Machine Learning Mastery 深度学习 NLP 教程（一）-CSDN博客

原文：Machine Learning Mastery

协议：CC BY-NC-SA 4.0

深度学习在自然语言处理中的 7 个应用

原文： machinelearningmastery.com/applications-of-deep-learning-for-natural-language-processing/

自然语言处理领域正在从统计方法转向神经网络方法。

在自然语言中仍有许多具有挑战性的问题需要解决。然而，深度学习方法正在某些特定语言问题上取得最新成果。

在最基本的问题上，最有趣的不仅仅是深度学习模型的表现;事实上，单个模型可以学习单词意义并执行语言任务，从而无需使用专门的手工制作方法。

在这篇文章中，您将发现 7 种有趣的自然语言处理任务，其中深度学习方法正在取得一些进展。

让我们开始吧。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

7 深度学习在自然语言处理中的应用
Tim Gorman 的照片，保留一些权利。

概观

在这篇文章中，我们将看看以下 7 种自然语言处理问题。

文本分类
语言建模
语音识别
标题生成
机器翻译
文件摘要
问题回答

我试图关注你可能感兴趣的最终用户问题的类型，而不是更深入学习的学术或语言子问题，如词性标注，分块，命名实体识别，等等。

每个示例都提供了问题的描述，示例以及对演示方法和结果的论文的引用。大多数参考文献都来自 Goldberg 2015 年优秀的 NLP 研究人员深度学习入门。

您是否有未列出的最喜欢的深度学习 NLP 应用程序？
请在下面的评论中告诉我。

1.文本分类

给定文本示例，预测预定义的类标签。

文本分类的目标是对文档的主题或主题进行分类。

第 575 页，统计自然语言处理基础，1999。

一个流行的分类示例是情感分析，其中类标签表示源文本的情感基调，例如“_ 阳性 ”或“ 阴性 _”。

以下是另外 3 个例子：

垃圾邮件过滤，将电子邮件文本分类为垃圾邮件。
语言识别，对源文本的语言进行分类。
流派分类，对虚构故事的类型进行分类。

此外，该问题可以以需要分配给文本的多个类的方式构成，即所谓的多标签分类。例如预测源推文的多个主题标签。

有关一般主题的更多信息，请参阅：

以下是用于文本分类的深度学习论文的 3 个示例：

腐烂番茄电影评论的情感分析。
- 深度无序构成对象文本分类的句法方法，2015。
亚马逊产品评论的情感分析，IMDB 电影评论和新闻文章的主题分类。
- 利用卷积神经网络有效使用词序进行文本分类，2015。
电影评论的情感分析，将句子分类为主观或客观，分类问题类型，产品评论情感等。
- 用于句子分类的卷积神经网络，2014。

2.语言建模

语言建模实际上是更有趣的自然语言问题的子任务，特别是那些在其他输入上调整语言模型的问题。

…问题是预测下一个词给出的前一个词。该任务是语音或光学字符识别的基础，也用于拼写校正，手写识别和统计机器翻译。

第 191 页，统计自然语言处理基础，1999。

除了对语言建模的学术兴趣之外，它还是许多深度学习自然语言处理架构的关键组成部分。

语言模型学习单词之间的概率关系，使得可以生成与源文本在统计上一致的新的单词序列。

单独的语言模型可用于文本或语音生成;例如：

生成新文章标题。
生成新的句子，段落或文档。
生成建议的句子延续。

有关语言建模的更多信息，请参阅：

维基百科上的语言模型
循环神经网络的不合理有效性，2015 年。
基于生成模型的文本到语音合成，第 10 讲，牛津，2017

以下是语言建模的深度学习示例（仅限）：

英语文本，书籍和新闻文章的语言模型。
- 神经概率语言模型，2003

3.语音识别

语音识别是理解所说内容的问题。

语音识别的任务是将包含口头自然语言话语的声学信号映射到由说话者预期的相应的单词序列中。

第 458 页，深度学习，2016 年。

给定文本作为音频数据的话语，模型必须产生人类可读的文本。

鉴于该过程的自动特性，该问题也可称为自动语音识别（ASR）。

语言模型用于创建以音频数据为条件的文本输出。

一些例子包括：

抄写演讲。
为电影或电视节目创建文字字幕。
在驾驶时向收音机发出命令。

有关语音识别的更多信息，请参阅：

维基百科上的语音识别

以下是语音识别深度学习的 3 个例子。

英语演讲文本。
- 连接主义时间分类：用循环神经网络标记未分段的序列数据，2006。
英语演讲文本。
- 深度循环神经网络语音识别，2013。
英语演讲文本。
- 探索用于语音识别的卷积神经网络结构和优化技术，2014。

4.标题生成

标题生成是描述图像内容的问题。

给定数字图像（例如照片），生成图像内容的文本描述。

语言模型用于创建以图像为条件的标题。

一些例子包括：

描述场景的内容。
为照片创建标题。
描述视频。

这不仅是针对听力受损者的应用，而且还是为可以搜索的图像和视频数据生成人类可读文本，例如在网络上。

以下是生成字幕的深度学习的 3 个示例：

生成照片的标题。
- 显示，参与和讲述：视觉注意的神经图像标题生成，2016。
生成照片的标题。
- 显示和告诉：神经图像标题生成器，2015。
为视频生成字幕。
- 序列到序列 - 视频到文本，2015。

5.机器翻译

机器翻译是将一种语言的源文本转换为另一种语言的问题。

机器翻译，文本或语音从一种语言到另一种语言的自动翻译，是 NLP 最重要的应用之一。

第 463 页，统计自然语言处理基础，1999。

鉴于使用深度神经网络，该领域被称为神经机器翻译。

在机器翻译任务中，输入已经由某种语言的符号序列组成，并且计算机程序必须将其转换为另一种语言的符号序列。这通常适用于自然语言，例如从英语翻译成法语。深度学习最近开始对这类任务产生重要影响。

第 98 页，深度学习，2016 年。

语言模型用于以源文本为条件输出第二语言的目标文本。

一些例子包括：

将文本文档从法语翻译成英语。
将西班牙语音频翻译为德语文本。
将英文文本翻译为意大利语音频。

有关神经机器翻译的更多信息，请参阅：

维基百科上的神经机器翻译

以下是机器翻译深度学习的 3 个例子：

文本从英语翻译成法语。
- 用神经网络进行序列学习的序列，2014。
文本从英语翻译成法语。
- 通过联合学习对齐和翻译的神经机器翻译，2014。
文本从英语翻译成法语。
- 联合语言和翻译建模与循环神经网络，2013。

6.文件摘要

文档摘要是创建文本文档的简短描述的任务。

如上所述，语言模型用于输出以完整文档为条件的摘要。

文档摘要的一些示例包括：

为文档创建标题。
创建文档的摘要。

有关该主题的更多信息，请参阅：

以下是文档摘要深度学习的 3 个示例：

新闻文章中句子的总结。
- 抽象概括的神经注意模型，2015。
新闻文章中句子的总结。
- 使用序列到序列 RNN 及其后的抽象文本摘要，2016。
新闻文章中句子的总结。
- 通过提取句子和单词进行神经总结，2016。

7.问题回答

问题回答是给定主题（例如文本文档）回答关于主题的特定问题的问题。

…通过返回适当的无短语（例如位置，人或日期）来尝试回答以问题形式表达的用户查询的问答系统。例如，为何杀死肯尼迪总统的问题？可能会用名词短语 Oswald 回答

第 377 页，统计自然语言处理基础，1999。

一些例子包括：

维基百科上的问题回答

有关问题解答的更多信息，请参阅：

回答有关维基百科文章的问题。
回答有关新闻文章的问题。
回答有关医疗记录的问题。

以下是 3 个问答的深度学习示例：

回答有关新闻文章的问题。
- 教学机器阅读和理解，2015。
回答关于 freebase 文章的一般知识问题。
- 使用多列卷积神经网络回答 Freebase 问题，2015 年。
回答提供特定文件的事实问题。
- 答案句子选择的深度学习，2015。

进一步阅读

如果您正在深入研究，本节将为 NLP 的深度学习应用程序提供更多资源。

自然语言处理神经网络模型入门，2015。
自然语言处理（几乎）来自 Scratch ，2011。
自然语言处理的深度学习，实用概述，牛津，2017 年
哪些 NLP 问题已成功应用深度学习或神经网络？
深度学习可以在自然语言处理方面取得类似的突破，就像它在视觉和视觉方面所做的那样。言语？

摘要

在这篇文章中，您发现了 7 种深度学习应用于自然语言处理任务。

您最喜欢的 NLP 深度学习的例子是错过的吗？
请在评论中告诉我。

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

如何实现自然语言处理的集束搜索解码器

原文： machinelearningmastery.com/beam-search-decoder-natural-language-processing/

自然语言处理任务，例如字幕生成和机器翻译，涉及生成单词序列。

针对这些问题开发的模型通常通过在输出词的词汇表中生成概率分布来操作，并且由解码算法来对概率分布进行采样以生成最可能的词序列。

在本教程中，您将发现可用于文本生成问题的贪婪搜索和集束搜索解码算法。

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

解码文本生成问题的问题。
贪婪的搜索解码器算法以及如何在 Python 中实现它。
光束搜索解码器算法以及如何在 Python 中实现它。

让我们开始吧。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

如何为自然语言处理实现集束搜索解码器
照片由参见 1，Do1，Teach1 ，保留一些权利。

用于文本生成的解码器

在自然语言处理任务（例如字幕生成，文本摘要和机器翻译）中，所需的预测是一系列单词。

为这些类型的问题开发的模型通常在输出序列中的每个单词的词汇表中的每个单词上输出概率分布。然后将其留给解码器处理以将概率转换为最终的单词序列。

在自然语言处理任务中使用循环神经网络时，您可能会遇到这种情况，其中文本生成为输出。神经网络模型中的最后一层具有输出词汇表中每个单词的一个神经元，并且 softmax 激活函数用于输出词汇表中的每个单词作为序列中的下一个单词的可能性。

解码最可能的输出序列涉及基于其可能性搜索所有可能的输出序列。词汇量的大小通常是数十或数十万个单词，甚至数百万个单词。因此，搜索问题在输出序列的长度上是指数级的，并且难以完全搜索（NP-complete）。

在实践中，启发式搜索方法用于为给定预测返回一个或多个近似或“足够好”的解码输出序列。

由于搜索图的大小在源句长度中是指数的，我们必须使用近似来有效地找到解。

第 272 页，自然语言处理与机器翻译手册，2011。

候选词的序列根据其可能性进行评分。通常使用贪婪搜索或集束搜索来定位候选文本序列。我们将在这篇文章中介绍这两种解码算法。

每个单独的预测都有一个相关的分数（或概率），我们感兴趣的是具有最大分数（或最大概率）的输出序列[…]一种流行的近似技术是使用贪婪预测，在每个阶段获得最高得分项目。虽然这种方法通常很有效，但它显然不是最佳的。实际上，使用光束搜索作为近似搜索通常比贪婪方法好得多。

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

贪婪的搜索解码器

一个简单的近似是使用贪婪搜索，在输出序列的每一步选择最可能的单词。

这种方法的好处是速度非常快，但最终输出序列的质量可能远非最佳。

我们可以用 Python 中的一个小设计示例来演示解码的贪婪搜索方法。

我们可以从涉及 10 个单词序列的预测问题开始。每个单词被预测为 5 个单词的词汇表上的概率分布。

# define a sequence of 10 words over a vocab of 5 words
data = [[0.1, 0.2, 0.3, 0.4, 0.5],
		[0.5, 0.4, 0.3, 0.2, 0.1],
		[0.1, 0.2, 0.3, 0.4, 0.5],
		[0.5, 0.4, 0.3, 0.2, 0.1],
		[0.1, 0.2, 0.3, 0.4, 0.5],
		[0.5, 0.4, 0.3, 0.2, 0.1],
		[0.1, 0.2, 0.3, 0.4, 0.5],
		[0.5, 0.4, 0.3, 0.2, 0.1],
		[0.1, 0.2, 0.3, 0.4, 0.5],
		[0.5, 0.4, 0.3, 0.2, 0.1]]
data = array(data)

我们假设单词已经整数编码，这样列索引可用于查找词汇表中的相关单词。因此，解码任务成为从概率分布中选择整数序列的任务。

argmax（）数学函数可用于选择具有最大值的数组的索引。我们可以使用此函数来选择序列中每个步骤最有可能的单词索引。该功能直接在 numpy 中提供。

下面的greedy_decoder()函数使用 argmax 函数实现此解码器策略。

# greedy decoder
def greedy_decoder(data):
	# index for largest probability each row
	return [argmax(s) for s in data]

综上所述，下面列出了演示贪婪解码器的完整示例。

from numpy import array
from numpy import argmax

# greedy decoder
def greedy_decoder(data):
	# index for largest probability each row
	return [argmax(s) for s in data]

# define a sequence of 10 words over a vocab of 5 words
data = [[0.1, 0.2, 0.3, 0.4, 0.5],
		[0.5, 0.4, 0.3, 0.2, 0.1],
		[0.1, 0.2, 0.3, 0.4, 0.5],
		[0.5, 0.4, 0.3, 0.2, 0.1],
		[0.1, 0.2, 0.3, 0.4, 0.5],
		[0.5, 0.4, 0.3, 0.2, 0.1],
		[0.1, 0.2, 0.3, 0.4, 0.5],
		[0.5, 0.4, 0.3, 0.2, 0.1],
		[0.1, 0.2, 0.3, 0.4, 0.5],
		[0.5, 0.4, 0.3, 0.2, 0.1]]
