精通-Spacy-全-
精通 Spacy(全)
原文:
annas-archive.org/md5/cab19785f4c5c60f7cc1edeb81e591d8译者:飞龙
前言
技术文献中常常充斥着冗长的代码列表、肤浅的解释和几乎触及不到表面概念。这本书正是有意偏离这种趋势。在这里,你不仅能找到代码,还能找到上下文——解释、理由和实用示例,这些内容将带你超越图书馆文档所能提供的内容。
为什么选择 spaCy?spaCy 是当今最强大和最通用的 NLP 库之一。它因其速度、易用性和适应广泛应用的灵活性而备受瞩目,从学术研究到企业级解决方案。但 spaCy 的真正潜力只有在超越基本使用并深入其架构、功能和可扩展性时才能得到释放。本书旨在成为你在这一旅程中的指南。
本书与众不同的地方在于其对现实应用性的关注。从一开始,我们就将专注于创建具体的 NLP 工作流程和组件,处理诸如句法解析、语义分析和训练自定义命名实体识别(NER)模型等任务。你不仅将学习如何使用 spaCy 的核心功能,还将学习如何整合大型语言模型(LLMs)和使用最新的数据和管理模型工具。
不论你是经验丰富的数据科学家还是 NLP 爱好者,本书旨在使复杂主题变得易于理解、引人入胜——最重要的是——实用。我们将一步步介绍 spaCy 的功能,并将它们转化为你可以应用于自己项目的可操作技能。
本书面向的对象
本书非常适合数据科学家、NLP 开发者和渴望掌握 spaCy 以应用于高级 NLP 应用的开发者。你应该对 NLP 概念和 Python 编程有基本的了解。本书结束时,你将能够构建高效且具有影响力的 NLP 解决方案,无论是提升现有技能还是首次踏入高级 NLP 的世界。
本书涵盖的内容
第一章 ,spaCy 入门,涵盖了库的概述、如何安装它,以及如何使用 displaCy 可视化文本。
第二章 ,spaCy 核心操作,涵盖了 spaCy 处理管道的基本知识。我们将深入探讨Tokenizer,通常是我们的文本处理管道的第一个组件。我们还将了解 spaCy 的主要容器,如Doc、Token和Span。
第三章 ,提取语言特征,涵盖了(不出所料)语言特征。我们将学习如何使用 spaCy 的词性标注和依存句法标注来分析和提取文本信息。
第四章 ,掌握基于规则的匹配,探讨了如何使用语言特征通过 spaCy 的匹配器和SpanRuler组件创建提取模块。
第五章 ,使用 spaCy 管道提取语义表示,介绍了如何使用您在第三章和第四章中学到的所有知识进行话语的语义解析,创建您的第一个自定义 spaCy 管道组件以提取文本的意图。
第六章 ,使用 spaCy 与 Transformers,教您如何使用spacy-transformers训练自定义 spaCy 组件。在本章中,您将了解 spaCy 配置文件和 spaCy 的 CLI,这些对于维护和重现 NLP 管道非常有用。
第七章 ,使用 spacy-llm 增强 NLP 任务,介绍了如何在 NLP 管道中使用 LLMs(大型语言模型)与spacy-llm。
第八章 ,使用您自己的数据训练 NER 组件,将重点介绍如何标记您自己的数据以训练 NER 组件。我们将看到如何准备数据,并了解标注工具,包括来自 spaCy 背后的团队 Explosion 的标注工具 Prodigy。
第九章 ,使用 Weasel 创建端到端 spaCy 工作流程,介绍了如何使用 Weasel,这是一个帮助我们创建可重复和结构良好的项目工作流程的工具。我们还将看到如何使用 DVC Studio 来管理模型。DVC 是另一个用于数据/模型版本控制和实验跟踪的酷开源项目。
第十章 ,使用 spaCy 训练实体链接模型,涵盖了 NLP 中的实体链接任务以及创建高质量 NLP 训练数据集的最佳实践。您还将学习如何使用自定义语料库读取器来训练 spaCy 组件。
第十一章 ,将 spaCy 与第三方库集成,介绍了如何将 spaCy 项目与 Streamlit 集成以构建美观的 Web 界面,以及与 FastAPI 集成以构建 NLP 模型的 API。
为了充分利用这本书
首先,您需要在您的系统上安装并运行 Python 3。所有代码示例都使用 spaCy v3.7。对于辅助库,如 pandas,可以使用pip上可用的最新版本。
| **本书涵盖的软件/硬件` | `操作系统要求** |
|---|---|
| Python >= 3.12 | Windows, macOS, 或 Linux |
| spaCy v3.7 | |
| spacy-transformers == 1.3.5 | |
| spacy-streamlit >= 1.0.6 | |
| FastAPI >= 0.112.0 |
如果您使用的是这本书的数字版,我们建议您亲自输入代码或从书的 GitHub 仓库(下一节中有一个链接)获取代码。这样做将帮助您避免与代码复制粘贴相关的任何潜在错误。
下载示例代码文件
您可以从 GitHub 下载本书的示例代码文件 github.com/PacktPublishing/Mastering-spaCy-Second-Edition 。如果代码有更新,它将在 GitHub 仓库中更新。
我们还有其他来自我们丰富的图书和视频目录的代码包可供选择,请访问 github.com/PacktPublishing/ 。查看它们!
使用的约定
本书使用了多种文本约定。
文本中的代码:表示文本中的代码单词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter/X 用户名。以下是一个示例:“spaCy 标记器的输入是 Unicode 文本,结果是Doc对象。”
代码块设置如下:
import spacy
nlp = spacy.load("en_core_web_md")
doc = nlp("It's been a crazy week!!!")
print([token.text for token in doc])
任何命令行输入或输出都应如下编写:
python3 -m pip install dvc dvc_gdrive
粗体:表示新术语、重要单词或屏幕上看到的单词。例如,菜单或对话框中的单词以粗体显示。以下是一个示例:“确定句子边界比标记化更复杂。因此,spaCy 使用依存句法分析器进行句子分割。”
小贴士或重要注意事项
看起来是这样的。
联系我们
我们始终欢迎读者的反馈。
一般反馈:如果您对本书的任何方面有疑问,请通过电子邮件发送给我们 customercare@packtpub.com,并在邮件主题中提及书名。
勘误:尽管我们已经尽一切努力确保内容的准确性,但错误仍然可能发生。如果您在这本书中发现了错误,我们将不胜感激,如果您能向我们报告这一点。请访问 www.packtpub.com/support/errata 并填写表格。
盗版:如果您在互联网上遇到我们作品的任何形式的非法副本,如果您能提供位置地址或网站名称,我们将不胜感激。请通过电子邮件发送给我们 copyright@packt.com,并提供材料的链接。
如果您有兴趣成为作者:如果您在某个主题上具有专业知识,并且您有兴趣撰写或为本书做出贡献,请访问 authors.packtpub.com 。
分享您的想法
读完 Mastering spaCy 后,我们非常乐意听到您的想法!请 点击此处直接进入此书的亚马逊评论页面 并分享您的反馈。
您的评论对我们和科技社区都至关重要,并将帮助我们确保我们提供高质量的内容。
下载本书的免费 PDF 副本
感谢您购买本书!
您喜欢在路上阅读,但无法携带您的印刷书籍到处走?
您的电子书购买是否与您选择的设备不兼容?
别担心,现在每购买一本 Packt 书籍,你都可以免费获得该书的 DRM-free PDF 版本。
在任何地方、任何设备上阅读。直接从你喜欢的技术书籍中搜索、复制和粘贴代码到你的应用程序中。
优惠远不止于此,你还可以获得独家折扣、时事通讯和每日免费内容的访问权限。
按照以下简单步骤获取优惠:
- 扫描下面的二维码或访问以下链接
![img]()
packt.link/free-ebook/978-1-83588-046-3
-
提交你的购买证明
-
就这些!我们将直接将你的免费 PDF 和其他优惠发送到你的邮箱。
第一部分:spaCy 入门
本节将介绍使用 spaCy 的自然语言处理(NLP)的基础知识,并指导你完成设置环境的初始步骤。你将从学习 spaCy 的核心功能开始,包括其处理管道和数据结构,为后续更高级的主题提供坚实的基础。
本部分包含以下章节:
-
第一章 ,spaCy 入门
-
第二章 ,使用 spaCy 进行核心操作
第一章:开始使用 spaCy
在本章中,我们将全面介绍使用 Python 和 spaCy 进行自然语言处理(NLP)应用开发。首先,我们将了解 NLP 开发如何与 Python 相辅相成,以及 spaCy 作为 Python 库提供的内容概述。
在热身之后,您将快速开始使用 spaCy,通过下载库和加载模型。然后,您将探索 spaCy 的流行可视化工具 displaCy,以可视化语言数据并探索其各种特性。
在本章结束时,您将了解使用 spaCy 可以实现什么,并对其关键特性有一个概述。您还将熟悉您的开发环境,该环境将用于本书的所有章节。
我们将涵盖以下主题:
-
spaCy 概述
-
安装 spaCy
-
安装 spaCy 的语言模型
-
使用 displaCy 进行可视化
技术要求
本章的代码可以在 github.com/PacktPublishing/Mastering-spaCy-Second-Edition 找到。
spaCy 概述
自然语言处理(NLP)是人工智能的一个子领域,它分析文本、语音和其他形式的人类生成语言数据。人类语言很复杂——即使是简短的段落也包含对先前单词的引用、指向现实世界对象的指针、文化引用以及作者或说话者的个人经历。图 1.1 .1 展示了这样一个例子句子,其中包含对相对日期的引用(最近),只有知道说话者的人才能解决的短语(关于说话者父母居住的城市),以及对世界有一般知识的人(城市是人类共同生活的地方):

