自动、可靠、安全地部署数据仪表板
新的开源软件，以所有语言和框架安全地自动部署数据科学家的交互式可视化
当今的数据项目需要交互式可视化，才能脱颖而出，给客户或组织中的决策者留下深刻印象。越来越多的开源仪表板框架允许数据科学家构建用户界面，而无需学习 Javascript 或 HTML。
来自 Pexels 的 ThisIsEngineering 摄影
例如，Volià以其最简单的形式显示了一个 Jupyter 笔记本，作为一个用户友好的网络应用程序——代码单元被隐藏，笔记本从上到下自动运行，用户不必在其中移动和输入。基于 Python 的小部件库提供了简单的用户控件，如滑块和下拉框。
数据科学家和分析师可以通过一个简短的教程开始使用这些框架。他们显然有技术能力找到一种方法来托管由此产生的 web 应用程序，也许是暂时在他们自己的笔记本电脑上，或者通过 AWS 帐户进行部署。
但是这个简单的部署步骤最终成为组织中采用仪表板框架最常见的障碍。
虽然这个过程可能很简单，但它本身是没有回报的——当数据科学家自豪地完成他们全新的分析时，需要运行一些乏味的命令。更糟糕的是，它容易出错，并可能暴露敏感数据。
正如自动化测试和持续集成使发布新功能变得有趣，而不是传统软件开发中的琐事一样，共享数据仪表板的任何障碍都会扼杀创新，阻碍新的迭代。
将部署选择留给您的数据科学家是不明智的，因为他们在技术上无疑是精明的。他们没有时间保护服务器，可能会选择最简单的认证系统。对于安全的定期部署，您确实需要一种统一的方法来托管您的数据团队，这种方法可以得到您的信息安全部门的全面批准。
这些仪表盘在技术上是网络应用。他们不需要 IT 部门花三个月的时间来审核他们的安全性，但需要有一种经过批准的方法来部署他们，这种方法不会像数据科学家在自己的设备上使用的临时方法那样让 IT 部门感到恐惧。
您需要知道您的所有仪表板在哪里运行，以及它们是如何被认证的。否则，可能会有过时和不安全的服务器在外面运行，暴露您的网络和敏感数据。当员工离开您的组织时，您需要能够终止他们对这些仪表板的访问。如果该员工碰巧在其个人 AWS 帐户上运行了一些仪表盘，您就不需要依靠他们来记住在哪里运行了什么，以便您可以关闭它们或转移所有权！
容器产品套件
免费的开源 ContainDS 软件产品可以为您的数据科学家提供一个统一的部署平台，允许他们以自动化、安全和可复制的方式共享基于开源框架的仪表板。
可以使用任何开源的仪表板框架。标配支持 Voilà、Streamlit、Plotly Dash、Bokeh、Panel 和 R Shiny。这些应该是您的数据科学团队可能面临的任何项目的良好起点！
ContainDS 是两个主要产品和相关开源技术的集合。
包含仪表板文档(图片由作者提供)
ContainDS Dashboards 是一个在互联网或内部网络上托管和共享仪表板的平台，拥有指定的认证用户——可能是特定的同事或客户。
有时，即使这样也太开放了，所以如果由于缺乏互联网或合同原因无法通过网络访问数据而需要离线共享仪表板， ContainDS Desktop 是一款适用于 Windows 或 Mac 电脑的应用程序，允许您在本地机器上运行仪表板，并将其作为单一平面文件与其他人共享。
在这里，我们将重点介绍在线仪表板软件。
通过 JupyterHub 的在线仪表板
ContainDS Dashboards 是流行的 JupyterHub 软件的扩展。如果你已经有一个正在使用的 JupyterHub，这使得安装特别容易，但是第一次安装一个并不太复杂，而且无论如何都是有用的。
JupyterHub 是为整个团队集中管理 Jupyter 笔记本环境的一种方式。标准安装允许每个用户启动他们自己的 Jupyter 笔记本，ContainDS Dashboards 扩展允许他们直接启动用户友好的仪表板，与其他经过身份验证的用户共享它们。
JupyterHub 的不同“发行版”提供了不同的维护和可伸缩性方法。有许多定制选项，但两个主要路径是运行在 Kubernetes 上的 Zero 2 JupyterHub ，允许为大量用户或项目在多台机器上无缝扩展资源；和最小的 JupyterHub 设置一个虚拟机来运行 JupyterHub(考虑到目前云提供商提供的虚拟机范围，这仍然可以支持惊人的大量使用！).
加载你的应用文件
选择用于部署仪表板的应用程序文件有两种主要方式:您的“文件源”可以来自您现有的 Jupyter 服务器树，也可以来自 Git repo(公共或私有)。
从 GitHub repo 创建 Voilà仪表板(图片由作者提供)
如果您已经是 Jupyter 笔记本的大量用户，并且可能只想将笔记本部署为 Voilà或 Panel 应用程序，那么使用第一个选项— Jupyter Tree 可能是有意义的。你可以像平常一样编辑你的笔记本，然后当你满意的时候，进入 JupyterHub 中的 Dashboards 菜单，输入你的笔记本的路径，看到它自动部署为一个新的仪表板。
更好的是，现在有一个配套的 Jupyter 扩展，所以你可以直接从 JupyterLab 或笔记本一键创建一个仪表板。
或者，如果您习惯于在本地机器上编辑 Streamlit、R Shiny、Plotly Dash 应用程序等，将您的代码签入 Git repo，然后指示 ContainDS Dashboards 直接从您的 repo 中提取并部署它，可能会更方便。你可以使用公共或私有 Git 回购，GitHub 集成意味着你可以通过 GitHub 帐户一键登录 JupyterHub，并在此过程中自动授予对你的回购的访问权限。
使用任何一种文件源方法，您也可以从多个 Conda 环境中进行选择，如果您已经为 JupyterHub 用户提供了这些环境的话。
从下拉列表中选择正确的“框架”也很重要，以确保使用正确的机制来服务仪表板。正如已经列出的，Voilà、Streamlit、Plotly Dash、Bokeh、Panel 和 R Shiny 目前都支持开箱即用，但很容易添加任何作为 web 应用程序工作的自定义框架。
一旦部署，仪表板实际上就像独立的 Jupyter 服务器，但它们不是运行 Jupyter notebook，而是直接运行您选择的框架的服务器软件。如果您曾经尝试过 Jupyter 笔记本中的 Voilà Preview 按钮，您会对最终结果很熟悉——但是在 ContainDS 仪表板的情况下，部署根本没有 Jupyter 前端。您的应用程序将被部署为纯 web 应用程序。这正是你要与他人分享的应用程序所需要的…最终用户不应该能够在你的服务器上运行任意代码。
与其他用户共享
添加到 JupyterHub 中的新仪表板菜单不仅用于注册新仪表板以进行部署，还用作与您共享的任何仪表板的内容列表。
仪表板主菜单屏幕(作者图片)
当您创建仪表板时，您可以选择是将其提供给 JupyterHub 中的所有用户，还是仅提供给选定的指定用户。JupyterHub 允许多种身份验证方法，例如，使用 LDAP 或 Google 单点登录，您的所有同事都可以通过自动为他们创建的帐户轻松访问您的仪表板。
为仪表板访问选择命名用户(按作者排序的图片)
授权用户可以点击任何与其共享的仪表板，点击确认 OAuth 同意屏幕，然后立即开始与仪表板交互。
在 ContainDS 仪表板内运行的仪表板可视化示例(图片由作者提供)
可扩展和可配置
关于 JupyterHub 的一切都是高度可配置的:从您托管它的位置(Kubernetes，在云 VM 上，或者在您的内部网络上)到用户登录时如何认证。
这同样适用于 ContainDS 仪表板——您可以完全控制它的行为方式，甚至可以通过编辑配置文件来插入您自己的仪表板可视化框架(例如，基于 Flask 的 web 应用程序)。
结论
这是对 ContainDS 仪表板的一个快速概述，解释了数据科学家部署一个新的交互式可视化来与客户或同事共享是多么容易。
您的数据科学家已经在试验新的可视化框架，这些框架在过去几年中出现在开源领域。他们的应用程序在他们的开发机器上运行得很好，但是当他们需要部署它时总是很痛苦。
通常，他们会转而导出 PDF 文件，或者只是将图表复制粘贴到电子邮件中。这是一个真正错过的机会，让决策者真正沉浸在数据模型中。
如果仪表板最终被部署，它通常不是以 it 批准的方式进行的，只有简单的身份验证步骤和托管在任意云服务器上。
对于大中型数据科学团队来说，不同的项目有不同的需求，数据科学家希望选择对他们自己的技能和项目需求有意义的开源框架。
为了克服这些问题，ContainDS Dashboards 提供了一个统一的部署和共享模型，无论数据科学团队使用何种技术来推动他们的分析，都可以由 IT 部门管理和轻松使用该模型。
有关安装详情，请参见包含仪表板文档。
丹·莱斯特是 Ideonate 的联合创始人，为数据科学家制作工具，包括ContainDS，这是一个为从事离散项目的团队提供的数据科学部署平台。
使用 TensorFlow 与 Docker 和 Flask 一起部署深度学习模型
通常，任何数据科学项目的生命周期都包括定义问题陈述、收集和预处理数据，然后是数据分析和预测建模，但任何数据科学项目最棘手的部分是模型部署，我们希望最终用户使用我们的模型。有许多部署机器学习模型的方法，但 TensorFlow serving 是一个高性能的模型部署系统，它使在生产环境中随着时间的推移维护和更新模型变得非常容易。
深度学习模型部署，TensorFlow 服务在 Docker 中运行，由 Flask App 使用
在本教程中，我们将借助 Docker 提供的 TensorFlow 部署一个预训练的 TensorFlow 模型，还将使用 Flask web framework 创建一个可视化 web 界面，该界面将用于从所提供的 TensorFlow 模型中获取预测，并使最终用户能够通过 API 调用进行消费。
TensorFlow serving 为开发人员提供了一个将人工智能融入软件系统的简单集成，并且已经被用于生产大量的谷歌产品。它可以同时服务于多个模型和同一模型的多个版本。Flask 是一个轻量级的 python web 框架，它让开发者可以轻松快速地创建 web 应用。Docker 是一个将软件组件隔离到容器中的工具，所有的软件依赖项都作为一个包安装和部署在容器中。
让我们把手弄脏吧！！
本教程将假设您运行的是 python 3.7 版的 Windows
让我们看一下目录结构，以便更好地理解模型结构和 Flask web app。
App.py—flask app 的主应用文件/控制器Model.py—将 TensorFlow 模型服务器连接到 flask web 应用程序pets—预训练保存的猫和狗分类 ML 模型Template—包含 flask 应用程序将提供的 html 文件static—包含应用程序的静态内容，例如图像
在本地主机上设置 TensorFlow 服务服务器
因为我们的 pets 文件夹中有一个预先训练好的模型，所以我们必须指定本地机器上的模型路径和模型将暴露到的端口，以便我们的 Flask 应用程序可以调用本地主机上的那个端口，并发送数据以获得预测。
Docker RUN 命令将安装 TensorFlow 服务的 Docker 映像，并将创建指向 pets 模型的 docker 实例。
*先决条件:*请启用 Hyper-V 功能并安装 docker
以管理员身份运行 CMD 并执行以下命令:
docker run -p 8501:8501 — name=pets -v “C:\pets:/models/pets/1” -e MODEL_NAME=pets tensorflow/serving
命令行参数的详细信息如下:
-p 8501:8501 —指定本地主机上 TensorFlow 服务器的端口 8501，docker 公开冒号后的端口用于服务
--name=pets —指定 docker 实例名称
-v “C:\pets:/models/pets/1” —指定本地主机上的模型路径和 docker 实例
内的模型路径**注意:**在模型路径“/models/pets/1”中，目录名“pets”应该与模型名环境变量相匹配，/1表示模型的版本，可以使用这个版本号升级模型。
-e MODEL_NAME=pets —指定模型名称环境变量
tensorflow/serving —指定要下载的 docker 图像名称
执行该命令后，您应该会得到以下输出:
现在，我们已经在localhost:8501上设置了模型服务器，让我们开发可视化 web 界面，它将使用 REST API 调用来使用模型。
使用引导程序对烧瓶 App 进行编码
现在，我们将遍历app.py文件，它将作为应用程序的控制器。这里，我们正在创建 flask app 的一个实例，并向接受 GET 和 POST 请求并将上传的图像保存在静态文件夹中的index.html 添加一个默认路由，然后静态文件夹调用 model.get_prediction 函数来获取预测并将其传递给result.html。
我们将简单地在 bootstrap 类中传递 app 实例，以便在 html 文件中使用 Bootstrap 功能。
我们可以在index.html 中编写一个完整的 html 代码，也可以使用 jinja 模板引擎将其分解成组件。现在，为了在我们的 html 文件中使用 bootstrap 和一些常见功能，我们将编写一个base.html ，它将从 Bootstrap 扩展base.html ，并设置应用程序的标题和定义内容块占位符。
接下来，我们编写一个index.html ，在其中我们扩展了 base.html，并进一步开发了上传图像的功能。
使用下面的代码在result.html中显示来自模型的预测和输入图像
到目前为止，TensorFlow 服务器已经启动，可视化 web 界面开发也接近完成，让我们通过在model.py 中编写一个小函数来连接这两个独立的实体，该函数将在 JSON 对象中加载、预处理和编码图像，并使用MODEL_URI向模型服务器发出 post 请求，并对模型预测执行后处理。
设置环境并运行应用
为避免现有安装出现问题，建议为此应用创建一个新的虚拟环境。
*先决条件:*请安装 anaconda 用于管理虚拟环境。
让我们创建一个虚拟环境并通过执行以下命令安装 flask 及其依赖项。
conda create –n flaskapp python=3.7
conda activate flaskapp
pip install tensorflow==2.1.0 flask flask-bootstrap requests pillow grpcio grpcio-tools
转到保存app.py 的目录，使用以下命令启动 flask 应用程序，但要确保 TensorFlow 服务的 docker 实例已经启动并正在运行。
python app.py
如果您获得以下输出，这意味着应用程序在本地主机上成功运行。
flask 的默认端口是 5000，因此通过键入localhost:5000 在浏览器中访问该应用程序，您应该会看到以下输出。
在上传猫图像并按下上传按钮后，应用程序将显示以下结果。
就是这样—模型部署从未如此简单。您刚刚学习了如何通过 docker 和 minimal flask web framework 利用 TensorFlow 服务的能力来构建一个简单的 AI 应用程序。
本教程是所有希望开发令人兴奋的人工智能应用程序的新手的快速入门。你可以在 Keras ( 这里)找到很多预先训练好的模型，在 Github 可以找到本教程的完整代码。
请在评论中留下您的疑问、反馈或建议。敬请关注更多内容！
在 Windows 上部署 Flask
一次悲伤痛苦的自我反省之旅。
塔达斯·萨尔在 Unsplash 上拍摄的照片
NB: 如果你会用 linux 请做！我不得不在我的公司使用 Windows，因为它不会给我们 linux 系统。因此，经过一番折腾之后，我不得不弄清楚如何部署 flask API。
对于这篇短文，我不会详细介绍 flask API 的实际创建，而是更多地介绍如何部署。这里是一个超级浓缩的一步一步让一个 flask API 运行。
安装:
pip install flask waitress
你会注意到我们正在安装女服务员，这是一个 Windows 兼容的服务器，我们可以使用它在多线程上部署我们的 flask 应用程序。这实际上是一个非常好的方法！下面是我们的 API 代码:
API 代码:
from flask import Flask
from waitress import serveapp = Flask(__name__)
[@app](http://twitter.com/app).route('/api/v1/')
def myendpoint():
return 'We are computering now'**serve(app, host='0.0.0.0', port=8080, threads=1) #WAITRESS!**
从上面可以看出，我们有一个超级复杂的 API，可以在运行时从浏览器调用:
python server.py
我们应该能够导航到http://myIP:8080/API/v1并得到预期的响应。
这一切都很好，但现在该怎么办呢？在 Windows 上，我们如何确保它在启动时运行？任务调度器是我如何做的。首先，确保你有管理员权限，然后打开任务调度。****
创建任务时，有一些非常重要的设置:
- 确保您选择了最高权限框
2.触发任务在启动时运行
3.确保你使用 pythonw 在后台运行(否则你将永远有一个命令提示)
4.使用 python 文件所在的起始目录。
嘣！这样，您应该能够点击 run 并测试您的端点。运气好的话，下次重新启动时，作业应该会触发并运行！
我真心希望这能在未来帮助一些可怜的灵魂。一路平安。
参考文献:
很多这只是实验和快照是我自己的！
使用 FLASK 将 H2o 模型部署为 API 的初学者指南
模型训练、调优和创建简单 API 的端到端示例(没有技术术语)。
我保证，如果你一直关注这篇文章，它将会是(来源:makeameme.org)
作为一名数据科学家，我们大部分时间都花在数据预处理(或者说数据角力)、模型训练、超参数调优、模型验证等方面。然而，数据科学家戴的帽子越来越多，因此，许多行业现在开始寻找能够将他们的 ML 模型转化为 API 的人。
这到底是什么意思？意思是:
- 你建立了一个非常精确的 ML 模型。
- 您现在希望其他人能够利用您的模型进行预测(因为您很好，或者因为它有利可图，或者两者兼而有之)，而不需要他们看到您的整个代码。这就是 API 的用武之地…
什么是 API？
API 允许我们建立一个连接，以便外部人员可以从服务器请求数据，向服务器发送新信息，更改服务器上的现有数据以及删除服务器上的现有数据。
用更简单的术语来解释(为了本文的目的)，API 是一个接口，当用户从前端请求数据时，它允许您在后端访问和操作数据(来自数据库或其他数据源)。Flask 是在后端编写数据科学 API 的最流行的 python 框架之一。
为了测试您的 API，您可以在本地运行后端服务器，默认情况下它运行在 localhost URL (http://127.0.0.1)上。这个 URL 后跟一个端口，比如说 5000，这样整个 URL 看起来就像http://127.0.0.1:5000。端口可以在 Flask 设置中更改，这样如果你想运行多个本地服务器，你可以在http://127.0.0.1:5000、http://127.0.0.1:5001等等上运行它们。
在本文中…
我们将使用 H2o AutoML 建立一个机器学习模型(使用非常少的代码行，但生成高性能的模型)。我们的模型将能够根据某些特征来预测贷款申请是被批准还是被拒绝。接下来，我们将创建我们的第一个 API，我们将向它发送一个关于客户年龄、汽车类型、贷款金额等的查询，它将返回申请的状态——批准或拒绝。
注:我将使用 Jupyter 笔记本构建和测试 H2o 模型，使用 Spyder 编写烧瓶代码。最后，我也将从 Jupyter 内部访问我的 API。
一步步走向 APIs
在我们开始为模型编写简单的 API 之前，我想简单地体验一下编写更简单的 API(不需要用户输入)的感觉。让我们开始驾驶 Spyder …
下面是我们将要使用的一些样板代码(稍后会对其进行修改):
from flask import Flask
from flask_restful import Resource, Apiapp = Flask(__name__)
api = Api(app)class HelloWorld(Resource):
def get(self):
return {'hello': 'world'}api.add_resource(HelloWorld, '/')if __name__ == '__main__':
app.run(debug=True, port = 12345)
需要注意的几件事:
- 这里的返回属于类型
dict，即一个键-值对(键是hello；值为world。 debug = True支持代码重载和更好的错误消息。切勿在生产环境中使用调试模式！- 重要的是使用
api.add_resource将您创建的任何资源(比如HelloWorld)添加到 API 中。 - 端口被显式指定为
port = 12345，因为有时默认端口可能被其他应用程序使用，并可能抛出错误。
最后，将文件保存为 medium_tut.py ，并使用顶部的绿色运行按钮(或 Mac 上的 F5)运行它。右侧控制台窗格中的输出应该如下所示:
如您所见，API 正在本地服务器[http://127.0.0.1:12345/](http://127.0.0.1:12345/.)上运行。现在打开 Jupyter Notebook 并键入以下代码来访问我们刚刚编写的 API。
from requests import get
import requestsurl = '[http://127.0.0.1:12345/'](http://127.0.0.1:12345/')
get(url).json()
写你的第一个 API 值得称赞。😃
如果您仔细注意，我们在HelloWorld中的 get 函数的返回类型是dict，因此我们在上面的代码中使用.json()来解析该字典的输出。
编写接受一个输入参数的 API
我们将修改我们之前在medium_tut.py文件中的代码，从用户端接受一个参数(更具体地说是一个数字),并将它的平方返回给用户。
from flask import Flask
from flask_restful import Resource, Api, **reqparse**app = Flask(__name__)
api = Api(app)***# argument parsing*
parser = reqparse.RequestParser()
parser.add_argument('num1')**class HelloWorld(Resource):
def get(self):
return {'hello': 'world'}**class PrintSquare(Resource):
def get(self):
*# use parser and find the user's input*
args = parser.parse_args()
user_query = float(args['num1'])
return {'ans': user_query * user_query}**api.add_resource(HelloWorld, **'/hello'**)
**api.add_resource(PrintSquare, '/sq')**if __name__ == '__main__':
app.run(debug=True, port = 12345)
评估我们所做的修改:
- 我们已经使用
parser.add_argument()将用户输入(在我们的例子中是一个数字)添加到解析器中。 - 我们现在有了一个新的类
PrintSquare来返回数字的平方。 - 由于我们现在有多个类，并且我们不希望在用户发出请求时混淆 API 应该运行哪个函数，我们必须通过添加
'/hello'作为端点来更新HelloWorld的add_resource。所以现在，HelloWorld将运行在[http://127.0.0.1:12345/](http://127.0.0.1:12345/.)hello而不是[http://127.0.0.1:12345/](http://127.0.0.1:12345/.)上
让我们看看是否可以访问我们的 API，回到 Jupyter 笔记本:
*# note the URL has been updates, i.e. the 'sq' endpoint has been added to it*
url = '[http://127.0.0.1:12345/sq'](http://127.0.0.1:12345/sq')*# we have one input parameter 'num1'*
params = {'num1': '2'}*# outputting the response from API*
response = requests.get(url, params)
response.json()
编写采用多个输入参数的 API
更新 Spyder 上的medium_tut.py文件，以接受来自用户的两个数字作为输入，并返回其总和。
from flask import Flask
from flask_restful import Resource, Api, reqparseapp = Flask(__name__)
api = Api(app)*# argument parsing*
parser = reqparse.RequestParser()
parser.add_argument('num1')
**parser.add_argument('num2')**class HelloWorld(Resource):
def get(self):
return {'hello': 'world'}class PrintSquare(Resource):
def get(self):
*# use parser and find the user's input*
args = parser.parse_args()
user_query = float(args['num1'])
return {'ans': user_query * user_query}**class PrintSum(Resource):
def get(self):
# use parser and find the user's inputs
args = parser.parse_args()
num1 = float(args['num1'])
num2 = float(args['num2'])
return {'ans': num1 + num2}**api.add_resource(HelloWorld, '/hello')
api.add_resource(PrintSquare, '/sq')
**api.add_resource(PrintSum, '/sum')**if __name__ == '__main__':
app.run(debug=True, port = 12345)
最后检查 API 是否在 Jupyter Notebook 中工作:
url = '[http://127.0.0.1:12345/sum'](http://127.0.0.1:12345/sum')*# we have two input parameters - 'num1' & 'num2*
params = {'num1': '2', 'num2': '5'}response = requests.get(url, params)
response.json()
瞧，你已经准备好为自己的 ML 模型创建 API 了。
提示:继续在桌面上(或其他地方)创建一个新目录，命名为H2o_API。这是我们将保存 Jupyter 笔记本的地方，该笔记本包含训练我们的模型的代码。稍后，当我们创建 API 脚本(在 Spyder 中)时，它也将保存在同一个目录中。这样做的全部逻辑是，当我们在本地创建和下载模型时，我们的 Flask 脚本可以访问它。
让我们深入研究数据
我们的数据集有 5 个预测特征:
- 年龄组:(老年、青年、中年)
- 汽车类型:分类(敞篷车、轿车、SUV)
- 贷款金额:浮动
- 存款:浮动
- 地区:分类(农村、城市)
以及一个结果变量，即应用 _ 结果，它可以取两个值:批准或拒绝。
我们的数据看起来是这样的:
将训练集和测试集转换为 H2o 框架
#Categorical Columns - enum
#Numerical Columns - real
col_dict = {'age_group' : 'enum',
'car_type' : 'enum',
'loanamount' : 'real',
'deposit' : 'real',
'area' : 'enum',
'application_outcome': 'enum'}train_h2o = h2o.H2OFrame(train, column_types = col_dict)
test_h2o = h2o.H2OFrame(test, column_types = col_dict)
使用 H2o AutoML 进行培训
自动机器学习(AutoML)是将机器学习应用于现实世界问题的端到端过程自动化的过程。使用 H2o 的 AutoML 接口可以很容易地执行(我将在下一篇文章中深入讨论)。简而言之，它提供了一个由许多模型的自动训练和调整获得的顶级模型组成的排行榜。
现在，让我们把它载入我们的 Jupyter 笔记本:
from h2o.automl import H2OAutoML
aml = H2OAutoML(max_models = 5, max_runtime_secs=100, seed = 1)
设置预测值和响应特征:
*# setting predictor and response features*
x = ['age_group', 'car_type', 'loanamount', 'deposit', 'area']
y = 'application_outcome'
训练过程可以简单地使用 H2o 中的一行代码来实现。
*# Training*
aml.train(x=x, y='application_outcome', training_frame=train_h2o, validation_frame=test_h2o)
最佳模型(基于默认指标 AUC)存储在aml.leader中:
aml.leader
正如你所看到的，即使没有太多的修改，我们已经在验证集上获得了 AUC = 0.87 的模型(一点也不差)！还有，注意这个模型的名字是StackedEnsemble_AllModels_AutoML_20200619_172405。您的模型的名称将类似于此，减去最后一个下划线后的部分，即172405。
将最佳模型保存到本地机器上
*# download the model built above to your local machine*
my_local_model = h2o.download_model(aml.leader, path="/Users/UserName/Desktop/H2o_API")
如果您在您的目录中检查这个保存的模型的名称，它将看起来像StackedEnsemble_AllModels_AutoML_20200619_******。
为您的模型创建 API
创建新的 python 脚本pred_API.py来编写我们的 Flask 脚本。
导入库和加载模型
from flask import Flask
from flask_restful import Resource, Api, reqparseapp = Flask(__name__)
api = Api(app)import h2o
import pandas as pd
h2o.init()*## load trained model*
model_path = 'StackedEnsemble_AllModels_AutoML_20200619_******'
uploaded_model = h2o.load_model(model_path)
解析输入参数
*# argument parsing*
parser = reqparse.RequestParser(bundle_errors=True) *# if there are 2 errors, both of their msgs will be printed*parser.add_argument('age_group', choices = ('Young', 'Older', 'Middle-Aged'), help = 'Bad Choice: {error_msg}. Valid choices are Young, Older, Middle-Aged')parser.add_argument('car_type', choices = ('SUV', 'Saloon', 'Convertible'), help = 'Bad Choice: {error_msg}. Valid choices are SUV, Saloon, Convertible')parser.add_argument('loanamount')parser.add_argument('deposit')parser.add_argument('area', choices = ('urban', 'rural'), help = 'Bad Choice: {error_msg}. Valid choices are urban, rural')
在将分类特征的值添加到解析器中时(比如age_group和car_type，我们将choices设置为一个元组，其中包含该特征可以采用的所有可能值。如果遇到选项中未提及的值，它将抛出help中指定的错误消息。
最后，我们设置bundle_errors = True，这样在两个错误的情况下，两个错误消息都被打印出来。例如，在下面的示例中，我们故意将age_group的值设置为‘older ’,将car_type的值设置为‘SUVv ’:
定义预测类
*#Categorical Columns - enum
#Numerical Columns - real*
col_dict = {'age_group' : 'enum',
'car_type' : 'enum',
'loanamount' : 'real',
'deposit' : 'real',
'area' : 'enum',
'application_outcome': 'enum'}*# prepare empty test data frame to be fed to the model*
data = {}*# results dict*
item_dict = {}class LoanPred(Resource):
def get(self):
args = parser.parse_args()
age = args['age_group']
car_type = args['car_type']
loanamount = float(args['loanamount'])
deposit = float(args['deposit'])
area = args['area']
application_outcome = 'declined' *#setting as default to declined (can set it as 'approved' as well, doesn't matter)*
*# put key:value pairs in empty dict called data*
data['age_group'] = age
data['car_type'] = car_type
data['loanamount'] = [loanamount]
data['deposit'] = [deposit]
data['area'] = area
data['application_outcome'] = application_outcome
*# creating dataframe from dict*
testing = pd.DataFrame(data)
*# converting pandas to h2o dataframe*
test = h2o.H2OFrame(testing, column_types = col_dict)
*# making predictions*
pred_ans = uploaded_model.predict(test).as_data_frame()
*# put key:value pairs in empty dict called item_dict*
item_dict['Prediction'] = pred_ans.predict.values[0]
item_dict['Approved'] = pred_ans.approved.values[0]
item_dict['Declined'] = pred_ans.declined.values[0]
return{'ans': item_dict}
api.add_resource(LoanPred, '/')if __name__ == '__main__':
app.run(debug=True, port= 1234)
我们首先获取所有输入参数，并使用它们创建一个名为testing的 pandas 数据帧。该数据帧必须转换成名为test的 H2o 帧，然后才能提供给 H2o 模型进行预测。
需要注意的一点是，model.predict()的输出是一个 h2o 帧，目前，Spyder ipython 控制台无法正确显示 H2o 数据帧(您可以在 Github 上的这里跟踪问题)。因此，我们需要使用as_data_frame()将model.predict()的输出显式转换为 pandas 数据帧。输出pred_ans是包含三列的数据帧—
- 最终预测(批准或拒绝)，
- 申请被批准的概率，
- 申请被拒绝的概率。
我们将这三个值作为键值对存储在item_dict中。
最后将 pred_API.py 中的所有代码放在一个地方:
from flask import Flask
from flask_restful import Resource, Api, reqparseapp = Flask(__name__)
api = Api(app)import h2o
import pandas as pd
h2o.init()## load saved model
model_path = 'StackedEnsemble_AllModels_AutoML_20200619_******'
uploaded_model = h2o.load_model(model_path)# argument parsing
parser = reqparse.RequestParser(bundle_errors=True) #if there are 2 errors, both's msg will be printed
parser.add_argument('age_group', choices = ('Young', 'Older', 'Middle-Aged'), help = 'Bad Choice: {error_msg}. Valid choices are Young, Older, Middle-Aged')
parser.add_argument('car_type', choices = ('SUV', 'Saloon', 'Convertible'), help = 'Bad Choice: {error_msg}. Valid choices are SUV, Saloon, Convertible')
parser.add_argument('loanamount')
parser.add_argument('deposit')
parser.add_argument('area', choices = ('urban', 'rural'), help = 'Bad Choice: {error_msg}. Valid choices are urban, rural')#Categorical Columns - enum
#Numerical Columns - real
col_dict = {'age_group' : 'enum',
'car_type' : 'enum',
'loanamount' : 'real',
'deposit' : 'real',
'area' : 'enum',
'application_outcome': 'enum'}#prepare empty test data frame to be fed to the model
data = {}# results dict
item_dict = {}class LoanPred(Resource):
def get(self):
args = parser.parse_args()
age = args['age_group']
car_type = args['car_type']
loanamount = float(args['loanamount'])
deposit = float(args['deposit'])
area = args['area']
application_outcome = 'declined'
# put key:value pairs in empty dict called data
data['age_group'] = age
data['car_type'] = car_type
data['loanamount'] = [loanamount]
data['deposit'] = [deposit]
data['area'] = area
data['application_outcome'] = application_outcome
# creating dataframe from dict
testing = pd.DataFrame(data)
# converting pandas to h2o dataframe
test = h2o.H2OFrame(testing, column_types = col_dict)
# making predictions
pred_ans = uploaded_model.predict(test).as_data_frame()
# put key:value pairs in empty dict called item_dict
item_dict['Prediction'] = pred_ans.predict.values[0]
item_dict['Approved'] = pred_ans.approved.values[0]
item_dict['Declined'] = pred_ans.declined.values[0]
return{'ans': item_dict}
api.add_resource(LoanPred, '/')if __name__ == '__main__':
app.run(debug=True, port= 1234)
访问 API 以获得预测
在朱庇特的笔记本上:
*# Normal API call with all inputs in correct format*url = '[http://127.0.0.1:1234/'](http://127.0.0.1:1234/')params = {'age_group': 'Young', 'car_type': 'SUV', 'loanamount': '12342', 'deposit': '2360', 'area': 'rural' }response = requests.get(url, params)
response.json()
我们走吧…我们已经成功地进行了 API 调用，并从 H2o 中训练的模型中检索预测。现在你所要做的就是找到一个朋友，他能把这个 API 输出变成一些漂亮的网络应用程序。
结论
这是对为 ML 模型创建 API 的概念的热情介绍。希望这不会太可怕，并且描述足够详细，可以帮助您理解相关的本质。所有代码都可以在 Github 上找到。
在下一部分中，我们将学习如何使用 Flask 和 Bigquery APIs 根据用户查询参数从 Bigquery 数据集中提取数据。
直到下一次:-)
在 Heroku.com 部署 Julia 项目
嗨！今天我将向你展示如何在云应用平台 Heroku 上用 Julia 编程语言部署项目。在本例中，我将部署一个 Dashboards.jl 文件进行演示。
这篇博客的所有内容都来自我的 GitHub 库，最终产品是这里的。请稍后查看示例:)
在我们开始之前，您将需要以下内容:您的 Dashboard 文件、一个 Heroku 帐户、一个 Julia 安装，以及安装的 Heroku 命令行界面 (CLI)。对于这个例子，我将在这里使用来自的仪表板文件。
现在，您可以创建一个新文件夹来存储部署应用程序所需的所有文件。这里，我将使用文件夹juliadash作为示例目录。之后输入julia进入茱莉亚。
mkdir juliadash
cd juliadash
julia
一旦你在 Julia 中，你将需要创建一个新的项目，包含Project.toml和Manifest.toml文件，包含你需要使用的软件包和注册表的版本信息。以下代码使用这两个文件激活您的新环境，并添加您的应用程序所需的包，然后将所有信息存储在这两个文件中。
using Pkg; Pkg.activate(".")
Pkg.add("Dashboards") #Do this as many times as you need to, changing the string (containing the package name) every time.
Pkg.add("HTTP")
⋮
完成后，您可以关闭 cmd/终端窗口。
接下来，我们将创建一个Procfile，这是一个空白文件，Heroku 使用它来指导您的文件的部署。您需要创建名为 Procfile 的文件，并将以下代码行复制并粘贴到该文件中。
web: julia --project app.jl $PORT
您需要用您的应用程序的启动文件的文件名替换app.jl。然后，您可以将文件保存到您的应用程序所在的目录中。
现在，您的目录应该有您的仪表板文件、Project.toml、Manifest.toml以及Procfile。
由于您通常将仪表板应用程序托管在本地主机的一个端口上，您将需要替换您的主机方法和编号，因为 Heroku 将应用程序部署在一个随机端口上。如果您使用的是 HTTP.jl，您需要用以下内容替换您的端口:
主持方式:用"0.0.0.0"代替HTTP.Sockets.localhost
主机端口:将8080替换为parse(Int,ARGS[1])
(如果你想知道，parse(Int,ARGS[1])对应的是Procfile中的$PORT。)
这是我的 HTTP serve 函数的样子:(更多细节，请看我在这个存储库中的代码。)
HTTP.serve(handler, "0.0.0.0", parse(Int,ARGS[1]))
完成后，您可以在 cmd 或终端上打开一个新窗口，并通过键入以下内容登录 Heroku CLI 帐户:
heroku login
它应该会打开一个浏览器窗口，让您输入凭据。完成登录并关闭浏览器窗口后，您会发现自己已经登录。现在，您可以再次进入您的目录并部署您的应用程序。
请在下面的代码中将my-app-name替换为您希望调用应用程序的名称！
cd juliadash
git init
HEROKU_APP_NAME=my-app-name
heroku create $HEROKU_APP_NAME --buildpack https://github.com/Optomatica/heroku-buildpack-julia.git
git heroku git:remote -a $HEROKU_APP_NAME
git add .
git commit -am "make it better"
git push heroku master
一旦该过程完成，应用程序将被部署并投入使用！
这可能需要一段时间，但一旦完成，您就可以运行以下命令在浏览器上打开您部署的应用程序！
heroku open -a $HEROKU_APP_NAME
希望这有助于你了解更多关于使用 Heroku 部署应用程序的知识。这种方法不仅限于仪表板应用程序。
如果你想看看我做的最终产品，点击https://juliadash.herokuapp.com/了解一下！
**引用:**该库中的dashex.jl文件来自这里的！
使用 Tkinter 部署机器学习项目
以可执行文件格式部署免费机器学习项目的完整指南。
介绍
由于各种各样的开源库，现在开始探索数据集并使用 Python 中简单的机器学习(ML)算法进行一些初步预测是相对容易的。虽然，为了使这些训练好的模型在现实世界中有用，有必要共享它们，并使它们在其他用户机器上容易访问以进行预测。只有这样，机器学习才能被用来造福社会。
在本文中，我将带您了解如何轻松地为您的机器学习项目创建图形用户界面(GUI ),然后将您的应用程序作为可执行文件共享，该文件可以在其他机器上运行(无需最终用户安装 Python 或任何库！).如果您有兴趣了解更多，本文使用的所有代码(以及更多！)可在我的 GitHub 档案上获得。
迁移学习图像分类
为了转移我们对图形界面开发和部署的关注，在本文中，我们将使用 Tensorflow 上提供的 VGG16 预训练模型来轻松构建一个便携式图像分类器。在视频 1 中，有一个演示我们应用程序最终工作流程的快速动画。
视频 1: GUI 演示
迁移学习是一个研究领域，专注于将机器学习模型获得的有用知识转移到另一个模型，我们计划将该模型用于不同的(但在某种程度上仍然相关的)主题。这在处理有限的数据时特别有用(图 1)。
图 1:迁移学习工作流(来源)
迁移学习最常见的应用之一是计算机视觉。例如，在本文中，我们将使用在 ImageNet 数据集上预先训练的 VGG16 模型，以便快速构建一个健壮的图像分类器。事实上，ImageNet 数据集包含大量图像(1400 万)和大约 21000 个类，因此对于这种类型的任务来说非常完整。
研究人员目前正致力于将迁移学习技术应用于其他领域，如音乐[1]和文本分类[2]。
图形用户界面(GUI)
首先，我们需要导入所有必需的依赖项。
现在，我们可以利用 Tkinter 库来创建我们的图形界面(如视频 1 所示)。我们首先创建窗口的基础( root )，然后在它上面添加不同的元素，例如程序标题( tit )、框架( 框架 )加载图像以在框架上显示的按钮(choose _ image)和启动图像分类器的按钮(class _ image最后，我们实例化我们的 VGG16 模型并启动我们的 GUI ( 使用 root.mainloop() )。**
为了关联当用户按下两个 GUI 按钮中的任何一个时要执行的动作，我们可以定义两个在单击时被激活的函数( load_img() 和 classify() )。
在 load_img() 函数中，我们首先清除框架以防有任何附加的小部件，然后我们让用户上传图像，最后我们重新缩放并在窗口框架上显示图像及其文件名。
在 classify() 函数中，我们改为预处理我们的图像(使用 Keras 指南用于这个预训练的模型)并最终在帧上打印我们的分类器的前 5 个预测及其百分比置信度。
一旦我们的程序在本地运行良好，我们就可以将其导出为可执行的格式。
部署
将 Python 文件转换成可执行文件的最简单方法之一(对于 Windows 或 Linux 平台)是使用 Pyinstaller (图 2)。
图 2: Pyinstaller [3]
对于只有一个文件且没有太多依赖项的项目，只需一条命令行语句即可完成:
pyinstaller my_script_name.py
虽然，对于更复杂的项目，为项目创建一个虚拟环境并使用一个 Spec 文件可能是一个更好的主意，以便给 Pyinstaller 关于如何创建可执行文件以及包含什么资产的明确指示。在此链接可获得该项目的规格文件示例。
最后，如果我们的可执行文件可能需要不同的资产(例如图像、视频等)，那么使用 NSIS 将所有东西都包含在安装系统文件中可能是一个好主意(这样更容易在另一台机器上安装可执行文件和所有需要的依赖项)。
如果您有兴趣自己使用这个应用程序，可以在我的个人网站上找到下载链接。
此外，可以用来部署机器学习系统的一些替代技术正在使用:
这些技术现在被广泛使用，它们可以使机器学习模型很容易地在 Web 上获得，尽管它们很可能会产生托管费用(而不是使用可执行文件)。
希望您喜欢这篇文章，感谢您的阅读！
联系人
如果你想了解我最新的文章和项目，请在媒体上关注我，并订阅我的邮件列表。以下是我的一些联系人详细信息:
文献学
[1]音乐分类和回归任务的迁移学习，Keunwoo Choi，Gyö rgy Fazekas。访问地点:https://arxiv.org/abs/1703.09179
[2]使用卷积神经网络进行文本分类的迁移学习的实践者指南，Tushar Semwal，Gaurav Mathur。访问地点:https://arxiv.org/abs/1801.06480
[3] Pyinstaller。将 Python 程序冻结(打包)成独立的可执行文件 Github。访问地点:https://github.com/pyinstaller/pyinstaller
在分布式实时数据流应用中部署 ML 模型
探索在 Apache Flink/Spark 或其他实时数据流应用程序中部署 ML 模型的各种策略。
过去十年，机器学习从零到一。ML 的崛起可以被视为科技行业最具决定性的时刻之一。今天，ML 模型在几乎所有的服务中无处不在。
至今仍然存在的挑战之一是使用实时数据对模型进行训练和推断。让我们来看看在数据流生产作业中可以用来进行预测的各种策略。
沿着管道建模
对实时数据进行预测的自然方法是在处理数据的管道中运行 ML 模型。
在管道执行器中部署模型
这种方法有两个主要的复杂性-
- 管道代码和模型代码的集成。
- 优化集成管道以有效利用底层资源。
综合
大多数实时数据管道都是用 Java 或 Python 编写的。 Apache Spark 和 Apache Flink 都提供 Python API。这使得使用 Scikit-Learn 或 Tensorflow 编写的模型可以轻松集成。
您也可以使用 Spark MLlib 或 Flink ML 来创建模型。这些模型便于集成，您不必担心可伸缩性和容错性。
但是如果你有一个用 Java 或 Scala 编写的预先存在的数据管道呢？在这种情况下，使用 Tensorflow Java API 或第三方库(如 MLeap 或 JPMML )来导出您的 Scikit-learn 模型并在您的代码中使用它们更有意义。JPMML 支持很多模型，但是 MLeap 更快。
最佳化
Python 和 Java/Scala 之间的选择代表了通用性和性能之间的权衡。如果您根据用例、预期的数据量和预期的延迟做出决策，那将是最好的。对于大多数应用程序，我更喜欢 Scala，因为预期的输入记录是每秒数百万条。
另一个优化是您应该分配给模型的并行执行器的数量。如果是逻辑回归或小型随机森林等轻量级模型，您甚至可以运行模型的单个实例，并将数据重新分区到单个执行器(这在生产中从来都不是一个好主意)。对于大型随机森林或深度神经网络之类的大型模型，找到正确的执行者数量主要是一项反复试验的工作。
您可能还需要优化您的 ML 模型，以便它们能够适合内存。有几种工具可用于此目的。
TensorFlow Lite 是一个开源的深度学习框架，用于设备上的推理。
www.tensorflow.org](https://www.tensorflow.org/lite)
这种方法的另一个复杂之处是将模型更新到一个更新的版本。更新通常需要全新的部署。这也使得 A/B 测试相当重要。
作为 REST 服务的模型
这是最流行的推理方法之一。在 docker 容器中运行 python 代码，并提供一个 REST 接口来获得结果。Tensorflow 已经提供了开箱即用的 REST 模型。
将 ML 模型部署为服务
对于 Java，可以使用 MLeap 或者 DeepLearning4J。在这种方法中，您还可以根据吞吐量动态地增加/减少服务器的数量。
如果您的模型调用是异步的，这种方法在数据突发的情况下(比如在重启期间)无法触发背压。这可能会导致模型服务器中的 OOM 故障。必须采取额外的预防措施来防止这种情况。
延迟也很高，因为您需要一个网络调用来获取结果。通过使用 gRPC 代替 REST，可以稍微减少延迟。
实现自己的 http/2 服务。
codeburst.io](https://codeburst.io/heres-how-you-can-go-beyond-http-1-1-59e73f68bf75)
数据库作为模型存储
如果您有固定的模型架构，例如线性回归、随机森林或小型神经网络，权重可以存储在分布式数据库中，如 Cassandra。您可以在运行时使用权重创建模型，并对新模型进行预测。
将模型存储在数据库中
这种方法是第一种和第二种方法的混合。它允许您在运行时更新模型，而不需要新的部署，同时还提供了背压功能。这是以多功能性为代价的，因为您限制了模型的潜在选项的数量。
那么应该选择哪种方法呢？
好吧，如果你想做一个简单的 POC 或者你的模型非常轻量级，就用 REST 模型服务器。运行您的模型所需的易于集成和非常少的代码更改使它成为一个有吸引力的选择。A/B 测试也可以快速完成。
如果您需要在几十毫秒内进行预测，流水线方法是首选。
最后，模型存储方法应该只在有几个模型的情况下使用，例如，每个城市数据有一个 ML 模型，并且它们也是轻量级的。
在 Azure 上部署 ML 模型
在云上创建、构建和部署您自己的 ML 模型
凯文·Ku 在 Unsplash 上的照片
介绍
在我花了 3 年多的时间在 Jupyter Notebook 上开发机器学习模型之后，我从未能够将它部署到云上。您的线性回归模型有 90%的准确性，接近完美的 R 值，高 AUC(曲线下面积)是好的，但如果您的模型没有投入使用或部署，它还有什么用？
在本文中，我将逐步创建、训练一个模型，并将其部署到 Azure Machine Learning Studio 中。请注意，这篇文章大量引用了以下 Coursera 课程。当你完成一门在线课程时，一张证书并不能说明很多关于你的事情。因此，我借此机会复制我所学到的，并在 Azure 上部署我的模型。这是我参加的课程:
[## 在 Azure | Coursera 上开发 AI 应用
本课程介绍人工智能和机器学习的概念。我们将讨论机器学习…
www.coursera.org](https://www.coursera.org/learn/developing-ai-applications-azure/)
我使用了一个免费试用版，你将获得价值 200 美元的货币来创建你的工作空间和存储空间。下面是它的链接:
[## 立即创建您的 Azure 免费帐户| Microsoft Azure
开始享受 12 个月的免费服务和 200 美元的信用点数。立即使用 Microsoft Azure 创建您的免费帐户。
azure.microsoft.com](https://azure.microsoft.com/en-us/free/search/?&ef_id=CjwKCAjwqJ_1BRBZEiwAv73uwPdRAtO49bav1c3mKYqYc0DFn2bfSIesgq7i_EAbJPEHr5Bz3p1HmhoCrPgQAvD_BwE:G:s&OCID=AID2000643_SEM_vDZWyCyS&MarinID=vDZWyCyS_341302918553_free%20trial%20azure_e_c__65978285502_kwd-300666826690&lnkd=Google_Azure_Brand&dclid=CPKDiI_EjOkCFcWRjwodmAoHbA)
创建工作空间
首先，您必须创建一个工作空间来存储您为项目创建的所有实验、模型和结果。有三种方法可以做到。
- 工作区可以在 portal.azure.com创建。
2.可以使用 Azure CLI 创建工作区
3.可以使用 Azure Notebook 创建工作区
Azure 笔记本
我们将利用 Azure Notebook 在 Azure 上创建、训练和部署我们的模型。Azure 笔记本和 Jupyter 笔记本很像。如果您想在本地环境中使用 Jupyter Notebook，请随意。以下步骤仍然有效。
[## 微软 Azure 笔记本电脑
提供对运行在微软 Azure 云上的 Jupyter 笔记本的免费在线访问。
www.notebooks.azure.com](https://www.notebooks.azure.com/)
配置文件
您需要设置您的配置文件，以便可以在多种环境中引用您的工作区(例如，虚拟机、个人笔记本电脑、工作笔记本电脑等)。).更多信息请参考文档:https://docs . Microsoft . com/en-us/python/API/azure ml-core/azure ml . core . workspace . workspace？view=azure-ml-py
# Creating your configuration file
ws.write_config(path="./", file_name="ws_config.json")# View your configuration file
!cat .azureml/ws_config.json
模特培训
现在所有的“管理问题”都解决了，你终于可以开始训练你的模型了！
“哦不，在所有累人的步骤之后，我关闭了我所有的步骤和笔记本。我如何再次进入我的环境？”
别担心，这正是配置文件的目的。通过下面两行代码，您可以轻松地将工作区加载回笔记本
# Load your workspace in a brand new environment
from azureml.core import Workspace
ws = Workspace.from_config(path="./.azureml/ws_config.json")
现在，让我们用 Sklearn 提供的波士顿房价数据集创建一个非常简单的线性回归模型。我将不详细讨论这个模型，因为这不是本文的目的。
%%writefile my_sklearn_lr.py# Load the libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import os
import sklearn# Load Boston data
from sklearn.datasets import load_boston
boston_dataset = load_boston()# Train test split data
from sklearn.model_selection import train_test_split
num_Rooms_Train, num_Rooms_Test, med_price_Train, med_Price_Test = train_test_split(boston_dataset.data[:,5].reshape(-1,1), boston_dataset.target.reshape(-1,1))# Create Linear Regression model
from sklearn.linear_model import LinearRegression
price_room = LinearRegression()
price_room.fit (num_Rooms_Train,med_price_Train)
现在您已经有了一个名为 price_room 的模型，让我们将这个模型保存为一个 pickle 文件:
# Save the model
from sklearn.externals import joblib
os.makedirs("outputs", exist_ok=True)
joblib.dump(value=price_room, filename="outputs/bh_lr.pkl")
将模型注册到工作空间
将模型保存为 pickle 文件后，您可以将其上传到您的工作空间:
from azureml.core.model import Modelmodel = Model.register(workspace=ws, model_path="./outputs/bh_lr.pkl", model_name="boston_housing_lr")
哒哒！您的模型现在在您的 Azure 工作区中可用
使用 Azure ML 训练模型
如果你的电脑只有 2GB 的 RAM 怎么办(我相信这种可能性极小…)？你可以用 Azure ML Services 提供的资源来训练你的模型，而不是使用你的本地资源。导入相关库后，您可以查看所有可用的虚拟机:
from azureml.core.runconfig import RunConfiguration
from azureml.core.compute import AmlCompute
list_vms = AmlCompute.supported_vmsizes(workspace=ws)
print(list_vms)
我们将简单地使用标准 DS1 v2:
compute_config = RunConfiguration()
compute_config.target = "amlcompute"
compute_config.amlcompute.vm_size = "Standard_DS1_v2"
属国
为了让您的模型在云中工作，您需要指定依赖关系。将依赖视为购物清单。你告诉程序你做饭/训练你的模型需要什么样的杂货店/图书馆。
from azureml.core.conda_dependencies import CondaDependenciesdependencies = CondaDependencies()
dependencies.set_python_version("3.6.6")
dependencies.add_pip_package("scikit-learn==0.20.3")
dependencies.add_pip_package("numpy==1.16.2")
dependencies.add_pip_package("pandas==0.23.4")
dependencies.add_pip_package("matplotlib==3.0.0")
compute_config.environment.python.conda_dependencies = dependencies
要找出依赖项的版本，只需键入:
<INSERT YOUR LIBRARY>.show_versions()
# e.g. pd.show_versions()
在云中训练您的模型
现在是时候运行具有依赖项的模型了，配置是您之前设置的。警告，这一部分可能需要相当长的时间，特别是如果您的模型很复杂，并且您使用的 VM 处理能力很低。
from azureml.core.experiment import Experiment
from azureml.core import ScriptRunConfig# The script you specify here is the one you wrote to train your linear model
script_run_config = ScriptRunConfig(source_directory=".",script="my_sklearn_lr.py", run_config=compute_config)
experiment = Experiment(workspace=ws, name="boston_lr_model")
run = experiment.submit(config=script_run_config)
run.wait_for_completion(show_output=True)
如果你觉得无聊，你可以在你的 Azure 门户中查看日志和输出:
部署您的模型
如果一个模型不用于预测，那么它有什么用呢？让我们检索您之前在云中训练的模型，并进行一些预测。
- 找出你的模型在哪里
run.get_file_names()
2.下载您的模型
run.download_file(name="outputs/bh_lr.pkl")
3.将模型加载到您的本地环境中
from sklearn.externals import joblib
import numpy as nprun_model = joblib.load('bh_lr.pkl')
4.用你的模型做一些预测
run_model.predict(np.array([7.354]).reshape(-1,1))
5.如果不满意，重新培训模型。否则，您可以将模型注册到您的工作空间中
from azureml.core.model import Model# There are 2 ways to register your model into Azure ML# First way, using your environment
model = Model.register(workspace=ws, model_path="bh_lr.pkl", model_name="cloud_boston_lr")# Second way, using local file
run.register_model(model_name="cloud_boston_lr", model_path="outputs/bh_lr.pkl")
我们可以验证我们的两个模型都已上传:
结论
恭喜你！现在，您已经成功地在云上训练和部署了您的模型！不要玩弄工作室，并尝试部署其他模式，如 LSTM，有线电视新闻网，决策树，SVM 或任何你知道的模式。请充分利用所提供的 200 美元。
使用 TensorFlow 模型服务器将模型部署到生产环境中
来源:tensorflow.org
模型创建无疑是人工智能应用的一个重要部分，但在训练后知道什么也是非常重要的。我将展示如何通过 HTTP 和 HTTPS 服务 TensorFlow 模型，并使用 TF Model Server 轻松完成模型版本控制或模型服务器维护等工作。您还将看到为此所需的步骤以及您应该遵循的流程。我们还将了解 Kubernetes 和 GKE，以自动调整您的部署。
这篇博文中演示所用的所有代码和一些额外的例子都可以在这个 GitHub repo-上找到
我在谷歌开发小组艾哈迈达巴德的会议是关于用 TensorFlow 模型服务器将模型部署到生产中，30…
github.com](https://github.com/Rishit-dagli/GDG-Ahmedabad-2020)
我也在 GDG(谷歌开发者组织)艾哈迈达巴德发表过关于这个的演讲，在这里找到录音版本-
我演讲的录音版本
这里有同样的幻灯片-【bit.ly/tf-server-deck
我希望你已经和一些深度学习模型合作过，并且自己也做了一些模型，也可以和 Keras 一起做。
部署过程背后的动机
来源:me.me
这是对理想场景的非常准确的描述，您的模型在测试或开发环境中工作良好，当您将其应用到现实世界或生产环境中时，问题就开始出现，事情就开始失败。您还需要确保您的模型一直在运行，并且您的用户有一个与模型交互的简单方法。它还应该在所有平台上运行良好，无论是 web、Android、IoS 还是嵌入式系统。您需要一个有弹性的管道来为您的模型服务，并且需要一个有效的方法来传递数据。这些只是生产和开发之间的一些差异。
需要处理哪些事情？
- 打包模型
因此，首先您需要获得模型，并以一种您可以在生产环境中使用的方式对其进行打包。理想情况下，您不会将相同格式的 Jupyter 笔记本投入生产，如果您愿意，您可以这样做，但通常不建议这样做。
- 在云托管服务器上发布模型
然后，您会希望将您的模型托管在某个云托管的服务器上，这样您就可以为您的用户提供服务，在他们需要模型的任何时候为他们提供模型。
- 维护服务器
既然您已经将模型发布到了云托管的服务器上，那么您还需要维护它。当我说你需要维护服务器的时候，我提到的主要事情之一是自动伸缩。如果你经历了用户数量的增加，你应该能够处理好你的用户，也许是通过增加你的资源。
显示自动缩放过程的图表
- 全球可用性
您现在想要确保的另一件事是您的模型具有全球可用性。这也意味着特定地区的用户不会面临大量的延迟。
- 应用程序接口
在此之后，您还需要为您的模型提供一种与您的设备交互的方式，很可能您会提供一个 API 来使用。然后你可以调用这个 API，或者有人可以调用你的模型并得到预测结果。你还有另外一件事要维护和保持运行，那就是 API。
- 模型版本控制
因此，明天当你或你的团队对模型进行更新时，你需要确保你的用户获得你的模型的最新版本，我们将在某个时候详细讨论这一点。例如，假设您提供一些影像分类服务，您必须不断更新您的模型，以便它能够以良好的准确性预测新的可用影像。
什么是 TF 模型服务器？
现在，您已经知道了将您的模型实际部署到云托管的服务器或为您的模型提供服务需要做些什么，让我们看看什么是 TF 模型服务器，更重要的是，它如何在您的用例中为您提供帮助。
TF Serving 是 TFX 或 TensorFlow Extended 的一部分，简单来说 TF Extended 是一个 API，旨在帮助您制作生产就绪的机器学习系统。我们将只讨论 TFX 的一个特定子部分，叫做 TF 服务。
演员表:劳伦斯·莫罗尼
这就是创建一个成熟的 ML 解决方案所要做的全部工作。我希望您了解的是，建模不是创建部署的唯一部分，事实上，也不是主要过程。TF 服务帮助您轻松完成服务基础架构部分。
因此，您可能希望在多种设备上运行您的模型，可能是在移动设备、低功耗嵌入式系统或网络上。也许您可以使用 TF Lite 将其部署在移动设备和嵌入式系统上，或者创建您的模型的 JavaScript 表示并直接在 web 上运行。很多时候，拥有一个集中的模型是一个更好的主意，在这个模型中，您的设备可以发送一个响应，然后服务器会执行它们，并将它们发送回发出调用的设备。
展示 TF 服务如何运作的图表
还记得我们讨论过的模型版本化吗？在这样的架构中，你只需要在服务器上更新模型的新版本，你的所有设备就可以立即访问它。然而，如果你使用传统的方法，如发送应用程序更新，一些用户有新的模式，一些用户有旧的模式，造成了不好的体验。在基于云的环境中，要做到这一点，可以根据用户数量动态分配资源。
TF 服务让你很容易做到这一点，这样你就不会遇到“哦，我刚刚更新了我的模型，我的服务器坏了！”诸如此类的事情。现在让我们在实践中看到这一点。
实践中的 TF 服务
- 安装 TF 服务
所以当然在开始之前你需要安装 TF 服务。repo 中这个博客的代码示例已经为您输入了安装命令。安装非常简单，在这里找到安装步骤。
- 转换模型
所以，你已经有了一个模型，你要做的第一件事就是简单地把它保存成一种 TF Serving 可用的格式。这里的第三行directory_path显示了保存模型的位置，另外两行只是传递输入和输出-
tf.saved_model.simple_save( keras.backend.get_session(), directory_path, inputs = {'input_image': model.input}, outputs = {i.name: i for i in model.outputs})
如果您导航到您保存此模型的路径，您将会看到一个类似这样的目录结构，我也创建了一个目录1，这是我的模型版本，我们将看到 TF server 如何帮助我们管理和部署这些版本。还要注意你的模型保存在一个.pb扩展名中。
保存的模型目录
- 保存的模型 CLI
还有一个很棒的界面叫做保存模型 CLI，我觉得它非常有用。这为您提供了许多关于已保存模型的有用信息，如操作签名和输入输出形状。
!saved_model_cli show --dir [DIR] --all
以下是显示该工具提供的信息的示例输出-
保存的模型 CLI 输出
- 启动模型服务器
这是你启动模型服务器的方法，让我们来分解一下
os.environ["MODEL_DIR"] = MODEL_DIR%%bash --bgnohup tensorflow_model_server \ --rest_api_port = 8501 \ --model_name = test \ --model_base_path="${MODEL_DIR}" >server.log 2>&1
因此，这里的第三行告诉它使用 tensorflow 模型服务器，当然，在实际实现它时，您不会包括 bash magic cell，即代码行%bash --bg,但是作为 Iassume，您可能会使用 Colab，我已经添加了这一点，因为 Colab 不为您提供直接终端。
这里的第四行指定了运行 TF 模型服务器的端口，这也非常简单。
需要注意的是,--model_name也会出现在你服务模型的 URL 中，所以如果你有多个模型在运行，管理你的服务模型 URL 也变得容易多了。
这里的最后一行指定您想要启用日志记录，有时日志在调试时非常有用。我个人经常使用它们来很容易地找出错误。
执行推理
现在让我们进入最有趣的部分，对模型进行推理。
- 传入数据
在模型上执行推理时要记住的一点是，在传递数据时，数据应该是列表的列表，而不仅仅是列表。事实上，这对开发者来说是一个额外的优势。让我们看看这意味着什么-
xs = np.array([[case_1], [case_2] ... [case_n]])
这里的case_1、case_2……case_n都有x1、x2……xi的所有特性值。
- 为数据创建一个 JSON 对象
data = json.dumps({"signature_name": [SIGNATURE], "instances": xs.tolist()})
如果你对保存的模型有所了解，你可能知道SignatureDef，对于那些不知道它定义了张量流图中支持的计算签名的人来说。所以你可以支持函数的 I/O。通过saved_model_cli你可以很容易的找到。在实例部分，我们将放入刚刚创建的xs。
- 提出推理请求
现在你可以简单地提出一个推理请求-
json_response = requests.post(
'[http://localhost:8501/v1/models/test:predict](http://localhost:8501/v1/models/helloworld:predict)',
data = data,
headers = headers)
记住我们谈论的是版本，而不是它包含的模型 URLv1，它允许我们容易地指定我们想要使用模型的版本 1。您还可以看到 URL 中反映的型号名称test。
你的头应该是这样的，因为你是以 JSON 的形式传入数据的
headers = {"content-type": "application/json"}
- 图像！
你们中的很多人可能会觉得，看看自己如何传递图像会很有趣。事实上，这样做很容易。代替我们在上面看到的case_1，您只需用一个值列表来替换它，这些值构成了您的图像。
一些额外的优势
现在你已经知道了 TF 服务器是如何工作的，以及如何使用它。了解了这一点，这里还有一些它提供的东西。现在，您可以理解，如果我们假设您部署了模型的版本 2，在出现任何问题的情况下，您的版本 1 将仍然是活动的和可用的。
此外，当您的新型号版本部署时，您没有停机时间，您的旧版本将继续正常工作，这些事情通常非常有用。TF 模型服务器可以帮助你很容易地做到这一点。
- 关注真实代码
TF Model Server 的一个非常棒的地方是让您专注于编写真正的代码，而不是担心基础架构和管理它，这是非常有用的，作为开发人员，您不会想花时间做这些基础架构方面的事情。这反过来允许您构建更好的 ML 应用程序，并让它们更快地启动和运行。
在云上服务模型
我们现在看到的东西可以很好地扩展到云，使其更加强大，您可以随时拥有自己的服务器。我们不会在这里讨论为什么是云或内部部署，也不会讨论负载平衡是如何发生的。我们将看到一个使用 Kubernetes 在云上部署模型的简短工作流。有了 TF 模型服务器，这就变得容易多了。
- 创建集群
首先，我假设您已经训练了一个模型，并为它构建了一个 docker 映像。做到这一点的步骤非常简单，我也在本次会议的 GitHub repo 中列出了它们。我们将从创建一个包含 5 个节点的 Kubernetes 集群开始，我将向您展示如何在云上部署一个简单的resnet模型。
gcloud container clusters create resnet-serving-cluster --num-nodes 5
- 推送 docker 图像
docker tag $USER/resnet_serving gcr.io/[PROJECT_ID]/resnetdocker push gcr.io/[PROJECT_ID]/resnet
然后，您可以将 docker 映像推送到容器注册表中
- 创建部署
现在，您已经准备好创建部署了，此处显示的 YAML 文件将为部署创建元数据，如您的映像和所需的复制副本数量，我在报告中为您提供了一个示例。
kubectl create -f [yaml]
另一件要记住的事情是，当使用云上托管的模型执行推理时，您现在将使用外部 IP 来进行推理请求，而不是我们之前使用的localhost。
我们从为什么部署过程是值得的开始。然后我们看到了部署您的模型所需要的东西，版本、可用性、全球性、基础设施等等。然后我们看到了 TF Model server 为我们提供了什么，以及为什么您应该选择 TF Model server 来进行部署。然后我们看到了与 TF 模型服务器相关的过程。您还看到了它如何允许您编写真正的代码，而不必担心基础设施、版本明智的 URL 以及对它们的简单管理。然后，我们开始研究如何在云上复制这一点，并了解 Kubernetes 如何让这一点变得简单。
我为你准备了几个笔记本，它们实现了你在这篇文章中看到的所有内容，你可以自己尝试一下。
关于我
大家好，我是里希特·达利
如果你想问我一些问题，报告任何错误，建议改进，给我反馈，你可以发邮件给我
使用 Heroku 容器注册中心部署 Panel (Holoviz)仪表板
交互式 Python 仪表盘
这篇文章旨在为使用 Heroku 部署面板应用程序提供一个简要的指南。当前的面板文档使用 Heroku 的默认应用程序构建，没有涵盖这里概述的大部分过程。
个人副业的福分之一就是选择和探索的能力。我最近开始了这样一个项目，主要是出于对全球变暖及其与我们宏观经济活动的联系的好奇。这让我经历了一个激动人心但有时也很痛苦的过程，我总结如下:
使用世界银行的 API 进行数据提取(高难度)→用于建模的数据准备(EDA)(高难度)→数据建模(低难度)
对我来说，最有趣的发现是，全国平均气温可能不一定是一个微不足道的概念。在某些情况下，我发现在同一气候带的国家之间，测量期间的温度变化很大；这是我们的宏观经济活动对气温产生重大影响的一个潜在迹象。不过，需要提醒的是，还需要更多的研究。对于任何有兴趣浏览研究结果或该项目的任何其他方面的人，这里有链接。
仪表板建筑
鉴于我已经经历了组织这个困难的数据集的过程，我不希望这个附带项目保持独立。我想建立一个仪表板，使我能够通过点击世界地图上的国家来查看每个国家的数据(我的数据是按国家排列的)。我还希望这张地图有一个显示每个国家温度变化(基于指数)的色标。最后，仪表板还必须在网上公开。
基于我对 Python 可视化/部署工具的了解，我期望花很多时间找到合适的库来实现这一点。令我惊讶的是，我发现 Anaconda 的 Holoviz 生态系统，由几个可视化、dashboarding 和部署工具组成，是我计划的一站式商店。
Holoviz 是所有这些多用途工具的集合
我不会进入代码或我如何建立仪表板的细节；有足够的材料可以带你经历这些。这些教程是一个很好的开始。
部署
现在这个帖子的关键来了。这是我旅程中在互联网上找不到太多直接帮助的部分。Panel 库(Holoviz 的一部分)为管理数据交互、设置管道、使用小部件和部署动态仪表板提供了一个优秀的工具包。部署就像用。servable()。这只有在部署在您的本地环境中时才成立。但是当涉及到像 Heroku(我将在这里讨论)这样的云服务器时，你很可能会遇到问题。然而，我希望这个简短的演练将有助于解决这些问题。
web 部署的问题
1.当我开始使用 Heroku 进行部署时，我遇到的第一个问题是我环境中的许多包无法通过 pip 获得；因此，应用程序构建阶段不断失败。
2.为了纠正上述问题，我尝试了几个定制的第三方构建包，它们应该能够处理基于 conda 的环境，但没有一个对我有效。
3.即使我很幸运地找到了一个 buildpack，我意识到我的环境超过了 3GB，而 Heroku 只允许最大 500 MB 用于这样的部署。
4.Panel library 文档中的另一个选项是使用 MyBinder 进行部署，我试过了，但还是无法构建我的环境。
解决办法
通过创建 docker 文件使用 Heroku 容器注册表进行部署解决了这个问题。这是 Heroku 提供的三个部署选项中的第三个。其次，我没有使用环境文件，而是在 docker 文件中使用单独的库安装命令(这提供了更多的稳定性；然而，如果使用环境文件是强制性的，这里有一个指南。
用近乎外行的语言快速浏览 Docker
3 个重要的 docker 概念:
-
Docker 容器:一个更简单/更快速的虚拟机替代品。因此，您可以在 Docker 容器中复制您的本地环境，该容器可能运行在提供商的平台上(在本例中为 Heroku ),并在其上运行您的应用程序。
-
Docker 镜像:构建和运行 Docker 容器的指令。
-
Dockerfile :包含 docker 图像蓝图的文本文件。
以下是我用来部署我的应用程序的 docker 文件:
# Starting from base miniconda image
FROM continuumio/miniconda3# Setting working directory in destination
WORKDIR /app# This is the complete set of libraries required
RUN conda install -c pyviz holoviz
RUN conda install -c pyviz geoviews-core
RUN conda install geopandas# Copy the relevant folder into the container
COPY ./dep-test/ .# Run panel serve to start the app
CMD panel serve --address="0.0.0.0" --port=$PORT main.py --allow-websocket-origin=worldbank-climate-dashboard.herokuapp.com
我的重点是最后一个 CMD 命令；但是为了理解这一点，有必要简要介绍一下 Panel 的部署系统:
本地部署使用。servable()
我提到过。servable()方法。什么时候。servable()附加到一个 panel 对象，该对象是使用 Tornado web 服务器部署的。因此，假设我有一个 python 文件或一个 jupyter 笔记本(在上面的例子中是它的 main.py ),其中包含一个带有可显示面板对象的仪表板的全部代码，我决定使用。servable()。要访问已部署的版本，我必须使用命令提示符浏览到我的项目文件夹(注意，提示符应该在适当的 conda 环境中),并输入以下命令:
panel servefilename . py或 filename.ipynb →这将在 Tornado web 服务器中打开应用程序，并为您提供使用浏览器访问它的链接。链接通常是: http://localhost:5006/ 文件名
Web 部署使用。servable()
使用 Heroku 的 Web 部署是类似的。使用上面的 Dockerfile 文件，我们已经设置了所需的环境。CMD 命令使您能够在 shell 中运行命令；因此，这就是我们使用面板服务的地方。以下是您将如何根据自己的应用程序自定义上述 docker 文件中的 panel serve 命令:
CMD panel serve --address="0.0.0.0" --port=$PORT ***main.py*** --allow-websocket-origin=***worldbank-climate-dashboard***.herokuapp.com
考虑上面粗体和斜体部分，您将执行以下操作:
- 用包含仪表板代码的文件替换 main.py
- 将world bank-climate-dashboard替换为您在 Heroku 中为应用程序选择的名称
如果你还没有帐户，下一步就是注册 Heroku(这是免费的)。他们的网络用户界面很棒，会引导你完成应用简介的创建过程。最后，在 Heroku 的 web UI 的应用程序部署部分，您将看到三种部署方法:
- Heroku Git(使用 Heroku CLI)
- Github(连接到应用程序的 Github Repo)
- 容器注册表(使用 Heroku CLI)
选择容器注册表，将显示必要的程序。只需记住 Heroku 提供的命令的以下附加内容:
$ heroku container:push web -a 'name of your app'
$ heroku container:release web -a 'name of your app'
我的朋友们。万事如意！
PS:这里有一个仪表盘回购的链接。
整理您的 Python 脚本并连接到外部 SQL Server
Docker、Python 和 SQL Server
查看了许多链接和教程后，我决定编写一个简单的指南，介绍如何将 Python 脚本部署到 Docker 容器，然后连接到外部 SQL Server 实例，并使用 pyodbc 执行简单的插入命令。
编写本指南时，假设您已经具备:
- Docker 安装完毕，转而使用 Linux 容器
- SQL Server 实例正在运行
您需要创建 3 个文件:
- Dockerfile 文件
- main.py(这是您的主要 Python 代码)
- requirements.txt
Dockerfile 文件
FROM python:3WORKDIR /appADD requirements.txt .
ADD main.py .#Optional
ENV https_proxy=[http://[](http://proxy1.uk.webscanningservice.com:3128)proxy]:[port]
ENV http_proxy=[http://[](http://proxy1.uk.webscanningservice.com:3128)proxy]:[port]# install FreeTDS and dependencies
RUN apt-get update \
&& apt-get install unixodbc -y \
&& apt-get install unixodbc-dev -y \
&& apt-get install freetds-dev -y \
&& apt-get install freetds-bin -y \
&& apt-get install tdsodbc -y \
&& apt-get install --reinstall build-essential -y# populate "ocbcinst.ini" as this is where ODBC driver config sits
RUN echo "[FreeTDS]\n\
Description = FreeTDS Driver\n\
Driver = /usr/lib/x86_64-linux-gnu/odbc/libtdsodbc.so\n\
Setup = /usr/lib/x86_64-linux-gnu/odbc/libtdsS.so" >> /etc/odbcinst.ini#Pip command without proxy setting
RUN pip install -r requirements.txt#Use this one if you have proxy setting
RUN pip --proxy [http://](http://proxy1.uk.webscanningservice.com:3128)[proxy:port] install -r requirements.txtCMD ["python","-i","main.py"]
main.py
main.py 可能的样子示例
requirements.txt
- 选项 1
创建一个文本文件并添加一行，如下所示:
pyodbc==4.0.28
- 选项 2
如果您使用 PyCharm 或任何终端并运行 pip freeze 命令，请使用 Python 终端:
pip freeze > requirements.txt
这将产生一个包含所有必需模块的文件。
构建并运行 Docker 映像
最后，我们希望构建并运行映像。
#Build the image
docker build -t my-app .
#Run it
docker run my-app
#Find container name
docker ps --last 1
#Check logs
docker logs <container name>
如果您想浏览容器并手动运行脚本，那么修改 Dockerfile 的最后一行，构建并再次运行:
*#CMD ["python","-i","main.py"]CMD tail -f /dev/null*
这将使容器长时间运行，使您能够使用以下命令打开 bash shell:
*docker exec -ti <container name> bash*
然后您将能够浏览容器并手动执行 main.py 。
打开 bash shell 后容器的屏幕截图
如果要停止或移除容器，请使用:
*#List all containers
docker ps -a#List all container id
docker ps -aq#Stop container
docker stop <container_name>#Will remove all your containers
docker rm -f $(docker ps -aq)*
使用 SAM 在 AWS Lambda 上部署 Sklearn 机器学习
在 API 背后的无服务器架构上生产机器学习
在笔记本电脑上构建机器学习模型非常简单。
部署模型以使它们在生产中可用并不容易。
生产 ML 很难。它不仅结合了 SDE，ML 和 DevOps。但是没有放之四海而皆准的方法。
一家公司的成立取决于业务需求、财务限制和技术技能的综合因素。
虽然大多数 ML 并不适合无服务器系统，但有时还是有意义的。一会儿有意义的时候我会解释的。
目录:
- 背景资料
- 在本地训练一个模型
- 将模式推向 S3
- 构建 SAM 应用程序
- 在本地测试应用程序
- 将应用程序部署到 AWS
- 测试 API
- 结论
背景
什么时候 ML 适合无服务器？
你的 ML 很适合 Lambda，如果…
- 你的型号小。 Lambda 会在每次请求时重新加载模型，因此大型模型会导致响应时间变慢。
- 数据向量很小。 Lambda 配备了 3GB 内存上限。所以如果你的输入数据是海量的，它就会崩溃。
- 您的模型将被零星地访问。 Lambda 向外扩展(不是向上扩展)到无限，并按请求收费。因此，它非常适合间歇性的“即时”需求。
- 低成本很重要。 Lambda 每百万次请求收费 0.2 美元。
否则…考虑在 EC2 或 Sagemaker 上部署(如果钱不是问题的话)。
山姆是什么？
SAM 代表“无服务器应用程序模型”。这是一个通过代码提供 AWS 服务的开源框架。
通常，在 AWS 控制台中，总是选择基础设施即代码，而不是设置基础设施。前者更易维护，可复制，并允许在 Github 中存储版本。
教程先决条件
你需要在你的机器上设置一些东西。
- AWS 外壳(下载并配置
- AWS SAM 客户端
- 码头工人
在本地训练一个模型
本教程的重点是部署。所以我们不会关心训练一个精确的模型。但是您可以很容易地用您自己的更复杂的模型来替换它。
在 Jupyter notebook 中，首先导入所需的库。
from sklearn.datasets import load_wine
import pandas as pd
import numpy as np
import pickle
导入数据并生成数据框架。
data = load_wine() # import dataset
df = pd.DataFrame(data['data'], columns=data['feature_names']) # build dataframe
df['target'] = data['target'] # add dependent variable
df = df.sample(frac=1) # randomize the data
df.head(3)
它看起来会像这样。
将数据分成测试集和训练集。
print("row count:",len(df))
train_df = df[:150]
test_df = df[150:]
#=> row count: 178
准备数据以训练模型。
def X_and_y_from_df(df, y_column, X_columns = []):
'''Extract data from the dataframe'''
X = {}
for feature in X_columns:
X[feature] = df[feature].tolist()
y = df[y_column].tolist()
return X, yX_train, y_train = X_and_y_from_df(train_df, 'target', ['alcohol'])
X_test, y_test = X_and_y_from_df(test_df, 'target', ['alcohol'])X_train = np.array(X_train['alcohol']).reshape(-1,1)
X_test = np.array(X_test['alcohol']).reshape(-1,1)
符合模型。
from sklearn.linear_model import LogisticRegression
model = LogisticRegression()
model.fit(X_train, y_train)
腌制模型。
import pickle
pickle.dump( model, open( "pickled_model.p", "wb" ) )
太好了！现在它的格式很容易在 S3 保存。
将模式推向 S3
在与上述笔记本相同的目录中打开命令行。
创建一个 S3 桶。
$ aws s3 mb s3://sam-sklearn-lambda-123
注意:您将需要自己的全球唯一的存储桶名称。
把你的腌模推到 S3 去。
$ aws s3 cp pickled_model.p s3://lambda-app-bucket-123
AWS 服务现在可以访问您的模型，并且无需重新部署任何其他代码就可以对其进行更新或更改。
构建 SAM 应用程序
在命令行上，初始化 SAM 应用程序。
$ sam init
这将询问您 4 个问题，这些问题将用于为我们的 SAM 应用程序构建一个起始模板。
回答下面的问题。
提示:
- 您想使用哪个模板源？ 1 — AWS 快速入门模板
- 您想使用哪个运行时？ 2 — python3.8
- 项目名称【Sam-app】:【按“回车”保留默认名称】
- AWS 快速入门应用程序模板: 1 — Hello World 示例
现在cd进入刚刚创建的目录，用你喜欢的文本编辑器打开它。我用的是 Atom。
目录结构应该如下所示。
接下来，让我们将 lambda 代码所在的子目录的名称从/hello_world改为code/。您可以使用以下命令来完成此操作。
$ mv hello_world/ code/
现在是时候更新文件了。
template.yaml
这个文件告诉 CloudFormation 应该提供哪些服务。
更新它，如下图所示。
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: 'Serverless wine classifier'
Globals:
Function:
Timeout: 10
Resources:
WineClassifierFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: WineClassifierFunction
Handler: app.lambda_handler
Runtime: python3.8
MemorySize: 1024
Role: arn:aws:iam::421242169512:role/LambdaCanReadS3
Environment:
Variables:
s3_bucket: lambda-app-bucket-123
model_name: pickled_model.p
Events:
WineClassifier:
Type: Api
Properties:
Path: /classify
Method: post
Outputs:
WineClassifierApi:
Description: API Gateway endpoint URL for Prod stage for WineClassifier function
Value:
Fn::Sub: [https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/classify/](https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/classify/)
*注意:您需要在 AWS 中创建一个 IAM 角色，它允许 Lambda 读取 S3 的文件。我的名字叫做"*arn:AWS:iam::421242169512:role/lambda can reads 3 "但是你需要用你的角色的名字替换它。
上面提供了 API 网关端点和 Lambda。
它还将运行在 lambda 上的语言指定为 Python3.8，设置一些可以在我们的 Lambda 代码中访问的变量，并配置 API 网关端点。
code/app.py
这是我们的 Lambda 代码所在的地方。
import json
import sklearn
import boto3
import os
import json
import pickles3 = boto3.client('s3')
s3_bucket = os.environ['s3_bucket']
model_name = os.environ['model_name']
temp_file_path = '/tmp/' + model_namefrom sklearn.linear_model import LogisticRegressiondef lambda_handler(event, context):
# Parse input
body = event['body']
input = json.loads(body)['data']
input = float(input ) # Download pickled model from S3 and unpickle
s3.download_file(s3_bucket, model_name, temp_file_path)
with open(temp_file_path, 'rb') as f:
model = pickle.load(f) # Predict class
prediction = model.predict([[input]])[0] return {
"statusCode": 200,
"body": json.dumps({
"prediction": str(prediction),
}),
}
简而言之，它导入库，从 S3 获取模型，解析输入请求，对其进行分类，并返回响应。
code/requirement . txt
这是我们指定应该在 Lambda 上安装什么库的地方。下面是我们所需要的。
requests
boto3
sklearn
现在在命令行上运行以下命令。
$ sam build
这将创建一个.aws-sam/build目录，其中包含将被部署到 AWS 的代码。
在本地测试应用程序
在部署之前，让我们确保应用程序在本地工作。在此处得到成功回复之前，请不要继续。
运行以下命令以在本地设置应用。
$ sam local start-api
现在用卷曲达到终点。
$ curl -XPOST http://127.0.0.1:3000/classify -H 'Content-Type: application/json' -d '{"data":".10"}'
响应应该如下所示。
{"prediction": "1"}
如果你的回答如上，请继续！
将应用程序部署到 AWS
cd进入.aws-sam/build/目录。
$ cd .aws-sam
$ cd build
现在在下面跑。这将创建一个 zip 文件，其中包含将要部署的依赖项(马上)。这需要一分钟。
注意:我使用我的 S3 桶的名字，但是你应该使用你的名字。
$ sam package --template-file template.yaml --s3-bucket lambda-app-bucket-123 --output-template-file packaged.yaml
然后运行以下命令来部署您的应用程序。
$ sam deploy --template-file packaged.yaml --stack-name SklearnLambdaStack --capabilities CAPABILITY_IAM
您应该得到一个应用程序已经部署的确认。
测试 API
在之前的部署响应中，您将获得一个 URL。
如果一切正常，向该 URL 发送请求应该会返回与向本地运行的应用程序发送请求相同的响应。
$ curl -XPOST https://6lsk6c6vw2.execute-api.us-east-1.amazonaws.com/Prod/classify/ -H 'Content-Type: application/json' -d '{"data":".10"}'
所以以上应该回归。
{"prediction": "1"}
恭喜你！您已经部署了您的第一个无服务器 ML 应用程序！
结论
如您所见，在无服务器架构上部署 ML 绝非易事。
我们所走过的例子非常简单；我们甚至跳过了 API 认证，因为我不想偏离核心课程。
关于生产无服务器 ML 的例子并不多，所以我希望这有助于加速你的学习过程。
我完全期待在未来我们会看到更多更好的生产 ML 的工具。但在此之前，基础设施将与模型部署紧密结合。
我希望你觉得这很有用。一如既往，如果你遇到困难，请告诉我，我会尽力帮助你！
将 Streamlit 应用部署到 GCP
来自 Unsplash 的 Rene b hmer 的照片。
什么是 Streamlit？
如果您熟悉 Python 中的数据科学软件生态系统，您可能会遇到一些广泛使用的仪表板和数据可视化工具，这些工具是为编程用途而设计的(例如，嵌入笔记本电脑或作为独立的 web 应用程序)。在过去的几年里，像 Dash 、 Bokeh 和 Voila 这样的公司已经成为这个领域中最大的开源公司之一。在 R 的世界里，还有仪表板工具的长期冠军:闪亮。
有了这个相对成熟的生态系统，你可能会质疑是否需要一个又一个框架来加入这个群体。但这正是 Streamlit 的团队正在做的事情:引入一个全新的框架来构建数据应用程序。更重要的是，他们也为他们的项目制造了不少轰动，以至于他们最近结束了一轮 2100 万美元的首轮融资，以允许他们继续开发他们的框架。
[## 宣布推出价值 2100 万美元的 Streamlit A 系列产品
为数据科学界开发新的超级能力。
medium.com](https://medium.com/streamlit/announcing-streamlits-21m-series-a-ae05daa6c885)
那么是什么让人们对 Streamlit 如此兴奋呢？
Streamlit 中实时计算机视觉可视化。照片来自 Streamlit 。
首先，这是你可能遇到的最简单的工具之一。没有样板文件，也没有什么特定于框架的概念需要记住。感觉设计的非常好。总的来说，这种简单性使得在几秒钟内构建一个应用程序变得非常快速和容易。
这种极简主义有助于第二个要点:事件管理轻而易举。这听起来可能很无聊，但在这种情况下这是一件大事。在 Streamlit 中管理事件不需要特定于框架的设计模式/回调。例如，假设您想通过点击一个按钮来运行一些代码，您可以在 Streamlit 中用以下代码来捕获:
import streamlit as stif st.button("Click Me"):
print("Clicked")
每当按下Click Me按钮时，其下的程序块将被执行。相同的概念以几乎相同的方式应用于他们所有的交互组件。它在幕后做了一些聪明的把戏来实现这一点，但最终效果是一样的:你可以快速简单地编写具有复杂行为的应用程序，只需对底层代码做很少的更改。与 Fire 让为现有代码创建 CLIs 变得异常容易一样，Streamlit 让从现有代码创建交互式应用变得异常容易。正如他们所说:它被设计成“洒”在你的代码上。
最后，Streamlit 与现有的数据可视化工具集成起来也非常容易，并且非常容易部署启动——它与现代部署工具和技术配合得非常好。你可以随心所欲地将你的matplotlib图表嵌入到你的dash图中，然后将其打包，随时准备部署。总而言之，这些特性共同使 Streamlit 成为目前最具生产力的现代数据可视化工具之一。
创建您的应用
虽然 Streamlit 的文档对入门很有帮助，但是没有太多关于部署应用的内容。本文旨在强调将 Streamlit 应用部署为一个面向公众的实时网站是多么简单。它将使用 Streamlit 提供的一个“标准”演示应用程序:一个按一天中的时间在纽约市的优步皮卡的可视化。但是，您可以随意创建自己的应用程序并进行部署(您将使用的模板无需更改！).
你需要什么
开始之前，你需要确定你已经准备好了一些东西。您将使用 Google App Engine 部署您的应用程序，因此这意味着您需要注册一个 Google Cloud 帐户(注册时还有 300 美元的信用点数！)然后安装他们的gcloud命令行工具。你可以在这里注册一个账户(不是代销商链接，不用担心！):
GCP 自由层以两种方式扩展我们的免费计划。3 个月免费试用的 300 美元积分和 20 多种免费产品…
cloud.google.com](https://cloud.google.com/free)
谷歌云也为安装gcloud提供了很好的“入门”指南。
[## gcloud 命令行工具概述| Cloud SDK 文档
本页包含 gcloud 命令行工具及其常用命令模式和功能的概述。的…
cloud.google.com](https://cloud.google.com/sdk/gcloud)
完成后，确保你已经安装了Docker并且正在运行。你不需要与 Docker 互动来跟进这篇文章，但你需要它运行！您还需要拥有 Python 3.6 或更高版本的有效版本。为项目设置并激活一个 Python 虚拟环境也是一个好主意。
编码时间到了
所以，首先要做的是。您需要从 GitHub 克隆部署就绪的 Streamlit 项目模板。在您的终端中，运行:
git clone [https://github.com/markdouthwaite/streamlit-project](https://github.com/markdouthwaite/streamlit-project)
导航到新的streamlit-project目录并运行:
pip install -r requirements.txt
正如您所料，这将安装运行此应用程序所需的软件包。有了这个设置，是时候测试你的应用了！您可以通过以下方式做到这一点:
make run-container
将您的应用程序构建到 Docker 映像中，并在http://0.0.0.0:8080启动运行您的应用程序的新容器。它会自动打开一个新的浏览器选项卡并加载你的应用程序。您应该会看到这样一个可爱的可视化效果:
照片来自 Streamlit 。
你可以随意编辑这个应用程序。了解 Streamlit 的强大功能是值得的。当你完成后，只要确保make run仍然在http://0.0.0.0:8080成功启动你的应用，然后你就可以开始部署了。
部署您的应用
您将使用谷歌应用程序引擎来部署应用程序。这是由 Google Cloud 提供的托管服务，可以帮助您超级轻松地部署和扩展您的应用。谷歌将为你管理缩放、服务器设置和其他零碎的东西。您所需要的只是一个正确配置的 Docker 映像，而且您已经很接近了。转到您的谷歌云控制台，前往左侧导航菜单中的 App Engine，检查您的 App Engine API 是否处于活动状态。您现在应该能够运行:
make gcloud-deploy
这将建立你的图像，存储在谷歌容器注册(GCR)，然后配置和启动你的应用程序。完成后它会告诉你的。您应该会看到类似这样的内容(其中{{YOUR-URL}}将是您部署的应用程序的 URL):
Deployed service [default] to [{{YOUR-URL}}]
导航到所提供的 URL，查看您的应用程序的所有优点！
后续步骤
完成后，你的应用程序现在是公开可见的，可以与你希望的任何人共享。您现在还可以使用make gcloud-deploy自由编辑和重新部署您的应用程序。你甚至可以考虑用 GitHub Actions 构建一个持续集成和持续交付 (CI/CD)管道，以便在每次你向 GitHub 推送更改时自动重新部署你的应用。不过这取决于你！
解决纷争
如果你在上述步骤中遇到任何问题，App Engine 的文档非常好，值得一看:
如果你还在挣扎，请随时在 Twitter 上联系我。
收尾工作
差不多就是这样了。以可扩展、安全的方式部署新的 Streamlit 应用。简单，嗯？当您深入研究 Streamlit 时，您会注意到它在几个方面仍然有点受限:例如，布局和样式在默认情况下是高度受限的。然而，他们最近的几轮融资给了他们很多开发一些很酷的新功能的机会，这些东西在他们的功能路线图上，所以他们的到来只是时间问题。如果你对数据可视化感兴趣，Streamlit 绝对值得一看。
使用简化 it 共享部署简化 it 应用
先睹为快 Streamlit 的新部署平台
作者图片
在过去的几周里，我一直在玩一个名为 Streamlit sharing 的新 Streamlit 功能，它使部署您的定制应用程序变得非常简单。我将首先介绍一些背景知识，因此如果您想查看 Streamlit 共享的文档，您可以在这里找到它们。
流线型背景
简单介绍一下背景，Streamlit 是一个框架，它可以让您快速而自信地将 python 脚本转换为 web 应用程序，对于需要快速共享模型或交互式分析的团队中的数据科学家来说，或者对于从事希望向世界展示的个人项目的数据科学家来说，它是一个不可思议的工具。如果你想尝试一下，这里有一个 Streamlit 初学者教程！
在过去的大约 6 个月里，我一直在使用 Streamlit，它一直非常有用。以前，如果我知道我想在项目结束时制作一个 web 应用程序，我总是会选择切换到 R 来获得精彩的 R shiny 框架，即使我是一个比 R 好得多的 python 程序员。经历 Django 或 flask 是如此多的开发摩擦，以至于对于个人项目来说很少是值得的，并且对于工作中的任何事情来说总是花费太多时间。但是在使用 Streamlit 之后，我现在不仅有了选择，而且发现自己更喜欢 python+Streamlit 而不是 R+shiny。
简化共享
这让我想起了几个月前。我启动了一个 DS 项目，专注于使用来自 Goodreads 应用的数据分析阅读习惯。我决定尝试一下 Streamlit，它将一个 Django/flask 应用程序在本地正常运行的多日过程变成了一个在本地使用 Streamlit 大约需要半小时的过程。这真的很简单，只要你想在应用程序上放一个图表、小部件或文本解释器，就可以把你的分析放到一个脚本中，并调用 Streamlit 函数。
然而，Streamlit 上最烦人的流程是部署和管理流程。我跟着学的教程很简单，没花多少时间，但是相当广泛。它需要启动一个 ec2 实例，配置 SSH，使用 tmux，并在每次想要更改 web 应用程序时返回到这个终端。这是可行的，但令人讨厌。
作者图片
几周前，Streamlit 看到了我的 Goodreads 应用程序，问我是否想测试一下他们的 Streamlit 共享测试版，该测试版应该可以消除上面解释的摩擦。很明显，我尝试过了。
我所要做的就是:
- 将我的应用程序推送到 Github 回购
- 添加一个 requirements.txt 文件，列出我使用的所有 python 库
- 通过指向存储库的链接将 Streamlit 指向我的应用程序
- 单击部署
这真的是那么容易弄清楚。我花了几个小时来解决这个问题，因为我预计会出现各种各样的错误(这是测试版！)，但我只用了不到 10 分钟就让它启动并运行了。
我目前正在运行三个应用程序，一个是测试应用程序，第二个是我之前提到的 Goodreads 图书推荐应用程序，第三个是我在大约一个半小时内完成的一项技术调查的交互分析(从想法到运行和部署 web 应用程序)。
切换到 Streamlit 共享还为我节省了每月约 5 美元的 AWS 账单，我很乐意为这项功能支付这笔费用，仅仅是因为节省了部署时间。
作者图片
如果我想尝试一个新的应用程序，我只需点击新的应用程序按钮，将其指向我的回购，他们就会处理其他一切。
作者图片
如果您的 Streamlit 应用程序使用任何其他包，请确保在您的 repo 中包含 requirements.txt 文件，否则您会在部署时立即得到一个错误。你可以使用像 pip freeze 这样的东西来获取需求，但是这会给你环境中的所有包，包括那些你在当前项目中不使用的包。这将降低您的应用程序部署速度！所以我建议使用像 pipreqs 这样的东西来保持你的应用程序的核心需求。
pip install pipreqs
pipreqs /home/project/location
如果对 apt-get 有要求，添加到packages.txt -，一行一个包。
结论
总而言之，Streamlit sharing 在节省开发时间和托管成本方面为我节省了美元(对使这一切成为可能的风险投资基金大喊一声)，使我的个人项目更具互动性和更漂亮，并消除了部署快速模型或分析的头痛。难怪我是细流迷。
想看更多这方面的内容？你可以在 Twitter 、 Substack 或我的作品集网站上找到我。
快乐的小溪！
部署晦涩的 Python 脚本:肖像图片的神经造型
Python 脚本的快速部署
作者 Rosaria Silipo 和 Mykhailo Lisovyi，KNIME
今天的款式是什么？
当今风格:卡拉瓦乔还是毕加索？
几个月前在网上冲浪时，我们看到了这项研究[i]，它承诺训练一个神经网络来根据你喜欢的画家的风格改变任何图像。这类研究释放了你的想象力(或者至少是我们的想象力)。
如何改变我目前的肖像图片，给它一个著名的卡拉瓦乔画美杜莎触摸？那位同事的肖像照得更像毕加索的风格不是更好看吗？或者把梵高的《星夜》作为另一个梦幻同事的背景？给我们当中最喜欢冒险的人一点伊卡洛斯蓝？如果你对艺术有一点了解，你可以给自己的肖像赋予无穷无尽的细微差别。
好消息是这项研究附带了一个 Python 脚本，可以下载并重复使用。[二]
坏消息是，我们大多数人没有足够的 Python 知识来部署解决方案或使其适应我们的图像集。事实上，我们大多数人甚至没有足够的关于算法本身的知识。但事实证明我们不需要。我们不需要了解 Python，也不需要了解算法细节来根据一幅选定的画生成神经风格的图像。我们实际需要做的是:
- 上传人像图片，选择喜欢的风格(梵高的夜星，伊卡洛斯蓝，卡拉瓦乔的美杜莎等。).
- 稍等片刻，等待奇迹发生。
- 最后，下载神经风格的肖像图像。
这确实是最终用户需要做的所有事情。关于算法的细节是不必要的，因为底层 Python 脚本的全部知识也是不必要的。最终用户也不需要安装任何额外的软件，应该能够通过任何 web 浏览器与应用程序进行简单的交互。
你知道卡拉瓦乔画的美杜莎吗？这是他著名的自画像。注意美杜莎头上的蛇(图 1b)。图 1a 显示了本文作者之一 Rosaria 的肖像。如果我们根据卡拉瓦乔的美杜莎(图 1c)重新设计罗萨莉亚的肖像，会发生什么？
为了查看神经样式化的结果，我们将 Python 脚本(用于对图像进行神经样式化)集成到一个应用程序中，该应用程序可通过网络访问，与算法无关，不支持脚本，并且具有完全根据最终用户的请求定制的用户界面。
来自网络浏览器的图像神经造型
图二。对图像进行神经样式化所需的三个步骤:1)上传图像文件并选择艺术样式。2)等待网络找出神经样式。3)欣赏你的新肖像，它具有你喜欢的绘画的艺术风格。
从电脑、平板电脑或智能手机上的网络浏览器，该应用程序以最经典的方式启动，上传图像文件。让我们上传两位作者 Misha 和 Rosaria 的肖像图片。
之后，我们被要求选择绘画风格。罗萨莉亚是卡拉瓦乔绘画的忠实粉丝，所以她选择了《美杜莎》。米沙更喜欢毕加索的立体派，选择了他的《多拉·玛尔画像》
此时，网络开始处理数据:在我自己的笔记本电脑上用了 35 分钟，只用了我的 CPU 在更强大的机器上 35 秒[iv]带 GPU 加速。
现在，我们进入应用程序的最终网页。让我们看看网络提出的重新设计(图 3-4)。
神经风格图像在下面的图 3 和图 4 中示出。请注意，输入图像没有发生很大的变化。他们只是从艺术杰作中获得了一些颜色和图案，比如罗莎丽亚的美杜莎式头发或米莎照片中的背景墙。免责声明:尽管这些照片很有趣，但它们可能还不能用于你的护照！
三个简单的步骤从原始图像到相同的图像，由大师设计！不需要脚本和底层算法的调整。您只需要知道图像文件的位置和要应用的艺术风格。如果你改变主意，你可以随时回去改变绘画风格或输入图像。
实现图像神经造型应用
为了组装这个应用程序，我们只需要我们工具中的一些特性。
- 与 Python 的集成
- 图像处理功能
- web 部署选项
Python 集成
这里的任务是集成由牛津大学视觉几何小组开发的 VGG19 神经网络，该神经网络可以从 Keras Documentation pageii 下载 Python 脚本来设计任意肖像图片。因此，我们需要一个 Python 集成。
开源分析平台的核心安装【v】中提供了与 Python 的集成。你只需要安装带有核心扩展的分析平台和带有 Keras 包的 Python。两个都安装好之后，您需要通过 File->Preferences->Python 页面将分析平台指向 Python 安装。如果你对下一步该做什么有疑问，请遵循 Python 集成安装指南和深入
学习集成安装指南。
安装后，您应该在节点库面板中看到一个 Python 类别，包括免费脚本、模型训练、模型预测器、绘图和更多 Python 函数(图 5)。所有 Python 节点都包括一个语法突出显示的脚本编辑器、两个用于脚本测试和调试的按钮、一个工作区监视器和一个显示可能错误的控制台。
注意，类似的集成也适用于 R、Java 和 JavaScript。这整个集成环境也使您能够协作和共享同事的代码和脚本。
图 5。在 KNIME 分析平台中提供 Python 函数的 Python 节点
图像处理扩展
图像处理功能在图像处理社区扩展中可用。安装后，您将在节点存储库中看到图像处理功能，在类别 Community Nodes/Image Processing 中。您可以使用它们来处理图像、提取特征、标注、过滤噪声、处理尺寸以及变换图像本身。
Web 部署选项
web 组件由 WebPortal 提供。所有小部件节点在封装到组件中时，都将其图形视图显示为网页的一个元素。图 2 所示的两个网页是通过将多个小部件节点组合成一个组件而构建的。
最终工作流程
实现上述 web 应用程序的最终工作流程如图 6 所示，可从中心下载，或从示例服务器的分析平台中，在 50 _ Applications/56 _ Restyling _ Images _ using _ Deep _ Learning 下下载。
图 6 中的工作流程开始于读取输入肖像图像和艺术风格图像(名为“上传输入图像”的组件)。然后，输入图像被调整大小、归一化，并且其颜色通道被重新排序。此时，Python 脚本(执行附录中所述的神经造型，并封装在名为“Python 中的样式转换”的组件中)接管并使用新的输入图像和选定的艺术样式重新训练神经网络。然后，对生成的图像进行反规格化，并将颜色通道恢复到原始顺序。最后一个节点称为“显示样式图像”，在最终的 web 页面上显示结果图像。
请注意，没有必要修改 Python 代码。将原始代码复制并粘贴到 Python 节点编辑器中，只需进行一些调整(例如，参数化训练设置)就足够了。
在更高的层面上，当终端用户从他们的 web 浏览器运行应用程序时，他们将看不到任何底层的 Python 脚本、神经网络架构，甚至是训练参数。这是向最终用户隐藏晦涩的脚本和算法复杂性的完美伪装。
图 6。工作流 01_Image_ReStyling_WebPortal 实现基于网络的应用程序，该应用程序执行输入图像的神经造型，并可在 50 _ Applications/56 _ ReStyling _ Images _ using _ Deep _ Learning 下的示例服务器上或在 KNIME Hub 上获得。
Python 代码作为可重用组件
现在，Python 脚本似乎工作得相当好，我们大多数不了解 Python 的人也可能喜欢使用它。“Python 中的样式转换”组件中的 Python 代码对我们来说工作得很好，但对其他人来说很难回收。
为了提高其他用户对 Python 脚本的可重用性，我们将这个组件转换为一个模板，并将其存储在一个中心位置。现在，新用户只需拖放模板，就可以在其工作流程中生成一个链接组件。
已经为图像处理组件创建了类似的模板。您可以通过灰色节点左下角的绿色箭头来识别此类模板的链接实例。
一键部署图像神经造型应用
最后一步是部署。换句话说，如何将我们新开发的工作流转化为一个可从 web 浏览器访问的高效应用程序，并处理当前数据。
我们需要做的只是将神经造型工作流从分析平台的本地工作区拖放到一个工作区。然后，可以通过服务器的 web 门户从任何 web 浏览器调用工作流。此外，如果使用了任何小部件节点，那么在 WebPortal 上执行工作流将会产生一系列交互式网页和仪表板。
请注意，这种一键式部署过程适用于任何 Python 脚本的部署，使其在生产环境中更易于使用。
总结
以玩 Rosaria 和 Misha 及其同事的神经风格肖像为借口，我们已经展示了导入、集成和部署一个晦涩的 Python 脚本是多么容易——而不需要了解 Python。
我们还展示了如何配置应用程序，使其可以在任何 web 浏览器上运行，我们只要求最终用户提供最少的必要信息，并隐藏所有其他不必要的细节。
为了使 Python 脚本和应用程序的其他部分可以被其他人重用，我们将一些部分打包为模板，并将其作为链接组件插入到许多其他不同的应用程序中。
附录:神经式转移
神经风格转移是一种使用神经网络从一幅图像中提取绘画风格并将其应用于另一幅图像的技术。它最早是在《艺术风格的神经算法 I》中提出的
主要思想是利用这样一个事实，即卷积神经网络(CNN)【VI】在不同的层中捕捉不同的复杂程度。第一个卷积层可以作为低级边缘检测器，而最后一个卷积层可以捕获对象。由于我们只对通用对象检测器感兴趣，所以我们不需要为了风格转换而训练专用网络。相反，我们可以使用任何现有的预训练多层 CNN。在本文中，我们使用了由牛津大学视觉几何小组开发的 VGG19 神经网络，该网络以 Python 脚本的形式提供，可从 Keras 文档页面[ii]下载。
样式化过程被定义为自定义函数的优化。该功能有几个部分:
- 一个术语确保结果图像类似于原始图像中的高级对象。这是通过输入和输出图像之间的差异实现的，其中输出图像是最后一个卷积层中的网络响应。
- 第二学期旨在捕捉艺术绘画的风格。首先，样式被表示为层内跨通道的相关性。接下来，从第一层到最后一层，跨 CNN 层计算样式表示的差异。
- 最后一个术语加强了生成的风格化图像的平滑度，并在“通过反转图像来理解深层图像表示”中得到提倡
最后，使用由 Keras 提供的自动微分功能迭代地执行该定制函数的优化。自定义函数需要针对每个新的输入图像进行优化。这意味着，对于每一个新的肖像，我们需要在预先训练好的 CNN 上再次运行优化程序。
[i] L. Gatys 等，艺术风格的神经算法，[arXiv:1508.06576]
[ii] Keras 神经传递样式示例，Keras 文档页面
[iii]笔记本电脑规格:CPU Intel i7–8550 u，4 核，多线程；16 GB 内存
【四】GPU 机器规格:CPU Intel i7–6700，4 核，带多线程；32 GB 内存；配备 8GB VRAM 的 NVIDIA GeForce GTX 1080
[v] Aravindh Mahendran，Andrea Vedaldi，通过反转理解深层图像表示，[arXiv:1412.0035]
[vi] 卷积神经网络YouTube 上的视频系列，Deeplearning.ai，2017
如首次发表于data versity。
在 AWS Fargate 中部署 Docker 容器
使用 Fargate 和 Cloud Formation 在 AWS 中部署容器化 web 应用程序的分步指南
照片由维达尔·诺德里-马西森在 Unsplash 拍摄
动机
Docker 是一个非常棒的工具，可以用一种简单且可扩展的方式封装和部署应用程序。事实上，我发现自己经常做的事情是将 Python 库封装到 Docker 映像中，以便以后可以用作项目的样板。
在本文中，我将说明如何在容器注册表中注册 Docker 映像，以及如何使用 Fargate 在 AWS 中部署容器，Fargate 是一个无服务器计算引擎，旨在运行容器化的应用程序。此外，我们将使用云形成以编程方式部署我们的堆栈。我们开始吧！
在容器注册表中注册您的图像
容器注册对于 Docker 图像就像代码库对于编码一样。在 registry 中，您可以创建映像存储库来推送和注册您的本地映像，您可以存储同一映像的不同版本，如果其他用户有权访问存储库，他们可以推送和更新映像。
现在，假设您已经在本地开发了一个映像，并希望将其部署到云中。为此，我们需要将本地映像存储在一个容器注册表中，可以从该注册表中提取和部署映像。在本文中，我将使用一个相当简单的图像，在端口 80 上启动一个 web Python-Dash 应用程序。
我们将使用 ECR (弹性容器注册表)来注册我们的图像。ECR 是一个 AWS 服务，非常类似于 DockerHub，用于存储 Docker 图像。我们要做的第一件事是在 ECR 中创建一个存储库，我们可以按如下方式使用 AWS CLI:
aws ecr create-repository \
--repository-name dash-app\
--image-scanning-configuration scanOnPush=true \
--region eu-central-1
您应该能够在 AWS 管理控制台中看到存储库
要将本地图像推送到我们的 ECR 存储库，我们需要在 AWS 中验证我们的本地 Docker CLI:
aws ecr get-login-password --region **region** | docker login --username AWS --password-stdin **acccount_id**.dkr.ecr.**region**.amazonaws.com
适当更换aws_account_id和region即可。您应该会在终端中看到消息Login Succeeded，这意味着我们的本地 Docker CLI 已经过身份验证，可以与 ECR 交互。
现在，让我们将本地图像推送到我们全新的存储库中。为此，我们必须标记我们的映像以指向 ECR 存储库:
docker tag **image_id** **account_id**.dkr.ecr.eu-central-1.amazonaws.com/dash-app:latest
现在我们只需要把它推到集控室:
docker push **account_id**.dkr.ecr.eu-central-1.amazonaws.com/dash-app:latest
您应该会在 AWS 控制台中看到推送的图像:
现在我们到了本节的结尾，让我们总结一下:(I)我们已经在 ECR 中创建了一个名为 dash-app 的映像存储库，(ii)我们已经授权我们的本地 Docker CLI 连接到 AWS，以及(iii)我们已经将一个映像推送到该存储库。在下一节中，我们将介绍如何在 AWS 中部署这个映像。
在 AWS 中部署 Docker 容器
撇开 Kubernetes 不谈，AWS 提供了几种部署容器化应用程序的选项:
- 在 EC2 上部署容器，通常是在一组自动扩展的实例中。在这个场景中，我们负责修补、保护、监控和扩展 EC2 实例。
- 在 AWS Fargate 上部署容器。因为 Fargate 是无服务器的，所以不需要管理或提供 EC2 实例。Fargate 管理我们的任务的执行，提供适当的计算能力(在这个上下文中，任务指的是作为应用程序一起工作的一组容器)。
在本节中，我们将关注第二个选项，说明如何在 AWS Fargate 上部署我们的 web 应用程序。此外，我们将为 AWS 云的形成分配所有必要的资源。
云的形成
云形成是一种以编程方式提供和部署资源的 AWS 服务，这种技术通常被称为代码或 IaC 基础设施。在 IaC 中，我们不是通过管理控制台手动分配资源，而是在 JSON 或 YAML 文件中定义堆栈。然后，该文件被提交给 Cloud Formation，它会自动部署文件中指定的所有资源。这有两个主要优势:(I)它使自动化资源供应和部署变得容易，以及(ii)这些文件有助于作为我们的云基础架构的文档。
尽管在 JSON/YAML 文件中定义我们的堆栈需要经历一个学习过程，并且忘记 AWS 管理控制台及其真正易于使用的向导，但从长远来看，这绝对是值得的。随着基础设施的增长，将所有的栈保持为代码将对有效地扩展非常有帮助。
堆栈
现在，让我们列出运行应用程序所需的资源:
- 任务 : 它描述了塑造我们的应用程序的一组 Docker 容器。在我们的例子中，我们只有一个图像。
- ECS 服务 : 它负责运行和维护所需数量的任务实例。例如，如果任务失败或停止，ECS 服务可以自动启动一个新实例，以保持所需数量的任务处于服务状态。
- Fargate**😗*一个用于容器的无服务器计算引擎。使用 Fargate，无需预订和管理服务器。它会自动提供计算能力来运行我们的任务。
- 网络资源:我们还需要一个 VPC，一个通过路由表连接到互联网网关的公共子网(别忘了我们正在部署一个应该可以从互联网到达的 web 应用程序)，以及一个安全组来安全地运行我们的容器。如果已经有了网络配置，就不需要设置这些资源，尽管我在云形成脚本中包含了它们。
现在，事不宜迟，让我们进入堆栈。下面的要点包含所有需要的资源。我们来详细解释一下:
- 这是 VPC。启用 DNS 支持和 DNS 主机名以访问 ECR 并提取映像非常重要。
INT-GATEWAY:这是一个互联网网关，需要将子网暴露给互联网。ATTACH-IG:连接互联网网关到 VPC。ROUTE-TABLE:这是一个路由表，我们将在其中添加规则，以将子网暴露给互联网网关。ROUTE:这为之前描述的路由表添加了一条规则。它将流量转发到互联网网关。SUBNETFARGATE:这是托管我们服务的子网。我们定义了可用性区域及其所属的 VPC。SUBNETROUTE:将路由表关联到子网。SGFARGATE:这是应用于我们服务的安全组。它允许端口 443 和 80 上的流量通过 HTTPS 和 HTTP 协议。FARGATECLUSTER:它定义了 Fargate 集群来托管我们的服务。ECSTASK:决定要执行的任务。它包括构成任务的 Docker 图像列表。对于每个容器，它注册端口映射、启动命令和日志选项。图像是从之前设置的 ECR 存储库中提取的。SERVICE:定义将启动和维护我们的任务的 ECS 服务。如果您已经有了网络配置，并且不需要创建新的子网和安全组，只需参考 ECS 服务的NetworkConfiguration部分中的现有资源。
一旦您的文件准备就绪，将其上传到 Cloud Formation 以创建您的堆栈:
按照管理控制台中的步骤启动堆栈。一旦完成，云形成将自动开始提供服务。您可以在“事件”选项卡中跟踪其进度:
更重要的是，准备就绪后，您可以在分配给正在运行的任务的公共 IP 地址访问您的 web 应用程序！
关于用户策略的说明
如果您遵循最佳实践，您就不会使用 AWS root 帐户创建资源。相反，您应该使用非根用户。但是，您应该注意，要将角色传递给服务，AWS 要求创建服务的用户拥有“传递角色”权限。在我们的例子中，我们需要我们的用户将角色ecsTaskExecutionRole传递给TaskDefinition服务，因此我们必须授予用户这样做的权限。这可以通过 IAM 中的 root 帐户或任何具有 IAM 权限的帐户来完成。只需添加下面的策略，并将其附加到将分配所有资源的用户。
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::account_id:role/ecsTaskExecutionRole"
}
]
}
结论
我们在这篇文章中已经讨论了很多。我们已经看到了如何创建 ECR 存储库以及如何将 Docker 映像推送到其中。我们还简要介绍了云形成和 IaC。我想重申将您的基础设施和堆栈指定为代码的重要性。随着您的基础设施的增长，在 JSON 或 YAML 文件中定义堆栈将使自动化部署更容易，以高效的方式扩展，并将提供关于您的基础设施的某些文档。最后，我们使用 AWS Fargate 以一种无服务器的方式部署 docker 容器，这让我们免去了供应和管理服务器的负担。
希望这篇文章对您有所帮助，感谢您的阅读。
参考
在 2021 年部署你的机器学习应用
实践教程
Streamlit 分享来了，很牛逼。
这是今天早上的我。(布鲁克·卡吉尔在 Unsplash 上拍照)
现在还是 2020 年。我醒来时发现收件箱里有些东西让我大吃一惊。如果这个承诺是真的，它将彻底改变我今后构建和部署机器学习应用的方式。
给你一点背景，我最近在做一个非常基础的项目，基于诊断方法预测糖尿病的发病。当我构建任何东西时，最终目标是让最终用户可以访问它。永远。在有了一些设计、开发和部署多个 ML 应用程序的经验之后，我或多或少地知道了这个过程。一旦模型开发完成，我首先构建一个包装模型的应用，然后将应用文档化，最后将它部署到任何云服务提供商。
但我不知道的是，Streamlit 的优秀团队另有打算。今天早上我的收件箱里收到了一封邮件。相信我，这改变了模型部署的一切。现在还是 2020 年，但我可以预见 2021 年将会发生什么。
这封邮件是对新推出的简化应用程序部署的 Streamlit 共享平台的邀请。虽然仍处于测试阶段，但我忍不住对 2021 年的到来感到兴奋。(作者截图)
简化共享和承诺
如果你还没有听说过 Streamlit ，它是一个 python 库，可以让构建 ML 应用变得快速而简单。当我说构建任何机器学习应用程序只需要几个小时时，我并没有夸大其词。 Streamlit 分享是一个新推出的分享 Streamlit 应用的平台。现在已经存在类似的平台，如 Heroku 和 Netlify，以便于部署，但当使用 Streamlit 构建时，这个新平台可能是您的最佳选择。Streamlit 称其为*“机器学习代码的简单、可共享的播放按钮。”*让我们来了解一下？
对我们这些数据科学家来说，这个承诺非常简单。将您的代码推送到 GitHub，将 Streamlit 指向您的存储库并免费部署您的应用程序。那么有什么问题呢？目前，共享仅支持公共和开源应用。如果你需要为私有/内部用例部署应用，你需要等待 Streamlit 团队，目前处于测试开发阶段。
现在我们已经了解了这个工具，我非常兴奋能够接触到这个平台。
如何部署机器学习应用程序
正如我之前提到的，我们将在这里使用的例子是使用 Streamlit 构建的糖尿病预测应用程序。请参考这个 GitHub 库获取应用的完整代码。确保添加 requirements.txt 文件。需求文件只不过是应用程序使用的 python 包及其版本的列表。在你的终端上一个简单的pip freeze命令会给你精确的细节。在幕后，该文件有助于简化 it 安装部署所需的所有依赖项。
现在我们的存储库已经准备好了，我登录了 Streamlit 共享平台。出现提示时，我授权 Streamlit 访问我的 Github 帐户。我填写了详细信息，然后单击了 Deploy。
简单的部署过程。(作者截图)
等等……就这样？我的应用被部署给全世界看。这个过程变得如此简单，让我惊叹不已。
整个部署过程大约需要 5 分钟。每当我更新应用程序并将代码推送到我的 GitHub 库时，部署的应用程序也会更新。这太疯狂了。
已部署应用的截屏(按作者)
然而，由于该平台仍处于测试阶段，因此存在一些资源限制，例如每个用户帐户 3 个应用程序，以及一些已知的限制。官方文档很好地概括了更多信息，社区总是很有帮助。
我坚信，到 2021 年，由于 Streamlit，这将成为常态。您可以使用 Streamlit 快速原型化您的 ML 应用程序，并使用 Streamlit 共享在几个小时内部署它们。老实说，我迫不及待地想看到更多的特性被添加到 Streamlit！
现在轮到你了
我明白了。既然你已经阅读了这篇文章，你会喜欢开发和部署你自己的机器学习应用程序。这里有一个你也可以做到的回顾。
- 构建您常用的 ML 模型，并快速将它们打包到一个 Streamlit 应用程序中。
- 将您的代码推送到 GitHub。确保包含 requirements.txt 文件。
- 请求邀请共享 Streamlit。(在我写这篇文章的时候还在测试阶段——应该很快就会推出)
- 登录您的 Streamlit 共享账户并授权其访问 GitHub。
- 选择要部署的存储库、分支和代码。点击部署！
- (可选)在此分享你的应用链接。我也很想看到并分享它。
This article is a part of my series on **Machine Learning in Production**:
- [How I Build Machine Learning Apps in Hours](https://medium.com/towards-artificial-intelligence/how-i-build-machine-learning-apps-in-hours-a1b1eaa642ed)
- [How to Dockerize Any Machine Learning Application](/how-to-dockerize-any-machine-learning-application-f78db654c601)
- [Deploying Your Machine Learning Apps in 2021](/deploying-your-machine-learning-apps-in-2021-a3471c049507)
我希望你喜欢阅读，就像我喜欢为你写这篇文章一样。我在这里的 媒体 中广泛地写了我在数据科学方面的经历。欢迎在LinkedIn上与我联系，我很乐意听到各种反馈。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