data = array(data)
# decode sequence
result = greedy_decoder(data)
print(result)

运行该示例会输出一个整数序列，然后可以将这些整数映射回词汇表中的单词。

[4, 0, 4, 0, 4, 0, 4, 0, 4, 0]

光束搜索解码器

另一种流行的启发式算法是集束搜索，它扩展了贪婪搜索并返回最可能的输出序列列表。

在构建序列时，不是贪婪地选择最可能的下一步，集束搜索扩展了所有可能的后续步骤并且最有可能保持k，其中k是用户指定的参数并通过概率序列控制光束数量或平行搜索。

局部集束搜索算法跟踪 k 个状态而不仅仅是一个状态。它以 k 个随机生成的状态开始。在每个步骤中，生成所有 k 个状态的所有后继者。如果任何一个是目标，则算法停止。否则，它从完整列表中选择 k 个最佳后继者并重复。

第 125-126 页，人工智能：现代方法（第 3 版），2009。

我们不需要从随机状态开始;相反，我们从k开始，最可能是单词作为序列的第一步。

对于贪婪搜索，公共集束宽度值为 1，对于机器翻译中的常见基准问题，公共集束宽度值为 5 或 10。较大的集束宽度导致模型的更好表现，因为多个候选序列增加了更好地匹配目标序列的可能性。这种增加的表现导致解码速度降低。

在 NMT 中，通过简单的集束搜索解码器转换新的句子，该解码器找到近似最大化训练的 NMT 模型的条件概率的平移。集束搜索策略从左到右逐字地生成翻译，同时在每个时间步长保持固定数量（集束）的活动候选。通过增加光束尺寸，转换表现可以以显着降低解码器速度为代价而增加。

神经机器翻译的光束搜索策略，2017。

搜索过程可以通过达到最大长度，到达序列结束标记或达到阈值可能性来分别停止每个候选。

让我们以一个例子来具体化。

我们可以定义一个函数来对给定的概率序列和集束宽度参数k进行集束搜索。在每个步骤中，使用所有可能的后续步骤扩展每个候选序列。通过将概率相乘来对每个候选步骤进行评分。选择具有最可能概率的k序列，并修剪所有其他候选者。然后重复该过程直到序列结束。

概率是小数字，将小数字相乘可以产生非常小的数字。为了避免使浮点数下溢，概率的自然对数相乘，这使得数字更大且易于管理。此外，通常通过最小化分数来执行搜索也是常见的，因此，概率的负对数相乘。最后的调整意味着我们可以按照他们的分数按升序对所有候选序列进行排序，并选择第一个 k 作为最可能的候选序列。

下面的beam_search_decoder()函数实现了集束搜索解码器。

# beam search
def beam_search_decoder(data, k):
	sequences = [[list(), 1.0]]
	# walk over each step in sequence
	for row in data:
		all_candidates = list()
		# expand each current candidate
		for i in range(len(sequences)):
			seq, score = sequences[i]
			for j in range(len(row)):
				candidate = [seq + [j], score * -log(row[j])]
				all_candidates.append(candidate)
		# order all candidates by score
		ordered = sorted(all_candidates, key=lambda tup:tup[1])
		# select k best
		sequences = ordered[:k]
	return sequences

我们可以将它与前一节中的样本数据联系起来，这次返回 3 个最可能的序列。

from math import log
from numpy import array
from numpy import argmax

# beam search
def beam_search_decoder(data, k):
	sequences = [[list(), 1.0]]
	# walk over each step in sequence
	for row in data:
		all_candidates = list()
		# expand each current candidate
		for i in range(len(sequences)):
			seq, score = sequences[i]
			for j in range(len(row)):
				candidate = [seq + [j], score * -log(row[j])]
				all_candidates.append(candidate)
		# order all candidates by score
		ordered = sorted(all_candidates, key=lambda tup:tup[1])
		# select k best
		sequences = ordered[:k]
	return sequences

# define a sequence of 10 words over a vocab of 5 words
data = [[0.1, 0.2, 0.3, 0.4, 0.5],
		[0.5, 0.4, 0.3, 0.2, 0.1],
		[0.1, 0.2, 0.3, 0.4, 0.5],
		[0.5, 0.4, 0.3, 0.2, 0.1],
		[0.1, 0.2, 0.3, 0.4, 0.5],
		[0.5, 0.4, 0.3, 0.2, 0.1],
		[0.1, 0.2, 0.3, 0.4, 0.5],
		[0.5, 0.4, 0.3, 0.2, 0.1],
		[0.1, 0.2, 0.3, 0.4, 0.5],
		[0.5, 0.4, 0.3, 0.2, 0.1]]
data = array(data)
# decode sequence
result = beam_search_decoder(data, 3)
# print result
for seq in result:
	print(seq)

运行该示例将打印整数序列及其对数似然。

尝试不同的 k 值。

[[4, 0, 4, 0, 4, 0, 4, 0, 4, 0], 0.025600863289563108]
[[4, 0, 4, 0, 4, 0, 4, 0, 4, 1], 0.03384250043584397]
[[4, 0, 4, 0, 4, 0, 4, 0, 3, 0], 0.03384250043584397]

进一步阅读

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

摘要

在本教程中，您发现了可用于文本生成问题的贪婪搜索和集束搜索解码算法。

具体来说，你学到了：

解码文本生成问题的问题。
贪婪的搜索解码器算法以及如何在 Python 中实现它。
光束搜索解码器算法以及如何在 Python 中实现它。

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

深度学习文档分类的最佳实践

原文： machinelearningmastery.com/best-practices-document-classification-deep-learning/

文本分类描述了一类问题，例如预测推文和电影评论的情感，以及将电子邮件分类为垃圾邮件。

深度学习方法在文本分类方面证明非常好，在一系列标准学术基准问题上实现了最先进的结果。

在这篇文章中，您将发现在开发用于文本分类的深度学习模型时要考虑的一些最佳实践。

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

深度学习方法的一般组合，在开始文本分类问题时要考虑。
第一个尝试提供有关如何配置超参数的具体建议的架构。
在灵活性和能力方面，更深层次的网络可能是该领域的未来。

让我们开始吧。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

深度学习文档分类的最佳实践
storebukkebruse 的照片，保留一些权利。

概观

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

词嵌入+ CNN =文本分类
使用单层 CNN 架构
拨入 CNN 超参数
考虑字符级 CNN
考虑更深入的 CNN 进行分类

1. 词嵌入+ CNN =文本分类

文本分类的操作方法涉及使用单词嵌入来表示单词和卷积神经网络（CNN）来学习如何区分分类问题的文档。

Yoav Goldberg 在自然语言处理深度学习的入门读物中评论说，神经网络通常提供比经典线性分类器更好的表现，特别是与预训练的字嵌入一起使用时。

网络的非线性以及容易集成预训练的字嵌入的能力通常会带来更高的分类准确率。

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

他还评论说卷积神经网络在文档分类方面是有效的，即因为它们能够以对输入序列中的位置不变的方式选择显着特征（例如令牌或令牌序列）。

具有卷积和池化层的网络对于分类任务很有用，在这些分类任务中我们期望找到关于类成员资格的强大的局部线索，但是这些线索可以出现在输入中的不同位置。 […]我们希望了解某些单词序列是该主题的良好指标，并不一定关心它们在文档中的出现位置。卷积层和汇集层允许模型学习如何找到这样的本地指标，而不管它们的位置如何。

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

因此，该架构由三个关键部分组成：

单词嵌入：单词的分布式表示，其中具有相似含义的不同单词（基于其用法）也具有相似的表示。
卷积模型：一种特征提取模型，用于学习从使用单词嵌入表示的文档中提取显着特征。
完全连接模型：根据预测输出解释提取的特征。

Yoav Goldberg 在他的书中强调了 CNN 作为特征提取器模型的作用：

… CNN 本质上是一种特征提取架构。它本身并不构成一个独立的，有用的网络，而是意味着要集成到一个更大的网络中，并接受训练以与其协同工作以产生最终结果。 CNNs 层的职责是提取对手头的整体预测任务有用的有意义的子结构。

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

将这三个要素结合在一起，可能是下一节中描述的最广泛引用的组合实例之一。

2.使用单层 CNN 架构

使用单层 CNN 可以获得用于文档分类的良好结果，可能在过滤器上具有不同大小的内核，以允许以不同比例对单词表示进行分组。

Yoon Kim 在研究使用预训练的单词向量进行卷积神经网络分类任务时发现，使用预先训练的静态单词向量非常有效。他建议在非常大的文本语料库中训练的预训练的单词嵌入，例如从谷歌新闻中训练的 1000 亿个令牌的免费 word2vec 向量，可以提供用于自然语言处理的良好通用特征。

尽管对超参数进行了很少的调整，但是具有一层卷积的简单 CNN 表现得非常好。我们的结果增加了公认的证据，即无监督的单词向量训练是 NLP 深度学习的重要组成部分

用于句子分类的卷积神经网络，2014。

他还发现，对单词向量进行进一步的任务特定调整可以提供额外的表现改进。

Kim 描述了使用 CNN 进行自然语言处理的一般方法。句子被映射到嵌入向量，并且可用作模型的矩阵输入。使用不同大小的内核（例如，一次 2 或 3 个字）逐字输入地执行卷积。然后使用最大池层处理所得到的特征图以压缩或汇总所提取的特征。

该架构基于 Ronan Collobert 等人使用的方法。在他们的论文“自然语言处理（几乎）来自 Scratch ”，2011 年。在其中，他们开发了一个单一的端到端神经网络模型，具有卷积和汇集层，可用于一系列基本自然语言处理问题。

Kim 提供了一个图表，有助于查看使用不同大小的内核作为不同颜色（红色和黄色）的过滤器的采样。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

用于自然语言处理的 CNN 过滤器和轮询架构的示例。
取自“用于句子分类的卷积神经网络”，2014 年。

有用的是，他报告了他所选择的模型配置，通过网格搜索发现并在一系列 7 个文本分类任务中使用，总结如下：

传递函数：整流线性。
内核大小：2,4,5。
过滤器数量：100
dropout 率：0.5
权重正则化（L2）：3
批量大小：50
更新规则：Adadelta

这些配置可用于激发您自己实验的起点。

3.拨入 CNN 超参数

在对文档分类问题调整卷积神经网络时，一些超参数比其他参数更重要。

Ye Zhang 和 Byron Wallace 对配置单层卷积神经网络进行文档分类所需的超参数进行了灵敏度分析。该研究的动机是他们声称模型对其配置很敏感。

不幸的是，基于 CNN 的模型（即使是简单的模型）的缺点是它们需要从业者指定要使用的确切模型架构并设置伴随的超参数。对于初学者来说，做出这样的决定看起来像黑色艺术，因为模型中有许多自由参数。

用于句子分类的卷积神经网络（和从业者指南）的灵敏度分析，2015 年。

他们的目标是提供可用于在新文本分类任务上配置 CNN 的常规配置。

它们提供了对模型架构的良好描述以及用于配置模型的决策点，如下所示。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

用于句子分类的卷积神经网络结构
取自“_ 用于句子分类的卷积神经网络（和从业者指南）的灵敏度分析 _”，2015。

该研究提供了许多有用的发现，可以作为配置浅 CNN 模型进行文本分类的起点。

一般调查结果如下：

预训练的 word2vec 和 GloVe 嵌入的选择因问题而异，并且两者都比使用单热编码的单词向量表现更好。
内核的大小很重要，应针对每个问题进行调整。
要素图的数量也很重要，应该进行调整。
1-max 池通常优于其他类型的池。
Dropout 对模型表现影响不大。

他们继续提供更具体的启发式方法，如下所示：

使用 word2vec 或 GloVe 字嵌入作为起点，并在拟合模型时进行调整。
跨不同内核大小的网格搜索，以找到问题的最佳配置，范围为 1-10。
搜索 100-600 的过滤器数量，并在同一搜索中探索 0.0-0.5 的丢失。
使用 tanh，relu 和线性激活功能进行探索。

关键的警告是，调查结果是基于使用单个句子作为输入的二元文本分类问题的实证结果。

我建议阅读全文以获取更多详细信息：

用于句子分类的卷积神经网络（和从业者指南）的灵敏度分析，2015 年。

4.考虑字符级 CNN

文本文档可以使用卷积神经网络在角色级别建模，该卷积神经网络能够学习单词，句子，段落等的相关层次结构。

张翔，等。使用基于字符的文本表示作为卷积神经网络的输入。该方法的承诺是，如果 CNN 可以学习抽象显着的细节，那么清理和准备文本所需的所有劳动密集型工作都可以克服。

…除了先前研究的结论之外，ConvNets 不需要语言的语法或语义结构，因此深入的 ConvNets 不需要语言知识。对于可以用于不同语言的单个系统而言，这种工程简化可能是至关重要的，因为无论是否可以分割成单词，字符总是构成必要的构造。仅处理字符还具有以下优点：可以自然地学习诸如拼写错误和表情符号之类的异常字符组合。

用于文本分类的字符级卷积网络，2015 年。

该模型以固定大小的字母表读入单热门的编码字符。编码字符以块或 1,024 个字符的序列读取。随后是具有池化的 6 个卷积层的栈，在网络的输出端具有 3 个完全连接的层以便做出预测。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

基于字符的文本分类卷积神经网络
取自“_ 用于文本分类的字符级卷积网络 _”，2015。

该模型取得了一些成功，在提供更大文本语料的问题上表现更好。

…分析表明，人物级别的 ConvNet 是一种有效的方法。 […]我们的模型在比较中的表现有多好取决于许多因素，例如数据集大小，文本是否经过策划以及字母表的选择。

