AWS-人工智能服务的自然语言处理-全-

AWS 人工智能服务的自然语言处理（全）

原文：annas-archive.org/md5/3ab419d215a27f011904d779022ad3a5

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

作者们总是很有个性，几乎就像伦敦的天气。天色阴沉，你想去特拉法加广场散步，你穿上雨衣，带上雨伞以防万一，觉得自己已经为一切做好了准备。然而，你却完全没意识到大自然对你早已准备好了别有用心的计划。你走了一英里左右，突然间，天空放晴，阳光如最亮的歌曲洒在你的脸上，突然间，你措手不及（就像鹿撞上了车灯），你还穿着雨衣，拿着雨伞，而你距离家太远，无法返回去把它们丢掉。这正是我们在开始写书时最常经历的情况。你带着明确的目标出发，集中思想，写出了一份出色的大纲，得到了批准，然后开始制定章节内容，但你并不知道，书本有着不同的计划，知道自己要如何被写出来。

当这种情况发生时，正如生活中的一切，总是有选择的。你可以让创意的流动通过你的双手在书页上展现，或者你可以抗拒并遵循你预设的模式。当然，也有第三种选择，那就是遵循你想传达的整体结构，但当创意想要掌控时，让它自由发挥。这就是我们为这本书所做的。但这并不像我们最初想的那样容易，因为创意不会轻易妥协。著名的苏菲诗人贾拉尔·阿尔-鲁米曾说：“在沉默中，有着雄辩。停止编织，看看图案如何改进。”最难的部分就是停止“编织”或停止从我们作为 AWS 作者已经发布的内容中获得灵感。这也是本书的硬性要求，因此它成为了我们进行创意发挥、提出原创且有需求的内容的强大动力。

所以，我们停止了“编织”。接下来的逻辑步骤是让模式有所改进。但什么也没有发生。第一章的截止日期迫在眉睫，我们的编辑们非常礼貌地提醒我们截止日期的临近。仍然没有进展。我们利用这段“没有编织”的时间来规划和设计技术章节，但将整本书连贯起来的“胶水”，即主线叙事，依然难以捉摸。然后突然有一天，没有任何预警，这一切迎刃而解。我们完全忽视了鲁米说的那句话的第一部分：“在沉默中，蕴藏着雄辩。”在附近小径的自然散步满足了每天的沉默配额，在这段时间里，一个微弱的念头浮现了，我想起了一个我父亲（Shri T. Rangarajan）小时候讲给我听的故事，叫做阿里巴巴与四十大盗。我突然意识到，故事中的著名情节其实是我第一次记得通过声音来执行任务（请参考书中的第一章，商业背景下的自然语言处理与 AWS AI 服务介绍）。从那时起，灵感之门大开，源源不断的思路涌现，直到整本书最终完成。这就是本书诞生的经过。

我们都知道的生活中一个有趣的事实是，唯一不变的就是变化。而在编写本书的过程中，这一点同样适用。AWS 最棒的一点就是它不断创新的速度，新的功能持续推出。AWS 的产品路线图是基于客户的直接反馈，并且功能通过迭代方式逐步改进，不断推出新的功能。所以，当我们在编写本书时，Amazon Comprehend和Amazon Textract新增了功能，控制台体验发生了变化，等等。例如，Amazon Comprehend 修改了其控制台体验，增加了对从 PDF 文档直接进行自定义实体识别训练的支持，并改善了其自定义实体识别模型框架，支持每个实体仅用 100 个标注和 250 个文档进行训练。Amazon Textract 将AnalyzeDocument和DetectDocumentText API 的定价在全球八个 AWS 区域降低了 32%，并宣布支持自动化处理发票等功能。可以通过此链接查看 2021 年 AWS 的新功能完整列表：aws.amazon.com/about-aws/whats-new/2021/。

当你为本书中的各种 NLP 用例构建解决方案时，你将会注意到这些变化。请注意，由于 Amazon Textract 和 Amazon Comprehend 控制台已发生变化，书中的指令可能与你在 AWS 管理控制台中的体验不完全一致；然而，这些指令依然准确，并能满足你的需求。

例如，Amazon Comprehend 控制台中用于自定义实体识别的Train Recognizer按钮现已更改为Create new model。类似地，Amazon Comprehend 控制台中用于自定义分类的Train Classifier按钮也已更改为Create new model。当你为自定义实体识别指定训练和测试数据集时，控制台中将新增一个选项，让你选择PDF、Word 文档。Amazon Textract 也发生了变化，现在可以通过AnalyzeExpense选项查看文档的分析结果。

然而，在本书的大部分内容中，我们使用了 API 来构建解决方案，而 AWS 的一个优势就是其 API 保持一致性。你将获得一致的响应和请求。如果你想使用最新版本，只需要升级 Python Boto3 的版本。此外，我们的目标是确保本书始终保持相关性并与时俱进。

本书适合谁阅读

如果你是一个 NLP 开发人员或数据科学家，希望快速开始使用 AWS AI 服务来实现各种 NLP 场景，那么本书就是为你准备的。它将展示如何通过几行代码轻松将 AI 集成到应用程序中。为了理解书中所涉及的概念，你需要具备基本的机器学习知识。拥有 Jupyter Notebooks 和 Python 的经验将会有所帮助。

本书的内容

第一章，商业环境中的自然语言处理（NLP）及 AWS AI 服务简介，介绍了 NLP 的构建和使用 NLP 的商业价值，并概述了 AWS AI 技术栈及关键的 NLP 服务。

第二章，介绍 Amazon Textract，详细介绍了 Amazon Textract 的功能、它旨在解决的业务挑战、它具有的特性、适用的用户需求类型，以及如何轻松将 Textract 与其他 AWS 服务集成，例如 AWS Lambda 来构建业务应用。

第三章，介绍 Amazon Comprehend，详细介绍了 Amazon Comprehend 的功能、它旨在解决的业务挑战、它具有的特性、适用的用户需求类型，以及如何轻松将 Comprehend 与其他 AWS 服务集成，例如 AWS Lambda 来构建业务应用。

第四章，自动化文档处理工作流，深入探讨了基于我们的集体经验和观察到的使用趋势，跨行业的几种常见应用场景，这些场景可以从基于 NLP 的技术中受益。我们将提供详细的代码示例、设计与开发方法，并提供逐步指南，教你如何设置和运行这些示例，并附带 GitHub 代码库的访问链接。

第五章，创建 NLP 搜索，深入探讨了我们根据集体经验和观察到的使用趋势，在各行业中普遍存在的多种 NLP 应用场景。我们将提供详细的代码示例、设计和开发方法，并附带逐步指导，介绍如何设置和运行这些示例，同时提供 GitHub 仓库的访问权限。

第六章，利用 NLP 提高客户服务效率，深入探讨了我们根据集体经验和观察到的使用趋势，在各行业中普遍存在的多种 NLP 应用场景。我们将提供详细的代码示例、设计和开发方法，并附带逐步指导，介绍如何设置和运行这些示例，同时提供 GitHub 仓库的访问权限。

第七章，理解客户声音分析，深入探讨了我们根据集体经验和观察到的使用趋势，在各行业中普遍存在的多种 NLP 应用场景。我们将提供详细的代码示例、设计和开发方法，并附带逐步指导，介绍如何设置和运行这些示例，同时提供 GitHub 仓库的访问权限。

第八章，利用 NLP 变现您的媒体内容，深入探讨了我们根据集体经验和观察到的使用趋势，在各行业中普遍存在的多种 NLP 应用场景。我们将提供详细的代码示例、设计和开发方法，并附带逐步指导，介绍如何设置和运行这些示例，同时提供 GitHub 仓库的访问权限。

第九章，从金融文档中提取元数据，深入探讨了我们根据集体经验和观察到的使用趋势，在各行业中普遍存在的多种 NLP 应用场景。我们将提供详细的代码示例、设计和开发方法，并附带逐步指导，介绍如何设置和运行这些示例，同时提供 GitHub 仓库的访问权限。

第十章，通过机器翻译降低本地化成本，深入探讨了我们根据集体经验和观察到的使用趋势，在各行业中普遍存在的多种 NLP 应用场景。我们将提供详细的代码示例、设计和开发方法，并附带逐步指导，介绍如何设置和运行这些示例，同时提供 GitHub 仓库的访问权限。

第十一章，使用聊天机器人查询文档，深入探讨了多种行业中普遍存在的使用案例，这些案例可以受益于基于自然语言处理（NLP）的技术，基于我们的集体经验和观察到的使用趋势。我们将提供详细的代码示例、设计和开发方法，以及一步步的指南，指导如何设置和运行这些示例，并提供对 Github 代码库的访问。

第十二章，医疗行业中的 AI 与 NLP，深入探讨了 AWS NLP 解决方案如何帮助医疗行业实现运营效率，特别是自动化理赔审查的使用案例。

第十三章，提高文档处理工作流的准确性，讨论了为什么我们需要在文档处理工作流中加入人类参与（HITLs），以及如何通过 Amazon 增强型 AI（A2I）设置 HITL 流程，从而提高现有文档处理工作流的准确性，特别是利用 Amazon Textract。

第十四章，审计命名实体识别工作流，通过引入 Amazon Comprehend 进行基于文本的洞察，扩展了前述方法，从而展示了为自定义命名实体识别使用案例设置审计工作流的端到端流程。

第十五章，文档分类与设置人类参与的主动学习，讲述了如何使用 Amazon Comprehend 自定义分类来对文档进行分类，然后如何使用 Amazon A2I 设置与自定义分类模型相关的主动学习反馈。

第十六章，提高 PDF 批处理的准确性，解决了一个已经存在一段时间并且普遍存在的操作需求，尽管如此，许多组织依然难以高效地解决它——这就是 PDF 批处理问题。

第十七章，可视化手写内容中的洞察，专注于如何从文本——即手写文本——中提取洞察并加以利用，从而推动决策过程。

第十八章，构建安全、可靠且高效的 NLP 解决方案，回顾了最佳实践、技术和指南，探讨了什么样的 NLP 解决方案能够从优秀变为卓越。

为了充分利用本书的内容

您将需要一个 AWS 账户，因此在开始之前，我们建议您先创建一个。

如果您正在使用本书的电子版，我们建议您手动输入代码。这样做可以帮助您避免与复制粘贴代码相关的潜在错误。

下载示例代码文件

您可以从 GitHub 下载本书的示例代码文件，地址是github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services。如果代码有更新，它将在现有的 GitHub 仓库中进行更新。

我们还提供了来自我们丰富书籍和视频目录中的其他代码包，您可以在github.com/PacktPublishing/查看。

下载彩色图像

我们还提供了一份包含本书中使用的截图和图表的彩色图像的 PDF 文件。您可以在此下载：static.packt-cdn.com/downloads/9781801812535_ColorImages.pdf。

实践中的代码

本书的《实战中的代码》视频可以通过bit.ly/3vPvDkj观看。

使用的约定

本书中使用了许多文本约定。

文本中的代码：表示文本中的代码字、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟网址、用户输入和 Twitter 用户名。例如：“复制创建的存储桶名称，打开Chapter 05/Ch05-Kendra Search.ipynb，并将其粘贴到以下单元格中，替换掉'<your s3 bucket name>'以开始操作。”

代码块的格式如下：

# Define IAM role
role = get_execution_role()
print("RoleArn: {}".format(role))
sess = sagemaker.Session()
s3BucketName = '<your s3 bucket name>'
prefix = 'chapter5'

当我们希望您注意到代码块中特定部分时，相关的行或项目会以粗体显示：

    <body>
        <h1>Family Bank Holdings</h1>
        <h3>Date: <span id="date"></span></h3>
        <div id="home">
          <div id="hometext">
        <h2>Who we are and what we do</h2>

粗体：表示一个新术语、重要词汇或您在屏幕上看到的文字。例如，菜单或对话框中的文字通常以粗体显示。举个例子：“您会看到页面有几个标题，然后有一段关于家庭银行的段落，家庭银行是LiveRight Holdings的子公司。”

提示或重要事项

如下所示。

联系我们

我们始终欢迎读者的反馈。

常规反馈：如果您对本书的任何内容有疑问，请通过电子邮件联系我们：customercare@packtpub.com，并在邮件主题中注明书籍标题。

勘误表：尽管我们已经非常小心确保内容的准确性，但错误仍然可能发生。如果您在本书中发现了错误，我们将不胜感激，如果您能将其报告给我们。请访问www.packtpub.com/support/errata并填写表格。

盗版：如果您在互联网上发现我们作品的任何非法复制版本，我们将不胜感激，如果您能提供位置地址或网站名称。请通过 mailto:copyright@packt.com 联系我们，并提供该材料的链接。

如果您有兴趣成为作者：如果您在某个领域有专业知识，并且有兴趣撰写或为书籍做出贡献，请访问authors.packtpub.com。

分享您的想法

一旦你阅读了《使用 AWS AI 服务进行自然语言处理》，我们非常希望听到你的想法！请点击这里直接进入本书的亚马逊评论页面并分享你的反馈。

你的评论对我们和技术社区非常重要，它将帮助我们确保提供优质的内容。

第一部分：AWS AI NLP 服务介绍

本节中，我们介绍了自然语言处理（NLP）的构建概念和使用 NLP 的商业价值，并概述了 AWS AI 技术栈以及关键的 NLP 服务。

本节包含以下章节：

• 第一章，业务背景中的自然语言处理（NLP）与 AWS AI 服务介绍

• 第二章，介绍亚马逊 Textract

• 第三章，介绍亚马逊 Comprehend

第一章：第一章：商业背景中的 NLP 及 AWS AI 服务简介

自然语言处理（NLP）在科学界非常流行，但利用这种人工智能（AI）技术来获得商业利益的价值，对于主流用户来说并不立刻显现出来。我们的重点将是提高人们的意识并教育您关于 NLP 的商业背景，提供关于非结构化文本中数据激增的示例，并展示 NLP 如何帮助提取有意义的见解，以指导企业的战略决策。

在本引言章节中，我们将建立基本背景，以帮助您熟悉一些人工智能和机器学习（ML）的基本概念，NLP 可以帮助解决的挑战类型，构建 NLP 解决方案时的常见陷阱，以及 NLP 如何工作以及它擅长做什么，并通过实例进行讲解。

本章内容将涵盖以下内容：

• 介绍 NLP

• 克服构建 NLP 解决方案中的挑战

• 理解为什么 NLP 正在成为主流

• 介绍 AWS ML 技术栈

介绍 NLP

语言与文明同在，没有任何一种沟通工具比口语或书面语言更为有效。在他们的童年时代，作者们曾为《一千零一夜》这部集印度、波斯和阿拉伯故事于一体的几百年古老故事集所吸引。在其中一个著名的故事《阿里巴巴与四十大盗》中，阿里巴巴是一个贫穷的男子，他发现了一个盗贼藏匿的藏宝洞，而这个洞只有通过说出魔法词语芝麻开门才能打开。在作者的记忆中，这是他们第一次接触到语音激活的应用程序。尽管这纯粹是虚构作品，但它确实激发了探索可能性的兴趣。

最近，在过去的二十年里，互联网的普及和智能设备的激增推动了数字通信技术的重大进展。与此同时，长期以来致力于开发人工智能的研究随着机器学习的出现取得了快速进展。阿瑟·李·塞缪尔（Arthur Lee Samuel）在 1959 年首次提出了机器学习这一术语，并通过创建一个跳棋游戏程序，展示了计算机如何被教授，使这一概念在计算机科学领域得到了广泛应用。

然而，机器可以被教导模仿人类认知的概念，早在 1950 年就由艾伦·图灵在他的论文《计算机机械与智能》中推广开来。这篇论文介绍了图灵测试，这是一种当时常见的派对游戏的变体。测试的目的是让一名解答者提问并比较来自人类参与者和计算机的回答。关键在于，解答者并不知道哪一方是人类，哪一方是计算机，因为三者都被隔离在不同的房间里。如果解答者无法分辨出两者，因为回答非常相似，那么图灵测试就成功验证了计算机具备人工智能。

当然，自那时以来，人工智能领域取得了飞跃式的发展，主要得益于机器学习算法在解决现实世界问题中的成功。算法，简单来说，是一种程序化功能，能够根据条件将输入转化为输出。与常规的可编程算法相反，机器学习算法已经学会了根据遇到的数据来调整其处理方式。根据需求，有不同的机器学习算法可供选择，例如：极端梯度提升（XGBoost），这是一种流行的回归和分类问题算法；指数平滑（ETS），用于统计时间序列预测；单次多框检测器（SSD），用于计算机视觉问题；以及潜在狄利克雷分配（LDA），用于自然语言处理中的主题建模。

对于更复杂的问题，机器学习（ML）已经发展为深度学习，通过引入人工神经网络（ANNs），这些神经网络能够通过从海量数据中学习来解决高度挑战性的任务。例如，AWS DeepComposer（aws.amazon.com/deepcomposer/）是亚马逊网络服务（AWS）的一项机器学习服务，它通过音乐作为教学媒介来教育开发者。DeepComposer 使用的机器学习模型之一是通过一种叫做卷积神经网络（CNN）的神经网络类型进行训练，利用自回归（AR）技术从简单的输入旋律中创作出新的独特音乐作品：

图 1.1 – 使用 AWS DeepComposer 和机器学习创作音乐

钢琴卷轴是音乐的图像表示，AR-CNN 将音乐生成视为这些钢琴卷轴图像的序列：

](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_01_03.jpg)

图 1.2 – 音乐的钢琴卷轴表示

尽管随着先进技术的普及，机器学习（ML）在各类组织中得到了广泛应用，并且有望解决多种问题，且 AWS 在能力的广度和深度上具备独特优势，但机器学习只是今天 AI 可能实现的功能的一部分。根据一项报告（www.gartner.com/en/newsroom/press-releases/2019-01-21-gartner-survey-shows-37-percent-of-organizations-have，2021 年 3 月 23 日访问），2015 到 2019 年间，AI 的采用率增长了 270%。而且这一增长势头仍在迅速发展。AI 不再是只有具备高性能计算机资源的大企业才能使用的外围技术。如今，AI 已成为希望为应用程序增添认知智能、加速商业价值的组织的主流选择。例如，埃克森美孚与亚马逊合作，为客户提供了一种创新且高效的加油支付方式。Alexa 支付加油技能使用车辆的 Alexa 设备或智能手机上的 Alexa 应用程序与加油机进行通信，完成支付。作者亲自访问了一家当地的埃克森美孚加油站并亲身体验，感觉非常棒。详情请参见 www.exxon.com/en/amazon-alexa-pay-for-gas。

AI 涉及广泛的任务范围，类似于人类的感官和认知能力。通常，这些任务被分为几个类别，例如计算机视觉（模仿人类视觉）、自然语言处理（模仿人类的语言、写作和听觉过程）、对话界面（如聊天机器人，模仿基于对话的交互）和个性化（模仿人类直觉）。例如，C-SPAN，一个报道美国参议院和众议院议程的广播公司，使用Amazon Rekognition（基于计算机视觉的图像和视频分析服务）标记每个时间点的发言人/镜头前的人。通过 Amazon Rekognition，C-SPAN 能够索引比之前多两倍的内容。此外，AWS 提供了智能搜索、预测、欺诈检测、异常检测、预测性维护等 AI 服务，这也是为什么 AWS 在首次 Gartner 云 AI 魔力象限报告中被评为领导者的原因。

虽然语言本身是有结构的且定义明确，但语言的使用或解释是主观的，可能无意间造成不良影响，因此在构建自然语言解决方案时需要特别注意。举个例子，电话游戏就展示了对话如何不自觉地被夸大，最终得到与最初内容完全不同的版本。每个参与者都重复他们认为自己听到的内容，而不是实际听到的内容。作为派对游戏时，这样做很有趣，但在现实生活中可能会带来更严重的后果。计算机也是如此，它们会根据底层机器学习模型如何解读语言来重复它们所“听到”的内容。

为了理解小的增量变化如何彻底改变意思，我们来看另一个受欢迎的游戏：单词阶梯（en.wikipedia.org/wiki/Word_ladder）。目标是将一个单词转换成另一个单词，通常是其反义词，尽可能用最少的步骤，每次只更改一个字母。

以下表格展示了一个例子：

图 1.3 – 单词阶梯游戏

将人工智能适应于自然语言处理，催生了一系列主要处理与人类语言和文本相关的认知和感知过程的计算仿真能力。应用可以被分为两个主要类别：

• 自然语言理解（NLU），用于像 Amazon Alexa 这样的语音应用，以及语音转文本/文本转语音转换。

• NLP，用于从文本中解读基于上下文的见解。

使用自然语言理解（NLU）技术，以前需要多个且有时繁琐的接口（如屏幕、键盘和鼠标）来实现计算机与人类的互动，现在只需要语音就能高效工作。

在斯坦利·库布里克的 1968 年电影2001 太空漫游中，（剧透警告！！）一个名为HAL 9000的人工智能计算机使用视觉和声音与船上的人类互动，在电影过程中，它发展出了个性，不接受自己犯错的事实，并在发现人类的停机计划后试图杀死他们。快进到现在，距离电影中描绘的未来已经过去 20 年，我们在语言理解和处理方面取得了显著进展，但幸运的是，尚未达到电影中情节的夸张程度。

现在我们已经很好地理解了自然语言处理（NLP）发展的背景以及它的应用方式，让我们来看看在开发 NLP 解决方案时可能遇到的一些常见挑战。

克服构建 NLP 解决方案中的挑战

我们之前提到，常规编程和机器学习（ML）算法的主要区别在于，机器学习算法能够根据输入的数据调整其处理方式。在自然语言处理（NLP）的背景下，正如在其他 ML 领域一样，这些区别带来了显著的价值，并加速了企业业务成果。例如，考虑一个需要为用户展示基于兴趣主题的书籍推荐的书籍出版组织。

在传统的世界里，你需要多个团队来逐一处理整个书籍集合，单独阅读每本书，识别关键词、短语、主题和其他相关信息，创建索引将书名、作者和类型与这些关键词关联，并将其与搜索功能连接起来。这是一个庞大的工作，根据书籍集合的规模、人员数量、他们的技能水平，建立这个系统需要几个月甚至几年的时间，而且索引的准确性容易受到人为错误的影响。随着书籍更新到新版，新增或移除书籍，这项工作还必须逐步重复进行。这也是一项重大成本和时间投入，可能会让很多人却步，除非这段时间和资源已经预先规划好。

要在我们之前的例子中引入一定程度的自动化，我们需要能够从文档中数字化文本。然而，这不仅是唯一的需求，因为我们还希望从书籍中提取基于上下文的洞察，以便为读者提供一个推荐索引。如果我们举例说，比如 Packt 出版公司，拥有超过 7,500 本书籍的收藏，我们需要一个解决方案，它不仅能处理大量页面，还能理解文本中的关系，并基于语义、语法、词语分割和语言提供解释，从而创建智能索引。在第五章，创建 NLP 搜索中，我们将详细介绍这一解决方案，包括代码示例和演示视频。

当今的企业在从数据中提取有意义的洞察方面面临挑战，主要是由于数据增长的速度。直到大约十年前，大多数组织都使用关系型数据库来满足所有数据管理需求，今天有些组织仍然在使用。这在当时是可以接受的，因为数据量需求通常只有单个 TB 数量级或更少。近年来，随着智能手机的普及、连接设备的大规模扩散（达到数十亿个）、基础设施动态扩展至新地域的能力，以及由于云计算的普及而使存储和计算成本变得更便宜，技术领域发生了巨大变革。这意味着应用程序被更频繁地使用，拥有更大的用户基础、更强的处理能力和功能，能够加快创新步伐，缩短市场推广周期，因此需要存储和管理 PB 级别的数据。再加上应用程序用户对更快响应时间和更高吞吐量的需求，给关系型数据库的性能带来了压力，推动了向专用数据库转型，如 Amazon DynamoDB，这是一种提供单毫秒级延迟的键值和文档数据库，能够在任何规模下运行。

虽然这一举措标志着一个积极的趋势，但更有趣的是企业如何利用这些数据来获得战略性洞察。毕竟，数据的价值在于我们能从中提取的信息。我们看到，许多组织在接受专用工具的好处时，却在孤立的环境中实施这些变化。因此，在正确利用数据优势的成熟度上存在不同的层次。一些部门使用 S3 数据湖（aws.amazon.com/products/storage/data-lake-storage/）从不同来源获取数据并运行机器学习以得出基于上下文的洞察，另一些则将数据整合到专用的数据库中，而其余的仍然在使用关系型数据库来满足所有需求。

你可以在以下图 1.5：Amazon S3 数据湖的示例中看到数据湖主要组件的基本解释：

图 1.4 – 一个 Amazon S3 数据湖的示例

让我们看看在这种情况下，NLP 如何通过回顾我们的图书出版示例继续增加业务价值。假设我们成功构建了智能索引解决方案，现在我们需要通过 Twitter 反馈更新书评。可搜索的索引应根据评价情感提供书籍推荐（例如，如果最近 3 个月内超过 50%的评价为负面，则不推荐该书）。传统上，通过在巨大的数据仓库上运行一套报告来生成业务洞察力，这些数据仓库收集、挖掘和组织数据到市场和维度中。一条推文甚至可能不被考虑为数据来源。如今，情况已经改变，挖掘社交媒体数据是生成洞察力的重要方面。建立业务规则来检查每条推文是一项耗时且计算密集的任务。此外，由于推文是非结构化文本，语义上的轻微变化可能会影响解决方案的有效性。

现在，如果考虑模型训练，构建精确的 NLP 模型所需的基础设施通常使用称为变压器的深度学习架构（请参阅www.packtpub.com/product/transformers-for-natural-language-processing/9781800565791），它使用序列到序列处理，无需按顺序处理标记，从而实现更高程度的并行化。变压器模型系列使用数十亿个参数进行训练架构，使用实例集群进行分布式学习，这增加了时间和成本。

AWS 提供的 AI 服务允许您只需几行代码即可将 NLP 添加到您的应用程序中，用于对几乎无限规模的非结构化文本进行情感分析，并立即利用等待发现的巨大潜力。我们将从第二章，介绍 Amazon Textract，开始更详细地介绍 AWS AI 服务。

在本节中，我们审查了组织在构建 NLP 解决方案时遇到的一些挑战，例如在数字化基于纸张的文本、理解来自结构化和非结构化数据的模式以及这些解决方案可能的资源密集型。现在让我们了解为什么 NLP 是当今企业的重要主流技术。

理解为什么 NLP 正在成为主流技术

根据这份报告（www.marketsandmarkets.com/Market-Reports/natural-language-processing-nlp-825.html，2021 年 3 月 23 日访问），全球自然语言处理（NLP）市场预计到 2026 年将增长至 351 亿美元，年复合增长率（CAGR）为 20.3%。考虑到机器学习（ML）在各行各业（如金融、零售、制造、能源、公共事业、房地产、医疗等）产生的影响，这并不令人惊讶，尤其是在云计算的兴起和规模经济的推动下，各种规模的组织都在广泛应用。

这篇关于Emergence Cycle的文章（blogs.gartner.com/anthony_bradley/2020/10/07/announcing-gartners-new-emergence-cycle-research-for-ai/），研究了 NLP 中的新兴技术（基于已提交的专利，且关注仍在实验室中或最近发布的技术），显示了 NLP 最成熟的应用是多媒体内容分析。根据我们的经验，这一趋势是成立的，内容分析以获得战略洞察力是我们与多个行业组织交流中常见的 NLP 需求：

图 1.5 – Gartner 的 NLP 出现周期 2020

例如，在 2020 年，当全球面临疫情的挑战时，许多组织采用了人工智能，特别是自然语言处理技术，来预测病毒传播模式、吸收病毒行为和疫苗研究的知识、监控安全措施的效果等。2020 年 4 月，AWS 推出了一个基于 NLP 的搜索网站cord19.aws/，使用了一项名为Amazon Kendra（aws.amazon.com/kendra/）的 AWS 人工智能服务。该网站提供了一个简单的界面，用户可以通过自然语言问题搜索COVID-19 开放研究数据集。由于该数据集根据 COVID-19 的最新研究不断更新，CORD-19 搜索凭借其对 NLP 的支持，能够轻松浏览这一不断扩展的研究文献集合，并找到问题的精确答案。搜索结果不仅提供包含问题答案的具体文本，还提供包含这些答案的原始文本：

图 1.6 – CORD-19 搜索结果

弗雷德·哈钦森癌症研究中心是一个致力于到 2025 年治愈癌症的研究机构。弗雷德·哈钦森癌症研究中心首席信息官 Matthew Trunnell曾表示：

“开发临床试验并将其与合适的患者群体连接的过程，要求研究团队筛选并标注大量非结构化的临床记录数据。Amazon Comprehend Medical 将把这一时间负担从数小时减少到数秒。这是一个关键步骤，可以让研究人员在需要时快速访问他们所需的信息，从而发现可操作的见解，以推动救生疗法的发展。”

有关 Amazon Comprehend 和 Amazon Comprehend Medical 的更多详细信息和使用示例，请参见第三章，介绍 Amazon Comprehend。

那么，AI 和 NLP 如何帮助我们治愈癌症或为大流行做准备呢？这就涉及到在看似不存在的地方识别模式。非结构化文本，如文档、社交媒体帖子和电子邮件消息，类似于阿里巴巴洞中的宝藏。为了理解这一点，让我们简要看一下 NLP 是如何工作的。

NLP 模型通过学习所谓的词嵌入进行训练，词嵌入是单词在大规模文档集合中的向量表示。这些词嵌入捕捉了文档中单词之间的语义关系和分布，从而帮助根据单词与其他单词的关系来映射单词的上下文。用于学习词嵌入的两种常见训练架构是Skip-gram和连续词袋模型（CBOW）。在 Skip-gram 中，输入单词的词嵌入用于推导相关单词的分布，以预测上下文；而在 CBOW 中，相关单词的词嵌入则用于预测中间的单词。两者都是基于神经网络的架构，并且在基于上下文的分析用例中效果良好。

现在我们理解了 NLP 的基础（通过将单词转换为向量表示来分析文本中的模式），当我们使用来自不同数据源的文本数据训练模型时，由于在狭窄上下文中看不见的模式在更广泛的视野中显现出来，因此常常能得到独特的见解，因为我们在利用数字来发现文本中的关系。例如，Amazon Prime 电视剧《全球经济的巨大怪物》中的橡胶一集展示了真菌性疾病有可能摧毁全球经济，即使乍一看，它们之间似乎没有任何联系。根据美国国家医学图书馆，天然橡胶占全球消费量的 40%，而南美叶斑病（SALB）真菌性疾病有可能在全球传播，并严重影响橡胶生产。没有橡胶，飞机无法着陆，橡胶的用途如此广泛，它对经济的影响将是前所未有的。这是一个机器学习和 NLP 模型在广泛文本语料库中找到具体感兴趣项的典型例子。

在 AWS 和云计算彻底改变了对先进技术的访问之前，设置 NLP 模型进行文本分析至少是充满挑战的。最常见的原因如下：

• 技能缺乏：数据识别、特征工程、构建模型、训练和调优等任务都需要一种独特的技能组合，包括软件工程、数学、统计学和数据工程，只有少数从业人员具备这些技能。

• 初始基础设施设置成本：机器学习训练是一个迭代过程，通常需要通过反复试验来调优模型，以达到期望的准确性。进一步的训练和推理可能需要基于数据量和请求数量的 GPU 加速，从而需要较高的初期投资。

• 当前本地环境的可扩展性：在本地服务器上运行机器学习训练和推理会限制所需的弹性，无法根据模型大小、数据量和推理吞吐量进行计算和存储的扩展。例如，训练大规模的变换器模型可能需要大规模并行集群，而针对这种场景的容量规划非常具有挑战性。

• 可用工具帮助协调 NLP 训练的各个环节：如前所述，机器学习工作流包含许多任务，例如数据发现、特征工程、算法选择、模型构建，包括对模型进行多次训练和微调，最后将模型部署到生产环境中。此外，获得一个准确的模型是一个高度迭代的过程。这些任务中的每一项都需要专门的工具和专业知识来实现高效性，而这一点并不容易。

不再需要。AWS 的自然语言能力 AI 服务允许通过 API 调用为应用程序添加语音和文本智能，而不必开发和训练模型。NLU 服务提供将语音转换为文本的能力，使用 Amazon Transcribe （aws.amazon.com/transcribe/）或将文本转换为语音的能力，使用 Amazon Polly （aws.amazon.com/polly/）。对于 NLP 需求，Amazon Textract （aws.amazon.com/textract/）使应用程序能够从图像和 PDF 文档中读取和处理手写和打印文本，而通过 Amazon Comprehend （aws.amazon.com/comprehend/），应用程序可以快速分析文本，发现洞察和关系，而无需先前的 ML 训练。例如，供应链数据管理公司 Assent 使用 Amazon Textract 阅读表格、表单和自由格式文本，并使用 Amazon Comprehend 从文本中提取业务特定的实体和值。在本书中，我们将引导您如何使用这些服务来处理一些流行的工作流程。更多详细信息，请参阅 第四章，自动化文档处理工作流。

在本节中，我们看到了一些 NLP 在解决现实世界挑战中的重要性的示例，并且了解了其具体意义。我们明白了数据中的模式可以揭示新的含义，而 NLP 模型非常擅长推导这些模式。然后，我们回顾了一些 NLP 实施中的技术挑战，并简要概述了 AWS AI 服务。在下一节中，我们将介绍 AWS ML 堆栈，并简要概述每一层。

介绍 AWS ML 堆栈

AWS ML 服务和功能被组织成堆栈的三层，考虑到一些开发人员和数据科学家是 ML 领域的专家，他们习惯于使用 ML 框架、算法和基础设施来构建、训练和部署模型。

对于这些专家来说，AWS ML 堆栈的底层提供了强大的 CPU 和 GPU 计算实例（aws.amazon.com/ec2/instance-types/p4/ 实例提供了目前云端 ML 训练的最高性能），支持包括TensorFlow、PyTorch 和 MXNet 在内的主要 ML 框架，客户可以使用这些框架通过 Amazon SageMaker 进行托管式体验，或使用 深度学习 AMI 和容器在 Amazon EC2 实例上构建模型。

您可以在下图中看到 AWS ML 堆栈的三层结构。更多详细信息，请参阅 aws.amazon.com/machine-learning/infrastructure/：

为了让机器学习更加易于访问和扩展，在堆栈的中间层，Amazon SageMaker是一个完全托管的机器学习平台，能够消除每个 ML 过程步骤中的繁重工作。SageMaker 于 2018 年推出，是 AWS 历史上增长最快的服务之一，建立在亚马逊二十多年构建真实世界机器学习应用经验的基础上。通过 SageMaker Studio，开发人员和数据科学家拥有了第一个专为 ML 设计的完全集成的开发环境。欲了解如何使用 Amazon SageMaker 构建 ML 模型，请参考 Julien Simon 的书籍，Learn Amazon SageMaker，此书由 Packt 出版（www.packtpub.com/product/learn-amazon-sagemaker/9781800208919）：

图 1.7 – 每个 ML 工作流步骤的 Amazon SageMaker 功能的表格列表

对于那些不想处理模型和训练的客户，在堆栈的最上层，AWS AI 服务提供了预训练模型，并通过 API 端点进行轻松集成，适用于包括语音、文本、视觉、推荐和异常检测在内的常见 ML 用例：

图 1.8 – AWS AI 服务

好的，现在是时候开始进入技术层面了。既然我们已经理解了云计算如何在将机器学习（ML）和人工智能（AI）推向主流方面发挥了重要作用，以及将自然语言处理（NLP）加入应用程序如何加速业务成果，我们现在深入了解一下用于文档分析的 Amazon Textract 和用于高级文本分析的 Amazon Comprehend 这两个 NLP 服务。

准备好了吗？我们开始吧！！

总结

本章中，我们通过追溯人工智能的起源、其在过去几十年中的演变，以及机器学习算法的重大进展如何使人工智能应用成为主流，介绍了 NLP。我们回顾了这些算法的一些示例，并展示了它们如何应用的实例。然后，我们转向人工智能趋势，看到人工智能的采用在过去几年中呈指数增长，并且已经成为加速企业商业价值的关键技术。

我们读到了埃克森美孚如何在他们的加油站使用 Alexa 的一个有趣例子，并深入探讨了人工智能如何被创建以模仿人类认知，以及其应用的广泛类别，如文本、语音和视觉。我们看到，人工智能在自然语言处理方面主要有两个应用领域：基于语音的自然语言理解（NLU）和从文本中提取洞见的自然语言处理（NLP）。

在分析企业今天如何构建 NLP 模型时，我们回顾了一些常见的挑战以及如何缓解这些挑战，例如数字化纸质文本、从不同来源收集数据、理解数据中的模式，以及这些解决方案可能需要的资源密集度。

接下来，我们回顾了 NLP 行业趋势和市场细分，并通过一个例子展示了 NLP 在疫情期间的重要性及其持续作用。我们深入探讨了 NLP 的哲学，意识到它的核心就是将文本转化为数值表示，理解其中的潜在模式，从而解读新的含义。我们通过一个例子分析了这种模式，展示了 SALB 如何影响全球经济。

最后，我们回顾了设置 NLP 训练的技术影响及相关挑战。我们回顾了 AWS 机器学习栈的三层结构，并介绍了提供预构建模型和即用型智能的 AWS AI 服务。

在接下来的章节中，我们将介绍 Amazon Textract，这是一项完全托管的机器学习服务，可以读取图像和 PDF 中的印刷文字和手写文本，无需训练或构建模型，且不需要机器学习技能即可使用。我们将涵盖 Amazon Textract 的功能、它的作用、它解决的业务挑战、适用的用户需求类型，以及它与其他 AWS 服务（如 AWS Lambda）集成的简便性，以帮助构建业务应用。

进一步阅读

• 《这只巨兽：全球经济》 (www.amazon.com/This-Giant-Beast-Global-Economy/dp/B07MJDD22F)

• 学习 Amazon SageMaker 由 Julien Simon 著 (www.packtpub.com/product/learn-amazon-sagemaker/9781800208919)

• 《AWS CORD-19 搜索：COVID-19 文献的神经搜索引擎》 (arxiv.org/abs/2007.09186)

• 《变形金刚与自然语言处理》 (aws.amazon.com/blogs/machine-learning/aws-and-hugging-face-collaborate-to-simplify-and-accelerate-adoption-of-natural-language-processing-models/)

• 使用 Amazon SageMaker 的模型并行库训练 NLP 模型 (aws.amazon.com/blogs/machine-learning/how-latent-space-used-the-amazon-sagemaker-model-parallelism-library-to-push-the-frontiers-of-large-scale-transformers/)

• Oppy, Graham 和 David Dowe，"图灵测试"，《斯坦福哲学百科全书》 （2021 年冬季版），Edward N. Zalta（主编），即将发布，网址 (plato.stanford.edu/archives/win2021/entries/turing-test/)

第二章：第二章：介绍 Amazon Textract

在上一章中，您了解了企业如何利用自然语言处理（NLP）从文本中获取洞察力，并简要介绍了 AWS ML 堆栈。接下来，我们将详细介绍 Amazon Textract，并提供动手示例代码和说明。Amazon Textract 是一项 AWS AI 服务，可以在几乎没有机器学习（ML）技能的情况下，从文档和图像中提取文本。在了解 Textract 能做什么之前，我们将首先讨论一些文档处理中的挑战。然后，我们将讲解 Textract 如何帮助克服这些挑战。我们还将讨论使用 Amazon Textract 的好处以及其产品特点。最后，我们将介绍如何将 Amazon Textract 快速集成到您的应用程序中。

本章将通过以下部分进行导航：

• 设置您的 AWS 环境

• 克服文档处理的挑战

• 了解 Amazon Textract 的帮助作用

• 展示 Amazon Textract 的产品特点

• 将 Amazon Textract 与您的应用程序集成

技术要求

在本章中，您需要访问 aws.amazon.com/console/ 上的 AWS 账户。请参考注册 AWS 账户小节，位于设置您的 AWS 环境部分，了解如何注册 AWS 账户并登录到 AWS 管理控制台的详细说明。

本章讨论的解决方案的 Python 代码和示例数据集可以在 github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/tree/main/Chapter%2002 获取。

请查看以下视频，在 bit.ly/3be9eUh 上查看代码演示。

设置您的 AWS 环境

重要提示

请不要单独执行本节中的说明。本节是书中所有基本设置任务的参考。您将在本章及本书后续章节中构建解决方案时，指引您进入本节。只有在指引时，才执行这些任务。

根据您所在的章节，您将使用 AWS 管理控制台、Amazon SageMaker Jupyter Notebook、命令行，或者它们的组合来运行任务。无论哪种方式，您都需要正确的 AWS 身份与访问管理（IAM）权限、资源，并且在大多数情况下，还需要一个或多个 Amazon 简单存储服务（S3）存储桶，作为构建解决方案的先决条件。本节提供设置这些基本任务的说明。我们将在本书的后续章节中根据需要参考本节。

注册 AWS 账户

在本章及所有后续运行代码示例的章节中，你将需要访问一个 AWS 账户。在开始之前，我们建议你按照以下步骤创建一个 AWS 账户：

注意

请使用 AWS 免费套餐，它允许你基于一定的时间限制或服务使用限制免费试用服务。有关详细信息，请参阅aws.amazon.com/free。

1. 打开portal.aws.amazon.com/billing/signup。

2. 点击页面左下角的创建一个新的 AWS 账户按钮

3. 输入你的电子邮件地址和密码，确认密码，并提供一个 AWS 账户名称（这可以是你如何使用该账户的参考，例如沙箱等）。

4. 选择使用类型（商务或个人），提供你的联系信息，阅读并同意 AWS 客户协议条款，然后点击继续。

5. 提供信用卡信息和账单地址，点击继续。

6. 完成剩余步骤以完成 AWS 账户的注册过程。请记下你的用户 ID 和密码；这是你访问 AWS 账户的根凭证。

7. 一旦 AWS 账户创建完成，前往AWS 管理控制台 – console.aws.amazon.com – 使用你在之前步骤中创建的根凭证登录。

8. 在控制台顶部的服务搜索框中输入IAM并选择IAM以导航到 IAM 控制台。在 IAM 控制台的左侧面板中选择用户，然后点击添加用户。

9. 提供一个用户名，然后选择程序访问和AWS 管理控制台访问作为访问类型。保持密码为自动生成，并保持需要密码重置为已选状态。

10. 点击下一步：权限。在设置权限页面，点击直接附加现有策略，并勾选AdministratorAccess左侧的复选框。点击下一步两次进入审核页面。点击创建用户。

11. 现在返回到 AWS 管理控制台(console.aws.amazon.com)并点击登录。提供你在上一步创建的 IAM 用户名、临时密码，并输入新密码以登录控制台。

12. 在各个章节和部分中被提示时，登录到你的 AWS 账户。

现在你可以访问 AWS 管理控制台(aws.amazon.com/console/)。在接下来的章节中，我们将展示如何创建一个 S3 桶并上传你的文档。

创建一个 Amazon S3 桶，一个文件夹，并上传对象

在本书中，我们将使用 Amazon S3 作为我们解决方案的存储选项。因此，我们需要创建一个 S3 桶，在桶内创建文件夹，并上传文档以供解决方案使用。请按照以下步骤学习如何操作：

1. 登录 AWS 管理控制台（aws.amazon.com/console/），在顶部的搜索栏中输入S3。

2. 从搜索结果中选择S3，并导航到 Amazon S3 控制台。点击创建存储桶。

3. 在创建存储桶页面上，提供一个存储桶名称（名称不能包含空格或大写字母；更多详情，请参阅docs.aws.amazon.com/console/s3/bucket-naming），并从列表中选择一个AWS 区域（有关 AWS 区域的更多详情，请参阅docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RegionsAndAvailabilityZones.html）。

4. 接受其余选项的默认值，并点击创建存储桶。有关这些选项含义的更多详情，请参阅docs.aws.amazon.com/AmazonS3/latest/userguide/UsingBucket.html。

5. 现在我们的 S3 存储桶已成功创建，可以在存储桶窗格上使用存储桶名称进行搜索，或者如果在存储桶窗格中的存储桶列表中显示，则点击存储桶名称。在存储桶页面上，点击页面右侧的创建文件夹按钮。

6. 在创建文件夹页面上，为文件夹提供一个名称，接受其余字段的默认值，并点击页面右下角的创建文件夹。

7. 在对象页面上，可以在对象标题下方的搜索栏中搜索您创建的文件夹，或者点击文件夹名称。

8. 现在您可以选择右侧的添加文件或添加文件夹按钮，以显示从计算机选择文件或文件夹添加到我们创建的 S3 存储桶中的选项。

   请注意，AWS 管理控制台并非上传对象到 S3 的唯一选项。您可以使用 AWS 命令行界面（CLI）（更多详情，请参阅docs.aws.amazon.com/cli/latest/reference/s3/），或者也可以使用 Python SDK 编程方式上传文件，例如（boto3.amazonaws.com/v1/documentation/api/latest/reference/services/s3.html）。AWS 提供多种编程语言的 SDK（aws.amazon.com/tools/）。

至此，关于创建 S3 存储桶、创建文件夹和将对象上传到存储桶的说明结束。在下一部分中，让我们看看如何为我们的 Amazon SageMaker Jupyter 笔记本角色添加 IAM 权限策略。

创建 Amazon SageMaker Jupyter 笔记本实例

在本节中，我们将看到如何在 Amazon SageMaker 中创建一个笔记本实例。这是一个重要步骤，因为我们的许多解决方案示例是通过笔记本运行的。在创建笔记本之后，请根据正在构建的解决方案，在相关章节中按照说明使用笔记本。请按照以下步骤创建 Amazon SageMaker Jupyter 笔记本实例：

1. 如果尚未登录 AWS 管理控制台，请先登录。然后在页面顶部的服务搜索框中输入SageMaker，从列表中选择SageMaker，并点击它进入 Amazon SageMaker 管理控制台。

2. 在 SageMaker 控制台的左侧面板中，点击Notebook以展开选项，并点击Notebook 实例。

3. 在笔记本实例页面，点击右上角的创建笔记本实例按钮。

4. 为笔记本实例输入名称，并选择合适的笔记本实例类型。对于本书中的大多数解决方案构建，AWS Free Tier（aws.amazon.com/free）实例，如ml.t2.medium，应该足够了。

5. 在权限和加密部分，点击IAM 角色列表，选择创建新角色，然后选择任何 S3 存储桶。

6. 对其余字段选择默认值，并点击创建笔记本实例。

   注意

   默认情况下，SageMaker 会为每个笔记本实例提供互联网访问权限。如果您希望禁用此笔记本实例的互联网访问，可以将其附加到您的虚拟私有云（VPC）中，VPC 是一个高度安全的虚拟网络，用于在云中启动 AWS 资源（https://docs.aws.amazon.com/sagemaker/latest/dg/appendix-notebook-and-internet-access.html），并选择禁用互联网访问。我们需要此笔记本实例的互联网访问，因此，如果您打算附加 VPC 并通过 SageMaker 禁用互联网访问，请配置网络地址转换（NAT）网关，允许 VPC 子网中的实例与 VPC 外部的资源通信，但反向不可行（docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html），或者使用接口 VPC 端点（docs.aws.amazon.com/sagemaker/latest/dg/interface-vpc-endpoint.html），通过 AWS 骨干网在笔记本实例和您的 VPC 之间提供私有连接。这样可以通过您在 VPC 中实施的控制来管理笔记本实例的互联网访问。

您的笔记本实例将需要几分钟时间进行配置；一旦准备好，状态将变为InService。请按照使用 Amazon Textract 与您的应用程序部分的说明，了解如何使用您的笔记本实例。在接下来的几部分中，我们将逐步介绍修改我们附加到笔记本的 IAM 角色所需的步骤。

更改 Amazon SageMaker 笔记本执行角色的 IAM 权限和信任关系

注意

您不能向一个 IAM 角色附加超过 10 个托管策略。如果您的 IAM 角色已经有来自前一章节的托管策略，请在根据当前章节的要求添加新策略之前，先解除附加此策略。

当我们创建一个Amazon SageMaker Jupyter 笔记本实例（如我们在前一部分所做的那样）时，默认角色创建步骤包括将权限授予您指定的 S3 桶或 AWS 账户中的任何 S3 桶。但通常，我们需要更多的权限。例如，我们可能需要使用Amazon Textract或Amazon Comprehend API 的权限，或者其他服务的权限。

在本节中，我们将逐步介绍为我们的 Amazon SageMaker Jupyter 笔记本角色添加额外权限策略所需的步骤：

1. 在您的 AWS 管理控制台页面顶部的服务搜索栏中输入sagemaker以打开 Amazon SageMaker 控制台，并从列表中选择Amazon SageMaker。

2. 在Amazon SageMaker控制台的左侧面板中，展开Notebook并点击Notebook 实例。

3. 点击您需要更改权限的笔记本实例名称。

4. 在Notebook 实例设置页面，向下滚动至权限和加密，然后点击IAM 角色 ARN。

5. 这将打开IAM 管理控制台，并显示您的角色摘要以及该角色的权限和其他详细信息。点击附加策略。

6. 在搜索栏中输入textract，选择您感兴趣的策略旁边的复选框，然后点击右下角的附加策略。现在您应该能看到该策略已附加到您的角色。

7. 在某些情况下，我们可能需要自定义策略来满足我们的需求，而不是 AWS 提供的托管策略。具体来说，我们添加一个内联策略（docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html），以允许我们的 SageMaker 笔记本执行角色将PassRole权限授予能够承担该角色的服务（在信任关系中添加）以执行从笔记本中需要完成的操作。点击 SageMaker 笔记本执行角色摘要页面右侧的添加内联策略。

8. 现在点击JSON标签，并将以下 JSON 语句粘贴到输入区域：

   { "Version": "2012-10-17", "Statement": [ {
     "Action": [
         "iam:PassRole"
     ],
     "Effect": "Allow",
     "Resource": "<IAM ARN of your current SageMaker notebook execution role>"
     }
    ]
   }
   

9. 点击审查策略。

10. 在审查策略页面中，输入您的策略名称，并点击页面右下角的创建策略。

11. 现在您已经知道如何将权限和内联策略附加到您的角色，让我们进入本节的最后一步，更新您的角色的信任关系（docs.aws.amazon.com/directoryservice/latest/admin-guide/edit_trust.html）。在 SageMaker 笔记本执行角色的概述页面上，点击信任关系标签页，然后点击编辑信任关系。

12. 复制以下 JSON 代码段并将其粘贴到策略文档输入字段中。此声明允许 Amazon SageMaker、Amazon S3 和 Amazon Comprehend 获取假设 SageMaker 笔记本执行角色权限的能力。根据我们正在构建的章节和用例，假设角色的服务会有所不同，您将根据需要获得相应的指导。目前，请将以下 JSON 代码段视为示例，以便理解如何编辑信任关系：

    { "Version": "2012-10-17", "Statement": [
      { "Effect": "Allow", 
        "Principal": 
          { "Service": 
              [ "sagemaker.amazonaws.com", 
                "s3.amazonaws.com", 
                "comprehend.amazonaws.com" ] 
              }, 
              "Action": "sts:AssumeRole" } 
          ] 
      }
    

13. 点击页面右下角的更新信任策略按钮。

14. 您应该查看为您的角色更新的受信任实体。

您现在已经完成。在本节中，您学习了如何更新 Amazon SageMaker 笔记本实例的 IAM 角色，添加权限策略、添加自定义内联策略，最后，编辑信任关系以添加您解决方案构建所需的受信任实体。您现在可以返回到之前导航到此章节的地方，继续您的解决方案构建任务。

克服文档处理中的挑战

自动化运营活动对于希望最小化成本、提高生产力并实现更快市场推广周期的组织来说至关重要。通常，这些企业核心运营活动会优先进行自动化。后勤支持流程，包括行政任务，通常被排在优先级列表的底部，因为它们可能不被视为至关重要。根据这份行业分析师报告（www.industryanalysts.com/111015_konica/，撰写于 2015 年，数据来源包括 Gartner Group、AIIM、美国劳动部、Imaging Magazine 和 Coopers and Lybrand， 并且 于 2021 年 3 月 30 日访问），组织仍然依赖纸质文档，而维护这些文档所需的工作量由于缺乏自动化和文档工作流中的低效，给企业带来了重大挑战。

许多组织，如金融机构、医疗保健、制造业以及其他中小型企业，拥有大量扫描和手写文档。这些文档可能采用多种格式，如发票、收据、简历、申请表等。此外，这些文档并不是集中存放的，而是分散在各个地方，这使得从这些文档中提取有用的信息变得非常困难。假设你有一个文档档案库，你希望从中提取数据。假设我们构建了一个应用程序，可以让你轻松地在这些档案库中的大量文档中进行搜索。从这些文档中提取数据对你来说非常重要，因为它们包含了许多对你的组织有用的信息。一旦你提取出所需的信息（当然，我们首先需要确定哪些是有用的，哪些不是），你就可以做很多事情，比如发现业务背景、建立合规性、为重要关键词设计搜索和发现功能，甚至自动化现有的业务流程。

随着时间的推移，我们看到越来越多的组织由于易于与其运营系统集成而开始拥抱数字媒体来处理业务流程，但纸质文档不会很快消失。根据这篇文章（medium.com/high-peak-ai/real-time-applications-of-intelligent-document-processing-993e314360f9，2021 年 3 月 30 日访问)，实际上，组织中纸质文档的使用在增加。因此，自动化文档处理工作流变得非常重要。

那么，纸质文档的问题是什么呢？问题在于使用传统方法从文档中提取数据所需的成本和时间。最常见的方法之一是人工处理这些文档。什么是人工处理？就是人工阅读文档，然后将所有的数值输入到应用程序中，或者复制粘贴到另一个文档中。这种方法效率低下且成本高昂：不仅需要投入时间和精力培训人工劳动力，使其理解所处理的数据领域，而且由于人为因素，数据输入过程中可能会出现错误。例如，在处理税务表格和财务表格时，你需要一位经验丰富的注册会计师（CPA）来进行手动输入，因为这需要会计知识来提取所需的详细信息。因此，我们可以看到，传统的人工处理文档的方法既耗时、易出错，又成本高昂。

我们看到的另一种方法是，组织使用基于规则的格式化模板与 光学字符识别 (OCR) 系统结合，从这些文档中提取数据。该方法的挑战在于，这些基于规则的系统没有足够的智能来适应不断变化的文档格式，甚至在模板稍有变化时也会出现故障。随着业务的增长和扩展，其基础流程需要灵活性以适应，这通常导致需要处理多个文档结构，可能达到数百甚至数千种格式。尝试为每种文档类型设置和管理这些格式，很快就会变成一个巨大的维护负担，一旦文档格式发生变化，基于规则的系统就变得难以更新这些格式。另一个需要考虑的挑战是基础设施的配置以及处理数百万份此类文档所需的扩展性和相关成本。

这就是我们拥有 Amazon Textract 的原因，它是一个完全托管的机器学习和人工智能服务，具备开箱即用的功能，可以从图像和 PDF 文档中提取表单、表格和页面中的手写和印刷文本。Textract 提供了 应用程序编程接口 (APIs)，背后运行着强大的机器学习模型，这些模型经过数百万文档的训练，提供了一种高效的智能文本提取解决方案。

因此，我们在本节中讨论了处理文档的挑战以及为什么我们需要 Amazon Textract。在下一节中，我们将讨论 Amazon Textract 如何帮助组织快速解决这一痛点。

了解 Amazon Textract 如何提供帮助

我们在第一章中简要介绍了 AWS AI 服务，即 业务背景中的自然语言处理和 AWS AI 服务简介，并介绍了 自然语言处理的业务背景。Amazon Textract 是 AWS AI 服务堆栈中的一个基于 OCR 的服务，提供现成的智能功能，使您无需任何机器学习经验就可以使用它进行文档处理工作流。值得注意的是，Amazon Textract 的起源来自为 Amazon.com 构建的深度学习机器学习模型。它配备了一个预训练模型，并提供 API，您可以通过这些 API 发送 PDF 或图像格式的文档，并得到以文本、表格和键值对的形式返回的响应，并附带一个置信度分数。

注意

Amazon Textract 目前支持 PNG、JPEG 和 PDF 格式。

Amazon Textract 提供了无服务器的 API，无需管理任何基础设施，使你能够快速自动化文档管理并扩展到处理数百万份文档。一旦提取了文档内容，你可以在你的业务应用中使用这些数据，处理各种行业和运营需求的文档处理场景。Amazon Textract 的模型会随着使用不断学习，因此随着你继续使用，它们会变得更加智能，更好地理解你的文档。请参阅以下列表，了解我们将在接下来的章节中介绍的部分 Amazon Textract 使用案例：

• 自然语言处理 (NLP) 用于文本提取 – 本应用场景将展示一个端到端的示例，如何使用 Textract 从文档中提取文本，然后对文本应用 NLP 技术以得出洞察。我们将在 第三章**，Amazon Comprehend 入门 中介绍一些关键概念和示例。

• 快速建立自动化文档处理工作流 – 在这个应用场景中，我们将展示如何使用 Textract 和其他 AWS 服务构建一个解决方案，自动化常见的文档管理任务，如贷款申请审批工作流，从而实现成本和时间节省。这个应用场景将在 第四章**，自动化文档处理工作流 中进行介绍。

• 构建可扩展的智能集中式搜索索引 – Amazon Textract 使你能够从扫描文档中提取数据并将其存储在 Amazon S3 中。Amazon S3 是一种具有成本效益和可扩展性的对象存储解决方案。存储在 Amazon S3 中的数据可以通过 Amazon Elasticsearch 索引，从而使你的档案可搜索。你还可以通过将数据迁移到 Amazon S3 来创建一个集中式搜索解决方案，整合你分散的数据。我们将在 第五章**，创建 NLP 搜索 中详细介绍这个应用场景。

• 在档案文档中实施合规性 – 由于 Textract 本身的机器学习功能，它可以自动识别页面、表格和表单中的文本。当你想构建依赖于文档元数据来确定业务流程合规性的智能系统时，这一功能尤其有用。我们将在 第六章**，利用 NLP 提高客户服务效率 中查看这个应用场景的示例。

• 将自动化数据捕捉从表单集成到现有应用程序/聊天机器人中 – Amazon Textract 提供了 API，可以在您的应用程序中使用，支持多种文档类型。例如，您可能需要查询供应商的收据，并将其作为运营决策的一部分。在这个用例中，我们将看到如何通过 Amazon Lex（aws.amazon.com/lex/）将聊天机器人与您的文档处理应用程序结合使用。详细内容将在第八章《利用自然语言处理将您的媒体内容变现》中讲解。

如您所见，Amazon Textract 可用于多种类型的文档处理用例，并提供了传统基于规则系统或 OCR 解决方案中找不到的若干高级功能。您可以在此处阅读其中一些好处：

• 文本？结构化？非结构化？Textract 来拯救: Amazon Textract 使用 AI 和机器学习（ML）来检测表格中的结构化文本以及来自文档的非结构化文本，如页面、行和单词中的文本数据。Amazon Textract 首先确定文档的布局，然后检测文档中的内容类型及其关系和上下文，再进行提取。它还为每个检测到的文本、表格和键/值对提供置信度分数。我们将在下一节看到一些示例。

• Amazon Textract 克服了 OCR 的局限性: 虽然 Amazon Textract 隐式使用 OCR，但这并不是唯一的好处。您无需担心维护各种模板和格式，因为它使用的是机器学习，而不是基于模板的方法。因此，它适用于跨行业使用的各种文档模板，例如发票、收据、雇佣表格、简历、税务准备文件、医疗索赔表格、技术规范等。

• 安全性和合规性: 安全性是 AWS 的最高优先级。Amazon Textract 遵循共享责任模型（aws.amazon.com/compliance/shared-responsibility-model/）。

  要了解 Amazon Textract 的安全性和合规性功能，请参考docs.aws.amazon.com/textract/latest/dg/security.html。Amazon Textract 通过多个 AWS 合规程序，包括 系统和组织控制（SOC）、国际标准化组织（ISO），以及 PCI 和 HIPAA，进行合规认证。有关更多细节，请参考docs.aws.amazon.com/textract/latest/dg/SERVICENAME-compliance.html。

• 简易集成到应用程序的 API：Amazon Textract 提供 Java、Python 和其他语言的 API。这些 API 背后运行强大的 ML 模型，可以轻松从文档中提取文本。有关 API 的详细讲解，请参见 在应用程序中使用 Amazon Textract 部分。

• Amazon Textract 是无服务器和可扩展的：Amazon Textract 是一项完全托管的无服务器服务，它会根据你需要处理的文档量自动扩展。它能够扩展以应对更多需求，并在需求减少时缩减规模。

• 成本效益：Amazon Textract 的定价类似于其他完全托管的 AWS 服务。客户仅需为实际使用的部分付费。例如，在 us-east-1 区域处理一页文档的费用为 $0.0015。为了让你能够快速入门，我们提供了免费层。更多详情，请参见 aws.amazon.com/textract/pricing/。

在本节中，我们简要列出了 Amazon Textract 可以帮助解决的一些有趣的文档处理用例，并回顾了 Amazon Textract 的一些关键优势，如预构建的智能、成本效益、可扩展性和易用性。在下一节中，我们将使用 AWS 管理控制台（console.aws.amazon.com/）来演示 Amazon Textract 的产品特性，如表格检测、表单检测、手写检测、文本检测以及多语言支持。

演示 Amazon Textract 的产品特性

好的，现在是时候开始探索我们一直在谈论的酷炫功能了。我们将从查看如何快速上传我们 GitHub 仓库中提供的示例文档开始（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services）。接下来，我们将演示 Amazon Textract 的关键特性，并使用一个法语 COVID-19 表单来展示多语言支持。我们还将介绍 Amazon Textract 与 Amazon A2I 的集成，A2I 可以帮助你快速设置一个人工审核工作流，适用于需要高度准确的文本，如发票金额（aws.amazon.com/augmented-ai/）的高层次处理。我们将涉及以下内容：

1. 登录到你的 AWS 管理控制台。

2. 上传示例文档。

3. 原始文本或文本提取。

4. 关键值提取或表单值提取。

5. 表格提取。

6. 多语言支持。

7. 手写识别。

8. 支持 Amazon Augmented AI 或 A2I 进行人工介入。

作为第一步，请参阅 技术要求 部分，注册一个 AWS 账户并登录开始使用。

上传示例文档。

现在，让我们看看如何将文档上传到 Textract：

1. 从 GitHub 仓库下载示例文档（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2002/employment_history.png）。

2. 在您的 AWS 管理控制台中，进入 Textract，然后选择 Amazon Textract。

3. 现在点击尝试 Amazon Textract，然后点击上传文档按钮选择您在步骤 1中下载的文档：

图 2.1 – 点击 Amazon Textract 控制台的上传文档按钮

这将把文档上传到 Amazon Textract：

图 2.2 – Employment application.png

原始文本或文本提取

在 Amazon Textract 控制台中显示以下分析：

图 2.3 – Amazon Textract 文本提取控制台

点击原始文本选项卡查看提取的文本：

图 2.4 – Amazon Textract 文本响应为行和单词

注

Amazon Textract 支持旋转文档。请参阅 docs.aws.amazon.com/textract/latest/dg/limits.html 获取有关 Textract 服务限制的更多详细信息。

处理多页文档

Amazon Textract 具有识别多种文档格式的智能功能，并能相应地提取内容。例如，您可能正在处理报告或带有多个段落的提案文档。请下载图 2.4中显示的图像（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2002/two-column-image.jpeg），并将其上传到 Amazon Textract 控制台以尝试：

图 2.5 – 多页扫描图像示例

Amazon Textract 将提取页面、段落、行和单词，并提供这些单词和段落在文档中的确切位置，这对于上下文非常重要。查看以下屏幕截图以了解使用 Textract 获得的边界框或几何形状：

图 2.6 – Textract 检测文本的边界框响应

这是 AWS 控制台中此文档的截图：

图 2.7 – 在 AWS 控制台中使用 Amazon Textract 提取的多页扫描图像文本响应

表单数据和键值对

Amazon Textract 会对文档进行分段，以识别表单，从而返回表单中的键值对。我们将使用来自 GitHub 仓库的就业申请示例文档模板（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2002/emp_app_printed.png），这是你从 GitHub 仓库下载的：

1. 在 Amazon Textract 控制台中点击上传文档按钮：

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_02_08.jpg)

   图 2.8 – 在 Textract 控制台中的上传文档按钮

2. 点击表单标签。你将看到提取的键值对，如下所示：

](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_02_09.jpg)

图 2.9 – 在 Amazon Textract 控制台中提取示例文档表单和键值对

表格提取

Amazon Textract 能够识别文档中是否包含表格结构的内容，例如收据，或技术规格清单、药房处方数据等。Textract 还允许你指定是否在使用 API 时应查找文档中的表格。除了表格及其内容，Textract 还会返回表格内容的元数据和索引信息，你可以在后面的 API 演示中了解更多内容。在此演示中，你可以下载这个示例收据（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2002/receipt-image.png）并将其上传到 Amazon Textract 控制台。你将看到以下截图中提取的表格：

图 2.10 – 在 Amazon Textract 控制台中提取示例收据的表格。

多语言支持

Amazon Textract 提供多语言文本提取支持。有关最新支持的语言列表，请参阅此链接：aws.amazon.com/textract/faqs/。

注意

当前支持手写文本识别的语言仅为英语（截至写作时为2021 年 4 月）。

在法国 COVID 封锁期间，任何想要离开家的人都必须填写一份声明表单，解释他们外出的原因。我们将使用此示例表单来演示 Amazon Textract 的法语语言检测功能。该表单可通过 www.connexionfrance.com/French-news/Covid-19-in-France-Your-questions-on-declaration-form-needed-to-leave-the-house 获取。

你也可以从github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2002/form-derogatoire.jpg下载此表单，并将其上传到 Amazon Textract 控制台。点击原始文本标签，然后选择表单：

图 2.11 – 从示例扫描的法语 COVID 表单中提取的法语数据

Amazon Textract 能够从这张法语表单中提取键值对和原始文本。

手写识别

客户在数据提取中面临的另一个非常常见的挑战是混合内容文档，例如手写文本和打印文本混合的文档。例如，这可能是一张医生为病人开具的处方表单，纸张上印有医生的名字和地址。这也带出了 Amazon Textract 的另一个关键功能：从文档中识别手写内容：

1. 从 GitHub 仓库下载手写发票样本(github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2002/sample-invoice.png)。

2. 将样本上传到 Amazon Textract 控制台，如图 2.12所示。Amazon Textract 可以从样本文档中提取手写文本和打印文本的键值对（表单数据）、表格和文本：

   图 2.12 – 从示例发票中提取的手写及打印文本

3. 你可以切换到表单和表格标签，查看 Amazon Textract 如何快速提取来自此样本文档的手写和打印内容。

人类参与

Amazon Textract 提供与Amazon A2I的内建集成（aws.amazon.com/augmented-ai/）。使用 Amazon A2I，您可以构建人工工作流，管理需要进一步人工审核的文档，进行审计或只是检查机器学习预测。例如，社保号码或货币金额可能需要高度准确。它类似于通过 AI 获得文本的初步处理，然后让人工团队核对 AI 为您预测的内容。

当我们进入*第十七章**，《从手写内容中可视化洞察》时，我们将详细讲解手写识别和人工审核流程。

最后，Textract 控制台提供了下载和查看 JSON 文档的选项，这些文档是我们所演示的各种 Textract 特性调用 API 后的响应结果：

图 2.13 – 从控制台下载 Textract 结果

在本节中，我们介绍了 Amazon Textract 的关键产品功能，如何从 PDF 和图像文档中提取文本、表单、表格和手写内容，包括对多语言文档的支持。在下一节中，我们将回顾如何使用 Amazon Textract API，详细解析 JSON 响应，并理解如何将 Textract 与您的应用程序结合使用。

将 Amazon Textract 与您的应用程序结合使用

在本节中，我们将介绍并演示 Amazon Textract API，用于文档的实时分析和批量处理。我们将通过 Amazon SageMaker Jupyter 笔记本展示这些 API 的实际应用。在本节中，您需要创建一个 Amazon SageMaker Jupyter 笔记本，并为该笔记本角色设置IAM权限，以便访问 Amazon Textract。之后，您需要从我们的 GitHub 仓库克隆笔记本（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services），下载示例图像，创建一个 Amazon S3（aws.amazon.com/s3/）桶，将这些图像上传到 S3 桶，然后在笔记本中引用该位置进行处理。

让我们开始吧：

1. 有关创建 Amazon SageMaker 笔记本实例的说明，请参见本章开头的设置 AWS 环境部分中的创建 Amazon SageMaker Jupyter 笔记本实例子节。或者，您可以参考 Amazon SageMaker 文档来创建笔记本实例：docs.aws.amazon.com/sagemaker/latest/dg/gs-setup-working-env.html。

   创建 Amazon SageMaker Jupyter 笔记本时的 IAM 角色权限

   首先，在创建笔记本时接受 IAM 角色的默认设置，以便访问任何 S3 桶。笔记本实例创建后，按照本章开头设置 AWS 环境部分下的子节：更改 IAM 权限和信任关系以执行 Amazon SageMaker 笔记本角色中的说明，添加 AmazonTextractFullAccess 作为笔记本 IAM 角色的权限策略。

2. 创建笔记本实例并且状态为InService后，在笔记本实例的操作菜单下点击打开 Jupyter：

   图 2.14 – 打开 Jupyter 笔记本

   这将带你进入笔记本实例的主文件夹。

3. 点击新建并选择终端，如下面的截图所示：

   图 2.15 – 在 Jupyter 笔记本中打开终端

4. 在终端窗口中，首先输入cd SageMaker，然后输入git clone https://github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services，如下面的截图所示：

   图 2.16 – git clone 命令

5. 现在，退出终端窗口，返回到主文件夹，你会看到一个名为Chapter 02的文件夹。打开该文件夹，你应该能看到一个名为Amazon Textract API Sample.ipynb的笔记本。点击打开此笔记本。

6. 按照本笔记本中的步骤执行，每次执行一个单元格，步骤对应于本节接下来的子标题。请阅读每个笔记本单元格上方的描述。

Textract API

在演示如何使用 Textract API 之前，我们将先探讨这些 API 及其功能。Amazon Textract API 可分为同步 API（用于实时处理）和异步 API（用于批处理）。现在我们来了解这些 API 的功能。

用于实时处理的同步 API

这些 API 从你现有的本地文件系统（如本地计算机）或 Amazon S3 桶中获取单页扫描图像（JPG 或 PNG）。有两个 API 用于实时分析：

• 文档文本检测 API：该 API 将从扫描的图像中提取单词和行。你可以在只需要从扫描中提取文本内容且数据中没有表单或表格的情况下使用此 API，比如故事书、学生考试卷和扫描的新闻文章。你还可以在网页或移动应用中使用此 API 快速扫描文档中的文本内容。另一种使用此 API 的方式是提取文本数据并对其进行进一步的自然语言处理（NLP），例如识别段落和标题，执行关键/值对的数据标注，或将其用于下游处理。

  键/值对

  在表单的情况下，键/值对的键将是名称，值将是“Jane Doe”。

• Analyze Document API：该 API 功能更为全面，可以帮助您从扫描的图像中提取文本，并识别文档中的表单（键/值对）和表格。您可以将此 API 用于各种类型的文档，如发票、收据、医疗登记表、简历、税表以及各种财务表格。您可以创建一个应用程序，用户拍摄收据照片，然后使用此 API 对发票进行快速分析，提取金额或发票 ID。

用于批量处理的异步 API。

这些 API 接受上传到 Amazon S3 存储桶的单页或多页图像（JPG/PNG）和 PDF 文件。它执行批量分析，从这些图像和文档中提取内容：

• AnalyzeDocument 同步 API 的功能，因为它将从输入文档中提取文本、表格和表单数据。不同之处在于，该 API 还支持 PDF 文档。输入文档应存储在 Amazon S3 存储桶中，并提供其 S3 URL 给该 API。此 API 将启动文档分析的批处理作业。

• StartDocumentAnalysis 操作以键/值对、表格和文本的形式进行。这也会返回作业 ID 及其成功或失败状态。

• DetectDocumentText API 的功能，它批量检测已上传到 Amazon S3 存储桶的文档中的文本。我们将在 Python notebook 示例中看到该 API 演示。

• StartDocumentTextDetection 操作以行和字的形式进行。这还会返回作业 ID 及其成功或失败状态。

  注意

  批量 API 可与存储在 Amazon S3 存储桶中的 JPEG、PNG 和 PDF 文档一起使用。

在本节中，我们介绍了 Amazon Textract 的批量和实时 API。在下一节中，我们将通过您在上一节中设置的 Jupyter notebook 来实现这些 API。

使用 Jupyter notebook 演示 Textract API。

在本节中，我们将通过 Jupyter notebook 提供 Textract API 的实现。我们将执行您在 github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2002/Amazon%20Textract%20API%20Sample.ipynb 中设置的 Jupyter notebook 代码单元，该 notebook 您在前一步骤中已克隆。该 notebook 包含先决步骤，我们将在这里详细讲解所有 API 的完整代码。书中只提供了重要的代码片段，如下所示：

• DetectText API 使用来自本地文件系统的文档，以图像字节的形式传递。

• 使用传递自 S3 的文档，通过 AnalyzeText API 检测发票中的文本、表单和表格。

• 使用 StartDocumentText 和 GetDocumentText API 对就业申请表进行批量处理。

DetectText API。

让我们开始吧：

1. 打开笔记本并执行第一个单元格，导入 boto3 库，以设置 Amazon Textract boto3 Python SDK。

2. 请参照笔记本设置和安装 boto3：

   1. 设置 Amazon S3 Python SDK boto3 客户端：boto3.amazonaws.com/v1/documentation/api/latest/reference/services/s3.html：

      s3 = boto3.client('s3')
      

   2. 设置 Amazon Textract Python SDK boto3 客户端：boto3.amazonaws.com/v1/documentation/api/latest/reference/services/textract.html：

      textract = boto3.client('textract')
      

3. 从 github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2002/sample-invoice.png 下载示例文档。如果您已经克隆了这个 GitHub 仓库，您无需重新下载示例文件，直接在笔记本的 Chapter 02 中引用它们即可。

4. 请按照 设置 AWS 环境 部分中的 创建 Amazon S3 存储桶和文件夹并上传对象 小节的说明，创建一个 S3 存储桶并上传您的示例文档。

5. 复制您创建的 Amazon S3 存储桶的名称，并粘贴到笔记本中，以便指向您上传的示例文档：

   s3BucketName = "<your amazon s3 bucket>" 
   

6. 这是我们在这个笔记本中将使用的图像：

   documentName = "sample-invoice.png"
   display(Image(filename=documentName))
   

   这将显示以下图像：

   

   图 2.17 – 一个示例收据

7. 让我们回到笔记本并运行以下代码，看看 Amazon Textract 的 DetectText API 是如何工作的。

   以下代码将读取文档内容，形式为图像字节：

   with open(documentName, 'rb') as document:
       imageBytes = bytearray(document.read())
   

8. 以下代码将通过传递来自您本地文件系统的图像字节来调用 Amazon Textract：

   response = textract.detect_document_text(Document={'Bytes': imageBytes})
   

   您将图像字节直接传递给该 API 并获取 JSON 响应。该 JSON 响应的结构包含识别的文本块、页面、行、边界框、表单键值和表格。为了理解 Amazon Textract 的 JSON 结构和数据类型，请参考此链接：docs.aws.amazon.com/textract/latest/dg/API_Block.html。

9. 现在我们将导入 JSON Python 包，以便打印我们的 API 响应：

   import json
   print (json.dumps(response, indent=4, sort_keys=True))
   

10. 以下展示了文档中一行的示例 JSON 响应。它包括块、块类型、检测该块类型行的置信度分数，以及使用边界框标示的该行的几何位置，和识别的文本：

    {
                "BlockType": "LINE",
                "Confidence": 99.96764373779297,
                "Geometry": {
                    "BoundingBox": {
                        "Height": 0.013190358877182007,
                        "Left": 0.5149770379066467,
                        "Top": 0.16227620840072632,
                        "Width": 0.06892169266939163
                    },
    
    

    注意

    这个 API 不会返回表单和表格。它只返回行、单词及相应的边界框。这个 API 对于像审计文档中的段落检测和从扫描书籍中提取文本等用例非常有用。

执行笔记本中的其余单元，以详细探索 JSON 响应。

DetectDocument API

现在，我们将向您展示如何使用 DetectDocument API 检测双栏文档中的文本，并按阅读顺序显示，数据存储在 Amazon S3 存储桶中：

1. 从 github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2002/two-column-image.jpeg 下载示例文档。如果您已经克隆了这个 GitHub 仓库，就不需要重新下载示例，您可以直接在 Chapter 02 中引用它。

2. 使用此处的说明将这些文档上传到您的 Amazon S3 存储桶中的 textract-samples 前缀：docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html。

3. 显示来自 Amazon S3 存储桶的输入文档：

   documentName = "textract-samples/two-column-image.jpg"
   display(Image(url=s3.generate_presigned_url('get_object', Params={'Bucket': s3BucketName, 'Key': documentName})))
   

4. 通过指定 Amazon S3 存储桶和文件名来调用 DetectDocumentText API，如以下代码片段所示。我们还将打印响应以检查结果：

   Response = textract.detect_document_text(
       Document={
           'S3Object': {
               'Bucket': s3BucketName,
               'Name': documentName
           }
       })
   print(response)
   

   注意

   关于 DetectDocumentText API 的更多详细信息，请参阅此链接：boto3.amazonaws.com/v1/documentation/api/latest/reference/services/textract.html#Textract.Client.detect_document_text。

5. 一旦获得响应，我们将使用以下代码解析多页文档中的按阅读顺序排列的行。我们将使用 Amazon Textract JSON 响应解析器来获取按阅读顺序排列的行。请运行此命令安装该库：

   python -m pip install amazon-textract-response-parser 
   

6. 现在，运行以下代码，以查看多列格式文档中逐行打印的结果：

   doc = Document(response)
   for page in doc.pages:
       for line in page.getLinesInReadingOrder():
             print(line[1])
   

   您将获得以下响应：

图 2.18 – 按阅读顺序排列的 Textract 响应行

AnalyzeDocument API

现在我们将使用 AnalyzeDocument API 分析发票，提取表单和表格：

1. 调用 Amazon Textract AnalyzeDocument API：

   response = textract.analyze_document(
       Document={
           'S3Object': {
               'Bucket': s3BucketName,
               'Name': documentName
           }
       },
       FeatureTypes=["FORMS","TABLES"])
   

2. 运行以下代码以解析键/值对并搜索键。为了便于解析 Textract 响应，您可以使用 Amazon Textract 响应解析器库。我们将使用它来提取数据并搜索一些键：

   doc = Document(response)
   for page in doc.pages:
       print("Fields:")
       for field in page.form.fields:
           print("Key: {}, Value: {}".format(field.key, field.value))
   

3. 在以下代码中，我们正在查找文档中的 Phone Number 键：

       print("\nGet Field by Key:")
       key = "Phone Number:"
       field = page.form.getFieldByKey(key)
       if(field):
           print("Key: {}, Value: {}".format(field.key, field.value))
   

4. 在以下代码中，我们正在查找文档中的 Address 键：

       print("\nSearch Fields:")
       key = "address"
       fields = page.form.searchFieldsByKey(key)
       for field in fields:
           print("Key: {}, Value: {}".format(field.key, field.value))
   

   您将获得以下输出：

   Fields:
   Key: Phone:, Value: 206-555-1234
   Key: Phone:, Value: None
   Key: Phone:, Value: None
   Key: COMMENTS OR SPECIAL INSTRUCTIONS:, Value: loading lack locatal in alley
   Key: SALES TAX, Value: 41.21
   Key: SHIPPING and HANDLING, Value: 50.00
   Key: REQUISITIONER, Value: None
   Key: SUBTOTAL, Value: 457.9n
   Key: TOTAL DUE, Value: 549.15
   Key: SALESPERSON, Value: John SMITH
   Key: SHIP TO:, Value: Jane Doe Doe Street Press 987 Doe St. #800 Seattle, WA 98108 206-555-9876
   Key: P.O. NUMBER, Value: 0000145678
   Key: TO:, Value: Jane Doe Doe Street Press 987 Doe St. #800 Seattle, WA 98108 206-555-9876
   Key: DATE:, Value: 01/10/2021
   

5. 要从 JSON 响应中解析表格，请参阅以下代码片段：

   doc = Document(response)
   for page in doc.pages:
        # Print tables
       for table in page.tables:
           for r, row in enumerate(table.rows):
               for c, cell in enumerate(row.cells):
                   print("Table[{}][{}] = {}".format(r, c, cell.text))
   

6. 您将看到以下响应：

   Table[0][0] = QUANTITY 
   Table[0][1] = DESCRIPTION 
   Table[0][2] = UNIT PRICE 
   Table[0][3] = TOTAL 
   Table[1][0] = 4 
   Table[1][1] = OFFILE GARS 
   Table[1][2] = 64.99 
   Table[1][3] = 25996 
   Table[2][0] = 2 
   Table[2][1] = OFFICE DESX 
   Table[2][2] = 98.99 
   Table[2][3] = 197.98 
   

   注意

   您可以将这些值转换为 pandas DataFrame，我们将在第十六章中讨论，提高 PDF 批处理精度。

   要了解更多有关 API JSON 响应的信息，请参考此链接：https://docs.aws.amazon.com/textract/latest/dg/how-it-works-tables.html。

使用 Textract 异步 API 处理 PDF 文档

在本节中，你将看到如何使用 Textract 异步 API 分析 PDF 文档，以处理示例工作申请表：

图 2.19 – 一份示例工作申请文件

1. 以下代码将帮助你开始使用StartDocumentText API 和GetDocumentText API：

   jobID = startTextAnalysis(s3Bucket, docName)
   print("Started text analysis for: {}".format(jobID))
   if(isAnalysisComplete(jobID)):
       response = getAnalysisResults(jobID)
   

2. 在这个startTextAnalysis方法中，你调用StartDocumentTextDetection API 来启动文本分析任务：

   def startTextAnalysis(s3Bucket, doc):
       response = None
       response = textract.start_document_text_detection(
       DocumentLocation={
           'S3Object': {
               'Bucket': s3Bucket,
               'Name': doc
           }
       })
       return response["JobID"]
   

3. 一旦启动分析，你可以使用以下方法检查分析是否完成：

   def isAnalysisComplete(jobID):
       response = textract.get_document_text_detection(JobId=jobID)
       status = response["JobStatus"]
       print("Text Analysis status: {}".format(status))
       while(status == "IN_PROGRESS"):
           time.sleep(2)
           response = textract.get_document_text_detection(JobId=jobID)
           status = response["JobStatus"]
           print("Status of Text Analysis is: {}".format(status))
       return status
   

4. 一旦任务完成，你可以使用GetDocumentTextDetection API 获取结果：

   def getAnalysisResults(jobID):
       pages = []
       response = textract.get_document_text_detection(JobId=jobID)
       pages.append(response)
       print("We received results for: {}".format(len(pages)))
       nextToken = None
       if('NextToken' in response):
           nextToken = response['NextToken']
       while(nextToken):
           response = textract.get_document_text_detection(JobId=jobId, NextToken=nextToken)
           pages.append(response)
           print("We got the results for: {}".format(len(pages)))
           nextToken = None
           if('NextToken' in response):
               nextToken = response['NextToken']
       return pages
   

演示已完成。希望你有机会回顾并使用不同的 Textract API 进行实时和批量处理，并成功完成了你的笔记本。在接下来的部分，我们将展示如何使用这些 API 构建无服务器应用程序。

使用 Amazon Textract API 构建应用程序

我们已经讨论了同步（或实时）API 和异步（或批量）API。现在，问题是如何将这些 API 集成到应用程序中。你可以通过使用 AWS Lambda 快速将这些 API 集成到 Web 应用程序或任何批处理系统中。AWS Lambda 以无服务器的方式运行任何代码，无论是 Java 还是 Python。这是一种基于事件的触发或编程技术，你可以根据事件触发 Lambda 函数。例如，你将文档上传到 Amazon S3，这可以触发 Lambda 函数。在该 Lambda 函数中，你可以调用 Amazon Textract API 并将结果保存到 Amazon S3：

](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_02_20.jpg)

图 2.20 – 使用 Amazon Textract 构建无服务器架构，以便与你的应用程序一起使用

我们将在接下来的章节中详细讨论架构，届时我们将讨论如何使用 Amazon Textract 的同步和异步 API 构建应用程序。我们还将讨论如何使用 AWS API Gateway 创建 RESTful API，以便将其集成到你的 Web 应用程序或移动应用程序中。

总结

在本章中，我们详细介绍了 Amazon Textract 及其产品功能，并进行了控制台操作演示，还展示了使用 Textract API 针对不同类型的文档进行实时和批量分析的代码示例。

我们首先介绍了 Amazon Textract 提供的现成智能，借助强大的预训练机器学习模型以及通过 API 调用将其能力集成到应用程序中的能力。我们还了解了 Textract 的一些常见使用案例，并引用了以下章节中的一些内容，在这些章节中我们将更详细地回顾这些使用案例。我们还了解了与传统 OCR 应用程序和基于规则的文档处理相比，Textract 的优势。

我们介绍了如何将 Amazon Textract 与不同类型的扫描图像和表单结合使用的各种示例。我们回顾了 Textract 的不同功能，例如检测原始文本、检测以键值对形式存储的表单值、检测表格中的文本、检测文本页面、检测行和单词、检测手写文本和打印文本，以及检测多语言文本，还包括检测文档中以双栏样式编写的文本。我们讨论了如何使用 Textract API 进行同步处理和异步处理。我们还了解了如何设置 Amazon SageMaker Jupyter notebook，克隆 GitHub 仓库，并开始运行 Jupyter notebook。我们能够使用 Amazon S3 桶存储输入文档，并将其与 Textract 一起使用，提取来自非结构化文档的数据并将其存储在 Amazon S3 桶中。

在本章中，我们还介绍了 Amazon Textract 实时 API，例如 AnalyzeDocument API 和 DetectDocumentText API。我们讨论了这些 API 的预期输入文档格式及其限制。接着我们讨论了如何为需要批量提取数据的使用案例扩展文档处理。我们了解了 批量处理 API 以及 Python SDK 演示。最后，我们介绍了如何使用 AWS Lambda 将 Textract 集成到应用程序中的架构。

在下一章中，您将了解 Amazon Comprehend，这是一项使用机器学习（ML）来发掘文本中洞察的人工智能服务。您将学习不同的自然语言处理（NLP）技术，回顾 Amazon Comprehend 的功能，了解其 API，学习如何使用 Comprehend 设置自定义的 NLP 模型来检测您业务中独特的实体，正如我们在本章中所做的那样，您将看到 Comprehend 在不同使用案例中的实际应用。

第三章：第三章：介绍 Amazon Comprehend

在上一章中，我们介绍了如何使用Amazon Textract进行光学字符识别（OCR）并深入探讨了它的功能和特定的 API 实现。在本章中，你将详细了解Amazon Comprehend和Amazon Comprehend Medical，它们的功能是什么，创建它们的业务挑战是什么，它们具有哪些功能，适用于哪些用户需求，以及如何轻松地将 Comprehend 与不同的AWS服务集成，如AWS Lambda，以构建业务应用程序。

在本章中，我们将涵盖以下内容：

• 了解 Amazon Comprehend 和 Amazon Comprehend Medical

• 探索 Amazon Comprehend 和 Amazon Comprehend Medical 产品功能

• 将 Amazon Comprehend 与你的应用程序集成

技术要求

本章中，你需要访问附加到笔记本实例的 AmazonComprehendFullAccess IAM 角色，并按照以下步骤操作：

1. 一旦你创建了笔记本实例，并且其状态为InService，请在笔记本实例的操作菜单下点击打开 Jupyter。

2. 在终端窗口中，首先输入cd SageMaker，然后输入git clone github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services。Amazon Comprehend 示例的 Python 代码和示例数据集在此仓库中：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services。进入仓库后，请选择第三章，介绍 Amazon Comprehend – 示例代码。

查看以下视频，观看bit.ly/3Gkd1Oi中的代码实战。

了解 Amazon Comprehend 和 Amazon Comprehend Medical

在本节中，我们将讨论设置ML（ML）预处理时与NLP（NLP）相关的挑战。然后，我们将讨论 Amazon Comprehend 和 Amazon Comprehend Medical 如何帮助解决这些痛点。最后，我们将讨论如何使用 Amazon Comprehend 分析通过使用 Amazon Textract 提取数据的文档中的提取文本。

设置 NLP 的 ML 预处理时面临的挑战

设置 NLP 预处理时的一些关键挑战是文档可能是半结构化的、非结构化的，或者可能是多种语言。 一旦你拥有大量的非结构化数据，你可能希望使用一些 NLP 技术从数据中提取洞察，用于大多数常见用例，如情感分析、文本分类、命名实体识别 (NER)、机器翻译和主题建模。

图 3.1 – NLP 建模

应用这些技术的挑战在于，大部分时间都花费在数据预处理上。这适用于无论你是做机器学习（例如情感分析），还是进行深度学习以应用关键的自然语言处理（NLP）技术来发现洞察。如果你在做机器学习，一些关键的预处理技术包括以下内容：

• 分词（Tokenization）：这意味着将非结构化的文本分割成单词或句子。例如，对于句子："This book is focusing on NLP"，分词后的结果将是 "This"、"book"、"is"、"focusing"、"on" 和 "NLP"。类似地，如果是复杂的文本，可以按句子而非单词进行分词。

• 停用词移除（Stop word removal）：停用词是指在句子中没有主要意义的单词，例如 "and"、"a"、"is"、"they" 等，但它们在沟通中仍然具有重要的作用。在以下文本中，停用词的例子是："This book is focusing on NLP"，其中 "is" 和 "on" 会被移除作为预处理的一部分。某些行业（例如医疗保健）中，移除停用词可能会导致语句含义的完全改变，因此在这些领域不应移除停用词。

• 词干提取（Stemming）：词干提取是指去掉一个给定单词的最后几个字符，得到一个更短的形式，即使这个形式本身没有任何意义。例如，"focusing"、"focuses" 和 "focus" 这几个单词传达的是相同的意思，可以在计算机分析中归为一个词干。因此，我们可以将它们归纳为同一个词："focus"。

• 词形还原（Lemmatization）：与此相反，词形还原是指根据单词的字典定义，将给定的单词转化为其基本形式。例如，focusing → focus。这个过程比词干提取耗时更多，并且是一个计算密集型的过程。

• 词性标注（PoS）标记：在分词之后，这种方法会将每个单词标记为一种词性。以 "This book is focusing on NLP" 为例，"book" 是名词，"focusing" 是动词。词性标记对于构建句法分析树非常有用。句法分析树用于构建命名实体识别器以及提取单词间的关系。词性标注用于构建词形还原器。词形还原器将一个单词还原为其基础形式。此外，进行词性标注有多种方法，如基于词汇的方法、基于规则的方法等。

即使在这些预处理步骤之后，如果你在预处理步骤的基础上进行深度学习，仍然需要应用高级的 NLP 技术。以下是一些常见的技术：

• Word embedding：这些是具有相似语义含义的字符串的向量表示。词嵌入是大多数深度学习 NLP 任务的起始技术，并且是 NLP 中一种流行的迁移学习方式。一些常见的词嵌入有Word2vec、Doc2Vec（用于文档）、GloVe、Continuous Bag of Words（CBOW）和Skip-gram。

• Transformers：2017 年，NLP 应用的构建方式发生了范式转变，从传统的方式（例如，使用RNN、LSTM或GRU并初始化词嵌入）转向使用 transformers。transformers 促使了如BERT（Bidirectional Encoder Representations from Transformers）和GPT（Generative Pretrained Transformer）等预训练系统的发展。BERT 和 GPT 已经使用大量的通用语言数据集进行训练，如Wikipedia Corpus和Common Crawl，并且可以针对特定的语言任务进行微调。

设置这些 NLP 模型时的一些挑战包括以下几点：

• 计算密集型过程，且需要使用 GPU 和 CPU

• 需要大规模的、有标签的数据集进行训练

• 设置基础设施来管理计算和扩展生产中的模型

• 需要大量时间，且需要机器学习技能来进行建模

为了克服这些挑战，我们有了 Amazon SageMaker，它帮助移除了构建、训练、调优和部署 NLP 模型从创意到执行的所有基础设施繁重工作。

Amazon SageMaker

你可以通过 Julien Simon 的书《Learn Amazon SageMaker》了解如何使用 Amazon SageMaker NLP 技术入门。

此外，专门谈到在 NLP 模型中实现 transformers 时，Amazon SageMaker 还支持在PyTorch、TensorFlow和HuggingFace中实现 transformers。

Hugging Face transformers包是一个非常受欢迎的 Python 库，提供了对多种 NLP 任务有用的预训练模型。参考这篇博客了解更多：aws.amazon.com/blogs/machine-learning/aws-and-hugging-face-collaborate-to-simplify-and-accelerate-adoption-of-natural-language-processing-models/。

所以，我们已经覆盖了处理 NLP 技术和建模时的一些关键挑战。借助 AWS AI 服务，如 Amazon Comprehend，你无需担心启动服务器或设置复杂的 NLP 训练基础设施。你也不需要担心我们已经覆盖的所有预处理技术，例如分词、词性标注等。

你也不需要考虑实现 transformers 来设置深度学习模型，以完成一些关键的 NLP 任务，如文本分类、主题建模、命名实体识别（NER）、关键词检测等。

Amazon Comprehend 和 Comprehend Medical 提供 API，帮助你完成一些关键的自然语言处理（NLP）任务（如情感分析、文本分类或主题建模），可以处理各种非结构化文本（如电子邮件、聊天记录、社交媒体动态或医疗笔记）。

在下一节中，我们将介绍如何在无需预处理的情况下，利用 Comprehend 和 Comprehend Medical 检测文本中的洞察。

探索 Amazon Comprehend 和 Comprehend Medical 的优势

在本节中，我们将通过讨论以下示例，介绍 Amazon Comprehend 和 Comprehend Medical 的一些关键优势：

• 集成了使用预训练深度学习模型的 NLP API。这些 API 可以添加到你的应用中，使其具备智能化功能，因为你不需要文本分析的专业知识即可使用它们。

• 提供可扩展的 NLP 处理，因其无服务器 API 使你能够分析多个文档或非结构化文本数据，而无需担心启动和管理服务器。

• 这两个服务都与其他 AWS 服务集成：AWS IAM，用于身份和访问管理；Amazon S3，用于存储；AWS Key Management Service (KMS)，用于在加密过程中管理安全密钥；AWS Lambda，用于创建无服务器架构。你可以实时分析来自 Amazon Kinesis 的流数据，或者来自 Amazon S3 的批量数据，然后使用 NLP API 获取数据洞察，并使用 Amazon Quicksight（类似于 Tableau 的可视化工具）将结果显示在仪表盘上。

• 这些服务为 Amazon S3 中的输出结果和数据提供加密功能。使用 Amazon Comprehend 时，你可以使用 KMS 密钥加密作业的输出结果，以及在处理分析任务时，计算实例存储卷上附加的数据。

• 该服务具有成本效益，因为你只需为需要分析的文本付费。

使用 Comprehend 和 Comprehend Medical 检测文本中的洞察，无需预处理

Amazon Comprehend 和 Amazon Comprehend Medical 是 AWS AI 服务，类似于 Amazon Textract（我们在第二章中介绍过的引入 Amazon Textract），你无需设置复杂的模型。你只需调用 Amazon Comprehend 和 Amazon Comprehend Medical 的 API，并发送文本请求，便会得到带有检测置信度得分的响应。Amazon Comprehend 和 Amazon Comprehend Medical 的区别在于，Comprehend Medical 专注于医疗领域的 NLP 用例。Comprehend Medical 使用机器学习从非结构化医疗文本中提取与健康相关的有意义信息，而 Amazon Comprehend 使用 NLP 从非结构化文本中识别 实体、关键词短语、语言、情感及其他常见元素，从而提取有意义的信息。

Amazon Comprehend 的一些关键应用场景如下：

• 使用话题建模根据话题搜索文档：通过 Amazon Comprehend 话题建模，您可以配置在文档或文本文件中寻找的主题数量。使用话题建模，您可以按主题搜索附带的文档。

• 使用情感分析分析客户对您产品的看法：通过 Amazon Comprehend 情感分析 API，您可以了解客户对其产品的情感（例如，正面、负面、中立或混合）。例如，假设您在 Yelp 上找到了一家餐厅，这是一家披萨店。您去那里，尝试了披萨，觉得不好，于是您发布了评论：“这里的披萨不怎么样。” 使用 Comprehend 情感分析的商家可以快速分析这段文本的情感，并在实际中采取行动，及时改善用户满意度，避免业务下滑。

• 基于话题和实体快速发现客户情感：您可以结合 Amazon Comprehend 的多项功能，例如话题建模，结合实体识别和情感分析，发现您的终端用户在各种论坛中讨论的话题。

• 带上您的数据执行自定义分类和自定义实体识别：Amazon Comprehend 为您提供了快速入门自定义实体的能力。例如，如果您是一家制造公司，并且正在寻找文件中的某些产品代码，如 PR123，系统应使用机器学习检测为产品代码。

  您可以带上您的数据样本，使用 Amazon Comprehend 自定义实体识别功能快速入门，而无需担心编写复杂的模型。您也不需要担心标注大规模数据集，因为 Amazon Comprehend Custom 在后台使用迁移学习。您可以使用少量标注数据快速开始，创建适用于您用例的自定义实体。同样，您可以带上自己的数据，执行自定义分类，进行多类和多标签分类，以识别不同类别。

在医疗记录的情况下，您可以使用 Amazon Comprehend Medical。您可以将 Comprehend Medical 用于以下医疗应用：

• 使用 Comprehend Medical API 分析病例文档，用于患者病例管理和结果分析。

• 使用 Comprehend Medical API 检测临床文本中的有用信息，以优化生命科学和研究组织的匹配过程和药物安全性。

• 使用 Comprehend Medical 提取账单编码，这可以减少涉及医疗账单的保险支付者的收入时间。

• Comprehend Medical 还支持本体链接，适用于ICD-10-CM（国际疾病分类-第 10 版-临床修改版）和RxNorm。本体链接意味着在临床文本中检测实体，并将这些实体与标准化医学本体中的概念进行关联，例如 RxNorm 和 ICD-10-CM 知识库。

• 检测 PHI 数据，例如临床文件中的年龄、日期，并设置控制措施，以便在医疗组织中实现 PHI 合规性。

我们将在 第十二章**, 医疗行业中的 AI 和 NLP 中详细讨论 Amazon Comprehend Medical 的应用场景。

使用这些服务从 Amazon Textract 中提取 OCR 文档信息

如果你的文档是扫描图像或 PDF 格式，你可以使用 Amazon Textract 从这些文档中快速提取数据，然后使用 Amazon Comprehend 从提取的文本中获得有意义的见解，例如实体、关键短语和情感。你还可以使用 Amazon Comprehend 文本分类来进一步对这些文档进行分类，并执行主题建模以识别文档中的关键主题。我们将在 第四章**, 为金融机构自动化文档处理工作流 和 第五章**, 创建 NLP 搜索 中的 创建 NLP 驱动的智能搜索索引 部分中，讲解如何将 Amazon Textract 与 Amazon Comprehend 结合使用。此外，对于医疗行业，如果你有大量扫描文档，如病人入院表格、病人记录等，你可以使用 Amazon Textract 从这些文档中提取数据，然后使用 Amazon Comprehend Medical 从这些非结构化文本数据中提取关键见解。

在本节中，我们首先讨论了设置 NLP 模型时遇到的挑战。然后，我们讨论了 Amazon Comprehend 和 Comprehend Medical 如何解决设置 NLP 模型时的痛点，例如可扩展性、预处理步骤和基础设施设置。最后，我们讲解了如何通过将 Amazon Textract 和 Amazon Comprehend 结合使用来自动化文档处理并丰富它们的 NLP 信息。我们已经介绍了 Comprehend 和 Comprehend Medical 如何提供丰富的 API 来构建智能 NLP 应用程序，这些应用程序同样具有可扩展性，可以处理大量文档或非结构化数据。在下一节中，我们将通过 AWS 控制台演示来讲解这些服务的一些产品特性。

探索 Amazon Comprehend 和 Amazon Comprehend Medical 产品特性

在本节中，我们将通过 AWS 控制台演示，讨论 Amazon Comprehend 和 Amazon Comprehend Medical 产品特性。我们将从 Amazon Comprehend 开始，然后转到 Amazon Comprehend Medical。

发现 Amazon Comprehend

Amazon Comprehend 使你能够分析你的非结构化数据，例如社交媒体信息流、帖子、电子邮件、网页、从 Amazon Textract 提取的数据、电话记录、呼叫中心记录，或者任何形式的非结构化文本数据。通过使用多个预训练模型，它可以帮助你深入理解内容的各种见解。图 3.2 是 Amazon Comprehend 实际工作流程的示意图：

图 3.2 – Amazon Comprehend 功能

使用 Amazon Comprehend，您可以通过以下 文本分析 API 在输入的非结构化文本数据上执行以下操作：

• 检测实体

• 检测关键短语

• 检测主导语言

• 检测个人身份信息（PII）

• 确定情感

• 分析语法

• 主题建模

这些文本分析 API 可以用于实时处理或批量处理，而主题建模是一个批量任务或异步过程，不能用于实时用例。

您可以使用这些 API 的两种模式：

• 在任何应用程序中的实时处理：您可以通过一次发送一个文档来使用这些 API 进行实时处理，或者通过批量实时操作一次发送 15 个文档并立即获得响应。

• 批量或异步方式：将大量数据上传到 Amazon S3，指向数据集，然后以批量任务的形式运行前述任何分析。批量任务的结果将保存到 S3 存储桶中。

  注意

  对于同步 API，您的文本必须是 UTF-8 编码并且不超过 5000 字节。

让我们快速浏览一下 AWS 控制台中的一些 Amazon Comprehend 功能。如果您还没有设置 AWS 账户，请参考技术要求部分。

由于我们都常常忘记设置自动支付信用卡账单的消息，在本演示中，我们将展示如何使用 Amazon Comprehend 对示例自动支付消息进行快速分析，以提取一些关键信息：

1. 进入 Amazon Comprehend，点击 启动 Amazon Comprehend：

   图 3.3 – Amazon Comprehend 控制台

2. 我们将使用以下示例自动支付文本，分析通过 AWS 控制台提供的 Amazon Comprehend 的所有功能：

   Hi Alex. Your NoNameCompany Financial Services, LLC credit card account 1111-0000-1111-0010 has a minimum payment of $25.00 that is due by Sunday, June 19th. Based on your autopay settings, we are going to withdraw your payment on the due date from your bank account XXXXXX1121 with the routing number  XXXXX0000.
   Your latest statement was mailed to 100 XYZ Street, Anytown, WA 98121.
   After your payment is received, you will receive a confirmation text message at 555-0100-0000.
   If you have questions about your bill, NoNameCompany Customer Service is available by phone at 206-555-0199 or email at support@nonamecompany.com.
   

3. 复制前面的文本并将其插入到 实时分析 → 输入文本 中，如图 3.4所示，然后点击 内置，再点击 分析：

   图 3.4 – AWS 控制台中的实时分析输入文本

4. 向下滚动以查看分析结果。

现在，我们将通过更改每个标签页来逐一了解每个 Insights API。

检测实体

从图 3.5的截图中可以看到，Amazon Comprehend 能够检测到您输入文本中的高亮实体：

图 3.5 – 检测实体分析结果

1. 向下滚动查看结果，了解这些实体以及 Amazon Comprehend 内置 API 在没有任何自定义的情况下识别的实体。

   在图 3.6中的下图中，你可以看到Alex被识别为人物，NoNameCompany，即自动支付消息的发送方，被识别为组织。Alex 的到期日期（6 月 19 日）被识别为日期实体，并附带了相应的置信度分数。置信度分数表示机器学习模型找到匹配项的可能性，范围从 0 到 100。分数越高，匹配结果的信心越大。分数为 100 意味着可能是完全匹配，而分数为 0 则表示未找到匹配答案：

   

   图 3.6 – 检测实体结果

   注意

   开箱即用，Amazon Comprehend 的内置 API 可以检测文本中的人物、位置、数量、组织、日期、商品项、数量和标题。

2. 让我们快速滚动到应用程序集成，看看它期望什么类型的请求，以及基于此请求 API 返回什么类型的响应：

图 3.7 – 理解检测实体请求和响应

在本章的最后一节，我们将看到如何使用python boto 3 SDK调用这些 API 并将它们集成到你的应用程序中。

检测关键短语

切换到关键短语标签页，以了解关键短语是什么，以及 Amazon Comprehend 的预测结果：

图 3.8 – 检测关键短语

在英语中，关键短语由一个名词短语（名词加修饰语）构成，描述特定的事物。例如，在图 3.8中的文本，“你好，Alex”，“你的 NoNameCompany 金融服务”以及“最低支付额”是 Amazon Comprehend API 识别的一些关键短语。通过查看这些关键字而不需要阅读全文，一个人就能知道这与一家金融公司和某种支付有关，这在处理大量非结构化文本时非常有用。

语言检测

切换到标签页，查看 Amazon Comprehend 识别的主导语言，如图 3.9所示：

图 3.9 – 检测语言控制台演示

类似于其他 Comprehend API，Amazon Comprehend 可以检测给定文本的语言，并提供一个置信度分数。你可以使用此功能来处理用多种不同语言书写的书籍，例如法语和印地语。通过使用语言检测 API，你可以检测语言并分类书中每种语言所占的比例，然后可以使用Amazon Translate，这是 AWS 提供的将文本从一种语言翻译成另一种语言的服务。我们将在后续章节中看到这个例子，以便进行翻译。

PII 检测

将标签切换为 PII，以查看使用 Amazon Comprehend 开箱即用的 PII 检测 API 将得到的结果如下：

图 3.10 – PII 检测演示

正如您在图 3.10中看到的，Amazon Comprehend 为您提供了通过其实时或同步 PII API 的偏移量和标签。如果您想从文本中删除 PII 数据，您可以使用异步作业。Amazon Comprehend 可以检测到以下 PII 实体：年龄、地址、AWS 访问密钥、AWS 秘密密钥、银行相关信息（如银行账户和银行路由号码）、信用卡信息（如信用卡号码和有效期）、身份信息（如驾驶执照 ID 和护照号码）、网络相关信息（如电子邮件、IP 地址和 MAC 地址）、网址；密码；和用户名。

通过了解 Amazon Comprehend 检测到的 PII 实体类型，让我们向下滚动，查看您输入文本中的 PII 偏移量检测结果：

图 3.11 – 检测 PII 结果

您还会获得一个置信度分数，以及实体和 PII 实体类型。

如果您不想识别具体实体，只是想了解文档中包含哪些类型的 PII，您可以使用标签 PII 功能。

选择标签按钮以查看此功能的实际应用：

图 3.12 – 检测 PII 标签结果

从图 3.12中显示的结果中，您可以清楚地看到，日期时间、电子邮件、姓名、地址和电话是与您输入文本中的某个人相关的 PII 信息。

检测情感

切换到情感标签以了解您输入文本的情感：

图 3.13 – 检测情感结果

由于文本与自动支付消息相关，Amazon Comprehend 的实时情感分析 API 检测到中性情感。Amazon Comprehend 的情感分析功能帮助确定情感是正面、负面、中性还是混合。您可以将此功能用于各种用例，例如确定在线书评的情感、Twitter 情感分析，或任何社交媒体情感分析，如 Reddit 或 Yelp 评论情感分析。

检测语法

点击最后一个标签，语法，以查看使用 Amazon Comprehend 的检测语法功能可以获得哪些类型的响应：

图 3.14 – 检测语法或词性结果

Amazon Comprehend 能够识别名词、动词和形容词，并且可以识别总共 17 种词性。这一功能对于需要进行词性标注的 NLP 模型的数据预处理非常有用。

注意

我们详细介绍了所有 Amazon Comprehend 文本分析实时 API。您可以使用我们所讲解的所有这些 API 执行批量实时操作，并一次发送 25-5000 字节的 UTF-8 文本文档（docs.aws.amazon.com/comprehend/latest/dg/guidelines-and-limits.html）以获得实时结果。Comprehend 自定义现在可以直接导入 PDF 文档进行分析和自定义训练。

Amazon Comprehend 自定义功能

使用 Amazon Comprehend 自定义，您可以导入自己的数据集，快速创建自定义实体，并执行自定义分类。此功能是一个批处理或异步功能，涉及两个步骤：

1. 通过提供一个小型的标记数据集来训练分类器或实体识别器。此分类器或实体识别器使用自动化机器学习（AutoML）和迁移学习，根据您提供的训练数据集选择并训练模型。它还会提供 F1 得分以及与该训练模型相关的精度和召回率指标。

2. 在训练自定义分类器或自定义实体识别器模型后，对该训练模型进行批量或实时分析。您可以再次选择两种方式：使用该训练模型为数据批量创建“分析作业”，并在 Amazon Comprehend 控制台中执行；也可以创建一个实时端点，用于分类实时用例，如 Twitter 实时动态、新闻动态或客户服务请求等，几乎实时地使用该模型。

图 3.15 – Comprehend 自定义分类工作流程

我们将在第十四章中介绍 Comprehend 自定义实体功能，审计命名实体识别工作流程，以及在第十五章中介绍 Comprehend 自定义分类功能，分类文档并为主动学习设置人工环节。

我们将在第六章中详细介绍主题建模产品功能，使用自然语言处理（NLP）提高客户服务效率。

Amazon Comprehend 事件

Amazon Comprehend 事件为金融组织提供了一个特定的使用场景，您可以通过此 API 查看在任何重要的金融事件中（如新闻发布、并购等）通过 Amazon Comprehend 提取的各个实体之间的关系。您可以使用这个 Events 批处理 API 来检测大型文档中的事件，以回答事件发生的“谁、什么、何时、何地”。要了解更多关于 Comprehend 事件的内容，请参考此博客：aws.amazon.com/blogs/machine-learning/announcing-the-launch-of-amazon-comprehend-events/。

使用 Comprehend Medical 从医生-患者对话记录中推导诊断

Amazon Comprehend Medical 提供两种分析类型：

• 文本分析 API：类似于 Amazon Comprehend 文本分析 API，Comprehend Medical 具有检测医疗实体和检测 PHI 的 API。

• 肿瘤学检测 API：这些 API 帮助将实体与 RxNorm 或 ICD-10-CM 链接起来。根据国家卫生研究院（NIH）(www.nlm.nih.gov/research/umls/rxnorm/index.html)的说法，RxNorm 为临床药物提供标准化名称，并将其名称链接到许多药房管理和药物相互作用软件中常用的药物词汇表。通过在这些词汇表之间提供链接，RxNorm 可以在不使用相同软件和词汇表的系统之间传递消息。ICD-10-CM（ICD-10 临床修改版）是世界卫生组织授权的 ICD-10 的修改版，并在美国作为诊断代码的来源使用。要了解更多信息，请参阅其维基百科条目：en.wikipedia.org/wiki/ICD-10-CM。

现在，我们将再次通过 AWS 控制台快速了解 Amazon Comprehend Medical 的功能：

1. 打开 AWS 控制台：console.aws.amazon.com/comprehend/v2/home?region=us-east-1#try-comprehend-medical

2. 在 Amazon Comprehend Medical 中点击实时分析功能，并输入以下示例文本：

   Pt is 35 yo woman, IT professional with past medical history that includes
   - status post cardiac catheterization in may 2019.
   She haspalpitations and chest pressure today.
   HPI : Sleeping trouble for present dosage of Catapres. Severe rash on thighs, slightly itchy
   Meds : Xanax100 mgs po at lunch daily,
   Catapres 0.2 mgs -- 1 and 1 / 2 tabs po qhs
   Lungs : clear
   Heart : Regular rhythm
   Next follow up as scheduled on 06/19/2021
   

3. 复制此文本并粘贴到图 3.16中的输入文本，然后点击分析：

   图 3.16 – 用于实时 Amazon Comprehend Medical 分析的输入文本

   注意

   使用 Comprehend Medical 实时 API，您可以分析多达 200,000 个字符。

4. 滚动到底部查看 Comprehend Medical 实体的实时 API 结果：

   图 3.17 – Comprehend Medical 检测实体

   您可以看到，Comprehend Medical 还提供这些实体内部的关系，例如Catapres剂量以及药物应该被服用的频率。Amazon Comprehend Medical 检测实体、类型和类别，例如实体是否为 PHI 或治疗或时间表达和特征，并附带置信度分数。

5. 进一步向下滚动以查看以35为实体检测的检测到的实体，其实体类型为年龄，类别为 PHI。

图 3.18 – Comprehend Medical 检测实体结果

RxNorm 概念

使用此功能识别药物作为实体：

1. 切换到RxNorm选项卡。您将看到一个类似以下截图的屏幕：![图 3.19 – Comprehend Medical InferRxNorm 结果

   ![Figure 3.20 – Comprehend Medical InferICD-10-CM 结果

   图 3.19 – Comprehend Medical InferRxNorm 结果

   如果您向下滚动至结果，Comprehend Medical 显示了每种药物的RXCUI，以及置信度评分。RXCUI 是一个机器可读的代码，指的是特定药物的唯一名称，具有相同 RXCUI 的药物被视为同一药物。这个 Comprehend Medical 功能提供 RxNorm 信息，例如强度、频率、剂量、剂型和给药途径。您可以将这个 RxNorm 功能用于以下场景：

   • 患者药物筛查。

   • 预防可能由新处方药与患者已经服用的药物相互作用而引起的负面反应。

   • 基于药物历史的筛选，使用 RXCUI 包含在临床试验中。

   • 检查药物的适当频率和剂量以及药物筛查。

ICD-10-CM 概念

让我们切换到ICD-10-CM 概念标签，您将获得以下分析：

![Figure 3.20 – Comprehend Medical InferICD-10-CM 结果

![Figure 3.20 – Comprehend Medical InferICD-10-CM 结果

图 3.20 – Comprehend Medical InferICD-10-CM 结果

InferICD10CM API 将可能的医疗状况检测为实体，并将其链接到 ICD-10-CM 的代码，同时附带置信度评分。在医疗保健中，这些代码是标准的医疗交易代码，用于诊断目的，以符合《健康保险移植与责任法》（HIPAA），并用于分类和报告疾病。您可以将这些 ICD-10-CM 代码用于下游分析，作为迹象、症状、特征和属性。

InferICD10CM 非常适合于专业医疗编码协助患者记录、临床试验和研究、与现有医疗软件系统集成、早期检测和诊断以及人群健康管理等场景。

在下一节中，我们将通过执行 Jupyter 笔记本的演示来查看这些 API 的实际效果。

使用 Amazon Comprehend 与您的应用程序

在本节中，您将通过 Jupyter 笔记本示例详细了解 Amazon Comprehend 和 Comprehend Medical 提供的广泛类别的 API，您可以在您的 AWS 账户中运行。要设置笔记本，请参阅本章的技术要求部分。

我们将展示 Comprehend 中一组关键 API 的子集及其功能，然后将讨论如何构建与 AWS Lambda、API Gateway和 Comprehend 集成的应用程序。

注意

我们将在第十二章**， 医疗保健中的人工智能和自然语言处理中涵盖 Amazon Comprehend Medical API。

让我们首先从 Amazon Comprehend 的 API 开始。Amazon Comprehend 提供三种类型的 API。

• 实时 API：适用于我们涵盖的所有文本分析功能和 Comprehend 定制模型端点。

• 批量实时 API：适用于所有文本分析功能。

• 批量或分析作业 API：用于所有文本分析功能、主题建模功能以及 Comprehend 自定义模型训练。

在笔记本中 github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2003/Chapter%203%20Introduction%20to%20Amazon%20Comprehend.ipynb，我们将涵盖实时 API 和批处理实时 API。

注意

你可以在其他支持的 API 中实现相同的功能，例如 Java、Ruby、.NET、AWS CLI、Go、C++、JavaScript 和 PHP。有关 Comprehend API 的更多信息，请参考 Amazon 文档：docs.aws.amazon.com/comprehend/latest/dg/API_Reference.html。

1. 让我们开始设置 Python boto3 API，以便使用 Amazon Comprehend：

   import boto3
   comprehend = boto3.client('comprehend')
   

2. 让我们看看如何使用同步或实时 API 执行detect_entities的实体提取。我相信你已经读了很多 Packt 的书；让我们看看以下关于 Packt Publications 的示例文本，以及我们可以从中提取哪些实体：

   SampleText="Packt is a publishing company founded in 2003 headquartered in Birmingham, UK, with offices in Mumbai, India. Packt primarily publishes print and electronic books and videos relating to information technology, including programming, web design, data analysis and hardware."
   

3. 我们将调用detect_entities API（comprehend.detect_entities）从示例文本中提取实体：

   response = comprehend.detect_entities(
   Text=SampleText,
       LanguageCode='en')
   

4. 以下是从关于 Packt Publications 的简介中提取的实体的响应：

   import json
   print (json.dumps(response, indent=4, sort_keys=True))
   

   这将给我们以下输出：

   

   图 3.21 – JSON 结果截图

   Comprehend 能够成功检测实体及其类型，并给出响应，表明 Packt Publications 是位于英国伯明翰和印度孟买的一个组织。

5. 现在我们知道了什么是 Packt Publications，让我们使用detect_key_phrases API 来识别关于该组织的一些关键短语，但文本是法语的。

   SampleText="Packt est une société d'édition fondée en 2003 dont le siège est à Birmingham, au Royaume-Uni, avec des bureaux à Mumbai, en Inde. Packt publie principalement des livres et des vidéos imprimés et électroniques relatifs aux technologies de l'information, y compris la programmation, la conception Web, l'analyse de données et le matériel"
   

6. 我们将使用detect_key_phrases API，并将fr作为LanguageCode参数，来从前面的法文文本中检测关键短语：

   response = comprehend.detect_key_phrases(
       Text= SampleText,
       LanguageCode='fr'
   )
   

7. 让我们看看来自 Amazon Comprehend 的响应：

   print (json.dumps(response, indent=4, sort_keys=True))
   

   这将返回以下内容：

图 3.22 – Comprehend 检测关键短语响应

Amazon Comprehend 能够识别关键短语，并且标明文本的位置。

现在，如果你想从 Packt Publications 购买一本书，你可能会想要阅读评论并判断它们是否积极。

使用batch_detect_sentiment API，我们将向你展示如何一次分析多个评论。对于这个演示，我们将从《每个程序员都应该知道的 40 种算法》这本书中挑选一些示例评论 (www.packtpub.com/product/40-algorithms-every-programmer-should-know/9781789801217)：

1. 我们将使用batch_detect_sentiment分析一些这本书的评论：

   response = comprehend.batch_detect_sentiment(
       TextList=[
           'Well this is an area of my interest and this book is packed with essential knowledge','kinda all in one With good examples and rather easy to follow', 'There are good examples and samples in the book.', '40 Algorithms every Programmer should know is a good start to a vast topic about algorithms'
       ],
       LanguageCode='en'
   )
   

2. 现在，让我们通过运行以下代码来查看该响应：

   print (json.dumps(response, indent=4, sort_keys=True))
   

   这将产生以下输出：

   

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_03_23.jpg)

   图 3.23 – Comprehend 情感分析响应

   在分析的这四条评论中，我们可以明显看到，总体来说，这是一本书的积极评论。在阅读这些评论时，有一些是不同语言写的，作为一个英语读者，我并不理解它们。很不幸，我不知道这些评论使用的是哪些语言，因此也不知道该选择哪种语言进行翻译。

3. 让我们使用 Comprehend 的 batch_detect_dominant_language API 在翻译之前识别这些评论使用的是哪些语言：

   response = comprehend.batch_detect_dominant_language(
       TextList=[
           'It include recenet algorithm trend. it is very helpful.','Je ne lai pas encore lu entièrement mais le livre semble expliquer de façon suffisamment claire lensemble de ces algorithmes.'
       ]
   )
   

4. 现在，让我们查看 Comprehend 的响应，以了解评论的语言：

   print (json.dumps(response, indent=4, sort_keys=True))
   

   这将给出以下输出：

图 3.24 – Comprehend 检测语言响应

有趣的是，我们发现，在这批次中发送的两条评论，分别检测出主导语言，一条是英语，另一条是法语。

我们现在已经介绍了一些关键的 API，如 detect_entities、detect_key_phrases、batch_detect_sentiment 和 batch_detect_dominant_languages。

现在，我们将看到如何在构建应用程序时使用这些 API。

使用 Amazon API Gateway、AWS Lambda 和 Comprehend 架构应用程序

在前面的章节中，我们介绍了 Amazon Comprehend 的文本分析 API。你可以通过 Lambda 函数以无服务器的方式轻松调用这些 API。Amazon Lambda 是一种无服务器、基于事件的触发器，可以与 Amazon API Gateway 集成，并触发 GET 和 POST 请求。Amazon API Gateway 是一种无服务器的 REST 基础服务，可以让你构建 GET/POST API，轻松与任何应用程序集成，无论是移动应用还是 Web 应用。

你可以创建一个 API，将其嵌入到你的应用程序中，通过 API Gateway 发送待分析的文本；然后 API Gateway 根据收到的请求类型调用 Amazon Lambda 函数。Amazon Lambda 可以进一步调用 Amazon Comprehend API（实时或批处理检测实时 API）。随后，它将 Comprehend 的响应传递给 API Gateway，如 图 3.25 所示的架构图：

图 3.25 – 使用 Amazon Comprehend 构建实时应用程序

总结

本章我们讲解了为什么需要使用 Amazon Comprehend 和 Amazon Comprehend Medical。我们还讨论了设置 NLP 流水线时面临的挑战。

然后，我们介绍了这些服务，并概述了它们提供的一些关键优势，例如不需要机器学习技能，或轻松使用 API 构建可扩展的 NLP 解决方案。接下来，我们通过控制台演示展示了 Amazon Comprehend 和 Amazon Comprehend Medical 的一些关键产品功能。Amazon Comprehend 的一些功能包括识别实体、关键词短语和情感分析，以及检测主导语言、主题建模等。对于 Amazon Comprehend Medical，我们介绍了如何使用文本分析 API 和肿瘤学 API 来丰富和提取医学笔记中的关键信息。随后，我们通过 Jupyter notebook 对这些 API 进行了简要的操作演示，并讲解了同步和批量同步 API。我们对使用这些 API 创建无服务器应用程序有了基本的理论了解。

在下一章中，我们将讨论如何将 Amazon Textract 与 Amazon Comprehend 集成，以实现财务文档的自动化处理。

第二部分：使用 NLP 加速业务成果

在本节中，我们将深入探讨多个行业中流行的、可以从 NLP 中受益的用例，基于我们集体的经验和观察到的使用趋势。我们将提供详细的代码示例、设计与开发方法，以及如何设置和运行这些示例的逐步指南，并提供访问 GitHub 代码库的链接。我们还将深入讨论如何通过 AWS NLP 解决方案，利用自动化索赔调整用例在医疗保健中实现运营效率。

本节包含以下章节：

• 第四章，自动化文档处理工作流

• 第五章，创建 NLP 搜索

• 第六章，使用 NLP 提高客户服务效率

• 第七章，理解客户声音分析

• 第八章，利用 NLP 变现您的媒体内容

• 第九章，从金融文档中提取元数据

• 第十章，通过机器翻译降低本地化成本

• 第十一章，使用聊天机器人查询文档

• 第十二章，AI 与 NLP 在医疗保健中的应用

第四章：第四章：自动化文档处理工作流

在上一章中，我们介绍了Amazon Comprehend和Amazon Comprehend Medical，并讲解了如何使用这些服务从文本中提取洞察。我们还花了一些时间了解自然语言处理算法如何工作、可以揭示的不同类型的洞察，并且运行了代码示例，尝试使用 Amazon Comprehend APIs。

本章将展示我们的第一个现实世界用例——自动化文档管理工作流，这是许多组织目前面临的挑战。我们根据我们的集体经验以及在职业生涯中观察到的使用趋势，整合了这一解决方案。系好安全带，准备好逐步体验如何构建一个端到端的 AI 解决方案，并看到它在你面前逐渐成型。我们预计在本章的整个过程中将进行实践，但我们已经准备好了所有必要的代码示例，以便开始。

我们将深入探讨如何使用Amazon Textract自动化文档处理，接着介绍如何使用Amazon Comprehend在文档中设置合规性和控制。最后，我们将讨论在设计实时文档处理工作流与批处理时的架构最佳实践。我们将提供详细的代码示例、设计和开发方法，并提供逐步指南，帮助您设置并运行这些示例，同时提供对 GitHub 仓库的访问。

本章将涵盖以下主题：

• 自动化文档处理工作流

• 设置合规性和控制

• 实时文档工作流与批量文档工作流的处理

技术要求

本章内容需要访问 AWS 账户。请确保按照第二章《介绍 Amazon Textract》中的技术要求部分的说明创建 AWS 账户，并登录 AWS 管理控制台，然后再尝试本章中的步骤。

本章代码的 Python 代码和示例数据集可以通过以下链接获取：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/tree/main/Chapter%2004。请根据以下章节中的说明，结合仓库中的代码来构建解决方案。

查看以下视频，观看代码的实际应用：bit.ly/3GlcCet。

自动化文档处理工作流

我们在上一章中讨论了 Amazon Textract 如何通过从任何文档中提取文本，帮助我们数字化扫描文档（如 PDF 和图像）。我们还介绍了 Amazon Comprehend 如何帮助我们从这些文档中提取洞察，包括实体、个人身份信息（PII）和情感。

现在，这些服务可以在架构中一起使用，以自动化大多数组织的文档处理工作流，无论是金融机构还是医疗机构，关于这一点我们将在第十二章，医疗行业中的 AI 和自然语言处理中讨论。

让我们从一个虚构的银行LiveRight Pvt Ltd.开始，该银行的客户正在申请住房贷款。我们都知道，这个贷款发放过程涉及到超过 400 份文件，需要银行在批准贷款之前提交并审核。这一过程的自动化将使银行和客户更容易获得贷款。自动化这些工作流的挑战在于，贷款发放过程有超过 1000 个模板，而使用任何光学字符识别（OCR）系统都需要管理这些模板。此外，这些基于 OCR 模板的方法不具备可扩展性，并且在格式变化时会出现问题。这就是为什么我们有 Amazon Textract，它可以从任何文档中提取文本，使这些文档能够在数小时内而非数月或数周内完成自动化处理。

你已经从这些表单或半结构化文档中提取了数据。接下来，你将需要对从这些文档中提取的数据进行合规性和控制设置；例如，确保如果数据是个人身份信息（PII），你可以进行掩码处理以供进一步处理。如果你想专注于贷款批准流程，还需要提取实体，例如贷款金额或请求人的详细信息。这正是 Amazon Comprehend 可以帮助的地方。事实上，你可以使用 Amazon Comprehend 根据你的需求对提交的文档和自定义实体进行分类；例如，通过 Textract 提取的文档发送至 Amazon Comprehend 进行自定义分类，判断该文档是驾照还是 W2 表格。

以下是如何将 Amazon Textract 和 Amazon Comprehend 一起使用，以自动化现有文档流程的架构：

图 4.1 – 自动化文档处理工作流

在这个架构中，您将接收文档，这些文档可能是财务文档、法律文档、按揭申请等。您将这些文档发送到 Amazon Textract，从中提取文本。提取文本后，您可以将其发送到 Amazon Comprehend，以提取见解。这些见解可以根据文档类型对这些文档进行分类，识别文档中的个人可识别信息（PII），或者通过自定义实体识别进行命名实体识别（NER）。我们在第十四章中讲解了自定义实体，第十五章中讲解了文档分类，审计命名实体识别工作流以及文档分类和设置人类介入进行主动学习。

在本节中，我们介绍了如何通过将 Amazon Textract 和 Amazon Comprehend 两项服务结合使用，快速轻松地设置自动化文档处理工作流。在下一节中，我们将讨论如何将这些服务结合使用，为 LiveRight Pvt Ltd. 设置合规性和控制，特别是通过屏蔽或删除其表单中的 PII 数据。

设置合规性和控制

在本节中，我们将讨论如何使用 Amazon Textract 和 Amazon Comprehend 为 LiveRight Pvt Ltd. 设置合规性和控制，并自动化其贷款发放流程。我们将通过在 Jupyter notebook 中使用代码示例来逐步讲解以下架构：

图 4.2 – 设置合规性和控制

我们将通过一个单一文档和示例代码来引导您完成这个架构。然而，这个架构可以通过 Step Function 和 Lambda 函数 以无服务器的方式自动处理大量文档。在这个架构中，我们将展示以下内容：

1. 如何上传示例文档并使用 .txt 或 .csv 文件将提取的文本返回到 Amazon S3 存储桶。

2. 接下来，我们将展示如何使用 Amazon Comprehend 的实时或同步 API 来检测 PII。

3. 接下来，我们将讨论如何使用 Amazon Comprehend 的 PII 检测作业，在 Amazon S3 中对提取的文本/CSV 文件中的 PII 数据进行屏蔽和删除。

4. 如何在 Amazon S3 中找到已删除 PII 数据的文档文本，作为 Comprehend PII 检测作业的输出。

那么，让我们开始设置 notebook。

设置以解决用例

如果你在前面的章节中没有这样做，你需要先创建一个 Amazon SageMaker Jupyter notebook，并为该 notebook 角色设置身份和访问管理（IAM）权限，以便访问我们将在本 notebook 中使用的 AWS 服务。之后，你需要克隆 GitHub 仓库（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services）。请按以下步骤完成这些任务，之后我们才能执行 notebook 中的单元格：

1. 按照第二章中[设置 AWS 环境]部分的创建 Amazon SageMaker Jupyter notebook 实例章节中的说明，创建你的 Jupyter notebook 实例。

   创建 Amazon SageMaker Jupyter Notebooks 时的 IAM 角色权限

   在创建 notebook 时，接受 IAM 角色的默认选项，以允许访问任何 S3 桶。

2. 创建完 notebook 实例并且其状态为InService后，点击 notebook 实例的操作菜单中的打开 Jupyter。

   图 4.3 – 打开 Jupyter notebook

   这将带你进入 notebook 实例的主文件夹。

3. 点击新建，然后选择终端，如下图所示：

   图 4.4 – 在 Jupyter notebook 中打开终端

4. 在终端窗口中，首先键入 cd SageMaker，然后键入 git clone https://github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services，如下图所示：

   图 4.5 – git clone 命令

5. 现在，退出终端窗口，返回主文件夹，你会看到一个名为Chapter 04的文件夹。点击该文件夹，你应该会看到一个名为Chapter 4 Compliance and control.ipynb的 notebook。

6. 点击此 notebook 打开它。

接下来，我们将介绍其他的 IAM 先决条件。

其他 IAM 先决条件

为了训练 Comprehend 自定义实体识别器并设置实时端点，我们必须启用额外的策略，并更新 SageMaker notebook 角色的信任关系。为此，请将 AmazonS3FullAccess、TextractFullAccess 和 ComprehendFullAccess 策略附加到你的 Amazon SageMaker Notebook IAM 角色。要执行此步骤，请参阅第二章中[设置 AWS 环境]部分的更改 IAM 权限和信任关系以便 Amazon SageMaker notebook 执行角色，介绍 Amazon Textract。

现在我们已经在 Amazon SageMaker notebook 实例中设置了所需的 IAM 角色和 notebook，接下来让我们进入代码讲解部分。

自动化文档控制与符合性

在这一部分，我们将通过代码讲解我们讨论的架构，该架构用于通过 Amazon Textract 自动化文档处理，并通过 Amazon Comprehend 实现符合性和控制，使用 PII 屏蔽，参考图 14.2，使用这个笔记本：

1. 执行你刚刚在以下链接设置的 Jupyter 笔记本中，第 1 步 – 设置并安装库下的单元格，github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2004/Chapter%204%20Compliance%20and%20control.ipynb，以确保你拥有笔记本所需的库。请注意，在此单元格中，你正在获取笔记本的 Amazon SageMaker 执行角色以及 SageMaker 会话。你正在设置 boto3 库，以调用 Amazon Textract、Amazon Comprehend 和 Amazon S3 API。你还将使用 SageMaker 会话访问默认的 SageMaker S3 存储桶，用于将数据以前缀或文件夹的方式存储到该存储桶中。

2. 现在，我们将从示例银行对账单开始。执行 Jupyter 笔记本中的第 2 步，从示例文档中提取文本下的单元格，显示示例文档，以提取文本并编辑 PII 信息：

   documentName = "bankstatement.png"
   display(Image(filename=documentName))
   

   你将获得以下响应：

   

   图 4.6 – 示例银行对账单

3. 现在，我们将调用 Amazon Textract 的 Detect Document Text Sync API，boto3.amazonaws.com/v1/documentation/api/latest/reference/services/textract.html#Textract.Client.detect_document_text，它可以近实时地从文档中提取文本，用于使用以下代码从示例银行对账单中提取数据：

   client = boto3.client(service_name='textract',
            region_name= 'us-east-1',
            endpoint_url='https://textract.us-east-1.amazonaws.com')
   with open(documentName, 'rb') as file:
               img_test = file.read()
               bytes_test = bytearray(img_test)
               print('Image loaded', documentName)
   response = client.detect_document_text(Document={'Bytes': bytes_test})
   print(response)
   

   你将从 Amazon Textract 获取一个 JSON 响应，使用 Detect Document Text Sync API。

4. 现在，我们将使用在第 1 步中安装的 Amazon Textract 解析器库从这个 JSON 响应中提取文本。运行以下代码将 Textract JSON 响应解析为文本：

   doc = Document(response)
   page_string = ''
   for page in doc.pages:
           for line in page.lines:
               page_string += str(line.text)
   print(page_string)
   

   现在，我们已经从 Textract JSON 响应中提取了文本，让我们进入下一步。

5. 在这一步中，我们将把从银行对账单中提取的文本保存到一个文本/CSV 文件，并上传到 Amazon S3，以便使用 Amazon Comprehend 批量作业进行处理。运行笔记本单元格第 3 步，将提取的文本保存到文本/CSV 文件并上传到 Amazon S3 存储桶，以将数据保存到文本文件中，然后上传到 Amazon S3。

6. 现在我们已经从银行对账单中提取了文本，将其转换为文本文件并上传到 Amazon S3，在此步骤中，我们将使用 Amazon Comprehend Detect PII Sync API 检测文本中的 PII。运行笔记本单元格步骤 4，使用 Amazon Comprehend Detect PII Sync API 检查 PII，通过传递来自 Amazon Textract 提取的文本来调用 Comprehend API：

   a) 首先，初始化 Amazon Comprehend 的 boto3 句柄：

   `comprehend = boto3.client('comprehend')
   

   b) 然后，调用 Amazon Comprehend，并将我们示例银行对账单图像中聚合的文本传递给 Comprehend，以检测 PII 实体：boto3.amazonaws.com/v1/documentation/api/latest/reference/services/comprehend.html#Comprehend.Client.detect_pii_entities:

   piilist=comprehend.detect_pii_entities(Text = page_string, LanguageCode='en')
   redacted_box_color='red'
   dpi = 72
   pii_detection_threshold = 0.00
   print ('Finding PII text...')
   not_redacted=0
   redacted=0
   for pii in piilist['Entities']:
       print(pii['Type'])
       if pii['Score'] > pii_detection_threshold:
                       print ("detected as type '"+pii['Type']+"' and will be redacted.")
                       redacted+=1
   
       else:
           print (" was detected as type '"+pii['Type']+"', but did not meet the confidence score threshold and will not be redacted.")
           not_redacted+=1
   print ("Found", redacted, "text boxes to redact.")
   print (not_redacted, "additional text boxes were detected, but did not meet the confidence score threshold.")s3_entity_key = prefix + "/train/entitylist.csv"
   

   您将收到一个响应，识别文本中的 PII，并将在下一步中使用 Amazon Comprehend PII 分析任务删除这些内容。

   

   图 4.7 – 使用 Amazon Comprehend 在银行对账单中进行 PII 检测

   我们将对在示例银行对账单中找到的 15 个个人身份信息（PII）实体进行屏蔽/删除。

7. 接下来，我们将调用 StartPiiEntitiesDetectionJob API 来启动一个异步的 PII 实体检测任务，适用于一组文档。在本示例中，我们只使用一个文档样本。您可以使用此任务删除大量文档。运行笔记本单元格步骤 5，使用 Amazon Comprehend PII 分析任务屏蔽 PII，以设置并启动 Amazon Comprehend 的 PII 删除分析任务：

   a) 然后，任务需要指定待屏蔽文档的 S3 位置以及您希望输出已屏蔽内容的 S3 位置。运行以下单元格，指定我们希望屏蔽的 S3 文本文件位置：

   import uuid
   InputS3URI= "s3://"+bucket+ "/pii-detection-redaction/pii_data.txt"
   print(InputS3URI)
   OutputS3URI="s3://"+bucket+"/pii-detection-redaction"
   print(OutputS3URI)
   

   b) 现在我们将通过设置删除参数并传递数据存储的输入 S3 位置来调用 comprehend.start_pii_entities_detection_job，运行以下笔记本单元格：

   response = comprehend.start_pii_entities_detection_job(
       InputDataConfig={
           'S3Uri': InputS3URI,
           'InputFormat': 'ONE_DOC_PER_FILE'
       },
       OutputDataConfig={
           'S3Uri': OutputS3URI
   
       },
       Mode='ONLY_REDACTION',
       RedactionConfig={
           'PiiEntityTypes': [
              'ALL',
           ],
           'MaskMode': 'MASK',
           'MaskCharacter': '*'
       },
       DataAccessRoleArn = role,
       JobName=job_name,
       LanguageCode='en',   
   )
   Mode='ONLY_REDACTION'|'ONLY_OFFSETS',
       RedactionConfig={
           'PiiEntityTypes': [
               'BANK_ACCOUNT_NUMBER'|'BANK_ROUTING'|'CREDIT_DEBIT_NUMBER'|'CREDIT_DEBIT_CVV'|'CREDIT_DEBIT_EXPIRY'|'PIN'|'EMAIL'|'ADDRESS'|'NAME'|'PHONE'|'SSN'|'DATE_TIME'|'PASSPORT_NUMBER'|'DRIVER_ID'|'URL'|'AGE'|'USERNAME'|'PASSWORD'|'AWS_ACCESS_KEY'|'AWS_SECRET_KEY'|'IP_ADDRESS'|'MAC_ADDRESS'|'ALL',
           ],
           'MaskMode': 'MASK'|'REPLACE_WITH_PII_ENTITY_TYPE',
           'MaskCharacter': 'string'
   

   有关更多详细信息，请参考 API 文档：docs.aws.amazon.com/comprehend/latest/dg/API_StartPiiEntitiesDetectionJob.html。

   c) 该任务大约需要 6-7 分钟。以下代码用于检查任务的状态。一旦任务完成，单元格执行也会完成：

   from time import sleep
   job = comprehend.describe_pii_entities_detection_job(JobId=events_job_id)
   print(job)
   waited = 0
   timeout_minutes = 10
   while job['PiiEntitiesDetectionJobProperties']['JobStatus'] != 'COMPLETED':
       sleep(60)
       waited += 60
       assert waited//60 < timeout_minutes, "Job timed out after %d seconds." % waited
       job = comprehend.describe_pii_entities_detection_job(JobId=events_job_id)
   

   您将收到一个 JSON 响应，且该任务大约需要 5-6 分钟。在此期间，您可以去喝杯咖啡，直到笔记本单元格运行并返回响应。

8. 一旦任务成功，我们将在此步骤中向您展示提取的、已屏蔽的文档输出。运行笔记本单元格步骤 6，查看 Amazon S3 存储桶中的已屏蔽/已删除输出，以从 Amazon S3 存储桶中提取输出：

   filename="pii_data.txt"
   s3_client = boto3.client(service_name='s3')
   output_data_s3_file = job['PiiEntitiesDetectionJobProperties']['OutputDataConfig']['S3Uri'] + filename + '.out'
   print(output_data_s3_file)
   output_data_s3_filepath=output_data_s3_file.split("//")[1].split("/")[1]+"/"+output_data_s3_file.split("//")[1].split("/")[2]+"/"+output_data_s3_file.split("//")[1].split("/")[3]+"/"+output_data_s3_file.split("//")[1].split("/")[4]
   print(output_data_s3_filepath)
   f = BytesIO()
   s3_client.download_fileobj(bucket, output_data_s3_filepath, f)
   f.seek(0)
   print(f.getvalue())
   

   您将获得以下已屏蔽的银行对账单：

](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_04_08.jpg)

图 4.8 – 使用 Amazon Comprehend PII Redaction 任务对银行对账单进行脱敏处理

在输出中，你可以看到 Amazon Comprehend PII 任务已经对 PII 数据（如地址、姓名、社会保障号码和银行账号）进行了脱敏处理，这些数据是通过 Amazon Comprehend Detect PII 实体识别出来的。

在本节中，我们为你展示了一个端到端的概念性架构，旨在实现文档的合规性和控制自动化。在下一节中，我们将讨论实时文档处理工作流与批量文档处理工作流的最佳实践。

处理实时文档工作流与批量文档工作流

在本节中，我们将讨论在使用 Amazon Textract 构建实时工作流与批量处理文档工作流的解决方案时的一些最佳实践。

让我们将 Textract 的实时 API 与我们在 第二章 中讨论的批量 API 做一个对比，介绍 Amazon Textract，通过以下表格帮助理解：

图 4.9 – Textract 同步 API 与批量 API 对比

注意

Textract 的定价是基于你将使用的三种不同 API 中的哪一种，分别是 Analyze Document（表单、表格）、Detect Text（文本提取）和 Analyze Expense（发票和收据）。无论你使用的是同步（sync）还是异步（async，批量）实现，都不会收取额外费用。因此，可以根据是否需要实时处理与批量处理来设计架构，因为定价是基于处理的文档数量，而与批量或实时模式无关。查看价格详情请访问：aws.amazon.com/textract/pricing/。

例如，LiveRight pvt Ltd. 可以使用 Detect Text API 的批量或实时实现来从其银行对账单中提取文本，处理数百万份文档。

我们在 图 14.2 中介绍了架构。该架构实现了 Amazon Textract Detect Text Sync API 的代码演示。现在，让我们看看如何通过 Lambda 函数实现架构自动化，以便扩展处理多个文档：

图 4.10 – 同步文档处理工作流

在前述架构中，我们演示了如何使用 Amazon Textract 的同步 API，通过同步文档处理工作流处理扫描图像。以下是该架构的步骤：

• 上传到 Amazon S3 的文档会向 Amazon SQS 队列发送消息以进行文档分析。Amazon SQS 是一种无服务器的托管队列服务，它会将文档轮询到队列中。

• 一个 Lambda 函数会通过包含队列消息的事件同步调用。

• 然后，Lambda 函数调用 Amazon Textract 同步 API，并将 Textract 输出或响应存储在 Amazon S3 或 Amazon DynamoDB 表中的响应元数据里。Amazon DynamoDB 是一个由 AWS 管理的 NoSQL 数据库，类似于键值存储。

您可以通过控制批处理大小和 Lambda 并发性来控制管道的吞吐量。

现在，我们将向您展示以下架构最佳实践，帮助您扩展多页扫描文档（这些文档可以是 PDF 或图片），并使用 Amazon Textract 的批处理 API 进行处理：

](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_04_11.jpg)

图 4.11 – 批量文档处理工作流程

在上面的图表中，我们展示了一个架构，展示了 Amazon Textract 批处理作业如何工作：

• 多页 PDF 和图片上传到 Amazon S3。这些文档被发送到 Amazon 简单队列服务（SQS）队列。

• 一个作业调度器 Lambda 函数以一定的频率运行，例如每 5 分钟一次，并轮询 SQS 队列中的消息。

• 对于队列中的每条消息，它会提交一个 Amazon Textract 作业来处理文档，并继续提交这些作业，直到达到 AWS 账户中并发作业的最大限制。

• 当 Amazon Textract 完成文档处理时，它会向 Amazon 简单通知服务（SNS）主题发送一个完成通知。

• SNS 然后触发作业调度器 Lambda 函数以启动下一组 Amazon Textract 作业。

• SNS 还会向 SQS 队列发送一条消息，然后由 Lambda 函数处理，以获取 Amazon Textract 的结果。结果会被存储在相关数据集中，例如 DynamoDB 或 Amazon S3。

这个 GitHub 链接，github.com/aws-samples/amazon-textract-serverless-large-scale-document-processing，包含了实现建议架构的代码示例，并且还有一些额外的组件，用于填充那些已经存在于 Amazon S3 存储桶中的文档。如果您有大文档进行实验，请随时设置并使用这个解决方案。

您还可以使用以下 GitHub 解决方案，github.com/aws-samples/amazon-textract-textractor，通过 Amazon Comprehend 提供的洞察实现大规模文档处理。

在本节中，我们介绍了使用实时处理或批处理与 Amazon Textract 的架构最佳实践。我们还展示了已经存在的一些 GitHub 实现，用于大规模文档处理。现在，让我们总结一下本章所涵盖的内容。

摘要

在本章中，我们介绍了如何使用 Amazon Textract 自动化您现有的文档。我们通过 LiveRight Pvt Ltd 提供的一个虚构银行用例展示了如何使用架构帮助银行自动化其贷款起源流程，并通过 Amazon Comprehend 设置合规性和控制。我们还介绍了使用样本银行对账单的代码示例，以及如何从扫描的银行对账单中提取数据并将其保存到 Amazon S3 中的 CSV.text 文件进行进一步分析。然后，我们展示了如何使用 Amazon Comprehend 使用同步 API 检测 PII，并如何使用 Amazon Comprehend 批处理 PII 擦除作业在 Amazon S3 中擦除该样本银行数据文本/CSV。

我们随后涵盖了一些关于使用实时处理文档工作流与批处理工作流的架构模式。我们还提供了一些 GitHub 实现，可用于处理大规模文档。

在本章中，您学习了何时以及如何使用实时 API 与批处理 API 来进行文档自动化的区别。您还学习了如何使用 Amazon Comprehend PII 作业设置 PII 擦除。

在下一章中，我们将看一个不同的用例，但它同样受企业欢迎，企业希望利用 NLP 极大化其业务价值，通过构建智能搜索索引。我们将介绍如何使用 Amazon Textract 和 Amazon Comprehend 以及 Amazon Elasticsearch 和 Amazon Kendra 来创建快速基于 NLP 的搜索。我们将介绍用例，讨论如何设计架构，建立先决条件，并详细讲解构建解决方案所需的各个步骤。

进一步阅读

• 使用 Amazon Textract 和 AWS Amplify 构建无服务器文档扫描仪，作者 Moheeb Zara (aws.amazon.com/blogs/compute/building-a-serverless-document-scanner-using-amazon-textract-and-aws-amplify/)

• 使用 Amazon Textract 从文档中自动提取文本和结构化数据，作者 Kashif Imran 和 Martin Schade (aws.amazon.com/blogs/machine-learning/automatically-extract-text-and-structured-data-from-documents-with-amazon-textract/)

第五章：第五章：创建 NLP 搜索

在前几章中，您已经了解了如何使用 Amazon Textract 提取文档中的文本，并使用 Amazon Comprehend 提取洞察，而无需提前具备 机器学习（ML）经验。在上一章中，我们向您展示了如何结合这些功能，通过贷款处理的实例，解决实际的文档自动化案例。

在本章中，我们将使用 Amazon Textract 和 Amazon Comprehend 服务，展示如何快速搭建一个智能搜索解决方案，并结合强大的元素，如 Amazon Elasticsearch，这是一项用于设置搜索和日志分析的托管服务，和 Amazon Kendra，这是一项由机器学习驱动的智能托管搜索解决方案，支持自然语言搜索。

本章将涵盖以下主题：

• 回顾搜索用例和搜索解决方案的选择

• 使用 Amazon Elasticsearch 为扫描图像构建搜索解决方案

• 使用 Amazon Kendra 设置企业搜索解决方案

技术要求

在本章中，您需要访问 AWS 账户。在开始之前，我们建议您按照以下步骤创建一个 AWS 账户：

1. 打开 portal.aws.amazon.com/billing/signup。

2. 请访问并执行网页上提供的步骤进行注册。

3. 在提示时登录到您的 AWS 账户。

本书的 GitHub 仓库中提供了 Amazon Textract 示例的 Python 代码和样本数据集，地址为：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/tree/main/Chapter%2005。

查看以下视频，查看代码演示：bit.ly/3nygP5S。

创建基于 NLP 的智能搜索索引

每个组织都有大量的文档，既有纸质文档，也有存档文件。问题在于，这些文档大多分散在不同的孤岛中，而不是集中在一个地方。因此，对于这些组织来说，基于这些孤立文档中的隐藏信息做出业务决策是极具挑战性的。这些组织采取的一些方法是将文档放入数据湖中以便搜索。然而，从这些文档中提取有意义的信息则是另一项挑战，因为这需要大量的自然语言处理（NLP）专业知识、机器学习（ML）技能以及搭建基础设施的能力。即使您能够从这些文档中提取出有价值的见解，另一个挑战将是建立一个可扩展的搜索解决方案。

本节将通过使用我们在前几章中介绍的 AWS AI 服务来解决这些挑战，并讨论如何利用这些服务建立一个集中式的文档存储。

一旦所有文档都存储在像 Amazon S3 这样的集中存储服务中，Amazon S3 是一种可扩展、耐用的对象存储，类似于 Dropbox，我们可以使用 Amazon Textract（如在 第二章 中介绍的）提取这些文档中的文本，并使用 Amazon Comprehend（如在 第三章 中介绍的）提取基于 NLP 的洞察，如实体、关键词、情感等。此外，我们可以快速对这些洞察和文本进行索引，并将其发送到 Amazon Elasticsearch 或 Amazon Kendra，以建立智能搜索解决方案。

以下图示展示了我们将在本节中讨论的架构：

图 5.1 – 创建基于 NLP 的搜索索引

在 图 5.1 中，你可以看到我们构建搜索索引的两种选项，具体如下：

1. 使用 Amazon Elasticsearch 在基于 Amazon Textract 和 Amazon Comprehend 的文档处理管道上构建搜索

2. 使用 Amazon Kendra 在现有的基于 Amazon Textract 和 Amazon Comprehend 的文档处理管道上构建无服务器的智能搜索

如果你正在寻找基于自然语言的搜索解决方案，且该解决方案由机器学习驱动，让你能够提问类似人类的问题，而不是只进行关键词搜索，你可以选择 Amazon Kendra 进行搜索，因为 Amazon Kendra 是一个由机器学习驱动的 AWS AI 服务。Amazon Kendra 提供自然语言搜索功能，并将为你提供基于自然语言处理（NLP）的答案，也就是说，提供类似人类的上下文答案。例如，假设你正在为 Salesforce 中的 IT 支持文档设置搜索功能。使用 Amazon Kendra，你可以直接提问诸如 “IT 服务台在哪里？” 这样的问题，Amazon Kendra 会给出精确的回答，比如 "在六楼"，而在 Amazon Elasticsearch 中，你只能进行基于关键词的搜索。

此外，你还可以将 Amazon Kendra 集成到 Amazon Lex 中，后者是一个用于创建聊天机器人的服务。你可以在网站上部署由 Amazon Lex 和 Amazon Kendra 提供支持的智能搜索聊天机器人。Amazon Kendra 还提供了大量连接器，能够发现并索引你的数据进行搜索，包括 Amazon S3、OneDrive、Google Drive、Salesforce、RDS 等关系型数据库，以及许多第三方供应商支持的其他平台。

你可以在许多不同的有趣用例中设置搜索功能，例如，财务分析师在寻找财务事件时，通常需要浏览大量的 SEC 文件报告，查找有意义的财务实体，如并购事件。使用提议的流程管道以及 Amazon Comprehend Events，可以轻松减少浏览这些文档时的时间和噪音，并在出现财务事件（如并购）时及时更新他们的财务模型。

对于医疗保健公司，他们可以利用 Amazon Comprehend Medical 提供的一整套服务和选项来创建智能搜索，医生可以登录并从 Amazon HealthLake 中集中管理的患者数据中搜索相关的关键词或信息。本章将进一步介绍这一用例。

我们都知道找工作非常困难。对于猎头公司来说，要在成千上万的简历中寻找合适的候选人和相关技能更是难上加难。你可以使用提出的解决方案，建立一个简历处理流水线，将不同候选人的简历上传到 Amazon S3，并根据你所寻找的职位要求，搜索相关技能。

在本节中，我们介绍了两种设置智能搜索索引的选项。在下一节中，我们将展示如何设置此架构，创建一个 NLP 驱动的搜索应用程序，在这个应用程序中，人力资源（HR）管理员用户可以快速上传候选人的扫描简历，其他用户可以登录并根据职位空缺搜索相关的技能集。

使用 Amazon Elasticsearch 构建扫描图像搜索解决方案

在前面的章节中，我们讨论了如何使用 Amazon Lambda 函数创建一个无服务器应用程序。在本节中，我们将通过以下架构，带你一步步建立一个基于扫描图像的搜索解决方案，通过 Amazon Lambda 函数调用 Amazon Textract 和 Amazon Comprehend APIs。我们将为此用例使用 Amazon Elasticsearch。不过，你也可以将 Amazon Elasticsearch 替换为 Amazon Kendra，以创建一个基于 ML 的搜索解决方案，在其中你可以使用自然语言提问进行搜索。

图 5.2 – 使用 Amazon Elasticsearch 构建 NLP 搜索

在之前的架构中使用的 AWS 服务是Amazon Cognito，用于设置后台用户的登录。

Amazon S3 用于集中存储。Amazon Lambda 函数作为无服务器事件触发器，在扫描的简历上传到 Amazon S3 后触发，然后我们使用 Amazon Textract 和 Amazon Comprehend 提取文本和洞察信息，如关键短语和实体。接着我们将所有数据索引到 Amazon Elasticsearch。最终用户可以通过 Cognito 登录，并通过与 Amazon Elasticsearch 集成的 Kibana 仪表盘进行可视化访问 Amazon Elasticsearch。

先决条件

我们将使用 AWS CloudFormation 模板来启动本章所需的资源。CloudFormation 模板是以 YAML 或 JSON 格式编写的脚本，用于启动资源或基础设施即代码（IaC）。AWS CloudFormation 模板编写 IaC，并为你设置所有必要的权限：

1. 点击forindexing.s3.eu-west-1.amazonaws.com/template-export-textract.yml下载并部署 AWS CloudFormation 模板。

   图 5.3 – CloudFormation 模板堆栈

2. 向下滚动到documentsearchapp，并找到如以下截图所示的DOMAINNAME:

   图 5.4 – 输入参数

3. 向下滚动并勾选Capabilities and transforms下的所有三个确认框，然后点击Create stack。

   图 5.5 – Capabilities and transforms 部分

4. 您将看到堆栈创建过程正在进行中。请等待直到完成，像下面的截图所示——您可以刷新页面以查看状态的变化。部署此堆栈可能需要 20 分钟，趁此机会去喝杯咖啡吧:

   图 5.6 – CloudFormation 资源创建完成

   注意：

   在您的堆栈创建过程中，您将收到一封包含 Cognito 登录详细信息的电子邮件。请确保检查在创建此堆栈时提供的相同电子邮件。管理员可以在部署后通过 Amazon Cognito 控制台添加多个用户的电子邮件地址。这些电子邮件可以发送给最终用户，在将简历数据上传到 Amazon S3 后，用户可以登录系统。

5. 转到Outputs标签页，向下滚动到Outputs部分。

   图 5.7 – CloudFormation 输出

6. 从Value部分复制S3KeyPhraseBucket和KibanaLoginURL的值。我们将在本节中使用这些链接，逐步指导您操作此应用程序。

现在，您已经通过 CloudFormation 设置了基础设施，包括 Amazon S3 桶、Lambda 函数、Cognito 登录、Kibana 以及 Amazon Elasticsearch 集群。您已经获得了 CloudFormation 的输出，其中包含 S3 桶和 Kibana 仪表板登录的 URL。在接下来的部分中，我们将向您展示如何将扫描的图像上传到此应用程序，并以管理员身份进行交互。

上传文档到 Amazon S3

我们将开始以下步骤来上传文档到 Amazon S3:

1. 点击从上一节 CloudFormation 模板输出中复制的 S3 链接。然后，下载github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2005/resume_sample.PNG中的示例简历，并通过点击Upload按钮，再点击Add files上传到 S3。

   图 5.8 – Amazon S3 中的扫描图像

2. 这个上传触发了一个 Amazon S3 事件通知到 AWS Lambda 函数。要检查此项，请转到属性标签页，然后滚动到事件通知，如下截图所示：

   图 5.9 – S3 事件通知以通知 AWS Lambda 函数

3. 点击目标下显示的 Lambda 函数链接。我们将在下一节中检查这个 Lambda 函数。

我们已将示例扫描简历上传到 Amazon S3，并且还向你展示了在哪里可以找到触发 Lambda 函数的 S3 事件通知。在下一节中，让我们一起探索 Lambda 函数中发生了什么。

检查 AWS Lambda 函数

在本节中，我们将检查 AWS Lambda 的代码块以及对 Amazon Textract 和 Amazon Comprehend 的 API 调用，并结合使用 Amazon Elasticsearch。

图 5.10 – AWS Lambda 函数

部署代码过于庞大，无法在此 AWS Lambda 控制台中显示。你可以通过以下 GitHub 仓库访问代码：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2005/lambda/index.py：

1. 首先，我们通过 Amazon S3 事件获取文件，如下所示是来自主 Lambda 处理程序的代码块。在 Lambda 中，所有代码块都从这个主处理程序执行。handler 方法会在每次函数调用时由 Lambda 调用，作为入口点。处理程序外的代码包含可以从主处理程序调用的函数以及一些全局变量：

   def handler(event, context):
   bucket = event['Records'][0]['s3']['bucket']['name']
   key = unquote_plus(event['Records'][0]['s3']['object']['key'])
   

2. 以下代码从 Amazon S3 下载文件，以便使用 Textract 和 Comprehend 进行处理：

          s3.Bucket(bucket).download_file(Key=key,Filename='/tmp/{}')
           with open('/tmp/{}', 'rb') as document:
               imageBytes = bytearray(document.read())
           print("Object downloaded")
   

3. 在通过 S3 事件获取对象或扫描简历并通过 Lambda 函数读取后，我们将调用 Amazon Textract AnalyzeDocument API，这是一个实时 API，用于提取文本，代码如下：

   response = textract.analyze_document(Document={'Bytes': imageBytes},FeatureTypes=["TABLES", "FORMS"])
   document = Document(response)
   

4. 我们将解析响应，提取要发送到 Amazon Comprehend 的文本行：

    blocks=response['Blocks']
           for block in blocks:
               if block['BlockType'] == 'LINE':
                    text += block['Text']+"\n"
             print(text)
   

5. 一旦提取了文本，我们将通过将其放入列表变量中调用 Comprehend Keyphrase API，以便稍后进行索引：

   keyphrase_response = comprehend.detect_key_phrases(Text=text, LanguageCode='en')
   KeyPhraseList=keyphrase_response.get("KeyPhrases")
    for s in KeyPhraseList:
                               textvalues.append(s.get("Text")
   

6. 现在我们将使用 Comprehend DetectEntities API 提取实体，并将其保存在映射数据结构变量中，以便稍后进行索引：

   detect_entity= comprehend.detect_entities(Text=text, LanguageCode='en')
   EntityList=detect_entity.get("Entities")
   for s in EntityList:
                                            textvalues_entity.update([(s.get("Type").strip('\t\n\r'),s.get("Text").strip('\t\n\r'))]
   

7. 现在我们将创建一个要进行索引的 Amazon S3 URL：

   s3url='https://s3.console.aws.amazon.com/s3/object/'+bucket+'/'+key+'?region='+region
   

8. 我们已经获取了文本、关键词和实体，以及上传文档的 S3 链接。接下来，我们将对其进行索引并上传到 Elasticsearch：

   searchdata={'s3link':s3url,'KeyPhrases':textvalues,'Entity':textvalues_entity,'text':text, 'table':table, 'forms':forms}
   print(searchdata)
   print("connecting to ES")
   es=connectES()
   es.index(index="document", doc_type="_doc", body=searchdata)
   

   注意：

   如果简历中包含表格或表单，我们已经准备好对它们进行索引。此外，这个解决方案还可以用于发票搜索。

在本节中，我们向您展示了如何从上传到 Amazon S3 的文档中提取文本和洞察。我们还将数据索引到 Amazon Elasticsearch 中。在接下来的部分，我们将向您展示如何使用您在创建 CloudFormation 模板时设置的管理员登录邮件登录 Kibana，并在 Kibana 仪表板中可视化数据。

在 Kibana 控制台中搜索并发现数据

在本节中，我们将讲解如何通过 Amazon Cognito 使用您在通过 AWS CloudFormation 部署资源时输入的管理员电子邮件来注册 Kibana。然后，我们将向您展示如何在 Kibana 中设置索引。我们还将展示如何根据来自 Amazon Comprehend 的实体、关键词和表格过滤器在 Kibana 仪表板中发现和搜索数据。最后，您可以从 Amazon S3 下载搜索到的简历链接。

我们将包括 Kibana 控制台的注册过程、使索引可被搜索功能发现，以及如何在 Kibana 中搜索洞察。

注册 Kibana 控制台

在这些步骤中，我们将向您演示如何使用 CloudFormation 生成的输出链接登录 Kibana：

1. 点击您从 CloudFormation 输出中获得的 Kibana 登录链接，如以下截图所示：

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_05_11.jpg)

   图 5.11 – CloudFormation 输出 – Kibana URL

2. 该链接将把您重定向到此控制台：

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_05_12.jpg)

   图 5.12 – Kibana 登录对话框

   注意：

   您可以通过点击前一截图中显示的注册按钮来注册更多的终端用户。

3. 您应该已收到一封包含用户名和临时密码的电子邮件 – 在前面的对话框中输入这些信息，然后点击Sign in。

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_05_13.jpg)

   图 5.13 – 验证和密码登录邮件

4. 第一次登录时，系统会要求您更改密码。更改密码后，您将被重定向到 Kibana 控制台。

我们已经讲解了如何注册 Kibana。在接下来的部分，我们将向您展示如何在 Kibana 中设置索引。

使索引可被搜索功能发现

在本节中，我们将向您展示如何在 Kibana 中设置索引以进行搜索：

1. 到达 Kibana 控制台后，点击Discover，我们将引导您在 Kibana 中设置索引。

   图 5.14 – Kibana 创建索引模式页面

2. 在Index pattern字段中输入document，如以下截图所示，然后点击Next step：

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_05_15.jpg)

   图 5.15 – 定义索引模式

3. 点击Create index pattern。这将使您的 Elasticsearch 索引可搜索。

](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_05_16.jpg)

图 5.16 – 创建索引模式

我们已经创建了索引。现在我们将开始搜索见解。

在 Kibana 中搜索见解

在本节中，我们将带您了解如何在 Kibana 中搜索见解：

1. 点击 Discover，在左侧您将找到可以添加到搜索筛选器中的实体和关键词短语，位于 可用字段 下。

   图 5.17 – Kibana 的 Discover 仪表盘 (a)

   让我们看一下以下截图中的另一个输出：

   

   图 5.18 – Kibana 的 Discover 仪表盘 (b)

2. 实体搜索：通过添加 Entity.TITLE 和 Entity.dATE 等可用字段，按日期和职位搜索候选人以快速查找。您可以点击 添加筛选器，这些筛选器将如下面的截图所示被添加。您可以看到它找到了 2017 年 7 月具有大数据分析职称的人：

   图 5.19 – 向选定字段添加实体筛选器

3. 使用关键词和表格进行搜索：从 可用字段 中添加 关键词短语 和 表格筛选器，您将获得一张汇总表，列出所有您需要的技能，以及关于候选人的关键词短语。

   图 5.20 – 关键词和表字段搜索

4. 在搜索框中输入 Amazon Sagemaker 和 MySQL，查看是否有符合我们需求的候选人简历。我们能够找到一份同时具备这两项技能的候选人简历，如下图所示：

   图 5.21 – 使用 AND 条件的关键词搜索

5. 下载匹配候选人简历：我们可以通过在 选定字段 上添加 S3 链接来下载匹配候选人的简历，如下所示：

图 5.22 – 下载简历的 S3 链接

在本节中，我们为您提供了扫描图像搜索解决方案的架构概述，其中管理员用户将扫描的文档上传到 Amazon S3，然后展示了如何注册 Kibana 仪表盘并搜索关键词，从扫描文档中获取有意义的见解。

我们已经带您完成了使用 AWS CloudFormation 模板一键部署架构的步骤，您可以查看 进一步阅读 部分，了解如何创建这些模板。我们还展示了如何通过上传一些示例文档与此应用程序进行交互。我们指导您如何设置 Kibana 仪表盘，并提供了一些示例查询，以便通过关键词和实体作为筛选条件获得见解。

在接下来的章节中，我们将探索一个基于 Kendra 的搜索解决方案。让我们开始探索 Amazon Kendra，以及如何通过使用它为 Textract 和 Comprehend 提供支持，来加速文档处理工作流。

使用 Amazon Kendra 设置企业级搜索解决方案

本节将介绍如何使用 Amazon Kendra 快速创建一个端到端的无服务器文档搜索应用。

本节将介绍开始使用的步骤。

Git 克隆笔记本

我们将演示如何 Git 克隆笔记本，并展示如何使用简单的 boto3 API 设置基于 Kendra 的搜索架构的代码示例。

1. 在前面章节中设置的 SageMaker Jupyter 笔记本中，使用 Git 克隆github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/。

2. 前往Chapter 05/Ch05-Kendra Search.ipynb并开始运行笔记本。

   注意：

   请为 SageMaker 笔记本的 IAM 角色添加 Kendra IAM 访问权限，以便你能够通过该笔记本调用 Kendra API。在前面的章节中，你已经为 SageMaker 笔记本添加了对 Amazon Comprehend 和 Textract API 的 IAM 访问权限。

创建 Amazon S3 存储桶

我们将展示如何创建 Amazon S3 存储桶。我们将使用此存储桶作为 Kendra 数据源，并用于存储从 Amazon Textract 提取的数据。

1. 通过访问 Amazon S3 控制台s3.console.aws.amazon.com/s3/home?region=us-east-1来创建一个 Amazon S3 存储桶。

2. 点击创建存储桶按钮，并输入任意存储桶名称，如下图所示：

   图 5.23 – 创建一个 Amazon S3 存储桶

3. 向下滚动并点击创建存储桶。

4. 复制已创建的存储桶名称，打开Chapter 05/Ch05-Kendra Search.ipynb，并在以下单元格中将其粘贴到'<your s3 bucket name>'的位置开始：

   # Define IAM role
   role = get_execution_role()
   print("RoleArn: {}".format(role))
   sess = sagemaker.Session()
   s3BucketName = '<your s3 bucket name>'
   prefix = 'chapter5'
   

我们已经准备好了笔记本，并且为本节的解决方案创建了 Amazon S3 存储桶。接下来，我们将通过快速的架构演示，帮助你了解关键组件，随后会引导你通过你已经设置的笔记本中的代码。

演示解决方案

设置企业级搜索可能比较困难。这就是为什么我们有 Amazon Kendra，它可以通过各种数据连接器爬取数据，快速创建简单的搜索解决方案。在接下来的架构中，我们将引导你了解如何在将 PDF 文档存储在 Amazon S3 中时设置文档搜索。我们将使用 Amazon Textract 从这些 PDF 文档中提取数据，并将其发送到 Amazon Comprehend，以提取一些关键实体，如组织、标题、日期等。这些实体将作为过滤器，在我们将文档直接同步到 Amazon Kendra 进行搜索时使用。

图 5.24 – 基于 Textract 和 Comprehend 的 Amazon Kendra 搜索架构

所以，我们在前面的图示中给出了一个高层次的实现架构。在下一节中，我们将向你展示如何用几行代码以及 Python Boto3 API 构建这个架构。

代码讲解

在本节中，我们将带你快速设置建议的架构：

1. 我们将参考这个笔记本：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2005/Ch05-Kendra%20Search.ipynb。以下代码展示了用于 Comprehend、Kendra 和 Textract API 的 Boto3 客户端设置。

   comprehend = boto3.client('comprehend')
   textract= boto3.client('textract')
   kendra= boto3.client('kendra')
   

2. 现在我们将从这个仓库上传 PDF 文档 github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2005/resume_Sample.pdf 到 Amazon S3。

   注意：

   你可以上传任意数量的文档进行搜索。为了演示，我们只提供了一个样本。请随意上传你的文档到 Amazon S3，并在开始同步文档到 Amazon Kendra 之前生成元数据文件。

   为了从上传到 Amazon S3 的 PDF 中提取文本，我们将使用与在第二章中处理异步过程相同的代码，介绍 Amazon Textract。

3. 以下代码展示了如何从 Amazon Textract 提取文本：

   text=""
   for resultPage in response:
       for item in resultPage["Blocks"]:
           if item["BlockType"] == "LINE":
               #print ('\033[94m' +  item["Text"] + '\033[0m')
               text += item['Text']+"\n"
   print(text)
   

   以下屏幕截图展示了从 PDF 中提取的文本：

   

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_05_25.jpg)

   图 5.25 – 从 Amazon Textract 提取的简历数据文本响应

4. 现在我们将通过运行以下代码将文本发送到 Amazon Comprehend 进行实体提取：

   entities= comprehend.detect_entities(Text=text, LanguageCode='en')
   

5. 现在我们将创建一个 Amazon Kendra 索引。请访问 Kendra 控制台 console.aws.amazon.com/kendra/home?region=us-east-1#indexes，点击索引名称，然后向下滚动并点击创建新角色（推荐），如下图所示：

   图 5.26 – 为 Kendra 索引创建新角色

6. 输入AmazonKendra-us-east-1-kendra作为角色名称并点击AmazonKendra-us-east-1-。

7. 对于配置用户访问控制，选择否以表示不使用令牌进行访问控制，然后点击下一步。

8. 对于指定配置，选择开发者版，然后点击创建。或者，在创建 IAM 角色后，您可以运行以下笔记本单元格，使用编程方式创建索引：

   response = kendra.create_index(
       Name='Search',
       Edition='DEVELOPER_EDITION',
       RoleArn='<enter IAM role by creating IAM role in IAM console')
   print(response)
   

   注意：

   索引创建可能需要最多 30 分钟。

9. 创建索引后，我们需要获取索引 ID，以便在此笔记本中运行。一旦索引创建完成，点击索引并进入索引设置以复制索引 ID。

   图 5.27 – 从 Kendra 控制台复制 Kendra 索引 ID

   或者，如果您使用CreateIndex API编程创建了索引，其响应将包含一个 36 位数字的索引 ID，您需要复制并粘贴该 ID，然后运行下一段代码，以根据 Comprehend 实体更新搜索过滤器。

10. 将 Kendra 索引 ID 复制并粘贴到以下单元格中的占位符处，然后运行该单元格以更新我们使用过滤器进行搜索的索引。有关完整代码以添加所有过滤器，请参阅笔记本：

    response = kendra.update_index(
        Id="<paste Index Id from Create Index response>",
        DocumentMetadataConfigurationUpdates=[
            {
                'Name':'ORGANIZATION',
                'Type':'STRING_LIST_VALUE',
                'Search': {
                    'Facetable': True,
                    'Searchable': True,
                    'Displayable': True
                }
            }}
    

11. 现在我们将定义 Comprehend 识别的类别列表：

    categories = ["ORGANIZATION", "PERSON", "DATE", "COMMERCIAL_ITEM", "OTHER", "TITLE", "QUANTITY"]
    

12. 现在，我们将遍历这些实体并生成一个元数据文件，以便根据 Amazon Comprehend 中的实体填充过滤器：

    for e in entities["Entities"]:
        if (e["Text"].isprintable()) and (not "\"" in e["Text"]) and (not e["Text"].upper() in category_text[e["Type"]]):
                    #Append the text to entity data to be used for a Kendra custom attribute
                    entity_data[e["Type"]].add(e["Text"])
                    #Keep track of text in upper case so that we don't treat the same text written in different cases differently
                    category_text[e["Type"]].append(e["Text"].upper())
                    #Keep track of the frequency of the text so that we can take the text with highest frequency of occurrance
                    text_frequency[e["Type"]][e["Text"].upper()] = 1
        elif (e["Text"].upper() in category_text[e["Type"]]):
                    #Keep track of the frequency of the text so that we can take the text with highest frequency of occurrance
                    text_frequency[e["Type"]][e["Text"].upper()] += 1
    print(entity_data)
    

13. 您将收到一个响应，详细说明从 PDF 文档中的文本检测到的 Comprehend 实体类型和值。

    图 5.28 – Comprehend 提取的实体

14. 从先前的实体填充 Kendra 元数据列表，以便为 Amazon Kendra 属性过滤器使用：

    elimit = 10
    for et in categories:
    

15. 选择elimit数量的识别文本字符串，这些字符串的出现频率最高：

        el = [pair[0] for pair in sorted(text_frequency[et].items(), key=lambda item: item[1], reverse=True)][0:elimit]
        metadata[et] = [d for d in entity_data[et] if d.upper() in el]
    metadata["_source_uri"] = documentName
    attributes["Attributes"] = metadata
    

16. 最后一步是将此文件保存为metadata.json。确保文件名是原始 PDF 文档的文件名，后面跟上metadata.json，并将其上传到您的 PDF 文档所在的 Amazon S3 存储桶中：

    s3 = boto3.client('s3')
    prefix= 'meta/'
    with open("metadata.json", "rb") as f:
        s3.upload_file( "metadata.json", s3BucketName,'%s/%s' % ("meta","resume_Sample.pdf.metadata.json"))
    

我们已经向您展示了如何上传 PDF 文档，使用 Amazon Textract 提取数据，然后使用 Amazon Comprehend 提取实体。然后，我们使用 Comprehend 提取的过滤器或实体创建了一个元数据文件，并将其上传到 Amazon S3。在下一部分，我们将向您展示如何将 Amazon Kendra 与您上传的 S3 文档同步，并且如何创建一个meta文件夹并将您的元数据文件放置在其中，以便 Amazon Kendra 在同步时将其作为元数据过滤器。

使用来自 Comprehend 的增强过滤器在 Amazon Kendra 中进行搜索

在这一部分，我们将向您展示如何将文档同步到您创建的索引，并同步元数据文件中的过滤器：

1. 将 Kendra 数据源设置为你上传文档的 Amazon S3 存储桶。导航到Amazon Kendra | 索引 | <索引名称>| 数据源 | 添加数据源 | Amazon S3，如下面的截图所示：

   图 5.29 – 配置 Amazon Kendra 同步

2. 在 meta/ 中输入 s3://<你的存储桶名称>，如前面的截图所示。

3. 在 角色名称 字段中填写 AmazonKendra-s3。

   图 5.30 – Kendra 按需运行的计划

4. 然后将同步运行计划的频率设置为按需运行，并点击下一步。

5. 点击 审核 + 创建。

6. 数据源创建后，点击 立即同步。

一旦同步成功，所有你在 Amazon S3 中的文档将被同步，Kendra 过滤器将填充由 Amazon Comprehend 提取的元数据属性。

在下一节中，我们将带你了解如何导航到 Amazon Kendra 控制台进行搜索。

在 Amazon Kendra 中进行搜索

Amazon Kendra 附带一个内置的搜索 UI，可用于测试搜索功能。

测试后，你还可以在 React 应用中部署此 UI。页面 docs.aws.amazon.com/kendra/latest/dg/deploying.html 提供了部署 UI 的代码，可以与任何使用 API Gateway 和 Lambda 的无服务器应用程序集成。

你还可以使用 Kendra.query() API 从你在 Kendra 中创建的索引中检索结果。

在本节中，我们将带你了解如何使用内置的 Kendra 搜索控制台：

1. 在搜索框中导航到 具有云技能的人员：

   图 5.31 – Kendra 查询结果

   Amazon Kendra 能够提供包含简历中 Jane Doe 的上下文答案，我们已将其简历索引。

   它还为你提供基于 Comprehend 实体的过滤器，位于左侧，可以根据 组织、职位、日期 等实体以及它们的词频快速对个人进行排序。

   你还可以创建 Comprehend 自定义实体，正如我们在 第四章* 自动化文档处理工作流* 中介绍的那样，依据你的业务需求丰富你的元数据过滤器。

2. 接下来，在 Kendra 搜索控制台中输入 具有 10 年经验的人员 查询。

图 5.32 – Kendra 查询结果，左侧显示 Comprehend 元数据增强的过滤器

Amazon Kendra 能够为你提供准确的上下文答案。你还可以根据相关性提高 Kendra 的响应，并通过点赞和点踩按钮提供反馈，改进你的 Kendra 模型。

注意：

Amazon Kendra 支持使用 PDF、Word、JSON、TXT、PPT 和 HTML 文档进行搜索功能。可以通过此管道添加更多文档，以提高搜索结果和准确性。

摘要

在本章中，我们介绍了设置文档处理工作流的智能搜索解决方案的两种选项。第一个选项涉及快速设置基于 NLP 的搜索，使用 Amazon Textract、Amazon Comprehend 和 Amazon Elasticsearch，通过 Lambda 函数和 CloudFormation 模板进行扫描简历分析，并且可以用于任何扫描的内容，如图像、发票或收据。第二个选项，我们介绍了如何为您的 PDF 文档设置一个企业级的无服务器可扩展搜索解决方案，使用 Amazon Kendra。我们还向您展示了如何利用从 Amazon Comprehend 生成的命名实体，丰富 Amazon Kendra 搜索的额外属性或元数据。

在下一章中，我们将讨论如何使用 AI 来提升联系中心的客户服务。

深入阅读

• 使用 Amazon Textract 和 Amazon Comprehend 构建 NLP 驱动的搜索索引，作者：Mona Mona 和 Saurabh Shrivastava（aws.amazon.com/blogs/machine-learning/building-an-nlp-powered-search-index-with-amazon-textract-and-amazon-comprehend/）

• 构建智能搜索解决方案与自动化内容丰富，作者：Abhinav Jawadekar 和 Udi Hershkovich（aws.amazon.com/blogs/machine-learning/build-an-intelligent-search-solution-with-automated-content-enrichment/）

第六章：第六章：利用 NLP 提升客户服务效率

到目前为止，我们已经看到了一些有趣的现实世界 NLP 应用案例，比如在第四章中用于贷款申请的智能文档处理解决方案，自动化文档处理工作流，以及在第五章中构建的智能搜索索引，创建 NLP 搜索。基于 NLP 的内容搜索索引正变得越来越流行，因为它弥补了传统基于关键词的搜索与自然语言搜索之间的差距。传统的关键词搜索可能让人感到沮丧，除非你知道要使用的确切关键词，而自然语言搜索则可以帮助快速找到你感兴趣的内容。我们还看到，如何利用 Amazon Textract 和 Amazon Comprehend 与如 Amazon Elasticsearch(aws.amazon.com/elasticsearch-service/)这样的服务进行集成，Amazon Elasticsearch 是由 AWS 完全管理的服务，提供开源 Elasticsearch 提供的搜索和分析功能，但无需处理设置 Elasticsearch 集群时的基础设施负担、安装或维护问题；以及 Amazon Kendra(aws.amazon.com/kendra/)，这是一个由机器学习驱动的完全托管企业搜索引擎，提供基于 NLP 的搜索功能，可以用来创建端到端的智能搜索解决方案。在本章中，我们将讨论一个普遍存在的用例，它已经存在了几十年，甚至几个世纪，但对于任何企业来说依然非常重要——那就是客户服务的改进。

企业如果没有客户，就无法发展，而客户满意度是一个关键指标，直接与组织的盈利能力相关。虽然组织在销售周期中与客户接触的各个环节非常重要，但更为关键的是其客户服务流程的有效性。组织需要迅速响应客户反馈，理解客户对话中的情感潜流，并在最短时间内解决问题。满意的客户是忠诚的客户，当然，这意味着客户流失率低，从而有助于降低成本并提高盈利能力。

为了展示客户服务改进的实际应用，我们将构建一个使用 AWS NLP 服务——Amazon Comprehend 的 AI 解决方案，分析历史客户服务记录，通过 Amazon Comprehend 主题建模提取关键主题，训练一个自定义分类模型，使用 Amazon Comprehend 自定义分类来预测呼叫路由的主题，并使用 Amazon Comprehend 情感检测来理解客户反馈的情感。我们将在本章中进行动手实践，但我们已经准备好所有需要的代码样本，以便开始。

在本章中，我们将涵盖以下主题：

• 引入客户服务用例

• 构建自然语言处理解决方案以改进客户服务

技术要求

对于本章，您将需要访问 AWS 账户。请确保您按照第二章中技术要求部分的说明来创建您的 AWS 账户。在尝试构建自然语言处理解决方案以改进客户服务部分的步骤之前，您还需要登录 AWS 管理控制台。

我们解决方案的 Python 代码和示例数据集可以在github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/tree/main/Chapter%2006找到。请按照以下部分的说明和本存储库中的代码构建解决方案。

查看以下视频以查看代码在bit.ly/2ZpWveN的实际应用。

介绍客户服务使用案例

那么，自然语言处理如何帮助我们改进客户服务呢？为了说明我们的例子，让我们回到我们的虚构银行公司LiveRight Holdings private limited。LiveRight在美国的许多州设有联系中心，他们每天收到超过 100,000 通来自客户的查询和问题，涉及信用、账户、债务等各种主题。虽然他们有一支经验丰富的团队处理客户请求，但他们的一线分流团队经常在第一分钟内解读客户请求的性质时遇到困难，这对他们来说是重要的服务水平协议。这是为了确定将请求路由给哪些代理人。他们有一支根据产品类型和经验水平专门的代理团队。初级代理处理对产品满意的客户，而处理恼怒客户的挑战通常是更有经验的代理人的任务。

LiveRight的高级管理层对一线团队的表现不满，因为他们总是未能满足 1 分钟 SLA 的要求。更糟糕的是，在过去的 3 个月里，一线团队错误地将不满的客户转接给了初级代理，导致了客户流失的增加。因此，高级管理层希望自动化一线筛选流程，以便他们的团队能够解决这些问题。LiveRight聘请你设计一个解决方案架构，能够自动确定路由选项和客户对话的情绪。作为该项目的企业架构师，你决定使用 Amazon Comprehend，利用其预训练的机器学习模型进行情感分析，使用 Comprehend 内置的主题建模功能来确定训练数据集中常见的主题，从而确定路由选项标签，并利用 Amazon Comprehend 的自定义分类器功能逐步创建属于自己的客户请求路由分类器，而无需构建复杂的自然语言处理算法。我们将构建的解决方案组件如下图所示：

图 6.1 – 客户服务的自然语言处理解决方案构建

我们将使用 Amazon SageMaker Jupyter 笔记本演示这个解决方案，这将使我们能够逐步查看代码和结果。有关如何使用 AWS Lambda（一个无服务器、事件驱动的计算服务来运行代码）将此解决方案构建为实时工作流的代码示例，请参考进一步阅读部分：

1. 第一阶段，我们将对输入数据集进行预处理，数据集中包含本书 GitHub 仓库中的消费者投诉内容，将其加载到 S3 桶中，并运行 Amazon Comprehend 的主题建模作业，以确定路由选项标签。

2. 然后，我们将创建包含已分配给消费者投诉的路由选项标签的训练数据集，并将其上传到 S3 桶中。

3. 我们将使用 Amazon Comprehend 自定义分类功能，利用我们先前创建的训练数据集训练分类器模型。

4. 最后，我们将创建一个 Amazon Comprehend 实时端点，部署训练好的模型，并演示如何预测路由选项。然后，我们将演示如何使用 Amazon Comprehend 的情感分析 API 实时确定客户对话的情绪。

在本节中，我们介绍了通过我们的自然语言处理解决方案试图解决的客户服务问题，回顾了LiveRight面临的挑战，并概述了我们将要构建的解决方案。在下一节中，我们将逐步展示解决方案的构建过程。

构建自然语言处理解决方案以改善客户服务

在上一部分，我们介绍了客户服务的联络中心用例，概述了我们将要构建的解决方案架构，并简要回顾了解决方案组件和工作流程步骤。在本节中，我们将开始执行构建解决方案的任务。但首先，我们必须处理一些前提条件。

设置以解决用例

如果您在之前的章节中还未完成此操作，您需要创建一个 Amazon SageMaker Jupyter notebook，然后设置 Chapter 06 文件夹，打开 chapter6-nlp-in-customer-service-github.ipynb notebook，并在 notebook 中提供存储桶名称以开始执行。

注意

请确保您已完成技术要求部分中提到的任务。

如果您已经在之前的章节中完成了以下步骤，请直接跳到预处理客户服务历史数据部分：

1. 请参考 Amazon SageMaker 文档创建一个 notebook 实例：docs.aws.amazon.com/sagemaker/latest/dg/gs-setup-working-env.html。要按照这些步骤操作，请登录AWS 管理控制台，然后在搜索框中输入并选择Amazon SageMaker。接着，导航到Amazon SageMaker控制台。

2. 选择Notebook 实例，通过指定实例类型、存储和 IAM 角色来创建一个 Notebook 实例。

   创建 Amazon SageMaker Jupyter notebooks 时的 IAM 角色权限

   在 notebook 创建时接受 IAM 角色的默认设置，以允许访问任何 S3 存储桶。通过点击 IAM 角色并导航到身份和访问管理控制台，为正在创建的角色选择ComprehendFullAccess作为权限策略。您随时可以返回到您的 notebook 实例的 IAM 角色，并根据需要附加其他权限策略。

3. 创建了 notebook 实例并且其状态为InService后，点击 notebook 实例的操作菜单中的打开 Jupyter：

   图 6.2 – 打开 Jupyter notebook

   这将把您带到 notebook 实例的主文件夹。

4. 点击新建，然后选择终端，如下面的截图所示：

   图 6.3 – 在 Jupyter notebook 中打开终端

5. 在终端窗口中，输入 cd SageMaker，然后 git clone github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services，如下面的截图所示：

   图 6.4 – git clone 命令

6. 现在，退出终端窗口并返回主文件夹。您将看到一个名为Natural-Language-Processing-with-AWS-AI-Services的文件夹。点击它；您将看到一个名为Chapter 06的文件夹。点击该文件夹；您应该能看到一个名为chapter6-nlp-in-customer-service-github的 Notebook。

7. 点击此 Notebook 以打开它。

8. 按照本 Notebook 中与本节接下来几个小标题对应的步骤操作，一次执行一个单元格。请阅读每个 Notebook 单元格上方提供的描述。

现在我们已经设置好 Notebook 并克隆了代码库，让我们添加所需的权限策略，以便成功运行我们的代码示例。

其他 IAM 先决条件

为了训练 Comprehend 自定义实体识别器并设置实时端点，我们需要启用额外的策略，并更新 SageMaker notebook 角色的信任关系。请完成以下步骤：

1. 请将ComprehendFullAccess策略附加到您的 Amazon SageMaker Notebook IAM 角色上。要执行此步骤，请参阅[设置您的 AWS 环境]章节中更改 IAM 权限和信任关系以执行 Amazon SageMaker notebook 角色小节，第二章**， 介绍 Amazon Textract。

2. 您的 SageMaker 执行角色应已具有访问 S3 的权限。如果没有，请将以下 JSON 语句作为内联策略添加。有关说明，请参阅[设置您的 AWS 环境]章节中更改 IAM 权限和信任关系以执行 Amazon SageMaker notebook 角色小节，第二章**， 介绍 Amazon Textract：

   { "Version": "2012-10-17", "Statement": [ {
     "Action": [
         "s3:GetObject",
         "s3:ListBucket",
         "s3:PutObject"
     ],
     "Resource": ["*"],
     "Effect": "Allow"
         }
     ]
   }
   

3. 最后，更新您的 SageMaker Notebook 执行角色的信任关系。有关说明，请参阅[设置您的 AWS 环境]章节中更改 IAM 权限和信任关系以执行 Amazon SageMaker notebook 角色小节，第二章**， 介绍 Amazon Textract*：

   { "Version": "2012-10-17", "Statement": [
     { "Effect": "Allow", 
       "Principal": 
         { "Service": 
             [ "sagemaker.amazonaws.com", 
               "s3.amazonaws.com", 
               "comprehend.amazonaws.com" ] 
             }, 
             "Action": "sts:AssumeRole" } 
         ] 
     }
   

现在我们已经设置了 Notebook 并创建了 IAM 角色来运行演示 Notebook，在下一节中，我们将开始处理主题建模的数据。

预处理客户服务历史数据

让我们开始下载并查看我们将用于本章的客户服务记录。我们将使用来自消费者金融保护局（Consumer Financial Protection Bureau）的俄亥俄州消费者投诉数据作为我们的解决方案：www.consumerfinance.gov/data-research/consumer-complaints/search/?dataNormalization=None&dateRange=1y&date_received_max=2021-05-17&date_received_min=2020-05-17&searchField=all&state=OH&tab=Map。你可以尝试该网站上的其他数据集，或者使用你自己的客户服务数据。为了方便起见，投诉数据已作为 CSV 文件包含在 GitHub 存储库中：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2006/topic-modeling/initial/complaints_data_initial.csv。当你克隆该存储库时，这些数据应该是可以使用的。你可以通过点击存储在笔记本中的 CSV 文件来查看其内容，或者使用chapter6-nlp-in-customer-service-github.ipynb笔记本中的代码来查看它。

打开笔记本并执行以下步骤：

1. 执行先决条件下的单元格，以确保我们有笔记本所需的库。请注意，在此单元格中，你将获取 Amazon SageMaker 执行角色。请确保你创建了一个 Amazon S3 桶（docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html），并在行中提供桶的名称。输入你选择的前缀，或者接受笔记本中已经提供的前缀：

   bucket = '<bucket-name>'
   prefix = 'chapter6'
   

2. 执行预处理文本数据下的单元格。

   首先，我们将加载包含消费者投诉数据的 CSV 文件（该文件已在本书的 GitHub 存储库中提供，链接为：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2006/topic-modeling/initial/complaints_data_initial.csv），并将其加载到 pandas DataFrame 对象中，便于操作：

   raw_df = pd.read_csv('topic-modeling/initial/complaints_data_initial.csv')
   raw_df.shape
   

   当我们执行前面的单元格时，我们将看到笔记本返回一个形状为(11485, 18)的数据，这意味着有 11,485 行和 18 列。我们只关心消费者投诉叙述字段，因此我们将从数据集中删除其余字段。执行此单元格后，形状应更改为(5152, 1)：

   raw_df = raw_df.dropna(subset=['Consumer complaint narrative'])
   raw_df = pd.DataFrame(raw_df['Consumer complaint narrative'].copy())
   raw_df.shape
   

   现在，让我们将其转换回更新后的 CSV 文件：

   raw_df.to_csv('topic-modeling/raw/complaints_data_subset.csv', header=False, index=False)
   

   执行笔记本中的单元格，以清理 CSV 文件中的文本内容，包括将文本重构为单独的句子，使得每个消费者投诉都成为单独的一行。有关此代码块的来源以及如何在句子中使用 Python 正则表达式函数的详细讨论，请参见stackoverflow.com/questions/4576077/how-can-i-split-a-text-into-sentences。继续执行单元格，以删除不必要的空格或标点符号，使用这些更改创建一个新的 CSV 文件，并将其上传到 S3 存储桶。我们还将创建一个新的 pandas DataFrame 对象，使用格式化后的内容，以便在后续步骤中使用。请执行笔记本中从预处理文本数据开始的所有剩余单元格：

   # Write the formatted sentences into a CSV file
   import csv
   fnfull = "topic-modeling/input/complaints_data_formatted.csv"
   with open(fnfull, "w", encoding='utf-8') as ff:
       csv_writer = csv.writer(ff, delimiter=',', quotechar = '"')
       for infile in all_files:
           for num, sentence in enumerate(infile):
               csv_writer.writerow([sentence])
   # Let's store the formatted CSV into a Pandas DataFrame 
   # as we will use this to create the training dataset for our custom classifier
   columns = ['Text']
   form_df = pd.read_csv('topic-modeling/input/complaints_data_formatted.csv', header=None, names = columns)
   form_df.shape
   # Upload the CSV file to the input prefix in S3 to be used in the topic modeling job
   s3 = boto3.client('s3')
   s3.upload_file('topic-modeling/input/complaints_data_formatted.csv', bucket, prefix+'/topic_modeling/input/topic_input.csv')
   

3. 接下来，我们将在格式化后的 CSV 文件上运行 Amazon Comprehend 主题建模任务，以提取一组可以应用于消费者投诉列表的主题。这些主题代表并帮助我们识别相关文本的主题领域或主题，并且表示文档中具有相同上下文参考的常用词汇集。有关更多详细信息，请参见 Amazon Comprehend 主题建模，docs.aws.amazon.com/comprehend/latest/dg/topic-modeling.html。

   要开始，请进入 AWS 控制台（如果您没有访问 AWS 控制台的权限，请参阅技术要求部分），并在控制台顶部的服务搜索窗口中输入 Amazon Comprehend。然后，导航到 Amazon Comprehend 控制台。

   点击8，如以下截图所示：

   

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_06_06.jpg)

   图 6.6 – 创建主题建模任务输入 – 第一部分

   提供其余字段的详细信息并点击创建任务，如以下截图所示：

   

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_06_07.jpg)

   图 6.7 – 创建主题建模任务输入 – 第二部分

   在 IAM 角色传播完成后，您应该看到任务提交状态，如以下截图所示。任务大约需要 30 分钟完成，这为您提供了快速吃点小吃或喝杯咖啡/茶的时间。现在，点击任务的名称，复制输出数据位置字段中提供的 S3 链接，然后返回到您的笔记本。我们将继续在笔记本中的步骤：

   

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_06_08.jpg)

   图 6.8 – 提交主题建模任务

4. 现在，我们将执行“处理主题建模结果”部分中的单元格。

   要下载主题建模任务的结果，我们需要tpprefix变量——特别是本地的output.tar.gz文件，并将其解压：

   # Let's first download the results of the topic modeling job. 
   # Please copy the output data location from your topic modeling job for this step and use it below
   directory = "results"
   parent_dir = os.getcwd()+'/topic-modeling'
   # Path
   path = os.path.join(parent_dir, directory)
   os.makedirs(path, exist_ok = True)
   print("Directory '%s' created successfully" %directory)
   tpprefix = prefix+'/topic_modeling/results/custom-classification and train folders, which we need in the notebook to execute the next step, as shown in the following code block:
   
   

   directory = "custom-classification"

   parent_dir = os.getcwd()

   path = os.path.join(parent_dir, directory)

   os.makedirs(path, exist_ok = True)

   print("目录 '%s' 创建成功" %directory)

   directory = "train"

   parent_dir = os.getcwd()+'/custom-classification'

   path = os.path.join(parent_dir, directory)

   os.makedirs(path, exist_ok = True)

   print("目录 '%s' 创建成功" %directory)

   
   Now, let's rearrange the columns so that we have the label as the first column. We will convert this into a CSV file and upload it into our S3 bucket. This CSV file will be the training dataset for our Amazon Comprehend Custom Classification model:
   
   

   form_df = form_df[['标签', '文本']]

   form_df.to_csv('custom-classification/train/train.csv', header=None, index=False)

   s3.upload_file('custom-classification/train/train.csv', bucket, prefix+'/custom_classification/train/train.csv')

5. 现在，我们将返回到 Amazon Comprehend AWS 控制台，训练我们的自定义分类模型，它可以为给定的文本预测标签。这些标签是我们在上一节中建模的主题。通过 Amazon Comprehend Custom，您可以在预训练的、功能强大的 Comprehend 模型基础上逐步训练出专属于您业务的模型。因此，这些自定义模型充分利用了默认 Comprehend 模型的知识，从而实现快速训练。与从头开始构建自定义分类模型相比，它们的准确性更高。您可以在 Amazon Comprehend 控制台中仅需几次点击即可运行此训练过程，而无需任何机器学习技能。更多详细信息，请参考docs.aws.amazon.com/comprehend/latest/dg/how-document-classification.html。

   要开始，请进入 AWS 控制台（如果您没有访问权限，请参考本章开头的技术要求部分），然后在控制台顶部的服务搜索窗口中输入 Amazon Comprehend。接着，导航到 Amazon Comprehend 控制台。

   点击启动 Amazon Comprehend按钮。

   点击左侧窗格中自定义分类下的自定义标题。

   点击训练分类器按钮，如下图所示：

   

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_06_09.jpg)

   图 6.9 – 训练分类器按钮

   输入分类器的名称，语言保持为英语，设置分类器模式为多类别。（对于我们的解决方案，我们为每个文档预测一个标签。如果您需要为每个文档预测多个标签，您可以使用多标签模式。）在训练数据格式下选择CSV 文件，如下图所示：

   

   图 6.10 – 自定义分类器输入 – 第一部分

   提供我们的训练数据集的S3 位置；即我们在前一节中创建的那个位置。对于IAM 角色，如果您在前几章中创建了AmazonComprehendServiceRole，请使用该角色，或者选择创建一个 IAM 角色并从列表中选择任何 S3 桶。点击训练分类器按钮，如下图所示：

   

   图 6.11 – 自定义分类器输入 – 第二部分

   训练作业将被提交。稍后，训练作业的状态将变为 Training，如下图所示：

   

   图 6.12 – 自定义分类器训练

   训练大约需要 1 小时才能完成。当作业完成时，状态将变为 Trained，如下图所示：

   

   图 6.13 – 自定义分类器训练完成

6. 现在我们已经完成了分类器的训练，我们将创建一个实时端点来部署模型。我们将在解决方案中使用此端点来执行请求路由预测。

   点击你在 Amazon Comprehend 控制台中的分类器名称。然后，向下滚动至 Endpoints 部分并点击 Create endpoint，如下图所示：

   

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_06_14.jpg)

   图 6.14 – 创建 Comprehend 端点

   输入端点名称，提供 1 的推理单元值，然后点击 Create endpoint，如下图所示。推理单元决定了端点的价格和容量。一个推理单元每秒提供 100 个字符的预测吞吐量。有关更多详情，请参阅 Amazon Comprehend 的定价指南：aws.amazon.com/comprehend/pricing/：

   

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_06_15.jpg)

   图 6.15 – 创建 Comprehend 端点输入

   创建完端点后，请通过点击端点名称记录端点的 ARN，如下图所示。这将在笔记本中进行推理时需要用到：

   

   图 6.16 – Comprehend 端点 ARN

7. 下一步，我们将返回到笔记本并执行 自动化请求路由 部分中的步骤。

   在笔记本单元格中提供你在前一步骤中记下的端点 ARN：

   endpoint_arn = '<comprehend-custom-classifier-endpoint-arn>'
   

   现在，让我们执行下一个单元，它展示了如何使用我们的端点进行实时分析。输入内容将使用一个已经分配给 test_text 变量的示例文本消息，如下方代码所示：

   test_text = 'because of your inability to accept my payments on time I now have a really bad credit score, you need to fix this now'
   comprehend = boto3.client('comprehend')
   response = comprehend.classify_document(Text=test_text, EndpointArn=endpoint_arn)
   print(response)
   

   我们的自定义分类器返回一个响应，如下方代码块所示：

   {'Classes': [{'Name': 'account', 'Score': 0.9856781363487244}, {'Name': 'credit', 'Score': 0.013113172724843025}, {'Name': 'debt', 'Score': 0.0005924980505369604}], 'ResponseMetadata': {'RequestId': 'c26c226c-3878-447e-95f5-60b4d91bb536', 'HTTPStatusCode': 200, 'HTTPHeaders': {'x-amzn-requestid': 'c26c226c-3878-447e-95f5-60b4d91bb536', 'content-type': 'application/x-amz-json-1.1', 'content-length': '151', 'date': 'Wed, 19 May 2021 17:35:38 GMT'}, 'RetryAttempts': 0}}
   

   运行以下代码块中的代码，从响应中选择具有最高置信度分数的 Name 属性。这将是客户请求在呼叫中心路由的部门或选项：

    cls_df = pd.DataFrame(response['Classes'])
   max_score = cls_df['Score'].max()
   routing_type = cls_df.query('Score == @max_score')['Name'].values[0]
   print("This request should be routed to: " + routing_type)
   

   这段代码将返回以下响应：

   This request should be routed to: account
   

8. 下一步，我们将执行 自动化反馈分析 部分中的步骤。

   为了分析客户对话的情感，我们将使用Amazon Comprehend Detect Sentiment API。这是 Amazon Comprehend 中的内置功能，不需要我们训练任何模型。我们可以直接调用该 API 并提供输入，它将返回文本的情感，如下所示：

   sent_response = comprehend.detect_sentiment(
       Text=test_text,
       LanguageCode='en'
   )
   print("The customer's feedback sentiment is: " + sent_response['Sentiment'])
   The customer's feedback sentiment is: NEGATIVE
   

这就是本章解决方案构建的总结。请参阅进一步阅读部分，了解与此用例类似的示例。在LiveRight的案例中，您可以将此构建集成到现有的联系中心工作流中，并使用Amazon Transcribe、AWS Step Functions和AWS Lambda扩展该解决方案。如何实现这一点的示例如下图所示：

图 6.17 – 客户服务中的 NLP 与实时转录

Amazon Transcribe 提供实时流式转录功能，将客户电话的语音转为文本。详情请参考aws.amazon.com/transcribe/。一个 AWS Step Functions(aws.amazon.com/step-functions/)工作流可以实现对完整过程流的编排，结合 AWS Lambda（一个完全托管的无服务器计算服务，可以在无需配置服务器的情况下运行代码，aws.amazon.com/lambda/）和多个 AWS 服务，设置为在接收到指定长度的转录时触发。Step Functions 工作流将调用 AWS Lambda 函数，检测客户请求的路由选项，且电话可以自动被路由到该选项，或/和通过调用 Detect Sentiment API 分析客户请求/反馈的情感，正如我们在自动化反馈分析部分看到的那样。结果是在通话进行时，联系中心代理将获得一个自动响应，包含预测的路由选项和情感，从而帮助快速且高效地解决客户的请求。

概述

在本章中，我们学习了如何构建一个 NLP 解决方案，通过使用 Amazon Comprehend 的主题建模功能、情感检测功能，并通过训练我们自己的自定义分类器来预测路由选项，使用 Comprehend 自定义分类后，通过 Comprehend 实时端点托管该解决方案。我们还看到如何在无需任何机器学习技能的情况下，利用强大且准确的 NLP 模型的灵活性。对于企业需求，Amazon Comprehend 能够无缝扩展以处理数百万份文档，提供基于使用量的定价，支持批量推断，并且通过实时端点的自动扩展支持，您可以有效地管理推断请求量并控制推断成本。

对于我们的解决方案，我们首先介绍了客户服务的使用案例、目前设置方式所固有的挑战，以及需要执行自动化路由和情感分析来控制由于当前低效流程导致的高客户流失率。随后，我们设计了一个架构，利用 Amazon Comprehend 来识别常见的主题或话题，创建训练数据集，训练一个自定义分类器来预测路由选项，并对客户请求进行情感分析。我们假设你是被分配到这个项目的解决方案架构师，并提供了解决方案组件的概述，以及架构图，在图 6.1中展示。

接着，我们介绍了解决方案构建的前提条件，设置了一个 Amazon SageMaker 笔记本实例，克隆了我们的 GitHub 仓库，并根据本章提供的说明开始在笔记本中执行代码。

在下一章中，我们将探讨一个稍微相关的使用案例，使用 NLP 来执行客户声音分析过程。我们将介绍该使用案例，讨论如何设计架构，建立前提条件，并详细讲解构建解决方案所需的各个步骤。

进一步阅读

• 宣布 Amazon Comprehend 自定义实体识别实时端点的发布，作者：Mona Mona 和 Prem Ranga（aws.amazon.com/blogs/machine-learning/announcing-the-launch-of-amazon-comprehend-custom-entity-recognition-real-time-endpoints/）。

• Amazon Comprehend 自定义分类模型的主动学习工作流 - 第二部分，作者：Shanthan Kesharaju, Joyson Neville Lewis 和 Mona Mona（aws.amazon.com/blogs/machine-learning/active-learning-workflow-for-amazon-comprehend-custom-classification-part-2/）。

第七章：第七章：理解客户声音分析

在前面的章节中，为了展示如何提升客户服务，我们构建了一个 AI 解决方案，利用AWS NLP服务Amazon Comprehend首先分析历史客户服务记录，使用 Amazon Comprehend 主题建模提取关键话题，并训练一个定制的分类模型，通过Amazon Comprehend Custom Classification预测呼叫路由的主题。最后，我们使用Amazon Comprehend detect sentiment来理解客户反馈的情感方面。

本章将重点讨论客户反馈的情感方面，客户可能是 Instagram 用户、Yelp 评论员，或者是你阿姨在 Facebook 上发表评论关于你生意的等等。

二十年前，想要尽快了解人们对你产品的感受并获取有意义的反馈以改进产品是非常困难的。随着全球化的进程和社交媒体的发明，今天，人人都有社交媒体应用程序，人们比以往任何时候都更自由地表达情感。我们都喜欢在 Twitter 上发表推文，表达我们的情感，无论是开心、悲伤、生气还是中立。如果你是一个非常受欢迎的人，比如电影明星，或者是一个有着成千上万评论的商业公司，那么挑战就变成了如何浏览粉丝发布的大量推文，并快速了解你的电影表现如何，是大获成功还是惨败。如果是公司、企业或初创公司，人们通过阅读评论迅速了解你的客户服务和产品支持是否好。

社交媒体分析是一个非常受欢迎且充满挑战的应用场景。本章我们将专注于文本分析的应用场景。我们将讨论一些非常常见的应用案例，其中 NLP 的强大功能将与分析技术相结合，分析来自聊天、社交媒体评论、电子邮件或 PDF 等非结构化数据。我们将展示如何快速为社交媒体评论设置强大的分析功能。

我们将通过以下几个部分进行讲解：

• 设置文本分析解决方案的挑战

• 设置 Yelp 评论文本分析工作流

技术要求

本章你需要有一个 AWS 账户。在开始之前，我们建议你创建一个 AWS 账户，如果你还没有账户，请参考前一章的注册细节。如果你已经有 AWS 账户并且按照前几章的说明进行操作，可以跳过注册步骤。Amazon Textract 示例的 Python 代码和示例数据集可以在此存储库链接中找到：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/tree/main/Chapter%2007。

我们将在 设置解决方案用例 部分，逐步带您完成如何在 Jupyter notebook 上设置上述代码库并配置正确的 IAM 权限的步骤。

查看以下视频，观看 bit.ly/3mfioWX 中的代码演示。

设置文本分析解决方案的挑战

大多数组织面临的挑战之一是从非结构化数据中获取业务洞察。

这些数据可以是各种格式，例如聊天记录、PDF 文档、电子邮件、推文等。由于这些数据没有结构，传统的数据分析工具很难对其进行分析。这正是 Amazon Textract 和 Amazon Comprehend 发挥作用的地方。

Amazon Textract 可以通过提取文本将这些非结构化数据转化为结构化数据，随后 Amazon Comprehend 可以提取洞察信息。一旦我们将数据转化为文本，就可以使用 Amazon Glue 执行无服务器的 提取、转换、加载（ETL），并将其转换为结构化格式。此外，您可以使用 Amazon Athena 对刚刚使用 Glue ETL 提取并转换的非结构化文本执行无服务器的临时 SQL 分析。Amazon Glue 还可以爬取您从 Amazon Textract 提取的非结构化数据或文本，并将其存储在 Hive 元数据存储中。

最后，您还可以使用 Amazon QuickSight 分析和可视化这些数据，以获得业务洞察。

Amazon QuickSight 帮助您创建快速的可视化图表和仪表板，供您与业务共享或集成到您的应用程序中，供最终用户使用。例如，您正在使用 Instagram 做生意，想要分析您产品图片下的评论，并创建一个实时仪表板来了解人们是发布了关于这些评论的积极还是消极意见。您可以使用上述组件创建一个实时社交媒体分析仪表板。

我们都喜欢在餐馆用餐。挑战是仅仅根据评论来挑选最佳餐馆。

我们将向您展示如何使用以下架构分析 Yelp 评论：

![图 7.1 – 社交媒体分析无服务器架构]

](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_07_01.jpg)

图 7.1 – 社交媒体分析无服务器架构

图 7.1 中的架构向您展示了如何将原始数据转化为新的洞察信息，优化数据湖中的数据集，并可视化无服务器结果。我们将通过以下步骤开始：

1. 获取 Yelp 评论数据集，并使用 Jupyter notebook 上传到 Amazon S3 存储桶中。

2. 通过爬取原始数据将其注册到 AWS Glue 数据目录中。

3. 在 AWS Glue 数据目录中执行此原始数据目录的 AWS Glue ETL。一旦在 AWS Glue 数据目录中注册，在爬取 AWS S3 中的 Yelp 评论数据后，ETL 将把原始数据转换为 Parquet 格式，并用 Amazon Comprehend 的洞察信息进行丰富。

4. 现在我们可以在 AWS Glue 数据目录中再次抓取并编目这些数据。编目操作会为 Amazon Athena 添加表格和元数据，以便进行临时的 SQL 分析。

5. 最后，您可以使用 Amazon QuickSight 快速创建在 Amazon Athena 中抓取的转换后的 Parquet 数据的可视化。Amazon QuickSight 可以直接与 Amazon Athena 和 Amazon S3 集成，作为可视化的数据源。

您还可以通过使用 Amazon Kinesis Data Firehose 将此解决方案转换为实时流式解决方案，调用这些 Yelp 评论和 Twitter API，并将近实时流数据直接存储在 Amazon S3 中，然后您可以使用 AWS Glue ETL 和编目功能与 Amazon Comprehend 结合进行转换和 NLP 丰富处理。之后，这些转换后的数据可以直接在 QuickSight 和 Athena 中进行可视化。此外，您还可以使用 AWS Lambda 函数和 Step Functions 来设置完全无服务器架构并自动化这些步骤。

在本节中，我们介绍了使用非结构化数据设置文本分析工作流的挑战，并提出了架构方案。在下一节中，我们将带您一步步构建 Yelp 评论数据集或任何社交媒体分析数据集的解决方案，只需通过 Jupyter 笔记本编写几行代码即可完成。

设置 Yelp 评论文本分析工作流

在本节中，我们将向您展示如何通过遵循使用 Jupyter 笔记本和 Python API 的步骤，为 Yelp 评论数据集或任何社交媒体分析数据集构建解决方案：

• 设置以解决用例

• 使用 Jupyter 笔记本走查解决方案

设置步骤将包括配置 身份与访问管理（IAM） 角色，且演示笔记本会引导您完成架构设置。那么，我们开始吧。

设置以解决用例

如果您在前面的章节中没有这样做，您将需要先创建一个 Amazon SageMaker Jupyter 笔记本并设置 Chapter 07 文件夹，然后打开 chapter07 social media text analytics.ipynb 笔记本：

1. 您可以参考 Amazon SageMaker 文档来创建笔记本实例：docs.aws.amazon.com/sagemaker/latest/dg/gs-setup-working-env.html。为了按照这些步骤进行，请在搜索窗口中登录 Amazon SageMaker，选择它，然后导航到 Amazon SageMaker 控制台。

2. 选择 Notebook 实例 并通过指定实例类型、存储和 IAM 角色创建笔记本实例。

3. 在为此设置创建 SageMaker 笔记本时，您需要对以下服务具有 IAM 访问权限：

   1. 使用 AWS Glue 运行 ETL 任务并抓取数据

   2. 使用 AWS Athena 通过笔记本调用 Athena API

   3. 使用 AWS Comprehend 执行情感分析

   4. AWS QuickSight 用于可视化

   5. AWS S3 访问

   确保您的笔记本 IAM 具有以下角色：

图 7.2 – 运行笔记本的重要 IAM 角色

你可以修改正在使用的现有笔记本角色，添加这些权限。在图 7.2中是你用于创建笔记本实例的 SageMaker IAM 角色。你可以导航到该角色并点击附加策略，确保你拥有执行笔记本所需的权限，以调用我们将使用的服务 API。

按照本笔记本中的步骤执行，逐个单元格地完成，每次执行时请阅读每个单元格中提供的描述。

从本笔记本调用 AWS Glue 的附加 IAM 先决条件

在上一部分中，我们引导你如何设置笔记本和重要的 IAM 角色以运行此笔记本。在本部分中，我们假设你已经进入笔记本，并且我们在笔记本中提供了有关如何获取笔记本执行角色并启用其从此笔记本调用 AWS Glue 作业的说明。

转到笔记本并按照查找当前执行角色的笔记本部分运行以下代码：

import sagemaker
from sagemaker import get_execution_role
sess = sagemaker.Session()
role = get_execution_role()
role_name = role[role.rfind('/') + 1:]
print(role_name)

你将获取与此笔记本关联的角色。接下来，在下一部分中，我们将引导你如何将 AWS Glue 添加为此角色的附加受信实体。

将 AWS Glue 和 Amazon Comprehend 作为附加受信实体添加到该角色中

如果你希望在调用 Glue API 时传递此笔记本的执行角色，而无需创建额外的角色，则需要执行此步骤。如果你之前没有使用过 AWS Glue，则此步骤是必须的。如果你之前使用过 AWS Glue，则应该已经有一个可以用来调用 Glue API 的现有角色。在这种情况下，你可以在调用 Glue 时传递该角色（稍后在本笔记本中），并跳过下一步：

1. 在 IAM 仪表板中，点击左侧导航栏中的角色，搜索角色。角色出现后，点击角色以进入其概述页面。

2. 点击概述页面中的信任关系选项卡，以将 AWS Glue 添加为附加受信实体。

3. 点击编辑信任关系，并将 JSON 替换为以下 JSON：

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Service": [
             "sagemaker.amazonaws.com",
             "glue.amazonaws.com"
           ]
         },
         "Action": "sts:AssumeRole"
       }
     ]
   }
   

4. 完成后，点击更新信任策略，即可完成设置。

图 7.3 – 在 IAM 角色中设置与 Glue 的信任

在本部分中，我们介绍了如何设置 Jupyter 笔记本和运行 Jupyter 笔记本所需的 IAM 权限。在下一部分中，我们将通过你所做的笔记本设置来演练解决方案。

使用 Jupyter Notebook 演练解决方案

在本部分中，我们将引导你如何通过遵循给定的步骤，使用 Jupyter 笔记本和 Python API 来构建 Yelp 评论数据集或任何社交媒体分析数据集：

1. 从 Yelp Reviews NLP Fast.ai 下载评论数据集，我们已经在笔记本中为你完成了这一步。

2. 将原始数据集注册为 AWS Glue 数据目录中的一个表。

3. 运行 PySpark（AWS Glue 作业）将数据集转换为 Parquet 格式，并使用 Amazon Comprehend 获取评论情感。

4. 将转换后的结果存储在一个新创建的数据集中。

5. 使用 Amazon Athena 对优化后的数据集执行无服务器查询。

6. 使用 Amazon QuickSight 或 Bokeh AWS Glue 数据目录提供结果的可视化洞察。

7. 转到这个笔记本并运行代码块中的以下步骤来设置库：

   import boto3
   import botocore
   import json
   import time
   import os
                 import project_path
   from lib import workshop
   glue = boto3.client('glue')
   s3 = boto3.resource('s3')
   s3_client = boto3.client('s3')
   session = boto3.session.Session()
   region = session.region_name
   account_id = boto3.client('sts').get_caller_identity().get('Account')
   database_name = 'yelp' # AWS Glue Data Catalog Database Name
   raw_table_name = 'raw_reviews' # AWS Glue Data Catalog raw table name
   parquet_table_name = 'parq_reviews' # AWS Glue Data Catalog parquet table name
   open_data_bucket = 'fast-ai-nlp'
   

8. 我们已经导入了笔记本设置所需的库，并定义了 AWS Glue 数据目录的数据库名和表名。在下一步中，我们将通过运行以下代码下载 Yelp 评论数据集：

   try:
       s3.Bucket(open_data_bucket).download_file('yelp_review_full_csv.tgz', 'yelp_review_full_csv.tgz')
   except botocore.exceptions.ClientError as e:
       if e.response['Error']['Code'] == "404":
           print("The object does not exist.")
       else:
           raise
   

9. 现在，我们将运行以下代码来解压或解压这个评论数据集：

   !tar -xvzf yelp_review_full_csv.tgz
   

10. 在 tar 包中有两个 CSV 文件，一个叫做train.csv，另一个是test.csv。有兴趣的人可以查看readme.txt文件，文件中对数据集有更详细的描述。

11. 我们将使用 Python 的 pandas 来读取 CSV 文件并查看数据集。你会注意到数据中包含两列未命名的列，分别是评分和评论。评分介于 1 到 5 之间，评论则是自由格式的文本字段：

    import pandas as pd
    pd.set_option('display.max_colwidth', -1)
    df = pd.read_csv('yelp_review_full_csv/train.csv', header=None)
    df.head(5)
    

12. 你将得到如下输出：

    图 7.4 – 原始 Yelp 评论数据

13. 现在，我们将上传之前创建的文件到 S3，以便稍后使用，通过执行以下笔记本代码：

    file_name = 'train.csv'
    session.resource('s3').Bucket(bucket).Object(os.path.join('yelp', 'raw', file_name)).upload_file('yelp_review_full_csv/'+file_name)
    

我们已经下载了 Yelp 数据集并将其存储在一个原始 S3 存储桶中。在下一部分中，我们将创建 AWS Glue 数据目录数据库。

创建 AWS Glue 数据目录数据库

在本部分中，我们将向你展示如何定义表并将其添加到 Glue 数据目录数据库中。Glue 爬虫会自动从 Amazon S3 或任何本地数据库中爬取数据，因为它支持多种数据存储。你也可以使用自己的 Hive 元数据存储并开始使用爬虫。一旦创建了爬虫，你可以执行 Glue ETL 作业，因为这些作业会使用这些数据目录表作为源数据和目标数据。此外，Glue ETL 作业将读取和写入 Glue 爬虫中指定的源数据和目标数据存储。每个 AWS 账户都有一个中央 Glue 数据目录：

1. 我们将使用glue.create_database API（boto3.amazonaws.com/v1/documentation/api/latest/reference/services/glue.html#Glue.Client.create_database）来创建一个 Glue 数据库：

   workshop.create_db(glue, account_id, database_name, 'Database for Yelp Reviews')
   

2. 现在我们将在 Glue 中创建原始表（docs.aws.amazon.com/glue/latest/dg/tables-described.html）。在 Glue 中创建表有不止一种方式：

   1. 使用 AWS Glue 爬虫：我们有分类器可以在爬取时自动确定数据集的架构，使用内置分类器。如果您的数据架构具有复杂的嵌套 JSON 结构，您还可以使用自定义分类器。

   2. 手动创建表或使用 API：您可以在控制台中手动创建表，也可以通过 API 创建表。在定义表时，您需要指定要分类的架构。

      注意：

      欲了解有关使用 AWS Glue 控制台创建表的更多信息，请参阅在 AWS Glue 控制台上处理表：docs.aws.amazon.com/glue/latest/dg/console-tables.html。

3. 我们使用glue.create_table API 来创建表：

   location = 's3://{0}/yelp/raw'.format(bucket)
   response = glue.create_table(
       CatalogId=account_id,
       DatabaseName=database_name,
       TableInput={
           'Name': raw_table_name,
           'Description': 'Raw Yelp reviews dataset',
           'StorageDescriptor': {
               'Columns': [
                   {
                       'Name': 'rating',
                       'Type': 'tinyint',
                       'Comment': 'Rating of from the Yelp review'
                   },
                   {
                       'Name': 'review',
                       'Type': 'string',
                       'Comment': 'Review text of from the Yelp review'
                   }
               ],
               'Location': location,
               'InputFormat': 'org.apache.hadoop.mapred.TextInputFormat',
               'OutputFormat': 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat',
               'SerdeInfo': {
                   'SerializationLibrary': 'org.apache.hadoop.hive.serde2.OpenCSVSerde',
                   'Parameters': {
                       'escapeChar': '\\',
                       'separatorChar': ',',
                       'serialization.format': '1'
                   }
               },
           },
           'TableType': 'EXTERNAL_TABLE',
           'Parameters': {
               'classification': 'csv'
           }
       }
   )
   

   上述代码将创建 AWS Glue 数据目录中的表。

4. 现在，我们将使用 Amazon Athena 的pyAthena API 可视化这些数据。为了查看原始 Yelp 评论，我们将安装此 Python 库，以便使用 Athena 查询 Glue 数据目录中的数据：

   !pip install PyAthena
   

5. 以下代码将帮助我们在 Glue 中可视化原始数据集的数据库和表：

   from pyathena import connect
   from pyathena.pandas.util import as_pandas
   cursor = connect(region_name=region, s3_staging_dir='s3://'+bucket+'/yelp/temp').cursor()
   cursor.execute('select * from ' + database_name + '.' + raw_table_name + ' limit 10')
   df = as_pandas(cursor)
   df.head(5)
   

6. 您将在输出中看到以下表格：

图 7.5 – Glue 数据目录中原始数据集的 Athena 输出

所以，我们介绍了如何创建 Glue 数据目录，并抓取我们在 Amazon S3 下载的原始 Yelp 数据。然后，我们展示了如何使用pyAthena库在 Amazon Athena 中可视化这些数据。在下一节中，我们将向您展示如何转换这些数据。

转换原始数据以提供见解和可视化

现在，我们将向您展示如何使用 PySpark 在 AWS Glue 作业中转换原始数据，调用 Amazon Comprehend API 对评论进行情感分析，将数据转换为 Parquet 格式，并按情感进行分区。这将使我们在按情感查看数据时优化分析查询，并仅返回我们需要的值，利用 Parquet 的列式格式。

我们在第三章中介绍了 Comprehend 的实时情感检测 API，《介绍 Amazon Comprehend》。在这个作业中，我们将使用实时批处理情感检测 API。

我们将创建一个 PySpark 作业来添加主键，并通过 Amazon Comprehend 批量处理评论，以获取评论的情感分析。该作业将限制转换的行数，但这段代码可以修改为处理整个数据集：

1. 为了在 AWS Glue 中运行代码，我们将直接将代码和依赖项上传到 S3，并在调用 Glue 作业时传递这些位置。我们将使用 Jupyter Notebook 的单元魔法%%writefile来编写 ETL 作业。接下来，我们使用 AWS Glue 脚本，通过 Glue 转换处理 Yelp 评论数据集，并通过使用 Amazon Comprehend 进行情感分析，将情感列添加到 DataFrame 中：

   %%writefile yelp_etl.py
   import os
   import sys
   import boto3
   from awsglue.transforms import *
   from awsglue.utils import getResolvedOptions
   from pyspark.context import SparkContext
   from awsglue.context import GlueContext
   from awsglue.job import Job
   from awsglue.dynamicframe import DynamicFrame
   import pyspark.sql.functions as F
   from pyspark.sql import Row, Window, SparkSession
   from pyspark.sql.types import *
   from pyspark.conf import SparkConf
   from pyspark.context import SparkContext
   from pyspark.sql.functions import *
   args = getResolvedOptions(sys.argv, ['JOB_NAME', 'S3_OUTPUT_BUCKET', 'S3_OUTPUT_KEY_PREFIX', 'DATABASE_NAME', 'TABLE_NAME', 'REGION'])
   sc = SparkContext()
   glueContext = GlueContext(sc)
   spark = glueContext.spark_session
   job = Job(glueContext)
   job.init(args['JOB_NAME'], args)
   

2. 我们已经导入了必要的 API，现在我们将把 Glue DynamicFrame 转换为 Spark DataFrame，以便从 Glue 数据目录中读取数据。我们将从数据库和我们在 Glue 数据目录中创建的表中选择评论和评分列：

   yelp = glueContext.create_dynamic_frame.from_catalog(database=args['DATABASE_NAME'], table_name=args['TABLE_NAME'], transformation_ctx = "datasource0")
   yelpDF = yelp.toDF().select('rating', 'review')
   

   我们正在定义一些限制，例如要发送多少个字符进行批量情感分析——MAX_SENTENCE_LENGTH_IN_CHARS——批量情感分析中每批评论的大小——COMPREHEND_BATCH_SIZE——以及要发送多少批次：

   MIN_SENTENCE_LENGTH_IN_CHARS = 10 
   MAX_SENTENCE_LENGTH_IN_CHARS = 4500
   COMPREHEND_BATCH_SIZE = 5  
   NUMBER_OF_BATCHES = 10
   ROW_LIMIT = 1000 #Number of reviews we will process for this workshop
   

3. 每个任务处理 510 条记录，我们正在调用 Comprehend 批量情感分析 API 来获取情感，并在经过 AWS Glue 转换后添加该情感。创建一个函数，传递文本列表并调用批量情感分析 API，已在 第三章 中介绍，介绍 Amazon Comprehend*：

   ComprehendRow = Row("review", "rating", "sentiment")
   def getBatchComprehend(input_list):
       arr = []
       bodies = [i[0] for i in input_list]
       client = boto3.client('comprehend',region_name=args['REGION'])
       def callApi(text_list):
           response = client.batch_detect_sentiment(TextList = text_list, LanguageCode = 'en')
           return response
   
       for i in range(NUMBER_OF_BATCHES):
           text_list = bodies[COMPREHEND_BATCH_SIZE * i : COMPREHEND_BATCH_SIZE * (i+1)]
           #response = client.batch_detect_sentiment(TextList = text_list, LanguageCode = 'en')
           response = callApi(text_list)
           for r in response['ResultList']:
               idx = COMPREHEND_BATCH_SIZE * i + r['Index']
               arr.append(ComprehendRow(input_list[idx][0], input_list[idx][1], r['Sentiment']))
   
       return arr
   

4. 以下代码将获取一组评论大小小于 Comprehend 限制的记录样本：

   yelpDF = yelpDF \
     .withColumn('review_len', F.length('review')) \
     .filter(F.col('review_len') > MIN_SENTENCE_LENGTH_IN_CHARS) \
     .filter(F.col('review_len') < MAX_SENTENCE_LENGTH_IN_CHARS) \
     .limit(ROW_LIMIT)
   record_count = yelpDF.count()
   print('record count=' + str(record_count))
   yelpDF = yelpDF.repartition(record_count/(NUMBER_OF_BATCHES*COMPREHEND_BATCH_SIZE))
   

5. 我们正在使用 Glue DataFrame 将提交 ID 和正文元组连接成大小相似的数组，并转换结果：

   group_rdd = yelpDF.rdd.map(lambda l: (l.review.encode("utf-8"), l.rating)).glom()
   
   transformed = group_rdd \
     .map(lambda l: getBatchComprehend(l)) \
     .flatMap(lambda x: x) \
     .toDF()
   print("transformed count=" + str(transformed.count()))
   

   我们正在将转换后的带有情感的 DataFrame 转换为 Parquet 格式，并将其保存到我们转换后的 Amazon S3 存储桶中：

   transformedsink = DynamicFrame.fromDF(transformed, glueContext, "joined")
   parquet_output_path = 's3://' + os.path.join(args['S3_OUTPUT_BUCKET'], args['S3_OUTPUT_KEY_PREFIX'])
   print(parquet_output_path)
   datasink5 = glueContext.write_dynamic_frame.from_options(frame = transformedsink, connection_type = "s3", connection_options = {"path": parquet_output_path, "partitionKeys": ["sentiment"]}, format="parquet", transformation_ctx="datasink5")
   
   job.commit()
   

6. 这段代码的关键点是利用 Glue 库，轻松访问 AWS Glue 数据目录：

   glueContext.create_dynamic_frame.from_catalog- Read table metadata from the Glue Data Catalog using Glue libs to load tables into the job.
   yelpDF = yelp.toDF() - Easy conversion from Glue DynamicFrame to Spark DataFrame and vice-versa joinedsink= DynamicFrame.fromDF(joinedDF, glueContext, "joined").
   

7. 使用 glueContext.write_dynamic_frame.from_options 写入 S3，并指定以下选项：

   • 基于列对数据进行分区——connection_options = {"path": parquet_output_path, "partitionKeys": ["sentiment"]}。

     将数据转换为列式格式——format="parquet"。

8. 我们现在将把 github_etl.py 脚本上传到 S3，以便 Glue 可以使用它来运行 PySpark 作业。如果需要，您可以将其替换为您自己的脚本。如果您的代码有多个文件，您需要将这些文件压缩成一个 ZIP 文件并上传到 S3，而不是像这里所做的那样上传单个文件：

   script_location = sess.upload_data(path='yelp_etl.py', bucket=bucket, key_prefix='yelp/codes')
   s3_output_key_prefix = 'yelp/parquet/'
   

9. 接下来，我们将通过 Boto3 创建一个 Glue 客户端，以便调用 create_job API。create_job API 将创建一个作业定义，该定义可用于在 Glue 中执行您的作业。这里创建的作业定义是可变的。在创建作业时，我们还将代码位置以及依赖项的位置传递给 Glue。AllocatedCapacity 参数控制 Glue 用于执行此作业的硬件资源。该参数以 DPU 单位进行度量。有关 DPU 的更多信息，请参见 docs.aws.amazon.com/glue/latest/dg/add-job.html：

   from time import gmtime, strftime
   import time
   timestamp_prefix = strftime("%Y-%m-%d-%H-%M-%S", gmtime())
   job_name = 'yelp-etl-' + timestamp_prefix
   response = glue.create_job(
       Name=job_name,
       Description='PySpark job to extract Yelp review sentiment analysis',
       Role=role, # you can pass your existing AWS Glue role here if you have used Glue before
       ExecutionProperty={
           'MaxConcurrentRuns': 1
       },
       Command={
           'Name': 'glueetl',
           'ScriptLocation': script_location
       },
       DefaultArguments={
           '--job-language': 'python',
           '--job-bookmark-option': 'job-bookmark-disable'
       },
       AllocatedCapacity=5,
       Timeout=60,
   )
   glue_job_name = response['Name']
   print(glue_job_name)
   

10. 上述作业现在将通过调用 start_job_run API 来执行。此 API 会创建一个不可变的运行/执行，对应于之前创建的作业定义。我们将需要该特定作业执行的 job_run_id 值来检查其状态。我们将把数据和模型的位置作为作业执行参数传递：

    job_run_id = glue.start_job_run(JobName=job_name,
                                           Arguments = {
                                            '--S3_OUTPUT_BUCKET': bucket,
                                            '--S3_OUTPUT_KEY_PREFIX': s3_output_key_prefix,
                                            '--DATABASE_NAME': database_name,
                                            '--TABLE_NAME': raw_table_name,
                                            '--REGION': region
                                           })['JobRunId']
    print(job_run_id)
    

    注意：

    该作业大约需要 2 分钟才能完成。

11. 现在我们将检查作业状态，以查看其是否为SUCCEEDED、FAILED或STOPPED。一旦作业成功，我们将在 S3 中以 Parquet 格式获得转换后的数据，我们将使用 Athena 查询并通过 QuickSight 可视化。如果作业失败，您可以进入 AWS Glue 控制台，点击左侧的Jobs选项卡，并从页面中点击该特定作业，您将能够找到这些作业的 CloudWatch Logs 链接（Logs下的链接），这可以帮助您查看作业执行中究竟发生了什么错误：

    job_run_status = glue.get_job_run(JobName=job_name,RunId=job_run_id)['JobRun']['JobRunState']
    while job_run_status not in ('FAILED', 'SUCCEEDED', 'STOPPED'):
        job_run_status = glue.get_job_run(JobName=job_name,RunId=job_run_id)['JobRun']['JobRunState']
        print (job_run_status)
        time.sleep(60)
    print(job_run_status)
    

在接下来的部分中，我们将演示如何使用 Glue 爬虫发现已转换的数据。

使用 Glue 爬虫发现已转换的数据

大多数 AWS Glue 用户使用爬虫将 AWS Glue 数据目录中的表填充为主要方法。为此，您需要在数据目录中添加一个爬虫来遍历您的数据存储。爬虫的输出由一个或多个在数据目录中定义的元数据表组成。您在 AWS Glue 中定义的ETL 作业使用这些元数据表作为数据源和目标：

• 爬虫可以抓取基于文件和基于表的数据存储。爬虫可以从各种类型的数据存储中抓取数据，例如 Amazon S3、RDS、Redshift、DynamoDB 或本地数据库：

  parq_crawler_name = 'YelpCuratedCrawler'
  parq_crawler_path = 's3://{0}/yelp/parquet/'.format(bucket)
                   response = glue.create_crawler(
      Name=parq_crawler_name,
      Role=role,
      DatabaseName=database_name,
      Description='Crawler for the Parquet Yelp Reviews with Sentiment',
      Targets={
          'S3Targets': [
              {
                  'Path': parq_crawler_path
              }
          ]
      },
      SchemaChangePolicy={
          'UpdateBehavior': 'UPDATE_IN_DATABASE',
          'DeleteBehavior': 'DEPRECATE_IN_DATABASE'
      },
      TablePrefix='reviews_'
  )
  

• 启动 Glue 爬虫：您可以使用 Glue 爬虫将表格填充到 AWS Glue 数据目录中。爬虫将自动抓取您的数据源，这可以是本地数据库或 Amazon S3 中的原始 CSV 文件，并在 Glue 数据目录中创建元数据表，同时推断模式。Glue ETL 作业使用 Glue 数据目录中的这些元数据表作为源和目标。您还可以将现有的 Hive 数据目录引入并运行 Glue ETL：

  response = glue.start_crawler(
      Name=parq_crawler_name
  )
  print ("Parquet Crawler: https://{0}.console.aws.amazon.com/glue/home?region={0}#crawler:name={1}".format(region, parq_crawler_name))
  

• 访问输出中的链接以在 Amazon Athena 中可视化您的爬虫：

![图 7.6 – Yelp 策划的爬虫]

](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_07_06.jpg)

图 7.6 – Yelp 策划的爬虫

• READY 状态，意味着爬虫完成了抓取。您还可以查看爬虫的 CloudWatch 日志以获取更多详情：

  crawler_status = glue.get_crawler(Name=parq_crawler_name)['Crawler']['State']
  while crawler_status not in ('READY'):
      crawler_status = glue.get_crawler(Name=parq_crawler_name)['Crawler']['State']
      print(crawler_status)
      time.sleep(30)
  

一旦您获得 READY 输出，继续下一步。在本节中，我们展示了如何爬取 Yelp 评论的转换后的 Parquet 数据，这些评论包含来自 Amazon Comprehend 的情感分数，并存储在 AWS Glue 数据目录中。在下一节中，我们将介绍如何可视化这些数据，以深入分析客户声音的见解。

查看转换后的结果

我们将再次使用 PyAthena 库，针对新创建的数据集运行查询，该数据集包含情感分析结果并以 Parquet 格式存储。为了节省时间，我们将使用笔记本中的 Bokeh AWS Glue 数据目录来可视化结果，而不是使用 Amazon QuickSight：

• QuickSight 也能够使用相同的 Athena 查询来可视化结果，并且具有多个内置连接器，可以连接到许多数据源：

  cursor.execute('select rating, review, sentiment from yelp.reviews_parquet')
                df = as_pandas(cursor)
  df.head(10)
  

• 以下是通过 Amazon Athena 查询 Glue 数据目录，以获取 Yelp 评论表中的评分、评论和情感的输出：

图 7.7 – 从 Glue 数据目录中的 Yelp 转换表中选择评分和情感的 Athena 查询

• groupby 本地使用。或者，我们也可以使用 Athena 中的内置 SQL 和聚合函数来实现相同的结果：

  group = df.groupby(('sentiment'))
  group.describe()
  

  接下来，你将看到按情感分组的 groupby 查询输出：

图 7.8 – 按情感分组查询的输出

从前面的输出中我们可以看到，Yelp 评论数据集中正面评论的数量多于负面评论。

• Bokeh 框架有许多内置的可视化工具。我们将在随后的代码中使用 Bokeh 来可视化按情感和评分分组的评论。

• 按评分可视化：我们现在将比较 Comprehend API 与数据集中的用户评分之间的差异。我们正在更改 DataFrame 中的 groupby 来更改数据集：

  group = df.groupby(('rating'))
  group.describe()
  

  你将在下一个屏幕截图中看到按评分分组的查询结果输出：

图 7.9 – 按评分分组的查询结果输出

• 现在，我们将向你展示如何在 Bokeh 中绘制这些数据：

  source = ColumnDataSource(group)
  ",".join(source.column_names)
  rating_cmap = factor_cmap('rating', palette=Spectral5, factors=sorted(df.rating.unique()))
  p = figure(plot_height=350, x_range=group)
  p.vbar(x='rating', top='review_count', width=1, line_color="white", 
         fill_color=rating_cmap, source=source)
  p.xgrid.grid_line_color = None
  p.xaxis.axis_label = "Rating"
  p.yaxis.axis_label = "Count"
  p.y_range.start = 0
  

  你将看到显示用户评分计数的条形图。

图 7.10 – 按用户评分的计数

我们可以看到，给出的最常见评分是 1，最不常见的是 2。本节中我们介绍了如何使用 Amazon Athena 中的简单查询和像 Bokeh 这样的可视化工具，对增强了 Amazon Comprehend 情感分析的 Yelp 评论数据集进行快速可视化和 SQL 分析。我们得到了很酷的洞察，例如大多数评论都是正面的，用户给出的最常见评分是 1。你可以通过使用简单的 SQL 进一步深入分析，获得特定评论的具体见解。这有助于迅速推动业务成果。在下一节中，我们将向你展示如何轻松创建一个 QuickSight 仪表板，为你的业务用户提供一些酷的见解。

Amazon QuickSight 可视化

在本节中，我们将向你展示如何设置或开始使用 Amazon QuickSight，并可视化 Athena 中的表格，这些表格通过 AWS Glue 和 Comprehend 进行了情感分析转换：

1. 你可以按照 docs.aws.amazon.com/quicksight/latest/user/getting-started.html 上的 入门指南 设置你的账户，然后按照代码块导航到 QuickSight 控制台：

   print('https://{0}.quicksight.aws.amazon.com/sn/start?#'.format(region))
   

2. 管理 QuickSight 中的 S3 访问：我们需要完成这个必需的步骤，以确保在使用 Amazon QuickSight 访问 Amazon Athena 时不会遇到访问拒绝的异常。

3. 进入管理 QuickSight | 安全和权限 | 添加或移除 | 在 S3 中。点击详细信息 | 选择您要查询的存储桶 | 更新。

   图 7.11 – 管理 QuickSight 对 S3 数据湖的访问

4. 点击创建数据集选项，您将看到以下选项：

   图 7.12 – Amazon QuickSight 设置及创建数据集选项

5. 选择前面选项中的Athena。点击新建数据集按钮，并选择Athena 数据源。命名数据源并选择 Yelp 的Glue 数据库和reviews_parquet表。点击创建数据源按钮完成创建。QuickSight 支持多种数据连接器。

6. 在yelp_reviews中点击创建数据源。同时，点击已验证。

   图 7.13 – 在 QuickSight 中创建 Athena 数据源

7. 接下来，您将选择我们在 Glue 数据目录中创建的Yelp数据库和reviews_parquet表。

   图 7.14 – 在 QuickSight 中选择要可视化的表

8. 点击保存并可视化。

在本节中，我们介绍了如何创建 QuickSight 仪表板以分析 Yelp 评论。在下一节中，我们将讨论如何删除您在此过程中创建的资源，以避免产生费用。

清理工作

在本节中，我们将带您逐步了解如何在笔记本中通过代码示例清理 AWS 资源，避免在进行 Yelp 情感分析解决方案时产生费用。

运行清理步骤，通过执行以下代码删除您为本笔记本创建的资源：

response = glue.delete_crawler(Name=parq_crawler_name)
response = glue.delete_job(JobName=glue_job_name)
response = glue.delete_database(
    CatalogId = account_id,
    Name = database_name
)
workshop.delete_bucket_completely(bucket)

我们删除了 Glue 爬虫、Glue ETL 作业以及使用笔记本创建的数据库。让我们继续下一部分，做个总结。

总结

在本章中，我们介绍了如何将文本分析解决方案与现有的社交媒体分析工作流相结合。我们给出了一个具体的例子，使用 Yelp 评论数据集并通过无服务器 ETL 结合 NLP，使用 Amazon Comprehend 快速创建一个可视化仪表板，并使用 Amazon QuickSight 进行展示。我们还介绍了通过 Amazon Athena 进行临时 SQL 分析，利用一些简单的 SQL 查询来了解大多数用户的声音或情感。这个解决方案可以与任何社交媒体平台集成，如 Twitter、Reddit 和 Facebook，支持批处理或实时模式。

在实时设置的情况下，你可以集成 Kinesis Data Firehose，在这个提议的工作流或架构中实现接近实时的流式推文或社交媒体信息流。查看进一步阅读部分，了解一个非常酷的AI 驱动的社交媒体仪表盘，可以在大规模实施该架构时使用。

你在文档自动化方面可以采取的另一种方法是使用 Amazon Textract 从你的 PDF 文件中提取数据，特别是在处理 RFP（请求建议书）或协议时，之后在提取的文本上执行 Glue ETL 操作后，可以按段落快速收集情感分析。

在下一章中，我们将讨论如何使用 AI 自动化媒体工作流，以降低成本并实现内容变现。

进一步阅读

• 如何使用 Amazon Comprehend、AWS Glue 和 Amazon Athena 扩展情感分析 作者：Roy Hasson (aws.amazon.com/blogs/machine-learning/how-to-scale-sentiment-analysis-using-amazon-comprehend-aws-glue-and-amazon-athena/)

• AI 驱动的社交媒体仪表盘 (aws.amazon.com/solutions/implementations/ai-driven-social-media-dashboard/)

• 使用 AWS Glue、Amazon Athena 和 Amazon QuickSight 协调、查询和可视化来自不同供应商的数据 作者：Ben Snively (aws.amazon.com/blogs/big-data/harmonize-query-and-visualize-data-from-various-providers-using-aws-glue-amazon-athena-and-amazon-quicksight/)

第八章：第八章：利用自然语言处理（NLP）赚取您的媒体内容

正如我们在本书中所见，人工智能（AI），特别是 NLP，由于数据的快速增长和云计算下机器学习（ML）的民主化，已经在传统 IT 领域有了广泛的应用。在上一章中，我们看到了一个很酷的例子，通过运行客户语音分析和情感检测，可以为社交媒体评论和其他形式的文本数据增添色彩。我们看到如何使用 AWS Glue 从 Amazon S3 中抓取原始数据，使用 Amazon Athena 交互式查询这些数据，使用 PySpark（spark.apache.org/docs/latest/api/python/index.html）在 AWS Glue 作业中转换原始数据，调用 Amazon Comprehend API（提供预训练的 NLP 模型）对评论进行情感分析，将数据转换为 Parquet 格式，并按情感分区（docs.aws.amazon.com/athena/latest/ug/partitions.html）以优化分析查询。在本章中，我们将转向关注一个因流媒体内容的广泛采用而在近年来广受欢迎的用例，具体来说是如何赚取内容。

线上广告和平面媒体广告之间的差距越来越大。根据这篇文章，引用了 PwC 关于全球娱乐和媒体的展望报告（www.pwc.com/outlook），即使考虑到 COVID-19 大流行，线上广告支出在 2020 年估计比电视广告高出约 580 亿美元，比杂志和报纸广告高出 1000 亿美元。

当然，这也受智能消费设备的增加和互联网时代消费趋势爆炸性增长的推动。谷歌广告是今天最流行的广告发布平台之一，占据了 Alphabet（拥有谷歌的上市控股公司）80%的收入，根据这篇文章在 2020 年赚取了 1470 亿美元：www.cnbc.com/2021/05/18/how-does-google-make-money-advertising-business-breakdown-.html。没错，你没看错：在线广告确实是一件大事。因此，当您考虑下一次发布那个很酷的旅行视频或您制作绝佳辣椒肉酱的食谱时，实际上您可能会从您的内容中赚钱。你可能会问，这一切很棒，但 NLP 在这种情况下如何帮助？继续阅读了解更多！

答案，正如你可能已经猜到的，是基于上下文的广告投放。假设你有一个智能解决方案，可以监听内容中的音频/文本，理解讨论的内容，识别代表内容上下文的主题，查找与这些主题相关的广告，并将这些广告无缝地插入到你的内容中，而无需训练任何机器学习模型：那岂不是太棒了吗？是的，这正是我们现在要构建的内容。

我们将浏览以下几个部分：

• 介绍内容变现用例

• 构建内容变现的 NLP 解决方案

技术要求

对于本章内容，您需要拥有一个 AWS 账户。请确保按照第二章中技术要求部分的说明创建 AWS 账户，并在尝试构建内容变现 NLP 解决方案部分的步骤之前，登录 AWS 管理控制台。

我们解决方案的 Python 代码和示例数据集可以在此处找到：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/tree/main/Chapter%2008。请按照以下部分的说明以及代码库中的代码构建解决方案。

查看以下视频，观看代码的实际应用：bit.ly/317mcSh。

介绍内容变现用例

我们知道 NLP 可以帮助提升客户服务体验，更好地理解客户的需求。现在，我们将使用 NLP 来确定媒体内容的上下文，并将相关广告无缝地插入到该内容中。为了说明我们的例子，让我们回到我们虚构的银行公司LiveRight Holdings Private Limited。LiveRight 的管理层决定，他们现在需要扩展到更多的地区，因为他们看到对无繁琐银行服务模式的需求很大，这种模式通过减少运营成本将节省下来的资金转移给客户。他们决定聘请你作为他们的营销技术架构师，负责所有内容创作，同时挑战你找到一种方式让这些内容通过其低成本政策实现自我盈利。你提出了创建有趣的教育视频的想法，这些视频展示了银行与技术交汇的最新趋势。由于这些视频可以免费观看，你可以在其中穿插广告以获得收入，同时它们还能提高银行的知名度，因此有很大的需求。

你已经思考过解决方案设计，并决定使用以下内容：

• AWS Elemental MediaConvert (aws.amazon.com/mediaconvert/)，一种托管的视频转码服务，可以将您的视频内容转换并增强为多个广播版本。

• Amazon Transcribe (aws.amazon.com/transcribe/) 用来获取视频内容的转录文本。

• Amazon Comprehend (aws.amazon.com/comprehend/) 用来利用其预训练的机器学习模型进行主题建模，从视频的文本内容中确定常见主题，这些主题将推动广告选择过程。

• AWS Elemental MediaTailor (aws.amazon.com/mediatailor/)，一种托管服务，可以接受媒体内容作为输入，将其组装成在线频道交付，并将广告插入到视频内容中。

我们将构建的解决方案的组件如下图所示：

图 8.1 – 内容货币化的 NLP 解决方案构建

我们将通过 AWS 管理控制台 (aws.amazon.com/console/) 和 Amazon SageMaker Jupyter 笔记本 (docs.aws.amazon.com/sagemaker/latest/dg/nbi.html) 演示此解决方案，这将使我们能够在逐步执行时查看代码和结果。如果您没有访问 AWS 管理控制台的权限，请遵循本书中第二章《介绍 Amazon Textract》部分中的技术要求部分的详细说明。

作为第一步，我们将查看 GitHub 仓库中提供的示例视频文件 (github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2008/media-content/bank-demo-prem-ranga.mp4)。示例视频展示了 AWS AI 服务在文档处理中的应用。有关该视频的完整版本，请参考 www.youtube.com/watch?v=vBtxjXjr_HA。我们将把这个示例视频上传到 S3 存储桶：

1. 在视频加载到 S3 存储桶后，我们将使用 AWS Elemental MediaConvert 创建我们示例视频内容的广播版本。

2. 同时，我们将打开我们的 Amazon SageMaker Jupyter 笔记本来运行代码，创建一个 Amazon Transcribe 转录任务，将我们示例视频的音频轨道转换为文本。

3. 我们将使用 Amazon Comprehend 主题建模来检测此文本中的主题。

4. 然后，我们将使用来自 'cmsid' 的样本 URL 和由标签 'vid' 引用的视频内容 ID，这些内容将被填充以在前一步中从转录文本中检测到的主题特定广告。

5. 然后，我们将为 AWS Elemental MediaConvert 作业的输出视频文件创建一个 Amazon CloudFront 分发。

6. 最后，我们将使用 AWS Elemental MediaTailor 创建一个新的配置，用于广播级流媒体内容，该配置将利用 CloudFront 分发提供的 MediaConvert 输出文件以及我们在上一步中修改的广告决策服务器 URL 来创建一个新的插入广告的视频文件。

在本节中，我们介绍了我们试图构建的 NLP 解决方案中引入的内容货币化需求，审视了 LiveRight 面临的挑战，并查看了我们将构建的解决方案概述。在下一节中，我们将逐步介绍构建解决方案的过程。

为内容货币化构建 NLP 解决方案

在上一节中，我们介绍了内容货币化的需求，涵盖了我们将构建的解决方案的架构，并简要地介绍了解决方案组件和工作流步骤。在本节中，我们将开始执行构建解决方案的任务。但首先，我们需要处理一些先决条件。

设置以解决使用案例

如果您在之前的章节中尚未完成此操作，您需要先创建一个 Amazon SageMaker Jupyter 笔记本实例，并为该笔记本角色设置身份和访问管理（IAM）权限，以便访问我们在本笔记本中将使用的 AWS 服务。之后，您需要克隆 GitHub 仓库（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services），创建一个 Amazon S3（aws.amazon.com/s3/）存储桶，并在笔记本中提供存储桶名称以开始执行。请按照接下来的步骤完成这些任务，然后我们可以执行笔记本中的代码单元格：

注意

请确保您已完成 技术要求 部分中提到的任务。如果您已经在之前的章节中创建了 Amazon SageMaker 笔记本实例并克隆了书籍的 GitHub 仓库，您可以跳过其中一些步骤。请直接转到打开与本章对应的笔记本文件夹的步骤。

1. 如果尚未完成，请按照 创建 Amazon SageMaker Jupyter 笔记本实例 部分中 设置 AWS 环境 部分中的第二章中记录的说明操作。介绍 Amazon Textract 来创建您的 Jupyter 笔记本实例。

   创建 Amazon SageMaker Jupyter 笔记本实例时的 IAM 角色权限

   在创建 notebook 时，接受默认的 IAM 角色选项以允许访问任何 S3 桶。

2. 一旦你创建了 notebook 实例，并且其状态为 InService，请点击 notebook 实例中的 操作 菜单下的 打开 Jupyter。

   图 8.2 – 打开 Jupyter notebook

   这将带你进入 notebook 实例的主文件夹。

3. 如下图所示，点击 新建 并选择 终端：

   图 8.3 – 在 Jupyter notebook 中打开终端

4. 在终端窗口中，首先输入cd SageMaker，然后输入git clone github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services，如下面的截图所示。如果你在前面的章节中已经执行过此操作，则不必再次克隆该仓库。

   图 8.4 – git clone 命令

5. 现在，退出终端窗口，返回到主文件夹，你将看到一个名为 Chapter 08 的文件夹。点击该文件夹，你应该会看到一个名为 contextual-ad-marking-for-content-monetization-with-nlp-github.ipynb 的 notebook。

6. 点击该 notebook 以打开它。

7. 暂时保持 notebook 打开。我们将先执行 上传示例视频并将其转换为广播格式 部分中的步骤，然后再执行 notebook 中的步骤。

现在我们已经设置好了 notebook 并克隆了仓库，接下来让我们添加所需的权限策略，以成功运行我们的代码示例。

额外的 IAM 前提条件

要运行 notebook，我们必须启用额外的策略，并更新 SageMaker notebook 角色的信任关系。请按以下步骤操作：

1. 如果尚未完成，请将ComprehendFullAccess和AmazonTranscribeFullAccess策略附加到你的 Amazon SageMaker notebook IAM 角色上。要执行此步骤，请参考 在《第二章》中，介绍 Amazon Textract 部分中的 更改 IAM 权限和信任关系。

2. 你的 SageMaker 执行角色应该已经可以访问 S3。如果没有，请将以下 JSON 语句作为内联策略添加。有关说明，请参考 在《第二章》中，介绍 Amazon Textract 部分中的 更改 IAM 权限和信任关系：

   { "Version": "2012-10-17", "Statement": [ {
     "Action": [
         "s3:GetObject",
         "s3:ListBucket",
         "s3:PutObject"
     ],
     "Resource": ["*"],
     "Effect": "Allow"
         }
     ]
   }
   

3. 最后，更新信任关系。有关说明，请参考本书中第二章，介绍 Amazon Textract部分中的更改 IAM 权限和信任关系以执行 Amazon SageMaker 笔记本角色小节。

   { "Version": "2012-10-17", "Statement": [
     { "Effect": "Allow", 
       "Principal": 
         { "Service": 
             [ "sagemaker.amazonaws.com", 
               "s3.amazonaws.com",
   "transcribe.amazonaws.com",
               "comprehend.amazonaws.com" ] 
             }, 
             "Action": "sts:AssumeRole" } 
         ] 
     }
   

现在我们已经设置了笔记本并配置了 IAM 角色来运行演练笔记本，在下一节中，我们将开始创建示例视频的广播版本。

上传示例视频并将其转换为广播格式

本节中，我们将创建两个 S3 存储桶，并上传示例视频进行处理。请执行以下步骤：

1. 访问我们的 GitHub 网址 - github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2008/media-content/bank-demo-prem-ranga.mp4，点击页面右侧中间的下载按钮，将视频文件下载到计算机中。

2. 现在创建两个 Amazon S3 存储桶，一个用于我们的媒体输入，另一个用于媒体输出。请参阅本书中第二章，介绍 Amazon Textract部分中的创建 Amazon S3 存储桶、文件夹和上传对象小节的详细说明。确保两个存储桶的公共访问阻止功能已启用。

3. 在 Amazon S3 媒体输入存储桶中，创建一个名为chapter8的文件夹或前缀。在此文件夹内，创建一个名为rawvideo的文件夹。请参阅本书中第二章，介绍 Amazon Textract部分中的创建 Amazon S3 存储桶、文件夹和上传对象小节的详细说明。

4. 现在将bank-demo-prem-ranga.mp4文件上传到rawvideo文件夹中。所以，在 S3 存储桶内，视频文件应位于路径chapter8/rawvideo/bank-demo-prem-ranga.mp4。

5. 现在，我们将转向使用 AWS Elemental MediaConvert 创建视频的广播版本。在 AWS 管理控制台中，在顶部的搜索框中输入Media，选择AWS Elemental MediaConvert，然后在控制台中点击开始使用。

   图 8.5 – AWS Elemental MediaConvert

6. 在s3://<media-input-bucket>/chapter8/rawvideo/bank-demo-prem-ranga.mp4。

   图 8.6 – 提供作业输入文件的 URL

7. 现在，点击屏幕左侧面板中的 添加 按钮，在 添加输出组 中选择 Apple HLS，然后点击 选择。输出组决定了生成的内容文件类型以及它们可以在哪些设备上播放。

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_08_07.jpg)

   图 8.7 – 为 MediaConvert 作业添加输出组

8. 现在，让我们填写 Apple HLS 输出组设置。提供自定义组名为 HLS。在 s3://<media-output-bucket>/bankdemo 中，AWS Elemental MediaConvert 服务将处理示例视频文件并生成用于广播的 Apple HLS 内容文件。在 10 和 3 中填写 最小段长度（秒）。

   图 8.8 – 为 MediaConvert 作业添加输出组设置

9. 滚动到 Output 1 的 名称修饰符 中的 _720。不要 点击 创建。

   图 8.9 – 为 MediaConvert 作业添加输出

10. 现在，点击 Output 1，如下所示：

    图 8.10 – 点击 Output 1

11. 如下图所示，在 1280 和 720 中输入 $dt$。在 比特率（比特/秒） 中输入 3000000。其他字段保持默认。

    图 8.11 – 修改输出和编码设置

12. 在左侧面板中，点击 作业设置 下的 AWS 集成。在右侧的 服务访问 下，对于 服务角色控制，选择 创建新的服务角色，完全权限。接受 新角色名称 中填充的默认名称。向下滚动并点击 创建。

    ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_08_12.jpg)

    图 8.12 – 为 MediaConvert 作业添加服务访问

13. 作业应在几分钟内完成。点击 Job ID 查看作业的摘要视图，如下图所示：

    图 8.13 – 作业摘要

14. 一旦状态显示 S3，在屏幕顶部的搜索栏中输入并进入 S3 控制台。在 bankdemo 下，如下图所示：

图 8.14 – AWS Elemental MediaConvert Apple HLS 输出文件

我们现在已经成功完成了将示例视频文件转换为适合广播的输出文件的步骤，这对于我们将广告插入到视频中是必需的。在接下来的章节中，我们将进行视频音频内容的转录，执行主题建模，创建VAST广告标签 URL 以供广告插入，并展示如何进行内容货币化。

运行转录、查找主题，并创建 VAST 广告标签 URL

打开你从 GitHub 仓库克隆的笔记本(github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2008/contextual-ad-marking-for-content-monetization-with-nlp-github.ipynb)，进入设置以解决用例部分，并按照以下步骤逐个执行单元格：

注意

请确保在执行笔记本中的单元格之前，已经执行了技术要求、设置以解决用例和上传示例视频并转换为广播格式部分中的步骤。

1. 执行转录部分下的前三个单元格，确保我们已经拥有笔记本所需的库。注意，在第一个单元格中你导入了库，在第二个单元格中你创建了进行主题建模所需的文件夹，在第三个单元格中你指定了 S3 存储桶和前缀。你应该已经在运行此笔记本之前创建了两个 S3 存储桶，正如在上传示例视频并转换为广播格式部分中提到的那样。在此行中，请提供媒体输入存储桶名称，输入你选择的前缀，或者你可以接受笔记本中已有的前缀。在此单元格中，我们还使用 Boto3（AWS Python 开发 SDK）定义了 Amazon S3 的 Python SDK 句柄(boto3.amazonaws.com/v1/documentation/api/latest/index.html)：

   bucket = '<your-s3-bucket>'
   prefix = 'chapter8'
   s3=boto3.client('s3')
   

2. 执行下一个单元格，以定义运行 Amazon Transcribe 转录任务的方法，将我们示例视频文件的音频内容转换为文本。请注意，我们将 MediaFormat 设置为 mp4。我们将使用来自 GitHub 仓库的原始示例视频文件(github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2008/media-content/bank-demo-prem-ranga.mp4)作为转录任务的输入：

   import time
   import boto3
   def transcribe_file(job_name, file_uri, transcribe_client):
       transcribe_client.start_transcription_job(
           TranscriptionJobName=job_name,
           Media={'MediaFileUri': file_uri},
           MediaFormat='mp4',
           LanguageCode='en-US'
       )
   

3. 提供一个转录任务名称（一个文本字符串），以便我们在后续过程中能够识别该任务。获取 Amazon Transcribe 服务的 Boto3 句柄，传入我们在媒体输入 S3 存储桶中加载的示例视频文件的 S3 位置，并调用 transcribe_file 方法运行转录任务：

   job_name = 'media-monetization-transcribe'
   transcribe_client = boto3.client('transcribe')
   file_uri = 's3://'+bucket+'/'+prefix+'/'+'rawvideo/bank-demo-prem-ranga.mp4'
   transcribe_file(job_name, file_uri, transcribe_client)
   

4. 现在，在新的标签页中导航到 AWS 管理控制台，在顶部的搜索框中输入 Amazon Transcribe，并打开 Amazon Transcribe 控制台。点击左侧面板中的转录任务。你应该能看到你之前指定的转录任务名称。当任务完成时，状态应该会变为完成。

   图 8.15 – Amazon Transcribe 转录任务

5. 现在回到笔记本并执行下一个单元，以获取转录结果的 S3 位置：

   job = transcribe_client.get_transcription_job(TranscriptionJobName=job_name)
   job_status = job['TranscriptionJob']['TranscriptionJobStatus']
   if job_status in ['COMPLETED', 'FAILED']:
       print(f"Job {job_name} is {job_status}.")
       if job_status == 'COMPLETED':
           print(f"Download the transcript from\n"
                 f"\t{job['TranscriptionJob']['Transcript']['TranscriptFileUri']}") 
   

6. 我们现在将执行transcript.csv文件中的代码单元，目的是将段落文本转换为单独的行（transcript_formatted.csv），然后作为输入发送到 Amazon Comprehend 主题建模任务中。请按照以下代码块中的示例执行笔记本中的代码：

   raw_df = pd.read_json(job['TranscriptionJob']['Transcript']['TranscriptFileUri'])
   raw_df = pd.DataFrame(raw_df.at['transcripts','results'].copy())
   raw_df.to_csv('topic-modeling/raw/transcript.csv', header=False, index=False)
   import csv
   folderpath = r"topic-modeling/raw" # make sure to put the 'r' in front and provide the folder where your files are
   filepaths  = [os.path.join(folderpath, name) for name in os.listdir(folderpath) if not name.startswith('.')] # do not select hidden directories
   fnfull = "topic-modeling/job-input/transcript_formatted.csv"
   for path in filepaths:
       print(path)
       with open(path, 'r') as f:
           content = f.read() # Read the whole file
           lines = content.split('.') # a list of all sentences
           with open(fnfull, "w", encoding='utf-8') as ff:
               csv_writer = csv.writer(ff, delimiter=',', quotechar = '"')
               for num,line in enumerate(lines): # for each sentence
                   csv_writer.writerow([line])
   f.close()
   s3.upload_file('topic-modeling/job-input/transcript_formatted.csv', bucket, prefix+'/topic-modeling/job-input/tm-input.csv')
   

7. 我们将对这个格式化的 CSV 文件运行一个 Amazon Comprehend 主题建模任务，提取一组适用于我们的转录内容的主题。这些主题代表并帮助我们识别相关文本的主题或领域，并表示在整个转录文本中具有相同上下文引用的共同单词集合。更多详情，请参阅Amazon Comprehend 主题建模：docs.aws.amazon.com/comprehend/latest/dg/topic-modeling.html。

8. 要开始使用，请访问 AWS 管理控制台（如果您没有访问 AWS 管理控制台的权限，请参考本书中第二章的技术要求，介绍 Amazon Textract），在我们之前上传到 S3 的transcript_formatted.csv文件中，输入Amazon Comprehend，如图所示：

   图 8.18 – 创建主题建模任务输入 2

   提供输出数据的 S3 位置，如图所示（你可以使用与输入相同的 S3 存储桶），然后输入一个名称后缀并点击创建任务。

   

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_08_19.jpg)

   图 8.19 – 创建主题建模任务输入 3

   在 IAM 角色传播完成后，您应该会看到任务已提交的状态。30 分钟后，任务状态应变为已完成。现在点击任务名称并复制输出数据位置字段中提供的 S3 链接，然后返回笔记本。我们将继续在笔记本中的步骤。

   

   图 8.20 – 主题建模任务已完成

9. 我们现在将执行 tpprefix 变量中的代码单元，特别是从 S3 URI 中复制的字符串，代码块如下所示，并突出显示粗体部分。

   directory = "results"
   parent_dir = os.getcwd()+'/topic-modeling'
   path = os.path.join(parent_dir, directory)
   os.makedirs(path, exist_ok = True)
   print("Directory '%s' created successfully" %directory)
   tpprefix = prefix+'/'+topic terms DataFrame contains the topic number, what term corresponds to the topic, and the weightage this term contributes to the topic. Execute the code shown in the following code block to review the contents of the topic terms DataFrame:
   
   

   for i, x in tt_df.iterrows():

   print(str(x['topic'])+":"+x['term']+":"+str(x['weight']))

   
   e.) We may have multiple topics on the same line, but for this solution, we are not interested in these duplicates, so we will drop them:
   
   

   dt_df = dt_df.drop_duplicates(subset=['docname'])

   
   f.) Let's now filter the topics such that we select the topic with the maximum weight distribution for the text it refers to:
   
   

   ttdf_max = tt_df.groupby(['topic'], sort=False)['weight'].max()

   
   g.) Load these into their own DataFrame and display it:
   
   

   newtt_df = pd.DataFrame()

   for x in ttdf_max:

   newtt_df = newtt_df.append(tt_df.query('weight == @x'))

   newtt_df = newtt_df.reset_index(drop=True)

   newtt_df

   
   h.) We will select the `content` topic term as it has the highest weight and assign this to a variable for use in the subsequent steps:
   
   

   adtopic = newtt_df.at[1,'term']

10. 我们现在将使用主题查找广告内容，并创建一个 VAST 广告标签 URL，该 URL 将作为输入用于将广告插入我们使用 AWS Elemental MediaConvert 创建的广播视频文件中。作者提供了两个包含广告查找内容元数据的示例 CSV 文件。ad-index.csv（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2008/media-content/ad-index.csv）包含作为键的主题列表和示例的cmsid与vid值。cmsid表示 Google Ad Server 中的内容管理源 ID，它是我们作为广告决策服务器在示例中使用的内容，而vid表示 Google Ad Server 中的视频内容 ID。adserver.csv（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2008/media-content/adserver.csv）包含我们在此步骤中需要修改的示例 Google 广告决策服务器 URL。在此示例中，我们将使用从我们的主题建模任务中发现的主题作为键来获取cmsid和vid。

    然后，我们将在创建 AWS Elemental MediaTailor 配置之前，替换 VAST 广告标记 URL 中的这些值。按照以下代码块所示执行代码单元：

    adindex_df = pd.read_csv('media-content/ad-index.csv', header=None, index_col=0)
    adindex_df
    

    a.) 请注意，这是来自作者为本次演示创建的示例ad-index.csv文件。当你在自己的使用场景中使用此解决方案时，你需要创建一个 Google Ads 账户以获取cmsid和vid值。更多详细信息，请查看此链接：support.google.com/admanager/topic/1184139?hl=en&ref_topic=7506089。

    b.) 运行以下代码片段，以根据我们的主题选择cmsid和vid值：

    advalue = adindex_df.loc[adtopic]
    advalue
    

    c.) 我们得到以下响应：

    1           cmsid=176
    2    vid=short_tencue
    

    d.) 现在，我们将创建用于 AWS Elemental MediaTailor 的广告服务器 URL。首先，从我们的 GitHub 仓库中复制可用的占位符 URL（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2008/media-content/adserver.csv），其中已填充前滚、中滚和后滚广告段：

    ad_rawurl = pd.read_csv('media-content/adserver.csv', header=None).at[0,0].split('&')
    ad_rawurl
    

    e.) 我们得到以下响应：

    ['https://pubads.g.doubleclick.net/gampad/ads?sz=640x480',
     'iu=/124319096/external/ad_rule_samples',
     'ciu_szs=300x250',
     'ad_rule=1',
     'impl=s',
     'gdfp_req=1',
     'env=vp',
     'output=vmap',
     'unviewed_position_start=1',
     'cust_params=deployment%3Ddevsite%26sample_ar%3Dpremidpost',
     cmsid and vid values highlighted in the preceding response with the values corresponding to our topic and reformat the URL:
    
    

    ad_formattedurl = ''

    对于 x 在 ad_rawurl 中的每一项：

    如果'x'中包含'cmsid'：

    x = advalue[1]

    如果'x'中包含'vid'：

    x = advalue[2]

    ad_formattedurl += x + '&'

    ad_formattedurl = ad_formattedurl.rstrip('&')

    ad_formattedurl

    
    g.) We get the following response. Copy the contents of the following URL:
    
    

    'https://pubads.g.doubleclick.net/gampad/ads?sz=640x480&iu=/124319096/external/ad_rule_samples&ciu_szs=300x250&ad_rule=1&impl=s&gdfp_req=1&env=vp&output=vmap&unviewed_position_start=1&cust_params=deployment%3Ddevsite%26sample_ar%3Dpremidpost&cmsid=176&vid=short_tencue&correlator=[avail.random]'

好的，这一部分就到这里。我们成功地使用 Amazon Transcribe 转录了样本视频文件，对转录内容进行了 Amazon Comprehend 主题建模，选择了一个主题，并结合了广告服务器 VAST 标签 URL 和与该主题对应的广告内容 ID。在下一部分，我们将使用 AWS Elemental MediaTailor 创建插入广告片段的新视频输出，并通过播放视频进行测试。

插入广告并测试我们的视频

在我们继续之前，需要为我们在 上传样本视频并将其转换为广播格式 部分中使用 AWS Elemental MediaConvert 转码的视频输出文件创建一个 Amazon CloudFront (aws.amazon.com/cloudfront/) 内容分发。

Amazon CloudFront 是一个托管的内容分发网络，可用于站点托管、API 以及图像、媒体和视频文件的传输，支持实时或按需流媒体格式，可根据选择的价格类别配置全球分发。请按照以下步骤为转码后的视频文件设置 CloudFront 分发：

1. 在 AWS 管理控制台中，在顶部的搜索框中输入 CloudFront，然后选择 Amazon CloudFront 并点击 创建分发。

   图 8.21 – Amazon CloudFront 创建分发

2. 在下一页，点击 开始使用 以继续进入 创建分发 页面。请注意，需要填写多个部分。在页面的 源设置 部分，点击 源域名 下拉框，选择包含来自 AWS Elemental MediaConvert 作业的视频输出文件的媒体输出存储桶。对于 限制存储桶访问 选择 是，对于 源访问身份 选择 创建新身份。对于 授予存储桶读取权限，选择 是，更新存储桶策略。

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_08_22.jpg)

   图 8.22 – Amazon CloudFront 创建分发的源设置

3. 向下滚动到 默认缓存行为设置 区域，并将 查看器协议策略 改为 重定向 HTTP 到 HTTPS。在 缓存策略 中，点击下拉框并选择 Managed-Elemental-MediaPackage。

   图 8.23 – 默认缓存行为设置

4. 向下滚动到分发设置区域，选择根据你所在位置的价格等级。将其他设置保持不变，向下滚动并点击创建分发。

   图 8.24 – 分发设置

5. 一旦分发创建完成，状态将变为已部署，并且状态会变为启用。复制从分发中得到的域名值。

   图 8.25 – 分发已启用

6. 我们现在将使用这个分发作为内容源，创建带有广告插入的新视频输出。在 AWS 管理控制台中，搜索框中输入MediaTailor，然后选择它以进入 AWS Elemental MediaTailor 控制台。点击创建配置开始。

   图 8.26 – AWS Elemental MediaTailor

7. 在创建配置页面， 在必需设置下，提供广告活动名称。在内容源字段中，粘贴前面步骤中复制的 Amazon CloudFront 分发域名。最后，在广告决策服务器字段中，输入你在运行转录、查找主题和创建 VAST 广告标签 URL部分最后一步中修改过的 VAST 广告标签 URL。滚动到底部并点击创建配置。

   图 8.27 – 创建 MediaTailor 配置

8. 创建的配置将如下面的截图所示。复制 HLS 播放前缀，因为我们在下一步中需要它。

   图 8.28 – MediaTailor 播放端点前缀

9. 下载 VLC 媒体播放器（www.videolan.org/）并打开它。点击bankdemo.m3u8。这是带有广告插入的 MediaTailor 视频输出的清单文件。完整的 URL 应如下所示（这是一个示例 URL）：https://<generated-hash-nr>.mediatailor.us-east-1.amazonaws.com/v1/master/<generated-hash-nr>/<chapter8-ad-campaign>/bankdemo.m3u8。

   图 8.29 – 使用 VLC 媒体播放器测试视频输出

10. 点击打开。视频将很快开始播放。请注意，广告插入在视频中显示需要几分钟时间。你应该看到一个 10 秒的前滚广告、一个 10 秒的中滚广告，以及后滚广告空间。由于我们使用了示例广告服务器 URL，这里不会显示实际广告，但一旦你通过广告决策服务器注册，你可以按照此方案中的步骤获得实际的广告内容。

这就是本章的解决方案构建部分。有关使用 AWS AI 和媒体服务进行媒体内容货币化的更多详细信息，请参阅进一步阅读部分。

摘要

本章中，我们学习了如何利用 AWS AI 服务 Amazon Transcribe 和 Amazon Comprehend、Amazon CloudFront 内容分发网络以及 AWS 媒体服务 Elemental MediaConvert 和 Elemental MediaTailor，构建一个用于媒体内容货币化的智能解决方案。我们以一个 MP4 视频文件为例，首先使用 MediaConvert 将其转码为 Apple HLS 输出文件，然后使用 Amazon Transcribe 从 MP4 文件中创建转录，分析转录内容，并通过 Amazon Comprehend 的主题建模检测主题，创建 VAST 广告决策服务器 URL。我们还介绍了如何使用 Amazon CloudFront 为转码后的视频内容创建分发，并使用该分发和广告决策服务器 URL，将广告插入转码后的视频中，使用 MediaTailor 进行操作。

对于我们的解决方案，我们首先介绍了 LiveRight 的内容货币化用例，该用例需要通过使用内容来支付内容创作的费用，从而实现具有成本效益的扩展。然后我们设计了一个架构，使用了 AWS AI 服务、媒体服务和内容分发网络，构建了一个端到端的操作流程，展示如何在视频文件中实现内容货币化。我们假设你，作为读者，是被指派到这个项目的架构师，并且我们回顾了方案组件的概述，并附带了图 8.1中的架构示意图。

接着我们回顾了解决方案构建的前提条件，设置了一个 Amazon SageMaker 笔记本实例，克隆了我们的 GitHub 仓库，并开始根据本章的说明，通过 AWS 管理控制台和笔记本中的代码执行步骤。

在下一章中，我们将探讨一个重要的用例——使用命名实体识别进行元数据提取。我们将像之前一样，介绍这个用例，讨论如何设计架构，建立前提条件，并详细阐述构建解决方案所需的各种步骤。

进一步阅读

• 媒体工作流货币化 (aws.amazon.com/media/resources/monetization/)

• 宣布 AWS 媒体智能解决方案 by Vasi Philozelligence-solutions/)

第九章：第九章：从金融文档中提取元数据

在上一章中，我们学习了如何利用 AWS AI 服务为媒体内容创收构建智能解决方案。我们讨论了如何通过我们虚构的公司 LiveRight Holdings 私人有限公司 寻求低成本的内容创收扩展。我们设计了一个架构，结合了 AWS AI 服务、媒体服务和内容分发网络，提供了如何在视频文件中实现内容创收的端到端流程。

在本章中，我们将研究 AWS AI 服务如何帮助我们提取 LiveRight Holdings 的财务报告元数据。这将使他们的金融分析师能够查看重要信息，并就合并、收购和 IPO 等财务事件做出更好的决策。

我们将讨论什么是元数据，为什么提取元数据很重要。然后，我们将介绍如何使用 Amazon Comprehend 实体提取，以及如何使用 Amazon Comprehend 事件从文档中提取元数据。

在本章中，我们将涵盖以下主题：

• 从金融文档中提取元数据

• 设置使用案例

技术要求

对于本章，您需要访问一个 AWS 账户。请确保按照第二章《介绍 Amazon Textract》部分中指定的技术要求创建 AWS 账户，并登录 AWS 管理控制台，然后再尝试 从金融文档中提取元数据 部分中的步骤。

我们解决方案的 Python 代码和示例数据集可以在github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/tree/main/Chapter%2009找到。请按照以下部分中的说明以及上述仓库中的代码构建解决方案。

请查看以下视频，了解代码的实际应用：bit.ly/3jBxp3E。

从金融文档中提取元数据

在本节中，我们将讨论一个使用案例，其中 LiveRight Holdings 私人有限公司 正试图收购 AwakenLife Pvt Ltd。它们即将发布新闻稿，金融分析师希望识别重要的元数据，例如收购日期、金额、组织等，以便根据市场情况采取行动。LiveRight 分析了 Amazon Whole Foods 合并案，以确定它能从中学到什么，以及元数据提取如何有助于其尽职调查。我们将使用 Amazon Whole Foods 合并案的示例数据集，了解如何使用前述架构执行元数据提取：

图 9.1 – 元数据提取架构

在此架构中，我们将从提取大规模财务文档的元数据开始。我们将展示如何使用 Amazon Textract 批处理作业从这些大型文档中提取数据，并将提取的数据保存为文本文件。然后，我们将展示如何使用 Comprehend Events 从该文本文件中提取实体，并使用知识图谱可视化实体之间的关系。你还可以使用 Amazon Neptune，它是一个图形数据库，可用于可视化这些关系。

在接下来的部分，我们将通过使用 Jupyter Notebook 代码来查看此架构。

设置用例

在本节中，我们将介绍如何入门，并带你走一遍上图所示的架构。

我们将解决方案代码演示分为以下几个部分：

• 设置笔记本代码和 S3 桶的创建

• 上传示例文档并使用 Textract 提取文本

• 使用 Comprehend 提取元数据

• 使用 SDK 启动 Comprehend Events 作业

• 从 S3 收集 Comprehend Events 作业结果

• 分析 Comprehend Events 的输出

设置笔记本代码和 S3 桶的创建

按照以下步骤设置笔记本：

1. 在你之前章节中设置的 SageMaker Jupyter 笔记本中，使用 Git 克隆 github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/。

2. 然后，前往 /Chapter 09/chapter 09 metadata extraction.ipynb 并开始运行笔记本。

3. 现在我们已经设置好了笔记本，接下来将创建一个 Amazon S3 桶。按照 第二章，介绍 Amazon Textract 中提供的步骤创建一个 Amazon S3 桶。

4. 复制创建的桶，打开你从 第九章**，从财务文档提取元数据 (Chapter 09/chapter 09 metadata extraction.ipynb) 中获取的示例代码，并将其粘贴到以下笔记本单元格中以开始：

   bucket = '<your s3 bucket name>'
   

   注意

   我们假设你的笔记本已获得 Amazon Comprehend 完全访问权限、Amazon S3 完全访问权限以及 Amazon Textract 完全访问权限。如果没有访问权限，将会遇到访问拒绝异常。

如果在运行笔记本中的任何步骤时遇到访问拒绝异常，请前往 第二章，介绍 Amazon Textract，并设置相关的 IAM 角色。

在下一部分，我们将引导你通过代码，让你了解架构是如何工作的。

上传示例文档并使用 Textract 提取文本

在本节中，我们将向您展示如何快速设置图 9.1 中显示的提议架构。我们已经创建了一个 Amazon S3 存储桶，用于存储您的输出和示例文件。我们还将该 S3 存储桶的名称粘贴在了笔记本单元格中。如果您还没有完成此步骤，请完成之前的步骤。

我们将参考以下笔记本：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2009/chapter%2009%20metadata%20extraction.ipynb。让我们开始吧：

1. 首先，我们必须从 Amazon S3 下载示例 PDF 财务新闻稿文件。

   现在，我们必须使用 upload_file S3 命令通过 sample_financial_news_doc.pdf boto3 API 将其上传到 S3 存储桶以进行处理。相同的存储桶将用于返回服务输出：

   filename = "sample_financial_news_doc.pdf"
   s3_client.upload_file(filename, bucket, filename)
   

   注意

   该 PDF 文件包含关于 Whole Foods 和 Amazon 在 2017 年合并的新闻稿声明，共 156 页。

2. 现在，我们将运行 Amazon Textract 将此 PDF 转换为文本文件；Amazon Comprehend 接受 UTF-8 编码的文本输入文件用于元数据提取。您可以运行笔记本代码开始一个异步处理任务，从文档中提取文本。我们已经在 第二章 中详细解释了异步 Textract 批处理代码的工作原理，介绍 Amazon Textract。如果您想深入了解，请参阅该章节。运行以下单元格获取任务结果：

   jobId = startJob(bucket, filename)
   print("Started job with id: {}".format(jobId))
   if(isJobComplete(jobId)):
       response = getJobResults(jobId)
   

   此时，您将获得一个 Job ID。等待任务的状态从进行中更改为完成：

   

   图 9.2 – Textract 任务状态

3. 现在，我们将通过运行以下笔记本单元格，将从 Amazon Textract 提取的数据转换为 UTF-8 文本文件，以供 Amazon Comprehend 使用：

   text_filename = 'sample_finance_data.txt'
   doc = Document(response)
   with open(text_filename, 'w', encoding='utf-8') as f:
       for page in doc.pages:
           page_string = ''
           for line in page.lines:
               #print((line.text))
               page_string += str(line.text)
           #print(page_string)
           f.writelines(page_string + "\n")
   

   财务新闻稿文件文本将从新闻稿文件中提取：

图 9.3 – 使用 Amazon Textract 从新闻稿文件中提取的文本

在本节中，我们介绍了如何使用 Amazon Textract 将新闻稿文件（关于 Amazon 收购 Whole Foods 的 2017 年新闻稿，共 156 页）中的文本数据提取为文本格式。在下一节中，我们将讨论如何使用 Comprehend 实体检测同步 API 和 Comprehend 事件异步任务从该文件中提取元数据。

使用 Comprehend 提取元数据

在本节中，我们将使用上述文本文件，利用 Amazon Comprehend 事件 API 提取元数据。

Comprehend 事件 API

Amazon Comprehend 事件是一个非常特定的 API，可以帮助您分析金融事件，如并购、收购、IPO 日期、新闻稿、破产等。它从这些事件中提取重要的金融实体，如 IPO 日期、并购方名称等，并建立关系，以便金融分析师能够实时处理其金融模型，做出准确的预测和快速决策。

Amazon Comprehend 事件可以帮助您分析异步作业。为此，您必须首先确保执行以下操作：

• 通过 AWS 控制台设置 Amazon Comprehend 事件作业。

• 通过笔记本设置 Amazon Comprehend 事件作业（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2009/chapter%2009%20metadata%20extraction.ipynb），使用 boto3 Python API。

  注意

  您可以选择上述方法之一，使用 Amazon Comprehend 事件分析您的新闻稿文档。

让我们从使用 Amazon Comprehend 控制台设置 Amazon Comprehend 事件作业开始：

1. 通过访问console.aws.amazon.com/comprehend/v2/home?region=us-east-1#home打开 Amazon Comprehend 控制台。

2. 转到分析作业 -> 创建分析作业。

3. 在作业设置中，输入名称：Test-events。您将看到可以选择多种分析类型，如情感分析、PII、实体和主题建模。选择事件。对于语言，选择英语，对于目标事件类型，选择所有可用选项，如下图所示：

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_09_04.jpg)

   图 9.4 – 创建 Comprehend 事件分析作业

4. 对于s3://<your bucket>/sample_finance_data.txt，选择每行一个文档作为输入格式。

   注意

   我们使用每行一个文档作为输入格式，而不是每个文件一个文档。这是因为这份新闻稿文档的总文件大小为 655 KB，而每个文件的文档大小限制为 10 KB。每行一个文档格式最多可以容纳 5,000 行；我们在本演示中使用的新闻稿文档包含 156 行。

   

   图 9.5 – 为分析作业选择输入数据

5. 对于s3://<your-bucket>：

   图 9.6 – 为分析作业选择输出 S3 位置

6. 对于events-role：

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_09_07.jpg)

   图 9.7 – 通过创建 IAM 角色设置访问权限

7. 点击创建作业按钮以触发事件作业。趁此机会喝杯咖啡或茶，因为此作业需要 15 分钟才能完成。

8. 一旦作业完成，请前往作业 ID：

图 9.8 – 在创建作业后，从作业详情页面复制作业 ID

注意

如果你是通过 Amazon Comprehend 控制台创建事件作业，跳过笔记本中的使用 SDK 启动异步作业部分，直接进入从 S3 收集结果部分。

在本节中，我们讲解了如何使用AWS 控制台为一份大型财务新闻稿文档创建 Comprehend Events 作业。如果你已经通过控制台进行设置，请跳过下一部分。

使用 SDK 启动 Comprehend Events 作业

在本节中，我们将切换回笔记本，使用 SDK 启动异步作业。让我们开始：

1. 通过访问 IAM 控制台 console.aws.amazon.com/iam/home?region=us-east-1#/home 创建一个 IAM 角色。确保创建一个有访问 Comprehend 权限并已指定 S3 的 IAM 角色。将以下内容粘贴到单元格中：

   job_data_access_role = 'arn:aws:iam::<your account number>:role/service-role/AmazonComprehendServiceRole-test-events-role'
   

2. 运行以下单元格以设置其他 Events 作业参数，如事件类型和输入数据格式：

   input_data_format = 'ONE_DOC_PER_LINE'
   job_uuid = uuid.uuid1()
   job_name = f"events-job-{job_uuid}"
   event_types = ["BANKRUPTCY", "EMPLOYMENT", "CORPORATE_ACQUISITION", 
                  "INVESTMENT_GENERAL", "CORPORATE_MERGER", "IPO",
                  "RIGHTS_ISSUE", "SECONDARY_OFFERING", "SHELF_OFFERING",
                  "TENDER_OFFERING", "STOCK_SPLIT"]
   

3. 运行以下单元格以触发 Events 分析作业。该作业正在调用 Python boto 3 启动事件检测作业的 API。请访问 boto3.amazonaws.com/v1/documentation/api/latest/reference/services/comprehend.html#Comprehend.Client.start_events_detection_job 了解更多信息：

   response = comprehend_client.start_events_detection_job(
       InputDataConfig={'S3Uri': input_data_s3_path,
                        'InputFormat': input_data_format},
       OutputDataConfig={'S3Uri': output_data_s3_path},
       DataAccessRoleArn=job_data_access_role,
       JobName=job_name,
       LanguageCode='en',
       TargetEventTypes=event_types
   )
   events_job_id = response['JobId']
   

在本节中，我们讲解了如何使用 SDK 启动 Comprehend Events 分析作业。此时，我们已有一个作业 ID，接下来将使用它收集输出并分析元数据。

从 S3 收集结果

在本节中，我们将在 Amazon S3 中分析此作业的输出结果。让我们开始：

1. 如果你之前使用过 Amazon Comprehend 控制台，你应该已经在该部分末尾复制了作业 ID。请通过取消注释将其粘贴到以下单元格中，然后运行该单元格：

   events_job_id ="<Job ID>"
   

2. 如果你使用 Amazon Comprehend SDK 启动了 Events 分析作业，请继续执行以下单元格来跟踪作业状态：

   job = comprehend_client.describe_events_detection_job(JobId=events_job_id)
   waited = 0
   timeout_minutes = 30
   while job['EventsDetectionJobProperties']['JobStatus'] != 'COMPLETED':
       sleep(60)
       waited += 60
       assert waited//60 < timeout_minutes, "Job timed out after %d seconds." % waited
       job = comprehend_client.describe_events_detection_job(JobId=events_job_id)
   

3. 一旦作业完成，你可以通过运行以下单元格从 Amazon S3 获取输出：

   output_data_s3_file = job['EventsDetectionJobProperties']['OutputDataConfig']['S3Uri'] + text_filename + '.out'
   results = []
   with smart_open.open(output_data_s3_file) as fi:
       results.extend([json.loads(line) for line in fi.readlines() if line])
   

在本节中，我们讲解了如何使用 SDK 跟踪 Comprehend Events 作业的完成情况，并从 Amazon S3 收集输出。现在我们已经收集了结果，接下来我们将分析提取的结果和元数据。

分析 Comprehend Events 的输出

在本节中，我们将向您展示不同的方式来分析 Comprehend Events 的输出。金融分析师可以利用这些输出预测市场趋势或查找大数据集中的关键信息。但首先，让我们了解一下Comprehend Events系统的输出（docs.aws.amazon.com/comprehend/latest/dg/how-events.html）：

• 系统返回每个提交文档的 JSON 输出。响应的结构如下所示：

  result = results[0]
  result
  

  在响应中，您会得到实体，以及作为 mentions、arguments 和 triggers 分组的实体，附带置信度分数。我们将在整个笔记本中看到这些术语的使用：

图 9.9 – Comprehend events JSON 输出

• Events 是 triggers 的组。API 的输出包括每个触发器的文本、字符偏移量和类型，以及置信度分数。事件组的成员资格置信度由 GroupScore 提供。运行以下笔记本单元格来查看这些内容：

  result['Events'][1]['Triggers']
  

  以下是前面代码的输出：

图 9.10 – Comprehend events 触发器

acquire 和 transaction 与 CORPORATE_ACQUISTION 类型的事件相关联。

• 参数通过 EntityIndex 与实体相关联，同时包括角色分配的分类置信度。它描述了实体与事件之间的关系。运行以下代码以理解这一点：

  result['Events'][1]['Arguments']
  

  arguments 的输出将如下所示：

图 9.11 – Comprehend events 参数

Investee、Amount 和 Date 是具有实体索引和置信度分数的角色。

• 实体是由 Mentions 组成的组，这些 Mentions 包括每个提及的 text、字符 offset 和 type，以及它们的置信度分数。实体组的成员资格置信度由 Group Scores 提供。让我们运行以下单元格来理解这一点：

  result['Entities'][5]['Mentions']
  

  以下输出显示了 Mention 实体的样子：

图 9.12 – Comprehend events 提及

entityIndex 5 指输出中的 Type Monetary_Value。

现在我们已经知道了什么是 entity、arguments 和 mentions，让我们可视化它们之间的关系。

事件和实体的可视化

在接下来的笔记本部分，我们将提供几种表格和可视化，帮助你理解 API 返回的内容。首先，我们将查看spans，包括triggers和实体mentions。序列标注任务中最基本的可视化任务之一是高亮文档中的标注文本。为了演示目的，我们将使用displaCy，这是一款内置的依存关系可视化工具，可以让你在浏览器中查看模型的预测结果（explosion.ai/demos/displacy）：

1. 运行以下代码将entity转换为 displaCy 格式。将Events的输出转换为 displaCy 格式：

   entities = [
       {'start': m['BeginOffset'], 'end': m['EndOffset'], 'label': m['Type']}
       for e in result['Entities']
       for m in e['Mentions']
   ]
   

2. 使用以下代码映射triggers：

   triggers = [
       {'start': t['BeginOffset'], 'end': t['EndOffset'], 'label': t['Type']}
       for e in result['Events']
       for t in e['Triggers']
   ]
   

3. 运行以下代码，使得spans被sorted，以便 displaCy 能够正确处理它：

   spans = sorted(entities + triggers, key=lambda x: x['start'])
   tags = [s['label'] for s in spans]
   output = [{"text": raw_texts[0], "ents": spans, "title": None, "settings": {}}]
   

4. 现在，我们将通过运行以下笔记本代码，呈现所有参与事件的entities：

   displacy.render(output, style="ent", options={"colors": color_map}, manual=True)
   

   以下是运行前述代码的输出：

图 9.13 – Comprehend 事件和实体

我们已根据发现的关系对事件进行了颜色编码。通过查看相同颜色的高亮实体和关系，我们可以看到 John Mackey 是联合创始人兼 CEO，并且他将继续在公司工作。

渲染表格数据

许多金融用户使用Events从非结构化文本中创建结构化数据。在本节中，我们将演示如何使用 pandas 做到这一点。

首先，我们必须通过以下操作将层次结构的 JSON 数据展平为 pandas DataFrame：

1. 创建entities DataFrame。实体索引必须显式创建：

   entities_df = pd.DataFrame([
       {"EntityIndex": i, **m}
       for i, e in enumerate(result['Entities'])
       for m in e['Mentions']
   ])
   

2. 创建events DataFrame。Event索引必须显式创建：

   events_df = pd.DataFrame([
       {"EventIndex": i, **a, **t}
       for i, e in enumerate(result['Events'])
       for a in e['Arguments']
       for t in e['Triggers']
   ])
   

3. 以下代码将把两个表连接成一个平坦的数据结构：

   events_df = events_df.merge(entities_df, on="EntityIndex", suffixes=('Event', 'Entity'))
   

   以下是EntityIndex作为表格结构的输出：

](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_09_14.jpg)

图 9.14 – Comprehend 事件作为 DataFrame 的实体

我们可以看到，将事件和相关元数据（如日期和时间）作为 python pandas DataFrame 进行分析和提取非常容易。一旦数据在 DataFrame 中，可以轻松保存到下游应用程序，如数据库或图数据库，进行进一步分析。

分析的表格表示

我们主要关注的是事件结构，因此我们通过创建一个新的表格，将Roles作为列标题，按事件分组来使其更加透明：

• 以下代码将为我们完成此操作：

  def format_compact_events(x):
      This code will take the most commonly occurring EventType and the set of triggers.
      d = {"EventType": Counter(x['TypeEvent']).most_common()[0][0],
           "Triggers": set(x['TextEvent'])}
      This code will loop for each argument Role, collect the set of mentions in the group.
      for role in x['Role']:
          d.update({role: set((x[x['Role']==role]['TextEntity']))})
      return d
  

• 以下代码将按EventIndex对数据进行分组并格式化：

  event_analysis_df = pd.DataFrame(
      events_df.groupby("EventIndex").apply(format_compact_events).tolist()
  ).fillna('')
  event_analysis_df
  

  以下截图展示了表示 Comprehend 事件表格格式的 DataFrame 输出：

](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_09_15.jpg)

图 9.15 – Comprehend 事件的表格表示

在前面的输出中，我们有事件类型、日期、被投资方、投资者、雇主、雇员和职务的表格表示，金融分析师可以轻松利用这些信息查看必要的元数据。

事件语义图

Comprehend Events 输出的最引人注目的表示形式是在语义图中，这是一个包含在文档中引用的实体和事件的网络。我们稍后将介绍的代码（请打开pyvis链接查看）使用了两个开源库：Networkx和pyvis。Networkx是一个 Python 包，用于创建、操作和研究复杂网络的结构、动态和功能（networkx.org/），而pyvis（pyvis.readthedocs.io/en/latest/）是一个库，可以快速生成可视化网络来呈现事件系统输出。顶点代表实体mentions和triggers，边则是图中实体与triggers之间所持的参数角色。

格式化数据

系统输出必须符合 Networkx 要求的节点（即顶点）和边列表格式。这需要遍历triggers、entities和argument结构关系。请注意，我们可以使用GroupScore和Score键对各种对象进行修剪，以剔除模型信心较低的节点和边。我们还可以使用不同的策略从每个mention组中选取一个“规范”提及以在图中显示；在这里，我们选择了字符串长度最长的提及。运行以下代码进行格式化：

• 为了简化，实体是按组与事件关联的，而非单个mentions。以下方法假设规范提及为最长的一个：

  def get_canonical_mention(mentions):
      extents = enumerate([m['Text'] form in mentions])
      longest_name = sorted(extents, key=lambda x: len(x[1]))
      return [mentions[longest_name[-1][0]]]
  

• 设置全局置信度阈值：

  thr = 0.5
  

• 在以下代码中，我们将节点表示为（id，type，tag，score，mention_type）元组：

  trigger_nodes = [
      ("tr%d" % i, t['Type'], t['Text'], t['Score'], "trigger")
      for i, e in enumerate(result['Events'])
      for t in e['Triggers'][:1]
      if t['GroupScore'] > thr
  ]
  entity_nodes = [
      ("en%d" % i, m['Type'], m['Text'], m['Score'], "entity")
      for i, e in enumerate(result['Entities'])
      for m in get_canonical_mention(e['Mentions'])
      if m['GroupScore'] > thr
  ]
  

• 在以下代码中，我们将边表示为（trigger_id，node_id，role，score）元组：

  argument_edges = [
      ("tr%d" % i, "en%d" % a['EntityIndex'], a['Role'], a['Score'])
      for i, e in enumerate(result['Events'])
      for a in e['Arguments']
      if a['Score'] > thr
  

• 为了创建一个紧凑的图形，一旦节点和边被定义，我们可以使用以下代码块来创建和可视化图形：

  G = nx.Graph()
  

• 遍历triggers和实体mentions，如下所示：

  for mention_id, tag, extent, score, mtype in trigger_nodes + entity_nodes:
      label = extent if mtype.startswith("entity") else tag
      G.add_node(mention_id, label=label, size=score*10, color=color_map[tag], tag=tag, group=mtype)
  

• 以下代码遍历参数角色分配：

  for event_id, entity_id, role, score in argument_edges:
      G.add_edges_from(
          [(event_id, entity_id)],
          label=role,
          weight=score*100,
          color="grey"
      )
  

• 以下代码会删除不参与事件的mentions：

  G.remove_nodes_from(list(nx.isolates(G)))
  nt = Network("600px", "800px", notebook=True, heading="")
  nt.from_nx(G)
  nt.show("compact_nx.html")
  

  以下是图形格式的输出：

图 9.16 – 理解事件知识图谱表示

在前面的输出中，如果我们遍历此图，可以看到实体之间的关系，已知的实体名为 Whole Foods，参与了公司合并的过程，且与其雇主有关系。雇主是 John Macey，他的职务是 CEO。

更完整的图

前面的图表非常简洁，只传达了基本的事件类型和参数角色信息。我们可以使用一组稍微复杂的函数来绘制 API 返回的所有信息。

这是events_graph.py中的一个便捷函数。它绘制了文档的完整图，显示了所有的events、triggers和entities，以及它们的分组：

import events_graph as evg
evg.plot(result, node_types=['event', 'trigger', 'entity_group', 'entity'], thr=0.5)

以下是图形格式的输出：

图 9.17 – 理解事件知识图谱可视化

注意

你可以使用Amazon Neptune与 Amazon Comprehend Events 进行大规模知识图谱分析。

在这里，我们已经提取了元数据并以表格方式分析它，并展示了如何将其呈现为图形。你可以使用 Amazon Neptune 与 Amazon Comprehend Events 进行大规模知识图谱分析，正如我们在图 9.1中所介绍的。

要深入了解如何使用 Amazon Neptune 实现这一点，请参考进一步阅读部分的相关博客，博客将引导你如何使用 Amazon Comprehend Events 在 Amazon Neptune 中构建知识图谱。

注意

使用 Comprehend Events 提取的Entities将与 Comprehend 的实体检测 API 不同，因为事件特定于金融事件的实体和关系提取。

你还可以使用 Amazon Comprehend 提取 Word 或 PDF 文档的元数据，使用检测实体、自定义实体，或者在金融文档的情况下使用 Comprehend Events，并通过SageMaker Ground Truth丰富文档标注过程。SageMaker Ground Truth 是一项主要用于标注数据的服务。

总结

本章中，我们学习了在查看LiveRight（我们虚构的银行）的用例之前，为什么元数据提取非常重要。该银行进行了收购并发布了新闻稿。财务分析师希望快速评估与该新闻稿相关的事件和实体，并进行市场预测。我们看了一种架构来帮助你实现这一目标。在图 1.1中展示的架构中，我们讨论了如何使用 AWS AI 服务，如 Amazon Textract，从样本新闻稿中提取文本。然后，我们将所有文本以 utf-8 编码保存在 Amazon S3 桶中，用于 Amazon Comprehend 的实体或元数据提取任务。

我们使用了一个 Amazon Comprehend Events 作业来提取实体及实体之间的关系。如果您希望进一步了解，可以在 进一步阅读 部分找到 Comprehend Events 功能 的 演示视频 链接。我们还提供了两种配置 Comprehend Events 作业的方法；即，可以使用 AWS 控制台或 AWS Python boto3 API。最后，我们讨论了如何使用图形 API（例如 displayCy、Networkx 或 pyvis）或使用 Amazon Neptune 的图形数据库来可视化提取的元数据之间的关系。我们还建议，可以将这些元数据进一步用作数据标注的输入，使用 Amazon SageMaker Ground Truth。

在下一章中，我们将讨论如何为您的酷炫网站进行内容变现。

进一步阅读

要了解更多本章中涵盖的主题，请查看以下资源：

• 在 Amazon Neptune 中使用 Amazon Comprehend Events 构建知识图谱，由 Brian O'Keefe、Graham Horwood 和 Navtanay Sinha 编写 (aws.amazon.com/blogs/database/building-a-knowledge-graph-in-amazon-neptune-using-amazon-comprehend-events/)。

• 宣布推出 Amazon Comprehend Events，由 Graham Horwood、Sameer Karnik 和 Ben Snively 编写 (aws.amazon.com/blogs/machine-learning/announcing-the-launch-of-amazon-comprehend-events/)。

• Fintech Snacks 2 – 使用 Amazon Comprehend Events 提取市场驱动事件，由 Mona Mona 和 Evan Peck 编写 (www.youtube.com/watch?v=QvmVT_8y7-Y)。

第十章：第十章：通过机器翻译降低本地化成本

大约十五年前（在互联网还不像今天这样发达的时候），其中一位作者去了瑞士进行观光旅行。这是一个冲动的、临时的决定，而且几乎没有太多规划。旅行本身很平淡，作者知道德语在瑞士是可接受的语言，于是在旅途中忙着进行英语到德语的罗塞塔语音练习。根据曾去过瑞士的朋友的建议，作者粗略地制定了一个行程，包括参观苏黎世、因特拉肯、伯尔尼等地。凭借他非常幼稚的德语，尤其是由于瑞士人流利的英语，作者逐渐放松了下来，甚至开始享受起旅行——直到，当然，他去了日内瓦，那里的每个人只说法语。他尝试用英语交谈时遭遇冷漠，他所知道的唯一法语单词就是“oui”（意思是“是”）和“au revoir”（意思是“再见”）！作者最终不得不使用手势语言，通过指着餐厅菜单上的项目、展示旅游指南书询问旅游景点等方式度过接下来的几天。如果当时作者能使用如今常见的基于机器学习的高级翻译解决方案——日内瓦本该是轻松愉快的。

在他 2005 年出版的书籍《世界是平的》中（几乎在这位作者前往日内瓦的同一时期），托马斯·L·弗里德曼详细描述了全球化的意义，特别是技术进步（包括个人电脑和互联网）如何导致经济界限和界区的崩塌，甚至将全球竞争的舞台拉平。当企业走向全球化时，他们最常遇到的任务之一就是将其网站的语言翻译成他们选择运营的国家或地区的本地语言。这就是所谓的本地化。传统上，组织会雇佣一个翻译团队， painstakingly（辛苦地）逐页翻译其网站内容，确保准确表达原文的上下文。这些内容会手动输入到多个页面中以搭建网站。这既耗时又昂贵，但由于这是必要的任务，组织们别无选择。如今，随着基于机器学习的翻译技术，如亚马逊翻译的出现，本地化可以以以前的几分之一的成本完成。

在上一章中，我们看到如何利用 AWS AI 服务的 NLP 功能为 LiveRight 提取财务报告的元数据，以便他们的财务分析师能够查看重要信息并就合并、收购和 IPO 等财务事件做出更好的决策。在本章中，我们将看到 NLP 和 AWS AI 服务如何通过 Amazon Translate（aws.amazon.com/translate/）帮助自动化网站本地化。Amazon Translate 是一个基于机器学习的翻译服务，支持 71 种语言。使用 Amazon Translate 不需要进行任何机器学习训练，因为它是预训练的，并且支持通过简单的 API 调用进行调用。对于适用于您业务的特定用例，您可以使用 Amazon Translate 的高级功能，如命名实体翻译自定义（docs.aws.amazon.com/translate/latest/dg/how-custom-terminology.html）、主动自定义翻译（docs.aws.amazon.com/translate/latest/dg/customizing-translations-parallel-data.html）等。

为了学习如何构建一个高性价比的本地化解决方案，我们将涵盖以下主题：

• 介绍本地化用例

• 使用机器翻译构建多语言网页

技术要求

对于本章，你需要一个 AWS 账户。请确保按照第二章中技术要求部分的说明，创建你的 AWS 账户。在尝试执行使用机器翻译构建多语言网页部分的步骤之前，请确保已登录 AWS 管理控制台。

我们解决方案的 Python 代码和示例数据集可以在以下链接找到：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/tree/main/Chapter%2010。请使用以下各节中的说明，并结合代码库中的代码来构建解决方案。

查看以下视频，了解代码演示：bit.ly/3meYsn0。

介绍本地化用例

在前几章中，我们探讨了多种自然语言处理（NLP）如何帮助我们更好地理解客户。我们学习了如何构建应用程序来检测情感、实现内容货币化、识别独特实体，并理解上下文、引用及其他分析流程，这些都帮助组织获得关于其业务的重要洞察。在这一章中，我们将学习如何自动化将网站内容翻译成多种语言的过程。为了说明这个例子，我们假设我们的虚拟银行公司LiveRight Holdings Private Limited已经决定扩展到德国、西班牙以及印度的孟买和金奈等城市，以吸引潜在客户。这四个试点区域的上线日期即将来临，也就是在接下来的三周内。扩展项目负责人已向高层管理层提出了担忧，表示 IT 团队可能无法按时准备好对应地区的德语、西班牙语、印地语和泰米尔语网站，以迎接上线。你接到了一通来自 IT 总监的紧急电话，她要求你作为应用架构师，在接下来的两周内设计并构建这些网站，这样他们可以利用最后一周进行验收测试。

你知道手动方法不行，因为雇佣翻译人员、完成工作并在两周内构建网站几乎不可能。在进行了一些快速调研后，你决定使用Amazon Translate，这是一项基于机器学习的翻译服务，来自动化网站的翻译过程。你查看了 Amazon Translate 定价页面（https://aws.amazon.com/translate/pricing/），发现你可以以最低 15 美元的价格翻译一百万个字符，更重要的是，在前 12 个月内，你可以利用AWS 免费套餐（aws.amazon.com/free/），每月免费翻译 200 万个字符。对于试点网站，你进行了字符计数，发现大约有 50 万个字符。与此同时，您的总监联系你，要求你快速创建一个关于我们页面的可展示原型（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2010/input/aboutLRH.html），并支持德语、西班牙语、印地语和泰米尔语这四种目标语言。

我们将通过 AWS 管理控制台和 Amazon SageMaker Jupyter 笔记本来演示这个解决方案。请参考第二章中设置您的 AWS 环境部分的注册 AWS 账户部分，获取关于如何注册 AWS 账户并登录AWS 管理控制台的详细说明。

首先，我们将创建一个 Amazon SageMaker Jupyter 笔记本实例（如果您在前几章中还没有创建的话），将代码库克隆到我们的笔记本实例中，打开用于解决方案演示的 Jupyter 笔记本 (github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2010/Reducing-localization-costs-with-machine-translation-github.ipynb)，并执行笔记本中的步骤。详细的操作说明将在 使用机器翻译构建多语言网页 部分提供。让我们一起来看看：

1. 在笔记本中，我们将查看关于我们页面的英文版本。

2. 然后，我们将审查 关于我们 页面的 HTML 代码，以确定哪些标签组件需要翻译。

3. 接下来，我们将为 Python 安装一个 HTML 解析器库（www.crummy.com/software/BeautifulSoup/bs4/doc/），并将我们感兴趣的标签的文本内容从 HTML 页面提取到一个列表中。

4. 我们将使用 boto3 AWS Python SDK 通过 Amazon Translate 来调用翻译功能。我们将以循环的方式获取德语、西班牙语、印地语和泰米尔语的翻译内容。

5. 然后，我们将采用原始的 HTML（英文版），并用每种语言对应标签的内容进行更新，从而创建四个独立的 HTML 页面。

6. 最后，我们将展示 HTML 页面，以审查翻译内容。

完成此操作后，您可以将 HTML 上传到 Amazon S3 桶，并设置 Amazon CloudFront 分发，几分钟内便能全球部署您的网站。有关如何操作的更多细节，请参阅此链接：docs.aws.amazon.com/AmazonS3/latest/userguide/website-hosting-cloudfront-walkthrough.html。在本节中，我们介绍了 LiveRight 的本地化需求，该公司希望拓展国际市场，需要为这些市场的启动提供本地语言的网页。在下一节中，我们将学习如何构建解决方案。

使用机器翻译构建多语言网页

在上一节中，我们介绍了网页本地化的需求，讨论了我们将要构建的解决方案的设计方面，并简要介绍了解决方案组件和工作流程步骤。在本节中，我们将开始执行构建解决方案的任务。但首先，我们需要处理一些前提条件。

设置以解决用例

如果您在前面的章节中没有这样做，作为前提条件，您需要创建一个 Amazon SageMaker Jupyter Notebook 实例，设置第十章文件夹，并打开Reducing-localization-costs-with-machine-translation-github.ipynb笔记本以开始执行过程。

注意

请确保您已经完成了技术要求部分提到的任务。

请按照第二章中[设置您的 AWS 环境]章节的创建 Amazon SageMaker Jupyter Notebook 实例部分的说明，创建您的 Jupyter Notebook 实例。让我们开始吧：

重要 – 在创建 Amazon SageMaker Jupyter 笔记本时的 IAM 角色权限

接受在笔记本创建时 IAM 角色的默认设置，以允许访问任何 S3 存储桶。

1. 一旦创建了笔记本实例并将其状态设置为TranslateFullAccess策略，接下来需要为您的 Amazon SageMaker 笔记本 IAM 角色设置权限。要执行此步骤，请参阅第二章中介绍 Amazon Textract部分的更改 IAM 权限和信任关系以便执行 Amazon SageMaker 笔记本角色章节。

2. 现在，返回到您的笔记本实例并点击操作菜单中的打开 Jupyter：

   图 10.1 – 打开 Jupyter 笔记本

   这将带您进入笔记本实例的主文件夹。

3. 点击新建并选择终端，如下图所示：

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_10_02.jpg)

   图 10.2 – 在 Jupyter 笔记本中打开终端

4. 在终端窗口中，键入cd SageMaker，然后键入git clone https://github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services，如下图所示。如果您在前面的章节中已经为该笔记本实例执行了此操作，则无需再次克隆代码库：

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_10_03.jpg)

   图 10.3 – git clone 命令

5. 现在，退出终端窗口并返回主文件夹–您将看到一个名为Natural-Language-Processing-with-AWS-AI-Services的文件夹。点击此文件夹后，您将看到chapter-10-localization-with-machine-translation。点击该文件夹，然后打开Reducing-localization-costs-with-machine-translation-github.ipynb笔记本。

现在，我们已经创建了笔记本实例并克隆了我们的代码库，可以开始运行笔记本代码了。

运行笔记本

打开你从本书 GitHub 仓库中克隆的笔记本（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2010/Reducing-localization-costs-with-machine-translation-github.ipynb），正如我们在为解决用例做好准备部分中讨论的那样，按照以下步骤逐步执行单元格：

注意

请确保在执行笔记本中的单元格之前，您已完成技术要求和为解决用例做好准备部分中的步骤。

1. 执行笔记本中的第一个单元格，位于输入 HTML 网页部分，渲染英文版网页的 HTML：

   from IPython.display import IFrame
   IFrame(src='./input/aboutLRH.html', width=800, height=400)
   

2. 您将看到页面中有几个标题，然后是一个段落，讲述家庭银行，它是LiveRight Holdings的子公司：

   图 10.4 – 网页的英文版本

3. 执行以下单元格以查看网页的 HTML 代码：

   !pygmentize './input/aboutLRH.html'
   

4. 我们将看到网页的以下输出。以下输出中突出显示的区域是我们感兴趣的、需要翻译的标签。在此代码块中，我们可以定义网页的标题以及一些默认的 JavaScript 导入：

   <!DOCTYPE html>
   <html>
       <head>
           <title>Live Well with LiveRight</title>
           <meta name="viewport" charset="UTF-8" content="width=device-width, initial-scale=1.0">
           <script src="img/jquery.min.js"></script>
           <script src="img/popper.min.js"></script>
           <script src="img/bootstrap.min.js"></script>
           <script src="img/aws-sdk-2.408.0.min.js"></script>
           <script src="img/Chart.min.js"></script>
       </head>
   

5. 现在，我们将通过 h1、h2 和 h3 标题来定义页面的主体，如下代码块所示：

       <body>
           <h1>Family Bank Holdings</h1>
           <h3>Date: <span id="date"></span></h3>
           <div id="home">
             <div id="hometext">
           <h2>Who we are and what we do</h2>
   

6. 接下来，我们将定义实际的正文部分为 h4 标题，以突出显示，如下代码块所示：

           <h4><p>A wholly owned subsidiary of LiveRight, we are the nation's largest bank for SMB owners and cooperative societies, with more than 4500 branches spread across the nation, servicing more than 5 million customers and continuing to grow.
             We offer a number of lending products to our customers including checking and savings accounts, lending, credit cards, deposits, insurance, IRA and more. Started in 1787 as a family owned business providing low interest loans for farmers struggling with poor harvests, LiveRight helped these farmers design long distance water channels from lakes in neighboring districts
                to their lands. The initial success helped these farmers invest their wealth in LiveRight and later led to our cooperative range of products that allowed farmers to own a part of LiveRight.
                In 1850 we moved our HeadQuarters to New York city to help build the economy of our nation by providing low interest lending products to small to medium business owners looking to start or expand their business.
                 From 2 branches then to 4500 branches today, the trust of our customers helped us grow to become the nation's largest SMB bank. </p>
           </h4>
           </div>
           </div>
   

7. 现在，我们将开始 HTML 中的 JavaScript 部分，以获取当前日期并显示，如下代码块所示：

           <script>
           // get date
               var today = new Date();
               var dd = String(today.getDate()).padStart(2, '0');
               var mm = String(today.getMonth() + 1).padStart(2, '0'); //January is 0!
               var yyyy = today.getFullYear();
               today = mm + '/' + dd + '/' + yyyy;
               document.getElementById('date').innerHTML = today; //update the date
           </script>
       </body>
       <style>
   

8. 最后，我们将声明每个部分所需的 CSS 样式（www.w3.org/Style/CSS/Overview.en.html）。首先，这里是网页主体的样式：

       body {
             overflow: hidden;
             position: absolute;
             width: 100%;
             height: 100%;
             background: #404040;
             top: 0;
             margin: 0;
             padding: 0;
             -webkit-font-smoothing: antialiased;
   }
   

9. 以下是背景和背景文本小部件的样式，这些小部件被称为 home 和 hometext：

           #home {
             width: 100%;
             height: 80%;
             bottom: 0;
             background-color: #ff8c00;
             color: #fff;
             margin: 0px;
             padding: 0;
           }
           #hometext {
             top: 20%;
             margin: 10px;
             padding: 0;
           }
   

10. 最后，我们将为网页中的每个标题和段落定义样式：

            h1 {
                text-align: center;
                color: #fff;
                font-family: 'Lato', sans-serif;
            }
            h2 {
                text-align: center;
                color: #fff;
                font-family: 'Lato', sans-serif;
            }
            h3 {
                text-align: center;
                color: #fff;
                font-family: 'Lato', sans-serif;
            }
            h4 {
                font-family: 'Lato', sans-serif;
            }
            p {
                font-family: 'Lato', sans-serif;
            }
    
        </style>
    </html>
    

11. 现在，我们将执行准备翻译部分中的单元格。执行第一个单元格以安装我们解决方案所需的 HTML 解析器，名为 Beautiful Soup（www.crummy.com/software/BeautifulSoup/bs4/doc/）：

    !pip install beautifulsoup4
    

12. 接下来，运行以下单元格将我们的英文 HTML 页面代码加载到一个变量中，以便我们可以使用 Beautiful Soup 解析它：

    html_doc = ''
    input_htm = './input/aboutLRH.html'
    with open(input_htm) as f:
        content = f.readlines()
    for i in content:
        html_doc += i+' '
    

13. 现在，解析 HTML 页面：

    from bs4 import BeautifulSoup
    soup = BeautifulSoup(html_doc, 'html.parser')
    

14. 让我们定义我们感兴趣的 HTML 标签列表，并将这些 HTML 标签的文本内容加载到字典中：

    tags = ['title','h1','h2','p']
    x_dict = {}
    for tag in tags:
        x_dict[tag] = getattr(getattr(soup, tag),'string')
    x_dict
    

15. 我们将收到以下响应：

    {'title': 'Live Well with LiveRight',
     'h1': 'Family Bank Holdings',
     'h2': 'Who we are and what we do',
     'p': "A wholly owned subsidiary of LiveRight, we are the nation's largest bank for SMB owners and cooperative societies, with more than 4500 branches spread across the nation, servicing more than 5 million customers and continuing to grow.\n           We offer a number of lending products to our customers including checking and savings accounts, lending, credit cards, deposits, insurance, IRA and more. Started in 1787 as a family owned business providing low interest loans for farmers struggling with poor harvests, LiveRight helped these farmers design long distance water channels from lakes in neighboring districts\n              to their lands. The initial success helped these farmers invest their wealth in LiveRight and later led to our cooperative range of products that allowed farmers to own a part of LiveRight.\n              In 1850 we moved our HeadQuarters to New York city to help build the economy of our nation by providing low interest lending products to small to medium business owners looking to start or expand their business.\n               From 2 branches then to 4500 branches today, the trust of our customers helped us grow to become the nation's largest SMB bank. "}
    

16. 现在，我们将执行翻译成目标语言部分中的单元格。在第一个单元格中，我们将导入boto3库（boto3.amazonaws.com/v1/documentation/api/latest/index.html），AWS 服务的 Python SDK，创建 Amazon Translate 的句柄，然后将我们的网页翻译成目标语言：

    import boto3
    translate = boto3.client(service_name='translate', region_name='us-east-1', use_ssl=True)
    out_text = {}
    languages = ['de','es','ta','hi']
    for target_lang in languages:
        out_dict = {}
        for key in x_dict:
            result = translate.translate_text(Text=x_dict[key], 
                SourceLanguageCode="en", TargetLanguageCode=target_lang)
            out_dict[key] = result.get('TranslatedText')
        out_text[target_lang] = out_dict
    

17. 现在，让我们执行为翻译文本构建网页部分中的单元格。该部分分为四个小节——每个目标语言一个。执行德语网页下的单元格。该代码将 HTML 解析器的输出分配给一个新变量，使用前一步翻译的内容更新 HTML 标签值，然后将完整的 HTML 写入输出 HTML 文件中。为简便起见，该小节下的四个独立单元格的代码被合并如下：

    web_de = soup
    web_de.title.string = out_text['de']['title']
    web_de.h1.string = out_text['de']['h1']
    web_de.h2.string = out_text['de']['h2']
    web_de.p.string = out_text['de']['p']
    de_html = web_de.prettify()
    with open('./output/aboutLRH_DE.html','w') as de_w:
        de_w.write(de_html)
    IFrame(src='./output/aboutLRH_DE.html', width=800, height=500)
    

18. 我们将得到以下输出：

    图 10.5 – 翻译后的德语网页

19. 执行西班牙语网页下的单元格。该代码将 HTML 解析器的输出分配给一个新变量，使用前一步翻译的内容更新 HTML 标签值，然后将完整的 HTML 写入输出 HTML 文件中。为简便起见，该小节下的四个独立单元格的代码被合并如下：

    web_es = soup
    web_es.title.string = out_text['es']['title']
    web_es.h1.string = out_text['es']['h1']
    web_es.h2.string = out_text['es']['h2']
    web_es.p.string = out_text['es']['p']
    es_html = web_es.prettify()
    with open('./output/aboutLRH_ES.html','w') as es_w:
        es_w.write(es_html)
    IFrame(src='./output/aboutLRH_ES.html', width=800, height=500)
    

20. 我们将得到以下输出：

    图 10.6 – 翻译后的西班牙语网页

21. 执行印地语网页下的单元格。该代码将 HTML 解析器的输出分配给一个新变量，使用前一步翻译的内容更新 HTML 标签值，然后将完整的 HTML 写入输出 HTML 文件中。为简便起见，该小节下的四个独立单元格的代码被合并如下：

    web_hi = soup
    web_hi.title.string = out_text['hi']['title']
    web_hi.h1.string = out_text['hi']['h1']
    web_hi.h2.string = out_text['hi']['h2']
    web_hi.p.string = out_text['hi']['p']
    hi_html = web_hi.prettify()
    with open('./output/aboutLRH_HI.html','w') as hi_w:
        hi_w.write(hi_html)
    IFrame(src='./output/aboutLRH_HI.html', width=800, height=500)
    

22. 我们将得到以下输出：

    图 10.7 – 翻译后的印地语网页

23. 执行泰米尔语网页下的单元格。该代码将 HTML 解析器的输出分配给一个新变量，使用前一步翻译的内容更新 HTML 标签值，然后将完整的 HTML 写入输出 HTML 文件中。为简便起见，该小节下的四个独立单元格的代码被合并如下：

    web_ta = soup
    web_ta.title.string = out_text['ta']['title']
    web_ta.h1.string = out_text['ta']['h1']
    web_ta.h2.string = out_text['ta']['h2']
    web_ta.p.string = out_text['ta']['p']
    ta_html = web_ta.prettify()
    with open('./output/aboutLRH_TA.html','w') as ta_w:
        ta_w.write(ta_html)
    IFrame(src='./output/aboutLRH_TA.html', width=800, height=500)
    

24. 我们将得到以下输出：

    图 10.8 – 翻译后的泰米尔语网页

25. 在某些情况下，你可能会发现特定于你组织的自定义品牌名称或产品术语未能正确翻译成目标语言中的所需上下文。在这种情况下，使用Amazon Translate 自定义术语来确保 Amazon Translate 能够识别这些独特单词的上下文。有关详细信息，你可以参考以下文档：docs.aws.amazon.com/translate/latest/dg/how-custom-terminology.html。

这就是本章解决方案的构建过程。如前所述，你可以将网页上传到 Amazon S3 存储桶 (boto3.amazonaws.com/v1/documentation/api/latest/guide/s3-uploading-files.html)，并使用 Amazon CloudFront (docs.aws.amazon.com/AmazonS3/latest/userguide/website-hosting-cloudfront-walkthrough.html) 在几分钟内将你的网页全球分发。此外，Amazon Translate 每月免费支持翻译 200 万字符，12 个月后，每百万字符仅需$15，极大降低了翻译成本。有关如何利用 Amazon Translate 满足你的需求的更多想法，请参考进一步阅读部分。

总结

在本章中，我们学习了如何使用 Amazon Translate 快速且高效地构建网页的内容本地化，Amazon Translate 是一种基于机器学习的翻译服务，提供强大的机器翻译模型，并通过 API 端点便捷访问。首先，我们回顾了一个虚构公司的使用案例，该公司名为LiveRight Holdings，希望扩大国际市场，并需要在 3 周内将其网站推出四种不同语言版本。LiveRight 没有足够的时间或资金聘请经验丰富的翻译人员来手动完成网站转换。LiveRight 的 IT 总监雇佣了你来制定一个快速且具有成本效益的解决方案。

为此，你设计了一个使用 Amazon Translate 的解决方案，利用 Python HTML 解析器从英文版本的 HTML 页面中提取相关标签内容，将其翻译成德语、西班牙语、印地语和泰米尔语，然后生成包含翻译内容的新 HTML 页面。为了执行该解决方案，我们创建了一个 Amazon SageMaker Jupyter 笔记本实例，并为该笔记本实例分配了 Amazon Translate 的 IAM 权限，克隆了本章的 GitHub 代码库，并通过逐个执行代码块的方式演示了解决方案。最后，我们在笔记本中展示了包含翻译内容的 HTML 页面以供审阅。

在下一章中，我们将探讨一个有趣的用例，以及 NLP 的一个重要应用：使用聊天机器人构建与文档内容交互并为消费者提供自助工具的会话界面。我们将再次以LiveRight Holdings为例，具体讨论贷款部门的需求，他们进行房屋买家研究以设计产品提供方案。与本章类似，我们将介绍用例，讨论架构设计，确立前提条件，并逐步介绍构建解决方案所需的各个步骤。

进一步阅读

如果想要了解本章涉及的主题更多信息，请查看以下资源：

• 在 CI/CD 流水线中使用 Amazon Translate 自动翻译您的网站或应用程序，作者是 Carlos Afonso (aws.amazon.com/blogs/machine-learning/translating-your-website-or-application-automatically-with-amazon-translate-in-your-ci-cd-pipeline/)

• 使用 Amazon Translate Active Custom Translation 自定义机器翻译，作者是 Watson Srivathsan 和 Xingyao Wang (aws.amazon.com/blogs/machine-learning/customizing-your-machine-translation-using-amazon-translate-active-custom-translation/)

• 在云中翻译语言文本 (aws.amazon.com/getting-started/hands-on/translate-text-between-languages-cloud/)

• 使用 Amazon Translate 翻译视频字幕，作者是 Siva Rajamani 和 Raju Penmatcha (https://aws.amazon.com/blogs/machine-learning/translate-video-captions-and-subtitles-using-amazon-translate/)

• 世界是平的 (www.amazon.com/World-Flat-History-Twenty-first-Century/dp/0374292884)

第十一章：第十一章：使用聊天机器人查询文档

想象一下，如果你能够与文档中的文本数据进行双向对话。假设你订阅了多本期刊，定期收到关于技术趋势的研究文章。这些文章可能涵盖多个行业和技术，但你只对某个特定行业和技术的洞察感兴趣。传统上，你会有一支团队去翻阅这些文档，解读、理解，并推荐你需要采取的方向。如果你可以仅通过拿起手机，与一个聊天机器人对话，获得你需要的答案，而这些答案就来自你的文档库，岂不是太棒了吗？这就是将自然语言处理（NLP）技术与聊天机器人结合的力量。你可以真正和你的文档“对话”，并得到回答。

在上一章中，我们讨论了企业如何依靠技术帮助其国际化扩展，但传统的人工翻译以本地化客户网站既费时又昂贵。因此，我们构建了一个利用机器学习（ML）翻译能力与Amazon Translate相结合的解决方案，高效应对网站本地化挑战。

在本章中，像之前一样，我们将回到我们最喜欢的银行公司，LiveRight Holdings，并帮助他们通过自然语言处理（NLP）和聊天机器人解决一个独特的使用案例。但在我们讨论挑战和解决方案之前，先来谈谈将对话界面（即聊天机器人）与基于文本的文档搜索结合的理念（稍后会详细讲解）。记得我们曾说过，NLP 可以帮助揭示看似无关的文档中的模式，就像阿里巴巴洞中的宝藏一样（第一章，商业环境中的 NLP 与 AWS AI 服务简介——我们知道，感觉像是很久以前的事情了）？如果你有一个像《阿拉丁神灯》中的神灯精灵，根据你的问题提供所需的洞察，岂不是很酷？当我们将 NLP 和聊天机器人结合起来时，就像是让神灯精灵随时按需从阿里巴巴的宝藏洞中分发宝藏。如果你还记得，我们之前确实讨论过如何通过 NLP 创建智能搜索索引，但本章中我们将讨论的解决方案更进一步，使得搜索更加用户友好。为了学习如何构建一个查询文档的聊天机器人，我们将通过以下几个部分进行讲解：

• 介绍聊天机器人使用案例

• 创建一个以Amazon S3 为数据源的Amazon Kendra 索引

• 构建Amazon Lex 聊天机器人

• 使用AWS CloudFormation 部署解决方案

技术要求

本章中，您需要拥有一个AWS 账户。请确保按照第二章《介绍 Amazon Textract》部分中指定的技术要求，创建您的 AWS 账户，并登录到AWS 管理控制台。如果您需要了解如何将对象上传到 Amazon S3 桶中，请参考创建 Amazon S3 桶、文件夹以及上传对象部分。在尝试构建查询文档的聊天机器人步骤之前，请完成这些任务。

在本章中，我们将通过 AWS 管理控制台完成所有任务。GitHub 仓库提供了解决方案所需的输入文档和 FAQ 列表，您可以在此查看：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/tree/main/Chapter%2011。

请使用以下部分的指示来构建解决方案。

介绍聊天机器人用例

现在让我们讨论一下，使用具备自然语言处理（NLP）能力的聊天机器人如何为企业带来益处。通过举例说明总是有帮助的，因此我们回到我们虚构的银行公司LiveRight Holdings Private Limited。LiveRight 公司中的按揭产品研究（MPR）部门对按揭业务至关重要，因为他们的建议直接影响着 LiveRight 提供给客户的按揭产品、特性和选择。这对 LiveRight 的收入和盈利能力有直接影响，因为按揭产品占 LiveRight 年收入的 40%以上。MPR 团队每月都会逐步收到数百份研究文档，这些文档既来自基于订阅的行业分析师，也来自专业的独立研究员。通常，这些文档提供了关于买家在购买房屋时的需求、房地产经纪人的角色、房价对卖家的影响等方面的洞察、趋势报告和详细视角。这些文档被存储到一个 Amazon S3 桶中，该桶已经包含了成千上万的文档，并且还在增长。

MPR 团队的“日常生活”场景是阅读这些大量的文档，分析其内容，识别感兴趣的领域、趋势和指标，并对这些事实进行分类，最终，这些信息会在一天的集体会议活动中被团队共同收集和评估，与过去几个月的统计数据进行比较，最终将建议写下来并发送给高层管理人员，同时将这些信息输入机器学习模型以确定抵押贷款产品特征。文档通常在前一个月的月底或月初收到，团队需要整个月的时间来阅读、分析、分类、讨论并做出建议。LiveRight 的高层管理人员长期以来一直认为这一过程非常耗时且成本高昂，这种看法是正确的。作为一个以经济实用为荣的组织，他们希望通过自动化这一过程来节省时间并降低成本。在看到使用 AWS AI 服务中的 NLP 技术在其他用例中对他们的帮助后，他们联系了你，ML 企业架构师，寻求帮助重新设计这一流程并构建一个高效的解决方案。此外，高层管理人员希望能够利用 MPR 团队中非常有才华的研究人员进行新的创新，而不是让他们浪费时间在琐碎和重复的任务上。

你发现来自 LiveRight 的这个请求既具有挑战性又令人兴奋，因为它是一个完全为 NLP 和 AI 量身定制的用例。你立即决定，帮助 MPR 团队讨论并决定他们的建议的最佳方式是一个智能 AI 助手，它可以参与他们的会议——倾听他们的问题并为他们回答。在经过一些分析后，你决定使用 Amazon Lex（aws.amazon.com/lex/），这是一个完全托管的 AI 服务，通过机器学习模型来构建智能聊天机器人，能够进行语音和文本的互动，并具备持续学习的能力；以及 Amazon Kendra（aws.amazon.com/kendra/），这也是一个完全托管的机器学习驱动的企业搜索服务，利用 NLP 技术为你的文档创建智能索引，接受自然语言查询，并返回精确匹配上下文的响应。你查看了 Amazon Lex 定价（aws.amazon.com/lex/pricing/），发现对于美国东部（北弗吉尼亚）地区每月 8,000 个语音请求和 2,000 个文本请求与聊天机器人的交互，每月只需支付 33.50 美元。你再查看了 Amazon Kendra 定价（aws.amazon.com/kendra/pricing/），发现开发者版支持每天处理 10,000 个文档和 4,000 个查询，价格为每小时 1.125 美元或每月 810 美元。你决定在试点阶段使用开发者版，待用户验收后再升级到企业版。

注意

这些价格截至撰写时是正确的。请检查链接以获取最新数据。

现在您已经准备好构建解决方案了。如前所述，我们将完全使用 AWS 管理控制台(aws.amazon.com/console/)来步行这个解决方案。如果您没有访问 AWS 管理控制台，请按照本书第二章中介绍 Amazon Textract部分中技术要求部分的详细说明进行操作。

首先，在我们继续解决方案构建之前，让我们完成前提条件：

1. 从我们的 GitHub 存储库下载样本家庭买家研究文档。从您的本地计算机打开一个互联网浏览器（最好是Google Chrome 版本 9.1及以上），并访问github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/tree/main/Chapter%2011。

2. 逐个点击文档名称下载每个四个文档。

3. 在文档页面上，点击右侧的下载按钮将文档下载到您的计算机上。

4. 按照本书第二章中创建 Amazon S3 桶、文件夹和上传对象部分的说明，将这些下载的文档上传到 Amazon S3 桶。在创建桶中的 Amazon S3 文件夹时，请使用以下文件夹/前缀路径 – chapter11/kendra-faq/faqs.csv、chapter11/kendra/2019-NAR-HBS.pdf、chapter11/kendra/2020-generational-trends-report-03-05-2020.pdf、chapter11/kendra/ Zillow-home-buyers-report.pdf。

5. 现在，你已经准备好开始构建解决方案了。

在本节中，我们介绍了使用 NLP 的聊天机器人的需求以及与此解决方案相关的商业利益。在接下来的部分中，我们将逐步介绍解决方案的构建过程。

使用 Amazon S3 作为数据源创建 Amazon Kendra 索引

在本节中，我们将首先创建一个 Amazon Kendra 索引，并将我们在上一节中上传的样本研究文档的 S3 存储桶添加为 Amazon S3 数据源。

注意

在继续之前，请确保您已经执行了技术要求部分和介绍聊天机器人使用案例部分中提到的先决条件。

请执行以下步骤创建您的 Amazon Kendra 索引：

1. 如果尚未完成，请按照本书第二章中介绍 Amazon Textract部分中技术要求部分的详细说明登录到您的AWS 管理控制台。

2. 在页面顶部中央的服务搜索栏中输入kendra并从列表中选择Amazon Kendra。当Amazon Kendra控制台打开时，点击创建索引，如图所示：

   图 11.1 – 创建亚马逊 Kendra 索引

3. 在指定索引详细信息页面中，输入索引的名称，添加可选描述，从IAM 角色列表框中选择创建新角色（推荐），并输入角色名称，如下截图所示。然后点击下一步继续：

   图 11.2 – 指定索引详细信息

4. 在配置用户访问控制页面中保持默认选择，并点击下一步继续。

5. 在指定配置页面中，保持默认选择，指向开发者版，然后点击创建。亚马逊 Kendra 将开始创建索引的工作。可能需要大约 15 到 30 分钟，因此您可以在此期间享用一些零食和咖啡/茶。

6. 索引成功创建后，点击添加数据源按钮继续。

7. 在向 Amazon Kendra 索引添加数据源连接器页面中，向下滚动并点击添加连接器，位于选择数据源连接器类型下的Amazon S3卡片中。

8. 在指定数据源详细信息页面中，输入数据源名称并点击下一步。

9. 在chapter11/kendra中，点击添加按钮：

   图 11.3 – 配置同步设置

10. 现在，向下滚动页面，找到IAM 角色信息，在IAM 角色列表框中选择创建新角色（推荐）并输入您选择的角色名称。在同步运行计划信息中，选择按需运行作为频率。点击下一步继续。

    图 11.4 – 数据源同步设置 IAM 角色和运行计划

11. 审核您的输入并点击添加数据源。亚马逊 Kendra 将首先传播 IAM 角色，然后创建数据源。

12. 数据源创建后，点击立即同步按钮，开始为我们的文档建立索引，以便搜索。

13. 同步大约需要 30 分钟（时间可以用来休息）。完成后，您可以查看同步运行历史。

14. 现在，我们将向索引添加一些常见问题解答（FAQ），以便为搜索添加更多背景信息。从左侧窗格中的数据管理标题下选择常见问题解答选项，然后点击添加常见问题解答。

15. 在介绍聊天机器人使用案例部分的前提步骤中输入faqs.csv文件。在IAM 角色中，选择创建新角色（推荐）并输入您选择的角色名称。向下滚动并点击添加。

16. 亚马逊 Kendra 将开始 FAQ 任务，几分钟后应该完成。

我们现在已完成使用 Amazon Kendra 设置智能搜索所需的步骤。在下一部分，我们将构建创建 Amazon Lex 聊天机器人的步骤。

构建 Amazon Lex 聊天机器人

在本节中，我们将执行构建 Amazon Lex 聊天机器人的步骤，并使用内置的意图（这是机器人基于用户请求执行的任务）将我们的聊天机器人与前一节中创建的 Amazon Kendra 索引集成。请按以下步骤执行：

1. 在 AWS 管理控制台中，在页面顶部中央的服务搜索框中输入lex，并从列表中选择Amazon Lex以进入 Amazon Lex 控制台。在 Amazon Lex 控制台的左侧窗格中，点击切换到新的 Lex V2 控制台链接，如下图所示：

   图 11.5 – 切换到新的 Lex V2 控制台

2. 在 Lex V2 控制台页面上，点击右侧的创建机器人，如图所示：

   图 11.6 – 创建机器人

3. 在HomeBuyerResearch中，为Bot 名称，在IAM 权限部分，选择创建具有基本 Amazon Lex 权限的角色作为运行时角色。

   图 11.7 – 配置机器人设置

4. 向下滚动至5，并为空闲会话超时选择分钟数，然后点击页面右下角的下一步。

5. 在为机器人添加语言页面，保持选择语言为英语（美国），并在语音交互列表框中选择Joanna。点击页面右下角的完成。

6. 当机器人创建完成后，Amazon Lex 将自动添加一个名为NewIntent的意图来启动机器人构建过程。

   图 11.8 – Lex 添加的 "NewIntent"

7. 向下滚动到页面底部的新意图的发话内容，点击NewIntent，这是一个自定义意图（在构建机器人时是必需的），并通过提供一个在与机器人交互时不会使用的发话内容来使其不可解析。这样可以强制将解析转到我们的 Amazon Kendra 内置意图。

8. 向下滚动并点击页面右下角的保存意图。

9. 现在，让我们返回到意图列表。点击返回到意图列表，它位于Amazon Lex标题下的左上方。

10. 在意图页面上，点击右侧的添加意图，并选择使用内置意图，如下图所示：

    图 11.9 – 添加内置意图

11. 在列表框中的kendra中，选择AMAZON.KendraSearchIntent。

    图 11.10 – Amazon Kendra 为 Lex 提供的内置意图

12. 在ResearchBuyers中，以及在chapter11-houses-index中（如果你使用了书中提到的相同名称），点击添加。

13. 向下滚动到消息字段中的Here is what I found for your query:((x-amz-lex:kendra-search-response-answer-1))，点击保存意图。保存意图后，点击更多响应选项。

14. 在消息字段中的I found a FAQ question for you: ((x-amz-lex:kendra-search-response-question_answer-question-1)) and the answer is ((x-amz-lex:kendra-search-response-question_answer-answer-1))，点击更新响应。再次点击保存意图。图 11.11 – 添加文本消息组

    图 11.11 – 添加文本消息组

15. 现在，滚动到页面顶部，点击蓝色导航链接中的语言：英语（美国）。

16. 向下滚动并点击页面右下角的构建按钮。这大约需要几分钟时间，但不会超过。

17. 当机器人完全构建完成后，点击页面底部构建按钮旁边的测试按钮。

18. 在输入框中输入Who is a first-time buyer?，然后按Enter键。

19. 机器人使用我们添加到亚马逊 Kendra 索引中的文档中的答案进行响应：图 11.12 – 机器人响应查询，内容来自示例研究文档

    图 11.12 – 机器人响应查询，内容来自示例研究文档

20. 现在，滚动到页面顶部，点击蓝色导航链接中的版本。

21. 在版本页面，点击右侧的创建版本按钮。

22. 向下滚动到页面底部，点击创建按钮。

23. 新版本已成功为我们的机器人创建。记下创建的版本号，我们在接下来的步骤中将需要它。

24. 现在，在左侧面板中找到部署标题，点击别名，

25. 点击hbr-web-ui。向下滚动，选择在前一步创建的机器人版本，点击选择一个现有版本，然后点击页面右下角的创建按钮。

    注意

    如果你是第一次创建版本，请选择会显示给你的版本 1。

26. 创建别名后，请记下我们的机器人别名 ID。在下一节部署机器人时需要用到这个 ID。

27. 同时，点击页面顶部蓝色导航链接中的机器人名称，并记下你的机器人 ID——我们在部署时也需要这个。

这就是构建我们 Amazon Lex 聊天机器人的全部内容。在下一部分，我们将使用 AWS CloudFormation (aws.amazon.com/cloudformation/)，这是一项托管服务，允许我们将基础设施配置任务写成JSON或YAML模板代码，从而自动化我们在 AWS 上构建解决方案所需的资源部署。由 Oliver Atoa 和 Bob Strahan 撰写的 Amazon Lex 博客文章《为你的聊天机器人部署 Web 用户界面》提供了一个 AWS CloudFormation 模板示例，用于将 Amazon Lex 聊天机器人集成到网站中：aws.amazon.com/blogs/machine-learning/deploy-a-web-ui-for-your-chatbot/。

我们将使用此模板创建一个网站，并将聊天机器人嵌入为小部件。

使用 AWS CloudFormation 部署解决方案

在前面两个部分中，我们逐步展示了如何使用 Amazon Kendra 创建索引并将来自 Amazon S3 存储桶的文档作为数据源，以及如何构建 Amazon Lex 聊天机器人并通过内置意图将其与我们的 Amazon Kendra 索引集成。这完成了我们解决方案构建的大部分内容。在这一部分，我们将使用来自附带仓库的 AWS CloudFormation 模板示例，这个仓库是我们在上一部分中提到的博客文章：github.com/aws-samples/aws-lex-web-ui/tree/master/templates。

让我们开始吧：

1. 点击github.com/aws-samples/aws-lex-web-ui/tree/master/templates，并向下滚动到网页上的Launch部分，点击第一个Launch Stack按钮以启动CodeBuild 模式。

   图 11.13 – 启动 AWS CloudFormation 堆栈

2. 该操作将打开 AWS CloudFormation 服务，进入 AWS 管理控制台，并带你到创建堆栈页面。点击下一步。

3. 为堆栈名称和CodeBuildName输入一个你选择的名称，或者使用提供的示例。

4. 向下滚动到名为en_US的部分。

   图 11.14 – 创建堆栈，Lex V2 机器人配置参数

5. 向下滚动到true。这将强制用户注册Amazon Cognito (aws.amazon.com/cognito/)，这是一个完全托管的用户身份验证和授权服务，适用于 Web 和移动应用程序。注册后，用户可以使用他们的凭证登录网站以访问聊天机器人。

6. 向下滚动一点，提供一个CognitoIdentityPoolName的名称。

7. 滚动到You can ask me questions on home buyers. For example – what is important for home buyers?，该内容位于Say 'what is important for home buyers' to get started的WebAppConfBotInitialSpeech字段中。当点击麦克风图标时，机器人会通过语音提示用户这一信息。

8. 向下滚动一点，找到ResearchHomeBuyers。然后，点击下一步。

9. 在此页面上，保持默认设置不变，点击页面底部的下一步。

10. 向下滚动到功能部分，选择两个复选框以确认创建 IAM 资源，并且可能需要自动扩展的能力。点击创建堆栈。

11. 创建我们所需的所有资源可能需要大约 15 分钟。有关将要创建的资源的详细信息，请参阅以下链接：github.com/aws-samples/aws-lex-web-ui/blob/master/templates/README.md#cloudformation-resources。

12. 当 CloudFormation 堆栈的状态更改为Create_Complete时，我们所需的资源已经配置完毕。在启动我们的网站之前，我们需要对父网站进行修改，以确保它发送正确的语言表达给我们的聊天机器人。点击您的 CloudFormation 堆栈的输出标签，查看已配置资源的列表。复制名为WebAppBucket的键的值。这是用于托管您网站的 Amazon S3 存储桶的名称：

    图 11.15 – 托管我们网站的 S3 存储桶

13. 现在，进入您的S3，并从列表中点击parent.html。

14. 在parent.html中，点击parent.html并将其下载到您的计算机：

    图 11.16 – 下载 parent.html

15. 在您喜欢的文本编辑器中打开parent.html，并将 panel-heading 标签的值更改为Send "what is important for buyers" utterance to iframe，如以下截图所示。要找到该条目，请搜索Buy Flowers。

    图 11.17 – 更改 parent.html 中的 panel-heading 标签

16. 继续搜索Buy Flowers，并将sendUtterance函数的参数更改为'what is important for buyers?'，如以下截图所示：

    图 11.18 – 更改发送语言表达函数输入

17. 现在，返回您的 Amazon S3 控制台，打开parent.html，点击上传，然后点击添加文件。

18. 从您的本地计算机选择修改后的parent.html，向下滚动并点击上传。

19. CloudFormation 堆栈配置的资源之一是 CloudFront 分发。点击 CloudFront，在列表中点击 CloudFront 以进入 Amazon CloudFront 控制台：

    图 11.19 – 导航至 Amazon CloudFront 控制台

20. 在 CloudFront 分发 页面中，检查 Origin 字段。您应该能在此看到一个条目，它的名称与您从 CloudFormation 堆栈的 Outputs 选项卡中复制的 WebAppBucket 值匹配。点击此条目的 ID。

21. 在 CloudFront 分发的详细信息页面中，点击 Invalidations 选项卡以打开它。然后，点击 创建无效化 按钮。

    图 11.20 – 为 CloudFront 分发创建无效化

22. 在 Object Paths 字段中的 / 处点击 无效化，如下截图所示。这个过程大约需要 5 分钟左右：

    图 11.21 – 无效化 CloudFront 分发

23. 无效化完成后，返回 Amazon CloudFormation 控制台中的堆栈 Outputs 选项卡，点击 ParentPageUrl 值：

    图 11.22 – 点击 ParentPageUrl 值

24. 这将启动您配置的网站，并展示您的聊天机器人。但在使用聊天机器人之前，Amazon Cognito 会强制您登录到网站，如下所示。如果这是您第一次访问该网站，请点击 注册 按钮并按照提示进行注册：

    图 11.23 – 注册或登录到您的网站

25. 注册过程完成后，您将收到一封包含验证码的邮件。输入验证码即可登录：

    图 11.24 – 输入验证码

26. 登录后，您的网站及其作为小部件的聊天机器人将显示出来。点击 发送 按钮将第一次输入的语句发送给机器人。您可以输入后续问题：

    图 11.25 – 与嵌入在主网站中的 Amazon Lex 聊天机器人小部件进行文本交互

27. 点击聊天小部件中的麦克风按钮与机器人对话。机器人会用语音回应，如下图所示。接受浏览器的通知，允许它使用麦克风继续操作。

图 11.26 – 与您的聊天机器人进行语音交互

这就完成了本章的解决方案构建。请随时尝试这个解决方案并给我们反馈。你可以根据自己的需求轻松地定制我们在本章中构建的内容。有关如何利用 Amazon Kendra 和 Amazon Lex 满足你需求的更多想法，请参考进一步阅读部分。

总结

在本章中，我们使用 Amazon Kendra 构建了一个解决方案，用于自动搜索并从文档语料库中提取洞察，无需手动阅读文档、理解上下文、解释含义、识别跨文档与共同主题相关的内容等等。我们还展示了如何使用 Amazon Lex 设置一个智能的基于 AI 的聊天助手，该助手隐式集成了 Amazon Kendra 的智能搜索功能，提供了一个无缝的聊天和语音界面，用于（字面上）“与文档对话”。最后，我们使用 AWS CloudFormation 的最佳实践方法将我们的聊天机器人部署到父网站作为嵌入式小部件，并通过 Amazon CloudFront 内容分发网络进行了分发。

有趣的是，NLP 在医学领域有着多种应用，正如我们在下一章中将看到的那样，在那里我们将回顾 NLP 和 AI 技术如何帮助转变现代医疗索赔处理。我们将从讨论如何自动从医疗接收表单中提取数据开始，如何使用Amazon Comprehend Medical (aws.amazon.com/comprehend/medical/)理解临床数据，以及如何为医疗索赔的裁定设置无服务器的实时管道。如之前所述，我们将介绍使用案例，讨论如何设计架构，建立前提条件，并详细讲解构建解决方案所需的各种步骤。

进一步阅读

• 通过 Amazon Kendra 增强企业搜索，作者：Leonardo Gomez：aws.amazon.com/blogs/machine-learning/enhancing-enterprise-search-with-amazon-kendra/

• Citibot 的聊天机器人搜索引擎如何利用 AI 找到更多答案，作者：Francisco Zamora、Bratton Riley 和 Nicholas Burden：aws.amazon.com/blogs/machine-learning/how-citibots-chatbot-search-engine-uses-ai-to-find-more-answers/

• 使用 Amazon Connect、Amazon Lex、Amazon Kendra 以及开源 QnABot 项目构建全渠道问答聊天机器人，作者：Bob Strahan 和 Michael Widell：aws.amazon.com/blogs/machine-learning/building-a-multi-channel-qa-chatbot-with-amazon-connect-amazon-lex-amazon-kendra-and-the-open-source-qnabot-project/?nc1=b_rp

第十二章：第十二章：医疗行业中的 AI 和 NLP

在上一章中，我们讨论了如何使用 AWS AI 服务，通过Amazon Lex和Amazon Kendra为您的文档工作流设置聊天机器人。在这一章中，我们将讨论Amazon Textract和Amazon Comprehend Medical如何帮助数字化医疗索赔。我们将讨论医疗行业的索赔处理系统，以及为什么自动化医疗索赔如此重要。接着，我们将引导您如何使用 Amazon Textract 将这些纸质索赔数字化，并使用后处理进行验证。然后，我们将展示如何使用 Amazon Comprehend Medical API 从这些索赔中提取 NLP 洞察，例如判断个人是否患有糖尿病。

对于无效的索赔，我们将向您展示如何轻松设置通知，以提醒提交索赔的人重新提交正确数据，如邮政编码或索赔 ID。最后，我们将向您展示一些架构模式，帮助您使用 AWS Lambda 函数自动化所有流程。通过这种方式，您将创建一个端到端的无服务器解决方案，从而缩短索赔处理工作流的市场时间。这是因为您无需设置和管理服务器，也无需扩展以处理数百万个此类索赔。

本章将涵盖以下主题：

• 介绍自动化索赔处理的使用案例

• 理解如何从医疗入院表单中提取和验证数据

• 理解使用 Amazon Comprehend Medical 的临床数据

• 理解无效医疗表单处理及通知

• 理解如何为医疗索赔创建无服务器管道

技术要求

本章需要您访问一个 AWS 账户：

• 请确保按照第二章中的技术要求部分的说明，创建您的 AWS 账户。

• 在尝试提高文档处理工作流准确性部分的步骤之前，请登录 AWS 管理控制台。

我们解决方案的 Python 代码和示例数据集可以在github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/tree/main/Chapter%2012找到。请使用以下章节中的说明，并结合前面仓库中的代码来构建解决方案。

查看以下视频，了解代码的实际应用：bit.ly/3GrClSK。

介绍自动化索赔处理的使用案例

根据2018 CAHQ 指数报告（www.caqh.org/sites/default/files/explorations/index/report/2018-index-report.pdf），2018 年，医疗行业共提交了约 61 亿个医疗理赔，预计这一数字在未来几年将继续增长。

医疗支付公司不断寻找高效且具有成本效益的方式，以可扩展的方式处理如此大量的理赔。由于当前理赔处理的手工流程，处理这些理赔需要花费大量时间。因此，医疗公司正在寻找使用 AI 和机器学习方法来自动化和数字化这些理赔。一旦他们能够将这些理赔数字化，就能够轻松推动一些洞察力，比如改善整体人群健康。此外，分析这些理赔文件可能有助于你发现一些行为，帮助预防某些医疗状况的发生。同时，医疗支付方也在寻找符合法规的解决方案，如HIPAA 合规。对于美国以外的朋友，HIPAA 是美国医疗行业特定的合规法律。

现在，我们理解了为什么自动化理赔如此重要。接下来，我们将讨论如何帮助你使用 AWS AI 服务，如 Amazon Textract，来自动化这一流程，数字化理赔处理。你可以通过从这些扫描的理赔文件中提取文本，并使用自然语言处理（NLP）和 Amazon Comprehend Medical 来验证它们，从中获取一些患者健康洞察。

在这个用例中，我们的虚构公司LiveRight Holdings Private Limited与一家名为AwakenLife的医疗保险提供商合作，处理由他们的保险持有人提交的理赔。这些理赔大多数是扫描图像，他们的大部分时间和精力都花费在处理这些理赔上，因为其中一些是无效的。这给组织带来了损失。由于 LiveRight 公司已经在前几章中使用了 Amazon Textract 来自动化、数字化并进一步创新他们的文档处理工作流，他们推荐使用AwakenLife，这样他们就可以利用一些 AWS AI 服务来改善和自动化他们的整体理赔流程。在本章中，我们将设置一个简单的基于 AI 的工作流来验证 AwakenLife 的理赔，从而进一步减少他们的整体处理时间。

这个解决方案具有高度的成本效益和可扩展性，因为这些服务是无服务器的，并且可以根据你的需求扩展来处理文档。在本章中，我们将向你展示以下架构：

图 12.1 – 用于笔记本的医疗理赔处理架构

在前面的图表中，我们可以看到以下内容：

• 您的医疗接待表单可以是图像或 PDF 格式，并且会被发送到 Amazon Textract 进行数字化或文本提取。

• Amazon Textract 从这些高度非结构化的医疗接待文档中提取文本。

• 您必须对 Amazon Textract 的响应进行 后处理，以验证索赔。对于本博客，我们使用邮政编码和索赔 ID 来确保索赔的有效性。您可以根据您的业务案例自定义这些验证规则。

• 一旦邮政编码和索赔 ID 被验证，合法的数据将被发送到 Amazon Comprehend Medical，以获得关于患者程序等的洞察和实体。

• 如果邮政编码和索赔 ID 无效，将向相关人员发送电子邮件，通知他们这是一个无效的索赔。

我们将使用 Jupyter 笔记本来演示之前的架构。一旦完成这部分内容，我们将介绍如何使用基于事件的 Lambda 函数自动化实现该架构。

在下一部分中，我们将讨论如何使用 Amazon Textract 从医疗接待表单中提取数据。

理解如何从医疗接待表单中提取和验证数据

在这一部分中，我们将展示如何使用 Amazon Textract 从医疗接待表单中提取关键值对或表单数据。然后，通过简单的逻辑，您将验证提取的值是否有效或无效。

如果您在之前的章节中没有这样做，您需要创建一个 Amazon SageMaker Jupyter 笔记本，并设置 Chapter 12 文件夹，打开 ch 12 automating claims processing.ipynb 笔记本。

注意：

确保笔记本中的 IAM 角色具备 AmazonSNSFullAccess、AmazonComprehendMedicalFullAccess 和 AmazonTextractFullAccess 权限。

现在，使用这个笔记本，我们将学习如何使用 Textract API 提取数据，并通过一个示例医疗接待表单使用一些后处理逻辑进行验证：

1. 我们将使用以下示例医疗接待表单开始。运行以下代码块加载示例医疗表单，这是一份有效的索赔医疗表单：

   documentName = "validmedicalform.png"
   display(Image(filename=documentName))
   

   您将看到以下医疗接待表单已经加载：

   

   def calltextract(documentName): 
       client = boto3.client(service_name='textract',
            region_name= 'us-east-1',
            endpoint_url='https://textract.us-east-1.amazonaws.com')
       with open(documentName, 'rb') as file:
               img_test = file.read()
               bytes_test = bytearray(img_test)
               print('Image loaded', documentName)
       response = client.analyze_document(Document={'Bytes': bytes_test}, FeatureTypes=['FORMS'])
                  return response
   

2. 至此，我们已经定义了一个 Textract 函数。现在，我们将通过传递扫描的医疗接待表单来调用此函数，并获取 Textract 响应。运行以下单元格：

   response= calltextract(documentName)
   print(response)
   

   如果 Textract 的响应成功，您将收到以下消息，并附有提取数据的 JSON 响应：

   

   图 12.3 – 医疗表单的 Textract JSON 响应

   前面的响应包含了大量信息，例如几何、页面以及文档元数据中的文本。

3. 现在，我们将创建一个函数来解析从此 JSON 响应中提取的表单数据或键值文本响应。我们使用 Textract 解析器来解析此 JSON 响应。在这里，我们创建了一个方法，它接受一个 JSON 响应并使用 Textract 解析器解析表单键值并返回键值对：

   from trp import Document
   def getformkeyvalue(response):
       doc = Document(response)
       key_map = {}
       for page in doc.pages:
           # Print fields
           for field in page.form.fields:
               if field is None or field.key is None or field.value is None:
                   continue
               key_map[field.key.text] = field.value.text
       return key_map
   

4. 现在，我们将把 Textract 的 JSON 响应传递给def getformkeyvalue(response)方法，以从 Textract JSON 响应中获取键值对或表单数据：

   get_form_keys = getformkeyvalue(response)
   print(get_form_keys)
   

   你将得到如下输出：

   

   ](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_12_04.jpg)

   图 12.4 – 从 JSON 响应解析的 Textract 表单数据

   所有表单项都作为键值对提取。

5. 现在，我们将使用一些定义好的业务规则检查这些键值对或表单项是否有效。对于本书来说，我们通过有效的邮政编码和索赔 ID 来检查表单的有效性。你也可以根据自己的业务需求修改验证代码。我们创建了一个方法，它接受键值对并检查从 Textract 提取的邮政编码或 ID 号码信息是否有效。如果有效，它将返回所需的 ID，如果无效，它将返回一条消息，说明索赔 ID 和邮政编码无效：

   def validate(body):
       json_acceptable_string = body.replace("'", "\"")
       json_data = json.loads(json_acceptable_string)
       print(json_data)
       zip = json_data['ZIP CODE']
       id = json_data['ID NUMBER']
       if(not zip.strip().isdigit()):
           return False, id, "Zip code invalid"
       length = len(id.strip())
       if(length != 12):
           return False, id, "Invalid claim Id"
       return True, id, "Ok"
   

6. 现在，我们将通过发送从getformdata(response)方法提取的键值对来测试这种验证方法是否适用于有效的医疗表单：

   textract_json= json.dumps(get_form_keys,indent=2)
   res, formid, result = validate(textract_json)
   print(result)
   print(formid)
   

7. 由于这是有效的索赔，邮政编码和索赔 ID 都是有效的，因此此方法返回有效的响应（有效的响应）：

](https://github.com/OpenDocCN/freelearn-dl-pt7-zh/raw/master/docs/nlp-aws-ai-svc/img/B17528_12_05.jpg)

图 12.5 – 有效的索赔响应

正如你所看到的，我们得到了一个Ok响应，并附带有效的索赔 ID。

现在，回到架构，有两种情况可能发生：

• 如果表单有效或此方法的响应是Ok，我们将把这些数据发送到 Comprehend Medical 以获得洞察，这将在下一节中讲解。

• 如果表单无效，我们将使用 Amazon Simple Notification Service（SNS）通知客户，该服务用于发送电子邮件或电话通知。我们将在最后一节中讨论这个内容，理解如何为医疗索赔创建无服务器管道。

在本节中，我们介绍了如何使用 Amazon Textract Analyze Document API 从医疗接收表单中提取表单值。我们还讨论了如何验证 Textract 响应。

由于响应对于医疗接收表单有效，在下一节中，我们将向你展示如何使用 Amazon Comprehend Medical 提取医疗洞察。

使用 Amazon Comprehend Medical 理解临床数据

在本节中，我们将讨论如何使用Amazon Comprehend Medical从有效的医疗接收表单中获取洞察。我们在第三章中介绍了 Amazon Comprehend 的功能，介绍 Amazon Comprehend。在本章中，我们将学习如何使用 Amazon Comprehend Medical Entity API 提取诸如患者诊断和个人健康信息（PHI）数据类型，如申诉 ID等医疗接收表单中的实体。让我们开始吧：

1. 回到您的笔记本并运行以下单元格，使用 Comprehend Medical boto3 API：

   comprehend = boto3.client(service_name='comprehendmedical')
   

2. 现在，我们将使用comprehend.detect_entities_v2 API (docs.aws.amazon.com/comprehend/latest/dg/API_medical_DetectEntitiesV2.html) 来分析来自医疗接收表单的临床文本数据，并返回与医疗文本相关的实体，如类型或诊断。运行以下单元格查看我们从有效医疗接收表单中提取的实体：

   cm_json_data =  comprehend.detect_entities_v2(Text=textract_json)
   print("\nMedical Entities\n========")
   for entity in cm_json_data["Entities"]:
       print("- {}".format(entity["Text"]))
       print ("   Type: {}".format(entity["Type"]))
       print ("   Category: {}".format(entity["Category"]))
       if(entity["Traits"]):
           print("   Traits:")
           for trait in entity["Traits"]:
               print ("    - {}".format(trait["Name"]))
       print("\n")
   

   您将使用此 API 获得以下医疗洞察：

   

   图 12.6 – 医疗实体

   它能够将电话号码和医疗 ID 识别为个人健康信息（PHI）。如果您有合规要求，您可以轻松地屏蔽或删除这些实体类型，因为它们已经被该 API 正确识别。

3. 现在我们已经提取了实体，我们将把这些提取的数据保存在 Amazon S3 中的 CSV 文件里。对于大规模的医疗接收表单处理，您会希望将所有这些洞察保存在 CSV 文件中，放入 S3 桶中，并使用分析服务进行分析，如我们在第八章中介绍的，利用 NLP 将您的媒体内容货币化。我们已经创建了一个函数，该函数接受 Comprehend Medical 的响应和来自医疗接收表单的验证 ID，并将其保存到 Amazon S3 中。运行以下代码：

   def printtocsv(cm_json_data,formid):       
           entities = cm_json_data['Entities']
           with open(TEMP_FILE, 'w') as csvfile: # 'w' will truncate the file
               filewriter = csv.writer(csvfile, delimiter=',',
                               quotechar='|', quoting=csv.QUOTE_MINIMAL)
               filewriter.writerow([ 'ID','Category', 'Type', 'Text'])
               for entity in entities:
                   filewriter.writerow([formid, entity['Category'], entity['Type'], entity['Text']])
   filename = "procedureresult/" + formid + ".csv"
    S3Uploader.upload(TEMP_FILE, 's3://{}/{}'.format(bucket, prefix))
   

4. 现在，我们将通过传递 Comprehend Medical Entity API 的 JSON 响应和来自验证逻辑的formid，调用printtocsv(cm_json_data,formid)方法：

   printtocsv(cm_json_data,formid)
   

   您将获得以下响应：

   "successfully parsed:procedureresult/a-184054-6661.csv"
   

在本节中，我们介绍了如何使用 Amazon Comprehend Medical API 提取来自 Amazon Textract 的有效申诉中的医疗洞察或实体。在下一节中，我们将使用 Amazon Textract 提取一个无效申诉表单的数据，并对这些数据进行后处理以检查其有效性。如果无效，我们将向您展示如何设置 SNS，通过电子邮件通知相关方。

了解无效医疗表单处理及通知

在本节中，我们将讲解当 Textract 后处理识别为无效时，如何按照图 12.1中指定的架构进行操作。我们将通过 Amazon SNS 向相关方发送消息。现在让我们回到笔记本：

1. 在笔记本中，我们将通过运行以下代码开始加载扫描的医疗入院表单：

   InvalidDocument = "invalidmedicalform.png"
   display(Image(filename=InvalidDocument))
   

   你将得到以下示例医疗表单，我们将检查其中的无效用例：

   

   图 12.7 – 医疗入院无效索赔表单

   在此表单中，邮政编码和身份证号码输入错误。

2. 现在，我们将调用之前章节中创建的calltextract(document)函数，并传入该文档以使用 Amazon Textract Sync API 提取文本或数据。为此，请运行以下代码：

   response = calltextract(InvalidDocument)
   

3. 在此之后，我们将调用在前面章节中定义的getformdata(response)方法，该方法以 Textract 的响应作为输入，并返回表单的键值数据：

   get_form_keys = getformkeyvalue(response)
   print(get_form_keys)
   

   你将得到以下输出：

   

   图 12.8 – 使用 Textract 提取的表单数据

   在这里，我们获取了所有的键值对或表单数据。

4. 现在，我们将通过将提取的键值对，如邮政编码和身份证号码，作为输入传递给前面章节中定义的validate(body)方法来检查其有效性。如果内容有效，该方法返回 true；如果提交的邮政编码和身份证号码无效，则返回 false：

   textract_json= json.dumps(get_form_keys,indent=2)
   res, formid, result = validate(textract_json)
   print(result)
   print(formid)
   print(res)
   

   你将得到以下响应：

   

   图 12.9 – 无效索赔响应

   有效的方法返回一个无效的索赔和false，以及无效的索赔 ID。

5. 现在，我们想通知用户此索赔无效。为此，我们将引导你如何通过 Amazon SNS 控制台设置Amazon SNS。请访问此链接创建一个主题，在该主题中发布无效消息：console.aws.amazon.com/sns/v3/home?region=us-east-1#/create-topic。

6. 对于invalid-claims-notify，如以下截图所示：

   图 12.10 – 在 SNS AWS 控制台创建主题

   确保选择标准主题类型。

7. 向下滚动并点击创建主题按钮。

8. 创建主题后，我们必须添加订阅者或将要订阅此主题以接收通知的人，方法是访问console.aws.amazon.com/sns/v3/home?region=us-east-1#/create-subscription。

9. 从下拉菜单中选择你的主题 ARN，设置协议为电子邮件，并在终端框中输入你的电子邮件 ID，如以下截图所示：

   图 12.11 – 通过电子邮件订阅主题

   向下滚动并点击创建订阅。

10. 一封电子邮件将发送到你刚刚用于订阅的地址。请检查你的邮箱或垃圾邮件，查看来自 SNS 的电子邮件，邮件主题为 AWS 通知 - 订阅确认，点击 确认订阅。

    注意：

    确认订阅非常重要，否则你将无法收到通知。

11. 现在，返回 console.aws.amazon.com/sns/v3/home?region=us-east-1#/topics 复制 invalid-claims-notify：

    图 12.12 – 从 AWS 控制台复制主题的 ARN

12. 复制此 ARN 后，返回到笔记本，并将其粘贴到以下笔记本单元格中，以加载 SNS boto3 客户端。在这里，输入一个主题：

    sns = boto3.client('sns')
    topicARN="<Enter your topic arn>"
    

13. 现在，我们将把无效信息转换为负载，并发布到此主题：

    snsbody = "Content:" + str(textract_json) + "Reason:" + str(result)
    print(snsbody)
    

14. 接下来，我们将使用 sns.publish Python boto3 API (boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns.html#SNS.Client.publish)，将无效电子邮件信息发送到已注册的电子邮件地址：

    try:
        response = sns.publish(
                        TargetArn = topicARN,
                        Message= snsbody
        )
        print(response)
    except Exception as e:
            print("Failed while doing validation")
            print(e.message)
    

    你将收到如下响应：

    

    图 12.13 – 将无效索赔信息推送到主题

15. 检查你订阅时使用的电子邮件地址，查看是否有通知无效医疗索赔的电子邮件：

图 12.14 – 发送的电子邮件通知

你可以随时选择退出你创建的主题。

在本节中，我们讲解了如何使用 Amazon Textract 处理医疗索赔，检查无效医疗索赔，并通知相关方。接下来，我们将学习如何为医疗索赔创建一个无服务器管道。

理解如何为医疗索赔创建无服务器管道

在前面的章节中，我们通过使用 Amazon Textract Sync API、Amazon Comprehend Medical Detect Entities Sync API 和 Amazon SNS 发送无效索赔，讲解了架构的构建模块。我们为此工作流定义了函数，并调用了文本提取和验证函数，展示了有效和无效医疗索赔表单的用例或工作流。这些函数可以移入 Lambda 代码中，并与 S3 事件通知 一起被触发，用于创建一个可扩展的医疗索赔处理管道。我们可以通过以下架构来实现：

图 12.15 – 使用 AWS Lambda 自动化扩展架构

我们通过一个 Jupyter 笔记本，展示了使用单一接收表单处理医疗理赔的各个代码组件。我们创建了 Python 函数来提取数据、验证数据、收集洞察，并将这些洞察转换为 CSV 文件。为了处理数百万这样的文档，我们将学习如何将代码函数转换为 AWS Lambda 函数，利用前面的架构图创建一个端到端的自动化无服务器架构。我们将使用的医疗理赔表单已由AwakenLife Ltd的付款方上传到 Amazon S3 存储桶：

• Amazon S3 声明上传会触发一个 Amazon S3 事件通知，进而触发 lambda 函数。

• 在这个 lambda 中，你可以调用我们在理解如何从医疗接收表单中提取和验证数据部分定义的textract函数，并通过传递该图像作为输入来调用 Amazon Textract。

• 你会收到一个文本响应。这些提取的文本可以被发送到我们在前一节中定义的validation函数。

• 对于有效的理赔，验证过的数据将发送到 Amazon Comprehend Medical 以提取洞察。提取的洞察将被返回给 AWS Lambda。

• 你可以将我们在使用 Amazon Comprehend Medical 理解临床数据部分定义的printtocsv（cm_json_data，formid）函数代码移到这个 lambda 函数中，将提取的洞察转换为 CSV 文件，并将其保存到 Amazon S3。

• 对于无效的理赔，你可以使用 SNS 通知相关方。

我们可以通过几行代码，在大规模处理医疗理赔文档时使用扩展性和流程化的方式。这种架构可以快速实现自动化，并以CloudFormation 模板的形式进行部署，从而让你能够设置基础设施即代码（IaC）。如果你有兴趣，我们已经在进一步阅读部分提供了一个类似的可扩展实现，以博客的形式呈现。

在本节中，我们讲解了如何使用我们在前面各节中定义的代码，并将其移至 AWS Lambda 部分，以构建一个使用逐步架构的端到端自动化工作流。现在，让我们总结一下这一章。

总结

在本章中，我们介绍了医疗理赔处理的使用案例。然后，我们讨论了如何使用 AWS AI 服务，如 Amazon Textract 来从这些扫描的医疗表单中提取表单数据。接着，我们讨论了如何根据您的业务规则对提取的文本进行一些后处理，以验证其表单数据。一旦表单数据经过验证，我们向您展示了如何使用 Amazon Comprehend Medical 来提取医疗见解，正如在第三章，介绍 Amazon Comprehend中所涵盖的那样。一旦您获得了医疗见解，这些数据可以转换为 CSV 文件并保存在 Amazon S3 中。完成这些步骤后，您可以使用Amazon Athena或Amazon QuickSight来分析这些数据以进行人口健康分析。我们还讨论了如何通过显示如何快速通过 AWS 控制台配置 Amazon SNS 并添加订阅者来处理无效理赔。您可以通过电子邮件通知您的订阅者提交的无效医疗索赔。

最后，我们向您展示了如何使用 AWS Lambda 架构一个无服务器可扩展解决方案，以调用这些 Textract Sync 和 Amazon Comprehend Medical Sync API。这确保了您在 Amazon S3 中上传的理赔文档具有端到端的自动化工作架构。

在下一章中，我们将介绍如何使用Amazon 增强 AI和人工协作流程来提高现有文档处理工作流程的准确性。我们还将深入探讨为什么需要人工协作流程以及如何帮助提高现有 AI 预测准确性的方面。

进一步阅读

要了解本章涵盖的主题的更多信息，请查看以下资源：

• 使用 Amazon Textract 和 Amazon Comprehend Medical 自动化理赔审批工作流，作者为 Sonali Sahu 和 Ujjwal Ratan（aws.amazon.com/blogs/industries/automating-claims-adjudication-workflows-using-amazon-textract-and-amazon-comprehend-medical/）

第三部分：提高生产中的 NLP 模型

在本节中，我们将深入探讨如何在文档处理工作流中为不同目的包含人工环节的策略，并介绍如何根据企业流量最佳地自动扩展你的 NLP 推理。

本节包括以下章节：

• 第十三章，提高文档处理工作流的准确性

• 第十四章，审计命名实体识别工作流

• 第十五章，对文档进行分类并为主动学习设置人工环节

• 第十六章，提高 PDF 批处理的准确性

• 第十七章，从手写内容中可视化洞察

• 第十八章，构建安全、可靠和高效的 NLP 解决方案

第十三章：第十三章：改善文档处理工作流的准确性

在上一章中，我们讨论了 AWS AI 服务，如Amazon Textract和Amazon Comprehend Medical，如何帮助快速自动化医疗工作流。在本章中，我们将讨论为什么在文档处理工作流中需要引入人工干预，并且如何通过设置人类环节（HITL）流程和Amazon 增强型 AI（Amazon A2I）来提高现有文档处理工作流的准确性，尤其是在使用Amazon Textract时。

Amazon A2I 是一种托管服务，它使构建需要人工审阅机器学习（ML）预测的工作流变得简单。在本章中，我们将讨论以下主题：

• 设置 HITL 流程在文档处理中的必要性

• 了解使用 Amazon A2I 实现 HITL 工作流的好处

• 在您的文档处理管道中添加人工审阅

技术要求

本章需要您拥有一个AWS 账户。请确保按照第二章**《介绍 Amazon Textract》中指定的技术要求部分中的说明创建您的 AWS 账户，并在尝试进行改善文档处理工作流的准确性的步骤之前，先登录到AWS 管理控制台。

我们解决方案的Python代码和示例数据集可以在以下链接找到：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/tree/main/Chapter%2013。

查看以下视频，观看代码演示：bit.ly/3jBxBQq。

请按照以下各节中的说明，并结合代码库中的代码来构建解决方案。

设置 HITL 流程在文档处理中的必要性

在前几章中，我们已经讨论了如何使用 Amazon Textract 和 Amazon Comprehend 自动化现有的文档处理工作流，借助 AWS AI 服务。我们涵盖了一些关键应用场景，如使用 Comprehend 分析 SEC 备案报告，使用 Textract 从任何文档中提取文本或快速数字化任何文档。我们还谈到了这些 AI 服务如何为每个预测的文本、单词、行或实体提供置信度分数。现在，客户常常问的问题是如何改进这些预测，并确保它们的准确性。在大多数 AI 系统中，要么是 AI 完成自动化过程，要么只是人工或手动流程。

理想的场景是人类与 AI 协同工作，以便由人类审查这些 AI 系统预测的结果，确保其高度准确。这适用于我们在文档处理工作流中处理高度关键性信息的场景，例如处理贷款申请、发票处理、抵押贷款处理或法律文档审核等。在所有这些场景中，您都希望有人类来验证或审查机器学习或 AI 系统预测的贷款金额或发票金额是否准确，因为如果不准确，一个零可能改变您的生活！这可能导致公司损失数百万。此外，在低置信度预测的情况下，您还希望让人类审查员检查 AI 预测的信息。例如，在索赔处理的情况下，如果您的机器学习系统预测索赔的置信度较低，您会希望根据人工审核来决定是拒绝还是批准该索赔。人类与 AI/ML 的协同工作有助于建立对该过程的信任，同时也减少了整体文档处理解决方案的上市时间。

本节我们讲解了为何需要在现有文档处理工作流中设置人类审核循环——也就是，它有助于提高准确性并与 AI 系统建立信任。在下一节中，我们将讨论在设置 HITL 工作流时使用 Amazon A2I 的一些关键好处。

看到使用 Amazon A2I 进行 HITL 工作流的好处

Amazon A2I 是一项托管服务，使构建和管理与任何机器学习应用相关的人类审查变得更加简单。它直接与 Amazon Textract 和 Amazon Rekognition 集成，以设置适用于内容审核或文档处理等用例的人类工作流。您还可以使用任何 Sagemaker 模型创建自定义工作流。使用 Amazon A2I 的一些好处如下：

• 它提供了 70 多个 UI 模板，帮助您快速入门，设置人类审查的用户界面。请查看这里：github.com/aws-samples/amazon-a2i-sample-task-uis。

• 它缩短了 AI 系统的上市时间，因为您知道有人工审核作为后盾来捕捉低置信度评分。

• 它为您提供了选择劳动力的选项。我们所说的 劳动力，是指谁将审查创建的人类循环任务。A2I 提供了三种选择——私有劳动力、Amazon Mechanical Turk 和第三方供应商。Amazon Mechanical Turk 是一个全球分布的劳动力选项，供您使用。如果您有敏感数据，可以选择将自己的员工加入并使用私有劳动力选项。在本章中，我们将展示如何创建私有劳动力并在 Amazon A2I 中使用它。

我们已经讨论了一些好处，现在让我们深入了解 Amazon A2I 如何与任何 AWS AI 服务、您的自定义模型或通过 Sagemaker 部署的模型协同工作，下面是相关架构：

图 13.1 – Amazon A2I 架构

让我们通过逐步分析每个步骤来理解图示：

1. 您的客户端应用程序将数据或文档发送到您的 AWS AI 服务或任何自定义模型。

2. AWS AI 服务，例如 Amazon Textract，或任何自定义机器学习模型，会进行预测。

3. 您可以与 ML 模型一起创建标准或阈值条件，以触发 Amazon A2I 的人工流程。在之前的架构中，阈值是高置信度预测，结果会立即返回给客户端应用程序。此阈值可以根据您的业务需求和用例进行设置，例如，检测到 99% 及以上的发票金额可以视为高置信度，因为它是高度关键的，要求非常准确。在提取某些实体（例如地点）时，您可以将 90% 视为高置信度水平，低于该水平时触发人工审核流程。

4. 低置信度预测，即低于您定义的阈值的预测，可以发送进行人工审核，人工审核者或您的工作人员将在由 Amazon A2I 管理的用户界面（UI）中查看。低置信度数据将在该 UI 中展示给人工审核者，他们将对低置信度预测进行审查，并进行增强、修正或验证。

5. 人工审核结果会保存在 Amazon S3 中，包含 AI 的预测结果以及人工修改或增强的部分。此数据可以视为真实数据，如果您使用自定义模型，它可以用来重新训练模型。您可以通过从增强数据集重新训练来自定义模型来提高其准确性。请参阅进一步阅读部分，了解有关如何实现这一点的博客参考。

从 Amazon S3，您修正或人工增强/验证后的 AI/ML 预测结果可以发送到客户端应用程序。

注意

使用 Amazon Textract，您只能增强或验证您的预测。当前不支持模型重新训练功能，因为 Amazon Textract 不支持自定义模型。然而，使用 Amazon Comprehend 的自定义分类和自定义实体，您可以使用 Amazon A2I 重新训练您的自定义模型并提高准确性。

在本节中，我们介绍了使用 Amazon A2I 的好处，并展示了它如何改善 AI/ML 系统的准确性。在接下来的部分，我们将指导您如何通过使用 Amazon Textract 和 Amazon A2I 设置文档处理工作流中的人工智能（HITL）流程。

向您的文档处理管道添加人工审核

我们已经介绍了 A2I 如何与任何 AWS AI 服务配合使用架构。在本节中，我们将专门讨论 Amazon A2I 如何与 Amazon Textract 集成，从而使您能够通过 HITL 自动化现有的文档工作流。我们还将展示如何使用 AWS 控制台设置人工审查工作流。

让我们首先来了解 Amazon A2I 如何与 Amazon Textract 协同工作：

图 13.2 – Amazon A2I 与 Amazon Textract 协同工作

您扫描的文档会发送到 Amazon Textract。Amazon Textract 会从文档中提取文本、键值对和表格。现在，对于这些提取的文本、键值对和表格，您还会获得置信度分数。您可以设置一个阈值，当达到该阈值时，Amazon A2I 会触发创建人工审查循环。您可以为 Amazon Textract 设置三个方面的阈值：

• 对于键值对检测中缺失的任何键，例如，如果在您审查的表单中邮寄地址是一个重要的键，但 AI 预测结果中缺失了该项。

• 您可以定义一个预测阈值，以便将其视为高置信度。

• 您可以发送质量保证（QA）审计的预测结果。

  注意

  Amazon Textract 和 Amazon A2I 在 API 中有原生集成，专门用于键值对或表单数据提取，如果您希望为 Amazon Textract 检测到的文本或表格数据设置人工审查，可以使用该集成。

您可以使用自定义的 A2I 用户界面模板，并通过 starthumanloop A2I API 设置循环，而不是使用 Textract API。当 Amazon A2I 启动人工审查 API 时，我们将添加如何设置自定义循环的示例（请参阅进一步阅读部分）：docs.aws.amazon.com/sagemaker/latest/dg/a2i-start-human-loop.html#a2i-instructions-starthumanloop。

让我们回到我们虚构的公司案例。该银行 LiveRight 想要数字化其支票处理系统。当前系统是手动审查支票金额和日期，这既耗时又容易出错。我们将展示 LiveRight 如何使用 Amazon Textract 和 Amazon A2I 来自动化其当前的支票处理系统。我们将使用这份示例支票文档：

图 13.3 – 示例支票

我们将使用这张支票来验证美元金额和日期，确保在向收款人发放之前准确无误。为此，我们将按照以下步骤操作：

• 创建一个 Amazon S3 存储桶

• 在 AWS 控制台中创建私人工作团队

• 在 AWS 控制台中创建人工审查工作流

• 通过调用 Amazon Textract API 将文档发送到 Amazon Textract 和 Amazon A2I

• 在 A2I 控制台中完成对文档的人工审查

• 在您的 S3 存储桶中查看结果

所以，让我们开始吧！

创建一个 Amazon S3 存储桶

首先，我们将讨论如何创建一个 Amazon S3 桶并上传示例文档，以便进行 Textract A2I 处理。正如我们在图 13.1的架构中所述，Amazon A2I 需要一个 Amazon S3 桶来存储人工注释结果。我们还将启用设置 A2I 循环所需的跨源资源共享（CORS）配置。

该配置允许 A2I 浏览器权限从此 S3 桶中下载资源。为此，请按照以下步骤操作：

1. 转到 Amazon S3 链接：s3.console.aws.amazon.com/s3/bucket/create?region=us-east-1。

   然后，按照第二章中“介绍 Amazon Textract”的说明，创建一个名为a2i-demos的桶。

2. 创建桶后，将以下链接中的示例检查文件上传到桶：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2013/samplecheck.PNG。

3. 上传示例检查文件后，转到Amazon S3 桶 | 权限，然后向下滚动到CORS，然后复制并粘贴以下 CORS 配置：

   [
       {
           "AllowedHeaders": [],
           "AllowedMethods": [
               "GET"
           ],
           "AllowedOrigins": [
               "*"
           ],
           "ExposeHeaders": []
       }
   ]
   

   你的 CORS 配置应该如下所示：

图 13.4 – 我们的 S3 A2I 输出桶的 CORS 配置

本节介绍了如何创建 S3 桶、上传示例检查文件并设置 CORS 配置。接下来，我们将设置私人工作团队。

在 AWS 控制台中创建私人工作团队

在本节中，我们将向你展示如何创建一个私人工作团队并使用你的电子邮件将自己添加为工作者：

1. 转到以下链接并选择私人：console.aws.amazon.com/sagemaker/groundtruth?region=us-east-1#/labeling-workforces。

2. 点击demo-team作为团队名称，向下滚动到添加工作者，输入你自己的有效电子邮件地址作为电子邮件地址，并在组织名称字段中输入你自己的组织：

   图 13.5 – 创建私人团队并添加工作者

3. 向下滚动并点击创建私人团队。

添加工作者到你创建的私人团队后，你将收到一封电子邮件。该邮件包含一个链接，可让你登录到 A2I 任务 UI 门户，并提供你的用户名和密码。

本节介绍了如何创建私人工作团队。接下来，让我们继续设置人工审核工作流。

在 AWS 控制台中创建人工审核工作流

在本节中，我们将展示如何使用 Amazon Textract 创建人工审核工作流。你需要在前面的章节中创建的 Amazon S3 存储桶和私人工作组，并且需要一个 UI 来显示审核和设置触发人工审核环节的阈值条件：

1. 访问此链接以创建人工审核工作流：console.aws.amazon.com/a2i/home?region=us-east-1#/create-human-review-workflows。

   在 Textract-check 中的 s3://a2i-demos/> 。对于IAM 角色，点击创建新角色并选择任意 S3 存储桶。你的设置应如下所示：

   

   图 13.6 – 使用 A2I 创建流程定义

2. 向下滚动并在任务类型中选择Textract 键值对提取。

3. 要触发人类审核，你可以选择至少一个条件或所有三个条件。对于缺失的 $ 和 0 到 90 的置信度阈值，如下图所示：

   图 13.7 – 设置阈值以触发 Textract 的 A2I 循环

4. 现在，点击第二个条件的复选框，审核所有表单键的置信度分数在指定范围内，并输入 0 到 90。

   我们设置了三个触发条件中的两个条件，以便 Textract A2I 触发审核。只有在前述条件满足时，才会创建人类审核环节——也就是说，如果缺少任何键，比如美元金额和日期，或者任何表单键的置信度分数低于 90%。

5. 在 textract-check-ui 中。这是 Textract 表单与 A2I 集成的默认 UI。你可以使用自己的自定义 UI 并通过 API 将其添加，我们将在下一章进行讲解。

6. 在 label the data。

7. 向下滚动到工作者并选择私人，然后点击你刚刚创建的私人团队：

   图 13.8 – 在人工审核工作流设置中选择你的私人团队

8. 点击创建。这将创建一个人工流程定义。复制此流程定义的 ARN，我们将在满足此流程定义中定义的条件时，使用它来调用 Textract API 中的人类审核环节。

在本节中，我们展示了如何为人工审核环节创建流程定义。在下一节中，我们将展示如何在 Textract Analyze 文档 API 中触发此流程定义，同时传递文档。

通过调用 Amazon Textract API 将文档发送到 Amazon Textract 和 Amazon A2I

在本节中，我们将展示如何在 Textract Analyze 文档 API 中使用表单触发你刚刚创建的 A2I 流程定义。

如果你在前面的章节中没有进行此操作，首先需要创建一个Chapter 13文件夹，并打开chapter13 Improving accuracy of document processing .ipynb笔记本：

注意

确保笔记本中的 IAM 角色具有 AmazonTextractFullAccess 权限（console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AmazonTextractFullAccess$jsonEditor）和 AmazonAugmentedAIFullAccess 权限（console.aws.amazon.com/iam/home?#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAmazonAugmentedAIFullAccess）。

1. 要开始，请转到这个笔记本并在以下笔记本单元格中输入你创建的 S3 桶名称：

   bucket="<your s3 bucket name>"
   

2. 在 humanLoopConfig 中，粘贴从先前设置中复制的流程定义 ARN：

   humanLoopConfig = {
       'FlowDefinitionArn':"<enter flow definition arn created> ",
       'HumanLoopName':"textract-10", 
       'DataAttributes': { 'ContentClassifiers': [ 'FreeOfPersonallyIdentifiableInformation' ]}
   }
   

3. 运行以下笔记本单元格，启动 HITL 配置，通过传递包含我们在控制台中创建的流程定义的humanloopconfig json，以便使用 A2I Analyze 文档 API：

   response = textract.analyze_document(
           Document={'S3Object': {'Bucket': bucket,'Name':  "samplecheck.PNG"}},
           FeatureTypes=["FORMS"], 
           HumanLoopConfig=humanLoopConfig
       )
   

4. 运行此命令后，你将得到一个响应，其中包含HumanLoopActivationConditionsEvaluationResults，如以下截图所示：

   图 13.9 – Textract Analyze 文档 API 与 A2I 设置的 JSON 响应输出

5. 转到你创建的私有工作团队：console.aws.amazon.com/sagemaker/groundtruth?region=us-east-1#/labeling-workforces

   将工作团队的 ARN 复制并粘贴到笔记本单元格中，如下所示：

   WORKTEAM_ARN= "enter your private workteam arn"
   

6. 运行以下代码块以导航到你的工作团队或 A2I 控制台：

   workteamName = WORKTEAM_ARN[WORKTEAM_ARN.rfind('/') + 1:]
   

7. 你将获得一个链接。点击该链接，并使用在创建工作团队时收到的用户名和密码登录（通过你的电子邮件 ID）。你将看到你的 A2I 任务，如下图所示。点击开始工作：

   图 13.10 – 亚马逊 A2I 控制台屏幕，显示工作任务

8. 你将被重定向到调用 Textract A2I 循环时创建的任务：

   图 13.11 – A2I 控制台，显示从示例检查中 Textract 检测到的键值对

9. 你可以在这个 UI 门户的左侧看到原始样本检查，右侧显示提取的键值对。可以验证数据并在需要时输入更改。确保$金额和日期正确，然后点击提交。当你点击某个特定的键值时，可以看到 Textract 检测到的输出被映射到原始文档上（边框框映射）：

   图 13.12 – 在 A2I 控制台中查看和修正 Textract 响应

10. 增强和验证数值后，点击提交，你的输出将保存在你创建的同一个 S3 存储桶中。运行以下笔记本单元格以从 S3 获取 JSON 结果并查看注释结果：

    for resp in completed_human_loops:
        splitted_string = re.split('s3://' + bucket  + '/', resp['HumanLoopOutput']['OutputS3Uri'])
        output_bucket_key = splitted_string[1]
        print(output_bucket_key)
        response = s3.get_object(Bucket= bucket, Key=output_bucket_key)
        content = response["Body"].read()
        json_output = json.loads(content)
        pp.pprint(json_output)
        print('\n')
    

    你将在以下截图中看到带有人类注释答案的输出：

图 13.13 – 人工修正的 A2I JSON 输出

本节内容为你提供了如何调用 Textract Analyze 文档 API 的笔记本操作指南，配置 HITL 以检测键值对或表单。

摘要

本章内容介绍了如何在使用 Amazon Textract 自动化文档工作流时提高现有文档处理工作流的准确性。我们介绍了 Amazon A2I 及其如何帮助提高文本预测的准确性，并且可以与 Amazon Textract 集成以设置人工审查工作流。我们还讨论了如何使用 A2I 和定制模型进行模型再训练以提高准确性，下一章将深入讲解这一部分内容。

为了进一步展示 A2I 的实际应用，我们还提供了一段 10 分钟的YouTube视频教程，由《深入阅读》部分提到的作者之一讲解。

深入阅读

• 使用 Amazon Textract 与 Amazon A2I 处理关键文档 由 Anuj Gupta, Talia Chopra 和 Pranav Sachdeva 编写：aws.amazon.com/blogs/machine-learning/using-amazon-textract-with-amazon-augmented-ai-for-processing-critical-documents//

• 了解如何在文档处理流程中添加人工审查 由 Mona Mona 编写：www.youtube.com/watch?v=U2J_pq17POA

第十四章：第十四章：审计命名实体识别工作流

在前一章中，我们介绍了使用Amazon Augmented AI（Amazon A2I）来提高从文档中提取结果准确性的方案。我们看到，Amazon A2I 可以添加到文档处理工作流中，以审核模型预测的准确性。这使我们能够在 LiveRight 的检查处理系统中包含人工审核。

本章将通过将Amazon Comprehend 用于基于文本的洞察扩展前述方法，从而演示如何为您的自定义命名实体识别用例设置审计工作流的端到端过程。我们根据集体经验和在职业生涯中观察到的使用趋势，整理了这个解决方案。我们预计在本章过程中将进行实际操作，但我们已经准备好了所有需要的代码示例。

通过机器学习（ML），企业可以建立自动化文档处理解决方案，经过训练后能够识别并提取文档中的自定义实体。这有助于从文本语料库中获得独特的洞察力，从而推动战略决策。然而，首先需要应对一些挑战。通常，企业会接收到大量格式不同、内容各异的文档，且文档可能是多语言的。而且，随着企业的发展，文档的类型和数量也在不断变化，很快就会进入一种维护负担的状态，需要不断调整各种模板、格式和规则，以确保它们与操作需求的使用方式同步。此外，还必须确保基础设施能够扩展以支持处理需求。

为了解决这些挑战，我们将展示如何利用Amazon Textract的现成机器学习功能，借助迁移学习创建一个自定义实体识别模型，并通过使用 A2I 审核预测结果，结合人工审核循环。我们在第十三章《提高文档处理工作流准确性》中详细介绍了 Amazon A2I。在本章中，我们将按照以下几个部分展开：

• 贷款申请认证

• 构建贷款认证解决方案

技术要求

对于本章，您需要访问AWS 账户，可以通过aws.amazon.com/console/进行访问。有关如何注册 AWS 账户并登录到AWS Management Console的详细说明，请参考第二章《介绍 Amazon Textract》中的注册 AWS 账户子部分。

本章讨论的解决方案的Python代码和示例数据集可以在以下链接找到：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/tree/main/Chapter%2014。

查看以下视频以查看代码在bit.ly/3GoBh1B中的运行情况。

认证贷款申请

每天，金融机构收到大量的贷款申请。虽然主要的机构已经转向完全数字化处理，但世界各地仍有许多银行和机构依赖纸质文档。为了说明我们的例子，让我们回到我们的虚构银行公司LiveRight Holdings Private Limited，并审查此用例的要求：

• LiveRight 向其主要是中小型企业和个人消费者的客户提供多种借贷产品。为了申请贷款，消费者填写基于纸张的贷款/抵押贷款申请表格，由专家团队验证申请的真实性（称为真实性检查过程）。如果被确认为有效申请人，LiveRight 的贷款处理人员将要求消费者提交支持文件以进行预批准资格。

• LiveRight 每天从潜在客户处收到 8,000 至 10,000 份贷款申请。这些申请每晚从公司各分支机构转发至总部的文档入口中心。今天，他们的真实性检查过程需要团队大约 2 到 4 周的时间扫描所有申请，并确定是否足够好以转发给贷款处理人员，甚至在预批准阶段也造成了显著的延迟。这引起了许多客户的不满，他们正在将业务转移到其他地方。LiveRight 已经聘请您自动化真实性检查流程，并希望在解决方案实施的头三个月内将处理时间缩短至 24 小时以内。

作为项目的企业架构师，您决定使用 Amazon Textract 来利用其预训练的 ML 模型进行文本提取，使用 Amazon Comprehend 的自定义实体识别器功能逐步创建自己的实体识别器，用于贷款申请检查，无需构建复杂的自然语言处理（NLP）算法，以及使用 A2I 设置人工审查工作流程，监视实体识别器的预测，并向识别器发送反馈，以改善其检测独特用例的实体能力。

您计划在前 2 到 3 个月内提供私有人工工作流，然后禁用它，此时文档处理工作流将完全自动化。当人工团队检查并更新实体标签时，您需要确定真实性检查决策，决策结果为批准、总结批准或拒绝。该决策以及贷款申请中的相关内容应存储在Amazon DynamoDB（一项完全托管的低延迟NoSQL数据库服务）表中，以供贷款处理人员访问内容并启用预审批资格。我们将构建的解决方案组件如下图所示：

图 14.1 – 贷款审批文档处理解决方案架构

我们将使用Amazon SageMaker Jupyter notebook来逐步执行代码并查看结果，从而引导我们走完整个解决方案流程。该解决方案的构建包括以下任务：

1. 作为第一步，我们将根据 GitHub 仓库中提供的训练数据集创建 Amazon Comprehend 自定义实体识别器。

2. 接下来，我们将创建一个私有标签团队，并添加一名团队成员，负责使用 Amazon A2I 服务来审查 Amazon Comprehend 自定义实体识别器的预测结果。我们将使用 Amazon SageMaker 控制台中的标签团队功能来创建私有团队。有关详细信息，请参考此链接：docs.aws.amazon.com/sagemaker/latest/dg/sms-workforce-private.html。

3. 我们通过检查在 GitHub 仓库中提供的示例贷款申请来开始解决方案工作流程。我们在笔记本中展示贷款申请的图片并查看其内容。

4. 然后，我们使用 Amazon Textract 从输入文档中提取键值对。

5. 然后，我们从键值对创建一个推理请求字符串，并准备将其发送到 Amazon Comprehend 自定义实体检测。

6. 接下来，我们设置一个 Amazon Comprehend 实时终端节点，并调用它来检测我们的推理请求字符串中的实体。

7. 我们将使用实体识别任务 UI 模板设置 Amazon A2I 人工审查循环，并将自定义实体检测的结果发送到 Amazon A2I 人工循环。

8. 以私有工作者身份登录后，我们将审查检测到的实体，并根据需要修改标签。

9. 接下来，我们将检查是否发生了新的实体检测事件，或者是否修改了现有的实体检测，更新实体列表，并将其发送回 Amazon Comprehend 进行实体检测模型的再训练。

10. 基于人工审查循环的输出，我们还将为贷款申请做出决定，并将此信息上传到DynamoDB 表中，以便后续处理。

现在我们已经了解了练习的背景并讨论了预定的流程，让我们开始构建解决方案。

构建贷款认证解决方案

在前面的部分，我们介绍了贷款申请审批的用例，讲解了我们将要构建的解决方案架构，并简要地介绍了解决方案组件和工作流程步骤。在本节中，我们将直接开始执行任务，构建我们的解决方案。但首先，我们需要处理一些先决条件。

设置以解决用例

如果您在之前的章节中尚未完成，您首先需要创建一个 Jupyter notebook，并为该 notebook 角色设置身份与访问管理（IAM）权限，以便访问我们将在本笔记本中使用的 AWS 服务。之后，您需要克隆 GitHub 仓库（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services），创建一个Amazon S3 存储桶（aws.amazon.com/s3/），并在笔记本中提供存储桶名称以开始执行。在我们可以执行笔记本单元格之前，请按照以下步骤完成这些任务：

注意：

请确保您已完成技术要求部分提到的任务。

1. 要创建您的 Jupyter Notebook 实例，请按照第二章中设置您的 AWS 环境部分的创建 Amazon SageMaker Jupyter Notebook 实例一节的说明操作，介绍 Amazon Textract。

   创建 Amazon SageMaker Jupyter 笔记本时的 IAM 角色权限

   在创建笔记本时接受默认的 IAM 角色，以便访问任何 S3 存储桶。

2. 一旦您创建了笔记本实例并且其状态为服务中，点击操作菜单中的打开 Jupyter，进入笔记本实例。

3. 这将带您进入笔记本实例的主页文件夹。

4. 点击新建，并选择终端。

5. 在cd SageMaker中输入，然后输入git clone github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services。

6. 现在，退出终端窗口，返回到Natural-Language-Processing-with-AWS-AI-Services。点击该文件夹以显示章节文件夹，再点击Chapter 14。点击该文件夹打开。您应该能看到名为chapter14-auditing-workflows-named-entity-detection-forGitHub.ipynb的笔记本。

7. 点击打开该笔记本。

按照本笔记本中本节下几小节对应的步骤，逐一执行每个单元格。请阅读每个笔记本单元格前提供的描述。

额外的 IAM 先决条件

为了训练 Comprehend 自定义实体识别器，设置实时端点，我们必须启用额外的策略，并更新我们的 SageMaker 笔记本角色的信任关系。请参考第二章中《设置 AWS 环境》章节里的更改 IAM 权限和信任关系以支持 Amazon SageMaker Notebook 执行角色部分，了解如何执行以下步骤的详细说明：

1. 请将TextractFullAccess、ComprehendFullAccess和AmazonAugmentedAIFullAccess策略附加到你的 Amazon SageMaker Notebook IAM 角色。

2. 向你的 SageMaker 笔记本执行角色添加IAM:PassRole权限作为内联策略：

   { "Version": "2012-10-17", "Statement": [ {
     "Action": [
         "iam:PassRole"
     ],
     "Effect": "Allow",
     "Resource": "<your sagemaker notebook execution role ARN">
     }
    ]
   }
   

3. 最后，更新信任关系：

   { "Version": "2012-10-17", "Statement": [
     { "Effect": "Allow", 
       "Principal": 
         { "Service": 
             [ "sagemaker.amazonaws.com", 
               "s3.amazonaws.com", 
               "comprehend.amazonaws.com" ] 
             }, 
             "Action": "sts:AssumeRole" } 
         ] 
     }
   

现在我们已经设置好了笔记本并配置了 IAM 角色来运行示范笔记本，在接下来的部分，我们将训练一个 Amazon Comprehend 实体识别器。

训练 Amazon Comprehend 自定义实体识别器

让我们开始训练一个自定义实体识别器，检测本解决方案特有的实体。Amazon Comprehend 提供了我们在上一章学习过的预训练实体识别功能。对于本解决方案，我们将使用 Amazon Comprehend 的自定义实体识别功能，它允许你使用增量训练训练一个适应自定义需求的识别器。我们所需要做的就是提供一个我们希望它识别的实体列表，以及包含文本行的原始数据集，这些文本行构成了将被识别为实体的上下文。打开笔记本并按照以下步骤执行：

1. 执行步骤 0 - 导入库下的单元，确保我们为笔记本准备好了所需的库。请注意，在此单元中，你将获取到用于笔记本的 Amazon SageMaker 执行角色，以及 SageMaker 会话。请确保你创建了一个 Amazon S3 存储桶（docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html），并在下面的行中提供存储桶名称：

   bucket = '<bucket-name>'
   

2. 执行boto3处理的单元，以便在 Amazon Comprehend 下运行：

   comprehend = boto3.client('comprehend')
   

   b) 然后，定义 S3 前缀的变量并将训练数据集和实体列表上传到 S3 存储桶：

   s3_raw_key = prefix + "/train/raw_txt.csv" 
   s3_entity_key = prefix + "/train/entitylist.csv"
   s3.upload_file('train/raw_txt.csv',bucket,s3_raw_key)
   s3.upload_file('train/entitylist.csv',bucket,s3_entity_key)
   

   c) 继续执行笔记本中的其余单元，声明包含我们输入文档的完整 S3 URI的变量，定义实体识别器的输入对象，最后调用 Comprehend API 来创建自定义实体识别器。这将启动训练任务：

   import datetime
   cer_name = "loan-app-recognizer"+str(datetime.datetime.now().strftime("%s"))
   cer_response = comprehend.create_entity_recognizer(
           RecognizerName = cer_name, 
           DataAccessRoleArn = role,
           InputDataConfig = cer_input_object,
           LanguageCode = "en"
   )
   

   d) 打印自定义实体识别器训练任务的结果：

   import pprint
   pp = pprint.PrettyPrinter(indent=4)
   response = comprehend.describe_entity_recognizer(
       EntityRecognizerArn=cer_response['EntityRecognizerArn']
   )
   pp.pprint(response)
   

3. 定期访问 Amazon Comprehend AWS 控制台 (console.aws.amazon.com/comprehend/v2/home?region=us-east-1#entity-recognition) 检查训练作业的状态。训练过程大约需要 15 到 30 分钟。可以趁此时间喝杯咖啡或小吃一下。

创建用于人工环节的私有团队

请参阅笔记本中的 第 2 步 (github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2014/chapter14-auditing-workflows-named-entity-detection-forGitHub.ipynb)，以获取我们现在要执行的指令。

在此步骤中，我们将使用 Amazon SageMaker 标注工作团队控制台创建一个私有团队，并将自己添加为该私有团队的工作人员。这样做是为了在我们进入此解决方案中的 Amazon A2I 步骤时，能够登录到标注任务的用户界面。请执行以下任务：

1. 如果尚未登录 AWS 管理控制台，请登录（更多详细信息，请参考本章开头的 技术要求 部分），在 服务 搜索栏中输入 amazon sagemaker，然后进入 Amazon SageMaker 控制台。进入后，在 UI 左侧点击 Ground Truth，再点击 Labeling workforces。在此页面，选择顶部标签中的 Private，然后点击 Create private team。

   图 14.2 – SageMaker 标注工作团队

2. 在 Team name 字段中输入您的私有团队名称，并在 Add workers 部分保持默认选择 Create a new Amazon Cognito user group。向下滚动并点击 Create private team。

3. 现在您将返回到 nlp-doc-team，应该可以在 arn:aws:sagemaker:region-name-123456:workteam/private-crowd/team-name 下看到它。请从屏幕上复制 ARN 并在笔记本单元格中提供：

   WORKTEAM_ARN= '<workteam-arn>'
   

4. 接下来，向下滚动到前一页面，进入 no-reply@verificationemail.com。按照指示完成注册过程。

   图 14.3 – 邀请新工作人员

5. 接下来，通过点击 nlp-doc-team，再点击 Add workers to team，将自己添加到私有团队中。从列表中选择您的电子邮件地址，然后点击 Add workers to team。

图 14.4 – 向团队添加工作人员

现在我们已经添加了私有团队，让我们通过使用 Amazon Textract 提取内容来审阅我们的贷款申请。

使用 Amazon Textract 提取样本文档内容

本节对应于笔记本中的步骤 3：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2014/chapter14-auditing-workflows-named-entity-detection-forGitHub.ipynb。

在此步骤中，我们将回顾示例贷款申请，然后使用 Amazon Textract 提取我们解决方案所关注的关键值对或表单数据，创建推理请求 CSV 文件，并将其作为输入传递给我们的 Comprehend 自定义实体识别器以检测实体。请通过笔记本逐步执行，并运行单元格以完成此步骤所需的任务：

1. 通过执行笔记本单元格中的代码来查看输入文档，如下所示：

   documentName = "input/sample-loan-application.png"
   display(Image(filename=documentName))
   

2. 现在让我们将此图像加载到我们的 S3 存储桶中：

   s3.upload_file(documentName,bucket,prefix+'/'+documentName)
   

3. 我们将从此文档中提取关键值对数据，转换并创建一个用于推理的请求字符串，使用 Amazon Textract 的AnalyzeDocument API。此 API 接受图像文件（PNG 或 JPEG）作为输入。如果要使用 PDF 文件或处理多个文档，可以使用StartDocumentAnalysis API：docs.aws.amazon.com/textract/latest/dg/API_StartDocumentAnalysis.html。

4. 我们将使用amazon-textract-response-parser库来处理来自 Textract 的 JSON 响应。通过输入以下命令进行安装：

    !pip install amazon-textract-response-parser        
   

5. 现在，让我们使用 Textract 的boto3 Python SDK 来检索文档内容，如下所示：

   textract = boto3.client('textract')
   response = textract.analyze_document(Document={'S3Object': {
               'Bucket': bucket,
               'Name': prefix+'/'+documentName
           }}, FeatureTypes=['FORMS'])
   

6. 我们现在将提取我们解决方案所需的关键值对。我们将不使用复选框字段，仅使用那些有值的字段。同时，我们将在接下来的步骤中筛选出我们实际需要的字段：

   from trp import Document
   doc = Document(response)
   df = pd.DataFrame()
   # Iterate over elements in the document
   x = 0
   for page in doc.pages:
       for field in page.form.fields:   
           if field.key is not None and field.value is not None:
               if field.value.text not in ('SELECTED','NOT_SELECTED'):
                   df.at[x,'key'] = field.key.text
                   df.at[x,'value'] = field.value.text
                   x+=1
   df
   

7. 现在，我们已经将 Textract 的结果加载到p****andas DataFrame中（pandas.pydata.org/docs/reference/api/pandas.DataFrame.html），接下来我们将运行一系列操作，从贷款申请中筛选出我们感兴趣的列。请执行笔记本中Extract contents for sending to Comprehend CER部分下的所有单元格。最终，我们应该会看到如下所示的过滤字段列表：

图 14.5 – 我们将用于 Comprehend 实体识别的最终字段列表

现在，让我们讨论如何使用 Amazon Comprehend 自定义实体识别器来检测实体。

使用 Amazon Comprehend 自定义实体识别器检测实体

现在我们已经从贷款申请中获得所需的内容，让我们构造一个字符串，该字符串将成为我们向最初训练的 Comprehend 自定义实体识别器发送的推理请求（笔记本中的第 1 步）。在检测实体之前，我们需要创建一个实时端点，并将其与我们的实体识别器关联。当你以批处理模式部署此解决方案或用于处理多个文档时，将使用 Amazon Comprehend StartEntitiesDetection API：docs.aws.amazon.com/comprehend/latest/dg/API_StartEntitiesDetectionJob.html。

请按照本节中的说明执行笔记本中的第 4 步单元：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2014/chapter14-auditing-workflows-named-entity-detection-forGitHub.ipynb：

1. 我们现在将创建一个请求字符串，该字符串将发送到 Amazon Comprehend 自定义实体识别器模型，用于检测我们训练过的实体。这一字符串包含了我们在上一步骤中使用 Amazon Textract 从贷款申请文档中提取的数据。我们将转置 pandas DataFrame，添加一个文档编号列，并用它来准备推理请求字符串：

   df_T.columns = df_T.columns.str.rstrip()
   df_T['doc'] = 1
   df_T
   for idx, row in df_T.iterrows():
           entry = 'Country'+':'+str(row['Country']).strip()+" "+'Years'+':'+str(row['Years']).strip()+" "+'Cell Phone'+':'+str(row['Cell Phone']).strip()+" "+'Name'+':'+str(row['Name']).strip()+" "+'Social Security Number'+':'+str(row['Social Security Number']).strip()+" "+'TOTAL $'+':'+str(row['TOTAL $']).strip()+" "+'Date of Birth'+':'+str(row['Date of Birth']).strip()
   

2. 接下来，让我们为 Comprehend 创建一个实时端点：

   custom_recognizer_arn=cer_response['EntityRecognizerArn']
   endpoint_response = comprehend.create_endpoint(
       EndpointName='nlp-chapter4-cer-endpoint',
       ModelArn=custom_recognizer_arn,
       DesiredInferenceUnits=2,
       DataAccessRoleArn=role
   )
   endpoint_response['EndpointArn']
   

3. 我们看到端点 Arn 如下所示：

   arn:aws:comprehend:us-east-1:<aws-account-nr>:entity-recognizer-endpoint/nlp-chapter4-cer-endpoint
   

4. 通过导航到 Amazon Comprehend 控制台，进入左侧菜单中的 自定义实体识别，点击你的识别器，然后向下滚动验证实时端点是否成功创建来检查端点的状态。如果端点未激活，笔记本中下一个单元的代码将失败。端点准备好可能需要约15 分钟：图 14.6 – 等待端点准备就绪

   图 14.6 – 等待端点准备就绪

5. 当端点准备就绪时，执行笔记本单元中的代码，将推理请求发送到自定义实体识别器，如下所示：

   response = comprehend.detect_entities(Text=entry,
                       LanguageCode='en',
   EndpointArn=endpoint_response['EndpointArn']
               )
   print(response)
   

6. 我们看到的输出如下所示。此显示表明我们的 Comprehend 实体识别已识别出所有代表有效人的属性：

   {'Entities': [{'Score': 0.9999999403953552, 'Type': 'PERSON', 'Text': 'Years:18', 'BeginOffset': 11, 'EndOffset': 19}, {'Score': 0.9999998211860657, 'Type': 'PERSON', 'Text': 'Cell Phone:(555 ) 0200 1234', 'BeginOffset': 20, 'EndOffset': 47}, {'Score': 1.0, 'Type': 'PERSON', 'Text': 'Name:Kwaku Mensah', 'BeginOffset': 48, 'EndOffset': 65}, {'Score': 1.0, 'Type': 'PERSON', 'Text': 'Social Security Number:123 - 45 - 6789', 'BeginOffset': 66, 'EndOffset': 104}, {'Score': 1.0, 'Type': 'PERSON', 'Text': 'TOTAL $:8000.00/month', 'BeginOffset': 105, 'EndOffset': 126}, {'Score': 1.0, 'Type': 'PERSON', 'Text': 'Date of Birth:01 / 01 / 1953', 'BeginOffset': 127, 'EndOffset': 155}], 'ResponseMetadata': {'RequestId': 'ecbd75fd-22bc-4dca-9aa0-73f58f6784e4', 'HTTPStatusCode': 200, 'HTTPHeaders': {'x-amzn-requestid': 'ecbd75fd-22bc-4dca-9aa0-73f58f6784e4', 'content-type': 'application/x-amz-json-1.1', 'content-length': '620', 'date': 'Tue, 06 Jul 2021 22:26:11 GMT'}, 'RetryAttempts': 0}}
   

7. 第 4 步中的最后一个任务是准备一个 human_loop_input 列表，以便与我们将在下一步中创建的 Amazon A2I 人工工作流一起使用：

   import json
   human_loop_input = []
   data = {}
   ent = response['Entities']
   existing_entities = []
   if ent != None and len(ent) > 0:
       for entity in ent:       
           current_entity = {}
           current_entity['label'] = entity['Type']
           current_entity['text'] = entity['Text']
           current_entity['startOffset'] = entity['BeginOffset']
           current_entity['endOffset'] = entity['EndOffset']
           existing_entities.append(current_entity)
       data['ORIGINAL_TEXT'] = entry
       data['ENTITIES'] = existing_entities   
       human_loop_input.append(data)
   print(human_loop_input)        
   126}, {'label': 'PERSON', 'text': 'Date of Birth:01 / 01 / 1953', 'startOffset': 127, 'endOffset': 155}]}]
   

在本节中，我们能够使用 Amazon Comprehend 实体识别器检测实体。在下一节中，我们将介绍如何使用 Amazon A2I 审查预测并对预测实体与实际实体之间的差异进行修改。

设置 Amazon A2I 人工工作流循环

有关这里讨论的代码块，请参阅笔记本中的步骤 5：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2014/chapter14-auditing-workflows-named-entity-detection-forGitHub.ipynb。

现在，我们已经从 Comprehend 自定义实体识别器中获取了检测到的实体，是时候使用我们在步骤 2中创建的私人团队设置人工工作流，并将结果发送到亚马逊 A2I 人工循环进行审查，以及根据需要进行修改/增强。随后，我们将更新最初用于训练 Comprehend 自定义实体识别器的entitylist.csv文件，以便根据人工反馈准备重新训练：

1. 我们首先初始化一些接下来任务所需的变量：

   timestamp = time.strftime("%Y-%m-%d-%H-%M-%S", time.gmtime())
   # Amazon SageMaker client
   sagemaker = boto3.client('sagemaker')
   # Amazon Augment AI (A2I) client
   a2i = boto3.client('sagemaker-a2i-runtime')
   # Flow definition name
   flowDefinition = 'fd-nlp-chapter14-' + timestamp
   # Task UI name - this value is unique per account and region. You can also provide your own value here.
   taskUIName = 'ui-nlp-chapter14-' + timestamp
   # Flow definition outputs
   OUTPUT_PATH = f's3://' + bucket + '/' + prefix + '/a2i-results'
   

2. 现在，我们将通过执行笔记本中的下一个单元格来创建人工任务的用户界面（参见笔记本中的步骤 5）。我们从亚马逊 A2I 示例任务 UI GitHub 仓库（github.com/aws-samples/amazon-a2i-sample-task-uis）选择了命名实体识别任务模板，并根据我们的需求进行了自定义。

3. 基于模板创建任务 UI：

   def create_task_ui():
       '''
       Creates a Human Task UI resource.
       Returns:
       struct: HumanTaskUiArn
       '''
       response = sagemaker.create_human_task_ui(
           HumanTaskUiName=taskUIName,
           UiTemplate={'Content': template})
       return response
   # Create task UI
   humanTaskUiResponse = create_task_ui()
   humanTaskUiArn = humanTaskUiResponse['HumanTaskUiArn']
   print(humanTaskUiArn)
   

4. 我们得到如下所示的输出：

   arn:aws:sagemaker:us-east-1:<aws-account-nr>:human-task-ui/ui-nlp-chapter14-<timestamp>
   

5. 执行笔记本中的接下来几个单元格，以创建亚马逊 A2I 流程定义，该定义管理任务分配给工作团队的编排以及输出数据的收集。我们现在准备启动人工工作流循环。执行笔记本中的下一个代码块以启动人工循环。

6. 通过执行笔记本中下一个单元格的代码来检查您的人工循环状态——它应该是InProgress：

   completed_human_loops = []
   a2i_resp = a2i.describe_human_loop(HumanLoopName=humanLoopName)
   print(f'HumanLoop Name: {humanLoopName}')
   print(f'HumanLoop Status: {a2i_resp["HumanLoopStatus"]}')
   print(f'HumanLoop Output Destination: {a2i_resp["HumanLoopOutput"]}')
   print('\n')
   if a2i_resp["HumanLoopStatus"] == "Completed":
       completed_human_loops.append(resp)
   

7. 我们得到如下所示的输出：

   HumanLoop Name: 0fe076a4-b6eb-49ea-83bf-78f953a71c89
   HumanLoop Status: InProgress
   HumanLoop Output Destination: {'OutputS3Uri': 's3://<your-bucket-name>/chapter4/a2i-results/fd-nlp-chapter4-2021-07-06-22-32-21/2021/07/06/22/33/08/<hashnr>/output.json'
   

在下一节中，我们将演示您的私人审查员如何登录到控制台并审查亚马逊 Comprehend 检测到的实体。

审查和修改检测到的实体

现在，我们将登录到亚马逊 A2I 任务 UI，审查、修改并重新标注从 Comprehend 自定义实体识别器中检测到的实体。根据本节讨论的指示执行笔记本中的单元格：

1. 让我们登录到工作门户以审查预测并根据需要修改它们。执行以下代码以获取我们的任务 UI 的 URL：

   workteamName = WORKTEAM_ARN[WORKTEAM_ARN.rfind('/') + 1:]
   print("Navigate to the private worker portal and do the tasks. Make sure you've invited yourself to your workteam!")
   print('https://' + sagemaker.describe_workteam(WorkteamName=workteamName)['Workteam']['SubDomain'])
   

2. 登录后，您将看到一个贷款申请审核任务。选择它并点击开始工作：

   图 14.7 – 亚马逊 A2I 任务列表

3. 您应该能够看到亚马逊 A2I 标签 UI，其中显示了由 Comprehend 自定义实体识别高亮的实体列表及其标签，如下图所示：

   图 14.8 – Amazon A2I 标签界面准备好进行人工审核

4. 现在，从右侧的标签中选择GHOST标签，然后将其分配给 UI 中未标记的Country:US条目，并点击提交。图 14.9 – 向检测到的实体添加/修改标签并点击提交

   图 14.9 – 向检测到的实体添加/修改标签并点击提交

5. 继续执行笔记本中的单元格，再次检查人工环路的状态（这应该显示entitylist.csv文件的状态，并触发我们 Comprehend 自定义实体识别器的再训练。让我们验证是否存在新实体：

   retrain='N'
   el = open('train/entitylist.csv','r').read()
   for annotated_entity in a2i_entities:
       if original_text[annotated_entity['startOffset']:annotated_entity['endOffset']] not in el:
           retrain='Y'
           word = '\n'+original_text[annotated_entity['startOffset']:annotated_entity['endOffset']]+','+annotated_entity['label'].upper()
           print("Updating Entity List with: " + word)
           open('train/entitylist.csv','a').write(word)
   if retrain == 'Y':
       print("Entity list updated, model to be retrained")
   

6. 我们看到如下代码块显示的输出。尽管 Comprehend 将Years和Cell Phone识别为PERSON实体，但它并未出现在原始的entitylist.csv文件中，因此它将与这些值一起更新，并且 Comprehend 实体识别将重新训练：

   Updating Entity List with: 
   Country:US,GHOST
   Updating Entity List with: 
   Years:18,PERSON
   Updating Entity List with: 
   Cell Phone:(555 ) 0200 1234,PERSON
   Entity list updated, model to be retrained
   

此响应会自动保存为 Amazon S3 存储桶中的 JSON 文件，格式为标签。在下一部分，我们将使用这些修改或审核过的标签来重新训练我们的自定义实体识别器模型。

重新训练 Comprehend 自定义实体识别器

我们现在将重新训练我们的 Comprehend 自定义实体识别器。要执行的单元格与我们最初训练识别器时所做的类似：

1. 执行笔记本中的步骤 7单元格：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2014/chapter14-auditing-workflows-named-entity-detection-forGitHub.ipynb。

   在声明变量后，我们执行以下代码块以启动训练：

   Import datetime
   cer_name = "retrain-loan-recognizer"+str(datetime.datetime.now().strftime("%s"))
   cer_response = comprehend.create_entity_recognizer(
           RecognizerName = cer_name, 
           DataAccessRoleArn = role,
           InputDataConfig = cer_input_object,
           LanguageCode = "en"
   )
   

2. 我们看到输出显示，表示重新训练任务已经提交。为了清晰起见，响应中的元数据已被移除：

   {   'EntityRecognizerProperties': {   'DataAccessRoleArn': 'arn:aws:iam::<aws-account-nr>:role/service-role/<execution-role>',
                                         'EntityRecognizerArn': 'arn:aws:comprehend:us-east-1:<aws-account-nr>:entity-recognizer/retrain-loan-recognizer1625612436',
                                         'InputDataConfig': {   'DataFormat': 'COMPREHEND_CSV',
                                                                'Documents': {   'S3Uri': 's3://<s3-bucket>/chapter4/train/raw_txt.csv'},
                                                                'EntityList': {   'S3Uri': 's3://<s3-bucket>/chapter4/train/entitylist.csv'},
                                                                'EntityTypes': [   {   'Type': 'PERSON'},
                                                                                   {   'Type': 'GHOST'}]},
                                         'LanguageCode': 'en',
                                         'Status': 'SUBMITTED',
                                         'SubmitTime': datetime.datetime(2021, 7, 6, 23, 0, 36, 759000, tzinfo=tzlocal())}}
   

3. 与之前一样，转到 Amazon Comprehend 控制台，检查实体识别器的状态，并验证状态是否已更改为已训练。

4. 请重复笔记本中的步骤 3到步骤 5，测试重新训练后的识别器。

现在，让我们执行步骤，将认证检查的结果存储，以便下游应用程序访问。

存储下游处理的决策

现在我们了解了如何设置审计工作流，让我们执行必要的步骤，将实体检测的结果持久化，以便将其发送到下游应用程序。如果大多数或所有实体都是GHOST类型，我们将发送拒绝决策；如果大多数是PERSON类型，我们将发送总结批准；如果全部都是PERSON，我们将发送批准；如果它们分布均匀，我们将发送拒绝决策：

1. 首先，让我们检查从 A2I 中检测到的PERSON或GHOST类型的实体数量。执行笔记本中步骤 8的第一个单元格。我们得到的输出如下：

   [{'endOffset': 10, 'label': 'GHOST', 'startOffset': 0},
    {'endOffset': 19, 'label': 'PERSON', 'startOffset': 11},
    {'endOffset': 47, 'label': 'PERSON', 'startOffset': 20},
    {'endOffset': 65, 'label': 'PERSON', 'startOffset': 48},
    {'endOffset': 104, 'label': 'PERSON', 'startOffset': 66},
    {'endOffset': 126, 'label': 'PERSON', 'startOffset': 105},
    {'endOffset': 155, 'label': 'PERSON', 'startOffset': 127}]
   

2. 让我们应用之前的规则来决定该贷款申请的结果：

   from collections import Counter
   docstatus = ''
   ghost = float(Counter(labellist)['GHOST'])
   person = float(Counter(labellist)['PERSON'])
   if ghost >= len(labellist)*.5:
       docstatus = 'REJECT'
   elif min(len(labellist)*.5, len(labellist)*.8) < person < max(len(labellist)*.5, len(labellist)*.8):
       docstatus = 'SUMMARY APPROVE'
   elif person > len(labellist)*.8:
       docstatus = 'APPROVE'
   print(docstatus)    
   

3. 我们得到的输出是 APPROVE。

4. 将决策存储在 Amazon DynamoDB 表中（提醒：这是一个托管的数据库服务，用于存储和访问具有极低延迟的键值对）。贷款处理器可以使用这些数据开始预资格审查过程。在笔记本中执行下一个单元格来创建 DynamoDB 表。

5. 现在，执行笔记本中的下一个单元格，将贷款申请的内容和决策插入到表中。我们看到插入到 DynamoDB 表中的值如下：

图 14.10 – DynamoDB 中的贷款真实性检查状态

这就结束了解决方案构建。请参考进一步阅读部分，获取更多关于此用例的解决方法示例，以及使用 AWS Lambda 和 CloudFormation 构建类似解决方案的代码示例。

总结

在本章中，我们学习了如何构建一个用于命名实体识别的审计工作流，以解决许多组织在文档处理方面面临的现实挑战，使用的工具包括 Amazon Textract、Amazon Comprehend 和 Amazon A2I。我们回顾了贷款认证的用例，以验证文档在传递给贷款处理器之前的有效性。我们考虑了一种架构，依据的条件包括将验证时间从 2 到 4 周减少到 24 小时，这个过程将在解决方案实施后的前三个月内完成。我们假设你是这项项目的解决方案架构师，并回顾了解决方案组件的概述以及图 4.1中的架构图示。

接着，我们逐步讲解了解决方案构建的先决条件，设置了一个 Amazon SageMaker Notebook 实例，克隆了我们的 GitHub 仓库，并根据本章的说明开始执行笔记本中的代码。我们涵盖了如何训练 Amazon Comprehend 的自定义实体识别器，如何使用 Amazon SageMaker 标注工作队伍建立我们的私人工作团队，如何使用 Amazon Textract 提取贷款申请中的相关内容，将其发送到 Comprehend 自定义实体识别器进行实体检测，将检测结果转发到 Amazon A2I 人工审核循环，使用 UI 完成人工任务步骤，审查审核结果，更新实体列表以重新训练自定义实体识别器，最后将文档内容和贷款验证决策存储到 Amazon DynamoDB 表中以供后续处理。

在下一章中，我们将构建一个为 NLP 量身定制的经典用例——即文本分类的主动学习工作流。我们将使用 Amazon Comprehend custom 训练一个文本分类模型，用于将文档标记为不同类别，利用 Amazon A2I 审查预测结果，并根据 Amazon A2I 人工审阅反馈重新训练分类器。我们将展示该解决方案如何通过反馈循环在提高分类准确性方面不断发展智能化。

深入阅读

• 使用 AWS 构建端到端智能文档处理解决方案，作者：Purnesh Tripathi: aws.amazon.com/blogs/machine-learning/building-an-end-to-end-intelligent-document-processing-solution-using-aws/

• 使用 Amazon SageMaker Ground Truth、Amazon Comprehend 和 Amazon A2I 设置 NLP 基础的实体识别模型的人工审阅，作者：Mona Mona 和 Prem Ranga: aws.amazon.com/blogs/machine-learning/setting-up-human-review-of-your-nlp-based-entity-recognition-models-with-amazon-sagemaker-ground-truth-amazon-comprehend-and-amazon-a2i/

• 宣布 Amazon Comprehend custom 实体识别模型改进和更低的标注限制，作者：Prem Ranga、Chethan Krishna 和 Mona Mona: aws.amazon.com/blogs/machine-learning/announcing-model-improvements-and-lower-annotation-limits-for-amazon-comprehend-custom-entity-recognition/

第十五章：第十五章：文档分类及设置人类参与的主动学习

在上一章中，我们介绍了如何使用Amazon Comprehend 自定义实体从文档中提取业务实体，并展示了如何结合 Amazon 增强型 AI（A2I）使用人工参与来增强或改进实体预测。最后，我们展示了如何通过使用增强数据集对 Comprehend 自定义实体模型进行重新训练，以利用 Amazon A2I 提高准确性。

在本章中，我们将讨论如何使用Amazon Comprehend 自定义分类来分类文档，并介绍如何通过 Amazon A2I 设置主动学习反馈，以优化你的自定义分类模型。

本章将涵盖以下主题：

• 使用带有人工参与的 Comprehend 自定义分类进行主动学习

• 构建文档分类工作流

技术要求

本章需要访问 AWS 账户。请确保按照 技术要求 部分中的说明，通过 第二章，介绍 Amazon Textract，创建你的 AWS 账户，并登录 AWS 管理控制台，然后再执行本章中的步骤。

设置带有人工反馈环节的 Comprehend 自定义分类解决方案的 Python 代码和示例数据集请参考以下链接：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/tree/main/Chapter%2015。

请查看以下视频，观看代码演示：bit.ly/3BiOjKt。

请按照以下各节中的说明，并结合代码库中的代码来构建解决方案。

使用带有人工参与的 Comprehend 自定义分类进行主动学习

Amazon Comprehend 提供了使用 Amazon Comprehend AutoML 分类数据的能力，并允许你使用自定义训练数据集。利用 Amazon Comprehend 自定义分类功能，你可以轻松完成很多任务，因为它要求用于训练 Comprehend AutoML 模型的文档较少。这意味着你花费更少时间在标注数据集上，而不用担心设置基础设施或选择正确的算法。

你可以使用 Amazon Comprehend 自定义分类处理各种用例，例如根据类型对文档进行分类、对新闻文章进行分类，或根据类型对电影进行分类。

虚构公司LiveRight pvt ltd希望在分析文档内容之前，先对客户提交的文档进行分类，例如判断提交的文档是身份证明还是银行对账单。此外，如果你使用分类模型来根据提交的文档类型对文档进行分类，你也希望基于 Amazon Comprehend 自定义分类模型预测的置信度分数，在实时中提高预测结果的准确性。这时，结合亚马逊增强型人工智能（Amazon Augmented AI）的人机协作将发挥作用。

我们在第十三章《提高文档处理工作流的准确性》中介绍了 Amazon A2I。在本章中，我们将带你了解一些参考架构，说明如何使用 Amazon Comprehend 轻松设置自定义分类模型，并与 Amazon A2I 建立反馈回路，以便对你的 Comprehend 自定义模型进行主动学习。

首先，我们将带你了解如何训练一个自定义分类模型，并创建一个实时端点，用于近实时地推断或分类文档。

图 15.1 – Comprehend 自定义分类训练工作流

该架构包括以下步骤：

1. 训练文档，如银行对账单或工资单，被上传到 Amazon S3。

2. Amazon Textract 从这些文档中提取文本，然后进行一些后处理，创建一个标签化的训练文件，用于 Comprehend 自定义分类训练。

3. 使用训练文件，创建一个 Amazon Comprehend 作业来分类文档，如银行对账单或工资单。

4. 训练完成后，你可以选择使用 Amazon Comprehend 执行批量推断，将一批文档分类，或者创建实时端点。在这个架构中，我们展示了如何设置实时端点来分类文档类型。

我们将在解决用例设置部分通过 Jupyter Notebook 和几行 Python 代码，带你了解前述概念架构的实现。

现在，我们有了一个近乎实时的文档分类端点。我们将展示如何使用这个 Amazon Comprehend 自定义分类端点设置人机协作，并通过以下架构建立模型重训练或主动学习循环，以提高模型的准确性：

图 15.2 – 通过模型重训练实现实时分类

在这个架构中，我们将带你完成以下步骤：

1. 客户端应用程序将文档发送给 Amazon Textract。

2. Amazon Textract实时提取数据或文本，并将提取的数据传递到 Amazon Comprehend 实时分类端点。

3. Amazon Comprehend 自定义分类端点将对该文档类型进行分类。

4. 该分类端点配置了 Amazon A2I 人工环节。如果分类预测的置信度高，根据您的业务阈值（您可以配置该阈值），则高置信度预测会直接发送到客户端应用程序。

5. 对于低置信度的预测，例如任何低于 95% 置信度的预测，预测的得分为低置信度。这时会创建一个人工环节，将这些预测发送给人工审核。请参考第三章，介绍 Amazon Comprehend，了解什么是置信度分数以及 Comprehend 的自定义功能。

6. 人工标注者修正或增加的数据会以JSON文件的形式保存在 Amazon S3 存储桶中。

7. 然后，这些数据与原始训练数据集结合，并使用人工反馈对 Amazon Comprehend 自定义模型进行重新训练，以实现主动学习。

我们将带您完成第 1 至第 6 步，使用 Jupyter Notebook 在设置用例部分。您可以自由地将增强的分类标签与原始数据集结合，尝试重新训练以加深理解。您还可以使用步骤函数和 Lambda 函数自动化此架构。我们将在进一步阅读部分与您分享帮助您使用 Lambda 函数设置此架构的博客。

在本节中，我们介绍了模型训练和重新训练或主动学习的架构。接下来，让我们进入下一节，通过代码来展示这些概念。

构建文档分类工作流

在本节中，我们将直接开始执行任务来构建我们的解决方案。但首先，我们需要处理一些前提条件。

设置以解决用例

如果您在前面的章节中还没有完成此操作，您需要先创建一个 Amazon SageMaker Jupyter 笔记本，并设置 Chapter 15 文件夹，打开 chapter15 classify documents with human in the loop.ipynb 笔记本。

现在，让我们进入下一节，向您展示如何设置库并使用此笔记本将训练数据上传到 Amazon S3。

设置并上传样本文档到 Amazon S3

在此步骤中，我们将按照说明设置一个 S3 存储桶并上传文档：

1. 转到笔记本并运行以下 boto 3 单元格进行设置。

2. 继续到下一个单元格，输入一个存储桶名称，以在您的帐户中创建一个 S3 存储桶。在执行此单元格之前，请确保在 data_bucket 中添加当前月份和日期（格式为 MMDD），如下面的代码块所示：

   data_bucket = "doc-processing-bucket-MMDD"
   region = boto3.session.Session().region_name
                  os.environ["BUCKET"] = data_bucket
   os.environ["REGION"] = region
   if region=='us-east-1':
       !aws s3api create-bucket --bucket $BUCKET
   else:
       !aws s3api create-bucket --bucket $BUCKET --create-bucket-configuration LocationConstraint=$REGION
   

3. 现在运行以下单元格，将本地笔记本中的样本银行对账单或工资单图像上传或复制为训练文件，上传到您刚刚创建的 S3 存储桶：

   !aws s3 cp documents/train s3://{data_bucket}/train –recursive
   

4. 现在运行笔记本中的接下来的两个单元，以列出我们刚刚复制到 Amazon S3 中的训练图像。我们创建了一个名为get_s3_bucket_items的函数。我们从 S3 获取图像对象，并将其保存为 Textract 处理的图像，供后续步骤使用。请参考笔记本执行这些步骤。

5. 运行以下步骤，定义一个路径或本地目录结构，以存储从 Amazon Textract 提取的数据：

   word_prefix=os.getcwd()+'/SAMPLE8/WORDS/'
   box_prefix=os.getcwd()+'/SAMPLE8/BBOX/'
   

我们已经介绍了如何创建 S3 存储桶并加载训练数据。接下来，让我们进入提取文本的下一部分。

使用 Amazon Textract 从示例文档中提取文本

转到笔记本并运行步骤 2：使用 Amazon Textract 从示例文档中提取文本中的代码，定义一个函数，使用 Amazon Textract 从 Amazon S3 中的示例图像提取数据。我们正在使用 DetectDocumentText 同步 API 进行提取；你也可以使用异步 API或Textract 批量 API来执行数据提取。请参考第四章，自动化文档处理工作流，深入了解这些 API：

def data_retriever_from_path(path):    
    mapping={}
    for i in names:
        if os.path.isdir(path+i):
            mapping[i] = sorted(os.listdir(path+i))
    label_compre = []
    text_compre = []
    for i, j in mapping.items():
                for k in j:
            label_compre.append(i)
            text_compre.append(open(path+i+"/"+k, encoding="utf-8").read().replace('\n',' '))
    return label_compre, text_compre

这个函数接受图片的路径并返回图片中的文本和标签。

让我们通过运行笔记本中的以下单元，调用这个函数并传入扫描文档的图像：

tic = time.time()
pool = mp.Pool(mp.cpu_count())
pool.map(textract_store_train_LM, [table for table in images ])
print("--- %s seconds for extracting ---" % (time.time() - tic))
pool.close()

上述函数提取数据并将其保存在你在设置并上传示例文档步骤中定义的本地目录结构中。以下是输出结果：

图 15.3 – Textract 输出

现在，我们已经提取了文本和相关标签，例如0代表银行对账单，1代表工资单。接下来，让我们进入 Comprehend 训练的下一部分。

创建 Amazon Comprehend 分类训练任务

在前一步中，我们已经从 Amazon S3 中的扫描文档样本提取了数据和标签。接下来，让我们了解如何使用步骤 3：创建 Amazon Comprehend 分类训练任务在笔记本中设置 Comprehend 分类训练任务：

1. 我们首先创建一个函数，将提取的数据和标签映射到 pandas DataFrame，以便在下一步将其转换为 CSV 训练文件。运行以下代码来定义该函数，它接受提取的数据位置并返回其中的标签和文本：

   def data_retriever_from_path(path):    
       mapping={}
       for i in names:
           if os.path.isdir(path+i):
               mapping[i] = sorted(os.listdir(path+i))
       # label or class or target list
       label_compre = []
       # text file data list
       text_compre = []
       # unpacking and iterating through dictionary
       for i, j in mapping.items():
           # iterating through list of files for each class
           for k in j:
               # appending labels/class/target
               label_compre.append(i)
               # reading the file and appending to data list
               text_compre.append(open(path+i+"/"+k, encoding="utf-8").read().replace('\n',' '))
       return label_compre, text_compre
   

2. 现在，我们将通过运行以下代码调用之前定义的函数：

   label_compre, text_compre=[],[]
   path=word_prefix+'train/'
   label_compre_train, text_compre_train=data_retriever_from_path(path)
   label_compre.append(label_compre_train)
   text_compre.append(text_compre_train)
   if type(label_compre[0]) is list:
           label_compre=[item for sublist in label_compre for item in sublist]
           #print(label_compre)
           text_compre=[item for sublist in text_compre for item in sublist]
           #print(text_compre)
   data_compre= pd.DataFrame()
   data_compre["label"] =label_compre   
   data_compre["document"] = text_compre
   data_compre
   

   你将获得一个包含标签和文档的 pandas DataFrame，内容如下所示：

   

   图 15.4 – 带标签的训练 DataFrame

3. 现在，我们将把这个 DataFrame 保存为 CSV 文件，并使用 S3 上传到 Amazon S3。将boto3 API 对象作为 Amazon Comprehend 训练文件进行训练：

   csv_compre=io.StringIO()
   data_compre.to_csv(csv_compre,index=False, header=False)
   key='comprehend_train_data.csv'  
   input_bucket=data_bucket        
   output_bucket= data_bucket       
   response2 = s3.put_object(
           Body=csv_compre.getvalue(),
           Bucket=input_bucket,
           Key=key)
   

4. 现在，访问 Amazon Comprehend 控制台链接（https://console.aws.amazon.com/comprehend/v2/home?region=us-east-1#classification）创建分类作业。点击 Train Classifier。

5. 在 doc-classifier 中，选择 1，然后向下滚动选择 csv 文件。

   重要提示

   我们可以为 Amazon Comprehend 自定义模型添加版本。要了解更多关于此功能的信息，请参考此链接：docs.aws.amazon.com/comprehend/latest/dg/model-versioning.html。

   

   图 15.5 – Amazon Comprehend 自定义分类 UI

6. 对于训练数据位置，浏览到 doc-processing-bucket-MMDD S3 桶，该桶位于 s3://doc-processing-bucket-MMDD/comprehend_train_data.csv。

7. 对于 Autosplit，这意味着 Amazon Comprehend 会自动为您拆分测试数据。您也可以选择通过提供自己的测试数据集来调整模型。

8. 对于输出数据，请输入 s3://doc-processing-bucket-MMDD S3 桶。

9. 对于访问权限，在 NameSuffix 中选择 classifydoc。

   图 15.6 – Amazon Comprehend 自定义分类 IAM 设置

10. 向下滚动并点击 Train Classifier 按钮开始训练。

    重要提示

    此训练将花费 30 分钟完成，因为本章中我们有大量文档需要训练。您可以利用这段时间设置一个私人工作队伍，为设置人类参与环节做准备，正如我们在第十三章中所做的，提高文档处理工作流的准确性。

一旦您的任务完成，继续进行下一步。

创建 Amazon Comprehend 实时端点并测试示例文档

在本节中，我们将展示如何在AWS 管理控制台中使用训练后的模型创建实时端点。Comprehend 使用推理单元（IU）来分析每秒钟可以实时分析多少个字符。IU 是端点吞吐量的度量。您可以随时调整端点的 IU。创建端点后，我们将展示如何使用 Jupyter Notebook 调用此端点来测试一个示例银行对账单：

1. 访问此链接，https://console.aws.amazon.com/comprehend/v2/home?region=us-east-1#endpoints，并点击 创建端点。

2. 输入 classify-doc 作为端点名称，设置我们在上一步中训练的 doc-classifier，并将推理单元设置为 1。

   图 15.7 – Amazon Comprehend 创建实时端点 UI

3. 向下滚动并选择 I Acknowledge，然后点击 创建端点。

   在笔记本的清理部分删除此端点，以避免产生费用。

4. 现在，复制下一张截图中显示的ARN，然后前往 Jupyter Notebook 链接：

   图 15.8 – Comprehend 自定义分类终端节点 ARN

5. 在笔记本中，按如下方式将之前复制的终端节点 ARN 输入到笔记本单元格中：

   ENDPOINT_ARN='your endpoint arn paste here'
   

6. 现在，我们将使用一个示例测试文档或任何未在训练中使用的薪资单进行实时分类。运行以下代码来查看示例薪资单：

   documentName = "paystubsample.png"
   display(Image(filename=documentName))
   

   你将获得以下输出：

   

   图 15.9 – 示例薪资单文档

7. 在使用 Textract 从此示例文档提取文本部分运行接下来的两个单元格，以提取此示例文档中的文本。

8. 运行以下单元格，它调用 Comprehend 的 ClassifyDocument API。此方法将提取的文本和自定义分类终端节点传递给 API，并返回一个响应：

   response = comprehend.classify_document(
       Text= page_string,
       EndpointArn=ENDPOINT_ARN
   )
   print(response)
   

   你将得到以下响应：

图 15.10 – ClassifyDocument 响应

根据响应，模型终端节点已经将文档分类为薪资单，置信度为 99%。我们已经测试了这个终端节点，现在让我们进入下一部分，设置人工环路。

使用实时终端节点和人工环路设置主动学习，结合 Comprehend

在本节中，我们将向你展示如何与 Comprehend 分类终端节点进行自定义集成，你可以使用 A2I StartHumanLoop API 调用此集成。你可以将任何类型的 AI/ML 预测响应传递给此 API 来触发人工环路。在第十三章中，提高文档处理工作流的准确性，我们通过将人工环路工作流 ARN 传递给 AnalyzeDocument API，向你展示了与 Textract Analyze 文档 API 的原生集成。设置自定义工作流包括以下步骤：

1. 创建一个工作任务模板。

2. 创建一个人工审核工作流。

3. 创建并启动 A2I 人工环路。

4. 检查人工环路状态并开始标注。

要开始，你需要创建一个私人工作团队，并在 Jupyter Notebook 中的环境设置步骤中复制私人 ARN：

1. 要创建一个私人工作团队，请参考第十三章中的在 AWS 控制台创建私人工作团队部分，提高文档处理工作流的准确性：

   REGION = 'enter your region'
   WORKTEAM_ARN= "enter your private workforce arn "
   BUCKET = data_bucket
   ENDPOINT_ARN= ENDPOINT_ARN
   role = sagemaker.get_execution_role()
   region = boto3.session.Session().region_name
   prefix = "custom-classify" + str(uuid.uuid1())
   

2. 运行下一个单元并转到创建工作任务模板。这是工作人员在标注时将要查看的 UI。我们将在 UI 中显示预测结果和原始文档数据。我们已经为此用例使用了一个预构建的分类模板（github.com/aws-samples/amazon-a2i-sample-task-uis/blob/master/text/document-classification.liquid.html）。运行笔记本单元来定义 HTML 模板。

   重要提示

   你可以根据希望向标注者展示的数据类型，创建自定义的 UI HTML 模板。例如，你可以在右侧显示实际文档，在左侧高亮显示实体，使用自定义 UI。

3. 我们在前一步中定义或选择了 HTML 模板，在此模板中，我们将通过运行以下代码，使用create_human_task_ui API 创建一个 UI 任务：

   def create_task_ui():
       response = sagemaker.create_human_task_ui(
           HumanTaskUiName=taskUIName,
           UiTemplate={'Content': template})
   return response
   

4. 运行下一个单元来调用前一步中定义的创建 UI 任务的函数。你将获得一个human task arn响应。

5. 现在，我们将定义一个人工审核工作流。这个人工审核工作流需要你创建的私人劳动力、你创建的 UI 模板任务，以及你希望将人工审核输出保存到的数据桶。我们将使用sagemaker.create_flow_definition API，通过运行以下代码创建一个工作流定义或人工审核工作流：

   create_workflow_definition_response = sagemaker.create_flow_definition(
           FlowDefinitionName= flowDefinitionName,
           RoleArn= role,
           HumanLoopConfig= {
               "WorkteamArn": WORKTEAM_ARN,
               "HumanTaskUiArn": humanTaskUiArn,
               "TaskCount": 1,
               "TaskDescription": "Read the instructions",
               "TaskTitle": "Classify the text"
           },
           OutputConfig={
               "S3OutputPath" : "s3://"+BUCKET+"/output"
           }
   
   flowDefinitionArn = create_workflow_definition_response['FlowDefinitionArn']
   

6. 现在，我们将从 Comprehend 自定义分类器端点获取工资单示例数据的响应，并解析此响应以设置人工循环：

   response = comprehend.classify_document(
       Text= page_string,
       EndpointArn=ENDPOINT_ARN
   )
   print(response)
   p = response['Classes'][0]['Name']
   score = response['Classes'][0]['Score']
           #print(f»S:{sentence}, Score:{score}»)
   response = {}
   response['utterance']=page_string
   response['prediction']=p
   response['confidence'] = score
   print(response)
   

7. 现在，使用这个前面的 JSON 响应，我们将设置一个信心阈值。这个StartHumanloop API 需要前一步创建的工作流 ARN 或流定义 ARN 以及 Comprehend 分类的 JSON 响应，以创建人工循环。我们将根据信心评分阈值触发这个循环，如下一个代码块所示：

   human_loops_started = []
   CONFIDENCE_SCORE_THRESHOLD = .90
   if(response['confidence'] > CONFIDENCE_SCORE_THRESHOLD):
           humanLoopName = str(uuid.uuid4())
           human_loop_input = {}
   
           human_loop_input['taskObject'] = response['utterance']
           start_loop_response = a2i_runtime_client.start_human_loop(
           HumanLoopName=humanLoopName,
           FlowDefinitionArn=flowDefinitionArn,
           HumanLoopInput={
                   "InputContent": json.dumps(human_loop_input)
               }
           )
           print(human_loop_input)
           human_loops_started.append(humanLoopName)
           print(f'Score is less than the threshold of {CONFIDENCE_SCORE_THRESHOLD}')
           print(f'Starting human loop with name: {humanLoopName}  \n')
   else:
            print('No human loop created. \n')
   

   重要提示

   前面的条件说明，任何大于 90%信心的模型端点输出将触发一个循环。这个阈值仅用于演示目的，实际使用时需要更改，例如，低于 90%时触发人工循环。

8. 现在，运行以下代码以获取私人工作团队的链接，开始标注工作：

   workteamName = WORKTEAM_ARN[WORKTEAM_ARN.rfind('/') + 1:]
   print("Navigate to the private worker portal and do the tasks. Make sure you've invited yourself to your workteam!")
   print('https://' + sagemaker.describe_workteam(WorkteamName=workteamName)['Workteam']['SubDomain'])
   

   你将获得以下 A2I 门户的链接：

   

   图 15.11 – 亚马逊 A2I 登录控制台

9. 选择任务标题并点击开始工作；你将被重定向到分类任务 UI。

   图 15.12 – 亚马逊 A2I 示例分类任务 UI

   查看前一截图左侧的数据，并通过选择工资单类别进行分类，然后点击提交。

10. 提交此分类任务作为人工审查后，返回笔记本并运行以下代码，获取已完成的任务：

    completed_human_loops = []
    resp = a2i_runtime_client.describe_human_loop(HumanLoopName=humanLoopName)
    

11. 现在，我们将审查从已完成的人工审查中获得的结果，这些结果会自动存储为 JSON 文件在 Amazon S3 中，你可以通过运行以下代码来查看：

    for resp in completed_human_loops:
        splitted_string = re.split('s3://' + data_bucket  + '/', resp['HumanLoopOutput']['OutputS3Uri'])
        output_bucket_key = splitted_string[1]
        response = s3.get_object(Bucket=data_bucket, Key=output_bucket_key)
        content = response["Body"].read()
        json_output = json.loads(content)
        pp.pprint(json_output)
    

    你将收到以下响应：

图 5.13 – 人工审查的 JSON 响应

利用这些数据，你可以扩展或丰富用于训练的现有数据集。试着将这些数据与我们创建的 Comprehend 训练数据结合，尝试重新训练你的模型以提高准确率。我们将在进一步阅读部分中提供一些博客链接，帮助你完成这一步。

重要提示

请删除我们在此笔记本中创建的模型和 Comprehend 端点。

总结

在这一章中，我们通过参考架构和代码演示讲解了两件事。首先，我们讲解了如何使用 Amazon Textract 从各种类型的文档中提取数据，如工资单、银行对账单或身份证。然后，我们学习了如何进行一些后处理操作，以创建用于 Amazon Comprehend 自定义分类训练的标签化训练文件。

我们向你展示了，即使只有 36 份银行对账单和 24 份工资单作为训练样本，你也可以通过使用 Amazon Comprehend 的迁移学习能力和 AutoML 进行文档或文本分类，获得非常好的准确率。显然，随着数据量的增加，准确率会提高。

接着，你学习了如何在 AWS 管理控制台中设置训练任务，以及如何在 AWS 管理控制台中设置实时分类端点。

其次，你学习了如何使用实时分类端点设置“人类在环”系统，以审查/验证和确认模型所分类的内容。我们还讨论了如何通过将这些数据与现有的训练数据一起添加，来重新训练现有的模型，并设置一个重新训练或主动学习循环。请参阅进一步阅读部分，了解如何使用 Lambda 函数自动化此工作流。

在下一章中，我们将讨论如何利用 Amazon Textract 和“人类在环”系统提高PDF 批量处理的准确性。敬请期待！

进一步阅读

• Amazon Comprehend 自定义分类模型的主动学习工作流 - 第二部分，Shanthan Kesharaju, Joyson Neville Lewis 和 Mona Mona (aws.amazon.com/blogs/machine-learning/active-learning-workflow-for-amazon-comprehend-custom-classification-part-2/)%20)

• 创建和使用自定义分类器（*docs.aws.amazon.com/comprehend/latest/dg/getting-started-document-classification.html）

第十六章：第十六章：提高 PDF 批处理的准确性

恭喜你走到了这本书的这一阶段！此时，你已经是一个能够利用 NLP 和 AI 的力量，构建实际应用以带来实际业务效益的高级开发者。你可能没有意识到，但我们到目前为止讨论的主题——以及我们接下来要继续讨论的内容——解决了一些最受欢迎、最具需求的商业挑战，这是我们帮助客户解决的问题之一。智能文档处理（IDP）是目前非常热门的需求，几乎在每个行业中都有广泛应用。我们从第十三章《提高文档处理工作流的准确性》开始阅读，了解了Amazon A2I（aws.amazon.com/augmented-ai/）在简化和提高 ML 工作流中人工审阅的准确性方面所发挥的关键作用，从而在过程中启用了主动学习。

在本章中，我们将解决一个已经存在了一段时间、普遍存在、但组织在高效处理上仍然面临困难的操作需求。这就是所谓的PDF 批处理。可以将其视为设置一个自动化文档处理工作流（类似于我们在前几章中构建的工作流），但它增加了批量处理 PDF 文档的灵活性，并结合智能技术，能够自动将文档中某些文本段落路由给人工审阅，原因是由于低置信度检测引起的无法辨认或错误的文本。

到现在为止，由于你在实施先进的 AI 解决方案方面的辛勤努力，LiveRight Holdings的盈利已经飙升。这个增长使得 LiveRight 开始将几个子公司独立出来，成为各自独立的组织，董事会决定这三家公司将在中期公开上市。你已经晋升为 LiveRight 的首席运营架构师，CIO 将任务交给你，要求你构建必要的组件，以便将三家公司作为公开交易公司注册到证券交易委员会（SEC）。

在本章中，我们将讨论以下主题：

• 介绍 PDF 批处理使用案例

• 构建解决方案

技术要求

本章内容需要你访问一个 AWS 账户，你可以通过访问aws.amazon.com/console/来获取。有关如何注册 AWS 账户并登录到AWS 管理控制台的详细说明，请参考第二章《介绍 Amazon Textract》中的注册 AWS 账户子章节。

本章节中讨论的解决方案的 Python 代码和示例数据集可以在本书的 GitHub 仓库中找到：github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/tree/main/Chapter%2016。

请查看以下视频，了解代码如何运行：bit.ly/3nobrCo。

引入 PDF 批处理处理用例

要确定架构的样子，你需要与财务部门沟通，了解如何将公司注册到美国证券交易委员会（SEC）的流程。根据该流程，财务部门将使用 SEC 的注册模板生成 PDF 文件，该模板也被称为Form S20（www.sec.gov/files/forms-20.pdf）。该流程还包括创建所有支持文档，并将这些文档与注册信息一同通过 API 调用发送给 SEC。LiveRight 的Partner Integration团队已经与 SEC 达成了合作协议，他们需要将表单数据存储在Amazon DynamoDB（aws.amazon.com/dynamodb/）表中，供他们用于创建向 SEC API 发送消息的调用。

然而，在将数据提供给 Partner Integration 团队之前，财务团队提到，他们需要审核一部分在 PDF 文档中检测到的文本行，特别是那些可能由于文档质量问题而未正确解析的文本。

通过这些信息，你意识到需要在文档处理解决方案中添加一个批处理组件。这将使得能够批量检测 PDF 文档中的文本，并将那些低于置信度阈值的文本行引导至人工审核环节，由财务团队成员进行审核。你决定使用Amazon Textract提供的异步文档文本检测 API，借助其预训练的机器学习模型从 PDF 文档中提取文本，使用Amazon A2I设置人工工作流，审核和修改那些置信度低于 95%的文本，同时利用 Amazon DynamoDB 存储原始检测到的文本以及修正后的内容，供 Partner Integration 团队使用。

我们将使用 Amazon SageMaker Jupyter 笔记本构建我们的解决方案，这将允许我们在逐步执行代码时查看代码和结果。我们将执行以下任务：

1. 作为第一步，我们将使用 Amazon SageMaker 控制台创建一个私有标签工作队伍进行人工审核。更多详情，请参考docs.aws.amazon.com/sagemaker/latest/dg/sms-workforce-private.html。

2. 我们将通过检查从 GitHub 仓库克隆的本章示例注册表单来启动解决方案工作流。我们将使用 Amazon Textract 启动一个异步文本检测任务。

3. 然后，我们将获取文本检测任务的结果，从文档中选择特定行，并检查检测置信度分数。

4. 我们将使用表格任务 UI 模板设置一个 Amazon A2I 人工审查循环，并将每个文档中的文本行发送到人工循环中。

5. 以私人工作者身份登录后，我们将处理分配的审查任务，对所有文档中检测置信度较低的文本行进行修改。

6. 我们将把检测到并修正的文本行上传到 DynamoDB 表中，以便进行后续处理。

现在我们已经了解了本次练习的背景并过了一遍我们的流程，接下来让我们开始构建解决方案。

构建解决方案

在上一节中，我们介绍了我们的用例——将公司注册提交给 SEC 进行公开交易，涵盖了我们将要构建的解决方案的架构，并简要介绍了解决方案组件和工作流步骤。在这一节中，我们将直接进入正题，开始执行构建解决方案的任务。但首先，我们需要处理一些先决条件。

为解决方案构建做准备

如果你在之前的章节中没有做过，你需要创建一个 Amazon SageMaker Jupyter 笔记本，并设置身份与访问管理（IAM）权限，允许该笔记本角色访问我们将在本笔记本中使用的 AWS 服务。之后，你还需要克隆本书的 GitHub 仓库（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services），创建一个 Amazon S3（aws.amazon.com/s3/）存储桶，并在笔记本中提供存储桶的名称以开始执行。

注意

请确保你已经完成了技术要求部分中提到的任务。

请按照以下步骤完成这些任务，然后我们就可以执行笔记本中的单元格了：

1. 按照第二章中设置 AWS 环境部分的创建 Amazon SageMaker Jupyter 笔记本实例子节中的说明，创建你的 Jupyter 笔记本实例。

   创建 Amazon SageMaker Jupyter 笔记本时的 IAM 角色权限

   在创建笔记本时接受默认的 IAM 角色，以允许访问任何 S3 存储桶。

2. 一旦你创建了笔记本实例并且其状态为InService，点击笔记本实例的操作菜单中的打开 Jupyter。

3. 这将带你到笔记本实例的首页文件夹。

4. 点击 New 并选择 Terminal。

5. 在终端窗口中，输入 cd SageMaker 然后 git clone https://github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services。

6. 现在，退出终端窗口，返回到主文件夹，您将看到一个名为 Natural-Language-Processing-with-AWS-AI-Services 的文件夹。点击该文件夹以显示章节文件夹，并点击 Chapter 16。

7. 通过点击打开该文件夹，您应该看到一个名为 Improve-accuracy-of-pdf-processing-with-Amazon-Textract-and-Amazon-A2I-forGitHub.ipynb 的笔记本。

8. 点击打开此笔记本。

9. 按照本笔记本中与本节接下来的子标题相对应的步骤，逐个执行每个单元格。请阅读添加到每个笔记本单元格中的描述。

接下来，我们将介绍一些额外的 IAM 前提条件。

额外的 IAM 前提条件

我们需要为我们的 SageMaker Notebook 角色启用额外的策略。请参阅 第二章 中的 更改 IAM 权限和信任关系以执行 Amazon SageMaker Notebook 角色 子章节，介绍 Amazon Textract 部分，了解如何执行以下步骤的详细说明：

1. 如果尚未执行，请将 TextractFullAccess 和 AmazonAugmentedAIFullAccess 策略附加到您的 Amazon SageMaker Notebook IAM 角色。

2. 将 iam:PassRole 权限作为内联策略添加到您的 SageMaker Notebook 执行角色中：

   { "Version": "2012-10-17", "Statement": [ {
     "Action": [
         "iam:PassRole"
     ],
     "Effect": "Allow",
     "Resource": "<your sagemaker notebook execution role ARN">
     }
    ]
   }
   

现在，我们已经设置好了笔记本并配置了运行演练笔记本的 IAM 角色，接下来我们将创建私有标注工作队。

为人工循环创建一个私有团队

请参考笔记本中的 Step 0（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2016/Improve-accuracy-of-pdf-processing-with-Amazon-Textract-and-Amazon-A2I-forGitHub.ipynb），以了解我们现在将执行的指令。在本节中，我们将使用 Amazon SageMaker 标注工作队控制台创建一个私有团队，并将我们自己作为工人添加到私有团队中。这是为了确保在此解决方案中的 Amazon A2I 步骤时，我们能够登录到标注任务 UI。请执行以下步骤：

1. 如果您尚未登录 AWS 管理控制台（请参阅本章开头的 技术要求 部分以了解更多详细信息），请在 Services 搜索栏中输入 Amazon SageMaker 并进入 Amazon SageMaker 控制台。进入控制台后，在 UI 左侧，点击 Ground Truth，然后选择 Labelling workforces。在屏幕上，选择顶部的 Private 标签并点击 Create private team。

2. 在团队名称字段中输入您的私人团队名称，并保持创建一个新的 Amazon Cognito 用户组为默认选择，保持在添加工作人员部分。向下滚动并点击创建私人团队。

3. 您将返回到nlp-doc-team团队，并应在arn:aws:sagemaker:region-name-123456:workteam/private-crowd/team-name下可见。请复制此 ARN 并在笔记本的步骤 1 – 单元格 1中提供它：

   WORKTEAM_ARN= '<your-private-workteam-arn>'
   

4. 接下来，向下滚动到前一个屏幕，进入 no-reply@verificationemail.com。按照提供的说明完成注册过程。

5. 现在，点击nlp-doc-team，然后点击向团队添加工作人员，将自己添加到私人团队中。从列表中选择您的电子邮件地址并点击向团队添加工作人员。

现在我们已经添加了私人团队，接下来创建一个 Amazon S3 存储桶。

创建一个 Amazon S3 存储桶

请按照 第二章中设置您的 AWS 环境部分的创建一个 Amazon S3 存储桶、文件夹并上传对象小节中的说明，创建您的 Amazon S3 存储桶。如果您在前面的章节中创建了 S3 存储桶，请重复使用该存储桶。本章仅需创建 S3 存储桶。我们将在笔记本中直接创建文件夹并上传对象：

1. 获取存储桶名称后，请在笔记本中的步骤 1 – 单元格 1中输入它：

   bucket = "<S3-bucket-name>"
   

2. 通过点击笔记本 UI 顶部菜单中的步骤 1 – 单元格 1的运行按钮来执行。这样将导入我们需要的库，初始化变量，并为下一组步骤准备好内核。

3. 最后，在笔记本中执行步骤 1 – 单元格 2，将注册文档上传到我们的 S3 存储桶：

   s3_client = boto3.client('s3')
   for secfile in os.listdir():
       if secfile.endswith('pdf'):
           response = s3_client.upload_file(secfile, bucket, prefix+'/'+secfile)
           print("Uploaded {} to S3 bucket {} in folder {}".format(secfile, bucket, prefix))
   

现在我们已经创建了 S3 存储桶，导入了所需的库，并将文档上传到 S3 存储桶，接下来使用Amazon Textract提取内容。

使用 Amazon Textract 提取注册文档的内容

本节对应于笔记本中的步骤 2和步骤 3（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2016/Improve-accuracy-of-pdf-processing-with-Amazon-Textract-and-Amazon-A2I-forGitHub.ipynb）。在本节中，我们将使用 Amazon Textract 提交一个异步文本检测作业。作业完成后，我们将获得文本检测的结果，并将其加载到pandas DataFrame中（pandas.pydata.org/docs/reference/api/pandas.DataFrame.html），选择我们需要的文本行并审查结果。请使用上述笔记本按照这些步骤执行单元格，以完成所需的任务：

1. 执行步骤 2 – 单元格 1来定义存储桶句柄，并声明一个字典，用于存储每个文档的 Textract 作业 ID：

   input_bucket = s3.Bucket(bucket)
   jobids = {}
   

2. 执行NotificationChannel属性作为 Textract StartDocumentTextDetection API 的输入（docs.aws.amazon.com/textract/latest/dg/API_StartDocumentTextDetection.html），以指示作业完成时，消息将发送到的 Amazon SNS（aws.amazon.com/sns）主题。您可以设置 AWS Lambda 来订阅该主题，并在收到消息后调用 Textract GetDocumentTextDetection API（docs.aws.amazon.com/textract/latest/dg/API_GetDocumentTextDetection.html）以检索提取的文本。我们将在笔记本中执行该 API，在步骤 3 – 单元格 1中。

3. 最后，执行步骤 2 – 单元格 3来打印每个文档的作业 ID：

   for j in jobids:
       print("Textract detection Job ID for {} is {}".format(j,str(jobids[j])))
   

4. 现在，我们必须进入笔记本中的步骤 3。在这里，我们将定义帮助类来解析来自 Textract 的 JSON 响应。然后，我们将需要的文本行加载到字典中，在后续步骤中使用。点击笔记本中的运行以执行步骤 3 – 单元格 1。

5. 执行df_indoc：

   text_extractor = TextExtractor()
   indoc = {}
   df_indoc = pd.DataFrame(columns = ['DocName','LineNr','DetectedText','Confidence', 'CorrectedText', 'Comments'])
   for x in jobids:
       pages = text_extractor.extract_text(jobids[x])
       contdict =pages[1]['Content']
       for row in range(1,(int(len(contdict)/2))+1):
           df_indoc.loc[len(df_indoc.index)] = [x, row, contdict['Text'+str(row)], round(contdict['Confidence'+str(row)],1),'','']
   

6. 执行步骤 3 – 单元格 3以定义筛选条件，指定在审查注册文件时哪些文本行对我们重要。最后，执行步骤 3 – 单元格 4以创建一个新的 DataFrame，其中只包含我们感兴趣的文本行：

   df_newdoc = pd.DataFrame(columns = ['DocName','LineNr','DetectedText','Confidence','CorrectedText','Comments'])
   for idx, row in df_indoc.iterrows():
       if str(row['LineNr']) in bounding_dict['lines'].split(':'):
           df_newdoc.loc[len(df_newdoc.index)] = [row['DocName'],row['LineNr'], row['DetectedText'], row['Confidence'], row['CorrectedText'],row['Comments']]
   df_newdoc
   

7. DataFrame 的结果显示在下面的屏幕截图中。这里高亮显示了一些低置信度条目：

图 16.1 – 来自 SEC 注册文件的文本行

注意

由于这些文本条目是故意在 PDF 文档中引入的，以触发低置信度的预测，因此它们显示为乱码。

现在我们已经将注册文件中需要的文本数字化，让我们开始设置使用 Amazon A2I 的人工审核工作流。

设置一个 Amazon A2I 人工工作流循环

对于这里讨论的代码块，请参考笔记本中的步骤 4、步骤 5和步骤 6（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/blob/main/Chapter%2016/Improve-accuracy-of-pdf-processing-with-Amazon-Textract-and-Amazon-A2I-forGitHub.ipynb）。现在是时候使用我们在步骤 0中创建的私人团队设置一个人工工作流，并将结果发送到Amazon A2I人工循环进行审核和修改，如有必要：

1. 让我们从初始化一些我们在接下来任务中需要的变量开始。请执行笔记本中的步骤 4 – 单元格 1。

2. 执行步骤 4 – 单元格 2，在笔记本中定义我们将用于人工审核活动的任务 UI 模板。我们从 Amazon A2I 样本任务 UI 的 GitHub 仓库中选择了适用于表格数据的任务模板（github.com/aws-samples/amazon-a2i-sample-task-uis），并根据我们的需求进行了定制。

3. 执行步骤 4 – 单元格 3，根据模板创建任务 UI：

   def create_task_ui():
           response = sagemaker.create_human_task_ui(
           HumanTaskUiName=taskUIName,
           UiTemplate={'Content': template})
       return response
   # Create task UI
   humanTaskUiResponse = create_task_ui()
   humanTaskUiArn = humanTaskUiResponse['HumanTaskUiArn']
   print(humanTaskUiArn)
   

4. 我们将获得以下输出：

   arn:aws:sagemaker:us-east-1:<aws-account-nr>:human-task-ui /ui-pdf-docs-<timestamp>
   

5. 现在，执行笔记本中的步骤 5 – 单元格 1，创建一个Amazon A2I 流定义，以协调任务与工作队伍，并收集输出数据：

   create_workflow_definition_response = sagemaker_client.create_flow_definition(
           FlowDefinitionName=flowDefinitionName,
           RoleArn=role,
           HumanLoopConfig= {
               "WorkteamArn": WORKTEAM_ARN,
               "HumanTaskUiArn": humanTaskUiArn,
               "TaskCount": 1,
               "TaskDescription": "Review the contents and correct values as indicated",
               "TaskTitle": "SEC Registration Form Review"
           },
           OutputConfig={
               "S3OutputPath" : OUTPUT_PATH
           }
       )
   flowDefinitionArn = create_workflow_definition_response['FlowDefinitionArn'] # let's save this ARN for future use
   

6. 执行步骤 5 – 单元格 2，启动人工工作流循环：

   for x in range(60):
       describeFlowDefinitionResponse = sagemaker_client.describe_flow_definition(FlowDefinitionName=flowDefinitionName)
       print(describeFlowDefinitionResponse ['FlowDefinitionStatus'])
       if (describeFlowDefinitionResponse ['FlowDefinitionStatus'] == 'Active'):
           print("Flow Definition is active")
           break
       time.sleep(2)
   

7. 我们将获得以下结果：

   Initializing
   Active
   Flow Definition is active
   

8. 执行步骤 6 – 单元格 1，将注册文件第一页的扫描图像上传到我们的 S3 存储桶。我们将在 Amazon A2I 任务 UI 中引用这些图像：

   reg_images = {}
   for image in os.listdir():
       if image.endswith('png'):
           reg_images[image.split('_')[0]] = S3Uploader.upload(image, 's3://{}/{}'.format(bucket, prefix))
   

9. 执行步骤 6 – 单元格 2，为我们用例中的所有三份注册文件启动人工循环。在此单元格中，我们将为每个人工循环创建一个随机名称，选择每份文件中低于 95%置信度阈值的特定行，并将这些输入发送到 Amazon A2I 的StartHumanLoop API 调用（docs.aws.amazon.com/augmented-ai/2019-11-07/APIReference/API_StartHumanLoop.html）：

   humanLoopName = {}
   docs = df_newdoc.DocName.unique()
   # confidence threshold
   confidence_threshold = 95
   for doc in docs:
       doc_list = []
       humanLoopName[doc] = str(uuid.uuid4())
       for idx, line in df_newdoc.iterrows():
           # Send only those lines whose confidence score is less than threshold
           if line['DocName'] == doc and line['Confidence'] <= confidence_threshold:
               doc_list.append({'linenr': line['LineNr'], 'detectedtext': line['DetectedText'], 'confidence':line['Confidence']})
       ip_content = {"document": doc_list,
                 'image': reg_images[doc.split('.')[0]]
                }                
       start_loop_response = a2i.start_human_loop(
               HumanLoopName=humanLoopName[doc],
               FlowDefinitionArn=flowDefinitionArn,
               HumanLoopInput={
                   "InputContent": json.dumps(ip_content)
               }
           )
   

10. 执行步骤 6 – 单元格 3，检查我们人工循环的状态；状态应为进行中：

    completed_human_loops = []
    for doc in humanLoopName:
        resp = a2i.describe_human_loop(HumanLoopName=humanLoopName[doc])
        print(f'HumanLoop Name: {humanLoopName[doc]}')
        print(f'HumanLoop Status: {resp["HumanLoopStatus"]}')
        print(f'HumanLoop Output Destination: {resp["HumanLoopOutput"]}')
        print('\n')
    

11. 现在，我们将登录到 Amazon A2I 任务 UI，审查并修改文本行。让我们登录到工作人员门户，审查预测并根据需要进行修改。执行步骤 6 – 单元格 4，获取我们的任务 UI 的 URL：

    workteamName = WORKTEAM_ARN[WORKTEAM_ARN.rfind('/') + 1:]
    print("Navigate to the private worker portal and do the tasks. Make sure you've invited yourself to your workteam!")
    print('https://' + sagemaker.describe_workteam(WorkteamName=workteamName)['Workteam']['SubDomain'])
    

12. 使用你在步骤 0中设置的凭据登录任务 UI，凭据是在创建标注工作队时设置的。你会看到一个名为SEC 注册表单审核的任务。选择它并点击开始工作。

13. 原始注册表单的第一页将显示：

    图 16.2 – 任务 UI 显示带有难以辨认文本的注册表单图像

14. 向下滚动页面，找到一个表格，显示 Textract 检测到的内容、文本行的置信度分数、一个单选按钮用于检查我们是否认为检测到的文本是正确还是错误、一个输入区域用于修改检测到的文本，还有一个评论字段。修改表格后，点击页面左下角的提交按钮：

    图 16.3 – Amazon A2I 中的文档修改页面

15. 现在，任务 UI 将刷新，显示我们提交给 Amazon A2I 进行人工审核的三个文档中的下一个文档。重复前述两步，审查图像，滚动表格以进行修改，并点击提交。你还需要为最后一个文档重复此过程。

16. 完成所有三个文档的更改并提交任务后，返回笔记本，执行步骤 6 – 单元格 5以检查人工审核环节的状态。所有三个人工审核环节的状态将为已完成。

17. 最后，执行笔记本中的步骤 6 – 单元格 7，以获取人工审核员所做的更改，并将其添加到我们的 DataFrame 中。检查 DataFrame 时，我们将看到以下结果：

图 16.4 – A2I 人工审核结果已更新

在本节中，我们通过使用 Amazon Textract 异步 API 从多个 PDF 文档中提取文本，涵盖了此解决方案的大部分处理需求。之后，我们使用 Amazon A2I 设置了一个人工审核环节，审查并修正低置信度的文本检测结果。作为我们解决方案的最后一步，我们将保存我们的活动结果。

为下游处理存储结果

现在我们已经了解如何设置审核工作流，接下来让我们将结果持久化，以便下游应用程序使用。我们将在本节中执行笔记本中的步骤 7：

1. 执行步骤 7 – 单元格 1来创建一个Amazon DynamoDB表，这是一个用于存储和访问键值对的托管数据库服务，具有非常低的延迟。

2. 执行步骤 7 – 单元格 2来将我们的 DataFrame 内容上传到 DynamoDB 表：

   for idx, row in df_newdoc.iterrows():
       table.put_item(
          Item={
           'row_nr': idx,
           'doc_name': str(row['DocName']) ,
           'line_nr': str(row['LineNr']),
           'detected_line': str(row['DetectedText']),
           'confidence': str(row['Confidence']),   
           'corrected_line': str(row['CorrectedText']),
           'change_comments': str(row['Comments'])   
           }
       )
   print("Items were successfully created in DynamoDB table")
   

3. 值将被插入到 DynamoDB 表中，如下所示：

图 16.5 – 在 DynamoDB 中纠正的注册文档条目

解决方案构建到此结束。请参考 进一步阅读 部分，以获取使用 AWS Lambda 和 CloudFormation 构建类似解决方案的代码示例。

总结

在本章中，我们继续构建先进的 NLP 解决方案，以应对现实世界的需求。我们重点讨论了异步处理 PDF 文档，并通过使用 Amazon Textract 和 Amazon A2I 审查和修改低置信度检测结果来提高其准确性。

我们了解了如何为需要提取文本的公司注册到 SEC 使用案例，然后验证并修改文档中的特定文本行，以便在提交给合作伙伴集成团队进行提交到 SEC 之前进行处理。我们考虑了一个为扩展性和易于设置而构建的架构。我们假设你是负责监督该项目的首席架构师，然后我们在 介绍 PDF 批处理使用案例 部分概述了解决方案组件。

接下来，我们讨论了解决方案构建的先决条件，设置了一个 Amazon SageMaker Notebook 实例，克隆了我们的 GitHub 仓库，并根据本章提供的说明开始执行 Notebook 中的代码。我们涉及了使用 Amazon SageMaker 标注工作队伍设置私有工作团队，使用 Amazon Textract 以批处理模式从 PDF 文档中提取相关内容，将检测结果转发到 Amazon A2I 人工审核循环，使用 UI 完成人工任务步骤，审查结果，并将文档内容及其修改存储到 Amazon DynamoDB 表中，以便后续处理。

在下一章中，我们将讨论 Amazon Textract 的另一个有趣功能——手写检测，以及如何设置解决方案来检测手写内容，以供审查、修改和使用。

进一步阅读

请参考以下资源以获取更多信息：

• 通过 Amazon Textract、Amazon Comprehend 和 Amazon Lex 从发票中提取对话性见解，作者：Mona Mona、Prem Ranga 和 Saida Chanda（aws.amazon.com/blogs/machine-learning/deriving-conversational-insights-from-invoices-with-amazon-textract-amazon-comprehend-and-amazon-lex/）。

• Amazon Textract 异步操作文档（docs.aws.amazon.com/textract/latest/dg/async.html）。

第十七章：第十七章：从手写内容中可视化见解

在前几章中，我们讨论并学习了如何使用Amazon Textract、Amazon Comprehend和Amazon A2I构建智能文档处理（IDP）流水线。设置此类流水线的优势在于，你可以将自动化引入到你的运营流程中，并解锁以前不太明显的见解。说到见解，它们究竟是什么？为什么每个人都如此热衷于从文本中挖掘见解，它们到底有什么用呢？

为了解答这个问题，让我们召唤Doc Brown和马蒂·麦克弗莱的时光旅行车，电影回到未来中的DeLorean，回到第一章，商业环境中的 NLP 及 AWS AI 服务简介，重新阅读理解为什么 NLP 正在成为主流这一部分。你现在记得了吗？也许这样能帮到你：根据韦伯斯特词典（www.merriam-webster.com/），“见解”一词被定义为“理解事物内在本质或直觉性地看到的行为或结果”。你明白了——这就是从看似模糊甚至平凡的数据中发现有用信息。简单来说，它意味着“清晰地看到”。

本章将介绍如何将文本中的见解可视化——也就是手写文本——并利用这些见解推动决策制定。根据维基百科，已知最早的手写文字是楔形文字（en.wikipedia.org/wiki/Cuneiform），大约出现在 5500 多年前。与此一样古老的，还有其中一位作者的母语——泰米尔语，无论是在口语还是书写形式上都已有几千年的历史。话虽如此，现在让我们回到我们最喜爱的虚构组织——LiveRight Holdings，解决他们似乎遇到的新挑战。

你被赋予了为公司举办创始人日的任务，这场活动预计将是一场盛大的庆典，因为 LiveRight 的知名度日益提高。为了跟上 LiveRight 文化，推动社区利益，你需要与几家当地供应商合作，为活动提供所需的家具、食物及其他物品。你被告知管理层需要所有支出的汇总报告，所以你决定使用现有的文档处理流水线来处理他们的收据。然而，令你沮丧的是，你发现当地供应商仅提供手写收据。你记得你之前构建的一个解决方案中，Amazon Textract 支持手写内容，于是你开始思考如何最好地设计这个解决方案。

本章将涵盖以下主题：

• 从手写图像中提取文本

• 使用 Amazon QuickSight 可视化见解

技术要求

本章需要你拥有一个 AWS 账户，你可以在aws.amazon.com/console/注册。有关如何注册 AWS 账户并登录AWS 管理控制台的详细说明，请参考第二章中的注册 AWS 账户小节，介绍 Amazon Textract部分。

本章讨论的解决方案的 Python 代码和示例数据集可以在github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services/tree/main/Chapter%2017找到。

请查看以下视频，了解代码的实际操作：bit.ly/3vLX5j0。

从手写图像中提取文本

此时，你已经准备好开始设计和构建方案。你意识到，为这个用例所构建的内容将成为现有文档处理解决方案的扩展，因此将在组织内长期使用。所以，你需要为未来的可扩展性进行设计。考虑到这一点，你决定使用Amazon S3（aws.amazon.com/s3/）作为对象存储，Amazon Textract（aws.amazon.com/textract/）进行手写识别，Amazon QuickSight（aws.amazon.com/quicksight/），这是一项无服务器的、由机器学习驱动的商业智能服务，用于可视化手写内容的洞察。我们将使用 Amazon SageMaker Jupyter notebook 进行文本提取，然后使用 AWS 管理控制台来设置 QuickSight 可视化。让我们开始吧。

创建 SageMaker Jupyter notebook

如果你在前面的章节中没有进行过此操作，你需要创建一个 Amazon SageMaker Jupyter notebook，并为该 Notebook 角色设置身份和访问管理（IAM）权限，以便访问我们将在此 notebook 中使用的 AWS 服务。之后，你需要克隆本书的 GitHub 仓库（github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services），创建一个 Amazon S3 存储桶（aws.amazon.com/s3/），并在 notebook 中提供存储桶名称以开始执行。

注意

请确保你已完成技术要求部分中提到的任务。

在执行 notebook 中的单元格之前，请按照以下步骤完成这些任务：

1. 按照第二章中设置你的 AWS 环境章节下的创建一个 Amazon SageMaker Jupyter 笔记本实例子章节中的说明，创建你的 Jupyter 笔记本实例。

   创建 Amazon SageMaker Jupyter 笔记本时的 IAM 角色权限

   在创建笔记本时接受 IAM 角色的默认设置，以允许访问 S3 存储桶。

2. 一旦你创建了笔记本实例并且其状态为InService，点击操作菜单中的打开 Jupyter，以获取笔记本实例。

3. 这将带你进入笔记本实例的主文件夹。

4. 点击新建并选择终端。

5. 如果你还没有这样做，在终端窗口中输入cd SageMaker，然后输入git clone https://github.com/PacktPublishing/Natural-Language-Processing-with-AWS-AI-Services。

6. 现在，退出终端窗口并返回到主文件夹；你将看到一个名为Natural-Language-Processing-with-AWS-AI-Services的文件夹。点击该文件夹，打开章节文件夹，并点击第十七章。

7. 点击该文件夹以打开。你应该会看到一个名为chapter17-deriving-insights-from-handwritten-content-forGitHub.ipynb的笔记本。点击它以打开。我们将在接下来的章节中使用此笔记本。现在，请保持此窗口打开。

接下来，我们将介绍一些额外的 IAM 先决条件。

额外的 IAM 先决条件

我们需要为 SageMaker 笔记本角色启用额外的策略。请参考第二章中设置你的 AWS 环境章节下的更改 IAM 权限和信任关系以便于 Amazon SageMaker 笔记本执行角色子章节中的详细说明，执行以下步骤：

1. 如果你还没有这样做，请将所有TextractFullAccess策略附加到你的 Amazon SageMaker 笔记本 IAM 角色上。

2. 将iam:PassRole权限作为内联策略添加到你的 SageMaker 笔记本执行角色中：

   { "Version": "2012-10-17", "Statement": [ {
     "Action": [
         "iam:PassRole"
     ],
     "Effect": "Allow",
     "Resource": "<your sagemaker notebook execution role ARN">
     }
    ]
   }
   

现在我们已经设置好了笔记本并为运行演练笔记本设置了 IAM 角色，在接下来的章节中，我们将创建一个 Amazon S3 存储桶。

创建一个 Amazon S3 存储桶

按照第二章中设置你的 AWS 环境章节下的创建一个 Amazon S3 存储桶、一个文件夹，并上传对象子章节中的说明，创建你的 Amazon S3 存储桶。如果你在前面的章节中已经创建了 S3 存储桶，请重新使用该存储桶。对于本章，你只需创建 S3 存储桶；我们将直接通过笔记本创建文件夹并上传必要的对象。让我们开始吧：

1. 一旦你有了存储桶的名称，请在笔记本的STEP 0 – CELL 1中输入该名称：

   bucket = "<enter-S3-bucket-name>"
   

2. 通过点击笔记本 UI 顶部菜单中的运行按钮，执行步骤 0 – 单元格 1。或者，你也可以按Shift + Enter来执行该单元格。这将导入我们需要的库，初始化它们的变量，并为下一组步骤准备好内核。

现在我们已经创建了 S3 存储桶并导入了所需的库，接下来让我们使用Amazon Textract提取内容。

使用 Amazon Textract 提取文本

我们现在将继续执行笔记本中的其余单元格，以更新 QuickSight 清单文件，包含我们的存储桶和前缀条目。清单文件为 QuickSight 数据集提供元数据，以便正确导入内容进行可视化。更多详情，请参阅文档（docs.aws.amazon.com/quicksight/latest/user/create-a-data-set-s3.html）。让我们开始吧：

1. 执行步骤 1 – 单元格 1以格式化清单文件，加入存储桶和前缀名称。

2. 现在，执行步骤 1 – 单元格 2将格式化后的清单文件上传到 S3 存储桶：

   s3 = boto3.client('s3')
   s3.upload_file(outfile,bucket,prefix+'/'+outfile)
   

3. 我们将得到以下输出。请复制这里打印出的 S3 位置，稍后在设置 QuickSight 时需要用到：

   Manifest file uploaded to: s3://<your-bucket-name>/chapter17/qsmani-formatted.json
   

4. 现在，执行步骤 2 – 单元格 1以安装Amazon Textract Response Parser（TRP）（github.com/aws-samples/amazon-textract-response-parser/blob/master/src-python/README.md），这是一个帮助库，提供了一种简便的方法来解析 Textract 的 JSON 响应：

   !python -m pip install amazon-textract-response-parser
   

5. 执行步骤 2 – 单元格 2以导入解析器的 Document 类，我们需要它来初始化 boto3 处理程序以用于 Textract。

6. 步骤 2 – 单元格 3做了几件事，让我们分部分来看。首先，它会在当前目录中查找以.jpg扩展名结尾的文件。这些是我们手写收据的输入图像文件。以下是其中一张收据：

   图 17.1 – 一张手写收据的示例

7. 当找到这些文件时，会逐个读取并转换成字节数组：

   for docs in os.listdir('.'):
       if docs.endswith('jpg'):
           with open(docs, 'rb') as img:
               img_test = img.read()
               bytes_test = bytearray(img_test)
   

8. 接下来，它调用AnalyzeDocument Textract API，并将bytearray作为输入，特别是从输入图像中寻找表格和表单。然后，Textract 响应会被 Textract Response Parser 库解析，结果存储在一个变量中。接着，我们必须遍历这些结果，找到表格，并初始化一个变量，表示我们将写入的 CSV 文件：

   response = textract.analyze_document(Document={'Bytes': bytes_test}, FeatureTypes=['TABLES','FORMS'])
           text = Document(response)
           for page in text.pages:
               for table in page.tables:
                   csvout = docs.replace('jpg','csv')
                   with open(csvout, 'w', newline='') as csvf:
   

9. 最终，单个单元格的值会写入 CSV 文件中，同时去除空格（如果有的话）以及表示货币的$符号。最后，新的 CSV 文件会上传到 S3 存储桶。对于输入文件夹中找到的每个图像文件，都会重复此过程：

   tab = csv.writer(csvf, delimiter=',')
                       for r, row in enumerate(table.rows):
                           csvrow = []
                           for c, cell in enumerate(row.cells):
                               if cell.text:
                                   csvrow.append(cell.text.replace('$','').rstrip())
                           tab.writerow(csvrow)
           s3.upload_file(csvout,bucket,prefix+'/dashboard/'+csvout)
   

10. 执行步骤 2 – 单元格 3 完成前述步骤中概述的任务。我们将得到以下输出。请记下 CSV 文件的 S3 位置。我们之前格式化的清单文件包含这些位置，允许 QuickSight 上传这些 CSV 文件：

    Extracted text from hw-receipt2.jpg
    CSV file for document hw-receipt2.jpg uploaded to: s3://<s3-bucket-name>/chapter17/dashboard/hw-receipt2.csv
    Extracted text from hw-receipt1.jpg
    CSV file for document hw-receipt1.jpg uploaded to: s3://<s3-bucket-name>/chapter17/dashboard/hw-receipt1.csv
    

    注意

    您还可以在此解决方案中使用Amazon A2I，设置人工循环来审查 Textract 输出，并根据需要对内容进行更改，然后创建 CSV 文件。更多详细信息，请参考第十三章，提高文档处理工作流的准确性，继续阅读。

这标志着笔记本中的步骤已经完成。接下来，我们将登录 AWS 管理控制台，设置 QuickSight 以进行可视化。

使用 Amazon QuickSight 进行洞察可视化

首先，我们需要为您的 AWS 账户启用 QuickSight，才能导入数据并运行可视化。请执行以下步骤继续：

1. 登录到 AWS 管理控制台（如果没有访问权限，请参考技术要求部分），并在页面顶部中间的服务搜索框中输入QuickSight。点击搜索结果中的QuickSight，进入QuickSight 注册页面。

2. 输入您的电子邮件地址并点击继续：

   图 17.2 – 注册 QuickSight

3. 登录后，点击左侧面板中的数据集，然后点击右上角的新建数据集按钮：

   图 17.3 – 新建数据集

4. 点击数据集页面上的S3：

   图 17.4 – S3

5. 在弹出的窗口中，对于handwritten-receipts，在上传清单文件输入区域，复制并粘贴在 Jupyter 笔记本中 步骤 1 – 单元格 2 打印的 S3 位置。然后，点击连接：

   图 17.5 – 指定 S3 清单文件

6. 数据集导入完成后，点击Chapter17/dashboard前缀：

   图 17.6 – 数据集导入成功

7. 您应该看到左侧显示来自 CSV 文件的列名，位于字段列表下方。您应该看到一个中间面板，里面有一个名为AutoGraph的图形空间。当您从左侧列表中添加字段时，QuickSight 会根据您的数据自动创建适当的图形。

8. 对于我们的使用案例，我们将创建饼图和甜甜圈图来可视化已订购的家具数量及其费用。在左侧的视觉类型部分，点击饼图符号，并将字段从字段列表添加到图表中，如下所示：

   图 17.7 – 可视化各类家具的数量

9. 现在，让我们向这个仪表板添加一个新的可视化。点击左上方的 Add，然后选择 Add visual：

   Figure 17.8 – 添加可视化

10. 现在，添加一个甜甜圈图来显示总成本和按家具类型分类的成本，如下图所示。首先，在左侧的 Visual types 部分选择甜甜圈可视化，选择 ITEM 和 PRICE，然后将它们添加到 Group/Color 和 Value 字段中：

    Figure 17.9 – 用于可视化总成本和按家具类型分类的成本的甜甜圈图

11. 在控制台左侧中间点击 Insights 选项，显示 QuickSight 能够从我们的数据中提取的见解：

Figure 17.10 – QuickSight 从我们的数据中提取的见解

就这么简单。随时可以尝试其他类型的可视化，以及 ML 驱动的预测和见解。有关更多详情，请参考以下文档：docs.aws.amazon.com/quicksight/latest/user/making-data-driven-decisions-with-ml-in-quicksight.html。您可以设置、共享、发布或导出仪表板，以供管理层和其他利益相关者使用。这也标志着本用例解决方案构建的结束。

总结

在这个用例中，我们只是触及了我们能够处理书面文本的一小部分——可能性真的是无穷无尽的！只需几个步骤，通过利用 Amazon Textract 等服务提供的先进 AI 能力，以及 Amazon QuickSight 提供的无服务器可扩展可视化，我们就能够从一张纸上潦草的内容中创建出强大的可视化效果。

我们首先创建了这个解决方案所需的 SageMaker Jupyter notebook 实例，克隆了本章的 GitHub 仓库，创建了一个 S3 存储桶，并在 notebook 中执行了步骤以格式化 QuickSight S3 清单文件。然后，我们使用 Amazon Textract 和 Textract Response Parser 库读取手写收据的内容，之后创建了 CSV 文件并上传到 S3 存储桶。在执行完这些步骤后，我们结束了 notebook，并登录到 AWS 管理控制台，注册使用 Amazon QuickSight。

在 QuickSight 中，我们导入了包含 CSV 文件的 S3 数据集，并创建了两个可视化图表和一个洞察。第一个图表是一个饼图，显示了已订购物品与其数量的对比，第二个图表是一个甜甜圈图，显示了两张收据的总成本，以及每个物品的成本。最后，我们展示了 QuickSight 自动生成的洞察，提供了它从我们的内容中读取到的摘要。我们简要讨论了如何导出或分享仪表板及 QuickSight 的基于 ML 的洞察。这也完成了本章的解决方案构建。

基于本书至今覆盖的众多使用案例，你已经知道如何为你和你的客户解决 NLP 中的主流挑战，而且我们完成这一切时没有需要调优任何超参数或从零开始训练模型。当然，我们训练了几个自定义的 Comprehend 模型，但那是没有传统机器学习工作流开销的。

在下一章，我们将结束本书，因此我们想留下些最佳实践、技巧和指南，供你在作为 NLP 和 AI 专家的职业生涯中随时参考。我们将讨论文档的预处理、后处理以及在解决方案设计过程中需要考虑的其他事项。我们快到了！

第十八章：第十八章：构建安全、可靠和高效的 NLP 解决方案

感谢亲爱的读者在这段（希望对您有帮助的）旅程中陪伴我们，帮助组织构建最佳的自然语言处理（NLP）解决方案，以从文本数据中发现洞察。本书的写作目的是让人们意识到，人工智能（AI）已经成为主流，我们正处于一个巨大的人工智能采用浪潮的边缘，许多企业都在朝着这个方向前进。这项激动人心的技术不仅能帮助你提升职业生涯，还为你提供了探索以前无法实现的创新领域的机会。例如，根据 BBC 的一篇文章（www.bbc.com/future/article/20181129-the-ai-transforming-the-way-aircraft-are-built），Autodesk（www.autodesk.com/）这家全球领先的设计和制造技术公司，使用生成式人工智能（www.amazon.com/Generative-AI-Python-TensorFlow-Transformer/dp/1800200889）帮助飞机制造商设计更高效的机身框架，这是减少燃油消耗的关键要求。

在本书中，我们回顾了企业今天处理的几种用例类型，旨在从基于文本的数据中获取有用信息。这些信息要么直接帮助他们提取洞察，要么作为推动下游决策的前兆，在这两种情况下都具有操作性影响。我们阅读了不同的商业场景，讨论了满足这些需求的不同解决方案设计方法、架构实施框架，以及实时和批处理解决方案。

现在我们了解如何使用AWS AI 服务设计、架构和构建 NLP 解决方案，但我们仍然缺少一个重要步骤。我们如何确保我们的解决方案已经准备好投入生产？在处理真实世界数据时，确保解决方案按预期工作需要满足哪些操作要求？架构需要遵守哪些非功能性要求？我们该如何在实现过程中将这些融入解决方案？为了回答这些问题，我们将回顾最佳实践、技巧和指导，阐明如何让一个优秀的 NLP 解决方案更加出色。

在本章中，我们将讨论以下主题：

• 定义 NLP 解决方案的最佳实践

• 应用最佳实践进行优化

技术要求

对于本章，您需要访问一个 AWS 账户（aws.amazon.com/console/）。

请参阅 第二章 中 设置您的 AWS 环境 部分的 注册 AWS 账户 子部分，详细了解如何注册 AWS 账户并登录到AWS 管理控制台的说明。

定义自然语言处理（NLP）解决方案的最佳实践。

如果您以前做过 DIY（自己动手）项目，您就知道工具对您的工作有多重要。在构建自然语言处理解决方案或任何解决方案时，您需要牢记以下几点：

• 您需要了解您的需求（"what"）。

• 您需要了解构建解决方案解决的问题（"why"）。

• 您需要了解构建解决方案所需的工具和技术（"how"）。

• 您需要估计构建解决方案所需的时间（"when"）。

• 最后，您需要确定团队所需的技能（"who"）。

但是，采用这种方法，您未必能够解决使解决方案可靠、可扩展、高效、安全或具有成本效益的需求。而这些同样重要（甚至更重要），以构建能够让客户满意的长久解决方案。

在构建使用 AWS 时，您可以获得几十年构建和运营高性能、大规模应用程序（如亚马逊）的经验中获得的指导和宝贵见解，以及帮助全球最大企业在 AWS 上运行其云工作负载的专业知识。所有这些经验和知识都已整理成一套架构指南和最佳实践，称为AWS Well-Architected Framework。

将良构建视为一个由五个支柱定义的全面问题清单。

• 运营卓越：运营卓越支柱建议自动化基础设施的提供和管理（如果适用），将解决方案架构模块化为可以独立管理的组件，实现敏捷性，实施基于 CI/CD 的 DevOps 实践，模拟运营故障，并为其做准备并从中学习。

• 安全性：安全性支柱建议通过从最基础的开始实施最少特权治理措施和相关的保护措施，注重身份和访问管理，计算和网络安全，数据在传输和静态状态下的保护，自动化，模拟和事件响应，将安全置于首要位置。

• 可靠性：可靠性支柱要求建立高度弹性的架构，能够从故障中自我修复，注重快速失败和恢复测试，具有自动缩放的弹性能力，并且高度自动化。

• 性能效率：性能效率支柱建议使用AWS 管理服务（AMS），以去除与管理基础设施相关的无差异重负担，利用全球 AWS 网络减少终端用户的延迟，并通过 API 去除重复实验和资源交互的耦合需求。

• 成本优化：成本优化支柱提供有关你可以采取的措施的建议，帮助你追踪并最小化使用成本。

欲了解更多有关良好架构框架的详细信息，以及帮助你入门的资源，请访问 Amazon 文档：docs.aws.amazon.com/wellarchitected/latest/framework/welcome.html

从整体来看，各个支柱的良好架构问题引导你完成架构设计、构建和实施。这使得你能够融入关键设计原则，构建出安全、可靠、经济高效且高效运作的解决方案（因此得名“良好架构”）。那么，在我们的案例中，良好架构对于 NLP 解决方案和 AI 服务意味着什么呢？为了帮助你清楚地理解这一点，我们将创建一个良好架构支柱矩阵，结合 NLP 开发阶段，如文档预处理、预测和后处理，并从我们在本书中使用的主要 AWS AI 服务（Amazon Textract 和 Amazon Comprehend）的角度进行说明。我们还将探讨在构建 NLP 解决方案时普遍应用的原则。在矩阵的每个单元格中，我们将总结如何使用最佳实践应用良好架构原则进行设计和实施。

图 18.1 – 良好架构的 NLP 解决方案矩阵

从前面的矩阵中可以看出，在解决方案开发过程中，你可以采用一些设计原则来构建高效且安全的 NLP 应用。为了明确起见，我们将这些原则根据良好架构框架支柱和 NLP 开发阶段分开。但是，正如你可能注意到的，有些原则在各个单元格中是重复的。这是因为某个支柱原则的应用可能会自动解决其他支柱的需求，这取决于我们所参考的原则。例如，当使用AWS Glue ETL 作业进行文档预处理和后处理任务时，我们的良好架构需求——包括运营卓越、成本优化和性能效率，都会得到满足，而无需做其他额外工作。

我们将在下一节中更详细地解释这一原因。本节中我们介绍了 AWS Well-Architected 框架，并回顾了如何将 Well-Architected 原则应用于本书中使用的 AWS AI 服务的矩阵。在下一节中，我们将深入探讨并讨论如何实现矩阵中的一些原则。

应用优化的最佳实践

在本节中，我们将深入探讨我们在《Well-Architected NLP 解决方案矩阵》中记录的每个设计原则的含义，以及如何根据您的需求实施这些原则。由于本书的范围主要是关于 AWS AI 服务，我们已经有了使用无服务器托管服务的优势，这解决了《Well-Architected 框架》中提到的多个建议。此外，如前所述，矩阵中记录的一些最佳实践可能看起来有些重复——这并不是错误，而是有意为之，因为应用某一种设计模式可能会在《Well-Architected 框架》的多个支柱中产生级联效益。我们将在遇到时重点说明这些内容。话不多说，让我们开始深入探讨。

使用 AWS S3 数据湖

本节涉及《Well-Architected NLP 解决方案矩阵》中的原则1.1a和1.3a（图 18.1）。

数据湖是一个用于存储结构化、半结构化和非结构化数据的仓库。最初，它是来自企业不同来源的数据集合，并作为下游分析、商业智能、机器学习（ML）和运营需求的数据来源。然而，由于数据加载到数据湖时保持其源格式（数据在加载到数据湖之前不会进行转换），因此在从数据湖中获取数据时，数据需要进行转换。使用Amazon S3（AWS 云中的完全托管对象存储解决方案）构建数据湖非常有意义，因为它可以根据需要进行扩展，并且存储在 S3 中的数据具有高度耐久性（更多信息，请参见关于“11 个 9s”耐久性的部分（aws.amazon.com/s3/faqs/）。

此外，AWS 提供了多种方式，帮助你将数据导入到 S3，并提供几种选项，帮助你从 S3 读取数据、转换数据并将其提供给消费者，以满足你的各种需求，所有这些步骤都以高度安全的方式进行。有关如何在 S3 上创建数据湖、将数据源注入数据湖、创建数据目录以及如何安全管理和转换数据的详细信息，请参考《构建大数据存储解决方案》白皮书（docs.aws.amazon.com/whitepapers/latest/building-data-lakes/building-data-lake-aws.html）。有关如何使用AWS Lake Formation（一个用于构建和管理数据湖的完全托管服务）设置数据湖的说明，请参考入门指南（docs.aws.amazon.com/lake-formation/latest/dg/getting-started.html）。

现在让我们讨论如何使用 AWS Glue 进行数据处理。

使用 AWS Glue 进行数据处理和转换任务

本节涵盖了《Well-Architected NLP 解决方案矩阵》中的原则1.4a、1.5a、3.1a、3.4b和3.5a（图 18.1）。

AWS Glue 是一个完全托管的无服务器数据目录、处理和转换服务，它使你能够构建端到端的 ETL 管道，提供现成的连接，以连接本地和 AWS 上的数据存储。AWS Glue 的无服务器托管特性消除了与基础设施管理和重复繁重工作相关的成本。AWS Glue 使你能够配置与数据存储以及 S3 数据湖的连接，直接拉取数据进行文档预处理。你可以使用 Glue ETL 作业在数据转换（如有需要）后将数据传送到 NLP 解决方案管道中，无论是用于训练自定义 NLP 模型，还是在推理时进行预测。这使得你的解决方案更加优雅和高效，避免了需要创建多个解决方案组件来处理这些任务。

AWS Glue ETL 作业可以根据你的需求按需触发或计划执行。你还可以在 NLP 解决方案完成识别或分类任务后，使用它进行文档后处理，以将数据持久化到下游数据存储，或供需要这些数据的操作流程使用。有关 AWS Glue 如何帮助你的详细演示，请参考以下使用AWS Glue Studio的教程，它是一个图形化界面，可以让你在创建和运行 ETL 作业时更方便地与 Glue 进行交互：docs.aws.amazon.com/glue/latest/ug/tutorial-create-job.html

在下一节中，我们将回顾如何使用Amazon SageMaker Ground Truth来进行文本标注任务。

使用 Amazon SageMaker Ground Truth 进行标注

本节讲解了 Well-Architected NLP 解决方案矩阵中的原则 1.4b (图 18.1)。

NLP 模型的准确性与其所基于的标注数据的质量成正比。虽然我们主要使用 AWS AI 服务中已预训练的模型，但我们也看到了一些需要使用 Amazon Comprehend 自定义模型进行实体识别和分类任务的用例。Amazon Comprehend 自定义模型使用迁移学习，通过使用我们提供的数据（即对我们业务独特的数据），从其自身的预训练模型中逐步训练自定义模型。因此，对于这些自定义训练需求，我们需要提供高质量的标注数据，这将影响我们模型的准确性。作为最佳实践，我们建议使用 Amazon SageMaker Ground Truth (aws.amazon.com/sagemaker/groundtruth/) 来处理这些标注任务。Ground Truth 已与 Amazon Comprehend 直接集成，你只需在设置 Amazon Comprehend 作业时，指向 Ground Truth 清单的位置。

Ground Truth 是一项完全托管的服务，提供易于使用的数据标注功能，可以选择使用你自己的私有劳动力、来自 AWS Marketplace 的第三方数据标注者，或者使用 Amazon Mechanical Turk 提供的众包公共数据标注者。

Ground Truth 默认提供数据加密，并通过在后台训练一个机器学习（ML）模型，自动学习人类标注者执行的标注活动。一旦达到一定的置信度阈值，Ground Truth 将应用该 ML 模型来自动化标注任务。Ground Truth 提供了适用于多种数据格式（如图像、文本和视频文件）的预构建任务模板。你还可以通过在创建标注作业时选择自定义任务类型，创建适合自己需求的模板。请参见以下截图，了解 Ground Truth 支持的不同类型的基于文本的标注任务：

图 18.2 – Amazon SageMaker Ground Truth 中的文本标注任务类型

要开始使用，你需要创建一个标注作业，选择数据集的 S3 存储位置，指定 IAM 角色（或者让 Ground Truth 为你创建一个），从预构建模板列表中选择任务类别（或者你可以选择 自定义 来创建自己的模板），并选择将处理你请求的标注劳动力。有关如何开始的更多细节，请参考以下文档：docs.aws.amazon.com/sagemaker/latest/dg/sms-label-text.html

现在我们已经了解了如何使用 Ground Truth 进行标注，让我们回顾一下最近推出的新功能，它可以直接从PDF或Microsoft Word文档进行自定义实体识别器训练。

直接使用 Amazon Comprehend 处理 PDF 和 Word 格式

本节涉及 Well-Architected NLP 解决方案矩阵中的原则1.4c（图 18.1）。

注意：

Amazon Comprehend 在 2021 年 9 月更新了自定义实体识别功能，以支持直接使用 PDF 和 Word 文档进行训练和推理。

为了提高 NLP 解决方案管道的性能效率，Amazon Comprehend 现在支持直接从 PDF 和 Word 文档格式训练自定义实体识别器，而无需执行预处理步骤将文档转换为机器可读的格式。要使用此功能，您可以按照我们在第十四章中指定的步骤，即审计命名实体识别工作流，训练 Amazon Comprehend 自定义实体识别器，但有一个小的不同之处。

注意：

您仍然需要在训练文档中标注实体，并使用 Ground Truth 创建增强的清单。更多细节，请参考此博客中的说明：aws.amazon.com/blogs/machine-learning/custom-document-annotation-for-extracting-named-entities-in-documents-using-amazon-comprehend/

请按照以下步骤，直接使用 Amazon Comprehend 从 PDF 或 Word 文档中进行训练和推理：

1. 登录到您的 AWS 管理控制台（更多细节请参见技术要求部分），并在服务搜索栏中输入comprehend。

2. 在左侧面板中点击自定义实体识别，然后点击创建新模型。

3. 在模型设置部分，为您的模型提供名称，并向下滚动至数据规范部分，选择增强的清单和PDF、Word 文档格式进行训练。提供增强清单的 S3 位置。向下滚动以选择或创建 IAM 角色，并点击创建以开始训练。一旦模型训练完成，您可以使用我们在第十四章中讨论的相同步骤进行推理，审计命名实体识别工作流。但是，提供 PDF 或 Word 文档作为输入，而不是 CSV 文件。

图 18.3 – 使用 PDF、Word 文档进行 Amazon Comprehend 自定义实体识别器训练

这个功能更新提高了预处理效率，并减少了设置我们的 NLP 解决方案管道时的前期时间投入。在下一部分，我们将回顾如何在构建 NLP 解决方案时强制执行访问控制。

强制实施最小权限访问

本节讨论了来自“良好架构化 NLP 解决方案矩阵”（图 18.1）的原则 1.2c、3.2b 和 4.2a。

高度安全架构的核心原则之一是强制实施所谓的 最小权限访问资源。AWS 身份与访问管理（IAM）是一个安全服务，它允许为您的用户定义并实施身份验证和授权策略，以确保对 AWS 基础设施的安全访问。通过 IAM，您可以创建权限策略，这些策略附加到角色或用户（身份）上，定义该身份能够或不能使用 AWS 服务（资源）执行哪些（操作）。如其名所示，最小权限就是为您的用户和角色定义高度限制性的权限策略。在 AWS 中，默认的权限是 拒绝。

如果没有为用户指定策略，则该用户没有权限在 AWS 中执行任何操作。因此，您需要添加策略声明，允许用户或角色使用 AWS 服务或资源执行特定任务。在本书的示例中，由于用例的性质以及为了简化和方便配置，我们建议您将托管权限策略（例如 TextractFullAccess 或 ComprehendFullAccess）添加到您的 SageMaker 执行 IAM 角色 中，用于您的笔记本。当您构建您的 NLP 解决方案并将其推广到生产环境时，作为最佳实践，您应该强制实施最小权限访问。让我们通过一个示例来讨论这意味着什么。ComprehendFullAccess 权限策略由以下 JSON 语句定义：

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Action": [
                "comprehend:*",
                "s3:ListAllMyBuckets",
                "s3:ListBucket",
                "s3:GetBucketLocation",
                "iam:ListRoles",
                "iam:GetRole"
            ],
            "Effect": "Allow",
            "Resource": "*"
        }
    ]
}    

如果您参考前面 JSON 代码中突出显示的部分，附加在 "comprehend" 上的通配符（*）表示允许角色或用户使用此策略执行所有 Amazon Comprehend API 操作。这不是一个限制性的策略，而是提供了广泛的权限集。

为了强制实施最小权限访问，应该创建一个新的策略，并按照以下 JSON 语句进行更改：

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Action": [
                "comprehend:DetectEntities",
                "comprehend:BatchDetectEntities",
                "comprehend:DetectPiiEntities",
                "comprehend:ContainsPiiEntities",
                "s3:ListAllMyBuckets",
                "s3:ListBucket",
                "s3:GetBucketLocation",
                "iam:ListRoles",
                "iam:GetRole"
            ],
            "Effect": "Allow",
            "Resource": "*"
        }
    ]
}

在这个更改后的 JSON 声明中，我们提供了限制性权限，允许用户或角色仅使用 Amazon Comprehend 中的实体检测功能。一种好的做法是仅提供完成任务所需的最基本权限。此外，你还需要确保监控 IAM 角色和策略分配，以确保在用户或角色完成任务后清理权限。这样可以避免因旧权限导致用户获得超出其需求的访问权限。AWS 提供了一种名为IAM 访问分析器的功能，用于主动监控权限并根据需要采取措施。有关 Access Analyzer 的详细介绍，请参考以下文档：docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html。

在下一节中，我们将回顾如何在构建 NLP 解决方案任务中保护敏感数据。

混淆敏感数据

本节讨论了《Well-Architected NLP 解决方案矩阵》中的原则 1.2a 和 4.2b（见 图 18.1）。

保护数据的机密性非常重要。企业通常将数据分类为公开、机密、秘密和绝密等类别，并根据这些分类应用控制措施和保护措施。如果你不确定如何对数据进行分类，请参考现有的数据分类模型，如美国国家分类方案。有关此模型的更多细节，以及 AWS 推荐的数据分类最佳实践，可以在以下文档中找到：docs.aws.amazon.com/whitepapers/latest/data-classification/welcome.html。

一旦你对数据进行了分类，下一步是确定数据所包含的保密性类型。数据可以是个人身份信息（PII），例如，可能包含社会保障号码、信用卡号码、银行账户号码等。或者，如果你的数据包含客户的私人健康记录，它被称为受保护健康信息（PHI）。如果你从事法律行业，那么律师-客户特权信息是受保护数据，必须保密。

如我们所见，数据保护至关重要，必须成为我们 NLP 解决方案开发中的关键考虑因素。在 AWS 上构建时，有多种方式可以保护你的机密数据，包括静态数据加密和传输数据加密，这些我们将在本章后续部分进行讨论。有关 AWS 如何支持最高隐私标准的详细信息，以及帮助你保护客户数据的资源信息，请参考以下链接：aws.amazon.com/compliance/data-privacy/

以下截图显示了 Amazon Comprehend 实时进行 PII 检测的结果。

图 18.4 – Amazon Comprehend PII 检测

在第四章，《自动化文档处理工作流》中，我们回顾了 Amazon Comprehend 如何提供检测数据中的个人身份信息（PII）实体的支持。你可以通过 Lambda 函数，在从 Amazon S3 获取数据时，自动对数据进行处理或转换，作为文档预处理阶段的一部分。对于 PII 检测，提供了两个 Lambda 函数，用于与 S3 对象访问 Lambda 一起使用。Amazon Comprehend 的 ContainsPiiEntites API 用于分类包含 PII 数据的文档，而 DetectPiiEntities API 用于识别文档中实际的 PII 数据，以便进行数据屏蔽。关于如何使用 S3 对象访问 Lambda 检测和屏蔽文档中的 PII 数据的教程，请参考这个 GitHub 仓库：github.com/aws-samples/amazon-comprehend-s3-object-lambda-functions

在下一部分，我们将回顾如何实施静态数据保护和传输数据保护。

保护静态数据和传输中的数据

本节讨论了《Well-Architected NLP 解决方案矩阵》（图 18.1）中的原则 1.2b、2.2a、3.2a 和 4.3b。

既然我们已经讨论了最小权限和数据保密性，现在让我们回顾一下保护数据静态存储和传输中的最佳实践（也就是说，数据在数据存储中时以及在传输过程中，比如由于服务 API 调用时）。当我们谈论静态数据保护时，我们指的是在 AWS 中对数据进行加密。你的数据可以存储在 Amazon S3 数据湖中、Amazon RDS（AWS 提供的关系型数据库托管服务）、Amazon Redshift（一款支持 PB 级数据的云端数据仓库）、Amazon DynamoDB，或其他为特定用途构建的数据库中，比如 Amazon DocumentDB（为 MongoDB 提供的 AWS 托管服务），或 Amazon Neptune（为 图形 数据库提供的 AWS 托管服务）等。

使用 AWS 的优势在于，您可以轻松启用加密来保护静态数据，使用AWS 密钥管理服务（KMS）（一个可靠且安全的服务，用于创建、管理和保护加密密钥，并在 AWS 中的多个服务之间应用数据加密）。加密使用AES-256标准（en.wikipedia.org/wiki/Advanced_Encryption_Standard）得到支持。

例如，当您将对象存储在 Amazon S3 时，您可以请求服务器端加密（在数据存储到 S3 时进行加密），通过选择使用 S3 管理的加密密钥（即您在存储桶级别创建的 KMS 密钥）或您自己的加密密钥（当您上传对象到 S3 存储桶时提供的密钥）来实现加密。

图 18.5 – 为您的 S3 存储桶启用加密

Amazon Redshift 在集群创建时提供类似的选项来加密您的数据（docs.aws.amazon.com/redshift/latest/mgmt/security-server-side-encryption.html）。

Amazon DynamoDB 默认使用 AWS KMS 加密您的所有数据（docs.aws.amazon.com/amazondynamodb/latest/developerguide/EncryptionAtRest.html）。

您可以为您的 Amazon RDS 数据库启用加密（docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.Encryption.html）。

您还可以为任何专用的 AWS 数据库启用加密，例如 Amazon DocumentDB (docs.aws.amazon.com/documentdb/latest/developerguide/encryption-at-rest.html)。

所有处理客户数据的 AWS 服务都支持加密。更多细节请参阅此博客：aws.amazon.com/blogs/security/importance-of-encryption-and-how-aws-can-help/

为了保护数据传输，您可以使用如传输层安全性（TLS）等协议来保护您的 API 端点：en.wikipedia.org/wiki/Transport_Layer_Security

类似于保护静态数据，AWS 提供了使用AWS 证书管理器（一个托管服务，用于配置和管理 TLS 证书）来加密通信、验证身份，并实现应用程序交互的HTTPS端点。所有处理客户数据的 AWS 服务都使用 TLS 和 HTTPS 进行加密保护。

使用 Amazon API Gateway 进行请求限制

本节讨论了《Well-Architected NLP 解决方案矩阵》中原则2.1a（图 18.1）。

当我们构建 Amazon Comprehend 自定义实体识别器或分类器时，我们通过创建 Comprehend 实时端点来托管这些模型，如下图所示：

图 18.6 – 创建 Amazon Comprehend 实时端点

您可以直接从代码中调用这些端点来检测实体或进行文本分类需求，具体代码片段如下：

response = comprehend.detect_entities(Text=entry,
                    LanguageCode='en',
                    EndpointArn='endpoint-arn'
            )

我们将在随后的章节中讨论如何为 Amazon Comprehend 实时端点设置自动扩展，但需要注意的是，您将按秒收费（aws.amazon.com/comprehend/pricing/），且容量以推理单位计量，每个推理单位表示每秒 100 个字符的吞吐量。对端点进行请求限制将有助于更有效地管理容量。Amazon API Gateway（aws.amazon.com/api-gateway/）是一个完全托管的、安全的、可扩展的 API 管理服务，可以用来创建 API，通过 AWS Lambda 函数抽象调用 Amazon Comprehend 端点，具体操作请参考以下教程：github.com/aws-samples/amazon-comprehend-custom-entity-recognizer-api-example

除了请求限制外，API Gateway 还支持流量管理、访问控制、监控和版本管理，这有助于为我们的解决方案实施一个强健的请求处理方法。有关更多详细信息，请参阅以下文档：docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-create-api-as-simple-proxy-for-lambda.html

在下一节中，我们将介绍如何为 Amazon Comprehend 实时端点设置自动扩展。

为 Amazon Comprehend 端点设置自动扩展

本节讨论了《Well-Architected NLP 解决方案矩阵》中原则2.3a（图 18.1）。

在上一节中，我们讨论了需要终端节点来启用来自 Amazon Comprehend 自定义模型的实时预测。终端节点推理能力用 推理单元 (IU) 表示，表示每秒 100 个字符的吞吐量。当您创建终端节点时，需要指定所需的 IU 数量，以帮助 Amazon Comprehend 确定为您的终端节点分配的资源。您根据终端节点所需的输出吞吐量（按字符每秒计算）来计算 IU，并且在终端节点处于活动状态时，无论是否接收请求，都会按持续时间收费。因此，您需要仔细管理 IU，以确保在需要时能够获得所需的容量（以保证性能），并在不需要时释放容量（以节省成本）。您可以通过 Amazon Comprehend 自动扩展来实现这一点：docs.aws.amazon.com/comprehend/latest/dg/comprehend-autoscaling.html

只能通过 AWS 命令行界面 (AWS CLI) 设置自动扩展。以下示例展示了如何为自定义实体识别启用自动扩展：

1. 通过在 AWS CLI 中运行以下代码片段注册可扩展目标。此处的 scalable-dimension 是指 Amazon Comprehend 资源类型以及容量的度量单位（IU）：

   aws application-autoscaling register-scalable-target \
   --service-namespace comprehend \
   --region <region> \
   --resource-id <your-comprehend-custom-endpoint> \
   --scalable-dimension comprehend:entity-recognizer-endpoint:DesiredInferenceUnits \
   --min-capacity 1 \
   --max-capacity 2
   

2. 然后，您需要创建一个 JSON 配置文件，指定您希望跟踪的目标，如下所示的代码片段：

   {
   "TargetValue": 90,
   "PredefinedMetricSpecification": 
   {
   "PredefinedMetricType": "ComprehendInferenceUtilization"
   }
   }
   

3. 最后，您将执行此扩展策略，如下所示的代码片段所示：

   aws application-autoscaling put-scaling-policy \
   --service-namespace comprehend \
   --region <region> \
   --scalable-dimension comprehend:entity-recognizer-endpoint:DesiredInferenceUnits \
   --resource-id <your-comprehend-custom-endpoint> \
   --policy-name CERPolicy \
   --policy-type TargetTrackingScaling \
   --target-tracking-scaling-policy-configuration file://config.json 
   

在接下来的章节中，我们将回顾如何监控自定义模型的训练指标，以便采取主动行动。

自动化监控自定义训练指标

本节内容涉及 Well-Architected NLP 解决方案矩阵（图 18.1）中的原则 4.3a。

在训练自定义分类或实体识别模型时，Amazon Comprehend 会生成 DescribeEntityRecognizer API（用于实体识别）或 DescribeDocumentClassifier API（用于分类）以获取自定义模型的评估指标。

以下是如何使用 DescribeEntityRecognizer API 的代码片段：

comprehend = boto3.client('comprehend')
response = comprehend.describe_entity_recognizer(
    EntityRecognizerArn='<arn-of-your-entity-recognizer>'
) 

要监控 Amazon Comprehend 自定义训练作业的完成情况，可以使用 DescribeEntityRecognizer 或 DescribeDocumentClassifier API 来获取评估指标。如果这些指标低于阈值，该功能可以通过 Amazon Simple Notification Service (SNS) 发送警报或通知。有关如何使用 Amazon EventBridge 安排事件的详细信息，请参考文档：docs.aws.amazon.com/eventbridge/latest/userguide/eb-run-lambda-schedule.html。

在接下来的章节中，我们将介绍如何使用 Amazon A2I 设置人工审核流程，以审查预测结果。

使用 Amazon A2I 审核预测结果

本节讨论了《良好架构化 NLP 解决方案矩阵》（图 18.1）中的原则 2.3b。

我们在本书的多个章节中详细介绍了如何使用 Amazon 增强 AI (Amazon A2I)（一个托管服务，用于设置机器学习预测的人工审核），从 第十三章，《提高文档处理工作流的准确性》开始。当你的解决方案是新开发时，最佳做法是设置人工审核环节，用于预测审核、审计和根据需要进行修正。你的解决方案还应包括基于人工审核数据的反馈循环，并进行模型再训练。我们建议在前 3 到 6 个月内使用 Amazon A2I 的人工审核环节，以便根据直接反馈使你的解决方案不断演进。之后，你可以禁用人工审核环节。

在下一节中，我们将介绍如何使用 异步 API 构建模块化、松耦合的解决方案。

使用异步 API 实现松耦合

本节讨论了《良好架构化 NLP 解决方案矩阵》（图 18.1）中的原则 2.4a 和 4.4a。

当我们设置一个需要扩展到处理数百万文档的 NLP 解决方案流水线时，最好使用 异步批处理 API 来实现这一架构。同步 API 遵循请求-响应模式，这意味着请求应用程序将等待响应，直到收到响应为止。当需要快速处理少量文档以满足实时或近实时、关键任务需求时，这种方式效果较好。然而，当文档量增大时，同步方式将占用计算资源，并且会减慢处理速度。通常，组织会实施两个独立的 NLP 解决方案流水线：一个用于实时处理，另一个用于批处理。对于批处理，根据处理的文档数量，推理结果将在几分钟到几小时后可用，具体取决于架构的设置方式。

使用 Amazon Comprehend 时，一旦实体识别器或分类器训练完成，当需要对大量文档进行 推理 时，使用 Batch API，如下面的实体识别代码片段所示。

1. 首先，我们提交一个 实体检测 任务（如果提供 ARN 端点，它将使用我们的自定义实体识别器）。响应返回一个 JobId、Job ARN 和 任务状态。任务完成后，结果会发送到你在 OutputDataConfig 中指定的 S3 位置：

   response = comprehend.start_entities_detection_job(
       InputDataConfig={
           'S3Uri': '<s3-location-input-documents>',
           'InputFormat': 'ONE_DOC_PER_FILE'|'ONE_DOC_PER_LINE'
       },
       OutputDataConfig={
           'S3Uri': '<s3-location-output-results>'
       }, 
       DataAccessRoleArn='<IAM-role>',
       JobName='<provide a job name>',
       EntityRecognizerArn='<ARN of your custom entity recognizer>')
   

   使用 Amazon Textract 处理大量文档时，可以首先使用 Batch API 提交文本分析或检测任务，分析任务完成后，再获取提取结果。以下步骤展示了如何使用 Amazon Textract 批处理 API。

   假设我们的用例是处理包含表格和表单数据的文档以及文本。在这种情况下，我们将首先使用StartDocumentAnalysis API（docs.aws.amazon.com/textract/latest/dg/API_StartDocumentAnalysis.html），并请求它查找表格和表单内容。段落中的文本默认会被提取。我们还会传递一个 Amazon SNS topic和一个IAM role，该角色为 Amazon Textract 提供权限，以便向 SNS topic发布消息。此 API 将返回一个JobId，我们将在下一步中使用：

   textract = boto3.client('textract') 
   job = textract.start_document_analysis(
       DocumentLocation={
           'S3Object': {
               'Bucket': '<s3-bucket-name>',
               'Name': '<file-name>'
           }
       },
       FeatureTypes=[
           'TABLES'|'FORMS',
       ],
       NotificationChannel={
           'SNSTopicArn': '<SNS-topic-arn>',
           'RoleArn': '<IAM-role-arn>'
       }
   )
   

2. 当任务完成时，Amazon Textract 会向 SNS 主题发送一条消息，指示任务状态。你可以将 AWS Lambda 函数附加到此 SNS 主题作为事件触发器。此 Lambda 函数将调用GetDocumentAnalysis API（docs.aws.amazon.com/textract/latest/dg/API_GetDocumentAnalysis.html），以从 Amazon Textract 任务中检索结果，如以下代码片段所示：

   textract_results = textract.get_document_analysis(
       JobId='<JobID that was returned in the previous step>',
       NextToken='<pagination-token>'
   )
   

响应是一个 JSON 对象，包含文本数据块，包括表格和表单内容。在下一节中，我们将讨论如何使用 Amazon Textract 响应解析器简化 JSON 响应对象的解析。

使用 Amazon Textract 响应解析器

本节讨论了 Well-Architected NLP 解决方案矩阵中的原则3.4a（图 18.1）。

Amazon Textract API 返回的 JSON 文档内容非常全面，文档内容被分类为多个块，这些块封装了页面、行、词、表格、表单以及它们之间关系的信息。当使用 Amazon Textract 处理复杂或描述性的文档时，理解 JSON 结果并解析它们以获取我们需要的数据可能显得有些耗时，因为文本在文档中的存储方式各不相同。以下代码片段显示了 Amazon Textract 从我们在第十四章使用的文档中提取的一行的 JSON 响应，审计命名实体识别工作流：

{'BlockType': 'LINE',
   'Confidence': 98.13241577148438,
   'Text': 'Lender Loan No./Universal Loan Identifier',
   'Geometry': {'BoundingBox': {'Width': 0.1989699900150299,
     'Height': 0.008062363602221012,
     'Left': 0.06528056412935257,
     'Top': 0.06330667436122894},
    'Polygon': [{'X': 0.06528056412935257, 'Y': 0.06330667436122894},
     {'X': 0.2642505466938019, 'Y': 0.06330667436122894},
     {'X': 0.2642505466938019, 'Y': 0.07136903703212738},
     {'X': 0.06528056412935257, 'Y': 0.07136903703212738}]},
   'Id': '678695ec-6c9c-4943-9dad-2d64fc5acc44',
   'Relationships': [{'Type': 'CHILD',
     'Ids': ['2600b0dc-ee1b-421b-a7f6-49de293c7b20',
      '70e20616-32b6-45f6-970d-e1a268ee97ec',
      '69792a6d-5df6-4729-8d25-b1f3b05a8cd5',
      'dfc16ed6-a526-46ac-98f3-f50453354c03',
      '71a1f5a2-3ff3-40de-9e58-3288f2ac83ee']}]},   

因此，为了简化从 JSON 输出中提取所需内容的过程，Amazon Textract 响应解析器库（或TRP）（github.com/aws-samples/amazon-textract-response-parser）应运而生。TRP 使我们能够用极少的代码行轻松获取所需的所有数据，并提高我们整体解决方案的效率。我们在本书中已经使用了 TRP，例如在第十四章中，审计命名实体识别工作流，以及第十七章中，从手写内容中可视化洞察。

以下代码片段展示了如何安装和使用 TRP 库：

1. 要安装 TRP 库，请使用以下代码片段：

   !python -m pip install amazon-textract-response-parser
   

2. 导入库，调用 Textract API 来分析文档，并使用 TRP 解析结果：

   from trp import Document
   textract = boto3.client('textract')
   response = textract.analyze_document(Document={'Bytes': bytes_test}, FeatureTypes=['TABLES','FORMS'])
   text = Document(response)
   

3. 现在，我们可以遍历结果以提取页面、表格等数据。有关如何使用 TRP 的Python 示例，请参阅代码示例：github.com/aws-samples/amazon-textract-response-parser/tree/master/src-python#parse-json-response-from-textract

   for page in text.pages:
               for table in page.tables:
   for r, row in enumerate(table.rows):
   for c, cell in enumerate(row.cells):
   

在下一节中，我们将回顾为什么持久化 NLP 解决方案的预测结果非常重要，以及我们如何利用这些数据。

持久化预测结果

在本书的过程中，我们看到了一些示例，其中实体识别或分类任务的结果被发送到Amazon Elasticsearch 实例（用于元数据提取）或 Amazon DynamoDB（用于持久化）。我们还看到了一些示例，这些结果被用来通知影响下游系统的决策。这样做的原因是，因为我们经常看到在组织中，文档处理为其主流业务操作提供了重要的输入。因此，当你设计和构建 NLP 解决方案时，必须考虑预测结果将如何被消费，谁会使用，以及目的是什么。根据消费的使用案例，我们有不同的选项可以使用。让我们回顾一下这些选项：

• 如果需要实时访问推理结果，请设置 API Gateway 和 AWS Lambda 函数，以抽象化 Amazon Comprehend 的实时端点。将推理请求和响应持久化到 Amazon S3 桶或 Amazon DynamoDB 以供将来参考。有关详细信息，请参考使用 API Gateway 进行请求限流部分。

• 如果结果需要发送到需要这些输入进行决策或功能需求的下游应用程序，您可以将结果持久化到 Amazon S3、Amazon RDS 数据库或 AWS 中的任何专用数据存储中。为了通知应用程序有新结果可用，您可以向 Amazon SNS 主题发布消息，或在数据存储中使用事件触发器。有关更多信息，请参考以下链接：docs.aws.amazon.com/lambda/latest/dg/services-rds-tutorial.html

• 如果您需要将结果填充到知识库或使其可供用户搜索，请将其发送到 Amazon Elasticsearch（现称为OpenSearch）索引。有关更多信息，请参考以下链接：docs.aws.amazon.com/opensearch-service/latest/developerguide/search-example.html

• 如果你想将结果用于商业智能或可视化，可以将结果发送到 Amazon S3 存储桶，并使用 Amazon QuickSight 对存储在 Amazon S3 中的数据进行分析。更多信息，请参考以下链接：docs.aws.amazon.com/quicksight/latest/user/getting-started-create-analysis-s3.html

• 如果你想在将结果发送到数据存储之前进行转换，可以使用 AWS Glue ETL 作业。更多详细信息，请参考使用 AWS Glue 进行数据处理和转换部分。

现在，让我们回顾一下如何使用 AWS Step Function 自动化 NLP 解决方案的开发。

使用 AWS Step Function 进行编排

在前面的部分，我们了解了如何使用 Batch API 帮助扩展架构以处理大量文档。我们回顾了 Amazon Comprehend 和 Textract API，这些 API 可以帮助我们实现批处理管道。在开始设计批处理解决方案时，它可能会以一个 Amazon S3 存储桶的形式出现，附加一个 AWS Lambda 事件触发器，该触发器将调用 Amazon Textract API 开始文档分析。然后，一个 Amazon SNS 主题将被提供，Amazon Textract 会将消息发送到该主题，AWS Lambda 将附加到该主题，以此类推。你明白了，这样的解决方案很难管理。为了设计一个优雅高效的 NLP 解决方案，你可以使用 AWS Step Function 来管理整个管道的编排（aws.amazon.com/step-functions/）。

AWS Step Function 是一个无服务器的事件驱动编排服务，可以帮助将多个过程步骤连接起来并进行端到端管理。错误处理是内建的，因此你可以在编排中配置重试、分支和补偿逻辑。以下截图展示了从 AWS 控制台中可用的示例中的 Step Function 编排：

图 18.7 – 一个示例的 Step Function 编排

要开始使用，你可以在 AWS 管理控制台的 Step Function 控制台中运行一个示例编排，方法是选择控制台左侧的运行示例项目，然后选择状态机选项。你还可以尝试这里提供的 Step Function 教程：aws.amazon.com/getting-started/hands-on/create-a-serverless-workflow-step-functions-lambda/

在下一部分，我们将讨论如何使用 AWS CloudFormation 自动化部署过程。

使用 AWS CloudFormation 模板

AWS CloudFormation (aws.amazon.com/cloudformation/) 是一项基础设施即代码服务，帮助你自动化和管理 AWS 中的资源配置任务。在使用 AWS AI 服务构建 NLP 解决方案时，我们主要处理托管服务，但根据我们的操作架构，使用 AWS CloudFormation 来自动化部署过程是非常有意义的。主要原因是它去除了大量与设置相关的开销，使变更管理变得更加简单，并帮助我们实现操作卓越。每个解决方案的拓扑结构都不同，但如果你的 NLP 架构包括 Amazon S3 桶和其他类型的 AWS 数据存储、AWS Step Function、AWS Lambda 函数、Amazon SNS 主题等，那么你将受益于使用 AWS CloudFormation。模板可以用 JSON 或YAML编写，且有大量资源可供你入门。

如果你需要一个包含 AWS Step Function 和 AWS Lambda 函数的 CloudFormation 模板示例，请参考以下链接：docs.aws.amazon.com/step-functions/latest/dg/tutorial-lambda-state-machine-cloudformation.html

如果你需要各种 AWS 服务的模板代码示例，请参考以下链接：docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/CHAP_TemplateQuickRef.html

正如我们在前面的章节中详细看到的，这些是你可以采纳的一些原则和最佳实践，帮助你设计和构建长久有效的 NLP 解决方案，具备成本效益、弹性、可扩展性、安全性和性能效率。这些特征构成了优秀解决方案的关键。

总结

在前几章学习了如何为多个实际应用案例构建 NLP 解决方案之后，本章我们阅读了如何利用 AWS Well-Architected Framework 构建安全、可靠且高效的架构。我们首先介绍了什么是 Well-Architected Framework，并回顾了它所包含的五大支柱：操作卓越、安全性、可靠性、性能效率和成本优化。我们简要阅读了每个支柱的内容，然后讨论了如何通过使用与 Well-Architected 原则和 NLP 解决方案开发不同阶段对齐的最佳实践矩阵，来帮助我们构建更好、更高效的 NLP 解决方案。

在总结了这些最佳实践后，我们深入探讨了每一个实践，学习如何通过 AWS 管理控制台、AWS 文档参考以及一些代码片段来实现它们。

这也意味着本书的结束。我们怀着沉重的心情向你告别，我们亲爱的读者。希望你在阅读这本书时，能像我们写书时那样感到愉快。请不要忘记查看进一步阅读部分，我们为你准备了一些参考资料，帮助你在令人兴奋的自然语言处理（NLP）领域继续学习。

进一步阅读

• AWS Well-Architected Labs (www.wellarchitectedlabs.com/)

• 亚马逊 Textract 博客 (aws.amazon.com/blogs/machine-learning/category/artificial-intelligence/amazon-textract/)

• 亚马逊 Comprehend 博客 (aws.amazon.com/blogs/machine-learning/category/artificial-intelligence/amazon-comprehend/)

• 亚马逊 Comprehend 工作坊 (comprehend-immersionday.workshop.aws/)

• AWS 自动化文档数据处理(aws.amazon.com/machine-learning/ml-use-cases/document-processing/)

Packt.com

订阅我们的在线数字图书馆，全面访问超过 7,000 本书籍和视频，以及行业领先的工具，帮助你规划个人发展并推进职业生涯。欲了解更多信息，请访问我们的网站。

第十九章：为什么订阅？

• 通过来自 4,000 多名行业专业人士的实用电子书和视频，减少学习时间，增加编程时间

• 通过专为你打造的技能规划提升学习效果

• 每月获得一本免费的电子书或视频

• 完全可搜索，便于快速访问重要信息

• 复制和粘贴、打印和收藏内容

你知道 Packt 提供每本已出版书籍的电子书版本，包括 PDF 和 ePub 文件吗？你可以在 packt.com 升级到电子书版本，作为印刷书籍客户，你有权享受电子书折扣。欲了解更多细节，请与我们联系：customercare@packtpub.com。

在 www.packt.com，你还可以阅读一系列免费的技术文章，注册各种免费的通讯，并获得 Packt 书籍和电子书的独家折扣和优惠。

你可能喜欢的其他书籍

如果你喜欢这本书，可能对 Packt 出版的以下其他书籍感兴趣：

使用 Amazon SageMaker 进行机器学习实用手册

Joshua Arvin Lat

ISBN: 978-1-80056-703-0

• 训练和部署 NLP、时间序列预测和计算机视觉模型，解决不同的业务问题

• 使用自定义容器镜像推动 SageMaker 定制化的极限

• 使用 SageMaker Autopilot 的 AutoML 功能创建高质量模型

• 使用有效的数据分析和准备技巧

• 探索用于调试和管理机器学习实验与部署的解决方案

• 使用 SageMaker Clarify 处理偏差检测和机器学习可解释性需求

• 使用各种解决方案自动化中间和复杂的部署与工作流

Amazon SageMaker 最佳实践

Sireesha Muppala 、 Randy DeFauw 、 Shelbee Eigenbrode

ISBN: 978-1-80107-052-2

• 使用 AWS Data Wrangler 和 SageMaker Clarify 执行数据偏差检测

• 使用 SageMaker Feature Store 加速数据处理

• 使用 SageMaker Ground Truth 克服标签偏差

• 通过 SageMaker Debugger 的监控和分析功能改善训练时间

• 使用 SageMaker 模型注册表，通过 CI/CD 解决模型部署自动化的挑战

• 探索 SageMaker Neo 进行模型优化

• 使用 Amazon Model Monitor 实现数据和模型质量监控

• 通过 SageMaker 数据和模型并行性提升训练时间并降低成本

Packt 正在寻找像你一样的作者

如果您有兴趣成为 Packt 的作者，请访问 authors.packtpub.com 并立即申请。我们已经与成千上万的开发者和技术专家合作，帮助他们将自己的见解分享给全球技术社区。您可以提交一般申请，申请我们正在招聘的某个热门话题的作者，或者提交您自己的想法。

分享您的想法

现在您已经完成了《AWS AI 服务中的自然语言处理》，我们很想听听您的想法！如果您是从亚马逊购买的本书，请 点击这里直接进入亚马逊评论页面，分享您的反馈或在您购买该书的网站上留下评论。

您的评论对我们和技术社区非常重要，它将帮助我们确保提供卓越的优质内容。