图 1.1 – 包含许多认知和文化方面的人类语言示例
我们如何使用计算机处理如此复杂的结构?使用 spaCy,我们可以轻松地用统计模型建模自然语言,并处理语言特征,将文本转换为结构良好的表示。本书为您提供了所有必要的背景和工具,以从文本中提取意义。
2022 年 11 月 ChatGPT 的推出,全世界都为模型能够以与我们人类非常相似的方式理解指令和生成文本的能力而感到震惊。然而,就像食品加工器可以在几秒钟内切碎、切片和搅拌一样,它并不总是每个工作的最佳工具。有时,你只需要一把简单的厨房刀就能快速高效地完成任务。同样,虽然大型语言模型(LLMs)如 ChatGPT 功能强大且多才多艺,但它们对于许多需要专注、高效和可解释解决方案的真实世界应用来说可能是过度配置的。
因此,了解如 spaCy 之类的库非常有价值。spaCy 提供了专门用于 NLP 的工具,允许你快速处理特定任务,而无需 LLM 的复杂性和资源需求。并且,通过spacy-llm,你还可以将 LLM 组件纳入 spaCy 管道中。无论你是构建命名实体识别器、文本分类器还是分词器,spaCy 都提供了实用的、优化良好的厨房刀,能够高效地解决复杂语言任务。了解何时以及如何使用正确的工具,在构建有效的 NLP 系统中可以起到决定性作用。
spaCy 库的高级概述
spaCy 是一个开源的 Python 库,旨在帮助我们完成实际工作。它非常快,因为其性能关键部分是用 Cython 实现的,允许优化速度同时仍然易于与 Python 一起使用。spaCy 附带预训练的语言模型和 75 多种语言的词向量。
另一个著名且经常使用的 Python 库是自然语言工具包(NLTK)。NLK 的焦点是为学生和研究人员提供一个语言处理的概念。spaCy 从第一天起就专注于提供生产就绪的代码。你可以期待模型在真实世界数据上的表现,代码的效率,以及能够在合理的时间内处理大量文本数据的能力。
spaCy 专注于真实世界 NLP 应用的事实并不仅仅是因为其处理速度,还因为使用它构建的应用程序易于维护代码。在 2019 年 PyCon 印度大会的主题演讲“让他们编写代码”(幻灯片可在speakerdeck.com/inesmontani/let-them-write-code-keynote-pycon-india-2019)中,Ines Montani(spaCy 的核心开发者之一)讨论了 spaCy 创建背后的哲学。spaCy 设计背后的主要思想是“帮助人们完成工作”。一些最糟糕的开发者体验是“想要完全 集成解决方案的工具。”
使用 spaCy,我们可以将每个 NLP 应用程序分解为管道组件,重用预构建的库组件或创建我们自己的自定义组件。我们将在第五章中深入探讨 spaCy 管道。spaCy 容器对象(Doc、Token和Span)使文本的处理和加工变得无缝(在第二章中详细介绍)并且我们可以使用 spaCy 的配置系统(spacy.io/usage/training#config)来训练统计模型,这带来了模块化、灵活性和清晰的声明性配置,使得 NLP 组件的定制和重用变得容易(第六章)。SpaCy 还使得在我们的 NLP 处理管道中集成使用 LLMs 的组件变得容易(第七章),并且还帮助我们使用Weasel(第九章)管理和共享不同用例和领域的端到端工作流程。最后,spaCy 还与其他酷炫的开源库如DVC、Streamlit和FastAPI(第九章和第十章)集成。所有这些内容涵盖了 spaCy 库的结构以及它如何帮助我们构建可维护的 NLP 解决方案的主要构建块。
到目前为止,我希望您在本书的学习之旅中学习如何使用所有这些酷炫功能感到兴奋。在下一节中,让我们安装 spaCy,这样我们就可以开始编码了。
安装 spaCy
让我们从安装和设置 spaCy 开始。spaCy 与 64 位 CPython 3.7+兼容,可以在 Unix/Linux、macOS/OS X 和 Windows 上运行。CPython 是用 C 实现的 Python 的参考实现。如果您已经在系统上运行了 Python,那么您的 CPython 模块很可能也是好的——因此,您不需要担心这个细节。最新的 spaCy 版本总是可以通过pip(pypi.org/)和conda(conda.io/en/latest/)下载。pip和conda是最受欢迎的发行包之一。
总是创建一个虚拟环境来隔离每个项目的独立 Python 包集是一个好主意。在 Windows 上,我们可以使用以下命令创建虚拟环境并使用pip安装spacy:
python -m venv .env
.env\Scripts\activate
pip install -U pip setuptools wheel
pip install -U spacy
如果您的机器有可用的 GPU,您可以使用以下命令安装具有 GPU 支持的 spaCy:
pip install -U 'spacy[cuda12x]'
您可以在spacy.io/usage#quickstart查看每个操作系统的安装说明。图 1.2展示了所有可用的安装选项。

图 1.2 – spaCy 安装选项
安装库后,我们需要安装语言模型。让我们在下一节中完成这个操作。
安装 spaCy 的语言模型
spaCy 的安装不包括 spaCy 管道任务所需的统计语言模型。spaCy 语言模型包含从一组资源收集的特定语言的知识。语言模型使我们能够执行各种 NLP 任务,包括词性标注,通常称为POS 标注和命名实体****识别(NER)。
不同的语言有不同的语言特定模型。同一语言也有不同的模型可供选择。模型的命名约定是[lang]_[name]。[name]部分通常包含有关模型功能、类型和大小的信息。例如,pt_core_web_sm模型是在网络文本上训练的小型葡萄牙语管道。大型模型可能需要大量的磁盘空间,例如,en_core_web_lg占用 382 MB,而en_core_web_md需要 31 MB,而en_core_web_sm只需 12 MB。
将模型类型与您的文本类型相匹配是一种良好的实践。我们建议选择尽可能接近您文本的类型。例如,社交媒体类型的词汇将与维基百科类型的词汇大不相同。如果您有社交媒体帖子、报纸文章或财经新闻,可以选择网络类型,即更多来自日常生活的语言。维基百科类型适用于较为正式的文章、长文档和技术文档。如果您不确定哪种类型最适合,您可以下载几个模型,测试一些来自您自己的语料库的示例句子,并查看每个模型的表现。
现在我们已经了解了如何选择模型,让我们下载我们的第一个模型。
安装语言模型
我们可以将 spaCy 模型作为 Python 软件包安装,这意味着您可以将它们像安装任何其他 Python 模块一样安装,并将它们作为您 Python 应用程序的一部分。它们也可以放入您的requirements.txt文件中作为依赖项。您可以手动从下载 URL 或本地目录安装模型,或通过pip安装。
您可以通过 spaCy 的download命令下载模型。download会寻找与您的 spaCy 版本最兼容的模型,然后下载并安装它。这样,您就不必担心模型与您的 spaCy 版本之间可能存在的任何不匹配。这是安装模型的最简单方法:
python -m spacy download en_core_web_sm
上述命令选择并下载与您本地 spaCy 版本最兼容的此特定模型的版本。要下载确切的模型版本,您可以使用以下命令(尽管您通常不需要这样做):
python -m spacy download en_core_web_sm-3.8.0 --direct
下载命令在幕后使用pip。当您进行下载时,pip会安装该软件包并将其放置在您的site-packages目录中,就像任何其他已安装的 Python 软件包一样。
下载后,我们可以通过 spaCy 的load()方法加载软件包:
import spacy
nlp = spacy.load('en_core_web_sm')
doc = nlp("One step forward and you're no longer in the same place")
到目前为止,我们已经设置好了一切,可以开始使用 spaCy。现在让我们了解一下 spaCy 强大的可视化工具displaCy。
使用 displaCy 进行可视化
可视化是向您的同事、老板以及任何技术或非技术受众解释一些概念的最简单方法。语言数据可视化特别有用,并允许您一眼就能识别数据中的模式。
有许多 Python 库和插件,如matplotlib、seaborn、tensorboard等。spaCy 也自带其可视化器 – displaCy。在本节中,您将学习如何在您的机器上启动 displaCy 服务器,在 Jupyter 笔记本中,以及在 Web 应用程序中。我们将从最简单的方法开始探索 – 使用 displaCy 的交互式演示。
开始使用 displaCy
请前往demos.explosion.ai/displacy使用交互式演示。在文本解析框中输入您的文本,然后点击右侧的搜索图标以生成可视化。结果可能看起来像图 1.3。

图 1.3 – displaCy 的在线演示
可视化器执行两个句法分析,词性标注和依存句法分析器。我们将在接下来的章节中探讨它们。现在,只需将结果视为句子结构。现在,让我们看看如何使用 displaCy 可视化命名实体。
实体可视化器
displaCy 的实体可视化器突出显示文本中的命名实体。在线演示在demos.explosion.ai/displacy-ent 。我们还没有讲解命名实体,但您可以将它们视为重要实体的专有名词,例如人名、公司名、日期、城市和国家名称等。
在线演示与句法分析器演示类似。将您的文本输入到文本框中,然后点击搜索按钮。图 1.4显示了示例。

图 1.4 – displaCy 的命名实体可视化器
右侧包含实体类型的复选框。您可以选择与您的文本类型匹配的复选框,例如,对于财务文本,可以选择MONEY和QUANTITY。就像在句法分析器演示中一样,您可以从可用的模型中选择。
使用纯 Python 与 displaCy 结合
displaCy 的可视化器集成到核心库中。这意味着您可以在安装 spaCy 到您的机器后立即开始使用 displaCy。让我们通过一些示例来了解:
-
首先,让我们导入 spaCy 和 displaCy,加载模型,并处理一个句子:
import spacy from spacy import displacy nlp = spacy.load('en_core_web_sm') doc= nlp("One step forward and you're no longer in the same place") -
现在,我们可以使用 displaCy 的
serve()方法在本地运行服务器,指定我们想要查看依存句法分析器的可视化:displacy.serve(doc, style='dep') -
启动此代码后,您应该会看到 displaCy 的响应,如图图 1.5所示。

图 1.5 – 在本地启动 displaCy
-
我们可以看到
http://0.0.0.0:5000是 displaCy 渲染您可视化本地的地址。您可以在浏览器中打开此 URL 来查看它。当您想要关闭服务器时,您可以按 Ctrl +C来关闭 displaCy 服务器并返回到命令行。 -
如果您想使用另一个端口号,或者如果您因为端口号
5000已经被占用而遇到错误,您可以使用 displaCy 的port参数与另一个端口号。将前面代码块的最后一行替换为以下行就足够了:displacy.serve(doc, style='dep', port=5001)
在这里,我们明确地提供了端口号 5001。在这种情况下,displaCy 将在 http://0.0.0.0:5001 上渲染图形。
-
创建实体识别器可视化也是类似的。我们传递
ent到样式参数而不是dep:import spacy from spacy import displacy nlp = spacy.load('en_core_web_sm') doc= nlp("spaCy's main developers are Matthew Honnibal and Ines Montani, the founders of the software company Explosion") displacy.serve(doc, style='ent')
让我们继续了解其他我们可以用来显示结果的平台。
在 Jupyter notebooks 中使用 displaCy
Jupyter Notebook 是日常数据科学工作的重要组成部分。为了在 Jupyter notebooks 中显示可视化,我们可以将 serve() 方法更改为 render()。其余的代码都是相同的。图 1 .6 展示了在 Jupyter notebook 中运行 displaCy 的结果。

图 1.6 – displaCy 在 Jupyter notebook 中的渲染结果
如果你想了解如何使用不同的背景图片、背景颜色和字体,你可以访问 displaCy 文档,网址为 spacy.io/usage/visualizers。
摘要
本章为您介绍了使用 Python 和 spaCy 的 NLP(自然语言处理)。您现在对为什么使用 Python 进行语言处理以及为什么选择 spaCy 创建您的 NLP 应用程序的原因有了简要的了解。我们还通过安装 spaCy 和下载语言模型开始了我们的 spaCy 之旅。本章还介绍了可视化工具 displaCy。
在下一章中,我们将继续我们的激动人心的 spaCy 之旅,学习 spaCy 的核心操作,如分词和词形还原。这将是我们第一次详细接触 spaCy 的功能。那里见!
第二章:spaCy 的核心操作
在本章中,你将学习关于 spaCy 的核心操作,例如创建语言管道、分词文本以及将文本分解成句子。
首先,你将了解什么是语言处理管道,并探索管道组件。我们将继续介绍一般的 spaCy 约定——重要的类和类组织——以帮助你更好地理解 spaCy 并建立对该库的坚实基础。
接下来,你将了解第一个管道组件——分词器。你还将了解一个重要的语言概念——词形还原——以及其在自然语言理解(NLU)中的应用。在此之后,我们将详细介绍容器类和spaCy 数据结构。我们将以一些有用的 spaCy 特性结束本章,这些特性将在日常 NLP 开发中使用。
在本章中,我们将涵盖以下主要主题:
-
spaCy 约定概述
-
介绍分词
-
理解词形还原
-
spaCy 容器对象
-
更多 spaCy 标记特性
技术要求
本章的代码可以在github.com/PacktPublishing/Mastering-spaCy-Second-Edition找到。
spaCy 约定概述
在我们的文本上调用nlp会使 spaCy 运行一个由许多处理步骤组成的管道。第一个步骤是分词,以生成文档对象。然后,根据我们添加到管道中的 spaCy 组件,文本可以进一步由如词性标注器、解析器和实体识别器等组件处理。我们称之为语言处理管道。每个管道都是使用组件构建的。每个组件返回处理后的文档,然后将其传递给下一个组件。这个过程在以下图中展示:

图 2.1 – 处理管道的高级视图
当我们加载语言模型时创建 spaCy 管道对象。在以下代码段中,我们加载一个英语模型并初始化一个管道:
-
首先,我们导入 spaCy 并使用
spacy.load返回一个语言类实例:import spacy nlp = spacy.load("en_core_web_md") -
现在我们可以使用这个语言实例来获取文档对象:
doc = nlp("I went there")
语言类在幕后将所有管道步骤应用于输入句子。在将nlp应用于句子后,文档对象包含标记,这些标记被标记、词形还原,如果标记是实体,则标记为实体(我们将在第五章中详细介绍实体,使用 spaCy 管道提取语义表示)。
每个管道组件都有一个明确的任务:
-
Tokenizer (分词器) : 将文本分割成标记
-
Tagger (词性标注器) : 分配词性标签
-
DependencyParser (解析器) : 分配依存标签
-
实体识别器 (ner):检测和标记命名实体
spaCy 语言处理管道 始终依赖于 驱动组件的统计模型。每个组件对应一个 spaCy 类。spaCy 类具有自解释的名称,例如 Language、Doc 和 Vocab。您可以在以下位置查看所有 spaCy 管道组件的列表:spacy.io/usage/spacy-101/#architecture-pipeline。还有用于表示文本和语言数据的数据结构类。我们已经熟悉了 Doc 类,但我们还有这些其他容器类:
-
Doc:spaCy 中的一个容器对象,代表整个处理过的文本,持有文档的结构及其标记。 -
标记:
Doc对象中的一个单一文本单元,如单词、标点符号或符号。 -
跨度:在
Doc对象内部的一块连续标记,代表文本的一部分,如短语或命名实体。 -
词元:一个存储关于单词的词汇信息(如其基本形式、拼写和属性)的对象,独立于其在文本中的上下文。
最后,spaCy 提供了用于向量、语言词汇和注释的辅助类。在这本书中,我们将经常看到 Vocab 类。Vocab 代表一种语言的词汇。spaCy 库的主干数据结构是 Doc 和 Vocab。Doc 对象通过拥有标记序列及其所有属性来抽象文本。Vocab 对象为所有其他类提供集中化的字符串和词汇属性。这样,spaCy 避免存储多个语言数据的副本。图 2.2 展示了所有 spaCy 容器是如何协同工作的。

图 2.2 – spaCy 架构
spaCy 在幕后为我们执行所有文本处理操作,使我们能够专注于我们自己的应用程序开发。让我们从 Tokenizer 类开始。
介绍分词
我们在 图 2.1 中看到,文本处理管道中的第一步是分词。分词始终是第一个操作,因为所有其他操作都需要标记。
分词简单地说就是将句子分割成其标记。您可以将标记视为文本片段中最小的有意义的部分。标记可以是单词、数字、标点符号、货币符号以及构成句子的任何其他有意义的符号。以下是一些标记的示例:
USA
N.Y.
City
33
3rd
!
…
?
's
spaCy 分词器的输入是 Unicode 文本,输出是一个 Doc 对象。以下代码展示了分词过程:
-
首先,我们导入库并加载英语语言模型:
import spacy nlp = spacy.load("en_core_web_md") -
接下来,我们将
nlp对象应用于一个句子以创建一个Doc对象。Doc对象是Token对象序列的容器。然后我们打印标记文本:doc = nlp("I own a ginger cat.") print([token.text for token in doc]) >>> ['I', 'own', 'a', 'ginger', 'cat', '.']
图 2 .3 展示了我们分割的分词及其索引。

图 2.3 – “I own a ginger cat.”的分词
分词可能很棘手。有许多方面我们应该注意 – 标点符号、空白、数字等等。使用text.split(" ")从空白处分割可能很有吸引力,看起来在示例句子I own a ginger cat中似乎有效。
关于句子"It's been a crazy week!!!"呢?如果我们进行分割( " " ),生成的分词将是It's、been、a、crazy、week!!!,这并不是您想要的。首先,It's不是一个分词,它是两个分词:it和's。week!!!不是一个有效的分词,因为标点符号没有被正确分割。此外,!!!应该按符号分词,并生成三个!。这可能看起来不是一个重要的细节,但对于情感分析来说很重要。让我们看看 spaCy 分词器生成了什么:
import spacy
nlp = spacy.load("en_core_web_md")
doc = nlp("It's been a crazy week!!!")
print([token.text for token in doc])
>>> ['It', "'s", 'been', 'a', 'crazy', 'week', '!', '!', '!']
图 2 .4 展示了分词及其索引。

图 2.4 – 引号和标点符号的分词
spaCy 是如何知道在哪里分割句子的?与其他管道部分不同,分词器不需要统计模型。分词基于语言特定的规则。您可以在以下链接中看到语言特定数据的示例:github.com/explosion/spaCy/tree/master/spacy/lang。
分词器异常定义了异常的规则,例如it's、don't、won't、缩写等等。如果您查看英语的规则(github.com/explosion/spaCy/blob/master/spacy/lang/en/tokenizer_exceptions.py),您会看到规则看起来像{ORTH: "n't", LEMMA: "not"},这描述了分词器对n't的分割规则。
前缀、后缀和中缀主要描述了如何处理标点符号 – 例如,如果句尾有一个句号,我们就分割它,否则,它很可能是像N.Y.这样的缩写的一部分,我们不应该触碰它。在这里,ORTH表示文本,LEMMA表示不带任何屈折的词的基本形式。图 2 .5 展示了 spaCy 分词算法的执行过程:

图 2.5 – spaCy 使用异常规则进行分词,来源:spacy.io/usage/linguistic-features#tokenization
分词规则取决于个别语言的语法规则。如分割句号、逗号或感叹号之类的标点符号规则在许多语言中是相似的;然而,一些规则是针对个别语言的,例如缩写词和撇号的使用。spaCy 通过允许手动编码的数据和规则来支持每个语言都有其特定的规则,因为每个语言都有自己的子类。
提示
spaCy 提供了非破坏性分词,这意味着我们总是能够从标记中恢复原始文本。在分词过程中,空白和标点信息被保留,因此输入文本保持原样。
每个 Language 对象都包含一个 Tokenizer 对象。Tokenizer 类是执行分词的类。当你创建 Doc 类实例时,通常不会直接调用这个类,而 Tokenizer 类在幕后工作。当我们想要自定义分词时,我们需要与这个类进行交互。让我们看看它是如何完成的。
自定义分词器
当我们处理特定领域,如医学、保险或金融时,我们经常会遇到需要特别关注的单词、缩写和实体。你将要处理的多数领域都有其特有的单词和短语,需要自定义分词规则。以下是向现有的 Tokenizer 类实例添加特殊案例规则的方法:
-
首先,让我们导入 spaCy 和
ORTH符号,它表示正字法:import spacy from spacy.symbols import ORTH -
现在我们像往常一样实例化
Language对象,处理Doc对象,并打印标记:nlp = spacy.load("en_core_web_sm") doc = nlp("lemme that") print([w.text for w in doc]) >>> ['lemme', 'that'] -
最后,我们可以定义一个特殊情况,其中单词
lemme应该被分词为两个标记,lem和me:special_case = [{ORTH: "lem"}, {ORTH: "me"}] nlp.tokenizer.add_special_case("lemme", special_case) print([w.text for w in nlp("lemme that")]) >>> ['lem', 'me', 'that']
在定义自定义规则时,默认的标点符号分割规则仍然会被应用。即使特殊情况被标点符号包围,它仍然会被识别。分词器会逐步处理标点符号,并将相同的处理过程应用于剩余的子字符串,如下例所示:
print([w.text for w in nlp("lemme!")])
>>> ['lem', 'me', '!']
只有在你确实需要的时候,才应该通过添加新规则来修改分词器。相信我,使用自定义规则可能会得到相当意外的结果。特别是如果你有社交媒体文本,首先将一些句子输入到 spaCy NLP 管道中,看看分词是如何进行的。让我们看看如何调试分词器组件。
调试分词器
spaCy 有一个用于调试的工具:nlp.tokenizer.explain(sentence)。它返回(分词规则/模式,标记)元组,帮助我们了解在分词过程中确切发生了什么。让我们看看一个例子:
-
让我们像往常一样处理文本:
import spacy nlp = spacy.load("en_core_web_sm") text = "Let's go!" doc = nlp(text) -
现在我们可以要求
Language对象的Tokenizer类实例解释这个句子的分词:tok_exp = nlp.tokenizer.explain(text) for t in tok_exp: print(t[1], "\t", t[0]) >>> Let SPECIAL-1 's SPECIAL-2 go TOKEN ! SUFFIX
nlp.tokenizer.explain() 方法逐一解释了分词器使用的规则。在将句子分割成其标记后,就到了将文本分割成其句子的时间了。
句子分割
我们看到,将一个句子分解为其标记并不是一个简单的任务。那么,将文本分解为句子呢?由于标点符号、缩写等原因,标记句子开始和结束的确要复杂一些。
Doc 对象的句子可以通过 doc.sents 属性访问:
import spacy
nlp = spacy.load("en_core_web_sm")
text = "I flied to N.Y yesterday. It was around 5 pm."
doc = nlp(text)
for sent in doc.sents:
print(sent.text)
>>> I flied to N.Y yesterday.
It was around 5 pm.
确定句子边界比标记化更复杂。因此,spaCy 使用 依存句法分析器 来执行句子分割。这是 spaCy 的一个独特特性——没有其他库将如此复杂的思想付诸实践。一般来说,结果非常准确,除非你处理的是非常特定类型的文本,例如来自对话领域或社交媒体文本。
现在我们知道了如何将文本分割成句子并对句子进行标记化,让我们从词形还原开始,这是语义和情感分析中常用的操作。
理解词形还原
词元 是一个标记的基本形式。你可以把词元看作是标记在词典中出现的形态。例如,eating 的词元是 eat ;eats 的词元也是 eat ;ate 同样映射到 eat。词形还原 是将词形缩减到词元的过程。以下代码是使用 spaCy 进行词形还原的快速示例:
import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("I went there for working and worked for 3 years.")
for token in doc:
print(token.text, token.lemma_)
>>> I I
went go
there there
for for
working work
and and
worked work
for for
3 3
years year
. .
到现在为止,你应该熟悉代码的前三行做了什么。在 for 循环中,我们打印出每个标记,text 和 lemma_ 。让我们通过一个现实世界的例子来看看词形还原的实际应用。
NLU 中的词形还原
词形还原是 NLU 中的一个重要步骤。我们将在本小节中通过一个例子来讲解。假设你为票务预订系统设计了一个 NLP 管道。你的应用程序处理客户的句子,从中提取必要的信息,然后将它传递给预订 API。
NLP 管道想要提取旅行的形式(航班、巴士或火车)、目的地城市和日期。应用程序需要验证的第一件事是旅行方式:
-
飞行
-
航班
-
航路
-
飞机
-
飞机
-
巴士
-
铁路
-
火车
我们有这个关键词列表,我们希望通过在关键词列表中搜索标记来识别旅行方式。进行这种搜索的最紧凑方式是查找标记的 词元 。考虑以下客户句子:
List me all flights to Atlanta.
I need a flight to NY.
I flew to Atlanta yesterday evening and forgot my baggage.
在这里,我们不需要在关键词列表中包含动词 fly 的所有词形( fly , flying , flies , flew , 和 flown ),对于单词 flight 也是如此;我们将所有可能的变体都缩减到了基本形式 – fly 和 flight 。不要只考虑英语;像葡萄牙语、德语和芬兰语这样的语言也有许多来自单个词元的词形。
当我们想要识别目的地城市时,词形化也很有用。全球城市有许多昵称,例如 Angeltown 对应于 Los Angeles。默认的标记化和词形化器不会区分官方名称和昵称。AttributeRuler 组件允许我们使用 Matcher 模式设置自定义标记属性(我们将在 第四章 中了解更多关于 Matcher 的内容)。
让我们添加一个特殊规则来设置 Angeltown 的词形为 Los Angeles:
-
nlp.get_pipe()方法返回一个管道组件。我们将获取AttributeRuler组件并添加特殊规则:import spacy nlp = spacy.load("en_core_web_sm") nlp.get_pipe("attribute_ruler").add([[{ "TEXT": "Angeltown"}]], {"LEMMA": "Los Angeles"}) -
让我们通过处理
doc并打印词形来查看这是否有效:doc = nlp("I am flying to Angeltown") for token in doc: print(token.text, token.lemma_) >>> I I am be flying fly to to Angeltown Los Angeles
现在我们已经了解了 tokenizer 和 lemmatizer 组件(通常是一个处理管道的两个组件),让我们继续学习更多关于 spaCy 容器对象 的内容。
spaCy 容器对象
在本章的开头,我们看到了一个包括 Doc、Token、Span 和 Lexeme 在内的容器对象列表。在本节中,我们将详细查看容器对象的属性。
使用容器对象,我们可以访问 spaCy 分配给文本的语言学属性。一个 容器对象 是文本单元(如文档、标记或文档的一部分)的逻辑表示。
spaCy 中的容器对象遵循文本的自然结构:一个文档由句子组成,句子由标记组成。我们在开发中最广泛使用 Doc、Token 和 Span 对象,分别代表文档、单个标记和短语。一个容器可以包含其他容器——例如,一个文档包含标记和跨度。
让我们逐一探索每个类及其有用的属性。
文档
我们在代码中创建了 Doc 对象来表示文本,所以你可能已经猜到 Doc 代表文本。在这里,doc.text 返回文档文本的 Unicode 表示:
doc = nlp("I like cats.")
print(doc.text)
>>> I like cats.
Doc 对象的构建块是 Token,因此当你迭代一个 Doc 对象时,你会得到作为项的 Token 对象:
for token in doc:
print(token.text)
>>> I
like
cats
.
同样的逻辑适用于索引:
print(doc[1])
>>> like
Doc 对象的长度是它包含的标记数量:
print(len(doc))
>>> 4
关于文本的句子,doc.sents 返回一个句子列表的迭代器。每个句子都是一个 Span 对象:
doc = nlp("This is a sentence. This is the second sentence")
sentences = list(doc.sents)
print(sentences)
>>> [This is a sentence., This is the second sentence]
文本中的命名实体由 doc.ents 提供。结果是 Span 对象的列表。我们将在本书的后面部分详细讨论命名实体——现在,把它们看作专有名词:
doc = nlp("I flied to New York with Ashley.")
print(doc.ents)
>>> (New York, Ashley)
另一个句法属性是 doc.noun_chunks。它返回文本中找到的名词短语:
doc = nlp("Sweet brown fox jumped over the fence.")
print(list(doc.noun_chunks))
>>> [Sweet brown fox, the fence]
属性 doc.lang_ 返回创建的文档的语言:
print(doc.lang_)
>>> en
一个有用的序列化方法是 doc.to_json。这是将 Doc 对象转换为 JSON 的方法:
from pprint import pprint
doc = nlp("Hi")
json_doc = doc.to_json()
pprint(json_doc)
>>> {'ents': [],
'sents': [{'end': 2, 'start': 0}],
'text': 'Hi',
'tokens': [{'dep': 'ROOT',
'end': 2,
'head': 0,
'id': 0,
'lemma': 'hi',
'morph': '',
'pos': 'INTJ',
'start': 0,
'tag': 'UH'}]}
小贴士
您可能已经注意到,我们调用的是 doc.lang_,而不是 doc.lang。doc.lang 调用返回语言 ID,而 doc.lang_ 返回语言的 Unicode 字符串,即语言名称。您可以在以下内容中看到相同约定:token.lemma_、token.tag_ 和 token.pos_。
Doc 对象具有非常实用的属性,您可以使用这些属性来理解句子的句法属性,并在您自己的应用程序中使用它们。让我们继续了解 Token 对象,看看它提供了什么。
Token
token 对象代表一个单词。词元对象是 Doc 和 Span 对象的构建块。在本节中,我们将介绍 Token 类的以下属性:
-
token.text -
token.text_with_ws -
token.i -
token.idx -
token.doc -
token.sent -
token.is_sent_start -
token.ent_type
我们通常不会直接构造 Token 类的对象,而是构造 Doc 对象,然后访问其词元:
doc = nlp("Hello Madam!")
print(doc[0])
>>> Hello
token.text 属性类似于 doc.text,提供了底层的 Unicode 字符串。token.text_with_ws 是一个类似的属性。如果它在 doc 对象中存在,它将提供带有尾随空白的文本:
print(doc[0].text_with_ws)
print(doc[2].text_with_ws)
>>> 'Hello '
'!'
查找词元的长度与查找 Python 字符串的长度类似:
print(len(doc[0]))
>>> 5
token.i 属性提供了词元在 doc 对象中的索引:
token = doc[2]
print(token.i)
>>> 2
词元的字符偏移量(字符位置)由 token.idx 提供:
print(doc[0].idx)
print(doc[1].idx)
>>> 0
6
另一个有趣的词元属性是,我们还可以访问创建词元的 doc 对象,如下所示:
token = doc[0]
print(token.doc)
>>> Hello Madam!
这也适用于获取词元所属的句子:
token = doc[1]
print(token.sent)
>>> Hello Madam!
另一个有用的属性是 token.is_sent_start;它返回一个布尔值,指示该词元是否是一个句子的开始:
doc = nlp("He entered the room. Then he nodded.")
print(doc[0].is_sent_start)
>>> True
print(doc[5].is_sent_start)
>>> True
print(doc[6].is_sent_start)
>>> False
这些是您每天都会使用的 Token 对象的基本属性。还有另一组属性,它们与句法和语义更相关。我们已经在上一节中看到了如何计算词元词干:
doc = nlp("I went there.")
print(doc[1].lemma_)
>>> go
您已经了解到 doc.ents 属性提供了文档中的命名实体。如果您想了解词元是哪种类型的实体,请使用 token.ent_type_:
doc = nlp("The Brazilian president visited Beijing")
print(doc.ents)
>>> (Brazilian, Beijing)
print(doc[1].ent_type_, spacy.explain(doc[1].ent_type_))
>>> NORP Nationalities or religious or political groups
与 POS 标注相关的两个句法特征是 token.pos_ 和 token.tag。我们将在下一章中学习它们是什么以及如何使用它们。Token 对象具有丰富的功能集,使我们能够从头到尾处理文本。让我们继续了解 Span 对象,看看它提供了什么。
Span
Span 对象代表短语或文本的片段。Span 对象必须是词元的连续序列。我们通常不会初始化 Span 对象,而是从 Doc 对象中切片:
import spacy
nlp = spacy.load("en_core_web_sm")
doc = nlp("All my moves are coldly calculated.")
print(doc[4:6])
>>> coldly calculated
尝试切片无效索引将引发 IndexError。Python 字符串的大多数索引和切片规则也适用于 Doc 切片:
doc = nlp("All my moves are coldly calculated.")
print(doc[5:]) # end index empty means rest of the string calculated.
print(doc[4:-1]) # minus indexes are supported
>>> calculated.
coldly calculated
创建Span对象还有另一种方法——我们可以使用char_span([start_idx, end_idx])从Doc对象中创建一个字符级别的切片:
doc = nlp("Recife has a thousand charms, it's a little piece of Brazil.")
print(doc.char_span(37, 59))
>>> little piece of Brazil
Span对象的基本构建块是Token对象。如果你遍历一个Span对象,你会得到Token对象:
doc = nlp("You went there after you saw me")
span = doc[2:4]
for token in span:
print(token)
>>> there
after
你可以将Span对象视为一个初级Doc对象。因此,Doc的大多数特性也适用于Span。例如,len是相同的:
doc = nlp("Hi Lorena!!")
span = doc[:2]
len(span)
>>> 2
Span对象也支持索引。切片Span对象的结果是另一个Span对象:
doc = nlp("You went there after you saw me")
span = doc[2:6]
print(span)
>>> there after you saw
print(span[1:3])
>>> after you
正如Token知道它是由哪个Doc对象创建的一样,Span也知道自己是由哪个Doc对象创建的:
doc = nlp("You went there after you saw me")
span = doc[2:6]
print(span.doc)
>>> You went there after you saw me
print(span.sent)
>>> You went there after you saw me
我们还可以在原始的Doc对象中定位Span对象:
doc = nlp("You went there after you saw me")
span = doc[2:6]
print(span.start) # index of the first token of the Span
>>> 2
print(span.end)
>>> 6
print(span.start_char) # start offset of the Span at character level
>>> 9
print(span.end_char)
>>> 28
如果你想创建一个新的Doc对象,你可以调用span.as_doc()。它会将数据复制到一个新的Doc对象中:
doc = nlp("You went there after you saw me")
span = doc[2:6]
small_doc = span.as_doc()
print(type(small_doc))
>>> <class 'spacy.tokens.doc.Doc'>
属性span.ents、span.sent、span.text和span.text_with_ws与它们对应的Doc和Token方法类似。现在我们将介绍更多特性和方法,以便在下一节中进行更详细的分析文本。
更多 spaCy 标记特性
大多数 NLP 开发都是基于标记和跨度进行的;也就是说,它处理标签、依存关系、标记本身和短语。我们应用一些转换,比如消除小词和意义不大的词,处理 URL 时考虑到协议和子域部分等。这些操作有时取决于标记形状(例如,如果标记是一个短词或如果标记看起来像 URL 字符串)或更语义化的特性(例如,标记是一个冠词,或标记是一个连词)。在本节中,我们将通过一些示例来查看这些标记特性。我们将从与标记形状相关的特性开始:
doc = nlp("Hello, hi!")
print(doc[0].lower_)
>>> hello
token.lower_特性将标记转换为小写。返回值是一个 Unicode 字符串,这个特性等同于token.text.lower()。
特性is_lower和is_upper与它们的 Python 字符串方法对应,islower()和isupper()。is_lower特性如果所有字符都是小写则返回True,而is_upper则对大写执行相同的操作。
is_alpha特性如果标记的所有字符都是字母则返回True。非字母字符的例子包括数字、标点和空白字符:
doc = nlp("Cat and Cat123")
print(doc[0].is_alpha)
>>> True
print(doc[2].is_alpha)
>>>False
is_ascii特性如果标记的所有字符都是 ASCII 字符则返回True:
doc = nlp("UR7 and Várzea")
print(doc[0].is_ascii)
>>>True
print(doc[2].is_ascii)
>>>False
is_digit特性如果标记的所有字符都是数字则返回True:
doc = nlp("Cat Cat123 123")
print(doc[0].is_digit)
>>>False
print(doc[1].is_digit)
>>>False
print(doc[2].is_digit)
>>> True
特性is_punct如果标记是一个标点符号则返回True:
doc = nlp("You, him and Sally")
print(doc[1])
>>>,
print(doc[1].is_punct)
>>>True
特征 is_left_punct 和 is_right_punct 分别在标记是左标点或右标点时返回 True。一个右标点可以是任何关闭左标点的标记,例如右括号、> 或 »。左标点类似,左括号 < 和 « 是一些例子:
doc = nlp("( [ He said yes. ] )")
print(doc[0])
>>> (
print(doc[0].is_left_punct)
>>>True
print(doc[-2])
>>>]
print(doc[-2].is_right_punct)
>>>True
方法 like_url、like_num 和 like_email 捕获关于标记形状的信息,如果标记看起来像 URL、数字或电子邮件,则分别返回 True。当我们想要处理社交媒体文本和抓取的网页时,这些方法非常实用:
doc = nlp("I emailed you at least 100 times")
print(doc[-2])
>>>100
print(doc[-2].like_num)
>>>True
doc = nlp("I emailed you at least hundred times")
print(doc[-2])
>>>hundred
print(doc[-2].like_num)
>>>True
doc = nlp("His email is hello@hello.com and his website is https://nicewebsite.com")
print(doc[3])
>>>hello@hellp.com
print(doc[3].like_email)
>>>True
print(doc[8])
>>>https://nicewebsite.com
print(doc[8].like_url)
>>>True
token.shape_ 是一个不寻常的特性——在其他 NLP 库中没有类似的东西。它返回一个字符串,显示了标记的正字法特征。数字被替换为 d,大写字母被替换为 X,小写字母被替换为 x。你可以将结果字符串用作机器学习算法中的特征,并且标记形状可以与文本情感相关联:
doc = nlp("Girl called Kathy has a nickname Cat123.")
for token in doc:
print(token.text, token.shape_)
>>>Girl Xxxx
called xxxx
Kathy Xxxxx
has xxx
a x
nickname xxxx
Cat123 Xxxddd
. .
特征 is_stop 经常被机器学习算法使用。通常,我们会过滤掉那些意义不大的词,例如 the、a、an、and、just、with 等等。这样的词被称为停用词。每种语言都有自己的停用词列表,你可以在 github.com/explosion/spaCy/blob/master/spacy/lang/en/stop_words.py 查找英语停用词:
doc = nlp("One step forward, and you're no longer in the same place.")
for token in doc:
print(token, token.is_stop)
>>>One True
step False
forward False
, False
and True
you True
're True
no True
longer False
in True
the True
same True
place False
. False
我们终于完成了 spaCy 的一些句法、语义和正字法特征的学习。许多方法都集中在 Token 对象上,因为一个标记是文本的句法单位。
摘要
本章为你全面介绍了 spaCy 库的类和方法。我们深入研究了语言处理管道,并了解了管道组件。我们还介绍了基本但重要的句法任务:分词。我们继续探讨了词形还原这一语言概念,并学习了 spaCy 这一特性的实际应用。我们详细探讨了 spaCy 容器类,并在本章最后部分审视了精确且有用的 spaCy 特性。在下一章中,我们将深入 spaCy 的全部语言能力。你将发现包括 spaCy 最常用的特性:词性标注器、依存句法分析器和命名实体。
第二部分:高级语言和语义分析
在基础知识的基础上,本节探讨了使用 spaCy 的语言和基于规则的工具分析文本和提取信息的先进技术。你将学习如何进行复杂的解析和匹配,甚至开发自己的自定义组件来处理复杂任务。
本部分包含以下章节:
-
第三章 ,提取语言特征
-
第四章 ,基于规则的匹配精通
-
第五章 ,使用 spaCy 管道提取语义表示
-
第六章 ,使用 Transformers 与 spaCy
第三章:提取语言特征
本章深入探讨了 spaCy 的全部功能。您将发现语言特征,包括 spaCy 最常用的功能,如词性(POS)标注器、依存句法分析器、命名实体识别器和合并/分割功能。
首先,您将了解词性标注的概念,spaCy 词性标注器的功能以及如何将词性标注放入您的自然语言理解(NLU)应用中。接下来,您将学习一种结构化的方法来通过依存句法分析器表示句子语法。您将了解 spaCy 的依存标签以及如何通过揭示性例子来解释 spaCy 依存标签分析器的结果。然后,您将学习一个非常重要的 NLU 概念,它是许多自然语言处理(NLP)应用的核心——命名实体识别(NER)。我们将通过 NER 从文本中提取信息的例子进行讲解。最后,您将学习如何合并和分割提取的实体。
在本章中,我们将涵盖以下主要主题:
-
什么是词性标注(POS tagging)?
-
依存句法分析简介
-
介绍命名实体识别(NER)
-
合并和分割标记
技术要求
本章的代码可以在github.com/PacktPublishing/Mastering-spaCy-Second-Edition找到。
什么是词性标注(POS tagging)?
词性是一个句法类别,每个词都根据其在句子中的功能落入一个类别。例如,英语有九个主要类别:动词、名词、代词、限定词、形容词、副词、介词、连词和感叹词。我们可以如下描述每个类别的功能:
-
动词:表达动作或存在状态
-
名词:指代人、地点或事物,或命名这些事物中的特定一个(专有名词)
-
代词:可以替换名词或名词短语
-
限定词:置于名词之前,表示数量或明确名词所指的内容——简而言之,名词引入者
-
形容词:修饰名词或代词
-
副词:修饰动词、形容词或另一个副词
-
介词:连接名词/代词与其他句子部分
-
连词:将单词、子句和句子粘合在一起
-
感叹词:以突然和感叹的方式表达情感
这个核心类别集,没有任何语言特定的形态学或句法特征,被称为通用标签。spaCy 通过pos_**特征**捕获通用标签。
在整本书中,我们提供英语语言的例子,因此我们只会关注英语。不同的语言提供不同的标签集。您可以通过选择模型语言在spacy.io/models并点击标签方案按钮来查看每个模型使用的标签方案。
spaCy 支持的语言都有自己的细粒度标签集和标注方案。这种语言特定的标注方案通常包括形态学特征、动词的时态和语气、名词的数量(单数/复数)、代词的人称和数量信息(第一、第二或第三人称,单数或复数)、代词类型(人称、指示或疑问)、形容词类型(比较级或最高级)等等。
spaCy 支持细粒度词性标注以满足特定语言的需求。tag_feature 对应于细粒度标签。如果你之前没有使用过词性标注,不要担心,通过我们的示例练习,你会变得熟悉。你还可以始终在标签上调用 spacy.explain()。我们通常有两种调用 spacy.explain() 的方式,要么直接在标签名称字符串上,要么使用 token.tag_。
让我们在实践中通过一些编码来实现这一点。到这一点,你应该已经安装了 spaCy 库和英语模型,如果没有,只需运行 python –m pip install spacy 然后运行 python –m spacy download en_core_web_sm。一切准备就绪;让我们开始吧:
-
首先,让我们导入 spaCy 并解释一下
NNS标签的含义:import spacy spacy.explain("NNS") >>> 'noun, plural' -
现在,让我们加载英语模型并处理一个句子:
nlp = spacy.load("en_core_web_sm") doc = nlp("I saw flowers.") -
我们可以打印出每个标记的文本和词性标注:
for token in doc: print(token.text, "tag:", token.tag_) >>> I tag: PRP saw tag: VBD flowers tag: NNS . tag: . -
我们也可以使用
token.tag_作为输入来打印解释:for token in doc: print(token.text, "tag:", token.tag_, "explanation:", spacy.explain(token.tag_)) >>> I tag: PRP explanation: pronoun, personal saw tag: VBD explanation: verb, past tense flowers tag: NNS explanation: noun, plural . tag: . explanation: punctuation mark, sentence closer
如果你想了解更多关于词性的信息,你可以在 Eight Parts of Speech:www.butte.edu/departments/cas/tipsheets/grammar/parts_of_speech.html 上了解更多。
词性标注提供了对句子非常基本的句法理解。当我们想要在句子中找到动词和名词或更好地消除一些词的意义歧义时,会使用词性标注(关于这个话题很快就会有更多介绍)。
每个词根据其上下文——其他周围的词及其词性标注——被标注为一个词性标签。词性标注器是顺序统计模型,这意味着“一个词的标签取决于其邻近的词、它们的标签以及这个词本身”。词性标注一直以不同的形式存在。序列到序列学习(Seq2seq)始于隐马尔可夫模型(HMMs),并演变为使用长短期记忆(LSTM)单元的神经网络模型。
许多自然语言理解(NLU)应用仍然需要知道词的类型以获得更高的准确性。句法信息可以用于一个传统的任务,称为词语消歧(WSD)。让我们在下一节中看看如何使用 spaCy 标注器来处理它。
词语消歧(WSD)
词语消歧是自然语言理解中的一个经典问题,它决定一个特定的词在句子中使用的意义。一个词可以有多个意义——例如,考虑一下“bass”这个词。以下是我们能想到的一些意义:
-
低音——海鲈鱼,鱼类
-
低音——最低的男性声音
-
低音——音域最低的男歌手
在搜索引擎、机器翻译和问答系统中,确定词义可能至关重要。对于先前的例子,不幸的是,词性标注器并没有太大的帮助,因为标注器将所有词义都标记为名词。我们需要的不只是一个词性标注器。关于“beat”这个词怎么样?让我们看看这里:
-
Beat—猛烈地打击(动词(
V)) -
Beat—在游戏或比赛中击败某人(动词(
V)) -
Beat—音乐或诗歌中的节奏(名词(
N)) -
Beat—鸟的翅膀运动(名词(
N)) -
Beat—完全筋疲力尽(形容词(
ADJ))
在这里,词性标注确实能帮上大忙。形容词标签决定了词义的确切性;如果“beat”被标记为形容词,它表示的词义是完全筋疲力尽。对于动词和名词标签来说则不是这样;如果“beat”被标记为动词标签,它的词义可以是猛烈地打击或击败某人。词义消歧是一个开放性问题,已经提出了许多统计模型。然而,如果你需要一个快速的原型,你可以在某些情况下(例如在先前的例子中)借助 spaCy 标签器来解决这个问题。
NLU 应用中的动词时态和体
在上一章中,我们使用了旅行社应用的例子,我们通过使用词形还原得到了动词的基础形式(这些形式摆脱了动词的时态和体)。在本小节中,我们将重点介绍如何使用在词形还原过程中丢失的动词时态和体信息。
动词时态和体可能是动词为我们提供的最有趣的信息,告诉我们动作何时发生以及动作是否完成或正在进行。时态和体一起表明动词对当前时间的参照。英语有三种基本时态:过去、现在和将来。动词时态可以表达不同的体和形式,如简单、进行/连续、完成、完成进行和将来时态。例如,在句子I’m eating中,动作eat发生在现在并且正在进行。因此,我们描述这个动词为现在进行/连续。
然而,我们如何在我们的旅行社 NLU 中使用这些信息?考虑以下可以指向我们的 NLU 应用的客户句子:
-
我飞往罗马
-
我正在飞往罗马
-
我将飞往罗马
在所有句子中,动作是飞:然而,只有一些句子表明有订票的意图。让我们想象以下带有周围上下文的句子:
-
我三天前飞往罗马。我还没收到账单,请尽快发送。
-
我下周将飞往罗马。你能查一下航班可用性吗?
-
我下周将飞往罗马。你能查一下航班吗?
从表面上看,动词 fly 的过去式并不表明预订意图。相反,它指向客户投诉或客户服务问题。另一方面,不定式和现在进行时形式则指向预订意图。我们可以使用词性标注来通过过滤具有 VBG 标签(现在进行时态的动词)或 VB 标签(基本/不定式形式的动词)的句子来过滤这些意图。让我们在下面的代码段中这样做:
import spacy
nlp = spacy.load("en_core_web_sm")
sent1 = "I flew to Rome"
sent2 = "I'm flying to Rome"
sent3 = "I will fly to Rome"
doc1 = nlp(sent1)
doc2 = nlp(sent2)
doc3 = nlp(sent3)
for doc in [doc1, doc2, doc3]:
print([(w.text, w.lemma_) for w in doc if
w.tag_== 'VBG' or w.tag_== 'VB'])
>>> []
[('flying', 'fly')]
[('fly', 'fly')]
我们已经涵盖了一个语义任务和一个形态学任务——WSD 和动词的时态/体。现在我们将继续另一个句法概念——依存句法分析。
依存句法分析简介
使用 spaCy 的依存句法分析器,我们可以表示句子的句法结构。在前一节中,我们关注了词性标注,它将词按照句法进行分类。虽然词性标注可以提供关于相邻词标签的见解,但它并没有揭示句子中非直接相邻词之间的关系。
正如其名所示,依存句法分析涉及通过标记之间的依存关系来分析句子结构。依存句法分析器为句子中的标记之间的句法关系进行标记,并连接句法相关的标记。依存关系或依存关系是一个两个标记之间的有向链接。
我们可以将依存句法分析可视化为一棵树,如图 图 3.1 所示。

图 3.1 – 在句子上运行依存句法分析的结果
让我们在下一节中了解更多关于这些依存关系的信息。
依存关系
NLP 中的许多统计方法都围绕单词的向量表示展开,并将句子视为单词的序列。如图 图 3.1 所示,句子不仅仅是标记的序列——它具有结构。句子中的每个单词都有一个明确定义的角色,例如动词、主语、宾语等;因此,句子具有结构。这种结构在聊天机器人、问答系统和机器翻译中得到广泛应用。
最有用的应用之一是确定句子中的宾语和主语。再次,让我们回到我们的旅行社应用程序。想象一下,一位客户正在抱怨服务。比较以下两个句子:“我把邮件转发给你”和“你把邮件转发给我”;如果我们消除了停用词“我”、“你”、“我”和“的”,剩下的就是:
-
我把邮件转发给你 -> 转发邮件
-
你把邮件转发给我 -> 转发邮件
尽管句子的剩余部分相同,但这两个句子具有非常不同的含义,需要不同的答案。在第一句中,句子主语是我(因此,答案很可能会以你开头),而第二句的主语是你(这将导致以我结尾的答案)。
依存分析器帮助我们更深入地了解句子句法和语义,超越了仅分析单词本身的分析。让我们从依存关系开始探索更多内容。
句法关系
spaCy 为每个标记分配一个依存标签,就像其他语言特征(如词元或 POS 标签)一样。spaCy 使用有向弧显示依存关系。图 3 .2显示了名词与其修饰形容词之间的依存关系示例:

图 3.2 – 名词与其形容词之间的依存关系
一个依存标签描述了两个标记之间的句法关系如下:其中一个标记是句法父节点(称为头)而另一个是其依存项(称为子节点)。在先前的例子中,flower是头,blue是其依存项/子节点。
依存标签被分配给子节点。标记对象有dep(整数值)和dep_(Unicode,可读字符串)属性,它们持有依存标签,如下面的代码片段所示:
doc = nlp("blue flower")
for token in doc:
print(token.text, "\tdep:",token.dep_)
>>> blue dep: amod
flower dep: ROOT
在这个例子中,我们遍历了标记并打印了它们的文本和依存标签。让我们了解这些依存标签:
-
blue被分配了amod标签。amod是形容词-名词关系的依存标签。 -
flower是ROOT。ROOT是依存树中的一个特殊标签;它被分配给句子的主要动词。如果我们处理的是一个短语(而不是完整的句子),则ROOT标签被分配给短语的根,即短语的中心名词。在blue flower短语中,中心名词flower是短语的根。 -
每个句子或短语恰好有一个根,它是分析树的根。
-
树节点可以有多个子节点,但每个节点只能有一个父节点(由于树的限制,以及不包含循环的树)。换句话说,每个标记恰好有一个头,但父节点可以有多个子节点。这就是为什么依存标签被分配给依存节点的原因。
让我们看看最常见的和最有用的依存标签列表,然后我们将了解它们如何确切地链接标记。首先是这个列表:
-
amod: 形容词修饰符 -
aux: 辅助 -
compound: 复合 -
dative: 宾格宾语 -
det: 限定词 -
dobj: 直接宾语 -
nsubj: 名词主语 -
nsubjpass: 名词主语,被动 -
nummod: 数量修饰符 -
poss: 所有权修饰符 -
root: 根
让我们看看这些标签的使用示例以及它们表达的关系:
amod是一个形容词修饰符。从其名称可以理解,这种关系修饰名词(或代词)。在图 3 .3中,我们看到白色修饰绵羊:

图 3.3 – amod 关系
aux是你可能猜到的:它是助动词与其主要动词之间的依赖关系。依赖项是一个助动词,中心项是主要动词。在图 3.4中,我们看到has是主要动词gone的助动词:

图 3.4 – aux 关系
compound用于名词复合;第二个名词由第一个名词修饰。在图 3.5中,phone book是一个名词复合,phone名词修饰book名词:

图 3.5 – 复合关系
det关系将限定词(依赖项)与其修饰的名词(其中心项)联系起来。在图 3.6中,the是这句话中名词girl的限定词:

图 3.6 – det 关系
接下来,我们将探讨两种宾语关系,dative和dobj。dobj关系在动词和它的直接宾语之间。一个句子可以有一个以上的宾语(如下面的例子所示);直接宾语是动词所作用的对象,其他的是称为间接宾语。
直接宾语通常用宾格来标记。dative关系指向dative 宾语,它从动词那里接受间接动作。在图 3.7中显示的句子中,间接宾语是me,直接宾语是book:

图 3.7 – 句子的直接和间接宾语
nsubj和nsubjposs是两种与名词性句子主语相关的关联。句子的主语是执行动作的人。被动主语仍然是主语,但我们用nsubjposs来标记它。在图 3.8中,Mary是句子的名词主语:

图 3.8 – nsubj 关系
图 3.9中的句子是you的被动名词主语:

图 3.9 – nsubjpass 关系
我们现在已经涵盖了句子主语和宾语关系。现在,我们将发现两种修饰关系;一个是nummod(数字修饰语),另一个是poss(拥有性修饰语)。数字修饰语通过数字或数量来修饰中心名词的意义。在图 3.10中的句子中,nummod很容易找到;它在3和books之间:

图 3.10 – nummod 关系
拥有性修饰语发生在所有格代词和名词之间,或者所有格的所有格和名词之间。在图 3.11中显示的句子中,my是名词book的拥有性标记:

图 3.11 – my 和 book 之间的 poss 关系
最后但同样重要的是,is是根标签,它不是一个真正的关系,而是句子动词的标记。根词在句法树中没有真正的父节点;根是句子的主要动词。在前面的句子中,主要动词是is助动词。请注意,根节点没有进入弧线——也就是说,没有父节点。
这些是我们 NLU 目的中最有用的标签。现在让我们练习如何利用依存关系标签。token.dep_包括从属标记的依存关系标签。token.head属性指向头/父标记。只有根标记没有父节点;spaCy 在这种情况下指向标记本身。让我们从图 3.11的示例句子中分割出以下内容:
doc = nlp("This is my book")
for token in doc:
print(token.text, "\tpos:", token.pos_, "\tdep:", token.dep_)
>>> This pos: PRON dep: nsubj
is pos: AUX dep: ROOT
my pos: PRON dep: poss
book pos: NOUN dep: attr
我们遍历了标记并打印了细粒度的词性标注和依存关系标签。is是句子的主要动词,并标记为ROOT标签。这是句子的主语。我们可以深入一级并打印这次标记的头,如下所示:
doc = nlp("This is my book")
for token in doc:
print(token.text, "\tpos:", token.pos_, "\tdep:", token.dep_, "\thead:", token.head)
>>> This pos: PRON dep: nsubj head: is
is pos: AUX dep: ROOT head: is
my pos: PRON dep: poss head: book
book pos: NOUN dep: attr head: is
我们可以看到动词is是除了my之外所有标记的头,而my的头是book。让我们检查一个更长、更复杂的句子的依存关系树,如下所示:
doc = nlp("We are trying to understand the difference.")
for token in doc:
print(token.text, token.pos_, "\tdep:", token.dep_, "\thead:", token.head)
>>> We PRON dep: nsubj head: trying
are AUX dep: aux head: trying
trying VERB dep: ROOT head: trying
to PART dep: aux head: understand
understand VERB dep: xcomp head: trying
the DET dep: det head: difference
difference NOUN dep: dobj head: understand
. PUNCT dep: punct head: trying
如图 3.12所示,我们可以定位到主要动词和尝试的根(它没有进入弧线)。尝试这个词的左侧看起来可以管理,但右侧有一系列弧线。让我们从左侧开始。我们这个代词被标记为nsubj。因此,这是句子的名词主语。另一个左侧的弧线,标记为aux,指向尝试的从属(are),它是主要动词尝试的助动词。

图 3.12 – 一个复杂的解析示例
现在我们来看看右侧发生了什么。尝试通过一个xcomp关系附加到第二个动词理解上。动词的xcomp(或开放补语)关系是一个没有自己主语的子句。在这里,理解差异这个子句没有主语,所以它是一个开放补语。我们跟随从第二个动词理解出发的dobj弧线,最终落在名词差异上,它是to understand the difference子句的直接宾语。
displaCy在线演示(demos.explosion.ai/displacy)是一个很好的工具,你可以用它来尝试自己的示例句子并查看解析结果。本节为我们将在第四章中看到的模式匹配练习提供了坚实的基础。
为了完成这一章,让我们了解一个非常著名的 NLP 任务:NER。
介绍 NER
什么是命名实体?命名实体是我们可以通过一个专有名称或感兴趣的数量来指代的现实世界中的对象。它可以是一个人、一个地方(城市、国家、地标或著名建筑)、一个组织、一家公司、一个产品、日期、时间、百分比、货币金额、一种药物或疾病名称。一些例子包括 Alicia Keys、巴黎、法国、勃兰登堡门、世界卫生组织、谷歌、保时捷卡宴等。
命名实体总是指向一个特定的对象,而这个对象可以通过相应的命名实体来区分。例如,如果我们标记“巴黎是法国的首都”这个句子,我们会将巴黎和法国解析为命名实体,但不会将单词首都解析为命名实体。原因是首都并不指向一个特定的对象;它是许多对象的通用名称。
NER 分类与 POS 分类略有不同。在这里,分类的数量可以高达我们想要的。最常见的分类是人物、地点和组织,并且几乎每个可用的 NER 标记器都支持这些分类。
spaCy 支持广泛的实体类型。你使用哪些类型取决于你的语料库。如果你处理财务文本,你很可能比WORK_OF_ART更频繁地使用MONEY和PERCENTAGE。以下是 spaCy 支持的实体类型列表(来源:towardsdatascience.com/explorations-in-named-entity-recognition-and-was-eleanor-roosevelt-right-671271117218):
-
PERSON:人物,包括虚构人物 -
NORP:民族或宗教或政治团体 -
FAC:建筑物、机场、高速公路、桥梁等 -
ORG:公司、机构、机构等 -
GPE:国家、城市、州 -
LOC:非 GPE 地点、山脉、水体等 -
PRODUCT:物体、车辆、食品等(不包括服务) -
EVENT:命名的飓风、战役、战争、体育赛事等 -
WORK_OF_ART:书籍、歌曲等的标题 -
LAW:成为法律的命名文件 -
LANGUAGE:任何命名的语言 -
DATE:绝对或相对日期或时期 -
TIME:小于一天的时间 -
PERCENT:百分比,包括% -
MONEY:货币价值,包括单位 -
QUANTITY:测量值,如重量或距离 -
ORDINAL:第一、第二等 -
CARDINAL:不属于其他类型的数词
就像 POS 标记器的统计模型一样,NER 模型也是顺序模型。第一个现代 NER 标记器模型是条件随机字段(CRF)。CRF 是用于结构化预测问题(如标记和解析)的序列分类器。当前最先进的 NER 标记是使用transformers架构实现的(更多内容请参阅第六章)。
文档中的命名实体可以通过doc.ents属性访问。doc.ents是一个Span对象的列表,如下面的代码片段所示:
doc = nlp("The Brazilian president visited Beijing.")
print(doc.ents)
print(type(doc.ents[0]))
>>> (Brazilian, Beijing)
<class 'spacy.tokens.span.Span'>
spaCy 也为每个标记标记了实体类型。命名实体的类型可以通过token.ent_type(整数)和token.ent_type_(Unicode)访问。如果标记不是命名实体,那么token.ent_type_只是一个空字符串。
正如对于词性和依存标签一样,我们可以在标签字符串或token.ent_type_上调用spacy.explain(),如下所示:
doc = nlp("He worked for NASA.")
token = doc[3]
print(token.ent_type_, spacy.explain(token.ent_type_))
>>> ORG Companies, agencies, institutions, etc.
在标记不同的句法特征后,我们有时希望将实体合并或拆分为更少或更多的标记。在下一节中,我们将看到这种合并和拆分是如何进行的。
合并和拆分标记
在某些情况下,我们希望合并或拆分多词命名实体。例如,当分词器在某些不寻常的标记上表现不佳,需要手动拆分时,这就很有必要。在本小节中,我们将介绍一种针对我们的多词表达式、多词命名实体和错别字的非常实用的补救方法:doc.retokenize。
doc.retokenize用于上下文管理器,并且是合并和拆分doc对象跨度范围的正确工具。retokenizer.merge()方法应该接收要合并的跨度以及要设置在这些合并标记上的属性。让我们看看以下如何通过合并多词命名实体进行重新分词的示例:
-
首先,让我们从句子中创建一个
doc并打印实体:doc = nlp("She lived in New Hampshire.") print(doc.ents) -
现在,让我们看看 spaCy 是如何分离标记的:
print([(token.text, token.i) for token in doc]) >>> [('She', 0), ('lived', 1), ('in', 2), ('New', 3), ('Hampshire', 4), ('.', 5)] -
我们希望合并位置
3和4的标记,并且分割的切片设置为(包含值,不包含值),因此我们将分割doc[3:5]并设置这个新标记的LEMMA:with doc.retokenize() as retokenizer: retokenizer.merge( doc[3:5], attrs={"LEMMA": "new hampshire"}) -
让我们再次打印标记,看看合并是否成功:
print([(token.text, token.i) for token in doc]) >>> [('She', 0), ('lived', 1), ('in', 2), ('New Hampshire', 3), ('.', 4)]
合并标记工作得很好,但拆分多词标记为几个标记又会如何呢?在这个设置中,要么是想要修复的文本中存在错别字,要么是自定义分词对于你的特定句子来说不满意。
拆分跨度比合并跨度要复杂一些,原因如下:
-
我们正在改变依存句法树
-
我们需要为新标记分配新的词性标签、依存标签和必要的标记属性
基本上,我们需要考虑如何为新创建的标记分配语言特征。让我们通过以下如何修复错别字的示例来了解如何处理新标记:
doc = nlp("She lived in NewHampshire")
print([(token.text, token.lemma_, token.i) for token in doc])
>>> [('She', 'she', 0),
('lived', 'live', 1),
('in', 'in', 2),
('NewHampshire', 'NewHampshire', 3)]
图 3 .13 展示了在分割操作之前依存句法树的样子。

图 3.13 – 在重新分词之前样本句子的依存句法树
现在,我们将 doc[3] , NewHampshire ,拆分为两个标记:New 和 Hampshire 。我们将通过将新的标记的依赖关系通过 heads 参数传递给 retokenize.split() 方法,为新标记提供细粒度的 POS 标签和依赖标签。我们还将通过传递新标记的父节点通过 heads 参数来重新排列依赖树。在安排头部时,有两个事情需要考虑,如下所述:
-
首先,当你提供一个相对位置,例如
(doc[3], 1),这意味着doc[3]的头部将是 前一个位置 的标记——在这种情况下,那就是doc[4]。 -
其次,如果你提供一个绝对位置,这意味着在原始
Doc对象中的位置。在下面的代码片段中,heads列表中的第二个项目表示Hampshire标记的头是原始 Doc 中的第二个标记,即in标记。
让我们在代码中实现这个功能:
with doc.retokenize() as retokenizer:
heads = [(doc[3], 1), doc[2]]
attrs = {"TAG":["NNP", "NNP"], "DEP": ["compound", "pobj"]}
retokenizer.split(doc[3], ["New", "Hampshire"], heads=heads, attrs=attrs)
print([(token.text, token.lemma_, token.i) for token in doc])
>>> [('She', 'she', 0),
('lived', 'live', 1),
('in', 'in', 2),
('New', 'New', 3),
('Hampshire', '', 4)]
图 3 .14 展示了拆分操作后依赖树的样子。

图 3.14 – 拆分操作后的依赖树
你可以将合并和拆分操作应用于任何跨度,而不仅仅是命名实体跨度。这里最重要的部分是正确安排新的依赖树和语言属性。
摘要
本章为您提供了 spaCy 的语言特征及其使用方法的详细信息。您了解了 POS 标记和其应用,并了解了 spaCy 中的一个重要但不太为人所知且使用较少的特征——依赖标签。然后,我们发现了一个著名的 NLU 工具和概念:NER。我们通过示例了解了如何进行命名实体提取。最后,我们以一个方便的工具来合并和拆分跨度结束了本章。
接下来是什么?在下一章中,我们将发现如何使用这些语言特征通过 Matcher , PhraseMatcher ,和 SpanRuler 类来提取信息。
第四章:掌握基于规则的匹配
基于规则的实体抽取对于任何自然语言处理(NLP)流程都是必不可少的。某些类型的实体,如时间、日期和电话号码,具有独特的格式,可以通过一组规则进行识别,而无需训练统计模型。
在本章中,你将学习如何通过匹配模式和短语快速从文本中提取信息。你将使用 形态学 特征、词性(POS)标签、正则表达式(regexes)以及其他 spaCy 特征来形成模式对象,并将其提供给 Matcher 对象。你将继续使用基于规则的匹配进行细粒度统计模型,以提高统计模型的准确性。
到本章结束时,你将了解信息提取的一个关键部分。你还将能够提取特定格式的实体,以及特定领域的实体。
在本章中,我们将涵盖以下主要主题:
-
基于标记的匹配
-
使用
PhraseMatcher创建模式 -
使用
SpanRuler创建模式 -
结合 spaCy 模型和匹配器
技术要求
本章的代码可以在github.com/PacktPublishing/Mastering-spaCy-Second-Edition找到。我们使用 Python 3.10 和 spaCy 3.7.4。
基于标记的匹配
一些自然语言理解(NLU)任务可以在不借助任何统计模型的情况下解决。其中一种方法就是使用 正则表达式,我们用它来将预定义的模式集与我们的文本进行匹配。
正则表达式是一系列字符,用于指定搜索模式。正则表达式描述了一组遵循指定模式的字符串。这些模式可以包括字母、数字和具有特殊意义的字符,如 ?、. 和 *。Python 内置库 re 提供了强大的支持来定义和匹配正则表达式。
那么,正则表达式看起来是什么样子呢?以下正则表达式匹配以下字符串:
"Barack Obama"
"Barack Obama"
"Barack Hussein Obama"
reg = r"Barack\s(Hussein\s)?Obama"
这个模式可以这样读取:字符串 Barack 可以可选地后跟字符串 Hussein(正则表达式中的 ? 字符表示可选;即 0 或 1 次出现)并且应该后跟字符串 Obama。单词间的空格可以是一个空格字符、一个制表符或任何其他空白字符(\s 匹配所有类型的空白字符,包括换行符)。
即使是如此简短且简单的模式,也不太易读,对吧?正则表达式的缺点如下:
-
难以阅读
-
调试困难
-
空格、标点符号和数字字符容易出错
由于这些原因,许多软件工程师不喜欢在生产代码中使用正则表达式。spaCy 提供了一个非常干净、易读、生产级和可维护的替代方案:Matcher 类。Matcher 类可以将我们预定义的规则与 Doc 和 Span 对象中的标记序列进行匹配。正如我们将在本章中看到的,规则还可以引用标记或其语言属性。
让我们从如何调用 Matcher 类的基本示例开始:
-
首先,我们导入库、
Matcher对象、Span标记,并加载模型:import spacy from spacy.matcher import Matcher from spacy.tokens import Span nlp = spacy.load("en_core_web_sm") -
现在,我们实例化
Matcher对象,传入模型的词汇表,定义一个模式,并将其以标签morningGreeting添加到Matcher对象中:matcher = Matcher(nlp.vocab) pattern = [{"LOWER": "good"}, {"LOWER": "morning"}, {"IS_PUNCT": True}] matcher.add("morningGreeting", [pattern]) -
最后,我们可以处理文本。为了使用 displaCy 可视化
Span对象,我们将Span对象添加到列表中,并将doc.spans["sc"]赋值给此列表。sc实例是默认的span_key值(任意Span对象的组)。以下是代码:doc = nlp("Good morning, I want to reserve a ticket.") matches = matcher(doc) spans = [] for match_id, start, end in matches: spans.append(Span(doc, start, end, nlp.vocab.strings[match_id])) doc.spans["sc"] = spans -
现在,让我们使用
displacy显示 spans:from spacy import displacy displacy.render(doc, style="span")
图 4 .1 展示了上一段代码块的结果:

图 4.1 – 第一个 Matcher 模式的 Span 匹配
你可以按以下方式读取前一个 步骤 2 列表中的 Matcher 模式:
-
一个文本转换为小写后为
good的标记 -
一个文本转换为小写后为
morning的标记 -
一个标点符号(即,
IS_PUNCT特征为True)
匹配结果是一个三元组列表,形式为 (match id,起始位置,和 结束位置)。你可能已经注意到,Good 和 morning 之间的空白根本不重要。事实上,我们可以在它们之间放两个空格,写下 Good morning,结果将是相同的。为什么?因为 Matcher 只匹配标记和标记属性。
模式始终引用标记对象的连续序列,并且每个括号中的项对应一个标记对象。让我们回到前面代码片段中的模式:
pattern = [{"LOWER": "good"}, {"LOWER": "morning"},
{"IS_PUNCT": True}]
结果始终是三个标记的匹配。我们能否添加多个模式?答案是肯定的。让我们通过以下示例看看:
-
如前所述,导入库并设置
Matcher对象:import spacy from spacy.matcher import Matcher from spacy.tokens import Span nlp = spacy.load("en_core_web_sm") matcher = Matcher(nlp.vocab) -
定义两个模式并将它们添加到
Matcher对象中:pattern1 = [{"LOWER": "good"}, {"LOWER": "morning"}, {"IS_PUNCT": True}] matcher.add("morningGreeting", [pattern1]) pattern2 = [{"LOWER": "good"}, {"LOWER": "evening"}, {"IS_PUNCT": True}] matcher.add("eveningGreeting", [pattern2]) -
处理文本,将
doc对象发送到Matcher对象,并将Span对象存储在列表中:doc = nlp("Good morning, I want to reserve a ticket. I will then say good evening!") matches = matcher(doc) spans = [] for match_id, start, end in matches: pattern_name = nlp.vocab.strings[match_id] spans.append(Span(doc, start, end, pattern_name)) doc.spans["sc"] = spans -
现在,我们可以使用 displacy 显示
Span对象:from spacy import displacy displacy.render(doc, style="span")
图 4 .2 展示了使用新模式的匹配结果:

图 4.2 – 使用两种模式进行 Span 匹配
在前面的代码示例中,pattern1 和 pattern2 只在单个标记上有所不同:evening** / **morning。我们是否可以用 IN 属性来表示晚上或早上,而不是编写两个模式?让我们在下一节中了解更多。
扩展语法支持
Matcher 允许在花括号内使用一些运算符,从而使模式更加丰富。这些运算符用于扩展比较,类似于 Python 的 in、not in 和 比较 运算符。您可以在 spaCy 的文档中查看完整的属性列表,文档可在 spacy.io/api/matcher/#patterns 找到。之前我们使用两个不同的模式匹配了 good evening 和 good morning。现在,我们可以通过使用 IN 来匹配 good morning** / **evening,如下所示:
pattern = [{"LOWER": "good"},
{"LOWER": {"IN": ["morning", "evening"]}},
{"IS_PUNCT": True}]
matcher.add("greetings", [pattern])
doc = nlp("Good morning, I'm here. I'll say good evening!!")
matches = matcher(doc)
spans = []
for match_id, start, end in matches:
pattern_name = nlp.vocab.strings[match_id]
spans.append(Span(doc, start, end, pattern_name))
doc.spans["sc"] = spans
比较运算符通常与 LENGTH 属性一起使用。以下是一个查找长标记的示例:
pattern = [{"LENGTH": {">=" : 10}}]
matcher.add("longWords", [pattern])
doc = nlp("I suffered from Trichotillomania when I was in college. The doctor prescribed me Psychosomatic medicine.")
matches = matcher(doc)
spans = []
for match_id, start, end in matches:
pattern_name = nlp.vocab.strings[match_id]
spans.append(Span(doc, start, end, pattern_name))
doc.spans["sc"] = spans
图 4 .3 展示了使用此模式的匹配结果:

图 4.3 – 使用 LENGTH 模式匹配的结果
在下一节中,我们将探讨一些最常用的标记属性,这些属性用于创建模式。
标记属性
让我们通过一些示例来回顾一些有用的标记模式键。在前面的例子中我们使用了 LOWER;它表示标记文本的小写形式。ORTH 和 TEXT 与 LOWER 类似:它们表示对标记文本的精确匹配,包括大小写。以下是一个示例:
pattern = [{"TEXT": "Bill"}]
上述代码将匹配 Bill 但不会匹配 bill。
下一个标记属性块是 IS_ALPHA、IS_ASCII 和 IS_DIGIT。这些特性对于查找数字标记和普通单词很有用。以下模式匹配两个标记的序列,一个数字后面跟一个普通单词:
pattern = [{"IS_DIGIT": True},{"IS_ALPHA": True}]
matcher.add("numberAndPlainWord", [pattern])
doc1 = nlp("I met him at 2 o'clock.")
matches = matcher(doc1)
spans = []
for match_id, start, end in matches:
pattern_name = nlp.vocab.strings[match_id]
spans.append(Span(doc1, start, end, pattern_name))
doc1.spans["sc"] = spans
displacy.render(doc1, style="span")
在前面的代码段中,2 o'clock 没有匹配到模式,因为 o'clock 包含撇号,这不是一个字母字符(字母字符是数字、字母和下划线字符)。让我们使用另一个句子来测试这个模式:
doc2 = nlp("He brought me 2 apples.")
matches = matcher(doc2)
spans = []
for match_id, start, end in matches:
pattern_name = nlp.vocab.strings[match_id]
spans.append(Span(doc2, start, end, pattern_name))
doc2.spans["sc"] = spans
displacy.render(doc2, style="span")
图 4 .4 显示了 2 个苹果 匹配的原因是 apples 标记由字母组成:

图 4.4 – 使用数字和平常单词模式匹配
IS_LOWER、IS_UPPER 和 IS_TITLE 是用于识别标记大小写的有用属性。如果标记全部为大写字母,则 IS_UPPER 为 True;如果标记以大写字母开头,则 IS_TITLE 为 True。如果标记全部为小写字母,则 IS_LOWER 为 True。想象一下,如果我们想在文本中找到强调的单词;一种方法就是寻找全部为大写字母的标记。大写标记通常在情感分析模型中具有显著的重要性。以下是一个示例:
pattern = [{"IS_UPPER": True}]
matcher.add("capitals", [pattern])
doc = nlp("Take me out of your SPAM list. We never asked you to contact me. If you write again we'll SUE!!!!")
matches = matcher(doc)
spans = []
for match_id, start, end in matches:
pattern_name = nlp.vocab.strings[match_id]
spans.append(Span(doc, start, end, pattern_name))
doc.spans["sc"] = spans
displacy.render(doc, style="span")
IS_PUNCT、IS_SPACE 和 IS_STOP 通常用于包含一些辅助标记的模式中,分别对应于标点符号、空格和停用词标记(停用词是语言中不携带太多信息的常见单词,例如英语中的 a、an 和 the)。IS_SENT_START 是另一个有用的属性;它匹配句子开头的标记。以下是一个以单词 can 开头且第二个单词首字母大写的句子模式:
-
在这个模式中,我们将把两个属性放入一个大括号中。
pattern中的第一个项目意味着一个标记是句子的第一个标记,并且其小写文本为can:pattern = [{"IS_SENT_START": True, "LOWER": "can"}, {"IS_TITLE": True}] matcher.add("canThenCapitalized", [pattern]) -
现在,我们处理文本并显示匹配结果:
doc2 = nlp("Can Sally swim?") matches = matcher(doc2) spans = [] for match_id, start, end in matches: pattern_name = nlp.vocab.strings[match_id] spans.append(Span(doc2, start, end, pattern_name)) doc2.spans["sc"] = spans displacy.render(doc2, style="span")
图 4 .5 显示了前面列表的匹配结果:

图 4.5 – 使用两个标记进行匹配
我们可以给大括号添加任意多的属性。例如,{"IS_SENT_START": False, "IS_TITLE": True, "LOWER": "bill"} 是一个完全有效的属性字典,它描述了一个大写字母开头、不是句子第一个标记,并且文本为 bill 的标记。因此,它是那些作为句子第一个单词不出现的 bill 实例的集合。
LIKE_NUM、LIKE_URL 和 LIKE_EMAIL 是与标记形状相关的属性;我们在 第三章 中讨论了它们。这些属性匹配看起来像数字、URL 和电子邮件的标记。
现在,让我们看看 POS、TAG、DEP、LEMMA 和 SHAPE 语言属性。您在上一章中看到了这些标记属性;现在,我们将使用它们进行标记匹配。以下代码片段查找以助动词开头的句子:
pattern = [{"IS_SENT_START": True, "TAG": "MD"}]
matcher.add("sentStartAuxBVerb", [pattern])
doc = nlp("Will you go there?")
matches = matcher(doc)
MD 是情态动词和助动词的标记。前面的代码片段是查找是/否疑问句的标准方法。在这种情况下,我们通常寻找以情态动词或助动词开头的句子。
当我们想要提取一个单词的含义时,我们通常将 TEXT/LEMMA 与 POS/TAG 结合。例如,当 match 是动词时,它需要与 POS/TAG 结合,或者当它是名词时,它可以是一个点火工具。在这种情况下,我们做出以下区分:
{"LEMMA": "match", "** **POS": "VERB"}
{"LEMMA": "match", "** **POS": "NOUN"}
同样,你可以将其他语言特征与标记形状属性结合,以确保只提取你想要的模式。
在接下来的章节中,我们将看到更多将语言特征与 Matcher 类结合的示例。现在,我们将继续探讨 Matcher 模式的一个非常实用的特性:类似正则表达式的操作符。
类似正则表达式的操作符
在本章的开头,我们指出 spaCy 的Matcher类提供了对正则表达式操作的更干净、更易读的等效方法,确实更干净、更易读。最常见的正则表达式操作是可选匹配(?)、至少匹配一次(+)和匹配 0 次或多次(*)。您可以在以下位置查看 spaCy 的Matcher运算符的完整列表:spacy.io/api/matcher/#patterns。本章的第一个正则表达式示例是匹配 Barack Obama 的名字,中间名是可选的。正则表达式如下:
R"Barack\s(Hussein\s)?Obama
?运算符在Hussein之后表示括号内的模式是可选的,因此这个正则表达式可以匹配Barack Obama和Barack Hussein Obama。我们在Matcher模式中使用?运算符如下:
pattern = [{"LOWER": "barack"},
{"LOWER": "hussein", "OP": "?"},
{"LOWER": "obama"}]
matcher.add("obamaNames", [pattern])
doc1 = nlp("Barack Obama visited France.")
doc2 = nlp("Barack Hussein Obama visited France.")
在这里,通过在第二个列表项中使用"OP": "?",我们使这个标记可选。匹配器选择了第一个doc对象中的Barack Obama和第二个中的Barack Hussein Obama,正如你在图 4 .6中可以看到:

图 4.6 – 使用正则表达式进行匹配
我们之前指出,+和*运算符与它们的正则表达式对应物具有相同的意义。+表示标记至少出现一次,而*表示标记可以出现 0 次或多次。让我们看看一些例子:
pattern = [{"LOWER": {"IN": ["hello", "hi", "hallo"]}, "OP":"+"},
{"IS_PUNCT": True}]
matcher.add("greetings", [pattern])
doc1 = nlp("Hello hello hello, how are you?")
doc2 = nlp("Hi, how are you?")
doc3 = nlp("How are you?")
for doc in [doc1, doc2, doc3]:
spans = []
matches = matcher(doc)
for match_id, start, end in matches:
pattern_name = nlp.vocab.strings[match_id]
spans.append(Span(doc, start, end, pattern_name))
doc.spans["sc"] = spans
displacy.render(doc, style="span")
图 4 .7显示了当我们使用+运算符时会发生什么:

图 4.7 – 使用+运算符进行匹配
在模式中,第一个标记读作hello、hi或hallo中的任何一个,应该出现一次或多次。注意模式的贪婪性质(每个hello实例都得到匹配)。第二个 doc 也有匹配,但第三个没有(因为它没有hello、hi或hallo中的任何词)。
当我们查看第一个 doc 对象匹配的结果时,我们看到不仅有一次,而是有三个不同的匹配。这是完全正常的,因为确实有三个序列与模式匹配。如果你仔细查看匹配结果,你会发现它们都匹配我们创建的模式,因为它们都匹配(** **hello)+模式。
让我们用*来做同样的模式,看看这次会发生什么:
pattern = [{"LOWER": {"IN": ["hello", "hi", "hallo"]},
"OP": "*"}, {"IS_PUNCT": True}]
matcher.add("greetings", [pattern])
doc1 = nlp("Hello hello hello, how are you?")
doc2 = nlp("Hello, how are you?")
doc3 = nlp("How are you?")
for doc in [doc1, doc2, doc3]:
spans = []
matches = matcher(doc)
for match_id, start, end in matches:
pattern_name = nlp.vocab.strings[match_id]
spans.append(Span(doc, start, end, pattern_name))
doc.spans["sc"] = spans
displacy.render(doc, style="span")
图 4 .8显示了结果:

图 4.8 – 使用*运算符的匹配
现在,仅凭标点符号而没有问候词被选中。这可能不是你希望在 NLP 应用中看到的情况。
上述例子是一个很好的例子,说明我们在创建模式时应该小心;有时我们会得到不想要的匹配。因此,我们通常考虑使用IS_SENT_START并使用*运算符来处理其余部分。
spaCy Matcher类还接受一个非常特殊的模式,即通配符标记模式。通配符标记将匹配任何标记。我们通常用它来选择我们想要独立于它们的文本或属性或忽略的单词。让我们看一个例子:
matcher = Matcher(nlp.vocab)
pattern = [{"LOWER": "name"},{"LEMMA": "be"},{}]
matcher.add("pickName", [pattern])
doc = nlp("My name is Alice and his name was Elliot.")
matches = matcher(doc)
spans = []
for match_id, start, end in matches:
pattern_name = nlp.vocab.strings[match_id]
spans.append(Span(doc, start, end, pattern_name))
doc.spans["sc"] = spans
displacy.render(doc, style="span")
在这里,我们想要捕捉句子中的名字。我们通过解析形式为name is/was/be firstname的标记序列实现了这一点。第一个标记模式,LOWER: "name",匹配文本小写后的文本为name的标记。第二个标记模式,LEMMA: "be",匹配is、was和be标记。第三个标记是通配符标记,{},表示任何标记。我们使用这个模式拾取任何在name is/was/be之后的标记。图 4.9 .9显示了结果:

图 4.9 – 使用通配符标记的匹配
当我们想要忽略一个标记时,我们也会使用通配符标记。让我们一起来做一个例子:
pattern = [{"LEMMA": "forward"}, {}, {"LOWER": "email"}]
matcher.add("forwardMail", [pattern])
doc1 = nlp("I forwarded his email to you.")
doc2 = nlp("I forwarded an email to you.")
doc3 = nlp("I forwarded the email to you.")
for doc in [doc1, doc2, doc3]:
spans = []
matches = matcher(doc)
for match_id, start, end in matches:
pattern_name = nlp.vocab.strings[match_id]
spans.append(Span(doc, start, end, pattern_name))
doc.spans["sc"] = spans
displacy.render(doc, style="span")
这与前面的例子正好相反。在这里,我们想要捕捉forward email序列,并且允许一个标记在forward和email之间。在这种情况下,语义上重要的部分是转发电子邮件的动作;它是谁的电子邮件并不重要。
到目前为止,我们已经在本章中提到了很多正则表达式,现在是时候看看 spaCy 的Matcher类如何使用正则表达式语法了。
正则表达式支持
当我们匹配单个标记时,通常我们想要允许一些变化,例如常见的拼写错误、UK/US 英语字符差异等。正则表达式非常适合这项任务,spaCy Matcher提供了对标记级正则表达式匹配的全支持。让我们探索如何为我们自己的应用使用正则表达式:
pattern = [{"POS": "PRON"},
{"TEXT": {"REGEX": "[Tt]ravell?ed"}}]
matcher.add("regex", [pattern])
doc1 = nlp("I travelled by bus.")
doc2 = nlp("She traveled by bike.")
for doc in [doc1, doc2]:
spans = []
matches = matcher(doc)
for match_id, start, end in matches:
pattern_name = nlp.vocab.strings[match_id]
spans.append(Span(doc, start, end, pattern_name))
doc.spans["sc"] = spans
displacy.render(doc, style="span")
在这里,我们的第二个标记模式是[Tt]ravell?ed,这意味着标记可以是首字母大写也可以不是。此外,在第一个l实例之后有一个可选的l实例。允许双元音和 ise/ize 变化是处理英国和美式英语变化的标准方式。
使用正则表达式还有另一种方式,即不仅与文本一起使用,还与 POS 标签一起使用。以下代码段做了什么?
pattern = [{"TAG": {"REGEX": "^V"}}]
matcher.add("verbs", [pattern])
doc = nlp("I went to Italy; he has been there too. His mother also has told me she wants to visit Rome.")
spans = []
for match_id, start, end in matches:
pattern_name = nlp.vocab.strings[match_id]
spans.append(Span(doc, start, end, pattern_name))
doc.spans["sc"] = spans
displacy.render(doc, style="span")
我们已经提取了所有的有限动词(你可以将有限动词视为非情态动词)。我们是如何做到这一点的呢?我们的标记模式包括正则表达式^V,这意味着所有以 V 开头的细粒度 POS 标签:VB、VGD、VBG、VBN、VBP和VBZ。然后,我们提取了具有动词 POS 标签的标记。
Matcher 在线演示
spaCy Matcher在其在线演示页面上提供了一个工具:explosion.ai/demos/matcher。我们可以创建模式并交互式地测试它们与我们要测试的文本。
在 图 4 .10 中,我们可以看到一个匹配示例。在右侧,我们可以选择属性、值和运算符(如 + 、 * 、 ! 和 ?)。在做出此选择后,演示在复选框下方右侧输出相应的模式字符串。在左侧,我们首先选择我们想要的 spaCy 语言模型(在本例中为英语核心小型),然后查看结果:

图 4.10 – spaCy 的基于规则的 Matcher 探索器
spaCy 的 Matcher 示例帮助你了解为什么你的模式匹配或未匹配。
使用 PhraseMatcher 创建模式
在处理金融、医疗或法律文本时,我们经常有长列表和字典,我们希望将文本与我们的列表进行扫描。正如我们在上一节中看到的,Matcher 模式相当是手工制作的;我们逐个编码每个标记。如果你有一长串短语列表,Matcher 并不很方便。不可能逐个编码所有术语。
spaCy 为比较文本与长字典提供了一种解决方案 – PhraseMatcher 类。PhraseMatcher 类帮助我们匹配长字典。让我们从一个使用 PhraseMatcher 匹配列表中定义的术语的基本示例开始:
-
导入库和类,并像往常一样实例化
nlp管道:import spacy from spacy.matcher import PhraseMatcher nlp = spacy.load("en_core_web_sm") -
现在,我们可以实例化
PhraseMatcher对象,并对每个术语逐个调用nlp.make_doc()来创建模式:matcher = PhraseMatcher(nlp.vocab) terms = ["Angela Merkel", "Donald Trump", "Alexis Tsipras"] patterns = [nlp.make_doc(term) for term in terms] matcher.add("politiciansList", patterns) -
最后,我们检查匹配项:
doc = nlp("3 EU leaders met in Berlin. German chancellor Angela Merkel first welcomed the US president Donald Trump. The following day Alexis Tsipras joined them in Brandenburg.") matches = matcher(doc) spans = [] for match_id, start, end in matches: pattern_name = nlp.vocab.strings[match_id] spans.append(Span(doc, start, end, pattern_name)) doc.spans["sc"] = spans displacy.render(doc, style="span")
这样,我们通过它们的精确文本值来匹配模式,如图 图 4 .11 所示:

图 4.11 – 使用 PhraseMatcher 进行匹配
如果我们想用其他属性进行匹配怎么办?这里是一个通过 LOWER 属性进行匹配的示例。
首先,我们创建一个 PhraseMatcher 实例,传递一个额外的参数,attr=LOWER。这样,PhraseMatcher 在匹配时使用 token.lower 属性:
matcher = PhraseMatcher(nlp.vocab, attr="LOWER")
terms = ["Asset", "Investment", "Derivatives", "Demand", "Market"]
patterns = [nlp.make_doc(term) for term in terms]
matcher.add("financeTerms", patterns)
现在,让我们显示结果:
doc = nlp("During the last decade, derivatives market became an asset class of their own and influenced the financial landscape strongly.")
matches = matcher(doc)
spans = []
for match_id, start, end in matches:
pattern_name = nlp.vocab.strings[match_id]
spans.append(Span(doc, start, end, pattern_name))
doc.spans["sc"] = spans
displacy.render(doc, style="span")
图 4 .12 显示了匹配结果:

图 4.12 – 使用 PhraseMatcher LOWER 属性进行匹配
PhraseMatcher 的另一个可能的用法是匹配 SHAPE 属性。这种匹配策略可以用于系统日志,其中 IP 地址、日期和其他数值出现很多。这里的好事是您不必担心数字是如何分词的;您只需将其留给 PhraseMatcher。让我们看一个例子:
matcher = PhraseMatcher(nlp.vocab, attr="SHAPE")
ip_nums = ["127.0.0.0", "127.256.0.0"]
patterns = [nlp.make_doc(ip) for ip in ip_nums]
matcher.add("IPNums", patterns)
doc = nlp("This log contains the following IP addresses: 192.1.1.1 and 192.160.1.1 .")
matches = matcher(doc)
spans = []
for match_id, start, end in matches:
pattern_name = nlp.vocab.strings[match_id]
spans.append(Span(doc, start, end, pattern_name))
doc.spans["sc"] = spans
displacy.render(doc, style="span")
图 4 .13 显示了结果:

图 4.13 – 使用 PhraseMatcher SHAPE 属性进行匹配
很方便,对吧?我们成功匹配了标记和短语;现在,让我们继续到命名实体识别(NER)。命名实体提取是任何 NLP 系统的基本组成部分,你将要设计的多数管道都将包括一个 NER 组件。下一节将专注于基于规则的命名实体提取。
使用 SpanRuler 创建模式
spaCy 的SpanRuler组件允许我们使用基于标记的规则或精确短语匹配将跨度添加到Doc.spans和/或Doc.ents字典中。
SpanRuler不是一个匹配器;它是一个管道组件,我们可以通过nlp.add_pipe将其添加到我们的管道中。当它找到匹配项时,匹配项将被追加到doc.ents或doc.spans中。如果添加到doc.ents,ent_type将是我们在模式中传递的标签。让我们看看它是如何工作的:
-
首先,为实体定义一个模式:
patterns = [{"label": "ORG", "pattern": [{"LOWER": "chime"}]}] -
现在,我们添加
SpanRuler组件。默认情况下,它将跨度添加到doc.spans中,而我们希望将其添加到doc.ents中,所以我们在配置中指定了这一点:span_ruler = nlp.add_pipe( "span_ruler", config={"annotate_ents":True}) -
现在,我们可以将模式添加到组件中并处理文本:
span_ruler.add_patterns(patterns) doc = nlp("I have an acccount with chime since 2017") displacy.render(doc, style="ent")
图 4.14显示了我们所匹配的实体:

图 4.14 – 使用 SpanRuler 创建的实体
我们可以在图 4.14中看到,chime标记被添加到了Doc.ents字典中。如果你不想覆盖现有的实体,可以将overwrite设置为False。让我们试试:
nlp.remove_pipe("span_ruler")
patterns = [{"label": "ORG",
"pattern": [{"LOWER": "chime"}]}]
span_ruler = nlp.add_pipe(
"span_ruler", config={"annotate_ents":True, "overwrite":False})
span_ruler.add_patterns(patterns)
doc = nlp("I have an acccount with chime since 2017")
displacy.render(doc, style="ent")
图 4.15显示了结果。现在,由ner组件添加的实体也出现了(你将在第五章中了解更多关于组件和管道的内容):

图 4.15 – 使用 SpanRuler 和 ner 组件创建的实体
就这样——简单,却强大。我们只用了几行代码就添加了自己的实体。
现在我们已经看到了如何使用Matcher类和SpanRuler提取信息,我们将继续到一个专门的部分,快速且非常实用的食谱。
结合 spaCy 模型和匹配器
在本节中,我们将介绍一些食谱,这些食谱将指导你了解你可能在 NLP 旅程中遇到的实体提取类型。所有示例都是现成的、真实世界的食谱。让我们从数字格式化的实体开始。
提取 IBAN
IBAN是金融和银行业中经常出现的重要实体类型。我们将学习如何解析它。
IBAN 是一种国际银行账户号码格式。它由两位数字的国家代码和随后的数字组成。
我们如何创建一个 IBAN 的模式?我们首先用两个大写字母开始,然后是两个数字。接着,可以跟任意数量的数字。我们可以这样表示国家代码和接下来的两个数字:
{"SHAPE": "XXdd"}
这里,XX 代表两个大写字母,而dd 是两个数字。然后,XXdd 模式完美地匹配 IBAN 的第一个数字块。那么其他数字块呢?对于其他块,我们需要匹配一个一到四个数字的块。\d{1,4}正则表达式表示一个由一到四个数字组成的标记。这个模式将匹配一个数字块:
{"TEXT": {"REGEX": "\d{1,4}"}}
我们有这些块的数量,所以匹配 IBAN 数字块的模式如下:
{"TEXT": {"REGEX": "\d{1,4}"}, "OP": "+"}
然后,我们将第一个形状块与其他块结合起来。让我们检查模式的完整代码:
-
定义模式并将其添加到
Matcher对象中:pattern = [{"SHAPE": "XXdd"}, {"TEXT": {"REGEX": "\d{1,4}"}, "OP":"+"}] matcher = Matcher(nlp.vocab) matcher.add("ibanNum", [pattern]) -
现在,让我们添加代码来显示匹配项:
doc = nlp("My IBAN number is BE71 0961 2345 6769, please send the money there.") doc1 = nlp("My IBAN number is FR76 3000 6000 0112 3456 7890 189, please send the money there.") for doc in [doc, doc1]: spans = [] matches = matcher(doc) for match_id, start, end in matches: pattern_name = nlp.vocab.strings[match_id] spans.append(Span(doc, start, end, pattern_name)) doc.spans["sc"] = spans displacy.render(doc, style="span")
图 4.16 显示了结果。在解析数字实体时,你可以始终遵循类似的策略:首先,将实体分成一些有意义的部分/块,然后尝试确定各个块的形式或长度:

图 4.16 – 提取 IBAN
我们成功解析了 IBAN。现在,我们将提取另一种常见的数字实体:电话号码。
提取电话号码
电话号码的格式因国家而异,匹配电话号码通常是一项棘手的工作。这里的最佳策略是明确你想要解析的国家电话号码格式。如果有多个国家,你可以在匹配器中添加相应的单个模式。如果你有太多的国家,那么你可以放宽一些条件,采用更通用的模式(我们将看到如何做到这一点)。
让我们从美国的电话号码格式开始。美国国内电话号码写作(541)754-3010,国际电话号码写作+1(541)754-3010。我们可以用一个可选的+1实例,然后是一个三位数的区号,然后是两个用可选的-实例分隔的数字块来形成我们的模式。以下是模式:
{"TEXT": "+1", "OP": "?"}, {"TEXT": "("}, {"SHAPE": "ddd"}, {"TEXT": ")"}, {"SHAPE": "ddd"}, {"TEXT": "-", "OP": "?"}, {"SHAPE": "dddd"}
让我们看看模式的例子:
pattern = [{"TEXT": "+1", "OP": "?"}, {"TEXT": "("},
{"SHAPE": "ddd"}, {"TEXT": ")"},
{"SHAPE": "ddd"}, {"TEXT": "-", "OP": "?"},
{"SHAPE": "dddd"}]
matcher = Matcher(nlp.vocab)
matcher.add("usPhonNum", [pattern])
接下来,我们有一些示例句子和显示匹配项的代码:
doc1 = nlp("You can call my office on +1 (221) 102-2423 or email me directly.")
doc2 = nlp("You can call me on (221) 102 2423 or text me.")
for doc in [doc1, doc2]:
spans = []
matches = matcher(doc)
for match_id, start, end in matches:
pattern_name = nlp.vocab.strings[match_id]
spans.append(Span(doc, start, end, pattern_name))
doc.spans["sc"] = spans
displacy.render(doc, style="span")
图 4.17 显示了结果。我们是否可以将模式变得更通用,以便也适用于其他国家?在这种情况下,我们可以从一个一到三位数的国家代码开始,后面跟一些数字块。这将匹配更广泛的数字集合,因此最好小心不要匹配文本中的其他数字实体:

图 4.17 – 提取电话号码
我们将把文本实体从数字实体中提取出来。现在,我们将处理社交媒体文本并提取社交媒体文本中可能出现的不同类型的实体。
提取提及
想象一下分析关于公司和个人产品的社交媒体帖子数据集,你的任务是找出以何种方式提及了哪些公司。数据集将包含这些类型的句子:
CafeA is very generous with the portions.
CafeB is horrible, we waited for mins for a table.
RestaurantA is terribly expensive, stay away!
RestaurantB is pretty amazing, we recommend.
我们要找的可能是BusinessName is/was/be adverb形容词形式的模式。以下模式将有效:
[{"ENT_TYPE": "ORG"}, {"LEMMA": "be"}, {"POS": "ADV", "OP": "*"}, {"POS": "ADJ"}]
这里,我们寻找一个组织类型实体,然后是一个is/was/be实例,接着是可选的副词,最后是一个形容词。
如果你想提取一个特定的商业实体——比如说,ACME 公司?你只需要将第一个标记替换为特定的公司名称:
[{"LOWER": "acme"}, {"LEMMA": "be"}, {"POS": "ADV", "OP": "*"}, {"POS": "ADJ"}]
就这样——简单易懂!在提取社交媒体提及之后,接下来要做的事情是提取哈希标签。
哈希标签提取
处理社交媒体文本有一些挑战。社交媒体文本有一个不寻常的标记类型:hashtags。它们对文本的意义有巨大影响。哈希标签指的是句子的主题/对象。
哈希标签由一个#字符开头,然后是一个 ASCII 字符的单词,没有单词间空格。一些例子是#MySpace,#MondayMotivation等等。spaCy 分词器将这些单词分词成两个标记:
doc = nlp("#MySpace")
print([token.text for token in doc])
>>> ['#', 'MySpace']
因此,我们的模式需要匹配两个标记:#字符和其余部分。以下模式可以轻松匹配 hashTag:
{"TEXT": "#"}, {"IS_ASCII": True}
以下模式提取了一个哈希标签:
pattern = [{"TEXT": "#"}, {"IS_ASCII": True}]
matcher = Matcher(nlp.vocab)
matcher.add("hashTag", [pattern])
现在,让我们使用句子"Start working out** **now #WeekendShred"来显示匹配结果:
doc = nlp("Start working out now #WeekendShred")
matches = matcher(doc)
spans = []
for match_id, start, end in matches:
pattern_name = nlp.vocab.strings[match_id]
spans.append(Span(doc, start, end, pattern_name))
doc.spans["sc"] = spans
displacy.render(doc, style="span")
同样简单。图 4 .18 展示了结果:

图 4.18 – 匹配 hashTag 模式
表情符号是另一种不寻常的标记,它有可能将情感赋予一个句子。我们还可以使用 spacymoji 包(spacy.io/universe/project/spacymoji)提取表情符号标记。
现在,让我们提取一些实体。我们将在下一节中介绍扩展命名实体的常用方法。
扩展命名实体
通常,我们希望将命名实体的范围扩展到左侧或右侧。想象一下,你想提取带有标题的PERSON类型命名实体,这样你可以轻松推断性别或职业。spaCy 的NER类已经提取了人名,那么标题呢?
doc = nlp("Ms. Smith left her house 2 hours ago.")
print(doc.ents)
>>> (Smith, 2 hours ago)
如你所见,单词Ms.没有包含在命名实体中,因为它不是人名的一部分。一个快速的解决方案是创建一个新的实体类型,称为TITLE:
nlp.remove_pipe("span_ruler")
patterns = [{"label": "TITLE",
"pattern": [{"LOWER": {"IN": [
"ms.", "mr.", "mrs.", "prof.", "dr."]}}]}]
ruler = nlp.add_pipe("span_ruler",
config={"annotate_ents":True, "overwrite":False})
ruler.add_patterns(patterns)
现在,让我们再次显示匹配结果:
doc = nlp("Ms. Smith left her house")
displacy.render(doc, style="ent")
图 4 .19 展示了结果:

图 4.19 – 使用 Matcher 扩展实体
这是一个快速且非常实用的方法。如果你处理维基文本或财经文本,经常会遇到解析标题。
摘要
在本章中,你学习了如何使用语言和标记级特征进行基于规则的匹配。你学习了关于Matcher类,spaCy 的基于规则的匹配器。我们通过使用不同的标记特征,如形状、词元、文本和实体类型,来探索Matcher类。
然后,你学习了关于SpanRuler的知识,这是一个可以让你取得很多成就的救命工具。你还学习了如何使用SpanRuler类提取命名实体。
最后,我们将本章所学内容与你的先前知识相结合,并通过几个示例将语言特征与基于规则的匹配相结合。你学习了如何提取模式、特定格式的实体以及特定领域的实体。
通过本章,你完成了语言特征的构建。在下一章中,我们将利用所有这些知识,通过 spaCy 管道从文本中提取语义表示。
第五章:使用 spaCy 管道提取语义表示
在本章中,我们将把在第四章中学到的知识应用到航空公司旅行信息系统(ATIS)这个知名机票预订系统数据集上。数据包括用户询问信息的句子。首先,我们将提取命名实体,使用SpanRuler创建自己的提取模式。然后,我们将使用DepedencyMatcher模式确定用户话语的意图。我们还将使用代码提取意图,并创建自己的自定义 spaCy 组件,使用Language.pipe()方法以更快的速度处理大型数据集。
在本章中,我们将涵盖以下主要主题:
-
使用
SpanRuler提取命名实体 -
使用
DependencyMatcher提取依存关系 -
使用扩展属性创建管道组件
-
使用大数据集运行管道
技术要求
在本章中,我们将处理一个数据集。数据集和本章代码可以在github.com/PacktPublishing/Mastering-spaCy-Second-Edition找到。
我们将使用pandas库来操作我们的数据集。我们还将使用wget命令行工具。pandas可以通过pip安装,而wget在许多 Linux 发行版中是预安装的。
使用SpanRuler提取命名实体
在许多自然语言处理应用中,包括语义解析,我们通过检查实体类型并将实体提取组件放入我们的 NLP 管道中来开始寻找文本中的意义。命名实体在理解用户文本的意义中起着关键作用。
我们还将通过从我们的语料库中提取命名实体来启动语义解析管道。为了了解我们想要提取哪种类型的实体,首先,我们将了解 ATIS 数据集。
了解 ATIS 数据集
在本章中,我们将使用 ATIS 语料库。ATIS 是一个知名的数据集;它是意图分类的标准基准数据集之一。该数据集包括想要预订航班和/或获取航班信息(包括航班费用、目的地和时间表)的客户的话语。
无论 NLP 任务是什么,你都应该用肉眼仔细检查你的语料库。我们想要了解我们的语料库,以便将我们对语料库的观察整合到我们的代码中。在查看我们的文本数据时,我们通常会关注以下方面:
-
有哪些类型的语句?是短文本语料库,还是语料库由长文档或中等长度的段落组成?
-
语料库包括哪些类型的实体?例如,包括人名、城市名、国家名、组织名等。我们想要提取哪些?
-
标点符号是如何使用的?文本是否正确使用了标点,或者根本就没有使用标点?
-
用户是否遵循了语法规则?语法规则是如何遵循的?大写是否正确?是否有拼写错误?
在开始任何处理之前,我们将检查我们的语料库。以下是方法:
-
让我们继续下载数据集:
mkdir data wget -P data https://github.com/PacktPublishing/Mastering-spaCy-Second-Edition/blob/main/chapter_05/data/atis_intents.csv数据集是一个两列的 CSV 文件。
重要提示
如果你在一个 Jupyter 笔记本上运行代码,你可以在命令前添加一个 ! 来在那里运行它们。
-
接下来,我们将使用
pandas对数据集统计进行一些洞察。pandas是一个流行的数据处理库,常被数据科学家使用。你可以在pandas.pydata.org/docs/getting_started/intro_tutorials/上了解更多信息。import pandas as pd df = pd.read_csv("data/atis_intents.csv", header=None, names=["utterance", "text"]) df.shapeshape属性返回一个表示DataFrame维度的元组。我们可以看到数据集有两列和 4,978 行。 -
让我们创建一个条形图来查看数据集中的出口数量:
df["utterance"].value_counts().plot.barh()value_counts()方法返回一个包含唯一值计数的序列。pandas 库在底层使用 Matplotlib 来绘制条形图;这是结果:

图 5.1 – 出口频率条形图
大多数用户请求是关于航班的信息,其次是关于机票的请求。然而,在提取出口之前,我们将学习如何提取命名实体。让我们在下一节中这样做。
定义位置实体
在本节中,我们的目标是提取 位置 实体。en_core_web_sm 模型的管道已经有一个 NER 组件。让我们看看默认 NER 模型从 "i want to fly from boston at 838 am and arrive in denver at 1110 in the morning" 这句话中提取了哪些实体:
-
首先,我们导入库:
import spacy from spacy import displacy -
然后我们加载 spaCy 模型并处理一个句子:
nlp = spacy.load("en_core_web_sm") text = "i want to fly from boston at 838 am and arrive in denver at 1110 in the morning" doc = nlp(text) -
最后,我们使用
displacy显示实体:displacy.render(doc, style='ent')我们可以在 图 5.2 中看到结果:

图 5.2 – NER 组件提取的实体
NER 模型为 boston 和 denver 找到 全球政治实体 ( **GPE ),但仅知道这些城市是不够的。我们想知道他们想从哪里飞以及飞往何处。这意味着在这种情况下,介词**(一个包括介词和后置介词的通用术语)很重要。spaCy 使用通用的 **词性 ( **POS ) 标签,因此介词标签被命名为 "ADP"。你可以在词汇表中看到所有 POS 标签、依存标签或 spaCy 实体类型的描述(github.com/explosion/spaCy/blob/master/spacy/glossary.py)。
回到之前的句子示例,从波士顿和在丹佛是我们想要提取的实体。由于我们知道需要哪些 POS 标签和 GPE 实体来创建新的实体,因此实现这种提取的一个好方法就是依赖于 NLP 管道中的Tagger和EntityRecognizer组件。我们将通过创建基于标签的规则来提取标记。spaCy 使用SpanRuler组件使得这一过程变得简单易行。
将 SpanRuler 组件添加到我们的处理管道中
使用 spaCy 定制 NLP 管道非常简单。每个管道都是通过 spaCy 组件的组合创建的。一开始可能不太清楚,但当我们加载现成的 spaCy 模型时,它已经包含了几种不同的组件:
nlp.pipe_names
nlp.pipe_names属性按顺序返回组件名称。图 5.3显示了所有这些组件。

图 5.3 – en_core_web_sm 模型的默认组件
我们可以看到,en_core_web_sm模型默认包含['tok2vec', 'tagger', 'parser', 'attribute_ruler', 'lemmatizer', 'ner']组件。每个组件返回一个处理后的Doc对象,然后传递给下一个组件。
您可以使用Language.add_pipe()方法向处理管道添加组件(这里 nlp 是 Language 类的对象,我们将使用它来调用add_pipe())。该方法期望一个包含组件名称的字符串。在底层,此方法负责创建组件,将其添加到管道中,然后返回组件对象。
SpanRuler组件是一个现成的基于规则的跨度命名实体识别组件。该组件允许您将跨度添加到Doc.spans和/或Doc.ents。让我们第一次尝试使用它:
-
首先,我们调用
add_pipe()方法:spanruler_component = nlp.add_pipe("span_ruler") -
然后我们使用
add_patterns()方法添加模式。它们应该使用包含"label"和"pattern"键的字典列表来定义:patterns_location_spanruler = [ {"label": "LOCATION", "pattern": [{"POS": "ADP"}, {"ENT_TYPE": "GPE"}]}] spanruler_component.add_patterns(patterns_location_spanruler)spaCy 使用Thinc(
thinc.ai/docs/api-config#registry)注册表,这是一个将字符串键映射到函数的系统。"span_ruler"字符串名称是引用SpanRuler组件的字符串。然后我们定义一个名为LOCATION的模式,并使用add_patterns()方法将其添加到组件中。 -
与
doc.ents不同,doc.spans允许重叠匹配。默认情况下,SpanRuler将匹配项作为spans添加到doc.spans["ruler"]跨度组中。让我们再次处理文本并检查SpanRuler是否完成了其工作。由于组件将 Span 添加到"ruler"键,我们需要指定这一点以使用displacy渲染跨度:doc = nlp(text) options = {"spans_key": "ruler"} displacy.render(doc, style='span', options=options)让我们看看图 5.4的结果。

图 5.4 – 使用 SpanRuler 提取的跨度
我们可以看到,组件识别了"from boston"和"in denver"跨度。SpanRuler有一些您可以更改的设置。这可以通过nlp.pipe()方法上的 config 参数或使用config.cfg文件来完成。让我们将跨度添加到Doc.ents而不是doc.spans["ruler"]:
-
首先,我们移除了管道中的组件,因为我们只有一个具有相同名称的组件:
nlp.remove_pipe("span_ruler") -
然后我们将组件的
"annotate_ents"参数设置为True。由于我们的模式需要EntityRecognizer添加的实体,因此我们还需要将覆盖参数设置为False,这样我们就不覆盖它们:config = {"annotate_ents": True, "overwrite": False} -
现在我们使用此配置再次创建组件,添加之前创建的模式,并再次处理文本。
spanruler_component_v2 = nlp.add_pipe( "span_ruler", config=config) spanruler_component_v2.add_patterns(patterns_location_spanruler) doc = nlp(text) displacy.render(doc, style='ent')通过做所有这些,匹配项变成了实体,而不是跨度。
让我们看看图 5.5 中的新实体:

图 5.5 – 使用 SpanRuler 提取的实体
您可以看到,{'GPE', 'boston'}和{'GPE', 'denver'}实体不再存在;现在分别是{'from boston', 'LOCATION'}和{'in denver', 'LOCATION'}。Doc.ents中不允许重叠实体,因此默认使用util.filter_spans函数进行过滤。此函数保留较短的跨度中第一个最长的跨度。
您可以覆盖大多数SpanRuler设置。一些可用的设置如下:
-
spans_filter:一个在将跨度分配给doc.spans之前过滤跨度的方法 -
ents_filter:一个在将跨度分配给doc.ents之前过滤跨度的方法 -
validate:一个设置是否应该验证模式或将其作为验证传递给Matcher和PhraseMatcher的方法
在本节中,我们学习了如何使用SpanRuler创建和提取实体。有了提取位置实体的模式,我们现在可以继续提取话语的意图。让我们在下一节中使用DependencyMatcher来完成这项工作。
使用 DependencyMatcher 提取依赖关系
为了提取话语的意图,我们需要根据它们之间的语法关系匹配标记。目标是找出用户携带的意图类型——预订航班、在他们已预订的航班上购买餐点、取消航班等。每个意图都包括一个动词(预订)和网页所作用的对象(航班、酒店、餐点等)。
在本节中,我们将从话语中提取及物动词及其直接宾语。我们将通过提取及物动词及其直接宾语来开始我们的意图识别部分。在我们继续提取及物动词及其直接宾语之前,让我们首先快速回顾一下及物动词和直接/间接宾语的概念。
语言学入门
让我们探索一些与句子结构相关的语言概念,包括动词和动词宾语关系。动词是句子中非常重要的组成部分,因为它表示句子中的动作。句子的宾语是受到动词动作影响的事物或人。因此,句子动词和宾语之间存在自然联系。及物性的概念捕捉了动词宾语关系。及物动词是需要作用对象的动词。让我们看看一些例子:
I bought flowers.
He loved his cat.
He borrowed my book.
在这些例子句子中,bought、loved和borrowed是及物动词。在第一个句子中,bought是及物动词,flowers是其宾语,即句子主语所购买的事物。I Loved – his cat和borrowed – my book是及物动词宾语例子。我们再次关注第一个句子——如果我们删除flowers宾语会发生什么?让我们看看这里的情况:
I bought
你买了什么?如果没有宾语,这个句子就完全没有意义了。在前面的句子中,每个宾语都完成了动词的意义。这是理解一个动词是否及物的一种方法——删除宾语并检查句子是否在语义上仍然完整。
有些动词是及物的,有些动词是不及物的。不及物动词是及物动词的相反,它不需要作用对象。让我们看看一些例子:
Yesterday I slept for 8 hours.
The cat ran towards me.
When I went out, the sun was shining.
Her cat died 3 days ago.
在所有前面的句子中,即使没有宾语,动词也有意义。如果我们删除除了主语和宾语之外的所有单词,这些句子仍然是有意义的:
I slept.
The cat ran.
The sun was shining.
Her cat died.
将不及物动词与宾语搭配是没有意义的。你不能跑某人或某物,你不能使某人或某物发光,你当然也不能使某人或某物死亡。
句子宾语
正如我们之前提到的,宾语是受到动词动作影响的物体或人。动词所陈述的动作是由句子主语执行的,而句子宾语受到动作的影响。一个句子可以是直接的或间接的。直接宾语回答了谁和什么的问题。你可以通过问主语{动词}什么/谁?来找到直接宾语。以下是一些例子:
I bought flowers. I bought what? - flowers
He loved his cat. He loved who? - his cat
He borrowed my book. He borrowed what? - my book
一个间接宾语回答了为了什么、为了谁和/或给谁的问题。让我们看看一些例子:
He gave me his book. He gave his book to whom? - me
He gave his book to me. He gave his book to whom? - me
间接宾语通常由介词to、for、from等引导。正如你从这些例子中看到的,间接宾语也是一个宾语,并且受到动词动作的影响,但它在句子中的角色略有不同。间接宾语有时被视为直接宾语的接受者。
这就是您需要了解的关于及物/不及物动词和直接/间接宾语的知识,以便消化本章的内容。如果您想了解更多关于句子语法的知识,可以阅读 Emily Bender 的优秀书籍 自然语言处理的语言学基础 (dl.acm.org/doi/book/10.5555/2534456)。我们已经涵盖了句子语法的基础知识,但这仍然是一个深入了解语法的极好资源。
使用 DependencyMatcher 组件匹配模式
DependencyMatcher 组件使我们能够将模式与提取信息相匹配,但与 SpanRuler 模式定义的相邻标记列表不同,DependencyMatcher 模式匹配指定它们之间关系的标记。该组件与 DependencyParser 组件提取的依存关系一起工作。让我们通过一个示例看看这个组件提取的信息类型:
text = "show me flights from denver to philadelphia on tuesday"
doc = nlp(text)
displacy.render(doc, style='dep')
让我们看看 图 5.6 的结果:

图 5.6 – 句子的依存弧(句子其余部分省略)
提取的依存标签是弧线下方的标签。Show 是一个及物动词,在这个句子中,它的直接宾语是 flight。这个依存关系由 DependencyParser 组件提取,并标记为 dobj(直接宾语)。
我们的目标是提取意图,因此我们将定义始终寻找 动词 和其 dobj 依存关系的模式。DependencyMatcher 使用 Semgrex 操作符来定义模式。Semgrex 语法 可能一开始会让人困惑,所以让我们一步一步来。
DependencyMatcher 模式由一系列字典组成。第一个字典使用 RIGHT_ID 和 RIGHT_ATTRS 定义一个锚点标记。RIGHT_ID 是关系右侧节点的唯一名称,RIGHT_ATTRS 是要匹配的标记属性。模式格式与 SpanRuler 中使用的相同模式。在我们的模式中,锚点标记将是 dobj 标记,因此第一个字典定义如下:
pattern = [
{
"RIGHT_ID": "direct_object_token",
"RIGHT_ATTRS": {"DEP": "dobj"}
}
]
如 spaCy 的文档所述 (spacy.io/usage/rule-based-matching/#dependencymatcher),在第一个字典之后,模式字典应包含以下键:
-
LEFT_ID:关系左侧节点的名称,该名称已在早期节点中定义 -
REL_OP:描述两个节点之间关系的操作符 -
RIGHT_ID:关系右侧节点的唯一名称 -
RIGHT_ATTRS:与SpanRuler中提供的正则标记模式相同的格式,用于匹配关系右侧节点的标记属性
给定这些键,我们通过指示关系的左侧节点、为新右侧节点定义一个名称以及指示描述两个节点之间关系的运算符来构建模式。回到我们的例子,在将 direct_object_token 定义为锚点后,我们将下一个字典的 RIGHT_ID 设置为 VERB 标记,并将运算符定义为 direct_object_token < verb_token,因为直接宾语是动词的 直接依赖项。以下是 DependencyMatcher 支持的一些其他运算符(您可以在这里查看完整的运算符列表):
-
A < B: A 是 B 的直接依赖项 -
A > B: A 是 B 的直接头 -
A << B: A 是在 dep → head 路径上跟随 B 的链中的依赖项 -
A >> B: A 是在 head → dep 路径上跟随 B 的链中的头
如果这些操作让您有点头疼,那也发生在我身上。这只是其中的一小部分,您可以在这里查看完整的运算符列表。好吧,让我们回到我们的例子并定义完整的模式:
pattern = [
{
"RIGHT_ID": "direct_object_token",
"RIGHT_ATTRS": {"DEP": "dobj"}
},
{
"LEFT_ID": "direct_object_token",
"REL_OP": "<",
"RIGHT_ID": "verb_token",
"RIGHT_ATTRS": {"POS": "VERB"}
}
]
现在,我们可以创建 DependencyMatcher:
-
首先,我们需要传递
vocabulary对象(词汇与匹配器操作的文档共享):from spacy.matcher import DependencyMatcher matcher = DependencyMatcher(nlp.vocab)接下来,我们需要定义一个回调函数,该函数将接受以下参数:
matcher、doc、i和matches。matcher参数指的是匹配器实例,doc是正在分析的文档,i是当前匹配的索引,matches是一个详细说明找到的匹配项的列表。我们将创建一个callback函数来显示一个单词的意图,例如bookFlight、cancelFlight、bookMeal等。该函数将接受匹配项的标记并打印它们的词元:def show_intent(matcher, doc, i, matches): match_id, token_ids = matches[i] verb_token = doc[token_ids[1]] dobj_token = doc[token_ids[0]] intent = verb_token.lemma_ + dobj_token.lemma_.capitalize() print("Intent:", intent) -
要向
matcher添加规则,我们指定一个 ID 键、一个或多个模式以及可选的回调函数来处理匹配项。最后,我们再次处理文本并调用matcher对象,将此doc作为参数传递:matcher.add("INTENT", [pattern], on_match=show_intent) doc = nlp("show me flights from denver to philadelphia on tuesday") matches = matcher(doc)太棒了!代码打印出
Intent: showFlightIntent,所以识别是成功的。在这里,我们识别了一个单一意图,但某些话语可能携带多个意图。例如,考虑以下来自语料库的话语:show all flights and fares from denver to san francisco在这里,用户想要列出所有航班,同时查看票价信息。一种处理方式是将这些意图视为单一且复杂的意图。处理此类话语的常见方式是用多个意图标记话语。
让我们看看 DEP 依赖关系由 DependencyParser 提取的:

图 5.7 – 新句子的依存弧(句子其余部分省略)
在 图 5.7 中,我们看到 dobj 弧连接了 show 和 flights。conj(连词)弧将 flights 和 fares 连接起来,表示连词关系。这种关系是通过连词如 and 或 or 构建的,表示一个名词通过这个连词与另一个名词相连。现在让我们编写代码来识别这两个意图:
-
将弧关系转换为
REL_OP操作符,direct_object_token将成为这次关系的头,因此我们将使用>操作符,因为direct_object_token是新的conjunction_token的 直接头。这是匹配两个意图的新模式:pattern_two = [ { "RIGHT_ID": "direct_object_token", "RIGHT_ATTRS": {"DEP": "dobj"} }, { "LEFT_ID": "direct_object_token", "REL_OP": "<", "RIGHT_ID": "verb_token", "RIGHT_ATTRS": {"POS": "VERB"} }, { "LEFT_ID": "direct_object_token", "REL_OP": ">", "RIGHT_ID": "conjunction_token", "RIGHT_ATTRS": {"DEP": "conj"} } ] -
我们还需要更新回调函数,使其能够打印出两个意图:
def show_two_intents(matcher, doc, i, matches): match_id, token_ids = matches[i] verb_token = doc[token_ids[1]] dobj_token = doc[token_ids[0]] conj_token = doc[token_ids[2]] intent = verb_token.lemma_ + \ dobj_token.lemma_.capitalize() + ";" + \ verb_token.lemma_ + conj_token.lemma_.capitalize() print("Two intents:", intent) -
现在我们只需要将这个新规则添加到匹配器中。由于模式 ID 已经存在,模式将被扩展:
matcher.add("TWO_INTENTS", [pattern_two], on_match=show_two_intents) -
在设置好所有这些之后,我们现在可以再次找到匹配项:
doc = nlp("show all flights and fares from denver to san francisco") matches = matcher(doc)
现在匹配器找到了两个模式的标记,第一个模式和这个新的模式,它匹配两个意图。到目前为止,我们只是 打印意图,但在实际设置中,将此信息存储在 Doc 对象上是一个好主意。为此,我们将创建自己的 spaCy 组件。让我们在下一节学习如何做到这一点。
使用扩展属性创建管道组件
要创建我们的组件,我们将使用 @Language.factory 装饰器。组件工厂是一个可调用对象,它接受设置并返回一个 pipeline component function。@Language.factory 装饰器还将自定义组件的名称添加到注册表中,使得可以使用 .add_pipe() 方法将组件添加到管道中。
spaCy 允许你在 Doc、Span 和 Token 对象上设置任何自定义属性和方法,这些属性和方法将作为 Doc._.、Span._. 和 Token._. 可用。在我们的案例中,我们将向 Doc 添加 Doc._.intent 属性,利用 spaCy 的数据结构来存储我们的数据。
我们将在一个 Python 类内部实现组件逻辑。spaCy 期望 __init__() 方法接受 nlp 和 name 参数(spaCy 会自动填充它们),而 __call__() 方法应该接收并返回 Doc。
让我们创建 IntentComponent 类:
-
首先,我们创建类。在
__init__()方法中,我们创建DependencyMatcher实例,将模式添加到匹配器中,并设置intent扩展属性:class IntentComponent: def __init__(self, nlp: Language): self.matcher = DependencyMatcher(nlp.vocab) pattern = [ { "RIGHT_ID": "direct_object_token", "RIGHT_ATTRS": {"DEP": "dobj"} }, { "LEFT_ID": "direct_object_token", "REL_OP": "<", "RIGHT_ID": "verb_token", "RIGHT_ATTRS": {"POS": "VERB"} } ] pattern_two = [ { "RIGHT_ID": "direct_object_token", "RIGHT_ATTRS": {"DEP": "dobj"} }, { "LEFT_ID": "direct_object_token", "REL_OP": "<", "RIGHT_ID": "verb_token", "RIGHT_ATTRS": {"POS": "VERB"} }, { "LEFT_ID": "direct_object_token", "REL_OP": ">", "RIGHT_ID": "conjunction_token", "RIGHT_ATTRS": {"DEP": "conj"} } ] self.matcher.add("INTENT", [pattern]) self.matcher.add("TWO_INTENTS", [pattern_two]) if not Doc.has_extension("intent"): Doc.set_extension("intent", default=None)现在,在
__call__()方法内部,我们找到匹配项并检查是否是"TWO_INTENTS"匹配。如果是,我们提取该模式的标记并设置doc._.intent属性;如果不是,则在else块中,我们提取"INTENT"匹配的标记:def __call__(self, doc: Doc) -> Doc: matches = self.matcher(doc) for match_id, token_ids in matches: string_id = nlp.vocab.strings[match_id] if string_id == "TWO_INTENTS": verb_token = doc[token_ids[1]] dobj_token = doc[token_ids[0]] conj_token = doc[token_ids[2]] intent = verb_token.lemma_ + \ dobj_token.lemma_.capitalize() + \ ";" + verb_token.lemma_ + \ conj_token.lemma_.capitalize() doc._.intent = intent break else: for match_id, token_ids in matches: string_id = nlp.vocab.strings[match_id] if string_id == "INTENT": verb_token = doc[token_ids[1]] dobj_token = doc[token_ids[0]] intent = verb_token.lemma_ + \ dobj_token.lemma_.capitalize() doc._.intent = intent return doc使用这段代码,我们在
Doc中注册自定义扩展,通过在__call__()方法上设置doc._.intent = intent来找到匹配项并保存意图。 -
现在我们有了自定义组件的类,下一步是使用装饰器来注册它:
@Language.factory("intent_component") def create_intent_component(nlp: Language, name: str): return IntentComponent(nlp)
重要提示
如果你正在使用 Jupyter Notebook 并且需要重新创建组件,你需要重新启动内核。如果不这样做,spaCy 会给我们一个错误,因为组件名称已经被注册。
就这样,这就是你的第一个自定义组件!恭喜!现在,为了提取意图,我们只需要将组件添加到管道中。如果我们想查看意图,我们可以通过doc._.intent来访问它。这是你可以这样做的方式:
nlp.add_pipe("intent_component")
text = "show all flights and fares from denver to san francisco"
doc = nlp(text)
doc._.intent
太酷了,对吧?如果你不记得,数据集有 4,978 个语音。这不是一个非常大的数字,但如果它更大呢?spaCy 能帮助我们让它更快吗?是的!在下一节中,我们将学习如何使用Language.pipe()方法运行我们的管道。
使用大型数据集运行管道
Language.pipe()方法将文本作为流处理,并按顺序产生Doc对象。它以批量而不是逐个缓冲文本,因为这通常更有效率。如果我们想获取特定的文档,我们需要先调用list(),因为该方法返回一个 Python 生成器,它产生Doc对象。这是你可以这样做的方式:
utterance_texts = df.text.to_list()
processed_docs = list(nlp.pipe(utterance_texts))
print(processed_docs[0], processed_docs[0]._.intent)
在前面的代码中,我们正在从本章开头加载的 DataFrame 中获取文本语音列表,并使用.pipe()进行批量处理。让我们通过使用和不使用.pipe()方法来比较时间差异:
import timestart_time = time.time()
utterance_texts = df.text.to_list()
processed_docs_vanilla = [nlp(text) for text in utterance_texts]
end_time = time.time()
execution_time = end_time - start_time
print("Execution time:", execution_time, "seconds")
>>> Execution time: 27.12 seconds
这给了我们 27.12 秒的时间。现在,让我们使用以下方法:
import timestart_time = time.time()
utterance_texts = df.text.to_list()
processed_docs_pipe = list(nlp.pipe(utterance_texts))
end_time = time.time()
execution_time = end_time - start_time
print("Execution time:", execution_time, "seconds")
>>> Execution time: 5.90 seconds
使用nlp.pipe(),我们在 5.90 秒内得到了相同的结果。这是一个巨大的差异。我们还可以指定batch_size和n_process来设置要使用的处理器数量。还有一个选项可以禁用组件,如果你只需要运行.pipe()来获取特定组件处理过的文本结果。
太棒了,我们使用自己的自定义组件完成了我们的第一个管道!恭喜!以下是管道的完整代码:
import spacy
from spacy.language import Language
from spacy.tokens import Doc
from spacy.matcher import DependencyMatcher
@Language.factory("intent_component")
def create_intent_component(nlp: Language, name: str):
@Language.factory("intent_component")
def create_intent_component(nlp: Language, name: str):
return IntentComponent(nlp)
class IntentComponent:
def __init__(self, nlp: Language):
self.matcher = DependencyMatcher(nlp.vocab)
pattern = [
{
"RIGHT_ID": "direct_object_token",
"RIGHT_ATTRS": {"DEP": "dobj"}
},
{
"LEFT_ID": "direct_object_token",
"REL_OP": "<",
"RIGHT_ID": "verb_token",
"RIGHT_ATTRS": {"POS": "VERB"}
}
]
pattern_two = [
{
"RIGHT_ID": "direct_object_token",
"RIGHT_ATTRS": {"DEP": "dobj"}
},
{
"LEFT_ID": "direct_object_token",
"REL_OP": "<",
"RIGHT_ID": "verb_token",
"RIGHT_ATTRS": {"POS": "VERB"}
},
{
"LEFT_ID": "direct_object_token",
"REL_OP": ">",
"RIGHT_ID": "conjunction_token",
"RIGHT_ATTRS": {"DEP": "conj"}
}
]
self.matcher.add("INTENT", [pattern])
self.matcher.add("TWO_INTENTS", [pattern_two])
if not Doc.has_extension("intent"):
Doc.set_extension("intent", default=None)
def __call__(self, doc: Doc) -> Doc:
matches = self.matcher(doc)
for match_id, token_ids in matches:
string_id = nlp.vocab.strings[match_id]
if string_id == "TWO_INTENTS":
verb_token = doc[token_ids[1]]
dobj_token = doc[token_ids[0]]
conj_token = doc[token_ids[2]]
intent = verb_token.lemma_ + \
dobj_token.lemma_. capitalize() + ";" + \
verb_token.lemma_ + \
conj_token.lemma_. capitalize()
doc._.intent = intent
break
else:
for match_id, token_ids in matches:
string_id = nlp.vocab.strings[match_id]
if string_id == "INTENT":
verb_token = doc[token_ids[1]]
dobj_token = doc[token_ids[0]]
intent = verb_token.lemma_ + \
dobj_token.lemma_. capitalize()
doc._.intent = intent
return doc
nlp = spacy.load("en_core_web_sm")
nlp.add_pipe("intent_component")
text = "show all flights and fares from denver to san francisco"
doc = nlp(text)
doc._.intent
spaCy 使管道代码整洁有序,这是我们想要维护代码库时两个至关重要的品质。
摘要
在本章中,你学习了如何生成语音的完整语义解析。首先,你添加了一个SpanRuler组件来提取与用例上下文相关的 NER 实体。然后,你学习了如何使用DependencyMatcher通过分析句子结构来进行意图识别。接下来,你还学习了如何创建自己的自定义 spaCy 组件来提取语音的意图。最后,你看到了如何使用Language.pipe()方法更快地处理大型数据集。
SpanRuler 和 DependencyMatcher 都依赖于我们创建的模式。创建这些模式的过程是一个反复迭代的过程。我们分析结果,然后测试新的模式,然后再分析结果,如此循环。本章的目标是教会你如何使用这些工具,以便你可以在自己的项目中执行这个过程。
在接下来的章节中,我们将更多地转向机器学习方法。第六章 将介绍如何使用 spaCy 与 Transformers 结合使用。
第六章:利用 spaCy 与转换器一起工作
转换器是 NLP 中的最新热门话题。本章的目标是学习如何使用转换器来提高 spaCy 中可训练组件的性能。
首先,你将了解转换器和迁移学习。接下来,你将更深入地了解 spaCy 可训练组件以及如何训练一个组件,介绍 spaCy 的 config.cfg 文件和 spaCy 的 CLI。然后,你将了解常用 Transformer 架构的架构细节——双向编码器 Transformer 表示(BERT)及其继任者 RoBERTa。最后,你将训练 TextCategorizer 组件,使用转换器层来提高准确率对文本进行分类。
到本章结束时,你将能够准备训练数据并微调你自己的 spaCy 组件。由于 spaCy 的设计方式;在这样做的时候,你将遵循软件工程的最佳实践。你还将对转换器的工作原理有一个坚实的基础,这在我们与 大型 语言模型(LLMs)在 第七章 一起工作时将非常有用。你将能够仅用几行代码就利用 Transformer 模型和迁移学习构建最先进的 NLP 管道。
在本章中,我们将涵盖以下主要主题:
-
使用 spaCy 进行模型训练和迁移学习
-
使用 spaCy 管道对文本进行分类
-
与 spaCy
config.cfg文件一起工作 -
准备训练数据以使用 spaCy 微调模型
-
使用 Hugging Face 的 Transformer 进行 spaCy 的下游任务
技术要求
数据集和章节代码可以在 github.com/PacktPublishing/Mastering-spaCy-Second-Edition 找到。
我们将使用 pandas 库来操作数据集,并安装 spacy-transformers 库以与 transformer spaCy 组件一起工作。
转换器和迁移学习
2017 年,随着 Vaswani 等人发表的研究论文 Attention Is All You Need 的发布,自然语言处理领域发生了一个里程碑事件(arxiv.org/abs/1706.03762),该论文介绍了一种全新的机器学习思想和架构——转换器。NLP 中的转换器是一个新颖的想法,旨在解决序列建模任务,并针对 长短期记忆(LSTM)架构引入的一些问题。以下是论文如何解释转换器的工作原理:
“Transformer 是第一个完全依赖自注意力来计算其输入和输出表示的转换模型,不使用序列对齐 RNN 或卷积”
在这个上下文中,转换意味着通过将输入单词和句子转换为向量来转换输入到输出。通常,一个变压器在一个巨大的语料库上训练。然后,在我们的下游任务中,我们使用这些向量,因为它们携带有关词语义、句子结构和句子语义的信息。
在变压器之前,NLP 世界中的热门技术是词向量技术。词向量基本上是一个词的密集数字表示。这些向量令人惊讶的地方在于,语义相似的词具有相似的词向量。例如,GloVe和FastText向量已经在维基百科语料库上进行了训练,可以用于语义相似度计算。Token.similarity()、Span.similarity()和Doc.similarity()方法都使用词向量来预测这些容器之间的相似度。这是一个简单的迁移学习示例用法,其中我们使用文本中的知识(从词向量训练中提取的词的知识)来解决新问题(相似度问题)。变压器更强大,因为它们被设计成能够理解上下文中的语言,这是词向量无法做到的。我们将在BERT部分了解更多关于这一点。
Transformer是模型架构的名称,但 Hugging Face Transformers 也是 Hugging Face 提供的一套 API 和工具,用于轻松下载和训练最先进的预训练模型。Hugging Face Transformers 提供了数千个预训练模型,用于执行 NLP 任务,如文本分类、文本摘要、问答、机器翻译以及超过 100 种语言的自然语言生成。目标是让最先进的 NLP 技术对每个人可访问。
在本章中,我们将使用变压器模型来应用一种迁移学习形式,以提高下游任务的准确性——在我们的案例中,是文本分类任务。我们将通过结合使用 spaCy 的transformer组件(来自spacy-transformers包)和textcat组件来实现这一点,以提高管道的准确性。使用 spaCy,还有直接使用现有 Hugging Face 模型的预测选项。为此,你可以使用spacy-huggingface-pipelines包中的封装器。我们将在第十一章中看到如何做到这一点。
好的,现在你已经知道了什么是变压器,让我们继续学习更多关于该技术背后的机器学习概念。
从 LSTMs 到 Transformers
在 Transformer 出现之前,LSTM 神经网络单元是用于建模文本的常用解决方案。LSTM 是循环神经网络(RNN)单元的一种变体。RNN 是一种特殊的神经网络架构,可以分步骤处理序列数据。在通常的神经网络中,我们假设所有输入和输出都是相互独立的。问题是这种建模方式并不适用于文本数据。每个单词的存在都依赖于其相邻的单词。例如,在机器翻译任务中,我们通过考虑之前预测的所有单词来预测一个单词。RNN 通过捕获关于过去序列元素的信息并将它们保持在内存中(称为隐藏状态)来解决这种情况。
LSTM 是为了解决 RNN 的一些计算问题而创建的。RNN 有一个问题,就是会忘记序列中的一些数据,以及由于链式乘法导致的梯度消失和爆炸等数值稳定性问题。LSTM 单元比 RNN 单元稍微复杂一些,但计算逻辑是相同的:我们每个时间步输入一个单词,LSTM 在每个时间步输出一个值。
LSTM 比传统的 RNN 更好,但它们也有一些缺点。LSTM 架构有时在学习长文本时会有困难。长文本中的统计依赖关系可能很难用 LSTM 表示,因为随着时间步的推移,LSTM 可能会忘记之前处理的一些单词。此外,LSTM 的本质是顺序的。我们每个时间步处理一个单词。这意味着学习过程的并行化是不可能的;我们必须顺序处理。不允许并行化造成了一个性能瓶颈。
Transformer 通过完全不使用循环层来解决这些问题。Transformer 架构由两部分组成——左侧的输入编码器块(称为编码器)和右侧的输出解码器块(称为解码器)。以下图表来自原始论文《Attention Is All You Need》(arxiv.org/abs/1706.03762),展示了 Transformer 架构:

图 6.1 – 来自论文“Attention is All You Need”的 Transformer 架构
上述架构用于机器翻译任务;因此,输入是源语言的单词序列,输出是目标语言的单词序列。编码器生成输入单词的向量表示,并将它们传递给解码器(编码器块指向解码器块的箭头表示词向量转移)。解码器接收这些输入单词向量,将输出单词转换为单词向量,并最终生成每个输出单词的概率(在图 6.1中标记为输出概率)。
变压器带来的创新在于多头注意力块。该块通过使用自注意力机制为每个单词创建一个密集表示。自注意力机制将输入句子中的每个单词与句子中的其他单词相关联。每个单词的词嵌入是通过取其他单词嵌入的加权平均来计算的。这样,就可以计算出输入句子中每个单词的重要性,因此架构依次关注每个输入单词。
下面的图示说明了 Transformer 模型中自注意力的机制。它展示了左侧的输入单词如何关注右侧的输入单词“它”。图中的颜色渐变表示每个单词与“它”的相关程度。颜色较深、较鲜艳的单词,如“动物”,相关性较高,而颜色较浅的单词,如“没”或“太累了”,相关性较低。
这个可视化演示了 Transformer 可以精确地确定这个句子中的代词“它”指的是“动物”。这种能力使得 Transformer 能够解决句子中的复杂语义依赖和关系,展示了它们理解上下文和意义的能力。

图 6.2 – 自注意力机制的说明
在本章的后面部分,我们将学习一个名为BERT的著名 Transformer 模型,所以如果现在所有这些内容看起来太抽象,请不要担心。我们将通过文本分类用例学习如何使用 Transformer,但在使用 Transformer 之前,我们需要了解如何使用 spaCy 解决文本分类问题。让我们在下一节中这样做。
使用 spaCy 进行文本分类
spaCy 模型在通用 NLP 目的上非常成功,例如理解句子的句法,将段落分割成句子,以及提取实体。然而,有时我们处理的是非常具体的领域,而 spaCy 预训练模型并没有学会如何处理这些领域。
例如,X(以前是 Twitter)文本包含许多非正规词,如标签、表情符号和提及。此外,X 句子通常只是短语,而不是完整的句子。在这里,spaCy 的 POS 标记器以不标准的方式表现是完全可以理解的,因为 POS 标记器是在完整的、语法正确的英语句子上训练的。
另一个例子是医疗领域。它包含许多实体,如药物、疾病和化学化合物名称。这些实体不被期望被 spaCy 的 NER 模型识别,因为它没有疾病或药物实体标签。NER 完全不知道医疗领域。
在本章中,我们将使用 Amazon Fine Food Reviews 数据集(www.kaggle.com/snap/amazon-fine-food-reviews)。这个数据集包含了关于在亚马逊上销售的精致食品的客户评论(J. McAuley 和 J. Leskovec. 隐藏因素和隐藏主题:通过评论文本理解评分维度。RecSys,2013,dl.acm.org/doi/abs/10.1145/2507157.2507163)。评论包括用户和产品信息、用户评分和文本。我们希望将这些评论分类为正面或负面。由于这是一个特定领域的问题,spaCy(目前)不知道如何进行分类。为了教会管道如何做到这一点,我们将使用 TextCategorizer,这是一个可训练的文本分类组件。我们将在下一节中这样做。
训练 TextCategorizer 组件
TextCategorizer 是一个可选的可训练管道组件,用于预测整个文档的类别。要训练它,我们需要提供示例及其类别标签。图 6 .3 显示了 TextCategorizer 组件在 NLP 管道中的确切位置;该组件位于基本组件之后。

图 6.3 – NLP 管道中的 TextCategorizer
spaCy 的 TextCategorizer 组件背后是一个神经网络架构,它为我们提供了用户友好且端到端的训练分类器的途径。这意味着我们不必直接处理神经网络架构。TextCategorizer 有两种形式:单标签分类器(textcat)和多标签分类器(textcat_multilabel)。正如其名所示,多标签分类器可以预测多个类别。单标签分类器对每个示例只预测一个类别,且类别互斥。组件的预测结果以字典形式保存在 doc.cats 中,其中键是类别的名称,值是介于 0 和 1(包含)之间的分数。
要了解如何使用 TextCategorizer 组件,学习如何一般地训练深度模型是有帮助的。让我们在下一节中这样做。
训练深度学习模型
要训练一个神经网络,我们需要配置模型参数并提供训练示例。神经网络的每个预测都是其权重值的总和;因此,训练过程通过我们的示例调整神经网络的权重。如果你想了解更多关于神经网络如何工作的信息,你可以阅读优秀的指南neuralnetworksanddeeplearning.com/。
在训练过程中,我们将多次遍历训练集,并多次展示每个示例。每次迭代被称为epoch。在每次迭代中,我们还会洗牌训练数据,以防止模型学习到与示例顺序相关的特定模式。这种训练数据的洗牌有助于确保模型能够很好地泛化到未见过的数据。
在每个 epoch 中,训练代码通过增量更新来更新神经网络的权重。这些增量更新通常通过将每个 epoch 的数据分成小批量来应用。通过比较实际标签与神经网络当前输出,计算出一个损失。优化器是更新神经网络权重以适应该损失的函数。梯度下降是用于找到更新网络参数的方向和速率的算法。优化器通过迭代更新模型参数,使其朝着减少损失的方向移动。这就是简而言之的训练过程。
如果你曾经使用 PyTorch 或 TensorFlow 训练过深度学习模型,你可能会熟悉这个过程经常具有挑战性的性质。spaCy 使用 Thinc,这是一个轻量级的深度学习库,具有功能编程 API,用于组合模型。使用 Thinc,我们可以在不更改代码的情况下(并且无需直接使用这些库进行编码)在 PyTorch、TensorFlow 和 MXNet 模型之间切换。
Thinc 概念模型与其他神经网络库略有不同。为了训练 spaCy 模型,我们需要了解 Thinc 的配置系统。我们将在本章的下一节中介绍这一点。
总结训练过程,我们需要收集和准备数据,定义优化器以更新每个小批量的权重,将数据分成小批量,并对每个小批量进行洗牌以进行训练。
我们还没有涉及到收集和准备数据的阶段。spaCy 的示例容器包含一个训练实例的信息。它存储了两个Doc对象:一个用于存储参考标签,另一个用于存储管道的预测。让我们在下一节学习如何从我们的训练数据中构建示例对象。
为 spaCy 可训练组件准备数据
要创建用于训练的数据集,我们需要构建Example对象。可以使用带有 Doc 引用和金标准注释字典的Example.from_dict()方法来创建Example对象。对于TextCategorizer组件,Example的注释名称应该是表示文本类别相关性的cat标签/值对字典。
我们将要处理的数据集中的每个评论可以是正面或负面的。以下是一个评论示例:
review_text = 'This Hot chocolate is very good. It has just the right amount of milk chocolate flavor. The price is a very good deal and more than worth it!'
category = 'positive'
Example.from_dict()方法将Doc作为第一个参数,将Dict[str, Any]作为第二个参数。对于我们的分类用例,Doc将是评论文本,Dict[str, Any]将是带有标签和正确分类的cat字典。让我们为之前的评论构建Example:
-
首先,让我们加载一个空的英文管道:
import spacy from spacy.training import Example nlp = spacy.blank("en") -
现在,让我们创建一个
Doc来封装评论文本,并创建带有正确标签的cats字典:review_text = 'This Hot chocolate is very good. It has just the right amount of milk chocolate flavor. The price is a very good deal and more than worth it!' doc = nlp(review_text) annotation = {"cats": {"positive": 1, "negative": 0}} -
最后,让我们创建一个
Example对象:example = Example.from_dict(doc, annotation)
在本章中,我们仅微调TextCategorizer组件,但使用 spaCy,你也可以训练其他可训练组件,如Tagger或DependencyParser。创建Example对象的过程是相同的;唯一不同的是每个对象的注释类型。以下是一些不同注释的示例(完整的列表可以在spacy.io/api/data-formats#dict-input找到):
-
text:原始文本 -
cats:表示特定文本类别对文本相关性的label** / **value对字典 -
tags:细粒度 POS 标签列表 -
deps:表示标记与其头标记之间的依赖关系的字符串值列表
amazon_food_reviews.csv文件是原始Amazon Fine Food Reviews数据集的 4,000 行样本。我们将从中取 80%用于训练,其余 20%用于测试。让我们创建包含所有训练示例的数组:
-
首先,让我们下载数据集:
mkdir data wget -P data https://github.com/PacktPublishing/Mastering-spaCy-Second-Edition/blob/main/chapter_06/data/amazon_food_reviews.csv -
现在,让我们加载并分割 80%的数据集用于训练:
import pandas as pd import spacy from spacy.training import Example df = pd.read_csv("data/amazon_food_reviews.csv") df_train = df.sample(frac=0.8,random_state=200) df_test = df.drop(df_train.index) df_test.to_json("data/df_dev.json") -
最后,让我们创建训练示例并将它们存储在一个列表中:
nlp = spacy.blank("en") TRAIN_EXAMPLES = [] for _,row in df_train.iterrows(): if row["positive_review"] == 1: annotation = {"cats": {"positive": 1, "negative": 0}} else: annotation = {"cats": {"negative": 1, "positive": 0}} example = Example.from_dict(nlp(row["text"]), annotation) TRAIN_EXAMPLES.append(example)
现在你已经知道了如何创建示例来提供训练数据,我们可以继续编写训练脚本。
创建训练脚本
训练模型的推荐方法是使用 spaCy 的spacy train命令和 spaCy 的 CLI;我们不应该编写自己的训练脚本。在本节中,我们将为了学习目的编写自己的训练脚本。我们将在本章的下一节学习如何使用 CLI 正确训练模型。
让我们回顾一下训练深度学习模型的步骤。在每个 epoch 中,我们通过使用optimizer functions进行incremental updates来随机打乱训练数据并更新神经网络的权重。spaCy 提供了创建训练循环中所有这些步骤的方法。
我们的目标是训练TextCategorizer组件,因此第一步是创建它并将其添加到管道中。由于这是一个可训练的组件,我们需要提供Examples来初始化它。我们还需要提供当前的nlp对象。以下是创建和初始化组件的代码,使用我们在前面的代码块中创建的列表:
import spacy
from spacy.training import Example
nlp = spacy.blank("en")
textcat = nlp.add_pipe("textcat")
textcat.initialize(lambda: TRAIN_EXAMPLES, nlp=nlp)
我们将整个TRAIN_EXAMPLES列表作为一个lambda函数传递。下一步是定义优化器以更新模型权重。spaCy 的Language类有一个resume_training()方法,它创建并返回一个优化器。默认情况下,它返回Adam优化器,我们将坚持使用它。
我们准备好定义训练循环。对于每个 epoch,我们逐个遍历训练示例并更新textcat的权重。我们遍历数据 40 个 epochs。spaCy 的util.minibatch函数遍历项目批次。size参数定义了批次大小。我有一个内存足够的 GPU,所以我将数据分成 200 行的组。
重要提示
如果你运行代码并遇到“GPU out of memory”错误,你可以尝试减小size参数。
在训练数据循环到位后,下一步是最终计算模型预测与正确标签之间的差异,并相应地更新权重。Language类的update方法处理这一点。我们将提供数据和字典来更新损失,这样我们就可以跟踪它和之前创建的优化器。以下代码定义了完整的训练循环:
-
初始化管道和组件:
import spacy from spacy.util import minibatch import random nlp = spacy.blank("en") textcat = nlp.add_pipe("textcat") textcat.initialize(lambda: TRAIN_EXAMPLES, nlp=nlp) -
创建优化器:
optimizer = nlp.resume_training() -
定义训练循环:
for epoch in range(40): random.shuffle(TRAIN_EXAMPLES) batches = minibatch(TRAIN_EXAMPLES, size=200) losses = {} for batch in batches: nlp.update( batch, losses=losses, sgd=optimizer, ) if epoch % 10 == 0: print(epoch, "Losses", losses) print(epoch, "Losses", losses)
由此,你就有了一个第一个训练好的 spaCy 组件。如果一切正常,模型正在学习,损失应该会减少。在每 10 个 epoch 后,我们打印损失以检查这是否发生。让我们预测一些未见过的评论的分类,快速看一下模型的行为:
text = "Smoke Paprika My mother uses it for allot of dishes, but this particular one, doesn't compare to anything she had. It is now being used for a decoration on the spice shelf and I will never use it and ruin a dish again. I have tried using just a little bit, thinking it was stronger than her's. And I am a decent cook. But this does not taste like the smoke paprika that I have had in the past. Sorry I don't recommend this product at all."
doc = nlp(text)
print("Example 1", doc.cats)
text = "Terrible Tasting for me The Teechino Caffeine-Free Herbal Coffee, Mediterranean Vanilla Nut tasted undrinkable to me. It lacked a deep, full-bodied flavor, which Cafix and Pero coffee-like substitute products have. I wanted to try something new, and for me, this substitute coffee drink wasn't my favorite."
doc = nlp(text)
print("Example 2", doc.cats)
text = "Dishwater If I had a choice of THIS or nothing, I'd go with nothing. Of all the K-cups I've tasted - this is the worst. Very weak and if you close your eyes and think really hard about it, maybe you can almost taste cinnamon. Blech."
doc = nlp(text)
print("Example 3", doc.cats)
图 5.4 显示了结果:

图 6.4 – 评论示例的分类
该模型对前两个例子是正确的,但最后一个显然是负面评论,而模型将其分类为正面。我们可以看到,评论中包含一些非常客观的负面评论指标,例如段落这是最糟糕的。也许如果我们添加更多关于像 transformers 这样的单词上下文的信息,我们可以提高模型的表现。让我们在下一节尝试一下。
在 spaCy 中使用 Hugging Face transformers
在本章中,我们将使用 spaCy 的transformer组件(来自spacy-transformers)与textcat组件结合使用,以提高管道的准确性。这次,我们将使用 spaCy 的config.cfg系统创建管道,这是训练 spaCy 组件的推荐方式。
让我们先了解 Transformer 组件。
Transformer 组件
Transformer 组件由 spacy-transformers 包提供。使用 Transformer 组件,我们可以使用 transformer 模型来提高我们任务的准确性。该组件支持通过 Hugging Face transformers 库可用的所有模型。在本章中,我们将使用 RoBERTa 模型。我们将在本章的下一节中了解更多关于这个模型的信息。
Transformer 为 Doc 对象添加一个 Doc._.trf_data 属性。这些 transformer 标记可以与其他管道组件共享。在本章中,我们将使用 RoBERTa 模型的标记作为 TextCategorizer 组件的一部分。但首先,让我们使用没有 TextCategorizer 的 RoBERTa 模型来查看它是如何工作的。Transformers 组件允许我们使用许多不同的架构。要使用 Hugging Face 的 roberta-base 模型,我们需要使用 spacy-transformers.TransformerModel.v3 架构。这就是我们这样做的方式:
-
导入库并加载一个空白模型:
import spacy nlp = spacy.blank("en") -
使用
Transformer组件定义我们想要使用的架构。Transformer组件接受一个model配置来设置包装 transformer 的 Thinc 模型。我们将架构设置为spacy-transformers.TransformerModel.v3并将模型设置为roberta-base:config = { "model": { "@architectures": "spacy-transformers.TransformerModel.v3", "name": "roberta-base" } } -
将组件添加到管道中,初始化它,并打印向量:
nlp.add_pipe("transformer", config=config) nlp.initialize() doc = nlp("Dishwater If I had a choice of THIS or nothing, I'd go with nothing. Of all the K-cups I've tasted - this is the worst. Very weak and if you close your eyes and think really hard about it, maybe you can almost taste cinnamon. Blech.") print(doc._.trf_data)
结果是一个包含 transformer 模型的输入和输出对象的批次的 FullTransformerBatch 对象。
很酷,现在我们需要使用这个模型输出与 TextCategorizer 组件一起使用。我们将使用 config.cfg 文件来完成,所以首先我们需要学习如何与这个配置系统一起工作。
spaCy 的配置系统
spaCy v3.0 引入了配置文件。这些文件用于包含训练管道的所有设置和超参数。在底层,训练配置使用 Thinc 库提供的配置系统。正如 spaCy 文档所指出的,spaCy 训练配置的一些主要优点和功能如下:
-
结构化部分:配置被分组到部分中,嵌套部分使用
.符号定义。例如,[components.textcat]定义了管道的TextCategorizer组件的设置。 -
插值:如果您有多个组件使用的超参数或其他设置,请定义一次,并作为变量引用。
-
无隐藏默认值的可重复性:配置文件是“单一事实来源”并包含所有设置。
-
Automated checks and validation:当你加载一个配置时,spaCy 会检查设置是否完整,以及所有值是否具有正确的类型。这让你能够及早捕捉到潜在的错误。在你的自定义架构中,你可以使用 Python 类型提示来告诉配置期望哪些类型的数据。
配置被分为多个部分和子部分,由方括号和点符号表示。例如,[components]是一个部分,而[components.textcat]是一个子部分。配置文件的主要顶级部分如下:
-
paths:数据和其它资产的路由。在配置中作为变量重用(例如,${paths.train}),并且可以在命令行界面(CLI)上覆盖。 -
system:与系统和硬件相关的设置。在配置中作为变量重用(例如,${system.seed}),并且可以在命令行界面(CLI)上覆盖。 -
nlp:nlp对象、其分词器和处理流程组件名称的定义。 -
components:流程组件及其模型的定义。 -
training:训练和评估过程的设置和控制。 -
pretraining:语言模型预训练的可选设置和控制。 -
initialize:在训练前调用nlp.initialize()时传递给组件的数据资源和参数(但不是在运行时)。
现在我们已经知道了如何训练一个深度学习模型,以及如何使用 Thinc 作为 spaCy 训练过程的一部分来定义此训练的配置。这个配置系统对于维护和重现 NLP 流程非常有用,并且不仅限于训练,还包括在我们不需要训练组件时构建流程。当与 spaCy CLI 结合使用时,spaCy 配置系统表现得尤为出色。
使用配置文件训练 TextCategorizer
在本节中,我们将使用 spaCy 的命令行界面(CLI)来微调分类流程。通常,训练模型的第一步是准备数据。使用 spaCy 进行训练时,推荐的方式是使用DocBin容器,而不是像之前那样创建Example对象。DocBin容器打包了一系列Doc对象,以便进行二进制序列化。
要使用DocBin创建训练数据,我们将使用评论的文本创建Doc对象,并相应地添加doc.cats属性。这个过程相当直接,我们只需要使用DocBin.add()方法添加一个Doc注释以进行序列化:
-
首先,我们像之前一样加载数据并进行分割:
import pandas as pd import spacy from spacy.tokens import DocBin df = pd.read_csv("data/amazon_food_reviews.csv") df_train = df.sample(frac=0.8,random_state=200) nlp = spacy.blank("en") -
现在,我们创建一个
DocBin对象,并在for循环内部创建Doc对象并将它们添加到DocBin:db = DocBin() for _,row in df_train.iterrows(): doc = nlp(row["text"]) if row["positive_review"] == 1: doc.cats = {"positive": 1, "negative": 0} else: doc.cats = {"positive": 0, "negative": 1} db.add(doc) -
最后,我们将
DocBin对象保存到磁盘:db.to_disk("data/train.spacy") -
我们还需要创建一个
dev测试集(它将在训练中使用),因此让我们创建一个函数来转换数据集:from pathlib import Path def convert_dataset(lang: str, input_path: Path, output_path: Path): nlp = spacy.blank(lang) db = DocBin() df = pd.read_json(input_path) for _,row in df.iterrows(): doc = nlp.make_doc(row["Text"]) if row["positive_review"] == 1: doc.cats = {"positive": 1, "negative": 0} else: doc.cats = {"negative": 1, "positive": 0} db.add(doc) db.to_disk(output_path) convert_dataset("en", "data/df_dev.json", "data/dev.spacy")
现在,我们已经以推荐的方式准备好了所有数据以训练模型。我们将在一分钟内使用这些 .spacy 文件;让我们首先学习如何使用 spaCy CLI。
spaCy 的 CLI
使用 spaCy 的 CLI,您可以通过命令行执行 spaCy 操作。使用命令行很重要,因为我们可以创建和自动化管道的执行,确保每次运行管道时,它都会遵循相同的步骤。
spaCy 的 CLI 提供了用于训练管道、转换数据、调试配置文件、评估模型等命令。您可以通过输入 python -m spacy --help 来查看所有 CLI 命令的列表。
spacy train 命令用于训练或更新一个 spaCy 管道。它需要 spaCy 的二进制格式数据,但您也可以使用 spacy convert 命令将数据从其他格式转换过来。配置文件应包含训练过程中使用的所有设置和超参数。我们可以使用命令行选项来覆盖设置。例如,--training.batch_size 128 会覆盖 "[** **training]" 块中 "batch_size" 的值。
我们将使用 spacy init config CLI 命令来创建配置文件。配置文件中的信息包括以下内容:
-
转换数据集的路径
-
一个种子数和 GPU 配置
-
如何创建
nlp对象 -
如何构建我们将使用的组件
-
如何进行训练本身
对于训练,明确所有设置 非常重要。我们不希望有隐藏的默认值,因为它们可以使管道难以重现。这是配置文件设计的一部分。
让我们创建一个不使用 Transformer 组件的训练配置,以了解训练模型的正确方式:
python3 -m spacy init config config_without_transformer.cfg --lang “en” --pipeline “textcat”
此命令使用英语模型和一个 TextCategorizer 组件创建一个名为 config_without_transformer.cfg 的配置文件,并默认定义了所有其他设置。
在文件中,在 paths 部分中,我们应该指向 train 和 dev 数据路径。然后,在 system 部分中,我们设置随机种子。spaCy 使用 CuPy 来支持 GPU。CuPy 为 GPU 数组提供了一个与 NumPy 兼容的接口。gpu_allocator 参数设置 CuPy 将 GPU 内存分配路由到哪个库,其值可以是 pytorch 或 tensorflow。这避免了在使用 CuPy 与这些库之一一起使用时出现的内存问题,但由于现在的情况,我们可以将其设置为 null。
在 nlp 部分,我们指定我们将使用的模型并定义管道的组件,目前只是 textcat。在 components 部分,我们需要指定如何初始化组件,因此我们在 component.textcat 子部分中设置了 factory = "textcat" 参数。textcat 是创建 TextCategorizer 组件的注册函数的名称。您可以在 spacy.io/api/data-formats#config 上看到所有可用的配置参数。
配置设置完成后,我们可以运行 spacy train 命令。这次运行的输出是一个新的管道,因此您需要指定一个路径来保存它。以下是运行训练过程的完整命令:
python3 -m spacy train config_without_transformer.cfg --paths.train "data/train.spacy" --paths.dev "data/dev.spacy" --output pipeline_without_transformer/
这个命令使用我们创建的配置文件训练管道,并指向 train.spacy 和 dev.spacy 数据。图 6 .5 展示了训练输出。

图 6.5 – 训练输出
E 表示时代,你还可以看到每个优化步骤的损失和分数。最佳模型保存在 pipeline_without_transformer/model-last 。让我们加载它并检查前述示例的结果:
import spacy
nlp = spacy.load("pipeline_without_transformer/model-best")
text = "Smoke Paprika My mother uses it for allot of dishes, but this particular one, doesn't compare to anything she had. It is now being used for a decoration on the spice shelf and I will never use it and ruin a dish again. I have tried using just a little bit, thinking it was stronger than her's. And I am a decent cook. But this does not taste like the smoke paprika that I have had in the past. Sorry I don't recommend this product at all."
doc = nlp(text)
print("Example 1", doc.cats)
text = "Terrible Tasting for me The Teechino Caffeine-Free Herbal Coffee, Mediterranean Vanilla Nut tasted undrinkable to me. It lacked a deep, full-bodied flavor, which Cafix and Pero coffee-like substitute products have. I wanted to try something new, and for me, this substitute coffee drink wasn't my favorite."
doc = nlp(text)
print("Example 2", doc.cats)
text = "Dishwater If I had a choice of THIS or nothing, I'd go with nothing. Of all the K-cups I've tasted - this is the worst. Very weak and if you close your eyes and think really hard about it, maybe you can almost taste cinnamon. Blech."
doc = nlp(text)
print("Example 3", doc.cats)
图 6 .6 展示了结果。

图 6.6 – 使用新流程的审查示例类别
现在,模型对前两个示例是不正确的,对第三个示例是正确的。让我们看看我们是否可以使用 transformers 组件来改进这一点。在这样做之前,现在是学习最有影响力的变压器模型之一,BERT 的内部结构的好时机。然后,我们将了解其继任者,RoBERTa,这是我们将在本章分类用例中使用的模型。
BERT 和 RoBERTa
在本节中,我们将探讨最有影响力和最常用的 Transformer 模型,BERT。BERT 在 Google 2018 年的研究论文中被介绍;您可以在以下链接中阅读:arxiv.org/pdf/1810.04805.pdf。
BERT 究竟做了什么?为了理解 BERT 的输出,让我们剖析一下这个名字:
Bidirectional: Training on the text data is bi-directional, which means each input sentence is processed from left to right as well as from right to left.
Encoder: An encoder encodes the input sentence.
Representations: A representation is a word vector.
Transformers: The architecture is transformer-based.
BERT 实质上是一个训练好的变压器编码器堆栈。BERT 的输入是一个句子,输出是一个单词向量的序列。BERT 与之前的词向量技术之间的区别在于,BERT 的词向量是上下文相关的,这意味着一个向量是根据输入句子分配给一个单词的。
类似于 GloVe 的词向量是上下文无关的,这意味着一个单词的词向量在句子中使用时总是相同的,不受句子上下文的影响。以下图表解释了这个问题:

图 6.7 – “bank”单词的词向量
在这里,尽管这两个句子中的单词 bank 有两种完全不同的含义,但词向量是相同的。每个单词只有一个向量,并且向量在训练后保存到文件中。
相反,BERT 词向量是动态的。BERT 可以根据输入句子为同一单词生成不同的词向量。以下图表显示了 BERT 生成的词向量:

图 6.8 – BERT 在两个不同语境下为同一单词“bank”生成的两个不同的词向量
BERT 是如何生成这些词向量的?在下一节中,我们将探讨 BERT 架构的细节。
BERT 架构
BERT 是一个变压器编码器堆叠,这意味着几个编码器层堆叠在一起。第一层随机初始化词向量,然后每个编码器层将前一个编码器层的输出进行转换。论文介绍了两种 BERT 模型大小:BERT Base 和 BERT Large。以下图表显示了 BERT 架构:

图 6.9 – BERT Base 和 Large 架构,分别有 12 和 24 个编码器层
两个 BERT 模型都有大量的编码器层。BERT Base 有 12 个编码器层,BERT Large 有 24 个编码器层。生成的词向量维度也不同;BERT Base 生成 768 大小的词向量,BERT Large 生成 1024 大小的词向量。
以下图表展示了 BERT 输入和输出的高级概述(现在忽略 CLS 标记;你将在 BERT 输入 格式 部分学习有关它的内容):

图 6.10 – BERT 模型输入词和输出词向量
在前面的图表中,我们可以看到 BERT 输入和输出的高级概述。BERT 输入必须以特殊格式,并包含一些特殊标记,如 图 6.10 中的 CLS。在下一节中,你将了解 BERT 输入格式的细节。
BERT 输入格式
要理解 BERT 如何生成输出向量,我们需要了解 BERT 输入数据格式。BERT 输入格式可以表示单个句子,也可以表示一对句子。对于问答和语义相似度等任务,我们将两个句子作为一个标记序列输入到模型中。
BERT 与一类特殊标记和一种称为 WordPiece 的特殊标记化算法一起工作。主要的特殊标记是 [CLS],[SEP] 和 [PAD]:
-
BERT 的第一个特殊标记是 [
CLS]。每个输入序列的第一个标记必须是 [CLS]。我们在分类任务中使用此标记作为输入句子的汇总。在非分类任务中,我们忽略此标记。 -
[
SEP] 表示句子分隔符。如果输入是一个单独的句子,我们将此标记放置在句子的末尾。如果输入是两个句子,则使用此标记来分隔两个句子。因此,对于单个句子,输入看起来像 [CLS] 句子 [SEP],而对于两个句子,输入看起来像 [CLS] 句子 1 [SEP] 句子 2 [SEP]。 -
[
PAD] 是一个特殊标记,表示填充。BERT 接收固定长度的句子;因此,我们在将句子输入到 BERT 之前对其进行填充。我们可以输入到 BERT 中的标记的最大长度是 512。
BERT 使用 WordPiece 分词对单词进行分词。一个“词片”字面上就是一个单词的一部分。WordPiece 算法将单词分解成几个子词。其想法是将复杂/长的标记分解成更简单的标记。例如,单词 playing 被分词为 play 和 ##ing。一个 ## 字符放置在每个词片之前,以指示此标记不是语言词汇中的单词,而是词片。
让我们看看更多的例子:
playing play, ##ing
played play, ##ed
going go, ##ing
vocabulary = [play, go, ##ing, ##ed]
通过这样做,我们更紧凑地表示语言词汇,将常见的子词分组。WordPiece 分词在罕见/未见过的单词上创造了奇迹,因为这些单词被分解成它们的子词。
在对输入句子进行分词并添加特殊标记后,每个标记被转换为它的 ID。之后,我们将标记 ID 的序列输入到 BERT。
总结来说,这是我们将句子转换为 BERT 输入格式的方法:

图 6.11 – 将输入句子转换为 BERT 输入格式
这个分词过程对于转换器模型至关重要,因为它允许模型处理词汇表外的单词,并有助于泛化。例如,模型可以学习到像 happiness 和 sadness 这样的单词中 ness 后缀具有特定的含义,并且可以使用这种知识来处理具有相同后缀的新单词。
BERT 在一个大型未标记的 Wiki 语料库和庞大的书籍语料库上训练。如 Google Research 的 BERT GitHub 仓库 github.com/google-research/bert 中所述,他们在一个大型语料库(维基百科 + BookCorpus)上长时间(1M 更新步骤)训练了一个大型模型(12 层到 24 层的转换器)。
BERT 使用两种训练方法进行训练:掩码语言模型(MLM)和下一个句子预测(NSP)。语言模型是预测给定先前标记序列的下一个标记的任务。例如,给定单词序列 Yesterday I visited a,语言模型可以预测下一个标记为诸如 church、hospital、school 等标记之一。掩码语言模型是一种语言模型,其中我们通过用 掩码标记随机替换一定比例的标记来掩码。我们期望 MLM 能够预测掩码的单词。
在 BERT 中的掩码语言模型数据准备如下。首先,随机选择 15 个输入标记。然后,发生以下情况:
-
所选择的标记中有 80% 被替换为 粗体标记。
-
所选择的标记中有 10% 被替换为词汇表中的另一个标记
-
剩余的 10% 保持不变
MLM 的一个训练示例句子如下:
[CLS] Yesterday I [MASK] my friend at [MASK] house [SEP]
NSP 是根据输入句子预测下一个句子的任务。在这个方法中,我们向 BERT 输入两个句子,并期望 BERT 预测句子的顺序,更具体地说,是否第二个句子是跟在第一个句子后面的句子。
让我们做一个 NSP 的示例输入。我们将以 [SEP] 标记分隔的两个句子作为输入:
[CLS] A man robbed a [MASK] yesterday [MASK] 8 o'clock [SEP]
He [MASK] the bank with 6 million dollars [SEP]
Label = IsNext
在这个例子中,第二句话可以跟在第一句话后面;因此,预测的标签是 IsNext。这个例子怎么样?
[CLS] Rabbits like to [MASK] carrots and [MASK] leaves [SEP]
[MASK] Schwarzenegger is elected as the governor of [MASK] [SEP]
Label= NotNext
这对句子示例生成的是 NotNext 标签,因为它们在上下文或语义上不相关。
这两种训练技术都允许模型学习关于语言的复杂概念。Transformer 是 LLM 的基础。LLM 正在改变 NLP 世界,这主要是因为它们理解上下文的能力。
现在你已经了解了 BERT 架构、输入格式的细节以及训练数据准备,你有了理解 LLM 的工作原理的坚实基础。回到我们的分类用例,我们将使用 BERT 的一个后继模型,即 RoBERTa。让我们在下一节中了解 RoBERTa。
RoBERTa
RoBERTa 模型在 arxiv.org/abs/1907.11692 中被提出。它建立在 BERT 的基础上,它们之间的关键区别在于数据准备和训练。
BERT 在数据预处理期间进行一次标记掩码,这导致每个训练实例在每个 epoch 中都有相同的掩码。RoBERTa 使用 动态掩码,每次我们向模型输入一个序列时,它们都会生成掩码模式。他们还移除了 NSP,因为他们发现它匹配或略微提高了下游任务性能。
RoBERTa 也比 BERT 使用更大的批量大小和更大的词汇量,从 30K 的词汇量到包含 50K 子词单元的词汇量。这篇论文是一篇非常好的读物,可以了解影响 Transformer 模型的设计决策。
既然我们已经了解了 BERT 和 RoBERTa 的工作原理,现在是时候最终在我们的文本分类管道中使用 RoBERTa 了。
使用转换器训练 TextCategorizer
要与transformer组件进行下游任务,我们需要告诉 spaCy 如何将组件输出与其他管道组件连接起来。我们将使用spacy-transformers.TransformerModel.v3和spacy-transformers.TransformerListener.v1层来完成这项工作。
在 spaCy 中,我们有不同的模型架构,这些是连接 Thinc Model实例的函数。TransformerModel和TransformerListener模型都是转换器层。
spacy-transformers.TransformerModel.v3层加载并包装了来自 Hugging Face Transformers 库的转换器模型。它与任何具有预训练权重和 PyTorch 实现的转换器一起工作。spacy-transformers.TransformerListener.v1层接受一个Doc对象列表作为输入,并使用TransformerModel层生成一个二维数组列表作为输出。
现在你已经了解了 spaCy 层概念,是时候回顾TextCategorizer组件了。在 spaCy 中,TextCategorizer组件有不同的模型架构层。通常,每个架构接受子层作为参数。默认情况下,TextCategorizer组件使用spacy.TextCatEnsemble.v2层,这是一个线性词袋模型和神经网络模型的堆叠集成。我们在使用配置文件训练管道时使用了这个层。
为了结束本章的旅程,我们将TextCatEnsemble的神经网络层从默认的spacy.Tok2Vec.v2层更改为 RoBERTa 转换器模型。我们将通过创建一个新的配置文件来完成这项工作:
python3 -m spacy init config config_transformer.cfg --lang "en" --pipeline "textcat" --optimize "accuracy" --gpu
此命令创建了一个针对准确性和 GPU 训练优化的config_transformer.cfg文件。图 6.12显示了命令的输出。

图 6.12 – 创建使用 RoBERTa 的新训练配置
现在,我们可以通过指向此配置文件来训练管道,训练模型,并做出预测,就像我们在上一节中所做的那样:
python3 -m spacy train config_transformer.cfg --paths.train "data/train.spacy" --paths.dev "data/dev.spacy" --output pipeline_transformer/ --gpu-id 0
这次,我们使用 GPU 进行训练,因此设置了gpu_id参数。图 6.13显示了使用这个新训练模型的结果。

图 6.13 – 使用转换器管道的评论示例类别
现在,模型能够正确地分类评论。不错,不是吗?
摘要
可以说,这一章是本书最重要的章节之一。在这里,我们学习了迁移学习和转换器,以及如何使用 spaCy 配置系统来训练TextCategorizer组件。
通过了解如何准备数据以训练 spaCy 组件以及如何使用配置文件来定义训练设置的知识,你现在能够微调任何 spaCy 可训练组件。这是一个巨大的进步,恭喜你!
在本章中,你学习了关于语言模型的内容。在下一章中,你将学习如何使用 LLMs,它们是目前最强大的 NLP 模型。
第三部分:定制和集成 NLP 工作流程
本节重点介绍创建定制的 NLP 解决方案以及将 spaCy 与其他工具和平台集成。你将了解如何利用大型语言模型(LLMs)、训练自定义模型以及将 spaCy 项目与网络应用程序集成以构建端到端解决方案。
本部分包含以下章节:
-
第七章 ,使用 spacy-llm 增强 NLP 任务
-
第八章 ,使用您自己的数据训练 NER 组件
-
第九章 ,使用 Weasel 创建端到端 spaCy 工作流程
-
第十章 ,使用 spaCy 训练实体链接器模型
-
第十一章 ,将 spaCy 与第三方库集成
第七章:使用 spacy-llm 增强 NLP 任务
在本章中,我们将基于在第六章中获得的知识,探讨如何使用spacy-llm库将大型语言模型(LLMs)集成到 spaCy 管道中。我们将从理解 LLMs 和提示工程的基础知识开始,以及这些强大的模型如何在 spaCy 中执行各种 NLP 任务。我们将演示如何配置和使用预构建的 LLM 任务,如文本摘要,然后进一步创建一个自定义任务,从文本中提取上下文信息。这涉及到使用 Jinja 模板创建提示,并编写自定义 spaCy 组件,以高效地处理复杂的 NLP 任务。到本章结束时,你将更深入地了解如何利用 LLMs 的灵活性和强大功能来增强传统的 NLP 管道。
在本章中,我们将涵盖以下主要主题:
-
LLMs 和提示工程基础知识
-
使用 LLMs 和 spaCy 进行文本摘要
-
使用 Jinja 模板创建自定义 LLM 任务
技术要求
在本章中,我们将使用 spaCy 和spacy-llm库来创建和运行我们的管道。你可以在此章节中找到使用的代码:github.com/PacktPublishing/Mastering-spaCy-Second-Edition。
LLMs 和提示工程基础知识
正如我们在第六章中看到的,语言建模是预测给定先前标记序列的下一个标记的任务。我们使用的例子是,给定单词序列昨天我访问了一个,语言模型可以预测下一个标记可能是教堂、医院、学校等。传统的语言模型通常以监督方式训练以执行特定任务。预训练语言模型(PLM)以自监督方式训练,目的是学习语言的通用表示。然后对这些 PLM 模型进行微调以执行特定的下游任务。这种自监督的预训练使 PLM 模型比常规语言模型更强大。
LLMs(大型语言模型)是 PLMs(预训练语言模型)的进化,拥有更多的模型参数和更大的训练数据集。例如,GPT-3 模型拥有 1750 亿个参数。其继任者 GPT3.5 是 2022 年 11 月发布的 ChatGPT 模型的基础。LLMs 可以作为通用工具,能够执行从语言翻译到编码辅助的各种任务。它们理解和生成类似人类文本的能力,在医学、教育、科学、数学、法律等领域产生了重大影响。在医学领域,LLMs 为医生提供基于证据的建议,并增强患者互动。在教育领域,它们定制学习体验,并协助教师创建内容。在科学领域,LLMs 加速研究和科学写作。在法律领域,它们分析法律文件并阐明复杂术语。
我们还可以使用 LLMs 进行常规 NLP 任务,如命名实体识别(NER)、文本分类和文本摘要。基本上,这些模型可以完成我们要求的几乎所有事情。但这是有代价的,因为训练它们需要大量的计算资源,大量的层和参数使它们产生答案的速度比非 LLM 模型慢得多。LLMs 也可能产生幻觉:产生看似合理但实际上不正确或与事实或上下文不一致的响应。这种现象发生是因为模型根据从训练数据中学习的模式生成文本,而不是通过外部来源验证信息。因此,它们可能会创建听起来合理但实际上具有误导性、不准确或完全虚构的陈述。鉴于所有这些,LLMs 是有用的,但我们始终应该分析它们是否是手头项目的最佳解决方案。
要与 LLMs 交互,我们使用提示。提示应引导模型生成答案或使模型采取行动。提示通常包含以下元素:
-
指令:您希望模型执行的任务
-
上下文:对产生更好答案有用的外部信息或附加上下文
-
输入数据:我们想要得到答案的输入/问题
-
输出指示器:我们希望模型输出的格式类型
使用spacy-llm,我们将提示定义为任务。当使用 LLMs 构建 spaCy 管道时,每个 LLM 组件都使用一个任务和一个模型来定义。任务定义了提示和解析结果的提示和功能。模型定义了 LLM 模型以及如何连接到它。
现在您已经了解了 LLMs 是什么以及如何与它们交互,让我们在管道中使用一个spacy-llm组件。在下一节中,我们将创建一个使用 LLM 来总结文本的管道。
使用 LLMs 和 spacy-llm 进行文本摘要
每个 spacy-llm 组件都有一个任务定义。spaCy 有一些预定义的任务,我们也可以创建自己的任务。在本节中,我们将使用 spacy.Summarization.v1 任务。每个任务都是通过一个提示来定义的。以下是该任务的提示,可在 github.com/explosion/spacy-llm/blob/main/spacy_llm/tasks/templates/summarization.v1.jinja 找到:
You are an expert summarization system. Your task is to accept Text as input and summarize the Text in a concise way.
{%- if max_n_words -%}
{# whitespace #}
The summary must not, under any circumstances, contain more than {{ max_n_words }} words.
{%- endif -%}
{# whitespace #}
{%- if prompt_examples -%}
{# whitespace #}
Below are some examples (only use these as a guide):
{# whitespace #}
{%- for example in prompt_examples -%}
{# whitespace #}
Text:
'''
{{ example.text }}
'''
Summary:
'''
{{ example.summary }}
'''
{# whitespace #}
{%- endfor -%}
{# whitespace #}
{%- endif -%}
{# whitespace #}
Here is the Text that needs to be summarized:
'''
{{ text }}
'''
Summary:
spacy-llm 使用 Jinja 模板来定义指令和示例。Jinja 使用占位符在模板中动态插入数据。最常见的占位符是 {{ }} ,{% %} 和 {# #} 。{{ }} 用于添加变量或表达式,{% %} 与流程控制语句一起使用,{# #} 用于添加注释。让我们看看这些占位符如何在 spacy.Summarization.v1 模板中使用。
我们可以要求模型输出具有特定最大单词数的摘要。max_n_words 的默认值是 null。如果我们在配置中设置了此参数,模板将包括此数字:
{%- if max_n_words -%}
{# whitespace #}
The summary must not, under any circumstances, contain more than {{ max_n_words }} words.
{%- endif -%}
Few-shot prompting 是一种技术,它包括提供一些期望的输入和输出示例(通常为 1 到 5 个),以展示我们希望模型如何生成结果。这些示例有助于模型更好地理解模式,而无需使用大量示例进行微调。spacy.Summarization.v1 任务有一个 examples 参数来生成少量示例。
现在我们已经了解了总结模板任务的工作原理,是时候开始处理 spacy-llm 的其他元素了,即 模型。我们将使用 Anthropic 的 Claude 2 模型。为了确保连接到该模型的凭据可用,您可以在计算机上的控制台中运行 export ANTHROPIC_API_KEY="..." 命令。现在让我们使用 python3 -m pip install spacy-llm==0.7.2 命令安装该包。我们将使用 config.cfg 文件来加载管道(如果您需要复习,可以回到 第六章 中的 使用 spaCy config.cfg 文件 部分)。让我们构建配置文件:
-
首先,我们将定义
nlp部分,其中我们应该定义我们的管道的语言和组件。我们只使用llm组件:[nlp] lang = "en" pipeline = ["llm"] -
现在,是时候指定
components部分。为了初始化llm组件,我们将写入factory = "llm";然后,我们将指定任务和模型:[components] [components.llm] factory = "llm" [components.llm.task] @llm_tasks = "spacy.Summarization.v1" examples = null max_n_words = null [components.llm.model] @llm_models = "spacy.Claude-2.v2" config = {"max_tokens_to_sample": 1024} -
为了加载此管道,我们将通过
spacy_llm.util的assemble方法传递此配置文件的路径。让我们要求模型总结本章的 LLMs 和提示工程基础 部分:from spacy_llm.util import assemble nlp = assemble("config.cfg") content = """ As we saw on Chapter 6, Language Modeling is the task of predicting the next token given the sequence of previous tokens. [...] Now that you know what LLMs are and how to interact with them, let's use a spacy-llm component in a pipeline. In the next section we're going to create a pipeline to summarize texts using a LLM. """ doc = nlp(content) print(doc._.summary) -
spacy.Summarization.v1任务默认将摘要添加到._.summary扩展属性中。以下是模型的响应:'Here is a concise summary of the key points from the text:\n\nLanguage models predict the next token in a sequence. Pre-trained language models (PLMs) are trained in a self-supervised way to learn general representations of language. PLMs are fine-tuned for downstream tasks. Large language models (LLMs) like GPT-3 have billions of parameters and are trained on huge datasets. LLMs can perform a variety of tasks including translation, coding assistance, scientific writing, and legal analysis. However, LLMs require lots of compute resources, are slow, and can sometimes "hallucinate" plausible but incorrect information. We interact with LLMs using prompts that provide instructions, context, input data, and indicate the desired output format. Spacy-llm allows defining LLM components in spaCy pipelines using tasks to specify prompts and models to connect to the LLM. The text then explains we will create a pipeline to summarize text using a LLM component.'
很好,对吧?你可以检查其他参数来在此处自定义任务 spacy.io/api/large-language-models#summarization-v1 。一些其他可用的 spacy-llm 任务包括 spacy.EntityLinker.v1** , **spacy.NER.v3** , **spacy.SpanCat.v3** , **spacy.TextCat.v3 , 和 spacy.Sentiment.v1 。但除了使用这些预构建的任务之外,你还可以创建自己的任务,这不仅增强了 spacy-llm 的功能,而且为构建 NLP 管道时遵循最佳实践提供了一种有组织的方式。让我们在下一节中学习如何做到这一点。
创建自定义 spacy-llm 任务
在本节中,我们将创建一个任务,给定一个来自 dummyjson.com/docs/quotes 的引用,模型应提供引用的上下文。以下是一个示例:
Quote: We must balance conspicuous consumption with conscious capitalism.
Context: Business ethics.
创建自定义 spacy-llm 任务的第一个步骤是创建提示并将其保存为 Jinja 模板。以下是此任务的模板:
You are an expert at extracting context from text.
Your tasks is to accept a quote as input and provide the context of the quote.
This context will be used to group the quotes together.
Do not put any other text in your answer and provide the context in 3 words max. The quote should have one context only.
{# whitespace #}
{# whitespace #}
Here is the quote that needs classification
{# whitespace #}
{# whitespace #}
Quote:
'''
{{ text }}
我们将这个保存到名为 templates/quote_context_extract.jinja 的文件中。下一步是创建任务的类。这个类应该实现两个函数:
-
generate_prompts(docs: Iterable[Doc]) -> Iterable[str]: 这个函数将 spaCyDoc对象列表转换为提示列表。 -
parse_responses(docs: Iterable[Doc], responses: Iterable[str]) -> Iterable[Doc]: 这个函数将 LLM 输出解析为 spaCyDoc对象。
generate_prompts() 方法将使用我们的 Jinja 模板,而 parse_responses() 方法将接收模型的响应并添加上下文扩展属性到我们的 Doc 对象。让我们创建 QuoteContextExtractTask 类:
-
首先,我们导入所有需要的函数并设置模板的目录:
from pathlib import Path from spacy_llm.registry import registry import jinja2 from typing import Iterable from spacy.tokens import Doc TEMPLATE_DIR = Path("templates") -
现在,让我们创建一个方法来读取 Jinja 模板中的文本:
def read_template(name: str) -> str: """Read the text from a Jinja template using pathlib""" path = TEMPLATE_DIR / f"{name}.jinja" if not path.exists(): raise ValueError(f"{name} is not a valid template.") return path.read_text() -
最后,我们可以开始创建
QuoteContextExtractTask类。让我们从创建__init__()方法开始。这个类应该使用 Jinja 模板的名称和一个字段字符串来设置任务将添加到Doc对象的扩展属性名称:class QuoteContextExtractTask: def __init__(self, template: str = "quotecontextextract", field: str = "context"): self._template = read_template(template) self._field = field -
现在我们将创建一个方法来构建提示。Jinja 使用
Environment对象从文件中加载模板。我们将使用from_string()方法从文本构建模板并生成它。每次此方法内部运行时,它将渲染模板,用模板中的{{text}}变量的值替换模板的doc.text:def generate_prompts(self, docs: Iterable[Doc]) -> Iterable[str]: environment = jinja2.Environment() _template = environment.from_string(self._template) for doc in docs: prompt = _template.render( text=doc.text, ) yield prompt -
我们现在可以编写类的最后一个方法。
parse_responses()方法将添加模型的响应到Doc对象。首先,我们创建一个辅助方法来添加扩展属性,如果它不存在。为了设置扩展属性,我们将使用 Python 的setattr ()方法,这样我们就可以使用类字段变量动态设置属性:def _check_doc_extension(self): """Add extension if need be.""" if not Doc.has_extension(self._field): Doc.set_extension(self._field, default=None) def parse_responses( self, docs: Iterable[Doc], responses: Iterable[str] ) -> Iterable[Doc]: self._check_doc_extension() for doc, prompt_response in zip(docs, responses): try: setattr( doc._, self._field, prompt_response[0].strip(), ) except ValueError: setattr(doc._, self._field, None) yield doc -
要在
config.cfg文件中使用这个类,我们需要将任务添加到spacy-llm的llm_tasks注册表中:@registry.llm_tasks("my_namespace.QuoteContextExtractTask.v1") def make_quote_extraction() -> "QuoteContextExtractTask": return QuoteContextExtractTask()
完成了!将此保存到quote.py类中。以下是应该在这个脚本中的完整代码:
from pathlib import Path
from spacy_llm.registry import registry
import jinja2
from typing import Iterable
from spacy.tokens import Doc
TEMPLATE_DIR = Path("templates")
def read_template(name: str) -> str:
"""Read the text from a Jinja template using pathlib"""
path = TEMPLATE_DIR / f"{name}.jinja"
if not path.exists():
raise ValueError(f"{name} is not a valid template.")
return path.read_text()
@registry.llm_tasks("my_namespace.QuoteContextExtractTask.v1")
def make_quote_extraction() -> "QuoteContextExtractTask":
return QuoteContextExtractTask()
class QuoteContextExtractTask:
def __init__(self, template: str = "quote_context_extract",
field: str = "context"):
self._template = read_template(template)
self._field = field
def generate_prompts(self,
docs: Iterable[Doc]) -> Iterable[str]:
environment = jinja2.Environment()
_template = environment.from_string(self_template)
for doc in docs:
prompt = _template.render(
text=doc.text,
)
yield prompt
def _check_doc_extension(self):
"""Add extension if need be."""
if not Doc.has_extension(self._field):
Doc.set_extension(self._field, default=None)
def parse_responses(
self, docs: Iterable[Doc], responses: Iterable[str]
) -> Iterable[Doc]:
self._check_doc_extension()
for doc, prompt_response in zip(docs, responses):
try:
setattr(
doc._,
self._field,
prompt_response[0].strip(),
),
except ValueError:
setattr(doc._, self._field, None)
yield doc
-
现在,让我们通过首先创建
config_custom_task.cfg文件来测试我们的自定义任务:[nlp] lang = "en" pipeline = ["llm"] [components] [components.llm] factory = "llm" [components.llm.task] @llm_tasks = "my_namespace.QuoteContextExtractTask.v1" [components.llm.model] @llm_models = "spacy.Claude-2.v2" config = {"max_tokens_to_sample": 1024} -
最后,我们可以使用这个文件组装
nlp对象,并打印出引语的上下文。别忘了从quote.py导入QuoteContextExtractTask,这样 spaCy 就知道从哪里加载这个任务:from spacy_llm.util import assemble from quote import QuoteContextExtractTask nlp = assemble("config_custom_task.cfg") quote = "Life isn't about getting and having, it's about giving and being." doc = nlp(quote) print("Context:", doc._.context) >>> Context: self-improvement
在本节中,你创建了一个自定义的spacy-llm任务来从给定的引语中提取上下文。这种方法不仅允许你根据需求定制高度具体的 NLP 任务,而且还提供了一种结构化的方式将软件工程的最佳实践,如模块化和可重用性,集成到你的 NLP 管道中。
摘要
在本章中,我们探讨了如何利用大型语言模型(LLMs)在 spaCy 管道中使用spacy-llm库。我们回顾了 LLMs 和提示工程的基础知识,强调它们作为多功能工具在执行各种 NLP 任务中的作用,从文本分类到摘要。然而,我们也指出了 LLMs 的局限性,例如它们的高计算成本和产生幻觉的倾向。然后,我们展示了如何通过定义任务和模型将 LLMs 集成到 spaCy 管道中。具体来说,我们实现了一个摘要任务,随后创建了一个自定义任务来从引语中提取上下文。这个过程涉及到创建提示的 Jinja 模板和定义生成和解析响应的方法。
在下一章中,我们将回到更传统的机器学习,学习如何使用 spaCy 从头开始标注数据和训练管道组件。
第八章:使用自己的数据训练 NER 组件
在本章中,你将学习如何使用自己的数据来训练 spaCy 的预训练模型。我们将通过训练一个命名实体识别(NER)管道来实现这一点,但你也可以将同样的知识应用到预处理和训练 spaCy 管道的任何 NLP 任务上。在本章中,我们将更多地关注如何收集和标注自己的数据,因为我们已经在第六章中看到了如何使用 spaCy 的config.cfg文件来训练模型。
本章的学习之旅包括如何最大限度地利用来自 Explosion 的标注工具Prodigy以及 spaCy 背后的团队。我们还将看到如何使用 Jupyter Notebook 标注 NER 数据。之后,我们将使用这些标注数据更新 spaCy 管道的 NER 组件。
本章将带你完成整个机器学习实践,包括收集数据、标注数据和训练信息提取模型。
到本章结束时,你将准备好在自己的数据上训练 spaCy 模型。你将具备收集数据、将数据预处理成 spaCy 可以识别的格式,以及最终使用这些数据训练 spaCy 模型的全套技能。我们将涵盖以下主要主题:
-
开始数据准备
-
标注和准备数据
-
训练 NER 管道组件
-
在同一管道中结合多个 NER 组件
技术要求
本章的代码可以在github.com/PacktPublishing/Mastering-spaCy-Second-Edition找到。我们将使用nertk库通过 Jupyter 笔记本来标注 NER 数据。
开始数据准备
spaCy 开箱即用的模型在通用 NLP 方面非常成功,但有时我们必须处理需要定制训练的非常具体的领域。
训练模型需要时间和精力。在开始训练过程之前,你应该决定是否需要训练。为了确定你是否真的需要定制训练,一个很好的起点是问自己以下问题:
-
spaCy 模型在你的数据上表现足够好吗?
-
你的领域是否包含许多在 spaCy 模型中缺失的标签?
-
Hugging Face Hub 或其他地方已经有了预训练的模型/应用程序吗?(我们不想重新发明轮子。)
让我们在以下章节中详细讨论这两个问题。
spaCy 模型在你的数据上表现足够好吗?
通常情况下,如果模型表现足够好(通常,准确率在 0.75 以上),那么你可以通过另一个 spaCy 组件来定制模型输出。例如,假设我们在导航领域工作,我们有以下这样的表述:
navigate to my home
navigate to Oxford Street
让我们看看 spaCy 的 NER 模型为这些句子输出了哪些实体:
import spacy
nlp = spacy.load("en_core_web_md")
doc1 = nlp("navigate to my home")
doc1.ents
()
doc2 = nlp("navigate to Oxford Street")
doc2.ents
(Oxford Street,)
doc2.ents[0].label_
'FAC'
spacy.explain("FAC")
'Buildings, airports, highways, bridges, etc.'
在这里,家根本不被识别为实体,但我们希望它被识别为地点实体。此外,spaCy 的 NER 模型将牛津街标记为FAC,意味着建筑/公路/机场/桥梁类型的实体,这并不是我们想要的。
我们希望这个实体被识别为GPE,即一个地点。在这里,我们可以进一步训练 NER 以识别街道名称为GPE,以及识别一些地点词汇(如工作、家和我的妈妈家)为GPE。
另一个例子是报纸领域。在这个领域,人物、地点、日期、时间和组织都是需要提取的目标实体,但你还需要一个额外的实体类型——车辆(汽车、公共汽车、飞机等)。因此,你不必从头开始训练,而是可以使用 spaCy 的SpanRuler(在第第四章中解释)添加一个新的实体类型。始终首先检查你的数据,并计算 spaCy 模型的成功率。如果成功率令人满意,那么可以使用其他 spaCy 组件进行定制。
你的领域是否包含许多在 spaCy 模型中不存在的标签?
例如,在先前的报纸示例中,只有车辆这个实体标签在 spaCy 的 NER 模型标签中缺失,但其他实体类型都被识别了。由于我们可以使用SpanRuler识别车辆实体,在这种情况下,你不需要定制训练。
再次考虑医疗领域。实体包括疾病、症状、药物、剂量、化合物名称等等。这是一份专业且长的实体列表。对于医疗领域,你需要进行定制模型训练。
如果我们需要定制模型训练,我们通常遵循以下步骤:
-
收集我们的数据。
-
标注我们的数据。
-
决定更新现有模型或从头开始训练一个模型。
在数据收集步骤中,我们决定收集多少数据:1,000 个句子、5,000 个句子,或者更多。数据量取决于我们任务的复杂性和领域。通常,我们从可接受的数据量开始,第一次训练模型,看看它的表现;然后,我们可以添加更多数据并重新训练模型。
在收集完数据集后,你需要以这种方式标注你的数据,使得 spaCy 的训练代码能够识别它。在下一节中,我们将看到训练数据格式以及如何使用 Explosion 的 Prodigy 工具标注数据。
第三步是决定从头开始训练一个空白模型,还是对现有模型进行更新。在这里,一个经验法则是:如果你的实体/标签存在于现有模型中,但你没有看到非常好的性能,那么就用你自己的数据更新模型,例如在先前的车辆示例中。如果你的实体在当前的 spaCy 模型中根本不存在,那么你很可能需要进行定制训练。
我们将开始构建模型的旅程,第一步是准备我们的训练数据。让我们继续到下一节,看看如何准备和标注我们的训练数据。
标注和准备数据
训练模型的第一步始终是准备训练数据。你通常从客户日志中收集数据,然后通过将数据作为 CSV 文件或 JSON 文件导出,将它们转换为数据集。spaCy 模型训练代码与DocBin对象一起工作,因此在本章中,我们将标注数据并将其转换为DocBin对象。
收集我们的数据后,我们标注我们的数据。标注意味着标记意图、实体、POS 标签等。
这是一个标注数据的示例,取自 spaCy 的在线评论中检测时尚品牌教程(可在github.com/explosion/projects/tree/v3/tutorials/ner_fashion_brands 获取):
{
"text": "Bonobos has some long sizes.",
"tokens": [
{ "text": "Bonobos", "start": 0, "end": 7, "id": 0 },
{ "text": "has", "start": 8, "end": 11, "id": 1 },
{ "text": "some", "start": 12, "end": 16, "id": 2 },
{ "text": "long", "start": 17, "end": 21, "id": 3 },
{ "text": "sizes", "start": 22, "end": 27, "id": 4 },
{ "text": ".", "start": 27, "end": 28, "id": 5 }
],
"spans": [
{
"start": 0,
"end": 7,
"token_start": 0,
"token_end": 0,
"label": "FASHION_BRAND"
}
]
}
我们标注数据的目的是指向统计算法我们想要模型学习的内容。在这个例子中,我们希望模型学习关于实体;因此,我们提供带有标注实体的示例。
在本节中,我们还将看到 spaCy 的标注工具Prodigy,以及nertk,一个简单的开源 Python 库,用于使用 Jupyter Notebook 标注 NER 数据。Prodigy 专为快速项目的小团队量身定制。尽管它不是免费或开源的,但购买 Prodigy 有助于资助开源项目,包括 spaCy 本身的发展。
使用 Prodigy 标注数据
Prodigy 是一个由主动学习驱动的现代工具。我们将使用Prodigy live demo(demo.prodi.gy/)来展示标注工具的工作方式。
让我们开始吧:
- 我们导航到 Prodigy Live Demo,并查看 Prodigy 要标注的示例文本,如下截图所示:

图 8.1 – Prodigy 界面(从他们的 Prodigy 演示页面截取的截图)
这张截图,图 8.1,展示了我们想要标注的示例文本。截图底部的按钮展示了接受这个训练示例、拒绝它或忽略它的方法。如果文本相关且标注良好,我们就接受它,并将其加入我们的数据集。
- 接下来,我们将标注实体。为此,首先,我们从顶部栏中选择一个实体类型。这个语料库包括两种类型的实体,
PERSON和ORG。然后,我们将用光标选择我们想要标注为实体的单词,如下截图所示:

图 8.2 – 在 Prodigy 演示页面上标注 PERSON 实体
- 在我们完成文本标注后,我们点击接受按钮。一旦会话结束,你可以将标注的数据导出为 JSON 文件。
Prodigy 的功能不仅包括命名实体识别(NER),还包括文本分类、计算机视觉、提示工程、大型语言模型等。
使用 nertk 标注数据
另一个标注工具是nertk,它是一个开源的 Python 库,用于 NER 文本标注(github.com/johnsmithm/nertk)。该工具在 Jupyter Notebook 中在线工作,允许你快速轻松地与数据交互并进行标注。该项目目前处于 alpha 开发阶段,因此它仅适用于简单和快速的 NER 标注会话。
要使用nertk,你需要使用pip install nertk安装它,运行 Jupyter Notebook 服务器,并在网页浏览器中打开服务器的 URL。为了处理nertk的数据,你需要对文本进行分词并传递你想要标注的数据。让我们一步一步来做:
-
首先,我们需要对数据进行分词,因为
nertk与单词列表一起工作。我们这一章的数据集是葡萄牙语,所以我们导入en模型并仅选择tokenizer组件,因为这是我们唯一需要的:import spacy nlp = spacy.load("en_core_web_sm", enable="tokenizer") -
我们将使用 spacy 的在线评论中检测时尚品牌教程的数据集。原始文本来自
r/MaleFashionAdvice和r/FemaleFashionAdvice子版块。数据是jsonl格式,因此我们将使用srsly库来读取它。让我们打印第一个条目来看看数据的样子:import srsly from pprint import pprint training_path = "data/fashion_brands_training.jsonl" for row in srsly.read_jsonl(training_path): pprint(row) break由于数据已经用 Prodigy 进行了标注,它具有
['text', 'meta', '_input_hash', '_task_hash', 'tokens', 'spans', '_session_id', '_view_id', 'answer']键。为了了解如果没有实体我们会怎么做,让我们只使用text键,它包含 Reddit 评论的文本。 -
下一步是对数据进行分词。我们需要创建一个列表,其中每个项目也是一个列表,但它是评论单词的列表。为此,我们将遍历数据,使用我们之前加载的模型对其进行分词,并将其添加到主列表中:
nertk_input_text = [] for row in srsly.read_jsonl(training_path): comment = nlp(row["text"]) comment_words = [token.text for token in comment] nertk_input_text.append(comment_words) -
现在,我们已经准备好开始使用
nertk工具。我们需要将实体标签名称的列表和每个评论的单词列表传递给Entator类。然后,我们可以调用run()方法开始标注:from nertk import Entator annotator = Entator(labels=['None', 'FASHION_BRAND'], inputs=nertk_input_text) annotator.run()我们将标注所有的
FASHION_BRAND实体。图 8.3 .3显示了nertk界面:

图 8.3 – nertk 界面
要选择属于FASHION_BRAND实体的标记,你只需点击它们。当你准备好示例后,你可以点击下一个按钮来标注另一个。标注的标记结果存储在annotator.targets属性中。
将标注的数据转换为 DocBin 对象
要使用此注释数据来训练模型,我们需要将其转换为DocBin格式。为此,我们将为每个注释创建一个Doc对象,并添加我们已注释的实体。让我们创建执行此操作的代码:
-
首件事是创建
DocBin对象,并遍历每个注释以获取注释实体的索引:from spacy.tokens import DocBin, Span from utils import create_consecutive_token_sequences db = DocBin() for idx, (row, nerkt_tokens, nertk_entities) in enumerate( zip(srsly.read_jsonl(training_path), nertk_input_text, annotator.targets)): if idx == 5: break doc = nlp(row["text"]) indexes_entity_tokens = [index for index, x in enumerate( nertk_entities) if x == "FASHION_BRAND"] -
使用
nertk,我们注释了每个标记,但实体可以包含多个标记。为了处理这种情况,我们使用一个辅助函数,该函数获取indexes_entity_tokens列表,并为每个实体的起始和结束标记的索引创建元组(此代码仍然位于主for循环内):span_indexes = create_consecutive_token_sequences(indexes_entity_tokens) -
现在,是时候为每个实体创建
Span对象了。我们创建一个ents列表来存储这些跨度,将此列表设置为doc.ents参数,并将此Doc添加到DocBin对象中(此代码仍然位于主for循环内):ents = [] label = "FASHION_BRAND" for start,end in span_indexes: span = Span(doc, start, end+1, label) ents.append(span) doc.ents = ents db.add(doc) -
最后,我们将
DocBin文件保存到磁盘:db.to_disk("data/nertk_training.spacy")这里是将
nertk注释的实体转换为DocBin的完整代码:from spacy.tokens import DocBin, Span from utils import create_consecutive_token_sequences db = DocBin() for idx, (row, nerkt_tokens, nertk_entities) in enumerate( zip(srsly.read_jsonl(training_path), nertk_input_text, annotator.targets)): if idx == 5: break doc = nlp(row["text"]) indexes_entity_tokens = [index for index, x in enumerate( nertk_entities) if x == "FASHION_BRAND"] span_indexes = create_consecutive_token_sequences( indexes_entity_tokens) ents = [] label = "FASHION_BRAND" for start, end in span_indexes: span = Span(doc, start, end + 1, label) ents.append(span) doc.ents = ents db.add(doc) db.to_disk("data/nertk_training.spacy")
这是创建用于微调 spaCy 组件的ner的训练数据的流程。要为任何其他可训练组件创建训练数据,流程是相同的。你创建Doc对象,使用适当的格式设置注释,然后将这些 Docs 保存为DocBin对象。你可以在这里检查所有数据格式:spacy.io/api/data-formats#dict-input。
在训练数据集之后,下一步是训练ner组件。让我们在下一节中完成这项工作。
训练 NER 管道组件
我们的目标是创建一个用于识别FASHION_BRAND实体的管道。我们将通过训练EntityRecognizer管道组件来实现这一点。它使用基于转换的算法,该算法假设关于接近初始标记的实体的最关键信息。
训练组件的第一件事是创建config文件。我们将使用spacy init config CLI 命令来完成此操作:
python3 –m spacy init config cpu_config.cfg --lang "en" --pipeline "ner" --optimize "efficiency"
这将创建包含所有默认配置的cpu_config.cfg文件,并将ner组件设置为针对效率(更快推理、更小的模型和更低的内存消耗)进行训练优化。我们将使用 spaCy 教程中的preprocess.py脚本来将jsonl数据转换为DocBin对象:
python3 ./scripts/preprocess.py ./data/fashion_brands_training.jsonl ./data/fashion_brands_training.spacy
python3 ./scripts/preprocess.py ./data/fashion_brands_eval.jsonl ./data/fashion_brands_eval.spacy
现在,我们准备好使用spacy train CLI 命令来训练模型:
python3 -m spacy train cpu_config.cfg --output training_cpu/ --paths.train ./data/fashion_brands_training.spacy --paths.dev ./data/fashion_brands_eval.spacy
output参数指定了存储训练管道的目录。在图 8 .4中,我们可以看到训练过程中产生的消息。

图 8.4 – ner 组件训练过程中产生的消息
我们可以看到,在训练过程中,有一个tok2vec组件和ner组件的训练损失。这是因为ner组件默认使用spacy.TransitionBasedParser.v2模型架构。正如 spaCy 文档所说(spacy.io/api/architectures#TransitionBasedParser),模型由两个或三个子网络组成。tok2vec组件将每个标记转换为一个向量,每次批量运行一次。Lower为每个批次的(标记,特征)对生成一个向量,结合特征并应用非线性以形成状态表示。Upper是一个可选的前馈网络,它从状态表示中推导出分数。如果省略,则直接使用底层模型的输出作为动作分数。总之,tok2vec组件负责将标记映射到向量表示。
评估 NER 组件的精度
我们可以使用spacy evaluate CLI 命令来评估管道的精度。该命令期望一个可加载的 spaCy 管道和DocBin格式的评估数据。我们没有测试数据集,所以我们将使用fashion_brands_eval.spacy数据集只是为了看看命令是如何工作的。由于数据集也被用来决定何时停止模型训练,所以结果会被高估。这被称为数据泄露。然而,在这里,我们是为了学习目的而训练模型,所以我们没问题。让我们运行命令并检查结果:
python3 -m spacy evaluate training_cpu/model-best ./data/fashion_brands_eval.spacy --output training_cpu/metrics.json
命令会显示输出并将指标保存到training_cpu/metrics.json文件中。图 8.5显示了结果:

图 8.5 – ner 模型的精度
精度得分为76.88,召回率为55.88。这是一个在 CPU 上训练的模型;如果我们用 GPU 训练它并使用 transformers 会怎样呢?spaCy 使尝试这一点变得简单;我们只需要创建一个新的config.cfg文件,然后再次运行spacy train命令。让我们在下一节中这样做。
训练一个针对精度优化的 NER 组件
训练一个针对精度优化且在 GPU 上运行的组件需要您安装spacy-transformers库。之后,我们可以创建新的配置文件,如下所示:
python3 -m spacy init config gpu_config.cfg -l "en" -p "ner" --optimize "accuracy" --gpu
然后,我们可以再次训练模型,这次指向这个gpu_config.cfg文件:
python3 -m spacy train gpu_config.cfg --output training_gpu/ --paths.train ./data/fashion_brands_training.spacy --paths.dev ./data/fashion_brands_eval.spacy --gpu-id 0
我的机器有一个 GPU,所以我使用–gpu-id 1参数来设置它。当我们为了精度而训练时,通常模型的表现会更好,但我们也可能得到一个更大、更慢的模型。图 8.6显示了训练过程中产生的消息:

图 8.6 – 训练 NER 组件以实现精度时产生的消息
这种架构使用了一个 transformer Model 组件而不是tok2vec组件。我们可以看到,在每个评估点,这个管道的分数都更高,始终高于0.78。让我们再次运行评估来比较模型:
python3 -m spacy evaluate training_gpu/model-best ./data/fashion_brands_eval.spacy --output training_gpu/metrics.json --gpu-id 0
命令显示输出并将指标保存到training_gpu/metrics.json文件。图 8.7显示了结果:

图 8.7 – 为准确性训练的 ner 模型的准确性
准确率为88.79,召回率为79.83。如果我们将其与为效率训练的模型的76.88和55.88结果进行比较,这是一个显著的增加。我们可以通过将训练期间创建的目录传递给nlp.load()方法来加载模型以供使用。让我们获取句子Givenchy is looking at buying U.K. startup for $** **1 billion 的实体:
-
首先,我们加载库和管道:
import spacy from spacy import displacy nlp = spacy.load('training_gpu/model-best') -
现在,我们可以将管道应用于文本:
sentence = "Givenchy is looking at buying U.K. startup for $1 billion" doc = nlp(sentence) displacy.render(doc, style="ent", jupyter=True)结果显示在图 8.8;管道能够找到
Givenchy实体:

图 8.8 – 使用为准确性训练的 ner 管道提取的实体
该组件只能识别FASHION_BRAND实体,这是我们唯一为其训练的实体。但 spaCy 提供的en_core_web_sm模型可以识别更多实体。让我们来看看:
-
加载库和模型:
import spacy from spacy import displacy nlp = spacy.load('en_core_web_sm') -
将管道应用于文本:
sentence = "Givenchy is looking at buying U.K. startup for $1 billion" doc = nlp(sentence) displacy.render(doc, style="ent", jupyter=True)结果显示在图 8.9;管道能够找到
GPE和MONEY实体:

图 8.9 – 使用 en_core_web_sm 管道提取的实体
如果我们想要提取我们训练过的实体以及en_core_web_sm NER 组件训练过的实体呢?我们可以通过在同一个管道中结合多个 NER 组件来实现这一点。
在同一个管道中结合多个 NER 组件
当 spaCy 加载一个管道时,它会遍历管道名称,并在[components]块中查找每个组件名称。组件可以通过factory或source来构建。Factories是命名函数,接受设置并返回一个管道组件函数,而source用于引用一个训练管道的路径名称,以便从中复制组件。
要使用我们训练过的 NER 组件以及en_core_web_sm的 NER 组件,我们将创建一个新的config.cfg文件,并在管道中引用 NER 组件。使用这个config.cfg文件设置后,我们将使用spacy assemble命令来组装配置,而无需额外的训练。为了能够使用spacy assemble引用训练过的 NER 组件,我们将为管道创建一个包,并使用pip install安装它。
为训练的管道创建包
spacy 包 CLI 命令从现有的管道目录生成一个可安装的 Python 包。spaCy 创建了一个可以与pip install一起安装的构建工件。如果您想在生产环境中部署您的管道或与他人共享,这很有用。
我们将提供包含管道数据的目录路径,创建包文件夹的目录路径以及包名称。这是完整的命令:
python3 -m spacy package training_gpu/model-best ./ --name "ner_fashion_brands"
命令创建了一个名为en_ner_fashion_brands-0.0.0的文件夹。我们现在可以安装这个包并在 Python 中加载它:
-
安装包:
python3 -m pip install en_ner_fashion_brands-0.0.0/ -
导入包,加载管道,并将其应用于文本:
import en_ner_fashion_brands from spacy import displacy nlp = en_ner_fashion_brands.load() sentence = "Givenchy is looking at buying U.K. startup for $1 billion" doc = nlp(sentence) displacy.render(doc, style="ent", jupyter=True)
它的工作方式就像从其目录中加载管道一样。现在,我们可以在新的config文件中指向这个管道的 NER 组件,以创建一个使用此 NER 组件和en_core_web_sm NER 组件的管道。
创建具有不同 NER 组件的管道
spacy assemble CLI 命令从config文件组装管道,无需额外训练。就这么简单。这个config文件更简单,因为它仅用于构建管道,而不是用于训练。让我们创建combined_ner.cfg文件:
-
首先,我们定义
nlp对象。我们将指定管道语言 ISO 代码和管道组件的名称顺序。我们将在[components]部分指定如何加载它们,这样我们就可以按我们的意愿命名它们:[nlp] lang = "en" pipeline = ["ner_fashion_brands","ner"] -
由于我们想要从现有管道中复制组件,我们将设置每个组件的
source参数。参数值可以是可加载的 spaCy 管道包或路径。定义后,我们设置component参数,这是source管道中组件的名称。让我们首先定义如何加载en_core_web_sm管道的ner组件:[components] [components.ner] source = "en_core_web_sm" component = "ner" -
现在,为了加载我们训练来识别时尚品牌的
ner组件,我们还需要使用replace_listeners参数包括source管道的tok2vec监听器的副本,如下所示:[components.ner_fashion_brands] source = "en_ner_fashion_brands" component = "ner" replace_listeners = ["model.tok2vec"]
现在,我们有一个用于组装最终管道的config文件。我们将在下一步做这件事。
从配置文件组装管道
要组装管道,我们将提供我们创建的combined_ner.cfg文件和存储最终管道的输出目录:
python3 -m spacy assemble combined_ner.cfg pipelines/fashion_ner_with_base_entities
如果一切正常工作,我们现在可以加载这个管道,它将识别出两个ner组件的所有实体。让我们看看这是否是情况:
-
让我们先加载我们组装的管道:
import spacy from spacy import displacy nlp = spacy.load("pipelines/fashion_ner_with_base_entities") -
现在,让我们处理文本并使用
displacy显示实体:sentence = "Givenchy is looking at buying U.K. startup for $1 billion" doc = nlp(sentence) displacy.render(doc, style="ent", jupyter=True)我们可以在图 8.10中看到结果:

图 8.10 – 使用组装的管道识别的实体 #TODO:获取新的截图
真是 neat,对吧?我们可以组合我们需要的任意数量的ner组件。
摘要
在本章中,我们探讨了如何使用我们自己的领域和数据来训练 spaCy NER 组件。首先,我们学习了决定我们是否真的需要自定义模型训练的关键点。然后,我们了解了模型训练的一个关键部分——数据收集和标注。
我们了解了两种标注工具——Prodigy 和 nertk——并学习了如何将数据转换为训练格式,以及如何使用 spaCy 的 CLI 来训练组件。接着,我们使用 spaCy CLI 命令来训练组件并创建用于管道的 Python 包。
最后,我们学习了如何将不同的 NER 组件组合成一个单一的管道。在下一章中,我们将学习如何使用 spaCy 和 Weasel 管理和共享针对不同用例和领域的端到端工作流程。
第九章:使用 Weasel 创建端到端 spaCy 工作流程
在本章中,我们将探讨如何使用 spaCy 及其配套工具Weasel创建端到端 NLP 工作流程。最初是 spaCy 的一部分,Weasel 现在已成为一个独立的库,这意味着您也可以将其用于不是用 spaCy 创建的其他项目。
数据版本控制(DVC)提供了一套针对数据/模型版本控制和实验跟踪的解决方案,增强了协作和实验管理。通过将 Weasel 与 DVC 集成,我们确保我们的项目能够高效地进行版本控制和跟踪,提高组织和可靠性。
在本章中,我们将首先使用 Weasel 克隆和运行项目模板,遵循最佳软件工程实践以确保可重复和结构良好的工作流程。然后我们将为此模板适应不同的用例,最后我们将探讨如何使用 DVC 跟踪和管理训练好的模型,从而实现高效的协作。这种方法将使我们能够创建健壮的 NLP 管道,为生产和工作团队做好准备。
我们将涵盖以下主要主题:
-
使用 Weasel 克隆和运行项目模板
-
为不同用例修改项目模板
-
使用 DVC Studio 模型注册管理模型
技术要求
在本章中,我们将使用 spaCy、Weasel 和 DVC 库。本章代码可以在github.com/PacktPublishing/Mastering-spaCy-Second-Edition找到。
使用 Weasel 克隆和运行项目模板
spacy weasel clone命令从 Git 仓库克隆一个项目模板。默认情况下,它使用 spaCy 的项目模板仓库(github.com/explosion/projects),但您可以使用--repo选项提供您有权访问的任何其他仓库(公开或私有)。
在本章中,我们将使用Reddit 帖子情感分类(也称为文本分类)项目作为我们的项目模板。让我们继续并克隆项目:
python3 -m weasel clone tutorials/textcat_goemotions
此命令在当前目录中创建一个textcat_goemotions文件夹。project.yml文件定义了与项目相关的所有内容。这包括资产和自定义命令。project.yml文件的主要部分如下:
-
title:没错,这定义了项目的标题。 -
description:可选的项目描述。 -
vars:一个包含路径、URL 和脚本的变量字典,可以通过 CLI 进行覆盖。 -
env:一个将变量映射到环境名称的字典,允许项目脚本使用环境变量中的值,例如${env.name}。 -
directories:要在项目中创建的目录列表,如果不存在,则由 spaCy 自动生成。 -
资产:要获取的资产列表,每个资产由一个 URL 或本地路径、项目内的目标位置以及可选的校验和定义。您还可以通过指定
repo、branch和path来指定 Git 仓库,直接从 Git 下载资产。 -
命令:命令指定了如何运行项目步骤。它通常指定如何运行 Python 脚本。每个命令都使用
script、deps和outputs指定。deps定义了命令所依赖的文件,而outputs定义了命令生成的文件。这允许 spaCy 确定何时重新运行命令,如果依赖项已更改。 -
工作流程:工作流程定义了一个应该按顺序执行的命令列表。
现在我们已经克隆了模板,下一步是获取资产。spacy weasel assets命令下载project.yml中assets部分定义的所有资产。让我们下载这些资产:
cd ./textcat_goemotions
python3 -m weasel assets
这个项目有四个资产:一个包含训练类别的文件和三个数据文件,一个用于训练,一个用于开发,一个用于测试。数据是.tsv格式,因此我们需要将其转换为.spacy二进制格式。scripts/convert_corpus.py脚本执行这个操作。project.yml文件中有一个名为preprocess的命令,我们可以使用它来运行这个脚本。让我们看看这个命令是如何定义的:
commands:
- name: preprocess
help: "Convert the corpus to spaCy's format"
script:
- "python scripts/convert_corpus.py"
deps:
- "assets/train.tsv"
- "assets/dev.tsv"
- "assets/test.tsv"
- "assets/categories.txt"
outputs:
- "corpus/train.spacy"
- "corpus/dev.spacy"
- "corpus/test.spacy"
命令指定了deps键中的资产(因为我们需要它们来运行代码)以及代码生成的输出。要运行此命令,我们可以使用spacy project run和命令名称,例如:spacy project run preprocess。此命令在corpus文件夹内创建train.spacy、dev.spacy和test.spacy。
all工作流程按顺序调用preprocess、train、evaluate和package命令。这样很有用,因为我们不需要手动调用每个命令。让我们尝试运行这个工作流程:
python3 -m weasel run all
图 9 .1显示了命令输出。Weasel 验证了preprocess命令的deps没有更改,因此跳过了这一步。

图 9.1 – 运行所有工作流程后的输出
visualize命令使用Streamlit和spacy-streamlit来提供用于与模型交互的 Web 应用程序。我们可以使用weasel run visualize运行此命令。图 9 .2显示了 Web 应用程序界面。我们将在第十一章中学习如何使用 spaCy 与 Streamlit 一起使用。

图 9.2 – 与模型交互的 Streamlit 界面
所有这些,我们已经成功使用项目模板来重新创建这个文本分类流程。如果我们有另一个数据集并且需要执行这些相同的项目步骤怎么办?我们可以简单地重用模板并调整以满足我们的需求。让我们在下一节中学习如何做到这一点。
修改项目模板以适应不同的用例
要为不同的用例重用项目模板,我们首先会克隆项目,指定一个不同的dest文件夹。让我们这样做:
cd ..
python3 -m weasel clone tutorials/textcat_goemotions textcat_github_issues
这将创建一个textcat_github_issues文件夹。新的用例使用来自Prodigy的标注数据,我们应该预测 GitHub 问题标题是否关于文档。原始项目在此处可用:github.com/explosion/projects/tree/v3/tutorials/textcat_docs_issues。本节的目标是学习如何重用项目模板,因此我们将修改textcat_goemotions项目以适应这个领域。
首先,我们应该使用这个新 GitHub 问题项目的信息更新title、description和vars。GitHub 问题的资产以.jsonl格式存在,因此我们需要修改命令以将数据转换为.spacy格式。我们有三个文件:train.jsonl、dev.jsonl和eval.jsonl。让我们首先修改project.yml中的 assets 键,使其指向这些文件:
assets:
- dest: "assets/train.jsonl"
url: "https://raw.githubusercontent.com/PacktPublishing/Mastering-spaCy-Second-Edition/refs/heads/main/chapter_09/data/train.jsonl"
description: "JSONL-formatted training data exported from Prodigy, annotated with `DOCUMENTATION` (661 examples)"
- dest: "assets/dev.jsonl"
url: "https://raw.githubusercontent.com/PacktPublishing/Mastering-spaCy-Second-Edition/refs/heads/main/chapter_09/data/dev.jsonl"
description: "JSONL-formatted development data exported from Prodigy, annotated with `DOCUMENTATION` (500 examples)"
- dest: "assets/test.jsonl"
url: "https://raw.githubusercontent.com/PacktPublishing/Mastering-spaCy-Second-Edition/refs/heads/main/chapter_09/data/eval.jsonl"
description: "JSONL-formatted test data generated with GPT-3.5 (300 examples)"
现在,我们可以使用assets命令下载资产:
cd textcat_github_issues
python3 -m weasel assets
让我们看看训练数据的一个片段:
{"text":"add please","cats":{"DOCUMENTATION":0.0,"OTHER":1.0}}
{"text":"Examples, failed to load qml","cats":{"DOCUMENTATION":0.0,"OTHER":1.0}}
{"text":"DMCHMM","cats":{"DOCUMENTATION":0.0,"OTHER":1.0}}
{"text":"Moving from MySQL to Hybrid SQL","cats":{"DOCUMENTATION":0.0,"OTHER":1.0}}
这种格式与textcat_goemotions不同,因此我们需要创建一个不同的convert_corpus.py脚本。我们将使用srsly(一个捆绑了一些最好的 Python 序列化库的包)来读取.jsonl数据,并使用typer(一个用于构建 CLI 应用程序的库)来指定脚本的参数。让我们编写一个脚本来完成这个任务:
-
首先,我们导入库并定义目录的变量:
import srsly import typer import spacy from spacy.tokens import DocBin from pathlib import Path ASSETS_DIR = Path(__file__).parent.parent / "assets" CORPUS_DIR = Path(__file__).parent.parent / "corpus" -
要运行脚本,我们应该指定读取资产的目录、保存语料的目录以及我们将用于创建
Doc对象的模型的语言。使用typer,我们可以通过创建一个具有这些参数的函数来完成此操作:def main(assets_dir: Path=ASSETS_DIR, corpus_dir: Path=CORPUS_DIR, lang: str="en"): -
脚本应该转换所有的
train.jsonl、dev.json和eval.jsonl文件,因此我们需要遍历assets_dir中的每个文件,如果它是一个.jsonl文件,我们将创建一个DocBin对象:nlp = spacy.blank(lang) for jsonl_file in assets_dir.iterdir(): if not jsonl_file.parts[-1].endswith(".jsonl"): continue db = DocBin() -
对于每个
jsonl_file,我们将构建Doc对象,设置cats参数,并将其添加到DocBin对象中。最后,我们将此DocBin对象保存到磁盘:for line in srsly.read_jsonl(jsonl_file): doc = nlp.make_doc(line["text"]) doc.cats = line["cats"] db.add(doc) out_file = corpus_dir / jsonl_file.with_suffix( ".spacy").parts[-1] db.to_disk(out_file) -
最后一步是将此脚本与 Typer 绑定。我们通过
typer.run(main)来完成:if __name__ == "__main__": typer.run(main) -
现在,我们可以保存这个新的
convert_corpus.py脚本并运行以下命令:python3 -m weasel run preprocess图 9 .3显示了此命令的输出。

图 9.3 – 运行 preprocess 命令后的 Weasel 输出
Weasel 表示我们缺少assets/train.tsv依赖项。这是因为我们没有更新preprocess命令的deps和outputs以适应这个新用例。让我们现在做这件事:
- name: preprocess
help: "Convert the corpus to spaCy's format"
script:
- "python scripts/convert_corpus.py"
deps:
- "assets/train.jsonl"
- "assets/dev.jsonl"
- "assets/test.jsonl"
outputs_no_cache:
- "corpus/train.spacy"
- "corpus/dev.spacy"
- "corpus/test.spacy"
-
现在您可以保存这些更改并再次尝试运行
preprocess命令。该脚本在/corpus目录中创建.spacy文件。好的,让我们也更新evaluate命令的依赖项并运行all工作流程来训练、评估并为这个 GitHub 问题项目创建一个包:python3 -m weasel run all图 9 .4 显示了此管道的评估结果。

图 9.4 – 评估结果
我们能否使用 BERT 获得更好的结果?让我们在project.yml的vars部分中更改这一点:
vars:
name: "textcat_github_issues"
version: "0.0.1"
# Choose your GPU here
gpu_id: 0
# Change this to "bert" to use the transformer-based model
config: "bert"
我在configs/bert.cfg文件上定义的批处理配置运行训练时遇到了麻烦,所以让我们将其更改为spacy.batch_by_padded.v1:
[training.batcher]
@batchers = "spacy.batch_by_padded.v1"
discard_oversize = true
size = 2000
buffer = 256
get_length = null
现在我们可以再次运行工作流程:
python3 -m weasel run all
图 9 .5 显示了此模型的评估结果,其性能优于第一个。

图 9.5 – 使用 BERT 的结果
现在我们有了训练好的模型,我们可以使用 Weasel 将它们上传到远程存储。让我们在下一节中这样做。
上传和下载项目输出到远程存储
您可以使用spacy project push命令将项目输出存储在远程存储中,这样您就可以共享管道包、与团队协作或缓存结果以避免重复任务。spacy project pull命令从远程存储检索任何缺失的输出。远程存储在project.yml的remotes部分中指定。要配置远程存储,您可以在project.yml文件的remotes部分中列出一个或多个目的地,将字符串名称映射到存储 URL。spaCy 使用cloudpathlib与远程存储通信,允许使用cloudpathlib支持的任何协议,包括 S3、Google Cloud Storage、Azure Blob Storage 和本地文件系统。
push命令将命令中outputs部分列出的所有文件或目录上传到远程存储。上传前,输出会被归档和压缩。Weasel 使用命令字符串和依赖项的哈希以及文件内容的哈希。这意味着push永远不会覆盖远程存储中的文件。如果所有哈希匹配,内容相同,则不会发生任何操作。如果内容不同,则上传新版本的文件。
pull命令下载命令中列出的所有文件或目录,除非它们已经存在于本地。在远程存储中搜索文件时,pull将考虑输出路径、命令字符串和依赖项哈希。
我们为 GitHub 问题用例训练了两个模型。如果我们处于生产环境中,我们需要管理这些训练好的模型。最直接的应用场景是在生产环境中在这两个模型之间切换。DVC 是一个库,它帮助我们通过管道连接到版本化的数据源和代码,跟踪实验,并注册模型。Weasel 受到了 DVC 的启发,我们可以使用spacy weasel dvc命令来自动生成一个 DVC 配置文件。有了这个文件,我们可以像管理其他 DVC 项目一样管理 spaCy 项目。在下一节中,我们将使用 DVC Studio 模型注册表来编目我们的机器学习(ML)模型,并在生产环境中管理它们。
使用 DVC 模型注册表管理模型
DVC 是一个开源的命令行工具,帮助我们开发可重复的机器学习项目。Weasel 本身受到了 DVC 的启发(x.com/honnibal/status/1316792615996592133)。它包含版本化数据和模型、跟踪实验、比较数据和共享实验的工具。在本节中,我们将使用 DVC Studio 中的模型注册表,这是一个网络应用程序,它使团队能够运行和跟踪实验,并管理模型的生命周期。
在底层,DVC Studio 使用一个名为Git Tag Ops(GTO)的命令行来进行模型注册操作。要使用 DVC,了解更多的GitOps很有用。让我们在下一节中这样做。
什么是 GitOps?
GitOps是一组强调使用 Git 版本控制系统作为声明性基础设施和应用程序的真相来源的实践。它借鉴了 DevOps 和基础设施即代码实践的思想。GitOps WG(opengitops.dev/)定义了四个 GitOps 原则(v1.0.0):
-
声明式:在 GitOps 管理的系统中,所需状态必须以声明性方式定义
-
版本化和不可变:所需状态以强制不可变和版本化的方式存储,并保留完整的版本历史
-
自动拉取:软件代理自动从源拉取所需状态声明
-
持续协调:软件代理持续监控系统,并努力使其与所需状态保持一致
让我们更深入地探讨以下列表中的每个原则:
-
原则 1 – 声明式:在实践中,这意味着你的基础设施和应用程序的所有配置和设置都描述在声明性格式中,例如 YAML 或 JSON 文件。而不是编写执行一系列步骤以达到所需状态的脚本,你定义最终状态应该是什么样子。这也是
Weasel对project.yml文件的原则——它确保我们没有隐藏的默认值。配置文件充当了如何配置你的系统的蓝图。 -
原则 2 – 版本化和不可变:这一原则强调所有配置文件(声明性描述)应存储在 Git 仓库中。Git 本身支持版本控制,允许您跟踪随时间的变化。不可变性意味着一旦定义并提交了特定状态,就不应对其进行更改。如果需要更改,应创建一个新的版本。这种做法确保您有配置所做每个更改的完整历史记录,使得理解代码和基础设施的演变以及必要时回滚到先前状态变得更容易。例如,如果新的配置破坏了您的应用程序,您可以使用 Git 的版本历史快速回滚到最后已知的好配置。
-
原则 3 – 自动拉取:在 GitOps 设置中,当检测到新的提交时,GitOps 代理应自动拉取更新的配置文件并将更改应用到基础设施或应用程序。这种自动化确保了 Git 仓库中进行的任何更新都能及时反映在实际运行环境中,无需人工干预。
-
原则 4 – 持续协调:GitOps 代理应持续比较您基础设施和应用程序的实际状态与 Git 仓库中定义的期望状态。如果两者之间存在差异,代理将尝试通过进行必要的调整来使实际状态与期望状态一致。这种持续协调确保您的系统始终与 Git 中的配置保持一致。这一原则确保了一致性和可靠性,防止了 Git 中声明的内容与您环境中实际运行的内容之间的偏差。
让我们继续讨论 DVC,接下来将解决常见的数据科学和机器学习挑战。
DVC 如何解决常见的数据科学和机器学习挑战
数据科学和机器学习项目经常面临可以使用 DVC 和 GitOps 原则有效解决的问题。以下是一些常见挑战以及这些工具和原则如何帮助解决它们:
-
困难的数据共享和协作:在团队成员之间共享数据集、模型和实验可能很复杂,尤其是在处理大文件或多个版本时,会导致重复工作和错误。使用 DVC,我们可以使用远程存储来跟踪数据集和模型,就像我们使用 Git 跟踪代码一样。这允许团队成员拉取和推送资产,以确保每个人都在使用相同的状态。
-
管道不可靠或不可重复:我们通常在 Jupyter 笔记本中开始我们的项目实验。这对于数据分析和原型设计是完全可行的,但当项目增长(我们希望如此)时,结构和自动化变得有益。结构化管道的一些要求包括将代码单元作为
.py模块,并在专用文件中管理配置(以跟踪参数、文件路径等)。DVC(和 Weasel)为我们完美地创建了一个结构,以便我们可以创建这些可重用的管道。 -
模型指标跟踪:保留模型性能指标的历史记录对于理解模型随时间演化和有效性至关重要。DVC 允许存储和版本控制性能指标,与模型一起,便于比较不同版本和分析改进。通过 GitOps,这些指标可以集成到 CI/CD 管道中,确保在部署之前,新模型版本始终与旧版本进行验证。
通过使用 DVC 和 GitOps 原则解决这些挑战,数据科学和机器学习团队可以实现更可靠、可重复和可扩展的工作流程。实施 GitOps 原则的好处包括以下内容:
-
提高开发人员和运营效率
-
提高开发者体验
-
提高稳定性
-
一致性和标准化
DVC 与 GitOps 实践无缝集成,因此通过使用此工具,我们可以获得所有这些好处。既然我们已经了解了 GitOps 是什么以及它所解决的挑战,那么我们就继续将我们的 Weasel 项目转换为 DVC,并将我们的模型添加到模型注册表中,以便我们可以共享它们。
从 Weasel 到 DVC
第一步是安装 DVC。DVC 是一个 Python 库,因此我们可以使用pip或conda进行安装:
python3 -m pip install dvc dvc_gdrive
现在,在项目目录内,我们可以运行dvc init来初始化一个 DVC 项目。在这个目录中必须初始化一个 Git 仓库。让我们初始化项目:
python3 -m dvc init
git commit -m "First commit"
dvc init命令创建三个文件:.dvc/config,.dvc/.gitignore,和.dvcignore。DVC 提供了对外部存储位置的访问,使我们能够管理和共享我们的数据和机器学习模型。它支持云提供商,如 Amazon S3、Microsoft Azure Blob Storage 和 Google Cloud Storage,以及自托管/本地选项,如 SSH 和 HDFS。在本章中,我们将使用 Google Drive 作为远程存储。为此,我们需要 Google Drive 文件夹的文件夹 ID。dvc remote add命令将远程配置添加到.dvc/config文件。让我们来做这件事:
python3 -m dvc remote add --default myremote gdrive:///path/to/folder
python3 -m dvc remote modify myremote gdrive_acknowledge_abuse true
gdrive_acknowledge_abuse标志允许下载被标记为可能具有滥用行为的文件,例如包含恶意软件或个人信息,但只有当此参数启用时,文件的所有者才能下载。现在,当我们运行dvc pull或dvc push以使用 Google Drive 作为远程存储来存储或检索模型工件时,浏览器将打开一个新窗口进行身份验证。
一旦配置了 DVC,spacy project dvc 命令会自动从你的 project.yml 文件中生成一个 dvc.yaml 文件。这让你可以使用在 project.yml 中定义的工作流程来管理你的 spaCy 项目,因此在本章中,我们只是将要使用模型注册功能,让我们继续看看下一节如何操作。
创建一个将模型添加到模型注册表的命令
要将模型添加到模型注册表,我们需要安装 DVCLive Python 包。DVCLive 是一个用于记录机器学习指标和其他元数据的 Python 库:
-
让我们安装它:
python3 -m pip install dvclive -
现在,让我们回顾一下我们的
project.ymlWeasel 文件。我们在那里定义了all工作流程,并包含以下命令:all: - preprocess - train - evaluate - package -
我们将要创建三个新的命令,一个用于使用 DVC 跟踪模型,一个用于将模型推送到远程存储,还有一个用于将模型添加到模型注册表中。
-
将模型推送到远程存储,首先我们需要使用 DVC 来跟踪它。我们通过
dvc add命令来完成这个操作。让我们在project.yml文件中创建这个命令:- name: track_model help: Track model artifact with DVC script: - "dvc add packages/${vars.language}_${vars.name}-${vars.version}/dist/${vars.language}_${vars.name}-${vars.version}.tar.gz" deps: - "packages/${vars.language}_${vars.name}-${vars.version}/dist/${vars.language}_${vars.name}-${vars.version}.tar.gz" -
现在,让我们使用 Weasel 运行这个命令:
python3 -m weasel run track_model
注意
你应该从 Weasel 创建的根 .gitignore 文件中删除 packages 文件夹,以便将模型包添加到 DVC(DVC 将在 model 文件夹内创建一个新的 .gitignore 文件)。
dvc add 命令为该工件创建一个 .dvc 文件,然后使用 Git 来跟踪这个工件。
-
现在,我们可以创建一个将此模型添加到 Google Drive 的命令:
- name: push_remote help: Push model to DVC remote storage script: - "dvc push packages/${vars.language}_${vars.name}-${vars.version}/dist/${vars.language}_${vars.name}-${vars.version}.tar.gz" deps: - "packages/${vars.language}_${vars.name}-${vars.version}/dist/${vars.language}_${vars.name}-${vars.version}.tar.gz"我们也可以使用 Weasel 运行它:
python3 -m weasel run push_remote
这个命令会打开浏览器,以便我们可以使用 Google Drive 进行身份验证。现在,我们终于准备好创建一个将模型添加到 DVC Studio 模型注册表的命令。为此,我们将创建一个新的 Python 脚本。让我们开始吧:
-
首先,我们导入库:
import typer from dvclive import Live -
现在,我们创建一个带有 DVCLive 日志记录器上下文管理器块的
main()函数,并使用log_artifact()方法来添加模型:def main(model: str, description: str, labels: str): with Live() as live: live.log_artifact( str(model), type="model", name="model" ) -
最后,我们将
typer.run(main)添加来处理命令行参数:if __name__ == "__main__": typer.run(main) -
我们可以将这个脚本保存为
scripts/add_model_registry.py。现在,我们可以创建一个命令来运行这个脚本:- name: add_to_model_registry help: Add model to DVC Studio Model Registry script: - "python scripts/add_to_model_registry.py packages/${vars.language}_${vars.name}-${vars.version}/dist/${vars.language}_${vars.name}-${vars.version}.tar.gz ${vars.name}" deps: - "scripts/add_to_model_registry.py" - "packages/${vars.language}_${vars.name}-${vars.version}/dist/${vars.language}_${vars.name}-${vars.version}.tar.gz" -
我们现在应该提交创建的
dvc.yaml文件:git add dvc.yaml git commit -m "feat: adding model using dvclive" git push现在,你应该前往
studio.iterative.ai/,使用 GitHub/GitLab/Bitbucket 连接,并导入你的 Git 仓库。完成之后,你可以点击 模型 菜单,在那里可以看到模型。图 9.6 显示了这个界面。

图 9.6 – DVC Studio 模型
- 下一步是注册模型。点击模型名称,可以看到在 图 9.7 中显示的选项。

图 9.7 – DVC Studio 模型选项
- 现在,点击蓝色的 注册第一个版本 按钮,选择我们模型开发历史中的一个特定提交,并将其附加到一个版本上,以便更容易跟踪它。图 9.8 显示了注册模型弹出窗口。

图 9.8 – DVC Studio 注册模型选项
模型现在已注册,我们可以下载它或将它分配到生命周期阶段。图 9.9显示了这些选项。

图 9.9 – 使用 DVC Studio 访问模型的方法
当模型被分配到某个阶段时,它可以自动触发 CI/CD 工作流程中的操作,例如将模型部署到新的环境。你可以在 DVC 文档中了解更多信息:dvc.org/doc/start/model-registry/model-cicd。
摘要
在本章中,你学习了如何使用 Weasel 管理 spaCy 项目。首先,你从 spaCy 的仓库克隆了一个项目模板并在你的机器上运行它。然后,你使用相同的项目结构对一个数据集进行模型训练。之后,你看到了 GitOps 如何解决一些数据科学和机器学习挑战,并使用 DVC 注册了我们训练的模型以与队友分享,或者添加部署设置。本章的目标是教你如何在生产环境中管理 NLP 项目。
在下一章中,我们将探讨如何训练用于指代消解的模型。这包括理解什么是指代消解,为什么它在 NLP 中很重要,以及如何使用 spaCy 来实现它。
第十章:使用 spaCy 训练实体链接器模型
实体链接是将文本提及映射到外部知识库中唯一标识符的 NLP 任务。本章将探讨如何使用 spaCy 训练实体链接模型,以及如何创建用于 NLP 训练的高质量数据集的最佳实践。我们还将学习如何使用自定义语料库读取器来训练 spaCy 组件。有了这些知识,你可以自定义任何 spaCy 组件,以便在训练模型时使用。
本章将涵盖以下内容:
-
理解实体链接在 NLP 中的概念和重要性
-
创建用于 NLP 训练的高质量数据集的最佳实践
-
使用 spaCy 训练实体链接器组件
-
利用自定义语料库读取器来训练 spaCy 组件
到本章结束时,你将能够开发与外部知识库集成的 NLP 模型,从而提高在现实世界场景中的准确性和适用性。
技术要求
本章的所有数据和代码都可以在github.com/PacktPublishing/Mastering-spaCy-Second-Edition找到。
理解实体链接任务
实体链接是将提到的实体与其在各个知识库中的对应条目进行关联的任务。例如,华盛顿实体可以指代人物乔治·华盛顿或美国的一个州。通过实体链接或实体解析,我们的目标是把实体映射到正确的现实世界表示。正如 spaCy 的文档所说,spaCy 的实体链接器架构需要三个主要组件:
-
一个用于存储唯一标识符、同义词和先验概率的知识库(
KB) -
一个用于生成可能标识符的候选生成步骤
-
一个用于从候选列表中选择最可能 ID 的机器学习模型
在 KB 中,每个文本提及(别名)都表示为一个可能或可能未链接到实体的候选对象。每个候选(别名,实体)对都分配一个先验概率。
在 spaCy 的实体链接器架构中,首先,我们使用共享的语言词汇表和固定大小实体向量的长度初始化一个 KB。然后,我们需要设置模型。spacy.EntityLinker.v2类使用spacy.HashEmbedCNN.v2模型作为默认的模型架构,这是 spaCy 的标准tok2vec层。
spacy.HashEmbedCNN.v2架构由一个多哈希嵌入嵌入层和一个最大输出窗口编码器编码层定义。
MultiHashEmbed 嵌入层使用子词特征,并构建一个嵌入层,该层使用哈希嵌入分别嵌入词汇属性("NORM"、"PREFIX"、"SUFFIX" 等)。哈希嵌入旨在解决嵌入大小的问题。在论文《用于高效词表示的哈希嵌入》(arxiv.org/pdf/1709.03933 )中,Svenstrup、Hansen 和 Winther 指出,即使是中等大小的嵌入尺寸(300 维度),如果词汇量很大(如 Google Word2Vec 中的 300 万个单词和短语),总参数数接近 10 亿。使用哈希嵌入是内存高效的,因为它是一个紧凑的数据结构,所需的存储空间比词袋表示少。
MaxoutWindowEncoder 编码层使用卷积来编码上下文。该层接受的两个主要参数是 window_size 和 depth。window_size 参数设置围绕每个标记连接的单词数量,以构建卷积。depth 参数设置卷积层的数量。
spacy.HashEmbedCNN.v2 和所有其他 spaCy 层都是使用 Thinc API 定义的。让我们看看定义这些层的代码(仅用于学习目的,因为我们只需要在 config.cfg 文件中指向这个定义):
@registry.architectures("spacy.HashEmbedCNN.v2")
def build_hash_embed_cnn_tok2vec(
*,
width: int,
depth: int,
embed_size: int,
window_size: int,
maxout_pieces: int,
subword_features: bool,
pretrained_vectors: Optional[bool],
) -> Model[List[Doc], List[Floats2d]]:
if subword_features:
attrs = ["NORM", "PREFIX", "SUFFIX", "SHAPE"]
row_sizes = [embed_size, embed_size // 2,
embed_size // 2, embed_size // 2]
else:
attrs = ["NORM"]
row_sizes = [embed_size]
return build_Tok2Vec_model(
embed=MultiHashEmbed(
width=width,
rows=row_sizes,
attrs=attrs,
include_static_vectors=bool(pretrained_vectors),
),
encode=MaxoutWindowEncoder(
width=width,
depth=depth,
window_size=window_size,
maxout_pieces=maxout_pieces,
),
)
我们可以看到,该层正在使用 MultiHashEmbed 来嵌入文本,并使用 MaxoutWindowEncoder 层来编码嵌入,为模型提供最终的线性输出。接下来,让我们看看 EntityLinker.v2 架构本身的代码:
@registry.architectures("spacy.EntityLinker.v2")
def build_nel_encoder(
tok2vec: Model, nO: Optional[int] = None
) -> Model[List[Doc], Floats2d]:
with Model.define_operators({">>": chain, "&": tuplify}):
token_width = tok2vec.maybe_get_dim("nO")
output_layer = Linear(nO=nO, nI=token_width)
model = (
((tok2vec >> list2ragged()) & build_span_maker())
>> extract_spans()
>> reduce_mean()
>> residual(Maxout(nO=token_width, nI=token_width,
nP=2, dropout=0.0)) # type: ignore
>> output_layer
)
model.set_ref("output_layer", output_layer)
model.set_ref("tok2vec", tok2vec)
# flag to show this isn't legacy
model.attrs["include_span_maker"] = True
return model
build_nel_encoder() 方法的参数是 tok2vec 模型和由 KB 中每个实体的编码向量的长度确定的输出维度 nO。当我们不设置 nO 时,它在调用 initialize 时会自动设置。我们将在 config.cfg 文件中定义 tok2vec 模型,如下所示:
[components.entity_linker.model]
@architectures = "spacy.EntityLinker.v2"
nO = null
[components.entity_linker.model.tok2vec]
@architectures = "spacy.HashEmbedCNN.v1"
pretrained_vectors = null
width = 96
depth = 2
embed_size = 2000
window_size = 1
maxout_pieces = 3
subword_features = true
现在您已经了解了 spaCy 和 Thinc 在底层如何交互以创建 EntityLinker 模型架构。如果您需要更改参数或尝试不同的模型,您知道去哪里更改这些设置。
在商业环境中,我们通常从没有可用的数据集开始,迫使我们创建自己的数据集。拥有高质量的数据集是训练性能良好的模型的关键组成部分,因此学习创建良好数据集的基本知识非常重要。让我们在下一节中讨论这个问题。
创建良好 NLP 语料库的最佳实践
由于微调技术的存在,幸运的是,我们今天不需要大量的数据来训练模型。然而,好的数据集仍然非常重要,因为它们对于保证和评估我们的 NLP 系统的性能至关重要。例如,如果未经仔细策划,语言中深深嵌入的偏见和文化细微差别可能会无意中塑造 AI 的输出。在文章《如何在不经意间制造出有种族歧视倾向的 AI》中(blog.conceptnet.io/posts/2017/how-to-make-a-racist-ai-without-really-trying/),研究人员罗宾·斯皮尔提供了一个关于情感分析的精彩教程,并展示了我们如何通过简单地重复使用在偏见数据上训练的嵌入来产生有种族歧视倾向的 AI 解决方案。
通常,NLP 任务的标注过程主要包括以下步骤:
-
定义问题或任务。我们试图解决什么问题?这个问题将指导我们如何选择用于标注的样本,如何一致性地标注数据,等等。
-
确定并准备一组代表性文本,作为语料库的起始材料。
-
定义一个标注方案,并对语料库的一部分进行标注,以确定数据解决任务的可行性。
-
标注语料库的大部分内容。
总是定义标注说明是一个好习惯,以确保数据集的标注一致性。这很重要,因为我们需要这种一致性,以便机器学习算法能够有效地泛化。安德鲁·吴在课程《生产中的机器学习》中讲述了标注过程中一致性的重要性(www.coursera.org/learn/introduction-to-machine-learning-in-production),其中,一个计算机视觉模型没有达到预期的性能,经过一些错误分析后,他们发现是由于标注过程中的不一致性。任务是寻找钢板图像中的缺陷,一些标注将整个有缺陷的区域标注为缺陷,而另一些则单独标注缺陷。
为了构建高质量的 NLP 数据集,我们可以从数据质量维度借用一些原则。一个好的标注数据集的第一个特征是一致性。数据在格式、标注和分类方面应该具有一致的结构和统一性。
一个好的数据集也应该代表目标应用领域。如果我们正在构建一个从公司业务文档中提取信息的管道,那么使用法律文本来训练嵌入模型可能不是一个好主意。
一个好的数据集的第三个也是最后一个特征是它有良好的文档记录。我们应该明确和透明地说明我们如何收集和选择数据,标签说明是什么,以及谁标注了数据。这种文档记录非常重要,因为它允许透明度、可重复性和偏差管理。
在接下来的章节中,我们创建了一个小数据集,我们创建了一个包含来自新闻网站提及我们想要消歧的实体(Taylor Swift、Taylor Lautner 和 Taylor Fritz)的句子的数据集。标签任务是标记新闻句子中的Taylor提及到每个提及的人。不幸的是,在现实生活中,我们通常不会遇到这样的简单场景,这些是我们遵循一致性、代表性和良好文档原则来构建数据集变得更为重要的时刻。
现在我们知道了如何创建语料库,让我们回到 spaCy,学习如何训练我们的实体链接器组件。
使用 spaCy 训练实体链接器组件
训练模型的第一个步骤是创建知识库。我们想要创建一个管道,用于检测对Taylor的引用是指 Taylor Swift(歌手)、Taylor Lautner(演员)还是 Taylor Fritz(网球运动员)。他们每个人在 Wikidata 上都有自己的页面和标识符,因此我们将使用 Wikidata 作为我们的知识库来源。要创建知识库,我们需要创建一个InMemoryLookupKB类的实例,传递共享的Vocab对象和我们将要用来编码实体的嵌入向量的大小。让我们创建我们的知识库:
-
首先,我们将选择语言对象(
en_core_web_md)并添加一个SpanRuler组件来匹配所有的taylor提及(这将用于创建语料库):import spacy nlp = spacy.load("en_core_web_md") ruler = nlp.add_pipe("span_ruler", after="ner") patterns = [{"label": "PERSON", "pattern": [{"LOWER": "taylor"}]}] ruler.add_patterns(patterns) -
我们将把知识库和模型保存到磁盘上,所以让我们定义这些文件:
kb_loc = "chapter_10/nel_taylor/my_kb" nlp_dir = "chapter_10/nel_taylor/my_nlp" -
最后,我们可以开始创建知识库。首先,我们实例化 kb 对象,传递
Vocab和向量的大小。en_core_web_md模型有 300 维的向量,所以我们为此设置实体向量的大小:import os from spacy.kb import InMemoryLookupKB kb = InMemoryLookupKB(vocab=nlp.vocab, entity_vector_length=300)
现在我们有了知识库,我们可以使用add_entity()方法添加实体,使用add_alias()方法添加提及(在我们的情况下,提及将是Taylor)以及每个实体的先验概率。让我们创建完成所有这些的代码:
-
首先,我们创建两个字典,一个包含我们每个实体的 Wikidata ID,另一个包含它们的描述:
entities = {'Q26876': 'Taylor Swift', 'Q23359': 'Taylor Lautner', 'Q17660516': 'Taylor Fritz'} descriptions = {'Q26876': 'American singer-songwriter (born 1989)', 'Q23359': 'American actor', 'Q17660516': 'American tennis player'} -
现在,是时候将实体添加到知识库中。每个 Wikidata QID 将有一个实体描述的向量表示。要添加实体,我们使用
add_entity()方法,目前我们可以为freq参数设置一个任意值(我们将告诉 spaCy 在训练模型的config.cfg文件中忽略这个频率):for qid, desc in descriptions.items(): desc_doc = nlp(desc) desc_vector = desc_doc.vector kb.add_entity(entity=qid, entity_vector=desc_vector, freq=111) -
现在,我们可以将提及(
alias)添加到知识库中。如果文本中出现Taylor Swift实体,我们毫无疑问它指的是歌手泰勒·斯威夫特。同样,如果文本中出现Taylor Lautner实体,我们毫无疑问它指的是演员泰勒·洛特纳。我们将通过将这些实体的概率设置为1来添加此信息到知识库中:for qid, name in entities.items(): kb.add_alias(alias=name, entities=[qid], probabilities=[1]) -
当实体的名字和姓氏都存在时,我们毫无疑问知道是谁,但如果文本只提到
Taylor呢?我们将为所有三个实体设置初始概率相等(每个实体 30%,因为概率之和不能超过 100%):qids = entities.keys() kb.add_alias(alias="Taylor", entities=qids, probabilities=[0.3, 0.3, 0.3]) -
我们的 KB 还没有完全设置好。让我们打印实体和别名来检查是否一切正常:
print(f"Entities in the KB: {kb.get_entity_strings()}") >>> Entities in the KB: ['Q23359', 'Q17660516', 'Q26876'] print(f"Aliases in the KB: {kb.get_alias_strings()}") >>> Aliases in the KB: ['Taylor Lautner', 'Taylor', 'Taylor Swift', 'Taylor Fritz'] -
现在,是时候将知识库和
nlp模型保存到磁盘上了,这样我们以后就可以使用它们:kb.to_disk(kb_loc) if not os.path.exists(nlp_dir): os.mkdir(nlp_dir) nlp.to_disk(nlp_dir)
在InMemoryLookupKB配置完成后,我们现在可以为 spaCy 准备训练数据。我们将处理的 CSV 文件包含名为text(句子)、person和label(实体的名称)、ent_start和ent_end(标记在句子中的位置)以及 Wikidata 的QID这些列。数据包含 49 个句子,我们将使用 80%进行训练(我们将将其分为train和dev集)和 20%进行测试。我们将分两步准备数据:首先,创建Doc对象,然后将其添加到DocBin的train和dev对象中。
为了创建Doc对象,我们将每个句子包装在一个Doc对象中,并使用 CSV 文件中的数据创建Span对象。这个Span对象有一个kb_id参数,我们将用它来设置实体的 Wikidata QID。让我们继续这样做:
-
首先,我们加载 CSV 文件,并获取 80%的行用于训练,其余的用于测试:
import pandas as pd df_labeled = pd.read_csv("https://raw.githubusercontent.com/PacktPublishing/Mastering-spaCy-Second-Edition/main/chapter_10/taylor_labeled_dataset.csv") df_train = df_labeled.sample(frac=0.8, random_state=123) df_test = df_labeled.drop(df_train.index) -
现在,我们实例化我们之前用于创建知识库的管道,将句子包装在它里面以创建
Doc对象,并为实体创建Span对象。我们将使用两个列表,一个用于存储docs,另一个用于存储QIDs:import spacy from spacy.tokens import Span from collections import Counter nlp_dir = "chapter_10/nel_taylor/my_nlp" nlp = spacy.load(nlp_dir) docs = [] QIDs = [] for _,row in df_train.iterrows(): sentence = row["text"] QID = row["QID"] span_start = row["ent_start"] span_end = row["ent_end"] doc = nlp(sentence) QIDs.append(QID) label_ent = "PERSON" ent_span = Span(doc, span_start, span_end, label_ent, kb_id=QID) doc.ents = [ent_span] docs.append(doc)
我们将使用QIDs列表将句子分割成train和dev的DocBin对象。为此,我们将获取每个 QID 的索引,使用前八个句子进行train,其余的留给dev。让我们在代码中这样做:
-
首先,我们导入对象并创建我们的空
DocBin对象:from spacy.tokens import DocBin import math train_docs = DocBin() dev_docs = DocBin() -
现在,我们遍历每个实体 QID,获取它们句子的索引,并将它们添加到每个
DocBin对象中:entities = {'Q26876': 'Taylor Swift', 'Q23359': 'Taylor Lautner', 'Q17660516': 'Taylor Fritz'} for QID in entities.keys(): indexes_sentences_qid = [i for i, j in enumerate(QIDs) if j == QID] for index in indexes_sentences_qid[0:8]: train_docs.add(docs[index]) for index in indexes_sentences_qid[8:]: dev_docs.add(docs[index]) -
现在我们可以将
DocBin文件保存到磁盘上:train_corpus = "chapter_10/nel_taylor/train.spacy" dev_corpus = "chapter_10/nel_taylor/dev.spacy" train_docs.to_disk(train_corpus) dev_docs.to_disk(dev_corpus)
当准备好train和dev集后,我们可以继续训练模型。我们将使用 spaCy 的 Nel Emerson 教程中使用的相同配置文件(github.com/explosion/projects/tree/v3/tutorials/nel_emerson)。您可以在 GitHub 仓库中获取此文件:github.com/PacktPublishing/Mastering-spaCy-Second-Edition/tree/main/chapter_10。
如果您需要刷新对 spaCy 训练过程的了解,可以参考第六章。为了训练EntityLinker组件,我们需要做一些新的事情,即使用一个包含用于训练的额外代码的自定义文件。我们将这样做,因为我们需要以EntityLinker需要的方式创建Example对象。让我们在下一节中更多关于这一点进行讨论。
使用自定义语料库读取器进行训练
spaCy 的Corpus类管理用于训练期间数据加载的标注语料库。默认的语料库读取器(spacy.Corpus.v1)使用Language类的make_doc()方法创建Example对象。此方法仅对文本进行分词。为了训练EntityLinker组件,它需要在文档中具有可用的实体。这就是为什么我们将创建自己的语料库读取器,并将其保存为名为custom_functions.py的文件。读取器应接收DocBin文件的路径和nlp对象作为参数。在方法内部,我们将遍历每个Doc以创建示例。让我们继续创建这个方法:
-
首先,我们禁用管道中的
EntityLinker组件,然后从DocBin文件中获取所有文档:def read_files(file: Path, nlp: "Language") -> Iterable[Example]: with nlp.select_pipes(disable="entity_linker"): doc_bin = DocBin().from_disk(file) docs = doc_bin.get_docs(nlp.vocab) -
现在,我们将为每个文档创建
Example对象。Example的第一个参数是经过nlp对象处理的文本,第二个参数是带有标注实体的doc:# ... for doc in docs: yield Example(nlp(doc.text), doc) -
为了在
config.cfg文件中引用此读取器,我们需要使用@spacy.registry装饰器进行注册。让我们导入我们将需要的库并注册读取器:from functools import partial from pathlib import Path from typing import Iterable, Callable import spacy from spacy.training import Example from spacy.tokens import DocBin @spacy.registry.readers("MyCorpus.v1") def create_docbin_reader(file: Path) -> Callable[["Language"], Iterable[Example]]: return partial(read_files, file) -
我们使用
partial函数,这样当 spaCy 代码在内部使用读取器时,我们只需要传递nlp对象。现在,我们可以在config.cfg文件中像这样引用这个MyCorpus.v1读取器:#config.cfg snippet [corpora] [corpora.train] @readers = "MyCorpus.v1" file = ${paths.train} [corpora.dev] @readers = "MyCorpus.v1" file = ${paths.dev} -
这里是我们的
custom_functions.py文件的完整源代码:from functools import partial from pathlib import Path from typing import Iterable, Callable import spacy from spacy.training import Example from spacy.tokens import DocBin @spacy.registry.readers("MyCorpus.v1") def create_docbin_reader(file: Path) -> Callable[["Language"], Iterable[Example]]: return partial(read_files, file) def read_files(file: Path, nlp: "Language") -> Iterable[Example]: # we run the full pipeline and not just nlp.make_doc to # ensure we have entities and sentences # which are needed during training of the entity linker with nlp.select_pipes(disable="entity_linker"): doc_bin = DocBin().from_disk(file) docs = doc_bin.get_docs(nlp.vocab) for doc in docs: yield Example(nlp(doc.text), doc) -
为了在调用
trainCLI 命令时使读取器可用,我们需要提供包含我们创建的 Python 代码的源代码。我们使用code参数来完成此操作。首先,我们获取config.cfg文件:!curl https://raw.githubusercontent.com/PacktPublishing/Mastering-spaCy-Second-Edition/main/chapter_10/config.cfg -o config.cfg -
现在,我们可以运行完整的命令来训练我们的
EntityLinker管道:python -m spacy train ./config.cfg --output entity_linking_taylor --paths.train ./nel_taylor/train.spacy --paths.dev ./nel_taylor/dev.spacy --paths.kb nel_taylor/my_kb --paths.base_nlp ./nel_taylor/my_nlp --code custom_functions.py
现在我们有了训练好的模型,我们需要对其进行测试。让我们在下一节中这样做。
测试实体链接模型
为了测试模型,我们将使用 train 命令从我们保存它的路径加载它,并在我们想要消歧义实体的文档上调用 nlp 对象。实体链接器模型将 kb_id 添加到实体中,我们可以用它来查看模型预测了哪个 Taylors。让我们使用一些 df_test 句子来评估模型:
-
首先,我们加载模型:
nlp = spacy.load("entity_linking_taylor/model-best") -
现在,我们处理句子。
doc.ents实体具有包含实体哈希值的kb_id属性,以及包含纯文本 QID 的kb_id_属性。让我们处理文本:text = 'Taylor struggled with chilly temperatures in Edinburgh, pausing the show to warm up her hands and to assist a distressed fan.' doc = nlp(text) -
现在,我们可以使用
displacy显示实体:from spacy import displacy displacy.serve(doc, style="ent") -
图 10.1 显示了结果。
Q26876是泰勒·斯威夫特的 Wikidata ID,所以这次模型也是正确的。

图 10.1 – 模型正确地消歧义了泰勒·斯威夫特的实体
让我们用另一个句子测试模型:
text = 'Now, Taylor has revealed that he had to re-audition for the part because the producers wanted to go in a different direction.'
doc = nlp(text)
- 图 10.2 显示了结果。
Q23359是泰勒·洛特纳的 Wikidata ID,所以模型在这点上也是正确的。

图 10.2 – 模型正确地消歧义了泰勒·洛特纳的实体
我们对模型采取轻松的态度,只评估这些简单的句子,因为这里的目的是仅展示如何从模型中获取结果。训练这个组件是一次相当漫长的旅程;恭喜!
摘要
在本章中,我们学习了如何使用 spaCy 训练 EntityLinker 组件。我们看到了一些实现细节,以了解更多关于 HashEmbedCNN.v2 层和 EntityLinker.v2 架构的信息。
我们还讨论了用于 NLP 训练的高质量数据集的一些特征,强调了一致性、代表性和详尽文档的重要性。最后,我们看到了如何创建用于训练实体链接模型的定制语料库读取器。有了这些知识,你可以定制任何其他 spaCy 组件。
在下一章和最后一章中,你将学习如何将 spaCy 与其他酷炫的开源库结合使用,以创建出色的 NLP 应用程序。那里见!
第十一章:将 spaCy 与第三方库集成
在本章中,我们将探讨如何将 spaCy 与第三方库集成,重点关注构建用于 NLP 任务的 Web 应用和 API。我们将从 Streamlit 开始,这是一个简化 Web 应用创建的 Python 框架,无需广泛的前端知识。我们将演示如何使用 Streamlit 和 spacy-streamlit 创建一个简单的 命名实体识别(NER)应用。在此之后,我们将深入研究 FastAPI,这是一个用于构建 API 的现代框架,以其速度和 Python 类型提示的使用而闻名。我们将学习如何创建一个使用 spaCy 模型从文本中提取实体的 API,展示了构建 NLP 驱动的服务的简便性。
在本章中,我们将涵盖以下主要主题:
-
使用 Streamlit 构建 spaCy 驱动的应用
-
使用 FastAPI 为 NLP 模型构建 API
技术要求
本章的所有数据和代码都可以在 github.com/PacktPublishing/Mastering-spaCy-Second-Edition 找到。
使用 Streamlit 构建 spaCy 驱动的应用
作为数据科学家和 NLP 工程师,我们在日常工作中主要使用的编程语言是 Python。如果你没有前端开发背景,曾经尝试构建 Web 应用或处理过 CSS,你就知道要在浏览器中开发应用程序是多么困难和令人沮丧。Streamlit 是一个 Python 框架,旨在帮助我们以简单快捷的方式使用纯 Python 创建 Web 应用。它建立在 Tornado Python Web 服务器框架之上(www.tornadoweb.org/en/stable/index.html),并在前端使用 React。幸运的是,我们不需要了解这些技术的使用方法来创建我们的 Web 应用,因为有了 Streamlit,我们只需声明一些 Python 变量就可以在页面上创建小部件。我们还可以通过使用 社区云 功能(streamlit.io/cloud)来平滑地部署、管理和共享 Streamlit Web 应用。部署只需一键即可完成,并且是免费的。
在本节中,我们将首先学习 Streamlit 的基础知识,然后学习如何使用 spacy-streamlit 包将 spaCy 可视化作为构建 Web 应用的基石。
使用 spacy-streamlit 构建 NLP 应用
要开始使用 Streamlit,第一步是使用 pip install streamlit 安装库。我们使用 Python 脚本创建 Web 应用。streamlit run app.py 命令在机器上运行本地服务器。为了检查安装是否正常,让我们运行 streamlit hello 命令。图 11 .1 展示了浏览器中的这个演示页面。

图 11.1 – Streamlit 欢迎页面
正如我们在引言部分所讨论的,使用 Streamlit 创建小部件和视觉组件可以通过简单地声明一个变量来完成。我们还可以通过使用 Streamlit 输入小部件来为应用程序添加交互性。主要的小部件有st.text_input、st.button和st.slider。该库有一个长长的页面元素列表。以下是一些主要元素及其描述:
-
st.write:这将内容写入页面,并自动检测内容的类型以正确呈现。如果您写入st.write('hi friends'),它将显示文本;如果您提供数据框而不是字符串,它将以适当的格式呈现数据框。 -
st.title:这将显示以标题格式化的文本。 -
st.markdown:这将显示以 Markdown 格式化的文本。 -
st.dataframe:这将以交互式表格的形式显示数据框。
spacy-streamlit包提供了可视化 spaCy 模型和开发交互式应用程序的工具。它具有各种组件,可以集成到您自己的 Streamlit 应用程序中,包括句法依存关系、命名实体、文本分类、标记属性等的可视化器。让我们构建一个应用程序,以了解 Streamlit 和spacy-streamlit是如何协同工作的。首先,您需要使用pip install spacy-streamlit安装该包。安装了库之后,让我们继续构建一个应用程序来显示我们在第八章中训练的模型中的实体:
-
首先,我们导入两个包,
Streamlit和spacy_streamlit:import streamlit as st import spacy_streamlit -
让我们为
st.text_input组件定义一个默认文本:DEFAULT_TEXT = """Givenchy is looking at buying U.K. startup for $1 billion""" -
现在我们定义第八章最终模型的路径:
spacy_model = "../chapter_08/pipelines/fashion_ner_with_base_entities" -
让我们添加一个标题和文本输入。
text_input的内容将被保存在text变量中:st.title("NER Fashion Brands App") text = st.text_area("Text to analyze", DEFAULT_TEXT, height=200)
我们还有一些工作要做,但首先,让我们看看只有这段代码时应用程序的样子。将代码保存到app.py脚本中,然后运行streamlit run app.py以在本地机器上提供服务。图 11.2展示了我们目前所拥有的内容。

图 11.2 – 带有 text_area 组件的 Streamlit 应用程序
当使用 Streamlit 构建应用时,每次用户与输入小部件交互时,库都会从顶部到底部重新运行整个 Python 脚本。我们的应用需要在处理文本之前加载模型,这意味着每次用户在 st.text_area 小部件中输入另一个文本时,他们可能需要等待模型再次加载。为了处理这种情况,Streamlit 有缓存功能(docs.streamlit.io/get-started/fundamentals/advanced-concepts#caching)和 spacy-streamlit 实现了 process_text() 方法。它缓存加载的模型并创建 Doc 对象。让我们使用该方法来处理我们应用中的文本,继续我们开始的列表:
-
process_text ()方法期望模型路径和将要处理的文本:doc = spacy_streamlit.process_text(spacy_model, text) -
最后,为了显示实体,我们将使用
visualize_ner()函数:spacy_streamlit.visualize_ner( doc, labels=["FASHION_BRAND", "GPE"], show_table=False, title="Fashion brands and locations", )
图 11 .3 显示了最终的应用。

图 11.3 – 使用 Streamlit 构建的 NER 应用
我们想添加一个按钮,让用户可以输入自己的文本并查看实体。由于每次我们与小部件交互时,Streamlit 都会重新运行所有脚本代码,所以我们不能使用 st.button 小部件。我们将使用 st.form 小部件,它将表单内的所有小部件值批量发送到 Streamlit。我们将使用 with 上下文管理器来创建表单。让我们试试:
-
我们将把所有应该重新加载的元素放入表单上下文管理器中。因此,当用户按下提交按钮时,我们将处理文档并使用可视化器显示它:
with st.form("my_form"): text = st.text_area("Text to analyze", DEFAULT_TEXT, height=200) submitted = st.form_submit_button("Submit") if submitted: doc = spacy_streamlit.process_text(spacy_model, text) spacy_streamlit.visualize_ner( doc, labels=["FASHION_BRAND", "GPE"], show_table=False, title="Fashion brands and locations", )
图 11 .4 显示了应用,现在有了 提交 按钮。

图 11.4 – 带有表单和提交按钮的 Streamlit 应用
-
下一个列表包含了网络应用的完整代码:
import streamlit as st import spacy_streamlit DEFAULT_TEXT = """Givenchy is looking at buying U.K. startup for $1 billion""" spacy_model = "../chapter_08/pipelines/fashion_ner_with_base_entities" st.title("NER Fashion Brands App") with st.form("my_form"): text = st.text_area("Text to analyze", DEFAULT_TEXT, height=200) submitted = st.form_submit_button("Submit") if submitted: doc = spacy_streamlit.process_text(spacy_model, text) spacy_streamlit.visualize_ner( doc, labels=["FASHION_BRAND", "GPE"], show_table=False, title="Fashion brands and locations", )
通过使用 streamlit 和 spacy-streamlit 库,我们仅用几行代码就能构建一个漂亮的 NLP 应用。其他 spacy-streamlit 可视化器包括 visualize_parser()、visualize_spans()、visualize_textcat()、visualize_similarity() 和 visualize_tokens()。
有时,我们需要为我们的 NLP 项目构建 API 而不是交互式网络应用。对于这种情况,我们可以使用另一个酷炫的库:FastAPI。让我们在下一节中了解更多关于它的信息。
使用 FastAPI 构建 NLP 模型的 API
FastAPI 是一个用于构建 API 的 Python 网络框架。它建立在另外两个 Python 库 Starlette 和 Pydantic 之上,使其成为可用的最快 Python 框架之一。FastAPI 基于标准的 Python 类型提示。通过类型提示,我们可以指定变量、函数参数或返回值的预期类型。这个特性帮助我们更早地捕捉到开发过程中的错误,所以在我们学习如何使用类型提示之前,让我们先了解如何使用它。
Python 类型提示 101
Python 是一种动态类型语言,这意味着它在运行时执行变量的类型检查。例如,如果我们运行此代码,它不会抛出任何错误:
string_or_int = "Hi friends"
string_or_int = 10
这运行得顺利,因为 Python 解释器处理了string_or_int从String到int的转换。这可能导致由于静默错误而出现的 bug。类型提示提供了一种在代码中指定预期类型的方法,因此它减少了我们创建 bug 的机会。让我们先看看一个没有类型提示的简单函数的例子:
def greeting(name):
return "Hello" + name
假设这个函数在一个代码库中,你只是导入它来在你的代码中使用。没有办法看到函数的作者期望name参数的类型,也没有关于返回类型的信息。为了获取这些信息,我们需要阅读并检查函数的代码。如果我们使用类型提示,情况就会改变:
def greeting(name: str) -> str:
return f"Hello {name}"
现在这些类型提示可以帮助你的代码编辑器,并显示类型。图 11.5显示了例如在Visual Studio Code中会发生什么。

图 11.5 – Visual Studio Code 中的类型提示
FastAPI 使用类型提示提供类型检查,导致 bug 和开发者引起的错误更少。现在我们知道了类型提示是什么,让我们使用 FastAPI 为我们的 spaCy 模型创建一个 API。
使用 FastAPI 为 spaCy 模型创建 API
我们构建 API 时使用的两个主要 HTTP 方法是GET和POST。GET用于请求不改变任何状态时,POST通常用于动作可以改变状态(向数据集添加元素、编辑值等)时。换句话说,GET用于读取数据,POST用于创建数据。在使用GET请求时,我们在 URL 地址中传递参数。在使用POST请求时,我们可以在请求体中传递参数。FastAPI 允许我们通过使用带有@app.get()或@app.post() Python 装饰器的函数来选择我们想要的请求类型。
让我们使用GET方法创建一个返回json对象的 API。首先,你需要使用pip install fastapi[standard]命令安装 FastAPI。现在创建一个包含以下命令的main.py文件:
-
首先,导入库并创建
app对象:from fastapi import FastAPI app = FastAPI() -
现在让我们创建
GET方法。我们将添加@app.get("/")装饰器。"/"表示调用此方法的 URL 路径将是我们的网站的根路径:@app.get("/") def root(): return {"message": "Hello World"} -
要在本地运行服务器,请转到命令行并输入
fastapi dev main.py。图 11.6显示了如果你打开浏览器并访问http://127.0.0.1:8000/URL 时应该看到的内容。

图 11.6 – GET 端点的响应
- FastAPI 的一个优点是它自动为 API 创建文档。默认情况下,它使用
Swagger UI(github.com/swagger-api/swagger-ui)。前往http://127.0.0.1:8000/docs查看。图 11 .7显示了我们的 FastAPI 的文档文档。

图 11.7 – 由 FastAPI 自动创建的我们的 API 文档
-
我们将创建一个 API,其风格与我们创建 Streamlit 网络应用时使用的风格相同。该 API 应接收一个文本列表,并返回一个包含实体的 JSON 响应。以下是一个请求示例:
{ "values": [ { "record_id": "1", "text": "Givenchy is looking at buying U.K. startup for $1 billion" } ] }
对于此请求,API 的响应应该是以下内容:
{
"values": [
{
"record_id": "1",
"data": {
"entities": [
{
"name": "Givenchy",
"label": "FASHION_BRAND",
"matches": [
{
"char_start": 0,
"char_end": 8,
"text": "Givenchy"
}
]
},
// [...] {
"name": "$1 billion",
"label": "MONEY",
"matches": [
{
"char_start": 47,
"char_end": 57,
"text": "$1 billion"
}
]
}
]
}
}
]
}
FastAPI 使用Pydantic模型来验证数据并构建 API 文档。让我们创建一些 Pydantic 模型来指定我们的 API 的POST请求。我们通过创建继承自 Pydantic 的BaseModel类的 Python 类来实现这一点:
-
为了提取实体,API 需要知道记录标识符和文本,因此让我们为它创建一个类:
from pydantic import BaseModel from typing import List class TextToExtractEntities(BaseModel): record_id: str text: str -
API 可以处理文本批次,因此请求的正文参数可以包含多个项目。让我们创建这个类:
class TextsRequest(BaseModel): values: List[TextToExtractEntities]
现在是时候使用 spaCy 提取实体以生成响应了。我们将创建一个与 Microsoft 的此 Cookiecutter 中使用的类非常相似的类:
github.com/microsoft/cookiecutter-spacy-fastapi
让我们开始吧:
-
我们应该初始化
EntityExtractor类,提供一个nlp模型以及记录标识符和记录文本的关键值:import spacy from spacy.language import Language class EntityExtractor: def __init__(self, nlp: Language, record_id_col_key: str = "record_id", record_text_col_key: str = "text"): self.nlp = nlp self.record_id_col_key = record_id_col_key self.record_text_col_key = record_text_col_key -
现在让我们创建一个提取实体的方法。该方法将遍历由
nlp.pipe()创建的文档,并为文本中的实体创建一个包含实体名称、标签以及实体起始和结束字符的列表:def extract_entities(self, records: List[Dict[str, str]]): ids = (item[self.record_id_col_key] for item in records) texts = (item[self.record_text_col_key] for item in records) response = [] for doc_id, spacy_doc in zip(ids, self.nlp.pipe(texts)): entities = {} for ent in spacy_doc.ents: ent_name = ent.text if ent_name not in entities: entities[ent_name] = { "name": ent_name, "label": ent.label_, "matches": [], } entities[ent_name]["matches"].append( {"char_start": ent.start_char, "char_end": ent.end_char, "text": ent.text} ) response.append({"id": doc_id, "entities": list(entities.values())}) return response -
为了测试此代码是否正常工作,让我们将其保存到
extractor.py脚本中,并按如下方式导入类:import spacy from pprint import pprint from extractor import EntityExtractor nlp = spacy.load("../chapter_08/pipelines/fashion_ner_with_base_entities") sentence = "Givenchy is looking at buying U.K. startup for $1 billion" doc = nlp(sentence) extractor = EntityExtractor(nlp) entities = extractor.extract_entities([{"record_id":1,"text":sentence}]) pprint(entities) -
我们使用在第八章中训练的模型来提取实体。响应应该是包含实体名称、标签和匹配项的字典:
[{ 'entities': [ { 'label': 'FASHION_BRAND', 'matches': [{ 'char_end': 8, 'char_start': 0, 'text': 'Givenchy' }], 'name': 'Givenchy' }, { 'label': 'GPE', 'matches': [{ 'char_end': 34, 'char_start': 30, 'text': 'U.K.' }], 'name': 'U.K.' }, { 'label': 'MONEY', 'matches': [{ 'char_end': 57, 'char_start': 47, 'text': '$1 billion' }], 'name': '$1 billion' } ], 'id': 1 }]
现在我们已经准备好完成我们的 API。/entities路径将是发送文本进行提取的POST端点。让我们回到 FastAPI 代码中创建此方法。
-
POST请求使用@app.post()装饰器定义。首先,我们需要将接收到的数据解析为具有record_id和text键的字典列表:@app.post("/entities") def extract_entities(body: TextsRequest): """Extract Named Entities from a batch of Records.""" documents = [] for item in body.values: documents.append({"record_id": item.record_id, "text": item.text}) -
现在我们将调用
EntityExtractor类,发送文档,并返回实体:entities_result = extractor.extract_entities(documents) response = [ {"record_id": er["record_id"], "data": {"entities": er["entities"]}} for er in entities_result ] return {"values": response} -
如果您将此代码添加到
main.py文件中,然后在终端中运行fastapi run main.py,并访问/docsURL,您现在应该能看到POST /entities端点规范。 -
关于 Swagger UI 的另一个酷点是,我们可以在浏览器中直接测试端点。点击
POST /entities向下的箭头按钮,然后点击右侧的Try it out按钮。现在你可以粘贴我们的示例请求,然后点击蓝色的Execute按钮。图 11.8 显示了POST /entities的箭头按钮。

图 11.8 – 发送数据到实体端点的按钮
下一个列表包含了我们 API 的完整代码:
from fastapi import FastAPI
from typing import List
from pydantic import BaseModel
import spacy
from extractor import EntityExtractor
app = FastAPI()
nlp = spacy.load("../chapter_08/pipelines/fashion_ner_with_base_entities")
extractor = EntityExtractor(nlp)
class TextToExtractEntities(BaseModel):
record_id: str
text: str
class TextsRequest(BaseModel):
values: List[TextToExtractEntities]
@app.get("/")
def root():
return {"message": "Hello World"}
@app.post("/entities")
def extract_entities(body: TextsRequest):
"""Extract Named Entities from a batch of Records."""
documents = []
for item in body.values:
documents.append({"record_id": item.record_id,
"text": item.text})
entities_result = extractor.extract_entities(documents)
response = [
{"record_id": er["record_id"],
"data": {"entities": er["entities"]}}
for er in entities_result
]
return {"values": response}
只用几行代码就能获得所有这些功能,这真是太酷了,对吧?这仅仅是使用 FastAPI 的基础知识。你可以在库的文档中查看更多高级内容,请访问 fastapi.tiangolo.com/learn/。
摘要
本章介绍了将 spaCy 与第三方库集成的两个强大工具:用于构建交互式网络应用的 Streamlit 和用于创建快速、类型安全的 API 的 FastAPI。我们展示了如何使用 Streamlit 和 spacy-streamlit 包构建一个 NER 网络应用,利用 Streamlit 的简洁性和交互性。然后我们转向使用 FastAPI 构建 API,强调类型提示在减少错误和提高代码可靠性方面的重要性。通过将 spaCy 与这些框架结合,你了解到你可以以最小的努力创建有效的、用户友好的 NLP 应用和服务。
在这一章的最后,我们结束了这本书。这是一段相当精彩的旅程!我希望你已经对 spaCy 的主要功能有了基本的了解,但更重要的是,我希望你现在能够使用 spaCy 创建遵循一些主要软件工程原则编写良好代码的解决方案。我迫不及待地想看看你接下来会构建什么!


浙公网安备 33010602011771号