Python Web 深度学习实用指南：第三部分-阿里云开发者社区

第 3 节：用于 Web 开发的不同深度学习 API 入门

本节将说明 API 在软件开发中的一般用法，并说明如何使用不同的最新深度学习 API 来构建智能 Web 应用。我们将涵盖自然语言处理（NLP）和计算机视觉等领域。

本节包括以下章节：

“第 5 章”，“通过 API 进行深度学习”
“第 6 章”，“使用 Python 在 Google Cloud Platform 上进行深度学习”
“第 7 章”，“使用 Python 的 AWS 上的 DL：对象检测和家庭自动化”
“第 8 章”，“使用 Python 在 Microsoft Azure 上进行深度学习”

五、通过 API 进行深度学习

到目前为止，我们已经熟悉了深度学习项目中遵循的基本流程。在上一章中，我们已经使用 Keras 和 TensorFlow.js 库完成了两个基本的端到端项目。我们已经熟悉 NumPy，pandas 和 Keras 等 Python 库，并且还了解了如何使用 JavaScript 开发深度学习模型。我们还使用了 Flask 框架从深度学习模型中创建 API。在“第 4 章”，“TensorFlow.js 入门”中，我们使用了第三方应用编程接口（API）创建了一个网站应用。

在本章中，我们将详细研究 API 的整个概念。从更为非正式的 API 定义开始，我们将研究与深度学习相关的所有 API。我们将首先看一些最广为人知的深度学习 API，然后再看一些鲜为人知的深度学习 API。我们还将学习如何选择深度学习 API 供应商。

在本章中，我们将讨论以下主题：

什么是 API？
API 与库有何不同？
一些广为人知的深度学习 API
一些鲜为人知的深度学习 API
选择深度学习 API 提供商

什么是 API？

让我们首先考虑一个问题场景。

假设您正在使用需要将图像识别模块集成到其中的 Web 应用。但是您不喜欢计算机视觉和深度学习。您有一个非常严格的截止日期才能参加该项目。您无力致力于学习深度学习，然后完成项目的图像识别模块。您现在应该怎么办？您的项目会在指定的期限内完成吗？

绝对不会！但是，借助 API 的强大功能，您将能够轻松地将图像识别模块集成到 Web 应用中。现在让我们更详细地讨论 API 的概念。

API 是可以集成到应用中以执行某些任务的一组函数（尽管从技术上讲，API 可以仅包含一个函数）。通常，作为开发人员，我们希望将喜欢的网站中的特定工具集成到自己的应用中。例如，Twitter 提供了一个 API，用于检索与某个关键字匹配的推文。我们可以使用此 API 来收集数据，对其进行分析，并最终得出有关数据的有趣见解。

Facebook，Google，Stack Overflow 和 LinkedIn 等公司提供用于某些任务的 API，作为开发人员，值得一试。 API 实际上类似于网站。当我们单击网站上的某些内容时，我们将被重定向到另一个页面/部分。在大多数情况下，我们将网页作为输出。但是，API 通常不会产生美观的网页作为其输出。应该从代码内部使用 API，并且 API 的输出通常采用某些流行的数据交换格式，例如 JSON 或 XML。然后，针对使用 API的应用相应地处理输出。 API 使您可以通过提供一套工具或生态系统来完成想要执行的任务，而不必担心细节。

您现在可以测试 API，而无需编写任何代码。例如，您可以使用诸如 Postman 之类的 API 客户端并测试您真正喜欢的开放 API，并且不需要编写任何代码即可执行此操作。

关于 API 的更神奇之处在于，您可以例如使用 Java 编写代码并使用以 Python 开发的 API。当您在团队中工作时，人们对他们使用的不同编程语言非常关注时，这特别有用。您的一个团队成员可能非常喜欢使用 Java，而另一个团队成员可能是 Python 专家。因此，在这些情况下，API 的整个概念确实派上了用场。

我们将讨论由 Google AI，Facebook AI Research 等提供的一些深度学习 API。在接下来的章节中，我们将看到如何使用这些 API 来开发智能 Web 应用。

使用 API 的重要性

API 除了在需要快速生产或最小工作量的产品演示时为您节省创建和部署自己的深度学习模型的大量工作之外，API 还可以提供一些好处，例如：

一个标准的稳定模型：

深度学习的 API 通常是由一群开发人员共同创建的，这些开发人员共同使用行业标准技术和研究工具，但可能并非所有开发人员都可以使用。而且，通过商业 API 部署的模型通常非常稳定地使用，并提供最新的功能，包括可伸缩性，自定义和准确率。因此，如果您遇到精度问题（这是深度学习模型生产中的常见情况），那么选择 API 是一个不错的选择。

高性能模型：

商业深度学习 API 通常在非常强大的服务器上运行，并且在很大程度上进行了优化，因此它们可以非常快速地执行任务。因此，如果您希望加快深度学习生态系统的学习速度，则此类 API 非常方便。

开发人员常用的平台：

从头开始编写任何东西都很简单，但是当最初编写该文件的人离开时却没有出示适当的文档，而一个新的人不得不从他们停下来的地方开始工作，这将变得非常困难。商业 API 定义了一套操作标准，并且集成有此类 API 的应用易于维护，因为 API 供应商也始终包含大量文档，这意味着开发人员可以事先了解 API。

定期和无缝更新：

对于刚起步的公司来说，一旦他们运行了第一个版本，就花大量的开发时间来改善深度学习模型通常是很昂贵的，特别是如果它们的整个商业模型不是特别以人工智能为中心的话。任何此类用例都将从 API 使用中受益匪浅，因为 API 由推送常规更新和新功能的人员维护。

考虑到所有这些，然后使用 API 提供了最新的技术，高性能和不断发展的模型，这些模型可以一次插入到应用中，然后使用多年，而无需再次考虑 API。

现在，您可能会问 API 和库之间有什么区别。让我们在下一部分中查找。

API 与库有何不同？

如今，术语库和 API 可互换使用。两者之间有很多相似之处，但是在很多方面都不同。与 API 一样，库也提供了可以根据需要使用的函数和类的集合。以下是一些指针，可以帮助您区分库和 API：

库通常特定于编程语言。例如，如果使用的是 PHP 编程环境，则不能使用 SciPy Python 库。但是，您可以开发一个使用 SciPy 的 API，然后使用您的 PHP 代码使用该 API。
开发人员无法直接访问 API。 API 的使用方式与库的使用方式不同。在开发人员实际使用它们之前，许多 API 会强制执行某种认证。在使用库时，我们很少看到这种情况。您可以轻松地覆盖和重载库函数或类，然后按需使用它。
库和 API 可以相互结合使用。许多库在内部使用不同的 API，反之亦然。

这些应该使您对库和 API 之间的基本区别有所了解。但是，如果您仍然难以划清界限，请不必担心：我们将研究许多示例，并且当您完成这些示例时，您肯定可以区分 API 和库。

现在，我们将介绍一些 API，这些 API 广泛用于开发支持深度学习的应用，其中一些众所周知，而有些则不那么受欢迎。

一些广为人知的深度学习 API

在本节中，我们将介绍一些使用最广泛的 API，这些 API 已部署用于各种深度学习任务，例如图像识别，图像中的情感检测，情感分类，语音到文本转换等。为了限制本节中的讨论，我们将深度学习任务分为两大类：

计算机视觉和图像处理
自然语言处理

然后，我们将列出与每个组相关的一些常见任务，并讨论可用于完成这些任务的 API。

现在，让我们快速列出一些常见的深度学习任务，并将其分配给它们的类别：

计算机视觉和图像处理：

图像搜索：就像 Google 搜索一样，图像搜索引擎允许我们搜索与特定图像相似的图像。
图像检测：这是在检测图像的内容。这也称为标签检测。
对象定位：给定包含一组不同对象的图像，这涉及检测图像中的特定对象。
内容审核：给定图像，这涉及检测不适当的内容。
图像归因：给定图像，这涉及到图像的不同特征的提取。

自然语言处理：

词性标记：给定一段文本，这涉及提取文本包含的词性。
主题摘要：给定一段文本，这涉及确定文本所涉及的主题。
情感分类：给定一些文本，这涉及预测文本所传达的情感。
命名实体识别：这涉及自动识别给定句子中存在的不同实体。
语音到文本的转换：这涉及到一段语音中包含的文本的提取。

此处列出的所有任务在我们的日常生活中都非常有用，很高兴得知我们可以使用现在将要讨论的 API 制作能够为我们完成这些任务的应用。

还有其他深度学习 API 可以大规模进行临时推理，但是暂时，我们可以忽略它们，而将注意力集中在受深度学习影响最大的两个领域。

下表汇总了一些业内使用最广泛的深度学习 API：

提供者	API	分组
谷歌	视觉 API	计算机视觉和图像处理
	视频智能 API
	自然语言 API	自然语言处理
	语音转文字 API
	文字转语音 API
	翻译 API
	Dialogflow API
脸书	DensePose	计算机视觉和图像处理
	Detectron
亚马逊	亚马逊 Rekognition	计算机视觉和图像处理
	亚马逊 Comprehend	自然语言处理
	亚马逊 Textract
	亚马逊 Polly
	亚马逊翻译
	亚马逊转写
微软	计算机视觉	计算机视觉和图像处理
	视频索引器
	人脸
	内容主持人
	文字分析	自然语言处理
	必应拼写检查
	翻译文字
	语言理解

上表中显示的 API 是使用经过良好测试和可扩展的深度学习 API 时最受欢迎的 API。但是，还有一些其他名称尚未像这些名称一样流行。在下一节中，我们将研究它们。

一些鲜为人知的深度学习 API

下表提供了一些鲜为人知的 API 的一些详细信息：

提供者	API	组
沃森	沃森虚拟识别	计算机视觉和图像处理
	沃森文字转语音	自然语言处理
	沃森自然语言分类器
	沃森对话
	沃森自然语言理解
AT&T	AT&T 演讲	自然语言处理
Wit.ai	演讲	自然语言处理
	信息
	实体

现在，在这片（几乎是全部）API 中，您如何选择用于特定任务的特定提供者？这可能很棘手，需要进行讨论。在本节中，我们将讨论可以有效帮助我们做出这些决策的一些策略。

选择深度学习 API 提供商

拥有可编译的一整套用于深度学习的 API 供应商，决定所需的 API 可能是一项艰巨的任务。但是，您可以遵循一些简单的规则来提出最适合您的需求的 API，我们将在这里详细讨论其中的一些：

平台：

听起来很简单，这可能是您选择 API 供应商时最重要的因素。例如，在大多数情况下，如果您要开发基于 Google 技术运行的产品，则可能要使用 Google 提供的深度学习 API，因为它们会与您使用的应用开发接口无缝集成。
通常，开发环境还提供模板化的解决方案，以使用其设置非常简单的深度学习 API。有时，提供商可能还会提供额外的激励措施，以使用其 API 开发新产品。

效果：

通过访问多个提供商的 API 来执行一项任务，您可以比较它们的表现，然后选择。在这种情况下，比较和判断不同 API 时所使用的度量标准取决于您。

费用：

不同的提供商使用不同的成本核算方法，这在决定使用哪个提供商方面可以发挥巨大作用。某个提供商可能会对免费 API 调用进行实验的数量有适当的限制，因此对于您来说可能是一个有利可图的选择。通常，有经验的开发人员和学生会选择与成本方面最优惠的提供商合作。

除了这三个因素之外，还有其他一些不可否认的因素，例如一家公司要求使用某个 API 或您自己对某个 API 供应商的倾向。但是，除非大规模使用，否则使用哪个供应商几乎没有多大关系，因为它们都为中小型使用提供相似的表现。

总结

在本章中，我们详细介绍了术语 API。在“第 3 章”和“创建第一个深度学习 Web 应用”中，我们看到了如何使用 Python 编写 Flask API，我们看到了如何在 Web 应用中使用该 API。现在，我们知道 API 与语言库的区别以及使用 API的重要性。我们熟悉一些顶尖组织提供的各种深度学习 API。

在接下来的章节中，我们将了解如何使用这些 API 来构建功能强大且智能的 Web 应用。在下一章中，我们将从 Google Cloud Platform 提供的深度学习 API 开始。

六、Google Cloud Platform 上的 Python 深度学习

在上一章中，我们看到了各种组织提供的各种深度学习 API。我们还看到它们的适用性大致分为两类：第一类是计算机视觉和图像处理，第二类是自然语言处理。我们还将在本章中继续探索深度学习 API。本章向您介绍 Google Cloud Platform（GCP）以及它在深度学习领域提供的三个 API。

在本章中，我们将介绍以下主题：

设置您的 GCP 帐户
在 GCP 上创建您的第一个项目
在 Python 中使用 Dialogflow API
在 Python 中使用 Cloud Vision API
在 Python 中使用 Cloud Translation API

技术要求

您可以从这里访问本章的代码。

要运行本章中的代码，您的系统上需要安装 Python 3.6+。

本章将介绍其他必要的安装。

设置您的 GCP 帐户

在继续使用 GCP 提供的 API 之前，您必须设置您的 GCP 帐户。假设您已经拥有 Google 帐户-首先，转到这里。如果您是第一次注册，GCP 会给您 300 美元的信用额度（您可以使用 12 个月）；这种信誉足以容纳许多优秀项目，并使您能够试用 GCP 的产品。完成此操作后，我们可以按照以下步骤操作：

在 GCP 主页的右上角，您应该能够找到“免费试用”按钮。只需单击它：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qu1sdCXO-1681705088841)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/8d0065fb-e97a-457a-bca4-8a70e70fa661.png)]

如果您尚未登录 Google 帐户，则会要求您登录。相应地选择您所在的国家/地区，并确保选中服务条款框。之后，单击“同意并继续”。您将在以下屏幕截图中看到一个页面：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lf5gf0pK-1681705088842)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/c2b7f7a6-bbb5-4daf-8a80-e52ef7edd315.png)]

然后，系统会要求您输入所选付款方式的详细信息。即使您有免费的积分，也要使用 GCP 的工具，也需要设置一个有效的结算帐户。但请放心，除非您允许 GCP 这样做，否则不会从您的结算帐户中向您收费。免费试用期间，将仅从您的免费信用额中扣除您将在 GCP 上使用的所有计费工具。一旦您的免费信用额度限额终止，GCP 就会向您发送提醒。

完成结算手续后，您应该进入 GCP 的控制台页面，该页面如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0anyOu28-1681705088842)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/469c0188-c363-4a28-a15f-d060ca342a01.png)]

这实际上是您的 GCP 信息中心，可为您提供 GCP 使用情况的总体摘要。 GCP 还允许您自定义出现在 GCP 控制台上的标签。

现在，您应该完成 GCP 帐户设置。为了能够使用 GCP 中的工具，您需要创建一个带有有效账单帐户的 GCP 项目。在下一节中，您将看到如何执行此操作。

在 GCP 上创建您的第一个项目