用于文本分类的字符级卷积网络，2015 年。

使用这种方法的扩展版本的结果在下一节中介绍的后续文章中被推到了最新技术水平。

5.考虑更深入的 CNN 进行分类

尽管标准和可重用的架构尚未被用于分类任务，但是使用非常深的卷积神经网络可以实现更好的表现。

Alexis Conneau，et al。评论用于自然语言处理的相对较浅的网络以及用于计算机视觉应用的更深层网络的成功。例如，Kim（上文）将模型限制为单个卷积层。

本文中使用的用于自然语言的其他架构限于 5 层和 6 层。这与用于计算机视觉的成功架构形成对比，具有 19 层甚至 152 层。

他们建议并证明使用非常深的卷积神经网络模型（称为 VDCNN）对分层特征学习有益。

…我们建议使用多个卷积层的深层架构来实现这一目标，最多使用 29 层。我们的架构设计受到最近计算机视觉进展的启发[…]所提出的深度卷积网络显示出比以前的 ConvNets 方法更好的结果。

他们的方法的关键是嵌入单个字符，而不是单词嵌入。

我们提出了一种用于文本处理的新架构（VDCNN），它直接在字符级别操作，并且仅使用小卷积和池化操作。

用于文本分类的非常深的卷积网络，2016。

一套 8 个大型文本分类任务的结果显示出比更浅层网络更好的表现。具体而言，在撰写本文时，除了两个测试数据集之外的所有数据集都具有最先进的结果。

通常，他们通过探索更深层的架构方法得出一些重要发现：

非常深的架构在小型和大型数据集上运行良好。
更深的网络减少了分类错误。
与其他更复杂的池化类型相比，最大池化可获得更好的结果。
通常更深入会降低准确率;架构中使用的快捷方式连接很重要。

…这是第一次在 NLP 中显示卷积神经网络的“深度效益”。

用于文本分类的非常深的卷积网络，2016。

进一步阅读

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

您是否在文档分类的深度学习方面遇到了一些很好的资源？
请在下面的评论中告诉我。

摘要

在这篇文章中，您发现了一些用于开发文档分类深度学习模型的最佳实践。

具体来说，你学到了：

一个关键的方法是使用字嵌入和卷积神经网络进行文本分类。
单层模型可以很好地解决中等规模的问题，以及如何配置它的想法。
直接在文本上运行的更深层模型可能是自然语言处理的未来。

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

关于自然语言处理的热门书籍

原文： machinelearningmastery.com/books-on-natural-language-processing/

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

该领域由统计范例主导，机器学习方法用于开发预测模型。

在这篇文章中，您将发现可以阅读的顶级书籍，以便开始使用自然语言处理。

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

实用自然语言处理的顶级书籍。
自然语言处理理论基础的顶级教科书。
我在架子上的 NLP 书籍。

让我们开始吧。

关于自然语言处理的顶级实用书籍

作为从业者，我们并不总是在开始一个新主题时抓住一本教科书。

本书中的代码示例使用 Python 编程语言。

虽然 NLP 的实用书籍比教科书少，但我试图挑选前三本书，这些书籍将帮助您入门并将 NLP 方法引入您的机器学习项目。

1.使用 Python 进行自然语言处理

由 Steven Bird ， Ewan Klein 和 Edward Loper 撰写。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

本书介绍了使用 Python 栈为从业者提供的 NLP。

本书侧重于使用 NLTK Python 库，这对于常见的 NLP 任务非常流行。

内容包括：

语言处理和 Python
访问文本语料库和词汇资源
处理原始文本
编写结构化程序
分类和标记单词
学习分类文本
从文本中提取信息
句子结构分析
构建基于特征的 GRammars
句子意义分析
管理语言数据

如果您正在寻找使用首选 NLTK 平台进入经典 NLP 的话，这本书是完美的。

资源

使用 Python 进行自然语言处理：使用自然语言工具包分析文本（在亚马逊上）
Python 自然语言处理（免费版）

2.驯服文字

本书介绍了一套不同的 NLP 工具和问题，例如 Apache Solr ， Apache OpenNLP 和 Apache Mahout 。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

代码示例使用 Java。

它可能更适合开发人员在工作项目中开始使用更大的企业级 NLP 工具。

由 Grant Ingersoll ， Thomas Morton 和 Drew Farris 撰写。

值得注意的是，Grant Ingersoll 是 Apache Mahout 项目的联合创始人。

内容包括：

入门驯服文本
驯服文本的基础
搜索
模糊字符串匹配
识别人物，地点和事物
聚类文本
分类，分类和标记
构建示例问答系统
解读文本：探索下一个前沿

资源

3.使用 R 进行文本挖掘

由 Julia Silge 和 David Robinson 撰写。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

本书展示了一系列现代应用程序的统计自然语言处理方法。

代码示例在 R.

代码侧重于 Hadley Wickham（论文）的“tidy”原则和作者的 tidytext 包。

在这三本书中，这是最近出版的，对演示有更实际和现代的感觉。

内容包括：

整洁的文本格式
整洁数据的情感分析
分析单词和文档频率：tf-idf
词语之间的关系：N-gram 和相关性
转换为 Nontidy 格式和从 Nontidy 格式转换
主题建模
案例研究：比较 Twitter 档案
案例研究：挖掘 NASA 元数据
案例研究：分析 Usenet 文本

资源

采用 R 进行文本挖掘：一种整洁的方法（在亚马逊上）
图书主页（及免费预订）
Book GitHub Repository （代码和数据）

你知道其他关于自然语言处理的实用书吗？
请在评论中告诉我。

关于自然语言处理的顶级教科书

有大量关于自然语言处理和特定子主题的教科书。

在本节中，我试图关注我（和共识）似乎看到的关于初学者的主题的最佳书籍，例如：希望深入理论的本科生或研究生以及从业者。

我试图选择一般的 NLP 书籍以及关于翻译和演讲等高度研究的主题的书籍。

本节的前两本书基本上是 NLP 学生的大炮。

1.统计自然语言处理的基础

由 Christopher Manning 和HinrichSchütze撰写。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

值得注意的是，克里斯托弗曼宁在斯坦福大学教授 NLP，并且支持 CS224n：深度学习自然语言处理课程。

本书介绍了自然语言处理的统计方法，涵盖了所需的语言学和较新的（当时，大约 1999 年）统计方法。

本书为更好地掌握新方法和编码提供了坚实的基础。

内容包括：

介绍
数学基础
语言要点
基于语料库的工作
搭配
统计推断：稀疏数据的 n-gram 模型
词义消歧
词汇习得
马尔可夫模型
词性标注
概率上下文自由语法
概率解析
统计对齐与机器翻译
聚类
信息检索专题
文本分类

资源

统计自然语言处理基础（亚马逊上）
书籍主页

2.语音和语言处理

由 Daniel Jurafsky 和 James Martin 撰写。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

本书从语音和文本的角度介绍了 NLP，重点关注应用程序（每章一章）。

该主题的报道感觉详尽无遗。

内容包括：

介绍
正则表达式和自动机
单词和传感器
N 元
词性标注
隐马尔可夫和最大熵模型
语音
语音合成
自动语音识别
语音识别：高级主题
计算音韵学
正式的英语语法
句法分析
统计分析
特色与统一
语言和复杂性
意义的表征
计算语义学
词汇语义学
计算词汇语义学
计算话语
信息提取
问答以及总结
对话和会话代理
机器翻译

资源

语音和语言处理，第 2 版（亚马逊上）
书籍主页

4.统计机器翻译

由 Philipp Koehn 撰写。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

本书介绍了统计机器翻译的主题，这是 NLP 的一个子领域。

内容包括：

介绍
单词，句子，科帕
概率论
基于单词的模型
基于短语的模型
解码
语言模型
评估
判别训练
整合语言信息
基于树的方法

资源

统计机器翻译（亚马逊上）
书籍主页

5.语音识别的统计方法

由 Frederick Jelinek 撰写。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

本书介绍了统计语音识别的主题，这是 NLP 的另一个子领域，它在 20 世纪 90 年代通过统计方法进行了大修。

内容包括

语音识别问题
隐马尔可夫模型
声学模型
基本语言建模
维特比搜索
假设搜索树和快速匹配
信息论的要素
任务的复杂性 - 语言模型的质量
期望最大化算法及其后果
决策树和树语言模型
正字法的语音学：拼写到基础形式的映射
三脚架和 Allophones
最大熵概率估计和语言模型
最大熵估计在树木语言建模中的应用
从计数和退避方法估计概率

资源

语音识别统计方法（亚马逊上）

我拥有的 NLP 书籍

我喜欢在架子上混合使用实用和参考文本。

NLP（对我而言）的难点在于大量的子问题和使用的专业术语和理论。

出于这个原因，我的架子上有以下 3 个 NLP 教科书：

我也很喜欢这样的样子：

牛津计算语言学手册（上未列出）

我建议您选择适合您和您的需求或项目的 NLP 书籍。

让我知道您选择或拥有哪些书籍。
在下面发表评论。

进一步阅读

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

顶级 NLP 书籍

Quora 的

摘要

在这篇文章中，您发现了有关自然语言处理的顶级书籍。

具体来说，你学到了：

实用自然语言处理的顶级书籍。
自然语言处理理论基础的顶级教科书
我在架子上的 NLP 书籍。

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

在 Python 中计算文本 BLEU 分数的温和介绍

原文： machinelearningmastery.com/calculate-bleu-score-for-text-python/

BLEU 或双语评估 Understudy 是用于将文本的候选翻译与一个或多个参考翻译进行比较的分数。

虽然是为翻译而开发的，但它可用于评估为一系列自然语言处理任务生成的文本。

在本教程中，您将发现使用 Python 中的 NLTK 库评估和评分候选文本的 BLEU 分数。

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

轻轻地介绍 BLEU 分数和对计算内容的直觉。
如何使用 NLTK 库为句子和文档计算 Python 中的 BLEU 分数。
如何使用一套小例子来确定候选人和参考文本之间的差异如何影响最终的 BLEU 分数。

让我们开始吧。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

在 Python 中计算文本 BLEU 分数的温和介绍
照片由 Bernard Spragg 撰写。 NZ ，保留一些权利。

教程概述

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

双语评估 Understudy 得分
计算 BLEU 分数
累积和个人 BLEU 分数
工作的例子

双语评估 Understudy 得分

双语评估 Understudy 分数，或简称 BLEU，是用于评估生成的句子到参考句子的度量。

完美匹配得分为 1.0，而完美匹配得分为 0.0。

该评分是为评估自动机器翻译系统的预测而开发的。它并不完美，但确实提供了 5 个引人注目的好处：

计算速度快，成本低廉。
这很容易理解。
它与语言无关。
它与人类评价高度相关。
它已被广泛采用。

BLEU 评分由 Kishore Papineni 等人提出。在 2002 年的论文“ BLEU：一种自动评估机器翻译的方法”。

该方法通过将候选翻译中的匹配 n-gram 计数到参考文本中的 n-gram 来进行工作，其中 1-gram 或 unigram 将是每个标记，并且 bigram 比较将是每个单词对。无论字顺序如何，都进行比较。

BLEU 实现者的主要编程任务是将候选者的 n-gram 与参考翻译的 n-gram 进行比较并计算匹配数。这些匹配与位置无关。匹配越多，候选翻译就越好。

BLEU：一种自动评估机器翻译的方法，2002。

修改匹配的 n-gram 的计数以确保它考虑参考文本中的单词的出现，而不是奖励产生大量合理单词的候选翻译。这在本文中称为修正的 n-gram 精度。

不幸的是，MT 系统可以过度生成“合理”的单词，导致不可能但高精度的翻译[…]直观地，问题很明显：在识别出匹配的候选词之后，应该认为参考词已经用尽。我们将这种直觉形式化为修改后的单字组精度。

BLEU：一种自动评估机器翻译的方法，2002。

该分数用于比较句子，但是还提出了通过其出现来标准化 n-gram 的修改版本以用于更好的多个句子的评分块。

我们首先逐句计算 n-gram 匹配。接下来，我们为所有候选句子添加剪切的 n-gram 计数，并除以测试语料库中的候选 n-gram 的数量，以计算整个测试语料库的修改的精确度分数 pn。

BLEU：一种自动评估机器翻译的方法，2002。

在实践中不可能获得满分，因为翻译必须与参考完全匹配。人类翻译甚至无法做到这一点。用于计算 BLEU 分数的参考文献的数量和质量意味着比较数据集之间的分数可能很麻烦。

BLEU 度量范围从 0 到 1.少数翻译将获得 1 分，除非它们与参考翻译相同。出于这个原因，即使是一个人类翻译也不一定会在大约 500 个句子（40 个一般新闻报道）的测试语料中得分 1.一个人类翻译对四个参考文献得分为 0.3468，对两个参考文献得分为 0.2571。

BLEU：一种自动评估机器翻译的方法，2002。

除了翻译，我们还可以通过深度学习方法将 BLEU 评分用于其他语言生成问题，例如：

语言生成。
图像标题生成。
文字摘要。
语音识别。

以及更多。

计算 BLEU 分数

Python Natural Language Toolkit 库（即 NLTK）提供了 BLEU 分数的实现，您可以使用它来根据引用评估生成的文本。

句子 BLEU 分数

NLTK 提供 sentence_bleu（）函数，用于针对一个或多个参考句子评估候选句子。

引用句子必须作为句子列表提供，其中每个引用是一个令牌列表。候选句子作为令牌列表提供。例如：

from nltk.translate.bleu_score import sentence_bleu
reference = [['this', 'is', 'a', 'test'], ['this', 'is' 'test']]
candidate = ['this', 'is', 'a', 'test']
score = sentence_bleu(reference, candidate)
print(score)

