Machine Learning Mastery 深度学习 NLP 教程（七）

原文：Machine Learning Mastery

协议：CC BY-NC-SA 4.0

如何使用 Keras 为深度学习准备文本数据

原文： machinelearningmastery.com/prepare-text-data-deep-learning-keras/

您无法直接将原始文本提供给深度学习模型。

文本数据必须编码为数字，以用作机器学习和深度学习模型的输入或输出。

Keras 深度学习库提供了一些基本工具来帮助您准备文本数据。

在本教程中，您将了解如何使用 Keras 准备文本数据。

完成本教程后，您将了解：

• 关于可用于快速准备文本数据的便捷方法。
• Tokenizer API，可以适用于训练数据，用于编码训练，验证和测试文档。
• Tokenizer API 提供的 4 种不同文档编码方案的范围。

让我们开始吧。

如何使用 Keras
为深度学习准备文本数据照片来自 ActiveSteve ，保留一些权利。

教程概述

本教程分为 4 个部分;他们是：

1. 用 text_to_word_sequence 分隔单词。
2. 用 one_hot 编码。
3. 使用 hashing_trick 进行哈希编码。
4. Tokenizer API

使用 text_to_word_sequence 分割单词

使用文本时，第一步是将其拆分为单词。

单词称为标记，将文本拆分为标记的过程称为分词。

Keras 提供 text_to_word_sequence（）函数，您可以使用它将文本拆分为单词列表。

默认情况下，此功能自动执行以下三项操作：