一个项目可帮助您系统地组织所有 GCP 资源。只需单击几下即可在 GCP 上创建项目：

登录到您的 Google 帐户后，使用这里打开 GCP 控制台。在左上角，您应该看到 Google Cloud Platform，在其旁边，您可以看到一个下拉列表，如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ge827Htt-1681705088842)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/97baa6ef-0c5a-4258-b4d2-f1910f97cc82.png)]

如果您在注册 GCP 或之前注册时确实创建了任何项目，则其中一个项目将显示在标记的区域中（fast-ai-exploration 和 gcp-api 是我在 GCP 上创建的两个项目）。现在，单击向下箭头，将出现一个弹出窗口：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gnvHIM9X-1681705088843)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/d3f3ccc7-fc1e-4338-9fb3-f5704b19b0f7.png)]

单击“新项目”继续。您应该最终显示在以下屏幕快照中的页面上，该页面将要求您指定项目的名称。 GCP 会为您正在创建的项目自动生成一个 ID，但也可以根据您的选择编辑该 ID：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UczKUYgf-1681705088843)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/d1652d62-c16c-4b05-b638-cbbaaebcb4b0.png)]

在指定完项目的初始详细信息之后，只需单击CREATE即可创建该项目。创建项目后，它应出现在项目列表中。您始终可以使用 GCP 在其控制台页面上提供的便捷下拉菜单导航至此列表。您可以在以下屏幕截图中看到它：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jkuBnWkI-1681705088843)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/eec5591a-a3f9-4e1a-b6aa-bbe3b0be234a.png)]

如果您想了解有关 GCP 项目的更多信息，可以在这个页面上查看官方文档。 GCP 配备了各种工具，可在这里中找到。鼓励您看一下，并就自己的兴趣进行探索。

GCP 为我们提供了广泛的 API，可用于各种任务，包括深度学习。在接下来的两节中，我们将了解如何使用 Python 代码来使用一些使用最广泛的深度学习 API。我们将从 Dialogflow 开始。

在 Python 中使用 Dialogflow API

在开始学习如何在 Python 中使用 Dialogflow API 之前，让我们了解 Dialogflow 的全部含义。

Dialogflow（以前称为 api.ai）提供了一套工具，用于构建自然而丰富的对话界面，例如语音助手和聊天机器人。它由深度学习和自然语言处理提供支持，并被许多公司使用。它与网站，移动应用以及许多流行的平台（例如 Facebook Messenger，Amazon Alexa 等）无缝集成。 Dialogflow 为我们提供了构建对话用户界面的三个主要组件：

可以轻松应用于任何对话用户界面的最佳做法和流程
添加构建会话用户界面可能需要的任何自定义逻辑的功能
训练智能体的设施，以便微调界面的整体体验

现在，我们将看到如何使用 Dialogflow 在 Python 中创建一个简单的应用。您可以参考这里了解有关 Dialogflow 的更多信息。

我们将从创建 Dialogflow 帐户开始。

创建一个 Dialogflow 帐户

创建 Dialogflow 帐户非常简单。该过程涉及以下步骤：

访问这里，您将看到以下屏幕：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6bhHB1oq-1681705088844)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/397707d9-086c-4cdf-902b-4ec2d5944ec1.png)]

单击“使用 Google 登录”按钮后，将要求您选择要用于 Dialogflow 的 Google 帐户。
选择帐户时，可能会要求您允许 Diagflow 的帐户权限，并接受 Dialogflow 条款和条件。

创建一个新智能体

创建帐户后，将为您提供一个仪表板，该仪表板将显示您活动的 Dialogflow 项目或要求您创建要显示的新智能体，但是智能体是什么？

用 Dialogflow 术语来说，智能体是一种软件，执行从用户接收输入的任务，该输入可能采用文本，音频，图像或视频的格式。然后，它尝试确定意图或与输入对应的先前定义的适当操作。匹配的意图可能会执行动作，或者可能只是对用户输入的查询产生超文本响应。最后，智能体将结果返回给用户。

要创建新智能体，请在 Dialogflow 控制台的左侧导航菜单中，单击“创建智能体”。

屏幕上将显示以下屏幕：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kJIwFpy3-1681705088844)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/9023d9b6-88bb-447f-aeb6-17b44aae03b8.png)]

我们已将智能体 DemoBot 命名为默认语言，并将其设置为英语。此外，我们必须为智能体选择一个 Google 项目。

Google 项目，或者简称为项目，是您在 GCP 研究中遇到的一个术语。一个项目包含分配给使用这些资源并由 GCP 上的一个计费帐户提供资金的任何软件项目的全部资源。如果没有为资源定义项目，则无法分配资源。此外，如果不向其添加有效的计费选项，则无法创建任何项目。

现在，您将能够看到一个屏幕，如以下屏幕截图所示，其中为您的智能体提供了某些默认意图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HxggLaLw-1681705088844)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/768479fc-f213-41d9-898d-927c60d1869b.png)]

在左侧，您可以看到导航菜单，该菜单提供了可以在您的智能体中组合在一起的所有各种模块，以实现软件提供的更好的类似于人的交互。在右侧面板中，您可以选择随时使用您提供的任何输入来测试智能体。这将在开发响应时以及在测试意图与提供的输入的匹配时派上用场。

创建一个新的意图

要为我们的智能体创建新的意图，请按照下列步骤操作：

单击中间部分右上角的“创建意图”按钮。
您需要为此目的提供一个名称-假设Dummy Intent。
然后，我们将需要提供一些触发此意图的训练短语。假设我们提供了三个训练短语，如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uzAhd3FE-1681705088845)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/a4a2458f-1671-4689-b374-e77d590feef0.png)]

现在，我们可以期望只要系统遇到训练中提到的短语（或类似短语），就会调用此意图。

现在，我们可以添加一些调用该意图时智能体将做出的响应，如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8sONwYyl-1681705088845)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/384b2f86-2a4f-40e0-8d34-b77951aa764d.png)]

在中间部分的右上角，单击“保存”按钮以保存新的意图，然后将通知您座席训练已开始。

对于小型智能体，训练将在几秒钟内完成，并且将为您提供智能体训练已完成的通知。

现在，我们准备测试我们的智能体是否能够执行此意图。

测试您的智能体

在 Dialogflow 控制台的右侧部分，您将能够测试您的智能体。在顶部文本字段中，输入查询。在我们的智能体中，要调用Dummy Intent，我们将编写为Talk to the dummy。

如果意图正确匹配，您将能够看到Dummy Intent的响应，如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xGZxl5ra-1681705088846)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/9846d629-256f-4200-a012-02f6dba24730.png)]

在上一个屏幕截图中，您将看到用户的输入为Talk to the dummy，生成的响应是我们在Dummy Intent响应中定义的两个响应之一。您可以观察到与输入匹配的意图是Dummy Intent。

现在，我们将研究如何使用 Python 调用智能体。

安装 Dialogflow Python SDK

在本节中，我们将演示如何将 Dialogflow Python API V2 与 Dialogflow 智能体一起使用，以使使用 Python 构建的应用具有交互性。首先，让我们了解 DialogFlow 生态系统的几个组件如何与下图交互：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cTzuWAvC-1681705088846)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/48741d83-0b89-4933-a7f4-df36291f5f9a.png)]

用户创建输入，然后通过集成 API，网站或应用将其发送到智能体。智能体将用户输入与可用意图进行匹配，并产生对查询的满足。响应通过 Webhook 发送回用户界面，并将响应呈现给用户。

集成 API 很有可能包含 Dialogflow 以外的服务。您可以创建一个应用，该应用可以将同一用户查询传播到多个智能体并合并他们的响应。

另外，开发人员可以引入中间件处理器或集成，它们将对用户查询和智能体响应进行预处理或后处理：

要安装 Dialogflow Python SDK，我们在终端中使用以下命令：

pip install dialogflow

强烈建议您先使用virtualenv创建一个虚拟环境，然后再使用上一个命令来创建干净无间断的依赖关系。要了解有关virtualenv的更多信息，请参阅这里。

安装完成后，您将可以使用以下导入代码将 Dialogflow API 导入到项目中：

import dialogflow

现在，我们将创建一个 GCP 服务帐户来验证我们的 Python 脚本，以便使用我们创建的 Dialogflow 智能体。

创建 GCP 服务帐户

GCP 服务帐户管理提供的访问 GCP 资源的权限。我们创建的 Dialogflow 智能体是 GCP 资源，因此要从 Python API 使用它，我们需要一个服务帐户：

在 GCP 控制台的左侧导航菜单中，转到“API | 服务 | 证书”。
单击“创建凭据”按钮以获取以下选项：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9t0ZJtuM-1681705088846)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/6bbe0df1-e132-459f-bc1b-f48cfb9be413.png)]

单击“服务帐户密钥”。在接下来出现的页面中，选择Dialogflow Integrations作为服务帐户，选择 JSON 作为密钥类型。单击“创建”后，将 JSON 文件下载到您的计算机。
记下此 JSON 文件的地址，例如/home/user/Downloads/service-account-file.json。文件名可能会有所不同，因为将文件下载到计算机时由 GCP 控制台提供。
打开此文件以获取项目 ID。
现在，在终端中使用以下命令（系统中将使用适当的替代命令）将凭据导出到环境变量：

export GOOGLE_APPLICATION_CREDENTIALS="<your_service_account_file_location>"
export DIALOGFLOW_PROJECT_ID="<your_project_id>"

set GOOGLE_APPLICATION_CREDENTIALS=<your_service_account_file_location>
set DIALOGFLOW_PROJECT_ID=<your_project_id>

完成此操作后，我们现在就可以编写将调用 Dialogflow 智能体的 Python 脚本了。

请注意，前面的命令仅设置当前会话的变量。每次重新启动会话时，都需要运行命令。

使用 Python API 调用 Dialogflow 智能体

在此示例中，我们将创建一个简单的基于 Python 的 API，该 API 调用在 Dialogflow 控制台中创建的智能体以调用Dummy Intent，如下所示：

首先，我们必须将 Dialogflow 模块导入到项目中。为此，请使用以下代码：

import dialogflow

为了将项目 ID 放入脚本中，我们可以从运行时环境变量中获取它。为此，请使用以下代码：

import os
project_id = os.getenv("DIALOGFLOW_PROJECT_ID")

我们还将声明一个唯一的会话 ID，以存储在与用户进行的任何单个会话中进行的会话的记录：

session_id="any_random_unique_string"

现在，我们将创建一个方便的函数，该函数将允许我们重复执行调用 Dialogflow 智能体所需的一组预处理语句：

def detect_intent(project_id, session_id, text, language_code):
    session_client = dialogflow.SessionsClient()
    session = session_client.session_path(project_id, session_id)
    text_input = dialogflow.types.TextInput(text=text, language_code=language_code)
    query_input = dialogflow.types.QueryInput(text=text_input)
    response = session_client.detect_intent(session=session, query_input=query_input)
    return response.query_result.fulfillment_text

在前面的代码中，我们将首先初始化SessionsClient对象。一个会话记录了一次不间断会话期间用户与 Dialogflow 智能体之间的完整交互。接下来，我们必须设置会话的路径，这是项目到唯一会话 ID 的映射。

前面的函数定义的后两行用于创建包含 Dialogflow TextInput对象的 Dialogflow QueryInput对象。 query_input变量保存用户为 Dialogflow 智能体输入的消息。

下一行调用SessionsClient对象的detect_intent()方法。 session ID-project ID映射与输入一起作为参数传递给方法。 Dialogflow 智能体的响应存储在响应变量中。该函数返回实现文本响应。

现在让我们使用此方法。首先，声明一条消息以传递给 Dialogflow 智能体。回忆我们为Dummy Intent提供给 Dialogflow 智能体的训练短语。我们将传递与训练短语相似的消息：

message = "Can I talk to the dummy?"
fulfillment_text = detect_intent(project_id, session_id, message, 'en')
print(fulfillment_text)

我们将获得一个输出，该输出是我们为Dummy Intent定义的两个响应之一。

在detect_intent()方法中生成响应变量，可以通过在detect_intent()函数中添加以下代码行来完成：

def detect_intent(project_id, session_id, text, language_code):
    ...
    response = session_client.detect_intent(session=session, query_input=query_input)
    print(response) ### <--- ADD THIS LINE
    return response.query_result.fulfillment_text

您将获得以下 JSON：

response_id: "d1a7b2bf-0000-0000-0000-81161394cc24"
query_result {
  query_text: "talk to the dummy?"
  parameters {
  }
  all_required_params_present: true
  fulfillment_text: "Congratulations, dummy intent user!"
  fulfillment_messages {
    text {
      text: "Congratulations, dummy intent user!"
    }
  }
  intent {
    name: "projects/gcp-api-232806/agent/intents/35e15aa5-0000-0000-0000-672d46bcefa7"
    display_name: "Dummy Intent"
  }
  intent_detection_confidence: 0.8199999928474426
  language_code: "en"
}

您将观察到匹配的意图的名称为Dummy Intent，而在此智能体调用中我们得到的输出为Congratulations, dummy intent user!。

还有其他几种使用 Python 使用 Dialogflow API 的方法，包括但不限于视听输入和基于传感器的输入。 Dialogflow 智能体可以与主要平台集成，例如 Google Assistant，Facebook Messenger，Slack，Telegram，WhatsApp 和其他几个平台，如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sFTTKpD5-1681705088847)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/1d530c5f-6145-41e3-8de2-e80c9a4b511e.png)]

Dialogflow 生态系统正在迅速引入新功能，并且正朝着提供可以同时执行多个任务的完整的基于 AI 的聊天机器人的方向发展。

在下一节中，我们将探索另一个 GCP API，该 API 可用于预测图像和视频的内容。

在 Python 中使用 Cloud Vision API

计算机视觉是使计算机理解图像并理解图像的领域。常见的计算机视觉任务包括图像分类，图像检测，图像分割等。如前几章所述，深度学习在实现人类水平（有时甚至更好）的表现方面的有效性已严重影响了计算机视觉领域。

Cloud Vision API 为我们提供了许多用于执行计算机视觉任务的工具。 Cloud Vision 允许我们使用预先训练的模型，以及建立自己的定制生产模型来满足我们的需求（例如 AutoML Vision Beta）。现在让我们简要地看一下 Cloud Vision API 提供的功能：

标签检测
光学字符识别
手写识别
地标检测
对象定位
图片搜索
产品搜索

除了前面提到的功能之外，Cloud Vision 还允许我们提取给定图像的不同属性。以下屏幕截图显示了此工具：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9IMTjW9Y-1681705088847)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/278c72a8-1139-4273-a4e3-2d4f2274343d.png)]

如我们所见，当提供图像时，Cloud Vision API 会自动提取其属性。您也可以通过转到这里来尝试此操作。

从较早的章节开始，我们一直在使用术语预训练模型。我们还看到了 Cloud Vision API 如何使我们整合预训练的模型。为了理解使用它们的重要性，有必要对术语“预训练的模型”进行更深入的研究。