运行此示例会打印出一个完美的分数，因为候选者会精确匹配其中一个引用。

1.0

语料库 BLEU 分数

NLTK 还提供称为 corpus_bleu（）的函数，用于计算多个句子（例如段落或文档）的 BLEU 分数。

必须将引用指定为文档列表，其中每个文档是引用列表，并且每个备选引用是令牌列表，例如，令牌列表列表。必须将候选文档指定为列表，其中每个文档是令牌列表，例如，令牌列表列表。

这有点令人困惑;这是一个文档的两个引用的示例。

# two references for one document
from nltk.translate.bleu_score import corpus_bleu
references = [[['this', 'is', 'a', 'test'], ['this', 'is' 'test']]]
candidates = [['this', 'is', 'a', 'test']]
score = corpus_bleu(references, candidates)
print(score)

运行该示例将像以前一样打印出完美的分数。

1.0

累积和个人 BLEU 分数

NLTK 中的 BLEU 分数计算允许您在计算 BLEU 分数时指定不同 n-gram 的权重。

这使您可以灵活地计算不同类型的 BLEU 分数，例如个人和累积的 n-gram 分数。

让我们来看看。

个人 N-Gram 分数

单独的 N-gram 分数是仅匹配特定顺序的克数的评估，例如单个单词（1-gram）或单词对（2-gram 或 bigram）。

权重被指定为元组，其中每个索引引用克顺序。要仅为 1-gram 匹配计算 BLEU 分数，您可以为 1-gram 指定权重 1，为 2,3 和 4 指定权重（1,0,0,0）。例如：

# 1-gram individual BLEU
from nltk.translate.bleu_score import sentence_bleu
reference = [['this', 'is', 'small', 'test']]
candidate = ['this', 'is', 'a', 'test']
score = sentence_bleu(reference, candidate, weights=(1, 0, 0, 0))
print(score)

运行此示例会打印 0.5 分。

0.75

我们可以针对 1 到 4 的单个 n-gram 重复此示例，如下所示：

# n-gram individual BLEU
from nltk.translate.bleu_score import sentence_bleu
reference = [['this', 'is', 'a', 'test']]
candidate = ['this', 'is', 'a', 'test']
print('Individual 1-gram: %f' % sentence_bleu(reference, candidate, weights=(1, 0, 0, 0)))
print('Individual 2-gram: %f' % sentence_bleu(reference, candidate, weights=(0, 1, 0, 0)))
print('Individual 3-gram: %f' % sentence_bleu(reference, candidate, weights=(0, 0, 1, 0)))
print('Individual 4-gram: %f' % sentence_bleu(reference, candidate, weights=(0, 0, 0, 1)))

运行该示例将给出以下结果。

Individual 1-gram: 1.000000
Individual 2-gram: 1.000000
Individual 3-gram: 1.000000
Individual 4-gram: 1.000000

虽然我们可以计算单个 BLEU 分数，但这不是该方法的用途，并且分数没有很多意义，或者似乎可以解释。

累积 N-Gram 分数

累积分数指的是从 1 到 n 的所有阶数的单个 n-gram 分数的计算，并通过计算加权几何平均值对它们进行加权。

默认情况下，sentence_bleu()和corpus_bleu()分数计算累积的 4 克 BLEU 分数，也称为 BLEU-4。

对于 1 克，2 克，3 克和 4 克的分数，BLEU-4 的重量分别为 1/4（25％）或 0.25。例如：

# 4-gram cumulative BLEU
from nltk.translate.bleu_score import sentence_bleu
reference = [['this', 'is', 'small', 'test']]
candidate = ['this', 'is', 'a', 'test']
score = sentence_bleu(reference, candidate, weights=(0.25, 0.25, 0.25, 0.25))
print(score)

运行此示例将打印以下分数：

0.707106781187

累积和单个 1 克 BLEU 使用相同的权重，例如（1,0,0,0）。 2 克重量为 1 克和 2 克各分配 50％，3 克重量为 1,2 克和 3 克分数各 33％。

让我们通过计算 BLEU-1，BLEU-2，BLEU-3 和 BLEU-4 的累积分数来具体化：

# cumulative BLEU scores
from nltk.translate.bleu_score import sentence_bleu
reference = [['this', 'is', 'small', 'test']]
candidate = ['this', 'is', 'a', 'test']
print('Cumulative 1-gram: %f' % sentence_bleu(reference, candidate, weights=(1, 0, 0, 0)))
print('Cumulative 2-gram: %f' % sentence_bleu(reference, candidate, weights=(0.5, 0.5, 0, 0)))
print('Cumulative 3-gram: %f' % sentence_bleu(reference, candidate, weights=(0.33, 0.33, 0.33, 0)))
print('Cumulative 4-gram: %f' % sentence_bleu(reference, candidate, weights=(0.25, 0.25, 0.25, 0.25)))

运行该示例将打印以下分数。他们是完全不同的，更具表现力

它们与独立的单个 n-gram 分数完全不同且更具表现力。

Cumulative 1-gram: 0.750000
Cumulative 2-gram: 0.500000
Cumulative 3-gram: 0.632878
Cumulative 4-gram: 0.707107

在描述文本生成系统的技能时，通常会报告累积的 BLEU-1 到 BLEU-4 分数。

工作的例子

在本节中，我们尝试通过一些例子为 BLEU 评分进一步发展直觉。

我们使用以下单个参考句在句子级别工作：

快速的棕色狐狸跳过懒狗

首先，让我们看看一个完美的分数。

