使用 IBM Watson 和 OpenScale 部署和解释神经网络
在进入如何使用 Watson Studio 部署机器学习模型并使用 OpenScale 解释结果的分步教程之前，我想讲一个的小故事，我想解释一下为什么我们实际上需要 AI，为什么 AI 是人类进化的下一步。如果您仅对技术部分感兴趣，那么可以随意跳到第二部分，名为 IBM Watson 。
为什么我们需要像人工智能这样的工具
大多数人，如果他们听到像人工智能或机器学习这样的术语，他们会想到机器人。这是因为大预算电影将人工智能呈现为一个类似人类的机器，具有毁灭人类的潜力的超能力。实际上 AI 并不真的需要胳膊和腿来毁灭人类，但这是另一个故事了。
人工智能基于这样一种想法，即人类的智能、行为、人类思维可以以这样一种方式建模，即机器(或算法)可以模仿人类，可以执行迄今为止需要人类干预的任务，即类似人类的推理。在我看来，我们不应该模仿类似人类的行为，人类非常容易出错，我们应该创造更好的机器/算法，它们可以为我们执行重复的任务，这样我们就可以专注于更重要的事情，也许是需要更多创造力、更多想象力、情感和其他类似人类品质的任务。
进步、创新、进化需要越来越好的工具，没有工具我们的身体和心理能力都非常有限，浅薄。如果你想想“现代”人类的历史，每个时代都是由工具定义的。如果我们从史前时代开始，所谓的史前史就已经被工具所定义，它被工具所划界。顾名思义，史前时期是从第一批石器的使用到书写系统的发明之间的时期。如你所见，在这个时代的定义中，我们已经有了工具，它被工具所界定。这两个事件之间有多个“时代”，像青铜时代或铁器时代，这些都是由工具定义的。
想想看，我们的现代历史也是由工具定义的，过去几十年最重要的事件是由新工具/机器/设备的发明定义的。是的，我说的是四次工业革命。如果我们思考这些革命，这些革命的原因是什么？答案是工具！
在第一次工业革命期间，最大的变化出现在机械化形式的工业中。机械化是农业开始被工业取代成为社会经济支柱的原因。
继第一次工业革命之后，近一个世纪后，我们看到世界经历了第二次**。它始于 19 世纪末，工业领域的巨大技术进步帮助出现了一种新的能源、电力、天然气和石油。第二次工业革命的重点是钢铁需求的发展、化学合成以及电报和电话等通讯方式。**
****第三次革命带来了电子、电信，当然还有计算机的崛起。通过新技术，第三次工业革命打开了太空探险、研究和生物技术的大门。
第四次工业革命或所谓的工业 4.0 正在发生，它被一件事所定义，那就是互联网。我们可以看到从植根于技术现象的第一次工业革命一直到发展虚拟现实世界的工业 4.0 的转变，这使我们能够弯曲物理定律。
正如你所看到的，我们历史上所有这些重大事件都是由工具定义的，人工智能是另一个强大的工具，它可以并将重塑我们的世界。在我看来， AI 是人类进化过程中绝对必要的一步(也许这将是人类历史上最后一次革命，但这是后话，另文)。如果我们想进行更高级的研究(例如以光速旅行或发明一种传送方式)，我们需要更强大的工具，其中之一就是人工智能。另一个大事件将是量子计算机的发明，然后是量子计算和人工智能的结合。从这一点来看，发明没有限制，从这一点来看，我们可以想象未来的研究人员将是人工智能算法，而不是人类，但这是一个非常遥远和非常脆弱的未来。我们就紧扣当下，说说我们现在有什么样的 AI/ML 的工具。****
如今，我们有许多设备连接到互联网(第四次工业革命),每个设备都会产生数据。因为我们想要智能的和个性化的** 设备，可以猜测我们的需求，所以我们需要处理这些数据。处理如此巨大数量的数据是一项非常艰巨的任务，并且它不能手动完成。所以对数据的自动推理是绝对必要的。这就是人工智能来救援的地方。但是在自动推理之后，我们还想了解 AI 算法的动作的原因。这就是对可解释性的大肆宣传是如何产生的。要阅读更多关于可解释人工智能的当前趋势，你可以阅读我的文章解释可解释人工智能 。**
IBM 沃森
IBM开发的平台名为 Watson Studio，结合了机器学习服务和Watson open scale是一个全面的组合，旨在使开发、训练、管理模型和部署人工智能应用变得容易。这是一个在 IBM Cloud 上交付的 SaaS 解决方案。它为您的数据科学家、工程师、开发人员和领域专家提供了协作所需的工具，以推动其业务创新。
Watson Studio 加速机器和深度学习工作流，将人工智能注入您的业务，以推动创新。它为数据科学家、应用程序开发人员和主题专家提供了一套工具，允许他们协作连接数据、讨论数据并使用数据来构建、培训和部署大规模模型。成功的人工智能项目需要算法+数据+团队的组合，以及非常强大的计算基础设施。
这个平台的唯一问题是文档可能很难理解并且来自社区的支持不是那么先进，关于如何使用 Watson 的文章很少，关于使用 Watson** 创建应用的文章**很少(几乎没有)。所以我决定我们应该缩小这个差距，Watson 是一个伟大的工具，由一个非常强大的基础设施支持，除了创建和部署模型，它还为人工智能模型提供开箱即用的解释能力。为了解释模型的结果，他们使用了在解释可解释 AI 中提出的 LIME 算法。****
在下一节中，您将看到一个示例，说明如何构建一个神经网络来预测糖尿病**，然后如何使用上面提到的工具部署模型、设置持续学习、漂移检测以及解释神经网络的结果。**
沃森中的糖尿病预测
在此示例中，我们将使用神经网络通过 Pima 糖尿病数据集来预测糖尿病。我们将使用 Keras 包来快速构建和训练一个神经网络。我们将使用 Watson Studio 来构建**、训练和部署网络和 OpenScale 来设置漂移检测、持续学习并向解释模型的结果。**
本例中使用的数据集可以从 Diabetes.csv 下载。数据集包括几个医学预测变量和一个目标变量，结果。预测变量包括患者的怀孕次数、身体质量指数、胰岛素水平、年龄等。数据集的列可以描述为:
- 怀孕次数
- 口服葡萄糖耐量试验中 2 小时的血浆葡萄糖浓度
- 舒张压(毫米汞柱)
- 三头肌皮褶厚度(毫米)
- 2 小时血清胰岛素(微单位/毫升)
- 体重指数(体重公斤/(身高米) )
- 糖尿病谱系功能
- 年龄(岁)
- 类别变量(0 或 1)
为了解决这个问题，首先让我们设置我们的 IBM 帐户并准备糖尿病预测所需的服务。
IBM Cloud — Watson 逐步部署
首先要做的是在 IBM Cloud 上创建一个账户，并登录你的账户。
重要提示:为了获得最佳性能和兼容性，每个资源应该在同一个区域。在本教程中，我将使用法兰克福作为每个资源的选定区域。您可以根据您的帐户类型和您当前的位置选择其他地区。
从这里开始，请遵循以下步骤:
- 在屏幕的右上角，单击您的帐户图片，然后单击 My IBM。
这将把您带到 IBM 仪表板
2.在您的 IBM 仪表板上，您将看到您的产品。从产品部分启动 IBM Cloud
这将带您进入 IBM Cloud Dashboard，在这里我们可以开始创建所需的服务。
或者，您可以使用https://cloud.ibm.com/直接访问 IBM Cloud
3.下一步是向您的云帐户添加新资源。在您的 IBM Cloud 帐户上，单击 Create Resource 按钮。
4.向下滚动并选择 Watson Studio 资源。
5.选择地区(我将选择法兰克福)，确保您已经选择了 Lite 计划(如果您不想支付)，然后单击创建。
6.在 Watson Studio 资源准备就绪之后，单击 Get Started。
7.在沃森工作室，我们将创建我们的第一个项目，称为糖尿病。为此，请单击“创建项目”按钮。
8.然后点击创建空项目按钮
10.为项目选择一个名称(此处为糖尿病)。下一步是将这个项目链接到一个对象存储(我们将在这里存储与项目相关的文件，如。用于训练数据、笔记本和由笔记本创建的资源等的 csv 文件)。要创建新的对象存储，请单击“添加”按钮。
11.选择 Lite 计划(如果您不想付费),然后单击创建
12.在弹出窗口中，为对象存储帐户命名，然后单击创建
13.刷新项目创建页面，您应该看到您创建的对象存储名称链接到项目。单击 Create 创建新的 Watson Studio 项目。
14.该项目将自动打开(如果没有，则在 Watson Studio 主页中单击该项目的名称)。现在，我们将在项目中添加一个 jupyter 笔记本文件，它将用于创建我们的神经网络，训练它，保存它并将其部署到 IBM Cloud。为此，请单击“添加到项目”按钮。
15.选择笔记本按钮。
16.给它起一个名字(比如糖尿病预测),对于运行时，选择默认的 Python 3.6 免费运行时。单击“创建笔记本”并等待笔记本初始化。
17.下一步是上传笔记本将使用的培训。为此，单击操作栏中的小矩阵图标，单击浏览并选择培训数据。csv 文件。
18.下一步是从上传的中读取数据。csv 文件。为此，单击 Insert to code 链接，这将自动向笔记本添加一段代码。如果您运行这个单元格(选择单元格并按 Shift+Enter ),它将连接到对象存储，读取 csv 文件并显示文件的前 5 行。
19.现在，我们将创建神经网络，训练它并将其保存到对象存储中
a.定义全局变量
b.导入必要的包
c.用于将数据拆分为特征变量和目标或标签变量，创建和训练模型，以及将模型加载到内存中的函数
d.因为我们将使用 zip deploy，所以我们必须压缩 NN 模型并创建一个. tgz 文件
20.现在我们有了压缩文件中的训练模型，下一步是将它部署到 IBM Cloud。对于这个部署，我们需要将 Watson 机器学习服务与糖尿病项目关联起来。为此，回到沃森工作室，点击汉堡包菜单，选择服务，然后沃森服务
21.点击添加服务
22.选择机器学习服务
23.在弹出菜单中选择地区(我将选择法兰克福)，给它命名并点击确认
24.将创建一个新的机器学习服务。单击服务的名称。
25.为了使用这个服务来部署我们的模型，我们需要凭证来访问这个服务。在“服务凭据”选项卡上，单击“新建凭据”按钮。
26.在弹出窗口中给 ti 一个名称，为服务 ID 选择 Auto Generate，然后单击 Add
27.复制服务凭据，因为我们将在笔记本中使用它进行部署
28.现在回到笔记本，因为我们将使用新创建的机器学习服务编写代码来部署模型
a.导入并创建 Watson 机器学习服务客户端
https://gist.github.com/cdc56c5f4ee03c9201b9e6d6ff842f8c
b.设置模型的属性，并将其发布到存储库中
c.我们将阅读新模型的指南，以确保它是成功生成的
d.创建部署
e.列出所有部署，以确保一切顺利
f.用于访问我们模型的 API 是自动生成的。我们将阅读这个的 url，来测试我们的模型。
g.从代码中测试模型。
29.如果我们想用 Postman 测试我们的模型，我们需要一个访问令牌。这可以用我们的笔记本来阅读:
a.安装 ibm-watson python 包
b.设置令牌管理器—您必须在 IBM Cloud IAM 中创建一个新的 API 密钥(或者在 IBM Cloud 主页上，单击 hamburger 菜单，选择 Security，选择 Manage，Identity and Access，这将为 IAM 打开一个新的选项卡)—单击 API 密钥，然后单击 Create an IBM Cloud API Key 按钮，复制密钥并插入令牌管理器。
d.在 Postman 头部分添加令牌
e.将测试数据添加到请求的正文中，然后单击 Send
30.现在，在你的名为糖尿病的沃森项目中，你应该有下图所示的资产
现在我们有了工作模型和 API 端点来安全地访问它**(基于令牌的认证)，我们可以继续使用 OpenScale 建立持续学习、漂移检测和**可解释性管道。****
在接下来的步骤中，我们将使用 Watson OpenScale 来解释结果，它使用 LIME 算法来解释模型(有关 LIME，请参见 解释可解释的 AI )。
IBM Cloud — OpenScale 逐步配置
- 在 IBM Cloud Resource 列表中，单击 Create resource 并选择 Watson OpenScale，为其命名，选择区域，选择 Lite 计划并单击 Create
2.启动 OpenScale 平台后，选择使用免费的 lite 计划数据库
3.下一步是添加机器学习提供者
4.你可以从多个提供商中选择，如沃森机器学习、Azure 或亚马逊服务，但我们有一个定制模型，因为我们的模型是手工构建的，由我们自己构建并手动部署。然后选择手动输入部署。
5.转到 Insights 仪表板，然后单击添加
6.在弹出窗口中，选择您部署的模型名称。
7.下一步是指定输入和输出数据模式。为此，我们必须创建一个新的 Jpyter 笔记本，并运行如下所示的代码:
8.下一步是配置模型细节:
a.选择存储桶名称和数据集名称
b.配置对象存储连接。为此，您应该进入 IBM Cloud 主页，单击“hamburger”按钮，单击“所有资源”、“存储”,选择您的存储，然后选择存储对象，在菜单中，您可以找到“配置”选项卡。在这里，您将找到建立连接的所有内容。
****
c.选择目标类的列名
d.选择功能列名称
e.选择包含分类数据文本的列(在本例中，我们没有任何分类数据)
f.选择输出变量名(这是自动创建的)
9.配置持续学习和漂移检测非常简单，您只需为评估指标(如准确性)设置一个阈值。
10.在所有的配置步骤(有效载荷记录、模型细节、质量、公平性、可解释性(这将被自动配置)、漂移)之后，你可以选择你的模型。
11.在“操作”下拉列表中，您可以上传测试数据并评估模型。如上图所示，生成了 10 份解释报告。如果您单击该数字，将出现一个弹出窗口，您可以在其中找到每个解释报告的 id。
12.您可以使用解释报告 id 来查看解释。
13.这将为您提供一个如下图所示的报告。例如，在这个报告中，您可以看到特征重要性、置信度等。
结论
在这篇文章中，我们了解到:
- 如何使用沃森工作室和沃森 OpenScale****
- 如何在沃森工作室使用 Jupyter 笔记本
- 如何在 Watson Studio 中创建、训练和测试神经网络****
- 如何将模型部署到 Watson 机器学习服务并设置具有安全连接的测试端点(基于令牌的安全性)
- 如何调用** 我们的模型使用 邮递员**
- 如何使用云对象存储以及如何将其连接到 Watson Studio 项目
- 如何建立一个 Watson OpenScale 部署模型并使用它来解释部署的神经网络的结果****
在下一篇文章中，我们将继续我们在可解释 AI** 世界的旅程，我们将继续 的第二部分解释可解释 AI**** 。未来，我们将讨论其他云提供商，我们将向您展示如何在 Google Cloud、Amazon 和 Azure 中部署模型和设置 API。如果你有兴趣，那么请跟着我上媒。**
感谢阅读这篇长文！
****成为媒介上的作家:https://czakozoltan08.medium.com/membership
我真的很喜欢咖啡，因为它给我精力去写更多的文章。如果你喜欢这篇文章，那么你可以给我买杯咖啡来表达你的欣赏和支持！
从 GitHub 向 Firebase 部署 Angular 应用程序
如何为自动化部署创建简单的 CI/CD 管道
由 Vadim Sadovski 在 Unsplash 上拍摄的照片
持续集成、持续交付或 CI/CD。这是开发人员的一个行话，而且有充分的理由。CI/CD 管道允许我们自动化大部分代码部署过程，使其在过程中更快更安全。
CI 部分包括构建、打包和测试我们的应用程序的自动化。在大多数情况下，这是由 Angular 自动完成的。而且，一旦我们编写了单元测试，它们也很容易集成到过程中。
接下来是 CD，我们应用程序的自动交付。在我们的例子中，这是对 Firebase 的部署。
在本文中，我们将使用 GitHub 操作来自动化 CI/CD 管道。这意味着每次我们点击git push origin master时，GitHub 会自动启动一个完整的构建、打包、(测试)和部署过程。我们将涵盖:
> Deployment Setup
- Writing Our Deployment (YAML)
- Secret Keys (With GitHub)
部署设置
首先，我们假设 Angular 应用程序已经通过常规的firebase deploy部署到 Firebase 主机上——如果你还没有这样做，请遵循这个指南。不会超过几分钟！
一旦我们准备好了，我们开始在项目的根目录下创建一个.github文件夹。在那里，我们添加了另一个名为workflows的文件夹，里面有一个名为main.yml的 YAML 文件。
Github Actions(相当于。github \我们项目目录中的工作流)。图片作者。
当目录.github\workflows被推送到 GitHub 时，它将被 GitHub 读取并用作 GitHub Actions 文件夹——我们为工作流存储 YAML 文件的地方！
但是什么是 YAML 文件呢？嗯，根据我们亲爱的维基百科 —
“YAML 是一种人类可读的数据序列化语言。它通常用于配置文件和存储或传输数据的应用程序中。
第一句话的意思是 YAML 是一种我们可以阅读的文件格式！它用于在不同语言或环境之间传输数据(JSON 是另一个例子)。
第二部分是我们需要了解的。这意味着 YAML 是一种提供指令的标准化方式，通常用于配置文件——就像我们的部署配置一样！
编写我们的部署
好的，让我们来看看我们将要使用的 YAML 文件。
虽然它看起来很混乱，但是一旦我们将脚本分解成几个部分，它就会变得非常简单。
- 简单来说就是给代码的不同部分命名(这是可选的！).
on: push: branches: - master，这是我们的触发器。它告诉 GitHub，一旦我们push到master branch，就触发下面的代码。- 接下来，我们在
jobs有我们的执行计划，包括一个build阶段。 - 我们在最新的 Ubuntu 机器
ubuntu-latest上执行一切。 - 现在我们执行计划中的每一个
steps。 - 我们通过
actions/checkout@master将我们的活动分支设置为master。 - 然后用
actions/setup-node@master初始化节点，这样我们就可以在下面的步骤中使用npm。 npm install添加了我们所有的应用依赖项，如下所示:
在 GitHub 动作中安装依赖项部署阶段。
- 之后，我们用
npm run build编译我们的应用程序——它被翻译成ng build:
GitHub 操作中部署的构建阶段。
- 最后，我们使用
w9jds/firebase-action@master部署我们新构建的应用程序，其中有两个额外的参数: - 我们传递了
deploy --only hosting参数，这意味着我们只部署到 Firebase 主机(而不是函数，例如)。 - 我们通过存储在 repo 中的
FIREBASE_TOKEN密钥传递我们的 Firebase 安全令牌(对我们进行身份验证)(我们将在接下来讨论这一点)。
这涵盖了我们的 YAML 中的所有内容，只不过是我们在部署应用程序时通常会执行的操作——除了指定操作系统！
秘密钥匙
唯一缺少的部分就是我们的FIREBASE_TOKEN。让我们解决这个问题。
如何使用 Firebase CLI 获取我们的 Firebase 令牌。图片作者。
首先，我们需要获得我们的访问令牌，为此我们只需:
1。打开我们的 CLI 并导航到我们的项目——通过键入firebase use [project-id](上面未显示)确保正确的 Firebase 项目处于活动状态。
2。使用firebase login:ci请求我们的 CI(持续集成)访问令牌，这将打开一个新窗口(否则，输入提供的 URL)。
3。在授权窗口中，我们需要登录 Google Cloud 并授权访问我们的帐户。
4。最后，我们收到了一个访问令牌，我们可以使用它将我们的应用程序部署到 Firebase！
现在我们有了令牌，我们需要导航到 GitHub 上的项目 repo 在这里我们可以添加访问令牌。
将 Firebase 令牌添加到项目 repo 的步骤。图片作者。
为此，在项目回购中，我们:
1 /3。从设置 > 机密中导航并点击新机密。打开新的秘密窗口。
4 /6。输入FIREBASE_TOKEN作为秘密名称，输入login firebase:ci提供的令牌，点击添加秘密！
现在，回到我们的 YAML 文件中，${{ secrets.FIREBASE_TOKEN }}允许我们访问刚刚为FIREBASE_TOKEN输入的值，而不需要将它存储在我们的回购文件中。
部署！
一旦我们设置好了一切，我们就像往常一样将项目推送到 GitHub repo 的主分支。回到我们的 CLI，我们输入如下内容:
git add .
git commit -m "Added CI support"
git push -u origin master
在 git 推送 origin master 之后，我们的 Angular 应用程序被部署到 Firebase。
我们的回购照常推送到 GitHub。要查看我们的部署，我们需要在 GitHub 中打开我们的 repo 并点击 Actions 选项卡。我们将看到“所有工作流程”窗口(如上)。
部署进度。
如果我们想更详细地查看我们的部署进度，我们单击我们的部署(在这里我们可以看到我们的提交消息)，在侧栏中，单击构建和部署。在这里，我们将能够看到我们的部署正在采取的行动列表。
部署完成！
一旦我们的部署完成，我们将在右上角看到一个绿色的勾号！我们可以通过点击构建和部署窗口中每个部署阶段旁边的下拉箭头来查看部署的更多细节。
最后几个音符
部署生产版本
目前，我们没有部署角度优化的生产构建。就像我们对ng build所做的一样——我们将--prod添加到npm run build以切换到生产版本。
回到我们的 YAML 文件，我们修改Build:
- name: Build
uses: npm run build **--prod**
集成测试
我们也可以合并我们的角度单元测试！就在— name: Install Dependencies之后，我们添加npm test，就像这样:
- name: Install Dependencies
run: npm install
**- name: Testing
run: npm test**
- name: Build
run: npm run build
包扎
我们结束了，我们已经谈了很多了！包括:
- YAML 脚本，以及如何编写一个将 Angular 应用程序部署到 Firebase 的脚本。
- 从 Firebase CLI 获取我们的
FIREBASE_TOKEN,并将其作为密钥添加到我们的 GitHub repo 中。 - 在 GitHub 中部署我们的应用程序并查看部署状态！
- 以及一些关于产品构建和单元测试的额外注释。
因此，我们建立了一个完全自动化的 CI/CD 管道——只要我们在 GitHub 中推送 master 就会触发！
我希望你喜欢这篇文章。如果您有任何问题、想法或建议，请随时通过 Twitter 或在下面的评论中联系我们！
感谢阅读！
将任何 Python 项目部署到 Kubernetes
是时候深入 Kubernetes，使用这个成熟的项目模板将您的 Python 项目带到云中了！
随着项目的增长，它可能会变得难以用单个虚拟机或一些简单的 SaaS 解决方案来处理。你可以通过切换到更强大的解决方案来解决这个问题，如 Kubernetes 。然而，如果你不熟悉它的概念或者以前从未使用过它，这可能会有点太复杂。因此，为了帮助您——在本文中——我们将介绍您入门并在集群上部署您的 Python 项目所需的所有内容——包括集群设置、所有的 Kubernetes 清单和一些额外的自动化，以使您的生活更加轻松！
这是上一篇关于 自动化您的 Python 项目 的每一个方面的文章的后续，所以在阅读本文之前，您可能想要检查一下。
TL；博士:这是我的储存库，里面有完整的源代码和文档:【https://github.com/MartinHeinz/python-project-blueprint】T21
舒适的开发设置
为了在你的开发过程中富有成效，你需要有一个舒适的本地开发环境。在这种情况下，这意味着在本地使用简单的 Kubernetes ，密切镜像您的真实生产集群，为此，我们将使用种类:
*KinD(Kubernetes-in-Docker)*顾名思义，在 Docker 容器中运行 Kubernetes 集群。它是 Kubernetes 维护人员用于 Kubernetes v1.11+一致性测试的官方工具。它支持多节点集群以及高可用性集群。因为在 Docker 中运行 K8s ， KinD 可以在 Windows、Mac、Linux 上运行。所以，你可以在任何地方运行它，你只需要安装 Docker。
所以，让我们安装类(在 Linux 上——如果你在 Windows 上，在这里看安装信息):
这样，我们就可以设置我们的集群了。为此，我们需要以下 YAML 文件:
这份清单描述了我们的星团。它将有 3 个节点—控制平面(role: control-plane)和 2 个工作者role: worker。我们还为它提供了一些更多的设置和参数，以便以后可以设置入口控制器，这样我们就可以在该集群上拥有 HTTPS。关于这些设置，您需要知道的只是extraPortMappings告诉集群将端口从主机转发到节点上运行的入口控制器。
注意:集群和 Python 应用程序的所有清单都可以在我的仓库 中找到，这里是 中的 *k8s* 目录。
现在，我们需要运行几个命令来启动它:
要创建集群，我们只需要运行第一个命令。之后，我们可以通过运行cluster-info和get nodes命令来检查是否可以运行。一段时间后，输入这些命令会变得很烦人，所以我们以后会更简单，但这样我们就可以启动并运行集群了。
接下来，我们要为我们的集群设置入口。为此，我们必须运行一些kubectl命令，使其与类一起工作:
首先，我们部署强制性的ingress-nginx组件。最重要的是，我们使用节点端口来公开 nginx 服务，这就是第二个命令所做的。最后一个命令为入口控制器应用一些类特定补丁。
定义清单
集群就绪后，就该设置和部署我们的应用程序了。为此，我们将使用非常简单的 Flask 应用程序— echo 服务器:
我选择了 Flask 应用程序，而不是一些 CLI 工具(或 Python 包)，因为我们需要不会像一些 Python 包那样立即终止的应用程序。另外，请注意host参数被设置为0.0.0.0，如果没有这个参数，当我们通过 Kubernetes 服务和入口公开应用程序时，将无法访问它。
接下来我们需要的是这个应用程序的 YAML 清单，让我们把它分成单独的对象:
- 命名空间:
这里没什么好谈的。我们通常不希望在default名称空间中部署应用程序，所以我们将使用这个名称空间。
- 配置映射:
这是我们可以为应用程序定义变量的地方。这些来自data部分的变量将作为环境变量注入到应用程序容器中。作为一个例子，我包括了FLASK_ENV和FLASK_DEBUG，当应用程序启动时，它们将被烧瓶自动拾取。
- 秘密:
与我们指定纯文本变量的方式相同，我们可以使用 Secret 向我们的应用程序添加凭证和密钥之类的东西。但是，不应该将该对象推送到您的存储库中，因为它包含敏感数据。我们可以使用以下命令动态创建它:
注意:部署应用程序所需的此命令和其他命令列在存储库中的 README 以及底部清单文件 中，此处为 。
- 部署:
.
现在是最重要的部分——部署。这里的相关部分是指定图像、端口和环境变量的spec部分。对于image，我们指定来自 Docker Hub 的图像。如果我们想使用像 Artifactory 这样的私有注册表，我们就必须添加imagePullSecret来提供集群获取映像的凭证。可以使用以下命令创建该密码:
这显示了您如何允许从 GitHub 包注册表中提取您的映像，不幸的是，由于上述 YAML 中列出的问题，它现在不能与类一起工作，但是它可以与您在云中的生产集群一起工作(假设它没有使用类)。
如果您想避免每次重新部署应用程序时都将映像推送到远程注册表，那么您可以使用kind load docker-image martinheinz/python-project-blueprint:flask将映像加载到集群中。
在image之后，我们还指定了ports。这些是我们的应用程序正在监听的端口，在本例中是5000，因为我们的应用程序开始使用app.run(host='0.0.0.0', port=5000)。
最后一部分，envFrom部分用于从上面显示的配置图和秘密中注入明文变量和秘密，通过在各自的Ref字段中指定它们的名称。
- 服务:
现在，我们已经有了在port上监听的应用程序，我们需要服务来公开它。所有这些对象定义了在端口5000上监听的应用程序应该在端口443上的集群节点上公开。
- 入口:
最后一大难题是入口——一个管理集群中服务外部访问的对象。让我们首先看看rules部分——在这种情况下，我们定义我们的主机是localhost。我们还将path设置为/，这意味着发送到localhost/的任何请求都属于由之前显示的服务及其port的名称定义的关联backend。
这里的另一部分是tls。本节通过指定包含tls.crt和tls.key的秘密为列出的hosts提供 HTTPS。让我们创造这个秘密:
上面的代码片段首先设置了几个变量，然后使用openssl为 TLS 生成证书和密钥文件。最后一个命令创建包含这两个文件的秘密。
部署应用程序
准备好所有清单后，我们终于可以部署我们的应用程序了:
上面的大多数命令我们已经在前面的章节中看到过了。新功能是kubectl apply -f app.yaml，它在我们的集群中创建了所有必要的对象。创建后，我们可以使用kubectl get all检查这些对象的存在。最后，我们可以使用cURL来检查应用程序是否是可访问的，它是可访问的！这样，我们的应用程序就可以在集群上运行了！
简单一点
如果你还没有完全适应所有的kind和kubectl命令，或者你像我一样懒，不想把它们都打出来，那么我有几个Make目标给你——让你的生活更轻松:
-
调出集群:
-
重新部署/重新启动应用程序:
如果集群还没有准备好，那么make cluster命令将为您设置集群，如果准备好了，它将为您提供关于它的所有信息。如果您需要检查节点的状态并切换到您的开发名称空间，这很好。
这个非常简单，它所做的只是推出新的部署，因此如果有新的映像，它将部署它，否则它将重新启动您的应用程序。
- 调试:
如果您需要调试您的应用程序，您可能想要查看与应用程序窗格相关的最近事件以及最近(上一小时)的日志。这正是make cluster-debug为你做的。
- 获取远程外壳:
如果日志不足以解决您可能遇到的一些问题，并且您决定需要在容器内部探索一下，那么您可以运行make cluster-rsh来获得远程 shell。
- 更新清单:
我们以前见过这个命令。它只是重新应用了 YAML 清单，这在您调整 Kubernetes 对象的一些属性时非常方便。
结论
这篇文章并不是 Kubernetes 的教程，但是我认为它足够让你快速启动并运行你的应用程序。为了学习更多关于 Kubernetes 的知识，我建议在清单中玩一玩，调整一下，改变一下，看看会发生什么。在我看来，这是了解事物如何工作并熟悉kubectl命令的好方法。如果您有任何疑问、建议或问题，请随时联系我或在我的资源库中创建问题。在这个报告中，你还可以找到本文中显示的文档和所有清单。
资源
本文最初发布于martinheinz . dev
在多个 Docker 容器中部署 Apache Airflow
在 Apache Airflow 中编排数据科学模型，使用 Celery Executor 进行扩展，并使用 Docker Compose 部署在多个 Docker 容器中
约书亚·阿拉贡在 Unsplash 上拍摄的照片
当涉及到数据科学模型时，它们会定期运行。例如，如果我们预测下个月的客户流失，模型必须在每个月的最后一天运行。每月手动运行该模型是不可取的。我们可以使用一个调度程序来自动化这个过程。Apache Airflow 是一个理想的工具，因为它允许调度和监控您的工作流。在本文中，我们将讨论如何使用 Docker 部署 Apache Airflow，并保留进一步扩展的空间。熟悉 Apache Airflow 和 Docker 概念将是阅读本文的一个优势。
阿帕奇气流简介
气流由 3 个主要部分组成；Web 服务器、调度程序和元数据库。Web 服务器负责用户与应用程序交互的用户界面。调度器负责作业调度，而元数据库存储调度细节。即使气流有几个执行器，芹菜执行器更适合可伸缩性。芹菜执行器 3 额外的组件添加到气流。它们是工作者、消息代理和工作者监视器。Worker 负责执行由调度程序触发的作业。可以有多个工人。这些工作者可以分布在集群实例中。工人的数量可以根据系统的工作量和机器的能力来决定。消息经纪人帮芹菜操作。可以使用监控工具来监控芹菜工人。
阿帕奇气流与芹菜执行器(图片由作者)
使用 Docker，我们计划将上述每个组件运行在一个单独的 Docker 容器中。Web 服务器、调度程序和工作人员将使用一个公共的 Docker 映像。这个公共映像对于项目来说是唯一的，我们将讨论构建这个映像的 Dockerfile 文件。所有其他容器将直接使用公开可用的图像。
在本教程中，PostgreSQL 被用作元数据库，Redis 被用作消息代理，而芹菜花被用于监控工人。因为有多个容器，所以使用 Docker Compose 可以很容易地一次性部署所有的容器。
项目结构
项目结构:https://github.com/nishakanthiA/Airflow-Docker(作者图片)
该图像显示了我们的项目结构。所有与项目相关的文件都放在脚本文件夹中。所有与气流相关的文件都放在气流文件夹中。与部署相关的其他文件在最外面的目录中。env.list包括分类模型所需的环境变量。requrements.txt定义要在 python 环境中安装的包，以便运行模型。
Dockerfile用于创建供 Airflow web 服务器、调度程序和工作人员使用的图像。docker-compose.yml用于定义和启动所有的容器。
提出了一个简单的模型来分类著名的虹膜数据集。我已经在 dags 文件夹中添加了两个带有PythonOperator的 DAGs。一个用于训练模型，另一个用于通过已训练的模型获得预测。DAG 到列车模型的定义没有计划间隔。这意味着一旦需要模型训练，它就可以被触发。预测旨在每天检索。因此，生成预测的 DAG 被安排每天运行模型。文件airflow.cfg包含气流的配置属性。
创建 Docker 图像
要使用 docker 展开气流，参考的最佳图像是puck El/docker-air flow*。(更新:气流现在有了它的官方 Docker 形象)*但是这个形象不能照原样使用；由于一些原因。一个原因是它没有安装我们在项目中使用的所有包。如果我们需要更改 airflow.config 文件中的属性，我们必须将它们作为环境变量传递。由于存在大量变量，这并不容易。因此，我们将使用puckel/docker-airflow的基本映像编写一个定制的 docker 文件。除了 message broker、元数据库和 worker monitor 之外，这个映像将用于我们的所有容器中。以下是 Dockerfile 文件。
FROM puckel/docker-airflow:1.10.9COPY airflow/airflow.cfg ${AIRFLOW_HOME}/airflow.cfgCOPY requirements.txt /requirements.txt
RUN pip install -r /requirements.txt
创建 Docker 容器
元数据库
让我们首先为元数据库容器定义服务。Docker image postgres:9.6用于此。用户凭证和数据库名称应该作为环境变量给出。设置该容器时，数据库名称(POSTGRES_DB=airflow)应与 airflow 配置sql_alchemy_conn中的数据库连接字符串兼容。
version: '3.7'
services:
postgres:
image: postgres:9.6
environment:
- POSTGRES_USER=airflow
- POSTGRES_PASSWORD=airflow
- POSTGRES_DB=airflow
如果您已经有一个现有的 PostgreSQL 服务器，并且希望使用它，则不需要为元数据库部署额外的容器。为服务器中的气流元数据创建专用数据库。Airflow 将在启动时填充数据库，然后负责维护数据库。可以通过气流配置给出服务器的详细信息。设置服务器细节的一种方法是修改airflow.cfg文件中的sql_alchemy_conn。另一种方法是把它作为一个环境变量AIRFLOW__CORE__SQL_ALCHEMY_CONN。下面是为 PostgreSQL 连接提供的连接字符串的格式。登录服务器的凭证用户名、密码、主机 IP、数据库名应该作为环境变量传递。
sql_alchemy_conn =postgresql+psycopg2://$PG_USER:$PG_PASSWORD@$PG_HOST:5432/$PG_DB_NAME
这样，我们的第一个容器就变成可选的了。
芹菜执行器的消息代理
在这个项目中，我们通过使用多个气流工作者来关注应用程序的可伸缩性。为此，我们可以使用芹菜执行器。在气流配置文件中设置executor = CeleryExecutor 。环境变量是AIRFLOW__CORE__EXECUTORT11。
Celery 是一个任务队列实现，Airflow 使用它在后台定期异步运行并行批处理作业。它需要一个像 Redis 和 RabbitMQ 这样的消息代理来传输消息。气流没有这部分，需要外部实现。这里我们用 Redis。我们可以使用 image Docker image *redis:5.0.5*
用我们的第二个容器docker-compose.yml会是这个样子。
version: '3.7'
services:
postgres:
image: postgres:9.6
environment:
- POSTGRES_USER=airflow
- POSTGRES_PASSWORD=airflow
- POSTGRES_DB=airflow
redis:
image: redis:5.0.5
这里我们也可以使用一个外部 Redis 服务，而不需要创建这个容器。凭证应由气流配置文件中的broker_url、celery_result_backend给出。
Airflow Web 服务器
气流用户界面(图片作者)
我们的第三个容器是 Aiflow web 服务器，它负责用户界面。对于这个容器，我们将使用以前创建的 Docker 图像。以下是服务“webserver”的 docker 容器配置。
**webserver:
image:** webserver:latest
**build:
context:** .
**restart:** always
**depends_on:** - postgres
- redis
**environment:** - LOAD_EX=n
- FERNET_KEY=46BKJoQYlPPOexq0OhDZnIlNepKFf87WFwLbfzqDDho=
- EXECUTOR=Celery
- PYTHONPATH=/usr/local/airflow
**env_file:** - env.list
**volumes:** - ./airflow/dags:/usr/local/airflow/dags
- ./scripts:/usr/local/airflow/scripts
**ports:** - **"8080:8080"
command:** webserver
**healthcheck:
test:** [**"CMD-SHELL"**, **"[ -f /usr/local/airflow/airflow-webserver.pid ]"**]
**interval:** 30s
**timeout:** 30s
**retries:** 3
每个命令的用法解释如下。
- 构建上下文:指向创建的 Dockerfile。相应映像是在容器启动时构建的
- 重新启动:如果由于任何原因停止了，重新部署容器。
- 依赖于:web 服务器需要与元数据库和消息代理容器通信
- 环境:这些是基本映像 puckel/docker-airflow 请求的列表环境变量。让它们保持原样。您可以自由地添加更多的环境变量，如“PYTHONPATH ”,这些变量将被您自己的程序脚本使用。
- env_file:可以使用 file 给出环境变量的列表
- 卷:Dag 和程序脚本可以作为卷挂载。这比将文件复制到 Docker 映像中更有效。文件更新后，更改将自动部署到 web 服务器中。不需要构建映像和重新部署容器。
- 端口:要部署的端口。web 服务器正在端口 8080 上运行。
- command : airflow 命令启动 web 服务器。这是基础映像 puckel/docker-airflow 所要求的。不要修改它。
- healthcheck:检查容器健康状况的测试
气流调度程序
我们的第四个容器是 Aiflow scheduler。除了命令和依赖关系之外，服务配置与 Airflow web 服务器非常相似。命令是启动调度程序的气流命令。调度程序依赖于 web 服务器容器。
**scheduler:
image:** scheduler:latest
**build:
context:** .
**restart:** always
**depends_on:** - webserver
**volumes:** - ./airflow/dags:/usr/local/airflow/dags
- ./scripts:/usr/local/airflow/scripts
**environment:** - LOAD_EX=n
- FERNET_KEY=46BKJoQYlPPOexq0OhDZnIlNepKFf87WFwLbfzqDDho=
- EXECUTOR=Celery
- PYTHONPATH=/usr/local/airflow
**command:** scheduler
**env_file:** - env.list
气流工人
下一个集装箱是气流工人。命令是启动工作机的气流命令。工作进程依赖于调度器容器。可以有多个工人。这里我加了两个。
**worker1:
image:** worker1:latest
**build:
context:** .
**restart:** always
**depends_on:** - scheduler
**volumes:** - ./airflow/dags:/usr/local/airflow/dags
- ./scripts:/usr/local/airflow/scripts
**environment:** - FERNET_KEY=46BKJoQYlPPOexq0OhDZnIlNepKFf87WFwLbfzqDDho=
- EXECUTOR=Celery
- PYTHONPATH=/usr/local/airflow
**command:** worker
**env_file:** - env.list
**worker2:
image:** worker2:latest
**build:
context:** .
**restart:** always
**depends_on:** - scheduler
**volumes:** - ./airflow/dags:/usr/local/airflow/dags
- ./scripts:/usr/local/airflow/scripts
**environment:** - FERNET_KEY=46BKJoQYlPPOexq0OhDZnIlNepKFf87WFwLbfzqDDho=
- EXECUTOR=Celery
- PYTHONPATH=/usr/local/airflow
**command:** worker
**env_file:** - env.list
让多个工人在同一台机器上还可以减少作业的执行时间。为了获得更有效和最佳的结果，气流配置文件中的属性parallelism 、dag_concurrency、worker_concurrency和max_threads应根据工人数量进行调整。其中一些属性也可以在 DAG 级别进行调整。
工人可以分布在集群中的多台机器上。一台单独的机器将负责每个工人，而所有其他容器可以部署在一台公共机器上。我们可以保留一个单独的 docker-compose 文件来部署工人。主 docker-compose 文件将包含其余容器的服务。以下是 ECS 集群中 AWS EC2 实例中部署的 worker 容器的 docker-compose 文件示例。
version: '3.7'
services:
remote_worker_3:
image: remote_worker_3:latest
build:
context: .
args:
github_token: ${GITHUB_TOKEN}
restart: always
external_links:
- redis_1:redis
networks:
- sample_project_default
environment:
- FERNET_KEY=46BKJoQYlPPOexq0OhDZnIlNepKFf87WFwLbfzqDDho=
- EXECUTOR=Celery
volumes:
- ./sample_project/airflow/dags:/usr/local/airflow/dags
- ./sample_project/src:/usr/local/airflow/dags/src
env_file:
- env.list
command: worker
stdin_open: true
tty: truenetworks:
sample_project_default:
external: true
网络名称可以通过docker network ls命令找到。如果你有兴趣了解更多关于 Docker 网络搜索的信息。
工人监视器
芹菜花仪表板(https://flower.readthedocs.io/en/latest/screenshots.html)
工人的行为可以通过芹菜花来监控。这也是一个可选的容器。以下是花卉容器的配置。
**flower:
image:** flower:latest
**build:
context:** .
**restart:** always
**depends_on:** - redis
**environment:** - EXECUTOR=Celery
**ports:** - **"5555:5555"
command:** flower
部署
现在，我们准备用多个 Docker 容器部署我们的气流项目。我们可以使用 docker-compose.yml 文件一次性部署所有的容器。下面是一些有用的 Docker 命令。
- 开始容器:
docker-compose up -d -- build - 停止容器:
docker-compose down - 查看容器:
docker ps - 进入一个容器:
docker exec -it <container-id> bash - 查看一个容器的日志:
docker logs <container-id> - 监控集装箱:
docker stats
项目网址:https://github.com/nishakanthiA/Airflow-Docker
用 Python 和 Docker 部署 API
使用 Flask、Docker 和 Google Cloud 部署 API 的权威指南
这里有一些软件开发中的技巧，它们就像闸门一样阻挡着广阔的机会海洋。当学习其中一种技能时，似乎一个全新的世界突然被照亮了。
通过这篇文章，我们将涵盖我认为是这些技能之一。能够编写可部署到互联网并与 API 通信的代码。
构建一个可部署的 API 需要几个子技能，我们将在组装 API 时讨论这些子技能。然而，罗马不是一天建成的，精通(甚至能力)也不是——所以这不是一篇五分钟内从零到英雄的文章。
这篇文章是一个介绍，我们将涵盖要点——不多不少。在本文的最后，我们将拥有一个托管在云上的全功能 API。
简而言之，我们将涵盖—
> **Build an** **API** with Flask
> **Package** our app with Docker
> **Deploy** with Google Cloud Platform (GCP)
> **Test** with Postman
您可以在这里找到本文的 GitHub repo。
用 Flask 构建 API
我们创建一个新文件夹，其中包含一个名为app.py的 Python 脚本。该脚本将包含我们的 API 代码，其结构如下:
importsapp initializationAPI class
GET method
POST method
DELETE methodHTTP mapping
如果事情的顺序变得混乱——完整的app.py脚本在这一部分的末尾，你可以在 GitHub 上找到这个项目。
设置
导入和应用初始化
在这里，我们在导入中设置了最低限度，并像这样初始化我们的 API flask 应用程序:
from flask import Flask
from flask_restful import Resource, Api, reqparse
import pandas as pd
import osapp = Flask(__name__)
api = Api(app)
API 类别
在我们的 API 脚本中，我们需要定义一个包含 HTTP 方法 GET、POST 和 DELETE 的类。
Flask 需要知道这个类是我们 API 的入口点，所以我们用类定义传入Resource。我们将创建一个名为Places的类:
class Places(Resources):
<methods go here>
我们还需要告诉 Flask 这个 API 类的入口点在哪里。例如，如果我们的 API 位于www.api.com，我们可能想要指定在[www.api.com**/places**](http://www.api.com/places.) 提供Places类的入口。
我们可以使用add_resource方法来做到这一点:
api.add_resource(Places, '/places')
这个方法被放在类定义之外，并遵循类定义。
当然，这意味着我们可以在 API 中添加多个类和入口点。这对于更复杂的服务尤其有用——尽管在本文中我们将只讨论其中一个。
为了简单起见，我们将把代码中嵌入的数据作为 Python 字典来操作。看起来是这样的:
DATA = {
'places':
['rome',
'london',
'new york city',
'los angeles',
'brisbane',
'new delhi',
'beijing',
'paris',
'berlin',
'barcelona']
}
获取
我们使用这种方法来获取数据，在我们的例子中，数据就是我们的DATA字典。
def get(*self*):
*# return our data and 200 OK HTTP code* return {'data': DATA}, 200
帖子
POST 方法用于将数据添加到我们的DATA['places']列表中。
def post(*self*):
*# parse request arguments* parser = reqparse.RequestParser()
parser.add_argument('location', *required*=True)
args = parser.parse_args()*# check if we already have the location in places list* if args['location'] in DATA['places']:
*# if we do, return 401 bad request* return {
'message': f"'{args['location']}' already exists."
}, 401
else:
*# otherwise, add the new location to places* DATA['places'].append(args['location'])
return {'data': DATA}, 200
这里发生了什么事？
reqparse库允许我们解析传递给 POST 请求的参数。例如，如果我们的 places API 位于 web 地址api.com/places处，我们可以指定我们要添加的新位置的location，如下所示:
api.com/places?**location=sydney**
- 在取出位置参数后，我们需要检查它是否已经存在于
DATA['places']中——这是我们用if语句完成的。如果数据已经存在，我们简单地返回409 Conflict和一条简短的消息，解释所提供的位置已经存在。 - 否则，我们可以将新位置添加到我们的
DATA['places']列表中，然后返回新的DATA和一个200 OKHTTP 代码。
删除
我们用 DELETE 作为 POST 的一个等价的相反的动作。用户指定要从DATA['places']列表中移除的位置。
def delete(*self*):
*# parse request arguments* parser = reqparse.RequestParser()
parser.add_argument('location', *required*=True)
args = parser.parse_args()*# check if we have given location in places list* if args['location'] in DATA['places']:
*# if we do, remove and return data with 200 OK* DATA['places'].remove(args['location'])
return {'data': DATA}, 200
else:
*# if location does not exist in places list return 404* return {
'message': f"'{args['location']}' does not exist."
}, 404
这里发生了什么事？
作为一个相等且相反的操作，我们稍微修改了 POST 逻辑:
- 我们还是用同样的方法使用
reqparse。 - 对于 location 参数，我们再次使用相同的
if语句来检查它是否已经存在于DATA['places']中。如果是的话，我们从 T3 中 T2 它，并返回新的 T4 和一个 T5 HTTP 代码。 - 否则，我们返回消息
404 Not Found，解释所提供的位置在DATA['places']中不存在。
总共
如果我们将所有这些部分放在一起，我们将得到以下脚本:
带 Docker 的包装
下一步，我们将创建一个 Docker 映像。这里有两个相似的术语——图像和容器。
一个映像本质上是一个蓝图——而一个容器是一个根据蓝图构建的结构/部署。
首先，我们将创建我们的映像，然后将它部署到 Google cloud(在那里它将成为一个容器)。
创建我们的 Docker 形象有三个关键步骤:
- 获取码头工人
- 设置我们的 docker 文件
- 建立我们的形象
1。Docker 文档能够比我更好地指导你完成安装过程！你可以在这里找到它们。
关于 Windows 或 Mac 上 Docker 的概述，请查看此视频:
Windows 上的 Docker 为 1:46:21，Mac 上的 Docker 为 1:53:22。
2。因为我们将 API 部署为 docker 容器，所以我们需要在目录中包含一个名为 Dockerfile 的容器设置文件。
在我们的 docker 文件中，我们将为三个 Python 库使用RUN命令——所有这些都将指定使用一个 requirements.txt 文件。
对于我们的简单 API，它看起来像这样:
flask
flask-restful
gunicorn
在我们的 **Dockerfile，**中，我们概述了我们的形象(容器蓝图)。Docker 将读取提供“构建”指令的Dockerfile。
FROM python:3.6-slim-busterWORKDIR /app
COPY . .RUN pip install -r requirements.txtCMD exec gunicorn --bind :$PORT --workers 1 --threads 8 --timeout 0 app:app
这里发生了什么？
- 我们使用另一个官方图像和
FROM python:3.6-slim-buster初始化我们的图像。这个脚本初始化官方的 Docker Python 3.6‘slim-buster’图像——官方 Python 图像的完整列表在这里可以找到。 - 接下来，我们将图像中的活动目录设置为带有
WORKDIR /app的/app——这是我们的 Google Cloud 实例所期望的结构。 - 现在我们
COPY从源文件目录到镜像文件系统的所有东西。在这种情况下，从目录Dockerfile所在—到活动图像目录/app。 - 我们的依赖关系列表
requirements.txt现在在镜像文件系统中，我们RUN pip install递归地-r遍历requirements.txt的每一行。实质上就是:
pip install flask
pip install flask-restful
pip install gunicorn
- 最后，我们使用
[gunicorn](https://gunicorn.org/)包初始化我们的 HTTP 服务器。我们使用CMD指令来执行gunicorn并传递几个服务器设置参数。
3。我们的最后一步是构建 Docker 图像，稍后我们将把它上传到 Google 容器注册中心。
要构建映像，请打开 CLI，导航到包含我们的文件的目录，然后键入:
docker build -t tut-api .
- 这里，
docker build是 Docker 镜像构建命令。 - 我们使用
-t标志来指定我们的图像名称。 tut-api仅仅是我们形象的名称，随便你怎么称呼它。.告诉 docker 将当前目录中的所有内容包含在映像中*(别忘了这一点，我几乎每次都这么做)*。
最后，我们可以继续将我们的 API 部署到云中。
部署到云
这里，我们将使用谷歌云平台(GCP)的容器注册表来存储我们的 Docker 映像，并使用 Cloud Run 来部署它。
项目和容器注册
首先，我们需要建立一个项目。我们首先在云控制台中导航到项目选择器页面，然后点击创建项目。
记下项目 ID —我们稍后会用到。
这里我们简单地给我们的项目起个名字——我的是 medium 。
接下来，我们需要在谷歌控制台中导航到容器注册表 (GCR)。如果我们已经正确设置了我们的项目，我们将会看到如下所示的屏幕:
我们的空谷歌容器注册(GCR)屏幕。
云构建
我们将使用云构建将我们的映像构建到一个容器中。在我们这样做之前，我们需要为我们的项目启用云构建 API。只需点击此处并选择您正在进行的项目:
为云构建 API 注册项目。
现在我们有了项目设置，我们需要使用 Google Cloud SDK 将我们的 API Docker 映像推送到 GCR——我们从这里下载。
证明
安装完成后，我们需要登录 gcloud。为此，只需在 CMD 提示符(或等效的 CLI)中键入:
gcloud auth login
该命令将打开我们的 web 浏览器，允许我们像往常一样登录。然后，我们将 Docker 配置为使用我们的凭证:
gcloud auth configure-docker
上传到容器注册表
我们将使用 GCR 来存储我们的形象。为了构建我们的容器并将其保存到注册表中，我们导航到我们的 API 目录并submit它:
gcloud builds submit --tag gcr.io/[PROJECT-ID]/tut-api
gcloud builds submit是我们用来将图像提交给云构建的命令。
我们的注册表位置作为目标映像提供，其中:
*gcr.io*是 GCR 主机名 。*[PROJECT-ID]*是我们的项目 ID，这是我们在创建项目时看到的——对我来说是*medium-286319*。*tut-api*是我们的形象名称。
现在，如果我们导航回我们的注册表，我们应该会看到我们新上传的 Docker 映像(这可能需要一些时间来构建，请查看您的云构建仪表板):
使用云运行部署
有了 Docker 容器，我们就可以通过 Cloud Run 将它部署到 web 上。
我们通过点击左上角的导航按钮(在 GCP 控制台中)并选择云运行来打开云运行控制台。
接下来，我们将看到云运行界面，我们通过单击创建服务来部署我们的容器:
接下来，我们(2)输入我们的首选部署设置，(3–4)选择我们的容器映像，以及(5)创建我们的部署！
在我们的 API 被部署之后，我们可以在云运行控制台的顶部找到 API 的 URL。
云运行中 API 的 URL。
测试我们的部署
对于测试 API， Postman 是你的朋友——在这里找到下载链接。
安装完成后，打开 Postman 并输入 API 的网址，例如:
[https://tut-api-2czbipghsq-ew.a.run.app/](https://tut-api-2abcdefgh-ew.a.run.app/.)
在我们的代码中，我们将我们的Places类的位置指定为/places:
api.add_resource(Places, '/places')
因此，我们知道要访问包含在Places中的方法，我们必须将/places添加到我们的 API 地址:
[https://tut-api-2czbipghsq-ew.a.run.app**/places**](https://tut-api-2abcdefgh-ew.a.run.app/places)
得到
对于 GET 请求，这就是我们所需要的—将其输入地址栏，在下拉列表中单击 GET ，然后单击 Send 。
顶栏显示我们正在向https://tut-api-2czbipghsq-ew.a.run.app/places发送一个 GET 请求。底部区域显示我们的数据响应，右上角显示状态:200 OK 。
让我们也测试一下其他方法——记住为 POST 和 DELETE 请求添加我们的location参数，并更新请求类型(在下拉列表中)。
邮政
在下拉列表中选择岗位，添加**？location=sydney** 到地址栏，点击发送。我们将返回我们的数据附加 sydney。
仍然使用 POST ，我们将地址栏中的悉尼改为罗马，并点击发送。我们将返回一个 401 未授权的 HTTP 代码和一条简单的消息，告诉我们罗马已经存在。
删除
在下拉列表中选择删除，我们保留位置为罗马，点击发送。我们将返回删除了罗马的数据。
现在，如果我们试图删除东京(不存在)——我们将返回一个 404 Not Found HTTP 代码，并带有一条消息告诉我们东京不存在。
打开闸门
这就是这个简单的 API 示例，它内置在 Flask 中，并使用 Docker 部署在 GCP 上。
简而言之，构建一个 API 并将其部署到 web 上是一个极其简单而高效的过程。这并不难，并为我们打开了一片广阔的机会之门。
我希望你喜欢这篇文章——如果你有任何问题或建议，请随时通过 Twitter 或在下面的评论中联系我们。如果你想要更多这样的内容，我也会在 YouTube 上发布。
感谢阅读！
如果您喜欢这篇文章，并且有兴趣进一步拓展您在网络技术方面的技能组合，请在此尝试我的数据科学角度介绍:
[## 如何使用 Angular 部署 TensorFlow Web 应用程序
在角度构建的 web 应用程序中使用 Python 构建的模型
towardsdatascience.com](/how-to-use-angular-to-deploy-tensorflow-web-apps-5675b5a042cc)
使用 CDK 将自动扩展机器学习模型推理堆栈部署到 AWS
使用 AWS/CDK 的强大功能，在一个堆栈中部署 ML 模型，该堆栈可以自动扩展，以便在 CPU 或 GPU 上进行推理
来源: unsplash
几年来，数据科学和机器学习非常性感，许多公司都将“人工智能”作为一种新的强大工具，以黑匣子的形式自动化复杂的任务。在这个领域，深度学习似乎是建立模型来检测和分类图像或文本以及其他酷东西的圣杯。一旦训练好模型，通常将它们部署在小型 web 服务器上，并公开一个简单的 REST API 来对给定的样本执行推理。它通常非常方便，而训练模型需要大量的计算能力和大量的 GPU，推理只需要一个相对低功率的 CPU 来对单个样本进行预测。您可以找到许多关于这种方法的文章和博客帖子；事件开源项目和公司可以使整个事情变得轻松。
然而，在有些情况下，您需要不仅对一个样本，而且对一批样本进行推断。在这种情况下，推理在 CPU 上执行时会花费大量时间，您需要使用 GPU 来并行化作业。使用一个小的网络服务器现在不再适用，因为你不想为一台连接了 GPU 的一直运行的机器付费。例如，假设您必须对上传到您的 S3 存储桶的大文件执行一些预测。你的文件首先被分割成小块，模型根据这些小块进行预测。你想要的是你的栈在一个文件准备好处理的时候自动启动，使用一个有 GPU 的机器，当没有东西要处理的时候关闭整个东西。因为没有可用的无服务器堆栈(将来会有吗？)，我们需要构建一个堆栈来根据我们的需求自动扩展。
体系结构
建议的体系结构如下:我们得到一个带有要执行的任务的 SQS 消息。例如，它可能是 S3 上要处理的文件的名称。根据在 AWS 的参数存储中找到的配置参数，该消息被转发到另一个 SQS 队列，一个用于基于 CPU 的堆栈，另一个用于基于 GPU 的堆栈。然后，ECR 集群使用 Cloudwatch 警报来触发两个自动伸缩组的伸缩，一个使用纯 CPU 实例，另一个使用支持 GPU 的实例。然后将结果返回到 S3 桶中。
提议的架构
自动化
为了使整个过程更加自动化，我们可以使用 CDK 应用程序。就像 Terraform 或 Kubernetes 提供通过代码构建堆栈一样，CDK 倾向于成为在 AWS 上部署堆栈的参考。你当然可以使用 Cloudformation，但是一想到要使用非常大的 YAML 文件来管理一个堆栈，我就害怕。然而，使用像 Typescript、C#或 Python 这样的现代编程语言要有趣得多。在存储库源代码中，您可以找到两个类来构建堆栈:DeployModelEcsMediumStackCore和DeployModelEcsMediumStack。第一个，顾名思义，构建堆栈的核心，即主 SQS 队列，附加一个 lambda 函数、一个 ECS 集群和一些 IAM 策略的定义。然后DeployModelEcsMediumStack类为 CPU 或 GPU 架构构建一个堆栈。SQS 队列和相关指标、具有正确 AMI 的自动扩展组、实例类型和扩展策略，以及具有要检索的正确 ECR 映像的 ECS 任务。
串
首先，应该用ecs.Cluster构造创建一个集群。在那里，我们创建一个自动扩展组，使用cluster.addCapacity静态方法向集群添加一个容量提供者。然后我们需要用构造ecs.Ec2TaskDefinition创建一个任务，提供用静态方法ecs.ContainerImage.fromEcrRepository检索的正确的 ECR 图像。该映像必须是基于 ECS 优化 AMI 的映像才能正常工作。没有官方的 AWS AMI 支持 ECS 的 GPU，但是你可以找到自定义的。我们还需要注意gpuCount属性，当我们要使用 GPU 时，将其设置为1。最后，使用构造ecs.Ec2Service创建服务，并将其附加到集群。
使用堆栈
一旦一切都部署完毕，您所需要做的就是在主 SQS 队列中发送一条消息，其中包含要执行的命令，在我的示例中就是要在 S3 上检索的文件的名称。要决定是使用基于 GPU 的实例还是仅使用 CPU 的实例，我们只需要在系统管理器的参数存储中更改配置。这种消息的一个例子可以是
aws sqs send-message --queue-url [https://sqs.ca-central-1.amazonaws.com/1234567890/MediumArticleQueue](https://sqs.ca-central-1.amazonaws.com/1234567890/MediumArticleQueue) --message-body '{"filename": "file_to_process.bin"}'
行列
在提议的架构中有三个 SQS 队列，但是用户只需要在主队列[MediumArticleQueue](https://sqs.ca-central-1.amazonaws.com/1234567890/MediumArticleQueue)中发送一个消息。一旦接收到消息，λ函数被触发，并且关于配置(SSM/参数存储中的参数)，消息被转发到适当的队列，GPUQueue用于管理基于 GPU 的实例的自动缩放组，CPUQueue用于仅基于 CPU 的实例。
密码
这个 CDK 堆栈的 typescript/python 代码在这里发布有点大，但是你可以在这个 repo 中找到源代码。请随意复制或分叉代码，只需竖起大拇指或一点点意见将不胜感激。
最后一个音符
在源代码中，我定义了警报来缩放自动缩放组，但没有缩放任务计数。原因是在添加 ECS 服务时，我们还用ecsService.autoScaleTaskCount方法设置了它的自动伸缩行为。然而，AWS/CDK 没有正确地将任务扩展和实例扩展联系起来，而任务扩展和实例扩展是容量提供者的职责。当您直接在控制台中工作时，可以实现这种行为，但不是通过编程实现的。有一个 PR 来纠正它，但是在这篇文章发表的时候它还不可用。为了以后支持这个特性，我添加了一个注释代码部分来说明当这个特性发布时，代码会是什么样子。
使用 PyCaret 构建:在 Microsoft Azure 平台上部署
实用教程
将机器学习模型部署到 Microsoft Azure 平台
在这个故事中，我开发了一个工作教程，在微软的 Azure 云平台上部署一个用pycaret库训练的模型。在我之前的文章用 PyCaret 构建:在 Google 云平台上部署中，我们已经学习了如何在 Google 云上部署模型。我们将在本教程中使用相同的示例，并在 Microsoft Azure 平台上部署该模型。
我们学习把用pycaret训练的模型部署到微软 Azure 平台上。pycaret支持在 AWS 上部署训练有素的模型，但目前不支持 GCP 或 Azure。我遵循了类似于 library 中使用的代码实践，用 AWS 部署和加载模型，在微软的 Azure 平台上部署模型。
PyCaret 是 Python 中的一个开源、低代码机器学习库，允许您在几秒钟内从准备数据到在您选择的笔记本环境中部署模型。来源
PyCaret 是公民数据科学家的 autoML 框架，在其官方文档和主页中使用。这是一个相对较新的库，几个月前发布供公众使用，目前仍在积极开发中。在浏览了一些源代码后，我意识到当前的公开版本缺乏对 Google 和 Azure 云平台的训练/最终模型部署的支持。不过，它支持在 Amazon web services 上部署。
微软 Azure 是另一个非常受欢迎的云服务框架，目标市场不同于谷歌和 AWS。Azure 已经拥有庞大的客户群，并获得了合理的市场份额。在我看来，对于公民数据科学家来说，大概微软 Azure 是最好的起点。让我们学习如何在 Microsoft Azure 上部署模型。
对于本教程，我们将使用回归教程(REG101) —初级初学者进行模型训练。
正在安装 pycaret
!pip install pycaret
安装 Gdrive
我们需要安装 google drive 来读取 colab 环境中的数据。下面是最简单的安装方法。您将被要求输入访问过程生成的令牌。这里是关于安装 gdrive 的文章的链接
在本教程中，我们将在 Google drive 上本地保存模型。
from google.colab import drive
drive.mount('/content/drive')Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount("/content/drive", force_remount=True).
让我们创建一个目录来本地保存模型。
# Create directory on google drive to save models locally. You can use temp paths.
import os
model_dir = '/content/drive/My Drive/azure_deploy_model/'
os.makedirs(model_dir, exist_ok=True)
获取数据
您可以从这里找到的原始源下载数据，并使用 pandas (了解如何使用) 加载数据，或者您可以使用 PyCaret 的数据存储库，使用get_data()函数加载数据(这将需要互联网连接)。
from pycaret.datasets import get_data
dataset = get_data('diamond')
#check the shape of data
dataset.shape(6000, 8)data = dataset.sample(frac=0.9, random_state=786).reset_index(drop=True)
data_unseen = dataset.drop(data.index).reset_index(drop=True)
print('Data for Modeling: ' + str(data.shape))
print('Unseen Data For Predictions: ' + str(data_unseen.shape))Data for Modeling: (5400, 8)
Unseen Data For Predictions: (600, 8)
在 PyCaret 中设置环境
让我们使用 pycaret 的设置模块设置建模管道。
from pycaret.regression import *exp_reg101 = setup(data = data, target = 'Price', session_id=123)Setup Successfully Completed!
创建一个轻型 GBM 模型
对于本教程，我们使用 pycaret 中实现的许多选项中的轻量级 GBM 对数据进行建模。您可以选择任何您喜欢的模型，但这不是本教程的重点。
lightgbm = create_model('lightgbm')
调谐光梯度增强机
让我们来训练这个模型，用 pycaret 的术语来说，这个模型也被称为调整模型。
tuned_lightgbm = tune_model('lightgbm')
残差图
下图显示了模型的残差
plot_model(tuned_lightgbm)
预测误差图用于绘制目标的预测误差与真实值。
plot_model(tuned_lightgbm, plot = 'error')
特征重要性图
特征重要性是非常有用的图，可以看到模型中每个特征的贡献。
plot_model(tuned_lightgbm, plot='feature')
分析模型性能的另一种方法是使用evaluate_model()功能，该功能显示给定模型所有可用图的用户界面。它在内部使用plot_model()功能。
evaluate_model(tuned_lightgbm)interactive(children=(ToggleButtons(description='Plot Type:', icons=('',), options=(('Hyperparameters', 'param…
根据测试/保留样本进行预测
predict_model(tuned_lightgbm);
最终确定用于部署的模型
final_lightgbm = finalize_model(tuned_lightgbm)#Final Light Gradient Boosting Machine parameters for deployment
print(final_lightgbm)LGBMRegressor(boosting_type='gbdt', class_weight=None, colsample_bytree=1.0,
importance_type='split', learning_rate=0.4, max_depth=10,
min_child_samples=20, min_child_weight=0.001, min_split_gain=0.9,
n_estimators=90, n_jobs=-1, num_leaves=10, objective=None,
random_state=123, reg_alpha=0.9, reg_lambda=0.2, silent=True,
subsample=1.0, subsample_for_bin=200000, subsample_freq=0)predict_model(final_lightgbm)
****
根据看不见的数据预测
unseen_predictions = predict_model(final_lightgbm, data=data_unseen)
unseen_predictions.head()
Label列被添加到data_unseen集合中。标签是使用final_lightgbm模型的预测值。如果您想对预测进行四舍五入，您可以在predict_model()中使用round参数。
保存模型
让我们首先在本地保存模型
model_dir
model_name = 'Final_lightgbm_model''/content/drive/My Drive/azure_deploy_model/'# Saving model to google drive
save_model(final_lightgbm, model_dir + model_name)Transformation Pipeline and Model Successfully Saved
加载保存的模型
为了在将来的某一天在相同或不同的环境中加载已保存的模型，我们将使用 PyCaret 的load_model()函数，然后轻松地将已保存的模型应用于新的未知数据进行预测。
saved_final_lightgbm = load_model(model_dir + model_name)Transformation Pipeline and Model Successfully Loaded
一旦模型加载到环境中，您就可以使用相同的predict_model()函数简单地使用它来预测任何新数据。下面我们应用了加载模型来预测我们在上面第 13 节中使用的相同的data_unseen。
new_prediction = predict_model(saved_final_lightgbm, data=data_unseen)new_prediction.head()
注意unseen_predictions和new_prediction的结果是相同的。
在 Microsoft Azure 上部署训练模型
微软 Azure 是最大的云提供商之一，在云即服务上提供机器学习。在我之前的文章中，我已经介绍了将模型部署到 Google 云平台。图书馆已经支持亚马逊网络服务部署。
一旦我们有了训练好的模型，下一个任务就是部署它来为客户服务。有各种可用的部署选项，但是在本节中，我将重点关注在 Microsoft Azure 平台上部署它。我尝试使用类似于pycaret库中的方法在 AWS 上部署。
先决条件
在 Azure cloud 上部署 ml 模型的先决条件是
- 熟悉微软 Azure 平台
- Microsoft Azure 帐户
- 基本了解存储容器及其命令行工具
- 使用 pycaret 的最终训练模型
import os, uuid
from azure.storage.blob import BlobServiceClient, BlobClient, ContainerClient
AZURE _ STORAGE _ CONNECTION _ STRING是连接到 AZURE 存储 blob 的身份验证字符串。您可以在您的环境中设置该字符串，并且可以随时使用。另一种选择是，只要需要连接，就输入字符串。
微软 Azure 存储容器相当于谷歌云存储桶
# add the connection string in environment
# Linux
! export AZURE_STORAGE_CONNECTION_STRING="<yourconnectionstring>"
# After you add the environment variable, restart any running programs that will need to read the environment variable. For example, restart your development environment or editor before continuing.
# Retrieve the connection string for use with the application. The storage
# connection string is stored in an environment variable on the machine
# running the application called AZURE_STORAGE_CONNECTION_STRING. If the environment variable is
# created after the application is launched in a console or with Visual Studio,
# the shell or application needs to be closed and reloaded to take the
# environment variable into account.
connect_str_env = os.getenv('AZURE_STORAGE_CONNECTION_STRING')
您可以使用下面的表单在 google colab 中输入您的连接字符串
## Enter connection string when running in google colab
connect_str = 'Enter Connection String Here' #@param {type:"string"}
print(connect_str)
若要创建到 blob 容器的连接，请使用下面的命令创建服务客户端对象。
# Create the BlobServiceClient object which will be used to create a container client
blob_service_client = BlobServiceClient.from_connection_string(connect_str)
我写了/收集了下面的实用程序来从 blobs 上传/下载数据。
def create_container(container_name):
# Create the container
container_client = blob_service_client.create_container(container_name)
return container_client
def upload_blob(container_name, source_file_name, destination_blob_name):
# Create a blob client using the local file name as the name for the blob
blob_client = blob_service_client.get_blob_client(container=container_name, blob=destination_blob_name)
print("\nUploading to Azure Storage as blob:\n\t" + source_file_name)
# Upload the created file
with open(source_file_name, "rb") as data:
blob_client.upload_blob(data)
def download_blob(container_name, source_blob_name, destination_file_name):
# Download the blob to a local file
print("\nDownloading blob to \n\t" + destination_file_name)
# Create a blob client using the local file name as the name for the blob
blob_client = blob_service_client.get_blob_client(container=container_name, blob=source_blob_name)
if destination_file_name is not None:
with open(destination_file_name, "wb") as download_file:
download_file.write(blob_client.download_blob().readall())
print(
"Blob {} downloaded to {}.".format(
source_blob_name, destination_file_name
)
)
将模型保存到 Azure 容器
使用上面的工具，使用下面的代码将模型上传到 Azure-container。在上传之前，我们创建容器，如果以前没有这样做。
也可以使用 GUI 创建容器。
# Create a unique name for the container
container_name = "pycaret" + str(uuid.uuid4())
container_client = create_container(container_name)
# Save Model Local/google drive and upload to Azure
model_name_azure = 'lightgbm-reg101-azure'
save_model(final_lightgbm, model_name= model_dir + model_name_azure, verbose=False)
model_src = model_dir + model_name_azure +'.pkl'
model_dst = str(model_name)+'.pkl'upload_blob(CLOUD_PROJECT, bucket_name, model_src, model_dst)File /content/drive/My Drive/azure_deploy_model/lightgbm-reg101-azure.pkl uploaded to Final_lightgbm_model.pkl.
从 Azure 下载预测模型
一旦你的模型上传到 Azure，你可以随时下载来执行预测。我遵循一个简单的流程，首先在本地或 google drive 中下载模型，然后使用load_model函数加载模型。
print("\nListing blobs...")
# List the blobs in the container
blob_list = container_client.list_blobs()
for blob in blob_list:
print("\t" + blob.name)
outfile_name = model_dir + 'lightgbm-reg101-azure-downloaded'
model_azure_src = str(model_name)+'.pkl'
download_blob(container_name, model_azure_src, outfile_name + '.pkl')
使用最近从 Azure 下载的模型来执行预测。
# Loading the model for predictions
azure_final_lightgbm = load_model(outfile_name)Transformation Pipeline and Model Successfully Loaded# Predictions from deployed model
new_prediction_azure = predict_model(azure_final_lightgbm, data=data_unseen)new_prediction_azure.head()
谷歌 Colab 笔记本
按照下面的谷歌合作笔记本来复制和实践这个指南。
结论
在本教程中，我们学习了如何在使用pycaret库进行培训时将模型部署到 Microsoft Azure。
主要目标是使用[pycaret](https://github.com/pycaret/pycaret)的内置实用程序从 Azure 部署和加载模型。以下是一些亮点
- 安装 google drive 以保存模型
- 用
pycaret训练回归模型 - 保存和加载经过培训/最终确定的模型 Microsoft Azure
- 将经过培训/最终确定的模型部署到微软的 Azure 容器
- 使用 Azure 部署的模型来执行预测
使用 Amazon SageMaker 部署 Fastai —基于变压器的 NLP 模型，并使用 AWS API 网关和 Lambda 函数创建 API
Fastai-Transformers 模型部署在 AWS SageMaker 上，并作为 AWS API 提供服务。
目录
- 介绍
- 第 1 部分—导出模型并重新加载它
- 第 2 部分——使用 Amazon SageMaker 进行部署
- 第 3 部分——使用 Amazon Lambda 和 Amazon API Gateway 创建模型 API
- 结论
- 参考
1.介绍
T 何变形金刚库由抱脸创建。这个库以前被称为 pytorch-transformers 或 pytorch-pretrained-bert，它汇集了 40 多个最先进的预训练 NLP 模型(bert、GPT-2、罗伯塔、CTRL……)。这是一个自以为是的库，专为寻求使用/研究/扩展大规模变压器模型的 NLP 研究人员而建。
该实现提供了有趣的附加工具，如 tokenizer、optimizer 或 scheduler。它可以是自给自足的，但是将它并入 fastai 库提供了与强大的 fastai 工具兼容的更简单的实现，例如区分学习率、逐步解冻或倾斜三角形学习率。这里的重点是轻松获得最先进的结果，并“让 NLP 再次变得不酷”。
我假设您已经实现了您的模型，我不打算讨论这一部分，本文将只讨论使用 AWS 服务的部署部分，但是如果您需要查看实现，请查看 Kaggle 上的这个内核。
2.第 1 部分—导出模型并重新加载它
2.1。 导出模型
首先，我们需要使用 fastai 库的学习模块将我们的模型导出为 PKL 文件:
2.2.加载模型:
当使用自定义的 transformers 模型(如 Bert)时，您需要重新定义自定义模型的体系结构，以便在加载它时，load_learner()函数会查找特定的函数以用于新的预测。
在加载模型之前，我们需要重新定义我们在培训中使用的定制 transformer 模型。
然后我们可以加载我们的模型并进行预测:
3.第 2 部分——使用 Amazon SageMaker 进行部署
用亚马逊自己的话说:
亚马逊 SageMaker 为每一个开发者和数据科学家提供了快速构建、训练和部署机器学习模型的能力。Amazon SageMaker 是一个完全托管的服务，涵盖了整个机器学习工作流，以标记和准备您的数据，选择算法，训练模型，调整和优化它以进行部署，进行预测，并采取行动。您的模型以更少的工作量和更低的成本更快地投入生产。
SageMaker 提供了一个框架来训练和部署您的模型。一切都在 Docker 容器中运行。
AWS SageMaker 的用户界面
因为我们将使用 Amazon SageMaker Python SDK，所以我们需要一个笔记本实例来运行我们的代码。
3.1。 使用 SageMaker Python SDK 部署模型
来自 SageMaker Python SDK 文档:
Amazon SageMaker Python SDK 是一个开源库，用于在 Amazon SageMaker 上训练和部署机器学习模型。
通过 SDK，你可以使用流行的深度学习框架、亚马逊提供的算法或你自己的内置于 SageMaker 兼容的 Docker 图像中的算法来训练和部署模型。
3.1.1。 准备环境:
部署的总体架构如下:
部署架构
将您的模型(PKL 文件)上传到笔记本实例后，我们需要将它压缩，这样我们就可以将它上传到 S3。
然后，我们可以将它上传到 S3 存储，如下所示:
现在我们已经准备好将我们的模型部署到 SageMaker 模型托管服务中。我们将使用 SageMaker Python SDK 和 Amazon SageMaker 开源 PyTorch 容器，因为该容器支持 fast.ai 库。使用一个预定义的 Amazon SageMaker 容器可以很容易地编写一个脚本，然后在 Amazon SageMaker 中运行它。
为了在 SageMaker 中服务模型，我们需要一个实现 4 个方法的脚本: model_fn，input_fn，predict_fn & output_fn 。
- model_fn 方法需要从磁盘上保存的权重中加载 PyTorch 模型。
- input_fn 方法需要将 invoke 请求体反序列化为我们可以对其执行预测的对象。
- predict_fn 方法接受反序列化的请求对象，并对加载的模型执行推理。
- output_fn 方法获取预测结果，并根据响应内容类型将其序列化。
方法 input_fn 和 output_fn 是可选的，如果省略，SageMaker 将假定输入和输出对象是 NPY 格式类型，内容类型为 application/x-npy。
这是 serve.py 脚本:
另一件事是将这个脚本放在一个文件夹中，并将其命名为 my_src，我们将添加一个需求文本文件；来强制 SageMaker 安装所需的库，比如 Fastai。
我的 requirements.txt 文件仅包含以下内容:
fastai==1.0.52
变压器
你可以在 SageMaker Python SDK 文档这里读到更多关于这个的内容。
3.1.2。 部署型号:
首先，我们需要创建一个 RealTimePredictor 类来接受 JSON/application item 作为输入和输出 JSON。默认行为是接受 NumPy 数组。
我们需要得到 IAM 角色 ARN 给 SageMaker 权限，以读取我们的模型从 S3 人工制品。
我们将把我们的模型部署到实例类型 ml.p2.xlarge。我们将传入我们的服务脚本的名称，例如 serve.py。我们还将传入我们之前上传的模型的 S3 路径。
SageMaker 需要一段时间来为推断准备好端点。
3.2.3。 使用 Boto3 调用端点:
Boto 是 Python 的 Amazon Web Services (AWS) SDK。它使 Python 开发人员能够创建、配置和管理 AWS 服务，如 EC2 和 S3。Boto 提供了一个易于使用的、面向对象的 API，以及对 AWS 服务的底层访问。
4.第 3 部分——使用 Amazon Lambda 和 Amazon API Gateway 创建模型 API
我们将使用 API Gateway 和 AWS Lambda 调用 Amazon SageMaker 部署的模型端点。
下图显示了如何使用无服务器架构调用部署的模型。从客户端开始，客户端脚本调用 Amazon API Gateway API 动作并传递参数值。API 网关是向客户端提供 API 的层。此外，它还密封了后端，这样 AWS Lambda 就可以在一个受保护的私有网络中运行。API Gateway 将参数值传递给 Lambda 函数。Lambda 函数解析该值并将其发送到 SageMaker 模型端点。该模型执行预测，并将预测值返回给 AWS Lambda。Lambda 函数解析返回值并将其发送回 API Gateway。API 网关用该值响应客户端。
部署架构
**4.1。**创建亚马逊 Lambda 函数
AWS Lambda 是一个事件驱动的无服务器计算平台，由亚马逊提供，作为亚马逊网络服务的一部分。它是一种计算服务，运行代码以响应事件，并自动管理该代码所需的计算资源。
为了创建一个函数，我们指定它的名称和运行时环境(在我们的例子中是 Python 3):
然后，我们使用自定义函数调用使用 Boto3 库的端点，如下所示:
4.2。 创建亚马逊 Web API 网关实例:
Amazon API Gateway 是一个完全托管的服务，使开发人员可以轻松地创建、发布、维护、监控和保护任何规模的 API。
我们创建一个 API 并将其关联到 Lambda 函数作为一个集成，如下所示:
然后我们需要确定 API 的路由，我们将只使用一个路由“/classify”和“POST”作为我们的请求方法。
4.3。 测试你的亚马逊 API
现在我们有了 Lambda 函数、API 网关和测试数据，让我们使用 Postman 来测试它，Postman 是一个用于测试 web 服务的 HTTP 客户端。
当我们部署您的 API 网关时，它提供了如下所示的调用 URL:
https://{restapi_id}。执行-api。{ region } . Amazon AWS . com/{ stage _ name }/{ resource _ name }
在 Postman 中，我们放置调用 URL，并选择 POST 作为请求方法。在 Body 选项卡中，我们放置要分类的文本，如下图所示。
然后我们发送我们的请求，它将返回 JSON item 作为包含模型预测的响应。
使用 postman 测试 API
我们还可以使用 python 中的请求库，如下所示:
结论
就是这样。您已经创建了一个由 Amazon SageMaker 部署和托管的模型端点。然后创建了调用端点的无服务器组件(一个 API 网关和一个 Lambda 函数)。现在你知道如何使用无服务器技术调用亚马逊 SageMaker 托管的机器学习模型端点了。
参考
这是使用亚马逊 SageMaker 的程序员实用深度学习 fast.ai 课程 v4 的快速入门指南…
course.fast.ai](https://course.fast.ai/start_sagemaker.html) [## 使用 Amazon API Gateway 和 AWS Lambda | Amazon Web 调用 Amazon SageMaker 模型端点…
在 AWS 机器学习研讨会上，客户经常会问，“在我部署了一个端点之后，我该从那里去哪里？”你可以…
aws.amazon.com](https://aws.amazon.com/blogs/machine-learning/call-an-amazon-sagemaker-model-endpoint-using-amazon-api-gateway-and-aws-lambda/) [## 步骤 6.1:将模型部署到 SageMaker 托管服务
要在 SageMaker 托管服务中部署模型，您可以使用 Amazon SageMaker Python SDK 或 AWS SDK
docs.aws.amazon.com](https://docs.aws.amazon.com/sagemaker/latest/dg/ex1-deploy-model.html)
在 Google Kubernetes 引擎上部署使用 Streamlit 和 PyCaret 构建的机器学习应用程序
在 Google Kubernetes 引擎上封装和部署 Streamlit 应用程序的循序渐进的初学者指南
在 Google Kubernetes 引擎上封装和部署 streamlit 应用程序的循序渐进的初学者指南
概述
在我们关于在云中部署机器学习管道的上一篇文章中，我们展示了如何在 PyCaret 中开发机器学习管道，并在 Heroku PaaS 上部署一个训练有素的模型，作为使用 Streamlit 开源框架构建的 web 应用程序。如果你以前没有听说过 PyCaret，你可以阅读这个公告来了解更多。
在本教程中，我们将使用相同的机器学习管道和 Streamlit 应用程序，并演示如何将它们封装和部署到 Google Kubernetes 引擎上。
在本教程结束时，您将能够在 Google Kubernetes 引擎上构建和托管一个全功能的容器化 web 应用程序。该 web 应用程序可用于使用经过训练的机器学习模型生成在线预测(逐个)和批量预测(通过上传 csv 文件)。最终的应用程序如下所示:
最终应用程序(第 1 页，共 2 页)
👉您将在本教程中学到什么
- 什么是容器，什么是 Docker，什么是 Kubernetes，什么是 Google Kubernetes 引擎？
- 建立一个 Docker 图像，并上传到谷歌容器注册(GCR)。
- 在 GCP 上创建一个集群，并以 web 服务的形式部署一个机器学习应用。
- 看看一个使用训练有素的机器学习管道来实时预测新数据点的 web 应用程序。
过去，我们讨论过使用 docker 的容器化以及在 Azure、GCP 和 AWS 等云平台上的部署。如果您有兴趣了解更多相关信息，可以阅读以下教程:
- 使用 PyCaret 和 Streamlit 构建和部署机器学习 web 应用
- 在 AWS Fargate 上部署机器学习管道
- 在 Google Kubernetes 引擎上部署机器学习管道
- 在 AWS Web 服务上部署机器学习管道
- 在 Heroku PaaS 上构建和部署您的第一个机器学习 web 应用
💻本教程的工具箱
PyCaret
PyCaret 是 Python 中的一个开源、低代码机器学习库，用于训练和部署机器学习管道和模型到生产中。PyCaret 可以使用 pip 轻松安装。
pip install **pycaret**
细流
Streamlit 是一个开源的 Python 库，可以轻松地为机器学习和数据科学构建漂亮的定制 web 应用。使用 pip 可以轻松安装 Streamlit。
pip install **streamlit**
谷歌云平台
由谷歌提供的谷歌云平台(GCP)是一套云计算服务，运行在谷歌内部用于其最终用户产品(如谷歌搜索、Gmail 和 YouTube)的相同基础设施上。如果你没有 GCP 的账户，你可以在这里注册。如果你是第一次注册，你将获得 1 年的免费学分。
让我们开始吧。
在我们进入 Kubernetes 之前，让我们了解一下什么是容器，为什么我们需要一个容器？
https://www.freepik.com/free-photos-vectors/cargo-ship
您是否遇到过这样的问题:您的代码在您的计算机上运行得很好，但是当一个朋友试图运行完全相同的代码时，却无法运行？如果你的朋友重复完全相同的步骤，他或她应该得到相同的结果，对不对？一个词的答案是 **环境。**你朋友的环境和你不一样。
环境包括什么？Python 等编程语言以及所有库和依赖项，以及构建和测试应用程序时使用的确切版本。
如果我们可以创建一个可以转移到其他机器上的环境(例如:你朋友的电脑或者谷歌云平台这样的云服务提供商)，我们就可以在任何地方重现结果。因此，容器 是一种将应用程序及其所有依赖项打包的软件，因此应用程序可以从一个计算环境可靠地运行到另一个计算环境。
那 Docker 是什么？
Docker 是一家提供允许用户构建、运行和管理容器的软件(也叫 Docker)的公司。虽然 Docker 的集装箱是最常见的，但还有其他不太出名的替代品，如 LXD 和 LXC 也提供集装箱解决方案。**
现在您已经具体了解了容器和 docker，让我们了解 Kubernetes 是什么。
什么是 Kubernetes？
Kubernetes 是 Google 在 2014 年开发的一个强大的开源系统，用于管理容器化的应用程序。简而言之，Kubernetes 是一个跨机器集群运行和协调容器化应用的系统。这是一个旨在完全管理容器化应用程序生命周期的平台。
特征
**✔️ **负载平衡:自动在集装箱之间分配负载。
**✔️ **缩放:当需求发生变化时，如高峰时间、周末和节假日，通过添加或移除容器来自动放大或缩小。
**✔️ **存储:保持存储与应用程序的多个实例一致。
✔️ 自我修复自动重启失败的容器，并杀死不响应用户定义的健康检查的容器。
✔️ 自动化部署你可以自动化 Kubernetes 为你的部署创建新的容器，移除现有的容器，并把它们的所有资源都移植到新的容器中。
有 Docker 为什么还要 Kubernetes？
想象一下这样一个场景，您必须在多台机器上运行多个 docker 容器来支持一个企业级 ML 应用程序，无论白天还是晚上都有不同的工作负载。虽然听起来很简单，但手动完成的工作量很大。
您需要在正确的时间启动正确的容器，弄清楚它们如何相互通信，处理存储问题，以及处理失败的容器或硬件。这就是 Kubernetes 正在解决的问题，它允许大量的容器和谐地一起工作，减少了操作负担。
什么是 Google Kubernetes 引擎？
Google Kubernetes 引擎是 Google 开源的 Kubernetes 在 Google 云平台上的一个实现。简单！
其他受欢迎的 GKE 替代品是亚马逊 ECS 和 T2 微软 Azure Kubernetes 服务。
最后一次，你明白吗？
- ****容器是一种打包应用程序及其所有依赖项的软件，因此应用程序可以从一个计算环境可靠地运行到另一个计算环境。
- Docker 是一个用于构建和管理容器的软件。
- Kubernetes 是一个开源系统，用于在集群环境中管理容器化的应用程序。
- ****Google Kubernetes 引擎是开源的 Kubernetes 框架在 Google 云平台上的实现。
在本教程中，我们将使用谷歌 Kubernetes 引擎。为了跟进，你必须有一个谷歌云平台账户。点击此处免费报名。
设置业务环境
一家保险公司希望通过使用住院时的人口统计和基本患者健康风险指标来更好地预测患者费用，从而改善其现金流预测。
( 数据来源 )
目标
使用训练有素的机器学习模型和管道，构建支持在线(逐个)以及批量预测的 web 应用程序。
任务
- 使用 PyCaret 训练、验证和开发机器学习管道。
- 构建一个前端 web 应用程序，具有两个功能:(一)在线预测和(二)批量预测。
- 创建 Dockerfile 文件
- 在 Google Kubernetes 引擎上部署 web 应用程序。一旦部署，它将成为公开可用的，并可以通过网址访问。
👉任务 1 —模型训练和验证
培训和模型验证是在集成开发环境(IDE)或笔记本电脑中进行的，可以在本地机器上进行，也可以在云上进行。如果您以前没有使用过 PyCaret，单击此处了解更多关于 PyCaret 的信息，或者在我们的网站上查看入门教程。
在本教程中，我们进行了两个实验。第一个实验是使用 PyCaret 中的默认预处理设置进行的。第二个实验具有一些额外的预处理任务，例如缩放和归一化、自动特征工程和将宁滨连续数据分成区间**。参见第二个实验的设置代码:**
****# Experiment No. 2**from **pycaret.regression** import *****r2 = **setup**(data, target = 'charges', session_id = 123,
normalize = True,
polynomial_features = True, trigonometry_features = True,
feature_interaction=True,
bin_numeric_features= ['age', 'bmi'])**
两个实验的信息网格比较
神奇的事情只发生在几行代码中。请注意，在实验 2** 中，转换后的数据集有 62 个用于训练的特征，这些特征仅来自原始数据集中的 6 个特征。所有的新特性都是 PyCaret 中的转换和自动特性工程的结果。**
转换后数据集中的列
PyCaret 中模型定型的示例代码:
**# Model Training and Validation
lr = **create_model**('lr')**
线性回归模型的 10 倍交叉验证
注意转换和自动特征工程的影响。R2 不费吹灰之力就增加了 10%。我们可以比较两个实验的线性回归模型的残差图**，并观察转换和特征工程对模型的异方差的影响。**
**# plot residuals of trained model **plot_model**(lr, plot = 'residuals')**
线性回归模型的残差图
机器学习是一个迭代的过程。迭代的次数和其中使用的技术取决于任务的关键程度，以及预测错误时的影响。在医院的 ICU 中实时预测患者结果的机器学习模型的严重性和影响远远超过为预测客户流失而建立的模型。
在本教程中，我们只执行了两次迭代，第二次实验中的线性回归模型将用于部署。然而，在这个阶段，模型仍然只是笔记本/ IDE 中的一个对象。要将其保存为可以传输到其他应用程序并由其他应用程序使用的文件，请执行以下代码:
**# save transformation pipeline and model
**save_model**(lr, model_name = 'deployment_28042020')**
当您在 PyCaret 中保存一个模型时，基于在 setup() 函数中定义的配置的整个转换管道被创建。所有的相互依赖都是自动编排的。查看存储在“deployment_28042020”变量中的管道和模型:
使用 PyCaret 创建的管道
我们已经完成了培训和模型选择。最终的机器学习管道和线性回归模型现在保存为 pickle 文件(deployment_28042020.pkl ),该文件将在 web 应用程序中用于生成对新数据点的预测。
👉任务 2 —构建前端 web 应用程序
现在，我们的机器学习管道和模型已经准备好开始构建一个前端 web 应用程序，它可以在新的数据点上生成预测。该应用程序将通过 csv 文件上传支持“在线”以及“批量”预测。让我们将应用程序代码分成三个主要部分:
页眉/布局
该部分导入库，加载训练模型，并创建一个基本布局，顶部有一个徽标，一个 jpg 图像，边栏上有一个下拉菜单，用于在“在线”和“批量”预测之间切换。
app.py —代码片段第 1 部分
在线预测
本节处理初始 app 功能，在线逐一预测。我们使用 streamlit 小部件，如数字输入、文本输入、下拉菜单和复选框来收集用于训练模型的数据点，如年龄、性别、身体质量指数、儿童、吸烟者、地区。
app.py —代码片段第 2 部分
批量预测
批量预测是该应用的第二层功能。streamlit 中的 file_uploader 小部件用于上传 csv 文件，然后从 PyCaret 调用原生的 predict_model() 函数来生成预测，使用 streamlit 的 write()函数显示这些预测。
app.py —代码片段第 3 部分
如果您还记得上面的任务 1，我们最终确定了一个线性回归模型，该模型根据从 6 个原始特征中提取的 62 个特征进行了训练。web 应用程序的前端有一个输入表单，只收集六个特征，即年龄、性别、bmi、儿童、吸烟者、地区。
我们如何将新数据点的这 6 个特征转换成用于训练模型的 62 个特征？我们不需要担心这一部分，因为 PyCaret 通过编排转换管道自动处理这一部分。当您在使用 PyCaret 定型的模型上调用 predict 函数时，在从定型模型生成预测之前，会自动(按顺序)应用所有转换。
在 Heroku 上发布应用程序之前的最后一步是在本地测试 web 应用程序。打开 Anaconda 提示符，导航到您的项目文件夹并执行以下代码:
****streamlit** run app.py**
简化应用测试—在线预测
简化应用测试—批量预测
现在我们有了一个全功能的 web 应用程序，我们可以开始在 Google Kubernetes 引擎上封装和部署应用程序了。
👉任务 3 —创建 Dockerfile 文件
为了将我们的应用程序进行容器化部署，我们需要一个 docker 映像，它在运行时成为一个容器。使用 docker 文件创建 docker 映像。Dockerfile 只是一个包含一组指令的文件。该项目的 docker 文件如下所示:
Dockerfile 文件
这个 Dockerfile 文件的最后一部分(从第 23 行开始)是特定于 Streamlit 的，通常不需要。Dockerfile 区分大小写，必须与其他项目文件位于项目文件夹中。
👉任务 4 —在 GKE 部署洗钱渠道:
如果你想继续，你必须从 GitHub 中派生出这个库。
https://github.com/pycaret/pycaret-streamlit-google
按照以下简单的 10 个步骤在 GKE 集群上部署应用程序。
步骤 1 —在 GCP 控制台中创建新项目
登录您的 GCP 控制台，然后转到“管理资源”
谷歌云平台控制台→管理资源
点击创建新项目****
Google 云平台控制台→管理资源→创建新项目
步骤 2 —导入项目代码
点击控制台窗口右上角的激活云壳按钮，打开云壳。
谷歌云平台(项目信息页面)
在 Cloud Shell 中执行以下代码来克隆本教程中使用的 GitHub 存储库。
**git clone [https://github.com/pycaret/pycaret-streamlit-google.git](https://github.com/pycaret/pycaret-streamlit-google.git)**
步骤 3-设置项目 ID 环境变量
执行以下代码来设置 PROJECT_ID 环境变量。
**export PROJECT_ID=**pycaret-streamlit-gcp****
pycaret-streamlit-gcp 是我们在上面的步骤 1 中选择的项目的名称。
步骤 4 —构建 docker 映像
通过执行以下代码，构建应用程序的 docker 映像并标记它以便上传:
**docker build -t gcr.io/${PROJECT_ID}/insurance-streamlit:v1 .**
docker 构建成功时返回的消息
您可以通过运行以下代码来检查可用的图像:
****docker** images**
步骤 5 —上传容器图像
- 认证到容器注册表(您只需要运行一次):
**gcloud auth configure-docker**
2.执行以下代码将 docker 图像上传到 Google 容器注册表:
**docker push gcr.io/${PROJECT_ID}/insurance-streamlit:v1**
步骤 6 —创建集群
现在容器已经上传，您需要一个集群来运行容器。一个集群由一个运行 Kubernetes 的计算引擎 VM 实例池组成。
- 为 gcloud 工具设置项目 ID 和计算引擎区域选项:
**gcloud config set project $PROJECT_ID
gcloud config set compute/zone **us-central1****
2.通过执行以下代码创建一个集群:
**gcloud container clusters create **streamlit-cluster** --num-nodes=2**
谷歌云平台→ Kubernetes 引擎→集群
步骤 7 —部署应用程序
要在 GKE 集群上部署和管理应用程序，您必须与 Kubernetes 集群管理系统通信。执行以下命令来部署应用程序:
**kubectl create deployment insurance-streamlit --image=gcr.io/${PROJECT_ID}/insurance-streamlit:v1**
步骤 8 —将您的应用程序公开到互联网上
默认情况下，您在 GKE 上运行的容器不能从互联网上访问，因为它们没有外部 IP 地址。执行以下代码，将应用程序公开给 internet:
**kubectl expose deployment insurance-streamlit --type=LoadBalancer --port 80 --target-port **8501****
步骤 9 —检查服务
执行下面的代码来获取服务的状态。 EXTERNAL-IP 是您可以在浏览器中查看已发布应用的网址。
**kubectl get service**
第 10 步—在网址上查看应用程序的运行情况
发布于https://34.70.49.248的应用程序—第 1 页
发布于https://34.70.49.248的应用程序—第 2 页
****注意:在这篇文章发表时，该应用程序将从公共地址中删除，以限制资源消耗。
PyCaret 2.0.0 来了！
我们收到了来自社区的大力支持和反馈。我们正在积极改进 PyCaret，并准备我们的下一个版本。 PyCaret 2.0.0 会更大更好。如果您想分享您的反馈并帮助我们进一步改进，您可以在网站上填写此表格或者在我们的 GitHub 或 LinkedIn 页面上发表评论。
关注我们的 LinkedIn 并订阅我们的 YouTube 频道，了解更多关于 PyCaret 的信息。
想了解某个特定模块？
从第一个版本 1.0.0 开始，PyCaret 有以下模块可供使用。点击下面的链接，查看 Python 中的文档和工作示例。
另请参见:
笔记本中的 PyCaret 入门教程:
你愿意投稿吗？
PyCaret 是一个开源项目。欢迎每个人都来投稿。如果您愿意投稿，请随意处理未决问题。dev-1.0.1 分支上的单元测试接受拉请求。
如果你喜欢 PyCaret，请给我们 GitHub 回购的⭐️。
**中:【https://medium.com/@moez_62905/ **
领英:https://www.linkedin.com/in/profile-moez/
推特:https://twitter.com/moezpycaretorg1
使用 Streamlit 和 Polyaxon 将机器学习应用程序部署到 Kubernetes
使用 Polyaxon 在 Azure Kubernetes(AKS) 上训练、分析和部署容器化 Streamlit 机器学习应用的分步指南。
本指南的学习目标
- 集装箱、 Kubernetes 、 Streamlit 和 Polyaxon 简介。
- 创建一个 Kubernetes 集群并使用舵部署 Polyaxon 。
- 如何在 Kubernetes 集群上运行的 Jupyter 笔记本上探索数据集。
- 如何在 Kubernetes 上使用 Polyaxon 训练一个机器学习模型的多个版本。
- 如何保存一个机器学习模型？
- 如何使用 Polyaxon UI 分析模型？
- 如何使用 Streamlit 通过用户界面展示模型并进行新的预测。
本指南所需的工具
什么是容器？
容器是一个标准的软件单元，它将代码及其所有依赖项打包，以便应用程序能够快速可靠地从一个计算环境运行到另一个计算环境。 Docker 是一个工具，旨在通过使用容器来更容易地创建、部署和运行应用程序。
在我们的指南中，我们将使用容器来打包我们的代码和依赖项，并轻松地将它们部署在 Kubernetes 上。
什么是 Kubernetes？
Kubernetes 是一个强大的开源分布式系统，用于管理容器化的应用程序。简而言之，Kubernetes 是一个在机器集群上运行和编排容器化应用的系统。这是一个旨在完全管理容器化应用程序生命周期的平台。
我为什么要用 Kubernetes？
- 负载平衡 : 自动在集装箱之间分配负载。
- **缩放:**当需求变化时，如高峰时间、周末和节假日，通过添加或移除容器来自动放大或缩小。
- **存储:**保持存储与应用程序的多个实例一致。
- 自我修复自动重启失败的容器，并杀死不响应用户定义的健康检查的容器。
- 自动化部署您可以自动化 Kubernetes 为您的部署创建新的容器，删除现有的容器，并将它们的所有资源应用到新的容器中。
什么是 Streamlit？
Streamlit 是一个开源框架，用来创建一个交互式的、漂亮的可视化应用。全部用 python！
Streamlit 提供了许多有用的特性，对数据驱动项目的可视化非常有帮助。
使用 Streamlit 的 Face-GAN 浏览器示例
这个 Streamlit 应用程序使用邵伯关的 TL-GAN 演示了 NVIDIA 名人脸 GAN 模型。
为什么我应该使用 Streamlit？
- 创建交互式用户界面的简单易行的方法
- 不需要开发经验
- 在数据驱动的项目中使用不同的功能很有趣:)
- 全面的文档
什么是 Polyaxon？
Polyaxon 是一个开源的云本机机器学习平台，它提供了简单的接口来训练、监控和管理模型。
Polyaxon 运行在 Kubernetes 之上，允许扩展和缩减集群的资源，并提供工具来自动化实验过程，同时跟踪关于模型、配置、参数和代码的信息。
我为什么要用 Polyaxon？
- 自动跟踪关键模型度量、超参数、可视化、工件和资源，以及版本控制代码和数据。
- 通过 CLI、dashboard、SDK 或 REST API 调度作业和实验，最大限度地提高集群的利用率。
- 使用优化算法有效地运行并行实验，并找到最佳模型。
- 可视化、搜索和比较实验结果、超参数、训练数据和源代码版本，以便您可以快速分析哪些有效，哪些无效。
- 持续开发、验证、交付和监控模型，以创造竞争优势。
- 根据需要扩展您的资源，并在任何平台(AWS、Microsoft Azure、Google 云平台和本地硬件)上运行作业和实验。
什么是头盔？
Helm 是 Kubernetes 的包管理器，它允许我们部署和管理像 Polyaxon 这样的云原生项目的生命周期。
蓝色库伯内特服务
在本教程中，我们将使用 Azure Kubernetes 服务(AKS) ，这是 Azure 上的一个完全托管的 Kubernetes 服务。如果您没有 Azure 帐户，您可以在此注册一个免费帐户。
在以后的帖子中，我们将提供在谷歌云平台 (GKE) 、 AWS (EKS)和一个带有 Minikube 的本地集群上运行本指南的类似说明。
设置工作空间
本教程的目的是获得在 Kubernetes 上运行机器学习实验和部署的实践经验。让我们从创建工作空间开始。
步骤 1 —使用 AKS 部署 Kubernetes 集群
让我们在 AKS 上创建一个简单的 Kubernetes 集群，它只有一个节点:
az aks create --resource-group myResourceGroup --name streamlit-polyaxon --node-count 1 --enable-addons monitoring --generate-ssh-keys
要确保您在正确的集群上，您可以执行以下命令
az aks get-credentials --resource-group myResourceGroup --name streamlit-polyaxon
步骤 2 —安装头盔
在您的本地机器上安装 Helm 以便能够管理 Polyaxon 以及您可能想要在 Kubernetes 上运行的其他云原生项目。
curl -fsSL -o get_helm.sh [https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3](https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3)chmod 700 get_helm.sh./get_helm.sh
第 3 步-添加多轴图表到头盔
helm repo add polyaxon https://charts.polyaxon.com
步骤 4—安装 Polyaxon CLI
pip install -U polyaxon
步骤 5—将 Polyaxon 部署到 Kubernetes
polyaxon admin deploy
步骤 6—等待部署进入就绪状态
kubectl get deployment -n polyaxon -w
这大约需要 3 分钟:
NAME READY UP-TO-DATE AVAILABLE AGE
polyaxon-polyaxon-api 1/1 1 1 3m17s
polyaxon-polyaxon-gateway 1/1 1 1 3m17s
polyaxon-polyaxon-operator 1/1 1 1 3m17s
polyaxon-polyaxon-streams 1/1 1 1 3m17s
步骤 7-公开 Polyaxon API 和 UI
Polyaxon 提供了一个简单的命令，以安全的方式在本地主机上公开仪表板和 API:
polyaxon port-forward
步骤 8-在 Polyaxon 上创建一个项目
在不同于用于显示仪表板的终端会话中，运行:
polyaxon project create --name=streamlit-app
您应该看到:
Project `streamlit-app` was created successfully.
You can view this project on Polyaxon UI: [http://localhost:8000/ui/root/streamlit-app/](http://localhost:8000/ui/root/streamlit-app/)
Polyaxon 的 Streamlit 项目
现在我们可以进入下一部分:训练和分析模型。
训练机器学习模型
在本教程中，我们将训练一个模型来根据其特征对鸢尾花进行分类。
虹膜特征:萼片，花瓣，长度和宽度
探索数据集
我们将首先在 Kubernetes 集群上运行的笔记本会话中探索 iris 数据集。
让我们启动一个新的笔记本会话，并等待它进入运行状态:
polyaxon run --hub jupyterlab -w
Polyaxon 提供了一系列高效的组件，称为 hub，并允许使用一个命令启动一个笔记本会话。在后台，Polyaxon 将创建一个 Kubernetes 部署和一个 headless 服务，并将使用 Polyaxon 的 API 公开该服务。更多细节请查看 Polyaxon 的开源中心。
几秒钟后，笔记本电脑将开始运行。
注意:如果您停止了上一个命令，您总是可以通过执行以下命令来获取上一个(缓存的)正在运行的操作:
polyaxon 运营服务
运行在 Polyaxon 上的 Jupyter 实验室
让我们创建一个新笔记本，并从检查数据集的功能开始:
探索数据集
执行的命令:
from sklearn.datasets import load_irisiris= load_iris()print(iris.feature_names)
print(iris.target_names)
print(iris.data.shape)
print(iris.target.shape)
print(iris.target)
数据集是关于鸢尾花的种类:
鸢尾花数据集
鸢尾花属性
探索模型
scikit-learn 提供了不同类别的算法，在本教程的范围内，我们将使用 最近邻 s 算法。
在我们创建一个健壮的脚本之前，我们将在笔记本会议中尝试一个简单的模型:
探索模型
执行的命令:
from sklearn.neighbors import KNeighborsClassifierX = iris.data
y = iris.targetclassifier = KNeighborsClassifier(n_neighbors=3)# Fit the model
classifier.fit(X, y)# Predict new data
new_data = [[3, 2, 5.3, 2.9]]
print(classifier.predict(new_data))
# Show the results
print(iris.target_names[classifier.predict(new_data)])
在这种情况下，我们使用n_neighbors=3和完整的数据集来训练模型。
为了探索我们的模型的不同变体，我们需要为我们的模型制作一个脚本，并对输入和输出进行参数化，以方便地更改参数，如n_neighbors。我们还需要建立一些估计模型的性能的严格方法。
一种实用的方法是创建一个评估程序，在该程序中，我们将数据集分成训练和测试。我们在训练集上训练模型，并在测试集上评估它。
scikit-learn 提供了分割数据集的方法:
from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1012)
生产模型训练
现在我们已经建立了一些实践，让我们创建一个接受参数、训练模型并保存结果分数的函数:
生产就绪模型
执行的命令:
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn import metrics
from sklearn.datasets import load_iristry:
from sklearn.externals import joblib
except:
passdef train_and_eval(
n_neighbors=3,
leaf_size=30,
metric='minkowski',
p=2,
weights='uniform',
test_size=0.3,
random_state=1012,
model_path=None,
):
iris = load_iris()
X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=random_state)
classifier = KNeighborsClassifier(n_neighbors=n_neighbors, leaf_size=leaf_size, metric=metric, p=p, weights=weights)
classifier.fit(X_train, y_train)
y_pred = classifier.predict(X_test)
accuracy = metrics.accuracy_score(y_test, y_pred)
recall = metrics.recall_score(y_test, y_pred, average='weighted')
f1 = metrics.f1_score(y_pred, y_pred, average='weighted')
results = {
'accuracy': accuracy,
'recall': recall,
'f1': f1,
}
if model_path:
joblib.dump(classifier, model_path)
return results
现在我们有了一个脚本，它接受参数来评估基于不同输入的模型，保存模型并返回结果，但这仍然是非常手动的，对于更大和更复杂的模型来说，这是非常不切实际的。
用 Polyaxon 进行实验
我们将创建一个脚本并使用 Polyaxon 运行模型，而不是通过手动更改笔记本中的值来运行模型。我们还将使用 Polyaxon 的跟踪模块记录结果指标和模型。
我们将要训练的模型的代码可以在这个 github repo 中找到。
使用默认参数运行示例:
polyaxon run --url=[https://raw.githubusercontent.com/polyaxon/polyaxon-examples/master/in_cluster/sklearn/iris/polyaxonfile.yml](https://raw.githubusercontent.com/polyaxon/polyaxon-examples/master/in_cluster/sklearn/iris/polyaxonfile.yml) -l
使用不同的参数运行:
polyaxon run --url=[https://raw.githubusercontent.com/polyaxon/polyaxon-examples/master/in_cluster/sklearn/iris/polyaxonfile.yml](https://raw.githubusercontent.com/polyaxon/polyaxon-examples/master/in_cluster/sklearn/iris/polyaxonfile.yml) -l -P n_neighbors=50
安排多个平行实验
我们不会手动更改参数，而是通过探索一系列配置来自动完成这一过程:
polyaxon run --url=[https://raw.githubusercontent.com/polyaxon/polyaxon-examples/master/in_cluster/sklearn/iris/hyper-polyaxonfile.yml](https://raw.githubusercontent.com/polyaxon/polyaxon-examples/master/in_cluster/sklearn/iris/hyper-polyaxonfile.yml) --eager
您将看到 CLI 创建了几个并行运行的实验:
Starting eager mode...
Creating 15 operations
A new run `b6cdaaee8ce74e25bc057e23196b24e6` was created
...
分析实验
在 Polyaxon 上并行运行多个实验
根据实验的准确度对实验进行分类
分类实验
比较accuracy和n_neighbors
可视化精度和 n 个邻居
通过准确性选择最佳模型
在我们的脚本中，我们使用 Polyaxon 在每次运行实验时记录一个模型:
# Logging the model
tracking.log_model(model_path, name="iris-model", framework="scikit-learn")
模型谱系
将模型部署为虹膜分类应用程序
我们将部署一个简单的 streamlit 应用程序，它将加载我们的模型并显示一个应用程序，该应用程序根据特征进行预测，并显示与 flower 类对应的图像。
import streamlit as st
import pandas as pd
import joblib
import argparse
from PIL import Image
def load_model(model_path: str):
model = open(model_path, "rb")
return joblib.load(model)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument(
'--model-path',
type=str,
)
args = parser.parse_args()
setosa = Image.open("images/iris-setosa.png")
versicolor = Image.open("images/iris-versicolor.png")
virginica = Image.open("images/iris-virginica.png")
classifier = load_model(args.model_path)
print(classifier)
st.title("Iris flower species Classification")
st.sidebar.title("Features")
parameter_list = [
"Sepal length (cm)",
"Sepal Width (cm)",
"Petal length (cm)",
"Petal Width (cm)"
]
sliders = []
for parameter, parameter_df in zip(parameter_list, ['5.2', '3.2', '4.2', '1.2']):
values = st.sidebar.slider(
label=parameter,
key=parameter,
value=float(parameter_df),
min_value=0.0,
max_value=8.0,
step=0.1
)
sliders.append(values)
input_variables = pd.DataFrame([sliders], columns=parameter_list)
prediction = classifier.predict(input_variables)
if prediction == 0:
elif prediction == 1:
st.image(versicolor)
else:
st.image(virginica)
让我们用 Polyaxon 来安排应用程序
polyaxon run --url=[https://raw.githubusercontent.com/polyaxon/polyaxon-examples/master/in_cluster/sklearn/iris/streamlit-polyaxonfile.yml](https://raw.githubusercontent.com/polyaxon/polyaxon-examples/master/in_cluster/sklearn/iris/streamlit-polyaxonfile.yml) -P uuid=86ffaea976c647fba813fca9153781ff
注意，在您的用例中，uuid 86ffaea976c647fba813fca9153781ff会有所不同。
在 Polyaxon 上运行的 Streamlit 分类应用程序
结论
在本教程中，我们经历了使用 Kubernetes、Streamlit 和 Polyaxon 训练和部署简单分类应用程序的端到端过程。
你可以在这个 repo 里找到这个教程的源代码。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