使用预训练模型的重要性

预训练模型的使用通常称为迁移学习。迁移学习并不是深度学习的基础，它只是一种方法。它并不表示特定的深度学习模型，但其对迁移学习的含义非常有效，尤其是在深度学习环境中。

我们人类不会从头开始学习每一项任务。我们尝试利用过去的经验来完成性质相似的任务。这是迁移学习。我们倾向于将过去的经验知识迁移到我们遇到的类似任务上。

但这如何适用于深度学习？让我们找出答案。

当针对特定任务训练神经网络时，它会尝试估计可能的最佳权重矩阵的值。现在，当您尝试在类似任务上训练另一个网络时，事实证明您可以使用上一个任务的权重。这里的“相似性”定义很宽泛，暂时可以避免。但是您可能想知道这里的优势是什么。好吧，优点是多方面的，但是这里有两个示例：

您无需从头开始训练您的神经网络，这可以节省大量时间。
它利用了机会来使用与您的问题域类似的最新结果。

在文献中，使用网络权重的任务称为源任务，将权重应用于的任务称为目标任务。您使用权重所依据的网络模型称为预训练模型。 Goodfellow 等。在他们的书深度学习中给出了迁移学习的非常微妙的定义：

“在一种情况下所学到的东西被用来改善另一种情况下的泛化性的情况。”

在自然语言处理（NLP），计算机视觉等领域的广泛深度学习应用中，迁移学习的使用已显示出非凡的成果。但是，迁移学习也有其局限性：

当源任务与使用迁移学习的任务不充分相关时，迁移学习会导致表现下降。
有时很难确定从源任务到目标任务需要多少迁移。

对于迁移学习的深入研究，建议您阅读 Dipanjan 等人的书籍《Python 迁移学习实践指南》。现在，我们将借助示例学习如何使用 Python 使用 Cloud Vision API。

设置视觉客户端库

Cloud Vision API 可通过一组适用于不同语言的库（称为 Vision Client 库）获得。

此集中提供的一个此类库是 Python Cloud Vision 客户端库，我们将在示例中使用该库：

要安装 Python Cloud Vision 客户端库，我们在终端中使用以下命令：

pip install --upgrade google-cloud-vision

强烈建议您使用 Python 虚拟环境安装 Vision Client 库。

安装完成后，我们将需要设置一个服务帐户以使用 API。
如前所述，设置服务帐户应遵循的步骤如下：

打开 Google Cloud 控制台。
转到“API | 服务 | 证书”。
单击“创建凭据”。
在下拉菜单中选择“新服务帐户”以选择服务帐户。
填写服务帐户的任何名称。
取消选中角色。使用 Cloud Vision API 时不需要这样做。
单击“创建”。确认出现的所有警告框。
service account credentials JSON 文件已下载到您的计算机。

现在，像我们之前所做的那样，将下载的文件导出到系统环境。为此，请使用以下命令：

export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/service-account-file.json"

set GOOGLE_APPLICATION_CREDENTIALS=/home/user/Downloads/service-account-file.json

作为使用 Cloud Vision API 的最后一步，我们需要在我们为其创建服务帐户的项目中启用该 API。为此，请执行以下操作：

在 Google Cloud 控制台的左侧导航面板中，单击“API 和服务”。
单击“启用 API 和服务”。
在出现的列表中找到 Cloud Vision API。
单击“启用”。

之后，我们准备在脚本中使用 Python 使用 Cloud Vision API。

使用 Python 调用 Cloud Vision API

让我们创建一个新的 Python 脚本（或 Jupyter 笔记本）。为了使用 Cloud Vision API，我们首先需要导入 Cloud Vision 客户端库。

为此，我们使用以下代码：

from google.cloud import vision

这样，我们就可以继续使用客户端库了。在我们的示例中，我们将对图像进行标注。图像标注服务由视觉库中的imageAnnotatorClient()函数提供。我们将创建该方法的对象：

client = vision.ImageAnnotatorClient()

现在，让我们将要测试的文件加载到程序中：

with open("test.jpg", 'rb') as image_file:
    content = image_file.read()

请注意，您必须在同一工作目录中包含test.jpg文件，此文件才能工作。

该文件当前是程序的原始二进制数据文件。为了使 Cloud Vision API 正常工作，我们需要将其转换为 Vision 客户端将接受的图像类型：

image = vision.types.Image(content=content)

最后，我们呼吁 GCP 通过 Cloud Vision API 标注图像：

response = client.label_detection(image=image)
labels = response.label_annotations

在打印了视觉 API 设置的标签后，我们将能够在提供的图片中查看 Cloud Vision API 能够检测到的所有可能的对象和功能，如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AtTH4SL9-1681705088847)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/20979113-d6cc-4b94-be0e-1fc2f49ba1c0.png)]

如果打印labels，结果应如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EDoH6oKc-1681705088847)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/fccb87ea-584c-4f34-8559-40f1e95c5206.png)]

预测的标记是Sky，Horizon，Atmosphere，Sunrise，Sunset，Morning，Ocean，Calm，Wing和Evening。

先前的预测非常接近先前照片中捕获的真实场景。那是日出，是从飞机窗上取下来的。

在 Python 中使用 Cloud Translation API

Cloud Translation API 可帮助开发人员轻松地将语言翻译功能集成到他们的应用中。它由最新的神经机器翻译提供支持，可以将其视为深度学习和机器翻译的结合。 Cloud Translation API 提供了用于使用预训练模型和构建可用于生产环境的自定义模型的编程接口。

许多开发人员使用 Cloud Translation API 的预训练模型将给定的一组文本动态翻译为目标语言。 Cloud Translate API 支持 100 多种语言。但是，该语言库正在不断发展，以增强开发人员社区的能力。以下屏幕截图显示了一些英语翻译成孟加拉语的译文：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yrpDA2M5-1681705088848)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/eb0bdcce-a7ea-47a3-bd8f-4f49cb6251a6.png)]

您随时可以在这个页面上尝试此操作。但是有时，给定文本的语言本身可能是未知的。 Cloud Translation API 提供了称为标签检测的服务来处理此类情况。

Cloud Translation API 的 AutoML 变体使我们可以根据需要针对语言对（源语言和目标语言）构建自定义模型。

设置适用于 Python 的 Cloud Translate API

要将 Cloud Translation API 与 Python 一起使用，我们必须首先安装 Google Cloud Translate Python 库。

为此，请在终端中使用以下pip命令：

pip install google-cloud-translate

现在，像以前一样，创建一个服务帐户并下载凭据文件。将此文件导出到GOOGLE_APPLICATION_CREDENTIALS环境变量的路径。
接下来，在要启用的 API 列表中找到Cloud Translate API。完成后，我们准备使用 GCP 直接从 Python 进行翻译。

使用 Google Cloud Translation Python 库

创建一个新的 Jupyter 笔记本或新的 Python 脚本。现在，我们将 Google Cloud Translate API 导入我们的项目。

为此，请使用以下代码：

from google.cloud import translate_v2 as translate

我们将需要创建一个 Cloud Translate API 对象来进行服务调用。我们可以这样做，如下所示：

translate_client = translate.Client()

现在让我们开始翻译过程。首先，我们需要一条消息来翻译：

original = u'नमस्ते'

这样会在印地语中创建一个包含单词Namaste的 Unicode 字符串。让我们看看它会转换成英文！

我们调用 API 使用以下代码将文本翻译成英文：

translation = translate_client.translate(original, target_language="en")

如果观察translation变量，则会发现它包含以下详细信息：

{
    'translatedText': 'Hello', 
    'detectedSourceLanguage': 'hi', 
    'input': 'नमस्ते'
}

从该词典中可以轻松推断出检测到的语言是印地语（由hi表示）。输入以输入的格式显示。translatedText保留Hello，这是Namaste的确切翻译。

总结

在本章中，我们探讨了 GCP 提供的一些著名的突破性的基于深度学习的服务。我们学习了如何使用 Python 使用 Dialogflow 来构建可以随时间学习的对话式聊天机器人。我们使用 Cloud Vision API 来预测任何图像中识别出的对象。我们可以轻松地将其推断为视频并获得类似的结果。最后，我们介绍了 Cloud Translate API，用于使用该服务执行基于 NLP 的深度转换。 GCP 提供的所有主要服务都可以通过 API 进行访问，这使得它们可以在任何项目中轻松替换。由训练有素的专业人员创建的模型的准确率值得称赞，并且在尝试构建基于 AI 的 Web 解决方案时，使 Web 开发人员的工作更加轻松。

在下一章中，我们将介绍 Amazon Web Services（AWS）提供的功能，以使用 Python 将 AI 与 Web 应用集成。

七、AWS 上的 Python DL：对象检测和家庭自动化

我们熟悉了 Google Cloud Platform 的一些基于深度学习的产品，并在“第 6 章”，“在 Google Cloud Platform 上使用 Python 进行深度学习”中学习了如何使用它们。现在，我们对云计算有了一个很好的概述，在本章中，我们将介绍另一个云计算平台 Amazon Web Services（AWS），该平台还提供了一些高性能的，以及高度可靠的基于深度学习的解决方案，使生活更加轻松。在本章中，我们将以 API 的形式介绍它们中的两个，并学习如何从 Python 程序中使用它们。

我们将首先设置我们的 AWS 账户并在 Python 中配置 boto3。然后，我们将学习如何在 Python 中使用 Rekognition API 和 Alexa API。

在本章中，我们将介绍以下主题：

设置您的 AWS 账户
AWS 产品简介
在 Python 中配置 boto3
在 Python 中使用 Rekognition API
在 Python 中使用 Alexa API

技术要求

您可以在这个页面上访问本章的代码。

要运行本章中的代码，您将需要以下软件：

Python 3.6+
Python PIL 库

本章将介绍所有其他安装。

AWS 入门

在使用任何 AWS 服务或 API 之前，您必须创建您的 AWS 账户。在本部分中，我们将快速完成在 AWS 中创建帐户的步骤：

第一步是转到这里。您应该进入类似于以下内容的页面：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fgpBpRvl-1681705088848)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/6c5749db-c62e-4e24-b514-9ca21e1afe34.png)]

然后单击“创建 AWS 账户”按钮，这将带您到以下页面：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tZS9KqwQ-1681705088848)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/69673107-63a9-4cbd-99da-9d9d8fc6876b.png)]

填写字段，然后单击“继续”。
门户将要求您提供一些更强制性的信息。它还将要求您注册一种付款方式以验证您的详细信息。

如果您不提供此服务，则您无权使用 AWS 工具的免费层。

在注册的最后一步，将要求您在三个计划中选择：免费，开发人员和商业。选择与您的需求相关的任何一个，然后继续。

与 Google Cloud Platform 一样，AWS 还提供免费的层访问。首次注册 AWS 时，您可以免费使用多种 AWS 服务和产品，但只能使用一定数量的配额。您可以转到这里了解更多信息。

完成上述步骤后，您将获得如下页面：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RW7Ko11B-1681705088848)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/5ff22c05-d2b5-4d25-9f60-b37da3ec231c.png)]

AWS 具有为用户推荐解决方案和服务的美丽功能。为了充分利用此功能，您需要输入两件事-您的角色和您感兴趣的主题。您可以在前面的屏幕截图中看到它。输入这两个详细信息，然后单击“提交”以获取一些有针对性的产品建议。

下一步是单击“登录到控制台”按钮。

成功登录到 AWS 控制台后，应该会看到以下窗口：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ez9a1csb-1681705088849)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/fe00e39b-59ba-4a1f-a61c-0f67d4cca381.png)]

在 AWS 控制台中，您可以找到 AWS 必须提供的所有服务和解决方案。单击“服务”选项卡，以随意探索整套服务。您也可以从搜索栏中搜索特定的服务。

到现在为止，我们的 AWS 账户应该已经准备好让我们动手了。在下一节中，我们将简要回顾 AWS 的产品，以更好地了解该平台。

AWS 产品简介

AWS 在各种领域中提供其服务和解决方案。以下是 AWS 提供的不同类型的模块（括号中的是 AWS 提供的不同服务的名称）：

计算（EC2，Lambda 等）
存储（S3，Storage Gateway 等）
机器学习（Amazon SageMaker，AWS DeepLens 等）
数据库（RDS，DynamoDB 等）
迁移和传输（Snowball，DataSync 等）
网络和内容交付（CloudFront，VPC 等）
开发人员工具（CodeStar，CodeCommit 等）
机器人技术（AWS RoboMaker）
区块链（Amazon Managed Blockchain）
分析（Athena，CloudSearch 等）

还有许多其他内容，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sSCbYiX7-1681705088849)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/e773d1e1-5b71-45f0-b465-66fc5d2902dd.png)]

该列表实际上是相当广泛的，但是暂时让我们将重点局限于机器学习（也称为深度学习）服务。

AWS 控制台中的搜索栏还使您可以搜索可能已经听说过的 AWS API。让我们在其中键入Rekognition并点击Enter。应该为您提供 Rekognition 的主页，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ML2aiLfg-1681705088849)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/4df1029c-865e-4d73-8f88-fcb487bf9849.png)]

我们将在本章后面详细介绍 Rekognition API。在下一部分中，我们将学习如何使用 boto3（一个提供 Python 编程接口的 AWS 开发工具包）与不同的 AWS 资源进行交互。

Boto3 入门

boto3 是由 AWS 团队提供的用于与 AWS API 通信的官方库。您可以在这个页面中找到该库，可以使用以下命令进行安装：

pip install boto3

安装后，您需要配置 boto3 以用于您的项目。要配置 boto3，第一步是从身份和访问管理（IAM）控制台。请执行以下步骤来执行配置：

转到这里的 AWS IAM 控制台。它将如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U7N8lb2y-1681705088849)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/53fc5106-5219-4269-9ace-5c45edc32c8b.png)]

在前面的仪表板上，您将能够看到访问键。

单击删除您的根访问密钥，然后单击管理安全证书。您将看到以下窗口：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6Hu93V3k-1681705088849)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/3bb72eab-b62e-42b6-9dee-6cd77653770d.png)]

展开**访问密钥（访问密钥 ID 和秘密访问密钥）**选项卡，然后从那里获取访问密钥。密钥成功生成后，您应该获得以下消息：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YJpjq5eS-1681705088850)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/2426808b-f6a7-462d-9692-8162fc50efbd.png)]

下载密钥文件并将其保存在安全的地方，因为配置 boto3 时需要此文件。

配置环境变量并安装 boto3

获得访问密钥后，创建两个环境变量aws_access_key_id和aws_secret_access_key。现在，在您拥有的键的帮助下相应地分配它们的值。密钥将包含有助于您区分密钥 ID 和秘密访问密钥的信息。现在，您已经配置了必要的环境变量，我们可以从在 Python 中加载环境变量开始。

在 Python 中加载环境变量

成功安装该库之后，可以使用以下代码行加载刚刚创建的环境变量：