# prefect match
from nltk.translate.bleu_score import sentence_bleu
reference = [['the', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy', 'dog']]
candidate = ['the', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy', 'dog']
score = sentence_bleu(reference, candidate)
print(score)

运行该示例打印完美匹配。

1.0

接下来，让我们改变一个词，‘_ 快速 ‘改为’ 快 _’。

# one word different
from nltk.translate.bleu_score import sentence_bleu
reference = [['the', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy', 'dog']]
candidate = ['the', 'fast', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy', 'dog']
score = sentence_bleu(reference, candidate)
print(score)

这个结果是得分略有下降。

0.7506238537503395

尝试更改两个单词，‘_ 快速 ‘到’ 快速 ‘和’ 懒惰 ‘到’ 困 _’。

# two words different
from nltk.translate.bleu_score import sentence_bleu
reference = [['the', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy', 'dog']]
candidate = ['the', 'fast', 'brown', 'fox', 'jumped', 'over', 'the', 'sleepy', 'dog']
score = sentence_bleu(reference, candidate)
print(score)

运行该示例，我们可以看到技能的线性下降。

0.4854917717073234

如果候选人的所有单词都不同怎么办？

# all words different
from nltk.translate.bleu_score import sentence_bleu
reference = [['the', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy', 'dog']]
candidate = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
score = sentence_bleu(reference, candidate)
print(score)

我们得分可能更差。

0.0

现在，让我们尝试一个比参考词少的候选词（例如删掉最后两个词），但这些词都是正确的。

# shorter candidate
from nltk.translate.bleu_score import sentence_bleu
reference = [['the', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy', 'dog']]
candidate = ['the', 'quick', 'brown', 'fox', 'jumped', 'over', 'the']
score = sentence_bleu(reference, candidate)
print(score)

当两个单词出错时，得分很像得分。

0.7514772930752859

如果我们让候选人的两个单词长于参考文件怎么样？

# longer candidate
from nltk.translate.bleu_score import sentence_bleu
reference = [['the', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy', 'dog']]
candidate = ['the', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy', 'dog', 'from', 'space']
score = sentence_bleu(reference, candidate)
print(score)

再次，我们可以看到我们的直觉成立并且得分类似于“_ 两个单词错 _”。

0.7860753021519787

最后，让我们比较一个太短的候选人：长度只有两个单词。

# very short
from nltk.translate.bleu_score import sentence_bleu
reference = [['the', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy', 'dog']]
candidate = ['the', 'quick']
score = sentence_bleu(reference, candidate)
print(score)

首先运行此示例将打印一条警告消息，指示无法执行评估的 3 克及以上部分（最多 4 克）。这是公平的，因为我们只有 2 克与候选人一起工作。

UserWarning:
Corpus/Sentence contains 0 counts of 3-gram overlaps.
BLEU scores might be undesirable; use SmoothingFunction().
  warnings.warn(_msg)

接下来，我们的分数确实非常低。

0.0301973834223185

我鼓励你继续玩实例。

数学很简单，我也鼓励你阅读论文并探索自己在电子表格中计算句子级别的分数。

进一步阅读

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

摘要

在本教程中，您发现了用于评估和评分候选文本以在机器翻译和其他语言生成任务中引用文本的 BLEU 分数。

具体来说，你学到了：

轻轻地介绍 BLEU 分数和对计算内容的直觉。
如何使用 NLTK 库为句子和文档计算 Python 中的 BLEU 分数。
如何使用一套小例子来确定候选人和参考文本之间的差异如何影响最终的 BLEU 分数的直觉。

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

使用编解码器模型的用于字幕生成的注入和合并架构

原文： machinelearningmastery.com/caption-generation-inject-merge-architectures-encoder-decoder-model/

字幕生成是一个具有挑战性的人工智能问题，它利用计算机视觉和自然语言处理。

编解码器循环神经网络架构已被证明在这个问题上是有效的。这种架构的实现可以被提炼为基于注入和合并的模型，并且两者都对循环神经网络在解决问题中的作用做出了不同的假设。

在这篇文章中，您将发现针对字幕生成的编解码器循环神经网络模型的注入和合并架构。

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

字幕生成的挑战和编解码器架构的使用。
注入模型将编码图像与每个单词组合以生成标题中的下一个单词。
合并模型，分别对图像和描述进行编码，这些图像和描述被解码以生成标题中的下一个单词。

让我们开始吧。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

使用编解码器模型的注入和合并架构生成标题
照片由 Bernard Spragg 撰写。 NZ ，保留一些权利。

图像标题生成

图像标题生成的问题涉及输出对照片内容的可读和简明的描述。

这是一个具有挑战性的人工智能问题，因为它需要来自计算机视觉的两种技术来解释照片的内容和来自自然语言处理的技术以生成文本描述。

最近，深度学习方法已经在这个具有挑战性的问题上取得了最新成果。结果令人印象深刻，这个问题已经成为深度学习能力的标准示范问题。

编解码器架构

标准编解码器循环神经网络架构用于解决图像标题生成问题。

这涉及两个要素：

编码器：一种网络模型，它使用内部表示读取照片输入并将内容编码为固定长度的向量。
解码器：读取编码照片并生成文本描述输出的网络模型。

有关编解码器循环神经网络架构的更多信息，请参阅帖子：

编解码器长短期记忆网络

通常，卷积神经网络用于编码图像，并且循环神经网络（例如长短期记忆网络）用于编码到目前为止生成的文本序列，和/或生成序列中的下一个单词。。

对于字幕生成问题，有很多方法可以实现这种架构。

通常使用在具有挑战性的照片分类问题上训练的预先训练的卷积神经网络模型来对照片进行编码。可以加载预训练的模型，移除模型的输出，以及用作输入图像的编码或内部表示的照片的内部表示。

对于问题的框架也是常见的，使得模型生成输出文本描述中的一个单词，给定照片和输入生成的描述。在此框架中，模型被递归调用，直到生成整个输出序列。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

字幕生成模型
的递归成帧取自“将图像放在图像标题生成器中的位置”。

这种框架可以使用两种架构中的一种来实现，由 Marc Tanti 等人调用。作为注入和合并模型。

注入模型

注入模型将图像的编码形式与迄今为止生成的文本描述中的每个单词组合在一起。

该方法使用循环神经网络作为文本生成模型，其使用图像和单词信息的序列作为输入，以便生成序列中的下一个单词。

在这些“注入”架构中，图像向量（通常从卷积神经网络中的隐藏层的激活值导出）被注入到 RNN 中，例如通过将图像向量与“单词”相提并论并且包括它作为标题前缀的一部分。

将图像放在图像标题生成器中的位置，2017 年。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

编解码器模型
的注入架构取自“图像标题生成器中的循环神经网络（RNN）的作用是什么？”。

该模型将图像的关注点与每个输入词组合在一起，要求编码器开发一种将视觉和语言信息结合在一起的编码。

在注入模型中，RNN 被训练以基于由语言和感知特征组成的历史来预测序列。因此，在该模型中，RNN 主要负责图像条件语言的生成。

循环神经网络（RNN）在图像标题生成器中的作用是什么？，2017。

合并模型

合并模型将图像输入的编码形式与到目前为止生成的文本描述的编码形式相结合。

然后，这两个编码输入的组合由非常简单的解码器模型使用，以生成序列中的下一个字。

该方法仅使用循环神经网络对目前生成的文本进行编码。

在“合并”架构的情况下，图像被排除在 RNN 子网之外，使得 RNN 仅处理字幕前缀，即仅处理纯语言信息。在对前缀进行向量化之后，然后将图像向量与前缀向量合并在一个单独的“多模式层”中，后者位于 RNN 子网之后

将图像放在图像标题生成器中的位置，2017 年。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

编解码器模型的合并架构
取自“图像标题生成器中循环神经网络（RNN）的作用是什么？”。

这分离了对图像输入建模，文本输入以及编码输入的组合和解释的关注。

如上所述，通常使用预训练的模型来编码图像，但类似地，该架构还允许使用预训练的语言模型来编码字幕文本输入。

…在合并架构中，RNN 实际上编码语言表示，它们本身构成了在多模式层之后的后来预测阶段的输入。只有在这个晚期阶段才能使用图像特征来预测预测

循环神经网络（RNN）在图像标题生成器中的作用是什么？，2017。

尽管 Marc Tanti 等人进行了实验，但有多种方法可以将两种编码输入结合起来，例如连接，乘法和加法。已经显示出更好的工作。

一般来说，Marc Tanti，et al。发现与注入方法相比，合并架构更有效。

总的来说，有证据表明，延迟将图像特征与语言编码合并到架构的后期阶段可能是有利的[…]结果表明合并架构比注入架构具有更高的容量，并且可以生成更小质量的字幕层。

循环神经网络（RNN）在图像标题生成器中的作用是什么？，2017。

进一步阅读

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

摘要

在这篇文章中，您发现了字幕生成的编解码器循环神经网络模型的注入和合并架构。

具体来说，你学到了：

字幕生成的挑战和编解码器架构的使用。
注入模型将编码图像与每个单词组合以生成标题中的下一个单词。
合并模型，分别对图像和描述进行编码，这些图像和描述被解码以生成标题中的下一个单词。

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

如何用 Python 为机器学习清理文本

原文： machinelearningmastery.com/clean-text-machine-learning-python/

你不能直接从原始文本到适合机器学习或深度学习模型。

您必须首先清理文本，这意味着将其拆分为单词并处理标点符号和大小写。

实际上，您可能需要使用一整套文本准备方法，方法的选择实际上取决于您的自然语言处理任务。

在本教程中，您将了解如何清理和准备文本，以便通过机器学习进行建模。

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

如何开始开发自己非常简单的文本清理工具。
如何采取措施并使用 NLTK 库中更复杂的方法。
如何在使用像文字嵌入这样的现代文本表示方法时准备文本。

让我们开始吧。

2017 年 11 月更新：修正了“分裂为单词”部分中的代码拼写错误，感谢 David Comfort。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

如何开发用于时间序列预测的多层感知机模型
照片由土地管理局提供，保留一些权利。

教程概述

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

弗兰兹卡夫卡的变态
文本清理是特定于任务的
手动标记
使用 NLTK 进行标记和清理
其他文字清理注意事项
清除词嵌入文本的提示

弗兰兹卡夫卡的变态

让我们从选择数据集开始。

在本教程中，我们将使用 Franz Kafka 的书 Metamorphosis 中的文本。没有具体的原因，除了它的简短，我喜欢它，你也可能喜欢它。我希望这是大多数学生在学校必读的经典之作。

Metamorphosis 的全文可从 Project Gutenberg 免费获得。

Franz Kafka 对 Project Gutenberg 的变形

您可以在此处下载文本的 ASCII 文本版本：

变形由 Franz Kafka 纯文本 UTF-8 （可能需要加载页面两次）。

下载文件并将其放在当前工作目录中，文件名为“metamorphosis.txt”。

该文件包含我们不感兴趣的页眉和页脚信息，特别是版权和许可证信息。打开文件并删除页眉和页脚信息，并将文件另存为“metamorphosis_clean.txt”。

clean 文件的开头应如下所示：

一天早上，当 Gregor Samsa 从困扰的梦中醒来时，他发现自己在床上变成了一个可怕的害虫。

该文件应以：

并且，好像在确认他们的新梦想和善意时，一旦他们到达目的地，Grete 就是第一个站起来伸展她年轻的身体的人。

穷格雷戈尔…

文本清理是特定于任务的

在实际掌握了您的文本数据之后，清理文本数据的第一步是对您要实现的目标有一个强烈的了解，并在该上下文中查看您的文本，看看究竟可能有什么帮助。

花点时间看看文字。你注意到什么？

这是我看到的：

它是纯文本，所以没有解析标记（耶！）。
原始德语的翻译使用英国英语（例如“_ 旅行 _”）。
这些线条是用约 70 个字符（meh）的新线条人工包裹的。
没有明显的拼写错误或拼写错误。
有标点符号，如逗号，撇号，引号，问号等。
有像盔甲一样的连字符描述。
有很多使用 em 破折号（“ - ”）继续句子（可能用逗号替换？）。
有名字（例如“ _Samsa 先生 _”）
似乎没有需要处理的数字（例如 1999）
有节标记（例如“II”和“III”），我们删除了第一个“I”。

我确信还有很多人会接受训练有素的眼睛。

我们将在本教程中查看一般文本清理步骤。

尽管如此，请考虑我们在处理此文本文档时可能遇到的一些目标。

例如：

如果我们有兴趣开发 Kafkaesque 语言模型，我们可能希望保留所有案例，引号和其他标点符号。
如果我们有兴趣将文件分类为“Kafka”和“ Not Kafka ”，那么我们可能会想要删除案例，标点符号，甚至修剪单词。

使用您的任务作为镜头，通过它选择如何准备文本数据。

手动标记

文本清理很难，但我们选择使用的文本已经非常干净了。

我们可以编写一些 Python 代码来手动清理它，这对于遇到的那些简单问题来说是一个很好的练习。像正则表达式和拆分字符串这样的工具可以帮到你很长的路。

1.加载数据

让我们加载文本数据，以便我们可以使用它。

文本很小，可以快速加载并轻松融入内存。情况并非总是如此，您可能需要将代码写入内存映射文件。像 NLTK 这样的工具（将在下一节中介绍）将使得处理大文件变得更加容易。

我们可以将整个“_ 变态 clean.text_ ”加载到内存中，如下所示：

# load text
filename = 'metamorphosis_clean.txt'
file = open(filename, 'rt')
text = file.read()
file.close()

运行该示例将整个文件加载到可以使用的内存中。

2.按空白分割

清晰文本通常表示我们可以在机器学习模型中使用的单词或标记列表。

这意味着将原始文本转换为单词列表并再次保存。

一种非常简单的方法是使用空格分割文档，包括“”，新行，制表符等。我们可以在 Python 中使用 split（）函数在加载的字符串上执行此操作。

# load text
filename = 'metamorphosis_clean.txt'
file = open(filename, 'rt')
text = file.read()
file.close()
# split into words by white space
words = text.split()
print(words[:100])

运行该示例将文档拆分为一长串单词并打印前 100 个供我们查看。

我们可以看到标点符号被保留（例如“_ 不是 ”和“ 盔甲式 ”），这很好。我们还可以看到句子标点符号的结尾与最后一个单词保持一致（例如“ 认为 _。”），这不是很好。

['One', 'morning,', 'when', 'Gregor', 'Samsa', 'woke', 'from', 'troubled', 'dreams,', 'he', 'found', 'himself', 'transformed', 'in', 'his', 'bed', 'into', 'a', 'horrible', 'vermin.', 'He', 'lay', 'on', 'his', 'armour-like', 'back,', 'and', 'if', 'he', 'lifted', 'his', 'head', 'a', 'little', 'he', 'could', 'see', 'his', 'brown', 'belly,', 'slightly', 'domed', 'and', 'divided', 'by', 'arches', 'into', 'stiff', 'sections.', 'The', 'bedding', 'was', 'hardly', 'able', 'to', 'cover', 'it', 'and', 'seemed', 'ready', 'to', 'slide', 'off', 'any', 'moment.', 'His', 'many', 'legs,', 'pitifully', 'thin', 'compared', 'with', 'the', 'size', 'of', 'the', 'rest', 'of', 'him,', 'waved', 'about', 'helplessly', 'as', 'he', 'looked.', '"What\'s', 'happened', 'to', 'me?"', 'he', 'thought.', 'It', "wasn't", 'a', 'dream.', 'His', 'room,', 'a', 'proper', 'human']

3.选择单词

另一种方法可能是使用正则表达式模型（重新）并通过选择字母数字字符串（a-z，A-Z，0-9 和’_'）将文档拆分为单词。

例如：

# load text
filename = 'metamorphosis_clean.txt'
file = open(filename, 'rt')
text = file.read()
file.close()
# split based on words only
import re
words = re.split(r'\W+', text)
print(words[:100])

再次，运行示例我们可以看到我们得到了单词列表。这一次，我们可以看到“_ 盔甲式 ”现在是两个词“ 装甲 ”和“ 喜欢 _”（精）但是收缩像“ _]什么是 “也是两个词” 什么 _“和”s“（不是很好）。

['One', 'morning', 'when', 'Gregor', 'Samsa', 'woke', 'from', 'troubled', 'dreams', 'he', 'found', 'himself', 'transformed', 'in', 'his', 'bed', 'into', 'a', 'horrible', 'vermin', 'He', 'lay', 'on', 'his', 'armour', 'like', 'back', 'and', 'if', 'he', 'lifted', 'his', 'head', 'a', 'little', 'he', 'could', 'see', 'his', 'brown', 'belly', 'slightly', 'domed', 'and', 'divided', 'by', 'arches', 'into', 'stiff', 'sections', 'The', 'bedding', 'was', 'hardly', 'able', 'to', 'cover', 'it', 'and', 'seemed', 'ready', 'to', 'slide', 'off', 'any', 'moment', 'His', 'many', 'legs', 'pitifully', 'thin', 'compared', 'with', 'the', 'size', 'of', 'the', 'rest', 'of', 'him', 'waved', 'about', 'helplessly', 'as', 'he', 'looked', 'What', 's', 'happened', 'to', 'me', 'he', 'thought', 'It', 'wasn', 't', 'a', 'dream', 'His', 'room']

3.按空格分割并删除标点符号

注意：此示例是为 Python 3 编写的。

我们可能想要这些单词，但没有像逗号和引号那样的标点符号。我们也希望将宫缩保持在一起。

一种方法是通过空格将文档拆分为单词（如“ _2.按空白划分 _”），然后使用字符串翻译将所有标点符号替换为空（例如删除它）。

Python 提供了一个名为string.punctuation的常量，它提供了一个很好的标点字符列表。例如：

print(string.punctuation)

结果是：

!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

Python 提供了一个名为 translate（）的函数，它将一组字符映射到另一组。

我们可以使用函数 maketrans（）来创建映射表。我们可以创建一个空的映射表，但是这个函数的第三个参数允许我们列出在翻译过程中要删除的所有字符。例如：

table = str.maketrans('', '', string.punctuation)

我们可以将所有这些放在一起，加载文本文件，通过空格将其拆分为单词，然后翻译每个单词以删除标点符号。

# load text
filename = 'metamorphosis_clean.txt'
file = open(filename, 'rt')
text = file.read()
file.close()
# split into words by white space
words = text.split()
# remove punctuation from each word
import string
table = str.maketrans('', '', string.punctuation)
stripped = [w.translate(table) for w in words]
print(stripped[:100])

我们可以看到，这主要是产生了预期的效果。

像“_ 什么 ”这样的收缩已成为“ 什么 ”，但“ 盔甲式 _”已成为“armourlike”。

['One', 'morning', 'when', 'Gregor', 'Samsa', 'woke', 'from', 'troubled', 'dreams', 'he', 'found', 'himself', 'transformed', 'in', 'his', 'bed', 'into', 'a', 'horrible', 'vermin', 'He', 'lay', 'on', 'his', 'armourlike', 'back', 'and', 'if', 'he', 'lifted', 'his', 'head', 'a', 'little', 'he', 'could', 'see', 'his', 'brown', 'belly', 'slightly', 'domed', 'and', 'divided', 'by', 'arches', 'into', 'stiff', 'sections', 'The', 'bedding', 'was', 'hardly', 'able', 'to', 'cover', 'it', 'and', 'seemed', 'ready', 'to', 'slide', 'off', 'any', 'moment', 'His', 'many', 'legs', 'pitifully', 'thin', 'compared', 'with', 'the', 'size', 'of', 'the', 'rest', 'of', 'him', 'waved', 'about', 'helplessly', 'as', 'he', 'looked', 'Whats', 'happened', 'to', 'me', 'he', 'thought', 'It', 'wasnt', 'a', 'dream', 'His', 'room', 'a', 'proper', 'human']

如果您对正则表达式有所了解，那么您就知道事情可能会变得复杂。

4.规范化案例

将所有单词转换为一个案例是很常见的。

这意味着词汇量会缩小，但会丢失一些区别（例如“Apple”公司与“apple”水果是一个常用的例子）。

我们可以通过调用每个单词的 lower（）函数将所有单词转换为小写。

例如：

filename = 'metamorphosis_clean.txt'
file = open(filename, 'rt')
text = file.read()
file.close()
# split into words by white space
words = text.split()
# convert to lower case
words = [word.lower() for word in words]
print(words[:100])

运行该示例，我们可以看到所有单词现在都是小写的。

['one', 'morning,', 'when', 'gregor', 'samsa', 'woke', 'from', 'troubled', 'dreams,', 'he', 'found', 'himself', 'transformed', 'in', 'his', 'bed', 'into', 'a', 'horrible', 'vermin.', 'he', 'lay', 'on', 'his', 'armour-like', 'back,', 'and', 'if', 'he', 'lifted', 'his', 'head', 'a', 'little', 'he', 'could', 'see', 'his', 'brown', 'belly,', 'slightly', 'domed', 'and', 'divided', 'by', 'arches', 'into', 'stiff', 'sections.', 'the', 'bedding', 'was', 'hardly', 'able', 'to', 'cover', 'it', 'and', 'seemed', 'ready', 'to', 'slide', 'off', 'any', 'moment.', 'his', 'many', 'legs,', 'pitifully', 'thin', 'compared', 'with', 'the', 'size', 'of', 'the', 'rest', 'of', 'him,', 'waved', 'about', 'helplessly', 'as', 'he', 'looked.', '"what\'s', 'happened', 'to', 'me?"', 'he', 'thought.', 'it', "wasn't", 'a', 'dream.', 'his', 'room,', 'a', 'proper', 'human']

注意

清理文本非常困难，特定于问题，并且充满了权衡。

记住，简单就是更好。

更简单的文本数据，更简单的模型，更小的词汇表。您可以随时将事情变得更复杂，看看它是否会带来更好的模型技能。

接下来，我们将介绍 NLTK 库中的一些工具，它们提供的不仅仅是简单的字符串拆分。

使用 NLTK 进行标记和清理

自然语言工具包，简称 NLTK，是为工作和建模文本而编写的 Python 库。

它提供了用于加载和清理文本的良好工具，我们可以使用这些工具来准备我们的数据，以便使用机器学习和深度学习算法。

1.安装 NLTK

您可以使用自己喜欢的包管理器安装 NLTK，例如 pip：

sudo pip install -U nltk

安装之后，您将需要安装库使用的数据，包括一组很好的文档，您可以在以后用它们来测试 NLTK 中的其他工具。

有几种方法可以做到这一点，例如在脚本中：

import nltk
nltk.download()

或者从命令行：

python -m nltk.downloader all

有关安装和设置 NLTK 的更多帮助，请参阅：

2.分成句子

一个很好的有用的第一步是将文本分成句子。

一些建模任务更喜欢以段落或句子的形式输入，例如 word2vec。您可以先将文本拆分为句子，将每个句子分成单词，然后将每个句子保存到文件中，每行一个。

NLTK 提供sent_tokenize()函数将文本拆分成句子。

下面的示例将“metamorphosis_clean.txt”文件加载到内存中，将其拆分为句子，然后打印第一个句子。

# load data
filename = 'metamorphosis_clean.txt'
file = open(filename, 'rt')
text = file.read()
file.close()
# split into sentences
from nltk import sent_tokenize
sentences = sent_tokenize(text)
print(sentences[0])

运行这个例子，我们可以看到虽然文档被分成了句子，但每个句子仍然保留了原始文档中行的人工包装的新行。

一天早上，当格里高尔萨姆莎从困扰的梦中醒来时，他发现
自己在床上变成了一个可怕的害虫。

3.分成单词

NLTK 提供了一个名为word_tokenize()的函数，用于将字符串拆分为标记（名义上为单词）。

它根据空格和标点符号分割标记。例如，逗号和句点被视为单独的标记。收缩被分开（例如“_ 什么 ”变成“ 什么 _”“'s”）。行情保留，等等。

例如：

# load data
filename = 'metamorphosis_clean.txt'
file = open(filename, 'rt')
text = file.read()
file.close()
# split into words
from nltk.tokenize import word_tokenize
tokens = word_tokenize(text)
print(tokens[:100])

运行代码，我们可以看到标点符号现在是我们可以决定专门过滤掉的标记。

['One', 'morning', ',', 'when', 'Gregor', 'Samsa', 'woke', 'from', 'troubled', 'dreams', ',', 'he', 'found', 'himself', 'transformed', 'in', 'his', 'bed', 'into', 'a', 'horrible', 'vermin', '.', 'He', 'lay', 'on', 'his', 'armour-like', 'back', ',', 'and', 'if', 'he', 'lifted', 'his', 'head', 'a', 'little', 'he', 'could', 'see', 'his', 'brown', 'belly', ',', 'slightly', 'domed', 'and', 'divided', 'by', 'arches', 'into', 'stiff', 'sections', '.', 'The', 'bedding', 'was', 'hardly', 'able', 'to', 'cover', 'it', 'and', 'seemed', 'ready', 'to', 'slide', 'off', 'any', 'moment', '.', 'His', 'many', 'legs', ',', 'pitifully', 'thin', 'compared', 'with', 'the', 'size', 'of', 'the', 'rest', 'of', 'him', ',', 'waved', 'about', 'helplessly', 'as', 'he', 'looked', '.', '``', 'What', "'s", 'happened', 'to']

4.过滤掉标点符号

我们可以过滤掉我们不感兴趣的所有令牌，例如所有独立标点符号。

这可以通过遍历所有令牌并且仅保留那些全部是字母的令牌来完成。 Python 具有可以使用的函数 isalpha（）。例如：

# load data
filename = 'metamorphosis_clean.txt'
file = open(filename, 'rt')
text = file.read()
file.close()
# split into words
from nltk.tokenize import word_tokenize
tokens = word_tokenize(text)
# remove all tokens that are not alphabetic
words = [word for word in tokens if word.isalpha()]
print(words[:100])

运行这个例子，你不仅可以看到标点符号，而且“_ 盔甲式 ”和“ 的 _”等例子也被过滤掉了。

['One', 'morning', 'when', 'Gregor', 'Samsa', 'woke', 'from', 'troubled', 'dreams', 'he', 'found', 'himself', 'transformed', 'in', 'his', 'bed', 'into', 'a', 'horrible', 'vermin', 'He', 'lay', 'on', 'his', 'back', 'and', 'if', 'he', 'lifted', 'his', 'head', 'a', 'little', 'he', 'could', 'see', 'his', 'brown', 'belly', 'slightly', 'domed', 'and', 'divided', 'by', 'arches', 'into', 'stiff', 'sections', 'The', 'bedding', 'was', 'hardly', 'able', 'to', 'cover', 'it', 'and', 'seemed', 'ready', 'to', 'slide', 'off', 'any', 'moment', 'His', 'many', 'legs', 'pitifully', 'thin', 'compared', 'with', 'the', 'size', 'of', 'the', 'rest', 'of', 'him', 'waved', 'about', 'helplessly', 'as', 'he', 'looked', 'What', 'happened', 'to', 'me', 'he', 'thought', 'It', 'was', 'a', 'dream', 'His', 'room', 'a', 'proper', 'human', 'room']

5.过滤掉停用词（和管道）

停用词是那些对词组的深层含义没有贡献的词。

它们是最常见的词，例如：“”，“a”和“_ 是 _”。

对于某些应用程序（如文档分类），删除停用词可能有意义。

NLTK 提供了各种语言（例如英语）共同商定的停用词列表。它们可以按如下方式加载：

from nltk.corpus import stopwords
stop_words = stopwords.words('english')
print(stop_words)

您可以看到完整列表，如下所示：

['i', 'me', 'my', 'myself', 'we', 'our', 'ours', 'ourselves', 'you', 'your', 'yours', 'yourself', 'yourselves', 'he', 'him', 'his', 'himself', 'she', 'her', 'hers', 'herself', 'it', 'its', 'itself', 'they', 'them', 'their', 'theirs', 'themselves', 'what', 'which', 'who', 'whom', 'this', 'that', 'these', 'those', 'am', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had', 'having', 'do', 'does', 'did', 'doing', 'a', 'an', 'the', 'and', 'but', 'if', 'or', 'because', 'as', 'until', 'while', 'of', 'at', 'by', 'for', 'with', 'about', 'against', 'between', 'into', 'through', 'during', 'before', 'after', 'above', 'below', 'to', 'from', 'up', 'down', 'in', 'out', 'on', 'off', 'over', 'under', 'again', 'further', 'then', 'once', 'here', 'there', 'when', 'where', 'why', 'how', 'all', 'any', 'both', 'each', 'few', 'more', 'most', 'other', 'some', 'such', 'no', 'nor', 'not', 'only', 'own', 'same', 'so', 'than', 'too', 'very', 's', 't', 'can', 'will', 'just', 'don', 'should', 'now', 'd', 'll', 'm', 'o', 're', 've', 'y', 'ain', 'aren', 'couldn', 'didn', 'doesn', 'hadn', 'hasn', 'haven', 'isn', 'ma', 'mightn', 'mustn', 'needn', 'shan', 'shouldn', 'wasn', 'weren', 'won', 'wouldn']

您可以看到它们都是小写并删除了标点符号。

您可以将您的令牌与停用词进行比较并过滤掉它们，但您必须确保以相同的方式准备文本。

让我们通过一小段文本准备来演示这一点，包括：

加载原始文本。
分成代币。
转换为小写。
从每个令牌中删除标点符号。
过滤掉非字母的剩余令牌。
过滤掉停用词的令牌。

# load data
filename = 'metamorphosis_clean.txt'
file = open(filename, 'rt')
text = file.read()
file.close()
# split into words
from nltk.tokenize import word_tokenize
tokens = word_tokenize(text)
# convert to lower case
tokens = [w.lower() for w in tokens]
# remove punctuation from each word
import string
table = str.maketrans('', '', string.punctuation)
stripped = [w.translate(table) for w in tokens]
# remove remaining tokens that are not alphabetic
words = [word for word in stripped if word.isalpha()]
# filter out stop words
from nltk.corpus import stopwords
stop_words = set(stopwords.words('english'))
words = [w for w in words if not w in stop_words]
print(words[:100])

运行这个例子，我们可以看到除了所有其他变换之外，还删除了诸如“a”和“_ 到 _”之类的停用词。

我注意到我们仍然留下像“nt”这样的令牌。兔子洞很深;我们总能做得更多。

['one', 'morning', 'gregor', 'samsa', 'woke', 'troubled', 'dreams', 'found', 'transformed', 'bed', 'horrible', 'vermin', 'lay', 'armourlike', 'back', 'lifted', 'head', 'little', 'could', 'see', 'brown', 'belly', 'slightly', 'domed', 'divided', 'arches', 'stiff', 'sections', 'bedding', 'hardly', 'able', 'cover', 'seemed', 'ready', 'slide', 'moment', 'many', 'legs', 'pitifully', 'thin', 'compared', 'size', 'rest', 'waved', 'helplessly', 'looked', 'happened', 'thought', 'nt', 'dream', 'room', 'proper', 'human', 'room', 'although', 'little', 'small', 'lay', 'peacefully', 'four', 'familiar', 'walls', 'collection', 'textile', 'samples', 'lay', 'spread', 'table', 'samsa', 'travelling', 'salesman', 'hung', 'picture', 'recently', 'cut', 'illustrated', 'magazine', 'housed', 'nice', 'gilded', 'frame', 'showed', 'lady', 'fitted', 'fur', 'hat', 'fur', 'boa', 'sat', 'upright', 'raising', 'heavy', 'fur', 'muff', 'covered', 'whole', 'lower', 'arm', 'towards', 'viewer']

6.词干

词干指的是将每个单词缩减为其根或基数的过程。

例如“_ 钓鱼 ”，“ 捕捞 ”，“fisher”全部减少到茎“ 鱼 _”。

一些应用程序，如文档分类，可以从词干分析中受益，以便既减少词汇量又专注于文档的感觉或情感，而不是更深层的含义。

有许多词干算法，尽管流行的和长期存在的方法是 Porter Stemming 算法。这种方法可以通过 PorterStemmer 类在 NLTK 中使用。

例如：

# load data
filename = 'metamorphosis_clean.txt'
file = open(filename, 'rt')
text = file.read()
file.close()
# split into words
from nltk.tokenize import word_tokenize
tokens = word_tokenize(text)
# stemming of words
from nltk.stem.porter import PorterStemmer
porter = PorterStemmer()
stemmed = [porter.stem(word) for word in tokens]
print(stemmed[:100])

运行这个例子，你可以看到单词已经减少到它们的词干，例如“trouble”变成了“troubl”。您还可以看到，词干实现还将令牌减少为小写，可能是字表中的内部查找。

您还可以看到，词干实现还将令牌减少为小写，可能是字表中的内部查找。

['one', 'morn', ',', 'when', 'gregor', 'samsa', 'woke', 'from', 'troubl', 'dream', ',', 'he', 'found', 'himself', 'transform', 'in', 'hi', 'bed', 'into', 'a', 'horribl', 'vermin', '.', 'He', 'lay', 'on', 'hi', 'armour-lik', 'back', ',', 'and', 'if', 'he', 'lift', 'hi', 'head', 'a', 'littl', 'he', 'could', 'see', 'hi', 'brown', 'belli', ',', 'slightli', 'dome', 'and', 'divid', 'by', 'arch', 'into', 'stiff', 'section', '.', 'the', 'bed', 'wa', 'hardli', 'abl', 'to', 'cover', 'it', 'and', 'seem', 'readi', 'to', 'slide', 'off', 'ani', 'moment', '.', 'hi', 'mani', 'leg', ',', 'piti', 'thin', 'compar', 'with', 'the', 'size', 'of', 'the', 'rest', 'of', 'him', ',', 'wave', 'about', 'helplessli', 'as', 'he', 'look', '.', '``', 'what', "'s", 'happen', 'to'

在 NLTK 中有一套很好的词干和词形还原算法可供选择，如果将词语缩减到它们的根目录就是你的项目需要的东西。

其他文字清理注意事项

我们才刚开始。

因为本教程的源文本开头是相当干净的，所以我们跳过了许多您可能需要在自己的项目中处理的文本清理问题。

以下是清理文本时的其他注意事项的简短列表：

处理不适合内存的大型文档和大量文本文档。
从标记中提取文本，如 HTML，PDF 或其他结构化文档格式。
从其他语言到英语的音译。
将 Unicode 字符解码为规范化形式，例如 UTF8。
处理特定领域的单词，短语和首字母缩略词。
处理或删除数字，例如日期和金额。
找出并纠正常见的拼写错误和拼写错误。
…

这份名单可以继续使用。

希望您能够看到获得真正干净的文本是不可能的，我们真的可以根据我们拥有的时间，资源和知识做到最好。

“清洁”的概念实际上是由项目的特定任务或关注点定义的。

专家提示是在每次转换后不断检查您的令牌。我试图在本教程中表明，我希望你能理解这一点。

理想情况下，您可以在每次转换后保存新文件，以便花时间处理新表单中的所有数据。在花时间审查您的数据时，事情总是会突然发生。

你以前做过一些文字清理吗？您最喜欢的变换管道是什么？
请在下面的评论中告诉我。

清除词嵌入文本的提示

最近，自然语言处理领域已逐渐从单词模型和单词编码转向单词嵌入。

单词嵌入的好处在于，它们将每个单词编码为一个密集的向量，捕获有关其在训练文本中的相对含义的内容。

这意味着在嵌入空间中将自动学习诸如大小写，拼写，标点符号等单词的变体。反过来，这可能意味着您的文本所需的清洁量可能更少，也许与传统的文本清理完全不同。

例如，干缩词语或删除标点符号可能不再有意义。

Tomas Mikolov 是 word2vec 的开发者之一，word2vec 是一种流行的嵌入式方法。他建议在学习单词嵌入模型时只需要非常小的文本清理。

下面是他在回答有关如何最好地为 word2vec 准备文本数据的问题时的回答。

没有普遍的答案。这一切都取决于你打算使用的向量。根据我的经验，通常可以从单词中断开（或删除）标点符号，有时还会将所有字符转换为小写。人们也可以用一些单一的标记替换所有数字（可能大于某些常数），例如。

所有这些预处理步骤都旨在减少词汇量，而不删除任何重要内容（在某些情况下，当你小写某些单词时可能不是这样，即’Bush’与’bush’不同，而’Another’通常有与“另一个”的意义相同。词汇量越小，内存复杂度越低，估计的词的参数越稳健。您还必须以相同的方式预处理测试数据。

…

简而言之，如果你要进行实验，你会更好地理解这一切。

阅读 Google 网上论坛的完整帖子。

进一步阅读

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

摘要

在本教程中，您了解了如何在 Python 中清理文本或机器学习。

具体来说，你学到了：

如何开始开发自己非常简单的文本清理工具。
如何采取措施并使用 NLTK 库中更复杂的方法。
如何在使用像文字嵌入这样的现代文本表示方法时准备文本。

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

你有清洁文字的经验吗？
请在下面的评论中分享您的经验。

如何配置神经机器翻译的编解码器模型

原文： machinelearningmastery.com/configure-encoder-decoder-model-neural-machine-translation/

用于循环神经网络的编解码器架构在标准机器翻译基准上实现了最先进的结果，并且正在用于工业翻译服务的核心。

该模型很简单，但考虑到训练它所需的大量数据，调整模型中的无数设计决策以获得最佳表现问题可能实际上难以处理。值得庆幸的是，研究科学家已经使用 Google 规模的硬件为我们完成这项工作，并提供了一套启发式方法，用于如何配置编解码器模型进行神经机器翻译和一般的序列预测。

在这篇文章中，您将了解如何最好地配置编解码器循环神经网络以进行神经机器翻译和其他自然语言处理任务的详细信息。

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

Google 研究调查了编解码器模型中的每个模型设计决策，以隔离它们的影响。
设计决策的结果和建议，如字嵌入，编码器和解码器深度以及注意机制。
一组基本模型设计决策，可用作您自己的序列到序列项目的起点。

让我们开始吧。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

如何配置神经机器翻译的编解码器模型
照片由 Sporting Park ，保留一些权利。

神经机器翻译的编解码器模型

用于循环神经网络的编解码器架构正在取代基于经典短语的统计机器翻译系统，以获得最先进的结果。

作为证据，他们的 2016 年论文“谷歌的神经机器翻译系统：缩小人机翻译之间的差距”，谷歌现在将这种方法用于他们的谷歌翻译服务的核心。

这种架构的一个问题是模型很大，反过来需要非常大的数据集来训练。这具有模型训练的效果，需要数天或数周并且需要通常非常昂贵的计算资源。因此，关于不同设计选择对模型的影响及其对模型技能的影响的工作很少。

Denny Britz 等人明确解决了这个问题。在他们的 2017 年论文“大规模探索神经机器翻译架构。”在本文中，他们设计了标准英语 - 德语翻译任务的基线模型，并列举了一套不同的模型设计选择和描述它们对模型技能的影响。他们声称完整的实验耗时超过 250,000 GPU 计算时间，这至少可以说令人印象深刻。

我们报告了数百次实验运行的经验结果和方差数，相当于标准 WMT 英语到德语翻译任务的超过 250,000 GPU 小时数。我们的实验为构建和扩展 NMT 架构提供了新颖的见解和实用建议。

在这篇文章中，我们将看一下本文的一些发现，我们可以用来调整我们自己的神经机器翻译模型，以及一般的序列到序列模型。

有关编解码器架构和注意机制的更多背景信息，请参阅帖子：

编解码器长短期记忆网络
长期短期记忆循环神经网络的注意事项

基线模型

我们可以通过描述用作所有实验起点的基线模型来开始。

选择基线模型配置，使得模型在翻译任务上表现得相当好。

嵌入：512 维
RNN Cell：门控循环单元或 GRU
编码器：双向
编码器深度：2 层（每个方向 1 层）
解码器深度：2 层
注意：巴达瑙式
优化者：亚当
dropout：投入 20％

每个实验都从基线模型开始，并且不同的一个元素试图隔离设计决策对模型技能的影响，在这种情况下，BLEU 分数。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

用于神经机器翻译的编解码器架构
取自“神经机器翻译架构的大规模探索”。

嵌入尺寸

字嵌入用于表示输入到编码器的字。

这是一种分布式表示，其中每个单词被映射到固定大小的连续值向量。这种方法的好处是具有相似含义的不同单词将具有类似的表示。

通常在将模型拟合到训练数据上时学习该分布式表示。嵌入大小定义用于表示单词的向量的长度。人们普遍认为，较大的维度将导致更具表现力的表现形式，从而产生更好的技能。

有趣的是，结果表明，测试的最大尺寸确实达到了最佳效果，但增加尺寸的好处总体上是微不足道的。

[结果显示] 2048 维嵌入产生了总体最佳结果，它们只是略微提高了。即使是小型的 128 维嵌入也表现出色，而收敛速度几乎快了两倍。

建议：从小型嵌入开始，例如 128，可能会稍后增加尺寸，以提高技能。

RNN 细胞类型

通常使用三种类型的循环神经网络细胞：

简单的 RNN。
长期短期记忆或 LSTM。
门控循环单元或 GRU。

LSTM 的开发是为了解决简单 RNN 的消失梯度问题，这限制了深 RNN 的训练。 GRU 的开发旨在简化 LSTM。

结果显示 GRU 和 LSTM 均明显优于 Simple RNN，但 LSTM 总体上更好。

在我们的实验中，LSTM 细胞始终优于 GRU 细胞

建议：在您的模型中使用 LSTM RNN 单位。

编解码器深度

通常，深层网络被认为比浅层网络具有更好的表现。

关键是要在网络深度，模型技能和训练时间之间找到平衡点。这是因为如果对技能的好处很小，我们通常没有无限的资源来训练非常深的网络。

作者探讨了编码器和解码器模型的深度以及对模型技能的影响。

当涉及编码器时，发现深度对技能没有显着影响，更令人惊讶的是，1 层单向模型仅比 4 层单向配置略差。双层双向编码器的表现略优于其他测试配置。

我们没有发现明确的证据表明超过两层的编码器深度是必要的。

建议：使用 1 层双向编码器并扩展到 2 个双向层，以提高技能。

解码器出现了类似的故事。具有 1,2 和 4 层的解码器之间的技能在 4 层解码器略微更好的情况下有所不同。 8 层解码器在测试条件下没有收敛。

在解码器方面，较深的模型以较小的幅度优于较浅的模型。

建议：使用 1 层解码器作为起点，并使用 4 层解码器以获得更好的结果。

编码器输入方向

源文本序列的顺序可以通过多种方式提供给编码器：

前进或正常。
逆转。
前进和后退都在同一时间。

作者探讨了输入序列顺序对模型技能的影响，比较了各种单向和双向配置。

通常，他们证实了先前的发现，即反向序列优于正向序列，并且双向略好于反向序列。

…双向编码器通常优于单向编码器，但不是很大。具有反向源的编码器始终优于其未反转的对应物。

建议：使用反向顺序输入序列或移动到双向以获得模型技能的小升力。

注意机制

朴素的编解码器模型的问题在于编码器将输入映射到固定长度的内部表示，解码器必须从该表示产生整个输出序列。

注意是对模型的改进，其允许解码器在输出序列中输出每个字时“注意”输入序列中的不同字。

作者研究了简单注意机制的一些变化。结果表明，注意力会比没有注意力的情况下产生明显更好的表现。

虽然我们确实期望基于注意力的模型明显优于没有注意机制的模型，但我们对[无注意]模型的表现有多么惊讶。

Bahdanau 等人描述的简单加权平均风格注意。在他们的 2015 年论文中，“神经机器翻译通过联合学习对齐和翻译”被发现表现最佳。

推荐：使用注意力并更喜欢 Bahdanau 式加权平均风格的关注。

推理

在神经机器翻译系统中通常使用集束搜索来对模型输出的序列中的单词的概率进行采样。

光束宽度越宽，搜索越详尽，并且据信，结果越好。

结果表明，3-5 的适度集束宽度表现最佳，通过使用长度惩罚可以非常轻微地改善。作者通常建议在每个特定问题上调整集束宽度。

我们发现，良好调谐的光束搜索对于获得良好的结果至关重要，并且它可以导致多个 BLEU 点的一致增益。

推荐：从贪婪搜索开始（集束= 1）并根据您的问题进行调整。

最终模型

作者将他们的研究结果汇总到一个“最佳模型”中，并将该模型的结果与其他表现良好的模型和最先进的结果进行比较。

该模型的具体配置总结在下表中，摘自论文。在为 NLP 应用程序开发自己的编解码器模型时，这些参数可以作为一个好的或最好的起点。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

最终 NMT 模型的模型配置总结
摘自“神经机器翻译架构的大规模探索”。

该系统的结果显示令人印象深刻，并且通过更简单的模型获得了接近最新技术的技能，这不是本文的目标。

…我们确实表明，通过仔细的超参数调整和良好的初始化，可以在标准 WMT 基准测试中实现最先进的表现

重要的是，作者将所有代码作为一个名为 tf-seq2seq 的开源项目提供。由于其中两位作者是 Google Brain 驻留计划的成员，他们的工作在 Google Research 博客上公布，标题为“介绍 tf-seq2seq：TensorFlow 中的开源序列到序列框架” ，2017 年。

进一步阅读

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

神经机器翻译架构的大规模探索，2017。
Denny Britz 主页
WildML 博客
介绍 tf-seq2seq：TensorFlow 中的开源序列到序列框架，2017。
tf-seq2seq：Tensorflow 的通用编解码器框架
tf-seq2seq 项目文件
tf-seq2seq 教程：神经机器翻译背景
神经机器翻译通过联合学习调整和翻译，2015。

摘要

在这篇文章中，您了解了如何最好地配置编解码器循环神经网络，用于神经机器翻译和其他自然语言处理任务。

具体来说，你学到了：

Google 研究调查了编解码器模型中的每个模型设计决策，以隔离它们的影响。
设计决策的结果和建议，如字嵌入，编码器和解码器深度以及注意机制。
一组基本模型设计决策，可用作您自己序列的起点，以对项目进行排序。

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

如何开始深度学习自然语言处理（7 天迷你课程）

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

NLP 速成课的深度学习。

在 7 天内为您的文本数据项目带来深度学习方法。

我们充斥着文字，包括书籍，论文，博客，推文，新闻，以及来自口头发言的越来越多的文字。

处理文本很难，因为它需要利用来自不同领域的知识，如语言学，机器学习，统计方法，以及如今的深度学习。

深度学习方法开始在一些具有挑战性的自然语言处理问题上超越经典和统计方法，使用单一和简单的模型。

在本速成课程中，您将了解如何在 7 天内使用 Python 开始并自信地开发自然语言处理问题的深度学习。

这是一个重要且重要的帖子。您可能想要将其加入书签。

让我们开始吧。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

如何开始深度学习自然语言处理
照片由 Daniel R. Blume ，保留一些权利。

谁是这个速成课？

在我们开始之前，让我们确保您在正确的位置。

以下列表提供了有关本课程设计对象的一般指导原则。

如果你没有完全匹配这些点，请不要惊慌，你可能只需要在一个或另一个区域刷新以跟上。

你需要知道：

你需要了解基本的 Python，NumPy 和 Keras 的深度学习方法。

你不需要知道：

你不需要成为一个数学家！
你不需要成为一名深度学习专家！
你不需要成为一名语言学家！

这个速成课程将带您从了解机器学习的开发人员到可以为您自己的自然语言处理项目带来深度学习方法的开发人员。

注意：此速成课程假设您有一个有效的 Python 2 或 3 SciPy 环境，至少安装了 NumPy，Pandas，scikit-learn 和 Keras 2。如果您需要有关环境的帮助，可以按照此处的分步教程进行操作：

如何使用 Anaconda 设置用于机器学习和深度学习的 Python 环境

速成课程概述

这个速成课程分为 7 节课。

您可以每天完成一节课（推荐）或在一天内完成所有课程（硬核）。这取决于你有空的时间和你的热情程度。

以下是 7 个课程，通过深入学习 Python 中的自然语言处理，可以帮助您开始并提高工作效率：

第 01 课：深度学习和自然语言
第 02 课：清理文本数据
第 03 课：Bag-of-Words 模型
第 04 课：词嵌入表示
第 05 课：学习嵌入
第 06 课：文本分类
第 07 课：电影评论情感分析项目

每节课可能需要 60 秒或 30 分钟。花点时间，按照自己的进度完成课程。在下面的评论中提出问题甚至发布结果。

课程期望你去学习如何做事。我会给你提示，但每节课的部分内容是强迫你学习去哪里寻求帮助以及深入学习，自然语言处理和 Python 中最好的工具（提示，我直接在这个博客上有所有答案，使用搜索框）。

我确实以相关帖子的链接形式提供了更多帮助，因为我希望你建立一些信心和惯性。

在评论中发布您的结果，我会为你欢呼！

挂在那里，不要放弃。

注：这只是一个速成课程。有关更多细节和 30 个充实的教程，请参阅我的书，主题为“ 深度学习自然语言处理”。

第一课：深度学习和自然语言

在本课程中，您将发现自然语言，深度学习的简明定义以及使用文本数据进行深度学习的承诺。

自然语言处理

自然语言处理（简称 NLP）被广义地定义为通过软件自动操纵自然语言，如语音和文本。

自然语言处理的研究已经存在了 50 多年，随着计算机的兴起，语言学领域逐渐兴起。

理解文本的问题没有解决，也可能永远不会，主要是因为语言混乱。规则很少。然而，我们可以在大多数时间轻松地相互理解。

深度学习

深度学习是机器学习的一个子领域，涉及受大脑结构和功能激发的算法，称为人工神经网络。

深度学习的一个特性是这些类型的模型的表现通过增加其深度或代表能力来训练它们的更多示例而得到改善。

除了可扩展性之外，深度学习模型的另一个经常被引用的好处是它们能够从原始数据执行自动特征提取，也称为特征学习。

NLP 深度学习的承诺

深度学习方法在自然语言中很受欢迎，主要是因为它们兑现了他们的承诺。

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

自然语言处理深度学习的三个关键承诺如下：

特色学习的承诺。也就是说，深度学习方法可以从模型所需的自然语言中学习特征，而不是要求专家指定和提取特征。
持续改进的承诺。也就是说，自然语言处理中的深度学习的表现基于实际结果，并且改进似乎在继续并且可能加速。
端到端模型的承诺。也就是说，大型端到端深度学习模型可以适应自然语言问题，提供更通用，表现更好的方法。

自然语言处理不是“解决”，但需要深入学习才能使您掌握该领域中许多具有挑战性的问题的最新技术。

你的任务

在本课程中，您必须研究并列出深度学习方法在自然语言处理领域的 10 个令人印象深刻的应用。如果您可以链接到演示该示例的研究论文，则可获得奖励积分。

在下面的评论中发表您的答案。我很乐意看到你发现了什么。

第 02 课：清理文本数据

在本课程中，您将了解如何加载和清理文本数据，以便可以手动和使用 NLTK Python 库进行建模。

文字很乱

你不能直接从原始文本到适合机器学习或深度学习模型。

您必须首先清理文本，这意味着将其拆分为单词并规范化问题，例如：

大写和小写字符。
单词内部和周围的标点符号。
金额和日期等数字。
拼写错误和区域变化。
Unicode 字符
以及更多…

手动标记

一般来说，我们指的是将原始文本转换为我们可以建模为“分词”的东西的过程，其中我们留下了单词列表或“标记”。

我们可以手动开发 Python 代码来清理文本，并且这通常是一种很好的方法，因为每个文本数据集必须以独特的方式进行分词。

例如，下面的代码片段将加载文本文件，按空格分割标记并将每个标记转换为小写。

filename = '...'
file = open(filename, 'rt')
text = file.read()
file.close()
# split into words by white space
words = text.split()
# convert to lowercase
words = [word.lower() for word in words]

您可以想象如何扩展此代码段以处理和规范化 Unicode 字符，删除标点符号等。

NLTK 分词

许多用于标记原始文本的最佳实践已被捕获并在名为 Natural Language Toolkit 或 NLTK 的 Python 库中提供。

您可以使用 pip 在命令行上键入以下命令来安装此库：

sudo pip install -U nltk

安装后，还必须通过 Python 脚本安装库使用的数据集：

import nltk
nltk.download()

或通过命令行：

python -m nltk.downloader all

安装后，您可以使用 API来标记文本。例如，下面的代码段将加载并分词 ASCII 文本文件。

# load data
filename = '...'
file = open(filename, 'rt')
text = file.read()
file.close()
# split into words
from nltk.tokenize import word_tokenize
tokens = word_tokenize(text)

此库中有许多工具，您可以使用自己的手动方法进一步优化干净的令牌，例如删除标点，删除停用词，词干等等。

你的任务

您的任务是在 Project Gutenberg 网站上找到一本免费的经典书籍，下载书籍的 ASCII 版本并将文本分词并将结果保存到新文件中。探索手动和 NLTK 方法的加分点。

在下面的评论中发布您的代码。我很想看看你选择哪本书以及你如何选择它来标记它。

第 03 课：词袋模型

在本课程中，您将发现单词模型包以及如何使用此模型对文本进行编码，以便您可以使用 scikit-learn 和 Keras Python 库来训练模型。

一袋词

词袋模型是一种在使用机器学习算法对文本建模时表示文本数据的方式。

该方法非常简单和灵活，并且可以以多种方式用于从文档中提取特征。

词袋是文本的表示，用于描述文档中单词的出现。

选择词汇表，其中可能丢弃一些不经常使用的词。然后使用对于词汇表中的每个单词具有一个位置的向量以及在文档中出现（或不出现）的每个已知单词的分数来表示给定的文本文档。

它被称为单词的“包”，因为有关文档中单词的顺序或结构的任何信息都被丢弃。该模型仅关注文档中是否出现已知单词，而不是文档中的位置。

带有 scikit-learn 的词汇

用于机器学习的 scikit-learn Python 库提供了用于为词袋模型编码文档的工具。

可以创建编码器的实例，在文本文档集上训练，然后反复使用以编码训练，测试，验证以及需要为您的模型编码的任何新数据。

有一个编码器根据他们的计数得分单词，称为 CountVectorizer，一个用于使用每个单词的哈希函数来减少称为 HashingVectorizer 的向量长度，以及一个使用基于文档中单词出现的得分和反向出现的单词。所有文件称为 TfidfVectorizer。

下面的代码段显示了如何训练 TfidfVectorizer 字袋编码器并使用它来编码多个小文本文档。

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

与 Keras 的词袋

用于深度学习的 Keras Python 库还提供了使用 Tokenizer 类中的 bag-of words-model 对文本进行编码的工具。

如上所述，编码器必须在源文档上进行训练，然后可用于对将来的训练数据，测试数据和任何其他数据进行编码。 API 还具有在对单词进行编码之前执行基本分词的优点。

下面的代码段演示了如何使用 Keras API 和单词的“计数”类型评分来训练和编码一些小型文本文档。

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)

你的任务

您在本课程中的任务是尝试使用 scikit-learn 和 Keras 方法为单词包模型编码小型设计文本文档。如果您使用文档的小型标准文本数据集进行练习并执行数据清理作为准备工作的一部分，则可获得奖励积分。

在下面的评论中发布您的代码。我很想看看您探索和演示的 API。

第 04 课：词嵌入表示法

在本课程中，您将发现嵌入分布式表示的单词以及如何使用 Gensim Python 库开发单词嵌入。

词嵌入

词嵌入是一种单词表示，允许具有相似含义的单词具有相似的表示。

它们是文本的分布式表示，这可能是深度学习方法在挑战自然语言处理问题上令人印象深刻的表现的关键突破之一。

单词嵌入方法从文本语料库中学习预定义固定大小的词汇表的实值向量表示。

训练词嵌入

您可以使用 Gensim Python 库训练嵌入分布式表示的单词，以进行主题建模。

Gensim 提供了 word2vec 算法的实现，该算法是在 Google 开发的，用于快速训练来自文本文档的字嵌入表示，

您可以在命令行中键入以下内容，使用 pip 安装 Gensim：

pip install -U gensim

下面的代码段显示了如何定义一些人为的句子并在 Gensim 中训练一个嵌入表示的单词。

from gensim.models import Word2Vec
# define training data
sentences = [['this', 'is', 'the', 'first', 'sentence', 'for', 'word2vec'],
			['this', 'is', 'the', 'second', 'sentence'],
			['yet', 'another', 'sentence'],
			['one', 'more', 'sentence'],
			['and', 'the', 'final', 'sentence']]
# train model
model = Word2Vec(sentences, min_count=1)
# summarize the loaded model
print(model)
# summarize vocabulary
words = list(model.wv.vocab)
print(words)
# access vector for one word
print(model['sentence'])

使用嵌入

一旦经过训练，嵌入就可以保存到文件中，作为另一个模型的一部分，例如深度学习模型的前端。

您还可以绘制单词的分布式表示的投影，以了解模型如何相信单词的相关性。您可以使用的常见投影技术是主成分分析或 PCA，可在 scikit-learn 中使用。

下面的代码段显示了如何训练单词嵌入模型，然后绘制词汇表中所有单词的二维投影。

from gensim.models import Word2Vec
from sklearn.decomposition import PCA
from matplotlib import pyplot
# define training data
sentences = [['this', 'is', 'the', 'first', 'sentence', 'for', 'word2vec'],
			['this', 'is', 'the', 'second', 'sentence'],
			['yet', 'another', 'sentence'],
			['one', 'more', 'sentence'],
			['and', 'the', 'final', 'sentence']]
# train model
model = Word2Vec(sentences, min_count=1)
# fit a 2D PCA model to the vectors
X = model[model.wv.vocab]
pca = PCA(n_components=2)
result = pca.fit_transform(X)
# create a scatter plot of the projection
pyplot.scatter(result[:, 0], result[:, 1])
words = list(model.wv.vocab)
for i, word in enumerate(words):
	pyplot.annotate(word, xy=(result[i, 0], result[i, 1]))
pyplot.show()

你的任务

您在本课程中的任务是使用 Gensim 在文本文档上训练单词嵌入，例如来自 Project Gutenberg 的书籍。如果您可以生成常用单词的图表，则可以获得奖励积分。

在下面的评论中发布您的代码。我很想看看你选择哪本书以及你学习嵌入的任何细节。

第 05 课：学习嵌入

在本课程中，您将学习如何学习嵌入字的分布式表示的单词，作为拟合深度学习模型的一部分

嵌入层

Keras 提供了一个嵌入层，可用于文本数据的神经网络。

它要求输入数据是整数编码的，以便每个单词由唯一的整数表示。可以使用 Keras 提供的 Tokenizer API 来执行该数据准备步骤。

使用随机权重初始化嵌入层，并将学习训练数据集中所有单词的嵌入。你必须指定input_dim，这是词汇量的大小，output_dim是嵌入的向量空间的大小，可选择input_length是输入序列中的单词数。

layer = Embedding(input_dim, output_dim, input_length=??)

或者，更具体地，200 个单词的词汇表，32 维的分布式表示和 50 个单词的输入长度。

layer = Embedding(200, 32, input_length=50)

嵌入模型

嵌入层可以用作深度学习模型的前端，以提供丰富的单词分布式表示，重要的是，这种表示可以作为训练深度学习模型的一部分来学习。

例如，下面的代码片段将定义和编译具有嵌入输入层和密集输出层的神经网络，用于文档分类问题。

当模型被训练有关填充文档及其相关输出标签的示例时，网络权重和分布式表示将被调整到特定数据。

from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Flatten
from keras.layers.embeddings import Embedding
# define problem
vocab_size = 100
max_length = 32
# define the model
model = Sequential()
model.add(Embedding(vocab_size, 8, input_length=max_length))
model.add(Flatten())
model.add(Dense(1, activation='sigmoid'))
# compile the model
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc'])
# summarize the model
print(model.summary())

还可以使用预先训练的权重来初始化嵌入层，例如由 Gensim 准备的权重，并将层配置为不可训练的。如果可以使用非常大的文本语料库来预先训练单词嵌入，则该方法可能是有用的。

你的任务

您在本课程中的任务是设计一个小型文档分类问题，其中包含 10 个文档，每个文档包含一个句子以及相关的正面和负面结果标签，并使用单词嵌入这些数据来训练网络。请注意，在使用 Keras pad_sequences（）函数训练模型之前，需要将每个句子填充到相同的最大长度。如果您加载使用 Gensim 准备的预训练单词嵌入，则可获得奖励积分。

在下面的评论中发布您的代码。我很想看看你设法的句子和模特的技巧。

第 06 课：文本分类

在本课程中，您将发现标准的深度学习模型，用于对文本情感分析等问题上使用的文本进行分类。

文件分类

文本分类描述了一类问题，例如预测推文和电影评论的情感，以及将电子邮件分类为垃圾邮件。

它是自然语言处理的一个重要领域，也是开始在文本数据上使用深度学习技术的好地方。

深度学习方法在文本分类方面证明非常好，在一系列标准学术基准问题上实现了最先进的结果。

嵌入+ CNN

文本分类的操作方法涉及使用单词嵌入来表示单词，使用卷积神经网络或 CNN 来学习如何区分分类问题的文档。

该架构由三个关键部分组成：

单词嵌入模型：单词的分布式表示，其中具有相似含义的不同单词（基于其用法）也具有相似的表示。
卷积模型：一种特征提取模型，用于学习从使用单词嵌入表示的文档中提取显着特征。
完全连接模型：根据预测输出解释提取的特征。

这种类型的模型可以在 Keras Python 深度学习库中定义。下面的代码段显示了一个深度学习模型示例，用于将文本文档分类为两个类之一。

# define problem
vocab_size = 100
max_length = 200
# define model
model = Sequential()
model.add(Embedding(vocab_size, 100, input_length=max_length))
model.add(Conv1D(filters=32, kernel_size=8, activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(Flatten())
model.add(Dense(10, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
print(model.summary())