• 按空格拆分单词（split =“”）。
• 过滤掉标点符号（filters =‘！“＃$％＆amp;（）* +， - 。/：;＆lt; =＆gt;？@ [\] ^ _` {|}〜\ t \ n’）。
• 将文本转换为小写（lower = True）。

您可以通过将参数传递给函数来更改任何这些默认值。

下面是使用 text_to_word_sequence（）函数将文档（在本例中为简单字符串）拆分为单词列表的示例。

from keras.preprocessing.text import text_to_word_sequence
# define the document
text = 'The quick brown fox jumped over the lazy dog.'
# tokenize the document
result = text_to_word_sequence(text)
print(result)

运行该示例将创建一个包含文档中所有单词的数组。打印单词列表以供审阅。

['the', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy', 'dog']

这是一个很好的第一步，但在使用文本之前需要进一步的预处理。

用 one_hot 编码

将文档表示为整数值序列是很流行的，其中文档中的每个单词都表示为唯一的整数。

Keras 提供 one_hot（）函数，您可以使用它来一步对文本文档进行分词和整数编码。该名称表明它将创建文档的单热编码，但事实并非如此。

相反，该函数是下一节中描述的 hashing_trick（）函数的包装器。该函数返回文档的整数编码版本。散列函数的使用意味着可能存在冲突，并且不是所有单词都将被分配唯一的整数值。

与上一节中的 text_to_word_sequence（）函数一样，one_hot（）函数将使文本小写，过滤掉标点符号，并根据空格分割单词。

除文本外，还必须指定词汇量（总词数）。如果您打算编码包含其他单词的其他文档，则可以是文档中的单词总数或更多。词汇表的大小定义了散列单词的散列空间。理想情况下，这应该比词汇量大一些百分比（可能是 25％），以最大限度地减少碰撞次数。默认情况下，使用’hash’函数，虽然我们将在下一节中看到，但是在直接调用 hashing_trick（）函数时可以指定备用散列函数。

我们可以使用上一节中的 text_to_word_sequence（）函数将文档拆分为单词，然后使用集合仅表示文档中的唯一单词。该集的大小可用于估计一个文档的词汇表大小。

例如：

from keras.preprocessing.text import text_to_word_sequence
# define the document
text = 'The quick brown fox jumped over the lazy dog.'
# estimate the size of the vocabulary
words = set(text_to_word_sequence(text))
vocab_size = len(words)
print(vocab_size)

我们可以将它与 one_hot（）函数放在一起，并对文档中的单词进行热编码。下面列出了完整的示例。

词汇大小增加三分之一，以最大限度地减少散列词时的冲突。

from keras.preprocessing.text import one_hot
from keras.preprocessing.text import text_to_word_sequence
# define the document
text = 'The quick brown fox jumped over the lazy dog.'
# estimate the size of the vocabulary
words = set(text_to_word_sequence(text))
vocab_size = len(words)
print(vocab_size)
# integer encode the document
result = one_hot(text, round(vocab_size*1.3))
print(result)

首先运行该示例将词汇表的大小打印为 8.然后将编码的文档打印为整数编码的单词数组。

8
[5, 9, 8, 7, 9, 1, 5, 3, 8]

使用 hashing_trick 进行哈希编码

整数和计数基本编码的限制是它们必须保持单词的词汇表及其到整数的映射。

此方法的替代方法是使用单向散列函数将单词转换为整数。这避免了跟踪词汇表的需要，词汇表更快并且需要更少的内存。

Keras 提供了 hashing_trick（）函数，它分词然后对文档进行整数编码，就像 one_hot（）函数一样。它提供了更大的灵活性，允许您将散列函数指定为“散列”（默认）或其他散列函数，例如内置的 md5 函数或您自己的函数。

下面是使用 md5 哈希函数对文档进行整数编码的示例。

from keras.preprocessing.text import hashing_trick
from keras.preprocessing.text import text_to_word_sequence
# define the document
text = 'The quick brown fox jumped over the lazy dog.'
# estimate the size of the vocabulary
words = set(text_to_word_sequence(text))
vocab_size = len(words)
print(vocab_size)
# integer encode the document
result = hashing_trick(text, round(vocab_size*1.3), hash_function='md5')
print(result)

运行该示例将打印词汇表的大小和整数编码的文档。

我们可以看到，使用不同的散列函数会导致单词的一致但不同的整数作为上一节中的 one_hot（）函数。

8
[6, 4, 1, 2, 7, 5, 6, 2, 6]

Tokenizer API

到目前为止，我们已经研究了使用 Keras 准备文本的一次性便捷方法。

Keras 提供了更复杂的 API，用于准备可以适合和重用以准备多个文本文档的文本。这可能是大型项目的首选方法。

Keras 提供 Tokenizer 类，用于为深度学习准备文本文档。必须构造 Tokenizer，然后将其放在原始文本文档或整数编码的文本文档上。

例如：

from keras.preprocessing.text import Tokenizer
# define 5 documents
docs = ['Well done!',
		'Good work',
		'Great effort',
		'nice work',
		'Excellent!']
# create the tokenizer
t = Tokenizer()
# fit the tokenizer on the documents
t.fit_on_texts(docs)

适用后，Tokenizer 提供了 4 个属性，您可以使用这些属性查询有关文档的内容：

• word_counts ：单词及其计数字典。
• word_docs ：一个单词词典和每个出现的文档数量。
• word_index ：单词字典及其唯一分配的整数。
• document_count ：用于适合 Tokenizer 的文档总数的整数计数。

例如：

# summarize what was learned
print(t.word_counts)
print(t.document_count)
print(t.word_index)
print(t.word_docs)

一旦 Tokenizer 适合训练数据，它就可用于编码训练或测试数据集中的文档。

Tokenizer 上的 texts_to_matrix（）函数可用于为每个输入提供每个文档创建一个向量。向量的长度是词汇表的总大小。

此函数提供了一套标准的词袋模型文本编码方案，可以通过函数的模式参数提供。

可用的模式包括：

• ‘binary’：文档中是否存在每个单词。这是默认值。
• ‘count’：文档中每个单词的计数。
• ‘tfidf’：文本频率 - 反向文档频率（TF-IDF）对文档中每个单词的评分。
• ‘freq’：每个单词的频率，作为每个文档中单词的比例。

我们可以将所有这些与一个有效的例子放在一起。

from keras.preprocessing.text import Tokenizer
# define 5 documents
docs = ['Well done!',
		'Good work',
		'Great effort',
		'nice work',
		'Excellent!']
# create the tokenizer
t = Tokenizer()
# fit the tokenizer on the documents
t.fit_on_texts(docs)
# summarize what was learned
print(t.word_counts)
print(t.document_count)
print(t.word_index)
print(t.word_docs)
# integer encode documents
encoded_docs = t.texts_to_matrix(docs, mode='count')
print(encoded_docs)

运行该示例使 Tokenizer 与 5 个小文档相匹配。打印适合标记符的详细信息。然后使用字数对 5 个文档进行编码。

每个文档被编码为 9 元素向量，每个字具有一个位置，并且每个字位置具有所选择的编码方案值。在这种情况下，使用简单的字数计数模式。

OrderedDict([('well', 1), ('done', 1), ('good', 1), ('work', 2), ('great', 1), ('effort', 1), ('nice', 1), ('excellent', 1)])
5
{'work': 1, 'effort': 6, 'done': 3, 'great': 5, 'good': 4, 'excellent': 8, 'well': 2, 'nice': 7}
{'work': 2, 'effort': 1, 'done': 1, 'well': 1, 'good': 1, 'great': 1, 'excellent': 1, 'nice': 1}
[[ 0\.  0\.  1\.  1\.  0\.  0\.  0\.  0\.  0.]
 [ 0\.  1\.  0\.  0\.  1\.  0\.  0\.  0\.  0.]
 [ 0\.  0\.  0\.  0\.  0\.  1\.  1\.  0\.  0.]
 [ 0\.  1\.  0\.  0\.  0\.  0\.  0\.  1\.  0.]
 [ 0\.  0\.  0\.  0\.  0\.  0\.  0\.  0\.  1.]]

进一步阅读

如果您要深入了解，本节将提供有关该主题的更多资源。

• 文本预处理 Keras API
• text_to_word_sequence Keras API
• one_hot Keras API
• hashing_trick Keras API
• Tokenizer Keras API

摘要

在本教程中，您了解了如何使用 Keras API 为深度学习准备文本数据。

具体来说，你学到了：

• 关于可用于快速准备文本数据的便捷方法。
• Tokenizer API，可以适用于训练数据，用于编码训练，验证和测试文档。
• Tokenizer API 提供的 4 种不同文档编码方案的范围。

你有任何问题吗？
在下面的评论中提出您的问题，我会尽力回答。

如何使用 scikit-learn 为机器学习准备文本数据

原文： machinelearningmastery.com/prepare-text-data-machine-learning-scikit-learn/

文本数据需要特殊准备才能开始使用它做出预测性建模。

必须解析文本以删除称为分词的单词。然后，需要将单词编码为整数或浮点值，以用作机器学习算法的输入，称为特征提取（或向量化）。

scikit-learn 库提供易于使用的工具，可以执行文本数据的分词和特征提取。

在本教程中，您将了解如何使用 scikit-learn 在 Python 中为预测性建模准备文本数据。

完成本教程后，您将了解：

• 如何使用 CountVectorizer 将文本转换为字数统计向量。
• 如何使用 TfidfVectorizer 将文本转换为字频向量。
• 如何使用 HashingVectorizer 将文本转换为唯一的整数。

让我们开始吧。

如何使用 scikit-learn
照片由 Martin Kelly 为机器学习准备文本数据，保留一些权利。

词袋模型

使用机器学习算法时，我们无法直接使用文本。

相反，我们需要将文本转换为数字。

我们可能想要执行文档分类，因此每个文档都是“_ 输入 ”，类标签是我们的预测算法的“ 输出 _”。算法将数字向量作为输入，因此我们需要将文档转换为固定长度的数字向量。

在机器学习中思考文本文档的简单而有效的模型被称为 Bag-of-Words 模型，或 BoW。

该模型很简单，因为它抛弃了单词中的所有订单信息，并关注文档中单词的出现。

这可以通过为每个单词分配唯一编号来完成。然后，我们看到的任何文档都可以编码为具有已知单词词汇长度的固定长度向量。向量中每个位置的值可以用编码文档中每个单词的计数或频率填充。

这是单词模型的包，我们只关注编码方案，这些编码方案表示存在的单词或它们在编码文档中存在的程度，而没有关于顺序的任何信息。

有很多方法可以扩展这个简单的方法，既可以更好地阐明“_ 字 _”是什么，也可以定义对向量中每个字进行编码的内容。

scikit-learn 库提供了我们可以使用的 3 种不同方案，我们将简要介绍每种方案。

Word 计数与 CountVectorizer

CountVectorizer 提供了一种简单的方法，既可以标记文本文档的集合，也可以构建已知单词的词汇表，还可以使用该词汇表对新文档进行编码。

您可以按如下方式使用它：

1. 创建CountVectorizer类的实例。
2. 调用fit()函数以便从一个或多个文档中学习词汇。
3. 根据需要在一个或多个文档上调用transform()函数，将每个文档编码为向量。

返回的编码向量具有整个词汇表的长度，并且返回每个单词出现在文档中的次数的整数计数。

因为这些向量将包含许多零，所以我们将它们称为稀疏。 Python 提供了一种在 scipy.sparse 包中处理稀疏向量的有效方法。

从对 transform（）的调用返回的向量将是稀疏向量，您可以将它们转换回 numpy 数组，以通过调用 toarray（）函数来查看并更好地了解正在发生的事情。

下面是使用 CountVectorizer 进行标记，构建词汇表，然后对文档进行编码的示例。

from sklearn.feature_extraction.text import CountVectorizer
# list of text documents
text = ["The quick brown fox jumped over the lazy dog."]
# create the transform
vectorizer = CountVectorizer()
# tokenize and build vocab
vectorizer.fit(text)
# summarize
print(vectorizer.vocabulary_)
# encode document
vector = vectorizer.transform(text)
# summarize encoded vector
print(vector.shape)
print(type(vector))
print(vector.toarray())

在上面，您可以看到我们访问词汇表以查看通过调用标记的确切内容：

print(vectorizer.vocabulary_)

我们可以看到默认情况下所有单词都是小写的，并且忽略了标点符号。可以配置分词的这些和其他方面，我建议您查看 API 文档中的所有选项。

首先运行该示例打印词汇表，然后打印编码文档的形状。我们可以看到词汇中有 8 个单词，因此编码的向量长度为​​8。

然后我们可以看到编码的向量是稀疏矩阵。最后，我们可以看到编码向量的数组版本，显示除了出现 2 的（index 和 id 7）之外的每个单词的出现次数为 1。

{'dog': 1, 'fox': 2, 'over': 5, 'brown': 0, 'quick': 6, 'the': 7, 'lazy': 4, 'jumped': 3}
(1, 8)
<class 'scipy.sparse.csr.csr_matrix'>
[[1 1 1 1 1 1 1 2]]

重要的是，相同的向量化程序可用于包含词汇表中未包含的单词的文档。忽略这些单词，并且在结果向量中不给出计数。

例如，下面是使用上面的向量化器来编码文档中的一个单词和一个单词不是的单词的示例。

# encode another document
text2 = ["the puppy"]
vector = vectorizer.transform(text2)
print(vector.toarray())

运行此示例将打印编码稀疏向量的数组版本，显示词汇中一个单词出现一次，而词汇中未出现的另一个单词完全被忽略。

[[0 0 0 0 0 0 0 1]]

然后，编码的向量可以直接与机器学习算法一起使用。

使用 TfidfVectorizer 的单词频率

字数是一个很好的起点，但非常基本。

简单计数的一个问题是，诸如“”之类的单词会出现很多次，并且它们的大数量在编码向量中不会非常有意义。

另一种方法是计算单词频率，到目前为止，最流行的方法称为 TF-IDF 。这是“_ 术语频率 - 反向文档 _”频率的首字母缩写，它是分配给每个单词的结果分数的组成部分。

• 术语频率：总结了给定单词在文档中出现的频率。
• 反向文档频率：这缩小了文档中出现的很多单词。

在没有进入数学的情况下，TF-IDF 是单词频率分数，试图突出更有趣的单词，例如，在文档中频繁但不在文档中。

TfidfVectorizer 将对文档进行标记，学习词汇和逆文档频率权重，并允许您对新文档进行编码。或者，如果您已经学习了 CountVectorizer，则可以将其与 TfidfTransformer 一起使用，以计算逆文档频率并开始编码文档。

与 CountVectorizer 一样使用相同的创建，拟合和转换过程。

下面是使用 TfidfVectorizer 学习 3 个小文档中的词汇和逆文档频率然后编码其中一个文档的示例。

from sklearn.feature_extraction.text import TfidfVectorizer
# list of text documents
text = ["The quick brown fox jumped over the lazy dog.",
		"The dog.",
		"The fox"]
# create the transform
vectorizer = TfidfVectorizer()
# tokenize and build vocab
vectorizer.fit(text)
# summarize
print(vectorizer.vocabulary_)
print(vectorizer.idf_)
# encode document
vector = vectorizer.transform([text[0]])
# summarize encoded vector
print(vector.shape)
print(vector.toarray())

从文档中学习 8 个单词的词汇表，并且在输出向量中为每个单词分配唯一的整数索引。

针对词汇表中的每个单词计算逆文档频率，将最低得分 1.0 分配给最频繁观察的单词：“ _[指示 7 处的 _”。

最后，第一个文档被编码为 8 个元素的稀疏数组，我们可以查看每个单词的最终评分，其中包含“”，“fox”和“ _ 狗 _“来自词汇中的其他词汇。

{'fox': 2, 'lazy': 4, 'dog': 1, 'quick': 6, 'the': 7, 'over': 5, 'brown': 0, 'jumped': 3}
[ 1.69314718 1.28768207 1.28768207 1.69314718 1.69314718 1.69314718
1.69314718 1\. ]
(1, 8)
[[ 0.36388646 0.27674503 0.27674503 0.36388646 0.36388646 0.36388646
0.36388646 0.42983441]]

将得分归一化为 0 到 1 之间的值，然后可以将编码的文档向量直接用于大多数机器学习算法。

散列 HashingVectorizer

计数和频率可能非常有用，但这些方法的一个限制是词汇量可能变得非常大。

反过来，这将需要大的向量来编码文档并对内存施加大量要求并减慢算法速度。

一个聪明的解决方法是使用单向哈希值将它们转换为整数。聪明的部分是不需要词汇表，你可以选择任意长的固定长度向量。缺点是散列是单向函数，因此无法将编码转换回单词（这对于许多监督学习任务可能无关紧要）。

HashingVectorizer 类实现了这种方法，可用于一致地对单词进行哈希处理，然后根据需要对文档进行标记和编码。

下面的示例演示了用于编码单个文档的 HashingVectorizer。

选择任意固定长度的向量大小 20。这对应于散列函数的范围，其中小值（如 20）可能导致散列冲突。记得回到 compsci 类，我相信有一些启发式方法可以用来根据估计的词汇量来选择哈希长度和碰撞概率。

请注意，此向量化程序不需要调用以适应训练数据文档。相反，在实例化之后，它可以直接用于开始编码文档。

from sklearn.feature_extraction.text import HashingVectorizer
# list of text documents
text = ["The quick brown fox jumped over the lazy dog."]
# create the transform
vectorizer = HashingVectorizer(n_features=20)
# encode document
vector = vectorizer.transform(text)
# summarize encoded vector
print(vector.shape)
print(vector.toarray())

运行该示例将示例文档编码为 20 个元素的稀疏数组。

编码文档的值默认对应于标准化字数，范围为-1 到 1，但可以通过更改默认配置来使其成为简单的整数计数。

(1, 20)
[[ 0\.          0\.          0\.          0\.          0\.          0.33333333
   0\.         -0.33333333  0.33333333  0\.          0\.          0.33333333
   0\.          0\.          0\.         -0.33333333  0\.          0.
  -0.66666667  0\.        ]]

进一步阅读

如果您要深入了解，本节将提供有关该主题的更多资源。

自然语言处理

• 维基百科上的词袋模型
• 维基百科上的标记
• 维基百科上的 TF-IDF

scikit 学习

• 第 4.2 节。特征提取，scikit-learn 用户指南
• scikit-learn 特征提取 API
• 使用文本数据，scikit-learn Tutorial

类 API

• CountVectorizer scikit-learn API
• TfidfVectorizer scikit-learn API
• TfidfTransformer scikit-learn API
• HashingVectorizer scikit-learn API

摘要

在本教程中，您了解了如何使用 scikit-learn 为机器学习准备文本文档。

我们在这些示例中只是略微表面，我想强调这些类有许多配置细节来影响值得探索的文档的分词。

你有任何问题吗？
在下面的评论中提出您的问题，我会尽力回答。

自然语言处理神经网络模型入门

原文： machinelearningmastery.com/primer-neural-network-models-natural-language-processing/

深度学习对自然语言处理领域产生巨大影响。

但是，作为初学者，你从哪里开始？

深度学习和自然语言处理都是巨大的领域。每个领域需要关注的重点是什么？NLP 的哪些领域是深度学习影响最大的？

在这篇文章中，您将发现有关自然语言处理的深度学习的入门读物。

阅读这篇文章后，你会知道：

• 对自然语言处理领域影响最大的神经网络架构。
• 可以通过深度学习成功解决的自然语言处理任务的广泛视图。
• 密集词表示的重要性以及可用于学习它们的方法。

让我们开始吧。

自然语言处理的神经网络模型入门
照片由 faungg 的照片，保留一些权利。

概观

这篇文章分为 12 个部分，遵循论文的结构;他们是：

1. 关于论文（简介）
2. 神经网络架构
3. 特征表示
4. 前馈神经网络
5. 词嵌入
6. 神经网络训练
7. 级联和多任务学习
8. 结构化输出预测
9. 卷积层
10. 循环神经网络
11. 具体的 RNN 架构
12. 树木建模

我想给大家介绍一下本文的主要部分和风格，以及对该主题的高级介绍。

如果你想更深入，我强烈推荐完整阅读或最新书。

1.关于论文

该论文的标题是：“_ 自然语言处理神经网络模型入门 _”。

它是在 ArXiv 上免费提供，并且是 2015 年的最后日期。它是一份技术报告或教程而不是一篇论文，并提供了针对自然语言处理（NLP）的深度学习方法的全面介绍，供研究人员使用和学生。

本教程从自然语言处理研究的角度对神经网络模型进行了调查，试图通过神经技术使自然语言研究人员加快速度。

该入门书由 Yoav Goldberg 撰写，他是 NLP 领域的研究员，曾在 Google Research 担任研究科学家。 Yoav 最近引起了一些争议，但我不会反对他。

这是一份技术报告，大约 62 页，有大约 13 页的参考文献。

该论文非常适合初学者，原因有两个：

• 除了你对这个主题感兴趣而且你知道一点机器学习和/或自然语言处理之外，它对读者几乎没有什么假设。
• 它具有广泛的广度，涵盖了广泛的深度学习方法和自然语言问题。

在本教程中，我尝试为 NLP 从业者（以及新手）提供基本背景，行话，工具和方法，使他们能够理解神经网络模型背后的原理并将其应用于自己的工作中。 …它针对那些有兴趣采用现有的有用技术并以有用和创造性的方式应用于他们最喜欢的 NLP 问题的读者。

通常，使用语言学或自然语言处理的术语或命名法重新构建关键的深度学习方法，从而提供有用的桥梁。

最后，这本 2015 年的入门书已经变成 2017 年出版的一本书，名为“自然语言处理的神经网络方法”。

如果您喜欢这本入门书并希望深入了解，我强烈推荐 Yoav 的书。

2.神经网络架构

这个简短的部分介绍了不同类型的神经网络架构，并在后面的部分中进行了交叉引用。

完全连接的前馈神经网络是非线性学习器，在大多数情况下，无论在何处使用线性学习器，它都可以用作替代品。

共涵盖了 4 种类型的神经网络架构，重点介绍了每种架构的应用和参考示例：

• 完全连接的前馈神经网络，例如，多层感知机网络。
• 具有卷积和池化层的网络，例如，卷积神经网络。
• 循环神经网络，例如长期的短期记忆网络。
• 循环神经网络。

如果您只对特定网络类型的应用程序感兴趣并想直接阅读源文件，那么本节提供了一个很好的来源。

3.特征表示

本节重点介绍从稀疏到密集表示的转换，这些表示又可以与深度学习模型一起进行训练。

从稀疏输入线性模型转向基于神经网络的模型时，最大的跳跃可能是停止将每个特征表示为唯一维度（所谓的单热表示）并将其表示为密集向量。

提出了 NLP 分类系统的一般结构，总结如下：

1. 提取一组核心语言功能。
2. 检索每个向量的相应向量。
3. 组合特征向量。
4. 将组合的向量馈送到非线性分类器中。

这个公式的关键是密集而不是稀疏的特征向量和核心特征的使用而不是特征组合。

请注意，神经网络设置中的特征提取阶段仅涉及核心特征的提取。这与传统的基于线性模型的 NLP 系统形成对比，在该系统中，特征设计者不仅需要手动指定兴趣的核心特征，还需要手动指定它们之间的相互作用。

4.前馈神经网络

本节提供前馈人工神经网络的速成课程。

具有两个隐藏层的前馈神经网络，取自“用于自然语言处理的神经网络模型的入门”。

使用脑启发的隐喻和使用数学符号来呈现网络。涵盖了常见的神经网络主题，例如：

• 表示功率（例如通用近似）。
• 常见的非线性（例如传递函数）。
• 输出变换（例如 softmax）。
• 词嵌入（例如内置的学习密集表示）。
• 损失函数（例如铰链和对数损失）。

5. 词嵌入

单词嵌入表示的主题是自然语言处理中神经网络方法的关键。本节对主题进​​行了扩展，并列举了关键方法。

神经网络方法的主要组成部分是使用嵌入 - 将每个特征表示为低维空间中的向量

将审核以下单词嵌入主题：

• 随机初始化（例如，从均匀的随机向量开始）。
• 监督任务特定的预训练（例如转学习）。
• 无人监督的预训练（例如像 word2vec 和 GloVe 这样的统计方法）。
• 训练目标（例如，目标对结果向量的影响）。
• 上下文的选择（例如每个单词周围的单词的影响）。

神经词嵌入源于语言建模的世界，其中训练网络以基于先前词的序列预测下一个词

6.神经网络训练

这个较长的部分侧重于如何训练神经网络，为那些刚接触神经网络范例的人编写。

神经网络训练是通过尝试使用基于梯度的方法最小化训练集上的损失函数来完成的。

本节重点介绍随机梯度下降（以及像迷你批次这样的朋友）以及正规化等训练期间的重要主题。

有趣的是，提出了神经网络的计算图透视，为像 Theano 和 TensorFlow 这样的符号数值库提供了入门，这些库是实现深度学习模型的流行基础。

构建图形后，可以直接运行正向计算（计算计算结果）或反向计算（计算梯度）

7.级联和多任务学习

本节以上一节为基础，总结了用于跨多种语言任务学习的级联 NLP 模型和模型的工作。

模型级联：利用神经网络模型的计算图定义来利用中间表示（编码）来开发更复杂的模型。

例如，我们可以有一个前馈网络，用于根据单词的相邻单词和/或组成单词的字符来预测单词的词性。

多任务学习：相关的自然语言预测任务不相互馈送，但可以跨任务共享信息。

用于预测块边界，命名实体边界和句子中的下一个词的信息都依赖于一些共享的底层语法 - 语义表示

在神经网络的背景下描述了这两个先进概念，其允许在训练（错误的反向传播）和做出预测期间的模型或信息之间的连接。

8.结构化输出预测

本节涉及自然语言任务的示例，其中深度学习方法用于进行序列，树和图等结构化预测。

典型示例是序列标记（例如，词性标记）序列分段（分块，NER）和句法分析。

本节涵盖贪婪和基于搜索的结构化预测，重点关注后者。

预测自然语言结构的常用方法是基于搜索。

9.卷积层

本节提供了卷积神经网络（CNN）的速成课程及其对自然语言的影响。

值得注意的是，CNN 已被证明对分类 NLP 任务非常有效，例如情感分析，例如，学习在文本中寻找特定的子序列或结构以做出预测。

卷积神经网络被设计用于识别大结构中的指示性局部预测器，并将它们组合以产生结构的固定大小向量表示，捕获对于手头的预测任务最具信息性的这些局部方面。

10.循环神经网络

与前一节一样，本节重点介绍特定类型网络的使用及其在 NLP 中的作用和应用。在这种情况下，用于建模序列的循环神经网络（RNN）。

循环神经网络（RNN）允许在固定大小的向量中表示任意大小的结构化输入，同时关注输入的结构化属性。

鉴于 RNN 的普及，特别是 NLP 中的长期短期记忆（LSTM），这个较大的部分通过各种经常性的主题和模型来工作，包括：

• RNN 抽象（例如网络图中的循环连接）。
• RNN 训练（例如，通过时间反向传播）。
• 多层（堆叠）RNN（例如深度学习的“深层”部分）。
• BI-RNN（例如，提供序列作为输入向前和向后）。
• 用于表示栈的 RNN

时间花在 RNN 模型架构或架构元素上，具体如下：

• 接受器：完成输入序列后输出计算的损耗。
• 编码器：最终向量用作输入序列的编码。
• 传感器：为输入序列中的每个观察创建一个输出。
• 编解码器：输入序列在被解码为输出序列之前被编码为固定长度的向量。

11.具体的 RNN 架构

本节以前面的方式为基础，介绍了特定的 RNN 算法。

具体涉及的是：

• 简单的 RNN（SRNN）。
• 长短期记忆（LSTM）。
• 门控循环单元（GRU）。

12.树木建模

最后一节重点介绍一种更为复杂的网络，称为循环神经网络，用于学习模型树。

树木可以是句法树，话语树，甚至是树，代表句子各部分所表达的情感。我们可能希望基于特定树节点预测值，基于根节点预测值，或者将质量分数分配给完整树或树的一部分。

由于循环神经网络维持输入序列的状态，循环神经网络维持树中节点的状态。

循环神经网络的示例，取自“用于自然语言处理的神经网络模型的入门”。

进一步阅读

如果您要深入了解，本节将提供有关该主题的更多资源。

• 自然语言处理神经网络模型入门，2015
• 自然语言处理的神经网络方法，2017
• Yoav Goldberg 主页
• Yoav Goldberg 中等

摘要

在这篇文章中，您发现了自然语言处理的深度学习入门。

具体来说，你学到了：

• 对自然语言处理领域影响最大的神经网络架构。
• 可以通过深度学习成功解决自然语言处理任务的广泛视图。
• 密集词表示的重要性以及可用于学习它们的方法。

你有任何问题吗？
在下面的评论中提出您的问题，我会尽力回答。

用于自然语言处理的深度学习的承诺

原文： machinelearningmastery.com/promise-deep-learning-natural-language-processing/

在自然语言处理领域深度学习的承诺是模型的更好表现，这些模型可能需要更多数据但是训练和操作的语言专业知识更少。

围绕深度学习方法存在很多炒作和大量宣称，但除了炒作之外，深度学习方法在挑战性问题上实现了最先进的结果。特别是在自然语言处理方面。

在这篇文章中，您将发现深度学习方法对解决自然语言处理问题的具体承诺。

阅读这篇文章后，你会知道：

• 深度学习自然语言处理的承诺。
• 关于 NLP 深度学习的承诺，从业者和研究科学家必须说些什么。
• 自然语言处理的关键深度学习方法和应用。

让我们开始吧。

自然语言处理深度学习的承诺
D. Brandsma 的照片，保留一些权利。

深度学习的承诺

深度学习方法很受欢迎，主要是因为他们兑现了他们的承诺。

这并不是说该技术没有大肆宣传，而是炒作是基于非常真实的结果，这些结果正在通过计算机视觉和自然语言处理的一系列非常具有挑战性的人工智能问题得到证明。

深度学习的第一次大型演示是自然语言处理，特别是语音识别。最近在机器翻译。

在这篇文章中，我们将讨论自然语言处理领域深度学习方法的五个具体承诺。该领域的研究人员和从业人员最近强调了这一承诺，这些人可能比承诺的承诺更平均。

总之，它们是：

1. 直接替换模型的承诺。也就是说，深度学习方法可以放入现有的自然语言系统中作为可以实现相称或更好表现的替代模型。
2. 新 NLP 模型的承诺。也就是说，深度学习方法提供了新的建模方法的机会，以挑战自然语言问题，如序列到序列预测。
3. 特色学习的承诺。也就是说，深度学习方法可以从模型所需的自然语言中学习特征，而不是要求专家指定和提取特征。
4. 持续改进的承诺。也就是说，自然语言处理中的深度学习的表现基于实际结果，并且改进似乎在继续并且可能加速。
5. 端到端模型的承诺。也就是说，大型端到端深度学习模型可以适应自然语言问题，提供更通用，表现更好的方法。

我们现在将仔细研究每一个。

对于自然语言处理还有其他深度学习的承诺;这些只是我选择强调的 5 个。

您认为深度学习对自然语言处理的承诺是什么？
请在下面的评论中告诉我。

1.直接替换模型的承诺

自然语言处理中深度学习的第一个承诺是能够用能够学习和利用非线性关系的表现更好的模型替换现有的线性模型。

Yoav Goldberg 在 NLP 研究人员的神经网络入门中强调了深度学习方法取得了令人瞩目的成果。

最近，神经网络模型也开始应用于文本自然语言信号，同样具有非常有希望的结果。

• 自然语言处理神经网络模型入门，2015。

他继续强调这些方法易于使用，有时可用于批量替换现有的线性方法。

最近，该领域已经在通过密集输入从稀疏输入的这种线性模型转换到非线性神经网络模型方面取得了一些成功。虽然大多数神经网络技术易于应用，有时几乎是旧线性分类器的替代品，但在许多情况下存在强大的进入障碍。

• 自然语言处理神经网络模型入门，2015。

2.新 NLP 模型的承诺

另一个承诺是深度学习方法有助于开发全新的模型。

一个强有力的例子是使用能够在很长的序列上学习和调节输出的循环神经网络。该方法的不同之处在于它们允许从业者摆脱传统的建模假设，从而实现最先进的结果。

Yoav Goldberg 在其关于 NLP 深度学习的书中指出，复杂的神经网络模型（如循环神经网络）可以提供全新的 NLP 建模机会。

2014 年左右，该领域开始看到在密集输入上从稀疏输入的这种线性模型转换为非线性神经网络模型取得了一些成功。 …其他更先进，需要改变思维方式，并提供新的建模机会。特别是，基于循环神经网络（RNN）的一系列方法减轻了对序列模型中普遍存在的马尔可夫假设的依赖，允许条件在任意长序列上产生有效的特征提取器。这些进步带来了语言建模，自动机器翻译和其他应用的突破。

• 第 xvii 页，自然语言处理中的神经网络方法，2017。

3.特色学习的承诺

深度学习方法能够学习特征表示，而不是要求专家手动指定和提取自然语言的特征。

NLP 研究员克里斯·曼宁（Chris Manning）在自然语言处理深度学习课程的第一讲中强调了不同的观点。

他描述了手动定义的输入功能的局限性，其中机器学习在统计 NLP 中的先前应用确实证明了人类定义功能并且计算机几乎没有学习。

克里斯认为深度学习方法的承诺是自动特征学习。他强调，功能学习是自动的而不是手动的，易于适应而不是脆弱，并且可以持续自动地进行改进。

一般而言，我们手动设计的功能往往过于规范，不完整，需要很长时间进行设计和验证，并且只能在一天结束时达到一定的表现水平。学习的功能易于适应，快速训练，他们可以继续学习，以便他们达到我们以前能够达到的更好的表现水平。

• Chris Manning，第 1 讲| 2017 年深度学习自然语言处理（幻灯片，视频）。

4.持续改进的承诺

对 NLP 进行深度学习的另一个承诺是继续并在挑战性问题上迅速改进。

在关于 NLP 深度学习的初始讲座中，克里斯·曼宁继续描述深度学习方法因其工作而受到自然语言的欢迎。

深度学习对大多数人来说如此令人兴奋的真正原因是它一直在起作用。

• Chris Manning，第 1 讲| 2017 年深度学习自然语言处理（幻灯片，视频）。

他强调，最初的结果令人印象深刻，并且在演讲中取得的成果比过去 30 年中的任何其他方法都要好。

克里斯接着提到，这不仅是最先进的成果，而且还有改进的速度。

…在过去的 6 到 7 年里，刚刚完全令人惊叹的是，正是这种惊人的发展方式，深度学习方法一直在不断改进，并以惊人的速度变得更好。 …我实际上只是说这是史无前例的，因为看起来这个领域的进展速度非常快，因为它能够逐月推出更好的办法。

• Chris Manning，第 1 讲| 2017 年深度学习自然语言处理（幻灯片，视频）。

5.端到端模型的承诺

深度学习的最后一个承诺是开发和训练自然语言问题的端到端模型，而不是开发专门模型的管道。

除了这些模型的改进表现之外，这对于开发的速度和简单性都是期望的。

神经机器翻译，或简称 NMT，是指试图学习将一种语言翻译成另一种语言的大型神经网络。这是一项传统上由传统手工调整模型管道处理的任务，每个模型都需要专业知识。

Chris Manning 在斯坦福大学 NLP 深度学习课程的第 10 讲中描述了这一点。

神经机器翻译用于表示我们想要做的是建立一个大的神经网络，我们可以训练整个端到端的机器翻译过程并优化端到端。

…

这种从手工定制的分段模型向端到端序列到序列预测模型的转变一直是语音识别的趋势。这样做的系统被称为 NMT [神经机器翻译]系统。

• Chris Manning，第 10 讲：神经机器翻译和注意模型，2017 年。（幻灯片，视频）

这种趋向于端到端模型而非专用系统的流水线也是语音识别的趋势。

在斯坦福大学 NLP 课程中的语音识别演示中，现在在 Nvidia 的 NLP 研究员 Navdeep Jaitly 强调语音识别的每个组成部分都可以用神经网络代替。

自动语音识别流水线的大块是语音处理，声学模型，发音模型和语言模型。

问题是，每个子系统的属性和重要的错误是不同的。这促使需要开发一个神经网络来端到端地学习整个问题。

随着时间的推移，人们开始注意到如果我们使用神经网络，每个组件都可以做得更好。 …但是，仍然存在问题。每个组件都有神经网络，但每个组件中的错误都不同，因此它们可能无法很好地协同工作。因此，这是尝试进入一个过程的基本动机，在这个过程中，您将整个模型作为一个大模型进行训练。

• Navdeep Jaitly，第 12 讲：语音处理的端到端模型，2017 年深度学习的自然语言处理（幻灯片，视频）。

NLP 深度学习网络的类型

深度学习是一个很大的研究领域，并不是所有这些都与自然语言处理相关。

很容易陷入特定的优化方法或扩展到旨在提升表现的模型类型。

从高层次来看，深度学习有 5 种方法，在自然语言处理中应用最受关注。

他们是：

1. 嵌入层。
2. 多层感知机（MLP）。
3. 卷积神经网络（CNN）。
4. 循环神经网络（RNN）。
5. 循环神经网络（ReNN）。

NLP 中的问题类型

深度学习不会解决自然语言处理或人工智能问题。

迄今为止，深度学习方法已经在自然语言处理的更广泛的问题中进行了评估，并在一小部分上取得了成功，其中成功表明表现或能力达到或高于之前使用其他方法的可能性。

重要的是，那些深度学习方法取得最大成功的领域是一些面向最终用户，具有挑战性且可能更有趣的问题。

5 个例子包括：

• 词表示法和意思。
• 文本分类。
• 语言建模。
• 机器翻译。
• 语音识别。

进一步阅读

如果您要深入了解，本节将提供有关该主题的更多资源。

• 自然语言处理神经网络模型入门，2015。
• 自然语言处理中的神经网络方法，2017。
• Stanford CS224n：深度学习的自然语言处理，2017

摘要

在这篇文章中，您发现了深度学习神经网络对自然语言处理的承诺。

具体来说，你学到了：

• 深度学习自然语言处理的承诺。
• 关于 NLP 深度学习的承诺，从业者和研究科学家必须说些什么。
• 自然语言处理的关键深度学习方法和应用。

你有任何问题吗？
在下面的评论中提出您的问题，我会尽力回答。

使用 Python 和 Keras 的 LSTM 循环神经网络的序列分类

原文： machinelearningmastery.com/sequence-classification-lstm-recurrent-neural-networks-python-keras/

序列分类是一种预测性建模问题，您可以在空间或时间上获得一些输入序列，任务是预测序列的类别。

使这个问题困难的原因是序列的长度可以变化，由输入符号的非常大的词汇表组成，并且可能要求模型学习输入序列中的符号之间的长期上下文或依赖性。

在这篇文章中，您将了解如何使用 Keras 深度学习库为 Python 中的序列分类问题开发 LSTM 循环神经网络模型。

阅读这篇文章后你会知道：

• 如何为序列分类问题开发 LSTM 模型。
• 如何通过使用压差来减少 LSTM 模型中的过拟合。
• 如何将 LSTM 模型与擅长学习空间关系的卷积神经网络相结合。

让我们开始吧。

• 2016 年 10 月更新：更新了 Keras 1.1.0 和 TensorFlow 0.10.0 的示例。
• 2017 年 3 月更新：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。
• 更新 May / 2018 ：更新了使用最新 Keras API 的代码，感谢 jeremy rutman。

用 Keras
用 Python 中的 LSTM 循环神经网络进行序列分类 photophilde ，保留一些权利。

问题描述

我们将在本教程中用于演示序列学习的问题是 IMDB 电影评论情感分类问题。每个电影评论是一个可变的单词序列，每个电影评论的情感必须分类。

大型电影评论数据集（通常称为 IMDB 数据集）包含 25,000 个用于训练的高极电影评论（好或坏），并且再次用于测试。问题是确定给定的电影评论是否具有积极或消极的情感。

这些数据由斯坦福研究人员收集并用于 2011 年的论文，其中 50-50 的数据被用于训练和测试。准确度达到 88.89％。

Keras 提供对内置 IMDB 数据集的访问。 **imdb.load_data（）**函数允许您以准备好在神经网络和深度学习模型中使用的格式加载数据集。

单词已被整数替换，这些整数表示数据集中每个单词的有序频率。因此，每个评论中的句子由一系列整数组成。

单词嵌入

我们将每个电影评论映射到一个真正的向量域，这是一种处理文字的流行技术，称为文字嵌入。这是一种在高维空间中将单词编码为实值向量的技术，其中单词之间的意义相似性转换为向量空间中的接近度。

Keras 提供了一种方便的方法，可以将单词的正整数表示转换为嵌入层的单词嵌入。

我们将每个单词映射到 32 长度的实值向量上。我们还将对建模感兴趣的单词总数限制为 5000 个最常用的单词，其余为零。最后，每个评论中的序列长度（单词数量）各不相同，因此我们将每个评论限制为 500 个单词，截断长评论并用零值填充较短的评论。

现在我们已经定义了我们的问题以及如何准备和建模数据，我们已经准备好开发 LSTM 模型来对电影评论的情感进行分类。

用于序列分类的简单 LSTM

我们可以快速开发用于 IMDB 问题的小型 LSTM 并获得良好的准确率。

让我们首先导入此模型所需的类和函数，并将随机数生成器初始化为常量值，以确保我们可以轻松地重现结果。

import numpy
from keras.datasets import imdb
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.layers.embeddings import Embedding
from keras.preprocessing import sequence
# fix random seed for reproducibility
numpy.random.seed(7)

我们需要加载 IMDB 数据集。我们将数据集限制在前 5,000 个单词中。我们还将数据集拆分为 train（50％）和 test（50％）集。

# load the dataset but only keep the top n words, zero the rest
top_words = 5000
(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words)

接下来，我们需要截断并填充输入序列，以便它们具有相同的建模长度。模型将学习零值不携带信息，因此实际上序列在内容方面不是相同的长度，但是在 Keras 中执行计算需要相同的长度向量。

# truncate and pad input sequences
max_review_length = 500
X_train = sequence.pad_sequences(X_train, maxlen=max_review_length)
X_test = sequence.pad_sequences(X_test, maxlen=max_review_length)

我们现在可以定义，编译和拟合我们的 LSTM 模型。

第一层是嵌入层，它使用 32 个长度向量来表示每个单词。下一层是具有 100 个内存单元（智能神经元）的 LSTM 层。最后，因为这是一个分类问题，我们使用具有单个神经元和 S 形激活函数的密集输出层来对问题中的两个类（好的和坏的）进行 0 或 1 个预测。

因为它是二分类问题，所以使用对数丢失作为损失函数（Keras 中的 binary_crossentropy ）。使用有效的 ADAM 优化算法。该模型仅适用于 2 个时期，因为它很快就能解决问题。 64 个评论的大批量用于分隔重量更新。

# create the model
embedding_vecor_length = 32
model = Sequential()
model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length))
model.add(LSTM(100))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
print(model.summary())
model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=3, batch_size=64)

一旦适合，我们估计模型在看不见的评论上的表现。

# Final evaluation of the model
scores = model.evaluate(X_test, y_test, verbose=0)
print("Accuracy: %.2f%%" % (scores[1]*100))

为了完整性，以下是 IMDB 数据集上此 LSTM 网络的完整代码清单。

# LSTM for sequence classification in the IMDB dataset
import numpy
from keras.datasets import imdb
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.layers.embeddings import Embedding
from keras.preprocessing import sequence
# fix random seed for reproducibility
numpy.random.seed(7)
# load the dataset but only keep the top n words, zero the rest
top_words = 5000
(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words)
# truncate and pad input sequences
max_review_length = 500
X_train = sequence.pad_sequences(X_train, maxlen=max_review_length)
X_test = sequence.pad_sequences(X_test, maxlen=max_review_length)
# create the model
embedding_vecor_length = 32
model = Sequential()
model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length))
model.add(LSTM(100))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
print(model.summary())
model.fit(X_train, y_train, epochs=3, batch_size=64)
# Final evaluation of the model
scores = model.evaluate(X_test, y_test, verbose=0)
print("Accuracy: %.2f%%" % (scores[1]*100))

运行此示例将生成以下输出。

请注意，如果您使用的是 TensorFlow 后端，您可能会看到一些与“PoolAllocator”相关的警告消息，您现在可以忽略这些消息。

Epoch 1/3
16750/16750 [==============================] - 107s - loss: 0.5570 - acc: 0.7149
Epoch 2/3
16750/16750 [==============================] - 107s - loss: 0.3530 - acc: 0.8577
Epoch 3/3
16750/16750 [==============================] - 107s - loss: 0.2559 - acc: 0.9019
Accuracy: 86.79%

您可以看到，这种简单的 LSTM 几乎没有调整，可以在 IMDB 问题上获得最接近的最新结果。重要的是，这是一个模板，您可以使用该模板将 LSTM 网络应用于您自己的序列分类问题。

现在，让我们看一下这个简单模型的一些扩展，您可能也希望将这些扩展带给您自己的问题。

LSTM 用于带有 Dropout 的序列分类

像 LSTM 这样的循环神经网络通常具有过拟合的问题。

可以使用 Dropout Keras 层在层之间应用 Dropout。我们可以通过在 Embedding 和 LSTM 层以及 LSTM 和 Dense 输出层之间添加新的 Dropout 层来轻松完成此操作。例如：

model = Sequential()
model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length))
model.add(Dropout(0.2))
model.add(LSTM(100))
model.add(Dropout(0.2))
model.add(Dense(1, activation='sigmoid'))

上面添加了 Dropout 层的完整代码列表示例如下：

# LSTM with Dropout for sequence classification in the IMDB dataset
import numpy
from keras.datasets import imdb
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.layers import Dropout
from keras.layers.embeddings import Embedding
from keras.preprocessing import sequence
# fix random seed for reproducibility
numpy.random.seed(7)
# load the dataset but only keep the top n words, zero the rest
top_words = 5000
(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words)
# truncate and pad input sequences
max_review_length = 500
X_train = sequence.pad_sequences(X_train, maxlen=max_review_length)
X_test = sequence.pad_sequences(X_test, maxlen=max_review_length)
# create the model
embedding_vecor_length = 32
model = Sequential()
model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length))
model.add(Dropout(0.2))
model.add(LSTM(100))
model.add(Dropout(0.2))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
print(model.summary())
model.fit(X_train, y_train, epochs=3, batch_size=64)
# Final evaluation of the model
scores = model.evaluate(X_test, y_test, verbose=0)
print("Accuracy: %.2f%%" % (scores[1]*100))

运行此示例提供以下输出。

Epoch 1/3
16750/16750 [==============================] - 108s - loss: 0.5802 - acc: 0.6898
Epoch 2/3
16750/16750 [==============================] - 108s - loss: 0.4112 - acc: 0.8232
Epoch 3/3
16750/16750 [==============================] - 108s - loss: 0.3825 - acc: 0.8365
Accuracy: 85.56%

我们可以看到 dropout 对训练产生了预期的影响，收敛趋势略微缓慢，在这种情况下，最终的准确率较低。该模型可能会使用更多的训练时代，并可能获得更高的技能（试试看）。

或者，可以使用 LSTM 精确地和单独地将压差应用于存储器单元的输入和循环连接。

Keras 通过 LSTM 层上的参数提供此功能，丢失用于配置输入丢失， recurrent_dropout 用于配置重复丢失。例如，我们可以修改第一个示例，将 dropout 添加到输入和循环连接，如下所示：

model = Sequential()
model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length))
model.add(LSTM(100, dropout=0.2, recurrent_dropout=0.2))
model.add(Dense(1, activation='sigmoid'))

下面列出了具有更精确 LSTM 丢失的完整代码清单，以确保完整性。

# LSTM with dropout for sequence classification in the IMDB dataset
import numpy
from keras.datasets import imdb
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.layers.embeddings import Embedding
from keras.preprocessing import sequence
# fix random seed for reproducibility
numpy.random.seed(7)
# load the dataset but only keep the top n words, zero the rest
top_words = 5000
(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words)
# truncate and pad input sequences
max_review_length = 500
X_train = sequence.pad_sequences(X_train, maxlen=max_review_length)
X_test = sequence.pad_sequences(X_test, maxlen=max_review_length)
# create the model
embedding_vecor_length = 32
model = Sequential()
model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length))
model.add(LSTM(100, dropout=0.2, recurrent_dropout=0.2))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
print(model.summary())
model.fit(X_train, y_train, epochs=3, batch_size=64)
# Final evaluation of the model
scores = model.evaluate(X_test, y_test, verbose=0)
print("Accuracy: %.2f%%" % (scores[1]*100))

运行此示例提供以下输出。

Epoch 1/3
16750/16750 [==============================] - 112s - loss: 0.6623 - acc: 0.5935
Epoch 2/3
16750/16750 [==============================] - 113s - loss: 0.5159 - acc: 0.7484
Epoch 3/3
16750/16750 [==============================] - 113s - loss: 0.4502 - acc: 0.7981
Accuracy: 82.82%

我们可以看到，LSTM 特定的丢失对网络的收敛具有比逐层丢失更明显的影响。如上所述，时期的数量保持不变并且可以增加以查看模型的技能是否可以进一步提升。

Dropout 是一种强大的技术，用于对抗 LSTM 模型中的过拟合，并且尝试这两种方法是个好主意，但是您可以使用 Keras 中提供的特定于门的丢失来获得更好的结果。

用于序列分类的 LSTM 和卷积神经网络

卷积神经网络在学习输入数据的空间结构方面表现出色。

IMDB 评论数据确实在评论中的单词序列中具有一维空间结构，并且 CNN 可能能够针对良好和不良情感挑选不变特征。然后，可以通过 LSTM 层将该学习的空间特征学习为序列。

我们可以在嵌入层之后轻松添加一维 CNN 和最大池池，然后将合并的特征提供给 LSTM。我们可以使用一小组 32 个特征，滤波器长度为 3 小。池化层可以使用标准长度 2 来将特征映射大小减半。

例如，我们将按如下方式创建模型：

model = Sequential()
model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length))
model.add(Conv1D(filters=32, kernel_size=3, padding='same', activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(LSTM(100))
model.add(Dense(1, activation='sigmoid'))

下面列出了具有 CNN 和 LSTM 层的完整代码清单，以确保完整性。

# LSTM and CNN for sequence classification in the IMDB dataset
import numpy
from keras.datasets import imdb
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.layers.convolutional import Conv1D
from keras.layers.convolutional import MaxPooling1D
from keras.layers.embeddings import Embedding
from keras.preprocessing import sequence
# fix random seed for reproducibility
numpy.random.seed(7)
# load the dataset but only keep the top n words, zero the rest
top_words = 5000
(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words)
# truncate and pad input sequences
max_review_length = 500
X_train = sequence.pad_sequences(X_train, maxlen=max_review_length)
X_test = sequence.pad_sequences(X_test, maxlen=max_review_length)
# create the model
embedding_vecor_length = 32
model = Sequential()
model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length))
model.add(Conv1D(filters=32, kernel_size=3, padding='same', activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(LSTM(100))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
print(model.summary())
model.fit(X_train, y_train, epochs=3, batch_size=64)
# Final evaluation of the model
scores = model.evaluate(X_test, y_test, verbose=0)
print("Accuracy: %.2f%%" % (scores[1]*100))

运行此示例提供以下输出。

Epoch 1/3
16750/16750 [==============================] - 58s - loss: 0.5186 - acc: 0.7263
Epoch 2/3
16750/16750 [==============================] - 58s - loss: 0.2946 - acc: 0.8825
Epoch 3/3
16750/16750 [==============================] - 58s - loss: 0.2291 - acc: 0.9126
Accuracy: 86.36%

我们可以看到，我们获得了与第一个示例类似的结果，尽管权重更小，训练时间更短。

如果将此示例进一步扩展为使用 dropout，我希望可以实现更好的结果。

资源

如果您有兴趣深入了解序列预测或这个具体的例子，下面是一些资源。

• LSTM 的 Theano 教程应用于 IMDB 数据集
• 在 IMDB 数据集上使用 LSTM 和 CNN 和 LSTM 的 Keras 代码示例。
• 监督序列标记与循环神经网络，2012 年由 Alex Graves（和 PDF 预打印）出版。

摘要

在这篇文章中，您了解了如何为序列分类预测性建模问题开发 LSTM 网络模型。

具体来说，你学到了：

• 如何为 IMDB 电影评论情感分类问题开发一个简单的单层 LSTM 模型。
• 如何使用分层和 LSTM 特定的压差扩展 LSTM 模型以减少过拟合。
• 如何将卷积神经网络的空间结构学习特性与 LSTM 的序列学习相结合。

您对 LSTM 或此帖的序列分类有任何疑问吗？在评论中提出您的问题，我会尽力回答。

斯坦福自然语言处理深度学习课程评价

原文： machinelearningmastery.com/stanford-deep-learning-for-natural-language-processing-course/

自然语言处理（NLP）是机器学习的一个子领域，涉及理解语音和文本数据。

统计方法和统计机器学习在该领域占主导地位，并且最近深度学习方法已被证明在挑战语音识别和文本翻译等 NLP 问题方面非常有效。

在这篇文章中，您将发现有关深度学习方法的自然语言处理主题的斯坦福课程。

本课程是免费的，我鼓励您使用这个优秀的资源。

完成这篇文章后，你会知道：

• 本课程的目标和先决条件。
• 课程讲座细分以及如何访问幻灯片，笔记和视频。
• 如何充分利用这种材料。

让我们开始吧。

概观

这篇文章分为 5 部分;他们是：

1. 课程摘要
2. 先决条件
3. 讲座
4. 项目
5. 如何最好地使用这种材料

课程摘要

该课程由 Chris Manning 和 Richard Socher 教授。

Chris Manning 是至少两本关于自然语言处理的顶级教科书的作者：

• 统计自然语言处理基础
• 信息检索简介

Richard Socher 是 MetaMind 背后的人，也是 Salesforce 的首席科学家。

自然语言处理是研究处理语音和文本数据的计算方法。

目标：计算机处理或“理解”自然语言以执行有用的任务

自 20 世纪 90 年代以来，该领域一直专注于统计方法。最近，该领域正在转向深度学习方法，因为它们提供了明显改进的功能。

本课程的重点是用深度学习方法教授统计自然语言处理。从网站上的课程描述：

最近，深度学习方法在许多不同的 NLP 任务中获得了非常高的表现。这些模型通常可以使用单个端到端模型进行训练，而不需要传统的，针对任务的特征工程。

从斯坦福深度学习 NLP 课程探索深度学习的原因

课程目标

• 了解和使用有效的现代方法进行深度学习的能力
• 对人类语言的一些全局了解以及理解和产生它们的困难
• 了解和建立 NLP 中一些主要问题的系统的能力

斯坦福深度学习 NLP 课程的目标

本课程在斯坦福大学讲授，虽然课程中使用的讲座已被记录并公布，我们将专注于这些免费提供的材料。

先决条件

该课程假设一些数学和编程技巧。

然而，如果必要的技能生锈，则提供进修材料。

特别：

• 大学微积分
  • 线性代数综述
• 统计与概率
  • 概率审查
• 机器学习
  • 凸优化评论
  • 随机梯度下降评论
• Python 编程
  • Python 评论

代码示例在 Python 中，并使用 NumPy 和 TensorFlow Python 库。

讲座

每次讲授课程时，讲座和材料似乎都会有所改变。考虑到事情正在改变领域的速度，这并不奇怪。

在这里，我们将看一下 CS224n 2017 年冬季课程大纲以及公开发表的讲座。

我建议观看讲座的 YouTube 视频，并仅在需要时访问幻灯片，论文和进一步阅读课程提纲。

该课程分为以下 18 个讲座和一个评论：

• 第 1 讲：深度学习的自然语言处理
• 第 2 讲：单词向量表示：word2vec
• 第 3 讲：GloVe：Word 表示的全局向量
• 第 4 讲：词窗分类和神经网络
• 第 5 讲：反向传播和项目建议
• 第 6 讲：依赖性解析
• 第 7 讲：TensorFlow 简介
• 第 8 讲：循环神经网络和语言模型
• 第 9 讲：机器翻译和高级复现 LSTM 和 GRU
• 审查会议：中期审查
• 第 10 讲：神经机器翻译和注意模型
• 第 11 讲：门控复发单元和 NMT 的其他主题
• 第 12 讲：语音处理的端到端模型
• 第 13 讲：卷积神经网络
• 第 14 讲：树循环神经网络和选区解析
• 第 15 讲：共同决议
• 第 16 讲：用于问答的动态神经网络
• 第 17 讲：NLP 中的问题和 NLP 的可能架构
• 第 18 讲：解决 NLP 深度学习的局限性

我在 YouTube 上以双倍播放速度观看了所有内容，并在记笔记时打开了幻灯片。

项目

预计该课程的学生将完成作业。

您可能希望自己完成评估，以便通过讲座来测试您的知识。

你可以在这里看到作业： CS224n 作业

重要的是，学生必须使用深度学习自然语言处理问题提交最终项目报告。

如果您正在寻找如何测试新发现技能的想法，这些项目可以很有趣。

提交的学生报告目录可在此处获得：

• 2015 学生项目报告
• 2016 学生项目报告

如果您发现了一些很棒的报告，请在评论中发布您的发现。

如何最好地使用这种材料

本课程专为学生设计，目的是教授足够的 NLP 和深度学习理论，让学生开始开发自己的方法。

这可能不是你的目标。

您可能是开发人员。您可能只对使用 NLP 问题的深度学习工具感兴趣，以获得当前项目的结果。

事实上，这是我的大多数读者的情况。如果这听起来像你，我会提醒你在处理材料时要非常小心。

• 跳过数学。不要关注方法的工作原理。相反，请关注方法如何工作的摘要，并跳过方程的大部分。您可以随时回来加深理解，以获得更好的结果。
• 专注于流程。从讲座中学习，并将您可以在自己的项目中使用的过程组合在一起。这些方法是分段教授的，关于如何将它们实际联系在一起的信息很少。
• 工具不变量。我不建议您自己编写方法，甚至不建议使用讲座中演示的 TensorFlow。学习原理并使用像 Keras 这样的高效工具来实际实现项目中的方法。

对于从业者来说，这种材料中有很多金币，但你必须保持智慧，而不是落入“_ 我必须了解所有 _”陷阱。作为一名从业者，你的目标是非常不同的，你必须无情地坚持目标。

进一步阅读

如果您要深入了解，本节将提供有关该主题的更多资源。

• CS224d：自然语言处理的深度学习
• CS224n：深度学习的自然语言处理
• CS224n 教学大纲（2017 年冬季）
• CS224n 视频讲座（2017 年冬季）
• CS22d Sub-Reddit
• CS224d 学生项目报告（ 2015 ， 2016 ）
• CS224n 分配

较旧的相关材料

• CS 224N / Ling 284 - 自然语言处理
• 2015 CS224d 讲座（2016 年新讲座弃用）
• 2016 CS224D 讲座视频
• 深度学习自然语言处理（无魔法）2013

摘要

在这篇文章中，您发现了斯坦福自然语言处理深度学习课程。

具体来说，你学到了：

• 本课程的目标和先决条件。
• 课程讲座细分以及如何访问幻灯片，笔记和视频。
• 如何充分利用这种材料。

您是否完成了部分或全部课程材料？
请在下面的评论中告诉我。

统计语言建模和神经语言模型的简要介绍

原文： machinelearningmastery.com/statistical-language-modeling-and-neural-language-models/

语言建模是许多重要的自然语言处理任务的核心。

最近，基于神经网络的语言模型已证明比独立的经典方法和作为更具挑战性的自然语言处理任务的一部分更好的表现。

在这篇文章中，您将发现用于自然语言处理的语言建模。

阅读这篇文章后，你会知道：

• 为什么语言建模对于解决自然语言处理中的任务至关重要。
• 什么是语言模型以及使用它们的一些示例。
• 神经网络如何用于语言建模。

让我们开始吧。

统计语言建模和神经语言模型的简要介绍
照片由 Chris Sorge 拍摄，保留一些权利。

概观

这篇文章分为 3 部分;他们是：

1. 建模语言问题
2. 统计语言建模
3. 神经语言模型

1.建模语言问题

可以完全指定正式语言，如编程语言。

可以定义所有保留字，并且可以精确定义它们可以使用的有效方式。

我们不能用自然语言来做这件事。自然语言不是设计的;它们出现了，因此没有正式的规范。

可能存在部分语言和启发式的正式规则，但经常使用不确认的自然语言。自然语言涉及大量术语，可以用于引入各种歧义的方式，但其他人仍然可以理解。

此外，语言改变，单词用法改变：它是一个移动的目标。

然而，语言学家试图用正式的语法和结构来指定语言。它可以做到，但是非常困难，结果可能很脆弱。

指定语言模型的另一种方法是从示例中学习它。

2.统计语言建模

统计语言建模，或语言建模，简称 LM，是概率模型的开发，它能够预测序列中的下一个单词，给出前面的单词。

语言建模是将概率分配给语言中的句子的任务。 […]除了为每个单词序列分配概率之外，语言模型还指定给定单词（或单词序列）跟随单词序列的可能性的概率

• 第 105 页，自然语言处理中的神经网络方法，2017。

语言模型基于文本示例来学习单词出现的概率。更简单的模型可以查看短序列单词的上下文，而较大的模型可以在句子或段落的级别上工作。最常见的是，语言模型在单词级别上运行。

语言模型的概念本质上是概率性的。语言模型是对从某些词汇表中提取的字符串进行概率测量的函数。

• 第 238 页，信息检索简介，2008 年。

语言模型可以独立开发和使用，例如生成看似来自语料库的新文本序列。

语言建模是大量自然语言处理任务的根本问题。更实际地，语言模型用于需要语言理解的任务的更复杂模型的前端或后端。

…语言建模是机器翻译和自动语音识别等实际应用中的关键组成部分。[…]出于这些原因，语言建模在自然语言处理，人工智能和机器学习研究中发挥着核心作用。

• 第 105 页，自然语言处理中的神经网络方法，2017。

一个很好的例子是语音识别，其中音频数据被用作模型的输入，并且输出需要语言模型来解释输入信号并且识别已经识别的单词的上下文中的每个新单词。

语音识别主要涉及将语音信号转录为单词序列的问题。 […]从这个角度来看，假定语音是由语言模型生成的，该语言模型为所有单词串 w 提供独立于观察信号的 Pr（w）的估计[…]语音识别的目标是找到最可能的词序列给出观察到的声学信号。

• 第 205-206 页，牛津计算语言学手册，2005 年。

类似地，语言模型用于在许多类似的自然语言处理任务中生成文本，例如：

• 光学字符识别
• 手写识别。
• 机器翻译。
• 拼写纠正。
• 图像标题。
• 文本摘要
• 以及更多。

语言建模是确定一系列单词概率的艺术。这在许多领域都很有用，包括语音识别，光学字符识别，手写识别，机器翻译和拼写校正

• 语言建模的一点进展，2001。

开发更好的语言模型通常会使模型在预期的自然语言处理任务中表现更好。这是开发更好，更准确的语言模型的动力。

[语言模型]在传统的 NLP 任务中发挥了关键作用，例如语音识别，机器翻译或文本摘要。通常（尽管不总是），训练更好的语言模型可以改善下游任务的基本指标（例如语音识别的单词错误率，或翻译的 BLEU 得分），这使得训练更好的 LM 的任务本身就是有价值的。

• 探索语言建模的局限，2016。

3.神经语言模型

最近，神经网络在语言模型开发中的使用已变得非常流行，以至于它现在可能是首选方法。

在语言建模中使用神经网络通常称为神经语言建模，简称 NLM。

神经网络方法在独立语言模型上以及在语音识别和机器翻译等具有挑战性的任务中将模型合并到较大模型中时，比传统方法获得更好的结果。

提高表现的一个关键原因可能是该方法的推广能力。

非线性神经网络模型解决了传统语言模型的一些缺点：它们允许在越来越大的上下文大小上进行调整，只需参数数量的线性增加，它们减少了手动设计后退顺序的需要，并且它们支持跨不同上下文的泛化。

• 第 109 页，自然语言处理中的神经网络方法，2017。

具体地，采用单词嵌入，其使用实值向量来表示项目向量空间中的每个单词。这种基于其用法的单词的学习表示允许具有相似含义的单词具有相似的表示。

神经语言模型（NLM）通过将单词参数化为向量（单词嵌入）并将其用作神经网络的输入来解决 n-gram 数据稀疏性问题。参数作为训练过程的一部分进行学习。通过 NLM 获得的单词嵌入表现出在诱导向量空间中语义上接近的单词同样接近的性质。

• 字符感知神经语言模型，2015。

这种概括是经典统计语言模型中使用的表示不能轻易实现的。

在一个离散的单词 indice 空间中很难获得“真正的泛化”，因为单词索引之间没有明显的关系。

• 用于大词汇量连续语音识别的连接语言建模，2002。

此外，分布式表示方法允许嵌入表示随着词汇量的大小更好地缩放。每个单词具有一个离散表示的经典方法使用越来越大的单词词汇来对抗维度的诅咒，这导致更长和更稀疏的表示。

语言建模的神经网络方法可以使用以下三个模型属性来描述，这些属性取自“ A Neural Probabilistic Language Model ”，2003。

1. 将词汇表中的每个单词与分布式单词特征向量相关联。
2. 根据序列中这些单词的特征向量表示单词序列的联合概率函数。
3. 同时学习单词特征向量和概率函数的参数。

这表示一种相对简单的模型，其中表示和概率模型直接从原始文本数据一起学习。

最近，基于神经的方法已经开始，然后一直开始超越传统的统计方法。

我们提供了充分的实证证据，表明连接语言模型优于标准的 n-gram 技术，除了它们的高计算（训练）复杂性。

• 基于循环神经网络的语言模型，2010。

最初，前馈神经网络模型用于介绍该方法。

最近，循环神经网络以及具有长期记忆的网络（如长短期记忆网络或 LSTM）允许模型在比更简单的前馈网络更长的输入序列上学习相关的上下文。

[RNN 语言模型]提供了进一步的概括：不考虑前面几个单词，假设具有来自循环连接的输入的神经元代表短期记忆。该模型从数据中学习如何表示内存。虽然浅前馈神经网络（仅具有一个隐藏层的神经网络）只能聚类相似的词，但是循环神经网络（可以被认为是深层架构）可以执行类似历史的聚类。这允许例如具有可变长度的模式的有效表示。

• 循环神经网络语言模型的扩展，2011。

最近，研究人员一直在寻求这些语言模型的极限。在文章“探索语言建模的极限”中，评估大数据集上的语言模型，例如一百万字的语料库，作者发现基于 LSTM 的神经语言模型胜过经典方法。

…我们已经证明 RNN LMs 可以在大量数据上进行训练，并且优于竞争模型，包括精心调校的 N-gram。

• 探索语言建模的局限，2016。

此外，他们提出了一些启发式方法来开发一般的高表现神经语言模型：

• 尺寸很重要。最好的型号是最大的型号，特别是内存单元的数量。
• 正规化很重要。在输入连接上使用正规化（如丢失）可改善结果。
• CNNs 与嵌入。字符级卷积神经网络（CNN）模型可用于前端而不是字嵌入，从而实现类似且有时更好的结果。
• 合奏很重要。结合多个模型的预测可以大大提高模型表现。

进一步阅读

如果您要深入了解，本节将提供有关该主题的更多资源。

图书

• 第九章语言建模，自然语言处理中的神经网络方法，2017。
• 第二十二章，自然语言处理，人工智能现代方法，2009。
• 第十二章，信息检索的语言模型，信息检索简介，2008。

文件

• 神经概率语言模型，NIPS，2001。
• 神经概率语言模型，JMLR，2003。
• 用于大词汇量连续语音识别的连接语言建模，2002。
• 基于循环神经网络的语言模型，2010。
• 循环神经网络语言模型的扩展，2011。
• 字符感知神经语言模型，2015。
• 用于语言建模的 LSTM 神经网络，2012
• 探索语言建模的局限，2016。

用品

• 语言模型，维基百科
• 神经网络语言模型，Scholarpedia

摘要

在这篇文章中，您发现了自然语言处理任务的语言建模。

具体来说，你学到了：

• 这种自然语言没有正式指定，需要使用统计模型来学习实例。
• 统计语言模型是许多具有挑战性的自然语言处理任务的核心。
• 使用神经语言模型，特别是那些具有字嵌入和循环神经网络算法的模型，可以实现最先进的结果。

你有任何问题吗？
在下面的评论中提出您的问题，我会尽力回答。

使用 Python 和 Keras 的 LSTM 循环神经网络的文本生成

原文： machinelearningmastery.com/text-generation-lstm-recurrent-neural-networks-python-keras/

循环神经网络也可以用作生成模型。

这意味着除了用于预测模型（做出预测）之外，他们还可以学习问题的序列，然后为问题域生成全新的合理序列。

像这样的生成模型不仅可用于研究模型学习问题的程度，还可以了解有关问题领域本身的更多信息。

在这篇文章中，您将了解如何使用 Keras 中的 Python 中的 LSTM 循环神经网络逐个字符地创建文本的生成模型。

阅读这篇文章后你会知道：

• 在哪里下载免费的文本语料库，您可以使用它来训练文本生成模型。
• 如何将文本序列问题构建为循环神经网络生成模型。
• 如何开发 LSTM 以针对给定问题生成合理的文本序列。

让我们开始吧。

注意：LSTM 循环神经网络训练速度很慢，强烈建议您在 GPU 硬件上进行训练。您可以使用 Amazon Web Services 非常便宜地访问云中的 GPU 硬件，请参阅此处的教程。

• 2016 年 10 月更新：修复了代码中的一些小错误拼写错误。
• 2017 年 3 月更新：更新了 Keras 2.0.2，TensorFlow 1.0.1 和 Theano 0.9.0 的示例。

用 Keras
在 Python 中使用 LSTM 循环神经网络生成文本 Russ Sanderlin ，保留一些权利。

问题描述：古腾堡项目

许多经典文本不再受版权保护。

这意味着您可以免费下载这些书籍的所有文本，并在实验中使用它们，例如创建生成模型。也许获取不受版权保护的免费书籍的最佳地点是 Project Gutenberg 。

在本教程中，我们将使用童年时代最喜欢的书作为数据集：刘易斯卡罗尔的爱丽丝梦游仙境。

我们将学习字符之间的依赖关系和序列中字符的条件概率，这样我们就可以生成全新的原始字符序列。

这很有趣，我建议用 Project Gutenberg 的其他书重复这些实验，这里是网站上最受欢迎的书籍列表。

这些实验不仅限于文本，您还可以尝试其他 ASCII 数据，例如计算机源代码，LaTeX 中标记的文档，HTML 或 Markdown 等。

您可以免费下载本书的 ASCII 格式（纯文本 UTF-8）全文，并将其放在工作目录中，文件名为 wonderland.txt 。

现在我们需要准备好数据集以进行建模。

Project Gutenberg 为每本书添加了标准页眉和页脚，这不是原始文本的一部分。在文本编辑器中打开文件并删除页眉和页脚。

标题很明显，以文字结尾：

*** START OF THIS PROJECT GUTENBERG EBOOK ALICE'S ADVENTURES IN WONDERLAND ***

页脚是文本行后面的所有文本：

THE END

您应该留下一个包含大约 3,330 行文本的文本文件。

开发小型 LSTM 循环神经网络

在本节中，我们将开发一个简单的 LSTM 网络，以学习 Alice in Wonderland 中的角色序列。在下一节中，我们将使用此模型生成新的字符序列。

让我们首先导入我们打算用来训练模型的类和函数。

import numpy
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.layers import LSTM
from keras.callbacks import ModelCheckpoint
from keras.utils import np_utils

接下来，我们需要将书籍的 ASCII 文本加载到内存中，并将所有字符转换为小写，以减少网络必须学习的词汇量。

# load ascii text and covert to lowercase
filename = "wonderland.txt"
raw_text = open(filename).read()
raw_text = raw_text.lower()

既然本书已加载，我们必须准备数据以供神经网络建模。我们不能直接对字符进行建模，而是必须将字符转换为整数。

我们可以通过首先在书中创建一组所有不同的字符，然后创建每个字符到唯一整数的映射来轻松完成此操作。

# create mapping of unique chars to integers
chars = sorted(list(set(raw_text)))
char_to_int = dict((c, i) for i, c in enumerate(chars))

例如，书中唯一排序的小写字符列表如下：

['\n', '\r', ' ', '!', '"', "'", '(', ')', '*', ',', '-', '.', ':', ';', '?', '[', ']', '_', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '\xbb', '\xbf', '\xef']

您可以看到，我们可能会删除某些字符以进一步清理数据集，从而减少词汇量并可能改进建模过程。

现在已经加载了本书并准备了映射，我们可以总结数据集。

n_chars = len(raw_text)
n_vocab = len(chars)
print "Total Characters: ", n_chars
print "Total Vocab: ", n_vocab

将代码运行到此点会产生以下输出。

Total Characters:  147674
Total Vocab:  47

我们可以看到这本书的字符数不到 150,000，当转换为小写时，网络词汇表中只有 47 个不同的字符供网络学习。远远超过字母表中的 26。

我们现在需要定义网络的训练数据。在训练过程中，如何选择拆分文本并将其暴露给网络，有很多灵活性。

在本教程中，我们将书本文本拆分为子序列，其长度固定为 100 个字符，任意长度。我们可以轻松地按句子分割数据并填充较短的序列并截断较长的序列。

网络的每个训练模式由 100 个时间步长组成，一个字符（X）后跟一个字符输出（y）。在创建这些序列时，我们一次一个字符地沿着整本书滑动这个窗口，允许每个角色从它前面的 100 个字符中学习（当然前 100 个字符除外）。

例如，如果序列长度为 5（为简单起见），则前两个训练模式如下：

CHAPT -> E
HAPTE -> R

当我们将书分成这些序列时，我们使用我们之前准备的查找表将字符转换为整数。

# prepare the dataset of input to output pairs encoded as integers
seq_length = 100
dataX = []
dataY = []
for i in range(0, n_chars - seq_length, 1):
	seq_in = raw_text[i:i + seq_length]
	seq_out = raw_text[i + seq_length]
	dataX.append([char_to_int[char] for char in seq_in])
	dataY.append(char_to_int[seq_out])
n_patterns = len(dataX)
print "Total Patterns: ", n_patterns

运行代码到这一点向我们展示了当我们将数据集拆分为网络的训练数据时，我们知道我们只有不到 150,000 个训练模式。这有意义，因为排除前 100 个字符，我们有一个训练模式来预测每个剩余的字符。

Total Patterns:  147574

现在我们已经准备好了训练数据，我们需要对其进行转换，以便它适合与 Keras 一起使用。

首先，我们必须将输入序列列表转换为 LSTM 网络所期望的 [样本，时间步长，特征] 形式。

接下来，我们需要将整数重新缩放到 0 到 1 的范围，以使默认情况下使用 sigmoid 激活函数的 LSTM 网络更容易学习模式。

最后，我们需要将输出模式（转换为整数的单个字符）转换为单热编码。这样我们就可以配置网络来预测词汇表中 47 个不同字符中每个字符的概率（更容易表示），而不是试图强制它准确地预测下一个字符。每个 y 值都被转换为一个长度为 47 的稀疏向量，除了在模式所代表的字母（整数）的列中有 1 之外，它们都是零。

例如，当“n”（整数值 31）是单热编码时，它看起来如下：

[ 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.]

我们可以执行以下步骤。

# reshape X to be [samples, time steps, features]
X = numpy.reshape(dataX, (n_patterns, seq_length, 1))
# normalize
X = X / float(n_vocab)
# one hot encode the output variable
y = np_utils.to_categorical(dataY)

我们现在可以定义我们的 LSTM 模型。在这里，我们定义了一个具有 256 个内存单元的隐藏 LSTM 层。网络使用概率为 20 的丢失。输出层是密集层，使用 softmax 激活函数输出 0 和 1 之间的 47 个字符中的每一个的概率预测。

问题实际上是 47 个类的单个字符分类问题，因此被定义为优化日志损失（交叉熵），这里使用 ADAM 优化算法来提高速度。

# define the LSTM model
model = Sequential()
model.add(LSTM(256, input_shape=(X.shape[1], X.shape[2])))
model.add(Dropout(0.2))
model.add(Dense(y.shape[1], activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam')

没有测试数据集。我们正在对整个训练数据集进行建模，以了解序列中每个字符的概率。

我们对训练数据集的最准确（分类准确率）模型不感兴趣。这将是一个完美预测训练数据集中每个角色的模型。相反，我们感兴趣的是最小化所选损失函数的数据集的概括。我们正在寻求在泛化和过拟合之间取得平衡，但缺乏记忆。

网络训练缓慢（Nvidia K520 GPU 上每个迭代约 300 秒）。由于速度缓慢以及由于我们的优化要求，我们将使用模型检查点来记录每次在时期结束时观察到损失改善时的所有网络权重。我们将在下一节中使用最佳权重集（最低损失）来实例化我们的生成模型。

# define the checkpoint
filepath="weights-improvement-{epoch:02d}-{loss:.4f}.hdf5"
checkpoint = ModelCheckpoint(filepath, monitor='loss', verbose=1, save_best_only=True, mode='min')
callbacks_list = [checkpoint]

我们现在可以将模型与数据相匹配。在这里，我们使用适度数量的 20 个时期和 128 个模式的大批量大小。

model.fit(X, y, epochs=20, batch_size=128, callbacks=callbacks_list)

完整性代码清单如下所示。

# Small LSTM Network to Generate Text for Alice in Wonderland
import numpy
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.layers import LSTM
from keras.callbacks import ModelCheckpoint
from keras.utils import np_utils
# load ascii text and covert to lowercase
filename = "wonderland.txt"
raw_text = open(filename).read()
raw_text = raw_text.lower()
# create mapping of unique chars to integers
chars = sorted(list(set(raw_text)))
char_to_int = dict((c, i) for i, c in enumerate(chars))
# summarize the loaded data
n_chars = len(raw_text)
n_vocab = len(chars)
print "Total Characters: ", n_chars
print "Total Vocab: ", n_vocab
# prepare the dataset of input to output pairs encoded as integers
seq_length = 100
dataX = []
dataY = []
for i in range(0, n_chars - seq_length, 1):
	seq_in = raw_text[i:i + seq_length]
	seq_out = raw_text[i + seq_length]
	dataX.append([char_to_int[char] for char in seq_in])
	dataY.append(char_to_int[seq_out])
n_patterns = len(dataX)
print "Total Patterns: ", n_patterns
# reshape X to be [samples, time steps, features]
X = numpy.reshape(dataX, (n_patterns, seq_length, 1))
# normalize
X = X / float(n_vocab)
# one hot encode the output variable
y = np_utils.to_categorical(dataY)
# define the LSTM model
model = Sequential()
model.add(LSTM(256, input_shape=(X.shape[1], X.shape[2])))
model.add(Dropout(0.2))
model.add(Dense(y.shape[1], activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam')
# define the checkpoint
filepath="weights-improvement-{epoch:02d}-{loss:.4f}.hdf5"
checkpoint = ModelCheckpoint(filepath, monitor='loss', verbose=1, save_best_only=True, mode='min')
callbacks_list = [checkpoint]
# fit the model
model.fit(X, y, epochs=20, batch_size=128, callbacks=callbacks_list)

由于模型的随机性，您将看到不同的结果，并且因为很难为 LSTM 模型修复随机种子以获得 100％可重复的结果。这不是这个生成模型的关注点。

运行该示例后，您应该在本地目录中有许多权重检查点文件。

除了丢失值最小的那个之外，您可以删除它们。例如，当我运行这个例子时，下面是我实现的损失最小的检查点。

weights-improvement-19-1.9435.hdf5

网络损失几乎每个时代都在减少，我预计网络可以从更多时代的训练中受益。

在下一节中，我们将介绍如何使用此模型生成新的文本序列。

使用 LSTM 网络生成文本

使用经过训练的 LSTM 网络生成文本相对简单。

首先，我们以完全相同的方式加载数据并定义网络，除了从检查点文件加载网络权重并且不需要训练网络。

# load the network weights
filename = "weights-improvement-19-1.9435.hdf5"
model.load_weights(filename)
model.compile(loss='categorical_crossentropy', optimizer='adam')

此外，在准备将唯一字符映射到整数时，我们还必须创建一个反向映射，我们可以使用它将整数转换回字符，以便我们可以理解预测。

int_to_char = dict((i, c) for i, c in enumerate(chars))

最后，我们需要实际做出预测。

使用 Keras LSTM 模型做出预测的最简单方法是首先以种子序列作为输入开始，生成下一个字符然后更新种子序列以在末尾添加生成的字符并修剪第一个字符。只要我们想要预测新字符（例如，长度为 1,000 个字符的序列），就重复该过程。

我们可以选择随机输入模式作为种子序列，然后在生成它们时打印生成的字符。

# pick a random seed
start = numpy.random.randint(0, len(dataX)-1)
pattern = dataX[start]
print "Seed:"
print "\"", ''.join([int_to_char[value] for value in pattern]), "\""
# generate characters
for i in range(1000):
	x = numpy.reshape(pattern, (1, len(pattern), 1))
	x = x / float(n_vocab)
	prediction = model.predict(x, verbose=0)
	index = numpy.argmax(prediction)
	result = int_to_char[index]
	seq_in = [int_to_char[value] for value in pattern]
	sys.stdout.write(result)
	pattern.append(index)
	pattern = pattern[1:len(pattern)]
print "\nDone."

下面列出了使用加载的 LSTM 模型生成文本的完整代码示例，以确保完整性。

# Load LSTM network and generate text
import sys
import numpy
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.layers import LSTM
from keras.callbacks import ModelCheckpoint
from keras.utils import np_utils
# load ascii text and covert to lowercase
filename = "wonderland.txt"
raw_text = open(filename).read()
raw_text = raw_text.lower()
# create mapping of unique chars to integers, and a reverse mapping
chars = sorted(list(set(raw_text)))
char_to_int = dict((c, i) for i, c in enumerate(chars))
int_to_char = dict((i, c) for i, c in enumerate(chars))
# summarize the loaded data
n_chars = len(raw_text)
n_vocab = len(chars)
print "Total Characters: ", n_chars
print "Total Vocab: ", n_vocab
# prepare the dataset of input to output pairs encoded as integers
seq_length = 100
dataX = []
dataY = []
for i in range(0, n_chars - seq_length, 1):
	seq_in = raw_text[i:i + seq_length]
	seq_out = raw_text[i + seq_length]
	dataX.append([char_to_int[char] for char in seq_in])
	dataY.append(char_to_int[seq_out])
n_patterns = len(dataX)
print "Total Patterns: ", n_patterns
# reshape X to be [samples, time steps, features]
X = numpy.reshape(dataX, (n_patterns, seq_length, 1))
# normalize
X = X / float(n_vocab)
# one hot encode the output variable
y = np_utils.to_categorical(dataY)
# define the LSTM model
model = Sequential()
model.add(LSTM(256, input_shape=(X.shape[1], X.shape[2])))
model.add(Dropout(0.2))
model.add(Dense(y.shape[1], activation='softmax'))
# load the network weights
filename = "weights-improvement-19-1.9435.hdf5"
model.load_weights(filename)
model.compile(loss='categorical_crossentropy', optimizer='adam')
# pick a random seed
start = numpy.random.randint(0, len(dataX)-1)
pattern = dataX[start]
print "Seed:"
print "\"", ''.join([int_to_char[value] for value in pattern]), "\""
# generate characters
for i in range(1000):
	x = numpy.reshape(pattern, (1, len(pattern), 1))
	x = x / float(n_vocab)
	prediction = model.predict(x, verbose=0)
	index = numpy.argmax(prediction)
	result = int_to_char[index]
	seq_in = [int_to_char[value] for value in pattern]
	sys.stdout.write(result)
	pattern.append(index)
	pattern = pattern[1:len(pattern)]
print "\nDone."

运行此示例首先输出所选的随机种子，然后输出生成的每个字符。

例如，下面是此文本生成器的一次运行的结果。随机种子是：

be no mistake about it: it was neither more nor less than a pig, and she
felt that it would be quit

随机种子生成的文本（清理后用于演示）是：

be no mistake about it: it was neither more nor less than a pig, and she
felt that it would be quit e aelin that she was a little want oe toiet
ano a grtpersent to the tas a little war th tee the tase oa teettee
the had been tinhgtt a little toiee at the cadl in a long tuiee aedun
thet sheer was a little tare gereen to be a gentle of the tabdit  soenee
the gad  ouw ie the tay a tirt of toiet at the was a little 
anonersen, and thiu had been woite io a lott of tueh a tiie  and taede
bot her aeain  she cere thth the bene tith the tere bane to tee
toaete to tee the harter was a little tire the same oare cade an anl ano
the garee and the was so seat the was a little gareen and the sabdit,
and the white rabbit wese tilel an the caoe and the sabbit se teeteer,
and the white rabbit wese tilel an the cade in a lonk tfne the sabdi
ano aroing to tea the was sf teet whitg the was a little tane oo thete
the sabeit  she was a little tartig to the tar tf tee the tame of the
cagd, and the white rabbit was a little toiee to be anle tite thete ofs
and the tabdit was the wiite rabbit, and

我们可以注意到有关生成文本的一些观察。

• 它通常符合原始文本中观察到的行格式，在新行之前少于 80 个字符。
• 字符被分成单词组，大多数组是实际的英语单词（例如“the”，“little”和“was”），但许多组不是（例如“lott”，“tiie”和“taede”）。
• 顺序中的一些词是有意义的（例如“_ 和白兔 _”），但许多词没有（例如“ wese tilel ”）。

这本基于角色的本书模型产生这样的输出这一事实令人印象深刻。它让您了解 LSTM 网络的学习能力。

结果并不完美。在下一节中，我们将通过开发更大的 LSTM 网络来提高结果的质量。

更大的 LSTM 循环神经网络

我们得到了结果，但在上一节中没有出色的结果。现在，我们可以尝试通过创建更大的网络来提高生成文本的质量。

我们将内存单元的数量保持为 256，但添加第二层。

model = Sequential()
model.add(LSTM(256, input_shape=(X.shape[1], X.shape[2]), return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(256))
model.add(Dropout(0.2))
model.add(Dense(y.shape[1], activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam')

我们还将更改检查点权重的文件名，以便我们可以区分此网络和之前的权重（通过在文件名中附加“更大”一词）。

filepath="weights-improvement-{epoch:02d}-{loss:.4f}-bigger.hdf5"

最后，我们将训练时期的数量从 20 个增加到 50 个，并将批量大小从 128 个减少到 64 个，以便为网络提供更多的机会进行更新和学习。

完整代码清单如下所示。

# Larger LSTM Network to Generate Text for Alice in Wonderland
import numpy
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.layers import LSTM
from keras.callbacks import ModelCheckpoint
from keras.utils import np_utils
# load ascii text and covert to lowercase
filename = "wonderland.txt"
raw_text = open(filename).read()
raw_text = raw_text.lower()
# create mapping of unique chars to integers
chars = sorted(list(set(raw_text)))
char_to_int = dict((c, i) for i, c in enumerate(chars))
# summarize the loaded data
n_chars = len(raw_text)
n_vocab = len(chars)
print "Total Characters: ", n_chars
print "Total Vocab: ", n_vocab
# prepare the dataset of input to output pairs encoded as integers
seq_length = 100
dataX = []
dataY = []
for i in range(0, n_chars - seq_length, 1):
	seq_in = raw_text[i:i + seq_length]
	seq_out = raw_text[i + seq_length]
	dataX.append([char_to_int[char] for char in seq_in])
	dataY.append(char_to_int[seq_out])
n_patterns = len(dataX)
print "Total Patterns: ", n_patterns
# reshape X to be [samples, time steps, features]
X = numpy.reshape(dataX, (n_patterns, seq_length, 1))
# normalize
X = X / float(n_vocab)
# one hot encode the output variable
y = np_utils.to_categorical(dataY)
# define the LSTM model
model = Sequential()
model.add(LSTM(256, input_shape=(X.shape[1], X.shape[2]), return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(256))
model.add(Dropout(0.2))
model.add(Dense(y.shape[1], activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam')
# define the checkpoint
filepath="weights-improvement-{epoch:02d}-{loss:.4f}-bigger.hdf5"
checkpoint = ModelCheckpoint(filepath, monitor='loss', verbose=1, save_best_only=True, mode='min')
callbacks_list = [checkpoint]
# fit the model
model.fit(X, y, epochs=50, batch_size=64, callbacks=callbacks_list)

运行此示例需要一些时间，每个时期至少 700 秒。

运行此示例后，您可能会损失大约 1.2。例如，我通过运行此模型获得的最佳结果存储在一个名称为的检查点文件中：

weights-improvement-47-1.2219-bigger.hdf5

在 47 迭代实现亏损 1.2219。

与上一节一样，我们可以使用运行中的最佳模型来生成文本。

我们需要对上一节中的文本生成脚本进行的唯一更改是在网络拓扑的规范中以及从哪个文件中为网络权重设定种子。

完整性代码清单如下所示。

# Load Larger LSTM network and generate text
import sys
import numpy
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.layers import LSTM
from keras.callbacks import ModelCheckpoint
from keras.utils import np_utils
# load ascii text and covert to lowercase
filename = "wonderland.txt"
raw_text = open(filename).read()
raw_text = raw_text.lower()
# create mapping of unique chars to integers, and a reverse mapping
chars = sorted(list(set(raw_text)))
char_to_int = dict((c, i) for i, c in enumerate(chars))
int_to_char = dict((i, c) for i, c in enumerate(chars))
# summarize the loaded data
n_chars = len(raw_text)
n_vocab = len(chars)
print "Total Characters: ", n_chars
print "Total Vocab: ", n_vocab
# prepare the dataset of input to output pairs encoded as integers
seq_length = 100
dataX = []
dataY = []
for i in range(0, n_chars - seq_length, 1):
	seq_in = raw_text[i:i + seq_length]
	seq_out = raw_text[i + seq_length]
	dataX.append([char_to_int[char] for char in seq_in])
	dataY.append(char_to_int[seq_out])
n_patterns = len(dataX)
print "Total Patterns: ", n_patterns
# reshape X to be [samples, time steps, features]
X = numpy.reshape(dataX, (n_patterns, seq_length, 1))
# normalize
X = X / float(n_vocab)
# one hot encode the output variable
y = np_utils.to_categorical(dataY)
# define the LSTM model
model = Sequential()
model.add(LSTM(256, input_shape=(X.shape[1], X.shape[2]), return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(256))
model.add(Dropout(0.2))
model.add(Dense(y.shape[1], activation='softmax'))
# load the network weights
filename = "weights-improvement-47-1.2219-bigger.hdf5"
model.load_weights(filename)
model.compile(loss='categorical_crossentropy', optimizer='adam')
# pick a random seed
start = numpy.random.randint(0, len(dataX)-1)
pattern = dataX[start]
print "Seed:"
print "\"", ''.join([int_to_char[value] for value in pattern]), "\""
# generate characters
for i in range(1000):
	x = numpy.reshape(pattern, (1, len(pattern), 1))
	x = x / float(n_vocab)
	prediction = model.predict(x, verbose=0)
	index = numpy.argmax(prediction)
	result = int_to_char[index]
	seq_in = [int_to_char[value] for value in pattern]
	sys.stdout.write(result)
	pattern.append(index)
	pattern = pattern[1:len(pattern)]
print "\nDone."

运行此文本生成脚本的一个示例生成下面的输出。

随机选择的种子文本是：

d herself lying on the bank, with her
head in the lap of her sister, who was gently brushing away s

生成的文本与种子（清理用于演示）是：

herself lying on the bank, with her
head in the lap of her sister, who was gently brushing away
so siee, and she sabbit said to herself and the sabbit said to herself and the sood
way of the was a little that she was a little lad good to the garden,
and the sood of the mock turtle said to herself, 'it was a little that
the mock turtle said to see it said to sea it said to sea it say it
the marge hard sat hn a little that she was so sereated to herself, and
she sabbit said to herself, 'it was a little little shated of the sooe
of the coomouse it was a little lad good to the little gooder head. and
said to herself, 'it was a little little shated of the mouse of the
good of the courte, and it was a little little shated in a little that
the was a little little shated of the thmee said to see it was a little
book of the was a little that she was so sereated to hare a little the
began sitee of the was of the was a little that she was so seally and
the sabbit was a little lad good to the little gooder head of the gad
seared to see it was a little lad good to the little good

我们可以看到，通常拼写错误较少，文本看起来更逼真，但仍然是非常荒谬的。

例如，相同的短语一次又一次地重复，例如“_ 对自己说 ”和“ 少 _”。行情已经开启但尚未平仓。

这些都是更好的结果，但仍有很大的改进空间。

改进模型的 10 个扩展思路

以下是可以进一步改进您可以尝试的模型的 10 个想法：

• 预测少于 1,000 个字符作为给定种子的输出。
• 从源文本中删除所有标点符号，从而从模型的词汇表中删除。
• 尝试对输入序列进行热编码。
• 在填充句子而不是随机字符序列上训练模型。
• 将训练时期的数量增加到 100 或数百。
• 将 dropout 添加到可见输入层并考虑调整丢失百分比。
• 调整批量大小，尝试批量大小为 1 作为（非常慢）基线，并从那里开始更大的尺寸。
• 向层和/或更多层添加更多内存单元。
• 在解释预测概率时，对比例因子（温度）进行实验。
• 将 LSTM 层更改为“有状态”以维护批次之间的状态。

你尝试过这些扩展吗？在评论中分享您的结果。

资源

该字符文本模型是使用循环神经网络生成文本的流行方式。

如果您有兴趣深入了解，下面是一些关于该主题的更多资源和教程。也许最受欢迎的是 Andrej Karpathy 的教程，题为“循环神经网络的不合理效力”。

• 使用循环神经网络生成文本 [pdf]，2011
• 用于文本生成的 LSTM 的 Keras 代码示例。
• 用于文本生成的 LSTM 的烤宽面条代码示例。
• MXNet 教程，用于使用 LSTM 进行文本生成。
• 使用循环神经网络自动生成 Clickbait。

摘要

在这篇文章中，您了解了如何使用 Keras 深度学习库开发用于 Python 文本生成的 LSTM 循环神经网络。

阅读这篇文章后你知道：

• 在哪里可以免费下载经典书籍的 ASCII 文本，以便进行训练。
• 如何在文本序列上训练 LSTM 网络以及如何使用训练有素的网络生成新序列。
• 如何开发栈式 LSTM 网络并提升模型的表现。

您对 LSTM 网络或此帖子的文本生成有任何疑问吗？在下面的评论中提出您的问题，我会尽力回答。

浅谈机器学习中的转导

原文： machinelearningmastery.com/transduction-in-machine-learning/

转导或转导学习是您在应用机器学习中可能遇到的术语。

该术语与循环神经网络的一些应用一起用于序列预测问题，如自然语言处理领域中的一些问题。

在这篇文章中，您将了解机器学习中的转导。

阅读这篇文章后，你会知道：

• 转导的定义一般和某些特定的研究领域。
• 机器学习中的转导学习是什么。
• 在谈论序列预测问题时，什么转导意味着什么。

让我们开始吧。

概观

本教程分为 4 个部分;他们是：

1. 什么是转导？
2. 转化学习
3. 语言学中的转导
4. 序列预测中的转导

什么是转导？

让我们从一些基本的字典定义开始。

转导手段将某些东西转导成另一种形式。

转导：将（诸如能量或信息之类的东西）转导成另一种形式，基本上感觉器官将物理能量转导成神经信号

• Merriam-Webster Dictionary （在线），2017

它是电子和信号处理领域的一个流行术语，其中“_ 传感器 _”是将声音转导为能量或反之亦然的组件或模块的通用名称。

所有信号处理都以输入传感器开始。输入传感器接收输入信号并将其转导为电信号。在信号处理应用中，换能器可以采用多种形式。输入变换器的常见示例是麦克风。

• 数字信号处理揭秘，1997

在生物学，特别是遗传学中，转导是指将遗传物质转移到另一种微生物的微生物的过程。

转导：转导的作用或过程;特别是：通过病毒剂（如噬菌体）将遗传物质从一种微生物转移到另一种微生物

• Merriam-Webster Dictionary （在线），2017

因此，通常，我们可以看到转导是关于将信号转导为另一种形式。

信号处理描述是最突出的，其中声波被转导成电能以供系统内的某些使用。在一些选定的采样水平下，每个声音将由一些电子签名表示。

信号处理传感器示例

转化学习

在统计学习理论领域中使用转导或转导学习来指代给出来自域的特定实例的具体实例。

它与其他类型的学习形成对比，例如归纳学习和演绎学习。

归纳，从给定数据中导出函数。扣除，导出关注点的给定函数的值。转导，从给定数据导出兴趣点的未知函数的值。

• 第 169 页，统计学习理论的性质，1995

从统计学习理论的本质看诱导，演绎和转导
的关系。

这是一个有趣的监督学习框架，其中“_ 近似于数据的映射函数并使用它来做出预测 _”的经典问题被认为比所需要的更困难。相反，直接从域中的实际样本进行特定预测。不需要函数逼近。

估计给定兴趣点处的函数值的模型描述了推理的新概念：从特定到特定的移动。我们将这种类型的推理转导推断称为。请注意，当想要从有限数量的信息中获得最佳结果时，会出现这种推理概念。

• 第 169 页，统计学习理论的性质，1995

转导算法的经典示例是 K 最近邻 算法，其不对训练数据建模，而是在每次需要预测时直接使用它。

转导自然与一组称为基于实例或基于案例的学习的算法相关。也许，这类中最着名的算法是 k-最近邻算法。

• 通过转导学习，1998 年

语言学中的转导

传统上，在谈论自然语言时，例如在语言学领域，已经使用了转导。

例如，存在“_ 转导语法 _”的概念，其指的是用于将一种语言的示例转导成另一种语言的一组规则。

转导语法描述了结构上相关的一对语言。它生成句子对，而不是句子。语言 1 句子（意图是）语言-2 句子的翻译。

• 第 460 页，自然语言处理手册，2000。

还有来自计算理论的“有限状态传感器”（FST）的概念，在讨论用于将一组符号映射到另一组符号的翻译任务时调用。重要的是，每个输入产生一个输出。

有限状态传感器由许多状态组成。当在状态之间转导时，消耗输入符号并发出输出符号。

• 第 294 页，统计机器翻译，2010。

在谈论理论和经典机器翻译时这种转导的使用在谈论现代序列预测与自然语言处理任务中的循环神经网络时使用该术语。

序列预测中的转导

在他的语言处理神经网络教科书中，Yoav Goldberg 将传感器定义为 NLP 任务的特定网络模型。

换能器被狭义地定义为为所提供的每个输入时间步长输出一个时间步长的模型。这映射到语言用法，特别是有限状态传感器。

另一种选择是将 RNN 视为换能器，为其读入的每个输入产生输出。

• 第 168 页，自然语言处理中的神经网络方法，2017。

他提出了这种类型的序列标记模型以及语言建模。他接着指出，例如使用编解码器架构的条件生成可以被认为是 RNN 换能器的特殊情况。

考虑到编解码器模型架构中的解码器允许给定输入序列的不同数量的输出，在定义中打破“每个输入一个输出”，这最后一点是令人惊讶的。

传感器 RNN 训练图。
取自“自然语言处理中的神经网络方法”。

更一般地，转导用于 NLP 序列预测任务，特别是翻译。这些定义似乎比 Goldberg 和 FST 严格的每输入输出更宽松。

例如，Ed Grefenstette，et al。将转导描述为将输入字符串映射到输出字符串。

许多自然语言处理（NLP）任务可以被视为转导问题，即学习将一个字符串转导为另一个字符串。机器翻译是转导的典型示例，最近的结果表明 Deep RNN 能够编码长源字符串并产生连贯的翻译

• 学习无限记忆的转导，2015。

他们继续提供一些特定的 NLP 任务列表，这些任务有助于使这个广泛的定义具体化。

字符串转导是 NLP 中许多应用的核心，从名称音译和拼写校正到屈折形态和机器翻译

Alex Graves 还使用转导作为转导的同义词，并且有用地还提供了符合定义的示例 NLP 任务列表。

许多机器学习任务可以表示为输入序列到输出序列的转导或转导：语音识别，机器翻译，蛋白质二级结构预测和文本到语音等等。

• 序列转导与循环神经网络，2012。

总而言之，我们可以重新列出一系列转导自然语言处理任务，如下所示：

• 音译，以源形式给出示例，以目标形式产生单词。
• 拼写纠正，在给出错误的单词拼写时生成正确的单词拼写。
• 屈折形态学，根据源序列和背景产生新的序列。
• 机器翻译，在源语言中给出示例，以目标语言生成单词序列。
• 语音识别，产生给定音频序列的文本序列。
• 蛋白质二级结构预测，预测给定氨基酸输入序列（非 NLP）的 3D 结构。
• 文本到语音，或语音合成，产生给定文本序列的音频。

最后，除了涉及广泛类别的 NLP 问题和 RNN 序列预测模型的转导概念之外，一些新方法明确地被命名为这样。 Navdeep Jaitly 等人。将他们新的 RNN 序列到序列预测方法称为“_ 神经传感器 _”，技术上用于序列到序列预测的 RNN 也是如此。

我们提出了一种神经传感器，一种更通用的序列到序列学习模型。当输入块到达时，神经传感器可以产生大块的输出（可能是零长度），从而满足“在线”的条件。该模型通过使用实现序列到序列模型的换能器 RNN 为每个块生成输出。

• 神经传感器，2016

进一步阅读

如果您要深入了解，本节将提供有关该主题的更多资源。

定义

• Merriam-Webster 字典定义转导
• 数字信号处理揭秘，1997
• 维基百科上遗传学的转录

学习理论

• 统计学习理论的性质，1995
• 通过转导学习，1998
• 维基百科上的转导（机器学习）

语言学

• 自然语言处理手册，2000。
• 维基百科上的有限状态传感器
• 统计机器翻译，2010。

序列预测

• 自然语言处理中的神经网络方法，2017。
• 学习无限记忆的转导，2015。
• 序列转导与循环神经网络，2012。
• 神经传感器，2016

摘要

在这篇文章中，您发现了应用机器学习中的转导。

具体来说，你学到了：

• 转导的定义一般和某些特定的研究领域。
• 机器学习中的转导学习是什么。
• 在谈论序列预测问题时，什么转导意味着什么。

你有任何问题吗？
在下面的评论中提出您的问题，我会尽力回答。