import os
aws_access_key_id= os.environ['aws_access_key_id']
aws_secret_access_key = os.environ['aws_secret_access_key']

一旦正确加载了环境变量，我们就可以调用 boto3 与 AWS 资源进行交互。假设您想加入您的 AWS 账户中拥有的 S3 存储桶，并希望将图像上传到特定存储桶。 S3 是您要访问的 AWS 资源。如果您的 AWS 账户中没有任何 S3 存储桶，则无需担心；您可以快速创建一个。

创建一个 S3 存储桶

您可以通过执行以下步骤快速创建 S3 存储桶：

转到 S3 控制台的主页。它应如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-96FHrPx0-1681705088850)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/2f02b3a1-2449-470f-a1ab-2ee93093e353.png)]

点击创建存储区。系统将要求您输入以下详细信息：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gjfHCInV-1681705088850)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/e9399ac7-840c-447c-93be-18677c3b69ea.png)]

为您的存储桶命名，保留所有内容，然后单击创建。成功创建存储桶后，您将能够从 S3 控制台中看到它：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Zx4hCkdk-1681705088850)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/86871ff5-e121-4939-b639-80c9587e7c56.png)]

接下来，我们将学习如何使用 boto3 从 Python 代码访问 S3。

使用 boto3 从 Python 代码访问 S3

现在，您可以从 Python 代码访问 S3 存储桶。以下代码行将向您显示可用的存储桶：

import boto3
s3 = boto3.resource(
    's3',
    aws_access_key_id=aws_access_key_id,
    aws_secret_access_key=aws_secret_access_key
)

您在resource()的第一个参数中指定了对访问 S3 感兴趣。您可以在这里阅读文档。现在，您可以通过以下几行代码找到可用的存储桶：

for bucket in s3.buckets.all():
 print(bucket.name)

您应该获得列表作为输出。现在，假设您要将图像上传到存储桶之一。假设您要上传的图像位于当前工作目录中，则以下代码行应将图像上传到特定的 S3 存储桶：

data = open('my_image.jpeg', 'rb')
s3.Bucket('demo-bucket-sayak').put_object(Key='my_image.jpeg', Body=data)

前面的代码行包含以下功能：

my_image.jpeg是您要上传图像的路径。
Bucket()方法中是将图像上传到的 S3 存储桶的名称。

如果代码成功执行，您应该收到以下输出：

s3.Object(bucket_name='demo-bucket-sayak', key='my_image.jpeg')

您可以转到 AWS S3 控制台，然后输入将映像上传到的存储桶，以验证是否已上传映像。您应该在那里看到以下内容：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xiFxtJd6-1681705088851)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/ea5a0e67-5997-4205-836e-532a4560ee54.png)]

现在您已经在 Python 中成功配置了 boto3，我们现在可以继续学习如何使用 boto3 在 Python 中使用 Rekognition 和 Alexa API。

在 Python 中使用 Rekognition API

Amazon Rekognition 是启用了深度学习的视觉分析服务，可以帮助您无缝搜索，验证和分析数十亿张图像。让我们首先简要回顾一下 Recognition API，然后我们将直接在 Python 中使用它。首先让我们进入 Rekognition API 的主页。我们已经在本章前面的部分之一中看到了 Rekognition 的主页。

您可能已经从导航栏中注意到了，Rekognition API 提供了几项功能：

对象和场景检测：这使您可以自动标记给定图像中的对象，标签和场景（以及置信度得分）。
图像审核：这使您可以检测图像中明显或暗示的成人内容以及置信度得分。
名人识别：使用此功能，您可以自动识别图像中的名人（以及置信度得分）。
人脸比较：可用于基于相似度百分比查看脸部匹配的紧密程度。

除了这些功能之外，它还有更多功能。

Rekognition API 提供的解决方案已被证明对各种各样的组织非常有用，因为它们可以真正解决一些现实世界和具有挑战性的问题。您可以通过单击 API 主页上的相应解决方案来尝试快速演示上述列表中提到的任何解决方案。让我们尝试一下名人识别解决方案。

首先，转到这里（请注意，该区域可能会有所不同）。它应如下图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m8Y2psNm-1681705088851)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/5d0a60f8-7ee3-4e21-84ec-0679a3475f7f.png)]

该门户将允许您上传自己的图像并进行测试。让我们测试一下我的图像（我们可以拍摄媒体名人的图像，但是这些图像受版权保护）。您可以看到预期的结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nou9fylZ-1681705088851)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/48570a56-c2cb-48b9-8d36-309bf77bcf96.png)]

也可以尝试其他解决方案。现在让我们看看如何从 Python 代码中使用 Rekognition API：

创建一个新的 Jupyter 笔记本。首先，您将要创建一个新的 Jupyter 笔记本，名称为Sample.ipynb。您将必须提供要使用 AWS Rekognition API 进行名人识别测试的图像，如 Jupyter 的以下目录结构屏幕快照所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6eIC7qOI-1681705088851)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/036c3c11-7381-44b9-83a5-f2c6f4f0b71f.png)]

将环境变量导入您的 AWS 账户中的凭证。您将需要像之前在 boto3 配置部分中所做的那样，将帐户凭据导入到脚本中。为此，请使用以下代码：

import os
aws_access_key_id= os.environ['aws_access_key_id']
aws_secret_access_key = os.environ['aws_secret_access_key']

使用 boto3 创建一个 AWS Rekognition API 客户端。现在，我们可以实例化 boto3 Rekognition API 客户端对象。为此，我们需要将希望使用的 API 以及希望使用该 API 的 AWS 区域名称传递给boto3对象。您还必须传递在上一步中检索到的凭据，如以下代码所示：

import boto3
client=boto3.client('rekognition', region_name='us-east-1', aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_secret_access_key)

从磁盘读取映像，并将其传递给 API。从 boto3 SDK 将文件发布到 AWS API 的方法有两种。首先，您可以直接从您具有权限的 S3 存储桶中发送它们，也可以从本地磁盘将图像作为Bytes数组发送。在上一节中，我们已经了解了如何从 S3 存储桶中查找图像。

现在，我们将向您展示一个示例，其中我们从本地磁盘中获取大量图像并将其通过 API 调用传递：

首先，使用 Python 的本机方法将图像读取到变量中以打开文件，如以下代码所示：

image = open("image.jpg", "rb")

现在，要通过前面实例化的客户端将其传递给 API，请使用以下代码行：

response = client.recognize_celebrities(Image={'Bytes':image.read()})

观察响应。一旦 API 调用成功，您的response变量将保存 API 返回的信息。要查看它，请打印变量：

{'CelebrityFaces': [{'Urls': ['www.imdb.com/name/nm1682433'],
 'Name': 'Barack Obama',
 'Id': '3R3sg9u',
 'Face': {'BoundingBox': {'Width': 0.3392857015132904,
 'Height': 0.27056020498275757,
 'Left': 0.324404776096344,
 'Top': 0.06436233967542648},
 'Confidence': 99.97088623046875,
 'Landmarks': [{'Type': 'eyeLeft',
 'X': 0.44199424982070923,
 'Y': 0.17130307853221893},
 {'Type': 'eyeRight', 'X': 0.5501364469528198, 'Y': 0.1697501391172409},
 {'Type': 'nose', 'X': 0.4932120144367218, 'Y': 0.2165488302707672},
 {'Type': 'mouthLeft', 'X': 0.43547138571739197, 'Y': 0.25405779480934143},
 {'Type': 'mouthRight', 'X': 0.552975058555603, 'Y': 0.2527817189693451}],
 'Pose': {'Roll': -1.301725149154663,
 'Yaw': -1.5216708183288574,
 'Pitch': 1.9823487997055054},
 'Quality': {'Brightness': 82.28946685791016,
 'Sharpness': 96.63640594482422}},
 'MatchConfidence': 96.0}],
 'UnrecognizedFaces': [],
 'ResponseMetadata': {'RequestId': 'ba909ea2-67f1-11e9-8ac8-39b792b4a620',
 'HTTPStatusCode': 200,
 'HTTPHeaders': {'content-type': 'application/x-amz-json-1.1',
 'date': 'Fri, 26 Apr 2019 07:05:55 GMT',
 'x-amzn-requestid': 'ba909ea2-67f1-11e9-8ac8-39b792b4a620',
 'content-length': '813',
 'connection': 'keep-alive'},
 'RetryAttempts': 0}}

API 将我们的形象识别为巴拉克·奥巴马（Barack Obama）。它为我们提供了许多其他有用的信息，例如面部匹配的BoundingBox，预测的Confidence，眼睛，嘴巴和鼻子的位置等。我们可以使用此信息对图像进行进一步的操作，例如，简单地裁剪出匹配的部分。

获取图像的匹配部分。要在可识别的位置准备图像的裁剪版本，我们可以使用以下代码：

from PIL import Image
from IPython.display import display
im=Image.open('image.jpg')
w, h = im.size
celeb = response['CelebrityFaces'][0]['Face']['BoundingBox']
x1 = (celeb["Left"])*w
y1 = (celeb["Top"])*h
x2 = (celeb["Left"] + celeb["Width"])*w
y2 = (celeb["Top"] + celeb["Height"])*h
box=(x1,y1,x2,y2)
im1=im.crop(box)
display(im1)

您应该看到以下图像是最终结果，它是 API 生成的用于执行名人识别的边界框：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RAGS1Pyq-1681705088851)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/175087bb-bb71-47a3-80ae-81095e96551f.png)]

在进一步探索适用于 AWS 的 boto3 API 时，您将认识到它能够处理所有 AWS 服务，而不仅限于 Rekognition API。这意味着，根据 API 规范要求，只需稍作修改，即可将几乎所有可用的 API 用于前面的示例代码。

在接下来的部分中，我们将看一下 Alexa，这是亚马逊的旗舰产品，用于构建语音接口，这些接口的功能可以从聊天机器人到虚拟个人助理。我们将学习如何使用 Alexa 构建简单的家庭自动化解决方案。

在 Python 中使用 Alexa API

亚马逊 Alexa 是由亚马逊开发的基于语音的个人助理。该产品首先以 Amazon Echo 设备的界面为特色，随后又激发了使用 Google Assistant 的 Google 的 Google Home 设备。 Alexa 的其他竞争对手是微软的 Cortana 和苹果的 Siri。作为虚拟助手，Alexa 可以轻松设置呼叫，安排会议或播放歌曲。 Alexa 可以执行的各种任务在 Alexa 术语中称为技能，我们将在本节中介绍这些技能。

Alexa 的技能是我们如何将功能引入平台的主要核心。需要从 Alexa 的主界面调用每个技能，然后该技能将接管整个功能，除非程序逻辑完成或用户明确要求该技能结束。技能将逻辑应用于要执行的任务，因此该逻辑需要存储在某个地方，也许还连同数据库和执行运行时一起存储。尽管许多技能都托管在 Heroku，PythonAnywhere，GCP 等多种服务上，但是托管技能和逻辑代码作为 AWS Lambda 函数是很常见的。

在本节中，我们将使用适用于 Alexa 的 Python SDK 创建示例家庭自动化 Alexa 技能，并将其托管在 AWS Lambda 上。

项目的前提条件和框图

在开始构建 Alexa 技能之前，您将分别需要在 AWS 和 Amazon Developer 上使用以下两种类型的帐户：

一个 AWS 账户（免费套餐有效）— aws.amazon.com
亚马逊开发者帐户（免费）— developer.amazon.com

一旦创建了这些帐户（其过程超出了本书的范围），您就可以继续创建我们的家庭自动化技能。以下框图显示了我们将要创建的家庭自动化技能的架构：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OMZK4zMK-1681705088852)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/dc3b9bf7-c327-4b8b-ab37-7039b36c77f6.png)]

在构建此技能时，我们将使用以下服务，您可以通过以下列表中的链接来了解更多信息：

为技能创建配置

技能要求服务之间有一定程度的联系才能正常工作。此外，需要将部署在 AWS Lambda 上的技能逻辑配置为供 Alexa 上的技能使用。在工作文件夹的根目录中创建一个setup.txt文件，内容如下。随着本节中各步骤的进行，我们将逐步添加该内容：

[LWA Client ID]
amzn1.application-oa2-client.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
[LWA Client Secret]
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
[Alexa Skill ID]
amzn1.ask.skill.XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
[AWS Lambda ARN]
arn:aws:lambda:us-east-1:XXXXXXXXXXXX:function:skill-sample-language-smarthome-switch
[APIs]
https://pitangui.amazon.com/api/skill/link/XXXXXXXXXXXXXX
https://layla.amazon.com/api/skill/link/XXXXXXXXXXXXXX
https://alexa.amazon.co.jp/api/skill/link/XXXXXXXXXXXXXX

在以下各节中，我们将将此文件称为setup.txt。这实际上仅包含有关您的技能的信息。也可以在其他任何文本编辑器（例如 Google Docs）中随意实现此功能。

Amazon 登录

对于家庭自动化技能，您将需要启用“使用亚马逊登录”服务。为此，请执行以下步骤：

转到这里。您将看到以下屏幕快照中显示的页面：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8eh6E8gH-1681705088852)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/4afa1398-744c-4718-bb55-0a9209e8ed04.png)]

在随后加载的页面上，单击“创建新的安全配置文件”按钮。
将安全配置文件名称设置为Smart Home Automation Profile。
提供配置文件的描述。
对于内容隐私声明 URL，您将需要一个有效的隐私策略网页来将技能推广到生产中。创建并托管隐私策略，并在此字段中提供指向它的链接。可以在这个页面中找到用于创建隐私策略的非常方便的工具。
点击“保存”。
在下一页显示的齿轮菜单中，单击“安全配置文件”选项。您将进入“安全配置文件管理”页面，如下图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0EylQ7XR-1681705088852)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/6baa4f01-2672-49cb-9e03-6dd1f0902cac.png)]

在安全配置文件列表中，单击“Web 设置”选项卡，以显示“家庭自动化配置文件”的“显示客户端 ID 和客户端密钥”链接。
复制显示的客户端 ID 和客户端密钥值，并将它们保存到工作目录中的setup.txt文件中，分别替换[LWA Client ID]和[LWA Client Secret]的格式示例条目。

保持此选项卡处于打开状态，以备将来使用。在新的浏览器标签中，完成下一部分的步骤。

创建技能

现在，我们可以继续创建技能：

登录这里开始该过程。您将能够看到类似于以下内容的屏幕：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jdri85V4-1681705088852)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/e055cf24-cc4d-4caf-87a6-b5187a26a92a.png)]

单击“创建技能”。
将名称设置为Home Automation Skill或您选择的名称。
在“选择要添加到您的技能的模型”部分下，单击“智能家居”模型。您的选择现在应类似于以下内容：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yCwu4dYa-1681705088852)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/15bd4a33-02ec-4ab9-b0fc-7cd83f015eec.png)]

单击“创建技能”以完成技能创建的初始阶段。
在出现的下一页上，您将能够看到技能 ID。将此技能 ID 复制到本地工作目录中的setup.txt文件。

