揭开 Python 中虚拟环境的神秘面纱
为什么要使用虚拟环境和安装步骤
Photo by João Silas on Unsplash
自从我开始用 Python 编码以来，我一直在用 Jupyter Notebook 进行我所有的 Python 编码。它非常强大，可以一次测试一行代码，添加 markdown 注释，并且有一个很好的界面。
Python 包允许在编程时访问各种要实现的功能，因此是 Python 编程的日常部分。唉，导入已安装的软件包时确实会出现问题。
我最近遇到了一个问题，我安装了一个特定的包(googletrans)，但一个错误说这样的包不存在，不断弹出。
有几件事需要注意:
- 使用命令
which python来确认您处于什么 Python 环境中。 - Jupyter 笔记本中运行的 Python 内核版本必须与你在
site-packages中安装包的版本相匹配。简而言之，您用来安装包的pip必须对应正确的 Python 内核(Python 2 或 Python 3)。你应该使用 Python 3+,因此对所有安装命令使用**pip3**。 - 使用
sys.path检查内核正在使用的所有当前路径，并确保考虑中的软件包下载文件夹的路径包括在内。
尽管如此，一个人可能会卡住。这些问题可能有很多潜在的原因。绕过他们的一种方法？ 虚拟环境。
默认情况下，所有的包和依赖项都下载到站点包的同一个目录中。因此，为了将每个项目的依赖性从系统中分离出来，并且相互分离，我们应该使用虚拟环境。
使用pip:
- 确保你已经安装了
virtualenv。如果没有，输入你的终端:pip3 install virtualenv。这将被下载到您的python3.7目录下的site-packages中。 - 接下来，
cd到您想要创建虚拟环境的目录。建议在一个地方存储所有虚拟环境。 - 接下来，创建一个虚拟环境:
virtualenv name-of-virtualenv - 上述命令将设置虚拟环境并安装
lib、bin和include文件夹。
Virtual environment installation
cd进入环境并激活:source bin/activate- 现在输入
jupyter notebook。在你想存放笔记本的文件夹中打开一个新的 Python3 笔记本。 - 要确认 Jupyter 内核使用的是什么 Python:
- 在你的 Jupyter 笔记本上输入并执行
!which python。该路径应该指向新创建的当前活动虚拟环境的 bin 中的 python。它应该是这样的:/path/to/created/virtual/environment/name-of-virtualenv/bin/python。 - 您还可以使用
import os和os.getcwd()来检查您当前的工作目录，并确保该路径与您的虚拟环境的路径相匹配。
- 使用
pip3开始安装软件包，一切都准备好了！所有这些包都将在name-of-virtualenv/lib/python3.7/site-packages中安装 - [EDIT]要导入已安装的包，我们必须将
site-packages路径添加到系统路径列表中。
import sys和sys.path.insert(1, './lib/python3.7/site-packages')。这将在索引“1”处插入路径，并确保在导入包时检查包的路径。./指向你当前的工作目录。请注意，每次内核重启时都必须执行这一步。 - 还要注意，一旦您关闭了 Jupyter 笔记本和
deactivate您的虚拟环境(通过在终端中键入命令)，然后您在与上面相同的位置打开了一个 Jupyter 笔记本，!which python命令将返回 Python 的默认“全局”版本。
基于 GAN 的图像彩色化
找回丢失的颜色…
Photo by Vladimir Perelman (1975, Kirillo-Belozersk), colorized by DeOldify (2019)
B **缺乏和白色摄影承担其情感冲击。你摆脱了民粹主义的干扰或俗气的色彩刻板印象。天空是蓝色的，玫瑰是红色的。那是肯定的。很明显的事情。但是我们内心是什么呢？灯光，阴影，对比。**富裕的世界。这就是黑&白摄影直接表达的。在你的皮肤下，进入你的心和灵魂。"
这是我爸爸以前告诉我的。他更了解这一点，因为他一生都在拍照。他是心理照片肖像大师。然而，他记录了一切——从 20 世纪 50 年代到 20 世纪 90 年代，苏联的日常生活、文化和荒谬。
我同意 B&·w 的情感力量，但同时，我想知道，当他永远记住他的世界的对比和细微差别时，他的世界是什么样子的。幸运的是，深度学习可以有所帮助。
#解密
这个模型是由 Jason Antic 创造并发布的。他立即着手于 deol dify(GitHub)——带来了惊人的成果和伟大的使命:
这个项目的任务是着色和恢复旧图像和电影胶片。(来源)
DeOldify 正在使用生成对抗网络以及两个神经网络生成器和鉴别器之间的迭代相互作用(就像《T21》中的艺术培育者)。但与上一个模型不同的是，DeOldify 中的图像不会以它们的形式被修改或生成。甘的力量带来颜色——生成器将颜色应用到他训练过的已识别对象上，鉴别器尝试对颜色选择进行批评。DeOldify 基于 fast.ai 库——为深度学习开发者带来了更多的能力和优化。
在这种情况下，天空是蓝色的。玫瑰是红色的。(但也不尽然。“视情况而定”，正如 Discriminator 用来宣称的那样)。
Jason 在这个模型上工作了很长一段时间——有失败也有成功——这是一段充满情感高峰的个人旅程。令人惊叹的时刻。
在 Hacker Noon 的采访中，他讲述了他对模型结果的第一次影响，在这张解密照片中，他看到了 Evely Nesbit 手中的奖杯:
Source: @citnaj
我承认这张照片有瑕疵。但看到这个之后，我知道我找到了一些东西。
所以他继续挖掘，这样他可以给老照片上色:
给画重新着色:
甚至为历史视频片段添加色彩:
对于研究人员来说，这是一个令人兴奋的功能，他们应该记住，结果不一定代表原始颜色。
给历史图像和视频带来色彩，给了我们一个以单色再现世界的绝佳机会。
你可以在 GitHub 中找到这个模型，也可以在两个笔记本中找到:图像( Colab 笔记本)和视频( Colab 笔记本)——试试吧！
以下是使用 DeOldify 笔记本的简短视频教程:
B&W 还是色彩？
我有自己的惊叹时刻，给我父亲的黑白照片上色。看看这些花——它们颜色的多样性，在黑白照片中看不到:
在这篇文章标题的照片中，你也可以看到画上的颜色——用 AI 重新想象想象力。绿草——和女孩们画的画中修道院的颜色相呼应。
我仍然赞同黑白肖像的心理能量。但是从我个人的角度来说，我很感激 DeOldify 能让我们回到过去。我父亲记忆的重生。颜色总是很鲜艳。在我们的记忆中——现在，在过去的不朽文献中。借助深度学习。
在推特上关注杰森·安蒂奇的# deol dify-新闻和色彩:https://twitter.com/citnaj/
更新。
使用#DeOldify 和其他 ML 模型可以创造奇迹:
正在使用的深度学习模型
towardsdatascience.com](/re-animated-history-6b5eb1a85efa)
依存解析器或如何找到一个单词的语法邻居
本文将通过理论来揭开 NLP 中这一不为人知的部分。然后，在第二篇文章中，我们将推荐一些工具来帮助您理解如何轻松地实现依赖解析器。
当我们考虑一个单词的邻居时，我们可以把邻居看作是他们在句子中的位置，他们与其他单词的关系(主语，行列式，等等。)，称之为句法，或者称之为它们意义的相似性，称之为语义。这里我们感兴趣的是句法上的邻域。
词汇
首先，我们来定义一些词汇，让大家更清楚。
- 语义学是研究意义和解释的语言学和哲学领域。它非常依赖单词之间的联系来理解句子，并分析意思的变化。在编程中，语义是程序的预期输出。
- 句法是语言学领域的语法。它是对句子中单词模式规则的研究。众所周知，在编程中，语法错误通常会导致错误，因为规则通常比口头语言要严格得多。
什么是依赖解析器？
依存关系树是一种可以被定义为有向图的结构，具有对应于单词的|V|个节点(顶点),以及对应于它们之间的句法依存关系的|A|个弧。我们可能还想将标签归属于依赖关系，称为关系。这些关系给出了依赖类型的细节(如主语、直接宾语补足语、决定因素……)。你可以通过下面的链接找到所有来自通用依赖的关系:【https://universaldependencies.org/u/dep/index.html】T4。
Example of Dependency Tree : “What is a parser ?”
在弧 h → d 中，h 是头，d 是从属。中心是一个短语中最重要的节点，而词根是整个句子中最重要的节点:它直接或间接地是所有其他节点的中心。
依存解析器只是将一个句子转换成一棵依存树。
度量:如何识别一个好的解析器？
一个准确的依存解析器能够很好地识别单词之间的依存关系。两个度量(分数)对此是有用的:
-未标记的附件分数(UAS)，其对应于在可能性的数量上正确预测的依赖性的数量；
-标记的附件分数(LAS)，其对应于在可能性的数量上正确预测的依赖性和关系的数量。
LAS 始终小于或等于 UAS，因为不正确的依赖关系会导致次优的 UAS 和 LAS，而不正确的关系(或标注)只会导致 LAS 下降。
算法:它是如何工作的？
正如您可能已经想到的，我们可以通过语言学家开发的规则创建一个依赖解析器。这些解析器被称为理性主义者。它们一点也不高效，因为语言非常复杂，而且会随着时间而变化。语言的任何微小变化都会导致解析器的巨大变化。机器学习允许开发数据驱动的经验解析器。通过许多句子，可以得出依赖或关系的概率。语言学知识可能会用到，但没有定论，如果你像我一样忘记了小学的功课，这是一个很好的观点…
创建依赖解析器需要几个步骤。我们的输入是句子的单词及其属性(索引、词性标签、词条、特征)；然后，我们必须为句子中所有可能的弧线计算特征。由于这些特性，我们为每种可能性计算一个分数，最后用一个解码器解码分数。
功能和评分
句子中的每个单词都有一些属性，比如词性标签或词条。如果你已经读过 NLP，你可能知道他们。如果没有，您可以在这里查看:
利用这些特征，我们训练一个机器学习回归模型，该模型返回将被解码器利用的分数。
特征选择至关重要，一些模型允许我们通过深度学习部分绕过这一部分。我们将在下一节介绍的算法就是这种情况。
解码器
已经开发了许多不同的解码器。然而，我们可以将它们分为两类:基于转换的解码器和基于图的解码器。基于转换的解码器速度更快，解码乐谱需要的内存更少，但通常不如基于图形的解码器准确。在本文中，我将只介绍基于图的模型原理。
其他算法可以应用不同的过渡，但这一个允许我们理解主要的原理。
基于图形的解码器
要理解这些算法，需要处理图论。
图 G=(V，A)是表示记号的顶点 V(也称为节点)和弧(I，j)∈ A 的集合，其中 I，j ∈ V。弧表示两个单词之间的依赖关系。
在基于图的依赖解析器中，图是有向的，这意味着链接有不同的方向，节点之间可以有多条弧线，这被称为多向图。
Weighted Multi Directed Graph (G)
你可以注意到有些箭头比其他的粗。这代表弧的权重。弧线的权重越大，两个节点之间的联系就越紧密。我们可以把这解释为解析器的语法依赖性的强度。比如 C 和 A 看起来很依赖 B，但是 B 看起来不太依赖 C 和 A。
图 G 太连通了。为了得到依赖树，我们需要:
- 仅将每个单词与其从属词链接，而不是与所有单词链接。弧的总数应该等于节点数减 1 (|A| = |V|-1)。
- 保持相同的节点(或记号或单词)。
- 让它成为非循环的:我们不希望一个头依赖于它的一个从属(直接或间接)。
幸运的是，所有这些都已经有了名字:我们想要的是一棵生成树！
Example of Spanning Tree from the graph G
An other example of Spanning Tree
如果我清楚什么是生成树，你应该知道有多种可能性，因为我们只有几个条件来得到一个。这里有一个窍门:我们当然想要最好的，但是我们如何确定“最好”的呢？
这里有 3 个节点，我们想保留它们。然而，我们有 6 个弧，我们只想保留 2 个。“最佳”依赖树是具有最高权重的树:这被称为最大生成树(MST)。
Maximum Spanning Tree of G
Minimum Spanning Tree of G
这个最大生成树给了我们依赖树，我们将使用它来寻找句子中最接近的语法邻居。
结论
与不同的现有算法相比，这里给出的见解是非常轻的。然而，在开发依赖解析器时，这应该会提高您的直觉。
使用 Terraform 和 Ansible 部署 Kafka 集群
供应、部署和管理 Kafka 平台的简单方法
Photo by Luca Bravo on Unsplash
概观
在我之前的帖子——在 AWS 中的 Ubuntu 上安装 Kafka 集群中，我已经详细描述了在 AWS 中手动设置消息传递主干的步骤。这是理解卡夫卡如何工作的伟大一步，但这需要很长时间，并且不可扩展。
一个 Kafka 集群有几个组件，如代理、动物园管理员、运行在多个实例上的工人，如下例所示。供应、部署和管理您的平台的最简单方法是使用可自动执行此任务的工具。
在这篇文章中，我将解释如何使用 Terraform 快速提供多个实例，然后使用 Ansible 在这些实例上安装 Kafka 来设置您的集群。
from AWS: https://aws.amazon.com/quickstart/architecture/confluent-platform/
首先，让我们从高层次的角度快速理解什么是 Terraform 和 Ansible
将（行星）地球化（以适合人类居住）
Terraform 是开源 基础设施 as code 软件工具，由 HashiCorp 打造。它使用户能够使用被称为 Hashicorp 配置语言(HCL)的高级配置语言或可选的 JSON 来定义和配置基础设施。
Terraform 支持许多云基础设施提供商，如亚马逊网络服务、谷歌云平台、微软 Azure 。
Terraform 生成一个执行计划，描述它将做什么来达到期望的状态，然后执行它来构建所描述的基础设施。随着配置的变化，Terraform 能够确定发生了什么变化，并创建可以应用的增量执行计划。
使用高级配置语法来描述基础结构。这允许对数据中心的蓝图进行版本控制，并像对待任何其他代码一样对待它。此外，基础架构可以共享和重复使用。
Ansible
Ansible 是一个非常简单的 IT 自动化平台，使您的应用程序和系统更容易部署。避免编写脚本或自定义代码来部署和更新您的应用程序——使用一种接近简单英语的语言，使用 SSH 来实现自动化，无需在远程系统上安装代理。
我们开始吧
首先，让我们安装 Terraform 和 Ansible
地形
您可以按照下面的说明进行操作，或者如果您使用的是 Mac，最简单的方法是使用 brew:
brew install terraform
Terraform 必须首先安装在您的机器上。Terraform 以二进制包的形式发布，适用于所有受支持的…
learn.hashicorp.com](https://learn.hashicorp.com/terraform/getting-started/install.html)
确认 Terraform 正确安装了:
terraform -v
from: Marcos Lombog console Screenshot
可回答的
使用 pip 命令安装 Ansible。PIP 是 Python 包的一个package manager。 macOS 默认没有安装 pip。你必须先安装它。
sudo easy_install pip
使用 pip 安装 Ansible
sudo pip install ansible
让我们验证是否安装了 Ansible
ansible --version
from: Marcos Lombog console Screenshot
对于其他操作系统，请使用下面的参考:
欢迎使用 Ansible 安装指南！默认情况下，Ansible 通过 SSH 协议管理机器。一旦 Ansible 是…
docs.ansible.com](https://docs.ansible.com/ansible/latest/installation_guide/intro_installation.html)
恭喜你！安装完成！
使用 Terraform 调配您的基础架构
现在，让我们使用 Terraform HCL 构建 Kafka 基础架构。
该设置基于使用公共 VPC 和子网的企业汇合 Kafka。
所有代码都可以在我的 GitHub 中找到
git clone [git@github.com](mailto:git@github.com):mlomboglia/kafka-cluster-infra.git
在 terraform 文件夹中，有以下文件:
from: Marcos Lombog console Screenshot
gateway.tf →互联网网关创建。没有必要更改这个文件
instances.tf →要创建的实例。没有必要更改这个文件
有五种类型的实例在括号中有一个短名称:
- Kafka Brokers (broker) →托管 Kafka broker 服务并维护主题数据
- zookeeper(zookeeper)→托管定额管理服务并管理主题元数据
- Kafka Connect REST API(Connect)→Kafka Connect 是 Kafka 的一个开源组件，是连接 Kafka 与数据库、键值存储、搜索索引、文件系统等外部系统的框架。
- REST 代理(rest) → REST 和对附加融合平台服务的 HTTP/HTTPS 访问
- KSQL 服务器 REST API (ksql) →KSQL 是支持实时数据处理的流 SQL 引擎
- Schema Registry REST API(Schema)→Schema Registry REST 服务器使用请求和响应的内容类型来指示数据的序列化格式以及正在使用的 API 的版本
- 控制中心(control_center) →汇合控制中心是一个基于 web 的工具，用于管理和监控 Apache Kafka。控制中心有助于构建和监控生产数据管道和流式应用程序。
public.tf →子网创建。对于本例，我使用的是公共子网
route.tf →路由表信息
security_group.tf →允许必要的网络流量进入实例的安全组设置。对于这个例子，不需要修改这个文件。
请记住，ingress 允许 0.0.0.0/0，所以这是对公共互联网开放的。您需要将其限制在生产环境中使用。
vpc.tf → VPC 创作
variables.tf 包含我们的地形的参数。您可以对此进行修改。对于我的例子，我将在 AWS 中提供 7 个实例。
" rest " = 1
" connect " = 1
" ksql " = 1
" schema " = 1
" control _ center " = 1
" broker " = 1
" zookeeper " = 1
前缀为“staging”
实例类型“t2.small”。
重要提示:Confluent 推荐一个最小实例类型“t2.large”来运行 Kafka，因此如果您修改它，它将超出 AWS 免费层，并且会花费您的钱
密钥对。
您将需要一个 AWS 密钥对来创建您的实例。如果您还没有，请登录您的 AWS 帐户
EC2 - >创建密钥对
from: Marcos Lombog AWS
给一个名字，点击创建。
下载您的密钥，复制到安全文件夹并更新权限
chmod 400 ~/.ssh/<Key Name>.pem
用您的键名更新 variables.tf 下面的部分
variable "key_name" {
description = "Key Pair"
default = "<Your Key Name>"
}
现在，我们可以走了。
Terraform init 将下载您的依赖项
cd kafka-cluster-infra
terraform init
from: Marcos Lombog console Screenshot
Terraform plan 将创建您的部署计划
terraform plan
现在，小心下一步。根据您的配置，这将花费您一些钱。
terraform apply
from: Marcos Lombog console Screenshot
用“是”确认
如果出现错误:找不到 ami，请转到 EC2 控制台，启动实例并使用最新的 ami 标签进行更新:
from: Marcos Lombog AWS
现在，您已经在 AWS 中提供了所有实例。
from: Marcos Lombog console Screenshot
进入 AWS，查看所有正在运行的实例，并记下每个实例的公共 DNS (IPv4)。在下一节中，您将需要用到它。
from: Marcos Lombog AWS
现在，让我们继续使用 Ansible 安装 Kafka
使用 Ansible 安装 Kafka
安装卡夫卡，我就用合流版。
1.创建一个hosts_example.yml文件的副本。
cd ..
cd cp**-**ansible
cp hosts_example**.**yml hosts**.**yml
2.使用您最喜欢的 IDE 并编辑 hosts.yml 文件，按照每个实例类型的标签，从上面的 AWS Terraform 安装中输入主机，看起来与您的公共 DNS 类似。
非常小心地在 YML 文件上使用正确的缩进:
from: Marcos Lombog console Screenshot
取消 hosts.yml 文件中以下行的注释，添加您的密钥路径
ansible_ssh_private_key_file: '~/.ssh/<Key Path>.pem'
3.确认 Ansible 可以通过 SSH 连接
ansible **-**i hosts**.**yml all **-**m ping
from: Marcos Lombog console Screenshot
键入“是”信任所有服务器。
如果连接到实例时出现问题，请尝试使用以下命令手动 SSH:
ssh -i <Key Path> [ec2-user@<](mailto:ec2-user@ec2-63-33-204-58.eu-west-1.compute.amazonaws.com)Instance Public DNS>
4.运行all.yml行动手册
ansible**-**playbook **-**i hosts**.**yml all**.**yml
from: Marcos Lombog console Screenshot
Ansible playbook 将在您的所有实例上执行 Kafka 安装。
一段时间后，您应该会看到上面的这条消息。所有东西都装好了！
现在，让我们测试安装:
- 您可以使用 SSH 连接到您的任何实例，以检查服务是否正在运行:
systemctl status confluent*
恭喜你！
要继续，你可以用我的另一篇文章构建你的第一个 Kafka 应用程序:
创建您的第一个生产和消费消息的 Kafka 应用程序
towardsdatascience.com](/your-first-kafka-application-9b1358ccb870)
(可选)销毁集群
不要忘记销毁您的群集并终止您的实例，运行以下命令:
terraform destroy
快乐短信！
在 AWS Elastic Beanstalk 上部署一个机器学习模型作为 API
现实世界中的数据科学
循序渐进的教程
Sorry, I don’t use Instagram, so I have to post pictures of my dog here.
每天都有几十篇很棒的文章和教程在讨论如何开发各种机器学习模型。但是，我很少看到解释如何将模型投入生产的文章。如果你想让你的模型对现实世界产生影响，它需要对其他用户和应用程序是可访问的。
这个分步指南将向您展示**如何将模型部署为 API。**为您的模型构建一个 API 是将您的工作集成到您公司系统中的一个很好的方式——其他开发人员只需要学习如何与您的 API 交互来使用您的模型。对于有抱负的数据科学家来说，这也是让他们的投资组合项目脱颖而出的绝佳方式。
本教程面向数据科学家和有抱负的数据科学家，他们在将应用程序和 API 部署到 web 方面没有什么经验。到最后，你会知道如何:
- 使用 Python 的 web 微框架 Flask 开发一个模型 API。
- 使用 Docker 将 API 容器化为微服务。
- 使用 AWS Elastic Beanstalk 将模型 API 部署到 web 上。
为什么要构建 API？
在深入研究代码之前，让我们讨论一下为什么我们更喜欢这种方法，而不是将模型代码放在主应用程序中。构建一个可以被主应用程序调用的独立服务有几个优点:
- 更新更加简单，因为每个系统的开发人员不需要担心破坏其他系统。
- 更具弹性，因为主应用程序中的故障不会影响模型 API，反之亦然。
- 易于扩展(当对 API 使用微服务架构时)。
- 易于与多个系统集成，即网络和移动系统。
模型
如果你正在开发一个项目组合，最好使用不太传统的数据集来帮助你在雇主面前脱颖而出。然而，为了本教程，我将使用著名的波士顿房价数据集。该数据集包含几个可用于预测 1980 年前后波士顿住宅价值的要素。
我选择使用随机森林来处理这个回归问题。我任意选择了一个特征子集来包含在模型中。如果我正在开发一个“真实世界”的模型，我会尝试许多不同的模型并仔细选择特性。
查看我的 GitHub repo 获取快速构建和保存模型的说明。跟着做，然后为您的建模项目构建一个 API！
API
在app/目录下创建脚本app.py。如果你遵循了回购中的说明，这个目录也应该包含保存的模型(model.pkl)。
app/app.py中的前几行从 Flask、NumPy 和 pickle 导入了有用的功能。我们也从下面包含的app/features.py进口FEATURES。接下来，我们初始化应用程序并加载模型。
# app/app.py# Common python package imports.
from flask import Flask, jsonify, request, render_template
import pickle
import numpy as np# Import from app/features.py.
from features import FEATURES# Initialize the app and set a secret_key.
app = Flask(__name__)
app.secret_key = 'something_secret'# Load the pickled model.
MODEL = pickle.load(open('model.pkl', 'rb'))
特征
我将特性列表存储在一个单独的脚本中，以保证 API 中模型训练和预测的一致性。
# app/features.pyFEATURES = ['INDUS', 'RM', 'AGE', 'DIS', 'NOX', 'PTRATIO']
端点
我们的 Flask app 对象(上面定义为app = Flask(__name__))有一个有用的 decorator 方法，使得定义端点.route()变得容易。在下面的代码中，@app.route('/api')告诉服务器每当 http://{your_ip_address}/api 接收到一个请求时，就执行直接在它下面定义的api()函数。
# app/app.py (continued)[@app](http://twitter.com/app).route('/api', methods=['GET'])
def api():
"""Handle request and output model score in json format."""
# Handle empty requests.
if not request.json:
return jsonify({'error': 'no request received'}) # Parse request args into feature array for prediction.
x_list, missing_data = parse_args(request.json)
x_array = np.array([x_list]) # Predict on x_array and return JSON response.
estimate = int(MODEL.predict(x_array)[0])
response = dict(ESTIMATE=estimate, MISSING_DATA=missing_data) return jsonify(response)
解析请求
我们需要包含parse_args()函数来解析 JSON 请求中的特性。
# app/app.py (continued)def parse_args(request_dict):
"""Parse model features from incoming requests formatted in
JSON."""
# Initialize missing_data as False.
missing_data = False# Parse out the features from the request_dict.
x_list = []
for feature in FEATURES:
value = request_dict.get(feature, None)
if value:
x_list.append(value)
else:
# Handle missing features.
x_list.append(0)
missing_data = True
return x_list, missing_data
启动应用程序
最后，在 Flask 的开发服务器上运行应用程序，确保它能够正常工作。
# app/app.py (continued)if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000, debug=True)
用$ python app.py启动服务器。在另一个终端窗口中，使用curl向 API 发送请求。以 JSON 格式传递带有--data标志的特性。
$ curl -X GET "[http://0.0.0.0:5000/api](http://0.0.0.0:5000/api)" -H "Content-Type: application/json" --data '{"INDUS":"5.9", "RM":"4.7", "AGE":"80.5", "DIS":"3.7", "NOX":"0.7", "PTRATIO":"13.6"}'{
"ESTIMATE": 18,
"MISSING_DATA": false
}
生产 Web 堆栈
Flask 的开发 web 服务器非常适合测试，但是由于我不在这里讨论的原因，我们需要在其他地方寻找我们的生产栈。你可以在这里阅读更多关于这个的内容。我们将使用 Gunicorn 作为应用服务器，使用 Nginx 作为 web 服务器。幸运的是，AWS Elastic Beanstalk 默认为我们处理 Nginx 部分。要安装 Gunicorn，运行$ pip install gunicorn。创建脚本app/wsgi.py并添加两行:
# app/wsgi.pyfrom app import app
app.run()
现在，运行$ gunicorn app:app --bind 0.0.0.0:5000。您应该能够执行与上面相同的curl命令来从 API 获得响应。
$ curl -X GET "[http://0.0.0.0:5000/api](http://0.0.0.0:5000/api)" -H "Content-Type: application/json" --data '{"INDUS":"5.9", "RM":"4.7", "AGE":"80.5", "DIS":"3.7", "NOX":"0.7", "PTRATIO":"13.6"}'{
"ESTIMATE": 18,
"MISSING_DATA": false
}
码头工人
Docker 现在非常流行，关于它的好处已经写了很多。如果你有兴趣学习更多关于 Docker 的知识并获得更深入的介绍，请阅读这个。
对于本教程，您需要在您的计算机上设置 Docker，按照这里的说明进行操作。你还需要一个 Docker Hub 账户。
一旦你都设置好了，让我们开始吧！构建 Docker 映像需要两个主要文件，Dockerfile和requirements.txt。
Dockerfile包括创建环境、安装依赖项和运行应用程序的说明。
# app/Dockerfile# Start with a base image
FROM python:3-onbuild# Copy our application code
WORKDIR /var/app
COPY . .
COPY requirements.txt .# Fetch app specific dependencies
RUN pip install --upgrade pip
RUN pip install -r requirements.txt# Expose port
EXPOSE 5000# Start the app
CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:5000"]
requirements.txt包含我们的应用程序所需的所有 Python 包。
# app/requirements.txtFlask==1.0.2
itsdangerous==1.1.0
Jinja2==2.10.1
MarkupSafe==1.1.1
simplejson==3.16.0
Werkzeug==0.15.2
numpy==1.16.4
pandas==0.24.2
scikit-learn==0.19.1
scipy==1.0.0
requests==2.22.0
gunicorn==19.9.0
在app/目录中，运行:
$ docker build -t <your-dockerhub-username>/model_api .$ docker run -p 5000:5000 blemi/model_api
您的应用程序现在运行在 Docker 容器中。重新运行curl命令，会得到同样的输出！
$ curl -X GET "[http://0.0.0.0:5000/api](http://0.0.0.0:5000/api)" -H "Content-Type: application/json" --data '{"INDUS":"5.9", "RM":"4.7", "AGE":"80.5", "DIS":"3.7", "NOX":"0.7", "PTRATIO":"13.6"}'{
"ESTIMATE": 18,
"MISSING_DATA": false
}
运行$ docker push <your-dockerhub-username>/model_api将图像推送到您的 Docker Hub 帐户。在部署到 AWS Elastic Beanstalk 时，这最后一步会非常方便。
AWS 弹性豆茎
是时候把我们的 API 放到网上了，这样我们的朋友和同事就可以访问它了！创建一个 AWS 帐户并登录控制台。 注意:您需要提供一张信用卡来创建您的帐户。如果您按照下面的说明操作，不修改任何选项，您的应用程序将符合自由层资格，并且成本将最低。一旦你启动了你的应用程序，导航到你的账单仪表板，在那里你可以看到你估计的每月费用。
接下来，我们将创建一个文件，告诉 AWS 在哪里访问我们的图像。这叫Dockerrun.aws.json。这里的关键部分是“名称”值。我的 Docker Hub 用户名是“blemi ”,我将图像命名为“model_api ”,所以我将把blemi/model_api:latest作为“name”值。
{
"AWSEBDockerrunVersion": "1",
"Image": {
"Name": "<your-dockerhub-username>/model_api:latest",
"Update": "true"
},
"Ports": [
{
"ContainerPort": "5000"
}
],
"Logging": "/var/log/nginx"
}
在 AWS 控制台中，搜索“Elastic Beanstalk”并选择它。
选择右上角的“创建新应用程序”，为您的应用程序添加名称和描述，然后单击“创建”
点按“立即创建一个”
保持“Web 服务器环境”处于选中状态，然后单击“选择”继续。
如果愿意，为“域”和“描述”填写一个自定义值。对于“平台”，选择“预配置的平台”，并在下拉列表中选择“Docker”。对于“应用程序代码”，选择“上传您的代码”并单击“上传”按钮。
点击“选择文件”按钮，打开我们在上面创建的Dockerrun.aws.json文件。 注意:只有当你把你的 Docker 镜像推送到 Docker Hub 时，这个功能才会起作用。
单击“上传”,然后单击“创建环境”来部署应用程序。
注意:如果您正在创建一个生产级 API，在选择“创建环境”之前，您可能需要在这里选择“配置更多选项”——如果您有兴趣了解其他一些增强安全性和可伸缩性的选项，请联系我。我的信息在这篇文章的底部。
该应用程序需要几分钟的时间来部署，但部署完成后，您可以通过屏幕顶部提供的 URL 进行访问:
现在，让我们在 web 上托管的 API 上运行curl命令。
$ curl -X GET "[http://api-demo-dattablox.us-west-2.elasticbeanstalk.com/api](http://api-demo-dattablox.us-west-2.elasticbeanstalk.com/api)" -H "Content-Type: application/json" --data '{"INDUS":"5.9", "RM":"4.7", "AGE":"80.5", "DIS":"3.7", "NOX":"0.7", "PTRATIO":"13.6"}'{"ESTIMATE":18,"MISSING_DATA":false}
总结和最终想法
我们用 Python Flask 构建了一个简单的模型 API，用 Docker 将其容器化，用 AWS Elastic Beanstalk 将其部署到 web 上。您现在可以利用这些知识为您的模型和项目开发 API 了！这使得与其他开发人员的合作变得更加容易。他们只需要学习如何使用你的 API 将你的模型集成到他们的应用和系统中。
要使这个 API 可以投入生产，还需要做更多的工作。在 AWS 和 Flask 应用程序本身中，您可以设置许多配置来增强安全性。如果使用量很大，还有许多选项可以帮助提高可伸缩性。Flask-RESTful 是一个 Flask 扩展，使得符合 REST API 最佳实践变得容易。如果你对使用 Flask-RESTful 感兴趣，可以看看这个伟大的教程。
取得联系
如果您有任何反馈或批评，请分享。如果您觉得本指南有用，请务必关注我，这样您就不会错过未来的文章。
如果你想联系，在LinkedIn上联系我。感谢阅读！
在 Python 中的 Kubernetes 上使用 NGINX 和 Docker 部署机器学习 Web API
Photo by Fotis Fotopoulos on Unsplash
几天前，我正在谷歌云平台(GCP) Kubernetes 引擎上部署机器学习预测 web API，并浏览了许多技术博客来完成我的任务。因此，我想写一步一步的指南来部署任何机器学习预测 web API，使用 Flask，Gunicorn，NGINX 在 GCP Kubernetes 引擎上的 Docker 中封装。
我把这个循序渐进的教程分成了 3 个部分:
- 在第 1 节中，我们将简要讨论 Flask、Gunicorn、NGINX、Docker 和 Kubernetes 等组件，以及项目搭建和在开发机器上的设置。
- 在第 2 节中，我们将讨论 Gunicorn、supervisor、NGINX 的设置、Docker 文件的创建和 Docker 映像。
- 在第 3 节中，我们将讨论 Kubernetes 并在 Google Kubernetes 引擎上部署 web API。
第一节:
组件描述
我假设读者对 Python，Flask，Gunicorn，NGINX，Docker，Kubernetes，最后但并非最不重要的机器学习有基本的了解。以下是本教程中使用的组件的基本介绍，有关更多详细信息，请参考嵌入的链接:
- 烧瓶 是用 Python 写的一个微型 web 框架。它被归类为微框架，因为它不需要特殊的工具或库。它没有数据库抽象层、表单验证或任何其他组件，而现有的第三方库提供了通用功能。
- Gunicorn 是众多 WSGI 服务器实现中的一个，是 web 应用部署的常用部分，为世界上一些最大的基于 Python 的 web 应用提供动力，如 Instagram。
- NGINX 常用作 web 服务器，为 web 浏览器客户端提供图片、CSS、JavaScript 等静态资产。NGINX 通常还被配置为反向代理，它将适当的传入 HTTP 请求传递给 WSGI 服务器。WSGI 服务器通过运行 Python 代码生成动态内容。当 WSGI 服务器传递它的响应(通常是 HTML、JSON 或 XML 格式)时，反向代理将结果响应给客户机。
- Docker 是一个开源项目，它通过在 Linux 上提供一个额外的抽象层和操作系统级虚拟化的自动化来自动化容器内软件应用程序的部署。
- Kubernetes 是一个开源的容器编排系统，用于自动化部署、扩展和管理容器化的应用程序。它是一个可移植的、可扩展的平台，用于管理容器化的工作负载和服务，促进了声明式配置和自动化。
项目脚手架
Project folder structure to create a docker image
- **app 文件夹:**主文件夹包含所有 python 代码，如:
a.机器学习逻辑，例如数据预处理、将保存的模型加载到存储器中以及机器学习模型预测。
b.requirement.txt 中所有必需的 python 包
c.main.py 中的所有 Flask 代码和路由
- Dockerfile: 定义了容器内部环境中发生的事情。在此环境中，对网络接口和磁盘驱动器等资源的访问是虚拟化的，与系统的其他部分隔离开来，因此您需要将端口映射到外部世界，并明确要将哪些文件“复制”到该环境中。然而，这样做之后，您可以预期在 docker 文件中定义的应用程序的构建无论在哪里运行都是一样的。
- 这个配置文件将为机器学习 flask 应用程序定义一个服务器块。
- gunicorn.conf: 这个配置文件将执行命令在后台运行 gunicorn 应用服务器。
- supervisord.conf: 这个配置文件将照看 Gunicorn 进程，并确保它们在出现问题时重新启动，或者确保这些进程在引导时启动。
- Makefile: 该 Makefile 将包含所有命令，如创建和运行 docker 映像、创建 Kubernetes 集群和部署 web API。
在开发机器上设置项目
- 在开发机器上安装所需的包:
$ sudo apt-get install -y python python-pip python-virtualenv nginx gunicorn supervisor
- 创建并激活 Python 虚拟环境:
Python 虚拟环境帮助我们用所需的 python 包创建特定于应用程序的环境。
安装虚拟环境包:
$ pip install virtualenv
创建虚拟环境:
$ virtualenv mypython
激活 Python 虚拟环境:
$ source mypython/bin/activate
- 打造机器学习预测的 Flask app:
安装 Flask 和其他依赖项:
$ pip install Flask
$ pip install -r requirements.txt
创建机器学习推理代码:
Flask 主要是为应用程序开发服务器创建的。我们可以在开发机器上测试 Flask API。
$ python main.py
不建议在生产环境中使用 Flask development server 来处理并发性和安全性。我们将使用 Gunicorn 作为 Python HTTP WSGI 服务器网关接口。
第二节
Architecture Diagram
- 安装 Gunicorn Python 包:
$ pip install gunicorn
配置 gunicorn.conf 文件以配置 Gunicorn web 服务器。
我们已经将 Gunicorn web 服务器配置为监听端口 5000，并从 app 目录运行 main.py 文件。
- 配置 supervisord 为监控进程:
Supervisord 允许用户在类似 UNIX 的操作系统上监视和控制几个进程。Supervisor 将负责 Gunicorn 进程，并确保它们在出现任何问题时重新启动，或者确保这些进程在引导时启动。
它将运行 NGINX 反向代理服务器，并在其上保持一个监视器。如果有任何失败，它会自动重启服务器并运行 NGINX 命令。
- 设置 NGINX 服务器:
打开一个服务器块，设置 NGINX 监听默认端口80。用户可以设置服务器名称来处理请求。
- 创建 Dockerfile:
我把 Dockerfile 分成了 5 个部分。让我们简单介绍一下每一部分:
- **创建一个 Ubuntu 环境。**安装 Ubuntu，更新必要的包。安装 python、pip、虚拟环境、NGINX、Gunicorn、supervisor。
- **设置烧瓶应用程序。**做一个目录“/deploy.app”。将所有文件从“app”文件夹复制到“/deploy/app”文件夹。安装所有需要的 python 包。
- **设置 NGINX。**删除默认 NGINX 配置。将烧瓶配置复制到 NGINX 配置。为 NGINX 烧瓶配置创建一个符号链接。
- **设置主管。**做一个目录“/var/log/supervisor”。将 Gunicorn 和 supervisord 配置复制到新创建的目录中。
- 启动监控程序进行监控。
- 构建并运行 docker 映像来测试生产就绪的 ML web API:
我已经创建了一个 makefile 来运行所有的命令。
下面的 Makefile 执行两个操作:
- 创建 docker 图像
- 在端口 80 上运行 docker 映像
运行 Makefile:
deploy-local:#build docker image
docker build -t gcr.io/${project_id}/${image_name}:${version} .#run docker image
docker run -d --name ${image_name} -p $(port):$(port) gcr.io/${project_id}/${image_name}:${version}
- 在开发机器上使用 Postman 测试生产就绪的 web API，网址:http://127 . 0 . 0 . 1/predict
在上一节中，我们已经学习了如何在开发机器上构建和运行 ML web API docker 映像。
第三节
在本节中，我们将学习如何在 GCP Kubernetes 引擎上部署这个容器化的 NGINX，并为生产环境公开 API。
- 构建机器学习应用程序的容器映像，并对其进行标记以便上传
#Set variables value as per your project
$ docker build -t gcr.io/${project_id}/${image_name}:${version} .
2.使用 gcloud 命令行工具，安装 Kubernetes CLI。Kubectl 用于与 Kubernetes 通信，Kubernetes 是 GKE 集群的集群编排系统
$ gcloud components install kubectl
3.使用 gcloud 命令行工具，安装 Kubernetes CLI。Kubectl 用于与 Kubernetes 通信，Kubernetes 是 GKE 集群的集群编排系统
$ gcloud components install kubectl
4.配置 Docker 命令行工具以向容器注册表进行身份验证
$ gcloud auth configure-docker
5.使用 Docker 命令行工具将图像上传到容器注册中心
#Set variables value as per your project
$ docker push gcr.io/${project_id}/${image_name}:${version}
6.使用 gcloud 命令行工具并设置项目 id
$ gcloud config set project ${project_id}
7.使用 gcloud 命令行工具并设置区域
$ gcloud config set compute/zone ${zone}
8.在 GCP 上创建一个名为 ML-API-cluster-nginx 的单节点 Kubernetes 集群
$ gcloud container ${cluster_name} create machine-learning-api --num-nodes=1
9.部署机器学习应用程序，监听端口 80
$ kubectl run ${image_name} --image=gcr.io/${project_id}/${image_name}:v1 --port 80
10.将机器学习应用程序暴露给来自互联网的流量
$ kubectl expose deployment ${image_name} --type=LoadBalancer --port $(port) --target-port $(port)
使用 curl 命令或 Postman 测试部署的机器学习 Web API。
我希望这能给你一个说明性的指南，用 Python 在 Kubernetes 上使用 NGINX 和 Docker 部署机器学习 Web API。
来源:
- https://opensource.com/article/18/4/flask
- 【https://www.fullstackpython.com/green-unicorn-gunicorn.html
- https://www.fullstackpython.com/nginx.html
- https://docker-curriculum.com/
- https://www . digital ocean . com/community/tutorials/an-introduction-to-kubernetes
- https://cloud . Google . com/kubernetes-engine/docs/how-to/exposure-apps
- https://cloud . Google . com/kubernetes-engine/docs/tutorials/hello-app
快乐学习！！！
通过 Panini 将 ML/DL 模型部署到生产中
https://paniniai.com是一个以低延迟为 ML/DL 模型提供服务的平台，可以将 ML 模型部署到生产环境的时间从几天缩短到几分钟。
帕尼尼是什么？
Panini 是一个以低延迟为 ML/DL 模型提供服务的平台，使 ML 模型从几天到几分钟内部署到生产环境。一旦部署在 Panini 的服务器中，它将为您提供一个 API 密钥来推断模型。Panini 查询引擎是用 C++开发的，它在模型推理过程中提供了非常低的延迟，Kubernetes 集群用于存储模型，因此它可扩展到多个节点。Panini 还负责在模型推断期间缓存和批处理输入。
我们目前支持 Python 中的框架，但是我们计划将来扩展到其他语言。我来演示一下上传经典迁移学习 Pytorch CNN 模型对狗和猫进行分类。源代码可从 https://github.com/avinregmi/Panini_Tutorial 的获得。确保您安装了 Pytorch 1.0 和 Python 3.6。
传统方法
传统的方法是将 Flask 和 Gunicorn 与 Nginx 一起使用，这需要大量的设置时间。此外，用 Flask 推断模型很慢，并且需要定制代码来进行缓存和批处理。使用烧瓶在多台机器中结垢也会导致许多复杂情况。
大多数人都在使用 Flask 向互联网公开 ML 模型并进行 API 调用。因为 Flask 不是服务于 ML 模型的合适平台。使用烧瓶的一些显著缺点包括:
- 它不支持缓存和批处理。
- 高延迟。有时需要预先计算预测。
- 维护。
- 难以在多个集群中扩展。
为了解决这些问题，我们开发了帕尼尼。
安装所需的包
Panini 需要 python 3.6 所以确保安装了 3.6 的环境。另外，如果你使用 Pytorch，确保你已经安装了 Pytorch 1.0 。
部署经典的狗与猫
完整的源代码可以从
我将使用迁移学习来修改 DenseNet 的最后一层。
保存模型时，确保只保存权重，而不是整个模型架构。推荐的方法是通过调用 state_dict()来保存权重。训练模型的代码非常简单，可以通过打开上面的链接来检索。我已经包括了 Jupyter 笔记本和一个 YouTube 教程。我已经预先训练了 DenseNet 模型来对狗和猫进行分类。我将权重保存为“last_layers.pth”
为帕尼尼准备文件
你需要上传至少三个文件到帕尼尼
- predict.py
- requirements.txt
- 我们保存的模型权重(last_layers.pth)
最重要的文件是 predict.py，这个文件告诉 Panini 加载您的模型并进行预测。如果您有额外的软件包，如 numpy 和 pandas，它可以通过在 requirements.txt 文件中指定 pip 软件包来安装。我们需要的最后一个文件是保存的权重模型。该文件可以命名为任何名称，但扩展名必须是. pth。
Predict.py 脚本里面需要有两个方法。它们是 load()和 predict()
- load(path): 当您的模型被加载到 Panini 的 Kubernetes 集群中时，第一次执行 load。它必须接受一个名为 path 的参数，并返回一个对模型的引用。您需要在这里指定您的模型架构，并将 weights.pth 文件加载回您的模型。在您的模型加载了预先训练的权重之后，它需要返回对您的模型的引用。
- predict(model，input_from_client): 每次向 API 链接发送 POST 请求时，都会执行 predict。它需要模型和 input_from_client 的参数。第一个参数是由 load 函数返回的对模型的引用。下一个参数是客户端通过 POST 请求发送的数据。另外，input_from_client 是一个数组，所以我们必须使用 for 循环来访问每个图像。一旦我们有了每个图像，我们可以应用一些预处理，并将我们的图像转换成张量。一旦我们的图像被转换成张量，我们就可以输入到我们的模型中。我们的模型将返回一个对数概率，这也是一个列表，我们可以将它返回给我们的客户端。确保值 predict()返回一个数组。此外，数组的长度必须等于模型中最后一层的长度。我们用神经网络修改了上面模型的最后一层。线性(256，2)。因此，predict()需要返回一个长度为 2 的数组。
部署时间到了
登录https://paniniai.com并创建一个账户。您可以使用 Google 帐户或 GitHub 登录。
Panini Dashboard
登录后，您将看到一个仪表板，并被要求填写一些信息。首先，给你的模型起个名字。名称必须少于或等于 10 个字符，并且只能是(a-z/0–9)。对于框架选择，PyTorch。目前，您有三种不同的选择。
- PyTorch :如果需要使用深度学习。目前，我们支持 Pytorch 1.0
- Python 函数:任意自定义 Python 函数。这包括 SciKit-Learn 和传统的机器学习，如 SVM 和回归。
- 快速 AI :如果你用的是快速 AI 库。
我们还需要指定模型期望的输入类型。因为我们将发送一张狗/猫的图片，并且将被编码为 base64 字节，所以让我们选择字节作为输入类型。点击浏览并选择你的三个文件。
- predict.py
- r equirements.txt
- last_layers.pth
额外的文件是可选的，不是必需的。有些型号需要额外的文件，如用于 RNNs 的 vocab 到整数映射 pickle 文件。在我们的例子中，我们没有额外的文件，所以我们可以把它留为空白。
选择三个文件后，单击“部署！”并等待文件上传达到 100%。目前，模型大小限制为 2GB。如果您的型号超过 2GB，请给我们发电子邮件。
日志输出
一旦页面显示 100%,您可以刷新页面以查看最新的日志输出。
最后的日志输出应该是“完成部署您的模型！你可以走了！”出现此消息后，您应该会在控制台上方看到一个 API 链接。
如何使用我们的 API 进行推断？
我们将对一只可爱的猫的图片进行 base64 编码，并发送给帕尼尼进行预测。
Let’s send this cute picture to Panini for Prediction.
现在，我们需要做的就是向我们的 API URL 发送一个 POST 请求。要发送图像，我们需要用 base64 编码，并用 JSON 格式包装。此外，关键标签应该是“输入”，值将是我们的图像的 base64 编码字节格式。
Prediction result from Panini
我们也可以使用邮递员
最后
我们已经使用 Panini 成功地将 DL 模型部署到生产中。随着我们模型的流量增加，panini 会自动将其复制到几个节点中。如果我们想将它合并到 web 应用程序中，我们可以从 javascript/NodeJs 发出 POST 请求。我们可以专注于开发我们的模型，而不用担心 DevOps。如果您在上传模型时遇到问题，请发送电子邮件给我们！
YouTube 教程:https://www.youtube.com/watch?v=tCz-fi_NheE&t =
源代码:【https://github.com/avinregmi/Panini_Tutorial】
大规模部署 ML 模型
第 1 部分:ML 模型的 API 服务
ML Model Deployment (Source)
让我们假设您已经构建了一个 ML 模型，并且您对它的性能感到满意。然后下一步是将模型部署到生产中。在这个博客系列中，我将介绍如何使用 AWS 和 docker 容器服务在可扩展的基础设施中部署大规模消费模型。
在这篇博客中，我将从构建 ML 模型的 API 框架的第一步开始，并在您的本地机器上运行它。出于这篇博客的目的，让我们考虑在这里建立的情感分类模型。为了部署该模型，我们将遵循以下步骤:
- 将模型转换成 .hdf5 文件或 。pkl 文件
- 实现 Flask API
- 运行 API
将模型转换成" .hdf5" 文件或’。“pkl”文件
如果模型是基于 sklearn 构建的，最好将其保存为。“pkl”文件。或者，如果它是深度学习模型，那么建议将模型保存为“HDF”文件。'之间的主要区别。pkl ‘和’。“hdf”是，pickle 需要大量的内存来保存数据结构到磁盘，而 HDF 是为了有效地存储大型数据集而设计的。
将模型保存在泡菜中(。pkl):
from sklearn.externals import joblib *# Save to file*# Fit the model (example of a model in sklearn)
model = LogisticRegression()
model.fit(X_train, Y_train)#*working directory* joblib_file = "best_model.pkl"
joblib.dump(model, joblib_file)
在 HDF 保存模型(. hdf5):
一旦在 keras 或 tensorflow 中训练了深度学习模型，就可以使用. hdf5 文件系统保存模型架构及其权重。
# save the best model and early stoppingsaveBestModel = keras.callbacks.ModelCheckpoint('/best_model.hdf5', monitor='val_acc', verbose=0, save_best_only=True, save_weights_only=False, mode='auto', period=1)
实现 Flask API
步骤 1: 根据文件类型，通过以下方法之一加载保存的模型(根据上一节)，即“hdf5”或“pkl”。
HDF5:
from keras.models import load_model
import h5py
prd_model = load_model('best_model.hdf5')
PKL:
from sklearn.externals import joblib
loaded_model = joblib.load('best_model.pkl')
**第二步:**导入 flask，创建 flask 应用对象，如下图所示:
from flask import Flask, url_for, requestapp = Flask(__name__)
步骤 3: 下一步是构建一个测试 API 函数，它返回“ *API working”字符串。*这可以用来确保 API 在生产中部署时的健康。这里我们使用’ @app.route '，这是一个 python 装饰器(装饰器是一个函数，它接受另一个函数并扩展后一个函数的行为，而不显式修改它)
[@app](http://twitter.com/app).route(‘/apitest')
def apitest():
return ‘API working’
步骤 4: 下一步是构建一个“POST”请求 api，用于处理对我们的情感模型的请求。我们使用的是路径名“/情绪”。该函数读取 json 输入并将其转换为 pandas 数据帧。它从 json 中提取相关字段，并调用“get _ opinion _ DL”函数进行处理。“get _ opinion _ DL”函数包含已通过“hdf5”文件加载的训练模型。它最终将以 json result 的形式返回模型的结果。
# main API code
[@app](http://twitter.com/app).route(‘/sentiment’, methods=[‘POST’])
def sentiment():
if request.method == ‘POST’:
text_data = pd.DataFrame(request.json)
text_out = get_sentiment_DL(prd_model, text_data, word_idx)
text_out = text_out[[‘ref’,’Sentiment_Score’]] #Convert df to dict and then to Json
text_out_dict = text_out.to_dict(orient=’records’)
text_out_json = json.dumps(text_out_dict, ensure_ascii=False) return text_out_json
第五步:详细的模型处理步骤将由“get _ sensation _ DL”函数执行。在我们的深度学习情感模型中，我们通过了:
- best_model:加载的模型
2.text_data:用于情感分类的输入文本
3.word_idx:手套文件中的 word 索引(型号详情此处)。
def get_sentiment_DL(best_model, text_data, word_idx):'''Modle Processing''' return sentiment_score
第 6 步:添加下面的部分来运行应用程序。这里主机被设置为“0.0.0.0 ”,因为我们在本地服务器上托管。但是，您可以根据您的网络设置对其进行配置。调试可以在构建 API 功能时设置为真。端口设置为 5005，但是这可以根据您的要求进行配置。
if __name__ == “__main__”:
app.run(host=”0.0.0.0", debug=False, port=5005)
运行 API
要运行 API，请打开命令行窗口并转到存储代码的目录。通过运行下面的命令来运行 python 脚本(“情绪. py”是上面的 API 实现的文件名)。
python sentiment.py
运行上述命令时，您将能够在命令行窗口中看到以下结果:
API 运行后，您可以在浏览器中输入“0.0.0.0:5005/apitest”来测试 API。你将会在你的浏览器中得到下面的结果。
Browser — API Test
现在，您可以使用 python 将任何数据传递给 API，如下所示。我们这里的地址是“http://0 . 0 . 0 . 0:5005/情操”。模型的结果将被返回并存储在“响应”字段中。
import requests
import json
import urllib.parsedata_json = '''{"ref":[1], "text":["I am well"]}'''head= {“Content-type”: “application/json”}response = requests.post(‘[http://0.0.0.0:5005/sentiment'](https://www.seelabs.app/face_rec_train'), json = data_json, headers = head)result = response.content.decode(‘utf8’)
结论
总之，我们已经介绍了将模型部署到本地计算机的 api 服务中的步骤。
下一步是将它作为微服务部署在云服务器中。在接下来的博客中，我将介绍 docker 等容器服务的使用，并在 AWS 中部署它。
在 Kubernetes 上使用 Istio 部署 TensorFlow 模型
部署、版本控制、扩展和监控的典型云应用需求也是机器学习(ML)服务的常见运营挑战。
这篇文章将关注于构建一个 ML 服务基础设施来持续更新、版本化和部署模型。
基础设施堆栈
在构建我们的 ML 服务基础设施时，我们将在云环境中设置一个 Kubernetes 集群，并利用 Istio 来处理服务级别操作。接下来，我们将使用 TensorFlow Serving 来部署和服务托管在 S3 存储桶上的 ResNet 模型。最后，我们将看看如何执行新模型版本的阶段性 canary 部署，并最终使用 Flagger 自动化部署过程。
概括地说，我们的基础架构包括:
- Kubernetes :面向应用基础设施和管理的开源容器编排系统。
- Istio :开源“service-mesh”实现分布式环境下微服务的运营管理。
- tensor flow Serving:开源的高性能 ML 模型服务系统。
- S3 存储 : AWS 云对象存储。
- Flagger :作为 Kubernetes 操作员的开源自动化金丝雀部署管理器。
库伯内特星团
Kubernetes 在重塑云基础架构格局方面创造了奇迹。多种环境都支持构建集群，几乎所有主要的云提供商都提供托管 Kubernetes 作为托管解决方案。
在这篇文章中，我们将借此机会测试一个最新的解决方案，DigitalOcean 的托管 Kubernetes 解决方案。首先在选定的数据中心和节点池配置上创建一个新的 DigitalOcean Kubernetes 集群。
下载配置文件并将其添加到 bash 会话中。
export KUBECONFIG=k8s-1-13-5-do-1-sfo2-1555861262145-kubeconfig.yaml
检查节点的状态，并验证它是否运行正常，是否准备好接受工作负载。
kubectl get nodesNAME STATUS ROLES AGE VERSIONk8s-1-13-5-do-1-sfo2-1555861262145-1-msa8 Ready <none> 57s v1.13.5
伊斯迪奥
Istio 是一个开源的“服务网格”,它将自己透明地分层到现有的分布式基础设施上。
“服务网格”是相互连接的服务相互交互的抽象。这种抽象有助于降低分布式环境中管理应用程序的连接性、安全性和可观察性的复杂性。
Istio 通过提供一个完整的解决方案来帮助解决这些问题，该解决方案对“网格”内的连接服务进行洞察和操作控制。Istio 的一些核心功能包括:
- HTTP、gRPC、TCP 连接上的负载平衡
- 具有路由、重试和故障转移功能的流量管理控制
- 包括度量、跟踪和可观察性组件的监控基础架构
- 端到端 TLS 安全性
在现有的 Kubernetes 集群上安装 Istio 非常简单。关于安装指南，看看 @nethminiromina 的这篇精彩帖子:
[## Istio 分步指南第 2 部分—开始使用 Istio
嗨！欢迎来到我的 Istio 循序渐进教程系列。通过这个教程，我会告诉你如何安装 Istio 在…
medium.com](https://medium.com/devopslinks/istio-step-by-step-part-02-getting-started-with-istio-c24ed8137741)
从下载的 Istio 包目录创建自定义资源定义(CRD ):
kubectl apply -f install/kubernetes/helm/istio/templates/crds.yaml
接下来，从打包的“一体化”清单中将 Istio 运营商资源部署到集群:
kubectl apply -f install/kubernetes/istio-demo.yaml
部署完成后，我们应该会在istio-system名称空间中看到以下服务列表:
确保所有吊舱都处于Running状态，并且上述服务可用。根据安装设置，启用对default名称空间的侧车注入:
kubectl label namespace default istio-injection=enabled --overwrite
Istio 交通管理
Istio 提供简单的规则和流量路由配置来设置服务级别属性，如断路器、超时和重试，以及部署级别任务，如 A/B 测试、canary 部署和分阶段部署。
Istio 交通管理的核心是飞行员和特使。Pilot 是管理服务发现和所有服务之间的智能流量路由的中心运营商，它通过翻译高级路由规则并将它们传播到必要的特使侧车代理。
Envoy 是一个高性能代理，用于协调网格中服务的所有入站和出站流量。它被部署为一个侧车集装箱，所有 Kubernetes 豆荚都在网格内。Envoy 的一些内置功能包括:
- 服务发现
- 负载平衡
- HTTP 和 gRPC 代理
- 基于%流量分割的分阶段部署
- 丰富的指标
- TLS 终端、断路器、故障注入等等！
我们将使用 Istio 的流量管理和遥测功能在我们的集群中部署、服务和监控 ML 模型。
出口和入口
Istio 通过简单的规则配置将流量管理从基础设施中分离出来，以管理和控制服务之间的流量。
为了让流量流入和流出我们的“网格”,我们必须设置以下 Istio 配置资源:
Gateway:在“网格”边缘运行的负载均衡器，处理传入或传出的 HTTP/TCP 连接。VirtualService:管理“网格”内 Kubernetes 服务之间流量路由的配置。DestinationRule:路由后服务的策略定义。ServiceEntry:内部服务配置附加条目；可以为内部或外部端点指定。
配置出口
默认情况下，支持 Istio 的应用程序无法访问集群外部的 URL。由于我们将使用 S3 存储桶来托管我们的 ML 模型，我们需要设置一个 ServiceEntry 来允许从我们的 Tensorflow 服务部署到 S3 端点的出站流量:
创建ServiceEntry规则以允许出站流量通过定义的端口到达 S3 端点:
kubectl apply -f resnet_egress.yamlserviceentry "aws-s3" created
配置入口
为了允许传入流量进入我们的“网格”，我们需要设置一个入口 [Gateway](https://istio.io/docs/tasks/traffic-management/ingress/#configuring-ingress-using-an-istio-gateway)。我们的Gateway将通过公开端口31400接收流量来充当负载平衡代理:
通过指定标签选择器istio=ingressgateway使用 Istio 默认控制器，这样我们的入口网关 Pod 将是接收该网关配置并最终公开端口的设备。
创建我们上面定义的Gateway资源:
kubectl apply -f resnet_gateway.yamlgateway "resnet-serving-gateway" created
张量流服务
Tensorflow 服务提供灵活的 ML 服务架构，旨在为 gRPC/REST 端点上的 ML 模型提供服务。
在这篇文章中，我们将使用一个预先训练好的、导出的 ResNet 模型作为我们在服务基础设施上部署的例子。
S3 模型库
为了访问 ML 模型，Tensorflow Serving 将任意文件系统路径的加载器抽象为接口，并提供 GCS 和 S3 云存储文件系统的开箱即用实现。
使用 AWS 控制台创建ml-models-repository S3 桶，在桶上设置 IAM 用户和角色。
将NHWC模型架构上传到ml-models-repository桶中，目录结构如下:
resnet/
1/
saved_model.pb
variables/
variables.data-00000-of-00001
variables.index
为了安全地从我们的桶中读取，使用 S3 访问凭证创建一个 Kubernetes 秘密:
kubectl create secret generic s3-storage-creds \
--from-literal=access_id=$AWS_ACCESS_KEY_ID \
--from-literal=access_key=$AWS_SECRET_ACCESS_KEYsecret "s3-storage-creds" created
Kubernetes 部署
以下清单将 Tensorflow 定义为 Kubernetes Deployment，以Service为前端，以公开服务器的 gRPC 和 REST 端点:
上面清单定义中的一些要点需要注意:
- 展开有两个标签
app=resnet-serving和version=v1。 - 该服务选择并公开 gRPC 端口
9000和 REST 端口9001的app=resnet-serving标签上的部署。 - ConfigMap 中的
model_config_listprotobuf 可用于定义模型路径和版本策略；在我们的例子中，我们已经将模型固定在版本1上进行加载。
将 Tensorflow 服务资源部署到集群中:
kubectl apply -f resnet_serving_v1.yamldeployment "resnet-serving" created
service "resnet-serving" created
configmap "tf-serving-models-config" created NAME READY STATUS RESTARTS AGE
resnet-serving-65b954c449-6s8kc 2/2 Running 0 11s
正如所料，Pod 应显示有两个集装箱在其中运行，主tensorflow-serving集装箱和istio-proxy侧车。
检查 Pod 中的tensorflow-serving容器日志，以验证服务器正在运行，并且已经成功加载了从我们的 S3 存储库中指定的模型:
kubectl logs resnet-serving-65b954c449-6s8kc -c tensorflow-serving2019-03-30 22:31:23.741392: I external/org_tensorflow/tensorflow/contrib/session_bundle/bundle_shim.cc:363] **Attempting to load native SavedModelBundle in bundle-shim from: s3://ml-models-repository/resnet/1**2019-03-30 22:31:23.741528: I external/org_tensorflow/tensorflow/cc/saved_model/reader.cc:31] **Reading SavedModel from: s3://ml-models-repository/resnet/1**2019-03-30 22:31:33.864215: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:285] **SavedModel load for tags { serve }; Status: success. Took 10122668 microseconds.**2019-03-30 22:31:37.616382: I tensorflow_serving/core/loader_harness.cc:86] **Successfully loaded servable version {name: resnet version: 1}**2019-03-30 22:31:37.622848: I tensorflow_serving/model_servers/server.cc:313] **Running gRPC ModelServer at 0.0.0.0:9000 ...**2019-03-30 22:31:37.626888: I tensorflow_serving/model_servers/server.cc:333] **Exporting HTTP/REST API at:localhost:9001 ...**
Tensorflow 服务中 S3 客户端的错误导致大量垃圾警告日志。这可以通过设置
*TF_CPP_MIN_LOG_LEVEL=3*环境变量来关闭。
模型部署和 Canary 推广
到目前为止，我们已经用 Kubernetes、Istio 和 Tensorflow 服务建立了我们的基础设施。现在，我们可以开始对我们的模型进行版本控制，设置到指定部署的路由，然后利用 Istio 的流量分割规则执行模型服务器部署的阶段性 canary 部署。
设置 V1 路由
我们需要设置流量规则，以便Gateway在接收请求时知道路由到什么服务。
该规则由一个VirtualService定义，它允许路由到目的地“网状”服务，而无需了解基础设施中的底层部署。下面的VirtualService连接到我们之前定义的Gateway上，将 100%的流量路由到端口9000.上v1子集的resnet-serving。DestinationRule资源用于定义VirtualService的路由策略。
应用以下VirtualService和DestinationRule清单:
kubectl apply -f resnet_v1_routing.yamlvirtualservice "resnet-serving" created
destinationrule "resnet-serving" created
在这篇文章中，我们没有公开任何公共负载平衡器或者在我们的集群上设置 TLS。因此，目前可以在端口转发网关端口上发送测试流量:
kubectl -n istio-system port-forward istio-ingressgateway-5b64fffc9f-xh9lg 31400:31400Forwarding from 127.0.0.1:31400 -> 31400
使用以下 Tensorflow 服务 python gRPC 客户端对输入图像进行预测请求:
python tf_serving_client.py --port=31400 --image=images/001.jpgname: "resnet"
version {
value: 1
}
signature_name: "serving_default"dtype: DT_INT64
tensor_shape {
dim {
size: 1
}
}
int64_val: 228
运行一个小负载测试，并在 Istio Mesh Grafana dashboard 上观察 p50、p90 和 p99 服务器端延迟:
这种延迟时间非常糟糕，原因有几个:
- (相对)低计算配置文件—每个节点 2 个 CPU。
- Vanilla Tensorflow 服务二进制文件未针对底层 CPU 平台进行优化。
在我们的 Mux 工程博客的以下帖子中，解释了构建 CPU 优化 Tensorflow 服务二进制的技术，以及针对延迟/吞吐量的性能调整。
[## 我们如何将 Tensorflow 服务性能提高 70%以上
Tensorflow 已经发展成为事实上的 ML 平台，在行业和研究领域都很受欢迎。需求和支持…
mux.com](https://mux.com/blog/tuning-performance-of-tensorflow-serving-pipeline/)
模型部署 V2
比方说，我们的v1模型表现不佳，我们希望部署新的模型版本以及优化的 TensorFlow 服务二进制文件。对模型部署的更改应该始终以迭代的方式进行，以便新模型的行为和性能可以在作为 GA 推广到所有客户端之前得到适当的测试和验证。
我们的新模型部署将使用新的Resnet-50 v2模型和更新的 CPU 优化 Tensorflow 服务映像。
将ResNet-50 v2 保存的模型上传到resnet/2/路径下的 S3 桶中，目录层次与之前相同。然后，创建一个新的部署和配置图，它将加载并提供resent模型的2版本。
与以前的清单相比，更改如下:
diff --git a/tf_serving.yaml b/tf_serving_v2.yaml
index 90d133d..05047a3 100644
**--- a/tf_serving.yaml
+++ b/tf_serving_v2.yaml**@@ -1,10 +1,10 @@
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
**- name: resnet-serving
+ name: resnet-serving-v2**
@@ -13,7 +13,7 @@ spec:
metadata:
labels:
app: resnet-serving
**- version: v1
+ version: v2** spec:
containers:
- name: tensorflow-serving
**- image: tensorflow/serving:latest
+ image: masroorhasan/tensorflow-serving:cpu**@@ -55,32 +55,15 @@ spec:
volumes:
- name: tf-serving-models-config
configMap:
**- name: tf-serving-models-config
+ name: tf-serving-models-config-v2**
___
apiVersion: v1
kind: ConfigMap
metadata:
**- name: tf-serving-models-config
+ name: tf-serving-models-config-v2**
@@ -90,19 +73,8 @@ data:
model_platform: "tensorflow",
model_version_policy: {
specific: {
**- versions: 1
+ versions: 2**
在这里可以找到v2部署和配置图的完整清单。这里需要注意一些重要部分:
- 新部署更新了版本标签
version=v2。 - 更新 Docker 镜像
masroorhasan/tensorflow-serving:cpu是预建的 CPU 优化二进制。 - ConfigMap 还与新版本策略相冲突，以专门获取模型的版本
2。
将部署应用到群集:
kubectl apply -f resnet_serving_v2.yamldeployment "resnet-serving-v2" created
configmap "tf-serving-models-config-v2" created
请注意，我们不需要更新resnet-serving服务，它在标签选择器app=resnet-serving上位于两个部署的前面。
设置 V2 金丝雀路由
现在我们已经有了新的模型部署，我们希望逐步向一部分用户推广它。
这可以通过更新我们的VirtualService来实现，将一小部分流量路由到v2子集。
我们将保持谨慎，更新我们的VirtualService以将 30%的传入请求路由到v2模型部署:
kubectl replace -f resnet_v2_canary.yamlvirtualservice "resnet-serving" replaced
destinationrule "resnet-serving" replaced
运行另一个负载测试，观察 Istio Mesh 仪表板，了解两个版本的resnet-serving工作负载的延迟指标。
按目的地划分的请求显示了类似的模式，流量在resnet-serving和resnet-serving-v2部署之间分流。
设置 V2 路由
一旦 canary 版本满足模型行为和性能阈值，部署就可以升级为面向所有用户的 GA。下面的VirtualService和DestinationRule被配置为将 100%的流量路由到我们的模型部署的v2。
更新路由规则，以将v2提升为所有传入流量的 GA:
kubectl replace -f resnet_v2_routing.yamlvirtualservice "resnet-serving" replaced
destinationrule "resnet-serving" replaced
当一个负载测试正在运行时，网格仪表板将显示流量完全从v1转移，而是流入我们部署的v2。
自动化金丝雀释放
到目前为止，我们已经对集群监控的模型性能进行了新模型版本的逐步、分阶段部署。然而，手动更新流量规则不符合操作可扩展性的精神。
Istio 流量路由配置可用于通过编程调整下游服务版本之间流量的相对权重来执行 canary 发布。在本节中，我们将使用 Weaveworks 的开源渐进式金丝雀部署工具来自动化金丝雀部署: Flagger 。
Flagger 是一家 Kubernetes 运营商，它使用 Istio 和 App Mesh 流量路由功能，基于自定义的 Prometheus 指标，自动迭代部署和推广 canary 版本。
让我们克隆 Flagger 存储库并创建服务帐户、CRD 和 Flagger 操作员:
git clone git@github.com:weaveworks/flagger.git
按照以下顺序创建服务帐户、CRDs 和操作员:
# service accounts
kubectl apply -f flagger/artifacts/flagger/account.yaml# CRD
kubectl apply -f flagger/artifacts/flagger/crd.yaml# Deployment
kubectl apply -f flagger/artifacts/flagger/deployment.yaml
应该在istio-system名称空间中创建 Flagger 部署。这是将对标有kind: Canary的客户资源进行操作的主要操作员。
Flagger 采用了 Kubernetes 部署，如resnet-serving，并创建了一系列资源，包括 Kubernetes 部署(初级 vs 金丝雀)、ClusterIP服务和 Istio 虚拟服务。
由于大量手动流量路由服务将由 Flagger 运营商负责，我们需要清理之前 Istio 流量路由相关资源和v2服务部署的集群。
# clean up routing
kubectl delete -f resnet_v1_routing.yaml
kubectl delete -f resnet_serving_v2.yaml
kubectl delete -f resnet_v2_routing.yaml# clean up svc
kubectl delete svc/resnet-serving
定义一个将引用我们的resnet-serving模型部署的 Flagger Canary 定制资源:
应用清单来创建 Canary 资源:
kubectl apply -f flagger_canary.yamlcanary "resnet-serving" created
如上所述，这将在创建一系列 Kubernetes 资源的同时初始化金丝雀。
要触发自动 canary 升级，请通过更新容器映像来触发部署:
kubectl set image deployment/resnet-serving \
tensorflow-serving=masroorhasan/tensorflow-serving:cpu
此时，Flagger 操作员将检测到部署修订中的更改，并对新的部署进行排队:
当 canary 部署升级为 GA 时，Flagger 将自动缩减旧部署。在部署期间应用对部署的更改将触发 Flagger 重新开始分析和重新部署。
包扎
在这篇文章中，我们通过在 Kubernetes 基础设施上部署 TensorFlow 服务来构建一个 ML 服务环境。然后，我们利用 Istio 的智能流量路由功能，以分阶段部署的方式管理模型部署。最后，我们在集群上部署了 Flagger operator，以自动化分阶段部署 canary 的过程。
虽然我们选择关注 ML 模型的服务方面，但是有许多框架和工具可以帮助整合端到端的 ML 管道。其中一些包括(除其他外):
- Kubeflow :在 Kubernetes 上提供内聚培训和服务基础设施的工具和框架的集合。
- SeldonCore :提供一个运行时 ML 图形引擎来管理 Kubernetes 上的服务 ML 模型。
- Clipper :一个预测服务系统，供数据科学家在 Docker-only 或 Kubernetes 环境中使用。
- Pipeline.ai :汇集了许多流行的开源工具来构建、实验端到端的机器学习管道。
- 云 ML 服务: [Google ML 引擎](https://cloud.google.com/ml-engine/)、 AWS SageMaker 和 Azure ML 服务
感谢您的阅读，我希望这篇文章有助于在 Kubernetes 上构建 TensorFlow 模型部署。我很想听听你对 ML 服务基础设施的设置——请随意联系 Twitter。感谢阅读！
参考文献
在云中部署和管理容器工作负载的最简单方式。
www.digitalocean.com](https://www.digitalocean.com/products/kubernetes/) [## 服务模型| TFX | TensorFlow
TensorFlow 服务是一个灵活、高性能的机器学习模型服务系统，专为生产…
www.tensorflow.org](https://www.tensorflow.org/tfx/guide/serving) [## 伊斯迪奥
连接、保护、控制和观察服务。
istio.io](https://istio.io/) [## 云对象存储|随处存储和检索数据|亚马逊简单存储服务
亚马逊简单存储服务(亚马逊 S3)是一种对象存储服务，提供行业领先的可扩展性、数据…
aws.amazon.com](https://aws.amazon.com/s3/) [## 将 Tensorflow 性能提高 70%
Tensorflow 已经发展成为事实上的 ML 平台，在行业和研究领域都很受欢迎。需求和支持…
mux.com](https://mux.com/blog/tuning-performance-of-tensorflow-serving-pipeline/) [## 介绍
Flagger 是一家渐进式交付 Kubernetes 运营商
docs.flagger.app](https://docs.flagger.app)
部署您的数据科学模型
第 1 部分:用 Pickle 或 Joblib 从笔记本上删除
作为一名初学数据科学的学生，到目前为止，我的大部分训练都是在选择、训练和评估许多有监督的机器学习方法。大部分是在 Jupyter 笔记本上。
Jupyter 笔记本电脑是数据科学的天赐之物，它在一个方便的开发环境中促进了分段评估和建模，这一点怎么说都不为过。很难想象，如果数据科学家不得不执行并寻找错误，那么训练他们会有多困难。py 可执行文件。
然而，Jupyter 笔记本并不适合部署。在我最近参加的一次黑客马拉松中，我可以开发建模对象，但是我的 Python 代码迫使全栈开发人员使用 Django 来适应它(及其依赖项)。我觉得自己是个不必要的负担。从那以后，我一直在寻找方法来部署我的模型，并在我的模型和生产环境之间建立更多的桥梁。为什么让那些家伙独享乐趣？这是系列文章的第一部分，将记录我在部署模型时遇到的困难。希望我能让你一路上不那么伤心。
所以，首先要做的是。你在笔记本上建立了一个模型。除非您想在生产中每次都运行笔记本，否则您需要从笔记本中取出建模对象，以便它可以在*中运行。py 可执行文件。
一般来说，有两种我们称之为模型持久性的方法。pickle 方法和更面向数据的 Joblib 方法。Pickle 方法或通常所说的“Pickle”是将一个对象转换成字节流以便保存和加载。由于编程中的几乎所有东西在其核心都被表示为一个对象，所以您可以看到这是多么有用。
然而，Joblib 库被开发成更适合 python 对象(通常是 numpy 类型)。如果对象是大量基于 numpy 数组的，这将大大节省保存和加载的时间。您可以看到 Joblib 在数据科学中的价值，并从中推断出它可能是建模持久性的更好途径。你可以两者兼得。但总的来说，更大的数据集将从使用 Joblib 中受益。pickle 正在更新，以便更好地适应基于 numpy 的对象，但这是以后的事了。不过今天不用担心，我将向您展示这两种方法，因为它们都相对简单。
首先，让我从心爱的虹膜数据集建立一个快速模型。
我们得分吧。
**唉。**不是最高分。但这不是重点。现在我们有了模型，并且知道它可以工作，让我们保存并加载 Pickle。
用泡菜塑造坚持。
Pickle 是 Python 2 和 3 的原生版本，所以不需要 pip 安装。我们首先想出一个要保存的文件名，然后用 pickle 启动 dump()方法，将我们的模型对象(上面的 km)写入二进制文件。注意这里的“wb”很重要，它不能和“w”(只写)一起使用。它需要转换成二进制形式。文件名是任意的，也是任意的。我使用的 sav "扩展名。它可以是任何东西，也不需要有扩展名。在你方便的时候给它起个名字，什么对你的目的起作用。
Huzzah, it’s off the notebook!
恭喜你。您已经成功保存了您的第一个模型以供将来使用。您可以使用这个 load 命令在将来的笔记本中调用它，或者出于演示的目的，我们可以在同一个笔记本中进行调用。我们对 pickle 使用 load()方法，对 read-binary 使用参数“rb”。现在，km_loaded_pickle 是我们之前的 km 模型对象。它应该有和以前一样的属性和方法。
It works!
另一件有趣的事情是——加载的模型维护了模型的所有方法。您不需要再次导入库来运行它的方法，例如运行预测。整洁！
用 Joblib 建模持久性
用 Joblib 实现模型持久性的过程或多或少是相同的，但是在我看来稍微简单一些。但是，您需要导入 sklearn.externals.joblib 包。我们以与前面相同的方式设置文件名，并使用我们刚刚定义的文件名在 km 模型上执行 joblib.dump。
嘣，保存了同一个模型，已经用了两种方法了！我们在这里好运连连。让我们强有力地结束。现在使用之前的文件名，用 joblib.load()重新加载它。
现在我们有了它，重新加载它并使用它的属性。像以前一样，我们也可以运行模型的方法，比如 predict()，而不需要导入库。这些都是内置在对象中的。
警告:不要加载任何你自己都不信任的 pickle 或 Joblib 二进制文件。两者都无法抵御恶意代码。
Photo by Japheth Mast on Unsplash
这就是了。从起点到最终部署的第一步。我希望能在一周内完成这个系列的每一个连续部分。接下来，我想我们可能会将所有这些都放入 docker 容器中。如果您有任何问题、评论或担忧，请告诉我，或者我如何才能将这个系列变成我们都可以使用的有用的东西。
直到下一部分，编码快乐！
部署您的第一个分析项目
数据专业人员权威指南(数据分析)
用 Heroku 部署 Lazada 的 Web 抓取仪表板
Source: Unsplash
问题陈述:
对于数据科学家来说，将您的应用程序部署到云中，让任何技术或非技术用户都可以访问它是非常重要的。根据我的工作经验，数据科学家创建机器学习模型，而工程师部署它们的期望已经不复存在。大多数时候，数据科学家需要同时做两件事:设计他们的数据模型和部署他们的数据应用程序(开发-运营)。
如果我们可以轻松自由地为我们的用户部署我们的数据应用程序，那该有多好。
进入 Heroku
Source Heroku
Heroku 是一个广泛使用的商业软件平台(PaaS ),它使数据专业人员更容易构建、管理和部署各种规模的应用程序。这意味着您现在可以专注于开发分析应用程序，而无需担心部署基础架构。Heroku 为您处理所有部署的繁重工作！
简而言之，无论您在本地 Jupyter 服务器上运行什么，您都可以将其部署到云上，供用户使用！
Source: Giphy
Heroku 在行动
Our Application in Big Picture, today we are going to learn how to deploy our application with Heroku
在本教程中，您将学习如何使用 Heroku 部署您的 Python Dashboard Web 应用程序。我们将部署仪表板来查看 Lazada 产品的价格下降并生成警报。
请随意欣赏这篇文章或访问我的 Github Repo 获取完整代码。或者向下滚动，欣赏这篇文章。
对于不熟悉我提到的仪表板 Web 应用程序的人来说。我正在建立一个基于 Lazada 报废产品价格变化的仪表板。每当用户修改下拉输入时，如果产品价格下降，应用程序会提醒用户。
我们的任务是用 Heroku 在云上部署这个应用程序。最终结果是一个链接，你可以分享给你的朋友或同事，以访问和监控 Lazada 产品的价格趋势。
Price Optimization Dashboard Scraped from Lazada over 3 days
以下是实现这一目标的关键步骤:
- 注册 Heroku 帐户
- 创建新应用程序
- 设置部署配置和库
- 使用 Heroku Toolbelt 部署您的第一个应用程序
- 调试和故障排除
注册 Heroku 帐户
访问 Heroku 并注册。然后，您会收到一封电子邮件通知，确认您的帐户创建。
一旦你准备好了，进入你的账户，你就可以访问你的个人应用主页。
Heroku Main Application Pages
创建新应用程序
继续点击页面右上角的新应用。输入您的应用程序名称，然后单击创建应用程序。
Creating new app
设置部署配置和库
Heroku 的第一页需要两个文件:requirements.txt 和 Procfile。
- requirements.txt 将在您运行应用程序时存储您的 Python 环境中的所有 Python 库和依赖项。您可以运行
pip freeze > **requirements**.**txt**将 Python 库转储到一个文件中 - Procfile 将指定部署标准，例如您使用的 dynos 类型。Dynos是在 Heroku 平台上运行和缩放 app 的容器模型。这是一种非常可扩展和可靠的方式来平衡流量，并让您的应用程序在小引擎单元内运行。在这种情况下，我们将使用 gunicorn 作为我们与 dynos 交互的接口。
Gunicorn 作为 Web 应用服务
Gunicorn 是一个 WSGI 接口，这意味着它可以托管任何 Python 可编程 web 应用程序，并确保与我们的 Dash Python 和 Flask 库进行适当的通信。
Gunicorn 负责 web 服务器和 web 应用程序之间的任务。它还可以帮助您运行 web 应用程序的多个实例，检查实例的健康状况，并在负载平衡这些实例时根据需要重置它们。我们已经做了很多努力来优化它，所以我们可以很容易地使用它。酷！
只需将这一行代码放在 Procfile 中，指示 dynos 使用 gunicorn web 界面。
web: gunicorn app:server
使用 Heroku Toolbelt 部署您的第一个应用程序
使用 Heroku 有很多部署方式。但是我发现的最简单的方法之一是使用 Heroku Toolbelt。参考此链接下载工具箱。
然后我们将使用 git 和 heroku 命令来部署我们的应用程序。
Initiating git in your code repos and deploying it with heroku
然后一旦你把它推入 heroku，你会看到你的主机将安装你在 requirements.txt 中指定的所有库。
Installing libraries from requirements.txt
在服务器完成它的任务后，你将获得链接来访问我们的应用程序。
恭喜你，你刚刚在 Heroku 上部署了你的第一个应用！
YAY!! Source: Giphy
调试和故障排除
在大多数情况下，您会遇到一些部署问题。因此，要对此进行调试，您可以插入命令**heroku logs -tail.**
该命令将返回以下日志，这些日志将告诉您应用程序崩溃的原因。
Heroku Logs to debug
这里说我仪表盘上的模块不叫 app。这是因为我将我的主应用程序命名为 dashboard.py，而不是 app.py。这导致了错误，因为 Flask 找不到要运行的主应用程序脚本。因此，我们可以重命名为 app.py，然后再次推送应用程序。
如果你遇到更多的问题，只需谷歌日志错误，堆栈溢出或破折号文件。如果没有，请在这里随意评论，我会尽快回复。干杯:)
最终结果
恭喜你！！您已经部署了第一个数据应用程序。如果你做得正确，你将能够在你的 链接上访问应用程序。如果没有，请随意查阅我的 Github 代码或者在这里提出你的问题。
Price Optimization Dashboard Scraped from Lazada over 3 days
现在，使用 Heroku 释放和部署您的分析应用程序
更多参考
如果你需要更多的例子和更好的见解，Heroku 可以提供一些引擎。请随意访问以下链接。
最后…
Source: Unsplash
我真的希望这是一本很棒的读物，是你发展和创新的灵感来源。
请在下面评论出来建议和反馈。就像你一样，我也在学习如何成为一名更好的数据科学家和工程师。请帮助我改进，以便我可以在后续的文章发布中更好地帮助您。
谢谢大家，编码快乐:)
关于作者
Vincent Tatan 是一名数据和技术爱好者，拥有在 Google LLC、Visa Inc .和 Lazada 实施微服务架构、商业智能和分析管道项目的相关工作经验。
Vincent 是土生土长的印度尼西亚人，在解决问题方面成绩斐然，擅长全栈开发、数据分析和战略规划。
他一直积极咨询 SMU BI & Analytics Club，指导来自不同背景的有抱负的数据科学家和工程师，并为企业开发他们的产品开放他的专业知识。
文森特还在 best top 上开设了他的一对一导师服务，指导你如何在谷歌、Visa 或其他大型科技公司获得你梦想中的数据分析师/工程师职位。 如果你正在寻找良师益友，请在这里预约他 。
最后，请通过 LinkedIn ，Medium或 Youtube 频道 联系文森特
将您的机器学习模型部署为 REST API
部署机器学习模型对初学者来说可能听起来有些吓人，甚至对那些有一些经验的人来说也是如此。这就是为什么我决定花一整篇文章来谈论它。
Photo by Franck V. on Unsplash
读完这篇文章后，你将能够部署机器学习模型，并根据你想要的任何编程语言进行预测。没错，你可以坚持使用 Python，或者你可以通过 Java 或 Kotlin 直接在你的 Android 应用中进行预测。此外，您可以在您的 web 应用程序中直接使用该模型——选项是无限的。为了简单起见，我将使用邮递员。
然而，我不会解释如何将模型放在一个活动的服务器上，因为选项是无穷无尽的，这可能是另一个帖子的好主意。该模型将在您的本地主机上运行，所以不，您将无法从不同的网络访问它(但是可以随意谷歌如何将模型部署到 AWS 或类似的东西)。
我已经创建了下面的目录结构:
ML-展开
- model / Train.py
- app.py
现在如果你已经通过 Anaconda 安装了你的 Python，那么你可能已经预装了所有的库，除了 Flask 。因此，启动终端并执行以下命令:
pip install Flask
pip install Flask-RESTful
进展顺利吗？ 好。现在让我们开始研究一些好东西吧。
制作一个基本的预测脚本
如果您正在按照目录结构进行操作，现在应该打开model/train . py文件。目标是载入 Iris 数据集，并使用简单的决策树分类器来训练模型。一旦训练完成，我将使用 joblib 库来保存模型，并且我还将向用户报告准确度分数。
这里没有什么复杂的，因为机器学习不是本文的重点，只有模型部署。以下是完整的脚本:
from sklearn import datasets
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.externals import joblib
def train_model():
iris_df = datasets.load_iris()
x = iris_df.data
y = iris_df.target
X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
dt = DecisionTreeClassifier().fit(X_train, y_train)
preds = dt.predict(X_test)
accuracy = accuracy_score(y_test, preds)
joblib.dump(dt, 'iris-model.model')
print('Model Training Finished.\n\tAccuracy obtained: {}'.format(accuracy))
部署
现在你已经准备好打开 app.py 文件并进行一些导入。你需要 os 模块，一些来自 Flask 和Flask-RESTful的东西，10 秒钟前创建的模型训练脚本，以及 joblib 来加载训练好的模型:
import os
from flask import Flask, jsonify, request
from flask_restful import Api, Resource
from model.Train import train_model
from sklearn.externals import joblib
现在你应该从 Flask-RESTful 中创建一个 Flask 和 Api 的实例。没什么复杂的:
app = Flask(__name__)
api = Api(app)
接下来要做的是检查模型是否已经训练好了。在 Train.py 中，您已经声明了模型将被保存在文件iris-model . model中，如果该文件不存在，则应该先对模型进行训练。一旦训练完毕，你就可以通过 joblib 加载它:
if not os.path.isfile('iris-model.model'):
train_model()
model = joblib.load('iris-model.model')
现在，您需要声明一个用于进行预测的类。Flask-RESTful使用这个编码约定，所以你的类需要从Flask-RESTful Resource模块继承。在类内部，可以声明 get() ， post() ，或者其他任何处理数据的方法。
我们将使用 post() ，因此数据不会直接通过 URL 传递。您需要从用户输入中获取属性(根据用户输入的属性值进行预测)。然后，可以调用 ***。*预测()**加载模型的功能。仅仅因为这个数据集的目标变量是以( 0，1，2 )的形式而不是( ‘Iris-setosa ‘，’ Iris-versicolor ‘，’ Iris-virginica’ )的形式，您还需要解决这个问题。最后，您可以返回预测的 JSON 表示:
class MakePrediction(Resource):
@staticmethod
def post():
posted_data = request.get_json()
sepal_length = posted_data['sepal_length']
sepal_width = posted_data['sepal_width']
petal_length = posted_data['petal_length']
petal_width = posted_data['petal_width']
prediction = model.predict([[sepal_length, sepal_width, petal_length, petal_width]])[0]
if prediction == 0:
predicted_class = 'Iris-setosa'
elif prediction == 1:
predicted_class = 'Iris-versicolor'
else:
predicted_class = 'Iris-virginica'
return jsonify({
'Prediction': predicted_class
})
我们就要到了，坚持住！您还需要声明一个路由，这是 URL 中用于处理请求的部分:
api.add_resource(MakePrediction, '/predict')
最后，告诉 Python 让在调试模式下运行应用:
if __name__ == '__main__':
app.run(debug=True)
仅此而已。您已经准备好启动模型并进行预测，无论是通过 Postman 还是其他工具。
以防你遗漏了什么，这里有完整的 app.py 文件:
import os
from flask import Flask, jsonify, request
from flask_restful import Api, Resource
from model.Train import train_model
from sklearn.externals import joblib
app = Flask(__name__)
api = Api(app)
if not os.path.isfile('iris-model.model'):
train_model()
model = joblib.load('iris-model.model')
class MakePrediction(Resource):
@staticmethod
def post():
posted_data = request.get_json()
sepal_length = posted_data['sepal_length']
sepal_width = posted_data['sepal_width']
petal_length = posted_data['petal_length']
petal_width = posted_data['petal_width']
prediction = model.predict([[sepal_length, sepal_width, petal_length, petal_width]])[0]
if prediction == 0:
predicted_class = 'Iris-setosa'
elif prediction == 1:
predicted_class = 'Iris-versicolor'
else:
predicted_class = 'Iris-virginica'
return jsonify({
'Prediction': predicted_class
})
api.add_resource(MakePrediction, '/predict')
if __name__ == '__main__':
app.run(debug=True)
好了，准备好了吗？
太好了。导航到根目录(其中app . py*)，启动终端并执行以下操作:*
*python app.py*
大约一秒钟后，您会得到一个输出，显示应用程序正在本地主机上运行。
现在我将打开邮递员并执行以下操作:
- 将方法更改为 POST
- 输入 localhost:5000/predict 作为 URL
- 在 Body 选项卡中，选择 JSON
- 输入一些 JSON 进行预测
然后，您可以点击发送:
瞧啊。几乎立刻你就能从你的模型中得到预测。
最后的话
我希望你已经设法看完了这篇文章。如果你只是复制粘贴所有的东西，只要你安装了所有必要的库，你就可以开始了。
我强烈建议将这些新获得的知识用于您自己的数据集和您自己的业务问题。如果你在用 Python 之外的其他语言编写应用程序，并且只是将 Python 用于数据和机器学习相关的东西，这就很方便了。
感谢阅读，保重。
喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。
* [## 通过我的推荐链接加入 Medium-Dario rade ci
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@radecicdario/membership)*
使用 tensorflow 服务和 kubernetes 部署您的机器学习模型
机器学习应用正在蓬勃发展，但数据工程师没有很多工具可以将这些强大的模型集成到生产系统中。在这里，我将讨论 tensorflow-serving 如何帮助您在产品中加速交付模型。这篇博文是关于服务机器学习模型的— 什么意思？
服务是你如何在训练后应用一个 ML 模型——从事 tensorflow 服务的 Noah Fiedel 软件工程师
为了说明 tensorflow 服务于的能力，我将介绍服务于对象检测模型的步骤。在我的 GitHub 上找到与本文相关的所有代码:https://github.com/fpaupier/tensorflow-serving_sidecar
Summary of a machine learning pipeline — here we focus on serving the model
张量流简而言之
Tensorflow 服务使您能够无缝地服务于您的机器学习模型。
- 部署新版本的模型，让 tensorflow 服务优雅地完成当前请求，同时开始使用新模型服务新请求。
- 分开考虑，数据科学家可以专注于构建出色的模型，而运营部门则可以专注于构建可服务于这些模型的高度灵活且可扩展的架构。
第 1 部分—预热:设置本地 tensorflow 服务器
在上线之前，最好确保你的服务器在本地工作。我在这里给出了大的步骤，在项目readme中找到更多的文档。
看看设置步骤以确保您能从本教程中获得最大收益:
- git 克隆https://github.com/fpaupier/tensorflow-serving_sidecar，创建 python3.6.5 虚拟环境并安装
requirements.txt - 获取 tensorflow 服务 docker 图片
docker pull tensorflow/serving - 得到一个模型来服务→我用这个，它执行对象检测更快 _rcnn_resnet101_coco
- 转到模型目录，用版本号重命名
saved model子目录，因为我们在这里做的是 v1，让我们称它为00001(它必须是数字)。我们这样做是因为 tensorflow serving docker image 在搜索要提供的模型时会搜索以该约定命名的文件夹。 - 现在运行 tensorflow 服务器:
# From tensorflow-serving_sidecar/
docker run -t --rm -p 8501:8501 \
-v "$(pwd)/data/faster_rcnn_resnet101_coco_2018_01_28:/models/faster_rcnn_resnet" \
-e MODEL_NAME=faster_rcnn_resnet \
tensorflow/serving &
在继续之前，请注意:
docker -v arg in our use case
这里我们绑定了容器的端口和本地主机。因此，当我们在localhost:8501上调用推断时，我们实际上将调用 tensorflow 服务器。
您还会注意到我们将本地主机目录faster_rcnn_resnet101_coco_2018_01_28——存储模型的地方——与容器/models/faster_rcnn_resnet路径链接起来。
请记住，此时savedModel.pb只在您的机器上，而不在容器中。
6.执行客户呼叫:
# Don't forget to activate your python3.6.5 venv
# From tensorflow-serving_sidecar/
python client.py --server_url "http://localhost:8501/v1/models/faster_rcnn_resnet:predict" \
--image_path "$(pwd)/object_detection/test_images/image1.jpg" \
--output_json "$(pwd)/object_detection/test_images/out_image1.json" \
--save_output_image "True" \
--label_map "$(pwd)/data/labels.pbtxt"
去查看--output_json 指定的路径，享受结果。(提供 json 和 jpeg 输出)
expected inference with our object detection model
很好，现在我们的模型运行良好，让我们将它部署到云上。
第 2 部分—在具有 tensorflow 服务的 kubernetes 集群上服务您的机器学习应用程序
在生产环境中，您希望能够随着应用程序负载的增加而扩展。你不希望你的服务器不堪重负。
An exhausted tensorflow server directly exposed over the network
为了避免这个问题，您将使用 kubernetes 集群来服务您的 tensorflow-server 应用程序。预期的主要改进:
- 负载将在您的副本之间平衡，您无需考虑这一点。
- 您是否希望在不停机的情况下部署新模型？没问题，kubernetes 支持你。执行滚动更新，逐步为您的新模型提供服务，同时适度终止旧模型上的当前请求。
a tensorflow server application running on many replicas in a k8s cluster, ensuring high availability to users
我们开始吧
首先，我们想要创建一个嵌入了对象检测模型的完整 docker 图像。一旦完成，我们将在 kubernetes 集群上部署它。我在谷歌云平台上运行我的例子，因为免费层使得免费运行这个教程成为可能。为了帮助你在 GCP 建立云环境，你可以点击这里查看我的教程。
创建自定义 tensorflow 服务 docker 图像
- 将服务映像作为守护程序运行:
docker run -d --name serving_base tensorflow/serving
2.将faster_rcnn_resnet101_coco模型数据复制到容器的models/文件夹中:
# From tensorflow-serving_sidecar/
docker cp $(pwd)/data/faster_rcnn_resnet101_coco_2018_01_28 serving_base:/models/faster_rcnn_resnet
3.提交容器以服务于faster_rcnn_resnet模型:
docker commit --change "ENV MODEL_NAME faster_rcnn_resnet" serving_base faster_rcnn_resnet_serving
*注意:*如果您使用不同的型号，相应地更改--change参数中的faster_rcnn_resnet。
faster_rcnn_resnet_serving将成为我们新的服务形象。您可以通过运行docker images来检查这一点，您应该会看到一个新的 docker 图像:
docker images result after creating a custom tensorflow-serving image
4.停止服务基本容器
docker kill serving_base
docker rm serving_base
太好了，下一步是测试我们全新的faster_rcnn_resnet_serving 形象。
测试定制服务器
在 kubernetes 上部署我们的应用程序之前，让我们确保它正常工作。
- 启动服务器:
docker run -p 8501:8501 -t faster_rcnn_resnet_serving &
*注意:*确保您已经停止(docker stop <CONTAINER_NAME>)之前运行的服务器，否则端口8501可能会被锁定。
2.我们可以使用相同的客户端代码来调用服务器。
# From tensorflow-serving_sidecar/
python client.py --server_url "http://localhost:8501/v1/models/faster_rcnn_resnet:predict" \
--image_path "$(pwd)/object_detection/test_images/image1.jpg" \
--output_json "$(pwd)/object_detection/test_images/out_image2.json" \
--save_output_image "True" \
--label_map "$(pwd)/data/labels.pbtxt"
我们可以检查我们是否有相同的好的，现在让我们在kubernetes集群上运行它。
在 kubernetes 上部署我们的应用
除非你已经在 GCP 上运行了一个项目，否则我建议你检查一下谷歌云设置步骤。
我假设你已经创建并登录了一个名为tensorflow-serving的gcloud项目
您将使用之前构建的容器映像faster_rcnn_resnet_serving在 Google 云平台中部署带有 Kubernetes 的服务集群。
- 登录您的项目，首先用
gcloud projects list列出可用的项目，选择项目的PROJECT_ID并运行
# Get the PROJECT_ID, not the name
gcloud projects list # Set the project with the right PROJECT_ID, i.e. for me it is tensorflow-serving-229609
gcloud config set project tensorflow-serving-229609
gcloud auth login
2.创建一个容器集群
- 首先，我们为服务部署创建一个 Google Kubernetes 引擎集群。由于免费试用的限制，您在这里不能使用超过 2 个节点，您可以升级或使用两个节点，这对我们的用例来说已经足够好了。在你的免费试用中，你的限额是 8 个 CPU。)
gcloud container clusters create faster-rcnn-serving-cluster --num-nodes 2 --zone 'us-east1'
您可以更新zone arg，您可以在中选择，例如 : europe-west1，asia-east1 -您可以使用gcloud compute zones list检查所有可用的区域。你应该有这样的东西:
kubernetes cluster creation output
3.为 gcloud container 命令设置默认集群，并将集群凭证传递给 kubectl 。
gcloud config set container/cluster faster-rcnn-serving-cluster
gcloud container clusters get-credentials faster-rcnn-serving-cluster --zone 'us-east1'
之后您应该会看到这样的内容:
gcloud container clusters get-credentials output
4.上传我们之前构建的自定义 tensorflow 服务 docker 图像。让我们将我们的图像推送到 Google 容器注册表，这样我们就可以在 Google 云平台上运行它。
使用容器注册表格式和我们的项目 id 标记faster_rcnn_resnet_serving图像，用您的PROJECT_ID更改tensorflow-serving-229609。最后还要修改标签，这是我们的第一个版本，所以我把标签设为v0.1.0。
docker tag faster_rcnn_resnet_serving gcr.io/tensorflow-serving-229609/faster_rcnn_resnet_serving:v0.1.0
如果你运行docker images，你现在会看到一个额外的gcr.io/tensorflow-serving-229609/faster_rcnn_resnet_serving:v0.1.0图像。
这个gcr.io前缀允许我们将图像直接推送到容器注册中心，
# To do only once
gcloud auth configure-dockerdocker push gcr.io/tensorflow-serving-229609/faster_rcnn_resnet_serving:v0.1.0
您已经成功地将您的图像推送到 GCP 集装箱注册中心，您可以在线查看:
docker image successfully pushed on Google Container Registry
5.创建 Kubernetes 部署和服务
该部署由一个由 Kubernetes 部署控制的 fast-rcnn 推理服务器的单一副本组成。副本通过 Kubernetes 服务和外部负载平衡器对外公开。
使用单个副本实际上没有意义。我这样做只是为了在自由层内通过。如果您只有一个实例来指导您的查询，那么负载平衡是没有用的。在生产设置中，使用多个副本。
我们使用示例 Kubernetes configfaster _ rcnn _ resnet _ k8s . YAML来创建它们。您只需要更新 docker 图像以在文件中使用，用您的实际图像全名替换行image: <YOUR_FULL_IMAGE_NAME_HERE>，看起来像这样:
image: gcr.io/tensorflow-serving-229609/faster_rcnn_resnet_serving@sha256:9f7eca6da7d833b240f7c54b630a9f85df8dbdfe46abe2b99651278dc4b13c53
您可以在容器注册表中找到它:
find your docker full image name on google container registry
然后运行以下命令
# From tensorflow-serving_sidecar/
kubectl create -f faster_rcnn_resnet_k8s.yaml
要检查部署和 pod 的状态，请使用kubectl get deployments来监视整个部署，使用kubectl get pods来监视部署的每个副本，使用kubectl get services来监视服务。
sanity check for deployment
一切正常运行可能需要一段时间。服务外部IP地址列在负载平衡器入口的旁边。您可以使用kubectl describe service命令来检查它:
kubectl describe service faster-rcnn-resnet-service
find the IP address to query upon to perform inference
查询您的在线模型
最后，让我们来测试一下。我们可以使用相同的客户端代码。简单地将前面使用的--server-url参数中的localhost替换为上面指定的负载平衡器入口的IP地址。
# From tensorflow-serving_sidecar/
python client.py --server_url "http://34.73.137.228:8501/v1/models/faster_rcnn_resnet:predict" \
--image_path "$(pwd)/object_detection/test_images/image1.jpg" \
--output_json "$(pwd)/object_detection/test_images/out_image3.json" \
--save_output_image "True" \
--label_map "$(pwd)/data/labels.pbtxt"
外卖食品
Tensorflow 服务提供了一个很好的基础，您可以依靠它以很少的开销在生产中快速部署您的模型。
- 机器学习应用程序的容器化部署能够分离运营和数据科学家之间的关注点
- Kubernetes 等容器编排解决方案与 tensorflow-serving 相结合，为不熟悉分布式计算的人提供了在几分钟内部署高可用性模型的可能性。
资源📚
- Tensorflow 服务由谷歌的软件工程师 Noah Fiedel 解释，他从事 Tensorflow 服务。它让我们深入了解它是如何建造的以及建造的目的是什么https://www.youtube.com/watch?v=q_IkJcPyNl0
- 免费提供预训练模型库https://github . com/tensor flow/models/blob/master/research/object _ detection/g3doc/detection _ model _ zoo . MD
- Tyler Labonte medium post 将 tensorflow 模型导出为保存的检查点https://medium . com/@ tmlabonte/serving-image-based-deep-learning-models-with-tensor flow-servings-restful-API-d 365 c 16 a7 DC 4
- 提供一个没有合适框架的 ML 模型是多么麻烦的例子https://towardsdatascience . com/how-to-build-and-deploy-a-lyrics-generation-model-framework-agnostic-589 f 3026 FD 53
- Cloud ML，用于部署 ML 模型的 Google 托管解决方案:https://cloud . Google . com/ML-engine/docs/tensor flow/deploying-models
扫一扫
720
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
