NeptuneAI-博客中文翻译-一-
NeptuneAI 博客中文翻译（一）
提高机器学习团队生产力的 10 大最佳工具
在过去的几年里，机器学习社区发展了很多。它带来的最大好处之一是大量高效的机器学习工具，帮助我们事半功倍。作为一名机器学习工程师，你现在在建立模型或管道时的工作量减少了。
例如，如果你想建立一个深度学习模型，你可能需要定义权重、偏好、节点数量、层数、激活函数、优化器等等。有了 ML 工具，你不需要自己做所有的事情。
这些工具让您可以处理数据、调整模型、调整性能等等，为您和您的团队节省宝贵的时间。
在这篇文章中，我们将分析能够为你的 ML 团队节省时间并提高你的生产率的最佳工具——以及一些用于时间跟踪、交流和其他一些工具。
让我们开始吧。
Neptune 是一个轻量级的、强大的元数据存储库。它为您提供了一个集中的位置来显示您的元数据，允许您轻松跟踪您的机器学习实验和结果。
要构建一个优化的 ML 模型，您需要使用不同的超参数和架构进行多次试验。跟踪每个实验的性能会成为一个瓶颈。这就是海王星出现的地方。
视频
很容易将 Neptune 集成到您的管道中，并使用广泛的指标进行跟进。但不止于此。Neptune 存储试验，管理和分析结果，创建可视化，并使与其他团队成员和经理分享您的发现变得容易。
Neptune 是灵活的，因此它可以很容易地与其他机器学习框架集成，如 Scikit-learn、R、PyTorch、Ignite、HiPlot、XGBoost 和 Skorch。
此外，这个工具可以像无足轻重一样扩展。跟踪可以支持数百万次运行规模的实验。
关键特征
- 大规模数据的存储和分析。
- 使用检查点运行尽可能多的实验。
- 从最后一个检查点继续实验。
- 与团队成员和项目干系人分享见解的工具。
- 与您喜欢的机器学习库和工具集成。
- 对您的数据执行探索性数据分析。
TensorFlow — 快速轻松地构建、训练和部署模型
TensorFlow 是一个强大的开源库，用于创建和部署您的机器学习模型。它附带了一个全面的工具和资源集合，用于快速、轻松地构建一流的 ML 驱动的应用程序。
您可以在各种环境中构建、训练和部署深度学习模型，包括浏览器、设备上、内部或云。简单灵活的架构可以在训练和推理深度学习模型的过程中节省你大量的时间。
TensorFlow 是一个应用深度学习解决现实世界问题的端到端平台。它是构建各种人工智能系统的绝佳选择，如文本到语音转换、图像字幕、对象检测、语言翻译、预测分析等等。
关键特征
- 用于各种机器学习任务的端到端开源平台。
- 使用计算图形中的矢量流执行高效的数值计算。
- 跨平台，几乎可以在任何东西上运行——GPU 和 CPU，包括移动设备和嵌入式平台。
- 扩展性好，这是三星、谷歌、苹果和英伟达等公司积极使用它的原因之一。
Scikit-learn 是一个开源库，拥有大量用于构建机器学习模型和解决统计建模问题的工具。这个库主要基于 Python，构建在 matplotlib、SciPy 和 NumPy 之上。
Scikit-learn 拥有大多数用于监督、非监督和强化学习问题的流行算法。其中一些是逻辑回归、线性回归、决策树、支持向量机、主成分分析和随机森林。
使用 Scikit-learn，在任何所需的算法上训练数据集就像导入算法并调用 fit 方法一样简单。这将为您省去从头构建整个模型的压力。
关键特征
- 强大的库，支持各种机器学习算法。
- 与其他机器学习库很好地集成，例如用于数据帧的 pandas、用于数组矢量化的 numpy 和用于绘图的 matplotlib。
- 对于回归，它支持贝叶斯回归、Lasso、Ridge、SVR 和其他算法。
- 对于聚类，它支持层次聚类、k-means、DBSCAN、mean shift、谱聚类和其他算法。
- 对于分类，它支持 SVC，逻辑分类器，随机森林分类器，k-最近邻，和其他算法。
- 具有用于特征选择、特征提取、维数减少和各种预处理过程的设施。
如何跟踪你的 Sklea 模型训练元数据。
trello—无缝管理、组织、可视化和共享项目
Trello 是一个足智多谋的工具，用于管理、组织、可视化和与他人共享项目。它并不明确意味着机器学习，但它对于管理 ML 工程团队中的团队合作来说很方便。
您为每个项目创建仪表板，称为 Trello 板。公告板上贴满了卡片，每个人都可以在上面评论和讨论细节。您可以在卡片上添加文件、截止日期、清单和标签，以便让团队成员跟上您的工作进度。
对于机器学习项目，Trello 板可能包含显示数据清理、数据预处理、探索性数据分析、模型构建、模型训练和部署步骤的卡片。这样，您可以非常方便地跟踪所有团队成员的进度。
关键特征
- 与您的 ML 团队成员进行可视化协作。
- 简单的拖放式编辑功能。
- 已分配任务的进度表清单。
- 截止日期提醒和通知。
- 支持文件附件。
- 强大的备份和信息检索机制。
- 易于使用的 API，用于集成 Trello 和第三方应用程序。
- 在多种操作系统上访问—Windows、Mac OS、iOS 和 Android。
Jupyter 笔记本—轻松交互地创建和共享文档
Jupyter Notebook 是一个开源的、基于 web 的 IDE，用于交互式地创建和展示数据科学和机器学习项目。您可以使用它来开发和共享带有解释性文本、可视化、等式和实时代码的文档。
Jupyter Notebook 允许您单独运行大量代码以快速获得结果，而不直接依赖于以前的代码。在您编码时，更容易确切地知道正在发生什么。
探索性数据分析的布局无可挑剔。它也非常适合渲染可视化，尤其是在与其他库(如 seaborn、matplotlib 或 plotly)一起使用时。
Jupyter Notebook 无疑是一个有用的工具，您可能已经在使用它来提高您的机器学习项目的生产率。
关键特征
- 易于使用，保留的关键字、注释、字符串和其他短语具有出色的颜色突出显示。
- 将 Jupyter 笔记本文档转换为其他输出格式，如 PDF、LaText、HTML 和演示文稿幻灯片。
- 连接几个内核支持各种语言编程，除了 Python，R，Julia。
- 伟大的文件管理系统。文件很小，很容易检索。
- 自动保存功能。万一发生意外的系统故障，您的代码不会丢失。
- 它不仅是编程的好工具，也是演示的好工具——具有 Markdown、Raw NBConvert 和 heading 特性。
tog GL—只需一次点击，即可跟踪您的在线和离线工作时间
Toggl 是时间管理的最佳工具之一。这是一个简单而强大的工具，用来记录你在项目上花费的时间。
有了 Toggl，时间跟踪就像开始工作时点击开始按钮，结束工作时点击停止按钮一样简单。这将帮助你保持高效率，更好地管理时间。
当你无所事事时，也许你离开了你的电脑，Toggl 会自动检测空闲时间并记录下来。在一个团队中，这对于透明度来说是非常好的——尤其是在远程工作的时候。你和你的团队可以看到你实际工作了多长时间。
另一个使 Toggl 成为首选的功能是检查你在工作时间访问的网页和程序，以及你在那里花了多长时间。通过这种方式，你可以深入了解自己是如何度过上网时间的。
使用 Toggl 甚至不需要一直在线。即使你离线，它也能准确工作。
关键特征
- 只需轻轻一点，即可跨多个平台(浏览器扩展、移动应用、桌面应用和 web 应用)跟踪时间。所有跟踪的条目都会实时自动同步。
- 自动跟踪您访问的每个网站或应用程序。
- 在线和离线都有效。
- 支持日历集成，显示你的时间去哪里。
- 支持与 100 多个第三方应用程序的无缝集成，包括 Trello、Todoist 和 Asana。
- 跟踪提醒。
- 强大的报告功能提供可操作的见解。过滤和排序您的数据，并通过 PDF 或 CSV 格式导出。
- 安排您喜欢的报告定期发送到您的电子邮件中。
- 对项目管理有用。Toggl 显示你在一个项目上花了多长时间，估计完成时间，你为每项活动分配时间的情况，等等。
- 对团队管理有用。
sweet viz—用几行代码执行深入的 EDA
Sweetviz 是一个开源库，用于执行探索性数据分析(EDA)并使用几行代码创建漂亮的可视化效果。它建立在熊猫档案库的基础上。
这是提高你工作效率的好工具。它大大减少了您手动清理数据和创建每个可视化所花费的时间，因为 Sweetviz 完成了所有艰苦的工作，而您则专注于您的核心活动。它具有目标分析、比较、特征分析、关联和输出等功能，是一个完全独立的 HTML 应用程序。
Sweetviz 分析您的全部数据，并提供详细的可视化 EDA 报告。生成的报告包含许多有助于理解数据集特征的信息。
您还可以使用它来检查特定要素如何影响数据集中的其他要素、在数据集中执行要素关联以及可视化要素。
关键特征
- 执行快速 EDA 并在几行代码中生成漂亮的可视化效果。
- 分析目标变量与数据集中其他要素的关系。
- 表征数据集并找出值的分布、使用的数据类型、缺失信息等。
- 比较和可视化两个不同的数据集，如训练和测试数据。
- 为目标数据集的特征创建一个易读而可靠的摘要。
- 自动检测连续、分类和文本数据。
- 与其他机器学习工具集成，如 Jupyter Notebook 和 Google Colab。
slack—与您的团队即时、方便地沟通
Slack 是一个方便交流的即时通讯平台。这是一个在你的机器学习团队中进行高效沟通和协作的绝佳场所。
你有不同的频道(聊天室)来方便导航。您可以创建私人和公共频道。任何人都可以进入公共频道，私人频道只能由频道所有者或管理员添加的团队成员访问。
您会在工作区中收到新消息的通知，包括当您从频道注销时，尽管此功能可以在通知设置中更改。
您可以从免费版本开始，在那里您可以存储和搜索多达 10，000 条最新消息。
关键特征
- 渠道为管理与其他团队成员的交流提供了一个集中的空间。向整个团队或直接向个人发送消息。
- 文件共享、语音通话、视频通话和表情符号反应。
- 与多个第三方工具集成，如 Asana、Google Drive、Trello 和 Zendesk。
- 非常适合文件归档。您可以将频道上的旧对话存档，以供将来参考。
- 神奇的搜索引擎。您可以搜索邮件、存档，甚至文件名。
- 易于使用的 API 将 Slack 功能集成到不同的用例中。
- 在各种平台上访问，包括移动 Android 和 iOS 应用程序、网络浏览器、Windows 和 Mac OS 的桌面客户端以及 Apple Watch。
Google Cloud AutoML——利用 Google 强大的技术，以最小的工作量自动训练模型
Google Cloud AutoML 是一套强大的工具，可以在没有广泛专业知识的情况下开始训练高质量的机器学习模型。利用谷歌的技术，用最少的努力训练你的模型。
Google Cloud AutoML 使用谷歌经过实战检验和预先培训的服务。在训练模型时并不是从零开始。
为了帮助你创建满足你需求的模型，AutoML 应用了谷歌的神经架构搜索技术(它会寻找额外网络层的正确混合)，以及自动深度转移学习技术(它从已经在其他数据上训练过的现有神经网络开始)。
Google AutoML 消除了寻找合适的算法、层数、节点数、学习速率和其他超参数调整的麻烦。
有了 Google Cloud AutoML，你不用担心训练今天的神经网络所需的时间密集性或丰富的经验。您可以使用它来为您的特定业务需求设计神经网络，而无需掌握其中的复杂性。
关键特征
- 自动训练一流的机器学习模型，即使知识有限。
- 谷歌复杂的神经架构搜索技术和深度转移学习技术自动执行机器学习任务。
- 适用于各种机器学习任务，包括图像分类、自然语言分类和语言对翻译。
- 大规模验证、调整和部署您的模型。
keras——在定义和训练模型时，尽量减少认知负荷
Keras 是一个健壮的开源 API，用于构建和评估深度神经网络。它被设计成模块化、灵活和简单的——您可以使用几行代码来定义和训练模型。
注意，Keras 不能独立工作。你需要一个后端(或引擎)来驱动它。默认情况下，后端是 TensorFlow，但它也支持其他后端，如 Theano 和微软认知工具包。
Keras 在开发机器学习模型时，将认知负荷降至最低。高效的 API 减少了您实现常见用例所需的工作，因此您在处理模型时可以更有效率。
关键特征
- 一致且易于使用的 API。即使是初学者也可以在几分钟内用 Keras 建立神经网络。
- 基于 Python 的接口，用于处理深度神经网络。
- 在 CPU 和 GPU 上都能很好地工作。
- 在任何地方部署—在浏览器中使用 JavaScript，在 TF Lite 上运行在嵌入式设备、Android 或 iOS 上。
- 灵活和伟大的研究目的。
- 涵盖机器学习工作流程每个步骤的庞大生态系统-从管理原始数据，通过训练超参数，一直到部署解决方案。
- 在机器学习社区被广泛采用。由亚马逊、微软、谷歌、苹果等科技巨头支持。
检查如何使用 Neptune + TensorFlow / Keras 集成来跟踪您的模型训练元数据。
最后的想法
这些是作为机器学习工程师，你可以用来提高自己或团队工作效率的十个最佳工具。
我们概述了每个工具的关键特性，以及它们如何帮助您将机器学习开发工作提升到一个新的水平。希望这有助于您为自己的案例选择正确的工具。
10 个 NLP 项目提升你的简历
原文：https://web.archive.org/web/https://neptune.ai/blog/10-nlp-projects
自然语言处理 (NLP)是一个非常令人兴奋的领域。在我们的日常生活中，NLP 项目和应用已经随处可见。从对话代理(亚马逊 Alexa)到情绪分析(Hubspot 的客户反馈分析功能)，语言识别和翻译(谷歌翻译)，拼写纠正(语法)，等等。
无论您是对 NLP 感兴趣的开发人员还是数据科学家，为什么不跳进游泳池的深水区，边做边学呢？
借助 PyTorch 和 TensorFlow 等知名框架，您只需启动一个 Python 笔记本，就可以在几分钟内处理最先进的深度学习模型。
在这篇文章中，我将通过推荐 10 个你现在就可以开始着手的伟大项目来帮助你练习 NLP 另外，这些项目中的每一个都将是你简历上的一大亮点！
自然语言处理领域的简史
这只是关于自然语言处理的一点背景知识，但是如果你不感兴趣的话，可以直接跳到项目上。
NLP 诞生于 20 世纪中叶。一个重要的历史里程碑是 1954 年的乔治敦实验，大约 60 个俄语句子被翻译成英语。
20 世纪 70 年代见证了许多聊天机器人概念的发展，这些概念基于处理输入信息的复杂的手工规则。在 20 世纪 80 年代后期，奇异值分解(SVD)被应用于向量空间模型，导致了潜在语义分析——一种用于确定语言中单词之间关系的无监督技术。
在过去的十年里(2010 年之后)，神经网络和深度学习一直在动摇 NLP 的世界。这些技术为最困难的自然语言处理任务(如机器翻译)提供了最先进的结果。2013 年，我们拿到了 word2vec 型号及其变种。这些基于神经网络的技术以这样一种方式对单词、句子和文档进行矢量化，即所生成的向量空间中向量之间的距离表示相应实体之间的意义差异。
在 2014 年，序列到序列模型被开发出来，并在机器翻译和自动摘要等困难任务中实现了显著改进。
后来人们发现长输入序列更难处理，这使我们想到了 注意力 技术。通过让模型关注与输出最相关的输入序列部分，这改进了序列间模型的性能。transformer 模型通过为编码器和解码器定义一个自我关注层，进一步改进了这一点。
这篇名为“注意力是你所需要的一切”的论文引入了注意力机制，也使得强大的深度学习语言模型得以创建，如:
- ULM-Fit–通用语言模型微调:一种针对任何任务微调任何基于神经网络的语言模型的方法，在文本分类的上下文中演示。这种方法背后的一个关键概念是区别性微调，其中网络的不同层以不同的速率被训练。
- BERT–来自变压器的双向编码器表示:通过保留编码器和丢弃解码器对变压器架构的修改，它依赖于字的屏蔽，然后需要作为训练度量准确预测。
- GPT 生成预训练的 Transformer: 对 Transformer 的编码器-解码器架构的修改，旨在为 NLP 实现可微调的语言模型。它抛弃了编码器，保留了解码器和它们的自我关注子层。
近年来，自然语言处理领域发展最为迅速。在现代 NLP 范式中，迁移学习，我们可以将从一组任务中获得的知识调整/转移到另一组任务中。这是向 NLP 的完全民主化迈出的一大步，允许知识在新的环境中以以前所需资源的一小部分被重新使用。
为什么要构建 NLP 项目？
NLP 是人工智能、计算机科学和语言学的交叉领域。它处理与语言和信息相关的任务。理解和表达语言的意义是困难的。所以，如果你想在这个领域工作，你需要大量的实践。下面的项目将帮助你做到这一点。
构建真实世界的 NLP 项目是获得 NLP 技能并将理论知识转化为有价值的实践经验的最佳方式。
之后，当你申请 NLP 相关的工作时，你会比没有实践经验的人有很大的优势。任何人都可以在简历中加上“NLP 熟练程度”,但不是每个人都可以用一个你可以展示给招聘人员的实际项目来证明这一点。
好了，我们已经介绍够了。让我们来看看你现在就可以开始的 10 个 NLP 项目。我们有初级、中级和高级项目——选择你喜欢的项目，成为你一直想成为的 NLP 大师！
10 个 NLP 项目创意提升你的简历
我们将从初级项目开始，但是如果你已经在实践中完成了 NLP，你可以进入中级或高级项目。
初级 NLP 项目
- 营销情感分析
这种类型的项目可以向你展示作为一名 NLP 专家是什么样的。在这个项目中，您希望了解客户如何评价竞争对手的产品，即他们喜欢什么和不喜欢什么。这是一个很好的商业案例。了解客户喜欢竞争产品的什么是改进你自己产品的好方法，所以这是许多公司正在积极尝试的事情。
为了完成这项任务，你将采用不同的 NLP 方法来更深入地了解客户的反馈和意见。
立即开始项目→ 转到项目存储库
在这个项目中，您希望创建一个模型，该模型可以预测将评论分类到不同的类别中。社交媒体上的评论往往是辱骂性和侮辱性的。组织通常希望确保对话不会变得太消极。这个项目是一个 Kaggle 挑战，参与者必须提出一个解决方案，使用 NLP 方法将有毒评论分类到几个类别中。
立即开始项目→ 转到项目存储库
- 语言识别
对于初学者来说，这是一个学习基本 NLP 概念和方法的好项目。我们可以很容易地看到 Chrome 或其他浏览器是如何检测网页编写语言的。有了机器学习，这个任务就简单多了。
您可以使用脸书的 fastText 模型构建自己的语言检测。
立即开始项目→ 转到项目存储库
- 预测堆栈溢出的封闭问题
如果你是任何类型的程序员，我不需要告诉你什么是堆栈溢出。它是任何程序员最好的朋友。
程序员一直在问很多关于栈溢出的问题，有些很棒，有些是重复的，浪费时间的，或者不完整的。因此，在这个项目中，您希望预测一个新问题是否会被关闭，以及关闭的原因。
数据集有几个特征，包括问题标题文本、问题正文文本、标签、帖子创建日期等等。
立即开始项目→ 转到数据集
- 创建文本摘要器
文本摘要是自然语言处理中最有趣的问题之一。作为人类，我们很难手动提取大型文本文档的摘要。
为了解决这个问题，我们使用自动文本摘要。这是一种识别文档中有意义的信息并在保留整体意义的同时对其进行总结的方法。
目的是在保留语义的同时，呈现原始文本的较短版本。
在这个项目中，您可以使用不同的传统和先进的方法来实现自动文本摘要，然后比较每种方法的结果，以得出哪种方法最适合您的语料库。
立即开始项目→ 转到项目存储库
- 文档相似度(Quora 问题对相似度)
Quora 是一个问答平台，在这里你可以找到各种各样的信息。网站上的每一条内容都是由用户生成的，人们可以互相学习经验和知识。
在这个项目中，Quora 要求 Kaggle 用户对问题对是否重复进行分类。
这项任务需要找到高质量的问题答案，从而改善 Quora 用户从作者到读者的体验。
立即开始项目→ 转到数据集
- 转述检测任务
复述检测是检查两个不同文本实体是否具有相同含义的任务。这个项目在机器翻译、自动剽窃检测、信息提取和摘要等领域有着广泛的应用。复述检测的方法分为两大类:基于相似性的方法和分类方法。
立即开始项目→ 转到项目存储库
高级 NLP 项目
- 生成研究论文标题
这是一个非常创新的项目，你想产生科学论文的标题。在这个项目中，一个 GPT-2 在从 arXiv 中提取的 2000 多个文章标题上进行训练。你可以在其他事情上使用这个应用程序，比如产生歌词、对话等文本生成任务。从这个项目中，您还可以了解 web 抓取，因为您需要从研究论文中提取文本，以便将其提供给模型进行训练。
立即开始项目→ 转到项目存储库
- 翻译和总结新闻
你可以构建一个 web 应用程序，将新闻从阿拉伯语翻译成英语，并对它们进行总结，使用伟大的 Python 库，如报纸、变形金刚和 gradio 。
其中:
立即开始项目→ 有用链接
- 用于相似性检查的 RESTful API
这个项目是关于建立一个使用 NLP 技术的相似性检查 API。这个项目最酷的地方不仅在于实现 NLP 工具，还在于你将学会如何通过 docker 上传这个 API，并把它作为一个 web 应用程序来使用。通过这样做，您将学习如何构建一个完整的 NLP 应用程序。
立即开始项目→ 转到项目存储库
结论
就是这样！希望你能选择一个你感兴趣的项目。把手弄脏，开始学习 NLP 技能吧！建立真正的项目是在这方面做得更好的唯一最好的方法，也是改善你的简历的最好方法。
目前就这些。感谢阅读！
你现在可以做的 15 个计算机视觉项目
原文：https://web.archive.org/web/https://neptune.ai/blog/15-computer-visions-projects
计算机视觉处理计算机如何从图像或视频中提取有意义的信息。它具有广泛的应用，包括逆向工程、安全检查、图像编辑和处理、计算机动画、自主导航和机器人。
在本文中，我们将探索 15 个伟大的 OpenCV 项目，从初级到专家级。对于每个项目，你都会看到基本指南、源代码和数据集，所以如果你愿意，你可以直接开始工作。
什么是计算机视觉？
计算机视觉就是帮助机器解读图像和视频。它是通过数字媒体与对象进行交互，并使用传感器来分析和理解它所看到的东西的科学。这是一个广泛的学科，对机器翻译、模式识别、机器人定位、3D 重建、无人驾驶汽车等等都很有用。
由于不断的技术创新，计算机视觉领域不断发展，变得越来越有影响力。随着时间的推移，它将为研究人员、企业以及最终消费者提供越来越强大的工具。
今天的计算机视觉
由于 AI 的进步，计算机视觉近年来已经成为一种相对标准的技术。许多公司将其用于产品开发、销售运营、营销活动、访问控制、安全等。
*Source: Author *
计算机视觉在医疗保健(包括病理学)、工业自动化、军事用途、网络安全、汽车工程、无人机导航等领域有大量的应用——不胜枚举。
计算机视觉是如何工作的？
机器学习通过从错误中学习来发现模式。训练数据做一个模型，这个模型对事物进行猜测和预测。现实世界的图像被分解成简单的模式。计算机使用多层神经网络来识别图像中的模式。
第一层获取像素值并尝试识别边缘。接下来的几层将尝试在边缘的帮助下检测简单的形状。最后，将所有这些放在一起以理解图像。
*Source: Author *
训练一个计算机视觉应用程序可能需要数以千计、有时数百万计的图像。有时甚至这还不够——一些面部识别应用程序无法检测不同肤色的人，因为它们是针对白人进行训练的。有时，应用程序可能无法找出狗和百吉饼之间的区别。最终，算法只会和用于训练它的数据一样好。
好了，介绍够了！让我们进入项目。
面向所有经验水平的计算机视觉项目
初级计算机视觉项目
如果你是新手或正在学习计算机视觉，这些项目将帮助你学到很多东西。
1.边缘和轮廓检测
如果你是计算机视觉的新手，这个项目是一个很好的开始。CV 应用程序首先检测边缘，然后收集其他信息。有许多边缘检测算法，最流行的是 Canny 边缘检测器，因为它与其他算法相比非常有效。这也是一种复杂的边缘检测技术。以下是 Canny 边缘检测的步骤:
- 降低噪声和平滑图像，
- 计算梯度，
- 非最大抑制，
- 门槛翻倍，
- 链接和边沿检测–滞后。
Canny 边缘检测代码:
import cv2
import matplotlib.pyplot as plt
img = cv2.imread('dancing-spider.jpg')
edges = cv2.Canny(img, 100, 200, 3, L2gradient=True)
plt.figure()
plt.title('Spider')
plt.imsave('dancing-spider-canny.png', edges, cmap='gray', format='png')
plt.imshow(edges, cmap='gray')
plt.show()
轮廓是连接所有连续物体或点(沿边界)的线，具有相同的颜色或强度。例如，它根据叶子的参数或边界来检测叶子的形状。轮廓是形状和物体检测的重要工具。物体的轮廓是构成物体本身形状的边界线。轮廓也被称为轮廓、边缘或结构，有一个很好的理由:它们是标记深度变化的一种方式。
查找轮廓的代码:
import cv2
import numpy as np
image = cv2.imread('C://Users//gfg//shapes.jpg')
cv2.waitKey(0)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
edged = cv2.Canny(gray, 30, 200)
cv2.waitKey(0)
contours, hierarchy = cv2.findContours(edged,
cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
cv2.imshow('Canny Edges After Contouring', edged)
cv2.waitKey(0)
print("Number of Contours found = " + str(len(contours)))
cv2.drawContours(image, contours, -1, (0, 255, 0), 3)
cv2.imshow('Contours', image)
cv2.waitKey(0)
cv2.destroyAllWindows()
推荐阅读&源代码:
2.颜色检测和隐形斗篷
这个项目是关于检测图像中的颜色。您可以使用它来编辑和识别图像或视频中的颜色。使用颜色检测技术的最流行的项目是隐身衣。在电影中，隐形是通过在绿色屏幕上执行任务来实现的，但在这里我们将通过移除前景层来实现。隐身衣的过程是这样的:
- 捕获并存储背景帧(仅仅是背景)，
- 检测颜色，
- 生成一个掩码，
- 生成最终输出以创建不可见的效果。
作用于 HSV(色调饱和度值)。 HSV 是 Lightroom 允许我们更改照片颜色范围的三种方式之一。这对于从图像或场景中引入或移除某些颜色特别有用，例如将夜间拍摄更改为白天拍摄(反之亦然)。就是颜色部分，从 0 到 360 识别。将该分量减少到零会引入更多的灰色并产生褪色效果。
值(亮度)与饱和度结合使用。它描述了颜色的亮度或强度，从 0 到 100%。所以 0 是全黑，100 是最亮的，透露最多的颜色。
推荐阅读&源代码:
3.使用 OpenCV 和 Tesseract (OCR)进行文本识别
在这里，您在图像上使用 OpenCV 和 OCR(光学字符识别)来识别每个字母并将其转换为文本。它非常适合任何希望从图像或视频中获取信息并将其转化为基于文本的数据的人。许多应用程序使用 OCR，如谷歌镜头、PDF 扫描仪等。
从图像中检测文本的方法:
- 使用 OpenCV–流行，
- 使用深度学习模型——最新的方法，
- 使用您的自定义模型。
使用 OpenCV 进行文本检测
处理图像和轮廓检测后的示例代码:
def contours_text(orig, img, contours):
for cnt in contours:
x, y, w, h = cv2.boundingRect(cnt)
rect = cv2.rectangle(orig, (x, y), (x + w, y + h), (0, 255, 255), 2)
cv2.imshow('cnt',rect)
cv2.waitKey()
cropped = orig[y:y + h, x:x + w]
config = ('-l eng --oem 1 --psm 3')
text = pytesseract.image_to_string(cropped, config=config)
print(text)
使用宇宙魔方进行文本检测
这是一个开源应用程序，可以识别 100 多种语言的文本，它得到了谷歌的支持。您还可以训练该应用程序识别许多其他语言。
使用 tesseract 检测文本的代码:
import cv2
import pytesseract
im = cv2.imread('./testimg.jpg')
config = ('-l eng --oem 1 --psm 3')
text = pytesseract.image_to_string(im, config=config)
text = text.split('\n')
text
推荐阅读&数据集:
4.用 Python 和 OpenCV 实现人脸识别
距离美国电视节目《犯罪现场调查:犯罪现场调查》首播已经过去十多年了。在此期间，面部识别软件变得越来越复杂。如今的软件不受皮肤或头发颜色等表面特征的限制，相反，它根据面部特征识别面部，这些特征通过外观的变化更加稳定，如眼睛形状和两眼之间的距离。这种类型的面部识别被称为“模板匹配”。你可以使用 OpenCV、深度学习或自定义数据库来创建面部识别系统/应用程序。
从图像中检测人脸的过程:
- 查找人脸位置和编码，
- 使用人脸嵌入提取特征，
- 人脸识别，对比那些人脸。
* Image source: The Times, Face Recognition: Author*
下面是从图像中识别人脸的完整代码:
import cv2
import face_recognition
imgmain = face_recognition.load_image_file('ImageBasics/Bryan_Cranst.jpg')
imgmain = cv2.cvtColor(imgmain, cv2.COLOR_BGR2RGB)
imgTest = face_recognition.load_image_file('ImageBasics/bryan-cranston-el-camino-aaron-paul-1a.jpg')
imgTest = cv2.cvtColor(imgTest, cv2.COLOR_BGR2RGB)
faceLoc = face_recognition.face_locations(imgmain)[0]
encodeElon = face_recognition.face_encodings(imgmain)[0]
cv2.rectangle(imgmain, (faceLoc[3], faceLoc[0]), (faceLoc[1], faceLoc[2]), (255, 0, 255), 2)
faceLocTest = face_recognition.face_locations(imgTest)[0]
encodeTest = face_recognition.face_encodings(imgTest)[0]
cv2.rectangle(imgTest, (faceLocTest[3], faceLocTest[0]), (faceLocTest[1], faceLocTest[2]), (255, 0, 255), 2)
results = face_recognition.compare_faces([encodeElon], encodeTest)
faceDis = face_recognition.face_distance([encodeElon], encodeTest)
print(results, faceDis)
cv2.putText(imgTest, f'{results} {round(faceDis[0], 2)}', (50, 50), cv2.FONT_HERSHEY_COMPLEX, 1, (0, 0, 255), 2)
cv2.imshow('Main Image', imgmain)
cv2.imshow('Test Image', imgTest)
cv2.waitKey(0)
从网络摄像头或直播摄像机中识别人脸的代码:
cv2.imshow("Frame", frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
video_capture.release()
cv2.destroyAllWindows()
推荐阅读&数据集:
5.目标检测
对象检测是对给定图像或视频帧中的对象的自动推断。它用于自动驾驶汽车、跟踪、人脸检测、姿势检测等等。有 3 种主要类型的对象检测-使用 OpenCV，一种基于机器学习的方法和一种基于深度学习的方法。
下面是检测物体的完整代码:
import cv2
cap = cv2.VideoCapture(0)
cap.set(3, 640)
cap.set(4, 420)
faceCascade = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")
'''
# if you want to detect any object for example eyes, use one more layer of classifier as below:
eyeCascade = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_eye_tree_eyeglasses.xml")
'''
while True:
success, img = cap.read()
imgGray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = faceCascade.detectMultiScale(imgGray, 1.3, 5)
for (x, y, w, h) in faces:
img = cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 3)
'''
# detecting eyes
eyes = eyeCascade.detectMultiScale(imgGray)
# drawing bounding box for eyes
for (ex, ey, ew, eh) in eyes:
img = cv2.rectangle(img, (ex, ey), (ex+ew, ey+eh), (255, 0, 0), 3)
'''
cv2.imshow('face_detect', img)
if cv2.waitKey(10) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyWindow('face_detect')
推荐阅读&数据集:
我们正在通过几个中级项目将事情推进到下一个级别。这些项目可能比初学者项目更有趣，但也更具挑战性。
6.手势识别
在这个项目中，你需要检测手势。检测到手势后，我们将向它们分配命令。您甚至可以使用手势识别功能通过多个命令玩游戏。
手势识别的工作原理:
- 安装 Pyautogui 库——它有助于在没有用户交互的情况下控制鼠标和键盘，
- 将其转换成 HSV，
- 找到轮廓，
- 分配任意值的命令–下面我们使用 5(从手)来跳转。
*Source: Author *
用手势玩恐龙游戏的完整代码:
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
try:
contour = max(contours, key=lambda x: cv2.contourArea(x))
x, y, w, h = cv2.boundingRect(contour)
cv2.rectangle(crop_image, (x, y), (x + w, y + h), (0, 0, 255), 0)
hull = cv2.convexHull(contour)
drawing = np.zeros(crop_image.shape, np.uint8)
cv2.drawContours(drawing, [contour], -1, (0, 255, 0), 0)
cv2.drawContours(drawing, [hull], -1, (0, 0, 255), 0)
hull = cv2.convexHull(contour, returnPoints=False)
defects = cv2.convexityDefects(contour, hull)
count_defects = 0
for i in range(defects.shape[0]):
s, e, f, d = defects[i, 0]
start = tuple(contour[s][0])
end = tuple(contour[e][0])
far = tuple(contour[f][0])
a = math.sqrt((end[0] - start[0]) ** 2 + (end[1] - start[1]) ** 2)
b = math.sqrt((far[0] - start[0]) ** 2 + (far[1] - start[1]) ** 2)
c = math.sqrt((end[0] - far[0]) ** 2 + (end[1] - far[1]) ** 2)
angle = (math.acos((b ** 2 + c ** 2 - a ** 2) / (2 * b * c)) * 180) / 3.14
if angle <= 90:
count_defects += 1
cv2.circle(crop_image, far, 1, [0, 0, 255], -1)
cv2.line(crop_image, start, end, [0, 255, 0], 2)
if count_defects >= 4:
pyautogui.press('space')
cv2.putText(frame, "JUMP", (115, 80), cv2.FONT_HERSHEY_SIMPLEX, 2, 2, 2)
推荐阅读&源代码:
7.人体姿态检测
许多应用程序使用人体姿势检测来查看玩家在特定游戏(例如棒球)中的表现。最终目标是定位体内的标志点。人体姿态检测用于许多现实生活视频和基于图像的应用，包括体育锻炼、手语检测、舞蹈、瑜伽等等。
推荐阅读&数据集:
8.自主车辆中的道路车道检测
如果你想进入自动驾驶汽车，这个项目将是一个很好的开始。你会发现车道，道路的边缘，等等。车道检测是这样工作的:
- 敷面膜，
- 进行图像阈值处理(阈值处理通过用相应的灰度级替换每个像素> =指定的灰度级来将图像转换为灰度级)，
- 做霍夫线变换(检测车道线)。
*Source: Author *
推荐阅读&数据集:
9.病理学分类
计算机视觉正在医疗保健领域崭露头角。病理学家一天要分析的数据量可能太多，难以处理。幸运的是，深度学习算法可以识别大量数据中的模式，否则人类不会注意到这些模式。随着更多的图像被输入并分类成组，这些算法的准确性随着时间的推移变得越来越好。
它可以检测植物、动物和人类的各种疾病。对于这个应用程序，目标是从 Kaggle OCT 获取数据集，并将数据分类到不同的部分。该数据集大约有 85000 张图片。光学相干断层扫描(OCT)是一种用于执行高分辨率横截面成像的新兴医疗技术。光学相干断层扫描术利用光波来观察活体内部。它可以用于评估变薄的皮肤、破裂的血管、心脏病和许多其他医学问题。
随着时间的推移，它已经获得了全球医生的信任，成为一种比传统方法更快速有效的诊断优质患者的方法。它还可以用来检查纹身色素或评估烧伤病人身上不同层次的皮肤移植。
用于分类的 Gradcam 库代码:
from tf_explain.callbacks.occlusion_sensitivity import OcclusionSensitivityCallback
import datetime
%load_ext tensorboard
log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)
o_callbacks = [OcclusionSensitivityCallback(validation_data=(vis_test, vis_lab),class_index=2,patch_size=4),]
model_TF.compile(optimizer=keras.optimizers.Adam(lr=0.001), loss='binary_crossentropy', metrics=[fbeta])
model_TF.fit(vis_test, vis_lab, epochs=10, verbose=1, callbacks=[tensorboard_callback, o_callbacks])
推荐阅读&数据集:
10.用于图像分类的时尚 MNIST
最常用的 MNIST 数据集之一是手写图像数据库，它包含大约 60，000 个训练图像和 10，000 个从 0 到 9 的手写数字的测试图像。受此启发，他们创建了时装 MNIST，将衣服分类。由于 MNIST 提供的大型数据库和所有资源，您可以获得 96-99%的高准确率。
这是一个复杂的数据集，包含来自 ASOS 或 H&M 等在线商店的 60，000 幅服装(35 个类别)的训练图像。这些图像分为两个子集，一个子集包含与时尚行业类似的服装，另一个子集包含属于普通大众的服装。该数据集包含每个类别的 120 万个样本(衣服和价格)。
推荐阅读&数据集:
高级计算机视觉项目
一旦你成为计算机视觉专家，你就可以根据自己的想法开发项目。如果你有足够的技能和知识，下面是一些高级的有趣项目。
11.使用生成对抗网络的图像去模糊
图像去模糊是一项有趣的技术，有着广泛的应用。在这里，一个生成式对抗网络(GAN)会自动训练一个生成式模型，就像 Image DeBlur 的 AI 算法一样。在研究这个项目之前，让我们先了解什么是 gan 以及它们是如何工作的。
生成对抗网络是一种新的深度学习方法，在各种计算机视觉任务中显示出前所未有的成功，如图像超分辨率。然而，如何最好地训练这些网络仍然是一个公开的问题。一个生成性的对抗网络可以被认为是两个相互竞争的网络；就像人类在像《危险边缘》或《幸存者》这样的游戏节目中相互竞争一样。双方都有任务，需要在整个游戏中根据对手的外貌或招式想出策略，同时也要尽量不被先淘汰。去模糊训练包括 3 个主要步骤:
- 使用发生器创建基于噪声的假输入，
- 用真实和虚假的场景训练它，
- 训练整个模型。
推荐阅读&数据集:
12.图像变换
有了这个项目，你可以将任何图像转换成不同的形式。例如，您可以将真实图像转换为图形图像。这是一个有创意和有趣的项目。当我们使用标准 GAN 方法时，很难转换图像，但对于这个项目，大多数人使用循环 GAN。
这个想法是你训练两个相互竞争的神经网络。一个网络创建新的数据样本，称为“生成器”，而另一个网络判断它是真是假。生成器改变其参数，试图通过产生更真实的样本来愚弄法官。通过这种方式，两个网络都随着时间的推移而改进，并不断改进——这使得 GANs 成为一个持续的项目，而不是一次性的任务。这是一种不同类型的 GAN，是 GAN 架构的扩展。Gan 所做的循环是创建一个产生输入的循环。假设你正在使用谷歌翻译，你将英语翻译成德语，你打开一个新的标签，复制德语输出，并将德语翻译成英语——这里的目标是获得你的原始输入。下面是一个将图像转换成艺术品的例子。
推荐阅读&源代码:
13.使用深度神经网络的照片自动着色
当涉及到给黑白图像着色时，机器从来都不能胜任。他们不能理解灰色和白色之间的界限，导致一系列看起来不现实的单色色调。为了克服这个问题，加州大学伯克利分校的科学家和微软研究院的同事一起开发了一种新的算法，通过使用深度神经网络自动给照片着色。
深度神经网络是一种非常有前途的图像分类技术，因为它们可以通过查看许多图片来学习图像的组成。密集连接的卷积神经网络(CNN)已被用于分类图像在这项研究中。CNN 使用大量标记数据进行训练，并输出对应于任何输入图像的相关类别标签的分数。它们可以被认为是应用于原始输入图像的特征检测器。
着色是给黑白照片添加颜色的过程。它可以手工完成，但这是一个繁琐的过程，需要几个小时或几天，这取决于照片的细节水平。最近，用于图像识别任务(如面部识别和文本检测)的深度神经网络出现了爆炸式增长。简单来说，就是给灰度图像或视频添加颜色的过程。然而，随着近年来深度学习的快速发展，卷积神经网络(CNN)可以通过在每像素的基础上预测颜色应该是什么来为黑白图像着色。这个项目有助于给旧照片上色。正如你在下图中看到的，它甚至可以正确地预测可口可乐的颜色，因为有大量的数据集。
推荐阅读&导读:
14.车辆计数和分类
现在，许多地方都配备了将 AI 与摄像头结合的监控系统，从政府组织到私人设施。这些基于人工智能的摄像头在许多方面都有帮助，其中一个主要功能是统计车辆数量。它可以用来计算经过或进入任何特定地方的车辆数量。这个项目可以用于许多领域，如人群计数，交通管理，车辆牌照，体育，等等。过程很简单:
- 帧差分，
- 图像阈值处理，
- 轮廓寻找，
- 图像膨胀。
最后，车辆计数:
推荐阅读&数据集:
15.汽车牌照扫描仪
计算机视觉中的车辆牌照扫描仪是一种计算机视觉应用，可用于识别牌照并读取其号码。这项技术用于各种目的，包括执法、识别被盗车辆和追踪逃犯。
计算机视觉中更复杂的车辆牌照扫描仪可以在高速公路和城市街道的繁忙交通条件下，以 99%的准确率每分钟扫描、读取和识别数百甚至数千辆汽车，距离最远可达半英里。这个项目在很多情况下非常有用。
目标是首先检测车牌，然后扫描上面写的数字和文字。它也被称为自动车牌检测系统。过程很简单:
- 捕捉图像，
- 搜索车牌，
- 过滤图像，
- 使用行分段进行行分隔，
- 数字和字符的 OCR。
推荐阅读&数据集:
结论
就是这样！希望你喜欢计算机视觉项目。最重要的是，我会留给你几个你可能会感兴趣的额外项目。
额外项目
- 照片素描
- 拼贴马赛克生成器
- 模糊脸部
- 图象分割法
- 数独求解器
- 目标跟踪
- 水印图像
- 图像反向搜索引擎
额外研究和推荐阅读
哈希尔·帕特尔
Android 开发者和机器学习爱好者。我热衷于开发移动应用程序、制造创新产品和帮助用户。
阅读下一篇
ML 实验跟踪:它是什么，为什么重要，以及如何实施
10 分钟阅读|作者 Jakub Czakon |年 7 月 14 日更新
10 mins read | Author Jakub Czakon | Updated July 14th, 2021
我来分享一个听了太多次的故事。
“…我们和我的团队正在开发一个 ML 模型，我们进行了大量的实验，并获得了有希望的结果…
…不幸的是，我们无法确切地说出哪种性能最好，因为我们忘记了保存一些模型参数和数据集版本…
…几周后，我们甚至不确定我们实际尝试了什么，我们需要重新运行几乎所有的东西"
不幸的 ML 研究员。
事实是，当你开发 ML 模型时，你会进行大量的实验。
这些实验可能:
使用不同的模型和模型超参数
- 使用不同的培训或评估数据，
- 运行不同的代码(包括您想要快速测试的这个小变化)
- 在不同的环境中运行相同的代码(不知道安装的是 PyTorch 还是 Tensorflow 版本)
- 因此，它们可以产生完全不同的评估指标。
跟踪所有这些信息会很快变得非常困难。特别是如果你想组织和比较这些实验，并且确信你知道哪个设置产生了最好的结果。
这就是 ML 实验跟踪的用武之地。
This is where ML experiment tracking comes in.
你真的应该知道的 6 种 GAN 架构
原文：https://web.archive.org/web/https://neptune.ai/blog/6-gan-architectures
生成对抗网络(GANs)是由 Ian Goodfellow 等人在 2014 年首次提出的。艾尔。从那时起，这个话题本身就开辟了一个新的研究领域。
几年之内，研究团体提出了大量关于这个主题的论文，其中一些有着非常有趣的名字:)。首先是 CycleGAN，然后是 BiCycleGAN，然后是 ReCycleGAN，依此类推。
随着 GANs 的发明，生成模型开始在生成真实图像方面显示出有希望的结果。甘斯在计算机视觉领域取得了巨大的成功。最近，它开始在音频和文本方面显示出有希望的结果。
一些最受欢迎的 GAN 配方有:
- 将图像从一个域变换到另一个域(CycleGAN)，
- 从文本描述生成图像(文本到图像)，
- 生成非常高分辨率的图像(ProgressiveGAN)等等。
在本文中，我们将讨论一些最流行的 GAN 架构，特别是您应该了解的 6 架构 ，以便对生成性对抗网络(GAN)进行多样化的报道。
即:
- CycleGAN
- StyleGAN
- 像素网络
- 文本-2-图像
- 迪斯科根
- 伊斯甘
香草甘
在监督学习的背景下有两种模型，生成模型和判别模型。判别模型主要用于解决分类任务，其中模型通常学习决策边界来预测数据点属于哪个类。另一方面，生成模型主要用于生成遵循与训练数据分布相同的概率分布的合成数据点。我们讨论的话题， 生成性对抗网络(GANs)就是生成性模型 的一个例子。
生成模型的主要目标是学习对训练观测值进行采样的群体的未知概率分布。一旦模型训练成功，您就可以对遵循训练分布的新的“生成的”观察值进行采样。
我们来讨论一下 GAN 公式的核心概念。
GAN 由两个独立的网络、一个发生器和一个鉴别器组成。
GAN 发生器架构
发生器在给定随机噪声[从潜在空间采样]的情况下生成合成样本，鉴别器是一个二元分类器，用于区分输入样本是真实的[输出标量值 1]还是虚假的[输出标量值 0]。
由生成器生成的样本被称为假样本。正如您在图 1 和图 2 中看到的，当训练数据集中的一个数据点作为输入提供给鉴别器时，它会将其作为真实样本调用，而当它由生成器生成时，它会将另一个数据点作为假样本调用。
Fig1: Generator and Discriminator as GAN building blocks
这个公式的美妙之处在于生成器和鉴别器之间的对立性质。
GAN 鉴频器架构
鉴别者希望以最好的方式完成自己的工作。 当一个[由发生器生成的]假样本被提供给鉴别器时，它想称其为假样本，但发生器想以某种方式生成样本，使鉴别器错误地称其为真样本。在某种意义上，生成器试图欺骗鉴别器。
Fig2: Generator and Discriminator as GAN building blocks
让我们快速看一下目标函数以及优化是如何完成的。 这是一个最小-最大优化公式，其中生成器想要最小化目标函数，而鉴别器想要最大化相同的目标函数。
图 3 描述了被优化的目标函数。鉴别函数称为 D，发生函数称为 g。Pz 是潜在空间的概率分布，通常为随机高斯分布。Pdata 是训练数据集的概率分布。当 x 从 Pdata 中采样时，鉴别器希望将其归类为真实样本。G(z)是一个生成的样本，当 G(z)作为输入被提供给鉴别器时，它想把它归类为一个伪样本。
Fig3: Objective function in GAN formulation
鉴别器想把 D(G(z))的可能性驱动到 0。因此，它希望最大化(1-D(G(z)))，而生成器希望将 D(G(z))的似然性强制为 1，以便鉴别器在调用生成的样本作为真实样本时出错。因此，生成器希望最小化(1-D(G(z))。
Fig4: Objective function in GAN formulation
CycleGAN
CycleGAN 是一种非常流行的 GAN 架构，主要用于学习不同风格的图像之间的转换。
作为一个例子，这种提法可以学到:
艺术图像和现实图像之间的映射，
- 马和斑马图像之间的转换，
- 冬季意象与夏季意象的转换
- 等等
- FaceApp 是 CycleGAN 最受欢迎的例子之一，其中人脸被转换为不同的年龄组。
举个例子，假设 X 是一组马的图像，Y 是一组斑马的图像。
目标是学习一个映射函数 G: X-> Y，使得 G(X)生成的图像与 Y 的图像不可区分。这个公式不仅学习 G，而且还学习逆映射函数 F: Y->X，并使用循环一致性损失来强制 F(G(X)) = X，反之亦然。
训练时，给出两种训练观察值作为输入。
一组观察值有成对的图像{Xi，易}用于 I，其中每个 Xi 都有其对应的易。
- 另一组观察具有来自 X 的一组图像和来自 Y 的另一组图像，而在和易之间没有任何匹配。
- 正如我之前提到的，有两种函数正在学习，其中一种是 G，将 X 转换为 Y，另一种是 F，将 Y 转换为 X，它包括两个独立的 GAN 模型。所以，你会发现 2 个鉴别函数 Dx，Dy。
Fig5: The training procedure for CycleGAN.
作为对抗性公式的一部分，有一个鉴别器 Dx，用于对转换后的 Y 是否与 Y 不可区分进行分类。类似地，还有一个鉴别器 d Y，用于对是否与 x 不可区分进行分类。
除了对抗损失，CycleGAN 还使用循环一致性损失来实现没有成对图像的训练，并且这种额外的损失帮助模型最小化重建损失 F(G(x)) ≈ X 和 G(F(Y)) ≈ Y
因此，All-in-all CycleGAN 配方包含如下 3 种损失:
作为优化的一部分，下面的损失函数被优化。
让我们来看看来自 CycleGAN 的一些结果。如您所见，该模型已经学会了将斑马图像转换为马图像，将夏季图像转换为冬季图像，反之亦然。
下面是不同损失函数的代码片段。完整的代码流程请参考以下参考。
CycleGAN
下面是一个例子，一个马的图像被转换成一个看起来像斑马的图像。
fake_y = generator_g(real_x, training=True)
cycled_x = generator_f(fake_y, training=True)
fake_x = generator_f(real_y, training=True)
cycled_y = generator_g(fake_x, training=True)
same_x = generator_f(real_x, training=True)
same_y = generator_g(real_y, training=True)
disc_real_x = discriminator_x(real_x, training=True)
disc_real_y = discriminator_y(real_y, training=True)
disc_fake_x = discriminator_x(fake_x, training=True)
disc_fake_y = discriminator_y(fake_y, training=True)
gen_g_loss = generator_loss(disc_fake_y)
gen_f_loss = generator_loss(disc_fake_x)
total_cycle_loss = calc_cycle_loss(real_x, cycled_x) + \
calc_cycle_loss(real_y,cycled_y)
total_gen_g_loss = gen_g_loss + total_cycle_loss + identity_loss(real_y, same_y)
total_gen_f_loss = gen_f_loss + total_cycle_loss + identity_loss(real_x, same_x)
disc_x_loss = discriminator_loss(disc_real_x, disc_fake_x)
disc_y_loss = discriminator_loss(disc_real_y, disc_fake_y)
参考文献:
研究论文:【https://arxiv.org/pdf/1703.10593.pdf】T2
Tensorflow 有一个关于 CycleGAN 的有据可查的教程。请参考以下网址作为参考:
https://www.tensorflow.org/tutorials/generative/cyclegan
stylenan
你能猜出哪个图像(从下面的 2 个图像中)是真实的，哪个是 GAN 生成的吗？
事实是，这两个图像都是由一种叫做 StyleGAN 的 GAN 公式想象出来的。
StyleGAN 是一种 GAN 配方，能够生成非常高分辨率的图像，甚至是 10241024 的分辨率。 这个想法是建立一个层的堆栈，其中初始层能够生成低分辨率图像(从 22 开始),并且进一步的层逐渐增加分辨率。
GAN 生成高分辨率图像的最简单方法是记住来自训练数据集的图像，并且在生成新图像时，它可以向现有图像添加随机噪声。实际上，StyleGAN 并不这样做，而是学习关于人脸的特征，并生成现实中不存在的人脸的新图像。如果这听起来很有趣，请访问https://thispersondoesnotexist.com/每次访问这个网址都会生成一张宇宙中不存在的人脸的新图像。
该图描述了 StyleGAN 的典型架构。潜在空间向量 z 通过由 8 个完全连接的层组成的映射变换，而合成网络由 18 层组成，其中每层产生从 4×4 到 1024×1024 的图像。输出层通过单独的卷积层输出 RGB 图像。这种架构有 2620 万个参数，由于可训练参数的数量非常大，因此该模型需要大量的训练图像来构建成功的模型。
This figure depicts the typical architecture of StyleGAN. The latent space vector z is passed through a mapping transformation comprises of 8 fully connected layers whereas the synthesis network comprises of 18 layers, where each layer produces image from 4 x 4 to 1024 x 1024. The output layer output RGB image through a separate convolution layer. This architecture has 26.2 million parameters and because of this very high number of trainable parameters, this model requires a huge number of training images to build a successful model.
使用自适应实例规范化(AdaIN)函数对每个层进行规范化，如下所示:
其中每个特征图 xi 被单独归一化，然后使用来自样式 y 的相应标量分量进行缩放和偏置。因此，y 的维数是该层上特征图数量的两倍。
参考文献:
论文:https://arxiv.org/pdf/1812.04948.pdf
github:https://github.com/NVlabs/stylegan
像素网络
PixelRNN 是自回归生成模型的一个例子。
在社交媒体时代，有大量的图片。但是在无人监管的环境下学习自然图像的分布是非常困难的。PixelRNN 能够模拟图像的离散概率分布，并在两个空间维度上预测图像的像素。
我们都知道，rnn 在学习条件分布方面很强大，尤其是 LSTM 擅长学习一系列像素中的长期依赖性。这个公式以渐进的方式工作，其中当提供了所有像素 X [0] 到 X [i] 时，模型预测下一个像素 X [i+1] 。
We all know that RNNs are powerful in learning conditional distribution, especially LSTM is good at learning the long-term dependency in a series of pixels. This formulation works in a progressive fashion where the model predicts the next pixel X[i+1] when all pixels X[0] to X[i] are provided.
与 gan 相比，PixelRNN 等自回归模型学习显式数据分布，而 gan 学习隐式概率分布。正因为如此，GAN 并没有明确地揭示概率分布，而是允许我们从已知的概率分布中抽样观察。
该图描述了 pixelRNN 的各个剩余块。它被训练到几层深度。PixelRNN LSTM 图层的输入地图具有 2h 要素。输入至状态组件通过在每个门产生 h 个特性来减少特性数量。应用递归图层后，通过 1 × 1 卷积将输出地图向上采样回每个位置 2h 个要素，并将输入地图添加到输出地图。
【来源:https://arxiv.org/pdf/1601.06759.pdf#page=9&zoom = 100，0，0
参考文献:
论文:https://arxiv.org/pdf/1601.06759.pdf
github:https://github.com/carpedm20/pixel-rnn-tensorflow
文本-2-图像
生成性对抗网络擅长生成随机图像。作为一个例子，在猫的图像上被训练的 GAN 可以生成具有两只眼睛、两只耳朵、胡须的猫的随机图像。但是猫身上的颜色图案可能是随机的。因此，随机图像通常对解决业务用例没有用处。现在，要求甘根据我们的期望生成一个图像，是一个极其困难的任务。
在本节中，我们将讨论一种 GAN 架构，它在基于明确的文本描述生成有意义的图像方面取得了重大进展。该 GAN 公式采用文本描述作为输入，并生成文本描述中描述的 RGB 图像。
作为一个例子，给定“这朵花有许多小的圆形粉红色花瓣”作为输入，它将生成一朵有圆形粉红色花瓣的花的图像。
在这个公式中，不是只给噪声作为生成器的输入，而是首先将文本描述转换成文本嵌入，与噪声向量连接，然后给生成器作为输入。
作为一个例子，文本描述已经被转换成 256 维的嵌入，并与 100 维的噪声向量(从通常为随机正态分布的潜在空间中采样)连接。
这个公式将帮助生成器生成与输入描述一致的图像，而不是生成随机图像。
对于鉴别器，不是将唯一的图像作为输入，而是将一对图像和文本嵌入作为输入发送。输出信号为 0 或 1。早先，鉴别者的职责只是预测一张给定的图像是真是假。
现在，鉴别者又多了一个额外的责任。除了识别给定图像是可读的还是伪造的，它还预测给定图像和文本是否相互对齐的可能性。
这个公式迫使生成器不仅生成看起来真实的图像，而且生成与输入文本描述一致的图像。
为了实现鉴别器的双重责任的目的，在训练期间，一系列不同的(图像、文本)对被作为模型的输入给出，如下:
作为输入和目标变量的(真实图像、真实字幕)对被设置为 1
- (错误图像，真实字幕)对作为输入，目标变量设置为 0
- 作为输入和目标变量的(伪图像、真实字幕)对被设置为 0
- 给定真实图像和真实字幕对，使得模型学习给定图像和文本对是否彼此对齐。错误的图像，阅读说明意味着图像不像说明中描述的那样。在这种情况下，目标变量被设置为 0，以便模型知道给定的图像和标题没有对齐。这里假图像是指由生成器生成的图像，在这种情况下，目标变量被设置为 0，以便鉴别器模型可以区分真实图像和假图像。
用于训练的训练数据集具有图像以及描述图像属性的 10 种不同的文本描述。
以下是来自训练的文本-2-图像模型的一些结果。
参考文献:
研究论文:【https://arxiv.org/pdf/1605.05396.pdf】T2
Github:https://github.com/paarthneekhara/text-to-image
迪科曼
最近，DiscoGAN 变得非常受欢迎，因为它能够在无监督数据的情况下学习跨域关系。
对于人类来说，跨域关系是非常自然的。给定两个不同领域的图像，人类可以找出它们之间的关系。例如，在下图中，我们有来自两个不同领域的图像，只需看一眼这些图像，我们就可以很容易地发现它们因其外观颜色的性质而相关联。
现在，在给定来自 2 个不同领域的不成对图像的情况下，建立一个机器学习模型来找出这种关系是一项极其困难的任务。
最近，DiscoGAN 在跨两个不同领域学习这种关系方面显示出有希望的结果。
DiscoGAN 的核心理念与 CycleGAN 非常相似:
两者都学习两个单独的变换函数，一个学习从域 X 到域 Y 的变换，而另一个学习反向映射，并且两者都使用重建损失作为在跨域的两次变换之后原始图像重建得有多好的度量。
- 两者都遵循这样的原则:如果我们将一个图像从一个域 1 转换到域 2，然后再转换回域 1，那么它应该与原始图像匹配。
- DiscoGAN 和 CycleGAN 之间的主要区别在于，DiscoGAN 使用两个重建损失，一个用于两个域，而 CycleGAN 使用单个循环一致性损失。
- 和 CycleGAN 一样，DiscoGAN 也是建立在重建损失的基础上。其思想是，当图像从一个域变换到另一个域，然后再变换回原始域时，生成的图像应该与原始图像一样接近。在这种情况下，定量差异被认为是重建损失，并且在训练期间，模型试图最小化这种损失。
Figure: (a) Vanilla GAN (b) GAN with reconstruction loss (c) DiscoGAN architecture
因此，该模型由两个 GAN 网络组成，分别称为 GAB 和 GBA。在上图中，模型正试图根据它们的方向来学习跨域关系。重建图像后，方向应该与原始方向相同。
参考文献:
研究 论文:【https://arxiv.org/pdf/1703.05192.pdf】T4
Github:【https://github.com/SKTBrain/DiscoGAN
伊斯甘
最近，生成对抗网络在无监督任务中表现出了令人印象深刻的性能。
在常规 GAN 中，鉴别器使用交叉熵损失函数，这有时会导致消失梯度问题。 取而代之，lsGAN 提出对鉴别器使用最小二乘损失函数。 这种配方提供了更高质量的图像生成 GAN。
早些时候，在 vanilla GAN 中，我们已经看到了以下最小-最大优化公式，其中鉴别器是二元分类器，并且在优化期间使用 sigmoid 交叉熵损失。
如前所述，对于位于决策边界正确一侧但远离密集区域的数据点，这种公式通常会导致消失梯度问题。最小平方公式解决了这个问题，并提供了模型的更稳定的学习和生成更好的图像。
以下是 lsGAN 的重新制定的优化公式，其中:
a 是假样品的标签，
- b 是真实样品的标签
- c 表示发生器希望鉴别器相信的假样本值。
- 现在，我们有两个单独的损失函数正在优化。一个相对于鉴别器最小化，另一个相对于发生器最小化。
与香草 GAN 相比，lsGAN 具有巨大的优势。在普通 GAN 中，由于鉴别器使用二进制交叉熵损失，只要观察值位于决策边界的正确一侧，其损失就是 0。
但是在 lsGAN 的情况下，如果观察值远离决策边界，即使它在决策边界的正确一侧，该模型也会惩罚该观察值。
这种惩罚迫使生成器向判定边界生成样本。除此之外，它还消除了渐变消失的问题，因为在更新生成器时，远点会生成更多的渐变。
参考文献:
研究 论文:【https://arxiv.org/pdf/1611.04076.pdf】T4
Github:【https://github.com/xudonmao/LSGAN
DiscoGAN 与 cycle gan–检查差异
DiscoGAN 和 CycleGAN 用于在给定不成对数据的情况下学习跨域关系。DiscoGAN 的目标与 CycleGAN 非常相似。两者都在重建损失的基础上接受训练，并使用前向、后向循环一致性损失来实现双射映射。
这两种模型几乎无法区分，除非损失函数有如下微小差异:
对于 CycleGAN，L1 距离 用于测量输入图像和重建图像之间的循环一致性损失，而 L2 距离 用作 DiscoGAN 的距离测量。
CycleGAN 使用一个额外的超参数来控制再生损失和循环一致性损失之间的相对重要性。
最后的想法
我们讨论过的所有 GAN 架构都有一个共同点。它们都是建立在对抗性损失原则上的，它们都有生成器和鉴别器，它们遵循对抗性来愚弄对方。GANs 在过去几年中取得了巨大的成功，成为机器学习研究领域最热门的研究课题之一。在未来，我们将看到这个领域的许多进展。
以下 Git 知识库整理了一份独家的 GAN 论文列表。
https://github.com/hindupuravinash/the-gan-zoo
参考
希布桑卡尔达斯
一位高级数据科学家@ WalmartLabs，在此之前，他曾在 Envestnet | Yodlee、微软研究院和凯捷工作。他曾被《印度分析》杂志授予“40 名 40 岁以下数据科学家”，因为他在基础机器学习和分析方面展示了专业知识，特别是在深度学习、生成模型和深度强化学习方面。
阅读下一篇
Python 中的图像处理:你应该知道的算法、工具和方法
9 分钟阅读|作者 Neetika Khandelwal |更新于 2021 年 5 月 27 日
9 mins read | Author Neetika Khandelwal | Updated May 27th, 2021
图像定义了世界，每张图像都有自己的故事，它包含了许多在许多方面都有用的重要信息。这些信息可以借助于被称为图像处理的技术来获得。
它是计算机视觉的核心部分，在机器人、自动驾驶汽车和物体检测等许多现实世界的例子中起着至关重要的作用。图像处理允许我们一次转换和操作数千幅图像，并从中提取有用的见解。它在几乎每个领域都有广泛的应用。
Python 是为此目的广泛使用的编程语言之一。它惊人的库和工具有助于非常有效地完成图像处理任务。
通过本文，您将了解处理图像并获得所需输出的经典算法、技术和工具。
让我们开始吧！
Let’s get into it!
7 强化学习在金融和交易中的应用
在本文中，我们将探索 7 个真实世界的交易和金融应用程序，其中强化学习用于获得性能提升。
好的，但是在我们进入这篇文章的本质之前，让我们定义一些我稍后会用到的概念。
首先，让我们快速定义强化学习:
一个学习过程，在这个过程中，一个主体通过试错法与其环境相互作用，以这样一种方式达到一个确定的目标:对于主体为达到其目标所做的每一个正确的步骤，主体可以最大化奖励的数量，并最小化环境给予的惩罚。
酷，现在我会经常用到几个关键词:
- 深度强化学习(DRL): 利用深度学习来逼近处于强化学习核心的价值或政策函数的算法。
- 策略梯度强化学习技术:用于解决强化学习问题的方法。策略梯度方法的目标是直接建模和优化策略功能。
- 深度 Q 学习:用神经网络逼近 Q 值函数。Q 值函数为工作的代理创建了一个精确的矩阵，它可以“参考”这个矩阵，以使它的长期回报最大化。
- 门控递归单元(GRU): 特殊类型的递归神经网络，在门控机制的帮助下实现。
- 门控深度 Q 学习策略:深度 Q 学习与 GRU 的结合。
- 门控策略梯度策略:策略梯度技术与 GRU 的结合。
- 深度递归 Q 网络:递归神经网络与 Q 学习技术的结合。
好了，现在我们准备看看强化学习是如何在金融世界中被用来实现利润最大化的。
1.具有强化学习的交易机器人
由强化学习驱动的机器人可以通过与交易和股票市场环境互动来学习。他们使用试错法来优化他们的学习策略，这些策略是基于股票市场上每一只股票的特征。
这种方法有几大优势:
- 节省时间
- 交易机器人可以 24 小时交易
- 所有行业的交易都变得多样化
例如，您可以使用深度 Q 学习项目来检查股票交易机器人。这里的想法是使用深度 Q 学习技术创建一个交易机器人，测试表明，在给定一组股票进行交易的情况下，一个经过训练的机器人能够在一段时间内进行买卖。
请注意，这个项目不是基于计算交易成本，执行交易的效率等。–所以这个项目不可能在现实世界中出类拔萃。另外，由于它的顺序方式，项目的训练是在 CPU 上完成的。
2.基于聊天机器人的强化学习
聊天机器人通常在序列到序列建模的帮助下进行训练，但是将强化学习添加到组合中可以为股票交易和金融带来巨大优势:
- 聊天机器人可以充当经纪人，向用户运营商提供实时报价。
- 基于对话式 UI 的聊天机器人可以帮助客户解决他们的问题，而不是来自员工或后端支持团队的人。这节省了时间，并将支持人员从重复的任务中解放出来，让他们专注于更复杂的问题。
- 聊天机器人还可以在交易时间内给出开盘价和收盘价的建议。
深度强化学习聊天机器人项目展示了一个基于强化学习的聊天机器人实现，使用策略梯度技术实现。
3.基于强化学习的 P2P 贷款风险优化
P2P 借贷是一种通过在线服务向个人和企业提供贷款的方式。这些在线服务为贷款人和投资者牵线搭桥。
在这些类型的在线市场中，强化学习派上了用场。具体来说，它可以用于:
- 分析借款人的信用评分以降低风险。
- 预测年化回报，由于在线业务的管理费用较低，与银行提供的储蓄和投资产品相比，贷方可以期待更高的回报。
- 它还可以帮助估计借款人有能力偿还债务的可能性。
使用神经网络的点对点借贷机器人顾问项目是一个用神经网络构建的在线借贷平台。它没有使用强化学习，但你可以看到这只是一种试验性的&错误场景，其中 RL 将非常有意义。
4.具有深度强化学习的投资组合管理
投资组合管理意味着将客户的资产投入股票，并持续管理，以帮助客户实现其财务目标。在深度策略网络强化学习的帮助下，随着时间的推移，可以优化资产的配置。
在这种情况下，深度强化学习的好处是:
- 它提高了人类管理者的效率和成功率。
- 它降低了组织风险。
- 它增加了组织利润方面的投资回报(ROI)。
针对金融投资组合管理问题的深度强化学习框架——该项目展示了投资组合管理与深度策略网络强化学习的实现。
5.具有强化学习的定价策略
复杂性和动态的股价变化是理解股价的最大挑战。为了理解这些性质，门控递归单元(GRU)网络与强化学习一起工作得很好，提供了如下优点:
- 提取能够代表股票内在特征的信息性财务特征。
- 在交易过程中帮助决定止损和止盈。
Photo by Olya Kobruseva | Source: Pexels
为了支持上述说法，时间序列的深度强化学习:玩理想化的交易游戏论文显示了堆叠门控递归单元(GRU)、长短期记忆(LSTM)单元、卷积神经网络(CNN)和多层感知器(MLP)中哪一个表现最好。
在捕捉波浪状价格时间序列的单变量游戏中，用于模拟 Q 值的 GRU 代理表现出最佳的整体性能。
可以将强化学习应用于 GRU 的两种技术是:
- 门控深度 Q 学习策略
- 门控策略梯度策略
要更好地理解这些技术，可以看看这篇文章:深度强化学习方法的自适应股票交易策略。
6.具有强化学习的推荐系统
当谈到在线交易平台时，基于强化学习技术的推荐系统可以改变游戏规则。这些系统有助于在交易时向用户推荐正确的股票。
强化学习有助于在接受大量股票培训后选择最佳股票或共同基金，最终带来更好的投资回报。
这里的优势可以是:
- 通过根据用户在平台上的行为提供终身选股建议来吸引现有用户。
- 通过推荐好股票来帮助新手交易。
- 从而更容易决定选择哪些股票。
项目展示了这样一个系统的实现。
7.以最小的资本投资实现利润最大化
如果我们把以上几点结合起来，我们可以构建一个自动化系统来获得高回报，同时保持尽可能低的投资。
在强化学习的帮助下，可以训练一个代理人，强化学习可以从任何来源获得最小的资产，并将其分配到股票中，这可以在未来使 ROI 翻倍。
如今，RL 代理已经能够学习优于人们过去应用的简单买卖策略的最优交易策略。这可以在马尔可夫决策过程(MDP)模型的帮助下，使用深度递归 Q 网络(DRQN)来实现。理解这个概念的一个很好的资源是 针对部分可观察 MDP 的深度递归 Q 学习 。
小心行事
需要补充的是，我们列出的很多项目本质上都是为了好玩而做的项目。他们是根据过去的数据训练的，没有经过适当的回溯测试。在看不见数据的情况下(例如 COVID stats)，下行风险比模型预期的要大得多。
市场是一个复杂的系统，机器学习系统很难只根据历史数据来理解股票。基于 ML 的交易策略的表现可以很好，但是它也会让你耗尽你的积蓄。所以对这些项目要有所保留。
结论
强化学习总是被低估。通过在本文中展示 RL 的金融和交易用例，我想分享关于 RL 如何有用的意识，为新的学习者和现有的开发者创建一条积极的道路，以更多地探索这个领域。真是个引人入胜的话题！
MLOps 的 8 个最佳数据科学和机器学习平台
从召集团队和准备数据到部署、监控和管理机器学习模型，MLOps 需要大量的时间、资源和技术。这是一个复杂的流程和实践网络，需要特定类型的技术。统计数据显示，人工智能技术在企业中的采用仍然很低，因为只有 14.6%的企业投资于生产中的人工智能能力。
无论您是想要优化您的 ML 实验流程的数据科学家，还是正在寻找人工智能方法来发展业务的企业所有者，您都可以使用专用的 MLOps 工具来帮助您管理每个阶段的实验。
以下是准备、部署和监控实验的最佳 MLOps 工具，将您的所有工作集中到一个地方！
Neptune 是一个轻量级的实验管理工具，可以帮助您跟踪您的机器学习实验，并管理您所有的模型元数据。它非常灵活，可以与许多其他框架一起工作，并且由于其稳定的用户界面，它实现了巨大的可伸缩性。
以下是 Neptune 为监控您的 ML 模型提供的内容:
- 快速美观的用户界面具有多种功能，可分组组织跑步、保存自定义仪表盘视图并与团队分享
- 版本化、存储、组织和查询模型，以及模型开发元数据包括数据集、代码、环境配置版本、参数和评估度量、模型二进制、描述和其他细节
- 在仪表板中对模型训练进行过滤、排序和分组，以便更好地组织您的工作
- 在一个表格中比较指标和参数,该表格自动发现运行之间的变化以及异常情况
- 每次运行实验时，自动记录代码、环境、参数、模型二进制文件和评估指标
- 您的团队可以跟踪在脚本(Python、R、other)、笔记本(local、Google Colab、AWS SageMaker)中执行的实验，并在任何基础设施(云、笔记本电脑、集群)上执行
- 广泛的实验跟踪和可视化功能(资源消耗，滚动图像列表)
Neptune 是一个强大的软件，可以让您将所有数据存储在一个地方，轻松地进行协作，并灵活地试验您的模型。
Amazon SageMaker 是一个平台，使数据科学家能够构建、训练和部署机器学习模型。它拥有用于整个机器学习工作流的所有集成工具，在单个工具集中提供了用于机器学习的所有组件。
SageMaker 是一个适合安排、协调和管理机器学习模型的工具。它有一个基于 web 的可视化界面来执行所有 ML 开发步骤，包括笔记本、实验管理、自动模型创建、调试和模型漂移检测
亚马逊 SageMaker–摘要:
- Autopilot 自动检查原始数据，应用特征处理器，挑选最佳算法集，训练和调整多个模型，跟踪它们的性能，然后根据性能对模型进行排序——它有助于部署性能最佳的模型
- SageMaker Ground Truth 帮助您快速构建和管理高度准确的训练数据集
- SageMaker Experiments 通过自动捕获输入参数、配置和结果，并将其存储为“实验”，帮助组织和跟踪机器学习模型的迭代
- SageMaker 调试器在训练过程中自动捕获实时指标(如训练和验证、混淆、矩阵和学习梯度)以帮助提高模型准确性。当检测到常见的培训问题时，调试器还可以生成警告和补救建议
- SageMaker Model Monitor 允许开发人员检测和补救概念漂移。它会自动检测已部署模型中的概念漂移，并给出详细的警报，帮助识别问题的根源
cnvrg 是一个端到端的机器学习平台，用于大规模构建和部署 AI 模型。它帮助团队管理、构建和自动化从研究到生产的机器学习。
您可以自由使用任何计算环境、框架、编程语言或工具，以超高速运行和跟踪实验，无需任何配置。
以下是 cnvrg 的主要特点:
- 将您的所有数据组织在一个位置，并与您的团队协作
- 实时可视化使您可以通过自动图表、图形等直观地跟踪模型运行，并轻松地与您的团队共享
- 存储模型和元数据，包括参数、代码版本、度量和工件
- 跟踪变化并自动记录代码和参数，以实现重现性
- 通过拖放功能，只需点击几下鼠标，即可构建生产就绪的机器学习管道
cnvrg 允许您存储、管理和轻松控制所有数据、实验，并根据您的需求灵活使用。
Iguazio 有助于机器学习管道的端到端自动化。它简化了开发，提高了性能，促进了协作，并解决了操作难题。
该平台包含以下组件:
- 一个数据科学工作台，包括 Jupyter 笔记本、集成分析引擎和 Python 包
- 具有实验跟踪和自动化管道功能的模型管理
- 可扩展 Kubernetes 集群上的托管数据和机器学习(ML)服务
- 实时无服务器功能框架——nucl io
- 快速安全的数据层，支持 SQL、NoSQL、时序数据库、文件(简单对象)和流
- 与第三方数据源集成，如亚马逊 S3、HDFS、SQL 数据库和流或消息协议
- 基于 Grafana 的实时仪表板
Iguazio 在一个现成的平台上为您提供完整的数据科学工作流，用于创建从研究到生产的数据科学应用程序。
Spell 是一个快速简单地训练和部署机器学习模型的平台。它提供了一个基于 Kubernetes 的基础设施来运行和管理 ML 实验，存储您的所有数据，并自动化 MLOps 生命周期。
下面是一些拼写的主要特征:
- 为 TensorFlow、PyTorch、Fast.ai 等提供基础环境。或者，你可以自己卷。
- 您可以使用 pip、conda 和 apt 安装您需要的任何代码包。
- 简单易用的 Jupyter 工作区、数据集和资源
- 可以使用工作流将运行链接在一起，以管理模型训练管道
- 由 Spell 自动生成的模型指标
- 超参数搜索
- 模型服务器使得生产用法术训练的模型变得容易，允许你使用一个工具来训练和服务模型
MLflow 是一个开源平台，有助于管理整个机器学习生命周期，包括实验、再现性、部署和中央模型注册。
MLflow 适合个人和任何规模的团队。
该工具与库无关。你可以用任何机器学习库和任何编程语言来使用它。
MLflow 包含四个主要功能:
- ml flow Tracking–一个 API 和 UI，用于在运行机器学习代码时记录参数、代码版本、指标和工件，并用于以后可视化和比较结果
- MLflow 项目–以可重用、可复制的形式包装 ML 代码，以便与其他数据科学家共享或转移到生产中
- MLflow 模型–管理不同 ML 库中的模型，并将其部署到各种模型服务和推理平台
- MLflow 模型注册中心–一个中央模型存储库，用于协作管理 MLflow 模型的整个生命周期，包括模型版本控制、阶段转换和注释
Tensorflow 是一个用于部署生产 ML 管道的端到端平台。它提供了一个配置框架和共享库来集成定义、启动和监控机器学习系统所需的通用组件。
TensorFlow 提供稳定的 Python 和 c++ API，以及面向其他语言的非保证向后兼容 API。它还支持一个由强大的附加库和模型组成的生态系统，包括 Ragged Tensors、TensorFlow Probability、Tensor2Tensor 和 BERT。
TensorFlow 让您轻松训练和部署您的模型，无论您使用什么语言或平台——如果您需要完整的生产 ML 管道，请使用 TensorFlow Extended (TFX );在移动和边缘设备上运行推理，使用 TensorFlow Lite 使用 TensorFlow.js 在 JavaScript 环境中训练和部署模型。
这是一个适合初学者和高级数据科学家的 MLOps 工具。它拥有所有必要的功能，并让您可以灵活地使用它。
Kubeflow 是 Kubernetes 的 ML 工具包。它通过打包和管理 docker 容器来帮助维护机器学习系统。
它通过使机器学习工作流的运行编排和部署更容易来促进机器学习模型的扩展。这是一个开源项目，包含一组特定于各种 ML 任务的兼容工具和框架。
这里有一个简短的 Kubeflow 总结:
- 用于管理和跟踪实验、作业和运行的用户界面(UI)
- 使用 SDK 与系统交互的笔记本电脑
- 重用组件和管道来快速创建端到端解决方案，而不必每次都重新构建
- Kubeflow Pipelines 可作为 Kubeflow 的核心组件或独立安装使用
- 多框架集成
参见海王星和库伯流的对比
把它包起来
端到端 MLOps 工具为您进行 ML 实验提供了很大的灵活性。它们还可以实现工作自动化，优化耗时的流程。尽管它们的目标是相同的——为您提供可扩展的 ML 实验的基础设施，但是它们的特性可能不同。因此，选择一个适合您的需求，以充分利用它。
快乐实验！
面向机器学习从业者的自动学习快速入门指南
在现实世界中使用 AutoML 框架正成为机器学习从业者的一件常规事情。人们经常会问:自动化机器学习( AutoML )会取代数据科学家吗？
不完全是。如果您渴望了解 AutoML 是什么以及它是如何工作的，请加入我的这篇文章。我将向您展示 auto-sklearn，一个最先进的开源 AutoML 框架。
为此，我必须做一些研究:
- 阅读 auto-sklearn V1 和 V2 的第一篇和第二篇论文。
- 深入研究了 auto-sklearn 文档和示例。
- 查看了官方汽车 Sklearn 博客帖子。
- 我自己做了一些实验。
AutoML research 也是如此，到目前为止我已经学到了很多。读完这篇文章后，你会更了解:
- AutoML 是什么，AutoML 是为谁服务的？
- 为什么 auto-sklearn 对 ML 社区很重要？
- 如何在实践中使用 auto-sklearn？
- auto-sklearn 的主要特点是什么？
- Neptune 中带有结果跟踪的 auto-sklearn 的一个用例。
开始吧！
自动化机器学习
AutoML 是一个年轻的领域。AutoML 社区希望建立一个自动化的工作流，它可以将原始数据作为输入，并自动生成预测。
这个自动化的工作流程应该自动执行预处理、模型选择、超参数调整以及 ML 过程的所有其他阶段。例如，看看下图，看看微软 Azure 是如何使用 AutoML 的。
AutoML 可以提高数据科学家的工作质量，但不会将数据科学家排除在循环之外。
专家可以使用 AutoML 通过专注于表现最好的管道来提高他们的工作表现，而非专家可以使用 AutoML 系统而无需广泛的 ML 教育。如果你有 15 分钟的空闲时间，下面的对话可能会帮助你理解 AutoML 是怎么回事。
视频
什么是 AutoML:约什·斯塔默与约安尼斯·察马迪诺的对话
AutoML 框架
有不同类型的 AutoML 框架，每一种都有独特的特性。他们每个人都自动化了完整机器学习工作流的几个步骤，从预处理到模型开发。在这张表中，我只总结了其中值得一提的几条:
自动 sklearn
auto-sklearn 是一个基于 scikit-Learn 的 AutoML 框架。这是最先进的，而且是开源的。
auto-sklearn 结合了强大的方法和技术，帮助创作者赢得了第一届和第二届国际汽车挑战赛。
auto-sklearn 基于将 AutoML 定义为现金问题。
CASH =组合算法选择和超参数优化。简而言之，我们希望在一个巨大的搜索空间中找到数据集的最佳 ML 模型及其超参数，其中包括大量的分类器和大量的超参数。在下图中，您可以看到由作者提供的 auto-sklearn 的表示。
auto-sklearn is based on defining AutoML as a CASH problem.
auto-sklearn 可以解决分类和回归问题。auto-sklearn 的第一个版本是在 2015 年第 28 届神经信息处理系统国际会议上，以一篇题为“高效和健壮的自动化机器学习”的文章推出的。第二个版本在 2020 年随论文“ auto-sklearn 2.0:下一代”一同亮相。
Auto-sklearn 功能
auto-sklearn 能为用户做些什么？它有几个有价值的特性，对新手和专家都有帮助。
只需编写五行 Python 代码，初学者就可以看到预测，专家可以提高他们的工作效率。以下是 auto-sklearn 的一些主要功能:
用 Python 编写，在最流行的 ML 库(scikit-learn)之上。
适用于许多任务，如分类、回归、多标签分类。
- 由几种预处理方法组成(处理缺失值，规范化数据)。
- 在相当大的搜索空间(15 个分类器，超过 150 个超参数被搜索)中搜索最佳 ML 管线。
- 由于使用了元学习，贝叶斯优化，集成技术。
- auto-sklearn 是如何工作的？
- Auto-sklearn 可以解决分类和回归问题，但是怎么做呢？机器学习管道中有很多东西。总的来说，V1 自动 sklearn 有三个主要组成部分:
元学习
贝叶斯优化
- 构建合奏
- 因此，当我们想要对新数据集应用分类或回归时，auto-sklearn 首先提取其元特征，以找到新数据集与依赖元学习的知识库的相似性。
- 在下一步中，当搜索空间通过元学习缩小到足够大时，贝叶斯优化将试图找到并选择表现优异的 ML 管道。在最后一步中，auto-sklearn 将基于搜索空间中的最佳 ML 工作流来构建集成模型。
Auto-sklearn v2:新一代
最近 auto-sklearn 第二版上市了。让我们来回顾一下新一代的变化。在官方博文和原论文的基础上，有四点改进:
他们允许每个 ML 管道在整个搜索空间内使用提前停止策略；该特性提高了大型数据集的性能，但它主要用于基于树的分类器。
改进模型选择策略:auto-sklearn 的一个重要步骤是如何选择模型。在 V2 的 auto sklearn 中，他们使用了 BOHB 等多保真优化方法。然而，他们表明，单一的模型选择并不适合所有类型的问题，他们整合了几种策略。为了熟悉新的优化方法，你可以阅读这篇文章:“ HyperBand 和 BOHB:了解最先进的超参数优化算法”
- 建立一个投资组合，而不是使用元特征在知识库中查找相似的数据集。您可以在下图中看到这种改进。
- 在之前的改进基础上构建自动化策略选择，以选择最佳策略。
- Auto-sklearn 主要参数
- 虽然 Auto-sklearn 可能能够在不设置任何参数的情况下找到一个表现更好的管道，但是有一些参数可以用来提高您的生产率。要检查所有参数，请访问官方页面。
参数名称
缺省值
| 描述 | ||
|---|---|---|
显示试衣后的模特是否
| 显示试衣后的模特 | |
|
显示任务还剩多少秒。如果你增加它，获得更好性能的机会也会增加
| 它显示任务还剩多少秒。如果您增加它，获得更好性能的机会也会增加 | |
|
显示每个 ML 模型应该花费多少秒
| 它显示了每个 ML 模型应该花费多少秒 |
initial _ configuration s _ viarn _ metal learning
|
| | 有多少通过元学习的配置考虑了超参数优化。如果设置为 0，此选项将处于非活动状态。此外，该参数在自动 sklearn V2 中不可用 | |
|
集合中模特的数量。要禁用该参数，将其设置为 1
T3 | 集合中模特的数量。要禁用此参数，请将其设置为 1 | |
|
并行作业的数量。要使用所有处理器，将它设置为-1
T3 | 并行作业的数量。要使用所有处理器，请将其设置为-1 | |
|
建立集合模型的最佳模型数。仅当 ensemble_size 大于 1
T3 时有效 | 建立集合模型的最佳模型数。仅在 ensemble_size 大于 1 时有效 | |
|
当没有估值器时，它将使用所有估值器。auto-sk learn V2
T3 不提供 | 当没有估值器时，它将使用所有估值器。不适用于 V2 auto-sk learn | |
|
你可以从搜索空间中排除一些估值器。auto-sk learn V2
T3 不提供 | 您可以从搜索空间中排除一些评估者。不适用于 V2 auto-sk learn | |
|
如果不定义指标，则根据任务选择。在本文中，我们将其定义为(autosklearn . metrics . roc _ AUC)
| 如果不定义指标，将根据任务选择指标。在本文中，我们定义它(autosklearn.metrics.roc_auc) | |
跟踪海王星上的 Auto-sklearn 实验
我做了一些笔记本，你可以轻松下载并自己做实验。但是，要再次完成所有步骤，您需要:
检查海王星的所有实验
首先，你需要在你的机器上安装 auto-sklearn。为此只需使用 pip3:
如果你得到一个错误，你可能需要安装依赖项，所以请检查官方的安装页面。你也可以用我在海王星为你准备的笔记本。然后运行以下命令以确保安装正确完成:
让我们解决一些分类和回归问题。
pip3 install auto-sklearn
用于分类的 Auto-sklearn
import autosklearn
print(autosklearn.__version__)
对于分类问题，我选择了一个珍爱的 Kaggle 竞赛——桑坦德客户交易预测。请下载数据集并随机选择 10000 条记录。然后按照第一个笔记本里的实验:
我们还需要定义一些配置，以便更深入地了解 auto-sklearn:
import autosklearn
X_train=None
X_val=None
y_train=None
y_val=None
train=pd.read_csv("./sample_train_Santander.csv")
X=train.drop(["ID_code",'target'],axis=1)
y=train["target"]
X_train,X_val,y_train,y_val = train_test_split(X,y, stratify=y,test_size=0.33, random_state=42)
automl = autosklearn.classification.AutoSklearnClassifier()
automl.fit(X_train, y_train )
y_pred=automl.predict_proba(X_val)
score=roc_auc_score(y_val,y_pred[:,1])
print(score)
show_modes_str=automl.show_models()
sprint_statistics_str = automl.sprint_statistics()
配置
范围值
| 描述 | ||
|---|---|---|
我用 60 秒开始实验，然后对于每个实验，我把它增加到 5000
| 我以 60 秒开始实验，然后对于每个实验，我把它增加到 5000 秒 | |
|
由于案例研究高度不平衡，那么我需要将指标改为 roc_auc
| 由于案例研究非常不平衡，因此我需要将指标改为 roc_auc | |
|
在 auto-sklearn V1 中，如果我没有定义重采样 _ 策略，就无法得到好的结果。但在 auto-sklearn V2 中，它自动做到了
| 在 auto-sklearn V1 中，如果我没有定义重采样 _ 策略，它不能得到一个好的结果。但是在 V2 的 auto-sklearn 中，它是自动完成的 |
重采样 _ 策略 _ 自变量
|
| | | 要使用上述配置，您可以如下定义 automl 对象: |
由于我使用了大量不同的配置，我只是在海王星上跟踪它们。你可以在图像中看到其中的一个，在海王星中查看全部。
当您安装 auto-sklearn 模型时，您可以使用 PipelineProfiler (pip 安装 PipelineProfiler)检查所有表现最佳的管道。为此，您需要运行以下代码:
TIME_BUDGET=60
automl = autosklearn.classification.AutoSklearnClassifier(
time_left_for_this_task=TIME_BUDGET,
metric=autosklearn.metrics.roc_auc,
n_jobs=-1,
resampling_strategy='cv',
resampling_strategy_arguments={'folds': 5},
)
automl.fit(X_train, y_train )
您的输出应该如下所示:
另一方面，我也运行了一些基于 auto-sklearn V2 的实验。结果令人着迷。您可以看到下面的结果:
import PipelineProfiler
profiler_data= PipelineProfiler.import_autosklearn(automl)
PipelineProfiler.plot_pipeline_matrix(profiler_data)
要使用 auto-sklearn V2，您可以使用以下代码:
用于回归的自动 sklearn
auto-sklearn 可以解决的第二类问题是回归。我基于 auto-sklearn 文档中的官方示例运行了一些实验。
TIME_BUDGET=60
automl = autosklearn.experimental.askl2.AutoSklearn2Classifier(
time_left_for_this_task=TIME_BUDGET,
n_jobs=-1,
metric=autosklearn.metrics.roc_auc,
)
我只是改变了时间预算来跟踪基于时间限制的性能。下图显示了结果。
最终想法
TIME_BUDGET=60
automl = autosklearn.regression.AutoSklearnRegressor(
time_left_for_this_task=TIME_BUDGET,
n_jobs=-1
)
automl.fit(X_train, y_train, dataset_name='boston')
y_pred = automl.predict(X_test)
score=r2_score(y_test, y_pred)
print(score)
show_modes_str=automl.show_models()
sprint_statistics_str = automl.sprint_statistics()
print(show_modes_str)
print(sprint_statistics_str)
总的来说，auto-sklearn 还是一项新技术。因为 auto-sklearn 是建立在 scikit-learn 之上的，所以许多 ML 从业者可以很快尝试一下，看看它是如何工作的。
这个框架最重要的优点就是为专家节省了大量的时间。一个缺点是它像一个黑盒，并没有说明如何做决定。
总而言之，这是一个相当有趣的工具，所以值得给 auto-sklearn 看一看。
The most important advantage of this framework is that it saves a lot of time for experts. The one weakness is that it acts as a black box, and doesn’t say anything about how to make a decision.
All in all, it’s a pretty interesting tool, so it’s worth giving auto-sklearn a look.
主动学习:策略、工具和真实世界用例
原文：https://web.archive.org/web/https://neptune.ai/blog/active-learning-strategies-tools-use-cases
在本文中，您将了解到:
- 什么是主动学习，
- 为什么我们需要主动学习
- 它是如何工作的
- 有哪些技巧
- 在现实世界中的应用
- 以及哪些框架可以帮助主动学习。
我们开始吧！
什么是主动学习？
主动学习是机器学习的一种特殊情况，在这种情况下，学习算法可以交互式地询问用户(或一些其他信息源)以用期望的输出来标记新的数据点。在统计学文献中，它有时被称为最优实验设计。–来源
通过选择看似最重要的数据点，在保持监督/标记数据集的数量最小的同时，创建一个像样的机器学习模型是一项重要的技术。
在贴标困难或耗时的情况下，也考虑这种技术。被动学习，或者由人类先知创建大量标记数据的传统方式，在工时方面需要巨大的努力。
在一个成功的主动学习系统中，算法能够通过一些定义的度量来选择最具信息量的数据点，随后将它们传递给人类标记器，并逐步将它们添加到训练集中。下图所示为示意图。
Diagram of active learning system | Source: Author
为什么我们需要主动学习？
动机
主动学习的想法是受已知概念的启发，即并非所有数据点对于训练模型都同样重要。看看下面的数据就知道了。这是两个集合的集群，中间有一个决策边界。
A cluster of two sets with a decision boundary in between | Source: Author
现在假设一个场景，有超过数万个数据点，没有任何标签可以学习。手动标记所有这些点会很麻烦，甚至非常昂贵。为了减轻这种痛苦，如果从一批数据中选择一个随机的数据子集，然后标记为模型训练，最有可能的是，我们最终得到的是一个性能低于标准的模型，如下图所示。问题是，这种随机采样产生的决策边界会导致较低的准确性和其他降低的性能指标。
A model with sub-par performance | Source: Author
但是，如果我们设法选择决策边界附近的一组数据点，并帮助模型有选择地学习，会怎么样呢？这将是从给定的未标记数据集中选择样本的最佳方案。这就是主动学习概念的起源和演变。
Possible scenario of NLP training | Source: Author
您在上面看到的插图可以很容易地应用于 NLP 培训中的场景，如获取相关的标注数据集以进行词性标注和命名实体识别等。，可能是一个挑战。
数据标签成本
为大规模训练创建标记数据是非常昂贵和耗时的。Google Cloud Platform/1000 单位数据标签的定价详情如下所示。通常情况下，每个实例应该有 2-3 个数据贴标机，以确保更好的标签质量。第 1 层高达 50K 单位，第 2 层高于该容量。
The pricing details of Data Labelling by Google Cloud Platform/1000 units | Source
通过查看上面显示的成本，您可以大致了解如果您要标记 100，000 张图像以用于涉及边界框的专门 ML 模型的训练，典型的标记成本是多少。比方说，每幅图像大约有 5 个边界框和两个贴标机。成本可能是 112，000 美元。但是同样，这个成本可能大也可能小，这取决于您的组织和项目预算的大小。
让我们看看医疗保健领域可能发生的另一种情况。想象一下，我们需要标记 10，000 个医学图像，每个图像平均需要 15 个语义分段对象和 3 个标记器来提高准确性。费用可能是 391，500 美元！
我想现在你有一个想法，数据标签的成本很容易飙升。上面提到的数字是非常真实的场景。如果我们在大型图像数据集上训练大型语言模型或基于视觉的模型，这可能会更高。
无论哪种方式，如果您使用内部资源或外部贴标服务，贴标时间将会很长，这是您希望避免的。通常情况下，数据需要由熟悉该领域的人来标记。
主动学习可以大大绕过这些挑战。因此，在某些领域有很大的推动力，如大型 NLP 系统的培训，自动驾驶等。，也就是采用主动学习。以英伟达观察的自动驾驶系统中的数据标注场景为例。
一个简单的粗略计算表明，每天行驶 8 小时的 100 辆汽车的车队将需要超过 100 万个贴标机以 30fps 的速度注释所有摄像机的所有帧，以进行对象检测。这完全不切实际。
我想我不需要再强调所涉及的成本——金钱和时间！如果还不服气，就想想可能的碳足迹吧！
边缘场景导致的问题
边缘情况场景可能是无害的，如下图所示，算法混淆了小狗和纸杯蛋糕。或者，它们可能会像一辆自动驾驶卡车一样危险，导致重大事故，因为它未能检测到夜间穿过道路的深色车辆！这些边缘情况故障看似很少发生，但可能会迅速导致具有高成本影响的重大负面结果。
The algorithm is confused between a puppy and a cupcake | Source
处理训练数据中的边缘情况的数据点的数量很少，这最终导致 ML 模型不能在其上训练。
Example bounding box detections for cars and pedestrians for a day & night image | Source
主动学习系统可以被训练来识别边缘案例，以便它们可以被人类有效地标记，并且可以被馈送到具有足够表示甚至更高权重表示的标记数据池！关于自动驾驶系统中主动学习的更详细的内容将在后面的章节中给出。
主动学习如何工作:情景
所以…迷因分开！让我们深入探究一下主动学习是如何工作的。
在经典的主动学习周期中，该算法选择最有价值的数据实例(也可能是边缘情况),并要求它们由人来标记。然后将这些新标记的实例添加到训练集中，并重新训练模型。这些数据实例的选择是通过研究人员通常称之为查询的过程进行的。引用文章中的一句话基于查询的学习:
基于查询的学习是一种主动的学习过程，学习者与教师进行对话，教师应要求提供关于所学概念的有用信息。
上面引用中提到的老师可能是一个基本的 ML 模型或一个简单的算法，通常事先用一小部分标记数据进行训练。如何形成查询是开发主动学习算法的关键。因此，无论您是在寻找一个模糊案例还是一个边缘案例来学习，它都与您如何设计查询格式密切相关。
在文献中有两种典型的主动学习场景:基于查询合成的和基于采样的。
查询合成
它主要基于这样的假设，即靠近分类边界的实例更不明确，标记这些实例将为学习模型提供最多的信息。因此，我们通过创建新的点或者利用基于欧几里德距离的技术选择已经最接近它的点来查询决策边界附近的点。
该算法
- 第一步是创建一个带有标签数据样本的简单模型。让我们假设一个二元分类的场景，假设 X[1]X[2]是属于两个独立类的两个点。通过使用一种类似于二叉查找树的方法，我们可以通过人类先知查询其中点的标签来找到接近决策边界的实例。这里的中点是指连接点 X[1]X[2]的直线的欧几里德中点。考虑这个例子。
让我们取属于由 X1 (2，5，4)，X2 (6，4，3)定义的不同类的两个点。因为它们有三个特征，找到它们的中点是一个简单的欧几里德运算，它给出中点为
X [中点] = (X [1] + X [2] )/2
X [中点] = (4，4.5，3.5)
因此，如果我们让点(X1 + X2)/2 的标签被查询，那么我们知道我们需要去哪个方向进行进一步的查询，并在非常接近决策边界的实例上着陆。
-
但是我们如何知道我们是否到达了决策边界呢？为此，我们需要定义相反类别之间概率分数的差异。如果分数差低于这个值，我们就停止查询。
-
但是在这里，我们冒着只在本地邻居中查询的风险。因此，为了在附近得到更多的点，我们需要尝试更多的技巧，如下所述。但是当然，如果有足够多的点分布在特征空间中，这在某种程度上是可以解决的。
-
为了在局部邻域之外进行查询，我们可以添加一个相对于相对类的最近对的正交向量，然后找出它的中点。但是如何做到这一点呢？嗯，我们可以再次找出对的中点，然后通过正交添加一条线找到它附近的另一个点。这条线的长度可以是父点之间的欧几里德距离的数量级。该过程简要说明如下。
The procedure of query beyond the local vicinity | Source: Author
- 下一步是(从当前模型中)获取该点的标签，并在另一个类中获取最近的未标记点，并再次重复该过程。这样，我们可以生成一堆更接近当前模型决策边界的数据实例。然后从人类先知那里获得这些生成点的标签，并用这些附加数据重新训练先前的模型。再次重复整个过程，直到达到我们的模型性能目标。
Visualization for generating queries by finding an opposite pair close to the hyperplane | Source
上述方法在理论上非常有效。但是，如果我们正在处理一个复杂的语言模型或计算机视觉用例，其中生成的查询点对人类的 oracle 没有任何意义，该怎么办呢？
如果这是一项计算机视觉任务，这些生成的实例可能无法被人类先知识别。因此，我们从未标记的集合中选择最近的邻居并查询其标记。最近邻搜索可以通过简单的欧几里德距离测量或基于余弦相似性。
我希望你们都熟悉用于手写数字分类的 MNIST 数据集。请看看下面显示的一组图像。顶部显示的是 MNIST 数据集中手写数字的随机样本。底部的一个显示了通过查询和最近邻搜索从同一数据集中选择的一些数字(3，5，7)。但是底下的不都比上面的看起来怪吗？对，没错！就应该是这样的！因为该算法正在寻找边缘情况，或者换句话说，奇怪的情况！
A random sample of handwritten numbers in the MNIST dataset | Source
Numbers (3, 5, 7) selected through querying and nearest neighbour search from the same MNIST dataset | Source
你可以在关于最近邻搜索的文章中详细了解这个过程。
使用抽样技术的主动学习
使用采样的主动学习可以归结为以下步骤:
- 使用人类甲骨文标记子样本数据。
- 在标记的数据上训练一个相对较轻的模型。
- 该模型用于预测每个剩余的未标记数据点的类别。
- 基于模型输出，给每个未标记的数据点打分。
- 基于这些生成的分数选择子样本，并将其发送出去进行标记(子样本的大小可能取决于标记预算/资源和时间的可用性)
- 基于累积的标记数据集重新训练该模型。
重复步骤 3-6，直到模型达到所需的性能水平。在稍后的阶段，您也可以增加模型的复杂性。这里有几个基于此的场景。
1.基于流的采样
在基于流的选择性采样中，未标记的数据被连续地馈送到主动学习系统，在该系统中，学习者基于预定义的学习策略来决定是否将这些数据发送给人类先知。这种方法适用于模型在生产中，并且数据源/分布随时间变化的场景。
2.基于池的采样
在这种情况下，数据样本是基于信息值得分从未标记的数据池中选择的，并被发送用于手动标记。与基于流的采样不同，通常会仔细检查整个未标记的数据集，以选择最佳实例。
所以现在我们知道，从更广泛的角度来看，主动学习算法在未标记数据集的子样本上归零，但是这种选择是如何发生的呢？我们在下面讨论这样的策略，允许选择与模型学习最相关的数据样本。
主动学习:二次抽样策略
基于委员会的策略
通过建立几个模型，从模型预测中选择信息丰富的样本。这里提到的这些模型的集合称为委员会。如果委员会中有 n 个不同的模型，那么我们可以对一个数据样本进行 n 次预测。抽样可以基于投票或产生的方差(在回归变量的情况下)，甚至基于这些模型之间的不一致。
有几种常见的方法可以为每个数据样本生成信息或优先级分数——
熵
根据维基百科，熵是一个科学概念，也是一个可测量的物理属性，通常与无序、随机或不确定状态相关联。
因此，想象一个有三个可预测类的监督学习场景。初始模型预测了类别概率，如 class_1 (0.45)、 class_2 (0.40)、 class_3 (0.15)。前两类对应的概率相当接近，相差只有 0.05。这意味着模型不确定它必须分配给数据实例的标签，因此导致两个或更多类别的接近概率。熵通常计算为所有类别的总和，如下所示。
这里‘x’代表每个类别，P(y|x)代表它们各自的预测概率。为未标记的数据点计算熵值，并发送选择的样本用于标记。更多上下文，请阅读机器学习中关于主动学习的内容。
KL-散度
KL-Divergence 代表两个概率分布之间的差异，或者，换句话说，它是一种统计距离:一个概率分布 P 与另一个参考概率分布如何不同的度量。更多理解请参考这个kull back-lei bler 散度。
下面从可用的研究论文中触及两个突出的基于委员会的策略。
- 基于熵的 Bagging 查询
在这种方法中，k 个训练集是通过替换从原始数据集创建的。这些抽出的子集被提供给相同数量的模型(这些模型在模型类型/超参数方面可能不同)进行训练。然后，这些模型用于对未标记的数据样本池进行预测。在这种方法中，用于测量不一致的试探法是熵，因此得名 EQB(基于熵的 bagging 查询)。
- 自适应最大差异
这是通过分割特征空间并向每个模型提供具有不同特征的数据集来实现的。这样，我们可以在具有不同特征的数据集上训练不同的模型。所使用的度量将与之前的策略相同(熵)。
基于高利润的策略
它们特别适用于基于保证金的分类器，如 SVM。在 SVM，支持向量将是最能提供信息的点，因此所选择的数据点将是落在该边缘附近的数据点。到分离超平面的距离可以被认为是测量模型对未标记数据样本的置信度或确定性的良好度量。这一类别中有几个策略可以修改，以应用于基于概率的模型。
边缘取样(毫秒)
支持向量是位于距离逻辑决策边界正好 1 的边缘上的标记数据样本。边际抽样策略基于这样的假设，即落在该边际区域内的数据样本与获取标签最相关。
在上面所示的等式中，F(xi，w)表示任何数据样本和类 w 的超平面之间的距离。 U 表示未标记的数据集。该策略选择单个数据样本进行查询。
边缘采样-最近支持向量(MS-cSV)
该策略首先存储来自支持向量的每个数据样本的位置。对于每个支持向量，选择与该支持向量距离最小的数据样本。这样，我们可以在每次迭代中有不止一个未标记的数据样本，消除了简单边缘采样的缺点，即每次迭代只选择一个数据样本来查询人类 oracle。
基于概率的策略
这是基于类成员概率的估计。与基于边际的策略不同，这适用于任何可以计算与数据实例相关的概率的模型。
基于概率的最小利润策略
这说明了最高类别和第二高类别的类别预测概率的差异。一旦为整个未标记的数据集计算了它们，就可以基于所生成的分数来抽取样本，并将其发送用于标记。
这里‘x’代表每个类别，P(y|x)代表它们各自的预测概率。
根据上述关系，具有最低裕度的实例将首先被发送用于标记，即，它们是前两个可能的类中确定性最小的实例。
最不自信
这种策略允许主动学习者选择模型在预测或类别分配中最没有信心的未标记数据样本。因此，如果模型预测概率最高的类别为 0.5，则 LC 值变为 0.5。
这种关系可以从下面给出的表格中推导出来
预期模型变化
在该策略中，算法选择导致模型中最大变化的数据实例。这个变化，比方说，可以用 SGD 过程中这个数据实例对应的梯度来衡量(随机梯度下降)。
预期误差减少
该算法试图捕获这些数据实例，这将减少后续迭代中的错误。基于最大程度地减少模型训练误差的能力，逐步选择数据样本。
除了上面讨论的几个，使用的一些不太流行的度量是最大归一化对数概率(【MNLP】)和贝叶斯不一致主动学习( 【秃头】 )。
真实世界中的主动学习
主动学习在自然语言处理和计算机视觉领域非常流行。具体来说，在自然语言处理的情况下，用于词性标注的信息提取、命名实体识别(NER)等。，需要大量的训练(标注)数据，而为这类用例标注数据的成本确实很高。大多数高级语言模型都基于深度神经网络，并在大型数据集上进行训练。然而，在典型的训练场景下，如果数据集太小，占上风的深度学习通常会减弱。因此，要使深度学习广泛有用，找到上述问题的有效解决方案至关重要。
NLP 中的主动学习用例(NER)
下面讨论使用主动学习来改进命名实体识别(NER)模型的用例。这篇论文深入探讨了 NER 特有的主动学习。他们将上面讨论的策略/评分标准与为每次迭代的训练选择的随机样本进行了比较。用于基准测试的数据集是 OntoNotes 5.0 。
Active learning use case in NLP (NER) | Source
正如我们在上面看到的，很明显，所有的主动学习策略都远远超过了随机抽样(RAND)的基线表现。
显示基于不同主动学习策略的性能改进与迭代次数的关系的另一种表示如下所示。同样与使用随机抽样技术获得的训练数据进行比较。
The performance improvement based on different active learning strategies vs the number of iterations | Source
计算机视觉中的主动学习用例(自动驾驶)
自动驾驶可能是目前使用主动学习的最有前途和最有价值的用例，并已证明其巨大的商业价值。世界各地的研究人员都在致力于提高自动驾驶系统近乎完美的性能预期所要求的预测准确性。
为了达到这种高精度或性能预期，以视觉为重点的深度学习模型需要大量的训练数据。但是，选择“正确的”训练数据来捕获所有可能的条件/场景和边缘情况，并且以适当的代表性权重来捕获这些数据是一个巨大的挑战。
下图是一个典型的边缘案例，它可能会在自动驾驶系统中造成混乱并导致潜在的灾难性事件。
A case of potential catastrophic event in Autonomous driving systems | Source
那么，我们如何检测这些标签的情况呢？让我们来看看主动学习是如何为一些领先的科技公司解决这些挑战的。
来自英伟达的文章‘自动驾驶的可扩展主动学习’中的一个观察要点在此呈现。为了优化数据选择，需要考虑以下因素
- 规模:如上所述，一个简单的粗略计算表明，每天行驶 8 小时的 100 辆汽车的车队将需要超过 100 万个贴标机以 30fps 的速度标注所有摄像机的所有帧，以进行物体检测。这是非常不切实际的。
- 成本:如前所述，如果我们不小心标记什么，视觉数据集中的标记成本会非常高！
- 性能:选择合适的帧，例如，我们通常不会遇到的罕见场景。
在上述文章中，他们试图从一组未标记的 200 万帧中选择最佳训练样本，这些帧来自于从道路上的车辆收集的记录。该方法从基于池的采样和基于模型集合之间的不一致的查询功能/获取功能开始。让我们假设模型 1 &模型 2 预测具有最高概率的类的数据实例(X1)的类概率为 0.78 & 0.91，另一个数据实例(X2)的类概率为 0.76 & 0.82。这里的类概率分歧是(X1(0.13) & X2(0.06)。显然，X1 的阶级分歧高于 X2，因此 X1 将是主动学习的更优选候选人。获取功能被应用于未标记的帧，以在池中选择最有信息量的帧。
下面的操作是在一个循环中执行的，这几乎类似于经典的主动学习算法，但查询/采样的方式略有不同，这最适合这个特定的用例。
- 根据当前标记的数据，使用随机参数训练“n”个模型。
- 查询在训练模型之间显示最大差异的样本。
- 将选择的数据发送给人类先知进行注释。
- 将新标记的示例追加到训练数据。
- 重复步骤 1-4，直到合奏达到所需的性能水平。
选定框架的示例热图如下所示。热图显示了这些选定帧中模糊程度较高的区域。这些就是我们要捕捉的数据点，让模型高效学习！因此，当由人类注释者标记时，这些样本可以作为主动学习的合适候选。
Sample of selected frames via active learning | Source
除了成本优势之外，使用主动学习还观察到平均精度的显著提高(从异议检测的角度来看)。
Mean average precision weighted across several object sizes (wMAP) as well as MAP for large and medium object sizes on test data from both manual curation and active learning | Source
医学领域的主动学习用例
用于优化遗传和代谢网络的多功能主动学习工作流程是医学领域主动学习的经典范例，即使用最少的数据集最大化生物目标函数(取决于多个因素的输出/目标),如下所示。下图显示了基于主动学习的采样策略带来的蛋白质产量的提高。
The improvement of protein production | Source
一些用于主动学习的流行框架
1 . modal:python 3 的模块化主动学习框架
模态 是 Python3 的一个主动学习框架，设计时考虑了模块化、灵活性和可扩展性。它建立在 scikit-learn 的基础上，允许您以近乎完全的自由度快速创建主动学习工作流。
modAL 支持前面讨论的许多主动学习策略，比如基于概率/不确定性的算法、基于委员会的算法、减少错误等等。
使用 scikit-learn 分类器(例如 RandomForestClassifier)进行主动学习可以像下面这样简单。
from modAL.models import ActiveLearner
from sklearn.ensemble import RandomForestClassifier
learner = ActiveLearner(
estimator=RandomForestClassifier(),
X_training=X_training, y_training=y_training
)
query_idx, query_inst = learner.query(X_pool)
learner.teach(X_pool[query_idx], y_new) code source
2.libact:Python 中基于池的主动学习
libact 是一个 python 包，旨在让现实世界的用户更容易进行主动学习。该软件包不仅实现了几种流行的主动学习策略，还通过学习元策略实现了主动学习，使机器能够在运行中自动学习最佳策略。下面是 libact 的一个用法示例:
dataset = Dataset(X, y)
query_strategy = QueryStrategy(dataset)
labler = Labeler()
model = Model()
for _ in range(quota):
query_id = query_strategy.make_query()
lbl = labeler.label(dataset.data[query_id][0])
dataset.update(query_id, lbl)
model.train(dataset)
3.羊驼
AlpacaTag 是一个基于主动学习的人群标注框架，用于序列标注，如命名实体识别(NER)。如其文档中所述，羊驼的独特优势如下。
- 主动、智能推荐:动态建议注释，并对最有信息量的未标记实例进行采样。
- 自动群体合并:通过合并来自多个标注器的不一致标签来增强实时标注器间的一致性。
- 实时模型部署:用户可以在创建新注释的同时，在下游系统中部署他们的模型。
AlpacaTag 对 NER 用例的注释 UI 如下所示。
Annotation UI for NER use cases by AlpacaTag | Source
生产中的主动学习
到目前为止，我们试图理解主动学习的概念，它的策略，以及它的一些关键应用。现在让我们深入了解它们是如何在生产系统中实际实现的。
主动学习管道主要属于自动和半自动类别。下面以生产就绪工作流为例对它们进行了简要介绍。
主动学习管道–半自动
在半自动或半主动学习方法中，每个周期自动运行，但需要手动触发。需要人工干预的关键领域是
1.选择用于注释的数据–我们需要以明智的方式选择下一张图像。
2.从每个周期中创建的模型集合中选择最佳模型
需要密切监控半自动流水线的性能指标，例如每个主动学习周期之后的模型性能度量。这种技术本质上容易出错，尤其是当它需要多个学习周期时。
用自动训练和神童进行半自动或半主动学习的例子
本节将简要介绍我们如何使用 AutoTrain 和 Prodigy 构建一个主动学习管道。
但在此之前，让我们快速了解一下什么是 AutoTrain & Prodigy！
顾名思义，AutoNLP，现在命名为 AutoTrain，是一个由 Hugging Face 创建的框架，以非常少的代码在可用的数据集上构建我们自己的深度学习模型。AutoNLP 建立在最新的 NLP 模型上，如 Transformers、NLP inference-API 和其他工具。您可以轻松上传您的数据和相应的标签，以启动培训管道。有了 Auto Train，我们可以使用最好的可用模型，它可以根据用例自动进行微调，并服务于最终用户。因此生产准备就绪！
Prodigy 是一款由爆炸的商业注释工具。主要是它是一个基于网络的工具，允许你实时注释数据。它支持两种 NLP &计算机视觉任务。但是您可以使用任何其他最适合您的用例及成本约束的开源或商业工具！
运行管道涉及的步骤有
- 在 AutoTrain 中创建新项目。
Creating a new Project in AutoTrain | Source:
- 对于标注部分，Prodigy 为 NLP 任务提供了一个交互界面。您可以将它安装在您的本地机器或云服务器上，一旦 prodigy 安装完毕，您可以按以下格式运行它
$ prodigy ner . manual labelled _ dataset blank:en dataset . CSV–label label 1，label2，label3
让我们看看这里的论点，
- blank: en 是分词器。
- Dataset.csv 是您的自定义数据集。
- 标签 1，标签 2 …..是将用于标记的标签列表。
一旦运行了这个命令，您就可以转到 prodigy 提供的 web UI，它通常运行在一个本地主机端口上，然后开始标记过程。用 Prodigy 为 NER 用例标记数据的过程如下所示。更多详情请参考篇。
The process of labeling data for a NER | Source
下图显示了 Prodigy web 用户界面用于普通文本分类标签。
The Prodigy web UI used for vanilla text classification labeling | Source
-
创建的标记数据集被转换为 AutoTrain 可读格式，以便上传到 AutoTrain 项目中。请参考这篇文章了解更多信息。
-
运行 NER 的自动列车管道，并可视化所创建的模型集合的准确性。
Visualization of the accuracy of the ensemble of models created | Source
- 看看 NER 模型的准确性，如果您对模型的性能不满意，请使用更多的标注数据从第 2 步开始重复该过程。
上述过程是半主动学习，因为没有算法明确选择哪些应该是最好的实体来标记，因为在现实世界的 NER 用例中，这是不可行的。因此，半主动学习在 NER 领域是一个良好的开端！
主动学习管道——自动化
因此，在自动流水线中，我们将两个手动干预步骤留给智能算法。可以通过上一节中讨论的任何一种采样技术来选择用于注释的数据，即查询、基于池的采样等。选择最佳模型也可以基于我们选择的任何性能指标或它们的加权值。以下是一些带有 AWS 的 AL 管线的示例。
下面显示的是使用实时分类 API、反馈循环和人工审查工作流的参考架构。这里使用的主要服务是亚马逊理解。
A reference architecture using Real-time classification APIs, feedback loops, and human review workflows | Source
假设我们有一个基于文本的大型数据集，我们需要通过利用主动学习为其建立一个分类器。在 AWS 提供的众多服务中，Amazon understand 是专门为文本分析而构建的，无论是分类、揭示见解、主题建模还是情感分析。下面简要介绍管道中涉及的一些服务。
-
这个过程从调用一个带有需要分类的文本的 Amazon API gateway 端点开始。API 网关端点然后调用 AWS Lambda 函数，该函数又调用亚马逊理解端点来返回标签&置信度得分。
-
置信度较低的实例会被发送给一个人进行审查，在上图中被命名为隐式反馈。也可能有自定义反馈，它被捕获为显式反馈。
-
然后，人工注释的数据集被馈送到再训练工作流中，并且再训练的模型被测试其性能，并且重复这些步骤，直到达到期望的 KPI 值。
详细的实现管道，可以参考 AWS 博客。
这来自 AWS SageMaker 范例库。目前，它采用笔记本的形式，为文本分类标注作业的自动化标注工作流创建所需的资源。请通过以上链接详细了解工作流程。
结束了！
机器学习环境中的主动学习就是在训练迭代过程中，在人工标记器的帮助下，动态地、增量地标记数据，以便算法可以从未标记的池中检测出哪些数据对它来说是最有信息价值的。
主动学习的应用使得标注的成本大大降低，并且提高了某些基于自然语言处理和计算机视觉的模型的性能。许多兴趣和研究正在主动学习领域发生。但事实上，只有少数现成的主动学习渠道可供使用。即使利用了它们，也需要进行大量的定制来使它们适应您的特定用例。
因此，根据您的专业知识和用例，您可以从上面讨论的概念和应用程序中获得灵感，自己构建一个，或者利用商业工具。
祝你在积极的学习旅途中好运！
参考
遗传算法中的自适应变异与 Python 实例
遗传算法是一种流行的进化算法。它使用达尔文的自然进化理论来解决计算机科学中的复杂问题。但是，要做到这一点，算法的参数需要一点调整。
其中一个关键参数是突变。它使染色体(即解)发生随机变化，以提高质量(即适应性)。突变应用于固定数量的基因。传统上，相同数量的基因在所有染色体上发生突变，不管它们的适合度如何。
在本教程中，我们将了解为什么基因数量固定的突变是不好的，以及如何用适应性突变来取代它。使用 PyGAD Python 3 库，我们将讨论几个使用随机和自适应变异的例子。
遗传算法快速概述
遗传算法是一种基于群体的进化算法，其中一组解决方案一起工作来寻找问题的最佳参数。下图来自本书，总结了遗传算法的所有步骤。
解的群体是随机初始化的，其中每个解由许多基因组成。使用适应度函数来评估解决方案的质量，该函数返回表示解决方案的适合程度的数值。
This figure is copyrighted material in this book and should not be used without permission.
高质量(高适应性)的解决方案比低适应性的解决方案存在的时间更长。适应度越高，选择解作为父代产生新后代的概率就越高。为了产生后代，成对的父母使用交叉操作进行交配，在交叉操作中产生携带其父母基因的新解。
在交叉之后，变异被应用于在解决方案上添加一些随机变化。这种进化会持续几代，以达到最高质量的解决方案。
有关遗传算法的更多信息，请阅读本文:遗传算法优化介绍。
即使相同的步骤适用于所有类型的问题，您仍然需要选择合适的参数来适应不同的问题。这些参数包括:
- 群体中解的数量，
- 父选择类型，
- 交叉运算符类型，
- 变异运算符类型，
- 交叉概率，
- 突变概率，
- 健身功能。
例如，有不同类型的父母选择，像排名和轮盘赌，你应该知道在设计特定问题的算法时使用哪一种。
我们要关注的参数是突变概率。那么，我们来回顾一下变异操作，变异概率是高还是低比较好。
突变是如何工作的
给定两个亲本进行交配，交配过程中的第一个操作就是杂交。产生的孩子只是从它的两个父母那里转移了一些基因。孩子身上没有什么新东西，因为它的所有基因都已经存在于它的父母身上。下图显示了交叉是如何工作的。
This figure is copyrighted material in this book and should not be used without permission.
如果父母内部有一些不好的基因，杂交后肯定会遗传给孩子。变异操作在解决这个问题中起着至关重要的作用。
在突变过程中，从每个孩子中随机选择一些基因，在这些基因中应用一些随机变化。基于每个基因的随机概率来选择基因。如果基因突变的概率小于或等于预定的阈值，那么该基因将被选择用于突变。否则，它将被跳过。我们稍后会讨论突变概率。
让我们假设解决方案中有 4 个基因，如下图所示，其中只有最后一个基因被选择进行突变。应用随机变化来改变其旧值 2 ，新值为 4 。
This figure is copyrighted material in this book and should not be used without permission.
在简要回顾了随机变异的工作原理后，接下来我们将使用带有随机变异的遗传算法来解决一个问题。
随机突变示例
在本教程中，我们将使用一个名为 PyGAD 的开源 Python 3 库，它提供了一个简单的接口来使用遗传算法解决问题。更多信息，请查看文档。源代码可在 github.com/ahmedfgad 的获得。
通过 pip 安装 PyGAD，如下所示:
pip install pygad
因为 PyGAD 用的是 Python 3，所以 Linux 和 Mac 用 pip3 代替 pip。
安装后，我们用它来优化一个简单的 4 输入 1 输出的线性方程。
Y = w1X1 + w2X2 + w3X3 + w4X4
我们希望获得 w1 至 w4 的值，以使以下等式成立:
Y = w1(4)+w2(-2)+w3(3.5)+w4(5)
下面是解决这个问题的 Python 代码:
import pygad
import numpy
function_inputs = [4,-2,3.5,5]
desired_output = 44
def fitness_func(solution, solution_idx):
output = numpy.sum(solution*function_inputs)
fitness = 1.0 / (numpy.abs(output - desired_output) + 0.000001)
return fitness
ga_instance = pygad.GA(num_generations=100,
sol_per_pop=5,
num_genes=4,
num_parents_mating=2,
fitness_func=fitness_func,
mutation_type="random")
ga_instance.run()
ga_instance.plot_result()
需要遵循 3 个步骤:
- 构建适应度函数，这是一个常规的 Python 函数(最大化函数)。
- 创建 pygad 的一个实例。GA 级。
- 调用 run()方法。
适应度函数被命名为 fitness_func()，它必须接受两个参数。这个函数应该返回一个代表解的适合度的数字。该值越高，解决方案越好。
在 pygad 的例子中。GA 类，使用以下参数:
num_generations=100:世代数。sol_per_pop=5:人口规模。num_genes=4:基因数量。num_parents_mating=2:要交配的父母数量。fitness_func=fitness_func:健身功能。mutation_type="random":已经默认为随机的变异操作类型。
要运行遗传算法，只需调用 run()方法。完成后，可以调用 plot_result()方法来显示一个图，该图总结了所有代中最佳解决方案的适应值。
100 代完成后，可以使用 best_solution()返回遗传算法找到的最佳解决方案的一些信息。
最佳解的适应值为 761.4506452116121，w1 到 w4 的值如下:
w1 = 2.26799886
w2 =-0.86295921
w3 = 4.85859239
w4 = 3.2391401
接下来，我们来讨论突变概率的重要性。
恒定突变概率
变异操作在遗传算法中至关重要。它通过改变某些基因的值来提高新生孩子的质量。为了决定一个基因是否突变，使用突变概率。
在传统的遗传算法中，变异概率只有一个恒定值。所以，不管解的适应值是多少，都有相同数量的基因变异。
由于是常数，对于每个问题必须使用一个合理的突变概率值。如果概率大，那么很多基因都会发生变异。如果在一个高质量的解决方案中有太多的基因发生突变，那么随机变化可能会破坏太多的基因，从而使这个解决方案变得更糟。对于低质量的解决方案，突变大量的基因有利于提高其质量，因为它改变了许多不好的基因。
另一方面，一个小的突变概率只会导致少数基因发生突变。对于一个高质量的解决方案，只随机改变它的部分基因就能保持它的高质量，并有可能提高它的质量。对于一个低质量的解决方案，它的一小部分基因被改变，所以质量可能仍然很低。
下图总结了之前关于使用恒定突变概率的讨论:
- 小的变异概率对高质量的解是有利的，但对低质量的解是不利的。
- 高变异概率对低质量的解决方案有利，但对高质量的解决方案不利。
接下来，我们将编辑前面的 Python 示例，使用 mutation_probability 参数提供一个恒定的突变概率。
恒定变异概率 Python 示例
pygad 在 PyGAD 的构造函数中提供了一个名为 mutation_probability 的参数。GA 类提供一个恒定的变异概率，用于所有解决方案，而不考虑它们的适应性(即质量)。恒定概率是 0.6，这意味着如果基因的随机概率< =0.6，它就是突变的。
import pygad
import numpy
function_inputs = [4,-2,3.5,5]
desired_output = 44
def fitness_func(solution, solution_idx):
output = numpy.sum(solution*function_inputs)
fitness = 1.0 / (numpy.abs(output - desired_output) + 0.000001)
return fitness
ga_instance = pygad.GA(num_generations=100,
sol_per_pop=5,
num_genes=4,
num_parents_mating=2,
fitness_func=fitness_func,
mutation_type="random",
mutation_probability=0.6)
ga_instance.run()
ga_instance.plot_result()
如果突变概率是一个非常小的值，比如 0.001，那么解决方案的改进很小。在 100 代之后，最佳解的适应值是 0.077，而在前面的例子中，当概率是 0.6 时，适应值是 328.35。
现在我们将继续讨论适应性变异，它根据解决方案的适应性/质量来调整变异概率。
适应性突变
适应性变异最初是在一篇名为遗传算法中的适应性变异的论文中提出的。该论文总结了使用恒定突变概率的缺陷:
“经典”GAs 的弱点是突变的完全随机性，这同样适用于所有染色体，而不管它们的适合度如何。因此，一条非常好的染色体和一条不好的染色体一样有可能被突变破坏。
另一方面，坏染色体不太可能通过交叉产生好染色体，因为它们缺乏构建模块，直到它们保持不变。它们将从变异中受益最大，并且可以用于在整个参数空间中传播，以增加搜索的彻底性。因此，在确定最佳突变概率时，有两种相互冲突的需求。"
该论文建议，处理恒定突变概率的最佳方式是选择低概率。请记住，所有解决方案的低变异概率对高质量的解决方案有利，但对低质量的解决方案不利。
“通常，在恒定突变的情况下，合理的妥协是保持低概率以避免好染色体的破坏，但这将防止低适应度染色体的高突变率。因此，恒定的突变概率可能会错过这两个目标，并导致群体的缓慢改善。”
该论文建议使用适应性变异来解决恒定变异的问题。适应性变异是如何工作的:
- 计算群体的平均适应值(f _ avg)；
- 对于每个染色体，计算其适应值(f)；
- 如果 f <f_avg then="" this="" solution="" is="" regarded="" as="" a="">低质量的解，则突变率应该保持较高，因为这将提高该解的质量；</f_avg>
- 如果 f>f_avg，那么这个解被认为是一个高质量的解，因此变异率应该保持较低，以避免破坏这个高质量的解。
在 PyGAD 中，如果 f=f_avg，那么这个解是高质量的。
下图总结了前面的步骤。
接下来，我们将构建一个使用自适应变异的 Python 示例。
自适应变异 Python 示例
从 2.10.0 版本开始，PyGAD 支持自适应变异。确保您至少安装了 PyGAD 2.10.0:
pip install pygad==2.10.*
您还可以通过打印 version 属性来检查是否安装了 PyGAD 2.10.0，如下所示:
import pygad
print(pygad.__version__)
要在 PyGAD 中使用适应性变异，您需要做以下更改:
- 将 mutation_type 参数设置为“adaptive”:mutation _ type = " adaptive "；
- 将恰好具有 2 个值的 list/tuple/numpy.ndarray 赋给 mutation_probability 参数。这是一个例子:突变 _ 概率=[0.57，0.32]。第一个值 0.57 是低质量解决方案的变异概率。第二个值 0.32 是低质量解决方案的突变率。PyGAD 期望第一个值大于第二个值。
下一段代码使用自适应变异来解决线性问题。
import pygad
import numpy
function_inputs = [4,-2,3.5,5]
desired_output = 44
def fitness_func(solution, solution_idx):
output = numpy.sum(solution*function_inputs)
fitness = 1.0 / (numpy.abs(output - desired_output) + 0.000001)
return fitness
ga_instance = pygad.GA(num_generations=100,
sol_per_pop=5,
num_genes=4,
num_parents_mating=2,
fitness_func=fitness_func,
mutation_type="adaptive",
mutation_probability=[0.6, 0.2])
ga_instance.run()
ga_instance.plot_result()
在一次运行中，在 100 代之后找到的适应值是 974，并且 4 个参数 w1 到 w4 如下:
w1 = 2.73998896
w2 =-2.7606857
23 =-1.67836889，
w4=6.67838764
下图显示了最佳解决方案的适应值如何随着每一代而变化。
PyGAD 不使用 mutation_probability 参数，而是支持使用具有自适应变异的其他参数:
mutation_percent_genes:要突变的基因的百分比。例如，如果解有 100 个基因和mutation_percent_genes=20，那么有 20 个基因发生突变。mutation_num_genes:明确指定要变异的基因数量。
像 mutation_probability 参数一样，mutation_percent_genes和mutation_num_genes都接受一个 list/tuple/numpy.ndarray，当mutation_type=adaptive时正好有两个元素。
结论
就是这样！我们已经讨论了遗传算法和自适应变异，自适应变异基于解的适合度来选择变异概率。
我们从遗传算法的概述开始，重点放在变异操作上。您看到了使用恒定变异概率的缺点，以及如何用适应性变异来解决它们。我希望你喜欢这个教程。查看 PyGAD 库，实现常量和自适应变异。感谢阅读！
了解更多信息
- Ahmed Fawzy Gad，使用深度学习的实际计算机视觉应用与 CNN，Apress，978-1484241660，2018
- 利贝利、马尔西利和阿尔瓦。"遗传算法中的适应性变异."软计算 4.2 (2000): 76-80
- 丹·西蒙，进化优化算法，威利，978-0470937419，2013 年
- Ahmed Gad，遗传算法优化导论，数据科学
神经网络的对抗性攻击:探索快速梯度符号法
自从他们发明以来，神经网络一直是机器学习算法的精华。他们推动了人工智能领域的大部分突破。
神经网络已被证明在执行高度复杂的任务方面是稳健的，即使人类也发现这些任务非常具有挑战性。
它们不可思议的健壮性能超越最初的目的吗？这就是我们在这篇文章中试图找到的。
就我个人而言，我从未想到会与 AI 相交的一个领域是安全。事实证明，这是神经网络失败的少数领域之一。
我们将尝试一种非常流行的攻击方法，即快速梯度符号方法，来演示神经网络的安全漏洞。但首先，让我们来探讨不同类别的攻击。
敌对攻击
根据您作为攻击者对您想要欺骗的模型的了解，有几种类型的攻击。最流行的两种是白盒攻击和黑盒攻击。
这两种攻击类别的总体目标都是欺骗神经网络做出错误的预测。他们通过在网络的输入端添加难以察觉的噪声来做到这一点。
这两种攻击的不同之处在于您能够访问模型的整个架构。使用白盒攻击，您可以完全访问架构(权重)，以及模型的输入和输出。
黑盒攻击对模型的控制较低，因为您只能访问模型的输入和输出。
在执行这些攻击时，您可能会想到一些目标:
错误分类，您只想让模型做出错误的预测，而不担心预测的类别，
- 源/目标错误分类，您的目的是向图像添加噪声，以推动模型预测特定类别。
- 快速梯度符号方法(FGSM)结合了白盒方法和误分类目标。它欺骗神经网络模型做出错误的预测。
让我们看看 FGSM 是如何工作的。
快速梯度符号法解释
这个名字看起来很难理解，但是 FGSM 攻击非常简单。它依次包括三个步骤:
计算正向传播后的损耗，
计算相对于图像像素的梯度，
- 在计算出的梯度方向上稍微推动图像的像素，使上面计算出的损失最大化。
- 第一步，计算前向传播后的损失，在机器学习项目中很常见。我们使用负似然损失函数来估计我们的模型的预测与实际类别的接近程度。
- 不常见的，是 计算的渐变与 对图像像素的尊重。当涉及到训练神经网络时，梯度是你如何确定将你的权重微移至减少损失值的方向。
代替这样做，这里我们在梯度的方向上调整输入图像像素以使损失值最大化。
当训练神经网络时，确定调整网络深处的特定权重(即，损失函数相对于该特定权重的梯度)的方向的最流行的方法是将梯度从起点(输出部分)反向传播到权重。
同样的概念也适用于此。我们将梯度从输出层反向传播到输入图像。
在神经网络训练中，为了微调权重以降低损失值，我们使用这个简单的等式:
new _ weights = old _ weights–learning _ rate * gradients
同样，我们将相同的概念应用于 FGSM，但我们希望最大化损失，因此我们根据下面的等式微调图像的像素值:
新像素=旧像素+ε渐变*
在上面的图像中，我们看到两个箭头代表两种不同的方式来调整梯度，以达到一个目标。你可能已经猜对了，左手边的方程是训练神经网络的基本方程。自然，计算出的梯度指向损耗最大的方向。神经网络训练方程中的负号确保梯度指向相反的方向——使损失最小化的方向。右手边的方程不是这种情况，它是愚弄神经网络的方程。因为我们想使损失最大化，所以可以说，我们应用了自然形式的梯度。
这两个方程有许多不同之处。最重要的是加减法。通过使用等式 2 的结构，我们在与最小化损失的方向相反的方向上推动像素。通过这样做，我们告诉我们的模型只做一件事——做出错误的预测！
在上图中， x 代表我们希望模型错误预测的输入图像。图像的第二部分表示损失函数相对于输入图像的梯度。
请记住，梯度只是一个方向张量(它给出了关于向哪个方向移动的信息)。为了加强轻推效果，我们用一个非常小的值ε(图中为 0.007)乘以梯度。然后我们把结果加到输入图像上，就这样！
由此产生的图像下的令人担忧的表达可以简单地这样表达:
输入 _ 图像 _ 像素+ε损失函数相对于输入 _ 图像 _ 像素的梯度*
至此，让我们总结一下到目前为止所讲的内容，接下来我们将进行一些编码。为了欺骗神经网络做出错误的预测，我们:
通过我们的神经网络向前传播我们的图像，
计算损失，
- 将梯度反向传播到图像，
- 向最大化损失值的方向微移图像的像素。
- 通过这样做，我们告诉神经网络对远离正确类别的图像进行预测。
- 我们需要注意的一点是，噪声在最终图像上的显著程度取决于ε–值越大，噪声越明显。
增加ε也增加了网络做出错误预测的可能性。
代码
在本教程中，我们将使用 TensorFlow 来构建我们的整个管道。我们将把重点放在代码最重要的部分，而不是与数据处理相关的部分。
首先，我们将加载 TensorFlow 最先进的模型之一， mobileNet V2 模型:
将模型的可训练属性设置为 false 意味着我们的模型不能被训练，因此任何改变模型参数以欺骗模型的努力都将失败。
我们可能希望将图像可视化，以了解不同的ε值如何影响预测以及图像的性质。简单的代码片段就能解决这个问题。
接下来，我们加载我们的图像，通过我们的模型运行它，并获得相对于图像的损失梯度。
pretrained_model = tf.keras.applications.MobileNetV2(include_top=True,
weights='imagenet')
pretrained_model.trainable = False
打印 signed_grad 显示 1 的张量。一些带有正号，另一些带有负号，这表明梯度仅在图像上实施方向效果。绘制它揭示了下面的图像。
现在我们有了渐变，我们可以在与渐变方向相反的方向上轻推图像像素。
def display_images(image, info):
_, label, prob = get_imagenet_label(pretrained_model.predict(image))
plt.figure()
plt.imshow(image[0]*0.5+0.5)
plt.title('{} n {} : {:.2f}% prob.format(info,label,prob*100))
plt.show()
换句话说，我们在最大化损失的方向上轻推图像像素。我们将对不同的ε值运行攻击，其中ε= 0表示没有运行攻击。
loss_object = tf.keras.losses.Categorical_Crossentropy()
def create_adversarial_pattern(input_image, input_label):
with tf.GradientTape() as tape:
tape.watch(input_image)
prediction = pretrained_model(input_image)
loss = loss_object(input_label, prediction)
gradient = tape.gradient(loss, input_image)
signed_grad = tf.sign(gradient)
return signed_grad
我们得到以下结果:
注意到上面三幅图中的图案了吗？随着ε值的增加，噪声变得更加明显，并且错误预测的可信度增加。
我们成功地愚弄了一个最先进的模型，让它做出了错误的预测，而没有改变这个模型的任何东西。
epsilons = [0, 0.01, 0.1, 0.15]
descriptions = [('Epsilon = {:0.3f}'.format(eps) if eps else 'Input')
for eps in epsilons]
for i, eps in enumerate(epsilons):
adv_x = image + eps*perturbations
adv_x = tf.clip_by_value(adv_x, -1, 1)
display_images(adv_x, descriptions[i])
让我们在这里做一个小实验来证实我们上面讨论的一个概念。我们不是将ε和梯度的张量乘法结果(image + eps * signed_grad)加到图像上，而是将图像的像素向损失最大化的方向推，而是执行减法，将图像的像素向损失最小化的方向推(image–EPS * signed _ grad)。
结果是:
通过在使损失最小化的梯度方向上轻推图像像素，我们增加了模型做出正确预测的信心，这比没有这个实验要多得多。从 41.82%的信心到 97.89%。
后续步骤
epsilons = [0, 0.01, 0.1, 0.15]
descriptions = [('Epsilon = {:0.3f}'.format(eps) if eps else 'Input')
for eps in epsilons]
for i, eps in enumerate(epsilons):
adv_x = image - eps*perturbations
adv_x = tf.clip_by_value(adv_x, -1, 1)
display_images(adv_x, descriptions[i])
自从 FGSM 发明以来，又创造了其他几种攻击角度不同的方法。你可以在这里查看这些攻击:攻击调查。
你也可以尝试不同的模型和不同的图像。你也可以从头开始建立自己的模型，也可以尝试不同的ε值。
就这些了，谢谢你的阅读！
Next steps
Since the invention of the FGSM, several other methods were created with different angles of attacks. You can check out some of these attacks here: Survey on Attacks.
You can also try out different models and a different image. You may also build your own model from scratch and also try out different values of epsilon.
That’s it for now, thank you for reading!
亚马逊 SageMaker 的最佳替代品[用于实验跟踪和模型管理]
原文：https://web.archive.org/web/https://neptune.ai/blog/amazon-sagemaker-alternatives
机器学习项目远比典型的软件项目复杂。与主要涉及编写和测试一些代码的软件项目相比，ML 项目遵循一个迭代过程，需要大量的实验。ML 项目失败不仅仅是因为代码错误，还因为概念漂移、超参数值的不良调整以及错误的模型架构。追踪机器学习模型帮助数据科学家和 ML 工程师处理这类问题。市场上有许多工具可以帮助专业人员跟踪模型实验及其管理。
在本文中:
- 我们将看看这一类别中最流行的工具之一— AWS SageMaker 及其功能。
- 我们还将讨论 AWS SageMaker 存在不足的几种情况，以及我们可以参考的替代方案。
AWS SageMaker 概述
Amazon SageMaker 是一项完全托管的服务，为每个开发人员和数据科学家提供了准备、构建、训练和部署机器学习模型的能力，没有任何麻烦。SageMaker 负责所有复杂的过程，并使其用户更容易开发高质量的模型。为了使模型可以投入生产，并通过机器学习模型创造价值，数据科学家和 ML 工程师定期训练数千个不同版本的模型，以找到最准确的模型..
当 ML 团队必须处理成千上万的工作，跟踪不同的度量标准，比较不同实验的结果等时，创建模型并找到最佳模型可能是一项乏味的工作。Amazon SageMaker 在一个罩下包含不同的功能，可以帮助机器学习服务的端到端处理。
亚马逊 SageMaker 实验和模型监控是亚马逊 SageMaker Studio 集成的两项功能。ML 工程师可以很容易地运行查询来可视化模型、性能指标和任何概念漂移，如果有的话。它还提供了模型 注册表功能，用户可以在其中识别模型实例——以前的模型元数据、训练指标、超参数等。
如何在亚马逊 pagemaker 中管理实验
SageMaker 实验自动跟踪每次实验迭代的输入、参数、配置和结果。它与 SageMaker studio 集成在一起，并提供可视化功能来查看实验，根据关键指标进行比较，并决定哪一个是性能最佳的模型。它支持跟踪所有用于创建模型的工件，并且用户可以轻松地重新访问模型以进行故障诊断或审计。
组织实验—它为用户组织模型实验提供了一种结构化的方式。一个实验可以有多个试验，一个试验是运行 ML 模型所需的输入资产的集合。通过 SageMaker 实验，用户可以对每个机器学习迭代进行分组，然后确定哪个试验产生了最好的模型。
AWS SageMaker: experiments | Source
-
跟踪实验–有两种方法可以使用此功能跟踪实验——自动和手动。它可以自动记录和跟踪独立的训练、批量转换、所有实验工件，包括数据集、算法、超参数和度量等。对于手动跟踪，SageMaker 提供了跟踪 API 来在笔记本上本地记录和跟踪 ML 实验。
-
比较和评估实验—使用 SageMaker studio 用户可以使用度量图表和图形比较多个实验。这些实验可视化随着实验的进行而实时更新。
-
sage maker auto pilot—auto pilot 自动构建、训练和调整 ML 模型。这消除了繁重的工作，并自动探索不同的实验以找到最佳模型。
-
如何在 amazon pagemaker 中监控你的模型
SageMaker 模型监控自动监控生产中的机器学习模型，如果出现任何不准确的预测和数据漂移，可以提醒 ML 工程师。
根据 2010 年的一些数据训练的模型在 2021 年运行时可能会失败，因为输入数据的统计性质会逐渐改变，最终会影响模型的准确性。它还有助于识别机器学习模型中的任何潜在偏差。用户可以使用预构建的模型监控功能，也可以根据自己的需求进行编辑。SageMaker 为模型监控提供了以下功能:
AWS SageMaker: model monitoring | Source
数据质量—用户可以创建基准作业并分析输入数据集。这些基线作业可以计算基线模式约束和统计数据。监控数据质量有助于了解模型是否开始失去准确性。
-
模型质量—模型质量可以使用性能指标进行监控。用户可以将模型的预测与实际情况进行比较。
-
偏差漂移–sage maker 用户可以定期监控模型的偏差。当训练数据不同于实时数据时，可能会引入偏差。
-
特征归因漂移–与偏差漂移类似，使用特征归因漂移，用户可以查看单个特征，并比较训练数据和实时数据的排名。
-
amazon pagemaker 模型注册表
亚马逊 SageMaker 模型注册中心帮助对模型的不同版本进行编目。用户可以按照几个步骤注册模型版本，然后将其部署到生产环境中。下面是使用模型注册中心可以完成的事情:
创建模型目录，将模型的不同版本打包在一起。
- 管理模型版本。
- 将元数据与模型相关联。
- 跟踪一组中的所有模型。
- AWS Sagemaker 什么时候不是最佳选择？
AWS SageMaker: model groups and registry | Source
AWS SageMaker 为其用户提供了对其机器学习模型和维护的完全控制。这有助于客户专注于创造价值，而不是不断检查他们的模型。尽管 AWS 是一个非常受欢迎的选择，但它在很多事情和很多情况下都是失败的
灵活性—AWS SageMaker 具有多种功能，可帮助用户跟踪和比较模型实验，但它们都是一个生态系统(即 AWS sage maker)的一部分，不能单独使用。这是它的不足之处，因为它没有为不同专业水平的用户提供灵活性，这些用户只希望利用少数几个功能，并且只对跟踪实验和发现哪个模型是最好的感兴趣。
-
费用-AWS sage maker 可免费使用 AWS 免费层服务。尽管免费层有一些限制，但用户可以使用一些基本服务和有限的功能。如果用户超出基线，AWS 会相应收费。与其他可用的解决方案相比，AWS 非常昂贵，并且随着用户继续消费更多的服务，成本会呈指数级增长。AWS SageMaker 实例比同等的 AWS EC2 实例贵 40%。
-
模型比较–通过 AWS SageMaker，用户可以比较多个 ML 作业，尽管它支持的视觉效果和数据类型数量有限。它不提供不同实验的表格比较，用户不能一次比较 3 个以上的实验。用户不能使用笔记本或代码记录自定义比较。
-
强制工作流–AWS 最初是一家云服务提供商，现在已经增加了多种 ML 功能。AWS SageMaker 不仅仅是一个服务，而是一个端到端的平台，让用户创建 ML 管道。这有点像一个封闭的盒子，用户只能在 AWS 的能力范围内工作，例如 ML 模型和相关资产存储在 S3 上，这使得很难与他人分享结果。
-
文档&社区支持—sage maker 提供了大量的设置文档，但这些文档令人困惑，而且需要花费时间才能找到正确的指南或教程。尽管 SageMaker 已经存在了一段时间，但在 StackOverflow 这样的平台上很难找到在线解决方案。每次你在网上搜索答案的时候，你都会发现 AWS 网页上只有教程和博客，它们可能并不相关。用户能做的最好的事情就是查看 Python SDK 代码或联系 AWS 支持。用户也可以在 AWS 论坛上发布他们的问题，但可能需要一段时间才能得到答案。
-
总的来说，当您的企业或团队已经使用 AWS 时，AWS SageMaker 是一个很好的工具。市场上还有其他高级工具，它们可以通过广泛的集成阵容为客户提供最佳体验。这些工具也更加简单，可移植，允许用户访问 SageMaker。
亚马逊 pagemaker 替代品
1.海王星. ai
Neptune.ai 是一个 ML 元数据存储库，它提供了一个单一的位置来记录、存储、显示、组织、比较和查询所有的模型构建元数据。这个 ML 元数据包括度量、超参数、学习曲线、训练代码、配置文件、控制台日志、诊断图表、模型版本、数据集版本等等。
记录的 ML 元数据用于实验跟踪和模型注册。它使 ML 工程师和数据科学家能够在实验运行时监控实验，并跟踪指标、参数等。Neptune.ai 提供了一个非常友好的用户体验，允许用户搜索、分组和比较实验。用户可以很容易地与他们的团队成员分享结果。
Neptune.ai 的优势
它提供了与 25 种以上不同工具的简单无缝集成
- 团队可以轻松协作、共享报告和见解等。
- 它有一个非常直观和灵活的用户界面，允许用户根据自己的选择可视化和安排数据
- Neptune.ai 存储了大部分元数据及其版本，可以帮助用户重现模型
- 用户可以选择使用不同的过滤器搜索实验和数据
- 模型跟踪和管理的主要功能
实验跟踪
通过 Neptune.ai 的实验跟踪用户可以在一个地方轻松记录任何模型对象，并显示它们以供监控。用户可以在任何地方运行实验——在个人笔记本电脑、云、笔记本电脑等。但仍然能够使用托管版本或内部部署将结果整合到一个地方。
在对比实验时，平台会自动将差异显示在表格中。用户还可以利用交互式性能图表来清楚地了解每个实验。可以将比较视图保存为仪表板，供以后使用，或者与其他利益相关者一起研究和共享结果。
Neptune.ai: experiment tracking | Source
此外，所有记录的对象和比较视图都可以提取到本地机器上。用户甚至可以在几个月后回到实验中，并且可以在任何需要的时候访问这些实验。更多细节请查看 Neptune.ai 的概述。
Neptune.ai: comparing experiments | Source
模型注册表
Neptune . ai 中的模型注册表帮助用户存储不同版本的机器学习模型和建模元数据。这允许用户在中央模型注册中心组织模型。它存储任何模型的每个训练版本以及数据集、代码和参数，这有助于重现、重新运行和部署模型。
2.彗星
Neptune.ai: model registry | Source
Comet 帮助用户管理和优化从实验跟踪到模型生产监控的整个 ML 生命周期。它提供了简单快速的集成，只需在现有代码中包含几行代码，用户就可以开始跟踪实验并比较不同版本的模型等。用户可以实时监控模型，并确定模型在所有细分市场中的表现是否符合预期。
它允许企业将实验和所有过程可视化。用户可以轻松整合、管理和协作所有报告，甚至让利益相关方了解绩效。
优于 pagemaker
与其他工具无缝集成。
- 提供用户管理功能，项目或工作区的可见性可能受到限制。
- 为实验跟踪和比较提供交互式可视化。
- 在基于网络的用户界面中，实验台是完全可定制的。
- 分段性能跟踪有助于监控数据漂移。
- 模型跟踪和管理的主要功能
实验管理
使用实验管理，comet 有助于使用所有记录的数据建立更好的模型，同时提高生产力、协作和可解释性。用户可以使用代码、超参数、度量、预测、依赖性、系统度量来比较实验。用户可以记录、转换、比较和可视化任何人工制品。
Comet 还允许用户从模型预测中查看、分析和获得洞察力，例如检测过度拟合和概念漂移。在使用一个实验记录一个模型之后，用户可以在 comet 平台上注册这个模型，并且可以将同一个模型的不同版本与不同的工件或者一些变更进行分组。
Comet 有两个实验视图——实验表和实验选项卡。用户可以查看他们的实验，状态，运行时间和可见性设置等，也有额外的列。在实验选项卡视图中，用户将能够在不同的选项卡中查看每个工件——指标、超参数、图表视图、输出、数据等。
Comet: track and compare | Source
模型生产监控
在 comet 中，用户可以实时监控生产模型，包括关键生产指标，以确定模型是否按预期执行。在训练和部署模型之后，数据和环境往往会改变，这可能会导致模型不合适。在 comet 的帮助下，用户可以监控超出准确度的指标，并了解基本事实。
Comet 还提供分段的性能跟踪，确保所有关键部分的可见性。用户可以将生产监控与实验管理相结合，探索模型在不同环境中的表现。
Comet: model production monitoring | Source
史前古器物
用户可以记录和存储不同版本的数据和模型，并更新它们，而不用担心回到以前的版本。comet 工件的目的是允许在任何实验之外跟踪不同的资产。用户可以在 ML 管道中随时创建、管理和使用这些资产。这些存储的工件可以通过工作区访问，并且可以重新用于任何其他实验。
3.重量和偏差
Comet: dataset and model versioning | Source
Weight&bias是一个平台，用于记录模型训练，在交互式图形和表格的帮助下比较和可视化不同的模型实验。WandB 主要专注于深度学习项目。
它是最受欢迎的平台之一，因为它的定制功能是许多工具所不具备的，例如，它会告诉您哪些指标是重要的，它可以提前发布任何表现不如预期的实验，以节省处理时间。使用 W&B 用户可以跟踪培训过程的每个部分。
优于 pagemaker
日志数据集的重复数据消除。
- 及早停止以避免浪费昂贵的资源。
- 用户友好的交互式仪表板，一个跟踪所有实验的中心位置。
- 可视化端到端 ML 管道流，并为最佳性能模型保留检查点
- 可视化重要的、将对模型度量和性能产生影响的特性
- 无论是系统还是云服务提供商，W&B 都提供了对工件的灵活跟踪和托管。
- 模型跟踪和管理的主要功能
实验
WandB 提供了一个轻量级的集成，可以与任何 python 脚本一起工作。实验跟踪，比较和可视化模型及其性能就像编写 5 行代码一样简单。用户可以在交互式表格和图形中实时查看模型指标，并比较任何实验，而不管您的模型在什么环境和地方接受训练。用户可以直接在 W & B 上保存代码提交、超参数、数据集和权重等，也可以链接到他们自己的存储。
用户可以监控 GPU 和 CPU 的使用情况，以确定资源分配中的任何瓶颈，并确定问题区域。
Weight & Biases: visualize and compare experiments | Source
史前古器物
使用 WandB，用户不必担心记录模型和数据集中的变化。该平台支持保存机器学习管道中每个步骤的版本，除此之外，它还自动复制数据集，即它只保存最新的更改或新数据。
用户还可以在增量跟踪的帮助下跟踪数据流，WandB 将为性能最佳的模型保留数据流中的检查点。用 W&B 更容易处理敏感数据，并在有限的组内控制可访问性。
全胜
Weight & Biases: dataset and model versioning | Source
WandB 为超参数搜索和模型优化提供了这种独特的功能。这清楚地展示了将影响模型度量或性能的重要超参数。
由于 WandB 还跟踪 GPU 的使用情况，为了避免浪费昂贵的资源，他们在工具中实现了 Hyperband 算法，可定制提前停止。这个特性保持了性能最好的模型的运行，而扼杀了其余的模型。用户可以定制扫描，并为输入、逻辑甚至提前停止的时间提供他们自己的分布。
4.MLflow
Weight & Biases: parameter importance and logic for sweeps | Source
Weight & Biases: parameter importance and logic for sweeps | Source
MLflow 是一个开源的、与库无关的平台。用户可以在任何系统中使用 MLflow，并且可以实现实验跟踪、监控模型和创建他们的模型的中央存储库。用户可以使用任何编程语言的任何机器学习库使用 MLflow，因为所有功能都可以通过 REST API 访问。这些功能也可以通过 Python、R 和 Java APIs 获得。
MLflow 没有像其他可用工具那样的 UI，但为了可视化结果，用户可以通过访问本地服务器来访问 MLflow UI，但当我们想要协作时，它并不理想。幸运的是，由于其结构，很容易在任何第三方工具(如 AWS)上设置远程 MLflow 跟踪服务器。一个现实世界的例子是 Databricks，它有一个 MLflow 的托管版本，ML 团队可以在其上高效地工作和协作 ML 项目。
"Databricks 上的托管 MLflow 是 MLflow 的完全托管版本，为从业者提供跨 Data bricks 笔记本、作业和数据存储的再现性和实验管理，以及统一数据分析平台的可靠性、安全性和可扩展性。
优于 pagemaker
一个帮助统一 ML 工作流程的开源平台。
- MLflow 可以与任何云服务提供商合作。
- 与大量开源 ML 框架(如 TensorFlow、Apache Spark 等)的强大而简单的集成
- 实时实验跟踪，这意味着当代码运行时，用户可以跟踪模型的性能
- 模型跟踪和管理的主要功能
物流跟踪
借助 MLflow tracking 组件，用户可以轻松记录参数、代码版本、指标和输出文件。用户可以在任何地方使用 Python、REST、R 和 Java APIs 记录和查询实验。实验可以在本地或远程服务器上记录。MLflow 使用两种类型的存储—后端存储和工件存储。
后端存储将保存 MLflow 实体，如运行、参数、度量、标签、注释、元数据等，而工件存储包含文件、模型、图像、内存中的对象或模型摘要等。
MLflow 模型注册表
MLflow: comparing the models | Source
MLflow model registry 是一个模型库，帮助管理 MLflow 模型的整个生命周期。从模型沿袭、模型版本化、阶段转换和注释，模型注册中心保存所有的信息。当计划使用自己的 MLflow 服务器时，用户将需要一个后端数据库来存储和访问模型注册表。该模型应该被记录到相应的模型风格中，并且只有在那时才可以使用 MLflow UI 或 API 访问该模型注册中心来添加、修改、更新、转换或删除。
6. Kubeflow
MLflow: registering model and model stage transitioning | Source
MLflow: registering model and model stage transitioning | Source
Kubeflow 用于在 Kubernetes 上创建机器学习工作流。这个想法是让用户在任何有 kubernetes 的系统上利用这些服务。Kubernetes(K8)是一个容器编排工具。在容器和 docker 图像的帮助下，任何人都可以重新创建相同的环境并运行模型实验。
它有一系列不同的功能来支持实验跟踪、创建和管理 Jupiter 笔记本，还有一个开源的无服务器框架来实时跟踪 ML 模型。
优于 pagemaker
在 Kubernetes 上构建 ML 应用程序的开源工具，有助于 ML 生命周期的标准化。
- 用于管理和跟踪模型实验、作业和运行的优秀用户界面。
- 在使用 Kubeflow 框架时，用户可以利用 sagemaker 等其他工具的优势，如果需要，可以轻松地迁移到任何其他平台。
- 内置笔记本服务器服务，用户可以轻松创建和管理 jupyter 笔记本。
- 模型跟踪和管理的主要功能
库伯弗洛管道公司
Kubeflow 管道可用于支持机器学习项目的端到端编排。用户可以运行大量实验，并可以轻松管理机器学习模型上的试验或实验。一个解决方案中的解决方案组件可以轻松地重复使用，以创建另一个解决方案，没有任何麻烦。在 Kubeflow UI 中，用户可以查看管道的运行时执行图，添加或更新管道的输入和输出，如预测结果和准确性指标等。
Katib
Kubeflow: runtime execution graph | Source
Katib 是一个针对 AutoML 的 kubernetes-native 项目，它支持超参数调优和任何实验的提前停止。在 Katib 的帮助下，用户无需担心运行训练作业和手动调整超参数以找到最佳值。它还为超参数值的各种组合提供了准确性验证。这些调整参数或提前停止的实验必须在 YAML 配置文件中定义，以便 Katib 相应地获取和运行。
中央仪表板
Kubeflow: hyperparameters and tuning | Source
Kubeflow central dashboard 提供对集群中部署的其他 Kubeflow 组件的快速访问，例如笔记本电脑、管道、指标等的列表。用户可以轻松管理笔记本服务器、TensorBoards、KFServing 模型和实验。如果需要，管理员可以集成第三方应用程序。
7.瓦罗海
Kubeflow: central dashboard | Source
Valohai 是 MLOps 平台，帮助企业实现端到端 ML 管道的自动化。它兼容任何编程语言或框架。它帮助用户从任何地方运行他们的实验，并自动跟踪每个实验。它可以在任何云平台或内部轻松设置。
Valohai 还提供完整的版本控制、实验比较和可追溯性。用户可以部署不同的模型版本，监控性能指标，并在需要时使用记录的超参数和元数据来重现实验。
优于 pagemaker
在团队内部以完全透明的方式标准化工作流程。
- 一个具有异步超参数扫描功能的笔记本电脑中心。
- 以图形或表格的形式可视化实验比较。
- 兼容任何编程语言和 ML 框架。
- 版本控制–valo hai 会自动对用户运行的所有内容进行版本控制，例如超参数、库版本和硬件或资源设置。完整的版本控制是实现可再现性和法规遵从性的唯一途径。用户不需要维护单独的模型注册中心或元数据存储。
模型监控–它收集并存储流程内部输出的所有内容，无论是错误堆栈跟踪、模型指标还是健康信息。当度量被解析时，可以使用 Valohai 部署监视 UI 来可视化它们，用户可以在其中分析任何所选时间范围的日志和度量。
Valohai: model version control | Source
实验比较—从平台上的执行表中，用户可以选择多个实验/执行，并使用交互式图形和表格比较它们的元数据。用户可以在一个很大程度上分布式的学习运行中轻松地实时可视化超参数调整。也可以在本地下载这些元数据，然后离线比较实验。
Valohai: model monitoring | Source
数据字典—valo hai 自动跟踪机器学习模型中使用的每一项数据资产。它的数据树表示从最终结果一直到原始数据的每一步，允许您深入任何中间数据资产并检查它。
Valohai: compare executions | Source
表格对比:Sagemaker vs 替代品
Valohai: auditable data lineage | Source
到目前为止，在本文中，我们已经讨论了 AWS SageMaker 的替代产品，以及为什么以及何时应该选择它们。让我们快速看一下这些工具在不同方面的不同之处，这样你就可以为你的用例做出正确的选择。
最后的想法
当谈到实验跟踪和模型监控时，有大量的工具可供选择。AWS SageMaker 是 ML 工程师中最受欢迎的工具之一，但它有其局限性，这就是为什么企业正在寻找更加开放和简单的集成工具。
这些替代工具中的大多数都提供了很好的用户界面，并且不局限于某个特定的 ML 框架或云平台。工具的选择完全取决于个人需求，例如，如果用户只希望跟踪某项实验的性能，他们可能更喜欢独立的工具；如果要求看透模型管道的每一步，他们可以选择端到端平台。
在过去的几年中，这些实验跟踪和模型监控等的市场呈指数增长，并且当前可用的工具已经被进一步改进。工具列表并不仅限于上述工具，还有更多类似的工具，可能最适合用户需求，如神圣、公会 AI 、 TensorBoard 、 Verta.ai 等。
所以继续学习，快乐实验！
娜塔莎·夏尔马
埃森哲
公司的高级软件工程师她从大型机开发人员做起，逐渐掌握了其他编程语言和工具。她拥有格拉斯哥大学的数据科学硕士学位，曾在一家数字分析公司担任数据分析师。她相信不断的学习和知识分享会让她写文章。她一直通过博客为数据科学社区做出贡献，如《走向数据科学》、《心跳》和《数据科学+》。
阅读下一篇
InstaDeep 案例研究:寻找协作功能和所有实验的中心位置
5 分钟阅读| 2021 年 11 月 22 日更新
InstaDeep Case Study: Looking for Collaboration Features and One Central Place for All Experiments
InstaDeep 是提供决策型人工智能产品的 EMEA 领导者。利用他们在 GPU 加速计算、深度学习和强化学习方面的广泛知识，他们已经构建了一些产品，如新颖的 DeepChain 平台，以解决一系列行业中最复杂的挑战。
InstaDeep 还与人工智能生态系统的全球领导者建立了合作关系，如谷歌 DeepMind、英伟达和英特尔。他们是英特尔 AI Builders 计划的一部分，也是 EMEA 仅有的两家英伟达精英服务交付合作伙伴之一。InstaDeep 团队由大约 155 人组成，在伦敦、巴黎、突尼斯、拉各斯、迪拜和开普敦的办事处网络中工作，并且发展迅速。
关于 BioAI 团队
BioAI 团队是 InstaDeep 中生物学与人工智能相遇的地方。在 BioAI，他们通过结合生物学和机器学习专业知识，推进医疗保健，并推动医学科学的发展。他们目前正在构建 DeepChain ，这是他们的蛋白质设计平台。他们还与生物领域的客户合作，在生物信息学和机器学习的帮助下解决最具挑战性的问题。
About the BioAI team
The BioAI team is the place at InstaDeep where Biology meets Artificial intelligence. At BioAI, they advance healthcare and push the boundaries of medical science through a combination of biology and machine learning expertise. They are currently building DeepChain™, their platform for protein design. They are also working with their customers in the bio sector to tackle the most challenging problems with the help of bioinformatics and machine learning.
他们应用 DeepChain 蛋白质设计平台，使用强化学习和进化算法等复杂的优化技术来设计蛋白质目标的新序列。他们还利用在数百万蛋白质序列上预先训练的语言模型，训练他们自己的内部蛋白质语言模型。最后，他们使用机器学习从序列中预测蛋白质结构。
问题
构建像蛋白质设计平台 DeepChain 这样的复杂软件，需要对不同的活动部件进行大量研究。客户需要各种类型的解决方案，每次都需要新的实验和研究。由于要为不同的客户运行几个实验，因此对于任何规模的团队来说，在确保实验保持高效的同时跟踪这些实验都不可避免地令人望而生畏。
尼古拉斯和 BioAI 团队被管理大量实验的想法所困扰，遇到了一系列挑战:
Building complex software like DeepChain™, a platform for protein design, requires a lot of research with different moving parts. Customers demand various types of solutions that require new experiments and research every time. With several experiments running for different customers, it will be unavoidably daunting for a team of any size to keep track of the experiments while ensuring they remain productive.
实验日志到处都是
分享实验结果很困难
-
机器学习研究人员正在处理基础设施和运营
-
2It was difficult to share experiment results
-
3Machine learning researchers were dealing with infrastructure and operations
深度学习指南:选择您的数据注释工具
我们都知道数据标注是什么。这是任何有监督的深度学习项目的一部分，包括计算机视觉。常见的计算机视觉任务，如图像分类、对象检测和分割，需要将每幅图像的注释输入到模型训练算法中。
你必须得到一个好的图像注释工具。在这篇文章中，我们将检查我作为深度学习工程师的职业生涯中工作过的几个最佳选择。尽管它们有相同的最终目标，但每个注释工具都非常独特，各有利弊。
为了比较它们，让我们定义一个标准列表，帮助您选择最适合您、您的团队和您的项目的工具。
选择正确的数据注记工具的标准如下:
- 效率，
- 功能性，
- 格式化，
- 应用程序，
- 价格。
效率
现在有很多图片可供深度学习工程师使用。注释本质上是手动的，所以图像标记可能会消耗大量的时间和资源。寻找尽可能节省手工注释时间的工具。诸如方便的用户界面(UI)、热键支持以及其他节省我们时间和提高注释质量的特性。这就是效率的意义所在。
功能
计算机视觉中的标签会根据您正在处理的任务而有所不同。例如，在分类中，我们需要一个标签(通常是一个整数)来明确定义给定图像的类别。
目标检测是计算机视觉中更高级的任务。就注释而言，对于每一个对象，您都需要一个类标签，以及一个边界框的一组坐标，该边界框明确说明给定对象在图像中的位置。
语义分割需要类别标签和具有对象轮廓的像素级遮罩。
因此，根据您正在处理的问题，您应该有一个注释工具来提供您需要的所有功能。根据经验，拥有一个可以为您可能遇到的各种计算机视觉任务注释图像的工具是非常好的。
格式化
注释有不同的格式:COCO JSONs、Pascal VOC XMLs、TFRecords、文本文件(csv、txt)、图像遮罩等等。我们总是可以将注释从一种格式转换为另一种格式，但是拥有一个可以直接以目标格式输出注释的工具是简化数据准备工作流的一个很好的方法，并且可以节省大量时间。
应用
你正在寻找一个基于网络的注释应用程序吗？也许你有时会离线工作，但仍然需要做注释，并且想要一个可以在线和离线使用的窗口应用程序？在你的项目中，这些可能是重要的问题。
一些工具同时支持窗口应用程序和基于网络的应用程序。其他的可能只基于网络，所以你不能在网络浏览器窗口之外使用它们。在寻找注释工具时，请记住这一点。
如果您使用敏感数据，请考虑隐私问题:将您的数据上传到第三方 web 应用程序会增加数据泄露的风险。您愿意冒这个风险，还是选择更安全的本地注释者？
价格
价格总是很重要。从我个人的经验来看，大多数中小型团队的工程师倾向于寻找免费工具，这也是我们在本文中要关注的。
为了公平的比较，我们也来看看付费解决方案，看看它们是否值得。我们将看看付费解决方案有意义并实际产生附加价值的情况。
在我对每个注释工具的评论中，你不会看到“最好”或“最差”。对我们每个人来说，“最好的”工具是满足我们个人需求和环境的工具。
我将描述五大注释工具，希望你能为自己选择一个。这些工具已经被证明具有良好的性能，并且在深度学习工程师中非常有名。我有机会使用这些工具，我很高兴与您分享我的经验。让我们跳进来吧！
LabelImg 是一个免费的开源注释器。它有一个 Qt 图形界面，所以你可以安装它并且在任何操作系统上本地使用它。界面非常简单直观，所以学习曲线不会特别陡。
LabelImg 可以输出多种格式的注释，包括 Pascal VOC XMLs 和 YOLO 的 txts。它还可以通过一些额外的步骤输出CSV和 TFRecords 。
LabelImg 支持 热键 改进标注过程，使之更加方便。用户还可以享受标签图像验证功能。
LabelImg 有一个，但是非常重要的缺点——它只支持 包围盒 用于注释。还值得一提的是，LabelImg 严格来说是一个基于窗口的应用程序，没有浏览器支持。如果这些限制对您来说是可以接受的，那么 LabelImg 确实是项目注释器的一个很好的候选对象。
对于更详细的审查，指导安装和注释过程演示，我推荐观看由人工智能家伙创建的本教程。
VIA 是另一个应该在您的观察列表中的图像注释工具。这是一个免费的开源解决方案，由牛津大学的一个团队开发。
与 LabelImg 不同，VGG 图像注释器完全在浏览器窗口中运行。尽管这是一款基于网络的应用，但用户可以在大多数网络浏览器中离线工作。这款应用适合轻量级的 HTML 页面。
VIA 具有广泛的功能。您可以在对象周围绘制不同的区域形状。不仅仅是边界框，VGG 图像注释器还支持圆形，椭圆形，多边形，点和折线。
VIA 还可以注释视频帧、音频片段和视频字幕。如果您想要一个通用但简单的工具，VIA 可能是一个不错的选择。
它有加速注释过程的基本键盘快捷键。我个人喜欢热键在 VIA 中的工作方式。极其方便，井井有条。
最终注释文件只能以有限的格式导出:COCO JSONs、Pascal VOC XMLs 和 CSV 是支持的格式。要将注释转换成其他类型的格式，将需要额外的外部转换，所以在做出决定时要考虑到这一点。
要试用 VGG 图像注释器，请查看带有预加载数据的演示。以下是一些您可以浏览的使用案例:
如果你想知道注释过程是如何在 VIA 中执行的，这是 BigParticle 的指导教程。云会给你一个很好的概述。
CVAT 的用户界面(UI)根据许多专业注释团队的反馈进行了优化。正因为如此，CVAT 为图像和视频注释做了非常好的设计。
你可以从 CVAT 的网站开始注释工作，并在基于网络的应用中完全在线工作。不过，CVAT 的网站有一些局限性:
- 你只能上传 500 mb 的数据，
幸运的是，你可以在本地安装它，甚至离线工作。安装是很好的记录，所有的操作系统都被支持。
支持的形状形式包括矩形，多边形，折线，点，甚至长方体，标签和轨道。与以前的注释器相比，CVAT 支持语义分割的注释。
用于导出的支持的注释格式的数量令人印象深刻。以下是截至 2021 年 3 月的完整列表:
- CVAT(消歧义)
- 我是大地之神
- Pascal VOC(XML)
- Pascal VOC 的分段掩码
- YOLO
- COCO 对象检测(jsons)
- tfrecords . tfrecords . tfrecords . tfrecords . tfrecords
- 一个字
- 标签 3.0
- ImageNet
- 坎维德
- 宽脸
- VGGFace2
- 市场-1501
团队会发现 CVAT 特别有用，因为它是如此的协作。CVAT 允许用户创建注释任务，并将工作分配给其他用户。此外，可以使用elastic search logstash kibana对注释作业进行监控、可视化和分析。有机会控制贴标过程、可视化进度并根据监控结果进行管理总是很棒的。
快捷键涵盖了最常见的动作，在实际标注工作中帮助很大。
使用预训练模型的自动注释可用。用户可以从模型动物园中选择一个模型，或者连接一个定制模型。
它有一些缺陷。像有限的浏览器支持给 CVAT 的客户端。它只在谷歌 Chrome 中运行良好。CVAT 没有针对其他浏览器进行测试和优化。这就是为什么你可以在其他浏览器中得到不稳定的操作，虽然并不总是如此。我不使用谷歌 Chrome，也没有看到性能的明显下降，只是一些小问题没有困扰我。
为了了解什么是 CVAT 及其用户界面，你可以尝试在 CVAT 的网站上进行在线演示，或者观看由 T4 尼基塔·马诺维奇制作的关于 T2 对象注释过程的视频。
VoTT was designed to fit into the end to end machine learning workflow.
Image from the official Microsoft’s github page
微软提出了自己的数据标注解决方案——可视对象标记工具(VoTT)。免费的开源工具，在数据科学家和机器学习工程师中享有很好的声誉。
微软表示，“VoTT 有助于促进端到端的机器学习管道”。它有三个主要特点:
- 它标记图像或视频帧的能力；
- 用于从本地或云存储提供商导入数据的可扩展模型；
- 用于将标记数据导出到本地或云存储的可扩展模型。
有一个网络应用程序和一个本地应用程序。与竞争对手相比，任何现代网络浏览器都可以运行注释者网络应用。对于那些习惯了某个特定浏览器，不想改变它的团队来说，这绝对是一个竞争优势。
另一方面，VoTT 的网络应用不像 VIA 的那么轻量级。在浏览器窗口中加载需要一些时间和资源。
VoTT 的 web 应用程序的另一个缺点是——它不能访问本地文件系统。数据集需要上传到云中，这可能不太方便。
可视对象标记工具将要求您指定两个连接:导入(源连接)和导出(目标连接)。VoTT 中的项目被设计为一个标签工作流程设置，需要定义源和目标连接。你可以在官方文件中分析 VoTT 对待和组织贴标工作的方式。整体结构设计和组织得非常好。
VoTT 中的批注形状仅限于两种类型:多边形和矩形。不过，用于导出的支持格式的库相当丰富。它包括:
- CSVs
- 通用 JSONs
- 帕斯卡 VOC
- TFRecords
- 微软认知工具包(CNTK)；
- Azure 自定义视觉服务。
有几个键盘快捷键,让用户在批注时总是一只手放在鼠标上，一只手放在键盘上。最常见的通用快捷方式(复制、粘贴、重做)在 VoTT 中也有完全的支持。
要尝试视觉对象标记工具，请访问 VoTT 的网络应用并尝试一下。关于 VoTT 的另一个很好的信息来源是指导教程。这个由 Intelec AI 编写的教程是我最喜欢的教程之一。如果你想了解更多关于 VoTT，它的 UI 和特性，可以考虑观看它。
我答应放一些付费的替代品，这就是。超级——端到端的计算机视觉生命周期平台。
Supervisely 不仅仅是一个注释工具，它还是一个用于计算机视觉产品开发的平台。从功能上讲，它不局限于单个数据注释过程。相反，团队和独立研究人员，不管有没有机器学习专业知识，都可以根据他们的需求建立深度学习解决方案。所有这些都在一个环境中完成。
在标记方面，Supervisely 让你不仅可以注释图像和视频，还可以注释 3D 点云(由复杂的传感器，如激光雷达和雷达传感器构建的 3D 场景)，以及体积切片。
注释工具包括传统的点、线、矩形和多边形。此外，一些像素级仪器:
- 画笔使用鼠标按住在场景上绘制任何形状；
- 删除不需要的像素的橡皮擦。
Supervisely 的一个最显著的特性可以增强实例和语义分割。叫做 AI 辅助标注。你只需要定义一个实例的形状，内置的神经网络会完成剩下的工作，填充目标像素。
An input image that needs manual instance segmentation labeling;
Instance outline defined manually by a user;
Instance segmentation output by AI Assisted Labeling.
图片取自人工智能辅助标注网页
注释作业可以在不同的比例进行管理。根据团队的不同，可以为用户分配不同的角色。标签工作进度是透明和可跟踪的。
带注释的数据可以立即用于训练神经网络。您可以从带有预训练模型的模型动物园中选择一个模型，或者选择一个定制模型。两种方式都可以。
模型动物园有非常丰富的预训练模型。动物园中的所有模型都可以添加到一个帐户中，并用于重新训练一个新的自定义模型，因此您不必担心特定神经网络所需的数据格式。超级为你做所有的数据准备和转换步骤。你只要把数据放进去就行了。
经过训练的模型可以作为 API 部署。或者，可以下载模型权重和源代码，用于任何其他场景。
Supervisely 还有许多其他很酷的特性，我无法在本文中一一介绍，因为我们将重点放在注释工具上。如果你想更多地了解这个平台，有一个官方的 youtube 频道。我鼓励你浏览他们的播放列表，观看关于你感兴趣的主题、功能和特性的视频。如果你愿意，你也可以看看一些用例。
在定价方面，学生和其他数据科学家可以免费使用 Supervisely。公司和企业应取得联系，以要求定价细节。Supervisely 表示，他们的服务被全球超过 25，000 家公司和研究人员使用，包括像马自达、阿里巴巴集团或巴斯夫这样的大公司。
结论
要为深度学习项目选择一个数据注释器，您需要考虑周全:有非常多的解决方案可供选择。毫不奇怪，每种工具都有不同的优缺点。到目前为止，您应该对它们之间的区别有了很好的认识，并且知道根据您的需求应该寻找什么。
我们已经从五个不同的角度考虑了五个候选人:效率、功能、注释格式、应用程序类型，当然还有价格。
我们的第一个候选对象 LabelImg 是一个简单的轻量级注释器。非常直观。如果你不需要不必要的复杂性，并且用标签解决对象检测任务，可能会对使用 LabelImg 感兴趣。它会完全满足你的需求。
VIA 涵盖了 LabelImg 的一些缺点。你可以使用网络应用程序，有更广泛的形状来标注；不仅仅是矩形，还有圆形、椭圆形、多边形、点和折线。
相反，CVAT 支持语义分割。它的协作功能将成为有效团队工作的良好基础。
VoTT 是唯一一个基于 web 的注释器，经过优化可以与所有现代 web 浏览器一起工作。它有微软做后盾，根本不可能是一个坏产品。
Supervisely 是我们唯一考虑的受薪候选人。有经验的深度学习工程师一定会受益于 Supervisely 的自动化和丰富的功能。经验较少的人会喜欢它如何简化机器学习工作流程。
找到并选择符合您要求的工具。希望这篇文章能帮助你做出好的选择。
时间序列中的异常检测
原文：https://web.archive.org/web/https://neptune.ai/blog/anomaly-detection-in-time-series
时间序列无处不在！网站上的用户行为，或财富 500 强公司的股票价格，或任何其他与时间相关的例子。时间序列数据在每个行业中都以某种形式存在。
自然，它也是研究最多的数据类型之一。根据经验，您可以说时间序列是一种基于某种时间相关维度(如年、月或秒)进行采样的数据。
时间序列是以有序的方式记录的并且在时间上相关的观察结果。
在分析时间序列数据时，我们必须确定异常值，就像我们在静态数据中所做的一样。如果您曾经以任何身份处理过数据，您就会知道异常值会给分析师带来多大的痛苦。这些异常值在时间序列行话中被称为“异常”。
时序数据中的异常/异常值和异常类型是什么？
从传统的观点来看，离群值/异常值是:
"一个与其他观测结果相差很大的观测结果，以至于让人怀疑它是由不同的机制产生的。"
因此，您可以将异常值视为不符合预期行为的观察值。
如上图所示，时间序列中的异常值可能有两种不同的含义。它们之间的语义区别主要基于你作为分析师的兴趣，或者特定的场景。
这些观察结果与噪声、错误或不需要的数据有关，这些数据本身对分析师来说并不有趣。在这些情况下，应删除或纠正异常值以提高数据质量，并生成可由其他数据挖掘算法使用的更清晰的数据集。例如，消除传感器传输误差以获得更准确的预测，因为主要目标是进行预测。
然而，近年来——特别是在时间序列数据领域——许多研究人员致力于检测和分析不寻常但有趣的现象。欺诈检测就是一个很好的例子——主要目标是检测和分析异常值本身。这些观察结果通常被称为异常。
时间序列的异常检测问题通常被公式化为识别相对于某种规范或通常信号的异常数据点。看看一些异常类型:
让我们逐一分析一下:
点异常值
点异常值是在特定时间实例中与时间序列中的其他值(全局异常值)或与其相邻点(局部异常值)相比表现异常的数据。
例子:你知道 Gamestop 狂潮吗？许多年轻的散户投资者购买 GME 股票，以报复大型对冲基金，推动股价大幅上涨。由于不太可能的事件而出现的突然、短暂的峰值是一个附加(点)异常值。基于时间的值在短时间内的意外增长(看起来像突然的峰值)属于加性异常值。
Source: Google
点异常值可以是单变量或多变量，这取决于它们是否分别影响一个或多个时间相关变量。
图 1a 包含两个单变量点异常值 O1 和 O2，而多变量时间序列由图 3b 中的三个变量组成，并且具有单变量(O3)和多变量(O1 和 O2)点异常值。
Fig: 1 — Point outliers in time series data. | Source
我们将在异常检测部分更深入地研究单变量点异常值。
后续异常值
这意味着连续的时间点，其联合行为是不寻常的，尽管每个单独的观察不一定是点异常值。子序列异常值也可以是全局的或局部的，并且可以影响一个(单变量子序列异常值)或多个(多变量子序列异常值)时间相关变量。
图 2 提供了单变量(图 2a 中的 O1 和 O2，以及图 2b 中的 O3)和多变量(图 2b 中的 O1 和 O2)子序列异常值的示例。注意，后者不一定影响所有变量(例如，图 2b 中的 O2)。
Fig: 2 — Subsequence outliers in time series data. | Source
时间序列数据中的异常检测技术
分析师可以用来识别数据中不同异常的技术很少。它从一个基本的统计分解开始，一直到自动编码器。让我们从最基本的开始，理解它如何以及为什么有用。
注意
STL 分解
STL 代表基于黄土的季节趋势分解程序。这种技术让你能够将你的时间序列信号分成三个部分:、季节、趋势和残差。
它适用于季节性时间序列，这也是最流行的时间序列数据类型。要生成 STL 分解图，我们只需使用令人惊叹的 statsmodels 来完成繁重的工作。
plt.rc('figure',figsize=(12,8))
plt.rc('font',size=15)
result = seasonal_decompose(lim_catfish_sales,model='additive')
fig = result.plot()
This is Catfish sales data from 1996–2000 with an anomaly introduced in Dec-1998
如果我们分析残差的偏差并为其引入一些阈值，我们将得到一个异常检测算法。为了实现这一点，我们只需要来自分解的剩余数据。
plt.rc('figure',figsize=(12,6))
plt.rc('font',size=15)
fig, ax = plt.subplots()
x = result.resid.index
y = result.resid.values
ax.plot_date(x, y, color='black',linestyle='--')
ax.annotate('Anomaly', (mdates.date2num(x[35]), y[35]), xytext=(30, 20),
textcoords='offset points', color='red',arrowprops=dict(facecolor='red',arrowstyle='fancy'))
fig.autofmt_xdate()
plt.show()
Residue from the above STL decomposition
利弊
它简单，健壮，可以处理很多不同的情况，所有的异常仍然可以被直观的解释。
缺点
这种技术最大的缺点是僵硬的调整选项。除了阈值和可能的置信区间之外，你对此无能为力。例如，您正在跟踪网站上的用户，该网站对公众关闭，然后突然开放。在这种情况下，您应该分别跟踪启动期前后发生的异常情况。
分类和回归树
我们可以利用决策树的能力和健壮性来识别时间序列数据中的异常值/异常。
- 首先，您可以使用监督学习来教会树对异常和非异常数据点进行分类。为了做到这一点，我们需要标记异常数据点，这在玩具数据集之外是不常见的。
- 无人监管才是你需要的！我们可以使用隔离森林算法来预测某个点是否是离群点，而不需要任何标记数据集的帮助。让我们看看怎么做。
与其他流行的离群点检测方法不同，隔离林的主要思想是显式识别异常，而不是分析正常数据点。像任何树集合方法一样，隔离森林是基于决策树的。
换句话说，隔离林纯粹基于异常是很少且不同的数据点这一事实来检测异常。异常隔离是在不采用任何距离或密度测量的情况下实现的。
- 当应用一个 IsolationForest 模型时，我们设置污染=离群值 _ 分数，也就是告诉模型数据中离群值的比例。这是一个试错指标。
- 拟合和预测(数据)对数据执行异常值检测，返回 1 表示正常，-1 表示异常。
- 最后，我们用时间序列视图可视化异常。
让我们一步一步来。首先，可视化时间序列数据:
plt.rc('figure',figsize=(12,6))
plt.rc('font',size=15)
catfish_sales.plot()
The same Catfish Sales data but with different (multiple) anomalies introduced
接下来，我们需要设置一些参数，如离群分数，并训练我们的 IsolationForest 模型。我们可以利用超级有用的 scikit-learn 来实现隔离森林算法。你可以在这里找到包含代码和其他东西的完整笔记本。
稍后阅读
如何使用 Neptune-sklearn 集成跟踪您的分类器、回归器和 k 均值聚类结果
outliers_fraction = float(.01)
scaler = StandardScaler()
np_scaled = scaler.fit_transform(catfish_sales.values.reshape(-1, 1))
data = pd.DataFrame(np_scaled)
model = IsolationForest(contamination=outliers_fraction)
model.fit(data)
最后，我们需要想象预测是怎样的。
catfish_sales['anomaly'] = model.predict(data)
fig, ax = plt.subplots(figsize=(10,6))
a = catfish_sales.loc[catfish_sales['anomaly'] == -1, ['Total']]
ax.plot(catfish_sales.index, catfish_sales['Total'], color='black', label = 'Normal')
ax.scatter(a.index,a['Total'], color='red', label = 'Anomaly')
plt.legend()
plt.show();
Anomaly Detection using Isolation Forest algorithm
如您所见，该算法在识别我们植入的异常方面做得非常好，但它也在开始时将一些点标记为“异常值”。这是由于两个原因:
- 一开始，该算法很天真，无法理解什么是异常。它得到的数据越多，它能看到的差异就越多，它会自我调整。
- 如果你看到许多真阴性，这意味着你的污染参数太高。相反，如果你没有看到红点在它们应该在的地方，那么污染参数设置得太低。
利弊
这种技术的最大优点是，您可以引入任意多的随机变量或特性来创建更复杂的模型。
缺点
缺点是越来越多的特性会很快影响你的计算性能。在这种情况下，您应该仔细选择功能。
使用预测的检测
使用预测的异常检测基于这样一种方法，即过去的几个点通过添加一些随机变量(通常是白噪声)来生成下一个点的预测。
可以想象，未来预测的积分会产生新的积分等等。它对预测范围的明显影响——信号变得更加平滑。
使用这种方法的难点在于，您应该选择差异数、自回归数和预测误差系数。
每处理一个新信号，你都应该建立一个新的预测模型。
另一个障碍是差分后你的信号应该是平稳的。简单地说，这意味着你的信号不应该依赖于时间，这是一个重要的限制。
我们可以利用不同的预测方法，如移动平均线，自回归方法，ARIMA 及其不同的变种。用 ARIMA 检测异常的程序是:
- 根据过去的数据预测新点，并找出与训练数据中的差值。
- 选择一个阈值并基于该差异阈值识别异常。就是这样！
为了测试这项技术，我们将使用时间序列中一个流行的模块，名为 fbprophet 。该模块专门针对平稳性和季节性，可以使用一些超参数进行调整。
The same Catfish Sales data but with different (multiple) anomalies introduced
我们将利用与上述相同的异常数据。首先，让我们导入它并为环境做好准备:
from fbprophet import Prophet
现在让我们定义预测函数。这里需要注意的一点是 fbprophet 将添加一些额外的指标作为特性，以便更好地识别异常。例如，预测的时间序列变量(通过模型)、目标时间序列变量的上限和下限以及趋势度量。
def fit_predict_model(dataframe, interval_width = 0.99, changepoint_range = 0.8):
m = Prophet(daily_seasonality = False, yearly_seasonality = False, weekly_seasonality = False,
seasonality_mode = 'additive',
interval_width = interval_width,
changepoint_range = changepoint_range)
m = m.fit(dataframe)
forecast = m.predict(dataframe)
forecast['fact'] = dataframe['y'].reset_index(drop = True)
return forecast
pred = fit_predict_model(t)
我们现在必须将预测变量推送到另一个函数，该函数将基于时间序列变量中的下限和上限阈值来检测异常。
def detect_anomalies(forecast):
forecasted = forecast[['ds','trend', 'yhat', 'yhat_lower', 'yhat_upper', 'fact']].copy()
forecasted['anomaly'] = 0
forecasted.loc[forecasted['fact'] > forecasted['yhat_upper'], 'anomaly'] = 1
forecasted.loc[forecasted['fact'] < forecasted['yhat_lower'], 'anomaly'] = -1
forecasted['importance'] = 0
forecasted.loc[forecasted['anomaly'] ==1, 'importance'] = \
(forecasted['fact'] - forecasted['yhat_upper'])/forecast['fact']
forecasted.loc[forecasted['anomaly'] ==-1, 'importance'] = \
(forecasted['yhat_lower'] - forecasted['fact'])/forecast['fact']
return forecasted
pred = detect_anomalies(pred)
最后，我们只需要绘制上述预测并可视化异常。
利弊
该算法很好地处理了不同的季节性参数，如每月或每年，并且它对所有时间序列指标都有本地支持。
如果仔细观察，与隔离林算法相比，该算法可以很好地处理边缘情况。
缺点
由于这种技术是基于预测的，它将在有限的数据场景中挣扎。在有限的数据中预测的质量会降低，异常检测的准确性也会降低。
基于聚类的异常检测
到目前为止，我们已经将 IsolationForest 算法视为我们的无监督异常检测方法。现在，我们将研究另一种无人监管的技术:聚类！
这种方法非常简单。落在定义的聚类之外的数据实例可能会被标记为异常。我们将使用 k-means 聚类，因为为什么不呢！
为了直观起见，我们将使用一个不同的数据集，该数据集对应于具有一个或多个基于时间的变量的多变量时间序列。数据集将是在这里找到的数据集的子集(列/特征是相同的)。
数据集描述:数据包含购物和购买信息以及价格竞争力信息。
现在为了处理 k-means，首先我们需要知道我们将要处理的聚类的数量。肘法在这方面非常有效。
Elbow 方法是聚类数与解释的方差/目标/得分的关系图
为了实现这一点，我们将使用 scikit-learn 的 K-means 实现。
data = df[['price_usd', 'srch_booking_window', 'srch_saturday_night_bool']]
n_cluster = range(1, 20)
kmeans = [KMeans(n_clusters=i).fit(data) for i in n_cluster]
scores = [kmeans[i].score(data) for i in range(len(kmeans))]
fig, ax = plt.subplots(figsize=(10,6))
ax.plot(n_cluster, scores)
plt.xlabel('Number of Clusters')
plt.ylabel('Score')
plt.title('Elbow Curve')
plt.show();
从上面的肘形曲线中，我们看到该图在 10 个聚类之后变得平稳，这意味着更多聚类的增加并不能解释我们的相关变量中更多的变化；在这种情况下，价格为美元。
我们设置 n_clusters=10，在生成 k-means 输出时，使用该数据来绘制 3D 聚类。
现在我们需要找出要保留的组件(特性)的数量。
data = df[['price_usd', 'srch_booking_window', 'srch_saturday_night_bool']]
X = data.values
X_std = StandardScaler().fit_transform(X)
mean_vec = np.mean(X_std, axis=0)
cov_mat = np.cov(X_std.T)
eig_vals, eig_vecs = np.linalg.eig(cov_mat)
eig_pairs = [ (np.abs(eig_vals[i]),eig_vecs[:,i]) for i in range(len(eig_vals))]
eig_pairs.sort(key = lambda x: x[0], reverse= True)
tot = sum(eig_vals)
var_exp = [(i/tot)*100 for i in sorted(eig_vals, reverse=True)]
cum_var_exp = np.cumsum(var_exp)
plt.figure(figsize=(10, 5))
plt.bar(range(len(var_exp)), var_exp, alpha=0.3, align='center', label='individual explained variance', color = 'y')
plt.step(range(len(cum_var_exp)), cum_var_exp, where='mid',label='cumulative explained variance')
plt.ylabel('Explained variance ratio')
plt.xlabel('Principal components')
plt.legend(loc='best')
plt.show();
我们看到第一个因素解释了将近 50%的差异。第二个成分解释了 30%以上。但是，请注意，几乎没有一个组件是真正可以忽略的。前两个组件包含 80%以上的信息。因此，我们将设置 n_components=2。
基于聚类的异常检测的基本假设是，如果我们对数据进行聚类，正常数据将属于聚类，而异常将不属于任何聚类，或者属于小聚类。
我们使用以下步骤来发现并可视化异常:
- 计算每个点与其最近质心之间的距离。最大的距离被认为是异常。
- 类似于 IsolationForest 算法，我们使用 outliers_fraction 向算法提供关于数据集中出现的离群值的比例的信息。这在很大程度上是一个超参数，需要点击/尝试或网格搜索来设置正确-作为一个开始数字，让我们估计，离群值分数=0.1
- 使用离群值分数计算离群值的数量。
- 将阈值设置为这些异常值的最小距离。
- anomaly1 的异常结果包含上述方法簇(0:正常，1:异常)。
- 使用集群视图可视化异常。
- 用时序视图可视化异常。
def getDistanceByPoint(data, model):
distance = pd.Series()
for i in range(0,len(data)):
Xa = np.array(data.loc[i])
Xb = model.cluster_centers_[model.labels_[i]-1]
distance.at[i]=np.linalg.norm(Xa-Xb)
return distance
outliers_fraction = 0.1
distance = getDistanceByPoint(data, kmeans[9])
number_of_outliers = int(outliers_fraction*len(distance))
threshold = distance.nlargest(number_of_outliers).min()
df['anomaly1'] = (distance >= threshold).astype(int)
fig, ax = plt.subplots(figsize=(10,6))
colors = {0:'blue', 1:'red'}
ax.scatter(df['principal_feature1'], df['principal_feature2'], c=df["anomaly1"].apply(lambda x: colors[x]))
plt.xlabel('principal feature1')
plt.ylabel('principal feature2')
plt.show();
现在，为了查看现实世界特征的异常，我们处理上一步创建的数据帧。
df = df.sort_values('date_time')
fig, ax = plt.subplots(figsize=(10,6))
a = df.loc[df['anomaly1'] == 1, ['date_time', 'price_usd']]
ax.plot(pd.to_datetime(df['date_time']), df['price_usd'], color='k',label='Normal')
ax.scatter(pd.to_datetime(a['date_time']),a['price_usd'], color='red', label='Anomaly')
ax.xaxis_date()
plt.xlabel('Date Time')
plt.ylabel('price in USD')
plt.legend()
fig.autofmt_xdate()
plt.show()
这种方法能够很好地封装峰，当然也有一些遗漏。这个问题的一部分可能是 outlier_fraction 没有处理很多值。
利弊
这种技术的最大优势类似于其他无监督技术，即您可以引入任意多的随机变量或特征来制作更复杂的模型。
缺点
缺点是越来越多的特性会很快影响你的计算性能。除此之外，还有更多的超参数需要调整和获得正确的结果，因此在性能方面总是有很大的模型差异。
自动编码器
没有深度学习就谈不上数据技术！因此，让我们讨论使用自动编码器的异常检测。
自动编码器是一种无监督的技术，它在通过不同的维度提取其特征的同时重新创建输入数据。因此，换句话说，如果我们使用来自自动编码器的数据的潜在表示，它对应于维度缩减。
为什么我们要应用降维来发现异常值？
如果我们降低维度，会不会丢失一些信息，包括离群值？答案是，一旦确定了主要模式，离群值就显现出来了。许多基于距离的技术(例如 KNNs)在计算整个特征空间中每个数据点的距离时会遭遇维数灾难。必须减少高维度。
有趣的是，在降维的过程中，离群值被识别出来。我们可以说离群点检测是降维的副产品。
自动编码器是一种无监督的发现异常的方法。
为什么选择自动编码器？
有许多有用的工具，如主成分分析(PCA)，用于检测异常值。为什么我们需要自动编码器？原因是 PCA 用线性代数来变换。相反，自动编码器技术可以利用其非线性激活功能和多层来执行非线性变换。用自动编码器训练几个层比用 PCA 训练一个巨大的变换更有效。因此，当数据问题本质上是复杂的和非线性的时，自动编码器技术显示了它们的优点。
建立模型
我们可以使用 Tensorflow 或 Pytorch 等流行的框架来实现自动编码器，但为了简单起见，我们将使用一个名为 PyOD 的 python 模块，它使用用户的少量输入在内部构建自动编码器。
对于数据部分，让我们使用 PyOD 的实用函数 generate_data()来生成 25 个变量、500 个观察值和 10%的异常值。
import numpy as np
import pandas as pd
from pyod.models.auto_encoder import AutoEncoder
from pyod.utils.data import generate_data
contamination = 0.1
n_train = 500
n_test = 500
n_features = 25
X_train, y_train, X_test, y_test = generate_data(
n_train=n_train, n_test=n_test,
n_features= n_features,
contamination=contamination,random_state=1234)
X_train = pd.DataFrame(X_train)
X_test = pd.DataFrame(X_test)
当您进行无监督学习时，标准化预测值总是一个安全的步骤，如下所示:
from sklearn.preprocessing import StandardScaler
X_train = StandardScaler().fit_transform(X_train)
X_train = pd.DataFrame(X_train)
X_test = StandardScaler().fit_transform(X_test)
X_test = pd.DataFrame(X_test)
为了更好地理解数据的样子，让我们使用主成分分析法将数据降维，并相应地绘图。
from sklearn.decomposition import PCA
pca = PCA(2)
x_pca = pca.fit_transform(X_train)
x_pca = pd.DataFrame(x_pca)
x_pca.columns=['PC1','PC2']
cdict = {0: 'red', 1: 'blue'}
import matplotlib.pyplot as plt
plt.scatter(X_train[0], X_train[1], c=y_train, alpha=1)
plt.title('Scatter plot')
plt.xlabel('x')
plt.ylabel('y')
plt.show()
聚集在一起的黑点是典型的观察值，而黄点是异常值。
模型设定
- [25, 2, 2, 25].输入层和输出层各有 25 个神经元。有两个隐藏层，每个都有两个神经元。
步骤 1——构建您的模型
clf = AutoEncoder(hidden_neurons =[25, 2, 2, 25])
clf.fit(X_train)
步骤 2——确定切割点
让我们应用训练好的模型 Clf 来预测测试数据中每个观察值的异常分数。我们如何定义离群值？异常值是指远离其他点的点，因此异常值分数由距离定义。PyOD 函数。decision_function()计算每个数据点的距离或异常值。
y_train_scores = clf.decision_scores_
y_test_scores = clf.decision_function(X_test)
y_test_scores = pd.Series(y_test_scores)
import matplotlib.pyplot as plt
plt.hist(y_test_scores, bins='auto')
plt.title("Histogram for Model Clf1 Anomaly Scores")
plt.show()
如果我们使用直方图通过异常分数来计算频率，我们会看到高分数对应于低频率——异常值的证据。我们选择 4.0 作为分界点，那些> =4.0 的为异常值。
步骤 3 —按集群获取汇总统计数据
让我们将那些异常分数低于 4.0 的观察值分配到聚类 0，将那些高于 4.0 的观察值分配到聚类 1。同样，让我们使用。groupby()。该模型已经识别了 50 个异常值(未示出)。
df_test = X_test.copy()
df_test['score'] = y_test_scores
df_test['cluster'] = np.where(df_test['score']<4, 0, 1)
df_test['cluster'].value_counts()
df_test.groupby('cluster').mean()
以下输出显示了每个聚类中的平均变量值。分类“1”(异常分类)的值与分类“0”(正常分类)的值大不相同。“得分”值显示了这些观察到的其他人的平均距离。高“分”意味着观察远离常态。
这样，我们可以很好地区分和标记典型基准面和异常。
利弊
- 自动编码器可以轻松处理高维数据。
- 由于其非线性行为，它可以在高维数据集中发现复杂的模式。
缺点
- 由于这是一种基于深度学习的策略，如果数据较少，它将特别困难。
- 如果网络深度增加，在处理大数据时，计算成本将会飙升。
到目前为止，我们已经看到了如何检测和识别异常。但是真正的问题出现在找到他们之后。现在怎么办？我们该怎么办？
让我们讨论一些您可以在您的场景中应用的要点。
如何处理异常情况？
检测之后，一个大问题是如何处理我们识别出的东西。有许多方法来处理新发现的信息。我将根据我的经验列出其中的一些来帮助你解决这个问题。
理解业务案例
异常几乎总是为你的问题提供新的信息和视角。股票价格突然上涨？这肯定是有原因的，就像我们在 Gamestop 看到的那样，疫情可能是另一个原因。因此，了解峰值背后的原因可以帮助你以有效的方式解决问题。
理解业务用例还可以帮助您更好地识别问题。例如，您可能正在进行某种欺诈检测，这意味着您的主要目标确实是了解数据中的异常值。
如果这些都不是你所关心的，你可以移除或平滑离群值。
调整异常值的统计方法
统计方法允许您调整异常值以匹配原始分布。让我们来看一个使用均值平滑异常的方法。
使用均值平滑异常值
这个想法是通过使用前一个日期时间的数据来平滑异常。例如，为了平衡由于您家中发生的事件而导致的突然用电量，您可以取前几年同一个月的平均用电量。
让我们实现同样的方法来获得一个清晰的图像。我们将使用与之前相同的鲶鱼销售数据。我们可以使用下面的脚本来调整平均值。
adjusted_data = lim_catfish_sales.copy()
adjusted_data.loc[curr_anomaly] = december_data[(december_data.index != curr_anomaly) & (december_data.index < test_data.index[0])].mean()
绘制调整后的数据和旧数据将如下所示:
plt.figure(figsize=(10,4))
plt.plot(lim_catfish_sales, color='firebrick', alpha=0.4)
plt.plot(adjusted_data)
plt.title('Catfish Sales in 1000s of Pounds', fontsize=20)
plt.ylabel('Sales', fontsize=16)
for year in range(start_date.year,end_date.year):
plt.axvline(pd.to_datetime(str(year)+'-01-01'), color='k', linestyle='--', alpha=0.2)
plt.axvline(curr_anomaly, color='k', alpha=0.7)
这样，您可以继续应用预测或分析，而不必太担心结果的偏斜。
有许多方法可以处理非时间序列数据，但不幸的是，由于底层结构的差异，这些方法不能直接用于时间序列。非时间序列处理方法涉及许多基于分布的方法，这些方法不能简单地转化为时间序列数据。如果你想看其中的一些，你可以点击这里的。
去除异常值
如果以上两个选项都没有在您的解决方案中引发任何争论，那么最后一个选项是消除异常。不建议这样做(因为您基本上是在去除一些潜在的有价值的信息)，除非这是绝对必要的，并且不会损害未来的分析。
您可以使用。熊猫识别后掉落()特征。它会为你做繁重的工作。
你已经到达终点了！
恭喜你！现在，您已经了解了异常情况、如何检测异常情况以及如何应对异常情况。少数尾注:
- 时间序列数据因商业案例的不同而有很大差异，因此最好进行试验并找出可行的方法，而不是仅仅应用您的发现。经验可以创造奇迹！
- 除了我们在这个博客上讨论的以外，还有大量的异常检测技术。我鼓励你多阅读研究论文。
你可以在这里找到完整的笔记本代码和一些额外的东西！
目前就这些，敬请关注更多！再见！
注:除非另有说明，图片均由作者创作。
Aayush Bajaj
NatWest Group 的数据科学家
一位热爱解决工程或科学数据问题的数据主管。在这里，你会发现很多概念博客以最具说明性的方式和框架相关教程进行了解释。如果你想知道机器将如何接管世界，请继续关注:)！
阅读下一篇
ML 实验跟踪:它是什么，为什么重要，以及如何实施
10 分钟阅读|作者 Jakub Czakon |年 7 月 14 日更新
我来分享一个听了太多次的故事。
“…我们和我的团队正在开发一个 ML 模型，我们进行了大量的实验，并获得了有希望的结果…
…不幸的是，我们无法确切地说出哪种性能最好，因为我们忘记了保存一些模型参数和数据集版本…
…几周后，我们甚至不确定我们实际尝试了什么，我们需要重新运行几乎所有的东西"
不幸的 ML 研究员。
事实是，当你开发 ML 模型时，你会进行大量的实验。
这些实验可能:
- 使用不同的模型和模型超参数
- 使用不同的培训或评估数据，
- 运行不同的代码(包括您想要快速测试的这个小变化)
- 在不同的环境中运行相同的代码(不知道安装的是 PyTorch 还是 Tensorflow 版本)
因此，它们可以产生完全不同的评估指标。
跟踪所有这些信息会很快变得非常困难。特别是如果你想组织和比较这些实验，并且确信你知道哪个设置产生了最好的结果。
这就是 ML 实验跟踪的用武之地。
Apache Spark 教程:开始使用 Spark 服务 ML 模型
原文：https://web.archive.org/web/https://neptune.ai/blog/apache-spark-tutorial
到 2025 年，预计每天将产生 463 艾字节的数据。数据科学家需要理解这些数据。显然，你不能在任何一台计算机上处理或存储大数据。大数据需要存储在计算机集群中。
这使得机器学习过程更加复杂。幸运的是，有专门为处理大数据而构建的工具。Apache Spark 就是这些工具之一。
让我们看看如何使用 Apache Spark 来处理大数据。
什么是阿帕奇火花？
Apache Spark 是一个分析和处理大数据的开源引擎。Spark 应用程序有一个驱动程序，运行用户的主要功能。它还负责在集群中执行并行操作。
这个上下文中的集群指的是一组节点。每个节点都是一台机器或服务器。发送给执行器的一个工作单元称为一个任务，涉及多个任务的并行计算称为一个作业。
火花语境
Spark 中的应用程序由 SparkContext 控制。它连接到集群管理器，如上图所示。有几个集群管理器，即:
- Spark 自己的独立集群管理器
- 梅索斯
- 故事
集群管理器为 Spark 应用程序分配资源。
火花执行者
执行器位于 worker 节点上，它们运行计算并存储应用程序的数据。工作节点负责在集群中运行应用程序代码。
Spark 中的每个应用都会有自己的执行程序。SparkContext 向执行者发送任务。应用程序是相互隔离的，因为每个应用程序都有自己的执行程序。
为什么使用 Apache Spark
还有其他工具，如 Hadoop ，可以用于分布式计算。你为什么要用 Apache Spark？
- 由于内存计算，它比 Hadoop 快 100 倍
- Apache Spark 可以用在 Java、 Scala 、 Python 、R 或者 SQL 中
- 您可以在 Hadoop、Apache Mesos、Kubernetes 或云中运行 Apache Spark
阿帕奇火花装置
预计您将在一个计算机集群中运行 Spark，例如一个云环境。然而，如果你是 Spark 的初学者，有更快的方法可以开始。让我们来看看其中的一些。
在 Google Colab 上设置 Spark
要在 Google Colab 上运行 Spark，你需要两样东西:openjdk 和 findspark。
“findspark”是使 spark 可以在 Google Colab 上导入的包。您还需要下载 Spark 并提取它。
!apt-get install openjdk-8-jdk-headless -qq > /dev/null
!wget -q https://www-us.apache.org/dist/spark/spark-3.0.1/spark-3.0.1-bin-hadoop2.7.tgz
!tar xf spark-3.0.1-bin-hadoop2.7.tgz
!pip install findspark
下一步，根据 Spark 和 Java 的安装位置设置一些环境变量。
import os
os.environ["JAVA_HOME"] = "/usr/lib/jvm/java-8-openjdk-amd64"
os.environ["SPARK_HOME"] = "/content/spark-3.0.1-bin-hadoop2.7"
接下来，使用“findspark”使 spark 可导入。
import findspark
findspark.init()
任何时候你想使用 Spark，你都需要创建 SparkContext。创建一个“SparkContext”实例，以确认 Spark 安装成功。
import pyspark
sc = pyspark.SparkContext()
在本地机器上安装 Apache Spark
如何在本地机器上安装 Spark？这个过程会变得非常复杂，非常迅速。这可能不值得，因为您实际上不会在本地机器上运行类似生产的集群。
使用容器在本地机器上运行 Spark 的安装会更加容易和快捷。您需要安装 Docker 以便使用容器安装 Spark。
下一步是从 Docker Hub 中提取 Spark 图像。完成后，您将能够访问本地主机:8888 上的现成笔记本。
$ docker run -p 8888:8888 jupyter/pyspark-notebook
当您导航到该笔记本时，您可以启动一个新的 SparkContext 来确认安装。
import pyspark
sc = pyspark.SparkContext()
在数据块上运行 Apache Spark
最省事的选择是使用 Databricks 社区版。你唯一需要做的就是建立一个免费账户。本文将假设您在 Databricks 上运行 Spark。然而，我们提到的所有其他替代方案都足够了。
Apache Spark 基础知识
在 Apache Spark 中需要理解的最基本的事情是它如何表示数据。主要表现在:
- 弹性分布式数据集
- Dataframes
弹性分布式数据集
一个弹性分布式数据集(RDD) 是一个可以并行操作的容错元素集合。rdd 自动从故障中恢复。在以下情况下，这种格式是很好的选择:
- 您正在处理非结构化数据，如媒体或文本流
- 您需要对数据集执行低级转换
RDD 创作
您可以通过并行化驱动程序中的集合或使用文件系统中的数据集来创建 RDD。Spark 将决定分割数据集的最佳分区数量。但是，您可以将它作为第二个参数传递给“并行化”函数:
my_list = [1, 2, 3, 4, 5,6]
my_list_distributed = sc.parallelize(my_list,3)
RDD 行动
在 Spark 中，有两种主要操作类型:
火花变换
转换将从现有的数据集创建新的数据集。这种操作的一个例子是“映射”。转换是懒惰的，这意味着它们不会立即返回计算结果。只有当动作请求结果时，计算才会发生。
my_list = [2,3,4,5,6]
def power_two(x):
return x**2
list(map(power_two,my_list))
Spark 中的其他转换包括:
filter–在选择在特定条件下返回 true 的项目后返回数据集union–返回两个数据集的并集
火花动作
在对数据集进行特定计算后，操作将返回值。例如,“减少”功能。
results = map(power_two,my_list)
for result in results:
print(result)
使用 Spark 还可以执行一些其他操作:
- ` collect '以数组形式返回数据集
- ` count '返回数据集中的项目数
- ` take(n )'返回数据集的前 n 个元素
- ` first '返回数据集中的第一个元素
RDD 持久性
Spark 允许您通过缓存数据集来提高应用程序的性能。计算结果可以保存在内存中，下次需要时可以从缓存中检索。Spark 中的缓存是容错的，因此任何丢失的分区都将使用创建它们的转换重新计算。
df.cache()
Dataframes
Spark 数据帧是不可变的，非常类似于熊猫数据帧。稍后您将会看到，Spark 数据帧可以使用 SQL 进行查询。通过下面的机器学习示例，您将看到 Spark 中数据帧和 SQL 的用法。
Spark 中的机器学习
你可以使用' pyspark.ml '在 spark 中进行机器学习，这个模块是 Spark 自带的，所以你不需要去寻找或者安装它。登录到您的 Databricks 帐户后，创建一个集群。本练习所需的笔记本电脑将在该集群中运行。
当集群准备就绪时，创建一个笔记本。接下来，您需要定义数据的来源。Databricks 允许您从其合作伙伴提供商上传数据或链接。上传数据时，需要小于 2GB。
为了便于说明，让我们使用来自 UCI 机器学习的心脏病数据集。
使用 Spark 进行数据探索
将数据集上传到 Databricks 后，请记下数据集的路径，以便可以使用它来加载数据。此外，请确保您的笔记本电脑已连接到集群。
df = spark.read.csv('/FileStore/tables/heart.csv',sep=',',inferSchema='true',header='true')
请注意，您不必创建 SparkContext。这是因为 Databricks 在默认情况下会为您做这件事。您可以在单元格中键入“sc”来确认这一点。
您还可以单击 Spark UI 的链接来查看关于您的集群的更多信息。
在数据块上运行数据探索的最快方法是使用“显示(df)”功能。这个函数是 Databricks 独有的，所以如果你在 Google Colab 或你的本地机器上，它将不起作用。在这些平台上，您可以使用:
df.display()
点击绘图选项按钮会给你更多的图表和选项，你可以尝试。你也可以下载这些图。
如前所述，您可以运行过滤操作。
df.filter((df.age>20) & (df.target=='1')).show()
Spark 还可以让你运行“分组”操作，就像你在熊猫身上做的那样。让我们看看如何做到这一点。
from pyspark.sql import functions as F
df.groupBy(["sex"]).agg(
F.mean("age").alias("Mean Age")
).show()
如果您来自 SQL 世界，您可能会对查询数据框感兴趣，就像查询 SQL 表一样。您可以通过使用“SQLContext”注册一个临时 SQL 表来实现这一点。之后，就可以正常运行 SQL 查询了。
from pyspark.sql import SQLContext
sqlContext = SQLContext(sc)
df.registerTempTable('df_table')
df_sql = sqlContext.sql('select age,target,sex,slope,cp from df_table where age>30 ORDER BY age DESC')
df_sql.show()
用 Spark 进行数据预处理
一旦完成了数据探索，下一步就是将数据转换成 Spark 的 MLlib 可以接受的格式。在这种情况下，需要将特征转换为单个向量，该向量将被传递给机器学习模型。
这可以使用“VectorAssembler”来完成。让我们导入它，并使用数据集中的功能实例化它。
from pyspark.ml.feature import VectorAssembler
feat_cols = ['age',
'sex',
'cp',
'trestbps',
'chol',
'fbs',
'restecg',
'thalach',
'exang',
'oldpeak',
'slope',
'ca',
'thal']
vec_assember = VectorAssembler(inputCols = feat_cols, outputCol='features' )
下一步是用它来转换数据框。
final_data = vec_assember.transform(df)
“take”功能可用于查看数据集的一部分。你会注意到一个叫做“特征”的向量，它包含了所有的特征。
final_data.take(2)
接下来，将数据集分成训练集和测试集。
training,testing = final_data.randomSplit([0.7,0.3],seed=42)
用 PySpark MLlib 构建机器学习模型
下一步是使这个数据集适合算法。这里我们用逻辑回归。
从导入开始。你可以在这里访问更多的算法。
from pyspark.ml.classification import LogisticRegression
让我们创建一个算法实例，同时传递标签列名和特性名。
lr = LogisticRegression(labelCol='target',featuresCol='features')
现在让模型适应训练集。
lrModel = lr.fit(training)
评估模型
在评估模型之前，您必须运行预测。使用“转换”功能。
predictions = lrModel.transform(testing)
您可以通过选择一些列来查看这些预测。
predictions.select('target','prediction','probability','age','sex').show()
由于这是二元分类，因此可以使用“BinaryClassificationEvaluator”函数来评估模型。
from pyspark.ml.evaluation import BinaryClassificationEvaluator
evaluator.evaluate(predictions)
服务于 Apache Spark 机器学习模型
Databricks 让你用 MLflow 服务你的机器学习模型。然而，为您的模型提供服务的最简单的方法是将其发送到像 Neptune 这样的模型注册中心。
lrModel.save("model.pkl")
neptune.log_artifact(“model.pkl”)
最后的想法
在本文中，您已经看到 Apache Spark 可用于分析和构建处理大数据的机器学习模型。我们还讨论了使用 Apache Spark 的核心概念:
- 什么是阿帕奇火花
- Apache Spark 中的数据表示
- 安装 Apache Spark 的各种方法
- 在本地机器 Databricks 和 Google Colab 上运行 Spark
- 使用 Apache Spark 构建和保存机器学习模型
现在，您已经掌握了使用大数据探索和构建机器学习模型所需的技能。感谢阅读！
人工智能在无人机技术中的应用:建立适用于无人机的机器学习模型(使用 TensorFlow/Keras)
欢迎回到利用无人机技术和深度学习构建面罩监控系统的第二部分。在第一部分中，我们介绍了无人机技术、各种分类、本项目使用的无人机架构，以及使用 python 设置无人机编程环境。
如果你不熟悉第 1 部分，你可以在我们的博客上找到它。
在这一部分中，我们将下载并预处理人脸面具数据集，使用 Tensorflow/Keras 建立人脸面具检测模型，运行训练并保存深度学习模型以供进一步实施。
先决条件
为了完全理解本教程，假设您:
以下是一些帮助您开始的链接:
现在，让我们继续建立我们的监视系统。在本节中，我们构建深度学习模型来检测两个类别，即:
- 戴面具的人
- 没有面具的人
Face mask classification
为了进行这种分类，我们将利用一种称为 卷积神经网络(CNN)的深度神经网络，它通常用于分析视觉图像。
下载和预处理数据集
数据是任何 ML/AI 算法的核心。对于这个项目，数据集是从 Kaggle 和 RMFD 数据集下载的。数据集由属于两类的 3835 幅图像组成:
- with_mask: 1916 个图像
- 不带 _mask: 1919 张图片。
为了开始构建这些模型，我们需要导入必要的库，包括用于预处理、模型构建、模型评估、可视化和文件管理的模块。
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.layers import AveragePooling2D
from tensorflow.keras.layers import Dropout
from tensorflow.keras.layers import Flatten
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Input
from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.applications.mobilenet_v2 import preprocess_input
from tensorflow.keras.preprocessing.image import img_to_array
from tensorflow.keras.preprocessing.image import load_img
from tensorflow.keras.utils import to_categorical
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from imutils import paths
import matplotlib.pyplot as plt
import numpy as np
import argparse
import os
同样为了帮助 TensorBoard 记录， Neptune AI 与两个平台进行了巧妙的集成。为了利用该服务，我们导入了以下库:
import random
import psutil
import neptune
import neptune_tensorboard as neptune_tb
接下来，我们将使用 dot_env 模块从.env加载我们的 Neptune API 凭证。需要这个 API 令牌来授权您的训练脚本和 Neptune 之间的通信。为了使我们的 API 令牌保密，因为它就像是我们应用程序的密码，我们将利用环境变量通过dot_env库来加载值。
from dotenv import load_dotenv
load_dotenv()
API_SECRET = os.getenv("NEPTUNE_API_TOKEN")
接下来，我们将启动项目并自动记录 TensorBoard 指标:
<pre class="hljs" style="display: block; overflow-x: auto; padding: 0.5em; color: rgb(51, 51, 51); background: rgb(248, 248, 248);">neptune.init(project_qualified_name=<span class="hljs-string" style="color: rgb(221, 17, 68);">'codebrain/Drone'</span>,
api_token=API_SECRET,
)
neptune_tb.integrate_with_tensorflow()
</pre>
有了这些，我们可以开始设置用于训练我们的人脸面具检测模型的环境，我们将初始化初始学习率、训练的时期数和批量大小，并设置实验日志目录。
PARAMS = {
'EPOCHS': 20,
'BS': 32,
'INIT_LR': 1e-4,
}
RUN_NAME = 'run_{}'.format(random.getrandbits(64))
EXPERIMENT_LOG_DIR = 'logs/{}'.format(RUN_NAME)
接下来，我们将构建参数解析器，使编写用户友好的命令行界面与数据集、绘图和模型进行交互变得容易。
ap = argparse.ArgumentParser()
ap.add_argument("-d", "--dataset", required=True,
help="path to input dataset")
ap.add_argument("-p", "--plot", type=str, default="plot.png",
help="path to output loss/accuracy plot")
ap.add_argument("-m", "--model", type=str,
default="mask_detector.model",
help="path to output face mask detector model")
args = vars(ap.parse_args())
接下来，我们将从数据集目录中获取图像列表，然后初始化数据和类/标签列表。
print("[INFO] loading images...")
imagePaths = list(paths.list_images(args["dataset"]))
data = []
labels = []
我们将循环遍历图像路径，从文件名中提取类别标签，并每次将图像预处理为 224×224 像素，然后输入到神经网络中。此外，我们将这些图像转换为数组，并将输入图像传递给preprocess_input函数，这意味着将您的图像充分转换为模型所需的格式(您保证您加载的图像与 preprocess_input 兼容)。最后将数据和标签转换成 NumPy 数组，以便进一步处理。对标签执行一次热编码，将分类数据转换为数字数据。
for imagePath in imagePaths:
label = imagePath.split(os.path.sep)[-2]
image = load_img(imagePath, target_size=(224, 224))
image = img_to_array(image)
image = preprocess_input(image)
data.append(image)
labels.append(label)
data = np.array(data, dtype="float32")
labels = np.array(labels)
lb = LabelBinarizer()
labels = lb.fit_transform(labels)
labels = to_categorical(labels)
接下来，我们告诉海王星创造一个实验。给它命名并记录超参数。如果可能的话，建议将所有内容都放在 with 语句中，以便在实验完成后执行自动清理。在训练模型之前，我们需要将数据分为训练和测试数据，其中 80%的数据用于训练，其余 20%用于测试。
with neptune.create_experiment(name=RUN_NAME, params=PARAMS):
(trainX, testX, trainY, testY) = train_test_split(data, labels,
test_size=0.20, stratify=labels, random_state=42)
构建训练图像生成器，以通过创建图像的修改版本来人为地扩大训练数据集的大小。这种数据扩充将有助于模型更好地概括。
aug = ImageDataGenerator(
rotation_range=20,
zoom_range=0.15,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.15,
horizontal_flip=True,
fill_mode="nearest")
模型结构
在对数据集进行预处理并正确标记后，下一步是训练一个模型来准确地对图像进行分类。有两种方法可以做到这一点，要么你从头开始建立一个分类器，要么使用一个预先训练好的模型。我选择了后者，并采用了 mobilenet_v2 这是一个 53 层深的卷积神经网络。
*MobileNet V2 Architecture *
注:使用预训练模型时，仔细阅读正在使用的模型非常重要，它可以用来解决手头的问题。此外，为了能够处理预处理过的数据集。由于 MobilenetV2 在对象检测、降低的复杂性以及对计算、图形处理和存储的限制方面具有最先进的性能，因此对其进行了调整。
调整模型包括用预训练的权重图像网加载模型，并向模型添加更多的结构。卷积层之后是激活函数 ReLU(增加非线性)和最大池(减少特征图)。添加辍学是为了防止神经网络过度拟合。然后，在末尾添加完全连接的层。最后，我们将我们的模型编译成损失函数、优化器和指标。****损失函数用于查找学习过程中的错误或偏差。 Keras 在模型编译过程中需要损失函数。优化是通过比较预测和损失函数来优化输入权重的重要过程，并且 指标用于评估您的模型的性能。模型被序列化并保存在我的本地磁盘上。
注意:头模型将被放置在基础模型之上，这将成为我们将要训练的实际模型。
baseModel = MobileNetV2(weights="imagenet", include_top=False,
input_tensor=Input(shape=(224, 224, 3)))
headModel = baseModel.output
headModel = AveragePooling2D(pool_size=(7, 7))(headModel)
headModel = Flatten(name="flatten")(headModel)
headModel = Dense(128, activation="relu")(headModel)
headModel = Dropout(0.5)(headModel)
headModel = Dense(2, activation="softmax")(headModel)
model = Model(inputs=baseModel.input, outputs=headModel)
for layer in baseModel.layers:
layer.trainable = False
print("[INFO] compiling model...")
opt = Adam(lr=PARAMS['INIT_LR'],
decay=PARAMS['INIT_LR'] / PARAMS['EPOCHS'])
model.compile(loss="binary_crossentropy", optimizer=opt,
metrics=["accuracy"])
print("[INFO] training head...")
tensorboard=tf.keras.callbacks.TensorBoard(log_dir=EXPERIMENT_LOG_DIR)
H = model.fit(
aug.flow(trainX, trainY, batch_size=PARAMS['BS']),
steps_per_epoch=len(trainX) // PARAMS['BS'],
validation_data=(testX, testY),
validation_steps=len(testX) // PARAMS['BS'],
epochs=PARAMS['EPOCHS'],
callbacks=[tensorboard]
)
下一步是通过预测测试数据标签来评估模型的性能。
print("[INFO] evaluating network...")
predIdxs = model.predict(testX, batch_size=PARAMS['BS'])
predIdxs = np.argmax(predIdxs, axis=1)
print(classification_report(testY.argmax(axis=1), predIdxs,
target_names=lb.classes_))
print("[INFO] saving mask detector model...")
model.save(args["model"], save_format="h5")
最后，我们需要从我们的海王星实验仪表板可视化训练损失和准确性。
在这里可以看到仪表板。
我们可以从 Neptune 实验仪表板监控硬件消耗。
仪表盘可以在这里看到。
在视频流上实现模型
这是一个新的脚本，它将从之前的会话中加载保存的模型。为了开始实现，我们需要导入一些必要的库。
from tensorflow.keras.applications.mobilenet_v2 import preprocess_input
from tensorflow.keras.preprocessing.image import img_to_array
from tensorflow.keras.models import load_model
from imutils.video import VideoStream
import numpy as np
import argparse
import imutils
import time
import cv2
import os
import time
接下来，我们将创建两个函数get_facenet_masknet和detect_and_predict_mask。get_facenet_masknet功能将读入之前序列化的训练模型和相应的权重。
def get_facenet_masknet():
ap = argparse.ArgumentParser()
ap.add_argument("-f", "--face", type=str,
default="face_detector",
help="path to face detector model directory")
ap.add_argument("-m", "--model", type=str,
default="mask_detector.model",
help="path to trained face mask detector model")
ap.add_argument("-c", "--confidence", type=float, default=0.5,
help="minimum probability to filter weak detections")
args = vars(ap.parse_args())
print("[INFO] loading face detector model...")
prototxtPath = (
'/Users/USER/Documents/DroneProjects/facemaskdetection/face_detector/deploy.prototxt')
weightsPath = (
'/Users/USER/Documents/DroneProjects/facemaskdetection/face_detector/res10_300x300_ssd_iter_140000.caffemodel')
faceNet = cv2.dnn.readNet(prototxtPath, weightsPath)
print("[INFO] loading face mask detector model...")
maskNet = load_model(
'/Users/USER/Documents/DroneProjects/facemaskdetection/mask_detector.model')
return(faceNet, maskNet, args)
在适当的位置，detect_and_predict_mask将抓取框架的尺寸，并从中构造一个斑点。斑点将通过网络来检测面部。
我们将抓住维度:
def detect_and_predict_mask(frame, faceNet, maskNet, args):
(h, w) = frame.shape[:2]
blob = cv2.dnn.blobFromImage(frame, 1.0, (300, 300),
(104.0, 177.0, 123.0))
faceNet.setInput(blob)
detections = faceNet.forward()
接下来，我们将初始化我们的人脸列表及其相应的位置，以及来自我们的人脸面具网络的预测列表。
faces = []
locs = []
preds = []
我们将循环检测以提取与检测相关的置信度(即概率)。
for i in range(0, detections.shape[2]):
confidence = detections[0, 0, i, 2]
接下来，我们将通过确保置信度大于最小置信度来过滤掉弱检测。
if confidence > args["confidence"]:
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype("int")
我们还必须确保边界框落在框架的尺寸范围内。
(startX, startY) = (max(0, startX), max(0, startY))
(endX, endY) = (min(w - 1, endX), min(h - 1, endY))
我们将做一些预处理步骤，包括提取面部 ROI，然后将其从 BGR 转换到 RGB 通道排序。然后继续将帧的大小调整为 224×224 像素，并将其转换为数组。
face = frame[startY:endY, startX:endX]
face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
face = cv2.resize(face, (224, 224))
face = img_to_array(face)
face = preprocess_input(face)
我们必须确保将面和边界框添加到它们各自的列表中。
faces.append(face)
locs.append((startX, startY, endX, endY))
如果至少检测到一个面，将进行预测，然后同时对所有面进行批量预测，而不是逐个预测。
if len(faces) > 0:
faces = np.array(faces, dtype="float32")
preds = maskNet.predict(faces, batch_size=32)
最后，我们将返回一个脸部位置及其对应位置的二元组。
return (locs, preds)
结论
在本教程中，您了解了如何预处理和加载面罩数据集，以及如何使用 Tensorflow Mobilenet V2 和 Python 来训练面罩检测模型。经过训练的模型进一步适用于视频流实现。最后，该模型被序列化为项目的下一阶段，包括在 flask 应用程序上部署该监视系统。
利用从第 1 部分和第 2 部分获得的知识，我们已经完全构建了监控系统的框架，下一部分将介绍该系统的部署。阅读愉快，敬请关注。
阿尔戈 vs 气流 vs 完美:它们有什么不同
原文：https://web.archive.org/web/https://neptune.ai/blog/argo-vs-airflow-vs-prefect-differences
我们生活在一个 ML 和 DL 软件无处不在的阶段。新的创业公司和其他各种公司正在将人工智能系统适应和集成到他们新的和现有的工作流程中，以提高生产率和效率。这些系统减少了手动任务，提供了智能的解决方案。尽管他们对自己所做的事情相当精通，但所有的人工智能系统都有不同的模块，必须将这些模块组合在一起才能构建一个可操作的有效产品。
这些系统可以大致分为五个阶段，记住这些阶段包含各种附加的和重复的任务:
- 1 数据收集
- 2 特色工程
- 建模(包括训练、验证、测试和推理)
- 4 部署
- 5 监控
单独执行这些阶段会花费大量时间和持续的人力。这些阶段必须同步，并按顺序编排，以便充分利用它们。这可以通过任务编排工具来实现，这些工具使 ML 从业者能够毫不费力地将人工智能系统的不同阶段整合在一起并进行编排。
在本文中，我们将探索:
- 1 什么是任务编排工具？
- 三种不同的工具可以帮助 ML 从业者协调他们的工作流程。
- 3 三种工具的对比
- 4 何时使用哪种工具？
编排工具使 MLOps 中的各种任务得以组织和顺序执行。这些工具能够在给定的时间内协调不同的任务。这些工具的关键属性之一是任务的分配。大多数工具利用了 DAG 或有向无环图，这在本文中会经常遇到。DAG 是需要执行的任务的图形表示。
*Graphic explanation of DAG | Source *
DAG 使管道中的任务能够并行分配给各种其他模块进行处理，这提供了效率。见上图。DAG 还使任务能够按顺序合理地执行或安排，以获得正确的执行和及时的结果。
这些工具的另一个重要特性是对敏捷环境的适应性。这使得 ML 从业者可以整合各种其他工具，用于监控、部署、分析和预处理、测试、推断等。如果一个编排工具可以从不同的工具中编排不同的任务，那么它可以被认为是一个好工具。但并非每次都是如此，一些工具被严格地包含在它们的派生环境中，这对于试图集成任何第三方应用程序的用户来说不是一个好兆头。
在本文中，我们将探索三个工具——Argo、气流和提督，它们结合了这两个属性以及其他各种属性。
TL；灾难恢复对照表
这里有一个受 Ian McGraw 文章启发的表格，它概述了这些工具为编排提供了什么，以及它们在这些方面有何不同。
| 特征 | 南船星座 | 气流 | 长官 | |
|---|---|---|---|---|
| 容错调度 | ||||
工作流定义语言
| | | |
| | | 由于 Argo 是基于容器的，它没有预装第三方系统。 |
支持各种第三方集成
|
支持各种第三方集成
|
| | | | | |
| | | | |
【混合(开源和基于订阅)
|
| | |
有广泛的参数传递语法。
|
没有传递参数的机制。
|
支持参数作为一级对象
|
| | | | | |
| | | | |
并联时使用 Kubernetes
|
| | | | | |
| | |
所有状态都存储在 Kubernetes 工作流内
| | |
| | | | | |
| | | | | |
| |
脚本中的 DAG 定义
|
Argo 使用文本脚本传入容器。
|
Airflow 使用基于 Python 的 DAG 定义语言。
|
Perfect 使用基于 Python 的 API 函数流。
|
| | |
–CI/CD-数据处理-基础设施自动化-机器学习-流处理
|
–ELT–ML 工作流- ML 自动化
|
–自动化数据工作流(ELT)–ML 工作流和流程编排——CI/CD
|
现在，让我们在三个主要类别下更详细地探讨这些工具:
- 1 核心概念
- 他们提供的功能
- 3 为什么要用？
核心概念
所有这三种工具都是建立在一套概念或原则之上的，它们都是围绕着这些概念或原则运行的。例如，Argo 是围绕两个概念构建的:工作流和模板。这两者构成了其系统的主干。同样，Airflow 是围绕web 服务器、【调度器】、执行器、和数据库、构建的，而 Prefect 是围绕流和任务构建的。现在重要的是我们要知道这些概念意味着什么，它们提供了什么，以及它如何对我们有益。
在进入细节之前，这里有一个概念的简要概述。
| 概念的属性 | |
|---|---|
它有两个概念工作流，和模板。本质上，工作流是配置 YAML 文件。它为工作流提供了结构和健壮性，因为它们使用 Dag 来管理工作流。另一方面，模板是需要执行的功能。
它们既是静态的也是动态的，这意味着您可以随时修改步骤。
|
| |
它有四个概念 Webserver、Scheduler、Executor、Database。他们基本上把整个过程分成不同的部分，这些概念作为主要的组成部分使整个过程自动化。这使得工作流变得高效，因为每个组件都依赖于另一个组件，这样就很容易找到并报告错误和错误。此外，监控相当容易。
虽然气流使用 DAGs，但它不是动态的，而只是静态的。
|
| |
它利用了两个概念流和任务。提督使用定义为使用 Python 的流对象的 Dag。在 Prefect 中，可以使用 Python 创建流对象，这提供了定义复杂管道的灵活性和健壮性。
任务就像 Argo 中的模板，用于定义需要执行的特定功能。同样，它使用 Python 来实现这一点。
因为 Prefect 使用 Python 作为它的主要编程语言，所以很容易使用。
|
概念概述
现在，我们来详细了解一下这些概念。
南船星座
Argo 使用两个核心概念:
- 工作流程
- 模板
工作流程
在 Argo 中，工作流恰好是整个系统最完整的组成部分。它有两个重要的功能:
- 它定义了需要执行的任务。
- 它存储任务的状态，这意味着它既是静态对象又是动态对象。
工作流是在 workflow.spec 配置文件中定义的。这是一个 YAML 文件，由一列模板和入口点组成。工作流可以被视为一个托管不同模板的文件。这些模板定义了需要执行的功能。
如前所述，Argo 利用 Kubernetes 引擎进行工作流同步，配置文件使用与 Kubernetes 相同的语法。工作流 YAML 文件包含以下字典或对象:
- apiVersion:这是定义文档或 API 名称的地方。
- kind:它定义了需要创建的 Kubernetes 对象的类型。例如，如果你想部署一个应用程序，你可以使用 Deployment 作为其中之一，其他时候你可以使用 service。但是在这种情况下，我们将使用工作流。
- 元数据:它使我们能够为该对象定义唯一的属性，可以是名称、UUID 等等。
- 规范:它使我们能够定义关于工作流的规范。这些规范将是入口点和模板。
- 模板:这是我们可以定义任务的地方。该模板可以包含 docker 图像和各种其他脚本。
模板
在 Argo 中，有两种类型的模板，它们又被细分为 6 种类型。两种主要类型是定义和调用方。
定义
顾名思义，这个模板定义了 Docker 容器中的任务类型。定义本身分为四类:
- 容器:用户可以在容器中安排工作流。由于应用程序在 Kubernetes 中是容器化的，所以 YAML 文件中定义的步骤是相同的。它也是最常用的模板之一。
- name: whalesay
container:
image: docker/whalesay
command: [cowsay]
args: ["hello world"]
- 脚本:如果你想要一个容器包装器，那么脚本模板是完美的。脚本模板在结构上类似于容器模板，但添加了一个源字段。该字段允许您就地定义脚本。您可以根据自己的需求定义任何变量或命令。一旦定义，脚本将被保存到一个文件中，它将作为一个 Argo 变量为您执行。
- name: gen-random-int
script:
image: python:alpine3.6
command: [python]
source: import random
i = random.randint(1, 100)
print(i)
- 资源:可以直接在 K8 集群上进行获取、创建、应用、删除等操作。
- name: k8s-owner-reference
resource:
action: create
manifest: |
apiVersion: v1
kind: ConfigMap
metadata:
generateName: owned-eg-
data:
some: value
- 暂停:基本上是给工作流引入一个时间维度。它可以在定义的持续时间内暂停工作流的执行，或者手动恢复工作流。
- name: delay
suspend:
duration: "20s"
创新者
一旦定义了模板，它们就可以被调用，或者被称为调用程序的其他模板按需调用。这些调用程序更多的是控制器模板，可以控制已定义模板的执行。
有两种类型的发票模板:
- 步骤:基本上可以让你分步骤定义任务。所有 YAML 文件都启用了“步骤”模板。
- 有向无环图(Directed acyclic graph):Argo 使其用户能够管理其工作流程中具有多种依赖关系的步骤。这允许在各自的容器中并行执行不同的工作流。使用有向非循环图或 DAG 来管理这些类型的工作流。例如，如果您正在处理用于医疗目的的图像分割和生成，那么您可以创建一个管道:
- 处理图像。
- 将图像(或数据集)分发到相应的 DL 模型，用于图像分割和生成管道。
- 持续预测分割掩模，并在适当检查后用新图像更新数据集存储。
气流
阿帕奇气流由四个主要部分组成:
- 网络服务器
- 调度程序
- 执行者
- 数据库ˌ资料库
Four main components of Apache Airflow | Source
网络服务器
它为用户提供了检查、触发和调试所有 Dag 和任务的 UI。它实际上是气流的入口。web 服务器利用 Python-Flask 来管理用户发出的所有请求。它还呈现数据库中的状态元数据，并将其显示给 UI。
调度程序
它监控和管理所有任务和 Dag。它通过查询数据库来检查任务的状态，以决定需要执行的任务的顺序。调度器的目标是解决依赖关系，一旦依赖关系得到处理，就将任务实例提交给执行器。
执行者
它运行准备运行的任务实例。它执行调度程序调度的所有任务。遗嘱执行人有四种类型:
- 顺序执行者
- 本地执行者
- 芹菜执行者
- Kubernetes Executor
元数据数据库
它存储任务和 Dag 的状态，调度程序可以使用这些状态来正确调度任务实例。值得注意的是，Airflow 使用 SQLAlchemy 和对象关系映射(ORM)来存储信息。
长官
提督使用两个核心概念:
- 流
- 任务
流
在 Prefect 中，流是可以交互的 Python 对象。这里 DAG 被定义为流对象。见下图。
DAG defined as flow objects | Source
对于任何给定的函数，Flow 可以被导入并用作装饰器@flow。流采用现有的函数，并将其转换为完美的流函数，具有以下优点:
- 该功能可以被监控和管理，因为它现在被报告给 API。
- 可以在 UI 中跟踪和显示功能的活动。
- 可以验证函数的输入。
- 诸如重试、分布式执行等各种工作流特征可以被添加到该功能中。
- 可以强制超时，以防止无意中长时间运行的工作流
下面是一个代码块，描述了一个流对象的实现。
from prefect import flow
@flow(name="GitHub Stars")
def github_stars(repos: List[str]):
for repo in repos:
get_stars(repo)
在上面的代码中，函数被转换成一个流，命名为“GitHub Stars”。这个功能现在在完美的编排法则的约束之内。
现在必须注意，所有工作流都必须在流函数中定义。同样，所有任务都必须在流(函数)中调用。请记住，当一个流被执行时，它被称为流运行。
任务
任务可以定义为需要执行的特定工作，例如，两个数的相加。换句话说，任务接受输入，执行操作并产生输出。像 flow 一样，任务可以被导入，并可以作为一个函数的装饰器@task 使用。一旦用于某个功能，它本质上将该功能包装在完美的工作流中，并且具有与流程相似的优点。例如，它可以自动记录关于任务运行的信息，比如运行时间、标签和最终状态。
下面的代码演示了如何定义任务:
@task(retries=3)
def get_stars(repo: str):
url = f"https://api.github.com/repos/{repo}"
count = httpx.get(url).json()["stargazers_count"]
print(f"{repo} has {count} stars!")
github_stars(["PrefectHQ/Prefect"])
总而言之，流程寻找任何在其主体中定义的任务，一旦找到，它就以相同的顺序创建一个计算图。然后，每当一个任务实例的输出被另一个任务实例用来产生输出时，它就在任务之间创建依赖关系。
特征
这三者都提供了或多或少相同的功能，但有些功能比其他功能更好，这也归结于用户的适应性。就像上一节一样，我们先来总结一下这些特性。
| 南船星座 | 气流 | 长官 | |
|---|---|---|---|
它拥有完整的工作流视图。您可以直接从 UI 定义工作流。
| 工作流维护得非常好，因为它提供了许多不同的视图。 |
提督类似于气流。
|
| |
仅支持 Kubernetes 支持的环境，如 AWS 和其他 S3 兼容的服务。
|
支持 Kubernetes 支持的环境以及其他第三方环境。
| |
| | | | |
| | | | |
| | | | |
特征比较
让我们从探索用户界面开始这一部分。
用户界面
南船星座
为了便于使用，Argo Workflow 提供了一个基于 web 的用户界面来定义工作流和模板。用户界面支持多种用途，例如:
- 人工制品可视化
- 使用生成的图表来比较机器学习管道
- 可视化结果
- 排除故障
- 它还可以用于定义工作流
气流
Airflow UI 提供了一个简洁高效的设计，使用户能够与 Airflow 服务器进行交互，允许他们监控和对整个管道进行故障排除。它还允许编辑数据库中任务的状态，并操纵 Dag 和任务的行为。
Airflow UI 还为其用户提供了各种视图，包括:
DAGs 视图
- 数据集视图
- 网格视图
- 图表视图
- 日历视图
- 可变视图
- 甘特图视图
- 任务持续时间
- Code View
- Prefect
Prefect like Airflow 提供了所有任务的概述，这有助于您可视化所有工作流、任务和 Dag。它提供了两种访问用户界面的方法:
完美云:它托管在云上，使您能够配置您的个人帐户和工作区。
- 提督猎户座 UI :本地托管，也是开源的。您不能像使用 Prefect cloud 那样配置它。
- perfect ui 的一些附加功能:
显示运行摘要
- 显示已部署的流详细信息
- 预定流量
- 延迟和失败运行的警告通知
- 任务和工作流的详细信息
- 任务相关性可视化和雷达流程
- 日志详细信息
- 部署风格
南船星座
它是一个本地 Kubernetes 工作流引擎，这意味着:
It is a native Kubernetes workflow engine which means it:
1 在容器上运行。
- 2 在 Kubernetes 支持的吊舱上运行。
- 3 易于部署和扩展。
- 缺点是:
实现是困难的，因为它使用配置语言(YAML)。
- 气流
1 支持 Kubernetes 以及其他第三方集成。
它也可以在容器上运行。
- 3 实现起来很容易。
- 气流的缺点是:
- 它不是并行可伸缩的。
部署需要额外的努力，这取决于您选择的云设施。
- 长官
- 最后，提督是阿尔戈和气流的结合体:
Prefect
它可以在容器和 Kubernetes 豆荚上运行。
2 它是高度并行和高效的。
- 支持容错调度。
- 4 易于部署。
- 它还支持第三方集成。
- 说到坏处:
- 它不支持 Kubernetes 的开源部署。
部署困难。
- 可量测性
- 当谈到可伸缩性时，Argo 和 Prefect 是高度并行的，这使它们高效且特别完美，因为它可以利用不同的第三方集成支持，使其成为三者中最好的。
另一方面，气流是水平可扩展的，即活动工作者的数量等于最大任务并行度。
易接近
这三个都是开源的，但是 Prefect 还附带了一个基于订阅的服务。
灵活性
与 Prefect 相比，Argo 和 Airflow 并不灵活，因为前者是 Kubernetes-native，它被限制在该环境中，使其变得僵化，而后者很复杂，因为它需要定义良好和结构化的模板，使其本身不太适合敏捷环境。
另一方面，Prefect 使您能够用原生 Python 创建动态数据流，这不需要您使用 DAG。所有 Python 函数都可以转换成完美的流程和任务。这确保了灵活性。
到目前为止，我已经比较了这些工具拥有的基本概念和特性。现在让我给出为什么你可以在你的项目中使用这些工具的理由。
南船星座
以下是您应该使用 Argo 的一些原因:
Argo
Kubernetes 本地工作流工具使您能够在它自己的 Kubernetes pod 中运行每个步骤。
2 易于扩展，因为它可以并行执行。
- 工作流模板提供了可重用性。
- 类似地，工件集成也是可重用的。
- 对于工作流的每次运行，DAG 都是动态的。
- 6 低延迟调度器。
- 事件驱动的工作流。
- 气流
- 您使用气流的原因:
Airflow
它使用户能够连接各种技术。
它提供了丰富的调度和易于定义的管道。
- 3python 集成是使用气流的另一个原因。
- 您可以根据自己的需求创建定制组件。
- 5 存储工作流程时，允许回滚到先前版本。
- 6 有一个定义良好的 UI。
- 多个用户可以为一个给定的项目编写一个工作流，即它是可共享的。
- 长官
- Prefect 是 MLops 精心设计的编排工具之一。它是 Python 原生的，需要你在工程方面下功夫。Prefect 的一个亮点是数据处理和管道。它可以用于获取数据、应用必要的转换，以及监控和编排必要的任务。
当涉及到与机器学习相关的任务时，它可以用于自动化整个数据流。
使用提督的其他一些原因是:
When it comes to tasks related to machine learning, it can be used to automate the entire data flow.
1 提供卓越的安全性，因为它可以保护您的数据和代码的隐私。
2 增强的用户界面和通知功能，可直接发送到您的电子邮件或 Slack。
- 3 可搭配 Kubernetes 和 Docker 使用。
- 4 任务的高效并行处理。
- 5 动态工作流。
- 6 允许许多第三方集成。
- 7 Prefect 使用 GraphQL API，使其能够按需触发工作流。
- 如何决定？
- 为您的项目选择合适的工具取决于您想要的和您已经拥有的。但是我肯定可以提出一些标准来帮助您决定哪种工具适合您。您可以使用–
南船星座
如果你想建立一个基于 Kubernetes 的工作流。
如果您想将工作流定义为 Dag。
- 如果数据集很大，并且模型训练需要高度并行和分布式的训练。
- 如果你的任务很复杂。
- 如果你精通 YAML 档案。即使你不是，学习 YAML 也不难。
- 如果你想使用像 GCD 或 AWS 这样的云平台，这是 Kubernetes 启用的。
- 气流
- 如果您想整合许多其他第三方技术，如 Jenkins、Airbyte、Amazon、Cassandra、Docker 等。检查受支持的第三方扩展列表。
如果你想用 Python 来定义工作流。
- 如果您想将工作流定义为 Dag。
- 如果你的工作流程是静态的。
- 如果你想要一个成熟的工具，因为气流是相当古老的。
- 如果您想按计划运行任务。
- 长官
- 如果您想整合许多其他第三方技术。
如果你想用 Python 来定义工作流。
- 如果你的工作流程是动态的。
- 如果您想按计划运行任务。
- 如果你想要轻松现代的东西。
- 我在 Reddit 上发现了一个关于使用气流和提督的帖子。也许这可以为您提供一些关于使用哪种工具的附加信息。
- “Airflow 的优势在于它是一个成熟且受欢迎的项目。这意味着找到一个随机写博客回答你的问题的人要容易得多。另一个好处是，雇佣有气流经验的人比雇佣有完美经验的人要容易得多。缺点是，Airflow 的时代正在显现，因为它并不是真正为现代数据环境中存在的那种动态工作流而设计的。如果你的公司要在计算或复杂性方面突破极限，我强烈建议你考虑一下 Prefect。此外，除非你通过天文学家网站，否则如果你找不到关于气流的问题的答案，你必须通过他们相当不活跃的聊天。
Prefect 的优点是，它对你在做什么和它需要做什么的假设更加现代。它有一个扩展的 API，允许你以编程的方式控制执行或者与调度程序交互，我相信 Airflow 只是最近才在他们的 2.0 版本中实现了测试版。在此之前，建议不要在生产环境中使用 API，这通常会导致黑客式的解决方法。此外，通过确定在运行时执行的 DAG，然后将计算/优化交给其他系统(即 Dask)来实际执行任务，Prefect 允许更动态的执行模型及其一些概念。我相信这是一个更聪明的方法，因为我已经看到工作流这些年来变得越来越动态。
如果我的公司既没有 Airflow 也没有 Prefect，我会选择 Prefect。我相信它允许更好的代码模块化(然后可以更积极/彻底地测试)，我已经认为这对于数据驱动的公司来说是值得的，这些公司依靠精心策划的数据来做出自动化的产品决策。你可以用气流实现类似的东西，但是你真的需要用你自己的方式来实现这样的事情，而在 Prefect 中，它是自然产生的。"
这里有一个有用的图表，展示了基于 GitHub stars 的不同编排工具的流行程度。
结论
在本文中，我们讨论并比较了三种流行的任务编排工具，即 Argo、Airflow 和 Prefect。我的主要目的是在三个重要因素的基础上帮助您理解这些工具，即核心概念、提供的功能以及您为什么应该使用它们。本文还对这三种工具提供的一些重要特性进行了比较，这可以帮助您决定为您的项目选择最合适的工具。
我希望这篇文章内容丰富，能让您更好地理解这些工具。
The popularity of different orchestration tools based on GitHub stars | Source
谢谢！！！
参考
https://github.com/argoproj/argo-workflows
https://codefresh.io/learn/argo-workflows/
- https://hazelcast.com/glossary/directed-acyclic-graph/
- https://towards data science . com/mlops-with-a-feature-store-816 CFA 5966 e 9
- https://medium . com/Arthur-engineering/picking-a-kubernetes-orchestrator-air flow-Argo-and-prefect-83539 ECC 69 b
- https://Argo proj . github . io/Argo-workflows/artifact-visualization/# artifact-types
- https://air flow . Apache . org/docs/Apache-air flow/stable/concepts/overview . html
- https://spell . ml/blog/orchestrating-spell-model-pipelines-using-prefect-YU3rsBEAACEAmRxp
- https://github.com/PrefectHQ/prefect
- https://www . data revenue . com/en-blog/air flow-vs-Luigi-vs-Argo-vs-ml flow-vs-kube flow
- https://hevodata.com/learn/argo-vs-airflow/#w6
- https://www . data revenue . com/en-blog/what-we-loving-about-perfect
- https://github.com/PrefectHQ/prefect
- https://docs.prefect.io/
- https://medium . com/the-prefect-blog/introducing-the-artifacts-API-B9 e 5972 db 043
- https://medium . com/the-prefect-blog/orchestrate-your-data-science-project-with-prefect-2-0-4118418 FD 7 ce
- https://www . Reddit . com/r/data engineering/comments/oqbiiu/air flow _ vs _ prefect/
- https://medium.com/the-prefect-blog/introducing-the-artifacts-api-b9e5972db043
- https://medium.com/the-prefect-blog/orchestrate-your-data-science-project-with-prefect-2-0-4118418fd7ce
- https://www.reddit.com/r/dataengineering/comments/oqbiiu/airflow_vs_prefect/
ARIMA 和萨里玛:现实世界的时间序列预测
时间序列和预测一直是统计学和数据科学中的一些关键问题。当按照具有时间限制的属性(如天数、月数和年数)对数据进行采样时，数据就变成了一个时间序列，这给了它一个隐含的顺序。预测就是我们获取数据并预测未来值。
ARIMA 和萨里玛都是预测的算法。 ARIMA 考虑过去的值(自回归，移动平均)并基于此预测未来值。 SARIMA 同样使用过去的值，但也考虑了任何季节性模式。由于萨里玛引入了季节性作为参数，它在预测包含周期的复杂数据空间方面明显比 ARIMA 更强大。
在博客的后面，我们将探索:
- ARIMA
- 它是什么以及它如何预测
- 用 ARIMA 预测美国 GDP 的例子
- 萨里玛
- 它是什么以及它如何预测
- 预测用电量的示例
- 两种模式的优缺点
- ARIMA 和萨里玛的真实使用案例
在我们进入算法之前，有一个关于数据处理的重要部分，在开始预测之旅之前，你应该警惕。
时间序列预测的数据预处理
时间序列数据很乱。从简单的滚动平均到 LSTMs 的预测模型要求数据是干净的。因此，在进行预测之前，这里有一些你可以使用的技巧。
注意:这个数据预处理步骤是通用的，旨在让读者强调它，因为现实世界的项目涉及许多清理和准备工作。
- 去趋势性/平稳性:在预测之前，我们希望我们的时间序列变量是均值-方差平稳的。这意味着一个模型的统计特性不会因为取样时间的不同而改变。建立在静态数据上的模型通常更稳健。这可以通过使用差分来实现。
- 异常检测:数据中出现的任何异常值都可能扭曲预测结果，因此在继续预测之前识别异常值并使其正常化通常被认为是一种良好的做法。你可以在这里关注这个博客，在这里我详细解释了异常检测算法。
- 检查采样频率:这是检查采样规律性的重要步骤。在应用任何建模技术之前，必须对不规则数据进行估算或使其一致，因为不规则采样会破坏时间序列的完整性，并且与模型不匹配。
- 缺失数据:有时，某些日期时间值可能会有缺失数据，这需要在建模之前解决。例如，缺少值的时间序列数据如下所示:
Missing data in time series | Source
现在，让我们继续讨论模型。
ARIMA
ARIMA 模型是一类利用历史值预测未来值的线性模型。ARIMA 代表自回归综合移动平均，每种技术都有助于最终预测。我们一个一个来了解吧。
自回归(AR)
在自回归模型中，我们使用该变量过去值的线性组合来预测感兴趣的变量。术语“自回归”表示它是变量对自身的回归。也就是说，我们使用目标变量的滞后值作为输入变量来预测未来的值。p 阶的自回归模型将看起来像:
m[t]=[0]+[1]m[t-1]+[2]m[t-2]+[3]m[t-3]+…+[p]m[t-p]
在上式中， m 的当前观测值是其过去 p 值的线性函数。[ 0，p]是训练后确定的回归系数。确定 p 的最优值有一些标准方法，其中之一是分析自相关和偏自相关函数图。
自相关函数(ACF)是同一变量的当前值和过去值之间的相关性。除了直接影响之外，它还考虑了价值随时间推移而产生的翻译效应。例如，两天前的石油价格会影响一天前的价格，并最终影响今天的价格。但是 2 天前的石油价格也可能对 ACF 测量的今天有影响。
另一方面，部分自相关(PACF)仅测量过去值和当前值之间的直接相关性。例如，PACF 将只测量两天前的石油价格对今天的影响，而没有平移效应。
ACF 和 PACF 图帮助我们确定过去值的相关性，进而帮助我们推断 AR 中的 p 。浏览这里的，深入了解如何推导 p (AR)和 q(MA)的值。
综合(一)
Integrated 表示为了使数据稳定而必须应用的任何差异。可以对数据运行 dickey-fuller 测试(代码如下)来检查稳定性，然后用不同的差异因子进行实验。差异因子 d=1 表示滞后，即 mt-mt-1。让我们看一下原始数据与差异数据的对比图。
Original Data | Source: Author
After applying d=1 | Source: Author
他们之间的区别是显而易见的。差分后，我们可以看到它明显比原始数据更稳定，并且多年来平均值和方差大致一致。我们可以使用下面的代码进行 dickey-fuller 测试。
def check_stationarity(ts):
dftest = adfuller(ts)
adf = dftest[0]
pvalue = dftest[1]
critical_value = dftest[4]['5%']
if (pvalue < 0.05) and (adf < critical_value):
print('The series is stationary')
else:
print('The series is NOT stationary')
移动平均线
移动平均模型在类似回归的模型中使用过去的预测误差而不是过去的值来预测未来值。移动平均模型可由以下等式表示:
m[t]=[0]+[1]e[t-1]+[2]e[t-2]+[3]e[t-3]+…+[q]e[t-q]
这就是所谓的 MA(q) 模型。在上式中， e 被称为误差，它代表模型和目标变量之间的随机剩余偏差。因为 e 只能在拟合模型后确定，并且因为它也是一个参数，所以在这种情况下 e 是一个不可观察的参数。因此，为了求解 MA 方程，使用像最大似然估计这样的迭代技术来代替 OLS。
既然我们已经了解了 ARIMA 是如何工作的，让我们深入一个例子，看看 ARIMA 是如何应用于时间序列数据的。
实施 ARIMA
对于实现，我选择了从 1996 年到 2008 年的鲶鱼销售数据。我们将把上面学到的技术应用到这个数据集，并观察它们的实际应用。尽管数据不需要大量清理，并且处于待分析的读取状态，但您可能必须对数据集应用清理技术。
不幸的是，我们不能复制每一个场景，因为清洁方法是高度主观的，也取决于团队的要求。但是这里学到的技术可以在清理后直接应用到您的数据集。
先说导入必备模块。
导入依赖关系
from IPython.display import display
import numpy as np
import pandas as pd
pd.set_option('display.max_rows', 15)
pd.set_option('display.max_columns', 500)
pd.set_option('display.width', 1000)
import matplotlib.pyplot as plt
from datetime import datetime
from datetime import timedelta
from pandas.plotting import register_matplotlib_converters
register_matplotlib_converters()
from statsmodels.tsa.seasonal import seasonal_decompose
from statsmodels.tsa.arima_model import ARIMA
from statsmodels.tsa.statespace.sarimax import SARIMAX
from statsmodels.tsa.stattools import adfuller
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
from time import time
import seaborn as sns
sns.set(style="whitegrid")
import warnings
warnings.filterwarnings('ignore')
RANDOM_SEED = np.random.seed(0)
这些是每个数据科学家都熟悉的不言自明的模块。设置 RANDOM_SEED 以使代码具有相同的结果是一个很好的做法。
接下来，我们将导入并绘制时间序列数据
提取-转换-加载(ETL)
def parser(s):
return datetime.strptime(s, '%Y-%m-%d')
catfish_sales = pd.read_csv('catfish.csv', parse_dates=[0], index_col=0, date_parser=parser)
catfish_sales = catfish_sales.asfreq(pd.infer_freq(catfish_sales.index))
start_date = datetime(1996,1,1)
end_date = datetime(2008,1,1)
lim_catfish_sales = catfish_sales[start_date:end_date]
plt.figure(figsize=(14,4))
plt.plot(lim_catfish_sales)
plt.title('Catfish Sales in 1000s of Pounds', fontsize=20)
plt.ylabel('Sales', fontsize=16)
为了简单起见，我将数据限制在 1996-2008 年。上述代码生成的图如下所示:
Catfish sales | Source: Author
第一印象是数据中存在明确的趋势和季节性。让我们做一个 STL 分解，以便更好地理解。
STL 分解
plt.rc('figure',figsize=(14,8))
plt.rc('font',size=15)
result = seasonal_decompose(lim_catfish_sales,model='additive')
fig = result.plot()
结果图如下所示:
思考要点:
- 可以看到 6 个月和 12 个月的季节性模式
- 上升和下降的趋势很明显
让我们看看 ACF 和 PACF 图，了解一下 p 和 q 值
ACF 和 PACF 图
plot_acf(lim_catfish_sales['Total'], lags=48);
plot_pacf(lim_catfish_sales['Total'], lags=30);
上述代码的输出绘制了 ACF 和 PACF:
Autocorrelation plot for Catfish data
Partial autocorrelation plot for Catfish data
思考要点:
- ACF 在 6 个月和 12 个月时有一个显著的峰值
- PACF 几乎是正弦曲线
差分因子 d 应保持为 1，因为有明确的趋势和非平稳数据。p 可以用值 6 和 12 来测试。
安装 ARIMA
我们将使用 statsmodels 模块来实现和使用 ARIMA。为此，我们从 statsmodels 中导入了 ARIMA 类。现在，让我们用上一节中讨论的参数来拟合。
arima = ARIMA(lim_catfish_sales['Total'], order=(12,1,1))
predictions = arima.fit().predict()
正如你在上面注意到的，我从(p，d，q)的(12，1，1)开始，就像我们在 ACF 和 PACF 图中看到的那样。
注意:使用算法模块(如 scikit-learn)非常方便，您会很高兴知道 statsmodels 是经常使用的库之一。
让我们看看我们的预测如何与原始数据相比较。
可视化结果
plt.figure(figsize=(16,4))
plt.plot(lim_catfish_sales.diff(), label="Actual")
plt.plot(predictions, label="Predicted")
plt.title('Catfish Sales in 1000s of Pounds', fontsize=20)
plt.ylabel('Sales', fontsize=16)
plt.legend()
上述代码的输出将为您提供预测和实际数据的对比图。
A comparative plot of predictions and the actual data
您可以在这里看到，该模型没有真正赶上某些峰值，但很好地捕捉到了数据的本质。我们可以用更多的 p，d，q 值进行实验，以更好地概括模型，并确保它不会过度拟合。
尝试和优化是一种方法，但你也可以使用自动 ARIMA。它本质上为您完成了繁重的工作，并为您调整了超参数。这个博客是汽车 ARIMA 的一个很好的起点。
请记住，参数的可解释性将是您在处理自动 ARIMA 时必须处理的事情，并确保它不会被转换为黑盒，因为预测模型必须在部署之前进行治理。因此，能够解释参数值及其贡献是一种很好的做法。
萨里玛
萨里玛代表季节性 ARIMA，它包括季节性对预测的贡献。季节性的重要性是显而易见的，而 ARIMA 未能含蓄地概括这一信息。
模型的自回归(AR)、综合(I)和移动平均(MA)部分与 ARIMA 模型相同。季节性的加入增加了 SARIMA 模型的稳健性。它表示为:
其中 m 是每年的观察次数。我们用大写符号表示模型的季节性部分，用小写符号表示模型的非季节性部分。
与 ARIMA 相似，模型季节性部分的 P、D、Q 值可以从数据的 ACF 和 PACF 图中推导出来。让我们为相同的鲶鱼销售模型实现 SARIMA。
实施 SARIMA
ETL 和依赖项将保持与 ARIMA 相同，因此我们将直接跳到建模部分。
安装 SARIMA
sarima = SARIMAX(lim_catfish_sales['Total'],
order=(1,1,1),
seasonal_order=(1,1,0,12))
predictions = sarima.fit().predict()
我尝试对非季节性部分取 1，1，1，对季节性部分取 1，1，0，12，因为 ACF 显示了 6 个月和 12 个月的滞后相关性。让我们看看结果如何。
可视化结果
plt.figure(figsize=(16,4))
plt.plot(lim_catfish_sales, label="Actual")
plt.plot(predictions, label="Predicted")
plt.title('Catfish Sales in 1000s of Pounds', fontsize=20)
plt.ylabel('Sales', fontsize=16)
plt.legend()
A comparative plot of predictions and the actual data
正如你所看到的，在开始模型，努力适应可能是因为偏离路线初始化，但它很快学会了正确的路径。与 ARIMA 相比，拟合度相当好，这表明萨里玛可以更好地了解季节性，如果它出现在数据中，那么尝试萨里玛是有意义的。
ARIMA 和萨里玛模式的利与弊
由于这两种算法的线性性质，它们非常方便，并在行业中用于实验和理解数据，创建基线预测分数。如果用滞后值(p，d，q)调整正确，他们可以表现得更好。这两种算法的简单和可解释的本质使它们成为分析师和数据科学家的首选。然而，与 ARIMA 和萨里玛大规模合作有利也有弊。让我们来讨论这两个问题:
ARIMA 和萨里玛的优点
- 易于理解和解释:你的队友和同事会欣赏的一件事是模型的简单性和可解释性。在保持结果质量的同时关注这两点将有助于与利益相关者进行演示。
- 有限变量:超参数较少，因此如果模型投入生产，配置文件将易于维护。
ARIMA 和萨里玛的缺点
- 指数时间复杂度:当 p 和 q 的值增加时，有同样多的系数要拟合，因此如果 p 和 q 高，时间复杂度增加。这使得这两种算法很难投入生产，并使数据科学家研究 Prophet 和其他算法。同样，这也取决于数据集的复杂程度。
- 复杂数据:您的数据可能过于复杂，没有 p 和 q 的最优解。尽管 ARIMA 和萨里玛失败的可能性极小，但如果发生这种情况，您可能不得不另寻他处。
- 所需数据量:这两种算法都需要大量的数据来处理，尤其是在数据是季节性的情况下。例如，使用三年的历史需求可能不足以做出好的预测(短生命周期产品)。
ARIMA 和萨里玛的真实使用案例
SARIMA 萨里玛是最流行的计量经济学模型，用于预测股票价格、需求预测，甚至传染病的传播。当潜在机制未知或过于复杂时，例如股票市场，或不完全已知时，例如零售，通常最好应用 ARIMA 或类似的统计模型，而不是像 RNNs 这样复杂的深度算法。
然而，在某些情况下，应用 ARIMA 可以得到相同的结果。
以下是一些使用 SARIMA 萨里玛的策划文件:
- ARIMA 模型在预测印度新冠肺炎疫情动态中的应用:这篇研究论文利用 ARIMA 预测了印度的新冠肺炎病例数。在这种情况下，利用 ARIMA 的缺点是，它只利用过去的值来预测未来。但是新冠肺炎会随着时间的推移而改变形状，它取决于除了过去的价值观之外的许多其他行为因素，这是 ARIMA 无法捕捉到的。
- 预测日平均和月平均全球太阳辐射的时间序列 ARIMA 模型:韩国首尔的案例研究:这是一项基于韩国气象局 37 年来使用 s ARIMA 获得的每小时太阳辐射数据预测韩国太阳辐射的研究。
- 时间序列中 ARIMA 模型的疾病管理:利用 SARIMA 萨里玛模型的广泛适用性，在疾病管理中使用 ARIMA 的另一个例子。研究论文触及了 ARIMA 的一些真实使用案例。例如，新加坡的一家医院准确预测了 SARS 流行期间 3 天内他们需要的病床数量。
- 使用 ARIMA 模型预测需求:这个用例主要使用 ARIMA 对一家食品公司的需求进行建模和预测。
说到这个行业，这里有一篇关于优步预测的好文章。
当问题陈述仅限于过去的值时，无论是预测医院床位、COVID 病例还是预测需求，您都会经常发现使用 SARIMA 萨里玛。然而，当在预测中有其他因素要考虑时，例如静态属性，缺点就出现了。留意你正在处理的问题陈述，如果这些情况发生在你身上，那么尝试使用其他方法，如 Theta ，QRF(分位数回归森林)，Prophet，RNNs。
结论和最后说明
你已经到达终点了！在这篇博客中，我们详细讨论了 ARIMA 和萨里玛，以及他们在行业研究中的应用和重要性。它们的简单性和健壮性使它们成为建模和预测的顶级竞争者。然而，在现实世界的用例中处理它们时，有一些事情需要记住:
- 增加 p，q 可以成倍增加训练的时间复杂度。因此，建议先推导出它们的值，然后进行实验。
- 他们容易过度适应。因此，请确保您设置了正确的超参数，并在进入生产之前进行验证。
我这边就这样。请继续学习，并关注更多内容！再见！
参考
- https://Neptune . ai/blog/time-series-prediction-vs-machine-learning
- https://otexts.com/fpp2/arima.html
- https://towards data science . com/understanding-ARIMA-time-series-modeling-d 99 CD 11 be 3 f 8
- https://towards data science . com/understanding-sa Rima-955 Fe 217 BC 77
- https://neptune.ai/blog/anomaly-detection-in-time-series
- https://www . stats models . org/dev/generated/stats models . TSA . statespace . sarimax . sarimax . html
- https://otexts.com/fpp2/seasonal-arima.html
- https://towards data science . com/time-series-forecasting-using-auto-ARIMA-in-python-bb83e 49210 CD
- https://towards data science . com/time-series-from scratch-自相关-和-部分自相关-解释-1dd641e3076f
- https://eng.uber.com/forecasting-introduction/
- https://www . capital one . com/tech/machine-learning/understanding-ARIMA-models/
- https://medium . com/analytics-vid hya/why-you-should-not-use-ARIMA-to-forecast-demand-196 cc 8 b 8d f3d
ARIMA vs 预言家 vs LSTM 进行时间序列预测
原文：https://web.archive.org/web/https://neptune.ai/blog/arima-vs-prophet-vs-lstm
假设我们同意对时间和因果关系的线性理解，正如 Sheldon Cooper 博士所说，那么将历史事件表示为随着时间的推移观察到的一系列值和特征，为从过去学习提供了基础。然而，时间序列与其他数据集有些不同，包括像文本或 DNA 序列这样的序列数据。
时间组件提供了预测未来时有用的附加信息。因此，有许多专门为处理时间序列而设计的不同技术。这些技术从简单的可视化工具(显示趋势随时间演变或重复)到先进的机器学习模型(利用时间序列的特定结构)不等。
在本帖中，我们将讨论从时间序列数据中学习的三种流行方法:
- 用于时间序列预测的经典 ARIMA 框架
- 2 脸书的内部模型 Prophet，它是专门为从商业时间序列中学习而设计的
- 3LSTM 模型，这是一种强大的递归神经网络方法，已被用于在序列数据的许多问题上取得最著名的结果
然后，我们将展示如何使用 Neptune 及其强大的功能来比较三个模型的结果。
我们先来简单概述一下这三种方法。
概述三种方法:ARIMA，先知和 LSTM
ARIMA
ARIMA 是一类时间序列预测模型，名字是自回归综合移动平均的缩写。ARIMA 的主干是一个数学模型，它使用时间序列的过去值来表示时间序列的值。该模型基于两个主要特征:
- 过去的值:很明显，过去的行为可以很好地预测未来。唯一的问题是我们应该使用多少过去的值。该模型使用最后 p 个时间序列值作为特征。这里 p 是我们设计模型时需要确定的超参数。
- 过去的错误:模型可以使用关于它在过去表现如何的信息。因此，我们将模型产生的最近的 q 错误添加为特征。同样，q 是一个超参数。
这里的一个重要方面是，时间序列需要标准化，以便模型独立于季节或临时趋势。对此的正式术语是，我们希望模型在一个平稳的时间序列上进行训练。从最直观的意义上来说，平稳性意味着生成时间序列的过程的统计特性不会随时间而改变。这并不意味着序列不会随着时间的推移而改变，只是它改变的方式本身不会随着时间的推移而改变。
有几种方法可以使时间序列平稳，最常用的是差分法。通过用 n-1 个差异替换系列中的 n 个值，我们迫使模型学习更高级的模式。当模型预测一个新值时，我们只需将最后一次观察到的值加进去，就可以得到最终的预测值。平稳性如果第一次遇到这个概念会有些混乱，可以参考这个教程了解更多细节。
因素
形式上，ARIMA 由描述模型三个主要组成部分的三个参数 p、d 和 q 定义。
- 综合****(ARIMA 的 I):达到平稳性所需的差数由参数 d 给出，设原特征为 Y [t] 其中 t 为序列中的索引。对于不同的 d 值，我们使用以下变换来创建一个平稳的时间序列。
对于 d=0
在这种情况下，级数已经是静止的，我们无事可做。
对于 d=1
这是最典型的转型。
对于 d=2
请注意，差分可以被视为微分的离散版本。对于 d=1，新特征表示值如何变化。而对于 d=2，新特征表示变化率，就像微积分中的二阶导数一样。以上也可以推广到 d > 2，但这在实践中很少使用。
-
自回归(AR): 参数 p 告诉我们，对于当前值的表达式，要考虑多少个过去的值。本质上，我们学习一个预测时间 t 的值的模型:
-
移动平均线(MA): 要考虑过去的预测误差有多少。新值计算如下:
过去的预测误差:
这三个部分的组合给出了 ARIMA(p，d，q)模型。更准确地说，我们首先对时间序列进行积分，然后我们将 AR 和 MA 模型相加，并学习相应的系数。
先知
Prophet FB 是由脸书开发的一种算法，用于内部预测不同商业应用的时间序列值。因此，它是专门为预测商业时间序列而设计的。
这是一个附加模型，由四个部分组成:
让我们讨论一下每个组件的含义:
- g(t): 它代表趋势，目标是捕捉序列的总体趋势。例如，随着越来越多的人加入网络，脸书的广告浏览量可能会随着时间的推移而增加。但是增加的确切作用是什么呢？
- s(t): 是季节性成分。广告浏览的数量也可能取决于季节。例如，在北半球的夏季，人们可能会花更多的时间在户外，花更少的时间在电脑前。对于不同的商业时间序列，这种季节性波动可能非常不同。因此，第二个组成部分是一个模拟季节性趋势的函数。
- h(t):节假日成分。我们使用对大多数商业时间序列有明显影响的假期信息。请注意，不同的年份、不同的国家，假期是不同的。因此信息需要明确地提供给模型。
- 误差项 ε [t] 代表模型无法解释的随机波动。通常，假设ε [t] 遵循正态分布 N (0，σ ² )，均值为零，未知方差σ必须从数据中得出。
LSTM 递归神经网络
LSTM 代表长期短期记忆。LSTM 细胞用于递归神经网络，该网络学习从可变长度的序列预测未来。请注意，递归神经网络可以处理任何类型的序列数据，与 ARIMA 和预言家不同，它不限于时间序列。
LSTM 细胞背后的主要思想是学习到目前为止看到的序列中的重要部分，忘记不太重要的部分。这通过所谓的门来实现，即具有不同学习目标的函数，例如:
- 到目前为止看到的时间序列的紧凑表示
- 如何将新的输入与序列的过去表示相结合
- 忘记这个系列的什么
- 作为下一时间步的预测输出什么。
更多细节见图 1 和维基百科文章。
设计基于 LSTM 的最佳模型可能是一项艰巨的任务，需要仔细调整超参数。以下是基于 LSTM 的模型需要考虑的最重要参数列表:
- 用多少个 LSTM 单元来表示这个序列？请注意，每个 LSTM 单元将关注到目前为止处理的时间序列的特定方面。一些 LSTM 细胞不太可能捕获序列的结构，而太多的 LSTM 细胞可能导致过度拟合。
- 典型的是，首先，我们将输入序列转换成另一个序列，即值 h [t] 。这产生了一个新的表示，因为ht 状态捕获了到目前为止所处理的系列的结构。但是在某些时候，我们不需要所有的 htvalues，而是只需要最后一个 h [t] 。这将允许我们将不同的ht[t]馈入完全连接的层，因为每个ht[t]对应于单个 LSTM 单元的最终输出。设计精确的架构可能需要仔细的微调和多次试验。
Figure 1: the structure of an LSTM cell | Source
最后，我们想重申，递归神经网络是从序列数据中学习的一类通用方法，它们可以处理任意序列，如自然文本或音频。
实验评测:ARIMA vs 先知 vs LSTM
资料组
我们将使用 Bajaj Finserv Ltd(一家印度金融服务公司)的股票交易数据来比较这三种模型。该数据集的时间跨度从 2008 年到 2021 年底。它包含每日股票价格(平均值、低值和高值)以及交易股票的总量和周转率。数据集的子样本如图 2 所示。
Figure 2: the data used for evaluation | Source: Author
我们对预测每天结束时的成交量加权平均价格(VWAP)变量感兴趣。时间序列 VWAP 值的图表如图 3 所示。
Figure 3: the daily values of the VWAP variable | Source: Author
为了进行评估，我们将时间序列分为训练和测试时间序列，其中训练序列由截至 2018 年底的数据组成(见图 4)。
观察总数: 3201
训练观察: 2624
测试观察: 577
Figure 4: the train and test subsets of the VWAP time series | Source: Author
履行
为了正常工作，机器学习模型需要良好的数据，为此，我们将做一点点特征工程。特征工程背后的目标是设计更强大的模型，利用数据中的不同模式。由于这三个模型学习了过去观察到的模式，我们创建了额外的特征来彻底描述股票运动的最近趋势。
特别是，我们跟踪 3、7 和 30 天内不同交易特征的移动平均线。此外，我们还考虑了月、周数和工作日等特性。因此，我们模型的输入是多维的。所用特征工程的一个小例子如下:
lag_features = ["High", "Low", "Volume", "Turnover", "Trades"]
df_rolled_7d = df[lag_features].rolling(window=7, min_periods=0)
df_mean_7d = df_rolled_7d.mean().shift(1).reset_index().astype(np.float32)
上面的代码摘录显示了如何添加描述股票销售的几个特征在上周的移动平均值。总的来说，我们创建了一组外生特征:
现在，让我们从主要型号开始:
ARIMA
我们从公开可用的包 pmdarima 中实现了 ARIMA 版本。函数 auto_arima 接受一列外生特征作为附加参数，其中我们提供了在特征工程步骤中创建的特征。auto_arima 的主要优点是，它首先执行几个测试，以确定时间序列是否是平稳的。此外，它采用智能电网搜索策略来确定上一节中讨论的 p、d 和 q 的最佳参数。
from pmdarima import auto_arima
model = auto_arima(
df_train["VWAP"],
exogenous=df_train[exogenous_features],
trace=True,
error_action="ignore",
suppress_warnings=True)
参数 p、d 和 q 的不同值的网格搜索如下所示。最后，返回具有最小 AIC 值的模型。(AIC 值是同时优化预测模型的准确性和复杂性的模型复杂性的度量。)
然后通过以下方式获得对测试集的预测
forecast = model.predict(n_periods=len(df_valid), exogenous=df_valid[exogenous_features])
先知
我们使用 Prophet 的公开可用的 Python 实现。输入数据必须包含两个特定字段:
- 日期:应该是可以计算假期的有效日历日期
- Y :我们要预测的目标变量。
我们将模型实例化为:
from prophet import Prophet
model = Prophet()
必须将特征工程期间创建的特征明确添加到模型中，如下所示:
for feature in exogenous_features:
model.add_regressor(feature)
最后，我们拟合模型:
model.fit(df_train[["Date", "VWAP"] + exogenous_features].rename(columns={"Date": "ds", "VWAP": "y"}))
并且测试集的预测如下获得:
forecast = model.predict(df_test[["Date", "VWAP"] + exogenous_features].rename(columns={"Date": "ds"}))
LSTM
我们使用 LSTMs 的 Keras 实现:
import tensorflow as tf
from keras.layers import Dropout
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import LSTM
from tensorflow.keras.metrics import RootMeanSquaredError, MeanAbsoluteError
from tensorflow.keras.models import Sequential
该模型由以下函数定义。
def get_model(params, input_shape):
model = Sequential()
model.add(LSTM(units=params["lstm_units"], return_sequences=True, input_shape=(input_shape, 1)))
model.add(Dropout(rate=params["dropout"]))
model.add(LSTM(units=params["lstm_units"], return_sequences=True))
model.add(Dropout(rate=params["dropout"]))
model.add(LSTM(units=params["lstm_units"], return_sequences=True))
model.add(Dropout(rate=params["dropout"]))
model.add(LSTM(units=params["lstm_units"], return_sequences=False))
model.add(Dropout(rate=params["dropout"]))
model.add(Dense(1))
model.compile(loss=params["loss"],
optimizer=params["optimizer"],
metrics=[RootMeanSquaredError(), MeanAbsoluteError()])
return model
然后，我们用一组给定的参数实例化一个模型。我们使用时间序列中过去的 90 个观测值作为模型的输入序列。其他超参数描述了用于训练模型的架构和特定选择。
params = {
"loss": "mean_squared_error",
"optimizer": "adam",
"dropout": 0.2,
"lstm_units": 90,
"epochs": 30,
"batch_size": 128,
"es_patience" : 10
}
model = get_model(params=params, input_shape=x_train.shape[1])
以上结果产生了下面的 Keras 模型(参见图 5):
Figure 5: a summary of the Keras LSTM model | Source: Author
然后，我们创建一个回调来实现提前停止，即，如果对于给定数量的时期(在我们的示例中为 10 个时期)验证数据集没有产生改进，则停止训练模型:
es_callback = tf.keras.callbacks.EarlyStopping(monitor='val_root_mean_squared_error',
mode='min',
patience=params["es_patience"])
参数 es_patience 是指提前停止的次数。
最后，我们使用预定义的参数拟合模型:
model.fit(
x_train,
y_train,
validation_data=(x_test, y_test),
epochs=params["epochs"],
batch_size=params["batch_size"],
verbose=1,
callbacks=[neptune_callback, es_callback]
)
实验跟踪和模型比较
因为在这篇博文中，我们想回答一个简单的问题，即哪个模型对测试数据集产生最准确的预测，我们需要看看这三个模型之间的差异。
有许多不同的方法用于模型比较，例如创建记录不同指标评估的表格和图表，创建绘制测试集上预测值与真实值的图表，等等。然而，在这个练习中，我们将使用海王星。
海王星是什么？
Neptune 是 MLOps 的元数据存储库，为运行大量实验的团队而构建。
它为您提供了一个记录、存储、显示、组织、比较和查询所有模型构建元数据的单一位置。
Neptune 习惯了 for:
- 实验跟踪:在一个地方记录、显示、组织和比较 ML 实验。
- 模型注册:对训练好的模型进行版本化、存储、管理和查询，以及建模元数据。
- 实时监控 ML 运行:实时记录和监控模型培训、评估或生产运行
如本教程中的所述，我们首先创建一个 Neptune 项目，并记录我们帐户的 API:
run = neptune.init(project='<YOUR_WORKSPACE/YOUR_PROJECT>',
api_token='<YOUR_API_TOKEN>')
变量 run 可以看作一个文件夹，我们可以在其中创建包含不同信息的子文件夹。例如，我们可以创建一个名为 model 的子文件夹，并在其中记录模型的名称:
run["model/name"] = "Arima"
我们将根据两个不同的指标来比较这些模型的准确性:
-
均方根误差(RMSE)
-
平均绝对误差
请注意，可以通过设置相应的值将这些值记录到 Neptune 中，例如，设置:
run["test/mae"] = mae
run["test/rmse"] = mse
三个模型的均方误差和平均误差可以在运行表中并排显示:
Figure 6. the MSE and the MAE for the three models in the Neptune UI
(the tags for each project are at the top) | Source
这三种算法的比较可以在 Neptune 中并排看到，如图 7 所示。
Figure 7: The mean square error and the mean average error for the three models can be seen next to each other
(the tags for each project are at the top) | Source
我们看到 ARIMA 产生了最好的性能，即它在测试集上实现了最小的均方误差和平均绝对误差。相比之下，LSTM 神经网络在三个模型中表现最差。
根据真实值绘制的准确预测可以在下图中看到。我们观察到，所有三个模型都捕捉到了时间序列的总体趋势，但 LSTM 似乎落后于曲线，即它需要更多来调整自己以适应趋势的变化。和先知似乎失去了对 ARIMA 在最后几个月的考虑测试期间，它低估了真正的价值。
Figure 8: ARIMA predictions | Source: Author
Figure 9: prophet predictions | Source: Author
Figure 10: LSTM prediction | Source: Author
对模型性能的深入了解
ARIMA 网格搜索
当在 ARIMA 对 p、d 和 q 的不同值进行网格搜索时，我们可以绘制出各个值的均方误差。图 11 中的彩色点显示了不同 ARIMA 参数在验证集上的均方误差值。
Figure 11: grid-search over the ARIMA parameters | Source
预言家的趋势
我们在 Neptune 中收集参数、预测数据帧、残差诊断图表和其他元数据，同时使用 Prophet 训练模型。这是通过使用一个单一函数来实现的，该函数捕获先知训练元数据并将其自动记录到 Neptune。
在图 12 中，我们展示了先知的不同组成部分的变化。我们观察到，趋势遵循线性增长，而季节性成分表现出波动。
Figure 12: the change of values of the different components in the Prophet over time | Source: Author
为什么 LSTM 表现最差？
当在几个时期内训练 LSTM 模型时，我们在海王星中收集平均绝对误差。这是通过使用一个 Neptune 回调函数来实现的，该回调函数捕获训练元数据并将其自动记录到 Neptune。结果如图 13 所示。
观察到，虽然训练数据集上的误差在随后的时段中减小，但是验证集上的误差却不是这样，验证集上的误差在第二个时段中达到其最小值，然后波动。这表明，LSTM 模型对于一个相当小的数据集来说过于先进，并且容易过度拟合。尽管增加了正则项，如辍学，我们仍然无法避免过度拟合。
Figure 13: the evolution of train and test error over different epochs of training the LSTM model | Source
结论
在这篇博文中，我们展示并比较了三种不同的时间序列预测算法。正如所料，没有明确的赢家，每种算法都有自己的优势和局限性。下面我们总结了我们对每个算法的观察:
- ARIMA 是一个强大的模型，正如我们所见，它为股票数据取得了最好的结果。一个挑战是，它可能需要仔细的超参数调整和对数据的良好理解。
- Prophet 是专门为商业时间序列预测而设计的。它在股票数据上取得了非常好的结果，但是，从轶事来看，它在其他领域的时间序列数据集上可能会失败。特别是，这适用于时间序列，其中日历日期的概念不适用，我们无法学习任何季节模式。Prophet 的优势在于它需要较少的超参数调整，因为它是专门为检测业务时间序列中的模式而设计的。
- 基于 LSTM 的递归神经网络可能是从序列数据中学习的最强大的方法，时间序列只是一个特例。当从大规模数据集学习时，我们可以检测复杂的模式，基于 LSTM 的模型的潜力就完全显现出来了。与 ARIMA 或 Prophet 不同，它们不依赖于关于数据的特定假设，如时间序列平稳性或日期字段的存在。一个缺点是 LSTM 的 rnn 很难解释，并且很难对它们的行为有直觉。此外，为了获得良好的结果，需要仔细调整超参数。
未来方向
所以我希望你喜欢阅读这篇文章，现在你一定对我们在这里讨论的时间序列算法有了更好的理解。如果你想深入了解，这里有一些有用资源的链接。快乐实验！
- PMD·ARIMA。各个 Python 包的文档。
- 先知。脸书先知的文档和教程。
- 凯拉斯·LSTM。喀拉斯 LSTM RNNs 的文档和示例。
- 海王星。有教程和文档的 Neptune 网站。
- 一篇关于用海王星跟踪 ML 实验的博客文章。
- 对 ARIMA 车型的更深入的了解。
- 关于用 LSTM 神经网络进行时间序列预测的教程。
- 原先知研究论文。
Arize AI 和 Neptune AI 合作伙伴关系:对 ML 模型的持续监控和持续改进
原文：https://web.archive.org/web/https://neptune.ai/blog/arize-partnership
将最好的机器学习模型交付给生产应该像培训、测试和部署一样简单，对吗？不完全是！从研究到生产，模型远非完美，而一旦投入生产，保持模型的性能更具挑战性。一旦脱离离线研究环境，模型消耗的数据可能会在分布或完整性方面发生变化，无论是由于在线生产环境中的意外动态还是数据管道中的上游变化。
如果没有正确的工具来检测问题并诊断问题出现的位置和原因，ML 团队就很难知道一旦部署到生产中，何时调整和重新培训他们的模型。作为任何模型性能管理工作流程的一部分，必须建立一个连续的反馈循环。实验、验证、监控和主动改进模型的工具帮助 ML 从业者在生产中一致地部署——并维护——更高质量的模型。
这就是为什么 Arize AI 和 Neptune AI 很高兴地宣布建立合作伙伴关系，将 Arize 的 ML 可观测性平台与 Neptune 的 MLOps 元数据存储连接起来。
通过这种合作关系，ML 团队可以更有效地监控其生产模型的执行情况，深入研究有问题的特征和预测群组，并最终做出更明智的再培训决策。
阿里斯-海王星公司
世界上有很多 ML 基础设施公司，所以让我们概括一下 Neptune 和 Arize 的专长:
-
Neptune 记录、存储、显示和比较您的模型构建元数据。它有助于实验跟踪、数据和模型版本化，以及模型注册，这样你就能真正知道你正在发布什么样的模型。
-
Arize 帮助您可视化生产模型性能，并了解漂移和数据质量问题。
Example dashboard in Arize
ML 生命周期应该被认为是一个跨越数据准备、模型建立和生产阶段的迭代流程。虽然 Arize 平台侧重于生产模型的可观察性，但它监控生产、培训和验证数据集，以构建部署前后可能出现的问题的整体视图。这允许您将任何数据集(包括生产中的前期)设置为比较模型性能的基线或基准。
那么，这有什么关系呢？有了 Neptune 这样的中央 ML 元数据存储，跟踪每个模型版本和模型历史的血统就容易多了。当涉及到试验和优化生产模型时，这对于确保 ML 从业者能够:
- 为团队遵循的模型版本化和打包建立一个协议
- 提供通过 CLI 和 SDK 以您在生产中使用的语言查询/访问模型版本的能力
- 提供一个地方来记录硬件、数据/概念漂移、来自 CI/CD 管道的示例预测、再培训工作和生产模型
- 为主题专家、制作团队或自动检查的批准建立协议。
TL；当结合使用 Arize 和 Neptune 时，DR–ML 从业者可以微调模型性能，并在更细粒度的级别上积极改进模型。
从 Arize 和 Neptune 开始
现在，让我们把这些放在一起！
你一做，就查看我们为你准备的教程！
你会在那里发现:
- 设置 Neptune 客户端和 Arize 客户端
- 海王星测井培训回电
- 记录培训和验证记录以存档
- 使用 Neptune 存储和版本化模型权重
- 用 Arize 实现生产中的日志记录和版本控制模型
结论
有了 Arize 和 Neptune，您将能够高效地完成您最好的机器学习工作:识别和训练您的最佳模型，预发布验证您的模型，并通过简单的集成在模型构建、实验和监控之间创建反馈回路。
关于海王星
Neptune 是 MLOps 的一个元数据存储库，为进行大量实验的研究和生产团队而构建。它为您提供了一个中心位置来记录、存储、显示、组织、比较和查询机器学习生命周期中生成的所有元数据。
成千上万的 ML 工程师和研究人员使用 Neptune 进行实验跟踪和模型注册，无论是作为个人还是在大型组织的团队内部。
有了 Neptune，您可以用一个真实的来源取代文件夹结构、电子表格和命名约定，在这个来源中，您所有的模型构建元数据都是有组织的，易于查找、共享和查询。如果你想更多地了解 Neptune 及其功能，请观看产品之旅或探索我们的文档。
关于艾瑞泽
Arize AI 是一个机器学习可观察性平台，帮助 ML 从业者轻松成功地将模型从研究转向生产。Arize 的自动化模型监控和分析平台允许 ML 团队在问题出现时快速检测问题，解决问题发生的原因，并提高整体模型性能。通过将离线训练和验证数据集连接到中央推理存储中的在线生产数据，ML 团队可以简化模型验证、漂移检测、数据质量检查和模型性能管理。
Arize AI 在部署的 AI 上充当护栏，为历史上的黑箱系统提供透明度和自省，以确保更有效和更负责任的 AI。要了解更多关于 Arize 或机器学习的可观察性和监控，请访问我们的博客和资源中心！
如何使用自动编码器[案例研究指南]
原文：https://web.archive.org/web/https://neptune.ai/blog/autoencoders-case-study-guide
自动编码器是一类神经网络，用于无监督学习任务。他们有两个神经网络组件:编码器和解码器。两个组件具有基本相同的配置，这意味着输入的形状将类似于输出的形状，并且输入将与输出相同。
把输入复制到输出的架构有什么用？一点用都没有。让我解释一下:
为了理解这些网络，它们之间有一个叫做“T0”的信息瓶颈“T1”。与编码器和解码器相比，这个瓶颈区域中的神经元数量要少得多。这迫使网络减少信息，从而减少噪声，并且它们只能近似原始数据，而不是端到端地复制它。
训练这些算法的目的是:
- 从瓶颈中的给定数据集学习表示或模式。
- 根据输入生成一组新数据。
传统上，自动编码器用于降维，高维数据可以在低维空间中表示，类似于 PCA。但是主成分分析受到线性度的限制，不能用高维非线性流形表示低维空间的数据。
多亏了神经网络，自动编码器可以做到这一点。这就是为什么 autoencoder 及其变体被用于许多应用中，包括高能和量子物理、分子生物学、医学图像分割、数据压缩等等。
自动编码器背后的数学直觉
使用数学概念定义自动编码器的一般方法是 f(x) = h，其中 x 是输入数据，h 是信息瓶颈中的潜在变量。这个公式表示网络的编码器部分。
解码器从信息瓶颈中提取潜在变量，然后将它们映射到可以表示为 g(h)= x’的输出中。解码器通常与编码器正好相反。
让我们更深入地探讨“信息瓶颈”和“潜在变量”这两个术语，因为它们非常重要。
信息瓶颈 (IB)于 1999 年推出，当时的假设是，it 可以通过压缩可以在网络中传输的信息量来提取重要信息或表示。这些信息被称为潜在变量或潜在表征。
简而言之，潜变量是不能直接观察到，而是从分布中提取出来的随机变量。这些变量是非常基本的，它们给了我们拓扑和数据分布的抽象知识。潜在变量，这里表示为 h，可以根据您使用的自动编码器的不同而不同。
整个自动编码器可以描述为:
其中 f 和 g 都是非线性函数。
自动编码器的类型
自 1987 年问世以来，自动编码器已经有了很大的发展，它们的应用程序使它们更加针对特定的任务。在这里，我们将讨论不同的自动编码器及其工作原理。
欠完整自动编码器
欠完整自动编码器旨在通过尽可能限制模型的容量，将输入 x 映射到输出 x `，从而最小化流经网络的信息量。
欠完整自动编码器通过最小化相同的损失函数来学习特征:
其中 L 是惩罚 g(f(x)) 偏离原始输入 x 的损失函数。 L 可以是均方误差，甚至是平均绝对误差。
自动编码器功能强大，因为它们的容量减少了——隐藏层中的节点数量随着信息瓶颈中的节点数量一起减少。之所以这样，是因为即使瓶颈只包含一个维度，当模型的容量很高时，自动编码器仍然可以将输入复制到输出，而不提取任何信息。
我们的目标总是提取表示，然后从这些表示中重建输入。为了使自动编码器能够学习和提取表示并重建输入，我们需要:
- 增加模型容量，
- 增加信息瓶颈容量，
- 正则化模型，使其支持以上两点。
优点:
因为欠完整自动编码器最大化了概率分布，所以它们不需要正则化函数。
缺点:
欠完整自动编码器不是通用的，它们往往会过拟合。它过度拟合的原因之一是因为它是一个容量有限的简单模型，不允许它具有灵活性。
正则化自动编码器
正则化自动编码器是基于数据复杂性设计的，它们解决了欠完整自动编码器的问题。编码器和解码器，随着信息瓶颈，可以有更高的容量。这使得它们更加灵活和强大。
正则化自动编码器对以下属性使用损失函数:
- 通过逼近从输入重构输出的能力。
- 表示的稀疏性。
- 表示的导数的微小性。
- 对噪声、异常值或缺失输入的鲁棒性。
稀疏自动编码器
稀疏自动编码器是正则化的自动编码器，在隐藏层上伴随着重构损失有损失:
其中 h 代表隐藏层。
这种惩罚隐藏层的方法意味着自动编码器可以具有更大的容量，同时仍然限制网络学习表示。该网络被限制为只激活隐藏层中一定数量的神经元。
值得注意的是，神经元的激活取决于输入数据，因此它们是数据依赖的，这意味着输入数据的分布导致隐藏层中神经元的激活。
从上面的图像中，你可以看到稀疏自动编码器如何激活隐藏层中的不同神经元来学习表示。
有两种方法可以在给定的网络上实现稀疏性:
- L1 正则化
- KL-散度
在 L1 正则化中，我们给我们的损失函数增加了一个λ项，该λ项惩罚层 h 中激活 a 的绝对值。
这个λ项帮助我们正则化整个模型，因为正则化项只依赖于λ。
另一方面，Kullback-Leibler 散度或 KL-Divergence 计算两个概率分布之间的差异。KL-divergence 在测量执行近似时丢失了多少数据方面非常出色。
KL-divergence 来自信息论，在信息论中，我们使用熵来计算一条信息的随机性。随机性或熵越高，解释数据就越困难。
定义熵的另一种方法是编码所需的最小信息量。本质上，如果随机性高，则需要更多的信息，如果随机性低，则需要更少的信息。
信息熵表示为:
其中 x 是所需的信息
信息熵的问题在于，我们无法获得实现编码所需的最佳信息。
另一方面，KL-divergence 通过考虑近似分布来修改信息熵。
我们可以将 KL 散度描述为:
从上面的公式中，可以看到增加了一个近似项。通过计算 KL 散度来测量分布中的差异，我们现在可以将这个正则化项与损失函数相加。KL-散度也称为相对熵。
优点:
在稀疏自动编码器中，通过应用稀疏惩罚来防止过拟合。稀疏惩罚应用于隐藏层和重构误差。通过增加容量和学习复杂的拓扑结构，这使得模型更加通用。
缺点:
重要的是，节点是数据相关的，因为输入向量负责在训练期间产生结果的不同节点的激活。因此，测试数据中任何微小的统计变化都会产生不同的结果。
收缩自动编码器
收缩型自动编码器学习对输入数据的微小变化具有鲁棒性的表示。收缩式自动编码器背后的思想是将有限的输入分布映射到更小的输出分布。这种想法本质上训练自动编码器学习表示，即使相邻点稍微改变。
与我们之前讨论的类型一样，这也在损失标准中增加了一个惩罚项。
让我们探索等式的第二部分。就是雅可比矩阵 J 的平方 Frobenius ||A||范数。Frobenius 可以认为是矩阵的 L2 范数，雅可比矩阵表示向量值函数的一阶偏导数，即潜在表示的向量。
上面的术语描述了潜在表示 h 相对于输入 x 的梯度场。这一项惩罚了雅可比矩阵的大导数或者潜在表示 h 的梯度场。输入中的任何小变化导致表征空间中的大变化或变动都是不利的。
优点:
相比稀疏自动编码器，收缩自动编码器是学习良好表示的好选择，因为它们对微小的变化是鲁棒的，并且节点不依赖于数据。
缺点:
在输入向量的编码和解码过程中，收缩自动编码器的主要缺点是其重构误差。这导致忽略了重建时值得考虑的更细微的细节。
降噪自动编码器
到目前为止，我们已经看到了如何通过惩罚与原始输入 x 不同的自动编码器来改进它。我们现在看到的方法是相反的。我们设计我们的损失函数，使得模型训练与原始输出不太相似。
在去噪自动编码器中，我们传递添加了噪声的输入。这里的目标是训练一个自动编码器来消除这些噪声，并产生一个无噪声的输出。假设更高层次的 表示相对稳定并且容易提取。
为了实现这一点，我们需要自动编码器来最大限度地降低以下标准:
不是最小化传统标准:
去噪自动编码器被训练来学习表示，而不是简单地记忆和复制输入到输出，因为输入和输出不再相同。
优点:
对自动编码器去噪有利于学习 损坏数据中的潜在表示，同时创建相同的鲁棒表示，允许模型恢复真实特征。
缺点:
为了训练去噪自动编码器，重要的是执行初步随机映射以破坏数据，然后将其用作输入。这不允许模型创建映射，因为输入和输出是不同的。
可变自动编码器
变型自动编码器，俗称 VAE，是自动编码器的一种更高级的变体。虽然在基本架构上相似，但它们拥有完全不同的数学公式。
人们可以观察到的最大变化之一是潜在变量的计算方式。VAE 使用概率方法来寻找潜在的变量或代表。这个属性使它非常强大，可以与我们之前看到的自动编码器相比较。
VAE 的信息瓶颈由两部分组成。一个分量代表输入分布的平均值，而另一个分量代表分布的标准偏差。
直观上，平均值控制输入的编码应该集中在哪里，而标准差控制“面积”；编码可以与平均值相差多少。我们还将高斯分布注入潜在空间，这允许 VAE 随机采样噪声，然后使用均值和标准差对其建模。
这使得 VAE 有一种概率方法来表示给定输入的每个潜在属性。
VAE 的编码器(也称为近似推理网络)试图推断潜在变量 z 的属性。这可以描述为:
解码器(称为发生器)从潜像中提取样本并生成输出。解码器可以描述为:
VAE 可以被描述为:
等式的第一部分描述了试图最大化重建似然的重建似然，第二部分是正则化项。
VAE 中的潜在变量是连续的这一事实使它们成为一个强大的生成模型。此外，参数编码器与生成器的同步训练鼓励模型学习可预测的坐标系，使它们成为流形学习的绝佳选择。
优点:
VAE 让我们能够控制我们希望如何对潜在变量的分布进行建模，而不是其他模型，这些模型可以在以后用于生成新数据。
缺点:
由于潜在空间中注入的高斯分布，生成的图像是模糊的。
自动编码器的应用
自动编码器已被广泛用于降维和表示学习。与 PCA 相比，自动编码器产生的重建误差更小。它还表明，从自动编码器中提取的低维流形提高了许多任务的性能，例如:
- 分类
- 异常检测
- 数据去噪
- 图像修复
- 信息检索
使用 MNIST 了解 Pytorch 中的自动编码器[教程]
现在，让我们了解如何用 PyTorch 编写自动编码器，并做一些可视化工作来探索潜在空间和解释模型。
对于一个普通的自动编码器，下面的库就足够了。我们还将为设备定义一个变量。它会自动检测 colab 笔记本是有 cpu 还是有 gpu。
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import matplotlib.pyplot as plt
from torchvision import datasets, transforms
import os
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
从 Pytorch 库下载的图像是 PIL 格式的，应该转换成张量格式。转变。ToTensor()将 PIL 转换为 Pytorch 要求的张量格式。
transform = transforms.Compose([transforms.ToTensor(),
transforms.Normalize((0.5, ), (0.5, ))
])
下载并加载培训数据。
trainset = datasets.MNIST('MNIST_data/', download = True, train = True, transform = transform)
testset = datasets.MNIST('MNIST_data/', download = True, train = False, transform = transform)
batch_size = 128
trainloader = torch.utils.data.DataLoader(trainset, batch_size = batch_size, shuffle = True)
testloader = torch.utils.data.DataLoader(testset, batch_size = batch_size, shuffle = True)
让我们检查一个样本。
dataiter = iter(trainloader)
images, labels = dataiter.next()
plt.figure()
plt.imshow(images[0].numpy().squeeze(), cmap = 'gray')
plt.colorbar(fraction=0.046, pad=0.04)
我们将定义一个学习函数，它将:
- 训练模型，
- 计算每个小批量的损耗并更新参数，
- 在每个纪元后显示视觉进度。
还有，注意损失函数。我们将定义均方误差损失来计算损失，并在优化过程中使用 adam optimizer。亚当是最受欢迎的优化器之一，用于大多数深度学习任务。
class Learner():
def __init__(self, train_dl, valid_dl, model, loss_func = nn.MSELoss()):
self.train_dl, self.valid_dl = train_dl, valid_dl
self.model = model
self.loss_func = loss_func
self.train_losses = []
self.valid_losses = []
def update(self,x, optm, vae):
y_hat, z = self.model(x)
loss = self.loss_func(y_hat,x)
loss.backward()
optm.step()
optm.zero_grad()
return loss.item()
def show_visual_progress(self, rows, title, epoch, flatten, vae):
image_title = f'{title}{epoch}'
plt.title(image_title)
iter(self.valid_dl)
image_rows = []
for idx, (image, label) in enumerate(self.valid_dl):
if rows == idx:
break
image = image.to(device)
if flatten:
image = image.view(image.size(0), 28*28)
images, z = self.model(image)
images = images.detach().cpu().numpy().reshape(image.size(0),28,28)
self.z = z.detach().cpu().numpy()
image_idxs = [list(label.numpy()).index(x) for x in range(10)]
combined_images = np.concatenate([images[x].reshape(28,28) for x in image_idxs],1)
image_rows.append(combined_images)
plt.imshow(np.concatenate(image_rows))
plt.show()
def fit(self, epochs = 1, lr = 1e-4, flatten = False, vae = False):
opt = torch.optim.Adam(self.model.parameters(), lr = lr)
for epoch in range(epochs):
for image, label in self.train_dl:
image = image.to(device)
if flatten:
image = image.view(image.size(0), 28*28)
self.train_losses.append(self.update(image, opt, vae=vae))
for image, label in self.valid_dl:
image = image.to(device)
if flatten:
image = image.view(image.size(0), 28*28)
self.valid_losses.append(self.update(image, opt, vae= vae))
print("Epoch number {} finished.".format(epoch))
self.show_visual_progress(rows=5, title='AutoEncoder Learning State at Epoch: ', epoch = epoch, flatten = flatten, vae= vae)
我们定义了一个非常简约的模型，其中潜在的大小可以改变。这将有助于我们看到和理解模型如何执行变化的潜在大小。
class AutoEncoder(nn.Module):
def __init__(self, latent_size = 3):
super(AutoEncoder, self).__init__()
self.encoder = nn.Sequential(
nn.Linear(784, 512),
nn.ReLU(),
nn.Linear(512, 128),
nn.ReLU(),
nn.Linear(128, latent_size)
)
self.decoder = nn.Sequential(
nn.Linear(latent_size, 128),
nn.ReLU(),
nn.Linear(128, 512),
nn.ReLU(),
nn.Linear(512, 784)
)
def forward(self, x):
z = self.encoder(x)
o = self.decoder(z)
return o, z
开始训练。
model = AutoEncoder().to(device)
learn = Learner(trainloader, testloader, model)
learn.fit(epochs = 10, lr = 1e-4, flatten = True)
plt.subplot(121)
plt.plot(learn.train_losses)
plt.subplot(122)
plt.plot(learn.valid_losses)
下图来自第九个时期，当时潜在变量固定为 5。你会观察到它重建图像的效果有多好。
The image above shows the output yielded by the autoencoder after 9 epochs.
案例研究 1:使用去噪自动编码器进行图像去噪
在第一个案例研究中，我们将应用自动编码器来消除图像中的噪声。这在计算机断层扫描(CT)中非常有用，在这种扫描中，图像可能很模糊，并且很难解释或训练分割模型。
MNIST py torch 中的自动编码器
我们将再次使用 MNIST，这次使用 Keras 来下载数据集，因为 Pytorch MNIST 数据是 PIL 格式的。虽然为了本文的简单起见，您可以使用它，但是我们将从 Keras 下载数据，因为它将确保我们以 NumPy 格式下载数据，以便我们可以添加噪声。
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import matplotlib.pyplot as plt
from torchvision import datasets, transforms
import os
from keras.datasets import mnist
from torch.utils.data import DataLoader,Dataset
向数据集添加噪声，我们将添加两种类型的噪声:
- 高斯的
- 点缀
def add_noise(img,noise_type="gaussian"):
row,col=28,28
img=img.astype(np.float32)
if noise_type=="gaussian":
mean=0
var=10
sigma=var**.5
noise=np.random.normal(-5.9,5.9,img.shape)
noise=noise.reshape(row,col)
img=img+noise
return img
if noise_type=="speckle":
noise=np.random.randn(row,col)
noise=noise.reshape(row,col)
img=img+img*noise
return img
noises=["gaussian","speckle"]
noise_ct=0
noise_id=0
traindata=np.zeros((60000,28,28))
for idx in (range(len(xtrain))):
if noise_ct<(len(xtrain)/2):
noise_ct+=1
traindata[idx]=add_noise(xtrain[idx],noise_type=noises[noise_id])
else:
print("n{} noise addition completed to images".format(noises[noise_id]))
noise_id+=1
noise_ct=0
print("n{} noise addition completed to images".format(noises[noise_id]))
noise_ct=0
noise_id=0
testdata=np.zeros((10000,28,28))
for idx in (range(len(xtest))):
if noise_ct<(len(xtest)/2):
noise_ct+=1
x=add_noise(xtest[idx],noise_type=noises[noise_id])
testdata[idx]=x
else:
print("n{} noise addition completed to images".format(noises[noise_id]))
noise_id+=1
noise_ct=0
print("n{} noise addition completed to images".format(noises[noise_id]))
可视化数据。
f, axes=plt.subplots(2,2)
axes[0,0].imshow(xtrain[0])
axes[0,0].set_title("Original Image")
axes[1,0].imshow(traindata[0])
axes[1,0].set_title("Noised Image")
axes[0,1].imshow(xtrain[25000])
axes[0,1].set_title("Original Image")
axes[1,1].imshow(traindata[25000])
axes[1,1].set_title("Noised Image")
数据经过预处理后，我们可以:
- 将数据转换成张量，
- 创建包含原始数据和噪声数据的数据集，
使用 Pytorch 的 DataLoader 函数创建可用于训练和建模的生成器变量。
class noisedDataset(Dataset):
def __init__(self,datasetnoised,datasetclean,labels,transform):
self.noise=datasetnoised
self.clean=datasetclean
self.labels=labels
self.transform=transform
def __len__(self):
return len(self.noise)
def __getitem__(self,idx):
xNoise=self.noise[idx]
xClean=self.clean[idx]
y=self.labels[idx]
if self.transform != None:
xNoise=self.transform(xNoise)
xClean=self.transform(xClean)
return (xNoise,xClean,y)
transform =transforms.Compose([
transforms.ToTensor()
])
trainset=noisedDataset(traindata,xtrain,ytrain,transform)
testset=noisedDataset(testdata,xtest,ytest,transform)
batch_size=32
trainloader=DataLoader(trainset,batch_size=32,shuffle=True)
testloader=DataLoader(testset,batch_size=1,shuffle=True)
定义一个去噪模型类似于定义一个普通的自动编码器，唯一改变的是用于从编码器获得最终输出的 sigmoid 函数。
sigmoid 函数将确保最终输出在 0 到 1 的范围内，因为干净数据在 0 到 1 的范围内。我们将最终信号转换到相同的范围是有意义的。
class denoising_model(nn.Module):
def __init__(self):
super(denoising_model,self).__init__()
self.encoder=nn.Sequential(
nn.Linear(28*28,256),
nn.ReLU(True),
nn.Linear(256,128),
nn.ReLU(True),
nn.Linear(128,64),
nn.ReLU(True)
)
self.decoder=nn.Sequential(
nn.Linear(64,128),
nn.ReLU(True),
nn.Linear(128,256),
nn.ReLU(True),
nn.Linear(256,28*28),
nn.Sigmoid(),
)
def forward(self,x):
z=self.encoder(x)
sigmoid =self.decoder(z)
return sigmoid
我们也将为此任务初始化相同的损失和优化器函数。
model=denoising_model().to(device)
criterion=nn.MSELoss()
optimizer=torch.optim.Adam(model.parameters(),lr=0.01)
初始化 120 个时期的训练。
epochs=120
l=len(trainloader)
losslist=list()
epochloss=0
running_loss=0
for epoch in range(epochs):
print("Entering Epoch: ",epoch)
for (idx), (dirty,clean,label) in enumerate(trainloader):
if idx == 50:
print('+', end='')
dirty=dirty.view(dirty.size(0),-1).type(torch.FloatTensor)
clean=clean.view(clean.size(0),-1).type(torch.FloatTensor)
dirty,clean=dirty.to(device),clean.to(device)
output=model(dirty)
loss=criterion(output,clean)
optimizer.zero_grad()
loss.backward()
optimizer.step()
running_loss+=loss.item()
epochloss+=loss.item()
losslist.append(running_loss/l)
running_loss=0
print("======> epoch: {}/{}, Loss:{}".format(epoch,epochs,loss.item()))
可视化结果。
f,axes= plt.subplots(6,3,figsize=(20,20))
axes[0,0].set_title("Original Image")
axes[0,1].set_title("Dirty Image")
axes[0,2].set_title("Cleaned Image")
test_imgs=np.random.randint(0,10000,size=6)
for idx in range((6)):
dirty=testset[test_imgs[idx]][0]
clean=testset[test_imgs[idx]][1]
label=testset[test_imgs[idx]][2]
dirty=dirty.view(dirty.size(0),-1).type(torch.FloatTensor)
dirty=dirty.to(device)
output=model(dirty)
output=output.view(1,28,28)
output=output.permute(1,2,0).squeeze(2)
output=output.detach().cpu().numpy()
dirty=dirty.view(1,28,28)
dirty=dirty.permute(1,2,0).squeeze(2)
dirty=dirty.detach().cpu().numpy()
clean=clean.permute(1,2,0).squeeze(2)
clean=clean.detach().cpu().numpy()
axes[idx,0].imshow(clean,cmap="gray")
axes[idx,1].imshow(dirty,cmap="gray")
axes[idx,2].imshow(output,cmap="gray")
The image above shows the output yielded by the denoising autoencoder which was able successfully remove noise from the input image and produced images similar to the original image.
案例研究 2:利用 LSTM 自动编码器检测心电图异常
心电图(ECG 或 EKG)是一种通过测量心脏的电活动来检查心脏功能的测试。这些信号可以用智能手表来测量。
ECG 信号可以告诉我们很多关于一个人的健康和幸福的信息。在本案例研究中，我们将预测 ECG 信号并检测信号中的异常。
我们将使用属性关系文件格式(ARFF)，所以我们将安装两个包来支持它们。首先是 arff2pandas，将 arff 文件转换成 pandas 框架。第二:pandas profiling，从 pandas DataFrame 生成 profile 报告。
要在 colab 笔记本中安装这些包，我们使用以下命令:
!pip install -qq arff2pandas
!pip install -U pandas-profiling
一旦安装了所需的包，我们就可以开始导入它们以及本案例研究所需的其他包。
import torch
import copy
import numpy as np
import pandas as pd
import seaborn as sns
from pylab import rcParams
import matplotlib.pyplot as plt
from matplotlib import rc
from sklearn.model_selection import train_test_split
from torch import nn, optim
import torch.nn.functional as F
from arff2pandas import a2p
为了视觉上吸引人的情节，我们设置以下变量:
%matplotlib inline
%config InlineBackend.figure_format='retina'
sns.set(style='whitegrid', palette='muted', font_scale=1.2)
HAPPY_COLORS_PALETTE = ["#01BEFE", "#FFDD00", "#FF7D00", "#FF006D", "#ADFF02", "#8F00FF"]
sns.set_palette(sns.color_palette(HAPPY_COLORS_PALETTE))
rcParams['figure.figsize'] = 12, 8
RANDOM_SEED = 42
np.random.seed(RANDOM_SEED)
torch.manual_seed(RANDOM_SEED)
以下命令可用于将数据直接下载到您的 colab 笔记本:
!gdown --id 16MIleqoIr1vYxlGk4GKnGmrsCPuWkkpT
Once the data is downloaded we unzip it in the desired folder.
mkdir -p 命令创建一个子目录和父目录。在我们的例子中，“data”是父目录，“timeseries”是子目录。
!mkdir -p data/timeseries
同样，我们可以使用！unzip ECG 5000 . zip-d data/time series 用于解压缩文件。参数-d 允许文件在期望的路径中解压缩。在我们的例子中，我们创建的目录。
!unzip ECG5000.zip -d data/timeseries
我们将定义 CPU 或 GPU 使用的设备。
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
一旦文件被解压缩，我们就可以使用 a2p 函数打开它，该函数使用 pandas 数据帧打开 arff 文件。
with open('data/timeseries/ECG5000_TRAIN.arff') as f:
train = a2p.load(f)
with open('data/timeseries/ECG5000_TEST.arff') as f:
test = a2p.load(f)
可视化数据。
df = train.append(test)
df = df.sample(frac=1.0)
df.shape
CLASS_NORMAL = 1
class_names = ['Normal','R on T','PVC','SP','UB']
ax = sns.countplot(df.target)
ax.set_xticklabels(class_names);
As you can see from the bar chart above, the normal class has by far the most examples. Now let’s plot a time series graph to see how these features look like against the target feature.
def plot_time_series_class(data, class_name, ax, n_steps=10):
time_series_df = pd.DataFrame(data)
smooth_path = time_series_df.rolling(n_steps).mean()
path_deviation = 2 * time_series_df.rolling(n_steps).std()
under_line = (smooth_path - path_deviation)[0]
over_line = (smooth_path + path_deviation)[0]
ax.plot(smooth_path, linewidth=2)
ax.fill_between(
path_deviation.index,
under_line,
over_line,
alpha=.125
)
ax.set_title(class_name)
classes = df.target.unique()
fig, axs = plt.subplots(
nrows=len(classes) // 3 + 1,
ncols=3,
sharey=True,
figsize=(14, 8)
)
for i, cls in enumerate(classes):
ax = axs.flat[i]
data = df[df.target == cls]
.drop(labels='target', axis=1)
.mean(axis=0)
.to_numpy()
plot_time_series_class(data, class_names[i], ax)
fig.delaxes(axs.flat[-1])
fig.tight_layout()
*If you observe carefully, the normal class stands out compared to other classes. This data attribute can help the autoencoder find anomalies more easily. *
使用条件语句创建带有两个变量(正常和异常)的数据集的时间。一旦创建了这两个变量，我们就可以使用 sklearn 中的 train_test_split 来分离训练、测试和验证数据。
normal_df = df[df.target == str(CLASS_NORMAL)].drop(labels='target', axis=1)
anomaly_df = df[df.target != str(CLASS_NORMAL)].drop(labels='target', axis=1)
train_df, val_df = train_test_split(
normal_df,
test_size=0.15,
random_state=RANDOM_SEED
)
val_df, test_df = train_test_split(
val_df,
test_size=0.33,
random_state=RANDOM_SEED
)
一旦数据被分离，我们就将 NumPy 转换成二维张量，autoencoder 可以用它来训练和模拟数据。
def create_dataset(df):
sequences = df.astype(np.float32).to_numpy().tolist()
dataset = [torch.tensor(s).unsqueeze(1).float() for s in sequences]
n_seq, seq_len, n_features = torch.stack(dataset).shape
return dataset, seq_len, n_features
train_dataset, seq_len, n_features = create_dataset(train_df)
val_dataset, _, _ = create_dataset(val_df)
test_normal_dataset, _, _ = create_dataset(test_df)
test_anomaly_dataset, _, _ = create_dataset(anomaly_df)
现在，让我们编码自动编码器。与我们之前用来建模图像的方法不同，我们使用不同的方法来建模时间序列或序列数据。在这个案例研究中，我们将使用长短期记忆或 LSTM。
LSTMs 擅长对顺序数据建模。他们可以记住长期序列，这使得根据序列长度预测变量变得更加容易。
class Encoder(nn.Module):
def __init__(self, seq_len, n_features, embedding_dim=64):
super(Encoder, self).__init__()
self.seq_len, self.n_features = seq_len, n_features
self.embedding_dim, self.hidden_dim = embedding_dim, 2 * embedding_dim
self.\r\nn1 = nn.LSTM(
input_size=n_features,
hidden_size=self.hidden_dim,
num_layers=1,
batch_first=True
)
self.\r\nn2 = nn.LSTM(
input_size=self.hidden_dim,
hidden_size=embedding_dim,
num_layers=1,
batch_first=True
)
def forward(self, x):
x = x.reshape((1, self.seq_len, self.n_features))
x, (_, _) = self.\r\nn1(x)
x, (hidden_n, _) = self.\r\nn2(x)
return hidden_n.reshape((self.n_features, self.embedding_dim))
一旦编码器准备好了，我们还要定义一个解码器。解码器也将具有相同的 LSTM 架构。
class Decoder(nn.Module):
def __init__(self, seq_len, input_dim=64, n_features=1):
super(Decoder, self).__init__()
self.seq_len, self.input_dim = seq_len, input_dim
self.hidden_dim, self.n_features = 2 * input_dim, n_features
self.\r\nn1 = nn.LSTM(
input_size=input_dim,
hidden_size=input_dim,
num_layers=1,
batch_first=True
)
self.\r\nn2 = nn.LSTM(
input_size=input_dim,
hidden_size=self.hidden_dim,
num_layers=1,
batch_first=True
)
self.output_layer = nn.Linear(self.hidden_dim, n_features)
def forward(self, x):
x = x.repeat(self.seq_len, self.n_features)
x = x.reshape((self.n_features, self.seq_len, self.input_dim))
x, (hidden_n, cell_n) = self.\r\nn1(x)
x, (hidden_n, cell_n) = self.\r\nn2(x)
x = x.reshape((self.seq_len, self.hidden_dim))
return self.output_layer(x)
让我们将编码器和解码器封装在一个模块中。
class RecurrentAutoencoder(nn.Module):
def __init__(self, seq_len, n_features, embedding_dim=64):
super(RecurrentAutoencoder, self).__init__()
self.encoder = Encoder(seq_len, n_features, embedding_dim).to(device)
self.decoder = Decoder(seq_len, embedding_dim, n_features).to(device)
def forward(self, x):
z = self.encoder(x)
o = self.decoder(z)
return o
现在我们定义模型。
model = RecurrentAutoencoder(seq_len, n_features, 128)
model = model.to(device)
让我们写一个我们将要训练的函数。
def train_model(model, train_dataset, val_dataset, n_epochs):
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
criterion = nn.L1Loss(reduction='sum').to(device)
history = dict(train=[], val=[])
best_model_wts = copy.deepcopy(model.state_dict())
best_loss = 10000.0
for epoch in range(1, n_epochs + 1):
model = model.train()
train_losses = []
for seq_true in train_dataset:
optimizer.zero_grad()
seq_true = seq_true.to(device)
seq_pred = model(seq_true)
loss = criterion(seq_pred, seq_true)
loss.backward()
optimizer.step()
train_losses.append(loss.item())
val_losses = []
model = model.eval()
with torch.no_grad():
for seq_true in val_dataset:
seq_true = seq_true.to(device)
seq_pred = model(seq_true)
loss = criterion(seq_pred, seq_true)
val_losses.append(loss.item())
train_loss = np.mean(train_losses)
val_loss = np.mean(val_losses)
history['train'].append(train_loss)
history['val'].append(val_loss)
if val_loss < best_loss:
best_loss = val_loss
best_model_wts = copy.deepcopy(model.state_dict())
print(f'Epoch {epoch}: train loss {train_loss} val loss {val_loss}')
model.load_state_dict(best_model_wts)
return model.eval(), history
注意:我们使用 L1Loss 或平均绝对误差。这在处理数据中的异常值或异常时非常有用。此外，对于序列分析，它工作得非常好，因为它使用与被测量的数据相同的尺度。
让我们开始训练吧。
model, history = train_model(
model,
train_dataset,
val_dataset,
n_epochs=150
)
一旦模型经过训练，我们就可以开始预测值，并将它们与原始数据进行比较，以了解我们的模型的表现如何。
def predict(model, dataset):
predictions, losses = [], []
criterion = nn.L1Loss(reduction='sum').to(device)
with torch.no_grad():
model = model.eval()
for seq_true in dataset:
seq_true = seq_true.to(device)
seq_pred = model(seq_true)
loss = criterion(seq_pred, seq_true)
predictions.append(seq_pred.cpu().numpy().flatten())
losses.append(loss.item())
return predictions, losses
_, losses = predict(model, train_dataset)
sns.distplot(losses, bins=50, kde=True)
As you can see from the graph, the model managed to minimize loss on the training data set. Now let’s do the same with the test dataset and see how our model performs.
predictions, pred_losses = predict(model, test_normal_dataset)
sns.distplot(pred_losses, bins=50, kde=True)
*You can see similar performance on the validation set as well. The losses are reduced. *
最后，让我们在时序图中看看模型性能。
def plot_prediction(data, model, title, ax):
predictions, pred_losses = predict(model, [data])
ax.plot(data, label='true')
ax.plot(predictions[0], label='reconstructed')
ax.set_title(f'{title} (loss: {np.around(pred_losses[0], 2)})')
ax.legend()
fig, axs = plt.subplots(
nrows=2,
ncols=6,
sharey=True,
sharex=True,
figsize=(22, 8)
)
for i, data in enumerate(test_normal_dataset[:6]):
plot_prediction(data, model, title='Normal', ax=axs[0, i])
for i, data in enumerate(test_anomaly_dataset[:6]):
plot_prediction(data, model, title='Anomaly', ax=axs[1, i])
fig.tight_layout()
从上图可以明显看出，该模型在预测正常心电图模式方面表现良好。它没有足够的准确性来对异常模式做出好的预测。如果我们的模型针对更多的时期和更多的数据进行训练，那么它可以在给定的任务中表现良好。
注意:该模型在预测正常模式方面表现出色，因为数据集的正常特征多于异常特征。
结论
我们已经讨论了什么是自动编码器，以及它们如何发现数据中的结构。压缩数据的信息瓶颈很重要，因为它允许自动编码器学习潜在的表示，这些表示可用于各种深度学习任务。自动编码器是 PCA 的高级版本，其可以是非线性流形，并且仍然对异常值具有鲁棒性。
我们看到了自动编码器的不同变体，以及它们如何针对特定任务相互改进。我们还对 autoencoder 进行了编码，以更好地理解它的工作原理，并了解了不同维度的潜在空间对结果的不同影响。
最后，我们探讨了如何使用自动编码器完成两项任务:图像去噪和异常检测。
我希望这个教程是有趣的和有益的。感谢您的阅读！
承认
第二个案例研究中使用的代码受到了 Venelin 的启发。我只是修改了一下让它更易读。
进一步阅读
机器学习项目中的自动化测试 MLOps 的最佳实践]
原文：https://web.archive.org/web/https://neptune.ai/blog/automated-testing-machine-learning
机器学习中的自动化测试是 ML 项目中非常有用的部分，它可以产生一些长期的差异。可能在开发的早期阶段被低估了，只有在后期阶段，当系统开始因为恼人的 bug 而分崩离析时，它才得到关注，这些 bug 只会随着时间的推移而增长。为了缓解这些问题并减少 bug 的数量，建议在项目中添加一些自动化测试。
在本文中，我们将尝试理解:
- 什么是自动化测试
- 以及如何用它们把 ML 项目做得更好。
什么是自动化测试？
自动化测试是一个过程，在这个过程中，测试人员使用特殊的工具来测试软件，并找出任何可能存在的错误。此外，它在 20 世纪 90 年代早期就已经出现了，但是直到最近几年，随着敏捷开发和持续集成(CI)的流行，它才开始流行起来。
自动化测试是开发过程中不可或缺的一部分。它可以帮助在开发生命周期的早期识别 bug 和缺陷，这可以节省以后修复它们的时间和金钱。众所周知，自动化测试比手工测试更可靠，因为它们不容易出现人为错误。
自动化测试过程比手工测试有很多优势。其中包括:
- 减少开发人员的工作量和总体成本
- 提高质量和一致性
- 更快的发布周期
- 跨多个设备或位置轻松分配测试
- 更好的报告能力和其他
预计全球自动化测试市场规模将从 2021 年的 207 亿美元增长到 2026 年的 499 亿美元，复合年增长率(CAGR)为 19.2%。这是由于移动和基于网络的应用程序的快速采用。此外，物联网、人工智能和机器学习等现代技术正在迅速扩展，这为测试它们提供了一个很好的机会。
自动化测试的例子
The opportunities in the automation testing market | Source
通常，当谈到自动化测试时，首先出现的是以软件质量保证为目的的软件测试。但是除了软件测试之外，自动化测试还可以包括一些其他类型的测试，比如硬件、安全性、性能等等。
硬件测试:在产品出厂前，使用特殊的硬件和软件自动测试来验证产品的质量。被测产品一般称为 UUT(被测单元)。例如，自动化硬件测试可以包括机械地(例如振动、致动、压力、温度变化)或电地(例如供电、触发)刺激 UUT。之后，对采集的数据进行分析并生成报告。
安全测试:也称为网络测试，是我们针对软件程序、网络设备或整个 IT 基础设施运行的一组自动化测试，旨在寻找黑客可能利用的漏洞。测试可能包括寻找系统的已知易受攻击的版本(例如，web 服务器的旧版本)，测试密码形式以查看它们是否能被暴力或字典攻击破解，或者尝试使系统过载以查看它是否会泄露信息(DDoS、暴力)。
性能测试:是一个软件测试过程，用于测试一个应用在特定工作负载下的速度、响应时间和稳定性。性能测试的主要目标是识别和消除软件应用程序中的性能瓶颈。一些类型的性能测试包括:
负载测试:用预期的用户数量测试应用程序，看看它是如何工作的。
- 压力测试:包括极端工作负载下的应用测试。
- 最后，与我们最相关的自动化测试类型是软件测试。软件测试最常见的例子是:
单元测试:对软件的单个组件或其功能进行的测试。基本上，他们隔离一个特定的组件或功能，并单独测试它们。在这个过程中，可以理解应用程序中每个单元的功能。
- 集成测试:在单元测试之后。集成测试的主要目的是找出软件不同组件交互之间的任何不规则性。
- 验收测试:这些测试的主要目标是证明应用程序是否做了预期的事情。他们在类似生产的环境中从最终用户的角度评估系统。
- 测试传统软件与测试机器学习项目
测试机器学习项目具有挑战性，而且没有一种标准的方法。由于 ML 项目严重依赖于数据和模型，而这些数据和模型不能被强有力地指定为先验的，因此测试 ML 项目比测试手工编码的系统是一个更复杂的挑战。与大多数传统软件测试不同，ML 项目测试必须包括数据测试、模型测试以及生产测试。
首先， ML 项目比传统软件有更多的不确定性。在很多情况下，我们甚至不知道项目在技术上是否可行，所以我们必须投入一些时间进行研究并给出答案。这种不确定性损害了良好的软件实践，例如测试，因为我们不想在开发的早期阶段花费时间测试 ML 项目，这可能不会获得进一步继续的绿灯。
Traditional system testing VS ML projects testing | Source
- 另一方面，项目越是没有测试，它积累的技术债务就越多。随着 ML 项目的成熟，我们必须开始越来越关注增加测试覆盖率和支付技术债务。
- 与传统的软件测试不同，在 ML 测试中我们需要特别注意数据测试。ML 系统不同于传统的基于软件的系统，因为 ML 系统的行为不是直接在代码中指定的，而是从数据中学习的。如果输入数据有一些缺陷，那么我们不能期望 ML 模型会产生最佳结果。
- 最后，确保 ML 系统不仅在开发和发布阶段正确运行，而且在生产阶段也能继续正确运行，这一点至关重要。在传统的软件中，测试只在开发环境中运行，并且假设如果一段代码进入生产环境，它一定已经被测试并正常工作。在 ML 项目中，随着时间的推移，一些外部条件可能会导致数据转移，或者我们可能会改变数据源和提供者。这就是为什么我们需要使用输出日志和仪表板继续测试和监控 ML 系统。
- 机器学习测试的挑战
正如我们在上一节中所描述的，测试 ML 项目比测试传统软件要复杂得多。除此之外，还有很多事情需要我们注意。特别是因为它们中的一些发生在 ML 系统管道的下游。例如，预测中的异常可能不是因为模型，而是因为输入数据。
ML 项目中的一些关键问题是:
数据问题:缺失值、数据分布偏移、设置问题、无法再现输入数据、低效的数据架构等。
- 模型问题:模型质量低、模型大、包版本不同等。
- 部署问题:环境不稳定、代码破损、培训服务不对称等。
- 正因为如此，在本文中，我们将提出一些可以减轻这类问题影响的测试。
机器学习中自动化测试的类型
机器学习中自动化测试的分类没有统一的规则。因此，在下面的文章中，我们粗略地将自动化测试分成了几个类别。
烟雾测试
冒烟测试是最简单的测试类型，应该在项目开始后立即实施。冒烟测试的主要目的是确保代码成功运行。这可能听起来微不足道，但是这个测试在 ML 项目中是有益的。
通常，ML 项目包括许多包和库。这些软件包会不时提供新的更新。问题是有时新的更新会改变包中的一些功能。即使代码中没有明显的变化，逻辑中的变化也可能会带来更严重的问题。此外，也许我们想使用一些更稳定和测试更好的包的旧版本。
因此，一个好的实践是创建一个包含所有依赖项的 requirement.txt 文件，并使用一个新的测试环境运行冒烟测试。通过这种方式，我们将确保代码在除了我们的工作环境之外的至少一个环境中运行，并且我们可以安装所有需要的依赖项。这是一个常见的问题，安装一些旧的依赖，我们已经从一些旧的项目本地。
履行
为了确保代码总是成功运行，许多团队在 CI 管道中实现冒烟测试，每当有人进行新的提交时，就会触发冒烟测试。接下来，我们可以使用 Jenkins、GitHub Actions 或任何其他 CI 工具在 CI 管道中设置一些冒烟测试。
单元测试
在冒烟测试之后，要实现的下一个逻辑测试是单元测试。如上所述，单元测试隔离一个特定的组件，并分别测试它们。基本上，这个想法是将代码分割成块或单元，然后一个一个地单独测试。
使用单元测试更容易发现 bug，尤其是在早期开发周期。调试代码非常方便，因为我们能够分析孤立的部分，而不是整个代码。此外，它有助于设计更好的代码，因为如果很难将代码的某些部分隔离出来进行单元测试，这可能意味着代码的结构不是很好。
根据经验，开始编写单元测试的最佳时机是我们开始将代码组织成函数和类的时候。这是因为，在 ML 项目开发的早期阶段，编写测试是浪费时间，而且为准备部署的系统编写测试也可能为时已晚。
履行
编写单元测试函数的标准模式包括以下步骤:
The standard pattern of writing a unit test function includes steps:
1 定义输入数据
- 2 用输入数据执行我们想要测试的逻辑并得到结果
- 3 定义预期结果
- 4 比较实际结果和预期结果
- 有很多单元测试的例子。基本上，对于可以逻辑分离的代码的每一部分，都可以编写单元测试。单元测试的一些例子包括测试输入数据、特性、模型输出等等。
Python 中默认的单元测试框架是 Unittest 。它支持测试自动化，共享测试的设置和关闭代码，将测试聚合到集合中，以及测试独立于报告框架。
此外，Unittest 拥有 unittest.mock 模块，该模块支持使用模拟对象来替换测试中的 ML 系统部分，并断言它们是如何使用的。为此，它提供了一个模拟类，旨在取代整个项目中测试 doubles 的使用。模拟跟踪我们如何使用它们，允许我们断言代码对它们做了什么。
另一个旨在帮助编写应用程序单元测试的库是 Pytest。Pytest 建立在 3 个主要概念之上，包括测试功能、断言和测试设置。它有一个用于编写测试的命名约定，允许自动运行测试。
集成测试
单元测试之后，测试组件如何协同工作是很有用的。为此，我们使用集成测试。集成测试不一定意味着测试整个 ML 项目，而是作为一个单元测试项目的一个逻辑部分。
例如，功能测试可能包括几个单元测试，但它们都是一个集成测试的一部分。集成测试的主要目标是确保模块在组合时能够正确交互，并且符合系统和模型标准。与可以独立运行的单元测试不同，集成测试在我们执行管道时运行。这就是为什么所有的单元测试都可以成功运行，但是集成测试仍然会失败。
在传统的软件测试中，测试只在开发阶段运行，因为它假设如果一个代码进入生产阶段，它一定已经被测试过了。在 ML 项目中，集成测试是生产管道的一部分。对于不经常执行的 ML 管道，总是将集成测试与一些监控逻辑结合在一起是一个很好的实践。
履行
Unit and integration tests in development and production | Source
集成测试可以在没有任何额外框架的情况下编写，直接集成到代码中作为断言语句或“try”–except 条件。很可能，我们大多数人已经编写了一些集成测试，甚至没有意识到这一点。因为它们可能非常简单，所以建议在开发的早期阶段将它们包含在 ML 项目中。
至于单元测试，有很多例子可以用集成测试来测试。例如，我们可以测试一些数据属性，如空值的存在、目标变量的分布，确保模型性能没有显著下降，以及其他类似的事情。
尽管集成测试可以在没有任何附加包的情况下编写，但是有一些包会有所帮助。例如，使用 Pytest，可以对特性管道运行集成或端到端测试。你可以在这里读到这个。
回归测试
通过回归测试，我们希望确保我们不会遇到一些我们以前见过并已经修复的错误，也就是说，我们希望确保代码中的新变化不会重新引入一些旧错误。因此，在提交 bug 修复时，编写一个测试来捕获 bug 并防止将来的退化是一个很好的实践。
在 ML 项目中，当数据集变得更加复杂，模型定期重新训练，并且我们希望保持模型的最低性能时，可以使用回归测试。每当我们遇到一个困难的输入样本，而我们的模型输出了一个错误的决策时，我们可能会将它添加到一个困难案例数据集中，并将该测试集成到我们的管道中。
履行
例如，如果我们正在处理一个计算机视觉模型，并且我们的子样本包含具有特定类型噪声(如带状噪声)的图像，那么在这种特定情况下，我们的模型可能会产生非常糟糕的结果。也许我们没有想到我们的输入数据会有这种噪声，因为我们的相机有一些暂时的缺陷导致了它。此外，目前修复模型可能过于复杂。在这种情况下，编写回归测试是一个好主意，以防万一来处理这个问题，并了解条带噪声是否可能是未来潜在的不正确模型结果的原因。
除此之外，回归测试可以用来防止一些尚未发生但将来可能会发生的错误。例如，如果我们正在为自动驾驶车辆构建一个 ML 系统，我们需要考虑现实世界中可能发生的所有可能情况，即使我们没有这些数据。或者，如果我们的计算机视觉模型从前面的例子中得到一个带有新型噪声的图像子样本，如高斯和类似噪声，那么测试一下情况。
没有特定的库来编写回归测试，因为它们都是不同的，并且依赖于项目。
数据测试
顾名思义，数据测试包括 ML 项目中与任何类型的数据测试相关的所有测试。在大多数情况下，除了冒烟测试之外，之前的所有测试都可能包括数据测试。关于数据测试的单独部分的目的是给出一些想法和例子，说明当我们处理数据时可以测试什么。
由于大多数 ML 项目的行为严重依赖于数据，这一部分尤其重要。下面，我们将介绍一些对数据验证有用的测试。
数据和特性期望:检查数据的某些属性会很有用。例如，人们期望一个人的身高是正数，并且超过 3 米；或者，如果我们正在处理图像，我们很可能知道图像的属性。即使我们不知道，也有可能从测试集中得出结论，并根据统计意义对未来做出一些假设。
- 特性重要性:了解每个特性提供的价值是有益的，因为每个增加的特性都有工程成本，并且在 ML 管道中消耗时间。有一些特性重要性方法，如置换特性重要性，可以定义为测试，并在每次添加新特性时运行。
- 新数据或新功能成本:测试额外的数据是否会消耗太多资源，是否真的值得。我们想要测量附加的特性是否增加了显著的推理延迟或 RAM 使用，并基于此决定我们是否真的想要在 ML 项目中保留该特性。
- 禁止的或错误的数据:我们希望确保这些数据可以合法使用，并且在将来不会引起法律问题。此外，我们需要确保数据来自经过验证的来源或供应商，并且数据源是可持续的。
- 数据的隐私控制:如果 ML 项目包含一些敏感数据，确保不会出现一些可能导致严重后果的数据泄露。我们可以测试管道数据的访问是否安全。
- 履行
大多数数据测试都与单元测试和集成测试相关。因此，为了实现其中的一些，我们需要遵循来自单元和集成测试的最佳实践。数据测试中最重要的事情是，我们对数据有预先的期望，并且希望这些期望在系统的实际状态中持续。
让数据测试部分在你的项目中排序的一个真正伟大的包是远大前程。它通过数据测试等方式帮助数据团队消除管道债务。你可以在这篇文章中了解更多。
模型检验
就像数据测试一样，模型测试可以是单元测试、集成测试或回归测试的一部分。这种测试是专门针对 ML 项目的，因为在传统的软件测试中，模型很少存在。下面，我们提到一些对模型测试有用的测试:
审查并提交模型规范:对模型规范进行适当的版本控制非常重要。同样，了解为重现特定结果而运行的确切代码也很重要。这就是为什么在主分支上推进代码之前，仔细检查新模型的结果是很重要的。
- 模型过度拟合:使用适当的验证技术和监控模型度量，确保没有模型过度拟合。使用单独的样本外检验来再次检查模型的正确性。
- 模型调整不够:使用适当的超参数调整策略，如网格搜索或更复杂的元试探法。可以编写一些带有网格搜索或随机搜索的自动化测试，当一个新的特性被引入时就会被触发。
- 模型陈旧的影响:例如，一些内容推荐系统和金融 ML 应用会随着时间的推移而发生变化。如果 ML 模型不能保持足够的更新，我们说这个模型是陈旧的。我们需要了解模型过时如何影响预测，并确定更新模型的频率和时间。解决这个问题的一个方法是执行测试，将旧模型或具有旧功能的模型与当前模型进行比较，并了解模型的老化，从而制定再培训计划。
- 简单的模型并不总是更好:对照一些简单的基线模型测试当前模型。
- 履行
模型测试可以作为单元测试或集成测试的一部分来实现，但是有一些有趣的包可以提供帮助。
例如， Deepchecks 是一个 Python 包，允许我们以最小的努力深度验证 ML 模型和数据。这包括对各种问题的检查，包括模型性能、数据完整性、分布不匹配等。
一个更有趣的包是清单。它包含测试 NLP 模型的代码，如论文“超越准确性:NLP 模型的行为测试与清单”中所述。
CheckList 提供了一种与模型和任务无关的测试方法，它使用三种不同的测试类型来测试模型的各个功能:
最小功能测试(MFT) :旨在创建小型且集中的测试数据集，对于检测 ML 模型何时使用快捷方式来处理复杂输入而没有实际掌握学习能力特别有用。
- 不变性测试(INV ):它是关于对输入应用标签保留扰动，并期望模型预测保持不变。例如，改变位置名称与 NER 能力的情绪分析任务。
- 方向预期测试(DIR) :类似于 INV，除了标签预期以某种方式变化。比如在句子中加入否定词，观察情绪变化。
- 监控机器学习测试
非常重要的是，不仅要知道 ML 项目在发布时工作正常，而且要知道它会随着时间的推移继续正常运行。一个好的做法是使用显示相关图表和统计数据的各种仪表板来监控系统，并在发生异常情况时自动发出警报。
监控服务系统、培训管道和输入数据对 ML 项目至关重要。正因为如此，为连续检查 ML 系统创建一些自动化测试将是非常有益的。其中一些列举如下:
依赖性和来源变化:通常当一个 ML 系统在生产中工作时，它消耗来自各种来源的数据来生成有用的特性。源系统中的部分中断、版本升级和其他更改会极大地破坏模型训练。因此，实现一些测试来监视数据源中的依赖性和变化是很有用的。
- 生产中的监控数据:我们在模型测试部分讨论的大多数测试都可以作为生产中的监控测试来实现。其中一些与输入数据差异、数据分布变化、输出异常等有关。
- 生产中的监控模型:与监控数据测试类似，大部分模型测试都包含在模型测试部分。其中一些是关于监控模型的陈旧性、训练速度的变化、服务延迟、RAM 使用等等。
- 履行
包含在 ML 项目中的一个好工具是 Aporia 。这是一个在生产中监控机器学习模型的平台。数据科学团队可以使用 Aporia 的 monitor builder 轻松创建用于检测漂移、意外偏差和完整性问题的监视器，并接收实时警报，以便进行进一步调查和根本原因分析。
Arize AI 是一个 ML 可观察性平台，使 ML 从业者能够更好地检测和诊断模型问题。它有助于理解机器学习模型在现实世界中部署时的行为方式。Arize AI 的主要目标是监控、解释、故障排除和改进机器学习模型。
WhyLabs 允许数据科学家深入了解他们的数据集，并监控他们部署的 ML 模型。它提供了与 Python 或 Java 的简单集成，只需最少的维护工作。WhyLabs 是一个平台，使开发人员能够轻松维护实时日志和监控 ML 部署。
尽管大多数测试可以用我们开发 ML 项目、发送通知和构建仪表板所用的相同编程语言来编写，但是有一些有用的工具是专门为帮助实现测试结构和逻辑而开发的。
虽然我们已经在上面讨论了它们，但是本节试图通过提及它们所附带的测试条款的类型来对它们进行总结。
While we have already discussed them above, this section seeks to summarize them all by mentioning the type of testing provisions they come with.
| 詹金斯 | GitHub 操作 | 单元测试 | Pytest | 深度检查 | 清单 | Aporia | 艾瑞泽·艾 | 为什么实验室 | 烟尘测试 |
|---|---|---|---|---|---|---|---|---|---|
| 单元测试 | |||||||||
| 集成测试 | |||||||||
| 回归测试 | |||||||||
| 数据测试 | |||||||||
| 模型测试 | |||||||||
| 监控测试 | |||||||||
| 结论 |
机器学习中的自动化测试是一个相对较新的话题，每天都在发展。随着复杂 ML 系统的出现，需要构建更复杂的测试解决方案。在本文中，我们介绍了测试 ML 项目的各种不同的方法。此外，我们还介绍了几个可以帮助我们在项目中实现测试逻辑的工具。
您可以参考本文中提到的资源来阅读更多关于自动化测试、相关工具以及如何使用它们来实现您的优势。
资源
Resources
AutoML 解决方案:作为一名数据科学家，我喜欢和不喜欢 AutoML 的地方
原文：https://web.archive.org/web/https://neptune.ai/blog/automl-solutions
有一种观点认为，AutoML 可能会让很多数据科学家失业。会吗？简而言之，没有。事实上，即使 AutoML 解决方案变得更好 10 倍，它也不会使任何行业的机器学习专家变得无关紧要。
你可能会问，为什么这么乐观？因为尽管 AutoML 是一个技术奇迹，但它并不是灵丹妙药。数据科学家做的大部分工作不是建模，而是数据收集、领域理解、弄清楚如何设计一个好的实验，以及哪些功能对后续的建模/预测问题最有用。大多数 ML 工程师和其他数据专业人员也是如此。
Inspired by CRISP-DM workflow, but with all the real-world feedback loops | Image by author
事实上，AutoML 听起来像某种算法魔术，在接收到你的标记数据后，会输出最好的 ML 模型。说实话，AutoML 有点像与精灵互动:“小心你的愿望”，或者更确切地说，你给它什么数据。
还记得那句谚语吗，垃圾进——垃圾出？由于 AutoML 系统中额外的反馈回路，与经典的 ML 解决方案相比,“垃圾”会被放大到超出你的想象。我个人不够小心，几次落入这个陷阱，但后来更多。
Based on personal experience and the references at the end of the article | Image by author
在做出任何声明之前，我们首先需要了解 AutoML 是什么，它不是什么。
AutoML 的当前状态
实际上，AutoML 可以采取不同的形式。有时一个相对有效的超参数优化工具(HPO)可以选择不同的 ML 算法，可以被称为 AutoML 工具。几个值得注意的例子是 TPOT 、 AutoKeras 、 H2O.ai AutoML (不要和无人驾驶. ai 混淆)。我甚至可以推测，如果有一个 GUI/Web 界面来与这些工具进行交互，并且有足够的营销预算，人们可以利用这些工具创建一个创业公司。
An example AutoML loop. Image by TPOT from Epistasis Labs | Source
对于一些深度学习的人来说，AutoML 将是关于 NAS，又名网络架构搜索算法或方法。这些方法实际上是一个非常有趣的研究方向，给我们带来了 EfficientNet、AmoebaNet 等计算机视觉架构，以及像飞镖、 ENAS 、 PNAS 等方法。几个著名的 NAS 开源工具是微软的 NNI 和 MXNet 自动增长。
回想一下我对 HPO +尼斯界面==利润 的猜测？这更多的是一种简化，但一些公司确实这样做了，当然增加了功能、可扩展性、安全性和客户服务，这很有效，它确实帮助组织让数据科学家解决了许多问题。H2O 的无人驾驶. ai 可能是这类解决方案中最知名的，但部分 DataRobot 和data aiku 的产品也在一个易于使用的界面后面进行自动管理。
我相信特别值得一提的是来自 Google、Azure 和 AWS 等云巨头的 AutoML 产品。我没有太多使用 Azure 和 AWS 的经验，但我可以谈谈我使用 Google 的 Vision AutoML 的经验。根据我的实验和知识，这些解决方案是在面向开发人员的产品中实际使用 NAS 的少数几个解决方案之一，这太棒了。
请注意，NAS 不会用于快速运行。我最后一次检查，特别是 Google Vision AutoML 使用迁移学习进行快速运行，使用 NAS 进行 24 小时运行。我已经有一段时间没检查过了。
让我们把这些信息组织一下，好吗？下面的表格应该让你从高层次上了解不同的工具是如何以这样或那样的方式实现 AutoML 的。
| 名字 | 开源？ | 本地还是托管？ | 特征 | 类型 |
|---|---|---|---|---|
【HPO+NAS+其他一些有趣的东西
| |
| | | |
NAS，支持处罚大型号
| |
| | | |
NAS，根据场景有基准它首先尝试
| |
| | | |
构建预处理+算法+集成流水线
|
【HPO++】，其实用的是遗传算法
|
| | | |
采用多种预处理、特征编码和选择方案
|
【HPO ++拥有更好的 UI，w 综合评测
|
| | | |
基本上是免费版的无人驾驶. ai
|
HPO++，有 Web UI，w 综合评测
|
| | | |
基本上是托管的，简单使用 NAS
|
转移学习+ NAS，极简 UI 与 w 综合评测
|
| | | |
具有 XAI、推理服务器、模型和实验管理的集成平台
|
AutoML 部分好像是 HPO++ w 综合评测和 XAI 还有一大堆其他玩意儿
|
从根本上说，AutoML 是在用计算预算(或时间)换取专业知识。如果你不知道如何解决问题，你会选择最大可能的搜索空间，等待搜索完成。另一方面，如果你想削减强大服务器的开支，或者不想等一个星期才得到结果，和 知道一些关于你的问题的事情，你可以减少搜索空间，更快地找到解决方案。
AutoML 应该更像是一个探索工具，而不是一个最佳的模型生成工具。它不能替代数据/ML 专业人员。
AutoML–好零件(优点)
好的，我认为我们已经确定 AutoML 不是解决所有 ML 问题的灵丹妙药。那 AutoML 有什么用？
加快模式探索阶段
老实说，对于我们大多数人来说，通常我们在自己工作的领域并不特别有经验。注意，我说的领域不是指计算机视觉、NLP 或时间序列，而是指广告、电子商务、金融、细胞生物学、基因组学，这个列表还可以更长。为了应对挑战，企业需要快速有效的结果。
我有一个半个人的故事，讲的是 AutoML 如何在有专业知识的人和没有专业知识的人之间架起一座桥梁。几年前，我在一个关于深度学习和强化学习的暑期学校。组织者安排了一个 Kaggle 比赛，基本上是试图预测一些时间序列。我有意省略了细节，你知道，这是半个人化的，所以…无论如何，有博士和博士后，都试图适应极其复杂的模型，其他一些人专注于创造有意义的功能。我，对于处理时间序列的知识有点浅薄，加上纯粹的懒惰，决定我可以只使用 AutoML，即 TPOT。事先没有太多 EDA，功能工程就更不用说了。我的成绩大约在第 50 百分位。现在，你认为获奖作品是什么？也是 TPOT，但进行了基本的异常值删除，将日期和时间转换为分类特征，如 is_it_weekend 等，并运行 TPOT 2 天。
这个故事的寓意是——如果你缺乏专业知识，或者没有时间学习，或者只是懒惰，AutoML 是一个相当好的起点。这也释放了时间去开发那些特性，从我的故事中可以看出，特性确实有所不同。
虽然我的故事表明了这一点，但这并不总是关于交付最终的模型，有时分析生成的候选模式也会有所帮助。例如，无论最佳解决方案是使用朴素贝叶斯、决策树、线性分类器，还是 AutoML 试图创建越来越复杂的集成，这意味着您还需要一个非常有表现力的模型来解决您的问题。
非常好的基线
所以，你在做一个新的 ML 项目。你做的第一件事，就模型而言——你实现一个简单的启发式基线，然后看看你在哪里。第二，您尝试一个简单的 ML 解决方案，并分析它对基线的改善程度。在这个阶段之后，你可以尝试做的一件事，至少是我喜欢做的，是尝试估计你的预测性能上限，让 AutoML 解决方案最大限度地利用你的数据和预处理。
它不仅有时会快速地交付卓越的结果，而且还会将您的感知转移到更好的功能上。
请注意，有时您没有资源或者受到其他一些因素的限制。所以 YMMV，但是在处理新项目时，一定要记住 AutoML 的这个用例。
快速识别–什么有效，什么无效？
特征变换、算法、它们的超参数以及组合所述算法的方式的可能组合的空间创建了可能的 ML 模型的巨大搜索空间。即使你知道对于给定的问题，什么解决方案可行，什么不可行，这仍然是一个巨大的搜索空间。AutoML 可以帮助相当快速地测试什么配置更有可能工作。
“怎么会？”你可能会问。通过多次运行 AutoML，并跟踪:
- 哪些配置更常被选中，
- 多久一次，
- 丢弃的是什么，
- 它下降的速度有多快，
- 诸如此类。
在某种程度上，这是某种 meta-EDA。有人可能会说——探索性模型分析。
你为什么会对它感兴趣？我们想要最好的模型，为什么不直入主题呢？因为我们的目标不是一个好的最终模型，而是了解什么可行，什么不可行。基于这种理解，我们可以更好地解决问题。即使有了 AutoML，也没有人能让你免除这些可爱的问题，比如需要定期根据新数据重新训练你的模型，以及试图减少 ML 的预算支出。
AutoML–坏零件(缺点)
虚假的安全感
老实说，这是我最讨厌 AutoML 的一点。感觉像魔法一样，让你变懒。就像任何自动化一样，你用得越多，失败的灾难性就越大。
正因为如此，很容易引入数据 bug。由于 AutoML 有时不透明的性质，这些错误很难被发现。
关于这一点，我也有一个亲身经历——一个我可能永远不会厌倦回忆的经历。我们正在研究一个细胞分类问题，阳性和阴性细胞之间的区别即使对人类来说也很难观察到。只有中小企业才能对这些图像进行准确的分类。我们花了几个月的时间试图创建一个计算机视觉模型来自动化这项任务。结果并不好。即使是最定制的解决方案，考虑了我们数据集的各种属性，能够从少量数据中学习而不会过度拟合，准确率也接近 69%。关于一个二元分类问题。
在那个阶段，我们有机会使用仍处于测试阶段的 Google Vision AutoML。快速测试的结果比我们的稍差。最终，我们决定运行完整的训练，这有点昂贵，为了充分利用我们的数据，我们手动增加图像以增加数据集的大小。你瞧，98.8%的准确率。大获成功！
只有我对此表示怀疑。经过几个月失败的实验，尝试了数百个超参数，使用了数十种方法，我无法相信一些 NAS 可以解决这个问题，并且以光年为单位。我的上司正准备向投资者和其他利益相关者宣布我们出色的业绩。我坚持要我们检查一下发生了什么事。几个星期后，通过几十张部分遮挡的图片，完全的困惑和绝望，我想通了。
在使用 Google Vision AutoML 之前，我们手动扩充了数据集，但我们没有手动指定拆分。因此，同一图像的增强版本处于训练、测试和验证分割中。模特只是记住了图像。一旦我们修复了它并再次运行它，我们得到了大约 67%。
这个故事的寓意是——不要对 AutoML 感到舒服，它会在背后咬你一口。
倾向于过度优化/过度拟合
根据数据的性质和模型验证设置，一些 AutoML 解决方案很容易过度拟合。我所说的数据本质是指它的属性，比如标签分布、有多少异常值以及数据集的整体质量。公平地说，通常不是工具的错，而是你的错，这意味着大多数时候过度拟合的原因在你的评估设置中。所以，注意你如何评估候选人，你如何分割你的数据，如果使用时间序列——我不羡慕你。像对待超参数优化一样对待 AutoML 过程，并使用类似嵌套交叉验证的东西相应地分割你的数据。
过于强调优化
正如已经提到过几次的，正确的思考方式是把 AutoML 看作一个使能器，让你更关注事物的数据方面。但是在现实中，许多人陷入了模型超参数和一般模型是 ML 项目中最重要的因素的想法，因为 AutoML 解决方案有时可以显示出极好的改进，加强了这种想法。
由此产生的模型部署起来可能会很乏味
我曾经有机会，或者不幸，取决于你什么时候问我，从事广告价格预测。最终，我尝试使用 AutoML，也就是 TPOT。它运行得很好，并且给出了非常好的结果，所以我们决定部署我们性能最好的模型。我被要求将模型转换成 Golang 或者至少 Java 后端能够理解的东西，因为部署 Python 服务是不可行的。
经过几个小时的研究，我发现了 PMML，而且我已经知道了 ONNX。长话短说，PMML-有能力的 libs 在他们能阅读的模型上有很大的不同。因此，虽然我的由 TPOT 生成的整体 Python 模型转换成 PMML 格式没什么问题，但让一个围棋程序明白这是不可能的。为什么？因为 Go lib 不知道如何处理集成、预处理和大多数模型，除了一些决策树、线性分类器，也许还有朴素贝叶斯。至于 ONNX，将 scikit-learn 集成管道转换为 ONNX 也被证明是有问题的。
通常，AutoML 候选模型会变得非常复杂，将它们转换成任何东西都会变得令人头痛。这就是为什么许多生产 ML 主要基于线性分类器、朴素贝叶斯和随机森林以及 GBDTs。您很少会看到不同分类器的复杂堆叠集合。它们天生就很慢，而且很难快速运行或与非 Python 环境兼容。
难以分析/调试模型
回想一下 Google Vision AutoML 的故事。谷歌没有任何设施来深入检查模型，就像 XAI 一样。此外，没有办法获得对个别图像预测的某种可解释性或解释。结果，我不得不混淆部分输入图像并分析预测。通常，AutoML 的可解释性和调试工具是一个特殊的问题。自动生成的模型往往非常复杂，因此很难分析。此外，在大多数情况下，复杂性会增加一倍，因为复杂的模型需要更多的时间来运行预测，而这反过来又会使使用黑盒分析工具获得解释变得更加繁琐。
汽车与数据科学家
在我给出一些数字之前，请记住，根据您试图解决的问题，您对 AutoML 的体验会有很大的不同。所以，让我们开始吧。
关于 AutoML 基准的一句话
关于 AutoML 基准测试的文献相当稀少，而且大多数时候都是比较 AutoML 解决方案的性能，而忽略了人的性能。此外，这些研究大多是关于表格数据集。幸运的是，我们在建立标准化的方法来评估不同 AutoML 解决方案的性能方面做了一些工作。
首先是 AutoML 基准，然后还有一个所谓的 Kaggle 基准，你可以在本文和这篇中等文章中找到的例子。关于在计算机视觉和文本分类任务中使用 AutoML/NAS 的信息，最简单的方法是检查 NAS Bench (mark)和少数其他比赛的结果。尽管如此，人们主导的设计和算法主导的设计之间没有太多的比较分析。
所有的希望都失去了吗？
不。一方面，你可以试着用上面提到的数据集运行你的模型，看看你对 AutoML 有多好/差。当然，这不是你想要的答案。输入 “人对机器:AutoML 和人类专家在网络钓鱼检测中的作用” 。我给你讲讲它的要点，还有一点个人意见。
Comparisons of the AUC score and training duration of the best model built using AutoML and non-AutoML frameworks | See the article for more details*
*需要注意的一点是——持续时间是根据模型在给定数据集上接受训练所需的时间来计算的。
-
作者得出结论，当应用这些解决方案的数据集在它们的类中有一些重叠时，AutoML 模型明显优于人，并且通常显示高度的非线性。换句话说，硬数据集。否则，性能相当于不使用 AutoML。他们还声称，与非 AutoML 相比，AutoML 解决方案通常需要更长的时间来创建高性能的模型。
-
这里有一个问题，作者没有提到提出一个高性能模型所需要的时间。为什么你会问？因为对于他们的非 AutoML 解决方案，他们采用现有的 scikit-learn 算法，根本不调整它们。这一切意味着什么？首先，对持续时间的结论要有所保留。其次，AutoML 只对有噪声、重叠类和高度非线性的硬数据集有意义。否则，您最好使用一些现成算法的默认设置。
他们对数据集复杂性和 AutoML 优势之间的相关性的发现与我的个人经验和 AutoML 基准测试的结果非常一致，在更复杂的数据集上，一些 AutoML 解决方案在 AUC 和准确性方面比手动创建的模型有 10%以上的优势。你可能还记得我在 AutoML cons 第一部分的故事，我花了几个月的工作，谷歌的 AutoML 几乎在 24 小时内匹配。
所有这些信息对你有什么帮助？如果你知道你的数据集是行为良好的，也许不要用 AutoML。但是你怎么知道？您可以尝试运行几个经典的 ML 模型，看看它们的交叉验证性能如何变化。或者只是“看看”你的数据。
就我个人而言，我首先使用 AutoML 作为快速探索工具，然后当所有希望都破灭时。从不介于两者之间。为了帮助你对 AutoML 做出自己的决定，请查看下面的链接，并进行实验。
进一步阅读 AutoML 方法的基准，包括针对人类的基准:
如果…每个人都一直使用 AutoML 会怎么样？
在我们深入这个思想实验之前，回想一下 AutoML 是通过用计算换取专业知识来工作的。如果我们一无所知，却拥有巨大的计算能力，这就是“工具”。让我们分析一下，如果我们在一家更经典、更成熟的企业和一家创新型公司中全力以赴，会发生什么。
像福特这样的大企业
根据哪个部门将使用 AutoML 而不是他们现有的 ML/DS 工具，我们可能会有一些好的结果，例如在市场营销和销售方面，有些坏的结果在物流和规划方面，可能绝对是垃圾结果，如 ADAS，这是高级驾驶辅助系统和模拟软件。此外，公司运行这些 AutoML 解决方案所需的计算能力的增加肯定会使他们花费一大笔钱。
即使他们有钱和不理性地在 AutoML 上全押，这仍然是一个坏主意，因为对模型可解释性的严格要求，这是 AutoML 产生的复杂集合模型所不能提供的。很难通过。
像 Palantir 这样的创新公司
如果我们具体谈论 Palantir，我相信无论有没有 AutoML，他们的软件都不会真的关心，因为它是关于集成和智能地使用一个组织的数据资产。尽管如此，大多数分析并不需要非常先进的 ML 算法，所以使用 AutoML 将是浪费金钱。当最佳模型仍然是线性回归或决策树时，为什么要使用它。为什么你会问？因为他们的客户是非常重视模型可解释性的组织。
对于任何其他创新公司来说，AutoML 都有自己的位置，但仍有一些严重的限制。很多时候，这些组织面临的问题不能简单地用监督分类或回归来描述，这使得使用 AutoML 变得很棘手。
用例越创新，就越难使用现成的解决方案。你能想象使用开源的 AutoML 工具来开发新药、复合材料，或者优化专用芯片上的晶体管布局吗？我也没有。这些任务很容易也应该被当作研究方向。有人需要创业想法吗？
分析
也许你已经注意到，行业采用 AutoML 的一个主要问题是可解释性。你可能会认为“哦，但也许他们没有听说过像，或 XAI(可解释的人工智能)这样的东西？那应该会改变他们的想法。我向你保证，不会的。反正不会很快。
*你看，模型的可解释性和可解释性之间有很大的区别。前者意味着模型可以被理解，因为它是。后者通常意味着有一种方法可以推断出为什么会做出某种预测，或者在更学术/前沿的情况下，模型会“告诉你”其预测背后的推理。也许你已经看到了这里的问题。没有人能向你保证这个解释是正确的。
这就是为什么，例如，有成千上万的人开发基于神经网络的计算机视觉模型，根据他们的 X 射线扫描来检测患者是否患有 COVID，但没有任何主要的医疗机构使用这些模型。医生需要很好地理解为什么做出这些预测。与法律、会计、销售、市场营销和所有其他部门一样，对模型可解释性有不同的、有时是不可协商的需求。这就是为什么组织仍然热衷于线性模型和决策树，而回避密集的神经网络。
那么什么是 AutoML 的好用例呢？
现在，让我们看一些可以从 AutoML 中获益最多的具体用例:
批处理作业
大多数 AutoML 工具没有考虑模型的复杂性/计算需求，结果给你非常好的模型，这可能是非常慢或计算要求高的。因此，在交互式或流式场景中使用这样的模型是不可能的，所以剩下的就是使用它们进行批处理作业。
也许将 ML 作为批处理作业运行听起来并不令人兴奋，尤其是在您阅读了部署 ML 模型与用户直接交互的令人难以置信的工程技术，甚至可能在边缘设备上，或者人们如何在流场景中使用 ML 模型以近乎实时的方式处理数十亿个事件之后，但是请相信我，许多企业的流程完全可以按照计划在几个小时、几天甚至几周内运行一次。你肯定听说过，在商业领域，最快的结果胜过最准确的结果，但是在很多情况下，准确性比时间更重要。
测试水的问题
我以前说过，现在我要再说一遍——AutoML 最适合快速原型开发。这是我最喜欢的 AutoML 用例，它可以帮助我评估性能的上限，以及我当前的数据集和预处理/特征工程。当你采用这种思维模式时，你会慢慢转向一个更加以数据为中心的 ML/AI 范式，因为你只是假设你总是会得到一个优化的模型。
请记住，这应该在 EDA 阶段的之后的完成。此外，如果可能的话，根据你的 EDA，尽量减少搜索空间。如果属性和目标变量之间没有显著的相关性，您可以放心地从搜索空间中删除线性分类器。我喜欢做的是使用 AutoML 工具在缩小的搜索空间内运行一些快速实验，只使用最简单的模型，由于可复制性，使用不同的随机种子，看看哪些是性能最好的模型。基于此，我可以为下一轮调整搜索空间。
外卖食品
AutoML 是福也是祸。就像任何工具一样，它可以被正确使用以获得最大的利益，也可以被滥用，然后说坏话。
要记住的一点是不要滥用它。
甚至在分析您的数据或理解您的问题之前，在任何问题上抛出 AutoML 都是诱人的。不要成为那样的人。
你应该从这篇博客文章中得到的另一件重要的事情是:将你使用 AutoML 节省的所有时间投资在特性工程上。你可以这样想，如果你的数据集有最好的模型，你还能做些什么来提高你的机器学习系统的性能呢？显然，您可以获取更多的数据，或者确保数据具有更高的质量或更丰富的特性。当然，AutoML 不会给你一个完美的模型，但基本原理是成立的。随着建模(几乎)的完成，更好的性能仍然是可能的，您应该专注于改进您的数据和特性以达到那些性能目标。如果结果看起来太好——调试它。
最重要的是，确保你非常了解业务需求。因此，在强大的 CPU 和 GPU 上运行 AutoML 几个小时之前，花几分钟时间讨论一下您的用户是否会欣赏预测性能的轻微提高，并且不会介意模型可解释性的缺乏。
如您所见，根据您询问的对象，AutoML 可以有完全不同的含义。我记得我第一次发现 AutoML 销售的大部分产品都可以通过多核工作站、超参数优化库来完成，并且所有这些都包装在一个简单的用户界面中时，我有些失望。只要对你有用，我想。
参考*
面向 MLOps 的 Azure ML (AML)替代方案
原文：https://web.archive.org/web/https://neptune.ai/blog/azure-ml-alternatives-for-mlops
Azure 机器学习(AML)是一种基于云的机器学习服务，面向数据科学家和 ML 工程师。您可以使用 AML 来管理机器学习生命周期——训练、开发和测试模型，还可以快速、高效、高质量地运行 MLOps 流程。
Azure Machine Learning | Source: Azure ML
对于希望扩大 ML 运营规模并释放人工智能潜力的组织来说，AML 等工具非常重要。像 AML 这样的一体化解决方案简化了 MLOps 流程。创建推动业务增长的机器学习解决方案变得更加容易。
但是，如果您不需要像 AML 这样的全面 MLOps 解决方案，该怎么办？也许您想要构建自己的堆栈，并且需要特定的工具来完成跟踪、部署等任务，或者管理 MLOps 的其他关键部分？你很幸运——在这篇文章中，我们回顾了针对 MLOps 的 Azure 机器学习(AML)的多种替代方案。
Azure ML 到底是做什么的？
为了找到反洗钱的替代方案，首先，我们需要准确分析反洗钱的作用:
- 实验跟踪
- 模型管理
- 模型部署
- 模型谱系
- 模型监控
- 数据标记
1.实验跟踪
实验跟踪记录您在 ML 实验中关心的每一条信息。机器学习是一个迭代的过程，所以这真的很重要。
Azure ML 为机器学习环境中的所有指标提供实验性跟踪。设置 AML 工作区以获取所需数据，可以更轻松地复制实验和比较结果。
2.模型管理
机器学习中的模型管理是关于管理从模型创建到模型部署的 ML 生命周期中的每个过程。这是任何 ML 管道的基本部分。AML 用于管理机器学习项目周期中的模型。有效的模型管理使用日志条目和模型/数据版本化来创建更好的实验环境。
使用 Azure ML，您可以控制实验并增强科学家之间的协作。该工具将与您的实验相关的参数记录在一个中心位置，您可以在这里看到每个模型，并根据需要复制它。
3.模型部署
模型部署让你的模型对人们有用。机器学习操作中的模型部署通常变得复杂和具有挑战性，因为它需要计算能力和资源。在这方面，Azure ML 特别有帮助。
使用 Azure ML Studio，您可以将 ML 模型部署到云中，将它们转换成 web 服务，并对它们进行测试。此外，它有助于在将应用程序发送到云之前对其进行打包和调试，并提高部署的成功率。
4.模型和数据谱系
数据科学家和 ML 工程师面临的一个大问题是向他们的模型提供准确的数据。Azure ML 对于在机器学习过程中处理模型和数据血统很有用。Azure ML 监控模型历史并跟踪它所使用的数据的变化。
你可以看到一个模型——以及支持它的数据——在 ML 生产周期的各个阶段是如何发展的。模型和数据沿袭很重要，因为它有助于您提高生产模型所使用的数据的质量。这减少了错误预测的机会，使模型更有价值。
5.模型监控
高效的模型监控使得在模型投入生产之前发现问题变得更加容易。像 Azure ML 这样强大的 MLOps 平台可以帮助您监控数据集的漂移、历史模型性能变化、公平性和偏见以及其他关键指标。
生产团队经常面临监控模型的预测性能，因为错误可能会导致不利的经济影响、用户信任度下降和风险暴露增加。Azure Monitor 通过记录数据指标和活动记录，让职业生活变得更加轻松。这样，您可以密切跟踪您的模型，并知道它们的预测性能何时开始下降。
6.数据标记
数据标记是为更好的训练标记原始数据的过程。在创建、管理和监控数据标签项目时，AML 中的标签非常有用。它处理图像和文本数据。可以为图像分类、对象检测(边界框)或实例分割(多边形)设置标签。
在 Azure ML 中，你可以从 Azure Marketplace 中选择一家厂商标签公司。你可以将你的本地数据集上传到 Azure Storage Explorer 。
- 协调数据、标签和团队成员，有效管理标签任务。
- 跟踪进度并维护未完成的标签任务队列。
- 启动和停止项目，控制贴标进度。
- 检查标记的数据并导出为 Azure 机器学习数据集。
Azure 机器学习是一个很棒的套件，但如果你有非常具体的需求，或者不需要 Azure 提供的选项，它可能会令人不知所措。
在 Azure ML 的 G2 人群评论中，用户提到:
- Azure ML 不符合他们特定用例的要求；它不够灵活，定制也很困难。
- 很难用 Azure 集成数据来创建模型。
- 相对于其他平台来说比较贵。
- 它的执行速度相当慢。
- 它只在网上可用，你需要强大的互联网连接才能有效地与 Azure Machine Learning Studio 合作。
因此，这里有多种可供选择的工具，你应该喜欢！
Example of experiment tracking dashboard in Neptune | Source
Neptune 是一个 MLOps 工具，为机器学习实验提供元数据存储。除了记录 ML 元数据，Neptune 还是一个跟踪实验改进的优秀工具。它可以帮助您监控正在进行的实验，并调试它们以提高性能。更好的是，你可以与他人分享你的工作，并获得有价值的反馈，以使你的模型更好。
Experiment tracking in MLflow | Source: MLflow
MLflow 是一个开源平台，用于管理机器学习工作流的各个部分，如模型构建、培训、测试和部署。它旨在标准化和统一机器学习过程。它有四个主要组件，帮助组织机器学习生命周期的不同部分。
- 物流跟踪
- MLFlow 模型
- MLFlow 模型注册表
- MLFlow 项目
MLflow 跟踪可用于实验跟踪。MLflow 擅长记录参数、代码版本、度量和与每次运行相关的工件，作为一个实验跟踪工具。
- MLflow tracking 提供可视化功能，可比较不同运行的结果。
- 它与 Java、REST API、R 和 Python 集成得很好，因此您可以轻松地记录和查询您的实验。
weight and bias(WandB)是一个平台，用于 ML 开发人员跟踪、比较、评估、版本化、可视化和共享他们的机器学习和深度学习实验。
- 它内置了与流行框架(TensorFlow、PyTorch、Keras)和工具(Kubeflow、SageMaker)的集成，可以轻松地将实验跟踪和数据版本化集成到现有项目中。
- 使用 WandB 可视化结果更容易，因为用户界面非常直观且易于导航。您可以选择在仪表板上查看您的实验数据，或者使用 WandB 公共 API 在 Python 中自动创建报告。
- WandB 对团队来说是有益的，因为它有增强协作的特性。
- WandB 将 ML 元数据存储在中央位置
| 工具 | 跟踪 | 记录 | 元数据存储 | 计划 |
|---|---|---|---|---|
实验跟踪工具对比
*Example of artifacts dashboard in Neptune | *Source
正如我们前面提到的，Neptune 提供了实验跟踪和版本控制，这是其模型管理框架的一部分。这意味着您可以鸟瞰您的实验，并跟踪模型在不同测试阶段的表现。
Neptune 还允许您在安全的中央存储库中记录、存储、显示、组织、比较和查询机器学习生命周期中生成的所有元数据。
- Neptune 为您的模型提供了一个模型注册表；
- 当你注册 Neptune 时，你会得到一个免费的管理服务选项，包括 100 GB 的存储空间、无限的实验、私人和公共项目
- Neptune 的集成列表非常广泛，涵盖了大多数流行的框架。
Model management in Metaflow | Source: Metaflow
Metaflow 是一个 python 友好的框架，用于创建和管理数据科学工作流和生命周期。它是由网飞开发的。Metaflow 为执行数据科学项目(从原型到生产)所需的基础架构堆栈提供了统一的 API。元流使用数据流范式，将程序建模为操作的有向图，并管理这些操作。
它配备了内置功能，如:
- 元流帮助您管理计算资源(GPU 等)
- it 经理外部依赖关系
- 版本、重放和恢复工作流运行
- 用于检查过去运行情况的客户端 API 适用于笔记本电脑
通过阅读元流文档了解更多关于元流的信息。
Vertex AI 是新的集成谷歌云人工智能平台。这是一个统一的人工智能平台，通过预先训练和定制的工具来构建和部署模型。它可以管理你的整个机器学习生命周期。它包括可以处理 ML 开发和实验的每个部分的工具。
Vertex AI 允许你管理你的实验，模型，版本等。，通过谷歌云控制台。它有一个 GUI，您可以在其中访问 Vertex AI 提供的所有选项，如存储管理、日志记录、监控等。
Model management in Vertex AI | Source: Author
如果你是命令行的粉丝，Vertex AI 还提供了一个用于执行 ML 任务的命令行工具，名为 gcloud 命令行工具。
Vertex AI 平台提供了一个 REST API，用于管理您在 Google Cloud 上的笔记本、工作流、数据、模型、版本和托管预测模型。
在 Vertex AI 上，你可以用笔记本电脑创建虚拟机实例，这些笔记本电脑预装了 JupyterLab ，并支持 TensorFlow 和 PyTorch 框架。它还允许笔记本与 Github 集成。
Vertex AI (Google Cloud AI)提供了一组深度学习虚拟机映像，这些映像针对机器学习和数据科学任务进行了优化。
虽然 vertex AI 平台不仅仅是模型管理，它对于个人、工具和组织来说都是一个很好的模型管理工具。
查看谷歌云人工智能文档，看看它是否有你的用例。
| 工具 | 模型注册表 | 存储管理 | 资源管理 |
|---|---|---|---|
模型管理工具对比
Streamlit 是一个开源 python 库，用于为您的 Python 数据科学项目和机器学习模型创建、管理和部署自定义 web 应用程序。
它要求您的项目位于公共 GitHub repo 上，然后您登录到 streamlit，单击 deploy app 选项，然后粘贴到 GitHub repo 中。在几分钟内，streamlit 可以将您的代码转换为 web 应用程序。
使用 Streamlit，您可以用简单的 python 代码创建应用程序的前端，它还提供了创建前端的模板。Streamlit 为您处理后端。
在 streamlit 上，开发人员可以使用 streamlit 应用程序中呈现的 Streamlit“组件”编写 JavaScript 和 HTML 来创建更多功能。它允许您从 python 脚本接收数据，也允许您向 python 脚本发送数据。Streamlit 还有一个社区制作的组件库，你可以找到已经制作好的组件并在你的应用中使用。Streamlit 兼容 OpenCV TensorFlow、PyTorch、Keras、matplotlib、Altair 等等。
在 Streamlit 文档中了解更多关于 Streamlit 的信息。
TensorFlow Serving 是谷歌支持的平台，用于部署机器学习模型，并在现实生活环境中测试其功能。虽然 TensorFlow 内置了与 TensorFlow 模型的集成，但它也可以与其他模型一起工作。
通过 TensorFlow 服务，您可以使用相同的架构和 API 来训练和服务多个机器学习模型。这简化了您的工作流程，并消除了模型部署和迭代的痛苦。
TensorFlow 的主要优势:
- 管理模型版本和控制
- 与高达 2GB 的大型机型兼容
- 用于顶级公司和企业
- 灵活的 API 改善了与现有架构的集成
查看 Tensorflow 服务文档了解更多信息。
TorchServe 是一个灵活且初学者友好的工具，用于部署 PyTorch 模型。这是 Pytorch 团队和 AWS 合作的成果。
如果您正在使用 PyTorch 框架创建您的模型，那么 TorchServe 是一个极好的选择。它与 PyTorch 机器学习模型进行了开箱即用的集成，应该可以很好地与您的工作流程同步。
然而，由于 TorchServe 被设计为仅服务于 PyTorch 模型，因此在其他 ML 环境中工作的团队或研究人员可能会遇到问题。但是，随着该工具未来的更新，这种情况可能会改变。
TorchServe 中的 RESTful API 功能意味着您可以跨不同的设备部署它。此外，TorchServe 减轻了您的工作量，因为它自带默认库，可用于执行对象分类、图像分类、对象检测和图像分割等任务。
TorchServe 的主要优势:
- 模型版本控制
- 日志记录指标
- 提升可扩展性
- 简单的设置+大量对新用户有用的资源
要了解更多关于 Touchserve 的信息，请查阅 TorchServe 文档。
| 工具 | 移动的 | 网 | 多模式服务 | 设备管理 | 模型类型 | 支持的环境 | 潜伏 |
|---|---|---|---|---|---|---|---|
AWS Sagemaker，Kubernetes，亚马逊 EC2
| |
模型部署工具对比
Model and data lineage in Pachyderm | Source: Pachyderm
Pachyderm 是一个数据平台，它将数据谱系与 Kubernetes 上的端到端管道混合在一起。它为数据科学项目和 ML 实验带来了数据版本控制的管道层。它进行数据采集、摄取、清理、管理、争论、处理、建模和分析。
点击了解更多关于厚皮动物的信息。
DVC 是一个模型和数据的开源版本控制系统。DVC 版本输入数据、配置和最初用于运行实验的代码。它实际上是每一次实验的版本。它利用了 GIT 等现有工具。
DVC 有一种内置的方式将 ML 步骤连接到 DAG 中，并端到端地运行整个管道。通过 DVC 数据管道，您可以看到模型和其他数据工件是如何构建的，这提高了可再现性。
DVC 运行在任何 Git 存储库之上，兼容任何标准的 Git 服务器或提供商(GitHub、GitLab 等)。它可以与亚马逊 S3、微软 Azure Blob 存储、谷歌驱动、谷歌云存储、阿里云 OSS、SSH/SFTP、HDFS、HTTP、网络附加存储或磁盘集成来存储数据。
DVC 处理中间结果的缓存，如果输入数据或代码是相同的，它不会再运行一个步骤。
Neptune 还跟踪、存储元数据和机器学习生命周期中创建的所有其他参数信息。Neptune 允许您在每次运行之前定义要记录的数据，并获得改进模型所需的信息。
Neptune 环境自动生成您的数据记录，并提供对数据变化的洞察。此外，它记录模型检查点，这对于记录您的模型版本并在以后使用它们很方便。
Neptune 易于与许多第三方应用程序集成，非常适合版本控制。它还可以处理大量数据。
| 工具 | 模型版本控制 | 数据版本化 | 血统跟踪 |
|---|---|---|---|
模型版本化工具对比|来源:作者
Amazon SageMaker Model Monitor 全天候跟踪生产模型的质量。它可以通过编程来检测模型质量的变化，还可以跟踪数据质量的漂移和模型制作中的偏差。
使用 SageMaker 模型监视器，您可以早期诊断模型的问题，并实施纠正措施。这可能是从重新训练你的模型到检查其他区域的任何事情。您可以将这些检查编程为自动运行，这样可以减少遗漏关键指标的可能性。
SageMaker 模型监视器解决了模型监视中的一个问题:MM 工具编写代码的困难。您可以轻松实现模型监控流程，而无需编写任何代码。同时，Model Monitor 是完全可定制的，允许您添加定制代码来收集更详细的数据。
点击了解更多关于 SageMaker 型号显示器的信息。
Fiddler 通过为生产中的模型提供高性能的监控来改进您的 ML 工作流。这种一体化工具集可以帮助完成以下模型监控任务:
- 跟踪和分析模型行为
- 管理模型和数据集
- 修复不准确的模型预测
- 监控机器学习模型的性能
Fiddler 用一套实用的工具来增强您的模型监控。预定的警报系统允许您检测模型质量问题并定位问题区域。您可以从一个界面组织和跟踪这些警报。
如果您想要更好地了解您的模型的行为，Fiddler 已经高度开发了将模型性能分解为基本元素的技术。这给了你更多的信息，所以你可以做更好的再培训。
借助 Fiddler 的多集成能力，您可以从几乎任何来源提取数据。也可以将它整合到您当前的框架中。
Seldon Core 是用于在 Kubernetes 中部署机器学习模型的 Seldon Deploy 平台的伴侣。Seldon Core 非常适合管理您的 ML 生产管道的各个方面，并为您的利益提供监控工具。
Seldon Core 开箱后带有一个用于监控模型性能的仪表盘，您可以轻松跟踪两个模型以获得更多见解。您可以根据需要生成度量，评估模型产品的质量，并比较模型版本。
很少核心的主要优势:
- 支持流行的 ML 库
- 检测异常值，以便更快地评估问题
- 用于分析模型预测的可用模型解释器
你可以在这里了解更多关于希罕的信息。
| 工具 | 仪表盘 | 形象化 | 解释者模型 |
|---|---|---|---|
亚马逊 Sagemaker 型号监控
| | | |
| | | | |
| | | | |
模型监控工具对比
Data labeling in Hasty | Source: Hasty
Hasty 是一个数据标记/注释工具，用于标记计算机视觉项目中地面真实数据集的图像和视频数据。它使用机器学习来执行注释。
使用 Hasty，用户必须手动注释或标记大约 10 幅图像，然后 Hasty 工具创建一个模型来训练这些图像，然后使用该模型(活动类)来自动注释后续图像。这使得仓促快速。
要开始使用 Hasty，请查看这里的。
Data labeling in Labelbox | Source: Labelbox
Labelbox 是一个端到端的平台，用于为机器学习训练创建和管理高质量的训练数据集。它进行图像分割、图像分类和文本分类。Labelbox 提供错误检测、客户个性化、安全监控和质量保证。它涉及一个分析和自动迭代过程，用于训练和标记数据并进行预测，以及主动学习。
Labelbox 有预制的标签界面，您可以使用。它还允许您创建自己的可插拔接口，以满足您的数据标记任务的需要。
它有助于多个分布式标签工作人员的人工协作和管理，因此世界各地的团队可以在数据标签过程中进行协作，使其成为一项包容和多样化的工作。
点击了解更多关于 Labelbox 的信息。
AWS SageMaker Ground Truth 为数据集提供自动数据标注。它使用主动学习模型来标记数据，并将任何无法准确标记的数据发送给数据科学家。它准确高效地进行数据标注。
SageMaker Ground Truth 为文本、图像、视频和 3D 云点添加标签。对于文本，它进行文本分类和命名实体识别。对于图像。它支持图像分类、对象检测和语义分割。对于视频，它支持视频对象检测、视频对象跟踪和视频剪辑分类。对于 3D 点云数据，它支持对象检测、对象跟踪和语义分割。
SageMaker Ground Truth 还为您提供了超过 500，000 名独立数据贴标承包商，您可以向他们发送您的贴标工作。对于机密数据或特殊技能，该工具还具有预先筛选的第三方供应商，如 iVision、CapeStart Inc .、Cogito 和 iMerit，它们可以使用特殊和机密程序执行数据标记。
查看 AWS SageMaker 地面真相文档。
| 工具 | 文本标签 | 图像标记 | 视频标注 |
|---|---|---|---|
AWS Sagemaker 地面真相
| | | |
数据标注工具对比
结论
Azure 机器学习仍然是扩展 MLOps 的最佳平台之一，拖放设计器选项使其对初学者友好。然而，如果您正在寻找更多的具体选项来集成到您的 ML 工作流中，有许多工具可以尝试。
实验追踪，Neptune.ai，Mlflow，WandB 都会很好的为你服务。它们都具有协作兼容性。如果你想部署一个简单的数据/ML 应用程序，Streamlit 是一个很好的选择，如果你已经使用 TensorFlow 或 PyTorch，那么 Tensorflow Serving、TorchServe 将是更好的工具。
对于模型管理，Vertex AI、Neptune.ai 和 Metaflow 是管理机器学习工作流的非常好的工具。对于数据标注 AWS Sagemaker Ground Truth，Hasty 和 Labelbox 对于希望扩展其数据标注流程的团队来说是不错的选择。
您可以查看 MLOps Tools Landscape 以了解各种工具及其特定用例，本文中提到的任何工具都可以使用。
快乐实验！
参考
https://azure . Microsoft . com/en-us/services/machine-learning/#功能
- https://neptune.ai
- https://docs.streamlit.io/en/stable/getting_started.html
- https://metaflow.org/
- https://www.tensorflow.org/tfx/guide/serving
- https://github.com/pytorch/serve
- https://www.pachyderm.com/
- https://docs . AWS . Amazon . com/sage maker/latest/DG/model-monitor . html
- https://github.com/SeldonIO/seldon-core
- http://fiddler.ai
- https://github.com/Labelbox/labelbox
- https://aws.amazon.com/sagemaker/groundtruth/
- https://aws.amazon.com/sagemaker/groundtruth/
神经网络反向传播算法综合指南
本文是对反向传播算法的全面指导，反向传播算法是用于训练人工神经网络的最广泛使用的算法。我们将从在训练神经网络的过程中定义正向和反向传递开始，然后我们将集中讨论反向传播在反向传递中是如何工作的。我们将研究反向传播算法的详细数学计算。
此外，我们将基于这个 GitHub 项目讨论如何使用 NumPy 从零开始用 Python 实现一个反向传播神经网络。该项目建立了一个通用的反向传播神经网络，可以与任何架构。
让我们开始吧。
神经网络体系结构快速概述
在最简单的情况下，神经网络的架构由一些连续的层组成，其中编号为 i 的层连接到编号为 i+1 的层。这些层可以分为 3 类:
- 投入
- 隐藏的
- 输出
下图显示了全连接人工神经网络(FCANN)的示例，这是演示反向传播算法如何工作的最简单的网络类型。该网络有一个输入层、两个隐藏层和一个输出层。在图中，网络体系结构是水平显示的，每一层都是从左到右垂直显示的。
每层由一个或多个用圆圈表示的神经元组成。因为网络类型是全连接的，那么层 i 中的每个神经元都与层 i+1 中的所有神经元相连。如果 2 个后续层具有 X 和 Y 神经元，则中间连接的数量为 XY* 。
对于每个连接，都有一个相关的权重。权重是一个浮点数，用于衡量两个神经元之间连接的重要性。权重越高，联系越重要。权重是网络进行预测的可学习参数。如果权重是好的，那么网络做出准确的预测，误差更小。否则，应该更新权重以减小误差。
假设在层 1 的一个神经元 N [1] 连接到在层 2 的另一个神经元 N [2] 。还假设 N [2] 的值是根据下一个线性方程计算的。
N[2]= w[1]N[1]+b
如果 N [1] =4，w [1] =0.5(权重)，b=1(偏差)，那么 N [2] 的值就是 3。
N [2] =0.54+1=2+1=3
这就是单个重量如何将两个神经元连接在一起。请注意，输入层根本没有可学习的参数。
层 i+1 的每一个神经元对于层 i 的每一个连接的神经元都有一个权重，但是它只有一个单一的偏向。因此，如果层 i 具有 10 个神经元，层 i+1 具有 6 个神经元，则层 i+1 的参数总数为:
权重数+偏差数=10×6 +6=66
输入层是网络中的第一层，它由网络的输入直接连接。网络中只能有一个输入层。例如，如果输入是一个学期的学生成绩，那么这些成绩将连接到输入图层。在我们的图中，输入层有 10 个神经元(例如，10 门课程的分数——一个英雄学生上了 10 门课程/学期)。
输出层是返回网络预测输出的最后一层。和输入层一样，只能有一个输出层。如果网络的目标是预测下学期的学生成绩，那么输出层应该返回一个分数。下图中的架构有一个返回下一学期预测分数的神经元。
在输入层和输出层之间，可能有 0 个或更多隐藏层。在本例中，有两个隐藏层，分别包含 6 个和 4 个神经元。请注意，最后一个隐藏层连接到输出层。
通常，隐藏层中的每个神经元使用类似 sigmoid 或整流线性单元(ReLU)的激活函数。这有助于捕捉输入和输出之间的非线性关系。输出层中的神经元也使用类似 sigmoid(用于回归)或 SoftMax(用于分类)的激活函数。
构建好网络架构后，就该开始用数据训练它了。
神经网络中的正向和反向传递
为了训练神经网络，有两个阶段:
- 向前
- 向后的
在前向传递中，我们从将数据输入传播到输入层开始，经过隐藏层，从输出层测量网络的预测，最后根据网络做出的预测计算网络误差。
该网络误差衡量网络距离做出正确预测还有多远。例如，如果正确的输出是 4，网络的预测是 1.3，那么网络的绝对误差是 4-1.3=2.7。注意，将输入从输入层传播到输出层的过程称为正向传播。计算出网络误差后，前向传播阶段结束，后向传递开始。
下图显示了一个指向向前传播方向的红色箭头。
在反向传递中，流程是反向的，因此我们从将误差传播到输出层开始，直到通过隐藏层到达输入层。将网络误差从输出层传播到输入层的过程称为反向传播，或简单的反向传播。反向传播算法是用来更新网络权重以减少网络误差的一组步骤。
在下图中，蓝色箭头指向向后传播的方向。
向前和向后的阶段从一些时期开始重复。在每个时期，会发生以下情况:
- 输入从输入层传播到输出层。
- 计算网络误差。
- 误差从输出层传播到输入层。
我们将关注反向传播阶段。让我们讨论一下使用反向传播算法的优点。
为什么使用反向传播算法？
前面我们讨论过，网络是用两个通道训练的:向前和向后。在正向传递结束时，计算网络误差，该误差应尽可能小。
如果当前误差较高，则网络没有从数据中正确学习。这是什么意思？这意味着当前的权重集不够精确，不足以减少网络误差并做出准确的预测。因此，我们应该更新网络权重以减少网络误差。
反向传播算法是负责以减少网络误差为目标更新网络权重的算法之一。挺重要的。
以下是反向传播算法的一些优点:
- 在计算导数时，它是内存高效的，因为与其他优化算法相比，它使用更少的内存，如遗传算法。这是一个非常重要的特性，尤其是对于大型网络。
- 反向传播算法速度很快，尤其适用于中小型网络。随着更多层和神经元的加入，随着更多导数的计算，它开始变得更慢。
- 这种算法足够通用，可用于不同的网络架构，如卷积神经网络、生成对抗网络、全连接网络等。
- 没有参数来调整反向传播算法，因此开销较少。该过程中唯一的参数与梯度下降算法有关，如学习速率。
接下来，让我们基于一个数学示例来看看反向传播算法是如何工作的。
反向传播算法如何工作
基于一个简单的网络可以很好地解释该算法的工作原理，如下图所示。它只有一个有 2 个输入的输入层(X [1] 和 X [2] )和一个有 1 个输出的输出层。没有隐藏层。
输入的权重分别为 W [1] 和 W [2] 。偏差被视为输出神经元的新输入神经元，其具有固定值+1 和权重 b。权重和偏差都可以被称为参数。
假设输出层使用由以下等式定义的 sigmoid 激活函数:
其中 s 是每个输入与其相应重量之间的乘积之和(SOP ):
s = X[1] W[1]+X[2]* W[2]+b*
为了简单起见，本例中只使用了一个训练样本。下表显示了具有输入的单个训练样本及其对应的样本的期望(即正确)输出。在实践中，使用了更多的训练实例。
假设权重和偏差的初始值如下表所示。
为简单起见，所有输入、权重和偏差的值都将添加到网络图中。
现在，让我们训练网络，看看网络将如何根据当前参数预测样本的输出。
正如我们之前讨论的，培训过程有两个阶段，向前和向后。
前进传球
激活函数的输入将是每个输入与其权重之间的 SOP。然后将 SOP 加到偏置上，返回神经元的输出:
s = X[1] W[1]+X[2]* W[2]+b*
s=0.1 0.5+ 0.30.2+1.83
s=1.94
然后将值 1.94 应用于激活函数(sigmoid)，得到值 0.874352143。
来自输出神经元的激活函数的输出反映了样本的预测输出。很明显，期望的输出和期望的输出之间存在差异。但是为什么呢？我们如何使预测输出更接近期望输出？我们稍后会回答这些问题。现在，让我们看看基于误差函数的网络误差。
误差函数表明预测输出与期望输出有多接近。误差的最佳值是零，这意味着根本没有误差，期望的和预测的结果是相同的。误差函数之一是平方误差函数，如下式定义:
注意，值 12 乘以等式是为了使用反向传播算法简化导数计算。
基于误差函数，我们可以如下测量网络的误差:
结果显示有误差，而且误差很大:( ~0.357 )。这个误差只是给了我们一个指示，告诉我们预测的结果离期望的结果有多远。
知道有错误，我们该怎么办？我们应该把它最小化。为了最小化网络错误，我们必须改变网络中的某些东西。请记住，我们唯一可以改变的参数是权重和偏差。我们可以尝试不同的权重和偏差，然后测试我们的网络。
我们计算误差，然后正向传递结束，应该开始反向传递计算导数，更新参数。
为了实际感受反向传播算法的重要性，让我们尝试不使用该算法直接更新参数。
参数更新方程
可以根据下式改变参数:
W[(n+1)]= W(n)+η[d(n)-Y(n)]X(n)
其中:
- n:训练步骤(0，1，2，…)。
- W(n):当前训练步骤中的参数。Wn=[bn，W1(n)，W2(n)，W3(n)，…，Wm(n)]
- η :学习率，取值在 0.0 到 1.0 之间。
- d(n):期望输出。
- Y(n):预测产量。
- X(n):网络做出错误预测的当前输入。
对于我们的网络，这些参数具有以下值:
- n: 0
- 女(男):[1.83，0.5，0.2]
- η :因为是超参数，那么我们可以选择 0.01 为例。
- d(n): [0.03]。
- Y(n): [0.874352143]。
- X(n): [+1，0.1，0.3]。第一个值(+1)是偏差。
我们可以如下更新我们的网络参数:
W[(n+1)]= W(n)+η[d(n)-Y(n)]X(n)
=[1.83，0.5，0.2]+0.01[0.03-0.874352143][+1，0.1，0.3]
=[1.83，0.5，0.2]+0.01[-0.844352143][+1，0.1，0.3]
=[1.83，0.5，0.2]+-0.00844352143[+1，0.1，0.3]
=[1.83，0.5，0.2]+[-0.008443521，-0.000844352，-0.002533056]
=【1.821556479，0.499155648，0.197466943】
下表列出了新参数:
根据新的参数，我们将重新计算预测的产量。新的预测输出用于计算新的网络误差。根据计算的误差更新网络参数。该过程继续更新参数并重新计算预测输出，直到它达到误差的可接受值。
这里，我们成功地更新了参数，而没有使用反向传播算法。我们还需要那个算法吗？是的。你会明白为什么。
参数更新方程仅仅依赖于学习率来更新参数。它以与错误相反的方向改变所有参数。
但是，使用反向传播算法，我们可以知道每个权重如何与误差相关。这告诉我们每个权重对预测误差的影响。也就是我们增加哪些参数，减少哪些参数才能得到最小的预测误差？
例如，反向传播算法可以告诉我们有用的信息，比如将 W1 的当前值增加 1.0 会使网络误差增加 0.07。这表明 W1 值越小，误差越小。
偏导数
向后传递中使用的一个重要操作是计算导数。在开始计算反向传递中的导数之前，我们可以从一个简单的例子开始，让事情变得简单一些。
对于一个多元函数，比如 Y=X2Z+H，给定变量 X 的变化对输出 Y 有什么影响？我们可以使用偏导数来回答这个问题，如下所示:
注意，除了 X 之外的一切都被视为常数。因此，在计算偏导数之后，H 被替换为 0。在这里，∂X 意味着变量 x 的微小变化，同样，∂Y 意味着 y 的微小变化，y 的变化是改变 x 的结果，通过对 x 做一个非常微小的改变，对 y 有什么影响？
微小的变化可以是微小值的增加或减少。通过代入 X 的不同值，我们可以发现 y 相对于 X 是如何变化的。
可以遵循相同的过程来学习 NN 预测误差如何随网络权重的变化而变化。因此，我们的目标是计算∂E/W [1] 和∂E/W [2] ，因为我们只有两个权重 W [1] 和 W [2] 。我们来计算一下。
预测误差对 R.T 参数的导数
看看这个方程，Y=X ² Z+H，计算偏导数∂Y/∂X 似乎很简单，因为有一个方程将 y 和 x 联系起来。在我们的例子中，没有直接方程同时存在预测误差和权重。所以，我们要用多元链式法则来求 Y W r t x 的偏导数
参数链预测误差
让我们试着找出预测误差和权重之间的联系。预测误差根据以下等式计算:
这个方程没有任何参数。没问题，我们可以考察前面方程的每一项(期望 & 预测)是如何计算的，用它的方程代入，直到达到参数。
前一个等式中的所需的项是一个常数，因此没有机会通过它获得参数。预测的项是基于 sigmoid 函数计算的，如下式所示:
同样，用于计算预测输出的等式没有任何参数。但是仍然有变量 s (SOP ),它已经依赖于用于其计算的参数，根据这个等式:
s = X[1] W[1]+X[2]* W[2]+b*
一旦我们得出了一个有参数(权重和偏差)的方程，我们就到达了衍生链的末端。下图显示了计算误差对参数的导数所遵循的导数链。
注意 s W.R.T 偏差 b 的导数(∂[s]/w1】为 0，可以省略。正如我们之前所做的那样，可以使用学习率简单地更新偏差。这留给我们计算 2 个权重的导数。
**根据上图，要知道预测误差如何随参数的变化而变化，我们应该找到以下中间导数:
- 预测输出的网络误差。
- SOP 下的预测产量。
- SOP W.R.T 三个参数中的每一个。
总共有四个中间偏导数:
∂E/∂Predicted ，∂predicted/∂[s]t5】，∂[s]/w[1]t11】和∂[s]/w[2]t17】
要计算误差对重量的导数，只需将误差链中的所有导数与每个重量相乘，如下 2 个等式所示:
∂e/w[1]=∂e/∂predicted∂predicted/∂[s]∂[s]/w[1]
∂ew[2]=∂e/∂predicted ∂predicted/∂s∂[s]/w[2]
重要提示:我们使用导数链解决方案，因为没有将误差和参数联系在一起的直接方程。但是，我们可以创建一个将它们联系起来的方程，并对其直接应用偏导数:
E = 1/2(desired-1/(1+E^(-(X1 * W1+X2 * W2+b)))²
因为这个方程直接计算误差对参数的导数似乎很复杂，所以为了简单起见，最好使用多元链规则。
用替换法计算偏导数值
让我们计算我们创建的链的每个部分的偏导数。
对于误差对预测输出的导数:
∂e/∂predicted=∂/∂predicted(1/2(desired-predicted)²)
=21/2(期望-预测) ^(2-1) (0-1)
=(期望-预测)(-1)*
=预测-期望
通过替换以下值:
∂e/∂predicted=predicted-desired=0.874352143-0.03
∂e/∂predicted=0.844352143
对于预测输出相对于 SOP 的导数:
[s][s](1/(1+e^(【s】))
记住:商法则可用于计算 sigmoid 函数的导数，如下所示:
∂predicted/∂s=1/(1+e(-s))(1-1/(1+e(-s))
通过替换以下值:
∂predicted/∂s=1/(1+e(-s))(1-1/(1+e(-s))=1/(1+e(-1.94))(1-1/(1+e(-1.94))
= 1/(1+0.143703949)(1-1/(1+0.143703949))
= 1/1.143703949(1-1/1.143703949)
= 0.874352143(1-0.874352143)
= 0.874352143(0.125647857)
∂predicted/∂s=0.109860473
对于 SOP W.R.T W1 的衍生产品:
[【s】]/w[【1】]=/
**= 1 * X[1](W[1])^((1-1))+0+0
= X[1](W[1])【T5(0)*
=X [1] (1)
∂[s]/w[1]= x[1]
通过替换以下值:
∂ [s] /W1=X [1] =0.1
对于 SOP W.R.T W2 的衍生产品:
[【s】]/w[【2】]=/
**= 0+1 * X[2](W[2])^((1-1))+0
= X[2](W[2])【T5(0)*
= X[2]①
∂[s]/w[2]= x[2]
通过替换以下值:
∂[s]/w[2]= x[2]= 0.3
在计算了所有链中的各个导数之后，我们可以将它们全部相乘，以计算所需的导数(即误差相对于每个重量的导数)。
对于误差 W.R.T W1 的导数:
∂e/w[1]= 0.844352143 * 0.109860473 * 0.1
∂e/w[1]= 0.009276093
对于误差 W.R.T W2 的导数:
∂e/w[2]= 0.844352143 * 0.109860473 * 0.3
∂e/w[2]= 0.027828278
最后，有两个值反映预测误差相对于权重如何变化:
0.009276093 为 W[1]
0.027828278 为 W[2]
这些值意味着什么？这些结果需要解释。
解释反向传播的结果
从最后两个导数中可以得出两个有用的结论。这些结论是基于以下几点得出的:
- 导数符号
- 导数大小
如果导数符号是正的，这意味着增加权重会增加误差。换句话说，减少权重会减少误差。
如果导数符号为负，增加权重会减小误差。换句话说，如果它是负的，那么减少权重会增加误差。
但是误差增加或减少了多少呢？导数的大小回答了这个问题。
对于正导数，权重增加 p 会使误差增加 DMp，对于负导数，权重增加 p 会使误差减少 DMp。
让我们将此应用到我们的示例中:
- 因为∂E/W [1] 导数的结果是正的，这意味着如果 W1 增加 1，那么总误差增加 0.009276093。
- 因为∂E/W [2] 导数的结果是正的，这意味着如果 W2 增加 1，那么总误差增加 0.027828278。
现在让我们根据计算出的导数来更新权重。
更新权重
在成功地计算出误差相对于每个单独权重的导数之后，我们可以更新权重来改进预测。每个权重基于其导数进行更新:
对于 W [1] :
w[1 新]= w[1]-η∂e/w[1]*
=0.5-0.010.009276093*
W[1 新的] =0.49990723907
对于 W [2] :
w[2 新]= w[2]-η∂e/w[2]*
=0.2-0.010.027828278*
W[2 新] = 0.1997217172
请注意，导数是从重量的旧值中减去(而不是加上)的，因为导数是正的。
权重的新值为:
- W [1] =0.49990723907
- W [2] = 0.1997217172
除了先前计算的偏差(1.821556479)之外，这两个权重被用于新的前向传递以计算误差。预计新误差将小于当前误差(0.356465271)。
以下是新的正向传递计算:
s = X[1] W[1]+X[2]* W[2]+b*
s = 0.1 * 0.49990723907+0.3 * 0.1997217172+1.821556479
s=1.931463718067
f(s)=1/(1+e ^(-s) )
f(s)= 1/(1+e^(-1.931463718067))
f(s)=0.873411342830056
E = 1/2(0.03-0.873411342830056)²
E=0.35567134660719907
当比较新误差(0.35567134660719907)和旧误差(0.356465271)时，减少了 0.0007939243928009043。只要有减少，我们就在朝着正确的方向前进。
误差减少很小，因为我们使用了一个小的学习率(0.01)。要了解学习率如何影响训练神经网络的过程，请阅读本文。
应该重复向前和向后传递，直到误差为 0 或经过多个时期(即迭代)。这标志着示例的结束。
下一节讨论如何实现本节讨论的例子的反向传播。
Python 中的编码反向传播
对于上一节讨论的例子，实现反向传播算法非常容易。在本节中，我们将使用 GitHub 项目从头开始构建一个具有 2 个输入和 1 个输出的网络。
下一个代码使用 NumPy 来准备输入(x1=0.1 和 x2=0.4)，值为 0.7 的输出，值为 0.01 的学习速率，并为两个权重 w1 和 w2 分配初始值。最后，创建两个空列表来保存每个时期的网络预测和误差。
import numpy
x1=0.1
x2=0.4
target = 0.7
learning_rate = 0.01
w1=numpy.random.rand()
w2=numpy.random.rand()
print("Initial W : ", w1, w2)
predicted_output = []
network_error = []
接下来的代码构建了一些函数来帮助我们进行计算:
- Sigmoid():应用 sigmoid 激活函数。
- error():返回平方误差。
- error_predicted_deriv():返回误差对预测输出的导数。
- sigmoid_sop_deriv():返回 sigmoid 函数相对于 sop 的导数。
- sop_w_deriv():返回单个权重的 SOP W.R.T 的导数。
update_w():更新单个权重。
import numpy
def sigmoid(sop):
return 1.0/(1+numpy.exp(-1*sop))
def error(predicted, target):
return numpy.power(predicted-target, 2)
def error_predicted_deriv(predicted, target):
return 2*(predicted-target)
def sigmoid_sop_deriv(sop):
return sigmoid(sop)*(1.0-sigmoid(sop))
def sop_w_deriv(x):
return x
def update_w(w, grad, learning_rate):
return w - learning_rate*grad
现在，根据下一个代码，使用“for”循环，我们准备对多个时期进行向前和向后传递计算。循环经过 80，000 个纪元。
for k in range(80000):
y = w1*x1 + w2*x2
predicted = sigmoid(y)
err = error(predicted, target)
predicted_output.append(predicted)
network_error.append(err)
g1 = error_predicted_deriv(predicted, target)
g2 = sigmoid_sop_deriv(y)
g3w1 = sop_w_deriv(x1)
g3w2 = sop_w_deriv(x2)
gradw1 = g3w1*g2*g1
gradw2 = g3w2*g2*g1
w1 = update_w(w1, gradw1, learning_rate)
w2 = update_w(w2, gradw2, learning_rate)
在正向传递中，执行以下代码行来计算 SOP，应用 sigmoid 激活函数来获得预测输出，并计算误差。这将分别在 predicted_output 和 network_error 列表中追加当前网络预测和误差。
y = w1*x1 + w2*x2
predicted = sigmoid(y)
err = error(predicted, target)
predicted_output.append(predicted)
network_error.append(err)
在向后传递中，执行“for”循环中的剩余行来计算所有链中的导数。误差 W.R.T 对权重的导数保存在变量 gradw1 和 gradw2 中。最后，通过调用 update_w()函数来更新权重。
g1 = error_predicted_deriv(predicted, target)
g2 = sigmoid_sop_deriv(y)
g3w1 = sop_w_deriv(x1)
g3w2 = sop_w_deriv(x2)
gradw1 = g3w1*g2*g1
gradw2 = g3w2*g2*g1
w1 = update_w(w1, gradw1, learning_rate)
w2 = update_w(w2, gradw2, learning_rate)
完整的代码如下。它在每个时期后打印预测的输出。此外，它使用 matplotlib 库创建 2 个图，显示预测输出和误差如何随时间演变。
import numpy
import matplotlib.pyplot
def sigmoid(sop):
return 1.0/(1+numpy.exp(-1*sop))
def error(predicted, target):
return numpy.power(predicted-target, 2)
def error_predicted_deriv(predicted, target):
return 2*(predicted-target)
def sigmoid_sop_deriv(sop):
return sigmoid(sop)*(1.0-sigmoid(sop))
def sop_w_deriv(x):
return x
def update_w(w, grad, learning_rate):
return w - learning_rate*grad
x1=0.1
x2=0.4
target = 0.7
learning_rate = 0.01
w1=numpy.random.rand()
w2=numpy.random.rand()
print("Initial W : ", w1, w2)
predicted_output = []
network_error = []
old_err = 0
for k in range(80000):
y = w1*x1 + w2*x2
predicted = sigmoid(y)
err = error(predicted, target)
predicted_output.append(predicted)
network_error.append(err)
g1 = error_predicted_deriv(predicted, target)
g2 = sigmoid_sop_deriv(y)
g3w1 = sop_w_deriv(x1)
g3w2 = sop_w_deriv(x2)
gradw1 = g3w1*g2*g1
gradw2 = g3w2*g2*g1
w1 = update_w(w1, gradw1, learning_rate)
w2 = update_w(w2, gradw2, learning_rate)
print(predicted)
matplotlib.pyplot.figure()
matplotlib.pyplot.plot(network_error)
matplotlib.pyplot.title("Iteration Number vs Error")
matplotlib.pyplot.xlabel("Iteration Number")
matplotlib.pyplot.ylabel("Error")
matplotlib.pyplot.figure()
matplotlib.pyplot.plot(predicted_output)
matplotlib.pyplot.title("Iteration Number vs Prediction")
matplotlib.pyplot.xlabel("Iteration Number")
matplotlib.pyplot.ylabel("Prediction")
在下图中，绘制了 80，000 个历元的误差。请注意误差如何在值 3.150953682878443e-13 处饱和，该值非常接近 0.0。
下图显示了预测的输出是如何随着迭代而变化的。请记住，在我们的示例中，正确的输出值设置为 0.7。输出饱和值为 0.6999994386664375，非常接近 0.7。
GitHub 项目也给出了一个更简单的接口来构建 Ch09 目录中的网络。有一个例子，建立一个有 3 个输入和 1 个输出的网络。在代码的最后，调用函数 predict() 来要求网络预测一个新样本[0.2，3.1，1.7]的输出。
import MLP
import numpy
x = numpy.array([0.1, 0.4, 4.1])
y = numpy.array([0.2])
network_architecture = [7, 5, 4]
trained_ann = MLP.MLP.train(x=x,
y=y,
net_arch=network_architecture,
max_iter=500,
learning_rate=0.7,
debug=True)
print("Derivative Chains : ", trained_ann["derivative_chain"])
print("Training Time : ", trained_ann["training_time_sec"])
print("Number of Training Iterations : ", trained_ann["elapsed_iter"])
predicted_output = MLP.MLP.predict(trained_ann, numpy.array([0.2, 3.1, 1.7]))
print("Predicted Output : ", predicted_output)
这段代码使用了一个名为 MLP 的模块，这是一个构建反向传播算法的脚本，同时为用户提供了一个简单的界面来构建、训练和测试网络。关于如何构建这个脚本的细节，请参考这本书。
反向传播的类型
反向传播算法有两种主要类型:
- 传统的反向传播一直用于固定输入和固定输出的静态问题，比如预测图像的类别。在这种情况下，输入图像和输出类永远不会改变。
- 时间反向传播(BPTT) 针对随时间变化的非静态问题。它应用于时间序列模型，如递归神经网络(RNN)。
反向传播算法的缺点
即使反向传播算法是训练神经网络最广泛使用的算法，它也有一些缺点:
- 应该仔细设计网络，以避免消失和爆炸梯度影响网络的学习方式。例如，从 sigmoid 激活函数计算出的梯度可能非常小，接近于零，这使得网络不能更新其权重。结果，没有学习发生。
- 反向传播算法平等地考虑网络中的所有神经元，并为每次反向传递计算它们的导数。即使使用了丢弃层，也要计算丢弃的神经元的导数，然后丢弃。
- 反向传播依赖于无限效应(偏导数)来执行信用分配。当人们考虑更深和更非线性的函数时，这可能成为一个严重的问题。
- 它期望误差函数是凸的。对于非凸函数，反向传播可能会陷入局部最优解。
- 误差函数和激活函数必须是可微的，以便反向传播算法能够工作。它不适用于不可微函数。
- 在正向传递中，层 i+1 必须等待层 i 的计算完成。在向后通道中，层 i 必须等待层 i+1 完成。这使得网络的所有层都被锁定，等待网络的其余层向前执行并向后传播错误，然后它们才能被更新。
传统反向传播的替代方案
传统的反向传播有多种替代方法。以下是四种选择。
李东贤等人的“差异目标传播”关于数据库中机器学习和知识发现的欧洲联合会议。施普林格，查姆，2015。，主要思想是在每一层计算目标而不是梯度。像渐变一样，它们是向后传播的。目标传播依赖于每层的自动编码器。与反向传播不同，即使当单元交换随机比特而不是实数时，它也可以被应用。
马、万多·库尔特、J. P .刘易斯和 w .巴斯蒂亚安·克莱因。" hsic 瓶颈:没有反向传播的深度学习."AAAI 人工智能会议记录。第 34 卷。04 号。2020.，他们提出了 HSIC (Hilbert-Schmidt 独立性准则)瓶颈，用于训练深度神经网络。HSIC 瓶颈是传统反向传播的替代方案，具有许多明显的优点。该方法有助于并行处理，并且需要的操作明显较少。它不会遭受爆炸或消失梯度。这在生物学上比反向传播更合理，因为不需要对称反馈。
在 Choromanska，Anna 等人的《超越反向投影:带辅助变量的在线交替最小化》中机器学习国际会议。PMLR，2019。，他们提出了一种用于训练深度神经网络的在线(随机/小批量)交替最小化(AM)方法。
贾德伯格、马克斯等人的“使用合成梯度的去耦神经接口”机器学习国际会议。PMLR，2017。，他们通过解耦模块(即层)打破了锁定层的约束，引入了网络图未来计算的模型。这些模型仅使用局部信息来预测建模的子图将产生什么结果。结果，子图可以独立地和异步地更新。
结论
希望现在你明白了为什么反向传播是训练人工神经网络最流行的算法。它相当强大，其内部工作方式令人着迷。感谢阅读！****
平衡精度:什么时候应该使用它？
原文：https://web.archive.org/web/https://neptune.ai/blog/balanced-accuracy
当我们训练一个 ML 模型时，我们希望知道它的表现如何，这种表现是用度量来衡量的。直到性能足够好，度量标准令人满意，模型才值得部署，我们必须不断迭代，找到模型既不欠拟合也不过拟合的最佳点(完美的平衡)。
有很多不同的指标来衡量机器学习模型的性能。在本文中，我们将探索基本的度量标准，然后更深入地挖掘平衡的准确性。
机器学习中的问题类型
机器学习中有两个广泛的问题:
第一个处理离散值，第二个处理连续值。
分类可以细分为两个更小的类型:
多类分类
在多类分类中，类等于或大于三。许多二进制分类使用带有标签的两个类进行操作，并且许多分类器算法可以对其进行建模，而多类分类问题可以通过应用某种策略(即一对一或一对一)使用该二进制分类器来解决。
二元分类
二元分类有两个目标标签，大多数时候一个类别处于正常状态，而另一个类别处于异常状态。设想一个欺诈性交易模型，该模型预测交易是否是欺诈性的。这种异常状态(=欺诈性交易)有时在一些数据中表现不足，因此检测可能至关重要，这意味着您可能需要更复杂的指标。
什么是评估指标？
初学数据的科学家可能会犯的一个错误是，在构建模型后没有对其进行评估，也就是说，在部署之前不知道他们的模型有多有效，这可能是灾难性的。
评估标准衡量模型在训练后的表现。您建立一个模型，从度量中获得反馈，并进行改进，直到获得您想要的精确度。
选择正确的指标是正确评估 ML 模型的关键。选择单一指标可能不是最佳选择，有时最佳结果来自不同指标的组合。
不同的 ML 用例有不同的度量。在这里，我们将重点关注分类指标。
请记住，指标不同于损失函数。损失函数显示了模型训练期间模型性能的度量。度量用于判断和测量训练后的模型性能。
显示我们模型性能的一个重要工具是混淆矩阵——它不是一个指标，但与指标一样重要。
混淆矩阵
混淆矩阵是数据上分类器性能分布的表格。这是一个 N×N 矩阵，用于评估分类模型的性能。它向我们展示了模型执行得有多好，需要改进什么，以及它犯了什么错误。
其中:
- TP–真阳性(模型正确预测的阳性类别结果)，
- TN–真阴性(模型的正确预测的阴性类别结果)，
- FP–假阳性(模型的错误预测阳性类别结果)，
- FN–假阴性(模型的错误预测的阴性类别结果)。
现在让我们转到指标，从准确性开始。
准确(性)
准确性是一种度量标准，它通过将总正确预测除以模型的总预测来总结分类任务的性能。它是所有数据点中正确预测的数据点的数量。
这适用于在混淆矩阵上看到的预测类别，而不是数据点的分数。
【准确度= (TP + TN) / (TP+FN+FP+TN)
回忆
召回率是一个度量标准，它量化了模型可以做出的所有肯定预测中的正确肯定预测的数量。
回忆= TP / (TP+FN)。
召回率是多类分类中所有类的真阳性的总和，除以数据中所有真阳性和假阴性的总和。
【回忆=总和(TP) /总和(TP+FN)
回忆也叫敏感。
宏观召回
宏观召回衡量每类的平均召回。它用于具有两个以上目标类别的模型，是召回的算术平均值。
宏调用=(Recall 1+Recall 2+——-Recall in)/n .
精确
精度量化了模型做出的正面预测中正确的正面预测的数量。Precision 计算真阳性的准确度。
精度= TP/(TP + FP。)
f1-分数
F1-score 保持了精确度和召回率之间的平衡。它通常用于类别分布不均匀的情况，但也可以定义为单个测试准确性的统计度量。
F1 = 2 ([精度召回]/[精度+召回])
ROC_AUC
ROC_AUC 代表“受试者操作者特征 _ 曲线下面积”。它总结了预测模型的真阳性率和假阳性率之间的权衡。当每个类之间的观察值平衡时，ROC 会产生好的结果。
无法从混淆矩阵中的汇总数据计算出此指标。这样做可能会导致不准确和误导的结果。可以使用 ROC 曲线来查看，该曲线显示了真阳性率和假阳性率之间每个可能点的变化。
平衡精度
平衡精度用于二进制和多类分类。它是灵敏度和特异性的算术平均值，其用例是当处理不平衡数据时，即当一个目标类比另一个出现得更多时。
平衡精度公式
敏感度:这也称为真阳性率或召回率，它衡量模型做出的总阳性预测中正确预测的真阳性的比例。
敏感度= TP / (TP + FN)
特异性:也称为真阴性率，它衡量正确识别的阴性占模型做出的总阴性预测的比例。
【特异性=TN / (TN + FP)
要在模型中使用这个函数，您可以从 scikit-learn 中导入它:
from sklearn.metrics import balanced_accuracy_score
bal_acc=balanced_accuracy_score(y_test,y_pred)
平衡精度二进制分类
二元分类的平衡精度有多好？让我们看看它的用例。
在异常检测中，如处理欺诈性交易数据集，我们知道大多数交易都是合法的，即欺诈性交易与合法交易的比率很小，对于这种不平衡的数据，平衡的准确性是一个很好的性能指标。
假设我们有一个二元分类器，其混淆矩阵如下:
Accuracy = (TP + TN) / (TP+FN+FP+TN) = 20+5000 / (20+30+70+5000)
Accuracy = ~98.05%.
这个分数看起来令人印象深刻，但它没有正确处理积极的一栏。
所以，让我们考虑平衡精度，这将说明类中的不平衡。下面是我们的分类器的平衡精度计算:
Sensitivity = TP / (TP + FN) = 20 / (20+30) = 0.4 = 40%
Specificity = TN / (TN + FP) = 5000 / (5000 +70) = ~98.92%.
Balanced Accuracy = (Sensitivity + Specificity) / 2 = 40 + 98.92 / 2 = 69.46%
平衡的准确性做了一件伟大的工作，因为我们想要识别我们的分类器中存在的阳性。这使得分数低于准确性预测的分数，因为它给了两个类相同的权重。
平衡精度多类分类
正如二元分类一样，平衡精度对于多类分类也是有用的。这里，BA 是在每个类别上获得的回忆的平均值，即每个类别的回忆分数的宏观平均值。因此，对于一个平衡的数据集，分数往往与准确性相同。
让我们用一个例子来说明在不平衡数据中，平衡精度是一个更好的性能指标。假设我们有一个带有混淆矩阵的二元分类器，如下所示:
从每个类获得的 TN、TP、FN、FP 如下所示:
让我们计算一下精确度:
Accuracy = TP + TN / (TP+FP+FN+TN)
TP = 10 + 545 + 11 + 3 = 569
FP = 175 + 104 + 39 + 50 = 368
TN = 695 + 248 + 626 + 874 = 2443
FN = 57 + 40 + 261 + 10 = 368
Accuracy = 569 + 2443 / (569 + 368 + 368 + 2443)
Accuracy = 0.803
分数看起来很棒，但是有个问题。集合 P 和 S 是高度不平衡的，模型在预测这一点上做得很差。
让我们考虑平衡精度:
平衡精度=(recall p+recall q+recall r+recall s)/4。
对数据中存在的每个类计算召回率(类似于二进制分类)，同时取召回率的算术平均值。
在计算召回时，公式是:
【回忆= TP / (TP + FN)
For class P, given in the table above,
Recallp = 10 / (10+57) = 0.054 = 5.4%,
如你所见，这个模型预测 P 类的真阳性率很低。
For class Q
RecallQ = 545 / (545 + 40) = 0.932
For class R,
RecallR = 11 / (11 + 261) = 0.040
For class S,
RecallS = 3 / (3 + 10) = 0.231
Balanced Accuracy = (0.054 + 0.932 + 0.040 + 0.231) / 4 = 1,257 / 4 = 0.3143
正如我们所看到的，与准确性相比，这个分数确实很低，因为对所有存在的类应用了相同的权重，而不考虑每个集合中的数据或点。
所以这里我们知道要得到一个更好的分数，应该提供更多的关于 P S .和 R .的数据。
平衡精度与分类精度
- 如果我们在数据集中有一个相似的平衡，准确性可以是一个有用的度量。如果不是，那么平衡精度可能是必要的。一个模型可以有高精度但性能差，也可以有低精度但性能好，这可能与精度悖论有关。
考虑下面不平衡分类的混淆矩阵。
看看这个模型的准确性，我们可以说它很高，但是…它不会产生任何结果，因为它的预测能力为零(这个模型只能预测一个类别)。
Binary Accuracy:
Sensitivity= TP / (TP + FN) = 0 / (0+10) = 0
Specificity = TN / (TN + FP) = 190 / (190+0) = 1
Binary Accuracy:
Sensitivity + Specificity / 2 = 0 + 1 / 2
Binary Accuracy = 0.5 = 50%
这意味着该模型不预测任何事情，而是将每个观察结果映射到一个随机猜测的答案。
准确性并不能让我们看到模型的问题。
在这里，模型积极因素得到了很好的体现。
所以，在这种情况下，平衡的准确性比准确性更好。如果数据集平衡良好，则精度和平衡精度往往会收敛于相同的值。
平衡准确度与 F1 分数
所以你可能想知道平衡准确度和 F1 分数之间的区别，因为两者都用于不平衡分类。所以，我们来考虑一下。
- F1 保持了精确度和召回率之间的平衡
F1 = 2 * ([precision * recall] / [precision + recall])
Balanced Accuracy = (specificity + recall) / 2
- F1 评分并不关心有多少真阴性正在被分类。当处理不平衡的数据集时，需要注意底片，平衡精度比 F1 更好。
- 在积极因素和消极因素同样重要的情况下，平衡准确度是比 F1 更好的衡量标准。
- 当需要更多关注正面数据时，F1 是不平衡数据的一个很好的评分标准。
考虑一个例子:
在建模期间，数据有 1000 个负样本和 10 个正样本。模型预测 15 个阳性样本(5 个真阳性，10 个假阳性)，其余为阴性样本(990 个真阴性，5 个假阴性)。
f1-得分和平衡准确度将为:
Precision = 5 / 15 = 0.33
Sensitivity = 5 / 10 = 0.5
Specificity = 990 / 1000 = 0.99
F1-score = 2 * (0.5 * 0.33) / (0.5+0.33) = 0.4
Balanced Accuracy = (0.5 + 0.99) / 2 = 0.745
你可以看到平衡精度仍然比 F1 更关心数据中的负数。
考虑另一种情况，数据中没有真正的负数:
Precision = 5 / 15 = 0.33
Sensitivity = 5 / 10 = 0.5
Specificity = 0 / 10 = 0
F1-score = 2 * (0.5 * 0.33) / (0.5 + 0.33) = 0.4
Balanced Accuracy = (0.5 + 0) / 2 = 0.25
正如我们所看到的，F1 没有任何变化，而当真负值降低时，平衡精度会快速下降。
这表明 F1 分数更重视正面的数据点，而不是平衡的准确性。
平衡精度与 ROC_AUC
平衡精度和 roc_auc 有什么不同？
在制作模型之前，您需要考虑以下事项:
- 这是为了什么？
- 它有多少种可能性？
- 数据有多平衡？等等。
Roc_auc 类似于平衡精度，但有一些关键区别:
-
平衡准确度是根据预测类别计算的，roc_auc 是根据每个数据点的预测分数计算的，这些数据点不能通过混淆矩阵计算获得。
-
如果问题是高度不平衡的，平衡精度是比 roc_auc 更好的选择，因为 Roc_auc 是不平衡数据的问题，即当偏斜严重时，因为少量的正确/错误预测会导致分数的巨大变化。
-
如果我们希望在分类中观察到一系列可能性(概率)，那么最好使用 roc_auc，因为它是所有可能阈值的平均值。然而，如果类别是不平衡的，并且分类的目标是输出两个可能的标签，那么平衡的准确度更合适。
-
如果你既关心正负类，又关心稍微不平衡的分类，那么 roc_auc 更好。
使用二进制分类实现平衡的准确性
为了更好地理解平衡准确性和其他评分者，我将在一个示例模型中使用这些指标。代码将会在 Jupyter 笔记本上运行。数据集可以从这里下载。
我们将在这里使用的数据是欺诈检测。我们希望预测交易是否是欺诈性的。
我们的流程将是:
- 加载数据，
- 清理数据，
- 建模，
- 预测。
加载数据
像往常一样，我们从导入必要的库和包开始。
Import seaborn as sns
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from joblib import dump
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import roc_auc_score
from sklearn.metrics import confusion_matrix
from sklearn.metrics import balanced_accuracy_score
from sklearn.metrics import accuracy_score,f1_score,precision_score,recall_score
import warnings
warnings.filterwarnings('ignore')
data_file_path='.../train.csv'
Train =pd.read_csv(data_file_path)
如您所见，数据既有数字变量，也有分类变量，一些操作将通过这些变量进行。
让我们看看目标中类的分布，即‘欺诈性列’。
让我们来看看剧情。
sns.countplot(train['fradulent'])
plt.title('A plot of transaction')
plt.xlabel('target')
plt.ylabel('number of cases')
plt.show()
我们可以看到分布是不平衡的，因此我们进入下一个阶段——清理数据。
数据清理
这个数据没有 NAN 值，所以我们可以继续从时间戳中提取有用的信息。
我们将通过下面的代码提取交易的年份和时间:
train['hour']=train['transaction time'].str.split('T',expand=True)[1].str.split(':',expand=True)[0]
train['year']=train['transaction time'].str.split('-',expand=True)[0]
编码
下一步是将字符串(分类)变量编码成数字格式。我们将对其进行标记和编码。Sklearn 也为此提供了一个名为 LabelEncoder 的工具。
encode={'account type':{'saving':0,'current':1},
'credit card type':{'master':0,'verve':1},
'occupation':{'clergy':0,'accounting':1,'lecturer':2,'banking':3,
'doctor':4,'farmer':5,'lawyer':6, 'musician':7},
'marital_status':{'married':0,'single':1,'unknown':2},
'year':{'2014':0,'2015':1,'2016':2,'2017':3}
}
train=train.replace(encode)
由于现在已经进行了编码，数据应该如下所示:
True / False 值列不需要编码，因为它们是布尔值。
设置索引和删除列
数据中不重要的列需要放到下面:
train.drop(['transaction time','id'],axis=1,inplace=True)
数据缩放
我们需要调整数据，以确保每个特征的权重相同。为了缩放这些数据，我们将使用 StandardScaler。
X=train.drop(['fradulent'],axis=1)
y=train['fradulent']
from sklearn.preprocessing import StandardScaler
std= StandardScaler()
X=std.fit_transform(X)
建模
在拟合之前，我们需要将数据分为测试集和训练集，这使我们能够在部署之前了解模型在测试数据上的表现。
run = neptune.init(project=binaryaccuracy,
api_token=api_token)
x_train,x_test,y_train,y_test=train_test_split(X,y,test_size=0.2,random_state=0)
在这种分割之后，我们现在可以在查看计算图时，用我们到目前为止讨论过的评分标准来拟合和评分我们的模型。
for epoch in range(100,3000,100):
gb=GradientBoostingClassifier(n_estimators=epoch,learning_rate=epoch/5000)
gb.fit(x_train,y_train)
y_pred=gb.predict(x_test)
roc_auc=roc_auc_score(y_test,y_pred)
acc=accuracy_score(y_test,y_pred)
bal_acc=balanced_accuracy_score(y_test,y_pred)
recall=recall_score(y_test,y_pred)
precision=precision_score(y_test,y_pred)
f1=f1_score(y_test,y_pred)
run["train/accuracy"].log(acc)
run['train/f1'].log( f1)
run['train/roc_auc'].log(roc_auc)
run['train/bal_acc'].log(bal_acc)
查看上面的图表，我们可以看到模型预测如何基于历元和学习率迭代波动。
- 虽然准确性最初很高，但与其他记分员相比，它逐渐下降，没有完美的下降。它没有很好地处理混淆矩阵上的数据表示。
- F1 的分数在这里很低，因为它偏向于数据中的负值。然而，在上面的数据中，正面和负面都很重要。
- roc_auc 得分是一个没有偏见的得分，数据中的两个标签被给予同等的优先级。与具有 1:100 比率的目标标记的一些数据相比，该数据偏斜度不是很大，因此 ROC_AUC 在这里表现得更好。
- 总的来说，平衡准确性在数据评分方面做得很好，因为模型并不完美，它仍然可以得到更好的预测。
要查看预测并存储在元数据中，请使用以下代码:
df = pd.DataFrame(data={'y_test': y_test, 'y_pred': y_pred, 'y_pred_probability': y_pred_proba.max(axis=1)})
run['test/predictions'] = neptune.types.File.as_html(df)
记录元数据并查看绘图。图表中要记录和比较的指标有:acc(准确度)、f1(f1-得分)、roc_auc 得分、bal_acc(平衡准确度)。
此函数创建绘图并将其记录到元数据中，您可以从 scikitplot.metrics 中获得它处理的各种曲线。
def plot_curve(graph):
fig, ax = plt.subplots()
graph(y_test, y_pred_proba,ax=ax)
run['charts/{}'.format(graph)] = neptune.types.File.as_image(fig)
plot_curve(plot_roc)
平衡准确性的问题
我们已经讨论了很多关于平衡精度的问题，但是在一些情况下，即使是最简单的指标也是绝对合适的。
-
当数据平衡时。
-
当模型不仅仅是映射到(0，1)结果，而是提供广泛的可能结果(概率)时。
-
当模型更倾向于正面而非负面时。
-
在多类分类中，一些类的重要性不如另一些类，由于所有类都具有相同的权重而不考虑类的频率，因此可能会出现偏差。这样做可能会导致错误，因为我们的模型应该提供解决方案，而不是相反。
-
当有一个很高的偏差或者一些类比其他类更重要时，那么平衡的准确性就不是模型的完美评判。
摘要
研究和构建机器学习模型可能很有趣，但如果没有使用正确的度量标准，也会非常令人沮丧。正确的度量标准和工具非常重要，因为它们向您展示了您是否正确地解决了手头的问题。
这不仅仅是关于一个模型有多棒，更重要的是解决它被认为应该解决的问题。
平衡精度在某些方面是很好的，例如当类不平衡时，但是它也有缺点。深入理解它，会给你所需的知识，让你知道该不该用它。
感谢阅读！
贝叶斯神经网络——用 JAX 框架实现、训练和推理
原文：https://web.archive.org/web/https://neptune.ai/blog/bayesian-neural-networks-with-jax
贝叶斯神经网络(BNN)不同于人工神经网络(NN) 。主要区别——BNNs 可以回答“我不确定”。这很有趣，但为什么你会希望神经网络告诉你它不知道你问题的答案？
为了向您展示网络说“我不确定”的重要性，我们需要考虑处理非分布数据。在人工智能安全中，非分布检测是当有人试图用并非来自数据集的例子愚弄网络时，网络如何感知的。
我们将探索 BNNs 背后的理论，然后用 BNNs 实现、训练和运行数字识别任务的推理。这很棘手，但是我会告诉你你需要做什么来让 BNNs 开始学习。我们将把它编码在新的、热门的 JAX 框架中(如果你不知道，我们将做一个快速介绍)。
在文章的最后，我们将向我们的神经网络输入字母而不是数字，看看它会做什么。我们开始吧！
人工神经网络的贝叶斯观点
在我们开始之前，请注意这是一个复杂的话题。如果你觉得这个理论很难理解，那就直接跳到本文的编码部分。稍后，您还可以查看本文末尾链接的其他深入指南。
在非贝叶斯人工神经网络模型中(上图左侧)，我们训练网络参数的点估计。
在贝叶斯人工神经网络(上图右侧)中，我们用分布来表示我们对训练参数的信念，而不是点估计。代替变量，我们有随机变量，我们想从数据中推断。
什么是贝叶斯神经网络？
贝叶斯神经网络组件列表:
-
数据集 D 带有预测器 X (例如图像)和标签(例如类)。
-
*可能性 P(D|θ) 或 P(Y |X，θ) 用由 θ 参数化的神经网络(NN)计算的逻辑上的分类 softmax 分布表示，例如 softmax 多层感知器。
- 注意:到目前为止，它与非贝叶斯神经网络没有区别。
- 如果我们“正常地”训练它 SGD 使用交叉熵损失——那么我们可以说，我们得到了参数的最大似然点估计。参见“深度学习”，第 5.5 章:最大似然估计(“深度学习”。自适应计算和机器学习。”麻省理工学院出版社，2016 )
- 然而，使用贝叶斯神经网络，参数来自它们的分布。进一步阅读！*
-
在神经网络参数之前，【P(θ)】用正态分布来表示。**
- 它编码了我们对参数值可能是什么的先验知识(或者说缺乏知识)。
- 然而，我们怀疑这些是零附近的一些小值。
- 这一假设来自我们的先验知识，即当我们将 dnn 的参数保持在 0 附近时，它们往往工作得很好。**
-
在看到数据之后，我们的 NN 参数的后验P(θ| D)***—人们可以说是“在训练之后”。
- 这是训练参数的分布。
- 我们将使用贝叶斯定理来计算它…
- …或者至少我们会尝试这样做。***
**### 贝叶斯定理
从理论上讲，贝叶斯定理是我们应该用来根据先验和似然性计算神经网络参数的后验概率的工具。但是，有一个条件。
这个积分很难计算。只有在一些需要使用共轭先验的特殊情况下才容易处理。在“深度学习”，第 5.6 章:贝叶斯统计(“深度学习”中了解更多信息。自适应计算和机器学习。”麻省理工出版社，2016 。在《走向数据科学》网站上还有一篇关于共轭先验的精彩文章。
在我们的例子中，它很难处理，因为这个积分没有解析解。我们使用一个复杂的非线性函数，名为“人工神经网络”。这在计算上也很难处理，因为在分母中有指数数量的可能参数赋值需要评估和求和。
想象一个二元神经网络，它对 N 个参数分配了2^N个参数。对于 N=272，就是2^(272)，已经比可见宇宙中的原子数量还要多。让我们同意，272 个参数并不多，要知道现代 CNN-s 有数百万个参数。****
变分推理为救援！
不会算？然后近似！
我们用一个分布 Q 来近似后验概率，称为变分分布，最小化它们之间的 KL 散度[KL](Q(θ)| |P(θ| D))**。我们将找到与后验概率最接近的概率分布，它由一小组参数表示，如多元高斯分布的均值和方差，并且我们知道如何从中采样。
此外，我们必须能够通过它进行反向传播，并每次对分布的参数(即均值和方差)进行一点点修改，以查看最终的分布是否更接近我们想要计算的后验分布。
如果后验概率正是我们想要计算的，我们如何知道最终的分布是否更接近后验概率？就是这个想法！
从分布之间的 KL 散度，D[KL](Q(θ)| |P(θ| D))**，可以得到证据下界(ELBO)。
这就是所谓的变分推理。它把推理问题变成了优化问题。通过优化右侧，我们优化了从我们的变分分布 NN 参数【θ∾Q()中采样的经典最大似然分类损失(例如交叉熵损失)，减去正则化损失，对于高斯分布，正则化损失采用封闭形式，这意味着它是一个众所周知的方程，您将在一分钟内看到。
通过优化它，我们最大化证据——我们的数据集为真的概率——并最小化我们的变分分布、【Q(θ)和后验、 P(θ|D) 之间的差异。后路正是我们想要的，是我们的目标！
还有一个注意:它被称为证据下限，因为 KL 散度将总是正的。因此，右边是左边证据的下限。详见本教程:多尔施，卡尔。变型自动编码器教程。
现在，正如所承诺的，我们有了 NN 参数上的分布，【Q(θ)，我们知道如何使用 ELBO 学习它。让我们跳到代码中来看看它的实践吧！
什么是 JAX？
正如我之前提到的，我们将使用 JAX。
“JAX亲笔签名和 XLA ，聚在一起进行高性能数值计算和机器学习研究。它提供了 Python+NumPy 程序的可组合转换:区分、矢量化、并行化、实时编译到 GPU/TPU，等等。”~ JAX 文档。
您可以查看 JAX 文档，但是您可能不需要它来理解下面的代码。正如作者所说，这就像机器学习和深度学习研究的 NumPy。但是，我建议至少读一节，关于随机数的那一节。这可能不直观，因为通常在 NumPy 中你不必考虑伪随机数发生器的状态，但是在 JAX 中，你可以显式地将它传递给随机值采样函数。
基于 JAX 的贝叶斯神经网络用于数字分类
你可以在这里找到代码。README 告诉您如何运行它。我鼓励你现在就去做，然后读完这篇文章。该回购包括:
- MNIST 的 mlp 分类器(在 JAX 和俳句中)。
- MNIST 上的伯努利 vae 生成模型。
- Bayes . py–MNIST 上的变分 Bayes NN 分类器。
今天，我们将做最后一个，变分贝叶斯神经网络分类器。我们将讨论代码中最重要的部分。
关于 HumbleSL(HSL 包)的说明
HumbleSL 是我写的直接监督学习(SL) Python 库。它提供了进行深度 SL 所需的所有样板代码:
- 一个网络定义工厂，
- 度量和损失，
- 一种数据加载器，
- 火车环线，
- 等等。
它得到了 JAX 图书馆和 T2 俳句框架的支持。它使用 TensorFlow 数据集进行数据加载和预处理。
培养
下载 MNIST 数据集
第 56-61 行下载训练和测试数据集。
train_dataset = hsl.load_dataset(
'mnist:3.*.*', 'train', is_training=True, batch_size=FLAGS.batch_size)
train_eval_dataset = hsl.load_dataset(
'mnist:3.*.*', 'train', is_training=False, batch_size=10000)
test_eval_dataset = hsl.load_dataset(
'mnist:3.*.*', 'test', is_training=False, batch_size=10000)
train_dataset 用于训练。train_eval_dataset 用于对训练数据集进行性能评估。test_eval_dataset 用于对测试数据集进行性能评估，你猜对了。
数据集是迭代器，您可以通过以下方式访问图像(和标签)的连续批次:
batch_image, batch_label = next(train_dataset)
创建多层感知器(MLP)模型
第 71-74 行创建了 MLP 模型。
net = hk.without_apply_rng(hk.transform(
hsl.mlp_fn,
apply_rng=True
))
如果你对这个片段到底做了什么感兴趣，请查看俳句基础。所有你需要知道的是，它创建了“标准”的 MLP 与 64 个单位的两个隐藏层。
它在输入端接受一个 28×28 的图像，并返回对应于每个可能的类(数字)的 10 个值。net 对象有两个函数:init 和 apply。
- params = net.init(next(rng)，batch_image)获取下一个随机生成器状态和图像批次，并返回初始模型参数。它需要随机发生器状态来采样参数。
- logits = net.apply(params，batch_image)获取模型参数和图像批次，然后返回批次输出(10 个数字的批次)。
你可以把网络想象成一个典型的裸架构。你需要提供一些参数来预测它。
初始化贝叶斯神经网络参数
第 79-85 行获取 MLP 模型参数，并使用它来初始化贝叶斯神经网络参数。
prior = dict(
mu=params,
logvar=jax.tree_map(lambda x: -7 * jnp.ones_like(x), params),
)
我们用平均场逼近后验概率。这意味着我们用以均值和方差(或对数方差)为参数的高斯分布来表示我们的变分分布，因为它可以采用任何值，而不仅仅是正值，这简化了训练。我们这样做是因为从高斯分布中取样很容易。
记住这里，后验概率是经过训练的 MLP 参数的分布。我们没有一套 MLP 参数来训练。我们训练近似后验的变分分布，并从中采样 MLP 参数。在代码中，对于变量名，我可能会交替使用 aprx_posterior、posterior 和 prior 来表示变分分布，我承认这不是 100%正确，但在实践中，它们是一回事，或者我想强调训练参数的阶段(即 prior 是未训练的后验)。
初始化优化程序
第 89-90 行定义并初始化 ADAM 优化器。
opt = optix.adam(FLAGS.lr)
opt_state = opt.init(prior)
就这么简单。您传递学习率 FLAGS.lr 和初始参数 prior。当然，优化器用于将梯度应用到参数上。与标准深度学习中的相同。
定义目标
第 92-110 行定义了 ELBO 目标。
def elbo(aprx_posterior, batch, rng):
"""Computes the Evidence Lower Bound."""
batch_image, batch_label = batch
params = sample_params(aprx_posterior, rng)
logits = net.apply(params, batch_image)
log_likelihood = -hsl.softmax_cross_entropy_with_logits(
logits, batch_label)
kl_divergence = jax.tree_util.tree_reduce(
lambda a, b: a + b,
jax.tree_multimap(hsl.gaussian_kl,
aprx_posterior['mu'],
aprx_posterior['logvar']),
)
elbo_ = log_likelihood - FLAGS.beta * kl_divergence
return elbo_, log_likelihood, kl_divergence
它获取一批图像(和标签)，对 MLP 参数进行采样，并对它们进行预测。然后，它计算 logits 和标签之间的交叉熵(分类损失)，并计算变分分布和正态分布之间的 KL 散度(正则化损失)。
hsl.gaussian_kl 以封闭形式计算后者。由 flagsβ加权的两者的组合产生 ELBO。这与上面 ELBO 的数学表达式相匹配。损失是负面的 ELBO:
def loss(params, batch, rng):
"""Computes the Evidence Lower Bound loss."""
return -elbo(params, batch, rng)[0]
我们需要取反，因为 JAX 优化器只能做梯度下降。然而，我们需要最大化 ELBO，而不是最小化它。
训练循环
第 116-126 行定义了 SGD 更新步骤。这是我们进行培训所需的最后一块。
@jax.jit
def sgd_update(params, opt_state, batch, rng):
"""Learning rule (stochastic gradient descent)."""
grads = jax.grad(loss)(params, batch, rng)
updates, opt_state = opt.update(grads, opt_state)
posterior = optix.apply_updates(params, updates)
return posterior, opt_state
此函数执行 SGD 更新的一个步骤。首先，它评估损失函数对于当前参数和该批数据的梯度。然后，计算更新并将其应用于参数。这个函数在一次更新后返回新的变分分布参数和优化器状态。之所以需要后者，是因为 ADAM 优化器存储并更新其自适应矩估计所需的状态。
现在，您只需在循环中运行这个函数，训练就会继续进行。我有一个助手函数:hsl.loop，它还负责检查点和定期评估训练和测试性能。
估价
第 128-140 行计算诊断。
def calculate_metrics(params, data):
"""Calculates metrics."""
images, labels = data
probs = predict(net, params, images, next(rng), FLAGS.num_samples)[0]
elbo_, log_likelihood, kl_divergence = elbo(params, data, next(rng))
mean_aprx_evidence = jnp.exp(elbo_ / FLAGS.num_classes)
return {
'accuracy': hsl.accuracy(probs, labels),
'elbo': elbo_,
'log_likelihood': log_likelihood,
'kl_divergence': kl_divergence,
'mean_approximate_evidence': mean_aprx_evidence,
}
它从对提供的参数和数据运行预测开始。这不同于在 ELBO 物镜中简单地采样一组参数。下一小节将对此进行描述。这些预测与地面实况标注一起用于计算精度 hsl.accuracy 辅助函数。
接下来，我们计算 ELBO、分类损失(log_likelihood)和正则化损失(kl_divergence)。ELBO 用于计算近似证据，这直接来自 ELBO 的公式——它是证据下界，不是吗？这是在当前参数下数据的近似概率，即图像具有相应的标签。越高越好，因为这意味着我们的模型很好地拟合了数据-它为来自数据集的标签提供了高概率。
所有这些指标都放在一个字典中，并返回给调用者。在我们的例子中，hsl.loop 辅助函数将不时地对来自训练和测试数据集的数据以及当前参数调用它。
预言；预测；预告
第 41-49 行运行预测。
def predict(net, prior, batch_image, rng, num_samples):
probs = []
for i in range(num_samples):
params_rng, rng = jax.random.split(rng)
params = sample_params(prior, params_rng)
logits = net.apply(params, batch_image)
probs.append(jax.nn.softmax(logits))
stack_probs = jnp.stack(probs)
return jnp.mean(stack_probs, axis=0), jnp.std(stack_probs, axis=0)
这只是在样本数量 _ 样本参数集上运行预测。然后，对预测进行平均，并计算这些预测的标准偏差作为不确定性的度量。
说到不确定性，现在我们已经有了所有的部分，让我们来玩一下贝叶斯神经网络。
玩贝叶斯神经网络
您运行代码并看到以下内容:
0 | test/accuracy 0.122
0 | test/elbo -94.269
0 | test/kl_divergence 26.404
0 | test/log_likelihood -67.865
0 | test/mean_approximate_evidence 0.000
0 | train/accuracy 0.095
0 | train/elbo -176.826
0 | train/kl_divergence 26.404
0 | train/log_likelihood -150.422
0 | train/mean_approximate_evidence 0.000
这些是训练前的诊断，看起来没问题:
- 精确度约为 10%,对于随机初始化的神经网络来说是非常好的。这是随机猜测标签的准确性。
- ELBO 非常低，这在开始是没问题的，因为我们的变分分布远离真实的后验概率。
- 变分分布和正态分布之间的 KL 散度为正。它一定是正的，因为我们是以封闭形式计算的，而 KL，因为它是距离的度量，不能取负值。
- MLP 模型返回的真实标签的对数似然或对数概率非常低。这意味着模型将低概率分配给真正的标签。如果我们还没有训练它，这是预料之中的。
- 平均近似证据为 0。同样，我们还没有训练模型，所以它根本没有对数据集建模。
让我们运行 10k 步，再次查看诊断结果:
10000 | test/accuracy 0.104
10000 | test/elbo -5.796
10000 | test/kl_divergence 2.516
10000 | test/log_likelihood -3.280
10000 | test/mean_approximate_evidence 0.560
10000 | train/accuracy 0.093
10000 | train/elbo -5.610
10000 | train/kl_divergence 2.516
10000 | train/log_likelihood -3.095
10000 | train/mean_approximate_evidence 0.571
这不好。真实标签的概率上升，log_likelihood 和
均值近似证据上升，变分分布更接近正态分布，kl 散度下降。
然而，采用返回概率的 argmax 来推断标签并将其与地面真实标签进行比较的准确度仍然比随机分类器好大约 10%。这不是代码中的错误。诊断是正确的，我们需要两个技巧来训练它。继续读！
训练贝叶斯神经网络的技巧
低β值
β参数对分类损失和正则化损失进行加权。beta 越高，正则化越强。太强的正则化会对模型有太多的约束，它将不能对任何知识进行编码。在上面的例子中，它被设置为 flagsβ= 1。
这使得 kl_divergance(正则化损失)大幅下降。但是，太强了！更好的值大约是 FLAGS.beta = 0.001，这是我提供给你的代码中的默认值。
低初始方差
另一件事是变分分布的初始方差。太大了，网络很难开始训练和编码任何有用的知识。这是因为采样参数变化很大。在上面的例子中，它被设置为大约 0.37。在代码中，默认情况下，它被设置为~0.001，这是一个更好的值。
固定示例
现在我们已经将超参数更改为正确的参数，让我们看看 10k 步后的诊断结果:
10000 | test/accuracy 0.979
10000 | test/elbo -0.421
10000 | test/kl_divergence 318.357
10000 | test/log_likelihood -0.103
10000 | test/mean_approximate_evidence 0.959
10000 | train/accuracy 0.995
10000 | train/elbo -0.341
10000 | train/kl_divergence 318.357
10000 | train/log_likelihood -0.022
10000 | train/mean_approximate_evidence 0.966
测试准确率为 98%，我们可以同意它现在工作！注意正则化损失(kl_divergence)有多大。
是的，它离正态分布有那么远，但它需要如此。尽管如此，有了这个小测试，它仍然可以防止过度拟合。平均近似证据也非常高，这意味着我们的模型很好地预测了数据。注意 ELBO 也非常接近零(这是它的最大值)。
查找不符合分布的示例
我把训练好的模型放在上面的数字“3”和字母“B”上运行。以下是输出结果:
| 预言；预测；预告 | 可能性 | Std。戴夫。(不确定性) | |
|---|---|---|---|
| 0 | |||
如你所见，它将数字“3”归类为 3 没有任何问题。然而，当我们给它喂食它在训练中没有看到的东西时，一件有趣的事情发生了。该模型将字母“B”分类为 8。如果我们处理的是正常的神经网络，那就是了。
幸运的是，我们训练的贝叶斯神经网络也可以告诉我们它有多确定。
我们看到，在数字“3”的情况下，它是可信的——STD。戴夫。概率为 0 左右。对于字母“B ”,它返回的概率在任一方向上可以变化 0，45 %!
这就像我们的模型告诉我们“如果我不得不猜，那么这是 8，但它可能是任何东西——我以前没见过这个。”
这样，贝叶斯神经网络既可以对图像进行分类，也可以说“我不知道”。我们可以查出性病。戴夫。阈值，在该阈值之后，我们拒绝来自例如我们用来评估我们的模型的测试数据集的分类。
我简单地在整个测试数据集上运行模型，并观察 std。戴夫。它的预测值。然后，我取第 99 个百分位数(99%的其他值较低的值)，在本例中为 0.37。因此，我决定应该拒绝 1%测试图像的分类。
我这样做是因为我知道 MNIST 数据集中有一些疯狂的图像，连我都无法正确分类。回到我们的例子，显然 0.45 > 0.37，所以我们应该拒绝字母“B”的分类。
结论
就是这样！现在你可以训练一个不会让你愚弄它的神经网络。不确定性估计是人工智能安全中的一个大主题。我留给你们更多的阅读材料:**
关于正在重塑人工智能格局的 BERT 和 Transformer 架构，你需要知道的 10 件事
原文：https://web.archive.org/web/https://neptune.ai/blog/bert-and-the-transformer-architecture
目前，很少有人工智能领域比 NLP 更令人兴奋。近年来，可以执行类似人类语言任务的语言模型(LM)已经发展到比任何人预期的更好。
事实上，他们表现得如此之好，以至于人们怀疑他们是否达到了一般智力的水平，或者我们用来测试他们的评估标准跟不上。当像这样的技术出现时，无论是电力、铁路、互联网还是 iPhone，有一点是明确的——你不能忽视它。它将最终影响现代世界的每一个部分。
了解这样的技术很重要，因为这样你就可以利用它们。所以，我们来学习吧！
我们将涵盖十个方面，向您展示这项技术的来源、开发方式、工作原理以及在不久的将来会有什么样的前景。这十件事是:
- 什么是 BERT 和变压器，为什么我需要了解它？像 BERT 这样的模型已经对学术界和商业界产生了巨大的影响，因此我们将概述这些模型的一些使用方法，并澄清围绕它们的一些术语。
- 在这些模型之前，我们做了什么？要了解这些模型，重要的是要了解这一领域的问题，并了解在 BERT 等模型出现之前我们是如何解决这些问题的。通过这种方式，我们可以了解以前模型的局限性，并更好地理解 Transformer 架构关键设计方面背后的动机，这是大多数 SOTA 模型(如 BERT)的基础。
- NLPs“ImageNet 时刻；预训练模型:原来我们都是自己训练模型，或者你要针对某个特定任务，全面训练一个模型。实现性能快速发展的关键里程碑之一是创建预先训练的模型，这些模型可以“现成”使用，并根据您的具体任务进行调整，只需很少的努力和数据，这一过程称为迁移学习。理解这一点是理解为什么这些模型在一系列 NLP 任务中一直表现良好的关键。
- 了解变形金刚:你可能听说过伯特和 GPT-3，但是关于罗伯塔、艾伯特、 XLNet ，或者龙前、改革者，或者 T5 变形金刚呢？新模型的数量看起来势不可挡，但是如果您理解 Transformer 架构，您将有机会了解所有这些模型的内部工作方式。这和你理解 RDBMS 技术的时候是一样的，让你很好的掌握 MySQL、PostgreSQL、SQL Server 或者 Oracle 之类的软件。支撑所有数据库的关系模型与支撑我们的模型的转换器架构是一样的。明白了这一点，RoBERTa 或 XLNet 就成了使用 MySQL 或 PostgreSQL 的区别。学习每个模型的细微差别仍然需要时间，但是你有一个坚实的基础，你不是从零开始。
- 双向性的重要性:当你读这篇文章时，你并没有严格地从一边读到另一边。你不是从一边到另一边一个字母一个字母地读这个句子。相反，你正在向前跳跃，从你现在所处的位置之前的单词和字母中学习上下文。事实证明，这是变压器架构的一个关键特性。Transformer 架构支持模型以双向方式处理文本，从开始到结束，从结束到开始。这是以前模型局限性的核心，以前的模型只能从头到尾处理文本。
- 伯特和变形金刚有什么不同？ BERT 使用 Transformer 架构，但在几个关键方面有所不同。对于所有这些模型，理解它们与 Transformer 的不同是很重要的，因为这将定义它们可以做好哪些任务，以及它们将努力完成哪些任务。
- 记号化器——这些模型如何处理文本:模型不会像你我一样阅读，所以我们需要对文本进行编码，以便它可以被深度学习算法处理。如何对文本进行编码对模型的性能有很大的影响，这里的每个决定都要进行权衡。所以，当你看另一个模型时，你可以先看看所使用的记号赋予器，并且已经了解了关于那个模型的一些东西。
- 掩饰——聪明的工作与努力的工作:你可以努力工作，也可以聪明地工作。和深度学习 NLP 模型没什么区别。这里的艰苦工作只是使用一个普通的 Transformer 方法，并向模型中投入大量数据，使其性能更好。像 GPT-3 这样的模型有令人难以置信的大量参数，使它能够以这种方式工作。或者，您可以尝试调整训练方法，以“强制”您的模型从更少的内容中学到更多。这就是像伯特这样的模型试图用掩蔽来做的事情。通过理解这种方法，你可以再次用它来观察其他模型是如何被训练的。他们是否采用创新技术来提高这些模型能够从给定的数据中提取多少“知识”？还是他们采取了一种更野蛮的方法，扩大规模，直到你打破它？
- 微调和迁移学习:BERT 的主要优势之一是它可以针对特定领域进行微调，并针对许多不同的任务进行培训。像伯特和 GPT-3 这样的模型是如何学习执行不同的任务的？
- 鳄梨椅——伯特和其他变形金刚型号的下一步是什么？为了回顾 BERT 和 Transformer 架构，我们将展望这些模型的未来
1.什么是伯特和变压器，为什么我需要了解它？
The Transformer (Muppet) family | Source: PLM Papers
为了理解 BERT 和 Transformer 的范围和速度，让我们看看这项技术的时间框架和历史:
- 2017:Transformer 架构于 2017 年 12 月在一篇谷歌机器翻译论文中首次发布“ 注意力是你所需要的全部 ”。那篇论文试图找到能够自动翻译多语言文本的模型。在此之前，许多机器翻译技术都涉及一些自动化，但它受到重要规则和基于语言的结构的支持，以确保翻译对于像 Google Translate 这样的服务来说足够好。
- 2018 : BERT(来自变压器的双向编码器表示)于 2018 年 10 月在“ 深度双向变压器语言理解预训练 中首次发布。
Improvements in Google translate with the Transformer | Source: Google AI Blog
起初，Transformer 主要影响机器翻译领域。新方法带来的改进很快被注意到。如果它停留在翻译领域，那么可能现在就不会读这篇文章了。
翻译只是一系列自然语言处理任务中的一项，包括词性标注、命名实体识别(NER)、情感分类、问答、文本生成、摘要、相似性匹配等等。以前，这些任务中的每一个都需要一个经过特殊训练的模型，所以没有人需要学习所有的任务，而且你通常只对你自己的领域或特定的任务感兴趣。
然而，当人们开始关注 Transformer 架构，并怀疑它是否能做一些不仅仅是翻译文本的事情时，这种情况发生了变化。他们观察了该架构能够“集中注意力”于特定单词并比其他模型处理更多文本的方式，意识到这可以应用于广泛的其他任务。
我们将在第 5 节中讨论转换器的“注意力”能力，我们将展示它如何使这些模型能够双向处理文本，并查看与当时正在处理的句子的特定上下文相关的内容。
一旦人们意识到 Transformer 架构可以被分解，并以不同的方式执行一系列任务，它的影响就开始迅速增长:
正是在这一点上，《变形金刚》超越了 NLP。突然间，人工智能的未来不再是有感知能力的机器人或自动驾驶汽车。
如果这些模型可以从文本中学习上下文和意义，并执行广泛的语言任务，这是否意味着它们理解文本？他们会写诗吗？他们会开玩笑吗？如果它们在某些 NLP 任务中表现得比人类更好，这是一般智力的一个例子吗？
像这样的问题意味着这些模型不再局限于聊天机器人和机器翻译的狭窄领域，而是它们现在是人工智能一般智能更大辩论的一部分。
“… in a lecture published Monday, Bengio expounded upon some of his earlier themes. One of those was attention — in this context, the mechanism by which a person (or algorithm) focuses on a single element or a few elements at a time. It’s central both to machine learning model architectures like Google’s Transformer and to the bottleneck neuroscientific theory of consciousness, which suggests that people have limited attention resources, so information is distilled down in the brain to only its salient bits. Models with attention have already achieved state-of-the-art results in domains like natural language processing, and they could form the foundation of enterprise AI that assists employees in a range of cognitively demanding tasks”. | Source: VentureBeat
像任何范式转换技术一样，了解它是被夸大还是被低估是很重要的。最初，人们认为电力不是一项变革性的技术，因为它需要时间来重新定位工作场所和城市环境，以利用电力提供的优势。
铁路也是如此，互联网诞生之初也是如此。关键是，不管你同意还是不同意，你至少需要对手边快速发展的技术有一些看法。
这就是我们现在对伯特这样的模型的看法。即使你不使用它们，你仍然需要理解它们可能对人工智能的未来产生的潜在影响，以及如果它让我们更接近开发普遍智能的人工智能——对社会的未来产生的影响。
2.伯特之前存在什么？
BERT 和 Transformer 架构本身，都可以在他们试图解决的问题的上下文中看到。像其他商业和学术领域一样，机器学习和 NLP 的进展可以被视为试图解决当前技术的缺点或不足的技术进化。亨利·福特使汽车更便宜、更可靠，因此它们成为了马的可行替代品。电报改进了以前的技术，能够与人交流而不需要亲自到场。
在 BERT 之前，NLP 的最大突破是:
- 2013 : Word2Vec 论文， 向量空间中单词表征的高效估计 发表。连续单词嵌入开始被创建，以更准确地识别单词的语义和相似性。
- 2015 : Sequence to sequence 的文本生成方法 一篇论文发布了一个神经对话模型 。它建立在 Word2Vec 中首次展示的一些技术之上，即深度学习神经网络从大量非结构化文本中学习语义和句法信息的潜在能力。
- 2018 :来自语言模型的嵌入(ELMo)论文 深度语境化词语表征 发布。ELMo(这是整个布偶命名的开始，不幸的是，它并没有停止，见厄尼、大鸟和 KERMIT )在单词嵌入方面是一个飞跃。它试图解释使用一个单词的上下文，而不是静态的，一个单词，一个意思的 Word2Vec 的限制。
在 Word2Vec 之前，单词嵌入要么是使用 one hot 编码技术的具有大量稀疏向量的简单模型，要么是我们使用 TF-IDF 方法来创建更好的嵌入，以忽略常见的低信息量单词，如“”、“ this ”、“ that ”。
*
One hot embeddings are not really useful since they fail to show any relationship between words, source: FloydHub blog
这些类型的方法在它们的向量中编码很少的语义意义。我们可以用它们来分类文本和识别文档之间的相似性，但是训练它们是困难的，并且它们的整体准确性是有限的。
Word2Vec 通过设计两种新的神经网络架构改变了这一切；跳跃式语法和连续词袋(CBOW)让我们能够在大量文本中训练单词嵌入。这些方法迫使神经网络在给出句子中其他单词的一些例子的情况下尝试并预测正确的单词。
这种方法背后的理论是常用词将一起使用。例如，如果你在谈论“手机”，那么我们很可能也会看到类似“手机”、 iPhone 、 Android 、电池、触摸屏等词汇。这些词可能会在足够频繁的基础上同时出现，以至于该模型可以开始设计一个具有权重的大向量，这将有助于它预测当它看到“电话”或“移动”等时可能会发生什么。然后，我们可以使用这些权重或嵌入来识别彼此相似的单词。
Word2Vec showed that embeddings could be used to show relationships between words like capital cities and their corresponding countries | Source: Semantic Scholar Paper
通过对更大的文本序列(如句子)做类似的事情，这种方法通过文本生成的例子得到了扩展。这就是所谓的顺序对顺序方法。它扩展了深度学习架构的范围，以执行越来越复杂的 NLP 任务。
这里要解决的关键问题是语言是一个连续的单词流。一个句子没有标准长度，每个句子都不一样。通常，这些深度学习模型需要知道它们正在处理的数据序列的固定长度。但是，这在文本中是不可能的。
因此，序列对序列模型使用了一种称为递归神经网络(RNNs)的技术。有了它，这些架构可以执行“循环”,并连续处理文本。这使他们能够创建响应输入提示产生文本的 LMs。
An example of how to think of RNNs as “looping” output from one part of the network to the input of the next step in a continuous sequence | Source: Chis Olah’s (amazing) post on RNNs
尽管像 Word2Vec 这样的模型和 RNNs 这样的体系结构在 NLP 方面取得了令人难以置信的进步，但它们仍然有一些缺点。Word2Vec 嵌入是静态的——每个单词都有一个固定的嵌入，即使单词根据上下文有不同的含义。RNN 架构的训练速度很慢，这限制了它可以训练的数据量。
正如我们所提到的，每一个新的模型都可以被看作是在以前的基础上进行改进的尝试。ELMo 试图解决 Word2Vec 的静态单词嵌入的缺点，采用 RNN 方法来训练模型识别单词含义的动态性质。
这是通过尝试根据单词所在的句子，动态地给单词分配一个向量来实现的。ELMo 模型允许用户向模型中输入文本，并基于该句子生成嵌入，而不是像 Word2Vec 那样使用带有单词和嵌入的查找表。因此，它可以根据上下文为一个单词产生不同的含义。
ELMo uses two separate networks to try and process text “bidirectionally” | Source Google AI Blog
这里需要注意的另一个要点是，ELMo 是第一个尝试非顺序处理文本的模型。以前的模型如 Word2Vec 一次读取一个单词，并按顺序处理每个单词。埃尔莫试图复制人类阅读文本的方式，他用两种方式处理文本:
- 开始到结束:架构的一部分正常读取文本，从开始到结束。
- 反过来，end to start :架构的另一部分从后往前读文本。理想的情况是，模型可以通过阅读“未来”来学习其他东西。
- 组合:在文本被阅读后，两个嵌入被连接起来“组合”意思。
这是一种双向阅读文本的尝试。虽然它不是“真正”双向的(它更像是一种反向的单向方法)，但它可以被描述为“浅”双向的。
在很短的时间内，我们已经看到了一些快速的进步，从 Word2Vec 到更复杂的神经网络架构，如用于文本生成的 RNNs，再到通过 ELMo 基于上下文的单词嵌入。然而，使用这些方法训练大量数据的限制仍然存在问题。这严重阻碍了这些模型提高在一系列 NLP 任务中表现良好的能力的潜力。这就是预训练的概念为伯特这样的模型的到来奠定了基础，以加速进化。
3.预训练的 NLP 模型
简单地说，如果没有预训练模型的出现，BERT(或任何其他基于 Transformer 的模型)的成功是不可能的。预训练模型的理想在深度学习中并不新鲜。在图像识别方面已经实践了很多年。
Training a model on a massive amount of data and then making it available pre-trained enabled innovation in machine vision | Source
ImageNet 是一个巨大的标签图像数据集。多年来，它一直是训练图像识别模型的基础。这些模型学会了从这些大型数据库中识别图像识别的关键方面。这是识别图像边界、边缘和线条以及常见形状和物体的能力。
这些通用的训练模型可以下载，并用于训练你自己的，小得多的数据集。假设你想训练它识别你公司的人的脸。你不需要从零开始，让模型了解图像识别的一切，而是只需建立一般训练的模型，并根据你的数据调整它们。
像 Word2Vec 这样的模型的问题是，虽然它们是在大量数据上训练的，但它们不是通用的语言模型。您可以根据您的数据从头开始训练 Word2Vec，或者您可以简单地使用 Word2Vec 作为网络的第一层来初始化您的参数，然后添加层来为您的特定任务训练模型。因此，您可以使用 Word2Vec 来处理您的输入，然后为您的情感分类或 POS 或 NER 任务设计您自己的模型层。这里的主要限制是，每个人都在训练自己的模型，很少有人有资源(无论是数据还是计算成本)来训练任何非常大的模型。
正如我们在第 2 节中提到的那样，直到 2018 年像 ELMo 这样的模型出现。在那段时间，我们看到其他模型，如 ULMFit 和Open AIs first transformer model，也创建预训练模型。
这就是领先的 NLP 研究人员 Sebastian Ruder 所说的 NLPsImageNet moment——NLP 研究人员开始在预训练模型的强大基础上构建新的更强大的 NLP 应用程序。他们不需要大量的资金或数据来做这件事，这些模型可以“开箱即用”。
这对于像 BERT 这样的模型至关重要的原因有两个:
- 数据集大小:语言杂乱、复杂，对计算机来说比识别图像要难学得多。他们需要更多的数据来更好地识别语言模式，识别单词和短语之间的关系。像最新的 GPT-3 这样的模型是在 45TB 的数据上训练的，包含 1750 亿个参数。这些是巨大的数字，所以很少有人甚至组织有资源来训练这些类型的模型。如果每个人都必须训练自己的 BERT，如果研究人员不利用这些模型的力量，我们将会看到很少的进展。进展将是缓慢的，并且仅限于几个大玩家。
- 微调:预先训练的模型具有双重优势，即它们可以“现成”使用，即无需任何更改，企业只需将 BERT 插入他们的管道，并与聊天机器人或其他应用程序一起使用。但这也意味着这些模型可以针对具体任务进行微调，而无需太多数据或模型调整。对于 BERT 来说，你所需要的只是几千个例子，你可以根据你的数据进行微调。预训练甚至使得像 GPT-3 这样的模型可以在如此多的数据上进行训练，以至于他们可以采用一种被称为零或少量拍摄学习的技术。这意味着他们只需要看一些例子就能学会执行一项新任务，比如编写一个计算机程序。
随着预训练模型的兴起，以及从 Word2Vec 到 ELMo 的训练和架构的进步，现在是 BERT 登场的时候了。在这一点上，我们知道我们需要一种方法来处理更多的数据并从这些数据中学习更多的上下文，然后使其在预训练的模型中可用，供其他人在他们自己的领域特定的应用中使用。
4.变压器架构
如果你从这篇文章中学到了什么，那就是对 Transformer 架构的总体理解，以及它与 BERT 和 GPT-3 等模型的关系。这将让您查看不同的 Transformer 模型，了解他们对 vanilla 架构做了哪些调整，并了解他们试图解决什么问题或任务。这提供了一个关键的洞察力，它可能更适合什么任务或领域。
据我们所知，最初的变形金刚论文叫做“注意力是你所需要的全部”。名称本身很重要，因为它指出了它与以前的方法有什么不同。在第 2 节中，我们注意到 ELMo 等模型采用 RNNs 以类似循环的方式顺序处理文本。
RNNs with sequence to sequence approaches processed text sequentially until they reached an end of sentence token (
现在想一个简单的句子，比如“狗在街上追着猫跑”。对于一个人来说，这是一个容易理解的句子，但是如果你想按顺序处理它，实际上有很多困难。一旦你到了“ it 部分，你怎么知道它指的是什么？您可能需要存储一些状态来识别这个句子中的主角是“猫”。然后，当你继续阅读这个句子时，你必须找到某种方法将" it "和" cat "联系起来。
现在想象这个句子的长度可以是任意数量的单词，试着想想当你处理越来越多的文本时，你将如何跟踪被引用的内容。
这就是序列模型遇到的问题。
它们是有限的。他们只能优先考虑最近处理过的单词的重要性。随着他们继续沿着句子前进，前面单词的重要性或相关性开始减弱。
你可以把它想象成在处理每个新单词时向列表中添加信息。您处理的单词越多，就越难引用列表开头的单词。本质上，你需要一次一个元素，一个单词一个单词地往回移动，直到你找到更早的单词，然后看看那些实体是否相关。
“它是指“猫”吗？这就是所谓的“消失梯度”问题，ELMo 使用了一种称为长短期记忆网络(LSTMs)的特殊网络来缓解这种现象的后果。LSTMs 确实解决了这个问题，但没有消除它。
最终，他们无法创造一种有效的方式来“聚焦”每个句子中的重要单词。这就是变压器网络通过使用我们已知的“注意”机制来解决的问题。
This gif is from a great blog post about understanding attention in Transformers. The green vectors at the bottom represent the encoded inputs, i.e. the input text encoded into a vector. The dark green vector at the top represents the output for input 1. This process is repeated for each input to generate an output vector which has attention weights for the “importance” of each word in the input which are relevant to the current word being processed. It does this via a series of multiplication operations between the Key, Value and Query matrices which are derived from the inputs. Source: Illustrated Self-Attention.
“注意力是你所需要的全部”这篇论文使用注意力来提高机器翻译的性能。他们创建了一个包含两个主要部分的模型:
- 编码器:这部分“注意力是你所需要的全部”模型处理输入文本，寻找重要部分，并根据与句子中其他单词的相关性为每个单词创建嵌入。
- 解码器:它接收编码器的输出，这是一个嵌入，然后将这个嵌入转换回文本输出，即输入文本的翻译版本。
然而，论文的关键部分不是编码器或解码器，而是用于创建它们的层。具体来说，编码器和解码器都不像传统的 RNNs 那样使用任何递归或循环。取而代之的是，他们使用“注意力”层，信息通过它线性传递。它没有多次循环输入——相反，转换器通过多个注意层传递输入。
你可以把每一个注意力层看作是“学习”更多的输入信息，也就是看着句子的不同部分，试图发现更多的语义或句法信息。这在我们之前提到的渐变消失问题中是很重要的。
随着句子长度的增加，rnn 处理它们和学习更多信息变得越来越困难。每一个新单词都意味着要存储更多的数据，并且更难检索这些数据来理解句子中的上下文。
This looks scary, and in truth it is a little overwhelming to understand how this works initially. So don’t worry about understanding it all right now. The main takeaway here is that instead of looping the Transformer uses scaled dot-product attention mechanisms multiple times in parallel, i.e. it adds more attention mechanisms and then processes input in each in parallel. This is similar to looping over a layer multiple times in an RNN. Source: Another great post on attention
变压器可以解决这个问题，只需添加更多的“注意头”，或层。由于没有循环，它不会遇到渐变消失的问题。转换器在处理更长的文本时仍然有问题，但它不同于 RNN 的问题，我们不需要在这里讨论。作为比较，最大的 BERT 模型由 24 个注意层组成。GPT 2 号有 12 个关注层，GPT 3 号有 96 个关注层。
在这里，我们不会详细讨论注意力是如何工作的。我们可以在另一个帖子中查看。同时，您可以查看上图中链接的博客文章。它们是关于注意力及其运作方式的极好资源。这篇文章的重点是要理解 Transformer 架构是如何消除我们在 NLP 中使用 RNNs 时遇到的许多问题的。我们前面提到的另一个问题是，在研究 RNNs 的局限性时，以无序方式处理文本的能力。通过注意力机制，转换器使这些模型能够精确地做到这一点，并双向处理文本。
5.双向性的重要性
我们前面提到过，rnn 是在 Transformer 之前用来处理文本的架构。rnn 使用递归或循环来处理文本输入序列。以这种方式处理文本会产生两个问题:
- 速度慢:单向顺序处理文本的成本很高，因为这会造成瓶颈。这就像高峰时段的单车道，那里有长长的车龙，而非高峰时段的道路上几乎没有车。我们知道，一般来说，如果这些模型根据更多的数据进行训练，它们会表现得更好，所以如果我们想要更好的模型，这个瓶颈是一个大问题。
- 它错过了关键信息:我们知道人类并不是以绝对纯顺序的方式阅读文本。正如心理学家丹尼尔·威林厄姆在他的书“《阅读的头脑》”、“我们不是一个字母一个字母地读，我们是一个字母一个字母一个字母地读，一次找出几个字母”。原因是我们需要知道一点未来的事情来理解我们现在正在读的东西。NLP 语言模型也是如此。单向处理文本限制了他们从数据中学习的能力
This text went viral in 2003 to show that we can read text when it is out of order. While there is some controversy around this, see here for more detail, it still shows that we do not read text strictly in a letter by letter format
我们看到 ELMo 试图通过我们称之为“浅层”双向的方法来解决这个问题。它在一个方向上处理文本，然后反转文本，即从末尾开始，并以这种方式处理文本。通过连接这两种嵌入，希望这将有助于捕捉句子中的不同含义，如:
- 鼠标放在桌子上，靠近笔记本电脑
- 那只老鼠在桌子上，靠近那只猫
这两个句子中的“鼠标”指的是一个非常不同的实体，这取决于句子中的最后一个词是“笔记本电脑还是“猫”。通过颠倒句子，从单词“ cat ”开始，ELMo 试图学习上下文，以便能够对单词“ mouse ”的不同含义进行编码。通过首先处理单词“cat ”, ELMo 能够将不同的意思结合到“反向”嵌入中。这就是 ELMo 如何改进传统的、静态的 Word2Vec 嵌入的方法，后者只能对每个单词的一个含义进行编码。
如果不理解这一过程的细微差别，我们会发现 ELMo 方法并不理想。
我们希望有一种机制能够让模型在编码过程中查看句子中的其他单词，这样它就可以知道我们是否应该担心桌子上有一只鼠标！而这正是 Transformer 架构的注意力机制让这些模型能够做到的。
这个来自 谷歌博客 的例子展示了变形金刚网络中的注意力机制如何将注意力“集中”在“它”所指的东西上，在这种情况下是街道，同时也认识到“动物”一词的重要性，即动物没有穿过它，因为街道太宽了。
能够双向读取文本是像 BERT 这样的 Transformer 模型能够在传统的 NLP 任务中取得如此令人印象深刻的结果的关键原因之一。正如我们从上面的例子中看到的，当你只从一个方向阅读文本时，要知道“它”指的是什么是困难的，并且必须顺序存储所有的状态。
我想这并不奇怪，这是 BERT 的一个关键特性，因为 BERT 中的 B 代表“双向”。Transformer 架构的注意机制允许像 BERT 这样的模型通过以下方式双向处理文本:
- 允许并行处理:基于 Transformer 的模型可以并行处理文本，因此它们不会像基于 RNN 的模型那样受到必须顺序处理文本的瓶颈的限制。这意味着，在任何时候，模型都能够查看它正在处理的句子中的任何单词。但是这引入了其他问题。如果你在并行处理所有的文本，你怎么知道原文中单词的顺序呢？这是至关重要的。如果我们不知道顺序，我们就只有一个单词袋类型的模型，无法从句子中完全提取意思和上下文。
- 存储输入的位置:为了解决排序问题，Transformer 架构将单词的位置直接编码到嵌入中。这是一个“标记”，让模型中的注意力层识别他们正在查看的单词或文本序列位于何处。这个漂亮的小技巧意味着这些模型可以并行处理大量不同长度的文本序列，并且仍然知道它们在句子中出现的顺序。
- 使查找变得容易:我们之前提到过，RNN 类型模型的一个问题是，当它们需要顺序处理文本时，这使得检索早期的单词变得困难。因此，在我们的“鼠标”例句中，RNN 人希望理解句子中最后一个词的相关性，即“笔记本电脑”或“猫”，以及它与句子的前一部分的关系。要做到这一点，它必须从 N-1 个单词，到 N-2，到 N-3 等等，直到它到达句子的开头。这使得查找变得困难，这就是为什么单向模型很难发现上下文的原因。相比之下，基于 Transformer 的模型可以在任何时候简单地查找句子中的任何单词。这样，它在注意力层的每一步都有一个序列中所有单词的“视图”。所以它在处理句子的前半部分时可以“向前看”到句子的末尾，反之亦然。(根据注意力层的实现方式，这有一些细微差别，例如，编码器可以查看任何单词的位置，而解码器仅限于“回顾”它们已经处理过的单词。但是我们现在不需要担心这个)。
由于这些因素，能够并行处理文本，在嵌入中嵌入输入的位置，并且能够方便地查找每个输入，像 BERT 这样的模型可以双向“读取”文本。
从技术上来说，它不是双向的，因为这些模型实际上是一次查看所有文本，所以它是非定向的。但是最好把它理解为一种尝试双向处理文本的方法，以提高模型从输入中学习的能力。
能够以这种方式处理文本带来了一些问题，BERT 需要用一种叫做“屏蔽”的巧妙技术来解决，我们将在第 8 节中讨论。但是，现在我们对 Transformer 架构有了更多的了解，我们可以看看在最初的“注意力是你所需要的”论文中 BERT 和普通 Transformer 架构之间的区别。
6.伯特和变形金刚有什么不同？
当你读到最新的模型时，你会看到它们被称为“变形金刚”模型。有时这个词会被不严格地使用，像伯特和 GPT-3 这样的模型都会被称为“变形金刚”模型。但是，这些模型在一些重要方面非常不同。
如“注意力是你所需要的”一文中所述的变压器网络。注意，左边是编码器，右边是解码器，这就是我们的网络。|来源: 关注是你所需要的
理解这些差异将有助于您了解针对您自己独特的用例使用哪种模型。理解不同模型的关键是了解它们如何以及为什么偏离最初的 Transformer 架构。一般来说，需要注意的主要事项有:
- 是否使用了编码器？最初的 Transformer 架构需要翻译文本，因此它以两种不同的方式使用注意机制。一个是对源语言进行编码，另一个是将编码后的嵌入解码回目标语言。查看新型号时，检查它是否使用了编码器。这意味着它涉及以某种方式使用输出来执行另一项任务，即作为另一层的输入来训练分类器，或类似的事情。
- 解码器用了吗？或者，一个模型可能不使用编码器部分，而只使用解码器。解码器实现的注意机制与编码器略有不同。它的工作方式更像传统的语言模型，在处理文本时只查看以前的单词。这将适用于语言生成等任务，这就是为什么 GPT 模型使用转换器的解码器部分，因为它们主要关心的是生成文本以响应文本的输入序列。
- 增加了哪些新的训练层？最后要看的是模型为了执行训练增加了哪些额外的层(如果有的话)。正如我们前面提到的，注意力机制通过平行和双向处理文本打开了一系列的可能性。不同的层可以在此基础上构建，并为不同的任务训练模型，如问答或文本摘要。
BERT only uses the encoder part of the original Transformer network
现在我们知道要找什么了，BERT 和普通的变形金刚有什么不同呢？
- BERT 使用编码器 : BERT 使用转换器的编码器部分，因为它的目标是创建一个执行许多不同 NLP 任务的模型。因此，使用编码器使 BERT 能够在嵌入中对语义和语法信息进行编码，这是许多任务所需要的。这已经告诉了我们很多关于伯特的事情。首先，它不是为文本生成或翻译等任务设计的，因为它使用编码器。它可以在多种语言上训练，但它本身不是一个机器翻译模型。同样，它仍然可以预测单词，所以它可以用作文本生成模型，但这不是它优化的目的。
- BERT 不使用解码器:如前所述，BERT 不使用普通变压器架构的解码器部分。所以，BERT 的输出是嵌入的，而不是文本输出。这很重要——如果输出是嵌入的，这意味着无论你用 BERT 做什么，你都需要做一些嵌入的事情。例如，您可以使用余弦相似性等技术来比较嵌入并返回相似性得分。相比之下，如果您使用解码器，输出将是一个文本，所以您可以直接使用它，而不需要执行任何进一步的行动。
- BERT 使用创新的训练层: BERT 采用编码器的输出，并将其用于执行两种创新训练技术的训练层，即掩蔽和下一句预测(NSP)。这些是解锁包含在 BERT 嵌入中的信息的方法，以使模型从输入中学习更多信息。我们将在第 8 节详细讨论这些技术，但要点是 BERT 让 Transformer 编码器尝试并预测隐藏或屏蔽的单词。通过这样做，它迫使编码器尝试并“学习”更多关于周围文本的信息，并能够更好地预测隐藏或“屏蔽”的单词。然后，对于第二种训练技术，它让编码器在给定前一个句子的情况下预测整个句子。BERT 引入了这些“调整”来利用转换器，特别是注意力机制，并创建了一个为一系列 NLP 任务生成 SOTA 结果的模型。在当时，它超越了以前做过的任何事情。
现在我们知道了 BERT 与普通变压器架构的不同之处，我们可以仔细看看 BERT 模型的这些部分。但首先，我们需要了解伯特是如何“阅读”文本的。
7.记号赋予者:伯特如何阅读
当我们考虑像 BERT 这样的模型时，我们经常忽略这个过程的一个重要部分:这些模型如何“读取”输入，以便能够从他们接受训练的大量文本中学习？
你可能认为这是容易的部分。一次处理一个单词，用一个空格把每个单词分开，然后把它传递给注意力层，让他们施展魔法。
Tokenization seems straightforward, it just breaks the sentence up into words. But it turns out this is not as easy as it seems. | Source: FloydHub
然而，当我们尝试通过单词或其他简单方法(如标点符号)来标记文本时，会出现一些问题，例如:
- 一些语言不通过空格分隔单词:使用单词级方法意味着该模型不能用于像中文这样的语言，在这些语言中单词分隔不是一项简单的任务。
- 你将需要大量的词汇:如果我们按单词来划分事物，我们需要为我们可能遇到的每一个可能的单词做相应的嵌入。这是个很大的数字。你怎么知道你在训练数据集中看到了每一个可能的单词？如果你没有，模型将无法处理一个新单词。这是过去发生的事情，当遇到一个未知单词时，模特们被迫向< UNK >令牌进行识别。
- 更大的词汇量会降低你的模型的速度:记住，我们需要处理更多的数据，让我们的模型学习更多的语言知识，更好地完成自然语言处理任务。这是 Transformer 的主要好处之一——我们可以处理比以前任何模型都多得多的文本，这有助于使这些模型变得更好。然而，如果我们使用单词级标记，我们需要大量的词汇，这增加了模型的大小，并限制了它对更多文本进行训练的能力。
HuggingFace 有一个很棒的标记器库。它包括关于不同方法如何工作的优秀范例教程。例如，这里显示了如何根据训练数据中单词的频率创建基本词汇。这显示了像“hug”这样的单词是如何被标记为“hug”的，而“pug”是由两个子单词部分“p”和“ug”标记的。
伯特是如何解决这些问题的？它实现了一种新的标记化方法， WordPiece ，它将子词方法应用于标记化。WordPiece 通过以下方式解决了许多以前与标记化相关的问题:
- 使用子词代替单词:wordpartie 不是查看整个单词，而是将单词分解成更小的部分，或者构建单词块，这样它就可以使用它们来构建不同的单词。比如想一个“学”这样的词。你可以把它分成三个部分，“lea”，“rn”和“ing”。这样，你就可以用积木造出各种各样的单词:
- 学习= lea + rn + ing
- lean = lea+rn
然后，您可以将它们与其他子单词单元组合在一起，组成其他单词:
- Burn = bu + rn
- 流失= chu +rn
- Turning = tur + rrn + ing
- 圈数= tu + rn + s
您可以为最常用的词创建完整的词，但为不经常出现的其他词创建子词。然后，您可以确信您将通过使用您创建的构建块来标记任何单词。如果你遇到一个全新的单词，你总是可以一个字符一个字符地把它拼凑起来，例如 LOL = l + o + l，因为子单词标记库也包括每个单独的字符。即使你从未见过，你也可以造出任何单词。但是一般来说，你应该有一些可以使用的子词单元，并根据需要添加一些字符。
- 创建一个小词汇量:因为我们不需要为每个单词准备一个令牌，我们可以创建一个相对较小的词汇量。例如，BERT 在其库中使用了大约 30，000 个令牌。这可能看起来很大，但是想想曾经发明和使用过的每一个可能的单词，以及它们所有不同的用法。要涵盖这一点，您需要包含数百万个标记的词汇表，但您仍然无法涵盖所有内容。能够用 30，000 个代币做到这一点是不可思议的。这也意味着我们不需要使用< UNK >令牌，仍然有一个小的模型大小和大量的数据训练。
- 它仍然假设单词由空格分隔，但是… 虽然 wordpartie 确实假设单词由空格分隔，但新的子单词令牌库，如sentepiece(与基于 Transformer 的模型一起使用)或多语言通用句子编码器 (MUSE)，是这种子单词方法的进一步增强，也是新模型最常用的库。
如果你想更深入地了解这个主题，我在这里写了一篇关于记号赋予者的深入评论。
8.掩盖:努力工作对聪明工作
正如我们在第 6 节中提到的，当你在看不同的基于 Transformer 的模型时，看看它们在训练方法上的不同会很有趣。就 BERT 而言，培训方法是最具创新性的方面之一。Transformer 模型提供了足够的改进，你可以使用传统的语言模型方法训练它们，并看到巨大的好处。
One problem with BERT and other Transformer based models which use the encoder is that they have access to all the words at input time. So asking it to predict the next words is too easy. It can “cheat” and just look it up. This was not an issue with RNNs based models which could only see the current word and not the next one, so they couldn’t “cheat” this way. Source: Stanford NLP
这是从以前的标记预测未来标记的地方。以前的 rnn 使用自回归技术来训练它们的模型。GPT 模型同样使用自回归方法来训练它们的模型。除了变压器架构(即我们之前提到的解码器)，他们可以训练比以往更多的数据。而且，正如我们现在所知，模型可以通过注意力机制和双向处理输入的能力更好地学习上下文。
BERT uses a technique called masking to prevent the model from “cheating” and looking ahead at the words it needs to predict. Now it never knows whether the word it’s actually looking at is the real word or not, so it forces it to learn the context of all the words in the input, not just the words being predicted.
相反，BERT 使用了一种创新技术，试图“强迫”模型从给定的数据中学习更多。这项技术还提出了许多关于深度学习模型如何与给定的训练技术进行交互的有趣方面:
- 为什么需要掩蔽？记住，转换器允许模型双向处理文本。本质上，模型可以同时看到输入序列中的所有单词。以前，对于 RNN 模型，他们只看到输入中当前的工作，不知道下一个单词是什么。让这些模型预测下一个单词很容易，模型不知道它，所以必须尝试预测它，并从中学习。然而，有了 Transformer，BERT 可以“欺骗”并查看下一个单词，因此它什么也学不到。这就像参加一个考试，并得到答案。如果你知道答案永远在那里，你就不会学习。伯特使用掩蔽来解决这个问题。
- 什么是掩蔽？掩蔽(也称为完形填空)简单地说就是我们隐藏或“掩蔽”一个单词，然后强迫模型预测这个单词，而不是预测下一个单词。对于 BERT 来说，15%的输入令牌在模型看到之前就被屏蔽了，所以它不可能作弊。为此，随机选择一个单词，简单地用“[MASK]”标记替换，然后输入到模型中。
- 不需要标签:对于这些任务，要记住的另一件事是，如果你正在设计一种新的训练技术，最好是你不需要为训练标记或手动构造数据。屏蔽通过要求一种简单的方法来实现对大量非结构化数据的训练来实现这一点。这意味着它可以在完全无人监督的情况下进行训练。
- 15%的 80%:虽然蒙版看起来是一个简单的技术，但它有很多细微的差别。在被选择用于屏蔽的 15%的令牌中，只有 80%实际上被替换为屏蔽令牌。取而代之的是，10%用一个随机的单词替换，10%用正确的单词替换。
- 蒙版有什么好玩的？为什么不直接屏蔽 100%选择的 15%输入？这是个有趣的问题。如果你这样做，模型将知道它只需要预测被屏蔽的单词，而不需要了解输入中的其他单词。不太好。你需要模型去了解所有的输入，而不仅仅是 15%的屏蔽输入。为了“强迫”模型学习非屏蔽单词的上下文，我们需要用随机单词替换一些标记，用正确的单词替换一些标记。这意味着 BERT 永远不知道它被要求预测的非屏蔽单词是否是正确的单词。作为一种替代方法，如果我们在 90%的时间里使用掩码标记，然后在 10%的时间里使用不正确的单词，BERT 会在预测非掩码标记时知道它总是错误的单词。类似地，如果我们只在 10%的时间里使用正确的单词，BERT 会知道它总是正确的，所以它会继续重用它为那个单词学习的静态单词。它永远也学不会这个单词的上下文嵌入。这是对 Transformer 模型如何在内部表示这些状态的一个有趣的洞察。毫无疑问，我们会在其他模型中看到更多类似的训练调整。
9.伯特:微调和迁移学习
现在应该很清楚了，当它在几年前出版时，BERT 在很多方面打破了这个模式。另一个区别是能够适应特定的领域。这建立在我们已经讨论过的许多事情的基础上，例如作为一个预先训练的模型，这意味着人们不需要访问大型数据集来从头训练它。您可以构建从更大的数据集中学习的模型，并将该知识“转移”到特定任务或领域的模型中。
In Transfer Learning we take knowledge learned in one setting, usually via a very large dataset, and apply it to another domain where, generally, we have much less data available. | Source Sebastian Ruder blog post
BERT 是一个预先训练好的模型，这意味着我们可以根据我们的领域对它进行微调，因为:
- BERT 可以进行迁移学习:迁移学习是一个 power 概念，最早是为机器视觉实现的。然后，在 ImageNet 上训练的模型可用于其他“下游”任务，在这些任务中，它们可以基于在更多数据上训练的模型的知识。换句话说，这些预先训练的模型可以将它们在大型数据集上学习的知识“转移”到另一个模型，后者需要更少的数据来出色地完成特定任务。对于机器视觉，预先训练的模型知道如何识别图像的一般方面，如线条、边缘、面部轮廓、图片中的不同对象等等。他们不知道像个人面部差异这样的细微细节。一个小模型可以很容易地被训练来将这种知识转移到它的任务中，并识别特定于它的任务的人脸或物体。如果你想让识别一株患病的植物，你不需要从头开始。
- 你可以选择相关的层来调优:虽然这仍然是正在进行的研究的问题，但似乎 BERT 模型的较高层学习更多的上下文或语义知识，而较低层往往在句法相关的任务上表现更好。较高层通常与特定任务的知识更相关。对于微调，您可以在 BERT 的基础上添加自己的层，并使用少量的数据来训练一些任务，如分类。在这些情况下，您可以冻结后面层的参数，只允许您添加的层参数发生变化。或者，您可以“解冻”这些更高层，并通过更改这些值来微调 BERT。
- 伯特需要更少的数据:既然伯特似乎已经学习了一些关于语言的“一般”知识，你需要更少的数据来微调它。这意味着你可以使用带标签的数据来训练分类器，但你需要标记的数据要少得多，或者你可以使用 BERT 的原始训练技术，如 NSP，来训练它对未标记的数据。如果你有 3000 个句子对，你可以用你的未标记数据来微调 BERT。
所有这些意味着 BERT 和许多其他 Transformer 模型可以很容易地适应您的业务领域。虽然微调似乎确实存在一些问题，而且许多模型已经从零开始为独特的领域训练 BERT，如 Covid19 信息检索，但这些模型的设计仍然有很大的转变，它们能够在无人监督和相对少量的数据上进行训练。
10.鳄梨椅:伯特和变形建筑的下一步是什么
Avocado chairs designed by a decoder based Transformer model which was trained with images as well as text. | Source: OpenAI
现在，我们已经结束了对 BERT 和 Transformer 架构的旋风式回顾，让我们期待一下深度学习这一令人兴奋的领域的未来:
- 关于这些模型局限性的问题:围绕着试图仅从文本中提取意义的潜在局限性，有一场引人入胜、近乎哲学的讨论。一些最近发表的论文展示了关于深度学习模型可以从语言中学习什么的一种新的思维形式。在对越来越多的数据进行训练方面，这些模型注定会达到收益递减的点吗？这些都是令人兴奋的问题，它们正在超越自然语言处理的界限，进入更广泛的通用人工智能领域。关于这些模型的更多限制，请看我们之前关于这个话题的 neptune.ai 帖子。
- 模型的可解释性:人们常说我们开始使用一项技术，然后才弄清楚它是如何工作的。例如，我们在真正理解湍流和空气动力学的一切之前就学会了驾驶飞机。同样，我们使用这些模型，我们真的不明白他们在学习什么或如何学习。对于这些工作，我强烈推荐莉娜·沃伊塔的博客。她对伯特、GPT 和其他变压器模型的研究令人难以置信，是我们开始逆向工程这些模型如何工作的越来越多的工作的一个例子。
- 一幅图像胜过千言万语:变形金刚模型的一个有趣的潜在发展是已经在进行一些工作将文本和视觉结合起来，使模型能够根据句子提示生成图像。类似地，卷积神经网络(CNN)一直是机器视觉的核心技术，直到最近，基于变压器的模型开始被用于该领域。这是一个令人兴奋的发展，因为视觉和文本的结合有可能改善这些模型的性能，而不是单独使用文本。正如我们前面提到的，最初的机器翻译模型已经演变成一种技术，似乎比人工智能的任何其他领域都更接近于实现一般智能的圣杯。仔细观察这个空间，它可能是目前人工智能最令人兴奋的领域。
结论
仅此而已。如果你做到了这一步，非常感谢你的阅读！我希望这篇文章能帮助您理解 BERT 和 Transformer 架构。
这确实是目前人工智能中最有趣的领域之一，所以我鼓励你继续探索和学习。您可以从我在本文中留下的各种不同的链接开始。
祝你的人工智能之旅好运！*
你需要知道的最好的 8 个机器学习模型部署工具
原文：https://web.archive.org/web/https://neptune.ai/blog/best-8-machine-learning-model-deployment-tools
机器学习在科技界并不新鲜。它为许多行业带来了革命性的变化，能够实现渠道自动化，并增加业务工作流程的灵活性。
我们如何在生产环境中创建和部署训练有素的模型 API 由机器学习生命周期的许多方面控制。 MLOps 的概念对于处理复杂的 ML 部署环境非常有益。
实施可靠的 MLOps 可以为投资机器学习的公司带来巨大的好处。理解使用和执行什么是这个难题的一个重要部分。学习和适应简化整体工作流程的新工具是另外一回事。
本文列出了用于模型部署的最佳 MLOps 工具。帮助您扩展和管理机器学习生命周期的所有要素，包括服务、监控和管理 API 端点。
如果您想将训练好的模型部署为端点，您可以使用 TensorFlow 服务来实现。
它允许您创建一个 REST API 端点来服务于训练好的模型。TensorFlow Serving 是一个健壮的高性能系统，用于服务机器学习模型。
您可以轻松部署最先进的机器学习算法，同时维护与其各自端点相同的服务器架构。它足够强大，可以为不同类型的模型和数据以及 TensorFlow 模型提供服务。
它是由谷歌创建的，许多顶级公司都使用它。将模型作为集中的模型库是一个很好的方法。服务架构对于大量用户同时访问模型是足够有效的。
如果由于大量请求而出现任何阻塞，可以使用负载平衡器轻松维护。总体而言，该系统具有较高的可扩展性和可维护性。
TensorFlow 发球优势:
- 一旦部署模型准备就绪，这个工具就可以轻松地提供服务。
- 它可以向同一个模型发起批量请求，因此可以有效地利用硬件。
- 它还提供了模型版本管理。
- 该工具易于使用，并负责建模和服务管理。
TensorFlow 发球缺点:
- 加载新型号或更新旧型号时，无法确保零停机时间。
- 仅适用于张量流模型。
如果您正在寻找一个开源工具来组织您的整个 ML 生命周期，这可能是您的平台。
MLflow 提供管理 ML 流程和部署的解决方案。它可以进行实验、复制、部署，或者作为一个中央模型注册中心。
该平台可以被个人开发者和团队用于 ML 部署。它可以整合到任何编程生态系统中。该库旨在满足各种技术需求，并可用于不同的机器学习库。
组织整个 ML 生命周期围绕着四个主要功能:跟踪、项目、模型和模型注册。
它有助于简化自动化 ML 模型跟踪的过程。但是一个缺点是它不能自动处理模型定义。这意味着向模型定义添加额外的工作需要手动完成。
MLflow 优点:
- 模型跟踪机制很容易建立。
- 它为服务提供了非常直观的 API。
- 日志记录实用且简单，因此很容易进行实验。
- 代码优先的方法。
MLflow 缺点:
- 向模型添加额外的工作并不是自动的。
- 对于将模型部署到不同的平台来说，这并不容易，也不理想。
Kubeflow 的主要目标是维护机器学习系统。这是为 Kubernetes 设计的强大套件。
主要操作包括打包，组织 docker 容器，帮助维护整个机器学习系统。
它简化了机器学习工作流的开发和部署，从而使模型具有可追溯性。它提供了一套强大的 ML 工具和架构框架来有效地执行各种 ML 任务。
多功能 UI 仪表板使管理和跟踪实验、任务和部署运行变得容易。笔记本功能使我们能够使用指定的平台开发套件与 ML 系统进行交互。
组件和管道是模块化的，可以重复使用以提供快速解决方案。这个平台是 Google 通过 Kubernetes 为 TensorFlow 任务服务而启动的。后来，它扩展到执行整个 ML 管道的多云、多架构框架。
Kubeflow 优点:
- 一致的基础架构，提供监控、运行状况检查、每次复制，以及对新功能的扩展。
- 简化新团队成员的入职流程。
- 标准化流程有助于建立安全性并更好地控制基础架构。
Kubeflow cons :
- 难以手动设置和配置。
- 高可用性不是自动的，需要手动配置。
- 这个工具的学习曲线很陡。
Cortex 是一个开源的多框架工具，非常灵活，可以用作模型服务工具，也可以用于模型监控等目的。
凭借其处理不同机器学习工作流的能力，它允许您完全控制模型管理操作。它还可以作为使用 SageMaker 工具提供模型的替代方案，以及基于 AWS 服务(如 Elastic Kubernetes Service (EKS)、Lambda 或 Fargate)的模型部署平台。
Cortex 扩展到 Docker、Kubernetes、TensorFlow Serving 和 TorchServe 等开源项目。它可以与 cohesion 中的任何 ML 库或工具一起工作。它提供端点的可扩展性来管理负载。
它允许您在单个 API 端点中部署多个模型。它还可以作为一种解决方案，在不停止服务器的情况下更新已经存在的生产端点。它覆盖了模型监控工具的足迹，监督端点的性能以及预测数据。
皮质优点:
- 当网络流量波动时，允许 API 安全的自动扩展功能。
- 支持多个平台，如 Keras、TensorFlow、Scikit-learn、PyTorch 等..
- 更新型号时不会停机。
皮层 cons :
- 设置过程可能有些令人望而生畏。
Seldon.io 提供了 Seldon core，这是一个开源的框架。该框架简化并加速了 ML 模型和实验部署。
它处理和服务在任何其他开源 ML 框架中构建的模型。ML 模型部署在 Kubernetes。当它与 Kubernetes 一起伸缩时，它使我们能够使用最先进的 Kubernetes 特性，比如定制资源定义来处理模型图。
Seldon 还提供了将您的项目与持续集成和部署(CI/CD)工具相连接的能力，以扩展和更新模型部署。
它有一个警报系统，当监控生产中的模型出现问题时，它会通知您。您可以定义模型来解释某些预测。该工具在云中可用，在内部也可用。
谢顿优点:
- 定制离线模型。
- 向外部客户公开 API 的实时预测。
- 简化部署过程。
谢顿缺点:
- 设置可能有点复杂。
- 对新来的人来说，学习可能很难。
BentoML 简化了构建机器学习服务的过程。它为部署和维护生产级 API 提供了一个基于 Python 的标准架构。这种架构允许用户使用任何 ML 框架轻松打包训练好的模型，用于在线和离线模型服务。
BentoML 的高性能模型服务器支持自适应微批处理，以及独立于业务逻辑扩展模型推理工人的能力。UI 仪表板提供了一个集中的系统来组织模型和监控部署过程。
其模块化设计使配置可在现有 GitOps 工作流中重复使用，自动 docker 映像生成使生产部署成为一个简单的版本化流程。
多用途框架解决了 ML 模型的服务、组织和部署。主要重点是连接数据科学和 DevOps 部门，以实现更高效的工作环境，并产生高性能的可扩展 API 端点。
欢迎使用:
- 易于大规模部署预测服务的实用格式
- 以单一统一的格式支持高性能模型服务和部署
- 支持部署到多个平台，而不仅仅是 Kubernetes
膨润土辅料:
- 不注重实验管理。
- 不支持开箱即用的水平扩展。
AWS Sagemaker 是亚马逊提供的强大服务。它让 ML 开发者能够快速构建、训练和部署机器学习模型。
它通过删除一些复杂的步骤来简化整个机器学习过程，从而提供高度可扩展的 ML 模型。
机器学习开发生命周期是一个复杂的迭代过程。它迫使你整合复杂的工具和工作流程。这项任务可能要求很高，令人恼火，而且可能会消耗你大量的时间。更不用说配置时出错的麻烦了。
Sagemaker 使这一过程变得更加容易，在一个集中的工具集中提供了用于机器学习的所有组件。没有必要配置每一个，因为它已经安装并准备使用。
这以最小的努力和成本加速了模型的生产和部署。该工具可用于使用任何 ML 框架创建的端点。它还提供预测跟踪和捕获，以及日程监控。
AWS Sagemaker 优点:
- 设置过程很简单，可以用 Jupyter 笔记本运行。因此，脚本的管理和部署得到了简化。
- 基于您使用的功能，成本是模块化的。
- 模型训练在多台服务器上完成。
AWS Sagemaker 缺点:
- 初级开发人员的陡峭学习曲线。
- 严格的工作流程很难定制。
- 仅适用于 AWS ecostystem
Torchserve 是一个 Pytorch 模型服务框架。它简化了训练有素的 PyTorch 模型的大规模部署。它消除了为模型部署编写定制代码的需要。
Torchserve 由 AWS 设计，是 PyTorch 项目的一部分。对于那些使用 PyTorch 环境构建模型的人来说，这使得设置变得很容易。
它支持低延迟的轻量级服务。部署的模型具有高性能和广泛的可伸缩性。
Torchserve 为一些 ML 任务提供了内置库，比如对象检测或文本分类。它可以节省你花在编写代码上的时间。它提供了强大的特性，比如多模型服务、用于 A/B 测试的模型版本控制、用于监控的指标以及用于应用程序集成的 RESTful 端点。
火炬服务的优点:
- 扩展部署的模型得到了简化。
- 服务端点是轻量级的，具有高性能规模。
火炬服务的缺点:
- 因为这个工具是实验性的，所以经常会发生变化和更新。
- 仅适用于 PyTorch 型号
结论
创建和部署高性能和可扩展的机器学习模型是具有挑战性的任务。
幸运的是，本文中列出的部署工具和框架可以帮助您创建健壮的 ML 模型，并快速、轻松地部署它们。
处理和组织全面的机器学习生命周期绝非易事。这些工具将帮助你节省时间和精力。
祝你好运！
资源:
克里斯萨纳瓦特·卡韦桑穆昂
InstaMobile 的开发者关系
只是一个典型的内向开发者，美国——没有上瘾，对人工智能和区块链充满热情。
阅读下一篇
你需要知道的最好的机器学习模型管理工具
9 分钟阅读|作者弗拉基米尔·利亚申科| 2021 年 7 月 14 日更新
开发您的模型是 ML 项目工作的重要部分。这通常是一个艰难的挑战。
每个数据科学家都必须面对它，还有困难，比如失去实验的线索。这些困难很可能既烦人又不明显，会让你时不时感到困惑。
这就是为什么简化管理 ML 模型的过程是有好处的，幸运的是有几个工具可以做到这一点。这些工具有助于:
- 实验跟踪
- 模型版本控制
- 测量推理时间
- 团队协作
- 资源监控
因此，寻找和使用适合您的项目的工具是常识和良好的实践。
在本文中，我们将探索模型管理工具的前景。我将尝试向您展示各种工具，并强调它们的优点。
我们将涵盖:
- 选择模型管理工具的标准
- 模型管理工具 : Neptune、亚马逊 SageMaker、Azure 机器学习、Domino 数据科学平台、Google Cloud AI 平台、Metaflow、MLflow
当你为电信行业的项目工作时，最好的 AI & ML 工具(+用例)
电信公司有许多业务和职能部门，这使得它们运转良好。
在电信部门工作的数据科学家根据部门的不同，可能需要处理各种任务。可能会有一个改善客户体验的数据科学团队，或者一个为产品&工程部门提供动力的团队。
在本文中，我们将从我作为一名前电信数据科学家的角度，来看看电信公司中数据科学和相关工具的流行用例。
我作为电信行业数据科学家的典型一天
作为客户体验团队中的数据科学家，我的角色涉及三种主要类型的任务。
一切照旧(BAU)
BAU 是您跟踪某些 KPI，或调整/更新现有机器学习模型的地方。
老实说，对于一个充满热情的数据科学家来说，这是最没意思的工作，因为它涉及很少的创新和大量多余的任务。
但它是电信公司非常重要的一部分，因为它有助于领导层和高管做出更好的决策，并有效地运营业务。
构建概念证明(POC)
大多数新项目都从概念验证开始。分配大量时间来构建这些概念证明是很常见的。
与 BAU 不同，这项工作需要专注、研究和发展。这是一个更有创造性的职位，你的工作结果并不总是积极的。
咨询
很多时候，业务涉众可能会提出一个业务问题，比如“为什么 NPS(净推广得分)下降了？”。
作为一名咨询数据科学家(许多受雇担任这一角色的数据科学家是根据他们的咨询型问题解决能力进行评估的)，您必须将该业务问题转化为数据科学问题。
首先，你可以探索影响 NPS 的因素。它有季节性吗？有时，即使 NPS 调查不友好，客户也会因为不喜欢该调查而倾向于给出糟糕的分数。正如你所看到的，这些问题是微妙的，需要数据科学家理解商业的本质，甚至心理学。
数据科学家需要戴上他们的咨询帽子，将他们的分析告诉他们的东西转化为对业务利益相关者有效、有价值的结论。
BAU、概念验证和咨询是数据科学家任务的主要类别，但不是唯一的类别。可能与上述三种任务重叠的一些其他类型的任务是:
会议
如果你曾在一家大公司工作过，你会知道你的大量时间都花在了会议上。
如果你的团队(比如我所在的团队)使用敏捷方法，那么你的日程表将会被大量与 sprint 相关的会议填满。每日站立，冲刺关闭，冲刺回顾，冲刺计划，积压整理/故事优先化。
这些只是和短跑有关。还有其他类型的内部会议。团队会议，与经理的一对一，越级会议等等。
无论你是软件工程师还是数据科学家，会议都是为大公司工作的最大诅咒。
你需要它们，因为它们为你正在解决的问题提供了背景，但是过多的会议会让你筋疲力尽。当你有冲刺计划或团队会议的时候，你会因为参加会议而感到疲惫。
数据治理
当您处理数据时，该流程从确定您需要什么类型的数据、谁拥有该数据(哪个业务部门)、数据存储在哪里、您是否需要信息安全部门的批准才能访问该数据、所有人需要谁签字等开始。
在开始项目或概念验证之前，您可能需要回答许多问题，克服许多困难。在电信公司，数据是圣杯。必须极其小心地对待它，否则你不仅会危及你的团队，甚至会危及你的整个公司及其品牌价值。
有大量的安全措施来避免任何灾难，它们会成为你启动项目的一大障碍。
有时，数据科学项目可能会被取消，仅仅是因为有人无法完成数据治理过程，或者因为该过程花费的时间比实际项目花费的时间多。
在完成所有必要的数据治理程序之前，您不能启动项目。
电信领域的数据科学和机器学习用例
这些用例将局限于客户体验数据科学家的视角。企业中的大多数数据科学用例都围绕团队的业务 KPI。
通常，数据科学团队的任务是改善这些 KPI，或者防止它们下降。
对于客户体验(CX)团队，示例 KPI 可以是:
- 客户流失，
- 活跃用户–DAU、WAU、MAU(每日、每周和每月活跃用户)，
- NPS–净推介值，
- CSAT-客户满意度得分。
基于这些 KPI 的用例将是:
- 客户流失预测，
- 识别驱动或影响客户流失的因素，
- 客户流失成本估算，
- 提高 DAU、WAU、MAU(用户保持率和活跃度)、
- 预测给定客户案例的 NPS，
- 识别驱动或影响 NPS 的因素，
- 来自 NPS 和 CSAT 调查反馈的客户反馈见解，
- 来自 NPS 反馈的情感分析，
- 构建客户 360°智能(主要针对 B2B 客户)，
- 向上销售和交叉销售的推荐引擎。
这些用例是如何处理的？首先，它从一个想法开始。比方说，“推荐引擎”是我们的想法，我们把它推销给相关的利益相关者——CX 主管或客户保持。
接下来，我们将在推介环节回答一些问题。如果项目负责人被说服了，这个想法就进入了 POC 阶段。
概念验证阶段是我们使用真实数据的小样本构建一个小型原型的阶段。这和产品公司的 MVP 流程很像。
POC 的成功将基于许多因素来衡量(通常这些成功指标是在想法推介阶段定义的)。如果“推荐引擎”是这个想法，那么成功的衡量标准可以是:
- 这能产生多少追加销售？
- 这个推荐引擎可以帮助获取多少客户钱包份额？
- 它还能避免客户流失吗？
- 它会提高客户保持率吗？
所有这些问题通常都有定性和定量的答案，有实际的数字(样本数据的小子集)。如果项目发起人或业务干系人/团队认为概念验证是成功的，那么项目就进入生产阶段。
将数据科学项目从 POC/原型阶段转移到生产阶段会带来新的挑战。
到目前为止，它只是关注数据科学团队及其各自的业务团队。当它进入生产阶段时，情况就完全不同了。事情是这样的:
- 优化我们现有的代码，
- 遵循工程/开发团队的编码标准，
- 代码和机器学习模型的质量保证，
- 确保依赖性，
- 为将来的更新设置 CI/CD 管道，
- 决定如何提供推理的设计——微服务、API 或 web 应用程序。
这需要更多团队的参与:IT、开发运维、工程。这涉及到更多的项目管理程序。
在这一点上需要注意的一件重要事情是，在 POC 阶段，我们给出了项目上线的最后期限。在计算截止日期时，必须考虑 POC 和生产之间的所有必要阶段，这一点很重要。
在大型组织中，使用不同的工具组来解决相同类型的问题是很常见的。
以数据可视化为例。您可能会看到数据科学团队(处理可视化)在一个项目中使用 Tableau，在另一个项目中使用 Qlik Sense，而与此同时，一些团队成员可能正在使用 R Shiny 或 Python Plotly Dash 构建新的仪表板。
底线–一个问题，多种工具。此外，因为电信行业通常是资本密集型的，他们不会回避投资昂贵的专有工具。
让我们来看看一家电信公司的客户体验数据科学团队使用的一些工具。
数据基础设施
在讨论数据科学团队时，数据基础架构是一个经常被忽略且不太被谈论的东西。不认识到数据工程团队为数据科学团队提供数据和计算平台所做的大量工作是亵渎神明的。
与许多现代科技公司不同，由于大量的安全和合规措施，电信公司没有采用云解决方案的奢侈。
随着监管要求，这使得使用尖端计算平台非常困难。像 Teradata、SAS 这样被认为是老派和昂贵的技术，仍然在为这样的电信数据科学团队提供动力。
如果你需要一台强大的机器呢？嗯，您可能会通过 VDI 或 Citrix(虚拟化)获得功能强大的远程服务器。这也带来了自身的安全和数据定位挑战。
即使你有一台强大的本地电脑/笔记本电脑，也有很多限制:
- VPN，
- 无法在本地机器上下载客户数据，
- 需要匿名 PII，
还有更多复杂的问题需要你去克服。总而言之，电信公司的数据是一件很难处理的事情。这不一定与数据复杂性有关，而是与安全性、合规性、数据源、存储、计算限制等有关。
Adobe Analytics
Adobe Analytics 过去被称为 Adobe Sitecatalyst 或 Omniture，是一种非常受欢迎的数字分析工具，电信公司使用它来收集和分析他们的数字(web 和应用程序)点击流数据。
这个工具帮助他们了解什么是最受欢迎的网页，什么是跳出率最高/最低的网页(以便可以优化页面)，如何优化转化率等等。
python–Numpy，Pandas，Scikit-Learn，Matplotlib，Plotly
Python 数据科学栈无处不在，几乎所有团队都在用，电信也不例外。
构建于 Numpy 之上的 Pandas 是许多基于 Python 的开发者的首选数据分析&数据操作工具。Pandas 与 Seaborn(基于 Matplotlib 构建)一起用于执行探索性数据分析。
Scikit-learn 绝对是机器学习的首选包/框架。虽然我在这里粗略地提到了机器学习，但它可以涵盖从构建基线 ML 模型到超参数调整和模型部署的任何内容。
这些天来，可解释的机器学习(也称为“可解释的人工智能”)越来越受欢迎。它有助于向业务涉众解释所谓的“黑盒”模型。
进入交互式可视化很常见:有时在 Jupyter 笔记本 中的独立 EDA 上，但其他时候作为仪表板的一部分。多亏了 Plotly 和 Plotly Dash，在 Python 中，交互式可视化和在其上构建简单的仪表板变得非常容易。
请注意，Plotly Dashdashboards/visualization 可能不是领导团队或更高层管理人员希望收到的最终内容。他们可能更喜欢类似 Tableau 的东西，因为他们很熟悉。
到目前为止，我还没有提到与深度学习相关的内容。事实是，在我的经历中，深度学习几乎从未发生过。发生这种情况的领域是网络分析、客户支持和概念验证。
你可以用手指数出正在生产的深度学习项目的数量(例如:聊天机器人、异常检测、预测、计算机视觉)。
但这并不意味着质量问题没有解决。对于表格数据，像 xgboost 、 lightgbm 、catboost 这样的框架是非常方便的，因为在这样的数据科学项目中，准确性只是成功的衡量标准之一(与可解释性、维护、部署一起)。
R + R 闪亮
R 编程语言(结合 RStudio 作为 IDE)是很多数据科学团队使用的流行解决方案。对于时间序列预测，它比 Python 更受欢迎(由于多功能的“预测”包)，例如预测即将到来的季度或财政年度的 NPS/CSAT/流失。
在运行实验(A/B 测试)的同时，r 也优先执行统计测试。Shiny 是一个 R 包，可以让你只基于 R 创建 web 应用程序和仪表板，它通常是快速原型或与业务涉众进行模型调整的首选。
鉴于 Shiny Server for Linux 是免费的(不像 Tableau Server)，它是团队尝试的一个划算的选择。
（舞台上由人扮的）静态画面
Tableau 是分享数据科学分析见解的最受欢迎的方式之一。Tableau 是首选，因为对于非技术高管来说，它很容易使用，并定期跟踪他们的一些 KPI。
数据科学团队也采用 Tableau 作为平台来提供见解，因为市场上有 Tableau 开发人员，并且数据科学家能够快速上手 Tableau。
信息/数据安全
信息/数据安全被视为电信行业的圣杯。如果你要从事与电信数据相关的工作，你应该愿意忍受等待数据、签署 InfoSec 批准表格、与数据隐私官(DPO)跟进以及极其小心地处理数据的痛苦。
即使是看似微不足道的数据泄露也会给你的公司带来巨大的灾难。最重要的是，坚持 GDPR 是数据科学和机器学习项目的另一个复杂因素。
真理的唯一来源(SSOT)
由于安全策略的原因，收集数据很难，同样，组合多个数据源并创建一个单一的真实来源也很难。为什么？
这主要是因为电信行业仍在使用大量遗留系统，遗留系统中驻留的或来自遗留系统的大量数据与您从现代数字系统中获得的数据非常不同。
例如，传统的销售点系统与最新的在线支付或充值系统之间存在巨大差异。你需要中间件来连接这些系统。
总而言之，数据来源越多，创建单一的真实来源就变得越复杂。
结论
在这篇文章中，我们探索了在一家电信公司的客户体验团队中担任数据科学家的感受。
我们还讨论了相关的数据科学和机器学习用例。我们经历了工具、框架和技术栈。
但最重要的是，如果你成为电信行业的数据科学家，你将面临的挑战和惊喜。
这是我个人经历的一个简短总结，我希望它对您了解在电信行业做一名数据科学家是什么感觉很有用。
But the most important thing were the challenges and surprises that you will face if you become a data scientist in telecom.
This was a short summary of my personal experience, and I hope it was useful for you to see what it’s like to be a data scientist in telecom.
MLflow 模型注册的最佳替代方案
原文：https://web.archive.org/web/https://neptune.ai/blog/best-alternatives-to-mlflow-model-registry
MLflow 模型注册是 MLflow 平台的四个组件之一。其他三个组件是跟踪、项目和模型。它们的设计方式使得每个组件都可以单独使用，但它们也可以很好地协同工作。
MLflow 模型注册组件是一个集中式模型存储、一组 API 和 UI，用于协作管理 MLflow 模型的整个生命周期。它提供模型沿袭(MLflow 实验和运行产生了模型)、模型版本化、阶段转换(例如从阶段转换到生产)和注释。”–ml 流程文件
MLflow Model Registry 的目标，就像任何机器学习模型注册工具一样，是为了让 ML 团队在需要的任何时候都能轻松找到所有与模型相关的元数据。以一种间接的方式，模型注册促进了将模型从培训转移到生产的过程，并确保了模型治理。
MLflow 模型注册组件和 MLflow 平台作为一个整体，都是很好的工具，可以在每个 ML 项目中提供巨大的帮助。但是，他们当然不会为每个人勾选所有的复选框。
您可能认为具有挑战性的一些事情:
- 没有模型传承和评估历史特性，如下游创建的模型或测试运行的历史。
- MLflow 模型注册表中缺少代码版本化和数据集版本化，这使得再现性更加困难。
- 团队协作和访问管理功能不可用，因此如果您在团队中工作，您必须找出一些耗时的解决方法。
- MLflow 是一个开源工具。因此，除非您想使用 Databricks 平台，否则您需要自己设置和维护 MLflow 服务器。
- 在这种情况下，您通常需要独自调试任何问题。没有专门的用户支持来一步一步地告诉你该做什么。即使开源社区非常活跃，他们也可能没有所有的答案，或者可能需要一些时间才能得到答案。
MLflow 模型注册表被很多团队使用，他们肯定看到了它的价值。但是如果以上几点对您或您的团队很重要，并且您希望在您的模型注册工具中包含它们，那么这里有几个您应该考虑的选择。
MLflow 模型注册替代方案
Neptune 是 MLOps 的元数据存储。它的主要焦点是帮助数据科学家和 ML 工程师进行实验跟踪和模型注册。
它在模型注册区提供了什么？
首先，你可以将各种建模元数据记录到 Neptune，包括代码、git 信息、文件、Jupyter 笔记本、数据集等等。通过这种方式，您可以在一个中央注册表中对模型进行版本化，并且可以轻松地分析、比较或检索数据。
无论你或你的同事(如果你在团队中工作)在哪里进行训练——无论是在云中、本地、笔记本或其他地方——Neptune 都可以成为你的真实来源和你过去跑步的数据库。
有了这些，对于任何模型，你都可以知道谁创建了它，如何创建的，但是你也可以检查你的模型是在什么数据上训练的，并且在运行之间比较数据集。
海王星还没有的是模型的审批机制。但是作为一个 ML 元数据存储，它给了你很大的灵活性，所以你可以自己建立提升模型的协议。
海王星——概要:
如果你想看海王星在行动，检查这个现场笔记本或这个例子项目(不需要注册)，只是玩它。你也可以看看这个 MLflow 和 Neptune 的深度对比。
阅读 Zoined 的案例研究，了解他们为什么选择 Neptune 而不是 MLflow。
Amazon SageMaker model registry | Source
Amazon SageMaker 是一个完全托管的服务，开发者可以将其用于 ML 开发的每一步，包括模型注册。使用 SageMaker 模型注册中心，您可以为生产编制模型目录，管理模型版本，将元数据(比如培训指标)与模型相关联，以及管理模型的批准状态。
要在 Amazon SageMaker 中注册一个模型，您只需要创建一个模型版本并指定它属于哪个组。还可以用指定容器和相关变量的推理管道注册它。然后，您将使用 AWS Python SDK 来创建新的版本模型。
AWS 的便利之处在于您可以在注册中心之外部署模型。机器学习模型经过训练后，可以部署到 SageMaker 端点，这些端点可以提供低延迟的实时推理。
在部署您的模型之后，您可以使用 Amazon SageMaker Model Monitor 持续实时监控您的机器学习模型的质量。
VertaAI model registry | Source
Verta AI 是一个模型管理和操作工具，具有模型注册功能，在一个统一的空间中，您可以管理和部署您的机器学习模型。
在一个友好的 UI 中，您注册您的模型并发布所有的模型元数据、文档和工件。然后，您可以将您的模型连接到一个实验跟踪系统，在那里您将能够端到端地管理实验。Verta 提供了所有模型信息的统一视图，以便更好地发现。
Verta AI 系统还为 ML 项目的版本控制提供工具，并允许单独跟踪代码、数据、配置和环境的变化。您可以随时访问审计日志，以检查模型的合规性和稳健性。这个平台可以在模型生命周期的任何阶段使用。
Verta AI 允许您减少发布时间，同时不影响质量。只有当模特通过基本的安全和隐私检查后，他们才会被放行。您可以构建适合您的项目的自定义审批工作流，并将其与您选择的票证系统集成。
Verta AI 的主要功能包括:
- 仪表盘用于报告和绩效评估，您可以根据需要定制。
- 集成–该工具在 Docker 和 Kubernetes 上工作，并与 Tensorflow 和 PyTorch 等大多数机器学习工具集成。它还为 CI/CD 带来了巨大的商机，因为它与 Jenkins 和 GitOps 等 CI/CD 管道相集成。
- 类似 Git 的环境–如果你有使用 Git 的经验(大多数开发者都有)，那么你会发现这个系统直观易用。
**Azure Machine Learning 是一个云 MLOps 平台，允许您管理和自动化整个 ML 生命周期，包括模型管理、部署和监控。Azure 中包含以下 MLOps 功能:
- 创建可复制的 ML 管道。
- 为培训和部署模型创建可重用的软件环境。
- 从任何地方注册、打包和部署模型。
- 处理端到端 ML 生命周期的数据治理。
- 就 ML 生命周期中的事件发出通知和警报。
- 监控 ML 应用程序的运行和 ML 相关问题。
- 利用 Azure 机器学习和 Azure 管道自动化端到端 ML 生命周期。
Azure ML 在模型注册和审计跟踪领域提供了特性。您可以使用中央注册中心来存储和跟踪数据、模型和元数据，并通过审计跟踪自动捕获沿袭和治理数据。
如果你想让你的整个 ML 基础设施基于云，或者已经这样做了，Azure 是很有帮助的。
Comet 是一个机器学习实验管理平台。这是一个功能丰富的系统，可以帮助您通过 Python SDK 实验记录实验模型，以及注册、版本化和部署它们。
在 Registered models 选项卡中，您将看到您的模型的所有版本，以及每个版本的详细信息。Comet 使得跟踪实验和模型版本的历史变得简单。由于通过贝叶斯超参数优化算法的模型再现和模型优化，ML 工作流的维护也变得更加有效。这里你可以阅读更多关于 Comet 的模型注册表。
总的来说，Comet 具有强大的功能，允许个人开发人员和专业团队运行和跟踪实验:
- 快速整合。只需几行代码，就可以轻松将该解决方案与您使用的其他工具集成。Comet 兼容大多数平台和机器学习库。
- 对比实验。您可以在一个用户界面中访问代码、超参数、指标和依赖关系，从而方便比较实验。
- 不断地监视。如果模型的性能下降，您会收到警报。从培训到生产的自动化监控提高了项目的质量。
- 改善报告。可视化和报告的内置功能有助于与利益相关者和团队其他成员的沟通。
Dataset versioning in Weights & Biases | Source
Weights and Biases 是一个用于实验跟踪、数据集版本化和模型管理的平台。模型注册不是它的主要焦点，而是 WandB 的组件之一， Artifacts ，允许您对数据集和模型进行版本化，这有助于 ML 模型的传承并保证它们的可重复性。
Wandb 还拥有令人难以置信的可视化工具，有助于可视化模型性能、训练指标和模型预测。您可以将 Weights & Biases 与您喜欢的库和框架一起使用。
除此之外，该工具使工程师能够用超参数的各种组合来训练模型。多亏了这个工具，这个过程变得简单多了:数据科学家所要做的就是准备代码来训练模型和调整超参数。
WandB 的主要优势包括:
- 简单的实验跟踪
- 自动超参数调谐
- 可定制的可视化
- 与流行框架的集成
- 协作功能
摘要
MLflow 是一个非常有用的工具，它不仅提供了模型注册，还提供了实验跟踪、代码和模型打包、模型部署等等。这是最受 ML 从业者欢迎的开源工具之一。但是，它缺少一些功能，比如模型血统、代码和数据集版本控制、访问管理或者共享项目(这对 ML 团队来说尤其有益)。它还必须托管在您自己的服务器上。
如果这些要点对你至关重要，看看市场周围，看看有什么替代工具可用总是好的。
你应该选择什么？如果您正在寻找一个专注于模型注册并扩展该领域功能的工具，Neptune 是最佳选择(它的主要焦点是实验跟踪和模型注册)。如果你对可以帮助你完成整个 ML 模型生命周期的工具感兴趣，可以去亚马逊 SageMaker 或者 VertaAI 看看。AzureML 和 Comet 也涵盖了更广泛的任务。
分析您的需求和用例，并测试与它们最匹配的工具。希望这个列表能帮助你找到一些选择！**
强化学习的最佳基准:终极清单
原文：https://web.archive.org/web/https://neptune.ai/blog/best-benchmarks-for-reinforcement-learning
在这篇文章中，我将与你分享我的支持训练强化学习(RL)代理的环境库。RL 研究的基础，甚至玩 RL 或者学习 RL 的基础，都是环境。它是你运行你的算法来评估它有多好的地方。我们将探索 23 种不同的基准，因此我保证您会发现一些有趣的东西！
但首先，我们将做一个简短的介绍，如果你刚刚开始学习 RL，你应该寻找什么。不管你目前的知识水平如何，我建议你浏览一下整个列表。我希望它能激励你继续做好工作，并激励你以不同于标准基准的方式开始自己的项目！
经验法则
如果你对专门研究离散动作空间 (PPO、DQN、彩虹……)的算法感兴趣，例如，动作输入可以是雅达利 2600 游戏控制器上的按钮，那么你应该看看开放 AI 健身房中的雅达利环境。这些包括 Pong，Breakout，Space Invaders，Seaquest 等等。
另一方面，如果你对专门研究连续动作空间 (DDPG、TD3、SAC、…)的算法更感兴趣，比如说，动作输入是学习走路的人形机器人关节上的扭矩，那么你应该看看 OpenAI Gym 和 DeepMind Control Suite 中的 MuJoCo 环境。PyBullet Gymperium 是一种免费的替代品。更艰苦的环境包括机器人在开放人工智能健身房。
如果你还不知道你感兴趣的是什么，那么我建议你在 OpenAI 健身房里玩玩经典控制环境，并阅读《T2》深度学习。
介绍够了，来看看基准吧！
基准
这一部分的第一部分只是一个列表，按字母顺序列出了所有 23 个基准。接下来，我添加了每个基准测试创建者的一些描述，向您展示它的用途。
RL 基准列表
A
体验假说是这样一种观点，即“智能出现在主体与环境的相互作用中，并且是感觉运动活动的结果”。 Habitat 是一个用于研究嵌入式人工智能的模拟平台。
想象一下，走到一个家用机器人面前，问“嘿，机器人，你能去看看我的笔记本电脑在不在我的桌子上吗？如果有的话，拿给我”。或者问一个以自我为中心的人工智能助理(坐在你的智能眼镜上):“嘿——我最后一次看到我的钥匙是在哪里？”。AI Habitat 能够在将学到的技能转移到现实之前，在高度逼真的&高效 3D 模拟器中训练这种具体化的 AI 智能体(虚拟机器人和以自我为中心的助手)。
如果你学习具有物理或虚拟化身的智能系统，这将是最适合你的。
B
bsuite 是一组精心设计的实验，调查强化学习(RL)代理的核心能力，有两个主要目标。
- 收集清晰的、信息丰富的、可扩展的问题，这些问题抓住了设计有效的、通用的学习算法中的关键问题。
- 通过代理在这些共享基准上的表现来研究他们的行为。
这个库自动评估和分析这些基准上的任何代理。它有助于对 RL 中的核心问题进行可重复和可访问的研究，并最终设计出优秀的学习算法。
D
dm_control 软件包是一个 Python 库和任务套件的集合，用于关节式身体模拟中的强化学习代理。MuJoCo 包装器提供了方便的函数和数据结构绑定，可以创建自己的任务。
此外，控制套件是一组具有标准化结构的固定任务，旨在作为性能基准。它包括像 HalfCheetah，Humanoid，Hopper，Walker，Graber 等经典任务(见图)。运动框架提供了运动任务(如足球)的高级抽象和示例。还包括一组可配置的操作任务，包括机械臂和拼接砖。
该软件包的介绍性教程可通过协作笔记本获得。
DeepMind Lab 是通过 ioquake3 和其他开源软件，基于 Quake III Arena 的 3D 学习环境。DeepMind 实验室为学习代理提供了一套具有挑战性的 3D 导航和解谜任务。它的主要目的是作为人工智能研究的试验台，代理人必须根据视觉观察采取行动。
DeepMind 记忆任务套件是一组 13 个不同的机器学习任务，需要记忆来解决。构造它们是为了让我们评估特定于内存的维持集的泛化性能。
Psychlab 是 DeepMind 实验室第一人称 3D 游戏世界内部的模拟心理学实验室。Psychlab 实现了经典的实验室心理学实验，因此它们可以与人类和人工代理一起工作。Psychlab 有一个简单灵活的 API，使用户能够轻松地创建自己的任务。例如，Psychlab 包括几个经典的实验范例，包括视觉搜索、变化检测、随机点运动辨别和多目标跟踪。
G
Google Research Football 是一个新颖的 RL 环境，代理人的目标是掌握世界上最受欢迎的运动——足球！模仿流行的足球视频游戏，足球环境提供了一个高效的基于物理的 3D 足球模拟，其中代理控制他们队中的一个或所有足球运动员，学习如何在他们之间传球，并设法克服对手的防守以得分。足球环境提供了一组要求严格的研究问题，称为足球基准，以及足球学院，一组越来越难的 RL 场景。
它非常适合多智能体和多任务研究。它还允许您创建自己的学院场景，以及使用模拟器，基于包括的例子全新的任务。
M
元强化学习算法可以使机器人通过利用先前的经验来学习如何学习，从而更快地获得新技能。 Meta-World 是一个开源的模拟基准，用于元强化学习和多任务学习，由 50 个不同的机器人操纵任务组成。作者旨在提供足够广泛的任务分布，以评估 meta-RL 算法对新行为的推广能力。
MineRL 是一个始于卡耐基梅隆大学的研究项目，旨在开发《我的世界》人工智能的各个方面。简而言之，MineRL 由两个主要部分组成:
- MineRL-v0 数据集–最大的模仿学习数据集之一，拥有超过 6000 万帧记录的人类球员数据。该数据集包括一组环境，这些环境突出了现代强化学习中的许多最困难的问题:稀疏奖励和分层政策。
- 用于在《我的世界》进行人工智能研究的丰富的 python3 包。这包括两个主要的子模块:MineRL . env——《我的世界》的一组不断增长的 OpenAI 健身房环境和MineRL . data——用于试验 MineRL-v0 数据集的主要 python 模块。
它使用“world gen:Randomized MuJoCo environments”允许用户生成复杂的、高度随机化的环境。如果你想创造自己的环境，你也应该尝试一下！
O
Gym 除了是最广为人知的基准之外，还是一个开发和比较强化学习算法的神奇工具包。它支持教导代理从行走模拟人形机器人(需要 MuJoCo，免费选择见 PyBullet Gymperium )到玩像 Pong 或 Pinball 这样的 Atari 游戏。我个人在研究中用得最多。它非常容易使用，而且是当今的标准配置。你应该好好了解一下。
健身房复古可以认为是 OpenAI 健身房的延伸。它可以让你将经典的视频游戏转化为开放式人工智能健身房环境，用于强化学习，并集成了约 1000 个游戏。它使用各种支持 Libretro API 的模拟器，使得添加新的模拟器相当容易。
OpenSpiel 是一个环境和算法的集合，用于游戏中一般强化学习和搜索/规划的研究。OpenSpiel 支持 n 人(单个和多个代理)零和、合作和一般和、一次性和连续、严格轮流和同时移动、完美和不完美信息游戏，以及传统的多代理环境，如(部分和完全可观察的)网格世界和社会困境。OpenSpiel 还包括分析学习动力和其他常见评估指标的工具。游戏被表示为程序性的扩展形式的游戏，带有一些自然的扩展。为了提高效率，核心的 API 和游戏都是用 C++实现的，为了便于使用，它们都暴露在 Python 中。
P
Procgen Benchmark 由 16 个独特的环境组成，旨在测量强化学习中的样本效率和泛化能力。这个基准是评估泛化的理想选择，因为在每个环境中都可以生成不同的训练集和测试集。该基准也非常适合于评估样本效率，因为所有环境都给 RL 代理带来了各种各样令人信服的挑战。环境的内在多样性要求代理学习健壮的策略；过度适应状态空间中的狭窄区域是不够的。换句话说，当代理人面对不断变化的水平时，概括的能力成为成功的一个不可或缺的组成部分。
PyBullet Gymperium 是 OpenAI Gym MuJoCo 环境等的开源实现。这些都是具有挑战性的连续控制环境，比如训练人形机器人行走。它的酷之处在于，它不需要用户安装 MuJoCo，这是一个需要付费许可证才能运行 30 天以上的商业物理引擎。
稀有
现实世界强化学习的挑战论文确定并描述了一组九个挑战，这些挑战目前阻碍了强化学习(RL)代理在现实世界应用和产品中的应用。它还描述了一个评估框架和一组环境，可以评估 RL 算法对现实系统的潜在适用性。从那时起，对现实世界强化学习的挑战进行了实证研究论文，实现了九个描述的挑战中的八个，并分析了它们对各种最先进的 RL 算法的影响。
这是用于执行该分析的代码库，也是用于围绕这些挑战进行可重复实验的通用平台。它被称为 realworldrl-suite (真实世界强化学习(RWRL)套件)。
RLCard 是一个卡牌游戏中强化学习(RL)的工具包。它通过易于使用的界面支持多卡环境。游戏包括 21 点，UNO，限制德州扑克，等等！它还允许您创建自己的环境。RLCard 的目标是在强化学习和不完美信息博弈之间架起一座桥梁。
RL 不插电是一套离线强化学习的基准测试。RL Unplugged 旨在促进易用性，它为数据集提供了统一的 API，一旦建立了通用管道，从业者就可以轻松地处理套件中的所有数据。它包括最常见基准的数据集:雅达利、DeepMind 移动、DeepMind 控制套件、Realworld RL、DeepMind 实验室和 bsuite。
S
Screeps 是一款大型多人在线即时战略游戏(phwee，很多)。每个玩家都可以在一个所有玩家共享的世界中创建自己的殖民地。这样的殖民地可以开采资源，建造单位，征服领土。随着你征服更多的领域，你在游戏世界中的影响力也在增长，你扩大自己影响的能力也在增长。然而，这需要你付出很多努力，因为多个玩家可能会瞄准同一个领域。最重要的是，你建立了一个能做所有这些的人工智能！
Screeps 是为有编程技能的人开发的。与其他 RTS 游戏不同，你在 Screeps 中的单位可以在没有你参与的情况下对事件做出反应——前提是你已经对它们进行了适当的编程。
毒蛇。AI 是一个简单而强大的新颖框架，帮助开发者创建游戏代理。用熟悉的 Python 代码，将你拥有的任何视频游戏变成一个成熟的沙盒环境进行实验。比如 GTA 里的这个自动驾驶智能体。该框架首先为机器学习& AI 研究提供了一个有价值的工具。作为一个业余爱好者来说，使用它也是非常有趣的(而且很容易上瘾)！
PySC2 为 RL 代理提供了与星际争霸 2 交互的接口，获取观察和发送动作。它将暴雪娱乐的星际争霸 2 机器学习 API 暴露为 Python RL 环境。这是 DeepMind 和暴雪的合作，将星际争霸 2 开发成一个丰富的 RL 研究环境。 PySC2 有很多预配置的小游戏地图，用于对 RL 代理进行基准测试。
T
这是一个开源项目，使游戏和模拟成为训练智能代理的环境。Unity 提供了最先进算法的实现(基于 PyTorch ),使游戏开发者和爱好者能够轻松训练 2D、3D 和 VR/AR 游戏的智能代理。然而，研究人员可以使用提供的简单易用的 Python API，通过强化学习、模仿学习、神经进化或任何其他方法来训练代理！例如，参见马拉松环境。
W
这是官方的 Python 实现 WordCraft:一个基准测试常识代理的环境。快速解决各种现实任务的能力需要对世界有常识性的理解。为了更好地利用常识对代理进行研究，你应该试试 WordCraft，一个基于小炼金术 2 的 RL 环境。小炼金术 2 是一个有趣和令人上瘾的游戏，它允许玩家组合元素来创造更多的元素。这种轻量级环境运行速度很快，并且建立在受现实世界语义启发的实体和关系之上。
结论
我们的 RL 基准测试列表到此结束。我真的不能告诉你应该选哪一个。对于一些人来说，在“经验法则”一节中描述的更经典的基准，如 OpenAI Gym 或 DM Control Suite，将是最合适的。对于其他人来说，这是不够的，他们可能会想投入一些不那么累的东西，如 Unity ML-agents 或 Screeps。
就我个人而言，有一次我和 GRF 一起工作，看到我的经纪人如何学习踢足球和进球很有趣。目前，我正在进行一些更基础的研究，并使用公认的 OpenAI Gym MuJoCo 环境测试我的代理，这在其他方面很有趣，比如看到我的方法真的有效。
无论你的选择是什么，我希望这个列表能帮助你让你的 RL 研究更令人兴奋！
最佳数据沿袭工具
原文：https://web.archive.org/web/https://neptune.ai/blog/best-data-lineage-tools
数据是每个机器学习模型的主要部分。你的模型只有在有数据的情况下才是好的，没有数据你根本无法建立一个模型。因此，只使用准确可信的数据来训练模型是有意义的。
在运营过程中，许多组织都需要改进数据跟踪和传输系统。这种改进可能会导致:
- 发现数据中的错误，
- 实施有效的变革以降低风险。
- 创建更好的数据映射系统。
一些作家说数据是新的石油。就像石油成为汽车的燃料一样，数据也必须经历从原始数据到模型组件甚至简单可视化的过程。
数据科学家、数据工程师和机器学习工程师依靠数据来构建正确的模型和应用程序。它有助于理解数据在用于构建精确模型之前的必要旅程。
这个数据之旅的概念实际上有一个真实的名字— 数据血统。在本文中，我们将探索数据血统在机器学习中的意义，并查看几个付费和开源的数据血统工具。
机器学习中的数据血统是什么？
机器学习中的数据谱系描述了数据从收集到使用的过程。它展示了从最终消费前理解、记录、可视化变化和转换数据的过程。它是数据如何转换、具体转换了什么以及为什么转换的详细过程。
在机器学习中，模型通常是对其进行训练的数据的压缩版本。当您知道数据集的数据谱系时，就更容易实现可重复性。
数据沿袭工具帮助您可视化和管理数据的整个过程。选择数据沿袭工具时，您应该寻找一些核心特性:
- 可追溯性:追踪和验证数据历史的能力。这非常重要，它有助于确保您拥有高质量的数据。
- 不变性:不变性给数据沿袭工具带来了信任。不变性意味着您可以在做出更改后返回到数据集的先前版本。
- 开源:开源数据沿袭工具的优点是可以免费使用，并且在不断改进。
- 集成:数据之旅涉及许多阶段和工具，从存储到不同的转换(争论、清理、摄取等。).因此，数据沿袭工具应该能够轻松地与第三方应用程序集成。
- 版本化:一个好的数据沿袭工具应该跟踪数据的不同版本，并在各种转换和调优过程中对变化进行建模。
- 协作:对于远程数据科学团队来说，在共享数据上协作很重要。此外，了解谁对数据进行了更改以及为什么要进行更改也很重要。
- 元数据存储:数据沿袭工具应该包括一个元数据存储。
- 大数据处理:很多机器学习模型都需要大数据，因此数据血统工具应该能够高效地处理和加工大数据。
现在，让我们看看机器学习中一些最好的数据谱系工具。
让我们从不同工具的汇总表开始，我们将在下面更详细地讨论每一个工具。
海王星
Neptune 是 MLOps 的元数据存储，为运行大量实验的研究和生产团队而构建。
它为您提供了一个中心位置来记录、存储、显示、组织、比较和查询机器学习生命周期中生成的所有元数据。个人和组织使用 Neptune 进行实验跟踪和模型注册，以控制他们的实验和模型开发。
特性:
Neptune 允许您显示和探索数据集的元数据。使用 Neptune 的名称空间或基本日志记录，您可以存储和跟踪数据集元数据，例如数据集的 md5 散列、数据集的位置、类列表、特性名称列表(针对结构化数据问题)。
- Neptune 允许你通过记录模型检查点来版本化你的模型。
- Neptune 有一个可定制的 UI ，允许你比较和查询所有的 MLOps 元数据。
- 要了解更多关于 Neptune 的数据血统和版本，请点击这里查看。
MLFlow
MLflow 是一个用于构建、部署和管理机器学习工作流的开源平台。它旨在标准化和统一机器学习过程。它有四个主要部分来帮助组织 ML 实验:
MLflow Tracking :这允许您记录您的机器模型训练会话(称为运行),并使用 Java、Python、R 和 REST APIs 运行查询。
- MLFlow 模型:模型组件提供了一个标准单元，用于封装和重用机器学习模型。
- ml flow Model Registry:Model Registry 组件让您集中管理模型及其生命周期。
- MLflow 项目:项目组件封装了数据科学项目中使用的代码，确保其可以轻松重用，实验可以重现。
- 特性:
MLflow Model Registry 为组织提供了一套 API 和直观的 UI，用于注册和共享新版本的模型，以及对现有模型执行生命周期管理。
- MLflow Model Registry 与 MLflow tracking 组件一起使用，它允许您追溯生成模型和数据工件的原始运行以及该运行的源代码版本，从而为所有模型和数据转换提供完整的生命周期谱系
- MLflow 模型注册组件与 Delta Lake Time Travel 集成:
- 为大数据存储提供数据存储(数据湖)。
- 当存储在增量表或目录中时，自动对存储在数据湖中的数据进行版本控制。
- 允许您使用版本号或时间戳获取数据的每个版本。
- 允许您在意外写入或删除错误数据时进行审核和回滚。
- 你可以复制实验和报告。
- 要了解更多关于 MLflow 的信息，请查看 MLflow 文档。
检查一下海王星和 DVC 有什么不同。
迟钝的人
Pachyderm 是一个数据平台，它将数据谱系与 Kubernetes 上的端到端管道混合在一起。它为数据科学项目和 ML 实验带来了数据版本控制的管道层。它进行数据采集、摄取、清理、管理、争论、处理、建模和分析。
Pachyderm 有三种版本:
社区版:一个你可以在任何地方使用的开源平台。
- 企业版:完整的版本控制平台，具有高级功能、无限的可扩展性和强大的安全性。
- Hub Edition:社区版和企业版的结合。它减轻了你自己管理 Kubernetes 的工作量。
- 特性:
像 Git 一样，Pachyderm 帮助您找到数据源，然后在模型开发过程中对数据进行处理时对其进行跟踪和版本化。
- 厚皮动物给出了从数据源到当前状态的日期。
- Pachyderm 允许您快速审计数据版本跟踪和回滚中的差异。
- Pachyderm 提供大数据的 dockerized MapReduce。
- Pachyderm 将所有数据存储在 Minio、AWS S3 或谷歌云存储等中央存储库中，并拥有自己的专用文件系统，称为 Pachyderm 文件系统或 PFS。
- 当数据集发生变化时，Pachyderm 会对所有相关数据进行更新。
- 它管理和记录对数据进行的转换。
- 要了解更多关于厚皮动物的信息，请查阅厚皮动物文档。
查查海王星和 MLflow 有什么区别。
真实数据
Truedat 是一个开源的数据治理工具，提供从模型开始到结束的端到端数据可视化。
特性:
Truedat 从业务和技术的角度提供了对数据的端到端(从起点到终点)理解。
-
Truedat 允许您通过可配置的工作流程组织和丰富信息，并监控政府活动。
-
使用数据湖管理选项，您可以请求、交付和使用受治理的数据。
-
Truedat 提供了对数据随时间变化的洞察。
-
Truedat 提供数据治理。
-
Truedat 提供了对象沿袭跟踪、沿袭对象过滤和数据的时间点可见性。
-
Truedat 提供数据的用户/客户端/目标连接可见性。
-
Truedat 提供了关于数据之旅的视觉和文本沿袭视图。
-
Truedat 提供数据库变更影响分析。
-
Truedat 可以集成在亚马逊 S3、亚马逊 RDS、Azure、大查询、Power BI、MySQL、PostgresSQL、Tableau 等上面。
-
要了解更多关于 Truedat 的信息，请查看 Truedat 文档。
CloverDX
CloverDX 支持多个数据流程的组织，改进并自动化透明的数据转换。CloverDx 集合了转换和工作流的设计，包括编码能力。
CloverDX 通过开发人员友好的可视化设计器为您的数据集提供数据沿袭。它有利于自动化与数据相关的任务，如数据迁移，而且速度很快。
特性:
CloverDX 为数据工作流提供了透明度和平衡。
- CloverDX 托管其他数据质量工具。
- CloverDX 为您的数据进行错误跟踪和解决。
- 可回收数据操作。
- 自给自足的数据操作。
- CloverDX 可以独立使用，也可以嵌入使用。
- CloverDX 集成了 RDBMS、JMS、SOAP、LDAP、S3、HTTP、FTP、ZIP 和 TAR。
- SentryOne 文档
SentryOne Document 为您提供强大的工具，确保您的数据库得到持续、准确的记录。此外，数据沿袭分析功能通过提供数据来源的可视化表示，帮助您确保合规性。
特性:
通过清晰显示整个环境中的数据依赖关系的可视化显示来跟踪数据沿袭。
- 记录数据源，包括 SQL Server、SQL Server Analysis Services (SSAS)、SQL Server Integration Services(SSIS)、Excel、Power BI、Azure Data Factory 等。
- 借助易于访问的云或软件解决方案，轻松管理文档任务和查看日志。
- DVC
DVC 是一个机器学习项目的开源版本控制系统。DVC 通过始终如一地维护最初用于运行实验的输入数据、配置和代码的组合来保证再现性。
它利用现有的工具，如 Git 和各种 CI/CD 应用程序。它可以被分组为组件。
特性:
DVC 提供了分布式版本控制系统的所有优势——无锁、本地分支和版本控制。
- DVC 运行在任何 Git 存储库之上，兼容任何标准的 Git 服务器或提供商(GitHub、GitLab 等)。
- 数据管道描述了模型和其他数据工件是如何构建的，并提供了一种有效的方法来复制它们。认为“数据和 ML 项目的 Makefiles”做得对。
- 它可以与亚马逊 S3、微软 Azure Blob 存储、谷歌驱动、谷歌云存储、阿里云 OSS、SSH/SFTP、HDFS、HTTP、网络附加存储或磁盘集成来存储数据。
- DVC 有一种内置的方式将 ML 步骤连接到 DAG 中，并端到端地运行整个管道。
- DVC 处理中间结果的缓存，如果输入数据或代码是相同的，它不会再运行一个步骤。
- 查查海王星和 MLflow 有什么区别。
齿条
Spline (SPark LINEage)是一个免费的开源工具，用于自动数据谱系跟踪和数据管道结构。它最初是为 Spark 设计的，但该项目已经扩展到容纳其他数据工具。
样条有三个主要部分:
Spline 服务器:它充当通过 Producer API 从 spline 代理获得的沿袭元数据的中央存储库，并将其存储在 ArangoDB 中。
- Spline 代理:Spline 代理监听 spark 活动，然后跟踪并记录从各种 Apache 数据管道(spark 活动)获得的沿袭信息，并使用 REST 或 Kafka 通过其生产者 API 以标准格式将其发送到 Spline 服务器。Spline 代理是一个 Scala 库，可以独立使用，不需要 Spline 服务器，这取决于您的使用情况。
- Spline UI:它是一个 docker 图像或 WAR 文件，用作 Spline 的 UI。Spline 消费者 API 端点可以从 Spline UI 上的用户浏览器直接访问。
- 特性:
Spline 跟踪并记录作业依赖关系，然后继续创建它们如何交互以及每个转换中发生的转换的概述。
- Spline 可以在 Azure 数据块中使用。
- 样条函数很好地处理大数据，并且易于使用。
- Spline 有一个显示沿袭信息的可视化界面。
- Spline 使与业务团队的沟通变得容易。
- Spline 可以很好地处理结构化数据 API，例如 SQL、数据集、数据框等。
- 要了解更多关于 Spline 的信息，请查阅 spline 文档。
结论
如您所见，如果您想做可重复的、高质量的工作，数据血统是非常重要的。浏览本文中列出的工具，看看什么最适合您的用例。感谢阅读！
As you can see, data lineage is very important if you want to do reproducible, high-quality work. Look through the tools listed in this article and see what fits your use case best. Thanks for reading!
增强机器学习模型理解的最佳数据科学工具
有一个广泛的工具目录，可以用来帮助您增加对机器学习模型的理解。它们分为不同的类别:
在本文中，我将尽可能简要地向您介绍一些工具，向您展示 ML 工具生态系统是多么丰富。
1.交互式 web 应用工具
这个开源的 ML 工具允许你为你的模型构建定制的 web 应用。你可以用一种非常互动和易懂的方式展示你的模型，这样任何人都可以很容易地使用它。
只需几分钟，您就可以构建和部署漂亮而强大的数据应用程序。
要使用 Streamlit，您只需使用以下命令将它与 pip 一起安装:
pip install streamlit
Streamlit 的用户界面会询问你是否想重新运行应用程序并查看更改。这允许您在快速迭代循环中工作:您编写一些代码，保存它，检查输出，再编写一些，等等，直到您对结果满意为止。
查看 Streamlit 文档以了解它是如何工作的。
用于构建 web 应用程序的最流行的轻量级 Python 框架之一。您可以使用它为您的模型开发一个 web API。它基于 Werkzeug WSGI 工具包和 Jinja2 模板引擎。
Flask 有一个简单的架构，你可以非常容易地学习它。强烈建议将其用于构建小型应用程序。您可以快速部署模型并设置 REST API。
要开始使用 Flask，请设置虚拟环境，并使用以下命令安装它:
pip install flask
有关详细信息，请查看烧瓶文档。
Shiny 是一个用于构建交互式 web 应用程序的 R 包。如果你已经知道 R 语言，那么用它来构建一个应用程序和分享你的作品将会非常容易。它有一个真正的交互式和直观的设计。
你可以在网页上托管独立的应用程序，或者将它们嵌入到 R Markdown 文档中，或者构建仪表盘。你也可以用 CSS 主题、 htmlwidgets 和 JavaScript 动作来扩展你闪亮的应用。
要开始使用 Shiny，请使用以下命令:
install.packages("shiny")
2.数据分析工具
DABL 代表数据分析基线库。您可以使用它来自动化在模型开发的早期阶段发生的重复过程，比如数据清理、预处理、分析、处理缺失值或者将数据转换成不同的格式。
这是一个新的 Python 库，所以它的功能有限，但它非常有前途。
要开始使用 DABL，请使用以下命令:
pip install dabl
想了解更多关于 DABL 的信息，请看这篇文章。
用于创建数据科学应用程序和构建机器学习模型的开源数据分析工具。
您可以通过其模块化数据管道概念来集成机器学习和数据挖掘的各种组件。KNIME 已经被用于 CRM、文本挖掘和商业智能等领域。
它提供了一个交互式 GUI 来使用拖放构建器创建工作流。它支持多线程的内存数据处理，KNIME server 支持基于团队的协作。
要开始使用 KNIME，请访问文档。
帮助您准备和分析数据的数据科学平台。非常用户友好，你可以拖放代码。
它有几个数据探索功能，您可以使用这些功能从您的数据中获得有价值的见解。它为数据分析提供了超过 14，000 个运算符。
要开始使用 RapidMiner，请点击此链接。
SAS 代表统计分析系统，它是用来分析统计数据的。它帮助您使用 SAS SQL 和自动代码生成进行数据分析。你可以很容易地将它与 Excel 等 MS 工具集成。
SAS 允许您创建交互式仪表板和报告，以更好地了解复杂的数据。
要开始使用 SAS，请查看本教程。
3.模型可解释性工具
Eli5 是一个 Python 包，可以让你解释机器学习分类器的预测。它支持以下包和框架:
- XGBoost–解释 XGBClassifier、XGBRegressor 的预测，并帮助验证特性的重要性。
- CatBoost–解释 CatBoostClassifier、CatBoostRegressor 的预测，并帮助验证功能的重要性。
- Scikit-learn–解释 sci kit-learn 线性分类器和回归器的权重和预测，并帮助验证决策树的特征重要性。
要了解更多关于 Eli5 的信息，请查看文档。
它代表沙普利加法解释。它基于沙普利价值观。SHAP 值通过分解预测来显示每个要素的影响，这可能会产生强大的模型洞察力。
SHAP 值的一些应用有:
- 一个模型说，银行不应该贷款给某人，法律要求银行解释每次拒绝贷款的依据。
- 医疗保健提供者希望确定哪些因素导致了患者的疾病风险，以便通过有针对性的健康干预措施直接解决这些风险因素。
要了解更多关于 SHAP 的信息，请查看这篇教程。
它代表描述性机器学习解释。这是一个 R 包，主要是为了模型的可解释性而构建的。
机器学习的可解释性变得越来越重要。这个软件包可以帮助您提取洞察力，并清楚地了解您的算法是如何工作的，以及为什么一个预测优于另一个预测。
Dalex 便于比较多种型号的性能。使用 Dalex 有几个优势:
- 它包括用于局部解释的独特和直观的方法，
- 它可以定制预测的输出，
- 它为结果比较提供了方便的方法。
要了解更多关于 Dalex 的信息，请查看官方 GitHub 页面。
4.模型调试工具
一个机器学习的可视化调试工具，由优步的团队开发。它的开发是为了使模型迭代过程更加明智和可行。
数据科学家可以使用它来查看总体摘要，并检测数据中预测不准确的部分。Manifold 还通过显示性能较好和较差的数据子集之间的特征分布差异，解释了模型性能较差的潜在原因。
Manifold 服务于大多数 ML 模型，包括大多数分类和回归模型。
要了解更多关于优步流形的信息，请查看官方页面。
5.模型性能调试工具
MLPerf 正在成为 ML 工作负载中有趣实验的主要部分，比较不同类型的专用基础设施或软件框架。它用于建立有用的标准来衡量 ML 硬件、软件和服务的培训绩效。
MLPerf 的目标是服务于商业和学术团体，确保可靠的结果，加速 ML 的进展，并使竞争系统的公平比较成为可能，同时鼓励创新以改进最先进的 ML。
要了解更多关于 MLPerf 的信息，请查看这篇介绍性文章。
6.实验跟踪工具
面向数据科学家的轻量级且功能强大的实验跟踪工具。它可以轻松地与您的工作流程集成，并提供广泛的跟踪功能。
您可以使用它来跟踪、检索和分析实验，或者与您的团队和经理共享它们。Neptune 非常灵活，可以与许多框架一起工作，并且由于其稳定的用户界面，它支持很好的可伸缩性(达到数百万次运行)。
它还允许您存储、检索和分析大量数据。
要了解更多关于海王星的信息，请查看网站。
它代表重量和偏见。这是一个 Python 包，可以让你实时监控模型训练。它很容易与 Pytorch、Keras 和 Tensorflow 等流行框架集成。
此外，它允许您将运行组织到项目中，在项目中您可以轻松地比较它们，并确定最佳执行模型。
在这篇介绍性文章中了解更多关于 WandB 的信息。
Comet 帮助数据科学家管理和组织机器学习实验。它可以让您轻松地比较实验，记录收集的数据，并与其他团队成员合作。它可以很容易地适应任何机器，并与不同的 ML 库很好地合作。
要了解更多关于 Comet 的信息，请查看官方文档。
用于跟踪机器学习实验和部署模型的开源平台。每个元素都由一个 MLflow 组件表示:跟踪、项目和模型。
这意味着，如果你正在使用 MLflow，你可以轻松地跟踪一个实验，组织它，为其他 ML 工程师描述它，并将其打包成一个机器学习模型。
MLflow 旨在实现从一个人到大型组织的可伸缩性，但它最适合个人用户。
要了解更多关于 MLflow 的信息，请查看官方文档。
7.生产监控工具
Kubeflow 使得部署机器学习工作流变得更加容易。它被称为 Kubernetes 的机器学习工具包，旨在利用 Kubernetes 的潜力来促进 ML 模型的扩展。
Kubeflow 背后的团队正在不断开发其功能，并尽最大努力让数据科学家的生活更轻松。Kubeflow 有一些跟踪功能，但它们不是该项目的主要焦点。作为补充工具，它可以很容易地与列表中的其他工具一起使用。
要了解更多关于 Kubeflow 的信息，请查看官方文档。
结论
这就结束了我们的不同机器学习工具的列表。正如您所看到的，生态系统是广泛的，这个列表并没有涵盖所有的工具。
有什么需求就有什么需求，不需要手动做事。使用这些工具来加快您的工作流程，让您作为数据科学家的生活更加轻松。
祝你好运！
利用机器学习项目改善工作流程的最佳 7 种数据版本控制工具
原文：https://web.archive.org/web/https://neptune.ai/blog/best-data-version-control-tools
跟踪所有用于模型和实验的数据并不容易。这需要很多时间，而且不仅仅是管理和跟踪文件。你需要确保每个人都在同一个页面上，并同时跟踪最新版本的变化。
使用正确的软件，你可以毫不费力地做到这一点！一个好的数据版本控制工具可以让你拥有一个统一的数据集和一个强大的实验库。
它还将实现所有团队成员之间的顺畅协作，因此每个人都可以实时跟踪变化，并始终知道发生了什么。
这是系统化数据版本控制、改进工作流程和最小化出错风险的好方法。
因此，请查看这些用于数据版本控制的顶级工具，它们可以帮助您实现工作自动化并优化流程。
如果您关心可再现性、可追溯性和 ML 模型血统，那么数据版本化工具对您的工作流程至关重要。
它们帮助您获得一个工件的版本，一个数据集或模型的散列，您可以在以后使用它来识别和比较。通常，您会将此数据版本记录到您的元数据管理解决方案中，以确保您的模型训练是版本化的和可重复的。
要为您的工作流选择合适的数据版本化工具，您应该检查:
- 支持您的数据形态:它是如何支持视频/音频的？它是否为表格数据提供了一些预览？
- 易用性:在你的工作流程中使用起来有多容易？它给你的执行增加了多少开销？
- Diff and compare :可以比较数据集吗？你能看到你的图像目录的不同吗？
- 它与您的堆栈配合得如何:您能否轻松连接到您的基础设施、平台或模型培训工作流？
- 你能让你的团队参与进来吗:如果你的团队不采用它，工具再好也没用。所以，记住你的队友的技能和偏好。
这里有一些值得探索的工具。
Neptune 是一个 ML 元数据存储库，为运行许多实验的研究和生产团队而构建。
您可以记录和显示几乎任何 ML 元数据，从超参数和度量到视频、交互式可视化和数据版本。
使用 Neptune 工件，您只需一行代码就可以从本地文件系统或任何 S3 兼容的存储中对数据集、模型和其他文件进行版本控制。具体来说，它可以节省:
- 文件或文件夹的版本(哈希)
- 文件或文件夹的位置
- 文件夹结构(递归)
- 文件或文件夹的大小
一旦登录，您可以使用 Neptune UI 对数据集版本进行分组运行，或者查看工件 c 如何在运行之间挂起。
说到数据版本控制，Neptune 是一个非常轻量级的解决方案，您可以很快上手。也就是说，它可能无法满足您在数据版本方面的所有需求。
另一方面，您可以将实验跟踪和模型注册都放在一个地方，并使用灵活的元数据结构以您想要的方式组织培训和生产元数据。它类似于您在代码中创建并显示在 UI 中的字典或文件夹结构。
如果您想知道它是否适合您的工作流程:
Pachyderm 是一个完整的版本控制的数据科学平台，有助于控制端到端的机器学习生命周期。它有三个不同的版本，社区版(开源，可以在任何地方部署)、企业版(完整的版本控制平台)和 Hub 版(托管版，仍处于测试阶段)。
这是一个在任何类型的机器学习项目上进行灵活协作的绝佳平台。
下面是你可以用 Pachyderm 作为数据版本工具做的事情:
- Pachyderm 允许您不断更新 repo 主分支中的数据，同时在单独的分支中试验特定的数据提交
- 它支持任何类型、大小和数量的文件，包括二进制和纯文本文件
- 厚皮动物提交是集中式和事务性的
- 出处使团队能够在彼此工作的基础上构建、共享、转换和更新数据集，同时自动维护完整的审计跟踪，以便所有结果都是可重复的
DVC 是一个机器学习项目的开源版本控制系统。这是一个工具，让你定义你的管道，不管你用什么语言。
当您在 ML 模型的先前版本中发现问题时，DVC 通过利用代码数据和管道版本化为您提供再现性来节省您的时间。您还可以训练您的模型，并通过 DVC 管道与您的队友分享。
DVC 可以处理大量数据的版本和组织，并以一种组织良好、易于访问的方式存储它们。它侧重于数据和管道版本化和管理，但也有一些(有限的)实验跟踪功能。
DVC–摘要:
- 可以使用不同类型的存储—不受存储限制
- 完整的代码和数据来源有助于跟踪每个 ML 模型的完整发展
- 通过始终如一地维护输入数据、配置和最初用于运行实验的代码的组合来实现可重复性
- 跟踪指标
- 一种将 ML 步骤连接到 DAG 并端到端运行整个管道的内置方式
- 跟踪失败的尝试
- 运行在任何 Git 存储库之上，并与任何标准 Git 服务器或提供商兼容
Git 大文件存储(LFS)是一个开源项目。它用 Git 中的文本指针替换大文件，如音频样本、视频、数据集和图形，同时将文件内容存储在远程服务器上，如 GitHub.com 或 GitHub Enterprise。
它允许你用 Git 在你的 Git 存储库中托管更多的****版本的大文件——甚至是那些大到几个 GB 大小的文件——用 Git，从处理大文件的存储库中更快地克隆和获取。
同时，在使用 GitHub 这样的远程主机时，您可以像 Git 存储库的其他部分一样，保留您的工作流以及对大文件的访问控制和权限。
Dolt 是一个 SQL 数据库，您可以像 git 存储库一样派生、克隆、分支、合并、推送和拉取。Dolt 允许数据和模式一起进化，以使版本控制数据库成为更好的体验。这是与您的团队合作的一个很好的工具。
您可以自由地连接到 Dolt，就像连接到任何 MySQL 数据库一样，使用 SQL 命令运行查询或更新数据。
使用命令行界面导入 CSV 文件，提交您的更改，将它们推送到远程，或合并您队友的更改。
你所知道的所有 Git 命令对 Dolt 都是一样的。Git 版本文件，Dolt 版本表。
还有DoltHub——一个分享 Dolt 数据库的地方。
lakeFS 是一个开源平台，它提供了一个类似 Git 的分支和提交模型，通过利用 S3 或 GCS 进行存储，该模型可以扩展到数 Pb 的数据。
这种分支模型使您的数据湖符合 ACID，因为它允许在独立的分支中发生变化，这些分支可以被自动地、即时地创建、合并和回滚。
lakeFS 有三个主要区域，让您关注 ML 模型的不同方面:
- 数据开发环境:提供了一些工具，您可以使用这些工具来隔离湖泊的快照，您可以对这些快照进行实验，而其他快照则不会暴露出来；比较变化和改进实验的再现性
- 持续数据集成:按照自己的规则录入和管理数据
- 连续数据部署:快速恢复数据变化的能力；提供数据集中的一致性；测试生产数据以避免连锁质量问题
lakeFS 是一个很好的工具，可以专注于数据集的特定区域，使 ML 实验更加一致。
Delta Lake 是一个开源存储层，它为数据湖带来了可靠性。Delta Lake 提供了 ACID 事务、可扩展的元数据处理，并统一了流式和批量数据处理。它运行在您现有的数据湖之上，并且与 Apache Spark APIs 完全兼容。
三角洲湖-概要:
- 可扩展的元数据处理:利用 Spark 的分布式处理能力轻松处理数十亿个文件的 Pb 级表的所有元数据。
- 流和批统一:Delta Lake 中的一个表是一个批表，也是一个流的源和汇。流式数据接收、批量历史回填、交互式查询都是开箱即用的。
- 模式实施:自动处理模式变化，以防止在摄取期间插入不良记录。
- 可串行化隔离级别确保读者永远不会看到不一致的数据。
- 数据版本支持回滚、完整的历史审计跟踪和可重复的机器学习实验
- 支持合并、更新、和删除操作，以支持复杂的用例，如变化数据捕获、渐变维度(SCD)操作、流上插等等。
把它包起来
现在您已经有了数据版本控制的最佳工具列表，您“仅仅”需要弄清楚如何让它为您和您的团队工作。
这可能很棘手。
选择数据版本时需要考虑的一些事项包括:
- 设置有多简单:你现在可能没有时间、需求或预算来测试一些沉重的东西。
- 你能让你的团队参与进来吗:有时候，解决方案很棒，但是你需要更多面向软件工程的心态来使用它。一些 ML 研究人员或数据科学家可能不会最终使用它。
- 您目前使用的是什么工具组合:您使用的是与特定数据版本化解决方案良好集成的特定工具、基础设施或平台吗？在这种情况下，可能最好的选择就是这样。
- 数据形态:是图像、表格、文本，还是全部？有时该工具并不十分支持您的模态，因为它构建时考虑了不同的用例。
如果您想讨论如何选择它或设置您的 MLOps 堆栈，我很乐意提供帮助。
联系我，让我们看看我能做些什么！
机器学习中使用的最佳图像处理工具
图像处理是一项非常有用的技术，该行业的需求似乎每年都在增长。历史上，使用机器学习的图像处理出现在 20 世纪 60 年代，作为模拟人类视觉系统和自动化图像分析过程的尝试。随着技术的发展和改进，针对特定任务的解决方案开始出现。
2010 年计算机视觉的快速加速，得益于深度学习以及开源项目和大型图像数据库的出现，只是增加了对图像处理工具的需求。
目前，已经创建了许多有用的库和项目，可以帮助您使用机器学习解决图像处理问题，或者简单地改进您使用 ML 的计算机视觉项目中的处理管道。
在本文中，我们将为您提供一个工具列表，这些工具将改进您的计算机视觉项目，分为:
- 框架和库
- 资料组
- 特定任务的现成解决方案
让我们开始吧！
框架和库
理论上，你可以从头开始构建你的图像处理应用程序，只需要你和你的电脑。但实际上，站在巨人的肩膀上，使用其他人构建的东西，并在需要的地方扩展或调整它，会更好。
这就是库和框架的用武之地，在图像处理中，创建高效的实现通常是一项困难的任务，这一点更是如此。
所以，让我给你一个你可以在你的图像处理项目中使用的库和框架的列表:
计算机视觉和图像处理算法的开源库。
专为实时计算机视觉应用而设计和优化。
旨在开发开放式基础设施。
功能性:
- 基本数据结构
- 图像处理算法
- 计算机视觉的基本算法
- 图像和视频的输入和输出
- 人脸检测
- 搜索立体声匹配(全高清)
- 光流
- 持续集成系统
- CUDA 优化架构
- 安卓版本
- Java API
- 内置性能测试系统
- 跨平台
用于机器学习的开源软件库。
旨在解决构建和训练神经网络的问题，目的是自动查找和分类图像，达到人类感知的质量。
功能性:
- 在多个并行处理器上工作
- 通过多维数据阵列计算——张量
- 张量处理器的优化
- 即时模型迭代
- 简单调试
- 自有记录系统
- 交互式日志可视化工具
开源机器学习平台。
旨在加速从研究原型到工业开发的开发周期。
功能性:
- 轻松过渡到生产
- 分布式学习和性能优化
- 丰富的工具和库生态系统
- 对主要云平台的良好支持
- 优化和自动微分模块
了解更多信息
了解如何使用 TensorFlow + Neptune 集成或 PyTorch + Neptune 集成来跟踪模型训练元数据。
专注于解决图像分类和分割问题的深度学习框架。
功能性:
- 使用 blobs 的计算–并行计算中使用的多维数据阵列
- 模型定义和配置优化，无需硬编码
- 轻松切换 CPU 和 GPU
- 工作的高速度
跨平台。用于图像处理的 OpenCV . net 插件。
功能性:
- 一起工作。NET 兼容语言——c#、VB、VC ++、IronPython 等。
- 兼容 Visual Studio、Xamarin Studio 和 Unity
- 可以在 Windows、Linux、Mac OS、iOS 和 Android 上运行
开源 C ++库的集合。
功能性:
- 加载、保存和修改许多常见文件格式的图像，包括非常大的图像
- 1、2 或 3 维中的点、曲线和其他基本对象的几何
- 相机几何
- 从运动中恢复结构
- 设计图形用户界面
- 拓扑学
- 3D 图像
用于读写栅格和矢量地理空间数据格式的库。
功能性:
- 获取有关栅格数据的信息
- 转换成各种格式
- 数据重投影
- 从栅格创建镶嵌图
- 使用栅格切片索引创建 shapefiles
2D/三维医学图像分割框架。
功能性:
- 创建分段管道
- 初步加工
- 输入输出
- 数据增长
- 补丁分析
- 自动评估
- 交互效度分析
计算机视觉 JavaScript 库。
功能性:
- 颜色跟踪
- 人脸识别
- 使用现代 HTML5 规范
- 轻量级内核(大约 7 KB)
眼球追踪库。
使用网络摄像头实时确定访问者在页面上的注视位置(用户正在看的地方)。
功能性:
- 模型的自校准，观察互联网访问者与网页的交互，并训练眼睛功能和屏幕上位置之间的显示
- 大多数现代浏览器中的实时外观预测
- 只需几行 JavaScript 就能轻松集成
- 预测多个视图的能力
- 在客户端的浏览器中工作，无需将数据传输到服务器
一个处理视频和图像的框架。
功能性:
- 捕捉视频帧
- 用于视频滤波的帧处理
- 多线程图像处理
- 通过 GUI 支持插件集成
- 从图像分量中提取特征
- 分形的产生
- 目标跟踪
- 运动检测
PyTorch 中的计算机视觉库。
功能性:
- 图像转换
- 极线几何
- 深度估计
- 低级图像处理(例如直接在张量上过滤和边缘检测)
- 颜色校正
- 特征识别
- 滤像
- 边界识别
数据集
没有数据，你无法建立机器学习模型。这在图像处理应用中尤其重要，在图像处理应用中，向训练数据集添加更多标记数据通常会比最先进的网络架构或训练方法获得更大的改进。
记住这一点，让我给你一个可以在你的项目中使用的图像数据集列表:
旨在减少算法偏差的数据集。
一百万张不同国籍、年龄和性别的人的面部标签图像，以及其他指标——头部大小、面部对比度、鼻子长度、前额高度、面部比例等。以及他们之间的关系。
用于识别伪造照片和视频的数据集。
使用 Face2Face、FaceSwap 和 DeepFakes 方法创建的一组图像(超过 50 万张)。
1000 个视频，使用每种伪造方法制作人脸。
Youtube 视频的数据集，带有 dynamics 中的标记内容。
大约 23.7 万个布局和 1000 个类别。
用于训练神经网络进行归纳的数据集
这些数据由真实世界的标记图像和未标记草图组成。
用于对无人机图像中的对象进行计数的数据集。
15532 次 RGB 无人机拍摄，每张图像都有一次红外拍摄。
对象标记可用于 RGB 和红外图像。
数据集包含方向对象边界和对象类。
在 31，064 幅图像的数据集中，总共标记了 441，642 个对象。
用于训练自动驾驶车辆的数据集。
包括带标记物体驾驶的视频。
3000 个总计 16.7 小时的驾驶视频，60 万帧，约 2500 万个 3D 物体边界和 2200 万个 2D 物体边界。
为了消除视频的一致性问题，在各种条件下进行记录。视频选项包括天气、行人、灯光、骑自行车的人和建筑工地。
数据的多样性提高了模型的泛化能力。
神经网络无法正确分类的图像数据集。
根据测试结果，模型从数据集中预测对象，精确度为 3%。
包含七千五百幅图像，其独特之处在于它们包含自然的视错觉。
旨在研究神经网络对模糊对象图像的稳定性，这将有助于提高模型的泛化能力。
现成的解决方案
现成的解决方案是为解决特定的、通常是专门化的任务而构建的开源存储库和软件工具。
通过使用这些解决方案，您可以将您的模型构建或图像处理流程“外包”给一个工具，只需点击一下鼠标或执行一个命令即可完成。
记住这一点，让我给你我的清单。
一组针对移动设备优化的计算机视觉算法。
功能性:
- 面部分析
- 根据环境确定位置
- 直接在智能手机上识别
- 低延迟和低功耗
面向 iOS 和 Android 开发者的机器学习平台。
功能性:
- 直接在移动设备上运行，无需数据传输
- 将模型移植到其他框架并更新应用程序中的模型，而无需发布新版本
用于标记照片和视频的交互式工具。
功能性:
- 用于标记的形状–矩形、多边形、折线、点
- 无需安装
- 合作能力
- 标记过程的自动化
- 支持各种注释脚本
三维图像中物体的分割。
解决实例分割问题在计算上比其他现有方法好 10 倍。
端到端神经网络，接受 3D 图像作为输入，并在输出端给出已识别对象的边界。
从数以千计的类别中识别物体。
检测图像中难以看见的物体。
允许您在任何现有检测器之上工作的体系结构。
噪声数据上物体边界的检测。
提高标记对象边界的精度。
任何语义编辑器和损失函数的附加层。
生成逼真的多功能图像。
修复了使用 GAN 生成图像的缺点。
编码器和解码器两级通信系统。
从视频中恢复帧。
当帧接近时恢复清晰度，并恢复视频录制中模糊帧的内容。
该模型在模型的输入端接收模糊帧，在输出端接收无模糊的恢复帧。
视频的自动标记。
从一个图像到整个视频的标记分发。
基于一个自我监督的模型。
用其他对象替换对象。
用最少的训练数据将物体图像从一类转换到另一类。
基于 GAN 架构。
图像问题的生成。
基于图片和期望的答案类型，显示生成的问题。
基于最大化相互信息。
对一个物体的部分进行视觉识别。
从部分图像中识别真实世界的物体。
基于将图像分成多个部分并学习这些部分如何组合在一起。
来自照片的布局。
从 360°照片恢复房间布局。
端到端模型。
从声音的音频记录中生成人脸的图像。
恢复声音所有者的主要外部特征。
以一个声谱图为输入，生成一个人的全脸无情绪的人脸。
物体与摄像机的接近度。
确定对象离相机有多近。
基于完全邻近图的比较。
从图像中建模物体的三维形状。
输入图像中对象的 3D 形状预测。
端到端模型。
从几张照片恢复三维视图。
从几张输出照片中恢复，从其他角度查看，以便可以在 3D 中查看图像。
基于一系列卷积神经网络。
将图像分辨率提高 8 倍。
更准确的面部图像质量更好，没有失真。
基于 GAN。
预测图像中的人数。
保留图像不同部分信息的确定。
端到端模型。
三维人体建模。
从一张照片恢复一个穿着衣服的人的 3D 模型。
端到端模型。
结论
项目的成功、执行效率和质量可能取决于许多因素，但选择正确的工具是最重要的因素之一——它可以让您显著节省时间和资源，并获得最佳结果。
有了图像处理的机器学习工具的知识，你可以更容易、更快、更有效地解决这类问题。
也就是说，阅读最佳工具是不够的:您仍然需要自己动手。因此，选择最适合您的工具并开始工作吧！
阅读下一篇
ML 实验跟踪:它是什么，为什么重要，以及如何实施
10 分钟阅读|作者 Jakub Czakon |年 7 月 14 日更新
我来分享一个听了太多次的故事。
“…我们和我的团队正在开发一个 ML 模型，我们进行了大量的实验，并获得了有希望的结果…
…不幸的是，我们无法确切地说出哪种性能最好，因为我们忘记了保存一些模型参数和数据集版本…
…几周后，我们甚至不确定我们实际尝试了什么，我们需要重新运行几乎所有的东西"
不幸的 ML 研究员。
事实是，当你开发 ML 模型时，你会进行大量的实验。
这些实验可能:
- 使用不同的模型和模型超参数
- 使用不同的培训或评估数据，
- 运行不同的代码(包括您想要快速测试的这个小变化)
- 在不同的环境中运行相同的代码(不知道安装的是 PyTorch 还是 Tensorflow 版本)
因此，它们可以产生完全不同的评估指标。
跟踪所有这些信息会很快变得非常困难。特别是如果你想组织和比较这些实验，并且确信你知道哪个设置产生了最好的结果。
这就是 ML 实验跟踪的用武之地。
作为一名数据科学家，您想要检查的最佳机器学习即服务平台(MLaaS)
云中巨大计算能力的可用性是机器学习革命背后的因素之一。因此，出现针对机器学习专家的基于云的服务就不足为奇了。但是选哪个呢？
事实上，基于云的服务并不新鲜。每个用户至少有一个电子邮件账户，这使他或她成为了云用户——他或她不知道电子邮件存储在哪里，也不知道用了多少计算能力来发送邮件。通常，没人会在意。
什么是机器学习即服务(MLaaS)？
当谈到机器学习时，获得计算能力对于这项技术的普及至关重要——该公司不需要服务器场来开发模型并使用它来自动化日常任务。但是，在开发一个模型时，仍然有多种工具可以使用，并且需要关注多个过程。商业现实从来不像发展理论那样简单明了。
机器学习即服务(MLaaS)基本上是一组基于云的工具的总称。这些工具旨在支持数据科学家和数据工程师的日常工作，就像基于云的办公套件彻底改变了办公环境一样。MLaaS 工具支持协作、版本控制、并行化和其他过程，否则这些过程会很麻烦。此外，较大的供应商提供了将他们的 MLaaS 服务与其产品组合的其余部分集成的简单方法，实现了部署流程的自动化，或者使人们能够使用基于机器学习的工具来丰富日常任务。
此外，对 MLaaS 工具的需求也越来越大。全球人工智能市场正在变得越来越大，根据 IDC 的估计，到今年年底，它的价值将达到 1565 亿美元。所以有很多公司愿意为数据科学家的工作付费。和许多其他公司，正等着通过提供贸易工具来攫取他们的份额。下面是后者的精选列表。
谈到云服务，AWS 机器学习是万能的。它允许公司利用几乎无限量的计算能力和存储。它还提供了更复杂的工具，其中包括 MLaaS。
AWS 机器学习(ML)提供了六种机器学习解决方案:
这是一项将文本转换成逼真语音的服务。它有助于开发能够说话的应用程序，并通过利用深度学习的力量来构建全新类别的语音产品。这也是为有叹息障碍的人构建包容性应用程序的巨大进步。
Polly 主要支持英语、巴西葡萄牙语、丹麦语、法语、日语、韩语、中文普通话和西班牙语等。Polly 支持的语言的完整列表在这里。
Polly 的 Neural 文本到语音(TTS) 支持两种说话风格。
- 新闻播音员风格——用于新闻叙述用例。
- 对话式–非常适合双向通信，如电话应用。
还提供了 亚马逊波利品牌 可以为组织打造定制语音。
使用亚马逊 Polly 品牌的公司有 FICO 、 USA Today 、 ProQuest 、 CBSi 、 Whooshkaa 、 MapBox 、等。
SageMaker 为开发者和数据科学家提供快速构建、训练和部署机器学习模型的服务，而无需担心代码。
所有的机器学习模型开发，包括笔记本、实验管理、自动模型创建和调试，都可以使用 SageMaker 的可视化界面进行。当谈到机器学习时，有许多重复和相对标准化的任务，这就是亚马逊 SageMaker 发挥作用的地方。
使用亚马逊 SageMaker 的好处:
- 用于机器学习任务的完全集成的开发环境(IDE)
- 自动构建、训练和调整模型。
- 降低高达 70%的数据标签成本。
- 支持所有领先的深度学习框架，如 TensorFlow、PyTorch、Apache MXNet、Chainer、Keras、Gluon、Scikit-learn。
使用亚马逊 SageMaker 的公司有 Intuit 、 GE 医疗、 ADP INC 、 Cerner 、道琼斯、等。
Amazon Lex 是一个用于聊天机器人的对话式 AI，它通过使用自动语音识别(ASR)的高级深度学习技术，将“对话界面”构建到任何使用语音和文本的应用程序中。
亚马逊 Lex 可以被认为是 Polly au rebours——Polly 对用户说话，Lex 可以阅读文本。
Amazon Lex 的用例:
- 呼叫中心聊天机器人和语音助手
- QnA 机器人和信息机器人
- 应用程序机器人
- 企业生产力机器人
使用亚马逊 Lex 的公司有诺基亚、沃纳格、复制子、健谈、等。
Amazon Rekognition 帮助识别图像和视频中的物体、人物、场景、文本和活动，检测任何不适当的内容。它还提供精确的面部分析和面部搜索功能，以便为用户验证任务检测、分析和比较面部。
使用 Amazon Rekognition 的好处:
- 它提供标签来识别对象，如自行车、电话、建筑物以及停车场、海滩、城市等场景。
- 用于扩展检测更多对象的能力的自定义标签。
- 内容审核
- 文本检测
- 人脸检测和分析
- 人脸搜索和验证
一些大公司如 NFL ， CBS ，国家地理， Marinus Analytics ， SkyNews 都在使用 Amazon Rekognition 。
亚马逊领悟 是一种自然语言处理(NLP)服务，使用机器学习在文本中寻找见解和关系。
工具利用机器学习的力量来发现非结构化数据中的见解和关系。该服务识别句子的语言，提取关键短语、地点、人物、品牌或事件。
亚马逊领悟医疗被广泛用于提取医疗文集信息，以帮助识别医疗状况、药物治疗和药物发明。
亚马逊理解的用例:
- 呼叫中心分析
- 索引和搜索产品评论
- 网站上的个性化内容
- 客户支持票据处理
- 临床试验招募
使用亚马逊领悟的公司有 LexisNexis 、 TeraDACT 、 FINRA 、 vidmob 。
亚马逊转录 通过利用一种称为自动语音识别(ASR) 的深度学习技术，通过将语音转换为文本，开发人员可以轻松地将语音转换为文本功能添加到他们的应用程序中。
此外，AWS 还为临床文档应用程序提供了医疗语音到文本的功能Amazon transcripte Medical。
亚马逊转录的好处:
- 创建易读的转录
- 过滤特定的单词
- 通过定制的转录提高准确性
用例
- 客户体验
- 通话后分析
- 临床对话文档
- 字幕和字幕工作流程
- 音频档案编目
使用亚马逊转录的公司有 echo360 、 GE 电器、 isentia 、等。
谷歌云平台(GCP)是由谷歌提供的一套云计算服务。
GC P 还为开发者和数据科学家提供了一个人工智能平台，用于构建、部署和管理机器学习模型。这项服务的独特之处在于，该平台提供了对张量处理单元的访问，这是一种谷歌设计的芯片，仅用于机器学习目的。
除此之外， GCP 拥有 MLOps 服务，可以通过部署强大的、可重复的管道来帮助管理机器学习模型、实验以及使用 MLOps 的端到端工作流。
GCP 提供以下人工智能和机器学习服务(免费试用)。
该机器学习服务为构建机器学习模型提供了以下四个套件:
该平台为开发人员、数据科学家和数据工程师提供了简化 ML 工作流程的途径。它通过标记数据来执行分类、对象检测、实体提取等任务，从而帮助 BigQuery 准备和存储数据集。
Cloud AutoML 帮助机器学习知识和专业知识有限的开发人员训练针对其业务需求的高质量模型。该工具使开发人员能够访问谷歌的研究工作，并根据自己的需要调整他们的结果。因此，几乎没有经验但具备基本知识的数据科学家或软件开发人员可以使用该服务对模型进行微调。
AutoML 提供的产品:
- Sight:AutoML vision从图像中获取洞察力， AutoML Video Intelligence (仅测试版)支持视频中强大的内容发现。
- 语言: AutoML 自然语言使我们能够构建和部署定制的机器学习模型，这些模型可以分析文档，对文档进行分类，识别文档中的实体，或者评估文档中的态度。
- 结构化数据: AutoML Tables (仅限测试版)在结构化数据上构建和部署机器学习模型。
AI building blocks 帮助将视线、语言、对话、结构化数据添加到 ML 应用中。事实上，它是一个现成模型的集合，可以用来丰富现有的 app。
有两种类型的人工智能构建模块:
- 定制模型–它通过利用最先进的转移学习和神经架构来构建特定领域的定制机器学习模型，从而帮助进行对象识别和分类。
- 预训练模型–这可以减少训练模型的麻烦，有助于 ML 模型的快速开发。
谷歌云平台提供了利用高性能云 GPU 和云 TPU 经济高效地训练深度学习模型的基础设施。这个提议是针对经验丰富的人工智能开发团队，他们可以利用那里提供的强大硬件。此外，这种产品使使用 ML 的公司能够通过使用专门的硬件进行几分钟的培训来节省成本，而不是使用数小时的商用硬件进行数小时的培训。
对话式人工智能最简单的例子是聊天机器人。聊天机器人是一种以文本或文本到语音的形式与人类交互的应用。
那么对话式人工智能提供了什么？
语音转文本是一个将语音命令转换成文本的过程。
谷歌的语音转文本提供了以下功能:
- 语音适配–它有助于定制语音识别，以转录特定领域的术语和生僻字。
- 特定领域模型–语音到文本可以使用预先训练好的机器学习模型用于特定的音频类型和来源。
- 流式语音识别–实时语音识别。
- 本地语音转文本–组织可以使用谷歌的语音识别技术保护本地语音数据，同时完全控制基础设施。
文本到语音转换可以将文本转换成听起来自然的人类语音。
谷歌的文本转语音提供了以下功能。
- wave net Voices–wave net 生成的语音听起来比其他文本到语音转换系统更自然。I t 从头开始创建原始音频波形，然后该模型利用神经网络的力量，这些神经网络已经使用大量语音样本进行了训练。
- 语音调谐–个性化选择多达 20 个半音的音高，并将语速调整为 4 倍的快慢。
- 文本和 SSML 支持–使用 SSML(语音合成标记语言)标签定制语音，允许您添加暂停、数据和时间格式以及发音说明。
- 【beta】-使用您的录音训练一个定制的语音合成模型，以创建一个独特的、听起来更自然的声音。
Dialogflow 是一个语言和视觉机器人构建平台，用于将对话用户界面设计和集成到移动应用程序、web 应用程序、交互式语音响应系统中。该工具可以分析多种类型的输入，如文本或音频信息。
Dialogflow 在其环境中有以下术语。
- 代理–它是一个虚拟代理，处理与最终用户的对话。
- 意图–意图是最终用户的对话意图。对于每个代理，可能有许多意图组成一个对话。 Dialogflow intent 通过执行一个意图分类任务将终端用户的表达与定义的代理中的最佳意义相匹配。
- 实体–每个意图参数都有一个称为实体的类型，用于提取最终用户表达式。
- 语境–对话流可以控制对话的流程。
- 跟进意图–跟进意图是其相关父意图的子意图。创建跟进意图时，会自动将输出上下文添加到父意图中，并将同名的输入上下文添加到跟进意图中。
- Dialogflow 控制台–这是一个管理 Dialogflow 代理的 web 用户界面。
Dialogflow 的使用案例:
- 聊天机器人(Chatbots)–界面可以被编程为回答问题、访问订单、预约和接受请求。
- 物联网(IoT)——它可以应用于物联网设备，使其更好地理解上下文并精确响应。
微软 Azure ML Studio 是一个面向开发者和数据科学家的 web 界面，为更快地构建、训练和部署机器学习模型提供了广泛的服务。尽管公司是离线起步的，微软还是尽力跟上最大的网络玩家。
Azure 提供了一个无代码 UI ，在拖放界面的帮助下，加速了机器学习模型的开发和部署。
它具有内置模块，可帮助预处理数据，以使用机器学习和深度学习算法(如计算机视觉、文本分析、推荐系统、异常检测)来构建和训练 ML/DL 模型。
Azure 还提供了 自动化机器学习 ，通过更智能的原型化和开发自动化迭代任务，快速构建高度精确的模型。
自动化机器学习 处理特征工程、算法选择、超参数调整使开发人员和数据科学家能够进行 ML/DL 模型的快速原型开发。
Azure 现在支持管理端到端的机器学习生命周期。它帮助数据科学家和开发人员跟踪数据集、代码、实验和环境。
如果一个组织为政府、金融和医疗保健等受监管行业工作，私有知识产权是必要的。
Workspace Private Link 是一种网络隔离功能，支持 Azure 机器学习通过其虚拟网络(VNet)中的私有 IP 进行访问。
Azure 机器学习工作室支持 sci-kit learn、TensorFlow、Keras、MxNet、PyTorch 等所有主流框架。
Azure 机器学习工作室的主要特点:
- 协作笔记本
- 自动化机器学习
- 拖放模型开发和管理
- 数据标记
- MLOps
使用微软 Azure ML studio 的公司有 EY 、 talentcloud 、 translink 。
IBM Watson 机器学习提供了广泛的工具和服务，因此任何人都可以构建、训练和部署机器学习模型。
在图形工具的帮助下，我们可以在几分钟内建立一个模型，使用 TensorFlow、Caffe、PyTorch 和 Keras 等流行框架自动优化超参数。
IBM Watson 因在 ML 营销方面的开拓而闻名。这台机器参加了一场危险的电视游戏，以 IBM 设计的“深蓝”几年前在一场国际象棋比赛中与加里·卡斯帕罗夫打赌的方式击败冠军。
视频
沃森工作室 AI 套件有三个工具包。
这个类别是专门针对视觉识别的。它有内置的模型来分析场景，物体和许多其他类别的图像。
图形视觉识别建模器不需要熟练的技术来自动训练一个模型来为场景、对象或定制内容分类图像。
这个类别是专门针对自然语言的分类。支持多种语言，如英语、阿拉伯语、法语、德语、意大利语、日语、韩语、葡萄牙语(巴西)和西班牙语。它可以被很少或没有技术技能的人使用，就像上面的工具一样。
沃森机器学习使我们能够建立、训练和部署分析模型和神经网络。
IBM Watson Studio 工具
- AutoAI 实验–AutoAI 自动对数据进行预处理，选择最佳的估计量，然后生成模型候选管道进行审核和比较。
- SPSS Modeler–它在开发模型时呈现模型的图形视图。
- 笔记本——它提供了一个处理数据、测试模型和快速成型的交互式编程环境。
BigML 提供了一个全面的机器学习平台，提供了广泛的算法来开发和管理机器学习模型。
该工具有助于航空航天、汽车、能源、娱乐、金融服务、食品、医疗保健、物联网等行业的预测应用。
BigML 提供以下服务模式:
- Web 界面:响应迅速的 Web 界面，有助于上传数据和开发预测模型。
- 命令行界面:命令行工具被称为基于 python API 的 bigmler ，提供比 web 界面更大的灵活性，例如本地或远程开发模型，以及执行交叉验证任务。
- API:REST API 可以作为包装器包含在任何编程语言中，比如 Python、Ruby、PHP、C#、Java、Bash、Clojure 和 Objective C。
BigML 的产品包括:
WhizzML 是一种特定于领域的语言，用于自动化机器学习工作流，实现高级机器学习算法，并轻松地与他人共享。
WhizzML 提供了创建和共享机器学习脚本和库的基础设施。
它是一个机器学习 REST API，可以轻松地构建、运行预测模型，并将其应用到现实世界的项目中。通过 BigML.io，任何人都可以执行基本的监督和非监督机器学习任务。
BigMLer 是 BigML 的 API 的命令行工具。它包装了 BigML 的 API Python 绑定，以提供高级命令行脚本来轻松创建和发布数据集和模型，开发集成，从多个模型和集群进行本地预测，并简化许多其他机器学习任务。
BigML PredictServer 将模型保存在内存中，并经过优化以快速做出预测。它具有高度的可扩展性，可以将 BIgML PredictServer 与现有的应用程序和数据中心集成在一起。
Flatline 是一种 lisp 语言，用于指定从输入数据集中提取或生成的值，使用输入行的有限滑动窗口。
它使我们能够以编程方式执行一系列数据转换，包括过滤和新字段生成。
Flatliner 是一个方便的代码编辑器，帮助测试flat liner表达式。
最后的想法
上面列出的工具只能被认为是冰山一角。有几十种甚至几百种工具以多种方式支持 ML 开发。有一些工具旨在处理自动化，支持版本控制或为机器学习开发提供端到端的环境。
关键是找到目前能提供最佳结果的工具——每个数据科学家或工程师都有自己的工作方式，并发现流程中的一些元素比其他元素更容易磨损。因此，如果你讨厌你出色工作流程的某个方面——有一款应用可以满足你！
你需要知道的最好的机器学习模型管理工具
原文：https://web.archive.org/web/https://neptune.ai/blog/best-machine-learning-model-management-tools
与构建软件相比，使用机器学习模型需要一套不同的组织能力。这些新的功能集是由 MLOps 驱动的——它被进一步划分为不同的 ML 模型过程，其中之一就是模型管理。
机器学习模型管理是一类技术和流程，它们协同工作，使公司能够可靠、安全地高速开发、验证、交付和监控模型，主要是为了创造竞争优势。它几乎涵盖了管理模型的整个范围，从开发到再培训和监控。因此，模型管理可以分为几个阶段:
- 最佳化
- 版本控制和跟踪
- 评估和测试
- 包装
- 部署和服务
- 监视
Model management within the MLOps workflow | Source
为了管理这些不同的功能集，我们需要根据特定的需求和用例准备好同样胜任的工具。考虑到这一领域中可用的工具数不胜数，每种工具都满足不同的需求，我们将它们分为 6 个类别，以便您知道有哪些选项。现在，让我们来看看一些策划得最好的。
ML 模型优化
超参数优化是模型管理的关键步骤。为了从模型中获得最佳性能，您必须调整超参数以从数据中获得最大收益。有几种工具可以帮助你实现这个目标。让我们探索几个选项，这些选项符合大多数情况:
Optuna 是一个自动超参数优化框架，专门为机器学习而设计。它具有一个命令式的、由运行定义的用户 API，因此它是高度模块化的，并且编码功能也可以用于其他领域。
Optuna 功能:
- 轻量级、通用且平台无关的架构:通过简单的安装处理各种各样的任务，几乎没有任何要求。
- Python 搜索空间:使用熟悉的 Python 语法定义搜索空间，包括条件和循环。
- 高效优化算法:采用最先进的算法对超参数进行采样，并高效修剪无希望的试验。
- 简单的并行化:将研究扩展到数十或数百名工作人员，对代码几乎不做任何更改。
- 快速可视化:检查各种绘图功能的优化历史。
SigOpt 是一个模型开发平台，它可以轻松跟踪运行、可视化训练和扩展超参数优化，适用于在任何基础设施上使用任何库构建的任何类型的模型。
SigOpt 通过贝叶斯和全局优化算法的结合来优化模型(甚至广告和产品)，这使得用户和公司可以提高他们模型的性能，同时降低成本，节省以前可能花费在更乏味的传统调整方法上的时间。
SigOpt 特性:
- 健壮的跟踪: SigOpt 跟踪并组织您的训练和调优周期，包括架构、度量、参数、超参数、代码快照以及特性分析、训练运行或调优作业的结果。
- 自动化训练&调整:它将自动化超参数调整与训练跑步跟踪完全集成，使这一过程变得简单易行。自动提前停止、高度可定制的搜索空间以及多测量和多任务优化等功能使您可以轻松调整正在构建的任何模型。
- 轻松集成:Sigopt 提供了与所有知名框架的轻松集成，如 H2O、Tensorflow、PyTorch、scikit 等。
版本控制和跟踪 ML 模型
在无数的实验中，我们如何跟踪数据、源代码和 ML 模型的变化？版本控制工具提供了一个解决方案，对于工作流来说是至关重要的，因为它们迎合了再现性。它们帮助您获得一个人工制品、数据集散列或模型的过去版本，可以出于性能原因或为了比较而用于回滚。
您通常会将这些数据和模型版本记录到您的元数据管理解决方案中，以确保您的模型训练是版本化的和可重复的。然后必须跟踪版本化模型，以便比较来自其他版本化实验的结果。
在一个理想的 ML 工作流中，您会想知道您的模型的元数据是如何构建的，哪些想法被测试过，或者在哪里可以找到所有打包的模型。为了实现这一点，您需要跟踪所有的模型构建元数据，如超参数、度量、代码和数据版本、评估结果、打包的模型以及其他信息。
这里有几个值得一试的工具。
Neptune 是一个 ML 元数据存储库，用于实验跟踪和模型注册。您可以记录和显示几乎任何 ML 元数据，从源代码和工件到度量、超参数、模型检查点和系统度量。在 Neptune 中跟踪所有的东西，您就可以顺流而下:从模型，通过运行，到它被训练的数据集，只要有必要。
web UI 是为管理 ML 模型实验和模型而构建的，它允许您:
除了日志记录，还可以从 Neptune查询元数据。
如果你想知道它是否适合你的工作流程，看看关于人们如何用 Neptune 建立他们的 MLOps 工具栈的案例研究。
海王星—摘要:
- 灵活的类似文件夹的元数据结构
- 高度可定制的 UI，用于搜索、显示、比较和组织 ML 元数据
- 易于使用的 API，用于记录和查询模型元数据，以及与 MLOps 工具的 25 多种集成
- 托管版本和内部版本均可用
- 协作功能和组织/项目/用户管理
数据版本控制(DVC)本质上是 ML 项目的一个实验管理工具。DVC 软件是基于 Git 构建的，这意味着它允许您在 Git 提交中捕获数据和模型的版本，同时将它们存储在本地或云存储中。它的主要目标是通过命令行编码数据、模型和管道。
DVC 的几个主要特征:
- 轻量级: DVC 是一个免费的开源命令行工具，不需要数据库、服务器或任何其他特殊服务。
- 一致性:用稳定的文件名保持你的项目可读性——它们不需要改变，因为它们代表可变数据。不需要复杂的路径或在源代码中不断地编辑它们。
- 高效的数据管理:DVC 以一种组织良好且易于访问的方式存储大量数据。这极大地有助于数据版本化。
- 协作:轻松分发您的项目开发，并在内部和远程共享其数据，或者在其他地方重用它。
- 数据合规性:将数据修改尝试视为 Git 拉取请求。审核项目不变的历史，以了解数据集或模型何时被批准以及为什么被批准。
- GitOps:将您的数据科学项目与 Git 生态系统联系起来。Git 工作流打开了通向高级 CI/CD 工具(如 CML)、数据注册中心等专用模式以及其他最佳实践的大门。
- 额外收获:DVC 还提供了一些实验跟踪功能。它可以跟踪这些实验，列出并比较它们最相关的度量、参数和依赖性，在它们之间导航，并只提交 Git 需要的那些。
Pachyderm 为 MLOps 提供了数据版本和管道。它们提供了一个数据基础，允许数据科学团队自动化和扩展他们的机器学习生命周期，同时保证可重复性。它提供商业企业版和开源社区版。如果需要，Pachyderm 也可以集成到您现有的基础架构或私有云。
Pachyderm 的主要目标是:
- 经济高效的可扩展性:通过优化资源利用率和运行复杂的数据管道，使用自动扩展和并行技术进行智能数据转换，从而提供可靠的结果。
- 可再现性:通过不可变的数据沿袭和数据版本化来确保任何类型数据的可再现性和合规性。类似 Git 的提交将提高团队效率。
- 灵活性: Pachyderm 可以利用现有的基础设施，并且可以在您现有的云或内部基础设施上运行。
使用企业版，您可以在上述功能的基础上获得一些额外的功能:
- 认证: Pachyderm 允许对任何 OIDC 提供者进行认证。用户可以通过登录他们最喜欢的身份提供商向 Pachyderm 认证。
- 基于角色的访问控制(RBAC): 企业规模的部署需要访问控制。Pachyderm 企业版使团队能够控制对生产管道和数据的访问。管理员可以通过控制用户对 Pachyderm 资源的访问来存储数据，防止对生产管道的意外修改，并支持多个数据科学家甚至多个数据科学小组。
- 企业服务器:一个组织可以有多个 Pachyderm 集群注册到一个企业服务器，该服务器管理企业许可以及与公司身份提供商的集成。
- 此外，您还可以使用 pachctl 命令暂停(pachctl enterprise pause)和取消暂停(pachctl enterprise unpause)集群以进行备份和恢复。
MLflow 是一个简化机器学习开发的平台，包括跟踪实验，将代码打包成可复制的运行，以及共享和部署模型。MLflow 提供了一组轻量级 API，可以与任何现有的机器学习应用程序或库(TensorFlow、PyTorch、XGBoost 等)一起使用。)，无论您当前在何处运行 ML 代码(例如，在笔记本、独立应用程序或云中)。
MLflow 既有开源版本，也有托管版本(由 Databricks 提供)。您可以在此处查看两个版本的详细对比，以便做出明智的决定。
该工具与库无关。你可以在任何机器学习库或任何编程语言中使用它。MLflow 包含四个有助于跟踪和组织实验的主要功能:
- ml flow Tracking–使用 Python、REST、R API 和 Java API 自动记录每次运行的参数、代码版本、指标和工件
- MLflow 项目–代表打包可重用数据科学代码的标准格式。
- ml flow Models——一种包装机器学习模型的标准格式，可用于各种下游工具——例如，通过 REST API 或 Apache Spark 上的批处理推理进行实时服务。
- MLflow Model Registry–提供集中的模型存储、一组 API 和 UI，以协作方式管理 ml flow 模型的整个生命周期。
ML 模型评估和测试
评估是 ML 工作流程中的一个重要阶段。ML 中的评估通常从定义度量标准开始，比如准确性和混淆矩阵，这取决于您的数据和用例。这种级别的模型评估对于真实世界的应用变得更加复杂，以考虑任何数据/概念漂移。
虽然大多数团队在部署模型之前都习惯于使用模型评估度量来量化模型的性能，但是这些度量通常不足以确保您的模型在现实场景中准备好投入生产。需要对你的模型进行彻底的测试，以确保它们在现实世界中足够健壮。
现在，问题是在工具的海洋中寻找什么。以下是在现实世界中测试模型时需要用到的一些技巧:
- 单元测试:关注特定场景或子类，例如“光线较暗时来自后方的汽车”。
- 回归测试:通过一次特定的推送(压扁的 bug)或“长尾”的一段获得的改进。
- 集成测试:从组成、分发、预处理等方面镜像部署条件。
让我们看一些提供这种 ML 模型测试能力的工具:
Kolena 是一个机器学习测试和调试平台，用于揭示隐藏的模型行为，并揭开模型开发的神秘面纱。Kolena 帮助您:
- 执行高分辨率模型评估
- 了解并跟踪行为的改善和退步
- 有意义地交流模型功能
他们提供单元测试、回归测试和集成测试作为软件包的一部分。您可以为您的用例创建自定义工作流，但是，有一些模板可用，如图像分割、对象检测等。
Kolena 特色:
- 提供大量测试功能:
- 单元/回归/集成测试
- 将多个测试组合成一个测试套件的选项
- 可以通过 pip 包-ko Lena-client 访问。
- Web 仪表板可用于快速可视化结果。
点击查看他们的文档了解更多信息。
Deepchecks 是测试和验证机器学习模型和数据的领先工具，它能够以最小的努力做到这一点。它满足各种验证和测试需求，例如验证数据的完整性、检查数据的分布、验证数据分割、评估模型以及比较不同的模型。
它们为 ML 工作流程的不同阶段提供测试:
- 数据完整性
- 培训测试验证(分布和方法检查)
- 模型性能评估
Deepchecks 是一款开源工具，提供:
包装 ML 模型
生产 ML 模型合乎逻辑的下一步是捆绑/打包它，这样它的行为就像一个应用程序。你的模型在 juypter 实验室环境中无法为用户服务；通过将它和它的依赖项打包，您就迈出了向真实世界展示您的模型的第一步。
基本上有两种方法可以打包您的 ML 模型:
- 基于 Web 的框架:包括像 Flask 和 FastAPI 这样的微框架。
- 集装箱化:包括码头工、集装箱工、搬运工等。
让我们来看看一些打包工具:
Flask 是一个 web 框架，本质上是一个 Python 模块，可以让您轻松开发 web 应用程序。它有一个小而易于扩展的核心:它是一个微框架，不包括 ORM(对象关系管理器)或类似的特性。Flask 依赖于 Werkzeug WSGI 工具箱和 Jinja2 模板。最终目的是帮助开发一个强大的 web 应用程序基础。
烧瓶主要特征:
- 它有一个内置的开发服务器和快速调试器。它有一个 RESTful 用于 HTTP 的请求分派和请求处理
- 它有内在的单元测试支持。
- 社区提供的多个扩展简化了新功能的集成。
FastAPI 是一个基于 web 的现代框架，使用 Python 3.6+版基于标准 Python 类型构建 API，提供了高性能。它是一个 ASGI 框架，这使得它高度并发。
快速 API 主要特性:
- 提供良好的性能，接近 NodeJS 和 Go，因为它使用 Starlette 和 Pydantic。目前最快的 Python 框架之一。
- 是一个健壮的框架，具有惊人的交互式文档。
- 完全兼容 API、OpenAPI 和 JSON 模式的开放标准。
- 直观——强大的编辑器支持，无处不在的自动完成，更少的调试时间。
Docker 是一个具有企业级的开源容器化平台。它使开发人员能够将应用程序打包到容器中，容器是标准化的可执行组件，将应用程序源代码与在任何环境中运行该代码所需的操作系统(OS)库和依赖项结合在一起。
Docker 的主要功能–
- Docker 映像可以使用 AWS ECS、Google Kubernetes 引擎等部署在云上。
- Docker 带有 CLI 以及用于 Windows、Mac 和 Linux 的应用程序。
- 开发集成在所有流行的代码编辑器中都可用，如 VS Code、Jetbrains 等。
- 所有主要的云服务提供商也提供软件集成。
ML 模型部署和服务
在打包您的模型之后，紧接着的下一步是确定部署和服务中的需求。生产机器学习模型在操作化方面提出了自己的挑战。
您遇到的第一批问题是如何打包、部署、服务和扩展基础架构以支持生产中的模型。模型部署和服务工具对此有所帮助。
这里有一些模型部署和服务工具。
- AWS！AWS
- 大脑皮层
- 欢迎使用 ML
亚马逊网络服务是领先的云服务提供商，市场份额为 33%。它提供 200 多种功能齐全的服务，从数据中心和基础设施技术(如全球各地的计算、存储和数据库)到新兴技术(如机器学习和人工智能、数据湖和分析以及物联网)。这使得将您现有的应用程序迁移到云中变得更快、更容易、更具成本效益，并构建几乎任何您可以想象的东西。
AWS 功能–
- 这是一个提供大量基础设施技术的大型技术平台。
- 作为该领域的领导者，它还提供高效的服务来满足您的 ML 模型需求。
- AWS 弹性容器注册与 docker 容器兼容，并与 AWS ECS 或 Fargate 等其他服务无缝集成，以将容器投入生产。
- AWS Lambda 允许您无服务器部署 web 服务，因此您不必担心流量的增加/减少，因为它会自动处理流量，从而节省成本和精力。
- AWS Sagemaker 提供了一套面向 ML 开发、部署和服务的服务。
Cortex 是一个开源平台，旨在将经过训练的机器学习模型直接部署为生产中的 web 服务。它建立在 Kubernetes 之上，支持大规模的机器学习工作负载。
皮质特征:
- 多框架: Cortex 支持多种框架，包括 TensorFlow、PyTorch、scikit-learn、XGBoost 等等。
- 自动伸缩:API 的自动负载平衡，以处理生产工作负载。
- 基础设施: Cortex 可以在 CPU 或 GPU 基础设施上运行推理。
- 滚动更新: Cortex 在部署后更新 API，没有任何停机时间。
BentoML 是机器学习模型服务的端到端解决方案。它有助于数据科学团队开发服务于终端的生产就绪型模型，并在每个阶段提供最佳 MLOps 实践和性能优化。
它提供了一个灵活的、高性能的框架来服务、管理和部署生产中的 ML 模型。它通过其标准且简单的架构简化了构建生产就绪模型 API 端点的过程。它为团队提供了一个强大的仪表板，帮助他们集中组织模型和监控部署。
BentoML 特点:
- 对流行 ML 框架的原生支持: Tensorflow、PyTorch、XGBoost、Scikit-Learn 等等！
- 定制管道:用预处理、后处理和集合模型定义定制服务管道。
- 易于版本控制和部署:标准。用于打包代码、模型和依赖项的 bento 格式，便于版本控制和部署。
- 最先进的模型服务: BentoML 通过 REST API 或 gRPC 提供在线服务，通过 Apache Spark 或 Dask 提供批量数据集的离线评分，通过 Kafka、Beam 和 Flink 提供流服务。
ML 模型监控
监控是模型管理的另一个组成部分。关于为什么监控你的 ML 模型如此必要，有几个概念。举几个例子:
- 检查您的模型在现实世界数据中的实际表现。它是否产生了疯狂和意想不到的结果？
- 以检查可能的模型漂移。
- 它能够解决最初为其开发的业务问题吗？
模型监控工具可以通过以下方式让您了解生产中正在发生的事情:
- 监控输入数据漂移:与训练数据相比，您的模型是否获得了不同的输入？
- 监控概念漂移:问题是否不再与最初相似，你的模型性能是否在衰减？
- 监测模型漂移:模型的预测能力是否因环境变化而下降？
- 监控硬件指标:新型号是否比旧型号更需要资源？
这里有你可以选择的。
AWS Sagemaker 是 AWS 平台的一部分。数据科学家和开发人员可以准备、构建、训练和部署高质量的机器学习(ML)模型。它声称是 ML 的第一个集成开发环境(IDE)。它有四个组成部分:准备、构建、培训和调优、部署和管理。用户可以记录、组织和比较实验，自动调整超参数，并调试训练运行。
Amazon SageMaker 提供了许多功能，其中包括:
- 分布式训练: Sagemaker 通过将数据分割到多个 GPU 上，使其用户更快地执行分布式训练，从而实现近乎线性的扩展效率。
- 剖析和调试训练运行: SageMaker 调试器实时捕获指标和剖析训练作业，使用户能够在模型部署到生产之前快速纠正性能问题。
- 支持强化学习:它内置了完全管理的强化学习算法，包括学术文献中最新、性能最好的算法。
- 针对主流框架优化: SageMaker 针对 TensorFlow、Apache MXNet、PyTorch 等众多流行的深度学习框架进行了优化。支持的框架总是保持最新版本，并针对 AWS 上的性能进行了进一步优化。
- 支持 AutoML: SageMaker autopilot 根据用户的数据自动构建、训练和调整最佳的机器学习模型，同时允许他们保持完全的控制和可见性。只需一次点击就可以将模型部署到生产环境中，或者对模型进行迭代以进一步提高模型质量。
Fiddler 是一个模型性能管理平台，它提供了模型监控、可观察性、可解释性和公平性。它让您可以构建一个集中式平台，通过简单的插件集成来监控和分析人工智能模型，并帮助企业了解他们的人工智能背后的“为什么”和“如何”。该平台监控人工智能模型的数据漂移、数据完整性问题、异常值和性能下降。
Fiddler ML 的主要特性:
- 性能监控:它为机器学习问题提供现成的性能和评估指标，包括但不限于二元分类、多类分类、回归和排序模型。
- 数据漂移:使用 Fiddler，您可以轻松地监控数据漂移，发现数据完整性问题，并比较基线和生产数据集之间的数据分布，以提高模型性能。
- NLP 和 CV 监控: Fiddler 提供复杂和非结构化数据的监控，比如自然语言处理和计算机视觉。
- 警报:它提供实时警报，以最大限度地减少由性能、数据漂移、数据完整性和服务指标(如流量、延迟和错误)引起的问题。
Arize 是机器学习可观察性平台，用于 ML 从业者监控、故障排除和解释模型。它记录了跨培训、验证和生产环境的模型推理。
Arize AI 有以下特点:
- ML 性能跟踪: Arize AI 提供 ML 性能跟踪，并专门构建工作流来高效地跟踪和追踪模型。
- 非结构化数据监控:支持 NLP 和计算机视觉的非结构化数据监控。
- 了解漂移影响:真实世界的数据是动态的，会随着时间的推移影响模型响应。使用 Arize，您可以跟踪上游数据、预测和实际数据的分布变化，以主动评估模型性能并寻找再培训机会。
- 自动化模型监控: Arize 提供了监控 ML 模型各个方面的能力，这对于捕捉关键指标的性能退化至关重要。
- 轻松集成&部署: Arize 旨在无缝插入您现有的 ML 堆栈和警报工作流。该平台可以在任何环境中与任何平台的任何模型框架一起工作。
WhyLabs 是一个人工智能可观察性平台，旨在通过允许您在生产中监控数据管道和机器学习模型来防止数据质量或模型性能下降。
它建立在一个名为 whylogs 的开源包之上，可以监控数据管道和 ML 应用程序的数据质量退化、数据漂移和模型性能退化。
WhyLabs 工具的主要特点:
- 轻松集成:Whylabs 提供了一个名为 whylogs 的开源模块，让您可以轻松地将代码与 WhyLabs SaaS 平台集成。
- 数据健康/数据操作:该工具自动捕捉数据质量问题。它可以在对用户体验产生任何影响之前识别和监控数据漂移和数据偏差。
- Model health / ModelOps: 您可以跟踪模型输出和模型性能，调试模型，并通过智能关联和可视化识别异常。Whylabs 还对概念漂移和模型精度下降发出警告。
- 保护隐私: WhyLabs profiles 对输入和输出进行建模，仅捕获底层数据的统计数据。原始数据不会离开客户的 VPC/边界。WhyLabs 的所有产品功能都基于统计数据。
- 零维护: Whylabs 提供了最少甚至没有维护的结构，没有模式维护，没有监控配置，没有数据采样开销，也没有部署困难。
- 与您现有的管道和工具无缝集成: Whylabs 支持所有主流框架，如 Tensorflow、PyTorch、scikit、Apache Spark、Azure、SageMaker 等。
要更深入地了解监控框架，请阅读我们的模型监控工具比较。
如果您正在为您的模型管理需求寻找一个全面的竞争者，那么有些选择可以作为“一站式商店”。让我们来看一些这样的工具，它们为完整的生命周期提供服务。
如上所述，亚马逊 SageMaker 是一个完全托管的机器学习服务。使用 SageMaker，您可以:
- 快速轻松地构建和训练机器学习模型，以及
- 然后将它们直接部署到生产就绪的托管环境中。
Sagemaker 提供:
- 一个集成的 Jupyter 创作笔记本实例，便于访问您的数据源进行探索和分析，因此您不必管理服务器。
- 它还提供了常见的机器学习算法，这些算法经过优化，可以针对分布式环境中的海量数据高效运行。有了对自带算法和框架的本地支持，
- SageMaker 提供灵活的分布式培训选项，可根据您的具体工作流程进行调整。通过在 SageMaker Studio 或 SageMaker 控制台上点击几下，将模型部署到一个安全且可伸缩的环境中。培训和托管按使用分钟计费，没有最低费用，也没有前期承诺。
Sagemaker 有一个很长的特性列表，涵盖了开发、打包、部署和监控。一些服务包括 Sagemaker Studio、Sagemaker 模型注册、Sagemaker 特性存储、Sagemaker 实验和 Sagemaker 预处理。你可以在这里看完整的功能列表。
Azure Machine Learning 是用于管理机器学习项目生命周期的云服务。这是一个用于培训、部署模型和管理 MLOps 的全方位工具。你可以在 Azure Machine Learning 中创建模型，也可以使用从开源平台构建的模型，比如 Pytorch、TensorFlow 或 scikit-learn。
Azure ML 提供:
- 协作，如共享笔记本电脑、计算资源、数据和环境，跟踪和显示谁在何时进行了更改的可审核性，以及资产版本控制。
- Azure Machine Learning studio 是项目工作区的图形用户界面，允许您:
- 查看运行、指标、日志、输出等。
- 创作和编辑笔记本和文件。
- 管理公共资产，如数据凭据、计算和环境。
- 可视化运行指标、结果和报告。
- 可视化通过开发人员界面创作的管道。
- 创作 AutoML 作业。
- 广泛支持 ML 框架，如 PyTorch、Tensorflow、scikit-learn、XGBoost、LightGBM 等。
- 支持 MLOPs 的集成:
- Git 集成
- MLflow 集成
- 机器学习流水线调度
- 针对自定义触发器的 Azure 事件网格集成
- 易于与 GitHub Actions 或 Azure DevOps 等 CI/CD 工具一起使用
注:Azure ML studio 将于 2024 年集成到 Azure 机器学习中。
Vertex AI 是一个托管的机器学习平台，它可以在一个地方为您提供谷歌的所有云服务，以部署和维护 ML 模型。它将用于构建 ML 的 Google 云服务集合在一个统一的 UI 和 API 下。
在 Vertex AI 中，您现在可以使用 AutoML 或自定义代码训练来轻松训练和比较模型，并且您的所有模型都存储在一个中央模型库中。这些模型现在可以部署到 Vertex AI 上的相同端点。
Vertex AI 提供:
- 训练和超参数调整: Vertex AI 训练提供完全管理的训练服务，Vertex AI Vizier 提供优化的超参数，以实现最大的预测准确性。
- 模型服务:顶点人工智能预测可以轻松地将模型部署到生产中，通过 HTTP 在线服务或批量预测进行批量评分。
- 模型调优与理解:顶点可解释 AI 告诉你每个输入特征对你的预测有多重要。
- 模型监控:持续监控为部署在 Vertex AI 预测服务中的模型提供了随时间推移对模型性能的简单而主动的监控。
- 模型管理: Vertex ML 元数据通过自动跟踪顶点管道中所有组件的输入和输出，为您的 ML 工作流进行人工制品、沿袭和执行跟踪，从而实现更轻松的可审计性和治理。
这个列表当然不是详尽的，Vertex AI 提供了许多其他的 MLOps 功能来满足你的需求。你可以在这里阅读更多关于功能的完整列表。
你已经到达终点了！
我们看到了模型管理对于构建能够被更多受众消费的模型是多么的必要。我们还讨论了可以支持模型开发并简化整个过程的工具。
您现在知道了在工具库中应该寻找什么，以及从哪里开始。您需要做的是列出您的问题陈述，并选择最适合您的用例的工具。
暂时就这样了。敬请关注更多内容！再见！
参考
- https://neptune.ai/blog/best-mlops-tools
- https://neptune.ai/blog/best-ml-experiment-tracking-tools
- https://www . dominodatalab . com/resources/field-guide/machine-learning-model-management
- https://neptune.ai/blog/machine-learning-model-management
- https://docs.kolena.io/core-concepts/test-cases
- https://docs . deep checks . com/stable/getting-started/welcome . html
- https://docs.arize.com/arize/
- https://www.ibm.com/in-en/cloud/learn/docker
- https://neptune.ai/blog/packaging-ml-models
- https://neptune.ai/blog/ml-model-serving-best-tools
- https://mlops-guide.github.io/Versionamento/
- https://censius.ai/mlops-tools/bentoml
- https://DVC . org/doc/用例/版本化数据和模型文件
- https://www.pachyderm.com/products/
- https://docs.pachyderm.com/latest/enterprise/overview/
- https://arize.com/
- https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html
- https://cloud.google.com/vertex-ai#section-1
- https://docs . Microsoft . com/en-us/azure/machine-learning/overview-what-is-azure-machine-learning
最佳 ML 元数据存储解决方案
原文：https://web.archive.org/web/https://neptune.ai/blog/best-metadata-store-solutions
如果您已经找到了这篇文章，那么您可能已经熟悉了 ML 元数据存储的概念，并且正在寻找最佳解决方案的建议。
对于那些不太熟悉这个概念的人来说，ML 元数据存储是一个存储从端到端机器学习(ML)管道生成的元数据的地方，供将来参考，这对机器学习操作(MLOps) 尤为重要。
ML 中的元数据可以从管道的任何阶段生成，包括诸如模型参数、度量、模型配置和数据版本之类的细节。这些细节对于实验比较、快速回滚、减少模型停机时间、再培训和许多更重要的功能都是必不可少的。
要更详细地了解机器学习元数据存储及其重要性，请随意在这里深入研究:“ ML 元数据存储:它是什么，它为什么重要，以及如何实现它”。
本文将重点介绍目前 ML 市场上的一些顶级 ML 元数据存储解决方案,还将为如何选择最适合您团队的解决方案提供一些指导。
在进入选择正确解决方案的细节之前，第一步是评估你是否真的需要一个。
如果你有一个正在成长的团队，计划扩展和改进现有的解决方案，或者想在他们的产品线中增加更多的 ML 解决方案，那么元数据存储是一个获得速度、自动化和智能洞察力的正确途径。
在为您的团队选择正确的机器学习元数据管理工具时，您可以参考下面的清单来找到正确的匹配:
- 跟踪能力—元数据存储应该具有广泛的跟踪特性，不仅包括模型跟踪，还包括更精细的跟踪能力，例如数据版本控制、跟踪数据和模型血统、源代码版本控制，甚至是测试和生产环境的版本控制。
- 集成–一个理想的元数据存储应该能够与您的机器学习生态系统中的大多数工具无缝集成，以便能够捕获从管道的每个阶段生成的活力。
- UI/UX–使用元数据存储平台的最大优势之一是一个易于使用的界面，只需点击几下鼠标就能交付结果，而无需手动跟踪、脚本编写和后台编码等额外工作。
- 协作能力–每个机器学习解决方案都是由多个团队构思、开发和维护的。例如，开发团队，操作团队，甚至商业团队一起创建一个成功的 ML 解决方案。
- 智能分析–虽然元数据存储记录了不同阶段的数据，但它也将这些数据放在一起，以提供智能见解，从而促进实验并增强报告。理想的元数据存储平台应该能够提供交互式视觉效果，开发人员可以对其进行定制，以表示管道数据中的特定焦点区域。
- 简单报告–机器学习解决方案由工程团队开发，但业务和产品团队的参与比例很高。因此，开发人员必须定期以通俗易懂的语言向不太懂代码的涉众展示进展或度量。
既然我们已经介绍了如何选择最佳的元数据存储解决方案，那么让我们来看看目前市场上一些具有有利特性的最佳选择。
Example of experiment tracking dashboard with various metadata in one place | Source
Neptune 是 MLOps 的一个元数据存储库，为运行大量实验的研究和生产团队而构建。
个人和组织使用 Neptune 进行实验跟踪和模型注册，以控制他们的实验和模型开发。
Neptune 为他们提供了一个中心位置来记录、存储、显示、组织、比较和查询机器学习生命周期中生成的所有元数据。
它非常灵活，可以在多个 DS 和 ML 字段中使用，因为它允许您记录和显示各种元数据。从度量、损失或参数等常见数据，到图像、视频或音频等丰富格式的数据，再到代码、模型检查点、数据版本和硬件信息。
它还与多个 ML 框架和工具集成，因此很容易将其插入任何 MLOps 管道。
Neptune 是这个列表中唯一一个非开源的工具——它是一个托管的解决方案(也可以在内部部署)。它的定价结构是基于使用的，这似乎是最适合任何 ML 团队的选择。
如果你想了解更多关于 Neptune 的信息，可以查看文档或者探索一个示例项目(不需要注册)。
MLMD: a high-level overview of the its components | Source
由 TensorFlow 开发的 ML 元数据(MLMD)是 TensorFlow Extended (TFX)的一部分，TensorFlow Extended()是一个端到端的平台，支持机器学习解决方案的部署。然而，MLMD 是这样设计的，它可以独立运行。
MLMD 分析管道的相互连接的部分，而不是孤立地分析每个部分。这为每个部分带来了重要的背景。 MLMD 从生成的工件、组件的执行和总体沿袭信息中收集元数据。存储后端是可插拔和可扩展的，API 可以用来最轻松地访问它。
使用 MLMD 的一些好处包括列出所有常见类型的工件，比较不同的工件，跟踪相关执行的 Dag 以及输入和输出，递归所有事件以了解不同工件是如何创建的，记录和查询上下文或工作流运行，以及过滤声明性节点。
注:对 ML 元数据和 MLflow 的区别感兴趣？阅读本讨论。
顶点 ML 元数据是由谷歌建立在 MLMD 概念之上的。它通过一个可导航的图来表示元数据，其中执行和工件是节点，而事件则相应地成为链接节点的边。执行和工件通过用子图表示的上下文进一步连接。
用户可以将键值对元数据应用于执行、工件和上下文。借助 Vertex ML 元数据，用户可以利用各种细节，例如识别用于训练模型的确切数据集、已应用于特定数据集的模型、最成功的运行以及可再现的数据、部署目标和时间、基于时间预测的模型版本等等。
MLflow runs dashboard | Source
MLflow 是一个开源平台，负责端到端的机器学习生命周期，包括实验、再现性、部署和模型注册等阶段。它可以与任何 ML 库或语言一起工作，可以针对多个用户进行显著扩展，还可以通过 Apache Spark 扩展到大数据。
MLflow 有四个主要组件:
- MLflow 跟踪，
- MLflow 项目，
- MLflow 模型，
- 和 MLflow 模型注册表。
跟踪组件记录和查询实验数据，例如代码、配置文件、数据和度量。项目通过以给定的格式打包 ML 解决方案，使得 ML 解决方案与平台无关。模型组件允许 ML 解决方案跨任何服务环境兼容。最后一个组件 model registry 用于存储、注释和管理中央存储库中的模型。
最后一个音符
元数据是任何端到端机器学习开发过程的支柱，因为它不仅加快了过程，还提高了最终管道的质量。虽然上述元数据存储解决方案是很好的无所不包的解决方案，但是 ML 框架的理想元数据存储将取决于管道的内部结构和分析。
Vertex ML 元数据和 MLMD 的构建类似，只是在 API 上有细微的差别。Vertex 的 API 具有额外的优势，能够托管来自 TensorBoard 的训练工件。此外，MLMD 要求用户用代码注册模型工件和管道。这对于用户来说可能是繁重的，因为它增加了额外的和广泛的步骤，这可能导致手动错误。在 MLflow 和 MLMD 之间，两者都有不同的解决方法。MLflow 用模型优先的观点来处理这个问题，而 MLMD 给予管道观点更高的优先权。
虽然上述所有解决方案都是开源的并且非常灵活，但是 Neptune 的元数据存储是一个可定制的解决方案，可以很好地适应用户现有的 ML 库以及一致的解决方案支持。Neptune 还通过一个简单的设置过程(只需几次点击)和一个自动更新功能(在不干扰框架的情况下添加新功能)减少了设置和维护的摩擦。与开放源码的设置相比，这是一个双赢的局面，因为开放源码的设置需要多个步骤，而且经常因为不断更新而变得脆弱。
资源:
ML 实验跟踪和管理的 15 个最佳工具
原文：https://web.archive.org/web/https://neptune.ai/blog/best-ml-experiment-tracking-tools
在进行机器学习项目时，从单次模型训练中获得好的结果是一回事。但是，让你所有的机器学习实验保持良好的组织，并有一个让你从中得出有效结论的过程，则完全是另一回事。
这些需求的答案就是实验追踪。在机器学习中，实验跟踪是保存所有实验相关信息的过程，这些信息是你在每次实验中所关心的。
ML 团队以不同的方式实现实验跟踪，可能是通过使用电子表格、GitHub 或自建平台。然而，最有效的选择是使用专门为跟踪和管理 ML 实验而设计的工具。
在这篇文章中，我们概述并比较了 15 个最好的工具，它们可以让你跟踪并管理你的 ML 实验。你将了解它们的主要特征，并看到它们之间的不同之处。希望这将有助于您评估它们，并根据您的需求选择合适的产品。
如何评价一个实验跟踪工具？
“最好的实验跟踪工具是什么？”这个问题没有答案。当你单独工作或在团队中工作时，你的动机和需求可能完全不同。根据您的角色，您可能会寻找各种功能。
如果你是数据科学家或研究人员，你应该考虑:
- 如果该工具带有 web 用户界面或基于控制台；
- 如果您能够将该工具与您首选的模型培训框架相集成；
- 您可以记录、显示和比较哪些元数据(代码、文本、音频、视频等。);
- 你能容易地比较多次跑步吗？如果是，以什么格式——只有表格，还是还有图表；
- 如果通过实验来组织和搜索是用户友好的；
- 如果您可以自定义元数据结构和仪表板；
- 如果该工具让您跟踪硬件消耗；
- 与其他团队成员合作有多容易——你能分享一个实验的链接吗，或者你必须使用截图作为解决方法？
作为一名 ML 工程师，你应该检查这个工具是否让你:
- 轻松重现和重新运行实验；
- 跟踪和搜索实验谱系(下游使用的数据/模型/实验)；
- 保存、获取和缓存实验数据集；
- 将它与您的 CI/CD 渠道集成；
- 轻松地与同事协作和共享工作。
最后，作为一名 ML 团队领导，你会对以下内容感兴趣:
- 一般业务相关的东西，如定价模型、安全性和支持；
- 该工具需要多少基础设施，将其集成到您当前工作流的难易程度；
- 产品是作为商业软件、开源软件还是托管云服务交付的？
- 它具有什么样的协作、共享和审阅功能。
在回顾市场上的工具时，我确保牢记这些动机。所以让我们仔细看看它们。
在我们深入研究每个工具之前，这里有 15 个最佳实验跟踪和管理工具的功能和集成的高级比较。
注:本表最后一次更新是在 2021 年 12 月 20 日。今天有些信息可能已经过时了。看到一些不正确的信息？让我们知道，我们将更新它。
| 焦点 | 元数据存储、实验跟踪、模型注册 | 实验管理 | 实验管理 | 实验管理 | 整个生命周期 | 实验管理 | 实验管理 | 实验管理 | 实验管理 | 整个生命周期 | 整个生命周期 | 运行编排 | 整个生命周期 | 整个生命周期 | 数据版本化 |
| 价格 |
- 个人:免费(+免费额度以上使用)
- 学术界:免费
- 团队:付费
|
- 个人:免费(+免费额度以上使用量)
- 学术界:免费
- 团队:付费
|
- 个人:免费(+免费额度以上使用)
- 学术界:免费
- 团队:付费
| 免费 | 免费 | 免费 | 免费 | |
免费还是付费，取决于计划
| | 娜 | 免费 |
- 开源:免费
- 托管:付费
| |
- DVC:免费
- DVC 工作室:免费或付费，视计划
|
| 独立组件还是更广泛的 ML 平台的一部分？ | 独立组件。专注于实验跟踪和模型注册的 ML 元数据存储库 | 独立组件 | 具有社区、自助和托管部署选项的独立工具 | Omniboard 是神圣的机器学习实验管理工具的网络仪表板 | 开源平台，为实验跟踪、代码打包、模型部署网络和模型注册提供四个独立的组件 | 开源工具，是 TensorFlow 生态系统的一部分 | 独立开源平台 | 独立工具 | 独立开源平台 | 独立组件 | 独立工具 | Kubernetes 环境的一部分 | 独立组件 | AWS sage maker 生态系统的一部分 | 独立组件 |
| 商业软件、开源软件还是托管云服务？ | 托管云服务 | 托管云服务 | 托管云服务 | 开源 | 独立产品是开源的，而 Databricks 管理的版本是商业的 | TensorBoarsd 是开源的，而 TensorBoard.dev 是免费的托管云服务 | 开源 | 提供开源社区计划和各种托管云选项 | 既可作为开源平台，也可作为托管云服务 | 托管云服务 | 基础包是开源的，提供企业级商业产品 | 基础产品是开源的，由云提供商提供托管发行版 | 既可作为开源平台，也可作为托管云服务 | 托管云服务 | 开源和托管云服务 |
| 托管版本还是内部部署？ | 跟踪托管在托管服务器上，也可以部署在内部和公共/私有云服务器上 | 是 | 是的，您可以在任何云环境或内部部署 Comet | 可以部署在内部和/或云上，但必须自我管理 | 追踪托管在本地/远程服务器上(本地或云)。也可作为 Databricks 平台的一部分在托管服务器上使用 | TensorBoard 在本地托管。TensorBoard.dev 在托管服务器上作为免费服务提供 | 可以部署在内部和/或云上，但必须自我管理 | 可在本地和云上托管 | 在本地和云上都可用 | 在本地和云上都可用 | 可在本地和云上托管 | 几乎所有流行的云提供商都维护自己的 Kubeflow 发行版。也可以在内部手动安装。点击此处了解不同的安装选项 | 在本地和云上都可用 | AWS Sagemaker 仅作为完全托管的云服务提供 | 跟踪托管在托管服务器上，也可以部署在内部和公共/私有云服务器上 |
| 在你的训练过程中，你需要改变多少？ | 极小。跟踪只需要几行代码 | 极小。跟踪只需要几行代码 | 极小。跟踪所需的几行代码 | 极小。只需要添加几行代码 | 极小。跟踪所需的几行代码 | 如果已经使用 TensorFlow 框架，则为最小，否则为显著 | 基本跟踪不需要更改代码 | 需要大量代码和基础设施变更 | 极小。跟踪只需要几行代码。 | 不需要更改代码。通过增加了一些额外的工作流程步骤 | 需要大量代码和基础设施变更 | 需要大量代码和基础设施变更 | 极小。跟踪所需的几行代码 | AWS 应用程序迁移服务让您无需任何更改即可将代码移植到 AWS。将 Jupyter 笔记本电脑从本地迁移到 Sagemaker Studio 所需的更改最少 | 极小。跟踪只需要几行代码 |
| Web 用户界面还是基于控制台？ | 网络用户界面 | 网络用户界面 | 网络用户界面 | 网络用户界面 | 网络用户界面 | 网络用户界面 | CLI 和 Web 用户界面 | Web 用户界面和 CLI | 网络用户界面 | Web 用户界面和 CLI | Web 用户界面和 CLI | 网络用户界面 | 网络用户界面 | web 用户界面和 CLI | 网络和控制台用户界面 |
| 元数据的记录和显示 |
| –数据集 | | 有限 | 有限 | 有限 | 有限 | 有限 | | 有限 | 有限 | 有限 | 有限 | 有限 | | 有限 | 有限 |
| –代码版本 | | | | 有限 | 有限 | | 有限 | | 有限 | 有限 | | 有限 | | | |
| –参数 | | | | | | | | | | | | | | | |
| –指标和损失 | | | | 有限 | | 有限 | 有限 | 有限 | 有限 | | | 有限 | | | 有限 |
| –图像 | | 有限 | 不适用 | | | | | 有限 | | | | 不适用 | | | |
| –音频 | | | | | | | | | | | 不适用 | | | | |
| –视频 | | | | | | | | | | | 不适用 | | | | |
| –硬件消耗 | 有限 | 有限 | 有限 | 有限 | | | | 有限 | 有限 | | | | | 有限 | |
| 对比实验 |
| –表格格式差异 | | | | | | | | | | 有限 | | | | | |
| –重叠的学习曲线 | | | | | | | | | | | | | | | |
| –代码 | 有限 | 有限 | | 有限 | | | 有限 | | | | | | | | |
| 组织和搜索实验和元数据 |
| –实验台定制 | | 有限 | 有限 | 有限 | | | | | 有限 | | | 有限 | | | |
| –定制仪表板 | 有限 | | 有限 | | | | | 有限 | | | | 有限 | 有限 | 有限 | |
| –UI 中的嵌套元数据结构支持 | | | | | | | | | | | | 有限 | | |
| 再现性和可追溯性 |
| –单命令实验重新运行 | | | | | | | 有限 | | | | 不适用 | 不适用 | | | |
| –实验谱系 | | | 有限 | | | | | 有限 | | | | 有限 | | | |
| –环境版本 | | | | | | | | | | | 不适用 | 不适用 | | | |
| –保存/获取/缓存实验数据集 | | | | | | | 有限 | | | | 不适用 | 不适用 | | | |
| 协作和知识共享 |
| –用户组和 ACL | 仅面向团队和企业客户 | 仅适用于付费计划 | 仅适用于职业队和企业队 | | 仅在托管版本中 | | | 仅适用于商业版 | 仅面向企业客户 | 仅面向企业客户 | 仅在企业版中 | | 仅面向企业客户 | | 仅面向团队和企业客户 |
| –与项目成员共享 UI 链接 | | | | | | 仅在 TensorBoard.dev 中 | 有限 | | | | 不适用 | 不适用 | | | |
| –与外部人员共享 UI 链接 | | | | | | 仅在 TensorBoard.dev 中 | 有限 | | | | 不适用 | 不适用 | | | |
| –评论 | | | | | | | | | | | | 不适用 | 有限 | | |
| 集成 |
| R | 有限 | | | | | 有限 | | | | | | | | | |
| 张量板 | 有限 | | | | | 不适用 | | | | | | | | | |
| MLFlow | 有限 | | | | 不适用 | | | | | | | | | | |
| 神圣的 | | | | 不适用 | | | | | | | | | | | |
| 亚马逊 SageMaker | | | | | | | | | | | | | | 不适用 | |
| Google Colab | | | | | 有限 | | | | | | | | | | |
| Kubeflow | | | | | | | | | | | | 不适用 | | | |
| Keras | | | | | | | 有限 | | | | | | | | |
| Tensorflow | | | | | | | 有限 | | | | | | | | |
| 指针 | | | | | | | | | | | | | | | |
| Scikit-Learn | | | | | | | | | | | | | | | |
| LightGBM | | | | | | | | | | | | | | | |
| XGBoost | | | | | | | | | | | | | | | |
| fastai | | | 没有本地集成，只有示例可用 | | | | | | | | | | | | |
| 斯科奇 | | | | | | | | | | | | | | | |
| PyTorch 闪电 | | | | | | | | | | | | | | | |
| 火焰喷射器 | 有限 | | | | | | | | | | | | | | |
| 催化剂 | | | | | | | | | | | | | | | |
| Optuna | | | | | | | | | | | | | | | |
| sci kit-优化 | 有限 | | | | | | | | | | | | | | |
| 射线调 | | | | | | | | | | | | | | | |
| 拥抱脸 | | | | | | | | | | | | | | | |
| 先知 | | | | | | | | | | | | | | 亚马逊自己的先知配送 | |
Neptune 是任何 MLOps 工作流的元数据存储库。它是为进行大量实验的研究和生产团队设计的。它可以让你在一个地方监控、可视化和比较数以千计的 ML 模型。
Neptune 支持实验跟踪、模型注册和模型监控，它的设计方式使协作变得容易。
用户可以在应用程序中创建项目，一起工作，并且彼此共享 UI 链接(或者甚至与外部利益相关者共享)。所有这些功能使得 Neptune 成为 ML 团队所有成员之间的纽带。
Neptune 有云版本，可以在内部部署。它还与 25+其他工具和库集成，包括多模型训练和超参数优化工具。
主要优势:
Weight & Biases 是一个机器学习平台，为实验跟踪、数据集版本化和模型管理而构建。对于实验跟踪部分，其主要重点是帮助数据科学家跟踪模型训练过程的每个部分，可视化模型，并比较实验。
W&B 也可以在云中使用，并作为一个内部工具。在集成方面，Weights & Biases 支持多个其他框架和库，包括 Keras、PyTorch environment、TensorFlow、Fastai、Scikit-learn 等等。
主要优势:
- 一个用户友好的交互式仪表板，是应用程序中所有实验的中心位置。它允许用户组织和可视化他们的模型训练过程的结果；
- 用 W&B 扫描进行超参数搜索和模型优化:
- 日志数据集的区分和重复数据删除。
Comet 是一个 ML 平台，帮助数据科学家在模型的整个生命周期(即从训练到生产)中跟踪、比较、解释和优化实验和模型。在实验跟踪方面，数据科学家可以注册数据集、代码更改、实验历史和模型。
Comet 适用于团队、个人、学者、组织以及任何想要轻松可视化实验、促进工作和运行实验的人。它可以用作托管平台或内部部署。
主要优势:
- 基于网络的用户界面中完全可定制的实验表格；
- 广泛的比较特性——代码、超参数、度量、预测、依赖性、系统度量等等；
- 用于视觉、音频、文本和表格数据的专用模块，可以轻松识别数据集的问题。
神圣的是开源软件，允许机器学习研究人员配置、组织、记录和复制实验。Sacred 没有自带合适的 UI，但是有一些 dashboarding 工具可以连接到它，比如 Omniboard(但是你也可以使用其他工具，比如 Sacredboard，或者通过集成使用 Neptune)。
神圣不具备以前工具的可扩展性，也没有适应团队协作(除非与另一个工具集成)，然而，当涉及到个人研究时，它有很大的潜力。
主要优势:
- 可能连接到首选的用户界面；
- 可以跟踪用任何 Python 库开发的任何模型训练；
- 丰富的实验参数定制选项。
MLflow 是一个开源平台，帮助管理整个机器学习生命周期。这包括实验，也包括模型存储、可再现性和部署。这四个元素中的每一个都由一个 MLflow 组件表示:跟踪、模型注册、项目和模型。
MLflow 跟踪组件由 API 和 UI 组成，支持记录各种元数据(包括参数、代码版本、指标和输出文件)并在以后可视化结果。
主要优势:
- 关注机器学习过程的整个生命周期；
- 提供社区支持的强大用户社区；
- 可以与任何 ML 库或语言集成的开放接口。
TensorBoard 是 TensorFlow 的可视化工具包，所以它往往是 TensorFlow 用户的首选。TensorBoard 为机器学习模型的可视化和调试提供了一套功能。用户可以跟踪实验指标，如损失和准确性，可视化模型图，将嵌入投影到低维空间，等等。
还有 TensorBoard.dev 可以让你上传并与任何人分享你的 ML 实验结果(TensorBoard 缺少协作功能)。TensorBoard 是开源的，在本地托管，而 TensorBoard.dev 作为免费服务在托管服务器上提供。
主要优势:
- 与处理图像相关的成熟功能，例如 TensorBoard 的投影仪，允许您可视化任何矢量表示，如单词嵌入和图像；
- 假设工具(WIT)，这是一个易于使用的界面，用于扩展对黑盒分类和回归 ML 模型的理解
- 提供社区支持的强大用户社区。
Guild AI 是一个用于机器学习的实验跟踪系统，在 Apache 2.0 开源许可下可用。它配备了允许您运行分析、可视化和差分、自动化管道、使用 AutoML 调整超参数、进行调度、并行处理和远程培训的功能。
Guild AI 还附带了多个集成工具，用于比较实验，例如:
- guild Compare——一个基于 curses 的应用程序，允许您以电子表格格式查看跑步记录，包括标志和标量值，
- guild View–一个基于网络的应用程序，允许您查看跑步记录并比较结果，
- 公会差异——一个让你比较两个回合的命令。
主要优势:
- 无需更改代码，它运行任何语言或框架编写的脚本；
- 不需要额外的软件或系统，如数据库或容器
- 提供社区支持的强大用户社区。
Polyaxon 是一个平台，用于可重复和可扩展的机器学习和深度学习应用。它包括从跟踪和优化实验到模型管理、运行协调和法规遵从性的广泛功能。其开发者的主要目标是在节约成本的同时最大化结果和生产率。
在实验跟踪方面，Polyaxon 允许您自动记录关键的模型度量、超参数、可视化、工件和资源，以及版本控制代码和数据。要在以后显示记录的元数据，您可以使用 Polyaxon UI 或将其与另一个电路板集成，例如 TensorBoard。
Polyaxon 可以部署在内部或您选择的云提供商上。它还支持主要的 ML 和 DL 库，如 TensorFlow、Keras 或 Scikit-learn。
主要优势:
- Polyaxon UI，由 Runs 仪表板表示，具有可视化功能、协作特性和可扩展的界面；
- 协作功能和项目管理工具；
- 可扩展的解决方案–提供从开源到云和企业的不同计划。
ClearML 是一个开源平台，一套工具来简化您的 ML 工作流程，由 Allegro AI 背后的团队提供支持。该套件包括模型训练记录和跟踪、ML 管道管理和数据处理、数据管理、编排和部署。所有这些特性都反映在 5 个 ClearML 模块中:
- ClearML Python 包，用于将 ClearML 集成到您现有的代码库中；
- ClearML 服务器存储实验、模型和工作流数据，并支持 Web UI 实验管理器；
- ClearML Agent 是 ML-Ops 编排代理，支持实验和工作流程的可再现性和可扩展性；
- 在文件系统/对象存储之上提供数据管理和版本控制的 ClearML 数据；
- ClearML 会话，允许您启动 Jupyter 笔记本和 VSCode 的远程实例。
ClearML 集成了许多框架和库，包括模型训练、超参数优化和绘图工具，以及存储解决方案。
主要优势:
- ClearML 网络用户界面，让您跟踪和可视化实验；
- 一个在脱机模式下处理任务的选项，其中所有信息都保存在本地文件夹中；
- ClearML 服务器支持多用户协作。
Valohai 是一个 MLOps 平台，它自动化了从数据提取到模型部署的一切。该工具背后的团队表示，Valohai“提供了类似 Kubeflow 的机器编排和类似 MLflow 的实验跟踪，无需任何设置”。虽然实验跟踪不是这个平台的主要焦点，但是它提供了一些功能，比如实验比较、版本控制、模型沿袭和可追溯性。
Valohai 兼容任何语言或框架，以及许多不同的工具和应用程序。它可以设置在任何云供应商或内部设置中。该软件也是面向团队合作的，并有许多功能来促进它。
主要优势:
- 模型建立过程的显著加速；
- 专注于机器学习的整个生命周期；
- 由于这是一个主要为企业构建的平台，隐私和安全是他们的驱动原则。
Pachyderm 是一个企业级开源数据科学平台，它使其用户能够控制端到端的机器学习周期。从数据沿袭，通过构建和跟踪实验，到可伸缩性选项。
该软件有三种不同的版本:
- 由专家社区构建和支持的 Pachyderm 的无社区和源代码版本；
- 企业版——一个完整的版本控制平台，可以部署在用户选择的 Kubernetes 基础设施上；
- hub Edition–托管和管理的厚皮动物版本。
主要优势:
- 根据您自己的需求调整软件版本的可能性；
- 端到端流程支持；
- 由强大的专家社区建立和支持。
Kubeflow 是 Kubernetes 的机器学习工具包。它的目标是利用 Kubernetes 的潜力来促进机器学习模型的扩展。该平台具有一些跟踪功能，但这不是该项目的主要焦点。它由几个组件组成，包括:
- Kubeflow Pipelines 一个基于 Docker 容器构建和部署可移植、可扩展的机器学习(ML)工作流的平台。这可能是 Kubeflow 最常用的功能；
- 中央仪表盘 Kubeflow 的中央用户界面(UI );
- 笔记本服务器——创建和管理交互式 Jupyter 笔记本的服务；
- KFServing–kube flow 模型部署和服务工具包
- 培训操作员–用于通过操作员(例如 PyTorch、TensorFlow)在 Kubeflow 中培训 ML 模型。
主要优势:
- 用于管理和跟踪实验、作业和运行的用户界面(UI)
- 一个端到端的开源平台；
- 内置笔记本服务器服务。
Verta 是一个企业 MLOps 平台。其主要特点可以用四个词来概括:跟踪、协作、部署和监测。这些功能反映在 Verta 的主要产品中:实验管理、模型注册、模型部署和模型监控。该软件旨在促进整个机器学习生命周期的管理。
实验管理组件允许您跟踪和可视化 ML 实验、记录各种元数据、搜索和比较实验、确保模型再现性、在团队中协作 ML 项目，等等。
Verta 支持许多流行的 ML 框架，包括 TensorFlow、PyTorch、XGBoost、ONNX 等等。它可以作为一个开源服务，SaaS 和企业。
主要优势:
- 建立可定制的仪表板和可视化建模结果的可能性；
- 协作功能和用户管理；
- 涵盖 MLOps 管道多个步骤的可扩展解决方案。
SageMaker Studio 是 AWS 平台的部分。它允许数据科学家和开发人员准备、构建、训练和部署高质量的机器学习(ML)模型。它声称是 ML 的第一个集成开发环境(IDE)。它有四个组成部分:准备、构建、训练&调优、部署&管理。实验跟踪功能包含在第三个功能中，训练&曲调。用户可以记录、组织和比较实验，自动调整超参数，并调试训练运行。
主要优势:
- 内置调试器和分析器，可让您识别并减少训练错误和性能瓶颈；
- 跟踪数千次实验的可能性；
- 与多种 Amazon 工具集成，用于 ML 相关任务。
DVC 工作室是由 iterative.ai 支持的 DVC 工具集团的一部分。最初，DVC 是一个开源版本控制系统，专门为机器学习项目创建。这个组件仍然存在，目的是使数据科学家能够共享 ML 模型，并使它们可复制。然而，现在也有了 DVC 工作室，一个 ML 项目的可视化界面，它被创建来帮助用户跟踪实验，可视化实验并与团队合作。
DVC 工作室应用程序可以在线访问，也可以在内部托管。
主要优势:
- DVC 工作室是一个可视化界面，可以连接 GitHub，GitLab，或者 Bitbucket
- 它从 JSON 文件中提取元数据(模型度量和超参数)，并在一个漂亮的 UI 中呈现出来；
- 为 ML 团队应用现有的软件工程堆栈。
最后的想法
跟踪机器学习实验一直是 ML 开发过程中的一个重要元素，然而，早期的过程是非常手动的，耗时并且容易出错。
在过去的几年里，用于机器学习的现代实验跟踪和实验管理工具的市场已经成长和成熟。现在可供选择的范围广泛而多样化。无论您是在寻找开源还是企业解决方案，如果您更喜欢独立的实验跟踪框架还是端到端平台，您肯定会找到合适的工具。
管理机器学习生命周期的最佳 MLOps 平台
机器学习生命周期是以高效的方式开发机器学习项目的过程。建立和训练一个模型是一个艰难而漫长的过程，但这只是你整个任务中的一步。机器学习生命周期背后有一个漫长的过程:收集数据、准备数据、分析、训练和测试模型。
组织必须管理数据、代码、模型环境和机器学习模型本身。这需要一个过程，在这个过程中，他们可以部署他们的模型，监控它们，并对它们进行再培训。大多数组织在生产中有多个模型，即使只有一个模型，事情也会变得复杂。
典型的 ML 生命周期
- 收集数据:ML 生命周期的第一步，这里的目标是从各种来源收集数据。
- 数据准备:收集完所有数据后，您需要对数据进行清理和转换，以便进行处理和分析。这是重新格式化数据和进行修正的重要过程。
- 分析数据:现在数据已经准备好了，可以用来建立模型，选择分析技术，等等。一旦完成，输出被审查以选择 ML 技术。
- 训练模型:使用各种机器学习算法来训练数据集，需要理解流程、模式和规则。
- 测试模型:一旦训练完成，您可以测试您的数据，检查模型的准确性，以及它的表现如何。
- 部署:现在所有的事情都运行良好，是时候将机器学习模型部署到现实世界中了。您可以监视模型的执行情况，并查看如何改进工作流。
参见关于机器学习生命周期的详细解释。
机器学习生命周期管理平台
在生产中管理机器学习模型是一项艰巨的任务，因此为了优化这一过程，我们将讨论几个最佳和最常用的机器学习生命周期管理平台。这些平台从小规模到企业级云和开源 ML 平台，将帮助您改进从收集数据到将应用程序部署到现实世界的 ML 工作流程。
1.亚马逊 SageMaker
Amazon SageMaker 是一个 ML 平台，它可以帮助您在生产就绪的 ML 环境中构建、训练、管理和部署机器学习模型。SageMaker 使用专门构建的工具加速您的实验，包括标记、数据准备、培训、调整、主机监控等等。
Amazon SageMaker 提供了大约 17 个与 ML 相关的内置服务，并且他们可能会在未来几年增加更多。确保你熟悉 AWS 的基础知识，因为你永远不知道分配这些服务器每小时要花多少钱。
特性:
Amazon Sagemaker 有许多特性，使 ML 模型的构建、培训、监控和部署变得简单。
- Sagemaker 附带了许多用于训练数据集(大数据集)的 ML 算法。这有助于提高模型的准确性、比例和速度。
- Sagemaker 包括监督和非监督的 ML 算法，如线性回归、XGBoost、聚类和客户细分。
- 端到端的 ML 平台加速了建模、标记和部署的过程。AutoML 特性将根据您的数据自动构建、训练和调整最佳 ML 模型。
- SageMaker 为您提供了集成 API 和 SDK 的选项，使设置变得容易，您可以在任何地方使用机器学习功能。
- 它有 150 多个预构建解决方案，您可以快速部署。这有助于您开始使用 Sagemaker。
查看亚马逊 SageMaker 与 Neptune 相比如何，以及如何将 Neptune 整合到亚马逊 sage maker 管道中。
定价:
SageMaker 不是免费的。如果你是新用户，前两个月可能是免费的。有了 AWS，您只需为您使用的内容付费。在 SageMaker 上构建、培训和部署您的 ML 模型，您将按秒计费。没有额外的费用或任何额外的收费。定价分为 ML 存储、实例和数据处理。
2.Azure 机器学习
Azure ML 是一个基于云的平台，可用于训练、部署、自动化、管理和监控所有机器学习实验。就像 SageMaker 一样，它既支持监督学习，也支持非监督学习。
特性:
Azure 具有创建和管理 ML 模型的特性:
- Azure ML 平台支持 Python、R、Jupyter Lab 和 R studios，具有自动机器学习功能。
- 拖放功能提供了一个无代码的机器学习环境，有助于数据科学家轻松协作。
- 你可以选择在本地机器或 Azure 机器学习云工作空间中训练你的模型。
- Azure 机器学习支持许多开源工具，包括 Tensorflow、Scikit-learn、ONNX、Pytorch。它有自己的 MLops 开源平台(微软 MLOps )。
- 一些关键功能包括协作笔记本、AutoML、数据标签、MLOps、混合和多云支持。
- 强大的 MLOps 功能支持创建和部署。轻松管理和监控您的机器学习实验。
定价:
Azure 机器学习提供 12 个月的免费服务和少量积分来探索 Azure。与其他平台一样，Azure 也采用现收现付的定价模式。免费信用/服务结束后，您需要付费使用。
蔚蓝—入门
3.谷歌云人工智能平台
谷歌云是一个端到端的完全托管的机器学习和数据科学平台。它具有帮助您更快、更无缝地管理服务的功能。他们的 ML 工作流程使开发者、科学家和数据工程师的工作变得简单。该平台具有许多支持机器学习生命周期管理的功能。
特性:
谷歌云人工智能平台包括许多资源，可以帮助你有效地进行机器学习实验。
- 云存储和 bigquery 帮助您准备和存储数据集。然后，您可以使用内置功能来标记您的数据。
- 通过使用具有易于使用的 UI 的 Auto ML 特性，您可以在不编写任何代码的情况下执行任务。你可以使用 Google Colab，在那里你可以免费运行你的笔记本。
- Google 云平台支持许多开源框架，如 KubeFlow、Google Colab 笔记本、TensorFlow、VM 镜像、训练模型和技术指南。
- 部署可以通过 Auto ML 特性来完成，它可以对您的模型执行实时操作。
- 通过管道管理和监控您的模型和端到端工作流。你可以用 AI 解释和 What-if-too l 来验证你的模型，这有助于你了解你的模型输出，它的行为，以及改进你的模型和数据的方法。
定价:
谷歌人工智能云平台根据您的项目和预算，为您提供灵活的定价选项。谷歌对每个功能的收费都不一样。你可能很少看到完全免费的功能，也很少从你开始使用它们的那一刻起就开始收费。当您开始使用 GCP 时，您将获得 300 美元的免费点数。免费试用结束后，将根据您使用的工具按月收费。
GCP-入门
3.元流
Metaflow 是一个基于 Python 的库，帮助数据科学家和数据工程师开发和管理现实生活中的项目。这是一个专门用于 ML 生命周期管理的工作空间系统。元流最初是在网飞开发的，目的是提高科学家的生产率。
特性:
Metaflow 于 2019 年由网飞和 AWS 开源，它可以与 SageMaker，Python 和深度学习基础库集成。
- Metaflow 为 stack 提供了一个统一的 API，从原型到基于生产的数据科学项目的执行都需要这个 API。
- 可以从数据仓库(可以是本地文件)或数据库中访问数据。
- Metaflow 有一个图形用户界面，它帮助你把你的工作环境设计成一个有向无环图(D-A-G)。
- 部署到生产环境后，您可以跟踪所有的实验、版本和数据。
元流-入门
5.图纸空间
Gradient by Paperspace 是一个机器学习平台，从探索到生产都可以使用。它帮助您构建、跟踪和协作 ML 模型。它有一个云托管的设计来管理你所有的机器学习实验。大部分工作流都是围绕 NVIDIA GRID 构建的，因此您可以期待强大而更快的性能。
特性:
Paperspace Gradient 可帮助您探索数据、训练神经网络和部署基于生产的 ML 管道。
- Paperspace Gradient 支持您可能正在使用或计划使用的几乎所有框架和库。
- 单一平台可训练、跟踪和监控您的所有实验和资源。
- 通过 jupyter 笔记本电脑支持的 GradientCI github 功能，您可以选择将您的机器学习项目与 github repo 集成。
- 你将获得免费的强大的图形处理器，你可以在一键启动。
- 用现代确定性过程开发 ML 管道。无缝管理版本、标签和生命周期。
- 你可以很容易地将你现有的实验转化为深度学习平台。
- 获得更多 GPU 选项，他们有 NVIDIA M4000，这是一种经济高效的卡，而 NVIDIA P5000 可以帮助您优化繁重的高端机器学习工作流。他们正计划添加 AMD 来优化机器学习工作流程。
定价:
根据您的用途，Paperspace Gradient 有许多方案。如果你是一名学生或初学者，它是免费的，使用和付费实例的费用有限。付费计划从每月 8 美元到 159 美元不等。你可以联系他们的销售团队来个性化你的计划。
纸张空间渐变-入门
6.MLflow
MLflow 是一个开源平台，用于管理机器学习生命周期——实验、部署和中央模型注册。它旨在与任何机器学习库、算法和部署工具一起工作。
特性:
MLflow 是用 REST APIs 构建的，这使得它的工作空间看起来很简单。
- 它可以与任何机器学习库、语言或任何现有代码一起工作。它在任何云中都以同样的方式运行。
- 它使用一种标准的格式来打包 ML 模型，该模型可以在下游工具中使用。
- MLflow 主要由四个部分组成，MLflow 跟踪、MLflow 项目、MLflow 模型和 MLflow 注册。
- MLflow 跟踪就是记录和查询你的代码和数据实验。
- MLflow 项目是一个数据科学包，它以可重用和可复制的格式提供代码。它还包括用于运行 ML 和数据科学项目的 API 和 cmd 工具。
- MLflow 模型帮助您部署不同类型的机器学习模型。每个模型都保存为包含任意文件的 dir。
- MLflow registry 可以帮助您在一个中央存储库中存储、注释、探索和管理您的所有机器学习模型。
下面是一个 MLFlow 项目示例，它可以由一个名为 MLproject 的简单 YAML 文件定义:
name: My Project
conda_env: conda.yaml
entry_points:
main:
parameters:
data_file: path
regularization: {type: float, default: 0.1}
command: "python train.py -r {regularization} {data_file}"
validate:
parameters:
data_file: path
command: "python validate.py {data_file}"
ml flow-入门
7.算法 a
Algorithmia 是一个基于企业的 MLOps 平台，可加速您的研究并快速、安全且经济高效地交付模型。您可以部署、管理和扩展所有的 ML 实验。
特性:
Algorithmia 可帮助您安全地部署、服务、管理和监控所有机器学习工作负载。
- Algorithmia 对工作空间有不同的规划。根据您的项目，您可以选择 Algorithmia 企业或 Algorithmia 团队。
- Algorithmia 的平台可以帮助您构建和管理各种机器学习操作，并轻松提升您的 ML 能力。
- 它以经济高效的方式将模型交付速度提高了 12 倍。Algorithmia 将在你机器学习生命周期的所有阶段为你工作。
- Algorithmia 使用自动化机器学习管道进行版本控制、自动化、日志记录、审计和容器化。您可以轻松访问 KPI、绩效指标和监控数据。
- 全面记录您的机器学习模型，并从您现有的实验中查询它们。Algorithmia 功能将向您清晰展示风险、合规性、成本和性能。
- 它支持超过 3900 种语言/框架。使用 MLOps 及其灵活的工具优化模型部署。
- Algorithmia 提供了一些高级功能，可以轻松处理 CI/CD 管道并优化监控。
- 你可以将你的机器学习模型部署在云上、你的本地机器上或者任何其他类型的环境中。
定价:
Algorithmia 有三个计划:团队、企业专用和企业高级。团队计划采用现收现付的价格(PRO 为 299 美元/月)，对于企业级计划，您需要联系他们的销售团队。
algorithm ia-入门
8. TensorFlow Extended (TFX)
Tensorflow Extended 是 Google 生产规模的 ML 平台。它提供了共享库和框架来集成到您的机器学习工作流中。
特性:
TFX 是一个在生产中开发和管理机器学习工作流的平台。
- TensorFlow extended 允许您在许多平台上编排您的机器学习工作流，如 Apache、Beam、KubeFlow 等..
- TFX 组件提供了帮助您轻松开始开发机器学习过程的功能。
- 它是实现机器学习管道的一系列组件，旨在帮助执行高端任务，建模，培训和管理您的机器学习实验。
- TFX 流水线包括示例生成、统计生成、模式生成、示例验证器、转换、训练器、调谐器、评估器、红外验证器、推动器、批量推断器。
- 自动化数据生成来描述对数据的期望，这是一个查看和检查模式的特性。
- TFX 图书馆包括:
- TensorFlow 数据验证分析和验证机器学习数据。这是一项高端设计，旨在改善 TFX 和 Tensorflow 的工作流程。
- 张量流变换用张量流对数据进行预处理。这有助于通过均值和标准差方法归一化输入值。
- 张量流模型分析评估张量流模型。它以分布式方式提供大量数据的指标。这些指标可以在 jupyter 笔记本上计算。
- TensorFlow 元数据提供了在用 TF 训练机器学习模型时有用的元数据。可以手动生成，也可以在数据分析过程中自动生成。
- ML 元数据(MLMD) 是一个用于记录和检索机器学习工作流元数据的库。
9.塞尔顿
Seldon 是一个开源平台，用于在 Kubernetes 上部署机器学习模型。它帮助数据科学家无缝管理工作流、审计、ML 实验、部署等。
特性:
Seldon 为任何企业创建了一个从部署到治理的无缝管道。它附带了一个开源的 Python 库，用于检查和解释机器学习模型。
- 谢顿主要有三个产品:谢顿部署，谢顿代码和谢顿不在场证明。
- 它构建在 Kubernetes 上，可以运行在任何平台上(云或本地机器)
- Seldon 支持大多数顶级的库、语言和工具包。
- 任何非 kubernetes 专家都可以部署机器学习模型，并在 ML 工作流中测试他们的模型。
- 您可以监控模型性能，并轻松检查和调试错误。
- Seldon 附带了一个机器学习模型解释器，它可以检测你工作流程中的任何危险信号。
- Seldon 的企业计划提供了更多功能，以实现更快的交付、适当的治理和全生命周期管理。
定价:
谢顿核心是免费部署到您的 Kubernetes 集群。塞尔登企业解决方案提供 14 天免费试用。您可以联系他们的销售团队或索取演示，以了解更多关于 Seldon Solutions 的信息。
10.HPE 埃兹迈拉 ML Ops
HPE·埃兹迈拉是惠普公司提供企业级机器学习操作的服务。从沙盒到模型训练、部署和跟踪。它可以与任何机器学习或深度学习框架无缝地执行。
特性:
它为 ML 生命周期的每个阶段的机器学习工作流提供了速度和敏捷性。
- 你可以在你的本地机器或者像 AWS、GCP 等云平台上运行 HPE·埃兹迈拉..
- 它为机器学习生命周期提供了基于容器的解决方案。构建、培训、部署和监控您的机器学习模型。
- 执行高端培训并获得对大数据的安全访问。
- 无缝跟踪型号版本、注册表。需要时更新您的 ML 模型。轻松监控模型性能。
- 在大规模部署之前，您可以运行 A/B 测试来验证模型。
- 您可以转变任何非云应用，无需重新架构。您可以构建应用程序，并将其部署到您想要的任何地方。
定价:
HPE Ezmeral 是一个企业级平台，所以你不会得到任何免费试用或现收现付的价格。你需要为你的项目得到个性化的报价。基本存储价格从 0.100 美元/GB 起，计算单价为 18.78 美元
比较
我们看到了许多平台，在这些平台上，你可以构建、训练、部署和管理你的机器学习模型。大多数平台彼此关系非常密切，具有相似的特性，但也有一些差异。我们将比较几个顶级平台及其最佳能力。
创造环境
亚马逊 Sage Maker——Sage Maker Studio 有一个很好的界面，跳过了所有的复杂性。你可以通过 jupyter 笔记本准备你的数据。
谷歌云平台–笔记本电脑云设置非常简单。只需在顶部搜索，您就可以部署所需的解决方案。GCP 主要运行在云壳特性上。你可以整合谷歌 Colab 的数据。
Microsoft Azure–Azure 允许您通过拖放选项导入保存的数据。您可以将数据集拖到实验画布上。
构建和培训模型
Amazon Sage Maker——借助 Python 代码，您可以将数据分成训练集和测试集。这是 SageMaker 的一个优点，它可以让你自动执行任务。使用预定的 XGBoost 算法，您可以通过在 jupyter 笔记本上运行，使用梯度优化来训练模型。
谷歌云平台——它没有预先构建、定制的机器学习算法，但它提供了一个使用 TF 运行模型的平台。通过进入数据集页面并定义模型详细信息，您可以用任何语言训练模型。创建自定义容器来安装培训工作流。
Microsoft Azure——在 Azure 中，如果你想拆分数据，你必须选择数据集中的列并拆分数据模块。Azure 允许你选择特性来训练你的算法。您可以简单地使用画布模块，拖动“火车模型”模块并连接您的数据。
测试、评分和部署模型
Amazon Sage Maker——要在服务器上部署模型，您需要在 Jupyter 笔记本上运行几行代码。请确保在测试后终止您的流程，以避免任何额外费用。
谷歌云平台 which 不提供自动化的超参数调整，相反，它有 Hypertune，可以让你精确地优化机器学习模型。基于 GCP 的模型被打包成一个 Python 模块，并将部署在 Google Cloud ML 上。
Microsoft Azure——为了测试和部署，您需要拖动并连接您的训练模型和您的分离数据和分数模型。完成后，您可以查看行和列中的输出。要评估您的模型执行情况，您可以将“评估模型”功能拖到画布中，并轻松连接它。
你应该选择哪一个？
大多数 ML 平台提供了一个健壮的基于 GUI 的工具来改进 ML 工作流程。不同的工具可能有不同的设计和工作流程。
有些平台对新手来说真的很容易。Azure 提供了一个拖动连接选项，对于访问、清理、评分和测试机器学习数据等任务来说非常简单。
当涉及到用 Python 编码和笔记本管理 ML 工作流时，很少有平台是真正非常复杂的。SageMaker、GCP 和其他一些公司是为了满足数据科学家和喜欢 Jupyter 笔记本的 ML 开发人员的需求而设计的。
每个平台都有优点和缺点。这是一个个人的选择，因为无论你选择什么平台，你的模型精度不会相差太多。工作流是不同的，但您可以导入您的算法。定价在这里是一个重要的话题，因为它们中的大多数都有一个现收现付的选项，允许您只为您使用的功能付费。我们讨论的大多数平台都有这个功能，所以定价部分没有问题。
如果你是一个单独的数据科学家、ML 工程师或有一个小团队，并且想在部署你的模型之前试用一个平台，你可以选择提供免费试用或免费积分的平台。它将帮助您了解事情是如何工作的，以及您和您的团队是否习惯使用一个平台。
额外研究和推荐阅读
计算机视觉项目管道的最佳 MLOps 工具
原文：https://web.archive.org/web/https://neptune.ai/blog/best-mlops-tools-for-computer-vision-project
应用或软件系统的生命周期(也称为 SDLC )有几个主要阶段:
- 策划，
- 发展，
- 测试，
- 部署，
然后，根据需要返回到包含特性、更新和/或修复的新版本。
为了执行这些过程，软件开发依赖于 DevOps 来简化开发，同时持续交付新版本并保持质量。
计算机视觉模型或任何机器学习模型的工作流程也遵循类似的模式。它与传统软件开发的不同之处在于它运行的环境。
例如，计算机视觉主要是数据驱动的，因此在行为上是不确定的。此外，正如最近的全球事件所表明的那样，我们的世界在不断变化，因此 CV 从业者必须预期驱动其模型的真实世界数据也将不可避免地发生变化。
因此，ML 实践者已经接受了 ML 模型的 DevOps 实践，并提出了 MLOps。在维基百科的术语中， MLOps 是将实验机器学习模型投入生产的过程。[ 来源
Gartner 将 MLOps 定义为 ModelOps 的子集。MLOps 专注于 ML 模型的可操作性，而 ModelOps 涵盖所有类型的 AI 模型的可操作性。[ 来源
在这篇博客中，我们主要关注的是计算机视觉中的模型运算(如果你对模型运算的重要性更感兴趣，你可以看看这篇博客)
*MLOps 和 DevOps 的主要区别是什么？
MLOps 比 DevOps 要复杂一些。所有这些值得做吗？
你为什么要做 MLOps，而不仅仅是专注于创造一个更好的 ML 模型？
您可以在没有 MLOps 的情况下实现和训练具有良好性能和准确性的模型。然而，真正的挑战是建立一个集成的 ML 系统，使其在生产中持续运行。
下图显示了真实 ML 系统中只有一小部分是由 L 代码组成的。所需的周围元素是巨大而复杂的。
上图显示了你在 CV 项目中应该遵循的步骤。现在，这些步骤的自动化水平定义了 CV 项目的成熟度。
什么叫成熟？让我们来看看谷歌在“ MLOps:机器学习中的连续交付和自动化管道”中简要规定的三个层次的 MLOps:
- m lops 0 级
在这里，开发人员手动控制从收集数据到构建模型和部署模型的所有步骤。这个过程通常是通过在笔记本上编写和执行实验代码来实现的，直到产生一个可行的模型。在这个级别，一个经过训练的模型被部署为一个生产服务。
- MLOps 一级
在级别 1 中，整个 ML 管道是自动化的。在这里，使用新数据在生产中重新训练模型的过程是自动化的。此外，为此，数据和模型验证步骤以及元数据管理需要自动化。在这一级，自动和循环运行以服务于训练模型的整个训练管道被部署为预测服务。
- MLOps 二级
在第 2 级中，CI/CD 管道与 ML 管道一起实现自动化。自动化 CI/CD 使您能够探索围绕功能工程或模型架构的新想法，并通过自动化管道构建、测试和部署轻松实现它们。
现在我们知道了 MLOps 的重要性，让我们来详细看看您的计算机视觉项目的每个阶段和组件，以及所有相关的 MLOps 工具。
数据和特征管理
数据收集
以下是常见 CV 项目中使用的数据集列表(除了非常著名的 CIFAR-10 、 ImageNet 和 MS Coco ):
最大的开源人脸图像数据集之一，带有性别和年龄标签。它由 523051 张人脸图像组成。
最大的数据集之一，包含在 50 个不同城市的街道场景中记录的一组不同的立体视频序列，除了 20，000 个弱注释帧之外，还有 5，000 个高质量注释帧。
它由 60，000 个训练样本和 10，000 个测试样本组成，每个样本都是与 10 个类别的标签相关联的 28 X 28 灰度图像。
该数据集由 Youtube 上的 6，50，000 个 10 秒钟的视频剪辑组成，包括大约 700 个人类动作类，每个类中至少有 600 个视频剪辑。一系列以人为本的行动。
这个开源数据集有密集标记的视频剪辑，这些视频剪辑是人类用日常物品执行预定义的基本动作。它是为 CV 模型创建的，目的是为了更好地理解物理世界中发生的基本动作。包含的视频总数为 220，847 个，其中 168，913 个是训练集，24，777 个是验证集，27，157 个是测试集。
数据创建
如果您想要构建自己的数据集，以下是计算机视觉中常用的工具，它们可以帮助您创建数据集:
- 这是一个图形图像注释工具。
- 用 python 编写，图形界面使用 Qt
- 注释以 PASCAL VOC 格式保存在 XML 中， ImageNet 使用的格式。还支持 YOLO 和 CreateML 格式。
- 这是一个免费的在线交互式视频和图像注释工具。
- 具有深度学习的无服务器自动标注功能
- 这是一个开源的数据标签工具，用于图像、视频、音频等，有一个简单的用户界面。
- 导出到各种模型格式
- 除了创建原始数据，还可以用于改进现有数据。
- VoTT 是一个 React + Redux 的 Web 应用，用 TypeScript 编写。
- 用于导入和导出数据的可扩展模型。
数据管理
除了通过出色的 UI 很好地完成数据版本控制，Neptune 还允许您记录图像目录的可视快照，这对于您的计算机视觉项目非常有帮助。
旨在处理大型文件和数据集以及机器学习模型和指标。
凭借无限制导出、通用主机、标签和注释工具等功能，Roboflow 非常适合您的计算机视觉项目。
Dataiku 是为那些喜欢使用代码而不是可视化工具来操作、转换和建模数据的人准备的。
数据验证
要检查图像或视频数据的质量保证，以下是一些工具:
Scale 通过帮助计算机视觉团队生成高质量的地面真实数据，加速了 AI 应用的开发。他们先进的激光雷达、视频和图像注释 API 允许自动驾驶、无人机和机器人团队专注于构建差异化的模型，而不是标记数据。它为所有人工智能应用程序提供高质量的培训和验证数据的付费服务，包括按需客户和企业客户。
Great Expectations 是开源的，通过数据测试、文档和概要分析，帮助数据团队消除管道债务。
它为您所有数据的端到端可观察性和控制提供付费服务。它的一些特性包括监控、测试和检查数据的适用性。
数据处理
数据处理和数据管道非常重要。有三个关键要素:
- 一个来源，
- 处理步骤，
- 这是一个可以提供给模型使用的名称。
数据管道架构需要考虑很多因素。要了解更多关于数据管道及其架构的信息，请阅读本文。
以下是您应该考虑用于数据处理和数据管道的一些工具:
这个由 Twitter 构建的开源数据编排器以可靠的方式对无界数据流进行批处理。它消耗数据流，并以任意复杂的方式处理这些数据流，在每个计算阶段之间重新划分数据流。
用于机器学习、分析和 ETL(提取、转换、加载)的数据编排器。它允许您根据称为实体的逻辑组件之间的数据流来定义管道。这些管道都是在本地建设的，可以在任何地方运行。
这种开源且灵活的内存框架可作为 map-reduce 的替代方案，用于处理批处理、实时分析和数据处理工作负载。
专题报道
开发一个 ML 管道不同于开发软件，主要是从数据的角度。数据或特性的质量与代码的质量一样重要。多亏了特征库，我们可以重用特征，而不是为不同的模型重新构建它们。这种自动化是 MLOps 的重要组成部分。
该特征库构建库以下列概念为中心:
- ETL:创建数据管道的中心框架。基于 Spark 的提取、转换和加载模块随时可用。
- 声明式特征工程:关心你要计算什么，而不是如何编码。
- 特征库建模:该库轻松提供您处理和加载数据到特征库所需的一切。
这个开源、易于使用的特征库是将分析数据用于模型训练的最快途径。主要特点是:
- 它调用您的离线数据，以便可以进行实时预测，而无需自定义管道。
- 通过保证在训练和推理过程中输入相同的数据，它消除了训练服务偏差。
- 它重用现有的基础设施，并在需要时旋转新的资源，因为它运行在云管理的服务之上。
Fig: Workflow with Feast [Source]
Amazon SageMaker 功能商店是一个专门构建的存储库，您可以在其中存储和访问功能，因此在团队之间命名、组织和重用功能更加容易，无需编写额外的代码或创建手动流程来保持功能的一致性。
Fig: Other features of Amazon SageMaker [Source]
存储时间序列数据的另一个显著特征。这个开源、方便、基于 Python 的功能库提供了:
- 类似熊猫的数据和功能界面，
- 每个特征的时间序列，
- 用于元数据存储的数据库，
- 每个名称空间的数据存储位置，
- 与 Jupyter 笔记本等流行工具兼容。
模型开发
模型注册表
构建 ML 模型的核心思想是不断改进模型，这就是为什么 MLOps 增加了另一个关键的连续性支柱，称为持续培训(除了持续集成和持续发展)。模型注册中心通过维护模型血统、源代码版本和注释来帮助您完成这项任务。以下是您可以用来存储这些信息的一些工具及其主要功能，以帮助您进行选择:
- 与团队分享 ML 模型。
- 从实验、在线测试、生产等等一起工作。
- 与批准和治理工作流集成。
- 监控 ML 部署及其性能。
Fig: MLflow workflow. [Source]
- 使用软件即服务，无需在硬件上部署。
- 与所有工作流程轻松集成。
- 笔记本版本和差异。
- 生产的目录模型。
- 将元数据(如培训指标)与模型相关联。
- 管理模型版本和模型的批准状态。
- 使用 CI/CD 自动进行模型部署。
Fig: CI/CD pipeline of SageMaker showcasing the importance of model registry. [Source]
模特培训
在不了解 OpenCV 和 T2 Scikit-learn 的情况下，人们不会开始一个计算机视觉项目。模型建造中的一些火炬手是 TensorFlow 、 PyTorch 和 Keras 。您可以根据项目或您的兼容性选择其中的任何一个。如果你在为你的计算机视觉项目选择合适的框架方面有困难，请看看这个博客。
如果您对构建自己的模型或微调流行模型不感兴趣，这里有一些带有预训练模型的计算机视觉平台，您可能会觉得有用:
- Google Cloud 的 Vision API 通过 REST 和 RPC APIs 提供了强大的预训练机器学习模型。
- 为图像分配标签，并快速将它们分类到数百万个预定义的类别中。
- 检测物体和人脸，阅读印刷和手写文本，并将有价值的元数据构建到您的图像目录中。
- PyTorch 实现和自我监督视觉变压器的预训练模型。
- 该模型可以发现和分割图像或视频中的对象，完全没有监督，也没有给定分割目标。
- 特征很容易解释，表明这类模型能够更好地理解图像
- 识别图像和视频中的对象、人物、文本、场景和活动，以及检测任何不适当的内容
- 提供基于亚马逊收集的数据的算法
- 您可以构建可在自定义数据集上训练的算法。
元数据管理
当您的 ML 管道的每个组件做出决定时，它会传递给下一个组件。元数据存储、存储和检索这些决策、使用的超参数以及在不同步骤使用的数据。以下是一些可以用作元数据存储的库:
Neptune 支持许多不同类型的模型构建元数据的日志和显示，比如度量和损失、参数和模型权重等等。你可以看看他们的现场笔记本了解更多。
SiaSearch 是一个基于元数据高效探索视觉数据的平台。它简化了数据识别和困难搜索，有助于提高效率。它的一些特点是:
- 通过自动创建自定义间隔属性来结构化数据。
- 使用自定义属性进行查询，查找罕见的边缘案例，并整理新的训练数据。
- 轻松保存、编辑、版本化、注释和与同事共享帧序列。
- 使用自定义属性可视化数据并分析模型性能。
Fig: Features of SiaSearch. [Source]
MLMD 在其数据库中登记了以下类型的元数据:
- 在您的 ML 管道的各个步骤中生成的工件。
- 关于这些组件执行的元数据。
- 血统信息。
超参数调谐
超参数调整为您提供了 ML 模型的最佳版本。如果你想知道关于超参数的重要性以及优化它们的不同方法，看看 Tanay Agrawal 的这本书。以下是可用于超参数调整的工具的简要列表:
Hyperopt 让用户描述搜索空间。通过提供更多关于你的函数在哪里定义的信息，以及你认为最好的值在哪里，你允许 Hyperopt 中的算法更有效地搜索。
Dask-ML 类为超参数优化中最常见的两个问题提供了解决方案:
- 当超参数搜索受到存储器限制时，
- 或者当搜索受到计算限制时。
这种高度模块化的超参数优化框架允许用户动态构建搜索空间。Optuna 的一些主要特点是:
- 轻量级架构，
- Pythonic 搜索空间，
- 易于并行化。
版本控制
版本控制，也称为源代码控制，跟踪和管理源代码的更改。它使团队能够工作并为相同的代码做出贡献。目前， GitHub 和 GitLab 是版本控制事实上的标准。在使用大量数据进行计算机视觉项目时，您可能会遇到 Git 的问题，因为它只是为了版本化应用程序代码而设计的，而不是为了存储大量数据，也不支持 ML 管道。 DVC 解决了这个问题，也致力于应用程序代码版本化。如果你觉得 DVC 在这件事上太死板，有更好的用户界面和更多的功能，比如可以随时看到团队的进展，那么使用 Neptune 可以证明是一个很大的优势。
看看 Neptune 与数据版本控制相比如何
操作化
模型服务
模型服务通常是 ML 模型管道的最后一步。创建 CV 模型后，您必须决定在哪里部署您的模型，也就是说，您将使用哪个平台来服务您的模型？您可以选择本地服务器，但这可能会变得非常昂贵，并且难以大规模管理。以下是模型服务的一些工具:
- 膨润土
服务、管理和部署机器学习模型的框架。BentoML 的一些关键特性包括:
- 支持多种 ML 框架，如 PyTorch、Tensorflow 和等等。
- 使用 Docker、Kubernetes、OpenShift 等进行生产部署的容器化模型服务器。
- 最佳在线服务性能的自适应微批处理。
阅读快速入门指南了解更多关于 BentoML 的基本功能。你也可以在 Google Colab 上试试。
为生产环境设计的机器学习模型的灵活系统。一些关键特征是:
- 允许在不更改代码的情况下部署新的模型版本。
- 支持许多 servables。
- 可服务的大小和粒度是灵活的。
Fig: Serve models in production with TensorFlow Serving [Source]
它专注于解决任何机器学习项目中的最后一步，以帮助公司将模型投入生产，解决现实世界的问题，并实现投资回报的最大化。
- 为基于任何开源或商业模型构建格式构建的模型提供服务。
- 它可以处理成千上万的生产机器学习模型。
- 使用预先打包的推理服务器、定制服务器或语言包装器，提供一种简单的方法来容器化定制 ML 模型。
CI/CD/CT
与软件应用程序不同，ML 中的训练数据起着至关重要的作用。没有训练就不能测试模型的有效性。这就是为什么通常的 CI/CD 过程在 ML 开发中通过增加持续培训而得到增强。这里是我能找到的在你的机器学习管道中实现 CI/CD 的一些最好的库:
CML 可用于自动化部分开发工作流程，包括模型训练和评估、跨项目历史比较 ML 实验，以及监控数据集。
Fig: on every pull request, CML helps you automatically train and evaluate models, then generates a visual report with results and metrics, like the report above [Source]
- 循环
CircleCI 可以配置为使用复杂的缓存、docker 层缓存、用于在更快的机器上运行的资源类以及性能定价来高效地运行复杂的管道。
Fig: Overview of CircleCI [Source]
Travis CI 是一个托管的持续集成服务，用于构建和测试项目。它在您的硬件上提供专有版本的定制部署。
监视
模型监控允许您在生产中不断调整和改进您的模型。在高度发展的 MLOps 工作流中，这应该是一个活动的过程。监控有三个方面:
- 技术/系统监控检查模型基础设施是否得到正确服务。
- 模型监控不断验证预测的准确性。
- 业务绩效监控归结于模型是否对业务有帮助。监控版本变化的影响是必要的。
我将分享四个你可以用来监控生产的工具。如果您正在寻找更广泛的 ML 监控工具列表，请访问本文。
这是监控你的模型的最轻便的工具之一。它可以版本化、存储、组织和查询模型，以及模型开发元数据。以下是使其独一无二的一些特征:
- 它通过在仪表板中过滤、排序和分组模型训练运行，帮助您更好地组织您的工作。
- 它帮助您比较表格中的指标和参数，自动发现运行和异常之间的变化。
- 整个团队可以跟踪在脚本中执行的实验，并在任何基础设施(云、笔记本电脑、集群)上执行。
Fiddler 帮助您监控模型性能，解释和调试模型预测，分析整个数据和切片的模型行为，大规模部署机器学习模型，以及管理您的机器学习模型和数据集。
Fig: Features fiddler helps with monitoring [Source]
显然有助于在生产中分析机器学习模型或进行验证。
Fig: Example of an interactive report generated by evidently to help analyze, monitor, and debug [Source]
SageMaker 中的一个工具，通过自动检测和警告生产中部署的模型的不准确预测，帮助您维护高质量的机器学习模型。
自动化
到目前为止，我已经讨论了可以用于 ML 管道的一个或几个组件的库和工具。但是，如果您热衷于从收集和管理数据到在生产中部署和监控数据的整个流程的自动化，也有工具可以做到这一点！
我们将研究两种类型的自动化及其相关工具:
AutoML
各种 AutoML 框架自动化了机器学习生命周期的各个步骤。我管理的列表是将用户从算法选择和超参数调整中解放出来的工具，并构建一个准备部署的模型。
这是一个将计算机视觉应用于特定场景的端到端平台。
- 为特定领域定制和嵌入最先进的计算机视觉图像分析。
- 在云中或容器边缘运行自定义视觉。
- 依靠企业级安全性和隐私保护您的数据和任何训练有素的模型。
AutoML Vision 使您能够训练机器学习模型，根据您自己定义的标签对您的图像进行分类。
- 从标记的图像中训练模型并评估它们的性能。
- 对带有未标记图像的数据集利用人工标记服务。
- 注册通过 AutoML API 提供服务的训练模型。
TPOT 是一个基于树的管道优化工具，它使用遗传算法来优化机器学习管道。
- 它建立在 scikit-learn 之上，使用它的回归器和分类器方法。
- 它需要一个干净的数据集。
- 它进行特征处理、模型选择和超参数优化，以返回性能最佳的模型。
Fig: an example machine learning pipeline devised by TPOT [Source]
Auto-sklearn 是一个自动化的机器学习工具包。它是 scikit-learn 估计器的替代产品。需要记住的一些事情是:
- 它使用简单，代码最少。举例。
- Auto-sklearn 库适用于中小型数据集，不适用于大型数据集。
- 它没有训练先进的深度学习模型，这些模型可能在大型数据集上表现良好。
Fig: Auto-sklearn pipeline [Source]
MLBox 是一个强大的自动化机器学习 Python 库。它的一些功能包括:
- 快速阅读和分布式数据预处理。
- 稳健的特征选择和泄漏检测。
Fig: representation of how MLBox works [Source]
MLOps 自动化
Algorithmia 是一个基于企业的 MLOps 平台，可加速您的研究并快速、安全且经济高效地交付模型。
- 您可以安全地部署、服务、管理和监控您的所有机器学习工作负载。
- 它使用自动化机器学习管道进行版本控制、自动化、日志记录、审计和容器化。您可以轻松访问 KPI、性能指标和监控数据。
- 它的功能将向您清楚地展示风险、合规性、成本和性能。
Fig: How Algorithmia operates [Source]
Kubeflow 是一个开源和免费的机器学习 Kubernetes-native 平台，用于开发、编排、部署和运行可扩展和可移植的机器学习工作负载。
Azure ML 是一个基于云的平台，可以用来训练、部署、自动化、管理和监控你所有的机器学习实验。它有自己强大的开源平台 MLOps 平台，简化了 ML 的创建和部署。要了解更多，请访问 Azure 的文档。
Fig: Features of Azure Machine Learning [Source]
Gradient 为模型开发、协作和部署提供了轻量级的软件和基础设施。gradient 提供的一些服务包括:
- 自动化版本控制、标签和生命周期管理的全面再现性。
- 自动化流水线:梯度作为机器学习的 CI/CD。
- 即时可扩展性:并行训练，轻松扩展部署的模型。
Fig: Workflow of Gradient [Source]
结论
总之，在生产中实现您的计算机视觉项目并不意味着只将模型作为 API 部署到生产中。
相反，它意味着部署一个 ML 管道，这个管道在不同的阶段是自动化的，并且有助于更快地改进您的模型。设置 CI/CD 系统使您能够自动测试和部署新的管道实现。
该系统将帮助您应对数据和业务的快速变化。这并不意味着你会立即将所有的过程从一个层次转移到另一个层次。不要操之过急！您应该逐步实施这些实践来帮助提高您的 ML 系统开发和生产的自动化。
资源
文章
书
录像
松弛的
网站*
最佳 MLOps 工具以及如何评估它们
原文：https://web.archive.org/web/https://neptune.ai/blog/best-mlops-tools
在我们的一篇文章中——机器学习团队实际使用的最好的工具、库、框架和方法——我们从 41 家 ML 初创公司学到的东西——Acerta 的 CTO Jean-Christophe Petkovich 解释了他们的 ML 团队如何接近 MLOps。
据他所说，一个完整的 T2 系统有几个组成部分:T3
- 您需要能够构建包含预处理数据和生成结果所需的所有信息的模型工件。
- 一旦您能够构建模型工件，您必须能够跟踪构建它们的代码，以及它们被训练和测试的数据。
- 您需要跟踪所有这三样东西，模型、它们的代码和它们的数据，是如何关联的。
- 一旦您可以跟踪所有这些内容，您还可以将它们标记为准备就绪，进行生产，并通过 CI/CD 流程运行它们。
- 最后，为了在该过程的最后实际部署它们，您需要某种方法来基于该模型工件旋转服务。
这是对如何在公司中成功实施 MLOps 的高度概括。但是了解高层需要什么只是拼图的一部分。另一个是采用或创建适当的工具来完成工作。
这就是为什么我们编制了一份最佳 MLOps 工具的清单。我们将它们分为六类，以便您根据自己的需求选择合适的工具。让我们开始吧！
几乎在所有的 ML 工作流程中，您都想知道您的模型是如何构建的，尝试了哪些想法，或者在哪里可以找到所有打包的模型。
为此，您需要跟踪所有的模型构建元数据和训练模型，如超参数、指标、代码和数据集版本、评估预测、打包模型等。
根据您的模型元数据问题是在研究方面还是在产品化方面，您可以选择更具体的解决方案:实验跟踪工具、模型注册中心，或者一个 ML 元数据存储。
无论如何，在考虑元数据存储和管理工具时，您应该考虑:
- 一般业务相关的东西:定价模式、安全性和支持
- 设置:需要多少基础设施，插入您的工作流程有多容易
- 灵活性、速度和可访问性:你能定制元数据结构吗？它能从你的语言/框架/基础设施中访问吗？它对你的工作流来说足够快和可靠吗？
- 模型版本化、沿袭和打包:你能版本化和复制模型和实验吗？你能看到下游使用的数据/模型/实验的完整模型谱系吗？
- 元数据的记录和显示:API 和 UI 支持哪些元数据类型？你能渲染音频/视频吗？你从你的框架中获得了什么？
- 对比和可视化实验和模型:支持哪些可视化，是否有平行坐标图？可以对比图像吗？你能调试系统信息吗？
- 组织和搜索实验、模型和相关元数据:你能在工具中以一种干净的方式管理你的工作流程吗？你能根据自己的需要定制用户界面吗？能轻松找到实验和模型吗？
- 模型评审、协作和共享:在转移到生产之前，您能自动和手动地批准模型吗？你能和你的团队一起评论和讨论实验吗？
- CI/CD/CT 兼容性:它与 CI/CD 工具的兼容性如何？它支持持续培训/测试(CT)吗？
- 集成和支持:它是否与您的模型培训框架相集成？你能在编排和管道工具中使用它吗？
根据您的模型元数据问题是在研究方面还是在产品化方面，您可能希望进行比较并选择更具体的解决方案:
记住这一点，让我们来看看其中的一些工具。
Neptune 是一个 ML 元数据存储库，为运行许多实验的研究和生产团队而构建。
您可以记录和显示几乎任何 ML 元数据,从超参数和度量到视频、交互式可视化和渲染的 jupyter 笔记本。
它有一个灵活的元数据结构，允许你以你想要的方式组织培训和生产元数据。您可以将它想象成一个字典或文件夹结构，您用代码创建并显示在 UI 中。
web UI 是为管理 ML 模型元数据而构建的，它允许您:
你可以通过易于使用的 API 和 25+ 与来自 ML 生态系统的工具集成，从 ML 元数据存储中记录和查询元数据。
如果您想知道它是否适合您的工作流程:
但是如果你和我一样，你会想先把它和这个领域的其他工具比如 MLflow，TensorBoard，wandb 或者 comet 进行比较。这里有许多更深入的逐个特性的比较以使评估更容易。
海王——概要:
- 灵活的类似文件夹的元数据结构
- 高度可定制的 UI，用于搜索、显示、比较和组织 ML 元数据
- 易于使用的 API，用于记录和查询模型元数据，以及与 MLOps 工具的 25 种集成
- 提供托管和本地版本
- 协作功能和组织/项目/用户管理
MLflow 是一个开源平台，帮助管理整个机器学习生命周期，包括实验、再现性、部署和中央模型注册。
MLflow 适合个人和任何规模的团队。
该工具与库无关。你可以用任何机器学习库和任何编程语言来使用它。
MLflow 包括四个帮助跟踪和组织实验的主要功能:
- ml flow Tracking——一个 API 和 UI，用于在运行机器学习代码时记录参数、代码版本、指标和工件，并在以后可视化和比较结果
- MLflow 项目——将 ML 代码打包成可重用、可复制的形式，以便与其他数据科学家共享或转移到生产中
- MLflow 模型——从不同的 ML 库中管理和部署模型到各种模型服务和推理平台
- MLflow Model Registry–一个中央模型存储库，用于协作管理 ml flow 模型的整个生命周期，包括模型版本控制、阶段转换和注释
检查ml flow&海王星之间的对比
Comet 是一个元机器学习平台，用于跟踪、比较、解释和优化实验和模型。它允许你在一个地方查看和比较你所有的实验。无论你在哪里用任何机器学习库运行你的代码，对于任何机器学习任务，它都能工作。
comet适合团队、个人、学者、组织以及任何想要轻松可视化实验、方便工作和运行实验的人。
这颗彗星最显著的一些特征包括:
- 团队共享工作:团队共享的多种特性
- 与现有的 ML 库配合良好
- 处理用户管理
- 让您比较实验——代码、超参数、度量、预测、依赖性、系统度量等等
- 允许您通过视觉、音频、文本和表格数据的专用模块可视化样品
- 有许多集成，可以轻松地将其连接到其他工具
查看彗星&海王星之间的对比
数据和管道版本控制
如果您关心再现性，数据和管道版本控制工具将对您的工作流程至关重要。
在数据方面，它们帮助您获得工件的版本，数据集或模型的散列，您可以在以后使用它来识别和比较。通常，您会将此数据版本记录到您的元数据管理解决方案中，以确保您的模型训练是版本化的和可重复的。
通过记录管道每个节点的输入/输出，您可以在管道中使用工件版本。通过这样做，您也可以对管道执行进行版本控制。
要为您的工作流选择一个好的数据/管道版本工具，您应该检查:
- 对您的数据形态的支持:它如何支持视频/音频？它是否为表格数据提供了一些预览？
- 易用性:在你的工作流程中使用起来有多容易？它给你的执行增加了多少开销？
- Diff and compare: 可以比较数据集吗？你能看到你的图像目录的不同吗？
这里有几个值得检查的工具。
DVC，或数据版本控制，是一个机器学习项目的开源版本控制系统。这是一个实验工具，帮助你定义你的管道,不管你使用什么语言。
当您在 ML 模型的前一版本中发现问题时，DVC 通过利用代码、数据版本化和可再现性来帮助节省时间。您还可以训练您的模型，并通过 DVC 管道与您的队友分享。
DVC 可以处理大量数据的版本和组织，并以一种组织良好、易于访问的方式存储它们。它专注于数据和管道版本化和管理，但也有一些(有限的)实验跟踪功能。
DVC——概要:
- 可以使用不同类型的存储—不受存储限制
- 完整的代码和数据来源有助于跟踪每个 ML 模型的完整发展
- 通过始终如一地维护输入数据、配置和最初用于运行实验的代码的组合来实现可重复性
- 跟踪指标
- 一种将 ML 步骤连接到 DAG 并端到端运行整个管道的内置方式
检查 DVC &海王星比较
Pachyderm 是一个将数据谱系与 Kubernetes 上的端到端管道相结合的平台。
它有三个版本，社区版(开源，可以在任何地方使用)、企业版(完整的版本控制平台)和中心版(仍是测试版，它结合了前两个版本的特点)。
您需要将 Pachyderm 与您的基础架构/私有云相集成。
由于在本节中我们讨论的是数据和管道版本，所以我们将讨论这两者，但除此之外还有更多内容(查看网站了解更多信息)。
谈到数据版本化，Pachyderm 数据版本化系统有以下几个主要概念:
- 存储库–厚皮动物存储库是最高级别的数据对象。通常，Pachyderm 中的每个数据集都有自己的存储库
- 提交–回购在特定时间点的不可变快照
- 分支–特定提交的别名或指针，在提交新数据时自动移动
- 文件–文件和目录是存储库中的实际数据。Pachyderm 支持任何类型、大小和数量的文件
- 出处——表达各种提交、分支和存储库之间的关系。它帮助您跟踪每个提交的来源
如果 MLOps 工作流的数据和管道版本控制部分对您很重要，请查看数据版本控制工具的更深入的比较。
超参数调谐
如果你想从你的模型中获得好的性能，而你不能仅仅给它更多的训练数据，你必须调整超参数。您可以使用随机搜索或贝叶斯优化方法手动完成。
许多工具都可以帮助您，但是要选择一个适合您的工具，请考虑:
- 易用性和 API :将其连接到您的代码库有多容易？您能在您的分布式基础设施中运行它吗？
- 支持的优化方法:可以动态构建搜索空间吗？它支持 TPE 吗？它有像 BOHB 那样的基于树的代理模型吗？
- 支持修剪、重启和异常处理:你能在没有希望的试验上提前停止吗？你能从检查站开始吗？当参数配置试验失败时会发生什么？
- 速度和并行化:在一台或多台机器上分配培训有多容易？
- 可视化和调试功能:你能可视化扫描吗？可以对比参数配置吗？它是否容易连接到监控/跟踪工具？
我们来看几个选项。
Optuna 是一个自动超参数优化框架，既可以用于机器学习/深度学习，也可以用于其他领域。它有一套最先进的算法，你可以选择(或连接)，它是非常容易的分布训练到多台机器，并让你很好地可视化你的结果。
它集成了流行的机器学习库，如 PyTorch、TensorFlow、Keras、FastAI、scikit-learn、LightGBM 和 XGBoost。
——概要:
- 支持在一台机器(多进程)和一个集群(多节点)上进行分布式培训
- 支持各种修剪策略，以更快地收敛(并使用更少的计算)
- 拥有一套强大的可视化工具，如平行坐标、等高线图或切片图
检查 Neptune-Optuna 集成，让您记录并实时监控 Optuna 超参数扫描。
SigOpt 旨在加速和放大机器学习、深度学习和模拟模型的影响。它有助于通过自动化过程节省时间，使其成为超参数调整的合适工具。
您可以将 SigOpt 无缝集成到任何模型、框架或平台中，而无需担心您的数据、模型和基础架构——一切都是安全的。
该工具还可以让你监控、跟踪和分析你的优化实验 以及可视化它们。
SigOpt——概要:
- 多指标优化便于同时探索两个不同的指标
- 条件参数允许定义和调整架构参数，并自动选择模型
- 高并行性使您能够充分利用大规模计算机基础设施，并在多达 100 名工作人员中运行优化实验
运行流程编排和工作流管道
当您的工作流有多个可以单独执行的步骤(预处理、培训、评估)时，您将受益于工作流管道和编排工具。
这些工具将帮助您:
- 按照正确的顺序执行步骤
- 将执行抽象到任何基础设施
- 确保每个步骤在开始运行之前都有来自其他步骤的所有输入
- 通过保存/缓存中间步骤的输出并只运行那些必须运行的输出，加速管道执行
- 重试/重新运行失败的步骤，而不使整个管道崩溃
- 基于时间(每周)或事件(每次合并到主分支)调度/触发管道执行
- 可视化管道结构和执行
让我们回顾一下其中的一些工具。
Kubeflow 是 Kubernetes 的 ML 工具包。它通过打包和管理 docker 容器来帮助维护机器学习系统。它通过使机器学习工作流的运行编排和部署更容易来促进机器学习模型的扩展。
这是一个开源项目,包含一组特定于各种 ML 任务的兼容工具和框架。
您可以使用 Kubeflow 管道来克服长时间的 ML 培训工作、手动实验、再现性和 DevOps 障碍。
kube flow——概要:
- 用于管理和跟踪实验、作业和运行的用户界面(UI)
- 使用 SDK 与系统交互的笔记本电脑
- 重用组件和管道来快速创建端到端解决方案，而不必每次都重新构建
- Kubeflow Pipelines 可作为 Kubeflow 的核心组件或独立安装使用
Polyaxon 是一个平台，用于复制和管理机器学习项目的整个生命周期，以及深度学习应用的整个生命周期。
该工具可以部署到任何数据中心、云提供商，并且可以由 Polyaxon 托管和管理。它支持所有主要的深度学习框架，如 Torch、Tensorflow、MXNet。
说到流程编排，Polyaxon 允许您通过 CLI、dashboard、SDK 或 REST API 调度作业和实验，从而最大限度地利用集群。
多轴 — 概要:
- 支持整个生命周期，包括运行流程编排，但可以做的远不止这些
- 有一个开源版本，您可以立即使用，但也为企业提供了选项
- 文档非常完整的平台，包括技术参考文档、入门指南、学习资源、指南、教程、变更日志等等
- 允许使用 experiment insights 仪表板监控、跟踪和分析每个优化实验
检查多轴&海王星之间的比较
Airflow 是一个开源平台，允许您使用 web 应用程序来监控、调度和管理您的工作流。它提供了对已完成和正在进行的任务状态的了解，以及对日志的了解。
Airflow 使用有向无环图(Dag)来管理工作流编排。该工具是用 Python 编写的，但是您可以将其用于任何其他语言
气流——概要:
- 易于与您当前的基础架构一起使用—与 Google 云平台、Amazon Web Services、Microsoft Azure 和许多其他服务集成
- 您可以可视化生产中运行的管道
- 它可以帮助您管理任务之间不同的相关性
这个工作流编排工具基于 Python。您可以创建可重复、可维护和模块化的工作流程，使您的 ML 流程更简单、更准确。Kedro 将软件工程集成到机器学习环境中，其中包含模块化、关注点分离和版本控制等概念。
它基于 Cookiecutter 数据科学 提供了一个标准的、可修改的项目模板。数据目录处理一系列轻量级数据连接器，用于跨许多不同的文件格式和文件系统保存和加载数据。
凯德罗——概要:
- 通过管道抽象，您可以自动化 Python 代码和工作流可视化之间的依赖关系。
- Kedro 支持单机或分布式机器部署。
- 主要焦点是创建可维护的数据科学代码，以解决 Jupyter 笔记本、一次性脚本和胶水代码的缺点。
- 这个工具使得不同层次的团队协作更加容易，并且通过模块化、可重用的代码在编码环境中提供效率。
检查 Kedro-Neptune integration ，它允许您过滤、比较、显示和组织管道和节点中生成的 ML 元数据。
如果你想回顾更多的框架，请阅读我们的管道编排工具的深度比较。
模型部署和服务
希望您的团队已经有了生产中的模型，或者您即将部署它们。太棒了！但是，正如你现在可能知道的，生产围绕 ML 模型的可操作性提出了它的挑战。
您遇到的第一批问题是如何打包、部署、服务和扩展基础架构以支持生产中的模型。模型部署和服务工具对此有所帮助。
选择工具时，您应该考虑:
- 与您的模型打包框架和模型打包实用程序的兼容性
- 基础设施扩展能力
- 支持各种部署场景:金丝雀、A/B 测试、挑战者与冠军
- 集成和支持生产模型监控框架或内置监控功能
这里有一些模型部署和服务工具。
BentoML 简化了构建机器学习 API 端点的过程。它提供了一个标准，但是简化的架构来将训练好的 ML 模型移植到生产中。
它让你打包训练好的模型，使用任何 ML 框架来解释它们，以服务于生产环境。它支持在线 API 服务和离线批处理服务。
BentoML 有一个灵活的工作流和一个高性能的模型服务器。该服务器还支持自适应微批处理。UI 仪表板提供了一个集中的系统来组织模型和监控部署过程。
工作机制是模块化的，使配置可重用，服务器不停机。这是一个多用途的框架，解决了 ML 模型服务、组织和部署的问题。主要重点是连接数据科学和 DevOps 部门，以实现更高效的工作环境，并产生高性能的可扩展 API 端点。
BentoML — 概要:
- 支持高性能的模型服务、模型管理、模型打包和统一的模型格式。
- 支持部署到多个平台。
- 灵活的模块化设计。
- 不处理现成的水平缩放。
Cortex architecture diagram | Source
cortex是一个开源的替代方案，可以通过 SageMaker 或在 AWS 服务如 Elastic Kubernetes Service (EKS)、Lambda 或 Fargate 和开源项目如 Docker、Kubernetes、TensorFlow Serving 和 TorchServe 之上构建自己的模型部署平台。
这是一个多框架工具，允许您部署所有类型的模型。
皮层 — 小结:
- 自动扩展 API 以处理生产工作负载
- 对任何 AWS 实例类型运行推理
- 在单个 API 中部署多个模型，并在不停机的情况下更新已部署的 API
- 监控 API 性能和预测结果
Seldon 是一个开源平台，允许你在 Kubernetes 上部署机器学习模型。它在云中和内部都可用。
谢顿——概要:
- 利用 canary deployment 等各种选项简化模型部署
- 出现问题时，使用警报系统监控生产中的模型
- 使用模型解释器来理解为什么会做出某些预测。谢顿还开源了一个模型解释器包 alibi
生产模型监控
如果您曾经“成功地”将模型部署到生产环境中，却发现它们产生了疯狂的结果，那么您知道监视生产模型是非常重要的，并且可以为您节省很多麻烦(和金钱)。如果没有，相信我的话。
模型监控工具可以通过以下方式让您了解生产中正在发生的事情:
- 监控输入数据漂移:你的模型得到的真实数据和训练数据有区别吗？
- 监控概念漂移:问题是否随着时间的推移而改变，你的模型性能在衰减？
- 监控硬件指标:该型号的功耗是否明显高于之前的型号？
选择模型监控工具时，您应该考虑:
- 易于集成:将其连接到您的模型服务工具有多容易
- 服务开销:日志记录给模型部署基础设施带来了多少开销
- 监控功能:是否监控数据/特征/概念/模型漂移？你能比较同时运行的多个模型吗(A/B 测试)？
- 警报:出现问题时，它会自动发出警报吗？
这里有你可以选择的。
亚马逊 SageMaker 模型监视器是亚马逊 SageMaker 平台的一部分，它使数据科学家能够构建、训练和部署机器学习模型。
谈到亚马逊 SageMaker 模型监视器，它可以让你自动监控生产中的机器学习模型，并在数据质量问题出现时提醒你。
该工具有助于节省时间和资源，因此您和您的团队可以专注于结果。
亚马逊 SageMaker 模型监视器—摘要:
- 在任何端点上使用该工具—当使用内置算法、内置框架或您自己的容器训练模型时
- 使用 SageMaker SDK，您可以捕获预测或发送到端点的数据的可配置部分，并将其存储在您的亚马逊简单存储服务(S3)桶中。元数据丰富了捕获的数据，您可以像保护任何 S3 对象一样保护和访问这些数据。
- 启动监视计划并接收报告，这些报告包含最新时间段内收到的数据的统计信息和模式信息，以及检测到的任何违规
Fiddler 是一个模型监控工具，它有一个用户友好的、清晰的、简单的界面。它允许您监控模型性能，解释和调试模型预测，分析整个数据和切片的模型行为，大规模部署机器学习模型，以及管理您的机器学习模型和数据集
Fiddler ML–摘要:
- 性能监控—一种直观的方式来探索数据漂移，并确定哪些数据正在漂移、何时漂移以及如何漂移
- 数据完整性—确保没有不正确的数据进入您的模型，并且不会对最终用户体验产生负面影响
- 跟踪异常值 —Fiddler 在异常值检测选项卡中显示单变量和多变量异常值
- 服务指标—让您基本了解生产中 ML 服务的运行状况
- Alerts —Fiddler 允许您为项目中的一个模型或一组模型设置警报，以警告生产中的问题
总的来说，它是一个监控机器学习模型的伟大工具，具有所有必要的功能。
Hydrosphere 是一个用于管理 ML 模型的开源平台。Hydrosphere Monitoring 是其模块，允许您实时监控您的生产机器学习。
它使用不同的统计和机器学习方法来检查你的生产分布是否与训练分布相匹配。它支持外部基础设施，允许您将 Hydrosphere 外部托管的模型连接到 Hydrosphere Monitoring，以监控其质量。
水圈监测—总结:
- 通过统计漂移检测，监控数据中的各种统计数据如何随时间变化
- 复杂的数据漂移可以通过水圈多元数据监控来检测
- 使用自定义 KNN 度量或自定义隔离林度量监控异常
- 它支持表格、图像和文本数据
- 当您的指标发生变化时，您会收到通知，以便能够快速响应
显然是一个开源的 ML 模型监控系统。它有助于在开发、验证或生产监控期间分析机器学习模型。工具从熊猫数据帧生成交互式报告。
目前，有 6 种报告可供使用:
- 数据漂移:检测特征分布的变化
- 数字目标漂移:检测数字目标和特征行为的变化
- 分类目标漂移:检测分类目标和特征行为的变化
- 回归模型性能:分析回归模型的性能和模型误差
- 分类模型性能:分析分类模型的性能和错误。适用于二进制和多类模型
- 概率分类模型性能:分析概率分类模型的性能、模型校准质量和模型误差。适用于二进制和多类模型
把它包起来
现在您已经有了最佳工具的列表，您“只”需要弄清楚如何让它在您的设置中工作。
一些资源可以帮助你做到这一点:
如果您想讨论如何设置 MLOps 堆栈，我很乐意提供帮助。
联系我 jakub.czakon@neptune.ai，看看我能做些什么！
你应该知道的最好的开源 MLOps 工具
原文：https://web.archive.org/web/https://neptune.ai/blog/best-open-source-mlops-tools
你不需要在 MLOps 工具上花很多钱，就能把 DevOps 的魔力带到你的机器学习项目中。有大量开源工具可供选择。当你试图解决独特的问题，并且需要一个可以依赖的社区时，这是一个很好的解决方案。但是也有一些倾向于开源工具。
- 首先，要小心——开源工具并不总是 100%免费的。例如，Kuberflow 有客户端和服务器组件，并且都是开放的。然而，有些工具可能只开放其中一个组件的源代码。客户端是开放的，但是供应商控制着服务器端的一切。
- 免费的开源工具也会让你在其他方面付出代价。如果你考虑到你必须长期托管和维护这个工具，你会发现开源毕竟是非常昂贵的。
- 最后，如果出现问题，您可能无法依靠 24/7/365 的供应商支持。社区可以帮助你，但是很明显，他们对你留下的结果不负任何责任。
最终，开源工具可能会很棘手。在为您的项目选择工具之前，您需要仔细研究它的优缺点。此外，您需要确保这些工具能够与您的堆栈的其他部分很好地协作。这就是为什么我为模型开发过程的不同阶段准备了一个流行的和社区认可的 MLOps 工具的列表。
在这个列表中，你会发现成熟的机器学习平台，以及帮助你进行数据探索、部署和测试的专业工具。
成熟的平台
成熟的平台包含机器学习工作流程所有阶段的工具。理想情况下，一旦你有了一个成熟的工具，你就不需要设置任何其他的工具。实际操作中，要看你的项目需求和个人喜好。
1. Kubeflow
几乎就在 Kubernetes 确立了自己作为处理集群容器的标准之后，Google 创建了 T2 kube flow——一个开源项目，简化了在 Kubernetes 中处理 ML 的工作。它拥有这种编排工具的所有优势，从在任何基础设施上部署的能力到管理松散耦合的微服务，以及按需扩展。
这个项目是为开发人员谁想要部署可移植和可扩展的机器学习项目。谷歌不想再造其他服务。他们希望创建一个最先进的开源系统，可以与各种基础设施(从超级计算机到笔记本电脑)一起应用。
视频
MLOps open-source tool: MLflow | Source
使用 Kuberflow，您可以受益于以下功能:
创建和定制 Jupyter 笔记本，立即查看运行代码的结果，创建交互式分析报告。
- 自定义张量流作业运算符
此功能有助于训练您的模型，并应用 TensorFlow 或 Seldon 核心服务容器将模型导出到 Kubernetes。
- 简化集装箱化
Kuberflow 消除了将代码容器化的复杂性。数据科学家可以在更短的时间内完成数据准备、培训和部署。
总而言之，Kuberflow 是一个用于端到端 ML 工作流开发和部署的成熟解决方案。
2.MLflow
MLflow 是一个开源平台，机器学习工程师可以通过实验、部署和测试来管理 ML 生命周期。当您想要跟踪模型的性能时，MLflow 就派上了用场。它就像一个仪表板，在这里您可以:
- 监控 ML 管道，
- 存储模型元数据，以及
- 挑选表现最好的型号。
MLOps open-source tool: MLflow | Source
目前，MLflow 提供了四个组件:
MLflow 跟踪组件是一个 API 和 UI，用于记录参数、代码版本、指标以及运行代码和可视化结果的输出文件。您可以使用 Python、REST、R API 和 Java APIs 进行日志和查询实验。你也可以记录结果。
MLflow 项目是 ML 团队以可重用和可复制的方式打包数据科学代码的工具。它附带了一个 API 和命令行工具来将项目连接到工作流中。它可以帮助你在任何平台上运行项目。
MLflow 模型可以轻松打包机器学习模型，供各种下游工具使用，如 Apache Spark。这样，在不同的服务环境中部署机器学习模型就更容易管理了。
总的来说，用户喜欢 MLflow，因为它易于在本地使用，无需专用服务器，并且有一个奇妙的 UI，您可以在其中探索您的实验。
网飞创建了 Metaflow 作为一个开源的 MLOps 平台，用于构建和管理大规模的企业级数据科学项目。数据科学家可以使用这个平台进行端到端的开发和部署他们的机器学习模型。
Metaflow 支持所有流行的数据科学库，如 TensorFlow 和 scikit-learn，因此您可以继续使用您最喜欢的工具。Metaflow 支持 Python 和 R，这使得它在库和包选择方面更加灵活。
- 强大的版本控制工具包
Metaflow 的优秀之处在于，它可以自动对你的所有实验进行版本化和跟踪。你不会丢失任何重要的东西，你甚至可以在笔记本上检查所有实验的结果。
如上所述，Metaflow 是专门为大规模机器学习开发而创建的。AWS 云为解决方案提供支持，因此如果您需要扩展，可以内置 AWS 的存储、计算和机器学习服务。您不必重写或更改代码来使用它。
4.MLReef
MLOps open-source tool: MLReef | Source
MLReef 是一个 MLOps 平台，供团队合作并分享他们的机器学习实验结果。项目是建立在可重用的 ML 模块之上的，这些模块可以由你或者社区来实现。这提高了开发速度，并通过促进并发性使工作流更加高效。
MLReef 提供了四个方向的工具:
您拥有一个完全版本化的数据托管和处理基础架构来设置和管理您的模型。
每个开发人员都可以访问容器化和版本化的脚本库，您可以在您的机器学习管道中使用它们。
您可以使用 MLReef 在项目的不同迭代中进行实验跟踪。
该解决方案可帮助您优化管道管理和流程编排，自动化日常任务。
此外，MLReef 欢迎任何规模的项目。新手可以将它用于小规模项目，有经验的开发人员可以将它用于小型、中型和企业项目。
如果你没有太多开发 ML 模型的经验，你会发现一个用户友好的界面和社区支持来解决你可能面临的任何问题。
MLReef 允许您在 Git 上构建项目，同时为您处理所有 DevOps 的混乱。您可以在自动化环境中轻松监控进度和结果。
MLReef for enterprise 易于在云中或内部进行扩展和控制。
总而言之，MLReef 是您 ML 项目的一个方便的框架。只需几个简单的设置，您就能够一砖一瓦地开发、测试和优化您的 ML 解决方案。
5. Kedro
Kedro 是一个 Python 框架，用于机器学习工程师和数据科学家创建可复制和可维护的代码。
如果你想组织你的数据管道并使 ML 项目开发更有效，这个框架是你最好的朋友。您不必在代码重写上浪费时间，并且将有更多的机会关注健壮的管道。此外，Kedro 帮助团队建立协作标准，以限制延迟并构建可伸缩、可部署的项目。
MLOps open-source tool: Kedro | Source
Kedro 有很多好的特性:
通常，你必须花很多时间去了解如何建立你的分析项目。Kedro 提供了一个标准模板，可以节省您的时间。
Kedro 将帮助您加载和存储数据，不再担心代码的可重复性和可伸缩性。
当你在处理复杂的软件系统时，这是一个必要的工具。如果您对配置管理不够重视，您可能会遇到严重的可靠性和可伸缩性问题。
Kedro 提倡一种数据驱动的 ML 开发方法，并在降低业务运营风险的同时维护行业标准。
如果您想利用组织良好的 Kedro 管道和强大的 Neptune UI 来组织和比较管道和节点中生成的 ML 元数据，请查看 Neptune-Kedro 插件。
MLOps 中的开发和部署工具可跨多个环境自动执行手动部署的日常任务。您可以通过更方便的工具进行部署，这取决于您使用的平台堆栈。
6.ZenML
MLOps open-source tool: ZenML | Source
ZenML 是一个 MLOps 框架，用于编排你的 ML 实验管道。它为您提供了以下工具:
ZenML 帮助您将原始数据转换成可供分析的数据。
在其他方便培训的工具中，该平台使用声明式管道配置，因此您可以在内部和云环境之间轻松切换。
ZenML 的创造者声称，该平台的主要好处是自动跟踪实验，并保证实验之间的可比性。
XML 致力于使 ML 开发对于个人开发人员和大型团队来说都是可重复和简单的。
这个框架让你摆脱了用传统工具交付机器学习模型的所有麻烦。如果您努力提供足够的实验数据来证明结果的可重复性，希望减少浪费并使代码的重用更简单，ZenML 将会有所帮助。
7.MLRun
MLRun 是 ML 模型开发和部署的工具。如果您正在寻找一种可以方便地在各种环境中运行并支持多种技术堆栈的工具，它绝对值得一试。MLRun 提供了管理数据管道的综合方法。
MLOps open-source tool: MLRun | Source
MLRun 具有分层架构，可提供以下强大功能:
- 功能和工件存储
这一层帮助您处理数据的准备和处理，并跨不同的存储库存储数据。
- 弹性无服务器运行时层
将简单的代码转换成易于扩展和维护的微服务。它与 Kubernetes jobs、Dask 和 Apache Spark 等标准运行时引擎兼容。
为了让您专注于训练模型和微调超参数，pipeline automation 工具可帮助您进行数据准备、测试和实时部署。你只需要提供你的监督来创建一个最先进的 ML 解决方案。
在这里，您可以访问统一的控制面板来管理您的整个工作流程。MLRun 有一个方便的用户界面、一个 CLI 和一个您可以在任何地方访问的 SDK。
使用 MLRun，您可以编写一次代码，然后使用自动化解决方案在不同的平台上运行它。该工具管理构建过程、执行、数据移动、缩放、版本控制、参数化、输出跟踪等等。
8.currentmodelogic 电流型逻辑的
CML (持续机器学习)是机器学习项目持续集成和交付(CI / CD)的库。该库是由 DVC 的创建者开发的，这是一个用于对 ML 模型和实验进行版本控制的开源库。CML 应该与 DVC、Tensorboard 和云服务一起，促进开发和实现 ML 模型到产品中的过程。
- 自动化管道建设
CML 被设计用来自动化 ML 工程师的一些工作，包括训练实验、模型评估、数据集以及它们的添加。
该工具被定位为支持数据科学项目 GitFlow 的库，允许自动生成报告，并隐藏使用外部服务的复杂细节。外部服务的例子包括云平台:AWS、Azure、GCP 等等。对于基础设施任务，也使用 DVC、docker 和 Terraform。最近，有一个 ML 项目的基础设施方面吸引了更多的注意力。
该库非常灵活，提供了广泛的功能；从发送报告和发布数据，到为项目分发云资源。
9.Cortex 实验室
Cortex Labs 是一家由伯克利科学家开发的早期创业公司。他们正在为神经科学家开发一种方便的工具，帮助他们理解大脑是如何工作的。这个应用程序的用途变得更加广泛。
Cortex Lab 项目很有趣，因为它允许您部署、管理和扩展容器，而不用担心 Kubernetes。它在 AWS 上将容器作为服务提供。
如果您决定将 Cortex 纳入您的技术体系，您将受益于以下特性:
Cortex 可以实时处理请求，并根据进行中的请求量自动扩展。
- 自动化集群管理
Cortex 使集群自动扩展变得容易。很容易用不同的参数创建集群。
- CI/CD 和可观察性集成
Cortex 允许您使用声明性配置创建供应集群。
Cortex Lab 旨在与 AWS 顺利集成。它运行在 EKS 之上，能够可靠、经济地扩展工作负载。您可以使用此工具来处理图像和视频处理的数据密集型模型。微服务架构使其易于扩展，没有任何资源限制。
10.塞尔顿核心
MLOps open-source tool: Seldon Core | Source
Seldon Core 是 Kubernetes 上 ML 模型部署的平台。这个工具可以帮助开发人员在一个健壮的 Kubernetes 环境中构建模型，具有定制资源定义等特性来管理模型图。您还可以将该工具与您的持续集成和部署工具合并。
Seldon core 可以将你建立在 TensorFlow、PyTorch、H2O 等框架上的模型转换成基于 REST/GRPC 的可扩展微服务架构。
- 监控模型性能
它将为您处理缩放，并为您提供测量模型性能、检测异常值和进行开箱即用的 A/B 测试的高级解决方案。
Seldon Core 可以夸耀通过持续维护和安全策略更新支持的系统的健壮性和可靠性。
Seldon Core 提供的优化服务器可以让你建立大规模的深度学习系统，而不必将其容器化或担心其安全性。
11.汽车经销商
AutoKeras 是一个用于自动机器学习(AutoML)的开源库。使用 AutoML 框架，您可以自动处理原始数据，选择机器学习模型，并优化学习算法的超参数。
- 简化 ML 模型开发
AutoML 减少了人类开发机器学习模型时出现的偏差和差异，并简化了机器学习模型的开发。
- 享受自动化超参数调谐
AutoKeras 是一种工具，它提供了自动匹配深度学习模型的架构和超参数的功能。
AutoKeras 最出名的是它的灵活性。在这种情况下，无论后端如何，您编写的代码都将被执行。它支持 Theano、Tensorflow 和其他框架。
AutoKeras 内部有几个训练数据集。它们已经以方便工作的形式放置，但它没有向您展示 AutoKeras 的全部功能。事实上，它包含了对文本、图片和时间序列进行适当预处理的工具。换句话说，最常见的数据类型，这使得数据准备过程更易于管理。该工具还具有内置的模型可视化功能。
12.H2O 汽车公司
视频
MLOps open-source tool: H2O Auto ML | Source
H2O.ai 是一个使用 AutoML 优化机器学习过程的软件平台。H2O 声称，该平台可以比 scikit-learn 等流行的机器学习库更快地训练模型。
H2O 是一个机器学习，预测数据分析平台，用于建立机器学习模型，并为它们生成 Java 和 Python 的生产代码，只需点击一个按钮。
- 实施现成的 ML 模型
它实现了监督和非监督算法，如 GLM 和 K-Means，以及一个易于使用的 web 界面，称为 Flow。
该工具对初学者和经验丰富的开发人员都有帮助。它为编码器配备了一个简单的包装器函数，用几行代码管理与建模相关的任务。经验丰富的 ML 工程师欣赏这一功能，因为它允许他们专注于其他更需要思考的建模过程(如数据探索和特征工程)。
总的来说，H2O 是解决机器学习和数据科学问题的强大工具。即使是初学者也能从数据中提取价值，建立稳健的模型。H2O 继续发展并发布新产品，同时保持全面的高质量。
数据有效性
数据验证是检查数据质量的过程。在此阶段，您要确保集合中没有不一致或缺失的数据。数据验证工具自动化了这一常规过程，并提高了数据清理的质量。
13.Hadoop
Hadoop 是一组可免费再分发的实用程序、库和框架，用于开发和执行在集群上运行的程序。这种存储和处理大数据的基础技术是 Apache 软件基金会的顶级项目。
该项目包括 4 个主要模块:
Hadoop Common 是一组基础设施软件库和实用程序，用于其他解决方案和相关项目，特别是用于管理分布式文件和创建必要的基础设施。
- HDFS 是一个分布式文件系统
Hadoop 分布式文件系统是一种在各种数据服务器上存储文件的技术，其地址位于一个特殊的名称服务器上。HDFS 为分布在计算集群节点之间的大文件提供可靠的逐块存储。
- YARN 是一个任务调度和集群管理系统
YARN 是一组系统程序，提供分布式应用程序的共享、可伸缩性和可靠性。
这是一个用于编程和执行分布式 MapReduce 计算的平台，使用许多计算机组成一个集群。
今天，Hadoop 中有一个完整的相关项目和技术生态系统，用于数据挖掘和机器学习。
14.火花
Apache Spark 帮助你处理半结构化的内存数据。Spark 的主要优势是性能和用户友好的编程界面。
该框架有五个组件:一个核心和四个库，每个解决一个特定的问题。
这是框架的核心。您可以将它用于调度和核心 I/O 功能。
Spark SQL 是处理数据时方便使用的四个框架库之一。为了运行得更快，该工具使用数据帧，并可以充当分布式 SQL 查询引擎。
这是一个易于使用的流数据处理工具。它将数据分解为微批量模式。Spark 的创造者声称，性能不会因此受到很大影响。
这是一个高速分布式机器学习系统。在对交替最小二乘(ALS)算法进行基准测试时，它比其竞争对手 Apache Mahout 库快 9 倍。MLlib 包括用于分类、回归和推荐系统的流行算法。
GraphX 是一个用于可伸缩图形处理的库。GraphX 不适合以事务方式变化的图形，例如数据库。
Spark 是完全自主的，但是如果需要的话，它也可以与其他标准的 ML 工具兼容，比如 Hadoop。
参见: Apache Spark 教程
数据探索
数据探索软件是为自动化数据分析而创建的，可提供简化的模式识别和轻松的洞察力可视化。数据探索是一个认知密集型的过程，你需要强大的工具来帮助你跟踪和执行代码。
15.Jupyter 笔记型电脑
Jupyter Notebook 是一个开发环境，在这里你可以立即看到执行代码及其片段的结果。与传统 IDE 的不同之处在于，代码可以分成块，并以任意顺序执行。您可以将文件加载到内存中，单独检查其内容，也可以单独处理内容。
MLOps open-source tool: Jupyter Notebook | Source
通常当我们谈论 Jupyter Notebook 时，我们指的是使用 Python。但是，事实上，您可以使用其他语言，比如 Ruby、Perl 或 r。
在云中使用 Jupyter 笔记本最简单的方法是使用 Google Colab。这意味着您只需启动浏览器并打开所需页面。之后云系统会给你分配资源，允许你执行任何代码。
好处是你不需要在电脑上安装任何东西。云处理一切，你只需编写和运行代码。
数据版本控制系统
在您完成之前，将会有多个 ML 模型版本。为了确保不丢失任何东西，使用一个健壮的、可信赖的数据版本控制系统，其中的每一个变化都是可跟踪的。
16.数据版本控制(DVC)
DVC 是为管理 ML 项目中的软件版本而设计的工具。这对于实验和将模型部署到生产中都很有用。DVC 运行在 Git 之上，使用 Git 的基础设施，并且有相似的语法。
- 全自动版本控制
DVC 创建元文件来描述需要保存在项目的 Git 历史中的管道和版本控制文件。如果你在 DVC 的控制下转移一些数据，它将开始跟踪所有的变化。
- 基于 Git 的修改跟踪
您可以像使用 Git 一样处理数据:保存一个版本，发送到远程存储库，获取所需的数据版本，在版本之间进行更改和切换。DVC 界面直观清晰。
总的来说，DVS 是一个优秀的数据和模型版本化工具。如果您不需要管道和远程存储库，您可以为在本地机器上工作的特定项目版本化数据。DVC 可以让你快速处理数十亿字节的数据。
然而，它也允许你在团队之间交换数据和模型。对于数据存储，可以使用云解决方案。
17.迟钝的人
Pachyderm 是一个类似 Git 的工具，用于跟踪数据的转换。它跟踪数据沿袭，并确保数据保持相关。
厚皮动物是有用的，因为它提供:
您希望您的数据从原始数据到最终预测都是完全可追溯的。凭借其数据版本控制，Pachyderm 为您提供了一个完全透明的数据管道视图。这可能是一个挑战；例如，当多个转换器使用同一个数据集时，很难说为什么会得到这样或那样的结果。
Pachyderm 向数据科学模型的可重复性迈进了一步。你永远可以放心，你的客户在模型交给他们之后，也能得到同样的结果。
Pachyderm 将您的所有数据存储在一个中心位置，并更新所有更改。任何转变都不会被忽视。
测试和维护
ML 开发的最后一步是主要工作完成后的测试和维护。特殊的工具可以确保结果在长期内是可重复的。
18. Flyte
MLOps open-source tool: Flyte | Source
如果你正在寻找一种工具来跟踪和维护你的机器学习项目，看看 Flyte 。这是 Lyft 发布的一个维护机器学习项目的平台。
- 大型项目支持
Flyte 帮助他们执行对其业务至关重要的大规模计算。众所周知，扩展和监控所有的管道变更非常具有挑战性，尤其是当工作流具有复杂的数据依赖性时。Flyte 成功地处理了更高复杂性的任务，因此开发人员可以专注于业务逻辑而不是机器。
这个工具还可以帮助你确定你建立的机器学习模型的可重复性。Flyte 跟踪变更，进行版本控制，并将模型及其依赖项封装起来。
创建 Flyte 是为了支持 Python、Java 或 Scala 中的复杂 ML 项目。
在发布给公众之前，Flyte 已经在 Lyft 内部进行了测试。它有着管理 7，000 多个独特工作流的良好记录，每月总计执行 100，000 次。
结论
开源的 MLOps 工具是必要的。它们帮助你自动化大量的日常工作，而不需要花费大量的金钱。成熟的平台为不同的目的提供了广泛的工具选择，可以满足您的任何技术需求。然而，在实践中，结果往往是您仍然需要将它们与使用起来更直观的专用工具集成在一起。幸运的是，大多数开源工具使集成尽可能无缝。
然而，关于开源工具需要理解的一件重要事情是，你不应该期望它们是完全免费的:基础设施、支持和项目维护的成本仍将由你承担。
使用 Docker 进行机器学习的最佳实践
原文：https://web.archive.org/web/https://neptune.ai/blog/best-practices-docker-for-machine-learning
可以使用 Docker 工具创建、部署和执行应用容器。它只是一个打包的应用程序代码包，以及运行它所需的库和其他依赖项。一旦被执行，一个 Docker 镜像就会变成一个容器，包含运行一个应用程序所需的所有组件。
然而，这样做有什么意义呢？作为一个数据科学家或者机器学习工程师，这有什么用？一个关键词，尤其是对数据科学家来说，就是可再现性。使用 Docker，可以开发一个基本的分类器，如果您的系统有一个没有更新的库和程序版本，并且由于您有在这些版本上运行的某些应用程序而无法更新，则该分类器可以保证很好的再现性。这是一个体面且简单的用例。
但是在我们深入探讨之前，让我们先从一些基础开始。
Docker 是什么？
Docker 是一个使用容器开发和部署应用程序的工具。容器是基于这样一个概念构建的，您可以将您的代码及其依赖项捆绑到一个可部署的单元中。容器已经使用了很长时间。有些人声称它们是由 Sun Microsystems 创建的，并在 2005 年作为区域作为 Solaris 10 的一部分发布，而其他人则声称 BSD Jails 是第一个实现的容器技术。考虑用于联运的集装箱作为视觉解释的例子。
一旦您将产品(代码和依赖项)放入容器中，您可以通过船只或火车(笔记本电脑或云)发送它，当它到达目的地时，它将继续运行，就像发货前一样。
货船类比
Docker – cargo ship analogy | Source
有一个有用的比较可能有助于解释 Docker 是如何工作的。如你所知，这些物品是用不同的集装箱运输到世界各地的。此外，这种隔离很重要，这样一个集装箱中的商品就不会影响旁边集装箱中的商品。
为了运输不同的物品，集装箱可以是单一的尺寸和材料，也可以是不同的尺寸和材料，这取决于所运输的货物种类。
有一个经理通常负责登船、离船和维护船上的集装箱。在这个场景中，服务器上运行的 Docker 引擎充当管理器。
作为船主，你可以指示船舶经理在船上装卸集装箱。类似地，docker 也可以在服务器上执行、部署和关闭您的应用程序。
对于容器，您需要一张图片作为容器大小和内容的模板。正是在这里，你需要一个蓝图，即图像，从这里建立这个容器。Docker hub 是一个存储图像的好地方，服务器上的 Docker 引擎会处理剩下的事情。
Docker 在机器学习领域扮演什么角色？
Docker 中的再现性
无论是开发模型还是进行数据分析，尽可能准确地再现结果是非常重要的。考虑以下场景:您被要求对一个数据集合进行探索性的数据分析。创建一个包含数据集和一些 Python 库的本地环境，然后启动 Jupyter 笔记本。分析数据集并开发初步模型后，您决定与同事和朋友分享您的发现。
问题是你的同事要复制你的分析，他们也必须复制你的整个堆栈。Docker 允许您快速轻松地复制您的工作环境。它使得标准化项目中使用的库的版本、随机种子、甚至操作系统成为可能，这样，在不同的机器上工作的同事可以一次又一次地生成相同的结果。
Docker 中的便携性
作为一名数据科学家，能够从本地工作站平稳地转移到提供额外资源(如 CPU、RAM、GPU 等)的外部集群是非常有益的。此外，我们希望能够尝试社区正在创建和共享的新框架和工具。
Docker 使您能够将代码和依赖项打包到容器中，这些容器随后可以移植到各种计算机上，即使底层硬件、操作系统等与原始机器不同。移动性的另一个好处是能够相对简单地与各种不同的同事一起工作。
作为一名数据科学家，在您开始处理已建立的代码库之前，您不必花费一整天(或一周)来设置环境。如果项目已经被“归档”，你将能够立即开始工作。
在 Docker 中部署
Docker 的使用简化了部署机器学习模型的过程。这是一个你是否想和别人分享你的模式的问题。这很简单，只需利用 Kubernetes 技术将您的模型包装在 API 中，然后放入容器中。本节中省略了几个小步骤。回想一下，从 Docker 到模型部署的转换过程相当简单。容器管理技术和方法可以用于我们的模型部署。
Docker 中的集成
云提供商和物理服务器可以使用 Docker 云来构建 Docker 节点。在您的物理服务器上安装 Docker 云代理，或者安全地连接您的云提供商凭据。然后，您可以在几秒钟内“构建节点集群”。
AWS、Azure、DigitalOcean、Packet 和 Softlayer 都与 Docker Cloud 相连，用于供应和管理。要管理 Docker Cloud (Google Cloud，Rackspace)不支持的基础设施上的节点，您还可以管理连接到互联网的物理 Linux 系统上的节点。
使用 Docker 进行机器学习的最佳实践(ML)
1.构建 Docker 图像
什么是 Docker 文件？
Docker 文件是一个文本文档，包含生成特定图像所需的所有命令，Docker 可以读取这些命令来自动构建该图像。在使用 docker image build 命令创建映像时，应该尽可能少地进行设置或更新，以便可以随时暂停和/或销毁容器，并轻松地重新构建或替换容器。
什么是图像？
除了 Docker 之外，任何使用过虚拟机的人都很熟悉 Docker 映像的使用。在其他虚拟机设置中，映像通常被称为“快照”。它们是 Docker 虚拟机在特定时间和地点的快照。虽然虚拟机快照类似于 Docker 映像，但还是有一些不同之处。
首先，Docker 图像是不可变的。在你制作了一张唱片之后，你可以删除它，但是你不能改变它。如果需要新的快照，从头开始创建新的映像。
在 Docker 世界中，不变性(不改变的能力)是一个有价值的工具。一旦您设置了 Docker 虚拟机并创建了一个映像，您就可以确定该映像将一直运行。这使得在您的环境中试验新特性变得简单。
你可能会尝试新的应用程序或者重组你的文件。因此，您可以确定您的运行实例不会受到影响。您的 Docker 虚拟机将始终能够关闭并继续使用您当前的映像，就像什么都没有改变一样。
构建映像的最佳实践
- 使用官方图片:在项目中，如果你是 Docker 的新用户，建议你使用 Docker 官方图片。这些照片有全面的文档，它们鼓励最佳实践，同时也迎合了最广泛的潜在应用。
修改 Docker 图像的一个典型原因是减小图像的尺寸。当安装需要优化代码的模块时，一个完整的构建工具链包含在许多编程语言堆栈映像中。一个更有经验的用户可以创建一个定制的映像，其中只包含绝对必要的预编译库，从而节省磁盘空间。
-
为了获得最佳效果，使用一个可靠的基础映像:当你在一个不可信的或未维护的映像上构建容器时，你将继承该映像的所有缺陷和漏洞。所以作为一般的经验法则，你应该遵循以下规则:
- 可信的存储库和供应商应该优先于由身份不明的个人创建的图片。
- 使用自定义映像时，在构建您自己的基础映像之前，请检查映像源和 docker 文件。在公共注册表中发布的图像不能保证是从 docker 文件中生成的。不保证以后会更新。
-
。dockerignore :当我们运行 docker build 命令时，为了防止映像中包含不需要的文件和目录，我们可以创建一个. dockerignore 文件，其中包含我们不想在映像中包含的文件和目录。如果不包含这个文件，应用程序的处理时间可能会缩短。
-
容器必须是短暂的:短暂的容器应该由 docker 文件中指定的映像生成。当它在被重建和替换为新容器之前可以被停止和销毁时，它被称为临时容器，只需要最少的设置和配置。一次性容器，如短暂的容器，可能被认为是这样的。对于每个新的容器实例，与之前的没有任何联系。在创建 Docker 图像时，应该尽可能多地使用短暂的模式。
-
避免安装不必要的应用程序:由于承诺以后会用到它，安装比您需要的更多的应用程序可能很诱人，但是为了减小映像的大小和复杂性，只安装实际需要的。例如，在使用 curl 包之后，最好将其移除，因为在构建容器的过程中，很多时候只需要使用它一次。
-
将每个论点分成几行:以这种方式对论点进行排序有很多好处。您可以更容易地确定是否有修改，这有助于检测包中的重复。
让我们看看下面的例子是如何工作的！
例一
RUN apt-get update && apt-get install -y php5-cli php5 php5-gd php5-LDAP php5-mysql apache2 php5-pgsql libapache2-mod-php5
例二
RUN apt-get update &&
apt-get install -y
apache2
libapache2-mod-php5
php5
php5-cli
php5-gd
php5-LDAP
php5-mysql
php5-pgsql
没有顺序的行很难阅读。由于理解它们需要大量的脑力劳动和注意力，我们倾向于在代码评审时跳过它们。那么，你认为应该首选哪种方式呢？
- 利用 Docker 缓存:Docker 图像的一个迷人且有用的特性是图层。层用于构建 Docker 映像，每个层都有特定的用途。Dockerfile 指令与每一层相关，并描述了映像的文件系统在执行前和执行后的变化。为了节省构建时间，Docker 会缓存层。Docker 将简单地重用缓存中的现有层，而不是重新创建一个类似的层。
另一方面，添加不是绝对必要的层会增加工作量。因为 Docker 层是文件系统，所以许多不需要的层都有性能问题。用应用所有依赖性的单个 run 命令建立单个缓存比将其分成许多级更有效，因为每个 RUN 命令产生一个新层。通过找到并使用可缓存的图层，从长远来看，您将节省大量时间。
- 通过将您的断言压缩成一个来减少层的数量:docker 文件中的每条指令都向图像添加一层。指令和层的数量应保持在最低水平，因为这会影响性能和构建时间。因此，当执行运行、复制或添加命令时，请尝试用一句话来执行。
FROM alpine:3.4
RUN apk update
RUN apk add curl
RUN apk add vim
RUN apk add git
FROM alpine:3.4
RUN apk update &&
apk add curl &&
apk add vim &&
apk add git
2.构建容器
什么是容器？
-
应用程序可能被打包在容器中，这些容器不过是孤立的环境。容器的目标是分离和支持跨多个平台的应用程序的移动性。
-
在容器中，映像提供了操作一组进程所需的所有文件。通过容器，应用程序与共享同一个内核的其他进程隔离开来，因此没有一个进程会影响其他进程的工作。
-
集群是容器的集合。在集群中，存储和处理能力等资源可以共享，这使得并发操作几十个甚至几百个容器变得可行。
-
容器在软件开发环境中非常有用。DevOps 方法基于它们的适用性，可以帮助运营和开发部门。当涉及到开发应用程序时，容器与环境的特性无关，例如操作系统，因此它们可以很容易地共享和访问，当涉及到在同一内核上运行应用程序时，它们不像虚拟机那样复杂。
-
尽管它们很相似，但容器不是虚拟机，因为容器可能与操作系统共享同一个内核，但虚拟机不能。
构建容器的最佳实践
- 每个过程一个容器
将容器视为可以同时运行几个不同方面的虚拟计算机是一个典型的错误。容器可能以这种方式工作，但是这减少了容器架构的大部分好处。例如，同时运行标准 Apache/MySQL/PHP 栈的所有三个组件是很诱人的。然而，建议的方法是利用两个或三个不同的容器:一个用于 Apache，一个用于 MySQL，如果您使用 PHP-FPM，可能还有一个用于 PHP。
由于容器的生命周期与其包含的应用程序相同，因此每个容器只能有一个应用程序。当一个容器被启动时，应用也是如此，当应用被关闭时，容器也是如此。下图描述了这种推荐做法。
Good practice
.
└── parent_process/
├── child process I/
│ ├── child process I.I
│ └── child process I.II
└── child process II/
├── child process II.I
└── child process II.II
Bad practice
.
├── parent_process I/
│ ├── child process I.I
│ └── child process I.II
--------------------------
└── parent process II/
├── child process II.I
└── child process II.II
建议每个容器只运行一个进程有几个原因:
- 假设您的应用程序架构中有两个 web 服务器和一个数据库。可以在一个容器中运行所有三个服务，但是最好在不同的容器中运行每个服务，这样可以更容易重用和扩展。
- 每个服务都有一个独立的容器，允许您横向扩展一个 web 服务器来容纳额外的流量。
- 将来您可能需要一个容器化的数据库用于另一个服务。在这种情况下，可以重用同一个数据库容器，而不需要两个额外的服务。
- 当容器被耦合时，日志记录变得更加困难。
- 由于要处理的外围应用面积更小，因此生成安全更新或解决问题要简单得多。
2。给你的容器贴上标签
说到维护图像，Docker 标记是一个非常有用的工具。它有助于维护 docker 映像的多个版本。下面是一个构建标签名为 v1.0.1 的 docker 图像的示例
docker build -t geekflare/ubuntu:v1.0.1
您可以使用几个标签:
- 使用 稳定标签 来保留容器的基本图像。避免将这些标记用于部署容器，因为这些标记会经常改变，这可能会导致生产环境中的差异。
- 使用 唯一标签 进行部署。使用独特的标记，您可以轻松地将生产集群扩展到多个节点。它可以防止不一致，并且主机不会获取任何其他 docker 映像版本。
建议在部署的图像标记上禁用写启用。这可以防止部署的映像从注册表中意外删除。
3.在 Docker 中运行您的模型
为什么要在 Docker 中放一个机器学习模型？
挑战
-
构建一个在我们的 PC 上运行的机器学习模型的过程并不困难，但与一个希望在不同类型的服务器上大规模利用该模型的客户合作确实具有挑战性。可能会出现各种问题，包括性能问题、程序崩溃和糟糕的优化。
-
我们的机器学习模型可以用 Python 这样的单一编程语言实现，但应用程序将需要与用其他编程语言编写的其他应用程序进行通信，以进行数据输入、预处理、前端等。，这本身就是一个挑战。
使用 Docker 的好处
- 由于每个微服务可能使用不同的语言，docker 支持可伸缩性和独立服务的简单添加或删除。Docker 的优点包括可复制性、可移植性、易于部署、增量更新、轻量级和简单性。
- 数据科学家最大的担心是他们的模型不能准确反映现实生活的结果，或者当它与其他研究人员共享时。在某些情况下，模型不是问题所在；更确切地说，是复制整个堆栈的需要。使用 Docker，可以在任何系统上复制训练和操作机器学习模型所需的工作环境。
- 使用 Docker，代码和依赖项可以一起打包到可移植的容器中，这些容器可以在各种不同的主机上运行，而不用考虑硬件或操作系统。
- 训练模型可以在本地系统上构建，并简单地转移到具有更多资源(如 GPU、更多 RAM 或强大的 CPU)的远程集群。OpenShift 是 Kubernetes 的一个发行版，通过将模型封装到容器中的 API 中，并使用类似这样的技术部署容器，它使部署变得简单，并使您的模型对世界开放。
- 可以使用 Docker 跟踪容器映像版本，以及谁开发了它们，用了什么。版本也可以回滚。此外，即使您的机器学习应用程序所依赖的服务之一正在升级、修复或不可用，它也可能会运行。例如，如果必须更新包含在整个解决方案中的输出消息，则不需要与其他服务交互并更新整个程序。
4.跟踪模型的指标
即使在模型开发之后，机器学习(ML)的生命周期也远未结束；事实上，这仅仅是这一进程的开始。要将您的模型投入生产，下一步是部署和监控您的模型。为了最大限度地利用你的机器学习模型，只要你在使用它，你就需要密切关注它。
将 ML 模型监测视为频繁的健康检查。作为一项操作任务，模型建模可以帮助您确保您的模型以最佳状态工作。
模型监控的重要性
监控您的 ML 模型的错误、崩溃和延迟是机器学习生命周期中模型部署之后的操作阶段的一部分。
模型漂移，或模型在使用过程中的退化，是为什么需要模型监控的最直接的原因。一个模型的预测能力可能下降有几个原因-
- 以前未见过的信息:如果没有足够的标记数据或者训练有计算限制，就不可能避免你的机器学习模型产生错误或错误结果的数据样本。
- 变量连接和周围环境的变化 : ML 模型根据建立时的变量和参数进行优化。想想 20 年前开发的垃圾邮件检测算法现在有多有效。二十年前，互联网甚至还不存在！这种方法可能无法跟上垃圾邮件不断变化的本质，因此它是否有效值得怀疑。这个例子说明了环境的变化。
- 上游数据的变化:这是一个术语，用来描述对运行数据管道的修改。数据科学团队通常无法完全控制输入数据所来自的所有系统。虽然数据是以摄氏温度记录的，但一个完全独立的软件工程团队可能会将变量的测量值改为华氏温度。例如，如果有人试图确定平均温度，这可能会产生严重的影响。
ML 实验跟踪工具
出于上一节提到的原因，很明显，机器学习模型的登台环境永远不会等同于生产环境，因此您必须密切关注您投入生产的任何 ML 模型。
有很多技术可以帮助我们做到这一点。首先，我们有知名的工具，比如 MLFlow 、 TensorBoard 、海王星、 DVC 、亚马逊 SageMaker、等等。
为了更好地理解，让我们看一下 Neptune，看看一旦通过 docker 部署了模型，我们如何通过这个工具来检查我们的模型。
海王星的简短概述
Neptune 是 MLOps 的 元数据存储，为运行大量实验的团队而构建。
它为您提供了一个记录、存储、显示、组织、比较和查询所有模型构建元数据的单一位置。
Neptune 习惯了 for:
- 实验跟踪:在一个地方记录、显示、组织和比较 ML 实验。
- 模型注册:对训练好的模型进行版本化、存储、管理和查询，以及建模元数据。
- 实时监控 ML 运行:实时记录和监控模型培训、评估或生产运行
如果您想了解更多信息，请查看文档或探索应用中的示例项目(无需注册)。
海王星码头工人
让我们按照一步一步的过程来看看我们如何在容器化的 Python 脚本或应用程序中记录实验元数据。
第一步:将 Neptune 添加到您的代码中
让我们训练一个简单的线性回归模型，并将其放入 Docker 容器中。
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
import joblib
import neptune.new as neptune
from neptune.new.types import File
import os
run = neptune.init(
project="PROJECT_WORKSPACE/PROJECT_NAME",
api_token="YOUR_API_TOKEN",
tags='a_tag_to_help_you'
)
lr = LinearRegression()
for _ in range(100):
rng = np.random.RandomState(_)
x = 10 * rng.rand(1000).reshape(-1,1)
y = 2 * x - 5 + rng.randn(1000).reshape(-1,1)
X_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=123)
lr.fit(X_train, y_train)
test_mse = mean_squared_error(y_test, lr.predict(X_test))
run['test/mse'].log(test_mse)
joblib.dump(lr, '/any_name.pkl')
run['model'].upload(File.as_pickle('any_name.pkl'))
为了观察我们的模型在不同数据下的表现，我们运行了 100 次，每次都使用 Numpy 的不同随机数据。RandomState()。因此，每一次，我们都会收到一个更新的度量值，这个值用。日志功能。
现在，lr 是我们的模型，test_mse 是我们的度量。我们如何让同样的结果在不同的机器上重现呢？我们用 Docker！
步骤 2:更新 requirements.txt 文件并创建 Dockerfile 文件
因为现在我们正在使用 Neptune 包，所以我们需要将它包含在我们的需求文件中。
joblib==1.1.0
neptune-client
numpy==1.21.4
scikit-learn==1.0.1
现在创建一个 Dockerfile 文件，它将:
- 指定基本容器映像，我们将从该映像构建我们的
- 在更新的 requirements.txt 中安装依赖项
- 将我们的训练脚本复制到容器映像，并定义执行它的命令。
FROM python:3.8-slim-buster
RUN apt-get update
RUN apt-get -y install gcc
COPY requirements.txt requirements.txt
RUN pip3 install -r requirements.txt
COPY . .
CMD [ "python3", "-W ignore" ,"training.py" ]
步骤 3:构建并运行 docker 容器传递 API 令牌
通过运行以下命令，从上一步中创建的 docker 文件构建 docker 映像:
docker build --tag <image-name> .
现在，我们用我们的凭证运行容器。
docker run -e NEPTUNE_API_TOKEN="<YOUR_API_TOKEN>" <image-name>
运行 docker 容器后，您会在终端上看到一个链接。点击链接打开海王星跑步，观看您的模型训练直播。
Monitor model training runs live in Neptune
在我们的示例中，我们记录 MSE，这可以更改为对您的模型和用例有意义的任何指标。
结论
互联网上的许多教程和文章只关注如何建模和理解度量。在科学过程中，一位杰出的科学家或一家小公司的雇员将不得不接受同行评议。
留意你的模型在新数据和变化下的表现。即使你对学习 MLOps 不感兴趣，你也无法从强化课程中获益。我希望这些材料对你的日常生活有所帮助！
这里有一些参考资料，可以帮助你更好地理解 Docker 最佳实践，以及机器学习从业者如何从中受益。
- 关于如何为你的机器学习模型构建和运行容器的更多信息，参见本文。
- 如果你是初学者，这篇文章将帮助你掌握模型监控的基础知识。
- 这篇文章有更多关于使用 Docker 进行深度学习应用的细节。
- 最后，这是一个关于机器学习 Docker 的 3 篇文章系列。
数据科学项目工作流和文件组织的最佳实践
自从 2012 年《哈佛商业评论》发表文章称数据科学是 21 世纪最性感的工作以来，这个领域已经席卷了所有行业。数据科学工作从来不会错过排名第一的最佳工作列表——一个工作列表每天可以收到 200-300 名申请人也就不足为奇了。福布斯的一篇文章称，“从 2010 年到 2020 年，世界上创建、捕获、复制和消费的数据量从 1.2 万亿千兆字节增加到 59 万亿千兆字节，几乎增长了 5000%”。按照目前的速度，我们完全淹没在数据中，各行各业的企业都在寻找利用数据的方法。
对一些人来说，这可能似曾相识，但对经历过软件工程繁荣时期的其他人来说，他们可能会看到一个熟悉的模式正在形成。实际上，每个从事软件工程的人都想保持或发展他们在市场中的竞争优势，因此他们决心向市场交付高质量的产品，这反过来导致了方法和所用工具的革命——一些例子包括敏捷、DevOps、CI/CD 等等。
然而，软件工程和数据科学的不同之处在于，软件工程师本质上是为了构建而学习，而对于数据科学家来说，学习通常发生在构建之后。尽管如此，这并不是说数据科学没有任何东西可以从它的表亲软件工程中学到。事实上，现实恰恰相反。
什么是数据科学工作流？
通常，工作流描述了人们执行任务以完成工作的方式。为了说明一个典型的工作流程是什么样子的，我们将使用图表或清单列出一系列应该按顺序完成的步骤。
工作流由编排好的可重复的业务活动模式组成，通过将资源系统地组织成转换材料、提供服务或处理信息的流程来实现。它可以描述为一系列操作，声明为一个人或一组人的工作，一个员工组织，或者一个或多个简单或复杂的机制【来源 : 维基百科
这是数据科学工作流的本质；数据科学工作流阐述了数据科学项目中采取的不同步骤。由于工作流的目的是说明如何完成工作，因此使用定义良好的数据科学工作流非常有用，因为它可以提醒所有团队成员哪些工作已经完成，哪些工作尚未完成。
工作流程的开发
“数据科学工作流来自哪里？”的简单答案是软件工程，但是和大多数事情一样，它真的没有那么简单。首先，软件工程师是工程师，因此无论何时他们学习新东西，目标都是构建。另一方面，数据科学家在成为工程师之前是科学家(如果他们有任何工程能力的话)，因此，只有在他们学会之后才能进行构建。
因此，数据科学家与代码的关系不同于工程师。数据科学家很少会在做实验时考虑编码最佳实践，相反，他们希望从实验的见解中学到一些有价值的东西。因此，数据科学家利用代码从数据中获得洞察力，并得出项目开始时制定的有趣问题的答案。
尽管存在差异，数据科学团队使用的最佳实践实际上是从软件开发最佳实践中借鉴来的。尽管存在大量的开发工作流，但是它们之间的一个共同点是，它们通常都包括定义规范、编写代码、代码审查、代码测试、代码集成以及将系统部署到生产环境中的步骤，以便它能够为业务服务。
同样，数据科学工作流也有其自身的共性。
数据科学工作流的一般方面
由于数据科学问题的本质——我们从一开始就不知道结果——很难定义一个在处理数据科学问题时应该普遍使用的具体模板。根据问题和数据的不同，您希望如何完成任务的路线图可能会有所不同，因此团队需要定义一个合适的结构。
尽管如此，当我们处理许多不同的问题时，不管数据集如何，我们都会看到非常常见的步骤。让我们来看看这些步骤。
注 :下面定义的过程绝不是线性的。数据科学项目是相当迭代的，许多阶段是重复和/或重新访问的。
定义问题
定义一个问题并不像看起来那么简单，因为有许多因素需要考虑，以确保解决正确的问题。定义问题时要考虑的问题如下:
- 我们试图解决什么问题？
- 我们的客户在使用我们的产品/服务时面临哪些挑战？
- 我们想更多地了解哪些见解？
- 我们目前面临哪些问题？
清楚地陈述问题的能力更像是一门艺术，但这是进行任何数据科学项目之前必不可少的第一步。如果没有一个团队所有成员都遵循的指南针，很容易花费大量时间做大量事情，而在增加业务价值方面没有太大进展。
数据收集
数据是工业数据科学项目中出现瓶颈最多的地方；很少有我们需要的所有数据都是现成的，因此，我们知道一些获取数据的技术是很重要的。这种现象被称为数据采集。
根据维基百科的描述，数据采集被描述为对测量现实世界物理条件的信号进行采样，并将结果样本转换为计算机可以操纵的数字数值的过程[ 来源 : 维基百科。
获取数据的方法有很多种，下面是一些想法:
- 公开日期
- 产品干预
- 数据扩充
- 从本质上讲，数据可以来自各种来源——这里有一些问题，但是详细描述它们超出了本文的范围。
数据探索
一旦收集的数据可供数据科学家访问，花时间熟悉这些数据是很重要的。
在这一阶段，在寻找模式和异常的同时，对数据进行假设是很重要的。你还想确定正在解决的问题的类型，例如，这是监督学习任务还是非监督学习任务？是分类任务还是回归任务？我们是在试图预测什么还是在推断什么？
监督学习包括建立一个模型，该模型学习基于输入-输出对的例子将输入映射到输出的函数。
- 无监督学习涉及建立一个从无标签数据中学习模式的模型。
- 分类是监督学习的一种形式，指的是模型输出为离散标签的建模问题。
- 回归是监督学习的一种形式，指的是模型输出连续的建模问题。
- 主要的要点是，我们希望足够好地理解我们的数据，以开发假设，当我们进入工作流的下一个阶段——数据建模时，我们可能会测试这些假设。
建模
一旦我们对数据进行了全面的研究，我们就会对我们所面临的问题类型有一个更好的了解，并且有希望在前一阶段产生一些我们可以尝试的假设。
由于数据科学是一门科学，我们可能需要测试各种不同的解决方案，然后才能得出我们希望如何推进项目的结论。每个实验或迭代将涉及 3 个阶段；
构建涉及使用训练数据学习和推广机器学习算法。
- 拟合涉及测量机器学习模型归纳为从未见过的与训练数据相似的例子的能力。
- 验证涉及使用来自训练数据的不同部分的测试数据来评估训练的模型。
- 阅读如何在专业视图中使用深入分析来比较 Neptune 中的多次运行。
传达结果
许多数据科学家在职业生涯的早期阶段沉迷于机器学习算法和艺术状态，然而，随着时间的推移，许多人开始意识到他们的注意力应该转移到所谓的软技能上。
清楚地传达您的结果是作为一名数据科学家最重要的技能之一，因为您将会做大量的工作。在这一阶段，数据科学家需要将发现、结果和/或故事反馈给各种利益相关者。在大多数情况下，这些利益相关者并不总是完全扎根于数据科学的人，因此能够改变您的信息以使您的受众能够理解是数据科学家工作流程中非常重要的一部分。
现有工作流程
数据科学工作流在该领域并不是一个新的专长，事实上，有许多框架可供团队选择。
Blitzstein & Pfister 工作流程
也被称为数据科学流程，Blitzstein 和 Pfister 为哈佛 CS 109 课程精心设计了一个数据科学工作流框架。Blitzstein 表示，该课程的目标是为决定参加该课程的人介绍数据科学调查的整体流程。
Blitzstein 和 Pfister 工作流由数据科学项目的 5 个关键阶段组成；
第一阶段:问一个有趣的问题
- 第二阶段:获取数据
- 第三阶段:探索数据
- 阶段 4: 对数据进行建模
- 第 5 阶段:沟通并可视化结果
- 如前所述，数据科学工作流不是一个线性过程，相反，它是一个非线性的、迭代性极强的过程。数据科学过程强调首先建立一个问题的重要性，该问题将指导您的工作流，以及迭代的重要性，这可以通过将每个阶段与下一个阶段和之前的上一个步骤链接起来的线条来看出。
CRISP-DM
CRISP-DM 是数据挖掘跨行业标准流程的缩写，是最受认可的数据科学工作流框架之一；CRISP-DM 的想法是创建一个可以跨行业使用的标准化流程。CRISP-DM 由 6 个迭代阶段组成，每个阶段都有应该完成的指定任务，以及一组可交付成果(即文档)。类似于 Blitzstein 和 Pfister 的工作流程，项目可以根据需要返回到之前的阶段。
如上述流程图所示，CRISP-DM 工作流程包括以下 6 个关键阶段:
第一阶段:业务理解
- 第二阶段:数据理解
- 第三阶段:数据准备
- 第四阶段:建模
- 第五阶段:评估
- 第六阶段:部署
- OSEMN
OSENM 最初是在希拉里·梅森和克里斯·维金斯 2010 年发表的一篇名为的博客文章中描述的，这是一种数据科学的分类法.) ，人们经常通过回忆 OSENM 听起来有多接近“possum”或“awesome”来记住这个框架。
然而，OSEMN 是一个首字母缩写词，代表着Ob ain、 S crub、 E xplore、 M odel 和 i N terpret。很可能大多数数据科学家对每个术语都很熟悉，并且在研究每个术语时应该会感到舒适。虽然数据科学将需要 OSEMN 的组合元素，但作者确定“O”和“S”任务需要更多的数据黑客技能，而“E”和“M”需要更多的机器学习技能，因此没有数据科学家会在每个步骤上都是专家。
由于没有图像说明，我将分解每个步骤。
#1 获取
为了执行数据科学，我们需要数据，因此该框架将“O”(获取)定义为工作流中的第一步。作者不赞成手动数据收集过程(即使用鼠标点击、从文档中复制和粘贴等)。)效率低下且不可扩展。
根据作者的说法，获取数据的最有效方法是采用一系列工具，这些工具将允许您针对您的问题自动获取数据。这些工具包括 unix 命令行工具、SQL、web 抓取和 shell 脚本。
注意: 另外，作者提到 API 对于访问数据至关重要
#2 擦洗
更常见的情况是，获得的数据会非常混乱——我们可以认为混乱的数据是被破坏的(即缺少值)。数据科学家经常在工作流程的这一部分花费大量时间，许多人会同意这可能是 21 世纪最性感工作中最不性感的部分。
对干净数据的简单分析可能比对嘈杂和不规则数据的复杂分析更有成效–数据科学的分类法
尽管如此，确保数据的干净、统一和一致可以在数据项目中获得极大的回报，因为你总是会得到你输入的内容——如果你输入垃圾，那么你可能会得到垃圾结果。
#3 探索
数据科学家通常将“探索”阶段称为探索性数据分析(或 EDA)。EDA 背后的想法是收集关于手边数据的情报。有了这种智能，数据科学家就可以收集想法，当我们进入数据科学工作流程的下一个阶段时，可以进一步测试这些想法。
在 Python 中执行 EDA 的一些有用工具有:
熊猫进行数据操作
- Matplotlib 用于数据可视化
- Jupyter 笔记本电脑易于使用的交互式数据科学环境
- 降维PCA 等方法
- 聚类算法寻找数据中的自然分组
- #4 型号
模型阶段是我们实施各种机器学习算法来预测某个结果的阶段。我们将最佳模型定义为最适合我们预定义的评估度量的模型。
“通常‘最佳’模型是最具预测性的模型”——数据科学的一种分类法
#5 解释
为了确定模型的表现如何，我们通常在训练期间模型不可用的新的看不见的实例上验证它的表现——想法是模型将很好地推广到新的看不见的实例。
根据作者的说法，模型的解释能力定义了模型建议接下来进行的最有用/最有趣的实验的能力(这是因为模型输出的解释应该提供对正在解决的问题的更多洞察)。
一个数据科学家读到这里可能会觉得工作流似乎是显而易见的，但是在开始一个项目之前定义一个工作流仍然有巨大的价值。因此，团队的所有成员都会确切地了解正在发生什么，需要做什么，并且让团队的其他成员相互负责。
组织您的数据科学项目
数据科学项目通常适合作为更大系统的一部分。我们为项目编写的实际代码只是整个系统的一小部分，例如，当创建假新闻分类器时，与同一系统中的其他元素(即数据收集、特征提取、配置等)相比，机器学习代码非常小。).正是基于这一点，我倾向于将这样的项目视为软件项目。
注:好奇的读者可能想读读 隐藏在机器学习系统 中的技术债。
“分层方法被认为是比整体实施协议更好的做法，因为分别实施概念上不同的问题有几个好处”Buschmann 等人(1996 年)
结构描述了数据科学项目开发中元素的预定义排列和组织。开始时可能会很耗时，但决定记录并遵循一个结构对数据科学团队来说非常有用——这往往会在整个项目过程中产生回报。
为什么结构很重要？
对于那些还没有被说服的人，这里有两个原因可以解释为什么在项目开始时花点时间来建立一个结构是非常有益的。
你未来的自己会感谢你
我们在本文前面探索的所有工作流本质上都是非常迭代的——仅此一点就足以证明可再现性的重要性。在将来的某个时候，我们可能需要重现我们在某个实验中做过的事情，但是作为一个从业者，这可能是你最不想去的地方。我们更关心下一步可以尝试什么实验，我们从当前的实验中学到了什么，什么有效，什么无效。
数据科学家参与快速实验、可视化和分析并不罕见，但是，这种类型的工作状态不适合结构性思维——实验是混乱的！
没有一个正式的结构，回到过去的实验/项目本身就是一个全新的挑战。作为脚本的创建者，如果不清楚最终的训练脚本是 train.py、new_train.py 还是 last_train.py，那么您现在必须花时间浏览每个脚本，以确定哪个脚本实际上执行了代码——时间花得不值得。
当你告诉某人你能做某事，而他们告诉你去证明它，而当你尝试时，它却不起作用，这有多尴尬？没错。当你无法重现自己的实验时，这是同样的感觉。当你不得不执行不可避免的任务，重温你过去做过的工作时，保持一个良好的结构将会节省你很多时间。
别人会感谢你
数据科学是一个团队的事情，成为一个好的团队成员的一部分包括通过尽自己的力量来减轻队友的负担；由于数据科学可能被视为一项团队工作，因此在某个时候可能会有人想要重温您过去完成的某些东西(例如，他们可能想要扩展它、验证它、展示它、学习它等等。).
这个人可能是一个当前的团队成员，一个刚刚被雇佣的人，或者是一个对组织内的项目完全陌生的人。通过保持良好的结构，你可以为将来可能需要使用你的作品的人节省大量时间。
拟议布局
像数据科学工作流一样，在定义要遵循的结构时，没有一个尺寸适合所有人，但有一些关键组件往往会在大多数项目中重复出现。一旦我们创建了项目目录，第一步就是分离代码、数据、笔记本和模型。为了更好地从概念上理解，请看下图。
数据
Image by Author
首先是数据目录，它存储了项目所需的所有数据。在整个项目过程中，我们会处理不同类型的数据，因此我们最好将它们分开，以避免在进行实验时出现任何复杂情况。下面是我们如何在父数据目录下对不同的数据目录进行排序:
Raw :存储数据的本地副本可以确保数据的稳定性——如果数据库每天更新，可能会干扰您对当前状态的数据执行的任务。该目录中的数据是不可变的，这意味着存储在该目录中的数据将始终保持其原始状态。
- 外部:从第三方来源提取的数据。存放在这个目录中的数据应该是不可变的(也就是说，您不应该将您以任何方式转换的数据保存到这个目录中)。
- 过渡:任何转换(即连接、合并等。)取得的原始数据和外部数据(如果有的话)将被存储在临时目录中。该目录中的数据是任何特征工程的数据。
- 已处理:当我们对数据执行了特征工程后，我们可以继续将数据存储到已处理的目录中。这里，数据处于准备由机器学习算法消费的状态(如果需要)。
- 模型
模型目录是我们在训练后存储序列化机器学习算法的地方。我们在训练后存储我们的模型，因为我们需要恢复它们用于推断。但是，存储模型也是一个好主意，以防我们将来决定构建一个合奏，并比较模型，因为我们很可能会在项目过程中构建许多模型。
笔记本电脑
笔记本是制作原型、探索和交流见解的更好方式。笔记本电脑缺乏的是可扩展性和可再现性。虽然上图中没有说明，但将笔记本电脑分成单独的子目录也是一个好主意，例如；探索、原型等。
注意 :使用好的命名约定将有助于将每台笔记本区分开来
科学研究委员会
Src 是源代码的缩写，所有的源代码都保存在这里。很难确切地知道我们需要什么样的脚本，但是作为一个通用的经验法则，您总是可以期望检索数据、执行特性工程和建模数据。
最后的想法
确定您团队的工作流程以及如何着手构建项目的最佳方式是评估团队成员，然后提出一套最适合团队价值观和目标的实践——评估现有框架并看看可以从它们那里获得什么也是一个好主意。
The best way to determine your team’s workflow and how to go about structuring projects is to assess the members of the team then come up with a set of practices that best fit the values and goals of the team – it may also serve as a good idea to assess existing frameworks and see what could be taken from them.
最佳强化学习教程、示例、项目和课程
在强化学习中，你的系统通过基本的做事和观察发生的事情来学习如何直观地与环境互动——但显然，还有更多。
如果您对 RL 感兴趣，本文将为您提供大量新内容来探索这个概念。在过去的几年里，人们在强化学习方面做了很多工作，我收集了一些最有趣的文章、视频和用例，展示了不同的概念、方法和手段。
在此列表中，您会发现:
- 强化学习教程，
- 在哪里应用强化学习的例子，
- 有趣的强化学习项目，
- 掌握强化学习的课程。
所有这些内容将帮助你从 RL 新手走向 RL 专业。
强化学习教程
1。 RL 与马里奥兄弟——在这个独特的教程中了解强化学习，它基于有史以来最受欢迎的街机游戏之一——超级马里奥。
2。人类的机器学习:强化学习——本教程是电子书《人类的机器学习》的一部分。它解释了强化学习的核心概念。有无数的例子，对强化学习算法未来的下一步的指导，以及易于理解的形象化解释。
3。强化学习介绍——这里有很多知识，解释得非常清晰和热情。它从强化学习及其过程和任务的概述开始，探索不同的强化学习方法，并以深度强化学习的基本介绍结束。
4。强化学习从零开始——本文将带你领略作者从零开始学习 RL 的过程。作者在 Unity Technologies 工作时学到了很多深度强化学习的知识。即使是初学者也能理解他对强化学习核心概念的概述。
5。自动化股票交易的深度强化学习–在这里，您将找到使用强化学习的股票交易策略的解决方案，该解决方案优化了投资流程，并使投资回报最大化。文章包括对三种组合算法的适当解释:近似政策优化(PPO)、优势行动者-批评家(A2C)和深度确定性政策梯度(DDPG)。每个算法中的最佳算法被协调以提供优化股票交易策略的解决方案。
6。强化学习在现实世界中的应用——探索强化学习框架在设计决策模型时是如何被低估的。对现实项目中 RL 应用的详细研究，解释什么是强化学习框架，并列出其在现实环境中的用例。它将应用缩小到 8 个学习领域，包括机器学习、深度学习、计算机游戏等主题。作者还探讨了 RL 与其他学科的关系，并讨论了 RL 的未来。
7 .。实用 RL——这个 GitHub repo 是一个关于强化学习的开源课程，在几个大学校园里教授。维护回购是为了支持在线学生选择两种语言环境，即俄语和英语。该课程提供聊天室、评分、常见问题解答、反馈表格和虚拟课程环境等服务。课程大纲涵盖了从 RL 基础到讨论和实现不同的模型、方法等等。
8。 用 Tensorflow 进行简单的强化学习第 0 部分:用表格和神经网络进行 Q 学习——关于用 TensorFlow 进行强化学习的教程系列的第一部分。作者研究了 RL 算法家族中的 Q 学习算法。首先实现算法的简单表格查找版本。关于使用 Tensorflow Q 算法实现神经网络的详细指南绝对值得您关注。
哪里应用强化学习的例子
1。火箭工程——探索强化学习在火箭发动机开发领域的应用。你会发现很多关于机器学习在制造业中的应用的有价值的信息。看看为什么在制造火箭发动机时，强化学习比其他机器学习算法更受青睐。
2。交通灯控制——该网站提供了多个研究论文和项目实例，突出了核心强化学习和深度强化学习在交通灯控制中的应用。它有教程、数据集和相关的范例论文，使用 RL 作为主干，这样你就可以做出自己的新发现。
3。营销和广告——看看如何让一个 AI 系统从一个预先存在的可能不可行或不可用的数据集学习，以及如何通过创建广告内容让 AI 实时学习。这是他们利用强化学习的地方。
4。市场营销中的强化学习|作者 deep thi A R——这个例子关注的是市场营销人员需要适应的不断变化的商业动态。配备了强化学习方案的人工智能可以从实时变化中学习，并帮助制定适当的营销策略。这篇文章强调了不断变化的商业环境是一个问题，强化学习是一个解决方案。
5。机器人——这个视频演示了强化学习在机器人技术中的应用。目的是展示机器人自主强化学习代理的实现。在机器人学中使用强化学习的主要例子。
6。推荐——推荐系统广泛应用于电子商务和商业网站的产品广告中。在许多流行的平台，如 YouTube、Google 等，总会有一个推荐区。如果没有强化学习，人工智能从实时用户交互中学习，然后向他们建议内容的能力是不可能的。本文展示了强化学习算法的使用以及在推荐系统中的实际实现。
7 .。医疗保健——医疗保健是一个庞大的行业，有许多尖端技术与之相关，人工智能的使用并不新鲜。这里的主要问题是如何优化医疗保健中的人工智能，并使其基于实时体验进行学习。这就是强化学习的用武之地。强化学习对医疗保健有着不可否认的价值，因为它有能力调节终极行为。利用 RL，医疗保健系统可以以更低的成本提供更详细、更准确的治疗。
8。 NLP 这个例子可能对从事自然语言处理和游戏解决方案的学习者有所启发。
9。交易——深度强化学习在股票交易市场上是一股不可小觑的力量。这里的例子演示了如何使用深度强化学习技术来分析股票交易市场，并提供适当的投资报告。只有配备了强化学习的人工智能才能提供准确的股市报告。
有趣的强化学习项目
1。CARLA–CARLA 是一款用于自动驾驶研究的开源模拟器。CARLA 的主要目标是支持自动驾驶系统的开发、培训和验证。凭借一套开源代码和协议，CARLA 提供了免费使用的数字资产。CARLA 生态系统还集成了运行条件强化学习模型的代码，具有独立的 GUI，以增强带有交通灯和交通标志信息的地图。
2。深度学习 Flappy Bird——如果你想以有趣的方式了解深度 Q 学习算法，那么这个 GitHub repo 就是为你准备的。该项目使用深度 Q 网络来学习如何玩 Flappy Bird。它遵循强化学习家族中的深度 Q 学习算法的概念。
3。 Tensorforce 它建立在 Google 的 Tensorflow 框架之上。它包含高级设计实现，如基于组件的模块化设计、RL 算法和应用的分离以及完整的张量流模型。
4。Ray–Ray 的主要目标是为构建分布式应用程序提供通用的 API。这个项目利用了 RLlib 包，这是一个可扩展的强化学习库，可以加速机器学习工作负载。
5。Neurojs——JavaScript 流行，开发网站必备。如果您需要在 JS web 项目中加入强化学习，该怎么办？向 Neurojs 问好，这是一个在浏览器中使用强化学习进行深度学习的 JavaScript 框架。它也可以执行一些神经网络任务。
6。马里奥 AI——如果你正在寻找一个具有模拟游戏的强化学习算法的项目，这个项目肯定会引起你的兴趣。Mario AI 提供了一个编码实现来训练一个模型，该模型只使用原始像素作为输入，自动播放超级马里奥世界的第一关。所应用的算法是强化学习算法家族中的深度 Q 学习算法。
7 .。深度交易代理——为比特币提供基于深度强化学习的交易代理的开源项目。该项目利用 DeepSense 网络进行 Q 函数逼近。目标是使用优化深度 Q 学习代理的强化学习算法来简化交易过程。它可以成为知识的重要来源。
8。Pwnagotchi——如果你正在使用深度强化学习技术破解 Wifi 网络，这个项目会让你大吃一惊。Pwnagotchi 是一个系统，它从周围的 Wi-Fi 环境中学习，以最大限度地利用它捕获的可破解的 WPA 关键材料。与大多数基于强化学习的系统不同，Pwnagotchi 会随着时间的推移放大其参数，以更好地破解你所暴露的环境中的 WiFi 网络。
掌握强化学习的课程
1。 【强化学习专业化(Coursera)——市场上最好的课程之一。总评分为 4.8 星，已有 21000 多名学生注册，本课程将帮助您掌握强化学习的概念。您将学习如何实现完整的 RL 解决方案，并注意其在解决现实问题中的应用。本课程结束时，你将能够将任务形式化为强化学习问题及其适当的解决方案，理解 RL 算法的概念，以及 RL 如何适应更广泛的机器学习。
2。****Python 中的强化学习(Udemy)–这是 Udemy 提供的高级课程，价格为 29.99 美元。它的总体评级为 4.5 星，有超过 39，000 名学员注册。本课程是那些寻求通过 Python 编程中的强化学习来实现人工智能解决方案的人的学习平台。通过理论和实践实现，你将学会将基于梯度的监督机器学习方法应用于强化学习，众多强化学习算法的编程实现，也知道 RL 和心理学的关系。
**3。 【实用强化学习(Coursera)——评分 4.2，37000+学习者，该课程是高级机器学习专业化的必备板块。你一定会了解 RL 算法的实际实现。您将深入了解强化学习方法的基础，并使用神经网络技术进行强化学习。一个有趣的部分是训练神经网络使用 RL 自己玩游戏。
4。理解强化学习的算法——如果你是强化学习领域的初学者，那么这可能是最适合你的课程。该课程在 PluralSight 平台中的总体评分为 4.0 星，持续时间近 3 小时，可以快速入门强化学习算法。您将获得关于强化学习算法、强化学习算法的基本原理、RL 分类和 RL 家族算法(如 Q-learning 和 SARSA)的深入信息。
5。佐治亚理工学院强化学习(Udacity)——最好的免费课程之一，由佐治亚理工学院通过 uda city 平台提供。该课程是为那些寻求从理论角度理解机器学习和人工智能世界的人制定的。它为最近关于强化学习的研究提供了丰富的见解，这将有助于您探索自动化决策模型。
6。强化学习冬季(斯坦福教育)——本课程由斯坦福大学提供冬季课程。对课程有一些基本的要求，比如 Python 编程的熟练程度，线性代数和微积分的知识，统计和概率的基础，机器学习的基础。本课程提供最新的讲座。最后，你将能够定义强化学习的关键特征，强化学习在现实世界问题上的应用，强化学习算法的编码实现，并对强化学习算法有深入的了解。本课程适合那些寻求 RL 生态系统高级学习资源的人。
7。高级 AI:用 Python 进行深度强化学习——如果你正在寻找一门关于强化学习的高级课程，那么这无疑是 Udemy 平台中最适合你的课程。这是一门标价为 29.99 美元的高级课程，评分为 4.6 星，为全球 32，000 多名学生提供娱乐。它不仅仅是基础级别的强化学习，还包括深度强化学习及其使用 Python 编程的实际实现。深度学习代理、Q 学习算法、深度神经网络、RBF 网络、具有深度 Q 学习的卷积神经网络的实际实现是本课程的主要内容。
8。实用强化学习——Coursera 提供的另一个热门课程，最适合那些寻找强化学习实用知识的人。它的总评分为 4.2 星，已有超过 37，000 名学生注册。
你还在等什么？开始学吧！
希望这些资源能帮助你深入理解强化学习，以及它在现实世界中的实际应用。
RL 是机器学习中令人着迷的一部分，值得你花时间在上面去掌握它。祝你好运！
克里斯萨纳瓦特·卡韦桑穆昂
InstaMobile 的开发者关系
只是一个典型的内向开发者，美国——没有上瘾，对人工智能和区块链充满热情。
阅读下一篇
强化学习的 10 个现实应用
10 分钟阅读|作者 Derrick Mwiti |年 5 月 25 日更新
在强化学习(RL) 中，智能体在一个奖励和惩罚机制上接受训练。代理人因正确的移动而得到奖励，因错误的移动而受到惩罚。在这样做的时候，代理人试图最小化错误的移动，最大化正确的移动。
在本文中，我们将看看强化学习在现实世界中的一些应用。
自动驾驶汽车中的应用
各种论文都提出了针对自动驾驶的深度强化学习。在自动驾驶汽车中，有各种各样的方面需要考虑，例如各个地方的速度限制，可驾驶区，避免碰撞——仅举几例。
一些可以应用强化学习的自动驾驶任务包括轨迹优化、运动规划、动态路径、控制器优化和基于场景的高速公路学习策略。
比如，可以通过学习自动泊车政策来实现泊车。可以使用 Q 学习来实现变道，而超车可以通过学习超车策略来实现，同时避免碰撞并在其后保持稳定的速度。
AWS DeepRacer 是一款自主赛车，旨在在物理赛道上测试 RL。它使用摄像头来可视化跑道，并使用强化学习模型来控制油门和方向。
机器学习项目合作的最佳软件
在机器学习项目上的合作具有挑战性。它需要专注，注意细节，以及很强的分析能力。但这也需要工具。
当你独自做一个项目时，你在工作风格上有充分的灵活性。那么，当你和你的团队合作的时候，该怎么做呢？保持灵活性是可能的，但是没有合适的软件是不可能做到的。
在机器学习项目上有许多协作工具，但并不是所有工具都能增强工作。秘密在于特性。
这里有 9 个最好的软件，它们会让从事 ML 项目的人的生活变得更容易。
所有这些协作平台都被机器学习和数据科学从业者所使用，并且可以很容易地整合到敏捷项目管理的过程中。因此，如果你想改善你的 ML 团队的合作，你来对地方了。
注:如果你对数据科学协作的话题感兴趣，请查看本文“数据科学工作者如何协作？角色、工作流和工具。
1.海王星——机器学习和数据科学的合作
Neptune 是个人和团队用于实验跟踪和模型注册的元数据存储。它为他们提供了一个中心位置来记录、存储、显示、组织、比较和查询机器学习生命周期中生成的所有元数据。
有了 Neptune，ML 团队可以合作研究他们的模型，跟踪他们的实验，并将历史数据存储在一个应用程序中。该流程定义明确，结构良好，最重要的是，标准化。
如果你是 ML 团队的一员，你可能最感兴趣的一件事是，Neptune 也很容易建立。 API 是与基础设施无关的，因此它将很好地适应您已经拥有的(或计划构建的)任何工作流。实际上几行代码就可以了，而与 ML 库的 25+集成让这变得更加容易。
“对我来说，海王星最重要的是它的灵活性。即使我在本地笔记本电脑上使用 Keras 或 Tensorflow 进行训练，而我的同事在虚拟机上使用 fast.ai，我们也可以在一个公共环境中分享我们的结果。”
以下是 Neptune 的几个特别增强团队协作的特性:
- 用户管理功能，包括角色区分和访问管理，
- 分享按钮可以让你复制、发送电子邮件或发推文链接到 Neptune UI 中的任何页面
- 与项目成员和外部人员共享 UI 链接的可能性，
- 基于使用的定价 方案，允许您向团队工作区添加任意数量的成员，而不会影响基本费用
- 可扩展性运行数千次
\ u 003 cimg class = \ u 0022 lazy load block-blog-intext-CTA _ _ arrow-image \ u 0022 src = \ u 0022 https://Neptune . ai/WP-content/themes/Neptune/img/image-ratio-holder . SVG \ u 0022 alt = \ u 0022 \ u 0022 width = \ u 002212 \ u 0022 height = \ u 002222 \ u 022
2.GitHub–软件开发平台
GitHub 是最受开发者欢迎的平台。它被全球数以百万计的团队使用，因为它允许简单和无痛的协作。有了 GitHub，你可以托管和审查代码，管理项目，构建软件。
对于那些希望简化工作流程和方便地分享想法的机器学习项目团队来说，这是一个很好的平台。GitHub 让团队管理想法，协调工作，并与整个团队保持一致，以便在机器学习项目上无缝协作。
以下是一些主要特性您和您的团队会发现很有帮助:
- 在管理代码的同一位置，以您想要的方式构建、测试、部署和运行 CI/CD
- 使用动作自动发布新的包版本到 GitHub 包。在您的 CI/CD 工作流中安装 GitHub 包或您首选的记录注册表上托管的包和映像
- 该软件允许您使用漏洞警报来保护您的工作，以便您可以补救风险并了解 CVEs 如何影响您
- 内置的评审工具使得评审代码变得简单方便——团队可以提出变更，比较版本，并给出反馈
- GitHub 可以轻松地与其他工具集成以实现流畅的工作，或者您可以使用 GitHubGraphQL API 创建自己的工具
GitHub 是一个可以轻松访问所有文档的平台，所有的功能使它成为一个灵活开发软件的统一系统。
“根据我的经验，我发现 GitHub 在与团队成员合作进行 ML 项目时帮助很大。它提供了一个公共平台，在这里我们可以对我们的实验进行版本控制，编写文档，创建分支和分叉以避免意外。此外，GitHub 中大型 ML 项目库的可用性有助于快速实现代码/调试。”
\ u 003 cimg class = \ u 0022 lazy load block-blog-intext-CTA _ _ arrow-image \ u 0022 src = \ u 0022 https://Neptune . ai/WP-content/themes/Neptune/img/image-ratio-holder . SVG \ u 0022 alt = \ u 0022 \ u 0022 width = \ u 002212 \ u 0022 height = \ u 002222 \ u 022
3.吉拉–敏捷团队的项目管理
吉拉对于敏捷团队来说是一个非常棒的软件，因为它允许全面的项目管理。这是一个问题和项目跟踪工具，因此团队可以计划、跟踪和发布他们的产品或软件，作为一个完美开发的“有机体”。
吉拉允许灵活的工作流程自动化。您可以通过将特定任务分配给人员、将 bug 分配给程序员、创建里程碑或计划在特定时间框架内执行特定任务来自由管理项目。
基于吉拉平台的产品和应用帮助团队计划、分配、跟踪、报告和管理工作。四个产品建立在吉拉平台上:吉拉软件，吉拉服务台，吉拉 Ops 和吉拉核心。每个产品都带有针对不同用例的内置模板，并且可以无缝集成，因此跨组织的团队可以更好地合作。
“我们使用 GitHub 和吉拉。GitHub 是我们维护所有代码/回购的地方，因为我们遵循敏捷模型，所以我们使用吉拉来维护我们的故事，并且还创建了一个 API，可以直接将我们的 GitHub 代码连接到吉拉(如果有人想看的话)。”
吉拉是程序员、分析师、软件架构师和所有软件开发团队协作的绝佳解决方案。它有助于简化、组织和构建工作流。
\ u 003 cimg class = \ u 0022 lazy load block-blog-intext-CTA _ _ arrow-image \ u 0022 src = \ u 0022 https://Neptune . ai/WP-content/themes/Neptune/img/image-ratio-holder . SVG \ u 0022 alt = \ u 0022 \ u 0022 width = \ u 002212 \ u 0022 height = \ u 002222 \ u 022
4.Slack–兼容其他应用的在线聊天
Slack 是最受欢迎的通信应用之一。它还可以增强从事机器学习项目的人的工作。
Slack 是将电子邮件转换成消息，将人员、信息和工具放在一个地方。
通过将人、应用程序和数据结合起来，它有效地取代了电子邮件和又长又乱的线程。此外，它让人们看到一个更大的画面，这样每个人都可以看到公司内部发生的事情，并保持在循环中。
Slack 使跟踪对话或在易于搜索的档案中查找重要信息变得简单。因此，当一个团队在一个 ML 项目中工作时，他们总是知道发生了什么，并且能够简化流程。
Slack 主要功能汇总:
- 工作区–您可以为不同的项目或团队创建多个工作区
- 频道–私人或公共，与客户共享，让您快速与其他人交流
- 直接和群组消息
- 公司的关键信息–线索、提及和反应、已保存的项目和人员都在您的手边，因此您可以在应用程序中快速导航
- 应用程序(Apps)——众多工具的清单让你可以将 Slack 与其他流行的工具整合在一起
- 文件——一个空间，你和你的团队以及整个公司可以在这里存储文件，并通过搜索选项轻松访问它们或上传新文件
保存草稿 - 历史记录和搜索让您可以快速、轻松地搜索您想要的东西
- 屏幕共享视频通话
- 创建自动化日常操作和通信的工作流
- 邮件和文件可以加密，您可以联系销售团队获得更多安全选项
Slack 是一个强大的沟通和协作工具，它小巧的特性允许团队以敏捷的方式工作。
5.idea . so–一体化工作空间
概念是一个协作工具，让你写，计划，合作，并组织团队合作。
它由四个模块组成，每个模块具有不同的功能:
- 笔记、文档–文本编辑器，为不同格式的文件、笔记提供空间；你可以添加图片、书签、视频、代码等等
- 知识库–在这个模块中，团队可以存储关于项目、工具、最佳实践以及开发机器学习项目所需的其他方面的知识
- 任务、项目–任务和项目可以组织在看板、日历和列表视图中
- 数据库–该模块可以有效地取代电子表格，并以方便的方式记录重要数据和独特的工作流程
此外，每个团队成员都可以使用个人使用的概念来记录与工作相关的活动和信息，例如，每周议程、目标、任务列表或个人注释。
其他小功能包括 #markdown。/Slash 命令、拖放功能、评论和讨论，以及与 50 多个流行应用程序的集成，如 Google Docs、Github Gist、CodePen 等
所有模块创建一个连贯的系统，作为工作管理和项目规划的统一中心。这是一个适合敏捷团队的轻量级工具。
“观念是研究和实验过程的一部分。部分实验文件保存在那里。Jupyter 笔记本是我们在研究过程中使用的主要 IDE，因为它简化了结果可视化和知识共享。
Github，我们主要用于产品开发。在有了研究答案之后，我们确信开发应该被集成到主产品中，这就是我们使用 Github 的时候——从版本控制到 git 管道。
吉拉:我们用它来定义研究路线图和产品本身。
Slack 和 Zoom 是聊天和视频支持，可用于任何思想交流或深入讨论。"
6.汇合点–产品文档工作区
Confluence 是由 Atlassian 开发的协同工作空间。它已经存在了很长时间(17 年),并根据社区不断变化的需求进行了相应的改进。今天，confluence 主要用作远程协作的工作空间。
它支持维护单一真实来源，并允许用户通过高级搜索功能快速找到特定信息。Confluence 有几个协作特性，这使它成为企业协作的一个非常有用的工具。其中一些包括实时编辑、聊天、通知、评论、注释、标签、页面树、项目层级和访问控制。
Confluence 拥有超过 75，000 名客户，并且还在继续增长。Confluence 非常适合协作工具的生态系统。由于可以与 Slack、吉拉、Dropbox、G-Drive 和 Trello 等常用应用程序集成，这使得它成为一个受欢迎的选择。
“我合作过的团队通常使用 Gitlab 来托管存储库。我也使用过 JIRA、Trello 和 Azure Board 进行项目管理，公司或团队通常会选择这些工具中的一个。我也曾使用 Confluence 进行文档处理，但最近我一直在使用 Dropbox 或 box 的授权版本，这取决于公司的选择。为了交流，我用过很多工具，包括 Slack、Matterport 和公司内置的聊天应用。
我之前的团队也使用过 Tableau 和其他类似的仪表板应用程序。我们广泛使用 Docker 来开发和部署容器化的应用程序，以及商业云平台，如 Azure/AWS for compute。"
7.Google Meet–实时会议
Google Meet 是最流行的电子会议平台之一。这对在机器学习项目上合作的远程团队尤其有帮助。Google Meet 允许团队以冲刺、会议、个人聊天或任何其他首选形式会面。
使用您的浏览器，您可以与队友和客户分享您的视频、桌面和演示文稿。
Google Meet 与 G Suite 的 Google Calendar 和 Gmail 集成在一起，因此您可以看到参与者和预定会议的完整列表。
您可以轻松快速地安排会议，并提前为团队成员设置，以便他们稍后可以通过自动生成的链接加入会议。
如果您的公司使用 G Suite，您可以通过拨打给定会议的电话号码来访问会议。它可以单独用于音频会议或视频会议，因为它允许用户关闭摄像头或静音麦克风，以便人们可以专注于正在发言的人。
\ u 003 cimg class = \ u 0022 lazy load block-blog-intext-CTA _ _ arrow-image \ u 0022 src = \ u 0022 https://Neptune . ai/WP-content/themes/Neptune/img/image-ratio-holder . SVG \ u 0022 alt = \ u 0022 \ u 0022 width = \ u 002212 \ u 0022 height = \ u 002222 \ u 022
即使你和 AI/ML 社区没有什么联系，你也会和 Jupyter 笔记本一起工作或者至少听说过它。它在刚刚开始机器学习之旅的初学者中特别受欢迎，但也同样被专家用作强大的合作工具。
Jupyter notebook 是一个网络应用程序，用户不仅可以编码，还可以维护极其详细的文档,包括视觉效果、结果、时间细节、序列、日志等等。在某种程度上，它促进了现有的最好的编码类型——伴随文档而来的那种。
Jupyter 笔记本支持超过 40 种语言，并且广泛用于 Python。它还支持 ML 友好的语言，如 R、Matlab 和 Scala，以及流行的编程语言，如 Java 和 C++。
由于易于使用和理解，Jupyter 笔记本是为门外汉分解复杂过程、为 AI/ML 平台创建用户友好的教程或记录实验的首选。
\ u 003 cimg class = \ u 0022 lazy load block-blog-intext-CTA _ _ arrow-image \ u 0022 src = \ u 0022 https://Neptune . ai/WP-content/themes/Neptune/img/image-ratio-holder . SVG \ u 0022 alt = \ u 0022 \ u 0022 width = \ u 002212 \ u 0022 height = \ u 002222 \ u 022
9.Google Docs–跨组织的实时协作
Google Docs 是组织文件和实时协作的最佳解决方案之一，无论有多少用户在处理这个文件。
甚至我是用谷歌文档写这篇文章的，所以参与发表的其他人可以很容易地合作。
Google Docs 有有用的功能，方便团队的工作:
- 根据需要创建尽可能多的文件，根据需要调整它们
- 使用模板库中的模板
- 加载项允许用户定制文档，以便更灵活有效地工作
- 智能编辑和样式工具有助于轻松设置文本和段落的格式——您可以从数百种字体中进行选择，添加链接、图像和绘图
团队成员可以通过手机、平板电脑或电脑访问、创建和编辑文档 - 每个人都可以同时在同一个文档中工作
所有的更改都会自动保存——无需将文件保存在本地计算机或其他设备上 - 您可以使用修订历史来查看同一文档的旧版本，按日期和更改者排序。
Google Docs 是机器学习项目协作的必备工具。
把它包起来
当选择用于 ML 项目协作的软件时，确保它符合您团队的偏好、工作风格，并且可以轻松地与您当前使用的应用程序集成。
这是确保项目一致性、无缝工作流和安全性的最佳方式。
合作愉快！
模型调整和超参数优化的最佳工具
我清楚地记得两年前我参加的一次机器学习黑客马拉松，当时我正处于数据科学职业生涯的初期。这是尼日利亚数据科学组织的训练营的资格预审黑客马拉松。
该数据集包含某些雇员的信息。我必须预测一个员工是否应该得到晋升。经过几天努力改进和设计功能，该模型的准确性似乎在 80%左右波动。
我需要做些什么来提高我在排行榜上的分数。我开始手动调整模型——得到了更好的结果。通过改变一个参数，准确率提高到了 82%(这一步非常重要，任何参加过黑客马拉松的人都可以证明！).兴奋之余，我开始调整其他超参数，但结果并不都很好。我已经精疲力尽了，想象一下连续工作 7 个小时来改进一个模型。挺累的。
我知道 GridSearchCV T1 和 T2 randomsearccv T3。我试用了 GridSearchCV，花了 3 个多小时才从我提供的一系列值中得出结果。更糟糕的是，来自 GridSearchCV 的结果并没有更好。沮丧之余，我决定试试 RandomSearchCV。这带来了一点喜悦，我的准确率从 82%上升到了 86%。
经过大量的试验，没有改善，我回到手动调谐，看看我能得到什么。在黑客马拉松结束时，我达到了 90%的准确率。我希望我已经知道了更快优化超参数的工具！幸运的是，尽管我没有进入前 50 名，我仍然有资格参加训练营。
那是过去的事了。现在，我知道有很好的超参数调优工具我可以使用，我很高兴与您分享它们。
在开始超调之前，请确保完成以下工作:
- 获得基线。您可以通过较小的模型、较少的迭代、默认参数或手动调整的模型来实现这一点。
- 将您的数据分成训练集、验证集和测试集。
- 使用提前停止周期来防止过度拟合。
- 在培训前设置好您的完整模型管道。
现在，我想讨论一下我将在文章中使用的一些术语:
- 模型参数–模型参数是您的模型从数据中学习的参数，如特征、关系等。，不能手动调整(不是特征工程)。
- 模型超参数–超参数是您可以从模型本身手动调整的值，如学习率、估计器数量、正则化类型等..
- 优化–通过使用优化技术之一，调整超参数以最小化成本函数的过程。
- 超参数优化–超参数优化只是一个搜索，以获得最佳超参数集，从而在特定数据集上给出模型的最佳版本。
- 贝叶斯优化–一类基于模型的顺序优化(SMBO)算法的一部分，用于使用之前实验的结果来改进下一次实验。
- 超参数采样–简单指定在超参数空间使用的参数采样方法。
我不反对使用 GridSearchCV。这是一个很好的选择，只是它非常耗时，计算量也很大。如果你像我一样，日程繁忙，你一定会找到更好的选择。
更好的替代方法是 RandomSearch CV，它使用随机超参数值来挑选最佳超参数。这比 GridSearchCV 快多了。这里的缺点是，由于它采用随机值，我们不能确定这些值是最佳组合。
但是说真的，我什么时候知道我需要做超参数优化？
作为数据科学家，我们经常犯的一个错误是使用模型的默认参数。根据您使用的默认参数，您可能没有使用模型的最佳版本。
有时，当您的模型过度拟合(在训练集上表现良好，在测试数据集上表现不佳)或欠拟合(在训练数据集上表现不佳，在测试数据集上表现良好)时，优化您的超参数确实会有所帮助。一点小小的调整就能带来很大的不同，从 60%的准确率到 80%的准确率，甚至更多！
好了，让我们结束介绍。在本文结束时，您将了解到:
- 最好的超参数调优工具，
- 各种开源服务(免费使用)和付费服务，
- 它们的特征和优点，
- 他们支持的框架，
- 如何为你的项目选择最好的工具，
- 如何将它们添加到您的项目中。
我们从一个 TL 开始。下面讨论的所有工具的灾难恢复比较。
模型调整和超参数优化的比较工具
如果您时间紧迫，这张表可以帮助您选择一个好的工具，在您的用例中进行尝试。有关每个工具的详细描述，请继续阅读下表。
接下来，我将从一些开源工具开始。每个工具将按以下方式描述:
- 工具简介，
- 工具的核心特性/优势，
- 如何使用该工具的步骤，
- 关于如何在项目中使用该工具的其他链接。
1.射线调谐
Ray 为构建分布式应用程序提供了一个简单、通用的 API。Tune 是一个 Python 库，用于任何规模的实验执行和超参数调整。Tune 是 Ray 众多包中的一个。Ray Tune 是一个 Python 库，它通过大规模利用尖端的优化算法来加速超参数调整。
为什么应该使用 RayTune？
下面是一些的特点 :
- 它很容易与许多优化库集成，如 Ax/Botorch 和hyperpt。
- 缩放可以在不改变代码的情况下完成。
- Tune 利用各种尖端优化算法，如 Ax/Botorch 、hyperpt和贝叶斯优化，使您能够透明地扩展它们。
- Tune 跨多个 GPU 和多个节点并行化，因此您不必构建自己的分布式系统来加速训练。
- 你可以用 Tensorboard 之类的工具自动显示结果。
- 它为优化算法提供了一个灵活的接口，您可以用几行代码轻松实现和扩展新的优化算法。
- 它支持任何机器学习框架，包括 Pytorch、Tensorflow、XGBoost、LIghtGBM、Scikit-Learn 和 Keras。
使用它需要五个简单的步骤(我假设您已经对数据进行了预处理):
pip install ray[tune]
无论您想在 ML 项目中使用 Tensorflow、Pytorch 或任何其他框架实现 Ray Tune，都有很多教程可供选择。以下是一些可供参考的例子:
您可以从本文中了解更多关于配置光线调节及其功能的信息:“光线调节:一个超参数库，可在任何比例下快速调节超参数”。
2.奥普图纳
Optuna 是专门为机器学习设计的。这是一个黑盒优化器，所以它需要一个目标函数。这个目标函数决定在即将到来的试验中从哪里采样，并返回数值(超参数的性能)。它使用不同的算法，如网格搜索，随机搜索，贝叶斯和进化算法来寻找最佳的超参数值。
一些特征是:
- 高效的采样和剪枝算法。
- 易于安装，要求不高。
- 比远视更容易使用。
- 使用分布式优化。
- 您可以使用 Python 语法定义搜索空间，包括条件和循环。
- 您可以直观地分析优化结果。
- 简单的可伸缩性，很少或不需要修改代码。
Optuna 使用修剪算法。修剪是一种在机器学习和搜索算法中使用的技术，通过删除树中对分类实例来说非关键和冗余的部分来减少决策树的大小。
Optuna 中的修剪会在训练的早期阶段自动停止没有希望的试验，您也可以称之为自动提前停止。Optuna 提供了以下修剪算法:
我将重点介绍使用 Optuna 所需的简单步骤:
- 首先，用“pip install optuna”安装 Optuna，如果它还没有安装的话。
- 定义你的模型。
- 选择要优化的参数。
- 创建一个研究。
- 定义目标函数。
- 优化。
- 检查试验结果。
要查看的教程和示例代码:
您也可以阅读此文章:“Optuna 指导如何监控超参数优化运行”，以更好地了解 Optuna 如何优化您的超参数。
可能有用
检查如何使用 Neptune + Optuna 集成来跟踪您的超参数优化过程。
3.远视
从官方文档来看， Hyperopt 是一个 Python 库，用于在笨拙的搜索空间上进行串行和并行优化，搜索空间可能包括实值、离散和条件维度。
Hyperopt 使用贝叶斯优化算法进行超参数调整，为给定模型选择最佳参数。它可以优化具有数百个超参数的大规模模型。
Hyperopt 目前实现了三种算法:
- 随机搜索，
- Parzen 估计量树，
- 自适应 TPE。
Hyperopt 的设计是为了适应基于高斯过程和回归树的贝叶斯优化算法，但不幸的是，它们目前还没有实现。
远视的特征:
超视需要 4 个基本组件来优化超参数:
- 搜索空间，
- 损失函数，
- 优化算法，
- 用于存储历史(分数、配置)的数据库
在您的项目中使用 Hyperopt 的步骤:
- 初始化要搜索的空间。
- 定义目标函数。
- 选择要使用的搜索算法。
- 运行远视功能。
- 分析存储在 trials 对象中的评估输出。
这里有一些实践教程，你可以看看:
这里还有一款不错的 kaggle 笔记本你可以试试。
4.sci kit-优化
Scikit-Optimize 是 Python 中超参数优化的开源库。它是由 Scikit-learn 背后的团队开发的。与其他超参数优化库相比，它相对容易使用。
它有基于模型的连续优化库，称为贝叶斯超参数优化(BHO)。BHO 的优势在于，他们可以在更少的迭代中找到比随机搜索更好的模型设置。
贝叶斯优化到底是什么？
贝叶斯优化是一种用于黑盒函数全局优化的顺序设计策略，它不采用任何函数形式。它通常用于优化计算量大的函数。至少维基百科是这么说的。
但是，简单地说，BO 评估了从过去的结果看起来更有希望的超参数，并找到了更好的设置，而不是使用迭代次数更少的随机搜索。过去超参数的表现影响未来的决策。
sci kit-Optimize 的特性:
- 基于顺序模型的优化，
- 构建于 NumPy、SciPy 和 Scikit-Learn 之上，
- 开源，商业可用，BSD 许可。
Scikit-Optimize 使用高斯过程的贝叶斯优化基于一种叫做 gp_optimize 的算法。你可以在这里了解更多。如果你对如何从零开始构建自己的贝叶斯优化器感兴趣，你也可以看看这个教程:“如何用 Python 从零开始实现贝叶斯优化”。
以下是使用 Scikit-Optimize 需要遵循的简单步骤:
- 如果尚未安装 skopt，请使用 pip install skopt 安装 skopt。
- 定义模型。
- 决定要优化的参数。
- 定义搜索空间。
- 定义目标函数。
- 运行优化。
以下是在您的项目中实现 Scikit Optimize 的教程列表:
关于 Scikit 优化特性的深入解释，请查看本文。
可能有用
检查如何使用 Neptune + Scikit 优化集成跟踪您的超参数优化过程。
5.微软的 NNI (神经网络智能)
NNI 是由微软开发的免费、开源的 AutoML 工具包。它用于自动化特征工程、模型压缩、神经架构搜索和超参数调整。
它是如何工作的？
该工具调度并运行由调整算法生成的试验作业，以在不同的环境(如本地机器、远程服务器和云)中搜索最佳的神经架构和/或超参数。
微软的 NNI 支持 Pytorch、Tensorflow、Keras、Theano、Caffe2 等框架。，以及像 Sckit-learn、XGBoost、CatBoost 和 LightGBM 这样的库。
NNI 的特色 :
- 很多流行的自动调谐算法(像 TPE 、随机搜索、 GP 调谐器、 Metis 调谐器等等)和提前停止算法 ( Medianstop 、 Curvefitting assessors)。
- NAS(神经架构搜索)框架，用户可以轻松指定他们想要使用的神经架构。
- 通过 NNI 试用 SDK 支持 NAS 算法，如 ENAS(高效神经架构搜索)和飞镖(可区分架构搜索)。
- 通过 NNI 试用软件开发工具包的自动特征工程:您不必创建一个 NNI 实验，只需在您的试用代码中导入一个内置的自动特征工程算法并运行！
- 命令行工具和 web UI 来管理培训实验。
- 可扩展的 API 来定制您的自动 ML 模型。
- 它可以在本地机器、远程服务器、Azure 机器学习、基于 kubernetes 的服务(如 Kube Flow、Adapt DL、Open pal 等)上进行训练..
- 它具有用于超参数调整的方法，包括穷举搜索、启发式搜索、贝叶斯优化和基于 RL。
- 它的一些贝叶斯优化算法的超参数调整是 TPE，GP 调谐器，Metis 调谐器，BOHB，等等。
以下是使用 NNI 时需要遵循的步骤:
- 在 Windows 或 Linux 上安装 NNI 并验证安装。
- 定义和更新模型。
- 启用 NNI API。
- 定义搜索空间。
- 定义你的实验。
- 准备庭审。
- 准备调谐器。
- 准备配置文件。
- 进行实验。
要了解更多关于这些步骤的信息，请查看 NNI 的官方文档。你也可以从 Github 了解更多关于微软的 NNI 算法。
寻找如何在您的项目中实现这一点？看看这个教程:“如何将微软的 NNI 添加到你的项目”。
6.谷歌的 Vizer
AI 平台 Vizier 是一个黑盒优化服务，用于调整复杂机器学习模型中的超参数。
它不仅通过调整超参数来优化模型的输出，还可以有效地用来调整函数中的参数。
它是如何工作的？
- 通过设置结果和影响结果的超参数来确定研究配置。
- 根据已设置的配置值创建研究，使用它来执行实验以产生结果。
为什么要用 Vizer？
- 很好用。
- 需要最少的用户配置和设置。
- 托管最先进的黑盒优化算法。
- 高可用性。
- 可扩展到每项研究数百万次试验，每项研究数千次平行试验评估，以及数十亿项研究。
按照以下步骤使用 Vizer:
在文档页面中，显示了如何使用 curl 进行 API 请求的步骤。
7.AWS Sage 制造商
AWS Sage Maker 是一款完全托管的机器学习服务。使用 SageMaker，您可以快速轻松地构建和训练机器学习模型。您可以在构建后直接将它们部署到生产就绪的托管环境中，就像一个完整的包一样。
它还提供了机器学习算法，这些算法经过优化，可以针对分布式环境中的海量数据高效运行。 SageMaker 本身支持自带算法和框架，还提供灵活的分布式培训选项，以适应您的特定工作流程。
SageMaker 使用随机搜索或贝叶斯搜索进行模型超参数调整。对于贝叶斯搜索，它要么使用接近来自最佳先前训练作业的组合的超参数值的组合来提高性能，要么选择远离它所尝试的那些超参数值的一组超参数值。
AWS Sagemaker 负责提取完成任务所需的大量软件开发技能，同时保持高效、灵活和成本效益。您可以专注于更重要的核心 ML 实验，SageMaker 用类似于您现有工作流程的简单抽象工具补充了剩余的必要技能。您的所有工具都在一个地方，因此您可以在一个平台上轻松地从数据预处理转移到模型构建和模型部署。
简而言之，你可以使用 SageMaker 的自动模型调优，内置算法，自定义算法，以及 SageMaker 为机器学习框架预先构建的容器。
在这些教程中了解更多信息:
👉也检查一下 SageMaker 和 Neptune 之间的比较。
7.Azure 机器学习
Azure 由微软开发，利用其不断扩张的全球数据中心网络。Azure 是一个云平台，可以在任何地方构建、部署和管理服务和应用。
Azure Machine Learning 是一个独立的现代化服务，提供完整的数据科学平台。从数据预处理到模型构建、模型部署和维护，整个数据科学之旅都在一个平台上完成。它支持代码优先和低代码体验。如果你喜欢很少或不喜欢代码，你应该考虑使用 Azure Machine Learning Studio。
Azure Machine Learning Studio 是一个关于 Azure Machine Learning 的门户网站，包含用于项目创作和资产管理的低代码和无代码选项(拖放)。
Azure 机器学习支持以下超参数采样方法:
- 随机抽样用于为每个超参数随机选择一个值，该值可以是离散值和连续值的混合。它还支持低性能运行的提前终止，就像基于树的模型中的提前停止一样。
- 仅当所有超参数都是离散的时，才可以采用网格采样，并且网格采样用于尝试搜索空间中参数的每个可能组合。
- 贝叶斯采样基于贝叶斯优化算法来选择超参数值，该算法尝试选择将导致先前选择的性能提高的参数组合。
对于一个非常大的超参数搜索空间(数百个超参数或更多)，将需要很多次迭代来尝试每一个组合。为了节省您的时间，您可以将早期迭代停止设置为那些结果比早期差的实验(迭代)。Azure 有提前停止策略来帮助你:
- 土匪政策。如果目标性能指标的表现比迄今为止的最佳运行差了一个指定的差值，您可以使用 bandit 策略来停止运行(实验或迭代)。
- 中位数停止策略。像 bandit 策略一样，它放弃目标性能度量比所有运行的运行平均值的中值差的运行。
- 截断选择策略。如果百分比低于您指定的截断百分比值，截断选择策略将取消每个评估间隔的所有运行。
如何在项目中开始使用 Azure 进行超参数调优？
- 定义搜索空间。
- 配置采样。您可以选择格网外采样、贝叶斯采样或随机采样。
- 配置提前终止。您可以使用 Bandit 策略、中值停止策略或截断停止策略。
- 运行一个超调训练实验。
查看微软的这个教程模块:“用 Azure 机器学习调优超参数”。
结论
我希望我能够教你一两件关于超参数工具的事情。不要只是让它停留在你的脑海里，尝试一下吧！请随时联系我，我很乐意了解您的意见和偏好。感谢阅读！
还可以查看其他资源:
文米·阿基雷米
一位热爱为移动设备构建 AI 解决方案的数据科学家和 Android 开发人员。我是一个有抱负的演讲者，对关于人工智能的技术演讲感兴趣。我从事过各种项目，包括图像分类、文本生成、聊天机器人、回归和分类问题。我也写科技文章和博客。
阅读下一篇
如何跟踪机器学习模型的超参数？
卡米尔·卡什马雷克|发布于 2020 年 7 月 1 日
机器学习算法可通过称为超参数的多个量规进行调整。最近的深度学习模型可以通过数十个超参数进行调整，这些超参数与数据扩充参数和训练程序参数一起创建了非常复杂的空间。在强化学习领域，您还应该计算环境参数。
数据科学家要控制好 超参数 空间，才能使 进步。
在这里，我们将向您展示最近的 实践，提示&技巧，和工具以最小的开销高效地跟踪超参数。你会发现自己掌控了最复杂的深度学习实验！
为什么我应该跟踪我的超参数？也就是为什么这很重要？
几乎每一个深度学习实验指南，像这本深度学习书籍，都建议你如何调整超参数，使模型按预期工作。在实验-分析-学习循环中，数据科学家必须控制正在进行的更改，以便循环的“学习”部分正常工作。
哦，忘了说随机种子也是一个超参数(特别是在 RL 领域:例如检查这个 Reddit )。
超参数跟踪的当前实践是什么？
让我们逐一回顾一下管理超参数的常见做法。我们关注于如何构建、保存和传递超参数给你的 ML 脚本。
每个数据科学家和 ML 工程师都应该尝试的 NLP 项目的最佳工具
原文：https://web.archive.org/web/https://neptune.ai/blog/best-tools-for-nlp-projects
自然语言处理 (NLP)是人工智能极其重要的子集。在智能设备使用(也称为人机通信)的增加、自然语言处理在医疗保健领域的进步以及基于云的解决方案的采用等因素的推动下，自然语言处理在企业中得到广泛采用。但是 NLP 到底是什么，为什么它很重要？
NLP 处于语言学、计算机科学和人工智能的交汇点。NLP 的应用程序处理和分析大量自然语言数据——人类所说的所有语言都是自然语言，无论该语言是英语、法语还是普通话——以便以类似人类的方式模仿人类之间的交互。一个好的 NLP 系统能够理解文档的内容，包括其中的细微差别。
为什么 NLP 如此重要？
我们比以往任何时候都更依赖于机器，这在很大程度上要归功于它们比我们更准确的能力，以及让我们更高效的能力。他们不会累。他们没有抱怨。他们从不感到无聊。然而，对于 NLP 任务，有一个主要的障碍…
对于人类来说，掌握一门语言相对简单，但对于机器来说，掌握自然语言是一个很大的挑战。自然语言的创造性和语言的模糊性使得自然语言处理成为一个高要求的领域。解决问题意味着，对于我们的问题，我们提出了一个解决语言创造性和模糊性问题的解决方案，因此，我们向被视为非结构化的数据添加了结构(即，文本没有模式，不像商店中的交易历史记录)。
不同类型的 NLP 任务
NLP 可以执行许多不同的任务，但是有一组基本任务在各种 NLP 项目中经常重复出现。由于它们的重复性，这些任务比其他 NLP 任务得到了更深入的研究。这些基本的 NLP 任务是:
语言建模
语言建模(LM)是给任何单词序列分配一个概率。本质上，在语言建模任务中，我们试图预测序列中出现的下一个单词，给定之前出现的单词的历史。LM 在 NLP 的各种应用中至关重要，是机器能够理解定性信息的原因。语言建模的一些应用包括:语音识别、光学字符识别、手写识别、机器翻译和拼写纠正。
文本分类
文本分类根据文本的内容将预定义的类别分配给文本。到目前为止，文本分类是 NLP 最受欢迎的应用，用于构建各种工具，如垃圾邮件检测器和情感分析机器人。
信息提取
信息抽取(IE)是从非结构化和/或半结构化的文本文档中自动抽取相关信息。这些类型的文档包括电子邮件中的日历事件，或社交媒体上帖子中提到的人名。
信息检索
每个在线的人都与某种信息检索(IR)系统互动，例如谷歌搜索。信息检索的任务是从大量的文档集合中找到与用户查询相关的文档。
对话代理
对话式智能体属于对话式人工智能。对话式人工智能包括建立对话系统，模仿人类在对话方面的互动。对话式人工智能的流行例子包括 Alexa、Siri、Google Home 和面向 Windows 爱好者的 Cortana。像聊天机器人这样的技术也是由对话代理驱动的，并且在企业公司中越来越受欢迎。
文本摘要
自动摘要是通过计算缩短一组数据的过程，以创建代表原始内容中最重要或最相关信息的子集[来源:维基百科 ]。
问题回答
问题回答的任务是构建能够自动回答人类用自然语言提出的问题的系统。
机器翻译
机器翻译(MT)是计算语言学的一个分支，涉及将一段文本从一种语言转换成另一种语言。这种类型的一个流行应用是谷歌翻译。
主题建模
主题建模是一种无监督的机器学习技术，它揭示了大量文档集合的主题结构。NLP 的这种应用是一种非常常见的工具，用于各种领域，如文学和生物信息学。
虽然这些任务各不相同，但是牢牢掌握这些任务足以让任何有抱负的 NLP 实践者具备构建各种 NLP 应用程序的良好基础。掌握这些应用程序的一部分包括学习在解决问题时可以用来提高生产力的技术。
有各种开源工具可以在非结构化文本(或其他形式的自然语言)中找到有价值的见解，并解决各种问题。下面提供的框架列表绝不是详尽的，但是它们是一个很好的开始，使得自然语言处理对于企业或者任何希望在他们的项目中使用 NLP 的人来说都是可行的。事不宜迟，这里列出了自然语言处理(NLP)项目中最常用的框架。
我是 NLTK
自然语言工具包(NLTK)是构建 Python 程序来处理和分析人类语言数据的领先平台之一。 NLTK 文档声明“”提供了 50 多个语料库和词汇资源(如 WordNet)的易用接口，以及一套用于分类、标记化、词干化、标记、解析和语义推理的文本处理库、工业级 NLP 库的包装器和一个活跃的讨论论坛。'
像编程世界中的大多数事情一样，掌握 NLTK 需要一些时间。幸运的是，有很多资源可以帮助你掌握这个框架，比如 NLTK 的创造者自己写的《用 Python 进行自然语言处理》一书——这是一种非常实用的自然语言处理任务编程方法。
*可以用 NLTK 执行的一些任务的例子包括标记化、标记、词干化、词汇化、解析、分类等等。看看下面来自 NLTK 文档的代码片段。
import nltk
sentence = """At eight o'clock on Thursday morning Arthur didn't feel very good."""
tokens = nltk.word_tokenize(sentence)
print(tokens)
>>>> ['At', 'eight', "o'clock", 'on', 'Thursday', 'morning', 'Arthur', 'did', "n't", 'feel', 'very', 'good', '.']
tagged = nltk.pos_tag(tokens)
print(tagged[0:6])
>>>> [('At', 'IN'), ('eight', 'CD'), ("o'clock", 'JJ'), ('on', 'IN'),
('Thursday', 'NNP'), ('morning', 'NN')]
entities = nltk.chunk.ne_chunk(tagged)
print(entities)
>>>> Tree('S', [('At', 'IN'), ('eight', 'CD'), ("o'clock", 'JJ'),
('on', 'IN'), ('Thursday', 'NNP'), ('morning', 'NN'),
Tree('PERSON', [('Arthur', 'NNP')]),
('did', 'VBD'), ("n't", 'RB'), ('feel', 'VB'),
('very', 'RB'), ('good', 'JJ'), ('.', '.')])
from nltk.corpus import treebank
t = treebank.parsed_sents('wsj_0001.mrg')[0]
t.draw()
空间
SpaCy 的首次发布是在 2015 年 2 月，使其成为 Python 自然语言处理应用程序的最新开源框架之一。与 2001 年创建的 NLTK 相比，SpaCy 的创建者有足够的时间来学习 NLTK 并了解它的不足之处。与 NTLK 相比，最显著的改进之一是性能增强，因为 SpaCy 使用了一些最新最好的算法。
此外，SpaCy 有很好的文档记录，并被设计为支持大量数据。它还包括一系列预训练的自然语言处理模型，这使得学习、教学和使用 SpaCy 进行自然语言处理变得更加容易。
注意 : 如果你希望将深度学习算法应用于你的非结构化数据，SpaCy 可能是你要使用的库——提取任务也是如此。
下面是 SpaCy 文档中 SpaCy 功能的一个例子。
import spacy
nlp = spacy.load("en_core_web_sm")
text = ("When Sebastian Thrun started working on self-driving cars at Google in 2007, few people outside of the company took him seriously.
I can tell you very senior CEOs of major American car companies would
shake my hand and turn away because 'I wasn't worth talking to',
said Thrun, in an interview with Recode earlier this week.")
doc = nlp(text)
print("Noun phrases:", [chunk.text for chunk in doc.noun_chunks])
print("Verbs:", [token.lemma_ for token in doc if token.pos_ == "VERB"])
for entity in doc.ents:
print(entity.text, entity.label_)
>>>> Noun phrases: ['Sebastian Thrun', 'self-driving cars', 'Google', 'few people', 'the company', 'him', 'I', 'you', 'very senior CEOs', 'major American car companies', 'my hand', 'I', 'Thrun', 'an interview', 'Recode']
Verbs: ['start', 'work', 'drive', 'take', 'can', 'tell', 'would', 'shake', 'turn', 'talk', 'say']
Sebastian NORP
Google ORG
2007 DATE
American NORP
Recode ORG
earlier this week DATE
斯坦福·科伦普
CoreNLP 是一个非常受欢迎的用于自然语言处理任务的库，由斯坦福 NLP 社区构建——他们也积极维护该框架。与分别用 Python 或 Cython 编写的 NLTK 和 SpaCy 相反，CoreNLP 是用 Java 编写的——这意味着你的计算机需要有 JDK(但它有用于大多数编程语言的 API)。
在 CoreNLP 主页上，开发者将 CoreNLP 描述为“Java 自然语言处理的一站式商店！CoreNLP 使用户能够导出文本的语言注释，包括标记和句子边界、词性、命名实体、数值和时间值、依存和选区解析器、共指、情感、引用属性和关系。CoreNLP 目前支持 6 种语言:阿拉伯语，中文，英语，法语，德语和西班牙语。
CoreNLP 的主要优势之一是它的可伸缩性，这使它成为复杂任务的首选。另一个因素是，它在建造时就考虑到了速度——它已经过优化，速度极快。
Gensim
Gensim 是一个专门的开源 Python 框架，用于以最有效、最轻松的方式将文档表示为语义向量。作者设计了 Gensim 来使用各种机器学习算法处理原始的、非结构化的纯文本——因此使用 Gensim 来处理主题建模等任务是一个好主意。此外，Gensim 在识别文本相似性、索引文本和导航不同文档方面做得很好。
在文档中，作者明确指出 Gensim 是从零开始构建的，原因有三:
- 实用性–作为行业专家，我们专注于解决实际行业问题的久经考验的算法。更多关注工程，更少关注学术。
- 内存独立性–不需要在任何时候将整个训练语料库完全驻留在 RAM 中。它可以使用数据流处理大型网络规模的语料库。
- 性能–使用 C、BLAS 和内存映射对流行的向量空间算法进行了高度优化。
下面是 Gensim Word2Vec 教程文档页面上的一些代码示例。
import gensim.downloader as api
wv = api.load('word2vec-google-news-300')
for index, word in enumerate(wv.index2entity):
if index == 10:
break
print(f"word #{index}/{len(wv.index2entity)} is {word}")
>>>> word
word
word
word
word
word
word
word
word
word
pairs = [
('car', 'minivan'),
('car', 'bicycle'),
('car', 'airplane'),
('car', 'cereal'),
('car', 'communism'),
]
for w1, w2 in pairs:
print('%rt%rt%.2f' % (w1, w2, wv.similarity(w1, w2)))
>>>> ‘car’ ‘minivan’ 0.69
‘car’ ‘bicycle’ 0.54
‘car’ ‘airplane’ 0.42
‘car’ ‘cereal’ 0.14
‘car’ ‘communism’ 0.06
TensorFlow & PyTorch
尽管是两个非常不同的框架，我认为最好列出这两个框架，因为它们都被认为是深度学习的流行框架。Tensorflow 是较早的一个，它是由谷歌的大脑团队开发的——他们也积极地将该框架用于研究和生产级别的项目。另一方面，Pytorch 是一个基于 torch 库的开源库，主要由脸书的 AI 研究(FAIR)实验室开发。
关于 Tensorflow 或 PyTorch 的争论由来已久，这绝对超出了本文的范围。我给那些不确定学习哪一个的人的建议是学习你的组织使用的，或者你想为之工作的组织。如果他们还没有完全采用深度学习，那么我会说 PyTorch 有一个更容易的学习曲线。
下面你可以看到如何使用这两个框架建立一个 LSTM 模型。首先是 tensor flow——完整的源代码，请访问 Christian Versloot 机器曲线博客。
import tensorflow as tf
from tensorflow.keras.datasets import imdb
from tensorflow.keras.layers import Embedding, Dense, LSTM
from tensorflow.keras.losses import BinaryCrossentropy
from tensorflow.keras.models import Sequential
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.preprocessing.sequence import pad_sequences
additional_metrics = ['accuracy']
batch_size = 128
embedding_output_dims = 15
loss_function = BinaryCrossentropy()
max_sequence_length = 300
num_distinct_words = 5000
number_of_epochs = 5
optimizer = Adam()
validation_split = 0.20
verbosity_mode = 1
tf.compat.v1.disable_eager_execution()
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=num_distinct_words)
print(x_train.shape)
print(x_test.shape)
padded_inputs = pad_sequences(x_train, maxlen=max_sequence_length, value = 0.0)
padded_inputs_test = pad_sequences(x_test, maxlen=max_sequence_length, value = 0.0)
model = Sequential()
model.add(Embedding(num_distinct_words, embedding_output_dims, input_length=max_sequence_length))
model.add(LSTM(10))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer=optimizer, loss=loss_function, metrics=additional_metrics)
model.summary()
history = model.fit(padded_inputs, y_train, batch_size=batch_size, epochs=number_of_epochs, verbose=verbosity_mode, validation_split=validation_split)
test_results = model.evaluate(padded_inputs_test, y_test, verbose=False)
print(f'Test results - Loss: {test_results[0]} - Accuracy: {100*test_results[1]}%')
>>>> Test results - Loss: 0.3655 - Accuracy: 85.6880
这是 PyTorch 中的一个 LSTM——要获得完整的运行和源代码，请访问 PyTorch 文档中的序列模型教程。
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
torch.manual_seed(1)
def prepare_sequence(seq, to_ix):
idxs = [to_ix[w] for w in seq]
return torch.tensor(idxs, dtype=torch.long)
training_data = [
("The dog ate the apple".split(), ["DET", "NN", "V", "DET", "NN"]),
("Everybody read that book".split(), ["NN", "V", "DET", "NN"])
]
word_to_ix = {}
for sent, tags in training_data:
for word in sent:
if word not in word_to_ix:
word_to_ix[word] = len(word_to_ix)
tag_to_ix = {"DET": 0, "NN": 1, "V": 2}
EMBEDDING_DIM = 6
HIDDEN_DIM = 6
class LSTMTagger(nn.Module):
def __init__(self, embedding_dim, hidden_dim, vocab_size, tagset_size):
super(LSTMTagger, self).__init__()
self.hidden_dim = hidden_dim
self.word_embeddings = nn.Embedding(vocab_size, embedding_dim)
self.lstm = nn.LSTM(embedding_dim, hidden_dim)
self.hidden2tag = nn.Linear(hidden_dim, tagset_size)
def forward(self, sentence):
embeds = self.word_embeddings(sentence)
lstm_out, _ = self.lstm(embeds.view(len(sentence), 1, -1))
tag_space = self.hidden2tag(lstm_out.view(len(sentence), -1))
tag_scores = F.log_softmax(tag_space, dim=1)
return tag_scores
model = LSTMTagger(EMBEDDING_DIM, HIDDEN_DIM, len(word_to_ix), len(tag_to_ix))
loss_function = nn.NLLLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)
with torch.no_grad():
inputs = prepare_sequence(training_data[0][0], word_to_ix)
tag_scores = model(inputs)
print(tag_scores)
for epoch in range(300):
for sentence, tags in training_data:
model.zero_grad()
sentence_in = prepare_sequence(sentence, word_to_ix)
targets = prepare_sequence(tags, tag_to_ix)
tag_scores = model(sentence_in)
loss = loss_function(tag_scores, targets)
loss.backward()
optimizer.step()
with torch.no_grad():
inputs = prepare_sequence(training_data[0][0], word_to_ix)
tag_scores = model(inputs)
print(tag_scores)
>>>> tensor([[-1.1389, -1.2024, -0.9693],
[-1.1065, -1.2200, -0.9834],
[-1.1286, -1.2093, -0.9726],
[-1.1190, -1.1960, -0.9916],
[-1.0137, -1.2642, -1.0366]])
tensor([[-0.0462, -4.0106, -3.6096],
[-4.8205, -0.0286, -3.9045],
[-3.7876, -4.1355, -0.0394],
[-0.0185, -4.7874, -4.6013],
[-5.7881, -0.0186, -4.1778]])
了解如何使用 TensorFlow + Neptune 集成或 PyTorch + Neptune 集成来跟踪模型训练元数据。
拥抱脸
近年来，变压器模型极大地推进了 NLP。它本质上是一种新颖的架构，在解决序列间任务时考虑了长期依赖性。在大多数情况下，NLP 模型非常大，需要大量的计算才能得到一个像样的工作模型。拥抱脸 Python 框架为各种 NLP 任务提供了对大量预训练模型的访问。甚至像亚马逊，谷歌人工智能和脸书人工智能利用这个包。
下面是一个用于情感分析的拥抱脸管道的例子——你可以在文档中读到更多相关信息。
from transformers import pipeline
clf = pipeline("sentiment-analysis")
data = ["I am happy to be reading this article",
"I am not happy to read this article",
"This is a really informative article",
"Thank you for reading"]
results = clf(data)
for result in results:
print(f"label: {result['label']}, score: {round(result['score'], 4)}")
>>>> label: POSITIVE, score: 0.9999
label: NEGATIVE, score: 0.9989
label: POSITIVE, score: 0.9998
label: POSITIVE, score: 0.9998
与传统的机器学习项目类似，NLP 项目是高度迭代的。在项目生命周期的旅程中，迭代特定的部分直到 NLP 系统满足一些期望的内在性能水平是很常见的。内在评估更关注中间目标，例如 NLP 组件如何在定义的子任务上执行。
一旦项目被部署到生产环境中，它还远远没有完成。现实世界中的交互、反馈和变化会改变当前 NLP 组件的需求，这意味着循环回到项目生命周期中的早期步骤来更新(或改进)它。
为了让你的 NLP 项目上线，有各种各样的工具不仅可以帮助开发人员，也可以帮助那些不太懂技术的 AI 团队成员。这些工具包括消息应用、实验管理工具、跟踪工具等等。这里有一个有价值的项目管理工具的列表，你可能想用在你的 NLP 项目中:
海王星 AI
海王星。AI 是一个轻量级的实验跟踪和模型注册。它极大地促进了合作，并且可以跟踪你所有的实验。它非常灵活，可以很好地与许多框架集成(包括上面提到的那些)。使用该工具，您可以记录、存储、显示、组织和查询您的所有机器学习操作(MLOps)元数据。
海王 AI 提供了什么？
- 记录和显示机器学习模型的元数据
- 组织实验和模型训练运行的中心
- 轻松比较实验和机器学习模型
- 观看您的机器学习实验实时运行
- 可重复的实验和模型训练运行
- 与队友分享可视化效果的特殊链接
- 以编程方式查询实验和模型训练元数据
- 从任何地方运行您的代码(笔记本电脑、云基础设施或集群)
MLFlow
MLFlow 的一个很酷的地方是，您可以将它用于任何机器学习库和任何编程语言，因为所有可用的函数都是通过 REST API 和 CLI 访问的。除了从技术角度来看的可访问性之外，MLflow 文档编写得非常好，易于理解。文档声明:
“MLflow 是一个管理端到端机器学习生命周期的开源平台。它处理四个主要功能:
- 跟踪实验以记录和比较参数和结果( MLflow Tracking )。
- 以可重用、可复制的形式包装 ML 代码，以便与其他数据科学家共享或转移到生产中( MLflow 项目)。
- 从各种 ML 库中管理和部署模型到各种模型服务和推理平台( MLflow Models )。
- 提供一个中央模型库来协作管理 MLflow 模型的整个生命周期，包括模型版本化、阶段转换和注释( MLflow 模型注册中心)。"
这基本上概括了 MLflow 提供的一切—我告诉过你他们的文档写得很好。
另请阅读:最佳物流替代方案(2021 年更新)
开源代码库
Github 是面向开发者的社交网站。它为全球超过 5600 万开发者提供互联网托管以及使用 Git 的版本控制。Github 使协作变得简单而不费力，其特性允许代码托管和审查、全面的项目管理和方便的软件构建。通常，项目经理和开发人员利用 Github 在单一环境中协调、跟踪和更新他们的工作。
平台有很多特性，每个特性都是多方面的。总的来说，Github 提供的功能分为七类:
- 协作编码
- 自动化和持续集成/持续开发(CI/CD)
- 安全性
- 客户端应用程序
- 项目管理
- 团队管理
- 社区
彗星 ML
彗星的主页。ML 的网站上写着“彗星。ML 允许数据科学家和开发人员轻松地监控、比较和优化他们的机器学习模型——没有比这更清楚的了。其中最受欢迎的功能是他们的现场实验图表；彗星。ML 为您提供了一个引人注目的仪表板，它将您的 ML 实验代码及其结果绑定在一起，还提供了一些功能，帮助从业者通过调整超参数来优化他们的模型。
NLP 项目在许多方面类似于传统的软件应用程序，但也有很大的不同。这是相似的，因为两个应用程序都是在受控的开发环境中制作的。这是不同的，因为 NLP 和机器学习项目通常还包括来自一个永无止境的来源，称为现实世界的数据，因此我们用来构建应用程序的数据也必须被跟踪。
这就是彗星。ML 进来了。彗星。ML 允许用户:
- 追踪数据集，
- 跟踪代码的更改，
- 跟踪实验历史和机器学习见解。
另外彗星。ML 为从业者更快地构建更好的模型提供了有价值的见解和数据，同时也提高了生产率、协作性和可解释性。
另请阅读:最佳 Comet.ml 替代方案
松弛的
想想 WhatsApp，Facebook Messenger，或者 iMessage……现在给它吃类固醇吧。那是懈怠。Slack 是一个面向团队和整个工作组织的消息应用程序。它可以跨各种不同的设备和平台使用。该应用程序具有许多强大的功能，可以让个人在各种聊天室以及一对一的房间中进行交流——自从全球疫情大受欢迎以来，Slack 已经成为企业和团队的一个宝贵工具。
为了让团队的所有成员保持一致，有各种功能，例如:
- 频道——对话的中心空间。各种主题可能有多个渠道(如资源、支持、项目 1)。
- Slack Connect–与来自不同公司的团队合作(对于参与 B2B 服务的公司来说非常好)
- 语音和视频通话
Slack 有许多应用程序和集成，可以全面提高生产率。我个人最喜欢的是 Google Drive 集成，它允许用户共享和管理对文件的访问，以及接收更新等，所有这些都在 Slack 中完成。还集成了其他常见应用程序，如 OneDrive、Zoom 和 Outlook。
吉拉
吉拉是由 Atlassian 开发的，用于专有问题跟踪，使它成为团队以灵活和自动化的方式规划项目、跟踪项目和发布产品或软件的伟大工具。这个工具非常适合敏捷团队，因为它包含了项目管理。用户可以自由地管理他们的项目，给团队成员分配任务(包括给程序员分配 bug)，创建里程碑，计划有指定期限的任务。
吉拉的一些功能包括(在吉拉功能页面上阅读关于这些功能的更多信息):
- Scrum 板
- 看板板
- 路线图
- 敏捷报告
吉拉很受欢迎，是 NLP 项目非常合适的解决方案，因为它促进了协作以及简化、组织和结构化工作流。
最后一个音符
数据科学家、人工智能团队和企业可以使用大量优秀的工具来简化 NLP 项目。
重要的是，您找到了最适合您需求的工具，并且集成了让您的项目顺利完成所需的功能。
感谢您的阅读，祝您的项目好运！*
记录和管理 ML 模型构建元数据的最佳工具
当你在开发机器学习模型时，你绝对需要能够重现实验。如果你得到了一个结果很好的模型，但是你不能复制它，因为你没有记录实验，这将是非常不幸的。
你可以通过记录每一件事来使你的实验具有可重复性。有几个工具可以用来做这件事。在本文中，让我们看看一些最流行的工具，看看如何开始用它们记录实验的元数据。您将了解如何使用这些工具运行一个 LightGBM 实验。
让我们开始吧。
海王星
Neptune 是一个可以用来记录和管理 ML 建模元数据的平台。您可以用它来记录:
- 型号版本，
- 数据版本，
- 模型超参数，
- 图表，
- 还有很多。
海王星托管在云上，不需要任何设置，随时随地都可以访问你的实验。你可以在一个地方组织你所有的实验，并与你的团队合作。你可以邀请你的队友来观看和研究任何实验。
要开始使用 Neptune，你需要安装 neptune-client。你还需要在设立一个项目。这是您将从 Neptune 的 Python API 中使用的项目。
Neptune 的一个新版本刚刚发布。新版本支持更多的工作流，如离线模式、ML 管道和恢复运行。然而，一些集成，如 LightGBM one，仍将被移植到新版本中。因此，在本文中，我使用了一个旧版本。敬请关注这一页的新版本。
下一步是初始化“neptune-client”来处理这个项目。除了项目，你还需要你的 API 密匙。你可以在你的个人资料图片下面得到这个，如下图。
有了这两件事，您现在可以初始化项目了。
import neptune
neptune.init(project_qualified_name='mwitiderrick/LIGHTSAT', api_token='YOUR_TOKEN')
下一步是创建一个实验并命名它。这个实验的参数也在这个阶段传入。
params = {'boosting_type': 'gbdt',
'objective': 'regression',
'num_leaves': 40,
'learning_rate': 0.09,
'feature_fraction': 0.8
}
exp = neptune.create_experiment(name='LightGBM-training',params=param)
现在，您将开始训练 LightGBM 模型。训练时，您将使用 Neptune 的 LightGBM 回调来记录训练过程。你需要安装“Neptune-contrib[监控]”。
接下来，您将导入“neptune_monitor”回调并将其传递给 LightGBM 的“train”方法。
from neptunecontrib.monitoring.lightgbm import neptune_monitor
import lightgbm as lgb
lgb_train = lgb.Dataset(X_train, y_train)
lgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train)
gbm = lgb.train(params,
lgb_train,
num_boost_round=200,
valid_sets=[lgb_train, lgb_eval],
valid_names=['train','valid'],
callbacks=[neptune_monitor()],
)
一旦训练过程结束，您可以回到 Neptune web UI 来查看实验并比较结果。
Neptune 也记录模型度量。例如，让我们看看如何记录平均绝对误差、均方误差和均方根误差。您可以使用“log_metric”功能记录各种指标。
predictions = gbm.predict(X_test)
import numpy as np
from sklearn.metrics import mean_squared_error, mean_absolute_error
neptune.log_metric('Root Mean Squared Error', np.sqrt(mean_squared_error(y_test, predictions)))
neptune.log_metric('Mean Squarred Error', mean_squared_error(y_test, predictions))
neptune.log_metric('Mean Absolute Error', mean_absolute_error(y_test, predictions))
Neptune 还自动记录训练和验证学习曲线。您可以在 web 用户界面的图表菜单下找到这些内容。
记录你训练好的模型是非常重要的。通过这种方式，您可以快速将其投入生产。您可以使用“log_artifact”功能记录所有模型。
gbm.save_model('model.pkl')
neptune.log_artifact('model.pkl')
Neptune 允许您访问这个实验并下载模型。使用“get_experiments”方法访问实验，并使用“download_artifact”功能下载模型。这个模型需要工件的名称以及您想要存储它的路径。
project = neptune.init('mwitiderrick/LIGHTSAT',api_token='YOUR_TOKEN')
experiment = project.get_experiments(id='LIGHTSAT-5')[0]
experiment.download_artifact("model.pkl","model")
查看这款笔记本，了解 Neptune 的更多功能，并体验完整的 LightGBM 实验。
MLflow
MLflow 是一个开源平台，用于跟踪机器学习模型、记录和管理 ML 模型构建元数据。它还集成了流行的数据科学工具。让我们来看看 LightGBM 集成(这种集成在 MLflow 中仍处于试验阶段)。
使用 MLflow 运行实验时，我们要做的第一件事是启用参数和指标的自动记录。
import mlflow
mlflow.lightgbm.autolog()
您也可以使用“log_param”功能手动记录参数。该方法记录当前运行下的参数。如果没有处于活动状态的管路，它将创建一个新管路。
params = {'boosting_type': 'gbdt',
'objective': regression,
'num_leaves': 67,
'learning_rate': 0.01,
'feature_fraction': 0.8
}
mlflow.log_param("boosting_type", params["boosting_type"])
mlflow.log_param("objective", params["objective"])
mlflow.log_param("num_leaves", params["num_leaves"])
mlflow.log_param("learning_rate", params["learning_rate"])
mlflow.log_param("feature_fraction", params["feature_fraction"])
也可以使用“log_model”功能手动记录经过训练的 LightGBM 模型。启用自动记录时，MFlow 会自动记录此情况。
from mlflow.lightgbm import log_model
log_model(artifact_path='lightgbm-model',lgb_model=gbm)
然后，您可以使用该模型对新数据进行预测。加载模型，并使用“预测”功能进行预测。
import mlflow
logged_model = 'file:///Users/derrickmwiti/Downloads/mlruns/0/56cb6b76c6824ec0bc58d4426eb92b91/artifacts/lightgbm-model'
loaded_model = mlflow.pyfunc.load_model(logged_model)
import pandas as pd
loaded_model.predict(pd.DataFrame(data))
如果你将模型作为火花 UDF 加载，你也可以在火花数据帧上进行预测。
import mlflow
logged_model = 'file:///Users/derrickmwiti/Downloads/mlruns/0/56cb6b76c6824ec0bc58d4426eb92b91/artifacts/lightgbm-model'
loaded_model = mlflow.pyfunc.spark_udf(logged_model)
df.withColumn(loaded_model, 'my_predictions')
您可以使用“mlflow.end_run()”函数结束活动的 MLflow 运行。可以随时从网络用户界面查看跑步记录。您可以通过在终端上执行“mflow ui”来启动 web UI。
网络用户界面使得比较不同的跑步变得容易。这将显示不同参数和指标的比较。
您还可以看到不同运行的训练和验证学习曲线的比较。
在 artifacts 部分，您将会找到记录的模型和图表。例如，下面是一次 LightGBM 训练运行的记录特征重要性。
点击查看完整的 MLflow 示例。
检查 MLflow 与海王星相比如何。
权重和偏差
Weights and Biases 是一个平台，用于实验跟踪、模型、数据集版本化以及管理 ML 模型构建元数据。要开始使用它，你必须创建一个账户和一个项目。然后，您将在 Python 代码中初始化项目。
现在让我们导入‘wandb’并初始化一个项目。此时，您可以传递将用于 LightGBM 算法的参数。这些将被记录下来，您将在 web 用户界面上看到它们。
import wandb
params = {'boosting_type': 'gbdt',
'objective': 'regression',
'num_leaves': 40,
'learning_rate': 0.1,
'feature_fraction': 0.9
}
run = wandb.init(config=params,project='light', entity='mwitiderrick', name='light')
下一步是使用来自“wandb”的 LightGBM 回调来可视化和记录模型的训练过程。将“wandb_callback”传递给 LightGBM 的“train”函数。
from wandb.lightgbm import wandb_callback
gbm = lgb.train(params,
lgb_train,
num_boost_round=200,
valid_sets=[lgb_train, lgb_eval],
valid_names=['train','valid'],
callbacks=[wandb_callback()],
)
权重和偏差日志标量，如准确性和回归度量。让我们看看如何记录每次 LightGBM 运行的回归指标。使用“wandb.log”功能。
import numpy as np
from sklearn.metrics import mean_squared_error, mean_absolute_error
predictions = gbm.predict(X_test)
wandb.log({'Root Mean Squared Error': np.sqrt(mean_squared_error(y_test, predictions))})
wandb.log({'Mean Squared Error': mean_squared_error(y_test, predictions)})
wandb.log({'Mean Absolute Error': mean_absolute_error(y_test, predictions)})
网络用户界面还会自动记录培训和验证学习计划。
您还可以从运行中快速创建报告。
您可以保存训练好的 LightGBM 模型，并在每次运行时将其记录到权重和偏差中。实例化一个空的“工件”实例，然后用它来记录模型。数据集可以类似地被记录。
gbm.save_model('model.pkl')
artifact = wandb.Artifact('model.pkl', type='model')
artifact.add_file('model.pkl')
run.log_artifact(artifact)
您将在 web UI 的工件部分看到记录的模型。
您可以使用' wandb.finish()'来结束特定的实验。点击查看完整的带重量和偏差的 LightGBM 示例。
检查权重&偏差与海王星相比如何。
神圣的
神圣是一个开源的机器学习实验工具。该工具还可以用于记录和管理 ML 模型构建元数据。使用神圣时，首先需要创建一个实验。如果你在 Jupyter 笔记本上运行实验，你需要通过“interactive=True”。
from sacred import Experiment
ex = Experiment('lightgbm',interactive=True)
接下来，使用@ex.config装饰器定义实验配置。该配置用于定义和记录算法的参数。
@ex.config
def cfg():
params = {'boosting_type': 'gbdt',
'objective': 'regression',
'num_leaves': 40,
'learning_rate': 0.01,
'feature_fraction': 0.9
}
接下来，定义 run 函数。在交互模式下运行时，这个函数必须用@ex.main修饰。否则，使用 ex.automain。这个修饰器负责计算主文件所在的文件名。带有这些装饰器的函数是在运行实验时执行的函数。对于这个实验，在“run”函数中会发生一些事情:
- LightGBM 模型的训练，
- 保存模型，
- 使用该模型进行预测，
- 使用“log_scalar”方法记录回归度量，
- 使用“add_artifact”函数记录模型。
您还可以使用“添加资源”功能记录资源，如 Python 文件。
import lightgbm as lgb
@ex.main
def run(params):
lgb_train = lgb.Dataset(X_train, y_train)
lgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train)
gbm = lgb.train(params,
lgb_train,
num_boost_round=200,
valid_sets=[lgb_train, lgb_eval],
valid_names=['train','valid'],
)
gbm.save_model('model.pkl')
predictions = gbm.predict(X_test)
ex.log_scalar('Root Mean Squared Error', np.sqrt(mean_squared_error(y_test, predictions)))
ex.log_scalar('Mean Squared Error', mean_squared_error(y_test, predictions))
ex.log_scalar('Mean Absolute Error', mean_absolute_error(y_test, predictions))
ex.add_artifact("model.pkl")
ex.add_resource("main.py")
下一步是进行实验。
r = ex.run()
不幸的是，Sacred 没有提供可以用来查看实验的网络用户界面。为此，您必须使用外部工具。这就把我们带到了下一个图书馆，Omniboard。
总括
Omniboard 是一个基于网络的神圣用户界面。该工具连接到神圣使用的 MongoDB 数据库。然后，它将为每个实验收集的指标和日志可视化。要查看神圣收集的所有信息，您必须创建一个观察者。“MongoObserver”是默认的观察者。它连接 MongoDB 数据库并创建一个包含所有这些信息的集合。
from sacred.observers import MongoObserver
ex.observers.append(MongoObserver())
准备就绪后，您可以从终端运行 Omniboard 。
$ omniboard -m localhost:27017:sacred
然后，您可以通过 127.0.0.1:9000 访问 web 用户界面。
点击跑步将显示更多相关信息。例如度量标准。
您还可以看到在运行过程中记录的模型。
跑步者配置也在那里。
使用神圣+ Omniboard 的完整例子在这里。你必须在服务器或你的本地机器上运行笔记本，这样你就可以完成所有需要的设置来运行 Omniboard。
查查神圣+全能和海王星相比如何。
最后的想法
在本文中，我们使用各种实验跟踪工具运行了机器学习实验。您看到了如何:
- 创建运行和实验，
- 日志模型和数据集，
- 捕获所有实验元数据，
- 比较不同的运行，
- 记录模型参数和度量。
希望你学到了新东西。感谢阅读！
管理机器学习项目的最佳工具
原文：https://web.archive.org/web/https://neptune.ai/blog/best-tools-to-manage-machine-learning-projects
管理机器学习项目并不完全是小菜一碟，但每个数据科学家都已经知道这一点。
它触及了很多东西:
- 数据探索，
- 数据准备和设置机器学习管道
- 实验和模型调整
- 数据、管道和模型版本控制
- 管理基础设施和运行流程编排
- 模型服务化和生产化
- 模型维护(生产中的再培训和监控模型)
- 不同角色(数据科学家、数据工程师、软件开发人员、开发人员、团队经理、业务利益相关者)之间的有效协作
那么如何保证一切顺利进行呢？如何管理所有的部分来创建一个连贯的工作流程？
…通过使用正确的工具来帮助您管理机器学习项目。但是你已经知道了😉有许多应用程序可以帮助你改善部分甚至整个工作流程。当然，自己做每件事真的很酷，但是如果工具能帮你省去很多麻烦，为什么不使用呢
让我们开始吧，看看盘子里有什么！以下是涉及上述各点的工具列表。有些更倾向于端到端，有些专注于机器学习生命周期的特定阶段，但所有这些都将帮助您管理您的机器学习项目。查看我们的列表，选择你最喜欢的。
Neptune 是为运行大量实验的研究和生产团队构建的 MLOps 的元数据存储库。它非常灵活，可以与许多其他框架一起工作，并且由于其稳定的用户界面，它实现了巨大的可伸缩性(达到数百万次运行)。
这是一个强大的软件，可以存储、检索和分析大量数据。Neptune 拥有高效团队协作和项目监督的所有工具。
海王星——概要:
- 为用户和组织管理提供不同的组织、项目和用户角色
- 快速美观的用户界面，具有多种功能来分组组织跑步，保存自定义仪表板视图并与团队共享
- 您可以使用托管应用程序来避免维护另一个工具的所有麻烦(或者将其部署在您的内部基础架构上)
- 您的团队可以跟踪在脚本(Python、R、other)、笔记本(local、Google Colab、AWS SageMaker)中执行的实验，并在任何基础设施(云、笔记本电脑、集群)上执行
- 广泛的实验跟踪和可视化功能(资源消耗、图像列表滚动)
Kubeflow 是 Kubernetes 的 ML 工具包。它通过打包和管理 docker 容器来帮助维护机器学习系统。它通过使机器学习工作流的运行编排和部署更容易来促进机器学习模型的扩展。
这是一个开源项目，包含一组专门针对各种 ML 任务的兼容工具和框架。
kube flow–摘要:
- 用于管理和跟踪实验、作业和运行的用户界面(UI)
- 使用 SDK 与系统交互的笔记本电脑
- 重用组件和管道来快速创建端到端解决方案，而不必每次都重新构建
- Kubeflow Pipelines 可作为 Kubeflow 的核心组件或独立安装使用
DVC 是机器学习项目的开源版本控制系统。这是一个工具，让你定义你的管道，不管你用什么语言。
当您在 ML 模型的先前版本中发现问题时，DVC 通过利用代码数据和管道版本化为您提供再现性来节省您的时间。您还可以训练您的模型，并通过 DVC 管道与您的队友分享。
DVC 可以处理大量数据的版本和组织，并以一种组织良好、易于访问的方式存储它们。它侧重于数据和管道版本化和管理，但也有一些(有限的)实验跟踪功能。
DVC–摘要:
- 可以使用不同类型的存储—不受存储限制
- 完整的代码和数据来源有助于跟踪每个 ML 模型的完整发展
- 通过始终如一地维护输入数据、配置和最初用于运行实验的代码的组合来实现可重复性
- 跟踪指标
- 一种将 ML 步骤连接到 DAG 并端到端运行整个管道的内置方式
Polyaxon 是一个平台，用于复制和管理机器学习项目以及深度学习应用的整个生命周期。
该工具可以部署到任何数据中心、云提供商，并且可以由 Polyaxon 托管和管理。它支持所有主要的深度学习框架，如 Torch、Tensorflow、MXNet。
poly axon–摘要:
- 支持整个生命周期，包括运行流程编排，但可以做的远不止这些
- 有一个开源版本，您可以立即使用，但也为企业提供了选项
- 文档非常完整的平台，包括技术参考文档、入门指南、学习资源、指南、教程、变更日志等等
- 允许使用 experiment insights 仪表板监控、跟踪和分析每个优化实验
GitHub 是最受开发者欢迎的平台。它被全球数以百万计的团队使用，因为它允许简单和无痛的协作。有了 GitHub，你可以托管和审查代码，管理项目，构建软件。
对于那些希望简化工作流程和方便地分享想法的机器学习项目团队来说，这是一个很好的平台。GitHub 允许团队管理想法，协调工作，并与整个团队保持一致，以便在机器学习项目上无缝协作。
GitHub–摘要:
- 在管理代码的同一位置，以您想要的方式构建、测试、部署和运行 CI/CD
- 使用动作自动发布新的包版本到 GitHub 包。在您的 CI/CD 工作流中安装 GitHub 包或您首选的记录注册表上托管的包和映像
- 该软件允许您使用漏洞警报来保护您的工作，以便您可以补救风险并了解 CVEs 如何影响您
- 内置的评审工具使得评审代码变得简单方便——团队可以提出变更，比较版本，并给出反馈
- GitHub 可以轻松地与其他工具集成以实现流畅的工作，或者您可以使用 GitHubGraphQL API 创建自己的工具
- GitHub 是一个可以轻松访问所有文档的平台，所有的功能使它成为一个灵活开发软件的统一系统。
吉拉是敏捷团队的优秀软件，因为它允许全面的项目管理。这是一个问题和项目跟踪工具，因此团队可以计划、跟踪和发布他们的产品或软件，作为一个完美开发的“有机体”。有了 Confluence，团队可以更加灵活地管理 ML 项目。
这两个工具允许灵活的工作流自动化。您可以通过将特定任务分配给人员、将 bug 分配给程序员、创建里程碑或计划在特定时间框架内执行特定任务来自由管理项目。
基于吉拉构建的产品和应用与 Confluence 帮助团队计划、分配、跟踪、报告和管理工作。来自吉拉的所有更新将自动出现在 Confluence 中，因为这两个工具是链接在一起的。
概念是一个协作工具，让你写，计划，并组织团队合作。
它有四个模块，每个模块具有不同的功能:
- 笔记、文档–文本编辑器，为不同格式的文件、笔记提供空间；你可以添加图片、书签、视频、代码等等
- 知识库–在这个模块中，团队可以存储关于项目、工具、最佳实践以及开发机器学习项目所需的其他方面的知识
- 任务、项目–任务和项目可以组织在看板、日历和列表视图中
- 数据库–该模块可以有效地取代电子表格，并以方便的方式记录重要数据和独特的工作流程
此外，每个团队成员都可以使用个人使用的概念来记录与工作相关的活动和信息，例如，每周议程、目标、任务列表或个人注释。
其他小功能包括#markdown。/Slash 命令、拖放功能、评论和讨论，以及与 50 多个流行应用程序的集成，如 Google Docs、Github Gist、CodePen 等。
所有模块创建一个连贯的系统，作为工作管理和项目规划的统一中心。
WandB 专注于深度学习。用户使用 Python 库跟踪应用程序的实验，并且作为一个团队，可以看到彼此的实验。
WandB 是一项托管服务，允许您在一个地方备份所有实验，并与您的团队合作完成一个项目。WandB 允许您记录许多数据类型，并在一个漂亮的 UI 中分析它们。
权重&偏差–汇总:
- 实验跟踪:广泛的日志选项
- 在团队中共享工作的多种功能
- 与其他可用工具的几个开源集成
- SaaS/本地实例可用
- WandB 记录了模型图，因此您可以在以后检查它
这是一个开源的 Python 库，使你能够为机器学习和数据科学构建奇特的定制网络应用。当你需要构建一个快速的概念验证应用程序并展示给某人看时，它是完美的，特别是当某人不太懂技术时。
在 Streamlit 中，您可以在每次更改源代码时自动更新您的应用程序。这使您能够以快速互动的方式工作:
- 你输入代码，保存它，现场试用
- 然后再输入一些代码，保存它，再试一次
- 诸如此类。
Streamlit 的架构允许您像编写普通 Python 脚本一样编写应用程序。
您可以轻松地与其他人分享您的机器学习模型，并有效地在团队中工作。
了解我们如何构建一个 streamlit 应用程序来探索在 COCO 上训练的图像分割和对象检测模型的结果:如何进行图像分割和对象检测的数据探索(我不得不艰难地学习的东西)
亚马逊 SageMaker 是一个平台，使数据科学家能够构建、训练和部署机器学习模型。它拥有用于整个机器学习工作流的所有集成工具，在单个工具集中提供了用于机器学习的所有组件。
SageMaker 是一个适合组织、训练、部署和管理机器学习模型的工具。它有一个基于 web 的可视化界面来执行所有 ML 开发步骤，包括笔记本、实验管理、自动模型创建、调试和模型漂移检测
亚马逊 SageMaker–摘要:
- Autopilot 自动检查原始数据，应用功能处理器，挑选最佳算法集，训练和调整多个模型，跟踪它们的性能，然后根据性能对模型进行排序——它有助于部署性能最佳的模型
- SageMaker Ground Truth 帮助您快速构建和管理高度准确的训练数据集
- SageMaker Experiments 通过自动捕获输入参数、配置和结果，并将其存储为“实验”，来帮助组织和跟踪机器学习模型的迭代
- SageMaker Debugger 在训练期间自动捕获实时指标(如训练和验证、混淆、矩阵和学习梯度)，以帮助提高模型准确性。当检测到常见的培训问题时，调试器还可以生成警告和补救建议
- SageMaker Model Monitor 允许开发人员检测和排除概念漂移故障。它会自动检测已部署模型中的概念漂移，并给出详细的警报，帮助识别问题的根源
Domino Data Lab 是管理机器学习项目的一个很好的工具，适用于需要一个中心来存储所有数据的团队。
Domino 是一个数据科学平台，支持对数据产品如模型、仪表板和数据管道的快速、可重复和协作工作。您可以运行常规作业，启动交互式笔记本会话，查看重要指标，与队友共享工作，并在 Domino web 应用程序中直接与他们交流。
这是一个用于各种机器学习项目的高级管理平台，特别有助于需要共享工作和快速有效地审查代码的成长型组织。
Cortex 是一个开源的替代方案，可以使用 SageMaker 提供模型服务，或者在 AWS 服务(如 Elastic Kubernetes Service (EKS)、Lambda 或 Fargate)和开源项目(如 Docker、Kubernetes、TensorFlow Serving 和 TorchServe)的基础上构建自己的模型部署平台。
这是一个多框架工具，允许您部署所有类型的模型。
皮层–总结:
- 自动扩展 API 以处理生产工作负载
- 对任何 AWS 实例类型运行推理
- 在单个 API 中部署多个模型，并在不停机的情况下更新已部署的 API
- 监控 API 性能和预测结果
结论
有许多很棒的工具可供选择。确保寻找适合您需求的集成和功能，以充分利用您的工作。
享受管理您的机器学习项目！
监控机器学习实验运行的最佳工具
监控机器学习实验运行是一项重要且健康的实践，但它可能是一项挑战。主要问题是:
- 您不能一直查看控制台日志，
- 当你查看日志时，你不会立即看到随时间的变化(想想学习曲线与第 10 个时期的损失)，
- 有时你甚至不能进入模型训练环境。
这就是工具派上用场的地方！您可以使用它们灵活地监控您的 ML 实验，并在需要时查看模型训练信息。尤其是在你无法访问机器的情况下(大学里的计算集群，工作中的 VPN，你在某个地方使用的云服务器，或者你在公交车上的时候:)。
使用专用工具监控 ML 实验可让您安心地了解您的训练运行情况。如果你想超越观看你的学习曲线，并想看到额外的信息，如性能图表，或每个时期后的预测可视化，那就更是如此。
查看我们的最佳工具列表，它们将使监控您的机器学习实验变得轻而易举！
Neptune 是为运行大量实验的研究和生产团队构建的 MLOps 的元数据存储。它非常灵活，可以与许多其他框架一起工作，并且由于其稳定的用户界面，它实现了巨大的可伸缩性(达到数百万次运行)。
这是一个强大的软件，可以存储、检索和分析大量数据。Neptune 拥有高效监控 ML 实验运行的所有工具。您还可以将它与其他工具集成，以获得更大的灵活性。
海王星——概要:
- 快速美观的用户界面，具有多种功能来分组组织跑步，保存自定义仪表板视图并与团队共享
- 为用户和组织管理提供不同的组织、项目和用户角色
- 您可以使用托管应用程序来避免维护另一个工具的所有麻烦(或者将其部署在您的内部基础架构上)
- 您的团队可以跟踪在脚本(Python、R、other)、笔记本(local、Google Colab、AWS SageMaker)中执行的实验，并在任何基础设施(云、笔记本电脑、集群)上执行
- 广泛的实验跟踪和可视化功能(资源消耗、滚动图像列表)
TensorBoard 是 TensorFlow 的可视化工具包，可让您分析模型训练运行。它是开源的，具有对整个机器学习工作流程有帮助的功能。
此外，它有一个广泛的工程师网络使用这个软件，分享他们的经验和想法。这使得一个强大的社区准备解决任何问题。然而，该软件本身最适合个人用户。
tensor board–摘要:
- 跟踪和可视化损失和准确性等指标
- 比较不同跑步的学习曲线
- 平行坐标图显示参数-度量相互作用
- 它还有其他与参数度量无关的可视化特性
- 将嵌入投影到低维空间
Hyperdash 是另一个有助于监控机器学习实验运行的工具。这是一个基于云的解决方案，适用于那些喜欢灵活性并专注于快速获取知识的人。这是一个简单的工具，可以与脚本和 Jupyter 一起使用。
有趣的是，与大多数工具不同，Hyperdash 可以在移动设备(iOS，Android)上使用，所以无论你在哪里，你都可以监控你的实验。
超级破折号–摘要:
- 跨不同模型实验跟踪超参数
- 实时绘制性能指标的图表
- 长时间运行的实验完成时的通知
Guild AI 是一个运行、跟踪和比较实验的工具。Guild AI 是跨平台和框架独立的——你可以使用任何库用任何语言训练和捕捉实验。
公会人工智能运行你未修改的代码，所以你可以使用你想要的库。该工具不需要数据库或其他基础设施来管理实验，简单易用。
帮会 AI–总结:
- 任何模型训练和任何编程语言的跟踪实验
- 拥有自动化的机器学习流程
- 与任何语言和库集成
- 远程培训和备份的可能性
- 重现结果或重现实验
WandB 专注于深度学习。用户可以使用 Python 库跟踪应用程序的实验，并且作为一个团队，可以看到彼此的实验。
WandB 是一种托管服务，允许您在一个地方备份所有实验，并与团队合作完成一个项目——工作共享功能可供使用。
在 WandB 中，用户可以记录和分析多种数据类型。
权重&偏差–汇总:
- 监控训练运行信息，如损失、准确性(学习曲线)
- 查看权重和偏差(没有双关语)或梯度的直方图
- 在培训期间记录丰富的对象，如图表、视频、音频或交互式图表
- 使用各种比较工具，如显示自动差异的表格、平行坐标图等
结论
现在您有了合适的工具，您可以从世界上的任何地方自由地监控 ML 实验运行。使用它们来优化您的工作，节省时间，提高工作效率。
享受监测您的机器学习实验运行！
最佳工作流程和管道编排工具:机器学习指南
原文：https://web.archive.org/web/https://neptune.ai/blog/best-workflow-and-pipeline-orchestration-tools
机器学习正在 IT 界横行，推动了许多高端技术的发展。它为研究人员和企业带来了自动化和灵活性的革命。
当谈到机器学习时，工作流(或管道)是驱动整个项目的重要组件。
在本文中，我们将探索什么是工作流和管道，以及 10 多种可以用来编排工作流和管道的工具。
什么是机器学习中的工作流？
ML 中的工作流是在机器学习过程中随后运行的一系列任务。
工作流是机器学习项目的不同阶段。这些阶段包括:
- 数据收集，
- 数据预处理，
- 建立数据集，
- 模型训练和提炼，
- 评价，
- 部署到生产。
机器学习中的流水线是什么？
机器学习中的管道是整个 ML 工作流的基础介质。管道有助于自动化整个 MLOps 工作流程，从数据收集、EDA、数据扩充到模型构建和部署。部署之后，它还支持复制、跟踪和监控。
ML 管道有助于提高整个模型的性能和管理，从而实现快速而简单的部署。
什么是机器学习编排工具？
机器学习编排工具用于自动化和管理工作流和管道基础设施，具有简单的协作界面。除了管理和创建定制工作流及其管道之外，这些工具还可以帮助我们跟踪和监控模型，以便进行进一步分析。
编排工具使 ML 过程更容易、更高效，并帮助数据科学家和 ML 团队专注于必要的事情，而不是浪费资源试图确定优先问题。
对于一家投资机器学习的公司来说，精心安排一个合适的工作流程可能非常有用。为此，您必须了解如何自动化整个，以及如何在生产过程中通过监控和跟踪提取有价值的模型输出。
因此，为了介绍 MLOps 工作流/管道编排的一些最佳工具，我们编制了一个列表。
- Kale–旨在简化部署 Kubeflow Pipelines 工作流的数据科学体验。
- Flyte–轻松创建并行、可扩展和可维护的机器学习工作流。
- ML run–数据科学家构建、运行和监控 ML 任务和管道的通用机制。
- 完美的工作流程管理系统，专为现代基础设施而设计。
- ZenML 是一个可扩展的开源 MLOps 框架，用于创建可复制的管道。
- Argo–开源容器-本地工作流引擎，用于在 Kubernetes 上编排并行作业。
- Kedro–为数据和 ML 管道实现软件工程最佳实践的库。
- Luigi–Python 模块，帮助您构建批处理作业的复杂管道。
- Metaflow-帮助科学家和工程师构建和管理数据科学项目的人性化 lib。
- Couler–用于在不同工作流引擎上构建和管理工作流的统一界面。
- valo hai–训练、评估和部署模型的简单而强大的工具。
- dagster . io–用于机器学习、分析和 ETL 的数据编排器。
- 网飞 Genie–Genie 由网飞开发，是一个开源的分布式工作流/任务编排框架。
羽衣甘蓝
当使用 Jupyter 笔记本时，数据科学家受益于交互性和可视化。在完成一项任务后，重构笔记本来管理 Kubeflow 管道可能会很困难且耗时。
羽衣甘蓝解决了这个问题。该工具简化了 Jupyter 笔记本在 Kubeflow Pipelines 工作流程中的部署流程。它将 Jupyter 笔记本直接转化为 KFP 管道。这样做，可以确保所有的处理构件都是组织良好且相互独立的。它还利用了 Kubeflow 提供的开箱即用的实验跟踪和工作流组织的能力。
它提供了一个在 Kubernetes 之上控制和协调复杂工作流的平台。此外，您可以创建可重用的组件，并与工作流一起执行它们。通过一个简单的用户界面直接从 JupyterLab 界面定义 KFP 管道，该工具对于工作流管道编排非常有效。
功能性:
- 开源
- 关注:Kubeflow 管道和工作流程
- 轻量级选手
争吵
轻松创建 ML 工作流的另一个高端工具。这是一个结构化编程和分布式处理平台，具有高度并发、可扩展和可维护的机器学习和数据处理工作流。
它已经管理了 10，000 多个工作流。stellar 基础架构允许您创建一个独立的回购、部署和扩展，而不会影响平台的其余部分。它构建在 Kubernetes 之上，提供了可移植性、可伸缩性和可靠性。
Flyte 的界面灵活、直观，易于多个租户使用。它为组织工作流提供了参数、数据沿袭和缓存。
整个平台是动态的和可扩展的，并提供了各种各样的插件来帮助工作流的创建和部署。可以重复、回滚、试验和共享工作流，以加速整个团队的开发过程。
功能性:
- 开源
- 关注:创建并发的、可伸缩的和可维护的工作流
- 轻量级选手
MLRun
MLRun 是一个开源的工作流/管道编排工具。它有一种整合的方法来组织机器学习管道，从最初的开发，通过模型构建，一直到生产中的完整管道部署。
它调用了一个抽象层，集成了各种 ML 工具和插件，用于处理功能和模型以及工作流部署。MLRun 有一个特性和工件存储，用于跨多个存储库和技术控制数据的接收、处理、元数据和存储。
它有一个弹性的无服务器服务，用于将简单的代码转换成可扩展和有组织的微服务。它还有助于自动化实验、模型训练和测试，以及实时管道工作流的部署。
整个 UI 有一个集中的结构来管理 ML 工作流。关键特性包括快速部署、弹性扩展、特性管理和灵活的可用性。
功能性:
- 开源
- 关注:端到端的 ML 管道
- 轻量级完美
我相信这是最好的自动化工作流管理工具之一。基于开源的完美核心工作流引擎，专为现代基础设施而打造。
这个工作流管理系统使得获取数据管道和添加语义变得容易，比如重试、日志记录、动态映射、缓存或失败通知。
它有助于两个现成的数据库:
完美核心的服务器，
- Prefect Cloud.
- 他们有 UI 后端，可以用丰富的 GraphQL API 自动扩展完美的核心引擎，使工作流程编排变得简单。Prefect Core 的服务器是 Prefect Cloud 的一个开源的轻量级替代方案。
完美云是完美核心的完全托管、部署就绪的后端。它具有增强的特性，如许可和授权、性能增强、代理监控安全运行时秘密和参数、团队管理或 SLA。一切都是自动化的，你只需要将任务转换成工作流，这个工具会处理剩下的事情。
功能性:
开源
- 关注:端到端的 ML 管道
- 轻量级选手
- ZenML
ZenML 是一个流行的开源 MLOps 工具，用于创建可重复的工作流。它旨在解决将 Jupyter 笔记本研究中观察到的模式转化为生产就绪的 ML 环境的问题。
该工具专注于基于生产的复制问题，如版本控制困难和模型、复制实验、组织复杂的 ML 工作流、桥接培训、部署和跟踪元数据。它可以与其他工作流编排工具一起工作，为将您的 ML 模型投入生产提供一个简单的途径。
在其核心，ZenML 将 ML 开发分解成代表单个任务的步骤。一起操作的任务序列形成了工作流管道。您可以利用集成，在本地和云系统之间无缝切换。
您可以准确地对数据、模型和配置进行版本控制。它会自动检测数据库模式，并允许您查看统计数据。它允许您评估模型(使用内置评估器)，比较训练管道，并将预处理分发到云。
功能性:
开源
- 关注:创建生产就绪的 ML 管道
- 轻量级选手
- 南船星座
Argo 是一个强大的、容器本地的、开源的工作流引擎。它非常适合在 Kubernetes 上编排并行作业。它是作为 Kubernetes 的自定义资源定义实现的。您可以定义管道工作流，其中各个步骤被视为一个容器。
它允许您将多步骤工作流建模为一系列任务。此外，由于有向无环图(DAG ), Argo 支持任务间的依赖性跟踪。它可以轻松处理机器学习和数据科学的密集型任务，为您节省大量时间。
Argo 有 CI/CD 直接配置在 Kubernetes 上，你不用插任何其他软件。它与云无关，可以在任何 Kubernetes 集群上运行，并支持在 Kubernetes 上轻松编排高度并行的作业。
功能性:
开源
- 关注:Kubernetes
- 轻量级选手
- 凯德罗
这个工作流编排工具基于 Python。您可以创建可重复、可维护和模块化的工作流，使您的 ML 流程更加简单和准确。Kedro 将软件工程集成到机器学习环境中，其中包含模块化、关注点分离和版本控制等概念。
它提供了一个基于 Cookiecutter 数据科学的标准的、可修改的项目模板。数据目录处理一系列轻量级数据连接器，用于跨许多不同的文件格式和文件系统保存和加载数据。
通过管道抽象，您可以自动化 Python 代码和工作流可视化之间的依赖关系。Kedro 支持单机或分布式机器部署。主要焦点是创建可维护的数据科学代码，以解决 Jupyter 笔记本、一次性脚本和胶水代码的缺点。这个工具使得不同层次的团队协作更加容易，并且通过模块化、可重用的代码在编码环境中提供效率。
功能性:
开源
- 关注:可复制性、模块化和可维护性
- 轻量级选手
- 可能有用
检查 Kedro-Neptune 集成，它让您过滤、比较、显示和组织管道和节点中生成的 ML 元数据。
路易吉
Luigi 是一个开源的 Python 包，针对执行批处理任务的工作流编排进行了优化。有了 Luigi，建造复杂的管道就更容易了。它提供不同的服务来控制依赖解析和工作流管理。它还支持可视化、故障处理和命令行集成。
它主要解决长期运行的复杂批处理过程。Luigi 负责所有可能需要很长时间才能完成的工作流管理任务，这样我们就可以专注于实际任务及其依赖项。它有一个包含通用项目模板的工具箱。
Luigi 为 HDFS 和本地文件提供了最先进的文件系统抽象。这样，所有文件系统操作都是原子的。因此，如果您正在寻找一个全 Python 工具来处理批处理作业的工作流管理，那么 Luigi 就是您的理想之选。
功能性:
开源
- 重点:为批处理作业构建复杂的管道。
- 轻量级选手
- 元流
Metaflow 是一个强大的现代工作流管理工具，专为要求苛刻的数据科学和机器学习项目而构建。它简化并加速了数据科学项目的实施和管理。我们可以使用任何与 Python 相关的工具来生成模型。这个框架也支持 R 语言。
您可以设计您的工作流，大规模运行它，并将其部署到生产中。Metaflow 对所有实验和数据进行自动版本控制和跟踪。有内置的支持来快速轻松地扩展。它与 AWS 云集成，后者为存储、计算和机器学习服务提供支持。
它有一个统一的基础架构 API，对于从开始到部署执行数据科学项目至关重要。它侧重于可用性和人体工程学。还有代码熵管理和协作平台。
功能性:
开源
- 关注:管理现实生活中的数据科学项目
- 轻量级选手
- 库勒
唯一用于管理其他工作流编排工具的工作流编排工具。Couler 有一个最先进的统一界面，用于使用不同的工作流引擎和框架编码和管理工作流。
不同的引擎，如 Argo 工作流、Tekton 管道或 Apache Airflow，具有不同的复杂抽象级别。Couler 的公共接口使得管理这些不同层次的抽象更加容易。
它具有定义工作流的命令式编程风格，并支持自动构造有向无环图。Couler 服务高度可扩展，支持其他工作流引擎。它促进了 ML 模型的分布式训练，确保了模块性和可重用性。Couler 支持自动化工作流程和资源组织，以实现最佳性能。
功能性:
开源
- 关注:其他工具的管理
- 轻量级选手
- 瓦罗海
如果您正在寻找一个 MLOps 工具来自动化从数据提取和准备到生产中的模型部署的一切，那么这个工具可能会成为您的新宠。
使用 Valohai，您可以方便地训练、评估和部署模型，而无需额外的手动工作，并且还可以自动重复该过程。它支持端到端的机器学习工作流，自动存储每个模型、实验和工件。部署之后，它还监视 Kubernetes 集群中部署的模型。
Valohai 是一个稳定的环境和 UI 界面，计算资源刚好够用。您可以管理您的定制模型，而不是在基础设施和手动实验跟踪上花费时间。它加快了您的工作，并且还支持自动数据、模型和实验版本化。
它包括一个非常稳定的 MLOps 环境，可以适应任何框架和语言。它可以进行超参数扫描，简化团队协作，实验和模型审计，并且有防火墙保护。
功能性:
高级，没有免费计划
- 重点关注:端到端的 ML 管道。
- 轻量级赛车
- Dagster 有一个丰富的 UI 来执行机器学习、分析和 ETL(提取、转换、加载)的工作流编排。
您可以构建用 Spark、SQL、DBT 或任何其他框架编写的计算管道。该平台允许您在本地或 Kubernetes 上部署管道。您甚至可以为部署创建自己的定制基础设施。
Dagster 在一个统一的视图中向您显示管道、表格、ML 模型和其他资产。它提供了一个跟踪工作流结果的资产管理器工具。它允许团队构建定制的自助服务系统。
web 界面(Dagit)允许任何人检查创建的任务对象，并探索它们的属性。它减轻了依赖的噩梦。代码库由存储库模型隔离，防止一个工作流影响另一个工作流的问题。
功能性:
高级，没有免费计划
重点关注:端到端的 ML 管道。
- 网飞精灵
- Genie 是一个开源的分布式工作流/任务编排框架。它有用于执行不同机器学习大数据任务的 API，如 Hadoop、Pig 或 Hive。它为计算资源提供了集中和可扩展的资源管理。
有用于监控集群上的工作流的 API，而不需要安装任何计算资源。它消除了必须自己安装计算资源的手工工作。它提供配置 API 来注册运行 Genie 的集群和应用程序。
Genie 的主要优势是可伸缩性。根据工作负载的增加和减少，它可以容纳多台机器。服务器 API 管理许多分布式处理集群的元数据和命令。
功能性:
开源
重点关注:大数据编排。
- 轻量级选手
- 结论
- 现在您已经了解了一些最好的 MLOps 工作流/管道编排工具，您可以为您的 ML 项目选择合适的工具。每种工具都有独特的优势。它们中的大多数都是开源的，所以你可以在没有任何财务承诺的情况下测试它们。
自动化流程、可扩展性、统一设计、全球插件集成等等——这些工具提供的功能使得在机器学习项目中取得优异成绩变得更加容易。从数据提取和实验的初始过程到生产中的部署，这些工具可以使事情变得更简单、更准确。
参考
克里斯萨纳瓦特·卡韦桑穆昂
InstaMobile 的开发者关系
只是一个典型的内向开发者，美国——没有上瘾，对人工智能和区块链充满热情。
阅读下一篇
最佳 MLOps 工具以及如何评估它们
12 分钟阅读| Jakub Czakon |年 8 月 25 日更新
The Best MLOps Tools and How to Evaluate Them
在我们的一篇文章中——机器学习团队实际使用的最好的工具、库、框架和方法——我们从 41 家 ML 初创公司学到的东西——Acerta 的 CTO Jean-Christophe Petkovich 解释了他们的 ML 团队如何接近 MLOps。
据他所说，一个完整的 MLOps 系统有几个要素:
您需要能够构建包含预处理数据和生成结果所需的所有信息的模型工件。
一旦您能够构建模型工件，您必须能够跟踪构建它们的代码，以及它们被训练和测试的数据。
- 您需要跟踪所有这三样东西，模型、它们的代码和它们的数据，是如何关联的。
- 一旦您可以跟踪所有这些内容，您还可以将它们标记为准备就绪，进行生产，并通过 CI/CD 流程运行它们。
- 最后，为了在该过程的最后实际部署它们，您需要某种方法来基于该模型工件旋转服务。
- 这是对如何在公司中成功实施 MLOps 的高度概括。但是理解高层需要什么只是拼图的一部分。另一个是采用或创建适当的工具来完成工作。
- 这就是为什么我们编制了一份最佳 MLOps 工具的清单。我们将它们分为六类，以便您可以为您的团队和业务选择合适的工具。让我们开始吧！
It’s a great high-level summary of how to successfully implement MLOps in a company. But understanding what is needed in high-level is just a part of the puzzle. The other one is adopting or creating proper tooling that gets things done.
That’s why we’ve compiled a list of the best MLOps tools. We’ve divided them into six categories so you can choose the right tools for your team and for your business. Let’s dig in!
你应该订阅的最佳 YouTube 机器学习频道
原文：https://web.archive.org/web/https://neptune.ai/blog/best-youtube-machine-learning-channels
机器学习在很短的时间内彻底改变了世界。由于数据正以指数速度增长，我们需要学习如何处理数据并从中获得洞察力。
机器学习是一个将统计和软件开发结合到一个职业中的领域，其主要目标是建立预测模型。
为了在这个领域保持领先，我们需要不断学习新的东西。我最喜欢的方法之一是向更聪明的人学习，如果可能的话，免费学习。
最有效的方法之一就是订阅最好的机器学习 YouTube 频道。这是一个很好的知识来源，最新的趋势，也是发展新技能的简单方法。
在本文中，我们将浏览YouTube 的 14 大频道，让你用机器学习的知识来驾驭自己。
1.Sentdex
如果你喜欢从头开始理解一切，那么这是迄今为止学习机器学习的最佳 YouTube 频道。
YouTube 频道sendex的所有者哈里森·金斯利教授人们各种技术，包括 Python 编程、网络开发、机器学习等。
如果你热衷于学习每种算法的工作流程，比如 bias 和 intercept 如何在每个时期更新，或者如何从零开始实现给定的机器学习算法，那么你必须查看以下由 Harrison Kinsley 亲自制作的系列。
视频
频道:send ex
2.数据学校
凯文马卡姆 谁是 数据学校的创始人。 我 o 还有 YouTube 频道的主人 数据学校 教育机器学习爱好者。得益于 凯文 的授课，无论你的教育背景如何，你都可以对机器学习有一个全面的了解。
Kevin 还制作了一些视频，涵盖了几个工具，如 pandas、NumPy、scikit-learn，这些工具将帮助您建立机器学习模型。
你可以尽情观看凯文创作的以下系列，以很好地掌握机器学习的基础知识。
视频
频道: 数据学校
3.人工智能——集所有功能于一身
在人工智能频道上有很好的课程——都在一个里，由尼提什·斯里瓦斯塔瓦杰弗里·辛顿 等专家授课。
关于人工智能的课程——都在中，涵盖了文本挖掘、文本检索、搜索引擎、神经网络和计算机视觉**等主题。
你可能想看看下面的系列，以便很好地掌握由 吴恩达 亲自教授的机器学习概念。
视频
频道:手腕al智能——全在一
4.Deeplearning.ai
“深度学习是一种超能力。有了它，你可以制造一台电脑看，合成小说艺术，翻译语言，进行医学诊断，或者建造一辆能够自动驾驶的汽车部件。如果这还不是超级大国，我不知道什么是。”吴恩达
如果你想深入学习，那么你应该看看下面的系列。
视频
5.菲尔的机器学习
Phil Tabor 是一名机器学习工程师，他在机器学习和深度学习领域制作教育视频。
他创建了一个关于深度强化学习教程的很棒的播放列表，在那里他教授强化学习的核心概念，如 TensorFlow 2 中的深度确定性策略梯度、PyTorch 中的软演员评论家、使用 TD3 的机器人控制等等。
视频
频道:机器学习与菲尔
6.杰瑞米·霍华德
杰瑞米·霍华德是一名数据科学家，他拥有哲学教育背景，但后来出于好奇，他利用统计学和编程的知识，为深度学习任务建立了最有效和易用的库 fastai 。
️阅读了如何通过 Neptune-fastai 集成跟踪模型训练元数据
在 fast.ai 出现之前，制作深度学习模型从来没有那么容易。如果你想建立深度学习模型，以最少的编码和最大的结果完成图像分割、图像分类、图像恢复等计算机视觉领域的任务，那么 fast.ai 适合你。
你可能想尽情观看下面的系列，以便在 fast.ai 库的帮助下，很好地掌握深度学习。
视频
频道:杰瑞米·霍华德
7.两份会议记录文件
两分钟论文 对于任何喜欢了解机器学习领域最新研究的人来说，这是一个非常棒的渠道。
两分钟的论文可以制作 2 分钟(几乎)长的视频来解释一篇研究论文。
如果你热衷于研究领域，那么你可能想看看以下系列
视频
频道:两分钟论文
8.莱克斯·弗里德曼播客
Lex Fridman 播客是最受欢迎和最好的机器学习 YouTube 频道之一。它的主人是一名人工智能研究人员，在麻省理工学院和其他地方从事自动驾驶汽车、人机交互和机器学习的研究。
莱克斯和他的客人谈论与人工智能和曼梯·里有关的一切。但他并不局限于这个主题。他谈到了其他可以激励、教导和推动你超越自身局限的事情。
来自机器学习领域的所有超级明星、有影响力的人和领先科学家的见解。他采访了像埃隆·马斯克、尼克·博斯特罗姆、吴恩达、扬·勒昆、弗拉基米尔·瓦普尼克、马特、t·伯特温尼克等许多人。
他还有第二个 YouTube 频道，名为 Lex Clips ，他在那里发布他的播客和其他视频的片段。
视频
9.卡格尔
Kaggle 频道是 YouTube 上的一个站点，在这里你可以深入 Kaggle 社区的世界，学习和做你的数据科学工作。
该频道提供与数据科学家的访谈视频、课程和有见地的技巧。
这是最好的机器学习 YouTube 频道之一，适合所有想要学习技巧、进行实验并在自己的工作中实施新实践的人，无论你在什么环境中工作。
10.Arxiv 见解
Arxiv Insights 是史云光·斯廷布鲁格旗下的一个频道。他从技术的角度总结了他的核心观点，同时让更多的观众能够理解。
如果你喜欢 ML 和 AI 上的技术故障，但是想要一个困难的和技术的主题的很好的总结，那是你正确的地方！
虽然作者不经常上传视频，但该频道因其有趣的内容而受到称赞。
11.谷歌云平台
不订阅谷歌云平台会是一种罪过。在该频道上，您可以了解安全基础设施、开发人员工具、API、数据分析和机器学习等主题。
这个 ML YouTube 频道让你了解谷歌的工作方式，如何成为一名更好的数据科学家，以及谷歌的一切。
这里有一个关于谷歌数据中心安全的有趣视频:6 层深度
视频
12.深度学习。电视
深度学习。电视讲的都是深度学习。该频道的主题包括如何操作、软件库和应用的评论以及对该领域关键人物的采访。
还有一系列概念视频展示了每种深度学习方法背后的直觉，因此你可以更好地理解深度学习是如何工作的。
13.跳板
跳板频道全是数据科学。有来自领先公司的专家与数据科学和机器学习的谈话，数据科学中的女性播放列表与在 ML 工作的女性的有趣对话，深度潜水或迷你课程。
这是一个非常棒的机器学习 YouTube，适合那些想了解如何找到工作，需要注意什么，以及了解在数据科学领域工作意味着什么的人。
视频
14.山姆·查林顿的 TWIML 人工智能播客
如果你正在寻找来自机器学习世界的最新消息，一定要看看 TWIML(本周机器学习)播客 YouTube 频道。
在这里，你会发现每周来自机器学习和人工智能世界的最有趣和最重要的故事。这是一个伟大的信息和知识的来源，每个人都想保持在最新的趋势，创新，并从 ML 的专家那里获得有趣的见解。
最终的结果
我们列出了免费学习机器学习的最佳渠道，但你必须坚定不移地学习它，只有将你的知识付诸实践才能学习机器学习。
祝你机器学习之旅好运。🙂**
二值化神经网络(BNN)及其在机器学习中的实现
二值化神经网络(BNN)来自 Courbariaux、Hubara、Soudry、El-Yaniv 和 beng io 2016 年的一篇论文。它引入了一种新的方法来训练神经网络，其中权重和激活在训练时被二值化，然后用于计算梯度。
通过这种方式，可以减少内存大小，并且位运算可以提高功效。GPU 消耗巨大的功率，使得神经网络很难在低功率设备上训练。BNNs 可以将功耗降低 32 倍以上。
该论文表明，可以使用二进制矩阵乘法来减少训练时间，这使得在 MNIST 上训练 BNN 的速度提高了 7 倍，达到了接近最先进的结果。
在本文中，我们将看到二进制神经网络是如何工作的。我们将深入研究该算法，并查看实现 BNNs 的库。
二进制神经网络如何工作
在我们深入挖掘之前，让我们看看 BNNs 是如何工作的。
在论文中，他们使用两个函数来二进制化 x(权重/激活)的值——确定性的和随机的。
Eq. 1
情商。1 是确定性函数，其中 signum 函数用于实值变量。
随机函数使用硬 sigmoid:
Eq. 2
方程式中的 xb。1 和 Eq。2 是实值变量(权重/激活)的二进制值。1 很简单。
在 Eq 中。2
Eq. 3
确定性函数在大多数情况下使用，除了少数实验中随机函数用于激活。
除了二进制化权重和激活之外，BNNs 还有两个更重要的方面:
- 为了让优化器工作，您需要实值权重，所以它们在实值变量中累积。即使我们使用二进制权重/激活，我们也使用实值权重进行优化。
- 当我们使用确定性或随机函数进行二值化时，会出现另一个问题。当我们反向传播时，这些函数的导数为零，这使得整个梯度为零。所以我们可以使用饱和 STE(直通估计量)，这是之前由 Hinton 提出并由 Bengio 研究的。在饱和 STE 中，signum 的导数用 1 [{x < =1}] 代替，简单来说就是当 x < =1 时，用恒等式(1)代替导数零。所以，当 x 太大时，它抵消了梯度，因为导数为零。
Fig. 1 – A binary weight filter from the 1st convolutional layer of BNN | Source
基于移位的批处理规范化和基于移位的 AdaMax 优化
除了常规批处理规范化和 Adamax 优化之外，还有一种替代方法。BatchNorm 和 Adam optimizer 都包含大量乘法运算。为了加快这个过程，它们被基于移位的方法所取代。这些方法使用位运算来节省时间。BNN 的论文声称，当用基于班次的批处理规范化和基于班次的 Adam 优化程序替换批处理规范化和 Adam 优化程序时，没有观察到准确度损失。
加速训练
BNN 论文中介绍的方法可以加速 BNNs 的 GPU 实现。与使用 cuBLAS 相比，它可以提高时间效率。
cuBLAS 是一个 CUDA 工具包库，提供 GPU 加速的基本线性代数子程序(BLAS)。
一种称为 SWAR 的方法，用于在寄存器内执行并行操作，用于加速计算。它将 32 位二进制变量连接到 32 位寄存器。
SWAR 可以在 Nvidia GPU 上仅用 6 个时钟周期评估这 32 个连接，因此理论上速度提高了 32/6 = 5.3 倍。值+1 和-1 对于执行此操作非常重要，因此我们需要将变量二进制化为这两个值。
让我们来看看一些性能统计数据:
Fig. 2 – Comparison between Baseline kernel, cuBLAS and the XNOR kernel for time and accuracy. | Source
正如我们在图 2 中看到的，所有三种方法的精确度；使用 cuBLAS 库和 paper 的 XNOR 核的未优化基线核在图的第三部分是相同的。在第一部分中，将矩阵乘法时间与 8192 x 8192 x 8192 矩阵进行比较。在第二部分中，在多层感知器上推断 MNIST 的全部测试数据。我们可以清楚地看到，XNOR 内核的性能更好。在矩阵乘法的情况下，XNOR 比基线内核快 23 倍，比 cuBLAS 内核快 3.4 倍。
我们可以看到，在运行 MNIST 测试数据时，cuBLAS 和 XNOR 内核之间的差异较小。这是因为在第一层，值不是二进制的，所以基线内核用于计算，从而导致一点延迟。但这不是什么大问题，因为输入图像通常只有 3 个通道，这意味着计算量更少。
密码
我们来看一些实现了 BNNs 的 Github repos。
BNNs 的前两个实现包含在原始论文中，虽然一个是用 lua(torch)实现的，另一个是用 Python 实现的，但是是用 theano 实现的。
提诺:
https://github . com/matthieurbarillas/binary net
火炬:
https://github.com/itayhubara/BinaryNet
PyTorch:
BNN 论文的作者之一提供了一个 pytorch 实现，包括 alexnet 二进制、resnet 二进制和 vgg 二进制等架构，具有不同的层数(resent18、resnet34、resnet50 等。)
https://github.com/itayhubara/BinaryNet.pytorch
没有文档，但是代码很直观。在子目录“模型”中，实现了三个二值化网络:vgg、resnet 和 alexnet。
使用文件“data.py”向 BNN 网络发送自定义数据集。‘preprocess . py’里也有很多变换选项。
Keras/TensorFlow:
到目前为止，我见过的最好的包之一是 Larq ，这是一个开源包，其中构建和训练二进制神经网络非常容易。
在前面讨论的包中，有可以使用的预先实现的网络。但是有了 Larq，你可以用一种非常简单的方式创建新的网络。这就像 Keras API，例如，如果你想添加一个二值化的 conv 层，而不是' tf.keras.layers.Conv2D '，你可以使用' larq.layers.Conv2D '。
关于这个包最好的一点是文档非常好，社区正在积极开发它，所以支持也很好。
尽管它有很棒的文档，但让我们看看文档中的一个例子，这样您就可以大致了解该库的易用性。
import tensorflow as tf
import larq as lq
kwargs = dict(input_quantizer="ste_sign",
kernel_quantizer="ste_sign",
kernel_constraint="weight_clip",
use_bias=False)
model = tf.keras.models.Sequential([
lq.layers.QuantConv2D(128, 3,
kernel_quantizer="ste_sign",
kernel_constraint="weight_clip",
use_bias=False,
input_shape=(32, 32, 3)),
tf.keras.layers.BatchNormalization(momentum=0.999, scale=False),
lq.layers.QuantConv2D(128, 3, padding="same", **kwargs),
tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=(2, 2)),
tf.keras.layers.BatchNormalization(momentum=0.999, scale=False),
lq.layers.QuantConv2D(256, 3, padding="same", **kwargs),
tf.keras.layers.BatchNormalization(momentum=0.999, scale=False),
lq.layers.QuantConv2D(256, 3, padding="same", **kwargs),
tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=(2, 2)),
tf.keras.layers.BatchNormalization(momentum=0.999, scale=False),
lq.layers.QuantConv2D(512, 3, padding="same", **kwargs),
tf.keras.layers.BatchNormalization(momentum=0.999, scale=False),
lq.layers.QuantConv2D(512, 3, padding="same", **kwargs),
tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=(2, 2)),
tf.keras.layers.BatchNormalization(momentum=0.999, scale=False),
tf.keras.layers.Flatten(),
lq.layers.QuantDense(1024, **kwargs),
tf.keras.layers.BatchNormalization(momentum=0.999, scale=False),
lq.layers.QuantDense(1024, **kwargs),
tf.keras.layers.BatchNormalization(momentum=0.999, scale=False),
lq.layers.QuantDense(10, **kwargs),
tf.keras.layers.BatchNormalization(momentum=0.999, scale=False),
tf.keras.layers.Activation("softmax")
])
注意，如前所述，我们没有将希格诺和 STE 用于输入层。我们来看看最终的架构。
model.summary()
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param
=================================================================
quant_conv2d (QuantConv2D) (None, 30, 30, 128) 3456
_________________________________________________________________
batch_normalization (BatchNo (None, 30, 30, 128) 384
_________________________________________________________________
quant_conv2d_1 (QuantConv2D) (None, 30, 30, 128) 147456
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 15, 15, 128) 0
_________________________________________________________________
batch_normalization_1 (Batch (None, 15, 15, 128) 384
_________________________________________________________________
quant_conv2d_2 (QuantConv2D) (None, 15, 15, 256) 294912
_________________________________________________________________
batch_normalization_2 (Batch (None, 15, 15, 256) 768
_________________________________________________________________
quant_conv2d_3 (QuantConv2D) (None, 15, 15, 256) 589824
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 7, 7, 256) 0
_________________________________________________________________
batch_normalization_3 (Batch (None, 7, 7, 256) 768
_________________________________________________________________
quant_conv2d_4 (QuantConv2D) (None, 7, 7, 512) 1179648
_________________________________________________________________
batch_normalization_4 (Batch (None, 7, 7, 512) 1536
_________________________________________________________________
quant_conv2d_5 (QuantConv2D) (None, 7, 7, 512) 2359296
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 3, 3, 512) 0
_________________________________________________________________
batch_normalization_5 (Batch (None, 3, 3, 512) 1536
_________________________________________________________________
flatten (Flatten) (None, 4608) 0
_________________________________________________________________
quant_dense (QuantDense) (None, 1024) 4718592
_________________________________________________________________
batch_normalization_6 (Batch (None, 1024) 3072
_________________________________________________________________
quant_dense_1 (QuantDense) (None, 1024) 1048576
_________________________________________________________________
batch_normalization_7 (Batch (None, 1024) 3072
_________________________________________________________________
quant_dense_2 (QuantDense) (None, 10) 10240
_________________________________________________________________
batch_normalization_8 (Batch (None, 10) 30
_________________________________________________________________
activation (Activation) (None, 10) 0
=================================================================
Total params: 10,363,550
Trainable params: 10,355,850
Non-trainable params: 7,700
现在你可以像训练一个在 keras 中实现的普通神经网络一样训练它。
？海王星与 PyTorch
的融合？海王星与 TensorFlow/Keras 的整合
应用程序
bnn 具有功率效率，因此可用于低功率器件。这是 BNNs 最大的优势之一。您可以使用 LCE(Larq 计算引擎)和 Tensorflow Lite Java 在 Android 上训练和推断神经网络，消耗更少的功率。
Fig. 3 – Example of Image Classification using LCE Lite | Source
你可以点击下面的链接阅读更多关于在 Android 设备上使用 BNNs 的信息。
结论
深度网络需要耗电的 GPU，很难在低功耗设备上训练它们。因此，二元神经网络的概念似乎很有前途。
它们消耗更少的功率而没有任何精度损失，并且可以在移动设备中用于训练 dnn。好像挺有用的！
感谢阅读。
参考
如果你想深入了解 BNNs，这里有一些参考资料:
二元分类法:来自 10 个 Kaggle 竞赛的提示和技巧
机器学习模型开发很难，尤其是在现实世界中。
通常，您需要:
了解业务问题，收集数据，探索数据，建立适当的验证方案，实现模型并调整参数，以对业务有意义的方式部署模型，检查模型结果，以便发现必须处理的新问题。
这还不是全部。
您应该对您运行的实验和训练的模型进行版本化，以防您或其他任何人将来需要检查它们或重现结果。从我的经验来看，这一时刻会在你最意想不到的时候到来，“我希望我以前就想到了”的感觉是如此的真实(和痛苦)。
但是还有更多。
随着 ML 模型服务于真实的人，错误分类的案例(这是使用 ML 的自然结果)正在影响人们的生活，有时会非常不公平地对待他们。这使得解释你的模型预测的能力成为一种要求，而不仅仅是一种美好。
那么你能做些什么呢...
Brier Score:了解模型校准
原文：https://web.archive.org/web/https://neptune.ai/blog/brier-score-and-model-calibration
当你的天气应用程序中下雨的概率低于 10%时，你是否遇到过风暴？嗯，这很好地展示了一个没有校准好的模型(也称为校准不良模型，或 Brier 分数非常高的模型)会如何破坏你的计划。
在构建预测模型时，您通过计算不同的评估指标来考虑其预测能力。其中一些是常见的，如准确性和精确度。但是其他的，像上面天气预报模型中的 Brier 分数，经常被忽略。
在本教程中，您将获得对 Brier 评分和校准的简单介绍性解释，这是用于评估统计预测性能的最重要的概念之一。
什么是欧石南乐谱？
Brier Score 评估概率预测的准确性。
假设我们有两个正确预测晴天的模型。一个概率为 0.51，另一个概率为 0.93。它们都是正确的，并且具有相同的精度(假设阈值为 0.5)，但是第二个模型感觉更好，对吗？这就是 Brier score 出现的原因。
当我们处理只能取有限数量的值的变量时(我们也可以称它们为类别或标签)，它特别有用。
例如，紧急程度(采用四个值:绿色、黄色、橙色和红色)，或者明天是雨天、阴天还是晴天，或者是否将超过阈值。
Brier 评分更像是一个成本函数。较低的值意味着准确的预测，反之亦然。处理这个概念的主要目标是减少它。
Brier 分数的数学公式取决于预测变量的类型。如果我们正在开发二元预测，则得分由下式给出:
其中 p 是事件发生的预测概率，如果事件发生，oi 项等于 1，否则等于 0。
让我们举一个简单的例子来理解这个概念。让我们考虑一下事件 A= "明天是晴天"。
如果您预测事件 A 将以 100%的概率发生，并且该事件发生了(下一个是晴天，这意味着 o=1)，Brier 得分等于:
这是可能的最低值。换句话说:我们能达到的最好的情况。
如果我们以同样的概率预测了同样的事件，但是该事件没有发生，那么 Brier 的得分是:
假设你预测 A 事件会以另一种概率发生，假设 60%。如果事件在现实中没有发生，Brier 的分数将是:
您可能已经注意到，Brier 分数是概率域中的一个距离。也就是说:这个分值越低，预测越好。
完美的预测会得到 0 分。最差的分数是 1。这是一个综合标准，提供了关于预测模型的准确性、稳健性和可解释性的综合信息。
虚线代表最坏情况(如果事件发生，圆圈等于 1)。
什么是概率校准？
概率校准是对模型进行后处理，以提高其概率估计。它有助于我们比较具有相同准确性或其他标准评估指标的两个模型。
当置信度为 p 的类的预测在 100%的时间内正确时，我们说模型被很好地校准。为了说明这种校准效果，让我们假设您有一个模型，该模型对每个患者的癌症预测得分为 70%(满分为 100 分)。如果你的模型校准良好，我们将有 70 名癌症患者，如果校准不当，我们将有更多(或更少)的患者。因此，这两种型号的区别在于:
模型的准确率为 70%，每个预测的置信度为 0.7 =校准良好。
- 一个模型的准确率为 70%，每次预测的置信度为 0.9 =校准不良。
- 对于完美的校准，预测概率和阳性分数之间的关系如下:
这种关系的表达式由下式给出:
上图是一个型号的可靠性图。我们可以使用 scikit-learn 绘制它，如下所示:
绘制多个模型的可靠性曲线使我们能够选择最佳模型，不仅基于其准确性，还基于其校准。
import sklearn
from sklearn.calibration import calibration_curve
import matplotlib.lines as line
import matplotlib.pyplot as plt
x, y=calibration_curve(y_true, y_prob)
plt.plot(x,y)
ref = line.Line2D([0, 1], [0, 1], color='black')
transform = ax.transAxes
line.set_transform(transform)
ax.add_line(line)
fig.suptitle('Calibration – Neptune.ai')
ax.set_xlabel('Predicted probability')
ax.set_ylabel('Fraction of positive')
plt.legend()
plt.show()
在下图中，我们可以排除 SVC (0.163)模型，因为它远未得到很好的校准。
如果我们想要一个数值来检查我们模型的校准，我们可以使用理论上给出的校准误差:
什么时候应该使用布赖尔乐谱？
评估机器学习模型的性能很重要，但评估现实世界应用的预测是不够的。
我们经常担心:
模型对其预测的信心，
- 它的误差分布，
- 以及如何进行概率估计。
- 在这种情况下，我们需要使用其他性能因素。Brier score 就是一个例子。
这种类型的性能分数专门用于高风险应用。该分数允许我们不将模型结果视为真实概率，而是超越原始结果并检查模型校准，这对于避免错误决策或错误解释非常重要。
需要校准好的概率/模型校准的例子
假设您想要构建一个模型，通过用户点击新闻页面的机会向用户显示新闻页面。如果用户点击建议项目的机会很高，则该项目显示在主页上。否则，我们显示另一个机会更高的项目。
在这种问题中，我们并不真正关心点击的确切机会是多少，而只关心在所有现有项目中哪个项目的机会最高。模型校准在这里并不重要。重要的是哪一个被点击的概率(几率)最高。
另一方面，考虑这样一个问题，我们建立了一个模型，根据一些分析的结果预测患某种特定疾病的概率。概率的精确值在这里至关重要，因为它影响医生的决策和患者的健康。
通常，当结果显示模型有高概率的错误(或当模型不输出概率估计值时的预测分数，例如随机森林)时，校准用于改进模型。
当然，你也可以看看其他将预测分数作为输入的指标，比如 ROC AUC 分数，但它们通常不会关注正确校准的概率。比如 ROC AUC 侧重于排名预测。
好了，现在我们可以知道什么时候模型没有校准好，但是我们能做些什么呢？我们如何校准它？
概率校准方法
人们使用大量的校准方法。我们将重点介绍两种最流行的方法:
普氏标度
普拉特缩放通常用于校准我们已经建立的模型。该方法的原理是基于将我们的分类模型的输出转换成概率分布。
我们的模型不仅会给出一个分类结果(标签或类别)，还会给出结果本身一定程度的确定性。
不是返回类 1 作为结果，而是返回这个类预测正确的概率。不幸的是，一些分类模型(如 SVM)不返回概率值，或者给出很差的概率估计。
这就是为什么我们使用特定的转换来校准我们的模型，并将结果转换为概率。
为了使用普拉特标度法，我们通常训练我们的模型，然后训练附加 sigmoid 函数的参数，以将模型输出映射成概率。
你可以使用逻辑回归拟合模型的输出。
保序回归
from sklearn.linear_model import LinearRegression
model=LinearRegression()
model.fit(p_out, y_out)
calib_p=model.predict(p_test)[:,1]
保序回归与普拉特标度做同样的事情——它们都将模型输出转换成概率，因此对其进行校准。
有什么区别？
Platt Scaling 使用 sigmoid 形状来校准模型，这意味着我们的概率分布中存在 sigmoid 形状的失真。
保序回归是一种更强大的校准方法，可以校正任何单调失真。它将一个非参数函数投射到一组递增函数(单调)。
如果数据集很小，不建议使用保序回归，因为它很容易过度拟合。
为了实现这种方法，我们将再次使用 sklearn(我们假设您已经构建并训练了您的“未校准模型”):
from sklearn.linear_model import IsotonicRegression
model=IsotonicRegression()
model.fit(p_out, y_out)
calib_p=model.transform(p_test)
在实际例子中使用模型校准
我们来练习一下吧！
为了保持它的唯一性，我们将使用来自 sklearn 的make_classification生成两个类。
之后，我们将在数据集上训练和拟合 SVM 分类器。
我们刚刚创建了独特的随机数据，并将其分为训练集和测试集。
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
X, y = make_classification(n_samples=2500, n_classes=2)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2)
现在，我们构建 SVC 分类器，并使其适合训练集:
我们来预测一下结果:
from sklearn.svm import SVC
svc_model=SVC()
svc_model.fit(X_train, y_train)
接下来，让我们绘制之前讨论过的校准曲线:
prob=svc_model.decision_function(X_test)
上面代码的结果是校准曲线或可靠性曲线:
from sklearn.calibration import calibration_curve
x_p, y_p=calibration_curve(y_test, prob, n_bins=10, normalize=’True’)
plt.plot([0, 1], [0, 1])
plt.plot(x_p, y_p)
plt.show()
这表明我们的分类器校准不良(校准参考是蓝线)。
现在让我们来计算这个校准不当的模型的 Brier 分数:
为此，我们得到 ROC AUC 分数等于 0.89(意味着良好的分类)和 Brief 分数等于 0.49。相当高！
from sklearn.metrics import brier_score_loss, roc_auc_score
y_pred = svc_model.predict(X_test)
brier_score_loss(y_test, y_pred, pos_label=2)
roc_auc_score(y_test, y_pred)
这解释了该模型校准不当的事实。我们该怎么办？
让我们再次使用 sklearn 校准我们的模型。我们将应用普拉特标度(使用 sigmoid 分布校准)。Sklearn 提供了一个预定义的函数来完成这项工作:CalibratedClassifierCV。
模型校准或校准后的可靠性曲线如下:
from sklearn.calibration import CalibratedClassifierCV
calib_model = CalibratedClassifierCV(svc_model, method='sigmoid', cv=5) calib_model.fit(X_train, y_train)
prob = calib_model.predict_proba(X_test)[:, 1]
x_p, y_p = calibration_curve(y_test, prob, n_bins=10, normalize='True')
plt.plot([0, 1], [0, 1])
plt.plot(x_p, y_p)
plt.show()
可靠性曲线显示了向校准参考的趋势(理想情况)。为了进行更多的验证，我们可以使用与之前相同的数字指标。
在以下代码中，我们计算校准模型的 Brier 得分和 ROC AUC 得分:
Brier 评分在校准后下降(从 0.495 降至 0.35)，ROC AUC 评分增加，从 0.89 增至 0.91。
from sklearn.metrics import brier_score_loss, roc_auc_score
y_pred = calib_model.predict(X_test)
brier_score_loss(y_test, y_pred, pos_label=2)
roc_auc_score(y_test, y_pred)
我们注意到，您可能想要在一个等待设置上校准您的模型。在这种情况下，我们将数据集分成三部分:
我们在训练集上拟合模型(第一部分)。
- 我们在校准集上校准模型(第二部分)。
- 我们在测试集上测试模型(第三部分)。
- 最后的想法
校准您的模型是提高其预测性能的关键步骤，尤其是如果您关心具有较低 Brier 分数的“好”概率预测。
然而，你应该记住，改进的校准概率是否有助于基于类别或概率的更好预测并不明显。
这可能取决于您用来测试预测的特定评估指标。根据一些论文，SVM、决策树和随机森林在校准后更有可能得到改进(在我们的示例中，我们使用了支持向量分类器)。
所以要一如既往地小心行事。
我希望，读完这篇文章后，你对 Brier score 和模型校准有一个很好的理解，并且你将能够在你的 ML 项目中使用它。
感谢阅读！
I hope that, after reading this article you have a good understanding of what Brier score and model calibration are and you’ll be able to use that in your ML projects.
参考
[1] Brier GW。“用概率表示的预测的验证”。周一天气 1950 年修订。
[2]涅廷·T·拉夫特里·艾。严格适当的评分规则、预测和评估。J Am 统计协会 2007。
[3]你的模型为现实世界做好准备了吗？–Inbar Naor–2018 年以色列皮肯大会
[4]Python 中的校准图指南–Chang Hsin Lee，2018 年 2 月。
[3] Is your model ready for the real world? – Inbar Naor – PyCon Israel Conference 2018
[4] A guide to calibration plots in Python – Chang Hsin Lee, February 2018.
如何使用 GitHub 操作构建 MLOps 管道[分步指南]
原文：https://web.archive.org/web/https://neptune.ai/blog/build-mlops-pipelines-with-github-actions-guide
一段时间以来， MLOps 已经成为所有日常使用机器学习和深度学习的公司的一个至关重要的流程。事实上，已经有许多专门为解决与 MLOps 管道相关的问题而构建的解决方案。
然而，对于许多只有少量模型投入生产的公司来说，学习和使用新工具(在本例中为 MLOps 管道工具和自动化工具)的成本超过了它将带来的收益。
事实是，要构建简单的 MLOps 管道，不需要学习新的复杂工具，如 Kubeflow 或 Airflow。事实上，您可以使用软件开发中最常用的工具之一:GitHub 来构建简单(但有效)的 MLOps 管道。
在这篇文章中，我将解释如何用 Github、 Github Actions 和一个云服务提供商以一种非常简单的方式创建 MLOps 管道。听起来很有趣？我们开始吧！
什么是 GitHub Actions？
GitHub Actions 是 GitHub 提供的一款工具，用于自动化软件工作流程。例如，软件开发人员使用 GitHub 动作来自动化分支合并，处理 GitHub 中的问题，进行应用程序测试等。
然而，我们作为数据科学家也可以在很多事情上使用 GitHub 动作。在我们的案例中，我们将使用它来自动化 MLOps 工作流的几个步骤，例如:
- 自动化 ETL 过程。
- 检查模型是否应该重新训练。
- 将新模型上传到您的云提供商并进行部署。
如你所见，GitHub 动作将会在我们的 MLOps 管道中被大量使用。好的一面是，如果你不知道 GitHub Actions 是如何工作的，它非常容易学习:你只需要在。工作流/github 文件夹。在这。yaml 文件中，您将指定几项内容，例如:
- 工作流的名称。
- 工作流何时触发:基于 cron 计划、http 请求、手动等。
- 工作流将运行的操作系统(Ubuntu、Windows 或 MAC)。
- 工作流应该执行的每个步骤。
注意:因为这不是 Github 动作教程，所以我不会深入这个话题。然而，这里你有一个教程，它将帮助你学习如何使用 GitHub 动作。
使用 GitHub 动作作为 MLOps 工作流的利弊
为 MLOps 使用 GitHub 动作的好处不仅仅是我们不必学习新工具，它还有许多其他优点:
- GitHub Actions 与用于数据科学的主要编程语言一起工作:Python、R、Julia 等。
- 可以利用学习 GitHub 动作的经验自动化其他流程。
- GitHub Actions 对公共库是免费的。此外，关于私有存储库，GitHub Actions 提供了以下内容:
- 免费账号:每月 2000 分钟的 GitHub 行动。
- 团队账户:每月 3000 分钟的 GitHub 行动。
- 团队账户:每月 50，000 分钟的 GitHub 行动。
- 这种自动化与 AWS、Azure 和 Google Cloud 等主要云提供商完美合作，因此您不会被单一云提供商束缚。
- 每次工作流程失败，您都会自动收到一封电子邮件。
如您所见，为 MLOps 使用 GitHub 动作有很多好处。然而，正如你可能想象的那样它并不是所有情况下的完美解决方案。在我看来，我不建议在以下场景中使用 GitHub 作为 MLOps 工作流工具:
- 你有许多你必须投入生产的模型或者少数但是复杂的模型(比如深度学习模型)。在这种情况下，你将需要大量的计算能力来训练你的模型，而 GitHub Action 的机器不适合这样做。
- 您已经在使用可用于 MLOps 的工具。例如，假设您正在使用 Apache Airflow 进行 ETL 过程。在这种情况下，将这个工具用于 MLOps 可能比用 GitHub 构建 MLOps 管道更好。
好了，现在你已经知道 GitHub Actions 是什么，什么时候你应该或者不应该把它作为 MLOps 管道工具，让我们学习如果你决定使用它，你如何用 GitHub Actions 构建 MLOps 管道。
如何使用 GitHub 和 Google Cloud 构建 MLOps 管道[分步指南]
在接下来的章节中，我们将讨论如何使用 GitHub、GitHub Actions 和 Google Cloud 构建 MLOps 管道并将其投入生产。为此，我们建立了一个模型来预测每小时的比特币交易量。
更具体地说，您将了解:
- 如何用 GitHub 动作设置数据提取管道？
- 如何用 GitHub 动作构建模型训练和选择管道？
- 如何将你的模型包装成 API？
- 如何对你的 API 进行 Docker 化，以便你的代码可以移植并部署在任何 Docker 友好的云服务中。
- 如何用云和 GitHub 动作设置一个持续部署管道？
- 如何用 GitHub 动作自动化模型重训练？
如果你已经有了部署机器学习管道的经验，其中的一些步骤你可能已经很熟悉了。我仍然鼓励您阅读它们，这样您就可以了解 GitHub 操作是如何完成的。
让我们从带有 GitHub 动作的 MLOps 教程开始吧！
为了创建模型，我们首先需要获取数据。此外，由于我们想要创建一个 MLOps 管道，我们将需要创建一个 ETL 过程来提取数据、转换数据并将其加载到某个地方，比如数据湖、数据仓库或数据库。通过这样做，我们将能够随时用新的数据重新训练模型，并将其投入生产。
如果我们想用 GitHub 操作来做这件事，我们将需要创建一个或多个脚本来承担 ETL 过程。这些脚本应该是可自动执行的，理想情况下，还应该处理异常并在出现错误时发出警告。
例如，如果您需要从外部数据源提取数据，那么当外部数据源不工作时，向某人发送警告通常是一种好的做法。这将有助于调试过程，并且肯定会使事情变得容易得多。
此外，需要注意的是，不是所有的过程都应该在一个脚本中完成。唯一的限制是带有 GitHub 动作的脚本的执行是不可并行的。
发送完毕后，让我们看看带有 GitHub 动作的数据提取管道在实践中是怎样的:
在我们的例子中，区块链为提供了这个 API ，它显示了每分钟添加到池中的交易数量。
考虑到这一点，由于我们希望预测每小时的事务数量，我们的 ETL 管道将由以下内容组成:
- 提取:从 API 中读取信息。
- 转换:分组求和得到小时交易数。
- Load :将信息上传到数据库，存储所有历史信息。
也就是说，我在下面的 Python 脚本中总结了所有这些过程，该脚本执行了上述步骤。
import pandas as pd
import requests
from datetime import datetime
from sqlalchemy import create_engine
import os
uri = os.environ.get('URI')
url = 'https://api.blockchain.info/charts/transactions-per-second?timespan=all&sampled=false&metadata=false&cors=true&format=json'
resp = requests.get(url)
data = pd.DataFrame(resp.json()['values'])
data['x'] = [datetime.utcfromtimestamp(x).strftime('%Y-%m-%d %H:%M:%S') for x in data['x']]
data['x'] = pd.to_datetime(data['x'])
engine = create_engine(uri)
query = engine.execute('SELECT MAX(reality_date) FROM reality;')
last_reality_date = query.fetchall()[0][0]
query.close()
engine = create_engine(uri)
query = engine.execute('SELECT MIN(prediction_date), MAX(prediction_date) FROM predictions;')
prediction_date= query.fetchall()[0]
query.close()
first_prediction_date = prediction_date[0]
last_prediction_date = prediction_date[1]
if last_reality_date is None:
date_extract = first_prediction_date
elif last_reality_date <= last_prediction_date:
date_extract = last_reality_date
else:
date_extract = last_reality_date
data['x'] = data['x'].dt.round('H')
data_grouped = data.groupby('x').sum().reset_index()
data_grouped = data_grouped.loc[data_grouped['x'] >= date_extract,:]
upload_data = list(zip(data_grouped['x'], round(data_grouped['y'],4)))
upload_data[:3]
for upload_day in upload_data:
timestamp, reality= upload_day
result = engine.execute(f"INSERT INTO reality(reality_date, reality) VALUES('{timestamp}', '{reality}') ON CONFLICT (reality_date) DO UPDATE SET reality_date = '{timestamp}', reality= '{reality}';")
result.close()
最后，我使用 GitHub Actions 自动化了这个工作流，这样每小时都会执行一次脚本并向数据库中插入新数据。这种自动化是通过以下 YAML 文件完成的:
name: update-ddbb
on:
schedule:
- cron: '0 0/6 * * *'
workflow_dispatch:
jobs:
build:
runs-on: ubuntu-latest
steps:
- name: Access the repo
uses: actions/checkout@v2
- name: Configure Python
uses: actions/setup-python@v2
with:
python-version: '3.9.7'
- name: Install necessary libraries
run: |
python -m pip install --upgrade pip
pip install -r requirements.txt
- name: Execute Python Script
env:
URI: ${{ secrets.URI }}
run: python update_real_data.py
正如您所看到的，仅仅用两个简单的文件，我们就构建并自动化了一个 ETL 过程。正如我之前所说的，您也可以使用其他工具，如 Apache Airflow，但是如果您没有它，您可以使用 GitHub Actions。
既然我们已经了解了如何获取数据，现在让我们看看如何用 GitHub 操作构建模型训练和选择管道。
使用 GitHub 操作的模型训练和选择管道
如何用 GitHub 动作建立模型训练和选择管道需求
用 GitHub 动作构建模型选择管道非常简单。您只需要创建一个脚本来读取您之前在数据提取管道中清理的数据，并使用它构建几个模型。
在建立了几个模型之后，你需要使用足够的性能模型来评估它们(你可以在这篇文章的中了解更多关于机器学习的性能指标)。
一旦你做到了这一点，你就找到了你训练过的表现最好的模型。这个模型是我们将用来进行预测的模型，它将由我们的 API 提供服务。
注:在分类和回归模型中，比较新模型和生产模型的预测能力通常是一种好的做法。然而，在预测模型中，这通常是不需要的，因为具有较新数据的模型通常比过去的模型效果更好。
模型训练和选择流程示例
首先，为了将模型投入生产，我们必须创建一个脚本来创建和调优几个模型。为此，我使用随机森林作为自回归模型进行了网格搜索。
为此，我使用了 skforecast 库，这是一个使用 sklearn 的模型作为时间序列预测的自回归模型的库(你可以在这里了解更多关于它的)。
在现实世界的场景中，我们不应该使用一个带有超参数调整的单一模型，而是应该训练几个模型，并调整每个模型的超参数。然而，为了使教程更加动态，我将只训练一个模型。
最后，在建立模型后，我将获得并保存最佳表现模型和最后的训练数据到一个文件中。这两个文件是进行预测所必需的。
在这一点上，我建议保存已经在元数据存储(比如 Neptune)中构建的所有模型的信息。通过这样做，您将获得关于已经构建的所有模型的信息，以及为什么选择生产中的模型。
在我们的比特币每小时交易预测示例中，这个过程是使用以下 Python 脚本进行的:
import pandas as pd
import pickle
from utils import create_predictors
from skforecast.model_selection import grid_search_forecaster
from skforecast.ForecasterAutoregCustom import ForecasterAutoregCustom
from sklearn.ensemble import RandomForestRegressor
import requests
from datetime import datetime
import os
from dotenv import load_dotenv
import neptune.new as neptune
load_dotenv()
NEPTUNE_API_KEY = os.environ.get('NEPTUNE_API_KEY')
NEPTUNE_PROJECT = os.environ.get('NEPTUNE_PROJECT')
steps = 36
n_datos_entrenar = 200
path_fichero = 'bitcoin.csv'
path_modelo = 'model.pickle'
uri_mlflow = 'http://104.198.136.57:8080/'
experiment_name = "bictoin_transactions"
url = 'https://api.blockchain.info/charts/transactions-per-second?timespan=all&sampled=false&metadata=false&cors=true&format=json'
resp = requests.get(url)
data = pd.DataFrame(resp.json()['values'])
data['x'] = [datetime.utcfromtimestamp(x).strftime('%Y-%m-%d %H:%M:%S') for x in data['x']]
data['x'] = pd.to_datetime(data['x'])
data.columns = ['date', 'transactions']
data['date'] = data['date'].dt.round('H')
grouped_data = data.groupby('date').sum().reset_index()
grouped_data = grouped_data.set_index('date')
grouped_data = grouped_data['transactions']
train_data = grouped_data[ -n_datos_entrenar:-steps]
test_data = grouped_data[-steps:]
forecaster_rf = ForecasterAutoregCustom(
regressor = RandomForestRegressor(random_state=123),
fun_predictors = create_predictors,
window_size = 20
)
param_grid = { 'n_estimators': [100, 500], 'max_depth': [3, 5, 10] }
grid_results = grid_search_forecaster(
forecaster = forecaster_rf,
y = train_data,
param_grid = param_grid,
steps = 10,
method = 'cv',
metric = 'mean_squared_error',
initial_train_size = int(len(train_data)*0.5),
allow_incomplete_fold = True,
return_best = True,
verbose = False
)
for i in range(grid_results.shape[0]):
run = neptune.init(
project= NEPTUNE_PROJECT,
api_token=NEPTUNE_API_KEY,
)
params = grid_results['params'][i]
run["parameters"] = params
run["mean_squared_error"] = grid_results['metric'][i]
run.stop()
last_training_date = test_data.index[-1].strftime('%Y-%m-%d %H:%M:%S')
pickle.dump(last_training_date, open('last_training_date.pickle', 'wb'))
pickle.dump(forecaster_rf, open(path_modelo, 'wb'))
Tracked runs visible in the Neptune UI | Source
现在我们已经构建了模型，让我们看看如何将它包装成一个 API 来使模型服务。
将模型包装成 API
一旦创建了模型，为了将它投入生产，我们将创建一个 API 来接收模型参数作为输入并返回预测。
此外，除了返回预测，API 将输入数据和预测保存在数据库中也很重要。通过这种方式，我们可以稍后将预测与现实进行比较，从而了解我们的模型表现如何，如果它表现不正常，我们可以重新训练它。
如何在 API 中包装模型将取决于您使用的语言类型，以及您的偏好。在使用 R 的情况下，最正常的事情是你使用 plumber 库，而在 Python 中你有几个库，如 FastAPI 或 Flask 。
说到这里，让我们看看如何在我们的例子中实现这一点。
将模型包装成 API 的例子
为了用 Python 创建 API，我选择使用 FastAPI 作为 API 生成框架，因为它允许轻松创建 API，还可以检查输入的数据类型。
此外，为了保存模型的预测，我在 Postgres 数据库中创建了一个表。通过这样做，因为真实数据在一个表中，而预测在另一个表中，所以我创建了一个视图，其中有:
- 我预测的时间
- 我对那个小时的预测。
- 那一小时的实际交易数量。
- 预测绝对误差。
通过这样做，创建一个可视化的视图来显示模型随时间推移的性能，就像连接到这个视图并显示一些图表和 KPI 一样简单。
关于 API，内部发生的事情非常简单，你只需加载模型，进行预测，然后将其插入数据库。
然而，在我们的例子中，由于它是一个时间序列模型，它有一个额外的复杂性层，因为我们可能会对某个日期进行预测，而我们之前已经对该日期进行了预测。在这种情况下，在数据库中进行插入是不够的，还必须替换以前的值。
因此，在下面的脚本中，您可以看到我是如何创建 API 的:
from fastapi import FastAPI
app = FastAPI()
@app.post("/forecast")
def forecast(num_predictions = 168, return_predictions = True):
import pandas as pd
import requests
from datetime import datetime
from sqlalchemy import create_engine
import pickle
import os
uri = os.environ.get('URI')
forecaster_rf = pickle.load(open('model.pickle', 'rb'))
last_training_date = pickle.load(open('last_training_date.pickle', 'rb'))
last_training_date = datetime.strptime(last_training_date, '%Y-%m-%d %H:%M:%S')
url = 'https://api.blockchain.info/charts/transactions-per-second?timespan=all&sampled=false&metadata=false&cors=true&format=json'
resp = requests.get(url)
data = pd.DataFrame(resp.json()['values'])
data['x'] = [datetime.utcfromtimestamp(x).strftime('%Y-%m-%d %H:%M:%S') for x in data['x']]
data['x'] = pd.to_datetime(data['x'])
engine = create_engine(uri)
query = engine.execute('SELECT MAX(prediction_date) FROM predictions;')
last_prediction_date= query.fetchall()[0][0]
query.close()
if (last_prediction_date is None) or (last_prediction_date > last_training_date):
predictions = forecaster_rf.predict(num_predictions)
fechas = pd.date_range(
start = last_training_date.strftime('%Y-%m-%d %H:%M:%S'),
periods = num_predictions,
freq = '1H'
)
elif last_prediction_date > last_training_date:
dif_seg= last_prediction_date - last_training_date
hours_extract = num_predictions + dif_seg.seconds//3600
predictions = forecaster_rf.predict(num_predictions)
predictions = predictions[-num_predictions:]
fechas = pd.date_range(
start = last_prediction_date.strftime('%Y-%m-%d %H:%M:%S'),
periods = num_predictions,
freq = '1H'
)
else:
predictions = forecaster_rf.predict(num_predictions)
fechas = pd.date_range(
start = last_training_date.strftime('%Y-%m-%d %H:%M:%S'),
periods = num_predictions,
freq = '1H'
)
upload_data = list(zip([
datetime.now().strftime('%Y-%m-%d %H:%M:%S')] * num_predictions,
[fecha.strftime('%Y-%m-%d %H:%M:%S') for fecha in fechas ],
predictions
))
for upload_day in upload_data:
timestamp, fecha_pred, pred = upload_day
pred = round(pred, 4)
result = engine.execute(f"INSERT INTO predictions (timestamp, prediction_date, prediccion)\
VALUES('{timestamp}', '{fecha_pred}', '{pred}') \
ON CONFLICT (prediction_date) DO UPDATE \
SET timestamp = '{timestamp}', \
prediccion = '{pred}'\
;")
result.close()
if return_predictions:
predictions
else:
return 'New data inserted'
现在我们已经创建了 API，我们进入 MLOps 部分，看看如何将模型进行 dockerize 以将其投入生产。让我们去吧！
将 API 归档
一旦我们创建了返回预测的 API，我们将把它包含在 Docker 容器中。通过这样做，我们将能够在任何使用 Docker 或 Kubernetes 的环境中把我们的代码投入生产，使我们的代码更加可移植和独立。
注意:如果你是 Docker 的新手，我推荐你阅读这篇关于如何使用 Docker 进行数据科学的教程。另一方面，如果你已经有了一些经验，肯定会对 Docker 最佳实践中的这篇文章感兴趣。
因此，为了对我们的 API 进行 Docker 化，我们必须创建一个 Docker 文件，因为它是告诉 Docker 如何构建映像的文件。从这个意义上说，Dockerfile 文件包含以下几点非常重要:
- 安装我们使用的编程语言和 API 框架。
- 安装必要的库来正确执行我们的代码。
- 复制 API、模型和 API 正确运行所需的所有文件。
- 在我们想要的端口中执行 API。
一旦我们创建了 docker 文件，验证它是否正常工作是很重要的。为此，我们必须执行以下命令:
cd <folder_where_Dockerfile_is_located>
docker build -t <image_name> .
docker run -p <port:port> <image_name>
之后，我们可以访问我们的端口并检查 API 是否正常工作。如果是的话，我们可以进入下一步:将我们的模型投入生产。
使用云和 GitHub 建立持续部署管道
这是我们用 GitHub 动作开始 MLOps 过程的地方。因此，当使用 GitHub 操作执行 MLOps 时，我们要做的是，将我们的 GitHub 存储库与我们的云提供商连接起来，这样，每当我们在 GitHub 中推送我们的 repo 时，Docker 映像就会在我们想要的云服务中构建和部署。而且，正如你可能想象的那样，一切都会自动发生。
换句话说，我们将不再需要在我们的云环境中手动部署我们的代码，而是每次我们推送到我们的存储库时自动完成。是不是很酷？
好消息是，对于这一点，过程总是相同的:
- 将我们的云服务与 GitHub 连接起来，每次推送时，Docker 图像都会上传到我们的云服务的容器注册中心。
- 创建一个文件，告诉我们的云服务应该对 Docker 映像执行哪些步骤。
对于谷歌云，我们将使用以下工具:
- Google Cloud Build: 用于构建 docker 映像的服务。
- 容器注册:存放容器的服务。
- Cloud Run: 将容器化的 API 部署到一个服务的服务，该服务自动向下扩展到 0，也就是说，如果该服务没有收到任何请求，就不会有虚拟机在运行。这意味着您只需在请求部署在 Cloud Run 中的服务时付费。
主要想法是将 Cloud Build 与 GitHub 连接起来，这样每次推送回购时，Cloud Build 都会构建映像。然后，运行一个脚本，将该映像推送到容器注册中心，并将其从容器注册中心部署到云运行。
MLOps with GitHub Actions: deployment workflow | Source: Author
为此，我们必须遵循以下步骤:
-
在事件部分，我们选择我们想要的触发器。在我们的例子中，我们将其保留为默认值:Push to a branch。
-
在资源库下的 Source 中，点击“Connect new Repository”按钮，如下图所示，选择 GitHub 作为您的资源库。
-
一个窗口将提示您授权 GitHub 帐户上的云构建应用程序。我们需要对它进行授权，并将应用程序安装在特定的存储库中或所有存储库中。
-
为 MLOPs 流程选择存储库。从云构建触发器菜单构建到存储库。
-
选择云构建配置模式。在这种情况下，我们必须选择云构建配置文件选项，如下图所示:
-
最后，我们选择一个服务帐户，然后单击“Create”按钮。
很好，我们现在已经将 GitHub 帐户与 Google 容器注册中心连接起来了。这种自动化将在我们每次推送容器时执行。
然而，我们仍然必须定义一个重要的并且经常被忽略的东西:云构建配置文件。我们来看看怎么做。
指定云构建配置文件
云构建配置文件是这样一个文件，它告诉云构建每当我们已经指出的触发器被触发时要执行什么云命令。
在我们的例子中，我们只希望执行三个命令:
- 使用来自 GitHub 库的文件创建 Docker 映像。
- 将 Docker 图像上传到 Google Cloud Container 注册表。
- 在 Google 云服务中部署 docker 映像，Kubernetes 或 Cloud Run(在我们的例子中，我们将使用后者)。
我们将在一个. yaml 文件中定义所有这些内容，指出每一点都是要执行的步骤。在下面的代码中，我们看到。我在比特币交易示例中使用的 yaml 文件:
steps:
- name: 'gcr.io/cloud-builders/docker'
args: ['build', '-t', 'gcr.io/mlops-example/github.com/anderdecidata/mlops-example:$SHORT_SHA', '.']
- name: 'gcr.io/cloud-builders/docker'
args: ['push', 'gcr.io/mlops-example/github.com/anderdecidata/mlops-example:$SHORT_SHA']
- name: 'gcr.io/cloud-builders/gcloud'
args: ['beta', 'run', 'deploy', 'mlops-example', '--image=gcr.io/mlops-example/github.com/anderdecidata/mlops-example:$SHORT_SHA', '- -region=europe-west1', '--platform=managed']
此外，好消息是这个过程适用于所有三个主要的云环境:AWS、Azure 和 Google Cloud。虽然我们只讨论了 Google Cloud，但这里有一个关于如何使用其他服务的简单解释:
- 使用 GitHub 和 Azure 的 MLOPs 工作流:你需要创建一个 GitHub 动作，它在每次推送时运行，并使用 Azure CLI 登录，构建和推送映像，然后部署它。这里可以找到一个的例子。
- 使用 GitHub 和 AWS 的 MLOPs 工作流:与 Azure 类似，您需要创建一个 GitHub 动作，该动作在每次推送时运行，登录 AWS ECR 并推送图像。这里可以找到一个的例子。
这样，我们就用 GitHub 操作创建了 MLOps 管道。这样，我们每推一款新机型到我们的 GitHub，它就会自动投产。
然而，这并不完全理想，因为我们需要定期手动重新训练模型。因此，让我们看看如何将我们的 MLOps GitHub 管道提升到一个新的水平。
用 GitHub 动作自动化模型重训练
根据我们到目前为止所看到的一切，要将重新训练的模型投入生产，我们只需创建一个脚本:
- 运行模型训练文件。
- 将新模型推送到我们的 GitHub 库。
这样，当推送完成时，Google Cloud Build 会自动检测到它，并使用新的模型构建映像，上传到云容器注册表，最后部署到 Cloud Run。
正如您可能已经猜到的，我们可以使用 GitHub 动作自动执行模型再训练。我们只需创建一个 GitHub 动作，定期执行训练文件并将新文件推送到 GitHub。
然而，这一点也不理想。因为，如果预测足够好，我们为什么要重新训练一个模型呢？或者，如果当前模型返回错误的预测，我们为什么要等到下一个模型重新训练？
因此，如果我们想更进一步，我们可以在模型的预测能力不好时重新训练模型。为此，我们只需:
- 使用 http 请求触发模型重新训练工作流。
- 创建一个脚本来检查模型的预测能力。如果模型的预测能力小于我们设置的阈值，脚本将通过对它的 http 调用来执行重新训练工作流。
后者是我如何用 GitHub 将它组装到 MLOps 工作流中，以预测比特币的交易数量。使用以下代码，我们可以检查 MAE 是否低于特定阈值，并在低于特定阈值的情况下启动重新训练工作流:
import pandas as pd
from sqlalchemy import create_engine
from datetime import datetime, timedelta
import requests
import json
import os
user = 'anderDecidata'
repo = 'Ejemplo-MLOps'
event_type = 'execute-retrain'
GITHUB_TOKEN = os.environ.get('TOKEN')
uri = os.environ.get('URI')
max_mae = 6
n_observations_analyze = 48
days_substract = round(n_observations_analyze/24)
engine = create_engine(uri)
resp = engine.execute('SELECT MAX(fecha) FROM tablon;')
largest_date = resp.fetchall()
resp.close()
initial_date = largest_date[0][0] - timedelta(days = days_subsctract)
resp = engine.execute(f"SELECT * FROM tablon WHERE fecha >'{initial_date}';")
data = resp.fetchall()
colnames = resp.keys()
resp.close()
data = pd.DataFrame(data, columns=colnames)
print(data['mae'].mean())
if data['mae'].mean() > max_mae:
url = f'https://api.github.com/repos/{user}/{repo}/dispatches'
resp = requests.post(url, headers={'Authorization': f'token {GITHUB_TOKEN}'}, data = json.dumps({'event_type': event_type}))
此外，我们可以通过下面的 GitHub 动作自动执行这个脚本:
name: Check retrain
on:
schedule:
- cron: '0 0/2 * * *'
workflow_dispatch:
jobs:
build:
runs-on: ubuntu-latest
steps:
- name: Checkout repo
uses: actions/checkout@v2
- name: Configure Python
uses: actions/setup-python@v2
with:
python-version: '3.9.7'
- name: Install libraries
run: |
python -m pip install --upgrade pip
pip install -r requirements.txt
- name: Execute python script
env:
URI: ${{ secrets.URI }}
TOKEN: ${{secrets.TOKEN}}
run: python check_retrain.py
结论
正如您在本教程中可能已经看到的，可以通过 GitHub 操作以相对简单的方式创建 MLOps 工作流，只需在我们当前的工作工具中添加一些工具。
在我看来，使用 GitHub 执行 MLOps 是一种非常好的方式来进行模型的持续部署，特别是在那些机器学习和高级分析不够重视或没有很多数据特定工具的组织中。
我希望本教程能够帮助您了解如何使用 GitHub 构建 MLOps 管道。如果你从来没有做过，我个人建议你创建一个，因为这是一个非常好的学习方法。
此外，如果你想学习其他工具而不是 GitHub 动作来构建 MLOps 管道，我会鼓励你学习 CircleCI 或 Gitlab CI 。这两个工具是公司用来代替 GitHub Actions 的替代品，但是构建 MLOps 管道的方式与本文中解释的方式相同。
相关资料:
安德尔·费尔南德斯·黄雷盖
Decidata 的高级数据科学家和德乌斯托大学大数据和商业智能研究生学位的教授(他在那里教授各种科目，从受监督的机器学习模型到创建 ETL 流程并将其放入云中)。他还试图通过他的博客与数据科学家社区分享所有这些知识，在他的博客中，他解释了数据世界中的各种主题:从从头开始的算法编程到云中的自动化脚本，所有这一切都是用 R 和 Python 编写的。
阅读下一篇
最佳 MLOps 工具以及如何评估它们
12 分钟阅读| Jakub Czakon |年 8 月 25 日更新
在我们的一篇文章中——机器学习团队实际使用的最好的工具、库、框架和方法——我们从 41 家 ML 初创公司学到的东西——Acerta 的 CTO Jean-Christophe Petkovich 解释了他们的 ML 团队如何接近 MLOps。
据他所说，一个完整的 MLOps 系统有几个要素:
- 您需要能够构建包含预处理数据和生成结果所需的所有信息的模型工件。
- 一旦您能够构建模型工件，您必须能够跟踪构建它们的代码，以及它们被训练和测试的数据。
- 您需要跟踪所有这三样东西，模型、它们的代码和它们的数据，是如何关联的。
- 一旦您可以跟踪所有这些内容，您还可以将它们标记为准备就绪，进行生产，并通过 CI/CD 流程运行它们。
- 最后，为了在该过程的最后实际部署它们，您需要某种方法来基于该模型工件旋转服务。
这是对如何在公司中成功实施 MLOps 的高度概括。但是理解高层需要什么只是拼图的一部分。另一个是采用或创建适当的工具来完成工作。
这就是为什么我们编制了一份最佳 MLOps 工具的清单。我们将它们分为六类，以便您可以为您的团队和业务选择合适的工具。让我们开始吧！
利用无人机技术和深度学习构建面罩监控系统
COVID19 的爆发让世界措手不及，影响了全球的政府、公司和个人。疫情对全球产生了有害的影响，因为许多国家为了阻止病毒的影响而实施了严格的行动限制。世界银行 全球经济展望 预测 2020 年全球 GDP 将收缩 5.2%，这是几十年来最严重的全球经济衰退。
大流行的影响需要来自各个领域的解决方案，这为采用高级分析和基于人工智能的技术的解决方案铺平了道路。本文展示了一个解决方案，它增强了决策制定，并且易于推向生产(在数据的上下文中，用于训练、验证和测试模型)。
这是一个端到端的文章系列。在它的三个部分中，我将向您展示如何构建一个无人机监控系统，以检测公众在开放区域使用口罩的情况。监控系统将对违约者进行截图，并通过电子邮件通知监管机构。最后，该系统将启用视频流记录。
戴口罩结合其他预防措施，如经常洗手和社交距离，有助于减缓冠状病毒的传播。一架戴着面罩进行监督的无人机不仅积极地缓解了病毒传播——它还具有一种酷的反乌托邦感觉，这是每个赛博朋克爱好者都暗暗渴望的！
在本教程结束时，您将拥有一个无人机监视系统，可以部署到人员大量涌入的开放区域，可以发现所有不符合面罩规定的情况。
我们将很快进入如何工作的细节，但在此之前，下面是我们将要构建的示意图:
Project workflow overview
在开始使用无人机技术之前(先决条件)
为了充分理解本教程，假设您:
在本系列的第一部分，您将了解无人机技术的使用和配置。在第 2 部分中，您将学习如何构建和训练人脸检测模型。在第 3 部分中，您将学习如何将各个部分组合在一起并部署服务。
无人机技术简介
无人机就是一个飞行机器人。它既可以远程控制，也可以通过嵌入式系统中的软件控制的飞行计划自主飞行，与机载传感器和 GPS 配合工作。
无人机的种类
为了在各种(机器学习)项目中使用无人机，你需要知道可用的类型。就本文而言，无人机的分类将以空中平台为基础，可分为 5 类，即:
1。多旋翼无人机:这些是最常见的无人机类型，也是最便宜的。该名称源自其结构中的大量电动转子。
该类别的一些子类包括三翼机(3 个旋翼)、四翼机(4 个旋翼)、六翼机(6 个旋翼)和八翼机(8 个旋翼)。由于其有限的飞行时间、续航能力和速度，这种类型的无人机不能用于大型项目。
Multi-rotor drone schema
2。 单旋翼无人机:该类无人机具有典型直升机的设计。它有一个电动旋翼和一个位于无人机尾部的补充旋翼，用于前进方向。空气动力学的经验法则是旋翼数量越少，稳定性越好。因此，可以肯定地说，单旋翼无人机比多旋翼无人机更有效率。
Single-rotor drone schema
3。固定翼无人机:该类无人机的设计灵感来源于飞机。它有固定的机翼，有相同的飞行和着陆顺序。它们有更长的飞行时间，因为它们通常利用气流保持漂浮。这种无人机的缺点是飞行所需的成本和培训较高。
Fixed-wing drone schema
4。动力提升无人机:这些无人机采用固定翼和旋翼混合设计。这种无人机可以垂直起飞和降落，也可以前进飞行。陀螺仪和加速度计有助于飞行中的稳定。
Power-lift drone schema
5。飞艇:这种无人机被建造成“比空气轻”——充满浮力气体(如氦气或氢气)，通常由发动机驱动。
Airship schema
对于本文的上下文，我们将使用可编程多旋翼无人机——泰洛·里兹。泰洛无人机由深圳瑞泽科技制造。它融合了 DJI 飞行控制技术和英特尔处理器。泰洛 RYZE 支持 scratch 的块编程和 python 的快速高级脚本。你可以在这里阅读更多关于泰洛 RYZE 无人机。
无人机架构
泰洛无人机具有简单的架构，因为它利用软件开发工具包(SDK)与无人机进行交互。泰洛 SDK 通过 Wi-Fi UDP 端口与无人机建立连接，允许用户通过脚本或文本命令控制无人机。
该工作流是双向的，因为它允许向泰洛发送 SDK 指令并从泰洛接收信息。Wi-Fi 用于在泰洛和 PC、平板电脑或智能手机之间建立连接，随后可以通过发送命令和接收信息
泰洛 IP: 192.168.10.1
端口:8889
无人机的主要部件如下所示:
下表概述了泰洛 RYZE 无人机:
根据上面的描述，很明显这款无人机主要用于室内。其定义特征使操作非常有限，因为它具有:
- 最大飞行距离为 100 米，
- 最大速度为 8 米/秒，
- 最长飞行时间为 13 分钟
- 最大飞行高度 30 米。
设置无人机编程环境
无人机可以用各种语言编程，但我为这个项目选择了 python，因为它有很好的计算机视觉和深度学习库。创建了不同的 Python 库，以向用户提供一种简单的方式来与 DJI·泰洛无人机进行交互并向其发送命令，如 DJI·泰洛 SDK 2.0 中所述，例如:
我将使用 djitellopy ，因为它似乎在 stars、forks 和 pull-requests 中拥有最活跃的社区。
本文使用的代码、数据集和其他资源可以在Github上找到。
*该项目由三(3)个 python 脚本组成:
- 无人机配置脚本:drone-config.py
- 实时面罩检测脚本:realtime-detection.py
- 运行项目的主脚本:main.py
无人机配置脚本
为了构建无人机配置脚本，我们需要导入必要的库来实例化所需的操作。djitellopy 和 openCV 可以通过终端由 PyPI 包管理器轻松安装，如下所示:
$ pip install djitellopy
$ pip install opencv-python
完全安装了用于与无人机和计算机视觉操作交互的库。我们开始如下:
from djitellopy import Tello
import cv2
import time
import os
pkg = Tello()
pkg.connect()
上面的片段通过 WiFi 连接成功地与无人机和我们的 PC 建立了 UDP 连接。将创建一个无人机类，如下所示:
class Drone:
"""Wrapper class to setup the tello drone"""
def __init__(self, width, height):
self.StartCounter = 0
self.width = width
self.height = height
self.back_velocity = 0
self.left_right_velocity = 0
self.up_down_velocity = 0
self.yaw_velocity = 0
self.speed = 0
创建无人机类别时，将后退速度、侧向(左/右)速度、垂直速度和偏航速度的默认状态以及初始速度设置为零，以确保无人机在起飞前处于平衡状态。更多关于无人机的物理知识可以在这里阅读。drone 类还接受所需框架的宽度和高度值。
def get_status(self):
battery = pkg.get_battery()
fly_time = pkg.get_flight_time()
drone_height = pkg.get_height()
atmospheric_pressure = pkg.get_barometer()
temperature = pkg.get_temperature()
yaw_velocity = pkg.get_yaw()
speed_x = pkg.get_speed_x()
speed_y = pkg.get_speed_y()
speed_z = pkg.get_speed_z()
acceleration_x = pkg.get_acceleration_x()
acceleration_y = pkg.get_acceleration_y()
acceleration_z = pkg.get_acceleration_z()
status_files = {
'battery': battery,
'fly_time': fly_time,
'drone_height': drone_height,
'atmospheric_pressure': atmospheric_pressure,
'temperature': temperature,
'yaw_velocity': yaw_velocity,
'speed': (speed_x, speed_y, speed_z),
'acceleration':(acceleration_x,acceleration_y, acceleration_z)
}
return status_files.items()
无人机类有一个“get_status”方法，该方法返回一个字典，其中包含以百分比表示的电池电量、以秒为单位的飞行时间、以厘米为单位的无人机当前高度、以厘米为单位的高度(高度计)、以摄氏度为单位的温度、以厘米/秒为单位的纱线速度、以厘米/为单位的 3d 空间(X、Y 和 Z 轴)中的速度以及以厘米/秒平方(cm/s2)为单位的 3D 空间(X、Y 和 Z 轴)中的加速度。
def get_stream_on(self):
pkg.streamon()
def get_stream_off(self):
pkg.streamoff()
drone 类有一个“get_stream_on”和“get_stream_off”方法来打开和关闭视频流。在 AP 模式下(即当您的计算机连接到泰洛-XXXXXX WiFi 网络时)，所有 Tello 都支持视频流。
def get_frame(self):
frame_read = pkg.get_frame_read()
return frame_read.frame
drone 类有一个“get_frame”方法来捕获从无人机摄像机接收到的帧。
def get_video(self):
fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('drone_video.avi', fourcc, 20.0, (640, 480))
frame_read = pkg.get_frame_read()
while(True):
cv2.imshow('Video Stream', frame_read.frame)
out.write(frame_read.frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
out.release()
cv2.destroyAllWindows()
return 'complete'
drone 类的“get_video”方法用一个保存视频流(逐帧处理)。avi 格式使用 OpenCV VideoWriter 类。帧大小为 640 x 480，采用 FourCC 编解码器。
def advance_movement(self):
pkg.takeoff()
pkg.move_forward(40)
def fallback_movement(self):
pkg.rotate_counter_clockwise(90)
pkg.move_forward(20)
pkg.end()
def get_movement(self):
pkg.takeoff()
pkg.rotate_counter_clockwise(5)
pkg.move_up(5)
pkg.move_forward(5)
pkg.rotate_clockwise(90)
time.sleep(20)
pkg.rotate_clockwise(90)
pkg.move_forward(5)
time.sleep(5)
pkg.end()
各种运动方案，如“前进 _ 运动”、“后退 _ 运动”和“获得 _ 运动”都是以厘米为距离单位创建的。这些方案包括向前、向后、向左、向右、向上和向下的运动，以及顺时针和逆时针旋转。为了开始运动，启动“起飞”命令，为了结束飞行，启动“结束”命令。
def get_snap_shots(self, label, frame):
count = 0
if label.split(':')[0] == 'No Mask':
file_name = './snapshots/no mask ' + str(count) + '.jpg'
print(file_name)
cv2.imwrite(file_name, frame)
count += 1
time.sleep(5)
最后，为 drone 类创建了一个“get_snap_shots”方法，以 jpg 格式编写标记为“No Mask”的帧的图像(截图)(在此上下文中，这些帧是默认的)。截图的能力应该是每隔 5 秒就做一次。
结论
在本教程中，您已经学习了:
无人机行业概述
- 为项目设置无人机环境
- 这是一个漫长的第一个帖子。在下一篇文章中，我们将讨论使用深度学习来构建实时面具检测模型，以与无人机结合。
It’s been a long first post. In the next post, we will talk about building the real-time facemask detection model using deep learning to be incorporated with the drone.*
为商业开发人工智能/人工智能项目-最佳实践
根据最近对 3000 名高管的调查，只有 10%的人工智能/人工智能项目产生了积极的财务影响。
鉴于这些可能性，似乎建立一个产生利润的 ML 项目需要整个组织从计划到生产的大量工作。
在这篇文章中，我将分享企业的最佳实践，以确保他们在机器学习和人工智能方面的投资实际上是有利可图的，并为整个组织创造重大价值。
识别人工智能用例的最佳实践
大多数人工智能项目在第一个障碍就失败了——对可以用人工智能解决的业务问题缺乏理解。这是 AI 成功部署的主要瓶颈。
这个问题由于人工智能的组织直觉的早期阶段，以及如何利用它来解决关键的业务问题而变得复杂。
这是什么意思？不是每个问题都可以用人工智能来解决。要了解您的特定问题是否可行，您需要经过尝试和测试的实践和方法。
如果你正在寻找建立能够交付成功结果的人工智能团队的最佳实践，请参见我以前的文章[3] 如何建立能够交付的机器学习团队。
人工智能用例
人工智能改变了工业。它自动化了常规和手动流程，并为几乎所有业务功能提供了重要的预测性见解。表 1 显示了一些使用 AI 成功解决的业务用例的列表。
| 投入 | 输出 | 应用 | 工业 |
|---|---|---|---|
表 1。人工智能解决的业务用例
理想情况下，应该与业务领导、产品经理和任何可用的主题专家一起对适当的业务问题进行头脑风暴。然后，应该审查源自整个组织的业务问题列表，并使用人工智能分析潜在的解决方案。
不是每一个商业问题都应该用 AI 来解决。通常，基于规则或工程的解决方案就足够了。此外，可以从客户评论或反馈中挖掘出许多业务问题，这些问题通常指向需要修复的中断的业务流程。
在表 2 中，您可以看到一个问题清单，包括技术和商业两个方面，以确定商业问题是否与 AI 相关。
| 数据 | |
|---|---|
结构化(表格)还是非结构化(图像、视频、文本、音频、多模态)？
|
| |
每个数据样本的大小和整个可用于训练的语料库
|
| |
金融、电子商务、客户服务、物流等。
|
| |
多久为用例生成一次数据，生成多少数据？
|
| |
标签对数据的可用性？贴标签的成本？是否有内部或外部领域专家来标记数据集？
|
| |
从最终用户到内部生态系统的数据流是怎样的，直到模型预测服务于用户？
|
| |
使用数据构建和部署 AI 模型是否有任何数据隐私、监管或合规约束？
|
| 人工智能相关性 | |
|---|---|
这是类似公司或更广泛的相关市场中的既定用例吗？
|
| | 有没有关于这个主题的重要学术研究来了解什么样的人工智能模型和方法可能是相关的？ |
| |
什么样的模型与用例相关？经典 ML，系综还是深度学习模型？
|
| |
模型是部署在云端还是移动/边缘设备上？
|
| |
用例需要实时还是批量/离线预测？
|
| |
衡量模型性能的指标有哪些？
|
| |
模型在生产中的精度、延迟和吞吐量有哪些约束？
|
| 商业 | |
|---|---|
什么是用户角色？如何最好地展现人工智能模型预测？UX 设计和实物模型，以确保易用性
|
| |
这是一个有数据可用的现有产品还是一个数据有限的新产品/功能来训练 AI 模型
|
| | 是否有定义明确的业务指标或需要重新集思广益？ |
| |
这个用例是短期投资还是长期投资？
|
| |
用例的端到端交付是否有清晰的路线图？
|
| |
可以分配多少预算来构建端到端的用例？
|
| |
用例需要哪些职能团队协作？
|
| |
涉众团队有多少带宽？
|
表 2。一份数据、模型和业务问题的清单，以验证潜在人工智能解决方案的业务问题。
kri 和指标
作为规划过程的一部分，应该讨论每个潜在用例的适当模型和业务度量。从预期的结果开始向后工作，就更容易明确要优化哪个特定的指标。
为了说明这一点，在表 3 中，我准备了一个 AI 用例以及相应的模型和业务度量的列表。对于一个人工智能项目的成功来说，确保实现业务指标和目标是非常重要的。
投入
| 输出 | 技术指标 | 商业指标 | |
|---|---|---|---|
依赖于域，例如罪犯或跟踪者等的 ID。
| 依赖于域，例如罪犯或跟踪者等的 ID。 |
| | |
收入损失、欺诈销售比率等。
| 收入损失、欺诈销售比率等。 |
| |
K 点平均精度
| K 时的平均精度 | 提高每个用户的平均收入，或增加购物车中的商品数量等。 |
| | |
提高每个用户的平均收入，或增加购物车中的商品数量等。
| 提高每个用户的平均收入，或增加购物车中的商品数量等。 |
| | | | |
| | | | |
表 3。示例人工智能用例及其技术和业务指标。
优化
我们有一系列的商业问题。在仔细考虑了表 2 中列出的标准，并分析了表 3 中列出的适当业务指标后，对它们进行了审查和记录。用例的候选列表需要根据对总体业务策略和目标的影响和相关性进行优先排序。
从描述业务用例的全面方面和潜在的基于人工智能的解决方案的详细书面文档来看，有一个客观的标准来在相同的规模上量化所有提议的用例是有用的。在这里，产品经理和业务负责人对人工智能在实践中如何工作有自己的直觉，或者依靠专注于产品的技术或领域专家的判断是至关重要的。虽然根据某些成功标准对项目进行排序很容易，但对人工智能项目的相关风险进行评级就不那么简单了。
一个平衡的度量应该考虑和权衡人工智能项目成功结果的可能性和影响，以及它失败或没有产生足够影响的风险。项目的风险可能与组织方面、人工智能问题的特定领域方面有关，或者与业务范围之外的外部因素有关。一旦定义了一个合适的平衡指标，它会将所有利益相关者和领导层联系起来，然后他们能够根据客观分数形成自己的主观观点。
在对一个特定的人工智能项目作出“是”或“否”的决定之前，需要考虑许多因素，以及在规定的时期内选择的人工智能相关项目的数量。获得领导层的认同很难。某些最终的执行决策可能看起来很主观，或者不是数据驱动的，但通过前面提到的规划过程以尽可能最好的方式呈现每个人工智能项目，并最大限度地提高人工智能项目被选中执行的可能性，仍然是绝对关键的。
规划人工智能用例的最佳实践
作为跨职能团队规划过程的一部分，组织必须有一个精简的机制来定义人工智能产品愿景或路线图、带宽、每个团队中个人贡献者和经理的具体角色和责任，以及技术方面(数据管道、建模堆栈、生产和维护的基础设施)。
在这一部分，我将描述构建一个成功的人工智能产品所必需的具体计划步骤的细节。
人工智能产品要求
对于每一个确定的用例，有必要画出路线图，说明产品如何随着时间的推移从基线版本发展到更成熟的产品。在表 4 中，我概述了为每个用例创建一个全面的 AI 路线图需要满足的一组基本问题和标准。
敬路线图
| 是否有从客户角度撰写的 FAQ 文档，解释人工智能产品如何解决特定的客户问题？ | |
|---|---|
| 是否有一个 FAQ 文档，从客户的角度来写，解释 AI 产品如何解决特定的客户问题？ | |
| 是否有一个全面的产品需求文档，详细描述了构建和交付 AI 产品的所有必要的组织成分？ | |
| 人工智能用例是由客户问题激发的吗？如果是由产品团队提出的，是否经过了客户调查的验证？ | |
| PRD 是否记录了产品开发期间在特定时间内可实现的里程碑，以评估和评价进度？ | |
| 是否所有可能使产品脱轨或延迟人工智能产品发布或开发的潜在风险因素都得到解决？ | |
| 根据表 3，业务指标和 KPI 是否定义良好？ | |
| 根据表 3，人工智能模型度量标准是否定义良好？ | |
| 对于人工智能产品的每一次阶段性发布，是否明确建立了验收标准？ |
PR-FAQ(新闻稿-常见问题)和 PRD(产品需求文档)是通常在产品构思和概念的初始阶段准备的两个关键文档。由 Amazon 首创，这两个文档充当所有相关团队的北极星，使他们与产品保持一致，并相应地构建和扩展产品。所有涉众团队对这些文档做出有意义的贡献，并分享他们特定领域的专业知识，以精心编制一份供管理层审阅的文档，这是绝对必要的。
所有涉众团队经理都有必要对文档进行评审和贡献，这样任何特定于团队或领域的产品开发的固有偏见都会暴露出来，并得到相应的解决。通常，团队应该依靠数据驱动的直觉进行产品开发。在缺乏内部数据的情况下，人工智能产品的直觉可以借鉴其他公司所做的工作或同一领域的研究[2，4]。
数据要求
由于路线图是在利益相关者会议后定义和最终确定的，因此准备好一个 MVP 或 AI 产品的基本原型来验证初始假设并提交给领导层总是有益的。这项工作也有助于简化必要的数据和工程管道，以获取、清理和处理数据，并训练模型以获得 MVP。
MVP 不应该是一个高度复杂的模型。它应该足够基本，能够成功地将输入数据转换为模型预测，并在最小的训练数据集上进行训练。如果 MVP 作为 API 托管，每个跨职能的涉众团队可以探索产品，并为如何为最终客户更好地开发 AI 产品建立直觉。
从数据的角度来看，机器学习团队可以更深入地研究最少的训练数据，并对表 5 中列出的数据进行仔细的分析。
数据检查
| |
特征是分类的、数值的、文本的？
|
| --- | --- |
| 特征是分类的、数字的还是文本的？ | |
| 每个特征的分布是怎样的？分类问题有多少个目标类？每个类的数据是否平衡？ |
离群值、缺失值和空值
|
|
数据的稳健程度如何？有多少缺失值和空值？您将如何解释这些问题并消除任何异常值？
|
特征选择/工程
|
| 所有的特征在直觉上对任务都很重要吗？您能否进行特征选择以减少冗余或高度相关的特征，或者将特征转换到低维空间，或者设计新的或复合的特征？ | |
| 每个训练样本都有标签吗？手动检查各类标签的随机样本的质量。 | |
| 现有的数据足以训练一个 MVP 吗？是否需要增加新的数据样本或创建合成数据？ | |
| 用于训练、验证和测试集的数据集是否被很好地管理和平衡以评估可推广性？ | |
| 是否有机制对原始、清理、转换、训练、验证和测试数据集的每个版本进行版本控制？ | |
| 训练模型并在生产中为其服务的最佳数据格式是什么？有没有更好的替代方案？ | |
| 在当前和未来的实验中，如何存储和访问整个数据处理和建模生命周期中的数据？ | |
| 是否建立了结构化且记录完善的数据转换管道，并牢记上述所有数据质量检查？ | |
模型要求
在系统评估了表 5 中列出的数据质量、特征、统计、标签和其他检查之后，机器学习团队可以开始构建原型/ MVP 模型。在产品开发的早期阶段，最好的方法是快速行动，而不是精确行动。初始(基线)模型应该足够简单，以证明该模型是可行的，数据和建模管道是无缺陷的，并且模型度量表明该模型的性能明显好于偶然。
多年来，机器学习用例和产品变得越来越复杂。虽然线性回归和二元或多类分类模型曾经太常见，但现在有了新的模型类别，它们训练起来更快，并且在真实世界的测试数据上概括得更好。对于 ML 科学家或工程师来说，不可能使用相同的工具和库的技术栈来构建两个用例。根据与 AI 用例相关的数据的特征(参见表 2)，数据科学团队必须定义特定于每个用例的建模堆栈(参见下面的表 6)。
人工智能模型检查
|
用例是否需要基于回归、分类、优化或推荐等的 ML 解决方案。？
| 用例需要基于回归、分类、优化或推荐等的 ML 解决方案吗？？ |
| --- | --- |
| |
传统 ML 模型能否有效解决用例？如果是，什么是合适的 ML 基线模型？
|
| |
是否有足够的(非结构化)数据来利用更复杂的神经网络和深度学习模型？
|
| |
ML/DL 模型的组合是否解决了用例的特定方面或数据的特定部分？
|
|
超参数优化
| 超参数优化 |
| 对于每一类 ML/DL 模型，需要优化的关键超参数是什么？最好的搜索方法是什么——网格搜索、随机搜索还是贝叶斯优化？ | 模型版本和格式 |
| 每个不同的模型将如何版本化和存储？部署模型的最佳模型格式是什么？ |
对于每个模型训练和超参数优化实验，实验元数据和结果将如何在团队中存储、访问和共享？
|
| | 是否有适当的框架来分析和分类模型错误、错误类型(假阳性或假阴性)以及如何用更新或更好的模型解释这些错误？ |
| |
从训练数据到模型预测、结果和可视化，是否存在端到端的 ML/DL 建模管道？
|
| |
在发布的每个阶段，模型在准确性、延迟和吞吐量方面的验收标准是什么？
|
| |
是否有清晰的管道将模型带入生产？该模型将通过 Docker 或云或笔记本服务器部署？什么样的实例最适合部署？
|
| |
是否设置了包括仪表盘、日志、指标在内的模型监控工具？
|
| | 表 6。人工智能模型列表和人工智能 MVP 的可行性检查。 |
执行人工智能用例的最佳实践
在确定和规划了有前途的人工智能用例之后，下一步就是实际执行项目。看起来执行是一个简单的过程，机器学习团队开始施展他们的魔法。但是，仅仅“构建模型”对于成功的部署是不够的。模型构建必须以协作和迭代的方式完成:
涉及产品用户以及跨职能团队的反馈，
整合来自产品团队的任何新的或修改的特性请求，
基于业务或操作环境的任何变化更新用例的初始假设，
- 然后才向用户推出产品。
- 将模型交付生产是一个值得庆祝、记录并在组织内分享的重要里程碑，但工作并未就此停止。监控模型在来自客户的真实世界数据上的表现，并定期应用修复或更新模型，使其不会随着以下方面的变化而过时，这一点至关重要:
- 数据的分布，
- 用例的性质，
客户行为，
- 等等..
- 在下一节中，我将讨论成功执行和部署 AI 模型以及实现所提议的商业价值的操作方面的最佳实践。
- 审查和反馈
- 一旦人工智能项目启动，机器学习团队就必须与利益相关者(包括产品团队和业务领导层)举行定期和临时的审查会议。在规划阶段准备的文档(PR-FAQ 和 PRD)作为任何更新或变更的背景。
定期会议的目标是评估产品路线图的进展状态，并解决以下方面的任何变化:
产品或商业策略，
组织结构，
分配给项目的资源。
- 虽然计划很重要，但大多数公司项目并不像最初计划的那样进行。重要的是要灵活敏捷，对任何新信息(关于技术、产品或业务方面)做出反应，并朝着共同的前进方向重新调整。例如，2020 年的停摆严重影响了经济。鉴于这种高影响的意外事件，适应和改变人工智能用例的策略也是至关重要的。
- 除了定期的内部反馈，在整个 AI 生命周期中与产品的最终用户保持联系也是很好的。在初始阶段(用户研究，目标用户角色及其人口统计的定义)，尤其是在产品设计和与模型预测的交互中。应该维持一个来自目标细分市场的核心用户群，以便在产品开发的所有阶段获得定期反馈。
- 一旦 MVP 准备好了，用户可以很有帮助地提供早期反馈，这通常可以揭示一些见解，并发现任何偏见或缺点。当人工智能模型准备好出货，不同的模型版本将被评估时，用户的反馈可以再次非常有见地。用户对设计、易用性、感知速度和整体用户流的洞察可以帮助产品团队根据需要完善产品策略。
迭代构建
从技术角度来看，模型构建过程通常是一个迭代过程。在建立了一个健壮的基线之后，团队可以洞察模型的性能离已建立的验收标准有多远。在模型构建的早期阶段，重点应该主要放在准确性而不是延迟上。
在模型开发的每个阶段，对验证集上的模型错误的全面分析可以揭示对模型缺点的重要见解，以及如何解决它们。还应与主题专家一起审查错误，以评估数据注释中的任何错误以及错误中的任何特定模式。
如果模型容易出现某种错误，它可能需要额外的特性。或者，可能需要将它更改为基于不同目标函数或基本原则的模型，以克服这些错误。这种重复的过程有助于机器学习团队巩固他们对用例的直觉，跳出框框思考，并提出新的创意或算法来实现预期的指标。
在建模过程中，机器学习实践者应该系统地记录每个实验和相应的结果。结构化方法不仅有助于特定的用例，也有助于建立有助于新员工的组织知识，或者作为成功的人工智能部署的光辉榜样。
部署和维护
一旦候选机器学习模型准备就绪，并在验证和测试集上进行彻底的基准测试，分析错误，并满足验收标准，该模型就可以投入生产。模型培训和部署环境之间存在巨大差异。模型的定型格式可能与将模型投入生产不兼容，需要进行适当的序列化并转换为正确的格式。
在模拟生产设置的环境中，应在保留数据集上再次验证模型准确性和延迟。部署应该通过将模型呈现给一小部分真实世界的流量或模型的输入来逐步完成，最好首先由内部或核心用户组进行测试。
一旦 MLOps 团队对部署管道进行了严格的测试和审查，就可以将更多的流量导向模型。在有一个或多个候选模型可用的情况下，应该系统地进行这些模型的 A/B 测试，并评估统计上的显著差异，以确定获胜的模型。
部署后，确保在数据生态系统中收集并适当归档所有输入输出对非常重要。应定期评估启动的模型，并将真实世界数据的分布与训练数据的分布进行比较，以评估数据和模型漂移。在这种情况下，将一些真实世界的测试样本反馈到原始训练数据集中的主动学习管道有助于减轻部署模型的缺点。
最后，一旦模型生产环境和所有管道稳定，机器学习和产品团队应该评估业务指标和 KPI，以评估指标是否满足预定义的成功标准。如果是这样，那么只有用例被认为是成功的，并且整个用例和结果的总结应该被记录并在内部与每个涉众和业务领导共享。
包扎
如果创业公司和企业中的机器学习、产品和业务团队采用系统化的方法，并遵循本文中列出的最佳实践，那么人工智能成功的可能性只会增加。
充分的前期准备至关重要。没有它，团队将无法纠正任何错误或应对变化，也无法实现人工智能可以提供的巨大商业潜力。
参考
If machine learning, product and business teams in startups and enterprises adopt a systematic approach and follow the best practices as laid out in this article, then the likelihood of successful AI outcomes can only increase.
Adequate upfront preparation is crucial. Without it, teams won’t be able to rectify any errors or respond to changes, nor realize the massive commercial potential that AI can deliver.
References
ML 中的分类:从建立和部署大规模模型中吸取的教训
分类是机器学习中应用最广泛的领域之一。作为数据科学家，我们都致力于 ML 分类模型。你还记得你解决的分类问题中有多少类吗，最多 100 或 200？当类的数量超过 10000 的时候，同样的模型架构会起作用吗？
几个现实世界的应用，包括产品识别、人脸匹配和视觉产品搜索，被公式化为一个多类分类问题。多类分类是一类问题，其中给定的数据点被分类到给定列表中的一个类中。
传统的机器学习和深度学习方法用于解决多类分类问题，但模型的复杂性随着类别数量的增加而增加。特别是在深度学习中，网络规模随着班级数量的增加而增加。因此，在某个时间点解决具有数千个类别的多类别分类问题变得不可行。在本文中，我们将讨论处理这种大规模 ML 分类模型的可行技术。
在本文中，您将了解到:
- 1 有哪些大规模 ML 分类模型的例子？
- 2 第 1 课:缓解 ML 分类算法中的数据稀疏问题
- 第 2 课:用于分类的深度度量学习
- 4 第三课:选择合适的损失函数训练大规模分类问题
- 第 4 课:测量大规模分类模型的性能
- 6 第 5 课:了解您在生产中使用分类模型将面临的常见挑战
- 第 6 课:为分类模型构建管道时要遵循的最佳实践
有哪些大规模 ML 分类模型的例子？
想象一个可视化产品搜索应用程序，给定一个产品的图片，系统需要从目录中获取最相关的产品。产品目录可能有近百万种独特的产品。为了解决产品搜索的问题，我们需要构建一个分类解决方案，其中类别的数量等于唯一产品的数量，这可能是数百万的数量级。使用传统的基于 softmax 的方法来解决这个问题是不可行的。对于这些类型的应用程序，需要构建不同的解决方案。
在处理这类问题时，记住几件事是很重要的。让我们来看看其中的一些。
第 1 课:缓解最大似然分类算法中的数据稀疏问题
用于解决多类分类问题的最流行的算法是什么？
- 1kn
- 2 决策树
- 3 随机森林
- 4 朴素贝叶斯
- 5 利用交叉熵损失的深度学习
在某种程度上，通过使用一对一或一对一策略拟合多个二元分类器，也可以利用逻辑回归和 SVM 来解决多类分类问题。
使用任何上述算法解决大规模分类问题的主要问题是，给定一个类，收集的样本数量有时可能非常有限。因此，模型可能没有足够数量的数据样本来学习每个类的模式。在大多数情况下，很难为每个类收集足够数量的样本，我们发现大多数时候，存在数据点数量相对较少的长尾类。
传统的基于 softmax 的分类方法在这里可能不能很好地工作，因为它们可能遭受这类中的数据稀疏问题。因此，这类问题需要以不同的方式解决。这些类型的问题可以通过将输入特征投影到高维向量空间中，然后在嵌入空间中执行 k 最近邻(kNN)搜索来解决，而不是针对交叉熵损失进行优化。 这种方法叫做度量学习。一些团体也称这个领域为极端分类。 零镜头或少镜头学习可能是另一种解决方法，因为这种方法允许模型学习，即使当观察样本的数量只有一个或几个时。
第 2 课:用于分类的深度度量学习
度量学习是一个研究领域，旨在使用监督或弱监督数据构建特定于任务的距离度量。度量学习方法通常使用线性投影，但深度度量学习利用深度学习架构来捕捉复杂的非线性转换。
度量学习问题主要分为两类，一类是受监督的，其中数据点具有作为目标的类别标签(与标准分类问题中相同)，另一类是弱监督的，其中数据点处于元组级别(成对、三元组或四元组)。在弱监督的情况下，目标是学习最小化正对之间的距离和最大化负对之间的距离的距离度量。这种方法也可以用来解决非分类问题。
由于这种方法对距离度量起作用，这些网络的成功取决于这些网络对样本之间相似关系的理解。然而，数据准备、数据采样策略、适当距离度量的选择、适当损失函数的选择以及网络的结构也决定了这些模型的性能。
Metric learning architecture | Source: Author
第 3 课:选择适当的损失函数来训练大规模分类问题
在本节中，您将学习一组损失函数，可用于训练大规模分类模型。正确的损失函数的选择对算法的成功起着关键的作用。
对比损失
对比损失考虑一对相似(称为正)和不相似(称为负)的样本，并通过对比这些样本对来区分它们。丢失的目的是以某种方式学习距离，使得正对的距离小于负对的距离。
在这个等式中:
- 当输入样本是相似对时，Y 为 0，当输入样本是不相似对时，Y 为 1。
- m 是余量。
- Dw 是距离函数。
下面是一个如何定义对比损失函数的示例:
三重损失
def contrastive_loss(output1, output2, target, margin):
distances = tf.reduce_sum(tf.pow(output1 - output2, 2), keepdims=True)
losses = (1 - target) * 0.5 * tf.pow(distances,2) + target * 0.5 * tf.pow(tf.math.maximum(0, margin - distances), 2)
return tf.reduce_mean(losses)
三联体损失对一组三联体起作用，其中每个三联体都有一个锚、正样本和负样本。它遵循与对比损失相同的基本原理，即最小化锚和正之间的距离，最大化锚和负之间的距离。
三重态损失的损失函数如下:
L(a，p，n) = max(0，D(a，p) — D(a，n) + margin)
其中 D(x，y):x 和 y 的学习向量表示之间的距离。作为距离度量，可以使用 L2 距离。该功能的目的是保持锚点和正极之间的距离小于锚点和负极之间的距离。
普通的 softmax 不是一个可行的选择
def triplet_loss(anchor, positive, negative, margin):
distance1 = tf.sqrt(tf.reduce_sum(tf.pow(anchor - positive, 2), 1, keepdims=True))
distance2 = tf.sqrt(tf.reduce_sum(tf.pow(anchor - negative, 2), 1, keepdims=True))
return tf.reduce_mean(tf.maximum(distance1 - distance2 + margin, 0))
当类的数量超过 100，000 或 100，000 时，我们需要超越普通的 Softmax。由于对大量类别求和，损失的计算变得昂贵。因此，这也导致了推理时间的增加。因此，不使用普通的 Softmax，而是使用分级 softmax 或噪声对比损失。
采样硬底片有助于学习更精确的特征
如前所述，在构建这些模型时，数据采样策略是成功的关键。如果我们使用三元组损失，数据集是一组三元组。每个数据样本都有三个一组的锚、阳性和阴性，其中锚和阳性是相似的对，锚和阴性是不相似的对。
在学习过程中，模型学习一个投影，其中正片比负片更靠近锚点。如果我们有简单的底片，那么模型就很容易学会投影。因此，有时对推动模型学习更多具体特征的硬负面进行采样是很重要的。
作为一个例子，关于产品识别系统，对于模型来说，学习关于一对苹果作为正面的模式和一对苹果和菠萝作为负面的模式相对更容易。但是当我们把一个芒果而不是一个菠萝当作阴性的时候，这个模型会学习到更精确的特征，因为芒果的形状和苹果更相似。因此，在数据准备期间，我们需要找出一种方法来识别容易否定、软否定和硬否定，并根据要求，从这些类别中选择一个样本。
第 4 课:衡量大规模分类模型的性能
Soft and hard negatives | Source: Author
为了评估分类模型，通常使用准确度、精确度、召回率和 f1 分数，其中度量是在单个数据样本上计算的，最后，求和以计算整体度量。所有这些上面的度量都是 0-1 度量，其中如果顶部预测的类别是相关的，则推断被认为是正确的预测。
对于产品识别系统，目标是在给定产品图像作为输入的情况下，识别商品的 SKU(库存单位)。举个例子，比方说有三种口味(覆盆子、巧克力和开心果)的 cornetto 冰淇淋。现在，预测一个“树莓 cornetto 冰淇淋”为“巧克力 cornetto 冰淇淋”将是一个比识别它为“玫瑰花瓶”成本更低的错误分类。
即使前一个预测不是最相关的，我们也有兴趣查看前 k 个中的相关预测。因此，我们不仅对前 1 个预测感兴趣，还对前 k 个中的任何类是否相关感兴趣。这就是为什么 Precision@k 和 recall@k 和 Precision @ k 一起，也是评价大规模分类系统的重要指标。
我们还可以利用可视化的力量来评估模型。一组类有时形成一个组/簇。因此，我们可以将高维向量空间划分为较低的维度，并在聚类级别评估完整性。
Ranking of products by two algorithms | Source: Author
第 5 课:了解您在生产中使用分类模型时将面临的常见挑战
Projection of products in high dimensional vector space | Source: Author
到目前为止，我们已经讨论了通过选择适当的采样策略、算法和损失函数以及选择正确的评估指标来构建模型的方法。在这一节中，让我们来讨论您在生产中可能会遇到的问题。
在传统的分类模型中，我们将输入的特征向量通过假设函数，在 O(1)时间内得到推理。但在这种情况下，我们处理问题的方式不同。我们打算学习输入特征向量的向量表示，然后在高维向量空间中执行 k 最近邻搜索。
k-最近邻搜索有时在计算时间方面具有挑战性，因为我们需要计算每个代表性样本的距离(每个类别需要一个或多个代表性样本)。因此，运行时间可能会更长。
由于与所有代表性样本的距离的计算不是微不足道的，我们遵循近似最近邻(ANN)搜索算法，该算法在 O(log N)时间内找到最相似的代表性样本。
近似最近邻(ANN)搜索算法可以主要分为三类。
Approximate Nearest Neighbour (ANN) search algorithms can be majorly categorised into 3 buckets.
1 基于哈希
- 2 基于树
- 3 基于图形
- 在下一节中，我们将简要讨论一些流行的人工神经网络算法。
HNSW
分层可导航小世界( HNSW )图是向量相似性搜索的首选之一。HNSW 是一种基于图的鲁棒算法，用于近似最近邻搜索。它构建了一个邻近图，其中两个邻近的顶点被链接。邻近图是建立在两个基础上的:概率跳表和可导航小世界(NSW)。
在概率跳过列表的情况下，HNSW 构建一个分层图，其中最高层具有较长的边，使得能够快速搜索，而较低层具有较短的边，使得能够精确搜索。
- 对于可导航小世界(NSW)图，其思想是建立一个具有短程和远程链接的邻近图，从而将搜索时间减少到多边形或对数复杂度。在搜索可导航的小世界图时，我们从预定义的源开始，通过识别最接近查询向量的顶点来遍历图。
HNSW 是构建最近邻搜索图的最直接的方法之一，但就内存利用而言，它是最好的索引方案。但是像乘积量化(PQ) 这样的技术可以通过压缩向量来提高内存利用率。
费斯
脸书人工智能相似性搜索(FAISS)是一个高效的相似性搜索库，实现了几种与向量相似性搜索相关的算法，包括(但不限于)产品量化、分层可导航小世界(HNSW)、加法量化、倒排索引搜索等。主干是用 C 语言实现的，它针对内存利用和速度进行了优化。
以下是使用 HNSW 算法的 FAISS 的代码片段。
查看此以了解更多信息。
import faiss
d = 128
M = 32
index = faiss.IndexHNSWFlat(d, M)
index.hnsw.efConstruction = 40
index.hnsw.efSearch = 16
index.add(xb)
D, I = index.search(xq, k)
Source: https://github.com/facebookresearch/faiss
扫描
可扩展最近邻(ScaNN)是针对大规模问题的向量相似性搜索的另一种实现。该实现包括用于最大内积搜索的搜索空间修剪和量化。这个库声称在搜索速度方面性能最好。
下面是使用 ScaNN 构建和搜索的代码片段。
import scann
normalized_dataset = dataset / np.linalg.norm(dataset, axis=1)[:, np.newaxis]
searcher = scann.scann_ops_pybind.builder(normalized_dataset, 10, "dot_product").tree(
num_leaves=2000, num_leaves_to_search=100, training_sample_size=250000).score_ah(
2, anisotropic_quantization_threshold=0.2).reorder(100).build()
neighbors, distances = searcher.search_batched(queries, leaves_to_search=150, pre_reorder_num_neighbors=250)
请参考本了解更多相关信息。
到目前为止，我们已经看到了多种提高推理周转时间的技术，但是所有这些技术都受到物理内存容量的限制。实际上，推理服务器的内存是有限的。因此，我们只能索引内存中的一些向量。因此，运行时间可能会随着类的数量成比例地增加，而传统的基于 softmax 的分类方法并非如此。当我们观察度量学习方法的端到端流程时，我们会发现可以优化多个领域来提高运行时间。
近似最近邻搜索中的优化
- 最近邻搜索的运行时间主要取决于搜索空间的大小。人们可能会想到更聪明的方法来制定问题，以减少搜索空间。由于我们正在处理大量的类，一组相似的类可能会形成一个集群。我们可以使用额外的信息来制定类的类型。因此，在推断过程中，首先，我们确定样本所属的聚类，然后在该聚类的空间上运行最近邻搜索。类似 HNSW 的人工神经网络搜索算法试图通过利用向量空间来实现类似的基本原理。
模型架构的优化
- 模型架构运行时的优化取决于模型的性质。我想提一下一些优化技术，它们不仅适用于大规模分类，也适用于任何深度学习模型，通常如下:
如果是 PyTorch 模型，使用 ONNX 运行时服务。
- 在 triton 推理服务器中部署模型。
- 使用多批次输入的水平缩放。
- 第 6 课:为分类模型构建管道时要遵循的最佳实践
版本化和构建自动化培训管道对于使用度量学习方法构建的模型来说是必不可少的。每当类发生变化时，就需要重新训练模型，并用新的变化刷新嵌入的索引。
这就是像 neptune.ai 这样的 MLOps 工具非常有用的地方。使用 neptune.ai ，你将能够执行模型及其工件的版本控制。Neptune 还允许您通过可定制的 UI 轻松管理 ML 元数据，进行搜索和比较等操作。它能够轻松与各种数据科学工具集成。
虽然 neptune.ai 帮助您无缝地跟踪和版本化模型工件，但是您可能还希望利用工作流和编排工具，如 Kubeflow 和 Apache Airflow，来构建和自动化索引管道。
最后的想法
本文讨论了在构建大规模分类模型时所面临的困难。我们已经看到了大规模分类系统与传统的基于 softmax 的分类器的不同之处。近似最近邻搜索是构建端到端系统的关键，近似最近邻搜索算法的选择是算法成功的驱动因素。深度学习的流行及其生成丰富表示的能力使这个主题成为一个活跃的研究领域，我们希望看到研究社区在这个领域的更多工作。
参考
References
构建基于深度学习的 OCR 模型:经验教训
原文：https://web.archive.org/web/https://neptune.ai/blog/building-deep-learning-based-ocr-model
深度学习解决方案席卷了整个世界，各种组织，如科技巨头、成熟的公司和初创公司，现在都在试图以某种方式将深度学习(DL)和机器学习(ML)融入他们当前的工作流程。在过去的几年中，OCR 引擎是非常受欢迎的重要解决方案之一。
OCR(光学字符识别)是一种直接从数字文档和扫描文档中读取文本信息的技术，无需任何人工干预。这些文档可以是任何格式，如 PDF、PNG、JPEG、TIFF 等。使用 OCR 系统有很多优点，它们是:
- 由于处理(提取信息)文档所需的时间更少，因此提高了工作效率。
- 它节省了资源，因为你只需要一个 OCR 程序来完成这项工作，不需要任何手工操作。
- 3 它消除了手动数据输入的需要。
- 出错的机会变少了。
从数字文档中提取信息仍然很容易，因为它们有元数据，可以给你文本信息。但是对于扫描副本，您需要一个不同的解决方案，因为元数据在这方面没有帮助。深度学习的需求来了，它为从图像中提取文本信息提供了解决方案。
在本文中，您将了解构建基于深度学习的 OCR 模型的不同课程，以便当您处理任何此类用例时，您可能不会遇到我在开发和部署期间遇到的问题。
什么是基于深度学习的 OCR？
OCR 现在已经变得非常流行，并且已经被几个行业采用，用于从图像中更快地读取文本数据。而像轮廓检测、图像分类、连通分量分析等解决方案。用于具有可比文本大小和字体、理想照明条件、良好图像质量等的文档。这种方法对于不规则的、不同种类的文本是无效的，这些文本通常被称为野生文本或场景文本。该文本可能来自汽车牌照、门牌号、扫描不良的文档(没有预定义的条件)等。为此，使用深度学习解决方案。使用 DL 进行 OCR 需要三个步骤，这些步骤是:
-
预处理: OCR 不是一个容易的问题，至少没有我们想象的那么容易。从数字图像/文档中提取文本数据还是可以的。但是当涉及到扫描或手机点击图像时，事情就变了。现实世界的图像并不总是在理想的条件下被点击/扫描，它们可能有噪声、模糊、倾斜等。这需要在将 DL 模型应用于它们之前进行处理。为此，需要图像预处理来解决这些问题。
-
文字检测/定位:现阶段的型号有 Mask-RCNN 、东方文字检测器、 YoloV5 、 SSD 等。用于定位图像中的文本。这些模型通常在图像或文档中识别的每个文本上创建边界框(正方形/矩形框)。
-
文本识别:一旦文本位置被识别，每个边界框被发送到文本识别模型，该模型通常是 RNNs 、CNN和注意力网络的组合。这些模型的最终输出是从文档中提取的文本。一些开源的文本识别模型，如 Tesseract 、 MMOCR 等。可以帮助你获得良好的准确性。
Deep learning based OCR model | Source: Author
为了解释 OCR 模型的有效性，让我们看一下现在应用 OCR 来提高系统的生产率和效率的几个部分:
-
银行业的 OCR:自动化客户验证、支票存款等。使用基于 OCR 的文本提取和验证的过程。
-
保险领域的 OCR:从保险领域的各种文档中提取文本信息。
-
医疗保健中的 OCR:处理诸如病历、x 光报告、诊断报告等文档。可能是一项艰巨的任务，但 OCR 可以让您轻松完成。
这些只是应用 OCR 的几个例子，要了解更多关于它的用例，你可以参考下面的链接。
构建基于深度学习的 OCR 模型的经验教训
既然您已经了解了什么是 OCR，以及是什么使它成为当前时代的一个重要概念，那么是时候讨论一下您在使用它时可能会面临的一些挑战了。我参与了几个与金融(保险)部门相关的基于 OCR 的项目。仅举几个例子:
- 我曾参与过一个【KYC】验证 OCR 项目，需要从不同的身份证明文件中提取信息并相互验证，以验证客户档案。
- 我还做过保险文档 OCR，需要从不同的文档中提取信息并用于其他目的，如创建用户档案、用户验证等。
我在研究这些 OCR 用例时学到的一件事是，你不必每次都失败来学习不同的东西。你也可以从别人的错误中学习。当我在团队中为这些基于 DL 的财务 OCR 项目工作时，有几个阶段面临挑战。让我们以 ML 管道开发不同阶段的形式来讨论这些挑战。
数据收集
问题
这是处理任何 ML 或 DL 用例的第一个也是最重要的阶段。大多数 OCR 解决方案被金融机构采用，如银行、保险公司、经纪公司等。因为这些组织有大量难以手动处理的文档。因为它们是金融机构，所以这些金融机构必须遵守政府的规章制度。
因此，如果您正在为这些金融公司进行任何 POC(概念验证)工作，他们可能不会为您共享大量数据来训练您的文本检测和识别模型。由于深度学习解决方案都是关于数据的，所以你可能会得到性能很差的模型。这当然与法规遵从性有关，如果他们共享数据，他们可能会侵犯用户的隐私，从而导致客户的财务和其他类型的损失。
解决办法
这个问题有什么解决办法吗？是的，它已经。假设您想要处理某种表单或 ID 卡来提取文本。对于表单，您可以向客户索要空模板，并用您的随机数据填充它们(耗时但有效);对于 id 卡，您可以在互联网上找到许多样本，您可以使用它们开始制作。此外，您可以只需要这些表格和身份证的一些样本，并使用图像增强技术为您的模型训练创建新的类似图像。
*Image augmentation for OCR | Source *
有时，当您想要开始处理 OCR 用例并且没有任何组织数据时，您可以使用在线(开源)的 OCR 数据集之一。你可以在这里查看 OCR 的最佳数据集列表。
标注数据(数据注释)
问题
现在，您已经有了数据，并且使用图像增强技术创建了新的样本，列表上的下一件事是数据标注。数据标注是在您希望对象检测模型在图像中找到的对象上创建边界框的过程。在这种情况下，我们的对象是文本，所以您需要在您希望模型识别的文本区域上创建边界框。创建这些标签是一项非常繁琐但重要的任务。这是你无法摆脱的。
此外，当我们谈论注释时，边界框过于笼统，对于不同类型的用例，使用不同类型的注释。例如，在你想要一个对象的最精确的坐标的情况下，你不能使用正方形或矩形的边界框，你需要使用多项式(多线)的边界框。对于想要将图像分成不同部分的语义分割用例，您需要为图像中的每个像素分配一个标签。要了解更多不同类型的注释，您可以参考此链接。
解决办法
有什么方法可以加快你作品的标签制作过程？是的，有。通常，如果你使用图像增强技术，如添加噪声，模糊，亮度，对比度等。图像几何形状没有变化，因此您可以将原始图像的坐标用于这些增强图像。此外，如果您要旋转图像，请确保将它们旋转多个 90 度，这样您也可以将注释(标签)旋转到相同的角度，这将节省您大量的返工。对于这项任务，您可以使用 VGG 或 VoTT 图像注释工具。
有时，当你有很多数据要注释时，你甚至可以外包，有很多公司提供注释解决方案。您只需要简单地解释您想要的注释类型，注释团队就会为您完成。
模型架构和培训基础设施
问题
您必须确保的一件事是用于训练模型的硬件组件。训练对象检测模型需要相当大的 RAM 容量和 GPU 单元(其中一些也可以与 CPU 一起工作，但训练会非常慢)。
另一部分是这些年来在计算机视觉领域已经引入了不同的对象检测模型。选择一个最适合您的用例(文本检测和识别)并且在您的 GPU/CPU 机器上运行良好的方法可能很困难。
解决办法
对于第一部分，如果你有一个基于 GPU 的系统，那么没有必要担心，因为你可以很容易地训练你的模型。但是，如果您使用的是 CPU，一次性训练整个模型会花费很多时间。在这种情况下，迁移学习可能是一条可行之路，因为它不涉及从零开始训练模型。
每个新引入的计算机视觉模型要么具有全新的架构，要么提高现有模型的性能。对于较小且密集的对象，如文本， YoloV5 因其架构优势而优先用于文本检测。
如果您想将一幅图像分割成多个部分(按像素)，最好考虑使用 Masked-RCNN 。对于文本识别，一些广泛使用的模型有 MMOCR 、 PaddleOCR 和 CRNN 。
培养
问题
这是一个非常关键的阶段，在这里你将训练你的基于 DL 的文本检测和识别模型。我们都知道的一件事是，训练深度学习模型是一个黑盒事情，你可以尝试不同的参数，以获得针对你的用例的最佳结果，而不知道下面发生了什么。你可能需要尝试不同的深度学习模型来进行文本检测和识别，这对于所有那些你需要在训练中注意的超参数来说是相当困难的。
解决办法
我在这里学到的一件事是，你必须专注于一个单一的模型，直到你尝试了所有的东西，比如超参数调整，模型架构调整等等。你不需要仅仅通过尝试一些东西来判断一个模型的性能。
此外，我会建议您分部分训练您的模型，例如，如果您想将您的模型训练到 50 个时期，请将其分为三个不同的步骤 15 个时期、15 个时期和 20 个时期，并在中间对其进行评估。通过这种方式，您将在不同的阶段获得结果，并了解模型的表现是好是坏。这比几天内一次尝试所有 50 个时期，最后发现模型对您的数据根本不起作用要好。
同样，正如上面已经讨论过的，迁移学习可能是关键。您可以从头开始训练您的模型，但使用已经训练好的模型并根据您的数据对其进行微调肯定会给您带来良好的准确性。
测试
问题
一旦你的模型准备好了，下一件事就是测试模型的性能。测试深度学习模型非常容易，因为你可以看到结果(在对象上创建的边界框)或将提取的文本与地面真实数据进行比较，不像传统的机器学习用例那样需要从数字中解释结果。
如今，你可以使用手工 DL 模型测试，或者尝试一种可用的自动化测试服务。手动过程需要一些时间，因为您必须自己检查每一张图像来判断模型的性能。如果您正在处理财务用例，那么您可能只能进行手工测试，因为您不能与在线自动化测试服务共享数据。
解决办法
我在这里给出的一个主要建议是，永远不要在训练数据集上测试你的模型，因为这不会显示你的模型的真实性能。您需要创建三个不同的数据集训练、验证和测试。首先，两个将用于训练和运行时模型评估，而测试数据集将向您展示模型的真实性能。
下一件事是决定评估检测和识别模型性能的最佳指标。因为文本检测是一种对象检测，所以使用 mAP(平均精度)来评估模型的性能。它将模型预测边界框与地面真实边界框进行比较，并返回分数，分数越高，性能越好。
对于文本识别模型，广泛使用的度量是 CER(字符错误率)。对于该测量，将每个预测特征与地面真实值进行比较，以告知模型性能，CER 越低，模型性能越好。您需要您的模型有少于 10%的 CER，以便用手动过程替换它。想了解更多 CER 以及如何计算，可以查看下面的链接。
部署和监控
问题
一旦你有了足够精确的最终模型，你就必须把它们部署到某个地方，让目标受众能够接触到它们。无论在哪里部署，这都是您可能会面临一些问题的主要步骤之一。我在部署这些模型时面临的三个重要挑战是:
- 我使用了 PyTorch 库来实现对象检测模型，如果你在训练的时候没有把它训练成多线程，这个库不允许你在推断的时候使用多线程。
- 模型大小可能太大，因为它是基于 DL 的模型，并且在推断时可能需要更长的时间来加载。
- 部署模型是不够的，您需要对它进行几个月的监控，以了解它是否如预期的那样执行，或者它是否有进一步改进的空间。
解决办法
因此，为了解决第一个问题，我建议您必须意识到，您必须使用 Pytorch 和多线程来训练模型，以便您可以在推理时使用它，或者另一个解决方案是切换到另一个框架，即寻找您想要的 torch 模型的 TensorFlow 替代方案，因为它已经支持多线程，并且非常容易使用。
对于第二点，如果您有一个非常大的模型，需要花费大量时间来加载进行推理，您可以将您的模型转换为 ONNX 模型，它可以通过⅓减少模型的大小，但对您的准确性有轻微的影响。
模型监控可以手动完成，但需要一些工程资源来查找 OCR 模型失败的情况。相反，你可以使用不同的自动监控解决方案，如 Neptune 、 Arize 、 WhyLabs 等。
Tracking KPIs with Neptune | Source
你可以在这篇文章中了解更多:做 ML 模型监控的最佳工具。
结论
读完这篇文章后，您现在知道什么是基于深度学习的 OCR，它的各种用例，并最终看到了一些基于我在处理 OCR 用例时看到的场景的经验教训。OCR 技术现在正在取代手工数据输入和文档处理工作，这可能是一个实践它的好时机，这样你就不会感到被排除在数字图书馆的世界之外。当处理这些类型的用例时，你必须记住你不可能一次就有一个好的模型。你需要尝试不同的事情，从你要做的每一步中学习。
从头开始创建解决方案可能不是一个好的解决方案，因为在处理不同的用例时，您不会有大量的数据，所以尝试迁移学习和微调不同的数据模型可以帮助您实现良好的准确性。这篇文章的目的是告诉您我在处理 OCR 用例时遇到的不同问题，这样您就不必在工作中面对它们。尽管如此，随着技术和库的变化，可能会出现一些新的问题，但是您必须寻找不同的解决方案来完成工作。
构建机器学习聊天机器人:选择正确的平台和应用
作为从事机器学习的人，你可能被要求为一个企业开发一个聊天机器人，或者你以前遇到过一个聊天机器人项目。
当我开始我的 ML 之旅时，一个朋友让我为她的生意做一个聊天机器人。许多失败的尝试之后，有人告诉我用聊天机器人建筑服务检查 ML 平台。从那里除了幸福什么都没有。
如今，企业希望扩大运营规模，聊天机器人不受时间和地理位置的限制，因此它们是实现规模化的良好工具。不仅仅是企业——我目前正在为一个政府机构开发一个聊天机器人项目。
但是让我们暂时回到基础——聊天机器人到底是什么？
在本文中，我们将主要关注机器学习聊天机器人。
什么是机器学习聊天机器人？
聊天机器人(对话式人工智能)是一种通过文本消息、语音聊天或两者兼有来模拟人类对话的自动化程序。它基于大量的输入和自然语言处理(NLP) 来学习这样做。
出于语义的考虑，聊天机器人和对话助手在本文中可以互换使用，它们的意思差不多。
你为什么需要聊天机器人？
为什么您的组织需要聊天机器人？
在甲骨文的一项调查中，80%的企业回答说他们使用聊天机器人，48%的企业已经在使用自动化技术。根据 Grand View Research 的报告，到 2025 年，全球聊天机器人市场预计将达到 12.3 亿美元，年复合增长率为 24.3%。聊天机器人是用来做什么的？
聊天机器人非常适合缩放操作，因为它们没有人类的限制。世界可能会被时区所分割，但聊天机器人可以随时随地吸引客户。在性能方面，如果有足够的计算能力，聊天机器人可以同时服务于大量的客户群。
聊天机器人在自动化特定任务方面非常有效。一旦它们被设定去做一个特定的任务，它们就能轻松完成。例如，一些客户问题被反复询问，并且有相同的、特定的答案。在这种情况下，使用聊天机器人来自动回答这些特定的问题将是简单而有用的。
让用户访问一个网站或一个应用程序并不是主要的挑战——重要的是让他们参与到网站或应用程序中。聊天机器人问候可以通过吸引用户来阻止他们离开你的网站。简短的聊天邀请让您能够主动与用户交流。
- 社交媒体整合
聊天机器人可以与脸书、Telegram、微信等社交媒体平台集成，无论你在哪里交流。它们还可以与网站和移动应用程序集成。集成聊天机器人有助于用户获得快速的问题回复，以及 24/7 小时的帮助，这可能会导致更高的销售额。
当与用户交互时，聊天机器人可以存储数据，这些数据可以被分析并用于改善客户体验。
- 能说多种语言
除了能够进行有意义的对话，聊天机器人还可以理解其他语言的用户查询，而不仅仅是英语。随着自然语言处理(NLP)和神经机器翻译(NMT)的进步，聊天机器人可以用用户的语言即时回复。
- 联系年轻客户
统计数据显示，千禧一代更喜欢通过社交媒体和实时聊天联系品牌，而不是通过电话。他们精通技术，购买力很强。满足他们的需求就好，有一个扎实的聊天机器人。
聊天机器人可以帮助的行业
如果你的公司需要全球扩张，你需要能够用不同的语言全天候回应客户。聊天机器人能有效地做到这一点。
随着在线商店的数量与日俱增，电子商务品牌面临着建立庞大的客户群、赢得客户信任并留住他们的挑战。为了成功完成这些任务，品牌需要全天候的客户协助，协助在线购买，管理支付，并向客户提供最新的折扣，建立信任和社交参与。
对于人类来说，做所有这些事情可能很麻烦，但由于聊天机器人没有人类的疲劳，它们可以做到这一点，甚至更多。
研究表明，医疗从业者将六分之一的工作时间花在行政工作上。医疗保健中的聊天机器人对于医疗保健专业人员来说是一个明显的游戏规则改变者。它通过逐渐减少医院就诊、不必要的药物和咨询次数来减少工作量，尤其是在医疗保健行业压力重重的现在。
对于患者来说，它减少了去医生办公室的通勤时间，提供了一个按钮就可以轻松访问医生的机会，等等。此外，聊天机器人有助于节省医疗保健服务的成本。专家估计，到 2022 年，全球医疗保健聊天机器人的成本节约将达到 36 亿美元。
通过聊天机器人，旅行社可以帮助客户预订航班，支付这些航班的费用，并推荐度假和旅游的有趣地点——节省了人类顾问在更重要问题上的时间。
银行和金融随着技术趋势不断发展，行业内的聊天机器人不可避免。通过聊天机器人，公司可以做出数据驱动的决策——促进销售和营销，识别趋势，并根据机器人的数据组织产品发布。
一些银行提供聊天机器人来帮助客户进行交易、投诉和回答问题。合规性和安全性是在金融领域采用新技术的主要障碍，但使用聊天机器人，您可以构建安全协议，如双因素身份认证、令牌集成、防火墙、24/7 监控、保护用户数据的加密后端等。
- 食品服务和杂货店
服务员有时会弄错食物订单。但大多数食品品牌和杂货店都在网上为客户服务，尤其是在这个后 covid 时期，所以几乎不可能依靠人工代理来服务这些客户。在这里使用聊天机器人已经成为必要。他们在正确收集客户订单并交付订单方面效率很高。此外，通过分析客户的查询，食品品牌可以更好地根据他们的市场。由于聊天机器人 24/7 全天候工作，它们随时可用，并能快速响应客户。
几乎每个行业都可以使用聊天机器人进行通信和自动化。一般来说，聊天机器人增加了组织在全球舞台上高效运营所需的灵活性和可伸缩性。
好吧，我们想造一个机器学习聊天机器人。首先，我们需要一个聊天机器人平台。
什么是聊天机器人平台？
聊天机器人平台是一种服务，开发者、数据科学家和机器学习工程师可以在其中创建和维护聊天机器人。他们提供机器学习功能，比如 NLP。它们还能让你将聊天机器人整合到社交媒体平台上，比如 Facebook Messenger。
我将总结不同的聊天机器人平台，并在每个部分添加链接，在那里您可以了解更多您感兴趣的任何平台。
由 Google Cloud 支持的 Dialogflow 简化了创建和设计接受语音和文本数据的 NLP 聊天机器人的过程。很容易与社交媒体平台整合。
Chatbot 开发通过 Dialogflow 控制台进行，使用起来很简单。在控制台中开发之前，您需要理解 Dialogflow 中使用的关键术语——代理、意图、实体等。
例如，意图是由开发人员定义的任务(通常是对话)。用户可以调用它。开发者用它来定义用户可能提出的问题，并纠正聊天机器人的反应。
实体是 Dialogflow 中用于回答用户请求或查询的属性。它通常是请求中的一个关键词——姓名、日期、地点。它们是在控制台内部定义的，因此当用户说话或键入请求时，Dialogflow 会查找实体，并且实体的值可以在请求中使用。
Dialogflow 有一组预定义的系统实体，您可以在构建意图时使用。如果这些还不够，您还可以定义您自己的实体在您的意图中使用。
继续，当您在 Dialogflow 中使用更多集成选项时， Fulfillment 提供了更动态的响应。实现是针对意图而启用的，启用后，Dialogflow 将通过调用您定义的服务来响应该意图。例如，如果用户想预订周四的航班，包括航班信息，聊天机器人将在航班数据库中运行，并将周四的航班信息返回给用户。
Context 可以通过设置输入和输出上下文来配置意图，输入和输出上下文由字符串名称标识。
等等，要理解所有这些概念，最好参考 Dialogflow 文档。
Dialogflow 的一个好处是它抽象出了构建 NLP 应用程序的复杂性。此外，它还提供了一个控制台，开发人员可以在这里可视化地创建、设计和训练一个由人工智能驱动的聊天机器人。在控制台上，有一个模拟器，您可以在其中测试和培训代理。
Dialogflow (Source: screenshot)
Dialogflow 提供了两种不同的虚拟代理服务，每种服务都有自己的代理类型、用户界面、API、客户端库和文档:
- Dialogflow ES:标准代理类型，最适合构建简单的聊天机器人。该代理服务的价格分为免费试用版和基础版。您可以通过对话流 ES 基础文档了解更多关于 ES 的信息。
- Dialogflow CX:高级代理服务，适用于大型或非常复杂的代理。它包括流，页面是对话设计的构建模块，状态处理程序用于控制对话路径。新开发人员可以获得 600 美元的免费积分来使用 Dialogflow CX，这将在第一次试用时自动激活，并在 12 个月后过期。要了解关于这种代理类型的更多信息，请查看 Dialogflow CX 基础文档。
像 Dominos、Shelf、Vonder 和 SnapEngage 这样的公司都使用 Dialogflow。
Dialogflow service types (Source: screenshot)
Dialogflow 可以与 GCP 和 AutoML 集成，以提高训练和 NLP 的准确性。
Amazon Lex 用于在任何使用语音和文本的应用程序中构建聊天机器人界面。Amazon Lex 使用自动语音识别(ASR)将语音转换为文本，并使用自然语言理解(NLU)来识别文本意图。有先进的深度学习功能，用于构建具有高度吸引人的用户体验和逼真的对话交互的应用程序。
它使用支持亚马逊 Alexa 的深度学习技术，使您能够快速轻松地构建复杂的自然语言对话机器人。
像 Dialogflow 一样，Lex 也有自己的一套术语，比如 intents、slots、fulfilments 等等。
- 意图:用户在与聊天机器人交互时将执行/进行的动作或对话。
- Slot:Amazon Lex 中的 slot 是一个参数，用于理解并正确满足用户请求。
- Slot type:这个 Slot type 是 Amazon Lex 用来训练机器学习模型识别 slot 值的值列表。例如，您可以定义一个名为“流派”的槽类型槽类型中的每个值是流派的名称，“喜剧”、“冒险”、“纪录片”等。您还可以为插槽类型值定义同义词。例如，您可以为值“喜剧”定义同义词“滑稽”和“幽默”每个插槽类型最多有 10，000 个值和同义词。一个 bot 总共可以有 50，000 个槽类型值和同义词。Amazon Lex 还提供了内置的插槽类型。
亚马逊 Lex 第一年免费。从您开始使用 Amazon Lex 之日起，您每月可以处理多达 10，000 个文本请求和 5，000 个语音请求或语音间隔。
Source: Amazon Lex pricing
Lex 具有内置支持，可以将机器人与脸书、Kik、Slack 等平台集成。要将您的机器人与您的网站或移动应用程序集成，您有两种方法:
- 使用 AWS SDK:AWS SDK 提供了向机器人发送查询的 API。这需要一定程度的编程知识。
- 使用komunicate:komunicate 是一个人-混合客户支持软件，它提供了与 Amazon Lex 的无代码集成，以及丰富的聊天界面。
亚马逊 Lex 的客户包括 TransUnion，GE Appliances， Citbot ， John Creek 等。
Azure Bot Services 是一个用于 Bot 开发的集成环境。它使用 Bot Framework Composer ，这是一个开源的可视化编辑画布，用于使用模板开发对话流，并使用工具为特定用例定制对话。
它集成了自然语言理解服务，如 LUIS 和 QnA Maker ，并允许机器人使用自适应语言生成进行回复。Composer 在桌面和基于 web 的组件上都可用。它还提供对自适应对话框和语言生成的访问。
自适应对话框:这是一个灵活的对话框模型，允许开发人员基于上下文动态更新保护流程。它使得计划语义的中断、取消和执行变得更加容易。在自适应对话文档中了解更多信息。
语言理解(LU): LU 是 Composer 中的核心组件，它允许开发人员和对话设计人员在编辑对话的上下文中直接训练语言理解。当在 Composer 中编辑对话框时，开发人员可以不断地增加他们的机器人的自然语言能力。要了解更多关于 Composer 中的语言生成，请查看语言生成文档。
Source: Azure bot framework documentation
简而言之，Composer 在语言生成(LG)中使用自适应对话框来简化中断处理并赋予机器人特性。
Composer 中的可视化设计界面消除了对样板代码的需要，并使 bot 开发更容易。您不再需要在体验之间导航来维护 LU 模型，它在应用程序中是可编辑的。设置环境的步骤更少，从而节省了时间。
Composer 提供了构建复杂对话体验所需的一切:
- 对话流的可视编辑画布，无需编写代码，
- 创作和管理语言理解(NLU)和 QnA 组件的工具，
- 强大的语言生成和模板系统，
- 一个现成的 bot 运行时可执行文件。
定价:
使用 Azure Bot 服务的公司包括戴姆勒、联合包裹服务公司、大金工业、西班牙电信等。
IBM 沃斯顿助手由 IBM 的 Watson AI 引擎提供支持，通过 IBM Cloud 交付，让您可以在任何应用程序、设备或渠道中构建、训练和部署聊天机器人。
IBM Console (Source: screenshot)
要使用 Watson Assistant 进行构建，您必须创建一个免费的 IBM Cloud 帐户，然后将 Watson Assistant 资源添加到您的服务包中。IBM Watson Assistant 提供了关于如何构建 IBM Watson Assistant 的各种学习资源。
IBM Watson Assistant 中的一个概念是技能的使用。这里的技能是指聊天机器人的能力。在技能中，你可以创建一个技能对话框和一个动作对话框。IBM Watson Assistant 还具有类似 Spring Expression Language、slot、decadevictions 或 content catalog 的特性。
沃森助手有一个虚拟开发工具包，用于将他们的聊天机器人与第三方应用程序集成在一起。使用该工具包，第三方应用程序可以将用户输入发送到 Watson Assistant 服务，该服务可以与供应商的后端系统进行交互。
沃森可以为最终用户的行为和偏好创建认知档案，并启动对话以提出建议。IBM 还为开发人员提供了一个已经配置好的汽车和酒店行业的客户服务和行业内容包目录。
开发人员还可以修改沃森助手的回应，以创建一个反映品牌人口统计数据的人工人格。它通过允许用户选择退出数据共享来保护数据和隐私。它还支持多种语言，如西班牙语、德语、日语、法语或韩语。
定价:在 Watson Assistant 上使用 Lite 计划构建聊天机器人是免费的，但它的上限是 10，000 次 API 调用。那么标准版的 Watson Assistant 定价为每个 API 调用 0.0025 美元。
DB Dialog 和 DB Steel、苏格兰 BBank、Staples、Workday 等公司都使用 IBM Watson Assistant 作为他们的对话式 AI 平台。
结论
聊天机器人在当今的数字经济中非常有用。它们为各种业务运营提供了可扩展性和灵活性。而且，它们的构建和部署非常简单。它们是自动化工作流程(如订购披萨等重复性任务)的绝佳方式。
我希望这篇文章能给你一些关于使用哪个平台来构建聊天机器人的想法。感谢阅读！
参考
小野寺次郎
机器学习工程师和研究员，对人工智能和人类福祉(医疗保健和教育)之间的交叉充满热情。在我的空闲时间，我喜欢尝试新的菜肴和看动漫。
阅读下一篇
如何构建和管理自然语言处理(NLP)项目
Dhruvil Karani |发布于 2020 年 10 月 12 日
如果说我在 ML 行业工作中学到了什么的话，那就是:机器学习项目很乱。
这并不是说人们不想把事情组织起来，只是在项目过程中有很多事情很难组织和管理。
你可以从头开始，但有些事情会阻碍你。
一些典型的原因是:
- 笔记本中的快速数据探索，
- 取自 github 上的研究报告的模型代码，
- 当一切都已设置好时，添加新的数据集，
- 发现了数据质量问题并且需要重新标记数据，
- 团队中的某个人“只是快速地尝试了一些东西”,并且在没有告诉任何人的情况下改变了训练参数(通过 argparse 传递),
- 从高层推动将原型转化为产品“仅此一次”。
多年来，作为一名机器学习工程师，我学到了一堆东西，它们可以帮助你保持在事物的顶端，并检查你的 NLP 项目(就像你真的可以检查 ML 项目一样:)。
在这篇文章中，我将分享我在从事各种数据科学项目时学到的关键指针、指南、技巧和诀窍。许多东西在任何 ML 项目中都是有价值的，但有些是 NLP 特有的。
构建 ML 管道:6 个问题和解决方案[来自数据科学家的经验]
原文：https://web.archive.org/web/https://neptune.ai/blog/building-ml-pipeline-problems-solutions
ML 工作以 jupyter 笔记本开始和结束的时代已经过去很久了。
由于所有公司都希望将他们的模型部署到生产中，因此拥有一个高效和严格的 MLOps 管道来实现这一点是当今 ML 工程师必须面对的真正挑战。
但是考虑到 MLOps 工具是多么新，创建这样一个管道并不是一件容易的事情。事实上，对于绝大多数中型公司来说，这个领域本身也不过几年的历史。因此，创建这样的管道只能通过反复试验来完成，并且需要掌握大量的工具/库。
在本文中，我将向您介绍
- 我在之前工作过的公司里看到的常见陷阱，
- 以及我是如何解决这些问题的。
然而，这绝不是故事的结尾，我相信从现在起两年后，MLOps 领域将会更加成熟。但是通过向你展示我所面临的挑战，我希望你能在这个过程中学到一些东西。我确实做了！
所以我们开始吧！
作者简介
在继续之前，了解一下我的背景可能会对你有所启发。
我是一名法国工程师，在离开研究生态系统加入行业生态系统之前，我攻读了粒子物理学的硕士和博士学位，因为我想对社会产生更直接的影响。当时(2015 年)，我只为自己和 1-2 个合作者开发代码，因此你可以猜测我的产品兼容编码能力(如果你没有:没有:)。
但从那以后，我用不同的语言(主要是 C#和 Python)贡献了不同的代码库，即使我不是编队的开发人员，我也不止一次地看到了什么可行，什么不可行:)。
为了在开始旅程之前不摧毁我所有的可信度，让我赶紧补充一下，我确实对深度学习有非零的了解(2017 年在 github 上向社区提供的这本白皮书有望证明这一事实:)。
构建 MLOps 管道:我遇到的最常见的问题
以下是我在过去 6 年的 ML 活动中遇到的 6 个最常见的陷阱。
在整篇文章中，我将深入探讨每一个问题，首先提出问题，然后提供可能的解决方案。
问题 1: POC 风格的代码
我经常遇到以概念验证(POC)风格开发的代码库。
例如，要将一个模型发布到产品中，可能需要链接 5 到 10 个 click 命令(或者更糟，argparse！)为了能够:
- 预处理数据
- 特征化数据
- 训练一个 ML 模型
- 将 ML 模型导出到生产中
- 制作关于模型性能的 CSV 报告
此外，需要编辑两个命令之间的代码以使整个过程工作是非常常见的。
这在创业公司中很正常，他们想打造创新产品，而且想快速打造。但是根据我的经验，将代码库留在 POC 级别是一个长期的灾难。
事实上，随着维护成本越来越高，以这种方式添加新功能变得越来越昂贵。另一个值得考虑的因素是，在人员流动均匀的公司中，每次带着这种代码库离开都会对结构速度产生实际影响。
问题 2:没有高层次的关注点分离
ML 代码库中的关注点分离在高层次上经常缺失。这意味着，所谓的 ML 代码通常也在进行功能转换，比如与 ML 无关的操作——比如物理文档接收、管理数据转换等。
此外，这些模块之间的依赖关系往往没有经过深思熟虑。看看由我编写的一个小包装器创建的幻想图(我的目标是有一天在 PyPI 上发布:)，它基于优秀的 pydeps ，给出了模块级重组的代码基础依赖关系(这更接近您可能认为的真实生活情况:):
对我来说，这个图中最令人担忧的方面是低级包和高级包之间存在的循环依赖的数量。
另一个我个人认为不太好的架构是一个大的 utils 文件夹，在 ML 代码库中经常看到 utils 文件夹中有几十个模块。
问题 3:没有关注点的低层次分离
不幸的是，代码中的关注点分离在低层次上也经常缺失。当这种情况发生时，您最终会有 2000 多个 line 类来处理几乎所有的事情:特征化、预处理、构建模型图、训练、预测、导出……只要您说得出，这些 master 类都涵盖了您的基础(只有 coffee 不在，有时您永远不知道……😃。但正如你所知，这并不是固体的 S 会推荐的。
问题 4:没有配置数据模型
用于处理 ML 配置的数据模型经常缺失。例如，这是一个幻想模型超参数声明的样子(同样，比您想象的更接近真实情况)。
350+ lines dictionaries :’(
更有问题的是(但是可以理解的)，这允许动态修改模型配置(从许多真实情况中得到灵感的幻想片段):
从上面的代码片段中可以看出,“params”属性被修改了。当这种情况在代码中的几个地方发生时(相信我，当您开始走这条路时，确实如此)，您最终得到的代码是一个真正的调试噩梦，因为您放入配置中的内容不一定是后续 ML 管道步骤中到达的内容。
问题 5:处理遗留模型
由于训练一个 ML 模型的过程经常涉及手工操作(见问题 1 ),这样做可能需要很长时间。它也容易出现一些错误(当人在循环中时，错误也是:)。在这种情况下，您最终会得到(幻想代码片段)这样的东西:
提示:查看文档字符串日期🙂
问题 6:代码质量:类型提示、文档、复杂性、死代码
正如上面的代码片段可以证明的那样，类型提示很少在最需要的时候出现。我猜 n_model_to_keep 是一个 int，但是在问题 5 的代码片段中命名 graph_configuration 的类型会很困难。
此外，我遇到的 ML 代码库通常只有有限数量的 docstring，并且代码质量的现代概念，如循环/认知复杂性或工作记忆(参见这篇帖子以了解更多信息)并不被尊重。
最后，大家都不知道的是，解决方案中经常会出现大量死代码。在这种情况下，您可能会在添加新功能的几天中绞尽脑汁，才意识到您没有设法让它与这个新功能一起工作的代码甚至没有被调用(再次，真实的故事)！
构建 MLOps 管道:我如何解决这些问题
现在，让我们来看看我为上述 6 个紧迫问题找到的解决方案(当然是在多年来我的合作者的帮助下),并向您概述如果我现在必须开发一个新的 MLOPS 管道，我会在哪里。
解决方案 1:从 poco 到 prod
多亏了 Typer ，大量的 click/argpase 样板代码可以从命令行中取消。
我是几个咒语的忠实粉丝:
- 最好的代码是你不需要写的代码(有趣的民间传说)。
- 当一个观察开始被用作度量时(在这种情况下，是用来证明所有工作完成的行数)，它就不再是一个好的观察了。
在我看来，这是启动端到端 ML 模型培训的一个很好的高级命令签名:
TL DR:对所有的命令行工具使用 Typer。
解决方案 2:处理高层次的关注点分离——从 ML 整体服务到 ML 微服务
这是一个大问题，我花了很长时间来改进。正如我猜我的大多数读者今天一样，在微服务/monolith 之战中，我站在微服务一边(尽管我知道微服务不是弹指一挥间解决所有开发问题的奇迹)。使用 docker 和 docker-compose 来包含不同的服务，您可以增量地改进您的架构的功能，并且与其余已经实现的功能隔离。不幸的是，ML docker 架构通常是这样的:
A typical docker ML container architecture
现在，我想提倡一些更像这样的东西(数据处理部分也得到承认):
与 ML 无关的数据接收和存储功能现在被委托给一个专用的特性存储容器。它将接收到的数据存储到一个 MongoDB (我习惯处理非结构化文档，当然如果你也/只处理结构化数据，使用一个 Postgresql 容器)容器，在处理完文档后，它通过调用一个 gotenberg 容器(一个非常有用的现成容器，用于处理文档)来接收数据。
ML 在这里被分成三个部分:
- 计算机视觉部分:文档识别容器，将计算机视觉技术应用于文档时，可以想到常见的疑点:open-cv、Pillow…我有在标签工具容器的帮助下做标签的经验，但是那里有很多替代品。
- 一个 NLP 部件:NLP ，带有一个将 NLP 技术应用于从文档中提取的文本的容器。想想常见的嫌疑人:nltk，Spacy，DL/BERT…我有在 doccano 容器的帮助下做标签的经验，在我看来没有更好的替代方案了:)
- 核心 DL 部件:pytorch_dl 容器。在我所有的 DL 活动中，我从 TensorFlow 迁移到 PyTorch，因为与 TensorFlow 互动是我沮丧的来源。我面临的一些问题:
- 在我的开发过程中，它很慢而且容易出错，
- 缺乏官方 github 的支持(有些问题已经存在很多年了！),
- 调试难度(即使 tensorflow2 的急切模式在一定程度上缓解了这一点)。
您一定听说过代码库和功能应该只进行增量更改。根据我的经验，这在 95%的情况下都是正确的好建议。但是有 5%的时间事情是如此错综复杂，并且通过做增量式的改变来悄悄破坏的危险是如此之高(低测试覆盖率，我正在看着你)，以至于我建议在一个新的包中从头重写所有的东西，确保新的包具有与旧的包相同的特性，并且此后，一举拔掉错误的代码以插入新的包。
在我以前的经历中，我曾经处理过 TensorFlow 到 PyTorch 的迁移。
为了实现 PyTorch 网络，我推荐使用 Pytorch Lightning T1，这是一个非常简洁易用的 py torch 高级库。为了衡量这种差异，我的旧 TensorFlow 代码库中的代码行大约是数千行，而 Pytorch Lightning 可以用十分之一的代码完成更多的工作。我通常在这些不同的模块中处理 DL 概念:
The PyTorch-dependent code
感谢 PyTorch Lightning，每个模块不到 50 行长(网络除外:)。
训练器是一个奇迹，你可以在弹指间使用你选择的实验记录器。我从来自 TensorFlow 生态系统的优秀的旧 TensorBoard logger 开始了我的旅程。但正如你在上面的屏幕上看到的，我最近开始使用它的一个替代品:是的，你猜对了， neptune.ai ，到目前为止我很喜欢它。使用和上面代码片段中看到的一样少的代码，您最终将所有模型以非常用户友好的方式存储在 Neptune 仪表盘上。
Metrics and losses tracked in the Neptune UI
为了进行超参数优化，在这篇深入的博文之后，这些年我从hyperpt切换到了 Optuna 。这种转变的原因很多。除其他外:
- 较差的远视记录
- 易于与 optuna 的 PyTorch Lightning 集成
- 超参数搜索的可视化
将为您节省大量时间的技巧:在 pytorch_dl 容器由于任何原因(服务器重启、服务器资源不足等)崩溃后，允许优雅的模型重启。)，我用相同的随机种子重放已完成运行的整个 TPEsamplings ，并从最后保存的检查点开始未完成的试验。这使得我不必每次在服务器上发生意外的事情时都在未完成的运行上浪费时间。
对于我的 R&D 实验，我使用屏幕和越来越多的tmux(tmux 上的一个好参考)脚本来启动超参数优化运行。
由于 plotly 平行坐标图，超参数比较非常容易。
最后，我使用一个定制的 reporter 容器将一个 tex 模板编译成一个 beamer pdf。想象一下 jinja2 like tex 模板，你用特定于每次运行的 png 和 CSV 填充该模板，以生成一个 PDF，当企业/客户开始理解机器学习模型性能(主要混淆、标签重新分配、性能等)时，该 PDF 是与他们进行对话的完美开端。).
这些架构模式极大地简化了新功能的编码。如果你熟悉 Accelerate ，那么你就会知道，拥有一个好的代码库可以将实现一个新特性所需的时间减少 10 到 50 倍，这是千真万确的，我可以证明这一点:)。
如果您需要将消息代理添加到您的微服务架构中，我可以推荐 rabbit MQ ,因为多亏了 pika 库，插入 python 代码非常容易。但是在这里，我对备选方案没什么可说的(除了阅读:、卡夫卡、雷迪斯……)，因为我迄今为止从未与他们合作过。
解决方案 3:处理低层次的关注点分离——良好的代码架构
容器之间关注点的清晰分离允许拥有一个非常干净的容器级架构。看看这个幻想(但是我提倡的那个！😃)pytorch_dl 容器的依赖关系图:
以及不同模块动作的时间顺序:
我提倡的不同模块重组的高级视图:
- 适配器将原始 CSV 转换为专用于特定预测任务的 CSV。
- 如果通过的 CSV 行未能通过给定的过滤标准(太罕见的标签等)，过滤器将删除这些行。对于过滤器和适配器，我通常使用通用类来实现所有的适配和过滤逻辑，并继承覆盖每个给定过滤器/适配器的特定适配/过滤逻辑的类(ABC/protocols 上的资源)。
- 特性化器总是基于 sklearn，本质上是将 CSV 转换成特性名称字典(字符串)和 NumPy 数组。在这里，我将常见的疑点( TfidfVectorizer ， StandardScaler )包装到我自己的类中，本质上是因为(出于我不知道的原因)，sklearn 没有为其特征提供记忆化。我不想使用 pickle ，因为它不是一个安全兼容的库，并且不提供任何针对 sklearn 版本变化的保护。因此，我总是使用自制的改进产品。
- PyTorch 包含数据集、数据加载器和训练器逻辑。
- 模型报告生成上面已经讨论过的 pdf beamer 报告
- 例如，标记者重组确定性技术来预测(想想专家规则)稀有数据。根据我的经验，DL 模型的性能可以通过人的知识来提高，如果可行的话，您应该始终考虑这样做的可能性。
- MLConfiguration 包含 ML 数据模型:不包含任何处理方法的枚举和类。想想超参数类，PredictionType 枚举等。旁注:在所有有意义的地方使用枚举代替字符串(封闭列表)
- 管道将所有的基本砖块连接在一起。
- 路由包含允许其他容器请求对新数据进行预测的 FastAPI 路由。事实上，我把烧瓶放在一边的原因和我左键单击放在一边的原因是一样的——更少的模板、易用性和可维护性，甚至更多的功能。天鬼是神:)。我瞥了一眼为模特服务的火炬，但考虑到我职业生涯中参与的项目规模，我还不觉得有必要投入其中。加上 TorchServe(截至 2022 年 7 月)还处于起步阶段。
我现在总是用一个定制的预提交钩子来执行不同代码库的模块依赖重组。这意味着每当有人试图添加新的代码来增加新的依赖关系时，协作者之间就会引发一场讨论来评估这种新的依赖关系的相关性。例如，根据我给出的架构，我看不出有什么理由要依赖 pytorch 的模型报告。并且会根据任何情况投票反对 ml_configuration。
解决方案 4:由于 Pydantic，简单的配置数据模型
为了避免代码中的 config 成为无类型的大字典，我对所有配置/数据模型类强制使用了 Pydantic 。我甚至从最好的迪斯尼电影中获得灵感🙂(参见代码片段)
这使得配置只能在一个地方定义，最好是在代码之外的 JSON 文件中，并且由于 Pydantic 一行程序可以序列化和反序列化配置。我一直关注着九头蛇，但是就像这里解释的(非常好的渠道)举例来说，这个框架可能太年轻了，大概在几个月/几年后会更加成熟和自然。
为了用 optuna 试用版更新冻结的配置，我通常只定义一个静音动作字典(optuna 试用版中出现的每个超参数键的静音动作值)。
解决方案 5:通过频繁的自动再培训来处理遗留模型
因为训练一个模型的入口点是一个唯一的 Typer 命令(如果您遵循解决方案 1 到 4:)，所以很容易 cron 它定期自动地重新训练模型。由于报告和它包含的指标，您有两个层次来决定是否将新模型投入生产。
- 自动，高级:如果新车型的宏观性能比老款好，就把新车型投入生产。
- 手动，细粒度:专家可以详细比较两个模型，并得出结论，即使某个模型在整体性能方面比另一个模型稍差，但如果它的预测在出错时更有意义，它可能会更好。例如(这里有一个完全虚假的视觉例子来清楚地说明 ImageNet 上的观点)，第二个模型错了，它把老虎和狮子混为一谈，而第一个模型预测蜜蜂。
我所说的将模型导出到生产中是什么意思？在上面描述的框架中，它本质上只是将一个模型文件夹从一个位置复制到另一个位置。然后，其中一个高级配置类可以将所有这些加载到一个中，以便通过 FastApi 和 PyTorch 进行新的预测。根据我的经验，PyTorch 简化了这个过程。使用 TensorFlow，当我将模型从一个文件夹移动到另一个文件夹时，我必须手动调整模型检查点。
解决方案 6:提高代码质量，在我的工具的帮助下，这是一场持久战
在代码质量和附属方面，我有几匹战马:
- 正如已经提到的，我实现的所有数据模型类都基于 Pydantic (另一个 python 神: Samuel Covin )。
- 我 docstring 每一个方法(但是试图禁止方法中的注释，在我看来，这是迫切需要应用优秀的老提取方法重构模式:)。谷歌风格指南是必读之作(即使你不完全遵守它，也要知道你为什么不遵守:)。
- 我使用 sourcery 来自动追踪糟糕的设计并应用建议的重构模式(你可以在这里找到当前的列表，他们定期添加新的)。这个工具是一个省时的工具——糟糕的代码不会存在很久，你的同事不必阅读它，也不必在痛苦的代码审查中指出它。事实上，我建议每个人在 pycharm 上使用的唯一扩展是 sourcery 和 tabnine
- 在其他预提交钩子中(还记得我已经谈到的关于高级依赖关系的自制钩子)，我使用了 autopep8 、 flake 和 mypy 。
- 我使用 pylint 对我的代码库进行 lint 处理，目标是 9-9.5。这完全是武断的，但正如理查德·塞勒所说——“我确信这有一个进化的解释，如果你给他们(男人)一个目标，他们就会瞄准。”
- 我使用 unittest (这是我曾经使用过的一个，我觉得没有必要切换到 pytest。即使这意味着一些样板文件，只要测试存在，我在测试方面会更加宽容！).和上一点提到的原因一样，我的目标是 95%的覆盖率。
- 对于导入，我采用了 sklearn 模式，这意味着导入到模块重组文件夹之外的所有内容，其中 init。py stands 必须在这个非常 init.py 中列出，这里列出的每个类/方法都是“包”的接口，必须经过测试(单元的和/或功能的)。
- 我经常试图实现跨平台的确定性测试(读这个和这个)但是失败了(虽然我确实在固定平台上成功了)。由于 GitLab 跑步者经常变化，这通常会导致很多痛苦。我决定在端到端测试中有一个“足够高”的性能。
- 为了避免几个容器之间的代码重复，我提倡在每个容器中安装一个低级的自制库(通过各自 docker 文件中的命令行)。
- 关于 CI ，在各自的 GitLab 管道中构建你的 docker 镜像。
- 尽量不要在生产中挂载代码(但是在本地挂载以便于开发。非常好的参考docker+python 上的博客)。
- 我不在产品中发布测试，也不发布运行测试所需的库(因此你应该瞄准两个需求文件，一个 requirement-dev.txt 不在产品中使用)。
- 我经常有一个定制的 python dev docker-compose 文件来简化我的生活(和新成员的加入),它不同于生产文件。
- 我主张(广泛地)使用你的 GitLab repos 的 wiki 部分:)，因为口述传统在人类历史的某些阶段是好的，但肯定不适合 IT 公司:)。
- 我试图最小化我的容器上装载的卷的数量，最好的数量是 0，但是对于一些数据源(比如模型检查点)来说，这可能很复杂。
- 处理死代码有一个简单的解决方法:秃鹫。运行它，检查(密切关注，因为他们是一些假阳性)它的输出，拔掉死代码，清洗和重复。
结论
很多时候，你会看到沾沾自喜的文章掩盖了 ML 领域的真实生活。我希望你离开这篇文章时知道这不是其中的一篇。这是我在过去六年中开发 MLOPS 管道的真实旅程，当我回顾我在 2006 年开始编码时的情况时，我会更加自豪(C 代码中超过 400 个字符的一行方法:)。
根据我的经验，有些切换决策很容易做出和实现(flask 到 FastAPI)，有些很容易做出但不容易实现(比如 Hyperopt 到 Optuna)，有些很难做出也很难实现(比如 TensorFlow 到 PyTorch)，但最终都值得努力避免我提出的 6 个陷阱。
这种心态有望让你从类似 POC 的 ML 环境过渡到符合 Accelerate 的环境，在这种环境中，实现新特性不到一个小时，将它们添加到代码库也不到一个小时。
就我个人而言，我学到了很多东西，为此我深深感谢我以前的雇主和同事！
构建机器学习管道:常见陷阱
原文：https://web.archive.org/web/https://neptune.ai/blog/building-ml-pipelines-common-pitfalls
近年来，机器学习取得了快速进步，这导致许多公司和初创公司在不了解陷阱的情况下钻研该领域。常见的例子是构建 ML 管道时遇到的陷阱。
机器学习管道很复杂，有几种方式可能会失败或被误用。参与 ML 项目的利益相关者需要了解机器学习管道如何失败，可能的陷阱，以及如何避免这样的陷阱。
在构建机器学习管道时，有几个陷阱你应该知道。最常见的陷阱是黑盒问题——管道太复杂，难以理解。这可能会导致无法识别给定系统的问题，或者为什么它不能按预期工作。
为了理解其他陷阱，我们将看一看典型的 ML 管道架构，包括所涉及的步骤，以及在各个步骤下要避免的陷阱。
通用 ML 流水线架构
机器学习管道帮助团队组织和自动化 ML 工作流。该管道还为 ML(和数据)工程师提供了一种管理培训数据、编排培训和服务工作以及管理生产模型的方法。
让我们回顾一下定义其架构的 ML 管道中的典型过程。
ML 管道应关注以下步骤:
-
数据摄取:收集必要的数据是整个程序的第一步。用于培训的数据将由数据科学家或具有业务专长的人员组成的专业团队与数据工程师共同定义。
-
数据验证和 预处理 :采集的数据有很多变化。这通常是手动完成的，以格式化、清理、标注和增强数据，从而确保模型的数据质量可以接受。该模型的特征是将在培训和生产中使用的数据值。
-
模特培训:培训是整个程序中最重要的一个环节。数据科学家将模型与以前的数据进行匹配以进行学习，训练它对看不见的数据进行预测。
-
模型分析和验证:为了保证较高的预测精度，根据测试和验证数据对训练好的模型进行验证。当比较测试的结果时，模型可能已经根据不同的数据进行了调整/修改/训练。
-
模型部署:最后阶段是将 ML 模型应用于生产设置。因此，本质上，最终用户可以利用它来获得基于实时数据的预测。
-
管道协调 : 管道协调技术采用简单的协作界面来自动化和管理所有管道流程，在某些情况下还包括基础设施。
-
元数据管理:这一步跟踪元数据，如代码版本、模型版本、超参数值、环境和评估度量结果，以一种使它们在公司内部可访问和协作的方式组织它们。
就 ML 管道架构而言，有几种选择是可能的，我们将依赖这些 ML 管道和服务提供商，如谷歌云和 AWS 。例如，Azure ML pipeline 帮助创建、管理和优化机器学习工作流。它是 ML 工作流的一个独立的可部署流程。它使用起来非常简单，并提供了各种额外的管道，每个管道都有不同的功能。
ML 管道步骤中的常见陷阱
从接收数据到建模、操作模型，运行 ML 管道可能非常繁琐。在 ML 应用程序的生命周期中，管理管道也是一个很大的困难。在本节中，您将了解在构建 ML 管道的每个步骤中可能遇到的常见陷阱。
数据摄取步骤
处理各种数据源
数据接收是指将数据从许多来源移动到一个集中的数据库中，通常是一个数据仓库，下游系统可以在那里使用这些数据。这可以在实时或批处理模式下完成。数据接收和数据版本控制构成了数据分析架构的核心。关于这一步，最常见的陷阱是不同的数据格式和类型，根据数据的性质，这些格式和类型可能会使流程变得混乱和不同。
成批处理方式
最流行的数据摄取模型批处理。在批处理中，摄取层根据定义获取源数据，并将其移动到数据仓库或其他数据库。批处理可能由时间表、预定义的逻辑序列或某些预定义的标准启动。因为批处理通常不太昂贵，所以当不需要实时数据接收时，经常使用批处理。
实时流模式
实时流是一种将数据从源实时接收到目标的技术。流没有周期性元素，这意味着数据一旦在源上变得可访问，就被接收到数据仓库中。没有等待期。这需要一个能够持续监控数据生产者的新数据的系统。
解决办法
这里最重要的规则是在整个管道中保持一致的数据层。
即使是从各种数据源获取数据，也要始终注意用相似的格式维护数据。
- 您需要良好的报告和其他下游分析系统，这些系统要有良好的数据质量和可追踪的数据血统才能正常工作。
- 您的数据需要保持一致，因为可能会通过不同的模式(实时和批处理)接收数据
数据验证和处理
选择错误的架构
数据验证和数据处理是可能被管道问题阻碍的两个步骤。因为数据源会定期变化，所以随着时间的推移收集的数据的格式和类型也会变化，所以使数据输入系统适应未来是一个重要的问题。
在数据输入和管道过程中，速度可能是一个问题。例如，建立一个实时管道是非常昂贵的，因此评估你的公司真正需要的速度是至关重要的。
忽视数据质量监控
例如，在计算机能够执行一个批处理任务之前，它的所有输入数据必须准备好；这意味着必须对其进行彻底检查。数据质量问题，批处理作业中出现的数据错误、差错和软件故障会使整个流程陷入停顿甚至更糟，导致静默模型故障。
解决办法
必须彻底监控数据质量，以确保管道中的后续步骤使用高质量数据..微小的数据错误，如日期输入错误，可能会导致批处理失败。
也就是说，我们必须始终记住，运行在生产服务器上的模型将利用真实世界的数据为用户做出预测，因此我们还需要监控数据分布随时间的变化。
创建 ML 模型并不是一项简单的任务，要使模型在不同的环境中表现良好，需要高质量的数据。进入管道的坏数据不仅会导致您的模型无法正常运行，还可能会在做出关键业务决策时带来灾难性后果，尤其是在医疗保健或无人驾驶汽车等任务关键型行业。
模特培训
在模型训练期间使用未经验证的非结构化数据
机器学习工程师在人工智能研究中最常见的错误之一是使用未经验证的非结构化数据。未验证的数据可能包含诸如重复、数据冲突、分类不准确或不完整、差异以及其他可能导致整个训练过程异常的数据问题。
解决办法
当然，补救所有这些问题的一个方法是利用一个实验跟踪工具。通过这种方式，您可以跟踪所有管道运行会话、训练数据的多个版本，并且在生产阶段，只需单击几下鼠标，即可轻松监控模型版本和数据流。 Neptune.ai 是在这种情况下使用的合适工具。
模型验证和分析
粗心的预处理会在模型验证期间引入训练/测试泄漏
模型验证在部署之前正确评估模型的真实性能。有一些要点需要记住:
- 模型应用:我们的模型可能用于关键任务应用。靠谱吗？
- 模型可推广性:当我们的模型被部署并且在现实世界中表现不佳时，我们不希望获得极好的测试集性能而感到失望。
- 模型评估:在部署期间，我们不会总是知道新输入的基本事实。因此，在部署后衡量模型的性能可能很困难。
在这个陷阱下，有两件事要永远记住:
- 一个简单的训练/测试分割隐含地假设我们的数据由 iid 样本组成。
- 如果我们的数据违反了 iid 假设，那么测试集的性能可能会误导我们，导致我们高估模型的预测能力。
解决方法
- 如果您的数据是 iid，那么您可以使用标准分割或交叉验证。以下是 Scikit-learn 的一些实现:
- 当你的数据有一个顺序结构(比如文本流、音频片段、视频片段)，那么你应该使用一个适合这种情况的交叉验证器。
模型部署
思考部署是最后一步
一个普遍的误解是，机器学习模型在部署后会自动纠正自己，并且不应该对模型做什么。这在诸如强化学习的领域中可能是真实的，然而，即使使用这种技术，模型参数也要在一段时间内更新以达到最优。
当然，典型的 ML 模型并非如此，在部署阶段会出现很多错误。一个常见的错误是忽略生产中的监控模型性能和使用成本。
解决办法
- 为了确保模型得到监控，我们可以利用各种模型监控工具，这取决于它们的易用性、灵活性、监控功能、开销和警报系统。
此外，根本原因分析可用于确定问题的根本原因，然后通过正确的行动计划来解决问题。
元数据管理
忽视管道元数据管理
正如您在本文中了解到的，使用 ML 管道会很快变得非常复杂。每个步骤都会产生元数据，如果不加以管理，可能会导致潜在的问题，例如无法跟踪和调试管道故障。
解决办法
使用管道元数据管理工具来跟踪和管理管道每个步骤产生的元数据。做得很好的工具之一是 Neptune.ai 。另一个擅长管理管道元数据的工具是 Kedro (由于有了 Neptune-Kedro 插件，实际上可以很容易地将它们集成在一起)。
使用 Neptune.ai，您可以轻松跟踪所有 ML 管道实验和元数据。当处理生产设置时，Neptune 可以用来避免问题。
元数据管理和实验跟踪
ML 元数据存储是用于管理模型管道元数据的 MLOps 栈的重要组件。 Neptune.ai 是一个集中式元数据存储，可以在任何 MLOps 进程中使用。
Example of run comparisons in Neptune.ai for speech recognition project | Source
上面的例子显示了一个仪表板比较了指标和来自管道中实验的训练结果。实验培训超出了上面的例子，它包括如下几个方便的功能:
- 超参数
- 学习曲线
- 培训代码和配置文件
- 预测(图像、表格等。)
- 诊断图表(混淆矩阵、ROC 曲线等。)—您可以使用外部库(如 Plotly 等)记录交互式图表。
- 控制台日志
- 硬件日志
- 模型二进制文件或模型资产的位置
- 数据集版本
- 链接到记录的模型训练运行和实验
- 模型描述和注释
要了解更多，你可以查看 Neptune 的文档，它非常详尽。在这里，您可以学习如何将 Neptune.ai 与您的管道集成。
总结想法
如您所见，在设计处理 ML 流程所有不同阶段的管道时，可能会出现很多问题。尤其是在生产过程中，可能会出现一些意外问题，从而导致严重的问题，甚至在某些情况下导致业务损失。
我们在这里讨论的陷阱很常见，在本文中，我们列出了一些解决方案。本文还向您简要介绍了可能导致事情偏离最初计划的原因。
最后，如果它符合您的工作流程，我会强烈推荐 Neptune.ai 作为您的管道元数据存储，无论您或您的同事在哪里运行您的管道——无论是在云中、本地、笔记本中还是其他任何地方。
艾曼·哈克姆
Spotbills 的数据科学家|机器学习爱好者。
阅读下一篇
最佳 MLOps 工具以及如何评估它们
12 分钟阅读| Jakub Czakon |年 8 月 25 日更新
在我们的一篇文章中——机器学习团队实际使用的最好的工具、库、框架和方法——我们从 41 家 ML 初创公司学到的东西——Acerta 的 CTO Jean-Christophe Petkovich 解释了他们的 ML 团队如何接近 MLOps。
据他所说，一个完整的 MLOps 系统有几个要素:
- 您需要能够构建包含预处理数据和生成结果所需的所有信息的模型工件。
- 一旦您能够构建模型工件，您必须能够跟踪构建它们的代码，以及它们被训练和测试的数据。
- 您需要跟踪所有这三样东西，模型、它们的代码和它们的数据，是如何关联的。
- 一旦您可以跟踪所有这些内容，您还可以将它们标记为准备就绪，进行生产，并通过 CI/CD 流程运行它们。
- 最后，为了在该过程的最后实际部署它们，您需要某种方法来基于该模型工件旋转服务。
这是对如何在公司中成功实施 MLOps 的高度概括。但是理解高层需要什么只是拼图的一部分。另一个是采用或创建适当的工具来完成工作。
这就是为什么我们编制了一份最佳 MLOps 工具的清单。我们将它们分为六类，以便您可以为您的团队和业务选择合适的工具。让我们开始吧！
物联网边缘生态系统的 MLOps:在 AWS 上构建 MLOps 环境
什么是 MLOps？
MLOps 或 DevOps for machine learning 是一种实践，旨在改善 ML 团队和运营专业人员在开发、部署和管理机器学习模型方面的项目管理、沟通和协作。MLOps 涉及使用工具和流程来自动构建、测试和部署机器学习模型，以及在生产中监控和管理这些模型，以提高生产率、可重复性、可靠性、可审计性、数据和模型质量。
虽然 MLOps 可以提供有价值的工具来帮助您扩展业务，但在您将 MLOps 集成到机器学习工作负载中时，您可能会面临某些问题。为了实施 MLOps，组织可以使用各种工具和技术，如版本控制系统、CI/CD 管道、构建或打包流程以及用于供应或配置的基础设施代码(IaC)。
是不是所有的事情都是用代码构建成一个过程？
CI/CD 是一个连续的工作流，旨在迭代产品的开发和部署，以改进和升级它。持续工作流(CX)概括了这一概念，并以相同的目标交付目的。为了管理机器学习产品的生命周期，我们必须定义以前不关心的新流程，例如，持续监控模型、评估新模型发布和自动数据收集。值得一提的是，您还需要考虑创建一个维护这些新流程的平台，类似于 Git 维护其工作流和操作，因为它们也有自己的生命周期。
物联网边缘项目的优势
总体而言，在物联网边缘公司中实施 MLOps 非常重要，因为物联网系统通常涉及相对大量的数据、高度的复杂性和实时决策，并且可以帮助确保高效地开发和部署机器学习模型，并确保它们随着时间的推移保持可靠和准确。MLOps 有助于确保每个人都朝着相同的目标努力，并且能够及时发现和解决任何问题或挑战。这可以使公司利用其物联网边缘设备生成的数据来推动业务决策，并获得竞争优势。
设计 MLOps 系统
值得注意的是，实施 MLOps 实践具有挑战性，可能需要在时间、资源和专业知识方面进行大量投资。考虑到这些因素，现在不同的云提供商提供的服务和工具有许多假设的场景和解决方案，然而，现实往往与你在博客和文章中读到的相去甚远。
AWS 提供了一个三层的机器学习堆栈，可以根据您的技能组合和团队对实现工作负载以执行机器学习任务的要求进行选择。如果你的用例所需要的机器学习任务可以使用 AI 服务来实现，那么你就不需要 MLOps 解决方案。另一方面，如果您使用 ML 服务或 ML 框架和基础设施，建议您实施一个 MLOps 解决方案，该解决方案将由您的使用案例的细节在概念上确定，例如，如果您在容器中构建在 AWS Greengrass 上运行的代码或通过操作系统管理它们，环境会有多大的不同，无论哪种情况都部署在边缘设备上。
作为第一步，执行需求评估
长话短说，作为一名 MLOps 工程师，您需要为您公司的所有类型的 Ops 需求整合和设计一个环境，并根据团队内部和跨团队的工作和计划进行定制。在设计数据、机器学习模型和代码生命周期的新流程时，您还需要有一个良好的愿景，不仅要基于 IT 标准，还要考虑它们的可行性。
Figure 1: The high-level overview of the MLOps environment architectural design built with AWS services listed in the left side | Source: Author
我与不同的团队进行了几轮采访和讨论，听取他们的期望，主要是 ML 团队，并与他们分享了其他团队的期望。该评估过程的结果导致概念化和设计一个框架，该框架提供了一个用于构建、管理和自动化过程或工作流的环境，通过该环境可以实现基于个人和跨团队需求的数据、模型和代码操作。
建筑设计
图 1 显示了环境架构及其所有资源。我在这里对它进行了分解，并解释了事物是如何被探测的，它是如何操作的，以及一个 MLOps 工程师如何使用它并在其中领导一个新过程的开发和部署。
作为第一步，我建议在 AWS 上创建一个新角色，并在这个角色下设置所有内容，这是一个好的实践。可以使用自定义虚拟专用云(VPC)并通过实施安全组和经由自定义 VPC 路由互联网流量来实施安全环境。此外，这个角色需要被授予适当的权利和权限来创建，例如，事件、Lambdas、层和日志的规则。让我们一步一步来看:
-
Twin SageMaker notebooks 拥有环境角色授予的所需权限:
–Development Twin是一个用于原型化和测试工作流脚本的环境，它拥有创建/更新/删除一些资源(如事件、Lambdas 和日志)的权限。
–部署 twin 严格地说是专门针对将在此组装在一起的 QA 流程和工作流。 -
红移，数据源可以后端连接到其他数据源和数据库，或者由任何其他类型的数据源(如 S3 桶或 DynamoDB)替代。孪生兄弟有权限对其进行读写(如果需要的话)。想象一下，作为一个用例，您需要通过编写一个复杂的查询来访问不同的数据库，然后将一个摘要写到另一个表中。
-
工作流由几个元素组成，它们协同工作以自动化流程:
–event bridge作为 Lambda 函数的自动触发器，如 cron 作业或事件
–Lambda 函数用于将脚本传递给部署 twin 执行
–备份 Lambda 函数以防出现故障，它可以从开发 twin 或手动调用
–cloud watch 来记录问题、跟踪报告或设置商业智能 -
SNS 服务，通过电子邮件进行自动订阅/发布报告。
-
Gitlab 用于维护工作流脚本(也用于控制平面资源)的存储库，其设计方式是通过推送请求进行部署。
Figure 2: Development twin, “control plane”, with its functionalities and associated resources to manage the environment for development and deployment | Source: Author
开发演练指南
- 作为一名开发人员，我可以登录 development twin，为任务或工作流编写脚本，从不同的表或桶中获取或推送一些数据，并使用 SageMaker SDK 来施展 orchestrator 的魔法[2]。
- 在完成开发、通过 QA 并最终用脚本更新存储库之后，是时候构建工作流的其余部分了，这意味着创建触发器、lambda 函数以及日志组和流。
- 图 2 显示了与 development twin 的角色策略相关的全部资源。我实际上称开发双胞胎为控制平面，因为你可以创建、更新和删除工作流所需的所有资源。“Boto3”，AWS python SDK，让你管理所有这些资源，相信我，使用 CloudFormation 或 Terraform 太麻烦了[1]。
- 我逐渐将我的脚本放在一起，并创建了一个工具箱来与这些资源进行交互，还为双胞胎指定了一个 S3 桶，并启用了版本控制来保存模型或数据集，这些模型或数据集是这些过程或工作流的结果。
部署演练指南
- 图 3 很好地展示了部署的工作流中涉及的所有部分。组装工作流后，由事件调用的 lambda 函数将传递工作流存储库，并告诉 SageMaker 笔记本需要执行哪个脚本或笔记本。
- Lambda 功能可以通过 WebSocket 与笔记本进行通信(甚至“Boto3”也可以让你打开/关闭笔记本)。下面这段 Python 代码展示了如何与 notebook API 交互。但是，WebSocket 库应该作为一个层添加到 Lambda 函数中。在执行脚本时，任何问题都将被记录下来进行跟踪，最终报告将发送给订阅该主题的团队。
sm_client = boto3.client("sagemaker", region_name=region)
Url = sm_client.create_presigned_notebook_instance_url(NotebookInstanceName)["AuthorizedUrl"]
url_tokens = url.split("/")
http_proto = url_tokens[0]
http_hn = url_tokens[2].split("?")[0].split("#")[0]
s = requests.Session()
r = s.get(url)
cookies = "; ".join(key + "=" + value for key, value in s.cookies.items())
terminal_resp = s.post(
http_proto + "//" + http_hn + "/api/terminals",
params={ "_xsrf": s.cookies["_xsrf"] }
)
ws = websocket.create_connection(
"wss://{}/terminals/websocket/1".format(http_hn),
cookie=cookies,
host=http_hn,
origin=http_proto + "//" + http_hn,
header=["User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36"]
)
commands = "pass commands here"
ws.send(f"""[ "stdin", {commands}]""")
Figure 3: Workflow plumbing in one glance | Source: Author
作为 MLOps 工程师的典型一天
想象一下，你在一家维护公司工作，该公司提供的服务具有内置于 AWS Greengrass 中的机器学习模型，在数百台物联网边缘设备上运行，以对传感器记录进行推断。然后，这些设备将数据流和(主动)决策的结果提交给后端服务器，以存储在桶和表上。根据我的经验，这可能是你日常工作的样子。
-
您正在参加一个战略会议，团队领导正在讨论建立新工作流的计划，该工作流基于查询表格和使用机器学习模型进行某些分析，并最终通过电子邮件发送报告。团队人员不足，许多任务需要自动化。
-
ML 团队领导希望您每天安排他们评估新部署的机器学习模型，比较不同版本，并根据预定义的性能指标持续收集一些模型漂移数据。
-
产品团队似乎试图与一个大客户达成交易，他们希望您创建并向他们发送 ML 团队在设备上部署的新发布功能的每月分析。
-
QA 团队经理已经确定了在用于监控机器学习模型的分段设备上运行的实时流程所报告的问题。可能有必要仔细检查现有的系统和流程，以确定问题的根本原因。对这些问题进行故障排除的一种方法可以包括检查由机器学习模型生成的日志和度量，建立监控工作流以识别可能指示任何问题的任何模式或异常，并在问题发生时运行调试例程。
到目前为止，无非是建立一些工作流和连续工作流(CX)，你需要为每个工作流编写脚本，创建 cron 作业，Lambdas，并将一些指标推送到日志中进行每月分析。
面向物联网边缘的 MLOps:挑战和需要考虑的要点
最后但同样重要的是，是时候分享我在设置环境时遇到的一些挑战了。
- 我建议努力提高你的 Terraform 技能是一项很好的投资，不要止步于此，因为许多公司也采用 Terragrunt 来保持 IaC 代码库的干燥[3，4]。在使用 IaC 的过程中，让我印象深刻的是向 MLOps 授予跨环境权限，如“暂存”或“生产”,这些权限需要在目标环境中定义，然后授予 MLOps 角色策略。稍后，您可以通过在“Boto3”会话中指定配置文件名来访问这些资源。下面是在。hcl 配置文件。
IAM role in target environment:
inputs = {
iam_role_name = "MLOps-env"
iam_assume_role_policy = <<EOF
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::MLops-env-id:root"
},
"Action": "sts:AssumeRole",
"Condition": {}
}
]
}
EOF
}
IAM role policy in target environment:
inputs = {
iam_role_policy_name = "MLOps-env"
iam_role_policy = <<-EOF
{
"Version": "2012-10-17",
"Statement": [
...
]
}
EOF
}
IAM role policy in MLOps environment within the “Statement”:
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::target-env-id:role/MLOps-env"
}
- 我意识到，尽管传统的 Git 的 CI 无法体现机器学习工件测试，但许多公司会在 Git 中为 CD 管道采用无服务器 bash 脚本。我决定建立一个集成的 Apache Airflow 来管理和执行 CI 测试过程和工作流。值得一提的是，我将开发 twin 用于培训任务，尽管如此，它也可以作为工作流自动化。
- Lambda functions retries 选项应该固定为 1，超时应该为 1 分钟左右，否则，工作流可能会被调用多次。
- 图表仪表板对于可视化和呈现数字和一些统计数据非常方便，但是维护和更新它们似乎是一项持续的任务。
- 提示请记住，笔记本实例中除 SageMaker 文件夹之外的所有内容都不会持续存在，并且不会为工作流的失败设置警报，稍后您会感谢自己。
结论
我写这篇文章的目的是通过将 MLOps 视为一种架构设计来带您走一条不同的道路，这是对您公司提供的产品或服务的 Ops 需求进行评估的结果。它并不是实现 MLOps 的终极或通用解决方案，但是如果您对 It 标准和实践有很好的理解，它会为您提供一些关于如何将不同部分整合在一起的想法。
说到向平台添加特性，我可以想象将 Apache Airflow 集成到平台中，并使用它来自动化一些特定的任务。此外，Ansible 似乎有一些有用的功能，可以在“设备上”为一些任务部署流程或工作流。启动一个 EC2 实例，并将其集成到 MLOps 环境中来托管这两个实例。有很多选择，最终，由您根据自己的需求做出正确的选择。
参考
Boto3 官方文档
[4] 保持你的地形代码干燥