不要关闭此标签，因为您仍然需要在此处填写字段。打开一个新的浏览器选项卡以在下一部分中使用。

配置 AWS Lambda 函数

在将 Lambda 函数的 ARN 添加到技能端点配置之前，我们必须为 Lambda 函数创建一个配置。您可以按照以下步骤进行操作：

转到这里。屏幕上将显示以下屏幕截图所示的屏幕：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CwMd2mZv-1681705088853)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/0fdc474a-3051-4bab-9698-8a9d883cb2f6.png)]

单击“创建策略”。
在“创建”策略编辑器的“JSON”选项卡中输入以下 JSON：

{
 "Version": "2012-10-17",
 "Statement": [
 {
 "Effect": "Allow",
 "Action": [
 "logs:CreateLogStream",
 "dynamodb:UpdateItem",
 "logs:CreateLogGroup",
 "logs:PutLogEvents"
 ],
 "Resource": "*"
 }
 ]
 }

单击“查看策略”，并将策略名称设置为HomeAutomationPolicy。
单击“创建策略”。
接下来，在页面的左侧导航菜单上，单击“角色”。
单击“创建角色”。
选择 AWS 服务和 Lambda，然后单击“下一步：权限”。
在过滤字段中搜索HomeAutomationPolicy。检查策略。您的屏幕应类似于以下内容：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7OpqIF7M-1681705088853)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/38f026ca-5a81-427f-ad3c-dc5efa7357de.png)]

单击“下一步：标签”。
单击“下一步：审阅”。
将角色名称设置为lambda_home_automation。
单击“创建角色”。

现在让我们创建 Lambda 函数。

创建 Lambda 函数

有了适合 Lambda 函数的配置，我们现在可以创建 Lambda 函数本身。为此，在 AWS 控制台中，导航至这里并执行以下步骤：

单击“创建函数”。
将函数名称设置为homeAutomation。
选择Python 3.6运行系统。
从执行角色中现有角色的下拉列表中选择lambda_home_automation角色。
点击Create function。
从出现的下一页复制 Lambda ARN，其中包含祝贺您创建 Lambda 函数的消息。将此 ARN 放入我们本地工作目录的setup.txt的[AWS Lambda ARN]字段中。
此时，屏幕应类似于以下屏幕截图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uzRSQqJZ-1681705088853)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/c27dff75-763d-479c-aea9-4846c6cd2e08.png)]

请注意，屏幕上显示的触发器和目的地可能与前面的屏幕截图不同。

在左侧导航上，单击“添加触发器”以调出您的 Lambda 函数的可用触发器的下拉列表，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NCk0Uod7-1681705088853)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/4c5d75a8-1315-43f1-87d7-961a97ea98c4.png)]

单击Alexa Skills Kit来打开此触发器的配置对话框。
将 Alexa 技能 ID 粘贴到技能 ID 字段中。我们先前已将此值存储在setup.txt中，它看起来像amzn1.ask.skill.xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx。
单击“添加”以添加触发器并返回到 Lambda 函数管理屏幕。
单击页面右上方的“保存”。

完成最后一步后，触发器部分将显示已连接的 Alexa 技能的详细信息。如果不是，则应检查是否已正确执行上述步骤。

配置 Alexa 技能

现在，我们需要配置在浏览器的另一个选项卡中保持打开状态的技能。我们将通过以下步骤进行操作：

返回该选项卡，并在“默认端点”字段中填写 Lambda 函数的 ARN。
点击“保存”。
单击页面底部的“设置帐户链接”。
对于授权 URL，输入https://www.amazon.com/ap/oa。
对于访问令牌 URL，输入https://api.amazon.com/auth/o2/token。
对于客户端 ID 字段，从setup.txt文件中复制[LWA Client ID]。
对于“客户端密钥”字段，从setup.txt文件中复制[LWA Client Secret]。
单击“添加范围”，然后输入profile:user_id。
从页面底部复制重定向 URL，然后将其粘贴到[API]部分下的setup.txt文件中。 URL 类似于以下内容：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MZlr6P7W-1681705088853)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/81841ec1-c702-47ac-84d3-11fc81c679bd.png)]

点击“保存”。
在“安全配置文件管理”浏览器选项卡中，单击“Web 设置”选项卡。
单击“编辑”，然后将三个重定向 URL 添加到“允许的返回 URL”字段中。您将必须单击“添加另一个”以输入多个 URL。
点击“保存”。

现在，让我们为该技能设置 Amazon DynamoDB。

设置 Amazon DynamoDB 以获得该技能

为了能够从用户保存数据，此功能需要数据库。我们将为此使用 Amazon DynamoDB 服务。设置服务的步骤如下：

转到这里。
单击“创建表”按钮。
输入表名称为SmartHome。
对于主键，输入ItemId。
保留所有默认设置，然后单击“创建”。在此步骤中，您的屏幕应类似于以下屏幕截图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gVCggcq5-1681705088854)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/c1615057-9eee-451a-aa6e-49226c642255.png)]

然后，您可以转到 DynamoDB 仪表板以查看刚刚创建的表。但是，这可能需要一些时间。

部署 AWS Lambda 函数的代码

我们剩下的最后一部分设置是为 AWS Lambda 函数提供逻辑的代码。转到 Lambda 函数配置页面，然后向下滚动到编辑器。

您将注意到编辑器具有两列界面：左列显示 Lambda 函数存储中的文件，而右列则可以编辑这些文件，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fLUk2VjJ-1681705088854)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/83315a84-c753-4f37-980c-a9b5dd4e5ed8.png)]

单击lambda_function.py开始编辑文件并执行以下步骤：

导入必要的模块。为了使该函数正常工作，我们需要一些通用库的支持，如以下代码所示：

import boto3
import json
import random
import uuid
import time

boto3 API 用于连接到我们设置的 Amazon DynamoDB 实例。 JSON 模块有助于生成 Alexa 技能的响应。其余模块有助于生成响应。

创建AlexaResponse类。为了能够完全复制 Alexa 技能的预期响应格式，我们可以快速设置一个帮助程序类，该类可以为 Lambda 函数调用生成响应。我们命名为AlexaReponse；以下代码段显示了该类的初始化：

class AlexaResponse:
    def __init__(self, **kwargs):
        self.context_properties = []
        self.payload_endpoints = []
        # Set up the response structure
        self.context = {}
        self.event = {
            'header': {
                'namespace': kwargs.get('namespace', 'Alexa'),
                'name': kwargs.get('name', 'Response'),
                'messageId': str(uuid.uuid4()),
                'payloadVersion': kwargs.get('payload_version', '3')
            },
            'endpoint': {
                "scope": {
                    "type": "BearerToken",
                    "token": kwargs.get('token', 'INVALID')
                },
                "endpointId": kwargs.get('endpoint_id', 'INVALID')
            },
            'payload': kwargs.get('payload', {})
        }
        if 'correlation_token' in kwargs:
            self.event['header']['correlation_token'] = kwargs.get('correlation_token', 'INVALID')
        if 'cookie' in kwargs:
            self.event['endpoint']['cookie'] = kwargs.get('cookie', '{}')
        if self.event['header']['name'] == 'AcceptGrant.Response' or self.event['header']['name'] == 'Discover.Response':
            self.event.pop('endpoint')

前面用于AlexaResponse类的初始化方法设置了预期的输出格式和各种常量设置，例如有效负载的版本号以及对输出对象的一些基本验证。接下来，我们创建用于添加内容属性的方法和用于在响应中设置 Cookie 的另一种方法。最后，添加了另一种方法来设置有效负载端点：

def add_context_property(self, **kwargs):
    self.context_properties.append(self.create_context_property(**kwargs))
def add_cookie(self, key, value):
    if "cookies" in self is None:
        self.cookies = {}
    self.cookies[key] = value
def add_payload_endpoint(self, **kwargs):
    self.payload_endpoints.append(self.create_payload_endpoint(**kwargs))

现在定义上一步中创建的三个处理器方法。上一步中声明的方法取决于它们自己的内部方法。这些主要是辅助函数，与本章的重点无关，因此我们将把这些留给您实现该函数，您可以通过研究 AWS Lambda 函数的响应主体文档和 Alexa 技能来创建这些函数。可以在本章的代码存储库中的lambda_function.py文件的 65 和 102 行之间找到示例实现。
接下来，我们将设置方法以从AlexaResponse类生成最终响应。最终，我们创建了将所有不同部分（上下文，事件，有效负载，端点和 cookie）同化为单个对象的方法，可以与 Alexa 技能进行交互：

def get(self, remove_empty=True):
        response = {
            'context': self.context,
            'event': self.event
        }
        if len(self.context_properties) > 0:
            response['context']['properties'] = self.context_properties
        if len(self.payload_endpoints) > 0:
            response['event']['payload']['endpoints'] = self.payload_endpoints
        if remove_empty:
            if len(response['context']) < 1:
                response.pop('context')
        return response
    def set_payload(self, payload):
        self.event['payload'] = payload
    def set_payload_endpoint(self, payload_endpoints):
        self.payload_endpoints = payload_endpoints
    def set_payload_endpoints(self, payload_endpoints):
        if 'endpoints' not in self.event['payload']:
            self.event['payload']['endpoints'] = []
        self.event['payload']['endpoints'] = payload_endpoints

AlexaResponse类现已完成。现在，我们将继续使用以下行来连接 DynamoDB 服务：

aws_dynamodb = boto3.client('dynamodb')

接下来，我们定义文件的主要方法和入口点-lambda_handler方法：

def lambda_handler(request, context):
    # JSON dump for the request
    print('Request: ')
    print(json.dumps(request))
    if context is not None:
        print('Context: ')
        print(context)

在本步骤的其余部分中，我们将继续添加上述方法。在前面的几行中，我们声明了lambda_handler方法，该方法接受 Alexa 技能的request和context对象。然后，它对请求进行 JSON 转储，以便我们以后可以从 Amazon CloudWatch 仪表板进行观察。接下来，它对上下文进行了转储（如果有附加到请求中的内容）：

# Validate we have an Alexa directive
    if 'directive' not in request:
        aer = AlexaResponse(
            name='ErrorResponse',
            payload={'type': 'INVALID_DIRECTIVE',
                     'message': 'Missing key: directive, Is the request a valid Alexa Directive?'})
        return send_response(aer.get())

然后，我们验证请求中是否有有效的 Alexa 指令，如果找不到有效的 Alexa 指令，则会生成错误消息并作为响应发送回去。注意此处AlexaResponse类对象的用法。将来我们将使用它来从以下脚本生成响应：

# Check the payload version
    payload_version = request['directive']['header']['payloadVersion']
    if payload_version != '3':
        aer = AlexaResponse(
            name='ErrorResponse',
            payload={'type': 'INTERNAL_ERROR',
                     'message': 'This skill only supports Smart Home API version 3'})
        return send_response(aer.get())

同样，进行另一项检查以确保请求的有效负载版本为 3。这是因为我们仅针对 Alexa 的 Smart Home API 版本 3 开发了它：

首先，我们打开请求并查看请求的内容：

name = request['directive']['header']['name']
    namespace = request['directive']['header']['namespace']

然后，我们根据namespace处理来自 Alexa 的传入请求。请注意，此示例接受任何grant请求，但是在您的实现中，您将使用代码和令牌来获取和存储访问令牌：

if namespace == 'Alexa.Authorization':
        if name == 'AcceptGrant':
            grant_code = request['directive']['payload']['grant']['code']
            grantee_token = request['directive']['payload']['grantee']['token']
            aar = AlexaResponse(namespace='Alexa.Authorization', name='AcceptGrant.Response')
            return send_response(aar.get())

前述条件适用于 Alexa 授权请求。

对于发现和关闭开关的操作，我们使用以下代码：

if namespace == 'Alexa.Discovery':
        if name == 'Discover':
            adr = AlexaResponse(namespace='Alexa.Discovery', name='Discover.Response')
            capability_alexa = adr.create_payload_endpoint_capability()
            capability_alexa_powercontroller = adr.create_payload_endpoint_capability(
                interface='Alexa.PowerController',
                supported=[{'name': 'powerState'}])
            adr.add_payload_endpoint(
                friendly_name='Sample Switch',
                endpoint_id='sample-switch-01',
                capabilities=[capability_alexa, capability_alexa_powercontroller])
            return send_response(adr.get())
        if namespace == 'Alexa.PowerController':
            endpoint_id = request['directive']['endpoint']['endpointId']
            power_state_value = 'OFF' if name == 'TurnOff' else 'ON'
            correlation_token = request['directive']['header']['correlationToken']

对于对TurnOff或TurnOn.的请求，此示例始终返回success响应。

现在，我们在设置状态时检查错误：

state_set = set_device_state(endpoint_id=endpoint_id, state='powerState', value=power_state_value)
        if not state_set:
            return AlexaResponse(
                name='ErrorResponse',
                payload={'type': 'ENDPOINT_UNREACHABLE', 'message': 'Unable to reach endpoint database.'}).get()
        apcr = AlexaResponse(correlation_token=correlation_token)
        apcr.add_context_property(namespace='Alexa.PowerController', name='powerState', value=power_state_value)
        return send_response(apcr.get())

最后，我们提取指令名称和指令的名称空间，以确定要发送回的响应的类型。根据要发送的指令，将生成不同的响应，并最终使用AlexaResponse类对象发送该响应。
注意上一步代码中send_response方法的用法。我们需要定义该方法。它的任务是以 JSON 格式发送AlexaResponse对象，并将其记录下来以便在 Amazon CloudWatch 中进行观察：

def send_response(response):
    print('Response: ')
    print(json.dumps(response))
    return response

更新device state方法。由于我们正在使用 Alexa 为简单的交换机设备构建自动化，因此我们需要维护交换机的状态信息。为此，我们将其状态存储在 DynamoDB 中。我们将为此添加一个更新方法，如以下代码所示：

def set_device_state(endpoint_id, state, value):
    attribute_key = state + 'Value'
    response = aws_dynamodb.update_item(
        TableName='SmartHome',
        Key={'ItemId': {'S': endpoint_id}},
        AttributeUpdates={attribute_key: {'Action': 'PUT', 'Value': {'S': value}}})
    print(response)
    if response['ResponseMetadata']['HTTPStatusCode'] == 200:
        return True
    else:
        return False

接下来，我们将测试 Lambda 函数。

测试 Lambda 函数

现在，我们可以检查函数是否正确响应。为此，我们必须通过以下步骤在 Lambda 函数的仪表板上创建一个测试：

在上一节中创建的函数的 Lambda 函数页面的右上角，单击“测试”。
将出现一个对话框，其中包含用于编写新测试或使用现有测试的选项。选择创建新测试事件的选项。
在“事件”模板中，确保已选择“Hello World”。
接下来，提供事件名称directiveDiscovery。
在编辑器中输入以下 JSON：

{
  "directive": {
    "header": {
      "namespace": "Alexa.Discovery",
      "name": "Discover",
      "payloadVersion": "3",
      "messageId": "1bd5d003-31b9-476f-ad03-71d471922820"
    },
    "payload": {
      "scope": {
        "type": "BearerToken",
        "token": "access-token-from-skill"
      }
    }
  }
}

此时，您的屏幕应类似于以下内容：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qRlPef3P-1681705088854)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/72352241-b56d-4536-b083-daebba4c21cf.png)]

向下滚动并单击“创建”。
返回 Lambda 函数仪表板后，在右上方，从下拉列表中选择directoryDiscover测试。
单击“测试”。

完成后，测试将显示响应状态和 Lambda 函数的响应。您可以在 Lambda 函数仪表板顶部的页面上看到结果，该结果类似于以下屏幕截图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dLJpU3dR-1681705088854)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/ff23d8a3-8380-4e37-949f-efd3614544ca.png)]

如果测试失败，请确保已仔细执行上述步骤，并确保存在不同服务的区域相同。

测试 AWS 家庭自动化技能

作为该项目的最后阶段，我们将在 Alexa 测试模拟器中测试我们的技能。为此，请执行以下步骤：

转到这里并登录。
单击左侧菜单中的“技能”。
单击页面右上方的您的技能。
选择“DEV SKILL”选项卡。
单击HomeAutomationSkill。您应该看到以下屏幕：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a2ltZVCn-1681705088855)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/246d6e58-cde0-45cd-9ad1-0f7dd1f02154.png)]

单击“启用”按钮。系统将要求您允许访问开发者帐户的权限。
返回到 Alexa Developer 控制台，然后单击“发现设备”。名为 Sample Switch 的新设备将显示为可用，如以下屏幕快照所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9CNBEx5r-1681705088855)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/77383ecb-ff77-43fa-99ae-c06f245dd01e.png)]

现在，转到 Alexa Skills Kit 开发页面上的“测试”选项卡，以获取 HomeAutomation 技能。
在模拟器中，键入alexa, turn on the sample switch。如果请求被接受，那么您将收到来自 Alexa 的OK，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SNiPCz8S-1681705088855)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/40856d4c-4de8-458c-b4e7-83073a821f59.png)]

要检查该技能是否真正起作用，可以转到 DynamoDB 表 SmartHome 并切换到表的“项目”选项卡。您应该能够看到以下记录：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vjm4b8mA-1681705088855)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/f0949a1c-45e6-49d6-af20-309f9b4dd0a3.png)]

恭喜您成功在 Alexa 中建立了简单的家庭自动化技能！您可以玩耍此技能，并为 Alexa 建立自己的家庭自动化技能。准备好将其发布给更广泛的受众后，您可以按照这个页面上提供的文档中的建议进行操作。

总结

在本章中，我们介绍了如何通过其 Python API boto3 使用 AWS。我们探索了使用 API的各种选项和配置要求，并查看了如何与 Rekognition API 一起使用以识别名人的示例。然后，我们深入研究了如何创建家庭自动化的 Alexa 技能，设置了打开/关闭开关的简单任务。这可以很容易地推断到其他智能家居设备。我们研究了如何在 AWS Lambda 上托管 Alexa 技能逻辑以及如何从 AWS CloudWatch 进行观察。我们还探索了 Amazon DynamoDB 中动态设备数据的存储。

在接下来的章节中，我们将了解如何使用 Python 在 Microsoft Azure 平台上使用深度学习。

八、Microsoft Azure 上的 Python 深度学习

我们将在本章结束我们的云 API 探索之旅。到目前为止，我们已经将自己轻轻地介绍给了 API 的美好世界，特别是让我们轻松进行深度学习的 API。我们已经看到了如何使用 REST API 并以编程方式使用它们。与 Google Cloud Platform（GCP）和 Amazon Web Services（AWS）一样，Microsoft 也提供了自己的云服务平台，该平台称为 Azure。与前几章一样，我们将只专注于 Azure 必须提供的基于深度学习的解决方案。我们将稍作调整，还将介绍 Microsoft 的认知工具包（CNTK），它是像 Keras 这样的深度学习框架。

在本章中，我们将介绍以下主题：

在 Azure 中设置您的帐户
快速浏览 Azure 提供的深度学习解决方案
在 Python 中使用 Face API
在 Python 中使用 Text Analytics API
CNTK 简介

技术要求

您可以从这里访问本章的代码。

要运行本章中使用的代码，您将需要以下软件：

Python 3.6+
Python PIL 库
Matplotlib 库

本章将介绍所有其他安装，例如 CNTK 和 Django。

在 Azure 中设置您的帐户

根据您以前使用云平台的经验，您可能已经意识到，这一切都始于在云提供商中设置帐户和计费。这是一个非常标准的工作流程，Azure 也不例外。因此，让我们转到这里并执行以下步骤：

单击“免费启动”按钮，如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tp0rIJSe-1681705088855)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/01908bbd-6abc-4f1b-8b26-2d05cab0472d.png)]

请注意，您将需要一个 Microsoft 帐户才能继续以下步骤。因此，如果您没有，请在这个页面中创建一个。

您将被重定向到另一个页面，在该页面上您将再次看到另一个“免费启动”按钮。点击它。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ok8wP2Xs-1681705088856)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/e67d8ec9-75a8-48a3-aa96-a76668954eb7.png)]

系统将要求您登录到您的 Microsoft 帐户以继续。相应地提供凭据，您应该进入页面，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LUlZrK70-1681705088856)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/89e7d103-9c26-4a97-aaa8-78989fd0b407.png)]

如果您是首次使用该产品，您将在 30 天内免费获得 200 美元的信用额（取决于您的货币），以浏览 Azure 提供的其他服务。

填写您的详细信息，其中还包括通过卡验证您的身份。

您可能需要为此支付象征性的费用。请确保查看 Azure 免费套餐的条款和条件，您可以在这个页面中找到这些条款和条件。

完成此过程后，您将全部准备就绪并可以移至 Azure 门户，该门户的作用方式与 GCP 和 AWS 控制台相同您已经在前面的章节中看到过。

Azure 门户如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yiEpTVSj-1681705088856)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/be9a0fa6-08a0-474a-8d62-b28113ea7fcf.png)]

现在，您已经设置了 Azure 帐户，让我们在下一部分中探索基于深度学习的 Azure 产品。

Azure 提供的深度学习服务一览

Azure 的基于深度学习（和通用机器学习）的产品大致分为三个部分：

Azure 机器学习服务，它提供端到端的机器学习生命周期，包括模型构建，训练和部署：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JzTMeUfJ-1681705088856)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/5e49fe53-bc9e-41e1-b544-97bdfb6d9e0a.png)]

机器学习 API，它们为各种学习任务提供 API，例如内容审核，翻译，异常检测，等等：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wUx8x87s-1681705088856)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/3172ed87-5c07-4de6-bcb3-8a1c49c9ac02.png)]

Azure AI，其重点是诸如知识挖掘之类的主题，决策挖掘以及计算机视觉和语言建模领域中的许多其他类似的机器学习功能：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l4996D5z-1681705088857)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/a33df20e-bf48-44a2-b065-44b02e2bf715.png)]

现在，我们将研究分别用于计算机视觉任务和自然语言理解任务的两个 API。我们还将研究如何从 Python 使用这些 API。让我们潜入。

使用 Face API 和 Python 的对象检测

对象检测是计算机视觉的经典用例，已广泛应用于许多实际问题，例如视频监视系统。在本节中，我们将使用 Face API 从给定图像中检测面部。在设计视频监视系统时，可以直接使用。您可以从其官方页面了解有关 Face API 的更多信息。

初始设置

Azure 还可以让您免费试用此 API 7 天。但是，由于您已经拥有一个 Azure 帐户（我想拥有免费信用），因此我们可以采用另一种方式，如下所示：

登录到您的 Azure 帐户。
转到这里。
单击“已经使用 Azure？立即免费试用此服务”。

现在，您应该有一个窗口，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RNtcZ2AE-1681705088857)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/f1b88b0e-e960-4830-9440-3e4ffa4ab083.png)]

相应地填写详细信息，完成后单击“创建”。您将看到一个弹出窗口，显示“正在提交部署”。

部署完成后，您应该进入页面，如以下屏幕截图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TqIFvEy7-1681705088857)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/8d44a941-a39a-4c25-8b07-1457bef65c63.png)]

单击“转到资源”，您将被重定向到资源页面，其中包含许多详细信息：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vBWWJpgy-1681705088857)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/08af55b4-5b80-44b4-9943-282a9618ff8d.png)]

只需向下滚动一点，您将能够看到 Face API 的端点。请注意，它会根据您在创建部署时输入的配置详细信息而有所不同。端点看起来像这里。注意这一点。

现在，要能够以编程方式使用 Face API，您需要创建相应的 API 密钥。在同一页面的顶部，有一个部分显示抓取密钥：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NDsWuJOy-1681705088857)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/15e48360-dd9c-48f2-b123-c6e1680e2514.png)]

在该部分下，单击“密钥”，您将看到以下屏幕截图中的内容：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qcOMRT1d-1681705088858)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/6166e10e-a211-4053-9236-f678e04822cc.png)]

既然您已经有了 Face API 的 API 密钥，就可以使用它了。

从 Python 代码使用 Face API

当您的包含诸如 API 密钥之类的安全凭证时，通常最好将这些密钥定义为环境变量，然后在程序中调用它们。因此，继续创建一个环境变量以存储 Face API 的 API 密钥之一。

要将环境变量添加到计算机，可以在这个页面上关注此文章。

就我而言，我已将环境变量命名为face_api_key。您可以放置任何包含面部的图像。对于此示例，我将使用以下图像：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tCu1RfOp-1681705088858)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/5429ceba-947a-43c2-abbe-7e92043a3fdf.jpg)]

创建一个新的 Jupyter 笔记本，然后按照以下步骤操作：

现在，让我们使用 Python 加载环境变量，如下所示：

import os
face_api_key = os.environ['face_api_key']

现在，将 Face API 端点（用于对象检测）分配给变量。
此外，将要测试的图像上载到在线文件服务器（例如 Imgur），然后检索允许从 Imgur 提取原始图像的 URL。

就我而言，我已将图像上传到 GitHub 存储库并使用了相应的 URL：

face_api_url = 'https://eastus.api.cognitive.microsoft.com/face/v1.0/detect'
image_url= 'https://raw.githubusercontent.com/PacktPublishing/Hands-On-Python-Deep-Learning-for-Web/master/Chapter8/sample_image.jpg'

请注意，在前面的 API 中，仅 URL 末尾的终结点名称发生更改。在大多数情况下，除非使用 Azure 平台本身要求进行更改，否则在使用认知服务期间，终结点名称之前的部分将保持不变。

现在，导入requests模块并设置 API 有效负载，如下所示：

import requests
params = {
'returnFaceId': 'true',
'returnFaceLandmarks': 'false',
'returnFaceAttributes': 'age,gender',
}

现在，我们可以向 Face API 发出请求了。

以下代码行可为您完成此操作：

# Define the header param
headers = { 'Ocp-Apim-Subscription-Key': face_api_key }
# Define the body params
params = {
'returnFaceId': 'true',
'returnFaceLandmarks': 'false',
'returnFaceAttributes': 'age,gender',
}

现在，我们可以显示从 API 收到的响应：

# Make the call to the API
response = requests.post(face_api_url, params=params, headers=headers, json={"url": image_url})
# Get the response and log
faces = response.json()
print('There are {} faces im the given image'.format(str(len(faces))))

在这种情况下，返回的代码如下：

There are 2 faces in the given image

请注意returnFaceAttributes主体参数，该参数可让您指定面孔的多个属性，并且 Face API 将针对这些属性分析给定的面孔。要查找有关这些属性的更多信息，请查看这个页面上的文档。

让我们以一种合理的方式将从 API 获得的响应嵌入到图像中。我们将在图像中显示检测到的面部的可能的性别和可能的年龄。我们将使用matplotlib，PIL和io库进行此操作，并且我们将使用 Jupyter 笔记本来处理本节中的以下代码段。我们将从导入库开始：

%matplotlib inline #Only for Jupyter Notebook
import matplotlib.pyplot as plt
from PIL import Image
from matplotlib import patches
from io import BytesIO

要使用从 API 收到的响应在图像上显示叠加层，我们使用以下方法：

存储 API 响应：

response = requests.get(image_url)

根据响应内容创建图像：

image = Image.open(BytesIO(response.content))

创建一个空图形：

plt.figure(figsize=(8,8))

显示使用响应创建的图像：

ax = plt.imshow(image, alpha=0.6)

遍历前面部分中指定的面部并提取必要的信息：

for face in faces:
 # Extract the information
 fr = face["faceRectangle"]
 fa = face["faceAttributes"]
 origin = (fr["left"], fr["top"])
 p = patches.Rectangle(origin, fr["width"], fr["height"], fill=False, 
 linewidth=2, color='b')
 ax.axes.add_patch(p)
 plt.text(origin[0], origin[1], "%s, %d"%(fa["gender"].capitalize(), fa["age"]), 
 fontsize=20, weight="bold", va="bottom")
# Turn off the axis
_ = plt.axis("off") 
plt.show()

您应该具有这样的图像：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4mM9cRZR-1681705088858)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/6602861e-76f7-4378-afcc-db74b1161cf8.png)]

鼓励您尝试使用 API提供的不同参数。现在，我们将研究自然语言理解（NLU）API。

使用 Text Analytics API 和 Python 提取文本信息

无论是有意还是无意，我们都必须遇到自然语言处理的一些惊人用例。无论是自动更正，下一个单词建议还是语言翻译，这些用例都非常重要而不能忽略。在本节中，我们将使用文本分析 API 从给定的一段文字中提取有意义的信息。

您可以使用前面提到的链接免费试用 API，并查看其功能。在以下示例中，我输入了短语I want to attend NeurIPS someday and present a paper there，Text Analytics API 从中提取了四个有意义的信息：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6Ok2UdBS-1681705088858)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/e67aa8f4-cd9d-4d88-922a-4c94bd55d0b0.png)]

观察 API 如何从短语中提取所有关键信息。

现在，我们将看到如何使用 Python 以编程方式执行此操作。设置步骤将与前面的步骤完全相同。只需转到这里并按照那里的步骤进行。一旦拥有使用 API的相应 API 密钥，请继续进行以下小节。别忘了记下各自的端点。端点应以这个页面开头。该 URL 不能单独使用；它需要有一个后缀，指向要调用的正确方法。

在 Python 代码中使用 Text Analytics API

本节将向您展示如何在自己的 Python 代码中使用 Text Analytics API。以下是使用它的步骤：

我们将从导入所需的库开始本节：

import requests
import os
from pprint import pprint

然后，我们将从环境变量中加载 Text Analytics API 的 API 密钥：

api_key = os.environ['text_api_key']

现在让我们指定一些 URL 来存储 API 端点：

text_analytics_base_url = \
'https://eastus.api.cognitive.microsoft.com/text/analytics/v2.0'
language_api_url = text_analytics_base_url + "/languages"
sentiment_api_url = text_analytics_base_url + "/sentiment"
key_phrase_api_url = text_analytics_base_url + "/keyPhrases"

现在，通过提供 API 密钥来定义headers参数：

headers = {"Ocp-Apim-Subscription-Key": api_key}

我们还要定义 body 参数。就我而言，我将保留之前在基于 GUI 的演示中显示的相同短语：

documents = { 'documents': [
{ 'id': '1', 'text': 'I want to attend NeurIPS someday and present a paper there.' }
]}

现在，我们可以调用 Text Analytics 的各个 API。让我们从检测语言开始：

response = requests.post(language_api_url, headers=headers, json=documents)
language = response.json()
pprint(language)

我们得到相应的响应，如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iuWGkTrI-1681705088859)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/16b55881-1edf-4f83-9814-5cd3c785a8da.png)]

请注意，我已突出显示该语言。现在，让我们继续进行情感分析部分：

response = requests.post(sentiment_api_url, headers=headers, json=documents)
sentiment = response.json()
pprint(sentiment)

显示的情感如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2sk6kWcJ-1681705088859)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/37049f4f-493f-4703-a41c-52f3a69aeb73.png)]

注意，此处使用的短语既不包含正面情感也不包含负面情感，因此不包含得分。现在，我们将从给定的文本中提取关键短语：

response = requests.post(key_phrase_api_url, headers=headers, json=documents)
phrases = response.json()
print(phrases)

关键短语如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4xGBYEjM-1681705088859)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/6e957a31-82f6-4670-8ad7-eaded45163f1.png)]

注意端点相对于任务的变化。您可以在这个页面上探索有关上一示例中使用的端点的不同参数的更多信息。

CNTK 简介

CNTK 是 Microsoft 提供的产品。该框架是 ONNX 格式计划的一部分，该计划允许在不同的神经工具套件框架之间轻松转换模型。该框架负责 Microsoft 软件和平台上的深度学习生产工作量的很大一部分。该框架于 2016 年推出，一直是 TensorFlow，PyTorch 等流行框架的竞争者。该框架是完全开源的，可以在这个页面中找到。

CNTK 为企业服务（例如 Cortana 和 Bing）以及广告（例如 Skype Translate，Microsoft Cognitive Services 等）提供动力。事实证明，它在某些应用上比 TensorFlow 和 PyTorch 等竞争对手更快地工作。

在本节中，我们将研究 CNTK 的一些基础知识，然后继续创建 Django 应用以将基于 CNTK 的模型传递到网络上。

CNTK 入门

CNTK 是最容易上手的框架之一，这得益于其简单的语法和无需会话概念即可工作的能力，就像 TensorFlow 一样，这使大多数学习器感到困惑。让我们看看如何在本地计算机或 Google Colaboratory 上设置 CNTK。

在本地计算机上安装

CNTK 框架支持 64 位和 32 位架构的计算机。但是，在编写本书时，它仅支持 3.6 版以下的 Python 版本。您可以在这个页面上验证最新支持的版本。此外，目前，CNTK 无法作为 macOS 上的内置二进制文件使用。

要安装框架，可以使用pip包管理器，也可以使用 Anaconda 上已编译的二进制文件进行安装。假设已设置 Python 环境，则可以使用以下命令在 Windows 和 Linux 上安装 CNTK：

如果没有 Anaconda，则将以下内容用于 CPU 版本：

# For CPU version
pip install cntk

将以下内容用于启用 GPU 版本：

# For the GPU enabled version
pip install cntk-gpu

在支持 Anaconda 的计算机上，可以使用pip通过以下命令安装 CNTK 框架：

pip install <url>

可以从 CNTK 网站获得<url>。

该命令将类似于以下内容：

pip install https://cntk.ai/PythonWheel/CPU-Only/cntk-2.6-cp35-cp35m-win_amd64.whl

现在，我们开始在 Google Colaboratory 中安装它。

在 Google Colab 上安装

默认情况下，CNTK 框架在 Google Colaboratory 平台上不可用，因此必须与其他必要模块一起安装。要在 Google Colaboratory 运行时上安装 CNTK，请在脚本顶部使用以下命令：

!apt-get install --no-install-recommends openmpi-bin libopenmpi-dev libopencv-dev python3-opencv python-opencv && ln -sf /usr/lib/x86_64-linux-gnu/libmpi_cxx.so /usr/lib/x86_64-linux-gnu/libmpi_cxx.so.1 && ln -sf /usr/lib/x86_64-linux-gnu/openmpi/lib/libmpi.so /usr/lib/x86_64-linux-gnu/openmpi/lib/libmpi.so.12 && ln -sf /usr/lib/x86_64-linux-gnu/libmpi.so /usr/lib/x86_64-linux-gnu/libmpi.so.12 && pip install cntk

请注意，前面的命令是单行命令。如果将其分成多行，则应确保将所需的更改添加到命令中。

一旦上一步成功运行，您将无需在该运行时再次使用此命令。因此，该命令可以在程序的将来运行中被注释掉。

通常，通过C别名将 CNTK 导入 Python 项目。我们使用以下代码将库导入项目：

import cntk as C

我们可以使用以下行来检查已安装的 CNTK 的版本：

print(C.__version__)

将 CNTK 导入到项目中后，我们准备着手创建深度学习模型的先决条件。

创建 CNTK 神经网络模型

在本节中，我们将完成创建预测神经网络之前所需的步骤，然后将创建神经网络本身：

首先，将必要的模块导入项目：

import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from sklearn.datasets import fetch_openml
import random
import cntk.tests.test_utils
from sklearn.preprocessing import OneHotEncoder
import cntk as C # if you have not done this before in the project

sklearn模块的fetch_openml()方法可帮助我们将本示例中使用的数据集直接下载到项目中，即 MNIST 手写数字数据集。 OneHotEncoder方法用于标签的单热编码。

接下来，设置程序执行过程中所需的几个常量：

num_samples = 60000
batch_size = 64
learning_rate = 0.1

我们将对 60,000 个样本进行训练，初始学习率为0.1。该速率可以在训练期间动态更新。

然后，我们需要创建一种用于生成随机迷你批的训练方法：

class Batch_Reader(object):
    def __init__(self, data , label):
        self.data = data
        self.label = label
        self.num_sample = data.shape[0]
    def next_batch(self, batch_size):
        index = random.sample(range(self.num_sample), batch_size)
        return self.data[index,:].astype(float),self.label[index,:].astype(float)

每次调用时，前面的方法将生成等于上一步中设置的大小的批量，例如，每个批量中有 64 个样本。这些样本是从数据集中随机抽取的。

现在需要获取数据集；为此，我们使用以下代码行：

mnist = fetch_openml('mnist_784')

提取数据后，可以将其分为训练和测试数据集，如下所示：

train_data = mnist.data[:num_samples,:]
train_label = mnist.target[:num_samples]
test_data = mnist.data[num_samples:,:]
test_label = mnist.target[num_samples:]

数据集中的标签在输入训练模型之前需要进行一次热编码。为此，我们使用以下代码：

enc = OneHotEncoder()
enc.fit(train_label[:,None])
train_encoded = enc.transform(train_label[:,None]).toarray()

现在，我们可以为训练批量生成器创建一个生成器对象，如下所示：

train_reader = Batch_Reader(train_data, train_encoded)

我们也快速对test数据集执行前面的步骤：

enc = OneHotEncoder()
enc.fit(test_label[:,None])
test_encoded = enc.transform(test_label[:,None]).toarray()
test_reader = Batch_Reader(test_data, test_encoded)

现在，让我们创建一个 CNTK 神经网络模型。我们首先从定义一些常量开始：

dimensions = 784
classes = 10
hidden_layers = 3
hidden_layers_neurons = 400

我们将输入数据的维度定义为784。回顾“第 3 章”，“创建第一个深度学习 Web 应用”的示例，在此我们使用了 MNIST 数据集。 MNIST 数据集中的图像以单维数组的格式存储，其中包含0至255范围内的28 x 28值。图像属于 10 个不同的类别，分别对应于阿拉伯数字系统中的每个数字。我们提供 3 个隐藏层，每个包含 400 个神经元。

然后，我们创建两个 CNTK input变量，以在创建模型时使用。这是 CNTK 最重要的概念之一。

input = C.input_variable(dimensions)
label = C.input_variable(classes)

CNTK 中的input变量本质上是一个占位符，我们在模型训练，评估或测试期间使用它来填充样本。在此步骤中，数据集输入的形状必须与input变量声明中声明的尺寸完全匹配。在这里重要的是要提到，很多人将输入的维数与数据集具有的特征数量混为一谈。具有N个特征数量和M个样本数量的数据集具有（M，N）形状，因此这个数据集的维度为2：

def create_model(features):
    with C.layers.default_options(init = C.layers.glorot_uniform(), activation = C.ops.relu):
            hidden_out = features
            for _ in range(hidden_layers):
                hidden_out = C.layers.Dense(hidden_layers_neurons)(hidden_out)
            network_output = C.layers.Dense(classes, activation = None)(hidden_out)
            return network_output

我们创建create_model()方法，该方法将特征的输入作为参数。

首先，为模型设置默认值，以使用权重初始化和其他值的均匀分布。默认激活函数设置为ReLU。

第一层包含特征本身，最后一层包含向量，其维数等于类的数量。中间的所有层都包含一个由 3 个隐藏层组成的全连接网络，每个隐藏层都有 400 个神经元，并具有 ReLU 激活函数：

model = create_model(input/255.0)

最后，我们使用先前的函数创建模型。除以255可对数据集进行归一化，从而在0和1之间的图像数组中呈现值。

训练 CNTK 模型

创建模型后，我们现在可以继续训练模型并使其学习预测。为此，我们需要使用 CNTK 模型对象，并将数据集中的样本拟合到该对象。我们可以同时记录loss和其他评估指标。我们需要执行以下步骤来训练我们的模型：

为loss和分类误差创建占位符：

loss = C.cross_entropy_with_softmax(model, label)
label_error = C.classification_error(model, label)

现在，我们可以为 CNTK 框架设置一个trainer对象，该对象用于执行实际的训练：

lrs = C.learning_rate_schedule(learning_rate, C.UnitType.minibatch)
learner = C.sgd(model.parameters, lrs)
trainer = C.Trainer(model, (loss, label_error), [learner])

现在开始进行训练：

epochs = 10
num_iters = (num_samples * epochs) / batch_size
for i in range(int(num_iters)):
    batch_data, batch_label = train_reader.next_batch(batch_size=batch_size)
    arguments = {input: batch_data, label: batch_label}
    trainer.train_minibatch(arguments=arguments)
    if i % 1000 == 0:
        training_loss = False
        evalaluation_error = False
        training_loss = trainer.previous_minibatch_loss_average
        evalaluation_error = trainer.previous_minibatch_evaluation_average
        print("{0}: , Loss: {1:.3f}, Error: {2:.2f}%".format(i, training_loss, evalaluation_error * 100))

我们将训练的周期数设置为10，以便进行快速训练和评估。您可以将其设置为较高的值，以提高训练的准确率；但是，在某些情况下，这可能不会导致更好的训练或过拟合。在第 1,000 次迭代中，我们显示直到那时为止的损失和评估误差。这些的总体趋势应该是下降。

测试并保存 CNTK 模型

在继续使用 Django 框架将该项目转换为 Web 应用之前，让我们快速测试在模型训练中获得的准确率。我们将执行以下操作以从模型进行预测：

predicted_label_probs = model.eval({input: test_data})

这将为数据集中的每个标签创建一个 NumPy 概率数组。必须将其转换为索引，并与测试数据的标签进行比较。我们这样做如下所示：

predictions = np.argmax(predicted_label_probs, axis=1)
actual = np.argmax(test_encoded, axis=1)
correct = np.sum(predictions == actual)
print(correct / len(actual))

我们发现预测的准确率约为 98%。这是一个非常好的值，我们将继续保存模型并通过 Django 使用它。为了保存 CNTK 模型，我们执行以下操作：

model.save("cntk.model")

成功保存模型后，如果您已使用 Colaboratory 构建模型，则必须将model文件下载到本地系统。接下来，我们可以继续在基于 Django 的服务器上部署模型。

Django Web 开发简介

Django 是使用 Python 进行 Web 开发的最受欢迎的框架之一。该框架轻巧，健壮，并由社区积极维护，可快速修补安全漏洞并添加新功能。在本书中，我们介绍了 Flask 框架，该框架本质上是 Python Web 开发的基本框架。但是，Django 随附了许多内置功能，这些功能可实现最新的方法和实践。

Django 项目的初始结构如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7hmRuJmW-1681705088859)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/220c2b95-9ed4-4521-9ee1-9937f6e28fec.png)]

使用django-admin工具创建新的 Django 项目时，这些文件会自动生成。顶级目录mysite表示 Django 项目的名称。每个 Django 项目均包含应用。应用类似于软件开发中模块的概念。它们通常是整个项目的独立部分，并由mysite主应用放在项目目录中。每个项目中可以包含多个应用。

让我们学习如何开始使用 Django 并创建一个新项目！

Django 入门

使用 Django 之前，最重要的步骤是安装它。幸运的是，该框架很容易从 Python PIP 存储库中作为模块安装。它也可以在 Conda 存储库中找到。要安装 Django，请打开一个新的终端窗口，然后使用以下命令：

conda install django

或者，如果您更喜欢 PIP，请使用以下命令：

pip install django

这会将 Django 模块安装到您的 Python 环境中。

要检查是否已成功安装，请在终端中使用以下命令：

python -m django --version

这将产生版本号的输出，例如- 2.0.8。如果没有，请检查您的 Django 安装。

创建一个新的 Django 项目

Django 提供了一个方便的工具django-admin工具，该工具可用于生成 Django 项目所需的样板代码。要创建一个名为cntkdemo的新项目，请使用以下代码：

django-admin startproject cntkdemo

这将创建所有样板文件夹和文件。但是，我们必须在项目中创建至少一个应用。使用终端将活动的工作目录更改为cntkdemo文件夹。使用以下命令在此项目中创建一个应用：

python manage.py startapp api

因此，我们创建了一个名为api的文件夹，其中包含以下文件夹；所有文件都是使用占位符代码和文档自动生成的：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w1LTkJMx-1681705088859)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/3d297b46-da99-422e-aab5-4dfb5cbc90e6.png)]

现在，我们可以进行初始 UI 的编码。

设置主页模板

现在让我们创建一个网页，该网页在访问/路由时加载。还记得我们在项目中创建的api应用吗？为了简单起见，使索引页面成为该应用的一部分。虽然可以在mysite应用的urls.py文件中创建此路由，但我们将为api应用提供其自己的路由处理文件。

让我们从设置主页模板的步骤开始：

在api文件夹中创建一个文件urls.py。该文件相对于项目目录的完整路径为mysite/api/urls.py。在此文件中，让我们使用以下代码添加/路由：

from django.urls import path
from . import views
urlpatterns = [
 path('', views.indexView), # This line handles the '/' route.
]

保存此文件。前面的代码从本质上为api应用添加了新路径/（注意，不是项目！）。它将导入api应用的views.py文件中的所有可用视图。请注意，indexView仍然不存在。下一步之后，我们将创建此视图。
api应用未链接到主项目应用。我们需要在mysite/mysite/urls.py文件中添加以下几行，以通过api应用的路由处理器启用路由处理：

from django.contrib import admin
from django.urls import path
from django.urls import include # -- Add this line!
urlpatterns = [
 path('', include('api.urls')), # -- Add this line!
 path('admin/', admin.site.urls),
]

第一行导入了一个工具，用于将特定于应用的路由设置包括到项目应用中。我们使用它使用api.urls字符串将urls.py文件包含在api应用内。这会自动将字符串转换为试图查找并包含正确文件的代码行。

在api应用目录内的views.py文件中，添加以下行：

from django.http import HttpResponse
from django.template import loader

HttpResponse方法允许view方法返回 HTML 响应。 loader类为我们提供了从磁盘加载 HTML 模板的方法。

现在让我们创建indexView方法：

def indexView(request):
 template = loader.get_template('api/index.html')
 context = {}
 return HttpResponse(template.render(context, request))

indexView方法加载api/index.html模板文件，并使用context词典中提供的变量以及模板可用的request参数对其进行呈现。当前，我们传递空白上下文，因为我们没有任何值可发送到模板。但是同样，先前定义的api/index.html文件不存在。

让我们创建一个用于保存模板的文件夹，并将其链接到项目设置。为此，请转到项目的根目录并创建一个名为templates的文件夹。我们需要项目能够将该文件夹识别为模板的目录。为此，我们需要修改mysite/mysite/settings.py文件中的TEMPLATES设置：

TEMPLATES = [
 {
 'BACKEND': 'django.template.backends.django.DjangoTemplates',
 'DIRS': [os.path.join(BASE_DIR, 'templates')], # -- Add this line!
 'APP_DIRS': True,
 'OPTIONS': {
 'context_processors': [

添加上一行后，项目将在mysite/templates/文件夹中查找模板。

创建index.html模板文件。
请注意，步骤 4 中的模板文件路由存在于api目录中。在templates目录中创建一个名为api的文件夹。在其中，使用以下代码创建index.html文件：

{% load static %}
...
        <div class="jumbotron">
            <h3 class="jumbotronHeading">Draw here!</h3>
            ...
        </div>
        <div class="jumbotron">
            <h3>Prediction Results</h3> 
            <p id="result"></p>
        </div>
        <div id="csrf">{% csrf_token %}</div>
    </div>
    <script src='https://cdnjs.cloudflare.com/ajax/libs/jquery/2.1.3/jquery.min.js'></script>
    <script src="{% static "/index.js" %}"></script>
...

我们在前面的代码块的末尾包含了一些必需的脚本，其中包括一个从后端获取 CSRF 令牌的脚本。

现在，让我们在上一个代码块中通过jumbotron类将canvas元素添加到div中，在这里我们将绘制数字。我们还将添加一个用于选择绘图笔宽度的滑块，如下所示：

<div class="jumbotron">
            <h3 class="jumbotronHeading">Draw here!</h3>        
            <div class="slidecontainer">
                <input type="range" min="10" max="50" value="15" id="myRange">
                <p>Value: <span id="sliderValue"></span></p>
            </div>
            <div class="canvasDiv">
                <canvas id="canvas" width="350" height="350"></canvas>
                <p>
                    <button class="btn btn-success" id="predict-btn" role="button">Predict</button>
                    <button class="btn btn-primary" id="clearButton" role="button">Clear</button>
                </p>
            </div>
        </div>

template文件还包括两个静态文件-style.css和script.js。我们将在接下来的部分中创建这些文件。我们尚未创建用于将数据发送到服务器并呈现收到的响应的脚本。

现在，我们将开始添加与后端 API 通信所需的 JavaScript 代码。首先，我们创建一种方法来检查是否需要 CSRF 令牌才能与后端进行通信。这只是一个工具函数，与调用后端 API 无关，后者可能有时被设计为接受没有 CSRF 令牌的请求。我们创建此函数，如下所示：

<script type="text/javascript">
    function csrfSafeMethod(method) {
        return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
    }

然后，我们为Predict按钮创建click处理器。此处理函数首先设置适当的标头，以调用后端 API，然后将画布上显示的图形转换为数据 URL 字符串：

$("#predict-btn").click(function() {
        var csrftoken = $('input[name=csrfmiddlewaretoken]').val();
        $.ajaxSetup({
            beforeSend: function(xhr, settings) {
                if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
                    xhr.setRequestHeader("X-CSRFToken", csrftoken);
                }
            }
        });
        $('#predict-btn').prop('disabled', true);
        var canvasObj = document.getElementById("canvas");
        var img = canvasObj.toDataURL();
        // MORE CODE TO BE ADDED BELOW THIS LINE
        // MORE CODE TO BE ADDED ABOVE THIS LINE
    });
    </script>

最后，我们将代码添加到Predict按钮的click处理函数中，以使用画布中的数据对后端进行 Ajax 调用，如下所示：

$("#predict-btn").click(function() {
...
        // MORE CODE TO BE ADDED BELOW THIS LINE
        $.ajax({
            type: "POST",
            url: "/predict",
            data: img,
            success: function(data) {
                console.log(data);
                var tb = "<table class='table table-hover'><thead><tr><th>Item</th><th>Confidence</th></thead><tbody>";
                var res = JSON.parse(data);
                console.log(res);
                $('#result').empty.append(res.data);
                $('#predict-btn').prop('disabled', false);
            }
        });
        // MORE CODE TO BE ADDED ABOVE THIS LINE
...
});
    </script>

在创建静态文件之前，我们需要为它们创建一个文件夹并将其链接到项目。这类似于我们创建templates文件夹的方式。首先，在项目目录中使用mysite/static/路径创建一个文件夹static。然后，在mysite/mysite/settings.py文件中修改STATIC配置，如下所示：

STATIC_URL = '/static/'
STATICFILES_DIRS = [
 os.path.join(BASE_DIR, "static"), # -- Add this line!
]

现在，我们可以使用模板文件顶部的{% load static %}指令创建静态文件并将其加载到项目模板中，就像在index.html文件中一样。

创建style.css和script.js-由于这些文件与本书的上下文没有明显关系，因此可以直接从这里下载它们。

请注意，没有script.js文件，该项目将无法运行。

我们已经创建了用于预测index.html模板文件中存在的画布上绘制的图像的设置。但是，/predict路由尚未创建。在下一部分中，让我们看看如何在 Django 中加载和使用 CNTK 模型。

在 Django 项目中将 CNTK 用于预测

在本节中，我们将首先设置 CNTK 模型与 Django 一起使用所需的路由，视图和导入。然后，我们将从保存的文件中加载 CNTK 模型，并使用它进行预测。

设置预测路由和视图

回想一下我们如何在api应用中创建/路由及其对应的视图：

首先，将以下行添加到mysite/api/urls.py：

urlpatterns = [
 path('', views.indexView),
 path('predict', views.predictView), # -- Add this line!
]

这将创建/predict路由。但是，视图predictView尚未创建。

将以下行添加到api应用中的views.py文件中：

from django.http import JsonResponse
def predictView(request):
 # We will add more code below this line
 # We will add more code above this line
 return JsonResponse({"data": -1})

请注意前几行中的占位符。在接下来的步骤中，我们将在此处添加更多内容。

进行必要的模块导入

现在，让我们加载使用 CNTK 模型进行预测所需的所有模块，如以下步骤所示：

将以下几行导入添加到api应用的views.py文件中：

import os
from django.conf import settings

我们需要前面的导入才能从磁盘加载模型：

import cntk as C
from cntk.ops.functions import load_model

前几行将 CNTK 模块导入到 Django 项目。 load_model方法将帮助我们加载保存的 CNTK 模型文件。

以下模块用于处理将在其上进行预测的图像：

from PIL import Image
import numpy as np

以下模块提供了用于处理 Base64 编码的字符串的工具，该格式是index.html页在请求中发送画布数据的格式：

import re
import base64
import random 
import string

在接下来的部分中将对其他库进行说明。

加载 CNTK 模型来做出预测

现在，我们将按照以下步骤进一步编辑predictView视图：

首先，使用以下代码将 Base64 编码的图像字符串数据读取为变量：

def predictView(request):
 # We will add more code below this line
 post_data = request.POST.items()
 pd = [p for p in post_data]
 imgData = pd[1][0].replace(" ", "+")
 imgData += "=" * ((4 - len(imgData) % 4) % 4)

Base64 解码的字符串没有适当的填充，并且包含需要转换为+的空格。上一个代码块中的最后两行对字符串执行相同的操作。

接下来，我们将将此 Base64 编码的字符串转换为 PNG 图像，并通过以下几行将其保存到磁盘：

filename = ''.join([random.choice(string.ascii_letters + string.digits) for n in range(32)])
convertImage(imgData, filename)

第一行为文件名创建一个 32 个字符长的随机字符串。下一行调用convertImage方法，该方法将base64字符串存储为提供的文件名。

但是，convertImage方法尚未定义。在predictView方法之外，添加函数的定义，如下所示：

def convertImage(imgData, filename):
 imgstr = re.search(r'base64,(.*)', str(imgData)).group(1)
 img = base64.b64decode(imgstr)
 with open(filename+'.png', 'wb') as output:
 output.write(img)

该方法从字符串中去除多余的元数据。然后，它解码该字符串并将其另存为 PNG 文件。

让我们回到predictView方法。我们将首先加载保存的image文件：

image = Image.open(filename+'.png').convert('1')

我们还将图像仅转换为黑白通道。这样会将图像中的通道数从 3 减少到 1。

回想一下，MNIST 数据集中的所有图像的尺寸均为28 x 28。我们必须将当前图像调整为相同的尺寸。我们使用以下代码行：

image.thumbnail((28,28), Image.ANTIALIAS)

现在，我们使用以下几行将图像转换为 NumPy 数组：

image_np = np.array(image.getdata()).astype(int)
image_np_expanded = np.expand_dims(image_np, axis = 0)

np.expanded_dims是 NumPy 中的一个简单工具，用于为数组添加额外的维度，以与大多数机器学习库保持适当的兼容性。

加载 CNTK 模型。首先，在项目的根目录中创建一个名为data的文件夹，然后将已保存的model文件复制到mysite/data/cntk.model中。
现在，我们以predictView方法加载 CNTK 模型，如下所示：

model = load_model(os.path.join(settings.BASE_DIR, "data/cntk.model"))

最后，我们可以预测图像的标签，如下所示：

predicted_label_probs = model.eval({model.arguments[0]: image_np_expanded})
data = np.argmax(predicted_label_probs, axis=1)

eval方法在其第一个参数中，期望图像的 NumPy 数组，并返回每个输出类的概率列表。 np.argmax方法用于找到概率最高的类别的索引。

要返回输出，请修改predictView方法的return部分，如下所示：

# We will add more code above this line
 return JsonResponse({"data": str(data[0])})

图像的预测标签将作为 JSON 响应的data变量中包含的数字发送，该变量显示在页面上。

测试网络应用

最后，我们可以测试我们开发的 CNTK + Django 应用。为此，打开终端并将其定向到项目的根目录。

使用以下命令启动 Django 服务器：

python manage.py runserver

如果端口可用，则服务器从http://localhost:8000启动。在网络浏览器中打开页面。在提供的画布上绘制数字，然后单击“预测”按钮。您将能够在页面底部看到来自模型的结果，如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jtx42M3n-1681705088860)(https://gitcode.net/apachecn/apachecn-dl-zh/-/raw/master/docs/handson-py-dl-web/img/b717132a-d629-41e8-b622-7424137ccf76.png)]

请注意，该模型在前面的屏幕快照 2 中返回了正确的输出。因此，我们得出了使用 Django 部署 CNTK 模型的结论。

总结

在本章中，我们介绍了 Microsoft AI 和 Azure 云提供的用于在网站上执行深度学习的产品。我们了解了如何使用 Face API 来预测图像中人物的性别和年龄，以及如何使用 Text Analytics API 来预测给定文本的语言的任何句子以及所提供文本或情感中的关键短语。最后，我们在 MNIST 数据集上使用 CNTK 创建了深度学习模型。我们了解了如何保存模型，然后通过基于 Django 的 Web 应用以 API 的形式部署模型。通过 Django 保存的模型的这种部署可以轻松地适应其他深度学习框架，例如 TensorFlow 或 PyTorch。

在下一章中，我们将讨论使用 Python 构建生产级深度学习应用的通用框架。

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Python Web 深度学习实用指南：第三部分

第 3 节：用于 Web 开发的不同深度学习 API 入门

五、通过 API 进行深度学习

什么是 API？

使用 API 的重要性

API 与库有何不同？

一些广为人知的深度学习 API

一些鲜为人知的深度学习 API

选择深度学习 API 提供商

总结

六、Google Cloud Platform 上的 Python 深度学习

技术要求

设置您的 GCP 帐户

在 GCP 上创建您的第一个项目

在 Python 中使用 Dialogflow API

创建一个 Dialogflow 帐户

创建一个新智能体

创建一个新的意图

测试您的智能体

安装 Dialogflow Python SDK

创建 GCP 服务帐户

使用 Python API 调用 Dialogflow 智能体

在 Python 中使用 Cloud Vision API

使用预训练模型的重要性

设置视觉客户端库

使用 Python 调用 Cloud Vision API

在 Python 中使用 Cloud Translation API

设置适用于 Python 的 Cloud Translate API

使用 Google Cloud Translation Python 库

总结

七、AWS 上的 Python DL：对象检测和家庭自动化

技术要求

AWS 入门

AWS 产品简介

Boto3 入门

配置环境变量并安装 boto3

在 Python 中加载环境变量

创建一个 S3 存储桶

使用 boto3 从 Python 代码访问 S3

在 Python 中使用 Rekognition API

在 Python 中使用 Alexa API

项目的前提条件和框图

为技能创建配置

Amazon 登录

创建技能

配置 AWS Lambda 函数

创建 Lambda 函数

配置 Alexa 技能

设置 Amazon DynamoDB 以获得该技能

部署 AWS Lambda 函数的代码

测试 Lambda 函数

测试 AWS 家庭自动化技能

总结

八、Microsoft Azure 上的 Python 深度学习

技术要求

在 Azure 中设置您的帐户

Azure 提供的深度学习服务一览

使用 Face API 和 Python 的对象检测

初始设置

从 Python 代码使用 Face API

使用 Text Analytics API 和 Python 提取文本信息

在 Python 代码中使用 Text Analytics API

CNTK 简介

CNTK 入门

在本地计算机上安装

在 Google Colab 上安装