NeptuneAI-博客中文翻译-五-
NeptuneAI 博客中文翻译（五）
潜在狄利克雷分配(LDA)教程:视频通话记录的主题建模(带缩放)
在本教程中，我们将使用 NLP 机器学习模型来识别在录制的视频会议中讨论的主题。我们将使用潜在的狄利克雷分配 (LDA)，一种流行的主题建模技术。我们将应用 LDA 将会议的内容(抄本)转换成一组主题，并导出潜在的模式。
这将是一个没有任何不必要的绒毛快速教程。我们开始吧！
先决条件
为了遵循并完全理解本教程，您需要具备:
- Python 3.6 或更新版本。
- 理解自然语言处理。
- 视频会议记录。
文件结构
这个项目的文件目录应该是这样的。已经安排实施干净编码最佳实践:
├── README.md
├── converter.py
├── env
├── key.json
├── main.py
├── modeling.py
├── sentence-split.py
├── transcribe.py
在本教程中，我们将在上面的目录树中创建所有文件。
设置 Python 虚拟环境
我们需要为这个项目特有的各种 python 依赖项创建一个隔离的环境。
首先，要在终端中创建一个新的开发文件夹，运行:
$ mkdir zoom-topic-modeling
接下来，创建一个新的 Python 虚拟环境。如果您使用的是 Anaconda，可以运行以下命令:
$ conda create -n env python=3.6
然后，您可以使用以下方式激活环境:
$ conda activate env
如果您使用的是标准 Python 发行版，请通过运行以下命令创建一个新的虚拟环境:
$ python -m venv env
要在 Mac 或 Linux 上激活新环境，请运行:
$ source env/bin/activate
如果您使用的是 Windows，请按如下方式激活环境:
$ venvScriptsactivate
无论您使用何种方法创建和激活虚拟环境，您的提示都应该修改为:
(zoom-topic-modeling) $
需求文件
接下来，随着环境的建立，我们将安装项目依赖项的特定版本(这些版本是我撰写本文时的最新版本)。为了重现我的结果，您应该使用相同版本的软件包:
gensim==3.8.3
google-api-core==1.24.1
google-api-python-client==1.12.8
google-auth==1.24.0
google-auth-httplib2==0.0.4
google-cloud-speech==2.0.1
googleapis-common-protos==1.52.0
nltk==3.5
pandas==1.2.0
pydub==0.24.1
pyLDAvis==2.1.2
你可以简单地$ pip install -r requirements.txt或conda install --file requirements.txt(如果你在 Anaconda 上)然后瞧！该程序的所有依赖项都将被下载、安装，并准备就绪。
或者，您可以按如下方式安装所有软件包:
pip install en_core_web_sm gensim google-api-core google-api-pyton-client google-auth google-auth-httplib2 google-cloud-speech googleapis-common-protos nltk pandas pyLDAvis
conda install -c conda-forge en_core_web_sm gensim google-api-core google-api-pyton-client google-auth google-auth-httplib2 google-cloud-speech googleapis-common-protos nltk pandas pyLDAvis
设置参数和源代码的分离
我们将积极地生成 API 凭证，这些凭证是存在于我们源代码之外的变量，对每个用户都是唯一的。首先，您需要创建一个环境文件(。env)，这可以在您的 IDE 中通过创建一个新文件并命名它来轻松完成。env 也可以通过终端完成，如下所示:
(zoom-topic-modeling) $ touch .env
(zoom-topic-modeling) $ nano .env
环境变量由名称/值对组成，在给定的时间点，可以创建任意数量的变量供参考。
例如，的内容。env 文件看起来应该有点像这样:
user=Brain
key=xxxxxxxxxxxxxxxxxxxxxxxxxx
与项目相关的参数直接指向源代码。与项目实例相关的参数转到环境文件。
或者，您可以将 API 凭证文件添加到 gitignore 文件中。这可以防止敏感信息(如 API 键和其他配置值)在源代码中公开。
项目范围说明书
如果有一句话我们在 2020 年后不会忘记，那就是“呆在家里，保持安全。”疫情迫使世界各地的人们呆在家里，以帮助遏制病毒的传播。每个能做到这一点的人都开始在远程环境中工作。
这导致视频会议服务如 Zoom、Cisco WebEx、Microsoft Teams 或 Google Hangouts Meet 的受欢迎程度激增。这种新的社交距离文化迫使人们通过在线会议保持社交的创造性，学校，音乐会，仪式，健身项目从现实世界转移到屏幕上。
因为我们在组织中的虚拟会议比以往任何时候都多，所以对于高管和员工来说，参加所有的虚拟会议可能是低效和耗时的。因此，在这个项目中，我们将尝试使用主题建模来提供人们无法参加的会议的主题摘要。
项目工作流程
任何项目工作流的三个组成部分是:
- 输入，
- 转变，
- 所需的输出。
在这个项目的背景下，输入是视频或音频形式的视频会议记录(来自 Zoom)。
接下来，我们必须处理这个输入，并将其转换为一致的文件格式，在我们的例子中是–FLAC(免费的无损音频编解码器)。这是一种压缩的音频编码无损文件格式。此外，为了处理 FLAC 文件的上下文，我们需要将其转换为文本，以执行各种自然语言处理(NLP)操作。考虑到这一点，我们将利用谷歌的语音转文本 API 来准确地将音频内容转录成文本。
有了文字稿，我们将执行 NLP 预处理，开始 LDA 建模，并可视化主题。
脚本和解释
每个脚本都是根据面向对象的编程范式编写的。以下是对每个脚本的高级解释。
1.Converter.py
为了使这个项目无缝，我们将把所有的音频/视频文件转换成 FLAC 格式，这是一种由谷歌语音到文本 API 支持的编码方案。Pyhub 库是一个强大的 python 库，可以快速完成这些转换。
import pydub
class Converter:
def __init__(self, file_path):
self.audio = pydub.AudioSegment.from_file(file_path)
def convert(self, desired_format):
output = './audio.'+ desired_format
self.audio.export(output, format=desired_format)
print('Successfully completed conversion')
2.转录. py
通过将音频/视频文件转换为 FLAC，我们可以将音频内容转录为 txt 格式的文本。为了使用谷歌的 API，你需要设立一个谷歌云免费层账户，在这里你可以获得 300 美元的免费积分来探索谷歌云平台。
在撰写本文时，大约有三种类型的转录类:长音频文件、短音频文件和流文件，正如你在这里看到的。在这篇文章中，我们转录长音频文件。
任何超过 1 分钟的音频文件都被视为长音频文件。为了转录一个长音频文件，该文件必须存储在谷歌云存储中，如文档中所述。这意味着如果文件很短，我们只能直接从本地机器上传文件进行转录。这就是为什么我们需要一个谷歌云存储桶。如果你还没有一个桶的话，跟随这个链接来创建一个桶。
最后，为了连接我们的应用程序和 google 语音转文本 API，我们需要创建并激活一个 Google 云服务帐户，它将为您提供一个 JSON 文件。点击此链接快速入门。
注意:下载的 JSON 文件应该保存在与 transcribe.py 脚本相同的目录下。
import time
from google.cloud import speech
from google.oauth2 import service_account
class Transcriber:
def __init__(self,URI):
self.credentials = service_account.Credentials.from_service_account_file(
'key.json')
self.client = speech.SpeechClient(credentials=self.credentials)
self.gcs_uri = URI
self.audio = speech.RecognitionAudio(uri=self.gcs_uri)
self.config = speech.RecognitionConfig(
encoding=speech.RecognitionConfig.AudioEncoding.FLAC,
language_code="en-US",
audio_channel_count=2,
enable_separate_recognition_per_channel=True,
)
def transcribe(self):
transcript = ''
operation = self.client.long_running_recognize(
config=self.config, audio=self.audio)
start_time = time.time()
print("Waiting for operation to complete...")
response = operation.result()
for result in response.results:
transcript += result.alternatives[0].transcript
print('Transcribing completed')
print('Transcription took {time.time()-start_time}seconds')
print('saving transcript')
with open('transcript.txt', 'w') as file:
file.write(transcript)
3.分句. py
transcribe.py 脚本为相应的音频文件返回一个 script.txt 文件。为了构建理解底层模式的 LDA 模型，我们需要为模型提供 CSV 格式的文本文件。在这里，我们将把抄本分成一个数据帧，用实例作为句子。为了做到这一点，我们将通过“.”来分割文本文件内容，语法上的意思是一句话的结尾。
import csv
class Spliter():
def split(self):
with open('transcript.txt') as file_, open('transcript.csv', 'w') as csvfile:
lines = [x for x in file_.read().strip().split('.') if x]
writer = csv.writer(csvfile, delimiter=',')
writer.writerow(('ID', 'text'))
for idx, line in enumerate(lines, 1):
writer.writerow((idx, line.strip('.')))
4.建模. py
这个脚本由一个 LdaModeling 类组成，该类加载了 script.csv(这是将脚本拆分成句子后生成的数据)。该类有四个方法:预处理，建模，绘图，性能。
为了通过 LDA 进行主题建模，我们需要一个数据字典和一袋单词语料库。预处理方法从标记化开始，这是创建数据字典和词袋语料库的关键方面。它包括将一段文本分成更小的单元，称为标记。
我们需要从数据集中删除标点符号和停用词，以便将注意力集中在重要的词上。为了统一起见，我们将所有的记号都转换成小写，并对它们进行词汇化，以提取单词的词根形式并去除屈折词尾。此外，我们删除了 5 个字符以下的所有标记。预处理方法返回一个数据字典和单词语料库包作为 gensim_corpus，gensim_dictionary。
现在，我们已经拥有了在 Gensim 中创建 LDA 模型所需的一切。我们将使用 gensim.models.ldamodel 模块中的 LdaModel 类来创建 LDA 模型。我们需要将我们之前创建的单词库作为第一个参数传递给 LdaModel 构造函数，后面是主题数、我们之前创建的字典和传递次数(模型的迭代次数)。建模方法返回 LDA 模型实例。
为了可视化我们的数据，我们可以使用本文开头下载的 pyLDAvis 库。该库包含一个用于 Gensim LDA 模型的模块。首先，我们需要通过将字典、单词库和 LDA 模型传递给准备方法来准备可视化。接下来，我们需要调用 pyLDAvis 库的 gensim 模块上的显示，如绘图方法所示。
作为一个好的 LDA 模型的经验法则，困惑分数应该低，而一致性应该高。Gensim 库有一个 CoherenceModel 类，可用于查找 LDA 模型的一致性。对于困惑，LdaModel 对象包含一个 log-perferency 方法，该方法将一包单词语料库作为参数，并返回相应的困惑。CoherenceModel 类将 LDA 模型、标记化的文本、词典和字典作为参数。为了获得一致性分数，使用 get_coherence 方法。
import nltk
import pandas as pd
import re
import gensim
import gensim.corpora as corpora
from gensim.utils import simple_preprocess
from gensim.models import CoherenceModel
import pyLDAvis
import pyLDAvis.gensim
nltk.download('stopwords')
en_stop = set(nltk.corpus.stopwords.words('english'))
from nltk.stem import WordNetLemmatizer
stemmer = WordNetLemmatizer()
import warnings
warnings.filterwarnings("ignore")
class LdaModeling():
def __init__(self, data):
self.df = pd.read_csv(data)
self.df = self.df.drop(columns=['ID'])
self.corpus_superlist = self.df[['text']].values.tolist()
self.corpus = []
for sublist in self.corpus_superlist:
for item in sublist:
self.corpus.append(item)
def preprocessing(self):
def preprocess_text(document):
document = re.sub(r'W', ' ', str(document))
document = re.sub(r's+[a-zA-Z]s+', ' ', document)
document = re.sub(r'^[a-zA-Z]s+', ' ', document)
document = re.sub(r's+', ' ', document, flags=re.I)
document = re.sub(r'^bs+', '', document)
document = document.lower()
tokens = document.split()
tokens = [stemmer.lemmatize(word) for word in tokens]
tokens = [word for word in tokens if word not in en_stop]
tokens = [word for word in tokens if len(word) > 5]
return tokens
processed_data = [];
for doc in self.corpus:
tokens = preprocess_text(doc)
processed_data.append(tokens)
gensim_dictionary = corpora.Dictionary(processed_data)
gensim_corpus = [gensim_dictionary.doc2bow(token, allow_update=True) for token in processed_data]
return gensim_corpus, gensim_dictionary
def modeling(self):
lda_model = gensim.models.ldamodel.LdaModel(gensim_corpus, num_topics=3, id2word=gensim_dictionary, passes=50)
lda_model.save('gensim_model.gensim')
return lda_model
def plotting(self, lda_model, gensim_corpus, gensim_dictionary):
print('display')
vis_data = pyLDAvis.gensim.prepare(lda_model, gensim_corpus, gensim_dictionary)
pyLDAvis.show(vis_data)
def performance(self, lda_model, gensim_corpus, gensim_dictionary):
print('nPerplexity:', lda_model.log_perplexity(gensim_corpus))
coherence_score_lda = CoherenceModel(model=lda_model, texts=gensim_corpus, dictionary=gensim_dictionary, coherence='c_v')
coherence_score = coherence_score_lda.get_coherence()
print('nCoherence Score:', coherence_score)
5.Main.py
这是程序的执行点。在这里，我们导入所有的脚本类，并输入所需的参数。
from converter import Converter
from transcribe import Transcriber
from sentence-split import Spliter
from modeling import LdaModeling
def main()
if __name__ == '__main__':
audio_converter = Converter('./audio.mp3')
audio_converter.convert('flac')
zoom_project = Transcriber("gs://zoom_project_data/audio.flac")
transcript = zoom_project.transcribe()
sentence_spliter = Spliter.split()
lda_instance = LdaModeling('transcript.csv')
gensim_corpus, gensim_dictionary = lda_instance.preprocessing()
lda_model = lda_instance.modeling()
lda_plot = lda_instance.plotting(lda_model, gensim_corpus, gensim_dictionary)
print(lda_plot)
main()
结果
下图中的每个圆圈对应于使用 3 个主题的 LDA 模型输出中的一个主题。圆圈之间的距离显示了主题彼此之间的不同，重叠的圆圈显示了主题通过常用词的交集。当您将鼠标悬停在任何圆圈上时，该主题的最常用术语列表将出现在右侧，同时还会显示该主题的出现频率。
模型性能非常令人满意，因为它产生了低困惑分数和高一致性，如下所示:
结论
至此，本教程到此结束。您可以尝试其他短信示例来查看结果。我相信你已经想到了这种建模的所有令人惊奇的可能性和用例。感谢阅读！
资源
- 杰罗达尔，h，王，y，袁，c，冯，x，蒋，x，李，y，赵，l(2018)。潜在狄利克雷分配(LDA)和主题建模:模型，应用，综述。arXiv:1711.04305v2 [cs。IR】。
- Putra, I. M., & Kusumawardani, R. P. (2017). Analisis Topik Informasi Publik Media Sosial di Surabaya Menggunakan Pemodelan Latent Dirichlet Allocation (LDA). Jurnal Teknik ITS Vol. 6, №2, 311–316.
- h . m . wallach、I . Murray、r . Salakhutdinov 和 d . Mimno(2009 年)。主题模型的评估方法。2009 年 ICML 第 26 届机器学习国际会议论文集， 4 ，1105–1112。
- http://qpleple.com/perplexity-to-evaluate-topic-models/
- http://qp ple . com/topic-coherence-to-evaluate-topic-models/
从哪里可以了解 MLOps？学习 MLOps 的最佳课程、书籍、文章和播客
原文：https://web.archive.org/web/https://neptune.ai/blog/learn-mlops-books-articles-podcasts
MLOps 不是小菜一碟。尤其是在当今不断变化的环境中。有许多挑战—构建、集成、测试、发布、部署和基础设施管理。你需要遵循良好的实践，并知道如何适应挑战。
如果你不学习和发展你的知识，你就会落伍。合适的资源可以帮助您遵循最佳实践，发现有用的提示，并了解最新趋势。
你不用看很远，我们会掩护你的！以下是您关于 MLOps 的最佳资源列表，分为书籍、文章、播客等类别。让我们开始吧！
MLOps 课程
这门课程由人工智能先驱吴恩达(Andrew NG)担任策划，他是世界上最有影响力的计算机科学家之一，是谷歌大脑和 Coursera 的联合创始人，并在百度领导人工智能研究。他的机器学习专业化课程仍然被认为是商业中最适合初学者的课程。
面向生产的机器学习工程(MLOps)专业包括如何概念化、构建和维护在生产中持续运行的集成系统。与标准的机器学习建模形成鲜明对比的是，生产系统需要处理不断发展的数据。此外，生产系统必须以最低的成本不间断地运行，同时产生最高的性能。
在本专业中:
- 您将学习如何使用成熟的工具和方法来有效和高效地完成所有这些工作。
- 你将熟悉机器学习工程在生产中的能力、挑战和后果。
- 最后，你将准备好运用你的新生产技能，参与前沿人工智能技术的开发，以解决现实世界的问题。
如果您希望围绕某个平台(如谷歌云平台(GCP))建立您的 MLOps 专业知识，这可能是适合您的课程。本课程向参与者介绍了在 Google Cloud 上部署、评估、监控和操作生产 ML 系统的 MLOps 工具和最佳实践。
本课程主要面向:
- 希望快速从机器学习原型转向生产以产生业务影响的数据科学家。
- 寻求发展机器学习工程技能的软件工程师。
- 希望在 ML 生产项目中采用谷歌云的 ML 工程师。
您将学会:
- 确定并使用支持有效 MLOps 所需的核心技术。
- 在 ML 系统中采用最佳 CI/CD 实践。
- 为可靠有效的 MLOps 环境配置和供应 Google 云架构。
- 实现可靠且可重复的训练和推理工作流。
此外，您可以查看 MLOps 的官方网站，获取更多有趣的信息和资源，以扩展您的知识并了解最佳实践。
视频
斯坦福 MLSys 研讨会系列，顾名思义，是一系列专注于机器学习和 ML 系统的研讨会——工具和所有用于编写机器学习模型的技术。
该课程于 2020 年秋季开始。在这个研讨会系列中，每个演讲都在 YouTube 上直播每周四下午 1-2 点。您可以通过在实时聊天中提问。会谈的视频之后也可以在 YouTube 上看到。点击关注该频道，每周收听一次精彩讨论！
该课程的目标是帮助策划 ML 系统中令人敬畏的工作的课程，以帮助将研究焦点转向有趣的问题。
MLOps 图书
介绍 MLOps:如何在企业中规模化机器学习是 Mark Treveil 和 Dataiku 团队(集体作者)写的一本书。它介绍了 mlop 的关键概念，展示了如何随着时间的推移维护和改进 ML 模型，并解决了 mlop 的挑战。
这本书是专门为分析和 IT 运营团队经理编写的，他们直接面对在生产中扩展机器学习(ML)的任务。这是创建成功的 MLOps 环境的指南，从组织到所涉及的技术挑战。
全书分为三个部分:
- 对 MLOps 主题的介绍，它如何以及为什么发展成为一门学科，谁需要参与成功地执行 MLOps，以及需要什么组件。
- 第二部分遵循机器学习模型生命周期，其中有关于开发模型、准备生产、部署到生产、监控和治理的章节。
- 提供了当今公司中 MLOps 的实际例子，因此读者可以理解实际中的设置和含义。
什么是 MLOps？Mark Treveil 和 Lynn Heidmann 撰写的《从数据科学中产生长期价值&机器学习是一份全面的报告，面向希望了解和学习 MLOps 的商业领袖，MLOps 是一个产生长期价值的过程，同时降低与数据科学、ML 和 AI 项目相关的风险。
该报告包括以下内容:
- ML 模型构建的详细组件，包括业务洞察如何为技术团队提供价值
- 人工智能项目生命周期中的监控和迭代步骤——以及业务在这两个过程中扮演的角色
- 现代人工智能治理战略的组成部分如何与 MLOps 交织在一起
- 调整人员、定义流程和汇集启动 MLOps 所需技术的指南。
Noah gift 和 Alfredo Deza 的书Practical MLOps:operationaling Machine Learning Models是一本颇有见地的指南，带你了解 m lops 是什么，它与 DevOps 有何不同，并向你展示如何将其付诸实践，以操作你的机器学习模型。
这是你将从书中学到的:
- 将 DevOps 最佳实践应用于机器学习
- 构建生产机器学习系统并维护它们
- 监控、装备、负载测试和操作机器学习系统
- 为给定的机器学习任务选择正确的 MLOps 工具
- 在各种平台和设备上运行机器学习模型，包括手机和专门的硬件。
这里是 GitHub 上的免费版本 。这是一个公共回购，其中存储了《实用手册》一书的代码示例。
无论你是一个小型创业公司的一部分，还是一个全球性的大公司，这本实用的书向数据科学家、sre 和企业主展示了如何在你的组织内可靠、有效和负责地运行 ML。您将深入了解从如何在生产中进行模型监控到如何在产品组织中运行一个调整良好的模型开发团队的方方面面。
通过将 SRE 思维应用于机器学习，作家和工程专业人士 Cathy Chen、Kranti Parisa、Niall、D. Sculley、Todd Underwood 和特邀嘉宾向您展示如何运行高效的 ML 系统。无论您是想增加收入、优化决策、解决问题，还是理解和影响客户行为，您都将学习如何在保持全局观念的同时执行日常的 ML 任务。
具体来说，您将检查:
- 什么是 ML:它是如何运作的，它依赖于什么？
- 理解 ML“循环”如何工作的概念框架。
- 有效的“生产化”，以及如何使其易于监控、部署和操作。
- 为什么 ML 系统会增加生产故障排除的难度，如何解决这些问题？
- ML、产品、生产团队如何有效沟通？
机器学习系统既复杂又独特。复杂，因为它们由许多不同的组件组成，并涉及许多不同的利益相关者。独一无二是因为它们依赖于数据，从一个用例到下一个用例，数据变化很大。在这本书里，你将学习一种整体的方法来设计可靠的、可伸缩的、可维护的、适应变化的环境和业务需求的 ML 系统。
作者 Chip Huyen 是 Claypot AI 的联合创始人，他在如何帮助系统整体实现其目标的背景下考虑每个设计决策，例如如何处理和创建训练数据，使用哪些功能，多长时间重新训练一次模型，以及监控什么。本书中的迭代框架使用了大量参考文献支持的实际案例研究。
这本书将允许你处理如下情况:
- 工程数据和选择正确的指标来解决业务问题。
- 自动化持续开发、评估、部署和更新模型的过程。
- 开发一个监控系统来快速检测和解决模型在生产中可能遇到的问题。
- 构建一个跨用例服务的 ML 平台。
- 开发负责任的 ML 系统
“如果你打算用机器学习来解决大规模的商业问题，我很高兴你能拿到这本书。”————谷歌首席决策科学家凯西·科济尔科夫
这本书因其关注实用机器学习中非常重要的主题而受到了几个行业中坚分子的强烈评论。它在以下方面做得很好:
- 概述监控的重要性
- 如何进行模型维护？
- 出了问题怎么办？
- 对于那些你无法预料的错误，如何考虑后备策略？
- 如何应对试图利用您的系统的对手？
- 如何管理你的人类用户的期望？
它提供了对机器学习工程最佳实践和设计模式的全面回顾，所以如果你正在寻找给他们的工作带来更多的结构，并找到与可再现性、可伸缩性和模型版本控制相关的解决方案，这本书就是为你准备的。
MLOps 社区
那绝对是最好的 MLOps 社区。在一个地方有将近 10，000 名练习者，他们问问题，分享知识，互相讨论关于 MLOps 的所有事情。
虽然 MLOps 与 DevOps 有很多共同点，但差异和相似之处一样多。我们需要一个社区，专注于解决我们每天处理的独特挑战，构建生产 AI/ML 管道。我们在一起。在一个向所有人开放的社区中与我们一起学习吧。分享知识。提问。获得答案。
除了非常活跃的 Slack 频道，MLOps 社区还运营一个播客(下面会有更多介绍)，组织聚会和阅读小组，并发送时事通讯。确保检查所有这些资源。
为了应对竞争情报/竞争情报在洗钱方面的挑战，在竞争情报基金会管理下成立了竞争情报/竞争情报小组，其目标如下:
- MLOps 定义和路线图:为 MLOps 创建愿景和路线图，它意味着什么，以及它在 CI/CD 生态系统中的角色是什么。
- 参考架构和设计模式:为 MLOps 创建参考架构、设计模式和实现以及流程。
- AI 治理和风险管理:围绕血统跟踪、元数据收集、实验跟踪、数据版本化、ETL 操作等定义架构和指导方针。一个典型的数据和 ML 管道应该支持它来实现伦理人工智能
您可以在他们的 Slack 社区上加入#sig-mlops 频道。
MLOps 播客
这是一个由 Neptune.ai 运营的节目/播客。这是一个两周一次的问答节目，在这里，从事合理规模的 ML 的从业者回答来自其他 ML 从业者的问题。我们开始它是因为在与许多 ML 团队交谈后，我们意识到他们都想更多地了解像他们这样的团队如何解决他们的问题。找到这种资源并不容易。所以我们想我们可以试着改变这一点。
但是我们想用一种非常实际的方式来做。演示很棒，但有时你几乎想马上跳到问答部分。时间永远不够，对吧？这通常是演讲中最有趣的部分。
所以我们决定把整件事做成现场问答。每一集都专注于与生产 ML 相关的不同主题，并且充满了有趣的内容，这些是你在公司博客帖子中找不到的。只有修行人在问修行人的时候才会得到的东西。
您可以在此处注册这些活动，如果您想赶上前几集，您可以登录:
我推荐你从这一集开始:
MLOps.community 是由 Demetrios Brinkmann 主持的播客。它有“每周一次的谈话和炉边聊天，内容涉及与 DevOps 周围出现的机器学习新空间(又名 MLOps，又名机器学习操作)有关的一切。”
有采访，与有趣的人交谈，提示，谈论挑战，趋势，等等。收听收看！
有很多很棒的剧集，所以很难选出最好的，但你绝对应该赶上的一集是这一集:
3.TWIML 播客
《本周人工智能和人工智能》是该领域的领先声音，拥有超过 700 万的下载量和一个庞大的参与社区。通过其播客，它旨在将人工智能和人工智能领域的顶级思想和想法带到一个由人工智能/人工智能研究人员、数据科学家、工程师和精通技术的商业和 it 领导者组成的广泛而有影响力的社区。
TWIML AI 播客由 Sam Charrington 主持，他是一位广受欢迎的行业分析师、演讲人、评论员和思想领袖。Sam 的研究重点是机器学习和人工智能的商业和消费者应用，将人工智能产品推向市场，以及人工智能支持的技术平台。
你可以在这里查看所有的剧集，这里有一集我们推荐你先听:
Pipeline Conversations 是一个两周一次的播客，为您带来与行业领导者、顶级技术专家和其他人的采访和讨论。它讨论了机器学习，深度学习和人工智能的最新发展，特别关注 MLOps，或如何在生产中使用训练好的模型。
它于 2021 年 11 月首次播出，迄今已有 15 集，主题从生产你的 ML 模型到监控它。
先听听这个:
它可以在许多平台上使用，如亚马逊音乐、 谷歌播客、乌云、 Spotify 和 Stitcher 。
本播客旨在将机器学习带入主流。每集都有与顶级数据科学和机器学习从业者的对话，他们分享了他们的想法、最佳实践和将机器学习推广到生产的技巧。
到目前为止，它有 9 集，主要集中在良好的 MLOps 实践以及构建和部署有影响力的模型。
看看这一集，非常酷的一集:
它可以在 YouTube、T2、Spotify 和 T4 的苹果播客上看到。
MLOps 会议
MLOps World 是一个国际社区组织，致力于更好地理解将 ML 模型部署到实际生产环境中的科学。目前，他们有 5 个分会，从北美到欧洲。这些分会组织年度会议、活动和聚会，参与者有机会沉迷于各种研讨会，聆听来自领先科技公司如微软、亚马逊、Lyft 等的 ML 高管的演讲。
该计划由多伦多机器学习协会(TMLS)创建，旨在团结和支持更广泛的人工智能生态系统，公司，从业者，学者和开源社区的贡献者。他们的活动包括但不限于
- 定期举行社交聚会
- 知识共享和职业发展
- 确定将模型部署到实际生产环境中的机会以及有效的实践、方法和原则
- 独特的本地和全球合作伙伴关系
- 招聘和人才培养
- 多元化和包容性团队的成长
“我们去年推出了 apply()活动系列，以满足在生产中部署 ML 的 MLOps 团队对更多实践知识的需求。”–迈克·德尔·巴尔索，泰克顿联合创始人兼首席执行官。
apply()是 Tecton 在应用机器学习的数据工程上策划的一系列事件。这方面的最新活动是 apply(conf)，这是一个以从业者为中心的会议，讨论 ML 工程师在构建和部署机器学习模型时面临的挑战。这些主题包括
- 最佳实践开发模式
- 工具和基础设施的选择
- 管理标签管道
- 实时转换和提供要素
- 规模化服务
您可以在此访问会议的会议和视频档案。
他们的活动包括研讨会和面对面的社交活动，以最大限度地增加学习和交流的机会。你可以加入他们的 slack 社区，跟踪他们即将到来的聚会和会议。
其他 MLOps 资源
ML-ops.org 网站是 MLOps 的指南，解释了各种概念，如背后的原则、构成 MLOps 管道的组件、管理该管道的各种工具和框架等。凭借高质量的图形和精心策划的内容，它是任何希望开始使用 MLOps 的人的宝贵资源。这个网站上列出了大量的参考文献，这使得它更加有用。
Awesome MLOps 是由 ml-ops.org 背后的人创建的 MLOps 参考列表
这是众多资源的链接列表，从书籍、文章到社区等等。简而言之——它拥有你可能读到的关于 MLOps 的一切。该目录包括: MLOps 论文，关于 MLOps 的讨论，现有的 ML 系统，机器学习，ML/AI 的软件工程产品管理，ML/AI 的经济学，模型治理，伦理学，负责任的 AI。
小心点！如果你想浏览所有的链接，这可能是一个艰难而漫长的阅读，但如果你想了解所有关于 MLOps 的信息，这是最好的资源之一。
MLOps:机器学习中的持续交付和自动化管道是一份来自 Google 的文档，它“讨论了实现和自动化机器学习(ML)系统的持续集成(CI)(CD)(CT】。”****
****如果您是 MLOps 的新手，本文档可能是一个很好的知识来源，因为它涉及到一些基本概念。但是如果你是 MLOps 老手，你也会发现更新和巩固你的知识是有帮助的。它还可以帮助可靠地建立和操作大规模的 ML 系统。
如果你想在 Azure stack 上开始使用 MLOps，这是一个很好的资源。它有点类似于谷歌云提供的最后一种资源，然而，与其说是一门课程，不如说是一门自己动手的课程。该项目旨在
- 让您了解 Azure 提供的大量资产管理和编排服务，以帮助您管理模型培训和部署工作流的生命周期。
- 使用 Microsoft Azure 培训和操作您的模型的最佳实践。
- 提供真实世界的例子来帮助你开始做同样的事情。
如果你喜欢直接从源头阅读任何东西，这里的是一个非常有用的链接。它包含了自 2015 年以来所有关于机器学习操作的科学和工业研究论文，讨论了从技术债务到以正确的方式设计整个 ML 系统的一切。
把它包起来
如果你想为你的 ML 实验建立高质量的模型，MLOps 是很重要的。它可以促进您的生产流程，提高团队的绩效。因此，不断学习实施最佳实践，并始终保持领先！
别忘了关注我们的博客，获取最新文章。我们定期发布内容，为您带来最佳内容。我们还有一个专门的 MLOps 专区，你可以在这里找到。
我们错过了什么吗？如果您在我们的列表中没有看到您喜欢的资源，请告诉我们！****
机器学习项目的生命周期:有哪些阶段？
原文：https://web.archive.org/web/https://neptune.ai/blog/life-cycle-of-a-machine-learning-project
机器学习及其生命周期是关于什么的？不同的人会给你不同的答案。
- 程序员可能会说，这是关于用 Python 和复杂的数学算法编程。
- 商业利益相关者通常将机器学习与数据和一点神秘感联系在一起。
- 机器学习工程师倾向于谈论模型训练和数据争论。
那么谁是对的呢？所有人。
机器学习是关于数据的——没有谎言。没有足够多的数据供机器学习，就没有机器学习。可用数据量呈指数级增长，这使得机器学习开发比以往任何时候都更容易。
机器学习和算法之间的联系也在一点上。的确，有复杂的数学方法迫使机器学习。没有数学——没有机器学习。
最后，模型训练和数据准备确实是每个 ML 项目的核心。机器学习工程师花费大量时间训练模型和准备数据集。这就是为什么它是 ML 工程师首先想到的。
机器学习是关于开发、操纵数据和建模的。所有这些独立的部分一起形成了一个机器学习项目生命周期，这正是我们在本文中要讨论的内容。
ML 生命周期的高级视图
机器学习项目的生命周期可以表示为一个多组件流程，其中每个连续的步骤都会影响流程的其余部分。让我们从很高的层面来看一下流程中的步骤:
- 问题理解(又名业务理解)。
- 数据收集。
- 数据标注。
- 数据角力。
- 模型开发、培训和评估。
- 生产环境中的模型部署和维护。
如你所见，整个循环包括 6 个连续的步骤。每一步都是独特的，有其自身的性质。这些差异导致完成每个步骤所需的资源、时间和团队成员的变化。让我们详细看看生命周期中的每个组成部分，看看它是怎么回事。
详细的 ML 生命周期
第一步:理解问题
每个项目都从一个你需要解决的问题开始。理想情况下，清晰的问题定义应该用数字描述。数字不仅能让你知道你的起点在哪里，还能让你在以后追踪变化的效果。
例如，我工作的公司有显示每个手动操作给企业带来多少成本的计算。这种方法有助于我们对运营进行分层，并根据我们需要花费的金额对其进行优先排序。
我们的管理层最近启动了一个新的机器学习项目，旨在为目前我们支出清单上最重要的特定手动操作带来自动化。该团队还进行了研究，将运营成本与我们的竞争对手进行了对比。
结果令人失望:类似的手动操作比我们行业中的其他公司便宜 20%。为了在市场上成功竞争，我们必须降低成本。这就是我们启动自动化项目的原因。
这就是我们的全部问题吗？不完全是。知道成本并不意味着我们可以将这个问题交给我们的机器学习团队，并期望他们来解决它。
到目前为止，我们只从商业角度定义了这个问题。在任何机器学习发生之前，我们需要从货币单位转移到我们的机器学习团队可以理解的其他 KPI。
为此，我们的管理层发现，如果我们想将给定的手动操作成本降低 20%，我们应该将手动处理的数量从 100%减少到至少 70%。这意味着 30%的操作应该是自动处理的。知道这一点可以帮助我们缩小项目的范围，让我们明白我们只需要针对问题的一部分，而不是整个问题。
接下来，我们要针对的手动操作被分解成几个部分。知道了每件事在时间(和金钱)上的花费，团队就能够为可能自动化的任务提出一个建议列表。
在与机器学习团队讨论这个列表时，他们挑选了一些任务，如果有适当的数据，这些任务可以通过监督机器学习算法来解决。
最后，问题理解完成:公司的每个团队都知道他们的目标和原因。项目可以开始了。
步骤 2:数据收集
数据就是力量。当问题清楚了，建立了合适的机器学习方法，就该收集数据了。
数据可以来自多个来源。您可能有一个可以查询相关数据的内部数据库。你可以让数据工程师帮你提取数据，或者使用现有的服务，比如亚马逊 Mturk，或者自己动手。
其他人从他们的客户端接收数据。当你和客户一起解决问题时，这是典型的情况。客户对最终结果感兴趣，并且愿意共享数据资产。
另一个可以考虑的选择是从第三方提供商那里购买数据。尼尔森媒介研究就是一个很好的例子。它专注于快速消费品市场。他们做了大量的研究，从不同的市场人群中收集数据。销售快速消费品的公司总是在了解他们的客户和他们的偏好，以便利用新兴趋势盈利。像 NMR 这样的第三方提供商是有价值数据的重要来源。
还有开源数据集。如果你在处理一个许多企业和行业都可能遇到的一般性问题，它们会特别方便。你需要的数据集很有可能已经在网上的某个地方了。一些数据集来自政府组织，一些来自上市公司和大学。
更酷的是，公共数据集通常带有注释(如果适用)，因此您和您的团队可以避免花费大量项目时间和成本的手动操作。请将这些文章视为指南，帮助您为您的项目找到合适的公开可用数据集:
你的目标是收集尽可能多的相关数据。如果我们谈论表格数据，这通常意味着获取大时间跨度的数据。记住:你的样本越多，你未来的模型就越好。
在生命周期的后期，您将经历数据准备步骤，这可能会显著减少数据集中的样本数量(稍后我将解释原因)。这就是为什么在项目生命周期的最开始，积累尽可能多的数据是至关重要的。
如果你收集的还不够，你有两个选择:
数据扩充会给现有数据集带来额外的变化，从而使模型更易于泛化。它并不真的添加更多的样本，它只是操纵当前的数据来充分利用它。
从个人经验来看，我可以说你应该仔细考虑你应用的数据增强的类型。您只需要寻找反映模型将被使用的真实生产环境的增强。没有必要“教导”模型为那些你肯定知道在现实生活中不会发生的情况做好准备。在本文的后面，我们将讨论探索性数据分析(EDA ),它可以揭示您处理哪种数据以及哪种类型的增强是合适的。
另一方面，合成数据集是可用作模型输入的新样本。这是全新的数据，你可以使用无监督的深度学习(例如，生成对抗网络)，或者使用图像库(例如，在 Python 中，你可以想到 OpenCV 或 PIL)人工生成。
生成对抗网络从现有的例子中生成新的例子。作为一个很好的例子，我们可以参考计算机视觉行业，工程师使用这种架构类型从现有的、通常很小的数据集创建新的独特图像。我个人可以说，GANs 生成的图像质量相当好，对于标注(ML 项目生命周期的第 4 步)和进一步的神经网络训练(生命周期的第 5 步)相当有用。
第三步:数据准备
收集的数据杂乱无章。机器学习工程师在处理原始数据时会面临很多问题。以下是最常见的问题:
- 应该过滤相关数据。无关数据要清理；
- 应识别并去除噪音、误导和错误的样本；
- 应识别并消除异常值；
- 缺失值应被发现，并通过适当的方法删除和估算；
- 数据应该转换成适当的格式。
正如你所看到的，当处理原始数据时，机器学习工程师可能会面临多个问题。就其带来的问题而言，每个数据集都是独特的。关于如何进行数据预处理，没有经验法则。这个过程是创造性的和多方面的。
让我们考虑缺失值。这是大多数数据集都存在的一个普遍问题。ML 工程师可以简单地丢弃这些值，只处理数据集中的有效记录。
或者，你可以进行插补，用 NaNs 填充记录。又在找经验法则？不幸的是，这里也没有。根据您选择的不同标准，可以通过多种方式进行估算。用于估算的数学算法也不同，同样你有多种选择要考虑。
从现有特征创建新特征是机器学习工程师应该考虑的另一个选项。这个过程被称为数据工程。我个人经常做的数据工程的一个很好的例子是通过主成分分析(PCA)进行降维。PCA 减少了数据集中的特征数量，只保留那些对未来决策最有价值的特征。
一旦您完成了数据准备的核心部分，您可能想要转移到数据处理。数据预处理是一个步骤，使你的数据可以被你正在训练的神经网络或算法所消化。它通常意味着数据规范化、标准化和缩放。
通常，数据准备步骤伴随着探索性数据分析(EDA ),它补充了整个准备过程。EDA 帮助工程师熟悉他们所处理的数据。这通常意味着构建一些可以从不同角度帮助数据的图表。工程师从这种分析中获得的直觉有助于以后为数据准备、模型架构/算法选择(ml 项目生命周期的步骤 5.2)以及正确的度量选择(项目生命周期的步骤 5.4)找到正确的方法和工具。
数据准备(又名数据争论)是最耗时的步骤之一，但也是最重要的步骤之一，因为它直接影响将进入网络的数据的质量。
我通常以数据预处理步骤结束，将处理后的数据分成三个独立的子集:用于训练、验证和测试的数据。对于小数据集，我分配不超过 30 %的数据用于验证和测试，其余的数据用于训练。对于大数据集(大于 10k，我是一名计算机视觉工程师，所以我处理图像),我的个人实践使我得出以下分割比:
- 10%用于测试，
- 10 %用于培训期间的验证，
- 80%用于培训。
我强烈推荐的拆分策略是分层拆分，这有助于保持每个数据集中类的比例相等。这对正确的性能评估很重要。
步骤 4:数据注释
如果你的工作是在监督学习领域，你需要为数据集中的每个样本添加一个标签。为数据样本分配标签的过程称为数据注释或数据标注。
数据标注是一项手动操作，非常耗时，而且通常由第三方执行。很少有机器学习工程师自己做标签的情况。考虑到您和您的团队很可能不会自己检查注释过程，您在这一步的主要目标是设计一个全面的注释指南。
指南将让注释者知道该做什么。这就是为什么要想出一个全面的指南来涵盖注释工作最基本的方面是至关重要的。不要忘记贴标过程中可能出现的边缘情况。您的注释团队应该为他们可能面临的每一个可能的场景做好准备。在注释工作中没有假设的空间。一切都必须清晰透明。您还应该指派一个人来协助注释团队。如果您不能处理一个特定的例子，注释者应该知道联系谁来解决他们的问题。
有一些很好的例子可以用来创建自己的注释指南。如果你对注释如何影响整个机器学习生命周期感到好奇，可以考虑阅读这篇研究论文。请记住，数据注释的质量会直接影响最终模型的性能。不要限制注释指南的工作时间。让它易于使用并且足够详细。例子总是有帮助的，并且通常很受注释者的欢迎。花在指南注释上的时间是对最终结果质量的投资。
第五步:建模
到这一步，您应该有一个完整的数据集，可以输入到模型中。下一步是什么？是时候对未来的模式做出决定，并组装它。
5.1.尝试通过迁移学习来解决你的问题
机器学习工程师不会从零开始创建模型。他们倾向于重用已经在大型公共数据集上表现良好的模型。这些预先训练的模型可用于微调。这种方法已经在深度学习中广泛建立。例如，在计算机视觉中，微调工作得很好，因为 CNN 提取的低级特征对于大范围的任务是统一的。
你可以找到公共预训练模型的地方被称为模型动物园。 Github 是预训练模型的一个很好的来源，有数百个可能的选项。你只需要搜索你所使用的给定架构和框架的模型。
例如，TensorFlow 是一个机器学习框架，它提供了一个导入预训练模型的机会。这里有一个由 TensorFlow 创建的带有检测模型的动物园的例子。这些模型可用于计算机视觉中的迁移学习。
您应该始终为您的项目寻找一个预先训练好的模型来开始工作。它将节省您的时间、计算资源，甚至提高最终结果的质量。
5.2.相应地调整模型架构
需要注意的是，我们导入的预训练模型需要进行修改，以反映我们正在执行的特定任务。
如果你从事计算机视觉，你可能记得一个分类模型可以识别的类的数量取决于模型架构的顶部。最后一个密集图层的单元数量应等于您想要区分的类的数量。您的工作是准备一个适合您目标的最终模型架构设计。
5.3.多做实验
机器学习工程师倾向于做大量实验。我们喜欢尝试多种模型配置、架构和参数。您可能不会接受您得到的基线结果，并将其转移到生产中。这个结果很少会成为最好的结果。寻找最佳模型配置的迭代训练过程是机器学习工程师的常见做法。
在这一点上，你应该尝试多种可供选择的假设，这些假设可能对你的任务有用。为了缩小可能选项的列表，您可以考虑使用大多数 ML 框架提供的超参数调优方法。这些方法评估多种配置的性能，比较它们，并让您了解性能最佳的配置。您只需指定要采样的值和参数。
实验是我们工作的本质。如果你的计算资源不是有限的，你一定要利用它。你可能会得到意想不到的结果。谁知道呢，也许一个新的最先进的模型配置将来自你的一个实验。
如果你运行了大量的实验，检查一下如何很好地跟踪和组织它们。
5.4.正确评估
评估总是和做实验联系在一起的。您需要了解每个模型的行为，以便选择性能最佳的模型。为了比较模型，需要定义一组度量标准。
根据您正在处理的问题，您的度量标准会有所不同。比如对于回归问题，我们通常看 MSE 或者 MAE。另一方面，要评估分类模型，准确性可能是平衡数据集的一个好选择。不平衡的集合需要更复杂的度量。对于这种情况，F1 分数是一个很好的指标。
训练期间的评估在单独的验证数据集上执行。它跟踪我们的模型在泛化方面有多好，避免了可能的偏差和过度拟合。
在培训工作中可视化模型进度始终是一个很好的实践。Tensorboard 是第一个也是最基本的选择。或者，Neptune.ai 是一个更高级的工具，它可以可视化模型随时间变化的性能，还可以进行实验跟踪。拥有合适的工具至关重要。花点时间去找一个符合你特殊需求的实验跟踪工具。当你得到一个的时候，你将会节省大量的时间并且改善你的整个工作流程。
步骤 6:模型部署
太棒了。你有一个出色的模型，准备投入生产。现在，工程师部署一个训练模型，并使其可用于外部推理请求。
这是机器学习生命周期的最后一步。但是工作还远没有结束，我们不能放松下来，等待新的项目。
部署的模型需要监控。您需要跟踪部署的模型性能，以确保它继续以业务所需的质量完成工作。我们都知道随着时间的推移可能会发生一些负面影响:模型退化是最常见的影响之一。
另一个好的做法是收集模型错误处理的样本，以找出其发生的根本原因，并使用它来重新训练模型，使其对此类样本更加稳健。这种小规模的持续研究将帮助你更好地理解可能的边缘情况和其他你当前的模型没有准备好的意外事件。
结论
到现在为止，你应该对整个机器学习项目的生命周期有了很好的理解。让我再次强调，一个周期中的每一个连续步骤都可能对后面的步骤产生重大影响，既有积极的一面，也有消极的一面。你必须仔细检查每一步。
我的个人实践表明步骤#2(数据收集)、步骤#3(数据准备)和步骤#4(数据标注)是需要时间最多的。
进入模型的数据质量是一个好模型的关键驱动因素。不要忽视这些步骤，并始终投入足够的时间和资源。
了解 LightGBM 参数(以及如何调整它们)
原文：https://web.archive.org/web/https://neptune.ai/blog/lightgbm-parameters-guide
我已经用了 lightGBM 一段时间了。这是我解决大多数表格数据问题的常用算法。的令人敬畏的特性的列表很长，我建议你如果还没有看的话看一看。
但是我一直很想了解哪些参数对性能影响最大，以及我应该如何调优 lightGBM 参数以充分利用它。
我想我应该做一些研究，了解更多关于 lightGBM 的参数…并分享我的旅程。
具体来说，我:
在此过程中，我获得了更多关于 lightGBM 参数的知识。我希望读完这篇文章后，你能够回答以下问题:
- LightGBM 中实现了哪些梯度提升方法，有什么不同？
- 一般来说，哪些参数是重要的？
- 需要调整哪些正则化参数？
- 如何在 python 中调优 lightGBM 参数？
梯度推进方法
使用 LightGBM，您可以运行不同类型的梯度增强方法。您有:GBDT、达特和戈斯，它们可以用boosting参数来指定。
在接下来的部分中，我将解释和比较这些方法。
lgbm gbdt(梯度增强决策树)
这种方法是传统的梯度推进决策树，在这篇 文章 中首次提出，并且是 XGBoost 和 pGBRT 等一些伟大库背后的算法。
如今，gbdt 因其准确性、高效性和稳定性而被广泛使用。你可能知道 gbdt 是决策树的集合模型，但是它到底是什么意思呢？
让我给你一个要点。
它基于三个重要原则:
- 弱学习者(决策树)
- 梯度优化
- 助推技术
所以在 gbdt 方法中，我们有很多决策树(弱学习者)。这些树是按顺序建造的:
- 第一棵树学习如何适应目标变量
- 第二棵树学习如何拟合第一棵树的预测和地面真实值之间的残差(差异)
- 第三棵树学习如何拟合第二棵树的残差，以此类推。
所有这些树都是通过在整个系统中传播误差梯度来训练的。
gbdt 的主要缺点是在每个树节点中寻找最佳分裂点是耗时且消耗内存的操作。其他 boosting 方法试图解决这个问题。
镖梯度增强
在这篇出色的论文中，您可以了解关于 DART 梯度提升的所有事情，DART 梯度提升是一种使用神经网络中的标准下降来改善模型正则化并处理其他一些不太明显的问题的方法。
也就是说，gbdt 遭受过度特殊化，这意味着在后面的迭代中添加的树往往只影响少数实例的预测，而对其余实例的贡献可以忽略不计。添加 dropout 会使树在以后的迭代中更难专注于这几个样本，从而提高性能。
lgbm goss(基于梯度的单侧采样)
事实上，将这种方法命名为 lightgbm 的最重要原因是使用了基于这篇论文的Goss方法。Goss 是更新更轻的 gbdt 实现(因此是“轻”gbm)。
标准的 gbdt 是可靠的，但是在大型数据集上不够快。因此，goss 提出了一种基于梯度的采样方法，以避免搜索整个搜索空间。我们知道，对于每个数据实例，当梯度较小时，这意味着不用担心数据训练良好，当梯度较大时，应该再次重新训练。所以我们这里有两边，有大梯度和小梯度的数据实例。因此，goss 保留所有具有大梯度的数据，并对具有小梯度的数据进行随机采样(，这就是为什么它被称为单侧采样)。这使得搜索空间更小，goss 可以更快地收敛。最后，为了获得更多关于戈斯的信息，你可以看看这篇的博文。
让我们将这些差异放在一个表格中:
| 方法 | 注意 | 需要改变这些参数 | 优势 | 不足之处 |
|---|---|---|---|---|
是
的默认增压类型 |
因为 gbdt 是 lgbm 的默认参数，所以您不必为它更改其余参数的值(仍然必须进行调整！)
| |
过度特殊化，耗时耗力
|
| |
试图解决 gbdt
中的过度专业化问题 |
drop_seed:用于选择丢弃模式的随机种子 sUniform_dro:如果要使用统一丢弃 xgboost_dart_mode:如果要使用 xgboost dart 模式，请将其设置为 true skip _ drop:在提升迭代期间跳过丢弃过程的概率 max_dropdrop_rate:丢弃率:在丢弃过程中要丢弃的先前树的分数
| | |
| |
戈斯通过分离那些梯度较大的实例为 GBDT 提供了一种新的采样方法
|
top_rate:大梯度数据保留率 other_rate:小梯度数据保留率
| |
数据集小时过拟合
|
如果你设置提升为 RF，那么 lightgbm 算法表现为随机森林，而不是提升的树！根据文档，要使用 RF，必须使用小于 1 的 bagging_fraction 和 feature_fraction。
正规化
在这一节中，我将介绍 lightgbm 的一些重要的正则化参数。显然，这些是您需要调整以防止过度拟合的参数。
您应该知道，对于小数据集(< 10000 条记录)，lightGBM 可能不是最佳选择。调优 lightgbm 参数可能对您没有帮助。
此外，lightgbm 使用逐叶树生长算法，而 eXGBoost 使用深度树生长算法。逐叶方法允许树更快地收敛，但是过度拟合的机会增加了。
也许这个来自 PyData 会议的演讲给了你更多关于 Xgboost 和 Lightgbm 的见解。值得一看！
视频
如果有人问你 LightGBM 和 XGBoost 的主要区别是什么？你可以很容易地说，它们的区别在于它们是如何实现的。
根据 lightGBM 文档，当面临过拟合时，您可能希望进行以下参数调整:
- 使用小 max_bin
- 使用小数量的叶子
- 使用叶中最小数据和叶中最小和
- 通过设置 bagging_fraction 和 bagging_freq 来使用 bagging
- 通过设置 feature_fraction 使用特征子采样
- 使用更大的训练数据
- 尝试 lambda_l1、lambda_l2 和 min_gain_to_split 进行正则化
- 尝试 max_depth 以避免树越长越深
在接下来的几节中，我将更详细地解释这些参数。
λ_ L1
Lambda_l1(和 lambda_l2)控制到 l1/l2，并与 min_gain_to_split 一起用于对抗过拟合。我强烈建议您使用参数调整(在后面的小节中探讨)来找出这些参数的最佳值。
叶子数量
当然 num_leaves 是控制模型的复杂度的最重要参数之一。使用它，您可以设置每个弱学习者拥有的最大叶片数。较大的 num_leaves 增加了训练集的准确性，也增加了因过度训练而受伤的机会。根据文档，一个简单的方法是 num_leaves = 2^(max_depth) 然而，考虑到在 lightgbm 中，逐叶树比逐层树更深，你需要小心过度拟合！因此，有必要将 num_leaves 与 max_depth 一起调。
子样本
使用子样本(或 bagging_fraction)，您可以指定每个树构建迭代中使用的行的百分比。这意味着将随机选择一些行来适应每个学习者(树)。这不仅提高了泛化能力，还提高了训练速度。
我建议对基线模型使用较小的子样本值，然后在完成其他实验时增加这个值(不同的特征选择，不同的树结构)。
特征 _ 分数
Feature fraction 或 sub_feature 处理列采样，LightGBM 将在每次迭代(树)中随机选择一个特征子集。例如，如果将其设置为 0.6，LightGBM 将在训练每棵树之前选择 60%的特征。
该功能有两种用法:
- 可以用来加速训练
- 可以用来处理过度拟合
最大深度
该参数控制每个训练树的最大深度，并将影响:
- num_leaves 参数的最佳值
- 模型性能
- 训练时间
请注意，如果您使用较大的值 max_depth ，您的模型将很可能过度适合列车组。
max_bin
宁滨是一种在离散视图(直方图)中表示数据的技术。Lightgbm 使用基于直方图的算法来寻找最佳分割点，同时创建弱学习器。因此，每个连续的数字特征(例如，视频的观看次数)应该被分成离散的箱。
还有，在这个 GitHub r epo 里，你可以找到一些全面的实验，完整的解释了改变 max_bin 对 CPU 和 GPU 的影响。
如果将 max_bin 定义为 255，这意味着每个特性最多可以有 255 个唯一值。那么小的 max_bin 导致更快的速度，大的值提高精度。
训练参数
训练时间！当您希望使用 lightgbm 训练模型时，训练 lightgbm 模型时可能出现的一些典型问题是:
- 培训是一个耗时的过程
- 处理计算复杂性(CPU/GPU RAM 限制)
- 处理分类特征
- 拥有不平衡的数据集
- 对定制指标的需求
- 分类或回归问题需要进行的调整
在本节中，我们将尝试详细解释这些要点。
迭代次数
Num_iterations 指定提升迭代的次数(要构建的树)。构建的树越多，模型就越精确，代价是:
- 更长的训练时间
- 过度拟合的可能性更高
从较低数量的树开始构建基线，稍后当您想要从模型中挤出最后的%时，增加基线。
建议使用较小的学习速率和较大的次数迭代。此外，如果你的训练没有学到任何有用的东西，你应该使用 early_stopping_rounds 来停止你的训练。
提前 _ 停止 _ 回合
如果验证指标在最后一轮提前停止后没有改善，该参数将停止训练。这应该与迭代次数的成对定义。如果你设置的太大，你会增加过度拟合的机会(但是你的模型可以更好)。
经验法则是在 num_iterations 的 10%时使用它。
light GBM category _ feature
使用 lightgbm 的一个优点是它可以很好地处理分类特征。是的，这个算法非常强大，但是你必须小心使用它的参数。lightgbm 使用一种特殊的整数编码方法(由 费希尔 提出)来处理分类特征
实验表明，该方法比常用的一键编码**具有更好的性能。
它的缺省值是“auto ”,这意味着:让 lightgbm 决定哪个意味着 lightgbm 将推断哪些特征是分类的。
它并不总是工作得很好(一些实验显示了为什么这里的和这里的和和)我强烈建议你简单地用这段代码手动设置分类特征
cat _ col = dataset _ name . select _ dtypes(' object '). columns . to list()
但是幕后发生了什么，lightgbm 如何处理分类特性？
根据 lightgbm 的 文档 ，我们知道树学习者不能很好地使用一种热编码方法，因为他们通过树深入生长。在所提出的替代方法中，树学习器被最佳地构造。例如，对于具有 k 个不同类别的一个特征，存在 2^(k-1)-1 个可能的分区，并且使用 fisher 方法，该方法可以通过在分类特征中的值的排序直方图上找到最佳分割方式来改进为 k * log(k) 。
light GBM is _ unbalance vs scale _ pos _ weight
在二元分类问题中你可能面临的一个问题就是如何处理不平衡数据集。显然，您需要平衡正/负样本，但是在 lightgbm 中您如何做到这一点呢？
lightgbm 中有两个参数可以让你处理这个问题 is_unbalance 和 scale_pos_weight ，但是它们之间有什么区别，如何使用？
- 当您设置 Is _ un lace:True 时，算法将尝试自动平衡受支配标签的权重(使用训练集中的正/负分数)
- 如果您想要在不平衡数据集的情况下更改 scale_pos_weight (默认为 1，这意味着假设正负标签相等)，您可以使用以下公式(基于 lightgbm 存储库上的这个问题)来正确设置它
样本位置权重=阴性样本数/阳性样本数
lgbm feval
有时你想要定义一个定制的评估函数来测量你的模型的性能，你需要创建一个feval函数。
Feval 函数应该接受两个参数:
并返回
- 评估名称
- 评估结果
- 越高越好吗
让我们一步一步地创建一个定制的度量函数。
定义一个单独的 python 函数
使用此函数作为参数:
def feval_func(preds, train_data):
return ('feval_func_name', eval_result, False)
要使用 feval 函数而不是公制，您应该设置公制参数“无”。
print('Start training...')
lgb_train = lgb.train(...,
metric=None,
feval=feval_func)
分类参数与回归参数
我之前提到的大多数事情对于分类和回归都是正确的，但是有些事情需要调整。
具体来说，您应该:
参数的名称
| 分类说明 | 回归注释 | |
|---|---|---|
设置为二进制或多类
| 将其设置为二进制或多类 | |
|
Binary_logloss 或 AUC 等。
| Binary_logloss 或 AUC 或 etc。 | RMSE 或平均绝对误差和或等。 |
| | | |
|
仅用于二进制和多类应用
| 仅用于二进制和多类应用 | |
|
仅在多类分类应用中使用
| 仅用于多类分类应用 | |
| |
用于拟合 sqrt(标签)代替原始值用于大范围标签
| 用于拟合 sqrt(标签),而不是大范围标签的原始值 |
在前面的章节中，我们已经回顾并了解了一些关于 lightgbm 参数的知识，但是如果不提到 Laurae 的令人难以置信的基准测试，任何一篇关于 boosted trees 的文章都是不完整的🙂
您可以了解 lightGBM 和 XGBoost 的许多问题的最佳缺省参数。
你可以点击这里查看，但最重要的几点是:
参数名称
| 默认值 | 范围 | 参数类型 | 别名 | 约束或注释 | 用于 | |
|---|---|---|---|---|---|---|
当你改变它时会影响其他参数
| 当你改变它时会影响其他参数 | 指定 ML 模型的类型 |
| | | | |
空表示将使用指定目标对应的度量
| 空表示将使用与指定目标相对应的指标 | 指定指标，支持多个指标 |
| | | | |
如果设置为 RF，那将是一个装袋方式
| 如果设置为 RF，这将是一种打包方法 | |
| | | | | | | |
| | | | |
0.0 <套袋 _ 分数<= 1.0
| 0.0 <套袋 _ 分数< = 1.0 | 随机选择部分数据，无需重采样 |
| | | | |
要启用 bagging，bagging_fraction 也要设置成小于 1.0 的值
| 为了启用 bagging，bagging_fraction 也应设置为小于 1.0 的值 | 0 表示禁用装袋；k 表示每 k 次迭代进行打包 |
| | | | | |
一棵树的最大叶子数
| 一棵树的最大叶子数 |
| | | | |
0.0 <特征 _ 分数<= 1.0
| 0.0 <特征 _ 分数< = 1.0 | 如果设置为 0.8，LightGBM 将选择 80%的功能 |
| | | | |
通常越大越好，但是过拟合速度会增加
| 通常越大越好，但是过度拟合速度会增加 | 限制树模型的最大深度 |
| | | | | | | |
| | | | | |
助推迭代次数
| 升压迭代次数 |
| | | | |
学习率>0.0 典型值:0.05
| 学习率>0.0 典型值:0.05 | 在 dart 中，它也影响掉落树木的归一化权重 |
| | | | |
如果最后一次验证没有改善，将停止训练 _ 停止
_ 回合
| 如果验证在最近一次提前停止中没有改善，将停止培训 | 模型性能、迭代次数、训练时间 |
| |
指定某一列的编号指标
| 为列索引指定一个数字 | | |
处理分类特征
| 处理分类特征 |
| | | | |
0 表示禁用装袋；k 表示每 k 次迭代进行打包
| 0 表示禁用装袋；k 表示每 k 次迭代进行打包 | 为了启用 bagging，bagging_fraction 也应设置为小于 1.0 的值 |
| | | | |
< 0:致命，= 0:错误(警告)，= 1:信息，> 1:调试
| < 0:致命，= 0:错误(警告)，= 1:信息，> 1:调试 | |
| | | | | |
可以用来处理过拟合
| 可用于处理过拟合 |
你不应该认为任何参数值是理所当然的，并根据你的问题来调整它。也就是说，这些参数是您的超参数调整算法的一个很好的起点
python 中的 Lightgbm 参数调优示例(lightgbm 调优)
最后，在解释完所有重要参数之后，是时候进行一些实验了！
我就用一个流行的 Kaggle 比赛:桑坦德客户交易预测。
我将使用这篇文章解释如何在任何脚本上运行 Python 中的超参数调优。
值得一读！
在我们开始之前，一个重要的问题！我们应该调整哪些参数？
注意您想要解决的问题，例如，Santander 数据集高度不平衡，在您的调优中应该考虑到这一点！ Laurae2 ，lightgbm 的贡献者之一在这里很好的解释了这一点。
- 有些参数是相互依赖的，必须一起调整或逐个调整。例如，min_data_in_leaf 取决于训练样本的数量和 num _ leaf。
- 注意:最好为超参数创建两个字典，一个包含您不想优化的参数和值，另一个包含您想要优化的参数和值范围。
通过这样做，您可以将基线值从搜索空间中分离出来！
SEARCH_PARAMS = {'learning_rate': 0.4,
'max_depth': 15,
'num_leaves': 20,
'feature_fraction': 0.8,
'subsample': 0.2}
FIXED_PARAMS={'objective': 'binary',
'metric': 'auc',
'is_unbalance':True,
'boosting':'gbdt',
'num_boost_round':300,
'early_stopping_rounds':30}
现在，我们要做的是。
首先，我们在 笔记本 中生成代码。它是公开的，你可以下载。
-
第二，我们在 neptune.ai 中跟踪每个实验的结果。你可以在应用中看到这个例子，因为它是我作为公共项目创建的。
-
查看文档，了解更多关于使用 Neptune-LightGBM 集成跟踪模型构建元数据的信息。
结果分析
如果您已经检查了前面的部分，您会注意到我已经在数据集上做了超过 14 个不同的实验。在这里，我解释如何一步一步地调整超参数的值。
注:最新的代码示例请参考 Neptune-LightGBM 集成文档。
创建基准培训代码:
from sklearn.metrics import roc_auc_score, roc_curve
from sklearn.model_selection import train_test_split
import neptunecontrib.monitoring.skopt as sk_utils
import lightgbm as lgb
import pandas as pd
import neptune
import skopt
import sys
import os
SEARCH_PARAMS = {'learning_rate': 0.4,
'max_depth': 15,
'num_leaves': 32,
'feature_fraction': 0.8,
'subsample': 0.2}
FIXED_PARAMS={'objective': 'binary',
'metric': 'auc',
'is_unbalance':True,
'bagging_freq':5,
'boosting':'dart',
'num_boost_round':300,
'early_stopping_rounds':30}
def train_evaluate(search_params):
# you can download the dataset from this link(https://www.kaggle.com/c/santander-customer-transaction-prediction/data)
# import Dataset to play with it
data= pd.read_csv("sample_train.csv")
X = data.drop(['ID_code', 'target'], axis=1)
y = data['target']
X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.2, random_state=1234)
train_data = lgb.Dataset(X_train, label=y_train)
valid_data = lgb.Dataset(X_valid, label=y_valid, reference=train_data)
params = {'metric':FIXED_PARAMS['metric'],
'objective':FIXED_PARAMS['objective'],
**search_params}
model = lgb.train(params, train_data,
valid_sets=[valid_data],
num_boost_round=FIXED_PARAMS['num_boost_round'],
early_stopping_rounds=FIXED_PARAMS['early_stopping_rounds'],
valid_names=['valid'])
score = model.best_score['valid']['auc']
return score
使用您选择的超参数优化库(例如 scikit-optimize):
neptune.init('mjbahmani/LightGBM-hyperparameters')
neptune.create_experiment('lgb-tuning_final', upload_source_files=['*.*'],
tags=['lgb-tuning', 'dart'],params=SEARCH_PARAMS)
SPACE = [
skopt.space.Real(0.01, 0.5, name='learning_rate', prior='log-uniform'),
skopt.space.Integer(1, 30, name='max_depth'),
skopt.space.Integer(10, 200, name='num_leaves'),
skopt.space.Real(0.1, 1.0, name='feature_fraction', prior='uniform'),
skopt.space.Real(0.1, 1.0, name='subsample', prior='uniform')
]
@skopt.utils.use_named_args(SPACE)
def objective(**params):
return -1.0 * train_evaluate(params)
monitor = sk_utils.NeptuneMonitor()
results = skopt.forest_minimize(objective, SPACE,
n_calls=100, n_random_starts=10,
callback=[monitor])
sk_utils.log_results(results)
neptune.stop()
尝试不同类型的配置，并在 Neptune 应用程序中跟踪您的结果。
最后，在下表中，您可以看到参数发生了什么变化。
超参数
| 调谐前 | 调谐后 | |
|---|---|---|
| 最后的想法 |
长话短说，你学到了:
什么是主要的 lightgbm 参数
- 如何使用 feval 函数创建定制指标
- 主要参数有哪些好的默认值
- 查看了如何调整 lightgbm 参数以提高模型性能的示例
- 和其他一些东西🙂更多详细信息，请参考参考资料。
资源
Laurae 广泛的指南，具有良好的默认设置等
- https://github . com/Microsoft/light GBM/tree/master/python-package
- https://lightgbm.readthedocs.io/en/latest/index.html
- https://papers . nips . cc/paper/6907-light GBM-a-high-efficient-gradient-boosting-decision-tree . pdf
- https://statweb.stanford.edu/~jhf/ftp/trebst.pdf
- https://statweb.stanford.edu/~jhf/ftp/trebst.pdf**
登录强化学习框架——你需要知道什么
原文：https://web.archive.org/web/https://neptune.ai/blog/logging-in-reinforcement-learning-frameworks
日志通常是一个重要的问题，因为框架有不同的方法。在本文中，我将向您展示日志记录是如何在流行的强化学习框架中实现的。
在我的前一篇文章中，我讨论了如何理解强化学习代理，以及在训练和调试期间应该记录什么以及为什么要记录。
在本教程中，我将向您展示日志如何在不同的框架中工作，以及如何轻松地向它们添加您自己的日志记录器(我将以 Neptune 为例)。框架包括 Acme 、 RLlib 、 SpinningUp 和稳定基线。
我创建了一个 GitHub 存储库，里面有本教程的所有补充材料在这里。
强化学习中的登录方法
有两种最常见的日志记录方法，我称之为“存储然后记录”和“现在写”(一语双关)。
存储然后记录
在这种方法中，您首先在运行时存储指标，在指定的时间间隔(比如每 10 000 个时间步长)之后，您计算这些指标的聚合统计信息并记录它们。
原则上，这意味着您可以存储，例如，跨许多集的集回报，并汇总结果以获得跨存储值的平均集回报。
这在随机环境中非常有用，或者当你的策略是随机的，每次运行代理时你可以得到不同的事件回报。如果是这种情况，您必须考虑平均值来减少日志中的噪声。
这种日志记录方法可以在旋转上升和稳定基线框架中找到。
旋转起来
在 spin Up 中，更容易看到“存储然后记录”的方法，因为代码非常简单，所以我们将使用它来描述这种方法，然后我将讨论如何将这样的自定义日志程序添加到上述两个框架中。
示例中的“存储然后记录”
**下面是旋转(纪元)记录器 API。我删掉了不太重要的代码。
class Logger:
"""
A Logger tailored for tracking average values over epochs.
Typical use case: there is some quantity which is calculated many times
throughout an epoch, and at the end of the epoch, you would like to
report the average / std / min / max value of that quantity.
"""
[...]
def store(self, **kwargs):
"""
Save something into the epoch_logger's current state.
Provide an arbitrary number of keyword arguments with numerical
values.
"""
[...]
def log_tabular(self, key, val=None, with_min_and_max=False, average_only=False):
"""
Log a value or possibly the mean/std/min/max values of a diagnostic.
Args:
key (string): The name of the diagnostic. If you are logging a
diagnostic whose state has previously been saved with
``store``, the key here has to match the key you used there.
val: A value for the diagnostic. If you have previously saved
values for this key via ``store``, do *not* provide a ``val``
here.
with_min_and_max (bool): If true, log min and max values of the
diagnostic over the epoch.
average_only (bool): If true, do not log the standard deviation
of the diagnostic over the epoch.
"""
[...]
def dump_tabular(self):
"""
Write all of the diagnostics from the current iteration.
Writes both to stdout, and to the output file.
"""
[...]
可以看到，logger 有三个主要方法: store 、 log_tabular、和 dump_tabular 。
- 存储 每次被调用的数量要汇总并计算日志。它只是存储值，如剧集回报或一些学习指标，用于未来的计算。
- log_tabular 在 epoch 结束时被调用，记录存储的指标的统计数据。您可以选择记录平均值和标准差(参数 average_only=False )，或仅记录平均值(参数 average_only=True )，或另外记录最小值和最大值(参数 with_min_and_max=True )。
- dump_tabular 在命令行中完成操作并打印日志。这是为计算的统计数据添加您的自定义目的地的地方，例如将它们发送到 Neptune。
现在让我们看一下在旋转 VPG 实现中使用“存储然后记录”方法和 EpochLogger 的代码示例(同样，为了清楚起见，稍微做了修改和删减)。
def update():
...some policy optimization code...
logger.store(LossPi=pi_l_old, LossV=v_l_old)
for epoch in range(epochs):
for t in range(steps_per_epoch):
a, ... = ...get action...
next_o, r, d, _ = env.step(a)
ep_ret += r
ep_len += 1
...
if d is True:
logger.store(EpRet=ep_ret, EpLen=ep_len)
...
update()
logger.log_tabular('Epoch', epoch)
logger.log_tabular('EpRet', with_min_and_max=True)
logger.log_tabular('EpLen', average_only=True)
logger.log_tabular('LossPi', average_only=False)
logger.log_tabular('LossV', average_only=False)
logger.dump_tabular()
定制记录器
正在旋转的日志程序存在于 logx.py 文件中，不幸的是，没有简单的方法来覆盖它以将日志发送到 Neptune。在其设计中非常简单的旋转是非常硬编码的，这阻碍了在不修改原始代码的情况下扩展它的能力。也就是说，我为你修改了代码，你可以从这里得到。在链接中，您还可以找到一个示例运行脚本。
要使用日志程序，请用上面提供的实现替换正在运行的代码中的 logx.py 文件(在安装期间克隆的)。然后，您可以在启动中运行任何现有的代理，如下所示:
import gym
import neptune
import tensorflow as tf
from spinup import ppo_tf1 as ppo
env_fn = lambda : gym.make('LunarLander-v2')
ac_kwargs = dict(hidden_sizes=[64,64], activation=tf.nn.relu)
neptune.init(project_qualified_name='<namespace/project_name>')
experiment = neptune.create_experiment()
logger_kwargs = dict(output_dir='path/to/output_dir',
exp_name='experiment_name',
neptune_experiment=experiment)
ppo(env_fn=env_fn, ac_kwargs=ac_kwargs, steps_per_epoch=5000, epochs=250, logger_kwargs=logger_kwargs)
更多信息请参见 Spinning Up 网站的运行实验部分。
稳定基线
稳定基线是一个更高级的框架，就日志记录方法而言，它在本质上非常类似于向上旋转，但是，与向上旋转相比，它是可扩展的。在这里你可以找到我为你准备的 Neptune 记录器代码和运行示例。你可以根据自己的需要进行调整。
现在让我们看看如何在稳定的基线中实现 Neptune 实验的定制日志输出。
from stable_baselines import logger
class NeptuneLogger(logger.KVWriter):
"""Stable Baselines Neptune logger."""
def __init__(self, experiment):
super().__init__()
self._experiment = experiment
def writekvs(self, kvs):
for k, v in sorted(kvs.items()):
if hasattr(v, 'dtype'):
v = float(v)
self._experiment.log_metric(k, v)
在这里你可以看到如何使用我们的记录器。我们首先导入它，然后创建 Neptune 实验，并将我们的记录器添加到默认的记录器输出中。
import neptune
import stable_baselines
from stable_baselines import logger
from logger import NeptuneLogger
neptune.init(project_qualified_name='<namespace/project_name>')
experiment = neptune.create_experiment()
logger_ = logger.Logger.CURRENT
logger_.output_formats.append(NeptuneLogger(experiment))
...further training code...
您可以在此找到更多关于培训稳定基线代理的信息。
现在写
这是一个概念上更简单的方法，因为你不需要存储任何东西。你只需记录可用的值，例如在每集之后。您记录或“立即”写入值，因此得名“立即写入”。是 Acme 和 RLlib 用的。
这种简单的方法有其缺点。主要问题是记录值中的高噪声。我们可以在这里回忆随机环境/政策的问题，但是训练统计数据作为一个损失，受到高方差的影响。
在命令行中查看每一集的打印值将是一场噩梦。但是只要我们使用像 Neptune 这样的实验跟踪工具，这并不是什么大问题。
Neptune 将获取所有这些细粒度的值，对它们进行平均，并将它们与最大值和最小值一起呈现在可解释的图表上(如图 1 中的阴影区域所示)。
Figure 1. DDPG’s critic loss on the Y-axis and timesteps on the X-axis. The agent was trained on the Humanoid MuJoCo environment.
过滤器
如果您仍然希望手动修复日志中差异较大的问题，可以使用过滤器。
过滤器是记录器上的包装器，它在记录值之前对值进行一些转换。
对于 Acme，我为你准备了两个。一个用于值平滑(参见本系列讲座的指数加权移动平均线，或 EMA，来自吴恩达)，另一个用于计算聚集统计数据，如“存储然后记录”。
所有这些最好用一个例子来描述，所以让我们跳到极致。
极致
和以前一样，我将使用两者中更简单的框架来介绍这种方法。然后我们将讨论自定义记录器和过滤器的实现。
示例中的“现在写”
**下面是取自 Acme EnvironmentLoop 类的“立即编写”方法(为了清楚起见，稍作修改)。
def run_episode():
...reset any counts and start the environment...
while not timestep.last():
action = actor.select_action(timestep.observation)
timestep = environment.step(action)
episode_return += timestep.reward
...
if should_update:
actor.update()
episode_steps += 1
steps_per_second = episode_steps / (time.time() - start_time)
result = {
'episode_length': episode_steps,
'episode_return': episode_return,
'steps_per_second': steps_per_second,
}
logger.write(result)
如您所见，记录器是一个简单的对象。每集之后，你把结果写到里面。结果是一个字典，其中的键是日志名，值是度量。没什么复杂的。
定制记录器
让我们来看看我为您准备的自定义 Neptune 日志程序代码和过滤器。记录器和过滤器在示例运行脚本旁的处可用。
记录器
import collections
import re
import acme.utils.loggers as acme_loggers
import acme.utils.tree_utils as acme_tree
import numpy as np
class NeptuneLogger(acme_loggers.base.Logger):
"""Neptune logger for Acme.
Args:
prefix (string): The string used to prefix data keys in a name of a log.
Can be None in which case no prefix is used.
index_name (string): The data key which value to use as a log index.
Can be None in which case no index is used.
"""
def __init__(self, experiment, prefix=None, index_name=None):
super()
self._experiment = experiment
self._prefix = prefix
self._index_name = index_name or ''
def write(self, values):
"""Send `values` to Neptune."""
values = acme_loggers.to_numpy(values)
index = values.pop(self._index_name, None)
for key, value in values.items():
prefixed_key = f'{self._prefix}/{key}' if self._prefix else key
if index:
self._experiment.log_metric(prefixed_key, index, value)
else:
self._experiment.log_metric(prefixed_key, value)
这很简单，你只需要实现一个方法--如 Neptune 记录器所示。
现在让我们跳到过滤器。
平滑滤波器
class SmoothingFilter(acme_loggers.base.Logger):
"""Logger which writes to another logger, smoothing matching data.
Args:
to (Logger): An object to which the current object will forward the
original data and its results when `write` is called.
smoothing_regex (string): A regex of data keys which should be smoothed.
smoothing_coeff (float): A desired smoothing strength between 0 and 1.
Note:
For example values of regex = 'return' and coeff = 0.99 will calculate
the running average of all data which contain 'return' in their key.
It's calculated according to: average = 0.99 * average + 0.01 * value.
Warm-up period of length 10 is also applied (see the comment in code).
"""
def __init__(self, to, smoothing_regex, smoothing_coeff):
super()
self._to = to
self._smoothing_regex = smoothing_regex
self._smoothing_coeff = smoothing_coeff
self._previous_values = collections.defaultdict(float)
self._smoothing_coeffs = collections.defaultdict(float)
def write(self, values):
"""Smooths matching data and forwards it with the original data."""
values_ = dict(values)
for key, value in values.items():
if re.search(self._smoothing_regex, key) is not None:
smoothed_key = f'{key}_smoothed_{self._smoothing_coeff}'
prev_value = self._previous_values[smoothed_key]
prev_smoothing_coeff = self._smoothing_coeffs[smoothed_key]
new_smoothing_coeff = (prev_smoothing_coeff * 0.9 +
self._smoothing_coeff * 0.1)
smoothed_value = (value * (1 - prev_smoothing_coeff) +
prev_value * prev_smoothing_coeff)
self._previous_values[smoothed_key] = smoothed_value
self._smoothing_coeffs[smoothed_key] = new_smoothing_coeff
values_[smoothed_key] = smoothed_value
self._to.write(values_)
您将一个正则表达式传递给平滑过滤器，它将平滑匹配正则表达式的日志值。您还可以使用 smoothing_coeff 参数在 0 和 1 之间控制平滑强度。
例如，regex = 'return '和 coeff = 0.99 的值将计算键中包含' return '的所有数据的移动平均值。它是根据:平均值= 0.99 *平均值+ 0.01 *值来计算的。还应用了长度为 10 的预热期(参见代码中的注释)。它有助于解决 EMA 上链接的讲座中描述的不准确的早期值。
注意，一个正则表达式可以很容易地用“or”操作符匹配多个不同的指标名称(在这里阅读更多)。
聚集过滤器
class AggregateFilter(acme_loggers.base.Logger):
"""Logger which writes to another logger, aggregating matching data.
Args:
to (Logger): An object to which the current object will forward the
aggregated data when `dump` is called.
aggregate_regex (string): A regex of data keys which should be
aggregated.
Note:
For not matched keys the last value will be forwarded.
"""
def __init__(self, to, aggregate_regex):
super()
self._to = to
self._aggregate_regex = aggregate_regex
self._cache = []
def write(self, values):
self._cache.append(values)
def dump(self):
"""Calculates statistics and forwards them to the target logger."""
results = {}
stacked_cache = acme_tree.stack_sequence_fields(self._cache)
for key, values in stacked_cache.items():
if re.search(self._aggregate_regex, key) is not None:
results.update({
f'{key}_mean': np.mean(values),
f'{key}_std': np.std(values),
f'{key}_median': np.median(values),
f'{key}_max': np.max(values),
f'{key}_min': np.min(values),
})
else:
results[key] = values[-1]
self._to.write(results)
self._cache.clear()
这个非常类似于“存储然后记录”方法的行为。方法 write 不会立即记录这些值，而是存储它们。然后，您还有一个方法 dump 来计算聚合统计数据，如 average、std。戴夫。、min 和 max，并将它们写入过滤器包装的记录器。
有关详细信息，请参见此代码和以前的过滤器代码。此外，在这里您将找到一个完整的示例，说明如何使用我们的定制记录器和过滤器运行 Acme 培训和评估。
如何做到这一切？
您可以通过包装记录器来使用过滤器。请看下面的摘录。
import acme.utils.loggers as acme_loggers
import logger as neptune_loggers
def make_logger(experiment,
prefix=None,
time_delta=1.0,
aggregate_regex=None,
smoothing_regex=None,
smoothing_coeff=0.99):
"""Creates an aggregate of Neptune and Terminal loggers with some filters.
Args:
experiment (NeptuneExperiment): Neptune experiment to log to.
prefix (string): The logger name (used also as NeptuneLogger prefix).
time_delta (float): Time (in seconds) between logging events.
aggregate_regex (string): A regex of data keys which should be
aggregated. If None, then no aggregation.
smoothing_regex (string): A regex of data keys which should be smoothed.
If None, then no smoothing.
smoothing_coeff (float between 0 and 1): A desired smoothing strength.
"""
neptune_logger = neptune_loggers.NeptuneLogger(
experiment, prefix, index_name='epoch')
terminal_logger = acme_loggers.terminal.TerminalLogger(prefix)
logger = acme_loggers.aggregators.Dispatcher(
[neptune_logger, terminal_logger])
if smoothing_regex:
logger = neptune_loggers.SmoothingFilter(
logger, smoothing_regex, smoothing_coeff)
logger = acme_loggers.filters.NoneFilter(logger)
logger = acme_loggers.filters.TimeFilter(logger, time_delta)
if aggregate_regex:
logger = neptune_loggers.AggregateFilter(
logger, aggregate_regex)
return logger
然后，使用这个方法为代理、训练循环和评估循环创建记录器。下面我包括了代码片段，完整的运行示例是这里是。
[...]
agent = d4pg.D4PG(
environment_spec=environment_spec,
policy_network=agent_networks['policy'],
critic_network=agent_networks['critic'],
observation_network=agent_networks['observation'],
sigma=1.0,
logger=make_logger(experiment, prefix='learner'),
)
train_loop = acme.EnvironmentLoop(
environment,
agent,
label='train_loop',
logger=make_logger(experiment,
prefix='train',
smoothing_regex='return')
)
[...]
eval_actor = actors.FeedForwardActor(policy_network=eval_policy)
eval_env = make_environment()
eval_logger = make_logger(experiment,
prefix='eval',
aggregate_regex='return')
eval_loop = acme.EnvironmentLoop(
eval_env,
eval_actor,
label='eval_loop',
logger=eval_logger,
)
[...]
您将在 repo 中找到关于运行 Acme 的更多信息，包括示例，在这里。
RLlib
与稳定基线的情况一样，RLlib 是一个更高级的框架，它使用与 Acme 相同的日志记录策略。我为您提供了允许您将 Neptune 日志添加到 RLlib 的代码。在这里您将找到日志程序代码和示例运行脚本。让我们先看看伐木工。
import neptune
import numpy as np
from ray import tune
class NeptuneLogger(tune.logger.Logger):
"""RLlib Neptune logger.
Example usage:
```
import ray
from ray import tune
ray.init()
tune.run(
"PPO",
stop={"episode_reward_mean": 200},
config={
"env": "CartPole-v0",
"num_gpus": 0,
"num_workers": 1,
"lr": tune.grid_search([0.01, 0.001, 0.0001]),
"logger_config": {"neptune_project_name": '<user name>/sandbox'},
},
loggers=tune.logger.DEFAULT_LOGGERS + (NeptuneLogger,),
)
```py
"""
def _init(self):
logger_config = self.config.get('logger_config')
neptune.init(logger_config.get('neptune_project_name'))
self.neptune_experiment = neptune.create_experiment(
name=str(self.trial),
params=self.config,
)
@staticmethod
def dict_multiple_get(dict_, indices):
"""Access the nested value."""
if not isinstance(indices, list):
indices = [indices]
value = dict_
index = None
for index in indices:
try:
value = value[index]
except KeyError:
print("Skipping", indices)
return {}
if isinstance(value, dict):
return value
else:
return {index: value}
def on_result(self, result):
list_to_traverse = [
[],
['custom_metrics'],
['evaluation'],
['info', 'num_steps_trained'],
['info', 'learner'],
['info', 'exploration_infos', 0],
['info', 'exploration_infos', 1],
['info', 'learner', "default_policy"]
]
for indices in list_to_traverse:
res_ = self.dict_multiple_get(result, indices)
prefix = '/'.join([str(idx) for idx in indices])
for key, value in res_.items():
prefixed_key = '/'.join([prefix, key])
if isinstance(value, float) or isinstance(value, int):
self.neptune_experiment.log_metric(
prefixed_key, value)
elif (isinstance(value, np.ndarray) or
isinstance(value, np.number)):
self.neptune_experiment.log_metric(
prefixed_key, float(value))
def close(self):
neptune.stop()
上面的海王星记录器的例子可能看起来很可怕，但它真的不是。它所做的只是从嵌套的结果字典中访问 list_to_traverse 中列出的日志。在这个过程中，它会为每个值添加前缀，这些值是根据原始嵌套数据结构中的键构建的。然后它会处理值数据类型，瞧！请随意复制这段代码，并根据您的日志需求进行修改。
下面你可以看到如何添加您的自定义记录器到 RLlib 培训。
import ray
from ray import tune
from logger import NeptuneLogger
ray.init()
tune.run(
"PPO",
stop={"episode_reward_mean": 200},
config={
"env": "CartPole-v0",
"num_gpus": 0,
"num_workers": 1,
"lr": tune.grid_search([0.01, 0.001, 0.0001]),
"logger_config": {"neptune_project_name": "<namespace/project_name>"},
},
loggers=tune.logger.DEFAULT_LOGGERS + (NeptuneLogger,),
)
结论
现在你有了它，两种日志方法和四个框架。在这里你会发现所有的代码与示例运行脚本。
玩得开心，祝你的 RL 实验好运！****
Python 算术编码无损数据压缩及其在深度学习中的应用
数据压缩算法使用比原始表示更少的比特数来表示长的符号序列。数据压缩算法有两类:有损和无损。
在本教程中，我们将讨论一种称为算术编码(AE)的无损算法。您将通过一个展示消息编码和解码步骤的示例来了解 AE 是如何工作的。
我们还将构建一个可以编码和解码文本消息的 Python 实现。这个 GitHub 项目的实现是可用的。
以下是我们将在本教程中涉及的所有内容:
- 算术编码概述
- 频率和概率表
- 编码
- 解码
- 十进制模块
- Python 实现
- 无损压缩在深度学习中的应用
开始吧！
无损算法概述(算术编码)
在数据压缩中，有损算法在压缩数据的同时会丢失一些细节。它们减少了用于表示消息的位数，即使这会降低重建数据的质量。
无损算法无损重建原始数据。因此，与有损算法相比，它们使用的位数更多。
算术编码 (AE)是一种无损算法，使用少量比特来压缩数据。
这是一种基于熵的算法，在 1987 年的一篇论文中首次提出(威滕、伊恩·h、拉德福德·m·尼尔和约翰·g·克利里。"用于数据压缩的算术编码."美国计算机学会的通讯 30.6 (1987): 520-540)。
AE 算法减少位数的一个原因是 AE 使用 0.0 到 1.0 之间的单个数字对整个消息进行编码。消息中的每个符号在 0-1 间隔中取一个子间隔，对应于它的概率。
为了计算每个符号的概率，应该给出一个频率表作为算法的输入。该表将每个字符映射到其频率。
符号越频繁，分配给它的比特数越少。结果，减少了表示整个消息的总位数。这与在霍夫曼编码中对消息中的所有符号使用固定数量的比特相比较。
频率表
要使用 AE 对信息进行编码(=压缩)，您需要以下输入:
要编码的消息。
信息中所有可能符号的频率表。
- 频率表通常通过分析不同的消息并根据每个符号重复的次数得出结论来计算。
- 例如:假设待编码的消息仅由 3 个符号 a 、 b 和 c 组成。通过分析一些以前的消息(例如 babb、cbab 和 bb)，我们得到 3 个符号的频率:
a=2
b=7
- c=1
- 根据频率表，如何使用 AE 对类似于 abc 的消息进行编码？在开始编码之前，你需要从频率表中计算出一个概率表。
- 概率表
使用频率表，我们可以计算每个符号出现的概率。概率计算如下:
符号的频率/所有符号的频率之和
根据频率表，以下是我们 3 个符号的概率:
p(a)=2/10=0.2
p(b)=7/10=0.7
p(c)=1/10=0.1
- 给定消息和概率表，AE 可以开始编码过程。
- 编码
- AE 中的编码工作原理是表示一条线上所有符号的累积概率，范围从 0.0 到 1.0。在那一行，每个符号使用一个子范围。
给定任何符号 C，它从值开始，到使用以下公式计算的值结束:
S+(P(C))R*
其中:
s:所有先前概率的累积和。
P(C):符号 C 的概率。
r:线的范围，通过从线的末端减去起点来计算。
一开始，这条线从 0.0 开始，到 1.0 结束，因此 R=1.0。
- 让我们计算 3 个符号 a 、 b 、 c 的起始值和结束值。
- 对于第一个符号， a ，从 0.0 开始到 0.0+(0.2)*1.0=0.2。起始值为 0.0，因为它是第一个符号。范围是(0.0:0.2)。
- 对于第二个符号， b ，从 0.2 开始到 0.2+(0.7)*1.0=0.9。范围是(0.2:0.9)。
第三个符号， c，从 0.9 开始到 0.9+(0.1)*1.0=1.0。范围是(0.9:1.0)。
给定所有符号的范围，最好用图形表示它们，如下图所示:
- 以下是一些注意事项:
- 第一个符号从线的相同起点(0.0)开始，最后一个符号在线的终点(1.0)结束。
- 符号 C 覆盖了与其概率相对应的范围的百分比。例如，符号 b 覆盖了 70%的线，因为它的概率是 0.7。
限制间隔
- AE 的工作原理是限制行间隔，行间隔从 0.0 到 1.0，通过一些等于消息中符号数的阶段。在这个例子中，消息中只有 3 个符号，所以只有 3 个阶段。
- 在每个阶段，根据当前符号的子间隔来限制线的间隔。
处理完所有符号后，AE 返回一个编码整个消息的单个 double 值。
现在，是时候查看要编码的消息， abc ，并处理第一个符号 a 以限制行间隔。基于上图，符号 a 覆盖了从 0.0 到 0.2 的区间。此间隔成为线条的间隔。换句话说，线间距从 0.0:1.0 变为 0.0:0.2，如下图所示。注意，符号 a 从 0.0 开始，最后一个符号c结束于 0.2。
为了计算每个符号的间隔，我们将使用已经提到的公式:
S+(P(C))R*
因为线的范围变了，R 变成 0.2-0.0=0.2。让我们计算每个符号的起始值和结束值:
对于第一个符号， a ，从 0.0 开始到 0.0+(0.2)*0.2=0.04。起始值为 0.0，因为它是第一个符号。范围是(0.0:0.04)。
对于第二个符号 b ，从 0.04 开始到 0.04+(0.7)*0.2=0.18。范围是(0.04:0.18)。
第三个符号 c 从 0.18 开始到 0.18+(0.1)*0.2=0.2。范围是(0.18:0.2)。
在第一阶段结束时，下图显示了每个符号间隔的起始值和结束值。
- 请注意，每个符号都占据了等于其概率的线的一部分。例如，符号 b 的概率是 0.7，因此它占据了线的间隔的 70%。
- 下图总结了 AE 在这一点上的进展。让我们开始第二阶段，这只是重复我们在第一阶段所做的。
- 消息中的下一个符号是 b 。根据最新的行间隔(0.0 到 0.2)，符号 b 从 0.04 到 0.18 开始。在这个阶段，线的区间将进一步限制为 b 的区间，如下图所示:
因为线的间隔变为(0.04:0.18)，所以 R 也改变。它的新值是 0.18-0.04=0.14。让我们计算每个符号的起始值和结束值:
对于第一个符号， a ，从 0.04 开始到 0.04+(0.2)*0.14=0.068。范围是(0.04:0.068)。
对于第二个符号， b ，从 0.068 开始到 0.068+(0.7)*0.14=0.166。范围是(0.068:0.166)。
第三个符号， c，从 0.166 开始到 0.166+(0.1)*0.14=0.18。范围是(0.166:0.18)。
下图总结了 3 个符号的间隔。这标志着第二阶段的结束。
- 为了总结到目前为止所取得的进展，下图连接了两个完成的阶段。让我们进入第三阶段。
- 消息中的第三个也是最后一个符号是 c 。根据最新阶段，该符号落在从 0.166 开始到 0.18 结束的范围内。 c 根据下一个数字，当前间隔将是生产线的下一个间隔。这条新线的 r 为 0.18-0.166=0.014。
- 在那一行，类似于前两个阶段，这是 3 个符号的间隔:
符号 a 从 0.166 开始到 0.166+(0.2)*0.014=0.1688。范围是(0.166 :0.1688)。
符号 b 从 0.1688 开始到 0.1688+(0.7)*0.014=0.1786。范围是(0.1688 :0.1786)。
符号 c 从 0.1786 开始到 0.1786+(0.1)*0.014=0.18。范围是(0.1786:0.18)。
间隔反映在下图中。
- 消息中没有更多符号。下图总结了从初始间隔(0.0:1.0)到最后一个间隔(0.166:0.18)的计算。
- 假设 AE 完成了编码过程，那么下一小节将计算对整个消息进行编码的单个数字。
单值编码报文
AE 达到的最新区间从 0.166 开始到 0.18。在此范围内，任何值都可以用来编码整个消息。例如，该值可以是 0.17 。
在本教程中，该值是间隔的平均值，即:
(0.166+0.18)/2 = 0.173
因此，基于所使用的频率表，消息 abc 被编码为值 0.173 。当频率表改变时，对消息进行编码的值也会改变。
这标志着编码过程的结束。现在我们来讨论解码过程。
解码
解码的输入有:
对消息进行编码的单个值。
频率表。它应该与用于编码的相同。
原始消息中的符号数。
在我们的例子中，编码消息的值是 0.173 。频率表为【a = 2，b=7，c = 1】。消息中的符号数是 3。
解码的第一步是根据频率计算符号的概率，类似于我们之前所做的。
- 概率表为【p(a)= 0.2，p(b)=0.7，p(c)= 0.1】。基于概率表，通过构造相同的间隔，解码过程类似于编码。
- 首先，根据下图创建一条从 0.0 开始到 1.0 结束的线。使用用于编码消息的相同等式来计算 3 个符号的间隔。
- S+(P(C))R*
值 0.173 落在第一个区间内(0.0:0.2)。因此，编码消息中的第一个符号是 a 。因此，线的间隔被限制为从 0.0 到 0.2 开始的间隔。
值 0.173 落在第二个区间内(0.04:0.18)。因此，编码消息中的第二个符号是 b 。在下图中，间隔将被限制在 0.04 到 0.18 之间。
值 0.173 落在第三个区间(0.166:0.18)内。这就是为什么消息中的下一个符号是 c 的原因。
记住原始消息中的符号数是 3 。解码 3 个符号后，解码过程完成。解码后的消息是 abc 。
让我们看另一个例子。
实施例 2
在这个例子中，我不会像以前那样详述步骤。
有 4 个符号可用于构建消息—a、 b 、 c 和 d 。这些符号的频率是:
a=2
b=3
c=1
d=4
根据频率表，符号的概率如下:
p(a)=2/10=0.2
- p(b)=3/10=0.3
- p(c)=1/10=0.1
- p(d)=4/10=0.4
- 下图显示了符号的累积概率，其中每个符号的间隔等于其概率。
现在，该对消息进行编码了，即 bdab 。
- 在第一阶段，该消息中的第一个符号 b 被处理。间隔将被限制为从 0.2 到 0.5 开始的 b 的间隔。
- 在第二阶段，消息中的下一个符号是 d 。如下图所示，线的间隔将被限制为从 0.38 到 0.5 开始的 d 的间隔。
- 因为消息中的下一个符号是 a ，所以第三阶段的间隔被限制为从 0.38 开始，到 0.404 结束。
- 在第四个也是最后一个阶段，下一个符号是 b ，所以间隔被限制在 0.3848 到 0.392 之间。
最后一个阶段结束时，区间从 0.3848 到 0.392。为了对整个消息进行编码，可以使用间隔内的任何值。
本例中使用平均值，即 0.3884。这标志着编码过程的结束。
(0.3848+0.392)/2 = 0.3884
给定以下 3 个输入，解码过程开始:
对消息编码的值， 0.3884 。
频率表。
消息的长度， 4 。
解码器从准备概率表开始，类似于编码器。请注意，解码器构建了与上图相同的图形。
解码过程是这样的:
通过检查从 0.0 到 1.0 的初始区间，值 0.3884 落在符号 b 的区间内。因此，消息中的第一个符号是 b 。
- 在从 0.2 到 0.5 开始的下一个区间中，值 0.3884 落在从 0.38 到 0.5 开始的 d 的区间内。因此，第二个符号是 d 。
- 下一个区间被限制为值 0.3884 落在符号 a 的区间内的 d 的区间。因此，第三个符号是 a 。
- 在下一个间隔中，值 0.3884 落在符号 b 的间隔内，因此消息中的第四个也是最后一个符号是 b 。
经过一些等于消息长度的阶段，即 4 ，解码后的消息为 bdab 。
至此，算术编码背后的理论已经很清楚了。我们准备用 Python 实现这个算法。
-
在开始之前，我们将讨论一个称为 decimal 的重要模块，它对于成功实现 AE 算法至关重要。
-
十进制模块
-
AE 技术将整个消息(无论其长度如何)编码成一个浮点数。
在 Python 中，float 数据类型被限制为有限数量的十进制数字。Python float 不能精确地保存超过这个十进制位数的数字。使用 structseq sys.float_info 中的 dig 属性返回精确的位数，如下一个代码(文档参考)所示。
例如，当创建一个值为 123456789.12345678998 的浮点变量时，实际存储的值是 123456789.12345679，与原始值不同。
在 AE 中，这是一场灾难，因为每个数字都有所不同。为了让 AE 使用 float 类型，消息必须限制为几个符号。
在 Python 中，有一个称为 decimal 的模块，它使用用户定义的精度。您可以存储任意位数的数字(文档参考)。
小数值的默认精度是 28，由 getcontext()返回。prec 属性。
如果要存储的数字超过精度 28，则该精度可以改变。下一行将精度设置为 1500。
根据本页，32 位系统的最大精度为 425000000。对于 64 位系统，它是 99999999999999999。这足以编码巨大的信息。
import sys
print(sys.float_info.dig)
下一小节创建一个十进制值。
print(float(123456789.12345678998))
创建一个小数值
decimal 模块有一个名为 Decimal 的类，它创建十进制值。下面是一个例子。这样，可以创建任意精度的数。
from decimal import getcontext
getcontext().prec
请注意，精度只在进行算术运算时才重要。即使创建的十进制值的精度超过 getcontext()中指定的精度。prec，十进制值将不受该精度的限制。只有在做算术运算的时候才会受到限制。
getcontext().prec = 1500
在接下来的代码中，我们创建了一个存储大数的十进制值。打印时，将返回该值，不会丢失任何数字。
print(decimal.MAX_PREC)
当应用算术运算时，比如在数字上加 1，getcontext()中的精度。prec 属性将生效，以限制小数位数。下一个代码的结果将是 1234567910432815552，其中末尾的一些数字被剪裁。
要解决此问题，您应该提高精度。
改变精度
from decimal import Decimal
a = Decimal(1.5)
decimal 模块允许您通过为 get context()prec 设置一个大于缺省值 28 的值来提高精度。在将精度设置为 40 之后，下一个代码的结果是 12345679104328155517578125，其中没有剪裁的数字。
现在让我们构建算术编码算法的 Python 实现。
a = Decimal(‘123456789.12345679104328155517578125’)
Python 实现
b = a + 1
print(b)
我们将 AE 的实现构建为一个名为 ArithmeticEncoding 的类，位于一个名为 pyae.py 的模块中。
传递给该方法的频率表是一个字典，其中每一项都有一个表示符号的字符串键和一个表示频率的整数值。这里有一个例子:
构造函数调用一个名为 get_probability_table()的方法。它接受频率表并返回存储在 probability_table 实例属性中的概率表。
下面是 get_probability_table 方法的实现。它只是将每个符号的频率除以表中所有频率的总和。
getcontext().prec = 40
a = Decimal('123456789.12345679104328155517578125')
b = a + 1
print(b)
返回的概率表是一个类似于用于频率的字典。这是之前频率表的概率表。
编码器
ArithmeticEncoding 类有一个名为 encode()的方法对消息进行编码。它接受两个参数:
msg:要编码的消息。
def __init__(self, frequency_table):
self.probability_table = self.get_probability_table(frequency_table)
概率表:概率表。
{"a": 2,
"b": 3,
"c": 1,
"d": 4}
下面是 encode()方法的实现。它有一个迭代次数等于消息长度的循环。
在每次迭代中，使用 process_stage()方法在一个阶段中处理消息的一个符号。该方法简单地接受概率表和当前间隔，并返回当前阶段内每个符号的间隔的字典。
def get_probability_table(self, frequency_table):
total_frequency = sum(list(frequency_table.values()))
probability_table = {}
for key, value in frequency_table.items():
probability_table[key] = value/total_frequency
return probability_table
这是第一次迭代后返回的字典。这个字典被附加到一个名为 encoder 的列表中，该列表保存了所有阶段的间隔。
{'a': 0.2,
'b': 0.3,
'c': 0.1,
'd': 0.4}
根据消息中的下一个符号和 process_stage 方法返回的结果，确定新的间隔。
处理完所有阶段后，调用 get_encoded_value()方法。它返回对整个消息进行编码的值。该值是上一阶段间隔的平均值。
在本例中，该值为 0.3884。除了编码器列表之外，编码器还返回这个值。当消息是 bdab 时，下面是编码器列表。列表中的每一项都是代表一个阶段的字典。每个字典保存每个符号的音程。
- 解码器
- 解码器是使用下面列出的 decode()方法在 ArithmeticEncoding 类中实现的。它接受以下三个参数:
encoded_msg:编码消息的值。
def encode(self, msg, probability_table):
encoder = []
stage_min = Decimal(0.0)
stage_max = Decimal(1.0)
for msg_term_idx in range(len(msg)):
stage_probs = self.process_stage(probability_table, stage_min, stage_max)
msg_term = msg[msg_term_idx]
stage_min = stage_probs[msg_term][0]
stage_max = stage_probs[msg_term][1]
encoder.append(stage_probs)
stage_probs = self.process_stage(probability_table, stage_min, stage_max)
encoder.append(stage_probs)
encoded_msg = self.get_encoded_value(encoder)
return encoder, encoded_msg
msg_length:原始消息长度。
概率表:编码过程中使用的概率表。
{
'a': [Decimal('0.0'), Decimal('0.2')],
'b': [Decimal('0.2'), Decimal('0.5')],
'c': [Decimal('0.5'), Decimal('0.6')],
'd': [Decimal('0.6'), Decimal('1.0')]
}
它的工作方式类似于 encode()消息，因为它会遍历一些等于消息长度的迭代。
通过每次迭代，调用 process_stage()方法来查找每个符号的间隔。对这些间隔进行检查，以找到限制消息编码值的间隔。
一旦定位到间隔，其对应的符号就是原始消息中的下一个。
[
{'a': [Decimal('0'),
Decimal('0.2')],
'b': [Decimal('0.2'),
Decimal('0.5')],
'c': [Decimal('0.5'),
Decimal('0.6')],
'd': [Decimal('0.6'),
Decimal('1.0')]},
{'a': [Decimal('0.2'),
Decimal('0.26')],
'b': [Decimal('0.26'),
Decimal('0.35')],
'c': [Decimal('0.35'),
Decimal('0.38')],
'd': [Decimal('0.38'),
Decimal('0.5')]},
{'a': [Decimal('0.38'),
Decimal('0.404')],
'b': [Decimal('0.404'),
Decimal('0.44')],
'c': [Decimal('0.44'),
Decimal('0.452')],
'd': [Decimal('0.452'),
Decimal('0.5')]},
{'a': [Decimal('0.38'),
Decimal('0.3848')],
'b': [Decimal('0.3848'),
Decimal('0.392')],
'c': [Decimal('0.392'),
Decimal('0.3944')],
'd': [Decimal('0.3944'),
Decimal('0.404')]},
{'a': [Decimal('0.3848'),
Decimal('0.38624')],
'b': [Decimal('0.38624'),
Decimal('0.3884')],
'c': [Decimal('0.3884'),
Decimal('0.38912')],
'd': [Decimal('0.38912'),
Decimal('0.392')]}
]
一旦找到等于消息长度的多个符号，解码过程结束。
完整代码
pyae.py 模块的完整代码如下所示。要获得最新的代码，请查看这个 GitHub 项目。
- 使用 pyae 的例子。算术编码类
- 使用 pyae。算术编码类，请按照下列步骤操作:
导入 pyae
实例化算术编码类
准备一条信息
def decode(self, encoded_msg, msg_length, probability_table):
decoder = []
decoded_msg = ""
stage_min = Decimal(0.0)
stage_max = Decimal(1.0)
for idx in range(msg_length):
stage_probs = self.process_stage(probability_table, stage_min, stage_max)
for msg_term, value in stage_probs.items():
if encoded_msg >= value[0] and encoded_msg <= value[1]:
break
decoded_msg = decoded_msg + msg_term
stage_min = stage_probs[msg_term][0]
stage_max = stage_probs[msg_term][1]
decoder.append(stage_probs)
stage_probs = self.process_stage(probability_table, stage_min, stage_max)
decoder.append(stage_probs)
return decoder, decoded_msg
对信息进行编码
破译信息
下面是使用 frequency_table 变量中给出的频率表对消息 bdab 进行编码的示例代码。
from decimal import Decimal
class ArithmeticEncoding:
"""
ArithmeticEncoding is a class for building arithmetic encoding.
"""
def __init__(self, frequency_table):
self.probability_table = self.get_probability_table(frequency_table)
def get_probability_table(self, frequency_table):
"""
Calculates the probability table out of the frequency table.
"""
total_frequency = sum(list(frequency_table.values()))
probability_table = {}
for key, value in frequency_table.items():
probability_table[key] = value/total_frequency
return probability_table
def get_encoded_value(self, encoder):
"""
After encoding the entire message, this method returns the single value that represents the entire message.
"""
last_stage = list(encoder[-1].values())
last_stage_values = []
for sublist in last_stage:
for element in sublist:
last_stage_values.append(element)
last_stage_min = min(last_stage_values)
last_stage_max = max(last_stage_values)
return (last_stage_min + last_stage_max)/2
def process_stage(self, probability_table, stage_min, stage_max):
"""
Processing a stage in the encoding/decoding process.
"""
stage_probs = {}
stage_domain = stage_max - stage_min
for term_idx in range(len(probability_table.items())):
term = list(probability_table.keys())[term_idx]
term_prob = Decimal(probability_table[term])
cum_prob = term_prob * stage_domain + stage_min
stage_probs[term] = [stage_min, cum_prob]
stage_min = cum_prob
return stage_probs
def encode(self, msg, probability_table):
"""
Encodes a message.
"""
encoder = []
stage_min = Decimal(0.0)
stage_max = Decimal(1.0)
for msg_term_idx in range(len(msg)):
stage_probs = self.process_stage(probability_table, stage_min, stage_max)
msg_term = msg[msg_term_idx]
stage_min = stage_probs[msg_term][0]
stage_max = stage_probs[msg_term][1]
encoder.append(stage_probs)
stage_probs = self.process_stage(probability_table, stage_min, stage_max)
encoder.append(stage_probs)
encoded_msg = self.get_encoded_value(encoder)
return encoder, encoded_msg
def decode(self, encoded_msg, msg_length, probability_table):
"""
Decodes a message.
"""
decoder = []
decoded_msg = ""
stage_min = Decimal(0.0)
stage_max = Decimal(1.0)
for idx in range(msg_length):
stage_probs = self.process_stage(probability_table, stage_min, stage_max)
for msg_term, value in stage_probs.items():
if encoded_msg >= value[0] and encoded_msg <= value[1]:
break
decoded_msg = decoded_msg + msg_term
stage_min = stage_probs[msg_term][0]
stage_max = stage_probs[msg_term][1]
decoder.append(stage_probs)
stage_probs = self.process_stage(probability_table, stage_min, stage_max)
decoder.append(stage_probs)
return decoder, decoded_msg
以下是代码打印的消息。因为十进制模块中使用的精度足以对消息进行编码，所以消息被成功解码。
深度学习的应用
一个高度感兴趣的深度学习 AE 应用是图像和视频压缩。
- 它与深度自动编码器一起使用，以非常小的每像素位数(bpp)实现高质量的图像压缩。
- 最近使用 AE 的论文之一是:程，，等“通过时空能量压缩学习图像和视频压缩”IEEE 计算机视觉和模式识别会议论文集。2019.
- 下一张图摘自总结事物如何工作的论文。
- 分析转换块表示自动编码器的编码器。它的潜在向量被馈送到量化步骤。使用算术编码对量化的输出进行编码。编码量化向量的值被转换成二进制。
- 然后，使用算术编码对二进制串进行解码，以馈送到代表自动编码器解码器的合成变换块。
结论
import pyae
frequency_table = {"a": 2,
"b": 3,
"c": 1,
"d": 4}
AE = pyae.ArithmeticEncoding(frequency_table)
original_msg = "bdab"
print("Original Message: {msg}".format(msg=original_msg))
encoder, encoded_msg = AE.encode(msg=original_msg,
probability_table=AE.probability_table)
print("Encoded Message: {msg}".format(msg=encoded_msg))
decoder, decoded_msg = AE.decode(encoded_msg=encoded_msg,
msg_length=len(original_msg),
probability_table=AE.probability_table)
print("Decoded Message: {msg}".format(msg=decoded_msg))
print("Message Decoded Successfully? {result}".format(result=original_msg == decoded_msg))
我对算术编码算法的介绍到此结束。AE 将整个消息编码成一个浮点数。
Original Message: bdab
Encoded Message: 0.3884
Decoded Message: bdab
Message Decoded Successfully? True
我们基于两个例子讨论了 AE 的详细步骤，在这两个例子中，编码器和解码器是如何工作的是很清楚的。
我们还构建了这个算法的一个 Python 实现，可以在 GitHub 上找到。
该实现只有一个名为 pyae.py 的模块，其中有一个名为 ArithmeticEncoding 的类来构建算法。
算术编码在深度学习中的一个很酷的应用是压缩高质量的图像，同时实现非常低的每像素位数(bpp)率。
在后面的教程中，我将提供更多关于算术编码的细节，比如对算术编码应用的深入讨论。该实现将扩展到处理各种类型的数据。此外，从编码过程返回的十进制值将被转换为二进制。
现在，感谢阅读！
The Analysis Transform block represents the encoder of the autoencoder. Its latent vector is fed to a quantization step. The output of the quantization is encoded using arithmetic encoding. The value that encodes the quantized vector is converted into binary.
The binary string is then decoded using the arithmetic encoding to be fed to the Synthesis Transform block which represents the decoder of the autoencoder.
Conclusion
This concludes my introduction to the arithmetic encoding algorithm. AE encodes the entire message into a single floating-point number.
We went over the detailed steps of AE based on 2 examples, within which it is clear how the encoder and the decoder work.
We also built a Python implementation of this algorithm which is available on GitHub.
The implementation has just a single module named pyae.py, which has a class named ArithmeticEncoding that builds the algorithm.
One cool application of arithmetic encoding in deep learning is compressing images with high quality while achieving a very low bits per pixel (bpp) rate.
In later tutorials, I’ll provide more details about arithmetic encoding, like an in-depth discussion of the applications of arithmetic encoding. The implementation will be extended to work with various types of data. Also, the decimal value returned from the encoding process will be converted into binary.
For now, thanks for reading!
日志分析的机器学习方法:如何分析日志？
原文：https://web.archive.org/web/https://neptune.ai/blog/machine-learning-approach-to-log-analytics
日志在软件系统的开发和维护中起着很大的作用。使用日志，开发人员和工程师可以分析系统的每一层发生了什么，并跟踪问题。尽管有大量的分布式日志数据，但充分分析这些数据仍然是一个巨大的挑战。
在本文中，我们将讨论手动日志分析的主要问题，并了解为什么机器学习是这一挑战的解决方案。
在收集和解析来自不同来源的日志后，日志分析工具分析大量数据，以找到与任何应用程序或系统错误相关的问题的主要原因。
这些工具对于在一个集中的位置监视、收集和评估日志是必不可少的。这样，用户可以从收集的日志数据中获得系统级的洞察力。您可以快速排除故障、修复问题，并找到有意义的行为模式来指导业务决策、调查和安全。
现代软件系统会生成大量日志，这使得基于手动查询级别匹配或基于规则的策略使用传统日志分析工具检查日志变得不切实际。
传统日志分析问题
在进行传统日志分析之前，我们首先需要定义日志分析本身，并了解为什么它对公司至关重要。
事实上，日志分析是审查和理解计算机生成的日志消息，如日志事件或审计跟踪记录(由计算机、网络、防火墙、应用服务器和其他 it 系统生成)。
它被组织用来提高性能和解决问题。它还可以降低各种风险，响应安全策略，理解在线用户行为，并在调查期间进行取证。
Steps of log analysis (source)
现代软件系统规模和复杂性的不断增加扩大了日志的数量，使得传统的手动日志检查变得不合理。事实上，现代软件系统会生成大量日志。例如，任何商业云应用程序每小时都会产生数千兆字节的数据。使用传统方法无法区分来自日常业务活动的数据和来自恶意活动的数据。
手动日志分析取决于运行分析的人员的熟练程度。如果他们对系统有深入的了解，他们可能会获得一些手动检查日志的动力。然而，这有严重的局限性。这使得整个团队处于一个人的支配之下。只要这个人联系不上，或者无法解决问题，整个运营就处于风险之中。
答案是机器学习日志分析
机器学习即使不能解决传统日志分析的挑战，也可以成为解决方案的一部分。
计算机已经证明它们能打败人类。在有大量数据的任务中，这种能力使机器能够驾驶汽车，识别图像和检测网络威胁。
借助机器学习驱动的日志分析，技术团队可以摆脱常规和可重复的任务，工程师可以专注于机器无法完成的其他任务。喜欢解决问题的任务，并思考创新的新产品。
机器学习对日志分析的好处
将机器学习与日志分析工具结合使用可以让我们:
- 快速分类数据:日志可以被视为文本数据，这意味着可以应用 NLP 技术以有组织的方式收集相同的日志，从而可以搜索特定类型的日志。
- 自动识别问题:ML 的好处之一是它可以自动检测问题，即使有大量的日志。
- 警报关键信息:许多日志分析工具会创建过多的警报，而在大多数情况下，这些警报并不是真正问题的原因。有了 ML，就有可能在有值得关注的事情时得到提醒。这样，我们就克服了误报警报的问题。
- 早期异常检测:在大多数灾难性事件中，总会有未被检测到的初始异常。机器学习可以在这种异常造成重大问题之前检测到它。
在本节中，我们将列出使用机器学习进行监控的最佳日志分析工具，并定义如何在它们之间进行选择。我们将通过回顾 10 大日志分析工具来做到这一点。
1。珊瑚
Coralogix 是一家希望将自动化和智能化引入日志记录的初创公司。他们正在构建一个由机器学习支持的远程监控和管理工具，该工具提供了一个分析平台来改善网络的交付和维护流程。用户有一个理想的平台来查看所有实时日志流，定义仪表板小部件以最大限度地控制数据，并将日志数据聚集回原始模式。
2. Datadog
Datadog 是一个日志分析工具，通过一个位于 SaaS 的数据分析平台提供对服务器、数据库、工具和服务的监控。Datadog 的可视化以图形的形式显示日志数据，这使您可以可视化网络性能随时间的变化。Datadog 使用集中式数据存储来保护日志数据不被泄露，并使用机器学习来检测异常日志模式和问题。
3。网络安全管理软件产品/ Loggly
Loggly 是日志数据管理的 SaaS 解决方案。用户可以简单地从整个基础架构中汇总日志，并将它们放在一个位置来跟踪活动和分析趋势。Loggly 有多种用途，例如监控应用程序分析、排除服务器和应用程序问题、事务关联和警报。它提供了不同的高级功能，如动态字段资源管理器、自动警报、默认或自定义仪表板以及派生的日志字段。
4。逻辑监视器
Logic Monitor 是一个基于 SaaS 的性能监控平台，能够监控对业务至关重要的数据，以便您能够快速响应问题并主动提供解决方案。它在一个组合视图中提供网络、云、服务器等的全栈可见性。
5。logz . io
**Logz.io 提供了一个可扩展的智能机器数据分析平台，构建于 ELK 和 Grafana 之上，用于监控现代应用。它将云原生的简单性和可扩展性与众包机器学习相结合，以在大问题发生前识别它们。用户可以使用一个统一的平台对任务关键型应用程序进行监控、故障排除和保护。
6。语义文本
Sematext 是一个基于云的日志管理和分析工具。这是麋鹿的在线实现。它也可通过 Sematext Enterprise 用于自托管解决方案。Sematext 是一个统一的平台，提供一体化解决方案，用于基础设施监控、应用性能监控、日志管理、真实用户监控和综合监控，为您的整个技术体系提供统一、实时的可观察性。
7 .。Splunk
Splunk 是流行的商业日志集中工具之一。典型的部署是内部部署(Splunk Enterprise)，尽管它也作为服务提供(Splunk Cloud)。它有实时警报。它们可以通过电子邮件或 RSS 发送。警报具有可配置的阈值和触发条件，以确定哪些活动将生成通知。警报中包含的支持信息有助于缩短事件解决时间。
8。SumoLogic
Sumo Logic 是一个日志管理工具，用于协作、操作、开发和保护应用程序。它具有强大的搜索语法，有助于以类似于 UNIX 管道的方式定义操作。它还是一个基于云的机器数据分析平台，旨在主动识别性能问题，确保无缝设备可用性，并增强应用部署。此外，Sumo 逻辑包括内置的模式检测、预测分析和异常检测。
9。x 测井
XpoLog 是一个用于全自动日志管理的端到端解决方案。它旨在收集和解析来自 It 基础设施、云应用程序和服务器的日志数据。此外，它还提供了分析工具、报告引擎、监控引擎、关联功能、事务跟踪和日志监控搜索引擎。Xpolog 支持无代理和基于代理的架构，这意味着它可以通过 SSH 之类的标准协议访问日志。
10。斑马鱼
Zebrium 是一款用于监控日志结构的软件，使用无监督的机器学习来自动捕捉软件事件并显示其根本原因。该工具通过查找日志和指标中相关异常模式的热点来工作。该软件提供 AES-256 加密，并通过 Slack 接收警报。
我们已经建立了一个 10 个日志分析工具比较表，以便于更好地审查。
| 工具 | 赞成的意见 | 骗局 | 最适合 |
|---|---|---|---|
更快的搜索体验，强大的日志聚合和警报功能。出色的客户支持。自动数据聚类、闲置提醒和电子邮件。
|
每天的日志量有限，不是每月。
|
小企业和创业公司。
|
| |
强大的预警和警告配置，大幅减少误报。良好的 API 文档，响应迅速的客户服务。
| 一些用户抱怨成本失控(由于灵活定价的可能性)。 |
中小型公司。
|
| |
良好的搜索功能，可以选择在一个集中的地方收集和分析来自许多不同来源的日志。用户还可以在 Slack、HipChat 或吉拉等不同平台上发布警报和创建票证。
| 用户界面不是很漂亮。基本功能，如 API 访问或多用户，仅在较高的定价计划中可用。 |
部署到云环境而非本地环境的组织。
|
| |
非常详细和精确地监控各种设备和环境，包括云环境和内部环境。自定义可视化仪表板和许多预配置的丰富仪表板。
| Web UI 有时需要刷新以显示更改，这很烦人。重新考虑入门级产品的定价，以便较小的组织可以使用该工具。 |
中型和大型公司。
|
| |
良好的搜索，易于使用，包括过滤和格式化功能。出色的警报机制，尤其适用于监控应用。
|
限于创建子账户，这是大公司的一大难题。数据保留不是很好。如果我们达到最大事件摄取量，有时我们可能会丢失事件。
|
基于云的应用。
|
| |
导航简单，界面环境好，没有复杂杂乱。良好的文档和出色的客户支持。
|
只解析服务器端的 Syslog 和 JSON。自定义解析必须在日志传送程序中完成。不能在同一个仪表板中混合 Kibana 和本机 UI 小部件。
|
面向企业和消费者的公司。
|
| |
广泛的功能列表包括机器数据索引、实时和历史搜索，以及高级报告功能。
|
非常昂贵。陡峭的学习曲线，昂贵的部署和高维护。
|
寻找可靠技术以及对公司和品牌的信心的组织。
|
| |
对现代应用不同方面的信息洞察，用于监控和可视化的仪表板，机器学习功能，预测分析功能。
| |
有几根圆木的小组织。
|
| |
非常易于维护和部署自动分析算法，包括大量日志分析和管理功能。
|
比其他工具更小的社区，产品比开发者的社区更注重 IT 和安全。
|
寻求经济实惠的快速部署解决方案的企业和中小型企业。
|
| |
易于使用，自动检测问题和根本原因，无需手动规则。可以用作独立的日志管理工具，也可以作为现有日志管理工具(如 ELK Stack)的 ML 附件。
|
免费计划每天限量 500 MB，保留 3 天。此外，它不像竞争对手那样知名。
|
大型企业，中小型企业。
|
结论
一些日志分析平台使用机器学习来帮助自动检测根本原因和问题，而不需要太多或任何手动分析。
当你选择一个日志分析工具时，不要只看功能和预算，要考虑你能获得的时间。您是想花时间开发自己的日志分析工具，还是更喜欢开箱即用的解决方案，以便专注于您的业务？
最终决定权在你。希望这篇文章能帮助你选择合适的工具！
参考
References**
机器学习即服务:它是什么，什么时候使用它，有什么最好的工具
在过去的十年里，机器学习已经成为不同企业和组织的游戏规则改变者。因此，出现大量定制的基于云的解决方案以多种方式支持数据科学家的工作就不足为奇了。
据福布斯报道，全球机器学习市场预计将从 2020 年的 73 亿美元增长到 2024 年的 306 亿美元，实现 43%的复合年增长率。为了推动这种增长，数据科学家和 ML 工程师的任务是建立更多的模型，以满足客户和股东不断变化的业务需求。
但是，仅仅建立模型通常是不够的:
- 你必须维护这些模型，
- 评估和监控其性能，
- 大规模部署它们，
- 有时尝试新的想法
- 维持生产。
大多数数据科学家都不是软件工程师，因此满足大规模的业务需求有时似乎是不可能的。有了机器学习即服务 (MLaaS)，数据科学家可以(更)轻松地管理这些复杂性。
什么是机器学习即服务？
您可能见过各种“即服务”产品，如平台即服务(PaaS)、软件即服务(SaaS)、后端即服务(BaaS)等。
机器学习即服务 (MLaaS)对于 aaS 来说并不是一个新生事物(没有双关语的意思)，但最近，它受到了很多关注，因为它对数据科学家、机器学习工程师、数据工程师和其他机器学习专业人士来说是多么有用和强大。
机器学习即服务是各种基于云的平台集合的总称，这些平台使用机器学习工具来提供解决方案，可以帮助 ML 团队:
- 各种使用案例的现成预测分析，
- 数据预处理，
- 模型训练和调整，
- 运行业务流程
- 模型部署。
它利用云计算的力量提供移动机器学习服务。
对 MLaaS 平台有什么期望
好吧，但是 MLaaS 平台实际上帮助你做什么？
让我给你举几个例子。
数据管理:随着越来越多的公司将其数据从内部存储转移到云存储系统，正确组织这些数据的需求也随之而来。由于 MLaaS 平台本质上是云提供商，也就是说，它们提供云存储，它们提供了正确管理机器学习实验数据的方法，数据管道化，从而使数据工程师更容易访问和处理数据。
访问 ML 工具 : MLaaS 提供商为企业提供预测分析和数据可视化等工具。他们还为情感分析、人脸识别、信誉评估、商业智能、医疗保健等提供 API。
数据科学家不需要担心这些操作的实际计算，因为它们是由 MLaaS 提供者抽象的。一些 MLaaS 提供商甚至为机器学习实验和模型构建提供了一个拖放界面(当然有其局限性)。
易用性: MLaaS 为数据科学家提供了快速开始机器学习的方法，而不必忍受繁琐的软件安装过程或像大多数其他云计算服务一样提供自己的服务器。借助 MLaaS，提供商的数据中心可以处理实际计算，因此对于企业来说非常方便。
成本效率:构建一个 ML 工作站是昂贵的，在撰写本文时，一个 Nvidia GPU 的价格为 699 美元，而谷歌云 TPU v2 的价格为 4.50 美元。
因此，事实上，当选择云 TPU 时，数据科学家在达到购买 Nvidia GPU 的初始成本时，已经计算了超过 155 个小时的实验。此外，芯片组需要大量的电力才能工作，因此电费将会上升。
MLaaS 在开发阶段也是有益的，因为您只需在实际使用硬件时为其付费。
MLaaS 平台提供了这些解决方案以及更多。让我们简要概述一下提供这些 MLaaS 解决方案的一些平台，以及如何访问它们。
最好的工具
MLaaS 市场相当大，2019 年价值 10 亿美元，预计到 2025 年将达到 84.8 亿美元，我将概述亚马逊、谷歌、微软和 IBM 的一些机器学习即服务平台(是的，所有大公司都有一个)。
让我们开始吧。
亚马逊机器学习服务
亚马逊的预测分析可以说是市场上最好的自动化解决方案之一。它可以从多个来源加载数据，包括亚马逊 RDS、亚马逊 Redshift、微软 SQL Server、MySQL、PostgreSQL、Github、吉拉、Teradata 等。
大多数数据预处理操作都是自动执行的——该服务可以识别哪些字段是分类字段，哪些是数值字段。
这种自动化水平对于 ML 的使用既是优点也是缺点，因为虽然自动预处理节省了时间，但有时处理的数据不符合数据科学家的意图，需要额外的定制(或者您可以自动构建一个实际上没有意义的模型)。
亚马逊通过其亚马逊机器学习服务和亚马逊 SageMaker IDE 提供了一系列强大的机器学习工具。这个平台提供预先训练的人工智能服务，不需要编程经验或机器学习专业知识，便于不太先进的团队使用。它也为更高级的团队提供了一个很好的基线解决方案。
这些服务包括:
这些服务包含非常全面的实施文档，易于理解和使用。
做圣人中的圣人
对于数据科学家来说，亚马逊 Sagemaker Studio 是一个机器学习环境，它通过提供快速模型构建和部署的工具来简化工作流程。它将大多数机器学习工具缝合在一起，使从构建模型到从其界面进行可扩展部署变得容易。
该平台包含 Jupyter notebook，可简化数据探索和分析，而无需麻烦的服务器管理。
此外，内置的 SageMaker 方法在很大程度上与 Amazon 建议的 ML APIs 交叉，但它允许数据科学家使用它们并使用他们自己的数据集。它还允许您添加自己的方法，并通过 SageMaker 利用其部署特性来运行模型。
SageMaker 与 PyTorch、 TensorFlow 、 Keras 、Apache MXNet 等机器学习库整合良好。
一般来说，亚马逊机器学习服务为初学者和有经验的数据科学家都提供了足够的自由。已经使用亚马逊云服务的公司可以使用这些服务，可能不需要过渡到另一家云提供商。
微软 Azure 机器学习工作室
机器学习工作室是一个开发环境，为入门级和有经验的数据科学家创造了一个丰富的游乐场。它拥有从数据分析、数据可视化、数据标记到深度学习的工具。与 Microsoft Windows 一样，Azure ML Studio 中的大多数操作都可以使用图形拖放界面来完成(使其易于使用)。这包括:
- 数据探索，
- 预处理，
- 选择建模方法，
- 验证建模结果。
这个 Azure ML 图形界面可视化了工作流中的每个步骤。要使用 Azure ML studio，不太高级的 ML 团队可以使用 GUI 来更深入地理解主要的方法和模型。后来，他们可以理解一些更复杂的数据科学概念。
Azure ML studio 提供了一个环境，数据科学家可以在其中:
- 建立模型，
- 招待他们，
- 所述模型版本，
- 管理，
- 监控模型。
它还允许这些模型在 Azure、本地甚至边缘设备上运行。它与 Visual Studio 和 Github 集成得很好，使软件工程师能够轻松访问和跟踪开发。ML studio 还支持一些在数据分析过程中有用的数据转换工具。
Azure AI services 是一个托管大量机器学习服务的平台，例如:
Azure AI Gallery 是 Azure ML 的另一大部分。它是由 Azure 社区提供的机器学习解决方案和数据科学模型模板的中心，Azure 社区由开发人员、研究人员、数据科学家、机器学习实践者和创业公司组成。它可供社区成员使用和探索。
人工智能画廊是构建模型和算法的开源中心。它需要一定水平的数据科学能力来操作，并且它还为 ml 模板提供定制模型工程。其数据科学服务产品提供了一个强大的工具集来管理数据科学和机器学习实验，使用 TensorFlow、scikit-learn 等流行框架。(这在 ML Studio 中不可用)。
注意:使用 Azure 的一个主要好处是可以使用多种算法。该工作室支持 100 多种方法，解决分类(二进制+多类)、**、回归、推荐、和文本分析。**
*### 谷歌云平台
谷歌在两个层面上提供其机器学习和人工智能服务:面向精通技术的数据专家的谷歌云机器学习和云自动学习。
Cloud AutoML 是一个基于云的 ML 平台，为初学者数据科学家提供各种机器学习产品。用户可以:
- 上传他们的数据集，
- 训练定制模型，
- 将它们部署在网站上。
Cloud AutoML 与谷歌的所有服务完全集成，并将数据存储在云中。经过训练的模型可以通过 REST API 接口进行部署。它依赖于谷歌最先进的转移学习和神经架构搜索技术。
您可以通过图形界面访问 Cloud AutoML 提供的多种产品，包括:
Cloud AutoML 是为深度学习模型定制的。它实现了自动深度迁移学习(意味着它从现有的在其他数据上训练的深度神经网络开始)和神经架构搜索(意味着它找到了额外网络层的正确组合)，用于语言对翻译和自然语言分类。
虽然 GCP 支持其他语言和框架，但它的重点显然是一个框架:谷歌的宝贝 Tensorflow。
谷歌机器学习引擎迎合有经验的数据科学家。它非常灵活，它建议使用 TensorFlow 的云基础设施作为机器学习框架。它还支持其他流行的算法，如线性学习器、TabNet、XGBoost 等。，以及 scikit-learn 等库。
谷歌还通过其数据工作室来迎合数据科学家和营销人员:这是最流行的可视化数据工具之一。
它可以用来直接从谷歌的营销工具套件中提取数据，包括:
- 谷歌分析，
- 谷歌 AdWords，
- 和谷歌搜索控制台。
它还支持 PostgreSQL 和 BigQuery 等数据库工具的连接器。
IBM 沃森机器学习
IBM Watson Machine Learning 是一个 MLaaS 平台，帮助数据科学家和开发人员加速他们的人工智能和机器学习部署。目前它提供了三种选择:
- IBM Cloud Pak for Data:IBM Cloud for Data 是一套集成的解决方案，可以在生产中自动部署 AI 用例。
- 沃森机器学习云:沃森机器学习云服务是一组 REST APIs，您可以从任何编程语言调用它们来开发应用程序，以做出更明智的决策，解决棘手的问题，并改善用户结果。
- 沃森机器学习服务器:沃森机器学习服务器是一个新的单节点服务器，是 IBM 沃森工作室的一部分，它提供分析资产，如 SPSS Modeler 流和机器学习模型笔记本，可以从沃森工作室桌面部署到沃森机器学习服务器，以获得可扩展的计算资源和部署管理服务的优势
他们都为模型提供 Auto-AI 生命周期管理。凭借其一系列开源工具和技术，IBM Machine Learning 为数据科学家提供了大规模模型部署和模型再训练的灵活性。
它还提供了一系列对企业有用的人工智能应用程序，如聊天机器人、情感分析工具、预测工具等。动态再训练的预训练模型工具通过免费的 IBM Watson OpenScale 平台进行管理。
沃森机器学习还通过其内置的可配置仪表板促进了单个建模空间内的团队协作。它还可以与现有系统轻松集成。
何时不使用 MLaaS
- 如果您的数据需要安全且在本地，那么您可能不应该使用 MLaaS。
- 如果您需要大量的定制和最先进的算法实现，您可能不需要 MLaaS(但它仍然有用)
- 如果您需要优化复杂算法的培训或服务成本，那么您可能希望在本地部署基础架构
何时使用 MLaaS
- 如果您已经在公司使用上述 MLaaS 提供商之一，将他们的 MLaaS 服务集成到您的系统将是一个很好的补充。
- 如果一些/许多用例可以外包给一个预测 API，MLaaS 是一条必由之路。
- 如果您的应用程序生成大量数据，并且您需要经常对这些数据进行测试，那么您肯定应该尝试 MLaaS。
- 如果您在公司中运行基于微服务的架构，MLaaS 将有助于正确管理其中的一些服务。
结论
随着现代世界的复杂性和动态性，在内部构建数据科学中心可能风险太大且不够灵活。MLaaS 是对这个问题的完美回应，能够扩展到无限，然后只需几次点击就可以重新缩放回现代 PC 的大小。
MLaaS 提供了大量的工具和服务，可以帮助您更有效地工作，解决忙碌的数据科学家或数据工程师每天面临的多个问题。最大的优势是不需要从零开始建立基础设施，不需要为机器、设置和维护付费。
小野寺次郎
机器学习工程师和研究员，对人工智能和人类福祉(医疗保健和教育)之间的交叉充满热情。在我的空闲时间，我喜欢尝试新的菜肴和看动漫。
阅读下一篇
MLOps:它是什么，为什么重要，以及如何实施
13 分钟阅读|卡努马王子|发布于 2021 年 1 月 14 日
13 mins read | Prince Canuma | Posted January 14, 2021
根据 techjury 的数据，2020 年每个人每秒至少创建 1.7 MB 的数据。对于像你我这样的数据科学家来说，这就像是提前过圣诞节，因为有太多的理论/想法需要探索、实验，有太多的发现和模型需要开发。
但是，如果我们想要认真对待，并让这些模型真正触及现实生活中的业务问题和真实的人，我们必须处理一些基本问题，如:
获取和清理大量数据；
- 为实验和模型训练运行设置跟踪和版本控制；
- 为投入生产的模型建立部署和监控管道。
- 我们需要找到一种方法来扩展我们的 ML 操作，以满足我们的 ML 模型的业务和/或用户的需求。
在过去，当我们需要扩展传统的软件系统以便更多的人可以使用它们时，也存在类似的问题。DevOps 的解决方案是一套开发、测试、部署和操作大规模软件系统的实践。有了 DevOps，开发周期变得更短，部署速度加快，系统发布变得可审计和可靠。
这就把我们带到了 MLOps 。它诞生于 DevOps 、数据工程、、机器学习的交汇点，与 DevOps 、是类似的概念但执行不同。ML 系统本质上是实验性的，并且有更多的组件，这些组件的构建和操作要复杂得多。
让我们开始吧！
Let’s dig in!
2021 年最好的机器学习大会有哪些？
原文：https://web.archive.org/web/https://neptune.ai/blog/machine-learning-conferences-2021
随着该领域的不断发展和呈现新的可能性，ML 会议越来越受欢迎。会议是交流最新研究成果、向专家学习、建立有助于业务发展的专业关系的绝佳方式。
参加会议是学习和发展技能的最好方式之一。此外，您可以结识新朋友，发现其他人如何在工作中应用机器学习。
为了帮助你做出选择，我们准备了 2021 年关于机器学习的最佳会议列表。但一定要仔细检查议程——由于冠状病毒疫情，许多活动转移到了在线或混合形式，对其他人来说，日期仍然需要确认。
时间:【2021 年 7 月 18 日至 24 日星期六
- 7 月 18 日星期日世博会
- 7 月 18 日至 24 日的会议、教程、研讨会和博览会
其中:仅虚拟
定价:待定。注册于 4 月 13 日开始
机器学习国际会议(ICML)是最好的机器学习会议之一。
ICML 以展示和发布机器学习各方面的前沿研究而闻名全球，这些研究应用于人工智能、统计和数据科学等密切相关的领域，以及机器视觉、计算生物学、语音识别和机器人等重要的应用领域。
时间:2021 年 6 月 21 日–23 日；世博会:2021 年 6 月 22 日至 23 日
地点:慕尼黑或网上
价格:€起价 669-1239
- 团队折扣:注册 3 个以上的同事，享受 10 %的折扣
- 2 合 1 会议特惠，如果您购买 ML 会议门票，可以免费参加物联网会议
- 额外特殊:自由职业者和科学机构的雇员获得个人特殊条件
机器学习创新大会。在这个大会上，你可以了解到机器学习在商业中的应用。
由于今年的疫情，会议采用了混合形式，你可以亲自参加，也可以在线参加。
现场编码和新想法的直接应用，会议，主题演讲和来自商业行业和科学的国际演讲者的有趣演讲，与来自各行各业的人建立联系——你可以参加所有这些活动，学习和认识可以帮助你在职业生涯中进步的专业人士。
此外，您将获得一份官方的机器学习会议证书，证明您的参与。
发言人:
- 托马斯·陈，数学、科学和工程学院
- Debjyoti Paul 教授，亚马逊
- 劳伦·皮卡尔，谷歌
- Pieter Buteneers 博士，Sinch
视频
时间:2021 年 8 月 17 日-19 日
其中:事件具有数字形式
定价:如果你在一个拥有 250 多名员工的组织中工作，担任高级职位和/或技术职务，对我们的受众没有销售兴趣(或为有销售兴趣的公司工作)，你可以申请免费通行证。
在三天的时间里，Ai4 2021 峰会汇集了商业领袖和数据从业者，以促进人工智能和机器学习技术的采用。
大会聚集了来自世界上积极参与人工智能项目的最具创新性的公司的发言者——来自全行业的企业领导者、政府组织、颠覆性创业公司、投资者、研究实验室、学术界、协会、开源项目、媒体和分析师。
在会议期间，您可以了解商业领域最新的人工智能趋势。Ai4 是每个人工智能爱好者都应该参加的最好的机器学习会议之一
时间:2021 年 5 月 6 日
地点:澳大利亚
价格:价格从 495 美元到 1495 美元不等
本次会议提供了深入的见解和用例，检查组织如何利用他们的人工智能战略和发展。它汇集了人工智能技术思想领袖和专家，使人工智能驱动的战略最终推动您的组织走向人工智能的未来。
这是一个专门面向首席信息官、AI/ ML 负责人、创新负责人和数据科学负责人的专业活动。
主要发言人:
- Jonathan Robinson——ANZ 银行数据与分析主管
- uj wal Kayande——墨尔本商学院商业分析中心主任
- Janice Carey–保柏客户数据与分析主管
- sveta Freidman——Carsales.com 数据分析总监
- giovanni Butera——Nixora 集团首席执行官兼总经理
时间和地点:【2021 年 4 月(非最终)，芝加哥
国际软件开发会议汇集了软件开发人员、IT 架构师和项目经理。
GOTO Conferences 是为开发人员、团队领导、架构师和项目经理设计的一系列软件开发会议。每个活动都是开发者为开发者组织的。
由于疫情，会议可能不会举行，所以请确保在线查看更新。
时间:5 月 4 日星期二到 8 日星期六
其中:仅虚拟(原维也纳)
定价:起价 650 美元
第九届国际学习表征会议是专业人士的首要聚会，致力于促进人工智能分支的发展，称为表征学习，通常被称为深度学习。
ICLR 以展示和发布人工智能、统计和数据科学领域中使用的深度学习的所有方面的前沿研究而闻名于世，以及机器视觉、计算生物学、语音识别、文本理解、游戏和机器人等重要应用领域。
ICLR 的参与者背景广泛，从学术和工业研究人员到企业家和工程师，到研究生和博士后。
时间:2021 年 10 月 5 日至 8 日
地点:英格兰湖区格拉斯米尔-英国和在线
定价:
- 早期现场注册费为 580 欧元(不迟于 2021 年 7 月 10 日星期六)；后期现场注册费为 630 欧元
- 早期在线注册费(仅适用于虚拟出席)为 290 欧元(不迟于 2021 年 7 月 10 日星期六)；逾期网上报名费用 340 欧元(2021 年 7 月 11 日起)。
第七届机器学习、优化和数据科学(LOD)年会是关于机器学习、计算优化、大数据和人工智能的国际会议。会议包括邀请讲座、辅导讲座、专题会议、工业跟踪、演示、口头和论文报告。
LOD 已经成为机器学习、计算优化、数据科学和人工智能领域的顶级跨学科会议。它为展示原创的跨学科研究成果以及交流和传播创新和实用的发展经验提供了一个国际论坛。
主题演讲人:
- 英国 Heriot Watt 大学 Verena Rieser
- 英国 DeepMind 的 Ioannis Antonoglou
- 佩奇·贝利，谷歌，美国
- 帕诺斯·帕达洛斯，美国佛罗里达大学
- 还有更多要宣布
时间:2021 年 5 月 19-21 日
其中:在线
定价:
应用人工智能国际会议(ICAPAI 2021)将为分享人工智能和机器学习在工业/现实世界环境中的理论、方法和应用方面的知识和成果提供一个优秀的国际论坛。ICAPAI 2021 欢迎人工智能和机器学习所有子领域的论文。会议旨在为来自学术界和工业界的研究人员和从业人员提供一个平台，以满足和分享有关该领域前沿发展的信息。
您还可以参加 9 月 17 日欧洲中部时间 10:00 举行的免费 ICAPAI 为期一天的网络研讨会！五位主题发言人、主持人和小组成员概述了人工智能在各种应用领域的应用。
时间:【2021 年 9 月 2 日至 3 日
地点:荷兰阿姆斯特丹|虚拟+现场
定价: 作者–650(现场)，400 英镑(虚拟)；参会人员–550 人(现场)，300 人(虚拟)
智能系统大会(IntelliSys) 2021 将专注于智能系统和人工智能(AI)的领域，以及它如何应用于现实世界。IntelliSys 是最受尊敬的人工智能(AI)会议之一。
IntelliSys 提供了一个领先的国际论坛，汇集了来自不同领域的研究人员和从业人员，旨在探索人工智能(AI)的基本角色、交互以及实际影响。
会议的目标是成为研究人员和行业从业者分享各领域新思想、研究成果和发展经验的主要场所。
主题演讲人:
- Elias Fallon(Cadence 设计系统工程组总监)
时间:2021 年 7 月 7 日至 10 日
地点:科罗拉多州博尔德(和/或在线，如有必要)
定价:
第 34 届学习理论年会(COLT 2021)聚集了机器学习领域的专业人士，这是一个了解最新发现和向专家学习的绝佳机会。
主题演讲人:
- Sara van de Geer(苏黎世联邦理工学院)
- 大卫·西尔弗(深度思维)
- 埃娃·塔尔多斯(康奈尔大学)
- persi ddiscois _ 斯坦福大学)
时间:2021 年 7 月 10 日-14 日
地点:仅在线会议
价格:价格从免费到 400 美元不等，取决于你是演讲者还是参与者
遗传和进化计算会议(GECCO)展示了自 1999 年以来遗传和进化计算的最新高质量结果。
主题包括:遗传算法、遗传编程、蚁群优化和群体智能、复杂系统(人工生命、机器人、进化硬件、生殖和发展系统、人工免疫系统)、数字娱乐技术和艺术、进化组合优化和元启发式、进化机器学习、进化多目标优化、进化数值优化、真实世界应用、基于搜索的软件工程、理论等。
时间:【2021 年 10 月 14 日至 15 日
地点:美国马萨诸塞州波士顿
定价:起价 900 美元
有趣的是，这是唯一一次无赞助商、无供应商、无招聘人员的数据科学大会。由于禁止图片/录音/广播的政策，会议赢得了一个安全场所的声誉，发言者可以分享信息，否则他们可能不会。
时间:8 月 14 日-18 日
地点:新加坡
一年一度的 KDD 会议是顶级的跨学科会议，汇集了来自数据科学、数据挖掘、知识发现、大规模数据分析和大数据的研究人员和从业人员。
要了解更多信息，您可以在大会网站上注册订阅时事通讯。
时间:2021 年 8 月 16 日-20 日
地点:丹麦哥本哈根和虚拟
VLDB 是数据管理和数据库研究人员、供应商、从业人员、应用程序开发人员和用户的首要年度国际论坛。VLDB 2021 会议将包括研究讲座、教程、演示和研讨会。
它将涵盖数据管理、数据库和信息系统研究方面的问题，因为它们是 21 世纪新兴应用的技术基石。
时间:2021 年 8 月 1 日-6 日
地点:泰国曼谷伯克利酒店
计算语言学协会第 59 届年会与第 11 届自然语言处理国际联席会议 (ACL-IJCNLP 2021)。与前几年一样，除了主会议之外，会议的计划还包括海报会议、教程、研讨会和演示。
时间:9 月 13 日至 17 日
其中:仅在线
欧洲机器学习会议和数据库中知识发现的原理和实践。该活动是欧洲机器学习和数据挖掘的顶级会议，建立在欧洲各地超过 19 年的成功活动和会议的基础上。
该会议为讨论机器学习、数据挖掘和知识发现相关领域的最新高质量研究成果提供了一个国际论坛。
开放数据科学大会聚集了与会者、演讲者和正在塑造人工智能和数据科学的现在和未来的公司。ODSC 是专业数据科学家最大的聚会之一，主要会议在美国、欧洲和亚洲举行。
何时何地:
- 东部 2021 年–3 月 30 日至 4 月 1 日的虚拟培训会议
- 欧洲 2021–虚拟会议，6 月 8 日至 6 月 10 日
- 西部 2021 年–旧金山，11 月 15 日–11 月 18 日
- APAC 2021 年奥运会–会议，2021 年 12 月
时间:3 月 30 日-4 月 1 日
地点:马萨诸塞州波士顿
价格:价格从 99 美元起
加速人工智能会议系列是高管和商业专业人士会见人工智能和数据科学领域最优秀和最聪明的创新者的地方。该会议汇集了顶级行业高管和 cxo，帮助您了解人工智能和数据科学如何改变您的业务。
涵盖的行业包括金融、医疗保健、生物技术、制药、能源、制造、零售、营销、运输等。
主题演讲人:
- 马克·韦伯——麻省理工学院-INM·沃森人工智能实验室应用研究科学家
- Serena Yeung 博士——斯坦福大学生物医学数据科学助理教授
- 里奇·达顿——谷歌公司工程主管
- 还有更多
何时:
其中:在线/混合会议
价格:价格从 55 美元起，有折扣
我们为您提供所有虚拟活动门票的八折优惠！请随意使用下面的代码，享受这些伟大的会议！
NeptuneVIP
数据科学沙龙是一个独特的垂直聚焦会议，发展成为一个由高级数据科学、机器学习和其他技术专家组成的多元化社区。会议以面对面和虚拟的方式聚集在一起，在轻松的氛围中相互学习，阐明最佳实践并创新新的解决方案。
向从业者、技术专家和高管学习如何通过利用数据、人工智能、机器学习和前沿技术的中断来解决现实世界的问题。每张门票都附带一个月的 DSS Insider 访问权限，这是所有数据科学沙龙的内容存储库。
来自公司的主题演讲人，例如:
- 彭博
- S&P 环球公司
- 富国银行
- 强生公司
- 购物化
- 《纽约时报》
时间:2021 年 8 月 21 日至 26 日
地点:加拿大蒙特利尔
第 30 届国际人工智能联合大会(IJCAI-21 )。
仍然没有太多关于会议的信息，所以请确保定期查看网站更新。现在，有一个在会议上提交论文的呼吁。
21. EACL 2021 年
时间:2021 年 4 月 19 日至 23 日
地点:在线会议
计算语言学协会欧洲分会第 16 届会议(EACL)。
与前几年一样，除了主会议之外，会议的计划还包括海报会议、指导、研讨会和演示。作为计算语言学领域的旗舰欧洲会议，EACL 欢迎欧洲和国际研究人员，他们涵盖了与自然语言的计算方法相关的广泛研究领域。
主题演讲人:
- 梅勒妮·米切尔，圣达菲研究所
- 菲娜达·费雷拉，加州大学戴维斯分校
- 马尔科·巴罗尼，庞贝·法布拉大学
时间:2021 年 6 月 6 日至 11 日
地点:墨西哥墨西哥城
会议主办方正在监控正在进行的全球疫情，并将在会议日期 临近时根据需要更新会议计划(如转向虚拟或混合形式)。
*2021 年计算语言学协会北美分会年会由机器学习专家研讨会组成。
时间:【2021 年 11 月 7 日至 11 日
地点:会议可能在多明尼加共和国举行，但组织者准备根据新冠肺炎局势的发展在网上举行。
2021 年自然语言处理经验方法会议。与近几年一样，会议上的一些报告将是由《美国计算机学会(TACL)学报》和《计算语言学(CL)学报》接受的论文。在这次会议期间，你将能够参加许多有趣的研讨会。
时间:2021 年 6 月 19 日至 25 日
其中:由于新冠肺炎疫情的持续影响和未来的不可预测性，CVPR 2021 将转向虚拟赛事。
CVPR 是首要的年度计算机视觉活动，包括主要会议和几个共同举办的研讨会和短期课程。凭借其高质量和低成本，它为学生、学者和行业研究人员提供了非凡的价值。
Re-Work 主办了几场活动，都致力于人工智能的不同领域。这些活动的常规发言人包括科技巨头谷歌、苹果、DeepMind、亚马逊和脸书，以及世界知名的学术机构、政府领导人、初创公司和投资者。他们还通过播客、白皮书和视频采访提供对当前趋势的分析。
跟随 这个链接可以看到所有 的事件。
时间:2021 年 11 月 27 日至 12 月 5 日
地点:地点即将公布因此，请务必查看官方网站的更新
神经信息处理系统年会的目的是促进神经信息处理系统在生物、技术、数学和理论方面的研究交流。核心焦点是同行评审的新颖研究，在全体会议上介绍和讨论，同时邀请各自领域的领导者进行演讲。
有一个博览会，顶级行业赞助商就学术感兴趣的主题进行演讲、小组讨论、演示和研讨会；教程，涵盖当前调查的广泛背景，会议，等等。
时间:2021 年 10 月 11 日-10 月 17 日
地点:加拿大蒙特利尔
ICCV 是首要的国际计算机视觉事件，包括主要会议和几个共同定位的研讨会和教程。凭借其高质量和低成本，它为学生、学者和行业研究人员提供了非凡的价值。
时间:2021 年 5 月 30 日至 6 月 5 日
其中:TIEEE ICRA 2021 将以混合的形式举行，包括现场会议和云会议
ICRA 2021 大会承诺将是一次伟大的盛会，有着出色的技术和社会项目。将会有关于机器人和自动化各方面的原创研究成果、教程和研讨会，以及关于新主题或创新应用的有组织的会议。还将有来自工业和研究实验室的展品，欢迎参观。
时间:【2021 年 6 月 6 日至 11 日
地点:形式上是加拿大安大略省的多伦多，但由于疫情的情况，它将完全是虚拟的
国际声学、语音、&信号处理会议(ICASSP)，是IEEE 信号处理学会关于信号处理及其应用的旗舰会议。该计划将包括杰出的国际演讲者的主题演讲，前沿的指导主题，以及前瞻性的特别会议。ICASSP 还为来自学术界、工业界和政府机构的志同道合的专业人士提供了一个很好的交流机会。
主题演讲人:
- 卡尔·弗里斯顿
- 摩根大通人工智能研究主管曼努埃拉·贝洛索
- Bernhard schuch head(伯尔尼哈德·施吕特石油公司)
时间:2021 年 9 月 27 日至 10 月 1 日
地点:捷克共和国布拉格
智能机器人和系统国际会议。即将召开的 IROS 2021 大会旨在创造机会，让大家见面、讨论并熟悉机器人、自主智能系统、仿人机器人、医疗机器人等领域的最新进展。与以往一样，IROS 2021 将包括一个大型机器人展览，作为活动的重要组成部分。
时间:2021 年 8 月 17-20 日
地点:哥本哈根 IT 大学
游戏大会(CoG)从传统的计算智能和游戏(CIG)演变而来，旨在汇集游戏领域学术界和工业界的领先研究人员和从业人员，讨论最新进展并探索未来方向。
IEEE CoG 2021 将包括同行评审论文演示、知名行业和学术领袖的特邀演讲、小组讨论、海报和演示。
何时:查看官网最新更新
其中:仅虚拟
SIGGRAPH 正在庆祝 48 年来计算机图形和交互技术的进步。
今年在虚拟环境中，组织者的目标是创造一个高质量的体验，其中将包括研究和技术的突破，激励和推动该领域前进的演讲者，以及合作和享受所有已实现和现在可能实现的社区。主题涵盖了计算机图形学、数字艺术、动画、视觉效果、机器学习、人工智能、沉浸式和混合现实、科学可视化等主题。
时间:2021 年 12 月 7 日至 10 日
其中: ICDM 2021 初步计划在纽西兰的奥克兰举行。但是，由于新冠肺炎疫情带来的环境变化，该格式可能会更新为虚拟或混合格式。查看官方网站的更新..
IEEE 数据挖掘国际会议(ICDM) 涵盖了数据挖掘的所有方面，包括算法、软件、系统和应用。
ICDM 吸引了来自大数据、深度学习、模式识别、统计和机器学习、数据库、数据仓库、数据可视化、基于知识的系统和高性能计算等广泛的数据挖掘相关领域的研究人员、应用程序开发人员和从业人员。通过促进新颖的、高质量的研究成果，以及对具有挑战性的数据挖掘问题的创新解决方案，会议寻求推进数据挖掘领域的最新发展。
时间:2021 年 7 月 14-18 日
地点:美国纽约
ICDM 数据挖掘工业会议每年举行一次。
来自世界各地的研究人员将提出关于数据挖掘的理论和面向应用的主题。
主题包括工业展览最佳论文奖演讲和海报研讨会:基于案例的推理 CBR-MD，营销 DMM 中的 DM，以及 B2ML I-商业到制造和生命科学-物联网和服务。
时间:2021 年 7 月 18 日至 22 日
其中:仅虚拟
国际神经网络联合会议(IJCNN)涵盖了神经网络领域的广泛主题，从生物神经网络到人工神经计算。这是关于机器学习的最受欢迎的会议之一。
主题演讲人:
- 马里奥斯·波利卡普
- 卡尔·j·弗里斯多教授
- 够了萨尔米
- 彼得·蒂诺
- 更多
时间:【2021 年 9 月 14 日至 17 日
地点:布拉迪斯拉发
第 30 届人工神经网络国际会议。
欧洲神经网络学会会议。
ICANN 的理想是将两个世界的研究人员聚集在一起:信息科学和神经科学。范围很广，从机器学习算法到真实神经系统的模型。目的是促进讨论和互动，努力开发更智能的计算系统，增加我们对大脑中神经和认知过程的了解。
时间:2021 年 9 月 13 日至 17 日
地点:意大利莱切
ICIAP 2021 是意大利计算机视觉、模式识别和机器学习研究协会 (CVPL，前 GIRPR)每两年组织一次的系列会议的第 21 届，该协会是国际模式识别协会(IAPR) 的部分。
会议的重点是计算机视觉、模式识别和图像处理的经典和最新趋势，涵盖理论和应用两个方面
主题演讲人:
- Larry S. Davis 教授——美国马里兰大学亚马逊分校
- Roberto Cipolla 教授-英国剑桥大学
- 马頔·阿尔达门教授——英国布里斯托尔大学
- Laura Leal-Taixe 教授-慕尼黑技术大学 GE
时间:2021 年 12 月 8 日至 12 日
地点:印度尼西亚巴厘岛
价格:价格从 250 美元到 800 美元不等
第 28 届国际神经信息处理会议(ICONIP2021)旨在为从事神经科学、神经网络、深度学习和相关领域工作的研究人员、科学家和行业专业人士提供一个领先的国际论坛，分享他们的新思想、进展和成就。
时间:2021 年 7 月 11 日-15 日
其中:仅在线
第 44 届国际 ACM SIGIR 信息检索研究与发展会议。
SIGIR 是展示新研究成果和展示信息检索新系统和新技术的首要国际论坛。会议由五天的完整论文、短文、资源论文、演示、指导、研讨会、博士联盟论文和观点论文组成，重点关注信息检索领域的研究和发展，以及行业跟踪和社会活动。
时间:2021 年 4 月 13 日至 15 日
其中:仅在线
第 24 届人工智能与统计国际会议。自 1985 年成立以来，AISTATS 一直是人工智能、机器学习、统计学和相关领域交叉研究人员的跨学科聚会。
时间:主会:2021 年 7 月 27 日-7 月 29 日；工作坊:2021 年 7 月 30 日
其中:在线
人工智能中的不确定性会议(UAI) 是研究不确定性下的知识表示、学习和推理的顶级国际会议之一。UAI 得到了人工智能不确定性协会(AUAI)的支持。
自 1985 年以来，该会议每年举行一次。
时间:【2021 年 9 月 9 日至 22 日
地点:美国阿拉斯加州安克雷奇
第 28 届 IEEE 国际图像处理会议(简称 IEEE ICIP) 是全球规模最大、最全面的专注于图像和视频处理以及计算机视觉的技术会议。
本次会议将展示世界级的全体演讲者、教程、展览、特别会议、行业会议和工程领域的女性，为促进创新和创业创造了一个绝佳的论坛。将会有机会与这个领域的学术界和工业界最聪明的人交流。此外，面向学生和专业人士的几项活动也将在 IEEE ICIP 2021 大会上展出。
时间:【2021 年 8 月 30 日至 9 月
其中:混合 Brno(捷克)散布有一个完全虚拟的备份选项。
组织这次会议的协会的目的是在国际范围内促进与语言通信科学和技术相关的所有领域的活动和交流。
该协会面向所有对基础研究和技术开发感兴趣的个人和机构，旨在描述、解释和再现人类语音交流的各个方面，即语音学、语言学、计算机语音识别和合成、语音压缩、说话人识别、嗓音疾病医学诊断辅助工具，但不假设这种列举是详尽无遗的。
时间:【2021 年 11 月 18 日至 19 日
其中:在线
本次会议将由数字枢纽卡尔斯鲁厄与枢纽法国 IA 第三次合作主办。
今年，大会的关键主题将是“物联网”，它将在网上组织，同时也有一个混合的组成部分。组织者预计来自德国、法国和世界各地的与会者将齐聚一堂，参加此次活动，其中包括 IT 决策者、商业和技术专家、初创企业和创新者以及政治决策者。
来自世界各地的高级演讲者将谈论人工智能的话题，包括人工智能中的数据空间、网络安全和边缘人工智能。此外，还将举行超过 10 小时的高质量投入和网络活动的互动研讨会。观众将了解人工智能的可能性，他们如何实现它，以及成功使用它们需要什么。
时间:2021 年 11 月 8 日-11 日
其中:在线
价格:免费
NVIDIA GTC 是一个面向创新者、技术人员和创意人员的人工智能会议。它将包含来自人工智能/人工智能、数据中心、网络、图形、自动驾驶汽车等领域的 500 多场演讲。注册是免费的。
主要发言人:
- 英伟达首席执行官黄仁勋
- 费-李非，斯坦福大学计算机科学教授
- Keith Perry，首席信息官，圣裘德儿童研究医院
- PayPal 数据科学总监 Venkatesh Ramanathan
- Epic Games 创始人兼首席执行官蒂姆·斯维尼
- Vijay Narayanan，ServiceNow 首席人工智能官
时间:2021 年 11 月 15-18 日
其中:在线
TMLS 计划致力于帮助促进人工智能/人工智能在所有行业中有效、负责任地发展。此外，为了帮助数据从业者、研究人员和学生快速跟踪他们的学习过程，并在 ML 和 AI 领域发展有益的职业生涯。
组织者致力于通过分享以下内容来提升您的 ML/AI 工作潜力:
- 车间
- 交互式会议演示
- P2P 网络
- 职业机会和招聘
2021 年的主要主题包括:
- 迁移学习
- 特征工程
- 特征存储设计和维护
- 变形金刚(电影名)
- 可解释性
- 模型监控
- MLOps
- 金融、保险、证券、零售、电信等领域的真实业务影响案例研究！
演讲者包括来自 Vector、CIFAR、谷歌、苹果、LinkedIn、HuggingFace、脸书人工智能等公司的高级领导和研究人员。
把它包起来
你将参加哪个会议？你在会议上预定了你感兴趣的位置了吗？如果没有，确保在别人跑得比你快之前这样做！
参加这样的活动是结识新朋友和了解机器学习最新消息的绝佳机会。*
机器学习工程师面试:期待什么？
原文：https://web.archive.org/web/https://neptune.ai/blog/machine-learning-engineer-interview
你是这份工作的最佳人选。你知道，我也知道——但是你仍然需要向面试官证明这一点。人们会根据你的技能、知识和性格来评判你，你需要证明你是合适的人选。哦，压力太大了！
我们都知道那是什么感觉。在复杂的环境中(机器学习项目肯定是复杂的)，与压力较小的工作相比，这甚至更难。不管你的资历如何，面试都是艰难的。高年级学生和低年级学生都一样害怕他们。
为了克服压力，你需要做好准备。如果你想增加被雇用的机会，你必须准备好回答最棘手的问题，而不失去镇定。
在这篇文章中，我将通过向你展示面试官如何喜欢绊倒机器学习工程师候选人，以及如何为他们的招聘策略做好准备，来帮助你赶走面试焦虑。
机器学习工程师的作用是什么？
在我们进入面试本身之前，让我们首先确保你实际上是在申请一份机器学习工程师(MLE)的工作。MLE 到底是做什么的？
MLE 的最终目标是塑造和构建高效的自学式人工智能应用。主要职责是:
- 设计机器学习系统和自运行 AI 软件。
- 转变数据科学原型。
- 使用数据建模和评估策略来发现模式和预测看不见的实例。
- 管理生产代码所需的基础设施和数据管道。
- 为培训目的在线查找可用数据集。
- 优化现有的 ML 库和框架。
- 运行机器学习测试并解释结果。
- 实施最佳实践以改进现有的机器学习基础设施。
- 记录机器学习过程。
在下图中，你可以找到一个来自 indeed 的 MLE 职位的例子。
最近对 mle 的需求已经超过了对数据科学家的需求(尽管很多人可能会互换使用这两个术语)。根据 Indeed 的数据，2015 年至 2018 年，MLE 职位空缺增长了 344%(来源:美国最佳工作)。
机器学习工程师 vs 数据科学家
我提到人们可以互换使用这些术语。这样做是错误的，因为两个帖子有区别。事实上，数据科学家的主要工作更多的是建立一个好的模型，机器学习工程师往往专注于模型的部署以及如何在生产环境中发布。
下表将向你介绍这两个职位所需的技能。
| 数据科学家 | 机器学习工程师 | |
|---|---|---|
—对数学、概率、统计和算法有深入的了解 rn——能够用 Python、Java 和 Rrn 编写强大的代码——有使用 SQL 或 pandasrn 进行数据操作和处理的经验——熟悉机器学习框架(如 Keras 或 PyTorch)和库(如 Scikit-learn)rn——具有出色的沟通技巧和分析及解决问题的技能
|
| |
——使用数据可视化工具的经验 rn——使用数据查询语言和统计或数学软件的经验 rn——数据挖掘和使用商业智能工具的经验 rn——对统计学、多变量微积分和线性代数有很好的理解
|
–了解数据结构、数据建模和软件架构 rn–出色的时间管理和组织能力 rn–了解算法在性能和功能方面的系统含义 rn–了解 Hadoop、Spark、Pig、Hive、Flume 等大数据框架 rn–精通 Linux 环境 srn–具有 NLP 和计算机视觉经验 rn–熟悉 AWS sage maker
T3 等机器学习技术】 |
你可以看看下面两个职位描述。我强调了区别这两种工作机会的一些要点。
Facebook Data science Scientist job description from Glassdoor
Facebook Machine Learning Engineer job description from Glassdoor
顶级公司的面试流程
每个大公司都有独特的招聘方式。这些公司已经建立了一个专门的面试，能够挑选出最优秀的机器学习工程师。
谷歌 ML 面试
谷歌的机器学习工程师面试寻求对数据结构、算法、系统设计和测试的理解。
面试过程将会非常广泛。他们会确保你是一个聪明的人，是公司的好员工。你应该意识到你会被问到什么样的问题，当你被要求编写一个回文问题或反转一个字符串时，不要感到惊讶。
苹果 ML 面试
像大多数其他公司一样，苹果对 MLE 的面试过程包括电话屏幕，然后是现场面试(或缩放)。面试官会问你过去的项目，重点是最先进的深度学习。然后是一些关于编码技巧以及优化、时间和空间复杂度的一般性问题。你会被问到关于 ML 概念的实现。这些问题将测试你对 ML 概念的核心知识，包括与面试官的讨论。
亚马逊 ML 面试
亚马逊机器学习面试由行为、软件工程和机器学习问题组成。面试官可能会问你一些基本的 ML 概念，你最近的项目，并描述如何解决一个给定的 ML/DL 问题。
此外，他们可能会给你一个编码问题，如递归或编码梯度下降算法。因此，你应该记住，你会遇到编码问题，因为机器学习工程师更像是软件工程师，而不是数据科学家。
脸书 ML 面试
脸书大学大型企业经理的招聘程序倾向于整体评估。包括两次编码面试，一次系统设计面试，一次行为面试，一次机器学习面试。
编码面试似乎很有挑战性，在某些情况下，你会得到一个家庭项目任务。脸书的好处在于，在面试之前，他们会通过招聘门户网站为你提供有用的准备资源。
Twitter ML 访谈
在 Twitter 的面试过程中，准备好接受计算机科学和数据科学知识的深度测试，重点是识别模式和趋势。面试包含一个技术编码面试，你将被要求实施一个程序，如如何编码一条推文或如何通过一个过程日志。技术部分会测试你对 ML 理论(基本概念和算法)的直觉。你需要展示你在统计学、实验模型和系统设计方面的知识。
顶级机器学习工程师面试问题
现在，让我们深入探讨可能会让你感到惊讶的 MLE 面试问题。做好准备，你就不会在面试中被绊倒。
这些问题混合了行为、技术和设计系统问题。我们会根据这个分类来划分面试问题。
行为问题
我们将看看你在任何公司的面试中可能遇到的常见行为问题，以及答案。
告诉我你遇到的最糟糕的经理是谁。
根据你遇到的经理的不同，有些问题可能很难回答。不要屈服于诱惑——即使你的前任经理很糟糕，也不要这么说。这不是发泄你的不满的合适地方。关注积极的一面，并展示出不管面临什么样的管理挑战，你都能卓有成效地工作。
你有什么与职业相关的遗憾吗？
对于这个问题，你需要谈论从负面经历中得到的好处，并清楚地强调你从中吸取的教训。只是要小心，选择一个真实发生的事件，不要假装，面试官会注意到的。
你认为自己是幸运的吗？
有些人认为运气是发现机会的能力。这就是发现或创造机会的人和等待机会到来的人之间的区别。当你追随你的激情时，你会找到快乐。所以，向你的面试官表达你很幸运能在一个你感兴趣的领域工作，并且有很多令人兴奋的个人和职业发展机会。
举出一个你面临道德困境的例子？
对于这个问题，你需要展示你正直地分析和解决问题的方法。小心，不要为采访者编造故事，他会发现是否是假的。事实上，当一些事情违背你的个人道德和价值观时，你可能会面临道德困境。它可能会迫使你在诚实和不诚实之间做出选择。一个道德困境的例子可能是这样的:项目的截止日期到了，你没有给你的经理任何东西。你承认自己的错误了吗，还是把责任推给了别人？在你进入面试之前，想想这样的故事，准备好一个以防你被问到这个问题。
ML/DL 问题
你会如何向孩子解释机器学习？
这个问题是为了测试你是否能把复杂的东西简单明了的解释给非技术人员听。在面试前准备一个这样的解释，在面试官熟悉的背景下举一些例子。
第一类错误和第二类错误有什么区别？
第一类错误是误报(如果有警报，但没有事件)，第二类错误是误报(没有警报，但有事件)。
3)数组和链表有什么区别？
数组和链表的关键区别在于,数组是对象的有序集合。数组的大小是在声明时指定的，以后不能更改。链表是一系列带有指针的对象。新元素可以存储在任何地方，并且使用指针为每个新元素创建一个引用。
你如何防止过度拟合？
检测过度拟合是有用的，但最重要的是确保您没有过度拟合模型。以下是一些最受欢迎的解决方案:
- 收集更多数据，用更多不同的样本来训练模型。
- 使用交叉验证技术
- 保持模型简单以减少差异
- 使用正则化技术
5) 熵和信息增益有什么区别？
熵是随机数据源产生信息的平均速率。这是你的数据有多脏的指标。越接近叶节点，它越小。
信息增益是通过观察另一个随机变量获得的关于一个随机变量或信号的信息量。它基于在属性上分割数据集后熵的减少。当你越靠近叶节点，它就越大。
更详细的解释，你可以查看这个链接。
什么是不平衡数据集？可以列举一些应对的方法吗？
任何具有不平等类分布的数据集在技术上都是不平衡的。
以下是一些处理不平衡数据的技巧:
- 对训练集进行重采样:有两种方法可以从不平衡的数据集得到平衡的数据集，即欠采样和过采样。
- 生成合成样本:使用 SMOTE(合成少数过采样技术)生成新的合成数据来训练模型。
为什么 XGBoost 的表现比 SVM 好？
XGBoost 是一种使用许多树的集合方法，因此它通过重复自身来改进。
SVM 是一个线性分隔符。当数据不是线性可分时，SVM 需要一个核将数据投射到高维空间。SVM 可以找到几乎任何数据的线性分离。
你会用什么评估方法来衡量一个 ML 模型的有效性？
- 将数据集分成训练集和测试集
- 使用交叉验证技术对数据集进行分段
- 实施准确性和 F1 分数等绩效指标
什么是辍学？
Dropout 是通过终止神经网络的某些单元来停止神经网络过拟合的一种简单实现方式。对每个训练示例重复这一过程，可以为每个示例提供不同的模型，改进处理，并减少时间。
什么是 GPT-3(或其他尖端技术)？你认为我们能如何使用它？
这个问题测试你是否关注新技术的宣传和研究。您可能知道，GPT-3 是最新的(至少在撰写本文时)语言生成模型，可以生成类似人类的文本。关于 GPT 3 号有很多观点。它可以改进聊天机器人，自动化客户服务，并通过 NLP 提升搜索引擎。
系统设计问题
系统设计面试分析你解决问题和创建设计系统来帮助客户的过程。这是一个向招聘经理展示你是一个有价值的团队成员，并充分展示你的技能的机会。面试官想知道当你拥有一个开放式问题时，你是如何思考的。
如何设计一个类似 Reddit、Quora 等的社交网络和留言板服务？？
这是一个常见系统设计问题的例子。要回答这个问题，你需要遵循以下指导步骤:
- 解释问题状态:
设计一个论坛，用户可以张贴问题。每个人都可以问问题，在评论区你可以写标签。
- 列出一般问题:
系统将如何定义标签？订阅源中显示了多少来自未关注标签的帖子？帖子是如何在服务器网络中分发的？
- 要求进一步澄清:
问一些澄清性的问题，向面试官展示你对系统需求的了解。
- 讨论新兴技术，如:
您将如何使用多线程和负载平衡器层来帮助支持更高的流量？你将如何使用 ML 和 NLP 来寻找标签之间的相关性？
你需要叙述你所做的任何决定，并简明扼要地解释你为什么做出这些决定。系统设计面试真的是一个很好的机会向面试官展示你是如何思考的，而不仅仅是你所拥有的知识。
关于机器学习系统设计的更多信息，你可以点击这里的链接。
结论
现在你已经对 MLE 面试有了一个从行为问题到设计系统的概述，你只需要自信，不要让压力控制你。记住，最终，问题和答案并不重要，重要的是你留下的整体印象。所以，认真听面试官说话，尽你所能让它听起来像是谈话的一部分。
记住这只是一次面试。如果你得不到这份工作，也不是世界末日！正如阿尔伯特·爱因斯坦所说，“困难之中蕴藏着机遇”。你很快就会为自己找到合适的机会…
…只要你为工作面试做好准备。祝你求职顺利！
机器学习工程师工资是多少？
原文：https://web.archive.org/web/https://neptune.ai/blog/machine-learning-engineer-salary
根据 O'Reilly 的研究 在企业中采用机器学习的状态 ，他们的受访者中有 50%声称在不同程度上采用了机器学习。
随着技术的发展和数据科学领域的新发现，对机器学习工程师的需求正在增长。越来越多的组织决定与机器学习专家合作，以增强产品和服务。与技术合作有助于超越竞争对手，提供创新的解决方案。
此外，奥赖利的同一项研究表明，专门针对机器学习的职位头衔已经在拥有丰富机器学习经验的组织中广泛使用:数据科学家 (81%)，机器学习工程师 (39%)，以及深度学习工程师 (20%)。在接下来的几年里，这种增长将会持续，统计数据将会显示更高的数字。
由于专业化的特殊性，机器学习工程师是劳动力中薪酬最高的群体之一。这不是没有原因的。这需要深厚的专业知识、适当的技能以及对科学世界的精通。
那么一个机器学习工程师到底学了多少呢？
为了找出多少，让我们从基本概念开始，一步一步地分析。
机器学习工程师——角色是什么，为什么重要？
机器学习工程师的角色如此重要和受到高度重视，原因很简单——不是每个人都注定会成为机器学习工程师，这些技能价值连城。
那么谁是机器学习工程师，他(或她)是做什么的？你可能听说过两个可以互换的名字——机器学习工程师和数据科学家。虽然边界模糊，但还是有一些细微的差别。
首先，数据科学是一个更宽泛的术语。它包括编程，但主要侧重于分析方法中的数据。因此，如果你是一名数据科学家，你会分析数据并得出有助于改善业务的结论。
机器学习工程师或专家可以是数据科学团队的一部分。ML 专注于建立模型，这些模型可以在以后被用来，例如，改进一个产品。
机器学习工程师可以创建一个图像识别系统，根据照片识别垃圾的类型，预测能源需求，根据历史数据预测未来产品的销售，或预测流行病的进程。
你可能听说过的一些最著名的例子是 交通预测 和 发明一种可以杀死多种抗生素耐药细菌的新药 。
而要做到这一点，ML 工程师必须具备深入的编程、概率和统计知识，并且是数学和计算机的大师。这些都是困难的技能，不是每个人都能够获得和驾驭的
这些只是工程师利用机器学习和数据可以做的奇妙事情的几个例子。
这是许多雇主寻求的一个注重增长的角色，因为它有助于发展业务。
机器学习工程师的工资和三个层次的经验
最重要的问题是机器学习工程师赚多少钱？没有具体的答案。机器学习工程师的工资取决于几个因素，例如，公司、职位、国家甚至城市。然而最重要的原因是的经历。
您在数据科学领域的经验和知识决定了您账户上的数字。那是因为你掌握的知识越多，你能给公司带来的价值就越多。你带来的价值越多，你得到的报酬就越多。
安德鲁·佐拉在他的文章中定义了机器学习工程师的三个经验层次。根据作者收集的数据，工资看起来如下(更多详细信息，阅读全文):
-
入门级机器学习工程师–(0-4 年经验)——平均约为 97090 美元。然而，加上潜在的奖金和利润分享，这个数字可能会迅速上升到 13 万美元甚至更多。
-
中级机器学习工程师–(5-9 年经验)——平均工资 112095 美元。加上潜在的奖金和利润分成，奖金可能达到 16 万美元或更多。
-
高级机器学习工程师–(10 年以上经验)——平均工资 13.25 万美元；加上奖金和利润，这个数字每年高达 18.1 万美元。
在这三种情况下，技能组合都是熟悉的:
技能可能因公司或工程师关注的领域而异。但最重要的是你能用它做什么，以及你是否愿意学习和适应变化。
毫不奇怪，一些赚得最多的公司是世界上最知名的公司。在前十名中，你可以分别找到苹果、英特尔公司、脸书、LinkedIn、Spotify、IBM 或谷歌等品牌。
此外，机器学习工程师的一些最佳城市是旧金山(加利福尼亚州)、圣何塞(加利福尼亚州)、西雅图(华盛顿州)和波士顿(马萨诸塞州)。这是因为一些最好的科技公司位于这些城市。
作为机器学习工程师如何挣得更多？
如何登顶？作为机器学习工程师如何挣得更多？品质、权威和经验是一个成功工程师的三个标志。所以一定要具备这三个。要做到这一点，你需要不断学习，发展你的技能，并对变化持开放态度。有很多方法可以提高你的技能:
参加会议、研讨会和课程——你可以从会议中学到很多关于行业、最新趋势和秘密的知识。这也是认识新朋友、专家甚至找工作的好机会。
学习新技能——你能做的最好的事情就是利用知识的力量。有很多机器学习的资源，你可以从中学习新的东西，扩展你当前的技能。
搬到一个不同的城市——如果你不得不，你可以搬到一个能给你机会找到更好工作的城市，也许是最好的公司之一
加入社区–互联网上有许多论坛和社区，人们在那里学习、教学、结识他人、交流思想并鼓励彼此更加努力地工作。也许你住的地方有个社区？加入这样的地方，寻找灵感。试试 Kaggle 、栈溢出，或者 Reddit 。
社交-当你参加会议或者你是一个社区的一员时，试着和尽可能多的人交谈。拥有一个值得信任的人际网络可以帮助你发展事业。接触那些激励你扩大社交网络的人。
读书——有一些很棒的书可以帮助你成为一名更好的机器学习工程师，甚至从头开始成为一名机器学习工程师。
喜欢什么就去尝试，混搭，不要放弃。
结论
在未来几年，也许我们可以期待机器学习工程师的繁荣，因为公司将努力开发和创造现代产品。作为一家公司，成长的最佳方式之一是投资有助于前进的技术和人工智能。
因此，如果你是一名数据科学家，你会有一个光明的未来。
本文中使用的资源:
1.机器学习在企业中的采用状况O ' Reilly
2.如何结合一些机器学习方法进行流量预测？由 Mahdi R .于 2018 年 6 月 14 日黑客中午
3.人工智能产生新抗生素
4.2019 年 7 月 19 日安德鲁·佐拉在跳板博客上发表的机器学习工程师工资指南
5.Glassdor 的机器学习工程师薪水
6.平均机器学习工程师工资按工资级别
7.如何成为一名机器学习工程师Robert Half 在 roberthalf.com8. 数据科学 vs .数据分析 vs .机器学习:专家讲座Sri Hari Sasikumar 在 SimpliLearn
机器学习模型管理:它是什么，为什么你应该关心，以及如何实现它
原文：https://web.archive.org/web/https://neptune.ai/blog/machine-learning-model-management
机器学习正在兴起。因此，新的问题不断涌现，ML 开发者和技术公司一起不断构建新的工具来解决这些问题。
如果我们以一种非常基本的方式来看待 ML，我们可以说 ML 在概念上是一种增加了一点智能的软件，但与传统软件不同，ML 本质上是实验性的。与传统的软件开发相比，它有一些新的组成部分，例如:健壮的数据、模型架构、模型代码、超参数、特性等等。因此，自然地，工具和开发周期也不同。软件有 DevOps，机器学习有 MLOps。
如果听起来不熟悉，这里有一个关于 DevOps 和 mlop的简短概述:
DevOps 是一套开发、测试、部署和操作大规模软件系统的实践。有了 DevOps，开发周期变得更短，部署速度加快，系统发布变得可审计和可靠。
MLOps 是数据科学家和运营专业人员之间进行协作和沟通的一套实践。应用这些实践可以提高最终质量，简化管理流程，并在大规模生产环境中自动部署机器学习和深度学习模型。这使得模型更容易与业务需求和法规要求保持一致。
MLOps 的关键阶段是:
- 数据采集
- 数据分析
- 数据转换/准备
- 模型开发
- 模特培训
- 模型验证
- 模型服务
- 模型监控
- 模型再训练
MLOps tools landscape | Click the image to enlarge it
我们将深入研究这一过程，所以拿起一杯你最喜欢的饮料，我们走吧！
什么是机器学习模型管理？
模型管理是 MLOps 的一部分。ML 模型应该是一致的，并且在规模上满足所有业务需求。为了实现这一点，一个符合逻辑、易于遵循的模型管理策略是必不可少的。ML 模型管理负责 ML 模型的开发、培训、版本和部署。
注 :版本化还包括 数据 ，这样我们就可以跟踪哪个数据集，或者数据集的子集，我们用来训练模型的特定版本。
当研究人员研究新的 ML 模型或将其应用于新的领域时，他们会使用不同的模型架构、优化器、损失函数、参数、超参数和数据进行无数次实验(模型训练和测试)。他们使用这些实验来获得最佳的模型配置，该配置概括了最好的配置，或者在数据集上具有最好的性能-精度折衷。
但是，如果没有一种方法来跟踪不同实验中的模型性能和配置，一切都可能(并将)失控，因为我们将无法比较和选择最佳解决方案。即使只是一个研究人员独立进行实验，跟踪所有的实验和结果也是很难的。
这就是我们做模型管理的原因。它让我们、我们的团队和我们的组织:
- 主动解决常见的业务问题(如法规遵从性)；
- 通过跟踪指标、损失、代码、数据和模型版本，实现可重复的实验；
- 以可重复的配置打包和交付模型，以支持可重用性。
^(阅读更多) 2020 年及以后的机器学习模型管理——你需要知道的一切
你需要知道的最好的机器学习模型管理工具
为什么机器学习模型管理很重要？
正如我之前提到的，模型管理是任何 ML 管道(MLOps)的基础部分。从创建、配置、实验、跟踪不同的实验，一直到模型部署，管理 ML 生命周期变得更加容易。
现在，让我们更深入一点，明确区分 ML 模型管理的不同部分。需要注意的是，在 ML 模型管理中，我们管理两件事情:
- 模型:这里我们负责模型打包、模型沿袭、模型部署&部署策略(A/B 测试等)、监控和模型再训练(当部署的模型的性能下降到设定的阈值以下时发生)。
- 实验:在这里，我们记录培训指标、损失、图像、文本或您可能拥有的任何其他元数据，以及代码、数据&管道版本控制，
如果没有模型管理，数据科学团队将很难创建、跟踪、比较、重新创建和部署模型。
模型管理的替代方案是特别的实践，这导致研究人员创建不可重复、不可持续、不可扩展和无组织的 ML 项目。
现在，除此之外，根据 AMY x . ZHANG *进行的研究，麻省理工学院等人关于DS 工作人员如何协作的研究表明，DS 工作人员团队广泛协作，利用 ML 从数据中提取见解，而不是单个数据科学家单独工作。为了有效地协作，他们在团队成员之间采用最佳协作实践(即文档、代码版本等等)和工具，前者高度依赖后者。
MLOps 促进了协作，但当今对数据科学协作的大多数理解只关注数据科学家的观点，以及如何构建工具来支持数据科学家之间全球分散和异步的协作，如代码的版本控制。此类工具提供的技术协作仅仅触及了数据科学团队内部可能发生协作的许多方式的表面，例如:
- 当涉众在编写代码或收集数据之前讨论初始问题的框架时
- 评论实验
- 接管他人的笔记本或代码作为基础进行构建
- 研究人员和数据科学家对模型进行培训、评估和标记，以便 MLE 知道应该审查模型(即 A/B 测试)并将其推广到生产(模型部署)
- 拥有一个共享的存储库，业务涉众可以在其中审查生产模型(也称为模型注册中心)
数据科学团队的协作程度如何？
协作率:在上图的五个数据科学角色中，三个角色的协作率达到 95%或更高。你可以清楚地看到，这些角色是 ML 团队中的核心角色。
该研究还表明，研究人员、数据科学家、ML 工程师广泛合作，并在 ML 模型(ML 模型管理)的开发、培训、评估(即准确性、性能、偏差)版本化和部署中发挥关键作用
还不信服？以下是模型管理重要的另外六个原因:
- 允许真理的单一来源；
- 允许对代码、数据和模型工件进行版本控制，以实现基准测试和可再现性；
- 更容易调试/缓解问题(即过拟合、欠拟合、性能和/或偏差)，从而使 ML 解决方案易于追踪并符合规定；
- 你可以做更快、更好的研发；
- 团队变得高效，方向感清晰。
- ML 模型管理可以通过使用各种最佳实践和工具(JupyterLab、Colab、Neptune.ai、MLflow、Sagemaker 等)来促进团队内部和/或团队之间围绕代码、数据和文档的协作；
ML 模型管理组件
在我们继续之前，这里有一个 ML 模型管理工作流的通用组件的词汇表:
- :版本控制系统帮助开发者管理源代码的变更。而数据版本控制是一组工具和过程，其试图使版本控制过程适应数据世界，以管理与数据集相关的模型的改变，反之亦然。
- ****代码版本控制/笔记本检查点:用于管理模型源代码的变更。
- 实验跟踪器 :用于跨不同配置(lr、epochs、优化器、损失、批量等)和数据集(train/val 拆分和转换)的多次运行，收集、组织和跟踪模型训练/验证信息/性能。
- 模型注册中心 : 是一个简单的集中跟踪系统，用于训练、测试和部署 ML 模型
- 模型监控 : 它用于跟踪模型的推理性能，并识别服务偏差的任何迹象，即当数据变化导致部署的模型性能降低到低于其在训练环境中显示的分数/准确度时。
**现在我们已经知道了模型管理的不同组件以及它们的作用，让我们来看看一些最佳实践。
机器学习模型管理的最佳实践
以下是 ML 模型管理最佳实践的列表:
模型
密码
部署
ML 模型管理与实验跟踪
实验跟踪是模型管理的一部分，所以它也是更大的 MLOps 方法的一部分。实验跟踪是指在不同配置(超参数、模型大小、数据分割、参数等)的多次运行中收集、组织和跟踪模型训练/验证信息。
如前所述，ML/DL 本质上是实验性的，我们使用实验跟踪工具对不同的模型进行基准测试。
实验跟踪工具有 3 个主要特征:
- 日志:记录实验元数据(指标、损耗、配置、图像等)；
- 版本控制:跟踪数据和模型版本，这在生产环境中非常有用，可以帮助调试和未来的改进；
- Dashboard :可视化所有记录和版本化的数据，使用可视化组件(图形)来比较性能，并对不同的实验进行排序。
^(书签以备后用) ML 实验跟踪:它是什么，为什么重要，如何实现
跟踪机器学习实验的 15 个最佳工具
如何实现 ML 模型管理
在我们继续之前，让我告诉你一个小故事。
去年，我的一些客户给我带来了很多问题，因为我没有跟踪我的实验:
- 我不能有效地比较不同的实验，我凭记忆做所有的事情，所以项目被推迟了。
- 我很大程度上依赖于集成来尝试修补单个模型的缺陷，这些模型只能部分工作，但基本上没有结果。
- 不记录实验结果也造成了长期的问题，我无法回忆起以前版本的模型的性能。
- 部署正确的模型是棘手的，因为永远不清楚哪一个是最好的，使用了哪些代码、转换和数据。
- 再现性是不可能的。
- CI/CD 和 CT 无法通过这种手工模型管理来实施。
我做了一些研究，发现了 ML 模型管理，并决定尝试一个实际的实验跟踪工具来加速我的过程。现在，没有我最喜欢的实验跟踪工具 海王 ，我连一个项目都不启动。
注 :在本文创作期间，Neptune.ai 的旗舰产品从过去一个简单的实验跟踪工具发展到现在已经成为一个大得多的东西，更多关于这方面的内容请见工具部分。
我一直在生产和研究中使用它，例如我为我的客户开发的定制 ML 模型项目，以及我最后一年的 CSE 学位项目。
还有许多其他工具，其中一些是用于管理整个 ML 生命周期的成熟平台，包括实验、可再现性、部署和中央模型注册。我们稍后将讨论这些工具。
因此，在对不同规模和需求的项目使用了与模型生命周期平台(在我的例子中是 MLflow)相结合的实验跟踪工具之后，我发现了 4 种实现 ML 模型管理的方法:
- Level-0****
- 一级
- 日志+模型和数据版本控制
- 二级
- 日志+代码、模型和数据版本控制
- 三级
- 日志记录+代码、模型和数据版本控制+模型部署和监控
0 级
特征
我称之为特别研究模型管理。在这个级别，您只是使用一个实验跟踪工具来进行记录。非常适合初学 ML 的初学者，或者做快速原型以证明假设是否值得追求的高级研究人员。
这个级别允许个人、团队和组织记录和查询他们的实验:
- 指标(准确性、IoU、Bleu 分数等)
- 损失(MSE、BCE、CE 等)
- 配置(参数，超参数)
- 从培训和测试中模拟性能结果
赞成的意见
- 特定数据科学
- 研究和快速原型驱动
骗局
- 无数据版本
- 没有模型版本
- 没有笔记本检查点
- 没有 CI/CD 管道
- 缺乏再现性
挑战
通常，美国数据科学家喜欢运行多个实验来测试不同的想法、代码和模型配置以及数据集。在这个水平上，这是相当具有挑战性的。
- 首先，你没有遵循任何会给你明确方向的 DS 项目管理方法学。因此，如果没有标准化的方法来管理数据科学项目，您将经常依赖不可重复、不可持续且无组织的临时实践。
- 其次，数据集不断更新，因此即使您记录了指标、损失和配置，您也不知道哪个版本的数据集用于训练特定的模型。
- 第三，代码也可能随着每次实验运行而改变，所以尽管保存了所有的模型配置，您可能不知道哪个实验中使用了哪个代码。
- 第四，即使您保存了模型的权重，您也可能不知道哪个模型是使用特定的配置和数据集训练的。
所有这些挑战使得任何特定实验的结果都不可能重现。为了解决这一级别的挑战，一个好的开始是向我们的模型和数据添加版本控制——一些实验工具开箱即用。这样我们就可以使部分再现成为可能。
一级
特征
我把这个叫做部分模型管理。通常用于做快速原型的结构良好的团队。在这个层次上，除了实验跟踪之外，您还将模型及其元数据(配置)以及用于训练它的数据集或数据分割存储在一个中央存储库中，该存储库将用作单一的真实来源。
赞成的意见
- 拥有数据版本
- 拥有模型版本
- 实验是部分可重复的
- 特定数据科学
- 研究和快速原型驱动
骗局
- 没有 CI/CD 管道
- 缺乏再现性
- 没有笔记本检查点
挑战
这个水平适合快速测试想法，而不需要完全投入其中。在研究环境中，它可能会非常有用，因为目标只是尝试有趣的想法，并在不同的个人、团队或公司之间比较实验。我们还没有考虑将它们投入生产。
虽然我们可以从用于训练它的模型元数据和数据集再现实验，但在这个层面上，我们仍然没有完全解决可再现性。我们只是部分解决了它。为了实现完整的循环，我们还需要一个组件——笔记本检查点，这样我们就可以跟踪代码的变化。
二级
特征
我把这个叫做半完整模型管理。对于那些不仅想快速测试他们的假设，而且想将他们的模型部署到生产环境中的个人、团队和公司来说，这是非常棒的。
这个级别允许个人和组织通过存储和版本化他们的笔记本/代码、数据和模型来保存完整的实验历史，除了记录元数据之外。这让我们兜了一圈，使可再现性成为现实，并且无论使用 ML/DL 框架还是工具集都很容易实现。在这个级别，您通常还会应用标准化的方法来管理数据科学项目。
赞成的意见
- 拥有数据版本
- 拥有模型版本
- 有笔记本检查点
- 实验是完全可重复的
- 再加上 DS 项目管理方法
- 生产驱动的
骗局
挑战
除了一件事:模型部署，您已经自动化了这个级别的所有东西。这就产生了压力。每当您有一个新的训练好的模型准备部署时，您必须手动部署它。为了完成 ML 模型管理管道，您需要集成 CI/CD。
三级
特征
我称之为端到端模型管理。在这个级别，您拥有一个完全自动化的管道，从模型开发、版本控制到部署。该级别提供了生产级设置，非常适合寻求完整、自动化工作流程的个人、团队和组织。一旦你设置好了，你就不用再做操作工作了。您可以专注于调整和改进模型和数据源。
赞成的意见
- 拥有数据版本
- 拥有模型版本
- 有笔记本检查点
- 实验是完全可重复的
- 再加上 DS 项目管理方法
- 生产驱动的
- CI/CD 管道
骗局
挑战
在这一点上，只缺少一样东西——一种持续监控已部署模型的方法。也称为 CT(连续测试)管道，用于监控部署的模型，如果当前部署的模型的性能下降到设定的阈值以下，则自动重新训练并为新模型提供服务。让我们在生产环境中采用一个计算机视觉模型，如 ResNet。要添加 CT，只需监视和记录以下内容即可:
要将此功能添加到组合中，您可以在训练期间重用来自 0 级或 1 级的相同代码来记录元数据，并将其用于推断。
像 Neptune 和 MLflow 这样的工具允许您在本地安装它们的软件，因此您可以将这种功能添加到您的部署服务器中。Neptune 在这里更强大，它为个人和团队提供了第二种选择，即轻量级 web 版本的软件，因此不需要安装和配置任何东西，只需在仪表板上创建一个新项目。只需在部署代码中添加几行代码，就可以完成了。
什么是机器学习(ML)模型注册表？
ML 模型注册中心是一个简单的集中跟踪系统，用于训练、分级和部署 ML 模型。它还跟踪谁创建了模型，以及用于训练它的数据。它通过使用数据库存储模型沿袭、版本、元数据和配置来实现这一点。
构建自己的简单模型注册中心相对容易。您可以通过使用一些本机或云服务(如 AWS S3 桶、RDBMS (Postgresql、Mongo…)以及编写一个简单的 python API 来轻松更新数据库记录，以防发生更改或更新。
虽然构建模型注册中心相对容易，但这是否意味着您应该这样做呢？它真的值得你花费时间、金钱和资源吗？
为了回答这个问题，让我们首先来看看为什么您可能想要构建自己的 ML 模型注册中心:
- 隐私:您的数据不能离开您的办公场所。
- 好奇心:和我一样，你喜欢建造东西。
- 业务:你在一家构建 ML 工具的公司运营或工作，你想把它添加到现有的产品中，或者作为一项新的服务提供给客户。
- 成本:现有工具对您的预算来说太贵了。
- 性能:现有工具无法满足您的性能需求。
所有合理的理由，除了成本，因为大多数现有的工具都是开源或免费的。
如果您关注的是性能，一些工具提供了很好的性能，因为它们提供了专用的云服务器实例，只需要很少的设置(如 Neptune 和 Comet)。
现在，如果你担心的是隐私，大多数工具也提供了他们软件的本地版本，你可以下载并安装在你组织的服务器上，以获得对进出数据的完全控制。这样您可以遵守法律法规，并保护您的数据安全。
在我看来，我认为在构建与购买之间存在一个普遍的误解。一些通常更成熟的团队/开发人员马上就能理解的东西，但是大多数 ML 社区仍然没有真正理解。
托管、维护、记录、修复、更新和调整开源软件的成本通常比供应商工具的成本高几个数量级。
事实是，为自己构建一个简单的、不可扩展的、没有文档记录的系统通常是相对容易的。
…但是，从这个系统过渡到一个可以让整个团队快速工作的系统会变得非常昂贵。
另外，当你决定构建它(甚至不是开源的)时，你会发现有人需要构建/维护它，而 ML 工程师和 devops 人员的工资并不便宜。
通常有一个很好的经验法则-->如果系统(如 ML model registry)不是你的核心业务，而且通常不是，那么你应该专注于你的核心业务(例如为自动驾驶汽车构建模型)，并为你没有建立竞争优势的部分雇佣/购买解决方案。
这么想吧，你会去创建一个 gmail 吗，因为你可以？
或者像 mailchimp 这样的邮件发送系统？
还是 wordpress 之类的 CMS？
有些公司会，尽管这不是他们的业务。这通常是一个很大的错误，因为你专注于制造铁锹而不是挖掘黄金:)。。
如果只是为了好玩，或者如果你经营一家构建 MLflow 或 Neptune 等 MLOps 工具的公司，那么构建自己的模型注册中心是最有意义的。
在许多其他情况下，这只是不合理的投资。
公司已经投资了数十亿美元来创造伟大的、免费的和/或优质的工具。这些工具中的大部分都可以很容易地扩展到适合您自己的用例，节省您的时间、金钱、资源和麻烦。
现在，让我们详细看看一些最流行的工具。
请记住，当谈到下面描述的工具时，我有我个人的偏好，但我尽量做到客观。
Neptune 现在是 MLOps 的元数据存储库，为运行大量实验的研究和生产团队而构建。
它为您提供了一个中心位置来记录、存储、显示、组织、比较和查询机器学习生命周期中生成的所有元数据。
成千上万的 ML 工程师和研究人员使用 Neptune 进行实验跟踪和模型注册，无论是作为个人还是在大型组织的团队内部。
这是一个非常灵活的软件，可以与许多其他框架和库一起工作。
Neptune 拥有团队协作和项目监督所需的所有工具。
有了 Neptune，您可以用一个包含所有模型构建元数据的真实来源来替换文件夹结构、电子表格和命名约定。
优点
- 数据版本化
- 模型注册表
- 实验跟踪
- 您可以在自己的硬件上安装服务器版本，或者通过客户端库将其作为服务使用
- 为用户和组织管理提供组织、项目和用户角色
- 快速美观的用户界面，具有多种功能，可以分组组织跑步，保存自定义仪表板视图，并与团队共享
- 您可以使用托管应用程序来避免维护另一个工具的所有麻烦(或者将其部署在您的内部基础架构上)
- 你的团队可以跟踪在脚本(Python，R，other)和笔记本(locCoal，Google lab，AWS SageMaker)中执行的实验
- 广泛的实验跟踪、可视化和比较能力；
- 与其他工具轻松集成
- 提供 100 GB 存储的免费托管服务选项，无限的实验，私人和公共项目
- 免费的托管服务选项非常适合个人，但仅限于个人，而小型和大型团队都有付费选项。
- 免费的托管服务已经准备好投入生产，您可以复制实验
- 付费托管服务选项:
缺点
- 缺乏数据管道版本控制
- 如果有更高级的 API 功能就太好了。
- 创建多行图形的 UI 应该更加灵活。
MLflow 是一个管理整个机器学习生命周期(MLOps)的开源平台。实验、可复制性、部署、中央模型注册中心，一切尽在其中。MLflow 适合个人和任何规模的团队。
该工具与库无关。你可以在任何机器学习库和任何编程语言中使用它。
MLflow 于 2018 年推出，由于其与 Tensorflow、Pytorch、Scikit-learn、Kubernetes 和 Sagemaker 等主要 ML 框架、工具和库的轻松集成，迅速成为行业标准。它有一个庞大的用户和贡献者社区。
MLflow 有四个主要功能来帮助跟踪和组织实验和模型:
- ml flow Tracking——一个 API 和 UI，用于在运行机器学习代码时记录参数、代码版本、指标和工件，并用于以后可视化和比较结果；
- MLflow 项目–以可重用、可复制的形式包装 ML 代码，以便与其他数据科学家共享或转移到生产中；
- ML flow Models–管理来自不同 ML 库的模型并将其部署到各种模型服务和推理平台；
- MLflow Model Registry–中央模型库，协作管理 ml flow 模型的整个生命周期，包括模型版本控制、阶段转换和注释。
优点
- 实验跟踪
- 与其他工具和库轻松集成
- 直观的 UI
- 大社区和大支持
- 免费的托管服务选项(MLflow Community edition)带有预配置的 ML 环境，包括:Pytorch、TF keras 和其他库。
- MLflow 社区很棒，仅限个人，而付费是团队。
- 通过云提供商提供的付费托管服务选项，附带预配置的计算和 sql 存储服务器。这项服务是按秒计费的。
缺点
- 缺乏数据管道版本控制
- MLflow 模型可以改进
- MLflow 社区实验比较 UI 可以简化
- MLflow 社区加载缓慢，无法用于生产
- MLflow 社区有一个限制为 15GB 的集群，没有工作节点
- MLflow Community edition 不包含运行和复制 MLflow 项目的功能。并且它的可伸缩性和正常运行时间保证是有限的。
Amazon Sagemaker 是一个端到端的 MLOps 平台，拥有一套工具来收集、准备和版本化数据，以及构建、培训、版本化、部署和监控 ML 模型。
我将这个平台用于我的 ML 管道的一些部分，比如训练大型模型，或者当我运行性能要求高的任务(图像或文本处理)时。根据我的经验，我可以对初学者这么说:Sagemaker 对初学者来说远不容易使用，它有一个陡峭的学习曲线，但是一旦你获得一些经验，它就会变得非常有用和有帮助，就像瑞士军队的绝地刀一样。
优点
- 为您使用的东西付费
- 提供集中控制
- 提供一个由生成管理的 Jupyter 笔记本
- 提供很大的自由和定制(你可以集成其他工具，如 MLflow，Neptune 等)
- 提供了一种简单直接的方法来构建训练和测试样本
- 使用 conda 进行包管理
- 出色的硬件选项
- 可量测性
- 所有的培训、测试和模型都存储在 S3 上，所以很容易访问
- 轻松部署 API
- 数据管道版本控制
缺点
- 昂贵的
- 不清楚和冗长的文件
- 可以更好地管理实验跟踪日志
- 没有模型比较用户界面
- 陡峭的学习曲线
- 大量样板代码
Azure 机器学习是微软的云 MLOps 平台。像 Sagemaker 一样，它是完整 ML 生命周期的端到端工具。
优点
- 为您使用的东西付费
- 它允许您为培训和部署模型创建可重用的软件环境
- 它提供关于 ML 生命周期中事件的通知和警报
- 出色的用户界面和用户友好性
- 广泛的实验跟踪和可视化功能
- 出色的表现
- 连接性，在 Azure ML 上嵌入 R 或 Python 代码非常容易，如果你想做更高级的东西，或者使用 Azure ML 上还没有的模型，你可以简单地复制+粘贴 R/Python 代码
缺点
- 对个人来说很昂贵
- 可能会有更多的型号
- 难以集成数据来创建模型
- 难以与其他工具集成
- 你总是需要一个良好的互联网连接来使用它。
关于 MLOps 的更多信息，请查看我之前的文章 MLOps:它是什么，它有什么关系；关于可用的最佳 MLOps 工具，请参见 Neptune 的 Jakub 的最佳 MLOps 工具。
结论
机器学习模型管理是 MLOps 工作流程的基础部分。它让我们将模型从开发阶段带入生产阶段，使得每个实验和/或模型版本都是可复制的。
最后，总结一下，ML 模型管理有 4 个级别:
- 0 级，即席研究模型管理
- 第 1 级，部分模型管理
- 第二级，半完整模型管理
- 第 4 级，完整的(端到端)模型管理
在每一关，你都会面临不同的挑战。ML 模型管理的最佳实践围绕 3 个部分展开:
就工具而言，我们有太多的选择，但是在本文中，我描述了几个流行的工具:
- MLflow
- 海王星 AI
- Sagemaker
- 天蓝色 ML
我希望这能帮助你选择正确的工具。
谢谢你阅读这篇文章，请继续关注。一如既往，我创建了一个长长的参考列表，供您探索，玩得开心！
参考
构建您自己的模型注册中心
工具**
如何用更少的数据启动机器学习项目
原文：https://web.archive.org/web/https://neptune.ai/blog/machine-learning-project-with-less-data
如果机器学习解决方案是汽车，那么它们的燃料就是数据。简单来看，ML 模型是需要数值和变量来运算的统计方程，数据是 ML 成功的最大功臣。
如今，数据来源丰富，可用数据的数量呈指数级增长。这使得我们能够争论，弯曲，并从一堆不必要的噪音中选择正确的数据集。
但是，当您的数据较少并且似乎不足以训练模型时，会发生什么呢？嗯，一辆汽车能靠低燃料跑很多英里吗？答案是肯定的和否定的，这取决于车型的类型和燃料的质量。如果答案是“是”，那么下一个问题就是:汽车怎么这么节能？
同样，如何构建数据高效的 ML 解决方案？
为了理解这一点，让我们从讨论数据不足的原因开始。
数据不足的原因
尽管每天生成的数据呈指数级增长，但一些专有类型的数据仍然来源有限。例如，来自完全自动驾驶汽车(新技术)的罕见疾病数据或事故统计数据。对于这样的数据，可扩展的选项是有限的，现有的数据是尝试和挖掘价值的全部。
即使数据在本质上不是排他性的，客户端也可能是。例如，如果是一家新公司，客户的财务数据可能会受到限制。
- 损坏或故障的数据源
如果数据源或记录数据的设备有问题，可能会导致丢失值。例如，如果您有一个数据集来检查特定机器的活力，如果一些传感器在机器的生命周期中途出现故障，并且由于高成本-有用性比率而没有修复，则信息可能是有限的。
现实生活中数据集最常见的问题是不同类别数据之间的不平衡。您可以拥有一个包含一百万条正样本记录的巨大数据集，但是如果数据集只有一百条负样本记录，模型将很难了解这两个类之间的差异。不平衡数据中少数类的一些实例包括银行数据中大额借记交易或关闭时间的欺诈案例、安全异常、预测性维护数据中的故障实例以及罕见疾病数据中的阳性案例。
这些是数据短缺的广泛例子，但是没有足够的数据用于您的模型可能还有更多原因。当这个问题发生时，我们如何解决它？
偏差方差权衡
当数据非常少时，训练数据就像是一种有限的资源。因此，为了不中断整个建模过程，必须彻底考虑偏差和方差的基本概念，以最小化原始值和预测值之间的误差。
偏见
偏差是机器学习模型用来使学习过程更容易的假设。例如，线性回归模型假设因变量和自变量之间存在线性相关性。
高偏差模型是对数据做出重大假设的模型。例如，线性模型，如线性回归、K 均值和逻辑回归。
低偏差模型对数据做出更少的假设，更擅长学习目标变量和独立变量之间的新型关系。例如，非线性模型，如决策树、随机森林和 K-NN 算法。
差异
方差是估计的目标变量将随着训练数据的改变而改变多少的度量。更简单地说，它衡量训练模型的稳定性。如果有很多变化，这意味着模型没有学习模式，而是学习训练数据中的噪声。
高方差模型对数据的变化很敏感，可以显示不同训练集之间的主要差异。这就是为什么他们需要用多重数据的迭代来训练和测试。对于低容量的数据，折叠不必是唯一的，甚至可以包含来自其他折叠的数据点。高方差模型的例子有决策树和随机森林。
低方差模型对训练数据的变化不太敏感，主要是因为对数据的固定假设。例如线性回归和线性判别分析。
权衡取舍
从偏差和方差的定义中可以清楚地看出，最终目标是将偏差和方差都降低到最小——一种很少假设的高稳定性状态。
偏差和方差是间接成正比的，两者达到最小值的唯一途径是在交点处。偏差和方差的计算是不可能的，因为我们不知道目标函数。然而，考虑到这些概念来选择和调整模型可以大大减少测试误差(通常是实际值和估计值之间的均方误差)。
过度拟合和欠拟合
对于任何数量的数据，如果模型处理不当，都有过度拟合和欠拟合的风险。然而，当数据量很小时，更可能的情况是过度拟合。开发人员可能希望最大化可用数据，在这样做的时候，错误地让模型学习噪音和偏差。
过度拟合是指模型被训练得过于贴近训练数据。在高层次上，模型不认为训练数据是近似值，而是认为它是绝对的。因此，当模型对一组训练数据过度拟合时，它无法对新的和看不见的数据集执行。
过度拟合在大多数情况下是可能的，因为非线性和灵活的模型可以密切跟踪具有高方差的数据。例如，随机森林算法可以分支多次，以适应大范围的数据。
欠拟合是指模型没有很好地从现有数据中学习。这可能是由多种原因造成的，但如果数据具有较高的方差且所选模型具有较高的偏差，则大多数情况下是在低容量数据中。例如，对与输出变量无关的数据使用线性回归。
Fig 2: Underfitting and Overfitting demonstrated through Bias and Variance | Image from towardsdatascience.com
如何避免在小数据集上过度拟合
如上所述，少量数据的主要问题是过度拟合。让我们看看如何解决这个问题。
低复杂度的模型不太灵活，也不太适应高方差数据。具有高复杂性的模型将试图记录数据的最小偏差，并且倾向于学习噪声。低复杂度的模型可以包括线性模型，如逻辑回归和线性回归。
然而，如果数据本质上不是线性的，这些模型就不会表现得很好。在这种情况下，建议使用非线性模型，如决策树和随机森林。为了限制这些基于树的算法的复杂性，可以对参数进行微调。例如，在限制 max_depth 参数后，树只增长到某个级别，并停止记录进一步的数据偏差。
如果你不正确对待，离群值会显著影响学习的轨迹。当数据集规模已经很小并且模型没有什么可学习的时候，遇到异常值可能会错误地改变目标函数，尤其是当模型具有高方差时。当异常值表示欺诈或黑客攻击等关键事件时，不建议移除异常值。
- 最优特征工程
这里，特征工程广义地定义了特征选择和特征创建。使用更少的数据，从有限的原始列创建多个有用特性的能力可以真正改变游戏规则。有一次，我遇到一个只有四个原始列(其中 3 个是日期)的项目，团队能够从这四个列中设计出大约 50 个新特性！
原始列是简单的数据，经过智能解释后可以提供更大的价值。例如，在从股票数据预测股票价格时，交易数量的简单特征与交易数量的变化率或随时间的差异相比，通常不太直观。
即使原始列的数量较少，特征工程也不必扩展的一种情况是当使用神经网络时。这是因为神经网络自己创建和选择特征。
过度拟合源于高方差，而集成学习是一种在不降低模型复杂性的情况下降低模型方差的方法。这是达到偏差-方差平衡的一种独特方式。根据定义，集成学习结合几个模型来计算每个模型的组合结果。这意味着您可以使用高偏差和高方差模型的组合来获得两全其美！
集成学习有三种主要形式:打包、提升和堆叠。如果你感兴趣，还有第四种类型的集成，称为级联——它处理高度不平衡的数据。所有不同类型的集成学习都是组合模型的技术。
过度拟合的问题是，随着训练数据的改变，测试数据的性能完全改变。理想情况下，对于不同的训练数据集，性能应该保持一致，这表明模型已经能够通过过滤掉噪声来提取基础数据模式。
这就是交叉验证进入图片以检查训练模型的一致性的地方。顾名思义，交叉验证是一种在验证数据的不同折叠上迭代测试模型的验证技术。
最常用的技术是 k 倍交叉验证。首先，我们将训练数据集分成 k 个折叠。对于一个给定的超参数设置，k 个折叠中的每一个都轮流成为拒绝验证集；然后，在剩余的 k-1 个褶皱上训练一个模型，并在保持褶皱上进行测量。
正如在“数据不足的原因”中所讨论的，一些数据类型的来源有限，因此数据量也有限。例如，如果有人想训练一个模型来预测对客户关怀电话的回复，他们需要根据过去对话的有限记录来训练模型。
这就是迁移学习非常有用的地方。由于该组织的客户关怀部门的对话记录有限，因此没有足够的数据供模型学习语法或解释新客户可能键入或说出的新单词。因此，已经在具体语料库(单词集合)上训练的模型可以与新模型集成。这就是从现有模型中获得的经验如何“转移”到新的解决方案中。这只是一个高层次的例子。迁移学习的概念和应用是巨大的。
Fig 4: Transfer Learning | Image from O’Reilly
如何扩展数据集
以最小的过度拟合高效地处理更少的数据是值得称赞的，但是在大多数情况下，有确定的方法来扩展数据集的大小。
技术途径
- 合成数据增强
当通过各种技术(如近似法)从现有数据中生成数据时，这被称为合成数据扩充。合成数据与原始数据相似，但为机器学习模型学习数据趋势提供了足够的方差。
SMOTE 或合成少数过采样技术是通过克服数据不平衡来消除过拟合的另一种方法。另一种消除数据不平衡的方法是对多数类进行欠采样，但这会导致数据丢失，这是不利的，尤其是当数据量较小时。
与随机过采样技术不同，SMOTE 专注于少数类，并通过相邻点之间的插值来创建与之相似的新数据点。SMOTE 使用 K-最近邻算法来识别邻居。
Fig 5: New datapoint X1 being created between 4 neighbors | Image from Github
SMOTE 的一个明显缺点是，它倾向于在两个不同类别的边界线附近创建模糊的数据点。例如，当 X13 和 X12(参见上图)来自 A 类，而 X14 和 X11 来自 b 类时，就会出现这种情况。这是点 X1 的分类变得复杂而不是简单的情况。
因此，边界线 SMOTE 考虑了边界线附近被错误分类的困难点，并且仅在该部分中生成更多的样本，以通过体积使区别更加清楚。
ADASYN 或自适应合成采样方法是 SMOTE 的另一种形式，也对少数类进行过采样。然而，与 SMOTE 和边界线 SMOTE 不同，ADASYN 考虑数据分布的密度，并相应地决定在特定区域中需要生成多少数据点。
因此，在特征空间中密度低的地方，ADASYN 将生成更多的样本，反之亦然。下图显示，对于每个正在创建的新点，ADASYN 都会考虑 8 个相邻点区域内多数类和少数类的相对密度。创建的数据点数量与密度成正比。
Fig 6: ADASYN at play | Image from Github
GANs(生成对抗网络)是人工智能领域的一个有趣的发明。大多数关于机器完成出色的类似人类任务的新闻文章都是关于甘斯的工作。
在现实世界中，你可能已经注意到，面对逆境或竞争，生物往往会变得更强大。一颗种子击败了它的兄弟姐妹和邻近的种子，长成一棵强壮健康的树，随着世代的延续，增加了更强壮的后代的机会。类似地，一个拳击竞争者估计他/她的竞争者的质量，以相应地做好准备。竞争者越强，准备的质量越高。
甘人几乎模仿真实世界，效仿并遵循对抗性训练的体系结构。对抗训练无非是“比较学习”。研究可用的样本，使得 GAN 可以创建来自相同类别的样本的其他实例。GAN 的目标是创建缺陷最少的样本，使它们与原始数据集无法区分。例如:GAN 可以创建新的文森特梵高风格的绘画，这样它看起来像是由画家自己创建的(GAN 还没有这么先进，但这是潜在的概念)。
在 GAN 中有两个对应物:发生器和鉴别器。发生器的工作是调整 GAN 的输出，使它们与原始信号无法区分。鉴别器的工作是判断生成的片是否合格，是否可以与已经存在的样品同等分类。否则，重复该循环，除非发生器产生足够好的样本，鉴别器不能从原始样本组中区分该样本。
变分自动编码器是深度神经网络，它依靠概率来创建新样本，特别是对于不平衡的数据。杰瑞米·乔登用一个出色的例子通过简化的直觉传达了变分自动编码器(VAE)的功能。
在该示例中，需要生成人脸的图片，使得新的人脸与原始样本集无法区分。因此，对于 VAE 遇到的每一张新图像，它都会创建该图像每个特征的概率分布。例如，微笑的人的概率分布，或者头发是直的概率分布等。
一旦一组这样的分布可用，VAE 从分布中随机采样(从分布中选择的随机特征值)以重建图像，因此在概率范围内创建同一图像的多个变化。
Fig 8: VAE used to create variations in the same image | Image by Jeremy Jordan
数据池意味着收集相关数据并将其添加到现有数据集中。这是一个敏感的过程，需要小心处理:
- 了解数据缺陷
要汇集相关数据，您需要了解数据中现有的缺陷类型。例如，如果有人缺乏维生素，最好的方法是找出哪种维生素缺乏，一旦确定，只服用特定维生素的补充剂。
类似地，在冒险寻找丢失的部分之前，数据中的缺陷类型是一个关键阶段。是数据有缺失值，还是不平衡，缺少少数数据点？数据是否缺少一些重要的特征或者需要更多的行/数据点？在搜索更多可以整合到现有数据集中的数据之前，必须考虑这样的问题以及更多的问题。
- 了解统计缺陷
一旦具体的缺陷问题(如缺失数据和数据点或特征不足)得到解决，还需要一个步骤来识别数据模式中的缺陷。
例如，如果收集了一个班级 10 名学生的身高，则不足以创建一个分布。鉴于数据的规模，即使经过过采样，数据也可能不符合任何分布，因为，比方说，这个班级碰巧有大多数高个子学生。然而，我们已经有了很多开源的身高数据，正如我们所观察到的，它们趋向于高斯分布。
因此，为了能够使样本集符合适当的分布，您需要确定一个相似的数据源，并以最小的偏差仔细采样。
与上面的高度示例一样，识别相似的数据源有助于扩展数据集，而不会对样本集的完整性造成太大损害。大多数数据都不是唯一的，大多数数据都是有用的，并且具有提供洞察力的内在目的。
- 了解业务限制并相应扩展
通过外部数据源进行扩展的一个限制是，它可能不符合业务需求。考虑两个客户端及其数据集，它们在分布和功能方面看起来很相似，但由于生成数据的过程完全不同而无法集成。这限制了未来因业务流程变化而造成的中断。同样，这意味着在为什么两个数据集被整合的背后必须有一个逻辑推理。
- 了解合规限制
数据池也会引发安全问题。因此，在处理投入生产的实际解决方案时，开发人员需要小心诸如数据来自哪里，或者现有数据是否保密之类的事情。例如，一个组织可能有 10 个具有相似数据的专属客户，但是如果每个客户都让该组织签署了保密协议，则没有数据可以交换以用于最佳模型构建。
非技术途径
一些非技术性的、面向业务的方法也可以帮助数据团队收集更多的数据来扩展现有的数据集。
- 创建免费应用程序来收集数据
创建一个有用的应用程序可以带来大量的数据，尤其是如果这个应用程序是免费的。例如，组织可以使用记录用户睡眠模式以帮助他们维持更好的睡眠周期的应用程序来了解睡眠模式不佳的根本原因。
如果你在免费的问答网站上玩得开心，你一定遇到过可选的数据调查。即使是测验数据，如果设计得当，也可以用来记录和扩展现有数据。通常，大型研究项目使用来自多个网站的数据来生成一个巨大的语料库，以研究大规模模式。发送调查的其他方式是通过电子邮件或目标频道上的主动广告。
一些受欢迎的网站和频道收集并保存大量数据，然后出售给需要的组织。一个流行的例子是脸书，它跟踪用户行为并将这些数据出售给广告商，这样他们就可以锁定行为符合特定消费模式的用户。这里需要注意的一点是，只与可信的买方或卖方交换数据。
最后一个音符
每隔一天，就会有更先进的技术(GANs 是一种相当新的技术)取代旧的技术，数据扩展或现有数据优化的可能性和方法是无止境的。
我们已经探索了几种技术，我建议您更深入地学习您最喜欢的技术。
注:我使用了来自医疗保健 的 GANs 的自引
能让你的 ML 团队会议更有效的 9 件事
原文：https://web.archive.org/web/https://neptune.ai/blog/machine-learning-team-meetings
根据 WaveStone 的一份报告，超过 90%的领先公司目前正在对人工智能进行投资——这是一个重要但并不令人惊讶的结果，反映了机器学习时代的蓬勃发展。由于其数据不可知的性质，其应用迅速扩展(例如，完全连接的网络可以用于天气预报以及房价预测)。随着企业集团的成功，许多初创公司也出现了，为传统问题提供现代人工智能解决方案。
然而，就像任何其他技术一样，成功的采用需要有组织的协作，然后是计划周密的执行。由于机器学习相对来说是小众的，并且与许多其他计算机科学领域有很大不同，公司，特别是初创公司可能会努力找到最佳策略来将机器学习融入日常生产中。因此，会议成为决定 ML 项目最终结果的一个重要方面。
这篇文章深入探讨了一些可以提高你的 ML 会议效率的小技巧。特别是，我们在 ML 项目开发的不同阶段提供会议提示，以确保整个过程的顺利进行。
先决条件
本文特别关注较大规模的 ML 模型(例如深度学习模型)，而不是传统的较小模型(例如线性/逻辑回归)，因为较大的模型表现出更多需要缓解的问题，以进行更有效的会议。为了给出更具体的视角，我们首先提供深度学习模型如何工作的概述。
深度学习是传统机器学习模型的一个分支，它利用了一种称为神经网络的特定类型的模型。神经网络受到具有多个神经元的复杂大脑结构的启发，神经元的激活是网络的最终预测。
对一个神经网络来说，人们必须通过一大组数据集，计算预测和增长真相答案之间的差异，并“反向传播”以更新神经元。反向传播必须重复进行，以允许模型缓慢地收敛到接近最优的解。随着可用数据的增多或模型复杂性的增加，处理时间也会增加。
为此，如何及时组织会议并避免浪费时间变得尤为重要。
前期——在实施 ML 项目之前
当提出一个 ML 项目时，无论该项目最终会给公司带来什么好处，都应该首先从现实世界的角度考虑项目的可行性。以下是需要强调的要点(有些是在会议之前，有些是在会议期间):
1.有可用的数据集吗？
在参加会议讨论您的项目之前，您应该对哪些数据集可能适用于您的任务有一个大致的了解。当你的任务应该被监督时，这一点尤其重要。也就是说，使用您的预测来计算误差和损失函数需要基本事实。
数据收集是劳动和时间密集型的，因此，在确认是否有足够的数据来执行训练之前，跳入 ML 项目并开始设计架构是低效的。
如何进行粗略检查？
-
公共数据集通常在 Kaggle/publications 上提供。第一步是浏览并查看是否有任何数据集与您的目标应用程序相同或相似。
-
如果数据集有些相似但不完全相同，那么您的团队可能需要收集一些额外的数据，并将其添加到您的训练集中。请注意，根据您团队的规模，这将占用大量时间。
-
最后，如果没有一个数据集是相似的，那么最好在一系列会议开始时解决这个问题，让团队知道。
2.在任何实施之前研究最先进的架构&让您的会议成为方法的分享会议
State-of-the-art Machine Learning algorithms | Source
-
虽然 PyTorch 和 Tensorflow 等库已经使神经网络的实现相对简单，但重要的是收集和分析以前的技术，而不是从头开始构建一个全新的网络。ML 是一个快速发展的社区，每次会议都有数千篇论文(和潜在可用的代码)发表。快速发展意味着今天采用一篇论文将大大加快你的设计阶段，并允许你做更多的测试。
-
一些值得注意的研究方法是浏览相关的顶级 ML 场所，如 ICLR、ICML、AAAI 的 NeurIPS，以及特定领域的会议，如 CVPR/ICCV 的计算机视觉和 ACL/EMNLP 的自然语言处理。虽然这项任务看起来很耗时，但是通过知道使用正确的工具，它将大大减少项目的实施时间。
-
提前搜索这些架构，并让你的会议成为一个分享会议，这也是让每个团队成员跟上进度的有效方法。事实上，这种会议已经被学术界的研究小组广泛采用。许多论文需要复杂的数学推导和理解，所以一个人的报告将极大地促进小组内的理解。
3.计算可行吗？
在决定项目和方法之后，在开始阶段解决项目的可行性也很重要。可行性的含义远远超出了“训练这个模型可能吗”，还延伸到“我们能不能训练这个模型”。这是现代深度学习问题中存在的一个关键问题；变压器等模型可能需要多个高端 GPU 来进行推理！下面我们描述值得在早期 ML 会议中讨论的记忆和时间限制。
计算开销
虽然经验法则是更复杂的模型通常在更复杂的情况下执行得更好，但是在准确性和存储空间要求之间经常存在折衷(例如，视觉转换器(ViT)通常比 ResNet 执行得更好，但是同时也大得多)。因此，深入研究您可能要实现的方法并交叉检查文章中关于所用 GPU 的任何实现细节是非常重要的。很多时候，牺牲一些准确性来保证生产顺利进行是可行的(也是明智的)。
训练时间
深度学习模型的另一个缺点是它们的训练时间。与学术界可能需要更长的培训时间不同，初创公司在将模型投入生产之前有一个时间表。在这种情况下，像培训前的无监督学习这样的项目，以其长时间的培训而闻名，可能不是一种可行的方法。综合考虑训练时间和计算资源也很重要，30 分钟的 TPU 训练可能意味着 Nvidia 1080Ti 的 2 周！
另一方面，一个解决方案可能是找到并使用预先训练的检查站，以节省培训成本。针对 ViT、ResNet、 BERT 等流行网络架构，在大规模数据集(如 ImageNet)上训练的检查点往往是可用的。从预先训练的检查点开始训练通常会导致更快的收敛，即使任务略有不同。
另一方面，使用预先训练的模型通常意味着在决定模型架构时灵活性较低，如果目标领域非常不同，微调仍然是一个昂贵的过程。
与人们可以快速验证其准确性的其他算法不同，深度学习算法要经历训练和验证的周期，以了解哪些地方可以进一步改进。在本节中，我们将介绍几个技巧，它们可以加快您的会议，使实施更快，尽管需要等待培训时间。
4.安排会议以确保所有环境都是一致的
根据手头的任务，深度学习模型可以包含多个模块。因此，确保开发的所有方面都在一个一致的环境中用库来完成是至关重要的，这样模型在组合时就不会崩溃。从这个意义上来说，会议更有利于建立每个贡献者的环境。这也将允许人们快速使用另一个人的代码/检查点进行培训/微调，并显著减少进一步会议的需求。
这样做的一些技巧包括:
-
决定使用 PyTorch 或 Tensorflow ，并确保相同版本的库。如果您使用更高级的软件包，如 PyTorch Lightning，请仔细考虑将所有模块打包到一个大模型中可能带来的困难。
-
使用与单个或多个 GPU 相同的设置。多线程上的代码不一定能在单 GPU 机器上运行，反之亦然。关于这一点，当组合更多模块时，还必须仔细考虑存储器需求。确保数据并行性或分布必须在模型训练方面达成一致，以避免仅仅为了整理和重新处理它们而需要的任何额外会议。
-
详细记录运行特定模块所需的库和版本。换句话说，如果其他人可能需要安装和运行您的代码来进一步构建它，请保留一个 readme 文档。
5.调查可以同时完成的任务，明确任务分配
MLOps life cycle | Source
坦率地说，尽管将工作分配给不同的角色对于任何编码项目来说都是很好的实践，但对于 ML 项目来说尤其重要，因为实验阶段的处理和培训周期可能需要几天甚至几周。如果一个人没有认识到这种设置，并创建副本，这将是一个巨大的时间浪费。
许多任务，如数据处理、模型架构设计和度量评估实现，可以同时完成，以减少深度学习模型训练的开销。在这一阶段，沟通是防止重复相同任务的关键。因此，在会议中决定哪些事情可以同时完成，并将任务分配给不同的团队成员也可以节省大量的时间。
6.有一个单一的地方来存储所有关于您的项目的信息
如果两个人在同一个网络架构上工作，但是在测试不同的超参数，请确保在已经运行的设置和将要运行的设置之间保持共享记录。这可以显著减少相互更新所需的时间，并允许每个团队成员对当前的进展和仍然需要做的事情有一个粗略的想法。
在 MLOps 领域有许多工具可以帮助解决这个问题。像 Neptune.ai、Weights & Biases 或 Comet 这样的平台可以成为整个团队的一个很好的事实来源。它们让你跟踪所有的元数据和实验，注册模型，比较它们，并与其他人合作。
深入了解 Neptune.ai 及其在 ML 团队会议中的作用:
- 最后，通过利用类似的工具，讨论检查点结果并相互共享检查点将消除过多的会议，并使项目管道更加有效。人们可以在他人的基础上稍加改进，进一步将它们整合到自己的测试中。
7.持续关注顶级场馆的新架构/数据扩充。对多个测试用例执行严格的测试。
神经网络模型的实现和测试可能需要几个月的时间，在此期间，新的架构/代码可能会迅速出现，以解决您试图解决的问题的特定方面。因此，每周/每月检查不同的技术，无论是架构本身还是数据扩充都应该在会议上进行和展示。通过这种方式，一个特定的方法可能是有帮助的，并且与当前的团队实现正交，可以快速地合并到生产周期中，从而导致更快的开发。
要记住的一个重要想法是，许多在学术数据集上工作得很好的架构/增强方案可能在真实世界的测试中工作得不好。因此，虽然在这个阶段并不是所有的数据集或真实场景都适用，但我们必须在不同的情况下进行仔细和严格的测试，并尽可能多地模拟可能发生的“事故”。
8.不要召开没有结果的会议
数据科学团队会议应该只讨论实际结果
这也许是让你的 ML 会议有效的最重要的提示。与程序应用或传统算法相反，深度学习模型的评估和可视化需要相当长的时间来运行，更不用说长时间的训练周期，在此期间人们除了静静地等待什么也做不了。如果培训仍在进行，或者评估需要一两个小时才能出现，那么见面只是浪费时间。如果结果还没有准备好，推迟会议将比推测一个不能加速的结果更有益。
另一方面，由于前面提到的 ML 模型训练时间的限制，建立自发的会议来解决新发现的结果(在架构和超参数方面)可以防止在类似任务的不同设置中工作的人走进许多死胡同。特别是，如果团队有一个指定的准确度阈值要达到，那么应该很快安排一个会议来阻止进一步的训练，并转移到项目的其他方面。
最后阶段–部署
9.将工作分为部署和持续改进，并密切讨论它们。
当你的 ML 模型在实施阶段达到预先设定的目标后，使 ML 会议有效的最后一件重要事情是将剩余的任务大致分为三类:
-
检查现实世界应用中的域转移结果:无论训练进行得多么严格和细致，训练和测试数据集中不可避免地存在变化。这将有助于团队的一部分快速测试并报告验证和真实测试数据集方面的差异。通知大的差异将允许团队快速跳回到中间阶段并继续实现过程。
-
部署到应用:部署到应用(如 App、平台、网站)也是一个耗时的过程。人们应该开始这个过程，并实现应用程序的大部分，以使模型插件流畅。
-
对当前模型的微小改进:这表明小的超参数调整不需要大的模型改变。这些变化可以为模型性能提供最后一点提升，同时快速应用到即插即用的产品中。
CI/CD 管道
Structure ML team meetings around CI/CD workflow | Source: Author
机器学习和软件工程社区中广泛采用的一种常见方法是将项目作为 CI/CD(持续集成/交付)来处理，其中您试图在构建、测试和部署中实施自动化。它允许对当前代码进行增量更改，以获得进一步的改进。
此外，还应该对模型进行广泛的 QA，以确保它们在生产阶段顺利工作。这允许在有多个模型要部署的初始阶段进行更快的部署。像 Jenkins 这样的工具在执行这些任务时可能会有很大的帮助。
结论
现在你知道了！9 个小技巧，帮助你一路提高 ML 会议的效率。虽然所有的项目都是不同的，但是关注新的研究，分配任务，建立自发的联系，一定会让你的 ML 会议更好，生产更快！
参考文献:
用 michatadeusiak 管理计算机视觉项目
这篇文章最初是 MLOps Live(T1)的一集，这是一个互动的 Q(T2)环节，在这里，ML 从业者回答来自其他 ML 从业者的问题。
每集都专注于一个特定的 ML 主题，在这一集里，我们和 Michal Tadeusiak 谈论了管理计算机视觉项目。
你可以在 YouTube 上观看:
视频
或者作为播客在以下位置收听:
但如果你更喜欢书面版本，这里有！
您将了解到:
计算机视觉项目的步骤和里程碑
- 管理计算机视觉项目的非技术方面
- 3 最大的失败和教训
- 4 构建 CV 项目团队
- 5…等等。
- Sabine Nyholm: 欢迎回到另一集 MLOps Live 。我是萨宾，你的主持人。和我一起的还有我的搭档主持人斯蒂芬，今天和我们在一起的还有迈克尔·塔德乌西亚克，他将回答关于管理计算机视觉项目的问题。
Michal 是 Deepsense.ai 的 AI 总监。他拥有巴黎理工大学和华威大学的两个复杂系统科学硕士学位。他领导过几个数据科学项目，涉及制造、零售、医疗保健、保险、安全等多个行业。此外，科学项目围绕技术，如预测建模，计算机视觉，自然语言处理，以及一些个人资料，如商业概念证明和竞争研讨会。
对我来说，列出你没做过的事情会容易得多，迈克尔。欢迎光临。你还有什么要补充的吗？
Michal Tadeusiak: 感谢您的介绍。原因可能是我已经在一家为客户做项目的公司工作了将近七年。我们无法控制这些项目的流程，也无法控制谁会是下一个目标，以及面临怎样的挑战。因此，我得说，这份清单相当宽泛。
一分钟管理计算机视觉项目
萨宾:绝对的。Michal，为了让你对所有这些问答有个热身，你能在一分钟内向我们解释一下如何管理计算机视觉项目吗？
管理计算机视觉项目，我要说的是，有一些东西仅仅与管理一般项目有关。尤其从我的角度来看，我正忙于为外部客户做项目。这是一个主要方面。我认为管理人员是最重要的部分。
Michal: Managing computer vision projects, I’d say that there’s something that is related just to managing projects in general. Especially from my point of view, I’m busy with projects for external clients. This is a major aspect. I’d say that managing people is the most important part.
1 一方面，这是一个我们必须共同管理的客户，我们必须了解其目标、范围、时间表和期望。这些都是非常关键和重要的方面。
- 2 对方正在管理团队开发项目。我们看到，比方说，人们的动力，在团队精神中为一个目标奋斗的感觉。这些可能是最重要的部分。
- 斯蒂芬:听起来完全像是典型的项目管理困境。非常感谢你的分享，迈克尔。
计算机视觉项目的典型步骤
Stephen: 我们现在正专注于计算机视觉，你能向我介绍一下从你开始与利益相关者讨论业务方面并提出业务需求开始，建立普通计算机视觉项目的典型步骤吗？你能给我介绍一下这个概念吗？
计算机视觉部分通常一开始就不太相关。
1.你想从
理解目标，
- 理解整个公司的商业目的
- 客户需要什么。
- 不一定一开始就是技术讨论。讨论的目的是理解主要的棘手问题，然后了解总体上业务是如何运作的。
然后还要讨论更多的技术细节。然后，根据另一方客户的成熟度和他们的技术水平，你可以深入了解或不了解技术细节。
一般来说，首先是把这个商业问题翻译成技术术语，尤其是机器学习术语。
2.然后，定义目标之后通常要做的第一件事，范围就是看数据。我的意思是要确保有足够的数据和标签来处理这项任务。特别是在计算机视觉项目中，我认为这与不同的 ML 项目相比是非常容易的。
在计算机视觉中，一旦你获得了哪怕是一个图像样本，就已经很清楚这个问题有多困难了。当我们谈到类似于 NLP 问题或带有表格数据的经典 ML 问题时，数据可以分布在巨大的数据库中。你必须做大量的清理、合并等工作。这是一件困难得多的事情。对于计算机视觉来说，这是一件非常容易的事情。
3.一旦我们有了它，那么开发项目的一般生命周期就会继续。不过，最重要的一点是，你必须与客户密切合作，让他们参与决策过程。还有，在对解决方案的评估中，像它为什么会进化，为什么会改变。
斯蒂芬:如果你可以的话，当然，我知道你在 Deepsense 做了很多事情。你能告诉我们一个计算机视觉项目的例子吗？在这个项目中，你与利益相关者交谈，你必须与客户就许多事情达成一致，或者不达成一致，并且实际上交付可工作的软件。
迈克尔:我可以给你举一个很好的例子，我想说的是我们为一家轮胎制造商做的一个严肃的项目。问题是制造的轮胎的质量保证。
这是当客户第一次问我们是否可以提出模型来检测不同的缺陷，评估严重性和类型，然后可能还会将它们分类为需要干预的和可以通过并且它们很好的。我们认为，当然，我们可以，但有很多要求，很多事情必须到位，以使它。
最后，模型显然就像数据科学家忙于的主要部分或关键部分，但还有许多其他事情必须首先得到保护。事实证明，这不会太容易，因为这是他们网站上一个非常初步的概念 ID。他们没有标签。他们还没有建造完整的设备来收集数据，等等。
我们正在帮助他们形成端到端的解决方案。最后我们不仅做了模型，然后我做了一个类似 ML 的解决方案。我们为他们设计和开发了一个贴标工具，专门用于给轮胎贴标，这不仅仅是我们拥有的常规图像。
一件事是轮胎有其相关的扇形区，但我们正在处理的一些缺陷也可以在图像中识别出来，就像视觉方面是关键的，像划痕或一些气泡，等等。还有一些更像是变形，很难注意到，像一块黑色的橡胶。因此，我们也有一些三维图像。
整个解决方案是将来自 2D 和 3D 的信息结合在一起。一旦我们为他们完成了标注工具，他们也完成了我们帮助他们完成的标注过程，接下来就是建模部分，这也需要一些时间。这是一个解决方案，可以解决质量保证对正常工作流程的干扰，这里有很多重要的方面。我的意思是如何处理这个，如何处理模型的输出，比如如何建造整个管道的其他部分，设施，做什么，等等。
一旦我们知道了什么样的缺陷会出现，什么样的缺陷会返回给他们，那么他们就可以设计进一步的步骤。它的端到端范围比最初想象的要广得多。
Stephen: 从这里我能得到的是，它超越了技术方面。建模只是部署的一小部分。必须有商业对话和所有这些事情。非常感谢你分享你的知识。
Stephen: 假设你被雇佣去清理一个计算机视觉模型，一个计算机视觉项目，可能这个团队以前已经做过，现在有点乱。你有 90 天的时间，你会先做什么？你加入一个团队，他们开始做这个特别的简历项目，然后不知怎么的就开始了。当然，他们雇佣你来清理项目。在最初的 90 天里你做什么？
九十天并不算少。当我们处理项目时，通常，我们喜欢把它们分成 3 个月，大约 90 天。正如你提到的，这个现存的遗留项目。
我可能会首先尝试了解问题所在。如果维护问题或性能问题，或数据流的一些问题，这是需要的。根据问题所在，你会用完全不同的方式来解决它。
Michal: Ninety days is not too little. When we work with the projects, quite often, we like to split them into 3 months periods, which is roughly 90 days. As you have mentioned, this existing legacy project.
1 如果性能是问题所在，那么首先要看结果，看网络产生了什么或解决方案产生了什么。
然后试着追溯到架构和它是如何构建的，看看问题可能出在哪里。如果问题出在维护上，因为你看到它就像一个意大利面条式的代码，甚至很难引入任何改变。
- 然后，可能在 90 天内，我们能够建立一个新的解决方案，一个更干净的解决方案，并尝试恢复现有的解决方案。
- 对于我习惯的计算机视觉项目来说，90 天是相当长的时间。
- 管理计算机视觉项目的非技术方面
斯蒂芬:现在我们稍微离开一下技术层面。我假设在考虑建立计算机视觉项目之前，一个组织或任何团队都应该具备一些内部知识或技能。那些是什么？我该怎么想？我会花相当多的时间在非技术方面。当我在考虑度量标准、目标和管理 CV 项目的所有事情时，我应该考虑哪些事情？
当我们希望尽可能广泛地与客户接触时，我将再次从咨询公司的角度来谈论这个问题。在这个业务部分，我们不仅仅是在技术方面。我要说的是，客户端需要什么在很大程度上取决于客户端的成熟度。也许，我会从简单的开始。
Stephen: Just moving away from the technical side a little bit now. I assume that some internal knowledge or skills that may be an organization should have or any team should have before thinking about setting up computer vision projects. What are those? How should I think about it? I will spend quite a reasonable amount of time on the non-technical side. What are those things I should think about when I’m thinking about the metrics, the goals, and everything when managing CV projects?
1 更容易的是那些已经有一些数据科学团队的人，他们的合作伙伴每天都在处理 ML 或计算机视觉。他们只是没有足够的能力来解决所有的挑战。那我们就是来帮忙的。
2 更有趣的是那些没有数据科学团队的公司，或者有时他们甚至没有像生活在 21 世纪的公司那样的软件开发人员。很明显，现在有很多系统，等等，但是他们可能甚至没有软件开发人员来接手，或者他们可以重新认证或改变他们的客户技能，成为一些初级数据科学家。这些是最有趣的。我们喜欢和这样的客户一起工作，因为从他们的工作和我们的工作中可以学到很多知识。
- 那么，在这种情况下，我们需要的肯定是这种意识，即通过开放，我们可能无法在一开始就指定某件事情会有多好。数据科学仍然非常接近，它介于工程和研究之间，而且通常很难首先说出将获得的非常精确的性能。开诚布公地共同解决问题是关键。
- 这通常不是关于公司中的技术人员，而是与利益相关者，然后我不知道，企业主，他们将致力于共同解决问题，对这种双向的知识信息转移持开放态度。
项目的业务方面与技术方面
Stephen: 你遇到过业务人员和技术人员意见不一致的情况吗？你遇到过那样的情况吗？当然，你提到必须有知识的转移。如果业务涉众和技术涉众意见不一致的情况经常发生，那该怎么办呢？您是否遇到过这种情况，您如何建议技术团队应对这种情况？
Michal: 这通常不是技术方法的情况，这也不会被接受。实际上，在某些情况下，企业主似乎也很专业，然后他们会有自己解决问题的想法。
通常，您不希望业务所有者对您的解决方案的实现和开发计划产生太大的影响。
当然，你所期望的是通过优先级来指导你，比如能够回答关于问题的细节，但不一定建议使用哪种架构或哪种模型。
因此，我们有一些问题。那么，最后，我能说什么呢？最后，两个部分协调起来需要花费更多的时间，而且还涉及到实际处理客户的想法。此外，每当其他想法不够充分时，就推行我们的想法。这很棘手。
我不确定我是否能给你一个更好的答案，只是与客户进行对话，然后让他们准备好，如果我们也想尝试你提出的东西，那么我们肯定会花更多的时间。如果你没意见，那我们就开始吧。
计算机视觉项目的架构
Sabine: 完全有道理，根据任务的不同有不同的需求。这里的下一个问题是，这些年来，你是否有一些被证明对计算机视觉项目最健壮的架构。你有这样的东西吗？
我坦率地说，当我更接近技术层面的时候，我更接近技术领导者的角色，而不是更接近形成解决方案的角色。当时，当我们要做出选择时，取决于某些要求，我的意思是，如果我们有一些计算限制，那么有一个主要的事情要考虑。
那么我们宁愿坚持说 YOLO，因为它不使用太多的资源或屏蔽 R-CNN 或更快的 R-CNN，这通常更准确，但显然更难使用。那是一段时间以前的事了，但是它们仍然很受欢迎。新一代的 YOLO 仍在不断更新。然后是更快的 R-CNN 或 Mask R-CNN，它们仍被用作框架，但主干不同。他们仍然在那里，但有时，他们都不是很好，或者对我们来说不够好。
尝试不同的架构也很好。如果手头的问题并不常见，不要羞于尝试不同的架构。还有，给你举几个例子。其中一个项目，当我们不得不开发我们自己的架构时，也是在一段时间以前，大约四年多以前。
我们处理了化学设施示意图的图像，那里有很多泵，阀门，它们之间的管道，等等。这个原理图通常是这样的——一张纸上有 100 个，比如 200 个不同的符号。其中一些非常相似，因为你可能有五种不同类型的瓣膜，但作为一种象征，它们不会有太大的区别。然后是一些测量设备的符号，等等。对于这类事情，没有一个真正好的网络。在这种情况下，屏蔽 R-CNN 或更快的 R-CNN，就像处理有几个物体的图像一样，只是比较大，而不是很小。
我们必须拿出一个专用的架构，我要说的是，如果我们要与一些现有的架构进行比较，这将是某种未来的金字塔网络，加上完全传统的架构，我不想过多地谈论细节，但是的，有时这是唯一的出路，就是进行实验和发挥创造力。
萨宾:我相信这一定令人印象深刻。
尽管如此，我还是想说，从一些现有的解决方案开始，仅仅是为了基线，肯定更快更可靠，这是值得的。
计算机视觉项目的里程碑
Sabine: 我们想更多地了解一下你们的项目进程。在这样的过程中，你通常会有多少个里程碑？
里程碑是整个画面的一部分。我的意思是在讨论如何处理计算机视觉项目的时候，一般来说就是机器学习项目。我个人非常喜欢这个领域最流行的 crisp DM 工作流程或方法。这是第一批中的一个，然后是这个方法没有完全抓住的一些东西。不可能有很多不同的 golden grails，目前已经有几种不同的方法。最后，他们彼此不会有太大的不同。
我的意思是，机器学习项目中最核心的东西是解决问题和回到里程碑的交互过程。
1.我要说的第一个里程碑之一是，如果我们在项目开始之前没有数据，就要把数据、数据集放在适当的位置。这是要拥有的核心东西之一。我们希望在开始之前将数据集准备好。有时候是不可能的。有时数据是在途中收集的，或者只有当我们与客户谈得更多时，我们才能更好地理解。他们知道需要什么，然后他们会给我们更多所需的数据。
第一个里程碑是拥有，比如说，运营数据集，你可以从它开始。通常，这应该是项目的早期阶段。
2.接下来的里程碑是我称之为解决方案的框架。当管理 ML 项目和计算机视觉的时候，我认为最重要的是首先要有一个最小但有效的端到端解决方案。
我的意思是会使用数据的东西，即使它是一个小的数据集或者只是你将要拥有的数据集的一部分。您将能够加载它来做一些简单的预处理或任何需要的事情，以便能够运行模型和训练第一个模型。你甚至不需要一开始就有模型。你可以使用一些试探法或一些常数模型。这是首个端到端解决方案，您甚至不需要进行培训。
3.然后是指标的验证程序和计算，类似于评估步骤。
4.一旦你有了它，然后可能是一些可交付物。你可能需要以某种格式，某种 JSON，或者某种可视化返回你在那里找到的东西，这一块也是如此。
一旦您有了这个端到端的解决方案，即使它是非常基础的，您也已经有了可以构建的东西。这有多重目的。
一个是现在问题可以被分解，人们可以在不同的方面并行工作。
一个人可以处理数据，输入更多的数据，
-
另一个可以从更复杂的验证程序或模型开始。
- 比方说，你在开发中越深入，并行性就越强。
- 另一件事是，您启动主监视器的结果，您将有第一个基准进行比较。这很难说，比方说，你在某个时候达到了 90%的性能，比如 F1。如果你不知道什么是随机猜测或启发式的基线得分，你甚至不能说它是好是坏。
-
一旦你有了它们，只有这样你才能评估表现，然后做里程碑，第二个里程碑是有了框架。
5.然后，剩下的里程碑，也就是针对一个特定的项目。取决于它是否更接近用户，你会在某个时候期待一些用户反馈。
6.另一个里程碑是有一个 MVP 可以展示给一些用户玩。如果它更多的是作为某个 web 应用程序的一部分，你会在哪里使用它，你可以在这个基础上构建后端，然后通过一些 API 服务于这个前端？那就看情况了。
当然，前两个是主要的，最重要的。
Sabine: 这在细节上的确是一个很好的里程碑。斯蒂芬，如果你在线上，请回电。
计算机视觉项目中最大的失败
很明显，我想知道 Sabine 之前什么时候看过你的个人资料，你所做的大量工作也很鼓舞人心。我想知道，在你长期从事计算机视觉相关项目的过程中，你有什么我们称之为最大的失败，你愿意分享吗？也许，这是你应该知道的事情，也许你已经克服了它们。
失败，当然，有很多失败。其中之一是当我们甚至没有开始项目时，失败首先是因为我们无法与客户达成一致。
1.比方说，客户离 IT 部门非常远。他们是一些塑料桶的制造商，我甚至不知道他们想要什么。这是一个基于人工智能的监控解决方案，用于观察人们是否因为一些重型机器工作或其他情况而没有进入他们不应该去的区域。比如说，如果垃圾桶装满了，专门用来装塑料或金属之类的东西。然后，他们可以计划清空它们。所以喜欢不同的方面。
一般来说，从 ML 的角度来看，这些事情不会太难。他们对待我们的方式就像对待一家公司一样，他们会重新组织他们的工作场所，比如在那里安装一些墙壁，额外的墙壁，或者安装一些额外的照明设备。这就像他们要求非常严格的时间表，没有缓冲的余地。他们非常严格地要求我们定义性能、要求等等。我们和他们讨论了几个星期，甚至去了这个地方。
最后，你就是启动不了。区别在于我们使用的语言和期望太大，以至于无法开始。这是失败之一。我们在这个项目上投入了相当多的时间，但最后，我们甚至没有开始。
2.我也有另一个，它是失败的，但在某种程度上也是成功的。我的意思是，他们是一个非常复杂的项目，我们已经做了 10 个月左右，最终证明不是那么成功。我的意思是这是一个非常大的团队在做这个项目。这是一个涉及 ML 方面的项目，但也有很多不同的东西，如前端和 UX，用户界面，并建立整个解决方案后端。
最后，结果是这样的，但是我相信，现在的技术还不能解决这个特殊的任务。我们总是差一点就到了，但从未到达。然后，它最后是失败的，我们没有真正解决它，大量的钱去了那里，所以，相当失败。
尽管如此，好消息是我们仍在和这个客户合作。他们发现用现有的技术是不可能解决这个问题的。他们仍然相信我们，相信我们会竭尽全力做到这一点。我们已经在一起合作几年了。最后，成功也。
斯蒂芬:我们非常喜欢本期播客中的战争故事。这些都是从战壕中得到的教训，我们认为团队绝对可以把它们作为带回家的教训。
管理计算机视觉项目与管理其他 ML 项目
斯蒂芬:我想你之前提到过计算机视觉项目更容易管理。我很想知道，在你看来，管理一个计算机视觉项目和，比如说，任何其他的 ML 项目，NLP，或者所有其他的项目有什么不同？你想分享的差异是什么？
计算机视觉，自然语言处理，还有一些表格数据库项目。他们会不同，他们会有自己的困难。1.从表格开始，当我们谈论相当经典的机器学习时，任务的一部分也是构建特征。这里棘手的部分通常是，很少有这样的情况，你有一个存储数据的地方，而且它已经处于良好的状态。
我的意思是，通常情况下，尤其是当你面对的不是那么成熟的技术客户，他们刚刚接触人工智能，他们希望看到人工智能有所帮助。他们可能还不够成熟，甚至没有一个数据湖或一个数据源。困难在于能够访问多个数据源，将它们组合在一起，了解所有这些可能有用的数据在哪里，以及如何组合它们。通常很难评估这需要多少时间，这是困难之一。你也无法评估数据中有多少信息。除非这是一个非常简单的问题，当你可以只使用一个表，一切都在那里，那么这是那些项目的棘手部分。
2.有了 NLP ，问题通常是数据。我的意思是，与计算机视觉相比，你经常会有一些开源数据集，至少与你所做的相似。我的意思是，你可能想对轮胎进行缺陷检测，可能没有这个特定的数据集，但可能会在 C-sheet 或一些碳纤维 sheet 上进行一些缺陷检测。一些最终会非常相似的东西。你可以重用大量现有的神经网络，或者在一些现有的数据上进行描绘。因此，对数据的需求要小得多，你不需要有太多的数据就能为客户提供有用的东西。
在 NLP 中，大多数时候也会用到迁移学习。然后使用一些通用模型来满足客户的特定需求。我的意思是你不会在开源中找到如此有用的非常相似的 NLP 数据集；这是一件事。
另一件事是，如果你想产生这些数据集，这不是那么容易自动生成。对于 OCR 问题，有大量人工生成的图像用于 OCR 训练目的。有了 NLP，那就不那么容易了。你可以使用一些现有的生成模型，比如 GPT，等等。最后，你要做的是训练模型不处理真实的数据，启发式数据，而是逆向工程 GPT，或者你能得到的东西，最后，不会在客户端上，在真实生活的数据上很好地工作。数据通常是另一个的问题。
在计算机视觉中管理计算成本
Stephen: 让我们稍微深入一下数据方面。我很想知道，你有没有遇到过这样的情况，因为对于计算机视觉项目，我认为其中一件事就是它可能会变得计算密集型。也许你正在处理更高分辨率的数据集，然后你必须使用分布式架构，软处理整个事情，或者也许你正在训练的模型也是如此。
您是否遇到过这样的情况:您正在管理这个项目，而计算成本超出了预算？这不是你的预算。你是否遇到过这种情况，并和你的团队一起走过了这条路？
迈克尔:我要说的是，这是你在项目早期就可以评估的事情。现在，当与客户讨论时，需要计算能力来处理现有的规模。我们通常会说，如果这是一个相对较小的项目，比如要处理数万张图像，我们有自己的服务器场，因此我们可以使用它，或者我们可以在云中完成它，但只需几个虚拟机来完成这项工作。
如果你看到将有一个非常繁重的计算项目的需求，通常，我们已经在交易中，因为我保证它。通常，我们更喜欢在客户端、在客户端的云中或在他们的帐户上完成。我们不必重新开发票或处理它。它已经在客户端了。这就是我们通常试图解决的方法。
我只记得我们有一些计算预算的项目，特别是如果你在云中工作，这不是特别可能的计算机视觉案例。比方说，如果你和一个未来的工程师一起工作，使用一些大查询或基础设施，如果设计得不好，成本会很高。在某些情况下，我们的成本相当高。
在计算机视觉中，它更加可控，因为我们没有这些不同计算量大的复杂交互操作。一旦你知道你使用的模型和数据量，你就已经能够很好地评估成本了。
管理计算机视觉项目的经验教训
斯蒂芬:我们将进入最后的收尾阶段。这是上课的时间，你学到的课程，等等。随着时间的推移，您是否从项目中学到了一些经验教训，您认为非常小的、可见规模的团队可以通过他们的计算机视觉项目采纳并整合这些经验教训，从而管理端到端的 it 流程？
如果我回顾我早期是如何着手这些项目的，就会有这种渴望。然后，这需要有解决方案或结果快，黑一些解决方案，使用网络，你最喜欢的东西或花式摆在第一位，并试图带来一些结果很快。这是我们现在肯定会避免的事情，或者让许多项目去做。
你会遇到的问题是，如果你这样做，也许在第一周之后，你会有一些非常好的结果。然后你有一个解决方案，但不是，无论如何你必须重建，你不能在它的基础上。你只需要把它扔进垃圾桶，然后认真开始。
另一件事是当与客户一起工作时，第一周之后你会有一些非常好的结果。然后是项目停滞不前的感觉，因为一开始很容易得到一些最初的好结果，然后一旦你进入细节，当你试图改善它们时，事情就变得棘手了。然后通常会有这种停滞不前的感觉。
肯定的，我宁愿首先构建最可能的基本解决方案，端到端，然后迭代改进。此外，在一个场景中观察这种互动的改进过程并不容易，也不简单。
这是数据科学家更好地理解问题并构建一些稳定的解决方案所必需的思考过程。此外，对于客户来说，你知道这不是一件容易的事情。
这是个过程。这不仅仅是你将这个人工智能的休息，把它放在那里，它会神奇地工作。没有魔法。只是辛苦的工作，时间，和工程。
如何为计算机视觉项目组建团队
Stephen: 以人员管理结束会很好，这是最后一点。你有没有一种特殊的方式来组织从事这些项目的特定团队？例如，你可能有一个基于研究的计算机视觉工程师，他正在做模型开发的工作。你需要有一个单独的发言权吗，负责部署的高级工程师，或者你通常如何组织一个计算机视觉项目的团队？
同样，这取决于最终要交付什么。如果这只是一个概念验证，那么一个数据科学家可能就足够了。
虽然，值得牢记的是，要有团队球员。但它的目标也是交付某些已部署的解决方案，使其产品化。我们经常或通常做的，也是我非常喜欢的，是尽快建立一个跨学科的团队。
我的意思是，当数据科学家与软件工程师或 MLOps 工程师携手合作时，他们将接管或完成解决方案。通常情况下，并不是说你有某个时间点，MLOps 部分的工作完成了，然后就可以产品化了。
通常，当改进已经很小的时候，这是一件很顺利的事情。它可能已经被部署了，但是还有一个工作进行阶段。然后，当这些人携手工作时，他们了解到这些项目两端的挑战和需求是什么。这是非常有益的。
人们喜欢它，因为他们也面临一些他们不太习惯的挑战或问题。这是我们喜欢做的事情。
Sabine: 如果我们能在结束前挤出一个简短的观众问题。Gabriel 想知道关于计算机视觉数据管理的任何想法。它似乎比常规的表格数据更复杂。对此有什么结论吗？
正如我在某个时候向我解释的那样，我不会说它有多复杂。这只是一种不同的方式，不同的方法，可能更容易，作为人，我们可以评估模型是如何工作的。我要说的是，调试要容易得多，发现问题所在以及如何解决问题要容易得多。我会说他们甚至更容易。很明显，不同的技术在使用什么，大部分时间，深度学习，所以不同的技能。否则，至少对我来说，更容易管理那些。
迈克尔:我没明白这个问题。那是数据管理。抱歉，不是项目管理。现在，我看到了。
可能，更重要的是，棘手的是大小，所以它只是在那里更重。如果您可以首先进行重复数据消除或采样，那么这绝对是值得做的事情。老实说，我们的问题通常是数据集太小，而不是太大。
但是，在有大量数据的情况下，通常不需要处理所有的数据。这更多的是关于挑选，为了一些主动的学习，或者为了知道数据来自哪里，以及知道元数据聚焦于最相关的数据。
其他问题
Sabine: 我们一会儿可能会跳回一个更技术性的问题。观众有一个关于基线建模方法的问题。你对不同的分类检测和分割模式有什么看法？
这些是计算机视觉项目中最常见的领域，也是需要回答的最常见的问题。关于计算机视觉项目的整个方法，我不会说这三者之间有什么大的区别。我的意思是，最后，所有那些与 ML 无关的事情都非常相似:
与客户方交谈，
和团队一起工作，
-
确信他们作为一个团队合作得很好，
-
然后是可交付部分，等等
-
这三者之间的区别可能是什么
需要一些预处理，
2 使用的型号，
- 3 还要验证程序。
- 这些是数据科学家必须处理的主要差异。
- 不同之处还在于，它们在数据属性的多少及其含义方面有所不同。如果你有图像，然后任务是做分类，那么在给定的图像中没有太多的信息。你可以说每张图片有一条信息，而在另一端的分割中，每个像素都给你一些信息，因为你已经将所有像素分配到特定的类别。因此，这是一种更加密集的表示，信息更加密集。因此，通常情况下，您需要更少的数据来解决问题。
非常有趣的是，即使有时客户说他们有这个检测问题要解决或分割问题要解决，但这并不是必须的。
也许，我会讲一个我们处理一些五官问题的例子。我们必须评估一些面部特征，比如皮肤有多凹凸不平。你可以试着用不同的方式解决它。
What’s quite interesting is that even though sometimes the client says they have this detection problem to be solved or segmentation problem to be solved, it doesn’t have to be.
你可以展示大量的面部图像，在这些图像中你会看到不同的面部特征，比如凹凸不平的皮肤，甚至是皮肤，等等。
当你只在你有更多，比如说，不均匀的东西，比如皱纹，或者一些不同的东西的区域标记分割蒙版时，你也可以有一个小得多的数据集…我不是这方面的专家。不一样，不凹凸不平的皮肤。
- 然后，最终，你解决了几乎相同的问题。最终，您将获得相同的评估工具。你可以用不同的方法处理它，因此，你对数据和标签过程的要求将会完全不同。这三种不同类型的产品之间可能存在某种转换。
- Sabine:Julian 在聊天中问了我们一个问题。他说，“你好，我很好奇。 Auto ML models 在计算机视觉顾问身份中扮演了什么角色？你觉得它们有用吗？他们普遍表现好吗？”
老实说，我们并不经常使用 Auto ML。实际上，在计算机视觉中，几乎从来没有，因为主要原因是你需要为此建立基础设施，以自动化的方式尝试不同模型的基础设施，这是一件非常昂贵的事情。自动 ML 任务，如果你想尝试，特别是在计算机视觉领域数百种不同的配置，那么它只是贵得惊人。
我们确实在咨询领域使用了一些自动 ML，但通常，当您必须处理表格数据时，这将是经典 ML，以这种自动方式尝试数百种不同的配置模型是非常便宜的。
在计算机视觉领域，我要说的是，像大牌一样，他们有所有的资源和资金来做这件事。作为一家温和的咨询公司，我们没有这笔钱可以烧。就像我说的，从一开始就更像是一个受过教育的方向。比如很好地理解手头的问题，比如首先理解哪些架构是最好的尝试，然后显然在架构中尝试不同的方法。这是一个比自动毫升小得多的规模。
萨宾:哦，是的。在我们的圈子里，这绝对是一个反复出现的话题。比如了解你和你的团队做这些事情的合适规模。
Sabine: 好了，我们还有更多来自 LinkedIn Live 的社区问题。Manish 想知道有什么推荐的库或者模块可以在 web app 上提取身体地标。有什么想法吗？
Michal: 正如我提到的，我对技术方面不是很了解。一般来说，我们通常会做的或者团队中的人会做的是，当要解决这样或那样的问题时，他们会先做研究。那么最好的尝试之一就是从有代码的文件开始。
然后，通常会有一个完整的子页面来检查一个常规问题，并且会有不同的基准和不同的模型来尝试。我可能不能给你更多了。
萨宾:好吧，我还是会向你抛出另一个技术性或者非常实际的问题。Manish 还想知道你是否有办法将模型或模块分解成块，以便它们可以快速加载到浏览器中。他说，“我们把大的 JavaScript 文件分解成多个块，然后并行下载。”
Michal: 这不仅是针对技术问题，也非常接近网络应用程序，我过去更接近这一点。事实上，我在这里领导过的最具挑战性的项目之一是构建 web 应用程序的一部分，可能与我们在那里遇到的挑战有点不同，比如在 web 浏览器中嵌入 unity 来显示 3D、海量 3D 点云。这个问题我帮不上忙，很抱歉。
萨宾:无忧。一切都好，是的。当然，人们脑子里有迫切的实际问题，如果你把它们扔出去，你总能走运。
萨宾:我们该结束今天的工作了。时间过得很快。非常感谢你，迈克尔。很高兴您能和我们分享您丰富的经验和项目管理专业知识。甚至一些有趣的失败故事。虽然，这是一点欺骗，因为这是一个变相的成功，对不对？
实际上，我不知道在项目结束时，客户会回来。那时候，那是一段非常艰难的时光。
Sabine: It is time for us to wrap things up for today. The hour went by fast. Thank you so much, Michal. It was great to have you and have you share your broad experience and project management expertise with us. Even some of those juicy failure stories. Although, it was a little bit of cheating because it was a success in disguise, right?
Michal: I didn’t know that at the end of the project, the clients will come back, actually. Back then, it was quite a sweaty time.
强化学习中的马尔可夫决策过程:你需要知道的一切
花点时间找出你周围最近的大城市。如果你要去那里，你会怎么做？开车去，坐公交，坐火车？也许骑自行车，或者买张机票？
做出这个选择，你将概率融入你的决策过程。也许有 70%的几率会下雨或发生车祸，这会导致交通堵塞。如果你的自行车轮胎旧了，它可能会坏掉——这当然是一个很大的概率因素。
另一方面，也有确定性成本(T0)和确定性回报(T1)，比如汽油或飞机票的成本，比如坐飞机的旅行时间。
这类问题——其中代理人必须平衡概率性和确定性的回报和成本——在决策中很常见。马尔可夫决策过程用于建模这些类型的优化问题，也可以应用于强化学习中更复杂的任务。
在机器学习中定义马尔可夫决策过程
为了说明马尔可夫决策过程，考虑一个骰子游戏:
- 每一轮，你可以选择继续或者退出。
- 如果你退出，你将获得 5 美元，游戏结束。
- 如果你继续，你将获得 3 美元并掷出一个 6 面骰子。如果骰子是 1 或 2，游戏结束。否则，游戏将进入下一轮。
这里有一个明显的权衡。首先，我们可以用 2 美元的确定性收益来换取掷骰子并进入下一轮的机会。
要创建一个 MDP 来模拟这个游戏，首先我们需要定义一些东西:
- 状态是代理(决策者)可以拥有的状态。在骰子游戏中，代理既可以是游戏中的，也可以是游戏外的。**
- 一个动作是代理可以选择的运动。它使代理在不同状态之间移动，并带有一定的惩罚或奖励。
- 转移概率描述了在给定动作 a 的情况下，结束于状态 s’(s 质数)的概率。这些将通常被表示为函数 P ( s ， a ，s’)，其输出在给定当前状态 s 和动作 a 的情况下结束于s’的概率。
比如p(s=玩游戏，a=选择继续玩，s’=不玩游戏)就是⅓，既然掷骰子有六分之二(三分之一)的几率输。** - 奖励根据行动给予。继续游戏的奖励是 3 美元，而退出游戏的奖励是 5 美元。“整体”奖励将得到优化。
**我们可以将一个马尔可夫决策过程形式化地描述为 m = ( S ， A， P ， R ，gamma)，其中:
- S 代表所有状态的集合。
- A 代表一组可能的动作。
- P 代表转移概率。
- R 代表奖励。
- Gamma 被称为折扣因子(稍后将详细介绍)。
MDP m 的目标是找到一个能产生最佳长期回报的策略，通常记为 pi。政策仅仅是每个状态的到行为分布的的映射。对于每个状态 s ，代理应该以一定的概率采取行动 a 。或者，策略也可以是确定性的(即代理将在状态 s 中采取动作 a )。
我们的马尔可夫决策过程如下图所示。一个代理通过做决定和遵循概率来遍历图的两个状态。
提到马尔可夫属性很重要，它不仅适用于马尔可夫决策过程，也适用于任何与马尔可夫相关的东西(比如马尔可夫链)。
它指出下一个状态可以仅由当前状态决定——不需要“记忆”。这适用于代理如何遍历马尔可夫决策过程，但请注意，优化方法使用先前的学习来微调策略。这并不违反马尔可夫性质，它只适用于 MDP 的遍历。
贝尔曼方程与动态规划
贝尔曼方程是马尔可夫决策过程的核心。它概述了一个框架，通过回答这个问题来确定在状态 s 下的最优期望报酬:“如果一个代理人现在和将来做出最优决策，他们能得到的最大报酬是多少？”
尽管贝尔曼方程的各种版本可能会变得相当复杂，但从根本上讲，它们中的大多数都可以归结为以下形式:
用公式化的术语来说，这是一个相对常识性的想法。请注意 gamma(介于 0 和 1 之间，含 0 和 1)在确定最佳奖励时所起的作用。如果 gamma 设置为 0，则 V(s ')项完全被抵消，模型只关心眼前的回报。
另一方面，如果 gamma 设置为 1，则该模型对潜在未来回报的权重与对即时回报的权重相同。gamma 的最佳值通常在 0 到 1 之间，这样，奖励值越远，效果越差。
让我们用贝尔曼方程来确定在骰子游戏中我们能得到多少钱。我们可以在两个选择中进行选择，所以我们的扩展方程看起来像 max(选择 1 的回报，选择 2 的回报)。
选择 1——放弃——会产生 5 英镑的奖励。
另一方面，选择 2 产生的回报为 3，加上三分之二的机会继续进入下一阶段，在这个阶段可以再次做出决定(我们是按预期回报计算的)。我们在表示计算 s’(下一个状态)的项前添加一个折扣因子γ。
这个等式是递归的，但是不可避免地，它将收敛到一个值，假设下一次迭代的值以⅔递减，即使最大伽马为 1。
在某种程度上，继续留在游戏中是无利可图的。让我们计算四次迭代，gamma 为 1，以保持简单，并计算总的长期最优回报。
在每一步，我们可以选择退出并获得额外的 5 美元期望值，或者留下来并获得额外的 3 美元期望值。每一轮新的，期望值乘以三分之二，因为有三分之二的概率继续，即使代理人选择留下。
在这里，计算十进制值，我们发现(根据我们当前的迭代次数),如果我们遵循最佳选择，我们可以期望得到 7.8 美元。
在这里，我们手动计算了最佳利润，这意味着我们的计算出现了错误:我们仅在四轮后就终止了计算。
如果我们继续计算几十行的期望值，我们会发现最佳值实际上更高。为了用程序有效地计算这个，你需要使用一个专门的数据结构。
另外，为了提高效率，我们不想单独计算每个期望值，而是与之前的值相关联。解决方案:动态编程。
贝尔曼方程的理查德·贝尔曼创造了术语动态规划，它被用来计算可以被分解成子问题的问题。例如，选择 Stay > Stay > Stay > Quit 的期望值可以通过计算 Stay > Stay > Stay first 的值得到。
这些预计算将存储在一个二维数组中，其中行表示状态[In]或[Out]，列表示迭代。我们可以编写规则，将表格中的每个单元格与之前预先计算的单元格相关联(此图不包括 gamma)。
然后，在计算足够的迭代后，解就是数组中的最大值。通过动态编程，计算期望值——马尔可夫决策过程和 Q 学习等方法的关键组成部分——变得高效。
q 学习:马尔可夫决策过程+强化学习
让我们考虑一个不同的简单游戏，其中代理人(圆圈)必须在一个网格中导航，以便在给定的迭代次数下获得最大的回报。
有七种类型的块:
- -2 惩罚，
- -5 惩罚，
- -1 惩罚，
- +1 奖励，
- +10 奖励，
- 以相等的概率将代理移动到空间 A1 或 B3 的块，
- 空街区。
请注意，这是一个网格形式的MDP——有 9 个状态，每个状态都连接到它周围的状态。如果代理人的惩罚为-5 或更少，或者代理人的奖励为 5 或更多，游戏终止。
在 Q-learning 中，我们不知道概率——它在模型中没有明确定义。相反，模型必须通过与环境的交互来自己学习这一点和景观。
这使得 Q-learning 适用于显式概率和值未知的情况。如果它们是已知的，那么你可能不需要使用 Q-learning。
在我们的游戏中，我们知道概率、奖励和惩罚，因为我们严格定义它们。但是，比方说，如果我们训练一个机器人在复杂的环境中导航，我们就不能硬编码物理规则；使用 Q-learning 或另一种强化学习方法将是合适的。
每走一步，模型都会在 Q 表中更新它的学习。下表存储了可能的状态-动作对，反映了关于系统的当前已知信息，这些信息将用于驱动未来的决策。
每个单元格都包含 Q 值，它表示在采取当前操作的情况下系统的期望值。(这听起来耳熟吗？应该是——这又是贝尔曼方程！)
表中的所有值都从 0 开始，并迭代更新。请注意，A3 没有状态，因为代理无法从该点控制他们的移动。
为了更新 Q 表，代理首先选择一个动作。它不能上下移动，但是如果它向右移动，它将受到-5 的惩罚，游戏终止。Q 表可以相应地更新。
当代理第二次遍历环境时，它会考虑它的选项。给定当前 Q 表，它可以向右或向下移动。与向下移动相比，向右移动的损失为-5，当前设置为 0。
为了便于模拟，让我们想象代理人沿着下面指示的路径行进，并在 C1 结束，以 10 英镑的奖励终止游戏。然后，我们可以填写代理人在这一过程中采取的每一项行动所获得的奖励。
显然，这个 Q 表是不完整的。即使代理从 A1 向下移动到 A2，也不能保证它将获得 10 的奖励。经过足够的迭代之后，代理应该已经遍历了环境，Q 表中的值告诉我们在每个位置应该做出的最佳和最差决策。
这个例子简化了 Q 值实际上是如何更新的，这涉及到上面讨论的贝尔曼方程。例如，根据 gamma 的值，我们可以基于更近且更准确的 Q 表来决定由代理收集的最近信息可能比旧信息更重要，因此我们可以在构建 Q 表时忽略旧信息的重要性。
这里需要注意的是勘探与开发的权衡。如果代理人沿着正确的路径朝着目标前进，但是由于某种原因，以不幸的惩罚结束，它将在 Q 表中记录负值，并将它采取的每一步都与这个惩罚相关联。
如果代理人纯粹是“剥削的”——它总是寻求最大化直接的即时收益——它可能永远也不敢在这条道路上迈出一步。
另一方面，如果一个代理人遵循小报酬的路径，纯粹的剥削代理人每次都会简单地遵循该路径，而忽略任何其他路径，因为它导致大于 1 的报酬。
通过允许代理“探索”更多，它可以更少地关注选择最佳路径，而更多地关注收集信息。这通常以随机性的形式发生，这允许代理在他们的决策过程中具有某种随机性。
然而，一个纯粹的“探索性”代理也是无用和低效的——它将采取明显导致大量惩罚的路径，并可能占用宝贵的计算时间。
结合一些中间的随机性是一个好的做法，这样代理人就可以根据以前的发现进行推理，但仍然有机会处理探索较少的路径。
结合勘探-开采权衡的一种复杂形式是模拟退火，它来自冶金学，金属的受控加热和冷却。
模拟退火不是允许模型在选择探索性或开发性时有某种固定的常数，而是通过让代理大量探索开始，然后随着时间的推移当它获得更多信息时变得更加开发性。
这种方法已经在离散问题上显示出巨大的成功，如旅行推销员问题，所以它也适用于马尔可夫决策过程。
因为模拟退火是从高探索开始的，所以它通常能够衡量哪些解决方案是有希望的，哪些是不太有希望的。随着模型变得更具开发性，它将注意力转向有希望的解决方案，最终以计算高效的方式接近最有希望的解决方案。
摘要
让我们总结一下本文中所探讨的内容:
马尔可夫决策过程(MDP)用于对决策进行建模，这些决策可能具有概率性和确定性的奖励和惩罚。
市场发展计划有五个核心要素:
- 一组代理可能处于的状态，
- a，代理在特定状态下可以采取的一组可能的动作，
- r，在状态 S 做出动作 A 的奖励；
- p，在原始状态 S 采取行动 A 后转移到新状态 S '的概率；
- gamma，它控制马尔可夫决策过程代理的前瞻性。
包括 MDP 在内的所有马尔可夫过程都必须遵循马尔可夫性质，即下一个状态可以纯粹由当前状态决定。
贝尔曼方程决定了代理人在当前状态和所有后续状态下做出最优决策时可以获得的最大回报。它递归地将当前状态的值定义为当前状态奖励的最大可能值加上下一个状态的值。
动态编程利用网格结构来存储以前计算的值，并在此基础上计算新值。它可以用来有效地计算策略的值，不仅可以解决马尔可夫决策过程，还可以解决许多其他递归问题。
Q 学习是在环境中学习 Q 值，这通常类似于马尔可夫决策过程。它适用于特定概率、奖励和惩罚不完全已知的情况，因为代理反复遍历环境以自己学习最佳策略。
希望你喜欢和我一起探讨这些话题。感谢您的阅读！
Andre Ye
机器学习和数据科学爱好者。对深度学习充满热情，并喜欢跟上推动机器智能的边界的新论文。
阅读下一篇
如何构建、组织、跟踪和管理强化学习(RL)项目
7 分钟阅读|弗拉基米尔·利亚申科|发布于 2020 年 12 月 23 日
构建和管理机器学习项目可能是一件棘手的事情。
当您投入到一个项目中时，您可能会很快意识到您淹没在 Python 脚本、数据、算法、函数、更新等等的海洋中。在某些时候，你会忘记你的实验，甚至说不出哪个脚本或更新产生了最好的结果。
因此，组织你的项目并跟踪实验是成功的关键部分。
从这个角度来看，从事一个 ML 项目总体来说可能具有挑战性，但是有些领域比其他领域更复杂。强化学习 ( RL )就是其中比较复杂的一种。
本文致力于构建和管理 RL 项目。我会尽量精确，并提供一个全面的分步指南和一些有用的提示。
我们将涵盖:
- 一般提示—项目目录结构， Cookiecutter ，使用 Neptune 跟踪实验，适当评估
- 将问题定义为 RL 问题–强化学习、监督学习、优化问题、最大化和最小化
- 挑选 RL 环境–open ai 健身房
- 选择 RL 库和算法–RL _ 蔻驰、张量力、稳定基线、RL _ 蔻驰准则
- 测试代理的性能
- 准备发布–自述文件、需求、可读代码、可视化
让我们跳进来。
ML 协作:来自 4 ML 团队的最佳实践
原文：https://web.archive.org/web/https://neptune.ai/blog/ml-collaboration-best-practices-from-ml-teams
建立 ML 团队
随着有可能改变业务的人工智能用例的激增，领导者正在对人工智能协作进行重大投资，建立能够提供机器学习承诺的团队。建立成功的 ML 团队很大程度上取决于组织的规模及其战略眼光。
组织的规模和战略愿景
建立 ML 团队是一个重要的决定，主要取决于领导层如何认可 ML 技术，以及他们是否相信 ML 符合他们组织的战略愿景。
关于如何建立成功的 ML 团队，没有金科玉律。领导者经常面临许多障碍和问题，例如
- 1 团队规模应该是多少？
- 我的团队应该具备什么样的技能？
- 如何平衡专家和通才的组合？在团队建设阶段的早期拥有多面手有助于制定业务问题，并产生对项目后期所需的一系列技能的需求。
- 4 如何在横向和纵向计划之间组织团队？
专注于 ML 的运营
大多数公司将生产工作作为事后的想法，并且不准备在创建生产级系统时处理规模。因此，ML 团队必须拥有能够成功操作 ML 模型的强大的数据架构师和工程专家。
如何组织 ML 团队
集中式 ML 团队
来自不同领域的人，如工程、产品、开发和 ML 都聚集在一个大团队下。这样的团队成为组织计划采用的任何 ML 计划的任务组。从开始到实现的构思周期变得非常快。这是一个拥有广泛技能的专家的理想案例——从而形成技术专长广度和深度的双赢。
然而，这种团队组织的缺点是知识局限于这个论坛。由于知识传播存在障碍，这种模式导致依赖性增加并阻碍民主化。
Illustration of centralized ML team | Source
分散式 ML 团队
它是一个由技术专家组成的小型“团队”,来交付一个特定的特性或解决方案。这种结构非常灵活，来自不同背景的团队为了一个特定的可交付成果走到一起，然后解散。
Illustration of decentralized ML team | Source
ML 协作:为什么它很重要
我们将在这篇文章的后面部分解释每一个不同的角色，但是快速浏览一下团队的组成已经突出了不同团队成员如何相互协作的潜在问题。
理解需求
很多时候，ML 协作方面并没有得到太多的关注。这导致了需求沟通上的差距，需求既没有被很好地理解，也没有被恰当地记录。因此，项目可能会在重复任务方面面临挫折，或者在最坏的情况下，将已经耗费精力的工作擦掉。
追求正确的方向
不同利益相关者对 ML 协作的明确关注确保了项目朝着预期的方向发展，并且任何不可预见的风险都在正确的论坛上及时传达。
利益相关方的批准
ML 项目本质上是迭代的。数据科学家将业务问题和目标构建到统计解决方案中，并从数据探索的第一步开始。众所周知，EDA 是项目中发现的关键阶段。正是在这个阶段，数据科学家可能会发现数据中缺乏高质量的信号或模式，或者选择的衡量成功的指标发生了变化，或者问题本身可能无法解决。
这样的发现，当通过商业领袖传播时，通常会导致商业目标的修改。在这种情况下，清晰的沟通对于确保所有的涉众对更新的项目状态保持一致是至关重要的。
业务和数据团队联盟
ML 项目的成功在于数据团队和业务团队之间的强大协作。业务团队的这种持续联盟有助于数据科学团队创建有可能增加重要业务价值的 ML 模型。
可见性取代了微观管理
强大的团队协作使每个成员对最终解决方案的贡献变得清晰可见。它强调了在 ML 项目生命周期中各种任务所有权的重要性。
Degree of communication based on role | Source
我们联系了四家公司，采访了他们如何构建他们的 ML 团队，他们的团队相互合作的最佳实践是什么，他们使用什么工具，等等。
请注意，在可能的情况下，这些组织和联络点的名称在获得批准后已经公开。
ML 协作和系统设计的及时评估
感谢 Gigaforce 公司的数据科学家 Abhishek Rai 与我合作撰写这篇采访文章，并在文章发表前对其进行了审阅。
组织
Gigaforce 公司
工业
保险技术提供商
团队规模
Gigaforce 在三年前的 2020 年建立了一个 ML 团队，团队规模为 5-7 人。
团队组成
该团队由领域专家、数据工程师、数据科学家和 ML 工程师组成。
机器学习协作
Gigaforce 根据项目的阶段分配工作。显然，在项目的整个生命周期中，并不需要所有的团队成员。例如，领域专家在项目的初始阶段扮演着至关重要的角色，帮助数据科学家满足业务需求。
Gigaforce 的 ML 团队已经能够在五个月内建立并部署一个回归模型到产品中，这是一个伟大的壮举，充分说明了无可挑剔的项目管理和团队组织。因此，让我们向他们学习，他们是如何分配角色和责任的，以及他们采取了什么措施来促进合作。
Gigaforce 处理大量数据，需要构建多个模型版本，也就是实验。该团队很快发现了对数据版本工具的需求，这是当今行业在构建生产级解决方案时面临的主要挑战之一。他们已经评估了 DVC 的数据版本需求，并致力于优化他们的用例。
“根据我们处理的数据量，模型版本化带来的主要挑战是跟踪数据，以便在未来重现类似的实验。因此，数据版本化是该行业面临的主要挑战之一，我们正在努力提高效率，优化对数据变化的跟踪。”
我们都见证了大约 80%的概念验证没有进入生产流程。可能有许多促成因素，如缺乏远见、强行安装 ML 组件来解决业务问题、没有良好信号质量的数据来学习模式等。但是，在项目进入瓶颈阶段之前，能够避免损失的一个因素是预见模型集成到组织的现有技术堆栈中时出现的复杂性的能力。在这一点上，Gigaforce 做出了正确的决定，在 POC 规划阶段就让工程师参与进来，就解决方案的可行性分享他们的技术专长。
使用的工具
跟踪进度
- 每天(或根据需要每周)举行站立会议，以促进团队内部的协作。
- Gigaforce 快速开发周期的成功归功于与业务和产品团队紧密耦合的反馈回路。这对于确保开发人员不会成为任何 moonshot 承诺的受害者，以及所有利益相关者及时了解任何意外情况以校准项目方向是至关重要的。
工程团队中的 ML 协作
感谢 Acquia 前产品经理 Makarand Pandey 与我合作撰写这篇采访文章，并在文章发表前审阅。
组织
工业
软件即服务
团队规模
Acquia 在 2017 年 5 年前建立了一个 ML 团队，团队规模为 6 人。
团队组成
该团队由数据管道工程师、ML 工程师、全栈工程师和数据科学家组成。
团队协作
它的团队构成提供了一个很好的案例，其中他们强调构建健壮的数据和模型管道，例如预测集群的容量扩展、精炼代码库和重新训练模型。
角色和职责通常是根据 sprints 中的项目组合来分配的。勘探项目主要由数据科学家处理，而操作请求则由 ML 工程师处理"
该团队是高度自给自足的，因为它自己设法建立了多个概率模型，预测购买、参与和转化的可能性以及客户的终身价值。不用说，Acquia 认为没有必要为这样一个高绩效的团队雇佣一名工程经理。该团队开发了概率模型，并对其进行迭代，以随着时间的推移提高模型的准确性。
使用的工具
- Jenkins 用于 CI/CD 流程
- 用于代码协作的 Git
- 模型版本控制的 MLflow
跟踪进度
Acquia 通过 slack 的异步站立简化了沟通——这是自混合工作文化开始以来业内常见的趋势。他们使用吉拉进行 sprint 跟踪，AHA 进行产品管理可视化，confluence 进行项目文档。
ML 协作和发挥团队的优势
该公司选择保持匿名，但乐于分享其在 ML 团队协作方面的最佳实践。我们真诚地感谢他们在这篇采访文章上的合作，以及在文章发表前的审阅。
组织
在下一节中，用代词“他们”匿名和指代。
工业
计算机软件
团队规模
他们在 2021 年建立了一个相当新的 ML 团队，团队规模为 5 人。
团队组成
该团队由全栈科学家和专业技能型专家组成。
团队协作
该团队在五个月内建立了异常检测的基线版本，并计划很快创建一个针对特定治疗的“索赔评分系统”。
虽然通常很难决定如何将项目分配给团队，但他们有一个公平的主张，即发挥团队的优势。有各种方法来决定项目分配，但没有经验法则。这取决于多种因素，例如组织中已经存在哪些技能，这些技能是否随时可以用于入职，以及如果分配的团队事先不具备这些技能，他们是否愿意学习和交付项目，等等。
该团队没有一个解决方案架构师来协调团队内部的工作，并帮助他们完成关键里程碑。这无疑强调了需要一个能够身兼数职的项目经理来使项目成功。
“不幸的是，我们的团队中没有一个业务架构师/产品负责人/分析师，所以在文档和保持进度更新方面存在巨大的困难”
使用的工具
跟踪进度
他们使用合流、观念、松弛和每日站立与团队分享知识和状态更新。
看板团队中的 ML 协作
感谢 Blue Yonder Inc .数据科学部门 CVP Felix Wick 与我合作撰写这篇采访文章，并在文章发表前对其进行审阅。
组织
工业
供应链 SaaS
团队规模
Blue Yonder 公司的 ML 团队规模为 30 人，并且还在增加。
团队组成
在几年的过程中，Blue Yonder 建立了一个工程团队，以开发以 ML 为核心的 SaaS 产品。Blue Yonder 的团队组织脱颖而出，因为它确保所有团队成员对整个系统有一个体面的概述，此外还有一些多面手。它拥有一个专注于特定领域的团队，如数据工程师、软件工程师、数据科学家、ML 工程师、全栈和前端开发人员。
团队协作
管理一个大型团队肯定是困难的，因此 Blue Yonder 找到了一种有效的方法，将团队分成几个子团队，这些子团队具有不同的技术重点，如数据、模型或以 UI 为中心。
虽然不同子团队的成员在端到端用户故事和史诗上与其他子团队合作，但他们在技术子团队内部有跨故事的密切交流。这种团队组织也带来了协同作用，并提供了一种有效的方式来确保所有团队成员都了解整个工作范围。
使用的工具
Blue Yonder 在开发模式下工作，通过一个连续的过程来扩大规模、改进和范围的扩展，同时操作产品。它使用现代协作平台，以这样的规模运营，以迎合全球客户。
“我们对所有子组件使用一个 mono 存储库，包含一个拉式请求工作流和 CI/CD(包含单元、集成、系统、模型和性能测试)。具有模型变更的提交分支自动触发对几个数据集的评估运行，输出与主模型的比较，根据该比较可以决定该模型是否是好的候选。”
跟踪进度
它遵循类似看板的结构，结合连续交付模式，包括
- 史诗的路线图，包括发行计划
- 每日站立，广泛的内部和外部审查版本
- 常规团队和子团队回顾
奖金金块
到目前为止，我们所讨论的一切都是从位于一个地方的中型团队的角度出发的。值得注意的是，随着任何公司员工人数的增加，可能需要一些适应性。大型组织在地理上分散了数据科学团队，这些团队通常不知道他们的同事在做什么。因此，维护一个包含所有数据科学家的中央数据库被认为是一种良好的做法，该数据库可以列出:
- 他们的专业领域，
- 他们过去做过什么项目，
- 他们历史项目的成功率是多少，
- 他们目前在做什么项目，以及
- 接下来他们渴望学习和交付什么技能和算法。
与其专注于特定的工具，不如从共享 excel 这样简单的东西开始，这是一个尽早开始并从回购中获益的好方法。目标是在组织范围内对内部已经存在的技能库进行可视化。此外，当项目管理团队希望为任何即将到来的项目分配数据科学家时，这样的存储库会很方便，使业务和数据科学家双赢。
外卖食品
与这些伟大组织的讨论让我们先睹为快，看看如何构建健壮的、可伸缩的、实时的 ML 生产系统。通过这篇采访文章，我们的目的是把他们的学习和经历带给我们的读者。我们想总结并分享三个关键要点，它们可能会对您的生产之旅有所帮助:
-
机器学习团队非常多样化，不同背景的专家集思广益，寻求成功之道。组织需要创造一种促进有效的 ML 合作的文化来提高团队的效率。
-
不要根据职位来判断，每个公司都不一样。相反，要非常清楚实现目标所需的技能和任务。不要低估任何一个团队成员的贡献。“ML 项目意味着数据科学家”是一个神话——它需要技术专家的大量脑力来建立世界级的系统。
-
但是有一件关于 ML 项目的事情不是神话——它们都是关于数据的。因此，准备好接受这样一个事实，您将拥有大量的数据版本，这将导致多模型管理。有很多产品可以帮助你管理这种混乱——我们强烈建议你做好研究，并及时投资。
参考
ML 工程师 vs 数据科学家
原文：https://web.archive.org/web/https://neptune.ai/blog/ml-engineer-vs-data-scientist
2010 年，DJ Patil 和 Thomas Davenport 宣称数据科学家是“21 世纪最性感的工作”。过去十年，数据科学和机器学习取得了巨大的进步。数据科学已经成功地为全球企业和组织提供了预测智能和数据驱动的决策，以至于数据科学不再被视为一个边缘话题。数据科学现在是一个主流职业，从大型科技公司到更传统的企业，各种组织都非常需要数据科学专业人员。
十年前，数据科学的重点更多地是算法开发和建模，以从数据中提取强大的洞察力。然而，随着数据科学在过去十年的发展，越来越清楚的是，数据科学不仅仅涉及建模。从原始数据到部署，机器学习生命周期现在依赖于专业专家，包括数据工程师、数据科学家、机器学习工程师以及产品和业务经理。
但是数据科学家的角色何时结束，机器学习工程师何时开始？
机器学习工程师的角色在各公司中越来越突出，因为他们意识到，只有在模型成功部署到生产中后，数据科学的价值才能实现。虽然许多工具和技术，如云 API、AutoML 和许多基于 Python 的库，使数据科学家的工作变得更容易，但将模型投入生产并监控其性能的 MLOps 仍然非常不结构化。
要详细了解从数据科学家到数据科学经理的各种档案的相应技能、职责和技术堆栈，请参考我以前关于如何在行业中建立有效的机器学习团队的文章[ 2 ]。
执行数据科学项目有四个核心步骤:
- 问题表述—将业务问题转化为数据科学问题
- 数据工程–准备数据和管道，以处理用于建模的原始数据
- 建模–设计并试验用例的算法和模型
- 部署–在测试和监控其性能后生产该模型。
Lifecycle of a data science project | Source
在大型科技公司和初创公司中，开展数据科学有一个更成熟的流程，工作也有明确的界限。因此，通常期望不同子领域的专业人员专注于他们各自的专业领域，并在需要时相互合作。然而，在没有庞大数据科学团队的小型组织中，最初的几名数据科学雇员预计将作为“全栈”数据科学家跨这些不同的职能部门工作。
因此，数据科学家与机器学习工程师的定义和范围是非常相关的，取决于数据科学团队的成熟程度。在本文的剩余部分，我将详细阐述数据科学家和机器学习工程师在大型既定数据科学团队中的角色。
在这篇文章中，我将:
- 回顾并比较机器学习行业中数据科学家和机器学习工程师不断演变的角色和职责；
- 讨论每个角色的范围、相似点和不同点，以及如何确保这两个核心配置文件之间强有力的沟通和协作，否则数据科学项目肯定会失败。
数据科学家和机器学习工程师的区别
在这一部分，我将讨论技能、职责、日常任务、技术堆栈等方面的主要差异。
数据科学家的主要职责是使用机器学习或深度学习模型为各种商业问题开发解决方案。并不总是需要创建新的算法或模型，因为这些任务是研究密集型的，会占用大量时间。在大多数情况下，使用现有算法或预先训练的模型，并在问题陈述的上下文中优化它们就足够了。然而，在更具创新性和研发为重点的团队或公司中，科学家可能被要求进行新颖的研究和制造模型。
相反，机器学习工程师的主要目标是把数据科学家准备好的模型拿到生产中去。这涉及多个方面，包括模型优化以使其与定制部署限制兼容，以及构建用于实验、A/B 测试、模型管理、集装箱化、部署的 MLOps 基础设施，并在部署后监控模型性能。
这些因素转化为各个角色在技能、职责和技术组合方面的潜在差异，如下表所示。
数据科学家
机器学习工程师
Machine Learning Engineer:
编程；编排
Machine Learning Engineer:
数据结构
Machine Learning Engineer:
数据建模
Machine Learning Engineer:
软件工程
机器学习:监督与非监督
Machine Learning Engineer:
机器学习框架
Machine Learning Engineer:
统计数字
Machine Learning Engineer:
ML 的概念知识
书面和口头沟通技巧
机器学习工程师:
机器学习工程师:
表 1。数据科学家与机器学习工程师的技能
数据科学家
机器学习工程师
识别和验证可以用 ML 解决的业务问题
Machine Learning Engineer:
将 ML 和 DL 模型部署到生产中
分析和可视化 ML 生命周期不同阶段的数据
Machine Learning Engineer:
优化模型以获得更好的性能、延迟、内存和吞吐量
开发定制算法和模型
Machine Learning Engineer:
在各种硬件上进行推理测试，包括 CPU、GPU 和边缘设备
识别附加数据集并生成合成数据
Machine Learning Engineer:
监控模型性能、维护、调试
开发数据注释策略
Machine Learning Engineer:
模型、实验和元数据的版本控制
与跨职能利益相关方协调
Machine Learning Engineer:
开发定制工具来优化整个部署工作流
开发定制工具以优化整个建模工作流程
机器学习工程师:
表二。数据科学家与机器学习工程师的职责
数据科学家
机器学习工程师
Machine Learning Engineer:
Python / C++ / Scala
Jupyter，SageMaker，Google Colab 笔记本
Machine Learning Engineer:
Linux，Bash
Machine Learning Engineer:
去吧，Github/ Bitbucket
Machine Learning Engineer:
云:AWS/ Azure/ GCP
ML: Scikit-learn，Rapids，Fast.ai
Machine Learning Engineer:
DL: PyTorch，TensorFlow，JAX，MXNet
Machine Learning Engineer:
码头工人，库比涅斯
可视化:Matplotlib，Seaborn，Bokeh
Machine Learning Engineer:
上菜:TFServing，TensorRT，TorchServe，ONNX
元数据存储:Neptune.ai，Comet.ml，Weights & Biases
Machine Learning Engineer:
元数据存储:Neptune.ai，Comet.ml，Weights & Biases
表 3。数据科学家与机器学习工程师的技术堆栈
相似性、干扰和移交
数据科学家和 ML 工程师的相似之处
如表 1-3 所示，数据科学家和机器学习工程师的技能和职责有部分重叠。技术栈也非常相似，虽然数据科学家预计主要用 Python 编码，但机器学习工程师也需要知道 C++，以便将模型工件移植到更高效、更快速的格式中。
与数据科学家相比，机器学习工程师在主题专业知识方面可能缺乏什么，他们在数据科学家不太熟悉的工程工具和框架(如 Kubernetes)方面的知识方面弥补了这一点。
数据科学家通常拥有 STEM 背景，甚至是生物学、经济学、物理学、数学等不同领域的博士学位。另一方面，机器学习工程师一般都有软件工程师的职业经验。
虽然数据科学家主要处理算法和模型开发，但机器学习工程师的主要关注点是与模型部署和监控相关的可扩展软件工程，其余任务通常是两种配置文件共有的。
在少数情况下，这些任务可能会根据数据科学团队的规模和成熟度进行分担，事情可能会顺利进行。然而，通常情况下，尤其是在较大的团队和组织中，这可能会产生相当大的冲突和摩擦，尤其是当数据科学家和机器学习工程师在不同的团队工作并向不同的经理报告时。
移交过程
可以在数据科学家和机器学习工程师的各自任务之间划清界限。通常，数据科学家会开发一个或多个候选机器学习模型，并按照特定的合同将这些模型交给机器学习工程师。
合同应规定:
- 模型精度，
- 潜伏期，
- 记忆，
- 参数的数量，
- 所使用的机器学习或深度学习框架，
- 型号版本，
- 模型预测，
- 和用于验证或测试集的接地标签以及其他参数。
结构化的移交合同确保机器学习工程师拥有所有必要的信息来进行模型优化、任何进一步的实验和部署过程。移交后，数据科学家可以专注于下一个用于生产的机器学习用例。
数据科学家和机器学习工程师之间的合作在部署后继续进行，并且变得至关重要，特别是当模型在生产中中断时。随着数据科学家对模型的工作有了更深入的了解，他们可以更好地解决问题和修复模型。
与此同时，一些模型故障与机器学习工程师开发的底层基础设施中的裂缝有关，他们最有能力解决这些问题。基于模型通过主动学习接收的实时数据对模型进行持续改进也属于数据科学家的领域。
数据科学家和 ML 工程师之间的沟通和协作
数据科学团队的成功取决于不同领域的强大协作[ 2 ]。数据科学家和机器学习工程师在模型开发、部署以及部署后监控和优化过程中不断合作。理想情况下，这两个档案应该属于同一个团队，并向同一个领导汇报。在这样的背景下，合作变得更加容易，也促进了强有力的共事和相互学习。
然而，当数据科学家和机器学习工程师属于不同团队的一部分，并向不同的领导层报告时，协作并没有达到应有的强度。在这样的组织环境中，数据科学家和机器学习工程师不会直接互动，而是依赖团队生产力和项目管理工具，如 Slack、Teams、JIRA、Asana 等。
对于许多重复和常见的用例来说，使用这样的协作工具实际上是一种恩惠，为团队节省了大量的时间和精力。然而，依赖于以票据或任务为原子单位的工具的事务性本质并没有创造出团队结合和协作的感觉。在严重依赖此类工具的数据科学团队中，这是一种常见的抱怨。
比较选择方案
支持团队协作的 MLOps 工具是传统项目管理工具的一个很好的替代品:
对于更复杂的任务或项目，面对面或视频协作是必须的，领导层不应忽视这一点。通常在这些环境中，技术专业人员可能会从业务领导那里了解到新的用例或客户，而业务专业人员反过来可能会了解到可以解决未来业务用例的新技术突破。数据科学家和机器学习工程师也是如此，各方都可以学习新的算法、模型或新的框架，以使数据科学更加有效和高效。
当前行业趋势
如果《哈佛商业评论》文章的新版本在 2021 年发表，它会宣称“机器学习工程师”是本世纪 20 年代最性感的工作。虽然数据科学和模型开发仍然是行业和学术界的一个有利可图的角色，但近年来，行业的重点已经略微转向构建可扩展的可靠基础架构，以便为数百万客户提供数据科学模型。
截至今天，在整个科技行业，机器学习工程师的需求远远超过数据科学家。
- 行业领导者已经认识到，虽然大型、复杂的机器学习和深度学习模型在学术基准或训练数据上实现最先进的性能是很好的，但这些模型不会给企业带来任何商业价值，除非部署并以高准确度可靠、快速地服务于客户请求。
- 随着越来越多的企业成为数据驱动的公司，并建立数据科学和机器学习团队或组织[ 3 ]，他们必须衡量并实现所需的 ROI 水平。
- 早期涉足并投资人工智能的以客户为中心的大型科技公司已经建立了强大的科学家团队，现在正在寻求提高生产能力，并将数据和研究科学家开发的 R&D 产品商业化。
- 虽然顶尖的数据科学家，特别是那些拥有博士等高等学位的科学家，将永远是高需求的，但我们目前正在见证一个寻找熟练的机器学习工程师的就业市场，与数据科学家相比，他们的供应是有限的。
从数据科学家到机器学习工程师的转变
在 Coursera、Udacity、Udemy 等学习平台上有很多在线课程。但专注于机器学习工程实践的教师和内容相对匮乏。虽然在 Kaggle 这样的沙盒环境中可以建立数据科学模型，但这些模型并不是为了服务于现实世界的预测，只有在现实世界的行业环境中才能学习可扩展的模型部署、监控和相关的机器学习工程任务。由于机器学习工程和 MLOps 是一门应用性更强的学科，拥有构建和维护强健基础设施所需技能的专家越来越少。
与此同时，现有的数据科学家在更大的潜在影响、更好的薪酬和长期职业前景的诱惑下，也在寻求过渡到 MLE 角色。
如表 1、2 和 3 所示，这两个角色之间有相当多的重叠。然而，机器学习工程师专注于将模型投入生产的“工程”方面，而数据科学家专注于为特定的业务问题开发正确的模型集。要成为一名高效的机器学习工程师，数据科学家需要学习的最相关的技能是软件工程，包括编写优化代码的能力，最好是用 C++，严格的测试，以及理解、构建和操作现有或定制的工具和平台，以实现可靠的模型部署和管理。
数据科学家绝对有可能学习 C++和软件工程和软件测试的最佳实践，以及来自多个来源的板载新工具和技术，如Docker、Kubernetes 、ONNX 和模型服务平台。然而，由于公司要求机器学习工程师具有先前的相关经验，如果数据科学家没有在行业环境中的真实实践经验，那么他们证明机器学习配置文件是不可行的。
鉴于这个问题的先有鸡还是先有蛋的性质，现有数据科学家过渡到机器学习工程的最佳途径是与他们当前的雇主合作。如果数据科学家向他们的经理表达对机器学习工程的兴趣，并被允许在特定项目上跟随甚至协助机器学习工程师并与之合作，那么在同一公司内部进行内部过渡就变得更加容易。这对没有任何行业经验的应届毕业生来说是一个挑战，从数据科学或软件工程到机器学习工程的类似内部过渡路线是推荐的途径。
随着行业的成熟和公司发展他们的机器学习系统和相关流程，如招聘和技能提升，更多候选人将更容易从数据科学过渡到机器学习工程。
结论
人工智能是现代企业的基石。这一人工智能革命在过去十年中显著加速，导致对数据科学专业人员的巨大需求得不到满足。数据科学作为一门学科也在发展，创建了专注于数据、建模、工程以及产品和客户成功管理的独特档案。在这些配置文件中，机器学习工程师在将数据科学家基于数据工程师准备的数据开发的模型以及产品或业务经理确定和开发的用例转化为成果方面发挥着关键作用。
目前，对机器学习工程师的需求类似于十年前对数据科学家的需求。人工智能行业中概况的范围和性质的这种变化将继续发生，并为工程师、科学家以及商业专业人士提供新的挑战性机会，以获得他们的脚。
参考
[1]https://HBR . org/2012/10/data-科学家-21 世纪最性感的工作
[2]https://Neptune . ai/blog/how-to-build-machine-learning-teams-that-delivered
[3]https://Neptune . ai/blog/building-ai-ml-projects-for-business-best-practices
他是个混蛋
人工智能和神经科学领域的领导者，在 4 个国家(美国、英国、法国、印度)拥有跨大科技(亚马逊 Alexa AI 的对话式人工智能)、独角兽初创公司(Swiggy 的应用人工智能)和 R&D(牛津大学和伦敦大学学院的神经科学)的专业经验。发表了 40+篇关于神经科学和 AI 的论文(h-index: 23，2000+引文)；为消费技术产品构建和部署人工智能；为科技初创公司提供人工智能/人工智能方面的咨询，并为有志于数据科学的学生、专业人士和公司提供辅导和技能提升服务。
阅读下一篇
最佳 MLOps 工具以及如何评估它们
12 分钟阅读| Jakub Czakon |年 8 月 25 日更新
在我们的一篇文章中——机器学习团队实际使用的最好的工具、库、框架和方法——我们从 41 家 ML 初创公司学到的东西——Acerta 的 CTO Jean-Christophe Petkovich 解释了他们的 ML 团队如何接近 MLOps。
据他所说，一个完整的 MLOps 系统有几个要素:
- 您需要能够构建包含预处理数据和生成结果所需的所有信息的模型工件。
- 一旦您能够构建模型工件，您必须能够跟踪构建它们的代码，以及它们被训练和测试的数据。
- 您需要跟踪所有这三样东西，模型、它们的代码和它们的数据，是如何关联的。
- 一旦您可以跟踪所有这些内容，您还可以将它们标记为准备就绪，进行生产，并通过 CI/CD 流程运行它们。
- 最后，为了在该过程的最后实际部署它们，您需要某种方法来基于该模型工件旋转服务。
这是对如何在公司中成功实施 MLOps 的高度概括。但是理解高层需要什么只是拼图的一部分。另一个是采用或创建适当的工具来完成工作。
这就是为什么我们编制了一份最佳 MLOps 工具的清单。我们将它们分为六类，以便您可以为您的团队和业务选择合适的工具。让我们开始吧！
ML 实验跟踪:它是什么，为什么重要，以及如何实施
原文：https://web.archive.org/web/https://neptune.ai/blog/ml-experiment-tracking
我来分享一个听了太多次的故事。
“…到目前为止，我们一直都是以手动和临时的方式完成所有工作。
有些人在用它，有些人在用那个，到处都是。
我们没有标准化的东西。
但是我们运行许多项目，团队在成长，我们的规模也在快速扩大。
所以我们遇到了很多问题。模特是怎么训练出来的？什么数据？我们对不同的版本使用了什么参数？我们如何复制它们？
我们只是觉得有必要控制我们的实验……”
– unfortunate Data Scientist.
事实是，当你开发 ML 模型时，你将会进行大量的实验。
这些实验可能:
- 使用不同的模型和模型超参数
- 使用不同的培训或评估数据，
- 运行不同的代码(包括您想要快速测试的这个小变化)
- 在不同的环境中运行相同的代码(不知道安装的是 PyTorch 还是 Tensorflow 版本)
因此，它们可以产生完全不同的评估指标。
跟踪所有这些信息会很快变得非常困难。特别是如果你想组织和比较这些实验，并且确信你知道哪个设置产生了最好的结果。
这就是 ML 实验跟踪的用武之地。
什么是 ML 实验跟踪？
实验跟踪是保存您关心的每个实验的所有实验相关信息的过程。
实验跟踪是保存您关心的每个实验的所有实验相关信息的过程。这种“您关心的元数据”在很大程度上取决于您的项目，但它可能包括:
当然，您希望在实验完成后可以获得这些信息，但是理想情况下，您希望在实验运行时也能看到一些信息。
为什么？
因为对于一些实验来说，你可以(几乎)马上看到它们不可能给你带来更好的结果。与其让他们跑(这可能需要几天或几周)，你不如简单地阻止他们，尝试一些不同的东西。
为了正确地进行实验跟踪，你需要某种系统来处理所有这些元数据。典型地，这样的系统将具有 3 个组件:
- 实验数据库:存储实验元数据的地方，可以记录和查询
- 实验仪表板:实验数据库的可视化界面。一个你可以看到你的实验元数据的地方。
- 客户端库:为您提供从实验数据库中记录和查询数据的方法。
当然，您可以用许多不同的方式实现每个组件，但总体情况是非常相似的。
等等，那么实验追踪不就是 MLOps 之类的吗？
实验跟踪与 ML 模型管理与 MLOps
实验跟踪(也称为实验管理)是 MLOps 的一部分:一个更大的工具和方法生态系统，处理机器学习的可操作性。
MLOps 处理 ML 项目生命周期的每一部分,从开发模型到安排分布式培训工作、管理模型服务、监控生产中模型的质量，以及在需要时重新培训这些模型。
这是许多不同的问题和解决方案。
实验跟踪关注迭代模型开发阶段当您尝试许多事情来使您的模型性能达到您需要的水平时。
那么实验跟踪和 ML 模型管理有什么不同呢？
ML 模型管理在模型投入生产时开始:
- 简化从实验到生产的模型移动
- 帮助模型版本化
- 在 ML 模型注册中心组织模型工件
- 帮助在生产环境中测试各种模型版本
- 如果新版本似乎要崩溃了，可以回滚到旧版本
但是并不是每个模型都能被部署。
即使你的模型没有进入生产阶段，实验跟踪也是有用的。
即使你的模型没有投入生产，实验跟踪也是有用的。在许多项目中，尤其是那些以研究为中心的项目，他们可能永远也不会实现。但是拥有关于你进行的每个实验的所有元数据可以确保你在这个神奇的时刻到来时做好准备。
好吧，如果你有点像我，你可能会想:
酷，所以我知道什么是实验跟踪。…但我为什么要在乎呢？
让我解释一下。
为什么实验跟踪很重要？
为 ML 从业者构建一个工具有一个巨大的好处。你可以和很多人交谈。
在与数百名在 Neptune 跟踪他们实验的人交谈后，我看到了实验跟踪可以改善你工作流程的 4 种方式。
你所有的 ML 实验都集中在一个地方
有许多方法可以运行您的 ML 实验或模型训练作业:
- 私人笔记本电脑
- 工作中的电脑
- 云中的专用实例
- 大学集群
- Kaggle 内核或 Google Colab
- 还有很多。
有时候你只是想快速测试一些东西，在笔记本上运行一个实验。有时你想加速一个分布式的超参数调优任务。
无论哪种方式，在一个项目的过程中(尤其是当有更多的人在做这个项目的时候)，你可能最终会让你的实验结果分散在许多机器上。
有了实验跟踪系统，你所有的实验结果都被设计记录到一个实验库中。将所有的实验元数据保存在一个地方，无论在哪里运行，都可以让你的实验过程更容易管理。
具体来说，集中式实验存储库使以下工作变得容易:
- 搜索和过滤实验，快速找到您需要的信息
- 无需额外工作即可比较他们的指标和参数
- 深入查看您到底尝试了什么(代码、数据版本、架构)
- 需要时，重现或重新运行实验
- 访问实验元数据，即使您无权访问运行它们的服务器
此外，你可以安心地睡觉，因为你知道你尝试过的所有想法都被安全地储存起来了，而且你可以随时回头再去想它们。
比较实验，分析结果，调试模型训练，几乎没有额外的工作
无论您是在调试训练运行、寻找改进思路，还是审核您当前的最佳模型，比较实验都是非常重要的。
但是当你没有任何实验跟踪系统时:
- 你记录事情的方式可以改变，
- 你可能会忘记记录一些重要的事情
- 你可能只是不小心丢失了一些信息。
在这种情况下，像比较和分析实验这样简单的事情会变得困难甚至不可能。
有了实验跟踪系统，你的实验被存储在一个地方，你遵循相同的协议来记录它们，所以那些比较可以非常深入。你不需要做太多额外的工作。
“跟踪和比较不同的方法显著提高了我们的工作效率，使我们能够更加专注于实验，并在我们的团队中开发新的良好实践……”–to masz gry giel，数据科学家@idenTT
适当的实验跟踪便于:
- 比较参数和指标
- 覆盖学习曲线
- 根据数据版本或参数值对实验进行分组和比较
- 比较混淆矩阵、ROC 曲线或其他性能图表
- 比较测试或验证集的最佳/最差预测
- 查看代码差异(和/或笔记本差异)
- 查看各种型号在训练运行期间的硬件消耗
- 查看预测解释，如要素重要性、SHAP 或莱姆
- 比较视频或音频等富格式工件
- …比较您记录的任何其他内容
现代实验跟踪工具将(几乎)免费为你提供许多比较功能。一些工具甚至可以自动发现实验之间的差异，或者向您显示哪些参数对模型性能有最大的影响。
当你把所有的片段都放在一个地方时，你可能仅仅通过查看你记录的所有元数据就能找到新的见解和想法。当你不是一个人工作时，尤其如此。
说开了…
改善协作:查看每个人都在做什么，轻松共享实验结果，以编程方式访问实验数据
当你是一个团队的一部分，很多人都在做实验时，为整个团队提供一个真实的来源是非常重要的。
【一个实验追踪系统】让我和队友分享结果变得很容易。我给他们发了一个链接，告诉他们要看什么，或者我在实验仪表板上建立了一个视图。我不需要自己生成，我团队中的每个人都可以访问它。”–ma ciej Bartczak，研究主管@Banacha 街
实验跟踪让你不仅可以组织和比较你过去的实验，还可以看到其他人都在做什么以及结果如何。
分享结果也变得更加容易。
现代实验跟踪工具让你通过发送一个链接到一个特定的实验或仪表板视图来分享你的工作。你不必发截图或“开个小会”来解释你的实验是怎么回事。它节省了大量的时间和精力。
例如，这里有一个链接，链接到我几个月前做的一个实验对比。很简单，对吧？
除了分享你在网络用户界面上看到的东西，大多数实验跟踪设置让你以编程方式访问实验元数据。当你的实验和模型从实验走向生产时，这就派上了用场。
例如，您可以将您的实验跟踪工具连接到 CI/CD 框架并将 ML 实验集成到您团队的工作流程中。分支“master”和“develop”上的模型之间的视觉比较(以及探索细节的方式)在您更新您的生产模型之前增加了另一个健全性检查。
实时查看您的 ML 运行:随时随地管理实验
当你在本地计算机上训练一个模型时，你可以随时看到发生了什么。但是，如果你的模型是在工作场所、大学或云中的远程服务器上运行，那么就不容易看到学习曲线是怎样的，甚至培训工作是否崩溃。
实验跟踪系统解决了这个问题，因为虽然允许远程访问你的所有数据和服务器可能是一个很大的安全禁忌，但让人们只看到他们的实验元数据通常是好的。
当你可以看到你的跑步实验就在你之前跑步的旁边时，你可以快速比较它们，并决定继续下去是否有意义。你可以看到你的云训练作业崩溃了，你可以关闭它(或者修复 bug 重新运行)。
为什么要在不收敛的东西上浪费那些宝贵的 GPU 时间。
说到 GPU，一些实验跟踪工具也会跟踪硬件消耗。这可以帮助你看到你是否有效地使用你的资源。
例如，随着时间的推移，查看 GPU 消耗可以帮助您了解您的数据加载器是否正常工作，或者您的多 GPU 设置实际上只使用了一个卡(这种情况发生在我身上的次数比我愿意承认的次数还要多)。
“如果没有监控部分的信息，我不会知道我的实验运行速度比正常情况慢了 10 倍。–micha Kardas，机器学习研究员@TensorCell
*## 实验跟踪最佳实践
到目前为止，我们已经讨论了什么是实验跟踪以及为什么它很重要。
是时候进入细节了。
在任何 ML 实验中，你都应该记录什么
正如我最初所说的，您可能想要跟踪的信息类型取决于项目特征。
也就是说，不管你在做什么项目，有些事情你都应该跟踪。这些是:
- 代码:预处理、训练和评估脚本、用于设计特性的笔记本、其他实用程序。运行(和重新运行)实验所需的所有代码。
- 环境:跟踪环境最简单的方法是保存环境配置文件，如
Dockerfile(Docker)、requirements.txt(pip)或conda.yml(conda)。你也可以在 Docker Hub 上保存 Docker 镜像，但是我发现保存配置文件更容易。 - 数据:保存数据版本(作为数据文件的一个散列或位置)可以很容易地看到你的模型被训练了什么。你也可以使用现代的数据版本控制工具，比如 T2 DVC T3。dvc 文件到你的实验跟踪工具)。
- 参数:保存您的跑步配置绝对至关重要。当您通过命令行(argparse，click，hydra)传递参数时要特别小心，因为这是一个您很容易忘记跟踪的地方(我有一些恐怖故事要分享)。您可能想看看这篇关于跟踪超参数的各种方法的文章。
- 度量:记录每次运行的训练、验证和测试集的评估度量是非常明显的。但是不同的框架做的不一样，所以你可能想看一看这篇文章，这篇文章深入地讨论了在 ML 模型中跟踪度量标准。
跟踪这些事情会让你重现实验，进行基本的调试，并在高层次上理解发生了什么。
也就是说，你总是可以记录更多的事情来获得更多的洞察力。
你还能跟踪什么
您可能希望跟踪的其他事情与您正在进行的项目类型有关。
以下是我对各种 ML 项目类型的一些建议。
机器学习
- 模型重量
- 评估图表(ROC 曲线、混淆矩阵)
- 预测分布
深度学习
- 模型检查点(培训期间和之后)
- 梯度规范(控制消失或爆炸梯度问题
- 训练后验证/测试集的最佳/最差预测
- 硬件资源:在调试数据加载器和多 GPU 设置时特别有用
计算机视觉
- 每个时期后的模型预测(标签、覆盖的遮罩或边界框)
自然语言处理
结构化数据
- 输入数据快照(如果使用 pandas，则为训练数据上的`. head()'
- 特征重要性(排列重要性)
- 像 SHAP 或部分相关图(它们都可以在 DALEX 中找到)这样的预测解释。
强化学习
- 剧集回归和剧集长度
- 总环境步数、墙壁时间、每秒步数
- 价值与警察职能的丧失
- 聚合多个环境和/或运行的统计数据
如果你想了解更多关于强化学习的最佳实验跟踪实践，你真的应该阅读这篇深度指南。
超参数优化:
- 运行分数:每次迭代后，你用 HPO 优化的度量
- 运行参数:每次迭代尝试的参数
- 最佳参数:迄今为止的最佳参数和 HPO 扫描完成后的最佳参数
- 参数对比图:在训练期间或之后，您可能想要记录各种可视化，如平行坐标图或切片图(顺便说一下，它们都可以在 Optuna 中找到)。
如何设置实验跟踪
好的，这些都是很好的指导方针，但是你如何在你的项目中实现实验跟踪呢？
(至少)有几个选择。最受欢迎的是:
- 电子表格+命名约定
- 使用 Github 对配置文件进行版本控制
- 使用现代实验跟踪工具
现在就来说说那些吧。
您可以使用电子表格和命名约定(但请不要这样做)
一种常见的方法是简单地创建一个大的电子表格,在那里你可以放置所有的信息(度量、参数等)和一个目录结构，在那里事物以特定的方式命名。这些名字通常都很长，比如' model _ v1 _ lr01 _ batch size 64 _ no _ preprocessing _ result _ accuracy 082 . H5 '。
每当你运行一个实验，你看着结果，并把它们复制到电子表格中。
这有什么错？
老实说，在某些情况下，它可能刚好足以解决您的实验跟踪问题。这可能不是最好的解决方案，但它快速而简单。
…事情很快就会分崩离析
但是事情很快就会分崩离析。(至少)有几个主要原因可以解释为什么在电子表格中跟踪实验对许多人来说不起作用:
你必须记得跟踪他们。如果事情没有自动发生，事情就会变得混乱，尤其是当更多的人参与进来的时候。
- 你必须确保你或你的团队不会无意中覆盖电子表格中的内容。电子表格不容易版本化，所以如果发生这种情况，你就有麻烦了。
- 你必须记住使用命名约定。如果您团队中的某个人搞砸了，您可能不知道您运行的实验的实验工件(模型权重、性能图表)在哪里。
- 你必须备份你的工件目录(记住东西会坏掉)。
- 当您的电子表格增长时，它变得越来越不可用。在一个电子表格中搜索东西和比较数百个实验(尤其是如果有多人想同时使用它)不是一种很好的体验。
- 您可以在 GitHub 中对元数据文件进行版本控制
另一个选择是在 Github 中对所有实验元数据进行版本化。
你可以这样做，就是在运行你的实验时，将度量标准、参数、图表和任何你想跟踪的东西提交给 Github。这可以通过 post-commit hooks 来完成，在那里你可以在实验完成后自动创建或更新一些文件(配置、图表等)。
… Github 不是为…机器学习而构建的
它可以在某些设置中工作，但是:
。git 和 Github 不是为了比较机器学习对象而构建的。
- 对比两个以上的实验是行不通的。对比一下。git systems 是为比较两个分支而设计的，例如，master 和 develop。如果你想比较多个实验，看看指标和叠加学习曲线你就不走运了。
- 组织许多实验是困难的(如果不是不可能的话)。你可以有想法的分支或者每个实验的分支，但是你运行的实验越多，它就变得越不可用
- 您将无法实时监控您的实验，信息将在您的实验完成后保存。
- 你应该怎么做？
你可以使用一种现代实验跟踪工具
虽然您可以尝试和调整通用工具来进行机器学习实验，但您可以只使用专门为跟踪、组织和比较实验而构建的解决方案之一。
“在最初的几十次运行中，我意识到跟踪是多么完整——不仅仅是一两个数字，还有代码的确切状态、存储到云的最佳质量模型快照，以及快速添加特定实验注释的能力。相比之下，我以前的方法简直是一团糟。”–英特尔数据科学家 Edward Dixon
它们的界面略有不同，但通常以相似的方式工作:
第一步
通过向您的培训代码添加一个代码片段来连接到该工具。
例如:
第二步
import neptune.new as neptune
run = neptune.init(...)
指定您想要记录的内容(或者使用 ML 框架集成来完成):
第三步
from neptune.new.types import File
run['accuracy'] = 0.92
for prediction_image in worst_predictions:
run['worst predictions'].log(File.as_image(prediction_image))
像平常一样运行您的实验:
就是这样！
python train.py
您的实验记录在中央实验数据库中，并显示在实验仪表板中，您可以在其中搜索、比较和深入查看您需要的任何信息。
今天至少有一些好的实验跟踪工具，我强烈推荐使用其中的一个。他们被设计成将机器学习实验视为一等公民，他们将永远:
对于机器学习者来说，比一般工具更容易使用吗
- 与 ML 生态系统有更好的整合
- 比一般的解决方案有更多以实验为中心的特性
- 后续步骤
实验跟踪不仅仅是一种工具或记录方法，更是一种实践。真正理解和实施需要一些时间:
为你的项目跟踪什么，
如何利用这些信息来改进未来的实验，
- 如何利用 it 改善您团队独特的工作流程，
- 甚至什么时候使用实验追踪。
- 希望在读完这篇文章后，你对实验跟踪是否能改善你(或你的团队)的机器学习工作流程有一个好的想法。
- 你想开始追踪你的实验吗？
你想知道更多关于这个话题的内容吗？
以下是一些附加资源:
快乐实验！
Here are some additional resources:
Happy experimenting!*
从研究到生产的 ML-挑战、最佳实践和工具[指南]
原文：https://web.archive.org/web/https://neptune.ai/blog/ml-from-research-to-production
将机器学习或人工智能投入生产需要很多耐心、努力和资源。人工智能模型非常适合预测各种事情，从你喜欢什么电影到你的猫是否会划伤家具。但在大多数情况下，人工智能模型很难投入生产。
在本文中，我们将讨论为什么很难将模型投入生产，如何将机器学习实验从研究阶段投入生产，以及在模型投入生产后需要考虑的事项。
From research to production – core steps | Source: Author
在生产中发布 ML 模型面
有大量不同的平台可以让你的模型可用。从编写平台的语言到使用的部署和分发模型，每个平台都面临着独特的挑战。由于这些挑战，一个好主意可能会在这个阶段被抛弃。
人工智能模型通过在数据中发现人类不会注意到的模式和关系来工作。模型做出的预测准确度高，但精确度较低——当您的企业依赖具有精确测量或公差的产品时，这可能是危险的。为了将这些模型用于现实世界的应用中，它们需要能够准确而精确地进行预测。
对于任何企业、商业或预测分析公司来说，训练和部署机器学习模型都是一项重大挑战。从可用的数据类型到所需的集成工作区，有几个原因导致 ML 模型难以投入生产。让我们探讨一下可能影响模型性能的几个原因。
异常值处理不佳
异常值处理是从数据集中消除异常值的过程。这项技术可以应用于不同的规模，以产生更准确的数据表示。这会影响模型的性能。根据模型的不同，影响可能大或小，例如，线性回归很容易受到异常值的影响。这个过程应该在模型训练之前进行。
生产监控
生产中的任何模型都需要定期监控。监控和管理机器学习模型是工作流的一个关键部分，保留所有数据集、输入和预测的记录也是如此。随着时间的推移，许多事情都会发生变化，因此监控我们的模型非常重要。
假设您的模型运行良好，但随着时间的推移，性能变得越来越差。您可能有一个包含新信息的新数据集，它正在改变模型。或者可能是模型存在严重问题，需要改进或更新。无论是哪种情况，您都需要一种方法来检查是否应该重新优化。最好定期监控和更新模型。
让我们来看看几个进行 ML 模型监控的最佳工具:
| 工具 | 信息 | 定价 | 关键特征 |
|---|---|---|---|
Neptune 是一个轻量级的实验管理和协作工具。它非常灵活，可以与许多其他框架一起工作
| |
–快速美观的 UIrn–实验跟踪和可视化功能 rn–高效存储和组织您的工作
|
| |
简单易行持续监控 ml-model 性能在 Azure，Google & AWS。在 Qualdo
T3【批量监控机器学习或分析模型】 |
免费赠送 10 GB，61 美元/月之后
|
–数据质量工具&针对所有利益相关方的指标 rn–在几分钟内消除高风险数据问题！
|
| |
Fiddler 是一个模型监控工具，具有友好、清晰、简单的界面
|
入门即可免费试用。你可以联系他们定价
|
–性能监控 rn–跟踪异常值 rn–服务指标和警报
|
→要了解更多关于监控的信息，请查看Neptune现场监控 ML 实验的完整指南。
偏差和方差
假设您正在构建一个预测模型来估计一辆汽车的年运营成本。您从相似品牌和型号的汽车中收集数据，您已经完成了该评估。您会注意到年度运营成本的值无处不在——一些项目的年成本为 2000 美元，而其他项目的年成本高达 8000 美元。为了尝试捕捉数据的可变性，您决定从其他来源引入更多数据。因为你现在有了更多的数据，你重新训练你的模型，最终得到一组新的值，但是它们又遍布地图。这是偏见的第一个来源。
我们数据集中的值的方差如此之大，以至于您无法对我们的数据做出任何可靠的统计结论。这是因为你没有足够的类似车辆的数据点，无法对这些汽车的实际年运营成本做出任何具体的结论。
偏差-方差权衡，当模型的偏差较低而方差较高时，它很可能从数据集过度学习了。线性算法倾向于具有高偏差但低方差，而非线性算法倾向于具有低偏差但高方差。当你增加方差时，偏差会减少，当你增加偏差时方差会减少。这种权衡是这两者所建立的误差之间的牵引。
阶级不平衡
在机器学习中，类不平衡问题是指一个类的实例比另一个类的实例更常见。虽然这在许多地区非常普遍(例如，狗的数量比猫多大约 3 比 1)，但这可能是一个相当大的问题。为了构建有效的机器学习算法，您需要能够在任何一种类型的实例上运行良好的模型。
导致类不平衡的一个常见情况是，您正在训练的算法将用于新域的数据集。例如，假设您正在构建一种垃圾邮件检测方法，您的数据包含数千封电子邮件，其中大多数是垃圾邮件，只有少数是非垃圾邮件。这造成了不平衡，因为数据集中 85%的实例是垃圾邮件。
解决这个问题的一个方法是从新的领域获取更多的数据，但这可能会被证明是昂贵的。相反，您可以从具有低类别不平衡的类似领域中获取一些现有数据，并在将我们的算法用于具有不平衡类别的原始较大集合之前，在这个较小集合上训练我们的算法。
| 研究 | 生产 | |
|---|---|---|
比更简单的型号
|
| | | |
| | |
不断移位，缺失值和标签
|
| | | |
从 ML 研究到生产:挑战
→在管理机器学习生命周期的最佳 MLOps 平台中阅读更多关于 MLOps 的信息
为生产做准备
让我们看看从研究到生产的各个步骤。它们是常见的步骤，但它们可能会根据您的机器学习模型或应用程序而变化。我们将讨论改进和优化您的模型的方法。
第一个关键步骤是对一切事物的深入研究；你的产品，模型，算法，工具，还有其他的一切。随着新技术或新方法的出现，这些事情会不时发生变化。你必须跟上时代的步伐。首先，你必须研究解决问题的不同方法。研究通常包括阅读研究论文或文章，观看演示或视频，或者使用工具和代码。所有这些都是研究过程的一部分。
与相同或不同领域的研究人员交谈。这会给你很多关于事情如何运作以及什么会出错的知识。它还将帮助您了解资源和工具。
世界上有成千上万的研究论文发表，但很少有人能在全球读者面前发表。以下是人工智能领域的几篇关键研究论文:
- 亚当:随机优化的一种方法 ，迪德里克·p·金马，吉米·巴
- 地震预警的分布式多传感器机器学习方法 ，凯文·福维尔、丹尼尔·巴卢克-托默特等 8 人。
- 更快的 R-CNN:面向实时目标检测的区域建议网络 ， 【邵青】 ， 【明凯】 等
- 注意力是你所需要的一切 ，瓦斯瓦尼等人，NeurIPS 2017，被 18178 引用
- 神经机器翻译通过联合学习来对齐和翻译 ，巴赫达瑙等人，ICLR 2015，被 16866 引用
还有很多很棒的研究论文，我在本文末尾多加了几篇。
一旦你完成了实验的研究，就到了定义你的模型如何工作的时候了——从所有可用的来源收集数据。数据越多越好。有两种类型的数据；结构化和非结构化。结构化数据包括日期、数字等。非结构化数据是大型文件，包括图像、文本、视频等。
有许多不同的方法来收集机器学习实验的数据。考虑图像分类的问题。为了对图像进行分类，首先，你需要有大量的图像。手动收集它们非常耗时，并且手动分类成千上万的图像需要相当长的时间。机器学习算法可以用来快速处理这成千上万的图像，节省时间。
- 探索性数据分析
使用机器学习应用程序时，理解您的数据非常重要。探索性数据分析(EDA)是识别数据集中的模式、异常和异常值的过程。它是通过探索大量数据，可视化模式以发现趋势，发现意想不到的结果或不规则性，并对它们进行理解来完成的。
商业中许多重要决策都是在探索性数据分析的基础上做出的。这项技术有助于确定针对这些假设要测试什么，这有助于证明或否定一个理论，无论是市场研究还是从生产材料中估算成本。这个过程包括检测结果的原因，并根据变量被分配到的分组来理解变量之间的关系。大多数情况下，当有许多不同的变量导致结果，并且您可能真的不知道结果或模式应该是什么样子时，EDA 会工作。它甚至可以应用于复杂的物流问题，只需在地图上放置数据点以及组成这些点的属性。
探索性数据分析类型:
EDA 通常是图形或非图形的(定量的)。
- 单变量非图形-这是一种通过一个变量分析数据的分析形式。这是所有 EDA 类型中最简单的方法。这里的动机是找到并画出图案。
- 单变量图形–当使用图形方法代替非图形方法时，它提供了数据的全貌。单变量图形由三个子部分组成；柱状图、茎图、叶图和箱线图。直方图是描述数值范围内案例总数的图表。茎和叶是代表分布形状和数据值的图。箱线图显示了最小值、中值和最大值的汇总。
- 多元非图形–这种方法表示两个或多个数据变量之间的关系。
- 多元图形–这是两个或多个数据变量之间关系的图形表示。在大多数情况下，条形图用于这种方法。
探索性数据分析工具:
Python 和 R 是 AI 和数据科学应用中使用最多的语言。如果你对编码了解较少，也可以使用其他工具。Trifacta、Excel、Rapid Miner、Rattle GUI 和 Qlikview 是一些很好的 EDA 非编程工具。
- 特征工程和模型选择
特征工程是机器学习中的一种方法，它使用数据来生成训练集中不存在的新变量。一旦你准备好了数据，这个过程就是下一步。它可以为监督和非监督学习生成新的要素，通常目标是简化和加速数据转换并提高模型精度。在处理机器学习模型时，特征工程是一种至关重要的方法。如果您有一个不好的特性，这将直接影响您的模型，不管数据或架构如何。这是一个在统计或机器学习技术的帮助下，将原始观察结果转换为所需特征的简单过程。向模型中添加新特征总是一个好主意，因为这可以提高灵活性并减少差异。
现在，让我们举一个简单的例子。下面是特定区域的房价。它显示了房子的面积和总价。
当您处理数据时，您的数据可能会出现问题。数据可能来自互联网或各种其他来源，并且充满错误。因此，收集完数据后，您将创建一个新列来显示每平方英尺的价格。
一旦创建了新列，您现在就可以使用领域知识。比如，你可以咨询任何一个房地产人士来确认平方英尺。价格。如果这个人说每平方英尺的价格不能低于 3500，那么你可能有问题。你可以将数据可视化以便更好地查看。
当你绘制数据时，你可以在上面看到一个特定的价格与其他价格有很大的不同。你可以很容易地在可视化方法中发现错误。你也可以使用数学/统计来观察你的数据。
模型选择是一种方法，可以应用于不同类型的模型，或同一类型但不同的超参数。简单地说，选择模型作为最终模型的过程定义了问题。在选择模型时，有许多事情需要考虑，并且有许多不同的模型选择技术。
→阅读机器学习中模型评估和选择的最终指南中关于模型评估和选择的更多信息
模型开发经常被误解，因为人们认为这一步花费的时间最多。然而，通常大部分时间都花在清理、准备和探索数据上。在此过程中，您将训练、测试和验证集合。为什么要使用三个过程而不是训练模型和测试它？从事模型开发需要配置调整。这是在从验证数据集收到的反馈的帮助下完成的。简单来说，你可以称之为一种学习形式。我们的主要目标是获得看不见的数据的准确输出。
目标是给模型尽可能多的关于其领域中对象属性的知识，并使用这些知识来做出准确的预测。许多这样的方法被用于不同的领域，包括自然语言处理、数据挖掘、用户界面设计、计算机视觉等等。
训练模型时，监控优化和泛化之间的关系很重要。优化是一种校准模型以在训练数据集上获得最佳结果的方法。泛化是一个让你知道一个模型如何对看不见的数据执行的过程。你的模型可能在某些时候表现不佳，这是由于过拟合或欠拟合造成的。正因为如此，泛化停止改进，模型变得不太准确。您可以通过添加更多数据来停止过度拟合或欠拟合，这是进行归纳的最佳方式。
在为生产构建模型时，需要记住的事情很少
一般化:这个过程显示了我们的模型在新的(看不见的)数据上的表现。最终目的是获得最好的泛化强度。与其花几个月的时间构建模型并失败，不如花更多的时间准备一个好的验证环境。
性能:模型性能有三种计算方式。首先，获得一个好的交叉验证分数。它用于比较和选择特定预测问题的模型。它包括将一个大项目分成许多小的子项目，这样它们就可以由不同的工人在大致相同的时间完成。K-fold 交叉验证是根据未知数据确定模型性能的过程。在 K-fold 验证中，您将数据分成 K 个独立的组，选择一个测试集并保留作为训练集，在测试集上测试它，并评估结果和得分。另一种方法是确定生产分数，当模型处于测试阶段时，您可以通过实时数据监控其性能。可解释性确保模型不难解释。
迭代过程:机器学习是一个漫长的过程，涉及收集、清理、准备、分析数据、拟合模型、获得输出、监控、修改等等。所以，不要认为从模型到生产是一蹴而就的过程。
正则化:这是一个通过在训练数据集上拟合模型来减少误差并避免过度拟合的过程。有几种正则化方法:
-
一种常用的方法是通过减少模型中的参数来减小模型的大小。您可以设置不同的参数集并测试性能。
-
L1 正则化，被称为最小绝对收缩和选择算子。它将权重系数的绝对值相加。
-
L2 正则化，被称为岭回归。它计算权重系数的平方值。
基准模型:基准模型是最易于使用、可靠、透明和可解释的模型，您可以与它进行比较。最佳实践是检查您的新机器学习模型在测试数据集中的表现是否优于已知基准。
基准模型易于实现，不需要太多时间。使用任何标准算法找到合适的基准模型，然后将结果与模型预测进行比较。如果标准算法和最大似然算法之间有许多共同特征，那么简单的回归可能已经揭示了算法可能存在的问题。
超参数调整:超参数调整是关于改进超参数，它控制学习算法的行为。例如，学习速率(α)或梯度下降优化中的复杂度参数(m)。
一个常见的超参数优化案例是通过使用交叉验证来选择最佳值，以便选择对看不见的数据最有效的方法。这评估了模型参数在训练期间是如何更新的。通常，这项任务是使用简单的试错法手动执行的。有很多不同的方法来调整超参数，例如网格搜索、随机搜索方法、贝叶斯优化方法和简单的有根据的猜测。
模型优化:一旦你完成了训练并获得了想要的结果，是时候让模型更好地预测了。机器学习优化是利用数学原理优化机器学习的过程。事情是这样的——你有一些数据，你用一种非平凡的机器学习算法来分析它，以找到模式。有许多算法可用于各种任务，但由于其复杂性，ML 优化可能很困难。ML 优化既需要数学方面的专家，也需要统计方面的专家，还需要相关领域的知识，因为它依赖于从专业领域学到的统计方法。我们将看到一些优化机器学习模型的方法。
梯度下降:梯度下降是一种可以用来优化优化问题的参数的技术。它将通过在梯度中最陡斜率的方向上执行小的改变来将参数移向其最佳值。它很有用，因为它有助于解决静态问题，在静态问题中，你知道我们的约束是什么，并且你有足够的数据来确定我们的当前值有多好。让我们举一个简单的例子，两个人在交谈:
斯密特:“罗伊，你数学考试得了多少分”
罗伊:“猜！”
斯密特:“80%？”
罗伊:“我不太擅长数学。”
斯密特:“60%？”
罗伊:“不行，那太低了。”
斯密特:“是 70%左右吗？”罗伊:“是的，非常接近！”
这就是梯度下降的工作原理。在梯度下降中，你从一个随机的猜测开始，慢慢地移动到正确的值。该过程从使用梯度下降来寻找截距开始，您将使用它来求解截距和斜率。
- 它有效且稳定，
- 它更容易在短时间内使用，
- 如果有许多局部极小值，它可能不起作用。
遗传算法:遗传算法是一种搜索优化方法。这项技术模拟了自然界中发生的自然选择过程，对于一个给定的问题，更好的解决方案比更差的解决方案更有可能存活和繁殖。例如，有许多模型，但你必须保留具有高度准确性的模型。
- 你可以在短时间内找到一个好的结果，
- 它提供了许多解决方案，
- 你无法确定结果是否是最优的。
穷举搜索:通过检查每个选项来搜索最优超参数的方法。例如，你忘记了你的电子邮件或手机密码，所以你尝试了每一个可能的选项。但在机器学习中，这是在非常大的集合上完成的。
- 该过程检查所有可能的选项，
- 这可能会让事情变得非常缓慢，
- 当集合很小时，它会更有效。
最后一步:现在一切都完成了，是时候进行模型的端到端测试和最后的训练了。您必须测试许多实现，以确保一切按计划进行。一旦一切顺利，你就去生产！
投入生产后需要考虑的事项
你的实验可能已经开始运行，但这并不是你工作的结束。你必须继续致力于生产架构。您将填补数据集中的空白，监控工作流程，并定期更新系统。
程序可重用性:在数据准备和培训阶段使用可重复、可重用的程序可以使事情变得健壮和易于扩展。笔记本通常不容易管理，但使用 Python 文件可能是一个不错的选择，因为这将提高工作质量。开发可重复管道的关键是将机器学习环境视为代码。这样，您的整个端到端管道可以在重大事件发生时执行。
数据和监控:对于您的 ML 实验的连续过程，您必须关注数据和环境。如果输入数据发生变化，您可能会发现模型准确性的问题。监控和管理机器学习模型是工作流的重要组成部分(保留所有数据集、输入和预测的记录)。有时，实现的数据和连接的标签可能会改变。
自动化:机器学习中一个经常被忽视的部分是自动化。在自动化脚本或工具的帮助下，原本需要几个小时才能变得简单的任务可以节省软件开发的时间，并专注于重要的步骤，如模型评估和功能工程。
治理:当你进入生产阶段时，从事产品/服务的开发人员和数据科学家的数量将会增加，因为这将有助于分配工作并使交付更快。如果没有适当的生产治理，会出现许多问题。你必须创建一个中心，让团队的每个成员都可以联系在一起，并且可以访问必要的东西。这使得事情变得非常顺利，易于维护。管理和组织你的机器学习实验本身就是一项任务。
海王星如何帮助你把你的项目从研究变成生产
Neptune 是为研究和生产团队开发的 MLOps 的元数据存储。它为我们提供了一个记录、存储、显示、组织、比较和查询机器学习生命周期中生成的所有元数据的中心。研究人员和工程师使用海王星进行实验跟踪和模型注册，以控制他们的实验和模型开发。
Metadata store is a connection between research and production stage
用于研究:
- 记录和显示所有元数据类型，包括参数、模型权重、图像、HTML、音频、视频等。,
- 快速美观的用户界面，具有多种功能，可以分组组织跑步，保存自定义仪表板视图并与团队共享，
- 在一个表格中比较度量和参数，该表格自动发现运行之间的变化和异常，
- 每次运行实验时，自动记录代码、环境、参数、模型二进制文件和评估指标，
- 你的团队可以跟踪在脚本(Python，R，other)，笔记本(local，Google Colab，AWS SageMaker)中执行的实验，并在任何基础设施(云，笔记本电脑，集群)上进行，
- 广泛的实验跟踪和可视化功能(资源消耗、图像列表滚动)
用于生产:
- 跟踪 Jupyter 笔记本，
- 协作和监督项目，
- 实时训练模型，
- 为个人和团队提供笔记本检查点和模型注册，以跟踪模型版本和沿袭，
- 跟踪数千次跑步，
- 版本、存储、组织、查询模型等等。
结论
将你的模型投入生产是很困难的，但是你的经验越多，你就会做得越好。大量的耐心、资源和承诺可以让生产之旅变得令人惊叹。我希望你喜欢这篇文章，感谢阅读！
额外研究和推荐阅读
ML 元数据存储:它是什么，为什么重要，以及如何实现它
原文：https://web.archive.org/web/https://neptune.ai/blog/ml-metadata-store
大多数找到这个页面的人都想改进他们的建模过程。
但是他们在存储和管理 ML 模型元数据方面的问题是不同的。
对一些人来说，问题在于杂乱的实验。
其他人已经将第一批模型部署到生产中，但是他们不知道这些模型是如何创建的，也不知道使用了哪些数据。
有些人已经在生产中有了许多模型，但是编排模型 A/B 测试，切换挑战者和冠军，或者触发、测试和监控再培训管道并不是很好。
如果你认为自己属于这些群体中的一员，或者介于两者之间，我可以告诉你，ML 元数据存储可以帮助你完成所有这些事情，还有其他一些事情。
您可能需要将其连接到其他 MLOps 工具或您的 CI/CD 管道，但它将简化大多数工作流程中的模型管理。
…但实验跟踪、模型注册、模型存储、模型目录和其他与模型相关的动物也是如此。
那么 ML 元数据存储到底是什么，它与其他模型有什么不同，它如何帮助您更自信地构建和部署模型？
这就是这篇文章的内容。
另外，如果你是那种喜欢摆弄东西来看看它们是什么的人，你可以在 Neptune ML 元数据存储库中查看这个示例项目。
但是首先…
在我们深入 ML 元数据存储之前，我可能应该告诉你我所说的“机器学习元数据”是什么意思。
当你做机器学习时，总会涉及到一个模型。这就是机器学习。
它可能是一个经典的监督模型，如 lightGBM 分类器、强化学习代理、贝叶斯优化算法或其他任何东西。
但它需要一些数据，通过一些数字运行，并输出一个决定。
…将它投入生产需要大量的工作。
您必须:
- 火车，
- 调，
- 调试，
- 评估，
- 解释一下，
- 并将其与基线进行比较。
如果您的模型通过了研究阶段，您还必须:
- 包装，
- 部署，
- 监视器，
- 重新训练它。
很多步骤。
现在你可能知道了，你不会线性地经历这些步骤，你不会经历一次。
修复数据、修复模型、修复预处理以及所有这些好的东西需要大量的迭代。
这些步骤中的每一步都会产生关于模型的元信息，或者许多人所说的 ML 模型元数据。
这些可能是:
- 训练参数，
- 评估指标，
- 预测实例，
- 数据集版本，
- 测试管道输出，
- 对模型权重文件的引用，
- 以及其他与模型相关的东西。
这些信息有助于您了解您的模型。
它有助于您了解:
- 模型的特定版本在哪里，并快速回滚到以前的版本
- 模型是如何构建的，是谁创建的
- 它在训练中使用了哪些数据/参数/代码
- 新的实验或模型版本与基线或以前的生产模型相比如何
- 它在各个评估阶段的表现如何
当你的模型对某人很重要时，当他们接触用户或帮助客户做决定时，你最好多了解他们。
为什么？
因为当你的模型工作时一切都很好，但当它停止工作时，你让它再次工作的唯一机会是理解它为什么失败。
但是你通常不会平等地关心所有的模型元数据。
对于某些工作流，实验元数据至关重要，对于某些工作流，它是生产模型元数据，对于某些工作流，它是再培训管道元数据。
由您来决定您和您的工作流程需要什么。
为了帮助您了解您可能关心的内容，让我们列出这些类别中的示例元数据。
关于实验和模型训练运行的元数据
在实验过程中，你通常关心的是调试、可视化、监控你的模型训练，以获得最佳模型。
为此，记录 ML 运行期间发生的任何事情都是一个好的做法，包括:
- 数据版本:参考数据集、md5 哈希、数据集样本，了解哪些数据用于训练模型
- 环境配置: requirements.txt，conda.yml，Dockerfile，Makefile 了解如何重建模型被训练的环境
- 代码版本:获取提交的 SHA 或代码的实际快照，以了解使用了什么代码来构建模型
- 超参数:管道的特征预处理步骤的配置，模型训练，以及必要时再现过程的推理
- 训练指标和损失:单值和学习曲线，看看继续训练是否有意义
- 记录硬件指标: CPU、GPU、TPU、内存看你的模型在训练/推理过程中消耗了多少
- 评估和测试指标:测试和验证集上的 f2、acc、roc，以了解您的模型表现如何
- 绩效可视化: ROC 曲线、混淆矩阵、PR 曲线，深入了解错误
- 模型预测:查看实际预测并了解超出指标的模型性能
- …以及大约 100 万个与你的领域相关的其他东西
Example of model training runs metadata | Source
关于工件的元数据
除了实验和模型训练运行，在 ML 项目中还使用了一个概念:工件。这些运行的输入或输出可以在项目的许多运行中使用。工件在项目过程中会发生变化，在 ML 生命周期的某个时刻，您通常会有同一个工件的多个版本。
工件可以是数据集、模型、预测和其他类似文件的对象。对于您可能想要记录的工件:
- 引用:数据集或模型的路径(s3 存储桶，文件系统)
- Version: Dataset 或 model md5 hash 让你快速看出区别
- 预览:数据集/预测预览(表头，图像文件夹快照)查看该数据集的内容
- 描述:关于神器的附加信息将帮助你理解它是什么。例如，您可能想要记录表格数据集工件的列名
- 作者:谁在何时创建和修改了这个工件
- 许多其他的事情可能是你的项目特有的，比如数据集的大小，ML 模型的类型等等
Example of artifacts metadata | Source
关于已训练模型的元数据
经过训练的模型在 ML 项目中是如此重要的一类工件，以至于我决定给它们一个单独的类别。
一旦您的模型经过训练并准备好投入生产，您的需求就会从调试和可视化转变为知道如何部署模型包、对其进行版本化，以及在生产中监控性能。
因此，您可能希望记录的 ML 元数据是:
- 模型包:模型二进制文件或者模型资产的位置
- 模型版本:代码、数据集、超参数、环境版本
- 评估记录:一段时间内发生的所有测试/验证评估的历史记录
- 实验版本:链接到记录的模型训练(和再训练)运行以及与该模型版本相关的其他实验
- 模型创建者/维护者:谁构建了这个模型，如果/当出现问题时，你应该问谁
- 下游数据集/工件:数据集、模型和其他下游用于构建模型的资产的引用。这对于一些组织的法规遵从性来说是必不可少的。
- 漂移相关指标:所有“实时”生产的数据漂移、概念漂移、性能漂移
- 硬件监控:生产中消耗的 CPU/GPU/TPU/内存。
- 当你的模型向世界发送预测时，还有什么能让你晚上睡觉的吗
为了管理所有的元数据，你可以使用模型注册表、生产模型监控工具、实验跟踪工具，或者软件监控解决方案。
Example of trained model metadata
关于管道的元数据
您可能处于这样一个点，您的 ML 模型在一个自动触发的管道中接受训练:
- 当性能下降到特定阈值以下时
- 当新的标记数据到达数据库时
- 当一个特征分支被合并开发时
- 或者干脆每周一次
您可能有一些 CI/CD 工作流连接到管道和编排工具，如 Airflow、 Kubeflow 或 Kedro。在这些情况下，每个触发器开始执行计算 DAG(有向无环图),其中每个节点产生元数据。
最佳工作流和管道编排工具
最佳 MLOps 工具
Kedro-Neptune 集成(允许您过滤、比较、显示和组织管道和节点中生成的 ML 元数据)
Pipeline visualization in Kedro-Viz | Source
在这种情况下，对元数据的需求与实验或模型有所不同。高效计算管道(DAG)需要此元数据:
- 输入和输出步骤:关于什么进入一个节点，什么从一个节点出来，以及是否所有的输入步骤都已完成的信息
- 缓存输出:引用来自管道的中间结果，以便您可以从图中的某个点继续计算
ML 元数据存储是 ML 模型相关元数据的“存储”。在这个地方，您可以获得您构建和部署的任何 ML 模型所需的任何东西。
更具体地说，ML 元数据存储使您能够:
- 日志，
- 店，
- 显示，
- 监视器，
- 比较一下，
- 组织起来，
- 过滤器，
- 并查询所有与模型相关的元数据。
简而言之，它给你一个单一的地方来管理所有关于实验、工件、模型和管道的 ML 元数据。
你可以把它想象成一个数据库和一个专门用来管理 ML 模型元数据的用户界面。它通常附带一个 API 或 SDK(客户端库)来简化 ML 元数据的日志记录和查询。
Metadata store – a database and a user interface | *Source *
等等，它是一个知识库/目录还是什么？
是的，不，算是吧。让我解释一下。
存储库 vs 注册表 vs 存储
在 ML 元数据的上下文中，所有这些基本上都是为存储元数据而创建的数据库，它们的功能略有不同。
元数据库是一个的地方，在这里你存储元数据对象以及这些对象之间的所有关系。您可以使用 GitHub 作为一个存储库，将所有评估指标保存为一个文件，该文件是通过提交后钩子创建的，或者将训练期间的参数和损失记录到一个实验跟踪工具中，该工具在本文中实际上是一个存储库。
元数据注册中心是一个为重要元数据设置“检查点”的地方。您注册了一些您关心的东西，并希望以后可以方便地找到和访问它。一个注册表总是为特定的东西服务的。没有通用注册中心。例如，您可能有一个模型注册中心，它列出了所有的生产模型，并引用了 ML 元数据存储库，实际的模型相关元数据就在那里。
元数据存储是一个你去“购买”元数据的地方。对于 ML 模型，它是一个中心位置，在这里您可以找到所有的模型、实验、工件和管道相关的元数据。你越是需要来到“商店”，搜索元数据“产品”，比较它们，“购买”它们，它就越是一个商店而不是一个储存库。
所以在 ML 模型元数据的情况下:
- 你有许多不同的元数据:许多模型，许多版本，甚至更多的实验和每个实验的元数据
- 你要经常查找和比较:选择最佳模型训练运行或调试生产模型
- 您希望经常记录和访问它:记录实验的训练指标或获取打包的模型
称它为“存储”比称它为“存储库”或“注册表”更有意义，但是和软件一样，这要视情况而定。
现在，如果我告诉你实际上有两种风格的 ML 元数据存储呢？
管道优先与模型优先的 ML 元数据存储
随着你的 ML 组织的成熟，当训练模型发生在一些自动化的、协调的管道中时，你会到达一个点。
此时，运行实验、培训和再培训生产模型总是与执行管道相关联。
您的 ML 元数据存储可以:
- 将管道视为一级对象，并将生成的模型和实验与它们相关联。
- 将模型和实验视为一级对象，将管道视为一种执行模式。
根据您放在中心的内容，您的 ML 元数据存储将做稍微不同的事情。
如果你关注过程，模型构建管道，你会得到类似于 MLMD 的东西，它驱动管道和编排工具，如 Kubeflow 和 TensorFlow Extended (TFX) 。
如果你关注输出，模型，你会得到类似于 MLflow 或者 Neptune 的东西。
哪个更好？
我想没有人知道，真的，但是 ML 社区的人们正在积极地测试这两者。
正如管道优先 ML 元数据商店的 MLMD 产品经理 Ben Mathes 解释的那样:
“答案背后有一些很精彩的 HCI 和产品策略观点。
在 ML 行业中有多种努力来解决跟踪所有 ML 工件的问题:模型、数据集、特征等。与经典软件工程迭代跟踪代码的多种方式相同(像 subversion 这样的集中回购，像 git 这样的分散回购，等等)。)，ML engineering 正在发展跟踪 ML Engineering 的最佳方式。
在我看来，ML-Flow 是一种模型优先的观点。如果你熟悉的话，这有点像 RDBMs 中的星型模式。与 TFX 的管道优先观点相反。MLMD 可以成为 TFX 管道记录每次运行的 DAG 历史的一部分。MLFlow 和 MLMD 都在积极开发中，所以这些意见是移动的目标🙂
理论上，每个视图(模型优先或管道优先)都可以从另一个视图中恢复。从管道优先视图中恢复模型优先视图更容易，因为它只需要隐藏信息(管道的其余部分)。但是模型优先视图可能不会首先存储模型之外的额外信息，如其训练数据、分析、与在相同管道上训练的其他模型的比较、模型的完整血统等。
所以 MLFlow 从一个不同于 ML 元数据的角度来看待这个问题。管道优先，而不是模型优先。我们谷歌发现，让管道成为一等公民更有用。"
“但是功能商店呢？”
好了，我们开始吧。
ML 元数据存储与功能存储
ML 元数据存储类似于功能存储吗？是不是同样的东西只是用在不同的地方？
简单的回答是否定的(详细的回答也是否定的🙂 ).
Feature store 是一种 ML 设计模式和实现它的一类工具，它抽象了特征生成，并允许您:
以同样的方式创建和访问特征
确保您在生产中使用的功能与培训中使用的功能相同
重复使用特征进行模型构建和分析
如果你想了解更多关于功能商店的细节，可以看看泰克顿的人写的一篇文章，他创建了最好的功能商店之一。
他们比我更清楚如何解释这件事。
但是为了便于讨论，请务必记住，功能存储侧重于:
一致的特性工程(从开发环境到生产环境)
轻松访问各种功能
了解特征生成过程
正如我前面所解释的，ML 元数据存储处理模型元数据，并关注:
发现、可视化和比较实验
模型传承和版本控制
模型训练和实验的可重复性
轻松访问包装模型
但是模型版本化的一部分是知道哪些特性被用来创建它，对吗？
正确。
这就是为什么您可以将 ML 元数据存储连接到要素存储，并记录对用于训练的要素的引用。
这些工具应该很好地协同工作，以改进您的建模工作流程。
这给我们带来了最重要的问题…
现在您已经知道了它是什么，让我们深入了解它如何帮助您自信地管理模型。
根据您的工作流是侧重于实验还是生产，您从 ML 元数据存储中获得的需求和价值可能是不同的。
让我们来谈谈这两个极端。
为什么要存储机器学习实验的元数据？
在实验和模型开发过程中，您最关心的是找到一个足够好的模型。
然而，什么是足够好的呢？
它可能是一个比随机猜测稍微好一点的模型，或者它可能是这个问题的最先进的(SOTA)。和往常一样，这要视情况而定，但是要实现这一点，您通常需要运行许多迭代。
为了在每次迭代中改进您的模型，您需要:
- 知道之前尝试过什么
- 将新想法与基线或当前最佳模型进行比较
- 可视化模型结果，执行错误分析，看看哪里可以改进
- 能够重现你之前尝试过的想法
- 调试模型和/或基础设施的问题
ML 元数据存储通过为您提供以下功能来帮助您完成所有这些工作:
- 在一个地方保存所有实验和 ML 模型元数据的跟踪记录
- 搜索/过滤界面找到你关心的实验
- 可视化和比较实验的工具
- 接口来记录/显示在调试过程中可能有用的所有元数据
Metadata store dashboard | Source
为什么要存储关于生产机器学习模型的元数据？
一旦你的模型投入生产，你的兴趣就会发生很大变化。
您有一个足够好的经过训练的模型版本，但是您想确信您可以在业务应用程序中使用它。具体来说，您可能希望:
- 了解模型是如何建造的。谁造的，用了哪些代码、数据、参数、环境版本来训练它。
- 包装模型，以便有人可以在不知道里面是什么的情况下使用。
- 从您的生产环境中轻松访问打包模型的当前和以前版本。
- 检查、监控并提醒模型输入/输出分布的任何意外变化。
- 监控硬件随时间的消耗。
- 在新模型版本部署到生产之前，对其进行测试和批准。
- 拥有自动化的 CI/CD 管道用于测试和培训模型。
- 更多
ML 元数据存储可以使它变得更容易，因为它提供了:
- 接口为团队建立模型版本化和打包的协议
- 能够通过 CLI 和 SDK 以您在生产中使用的语言查询/访问模型版本
- 记录硬件、数据/概念漂移、CI/CD 管道的示例预测、再培训工作和生产模型的地方
- 接口来设置由主题专家、生产团队或自动检查进行批准的协议
Monitoring in a metadata store
你需要一个 ML 元数据存储吗？
但是知道了这些，你真的需要一个吗？
你能仅仅用一个电子表格、文件夹结构、tensorboard 截图和一个 S3 桶就搞定吗？
是的，当然，有时候，但这有什么意义呢？
一位智者曾经告诉我，每一个商业问题都可以通过一个电子表格、google drive 和大量的动力来解决。
我真心相信他是对的。
真正的问题是，为什么要这么做。
为什么要在 ML 模型元数据簿记上浪费时间当您可以:
改进模型的工作
自动化、测试或记录管道的某些部分
找出 ML 要解决的下一个问题
向用户介绍您的解决方案
或者坦白地说，在 youtube 上看《猫》
所有这些都比编写胶水代码或在谷歌表单中输入参数更能利用你的时间…
但是你可以说:“我可以写脚本来自动化所有这些”。
嗯，好吧，我们来谈谈实现。
构建 vs 维护 vs 购买
这是一个古老的难题。从事软件工作的人在职业生涯中会面临很多次。
要做出决定，您应该:
-
了解你实际上在解决什么问题
-
在构建之前，看看是否有工具可以解决这个问题
-
评估构建、维护和定制它需要多少时间
-
不要低估为此付出的努力
但是，让我们具体看看您在 ML 元数据存储上下文中的选项。
自己建立一个系统
赞成的意见
| 骗局 | |
|---|---|
你可以完全为你的用例
创建它 |
| 您可以完全根据您的用例来创建它 | 你必须建立和维护基础设施 |
| 你可以随意改进/改变它 | 你必须为其他人记录下来 |
| | |
|
你必须实现改进并与其他工具集成
| 您必须实现改进并与其他工具集成 |
|
软件不工作是你的错
| 当软件不工作时，那是你的错 |
你可以自己建造整个东西。为元数据设置一个数据库，创建一个可视化界面和一个 python 包来记录数据。
它肯定会完美地工作。
当元数据的数量变得太大，数据库无法处理时，您可以对其进行优化。你可以设置备份和分片，使其防弹。
如果您创建的笔记本中缺少可视化功能，您可以设置适当的 web 界面，并实现与数据库的通信。然后，优化它，智能地处理数据负载，并学习一些设计，使它看起来很好。
您可以实现与 ML 框架的集成，以简化日志记录。如果日志记录部分降低了您的训练脚本的速度，您可以实现一些与数据库的异步通信，以便在单独的线程中记录更大的元数据对象，如图像或音频。
当人们加入你的团队并喜欢你所创建的东西时，你可以创建例子和文档来帮助他们使用它，并随着每一次改进而更新它。
你可以，你可以，但是你的工作是实现和维护一些元数据簿记工具吗？
有时没有其他办法，因为你的设置是超级定制的，你解决的问题与其他人的问题如此不同，以至于你必须这样做。
其他 99.6%的时候，你可以使用别人开发的工具，专注于你应该首先解决的问题。我想是和曼梯·里有关的。
保持开源
赞成的意见
骗局
| |
你要建立和维护基础设施
|
| --- | --- |
| 你必须建立和维护基础设施 |
你不用实现它
|
|
你要根据自己的需求调整
|
文档和社区支持已经存在
|
|
你必须依靠社区的支持
|
其他人正在创造你可能关心的改进
|
|
你可以推出新功能，但可能必须自己实现
| |
| 当软件不工作时，那是你的错 | |
| 项目可能会被创建者/维护者/社区放弃 | |
这通常是一个好的选择，因为您想要的许多特性已经实现了。您可以看到它是如何完成的，并在需要的地方扩展功能。
使用该工具的文档和社区可以帮助您。你可以叉回购，并感到安全，该工具不会消失。
说真的，这通常是一个好的选择，但是有一些事情需要考虑。
一个问题是，通常您仍然需要自己设置和维护它。你必须处理备份，后端数据库的自动伸缩，以及所有这些事情。
另一件事是，即使社区就在那里，当你有问题时，他们也不一定会帮助你。你可能要等几个星期才能得到 GitHub 问题的答案。
第三，如果缺少了什么，你实际上需要继续下去，花一些时间去实现它。
我的观点是，使用开源软件，你不需要为订阅或许可付费，但它并不完全免费。您仍然需要支付:
托管它的基础设施
您或您的团队花费在维护和扩展软件上的时间
- 你或你的团队花在解决问题和寻找解决方案上的时间。
- 不是说不好。只是需要考虑和顾及的事情。
- 你可以把你投入到建立基础设施、维护、修复和扩展项目的时间花在其他事情上，比如做 ML。
购买解决方案
赞成的意见
骗局
你不用实现它
| 你不必实现它 | |
|---|---|
文档和支持由厂商
提供 |
您可能无法自己修复错误/做出改进，供应商修复它们的速度可能会很慢
|
| 您可能无法自己修复 bugs 进行改进，供应商修复它们的速度可能会很慢 | 基础设施已经存在(对于托管选项) |
| 公司可能会退出市场 | 当您需要功能时，您可以请求它们 |
| | |
| | 实际上，许多开源项目都有企业版，你可以付费获得支持或托管版本。 |
所以，是的，你可以花钱请人来:
托管解决方案并扩展基础架构
维护软件
为您提供正常运行的保证，并在出现问题时解决问题
- 支持你和你的团队
- 改进和扩展产品，以帮助您解决您的用例
- 专注于做 ML 的事情。
- 当然，事情并非一帆风顺。
- 您可能仍然会遇到错误，等待数周的改进，或者产品背后的公司可能会破产。
但是这仍然是一个比在你的生产模型变得疯狂的周末修复一些废弃的开源项目的错误更好的选择。最好有一个支持团队，你可以打电话给他们，让他们知道这是他们的问题。
无论如何，假设你想要一个 ML 元数据管理工具。你能用什么？
有哪些 ML 元数据存储解决方案？
MLMD(机器学习元数据)
正如官方文件所说的。
ML 元数据(MLMD)是一个用于记录和检索与 ML 开发人员和数据科学家工作流相关的元数据的库。MLMD 是 TensorFlow Extended (TFX)不可或缺的一部分，但其设计可以独立使用。”
它是一个开源的管道第一 ML 元数据存储，支持 TensorFlow Extended (TFX)和 Kubelfow。
查看教程并开始学习。
MLflow
A high-level overview of the various components that are part of MLMD | Source
MLflow 是一个管理 ML 生命周期的开源平台，包括实验、再现性、部署和中央模型注册。MLflow 目前提供四个组件:MLFlow 跟踪、MLFlow 项目、MLFlow 模型、模型注册"
这是一个开源的模型优先的 ML 元数据存储，您可以使用它来跟踪您的实验(MLFlow Tracking)或打包生产模型(Model Registry)。
如果你有兴趣，可以看看一些使用 MLflow 的例子。
海王星
A list of experiment runs with metrics in MLflow UI | Source
Neptune 是 MLOps 的一个元数据存储库，为运行大量实验的研究和生产团队而构建。
它为您提供了一个中心位置来记录、存储、显示、组织、比较和查询机器学习生命周期中生成的所有元数据。
个人和组织使用 Neptune 进行实验跟踪和模型注册，以控制他们的实验和模型开发。
它支持许多与 ML 模型相关的元数据类型，集成了 MLOps 生态系统中的大多数库，你可以在大约 5 分钟内开始免费使用它。
如果您想了解更多信息:
要了解更多选项，请查看我们写的这篇关于最佳 ML 元数据存储解决方案的文章，并对它们进行比较。
最后的想法
Example dashboard in Neptune | Source
如果你能走到这一步，太好了。感谢您的阅读！
现在，您可能想要自己构建一个 ML 元数据存储库，设置并维护一个开源工具，或者选择一个付费的解决方案。
我们花了数年时间为许多 ML 团队构建、修复和改进 Neptune，以获得人们真正想要使用的东西。
所以如果你决定 试试海王， 牛逼！
ML 模型元数据管理实际上是我们唯一想做好的事情，所以我们略知一二。
如果你走另一个方向，也很棒:)。
当你在自己构建它的时候遇到了障碍，或者受到了其他工具的限制，请联系我们，我们很乐意帮助你。
在那之前，快乐训练！
If you go in the other direction, also great 😃.
When you hit roadblocks building it yourself or get to limitations of the other tools, just reach out, we’d be happy to help.
Until then, happy training!
ML 模型调试的深度指南和你需要知道的工具
原文：https://web.archive.org/web/https://neptune.ai/blog/ml-model-debugging-and-tools
每个人都对机器学习感到兴奋，但只有少数人知道并理解阻止 ML 被广泛采用的局限性。ML 模型在特定的任务上很棒，但是它们也会犯很多错误。项目成功的关键是理解你的模型是如何失败的，并提前准备好适当的解决方案。
如果您不能在模型表现不佳或行为不当时排除故障，您的组织将无法长期适应和部署 ML——这就是为什么模型调试至关重要。
什么是模型调试？
模型调试研究 ML 响应函数和决策边界，以检测和纠正 ML 系统中的准确性、公平性、安全性和其他问题。
现在，如果机器学习是软件，难道不能使用与传统软件开发相同的调试工具吗？
调试 ML 模型比调试传统程序更难，原因有几个:
- 机器学习不止是代码
与传统的代码库相比，ML 代码库有更多的活动部分。存在数据集、在训练期间微调的模型权重、在训练期间改变的优化及其梯度等等。你可以说代码在训练期间是“动态的”,之后它停止变化，而数据和模型在训练期间的语义偏差就像一个未被捕获的 bug 一样在代码中根深蒂固。
缺乏适当的工具来检查培训过程是我们许多人使用打印报表和记录器来分析的原因。
- ML 训练期间的监控和干预很困难
许多 ML 训练代码运行在集群或云中。当您在集群上运行分布式培训作业时，监控进度的主要方法是告诉您的代码生成日志，并将它们保存在一个中心位置以供分析。更好的替代方法是实时监控进度——这在 ML 调试器中是必不可少的。
有一些工具专门用于在培训期间监控你的 ML 模型的进度。以下是这些工具的列表:
- Neptune . ai——除了广泛的跟踪和监控功能，它还自动跟踪代码的其他方面，并在表格中比较参数和指标。看看这个的例子，运行监控实验，看看这看起来如何像现场直播。
- 权重和偏差–它有助于实时可视化实验，并且非常容易集成。它自动化超参数优化，并有助于探索可能的模型。
- Comet–与之前的工具类似，Comet 旨在允许数据科学家跟踪和管理他们的实验。
- 调试 ML 代码可能需要大量的重写或框架切换
ML 代码大多基于消除底层复杂性的高级框架，这使得模型难以调试。
如何调试 ML 模型，调试用的工具有哪些？
您的调试策略应该考虑三个重要阶段:
- 数据集准备
- 模型结构
- 输出测试
让我们看看这些策略，以及实现它们的工具。
ML 模型的数据中心调试
确保数据集处于良好状态有三大步骤。
1.验证数据质量
数据质量会显著影响模型性能。不平衡或不常见的特征会引入偏差。因为我们在给模型提供数据，所以当模型预测错误时，很容易挑出低质量的数据，而不是猜测它是否存在。
一旦我们了解了导致数据质量下降的问题，我们就可以立即解决它们。建议确保高质量的实验数据，因为如果没有高质量的数据，我们将无法建立一个理想的模型。以下是导致数据质量差的一些因素和解决方法:
\ 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
Fig: Example of imbalanced data
- 重采样数据集:将副本添加到表示不足的类中，或者从表示过度的类中删除数据，可以对数据进行重采样，使其更加平衡。
- 失衡标准化绩效指标:使用失衡标准化的指标，如科恩的 Kappa ，描绘出模型预测准确性的更清晰画面。也可以使用 ROC 曲线。
- 生成合成数据:有一些算法可以用来生成合成数据，而不是从像 SMOTE (合成少数过采样技术)这样的次要类中复制数据。
\ 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
数据集可能包含缺少值的行。以下是应对这些问题的一些方法:
- 如果不影响数据集的大小，删除包含缺失值的行。
- 估算或用平均值或中值替换缺失值。最频繁或任何常数值可用于分类特征，但这可能会在数据中引入偏差。
\ 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
离群值可以定义为其潜在行为不同于其余数据的数据。由于我们的 ML 模型对训练期间输入的所有数据都很敏感，所以这些异常值，不管它们有多小，都会误导我们的训练过程，导致训练时间更长，模型精度更低。人们可以尝试这些方法来识别和去除异常值:
Fig: Three obvious outliers in the dataset presented here
- 可视化:可视化帮助我们了解数据之间的关联程度，并通过设置阈值来移除异常值。这是一个单变量方法，因为我们使用一个变量进行异常值分析。
- 数学函数:像 Z 得分或 IQR 得分这样的函数帮助我们建立数据之间的关系，并从统计上找出异常值。z 得分通过找出数据点与数据集的标准差和均值的关系来描述任何数据点。四分位间距分数是一种统计离差的度量，它具有一个阈值，可用于消除异常值。
- 聚类算法:聚类算法可用于根据数据点的密度对其进行聚类，低密度聚类可被标记为异常值，例如，带有噪声的应用的基于密度的空间聚类( DBSCAN )
2.确保高质量的数据分割
我们必须确保数据在统计上被平均分割用于训练和测试。例如，假设我们正在制作一个猫狗分类器。我们有一个包含 10，000 张图片的数据集，其中每个类别有 5，000 张图片。我们以 8:2 的比例分割数据集，8000 张图像用于训练，2000 张图像用于测试:
- 训练集= 5000 张猫图像+ 3000 张狗图像
- 测试集= 2000 张狗图像
该数据集在统计上并不是平均分割的，所以它会使我们的猫模型输出产生偏差，因为训练集有更多的猫的例子。此外，在测试时，我们不会获得任何关于模型对猫图像的行为的信息。
另一件要记住的事情是选择正确的数据分割比例。一个 8:2 的训练:测试比例被称为****的帕累托原理。比率可能会根据数据变化。有关比率的快速总结，请查看这个堆栈溢出线程。
**
Fig: Example way to split the dataset. [Source]
K 折是拆分数据的另一种方法。使用这种方法，数据如何分割并不重要，事实证明考虑这种方法是一个很好的优势。这里，原始数据被分成 K 个相同大小的折叠，使用随机抽样，没有重复。然后该模型被训练 K 次，每次使用 K-1 个折叠作为训练集，1 个折叠作为测试集。如果我们设置 K = n，那么就变成了留一个的情况！层状 K 型褶皱返回开始形成褶皱。折叠是通过保留每个类别的样本百分比来完成的。
3.测试工程数据
特征是模型所基于的主要输入；它们来源于原始数据，这使得它们不同。手动调试时很难大量分析它们。克服这个问题的一个方法是用单元测试来测试工程特性。单元测试可以被写成测试条件，比如:
- "所有的数字特征都是成比例的."
- "独热编码向量只包含单个 1 和 N-1 个零."
- "缺失的数据由缺省值(平均值)代替."
- "异常值通过缩放或剪裁来处理."
单元数据测试让您更好地理解数据，并支持明智的决策。这也有助于可伸缩性，因为它确保数据保持准确和可靠。
关于单元测试数据的基础知识，请阅读 单元测试数据:它是什么，你是怎么做的？
现在，让我们继续讨论数据验证和/或单元数据测试的工具。它们都是开源的，按字母顺序排列。
Cerberus 通过验证来守卫数据流的大门。它可以用于基本功能，如类型检查，但它也做自定义验证。它没有任何依赖性，所以它是轻量级的，易于实现。它被设计成非阻塞的，因此具有广泛的可扩展性。
Deequ 是一个建立在 Apache Spark 之上的数据质量断言工具。根据您对质量的定义，Deequ 测量批处理或流数据的相关 KPI，然后生成结果报告。它支持的功能有:对数据质量度量随时间变化的数据剖析、异常检测、对大型数据集的自动约束建议，以及使用度量存储库查询计算出的数据度量。
在论文中了解更多 Deequ 的内部工作原理 自动化大规模数据质量验证 。
Fig: Overview of Deequ components. [Source]
Great Expectations 是一个很棒的数据断言库，可以与任何管道工具一起使用。它有四个主要特点。
- 数据测试
- 数据文档–它提供了清晰易读的文档
Fig: Example of documentation done by Great Expectations. [Source]
- 自动化数据分析–它自动生成测试，利用领域专业知识帮助启动数据测试过程
- 可插拔、可扩展、可伸缩–每个组件都是可扩展的，可以针对生产就绪数据验证进行扩展。
您可以使用这个库来消除管道债务，并寄予厚望(双关语)。
Fig: What does Great Expectations do? [Source]
点击这里 找到远大前程的完整文档。你可以在 Slack 上加入他们，问他们任何问题！
4。格里芬
Griffin 是一个数据质量断言工具，它有一个统一的过程来从不同的角度测量数据质量。它旨在支持大型数据集以及流式和批处理模式。它通过三个步骤处理数据质量问题:
- 定义数据质量要求，如完整性、概要、准确性等。
- 基于定义的需求测量数据质量。
- 报告数据质量，因为指标被驱逐到预定义的目的地。
Fig: Architecture of Griffin. [Source]
5。 JSON 模式
使用模式进行单元测试听起来可能很奇怪，但是许多模式库允许您在规范中强制执行数据要求。
查看谷歌对 数据模式 的简要全面解释。
验证数据模式就像验证建筑物的蓝图一样。JSON Schema 是一个强大的工具，它还允许您在 API 层测试数据。
阅读' 理解 JSON 模式 '。
ML 模型的以模型为中心的调试
模型可解释性
你的机器学习模型是一个黑盒，你想知道为什么你的模型做出某些决定？如果你发现它为什么以及如何做决定，你就可以了解问题、数据以及它可能失败的原因。可解释性解释了我们的 ML 模型黑盒的奥秘，并告诉我们为什么他们做出某些决定。
解释错误的预测为修复模型提供了方向。
我们需要可解释模型的两个主要原因是:
- 调试错误–调试的目的是找出错误的原因并解决问题。如果模型不可解释，错误就不能被调试，问题也不能从根本上解决。
- 预测边缘案例–我们已经知道它们是如何构建的。现在，当模型是透明的，我们知道它们是如何做决定的，我们可以根据数据预测所有的结果。这提醒我们注意边缘情况，帮助我们建立一个有效的 ML 模型。
Fig: Different model’s interpretability vs accuracy graph. [Source]
机器学习中的可解释性是一个巨大的话题。我建议阅读 Christoph Molnar 的书' 可解释的机器学习。制作黑盒模型的指南可讲解 ”。他很好地抓住了可解释 ML 的精髓，并给出了很好的例子。这是一本理解主题的好书。
以下是一些模型解释工具:
Alibi 是一个开源库，支持模型检查和解释。它可以让您仔细检查模型在概念漂移和算法偏差方面的性能。它与语言和工具包无关，因此易于集成和使用。
**Captum 是一个基于 Pytorch 的模型可解释性工具。它支持视觉、文本等模型。它有集成梯度，所以它试图根据对模型输出有贡献的特征来解释模型。它可以通过与 PyTorch 模型交互的算法轻松实现。它可以用在生产中经过训练的模型上。
Fig: Sample screenshots of Captum Insights. [Source]
一个开源工具包，用最先进的技术来解释模型行为。它支持玻璃盒模型——易于解释的模型，如线性模型、决策树和现有系统的黑盒解释器。它实现了可解释的助推机器，一个强大的、可解释的玻璃盒子模型，可以像许多黑盒模型一样精确。InterpretML 支持以下技术:
查看他们的论文， InterpretML:机器学习的统一框架可解释性 深入了解它是如何工作的。
Lime 是LocalIinterpretableM模型不可知论者 E 解释的缩写，解释作用于表格或图像的分类器的个体预测。它基于本文中介绍的工作。它可以解释任何有两个或更多类的黑盒分类器。它采用一个 NumPy 数组或原始测试，并给出每个类的概率。
Fig: Explaining a prediction with LIME. [Source]
查看 教程 用随机森林分类器讲解石灰的基本用法。
Shap 做了 Shapley 的基于加法的解释。它基于博弈论的方法来解释任何 ML 模型的输出。SHAP 试图通过计算每个特征对预测的贡献来解释一个实例的预测。SHAP 解释法从联盟博弈论中计算出沙普利值。
DALEX 是描述性机器学习解释工具的缩写，它有助于在更深层次上分析和理解模型是如何工作的。
- DALEX 的关键目标是一个解释者。它在一个预测模型周围创建了一个包装器，然后可以探索这些包装的模型，并与其他局部或全局解释器进行比较。
- DALEX 使用各种技术，如 SHAP 、分解、交互分解来分析和理解模型预测。
- 它使用在其他条件不变的情况下来绘制模型预测的变化，以帮助您了解模型对特征值变化的敏感度。
- 它可以被创建并与 sklearn、keras、lightgbm 等流行的框架集成。
- 它可以与 Neptune 配合使用，为每次训练自动保存和版本化这些讲解器和互动图表。
Fig: How DALEX can be used. [Source]
ML 模型的以预测为中心的调试
最大似然模型预测通常使用诸如均方误差(MSE)、曲线下面积(AUC)等指标来评估。这些度量告诉我们模型的表现如何，但是没有告诉我们为什么模型表现不好。我们知道自己离目标或期望的产出有多近，但不会找出模型失败的地方。因此，可视化调试工具让我们看到了这些指标之外的特性，比如性能比较、数据集上的特性分布等等。
让我们看看一些可视化调试工具:
Manifold 是优步的一个模型无关的可视化调试工具。它通过解释导致模型性能不佳的潜在问题，将模型性能不佳可视化。它揭示了性能较好和较差的数据子集之间的特征分布差异。流形依靠三个关键特征来解释模型输出:
- 性能比较视图
跨不同数据子集可视化模型的总体性能。Manifold 使用聚类算法根据性能相似性将预测数据分成 N 个部分。这有助于您挑选出表现不佳的子集进行检查。
Fig: Example of Performance comparison view in Manifold. [Source]
这显示了由用户定义的段组合在一起的数据的特征值。识别任何可能与不准确的预测输出相关的输入要素分布。您可以区分每个特征中的两个分布。这里的分布表示在性能比较视图中选择的两段式组的数据差异。
Fig: Example of Feature Attribute View in Manifold. [Source]
如果数据集包含地理空间要素，它将与该要素一起显示在地图上。经纬度坐标和 h3 六边形 id 是流形目前支持的特征类型。它通过表示先前选择的两个子集之间的空间分布差异来显示两个段组之间的地理位置差异。
Fig: Manifold architecture. [Source]
**这个用于调试工具的高级平台非常易于使用，并且非常具有可扩展性:
- 它在 Jupyter Notebook 中运行，并显示机器学习训练的实时可视化，让您也可以执行关键分析。
- 它也非常灵活；它让您自定义可视化。
- 它有一个独特的能力叫做懒惰日志模式。这将针对实时 ML 训练过程执行任意查询，并返回该查询的结果，在可视化工具的选项中显示它们。
参见 教程 和 笔记本 深入了解 TensorWatch 的特性。
Efemarai 是一个独特的 Python 工具，用于可视化、检查和调试。除了基本的用法之外，它还可以用来研究可解释性、健壮性等等。让我们来看看它的一些特性:
- 它可以构建大型多维张量的直观 3D 可视化以及自动生成的计算图形。通过让您直观地检查数据，这有助于您密切关注数据。
Fig: Example of multidimensional tensor inspection. [Source]
- 它有一些功能，使你能够毫不费力地检查任何张量或张量元素，没有明确处理(如梯度张量)在几下点击。这样就可以访问代码使用或生成的所有值。
- 所有的断言(由您定义)都是自动监控的，因此您可以快速检测出违反您对数据或代码行为的假设的情况。
- 当张量梯度可用时，它跟踪张量梯度，简化优化过程。
SageMaker 是可伸缩和可扩展的。它的调试效果如何？
- 它实时捕捉训练指标，并帮助您分析和优化您的 ML 模型。
- 它不断跟踪训练过程，因此它可以自动终止训练过程。这减少了训练 ML 模型的时间和成本，提高了效率。
- 它可以实时自动分析和监控系统资源利用率，并在发现预定义的瓶颈时发送警报。
- 它支持广泛的 ML 算法和 DL 框架。
- 它不是开源的，所以如果你正在寻找一个工具来进行实验或开始新的尝试，这并不适合你。如果您想在训练时监控您的模型并执行实时分析，那么这个工具可以很好地完成这项工作。
结论
机器学习系统比传统软件更难测试，因为我们没有明确地编写。我已经向您展示了一些 ML 模型的调试策略，以及实现它们的工具，然后我们开始检查我们的模型并讨论模型的可解释性。我们还研究了模型调试工具，这些工具跟踪从输入到输出的错误路径。
我希望所有这些能帮助您更好地理解 ML 调试。感谢您的阅读！下面是您可以阅读的内容，以了解更多信息:
进一步阅读
论文
博文
会议
视频
书籍******
机器学习中模型评估和选择的最终指南
原文：https://web.archive.org/web/https://neptune.ai/blog/ml-model-evaluation-and-selection
为了正确评估你的机器学习模型并选择最佳模型，你需要为你的问题选择一个好的验证策略和可靠的评估指标。
一个好的验证(评估)策略基本上就是你如何分割你的数据来估计未来的测试性能。它可以像训练测试分割一样简单，也可以是复杂的分层 k 倍策略。
一旦您知道您可以估计未来的模型性能，您需要选择一个适合您的问题的指标。如果你理解了分类和回归度量，那么大多数其他复杂的度量(例如，在对象检测中)就相对容易掌握。
当你搞定那两个人，你就很棒。
在这篇文章中，我将谈论:
- 选择一个好的评估方法(重采样、交叉验证等)
- 流行的(不太为人所知的)分类和回归指标
- 以及机器学习中的偏差/方差权衡。
所以让我们开始吧。
可以使用 neptune.ai. 基于度量、参数、学习曲线、预测图像、数据集版本等来比较实验和模型。
它使得模型评估和选择方式更加容易。
更多信息:
–查看实验对比文档
–了解我们的实验跟踪产品
–查看关于对比实验和模型的视频项目和其他资源
为了确保我们在同一页上，让我们把定义放在一边。
什么是模型评估？
模型评估是在选定的评估设置上评估模型性能的过程。这是通过计算量化性能指标(如 F1 分数或 RMSE)或由主题专家定性评估结果来完成的。您选择的机器学习评估指标应该反映您希望使用机器学习解决方案优化的业务指标。
什么是选型？
模型选择是为给定任务选择最佳 ml 模型的过程。这是通过在根据设计的评估方案计算的所选评估指标上比较各种候选模型来完成的。选择正确的评估模式，无论是简单的训练测试分割还是复杂的交叉验证策略，都是构建任何机器学习解决方案的至关重要的第一步****。
**## 如何评价机器学习模型，选出最好的？
我们将深入探讨这个问题，但让我一步一步地告诉你:
第一步:选择合适的验证策略。不能强调这一点，没有一个可靠的方法来验证您的模型性能，再多的超参数调整和最先进的模型也不会帮助您。
第二步:选择正确的评估指标。找出你的模型背后的商业案例，并尝试使用与此相关的机器学习指标。通常情况下，没有一个度量标准适合这个问题。
因此，计算多个指标，并在此基础上做出决策。有时，您需要将经典的 ML 指标与主题专家评估结合起来。这没关系。
第三步:记录你的实验结果。无论你使用电子表格还是专用的实验跟踪器，确保记录所有重要的指标、学习曲线、数据集版本和配置。你以后会感谢自己的。
第四步:对比实验，选出一个赢家。不管您选择什么样的指标和验证策略，最终，您都希望找到最好的模型。但是没有一个模型是真正最好的，但是有些已经足够好了。
因此，确保了解什么对您的问题足够好，一旦您达到了这一点，就转移到项目的其他部分，如模型部署或管道编排。
机器学习中的模型选择(选择模型验证策略)
重采样方法
顾名思义，重采样方法是重新排列数据样本的简单技术，用于检查模型在未经训练的数据样本上是否表现良好。换句话说，重采样有助于我们理解模型是否能很好地概括。
随机分裂
随机拆分用于将一定百分比的数据随机抽样到训练集、测试集中，最好是验证集中。这种方法的优点是原始群体很有可能在所有三个集合中得到很好的代表。用更正式的术语来说，随机分裂将防止数据的有偏抽样。
在模型选择中注意验证集的使用是非常重要的。验证集是第二个测试集，有人可能会问，为什么有两个测试集？
在特征选择和模型调整过程中，测试集用于模型评估。这意味着选择模型参数和特征集，使得它们在测试集上给出最佳结果。因此，具有完全看不见的数据点(在调整和特征选择模块中没有使用)的验证集被用于最终评估。
基于时间的分割
有种类型的数据不可能随机分割。例如，如果我们必须为天气预报训练一个模型，我们不能将数据随机分为训练集和测试集。这将打乱季节模式！这种数据通常被称为时间序列。
在这种情况下，使用时间分割。训练集可以包含最近三年和今年 10 个月的数据。最后两个月可以留给测试或验证集。
还有一个 窗口 集合的概念——其中模型被训练到一个特定的日期，并在未来的日期被反复测试，使得训练窗口保持增加一天的偏移(因此，测试集合也减少一天)。这种方法的优点是，当测试集非常小(比如 3 到 7 天)时，它可以稳定模型并防止过度拟合。
但是，时序数据的缺点是事件或数据点不是 相互独立的 。一个事件可能会影响随后的每个数据输入。
例如，执政党的更迭可能会极大地改变未来几年的人口统计数据。或者臭名昭著的冠状病毒疫情将对未来几年的经济数据产生巨大影响。
在这种情况下，没有机器学习模型可以从过去的数据中学习，因为事件前后的数据点有很大的差异。
k 倍交叉验证
交叉验证技术的工作原理是随机改组数据集，然后将其分成 k 组。此后，在对每个组进行迭代时，该组需要被认为是一个测试集，而所有其他组一起加入训练集。在测试组上测试该模型，并且对 k 个组继续该过程。
因此，在该过程结束时，在 k 个不同的测试组上有 k 个不同的结果。然后，通过选择具有最高分数的模型，可以容易地选择最佳模型。
分层 K 折叠
分层 k-fold 的过程类似于 k-fold 交叉验证的过程，只有一个单点差异–与 K-Fold 交叉验证不同，分层 K-Fold 会考虑目标变量的值。
例如，如果目标变量是具有两个类别的分类变量，那么分层 k-fold 确保当与训练集比较时，每个测试 fold 获得两个类别的相等比率。
这使得模型评估更准确，模型训练更少偏差。
引导程序
Bootstrap 是获得稳定模型的最有效的方法之一。它接近于随机分裂技术，因为它遵循随机采样的概念。
第一步是选择样本大小(通常等于原始数据集的大小)。此后，必须从原始数据集中随机选择一个样本数据点，并将其添加到引导样本中。添加后，需要将样品放回原始样品中。这个过程需要重复 N 次，其中 N 是样本大小。
因此，它是一种重采样技术，通过用替换的 从原始数据集 中采样数据点来创建引导样本。这意味着引导示例可以包含同一数据点的多个实例。
该模型在引导样本上进行训练，然后在所有那些没有进入引导样本的数据点上进行评估。这些样品被称为样品。
*比较和评估交叉验证的结果可能会变得棘手。
医疗保健初创公司 Theta Tech AI 为此使用了海王星实验跟踪器。
“通过验证集进行分组对我们来说非常重要，许多其他人也将受益于验证分组功能。”–罗伯特·托特博士 西塔科技人工智能创始人
更多信息:
概率测度
概率度量不仅考虑模型性能，还考虑模型复杂性。模型复杂性是对模型捕捉数据中的差异的能力的度量。
例如，像线性回归算法这样的高偏差模型不太复杂，而另一方面，神经网络的复杂性非常高。
这里需要注意的另一个要点是，在概率度量中考虑的模型性能是仅根据训练集计算的。通常不需要保持测试组。
然而，一个相当大的缺点在于，概率测量没有考虑模型的不确定性，并且有可能选择较简单的模型而不是复杂的模型。
赤池信息标准(AIC)
众所周知，每个模型都不完全准确。总是存在一些信息损失，这可以使用 KL 信息度量来测量。Kulback-Liebler 或 KL 散度是两个变量的概率分布差异的度量。
统计学家 Hirotugu Akaike 考虑了 KL 信息和最大似然(在最大似然中，在给定参数和指定概率分布的情况下，希望最大化观察数据点 X 的条件概率)之间的关系，并发展了信息标准(或 IC)的概念。因此，赤池的 IC 或 AIC 是信息损失的度量。这就是如何捕获两个不同模型之间的差异，并建议选择信息损失最少的模型。
K =独立变量或预测值的数量
L =模型的最大似然
- N =训练集中数据点的数量(在小数据集的情况下尤其有用)
- AIC 的局限性在于它不太擅长概化模型，因为它倾向于选择丢失较少训练信息的复杂模型。
- 贝叶斯信息准则(BIC)
BIC 源自贝叶斯概率概念，适用于在最大似然估计下训练的模型。
K =独立变量的数量
L =最大似然
- N =训练集中样本/数据点的数量
- BIC 因模型的复杂性而对其不利，当数据集的大小不是很小时，最好使用它(否则它倾向于停留在非常简单的模型上)。
- 最小描述长度(MDL)
MDL 来源于信息论，信息论处理熵之类的量，这些量测量用概率分布或随机变量表示事件所需的平均位数。
MDL 或最小描述长度是表示模型所需的最小位数。
d =模型
D =模型做出的预测
- L(h) =表示模型所需的位数
- L(D | h) =表示模型预测所需的位数
- 结构风险最小化(SRM)
- 机器学习模型面临着从一组有限的数据中定义一个通用理论的不可避免的问题。这导致过度拟合的情况，其中模型偏向于作为其主要学习源的训练数据。SRM 试图平衡模型的复杂性和数据拟合的成功性。
如何评估 ML 模型(选择性能指标)
可以使用多种指标来评估模型。然而，评估指标的正确选择是至关重要的，并且通常取决于正在解决的问题。对各种度量标准的清楚理解可以帮助评估者找到问题陈述和度量标准的适当匹配。
分类指标
对于每个分类模型预测，可以构建一个称为 混淆矩阵 的矩阵，其展示了正确和错误分类的测试用例的数量。
大概是这样的(考虑到 1-正和 0-负是目标类):
TN:正确分类的阴性病例数
TP:正确分类的阳性病例数
- FN:被错误归类为阴性的阳性病例数
- FP:正确归类为阳性的阴性病例数
- 准确(性)
- 准确性是最简单的度量，可以定义为正确分类的测试用例的数量除以测试用例的总数。
它可以应用于大多数一般问题，但在涉及不平衡数据集时不是很有用。
例如，如果我们在银行数据中检测欺诈，欺诈与非欺诈案例的比例可能是 1:99。在这种情况下，如果使用准确性，通过预测所有测试案例为非欺诈，该模型将证明是 99%准确的。99%准确的模型将完全无用。
如果一个模型训练很差，以至于它预测所有 1000 个数据点为非欺诈，那么它将错过 10 个数据点。如果测量准确性，它将显示该模型正确预测了 990 个数据点，因此，它的准确性为(990/1000)*100 = 99%！
这就是为什么准确性是模型健康的虚假指标。
因此，对于这种情况，需要一个指标来关注模型完全遗漏的十个欺诈数据点。
精确
精度是用于识别分类正确性的度量。
直观上，这个等式是正确的肯定分类与预测的肯定分类总数的比率。分数越大，精度越高，这意味着模型正确分类正类的能力越强。
在预测性维护的问题中(必须提前预测机器何时需要维修)，精确度发挥了作用。维护成本通常很高，因此，不正确的预测会给公司带来损失。在这种情况下，模型正确分类阳性类别和降低假阳性数量的能力至关重要！
回忆
回忆告诉我们在阳性病例总数中正确识别的阳性病例数。
回到欺诈问题，召回值在欺诈案例中非常有用，因为高召回值将表明在欺诈总数中识别出大量欺诈案例。
F1 分数
F1 分数是召回率和准确率的调和平均值，因此平衡了两者的优势。
这在召回率和精确度都很重要的情况下很有用——比如识别可能需要修理的飞机部件。在这种情况下，需要精确以节省公司成本(因为飞机零件极其昂贵),需要召回以确保机器稳定且不会对人类生命构成威胁。
AUC-ROC
ROC 曲线是真阳性率(回忆)对假阳性率 (TN / (TN+FP))的曲线图。AUC-ROC 代表受试者操作特征下的面积，面积越大，模型性能越好。
如果曲线在 50%对角线附近，则表明模型随机预测了输出变量。
原木损失
对数损失是一个非常有效的分类指标，相当于-1*对数(似然函数)，其中似然函数表明模型认为观察到的结果集的可能性有多大。
由于似然函数提供了非常小的值，因此解释它们的更好方法是将这些值转换为对数，并添加负值以颠倒度量的顺序，这样较低的损失分数表明模型更好。
增益和提升图表
增益和提升图是评估模型性能的工具，就像混淆矩阵一样，但有细微而显著的区别。混淆矩阵决定了模型在整个群体或整个测试集上的性能，而增益和提升图评估模型在部分群体上的性能。因此，我们对每%的人口(x 轴)都有一个分数(y 轴)。
提升图衡量模型与随机预测相比带来的改进。这种改进被称为“提升”。
k 线图
K-S 图或 Kolmogorov-Smirnov 图确定了两种分布之间的分离程度——正类分布和负类分布。差异越大，模型就越能更好地区分正面和负面案例。
回归度量
回归模型提供了一个连续的输出变量，不同于具有离散输出变量的分类模型。因此，用于评估回归模型的度量被相应地设计。
均方差或 MSE
MSE 是一个简单的指标，它计算实际值和预测值之间的差异(误差)，将其平方，然后提供所有误差的平均值。
MSE 对异常值非常敏感，即使在拟合良好的模型预测中存在一些异常值，MSE 也会显示出非常高的误差值。
均方根误差或 RMSE
RMSE 是 MSE 的根源，并且是有益的，因为它有助于降低更接近实际值的误差范围，使其更易于解释。
记录比每次模型训练运行所需更多的指标通常是一个好主意。
但是你必须把它们形象化并进行比较。这就是用于实验跟踪的工具的用处。
您可以使用 neptune.ai. 在一个地方可视化、组织和比较您的所有模型指标。
更多信息:
–看 2 分钟产品走一遍
–看实验对比文档
–了解我们的实验跟踪产品
–查看关于对比实验和模型的视频项目和其他资源
平均绝对误差
MAE 是绝对误差值(实际值–预测值)的平均值。
如果想在一定程度上忽略异常值，可以选择 MAE，因为它通过去除平方项显著降低了异常值的损失。
均方根对数误差
在 RMSLE 中，遵循与 RMSE 方程相同的方程，除了增加了对数函数以及实际值和预测值。
x 是实际值，y 是预测值。这有助于通过对数函数淡化较高的错误率来缩小离群值的影响。此外，RMSLE 通过使用日志帮助捕获相对 误差(通过比较所有误差值)。
r 平方
R-Square 有助于确定目标变量的方差比例，该比例可在独立变量或预测值的帮助下获得。
然而，R-square 有一个巨大的问题。比方说，一个新的不相关特征被添加到一个分配了权重 w 的模型中。如果模型发现新的预测值和目标变量之间绝对没有相关性，则 w 为 0。然而，由于随机性，几乎总是存在小的相关性，这增加了小的正权重(w > 0 ),并且由于过拟合，实现了新的最小损失。
这就是为什么 R 平方随着任何新特性的增加而增加。因此，它的无法在添加新功能时降低价值限制了它识别模型是否在功能较少的情况下做得更好的能力。
调整后的 R 平方
调整的 R-Square 解决了 R-Square 的问题，因为它无法通过添加功能来降低值。随着更多功能的加入，分数会降低。
这里的分母是魔术元素，它随着特性数量的增加而增加。因此，需要显著增加 R ² 来增加整体值。
聚类度量
聚类算法预测数据点组，因此基于距离的度量是最有效的。
邓恩指数
邓恩指数侧重于识别具有低方差(在集群的所有成员中)并且紧凑的集群。不同聚类的平均值也需要相距很远。
δ(Xi，Yj)是簇间距离，即 Xi 和 Xj 之间的距离
∈( Xk)是聚类 Xk 的聚类间距离，即聚类 Xk 内的距离
- 然而，邓恩指数的缺点是随着更高的聚类数和更多的维度，计算成本增加。
- 轮廓系数
轮廓系数在-1 到+1 的范围内追踪一个聚类中的每个点与其他聚类中的每个点的接近程度。：
较高的轮廓值(接近+1)表示来自两个不同聚类的采样点距离较远。
0 表示这些点接近决策边界
- 并且接近-1 的值表明这些点被错误地分配给该聚类。
- 肘法
- 肘形法用于确定数据集中的聚类数，方法是将 x 轴上的聚类数与 y 轴上的方差百分比相对照。x 轴上曲线突然弯曲的点(肘部)被认为是建议最佳聚类数的点。
ml 模型选择中的权衡
偏差与方差
在高层次上，机器学习是统计和计算的结合。机器学习的关键围绕着算法或模型的概念，事实上，它们是类固醇的统计估计。
然而，根据数据分布的不同，任何给定的模型都有一些限制。它们中没有一个是完全准确的，因为它们只是 (即使使用类固醇) 。这些限制俗称 偏差 和 方差 。
具有高偏差的模型会由于不太注意训练点而过于简化(例如:在线性回归中，不管数据分布如何，模型将总是假设线性关系)。
当一个模型被假设严格控制时，就会出现偏差——就像线性回归模型假设输出变量和独立变量之间的关系是一条直线。当实际值与独立变量非线性相关时，这导致 欠拟合 。
具有高方差的模型将通过不对其之前未见过的测试点进行概括来将其自身限制于训练数据(例如:随机森林，其中 max_depth = None)。
当一个模型过于关注训练集并且非常接近地学习变化时，方差很高，从而影响了泛化能力。这就导致 过拟合 。
当限制很微妙时，问题就出现了，比如当我们必须在随机森林算法和梯度推进算法之间进行选择，或者在同一决策树算法的两个变体之间进行选择。两者都趋向于具有高方差和低偏差。
最佳模型是具有最低偏差和方差的模型，因为这两个属性是间接成比例的，所以实现这一点的唯一方法是在两者之间进行权衡。因此，模型选择应该使偏差和方差交叉，如下图所示。
这可以通过迭代地调整使用中的模型的 超参数 来实现(超参数是馈入模型函数的输入参数)。在每次迭代之后，必须使用合适的度量标准进行模型评估。
学习曲线
Soure: Analytics Vidhya
跟踪模型训练或构建进度的最佳方式是使用学习曲线。这些曲线有助于识别一组超参数组合中的最佳点，并在模型选择和模型评估过程中提供大量帮助。
通常，学习曲线是一种在 y 轴上跟踪模型性能的学习或改进，在 x 轴上跟踪时间或经验的方法。
两个最受欢迎的学习曲线是:
培训学习曲线–它有效地绘制了培训过程中的评估指标分数，从而有助于跟踪模型在培训过程中的学习或进度。
验证学习曲线–在该曲线中，评估指标分数相对于验证集的时间绘制。
- 有时可能会发生这样的情况，训练曲线显示出改进，但是验证曲线显示出性能下降。
- 这表明模型过度拟合，需要恢复到之前的迭代。换句话说，验证学习曲线确定了模型的泛化能力。
因此，在训练学习曲线和验证学习曲线之间有一个折衷，并且模型选择技术必须依赖于两条曲线相交并且处于最低点的点。
好吧，但是你实际上是怎么做的呢？
下一步是什么
评估 ML 模型并选择性能最佳的模型是制作前的主要工作之一。
希望通过这篇文章，您已经学会了如何正确地建立模型验证策略，以及如何为您的问题选择度量标准。
你已经准备好进行一系列的实验，看看什么有效。
随之而来的另一个问题是跟踪实验参数、使用的数据集、配置和结果。
弄清楚如何可视化和比较所有这些模型和结果。
为此，您可能想看看:
其他资源
Kaggle 竞赛的交叉验证和评估策略:
评估指标和可视化:
Cross-validation and evaluation strategies from Kaggle competitions:
实验跟踪视频和真实案例研究:
Evaluation metrics and visualization:
Experiment tracking videos and real-world case studies:***
ML 模型解释工具:什么，为什么，以及如何解释
原文：https://web.archive.org/web/https://neptune.ai/blog/ml-model-interpretation-tools
解释字面意思是解释或展示自己对某事的理解。
当您创建一个 ML 模型时，它只不过是一个可以学习模式的算法，对于其他项目涉众来说，它可能感觉像一个黑盒。有时甚至对你。
这就是为什么我们有模型解释工具。
什么是模型解释？
一般来说，ML 模型必须获得预测，并使用这些预测和最终的见解来解决一系列问题。我们已经可以问几个后续问题了:
- 这些预测有多可信？
- 他们是否足够可靠，可以做出重大决策？
模型解释将你的注意力从‘结论是什么？’“为什么会得出这个结论？”。您可以了解模型的决策过程，即究竟是什么驱动模型对数据点进行正确或错误的分类。
为什么模型解释很重要？
考虑一个哈士奇与狼(狗品种)分类器的例子，其中一些哈士奇被错误地分类为狼。使用可解释的机器学习，您可能会发现这些错误分类主要是因为图像中的雪而发生的，分类器将雪用作预测狼的特征。
这是一个简单的例子，但是您已经可以看到为什么模型解释是重要的了。它至少在几个方面有助于您的模型:
- 公平——公司用来决定加薪和晋升的一个可解释的模型可以告诉你为什么某个人得到或没有得到晋升。
- 可靠性–输入的微小变化不会导致多米诺骨牌效应，也不会大幅改变输出。
- 因果关系–只有因果关系对决策有用。
- 信任——对于所有的项目涉众来说，尤其是在非技术方面，更容易信任一个可以用外行的术语解释的模型。
如何解读一个 ML 模型？
机器学习模型的复杂程度和性能各不相同。一种尺寸并不适合所有人。于是，就有了不同的解读方式。这些方法主要可分为以下几类:
- 特定型号/不特定型号
- 特定于模型的方法是特定于某些模型的，它们依赖于模型的内部机制来做出某些结论。这些方法可能包括解释广义线性模型(GLMs)中的系数权重，或神经网络中的权重和偏差。
- 模型无关的方法可以用在任何模型上。它们通常在培训后使用。它们通常通过分析要素输入-输出对之间的关系来工作，并且无法访问模型的内部机制，如权重或假设。
- 局部/全局范围
- 局部范围仅涵盖单个预测，仅捕获指定预测背后的原因。
- 全局范围超越了单个数据点，涵盖了模型的一般行为。
让我们创建一个模型来解释。我们将对模型创建步骤做一个简短的演练，然后我们将关注不同的与模型无关的工具和框架来解释创建的模型，而不是解决实际的问题。
模型创建
1.加载数据集
数据集架构:
属性
| 描述 | |
|---|---|
社交媒体帖子类型
| 社交媒体帖子的类型 |
|
社交媒体帖子的领域
| 社交媒体帖子的领域 |
| | |
| | |
| | |
| | |
| | |
|
帖子的实际文字对话
| 帖子的实际文本对话 |
患者标签
(1 =患者，0 =非患者)
| 2.执行探索性数据分析和数据预处理 | 填充空值。 |
|---|
删除冗余特征，如时间(GMT)。
通过删除所有字母数字字符来清理文本数据。
- 编码分类值属性的标签
- 处理某些属性中出现的错误值
- 基于文本的特征的词汇化和 Tf-Idf 矢量化。
- 3.特征工程
- 将所有文本特征组合成单个文本特征以弥补缺失值。
- 将数据映射到工作日。
将时间映射到小时。
- 基于对话文本的长度创建另一个特征。
- 4.最终培训和测试数据集
- 可以看出，tf-idf 矢量化以及特征工程导致了训练和测试数据集中属性数量的增加。
- 5.训练分类器
虽然一系列模型可以用于这项任务，但我们将使用随机森林分类器，它不容易解释，因为它很复杂。我们希望使用一些工具和框架来使它变得可解释。
6.获取测试数据集的预测
7.模型性能评估
由于我们没有来自测试数据集的正确标签，让我们通过训练分类报告和 K 倍交叉验证分数来看看我们的模型是如何执行的。
From sklearn.ensemble import RandomForestClassifier
rfc = RandomForestClassifier()
rfc.fit(train_X,y)
培训分类报告:
testpred = rfc.predict(test_X)
k 倍交叉验证分数:
既然我们已经建立了一个模型，是时候开始使用解释工具来解释我们模型的预测了。我们将从最流行的工具之一 ELI5 开始。
1.ELI5
ELI5 是“像我 5 岁一样解释”的首字母缩写。这是一个很受欢迎的 Python 库，因为它很容易使用。它主要用于:
了解在预测中起关键作用的重要特征。
来分析某个特定的个人预测，看看到底是什么导致了这个模型的预测。
ELI5 更多地以局部/全局范围的方式解释模型，而不是我们上面讨论的特定/不可知的方式。
- 此外，目前 ELI5 只能用于几个主要的模型 Sklearn 广义线性模型(GLMs)和基于树的模型，Keras 模型，LightGBM，XGBoost，CatBoost。
- 如何安装 Eli5
可以使用 pip 命令安装 Eli5。
或者，可以用 conda 命令安装。
在我们的模型上使用 Eli5
让我们首先导入所需的依赖项
pip install eli5
答:特征权重和重要性
conda install -c conda-forge eli5
让我们从一个标准的函数调用开始。
这是从另一端出来的。
Import eli5
“权重”列包含“特征”列中显示的相关特征的权重。现在你可能会想，如果特征是数字，你怎么理解任何东西？这些见解很难解释。为了解决这个问题，我们需要对我们的原始函数调用进行一些修改。
这里，我们使用 vect(Tf-Idf 矢量器)和包含工程特性的可变列来获取特性名称。然后，特性名称作为* *参数传递给同一个函数。这是我们现在得到的。
eli5.show_weights(rfc)
因为我们有 5000 个 Tf-Idf 特性，所以看到很多词被赋予高度重要性是有意义的。除了单词之外，还有一个特征“text_num_words”，它是在特征工程之后获得的。它被列为第 12 个最重要的功能。这可能是一个迭代的过程，你可以看到工程属性的活力，如果需要，重新设计它们。
我们还可以:
columns = ['Source','weekday','hour','text_num_words']
feature_names = list(vect.get_feature_names()) + columns
eli5.show_weights(rfc, feature_names = feature_names)
使用“Top”参数指定我们是需要所有功能还是只需要前“n”个功能。
使用 features_re 和 features_filter 参数只获取那些符合我们的条件和约束的功能。
现在我们来看看 Eli5 的另一个用例。
- B: 个体预测分析
- 孤立地分析某些预测可能非常有价值。你可以用通俗易懂的语言向所有利益相关者解释所获得的预测背后的数学机制。
先查一个真阳性的案例。
这是导致模型预测该数据点属于患者的原因。
因此，模型推断这个数据点属于一个病人，因为有类似'增大的心脏'、医院心脏'、眩晕'、癌症等特征..有道理。
现在让我们来看一个真否定的例子。
eli5.show_prediction(rfc,train_X.toarray()[1],
feature_names=feature_names, top=20, show_feature_values=True)
与第一张图片相比，我们可以清楚地看到
健康/医疗条件太差了。即使像“已诊断”、“充血性心脏”这样的几个特征进入了前几名，它们的相关贡献和价值也是零。
让我们转向另一个令人兴奋的工具。
2.石灰
LIME 代表LocalIinterpretableMmodel-agnosticEexplanations。让我们更深入地了解一下这个名字:
术语“局部”意味着对单个预测的分析。LIME 让我们对某个预测背后发生的事情有了更深入的了解。
它是模型不可知的，这意味着它将每个模型都视为一个黑盒，因此它可以在不访问模型内部的情况下进行解释，从而允许它与广泛的模型一起工作。
正如名字一样直观，其解释逻辑背后的思想也一样直观:
- LIME 主要测试一旦模型在输入数据中出现某些变化时，预测会发生什么情况。
- 为了测试这一点，LIME 在一个新的数据集上训练了一个可解释的模型，该数据集由扰动的样本和黑盒模型的相应预测组成。
这个新的学习模型需要是一个好的局部近似(对于某个个体预测)，但不必是一个好的全局近似。它在数学上可以表示为:
- 解释模型，例如 x，是由 LIME 创建的可解释模型 g，其最小化损失函数 L，损失函数 L 测量解释与原始模型 f 的预测有多接近，同时模型复杂度ω(g)保持较低(较少特征)。g 是一族可能的解释，即所有的 glm。
- 石灰怎么装？
- 像 ELI5 一样，它也可以用一个简单的 pip 命令安装。
或者使用 conda 命令。
在我们的模型上使用石灰
LIME 主要提供三种解释方法，这三种方法处理不同类型的数据:
pip install lime
表格解释，
conda install -c conda-forge lime
文字解读，
图像解读。
- 在我们的 5004 个可训练属性中，有 5000 个是基于 Tf-Idf 的特性，而这些特性除了单词什么也不是。s，我们就用莱姆的文本解读法。为此，我们必须对我们的训练做一些改变。
- 如你所见，我们现在只使用矢量化的文本特征进行建模。
- 正如我们所知，LIME 准备了一个新的数据集，并在此基础上训练自己的可解释模型。但是对于文本数据，LIME 是如何做到的呢？这是怎么回事:
通过切换原始文本中随机选择的单词的存在/不存在来创建新文本。
rfc.fit(vectorized_train_text,y)
如果包含相应的单词，则特征为 1，如果移除，则特征为 0，从而使其成为二进制表示。
理论部分讲够了，让我们来看看石灰的作用。
- 导入所需的依赖项:
- 进行所需的函数调用:
首先，我们创建一个文本解释器的实例。然后，因为我们正在处理文本特征，所以我们使用 sklearn 的管道方法将我们的矢量器(vect)与我们的模型(rfc)相结合，以便文本特征(将获得输入)可以被矢量化，并且预测可以发生。
就像 ELI5 一样，让我们先检查一个真正的正实例。
Import lime
From sklearn.pipeline import make_pipeline
让我们画出实例结果，看看我们会得到什么。
explainer = lime.lime_text.LimeTextExplainer(
class_names=[‘Not Patient’, ‘Patient’])
pl = make_pipeline(vect,rfc)
在阅读文本时，它变得非常清楚，它是在谈论一些在急需的心脏移植后挽救了生命的病人，同时感谢医务人员。我们可以看到突出显示的单词出现在“患者”列中，因此负责将该数据点正确分类为“患者”。
现在让我们看看一个真正的负实例的解释图是什么样子的。
exp = explainer.explain_instance(
train[‘combined_text’][689], pl.predict_proba)
第一眼看到突出显示的关键词，如“冷”、“脂肪”、“烧伤”等。，该数据点看起来与“患者”类别相关联。在实际阅读时，我们理解文本是在谈论洗冷水澡的好处，显然，我们的模型也理解这一点。
exp.show_in_notebook()
到目前为止一切顺利。但是如果我们的特征是表格格式的连续值，或者是图像的像素值呢？
为此，我们只需要记住我们上面讨论的内容:
数据类型
功能
正文
| lime.lime_text。LimeTextExplainer() | 表格 |
|---|---|
| lime . lime _ tabular . limetable plainer() | 图像 |
| lime . lime _ image . lime image explainer() | |
| 好了，让我们进入下一个模型解释工具——SHAP。 | 3.SHAP |
SHapleyAadditive exP解释是一种解释任何机器学习模型输出的博弈论方法。 SHAP 通过计算每个特征对预测的贡献来解释一个实例的预测。它使用 Shapley 值。
什么是沙普利值？
沙普利值——一种来自联盟博弈论的方法——告诉我们如何在特性之间分配“支出”。
因此，可以通过假设实例的每个特征值是游戏中的“玩家”来解释预测，其中预测是支出。
【Shapely 值是怎么计算出来的？
- Shapely 值是所有可能组合中某个特征值的平均边际贡献。
- 假设我们有一个形状为 N x M 的数据集，其中 N 是样本数，M 是特征数，例如 5–A、B、C、D & E。
e 是具有连续值的从属属性，而 A，B，C，D 是我们的分类值预测值。
- 现在，假设我们要计算特征 A 的贡献，即计算它的 Shapely 值。
- 我们通过从数据集中随机选取一个实例并使用其特性 d 的值来模拟只有 A、B 和 C 在一个联盟中，然后我们预测这个组合的 E，假设它是 x。
- 现在我们用从 A 的域中随机抽取的值替换这个组合中的特征 A 的值(假设它是不同的),并再次预测 E，假设这次它是 Y。
- X-Y 之间的差异，无论是正的还是负的，都是特征 A 在预测中的贡献。
- 对 A 值的这个采样步骤被反复重复，并且贡献被平均以获得 A 的 Shapely 值。
- SHAP 的解释可以用数学方法表达为:
- 其中 g 是解释模型，z′ϵ{0,1}^m是联合向量，m 是最大联合大小，而 [j] ϵ R 是特征 j 的匀称值
- 理论到此为止，让我们看看 SHAP 在我们的模型上表现如何。
如何安装 SHAP
就像其他库一样，可以用 pip 命令安装，只要确保 pip 版本在 19.0 以上即可。
如果你在使用 pip 时遇到任何错误，你总是可以使用 conda 进行安装。
在我们的模型上使用 SHAP
导入所需的依赖项:
pip install shape
根据您的型号，您可以使用 SHAP 提供的不同解释器。因为我们正在处理一个随机的森林分类器，我们将使用 SHAP 的树解释器。
conda install -c conda-forge shap
让我们为我们的特征计算 shap 值。请记住，由于我们的大多数特性都是基于文本的，我们将利用它们来理解我们的模型，就像我们对 LIME 所做的那样。
shap_values 是一个包含 2 个数组作为元素的列表，对应于我们数据集中的 2 个类。所以，我们可以从这两个类的角度来解释这个预测。
Import shap
按照我们的方法，让我们首先从解释一个真实的正例开始。为了展示一致性，我们将检查与 LIME 相同的数据点。
explainer = shap.TreeExplainer(rfc)
情节是这样的:
shap_values =
explainer.shap_values(vectorized_train_text.toarray(),check_additivity=False)
现在，代码中的索引，以及情节本身，似乎有点令人不知所措。让我们一步一步地分解它。
与“患者”类相关的值出现在 expected_value 和 shap_values 的第一个索引处，因此该图是从“患者”类的角度绘制的。
shap.initjs()
shap.force_plot(explainer.expected_value[1], shap_values = shap_values[1][689], features = vectorized_train_text.toarray()[0:][689], feature_names = vect.get_feature_names())
关于剧情:
所有特征值的预测得分为 0.74，以粗体显示。
基值= 0.206 是训练模型的所有输出值的平均值。
显示为粉红色(红色)的特征值会影响对类别 1(患者)的预测，而显示为蓝色的特征值会将结果拉向类别 0(非患者)。
- 彩色块的大小表示特征重要性的大小。
- 由于我们的预测得分(0.74)>基础值(0.206)，该数据点已被积极分类，即类别=患者。
- 如果我们从另一个类的角度来看这个实例，会发生什么？
- 我们很容易理解这里发生了什么:
- 我们将 expected_value 和 shap_values 的索引从 1 切换到 0，因为我们希望视角从“患者”反转到“非患者”。
因此，所有出现在粉红色(红色)中的特征已经切换到蓝色，并且现在对“非患者”类别的预测产生负面影响。
shap.initjs()
shap.force_plot(explainer.expected_value[1], shap_values = shap_values[1][689], features = vectorized_train_text.toarray()[0:][689], feature_names = vect.get_feature_names())
尽管预测得分(0.27)
- 现在让我们检查真正的否定实例。
- 剧情出来是这样的。
- 由于预测分数小于基础值，因此被归类为“没有耐心”。
除了局部解释，SHAP 还可以通过全局解释来解释模型的一般行为。
shap.initjs()
shap.force_plot(explainer.expected_value[1], shap_values = shap_values[1][120], features = vectorized_train_text.toarray()[0:][120], feature_names = vect.get_feature_names())
从代码中可以明显看出，我们是从“患者”类别的角度绘制的，我们可以看到“充血性心脏”、“充血性心力衰竭”和“麻烦”等特征向红色光谱延伸，因此对“患者”类别起着必不可少的作用。
一开始，SHAP 提供的一系列功能可能会让你有些不知所措，但是一旦你掌握了它，没有什么比这更直观的了。
我们将查看另一个解释库，MLXTEND。
shap.summary_plot(shap_values = shap_values[1], features = vectorized_train_text.toarray(), feature_names = vect.get_feature_names())
4.MLXTEND
MLxtend 或机器学习扩展是一个用于日常数据科学和机器学习任务的有用工具库。它提供了广泛的功能。
到目前为止，我们只分析了文本特征，其他特征仍然是局外人。这一次，让我们使用 MLXTEND 来看看其余的特性。
如何安装 MLXTEND
它可以用一个简单的 pip 命令安装。
或者，您可以从https://pypi.python.org/pypi/mlxtend手动下载这个包，解压缩它，导航到这个包，并使用命令:
在我们的模型上使用 MLXTEND
导入所需的依赖项:
pip install mlxtend
MLXTEND 提供不同的功能，例如:
python setup.py install
1。PCA 相关圆
一种有趣的观察结果的方式是通过主成分分析。
Import mlxtend
MLXTEND 允许您使用 plot_pca_correlation_graph 函数绘制 PCA 相关圆。
我们基本上计算我们的特征和主成分之间的相关性。
- 然后这些相关性被绘制成单位圆上的向量，其轴是主分量。
- 特定的主成分可以作为元组传递给 dimensions 函数参数。
- 相关圆轴显示了相应主成分解释的方差百分比。
- 让我们为剩下的特征画出这个相关圆，看看我们会得到什么。
- 第一主成分解释了总方差的 31.7%，而第二主成分解释了 25.8%
- Text_num_words & Source 更符合第一台电脑，而 hour 和 weekday 更符合第二台电脑。
2。偏差-方差分解
from mlxtend.plotting import plot_pca_correlation_graph
from sklearn.preprocessing import StandardScaler
X = StandardScaler().fit_transform(train[['text_num_words', 'weekday','hour','Source']].values)
fig, corr_matrix = plot_pca_correlation_graph(
X,
['text_num_words', 'weekday','hour','Source'],
dimensions=(1, 2),
figure_axis_size=6
)
- 大家都知道偏差-方差权衡，这个问题困扰着所有的机器学习项目。
- 通常目标是在两者之间找到一个最佳点，通过保持低偏差来避免欠拟合，通过保持低方差来避免过拟合。
很难获得任何预测模型的偏差-方差分数，但 MLXTEND 可以将模型的泛化误差分解为偏差、方差和误差分数。
- 让我们尝试为我们的随机森林分类器计算这个分数。
- 为了进行这种计算，必须将我们的数据集分成训练和测试。
- 这就是结果。
在这个练习中，我们根据文本特征来训练模型。
from mlxtend.evaluate import bias_variance_decomp
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(vectorized_train_text, y,test_size=0.25,
random_state=1,shuffle=True,stratify=y)
根据我们得到的分数，我们可以推断我们的模型可能擅长泛化，也就是说，它没有过度拟合。
avg_expected_loss, avg_bias, avg_var = bias_variance_decomp(
clf2, X_train, y_train, X_test, y_test,
loss='mse',
num_rounds=50,
random_seed=1
)
print(f"Average expected loss: {avg_expected_loss.round(3)}")
print(f"Average bias: {avg_bias.round(3)}")
print(f"Average variance: {avg_var.round(3)}")
由于它具有相对较高的偏差，这可能意味着它在某种程度上不适合我们的数据集。
- 3。绘制决策边界&模型区域
- 使用 MLXTEND，我们还可以查看模型的二维决策边界，并了解模型如何区分不同类别的数据点。
- 然而，这种解释技术有一个缺点。对于这种可视化，一次只能使用两个特征，因此我们将在这里两个一组地使用我们的非文本特征。
让我们看看我们在这里得到了什么样的决策边界。
- 进行所需的进口:
- 实例化模型:
现在，绘制:
这是我们得到的结果:
from mlxtend.plotting import plot_decision_regions
from mlxtend.classifier import EnsembleVoteClassifier
import matplotlib.gridspec as gridspec
import itertools
import matplotlib.pyplot as plt
我们可以清楚地看到，这是一个非常糟糕的决策边界。输入要素不是很好的区分因素，因此巩固了我们用其他工具获得的结果。
Clf = RandomForestClassifier(random_state=1)
value=1.5
width=0.75
gs = gridspec.GridSpec(1,2)
fig = plt.figure(figsize=(15,8))
labels = ['Random Forest']
包扎
for clf, lab, grd in zip([clf2], labels, itertools.product([0],[0])):
clf.fit(train[['Source', 'weekday']].values, y)
ax = plt.subplot(gs[grd[0], grd[1]])
fig = plot_decision_regions(X=train[['Source', 'weekday']].values,
y=y, clf=clf)
plt.title(lab)
随着越来越复杂的架构，模型解释是你现在必须做的事情。我希望现在你已经知道如何去做了。
我们在本文中探索的工具并不是唯一可用的工具，还有许多方法可以理解模型预测。其中一些方法可能包含工具或框架，而另一些可能不包含，我鼓励您探索所有这些方法。
未来方向
如果你喜欢你读到的内容，并想更深入地研究这个主题，你可以查看这个链接下的模型解释部分。它包含了许多你可能想要的解释模型的方法的信息。
暂时就这样了。敬请关注更多内容！
Future directions
If you liked what you read and want to dig deeper into this topic, you can check out the Model Explanation section under this link. It contains information about many of the approaches you might want in your arsenal for interpreting your model.
That’s it for now. Stay tuned for more!
进行 ML 模型监控的最佳工具
原文：https://web.archive.org/web/https://neptune.ai/blog/ml-model-monitoring-best-tools
如果您迟早将模型部署到生产中，您将开始寻找 ML 模型监控工具。
当你的 ML 模型影响业务时(它们应该影响)，你只需要了解“事情是如何工作的”。
你第一次真正感觉到这一点是当事情停止工作的时候。在没有建立模型监控的情况下，您可能不知道哪里出了问题，也不知道从哪里开始寻找问题和解决方案。人们希望你尽快解决这个问题。
但是在这个上下文中“事物”和“工作”是什么意思呢？
有趣的是，根据团队/问题/管道/设置的不同，人们的意思完全不同。
在一家 MLOps 公司工作的一个好处是你可以和许多 ML 团队交谈并获得第一手信息。因此，事实证明，当人们说“我想监控 ML 模型”时，他们可能想:
- 监控模型在生产中的表现:查看模型的预测准确度。看看模型性能是否随时间衰减，你应该重新训练它。
- 监控模型输入/输出分布:查看进入模型的输入数据和特征的分布是否改变？预测的阶级分布是否随时间而改变？这些事情可能与数据和概念漂移有关。
- 监控模型训练和再训练:在训练和再训练期间，查看学习曲线、训练模型预测分布或混淆矩阵。
- 监控模型评估和测试:为您的自动化评估或测试管道记录度量、图表、预测和其他元数据
- 监控硬件指标:查看您的模型在训练和推断过程中使用了多少 CPU/GPU 或内存。
- 监控 CI/CD 管道的 ML :查看您的 CI/CD 管道作业的评估，并进行直观比较。在 ML 中，度量标准通常只能告诉你这么多，需要有人实际看到结果。
你指的是哪个 ML 模型监控？
无论哪种方式，我们都将研究有助于所有这些用例的工具。
但是首先…
显然，根据您想要监控的内容，您的需求会发生变化，但是在选择 ML 模型监控工具之前，您应该明确考虑一些事情:
- 易于集成:将其连接到您的模型培训和部署工具有多容易
- 灵活性和表现力:你能记录并看到你想要的东西和你想要的方式吗
- 开销:日志记录给你的模型训练和部署基础设施带来了多少开销
- 监控功能:能监控数据/特征/概念/模型漂移吗？你能比较同时运行的多个模型吗(A/B 测试)？
- 警报:当性能或输入变得疯狂时，它是否提供自动警报？
好了，现在让我们来看看实际的模型监控工具！
首先，让我们回到不同的监控功能，看看哪个工具选中了这些框。
| 模型评估和测试 | 是 | 有限 | 有限 | 否 | 否 | 否 | 否 | 是 | 否 | 否 |
| 硬件指标 | 是 | 否 | 否 | 是 | 否 | 否 | 否 | 否 | 否 | 否 |
| 模型输入/输出分配 | 否 | 是 | 是 | 有限 | 是 | 是 | 是 | 是 | 是 | 是 |
| 模型训练和再训练 | 是 | 有限 | 有限 | 否 | 否 | 否 | 否 | 是 | 否 | 否 |
| 生产中的模型性能 | 否 | 是 | 是 | 有限 | 是 | 是 | 是 | 是 | 是 | 是 |
| ML 的 CI/CD 管道 | 是 | 否 | 否 | 否 | 否 | 否 | 否 | 是 | 否 | 否 |
现在，我们将更详细地回顾一下这些工具。
Neptune 是为运行大量实验的研究和生产团队构建的 MLOps 的元数据存储。
您可以记录和显示几乎任何 ML 元数据，从指标和损失、预测图像、硬件指标到交互式可视化。
说到监控 ML 模型，人们通常将其用于:
- 模型训练，评估，测试，
- 硬件指标显示
- 但是您可以(有些团队确实这样做了)记录来自生产作业的性能指标，并从 ML CI/CD 管道中查看元数据。
它有一个灵活的元数据结构，允许你以你想要的方式组织培训和生产元数据。您可以将它想象成一个字典或文件夹结构，您用代码创建并显示在 UI 中。
您可以构建仪表板，显示您想要查看的性能和硬件指标，以便更好地组织您的模型监控信息。
您可以比较模型和运行之间的指标,以了解模型更新如何改变性能或硬件消耗，以及您是否应该中止实时模型训练，因为它不会超过基线。
您可以通过易于使用的 API 和 25+ 与来自 ML 生态系统的工具集成来记录您想要监控的元数据。
如果您想知道它是否适合您的工作流程:
Example drift monitor | Source
2021 年，Arize AI 被福布斯宣称为最有前途的 AI 工具之一。这是一个 ML 模型监控平台，能够增强您项目的可观察性，帮助您解决生产 AI 的问题。
如果 ML 团队在没有强大的可观察性和实时分析工具的情况下工作，工程师可能会浪费几天时间来试图识别潜在的问题。Arize AI 获得了 1900 万美元的投资，因为它可以很容易地找出问题所在，以便软件工程师立即找到并修复问题。此外，它允许 ML 工程师稳健地更新现有模型。Arize AI 有以下特点:
- 简单整合。 Arize AI 可用于增强任何环境下任何模型的可观测性。详细的文档和社区支持使您能够在几分钟内集成并投入使用。
- 上市前验证。在部署之前，检查您的模型的行为是否符合预期非常重要。发布前验证工具包可帮助您增强对模型性能的信心，并执行发布前和发布后验证检查。
- 自动监控。 模型监控应该是主动的，而不是被动的，这样您就可以尽早发现性能下降或预测偏差。自动化监控系统可以帮助你做到这一点。它要求零设置，并为易于定制的仪表板提供空间。
WhyLabs 是一个模型监控一个 d 可观察性工具，帮助 ML 团队用监控数据管道和 ML 应用。监控已部署模型的性能对于主动解决这个问题至关重要。您可以确定重新训练和更新模型的适当时间和频率。它有助于检测数据质量下降、数据漂移和数据偏差。WhyLabs 很快在开发人员中变得非常受欢迎，因为它可以很容易地在混合团队中使用，经验丰富的开发人员可以与初级员工并肩工作。
该工具使您能够:
- 使用现成的或定制的指标自动监控模型性能。
- 检测整体模型性能下降，并成功识别导致性能下降的问题。
- 通过其开源数据记录库 whylogs，在保持高隐私保护标准的同时，与其他工具轻松集成。
- 使用流行的库和框架，如 MLFlow、Spark、Sagemaker 等。让 WhyLabs 的采用顺利进行。
- 使用内置工具轻松调试数据和模型问题。
- 通过易于使用的零配置设置，在几秒钟内设置好该工具。
- 通过您喜欢的渠道(如 Slack、SMS 等)获得当前工作流程的通知。
WhyLabs 用于模型监控的最大优势之一是，它消除了手动解决问题的需要，从而节省了资金和时间。无论规模如何，您都可以使用该工具处理结构化和非结构化数据。WhyLabs 用的是 AWS 云。它使用亚马逊 ECS 运行容器，并使用亚马逊 EMR 进行大规模数据处理。
Prometheus 是一款流行的开源 ML 模型监控工具，最初由 SoundCloud 开发，用于收集多维数据和查询。
Prometheus 的主要优势是与 Kubernetes 和许多可用的导出器和客户端库紧密集成，以及一种快速查询语言。Prometheus 也与 Docker 兼容，可在 Docker Hub 上获得。
Prometheus 服务器有自己的独立单元，不依赖于网络存储或外部服务。因此，部署额外的基础架构或软件并不需要做很多工作。它的主要任务是存储和监控某些对象。对象可以是任何东西:Linux 服务器、进程之一、数据库服务器或系统的任何其他组件。您想要监控的每个元素称为一个指标。
Prometheus 服务器以您定义的时间间隔读取目标，以收集指标并将它们存储在时序数据库中。您可以设置目标和读取指标的时间间隔。您使用 PromQL 查询语言查询 Prometheus 时间序列数据库中存储指标的位置。
Grafana 允许您可视化监控指标。rafana 擅长时间序列分析。它可以以线形图、热图和直方图的形式显示监测工作的结果。
您不用直接向 Prometheus 服务器编写 PromQL 查询，而是使用 Grafana GUI 板从 Prometheus 服务器请求指标，并在 Grafana 仪表板中呈现它们。
Grafana 的主要特点:
- 警报。您可以通过从信使到 Slack 的各种渠道接收警报。如果您喜欢其他选项，您可以使用少量代码手动添加自己的提醒。
- 仪表板模板。您可以为不同的任务创建定制的仪表盘，并在一个界面中管理您需要的一切。
- 自动化。您可以使用脚本在 Grafana 中自动完成工作。
- 注解。如果出现问题，您可以对来自不同仪表板和来源的事件进行时间匹配，以分析故障原因。您可以通过向所需的点和地块片段添加注释来手动创建注释。
显然是一个开源的 ML 模型监控系统。它有助于在开发、验证或生产监控期间分析机器学习模型。工具从熊猫数据帧生成交互式报告。
目前，有 6 种报告可供使用:
- 数据漂移:检测特征分布的变化
- 数字目标漂移:检测数字目标和特征行为的变化
- 分类目标漂移:检测分类目标和特征行为的变化
- 回归模型性能:分析回归模型的性能和模型误差
- 分类模型性能:分析分类模型的性能和错误。适用于二进制和多类模型
- 概率分类模型性能:分析概率分类模型的性能、模型校准质量和模型误差。适用于二进制和多类模型
Qualdo 是 Azure、Google 和 AWS 中的机器学习模型性能监控工具。这个工具有一些很好的基本特性，允许你在整个生命周期中观察你的模型。
借助 Qualdo，您可以从生产 ML 输入/预测数据、日志和应用数据中获得洞察力，以观察和改进您的模型性能。有模型部署和自动监控数据漂移和数据异常，您可以看到质量指标和可视化。
它还提供工具来监控 Tensorflow 中的 ML 管道性能，并利用 Tensorflow 的数据验证和模型评估功能。
此外，它还集成了许多人工智能、机器学习和通信工具，以改善您的工作流程并使协作更容易。
这是一个相当简单的工具，没有提供很多高级功能。因此，如果您正在寻找一个简单的 ML 模型监控性能解决方案，这是最好的选择。
Fiddler 是一个模型监控工具，它有一个用户友好的、清晰的、简单的界面。它允许您监控模型性能，解释和调试模型预测，分析整个数据和切片的模型行为，大规模部署机器学习模型，以及管理您的机器学习模型和数据集
以下是 Fiddler 的 ML 模型监控特性:
- 性能监控—一种直观的方式来探索数据漂移，并确定哪些数据正在漂移、何时漂移以及如何漂移
- 数据完整性—确保没有不正确的数据进入您的模型，并且不会对最终用户体验产生负面影响
- 跟踪异常值 —Fiddler 在异常值检测选项卡中显示单变量和多变量异常值
- 服务指标—让您基本了解生产中 ML 服务的运行状况
- Alerts —Fiddler 允许您为项目中的一个模型或一组模型设置警报，以警告生产中的问题
总的来说，它是一个监控机器学习模型的伟大工具，具有所有必要的功能。
亚马逊 SageMaker 模型监视器亚马逊 SageMaker 工具之一。它会自动检测部署在生产中的模型的不准确预测并发出警报，因此您可以保持模型的准确性。
以下是 SageMaker 型号监控功能的总结:
- 可定制的数据收集和监控–您可以选择想要监控和分析的数据，而无需编写任何代码
- 统计规则形式的内置分析，用于检测数据和模型质量的偏差
- 您可以编写自定义规则，并为每个规则指定阈值。然后，可以使用这些规则来分析模型性能
- 指标的可视化，以及在 SageMaker 笔记本实例中运行特别分析
- 模型预测–导入您的数据以计算模型性能
- 计划监控作业
- 该工具与 Amazon SageMaker Clarify 集成，因此您可以识别您的 ML 模型中的潜在偏差
当与 ML 的其他工具一起使用时，SageMaker 模型监视器可以让您完全控制您的实验。
Seldon Core 是一个开源平台，用于在 Kubernetes 上部署机器学习模型。这是一个 MLOps 框架，允许您打包、部署、监控和管理数千个生产机器学习模型。
它运行在任何云上和内部，与框架无关，支持顶级的 ML 库、工具包和语言。此外，它将您的 ML 模型(例如 Tensorflow、Pytorch、H2o)或语言包装器(Python、Java)转换为生产 REST/GRPC 微服务。
基本上，Seldon Core 拥有扩展大量 ML 模型的所有必要功能。您可以期待高级度量、离群点检测器、金丝雀、由预测器、转换器、路由器或组合器组成的丰富的推理图等功能。
Censius 是一个人工智能模型可观察性平台，允许您监控整个 ML 管道，解释预测，并主动解决问题以改善业务成果。
Censius 的主要特点:
- 完全可配置的监控器，可检测漂移、数据质量问题和性能下降
- 实时通知，让您提前了解模型服务渠道中的问题
- 可定制的仪表板，您可以在其中切割您的模型培训和生产数据，并观察任何业务 KPI
- 对 A/B 测试框架的本机支持，您可以在生产中继续试验和迭代不同的模型
- 利用表格、图像和文本数据的可解释性，深入到问题的根本原因
结论
既然您已经知道了如何评估 ML 模型监控工具以及现有的工具，那么最好的方法就是测试您喜欢的工具！
如果你想尝试海王星，接下来的步骤是:
您还可以通过查看 mlops.community 准备的资源 ml 模型监控工具比较来继续评估工具。
不管怎样，监控愉快！
以正确的方式进行 ML 模型性能监控
原文：https://web.archive.org/web/https://neptune.ai/blog/ml-model-performance-monitoring
机器学习模型的开发和部署使人工智能应用程序能够解决问题。底层算法从数据中学习模式，但世界在不断变化，所以数据也在不断变化。
这意味着最大似然算法必须跟上不断变化的新数据，并定期更新，以保持预测能力。幸运的是，已经开发了许多工具来帮助数据科学家、机器学习工程师和决策者密切监控部署模型的性能。这些工具提供了有用的统计数据和模型性能详细信息，可以提供深刻的见解并帮助您提高模型性能。
然而，并不是所有的工具都适合您的用例。训练一个最先进的机器学习模型是一个缓慢的过程，更新一个已经训练和测试过的模型可能是耗时、具有挑战性和风险的。如果我们知道模型的弱点，我们就可以计划一个不会损害模型性能的行动过程。
因此，在本文中，我们将讨论如何进行模型监控，以获得最大的价值。希望它能帮助您(作为模型开发人员或决策者)在您的用例中设计一个合适的模型监控策略。
设定现实的目标
设计机器学习模型的关键步骤之一是选择合适的指标来评估模型性能。通常，这些度量标准有一个直观的解释，它们不仅在模型设计中使用，而且在与更广泛的受众交流结果时也使用。
有关详细的指标指南，请参见我们关于机器学习性能指标的文章。
在模型监控期间，跟踪用于模型评估的相同指标的性能是很自然的。但是在开始收集统计数据之前，我们首先必须考虑我们到底要寻找什么:
- 所选指标对未来数据分布变化的稳健性如何？
特别是，模型性能下降是否一定意味着模型性能变差？回归问题中广泛使用的误差度量是均方误差，但众所周知，均方误差对异常值非常敏感。例如，当预测用户在 Twitter 这样的平台上的受欢迎程度时，一个不受欢迎的用户可能会很幸运地捕捉到总统的一张重要照片。突然，他们个人资料的点击量激增，我们的预测算法表现很差。像这样的异常值可能是罕见的事件，甚至不会出现在我们的训练数据中。单个异常值可能导致整批数据的均方误差变得任意糟糕。那么，我们是否应该触发模型表现低于预期的警报，或者调整误差指标以允许少量的不良预测？这些问题需要高级领域知识，不应该由数据科学家独自回答。
简单模式的均方误差
在上图中，我们展示了一个简单模型(实线)的均方误差，该模型代表在测试数据集上评估的非线性函数。这个模型产生了很好的预测。然而，通过添加一个异常值，即右侧图中的红点，均方误差会增加 10%以上。我们应该关心离群值吗？
- 什么是好的，什么是坏的模型表现？
首先，我们需要为我们的模型性能设定现实的期望。模型的表现不太可能像设计时用于评估模型的初始测试数据那样好。随着时间的推移，数据很可能会发生变化，并且可能会出现某种程度的性能衰减，这就是为什么您需要为可接受的性能设置较低和较高的阈值。最终，这取决于底层应用程序，这个决定不应该由机器学习专家单独做出。
比如我们有两个图像分类系统，我们把监控分类精度作为主要度量。在医院系统中，从 X 射线图像中检测肺炎的准确率下降 1%，与在 Android 应用程序中动物分类的准确率下降 1%有着非常不同的影响。在第一种情况下，我们可能面临公共健康风险，而在第二种情况下，分类错误可能具有娱乐价值，甚至可能有助于应用程序的流行。显然，这样的问题超出了纯粹的技术考虑，因此不能只由机器学习专家来讨论。
- 性能其实很差吗？
机器学习研究的一个主要课题是模型比较。什么时候我们可以在某种程度上肯定地说，模型 A 在所选择的指标方面比模型 B 表现得更好？
有时候，我们认为一个模型做得更好，但这种改善在统计上是微不足道的。特别是，对于较小的数据样本，性能在很大程度上取决于随机因素。有大量的统计测试来比较模型的性能。考虑使用统计测试来比较一段时间内的模型性能(如 ANOVA、f 检验等)。
为了避免偏差，应该在进行模型监控之前设计这些测试。为了确保对模型性能的现实期望，与团队成员、业务领导和领域专家讨论这些测试是很重要的。
数据预处理和预测模型的模块化
假设您有一个分类变量，并且您已经创建了自己的标签编码器。通常情况下，标签分布是高度倾斜的，大多数例子中只出现一小部分类别。例如，在单词袋模型中，您只将前 n 个单词视为特征。你的编码器只是一个将单词转换成索引的字典。如果一个单词不在字典中，那么我们返回一个默认代码，比如 0。在 Python 中，应该是这样的:
【word encoding . get(word，0)
其中“wordencoding”是将单词映射到整数的字典。
然而，随着时间的推移，输入略有变化。例如，我们可能会获得更多关于英式英语拼写的数据，并且我们已经在具有美式英语拼写的文本上训练了模型。监控工具可能无法捕捉这些细微之处，我们可能会认为我们有数据漂移。
或者，测量单位可能会有变化，例如从千克到磅；编码标准的改变(疾病分类从 ICD-9 改为 ICD-10)；或者由于将无符号整数转换成有符号整数而突然出现负值。您不需要为这样的异常重新训练您的模型，更新预处理管道就足够了。因此，重要的是将数据准备和模型训练作为单独的模块，仅通过公共接口相互交互。虽然模型再训练可能很慢，成本很高，而且容易出错，但是数据预处理应该很容易解决。
使用基线
设计预测模型时，一种常见的策略是从简单的可解释模型开始。例如，在实现用于序列分类的双向递归神经网络体系结构之前，可以尝试逻辑回归或决策树模型。在大多数情况下，这种简单的模型将表现得相当好，并为我们提供有价值的见解。
当然，我们模型的业务需求可能会高得多，所以我们可能想要部署我们精心设计的、性能最好的模型。但是，我们可以将高级模型与并行运行的基本模型打包在一起。
基本模型应该是轻量级的，在一点点计算资源上运行，并且不应该影响系统的整体可伸缩性。然后，我们可以将高级模型的性能与基本模型进行比较。如果我们在高级模型中观察到性能衰减，而在基线模型中没有，那么很可能高级模型存在过度拟合问题。部署模型的一个更规范的版本可能会表现得更好。
另一方面，如果两个模型的性能都出现下降，那么我们可能会得出结论，确实存在数据或概念漂移，我们需要改进模型(在数据漂移中，数据的分布发生了变化，而在概念漂移中，模型学习到的模式不再准确—查看本次调查了解更多详细信息)。
最终，这意味着我们需要在数据中检测新的精确模式，并且模型再训练是必要的。
A decision tree can be easily visualized and provides deeper insight into model performance | Source
模型再训练
我们做了所有必要的步骤，发现我们的模型表现低于预期，因此需要重新训练。现在，重要的是我们不要重新发明轮子，从零开始训练一个新的模型。尽可能多地重复使用你的作品！
如果我们已经得出结论，模型过拟合，我们可以简单地通过调整正则化超参数来重新训练已经设计的模型。这很酷，因为我们不需要考虑诸如特征工程、机器学习算法的选择、成本函数等问题。
最糟糕的情况是有相当大的数据和/或概念漂移，我们需要一个新的机器学习模型。即使在这种情况下，建立在你已经完成的工作上也是好的。
当首先设计模型时，我们应该始终记住，它应该易于更新。有两个高级机器学习模型家族，它们允许在不牺牲先前工作的情况下进行改进:
- 集合模型，
- 神经网络。
集合模型
如果我们的模型是由许多基本模型组成的集成模型，我们可以丢弃一些基本模型，并用新训练的基本模型替换它们。
当然，选择丢弃哪些基本模型以及如何训练新的基本模型的确切机制将取决于我们设计的集成方法。这些考虑是模型设计过程的重要部分。
神经网络
在数学上，神经网络计算复杂的函数，这些函数可以表示为几个简单函数的组合。作为一个具体的例子，考虑来自特定领域的图像的图像分类问题。例如，在大型体育赛事中拍摄的图像，其目标是检测不同的体育项目。即使由于季节性原因(冬季田径项目较少，秋季足球项目较多)存在概念漂移，这些图像仍将共享许多特征。
类似于使用预训练模型如 VGG19 或 ResNet50 的迁移学习，我们可以使用最近的数据批次仅重新训练网络的顶层。因此，我们的预训练模型被用作特征检测器，并且我们从产生更好的分类错误的现有特征中学习新的组合。类似的例子包括使用分类变量的预训练嵌入层或序列表示的注意力权重。
A pre-trained neural network for image classification can be extended in order to consider different domains | Source
在几个高质量的模型监控工具的帮助下，可以将上述考虑应用到实际设置中。这些工具具有出色的可视化功能，可以跟踪不同的模型性能统计数据(查看这篇关于模型监控工具的博客文章，了解更多细节)。
以下是这些工具的一些功能概述:
Neptune 提供了一个用户友好的界面，该工具可以很容易地与不同平台集成。我们可以收集和可视化不同的统计数据和性能指标。特别是，Neptune 可以随着时间的推移跟踪探索性数据分析可视化，这有助于检测输入数据中的异常，而不依赖于数学公式，这使得它可以被更广泛的用户群访问。
这一类的其他工具显然还有和 Anodot 。的一个有用功能显然是它检测目标标注和输入要素之间的相关性以及它们如何随时间变化。然而，正如上一节所讨论的，如果我们想要跟踪更复杂的模式，使用简单的模型比如决策树可能会更好。
**我们还建议考虑像 Grafana 、 Great Expectations 和 Fiddler 这样的工具，它们提供了各种有用的功能，比如检测异常值和异常值。
对于大规模系统来说，使用高级商业模型监控工具的定制版本可能会更好，比如亚马逊的 SageMaker 模型监控工具或者 T2 的 KFServing 工具。
结论
模型监控应被视为模型开发的一个组成部分。它需要是部署管道中设计良好的元素。
有许多优秀的工具可以监控已部署模型在各种度量方面的性能，并提供重要的见解。然而，就像处理任何实验任务一样，我们应该首先设计一个针对我们特定环境的策略。这是一项重要的任务，可能需要不同方面的专业知识，从数据科学家和 ML 工程师到商业领袖和最终用户。
如果您正确地分析和规划了模型监控任务，您将会以一种高效且有结果的方式实现预期的目标，而不会损害已部署的机器学习管道的完整性。
额外资源
工具:
研究论文:**
最佳 ML 模型注册工具
原文：https://web.archive.org/web/https://neptune.ai/blog/ml-model-registry-best-tools
一个模型注册中心 是一个中央存储库，用于版本控制机器学习(ML)模型。它只是在模型在培训、生产、监控和部署之间移动时跟踪它们。它存储所有主要信息，例如:
- 元数据，
- 血统，
- 型号版本，
- 注释，
- 和培训工作。
由于模型注册表由从事同一机器学习项目的多个团队成员共享，模型治理是这些团队的主要优势。这些治理数据告诉他们:
- 哪个数据集用于训练，
- 他训练并出版了一个模型，
- 模型的预测性能如何，
- 最后，当模型被部署到生产中时。
通常，在团队中工作时，不同的团队成员倾向于尝试不同的东西，只有少数几个最终确定并推送到他们使用的版本控制工具。模型注册帮助他们解决这个问题，因为每个团队成员都可以尝试他们自己的模型版本，并且他们将拥有他们在整个项目旅程中试验过的所有东西的记录。
本文将讨论模型注册工具以及这些工具的评估标准。您还将看到不同模型注册工具的比较，例如:
- 海王星. ai，
- MLflow，
- AWS Sagemaker，
- Verta.ai，
- 还有彗星。
所以让我们开始吧！
模型注册中心是 MLOps 平台/工具的重要组成部分。市场上有很多工具可以满足您的 ML 工作流需求。这里有一个插图，它根据这些工具的专门化程度对它们进行了分类。
Classification of model registry tools | Source
右下方的产品集中在部署和监控；左下方的按钮专注于训练和跟踪。那些处于最顶端的人的目标是覆盖 ML 生命周期的每一个方面，而那些处于中顶端的人通过学习这样或那样的方式做大部分或所有的事情。
为了更精确地形象化，让我们来看另一张图片:
More precise classification of model registry tools | Source
从上图可以推断，像 Kubeflow 和其他云提供商这样的工具是最平衡的，并且平等地覆盖了 ML 管道开发的每个阶段。像 Neptune 和 Polyaxon 这样的专门工具最接近它们的轴，即主要集中在模型训练上。
注意:上述这些工具的评估标准取决于这些工具在该时间点(2021 年 11 月)的特性。在过去的一年中，这些工具中的许多已经远远超出了它们的专业领域，所以对这个讨论要有所保留。
然而，有一些永恒的因素是决定一个注册工具的有效性不可或缺的。从我自己的经验来看，其中一些是:
安装和集成
选择正确的模型注册工具通常会受到它的安装方式和它所提供的集成类型的影响。通常，组织根据他们的开发环境来选择工具。例如:
- 如果组织使用 AWS 进行整个开发和部署，在这种情况下，Sagemaker 会很有意义，因为不会有兼容性问题。
- 但是如果组织没有使用 AWS，那么像 Neptune 或 MLFlow 这样的工具可以用于模型注册。
- 另一方面，通常被视为端到端的工具，如 Sagemaker，对互操作性的概念越来越开放，用户可以用其他工具补充它们。
对于致力于当前技术选择的公司来说，集成可能是一个主要的担忧。如果一个组织正在使用一些持续集成工具，他们可能更喜欢容易融合的模型注册工具。
自动化的简易性
模型注册工具的另一个需求是开发团队使用该工具的难易程度。
- 一些工具要求您编写存储模型版本所需的所有东西，
- 而有些工具只需要很少的代码，你只需要拖放不同的组件就可以使用。
- 还有一些工具完全基于 AutoML 的概念，并且不需要您编写任何代码来存储您的模型版本。
Auto-ML 工具在定制方面灵活性较差，而低代码工具提供定制和自动化选项。最后，代码优先工具只提供编写代码的功能。您可以根据自己的需求选择工具。
更新的模型概述和模型阶段跟踪
模型注册工具的全部目的是提供一个开发团队已经尝试过的所有模型版本的简单概述。在选择工具时，您必须记住，该工具必须在每个阶段提供每个版本的模型概述。跟踪模型超越了开发；这样做是为了在试运行和生产中进行维护和增强。机器学习模型寿命包括:
- 培训，
- 分期，
- 和生产，
必须由模型注册工具跟踪。
管理模型依赖的能力
模型注册工具必须与 ML 模型需要的所有依赖项兼容。您应该检查机器学习库、Python 版本和数据的依赖能力。如果你正在处理一个需要特殊 ML 库的用例，而注册工具不支持它，那么这个工具对你来说没有多大意义。
提供团队协作的灵活性
你可以评估你和你的团队是否可以在注册的模型上合作。如果模型注册使您能够与您的团队在同一个 ML 模型上工作，那么您可以选择这个工具。
因此，您可以遵循评估标准，根据您的需求选择最佳的模型注册工具。
每个模型注册工具都有不同的特性，并执行各种独特的操作。以下是他们的对比:
| 功能 | Neptune.ai | 亚马逊 SageMaker | MLFlow | 彗星 | Verta.AI |
|---|---|---|---|---|---|
版本化模型解释
| | | | | |
| | | | | | |
|
主舞台过渡标签
| | | | | |
| | | | | | |
| | | | | | |
| | | | | | |
|
对个人和研究人员免费，对团队收费
| 个人和研究人员免费，团队付费 | |
对个人和研究人员免费，对团队收费
| 个人和研究人员免费，团队付费 | 提供开源和付费版本 |
下面是一些在整个行业中使用的模型注册工具:
Neptune 是一个用于实验跟踪和模型注册的元数据存储库。所以注册模型是这个工具的两个关键功能之一。
总的来说，Neptune 允许你记录、比较、显示、查询和组织所有与 ML 实验和模型相关的元数据。只需要几行代码就可以将它与您的代码集成在一起，API 非常灵活，UI 对用户友好，但也为大量的日志元数据做好了准备。
Neptune 模型注册表的一些功能包括:
Neptune dashboard showing a list of registered model versions | Source
它让您注册模型和模型版本，以及与这些版本相关联的元数据。它可以对模型代码、图像、数据集、Git 信息和笔记本进行版本控制。
- 它允许您轻松过滤和排序版本化数据。
- 它让您使用四个可用阶段来管理模型阶段转换。
- 然后您可以查询并下载任何存储的模型文件和元数据。
- 此外，它还在一个地方记录了所有用于机器学习模型开发的元数据和版本控制。
- 它还通过为其中央 ML 元数据存储和迄今为止所有运行的表提供持久链接和共享按钮，帮助您的团队在模型构建和实验方面进行协作。
- 它支持不同的连接模式，例如版本化元数据追踪的异步(默认)、同步、离线、只读和调试模式。
- 一个开源平台，可以用来管理 ML 模型的生命周期。借助 MLFlow 的 API，您可以跟踪 MLOps 的生命周期。它提供了模型版本控制、模型沿袭、注释，以及从开发到部署的转换功能。
MLflow 模型注册表的一些功能如下:
它提供了按时间顺序排列的模型谱系，即在给定时间哪个 MLflow 实验和运行产生了模型。
- 它提供了不同的预定义模型阶段，如归档、登台和生产，但一次为不同的模型版本分配一个模型阶段。
- MLflow 允许您对顶级模型进行注释，并使用 markdown 分别对它们进行版本化。
- 它提供了 webhooks，这样你就可以基于注册表事件自动触发动作。
- 还提供了模型事件的电子邮件通知。
- 开发人员使用 Amazon SageMaker 来完全控制 ML 开发生命周期。您可以使用 SageMaker registry 对生产模型进行编目，关联元数据，并管理模型的版本和批准状态。
首先，您创建一个模型版本，并指定其各自的组。此外，您可以使用推理管道来用变量和容器规范注册模型。然后，您可以使用 AWS Python SDK 创建新的模型版本。此外，您还可以使用 AWS 将模型部署到模型注册中心之外。您可以将经过训练的机器学习模型部署到 SageMaker 端点，具有实时干扰和低延迟。可以使用 Amazon SageMaker 模型监控特性来监控这个部署的模型。
Amazon Sagemaker 模型注册中心的一些特性如下:
*Amazon SageMaker dashboard | Source *
您可以创建一个模型组来解决特定的 ML 问题。它允许您查看与模型组相关联的所有模型版本。
- 使用 AWS Python SDK 或 Amazon Sagemaker Studio，您可以查看模型的特定版本的详细信息。
- 您还可以将元数据(如培训指标)与模型相关联，并将其作为一个整体进行版本化。
- 您可以在模型注册中心内批准或拒绝模型版本，如果批准，CI/CD 部署可以从那里轻松执行。
- 开发者可以使用 Comet 平台来管理机器学习实验。该系统允许您使用 Python SDK 实验来版本化、注册和部署模型。
Comet 跟踪模型版本和模型的实验历史。您可以查看所有型号版本的详细信息。此外，您可以使用模型复制和优化更有效地维护 ML 工作流。
功能丰富的 Comet 具有运行和跟踪 ML 模型实验的各种功能，包括:
Comet 允许您轻松地检查评估/测试运行的历史。
- 您可以使用 Comet 模型注册表轻松比较不同的实验。
- 它允许您在单个 UI 中访问代码、依赖项、超参数和指标。
- 它具有内置的报告和可视化功能，可以与团队成员和利益相关者进行交流。
- 它允许您配置 webhooks，并将 Comet 模型注册表与您的 CI/CD 管道集成。
- 您可以使用 Verta AI 工具在一个统一的空间中管理和操作模型。它提供了一个交互式的 UI，您可以在其中注册 ML 模型并发布元数据、工件和文档。然后，为了管理端到端的实验，您可以将模型连接到实验跟踪器。Verta AI 也提供 ML 项目的版本控制解决方案。
此外，它使您能够跟踪对数据、代码、环境和模型配置所做的更改。通过审计日志的可访问性，您还可以随时检查模型的可靠性和兼容性。您还可以创建适合您的项目的唯一批准序列，并将其与选定的票证系统合并。
Verta AI 的模型注册的一些主要特征是:
它支持端到端的信息跟踪，例如模型 ID、描述、标签、文档、模型版本、发布阶段、工件、模型元数据等等，这有助于选择最佳的模型。
- 它可以在 Kubernetes 和 Docker 等容器工具上工作，并且可以与 GitOps 和 Jenkins 集成，这有助于自动跟踪模型版本。
- 它提供了对详细的合规性审核日志的访问。
- 它有一个类似 Git 的环境，使它变得直观。
- 您可以为编辑者、审阅者和协作者设置粒度访问控制。
- 摘要
阅读完本文后，我希望您现在知道什么是模型注册工具，以及在选择模型注册工具时必须考虑的不同标准。为了提供一个实用的视角，我们还讨论了一些流行的模型注册工具，并在几个方面对它们进行了比较。现在，让我们用一些关键要点来总结这篇文章:
Model registry 执行模型版本控制，并将它们发布到产品中。
- 在选择模型注册工具之前，您必须根据您的需求评估每个模型。
- 模型注册评估标准的范围从监控和管理不同 ML 模型阶段和版本的能力到易用性和定价。
- 您可以参考不同模型注册工具的突出特性，以更好地了解该工具与您的用例的兼容性。
- 考虑到这几点，我希望您的模型注册工具搜索会容易得多。
参考
https://www.phdata.io/blog/what-is-a-model-registry/
- https://Neptune . ai/blog/best-alternatives-to-ml flow-model-registry
- https://www . data revenue . com/en-blog/why-is-a-model-registry-valued
- https://www.datarevenue.com/en-blog/why-is-a-model-registry-valuable
ML 模型注册中心:它是什么，为什么重要，如何实现
原文：https://web.archive.org/web/https://neptune.ai/blog/ml-model-registry
为什么一定要多了解 model registry？如果你曾经是团队中唯一的数据科学家，你可能会有这种感觉:你开始从事一个机器学习项目，并进行一系列实验，产生各种模型(和工件)，你通过非标准的命名约定“跟踪”这些模型(和工件)。由于您用于模型文件的命名约定不明确，所以您需要花费一些时间来找到您训练的最佳模型。当您最终这样做时，您决定要么将原始工件交给操作团队，要么更糟，自己部署它。
运营团队收集了您的模型，并告诉您他们需要更多关于以下方面的信息:
1 如何使用
- 2 如果模型被测试
- 3 模型的运行时依赖性
- 4 和其他重要的操作信息
- 因为您所做的只是构建模型并交付，所以可能很难与他们合作来成功部署。
现在想象另一个场景。你的公司正计划推出更多基于 ml 的产品/特性。一名数据科学家、工程师，甚至可能还有一名产品经理加入团队。当您独自工作时，尽管您的模型部署起来很痛苦(如果部署了的话)，但是您的工作流是有效的。现在您有了新的队友，他们开始询问您的模型版本，您意识到将模型存储在文件中并不是那么容易管理的。这是您真正感受到没有有效的方法来共享您的模型版本、工件和模型元数据的痛苦的时刻。
问题是，在这一点上，没有简单的方法回到过去，建立一些适当的东西。
您经过改进的新跨职能团队向您询问:
我们在哪里可以找到该模型的最佳版本，以便我们可以审计、测试、部署或重用它？
- 这个模型是怎么训练出来的？
- 我们如何跟踪每个模型的文档，以确保它们是兼容的，并且人们可以知道关于它的必要细节，包括元数据？
- 我们如何在模型投入使用之前或者甚至在它们被部署之后对其进行评审呢？
- 我们如何集成工具和服务，使新项目的发布更加容易？
- 你能责怪他们吗？
他们希望了解生产中运行的是什么，如何改进它或回滚到以前的版本。这很有道理。
有了这些美好的经历，你开始了你的下一个项目，并寻找一个处理它的工具。你会发现这篇关于 ML 模型注册的文章。
在本文中，您将了解到:
什么是模型注册中心？
模型注册中心是一个中央存储库，它允许模型开发人员发布生产就绪的模型以便于访问。有了注册中心，开发人员还可以与其他团队和利益相关者一起工作，共同管理组织中所有模型的生命周期。数据科学家可以将训练好的模型推送到模型注册中心。一旦在注册表中，您的模型就可以在类似于下面的工作流中进行测试、验证和部署到生产中了:
模型注册中心提供:
What is a model registry? | Source: Author
所有型号的集中存储，
- 和用于模型生命周期管理协作单元。
- 让我们仔细看看以上几点:
集中存储
模型注册中心提供了一个中央存储单元，用于保存模型(包括模型工件),以便应用程序(或服务)进行检索。没有模型注册中心，模型工件将被存储在难以跟踪的文件中，并被保存到任何已建立的源代码存储库中。有了模型注册中心，通过集中存储这些模型的区域，这个过程变得更加简单。
集中式存储还使数据团队能够拥有所有模型状态的单一视图，从而使协作更加容易。下面的例子展示了不同模型的单一视图，模型工件存储在模型注册中心:
协作单位
模型注册中心为 ML 团队提供了一个协作单元来处理和共享模型。它通过以下方式实现协作:
A list of different models registered in the model registry | Source
弥合实验和生产活动之间的差距。
为团队提供一个集中的 UI(用户界面)来协作开发模型。
- 为下游系统提供使用模型的接口。
- 弥合实验和生产活动之间的差距
- 模型注册中心是 MLOps 的核心组件，它使模型开发团队、软件开发团队和操作团队能够协作。这是组织内技术和文化的重要组成部分。构建机器学习模型和操作化它们之间太熟悉的差距可以通过使用模型注册表作为 MLOps 堆栈的一部分来弥合。
Bridging the gap between experiment and production activities
该注册中心以及自动化培训管道还可以实现生产中模型服务的持续集成、交付和培训(CI/CD/CT ),因为模型可以被频繁地更新、推送到该注册中心，并且全部部署在管道中。
为团队提供一个集中的 UI(用户界面)来协作开发模型
Model registry is a central component of MLOps | Source: modified and adapted from YouTube
模型注册为团队提供了对他们模型的可见性。有了中央界面，团队可以:
搜索模型，
查看模型的状态(如果它们正在暂存、部署或退役)，
- 批准或不批准不同阶段的模型，
- 并查看必要的文档。
- 这使得团队中的每个人更容易发现模型。如果需要部署模型，运营团队可以轻松地:
- 搜索一下，
查找验证结果和其他指标，
- 打包模型(如果需要的话)，
- 并将它从暂存环境移动到生产环境。
- 这改善了跨职能团队在 ML 项目上的合作方式。
- And move it from the staging environment to the production environment.
通过 UI，模型评审者(或 QA 工程师)还可以在批准、发布或审核治理的生产模型之前，审核模型以确保它适合部署到生产中。
为下游服务提供使用模型的接口
Inspecting model’s versions through the dashboard in Neptune.ai | Source
模型注册中心提供了接口，使得下游服务能够通过 API 集成来使用模型。通过这种集成，下游系统可以很容易地获得模型的最新(或可接受的)版本。该集成还可以跟踪模型的离线和在线评估指标。正如我们在上一节中所讨论的，这使得使用 ML 管道构建 CI/CD/CT 的自动化设置变得容易。下游服务可以是模型用户、自动化作业或 REST 服务，它们可以使用最稳定的——或任何版本的模型。
为什么需要模型注册中心？
由于在上一节中已经向您介绍了什么是模型注册中心，您的问题可能是为什么它对您有用，以及它给您的工作流带来了什么好处。模型注册表支持机器学习操作。回想一下，MLOps 的四大支柱包括:
Why do you need a model registry?
1 生产模式部署
2 生产模式监控
-
3 车型生命周期管理
-
4 生产模式治理
-
现在，让我们了解一下 MLOps 工作流中的模型注册组件如何支持部署、管理和治理支柱。
-
Model registry 支持更快地部署您的模型
您在前面已经了解到，模型注册中心支持协作的方式之一是它在实验和生产活动之间架起了一座桥梁。这导致您的生产模型的更快推出。此外，模型注册中心存储了经过训练的模型，以便任何集成的应用程序或服务能够快速方便地检索，这最终是您在理想的自动化设置中想要的。
有了模型注册中心，软件工程师和评审人员可以很容易地识别和选择经过训练的模型的最佳版本(基于评估度量)，因此模型可以被测试、评审和发布到产品中。这使得它成为培训和部署管道的一个很好的统一组件，因为在从实验到生产环境的生产就绪模型的移交中有更少的摩擦。
模型注册简化了模型生命周期管理
当你在一个大型组织中工作，有许多实验在运行，许多模型，和跨职能团队，管理这些模型的生命周期通常是一个具有挑战性的过程。虽然管理一个或几个模型是可能的，但是在大多数情况下，您将有许多模型在生产中运行并服务于不同的用例。模型注册中心有助于应对这一挑战，并简化模型生命周期的管理。使用注册表，您可以:
在一个组织有序、可搜索的中央存储库中注册、跟踪和发布您的经过培训、部署和淘汰的模型。
存储 您训练好的模型的元数据，以及它们的运行时依赖关系，从而简化部署过程。
- 建立自动化管道使生产模式的持续集成、交付和培训成为可能。
- 将生产中运行的模型(冠军模型)与试运行环境中新训练的模型(或挑战者模型)进行比较。
- 以下是一个在模型注册表中注册和版本化的训练模型的示例，其中包括模型训练摘要和相关元数据:
- Compare models running in production (champion models) to freshly trained models (or challenger models) in the staging environment.
注册中心还可以跟踪和存储模型的在线和离线评估指标。利用这一功能，您可以轻松地查找生产中的模型，以检测模型性能的下降(或概念漂移)。您还可以比较它们的在线和离线性能，以查看哪些生产模型需要审查、维护或归档。
您不仅可以在生产和培训中跟踪模型的评估指标，还可以跟踪系统指标，以了解哪些模型消耗了最多的应用程序资源(CPU、内存和 GPU 使用)。以下是 Neptune.ai 模型注册中心跟踪离线系统和最佳模型评估指标的示例:
Example of a trained model’s version in the Neptune model registry | Source
The registry can also track and store online and offline evaluation metrics for the models. With this functionality, you can easily look up models that are in production to detect a drop in the performance of the model (or concept drift). You can also compare their online and offline performance to see which of the production models need to be reviewed, maintained, or archived.
模型注册支持生产模型治理
模型注册中心做得非常好的一件事是集中模型并组织它们的相关细节。有了注册表，您就有了模型在其生命周期的不同阶段的中心真实来源，包括:
Trained model monitoring on Neptune.ai | Source
发展，
验证，
- 部署，
- 和监控。
- 这有助于创建可见性和模型发现，这对于特定行业(如卫生、金融和法律)中需要全面监管投诉流程的模型非常重要。
- 负责确保法律合规性的用户应该能够轻松查看注册表中的模型，并理解:
模型是如何被训练的，
模型是在什么版本的数据上被训练的，
- 在充分了解模型的能力和局限性的情况下，模型表现最佳并产生一致结果的条件。
- 一个标准的模型注册还将加强模型的文档和报告，确保结果是可重复的，并且可以被任何审计用户复制。评审、批准、发布和回滚都是模型启动过程中的步骤，注册中心可以提供帮助。这些选择基于多种因素，包括离线表现、偏见和公平措施以及在线实验的结果。
- 模型注册还可以提高模型的安全性
必须对模型以及用于构建模型的底层包进行漏洞扫描，尤其是在使用大量包来开发和部署模型时。模型注册中心可以管理包的特定版本，您可以扫描并删除可能对系统造成威胁的安全漏洞。
模型同样容易受到恶意攻击，因此，必须对它们进行维护和保护。在某些情况下，必须采用最低特权访问安全概念，以便只有授权用户才能访问指定的模型信息、数据隐私以及保护【PII】和其他资源。
模型注册中心在 MLOps 堆栈中的什么位置？
如果您想要高效且大规模地运行机器学习项目，您很可能需要将模型注册表添加到您的 MLOps 堆栈中。根据您在 MLOps 栈中的实现级别,您对模型注册中心的需求会有所不同。哪里合适？好吧，回想一下我们之前学过的，模型注册处位于机器学习开发和部署之间。
MLOps 级别 0 中的模型注册表
如果您处于 MLOps 的级别 0 实现，那么您的带有模型注册中心的工作流可能如下所示:
实验步骤的输出被输入到模型注册中心。这涉及到一个手动过程，数据科学家准备模型工件和元数据，也可以在注册它们之前打包它们(序列化，容器化)。在将打包的模型部署到可以与其他应用程序集成的预测服务引擎之前，运营团队可以将打包的模型推送到临时环境进行测试。
MLOps 级中的模型注册表
MLOps level 0 workflow with a model registry | Source (modified)
与 0 级(其中工作流是手动过程)相反，1 级中工作流的目标是通过自动化 ML 管道来执行模型的连续训练。这是一个模型注册中心能够很好实现的过程，因为它能够与管道集成。在这一级，整个管道被部署，并且当模型在所提供的数据集上被训练时，输出(被训练的模型和元数据)被馈送到模型注册中心，在那里它可以被登台，并且如果它通过必要的测试和检查，它可以被馈送到连续交付管道用于发布。
MLOps 级别 2 中的模型注册表
在 MLOps 工作流程的第 1 级中，模型注册中心的角色也与第 2 级的角色相同——自动化管道将经过训练的模型交付到模型注册中心，在那里进行准备，可能通过 QA 检查，然后发送到连续交付管道:
MLOps level 1 workflow with a model registry | Source (modified)
模型注册中心在任何自动化管道中都是一个至关重要的组件，因为事件触发器可以与它集成，以便在对新数据或归档模型进行重新训练时提升具有良好指标的模型。
模型登记册的关键功能
Stages of the CI/CD automated ML pipeline with a model registry | Source (modified)
在上一节中，我们学习了模型注册如何适应您的 MLOps 工作流。为了理解模型注册中心的关键功能及其必备条件，让我们看看它是如何适应开发和运营的。
模型注册表中的关键功能包括:
与实验管理系统或培训管道集成。
Workflow components of an ideal model registry | Source: Author
为您的定型模型提供登台环境。
- 与自动化的模型交付工具和服务集成。
- 与模型部署工具集成。
- 整合实验管理系统或培训管道
- 模型注册中心必须能够与输出经过训练的模型的系统集成。经过训练的模型可以是原始的工件(模型权重、配置和元数据)或者是为了与生产环境兼容而被序列化为文件(例如 ONNX 文件)或者被容器化(使用 Docker)以导出到生产环境的模型。
模型注册中心应该能够:
登记车型、
给分配一个版本，
- 注意模型被训练的数据集的版本，
- 添加注释和标签，
- 从实验管理系统中检索模型上的参数、验证结果(包括度量和可视化)，以及其他相关的模型元数据。
- 为了使协作更容易，注册管理机构还应包括以下详细信息:
- 模型所有者或开发者，
模型在实验运行 id 下被训练，
- 版本化模型源代码，
- 用于训练模型(和版本)的环境运行时依赖性，
- 评论和模型改变历史，
- 和模型文档。
- 为您的训练模型集成登台环境
- 模型注册中心应该提供与登台环境集成的功能，以便在模型上运行所有类型的检查和平衡。这些检查可以包括在模型被提升到生产环境之前的集成测试(与其他应用程序)和其他 QA 测试。
应该为该环境中的模型启用共享和协作，以便部署工程师可以与数据科学家合作来测试模型，并确保它们适合部署。
在阶段环境中，模型评审者还应该能够对模型执行公平性检查，以确保它:
输出可解释的结果，
符合法规要求，
- 并提供有用的商业利益。
- 通常，治理和批准工作流应该在这种环境中配置。对于这种环境中的模型，还应该有访问级别控制和安全授权，尤其是那些使用带有敏感信息的数据进行训练的模型。
- 自动化是构建任何可伸缩软件的关键部分。在机器学习中，建立自动化管道将允许你花更多的时间来构建新产品，而不是维护旧模型。
模型注册中心应该能够与管道自动化工具集成，并提供自定义 API，允许您插入自定义工作流工具。例如，使用 webhooks 来触发基于注册表中预定义事件的下游操作。
您还应该能够通过开发(培训)、登台(测试)、生产(服务)等不同环境配置模型推广方案。性能是构建自动化管道的关键要求。模型注册中心应该对基于事件或时间表的自动化作业高度可用，以支持模型的持续培训和交付。
最终，必须部署模型，部署过程越高效越好。模型注册中心应该能够与下游服务和 REST 服务集成，这些服务可以消费模型，并在生产环境中为模型服务。
注册中心还应该能够收集生产模型的实时(或聚合)指标，以记录模型的性能细节。这将有助于模型之间的比较(已部署的和已部署的)，以及审计生产模型以供审查。
如何建立一个 ML 模型注册中心？
构建与管理和购买
为您的 MLOps 工作流设置模型注册中心需要您决定是构建一个、维护一个还是购买一个。到目前为止，在本指南中，我们已经重点了解了什么是模型注册中心以及为什么您需要一个模型注册中心。您还了解了模型注册中心在 MLOps 工作流的特定实现级别中的位置。我们还发现，无论您处于什么样的 MLOps 实现级别，模型注册中心都是有用的。也许级别越高，您就越需要一个模型注册中心。
我想到的一个更重要的决定是，您是应该构建自己的、管理的还是自己托管的解决方案，还是购买完全托管的解决方案。让我们仔细看看这些决定中的每一个，以及在做出选择之前要考虑的因素。
构建模型注册中心解决方案
像任何软件解决方案一样，如果你了解关键功能和需求，你可以自己构建一个系统。模型注册中心就是这种情况。您可能希望设置以下内容:
存储对象 为模型和构件。
数据库 用于记录模型详细信息。
- API 集成 用于接收模型、跨各种环境推广模型以及从不同环境收集模型信息。
- 用户界面 (UI)供 ML 团队与可视化工作流进行交互。
- 虽然自己构建解决方案可能看起来很理想，但您应该考虑以下因素:
- 激励:构建您的解决方案的激励是什么？是为了定制还是为了拥有解决方案的专有许可证？
人力资源:你有能力和技能来构建你的解决方案吗？
- 时间:你需要多长时间来构建一个解决方案，值得等待吗？
- 运营:当解决方案最终建成时，谁来维护它的运营？
- 成本:构建一个解决方案需要多少成本，包括解决方案的维护？
- 维护自托管的模型注册中心
- 如果您不想构建解决方案，另一个可以考虑的选择是自己维护现有的解决方案。在这个场景中，解决方案已经构建好了，但是您可能需要管理一些特性，比如对象存储和数据库。这些现有的解决方案大多是开源解决方案。
以下是需要考虑的因素:
解决方案类型:您是选择没有许可成本的开源解决方案还是有许可成本的闭源解决方案？
运营:谁来管理解决方案？该解决方案是否支持一致的维护和软件更新？
- 成本:就托管解决方案的基础设施和运行成本而言，运营该解决方案的成本是多少？
- 特性:已经实现了哪些特性，有哪些特性是你要自己构建和管理的？与构建您的解决方案相比，它是否值得采用？
- 支持:如果在操作过程中发生故障，有什么类型的支持？有社区或专门的客户支持渠道吗？对于开源解决方案，虽然您可能有一个社区，但与闭源解决方案相比，您可能缺少解决问题所需的必要的开发人员支持。
- 可访问性:开始使用该解决方案有多容易？文档是否足够全面？从模型评审人员到模型开发人员和软件工程师，每个人都能直观地使用该解决方案吗？
- 购买全面管理解决方案的许可证
- 要考虑的最后一个选项是订阅完全托管的解决方案，由解决方案供应商处理注册中心的运营和管理。在这种情况下，您不必担心构建或维护解决方案。您只需要确保您的系统和服务能够与注册中心集成。
以下是需要考虑的因素:
行业类型:模型是为什么类型的行业打造的？模特们学到了哪些敏感信息？是否有数据隐私合规措施？模型只允许留在内部吗？
特性:该解决方案中是否提供了任何模型注册中心的关键特性和功能？有哪些额外功能可用，它们与您的工作流程有多大关联？
- 成本:购买许可证的成本是多少，这些功能是否物有所值？
- 安全性:托管解决方案的平台有多安全？抗第三方攻击吗？
- 性能:注册表的性能高吗？对于模型太大的情况，注册中心能提供模型让服务以低延迟消费吗？
- 可用性:解决方案的正常运行时间有多长，是否满足您要求的服务水平协议(SLA) ？
- 支持:万一事情变糟，可以提供什么级别的支持？
- 可访问性:开始使用该解决方案有多容易？文档和学习支持是否足够好？在使用方面有什么学习曲线？
- 现在，您已经了解了可供您决定是否要选择解决方案的各种选项。您还应该仔细考虑每个选项下的因素，以便做出最佳决策。让我们来看看市场上的一些模型注册中心解决方案。
- 有哪些 ML 模型注册解决方案？
1.Neptune.ai 模型注册表
类型:专有，提供免费和付费服务。
选项:托管(自托管)、完全托管的产品。
Neptune 是 MLOps 的元数据存储库，为运行大量实验的研究和生产团队而构建。
它为您提供了一个中心位置来记录、存储、显示、组织、比较和查询机器学习生命周期中生成的所有元数据。
Neptune model registry dashboard | Source
个人和组织使用 Neptune 进行实验跟踪和模型注册来控制他们的实验和模型开发。
特征
海王星让你:
创建模型并跟踪通用模型元数据，例如模型签名和验证数据集。
为您的模型创建版本:
- 日志参数和其他元数据可能会从一个版本更改到另一个版本。
- 跟踪或存储模型二进制文件。
- 跟踪特定模型版本的性能。
- 使用四个可用阶段管理模型阶段转换。
- 查询并下载任何存储的模型文件和元数据。
- 查看型号注册文档了解更多详情。
- 海王星商店:
数据集元数据，
模型源代码版本，
- 环境配置版本，
- 模型参数，
- 模型评估指标，
- 模型二进制。
- 它支持和存储许多 ML 模型相关的元数据类型，您可以对建模过程中生成的大多数元数据进行版本化、显示和查询。
- 就成本而言，Neptune 既有自托管选项可用，也有各种订阅层级的全托管云产品。
如果您想了解更多信息:
➡️看到了产品页面
➡️看到了文档
➡️检查出一个示例项目(不需要注册)
2.MLflow 模型注册表
类型:开源
选项:托管(自托管)、完全托管的产品。
MLflow Model Registry 组件是一个集中式模型存储、一组 API 和 UI，用于协作管理 MLflow 模型的整个生命周期。它提供了模型沿袭(MLflow 实验和运行产生了模型)、模型版本化、阶段转换(例如从阶段转换到生产)和注释。模型注册组件是 2019 年 MLflow 用户的迫切需求之一。
MLflow 模型注册中心是当今市场上为数不多的开源模型注册中心之一。你可以决定在你的基础设施上管理这个 T1，或者在像 T4 数据块 T5 这样的平台上使用 T2 完全管理的实现 T3。
MLflow model registry dashboard | Source
特征
MLflow 提供:
注释和描述工具用于标记模型，提供文档和模型信息，如模型注册日期、注册模型的修改历史、模型所有者、阶段、版本等。
模型版本在更新时自动跟踪注册模型的版本。
- 一个 API 集成，将机器学习模型作为 RESTful APIs，用于在线测试、仪表板更新等。
- CI/CD 工作流集成记录阶段转换、请求、审查和批准变更，作为 CI/CD 管道的一部分，以实现更好的控制和治理。
- 一个模型阶段特性为每个模型版本分配预设或定制的阶段，如“阶段”和“生产”来代表模型的生命周期。
- 促销方案配置方便在不同阶段之间移动模型。
- MLflow 商店:
- 模型人工制品，
元数据，
3.亚马逊 Sagemaker 模型注册表
选项:完全管理的产品
亚马逊 SageMaker 是一个完全托管的服务，开发者可以在 ML 开发的每一步使用它，包括模型注册。模型注册中心是 SageMaker 中MLOps 套件的一部分，该套件通过在整个组织中自动化和标准化 MLOps 实践来帮助用户构建和操作机器学习解决方案。
特征
Amazon SageMaker model registry | Source
使用 SageMaker 模型注册表，您可以执行以下操作:
生产用目录型号。
管理型号版本。
- 将元数据，例如训练指标，与模型相关联。
- 管理模型的审批状态。
- 将模型部署到生产中。
- 使用 CI/CD 自动进行模型部署。
- 您可以创建一个模型组来跟踪您为解决特定问题而训练的所有模型。然后，您训练的每个模型都可以被注册，模型注册中心会将它作为一个新的模型版本添加到模型组中。典型的工作流可能如下所示:
- 创建模型组。
使用训练模型的 SageMaker 管道创建一个 ML 管道。
- 对于 ML 管道的每次运行，创建一个模型版本，并在第一步中创建的模型组中注册。
- 使用模型注册中心的成本与 SageMaker 定价层捆绑在一起。你可以在文档中了解更多关于 SageMaker 的模型注册组件的信息。
- 4.Verta.ai 模型注册表
Type :专有，带有开源、SaaS 和企业产品。
选项:完全管理的产品。
Verta.ai 模型注册表帮助您在一个位置管理您的 AI-ML 模型。它提供了一些特性，使您能够打包、验证和可靠地提升发布就绪模型，并应用安全的发布和治理实践。
特征
Verta.ai model registry dashboard | Source
它提供了一个统一中心来发布发布就绪模型,允许您:
连接实验管理系统进行端到端的信息跟踪。
-
在一个中央存储库中发布所有的模型元数据、文档和工件。
- 从模型实验中选择最适合的模型和准备发布。
- 记录状态转换和管理从开发、试运行、生产到归档的发布生命周期。
- 它支持模型验证和 CI/CD 自动化，允许您:
- 与 Jenkins、Chef 等现有 CI/CD 渠道整合。
-
使用 webhooks 触发下游动作进行模型验证和部署。
- 自动跟踪型号版本和标记的版本。
- 设置粒度访问控制编辑、审阅者和协作者。
- 访问详细的审计日志以了解合规性。
-
一旦模型通过基本的安全性和公平性检查，就发布它们。
-
您可以在此页面上了解有关可用定价等级的更多信息。你可以在这个页面上了解更多关于 Verta 注册表的信息。
-
想了解市场上更多可用的解决方案吗？
澄清一些模型注册中心的误解
模型注册中心与模型存储
一个常见的误解是，模型注册中心只是一个作为营销术语的模型商店。虽然这两个组件在功能上几乎没有区别，并且两者都可以被一些从业者互换使用，但是它们之间还是有一些细微的差别。
模型存储是模型注册的超集——这意味着在模型存储中，您可以找到模型注册组件。store 是一个服务，其他服务可以通过它从注册表中检索模型。在模型注册中心，您可以存储和获取模型(就像 docker 注册中心)，但是在模型存储中心，您可以拥有完整的日志、发现、资产、管道、元数据、所有模型信息，甚至是用于构建新模型的蓝图。典型的模型商店的例子有谷歌的人工智能中心和拥抱面孔模型库。
模型注册与实验跟踪
MLOps 世界中另一个常见的误解是注册表只是“实验跟踪重命名”。你可能已经知道，这与事实相差甚远。模型注册必须与实验管理系统(跟踪实验)集成，以注册来自各种实验运行的模型，使它们更容易找到和使用。让我们来看看模型注册和实验管理系统之间的一些关键区别。
Model registry vs experiment tracking
模型注册表
实验跟踪
在中央存储库中存储经过培训的、生产的和退役的模型
为了跟踪不同参数配置和组合的实验运行
Model registry:
确保模型是可发现的，并且可以被任何用户或系统访问
Experiment tracking:
确保实验更容易管理和合作
Model registry:
与实验跟踪系统集成，以注册来自成功实验的模型，包括模型和实验元数据
Experiment tracking:
与培训管道集成，以执行实验运行并跟踪实验细节，包括数据集版本和元数据
Model registry:
MLOps 和生产模型的关键部分
Experiment tracking:
在模型开发阶段最有用，但对模型的操作有间接影响。
Model registry:
结论
Experiment tracking:
在本指南中，到目前为止，您已经了解到模型注册能够使机器学习项目成功运作。它提供了模型的可见性，并使用户能够轻松地发现和使用模型。使用模型注册表，您可以:
有把握地部署模型。
有效管理模型生命周期。
启用了自动化工作流。
- 在有组织的工作流程中共享和协作模型和项目。
- 适当地管理机器学习模型。
- 下一步是你挑选一个解决方案，看看它是否能改善你的 MLOps 工作流程。如果您是一名个人数据科学家，Neptune 是免费的，并且在 5 分钟内就可以轻松上手——但是当然，让这篇文章作为您的指南，根据您的 MLOps 实施水平和值得考虑的因素做出具体的决定。
- 为更多的建设和运作干杯！
- 参考资料和资源
斯蒂芬·奥拉德勒
开发者倡导者和 MLOps 技术内容创建者。
阅读下一篇
Continuum Industries 案例研究:如何跟踪、监控和可视化 CI/CD 管道
7 分钟阅读| 2021 年 8 月 9 日更新
READ NEXT
Continuum Industries 是一家基础设施行业的公司，希望自动化和优化线性基础设施资产的设计，如水管、架空传输线、海底电力线或电信电缆。
其核心产品 Optioneer 允许客户输入工程设计假设和地理空间数据，并且使用进化优化算法来寻找可能的解决方案，以在给定约束的情况下连接 A 点到 B 点。
Continuum Industries is a company in the infrastructure industry that wants to automate and optimize the design of linear infrastructure assets like water pipelines, overhead transmission lines, subsea power lines, or telecommunication cables.
首席科学家安德烈亚斯·马莱科斯(Andreas Malekos)致力于研究人工智能发动机，他解释道:
“建造像电力线这样的东西是一个巨大的项目，所以你必须在开始之前获得正确的设计。你看到的设计越合理，你就能做出更好的决定。Optioneer 可以在几分钟内为您提供设计资产，而成本只是传统设计方法的一小部分。”
但是，创建和操作 Optioneer 引擎比看起来更具挑战性:
目标函数不代表现实
有很多土木工程师事先不知道的假设
不同的客户给它提出完全不同的问题，算法需要足够健壮来处理这些问题
- 与其构建完美的解决方案，不如向他们展示一系列有趣的设计选项，以便他们做出明智的决策。
- 引擎团队利用来自机械工程、电子工程、计算物理、应用数学和软件工程的各种技能来实现这一目标。
- 问题
无论是否使用人工智能，构建一个成功的软件产品的一个副作用是，人们依赖它工作。当人们依赖您的优化引擎做出价值百万美元的基础设施设计决策时，您需要有一个强大的质量保证(QA)。
正如 Andreas 所指出的，他们必须能够说，他们返回给用户的解决方案是:
好，意思是这是一个土木工程师可以看到并同意的结果
更正，这意味着计算并返回给最终用户的所有不同工程数量都尽可能准确
除此之外，该团队还在不断改进优化引擎。但要做到这一点，您必须确保这些变化:
- 不要以这样或那样的方式破坏算法
- 实际上，它们不仅改善了一个基础设施问题的结果，还改善了所有问题的结果
基本上，您需要建立适当的验证和测试，但是团队试图解决的问题的性质带来了额外的挑战:
- 您无法自动判断算法输出是否正确。这不像在 ML 中，你已经标记了数据来计算你的评估集的准确度或召回率。
- 您需要一组示例问题，代表算法在生产中需要解决的那类问题的。此外，这些问题需要被版本化，以便尽可能容易地实现可重复性。
Basically, you need to set up a proper validation and testing, but the nature of the problem the team is trying to solve presents additional challenges:
- You cannot automatically tell whether an algorithm output is correct or not. It is not like in ML where you have labeled data to compute accuracy or recall on your evaluation set.
- You need a set of example problems that is representative of the kind of problem that the algorithm will be asked to solve in production. Furthermore, these problems need to be versioned so that repeatability is as easily achievable as possible.
做 ML 模型服务的最佳工具
原文：https://web.archive.org/web/https://neptune.ai/blog/ml-model-serving-best-tools
机器学习中的模型服务工具可以为您提供数据工程师和 DevOp 关注的许多问题的解决方案。它们有许多功能，使管理您的模型变得更加容易。
您可以在 ML 项目的整个生命周期中使用它们，从构建一个训练有素的模型开始，到部署、监控、提供易访问性和生产。他们将自动化和优化你的工作，但也确保没有错误，使其易于与其他人协作，并实时跟踪变化。
让我们来看看能在模型服务中帮助你的最好的工具！
BentoML 标准化了模型打包，并为用户在广泛的部署环境中部署预测服务提供了一种简单的方法。该公司的开源框架旨在弥合数据科学和 DevOps 之间的差距，使团队能够以快速、可重复和可扩展的方式提供预测服务。
下面是 BentoML 的总结:
- 标准化的“便当”格式打包了模型、依赖项和代码
- 管理所有主要 ML 框架的依赖项和包
- 使用 BentoCtl 可在任何云环境中部署
- 通过 REST/GRPC 的在线 API 服务或离线批处理服务
- 自动生成和配置 docker 映像以进行部署
- 具有自适应微批处理支持的高性能 API 模型服务器
- 本机 Python 支持将推理工人与业务逻辑分开扩展
- 通过 Web UI 和 API 作为管理模型和部署流程的中心
Cortex 是一个用于部署、管理和扩展机器学习模型的开源平台。这是一个多框架工具，允许您部署所有类型的模型。
Cortex 基于 Kubernetes 构建，支持大规模机器学习工作负载。
皮层–总结:
- 自动扩展 API 以处理生产工作负载
- 对任何 AWS 实例类型运行推理
- 在单个 API 中部署多个模型，并在不停机的情况下更新已部署的 API
- 监控 API 性能和预测结果
TensorFlow Serving 是一个灵活的机器学习模型系统，专为生产环境而设计。它处理机器学习的推理方面。
它接受训练后的模型并管理它们的生命周期，通过高性能的引用计数查找表为您提供版本化访问。
以下是一些最重要的特性:
- 可以同时服务于多个模型或同一模型的多个版本
- 公开 gRPC 和 HTTP 推理端点
- 允许在不更改代码的情况下部署新的模型版本
- 让您灵活地测试实验模型
- 其高效、低开销的实现给推理时间增加了最小的延迟
- 支持许多服务:张量流模型、嵌入、词汇表、特征转换和非基于张量流的机器学习模型
TorchServe 是一款灵活易用的工具，用于服务 PyTorch 模型。这是一个开源框架，可以轻松地大规模部署训练有素的 PyTorch 模型，而无需编写定制代码。TorchServe 提供低延迟的轻量级服务，因此您可以部署您的模型进行高性能推理。
TorchServe 是实验性的，可能还会经历一些变化，但无论如何，它提供了一些有趣的功能。
火炬服务-主要特点:
- 多模式服务
- A/B 测试的模型版本控制
- 监控指标
- 用于应用集成的 RESTful 端点
- 支持任何机器学习环境，包括亚马逊 SageMaker、Kubernetes、亚马逊 EKS 和亚马逊 EC2
- TorchServe 可以在生产环境中用于许多类型的推理
- 提供易于使用的命令行界面
KFServing 提供了一个 Kubernetes 自定义资源定义(CRD ),用于在任意框架上服务机器学习模型。它旨在通过为通用 ML 框架如 Tensorflow、XGBoost、ScikitLearn、PyTorch 和 ONNX 提供高性能、高抽象的接口来解决生产模型服务用例。
该工具提供了一种无服务器的机器学习推理解决方案
部署模型的简单界面。
KFServing 的主要特点:
- 通过提供预测、预处理、后处理和可解释性，为您的生产 ML 推理服务器提供一个简单、可插入和完整的故事
- 可定制的推理服务，为 CPU、GPU、TPU 和内存请求和限制添加您的资源请求
- 批量处理单个模型推理请求
- 交通管理
- 从零开始缩放
- 修订管理
- 请求/响应日志记录
- 可扩展的多模型服务
多模型服务器(MMS)是一个灵活且易于使用的工具，用于服务使用任何 ML/DL 框架训练的深度学习模型。该工具可用于生产环境中的多种推理。它提供了一个易于使用的命令行界面，并利用基于 REST 的 API 来处理状态预测请求。
您可以使用 MMS 服务器 CLI 或预先配置的 Docker 图像来启动一个服务，该服务设置 HTTP 端点来处理模型推断请求。
主要特性:
- 高级配置允许深度定制彩信的行为
- 开发定制推理服务的能力
- MMS 的内务处理单元测试
- JMeter 通过 paces 运行 MMS 并收集基准数据
- 多型号服务器基准测试
- 亚马逊弹性推理服务模型
- ONNX 模型导出功能支持深度学习框架的不同模型
Triton 推理服务器提供了优化的云和边缘推理解决方案。它针对 CPU 和 GPU 进行了优化。Triton 支持 HTTP/REST 和 GRPC 协议，允许远程客户端请求对服务器管理的任何模型进行推理。
对于 edge 部署，Triton 是一个带有 C API 的共享库，允许将 Triton 的全部功能直接包含在应用程序中。
Triton 的主要特性:
- 支持多种深度学习框架(TensorRT、TensorFlow GraphDef、TensorFlow SavedModel、ONNX 和 PyTorch TorchScript)
- 在同一个 GPU 或多个 GPU 上同时执行模型
- 动态配料
- 可扩展后端
- 支持模型集成
- 普罗米修斯数据格式的指标，指示 GPU 利用率、服务器吞吐量和服务器延迟
ForestFlow 是在 Apache 2.0 许可下授权的 LF AI 基金会孵化项目。
它是一个可扩展的基于策略的云原生机器学习模型服务器，用于轻松部署和管理 ML 模型。
它为数据科学家提供了一种简单的方法，以最小的摩擦将模型部署到生产系统，从而加速生产价值主张的开发。
以下是 ForestFlow 的主要特性:
- 可以作为单个实例(笔记本电脑或服务器)运行，也可以部署为协同工作并自动管理和分配工作的节点群集。
- 提供原生 Kubernetes 集成，只需少量配置即可轻松部署在 Kubernetes 集群上
- 允许在影子模式下部署模型
- 不使用时自动缩小(合并)模型和资源，并自动将模型重新合并到内存中以保持高效
- 多租户
- 允许为多个用例部署模型，并在不同的路由策略之间进行选择，以在服务于每个用例的模型变量之间引导推理流量
DeepDetect 是一个用 C++11 编写的深度学习 API 和服务器，以及一个用于培训和管理模型的纯 Web 平台。
DeepDetect 旨在使先进的深度学习易于使用并集成到现有的应用程序中。它支持后端机器学习库 Caffe、Caffe2、Tensorflow、XGBoost、Dlib 和 NCNN。
DeepDetect 的主要特性:
- 为图像标记、对象检测、分割、OCR、音频、视频、文本分类、表格数据和时间序列的 CSV 应用做好准备
- 用于培训和管理模型的 Web 用户界面
- 由于有超过 25 种预先训练的模型，训练速度很快
- 用纯 C++编写的快速服务器，适用于云、桌面和嵌入式的单一代码库
- 用于 GPU、CPU 和嵌入式设备的最有效架构的神经网络模板
- 从对象检测到 OCR 和情感分析，为一系列任务提供了现成的模型
Seldon Core 是一个开源平台，它有一个框架，可以更容易、更快地在 Kubernetes 上大规模部署你的机器学习模型和实验。
这是一个独立于云的、安全、可靠且强大的系统，通过一致的安全和更新策略进行维护。
谢顿核心——摘要:
- 使用我们预先打包的推理服务器、定制服务器或语言包装器来容器化 ML 模型的简单方法
- 由预测器、转换器、路由器、组合器等组成的强大而丰富的推理图
- 元数据来源，以确保每个模型可以追溯到其各自的培训系统、数据和指标
- 集成到 Prometheus 和 Grafana 的高级和可定制指标。
- 通过模型输入输出请求的完全可审计性(与 Elasticsearch 的日志集成)
把它包起来
有大量的机器学习模型工具可供选择。在你选择你最喜欢的之前，确保它满足你的所有需求。虽然相似，但每个工具提供的不同功能可能不适合每个 ML 从业者。
保罗·查科夫
将市场营销引入机器学习世界。
阅读下一篇
你需要知道的最好的机器学习模型管理工具
9 分钟阅读|作者弗拉基米尔·利亚申科| 2021 年 7 月 14 日更新
开发您的模型是 ML 项目工作的重要部分。这通常是一个艰难的挑战。
每个数据科学家都必须面对它，还有困难，比如失去实验的线索。这些困难很可能既烦人又不明显，会让你时不时感到困惑。
这就是为什么简化管理 ML 模型的过程是有好处的，幸运的是有几个工具可以做到这一点。这些工具有助于:
- 实验跟踪
- 模型版本控制
- 测量推理时间
- 团队协作
- 资源监控
因此，寻找和使用适合您的项目的工具是常识和良好的实践。
在本文中，我们将探索模型管理工具的前景。我将尝试向您展示各种工具，并强调它们的优点。
我们将涵盖:
- 选择模型管理工具的标准
- 模型管理工具 : Neptune、亚马逊 SageMaker、Azure 机器学习、Domino 数据科学平台、Google Cloud AI 平台、Metaflow、MLflow
ML 模型测试:4 个团队分享他们如何测试他们的模型
尽管机器学习行业在开发帮助数据团队和从业者操作他们的机器学习模型的解决方案方面取得了进展，但测试这些模型以确保它们按预期工作仍然是将它们投入生产的最具挑战性的方面之一。
大多数用于测试生产用途的 ML 模型的过程是传统软件应用程序的原生过程，而不是机器学习应用程序。当开始一个机器学习项目时，标准的做法是对业务、技术和数据集要求进行严格的记录。尽管如此，团队经常忽略稍后的测试需求，直到他们准备好部署或者完全跳过部署前的测试。
团队如何测试机器学习模型？
对于 ML 测试，你在问这样的问题:“我如何知道我的模型是否有效？”本质上，您希望确保您学习到的模型行为一致，并产生您期望的结果。
与传统的软件应用程序不同，建立测试 ML 应用程序的标准并不简单，因为测试不仅依赖于软件，还依赖于业务环境、问题领域、使用的数据集和选择的模型。
虽然大多数团队习惯于在部署之前使用模型评估指标来量化模型的性能，但是这些指标大多不足以确保您的模型准备好投入生产。您还需要对您的模型进行彻底的测试，以确保它们在现实世界中足够健壮。
这篇文章将教你不同的团队如何对不同的场景进行测试。同时，值得注意的是，这篇文章不应该被用作模板(因为 ML 测试是与问题相关的),而应该是一个指南，指导你根据你的用例，为你的应用尝试什么类型的测试套件。
Developing, testing, and deploying machine learning models | Source
小便笺
本文中分享的信息是基于我与团队代表的互动，这些团队代表要么在为他们的 ML 项目执行测试的团队中工作，要么仍然在这样的团队中工作。
如果你觉得文章中有任何需要更新的地方或有任何疑问，请随时通过 LinkedIn 联系我。
1.结合自动化测试和手动验证进行有效的模型测试
组织
格林斯团队-一家 i4 洞察公司
工业
计算机软件
机器学习问题
各种 ML 任务
感谢格林斯团队前 ML 工程师Tymoteusz Wolodzko接受我的采访。本节利用了 Tymoteusz 在采访中得到的回复以及他在 Neptune.ai 博客上发表的 案例研究博文 。
业务用例
greens team–一家 i4 Insight 公司为海洋行业提供软件解决方案，帮助减少燃料消耗。过量使用燃料既费钱又对环境有害，国际海事组织要求船舶运营商更加环保，到 2050 年将二氧化碳排放量减少 50%。
GreenSteam – an i4 insight company dashboard mock | Source
测试工作流程概述
为了在他们的项目中执行 ML 测试，这个团队有几个级别的测试套件，以及验证:
- 模型验证的自动化测试，
- 手动模型评估和验证。
为了在他们的工作流程中实现自动化测试，团队利用 GitOps 运行代码质量检查 Jenkins 和冒烟测试在测试环境中使用类似生产的运行。结果，团队有一个模型代码的单一管道，每个拉请求都经过代码审查和自动化单元测试。
拉取请求也通过了自动冒烟测试。自动化测试套件的目标是确保测试在开发过程的早期标记出错误的代码。
在自动化测试运行并通过模型管道之后，一个领域专家手动地检查评估度量，以确保它们有意义，验证它们，并标记它们为部署做好准备。
模型验证的自动化测试
自动化测试的工作流程是，每当团队中有人提交时，冒烟测试将运行以确保代码工作，然后单元测试将运行，确保代码和数据中的断言得到满足。最后，将运行集成测试，以确保该模型与管道中的其他组件配合良好。
自动烟雾测试
每一个拉取请求都经过了自动化的冒烟测试，团队在测试中训练模型并进行预测，在一小块实际数据上运行整个端到端管道，以确保管道按预期工作，不会出现任何问题。
对 smoke suite 进行正确的测试可以让任何团队有机会在部署管道之前了解其质量。尽管如此，运行冒烟测试套件并不意味着整个管道都保证完全工作，因为代码通过了。因此团队不得不考虑单元测试套件来测试数据和模型假设。
自动化单元和集成测试
团队运行的单元和集成测试是为了检查数据集的一些断言，以防止低质量的数据进入培训管道，并防止数据预处理代码出现问题。您可以将这些断言视为团队对数据做出的假设。例如，他们期望在数据中看到某种相关性，或者看到模型的预测界限是非负的。
单元测试机器学习代码比典型的软件代码更具挑战性。对团队来说，对模型代码的几个方面进行单元测试是很困难的。例如，为了准确地测试它们，他们必须训练模型，即使有适度的数据集，单元测试也可能需要很长时间。
此外，一些测试是不稳定的和不可靠的(随机失败)。运行单元测试来断言数据质量的挑战之一是，在样本数据集上运行这些测试比在整个数据集上运行它们更复杂，花费的时间也更少。对团队来说很难修复，但是要解决这些问题。他们选择取消部分单元测试，转而进行冒烟测试。
团队定义了验收标准，他们的测试套件随着他们的实验不断发展，添加新的测试，删除其他测试，获得更多关于什么有效什么无效的知识。
他们将在类似生产的环境中，针对每个新的拉取请求，在完整的数据集上训练模型，除了他们将超参数调整为快速产生结果的值。最后，他们将监控管道的健康状况，发现任何问题并及早发现。
GreenSteam – an i4 insight company MLOps toolstack including testing tools | Source
手动模型评估和验证
“我们有一个人在回路的框架，在训练完模型后，我们用不同的图来创建报告，显示基于数据集的结果，这样领域专家就可以在模型发布前检查它们。”
Tymoteusz Wołodźko*, a former ML Engineer at GreenSteam *
在训练模型之后，领域专家生成并审查了模型质量报告。专家将通过手动审核过程批准(或拒绝)模型，然后在获得验证并通过所有之前的测试后，最终由团队交付生产。
2.零售客户端应用程序的机器学习测试方法
组织
身份不明的
工业
零售和消费品
机器学习问题
分类
业务用例
这个团队使用机器学习帮助一个零售客户以自动化的方式解决了问题。当用户提出票证或由维护问题产生时，应用程序使用机器学习将票证分为不同的类别，帮助更快地解决问题。
测试工作流程概述
这个团队测试模型的工作流程包括在每次提交时在持续集成(CI)管道中生成构建。此外，构建管道将运行代码质量测试 ( 林挺测试)以确保没有代码问题。
一旦管道生成了构建(一个容器映像)，模型就通过发布管道在类似生产的环境中接受压力测试。在部署之前，团队还会偶尔对模型进行 A/B 测试，以评估不同情况下的性能。
在团队部署管道之后，他们将运行部署和推理测试，以确保它不会破坏生产系统，并且模型能够持续正确地工作。
让我们来深入看看这个用例的一些团队测试。
代码质量测试
运行测试来检查代码质量对于任何软件应用程序都是至关重要的。您总是希望测试您的代码，以确保它:
- 正确，
- 可靠(在不同条件下不会断裂)，
- 安全，
- 可维护的，
- 和高性能。
在 CI 管道中构建任何容器映像之前，这个团队对他们的代码执行了林挺测试。林挺测试确保他们能够执行编码标准和高质量的代码，以避免代码崩溃。执行这些测试还允许团队在构建过程之前捕捉错误(当它们易于调试时)。
A screenshot showing a mock example of linting tests | Source
A/B 测试机器学习模型
“在部署模型之前，我们有时会做 A/B 测试，但不是每次都做，这取决于需要。”
Emmanuel Raj, Senior Machine Learning Engineer
根据用例，团队还执行了 A/B 测试，以了解他们的模型在部署之前在不同条件下的表现，而不是纯粹依赖离线评估指标。通过从 A/B 测试中学到的东西，他们知道新模型是否改进了当前模型，并调整他们的模型以更好地优化业务指标。
压力测试机器学习模型
“我们使用发布管道对模型进行压力测试，每分钟对模型的部署进行 X 次推理。X 可以是 1000 或 100，取决于我们的测试。目标是看模型是否按照需要执行。”
Emmanuel Raj, Senior Machine Learning Engineer
测试模型在极端工作负载下的性能对于通常期望来自用户的高流量的业务应用程序至关重要。因此，该团队执行了压力测试，以查看在给定时间范围内，随着预测请求数量的增加，模型的响应能力和稳定性如何。
通过这种方式，他们对模型在负载下的可伸缩性进行了基准测试，并确定了模型的断点。此外，该测试还帮助他们确定模型的预测服务是否满足正常运行时间或响应时间指标所要求的服务级别目标(SLO)。
值得注意的是，对模型进行压力测试的目的，与其说是为了了解模型可以处理多少推理请求，不如说是为了了解当用户超过这样的流量时会发生什么。这样，您就可以了解模型的性能问题，包括加载时间、响应时间和其他瓶颈。
部署后测试模型质量
“在部署模型后的生产中，我们测试数据和模型漂移。我们也做后期制作审计；我们有季度审计来研究运营情况。”
Emmanuel Raj, Senior Machine Learning Engineer
测试生产模型的目标是确保模型的部署是成功的，并且模型能够在生产环境中与其他服务一起正常工作。对于这个团队来说，在生产中测试模型的推理性能是持续提供商业价值的关键过程。
此外，该团队测试了数据和模型漂移，以确保模型可以被监控，并且在检测到这种漂移时可能会重新训练。另一方面，测试生产模型可以使团队通过领域专家的手动检查对他们的关键任务模型执行错误分析。
An example of a dashboard showing information on data drift for a machine learning project in Azure ML Studio | Source
3.金融科技初创公司机器学习应用的行为测试
组织
工业
金融技术
机器学习问题
自然语言处理(NLP)和分类任务
感谢 埃梅卡鲍里斯 在本节选出版前给予我采访和审阅。
业务用例
MonoHQ 的交易元数据产品使用机器学习对交易语句进行分类，这些交易语句有助于各种企业客户应用程序，如信贷申请、资产规划/管理、BNPL(立即购买，稍后支付)和支付。基于叙述，该产品将数以千计的客户的交易分为不同的类别。
测试工作流程概述
在部署模型之前，团队进行行为测试。该测试由 3 个要素组成:
- 预测分布，
- 故障率，
- 潜伏。
如果模型通过了这三个测试，团队就会将其列为部署对象。如果模型没有通过测试，他们将不得不重新工作，直到它通过测试。他们总是确保为这些测试设置一个性能阈值作为度量。
他们还对他们的模型执行 A/B 测试，以了解哪个版本更适合投入生产环境。
检查预测质量的行为测试
该测试显示了模型如何响应推理数据，尤其是 NLP 模型。
本质上，他们试图在这里回答:在具有相似上下文的数据集中的微小调整会产生一致的输出吗？
机器学习模型的性能测试
为了测试模型在负载下的响应时间，团队配置了一个测试环境，在这个环境中，他们将向模型服务发送大量流量。这是他们的流程:
- 它们需要大量交易数据集，
- 创建一个表，
- 将数据流式传输到模型服务，
- 记录推理潜伏期，
- 最后，计算整个事务数据的平均响应时间。
如果响应时间超过了指定的延迟阈值，就可以部署了。如果没有，团队将不得不返工以改进它，或者设计另一种策略来部署模型以减少延迟。
A/B 测试机器学习模型
“我们进行 A/B 测试，看看哪个版本的模型最适合部署。”
Emeka Boris, Senior Data Scientist at MonoHQ.
对于这个测试，团队将两个模型封装起来部署到生产系统中，以便上游服务消费到生产系统中。他们部署其中一个模型来服务来自随机用户样本的流量，并部署另一个模型来服务不同用户样本的流量，以便他们可以衡量模型结果对其用户的实际影响。此外，他们可以使用真实客户来调整他们的模型，并衡量他们对模型预测的反应。
这个测试也有助于团队避免引入来自新训练的模型的复杂性，这些模型很难维护并且对他们的用户没有增加价值。
4.为机器学习应用程序执行工程和统计测试
组织
工业
金融科技——市场情报
机器学习问题
各种 ML 任务
感谢 拉斯洛·斯拉格纳 在本节选出版前给予我采访和审阅的机会。
业务用例
一个处理来自新兴市场的新闻的系统，为交易员、资产经理和对冲基金经理提供情报。
Arkera.ai LinkedIn cover image | Source
测试工作流程概述
这个团队对他们的机器学习项目进行了两种类型的测试:
- 基于工程的测试( )单元和集成测试 ) ，
- 基于统计的测试())。
*工程团队运行单元测试，并检查模型是否抛出错误。然后，数据团队将交付(给工程团队)一个模拟模型，该模型具有与他们正在构建的模型相同的输入输出关系。此外，工程团队将测试该模型，以确保它不会破坏生产系统，然后为其提供服务，直到数据团队准备好正确的模型。
一旦数据团队和利益相关者评估并验证了模型可以部署，工程团队将使用原始模型运行集成测试。最后，如果可以的话，他们会将模拟模型与生产中的原始模型进行交换。
基于工程的机器学习模型测试
单元和集成测试
为了运行一个初始测试来检查该模型是否能与生产中的其他服务很好地集成，数据团队将向工程团队发送一个模拟(或虚拟)模型。模拟模型与真实模型具有相同的结构，但是它只返回随机输出。工程团队将为模拟模型编写服务，并为测试做准备。
数据团队将向工程团队提供数据和输入结构，以测试输入-输出关系是否符合他们的预期，是否以正确的格式出现，并且不抛出任何错误。
工程团队不检查该模型是否是正确的模型；他们只从工程角度检查它是否可行。他们这样做是为了确保当模型投入生产时，不会打破产品管道。
当数据团队训练和评估正确的模型，并且涉众验证它时，数据团队将打包它并将其交给工程团队。工程团队将用正确的模型替换模拟模型，然后运行集成测试，以确保它按预期工作，并且不抛出任何错误。
机器学习模型的基于统计的测试
模型评估和验证
数据团队将在真实世界数据和统计评估指标上训练、测试和验证他们的模型。数据科学负责人审核结果并批准(或拒绝)模型。如果有证据表明该模型是正确的模型，数据科学负责人将向必要的利益相关方报告结果。
他将解释模型的结果和内部运作，模型的风险，以及它产生的错误，并确认他们是否对结果感到满意或模型仍然需要重新工作。如果模型被批准，工程团队将模拟模型与原始模型交换，重新运行集成测试以确认它没有抛出任何错误，然后部署它。
结论
希望，正如您从用例及工作流中所了解到的，模型评估指标不足以确保您的模型为生产做好准备。您还需要对您的模型进行彻底的测试，以确保它们在现实世界中足够健壮。
为 ML 模型开发测试可以帮助团队系统地分析模型错误并检测故障模式，因此在将模型部署到生产环境之前制定并实现解决方案。
参考资料和资源*
在 AILS 实验室建立可扩展的医学 ML 研究工作流程[案例研究]
原文：https://web.archive.org/web/https://neptune.ai/blog/ml-research-workflow-case-study-ails-labs
ailslab 是一个生物医学信息学研究小组，致力于使人类更加健康。这个任务就是建造模型，也许有一天可以拯救你的心脏病。它归结为应用机器学习来基于临床、成像和遗传学数据预测心血管疾病的发展。
四名全职和五名以上兼职团队成员。生物信息学家、内科医生、计算机科学家，许多人都有望获得博士学位。正经事。
虽然业务可能是一个错误的术语，因为面向用户的应用程序还没有在路线图上，但研究是主要的焦点。研究如此激烈，以至于需要一个定制的基础设施(花了大约一年时间建造)来从不同类型的数据中提取特征:
- 电子健康记录(EHR)，
- 诊断和治疗信息(时间-事件回归方法)，
- 图像(卷积神经网络)，
- 结构化数据和心电图。
通过融合这些特征，精确的机器学习模型可以解决复杂的问题。在这种情况下，这是心血管一级预防的风险分层。本质上，它是关于预测哪些患者最有可能患心血管疾病。
ailslab 有一个彻底的研究过程。每个目标都有七个阶段:
- 定义要解决的任务(例如，建立心血管疾病的风险模型)。
- 定义任务目标(例如，定义预期的实验结果)。
- 准备数据集。
- 使用 Jupyter 笔记本以交互模式处理数据集；快速试验，找出任务和数据集的最佳特性，用 R 或 Python 编码。
- 一旦项目规模扩大，使用一个工作流管理系统，如 Snakemake 或 Prefect 将工作转化为一个可管理的管道，并使其可复制。否则，复制工作流程或比较不同模型的成本会很高。
- 使用 Pytorch Lightning 与 Neptune 集成创建机器学习模型，其中应用了一些初始评估。记录实验数据。
- 最后，评估模型性能并检查使用不同特征和超参数集的效果。
扩大机器学习研究的 5 个问题
ailslab 最初是一个由开发人员和研究人员组成的小组。一个人编写代码，另一个人审查代码。没有太多的实验。但是协作变得更具挑战性，随着新团队成员的到来，新问题开始出现:
- 数据隐私，
- 工作流程标准化，
- 特征和模型选择，
- 实验管理，
- 信息记录。
1.数据保密
数据收集需要很多时间。对于像这样的医学机器学习研究，很难获得足够的数据，甚至是未标记的数据。这是一个关键问题，使得建立通用模型变得困难。该解决方案涉及使用来自医院和医疗保健系统的受 NDA 保护的私有数据。
你不能把这么敏感的数据上传到远程服务器，所以你只能在本地训练模型。当您的团队运行许多实验并存储每个实验的信息时，这是一个令人痛苦的限制。
对于 ailslab 来说，在本地管理实验，比较不同的模型，甚至与他人分享结果变得更加困难。
2.工作流程标准化
有一段时间这是一个小得多的团队。尽管要处理大量的定制代码，但只有几个开发人员，管理这个项目还是很容易的。
“去年，我们建设了基础设施。我们开始开发时间-事件回归方法和几个特征提取器。目前，我们为成像数据建立类似 CNN 的模型，为 ECG 数据建立类似 TCN 的模型。我们有足够的自定义代码。现在的目标是每个月标准化一些东西。”–Jakob stein feldt，内科研究员@ailslab
没有理由太在意开发流程的结构化或标准化，也没有太多的代码检查在进行。
然而，新的开发人员不断加入团队，带来了不同风格的编码。对标准化代码开发解决方案的需求变得很明显。调试和跟踪每个团队成员编写的代码变得更加困难，因为没有清晰的过程。
3.特征和模型选择
这项研究的核心任务之一是使用时间-事件回归方法进行生存预测。这包括来自大型队列的观察数据，涉及详细的患者记录。
记录有不同的数据形式:
- 文字，
- 声音，
- 图像，
- 等等。
这带来了一个重大挑战:多模态学习。与只使用一种类型的模型相比，使用多种类型的数据构建模型更具挑战性。
例如，除了医学图像之外，患者的 EHR(电子健康记录)中可能还有上下文数据。诊断需要两者。
Metadata logged in Neptune | Click to enlarge the image
像长短期记忆(LSTM)这样的模型处理文本，而卷积神经网络(CNN)处理图像。每个模型都有不同的属性和发现。
为了进行更准确的诊断，可以将不同类型数据的发现结合起来。但是，正如 ailslab 的研究人员可以证明的那样，这造成了许多困难:
- 如何从不同的数据形态中提取有代表性的特征并融合它们？
- 对于所有数据形态来说，完成时间-事件预测这样的任务的最佳模型类型是什么？
- 哪些超参数最适合模型和数据？
回答这些问题需要大量的试错，比如生成不同的特征集来训练多个模型。但是还有另一个问题——比较由不同特征集训练的不同模型。
由于 ailslab 团队做了如此多的实验，有必要找到一种简单的方法来跟踪所有的工作，避免原地打转。否则，很难跟踪在不同版本的数据集及其特征上训练的所有模型。
4.实验管理
团队不断壮大，研究人员不断加入项目。他们中的一些人可能经验不足。你如何确保两个人不会误做同一项任务？
考虑这个场景:
二十名研究人员，在一名技术负责人的监督下，一起努力寻找同一问题的解决方案。每个人都以自己的方式设计解决方案，并向技术主管解释。反过来，技术主管会根据结果判断什么是正确的，什么是不正确的。
技术主管应该能够重新运行代码并重现良好的结果。超参数、特性和度量应该是清楚的。对于 ailslab 来说，像手动创建检查点，或者弄清楚如何更改一个或多个超参数来做另一个实验这样的任务简直就是浪费时间。
此外，学生有时会在有限的时间内参与项目。有必要跟踪和存储任何项目贡献者的实验数据，不管他们是否还在团队中。
“你可以在电子表格中记录你的工作，但这非常容易出错。每一个我不使用和事后不看的实验都是浪费计算:这对环境有害，对我也有害，因为我浪费了时间。”–索尔·bürgel，博士生@ailslab
5.信息记录
对于每个实验，需要记录一些信息，包括:
- 用于训练的 GPU，
- 模型架构，
- 像特征、端点、数据集日期、路径，
- 度量及其性能。
Monitoring in Neptune | Click to enlarge the image
这些记录的信息是每个实验的特征。它在分析和回答以下问题时非常方便:
- 该模型在不同的记录组上表现如何？
- 哪些功能或功能集最能预测端点？
- 特征对预测有什么影响？
使用自定义记录器，回答这些问题或全面比较不同的实验并不容易。构建定制的记录器会带来长期管理记录器和在必要时添加新功能的负担。当错误发生时，就有更多的时间来构建一个内部工具，而不是做研究。这是艾尔斯伯想要避免的。
有了 Neptune，扩大机器学习研究变得更加容易
我们描述的五个问题是由于扩大团队和增加实验数量而产生的。海王星在 PyTorch Lightning docs 中引起了他们的注意，并很快加入了他们的研究工具集。
"海王星的工作完美无缺，与 PyTorch Lightning 的整合非常顺利."–Jakob stein feldt，内科研究员@ailslab
为什么是海王星？它是如何帮助解决团队扩展中的五个问题的？请继续阅读，寻找答案。
艾尔斯伯为什么选择海王星
简而言之——因为它节省时间。
如果你是一名研究人员，你会知道管理多个实验是具有挑战性的。
电子表格只是在某个时候停止切割。如果您有数百个实验保存在电子表格中，您的本地机器或云服务器会很混乱。你可能永远也不会充分利用所有的实验信息。
你浪费更多的时间建立电子表格，然后你很少使用这些电子表格。你可以让 Neptune 收集并存储所有信息，而不是那样做。
你会看到你所有实验的综合历史，比较它们，选择哪些不值得保留。准备环境的开销更少，并且节省了时间。
数据保密
由于医疗数据特别敏感，有必要将数据工作流与分析工作流分开。
Neptune 不需要上传敏感数据，符合数据保护法。它只接收研究人员决定共享的记录信息，训练部分可以在本地机器或其他任何地方进行。它意味着最大限度的控制。数据始终是安全的，不存在数据泄露的风险。
“通过允许我们只在本地训练模型并记录 ML 元数据而不上传实际数据，Neptune 为我们解决了一个巨大的问题。”–Jakob stein feldt，内科研究员@ailslab
工作流程标准化
在大范围内，最好使用标准化的工具进行开发。没人能否认这一点。Neptune 对 ailslab 进行标准化研究，因为:
- 它支持使用标准库来构建模型，这比编写难以解释或调试的定制代码要容易得多。
- 通过完整的 PyTorch Lightning 集成，Neptune 提供了记录信息的标准化视图。您可以记录您喜欢的任何内容，Neptune 在一个简单的视图中处理所有信息。所有团队成员都使用相同的基础设施。
- 海王星统一了每个人展示结果的方式，所以沟通不畅的情况会更少。
“我们有许多学生，对我们研究的许多方面和我们使用的基础设施都不熟悉。这种设置为许多潜在问题创造了空间。海王星帮助我们沟通和避免这些问题。而不是讨论，我们可以只看超参数空间或者特征空间里的一切。很方便。”–Jakob stein feldt，内科研究员@ailslab
特征和模型选择
使用 Neptune，可以更容易地为模型选择最佳特征，因为它有多种方式来呈现和比较不同的实验:
- 有一个漂亮而简单的用户界面，具有类似弹性的搜索功能。
- 您可以在交互式图表中比较模型性能，并查看哪种模型最适合给定的一组功能。
- 当您选择参数进行比较时，除了评估指标之外，您还可以看到哪些功能最能描述一组记录。
模型性能(即预测准确性)很少是唯一的目标。ailslab 团队还关心所使用的资源。Neptune 测量硬件指标，以查看消耗了多少功率(RAM 或 GPU)来获得结果。
Metrics’ charts in Neptune | Click to enlarge the image
此外，海王星很容易扩展到数百万次实验。这意味着，即使在有许多活动部分和大量实验的多模态学习的情况下，跟踪所有这些仍然是方便的。
实验管理
考虑到不同的用户对同一个项目做出贡献，Neptune 在管理来自不同研究人员的贡献方面起着关键作用。它使得监督研究人员和比较他们的实验变得容易得多，而且这一切都发生在一个仪表板上。
“所以我要说，使用 Neptune 的主要理由是，你可以确保没有任何东西丢失，一切都是透明的，我可以随时回到历史中进行比较。”–索尔·bürgel，博士生@ailslab
组织实验不再是一个问题，因为海王星做得很优雅。此外，海王星版本的数据更好地控制实验。
信息记录
海王星可以分组实验进行对比。很容易得到一个链接，与另一个研究人员或利益相关者分享结果。即使研究人员或学生离开项目，不再有空，他们实验的所有信息都会保存下来。
作为一个日志记录器和元数据存储库，Neptune 有一个记录每个实验的自动化流程。它有一个 API，让研究人员毫不费力地记录他们的结果。团队的所有成员都可以看到所有实验，这使得整个项目变得透明。
海王星——更多的时间用于 ML，更容易的合作，完全透明
海王星最突出的两点是:
- 易用性，
- 所有东西都放在一个地方。
与使用定制的日志程序相比，Neptune 可以处理所有的事情，并且团队有更多的时间来完成研究任务。Neptune 简单的用户界面使构建和比较实验变得前所未有的简单。
ailslab 研究人员现在使用一个平台，他们的结果以同样的方式呈现。监督他们的工作更容易，即使他们只是短期工作，或者没有向他人展示成果的经验。比较不同研究者使用的数据参数不再是问题。它减少了犯错的空间。
比较和管理实验也需要更少的时间。研究人员可以在实验历史之间来回切换，做出改变，并观察这些改变如何影响结果。完成的实验越多，工作效率就越高。团队成员只需登录 Neptune，就可以查看所有必要的数据，而不会让他们的驱动器或服务器堆满电子表格。
Runs view in Neptune | Click to enlarge the image
构建复杂的模型并探索它们是如何工作的变得更加容易了。Neptune 存储关于环境设置、底层代码和模型架构的数据。
最后，海王星帮助组织事情。在 ailslab 中，他们将 Neptune 的实验 URL 添加到他们的看板中的卡片上。实验信息的便捷获取有助于保持一切井然有序。整个团队对超参数对模型的影响有了更好的认识。
机器学习很难。建立 ML 模型以在心脏病发生前检测它增加了另一层非常厚的困难。我们很高兴海王星带走了 ailslab 项目的乏味部分，我们祝愿他们在研究中一切顺利。
如何使您的 MLflow 项目易于共享和协作
原文：https://web.archive.org/web/https://neptune.ai/blog/mlflow-projects-easy-to-share-and-collaborate-on
如果您使用 MLflow，您将会大开眼界！因为，在本文中，您将看到如何使您的 MLflow 项目更容易共享，并实现与您的队友的无缝协作。
为你的机器学习项目创建一个无缝的工作流程是极具挑战性的。
典型的机器学习生命周期包括:
- 数据收集+预处理
- 根据数据训练模型
- 将模型部署到生产中
- 测试+用新数据改进模型
这四个步骤看起来相当简单，但是每一层都有新的障碍。您可能需要为每个步骤使用不同的工具——Kafka 用于数据准备，Tensorflow 作为模型训练框架，Kubernetes 作为部署环境，等等。
每次使用新工具时，您都必须重复整个过程，可能是通过 Scikit-learn 运行相同的漏斗并部署到 Amazon SageMaker。随着 API 和组织的扩张，这显然是不可持续的。
另外，调整超参数对于创建一个非凡的模型是至关重要的；应该有超参数历史、源代码、性能指标、日期、人员等的完整记录。机器学习生命周期可能是一个令人生畏的平台开发挑战:你应该能够轻松地复制、重新访问和部署你的工作流到生产中，你还需要一个标准化生命周期的平台。
幸运的是，有 MLflow，这是一个很棒的开源解决方案，围绕 3 个支柱构建:跟踪、项目和模型。
围绕您的模型创建一个广泛的日志框架，分配特定的指标来比较运行。
创建一个 MLflow 管道来确定模型如何在云上运行。
以标准格式打包您的机器学习模型，以便在各种下游工具中使用。比如用 REST API 实时服务，或者用 Apache Spark 批量推理。
MLflow 为大型组织提供了可再现性和可扩展性。相同的模型可以在云中、本地或笔记本中执行。您可以使用任何 ML 库、算法、部署工具或语言，也可以添加和共享以前的代码。
但是，有些东西是 MLflow 没有的:一种简单的组织工作和协作的方式。
您需要托管 MLflow 服务器，精心组织团队成员访问，存储备份，等等。再加上 MLflow 的 UI，让你对比实验的 MLflow 追踪模块一点都不好用，尤其是大型团队。
不要担心！我们可以用海王 AI 来解决这个问题。
Neptune 的直观 UI 让你跟踪实验并与队友合作，同时也让你最喜欢的部分远离 MLflow。
Neptune 和 MLflow 集成简介
Neptune 是一个轻量级的 ML 实验管理工具。它灵活且易于与所有类型的工作流集成。您的队友可以使用不同的 ML 库和平台，共享结果，并与 Neptune 在单个仪表板上协作。您甚至可以使用他们的 web 平台，这样您就不必在自己的硬件上部署它。
海王星的主要特征是:
- 实验管理:跟踪你团队的所有实验，并对它们进行标记、过滤、分组、排序和比较
- 笔记本版本和区分:比较两个笔记本或同一笔记本中的检查点；与源代码类似，您可以进行并排比较
- 团队协作:添加评论，提及队友，比较实验结果
️ 海王 vs ml flow——他们有什么不同？
Neptune 和 MLflow 可以通过一个简单的命令进行集成:
neptune mlflow
现在，你可以把所有这些 MLrun 物体推向海王星实验:
- 实验 id +名称
- 运行 id +名称
- 韵律学
- 因素
- 史前古器物
- 标签
与 Neptune 的组织和协作
现在，让我们来看看您将如何通过 Neptune 漂亮直观的用户界面分享和协作 MLflow 的实验。
Neptune 设置(如果您已经有一个 Neptune 帐户，请跳过)
1.先注册一个海王 AI 账号。它对个人和非组织都是免费的，你可以获得 100 GB 的存储空间。
2.通过点击右上角的菜单获取您的 API 令牌。
- 创建一个 NEPTUNE_API_TOKEN 环境变量，并在控制台中运行它。
export NEPTUNE_API_TOKEN=’your_api_token’
4.创建一个项目。在您的项目仪表板中，单击“新建项目”并填写以下信息。注意隐私设置！
同步 Neptune 和 MLflow
首先安装 Neptune-MLflow:
pip install neptune-mlflow
接下来，将 NEPTUNE_PROJECT 变量设置为用户名/项目名:
export NEPTUNE_PROJECT=USER_NAME/PROJECT_NAME
最后，将您的 mlruns 目录与 Neptune 同步:
neptune mlflow
与海王星合作
您的实验元数据现在应该存储在 Neptune 中，您可以在您的实验仪表板中查看它:
您可以通过添加标签和使用自定义过滤器对实验进行分组来自定义仪表板。
Neptune 让你只需发送一个链接就可以分享 ML 实验。它可以是:
Neptune 还带有工作区，一个你可以管理项目、用户和订阅的中心枢纽；有个人和团队工作空间。
在团队工作区中，团队成员可以浏览与其分配的角色相关的内容。您可以在项目和工作区中分配各种角色。在团队工作区中，您可以邀请管理员或成员，每个人都有不同的权限。
可以在顶栏上的工作区名称中更改工作区设置:
在概述、项目、人员和订阅选项卡下，您可以看到工作场所设置:
项目中有三个角色:所有者、贡献者和查看者。根据角色的不同，用户可以运行实验、创建笔记本、修改以前存储的数据等。
更多详情参见- > 用户管理
了解更多关于海王星的信息
如您所见，MLflow 和 Neptune 并不相互排斥。您可以从 MLflow 中保留您最喜欢的功能，同时使用 Neptune 作为管理您的实验并与您的团队合作的中心位置。
如果你想了解更多关于 Neptune 的知识，请查阅官方文档。如果你想尝试一下，创建你的账户，开始用 Neptune 跟踪你的机器学习实验。
MLflow vs Kubeflow vs neptune.ai:有什么区别？
原文：https://web.archive.org/web/https://neptune.ai/blog/mlflow-vs-kubeflow-vs-neptune-differences
作为一名数据科学家、ML/DL 研究人员或工程师，您可能会遇到或听说过 MLflow、Kubeflow 和 neptune.ai。由于 ML 和 DL 的大量采用，围绕部署、可伸缩性和可再现性出现了许多问题。因此，MLOps 作为数据工程、DevOps 和机器学习的混合体而诞生。
我们必须为 ML 想出这种新的方法，因为 ML 开发是复杂的。
很自然的问题是为什么？
很自然的，你可能会认为是因为数学，算法，需要的资源(GPU，TPUs，CPUs)，数据，API，库，框架。嗯，有一部分是真的，但不完全是，因为现在大部分都被我们抽象化了。如果我们以拥抱脸或 fast.ai 为例，你只需调用一个特定类的实例，框架/库就会帮你完成所有繁重的工作。再者，随着 迁移学习 的发展，我们不再需要海量的数据来训练一个模型。
那么复杂性从何而来？
复杂性来自几个方面:
- ML 本质上是实验性的
- 它有更多的部分需要考虑，例如:数据(收集、标记、版本化)、模型(培训、评估、版本化和部署)和配置(超参数等等)。
- 我们如何进行传统软件开发(DevOps)的范式不同于我们如何进行 ML (MLOps)。
随着 MLOps 的成熟，许多工具已经出现并正在出现，以解决工作流的不同部分，这三个工具在 MLOps 工作流中发挥着关键作用，以降低复杂性并解决我们将在后面的章节中讨论的问题。
现在，他们到底是做什么的，他们是如何相互比较的？
在这篇文章中，我们将回答这些问题，甚至更多。以下是我们正在解决的问题:
- 工具
- MLflow
- 库贝弗洛
- neptune.ai
- 你应该在什么时候使用哪一个？
- 高级功能对照表
让我们开始吧！
MLflow
这是一个开源 MLOps 平台，它诞生于学习大技术的标准，专注于创建可转移的知识、易用性、模块化以及与流行的 ML 库和框架的兼容性。它是为 1 人或 1000 多人的组织设计的。
MLFlow 允许您在本地或远程开发、跟踪(和比较实验)、打包和部署。它处理从数据版本化、模型管理、实验跟踪到部署的所有事情，除了数据源、标签和流水线。
它几乎是 MLOps 工作流程的万金油和/或瑞士刀。
该平台由 4 个组件组成:
- 物流跟踪
- MLflow 项目
- ml 流程模型
- 只是模型注册表
让我们更深入地了解这些组件中每一个的重要性以及它们是如何工作的。
物流跟踪
MLflow 跟踪组件是一个 API 和 UI，用于在运行机器学习代码时记录参数、代码版本、指标和输出文件，并在以后可视化和比较结果。MLflow Tracking 允许您使用 Python、REST、R API 和 Java API APIs 来记录和查询实验。
如前所述，MLFlow 允许本地或远程开发，因此实体和工件存储都是可定制的，这意味着您可以在本地或云上保存(AWS s3，GCP 等)
跟踪中的关键概念
- 参数:代码的键值输入
- 指标:数值(可以随时更新)
- 标签和注释:关于跑步的信息
- 工件:文件、数据和模型
- 来源:运行了什么代码？
- 版本:代码运行的版本是什么？
- Run:由 MLFlow 运行的代码实例，其中将记录度量和参数
跟踪 API
- 流畅的 MLFlow APIs(高级)
- MLFlow 客户端(低级)
MLflow 项目
MLflow 项目是一个独立的执行单元，包含以下内容:
- 密码
- 配置
- 属国
- 数据
将其部署在本地或远程服务器上。
这种格式有助于再现性，并允许创建具有单独项目(或同一项目中的入口点)作为单个步骤的多步骤工作流。
换句话说，MLflow 项目只是一个组织和描述代码的约定，以便让其他数据科学家(或自动化工具)运行它。每个项目只是一个文件目录，或者一个 Git 存储库，包含您的代码。MLflow 可以根据在此目录中放置文件的惯例运行一些项目(例如，conda.yaml 文件被视为 conda 环境)，但您可以通过添加 MLproject 文件来更详细地描述您的项目，该文件基本上是 yaml 格式的文本文件。
ml 流程模型
MLflow 模型是打包机器学习模型的标准格式，可用于各种下游工具，例如，通过 REST API 或 Apache Spark 上的批处理推理进行实时服务。该格式定义了一个约定，允许您以不同的“风格”保存模型，这些风格可以被不同的下游工具所理解。
口味是使 MLFlow 模型强大的关键概念:它们是部署工具可以用来理解模型的约定。基本上，我们通过创建一种中间格式来抽象模型，该格式将您想要部署到各种环境中的模型打包，就像模型的 docker 文件或 lambda 函数一样，您可以将它部署到所需的环境中，并调用其名为 predict 的评分函数。
模型注册表
MLflow 模型注册组件是一个集中式模型存储、一组 API 和 UI，用于协作管理 MLflow 模型的整个生命周期。它提供了模型沿袭(MLflow 实验和运行产生了模型)、模型版本化、阶段转换(例如从阶段转换到生产)和注释。
Kubeflow
Kubeflow 是一个开源项目，它利用 Kubernetes 构建可扩展的 MLOps 管道并编排复杂的工作流。您可以将其视为 Kubernetes 的机器学习(ML)工具包。
注 : Kubernetes(或简称 K8s)是一个容器编排工具。
现在，出现了两个问题:
- 为什么要容器化你的 ML 应用？
- 为什么 K8s 上的 ML？
为什么要将 ML 应用容器化
通常团队中不同的人所处的环境是不同的，这些差异可以延伸到:
- 依赖性(库、框架和版本)
- 代码(辅助功能、培训和评估)
- 配置(数据转换、网络架构、批量大小等)
- 软件和硬件
如果两个或两个以上的成员要合作或继承某人的工作并做出改进，这会导致各种各样的问题。
但是通过容器，你可以简单地发送一个 docker 镜像，只要对方在本地或者他的云环境中安装了 docker。他可以轻而易举地重现同样的环境、实验和结果。
集装箱的好处
-
包装:
- 密码
- 属国
- 配置
-
帮助创建 ML envs:
- 轻量级选手
- 轻便的
- 可攀登的
为什么 K8s 上的 ML？
正如我之前提到的，K8s 是一个容器编排工具。它实现了容器化应用程序的自动化部署、扩展和管理。但问题在于 k8s 本身的管理，它可能是 heptic。但是现在有不同的 k8s 即服务提供商，例如:AWS EKS、Google GKE 和 Azure AKS。
使用托管 k8s 作为服务，允许 ML 从业者充分利用 k8s 带来的好处，例如:
- 可组合性
- 轻便
- 可量测性
- 或者它已经是公司或团队工作流程的一部分
既然我们已经解决了这个问题，让我们更详细地看看 Kubeflow。
Kubeflow 组件
Kubeflow 由各种项目/工具组成，但这里我们将重点关注 4 个主要项目:
- 笔记本电脑
- 管道
- 培养
- 服务
笔记本
Kubeflow 包括创建和管理交互式 Jupyter 笔记本的服务。您可以自定义笔记本电脑部署和计算资源，以满足您的数据科学需求。在本地试验您的工作流，然后在准备就绪时将它们部署到云中。
管道
这可能是最著名的项目，也是很多团队选择 kubeflow 的原因。简而言之，kubeflow pipelines 是一个基于 Docker 容器构建和部署可移植、可扩展的机器学习(ML)工作流的平台——它可作为 kubeflow 组件或独立安装使用。
该项目的核心是两个部分:
- Pipeline–是对 ML 工作流的描述，包括工作流中的所有组件以及它们如何以图表的形式组合在一起。管道包括运行管道所需的输入(参数)以及每个管道组件的输入和输出的定义。
- 管道组件–是一组独立的用户代码，打包成 Docker 映像，执行管道中的一个步骤。例如，一个组件可以负责数据预处理、数据转换、模型训练等等。
管道特征
- 用于管理和跟踪实验、作业和运行的用户界面(UI)。
- 用于安排多步骤 ML 工作流的引擎。
- 用于定义和操作管道和组件的 SDK。
- 使用 SDK 与系统交互的笔记本电脑。
- 可重用性:使您能够重用组件和管道，而不必每次都重新构建。
训练
该项目为您提供了不同的培训 ML 模型框架，例如:
- 链式训练
- MPI 培训
- MXNet 培训
- PyTorch 培训
- 作业调度
- 张量流训练(TFJob)
在这里，您可以执行培训工作，监控培训和更多。其中一个很酷的特性实际上是能够容易地定义和利用 kubernetes 副本，它允许您旋转容器映像的多个相同版本。因此，如果一个或多个副本在培训作业期间失败，您的进度不会完全丢失，因为您有另一个版本在并行运行。
上菜
说到服务模型，kubeflow 提供了很大的支持。
Kubeflow 有一个名为 KFServing 的组件，它支持 Kubernetes 上的无服务器推理，并为 TensorFlow、XGBoost、scikit-learn、PyTorch 和 ONNX 等常见机器学习(ML)框架提供高性能、高抽象的接口，以解决生产模型服务用例。
KFServing 可用于以下目的:
- 为在任意框架上服务 ML 模型提供 Kubernetes 定制资源定义。
- 封装自动扩展、网络、健康检查和服务器配置的复杂性，为您的 ML 部署带来尖端的服务功能，如 GPU 自动扩展、零扩展和 canary 部署。
- 通过提供现成的预测、预处理、后处理和可解释性，为您的生产 ML 推理服务器提供一个简单、可插入和完整的故事。
此外，除了 KFserving，Kubeflow 还支持 TensorFlow 服务容器将训练好的 TensorFlow 模型导出到 Kubernetes。它还与 Seldon Core(一个用于在 Kubernetes 上部署机器学习模型的开源平台)和 NVIDIA Triton Inference Server 集成，以便在大规模部署 ML/DL 模型时最大化 GPU 利用率。最后，它还支持 BentoML ，这是一个用于高性能 ML 模型服务的开源平台。它使得为您的 ML 模型构建生产 API 端点变得容易，并支持所有主要的机器学习培训框架，包括 Tensorflow、Keras、PyTorch、XGBoost、scikit-learn 等
但这并没有结束，除此之外，你还可以在 Kubernetes Engine 和 AWS、GCP 或 Azure 上运行 Kubeflow。以 AWS 为例，Kubeflow 与 AWS Sagemaker 进行了集成，允许您充分利用这种托管服务带来的规模优势。
在我看来，我不认为端到端的 ML 平台是一条出路。更多细节你可以稍后阅读这篇 文章 我会详细解释，一旦你完成这篇文章。
我相信微服务可以让您更加灵活地将任何新服务插入到您的管道中，或者替换损坏的服务/组件或工具，但 kubeflow 和这些不同的云提供商等集成可以让您构建更强大的解决方案。
neptune.ai
neptune.ai 是 MLOps 的元数据存储，为运行大量实验的研究和生产团队而构建。
它为您提供了一个中心位置来记录、存储、显示、组织、比较和查询机器学习生命周期中生成的所有元数据。
成千上万的 ML 工程师和研究人员使用 Neptune 进行实验跟踪和模型注册，无论是作为个人还是在大型组织的团队内部。
现在，可能会出现一个问题:为什么是元数据存储？
为什么是元数据存储？
与 notes、组织协议或开源工具不同，正如我之前提到的，元数据存储是一个集中的地方，但它也是轻量级的、自动的，并由组织(在这种情况下是 Neptune)或社区维护，因此人们可以专注于实际做 ML 而不是元数据簿记。
此外，元数据存储是作为 MLOps 工作流的不同部分/阶段/工具之间的连接器的工具。
元数据存储的好处
- 记录和显示所有元数据类型，包括参数、图像、HTML、音频、视频
- 在仪表板中组织和比较实验
- 观看模型训练直播
- 让别人(不是你)来维护和备份它(元数据存储)
- 无需额外努力即可调试和比较实验和模型
- 数据库和仪表板都可以通过数千次实验进行扩展
- 帮助简化从研究到生产的过渡
- 在其基础上轻松构建定制库/工具
既然我们已经解决了这个问题，让我们更详细地看看海王星。
海王星组件
海王星由 3 个主要部件组成:
- 数据版本化
- 实验跟踪
- 模型注册表
数据版本化
版本控制系统帮助开发人员管理源代码的变更。而数据版本控制是一组工具和过程，其试图使版本控制过程适应数据世界，以管理与数据集相关的模型的改变，反之亦然。换句话说，该功能有助于跟踪我们用来训练模型的特定版本的数据集或数据集的子集，从而实现并促进实验的可重复性。
借助 Neptun e 中的数据版本功能，您可以:
- 在使用工件的模型训练运行中跟踪数据集版本
- 查询以前运行的数据集版本，以确保您在相同的数据集版本上进行训练
- 根据训练的数据集版本对 Neptune 跑步进行分组
实验跟踪
海王星的这个特性帮助你在一个地方组织你的 ML 实验:
- 记录和显示度量、参数、图像和其他 ML 元数据
- 无需额外努力即可搜索、分组和比较实验
- 在实验运行时实时可视化和调试实验
- 通过发送持久链接来共享结果
- 以编程方式查询实验元数据
模型注册表
这个特性允许您通过在中央模型注册中心中组织您的模型来控制您的模型开发，使它们可重复和可追踪。
这意味着您可以在模型开发到部署的过程中对模型进行版本化、存储、组织和查询。保存的元数据包括:
- 数据集、代码、环境配置版本
- 参数和评估指标
- 模型二进制文件、描述和其他细节
- 测试集预测预览和模型解释
此外，它还使地理位置接近或远离的团队能够在实验中进行协作，因为您的团队记录到 Neptune 的所有内容都可以被每个团队成员自动访问。所以再现性不再是问题。
您可以通过 API 访问模型训练运行信息，如代码、参数、模型二进制文件或其他对象。
使用 Neptune，您可以用一个真实的来源来代替文件夹结构、电子表格和命名约定，在这个来源中，您的所有模型构建元数据都是有组织的，易于查找、共享和查询。
该工具通过记录模型开发过程中发生的所有事情，让您能够控制模型和实验。
这相当于减少了寻找配置和文件、上下文切换、非生产性会议所花费的时间，并将更多时间用于高质量的 ML 工作。有了 Neptune，您不必实现记录器、维护数据库或仪表板，或者教人们如何使用它们。
通过跟踪你已经尝试过的所有想法以及你使用了多少资源，你可以充分利用你的计算资源。实时监控您的 ML 运行，并在运行失败或模型停止收敛时快速做出反应。
最后，Neptune 允许您通过对所有的模型训练运行进行版本化来构建可再现的、兼容的和可追踪的模型，并且还允许您知道谁构建了生产模型，使用了哪些数据集和参数，以及它在任何时候是如何执行的。
现在，只要告诉我哪一个和什么时候使用它
MLflow
如果您想要一个由开源社区支持的 MLOps 平台，它允许您:
- 跟踪、可视化和比较实验元数据
- 允许您可视化和比较实验结果的用户界面
- 开发(打包和部署)模型
- 允许您创建多步骤工作流的平台(很像 Kubeflow 管道，但不使用容器)
以及一种抽象模型的方法，从而可以轻松地将其部署到各种环境中，那么 MLflow 就是一种方法。
Kubeflow
如果您想要一个端到端开源平台，让您能够:
- 管理和设置不同团队的资源配额，以及在本地或云中编码、运行和跟踪实验元数据
- 能够使用跨越整个 ML 生命周期(从数据收集一直到模型构建和部署)的组件构建可重复的管道，那么 kubeflow 就是一条路
- 允许您可视化管道和实验元数据以及比较实验结果的 UI。
- 内置笔记本服务器服务
最后，您的 K8s 环境可能资源有限，但 K8s 和 kubeflow 都与 AWS Sagemaker 集成，支持从 Kubernetes 或 Kubeflow 本机跨 ML 工作流使用完全托管的 Sagemaker ML 工具，这意味着您可以利用它的功能来扩展资源(即 GPU 实例)和服务(即 Sagemaker 地面真相、模型监视器等)。
这消除了您手动管理和优化基于 Kubernetes 的 ML 基础设施的需要，同时仍然保持对编排和灵活性的控制。
neptune.ai
如果你想要集中的地方:
- 存储所有元数据(数据版本、实验跟踪和模型注册)
- 它具有直观且可定制的用户界面，允许您可视化和比较实验结果，并按照您的意愿排列显示的数据
- 拥有一个项目 wiki，有助于分享关于项目进度、运行和数据探索笔记本的报告、见解和评论
- 笔记本检查点(用于 Jupyter)
- 它可以与业界大多数最佳工具以及 MLOps 平台轻松无缝地集成
- 例如，Neptune 集成了 MLflow 和许多其他库、工具和 ML/DL 框架。
- 如果集成不可用，您可以将其添加到笔记本中。py 项目或容器化的 ML 项目(如果您使用的是 Kubernetes 或 Kubeflow ),由您喜欢的库、工具和框架提供支持，例如使用 python 客户端的 Pytorch。
最后，如果您想要一个完全托管的服务，或者如果您想要更多的控制，有服务器版本，那么 Neptune 是一个不错的选择。
高级功能对照表
| MLflow | Kubeflow | neptune.ai | |
|---|---|---|---|
对个人免费，非营利和教育研究
对团队付费
|
| | | | |
| | |
有一条学习曲线
| |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
结论
最终，选择权在你手中，这取决于你的要求和需求，但我想让你知道，这不是一个非此即彼的情况。这些工具并不互相排斥，您可以根据自己的需求和愿望混合搭配它们。
它可以是 Kubeflow 与 MLflow 或 Kubeflow 与 neptune.ai 以及 MLflow 与 neptune.ai。
让我详细说明一下，例如 Kubeflow 和 MLflow 或 Kubeflow 和 Neptune，在这两种情况下，Kubeflow 可能没有直接集成，但您可以将 MLflow 或 Neptune 添加到管道组件(也称为容器化应用程序)。
现在当涉及到 MLflow 和海王星的时候就容易多了，因为海王星和 MLflow 是一体的。
因此，您不会只使用一种工具。
我们已经兜了一圈，下面是一大堆参考资料供你查阅和消化。玩得开心！
谢谢大家！
参考文献
MLflow(流动)
忽必烈忽必烈忽必烈忽必烈忽必烈忽必烈忽必烈忽必烈忽必烈忽必烈忽必烈忽必烈忽必烈忽必烈忽必烈忽必烈
海王星啊
neptune.ai
MLflow vs TensorBoard vs Neptune:有什么区别？
你看到无穷无尽的列和行，随机的颜色，不知道在哪里找到任何值？啊，美丽混乱的实验数据表。机器学习开发者不应该经历这种痛苦。
在电子表格中跟踪和管理无数的变量和工件令人疲惫不堪。您必须手动处理:
- 参数:超参数，模型架构，训练算法
- 作业:预处理作业、培训作业、后处理作业—这些作业消耗其他基础架构资源，如计算、网络和存储
- 工件:训练脚本、依赖项、数据集、检查点、训练模型
- 指标:训练和评估准确性，损失
- 调试数据:权重、偏差、梯度、损耗、优化器状态
- 元数据:实验、试验和作业名称、作业参数(CPU、GPU 和实例类型)、工件位置(例如 S3 桶)
从长远来看，切换到专用的实验跟踪工具是不可避免的。如果你已经在考虑哪种工具适合你，今天我们将比较 Neptune、Tensorboard 和 MLflow。以下是您将在本文中发现的内容:
- 快速概述 MLflow、Tensorboard、Neptune 以及它们的功能；
- 比较 MLflow、Tensorboard、Neptune 特征的详细图表；
- 当海王星是比 MLflow 和 Tensorboard 更好的替代方案；
- 海王星如何与 MLflow 和 Tensorboard 集成。
MLflow、TensorBoard 和 Neptune 的快速概述
尽管您可以使用这三种工具来解决类似的问题，但是根据您的使用情况，它们的差异可能非常重要。
在 海王 中，你可以追踪机器学习实验，记录度量，性能图表，视频，音频，文字，记录数据探索，有机的组织团队合作。Neptune 速度很快，您可以自定义 UI，并在本地环境或云环境中管理用户。管理用户权限和对项目的访问轻而易举。它监控硬件资源消耗，因此您可以优化您的代码以有效地使用硬件。
Neptune 具有广泛的框架集成，因此集成您的 ML 模型、代码库和工作流不会有问题。它是按比例构建的，因此您的实验不会有太大的问题。
MLflow 是一个开源平台，通过跟踪实验来管理您的 ML 生命周期，提供可在任何平台上重复运行的打包格式，并将模型发送到您选择的部署工具。您可以记录运行，将它们组织到实验中，并使用 MLflow tracking API 和 UI 记录其他数据。
另一方面是专门从事视觉化。您可以跟踪包括损失和准确性在内的指标，并可视化模型图。Tensorboard 允许您查看权重、偏差或其他张量的直方图、项目嵌入，并且您可以合并描述图像、文本和音频。
**### 比较 MLflow、TensorBoard 和 Neptune 特性的详细图表
Neptune 在实验跟踪、框架和团队协作方面的灵活性，使其高于 MLflow 和 Tensorboard。
| MLflow | 海王星 | 张量板 | |
|---|---|---|---|
——个人免费，
非盈利及教育研究团队:
| |
| | | | |
|
实验跟踪功能
|
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| |
|
规模达到百万次运行
| | | |
| | | | |
| |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
| | | | |
当海王星是比 MLflow 和 TensorBoard 更好的选择时
让我们来探索当你想要选择海王星而不是 MLflow 和 TensorBoard 的情况。稍后，您还将看到这三个工具可以一起使用，为您提供一个丰富的环境来满足您所有的 ML 实验需求。
哪个工具的可视化仪表板最容易为您的整个团队设置？
在 Neptune 中，您可以通过在托管服务器上备份或本地安装来保存实验数据。您可以轻松共享实验，无需任何开销。
说到 TensorBoard 和 MLflow，他们在本地存储和跟踪实验。他们的用户管理和团队设置能力非常有限，所以我绝对推荐 Neptune 用于大型协作项目。
可以在 MLflow 和 TensorBoard 中管理用户权限吗？
在 MLflow 和 TensorBoard 中协作非常有限。在 Neptune 中，你拥有对用户和访问权限的完全控制权。有三种用户规则:管理员、贡献者或查看者。
您可以通过电子邮件邀请轻松添加团队成员:
MLflow 和 TensorBoard 上千跑快吗？
Neptune 是按比例构建的，以便支持前端和后端的数百万次实验运行。
MLflow 作为一个开源工具，并不是最快的工具；尤其是运行了 100 次或 1000 次之后，UI 会变得滞后。TensorBoard 是一个可视化工具包，它远没有 Neptune 快。
可以在 MLflow 和 TensorBoard 中保存不同的实验仪表板视图吗？
TensorBoard 和 MLflow 最适合个人工作，具有本地存储和本地 UI/仪表板。对于多用户(多租户)，这很快就会变得不舒服。
团队成员可以对如何设计实验仪表板有不同的想法。在 Neptune 中，每个人都可以随心所欲地定制、更改和保存实验仪表板视图。
能否在 MLflow 和 TensorBoard 中获取硬件指标？
不多。TensorBoard Profile 确实分析了代码的执行，但只针对当前运行。但是在 Neptune 中，您可以持续监控硬件和资源消耗(CPU、GPU、内存),同时训练您的模型。有了这些数据，您可以优化您的代码，以最大限度地利用您的硬件。
这些数据是自动生成的，您可以在 UI 的 monitoring 部分找到它:
在 MLflow 和 TensorBoard 中记录图像和图表有多容易？
现在，您可以在 UI“日志”部分的“预测”选项卡中浏览您的图像。
您甚至可以通过 neptunecontrib.api.log_chart 记录将在 UI 中交互呈现的交互式图表。
MLflow 和 TensorBoard 会自动给你的 Jupyter 笔记本拍快照吗？
Neptune 与 Jupyter 笔记本集成，因此无论何时运行包含neptune.create_experiment()的单元格，您都可以自动拍摄快照。
不管您是否提交您的实验，所有的东西都将被安全地版本化，并准备好被探索。
你能用 MLflow 和 TensorBoard 追踪一个解释性分析吗？
在海王星，你可以版本化你的探索性数据分析或结果探索。保存在 Neptune 中后，您可以命名、共享和下载，或者在您的笔记本检查点中查看差异。
使用 Neptune，您可以自动将图像和图表记录到多个图像通道，浏览它们以查看模型训练的进度，并更好地了解训练和验证循环中发生的事情。
要将一个或多个图像记录到日志部分，您只需:
neptune.log_image('predictions', image)
for image in validation_predications:
neptune.log_image('predictions', image)
MLflow 和 TensorBoard 允许你直接把你的实验仪表板拿到熊猫数据框吗？
mlflow.serach_runs()API 返回熊猫数据帧中的 mlflow 运行。
海王星允许你获取你或你的队友追踪和探索的任何信息。HiPlot 集成等探索性特性将帮助您做到这一点。
neptune.init('USERNAME/example-project')
make_parallel_coordinates_plot(
metrics= ['eval_accuracy', 'eval_loss',...],
params = ['activation', 'batch_size',...])
与 MLflow 的 Neptune 集成
正如我们之前提到的，MLflow 的一个缺点是，您不能轻松地共享实验，也不能就它们进行协作。
为了增加组织和协作，您需要托管 MLflow 服务器，确认正确的人可以访问，存储备份，并通过其他环节。
实验对比界面有点欠缺，尤其是团队项目。
但是你可以把它和海王星结合起来。这样，您可以使用 MLflow 接口来跟踪实验，将 runs 文件夹与 Neptune 同步，然后享受 Neptune 灵活的 UI。
您不需要备份 mlruns 文件夹或在专用服务器上启动 MLflow UI 仪表板。多亏了海王星，你的 MLflow 实验将被自动托管、备份、组织并支持团队合作。
将工作流程从:
mlflow ui
收件人:
neptune mlflow
你可以像平常一样做任何事情。
海王星与张量板集成
您还可以将 Neptune 与 TensorBoard 集成，让您的 TensorBoard 可视化托管在 Neptune 中，将您的 TensorBoard 日志直接转换为 Neptune 实验，并即时记录主要指标。
首先，安装库:
pip install neptune - tensorboard
在用 Tensorboard 日志创建了一个简单的训练脚本并初始化 Neptune 之后，您可以用两行简单的代码进行集成:
import neptune_tensorboard as neptune_tb
neptune_tb.integrate_with_tensorflow()
一定要创建实验！
with neptune.create_experiment(name=RUN_NAME, params=PARAMS):
现在，你的实验将被记录到海王星，你也可以享受团队协作的功能。
了解有关海王星的更多信息…
如您所见，这些工具并不一定相互排斥。您可以从 MLflow 和 TensorBoard 的喜爱功能中受益，同时使用 Neptune 作为管理您的实验并与您的团队合作的中心位置。
你想更多地了解海王星吗？
你想马上开始追踪你的实验吗？
快乐实验！
Happy experimenting!**
MLOps:你应该知道的 10 个最佳实践
原文：https://web.archive.org/web/https://neptune.ai/blog/mlops-10-best-practices
“……开发和部署 ML 系统相对来说既快又便宜，但是随着时间的推移对它们进行维护既困难又昂贵。”–d . Sculley 等人，“机器学习系统中隐藏的技术债务，NIPS 2015
每一位数据科学家都会认同这句话。也许你在寻找解决机器学习系统的许多移动部分之一的问题时遇到过它:数据、模型或代码。
拼凑一个解决方案通常意味着招致技术债务，这种债务会随着系统的老化和/或复杂性的增加而增加。更糟糕的是，您可能会损失时间、浪费计算资源并导致生产问题。
MLOps 可能令人生畏。成千上万的课程可以帮助工程师提高他们的机器学习技能。虽然开发一个模型来实现业务目标(项目分类或预测连续变量)并将其部署到生产中相对容易，但在生产中操作该模型会带来许多问题。
由于数据漂移等原因，模型性能在生产中可能会降低。您可能需要改变预处理技术。这意味着新的模型需要不断地投入生产，以解决性能下降的问题，或者提高模型的公平性。
除了持续集成和持续交付的 DevOps 实践之外，这需要持续的培训和持续的监控。因此，在本文中，我们将探索工程师需要的一些最佳实践，以一致地交付他们的组织所需的机器学习系统。
命名规格
命名约定并不新鲜。例如，Python 对命名约定的建议包含在PEP 8:Python 代码的样式指南中。随着机器学习系统的增长，变量的数量也在增长。
因此，如果你为你的项目建立了一个清晰的命名约定，工程师们将会理解不同变量的角色，并且随着项目复杂性的增加而遵循这个约定。
这种做法有助于缓解“改变一切就改变一切”( CACE)原则的挑战。这也有助于团队成员快速熟悉您的项目。这是一个构建 Azure 机器学习管道的项目的例子。
from azureml.pipeline.core import PipelineData
from azureml.pipeline.core import PipelineParameter
from azureml.pipeline.steps import PythonScriptStep
intermediate_data_name_merge = "merged_ibroka_data"
merged_ibroka_data = (PipelineData(intermediate_data_name_merge, datastore=blob_datastore)
.as_dataset()
.parse_parquet_files()
.register(name=intermediate_data_name_merge, create_new_version=True)
)
mergeDataStep = PythonScriptStep(name="Merge iBroka Data",
script_name="merge.py",
arguments=[
merged_ibroka_data,
"--input_client_data", intermediate_data_name_client,
"--input_transactions_data", intermediate_data_name_transactions
],
inputs=[cleansed_client_data.as_named_input(intermediate_data_name_client),
cleansed_transactions_data.as_named_input(intermediate_data_name_transactions)],
outputs=[merged_liko_data],
compute_target=aml_compute,
runconfig=aml_runconfig,
source_directory="scripts/",
allow_reuse=True
)
print("mergeDataStep created")
intermediate_data_name_featurize = "featurized_liko_data"
featurized_ibroka_data = (PipelineData(intermediate_data_name_featurize, datastore=blob_datastore)
.as_dataset()
.parse_parquet_files()
.register(name=intermediate_data_name_featurize, create_new_version=True)
)
featurizeDataStep = PythonScriptStep(name="Featurize iBroka Data",
script_name="featurize.py",
arguments=[
featurized_liko_data,
"--input_merged_data", intermediate_data_name_merge,
],
inputs=[merged_liko_data.as_named_input(intermediate_data_name_merge)],
outputs=[featurized_liko_data],
compute_target=aml_compute,
runconfig=aml_runconfig,
source_directory="scripts/",
allow_reuse=True
)
print("featurizeDataStep created")
这里，流水线的两个步骤的中间输出被命名为中间 _ 数据 _ 名称 _ 合并和中间 _ 数据 _ 名称 _ 特征化。它们遵循易于识别的命名惯例。
如果在项目的另一个方面遇到了另一个这样的变量，比如说intermediate _ data _ name _ clean，这种命名约定可以很容易地理解它在更大的项目中所扮演的角色。
代码质量检查
Alexander Van Tol 关于代码质量的文章提出了高质量代码的三个合意标识:
- 它做它应该做的事情
- 它不包含缺陷或问题
- 易于阅读、维护和扩展
由于 CACE 原理，这三个标识符对于机器学习系统尤其重要。
通常，输入训练管道的真实世界数据中没有明确包含结果变量。例如，设想一个包含订阅事务的 SQL 数据库。可能没有说明特定订阅是否被续订的列。但是，很容易查看后续交易，并了解所述订阅是否在到期时终止。
这种结果变量的计算可以发生在训练流水线的一个步骤中。如果执行这种计算的函数有任何问题，模型将被拟合到错误的训练数据上，并且在生产中不会做得很好。代码质量检查(在这种情况下是单元测试)让像这样的关键功能做它们应该做的事情。
然而，代码质量检查超越了单元测试。您的团队将从使用 linters 和 formatters 在您的机器学习项目中强制执行特定的代码风格中受益。这样，您可以在 bug 进入产品之前将其消除，检测代码气味(死代码、重复代码等)。)，并加快代码审核速度。这对您的 CI 流程是一个促进。
将这种代码质量检查作为 pull 请求触发的管道的第一步是一个很好的实践。你可以在带有 AzureML 模板项目的 MLOps 中看到这样的例子。如果你想让棉绒成为一个团队，这里有一篇很棒的文章可以帮助你开始——棉绒不会妨碍你。他们站在你这边
实验——并跟踪您的实验！
特征工程、模型架构和超参数搜索都在不断发展。鉴于当前的技术状态和数据中不断发展的模式，ML 团队总是致力于交付尽可能最好的系统。
一方面，这意味着掌握最新的想法和基线。这也意味着尝试这些想法，看看它们是否能提高你的机器学习系统的性能。
实验可能包括尝试代码(预处理、训练和评估方法)、数据和超参数的不同组合。每一个独特的组合产生了你需要与你的其他实验进行比较的指标。此外，实验运行条件(环境)的变化可能会改变您获得的指标。
回忆什么提供了什么好处，什么有效，很快就会变得乏味。使用现代工具(海王星是一个伟大的！)当你尝试新的过程时，跟踪你的实验可以提高你的生产力，而且它使你的工作具有可重复性。
想入手实验用海王星跟踪？阅读本文—ML 实验跟踪:它是什么，为什么重要，以及如何实施。
视频
数据有效性
在生产中，数据可能会产生各种各样的问题。如果数据的统计属性不同于训练数据属性，则训练数据或采样过程是错误的。数据漂移可能会导致连续数据批次的统计属性发生变化。数据可能具有意外的特征，一些特征可能以错误的格式传递，或者像 Erick Breck 等人的论文中的例子一样，一个特征可能被错误地固定到特定值！
服务数据最终成为训练数据，因此检测数据中的错误对于 ML 模型的长期性能至关重要。一旦发现错误，你的团队就可以进行调查并采取适当的行动。
Pandera 是一个数据验证库，可以帮助你完成这项工作，以及其他复杂的统计验证，如假设检验。这里有一个使用 Pandera 定义的数据模式的例子。
import pandera as pa
from azureml.core import Run
run = Run.get_context(allow_offline=True)
if run.id.startswith("OfflineRun"):
import os
from azureml.core.dataset import Dataset
from azureml.core.workspace import Workspace
from dotenv import load_dotenv
load_dotenv()
ws = Workspace.from_config(path=os.getenv("AML_CONFIG_PATH"))
liko_data = Dataset.get_by_name("liko_data")
else:
liko_data = run.input_datasets["liko_data"]
df = liko_data.to_pandas_dataframe()
liko_data_schema = pa.DataFrameSchema({
"Id": pa.Column(pa.Int, nullable=False),
"AccountNo": pa.Column(pa.Bool, nullable=False),
"BVN": pa.Column(pa.Bool, nullable=True, required=False),
"IdentificationType": pa.Column(pa.String checks=pa.Check.isin([
"NIN", "Passport", "Driver's license"
]),
"Nationality": pa.Column(pa.String, pa.Check.isin([
"NG", "GH", "UG", "SA"
]),
"DateOfBirth": pa.Column(
pa.DateTime,
nullable=True,
checks=pa.Check.less_than_or_equal_to('2000-01-01')
),
"*_Risk": pa.Column(
pa.Float,
coerce=True,
regex=True
)
}, ordered=True, strict=True)
run.log_table("liko_data_schema", liko_data_schema)
run.parent.log_table("liko_data_schema", liko_data_schema)
该模式确保:
- Id 是一个整数，不能为空
- BVN 是一个布尔值，它可能在某些数据中不存在
- IdentificationType 是列出的四个选项之一
- 出生日期为空或小于“2000-01-01”
- 包含字符串“ _Risk ”的列包含可强制转换为 float dtype 的数据。
- 新数据的列顺序与该架构中定义的顺序相同。这可能很重要，例如，当使用 XGBoost API 时，可能会因为列顺序不匹配而引发错误。
- 此模式中未定义的列不能作为服务数据的一部分传递。
这个简单的模式在项目中构建了许多数据验证功能。然后，可以在下游步骤中应用定义的模式，如下所示。
liko_data_schema.validate(data_sample)
Tensorflow 还提供了全面的数据验证 API，这里记录了。
跨细分市场的模型验证
重用模型不同于重用软件。您需要调整模型以适应每个新的场景。为此，您需要培训渠道。模型也会随着时间而衰减，需要重新训练才能保持有用。
实验跟踪可以帮助我们处理模型的版本化和可再现性，但是在将模型提升到产品之前对其进行验证也是很重要的。
您可以离线或在线验证。离线验证包括在测试数据集上生成度量(例如，准确度、精确度、归一化均方根误差等)，以通过历史数据评估模型对业务目标的适合性。在做出促销决策之前，这些指标将与现有的生产/基准模型进行比较。
适当的实验跟踪和元数据管理为您提供了指向所有这些模型的指针，您可以无缝地进行回滚或升级。通过 A/B 测试进行在线验证，如本文的文章中所探讨的，然后在实时数据上建立模型的适当性能。
除此之外，您还应该在不同的数据段上验证模型的性能，以确保它们满足需求。业界越来越注意到机器学习系统可以从数据中学习的偏见。一个流行的例子是 Twitter 的图像裁剪功能，该功能被证明对于某些用户来说表现不佳。为不同的用户群验证模型的性能可以帮助您的团队检测并纠正这种类型的错误。
资源利用:记住你的实验是要花钱的
在培训期间和部署后的使用中，模型需要系统资源— CPU、GPU、I/O 和内存。了解您的系统在不同阶段的需求可以帮助您的团队优化您的实验成本并最大化您的预算。
这是一个经常受到关注的领域。公司关心利润，他们希望最大限度地利用资源来创造价值。云服务提供商也意识到了这一点。Sireesha Muppala 等人在他们的文章中分享了关于在 Amazon SageMaker 调试器中降低培训成本的考虑。微软 Azure 还允许工程师在使用 SDK 部署之前确定他们模型的资源需求。
这种分析使用提供的数据集测试模型，并报告资源需求的建议。因此，重要的是所提供的数据集能够代表模型投入生产时可能提供的服务。
剖析模型还提供了成本之外的其他优势。次优资源可能会降低培训工作的速度，或者给生产中的模型操作带来延迟。这些是机器学习团队必须快速识别和修复的瓶颈。
监控预测服务性能
到目前为止，上面列出的实践可以帮助您持续交付一个健壮的机器学习系统。在操作中，除了训练/服务数据和模型类型之外，还有其他指标决定您部署的模型的性能。可以说，这些指标与熟悉的项目指标(如 RMSE、AUC-ROC 等)一样重要。)来评估与业务目标相关的模型性能。
用户可能需要机器学习模型的实时输出，以确保能够快速做出决策。在这种情况下，监控运营指标至关重要，例如:
- 延迟:以毫秒为单位。用户能获得无缝体验吗？
- 可伸缩性:以每秒查询数(QPS)衡量。在预期延迟下，您的服务可以处理多少流量？
- 服务更新:在更新您的服务的基础模型的过程中引入了多少停机时间(服务不可用)？
例如，当时尚公司开展广告活动时，ML 推荐系统的不良服务性能会影响转化率。客户可能会对服务延迟感到失望，然后不再购买。这转化为商业损失。
Apache Bench 是 Apache 组织提供的一个工具，它允许您监控这些关键指标，并根据您组织的需求做出正确的规定。对于您的服务来说，跨不同地理位置测量这些指标非常重要。Austin Gunter 的用 Apache Benchmark 测量延迟和这个教程也是对这个有用工具的很好的介绍。
仔细考虑你选择的 ML 平台
MLOps 平台可能很难比较。尽管如此，你在这里的选择可以决定你的机器学习项目的成败。您的选择应基于以下信息:
- 你所拥有的团队:经验的水平；主题专家还是技术专家？
- 你的项目是用传统的机器学习还是深度学习。
- 您将使用的数据类型。
- 你的商业目标和预算。
- 技术需求，比如你的模型监控需要有多复杂。
- 该平台的特性以及从长远来看它们将如何发展。
在线上有一些 ML 平台的比较来指导你的选择，比如机器学习中的 12 大现场跟踪工具。海王星是讨论的平台之一。它使协作变得容易，并帮助团队管理和监控长期运行的实验，无论是在内部还是在 web UI 中。你可以在这里查看它的主要概念。
开放的通信线路很重要
长期实施和维护机器学习系统意味着各种专业人员之间的合作:数据工程师、数据科学家、机器学习工程师、数据可视化专家、DevOps 工程师和软件开发人员的团队。UX 设计师和产品经理也可以影响服务于您的系统的产品如何与用户交互。经理和企业所有者有控制如何评估和欣赏团队绩效的期望，而合规专业人员确保运营符合公司政策和法规要求。
如果您的机器学习系统要在不断发展的用户和数据模式及期望中不断实现业务目标，那么参与其创建、操作和监控的团队必须有效沟通。Srimram Narayan 探讨了这样的多学科团队如何在敏捷 IT 组织设计中采用面向结果的设置和业务目标方法。一定要把它加入到你的周末读物中！
定期对您的 ML 系统进行评分
如果您了解上述所有实践，很明显您(和您的团队)致力于在您的组织中建立最佳的 MLOps 实践。你应该得到一些掌声！
给你的机器学习系统打分既是你努力的一个很好的起点，也是随着你的项目逐渐成熟而进行持续评估的一个很好的起点。谢天谢地，这样的评分系统是存在的。Eric Breck 等人在他们的论文中提出了一个综合评分系统——你的 ML 测试分数是多少？大规模生产系统的规则。评分系统包括功能和数据、模型开发、基础设施以及监控。
结论
就是这样！您绝对应该考虑实施的 10 个实践是:
- 命名规格
- 代码质量检查
- 实验——并跟踪您的实验！
- 数据有效性
- 跨细分市场的模型验证
- 资源利用:记住你的实验是要花钱的
- 监控预测服务性能
- 仔细考虑你选择的 ML 平台
- 开放的通信线路很重要
- 定期对您的 ML 系统进行评分
尝试一下，你肯定会看到你在 ML 系统上的工作有所改进。
MLOps 架构指南
原文：https://web.archive.org/web/https://neptune.ai/blog/mlops-architecture-guide
一个成功的机器学习项目不仅仅是部署一个工作应用程序。这是关于传递积极的商业价值，并确保你继续传递它。
当你从事许多机器学习项目时，你发现其中一些项目在开发阶段工作得很好，但从未达到生产阶段。其他项目可以投入生产，但无法满足用户需求。然而，另一个项目在扩大规模后将过于昂贵而无法产生利润。
Source: Author
常规软件有 DevOps，我们有 MLOps ，这个更重要。如果您想要成功，您需要针对开发和生产工作负载的最佳 MLOps 架构。
下图可能是整个 MLOps 社区中最常见的图表，它来自一篇被引用最多的 ML 论文。
这个图表告诉我们，生产级机器学习系统不仅仅是设计学习算法和编写代码。能够为您的项目选择和设计最佳架构通常是弥合机器学习和操作之间的差距，并最终为您的 ML 系统中隐藏的技术债务买单。
在本文中，您将了解到:
在本文的某个地方，我还向您提出了一个挑战，那就是在给定一个业务问题的情况下，提出最佳架构。我希望你玩得开心，让我们直接进入文章吧！
生产级机器学习系统的现实
当您考虑从事机器学习项目时，一个非常详细的工作流程可能是:
Image by the author (click to enlarge)
事实上，您可能已经使用这样的工作流开发了您的模型，并且想要部署您的模型并为生产挑战做好准备，例如恶化、可伸缩性、速度、维护等等。
如果你在考虑实验和开发之外的生活，你可能需要彻底的重新思考——从选择正确的架构来在野外操作你的解决方案开始。
在一般水平上操作一个机器学习系统需要一个复杂的架构——或者在著名的“机器学习系统中隐藏的技术债务”论文中是这样说的。
对于一个实时为用户服务的机器学习项目，你认为架构应该是什么样子的？你会考虑什么？你应该说明什么？
下面是在为您的项目寻找合适的架构时，您可能会发现的额外复杂性的说明(尽管它很多，但它仍然没有考虑到构建生产级机器学习系统所需的一切。
Image by the author (click to enlarge)
考虑的还挺多的！正如你所看到的，这个系统有一个机器学习(ML)部分和一个操作(Ops)部分。它们共同定义了机器学习系统的架构。
在 MLOps 的通用架构模式中，架构变更发生在 ML 阶段和 Ops 阶段，在这两个阶段中，您可以根据问题和数据采用不同的开发和部署模式。在下一节中，我们将看看 ML 系统的常见 MLOps 架构模式。
MLOps 的通用架构模式
正如你在上面机器学习系统的(相当)复杂的表示中所看到的，MLOps 只是机器学习和操作混合在一起，运行在基础设施和资源之上。
MLOps 中的架构模式是关于培训和服务设计的。数据管道架构通常与培训和服务架构紧密耦合。
机器学习开发/培训架构模式
在您的培训和试验阶段，架构决策通常基于您接收的输入数据类型和您正在解决的问题。
例如，如果输入数据在生产中经常变化，您可能想要考虑一个动态训练架构。如果输入数据很少改变，你可能想考虑一个静态训练架构。
动态培训架构
在这种情况下，您可以根据生产中不断变化的数据分布对模型进行重新训练，从而不断刷新模型。基于收到的输入和整体问题范围，有 3 种不同的体系结构。
1.基于事件的培训架构(基于推送)
Push-based training architecture | Source: Author
针对基于事件的场景的培训体系结构，在这些场景中，某个操作(如将数据流入数据仓库)会导致触发器组件打开:
如果您希望您的系统持续训练从物联网设备获取实时数据，以进行流分析或在线服务，您可能需要此功能。
2.协调的拉动式培训架构
Pull-based training architecture | Source: Author
培训体系结构，适用于您必须按照预定的时间间隔重新培训模型的情况。您的数据在仓库中等待，工作流编排工具用于安排提取和处理，以及对新数据的模型重新训练。这种架构对于用户不需要实时评分的问题特别有用，比如内容推荐引擎(针对歌曲或文章)，当用户登录他们的帐户时，它会提供预先计算的模型推荐。
3.基于消息的培训架构
Message-based training architecture | Source: author
当您需要连续的模型训练时，这种训练架构是有用的。例如:
- 新数据来自不同的来源(如移动应用程序、web 交互和/或其他数据存储)，
- 数据服务订阅消息代理，以便当数据进入数据仓库时，它将消息推送到消息代理，
- 消息代理向数据管道发送消息，从仓库中提取数据。
一旦转换结束，数据被加载到存储中，一条消息将被再次推送到代理，以向训练管道发送一条消息，从而从数据存储中加载数据并开始训练作业。
从本质上讲，它将数据服务(数据管道)和培训服务(培训管道)结合到一个单一的系统中，因此培训在每项工作中都是连续的。例如，当您需要刷新您的实时事务模型(欺诈检测应用程序)时，您可能需要这个培训体系结构。
您还可以拥有一个用户触发的培训架构，其中用户向培训管道服务发送一个请求，开始对可用数据进行培训，并写出模型数据，也许还有培训报告。
静态培训架构
如果您的数据分布与离线时相比没有太大变化，那么可以考虑使用这种架构。这类问题的一个例子可能是贷款审批系统，在该系统中，决定是批准还是拒绝贷款所需的属性经历逐渐的分布变化，只有在像疫情这样的罕见情况下才会发生突然的变化。
下面是静态培训的参考架构——培训一次，偶尔再培训。
Modified by the author and adapted from the source.
服务架构
您的服务架构有很多种。为了在生产中成功地操作该模型，它不仅仅是服务。您还必须在生产环境中监控、治理和管理它们。您的服务架构可能会有所不同，但它应该始终考虑这些方面。
您选择的服务架构将取决于业务环境和您提出的需求。
通用操作体系结构模式
批量架构模式
这可以说是在生产中为您的经验证的模型服务的最简单的架构。基本上，您的模型离线进行预测，并将它们放入可以按需提供的数据存储中。
Source: Author
如果需求不涉及以秒或分钟为单位向客户提供预测，您可能希望使用这种服务模式。一个典型的用例是内容推荐系统(在用户登录帐户或打开应用程序之前，为用户预先计算推荐)。
在线/实时架构模式
Source: Author
有些情况下，您希望以极小的延迟(几秒或几分钟内)向用户提供模型预测。您可能想考虑一个在线服务架构，它意味着在用户请求时实时向用户提供预测。
符合这种特征的用例的一个例子是在交易完成之前检测交易中的欺诈。
其他值得您花费时间的架构有:
- 接近实时的服务架构–适用于个性化用例。
- 嵌入式服务架构–适用于数据和/或计算必须驻留在本地或边缘设备(如手机或微控制器)上的用例。
现在您已经看到了常见的 MLOPs 架构模式，让我们继续实现一个吧！
如何为项目选择“最佳”MLOps 架构
像任何其他产品或解决方案一样，你想设计出正确的设计是非常具体的问题。你会经常发现，类似的问题在架构上可能只有细微的变化。所以，“最好”可能是非常主观的，我想在这篇文章中说得非常清楚。我定义的“最佳”架构是这样的:
- 围绕最终用户的需求而设计。
- 考虑项目商业成功所需的必要项目要求。
- 遵循模板最佳实践、原则、方法和技术；对于最佳实践和设计原则，我参考了机器学习镜头——AWS 架构良好的框架实践，这似乎是目前为止最通用的模板。
- 通过强大的工具和技术实施。
您还会发现，根据您的 MLOps 成熟度，其中一些可能适用于您，也可能不适用于您，这使得架构选择更加主观。无论如何，我试图给出项目的全部细节，包括 MLOps 成熟度级别，同时考虑到运行系统的成本。
为了保持一致性，我们的项目用例考虑了 MLOps 的四大支柱:
- 生产模型部署，
- 生产模型监控，
- 生产中的模型治理，
- 模型生命周期管理(再培训、重塑、自动化管道)。
为了向您展示如何考虑这些架构，我遵循相同的模板:
- 问题分析:目标是什么？生意是关于什么的？现状？建议 ML 解决方案？项目的数据可用吗？
- 需求考虑:一个成功的项目运行需要哪些需求和规范？需求是我们希望整个应用程序做什么，在这种情况下，规范是我们希望应用程序如何做——在数据、实验和生产模型管理方面。
- 定义系统结构:通过方法论定义架构主干/结构。
- 决定实施:用推荐的健壮的工具和技术填充结构。
- 使用 AWS 架构良好的框架(机器学习镜头)实践，思考为什么这样的架构是“最好的”。
从 AWS 良好架构的框架(机器学习镜头)中调整好的设计原则
我们采用由 AWS 开发的架构良好的解决方案的 5 个支柱。他们使用良好设计原则和最佳实践的标准框架，帮助构建具有最佳商业价值的解决方案:
- 卓越运营:专注于在生产中运营您的模型的能力，监控并洞察 ML 系统，以交付商业价值并持续改进支持流程和程序。
- 安全性:关注保护信息、系统和资产(数据)的能力，同时通过风险评估和缓解策略提供商业价值。
- 可靠性:关注系统从基础设施或服务中断中恢复的能力，动态获取计算资源以满足需求，以及减轻错误配置或短暂网络问题等中断的能力。
- 性能效率:关注计算资源的高效使用以满足需求，以及如何随着需求的变化和技术的发展保持这种效率。
- 成本优化:专注于构建和运营成本感知型 ML 系统的能力，以实现业务成果和成本最小化，从而让您的企业获得最大的投资回报。
面向机器学习的架构良好的框架架构设计原则
我根据您在规划架构时应该注意的这 5 个支柱的设计原则，为您创建了一个汇总表:
| 结构良好的柱子 | ML 系统的设计原则 |
|---|---|
–建立跨职能团队。
—在 ML 工作流程的早期确定端到端的架构和运营模式。
–持续监控和测量 ML 工作负荷。
–建立一个再培训战略的模型:自动化？人为干预？
–版本机器学习输入和工件。
–自动化机器学习部署管道。
|
| |
–限制对 ML 系统的访问。
–确保数据治理。
–实施数据传承。
–强制执行法规遵从性。
|
| |
–通过自动化管理模型输入的变更。
–一次培训，跨环境部署。
|
| |
–针对您的 ML 工作负载优化计算。
–为您的模型定义延迟和网络带宽性能要求。
–持续监控和测量系统性能。
|
| |
–使用托管服务降低拥有成本。
–用小数据集做实验。
–合适规模的培训和模型托管实例。
|
已定义项目的最佳 MLOps 架构
我们在下面选择了一个项目，在这里我们可以思考为每个项目选择架构的过程。开始了。
项目:新闻文章推荐系统
内容推荐系统有助于企业保持用户对相关内容的关注，从而使他们在平台上花费更多。尤其是在媒体领域，目标一直是提高客户参与度。
方案
我们公司(一家新闻文章推荐公司)的一位业务分析师意识到，最近客户流失很多。在分析了这种情况后，他们得出的结论是，用户感觉不到与平台的互动，所以他们要么不继续订阅，要么干脆转向其他媒体平台。我们与业务分析团队和一些忠实客户密切合作，发现在我们能够为用户个性化平台之前，我们可能会看到他们完全脱离，甚至更糟，完全流失。
第一步是构建一个与现有产品集成的功能，该功能将推荐读者登录后可能会阅读的新闻文章，并将它们发送到他们的电子邮件中。
管理层同意我们建立系统，并在扩大范围之前对选定数量的用户进行测试。
…我们就是这样来到这里的。我们现在要干嘛？好了，让我们开始架构吧！
问题分析
业务理解
- 该公司目前在 3 个地区(拉丁美洲、非洲和北美)拥有超过 521，000 名付费客户。
- 他们从各种出版物中挑选文章，为付费订户服务。
- 当用户第一次访问该平台并激活免费试用时，系统会提示他们选择感兴趣的相关类别的文章。他们获得该类别的最新文章，并收集他们与文章的互动以及他们在应用程序或网站的页面上停留多长时间的数据。
业务目标是什么？通过向用户推荐与任何特定登录会话最相关的文章来提高用户参与度，从而使他们能够不断回来，进而继续订阅该服务。
业务指标是什么？用户花在一篇文章上的时间增加了。我们使用这个指标而不是点击量的原因很简单，就是系统之外有更多的外部因素可以影响用户是否点击一篇文章。从标题到封面照片，或者副标题，到 UI 设计，等等。
项目的范围是什么？
- 项目范围是低风险的，主要是因为有一个可以采用的模板。
- 这是一个面向外部的项目，用户的体验将直接受到影响。
- 我们现在只构建项目和测试大约 15，000 个用户，因此企业可以适当地控制项目和管理影响。
- 业务利益相关者还要求我们在内部运行整个系统，因为我们正在对大约 15，000 名用户进行测试，当最终报告显示运行整个项目的成本时，我们可以对此进行更明确的讨论。
- 有时文章会传播错误信息和宣传，所以我们在管理系统时应该注意这一点。
技术考虑因素
- 团队:我们目前是两人团队；我自己和一个数据工程师(这对于这个范围来说很好)——我们必须找到让我们每个人的操作压力更小的方法！我们还可以访问该组织的运营团队，他们已经在 Kubernetes 集群上为我们的内部系统和私有云平台部署了应用程序和内部系统。
- 硬件/基础设施供应:我们一直在内部供应我们自己的资源来运行项目。我们还可以自由选择我们的工具——这可能不适合您，尤其是当您的运营团队拥有现有工具时。
数据理解
- 可用的历史数据包括文章的内容细节、内容类别、用户在特定文章上花费的时间、用户的唯一标识符、他们访问文章的总次数；
- 各种出版物预计每天约有 144，000 篇新文章；
- 文章附有链接、类别、发布日期、出版物名称和其他元数据。
需求考虑
在考虑系统需求时，您需要了解几件事情:
- 如何确保良好的用户体验？记住，用户可以是真实的人，也可以是消费者(下游服务)，比如后端服务。
- 为了获得良好的用户体验，解决方案的哪些部分是最关键的？
- 为了将第一个版本提供给用户并收集反馈，我们能尽快实现的最低有价值的产品是什么？
为了提出项目的需求，您可以根据自己的需要修改 Volere 的需求规格模板。对于我的要求，我使用了由迈克尔·柏林策划的 GitHub 上这个清单中的问题。
需求: 该服务应通过移动应用程序或网站主页，根据用户对给定登录会话的兴趣，推荐用户可能阅读的前 10 篇文章。
我们现在可以仔细看看 ML 系统每个组件的规格。
数据采集和特征管理规范
- 由于文章是从各种来源获得的，因此将数据访问集中到数据仓库中是有意义的，这样我们就可以轻松地将生产数据接收到数据管道中。
- 我们将需要一个特征库来存储从生产数据中提取的转换特征值，以便离线重新训练机器学习模型。
- 还应该启用数据版本控制，以便我们可以出于审计、调试或其他目的正确地跟踪数据沿袭。
- 我们还应该监控数据的质量，以便它是我们的自动化工作流所期望的。
实验管理和模型开发规范
- 训练应该离线进行，利用现有的用户数据和他们与以前文章的互动。
- 我们需要一个动态的训练架构来弥补发布的文章的新鲜度，以避免陈旧的模型和最终陈旧的推荐。
- 我们需要一个模型注册表来存储实验的细节和来自我们训练运行的元数据。这也将支持正在部署的模型和数据的沿袭可追溯性。
- 培训管道将是必要的，因为我们需要自动化的再培训过程，因为每天都有新的文章进来。
- 因为我们的预算有限，我们的模型需要每天在合理的时间内进行训练，我们可能必须限制每次训练的数据量，因为我们不能花太多时间进行训练，也不能发布大量的新文章。
- 在我们的培训架构中，我们可能还希望利用模型检查点，以便培训和再培训不会花费太长时间(最好在他们进来的几个小时内，因为这通常是我们用户的登录高峰时间)。
生产模式管理规范
1.部署和服务规范
- 看起来批量推理系统是值得的，因为我们不需要在用户浏览平台时实时向他们提供预测。这些推荐可以离线计算，存储在数据库中，并在用户登录时提供给用户。
- 为了与现有系统交互，我们可以将模型作为一个具有 RESTful 接口的服务来提供。
- 我们需要尽量避免处理服务依赖关系的变化，这样我们的自动化管道运行就不会因为这些变化而失败。
- 我们希望确保在成功评估后可以轻松地持续部署新的模型版本，并在每天都进行培训时对其进行跟踪。
2。模型监控规范
- 应该实时监控模型漂移，这样用户就不会得到过时的推荐，因为新闻事件是非常动态的，用户的阅读行为也可能变得不确定。
- 我们需要监控数据质量问题，因为有时候新文章的数量可能会比一天的预期数量少。还考虑了损坏的数据。
- 由于我们将频繁地重新训练我们的模型，我们需要跟踪每次运行的训练元数据，以便当一个模型无法执行时，我们可以审计它的训练细节并进行故障排除。
- 我们正在处理管道，因此我们需要监控组件来测量管道的健康状况。
- 我们需要收集一个人在一篇文章上花了多长时间的基本事实标签，以衡量我们的模型性能和模型漂移。
- 数据漂移也应与模型漂移一起监控，以捕捉用户偏好和文章特征的变化。
- 当管道发生故障时，我们还应该能够以仪表板视图和警报的形式获得报告，因为我们希望确保我们的模型不断更新。
3.模型管理规范
- 由于大量的文章是基于事件随机出现的，我们可以建立一个基于拉的架构，该架构按计划执行工作流，以根据新数据重新训练我们的模型。
- 对于每个重新训练和重新部署的模型版本，模型版本化也需要到位，这样如果重新训练的模型性能更差，我们可以很容易地回滚。
- 将对已转换并加载到要素存储中的数据进行重新训练。
4.模型治理规范
- 模型决策应该是可解释的，因为错误信息可以被审计，需要被监管。
系统操作(Ops)规范
-
我们需要定义您的模型如何能够在生产环境中运行。服务之间交互的标准是什么？这将如何定义整个系统的操作？基本上，最佳系统运行的性能要求。
-
推荐服务和后端服务器之间 95%的服务级别协议(SLA)。
-
当通过数据存储向数千用户提供批量预测时，提供低服务延迟和高吞吐量服务。
-
跟踪成功、失败和超时的 API 调用的数量。
-
应根据培训管道和整个系统消耗的资源量对其进行监控；I/O、CPU 使用率和内存。
-
基础设施必须与模型和运行时无关。
-
我们的生产环境不应该要求频繁的依赖关系更改，这可能会导致我们的数据和模型管道在执行时失败。它应该主要是确定性的。
-
我们还需要一个可复制的环境，因为它将在系统出现故障时启用我们的回滚策略。
-
我们应该确保对每个基础设施包进行正确的版本控制，这样就可以很容易地调试由于依赖关系的变化而产生的冲突。
定义系统结构
基于上面列出的目标、需求和规范，我们可以为我们的系统设计出下面的结构。您可能会注意到，这里没有提到工具或实现。对！这更多的是关于设计一个考虑到商业目标和最终用户的系统。在设计你的架构时，你应该尽可能不考虑技术，只关注需求和规格。
Source: Author
系统的结构是基于需求和规范的，而需求和规范是基于业务目标的。一旦您已经能够将结构就位，您现在就可以开始选择工具和技术来实现该结构。
除了像上面这样的架构图，通常被称为基于组件的架构——你可能想要更深入地挖掘图的每个部分，以确保你不会错过重要的东西。此外，考虑其他图表，例如:
正如您可能已经猜到的那样，该架构在某种程度上处于 MLOps 成熟度级别的第 1 级。
顺便说一下，这种结构对于你正在解决的 ML 问题是完全不可知的。这意味着无论您是在从事计算机视觉项目还是自然语言处理任务，它都可以工作——这是显而易见的，但当然，一些数据管理规范将会发生变化。
决定实施
决定实施时的考虑事项
重申一下之前的观点，因为 MLOps 仍然是一个相当新兴的领域，构建一个高效的 ML 系统需要结合遵循模板化的最佳实践和使用健壮的工具(归功于 Raghav Ramesh 提出了最初的想法)。这实质上意味着，在根据您的需求和规范决定用于实现您的结构的各种组件的工具时，您必须深思熟虑。
目前，寻找对您想要实现的组件足够健壮的工具是有益的。最好是一个平台，它覆盖了整个水平堆栈(管理您的数据、实验和模型),并且足够动态，可以与您现有的生态系统集成，或者可以允许跨环境轻松迁移。令人欣慰的是，MLOps 社区令人惊叹，你可以在这个网站上找到 MLOps 工具的完整列表。
在决定实施 MLOps 架构的工具(或“玩具”)时，您可能需要考虑以下几点:
- 你多久需要一个 MVP 出来，你需要什么来发布一个？
- 你进行的风险评估有什么结果？就数据、模型和整个系统而言，平台的安全需求有多重要？
- 这个工具会很难学习并与我们现有的工具生态系统集成吗？
- (如果你在团队中工作)你在团队中有使用特定工具或工具集的经验吗？
- 这些工具的成本是否合理地包含在您为此项目预留的预算中？在订阅或许可费(如果你正在购买)，托管费(如果你正在建设)，维护费，等等。
本质上，就决定您的实现而言，您希望根据范围、需求、风险和约束(如成本、涉众的怀疑，等等)来选择什么对您的项目是最佳的。
回到项目上来！在这种情况下，我将使用各种健壮的工具来实现组件。由于我的预算限制和目前项目的范围，我还会考虑开源解决方案。我会从基础设施的考虑开始。
基础设施工具
- 我们将从基础设施决策开始。为此，我们希望整个系统是可移植的，可以在任何地方执行,并且它应该是模型不可知的。
- 我们将为我们的运行时环境使用Kubernetes引擎，因为这在规范方面是合理的，并且是开源的。
- 通过 Kubernetes 实现整个系统的可移植性还将确保我们可以在需要时轻松地从本地解决方案迁移到云或混合解决方案。
- 由于预算的限制，我们可以使用 Kubernetes】指定一个系统资源限制,它会将整个系统限制在这个限制内。它也是开源的，我们有一个已经熟悉它的内部运营团队(回想一下我们的“技术考虑”部分)。
- 作为一种安全措施，我们还可以使用 Kubernetes 扩展进行系统范围的访问控制。
NB: 我知道使用 K8s (Kubernetes)进行机器学习的兔子洞，但我们现在就假装不知道 Kubeflow 。毕竟，这不是架构的最终形式，对吗？我们一定会吸取教训，在以后的某个时候重新审视这个架构！
数据采集和特征管理工具
- 对于数据存储，我们将采用 PostgreSQL ，一个用于结构化数据的开源、高效的数据库。此外，大多数托管解决方案通常基于 PostgreSQL 和 MySQL。
- 我们还需要一个数据管道，我们将使用 Apache Beam 来编写我们的 ETL(提取、转换、加载)。
- 为了版本化数据管道，我们将使用数据版本控制(DVC) ，一个类似 GIT 的开源工具，用于版本化数据集。
- 对于功能商店，我们将不得不选择盛宴，它是开源的，并且与其他存储工具(PostgreSQL)集成得很好。
实验管理和模型开发工具
- 对于实验管理，我们将选择 Neptune ，因此培训是可重复的，并且记录了关于硬件使用(CPU 和内存使用)和超参数值的必要元数据，我们可以轻松地可视化它们并共享它们。
- Neptune 还帮助对数据集进行版本控制，并跟踪模型在哪个特定的数据集版本上被训练。
- 对于模型开发，我们将使用支持 Python 的框架；我们将在实现过程中选择它。
- 我现在还没有一个实现分布式训练的规范，所以我暂时把这个留下。
生产模式管理
1.部署和服务工具
- 为了打包我们的部署模型，我们将使用 Docker 。它几乎受所有平台的支持，在本地运行，并且可以在 Kubernetes 中管理。免费版本将做现在，因为没有妥协，看看我们的项目范围。
- 我们的 API 协议将是 REST API，API 网关我们将使用孔网关，它是开源的，原生支持 Kubernetes，可以在本地运行。而且真的很容易设置！
- 为了部署我们的模型代码，我们将使用 GitHub 动作，因为我们所有的项目代码几乎都将驻留在我们的私有 GitHub 存储库中。这也将支持我们的 CI-CD 渠道。内部托管是免费的，但我们会密切监控我们的工作流程所花费的时间，以确定私有存储库的免费版本是否足以满足我们的需求。
- 根据我们使用的框架，我们将考虑使用服务工具来部署我们的模型即服务。我们现在正在考虑烧瓶或 FastAPI 。也许我们还可以研究一下服务于的 TensorFlow，但是基于范围，上面两个框架中的任何一个都应该足够了。
2.监控工具
- 为了在生产中监控我们的模型，我们将使用完美的开源组合 Prometheus 和 Grafana——Prometheus 是一个时间序列数据库，用于收集监控数据，Grafana 将监控的指标和组件可视化在图表上。有非常有用的文档和教程，告诉我们如何将它们转换成 ML 监控服务。它们是非常强大的工具。
- 我们还将考虑使用 Prometheus 的 Alertmanager 从我们的工具发送服务报告之外的通知，以实现持续监控和可观察性。
- 对于日志系统指标，我们将使用来自 ELK 栈的 Elasticsearch ，因为它是开源的，受流行平台支持。
- 我们还可以记录对我们系统的 API 调用的详细信息；成功的、失败的和超时的调用。
- 我们还可以跟踪吞吐量，因为这是一个核心规范，根据系统进行的交易量、它处理的请求数量以及交付前 n 名(这可能是前 5 名或前 10 名，取决于客户的请求)推荐文章所用的时间，以及它们在数据库中的相似性得分。
3.模型管理工具
- Neptune.ai 可以作为每次训练运行的模型注册表。模型版本可以被记录下来，以便进行追溯。
- 对于工作流调度和编排，我们将使用 Apache Airflow ，这可能是最广泛使用的编排工具。
4.模型治理工具
这就是实现选择—您可以看到它是基于结构构建的，并且符合我们在规划阶段定义的需求和范围。我们现在将继续使用我们之前看到的 AWS 架构良好的框架(机器学习镜头)。
用架构良好的框架内联评审架构
卓越运营
- 我们能够在 ML 工作流的早期识别端到端架构和操作模型。
- 我们确保整合对机器学习工作负载的持续监控和测量。
- 我们根据我们的问题陈述、需求和预算建立了一个模型再培训策略。
- 我们在培训管道中实现了对模型和工件进行版本控制的组件。
- 我们的自动化工作流和将我们的训练代码提交给工作流工具确保了我们模型的持续集成和部署。
安全
- 到目前为止，我们只实施了数据和模型谱系可追溯性——这是一个很好的补充。
- 在实施过程中，我们将使用的大多数工具都提供了访问级别控制，因此我们可以遵循安全最佳实践。
- 我们可以期待规划其他措施，例如生产环境的运营安全、灾难恢复，以及对传输中和静态的流数据源中的数据进行加密。
- 审计安全措施也将是这个架构允许我们做的事情。
可靠性
- 到目前为止，我们已经能够使我们的系统运行时不可知，并训练我们的模型一次，并在任何地方运行它。
- 对于 Apache Beam 和 Apache Airflow，我们需要做的一件事是为接收到数据管道中的数据实现可测试性。
性能效率
- Kubernetes 可以限制资源来运行我们的工作负载，它会自动调整我们的工作负载，以优化 ML 工作负载的资源。
- 使用 Prometheus 和 Grafana 监控系统指标可以帮助我们跟踪模型的资源使用情况。
- 我们的监控工具将通过系统指标实现对系统性能的持续监控和测量。
成本优化
- 我们的架构允许流式传输任何大小的数据集，无论大小，我们都可以考虑尝试不同的大小。
- 我们的大多数工具目前都是内部部署的，但由于我们的运行时环境是可移植的，我们总是可以将其迁移到托管基础架构中。
- 我们可以在 Kubernetes 的 YAML 文件中指定 ML 工作负载所使用的资源。
你的挑战
一开始，我说我要给你一个挑战。这是:
对于承诺次日履行的企业，您将如何构建一个需要与订单管理服务集成的欺诈检测系统？
你可以随意定义你想要的业务，但是你可能要考虑一个比前一个项目更大的范围。
如果您准备好迎接挑战，您可以在本文末尾的“为您的项目选择最佳 MLOps 架构的参考资料”一节中找到我(基于该问题)提出的参考架构示例。祝你好运！
现在轮到您了:您应该如何为您的项目选择最佳的 MLOps 架构？
要为您的项目选择最佳架构，我建议您执行以下操作:
- 清楚地理解并阐明项目所需的需求、范围和约束:这里有一个由 Michael Perlin 制作的 3 集系列视频，你可以用它来开始这个项目。其他资源可以在参考和资源部分找到。您的需求应该清楚地陈述业务目标以及什么构成了良好的用户体验。
- 根据需求设计系统的结构，此时不要考虑适合该结构的实现或技术。您的主要目标是根据上一步的要求定义结构。我建议看看其他人在这一点上根据他们自己的系统结构/架构已经做了什么/正在做什么。(我在本文末尾的参考资料部分链接了一些你可以学习的架构中心。)
- 现在是你决定自己实现的时候了！在选择工具和技术时，要确保它们足够健壮，能够用于 ML 管道的任何阶段。如果它是一个监控工具，确保它是可扩展的，并且具有所有必要的功能。
- 最后，通过使用来自 AWS 的 机器学习架构良好的框架 设计原则和最佳实践或者任何其他好的模板来证明你的架构。
要明白，你的架构只是形成了基础，并为你提供了如何构建你的 ML 系统的途径。它不应该把你锁在一个实现盒子里，而应该只给你一个清晰的路径——理解当你迭代地构建你的 ML 系统时，你可以调整事情。这就是为什么敏捷 ML 软件构建是一条可行之路，因此您可以快速发现问题，甚至可以看到更好的工具或平台来帮助您的实现，并帮助您在必要的时间内交付最佳的 ML 系统。
您可能会发现一些有用的提示…
- 遵循已确立的最佳实践+健壮的工具和实现+尽快发布 MVP以迭代构建最佳解决方案。
- 您应该在机器学习项目生命周期的早期就开始考虑和规划您的 MLOps 架构。这将帮助您协调活动，并找到开发和操作中的盲点。
- 给别人“烤”你的架构的机会。在 MLOPs 社区 Slack 频道经常发生的事情是，我看到其他人上传他们架构的公共版本，让其他人有机会评论它并给出有用的反馈。你可以加入这样的社区，与其他从业者互动，设计你认为你的系统应该是什么样子。允许其他从业者通过共享公共版本和必要的需求来评论它。
- 如果您发现您的需求可能涉及在一个平台上训练您的模型，并在另一个平台上为其提供服务，无论该平台是内部平台、不同的云供应商还是微控制器/边缘设备，您还可以深入研究具有多云和多平台解决方案的混合 ML 系统以及嵌入式系统 MLOps 架构。
结论
在本文中，我们了解到:
- 用于培训和服务的通用 MLOps 架构模式，
- 如何为您的项目选择最佳的 MLOps 架构，
- 为您的项目选择最佳 MLOps 架构的框架，
- 最重要的是:
Source: Author
感谢您的阅读！
为您的项目选择最佳 MLOps 架构的资源
-
如果您想了解有关分析数据科学业务需求的更多信息，请查看 Pluralsight 上的课程。
-
对于架构模板，查看；
-
想为您的 MLOps 实施选择强大的工具吗？在 Neptune.ai 的博客上查看这类文章。
-
想看看实际情况吗？退房；
- 你可以参加 Kumaran Ponnambalam 在 LinkedIn 学习的课程“架构大数据应用:实时应用工程”和“架构大数据应用:批处理模式应用工程”。
- 同样，另一个更好地设计 ML 系统的方法是看看别人在做什么。关于 Quora、优步、网飞、DoorDash、Spotify 或其他不太知名的公司如何构建自己的系统，有一些网络研讨会和博客帖子。退房；
- YouTube 上的 MLconf 是非常好的课程。
- YouTube 上的数据块视频。
- 我最近写了一篇关于 8 家公司如何实施 MLOps 的文章，你可以在这里查看。
-
这里有一个最近发布的如何从零开始构建一个 ML 平台，我想你会觉得有用。
-
如果你想将你自己和你的团队从所有第三方工具中抽象出来，并为每个组件使用单独的工具，你可以考虑使用一些好的 MLOps 平台:管理机器学习生命周期的最佳 MLOps 平台
-
我对所给挑战的解决方案。
参考
格林斯团队的 MLOps:运输机器学习[案例研究]
GreenSteam 是一家为海洋产业提供软件解决方案的公司，这些软件解决方案有助于减少燃料的使用。过量使用燃料不仅成本高昂，而且对环境有害，国际海事组织要求船舶运营商更加环保，到 2050 年将二氧化碳排放量减少 50%。
尽管我们不是一家大公司(50 人，包括业务人员、开发人员、领域专家、研究人员和数据科学家)，但我们在过去 13 年中已经开发了几款机器学习产品，帮助一些大型航运公司做出明智的性能优化决策。
在这篇博文中，我想分享我们构建 MLOps 堆栈的旅程。具体来说，我们如何:
- 处理了代码依赖
- 走近测试 ML 模型
- 建立自动化培训和评估渠道
- 部署和服务我们的模型
- 设法在 MLOps 中保持人在回路中
新的开始
2019 年，创建了一个由一名数据科学家、另一名机器学习工程师和我组成的项目团队。我们的工作是建立一个新的机器学习模型，取代我们以前使用的一些模型。
我们像其他人一样开始。我们进行无休止的讨论，创建新的笔记本，重新培训，比较结果。这对于构建一个原型是有效的，但是我们需要更好地组织它。
随着格林斯团队的顾客越来越多:
- 我们需要处理越来越多的数据，
- 我们发现了更多的边缘案例，在这些案例中，我们的模型表现不如预期，
- 我们观察到了一个数据漂移，我们的模型还不足以处理它。
另一件困扰我们的事是对未来的规划。我们知道我们的 ML 运营需要与公司一起成长，我们需要一个可以处理它的机构。我们既想要一个健壮的模型，可以处理我们从客户那里获得的不同类型的数据，又想要一个可扩展的技术解决方案。
有时候，最好的前进方式是后退一步，这正是我们所做的。
我们决定从头开始，重新思考我们的整个机器学习基础设施和操作。
步骤 1:共享 ML 代码库
一开始，每个新想法都是一个新的笔记本。随着我们的实验，我们有越来越多的笔记本分散在我们的笔记本电脑上。在某个时候，我们开始忘记笔记本中所有的代码变化。合并它们以保留一些共同的代码库也是一件非常痛苦的事情。
是时候将共享代码库的一部分提取到一个 Python 包中，并为其创建一个 git 存储库。通过这样做，我们仍然可以在笔记本上试验我们的想法，同时对代码库中变化不快的部分进行版本控制。区别和合并脚本也比笔记本容易得多。
步骤 2:处理依赖性和再现性
在这个阶段，我们还注意到了可重复性的问题。虽然我们的笔记本电脑设置相似，但并不相同。
使用 【康达】 解决了一些问题，但这是一个脆弱的解决方案。有时，有人会在他们的本地环境中安装一些东西，使其与我们认为的环境有所不同。它导致了一些小的但是令人恼火的“它在我的机器上工作”类型的错误。
随着我们的模型逐渐成熟，我们在更大的数据集上测试它，使用更强大的云机器，而不仅仅是我们的笔记本电脑。但是当你从本地环境转移到云端时，另一个问题就出现了。人们很容易忘记一些依赖关系，因此拥有可以信任的环境配置变得至关重要。
“Docker 帮助我们做到了这一点，这是一个新时代的开始。它使我们能够拥有一个统一、密封的设置，无论是谁在哪里运行它。”
****码头工人帮了我们，这是一个新时代的开始。它使我们能够拥有一个统一的、密封的设置，无论是谁在哪里运行它。对于设置，我指的是代码库、包版本、系统依赖、配置。设置环境所需的一切。
**此时，我们可以从容器内部启动 Jupyter，保存所有版本控制代码的散列并生成结果。这与在 git 中存储所有内容一起，极大地提高了我们的代码库和模型变更的可再现性和可追溯性。
步骤 3:如何处理不测试的测试
测试代码本身就是一个问题。
从一开始，我们就以高测试覆盖率为目标，总是使用类型提示并关注代码质量。但是对于机器学习代码，事情并不总是那么简单。
模型代码的某些部分很难进行单元测试。例如，为了正确测试它们，我们需要训练模型。即使你使用一个小的数据集，对于一个单元测试来说也是相当长的。
你还能做什么？
我们可以采用预先训练好的模型，但是对于多重测试，初始化它的开销使得测试套件足够慢，从而阻碍了我们频繁地运行它。
最重要的是，这些测试中的一些是古怪的，随机失败。原因很简单(也很难解决):你不能指望在一个小数据子样本上训练的模型像在整个真实数据集上训练的模型一样。
“…我们决定放弃一些单元测试并运行冒烟测试…我们将监控管道中的任何问题，并尽早发现它们。”
为了解决所有这些问题，我们决定放弃一些单元测试，运行 冒烟测试 。对于每个新的 pull 请求，我们将在类似生产的环境中，在完整的数据集上训练模型，唯一的例外是超参数被设置为可以快速获得结果的值。我们将监控这条管道的任何问题，并尽早发现它们。
在一天结束时，我们希望我们的测试尽早标记失败的代码，这个设置为我们解决了这个问题。
步骤 4:代码质量、类型检查和持续集成
既然我们可以在不同的执行环境(Docker)之间移动，并且已经建立了我们的测试，我们就可以添加持续集成来使检查和评审更加有效。
我们还将所有代码检查移入 Docker ，因此 flake8、black、mypy、pytest 的版本和配置也统一了。这帮助我们将本地开发设置与我们在 Jenkins 上使用的相统一。不再有不同版本的 linter 在本地和 Jenkins 显示不同结果的问题。
对于本地开发，我们有一个 Makefile 来构建映像，运行它，并对代码运行所有的检查和测试。对于代码审查，我们设置 Jenkins 作为 CI 管道的一部分运行相同的检查。
“…在许多情况下，mypy 帮助找到单元测试没有覆盖的代码部分的问题。”
帮助我们晚上睡得好的另一个保障是使用【mypy】。人们有时认为它“只是”一个检查类型的静态分析器(对于动态类型语言！).从我们的经验来看，在许多情况下，mypy 有助于发现单元测试没有覆盖的部分代码的问题。看到一个函数接收或返回一些我们不期望的东西是一个简单但强大的检查。
步骤 5:添加流程编排、管道，并从整体服务转向微服务
现在，我们需要针对不同场景中不同客户端的多个数据集来测试我们的模型。这不是您想要手动设置和运行的。
我们需要流程编排，我们需要自动化管道，我们需要轻松地将其插入到生产环境中。
将我们的 ML 代码 Dockerized 使得在不同的环境(本地和云)之间移动变得容易，但这也使得将它作为微服务直接连接到生产管道成为可能。
也正是格林斯 team 从气流切换到 Argo 的时候，所以在我们的容器里插上几个 YAMLs 就完事了。
步骤 6:跟踪所有的模型版本和结果
现在，我们可以有效地扩展我们的模型构建操作，但是这引发了另一个问题:我们如何管理所有这些模型版本？
我们需要监控多个模型的结果，在多个数据集上用不同的参数和指标进行训练。我们想将所有这些模型版本相互比较。
经过一些研究，我们发现了两个解决方案可以帮助我们做到这一点，MLflow 和 Neptune。让我们相信 Neptune 的是，它更像是一个开箱即用的解决方案。它使我们能够在一个地方标记实验、保存超参数、模型版本、度量和绘图。
步骤 7:定制模型服务
让我们回到阿尔戈。
对于训练机器学习模型来说，这是一个非常低级的解决方案。为什么我们不使用一些对数据科学更友好的东西，例如一些一体化的 ML 平台？
一个显而易见的原因是我们已经在使用 Argo 运行其他进程，但对我们来说，更大的问题是模型服务和部署。
在标准的机器学习场景中:
- 从一个数据集开始，
- 将它推入预处理管道
- 训练你的模型，
- 将它包装在一些预测函数中，这些函数可以被腌泡或打包到 REST API 中，
- 为生产服务。
然而，在我们的案例中，我们的客户希望我们对不同种类和品种的船只进行预测。它们可以是慢速挖泥船、大型游轮、巨型油轮，仅举几例，通常在非常不同的条件下航行。在许多情况下，你不能轻易地将你从一艘船上的数据中学到的东西转移到另一艘船上。
因此，我们需要用不断增长的时间序列数据集为每种血管类型训练一个单独的模型。
此外，与传统的机器学习不同，在传统的机器学习中，模型预测单一事物，我们的目标是拥有一个预测船只行为的多种特征的模型。
这些预测然后被插入到几个服务中，帮助我们的客户计划诸如配平、速度、安排船体清洁以恢复污垢的影响等事情。底线是，这些事情都在很大程度上影响燃料消耗，我们的模型可以帮助做出更好的决定。
我们查看了现成的解决方案，如 SageMaker 或 Kubeflow，但不幸的是，我们没有发现它们能很好地服务于我们的用例。
“我们最终将模型打包到微服务中，……使用 FastAPI 完成这项工作比我们想象的更容易。”
我们最终将模型打包到微服务中，因此如果需要，我们可以很容易地用另一个服务替换一个服务，只要它共享相同的接口。使用 FastAPI 来做这个 ，结果比我们想象的更轻松。
为了举例说明设置的灵活性，我们最近需要推出一个运行速度非常快的虚拟模型，只是为了测试我们的基础设施。将一个简单的 Scikit-learn 代码打包到一个我们可以插入的微服务中，包括代码审查在内，整个生产过程只花了四天时间。
步骤 8:人在回路模型审计
我们扩展了它，但是仍然存在一个瓶颈。我们如何确保模型提供良好的业务洞察力(而不仅仅是良好的机器学习指标)？
我们的设置假设每个经过训练的模型都经过了领域专家的审核和批准。在培训结束时，我们会制作一份报告，这是一个静态网页，上面有描述结果的图表和统计数据。
这不是很好的扩展。我们试图通过创建一套检查来自动拒绝可疑的结果，这些检查将查询模型以验证预测是否与我们从物理学和常识中预期的一致。这些检查有点作用，但有时在数据质量问题上失败了。垃圾进，垃圾出。
我们将继续寻找一个令人满意的解决方案，但由于质量如此重要，我们依赖于领域专家对每个训练模型结果的审核。
步骤 9:功能存储和微服务(进行中)
下一步是将我们学到的知识归纳到一个合适的微服务架构中，该架构可以轻松处理许多不同的模型。
我们现在的目标是确保我们的架构能够让我们轻松地将任何未来模型作为微服务插入:
- 我们通过创建我们的特征库，将我们自己从数据管道中分离出来，为模型预先计算特征。
- 我们的模型作为独立的微服务运行。
- 虽然我们仍然部分地以推模式运行，在这种模式下，经过训练的模型将结果发送到系统的其他部分，我们的目标是使它成为拉模式，在这种模式下，当需要访问结果时，服务将调用我们的 API 。
我们当前的 MLOps 堆栈(以及一些经验教训)
在这个项目上工作了一年多之后，我们学到了很多关于如何有效地解决类似的问题并将它们转化为可行的解决方案。当然，我们前面还有很长的路要走，但我们希望我们能够应对新的挑战。
我已经提到了许多优秀的工具，但为了让您全面了解我们目前使用的 MLOps 技术体系:
- 架构:微服务/混合
- 管道:阿尔戈
- 云:和
- 环境管理 : Docker、Conda、Pip、诗歌、Makefiles
- 源代码:BitBucket.com 上的 git
- 开发环境 : Jupyter 笔记本
- CI/CD:gitop 使用 Jenkins 运行代码质量检查，在测试环境中使用类似生产的运行进行冒烟测试
- 实验跟踪:海王星
- 模型测试和批准:定制解决方案
- 代码质量 : pytest，mypy，black，isort，flake8，pylint
- 监视:基巴纳，哨兵
- 模型服务:带有 FastAPI REST 接口的 Docker
- 机器学习栈 : Scikit-learn，PyMC3，PyTorch，Tensorflow
对我来说，在这里学到的最大的教训是保持简单 ( 你不会需要它！)，不要面向未来，但同时要保持足够的灵活性，这样你就可以很容易地改变未来的事情。我们不断地重构代码和实验。拥有一个统一的开发环境，测试到位，能够轻松地将组件插入或替换到现有的架构中，这使得事情变得更加容易。
提摩太的船
格林斯团队的机器学习工程师
接下来的步骤
如何在 5 分钟内上手海王星
1.创建一个免费帐户
2.安装 Neptune 客户端库
3.将日志记录添加到脚本中
2. Install Neptune client library
pip install neptune-client
3. Add logging to your script
import neptune.new as neptune
run = neptune.init_run("Me/MyProject")
run["parameters"] = {"lr":0.1, "dropout":0.4}
run["test_accuracy"] = 0.84
合理规模的 MLOps 终极指南]
原文：https://web.archive.org/web/https://neptune.ai/blog/mlops-at-reasonable-scale
几年来， MLOps 可能是 ML 行业中使用最多的术语。人们想要部署到生产中的模型越多，他们就越想如何组织这个过程的操作部分。
自然地，市场上的大玩家——如谷歌、网飞和优步——已经决定了如何进行 MLOps。他们为社区所做的是伟大的，但他们解决了他们的 MLOps 问题。
大多数公司没有他们的问题。大多数 ML 团队的经营规模较小，面临不同的挑战。然而，他们是传销行业中最大的一部分，他们想知道以他们的规模，以他们的资源和限制，做传销的最好方法是什么。
合理规模的 MLOps 正在解决这一需求。“合理规模”是雅格布·塔利亚布埃去年创造的一个术语，它指的是这样的公司:
- 拥有每年产生几十万到几千万美元(而不是几亿或几十亿)的 ml 模型
- 有几十个工程师(而不是几百或几千个)
- 处理万亿字节(而不是千兆字节或千兆字节)
- 计算预算有限
在本指南中，您将在合理的范围内了解更多关于 MLOps 的信息，并了解有助于您理解如何在工作中实施它们的最佳实践、模板和示例。
在此之前，我们先退后几步，看看为什么我们还要谈论合理的规模。
规模合理的多点作业与多点作业
解决正确的问题和创建一个工作模型虽然仍然至关重要，但已经不够了。越来越多的公司需要将 ML 部署到生产中，以显示“业务的真正价值”。
否则，你的经理或你的经理的经理会开始问“我们的 AI 投资的 ROI”的问题。这意味着麻烦。
好的一面是，许多团队，无论大小，都已经过了那个阶段，他们的模型正在为企业做一些有价值的事情。问题是:
您如何在生产中部署、维护和操作这些模型？
答案似乎是 MLOps。
2021 年，如此多的团队围绕 ML 运营寻找工具和最佳实践，以至于 MLOps 成为一项真正的交易。许多工具和创业公司被创造出来。2021 年甚至被称为“MLOps 之年”。酷毙了。
但是建立 MLOps 意味着什么呢？
如果你通读在线资源，它会是:
- 可再生和协调的管道，
- 警报和监控，
- 版本化和可追踪的模型，
- 服务端点的自动扩展模型，
- 数据版本和数据沿袭，
- 功能商店，
- 还有更多。
但是它必须是全部吗？
您真的需要所有这些东西吗，或者它只是一个“标准的行业最佳实践”？那些“标准行业最佳实践”究竟来自哪里？
大多数好的博客文章、白皮书、会议演讲和工具都是由来自超先进、超大规模公司的人创造的。像谷歌、优步和 Airbnb 这样的公司。他们有数百人在处理 ML 问题，每月处理数万亿次请求。
这意味着您发现的大多数最佳实践自然偏向于超大规模。但是 99%的公司没有在超大规模进行生产 ML。
大多数公司要么还没有进行任何生产 ML，要么以合理的规模进行。合理的规模是指五个 ML 人员、十个模型、数百万个请求。合理，要求高，但没有疯狂和超大规模。
好吧，最佳实践偏向于超大规模，但这有什么错呢？
问题是当一个合理规模的团队采用“标准行业最佳实践”并试图构建或购买一个成熟的超大规模 MLOps 系统时。
用合理规模的 ML 团队的资源来构建超大规模的 MLOps 是行不通的。
超大规模公司需要一切。合理规模的公司需要解决当前最重要的挑战。他们需要明智而务实地对待他们现在需要的东西。
棘手的部分是告诉你的实际需求是什么，什么是潜在的，美好的，未来的需求。有这么多的博客文章和会议讨论，这很难。一旦你清楚了你的现实，你就成功了一半。
但是也有一些实例表明务实的公司通过接受合理的规模 MLOps 限制而取得了巨大的成就:
- 柠檬水仅用 2 名 ML 工程师服务 20 名数据科学家，就能从 ML 模型中产生超过 1 亿美元的年度经常性收入。
- Coveo 利用工具为数千家(几乎)没有 ML 基础设施人员的公司提供推荐系统。
- Hypefactors 用一个只有几个人的团队在整个社交媒体领域运行 NLP/CV 数据丰富管道。
您可能从未听说过它们，但是它们的问题和解决方案比您在其他选项卡中打开的网飞博客帖子或谷歌白皮书更接近您的用例。
查看更多合理规模公司的故事了解他们如何解决 ML 工作流程的不同部分。
MLOps 的支柱
好吧，假设你想做好多项工作，你会怎么做？尽管 MLOps 仍在发展中，但有些事情是明确的(ish ),例如，MLOps 的支柱可以作为如何开始思考该主题的一种指导。
MLOps 的支柱–堆栈组件
第一种方法基于您需要以某种方式实施的 MLOps 的四个或五个主要支柱:
- 数据接收(以及可选的功能存储)
- 管道和流程编排
- 模型注册和实验跟踪
- 模型部署和服务
- 模型监控
我说四个或五个是因为数据接收部分并不总是作为支柱之一被提及。但我相信这是一个至关重要的因素，不应该被忽略。
The pillars of MLOps
根据您的需求，这些中的每一个都可以通过简单的脚本或成熟的解决方案来解决。
端到端与一流工具的规范组合
决定归结为你是否想要:
- 端到端平台与一堆同类最佳的单点解决方案
- 购买 vs 构建 vs 维护开源工具(或者购买、构建和维护 oss)。
一如既往，答案是“视情况而定”。
一些团队有一个相当标准的 ML 用例，并决定购买一个端到端的 ML 平台。
通过这样做，他们可以从盒子里取出所有的 MLOps，并且他们可以专注于 ML。
问题是，你离标准用例越远，就越难调整平台来适应你的工作流。而且一开始一切看起来简单标准。然后业务要变，需求要变，就不再那么简单了。
然后是定价讨论。当您真正需要的只是 10 个组件中的 3 个时，您能证明在端到端企业解决方案上花费“这么多”是合理的吗？有时候可以，有时候不行。
合理规模 MLOps 的支柱–组件
正因为如此，许多团队远离端到端，决定从点解决方案构建一个规范的 MLOps 堆栈，这些点解决方案只能很好地解决某些部分。
Potential implementation of the pillars of MLOps
这些解决方案有些是内部工具，有些是开源的，有些是第三方 SaaS 或内部工具。
根据他们的用例，他们可能有一些像 bash 脚本一样基本的东西用于他们的大多数 ML 操作，并在他们需要的地方得到一些更高级的东西。
例如:
- 你把你的模型移植到本地移动应用。您可能不需要模型监控，但是可能需要高级的模型打包和部署。
- 你有许多模型一起工作的复杂管道。那么你可能需要一些高级的流水线和编排。
- 您需要大量试验各种模型架构和参数。你可能需要一个可靠的实验跟踪工具。
通过务实地关注你现在实际存在的问题，你不会为未来设计过多的解决方案。你将有限的资源(作为一个团队，在合理的范围内进行 ML)投入到对你的团队/业务有影响的事情中。
合理规模 MLOps 的支柱——原则
还有另一种实现 MLOps 支柱的方法值得一提。Ciro Greco、Andrea Polonioli 和雅格布·塔利亚布埃在文章haga kure for MLOps:ML 在合理规模下的四大支柱中提出了这一观点。他们写的原则是:
- 数据优于建模:迭代数据往往能收获更多，而不是模型(吴恩达用“以数据为中心的人工智能”讲了很多)
- Log then transform :您应该将数据接收(获取原始数据)与数据处理分开，以获得再现性和可重复性。你可以得到那个，例如用雪花 + dbt
- PaaS & FaaS 优于 IaaS: 你的资源有限。把它们集中在你有所作为的地方。不要构建和维护堆栈的每个组件，尽可能使用完全托管的服务。你团队的时间才是真正的成本，而不是订阅。
- 垂直切入比分布式更深:大多数情况下，你并不真的需要分布式计算架构。您可以使用容器化的云原生扩展。
以合理的规模设置 MLOps 的最佳实践和技巧
好了，我们已经讨论了mlop 的支柱以及如何实现它们的原则。现在是更实际的部分了。你可能想知道:
合理的规模公司实际上是如何设置的(以及你应该怎么做)？
以下资源将帮助您为您的用例构建实用的 MLOps 堆栈。
先说一些小技巧吧。
最近，我们采访了一些关于建立 MLOps 的 ML 从业者。
里面有很多好东西，但有一个想法我必须和你分享:
“我的第一条建议是，MLOps 不是一种工具。它不是一个产品。它描述了自动化和简化构建人工智能相关产品和服务的过程的尝试。
因此， 花时间定义你的过程，然后找到适合那个过程的工具 和技术。
例如，一家银行的流程与一家科技创业公司的流程大相径庭。所以最终的 MLOps 实践和堆栈也非常不同。"–Winder Research 首席执行官 Phil Winder
因此，在做任何事情之前，要务实，考虑你的用例、工作流程和需求。不是“行业最佳实践”。
我不断回想起雅格布·塔利亚布埃、科威的人工智能负责人，但事实是，没有他T5，任何合理规模的 ML 讨论都是不完整的(毕竟，是他创造了这个术语，对吗？).在他的 pivotal 博客文章中，雅格布提出了一个我们认为至关重要的思维转变(尤其是在你的 MLOps 之旅的早期):
“要在一个合理的规模上实现大规模生产，你应该 把你的时间投入到你的核心问题 (不管是什么)上，并购买其他所有东西。”
你可以在这个斯坦福系统研讨会视频中看到他对这个主题的深入探讨。
视频
我想让你记住的第三个技巧来自 Orr Shilon，他是柠檬水的 ML 工程团队领导。
在 mlops.community 播客的这一期中，他谈到了平台思维。
他指出，他们的关注自动化，并尽可能务实地利用工具是在 MLOps 中高效做事的关键。
通过这种方法，他的两个 ML 工程师团队一度成功支持了 20 多人的整个数据科学团队。这是一些基础设施杠杆。
还有一个地方可以让你更好地了解如何建立你的 MLOps，那就是 Andy McMahon 的 MLOps 社区聚会，名为“建立它！让 ML 工程和 MLOps 变得真实的小技巧"。安迪谈到:
- 当你想要操作你的 ML 模型时，从哪里开始？
- 什么先来——流程还是工具？
- 如何建立和组织一个 ML 团队？
- …以及更多
视频
这是他在现实生活中做这些事情时学到的东西的一个很好的概述。那里有许多宝贵的经验。
现在，让我们看看示例 MLOps 堆栈！
有许多工具在许多 MLOps 类别中发挥作用，尽管有时很难理解谁做什么。
MLOps tools landscape | Credit: Neptune.ai
根据我们对合理规模团队如何建立堆栈的研究，我们发现:
务实的团队不会做所有的事情。他们专注于他们真正需要的东西。
例如，Continuum Industries 的团队需要深入了解他们优化算法的测试和评估套件。
因此，他们将 Neptune 与 with GitHub actions 连接起来，以可视化和比较各种测试运行。
Continuum Industries tool stack | Credit: Neptune.ai
格林斯团队需要能在混合整体微服务环境中工作的东西。
由于他们的定制部署需求，他们决定使用 Argo 管道进行工作流程编排，并使用 FastAPI 进行部署。
他们的堆栈:
GreenSteam tool stack | Credit: Neptune.ai
这些团队没有深入地解决所有问题，但是准确地指出了他们需要什么，并且做得很好。
我们的客户中有更多合理规模的团队，以下是一些值得研究的案例:
- Zoined 与几位数据科学家谈论可扩展的 ML 工作流& ML 工程师
- Hypefactors 讲述如何管理数量可变的 ML 实验过程
- Deepsense.ai 谈论找到一种跟踪超过 100k 个模型的方法
- Brainly 谈论在与 SageMaker Pipelines 合作时如何管理他们的实验
- InstaDeep 谈论建立一个有利于研究和团队的流程栈&
如果您想了解更多合理规模团队如何建立其 MLOps 的示例，请查看以下文章:
此外，如果你想深入了解，还有一个 slack 频道，人们可以在这里分享和讨论他们的 MLOps 堆栈。
你可以这样加入:
- 加入 mlops.community slack
- 找到#煎饼堆通道
- 在这个时候，来在 #neptune-ai 频道打个招呼，并询问我们关于这篇文章、MLOps 或其他任何东西的问题
好吧，堆栈很好，但是你可能也需要一些模板。
MLOps 模板
最佳合理规模的 MLOps 模板来自，你猜对了，雅格布·塔利亚布埃及其合作者。
在这个开源的 GitHub 知识库中，他们将意图预测和会话推荐的端到端(基于元流)实现放在一起。
它展示了如何连接 MLOps 的主要支柱，并构建一个端到端的工作 MLOps 系统。这是一个很好的起点，让您可以为每个组件使用默认或挑选工具。
另一个值得一提的资源是 MLOps 基础设施堆栈文章。
在那篇文章中，他们解释了如何:
“mlop 必须是与语言、框架、平台和基础设施无关的实践。MLOps 应该遵循“配置之上的约定”实现。
它附带了一个很好的图形模板，来自 Valohai 的人们。
它们解释了一般注意事项、工具类别以及每个组件的示例工具选择。总的来说，这是一本好书。
MyMLOps 为您提供了一个基于浏览器的工具堆栈构建器，它简要介绍了工具的作用以及它们在哪个类别中发挥作用。您还可以与其他人共享您的堆栈。
雅格布·塔利亚布埃的又一个模板。这是专门针对推荐系统的—合理规模的推荐系统。它的创建是为了以开源代码的形式发布一个现实的数据和 ML 管道，用于“刚刚工作”的尖端推荐系统。
MLOps template for recommender systems | Source
您也可以查看我们的一些资源，为堆栈的特定组件选择工具:
你下一步应该做什么？
好了，现在使用这些知识，去构建您的 MLOps 堆栈吧！
我们在这里收集了很多资源，应该会对你有所帮助。但是，如果你在路上有具体的问题，或者只是想更深入地挖掘这个主题，这里有更有用的东西。
- MLOps 社区–我可能在重复我自己，但这绝对是最好的 MLOps 社区。在一个地方有将近 10，000 名练习者，他们问问题，分享知识，互相讨论关于 MLOps 的所有事情。
- 除了非常活跃的 Slack 频道， MLOps 社区还运营一个播客，组织聚会和阅读小组，并发送时事通讯。确保检查所有这些资源。
- MLOps Live–这是由我们 Neptune.ai 组织的两周一次的活动，在这里，ML 从业者回答其他 ML 从业者关于一个选定的与 ML ops 相关的主题的问题。你可以在 YouTube 上观看之前的剧集，或者作为播客收听。
- ML 人的个人博客——许多 ML 从业者都有自己的博客，我们也强烈推荐。确保跟随例如奇普·胡延、尤金·严、杰瑞米·乔登、史瑞亚·尚卡尔或拉斯洛·斯朗格。你也可以查看 Outerbounds 博客。
- MLOps 博客–我们自己的博客也充满了由数据科学家和 ML 工程师撰写的与 MLOps 相关的文章。您将找到涵盖最佳实践、工具、真实 MLOps 管道等更多内容的文章。这里有几篇文章，我认为你应该从它们开始:
- 走向数据科学——这可能是一个显而易见的资源，但当涉及到合理规模的 ML 团队分享他们的解决方案和实践时，你可以在那里找到很多黄金。
- apply(conf)–虽然也有来自超大规模公司的发言人，但本次会议在他们的议程中为合理规模的团队提供了大量空间。这是 ML 社区最喜欢的活动之一，所以这肯定是有原因的。
- 太棒了 MLOps GitHub repos——实际上有两个同名的 repos——这里是这里是这里是。他们列出了从文章、书籍和论文到工具、时事通讯、播客和事件的所有内容。
- 如果您想后退一步，或者您刚刚开始了解 MLOps，请不要担心。每个人都有适合自己的东西。你可以去查其中一门课程:Coursera 上的 MLOps Fundamentals ，DataTalks Club 组织的 Zoomcamp 或者 ML 制作的。
MLOps 挑战和如何面对它们
原文：https://web.archive.org/web/https://neptune.ai/blog/mlops-challenges-and-how-to-face-them
大约在 2018 年，企业组织开始尝试机器学习(ML)功能，以在他们现有的解决方案上构建附加组件，或为他们的客户创建全新的解决方案。
在那个时候，这不是速度的问题，而是在竞争中获得额外的优势。如果你在你的提议中加入一些听起来科幻的 ML 功能，你可以吸引更多有兴趣尝试最新技术的客户。
在当前的 MLOps 趋势中，叙述几乎完全改变了。与任何其他时代的技术相比，人工智能(AI)每年都有指数级的进步。这个领域发展非常迅速，人们更加意识到它的局限性和机遇。
这些年来 AI/ML 的格局发生了怎样的变化，未来 MLOps 的趋势是什么？
以下是对人工智能和人工智能的发展影响最大的三大因素:
- 大规模采用-企业界现在对人工智能/人工智能解决方案非常感兴趣，这不仅是为了潜在客户和顾客的利益，也是为了获得投资者和推动增长。基于人工智能的功能可以说是公司获得资金与否的决定性因素。
- 更激烈的竞争–由于快速的大规模采用，在传统软件中增加一个简单的 ML 特性已经不足以给你带来优势。事实上，如此多的组织正在运行 AI/ML 项目，它已经成为一个标准的业务特性，而不仅仅是一个好东西。
- 高速生产–就像传统的软件生产一样，需要通过高速生产新的和改进的功能来应对激烈的竞争。考虑到早期的 ML 开发方式(没有 MLOps ),这个壮举似乎几乎是不可能的。
总的来说，我们可以说，就公司如何使用它们而言，AI/ML 解决方案正变得等同于常规软件解决方案，因此毫不奇怪，他们需要一个像 DevOps 一样规划良好的生产框架。
这个精心策划的框架就是 MLOps 。你可能听说过，但 MLOps 到底是什么？
什么是 MLOps？
MLOps 基本上是 DevOps(开发和运营团队协作的系统流程)，但用于机器学习开发。
MLOps 通过在端到端 ML 管道中引入结构和透明性，将机器学习和操作结合起来。借助 MLOps，数据科学家可以有组织、高效地与部署解决方案的数据工程师一起工作并共享他们的解决方案。MLOps 还提高了参与生产流程各个环节的各种其他技术和非技术利益相关方的可见性。
多年来，组织已经开始看到 MLOps 在执行高效生产流水线方面的优势。然而，MLOps 仍处于青少年阶段，大多数组织仍在寻找适合各自项目的最佳实现。
MLOps 中有几个漏洞和开放式挑战，需要解决。让我们来看看挑战并权衡可能的解决方案。
MLOps 挑战和潜在解决方案
我根据 ML 管道的七个不同阶段将挑战分为七组。
Fig 2. Summary of MLOps challenges across Stages of ML | Illustrated by Author
阶段 1:定义业务需求
这是业务涉众设计解决方案的初始阶段。它通常涉及三个利益相关者:客户、解决方案架构师和技术团队。在这一阶段，您设定期望值，确定解决方案的可行性，定义成功标准，并设计蓝图。
- 挑战 1:不切实际的期望
一些企业将人工智能视为解决所有问题的神奇方法。这种观点通常是由非技术利益相关者提出的，他们跟随流行词汇，而不考虑背景细节。
解决方案:这是技术领导发挥关键作用的地方。有必要让所有利益相关者意识到解决方案的可行性，并清楚地解释其局限性。毕竟，一个解决方案只和数据一样好。
- 挑战 2:误导性的成功指标
机器学习解决方案的有效性可以通过一个或多个指标来衡量。俗话说得好，“你衡量什么就得到什么”，即使在构建 ML 解决方案时也是如此。对解决方案需求的不良分析会导致不正确的度量目标，从而阻碍设计的健康发展。
解决方案:技术团队需要对解决方案目标进行深入分析，以得出现实的衡量标准。在这里，技术和非技术利益相关者都扮演着重要的角色，因为这涉及到对业务的深刻理解。决定度量标准的最佳方式是缩小两种度量标准的范围:
-
高级指标:适合客户观点，并提供解决方案发展方向的好主意。换句话说，高级指标展示了全局。
-
低级指标:这些是在解决方案开发期间支持开发人员的详细指标。通过分析多个低级指标，开发人员可以调整解决方案以获得更好的读数。低级指标加起来就是高级指标。
第二阶段:数据准备
数据准备包括根据需要收集、格式化、清理和存储数据。这是一个高度敏感的阶段，因为输入的数据决定了解决方案的命运。ML 工程师需要对数据质量和数据访问点进行健全性检查。
- 挑战 1:数据差异
数据通常需要来自多个来源，这导致了数据格式和值的不匹配。例如，最近的数据可以直接从预先存在的产品中获取，而旧的数据可以从客户端收集。映射中的差异，如果没有正确评估，可能会破坏整个解决方案。
解决方案:限制数据差异可能是一项人工密集型且耗时的任务，但您仍然需要这样做。处理这个问题的最好方法是集中数据存储，并在不同的团队之间建立通用映射。这是每个新账户的一次性设置，只要客户还在，你就能从中受益。
- 挑战 2:缺乏数据版本控制
即使使用中的数据没有任何中断或格式问题，也总会有时间问题。数据不断发展和再生，对于更新的数据转储，相同模型的结果可能会有很大差异。更新可以是不同处理步骤的形式，也可以是新的、修改的或删除的数据。如果你没有版本，你的模型性能记录不会很好。
解决方案:修改预先存在的数据转储对于空间优化非常有用，但是最好创建新的数据版本。但是，为了优化空间，您可以存储给定数据版本的元数据，以便可以从更新的数据中检索它，除非值也被修改。
阶段 3:运行实验
由于 ML 解决方案是基于大量研究的，因此需要大量实验来获得最佳路线。实验涉及开发的所有阶段，包括特征选择、特征工程、模型选择和模型调整。
- 挑战 1:低效的工具和基础设施
运行多个实验可能会很混乱，而且会耗费公司资源。不同的数据版本和流程需要在配备了在最短时间内执行复杂计算的硬件上运行。此外，不成熟的团队依赖笔记本来运行他们的实验，这是低效和耗时的。
解决方案:如果硬件是一个问题，开发团队可以寻求订购虚拟硬件的预算，例如 AWS 或 IBM Bluemix 上的虚拟硬件。当谈到笔记本电脑时，开发人员必须在脚本上进行实验，因为这样效率更高，耗时更少。
- 挑战 2:缺乏模型版本控制
每个 ML 模型都必须用多组超参数组合进行测试，但这不是主要的挑战。输入数据的变化会降低所选组合的性能，因此必须重新调整超参数。尽管代码和超参数由开发人员控制，但数据是影响受控元素的独立因素。
解决方案:应该记录模型的每个版本，以便能够找到最佳结果，并以最少的麻烦重现。这可以通过像 neptune.ai 这样的平台无缝完成，这些平台在一个地方管理所有的模型构建元数据，你可以记录、存储、组织和轻松比较不同的模型版本。
Fig 3. A practical benefit of model (experiment) versioning at play | Illustrated by Neptune.ai
- 挑战 3:预算限制
有时，由于预算限制，或者由于多个团队共享一项资源，开发团队不能使用公司资源。具有高性能计算或巨大存储容量的资源，即使它们对于扩展 ML 解决方案至关重要，也超出了大多数组织的预算标准。在这种情况下，ML 团队必须找到一种解决方法(这通常是次优的)，尽可能使解决方案以相同的功率工作。
解决方案:为了减少长时间的审批和预算限制，开发团队通常需要深入业务方面，并对限制供应和可以在这些供应上运行的工作解决方案的投资回报进行彻底的成本效益分析。团队可能需要与其他部门合作，以获得关于成本数据的准确反馈。组织中的关键决策者具有短期或长期利润导向的观点，而承诺增长的成本效益分析可能是打开一些瓶颈的驱动因素。
阶段 4:验证解决方案
ML 模型基于历史数据进行训练，并且需要在看不见的数据上进行测试，以检查模型的稳定性。模型需要在验证阶段表现良好，以便于部署。
- 挑战 1:忽略元性能
仅仅考虑模型验证的高层次和低层次的成功度量是不够的。仅仅基于这些因素就批准可能会导致处理速度变慢，并最终导致最终客户的问题升级。
解决方案:在验证解决方案时，还应考虑内存和时间消耗、硬件要求或生产环境限制等因素。它们被称为元度量，考虑它们将在很大程度上帮助您避免墨菲定律的后果。
- 挑战 2:缺乏沟通
仅仅从开发人员的角度来验证解决方案是有害的。没有让所有的利益相关者都参与到验证过程中会与期望相冲突，并导致返工和不满意。
解决方案:让业务干系人参与进来，了解模型性能如何与业务 KPI 相关联，以及它们如何直接影响干系人。一旦他们理解了这种联系，验证过程将会更加有效，因为它将结果与现实世界的含义进行了比较。
- 挑战 3:忽视偏见
偏见是非常狡猾的，即使是有经验的开发人员也可能会忽略它。例如，当结果在验证集上很好，但在输入的测试数据上却非常失败时，我们可能会有偏见。发生这种情况是因为模型是在有偏差的样本上训练的，并且当验证集具有与有偏差的样本相似的样本时。
解决方案:在多个数据组合上验证模型，无需替换。如果所有集合的结果几乎一致，这意味着模型是无偏的。但是，如果结果在这些集合之间有显著差异，这意味着需要使用偏差较小的样本更新训练数据，并且需要重新训练模型。
阶段 5:部署解决方案
在这一阶段，本地开发的解决方案在生产服务器上启动，以便最终客户可以使用。这是部署和开发团队协作执行发布的地方。
- 挑战 1:让 IT 部门大吃一惊
在真实的场景中，开发和部署团队之间会有很大的摩擦。这是因为从最初的步骤开始就没有沟通，也没有 IT 部门的参与。通常，在一个解决方案被设计出来之后，开发团队希望它在最早的时候被部署，并在很短的时间内要求 it 团队进行昂贵的设置。延迟沟通是有原因的——通过多次实验，开发团队不确定将实施哪个解决方案，并且每个解决方案都有不同的需求。
解决方案:尽快让 IT 团队参与进来。有时，他们对特定解决方案的需求方向有很好的见解。他们还可以指出可以在早期建立的潜在解决方案之间的共同要素。
- 挑战 2:缺乏迭代部署
开发和生产团队在大多数情况下是不同步的，在解决方案设计的最后才开始协作。即使 ML 有一个基于研究的方法，一次性的部署过程是错误的和低效的。
解决方案:就像在任何常规的软件部署中一样，ML 解决方案的迭代部署可以节省大量的返工和摩擦。迭代地设置解决方案的不同模块并在 sprints 中更新它们是理想的。即使在基于研究的解决方案中，需要测试模型的多个变体，也可以将模型的一个模块传达给部署团队，部署团队可以在 sprints 中更新该模块。
- 挑战 3:次优的公司框架
对于部署 ML 解决方案来说，一个公司正在开发的软件部署框架可能是次优的，甚至是不相关的。例如，一个基于 Python 的 ML 解决方案可能必须通过一个基于 Java 的框架来部署，以符合公司现有的系统。这可能会使开发和部署团队的工作加倍，因为他们必须复制大部分代码库，这需要大量的资源和时间。在资源优化方面，陈旧的、在以前构建的框架上统一运行的公司可能看不到 ML 团队的最佳结果，因为团队将忙于计算如何通过有限的可用框架来最好地部署他们的解决方案。一旦弄清楚了，他们必须为他们想要部署的每个解决方案重复次优的过程。
解决方案:对此的长期解决方案是投资创建一个独立的 ML 堆栈，它可以集成到公司框架中，但也可以减少开发方面的工作。对此的快速解决方案是利用虚拟环境为最终客户部署 ML 解决方案。Docker 和 Kubernetes 等服务在这些情况下非常有用。
- 挑战 4:审批链过长
对于需要在生产服务器上反映的每个更改，都需要批准。这需要很长时间，因为验证过程很长，最终会延迟开发和部署计划。这个问题不仅仅是生产服务器的问题，在提供不同的公司资源或集成外部解决方案方面也存在这个问题。
解决方案:为了缩短生产服务器上机器学习库的审批时间，开发人员可以将他们的代码引用限制为经过验证的代码库，如 TensorFlow 和 scikit-learn。如果使用了 Contrib 库，开发人员必须对其进行彻底检查，以验证输入和输出点。
阶段 6:监控解决方案
创建和部署解决方案并不是服务的终点。模型根据本地和过去的数据进行训练。检查它们在新的和未知的数据上的表现是至关重要的。这是建立解决方案的稳定性和成功性的阶段。
- 挑战 1:手动监控
手动监控要求很高，并且浪费资源和时间。除非资源是可消耗的，否则这不是监控模型结果的好方法。此外，对于时间敏感的项目，手动监控绝对不是一个选项，因为它无法在性能下降时立即发出警报。
解决方案:有两个选项。首先，明确地自动化监控过程和同步警报。第二，如果自动化目前不是一个即时的选项，您可以研究最近的监控数据。如果表现似乎持续下降，是时候建立再培训过程了(不是开始而是设置)。
- 挑战 2:数据趋势的变化
有时，由于与数据历史不同步的外部因素，数据可能会面临突然的变化。例如，股票数据可能会受到相关新闻文章的严重影响，或者进口数据可能会受到新税法的影响。清单是无穷无尽的，处理这样的突然中断是一个挑战。
解决方案:解决方案是保持数据最新或极其新鲜，尤其是在解决方案对时间敏感的情况下。这可以通过可以定期检查数据的自动爬虫来完成。这也将防止性能数据的滞后。
第七阶段:再培训模式
模型再训练是任何机器学习解决方案不可避免的阶段，因为它们都严重依赖数据，并且数据趋势会随时间而变化。有效的模型再训练有助于保持解决方案的相关性，并节省重新创建新解决方案的成本。
- 挑战 1:缺少脚本
不太成熟的 ML 团队是手工密集型的。一个早期团队仍在寻找框架、最佳解决方案和职责。然而，这也降低了团队效率，增加了重新培训的等待时间。
解决方案:总结 ML 管道的脚本创建或调用起来并不困难，并且通过一次性设置节省了时间和资源。创建脚本的最佳方式是对不同的子模块使用条件调用，这样就可以决定自动化的程度。
- 挑战 2:决定触发阈值
你应该什么时候开始重新训练模型？每一个机器学习模型在商业中都有一些现实世界的后果，一个偏离的表现可以显著影响各种团队的表现。因此，知道何时开始再培训是至关重要的，也同样具有挑战性。
解决方案:由于业务利益相关者想要良好的模型性能，权衡他们的观点和他们对性能下降的挑战是很重要的。例如，预测客户付款日期的模型会直接影响收款人发出的电话。因此，在进行再培训电话时，需要考虑诸如顺便拜访的点击次数和损失的付款等因素。
- 挑战 3:决定自动化程度
模型再训练可能很棘手。一些解决方案的再培训可以完全自动化，而其他解决方案需要密切的手动干预。不成熟的团队可能会犯在没有评估低性能原因的情况下自动化整个再培训脚本的错误。模型需要重新训练主要是因为偏离数据。在数据堆上训练模型，但是随着时间的推移，学习到的趋势可能不再适用于传入的数据。在这里调整模型超参数不会改变太多。
解决方法:解决方法是观察性能偏差，找出其背后的原因。如果数据偏差很小，自动化脚本可以很好地处理再训练过程。然而，如果数据发生了重大变化(一个极端的例子:全球危机期间就业数据的偏差)，探索性数据分析是可行的方法(即使这是一个人工密集型过程)。
结论
我们探讨了 MLOps 和 ML 管道中最常见的高级挑战。如你所见，它们是沟通和技术挑战的混合体。
每个阶段都有几个较低层次的挑战，但从解决重大组织、沟通和技术问题的 MLOps 战略开始，是解决低层次挑战的关键。
在本文中，我使用了我之前在 Neptune 博客上发表的一些内容，您可能会感兴趣:当 MLOps 是一个组织和沟通问题时，而不是一个技术问题。
萨马德里塔·戈什
一个内容营销和 AI 爱好者。她的使命是帮助基于人工智能的公司建立品牌知名度，并通过高质量的内容抓住网民的巨大市场，无论是信息丰富的博客还是教育播客！
阅读下一篇
最佳 MLOps 工具以及如何评估它们
12 分钟阅读| Jakub Czakon |年 8 月 25 日更新
在我们的一篇文章中——机器学习团队实际使用的最好的工具、库、框架和方法——我们从 41 家 ML 初创公司学到的东西——Acerta 的 CTO Jean-Christophe Petkovich 解释了他们的 ML 团队如何接近 MLOps。
据他所说，一个完整的 MLOps 系统有几个要素:
- 您需要能够构建包含预处理数据和生成结果所需的所有信息的模型工件。
- 一旦您能够构建模型工件，您必须能够跟踪构建它们的代码，以及它们被训练和测试的数据。
- 您需要跟踪所有这三样东西，模型、它们的代码和它们的数据，是如何关联的。
- 一旦您可以跟踪所有这些内容，您还可以将它们标记为准备就绪，进行生产，并通过 CI/CD 流程运行它们。
- 最后，为了在该过程的最后实际部署它们，您需要某种方法来基于该模型工件旋转服务。
这是对如何在公司中成功实施 MLOps 的高度概括。但是理解高层需要什么只是拼图的一部分。另一个是采用或创建适当的工具来完成工作。
这就是为什么我们编制了一份最佳 MLOps 工具的清单。我们将它们分为六类，以便您可以为您的团队和业务选择合适的工具。让我们开始吧！
MLOps 工程师是个东西吗？我们就此询问了 6 名工程师
原文：https://web.archive.org/web/https://neptune.ai/blog/mlops-engineer
当谈到在工作场所使用机器学习技术时，it 部门遇到了一些困难。一个是设计一个框架的需求，该框架将允许模型同时被安全地扩展和部署。因此，开发和运营团队必须更加紧密地合作。
如今市场上已经有了一个将这两个世界结合在一起的术语: DevOps 。尽管它很受欢迎，但 DevOps 需要专门的技术来支持机器学习。
专业人士一直在考虑 MLOps(机器学习操作)来应对这些需求，并从智能系统中获得更高的性能。
什么是 MLOps(快速提醒)
MLOps 是一组最佳实践，能够更好地管理 ML 项目和模型的顺利生产部署。如果你想自动化智能算法的设计和维护，并管理它们的生命周期，这就是你要走的路。MLOps 最佳实践可以保证 ML 模型始终保持高质量。
机器学习、数据工程和 DevOps 都集中在这个领域。换句话说，它将机器学习与设计、构建和维护系统的任务联系起来。
如果你在这里，你可能已经知道 MLOps 是什么，但是如果你想更深入地挖掘，请查看这篇文章“m lops:它是什么，它为什么重要，以及如何实现它”。您将了解更多关于 MLOps 及其在机器学习行业中的潜在应用。
MLOps 工程师及其在 ML 团队中的角色
MLOps 是将 DevOps 思想应用于 ML 系统的学科。它有助于在大数据科学计划中创建和部署 ML 模型。在大多数项目中，操作元素使模型创建相形见绌。因此，这通常不仅仅需要数据科学家。
大公司把职能和职责处理得相当好。根据公司和项目的不同，数据科学团队可能承担一项或多项责任。在中小型团队中，机器学习团队的角色有时是模糊的。让我们看看 MLOps 工程师在这个范围内的位置。
数据科学家
他们的职责是找到并应用最佳的机器学习模型来应对业务挑战。他们试验不同的算法，微调他们的超参数，然后使用一系列标准评估和证实他们的结果。
对于较小的团队，数据科学家处理大多数额外的角色，导致员工不堪重负。数据科学家也是小公司的数据架构师和工程师。
软件工程师
使用机器学习预测需要使用 Jupyter 笔记本和 Python 脚本。如果它有令人愉快的界面，软件工程师会使用它。此外，软件工程师会担心传统数据科学家不会担心的事情。一些例子包括访问控制、使用数据收集、跨平台集成、托管。
从事机器学习项目的软件工程师应该懂数据。但并不是所有的软件工程师都是模型建造者。
数据工程师
数据工程师主要是创建数据管道。数据管道提供来自源、预转换和存储的连续数据流。这就是所谓的 ETL。数据工程师使用 Airflow 和 Prefect 构建 ETL 管道。他们帮助安排和协调大量的职责。
MLOps 工程师(或 ML 工程师)
MLOps 工程师支持生产系统的模型部署自动化。自动化程度因组织而异。MLOps 工程师采用数据科学家的模型，并使使用该模型的软件可以访问该模型。机器学习模型通常使用 Jupiter 笔记本或脚本文件来构建、测试和验证。然而，软件开发人员希望机器学习模型可以通过 REST 这样的可调用 API 获得。
为了更多地了解 MLOps 工程师的角色，我联系了他们中的一些人，并问了几个问题。
我的客座专家是:
- 卡洛琳·扎戈 ，巴西，目前在 XP Inc .担任 MLOps 工程师；
- 德米特里·戈尔尤诺夫 ，德国，在 deepset 担任 MLOps 工程师；
- 麦莎·达乌德 ，纽西兰，在 Servian 担任 MLOps 工程师；
- Amy Bachir ，美国，在 Interos Inc .担任高级 MLOps 工程师；
- 阿列克谢·格里戈里耶夫 ，祖籍俄国，现居柏林，OLX 集团首席数据科学家，DataTalksClub 创始人，《机器学习图书营》作者，近期也在免费的机器学习训练营授课；
- 最后但同样重要的是， 英国尼尔·拉西亚 ，在蒙索银行担任机器学习副总监。
这些人每人回答了七个关于 MLOps 工程师角色的问题，这些问题可能有助于澄清一些误解。
你是怎么开始做 MLOps 工程师的？
Dmitry Goryunov :“当我对机器学习产生兴趣时，我已经在软件工程领域工作了十多年。Coursera 上有几门关于这个主题的课程。它们并不容易，但经历它们却很有趣。后来，我加入了一个自然语言处理团队，该团队有几名出色的数据科学家，但没有工程师。”
Amy Bachir :“在进入 MLOps 之前，我曾担任过几年的 DevOps 工程师，因此我已经具备了 CI/CD(持续集成/持续部署)、GitOps、部署、监控和自动化方面的经验。然而，我错过了机器学习应用程序生命周期特有的部分，所以我开始查看在线课程来学习基础知识。我在 Udacity 找到了一个非常有趣和全面的纳米学位，用于建立机器学习模型，所以我拿了那个纳米学位，并从它毕业。在获得了纳米学位并在 DevOps 中有了扎实的经验后，我很容易就在 MLOps 中获得了第一个角色。”
卡洛琳·扎戈:“我最初是一名数据科学家实习生，但我喜欢开发运维以及软件工程。然后，我找到了 MLOps，它集合了我喜欢的三个领域。”
Dmitry :“从我的软件工程背景来看，我习惯了软件开发生命周期。你知道，规划、开发、测试、部署、监控等等。起初，我对曼梯·里的不同感到震惊。这看起来像一个狂野的西部，一个数据科学家在 Jupyter 笔记本上训练一个模型，测量它的性能，然后把结果以二进制文件的形式交给工程师。
工程师在云中部署模型，使其成为业务逻辑的一部分，并将二进制文件永远留在生产中:没有适当的监控，没有可追溯性。我甚至没有提到持续集成之类的东西。最糟糕的是，在二进制文件部署后，每个人都去了下一个项目。
我很幸运在我的第一个团队中有非常善解人意的数据科学家；我们一起看到了 MLOps 的作用，以确保 ML 模型受益于软件开发中建立的相同的最佳实践。这样做可以确保生产中的 ML 模型具有与测试数据集大致相同的性能。"
如你所见，成为 MLOps 工程师的道路千差万别。没有唯一的配方。对机器学习感兴趣并且已经完成了与 MLOps 合作过程一半的 DevOps 专家是该领域新人的最典型来源。
无论你怎么划分，成为一名 MLOps 工程师都需要付出艰苦的努力。这是一个新领域，这是最大的挑战之一。因此，在许多情况下，可能缺乏可用的材料。然而，目前有许多工具可以帮助你变得更加专业。Deeplearning.ai 在 Coursera 上的面向生产的机器学习(MLOps)专业是最知名的专业之一，奥赖利的许多材料也是如此。
ML 工程师和 MLOps 工程师有区别吗？
我觉得每当讨论 MLOps 工程师的角色时，这个问题总是会出现。有区别吗？在文献中没有很多讨论涉及 MLOps 工程师和 ML 工程师之间的任何区别。这些内容分别针对每一个问题。需要注意的一点是每个领域的职责是如何不同的。
文章“什么是机器学习工程师:责任、技能和带来的价值”将机器学习工程师定义为“结合了软件工程专业知识和机器学习知识的人。这里的重点是工程，而不是构建 ML 算法。该专家的主要目标是将 ML 模型部署到生产中，并尽可能自动化理解数据的过程。”
现在，在这个“数据科学家 vs 机器学习运营工程师。这里是区别"，我们读到“作为一名 MLOps 工程师，您可以期望与数据科学家合作，通过数据工程和 DevOps 工具的实践，在您的公司软件中连接从测试到生产的差距。”
看起来这两个角色之间的区别没有很好的定义。人们经常互换使用这些术语。当然，这很大程度上取决于 ML 团队的规模和结构。无论如何，从理论到实践，让我们在源头上发现它是什么样子的。
是啊！绝对的！在我看来，ML 工程师建立并重新训练机器学习模型。MLOps 工程师支持 ML 工程师。MLOps 工程师构建并维护一个平台，以实现机器学习模型的开发和部署。他们通常通过标准化、自动化和监控来做到这一点。MLOps 工程师重申了平台和流程，以使机器学习模型的开发和部署更快、更可靠、可重复和高效。
Neal Lathia :“在 Monzo 内部，我们(还)没有任何人被称为“MLOps 工程师”。“相反，我们有:
- 设计、训练和运送模型的机器学习科学家；
- 拥有并管理 Monzo 基础设施的几个后端工程师团队，以及
- 一个后端工程师，他专注于特定于 ML 的系统，比如我们的特性库。*
对我来说，这和工程团队和运营团队的区别是一样的。工程师创造软件，Ops 提供运行软件的基础设施，并确保软件可靠运行。然而，界限是模糊的，MLOps 工程师可以(并且经常应该)端到端地做事。
尽管 MLOps 已经讨论了一段时间，但它仍在不断发展。作为一名数据科学家或机器学习工程师，你可能会发现自己承担了 MLOps 工程师的一些任务。另一方面，拥有小项目甚至小团队的公司可能觉得没有必要根据员工的职称来分配具体的职责。正如 Alexey 指出的，MLOps 工程师的工作可能会令人困惑，因为它仍然是一个相对较新的研究领域。在其他情况下，MLOps 工程师的工作可能被称为不同的名称或整个团队。
MLOps 工程师是做什么的？在工作中，你的日常是怎样的？
麦莎·达乌德:“我们每天早上都要早起，之后通常会和同事单独开几次会，回答彼此的问题或者制定计划开始一项任务。我一直工作到午餐时间，我把午餐时间分为 15 分钟步行(跑步机)和 15 分钟吃零食。之后，我会回到办公桌前，和同事们聊聊事情的进展。如果我在下午 4 点左右完成一项任务，那么，是的，我可以随意看看一些个人发展课程/读物，因为 Servian 领导鼓励我们保持更新。这种情况下我一般下午 6 点结束。”
哦，看情况。当你在 Zalando 这样的公司工作时，你的工作会让数据科学家富有成效。因此，您需要与数据科学家密切合作，了解他们将要做什么，定义他们的需求。然后，您尝试在公司的基础架构中满足他们的需求，构建数据管道，部署服务器来托管模型，组织监控和持续集成。现在我在 Deepset 工作，我试着总结我以前的经验。现在，它更多的是建立一个方便的工具箱，以便使用语义搜索和问题回答系统的数据科学家可以通过点击几个按钮来训练、评估和部署问题回答系统。
Neal :“我从煮咖啡开始新的一天！然后我会做一些事情，比如参加规划和站立会议，在特定的工作领域与 ML 科学家合作(通过对他们的设计和建议提供反馈)，以及在优先领域与公司的其他领导合作。如果我们的系统有任何问题，我会全力以赴帮助解决。我现在也在花相当多的时间招聘和面试人员。”
贵公司的 MLOps 团队和数据科学团队之间的关系如何？
Amy :“是很亲密的关系。我们一直在一起工作。在很大程度上，我们所做的一切都是为了他们，所以我们在设计任何东西之前都会咨询他们。我们还进行季度调查，以获得他们对现有系统的反馈，以及他们认为可能缺少或不适合他们的内容。总的来说，我认为在我们构建的所有产品中，让最终用户参与进来非常重要，因为他们最终是消费者，我们构建的产品应该解决他们的问题，满足他们的需求。”
Alexey :“我们在 OLX 没有独立的数据科学团队，我们在跨职能团队中工作，数据科学家与其他人一起研究产品的同一部分。然而，我们有一个中心团队，你们可以称之为 MLOps。团队的作用是帮助数据科学家变得更加有效，尤其是在没有很多工程支持的团队中。该团队还标准化了所有不同包装的一些流程。”
你认为这个职位的前景如何？
Caroline :“我相信这个职位在拥有数据科学团队的公司中会越来越受欢迎，因为只有一个没有构建、生产和监控的必要结构的模型，才不会有公司期望的回报。”
Dmitry :“我们看到如今出现了许多自动化 MLOps 的工具。如果我们在几年内继续朝着这个方向发展，数据科学家团队可能不需要专门的 MLOps 工程师的支持。这是你在海王星所做的，这是我们在 Deepset 所做的。
在这种趋势的另一面，我们看到许多现成的模型被可能没有机器学习背景的人使用。像 Haystack、抱抱脸、Neptune Model Registry 这样的产品使 ML 民主化；它们使得 ML 成为应用程序的一部分变得更加容易。
这两种趋势可能会导致一个专家负责一个模型的整个生命周期。"
Neal :“随着机器学习的知识变得越来越大众化，我相信 ML 将越来越多地与工程交叉，而不需要成为它自己单独的东西。我希望在(不久的)将来，工程师将培训和运输 ML 系统作为他们日常工作的一部分，而不需要去专门的团队或通过专门的工具。都会成为主流。”
看起来 ML 解决方案的进步是 MLOps 工程师角色在 ML 团队中出现和成长的基本要求。在使用机器学习方面更先进的公司对专家的迁移有更大的影响，这些专家越来越专注于数据项目的各个阶段。随着这些职业的兴起，出现了“数据工程师”和“操作工程师”这两个术语
随着每项活动难度的增加，分离和专业化变得更加必要(例如，新的数据存储和建模方法。MLOps 工程师不仅仅是一个已经被非常有效地完成的事情的花哨名字。
你认为这个新角色的存在对科技行业产生了怎样的影响？
MLOps 是特定于云的实践。在我开始行业职业生涯的早期，我曾经看到 ML 工程师在本地工作，并在云提供商中部署他们的模型——尽管这已经慢慢转变为越来越依赖云服务。MLOPs 正以另一种方式进行 ML 实践；我们在从笔记本电脑到部署的每一步都使用云服务，尽管这不是强制性的，而是推荐的最佳实践。
Neal :“每当一个新的职位出现在市场上，这是一个将更多人带入科技世界的好机会。这也是一个很好的机会来建立解决同类问题的社区。然而，当一个职位头衔是新的时，这也意味着大多数公司不太清楚他们想要或期望从这个职位上得到什么，或者如何让这个职位最适合他们的公司。几年前数据科学家就是这种情况。实际上，这意味着不同公司的数据科学家经历可能会大不相同。”
最后:对于正在考虑从事 MLOps 工程的人，你有什么建议？
最有影响力的机器学习系统是那些可以安全快速地推出，并能对你公司的产品产生积极影响的系统。因此，我的建议是，始终关注您构建的工具是否能够实现这一点。
麦莎:“我非常喜欢做 MLOps 工程师，就像我以前喜欢从事 ML 研究一样。MLOps 的角色是团队合作，所以你需要为合作的想法做好准备，特别是因为没有唯一正确的方法来完成这项工作。很有趣，相信我。
云提供商发展非常快，尤其是在开发 ML SDKs(软件开发工具包)方面。你需要很大的耐心和自我激励来让自己保持在正轨上。"
Amy :“这是个棘手的问题！MLOps 是一个非常令人兴奋的角色！创新空间很大！你永远不会感到无聊。同时，这是一个非常具有挑战性的角色。一个人几乎不可能具备在这个职位上取得成功所需的综合技能，所以要做好大量学习的准备。”
我会说，通过建模了解解决问题的过程，了解进入生产的步骤，以及学习专注于机器学习的软件工程概念，如优化、测试和监控，是极其重要的。我还认为 DevOps 概念，当然还有数据科学，应该是 MLOps 工程师知识的一部分
Alexey :“不要听数据科学家关于 MLOps 的建议。”
德米特里:“这要看这个人有什么背景。如果有人像我一样来自软件工程师工作家庭，建议是至少学习机器学习的基础知识。
我不是说要获得这个领域的博士学位，更像是通过在线课程或者读几本书。现在很容易在网上找到很多材料。吴恩达的课程是我如何开始的。
要理解 ML 的概念并获得基本的理解并不容易。至少，对我来说不容易。但是，我向你保证，这是值得的。对 ML 的基本理解可以让你和你的数据科学家说同样的语言，这对 ML 项目的成功很重要。
在学习 ML 的时候，你可能会发现其中一个主题比其他的更有趣。如果是这种情况，去读几篇论文或者看几个解释它们的视频。视频有时甚至更好。深入某一特定话题。通过这种方式了解 ML 更有趣。"
结论
很容易观察到客人们对某些话题的观点的一致和不同之处。例如，MLOps 工程师和 ML 工程师之间的区别很有意思。艾米和阿列克谢提出了在比较这两种职业时需要考虑的一些关键因素。据双方称，MLOps 专业平台使 ML 工程师能够快速有效地工作。
对于那些质疑这个角色命运的人，一些人认为 MLOps 将成为一个独立的职业。相比之下，其他人认为这些方法将更多地融入现有的工作中，因为新技术正在开发，以简化这一过程。
话虽如此，前景还是一片光明。无论 MLOps 工程师的未来如何，最佳实践、新工具和工作流都将继续存在，并为数据世界带来的挑战做出更大贡献。
Dairenkon Majime
我目前在 Loft 担任数据科学家实习生，在 Tera 担任数据学习辅导员和导师。我也是一名自由职业内容作家，撰写关于一般技术、数据科学和机器学习的文章。我热衷于通过教授他人来学习，并致力于为所有人提供开放和免费的教育。
阅读下一篇
最佳 MLOps 工具以及如何评估它们
12 分钟阅读| Jakub Czakon |年 8 月 25 日更新
在我们的一篇文章中——机器学习团队实际使用的最好的工具、库、框架和方法——我们从 41 家 ML 初创公司学到的东西——Acerta 的 CTO Jean-Christophe Petkovich 解释了他们的 ML 团队如何接近 MLOps。
据他所说，一个完整的 MLOps 系统有几个要素:
- 您需要能够构建包含预处理数据和生成结果所需的所有信息的模型工件。
- 一旦您能够构建模型工件，您必须能够跟踪构建它们的代码，以及它们被训练和测试的数据。
- 您需要跟踪所有这三样东西，模型、它们的代码和它们的数据，是如何关联的。
- 一旦您可以跟踪所有这些内容，您还可以将它们标记为准备就绪，进行生产，并通过 CI/CD 流程运行它们。
- 最后，为了在该过程的最后实际部署它们，您需要某种方法来基于该模型工件旋转服务。
这是对如何在公司中成功实施 MLOps 的高度概括。但是理解高层需要什么只是拼图的一部分。另一个是采用或创建适当的工具来完成工作。
这就是为什么我们编制了一份最佳 MLOps 工具的清单。我们将它们分为六类，以便您可以为您的团队和业务选择合适的工具。让我们开始吧！
真实世界的 MLOps 示例:超因子中的模型开发
原文：https://web.archive.org/web/https://neptune.ai/blog/mlops-examples-model-development-in-hypefactors
在“真实世界的 MLOps 示例”系列的第一部分中，MLOps 工程师 Jules Belveze 将带您了解 Hypefactors 的模型开发流程，包括他们构建的模型类型、他们如何设计培训渠道，以及您可能会发现的其他有价值的细节。享受聊天！
公司简介
Media monitoring dashboard in Hypefactors | Source
Hypefactors 提供一体化媒体智能解决方案，用于管理公关和沟通、跟踪信任度、产品发布以及市场和金融情报。他们运营着大型数据管道，实时传输世界各地的媒体数据。人工智能用于许多以前手动执行的自动化操作。
嘉宾介绍
你能向我们的读者介绍一下你自己吗？
嘿，斯蒂芬，谢谢你邀请我！我叫朱尔斯。我 26 岁。我在巴黎出生和长大，目前住在哥本哈根。
嘿朱尔斯！谢谢你的介绍。告诉我你的背景以及你是如何成为催眠师的。
我拥有法国大学的统计学和概率学士学位以及普通工程学硕士学位。除此之外，我还毕业于丹麦的丹麦技术大学，主修深度学习的数据科学。我对多语言自然语言处理非常着迷(并因此专攻它)。在微软的研究生学习期间，我还研究了高维时间序列的异常检测。
今天，我在一家名为 Hypefactors 的媒体智能技术公司工作，在那里我开发 NLP 模型，帮助我们的用户从媒体领域获得洞察力。对我来说，目前的工作是有机会从原型一直到产品进行建模。我想你可以叫我书呆子，至少我的朋友是这么形容我的，因为我大部分空闲时间不是编码就是听迪斯科黑胶。
超因子模型开发
你能详细说明你在 Hypefactors 建立的模型类型吗？
尽管我们也有计算机视觉模型在生产中运行，但我们主要为各种用例构建 NLP(自然语言处理)模型。我们需要覆盖多个国家和处理多种语言。多语言方面使得用“经典机器学习”方法开发变得困难。我们在变形金刚库的基础上打造深度学习模型。
我们在生产中运行各种模型，从跨度提取或序列分类到文本生成。这些模型旨在服务于不同的用例，如主题分类、情感分析或总结。
你能从 Hypefactors 中挑选一个用例，从头到尾地向我介绍一下你的机器学习工作流程吗？
我们所有的机器学习项目都倾向于遵循类似的生命周期。我们要么启动一个 ML 项目来改善我们用户的体验，要么为我们客户的体验添加一个有意义的特性，然后将其转化为一个 ML 任务。
让我向您介绍一下我们最新添加的命名实体识别模型的流程。我们从使用开箱即用的模型制作 POC(概念验证)开始，但是由于我们的生产数据和模型微调的数据之间存在一些偏差，我们必须按照我们整齐定义的注释准则在内部标记我们的数据。然后，我们开始设计一个相对简单的模型，并对其进行迭代，直到我们达到与 SOTA 相当的性能。然后对模型进行了推理优化，并在现实生活条件下进行了测试。
基于 QA(质量保证)会议的结果，在将模型部署到生产环境之前，我们迭代数据(例如，细化注释指南)以及模型(例如，提高其精度)。一旦部署完成，我们的模型将受到持续监控，并通过主动学习进行定期改进。
ML workflow at Hypefactors | Source: Author
你能描述一下你的模型开发工具吗？
我们使用几种不同的工具进行模型开发。我们最近将我们的代码库移植到了 PyTorch Lightning 和 T2 Hydra 的组合中，以减少样板文件。前者支持四个主要组件之间的结构化代码:
- 1 数据
- 2 型号
- 3 优化
- 4 非必需品
PyTorch Lightning 抽象掉了所有的样板代码和工程逻辑。自采用以来，我们已经注意到在迭代模型或启动新的概念验证(POC)时速度显著加快。
此外，Hydra 帮助您“优雅地”编写配置文件。为了帮助我们设计和实现神经网络，我们非常依赖 Transformer 库。在跟踪实验和数据版本化时，我们使用 Neptune.ai，它与 Lightning 有着平滑的集成。最后，我们选择 Metaflow 而不是其他工具来设计和运行我们的训练管道。
Hypefactors model training and evaluation stack | Source: Author
你的 NLP 用例是如何驱动培训管道设计选择的？
运行端到端的 NLP 训练管道需要大量的计算能力。对我来说，自然语言处理中最艰巨的任务之一就是数据清洗。当处理直接从网络或社交媒体中提取的文本数据时，这变得更加重要。即使像 B ERT 或 GPT 这样的大型语言模型相当健壮，数据清理也是至关重要的一步，因为这可以直接影响模型的性能。这意味着相当繁重的预处理，因此需要并行计算。此外，微调预先训练的语言模型需要在针对计算优化的硬件(例如，GPU、TPU 或 IPU)上运行训练。
此外，我们对待 NLP 模型的评估不同于“常规”模型。尽管评估指标很好地代表了模型的性能，但是我们不能仅仅依赖它们。这个问题的一个很好的例子是用于抽象概括的 ROUGE score。尽管 ROUGE 评分可以很好地代表摘要和原文之间的 n 元语法重叠，但仍需要人工检查来评估语义和事实的准确性。这使得不需要任何人工干预的全自动管道变得非常困难。
您的培训渠道使用什么工具，它们的主要组成部分是什么？
我们最近开始设计可重用的端到端培训管道，主要是为了节省我们的时间。我们的管道是使用网飞的 Metaflow 设计的，它们都共享相同的构建模块。
在处理之前，我们首先从我们的标注工具中获取新的手工标注的数据。处理后，数据集将与配置文件一起进行版本化。
我们还保存代码和 git 散列，使得完全相同的实验重现成为可能。然后我们开始训练想要的模型。
在训练结束时，最佳重量会保存到内部工具中，并生成一份训练报告，使我们能够将这次跑步与之前的跑步进行比较。最后，我们将检查点导出到 ONNX，并优化推理模型。
参见:纵向扩展 PyTorch 推理:用 ONNX 运行时服务数十亿次日常 NLP 推理【微软开源博客】
我们的管道是这样设计的，任何有一点技术知识的人都可以复制一个实验，或者用新注释的数据或不同的配置训练现有模型的新版本。
什么样的工具在外面很容易获得，什么样的工具需要在内部实现？
关于建模方面，我们非常依赖变形金刚库。然而，由于我们用例的特殊性(web 数据和多语言需求)，我们在它的基础上构建模型。使用如此庞大的模型的一个缺点是它们很难扩展。有相当多的工具可以用来缩小基于 transformer 的模型(例如，DeepSpeed、DeepSparse)，但是它们受到基本模型的限制。我们已经实现了一个内部工具，使我们能够训练各种早期存在的架构，执行模型提取、修剪或量化。
实验跟踪和元数据存储空间具有大量易于使用的完整工具，因此我们没有必要重新发明轮子。
ML 工作流编排器也是如此。我们实际上花了相当多的时间挑选一个足够成熟并且学习曲线不太陡的。我们最终选择了 Metaflow 而不是 Kubeflow 或 MLFlow ，因为它易于采用，可用的功能以及不断增长的社区。
总的来说，对于机器学习工作流程的所有不同构建模块，有太多的工具可用，这也可能是压倒性的。
您使用什么类型的硬件来训练您的模型，您使用任何类型的并行计算吗？
我们所有的训练流程都在配备一个或多个 GPU 的机器上运行，具体取决于给定任务所需的计算能力。PyTorch Lightning 使得从单 GPU 切换到多 GPU 变得相对容易，并且还提供了各种后端和分布式模式。NLP 任务需要相对繁重的预处理。因此，我们通过 DDP PyTorch 模式使用分布式训练，该模式使用多处理而不是线程来克服 Python 的 GIL 问题。与此同时，我们试图在设计模型时最大限度地利用张量运算，以充分利用 GPU 的能力。
由于我们只对模型进行微调，因此不需要我们执行分片训练。然而，当我们需要快速迭代时，我们偶尔会在 TPU 上训练模型。
说到数据处理，我们使用“数据集”，这是一个构建在 Apache Arrow 之上的 Python 库，支持更快的 I/O 操作。
你希望在不久的将来出现什么工具？
我认为每个机器学习工程师都会同意，目前缺少的是一个统治一切的工具。人们需要至少 5 到 6 种不同的工具用于训练，这使得维护和学习变得很困难。我真的希望我们将很快看到包含多个步骤的新兴工具。
在 NLP 领域，我看到越来越多的人专注于确保标注质量，但是我们仍然受到任务性质的限制。发现错误的标签是一项艰巨的任务，但一个可靠的工具可以真正改变游戏规则。我想大多数数据科学家都会同意，数据检查是一项非常耗时的任务。
此外，工作流程的一个重要方面是模型测试。在 NLP 中，找到保证模型忠实性的相关度量标准是非常棘手的。有几个工具出现了(例如，我们开始使用微软的"清单")，但在我看来，在这个领域拥有更广泛的工具会很有趣。
对于每项任务，我们的数据专家都会提出一组行为测试案例，从相对简单到更复杂，分为“测试方面”然后，我们使用清单生成不同测试的摘要，并比较实验。这同样适用于模型的可解释性。
感谢 Jules Belveze 和 Hypefactors 的团队与我们一起创作了这篇文章！
MLOps 是 DevOps 的扩展。不是叉子——作为 MLOps 初创公司 CEO，我对 MLOPS 论文的看法
原文：https://web.archive.org/web/https://neptune.ai/blog/mlops-is-extension-of-devops
到现在为止，每个人都应该已经看到了 MLOps 文件。
由 dominik kreuzberger，niklas kühl，sebastian hirschl 主持
很棒的东西。如果你还没有读过，一定要读。
作者对以下内容进行了全面概述:
- 什么是 MLOps，
- MLOps 生态系统的原理和组成部分，
- 参与执行 MLOps 的人员/角色，
- 许多团队都有的 MLOps 架构和工作流。
他们解决了规范 MLOps 运动中的丑陋问题:所有这些 MLOps 堆栈组件实际上是如何相互关联并一起工作的？
在这篇文章中，我分享了我们作为 MLOps 工具公司的现实以及我个人对 MLOps 的看法。我今天将在这里谈论的许多事情我已经看到了。有些是我 3-4 年的赌注。
你要知道我从哪里来:
- 我有丰富的软件开发背景(15 年以上的软件工作经验)。经历了德沃普斯革命。从软件来到 ML。
- 创建了两家成功的软件服务公司。
- 创建了 neptune.ai ，一个用于 ML 元数据存储的模块化 MLOps 组件，又名“实验跟踪器+模型注册表”。
- 我领导产品，观察这个市场角落的用户、客户和其他供应商在做什么。
- 我们的大多数客户都在以合理的规模进行 ML/MLOps，而不是大型高科技 FAANG 公司的超大规模。
如果你想要一个 TLDR，这里就是:
- MLOps 是 DevOps 的扩展。不是分叉:
–MLOps 团队应该由开发运维工程师、后端软件工程师、数据科学家+普通软件人员组成。我看不出 ML 和 MLOps 的工程师在这里会起什么特殊作用。
—我们应该围绕 CI/CD 建立特定于 ML 的反馈循环(审核、批准)。 - 我们需要自动持续监控和定期人工检查。
- 将只有一种类型的 ML 元数据存储(模型优先)，而不是三种。
- 工作流编排组件实际上是两件事，工作流执行工具和管道创作框架。
- 我们不需要模型注册中心。如果有的话，它应该是一个工件库的插件。
- 模型监控工具将与 DevOps 监控堆栈合并。可能比你想象的要快。
好吧，我来解释一下。
MLOps 是 DevOps 的扩展。不是叉子。
首先，谈论 MLOps 和 MLOps 堆栈组件很好，但归根结底，我们都只是在这里交付软件。
一种特殊类型的软件，里面有 ML，但仍然是软件。
我们应该考虑如何连接到现有的和成熟的 DevOps 实践、堆栈和团队。但是我们在 MLOps 中做的很多事情都是构建 DevOps 中已经存在的东西，并在它们上面打上 MLOps 的印记。
MLOps is an extension of DevOps
当公司将 ML 模型添加到他们的产品/服务中时，某些东西已经存在了。
那就是常规的软件交付过程和 DevOps 工具堆栈。
事实上，几乎没有人是从零开始的。
最后，我认为 MLOps 和 DevOps 堆栈不会彼此相邻，而不仅仅是一个堆栈。
我的意思是，如果你同意我说的“ML 只是一种特殊类型的软件”，MLOps 只是一种特殊类型的 DevOps。
因此，弄清楚 MLOps 架构和原则是很重要的，但我想知道这与扩展现有的 DevOps 原则、流程和工具堆栈有什么联系。
生产 ML 团队组成
让我们把这个“MLOps 是 DevOps 的扩展”的讨论带到团队结构中来。
我们需要谁来构建可靠的 ML 驱动的软件产品？
- 负责软件交付可靠性的人🙂
- 我们正在开发产品，因此产品和最终用户之间需要有明确的联系。
- 我们需要构建产品的 ML 特定部分的人。
- 我们需要构建产品的非 ML 特定部分的人。
很好，现在，那些人到底是谁？
我相信这个团队会是这样的:
- 软件交付可靠性:DevOps 工程师和 sre(devo PS vs SRE 这里)
- 特定于 ML 的软件:软件工程师和数据科学家
- 非特定 ML 软件:软件工程师
- 产品:产品人员和主题专家
等等，军事行动工程师在哪里？
ML 工程师怎么样？
让我解释一下。
MLOps 工程师只是 DevOps 工程师
这可能有点极端，但我没有在这个团队中看到任何特殊的 MLOps 工程师角色。
今天的 MLOps 工程师要么是 ML 工程师(构建特定于 ML 的软件)，要么是 DevOps 工程师。这里没什么特别的。
我们应该称一个主要操作 ML 驱动的软件交付的 DevOps 工程师为 MLOps 工程师吗？
我的意思是，如果你真的想，我们可以，但我不认为我们需要一个新的角色。这只是一个 DevOps 工程。
不管怎样，我们肯定需要这个人在团队里。
现在，让我感兴趣的是这里。
数据科学家 vs ML 工程师 vs 后端软件工程师
首先，数据科学家、ML 工程师、软件工程师和 ML 研究员之间的实际区别是什么？
今天我是这样看的。
总的来说，ML 研究人员非常重视特定于 ML 的知识，而不太擅长软件开发。
软件工程师擅长软件，不太擅长 ML。
数据科学家和 ML 工程师介于两者之间。
但那是今天，甚至可能是昨天。
有几个因素会很快改变这种情况:
- 业务需求
- ML 教育的成熟
先说业务需求。
产品公司内部部署的大多数 ML 模型将不会是尖端的，超级重在调整。
他们不需要最先进的模型压缩技术来降低延迟或类似的调整。它们将是在该组织拥有的特定数据集上训练的一般模型。
这意味着数据科学家和 ML 研究人员对超级定制模型开发的需求将不会像构建包装和部署一般模型那样普遍。
肯定会有需要大量工作的团队。只是市场的大多数不会。尤其是那些基线模型变得如此之好。
好的，所以我们将更需要人工智能工程师而不是数据科学家，对吗？
没那么快。
再说说计算机科学教育。
我学 CS 的时候有一学期的 ML。今天，在同一个程序中，ML 内容增加了 4 倍以上。
我相信包装/构建/部署普通的 ML 模型将成为后端开发人员的常识。
即使在今天，如果需要的话，大多数后端软件工程师也可以很容易地学习足够的 ML 来做这件事。
再说一次，不要谈论那些棘手的训练，重在调整模型。我说的是好的基线模型。
所以考虑到:
- 基线模型会变得更好
- 经典 CS 项目中的 ML 教育将会改善
- 需要大量 ML 调整的业务问题将不再常见
我相信 ML 团队目前的角色将会发生变化:
- ML 重要角色->数据科学家
- 软件重要角色->后端软件工程师
那么谁应该处理产品的 ML 特定部分呢？
我相信你永远都需要大量数据科学家和大量软件后端工程师。
后端软件工程师将打包这些模型，并将其“发布”到由 DevOps 工程师运营的生产管道中。
当商业问题是 ML-heavy 时，数据科学家将建立模型。
但是，即使问题不严重，你也需要数据科学家，后端软件工程师可以很容易地部署一般的模型。
为什么？
因为模型失败了。
当它们失败时，很难调试它们并理解根本原因。
真正理解模型的人是大量数据科学家。
但是，即使 ML 模型部分“如预期的那样”工作，ML 燃料的产品也可能失败。
这就是为什么你也需要密切参与交付 ML 驱动的软件产品的主题专家。
主题专家
好的产品交付需要频繁的反馈循环。有些反馈循环可以自动化，但有些不能。
尤其是在 ML。尤其是在没有您或主题专家查看结果的情况下，您无法真正评估您的模型的时候。
这些主题专家(SME)参与 MLOps 流程的次数似乎比您想象的要多。
我们看到时装设计师注册了我们的 ML 元数据商店。
什么？这是一个很大的惊喜，所以我们看了看。
结果是团队非常希望中小型企业参与手工评估/测试。
尤其是 AI-first 产品公司的团队希望他们的中小企业参与模型开发。
这是好事。
并非所有东西都可以用 AUC 或 R2 这样的指标来测试/评估。有时，人们只需要检查事情是否有所改善，而不仅仅是指标变好了。
这种人在回路的 MLOps 系统实际上在我们的用户中相当普遍:
所以这种人在回路中的设计使得真正的自动化变得不可能，对吗？
很糟糕，对吧？
乍一看似乎有问题，但这种情况在正规软件中是完全正常和常见的。
我们有质量保证(QA)或用户研究人员手动测试和调试问题。
这发生在自动化测试之上。所以不是“非此即彼”，而是“兼而有之”。
但是 SME 肯定存在于(手动)MLOps 反馈回路中。
原理和组件:与 DevOps 的区别是什么
我真的很喜欢 MLOps 论文作者做的一些事情。
他们从研究 MLOps 的原理开始。不仅仅是工具，还有原则。您希望通过使用工具、流程或任何其他解决方案来完成的事情。
它们进入以后解决不同问题的组件(工具)。
太多时候，这是完全相反的，讨论是由工具做什么来决定的。或者更具体地说，这些工具今天声称要做什么。
工具是暂时的。原则是永恒的。可以这么说。
在我看来，一些关键的 MLOps 原则缺失了，而其他一些原则应该以不同的方式“打包”。
更重要的是，其中一些东西不是“真正的 MLOps ”,而实际上只是 DevOps 的东西。
我认为作为 MLOps 工具的构建者和用户社区，我们应该考虑“真正的 MLOps”的原则和组件。扩展现有 DevOps 基础设施的东西。
这是我们为当前环境增加的价值。而不是重新发明轮子并贴上 MLOps 的标签。
所以，让我们开始吧。
原则
因此，CI/CD、版本控制、协作、可再现性和持续监控是 DevOps 中也有的东西。我们在 ML 中做的许多事情实际上都属于这些。
让我们深入这些细微差别。
CI/CD + CT/CE +反馈回路
如果我们说 MLOps 只是 DevOps +“一些东西”，那么 CI/CD 就是其中的一个核心原则。
使用 CI/CD，您可以获得自动触发的测试、批准、审查、反馈循环等等。
随着 MLOps 而来的是 CT(持续培训/测试)和 CE(持续评估)，它们对于一个干净的 MLOps 过程是必不可少的。
它们是独立的原则吗？
不，它们是同一原则的一部分。
使用 CI/CD，您希望以自动化或半自动的方式构建、测试、集成和部署软件。
训练 ML 模型不就是搭建吗？
评估/测试只是测试？
它有什么特别之处？
也许是对新型号的人工检查。
这感觉非常像通过查看差异和检查(通常)自动化测试是否通过来审查和批准一个拉请求。
不仅代码之间有区别，模型/数据集/结果之间也有区别。但还是有区别。
然后你批准，它就投入生产了。
我真的不明白为什么 CT/CE 不仅仅是 CI/CD 的一部分。如果不在命名，那么至少在把它们放在一起作为一个原则。
通过 CI/CD 的审查和批准机制非常有效。
我们不应该在 MLOps 工具中构建全新的模型批准机制。
我们应该将 CI/CD 整合到尽可能多的反馈回路中。就像人们在常规软件开发中做 QA 和测试一样。
工作流程编排和管道创作
当我们谈到 ML 中的工作流编排时，我们通常会混淆两件事。
一个是调度、执行、重试和缓存。我们为确保 ML 管道正确执行所做的事情。这是一个经典的 DevOps 用例。没什么新鲜的。
但是这里有一些特别的东西:轻松创建 ML 管道的能力。
管道创作？
没错。
当使用 Kedro 创建集成时，我们了解了这种区别。
Kedro 明确声明它们是一个“管道创作”的框架，而不是工作流编排。他们说:
“我们关注的是另一个问题，即创作管道的过程，而不是运行、调度和监控管道。”
您可以使用不同的后端运行器(如 Airflow、Kubeflow、Argo、Prefect)，但您可以在一个框架中创作它们。
Pipeline authoring 是 orchestrators 之上的开发者体验(DevEx)层，满足数据科学用例的需求。这使得在这些管道上的合作更加容易。
不同团队之间的协作和管道的可重用性正是 Kedro 成立的原因。
如果你想要 ML 管道的可重用性，你需要解决可复制性。毕竟，如果您使用相同的输入重新使用模型训练管道，您会得到相同的结果。
版本控制与 ML 元数据跟踪/记录
这不是两个独立的原则，实际上是一个原则的一部分。
我们已经花了数千个小时与用户/客户/潜在客户谈论这些东西。
你知道我们学到了什么吗？
模型、结果和 ML 元数据的版本化、日志、记录和跟踪是紧密相连的。
我不认为我们确切地知道一个在哪里结束，另一个在哪里开始，更不用说我们的用户了。
他们经常交替使用版本控制和跟踪。
这是有意义的，因为您希望对模型及其附带的所有元数据进行版本化。包括模型/实验历史。
你想知道:
- 模型是如何建立的，
- 结果如何，
- 使用了什么数据，
- 训练过程是什么样的，
- 它是如何被评估的，
- 等等。
只有这样，你才能谈论再现性和可追溯性。
所以在 ML 中，我们需要这种“版本控制+”，它基本上不仅仅是模型工件的版本控制，而是围绕它的一切(元数据)。
因此，也许“版本控制”的原则应该只是一个更广泛的“ML 版本控制”或“版本控制+”，其中也包括跟踪/记录。
模型调试、检查和比较(缺失)
ML 模型、实验和流水线执行运行的“调试、检查和比较”是 MLOps 论文中缺失的原则。
作者们谈到了版本控制、跟踪和监控，但是我们看到人们想要但没有提到的一个原则是:
迄今为止，ML 中的很多东西都没有实现自动化。它们是手动或半手动的。
理论上，您可以自动优化每个模型的超参数到无穷大，但实际上，您是根据结果探索来调整模型配置。
当模型在生产中失败的时候，你不能马上从日志中知道发生了什么(大多数时候)。
您需要查看、检查、调试和比较模型版本。
显然，在模型开发过程中，您会进行大量实验，然后比较模型是关键。
但是，当这些手工构建的模型遇到再培训渠道时，会发生什么呢？
您仍然需要将 in-prod 自动重新训练的模型与初始的手动构建的模型进行比较。
尤其是当事情没有按计划进行，新的模型版本实际上并不比旧的版本更好的时候。
并且那些比较和检查是手动的。
自动持续监控(+手动定期检查)
所以我完全支持自动化。
自动化平凡的任务。自动化单元测试。自动化健康检查。
当我们谈到持续监控时，它基本上是各种 ML 健康检查的自动监控。
在此之前，您需要回答两个问题:
- 你知道什么会出错，你能为此建立健康检查吗？
- 你真的有必要进行这些健康检查吗？
是的，许多团队并不真正需要生产模型监控。
我的意思是，你可以每周手动检查一次。找到你不知道自己存在的问题。更熟悉你的问题。
正如 Shreya Shankar 在她的“读博一年后对 ML 工程的思考”中所分享的那样，你可能不需要模型监控。只是定期重新训练你的模型。
“研究人员认为分布转移非常重要，但源于自然分布转移的模型性能问题会随着再培训而突然消失。”史瑞亚·尚卡尔
你可以用 cron 作业来做。通过这种脏活产生的商业价值可能是你购买的工具的 10 倍。
好吧，但是有些队伍确实需要，百分百需要。
这些团队应该为他们知道可能出错的任何东西建立连续的监控、测试和健康检查。
但是即使这样，你也需要不时地手工检查/调试/比较你的模型。
捕捉你对自己的 ML 系统不了解的新事物。
没有度量标准可以捕捉的无声的错误。
我想这是一个很长的说法:
您不仅需要持续监控，还需要人工定期检查。
数据管理
ML 中的数据管理不仅仅是版本控制，而是一个重要的、大得多的过程。
您可以对数据集进行数据标记、检查、探索、比较、供应和协作。
尤其是现在，当以数据为中心的 MLOps(迭代数据集比迭代模型配置更重要)的思想在 ML 社区获得如此多的关注时。
此外，根据您的生产数据变化的速度或您需要如何设置评估数据集和测试套件，您的数据需求将决定您的堆栈的其余部分。例如，如果您需要经常重新训练，您可能不需要模型监控组件，或者如果您只是解决 CV 问题，您可能不需要特征存储等。
合作
当作者谈到合作时，他们会说:
“五常协作。协作确保了在数据、模型和代码上协同工作的可能性。”
他们展示了这种协作(P5)发生在源代码库中:
这与我们观察到的现实相差甚远。
协作还发生在:
- 实验和模型构建迭代
- 数据注记、清理、共享数据集和要素
- 管道创作和重用/传输
- CI/CD 审查/批准
- 主题专家参与的人在回路反馈循环
- 模型移交
- 处理生产模型中的问题以及来自第一线(用户、产品人员、主题专家)和模型构建者的沟通
澄清一下，我不认为我们作为一个 MLOps 社区在这里做得很好。
源代码回购中的协作是一个良好的开端，但它甚至没有解决 MLOps 中一半的协作问题。
好了，我们已经讨论了 MLOps 原则，现在让我们来讨论这些原则是/应该如何在工具堆栈组件中实现的。
成分
同样，CI/CD、源代码版本控制、培训/服务基础设施和监控等许多组件只是 DevOps 的一部分。
但是有一些额外的东西和一些现有的细微差别。
- 管道创作
- 数据管理
- ML 元数据存储(是的，我知道，我有偏见，但我确实相信，与软件不同，实验、调试和手工检查在 ML 中起着核心作用)
- 模型监控作为应用程序监控的插件
- 不需要模型注册中心(yep)
工作流执行者与工作流创作框架
正如我们之前在原则中提到的，我们有两个子类别的工作流编排组件:
- 工作流程编排/执行工具
- 管道创作框架
第一个是确保管道正确有效地执行。像 Prefect、Argo 和 Kubeflow 这样的工具可以帮助你做到这一点。
第二个是关于创建和重用管道的开发。像 Kedro、ZenML 和 Metaflow 这样的框架就属于这一类。
数据管理
这个组件(或一组组件)应该理想地解决的问题是:
- 数据标记
- 特征准备
- 特征管理
- 数据集版本化
- 数据集审查和比较
如今，这似乎可以通过自主开发的解决方案或一系列工具来实现:
- 特色店像泰克顿。有趣的是，现在他们更倾向于功能管理平台:“实时机器学习的功能平台”。
- 贴标平台如贴标箱。
- 数据集版本控制与 DVC 。
- 利用 dbt 实验室进行特征转换和数据集预处理。
应该将这些捆绑到一个“端到端数据管理平台”中，还是用同类最佳的模块化互操作组件来解决？
我不知道。
但是我相信不同部分的用户之间的合作是非常重要的。
尤其是现在这个更加以数据为中心的 MLOps 世界。当主题专家审查这些数据集时更是如此。
目前，没有任何工具/平台/堆栈在这方面做得很好。
ML 元数据存储(只有一个)
在论文中，ML 元数据存储在三个上下文中被提及，并且不清楚我们是在谈论一个组件还是多个组件。作者谈到:
- 配置在实验组件旁边的 ML 元数据存储
- 使用工作流编排配置的 ML 元数据存储
- 使用模型注册表配置的 ML 元数据存储
在我看来，应该只有一个 ML 元数据存储库来实现以下原则:
- “再现性”
- 调试、比较、检查
- “版本控制+”(版本控制+ ML 元数据跟踪/日志记录)，它包括来自不同阶段的任何测试和评估的元数据/结果(例如，在模型发布候选对象进入模型注册中心之前，它们的健康检查和测试结果)
让我回顾一下这三个 ML 元数据存储库，并解释我为什么这样认为。
- 配置在实验组件旁边的 ML 元数据存储
这个很简单。也许是因为我在 Neptune 一直听到这个消息。
当您进行实验时，您想要迭代各种实验/运行/模型版本，检查结果，并调试问题。
您希望能够重现结果，并对准备生产的模型进行版本化。
您想要“跟踪”实验/运行配置和结果、参数、度量、学习曲线、诊断图表、解释器和示例预测。
你可以把它想象成一个运行或者模型优先的 ML 元数据存储。
也就是说，我们交谈的大多数人把解决它的组件称为“实验跟踪器”或“实验跟踪工具”。
当涉及到实验时,“实验追踪者”似乎是一个很棒的名字。
但是，然后您使用它来比较初始实验的结果与 CI/CD 触发的、自动运行的生产再培训管道，并且“实验”部分似乎不再起作用。
我认为 ML 元数据存储是一个更好的名字，因为它抓住了这个组件的本质。让“记录、存储、比较、组织、搜索、可视化和共享 ML 模型元数据”变得简单。
好了，解释了一个 ML 元数据存储。还有两个。
2。配置了工作流编排的 ML 元数据存储
这一个很有趣，因为有两个独立的工作人们想用这个来解决:与 ML 相关的(比较、调试)和与软件/基础设施相关的(缓存、高效执行、硬件消耗监控)。
从我们的用户来看，这两项工作是由两种不同类型的工具解决的:
- 人们通过使用本地解决方案或集成外部实验跟踪器来解决与 ML 相关的工作。他们希望在有实验结果的地方得到重新训练的跑步结果。当你想要比较/检查/调试它们时，这是有意义的。
- 与软件/基础设施相关的工作由 orchestrator 组件或 Grafana、Datadog 等传统软件工具完成。
等等，那么配置在工作流编排工具旁边的 ML 元数据存储不应该收集所有关于管道执行的元数据吗，包括特定于 ML 的部分？
也许应该。
但是大多数配置了工作流编排器的 ML 元数据存储并不是按照“比较和调试”原则专门构建的。
他们在其他方面也做得很好，比如:
- 缓存中间结果，
- 基于执行标志重试，
- 在可用资源上分配执行
- 提前停止执行
可能是因为我们看到人们使用我们的实验跟踪器来比较/调试复杂 ML 流水线执行的结果。
因此，如果人们使用实验跟踪器(或运行/模型优先的 ML 元数据存储)来处理 ML 相关的东西，那么这个管道/执行优先的 ML 元数据存储会发生什么呢？
它应该只是工作流程编排器的一部分。事实往往如此。
它是一个内部引擎，使管道运行顺畅。通过设计，它与工作流编排器紧密结合。把它外包给一个独立的组件是没有意义的。
好了，再说第三个。
3。用模型注册表配置的 ML 元数据存储
引用论文:
可以在模型注册中心内配置另一个元数据存储，用于跟踪和记录每个训练作业的元数据(例如，训练日期和时间、持续时间等)。)，包括特定于模型的元数据—例如，使用的参数和产生的性能指标、模型谱系:使用的数据和代码”
好的，这里列出的几乎所有东西都会被记录到实验跟踪器中。
那里通常不记录什么？大概是:
- 生产前测试的结果、再培训运行的日志、CI/CD 触发的评估。
- 有关模型打包方式的信息。
- 关于模型何时被批准/在阶段之间转换(阶段/生产/归档)的信息。
现在，如果你像我一样，更广泛地将“实验跟踪器”视为一个 ML 元数据存储，它解决了“可再现性”、“调试、比较、检查”和“版本+”原则，那么大部分元数据实际上都在那里。
没有的东西，比如阶段转换时间戳，保存在诸如 Github Actions 、Dockerhub、Artifactory 或 CI/CD tools 之类的地方。
我不认为还有什么需要记录到一个特殊的“配置在模型注册中心旁边的 ML 元数据存储”中。
我也认为这是为什么我们交谈的这么多团队期望实验跟踪和模型注册之间的紧密耦合。
这很有意义:
- 他们想要实验跟踪器里所有的 ML 元数据。
- 他们希望在模型注册中心有一个生产就绪的打包模型
- 他们希望这两个部分之间有明确的联系
但是不需要另一个 ML 元数据存储。
只有一个 ML 元数据存储。有趣的是，大多数 ML 从业者甚至不称之为“ML 元数据存储”，而是称之为“实验跟踪器”。
好了，既然说到“模型注册”，我还有一件事要讨论。
模型注册表。我们真的需要它吗？
前一段时间，我们向 Neptune 引入了模型注册功能，并且我们一直致力于为我们的用户和客户改进它。
同时，如果您问我，从长远来看，MLOps/DevOps 中是否有/将会有对模型注册中心的需求，我会说没有！
对我们来说，“模型注册”是向用户和社区传达我们的 ML 元数据存储是存储和管理关于生产模型的 ML 元数据的正确工具栈组件的一种方式。
但它不是也不会是实现批准系统、进行模型供应(服务)、自动扩展、金丝雀测试等的正确组件。
从软件工程的角度来看，这就像是重新发明轮子一样。
像 Docker Hub 或 JFrog Artifactory 这样的工件注册中心不是更好吗？
难道你不想把包装好的模型放在 Kubernetes 的舵手图表里，然后就此收工吗？
当然，您需要参考模型构建历史或生产前测试的结果。
您希望确保新模型的输入-输出模式与预期的模式相匹配。
您希望在可以比较以前/新模型的同一位置批准模型。
但是所有这些并没有真正“存在”在新的模型注册组件中，不是吗？
它们主要存在于 CI/CD 管道、docker 注册表、生产模型监控工具或实验跟踪器中。
它们不在名为模型注册中心的闪亮的新 MLOps 组件中。
您可以通过完美集成以下内容来解决这个问题:
- CI/CD 反馈循环包括手动批准和“部署按钮”(查看 CircleCI 或 GitLab 如何做到这一点)
- +模型打包工具(以获得可部署的包)
- +容器/工件注册中心(有一个放置现成模型的地方)
-
- ML 元数据存储(获取完整的建模历史)
对吗？
我可以向我的 DevOps 朋友解释模型注册中心需要一个单独的工具吗？
我们交谈过的许多曼梯·里的人似乎都明白这一点。
但这是因为他们没有真正完全理解 DevOps 工具提供了什么吗？
我想可能是这样。
说实话，一些团队有自己开发的模型注册解决方案，它只是所有这些工具之上的一个薄层。
也许这就足够了。也许这正是注册管理机构的模式。一个抽象薄层，包含对 DevOps/MLOps 堆栈中其他工具的引用和挂钩。
模型监控。等等，哪一个？
“模型监控”是 MLOps 领域中最模糊、最令人困惑的名称(“ML 元数据存储”排在第二位)。
“模型监控”对三个不同的人来说意味着六件不同的事情。
我们与团队交流的意思是:
- (1)在生产中监控模型性能:看模型性能是否随时间衰减，你要重新训练。
- (2)监控模型输入/输出分布:查看输入数据的分布、特征或预测分布是否随时间变化。
- (3)监控模型训练和再训练:在训练和再训练过程中，查看学习曲线、训练后的模型预测分布或混淆矩阵。
- (4)监控模型评估和测试:为您的自动化评估或测试管道记录度量、图表、预测和其他元数据
- (5)监控基础设施指标:查看你的模型在训练和推断过程中使用了多少 CPU/GPU 或内存。
- (6)监控 CI/CD 管道的 ML: 查看您的 CI/CD 管道作业的评估，并进行直观比较。
例如:
- Neptune 在(3)和(4)上做得很好，(5)还可以(正在努力)，但是我们看到团队也在(6)上使用它
- 普罗米修斯+格拉法纳确实擅长(5)，但人们把它用于(1)和(2)
- Whylabs 或者 Arize AI 真的很擅长(1)和(2)
因为我确实相信 MLOps 只是 DevOps 的一个扩展，所以我们需要了解像 Datadog、Grafana、NewRelic 和 ELK (Elastic、Logstash、Kibana)这样的软件可观测性工具在今天和未来适合 MLOps。
此外，一些部分本质上是非连续和非自动的。比如比较/检查/调试模型。有主题专家和数据科学家参与其中。我看不出这是如何持续和自动的。
但最重要的是，我们应该弄清楚什么是真正特定于 ML 的，并在那里构建模块化工具或插件。
对于其他的，我们应该使用更成熟的软件监控组件，很可能你的 DevOps 团队已经有了。
因此，也许下面的拆分会让事情变得更加明显:
- 生产模型的可观察性和监控(亚利桑那州 WhyLabs)
- 监控模型培训、再培训、评估和测试(MLflow、Neptune)
- 基础设施和应用监控(Grafana、Datadog)
我很想看看 Datadog 和 Arize AI 的首席执行官如何考虑他们在 DevOps/MLOps 中的长期位置。
漂移检测只是应用程序监控堆栈的一个“插件”吗？我不知道，但实际上似乎很合理。
最后的想法和公开的挑战
如果我想让你从这篇文章中学到什么，那就是这个。
我们不应该考虑如何从头开始构建 MLOps 堆栈。
我们应该考虑如何逐步扩展现有的 DevOps 堆栈，以满足您目前的特定 ML 需求。
作者说:
“为了成功开发和运行 ML 产品，需要从模型驱动的机器学习向面向产品的学科进行文化转变
…
尤其是在设计 ML 产品时，与这些活动相关的角色应该有一个以产品为中心的视角。
我认为我们需要更大的思维转变:
ML 模型- > ML 产品- >使用 ML 的软件产品- >只是另一个软件产品
并且你的 ML 驱动的软件产品被连接到交付软件产品的现有基础设施上。
我不明白为什么 ML 在这里长期是一片特殊的雪花。我真的不知道。
但是，即使查看所展示的 MLOps 堆栈，99%的团队实际需要的实用的 v1 版本是什么？
作者采访了拥有 6500 多名员工的公司的 ML 从业者。大部分做生产 ML 的公司都不是那样的。对于大多数团队来说，MLOps 堆栈要简单得多。
尤其是那些在合理规模做 ML/MLOps 的。
他们可能会选择 1 到 2 个他们深入研究的组件，其余的则是超级基础的东西。
或者什么都没有。
你不需要:
- cron 作业足够时的工作流程编排解决方案。
- 当 CSV 足够时存储功能。
- 当电子表格足够时，进行实验跟踪。
真的，你不知道。
我们看到许多团队通过务实和专注于目前对他们来说重要的事情来交付伟大的东西。
在某个时候，他们可能会将其 MLOps 堆栈增长到我们在本文中看到的规模。
或者参加 DevOps 会议，并意识到他们应该只是扩展 DevOps 堆栈😉
我偶尔会在我的 Linkedin 个人资料上分享我对 ML 和 MLOps 前景的看法。如果你对这个话题感兴趣，请随时跟我来。此外，如果你想和我聊聊，也可以联系我。
MLOps 模型商店:定义、功能、工具回顾
原文：https://web.archive.org/web/https://neptune.ai/blog/mlops-model-stores
什么是 ML(机器学习)模型库？这里有一个你可能会发现自己身处其中的场景。你经历了一个严格的开发工作流程，用不同的结果和性能分数试验和训练各种机器学习模型。你决定最好的协作方式是共享你的模型，这些模型存储在像 S3 或 GCS 这样的对象存储器中，并在电子表格上记录。
您经历了上面的过程，所以当团队中的每个人见面时，您都可以讨论结果，并可能回去开发更多的实验，或者在某些情况下，讨论团队应该部署哪些模型。
在就部署什么模型进行了几个小时的争论后，团队最终同意了一个模型。现在又出现了另一个问题，那就是实际打包将要部署的模型，对其进行分级，并使其为生产做好准备。
这种手动、费力且重复的过程可能非常耗时，甚至可能对您和您的团队有害。必须有一种方法来保持开发和部署机器学习模型的所有协作高效和简化，对吗？
模型商店是一种新的东西，可以帮助你做到这一点。让我们探索什么是模型商店，它们如何帮助，以及如何为您的项目选择正确的模型商店。
什么是模型商店？
模型存储是数据科学家获取和管理他们的模型和实验的中央存储，包括模型文件、工件和元数据。
通过模型存储，您可以控制管理多个机器学习模型的复杂性。这种结构还有助于数据科学家:
- 将多个新训练的模型版本与现有部署的版本进行比较；
- 将全新模型与标记数据上的其他模型版本进行比较；
- 随着时间的推移跟踪模型性能；
- 跟踪组织范围内的实验；
- 管理全组织机器学习模型的服务需求。
像特征商店这样的模型商店是你的机器学习项目的资产管理技术。“模型商店”术语是新一波 MLOps 行话的一部分。这看起来像是一个营销噱头，但对于如何开发和部署机器学习应用程序至关重要。
除了这些模型的可搜索清单之外，您还可以访问模型工件、模型配置文件以及相关模型的实验元数据。
模型存储充当您将提供给生产环境的模型的登台环境。模型商店允许您将再现性和生产就绪模型结合起来。在您的所有模型经历了必要的开发工作流程之后，可以把它想象成一个包装器。此时，它们已经准备好部署到生产环境中，或者由预测服务引入生产环境中。
当您希望您的模型是可复制的并且可用于生产时，您可以使用模型存储。模型存储包含重现模型结果所需的所有信息和文件。它包括对模型进行打包、测试和准备部署的必要过程。
What is a model store? | Source: Author
可以说，模型商店和注册中心几乎没有区别。然而， Eduardo Bonet 在 MLOps 社区 Slack 频道中提出的一个重要观点是，在模型注册表中，你存储和获取模型(就像 docker 注册表一样)。
在模型存储中，您有日志、发现、示例、元数据，所有您需要的，并且模型存储包含模型注册。您可能仍然会发现公司更喜欢使用“模型注册中心”作为一个包含性的术语，因为现在在命名约定中没有任何特定的标准。
为什么您的 MLOps 项目需要一个模型商店？
机器学习操作(MLOps)项目需要模型存储有三个主要原因:
让我们仔细看看这些关键的原因，以理解为什么您的项目需要模型商店。
模型的再现性
机器学习项目最具挑战性的方面之一是重现结果。在试验过程中，您的模型会用随机值进行初始化，然后根据训练数据进行调整。这种随机性使得手动实现再现性成为一个复杂的过程。其他工件需要修复，以确保训练期间的再现性。
模型存储通过以下方式保证再现性:
- 跟踪和收集实验–和 ML 管道相关的元数据(实验作者/所有者、描述等。).
- 收集数据集元数据，包括数据集的版本、位置和描述。此外，用户如何选择数据或数据链接到特征存储中的何处。
- 收集模型工件、元数据(包、框架、语言、环境文件、git 文件等)和配置文件。
- 收集容器文物。
- 项目文档，包括如何运行模型的演示和例子。
该商店也是团队“购买”可重用模型的地方，有助于更有效的协作和可访问的机器学习项目。您可以在类似于其他人最初训练模型的数据集上重新训练现成的模型，确保团队可以更快地试验和推出模型。
团队成员可以通过目录功能搜索相关的模型，以重用、改进或管理这些模型。这个特性在某种程度上消除了孤岛构建的问题，并简化了整个组织的协作。有了模型存储，无论项目在何时何地运行，它们的结果都是一致的。
总之，模型存储在可再现性方面促进了个人和团队的协作、可访问性和更有效的机器学习项目工作流。
确保模型可以投入生产
模型存储与生产系统集成在一起，为模型提供弹性服务。使用模型存储，您可以更快地部署生产模型，因为将模型部署到生产中的一个技术瓶颈是由数据科学家(开发模型)和操作团队(部署模型)之间的移交过程引起的。
在模型存储中，为生产绑定的模型验证了它们的工件，模型被编译并集成到登台环境中。此功能确保在将模型部署到预测服务之前，可以测试模型与其他应用程序的兼容性和预测能力。
模型存储还包含模型的预处理描述。生产中的数据管道可以使用模型在实验期间经历的相同预处理，以避免训练-服务偏斜。模型存储与生产环境和服务基础设施集成，以便于模型部署、模型废弃(或归档)和回滚。
除了试运行之外，模型存储还可以支持验证和部署模型的其他策略，例如金丝雀集成测试和部署、影子模式部署和 A/B 部署。对于自动化的 MLOps 管道，您可以将模型存储与持续集成和交付/部署 (CI/CD)和持续培训 (CT)相集成，以消除手动操作实践。
为了跟踪和重现应用程序中的错误，您需要知道哪个模型正在生产中运行。为此，您需要保留一份与训练模型所基于的数据集(和要素)相链接的训练模型记录，模型存储会为您完成这项工作。
有效管理模型
跨项目和整个组织管理模型可能非常复杂。组织已经从部署少数解决特定问题的模型发展到部署数百甚至数千个模型来解决不同的生产问题。模型存储有助于这些模型的可见性、可发现性和管理。
改进模型治理
在生产中管理模型的一个主要原因是为了改善这些模型的治理和安全性。大多数行业在向客户部署产品时都遵循法规要求。模型存储允许对模型进行审查和审计，因此它们的结果符合法规要求。
除了法规要求之外，确保在使用许可和开源工具开发和部署模型时没有任何限制也是至关重要的。此类限制可能导致违反许可协议或使用这些工具。在这个场景中，评审和审计成为模型管理的重要方面。
提高模型安全性
还需要对模型和用于构建模型的底层包进行漏洞扫描，尤其是当大量包开发和部署模型时——管理包的特定版本，消除任何可能对系统造成威胁的安全漏洞。
模型也容易受到恶意攻击，因此需要管理和保护模型免受这种攻击。还有一些情况需要应用最低特权访问的安全原则，以便只有授权用户才能访问特定的模型信息和资源。
模型商店适合您的 MLOps 平台
到目前为止，我们知道模型存储提高了模型的可再现性和弹性服务。让我们看看它们在您的 MLOps 平台中的位置。
下图由谷歌云的《MLOps:机器学习中的连续交付和自动化管道》文章修改而来。
模型存储与您的实验管理系统相耦合，并与您的生产管道相集成，以管理模型部署过程:审查、测试、批准、发布和回滚。模型存储处理来自实验管理系统的工件和元数据，或者在高层次上支持连续训练的自动化生产管道。
在工件管理方面，模型存储管理模型的生命周期，包括打包模型用于阶段化或发布。对于元数据管理，搜索与模型相关的元数据、创建报告和其他功能使得在商店中发现模型变得容易。
你能在模型商店里找到什么
让我们来看看一个模型在你训练和验证之后的旅程:
- 您已经训练和验证的模型的工件和元数据从实验管理系统到达模型存储。
- 对工件进行验证，以确保经过训练的模型包含所有必需的工件，以便提供服务和进行监控。
- 模型工件和元数据被打包到一个独立的、可加载的包中，为集成的生产环境服务。
- 打包后的模型将进行部署，以验证模型并确保它们适合服务。验证包括对模型和它将集成到生产环境中的其他应用程序进行质量保证测试。
采取这些步骤的主要原因是为了确保模型在生产中的稳定性。由于同一个容器中加载了多个模型，一个糟糕的模型可能会导致预测请求失败，并可能中断同一个容器中的模型。在其他场景中，同一模型可能会破坏整个应用程序的结果和性能。
让我们来看看你能在模型商店里找到什么:
- 多样的元数据:来自模型、数据、实验。
- 工件:像元数据一样，存储包含所有与您如何开发、部署和管理模型相关的工件。
- 文档和报告工具:文档对于评审和可重复项目至关重要。模型存储支持与您如何开发、部署和管理模型相关的文档。
- 目录:模型商店中的信息需要是可搜索的，而目录可以实现这一点。搜索要使用的模型？相关元数据怎么样？搜索在特定数据集上训练的模型？目录使得商店可被搜索。
- 登台工具:模型存储的另一个特性是它可以在模型上执行的登台集成测试。您可以在模型存储中找到用于测试的暂存模型的工具。
- 自动化工具:模型存储的目标之一是在您训练和验证了一个模型之后，自动化一些重复的任务，以提高部署大量模型的团队的生产力。在商店内，您可以找到支持该流程的自动化工具和工作流程。
跟踪和管理元数据对于任何机器学习工作流都至关重要。该特性包括对您如何开发、部署和管理模型很重要的任何类型的元数据。模型存储与实验管理系统集成，以跟踪实验或管道相关的元数据。
当您运行实验时，实验管理系统会记录实验的输出，以便可以有效地跟踪和管理它们。这里的“有效”是指来自实验运行的元数据旨在帮助你在开发过程中监控你的模型，调试你可能遇到的任何错误，甚至在图表中可视化模型的性能。
您可以在模型存储中找到的一些实验元数据包括:
- 环境配置:封装了完整的环境，包括所有的工具、依赖项、包、Docker 文件和其他构建模型所需的配置文件。
- 计算信息:在实验运行期间使用的硬件和加速器(如果有的话)的类型，以及在该过程中消耗的功率有助于确定项目的碳足迹。
- 代码版本:包括提交的 git SHA 或者用于构建模型的代码的实际快照。
- 执行细节:特定运行的唯一标识符、实验触发日期(时间戳)、运行时间以及完成时间。
- 管道相关元数据:如管道版本、运行号、管道参数等。
- URI 的文件为图表、曲线图和实验的性能结果。
让我们看看您可以在实验运行的模型存储中找到的其他一些元数据类别。
您可以在模型存储中找到的模型元数据包括:
- 型号名称由用户设定。
- 用户开发的型号描述。
- 模型的 URI (或者它将被存储的位置)。
- 模型类型:你用于模型的算法。假设是逻辑回归算法或者卷积神经网络算法。
- 框架和库，包括被训练模型的版本号。
- 该实验运行模型的超参数配置。
- 车型版本，对于在车型商店中唯一标识车型至关重要。
- 型号标签(开发、退役或生产)或标签。
- 型号代码。
- 用于模型的指标类型。
- 其他必要的模型配置文件。
您可以在模型存储中记录的数据集元数据包括:
- 数据集的版本。
- 用于训练模型的数据集的 URI 或位置(文件路径)。
- 数据集所有者。
- 数据集源。
所有这些都允许您更详细地跟踪摄取的数据。它们还将使您能够验证在训练期间使用的数据集仍然是稍后时间点的数据集，这对于再现性是至关重要的。
史前古器物
您可以在模型存储中找到的工件包括模型工件(以各种格式保存的模型，如 ONNX 、 pickle 、 protobuf 等)和容器工件，如在模型打包以进行测试和部署期间的 Docker 图像。
证明文件
模型文档是模型可再现性和审计的关键部分。记录和共享关于模型如何做出预测的上下文可以实现协作，因此团队成员可以基于示例再现结果，并帮助透明的模型报告。该文档还将包含模型预期用途的详细信息、模型可能表现出的偏差，以及关于模型预期表现良好的输入类型的免责声明。一些商店正在测试模型卡，用于模型文档和报告。
目录
在模型存储中，您会发现一个模型目录，您可以搜索它，这样就可以很容易地找到资产，特别是当成百上千的模型在生产中运行或不运行时。在某些模型商店中，这种搜索是通过图形用户界面(GUI)或 API 完成的，因此该功能可以与其他系统集成。
模型存储的功能
模型商店的关键功能和必备条件是什么？
集成到实验管理系统中
如果您想要提高生产率并确保模型结果的可重复性，以便它们在运行中保持一致，那么跟踪您的实验是关键。模型存储应该与实验管理系统相结合来跟踪实验，因此元数据、工件和其他信息都被收集到存储中。这种集成还有助于做出将模型发布到生产环境的决策。
暂存环境
在模型存储中，应该有一组运行模型所需的基础设施，这些基础设施与应用程序或服务的其他部分相集成。此功能通常包括应用程序服务器、数据库、缓存以及与预测服务(包含模型)集成的其他系统。序列化的模型被编译并部署到登台环境中。
登台环境用于在将模型发布到生产环境之前在集成环境中进行测试，这通常是客户使用的环境以及他们与之交互的其他服务。从试运行环境中，我们可以执行质量保证测试、适当的治理和批准工作流。
适当的治理和批准工作流还需要模型存储中的共享和协作。团队和涉众可以很容易地访问注册的模型，并编辑和更新其中的信息。它还应该包括访问控制功能，商店中注册模型的所有者可以授予用户完全访问、部分访问、读取或写入权限。这个功能还应该附带一个活动日志，它可以跟踪和记录模型存储中的变更以及必要的信息。
自动化
自动化是模型存储的另一个功能，因为正如我们前面所讨论的，许多项目工作流是手工的和重复的。这一功能带来了对工具的需求，该工具可以在您开发模型之后自动化模型生命周期，因此生命周期中的审查、批准、发布和回滚步骤是无缝的。
当前面的步骤完成时，模型存储应该使用 API 和 webhooks 来触发下游动作。在本文的前面，您看到了一个模型在实验之后的旅程。当实验管理系统发送工件和元数据时，需要触发的下游活动对于模型存储来说是至关重要的。
例如，当实验管理系统传递模型工件时，它们必须被自动注册。当用户将模型移动到阶段环境中时，在批准和发布(部署)之前，它们被容器化以进行本地测试。
您可以根据模型存储将模型加载到预测服务的方式来配置一些模型存储。例如，如前所述，将模型加载到预测服务中合适的集群，或者使用特定的部署策略(如 canary 部署或 A/B 部署)。当部署需要特定加速器在生产环境中有效工作的大型模型时，该功能也是如此。
部署
模型存储的另一个核心功能是与生产环境的集成。前面，您一定已经看到，如果您使用包含 CI/CD 工作流的自动化管道，交付经过充分测试的模型是至关重要的，这使得生产系统稳定。
查看各种模型商店
在本节中，我们将回顾各种模型商店，以思考您可能想要探索的一些选项。值得注意的是，这些工具中的一些也可能被称为“模型注册表”在本文的前面，我们已经了解了模型存储和模型注册之间的细微差别。
其中一些解决方案是开源的；其他涉及定价计划。现在，我们将简要介绍您可以开始探索的 5(五)个模型商店，在下一节中，我们将总结如何根据您的需求选择合适的模型商店。
开源解决方案
模型商店
Modelstore (多么原创， Neal ！😅)是一个开源 Python 库，它允许你在你的文件系统或云存储提供商(AWS 或 GCP)之间版本化、导出和保存/检索机器学习模型。
除了开源之外，modelstore 还有以下一些特性:
- 自动化模型的版本控制。
- 以结构化的方式存储您的模型，以便于访问。
- 收集和处理用于训练模型的代码的 Python 运行时、依赖项和 git 状态的元数据。
- 支持几种流行的开源机器学习库，你可以在这里找到它们。
- 它可以使用你的本地文件存储、谷歌云存储或 AWS S3 存储桶作为你的后端。
- 它提供了模型打包特性以及工件处理特性。
- 积极维护，添加了其他支持和模型存储功能。
在撰写本文时，modelstore 还不支持模型存储的一些核心特性，并且有一些缺点，包括:
- 目前通过 API 访问特性，因为还没有 GUI 访问。
- 该库的模型文档和报告功能仍在开发中。
值得注意的是，目前有一个贡献者在管理 modelstore，所以如果你想采用这个解决方案，你需要考虑到这一点。
要开始使用 modelstore，请查看快速入门指南。
ClearML 模型存储
ClearML 在其网站上声明，它是唯一一款在统一、强大的平台上管理所有 MLOps 的开源工具，提供协作式实验管理、强大的编排、易于构建的数据存储和一键式模型部署。
一个令人兴奋的 ClearML 特性是 MLOps 开放架构栈，它带有一个开源的 MLOps 引擎，如果 ClearML 应用不能解决你的问题，你可以在其上构建定制应用。
ClearML Open Architecture Stack | Source
虽然模型存储不是 ClearML 应用程序堆栈的一部分，但是您可以在开源的 MLOps 引擎上构建一个定制的模型存储，它提供了模型存储应该提供的核心功能。正如第由制作的视频所解释的，唯一的问题是:
- 您不能为元数据创建自定义标签。
- 在模型打包期间，不能使用自定义序列化(比如 ONNX )。引擎使用开发过程中使用的框架生成的序列化文件，例如，Tensorflow 和 Keras 模型的 protobuf 或 .h5 格式。这一挑战可能会导致生产中的兼容性问题(例如模型互操作性)。
你可以通过观看这个视频和后续的 Google Colab 演示来开始使用 ClearML 中的模型商店。
MLflow 模型注册表
MLflow 是一个管理 ML 生命周期的开源平台，包括实验、可复制性、部署和中央模型注册。MLflow 模型注册组件是一个集中式模型存储、一组 API 和 UI，用于跨数据团队协作管理 MLflow 模型的整个生命周期。
MLflow 模型注册表的一些功能包括:
- 提供一个中央存储库来存储和管理唯一命名的注册模型，以实现跨数据团队的协作和可见性。
- 为注册表操作提供了 UI 和 API，以及流畅的工作流体验。
- 允许在不同的阶段环境(阶段和生产环境)中有多个版本的模型。
- 允许跨不同环境和阶段的过渡和模型推广方案。模型可以从试运行中移走，加载到生产环境中，回滚，退役或归档。
- 与 CI/CD 管道集成，以快速加载特定的模型版本，用于测试、审查、批准、发布和回滚。
- 模型谱系跟踪特征，提供模型描述、谱系和活动。
MLflow registry 还提供对元数据存储和工件存储的支持。元数据存储可以在任何有 PostgreSQL 、 MySQL 和 SQLlite 的地方使用。工件存储支持本地文件系统后端和一些托管后端，如 S3 存储、 Azure Blob 存储、谷歌云存储和 DBFS 工件存储库。此外，还有一个可管理的 MLflow 计划，您可能想在此处查看。
你可以从这个工作坊开始学习 MLflow Model Registry，看看文档。
免费和付费解决方案
Neptune.ai
Neptune 是 MLOps 的元数据存储，为运行许多实验的研究和生产团队而构建。
它为您提供了一个中心位置来记录、存储、显示、组织、比较和查询机器学习生命周期中生成的所有元数据。
个人和组织使用 Neptune 进行实验跟踪和模型注册，以控制他们的实验和模型开发。
Example dashboard in Neptune | Source
海王星的一些核心特征包括:
- 记录所有类型的机器学习模型相关的元数据类型。您可以在文档中找到所有元数据类型的完整列表。
- 在您工作的地方工作，因为 Neptune 与机器学习、深度学习和强化学习中流行的 Python 库进行了 25+次集成。
Neptune 更像是一个元数据存储，而不是一个实际的工件存储，模型存储也管理和处理工件存储。Neptune 对于您的实验和生产用例都是最佳的。
Neptune 对一个用户免费，对团队付费(可以进行团队试用)。大约 5 分钟后就可以开始免费使用。您还可以了解更多信息:
Verta.ai
Verta.ai 使用一套工具来支持数据科学和机器学习团队快速开发和部署生产就绪模型，从而实现 ML 与各种产品的高效集成。他们平台中的一个工具是模型注册中心，这是一个寻找、发布、协作和使用生产就绪模型的中央存储库。
Verta.ai Model Registry dashboard | Source
Verta.ai 与您的模型治理工作流和部署系统相集成，以保证可靠和自动化的发布过程。要开始使用 Verta 的模型注册工具，你可以点击这里进行免费试用。
其他解决方案
您可能想了解的一些其他选项有:
如何为您的 MLOps 项目选择合适的模型存储
当您想要为您的项目选择一个模型存储时，有一些考虑事项。我们来复习一下。
团队的规模和部署的模型数量
如果你是一个一个人的团队或者一个小团队，那么模型商店在你的平台堆栈中不是最优先的，这是可以理解的。通常，如果一个小团队部署了少量的模型，您不需要模型存储。尽管如此，随着您的团队不断成长，团队正在开发和部署的模型数量不断增加，必须考虑采用模型存储来简化可重复性和服务。
您希望确保通过减少冗余流程来优化团队的生产力。这些过程包括设置一个存储桶，手动上传工件、配置文件，以及每当团队决定一个模型可以生产时打包模型。
对于一个小团队来说，想要开始一个模型商店，尝试使用一个具有最基本功能的免费选项，例如:与开发环境集成、元数据和工件处理、目录特性和打包特性。
对于较大的团队部署许多模型，其中协作和可见性是必不可少的，考虑选择一个模型商店来解决围绕您的模型的更快展示、改进的治理和批准工作流以及组织范围的模型可见性和发现的痛点。
另一个需要考虑的问题是，如果必须对模型进行记录和审计，尤其是在监管严格的行业，那么应该考虑部署到生产中的模型的类型。
结论和资源
通过本指南，您已经了解了什么是模型商店以及为什么您可能需要它们。您了解到它们是管理和部署机器学习模型的模型优先方法。
它们有助于集中组织范围内的 ML 模型，因此它们更容易复制，在某些情况下，更容易重用。您了解了模型存储与您的实验管理系统集成，并根据它们在 MLOps 堆栈中的位置来帮助您的模型启动过程。
模型存储将可再现性、治理、安全性和弹性服务一起结合到您的项目工作流中。
资源和参考资料
斯蒂芬·奥拉德勒
开发者倡导者和 MLOps 技术内容创建者。
阅读下一篇
最佳 MLOps 工具以及如何评估它们
12 分钟阅读| Jakub Czakon |年 8 月 25 日更新
在我们的一篇文章中——机器学习团队实际使用的最好的工具、库、框架和方法——我们从 41 家 ML 初创公司学到的东西——Acerta 的 CTO Jean-Christophe Petkovich 解释了他们的 ML 团队如何接近 MLOps。
据他所说，一个完整的 MLOps 系统有几个要素:
- 您需要能够构建包含预处理数据和生成结果所需的所有信息的模型工件。
- 一旦您能够构建模型工件，您必须能够跟踪构建它们的代码，以及它们被训练和测试的数据。
- 您需要跟踪所有这三样东西，模型、它们的代码和它们的数据，是如何关联的。
- 一旦您可以跟踪所有这些内容，您还可以将它们标记为准备就绪，进行生产，并通过 CI/CD 流程运行它们。
- 最后，为了在该过程的最后实际部署它们，您需要某种方法来基于该模型工件旋转服务。
这是对如何在公司中成功实施 MLOps 的高度概括。但是理解高层需要什么只是拼图的一部分。另一个是采用或创建适当的工具来完成工作。
这就是为什么我们编制了一份最佳 MLOps 工具的清单。我们将它们分为六类，以便您可以为您的团队和业务选择合适的工具。让我们开始吧！
当 MLOps 是一个组织和沟通问题而不是技术问题时
在本文中，您将获得对 MLOps 及其阶段的简要概述。您还将了解 MLOps 何时是一个组织和沟通问题，何时是一个技术问题，以及如何解决这些挑战。
什么是 MLOps？
MLOps 深受 DevOps 概念的启发，在 devo PS 中，开发团队(Dev)和运营团队(Ops)通过系统化的标准流程进行协作。
MLOps，机器学习和运营的结合是将任何数据科学项目的开发和生产对应方结合起来的举措。换句话说，它试图在端到端的 ML 管道中引入结构和透明度，以便数据科学家能够以有组织的方式工作，并与数据工程师和生产端的技术/非技术利益相关者顺利互动。
为什么实施 MLOps 会有阻力？
数据科学团队在企业界相对较新，任何数据科学项目的流程仍然无法正确绘制。涉及大量的研究和数据迭代，使用固定的系统无法跟踪这些数据。与常规的工程团队不同，ML 团队的过程和方法不是绝对的，并且经常有一个悬而未决的问题:如果这都不行，还有什么可以？
这就是为什么数据科学团队在他们的方法上设置条款、条件和时间表时，常常感到受到限制。
为什么需要 MLOps？
想象一下，有两片中间有很多馅的干面包。它会变得很乱，而且很有可能大部分东西会掉下来。解决这个问题的方法是添加一些像奶酪一样的粘性物质，将两片和馅料粘在一起。MLOps 仅仅是:将机器学习项目的整个过程结合在一起的工具。
查看 MLOps 工具前景找到最适合您的使用案例的 MLOps 工具。
就像两片面包一样，建模和部署团队经常不同步，缺乏对彼此需求和工作方法的理解。如果没有 MLOps 将这些部分整合在一起，来自两端的努力和辛勤工作在到达最终消费者之前必然会减少。
据估计，在左右，60%的机器学习项目从未实施。作为数据科学社区的一员，我目睹了几个由于不可扩展和低效的框架而无法到达最终客户的项目。数据科学对于预测极其重要，但是如果预测仍然局限于数据科学家的系统，对最终客户没有好处。
尽管 MLOps 仍然是一个正在试验的概念，但它可以大大缩短 ML 项目的时间表，并确保更高比例的项目得到部署。通常，全球的 ML 团队都有持续的抱怨，一个项目平均需要花费 6 个月来开发和部署。
使用 MLOps，可以显著降低流程的时间复杂度；由于数据科学团队刚刚步入 IT 世界，这是坚持分析和建立正确秩序的最佳时机。
MLOps 和 DevOps 有什么相似之处？(优势和挑战)
MLOps 的概念是仿照 DevOps 设计的，因此两者之间有一些核心相似之处:
- CI/CD 框架–持续集成和持续交付是软件和机器学习解决方案的核心框架，因为对现有代码的改进是不断提出和添加的。
- 敏捷方法–敏捷方法旨在通过将端到端过程划分为多个冲刺，使持续集成和改进的过程不那么繁琐。使用 sprint 的好处是每个 sprint 的结果都有很高的透明度，并且分布在项目中涉及的所有团队和涉众之间。这确保了在解决方案开发的后期不会出现意外。总的来说，敏捷方法解决了以下问题:
- 漫长的开发到部署周期——当开发团队构建一个完整的解决方案并将其作为一个整体移交给部署团队时，会出现主要的延迟。在这种转移中有一个很大的缺口，因为许多依赖关系经常没有解决。在敏捷方法的帮助下，交接是冲刺式的，依赖性从开发本身的最初几个阶段就被清除了。
- 团队之间缺乏同步–每个数据科学项目不仅仅包括一个开发和部署团队。许多利益相关者，如项目经理、客户代表和其他决策者也参与其中。如果没有 MLOps 的实施，ML 解决方案的可见性将会大大降低，利益相关者只能在开发的后期阶段尝到它的甜头。这有可能搞乱整个项目，因为众所周知，面向业务的团队会提供能够扭转整个解决方案的专家建议。通过敏捷方法，他们的输入可以从一开始就被采纳，并在所有 sprints 中被考虑。
MLOps 和 DevOps 有什么不同？
尽管 mlop 和 DevOps 的核心框架相似，但一些明显的差异使得 mlop 更加独特和难以处理。关键原因是数据。数据的变化会给 MLOps 带来额外的麻烦。例如，数据的变化可能导致超参数组合的变化，这可能使建模和测试模块的行为完全不同。让我们看一下 MLOps 的不同阶段，以便更好地理解它们的区别。
MLOps 的阶段
在 ML 项目中，有五个总括阶段:
- 用例识别:这是开发和业务团队与客户合作来理解和制定手头问题的正确用例的时候。这可能包括计划和软件文档的准备，以及从客户端获得它们的审查和批准。
- 数据工程和处理:这是第一个技术接触点，数据工程师和数据科学家在这里查看各种来源，从这些来源可以获得数据以用于解决方案开发。确定来源之后，构建管道，以正确的格式简化数据，并检查流程中的数据完整性。这需要数据科学家和数据工程师之间的密切合作，也需要不同团队的点头，例如可能使用同一数据主的咨询团队。
- ML 解决方案构建:这是 MLOps 生命周期中最紧张的部分，在 CI/CD 框架的帮助下，在连续的周期中开发和部署解决方案。一个 ML 解决方案涉及多个实验，有多个版本的模型和数据。因此，每个版本都必须被很好地跟踪，以便在以后的阶段可以很容易地参考最佳的实验和模型版本。开发团队经常不使用标准的工具来跟踪这些实验，最终导致过程混乱，增加了工作和时间需求，并且很可能降低了最佳的模型性能。成功创建的每个模块都应该迭代地部署，同时为更改核心元素(如超参数和模型文件)留出足够的空间。
- 生产部署:一旦在本地环境中构建、测试和部署了 ML 解决方案，就应该将其连接到生产服务器并部署在其上，生产服务器可以是公共云、本地或混合云。接下来是一个简短的测试，检查解决方案是否在生产服务器上工作，这通常是因为相同的解决方案之前已经在本地服务器上测试过。然而，有时由于配置不匹配，测试会失败，开发人员必须迅速查明原因并找到解决方法。
- 监控:解决方案在生产服务器上成功部署后，必须在几批新数据上进行测试。根据数据类型的不同，监控的关键时间从几天到几周不等。一些特定的和预先决定的目标度量用于识别模型是否继续服务于目的。触发器用于在性能低于预期时发出提示警报，并通过返回到解决方案构建的第三阶段来要求优化。
当 MLOps 成为组织和沟通的挑战时
- 漫长的审批链–对于需要反映在生产服务器上的每一项更改，都必须获得相关机构的批准。这需要很长时间，因为验证过程很长，最终会延迟开发和部署计划。然而，这个问题不仅仅是生产服务器的问题，在提供不同的公司资源或集成外部解决方案方面也存在。
- 预算内供应–有时，由于预算限制或资源在多个团队之间共享，开发团队无法使用公司的资源。有时，ML 解决方案也特别需要新的资源。例如，具有高性能计算或巨大存储容量的资源。这样的资源，即使对扩展 ML 解决方案至关重要，也不符合大多数组织的预算标准。在这种情况下，ML 团队必须找到一个通常是次优的解决方案，如果可能的话，让解决方案以同样的活力工作。
- 不同于自主开发的框架的 ML 堆栈——大多数公司一直在开发的软件部署框架对于部署 ML 解决方案来说可能是次优的，甚至是不相关的。例如，基于 python 的 ML 解决方案可能必须通过基于 Java 的框架进行部署，以符合公司现有的系统。这可能会给开发和部署团队带来双重工作，因为他们必须复制大部分代码库，这对资源和时间都是一种负担。
- 安全先行–每一个机器学习模型或模块几乎总是一个大型知识库的一部分。例如，随机森林模型的一个版本被编码在 scikit-learn 库中，用户可以简单地使用函数调用来启动模型训练。最常见的情况是，用户不知道代码在做什么，也不知道除了数据之外，它还在利用哪些来源。因此，为了确保安全性，在将代码上传到生产服务器之前，需要由相关的安全团队检查封装功能的代码。此外，云上的安全 API、公司的安全基础设施和许可因素是时间密集型的，需要加以注意。
- 在所有团队之间同步相关数据–从客户处获得的公共数据主数据由多个团队使用，如销售团队、咨询团队，当然还有开发团队。为了避免数据中的差异，必须维护一组公共的列定义和一个公共的数据源。尽管这听起来是可行的，但是在现实世界的场景中，由于涉及到多个参与者，这通常会成为一个挑战，导致团队之间为了解决内部创建的数据问题而来回奔波。此类问题的一个例子是，在构建了整个解决方案之后，开发人员意识到客户入职团队对其中一列进行了不同的填充。
解决 MLOps 中组织和沟通挑战的解决方案
- ML 栈的虚拟环境——对于已经实施了敏捷方法并采用了大部分相关框架的新公司和初创公司来说，回溯的本土框架不是问题。然而，相对较老的公司，在以前建立的框架上统一运作，可能看不到 ML 团队在资源优化方面的最佳结果。这是因为团队将忙于计算如何通过可用的框架最好地部署他们的解决方案。一旦弄清楚了，他们必须为他们想要部署的每个解决方案重复次优的过程。
解决这个问题的长期办法是投入资源和时间创建一个独立的 ML 堆栈，它可以集成到公司框架中，但也可以减少开发方面的工作。对此的快速解决方案是利用虚拟环境为最终客户部署 ML 解决方案。Docker 和 Kubernetes 等服务在这种情况下非常有用。 - 成本效益分析—为了减少审批的长队和预算限制，数据科学开发团队通常需要深入业务方面，并对限制供应与可以在这些供应上运行的工作数据科学解决方案的投资回报进行彻底的成本效益分析。团队可能需要与业务运营团队合作，以获得准确的反馈和数据。组织中的关键决策者具有短期或长期利润导向的观点，而承诺增长的成本效益分析可能是打开一些瓶颈的驱动因素。
- 公共键引用–为了保持对来自客户的主数据进行操作的多个团队之间的透明度，可以使用引用键，因为在开发团队必须多次复制和下载数据的情况下，公共数据源是不实际的。列定义的公共键可能不是避免数据差异的理想解决方案，但它是对现有过程的改进，在现有过程中，数据列很容易被误解，尤其是当列名没有说明性时。
- 使用经过验证的代码源:为了缩短在生产服务器上上传或批准机器学习库时进行安全检查所需的时间，开发人员可以将他们的代码引用限制在经过验证的代码库，如 TensorFlow 和 scikit-learn。如果使用了 Contrib 库，开发人员必须对其进行彻底检查，以验证输入和输出点。这是因为，在有一些安全问题的情况下，重新开发和安全检查的循环重新开始，可能会疯狂地减慢这个过程。
当 MLOps 是一项技术挑战时
MLOps 的主要技术挑战出现在解决方案并行开发和部署的第三阶段。以下是一些特定于 MLOps 的技术挑战，这些挑战与 DevOps 完全不同:
- 超参数版本化–在找到最佳解决方案之前，每个 ML 模型都必须经过多组超参数组合的测试。然而，这不是主要的挑战。输入数据的变化会降低所选组合的性能，必须重新调整超参数。尽管代码和超参数由开发人员控制，但数据是影响受控元素的独立因素。必须确保数据和超参数的每一个版本都得到跟踪，以便能够以最少的麻烦找到和再现最佳结果。
- 多次实验–随着数据的不断变化，大量代码也必须在数据处理、特征工程和模型优化方面进行修改。这种迭代是无法计划的，并且会增加构建 ML 解决方案所需的时间，影响所有后续阶段和计划的时间表。
- 测试和验证–该解决方案必须在多个未知数据集上进行测试和验证，以了解该解决方案是否能在生产环境中处理传入的数据。这里的挑战是，经过训练的模型可能会偏向训练数据集。为了避免这一点，测试和验证必须在模型创建本身的迭代中完成。假设建模迭代的次数不固定，用看不见的数据集进行测试所花费的时间会随着迭代次数的增加而增加。
- 部署后监控—这里的主要挑战是新数据可能与历史数据模式不一致。例如，在疫情期间，股票市场曲线违背了所有的历史模式，并以机器学习解决方案无法预测的方式下跌。这种外部因素经常起作用，并且必须相应地收集、更新和处理数据，以保持解决方案的最新性。
解决大多数技术挑战的一站式解决方案是系统地记录整个过程，这样就有很高的可见性，并易于访问和导航。记录、存储、组织和比较模型版本和输出是从大量迭代中获得最佳可见性和结果的关键。 Neptune.ai 平台在一个地方管理所有的建模元数据，除了日志、存储、显示、组织和比较之外，它甚至还提供了查询所有 MLOps 元数据的功能。
了解更多关于 Neptune 的特性以及它如何帮助你组织你的 ML 工作流程。
结论
作为一个概念，MLOps 是非常新颖的，即使它今天几乎没有触及数据科学和机器学习社区的领域，它也通过强调它确实是当前的需要而留下了印记。尤其是当 ML 实现的数量呈指数级增长时。通过解决一些组织和沟通问题，可以消除 MLOps 的许多多余的麻烦，使其对开发人员和操作更加友好。
为计算机视觉构建 MLOps 流水线:图像分类任务[教程]
Vaswani 和团队在 2018 年推出的变形金刚，为各种任务的深度学习模型的研发带来了重大变革。转换器利用了 Bahdanau 和团队从注意力机制中采用的自我注意力机制。通过这种机制，一个输入可以与其他输入进行交互，使其能够集中或关注数据的重要特征。
因此，transformers 能够在各种 NLP 任务中实现最先进的结果，如机器翻译、摘要生成、文本生成等。它还在几乎所有的 NLP 任务中取代了 RNN 及其变体。事实上，随着它在 NLP 中的成功，变形金刚现在也被用于的计算机视觉任务中。2020 年，Dosovitskiy 和他的团队开发了《视觉变形金刚》(ViT)，他们认为没有必要依赖 CNN。基于这个前提，在本文中，我们将探索和学习 ViT 如何帮助完成图像分类的任务。
本文是一篇旨在使用 ViT 为计算机视觉任务构建 MLOps 管道的指南，它将关注与典型数据科学项目相关的以下领域:
- 项目的目标
- 硬件规格
- 注意力可视化
- 建立模型和实验跟踪
- 测试和推理
- 创建用于部署的细流应用
- 使用 GitHub 操作设置 CI/CD
- 部署和监控
这篇文章的代码可以在这个 Github 链接上找到，这样你就可以跟上了。让我们开始吧。
用于图像分类的 MLOps 管道:理解项目
了解项目或客户的需求是重要的一步，因为它可以帮助我们集思广益，研究项目可能需要的各种组件，如最新的论文、存储库、相关工作、数据集，甚至基于云的部署平台。本节将重点讨论两个主题:
-
1 项目目的。
-
2 加速训练的硬件。
项目目标:鸟类图像分类器
该项目的目的是建立一个图像分类器来对不同种类的鸟类进行分类。由于该模型稍后将部署在云中，我们必须记住，必须对该模型进行训练，以在训练和测试数据集中获得良好的准确性分数。为了做到这一点，我们应该使用精度、召回率、混淆度、F1 和 AUROC 分数等指标来查看模型在两个数据集上的表现。一旦模型在测试数据集上取得了好成绩，我们将创建一个 web 应用程序，将其部署在基于云的服务器上。
简而言之，这就是项目的执行方式:
-
1 用 Pytorch 构建深度学习模型
-
2 测试模型
-
3 创建一个简化应用
-
4 为部署创建目录及其各自的配置文件
-
最后，将其部署在谷歌云平台上
这个项目将包括您将在本文中找到的一些附加实践，例如:
- 实时跟踪以监控指标，
- 注意力可视化，
- 目录结构，
- 所有 python 模块的代码格式。
加速训练的硬件
我们将使用两套硬件进行实验:
- M1 Macbook :苹果 M1 处理器的效率将允许我们快速开发模型，并在更小的数据集上训练它们。一旦训练完成，我们就可以开始在本地机器上构建一个 web 应用程序，并在云中扩展模型之前，创建一个小型的数据接收、数据预处理、模型预测和注意力可视化管道。
注意:如果你有一台 M1 笔记本电脑，那么一定要在我的 Github repo 中查看安装过程。
- Kaggle 或 Google Colab GPU:一旦我们的代码在我们的本地机器上正常工作，并且创建了管道，我们就可以扩展它，并在免费的 Google Colab 或 Kaggle 中对整个模型进行更长时间的训练。一旦训练完成，我们就可以将新的权重和元数据下载到我们的本地计算机，并在将 web 应用程序部署到云之前，测试它在看不见的数据中是否表现良好。
现在让我们开始实现。
用于图像分类的 MLOps 流水线:数据准备
实施深度学习项目的第一步是规划我们将要拥有的不同 python 模块。尽管我们将使用 Jupyter 笔记本进行实验，但在开始编码之前做好一切准备总是一个好主意。规划可能包括参考代码库以及研究论文。
为了提高效率和便于导航，为项目创建目录结构总是一个好主意。
ViT Classification
├── notebooks
│ └── ViT.ipynb
└── source
└──config.py
在我们的例子中，主目录称为 ViT 分类，它包含两个文件夹:
- 笔记本:这是 jupyter 笔记本所有实验的地方。
- Source :这是所有 Python 模块将驻留的地方。
随着我们的进展，我们将继续向源目录添加 Python 模块，我们还将创建不同的子目录来存储元数据、docker 文件、README.md 文件等等。
建立图像分类模型
如前所述，研究和规划是实现任何机器学习项目的关键。我通常首先做的是，创建一个 config.py 来存储与数据预处理、模型训练和推理、可视化等相关的所有参数。
class Config:
IMG_SIZE = 32
PATCH_SIZE = 10
CROP_SIZE = 100
BATCH_SIZE = 1
DATASET_SAMPLE = 'full'
LR = 0.003
OPIMIZER = 'Adam'
NUM_CLASSES = 400
IN_CHANNELS = 3
HIDDEN_SIZE = 768
NUM_ATTENTION_HEADS = 12
LINEAR_DIM = 3072
NUM_LAYERS = 12
ATTENTION_DROPOUT_RATE = 0.1
DROPOUT_RATE = 0.1
STD_NORM = 1e-6
EPS = 1e-6
MPL_DIM = 128
OUTPUT = 'softmax'
LOSS_FN = 'nll_loss'
DEVICE = ["cpu","mps","cuda"]
N_EPOCHS = 1
上面的代码块给出了参数应该是什么样子的模糊概念。随着我们取得进展，我们可以不断添加更多的参数。
注:在设备配置部分，我已经给出了三个硬件的列表:CPU、MPS、CUDA。MPS 或金属性能着色器是在 M1 macbook 上训练的硬件类型。
资料组
我们将使用的数据集是可以从 Kaggle 下载的鸟类分类数据集。该数据集由 400 个鸟类类别组成，具有三个子集:训练、验证和测试，每个子集分别包含 58388、2000 和 2000 张图像。一旦数据下载完毕，我们就可以创建一个函数来读取和可视化图像。
The image above is a sample from the dataset along with the class that it belongs to | Source
准备数据
我们可以继续创建一个数据加载器，将图像转换成图像张量。除此之外，我们还将执行尺寸调整、图像裁剪和规范化。一旦预处理完成，我们就可以使用 DataLoader 函数批量自动生成用于训练的数据。以下伪函数将让您了解我们正在努力实现的目标，您可以在代码标题中提供的链接中找到完整的代码:
def Dataset(bs, crop_size, sample_size='full'):
return train_data, valid_data, test_data
上面的函数有一个样本大小参数，它允许创建训练数据集的子集，以便在本地机器上进行测试。
用于图像分类的 MLOps 流水线:使用 Pytorch 构建视觉转换器
我已经按照作者在论文中对 ViT 的描述创建了完整的模型。这段代码的灵感来自于 jeonsworld repo，为了这个任务的目的，我增加了一些更多的细节并编辑了一些代码行。
我创建的模型分为 9 个模块，每个模块可以独立执行各种任务。为了便于理解，我们将探讨每个部分。
把...嵌入
变形金刚和所有的自然语言模型都有一个重要的组件叫做嵌入。它的功能通常是通过将相似的信息组合在一起来捕获语义信息。除此之外，嵌入可以跨模型学习和重用。
在 ViT 中，嵌入通过保留可以输入编码器的位置信息来达到同样的目的。同样，下面的伪代码将帮助您理解发生了什么，您也可以在代码标题中提供的链接中找到完整的代码。
class Embeddings(nn.Module):
def __init__(self, img_size:int, hidden_size:int, in_channels:int):
def forward(self, x):
return embeddings
请注意，可以使用卷积层来创建图像的嵌入补丁。这是非常有效的，也很容易修改。
编码器
编码器由许多关注模块组成，关注模块本身有两个重要模块:
-
1 自我注意机制
-
2 多层感知器(MLP)
自我注意机制
先说自我关注机制。
自我关注机制是整个系统的核心。它使模型能够关注数据的重要特征。它通过对不同位置的单个嵌入进行操作来计算相同序列的表示。您可以在下面找到完整代码的链接，以获得更深入的了解。
class Attention(nn.Module):
return attention_output, weights
注意力块的输出将产生注意力输出以及注意力权重。后者将用于可视化使用注意机制计算的 ROI。
多层感知器
一旦我们接收到注意力输出，我们就可以把它输入到 MLP 中，这将给我们一个分类的概率分布。您可以在 forward 函数中了解整个过程。要查看完整代码，请单击下面代码标题中提供的链接。
class Mlp(nn.Module):
def __init__(self, hidden_size, linear_dim, dropout_rate, std_norm):
return x
值得注意的是，我们使用 GELU 作为我们的激活函数。
GELU as activation function | Source
使用 GELU 的好处之一是它避免了消失梯度，这使得模型易于缩放。
注意力阻断
注意模块是我们组装两个模块的模块:自我注意模块和 MLP 模块。
class Block(nn.Module):
return x, weights
该模块还将直接从注意力机制中产生注意力权重，以及由 MLP 产生的分布。
现在让我们简单了解一下编码器。编码器本质上使我们能够创建多个注意块，给转换器更多对注意机制的控制。三个组件:编码器、变压器和 ViT 写在同一个模块中，即 transformers.py 。
class Encoder(nn.Module):
return encoded, attn_weights
变压器
组装好关注模块后，我们就可以对转换器进行编码了。注意块转换器是嵌入模块和编码器模块的组合。
class Transformer(nn.Module):
def __init__(self, img_size, hidden_size, in_channels, num_layers,
num_attention_heads, linear_dim, dropout_rate, attention_dropout_rate,
eps, std_norm):
super(Transformer, self).__init__()
self.embeddings = Embeddings(img_size, hidden_size, in_channels)
self.encoder = Encoder(num_layers, hidden_size, num_attention_heads,
linear_dim, dropout_rate, attention_dropout_rate,
eps, std_norm)
def forward(self, input_ids):
embedding_output = self.embeddings(input_ids)
encoded, attn_weights = self.encoder(embedding_output)
return encoded, attn_weights
视觉变压器
最后，我们可以编码我们的视觉转换器，它包括两个组件:转换器和最终的线性层。最终的线性将帮助我们找到所有类别的概率分布。它可以被描述为:
class VisionTransformer(nn.Module):
def __init__(self, img_size, num_classes, hidden_size, in_channels, num_layers,
num_attention_heads, linear_dim, dropout_rate, attention_dropout_rate,
eps, std_norm):
super(VisionTransformer, self).__init__()
self.classifier = 'token'
self.transformer=Transformer(img_size, hidden_size, in_channels,
num_layers, num_attention_heads, linear_dim,
dropout_rate, attention_dropout_rate, eps,
std_norm)
self.head = Linear(hidden_size, num_classes)
def forward(self, x, labels=None):
x, attn_weights = self.transformer(x)
logits = self.head(x[:, 0])
if labels is not None:
loss_fct = CrossEntropyLoss()
loss = loss_fct(logits.view(-1, 400), labels.view(-1))
return loss
else:
return logits, attn_weights
请注意，网络将持续产生注意力权重，这对可视化注意力地图非常有用。
这是额外的小费。如果您想要查看模型的架构以及输入是如何操作的，那么使用下面的代码行。代码将为您生成一个完整的操作架构。
from torchviz import make_dot
x = torch.randn(1,config.IN_CHANNELS*config.IMG_SIZE*config.IMG_SIZE)
x = x.reshape(1,config.IN_CHANNELS,config.IMG_SIZE,config.IMG_SIZE)
logits, attn_weights = model(x)
make_dot(logits, params=dict(list(model.named_parameters()))).render("../metadata/VIT", format="png")
你可以在给定的链接中找到图像。
但简而言之，这就是建筑的样子。
The architecture of vision transformer | Source
用于图像分类的 MLOps 流水线:使用 Pytorch 训练视觉转换器
在培训模块中，我们将组装所有其他模块，如配置模块、预处理模块和转换器，并将包括元数据在内的参数记录到 Neptune API 中。记录参数最简单的方法是使用 Config。__ 词典 _ _。这会自动将类转换成字典。
您可以稍后创建一个函数，从字典中删除不必要的属性。
def neptune_monitoring():
PARAMS = {}
for key, val in Config.__dict__.items():
if key not in ['__module__', '__dict__', '__weakref__', '__doc__']:
PARAMS[key] = val
return PARAMS
培养
训练函数非常简单明了。我在伪代码中包含了培训和评估。您可以在此找到完整的训练模块，或者您可以点击下面的代码标题。
def train_Engine(n_epochs, train_data, val_data, model, optimizer, loss_fn, device,
monitoring=True):
现在我们的训练循环已经完成，我们可以开始训练并将元数据记录到 Neptune.ai 仪表板中，我们可以使用它在旅途中监控训练，保存图表和参数，并与队友共享它们。
if __name__ == '__main__':
from preprocessing import Dataset
from config import Config
config = Config()
params = neptune_monitoring(Config)
run = neptune.init( project="nielspace/ViT-bird-classification",
api_token=API_TOKEN)
run['parameters'] = params
model = VisionTransformer(img_size=config.IMG_SIZE,
num_classes=config.NUM_CLASSES,
hidden_size=config.HIDDEN_SIZE,
in_channels=config.IN_CHANNELS,
num_layers=config.NUM_LAYERS,
num_attention_heads=config.NUM_ATTENTION_HEADS,
linear_dim=config.LINEAR_DIM,
dropout_rate=config.DROPOUT_RATE,
attention_dropout_rate=config.ATTENTION_DROPOUT_RATE,
eps=config.EPS,
std_norm=config.STD_NORM)
train_data, val_data, test_data = Dataset(config.BATCH_SIZE, config.IMG_SIZE,
config.DATASET_SAMPLE)
optimizer = optim.Adam(model.parameters(), lr=0.003)
train_Engine(n_epochs=config.N_EPOCHS, train_data=train_data, val_data=val_data,
model=model,optimizer=optimizer, loss_fn='nll_loss',
device=config.DEVICE[1], monitoring=True)
注意:这个模型的原型是在 Macbook Air M1 的一个更小的数据集上完成的，这个数据集有 10 个类。在原型阶段，我尝试了不同的配置，并尝试了模型的架构。一旦我满意了，我就用 Kaggle 来训练这个模型。由于数据集有 400 个类，模型需要更大，并且需要更长时间的训练。
实验跟踪
在原型阶段，实验跟踪成为对模型进行进一步修改的一个非常方便和可靠的来源。您可以在训练期间关注模型的性能，并随后对其进行必要的调整，直到您获得一个高性能的模型。
Neptune API 使您能够:
如果您想在系统中记录您的元数据，那么导入 Neptune API 并调用 init 函数。接下来，输入为项目提供的 API 键，就可以开始了。在这里了解更多关于如何开始使用 Neptune 的信息。另外，这里是 Neptune 仪表板，它有与这个项目相关的元数据。
run = neptune.init(project="nielspace/ViT-bird-classification",
api_token="API_TOKEN")
一旦完成初始化，就可以开始日志记录了。例如，如果您想要:
- 上传参数，使用:run['parameters'] = params。注意:确保参数是字典类的。
- 上传指标，使用:run['Training_loss']。log(loss.item())并运行['Training_loss']。log(loss.item())
- 上传模型权重，使用:run["model_checkpoints/ViT"]。上传(" model.pt ")
- 上传图片，使用:run["val/conf_matrix"]。上传("混淆 _ 矩阵. png ")
根据您优化模型的目的，有很多事情可以记录和跟踪。在我们的例子中，我们强调训练和验证的损失和准确性。
记录元数据和仪表板
在持续的培训过程中，您可以监控模型的性能。随着每次迭代，图形将会更新。
除了模型的性能，您还会发现 CPU 和 GPU 的性能。见下图。
您还可以找到所有的模型元数据。
The model metadata
使用 Kaggle 缩放
现在，让我们缩放模型。我们将在这个项目中使用 Kaggle，因为它是免费的，也因为数据集是从 Kaggle 下载的，所以它将很容易在平台本身上扩展和训练模型。
-
我们需要做的第一件事是上传模型，将目录路径更改为 Kaggle 特定的路径，并启用 GPU。
-
请注意，模型必须是复杂的，以便捕捉用于预测的相关信息。您可以通过逐渐增加隐藏层的数量并观察模型的行为来开始缩放模型。你可能不希望接触其他参数，如注意力头的数量和隐藏大小，因为它可能会抛出算术错误。
-
对于每一次更改，您都要让模型在所有 400 个类别的小数据批次中运行至少两个时期，并观察准确性是否在提高。通常，它会增加。
-
一旦满意，运行模型 10 到 15 个时期，对于 30000 个样本的子集，这将花费大约 5 个小时。
-
在训练之后，在测试数据集上检查它的性能，如果它表现良好，则下载模型权重。此时，对于 400 个类，模型的大小应该在 650 MB 左右。
注意力可视化
如前所述，自我关注是整个视觉转换器架构的关键，有趣的是，有一种方法可以将其可视化。注意图的源代码可以在这里找到。我对它做了一点修改，并将其创建为一个单独的独立模块，可以使用转换器的输出来生成注意力地图。这里的想法是存储输入图像及其对应的注意图图像，并在 README.md 文件中显示。
def attention_viz(model, test_data, img_path=PATH, device='mps'):
我们可以通过简单地调用 attention_viz 函数并传递相应的参数来运行这段代码。
if __name__ == '__main__':
train_data, val_data, test_data = Dataset(config.BATCH_SIZE,config.IMG_SIZE, config.DATASET_SAMPLE)
model = torch.load('metadata/models/model.pth', map_location=torch.device('cpu'))
attention_viz(model, test_data, PATH)
*The image above is an example of attention visualization. The image on the left is the original image whereas the image on the right is overlaid with the attention map. The region i.e. the face of the bird is quite bright as that area constitutes the features to which the model is paying attention *
测试和推理
我们还可以在测试模块中使用 attention_viz 函数，我们将在测试数据上测试模型，并测量模型在各种指标上的性能，如混淆矩阵、准确度分数、f1 分数、召回分数和精确度分数。
def test(model, test_data):
return logits_, ground, confusion_matrix
我们可以使用 seaborn 的热图轻松生成混淆矩阵并进行可视化，并将其保存在 results 文件夹中，我们还可以使用该文件夹在 README.md 文件中显示它。
Above is the image of a confusion matrix that is of the shape 100X100 trained for 50 epochs. As you can see the model is quite efficient to predict true positives which can be seen in the diagonals in white color. But there are few false positives across the graph which means that the model still makes wrong predictions
我们还可以生成精度和损失图，并将其存储在结果文件夹中。因此，我们可以使用 Sklearn 找到其他度量，但在此之前，我们必须将 tensors 数组转换为 NumPy 数组。
probs = torch.zeros(len(logits_))
y_ = torch.zeros(len(ground))
idx = 0
for l, o in zip(logits_, ground):
_, l = torch.max(l, dim=1)
probs[idx] = l
y_[idx] = o.item()
idx+=1
prob = probs.to(torch.long).numpy()
y_ = y_.to(torch.long).numpy()
print(accuracy_score(y_, prob))
print(cohen_kappa_score(y_, prob))
print(classification_report(y_, prob))
一旦我们对模型的性能感到满意，我们就可以通过同时创建一个 Streamlit 应用程序来进行推理。
用于影像分类的 MLOps 管道:使用 Streamlit 创建应用程序
Streamlit 应用将是一个网络应用，我们将部署在云上。为了构建应用程序，我们必须首先 pip 安装 streamlit，然后在新模块中导入库。
该模块将包含与推理模块相同的模块，我们只需要复制和粘贴评估函数，然后使用 Streamlit 库构建应用程序。下面是应用程序的代码。
import warnings
warnings.simplefilter(action='ignore', category=FutureWarning)
from PIL import Image
import torch
from torchvision import transforms
import torch
import streamlit as st
from embeddings import Embeddings
from attention_block import Block
from linear import Mlp
from attention import Attention
from transformer import VisionTransformer, Transformer, Encoder
from config import Config
config = Config()
st.set_option('deprecation.showfileUploaderEncoding', False)
st.title("Bird Image Classifier")
st.write("")
file_up = st.file_uploader("Upload an image", type = "jpg")
def predict(image):
"""Return top 5 predictions ranked by highest probability.
Parameters
----------
:param image: uploaded image
:type image: jpg
:rtype: list
:return: top 5 predictions ranked by highest probability
"""
model = torch.load('model.pth')
transform = transforms.Compose([
transforms.Resize(128),
transforms.CenterCrop(128),
transforms.ToTensor(),
transforms.Normalize(
mean = [0.485, 0.456, 0.406],
std = [0.229, 0.224, 0.225])])
img = Image.open(image)
x = transform(img)
x = torch.unsqueeze(x, 0)
model.eval()
logits, attn_w = model(x)
with open('../metadata/classes.txt', 'r') as f:
classes = f.read().split('n')
prob = torch.nn.functional.softmax(logits, dim = 1)[0] * 100
_, indices = torch.sort(logits, descending = True)
return [(classes[idx], prob[idx].item()) for idx in indices[0][:5]]
if file_up is not None:
image = Image.open(file_up)
st.image(image, caption = 'Uploaded Image.', use_column_width = True)
st.write("")
st.write("Processing...")
labels = predict(file_up)
for i in labels:
st.write(f"Prediction {i[0]} score {i[1]:.2f}")
但是在部署之前，我们必须在本地进行测试。为了测试应用程序，我们将运行以下命令:
streamlit run app.py
一旦执行了上述命令，您将得到以下提示:
You can now view your Streamlit app in your browser.
Local URL: http://localhost:8501
Network URL: http://192.168.0.105:8501
复制网址粘贴到你的浏览器，app 就上线了(本地)。
Copied URL
上传图片进行分类。
Uploaded image
随着 ViT 模型的训练和应用程序的准备，我们的目录结构应该看起来像这样:
.
├── README.md
├── metadata
│ ├── Abbott's_babbler_(Malacocincla_abbotti).jpg
│ ├── classes.txt
│ ├── models
│ │ └── model.pth
│ └── results
│ ├── accuracy_loss.png
│ ├── attn.png
│ └── confusion_matrix.png
├── notebooks
│ ├── ViT.ipynb
│ └── __init__.py
└── source
├── __init__.py
├── app.py
├── attention.py
├── attention_block.py
├── attention_viz.py
├── config.py
├── embeddings.py
├── linear.py
├── metrics.py
├── preprocessing.py
├── test.py
├── train.py
├── transformer.py
现在我们开始部署应用程序。
用于图像分类的 MLOps 流水线:代码格式化
首先，让我们格式化我们的 Python 脚本。为此，我们将使用黑色。Black 是一个 Python 脚本格式化程序。你所需要做的就是 pip 安装 black，然后运行 black 跟在 python 模块甚至整个目录的名字后面。对于这个项目，我运行 black，然后运行包含所有 python 模块的源目录。
ViT-Pytorch git:(main) black source
Skipping .ipynb files as Jupyter dependencies are not installed.
You can fix this by running ``pip install black[jupyter]``
reformatted source/config.py
reformatted source/embeddings.py
reformatted source/attention_block.py
reformatted source/linear.py
reformatted source/app.py
reformatted source/attention_viz.py
reformatted source/attention.py
reformatted source/preprocessing.py
reformatted source/test.py
reformatted source/metrics.py
reformatted source/transformer.py
reformatted source/train.py
使用 black 的好处是去掉了不必要的空格，增加了双引号而不是单引号，让审查代码更快更高效。
下面给出了使用黑色格式化代码前后的图像。
Examples before and after using black to format the code
如你所见，不必要的空格被删除了。
用于图像分类的 MLOps 管道:设置 CI/CD
对于我们的 CI/CD 流程，我们将使用 Github Actions、和 Google Cloud Build 来集成和部署我们的 Streamlit 应用程序。以下步骤将帮助您创建完整的 MLOps 管道。
创建 Github 存储库
第一步是创建 Github 存储库。但在此之前，我们必须创建三个重要文件:
-
1 要求. txt
-
2 makefile
-
3 main.yml
requirements.txt
requirements.txt 文件必须包含模型正在使用的所有库。有两种方法可以创建 requirements.txt 文件。
- 如果您有专门为此项目创建的专用工作环境，那么您可以运行 pip freeze>requirements.txt，它将为您创建一个 requirements.txt 文件。
- 如果您有一个通用的工作环境，那么您可以运行 pip 冻结并复制粘贴您一直在工作的库。
该项目的 requirement.txt 文件如下所示:
numpy==1.22.3
torch==1.12.0
torchvision==0.12.0
tqdm==4.64.0
opencv-python==4.6.0.66
streamlit==1.10.0
neptune-client==0.16.3
注意:始终确保你提到的版本，以便在未来，应用程序保持稳定和最佳性能。
生成文件
简而言之，Makefile 是一个命令提示符文件，它可以自动完成安装库和依赖项、运行 Python 脚本等等的整个过程。典型的 Makefile 如下所示:
setup:
python3 -m venv ~/.visiontransformer
source ~/.visiontransformer/bin/activate
cd .visiontransformer
install:
pip install --upgrade pip &&
pip install -r requirements.txt
run:
python source/test.py
all: install run
对于这个项目，我们的 Makefile 将有三个过程:
-
1 设置虚拟环境并激活它。
-
2 安装所有的 Python 库。
-
3 运行一个测试文件。
实际上，每次我们进行新的提交时，都会执行 makefile，它会自动运行 test.py 模块，生成最新的性能指标并更新 README.md 文件。
但是 Makefile 只有在我们创建一个动作触发器时才能工作。让我们来创造它。
动作触发器:。github/workflow/main.yml
要创建动作触发器，我们需要创建以下目录:。github/workflow，之后创建一个 main.yml 文件。每当 repo 被更新时，main.yml 将创建一个动作触发器。
我们的目标是持续集成现有构建中的任何变更，如更新参数、模型架构，甚至 UI/UX。一旦检测到更改，它将自动更新 README.md 文件。这个项目的 main.yml 被设计为在任何 push 或 pull 请求时触发工作流，但是只针对 main 分支。
在每次新提交时，该文件将激活 ubuntu-latest 环境，安装特定的 python 版本，然后执行 Makefile 中的特定命令。
name: Continuous Integration with Github Actions
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Set up Python 3.8
uses: actions/setup-python@v1
with:
python-version: 3.8
- name: Install dependencies
run: |
make install
make run
测试
创建文件后，您可以将整个代码库推送到 Github。上传后，您可以点击 Actions 选项卡，亲自查看内置进度。
Build-in progress in the Actions tab
部署:Google 云构建
测试完成后，Github README.md 文件中的所有日志和结果都已更新，我们可以进入下一步，即将应用程序集成到云中。
- 首先，我们将访问:https://console.cloud.google.com/，然后我们将在仪表板中创建一个新项目，并将其命名为 Vision Transformer Pytorch。
Creating a new project
一旦创建了项目，您就可以导航到该项目，它看起来会像这样:
The project
如你所见，google cloud build 在项目主页上为我们提供了各种现成的服务，如虚拟机、大查询、GKE 或 Kubernetes 集群。但是在我们在云构建中创建任何东西之前，我们必须启用 Kubernetes 集群，并在项目目录中创建某个目录和它们各自的文件。
- Kubernetes
让我们在创建任何文件之前设置我们的 Kubernetes 集群。为此，我们可以在谷歌云控制台搜索栏中搜索 GKE 并启用 API。
Setting up Kubernetes cluster
启用 API 后，我们将导航到下一页。
Kubernetes cluster
但是我们将使用内置的云 shell 来创建集群，而不是手动创建集群。为此，点击右上角的终端按钮，查看下图。
Activating Cloud Shell
Creating cluster by using inbuild cloud shell
激活云 shell 后，我们可以键入以下命令来创建 Kubernetes 集群:
gcloud container clusters create project-kube --zone "us-west1-b" --machine-type "n1-standard-1" --num-nodes "1"
这通常需要 5 分钟。
Creating Kubernetes clusters
完成后，它看起来会像这样:
Kubernetes clustering completed
现在让我们设置两个配置 Kubernetes 集群的文件:deployment.yml 和 service.yml。
yml 文件允许我们在云中部署模型。根据要求，部署可以是淡黄色、重新创建、蓝绿色或任何其他颜色。在本例中，我们将覆盖部署。这个文件也有助于使用参数副本有效地缩放模型。下面是一个 deployment.yml 文件的示例。
apiVersion: apps/v1
kind: Deployment
metadata:
name: imgclass
spec:
replicas: 1
selector:
matchLabels:
app: imageclassifier
template:
metadata:
labels:
app: imageclassifier
spec:
containers:
- name: cv-app
image: gcr.io/vision-transformer-pytorch/vit:v1
ports:
- containerPort: 8501
下一个文件是 service.yml 文件。它本质上是将应用从容器连接到现实世界。注意到容器端口参数被指定为 8501，我们将在我们的 service.yml 中为目标端口参数使用相同的数字。这与 Streamlit 用来部署应用程序的数字相同。除此之外，两个文件中的应用参数是相同的。
apiVersion: v1
kind: Service
metadata:
name: imageclassifier
spec:
type: LoadBalancer
selector:
app: imageclassifier
ports:
- port: 80
targetPort: 8501
注意:一定要确保 app 的名字和版本都是小写的。
- Dockerfile
现在让我们配置 Dockerfile 文件。该文件将创建一个 Docker 容器来托管我们的 Streamlit 应用程序。Docker 是非常必要的，因为它将应用程序包装在一个易于扩展的环境中。典型的 docker 文件如下所示:
FROM python:3.8.2-slim-buster
RUN apt-get update
ENV APP_HOME /app
WORKDIR $APP_HOME
COPY . ./
RUN ls -la $APP_HOME/
RUN pip install -r requirements.txt
CMD [ "streamlit", "run","app.py" ]
Dockerfile 包含一系列命令，这些命令:
- 安装 Python 版本。
- 将本地代码复制到容器映像。
- 安装所有库。
- 执行 Streamlit 应用程序。
请注意，我们使用的是 Python 3.8，因为一些依赖项使用的是最新的 Python 版本。
- cloudbuild.yaml
在 Google Cloudbuild 中，cloudbuild.yml 文件将所有工件缝合在一起，创建了一个无缝管道。它有三个主要步骤:
- 使用当前目录中的 Docker 文件构建 Docker 容器。
- 将容器推送到 google 容器注册表。
- 在 Kubernetes 引擎中部署容器。
steps:
- name: 'gcr.io/cloud-builders/docker'
args: ['build', '-t', 'gcr.io/vision-transformer-pytorch/vit:v1', '.']
timeout: 180s
- name: 'gcr.io/cloud-builders/docker'
args: ['push', 'gcr.io/vision-transformer-pytorch/vit:v1']
- name: "gcr.io/cloud-builders/gke-deploy"
args:
- run
- --filename=kubernetes/
- --location=us-west1-b
- --cluster=project-kube
注意:请交叉检查 deployment.yml 和 cloudbuild.yml 文件中的容器名等参数。此外，还要用 clouldbuild.yml 文件中的集群名称交叉检查您之前创建的集群名称。最后，确保文件名参数与 deployment.yml 和 service.yml 所在的 Kubernetes 目录相同。
创建文件后，整个项目的文件结构应该如下所示:
.
├── Dockerfile
├── .github/workflow/main.yml
├── Makefile
├── README.md
├── cloudbuild.yaml
├── kubernetes
│ ├── deployment.yml
│ └── service.yml
├── metadata
│ ├── Abbott's_babbler_(Malacocincla_abbotti).jpg
│ ├── classes.txt
│ ├── models
│ │ └── model.pth
│ └── results
│ ├── accuracy_loss.png
│ ├── attn.png
│ └── confusion_matrix.png
├── notebooks
│ ├── ViT.ipynb
│ └── __init__.py
├── requirements.txt
└── source
├── __init__.py
├── app.py
├── attention.py
├── attention_block.py
├── attention_viz.py
├── config.py
├── embeddings.py
├── linear.py
├── metrics.py
├── preprocessing.py
├── test.py
├── train.py
├── transformer.py
└── vit-pytorch.ipynb
- 克隆和测试
现在，让我们在 google cloud build 项目中克隆 GitHub repo，将其放入 cd 中，并运行 cloudbuild.yml 文件。使用以下命令:
Cloning the GitHub repo
- gcloud builds 提交–配置 cloudbuild.yaml
部署过程将如下所示:
The deployment process
- 部署大约需要 10 分钟，这取决于各种因素。如果一切都正确执行，您将会看到这些步骤用绿色标记进行了颜色编码。
Succcessful deployment
- 部署成功后，您可以在 Kubernetes 引擎的 Services & Ingress 选项卡中找到应用程序的端点。单击端点，它会将您导航到 Streamlit 应用程序。
The endpoints
The Streamlit app
附加提示:
- 确保在所有*中使用小写的应用程序名称和项目 id。yml 配置文件。
- 交叉检查所有*的论点。yml 配置文件。
- 由于您是在虚拟环境中拷贝您的存储库，请交叉检查所有目录和文件路径。
- 如果在云构建过程中出现错误，请寻找一个命令来帮助您解决在错误语句中发现的错误。请看下图，以便更好地理解；我突出显示了在重新运行云构建命令之前需要执行的命令。
An error in the cloud build process
云构建集成
现在，我们将把 Google cloud 构建集成到 Github repo 中。这将创建一个触发操作，每当在回购中进行更改时，该操作将更新构建。
- 在市场中搜索谷歌云构建
Searching for Google Cloud Build
- 选择要连接的回购。在这种情况下，它将是 ViT-Pytorch 并保存它。
Selecting the repo
- 在 Google Cloud Build 中，我们将转到 Cloud Build 页面，并单击 Triggers 选项卡来创建触发器。
Creating triggers
- 单击“创建触发器”后，我们将被导航到下面的页面。这里我们将提到触发器名称，选择将触发 cloudbuild.yml 文件的事件，并选择项目存储库。
Trigger settings
- 遵循认证过程。
Authentication process
- 连接存储库。
Connecting the repository
- 最后，创建触发器。
Creating the trigger
既然已经创建了触发器，那么您在 Github repo 中所做的所有更改都将被自动检测到，并且部署也将被更新。
Created trigger
监控模型衰减
随着时间的推移，模型会衰退，这将影响预测能力。我们需要定期监控性能。一种方法是偶尔在新数据集上测试模型，并在我之前提到的指标上进行评估，如 F1 分数、准确度分数、精确度分数等。
监控模型性能的另一个有趣的方法是使用 AUROC 指标，它测量模型的区分性能。因为此项目是多分类项目，所以您可以将其转换为二元分类项目，然后检查模型的性能。如果模型的性能已经衰退，那么必须用新的样本和更大的样本再次训练模型。如果真的需要，那么也要修改架构。
这里的是代码的链接，它将允许您测量 AUROC 分数。
结论
在本文中，我们学习了使用 Pytorch 和 Streamlit 通过 Vision Transformer 构建一个图像分类器应用程序。我们还看到了如何使用 Github 操作和技术(如 Kubernetes、Dockerfile 和 Makefile)在 Google 云平台上部署应用程序。
本项目的重要收获:
- 更大的数据需要更大的模型，这本质上需要更多时代的训练。
- 在创建原型实验时，减少类的数量，并测试准确性是否随着每个历元而增加。在 Kaggle 或 Colab 等云服务上使用 GPU 之前，尝试不同的配置，直到您确信模型的性能正在提高。
- 使用各种性能指标，如混淆指标、精确度、召回率、混淆指标、f1 和 AUROC。
- 一旦部署了模型，就可以偶尔而不是频繁地对模型进行监控。
- 为了进行监控，使用像 AUROC 分数这样的性能指标是很好的，因为它会自动创建阈值并绘制模型的真阳性率和假阳性率。有了 AUROC 评分，就可以很容易地比较模型以前和当前的性能。
- 只有当模型发生显著漂移时，才应该重新训练模型。由于像这样的模型需要大量的计算资源，频繁的重新训练可能是昂贵的。
我希望你发现这篇文章信息丰富，实用。你可以在这个 Github repo 中找到完整的代码。也可以随意与他人分享。
参考
- 一幅图像值 16×16 个字:大规模图像识别的变形金刚
- 变形金刚比 CNN 更健壮吗？
- https://www . kdnugges . com/2022/01/machine-learning-models-die-silence . html
- https://github.com/jeonsworld/ViT-pytorch
- https://gist . github . com/khizirsiddiqui/559 a 91 dab 223944 FB 83 f 8480715d 2582
- https://github.com/srivatsan88/ContinousModelDeploy
- 为 NLP 构建 MLOps 管道:机器翻译任务
为 NLP 构建 MLOps 管道:机器翻译任务[教程]
原文：https://web.archive.org/web/https://neptune.ai/blog/mlops-pipeline-for-nlp-machine-translation
机器学习操作通常被称为 MLOps 使我们能够创建一个端到端的机器学习管道，从设计实验、构建 ML 模型、训练和测试，到部署和监控，换句话说就是 机器学习生命周期 。MLOps 的这个领域类似于 DevOps，但专门为机器学习项目量身定制。
作为一个相对较新的领域，像机器学习这样的 MLOps 已经获得了很大的吸引力，正因为如此，人工智能驱动的软件正在所有行业中流行。我们必须有专门的操作人员来完成这一过程。MLOps 使我们能够利用其两个主要组件来构建人工智能驱动的软件:持续集成和持续部署。我们可以创建从开始到部署的无缝管道，并随时修改构建。
在本文中，我们将详细讨论如何使用各种技术为机器翻译构建 MLOps 管道。我们将使用的一些关键技术是:
- 唐斯多夫，
- 海王星啊！
- GitHub 股份公司，
- 码头工，
- Kubernetes，
- 和谷歌云构建。
本教程旨在为您提供如何为您自己的机器学习或数据科学项目逻辑地实现 MLOps 的完整理解。
什么是 MLOps 管道？
MLOps 可以被描述为机器学习或数据科学项目的生命周期。生命周期本身由三个主要部分组成:
- 1 设计
- 2 模型开发
- 3 操作
通过结合这三个部分，我们可以建立一个集成的系统，可以利用机器学习和软件应用程序的力量。这个管道自动化了数据收集、数据预处理、培训和测试、部署和监控的过程。除此之外，它还能够检测构建中的任何新变化，并同时更新全局的新变化。
为机器翻译构建 MLOps 管道:从哪里开始？
为了打造流畅的 MLOps 生命周期管道，必须考虑以下步骤。
设计
设计基本上是理解通常与目标受众打交道的业务问题的过程。
设计实验还包括研究可用的资源，如知识收集、可以使用的数据类型、合适的体系结构、财务资源、计算资源等等。
通常，在这个过程中，数据科学家和机器学习工程师为了节省时间，会尝试寻找可用的解决方案，并根据要求进行修改。
本质上，设计通过预测的解决方案设定目标。
问题陈述
作为本文的一部分，让我们考虑我们需要构建一个应用程序，将葡萄牙语翻译成英语。这个问题属于自然语言处理的范畴，更具体地说是机器翻译。现在，作为一名数据科学家或 ML 工程师，您需要考虑以下几点:
- 1 应该使用什么计算语言和相关库？
- 我们可以从哪里获得数据？
- 3 模型的核心架构必须是什么？
- 4 培训目标和输出应该是什么，以及准确性和损失指标、优化技术等等。
- 截止日期和预算是什么？
研究
研究是我们探索每一个可能的解决方案来制造产品的一部分。例如，在选择构建深度学习模型的语言时，python 是最佳选择。但如果你是一名 iOS 开发者，那么 Swift 是首选语言，一些公司如 Tesla 确实考虑 C 和 C++以及 Python。对于本文，让我们坚持使用 python，因为它是构建深度学习和机器学习模型最广泛使用的语言。
现在，为了构建深度学习模型，可以使用两个 python 库中的一个:Tensorflow 和 Pytorch。两者都非常受欢迎，多才多艺，并拥有大量的社区支持。在这个阶段，这一切都归结为偏好和一方相对于另一方的优势。在我们的例子中，我们将使用 Tensorflow，因为它有一个非常结构化的 API，即 Keras，并且与 Pytorch 相比，实现它需要更少的代码行。
当语言和核心库设置好后，我们就可以研究可以用来实现机器翻译的架构了。目前我们知道大多数 SOTA 语言模型大量使用变形金刚，因为它的自我关注机制。所以我们也会这样做。
说到数据，我们可以很容易地从几乎任何地方下载语言翻译数据，但最佳实践是从合法资源下载精选数据，如 Kaggle。在我们的例子中，我们将使用 TensorFlow-dataset API 来下载数据。
现在让我们了解一下目录结构。
目录结构
在所有项目中，最关键的是目录结构。一个结构良好的项目有利于读者高效地跟踪和协作。就 MLOps 而言，它扮演着重要的角色，因为从构建到部署，我们将使用不同的技术来访问端点。
MLOps 项目的一般结构如下所示:
Machine-translation
├── kube
├── metadata
├── notebook
├── requirements.txt
├── README.md
└── source
这是主目录结构及其子目录 requirements.txt 和 README.md 文件。随着我们继续前进，我们将不断向目录中添加更多的文件。
机器翻译的 MLOps 流水线:模型开发
为了这篇文章，我们将使用 Tensorflow 网站上提供的笔记本。该笔记本信息量很大，并给出了如何编写和训练机器翻译模型的透彻想法。
我们将对笔记本进行一些修改，并在培训期间集成 Neptune 客户端来监控模型。现在我们来简单的探讨一下，修改一下笔记本。
设置
首先，我们必须安装三个库: Tensorflow-datasets 用于下载数据， Tensorflow 用于深度学习，以及 Neptune-client 用于监控和保存元数据。
!pip install tensorflow_datasets
!pip install -U 'tensorflow-text==2.8.*'
!pip install neptune-client
一旦安装了库，我们就可以将它们全部导入到笔记本中。
下载数据集
我们将使用的数据集，即将葡萄牙语翻译成英语，可以直接从 TensorFlow-datasets 库中下载。一旦数据集被下载，我们就可以把它分成训练数据集和验证数据集。
examples, metadata = tfds.load('ted_hrlr_translate/pt_to_en', with_info=True,
as_supervised=True)
train_examples, val_examples = examples['train'], examples['validation']
创建 requirements.txt
Requirements.txt 是一个重要的文件，因为它包含了所有的库。这允许新的贡献者在他们的工作环境中快速安装所有的库或依赖项。
要创建一个 requirement.txt 文件，我们需要做的就是运行:
!pip freeze > requirements.txt
这可以在我们安装并导入所有文件之后，或者在您完成了对模型的训练和执行推断之后完成。优选地，实践后者。
requirements.txt 文件应该是这样的:
matplotlib==3.2.2
neptune-client==0.16.1
numpy==1.21.6
tensorflow-datasets==4.0.1
tensorflow==2.8.0
跟踪模型元数据
登录 neptune.ai 仪表盘相当简单。首先，我们创建一个类，存储所有的超参数。这种方法在创建单独的 python 模块时非常方便(我们将在后面看到)。
class config():
BUFFER_SIZE = 20000
BATCH_SIZE = 64
MAX_TOKENS = 128
MAX_EPOCHS = 5
TRAIN_LOSS = 'train_loss'
TRAIN_ACCURACY = 'train_accuracy'
OPTIMIZER = 'Adam'
BETA_1 = 0.9
BETA_2 = 0.98
EPSILON = 1e-9
NUM_LAYER = 4
D_MODEL = 128
DFF = 512
NUM_HEAD = 8
DROP_OUT = 0.1
然后我们可以创建一个存储所有超参数的字典。
params = {
'BUFFER_SIZE': config.BUFFER_SIZE,
'BATCH_SIZE' : config.BATCH_SIZE,
"MAX_TOKENS" : config.MAX_TOKENS,
"MAX_EPOCHS" : config.MAX_EPOCHS,
"TRAIN_LOSS" : config.TRAIN_LOSS,
"TRAIN_ACCURACY" : config.TRAIN_ACCURACY,
"OPTIMIZER" : config.OPTIMIZER,
"BETA_1" : config.BETA_1,
"BETA_2" : config.BETA_2,
"EPSILON" : config.EPSILON,
"NUM_LAYER" : config.NUM_LAYER,
"D_MODEL" : config.D_MODEL,
"DFF" : config.DFF,
"NUM_HEAD" : config.NUM_HEAD,
"DROP_OUT" : config.DROP_OUT,
}
一旦创建了字典，我们就可以使用 API 令牌初始化 Neptune 客户端，并将参数作为字典传递。
run = neptune.init(
project="nielspace/machine-translation",
api_token="eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiJkYjRhYzI0Ny0zZjBmLTQ3YjYtOTY0Yi05ZTQ4ODM3YzE0YWEifQ==",
)
run["parameters"] = params
一旦执行，这将是它在 neptune.ai 仪表板中的外观。
Parameters logged in Neptune.ai | Source
如您所见，所有的超参数都被记录下来。
模特培训
一旦模型的所有组件如编码器、解码器、自我关注机制等都准备好了，就可以训练模型了。但是，我们必须再次确保在训练期间集成 Neptune-client 来监控模型，以查看它的表现如何。
要做到这一点，我们只需要定义精度和损失函数，并将它们传递到训练循环中。
train_loss = tf.keras.metrics.Mean(name=config.TRAIN_LOSS)
train_accuracy = tf.keras.metrics.Mean(name=config.TRAIN_ACCURACY)
在训练循环中，我们将使用与之前相同的方法来记录准确性和损失。
run['Training Accuracy'].log(train_accuracy.result())
run['Training Loss'].log(train_loss.result())
让我们将它们整合到培训循环中。
for epoch in range(config.MAX_EPOCHS):
start = time.time()
train_loss.reset_states()
train_accuracy.reset_states()
for (batch, (inp, tar)) in enumerate(train_batches):
train_step(inp, tar)
run['Training Accuracy'].log(train_accuracy.result())
run['Training Loss'].log(train_loss.result())
if batch % 50 == 0:
print(f'Epoch {epoch + 1} Batch {batch} Loss {train_loss.result():.4f} Accuracy {train_accuracy.result():.4f}')
if (epoch + 1) % 5 == 0:
ckpt_save_path = ckpt_manager.save()
print(f'Saving checkpoint for epoch {epoch+1} at {ckpt_save_path}')
print(f'Epoch {epoch + 1} Loss {train_loss.result():.4f} Accuracy {train_accuracy.result():.4f}')
print(f'Time taken for 1 epoch: {time.time() - start:.2f} secsn')
run.stop()
这是培训期间仪表板的外观。
Training accuracy and loss logged in Neptune.ai | Source
要记住的一个关键点是，在实验完成或训练循环完全执行后停止运行。
Neptune-client API 的一个好处是，您可以记录几乎任何事情。
验证和测试模型
一旦训练完成，我们就可以在创建应用程序之前对模型进行推理测试。当创建一个用于推理的类对象时，你必须记住，所有的预处理步骤都必须包含在内，因为这个相同的类将在 app.py 中用来创建端点。
这里有一个例子:
class Translator(tf.Module):
def __init__(self, tokenizers, transformer):
self.tokenizers = tokenizers
self.transformer = transformer
def __call__(self, sentence, max_length=config.MAX_TOKENS):
assert isinstance(sentence, tf.Tensor)
if len(sentence.shape) == 0:
sentence = sentence[tf.newaxis]
sentence = self.tokenizers.pt.tokenize(sentence).to_tensor()
encoder_input = sentence
start_end = self.tokenizers.en.tokenize([''])[0]
start = start_end[0][tf.newaxis]
end = start_end[1][tf.newaxis]
output_array = tf.TensorArray(dtype=tf.int64, size=0, dynamic_size=True)
output_array = output_array.write(0, start)
for i in tf.range(max_length):
output = tf.transpose(output_array.stack())
predictions, _ = self.transformer([encoder_input, output], training=False)
predictions = predictions[:, -1:, :]
predicted_id = tf.argmax(predictions, axis=-1)
output_array = output_array.write(i+1, predicted_id[0])
if predicted_id == end:
break
output = tf.transpose(output_array.stack())
text = tokenizers.en.detokenize(output)[0]
tokens = tokenizers.en.lookup(output)[0]
_, attention_weights = self.transformer([encoder_input, output[:,:-1]], training=False)
return text, tokens, attention_weights
如您所见，预处理和预测所需的步骤包含在同一个类对象中。现在我们测试我们的模型在看不见的数据上的表现。
def print_translation(sentence, tokens, ground_truth):
print(f'{"Input:":15s}: {sentence}')
print(f'{"Prediction":15s}: {tokens.numpy().decode("utf-8")}')
print(f'{"Ground truth":15s}: {ground_truth}')
sentence = 'este é um problema que temos que resolver.'
ground_truth = 'this is a problem we have to solve .'
translator = Translator(tokenizers, transformer)
translated_text, translated_tokens, attention_weights = translator(
tf.constant(sentence))
print_translation(sentence, translated_text, ground_truth)
输出:
Input: : este é um problema que temos que resolver.
Prediction : this is a problem that we have to solve .
Ground truth : this is a problem we have to solve .
下载元数据和笔记本
一旦训练和推理完成，我们就可以从 Google Colab 下载元数据和笔记本到我们的本地目录，然后为每个类对象创建单独的 python 模块。
例如，你可以看到所有的目录已经完全被它们各自的文件和元数据填满了。
machine-translation
├── metadata
│ ├── checkpoints
│ │ └── train
│ │ ├── checkpoint
│ │ ├── ckpt-1.data-00000-of-00001
│ │ └── ckpt-1.index
│ ├── ted_hrlr_translate_pt_en_converter
│ │ ├── assets
│ │ │ ├── en_vocab.txt
│ │ │ └── pt_vocab.txt
│ │ ├── saved_model.pb
│ │ └── variables
│ │ ├── variables.data-00000-of-00001
│ │ └── variables.index
│ ├── ted_hrlr_translate_pt_en_converter.zip
│ └── translator
│ ├── assets
│ │ ├── en_vocab.txt
│ │ └── pt_vocab.txt
│ ├── saved_model.pb
│ └── variables
│ ├── variables.data-00000-of-00001
│ └── variables.index
├── notebook
├── requirements.txt
└── source
├── attention.py
├── config.py
├── decoder.py
├── encoder.py
├── inference.py
├── preprocessing.py
├── train.py
└── transformer.py
在上面的例子中，源目录由 python 模块组成，这些模块包含直接取自笔记本的函数和类对象。
app.py
下一步是创建一个 app.py，它将利用 flask API 为模型服务。为了服务于该模型，我们需要:
- 1 从预处理和转换模块导入所有函数。
- 2 加载保存在翻译目录中的重量。
- 3 定义获得预测的端点。
import flask
from flask import Flask
import logging
import time
import numpy as np
import matplotlib.pyplot as plt
import tensorflow_datasets as tfds
import tensorflow as tf
import tensorflow_text
import source.config as config
from source.preprocessing import *
from source.transformer import *
app = Flask(__name__)
@app.route("/predict")
def predict():
sentence = request.args.get("sentence")
response = translator(sentence).numpy()
return flask.jsonify(response)
if __name__ == "__main__":
translator = tf.saved_model.load('../translator')
app.run(host="0.0.0.0", port="9999")
机器翻译的 MLOps 管道:操作(CI/CD)
一旦代码库准备就绪，我们就可以继续我们的第三个也是最后一个阶段，即运营，这是我们将实施持续部署和持续集成的地方。这就是事情变得有点棘手的地方。但是不要担心，我已经把整个操作分成了不同的部分，这样每个模块都清晰易懂。这些是我们将遵循的步骤:
- 1 创建 Github repo。
- 使用 Docker 文件创建图像。
- 3 将图像推送到 Google Cloud Build。
- 4 展开。
创建 GitHub repo
第一步是将您的所有代码从本地目录推到您的 GitHub 帐户。这将有助于我们将回购目录连接到谷歌云开发。在那里，我们可以创建 Kubernetes pods 并在其中部署应用程序。
Dockerfile
dockerfile 使我们能够创建一个容器，这是一种包装应用程序的软件，包括它的库和依赖关系。它还创建了一个静态环境，使应用程序能够在任何环境中运行。
另一方面，Docker 是构建和管理容器的软件。我们可以创建任意多的容器。
为了给我们的 app.py 创建一个容器，我们需要创建一个 Dockerfile 。该文件即映像必须存储构建容器所需遵循的所有指令。一些一般说明如下:
- 安装编程语言，在我们的例子中是 python。
- 2 创造环境。
- 3 安装库和依赖项。
- 4 复制模型、API 和其他实用程序文件，以便正确执行。
在下面的例子中，你会看到我是如何构建 Docker 配置的。相当简约极简。
FROM python:3.7-slim
RUN apt-get update
ENV APP_HOME /app
WORKDIR $APP_HOME
COPY . ./
RUN ls -la $APP_HOME/
RUN pip install -r requirements.txt
CMD ["python3","app.py" ]
谷歌云开发
配置 Dockerfile 后，我们将使用 Google Cloud Development 或 GCD 来自动化 CI/CD 管道。当然，你可以使用任何其他服务，比如 Azure、AWS 等等，但是我发现 GCD 简单易用。我将详细解释这一部分，以便您可以轻松掌握完整的概念并理解该过程。
第一步是登录你的 GCD 账户，如果你是新用户，你将获得 300 美元的免费积分，可以在 90 天内使用。
谷歌云开发:云壳
一旦你登录到你的 GCD，创建一个新项目。之后点击屏幕右上角的云壳图标激活云壳。
需要注意的一点是，在大多数情况下，我们将使用内置的云外壳来执行流程。第一步是从 Github 克隆存储库。您可以在给定的链接中使用相同的代码。
Google Cloud development: Cloud Shell | Source: Author
一旦回购被克隆到 cd 中。
谷歌云开发:Kubernetes
现在我们将启用，设置，和启动Kubernetes 引擎。Kubernetes 引擎将允许我们管理我们的 dockerized 应用程序。要配置 Kubernetes，我们需要遵循 4 个步骤:
- 1 创建 deployment.yaml 文件。
- 2 创建一个 service.yaml 文件。
- 3 在 GCD 中启用 Kubernetes 引擎。
- 4 通过云壳启动 Kubernetes 引擎。
创建一个 deployment.yaml
deployment.yaml 的目的是配置部署设置。它由两部分组成:
- API 版本和操作种类
apiVersion: apps/v1
kind: Deployment
metadata:
name: translation
spec:
replicas: 2
selector:
matchLabels:
app: translation-app
template:
metadata:
labels:
app: translation-app
spec:
containers:
- name: translation-app
image: gcr.io/tensor-machine-translation/translation:v1
ports:
- containerPort: 9999
下面是我在元数据中指定的配置内容:
- 在本例中，我将使用的复制副本或 pod 的数量是 2。
- 集装箱位置。该位置也可以分为四个步骤:
- URL: " gcr.io "。这是常见的容器地址。
- 项目 ID: " 张量机器翻译"
- App 名称:翻译。您可以给出任何名称，但它必须在所有配置文件中相同。
- 版本: v1 。这是一个标签。
创建一个 service.yaml
service.yaml 将整个应用程序暴露给网络。它类似于 deployment.yaml，但主要区别在于我们想要实现的操作类型，它也由两部分组成:
- API 版本和操作种类
apiVersion: v1
kind: Service
metadata:
name: machinetranslation
spec:
type: LoadBalancer
selector:
app: machinetranslation
ports:
- port: 80
targetPort: 9999
配置完部署和服务文件后，让我们转到 Kubernetes。
在 GCD 中启用 Kubernetes 引擎
一旦我们的配置文件准备好了，我们就可以开始启用 Kubernetes API 了。这是一个用于管理 Dockerized 应用程序的开源系统。要启用 Kubernetes，只需在 GCD 搜索栏中输入‘GKE’。只要点击‘启用，你就会被导航到 Kubernetes 引擎 API 页面。
Building MLOPS pipeline with Kubernets | Source: Author
启用 API 后，您需要创建 Kubernetes 集群。有两种方法可以创建集群:
- 1 只需点击屏幕上的“创建”按钮。
- 使用 Google-Cloud shell。
Kubernets clusters | Source: Author
在我们的例子中，我们将使用 Google-Cloud shell，因为您可以更具体地了解您想要什么类型的集群。
启动 Kubernetes 引擎
要启动 Kubernetes 引擎，请在您的云 shell 中编写以下代码。
!gcloud config set project tensor-machine-translation
!gcloud config set compute/zone us-central1
!gcloud container clusters create tensorflow-machine-translation --num-nodes=2
Launching the Kubernetes engine | Source: Author
完成后，您可以在仪表板上查看 K8 集群。
Launching the Kubernetes engine | Source: Author
现在，我们的 Kubernetes 配置文件和引擎已经准备好了，我们可以开始配置我们的 clouldbuild.yaml 文件，然后启动整个应用程序。
谷歌云开发:云构建
cloudbuild.yaml 文件将所有进程同步在一起。这很容易理解。配置文件通常包含以下步骤:
- 1 从 Dockerfile 文件构建容器映像。
- 2 将容器映像推送到 Google Cloud Registry (GCR)。
- 3 配置入口点。
- 4 在 Kubernetes 引擎中部署整个应用程序。
steps:
- name: 'gcr.io/cloud-builders/docker'
args: ['build', '-t', 'gcr.io/tensor-machine-translation/translation', '.']
timeout: 180s
- name: 'gcr.io/cloud-builders/docker'
args: ['push', 'gcr.io/tensor-machine-translation/translation']
- name: 'gcr.io/cloud-builders/gcloud'
entrypoint: "bash"
args:
- "-c"
- |
echo "Docker Container Built"
ls -la
ls -al metadata/
- name: "gcr.io/cloud-builders/gke-deploy"
args:
- run
- --filename=kube/
- --location=us-west1-b
- --cluster=tensor-machine-translation
配置完 cloudbuild.yaml 文件后，您可以返回到 Google-Cloud Shell 并运行以下命令:
!gcloud builds submit --config cloudbuild.yaml
Google Cloud development: Cloud Build | Source: Author
部署完成后，您将获得应用程序的链接。
GitHub 操作
现在，我们已经完成了所有重要的过程，我们的应用程序已经启动并运行了。但现在我们将看到如何使用 Github 动作创建触发器，这将使我们能够在修改和推送 Github repo 中的代码时自动更新构建。让我们看看我们能做些什么。
去 Github 市场搜索 Google Cloud Build。
Github marketplace | Source: Author
点击谷歌云构建。
Selecting Google Cloud Build | Source: Author
点击建立一个计划。
Setting up a plan with Google Cloud Build | Source: Author
Setting up a plan with Google Cloud Build | Source: Author
点击配置。
Google Cloud Build configuration | Source: Author
选择存储库。
Selecting Google Cloud Build repository | Source: Author
选择项目在我们的情况下，它是张量机器翻译。
Selecting “Tensor-machine-translation” | Source: Author
点击创建触发器。
Creating a trigger | Source: Author
为触发器提供一个“名称”,并保留所有设置。
Naming the trigger | Source: Author
点击创建。
Creating a trigger | Source: Author
创建后，您将被引导至以下页面。
Trigger’s view in Google Cloud Build | Source: Author
现在，有趣的部分是，每当您对 Github repo 进行任何更改时，云构建都会自动检测到它，并在部署的构建中进行更改。
生产中的监控模型
到目前为止，我们已经了解了如何构建自动 MLOps 管道，现在我们将探讨最后一步，即如何监控部署在云上的应用。这个过程称为云部署。GCD 为我们提供了一个仪表板，使我们能够从任何设备监控应用程序:手机、平板电脑或电脑。
下面是 iOS 中给出的谷歌云控制台的图像。
Google Cloud console | Source: Author
为了监控该应用程序，您只需在 GCD 搜索栏中键入 monitor，它就会将您导航到相应的页面。
Monitoring in Google Cloud | Source: Author
你会看到一堆选项可供选择。我建议您首先选择一个概述，然后探索所有可能的选项。例如，如果您选择 GKE，那么您将看到关于 Kubernetes 的所有信息:各个项目的 pod、节点、集群等等。
Monitoring in Google Cloud | Source: Author
同样，您也可以创建警报策略。和许多其他事情。
Monitoring in Google Cloud | Source: Author
在监控阶段，您必须熟悉的一个重要概念是模型漂移。当模型的预测能力随着时间的推移而下降时，就会发生这种情况。
模型漂移可分为两种类型:
数据漂移
数据漂移通常是生产数据与训练/测试数据之间的差异。它通常发生在训练和部署之间有时间间隔的时候。一个这样的例子是任何时间序列数据，如新冠肺炎数据或股票市场数据。在这种情况下，像可变性这样的因素每小时都会被引入，换句话说，数据会随着时间的推移而不断发展。数据的这种演变会在生产阶段产生预测误差。
在我们的例子中，我们不必担心，因为语言数据在大多数情况下保持稳定，因此我们可以在更长的时间内使用相同的模型。
您可以在下面的博客中找到更多关于数据漂移检测的信息:为什么数据漂移检测如此重要，以及如何通过 5 个简单的步骤实现自动化。
概念漂移
当预测变量随时间变化时，或者换句话说，当输出的统计属性随时间变化时，就会发生概念漂移。在概念漂移中，模型无法利用它在训练期间提取的模式。例如，让我们说垃圾邮件自从被定义以来已经随着时间的推移而发展。现在，该模型将发现很难使用 3 周前在训练中提取的模式来检测垃圾邮件。为了解决这些问题，必须调整模型参数。
如果公司的商业模式正在发生变化，或者所使用的数据集不能代表整个人口，那么概念漂移就可能发生。
如何监控一个模型？
- 像顺序分析和时间分布方法这样的方法有助于识别数据漂移。
- 另一方面，持续监控输入数据并观察其统计特性有助于克服概念漂移。
- 除了像 ADWIN、卡方检验、直方图交叉、kolmogorov smirnov 统计之类技术之外，这些技术也是有用的。
如何克服模型漂移？
模型再训练是解决模型漂移(包括数据漂移、概念漂移和模型退化问题)的最好方法。再培训可以参考这些策略:
- 定期再培训–定期:每周、每月等等。
- 数据/事件驱动–每当新数据可用时。
- 模型/度量驱动–当精度低于阈值时。
结论
在本教程中，我们探讨了如何使用各种技术来无缝部署机器翻译应用程序。这就是 MLOps 的力量。当然，你可以像 UI/UX 一样在 app.py 文件中添加很多东西，创建一个全新的网页。
总而言之，我们看到:
1 如何设计一个实验？
- 2 训练和测试模型。
- 3 保存模型的权重和元数据。
- 4 构建目录。
- 5 分离功能，创建 python 模块。
- 6 创建 Flask app。
- 7 将应用程序归档。
- 创建和配置 Google Kubernetes 引擎。
- 9 在 Google Kubernetes 引擎中部署应用程序。
- 最后，使用 Github Actions 自动化整个过程。
- 如果你正在创建任何利用机器学习或深度学习算法的项目，那么你应该超越并创建一个 MLOps 管道，而不是停留在模型训练上。我希望本教程能够帮助您理解如何在自己的项目中实现 MLOps。
请务必尝试一下，因为这是部署您的 ML 和 DL 应用程序的最佳方式。
密码
你可以在这里找到完整的库。另外，值得一提的是，机器翻译的笔记本取自官网。
参考
注意力神经机器翻译
- 机器学习操作
- 如何使用 GitHub 操作构建 MLOps 管道【分步指南】
- 为 MLOps 使用 GitHub 动作
- 在 Google Kubernetes 引擎上部署机器学习管道
- 为什么数据漂移检测如此重要，您如何通过 5 个简单的步骤实现自动化
- Why data drift detection is important and how do you automate it in 5 simple steps
为时序预测构建 MLOps 管道[教程]
在本教程中，我们将展示一个基于时间序列的 ML 项目的简单示例，并为其构建一个 MLOps 管道。每一步都将按照 MLOps 的最佳实践来执行，整个项目将一步一步地解释。
这个时序项目是基于币安交易应用，但类似的逻辑也适用于其他 ML 项目。
注意:这篇文章不是为了财务建议，它只是为了教育目的而写的。此外，本文的主要目的是介绍具有端到端 ML 项目流程的 MLOps 架构，而不是介绍有利可图的交易策略。
MLOps 101
MLOps 代表机器学习操作，它是管理 ML 项目管道的过程。MLOps 的作用是将 ML 项目的不同部分连接成一个结构，与其所有组件协调工作，并在将来保留该功能。为了实现最大的健壮性，MLOps 应用了 DevOps 的一些实践，尤其是持续集成和持续交付(CI/CD):
-
持续集成确保每当一段代码或数据更新时，整个 ML 管道都能平稳运行。这是通过代码和数据版本化实现的，它允许代码在不同的团队之间共享和运行。重新运行可能包括培训和测试，但是拥有并运行代码测试以确保输入和输出数据遵循特定的格式并且一切按预期运行也是一个好的实践。
-
连续交付允许自动部署新的 ML 模型。通过 CD 流程，可以使用触发器在现有环境中部署新模型，例如新数据集上的重新训练模型、新超参数或新模型架构。
总的来说，对于有编程经验的人来说，理解 MLOps 最简单的方法就是和 DevOps 对比。但在工具和流程上，它们并不完全相同。DevOps 和 MLOps 都试图整合开发、测试和操作原则；然而，DevOps 专注于常规软件开发，而 MLOps 只专注于 ML 项目。
在 ML 项目中，代码不是版本控制管理下的唯一组件。输入数据、超参数、元数据、日志和模型会随着时间而变化，因此需要控制和监控。另一个区别是传统软件不会退化，而 ML 模型会。一旦模型被部署到生产中，它就有可能开始产生错误和不准确的结果。这是因为输入数据随着时间的推移而变化，而模型保持不变，用旧数据进行训练。
因此，除了 CI/CD 之外，MLOps 还包括:
- 持续培训(CT)-在生产中自动重新培训 ML 模型的过程。
- 持续监控(CM)-持续监控生产中的数据和模型，以便注意潜在的数据漂移或模型过时。
MLOps 阶段
没有解决 MLOps 问题的独特方法或架构，尤其是现在有数百个与 MLOps 相关的工具和软件包。这是因为 ML 项目的多样性和 MLOps 的概念相当年轻的事实，我们可以提出一些步骤来帮助建立 MLOps 管道，但最有可能的是，它们可能不是详尽的。
设计和范围
Some of the MLOps tools | Source
在我们开始开发 ML 项目和编写代码之前，我们需要确保业务目标是明确的，并且我们有足够的能力解决问题。接下来是设计和范围的阶段。
在这个阶段，我们需要确保理解项目的问题陈述和业务目标。此外，我们需要检查所有资源的可用性，例如合适的架构、计算资源、有能力的团队等等。
发展
在设计和确定范围之后，是项目开发。它包括:
研究–收集关于潜在输入特征、数据预处理步骤、ML 模型、新工具等的新信息。
- 数据工程——数据摄取、开发 ETL 管道、数据仓库、数据库工程等。
- 探索性数据分析(EDA)–使用数据分析和可视化技术了解我们的数据。
- 实验开发–可能包括数据预处理、特征工程、ML 模型开发、超参数调整等。
- 实验跟踪–最后，我们要比较所有实验并得出结论。
- 操作
在一个模型被开发出来并准备好投入生产后，就进入了运营阶段。运营的主要目标是使用一些 MLOps 实践将开发的模型投入生产，如测试、版本控制、CI/CD、监控等。
时间序列 101
时间序列是按时间顺序排列的数据点序列。它是同一变量在不同时间点的一系列观察结果。时间序列数据通常表示为图表上的一条线，x 轴表示时间，y 轴表示每个数据点的值。此外，每个时间序列都由四个部分组成:
A time series is a sequence of data points that are ordered in time. It is a series of observations of the same variable at different points in time. A time-series data is often presented as a line on a graph with time on the x-axis and the value of each data point on the y-axis. Also, every time series is composed of four components:
1 趋势
-
2 季节变化
-
3 周期性变化
-
4 不规则或随机变化
时序项目示例
Example of a time series | Source
时间序列在许多行业中都有表示，并且有大量时间序列项目的真实例子。这里，我们只提其中的一部分。
网站流量预测
主要思想是预测特定网站的流量，并在此基础上优化资源分配。它可能有助于负载平衡器将网络或应用程序流量分布到多个服务器上。除此之外，为了发现潜在的黑客攻击，有可能为 web 流量中的异常检测开发 ML 解决方案。
许多组织，如脸书、亚马逊、易贝等，都使用类似的应用程序来预测和监控互联网流量。
医疗保健中的时间序列项目
医疗保健中的时间序列数据，如电子健康记录(EHR)和注册表，代表了有关患者的有价值的信息来源，并可在许多方面用于患者福利。使用这些数据，可以开发 ML 模型，从而更深入地了解个体健康和疾病的轨迹，如癌症、阿尔茨海默病、心血管疾病、新冠肺炎和许多其他疾病。
利用时间序列和 ML 模型，有可能发现未来死亡率、复发和并发症的风险，并推荐相同的处方和预防措施。
股票市场预测
股票市场预测是一项非常具有挑战性的任务，其主要目标是创建各种策略来预测未来的股票价格。由于许多因素，如全球经济、财务报告、政治和其他因素，股票市场具有非常不稳定和混乱的行为。
Time series and ML in medicine | Source
一般来说，股市预测方法的应用方式有很多种。其中一些是趋势预测，长期价格预测，波动预测，每日，每小时，或高频交易，等等。
其中大多数基于两种方法；基本面分析和技术面分析。基本面分析会考虑一些因素，如财务报告、行业趋势、通货膨胀率、GDP 等。技术分析使用从历史股票数据中计算出来的技术指标，并在此基础上预测股票未来的表现。
比特币交易
比特币是一种数字资产，其价格由供需决定。同样，作为股票市场，它具有非常不稳定和混乱的行为，而比特币价格预测是一个复杂的挑战。众所周知，比特币与一些科技公司的股票相关，因此可以使用许多股市预测技术。
在本文中，我们将使用比特币价格交易作为时间序列项目的示例。这篇文章不是金融建议，它是为教育目的而写的，重点是时间序列和 MLOps 架构。因此，使用 Python 只能开发简单的交易策略。
为了编写一个能够自动下订单的 Python 程序，我们将使用币安交易所和币安 API 及其自己的包装包Python-币安。此外，币安提供了一个模拟账户，允许交易者在模拟环境中用“纸币”进行交易。关于这一点的更多内容将在下面的文章中介绍。
时间序列预测的 MLOps 流水线:设计和范围
前面提到和简要描述的所有阶段将在下面使用我们的比特币交易示例一步一步地实际实现。
问题陈述
首先，我们需要确定我们清楚这个问题。在这种特殊的情况下，我们不需要与客户或利益相关者等外部因素进行沟通。为了更简单，我们将尝试预测每小时的比特币走势。意味着我们要预测比特币接下来一个小时是涨还是跌，这说明这是一个分类问题。基于这一预测，我们将建立多头或空头头寸(买入或卖出特定数量的比特币)。
例如，如果我们预测比特币的价格将在接下来的一个小时内上涨，如果它从 100 美元涨到 105 美元，我们的利润将是 5 美元。否则，如果价格从 100 美元降到 95 美元，我们将损失 5 美元。
粗略地说，预测将使用 XGBoost 模型，整个 ML 项目将遵循最佳 MLOps 实践。
在此阶段，我们可以大致提出 MLOps 结构的蓝图如下:
商业目标
这里的商业目标很明确，那就是盈利。这是一个非常投机的策略；除此之外，我们还需要定义我们可以处理什么样的损失。例如，在任何时候，如果该策略的累计回报率低于-20%，交易将被暂停。
可利用的资源
Proposed MLOps architecture | Source: Author
由于我们的项目很小，而且本质上是实验性的，很可能我们不需要在工具上花任何钱。此外，不会投入实际资金，因为该项目将部署到币安模拟环境。
用于功能工程和培训的所有历史比特币价格数据将从 AWS S3 的币安下载。由于历史数据不是很大，我们也将它下载到本地，模型开发也将在本地完成。
最后，我们需要获得所有将在我们的项目中使用的工具，这将在途中完成。
时间序列预测的 MLOps 管道:模型开发
研究
正如我们之前提到的，ML 项目开发的一个好的实践是从研究开始。在我们的例子中，我们可以简单地谷歌一些与我们的项目相关的术语，如“机器学习比特币交易 python”或“比特币技术指标”。此外，youtube 是一个很好的信息来源，尤其是在一些更复杂的概念需要解释的时候。
一些高质量的资源可能不容易通过谷歌搜索获得。例如，来自 Kaggle 的笔记本很少出现在顶级搜索结果中。此外，一些特定领域的高级课程可能会出现在 Udemy 、 Udacity 或 Coursera 上。
有一些流行的 ML 网站，像机器学习大师、中级和走向数据科学。高质量的 MLOps 内容搜索的一个好地方肯定是 Neptune.ai 博客。Slack 上还有 MLOps 社区，这是一个超级活跃的从业者讨论和分享知识的团体。你可以在这里加入(如果你真的加入了，就来#neptune-ai 频道说说 MLOps，这篇文章，或者只是打个招呼！).
最后，对于一些最先进的解决方案，我们可以搜索谷歌学术或研究之门。
数据工程
在我们的例子中，输入数据的唯一来源是币安。使用 python-finance 包，可以用现有的方法直接获得数据。此外，还有一种获取历史价格并直接保存的替代方法。每月整理的 csv 文件。
为此，我们需要使用币安公共数据库。下载压缩文件。csv 文件，我们使用命令:
其中“download-kline.py”是“python”目录中的脚本。关于这个 python 脚本及其参数的更多信息可以在这里找到。
由于我们将使用 AWS 云架构，数据将被摄取到 S3 存储中。新的 AWS 帐户可以免费获得 12 个月的 5GB S3 存储空间。为了上传数据，我们需要创建一个 bucket，它是存储在 S3 上的对象的容器。如何创建一个桶并在桶中上传一个文件在这个视频中有解释。
除了使用 AWS web 控制台上传数据之外，还可以从 AWS EC2 实例上传数据。基本上，使用 EC2 可以创建一个实例或虚拟机，我们可以从那里下载数据，并使用一个简单的命令直接复制到 S3 存储桶:
`python download-kline.py -s BTCUSDT -i 1h -startDate 2017-08-01 -endDate 2022-06-01`
有了一个新的 AWS 帐户，就有可能每月获得 750 小时的小实例，12 个月免费。此外，我们还将在 EC2 实例上部署我们的项目。
对于更复杂的项目，AWS 上有几个其他的数据工程服务，一些最常用的服务在视频中解释。
ML 模型开发
`aws s3 cp LOCAL_DIRECTORY/ s3://BUCKET_NAME/DIRECTORY/ --recursive`
现在，当数据准备好了，我们可以开始探索性数据分析(EDA)。EDA 的主要目标是探索和可视化数据，以发现一些见解，并计划如何开发模型。通常，EDA 是使用 Jupyter notebook 和一些用于数据操作和分析的包来完成的，例如熊猫、 numpy 、 matplotlib 等等。
接下来，我们可以从特征工程开始。出于本教程的考虑，我们将使用 9 个技术指标作为特征(5、10 和 20 小时的移动平均线，7、14 和 21 小时的 RSI 和 MFI)。所有技术指标将使用 TA-Lib 进行计算，它们大多与金融时间序列相关，但一般来说，软件包 tsfresh 是计算时间序列特征的一个好选择。
对于 ML 模型，我们将尝试使用 XGBoost 和 Optuna 来优化超参数。默认情况下，Optuna 使用树形结构的 Parzen 估计器算法，但也有更多的算法可供选择。优化算法将尝试最大化我们策略的累积回报。
Top AWS data engineering services | Source
数据集将分为两部分:
样本内(从 2018-01-01 到 2021-12-31，用于超参数搜索和回测)
样本外(从 2022 年 1 月 1 日到 2022 年 5 月 31 日，用于复查选择策略，以确保我们没有过度拟合模型)
回测将使用固定滑动窗口的时间序列交叉验证来完成，因为我们希望在每次迭代中保持我们的训练集大小相同。
实验跟踪
- 实验跟踪将使用 neptune.ai 对 Optuna 的集成来完成。这是一个非常方便的集成，让您只需几行代码，通过几个图就可以跟踪来自模型训练的所有元数据。
- 在我们的例子中，我们将使用 Neptune-Optuna 集成来记录和监控 XGBoost 模型的 Optuna 超参数调优。通常，与一些卷积神经网络相比，时间序列模型并不大，并且作为输入，具有几百或几千个数值，因此模型训练得相当快。
对于金融时间序列，有一种方便的方法来跟踪模型超参数尤其重要，因为我们需要运行许多不同的实验。这是因为金融中的时间序列往往具有非常混乱的运动，需要大量的调整。
通过使用合适的超参数跟踪工具，我们将能够通过观察优化历史图来识别优化是如何进行的。除了运行时间和硬件消耗日志之外，我们将能够断定我们是否需要增加优化试验(迭代)。
Time series cross validation with sliding window | Source
Neptune-Optuna 集成提供了对超参数重要性、平行坐标图的可视化，显示了不同超参数值和目标函数值之间的关系，以及许多更有用的功能。
为此，首先，我们将在主类中定义“objective”方法:
其中“trial”是 Optuna 中使用的参数，“apply_strategy”准备数据并训练模型，而“get_score”在我们的情况下返回累积回报，作为我们想要优化的度量。之后，我们需要连接 Optuna 和 neptune.ai
更多信息，请遵循这个海王星-Optuna 整合指南。
用于时间序列预测的 MLOps 流水线:自动化测试
在模型开发期间，我们将使用 GitHub 作为源代码管理工具。此外，基于一个项目及其需求，实现一些自动化测试是一个很好的实践。
def objective(self, trial):
params = {
'n_estimators': trial.suggest_int('n_estimators', 350, 1000),
'max_depth': trial.suggest_int('max_depth', 3, 10),
'learning_rate': trial.suggest_uniform('learning_rate', 0.01, 0.10),
'subsample': trial.suggest_uniform('subsample', 0.50, 0.90),
'colsample_bytree': trial.suggest_uniform('colsample_bytree', 0.50, 0.90),
'gamma': trial.suggest_int('gamma', 0, 20),
}
look_back = trial.suggest_int('look_back', 30, 180)
self.apply_strategy(params)
return self.get_score()
作为自动化测试的一个例子，我们将创建一个简单的冒烟测试，使用 GitHub actions 运行整个项目。这是一个简单的自动化测试，检查我们的主要 python 脚本是否可以成功运行。
import optuna
import neptune.new as neptune
import neptune.new.integrations.optuna as optuna_utils
run = neptune.init(
project="enes.zvornicanin/optuna-test",
api_token="YOUR_API_TOKEN",
)
neptune_callback = optuna_utils.NeptuneCallback(run)
hb = HourlyBacktester(dt.data, trader_config)
n_trials = 20
study = optuna.create_study(direction="maximize")
study.optimize(hb.objective, n_trials=n_trials, callbacks=[neptune_callback])
为了测试这个项目，在我们的“main.py”脚本中，除了 main 函数之外，我们还将创建一个名称相同但前缀为“test_”的函数:
这样，如果我们以“pytest main.py”的形式运行“main.py”和 Pytest ，Pytest 将自动运行所有带有“test_”前缀的函数。在“test_main”函数中，我们提供了一个“debug”参数，该参数控制我们是使用真实数据还是仅用于测试的虚拟数据。此外，当“debug=True”时，程序不登录币安帐户，而是创建一个模拟币安客户对象的一个方法的模拟对象:
其中 client.create_order 将在代码的后面使用。
接下来，我们将设置 GitHub，使它在每次推送到存储库后自动在 Ubuntu 虚拟机上运行我们的测试。第一步是在目录“. github/workflows”中创建一个. yml 文件，或者直接在 github 存储库中创建，方法是:
操作->新建工作流->自行设置工作流:
def main():
pt = PaperTrader(config)
pt.execute_trade()
def test_main():
pt = PaperTrader(config, debug=True)
pt.test_execute_trade()
if __name__ == '__main__':
main()
def log_in(self):
if self.debug:
self.client = Mock()
self.client.create_order = lambda symbol, side, type, quantity:{
"executedQty":1,
"cummulativeQuoteQty":np.random.rand()+1
}
return
self.client = Client(api_key = os.environ.get('BINANCE_TESTNET_API'),
api_secret = os.environ.get('BINANCE_TESTNET_SECRET'),
tld = 'com',
testnet = True)
之后，将出现一个新的工作流模板，其中包含一些基本命令:
更新的。为我们的用例创建的 yml 文件在存储库中可用，它看起来像这样:
Setting up workflow | Source: Author
这将使名为“Tests”的 GitHub 操作使用“master”分支在 push 上运行下面的命令。该工作流将在 Ubuntu 机器上运行，前两个步骤在大多数项目中都很常见，与检出存储库和 python 的设置相关。之后，它安装需求和需要特殊安装的包 talib(用于技术指标)。最后，它运行我们的测试。
如果操作成功完成所有步骤，操作选项卡下将出现绿色标志:
New workflow template | Source: Author
用于时间序列预测的 MLOps 管道:部署和连续交付
将使用 GitHub actions 、 Docker 和 AWS ECS 按照 CI/CD 实践进行部署。弹性容器服务(ECS)是一种容器编排服务，可以轻松部署、管理和扩展容器化的应用程序。在我们的例子中，我们将把它用作 CI/CD 服务，它将托管 docker 将在其中运行的 EC2 实例。
The updated .yml file | Source: Author
将使用 AWS 身份和访问管理(IAM) 服务提供对 AWS 服务的访问。此外，在部署之前，我们将在 AWS S3 上接收输入数据。
简而言之，部署步骤如下:
当代码被推送到一个定义的分支时，GitHub 动作激活并启动 CD 进程。首先，操作配置 AWS 凭证，以便访问服务。
Completed action | Source: Author
动作建立 Docker 图像并将其推送到 AWS ECR 上。Elastic Container Registry 是一个容器图像的存储库，其中的图像可以很容易地通过其他 AWS 服务进行推送、访问和分发。
操作在 ECS 服务上部署定义的映像。
ECS 服务将操作一个 EC2 实例，其中将部署一个 Docker 容器。在 Docker 容器中，cron 作业将使用 Miniconda 环境，每小时运行一次我们的主 python 脚本。
输出数据将存储在 AWS S3 上。此外，一些输出结果和元数据将作为监控服务存储在 neptune.ai 上。
-
我和 S3
-
创建 IAM 用户的步骤
-
1.AWS -> IAM ->用户->添加用户
-
2.填写用户名，并在 AWS 访问类型下选择“访问密钥-编程访问”,然后单击权限选项卡旁边的。
3.选择以下策略:
Production set-up | Source: Author
AmazonS3FullAccess
亚马逊 C2FullAccess
amazone C2 containerregistryfull access
AmazonECS_FullAccess
Adding a user | Source: Author
EC 2 instanceprofileforimagebuilderecrcontainerbuilds
- 4.单击“下一步”按钮两次，然后单击“创建用户”。现在，用户凭证将会出现，请确保下载并保存它们，因为您将无法再次看到它们。
- 创建 S3 存储桶的步骤
- 1.转到 AWS ->亚马逊 S3 ->桶->创建桶
- 2.写入存储桶名称，并可选地启用存储桶版本控制。单击 create bucket，它应该已经创建好了。
- 3.现在点击你的桶名，试着从你的电脑上传一个文件。
ECR 和 ECS
Selecting policies | Source: Author
创建 ECR 存储库的步骤
1.转到 AWS ECR ->入门(创建存储库)
Download and save user credentials | Source: Author
2.在可见性设置中，选择私有。
3.定义存储库名称。
4.单击创建存储库。
对于 ECS 服务，我们需要创建:
任务定义(需要在 Amazon ECS 中运行 Docker 容器)
Creating S3 bucket | Source: Author
集群(定义 Docker 将运行的基础设施)
创建 ECS 任务定义的步骤
1.转到 AWS ECS ->任务定义->创建新任务定义
2.为启动类型兼容性选择 EC2。
3.指定任务定义的名称。
4.在容器定义下，单击添加容器按钮。
5.对于容器名称，添加先前定义的 ECR repo 名称。
Creating ECR repository | Source: Author
6.为映像添加 ECR repo URI 链接(可以在 ECR 服务中找到，在存储库名称旁边)。内存限制和端口映射如下图所示。单击添加，然后单击创建按钮。
- 创建 ECS 群集的步骤
1.转到 AWS ECS ->集群->创建集群
2.选择 EC2 Linux +网络，然后单击下一步。
3.定义一个集群名称，选择 EC2 实例类型(t2.micro 符合免费层的条件)并创建一个密钥对(或选择现有的密钥对)。点击创建按钮。
4.创建群集后，单击群集名称，然后在“Services”选项卡下，单击“Create”按钮。
5.选择 EC2 作为启动类型，定义服务名称和任务数(1)。
6.几次单击下一步，然后单击“创建服务”按钮完成。
Creating ECS task definition | Source: Author
Dockerfile
Dockerfile 可以在这个资源库中找到，我们在这里简单解释一下。
对于 Docker 容器，我们将使用 Ubuntu 22.10 映像。我们为 miniconda 设置了环境变量 PATH、python 脚本将使用的环境变量，并为 Ubuntu 安装了一些包。之后，我们下载、安装并创建一个名为“env”的 miniconda python 环境。
命令收到。币安 _ 贸易/`复制我们项目的所有文件到 Docker“币安 _ 贸易”目录。下一组命令与安装 Ta-Lib Python 包有关，我们用它来表示技术指标。之后，我们安装 requirements.txt 文件中的所有其他包。
Creating ECS cluster | Source: Author
接下来的几个命令与在 Docker 中配置 cron 作业的相关。为此，我们需要在存储库中有一个“cron-job”文件，我们将把它复制到 Docker 容器中。容器启动时将被激活的最后一个命令将环境变量重定向到/etc/environment 文件中，以便对 cron 作业可见。此外，它还会激活 cron 作业。
Cron 作业文件是在我们的存储库中定义的，它应该每小时运行一次我们的主脚本。
Creating ECS cluster | Source: Author
GitHub 操作
接下来，我们将解释如何将我们的项目作为持续部署(CD)工作流的一部分部署到 ECS。为此，我们将使用 GitHub 动作。定义这个过程的 Yaml 文件可以在资源库中找到，在这里我们将一步一步地解释它。
我们将遵循 GitHub 文档中可用的框架。该操作将在推送到主分支时被激活。
1.首先，我们定义一些稍后将会用到的环境变量。其中一些如存储库、服务、集群和容器名称是在前面的步骤中定义的。AWS 区域与 AWS 配置文件相关。
2.ECS 任务定义可以存储为。json 文件，位于 ECS ->任务定义->您的定义名称-> JSON 选项卡下
Dockerfile | Source: Author
-
之后，在 yaml 文件中，我们定义了将在最新的 Ubuntu 操作系统上运行的步骤，第一步是检查存储库。
-
4.接下来，我们需要配置 AWS 凭证。我们在 IAM 用户下创建了它们。此外，它们将被存储为动作秘密，我们可以在 GitHub 存储库中定义它们，位于:设置选项卡->秘密->动作->新存储库秘密
-
所有机密都可以使用$ { { secrets }访问。变量名称}}符号。
-
5.登录 Amazon ECR 后，我们构建 Docker 映像并将其推送到 ECR 存储库。这里我们从秘密中定义局部环境变量。其中一些在构建命令期间作为构建参数被处理到 Docker 容器中。这样，我们的 python 脚本就能够使用方法访问它们。
6.最后，我们在任务定义中填充一个新的映像 ID，并将其部署在 ECS 上。
现在，如果我们在我们的存储库中推送更改，GitHub actions 将启动这个过程。下面是一个成功运行的例子:
用于时间序列预测的 MLOps 管道:监控
我们可以使用 neptune.ai 轻松获得相同的功能，而不是建立一个 Flask 或 Fast API web 服务器来显示我们的结果、元数据和图表。这个想法是在每次脚本运行后，即每次交易后，我们在 neptune.ai 项目上上传带有图表的结果。通过几行代码和两分钟的工作，我们将能够存储和跟踪我们的 Matplotlib 图表和。neptune.ai 项目中的 csv 结果文件。
Defining environment variables | Source: Author
要开始监控性能指标，请运行以下代码:
ECS task definition | Source: Author
- 定义 matplotlib 图:
Checking repository | Source: Author
并将其作为静态或交互式图像上传到项目中:
为了上传包含结果的 pandas 数据框，请再添加一行代码:
在这种情况下，这将自动记录元数据和结果的过程。同时，您还可以根据定义的指标，在不同的实验运行之间进行比较，如下一个屏幕截图所示。
import os
aws_access_key_id = os.environ.get('AWS_ACCESS_KEY_ID')
Building and pushing the Docker image to the ECR repository | Source: Author
除了简单地跟踪我们的结果以便向我们的同事和客户展示之外，为 ML 项目建立监控系统还有更多好处:
Successful run | Source: Author
例如，模型陈旧是金融时间序列中的常见问题。虽然在这个项目中，模型再训练的逻辑是在代码中实现的，并且在模型开始表现不佳时会被触发，但是直接监控模型的陈旧性可能是有用的。
类似地，数据漂移可以是监控的对象，可以创建仪表板，显示每个模型预测的实时生产数据的统计数据。
除了 Neptune 之外，还有一些更专用于 ML 监控的工具。例如， Arize AI 通过帮助理解机器学习模型在现实世界中部署时的行为方式，使 ML 从业者能够更好地检测和诊断模型问题。
import neptune.new as neptune
run = neptune.init(
project=os.environ.get('NEPTUNE_PROJECT'),
api_token=os.environ.get('NEPTUNE_API_TOKEN'),
)
类似地， WhyLabs 是一个模型监控工具，帮助 ML 团队监控数据管道和 ML 应用程序。更多关于 ML 监控工具的信息可以在本文中找到:做 ML 模型监控的最佳工具。
fig = plt.figure(figsize =(4, 4))
结论
run["static-img"].upload(neptune.types.File.as_image(fig))
run["interactive-img"].upload(neptune.types.File.as_html(fig))
在本教程中，我们介绍了一个简单的端到端 ML 时间序列项目，遵循 MLOps 实践。
run['data/results'].upload(neptune.types.File.as_html(df_results))
我们的项目位于 github 库上，定义了在代码推送时触发的冒烟测试。这是 CI 实践的一个简单例子。除此之外， CD 功能是通过 GitHub actions、Docker 和 AWS 服务实现的。 CM 示例是使用 neptune.ai 简单提供的，而 CT 逻辑集成在 python 代码本身中，如果最后 N 次运行的结果低于 T 阈值，模型将被重新训练和优化。
关于这个项目的任何其他问题，请随时联系我。
参考
-
For instance, model staleness is a common issue in financial time series. Although in this project, the logic for model retraining is implemented in the code and will be triggered if the model starts to perform badly, it might be useful to monitor model staleness directly.
-
Similarly, data drift can be a subject for monitoring, where it’s possible to create dashboards that will show some statistics about real-time production data at every model prediction.
Besides Neptune, there are a few more tools that are more specialized for ML monitoring. For example, Arize AI enables ML practitioners to better detect and diagnose model issues by helping understand why a machine learning model behaves the way it does when deployed in the real world.
Similarly, WhyLabs is a model monitoring tool that helps ML teams with monitoring data pipelines and ML applications. More about ML monitoring tools can be found in this article: Best Tools to Do ML Model Monitoring.
Conclusion
In this tutorial, we’ve presented a simple end-to-end ML time series project following MLOps practices.
Our project is located on the github repository with defined smoke tests which are triggered on code push. That is a simple example of CI practices. In addition to that, CD functionality is implemented with GitHub actions, Docker, and AWS service. CM example is simply provided using neptune.ai and CT logic is integrated in the python code itself, where the model will be retrained and optimized if the results of the last N runs are below the T threshold.
For any additional questions regarding this project, feel free to reach out to me on Linkedin.
References
MLOps 原则及其实施方法
原文：https://web.archive.org/web/https://neptune.ai/blog/mlops-principles
在过去几年中，机器学习操作是一个越来越受关注的话题。随着公司在看到在其产品中使用 ML 应用程序的潜在好处后，不断投资于人工智能和机器学习，机器学习解决方案的数量正在增长。
此外，许多已经开始的项目，例如，半年或一年前，最终准备用于大规模生产。对于大多数项目和开发者来说，这意味着一个完全不同的世界、问题和挑战。
让一个 ML 项目生产准备就绪不再仅仅是模型做好它的工作和满足业务指标。这仍然是关键目标之一，但还有其他重要问题:
-
模型能在一定时间内处理和响应请求吗？
-
2 如果输入数据的分布随时间变化，它会如何表现？
-
在你的项目中，你如何安全地测试一个全新版本的模型？
在某些时候，每个机器学习项目都会遇到这些问题，回答这些问题需要一套不同于研究阶段的技能和概念，无论是在哪个领域，无论是预测客户的行为或销售，检测或计算图像中的对象，还是复杂的文本分析。底线是，这些项目中的每一个都意味着产品化和维护，以便在某一点上，它开始得到回报，因此必然会遇到前面提到的打嗝。
Explanation of mlops | Source: Author
数据科学项目的研究部分已经得到了很好的探索，即有一些标准的库、工具和概念(想想 Jupyter、pandas、实验跟踪工具等。).然而，与此同时，工程或“生产”部分对许多 ML 从业者来说仍然是一个谜——有许多灰色地带和不明确的标准，并且在很长一段时间内，没有一个设计良好、易于维护的 ML 项目的黄金路径。
这正是 MLOps(机器学习操作)应该解决的问题。在这篇文章中，我将解释:
- 它是关于什么的，
- MLOps 的原则是什么，
- 以及如何在您当前或未来的项目中实现它们。
MLOps 的原则:强大的 MLOps 战略的核心要素
现在，我们对 MLOps 及其在机器学习项目中的一般作用有了基本的了解，让我们更深入地了解哪些关键概念/技术将有助于您在现有或未来的项目中实施 MLOps 最佳实践。
我将介绍 ML 运营的几个“支柱”，并向您解释:
- 为什么这些对于使您的解决方案更加健壮和成熟非常重要
- 如何用可用的工具和服务实现它们
让我们更深入地了解细节，看看 MLOps 的关键原则是什么。
The key principles of MLOps | Source: Author
1.MLOps 原则:再现性和版本控制
一个成熟的机器学习项目的核心特征之一是能够重现结果。人们通常不会太关注这一点，尤其是在项目的早期阶段，他们主要是用数据、模型和各种参数进行实验。这通常是有益的，因为它可以让您找到(即使是偶然地)某个参数和数据分割率的一个好值。
然而，一个可能帮助您的项目变得更容易维护的良好实践是确保这些实验的可重复性。找到一个非常好的学习率是一个好消息。但是，如果你用相同的值再次进行实验，你会得到相同(或足够接近)的结果吗？
在某种程度上，你的实验的非确定性运行可能会给你带来一些运气，但是当你在一个团队中工作时，人们希望继续你的工作，他们可能会期望得到和你一样的结果。
在这种情况下，还有一件更重要的事情——为了让您的团队成员重现您的实验，他们还需要使用相同的配置(参数)执行完全相同的代码。你能向他们保证吗？
代码一天要修改几十次，您不仅可以修改参数的数值，还可以修改整个逻辑。为了保证项目的可再现性，您应该能够对您使用的代码进行版本控制。无论您使用的是 Jupyter Notebook 还是 Python 脚本，使用 git 这样的版本控制系统来跟踪变更应该是一件很容易的事情，这是您不能忘记的事情。
Reproducibility and Versioning | Source: Author
还有什么可以被版本化以使你在项目中的工作可重复？
- 基本上，代码 EDA 代码、数据处理(转换)、培训等。
- 您的代码使用的配置文件，
- 基础设施！
让我们在最后一点暂停一下——基础设施也可以而且应该进行版本控制。
但什么是“基础设施”？基本上，任何种类的服务、资源和配置都托管在像 AWS 或 GCP 这样的云平台上。无论是简单的存储或数据库、一组 IAM 策略，还是更复杂的组件管道，当您需要在另一个 AWS 帐户上复制整个架构，或者需要从头开始时，对这些进行版本控制可以节省您大量的时间。
如何实现可再现性和版本控制原则？
至于代码本身，您应该使用 git 之类的版本控制(您可能已经这样做了)来提交和跟踪更改。根据同样的概念，您可以存储配置文件、小型测试数据或文档文件。
请记住，git 不是对大文件(如图像数据集)或 Jupyter 笔记本进行版本控制的最佳方式(这里，这与大小无关，而是比较特定版本可能会很麻烦)。
为了对数据和其他工件进行版本化，你可以使用类似于 DVC 或者海王星的工具，这将使得存储和跟踪与你的项目或者模型相关的任何类型的数据或者元数据变得更加容易。至于笔记本——虽然将它们存储在 git 存储库中并不是一件坏事，但是你可能想要使用像 ReviewNB 这样的工具来使比较和审查变得更加容易。
Versioning artifacts with Neptune | Source
版本化基础设施是一个普遍的问题(这整个概念被称为代码为的基础设施)，通过众所周知的解决方案解决，如 Terraform 、 Pulumi 或 AWS CDK 。
2.MLOps 原则:监控
人们通常认为“监控”是顶部的樱桃，是 MLOps 或机器学习系统的最后一步。事实上，恰恰相反—监控应该尽快实现，甚至在您的模型被部署到产品中之前。
需要仔细观察的不仅仅是推理部署。你应该能够可视化和跟踪每一个训练实验。在每个培训课程中，您可以跟踪:
- 训练指标的历史，如准确性、F1、训练和验证损失等。,
- 训练期间脚本使用的 CPU 或 GPU、RAM 或磁盘的利用率，
- 在训练阶段之后产生的对维持集的预测，
- 模型的初始和最终权重，
以及与您的用例相关的任何其他指标。
现在，从训练转移到推理，这里也有很多东西需要监控。我们可以将这些分为两组:
-
部署服务本身的服务级监控(Flask web Service，托管在 Kubernetes 上的微服务， AWS Lambda 等。);了解处理来自用户的单个请求需要多长时间，平均负载大小是多少，您的服务使用了多少资源(CPU/GPU、RAM)等等，这一点很重要。
-
模型级监控，即模型返回的预测以及模型收到的输入数据。前者可用于分析一段时间内的目标值分布，后者可以告诉您输入的分布，输入也可以随时间而变化，例如，财务模型可以将工资视为输入特征之一，其分布可以随时间的推移而改变，因为工资较高-这可能表明您的模型已经过时，需要重新培训。
Training and inference as a part of monitoring | Source: Author
如何实施监测原则？
至于培训，你可以使用大量的实验跟踪工具，例如:
它们中的大部分可以很容易地集成到您的代码中(可以通过 pip 安装),并允许您在训练/数据处理期间实时记录和可视化指标。
Monitoring experiments with Neptune | Source
关于推理/模型部署——这取决于您使用的服务或工具。如果是 AWS Lambda，它已经支持发送给 AWS CloudWatch 服务的相当广泛的日志记录。另一方面，如果你想在 Kubernetes 上部署你的模型，可能最流行的栈是用于导出指标的 Prometheus 和用于创建你的定制仪表板和实时可视化指标和数据的 Grafana 。
3.MLOps 原则:测试
在机器学习团队中，很少有人提到“测试”、“编写测试”等。在传统的软件工程项目中，编写单元、集成或端到端测试更加常见(或者已经成为一种标准，希望如此)。那么 ML 中的测试是什么样子的呢？
有几件事您可能希望始终保持验证状态:
-
1 输入数据的数量和质量，
-
2 输入数据的特征模式(预期值范围等。)，
-
3 你的加工(转换)作业产生的数据，以及作业本身，
-
4 您的功能和数据管道的合规性(如 GDPR)。
它将使你的机器学习管道更加健壮和有弹性。有了这样的测试，您就可以在数据或基础架构出现意外变化时立即检测出来，从而有更多的时间做出相应的反应。
如何实施测试原则？
让我再把它分成几个主题:
-
对于数据验证，你可以使用开源框架，比如远大前程或者深度检查。当然，根据您的用例以及使用外部工具的意愿，您也可以自己实现基本的检查。一个最简单的想法是从训练数据中计算统计数据，并使用这些数据作为其他数据集(如生产中的测试数据)的预期。
-
在任何种类的管道中，都可以测试转换，甚至是最简单的脚本，通常与测试典型软件代码的方式相同。相信我，如果您使用一个处理/ETL 作业来定期转换新的输入数据，那么在将数据进一步推送到训练脚本之前，您会希望确保它能够工作并产生有效的结果。
-
特别是当涉及到工程或基础设施时，您应该总是倾向于将基础设施作为设置任何云资源的代码范例，我已经在关于可再现性的一节中提到了这一点。尽管还不常见，基础设施代码也可以进行单元测试。
-
关于符合性测试，应该针对每个项目和公司具体地仔细实施。您可以在这里阅读更多关于模型治理的有用测试和过程。
4.MLOps 原则:自动化
最后但同样重要的是，MLOps 的一个重要方面。它实际上与我们到目前为止讨论的所有内容都有关系——版本控制、监控、测试等等。自动化的重要性已经在ml-ops.org得到了很好的描述(必读):
数据、ML 模型和代码管道的自动化水平决定了 ML 过程的成熟度。随着成熟度的提高，新模型的训练速度也在提高。MLOps 团队的目标是将 ML 模型自动部署到核心软件系统中或作为服务组件。这意味着自动化完整的 ML 工作流步骤，无需任何手动干预。
如何以及在多大程度上自动化你的项目是 MLOps 工程师的关键问题之一。在理想的情况下(有无尽的时间，明确的目标，无限多的工程师等等。)，您几乎可以自动化管道中的每一个步骤。
An example of an automated ML pipeline | Source
想象以下工作流程:
- 新数据到达原始数据存储器，
- 然后清理、处理数据，并创建特征，
- 数据也得到测试的功能模式，GDPR；在计算机视觉项目中，它还可以包括特定的检查，例如图像质量，或者可能涉及面部模糊，
- 如果适用，已处理的特征被保存到特征存储中以备将来重用，
- 一旦数据准备就绪，您的训练脚本就会自动触发，
- 所有的培训历史和指标都会被自然地跟踪和可视化，
- 模型已经准备好了，并且证明非常有前景，这也是自动评估的，并且以相同的自动方式触发部署脚本，
- …
我可以继续进行故障处理、警报、自动化数据标记、检测模型中的性能衰减(或数据漂移)以及触发自动模型再训练。
关键是，它描述了一个几乎理想的系统，不需要人为干预。如果它必须适用于一个以上的模型/用例，那么它将花费大量的时间来实现。那么如何以正确的方式去做呢？
如何实现自动化原则？
首先，没有配方，也没有自动化的适量。我的意思是，这取决于你的团队和项目目标以及团队结构。
然而，有一些指导方针或示例体系结构可能会给你一些意义和问题的答案，“我实际上应该自动化多少？”。最常被引用的资源之一是 Google 的 MLOps Levels。
假设您已经知道您将自动化系统的哪些部分(例如，数据摄取和处理)。但是你应该使用什么样的工具呢？
这一部分可能是目前最模糊的，因为 MLOps 系统中的每个组件都有几十个工具。你必须评估和选择什么是适合你的，但是有像州 MLOps 或 MLOps 社区这样的地方会告诉你什么是最受欢迎的选择。
Airbnb 的真实例子
现在让我们讨论 Airbnb 如何简化复杂的 ML 工作流程并设法将过多的不同项目纳入一个系统的例子。创建 Bighead 是为了确保模型的无缝开发及其全面管理。
Airbnb’s End-to-End ML Platform | Source
让我们看一下每个组件的解释，并了解它与原则的关系:
ML 数据管理框架
Zipline 是一个用于定义、管理和共享功能的框架。它符合大多数条件——存储可以共享的功能定义(可能与其他项目共享),让 Airbnb 拥有了再现性和版本化(数据集和功能)的能力。不仅如此，正如作者所说，该框架还有助于实现更好的数据质量检查(测试原则)和监控ML 数据管道。
Redspot(托管 Jupyter 笔记本服务)
图表中的下一个组件是 Redspot，它是一种“托管的、容器化的、多租户 Jupyter 笔记本服务”。作者说，每个用户的环境都以 Docker 映像/容器的形式存在。
这使得其他开发者在其他机器上复制他们的代码和实验变得更加容易。同时，这些用户环境可以在内部容器注册中心自然地版本化。
大头图书馆
再一次，关于再现性的附加点。Bighead Library 再次专注于存储和共享特性和元数据，这就像使用 Zipline 更容易一样，是解决版本控制和测试 ML 数据的好办法。
沉思
Deep think 是一个共享的 REST API 服务，用于在线推理。它支持 ML 管道中集成的所有框架。部署完全由配置驱动，因此数据科学家不必让工程师参与推出新模型。然后，工程师可以连接到其他服务的 REST API 来获得分数。此外，还支持从 K/V 存储中加载数据。它还为模型性能的监控和离线分析提供了标准化的日志记录、警报和仪表板。
Airbnb 平台的最后一个组件专注于另外两个原则:自动化(尽管根据图表，自动化可能也已经融入了之前的组件)和监控，通过提供“标准化的日志记录、警报和仪表板以监控(……)模型性能。
deep think 部署是“完全配置驱动的”,这意味着大多数技术细节对用户是隐藏的，并且很可能是自动化的。数据科学家用来部署新模型的这些配置文件的正确版本控制将允许其他开发者在另一个账户或另一个项目中复制部署
所有这些组件共同实现了一个运转良好的 MLOps 机器，并构建了一个流畅的工作流程，这是 Airbnb ML 功能不可或缺的一部分。
摘要
读完这篇文章后，你有希望知道这些原则(版本控制、监控、测试和自动化)是如何协同工作的，以及为什么它们对机器学习平台很重要。
如果你对这个话题更感兴趣，并且想阅读其他涉及这些原则的真实世界的 ML 平台，有许多由像【优步】、 Instacart 和 others(网飞、Spotify) 这样的公司写的例子和博客文章，在这些文章中，他们解释了他们的内部 ML 系统是如何构建的。
在其中一些文章中，您可能找不到任何关于“mlops 支柱”的明确信息，而是关于在该平台中使用或实现的特定组件和工具。您很可能会看到“特性库”或“模型注册”，而不是“版本控制和再现性”。类似地，“工作流程编排”或“ML 管道”为平台带来了“自动化”。记住这一点，好好读一读！
MLOps 问题和最佳实践
原文：https://web.archive.org/web/https://neptune.ai/blog/mlops-problems-and-best-practices
你、我、我们所有人在网上度过的每一分钟都会产生大量的数据。对于商业和科学来说，这是一个不容忽视的机会。随着越来越多的组织采用这些技术，对人工智能和机器学习的宣传不断升温。
用户生成的数据量呈指数级增长。传统的内部部署服务器转变为灵活、可扩展的云。任何产生大量数据的组织都希望利用这些数据，从数据中提取有价值的见解来指导业务决策。
随着数据的增长，我们可以看到许多与数据相关的工作机会。数据科学家、数据分析师、数据工程师、机器学习工程师、人工智能工程师、深度学习工程师，不胜枚举。
最近，业界对一个新角色有很多讨论，这个新角色就是m lops 工程师 。这项工作位于机器学习、DevOps 和数据工程的交叉点。
在我们为普通 MLOps 工程师的问题定义解决方案之前，让我们看看这种专业化如何适应承担不同责任的各种数据科学角色。
MLOps 工程师的角色和职责
如果你是一个有抱负的专业人士，准备接受一个 MLOps 工程师的角色，下面是你做这份工作需要的东西，以及它看起来会是什么样子(粗略地说)。
MLOps 工程师技能和资格
注意:这些要求相当宽泛，可能不代表任何工作描述。与 MLOps 相关的工作可能来自广泛的行业，并且可能包含这些要求的子集。
- 具有高度分析学科的学位(学士、硕士或博士)，如统计学、经济学、计算机科学、数学、运筹学等，具有深厚的定量/编程背景。
- 在端到端管理机器学习项目方面总共有 3-6 年的经验，过去 18 个月专注于 MLOps。
- 使用自动化监控和警报工具监控构建和生产系统。
- 具有使用 MLOps 工具的经验，如 ModelDB、Kubeflow、Pachyderm 和数据版本控制(DVC)。
- 在支持基于 IDE 的模型和 autoML 工具的模型构建和模型部署、实验跟踪、模型管理、版本跟踪&模型培训(Dataiku、Datarobot、Kubeflow、Kubeflow tfx、MLflow)、模型超参数优化、模型评估和可解释性(SHAP、Tensorboard)方面具有丰富的经验。
- 机器学习框架知识:TensorFlow，PyTorch，Keras，Scikit-Learn。
这些技能让你成为不可抗拒的 MLOps 候选人
- 集装箱技术经验(Docker，Kubernetes，EKS，ECS)。
- 拥有与多家云提供商合作的经验(AWS、GCP、Azure 等)。
- 分布式计算经验。
MLOps 工程师工作职责
- 部署和实施 MLOps，特别是实施:
- 模型超参数优化
- 模型评估和可解释性
- 模型训练和自动化再训练
- 从入职、运营到退役的工作流建模
- 模型版本跟踪和治理
- 数据存档和版本管理
- 模型和漂移监控
- 创建和使用基准、指标和监控来衡量和改进服务。
- 提供最佳实践，执行 POC 以大规模实现自动化和高效的模型操作。
- 设计和开发可扩展的 MLOps 框架，以支持基于客户需求的模型。
- 作为销售团队的 MLOps 专家，提供技术设计解决方案以支持 RFP。
MLOps 工程师从项目一开始就与数据科学团队中的数据科学家和数据工程师密切合作。
让我们继续机器学习项目生命周期。它有几个阶段，我们将看到 MLOps 工程师是否以及如何参与其中。
机器学习项目生命周期
没有一个所有公司都遵循的标准项目生命周期。ML 发展迅速，最佳实践也日新月异。
但还是有一个共同的模式。让我们来看一个简化的 ML 项目生命周期来更好地理解 MLOps。
你可以在上图中看到一个机器学习项目的基本部分和职责。我们来分析一下其中的每一部分。
1.机器学习
我们简化项目生命周期的第一部分是机器学习。这个阶段有三个部分:
- 数据采集
- 商业理解
- 初始建模
数据采集
数据是整个生命周期最重要的东西。在我们可以在项目中做任何事情之前，我们需要收集必要的数据并存储它。
责任
数据工程师是项目这一阶段的主要参与者。他们创建管道来收集来自不同来源的数据，检查数据的一致性和正确性，将其存储在存储库中，等等。
数据采集问题
- 数据通常不完整–确保收集所有必要的数据。
- 格式问题–如果数据以一种格式出现，您可能会在数据格式转换过程中丢失数据
- 数据清理技术–当数据工程师用最少的知识清理或执行 ETL 转换时，丢失有价值数据的风险很高。
- 数据接收频率–根据数据迭代创建一个管道，否则你可能会丢失数据。
最佳实践
- 了解数据的 5 V(容量、速度、多样性、准确性、价值)。
- 维护失败管道和数据收集的通知。
- 维护元数据。
- 在不同的地理位置维护备份。
- 了解谁负责数据清理和 ETL 操作。
商业理解
一旦我们收集了数据并将其转换到我们的存储库中，我们需要了解企业想要用这些数据做什么。几乎所有的数据科学团队成员都将参与这一阶段，因为每个人都应该知道我们在做什么。经理和其他项目涉众将告诉我们他们需要从数据中得到什么。
责任
在这个阶段，每个人都需要理解业务目标并定义一个行动计划。每个团队领导将被分配一部分工作和交付时间表。
商业理解问题
- 缺乏明确性–团队领导经常不清楚可交付成果的时间表，这会导致不必要的压力和匆忙
- 更少的讨论时间–讨论通常很匆忙，许多人容易误解他们正在做的工作
最佳实践
- 了解你的工作，毫不犹豫地表达你的想法。
- 不要对你的时间表犹豫不决。
- 确保每个人都理解路线图。
- 确保在路线图中包含模型的迭代测试。
初始建模
这是“初始”建模，因为在我们生命周期的开发阶段还有另一个建模步骤。这个阶段是最耗时的。数据科学项目的大部分时间都将花费在这里。
初始建模有三个部分:
- 数据准备
- 特征工程
- 模型训练和模型选择
这是整个生命周期中最关键的一步，人们在这里会犯很多错误。让我们看看那些错误是什么。
检查实验跟踪如何帮助你组织这部分过程，避免错误。
数据准备
新手在数据获取和数据准备之间有很多困惑。大三学生倾向于混淆这两个阶段。在数据获取中，我们引入了业务需要的所有数据(模型、仪表板以及两者之间的任何东西都可能需要这些数据)。在数据准备中，我们专注于可以解决业务问题的数据，并准备好被我们的 ML 模型吸收。
责任
在数据准备中，我们获取所有数据并对其进行清理。比方说，我们的业务问题是流失。在这种情况下，我们希望获得所有可以帮助我们分析客户流失原因的数据。一旦我们得到数据，我们就检查异常值、空值、缺失值、类不平衡、删除不需要的列，并根据数据进行其他数据检查。
数据准备问题
- 没有收集所有必要的数据—这是由于数据工程师的集成问题，我们最终得到的数据不完整。
- 不理解数据，或根据标准数据准备实践删除列—这很常见，许多人往往会忘记 EDA(探索性数据分析),并根据标准实践删除列，从而在此过程中删除有价值的信息。
- 时间表–由于严格的截止日期，专业人员可能不会验证他们的数据准备，这可能会导致后续步骤出现问题。
- 误解商业问题——当你的目标错了，你最终会遇到问题。
最佳实践
- 确保您拥有解决业务问题所需的所有数据。
- 不要只是按照标准代码来清理你的数据。
- 在删除任何不需要的列之前，进行 EDA(探索性数据分析)。
- 检查空值或缺失值是否有任何模式。
- 花时间为建模准备数据，这样就不会再回到这一步。
特征工程
特征工程是机器学习管道中最重要的部分之一，因为它优化了事物的数据方面，所以我们得到了数据的水果部分，这必将在我们的策划模型上表现良好。为此，我们分析数据中的每个特征/属性，并选择能够解释目标变量中大部分差异的子集/超集。
责任
这里的职责取决于我们正在处理的数据类型和业务问题本身。任务的几个例子可以是 one-hot 编码分类数据、标准化、应用对数和其他数学函数、分组一些列以使它们更容易学习和缩放。
特征工程问题
- 太多的功能–一些专业人士不理解他们的数据，并按照标准做法创建更多的功能，这些功能将来会被删除，因为他们很少在培训中做出贡献。
- 没有足够的特征–这是一个棘手的问题，记住这里应该遵循偏差-方差权衡。功能数量不能多也不能少，但需要权衡。
- 无法识别业务问题/用例 —在进入特性工程之前，识别业务用例以及与之相关的术语/特性是很重要的。
例如，在贷款预测问题的情况下，您可以创建一个称为“固定债务收入比”或 FOIR 的东西，可以使用 EMI/生活成本进行计算。这是贷方确定申请人贷款资格时最常用的参数，反过来也可以证明是数据集的一个精心设计的指标。
最佳实践
- 尝试基于您的数据和您正在解决的业务问题选择的多种特征工程方法。
- 确保不要创建不必要的特征。
- 特征工程是一件不可能一蹴而就的事情，它需要不断地用数据和模型差异进行反复试验。
模型训练和模型选择
模型训练和模型选择是一个过程，在这个过程中，基于业务问题，我们选择几个具有不同参数的模型，并用我们干净的和特征工程的数据训练它们。根据验证指标和其他结果，我们将为后续阶段选择一个模型。
责任
在这个阶段，我们需要尝试很多模型。多少？这取决于我们面临的问题的类型。我们倾向于测试监督学习的更多模型，无论是分类回归，还是非监督学习(聚类)的更少模型。我们试图用我们的训练数据来拟合所有入围的模型，并根据评估指标来决定最佳模型。
模型训练和选择问题
- 考虑较少的模型–无论是截止日期还是有限的资源，有时我们考虑的模型不够多。
- 虚假模型选择–我们倾向于根据一些评估指标来选择模型，准确率高达 99%的模型可能不是最符合我们数据的。
- 过于频繁地引入深度学习模型–由于围绕深度学习的大肆宣传，我们倾向于添加它们，这可能会影响模型的可解释性。我们需要了解何时添加深度学习模型。
最佳实践
- 确保你已经尝试了所有可能的模式。
- 在选择最终模型的过程中，尝试添加更多的验证技术。
- 不要只使用一个评估指标，检查所有可用的指标，然后再做决定。
2.发展
我们项目生命周期的下一部分是开发。我们已经在机器学习中开发了一个 POC 模型，现在，我们进一步开发该模型，并将其推向生产。三的规则在这篇文章中很强，所以我们又有三个部分:
- 超参数调谐
- CI/CD(持续集成和持续发展)
- 真实世界测试
超参数调谐
既然我们已经训练和验证了我们的模型，为什么我们还需要这个阶段？模型训练有助于我们理解描述数据的最佳特征，但是我们在超参数调整期间使用超参数来获得所选模型的最佳拟合。
责任
在机器学习部分的建模阶段之后，我们经常最终无法选择一个 ML 模型。因此，我们从该阶段中选择他们表现最好的模型，并决定在该阶段进一步选择哪一个。我们使用不同的超参数调整技术，这可能会导致各种问题。
超参数调谐问题
- 默认参数–当专业人士表现良好时，他们倾向于坚持默认的模型参数，他们可能会错过最佳拟合，这使他们最终回到这个阶段。
- 过度调整–不要过度调整你的模型。使用交叉验证、回溯测试和正则化来避免它。
- 手动超参数调整–专业人士倾向于选择手动调整，而不是遵循标准做法，这可能会增加时间，并减少他们使用自动化方法可以实现的不同结果集。
最佳实践
- 千万不要使用默认的模型超参数集。
- 确保不要为了寻找最佳拟合而过度拟合模型。
- 保持超参数之间的权衡，不要太低，也不要太高。
- 使用标准调优技术(网格搜索、随机搜索)，不要手动操作。
持续集成和持续部署(CI/CD)
您可能经常从 DevOps 工程师那里听到这种说法。CI/CD 是一组自动化集成和部署的实践。假设我们已经完成了我们的 ML 模型开发，并且在版本控制库中拥有了我们的全部代码。当我们在一个团队中工作时，许多人在代码的不同部分工作，所以我们需要以某种方式集成所有的更改，并在我们的所有环境(开发、测试、生产)中部署最新的代码。这就是 CI/CD 的用武之地。
责任
这是 MLOps 工程师工作最多的阶段。有许多版本控制存储库和部署实例。我们不要挑毛病，把责任一概而论。在这个阶段，我们需要为持续集成创建一个管道来部署一个 ML 模型。这个管道从数据准备开始，一直到模型部署。数据工程师和数据科学家都会用到它。
例如，数据工程团队获得了添加数据清理技术的新需求，但是我们目前处于模型培训阶段。数据工程团队可以在管道中更新他们的代码，如果我们有一个 CI 管道，新的变化将会自动反映出来。
管道的下一阶段是持续部署。每当我们的版本控制代码库中有变化时，这有助于创建构建并将它们部署到我们所有的环境中。
CI/CD 问题
- 缺乏沟通–每当团队成员开发他们的代码并与存储库集成时，如果他们遇到困难，他们需要与 MLOps 工程师沟通。
- 不必要的代码块–每个团队成员都应该知道 CI/CD 的流程，并确保添加所需的代码部分。这减少了自动化时间。
- 不必要的运行——虽然有很多方法可以回滚到之前的代码，但这是这个阶段最常见的错误。
最佳实践
- 确保在管道中包含通知。
- 确保在管道中包含正确的代码。
- 确保您添加了授权和身份验证。
- 尝试对每个管道进行注释，以便每个团队成员可以检查哪个管道做什么。
真实世界测试
一旦 CI/CD 管道按预期设置并运行，我们需要在部署的 ML 模型中测试真实世界的数据。
责任
在这个阶段，我们用定期(每小时、每天、每周、每月)的新数据测试我们的 ML 模型，并随着时间的推移检查模型的正确性。
真实世界的测试问题
- 避免这一阶段将导致麻烦–这一阶段告诉我们模型在真实数据和训练数据上是否像预期的那样运行。如果不是这样，我们需要回到导致这种情况的阶段。避免这一阶段可能会导致意外的停机和错误，从而影响用户体验。
最佳实践
- 不要回避用真实世界的数据进行测试。
- 重复测试不仅有助于增强软件基础设施，还有助于提升整体用户体验和产品的整体性能。
3.操作
这是我们项目生命周期的最后一部分。一旦模型被训练、测试和部署，这个循环就不会结束。我们需要确保部署的模型能够长期工作，并监控是否会遇到任何问题。运营有三个部分:
- 连续交货
- 数据反馈回路
- 监视
连续交货
许多项目在项目的 DevOps 部分包括这个阶段以及 CI/CD 阶段。即使我们的数据或业务需求有微小的变化，持续交付也能保持我们的产出按时交付。这有助于我们在几个阶段提供我们的整体产品，这些阶段被称为软件发布。
责任
基于公司的业务问题和工作文化，对软件发布进行规划。利益相关者指定他们对每个版本的需求和要求，基于此，整个数据科学团队需要详细的计划来交付它们。
连续交货问题
- 混淆–团队成员经常混淆来自不同版本的需求
- 时间表–不要以牺牲效率为代价屈服于最后期限。
最佳实践
- 确保您了解每个版本的全部需求，并据此制定计划。
- 确保所有团队成员意见一致。
数据反馈回路
数据反馈循环通过发回错误预测的数据来帮助模型从错误中学习。如果没有数据反馈环，ML 模型往往会随着时间的推移而失去其指标，因为它不能适应数据的变化。
责任
这一阶段的职责取决于我们处理的数据类型和我们试图解决的业务问题。让我们假设我们已经开发并部署了一个基于历史数据预测股票价格的 ML 模型。该模型运行良好，开始预测时误差较小。最终，它试图只根据部署前训练的历史数据进行预测，而不是根据部署后的数据。
为了使我们的模型适应一段时间内更新的股票表现，我们需要创建一个数据反馈循环，将我们的模型预测错误的数据(我们可以为其指定一个阈值)发送回模型进行训练。这条管道可以根据我们正在处理的数据及时运行。
数据反馈回路问题
- 忽略数据反馈循环–许多团队倾向于忽略这个阶段，这使得他们的模型随着时间变得越来越差。
- 反馈时间–如果我们更频繁地发送不正确的数据，模型会试图对数据进行过度拟合。
最佳实践
- 了解模型无法预测的原因，并找出原因。
- 确保你的反馈循环管道有时间触发器。
监视
监控在软件开发中与在数据科学中一样重要。一旦我们的模型部署好了，反馈回路到位了，我们就不能休息了。我们需要不断地监控模型，让用户满意。例如，模型可能被部署并准确预测，但是我们不能向我们的最终消费者展示这一点，因为我们有一个坏的网关。这是监控重要性的典型例子。
最佳实践
- 确保输入的数据是正确的。
- 持续的健康检查。
- 确保数据库和存储库都完好无损并且功能正常。
- 为我们的模型获取实时功能，如单独的仪表板。
- 永远不要完全依赖单一指标。
- 使用 Neptune 之类的自动化模型监控。Neptune 是 MLOps 的一个元数据存储库，为运行大量实验的研究和生产团队而构建。
结论
如果你做到了这一步，感谢你的阅读！如你所见，MLOps 工程师是一个非常有趣的角色。
我所分享的工作流程和经验来自我自己的经历，对于其他团队和公司来说会有些许不同。如果你觉得我错过了一些重要的东西，或者你有非常不同的经历，请在评论区告诉我！
参考
- https://caiomsouza . medium . com/mlops-machine-learning-and-operations-and-ai-at-scale-ff CAC 7 e 50 f 62
- https://towards data science . com/ml-ops-machine-learning-as-an-engineering-discipline-b 86ca 4874 a 3f
- https://towards data science . com/machine-learning-monitoring-what-it-is-and-what-we-missing-e 644268023 ba
- https://elitedatascience.com/feature-engineering
- https://towards data science . com/complete-data-science-project-part-1-business-understanding-b 8456 bb 14 BD 4
- https://towards data science . com/understanding-hyperparameters-and-its-optimization-techniques-f 0 debba 07568
- https://toward sai . net/p/data-science/two-productivity-secrets-from-elon-musk-the-can-help-in-data-science
与雅格布塔利亚布埃公司一起建立合理规模的 MLOps
原文：https://web.archive.org/web/https://neptune.ai/blog/mlops-reasonable-scale-jacopo-tagliabue
本文最初是 MLOps Live 的第二集，这是一个互动 Q &环节，ML 从业者回答来自其他 ML 从业者的问题。
每集都专注于一个特定的 ML 主题，在这一集里，我们和雅格布·塔利亚布埃谈论了合理规模的 MLOps。
你可以在 YouTube 上观看:
视频
或者作为播客在以下位置收听:
但是，如果你喜欢书面版本，这里有！
您将了解到:
1 什么是合理的 MLOps 规模
-
2 如何建立合理规模的 MLOps】
-
使用什么工具，是购买还是制造工具
-
4 如何向客户交付模型
-
5 合理规模的界限是什么
-
6 还有更多。
-
让我们开始吧。
Sabine Nyholm: 很荣幸向大家介绍雅格布·塔利亚布埃，他甚至被称为合理规模营销之父。绝对是机器学习摇滚明星。雅格布，你能向我们的观众介绍一下你自己吗？
雅格布·塔利亚布埃:当然。我现在是 Coveo 的 AI 总监。对于那些不了解 Coveo 的人来说， Coveo 是一家在 TSX 上市的公司。我们基本上向客户提供机器学习模型，以服务于不同类型的用例。最重要的是电子商务，因为我来自那里。
这个想法是，让我们说你有一个网站，你想让你的网站有智能推荐，然后你会要求 Coveo 为你提供一个模型来做到这一点。
这很重要，不仅仅是为了告诉你一些关于我自己的事情，而且在接下来的一个小时里，这也很重要，告诉你我们从何而来，合理的规模 ML。
我们是一家 B2B 公司。我们没有客户直接使用模型，但我们为客户提供模型，用于他们的购物者或类似的事情。我认为这是一个重要的区别。
我加入 Coveo 是因为收购了我的公司 Tooso，它与我的联合创始人 Ciro 和 Mattia 在旧金山做着几乎相同的事情， 自然语言处理和电子商务 AI。所以我也曾是一名企业家。
我也喜欢成为研究和学术团体的一员。我是 NYU 大学的兼职教授，在那里我教授机器学习系统，所以实际上如何把所有这些机器学习部件放在一起让它们工作。我和我的团队尽我所能为电子商务技术社区做贡献——通过论文、开源和数据。
什么是合理的规模利润？
萨宾:优秀。非常感谢你雅格布。为了让你暖和起来，雅格布，你如何在一分钟内解释合理的规模？
雅格布:当然可以。我们每天在博客文章或商业评论中读到的许多 ML 指南和 ML 实践都是“谷歌这样做了，或者脸书这样做了，你应该这样做”。
合理规模 ML 的理念是，如果你不是谷歌，那就没关系。不是谷歌也没关系。实际上，在不久的将来，绝大多数的 ML 用例将会出现在企业内部，或者不一定是大型科技公司的内部。
视频
这是合理规模的背景，但合理规模令人兴奋的部分是，由于开源工具或解决方案(例如 Neptune )的不断增长和繁荣的生态系统，现在每个人都可以以非常低的门槛进入，所以有可能以合理的规模做尖端的 ML。这是一个巨大的差异，因为四年前，当我们开始创办我自己的公司 Tooso 时，许多现在我们认为理所当然的东西并不存在。
你需要大量的资源来实现这一点，但是现在第一次:
That’s the context for a reasonable scale, but the exciting part of a reasonable scale is that thanks to the growing and blooming ecosystem of open-source tools or solutions (like Neptune, for example) that are now available for everybody with a very low barrier to entry, it’s possible to do cutting-edge ML at reasonable scale. This is a huge difference because four years ago, when we started Tooso, my own company, a lot of things that now we take for granted were not there.
如果你从一个小团队开始
2 或者没有那么多资源，
- 你仍然可以做一个非常好的 ML。再次感谢这个不可思议的生态系统。
- 我们试图做的是向人们传播福音。这甚至不是我们自己的事情，但我们正试图向为我们工作的人宣传，帮助他们摆脱在生产中做 ML 是超级复杂的想法。如果你没有合适的工具，那就是了。如果你知道自己在做什么就不是了。
Stephen Oladele: 雅格布，我想知道是什么让你开始考虑合理的规模？这背后有什么故事？
雅格布:我们之前说过，记住，B2B 公司和 B2C 公司有很大不同。典型的 B2C 公司是 Airbnb 的 ML 堆栈，或者让我们说亚马逊，他们有一个推荐系统(为了简化)，他们有一个网站要处理。这是一个非常巨大和非常重要的网站，非常困难，但最终，他们控制了这个网站。
每次他们在推荐系统上做一点小的改进，他们都会把他们将要赚的钱装进口袋，在亚马逊的例子中，这是数十亿美元，值得投资这么做。
像 Tooso 或 Coveo 这样的 B2B 公司有一种不同的增长方式。我们通过增加顾客来发展。当然，我们的 ML 需要是好的，但是我们需要优化的不是一个特定的客户，而是跨越数百个客户的健壮性。
当你去拜访每一个客户时，他们中的每一个都不会是亚马逊，也许所有人都是，他们有太多太多的数据，但他们中的每一个都是合理规模的客户，每天有数百万次事件，而不是数万亿次。合理规模堆栈的想法来自于这样一种认识，即我们的大多数业务问题都是针对每个客户或组织的，并且世界上大多数组织都是合理规模的组织。
事实上，全球大多数组织都不是亚马逊，我们也想帮助他们。没有理由因为你不是亚马逊就没有好的 ML。那是 TL；博士这一切的口号。
建立合理规模的 MLOps
超大规模与合理规模的公司
斯蒂芬:谈到亚马逊、谷歌等等，这些都是像你提到的超大规模公司。你认为最大的区别是什么？如果你正在为一个小公司建立 ML，比如说，四个工程师或两个数据科学家，与亚马逊规模相比，你能指出的有帮助的区别是什么？
雅各:t1]
第一个，回到我之前的观点，是激励的不同。有区别。
如果你在谷歌或亚马逊，你有动力在某件事情上做得更好，因为它在 X 上 0.1 的改进将转化成数十亿美元。
- 对于一个合理规模的公司来说，这是不必要的。在激励方面，你构建团队的方式，例如，有多少数据工程师，多少数据科学家，以及你有多少机器学习研究，都取决于这个业务约束。
- 第二点是构建相对于购买相对于开源相对于你想要的任何东西，但是它是你如何使用你的资源的想法。
- 如果你的资源在某种程度上受到限制，你真的想花绝大部分时间，可能是全部时间，做高价值、高利润的活动。
- 例如，如果我是一名数据科学家，在 Coveo 中构建您的推荐模型，我想做推荐模型。我不想处理基础设施、扩展、实验跟踪等等。我们可以说出他们所有人的名字。对我来说，购买或以某种方式利用这些东西中已经非常好的其他东西要好得多，这不是我的核心。它们对我的工作来说是必要的，但这不是我所做的，然后我可以专注于最好的事情。
合理规模的工具组
- 克里斯:雅格布，我很欣赏你对 B2B 和 B2C 的定义。我们销售给其他企业，所以我们称自己为 B2B，但实际上我们是 B2C。那些只是顾客。我们有自己的产品，我们有界面。(我这么说是为了框出或者帮助你解答。)
Comparison of “reasonable scale” and “hyperscale” companies
我们处于零阶段。我是一名机器学习工程师，几个月前刚刚入职，到目前为止，我花了所有的时间做软件工程，但我的任务是试图找出我认为最重要的机器学习实验，因为一个小型数据科学团队继续试图推进我们今天拥有的三个商业化数据科学模型。
最大的问题是，我们是一家 AWS 商店，所以我正在努力使用 MLflow 、 SageMaker 和 Neptune 平台范例来开始。
雅格布:你说的只是整个管道的实验跟踪部分？你只是想专注于标本追踪吗？
克里斯:我得吃一小口。我认为一个三人团队试图包揽一切是错误的。
AWS 希望我们只需在上面签字，然后全部完成。我还没被 SageMaker 实验说服。
我还不赞成小公司承担 MLflow 资源需求的成本，尽管我们在 AWS 上的 Kubernetes 上支持这一点。
- 我们到了。一小口一小口。现在，我们正在讨论模型实验，控制它，在团队内部更好地了解我们每个人对主要核心组件做了什么。
- 雅格布:之后我会回到一般的点上，但我先来回答这个具体的问题。对于实验跟踪，我非常熟悉海王星、重量&偏差和彗星产品。
我认为它们迎合了略有不同的用户类型，但对我来说，总的建议是，与 MLflow 相比，我更喜欢 Neptune 提供的 SaaS 体验。
不是因为 MLflow 不太好，我们以前也使用过，而是因为它不值得我们团队为这样的功能进行额外的维护和拥有成本，我们的团队非常重视尖端实验，而不是基础设施和基本维护。
我认为在这里你必须做出的第一个选择是在你托管的东西和这些工具中的一个之间。
在我看来，这是一个显而易见的 SaaS 的事情。这是特别小的团队应该去 SaaS 的事情之一，但是我理解其他一些人可能在安全或各种其他问题上有不同的限制。如果你问我，这是 SaaS，这是 100%购买。在宇宙中没有这种自我塑造的事情。
Chris: 是的，我认为第一阶段的安全性是我们最关心的问题，因为从公司的客户和客户的客户的角度来看，它都是 PII，所以它必须在我们的 VPN 后面，我们还没有就成本和复杂性与 Neptune 展开对话，以进行设置。
雅格布:我完全理解。据我所知，有了所有这些解决方案，您就可以开始了——对于实验跟踪部分，实际上，您似乎不需要发送太多敏感信息来从这个工具中获得价值。更多的是损失指标、聚合指标和评估。我认为对于所有这些工具来说，即使是采用 SaaS 也可能是一次旅程。
当您从安全性较低但仍能为您的试验周期提供价值的东西开始时。然后你建得越多，你的胃口就越大。我认为这里有一条路径，可以有一个短的采用周期，看看它如何进行，然后推迟安全性讨论，直到你需要上传工件或数据之类的东西。有意义吗？
克里斯:很多。谢谢，是的。
许多 SaaS 工具也可以部署在您的服务器上。查看 Neptune 的内部发售。
关于 AWS，我想说的另一件事是，有一个我们非常推荐的工具(它是开源的，所以没有人从中获得任何金钱)，它被称为 Metaflow 。事实上，我们在 GitHub 上有几个开源回购，向你展示如何建立一个完整的端到端系统。对于使用 AWS 的人来说，我们总是发现 Metaflow 是一个很好的主干，可以放在上面，就像 Neptune 和 SageMaker for serving 或 Seldon 或任何你需要的东西。
我的建议是，如果你已经购买了 AWS，这并不意味着你需要走整个 SageMaker 的路，你可以选择一些其他的开源工具。他们非常擅长让你富有成效。
Sabine: 是的，我们实际上在聊天中有一个关于 Metaflow 的后续问题。它准备好了吗？
我不能正式说，因为我不知道最新的版本。我想我可以说它在工作中。不知道是已经出了还是在测试中。不过，我们使用它的是共享计算的 AWS。对我们来说，这没什么大不了的，因为我们正在 AWS Lambdas 中的 AWS 批处理之上使用它，这已经是我们基础架构的一部分。
我认为 Kubernetes 的东西很有趣，因为许多人使用它，当然，当他们查看他们的基础设施的现有主干时。
我认为 Chip 有一个很好的帖子说数据科学家不需要知道 Kubernetes。我会向前迈进一步，我会说很多 ML 团队根本不需要使用 Kubernetes。
在一个合理的规模上，有像 Kubernetes 一样好的解决方案来运行您的计算、培训和服务，可能只需要实际去 Kubernetes 的维护头痛的一小部分。
不管 Metaflow 和 Kubernetes 目前的状况如何，我相信这将会改善，我们在使用 AWS 过去的服务运行 Metaflow 时从未遇到任何问题，我们实际上非常非常看好使用这些过去的服务而不是自己维护集群的想法。
Sabine: 从时间计算存储或其他角度来看，MLOps 工具和流程中对您来说最昂贵的部分是什么？
那真的取决于你做什么。对我们来说，它是计算，特别是 AWS 补丁，特别是 GPU。对我的团队来说，按比例来说，这是我们账单中最大的一部分。
但我的团队所做的，要么是研究，前沿建模或原型，也有点前沿，但仍然是深度学习的东西，大量的数据，等等。我们账单的最大部分将会是那样的。
另一个重要的部分是雪花组件，它现在变得更便宜了。我们所有的数据都存储在数据仓库中，对我们来说，这是雪花。我们称之为真理的单一来源，因为我们通过设计把一切都储存在那里。
当您查询大量万亿字节的数据时，即使是合理的规模，在某些时候，账单也会堆积起来。
不过，我想说的是，虽然 GPU、雪花或 SageMaker 的成本很高，但这只是我的时间或像我这样的人的时间成本的一小部分。与美国一个熟练的 ML/AI 人员的花费相比，这只是微不足道的一小部分。我花在担心基础设施上的每一分钟都比付钱给杰夫·贝索斯让他给我要昂贵得多。
当然，在某些时候，这种类比是站不住脚的。
但是还是那句话，在合理的规模下，你人少的时候，你的成本就是人。从字面上看，你唯一的成本就是人。因为如果有人因为做 infra 而不是 ML 不开心，他们会离开。更换它们的成本会更高。
我们没有考虑所有这些隐性成本，因为这是人的成本。它们比你的 AWS 账单要大得多，大得多。在合理的尺度上为人民的幸福而优化。然后，当你真正变大时，你也可以针对计算进行优化。
Sabine:shri Kant 向我们提出了一个硬件问题。雅格布，你的模型训练推理使用英伟达 GPU 驱动的计算吗？如果是，在一个模型中，针对不同功能的定制消费需求，GPU 的抽象程度如何？
是的，我们使用的是通过 AWS 提供的标准 NVIDIA 产品，是在 SageMaker 批量购买的。是的，我们使用 NVIDIA 的东西，我们正在评估使用 NVIDIA 开源推理服务 Triton 作为实际部署的软件堆栈。
这两件事并不排斥。您可以拥有一个基于 SageMaker 的端点，它运行 Triton 作为您的推理软件。
抽象实际上是相当透明的。当您实际告诉 Metaflow 在 AWS 批处理上运行什么时，您可以将 Metaflow 指向您用正确的依赖项构建的特定容器。
发生的情况是:你告诉 Metaflow，“嘿，在这个容器上运行这个 Keras 模型的训练代码，这个容器被证明可以在 AWS 补丁 GPU 支持的东西上运行”——它将开箱即用。对于 SageMaker 服务来说，也是一样的。为 GPU 预先制作的服务实例将自动在 GPU 之外工作。
对我们来说，这已经很抽象了。我不认为我们在 GPU 方面有 99%的复杂性，因为我们大部分的 GPU 工作都是为了研究和原型制作。这种设置可能无法满足那些希望以非常低的延迟提供 GPU 服务的人。就目前而言，这是一个我们不必面对的问题。但是对于研究和迭代，我们的 GPU 抽象和 AWS 补丁到目前为止工作得非常好。
Sabine: 一个关于组织 ML 工作流程的问题。拉斐尔一直使用完美和气流。他说，“我愿意使用 SageMaker 推理端点来简化模型部署。你认为使用 SageMaker 管道来编排工作流有意义吗？”
雅格布:我没有 SageMaker 管道的经验，所以我在这里的意见可能不是决定性的。我有使用 Airflow 和 Prefect 的经验，如果你认为 Metaflow 是 ML orchestrator，那也是一个选择。
我不认为你被迫购买整个 SageMaker 管道只是为了从中获得价值。
比如，我们没有。我们用 SageMaker 进行训练。我们发现与普通 Python 相比，它作为 API 有点笨拙。我觉得你可以独立做出你的评价。如果你不想的话，没有理由跳进完整的 SageMaker 的东西。
另一方面，有很多理由使用 SageMaker 来处理与编排的其余部分完全无关的事情(例如，端点)。
如何建立合理规模的 MLOps
斯蒂芬:当你以合理的规模建造房屋时，你是如何考虑先放入哪些组件的？尤其是当你的团队中有两名数据科学家或四名工程师时？
视频
雅格布:你的第一个 ML 项目需要做的第一件事，第一条规则永远是:如果可以，千万不要做 ML。
**如果你的团队很小，我建议:
从数据开始。确保它是干净的，并妥善存放。我们可以讨论如何做到这一点。
然后，你可以对这些数据进行处理，产生一个小的端点。一开始，它不需要成为 MLM 点。它可以是一套规则，它可以是你能想到的最愚蠢的模型，它可以是一袋单词和一个侧面工具包来做测试分类。
- 然后确保端到端的工作，从数据到你的模型，到预测，然后你可以捕捉到你的用例的任何反馈。比方说如果是推荐，那就是点击。如果是文本分类，可能是拇指向上或拇指向下，如果用户想留下评论或类似的东西。
- 一旦你的两个数据科学家知道如何从数据到干净的数据，建模到终点，以及反馈，一旦所有这些指针都到位，解耦。
- 只要你保持这些部分之间的接触完好无损，现在你就可以开始改善了。现在我们把单词袋拿掉，用你想要的任何东西来代替它们。现在我们让数据质量更好。我们可以使用 Great Expectations 来检查分布情况或其他情况，而不只是检查我们有多少数据。
- 从小处开始，但以薄片的形式开始。因为如果你从小处着手，只关注其中的一部分，你就失去了对问题的关注。你需要解决的是端到端。它从数据到用户，然后从用户反馈回到数据。
- 我们试图做的，总是原型化一个特征的薄片。然后你回去，改善这一切。你改进得很好。你可以改善几个月。但首要的是花尽可能少的时间把东西拿出门来。如果你使用好的工具，这是可能的。如果你使用 SaaS 实验跟踪器。如果你不把时间浪费在愚蠢的事情上。那是非常重要的。
比方说，你考虑购买一个 SaaS 实验平台的时间最终会比你注册的花费更多。你用一个月，你出货，你看看效果如何，然后你再决定。真的很重要。
Examples for pillars of MLOps | Source
同样，这来自于建立一个合理规模的公司的一种非常具体的方式，来自于当你不断迭代时的一种非常创业的心态。速度是一种美德。
我明白这并不是在所有情况下都是正确的。当然，我不会建议医疗保健或自动驾驶汽车这样做。在有些地方，快速移动不是一个价值，但在很多地方，快速移动是擅长 ML 的一个重要组成部分。
Sabine: 在 Robert 的聊天中，我们有一个问题。他在这里有一些数据隐私问题，他问你是否有任何关于建立完整 MLOps 管道的工具的建议，除了为一个小型 ML/AI 团队服务，三到五个人有在内部运行的硬性要求。他们有一些 GitLab CI 和 DVC 已经建立和运行。
不幸的是，或者对我来说幸运的是，电子商务是一个非常不敏感的数据领域，因为电子商务数据首先总是被散列或匿名化。我们处理的许多数据都是交互数据，或者人们在我们网站上做的事情都有正常的安全问题，但不是医疗保健，或者不是特别敏感。一旦您符合 GDPR 和一般法规，您作为数据科学家的工作就会因为业务案例而变得简单。
不幸的是，我在隐私优先的环境中没有丰富的经验。我知道 DVC 很棒，但我们所有的生活都是关于云和服务的生活，合理规模的东西是云和服务是好的，因为它们允许你比你自己维护员工更快地移动，这显然意味着有时当不可能时，你必须自己去做事情。
我不知道具体的用例，但我在经验中发现的另一件事是，与云提供商或 SaaS 提供商相比，许多人倾向于大大高估自己设置的安全性。如果有人真的去调查的话，它们提供了同样的甚至更好的安全性。
同样，我不知道具体的使用案例，但我知道在另一个领域的其他案例中，对迁移到云的抵制更多的是文化上的，而不是关于云不安全的实际问题，无论它是安全的还是私有的。
也许，在这种情况下，为数据集或数据访问或雪花或元流等设置良好的数据治理，可能是减轻这种隐私担忧的一种方式。
Stephen: 就公司而言，允许他们的数据和流程之类的东西在这个特定的堆栈之外是违反文化的。他们的文化依赖于内部拥有一切，他们如何解决这个问题？他们如何应对这种情况，他们如何采用合理规模的 MLOps 方法来处理事情？
视频
雅格布:这是最难的问题之一。这是一个关于人类的问题，而不是关于 Python 或 SageMaker 或其他什么的问题。很辛苦。在我与数十个组织合作的经验中，这些组织是我们以前的客户或现在的客户或我在整个行业中的朋友，文化方面是最难改变的。
事实上，我们对我们的 Bigger Boat repo 或其他开源解决方案的许多抵制是，“嗯，你很幸运，因为他们允许你在公司里做所有这些事情。在我的公司里，有一个团队负责数据，有一个团队负责模型，有一个团队负责部署或其他什么(你可以将这些映射到你自己的经历中)。”
对我们来说，这是所有战斗之母，如果你能战斗的话。我们赞同端到端机器学习实践者或数据科学家的想法。有个人说:
In fact, a lot of the pushback we have with our Bigger Boat repo or other solutions we put out as open sources is, “Well, you’re lucky because they allow you to all of these things in your company. In my company, there’s a team for data, there’s a team for the model, there’s a team for deployment or whatever (you can map this into your own experience).”
1 可以看到已经清理准备好的数据，当然是数据专家，
2 能准备自己的特写，
-
3 可以训练自己的模型，
-
4 并且可以运出去。
-
在我们做的每一件事情中，回到团队切片的想法是授权给一个人，甚至一个人，也许更多，但它甚至可以是一个人能够做所有这些事情并产生商业价值，而无需与任何其他人交谈。不跟 DevOps 的人，不跟工程师，不跟保安，不跟任何人谈。
-
其他一切都没有足够抽象，因此一个机器学习工程师可以从数据到端点，这是一个改进的机会。越多的公司理解这一点，他们从他们的 ML 计划中获得的流动性就越大。
这家以一个小型数据科学家团队起家的公司的问题之一是，他们没有将他们嵌入到公司的工作流程和文化中，而是将他们放在一个孤岛中做笔记本或笔记本电脑上的任何东西。
然后一年后，Gartner 说 97%的项目从未进入生产阶段(我的 LinkedIn feed 上几乎都是 Gartner 说人们从未将员工投入生产)。也许我们可以说这是数据科学家的错，但我们并没有真正为他们的成功做好准备。我们把它们放在一个泡泡里，然后做，“嘿，做一些神奇的东西。”现在无论他们做什么魔法，对我们来说，都不可能在公司里消耗掉。
我对人们创业的建议是违反直觉的，但是从很少的人开始，让人们理解端到端的价值。
他们不需要成为建模方面的最优秀的人，不需要成为 SQL 方面的最优秀的人，不需要成为基础设施方面的最优秀的人，但是他们理解所有这些问题。我知道这些人的成本往往很高，因为他们之前没有多少人真正做过这种端到端的工作。但是一两个知道自己在做什么的人会让接下来的 10 次招聘变得更加高效。
如果你走另一条路，从大学里雇佣 20 个知道 PyTorch 的人(这种情况我见过很多次)，现在你有 20 个相对昂贵的人，可能每人不太贵，但是相对昂贵。他们跑来跑去找数据，记在笔记本上，但什么也没做成。一年后，高管说，“嗯，这个 ML 的东西不工作。”
当然，它不是这样的。我建议另一种方法。当你首先雇佣专家的时候，你建立了一个生产力工具，然后你雇佣一些人来实际地做建模和改进。这是我对创业人士的建议。同样，这是最难的部分，因为这是一场文化之战；这不是技术战。
Sabine: 你会推荐全栈工程师还是更专业的数据科学家、ML 工程师或者软件工程师？
Jacopo: 为了构建 MLOps 的顶层部分，我认为有些人需要了解 ML 模型的生命周期。
Sabine: Would you recommend going with full-stack engineers or more specialized data scientists, ML engineers, or software engineers?
这可能是一个非常有才华的软件工程师，我不知道，他来自网飞，也接触过建模。
对 ML 有一定了解的数据工程师也可以。
- 也可以是一个对数据有一定了解的 ML 人员。
- 以我的经验来看，仅仅来自软件工程师背景的人，倾向于非常擅长其中的一些工具，但是他们倾向于低估 ML 中出现的一些其他问题，典型的是数据不断变化的事实。系统的行为实际上是一个分布，它不像一个线性路径，一个正常的软件。
- 仅仅是一个总是专注于建模的数据科学家的人可能会低估另一个复杂性——使数据清晰可用、可扩展等等有多难。
这就是为什么我要说，我知道很难找到这些什么都懂的人。但根据我的经验，他们往往是最好的人，至少可以建立一个良好的实践。他们是您的数据领导者。然后，在您获得数据领导者后，您可以让拥有最专业知识的人来完成他们的工作。
向客户交付模型并在生产中监控它们
Sabine: 然后，我们有几个关于不同话题的问题。
Delivering models to customers and monitoring them in production
1 你如何将模型交付给客户？
他们使用你的 API 吗，或者它的工作方式有所不同？
- 你如何知道模型在生产中的表现？
- 例如，你如何知道何时更新它们呢？
- 雅格布:这是两个非常好的问题。对于第一个问题，我打算一分为二。一个是原型内部部署，一个是面向公众的全球可用性部署。因为，再一次，记住我们做的是字面上的 API，我们之前的产品 Coveo 或 Tooso 是字面上的 API。模型就是产品。我们不是植入 Airbnb 的模型，模型其实就是产品。
- 对于全球可用的东西，有一个由 Coveo 工程师用一年时间构建的完整基础架构，它基于我们自己的内部工具。它实际上是基于 Kubernetes 的，而且是在 Fargate 之类的过去的服务不太可用的时候完成的。
对于新的东西，比如我们做的原型和研究，特别是在我的团队中，我们非常乐意使用托管服务。
- 如果是非常简单的东西，我们可以使用，比如说，Fargate。(Faregate 的 Fast API 就像是你可以在网上找到的标准数据科学教程。)
- 对于稍微复杂一点的模型，我们使用 Sagemaker，因为它为您提供了这种基于 Python 的 API，这样，如果您使用 Metaflow，就像我们的情况一样，当您使用两行 Python 部署您的模型时，在实验跟踪等之后，您可以在管道中进行最后一步。它与 Metaflow 配合得很好，因为模型工件已经存储在 S3，所以您只需告诉 Sagemaker 模型工件在哪里，然后 Sagemaker 将为您创建一个端点。您会发现这是迭代和构建内部端点的一个非常好的方法。从任何角度来看，Sagemaker 都不是完美的。我们发现依赖项和定制容器的管理可以得到极大的改进，但是一旦你解决了这个问题，在你的 Python 基础上做一些事情实际上是非常快的。
- 这很有希望回答了问题的第一部分。关于监控的第二部分更有趣。但对我们团队和公司来说，这是一个新的开始。
- 监控空间在最近半年左右的时间里百花齐放。我们实际上正在评估该领域的开源平台和 SaaS 提供商，因为我们做的事情非常快，这就是信息检索。
我们所做的大部分工作要么是推荐，要么是搜索，因此这种使用情形不是人们在进行监控时通常提到的情形。也许他们提到了贷款预测问题或 NLP，但我们公司大多数人实际上是做信息检索的。所以它处理伪反馈，它有一个与大多数不同的约束。
当我们有了答案，我们可能会发表一篇博文或另一个开源回购来告诉你我们的想法。但就目前而言，监控领域对我们来说也是一个非常进步的领域。
扩展和改进 MLOps 工作流程
Stephen: 如果你在那张薄薄的幻灯片内开始我们合理的规模，MLOps，然后在那之上开始做事。你如何确定什么时候某个东西应该只是一个 bash 脚本，你可以在一个非常复杂的现成的 SaaS 平台上实现自动化？
雅格布:对我来说，非常务实，一切管用就好。那个人常说，完美的实现不是因为没有什么可以增加，而是因为没有什么可以减少。你的移动部件越少，你的系统就越健壮。那是肯定的。如果您只需运行三行 Python 代码就可以解决您的问题，那么没有必要获得一个全新的基础设施。
我通常发现，如果你把工作的功能部分做对了，比如说，数据、清理、培训、跟踪、部署等等。如果你把它们放在这些盒子里，有些东西一开始可能会非常容易，也许是一个小脚本，三行模式，等等，但是当这三行 Python 不再有用时，它会给你留下一个成长的机会。
从 bash 脚本或您为一个用例所做的任何事情开始，但是总是将那个脚本或那行 Python 放到一个增长的管道中。人们通常不会因为盒子里的东西而慢下来，而是因为盒子是如何连接在一起的。这就是为什么我说第一个，弄清楚盒子是如何连接的，然后进入每个盒子(如果你想，如果你需要)使它们变得更好。
Stephen: 我还有一个关于扩展堆栈的问题。例如，如果我有一个用例，我已经建立了一个视觉模型，并且我可能一天服务几个请求。但我确信这些模型肯定会扩大规模。我将建立模型来解决不同的问题，比如一年 20 个模型。这些可能会服务于数百万的请求。
我如何思考从零到合理的规模，并且一路上不打破东西？不破坏我已经建立的 bash 脚本之类的东西？
视频
Jacopo: 如果您关注的是未来的可扩展性，这意味着我们从一个小数据集、小反馈、小服务开始，我们可以随着时间的推移不断增加。这是很重要的一点，增长可能不是均匀的。
也许训练数据保持不变，但现在你服务于 10 亿用户，因为你的模型更加成功。
或者一切都被放大了。
- 也许这是信息检索，所以你实际上摄取的是反馈数据，所以你的培训数据也会上升，因为你的服务是成功的。
- 也许它是稍微相关的，但也可能是完全独立的。因此，重要的是您的管道能够维持这种独立的扩展。
- 雪花解决方案将为您提供现成的数据接收和准备。它可以处理 100 千兆字节的数据和 100 太字节的数据。唯一要改变的是你的账单，但是你的代码会像没有改变一样运行。
在培训方面，你需要做的是，假设你正在使用 Metaflow AWS 批处理，你可以在代码中自动将其扩展到某个点。例如，如果一开始你使用一个 GPU，现在你可以使用四个，随着你的进步，这对于你的代码来说是一个可以忽略的变化。其他一切保持不变。
- 现在我们进入部署部分。
- 比方说，在第 0 天，你甚至可以不使用服务器。我还没试过。我知道它已经举行了两个月或什么的，但现在有一个 SageMaker 选项，这只是支付推理。没人查询的时候你甚至都不交钱。对于第一个模型，如你所说，每天有几个请求。所以对你来说可能是超级便宜的解决方案。第一个月基本上是免费的。
- 当它变得更好时，也许你可以进入标准的自动缩放 SageMaker。在你的管道中可能会有两行不同的代码。
- 当你真正达到规模时，SageMaker 的成本会很高，然后你可能不得不选择其他部署方案。但是这是一个简单的方法，你可以在第一天工作，在第 365 天工作 98%是一样的。
- “购买与构建和维护”的困境
- 举例来说，看看小团队，一件非常重要的事情是软件行业中正在进行的或永恒的争论:构建对购买对开源。
在合理的规模堆栈背景下，您如何看待这一点？
Jacopo: 对我们来说，这可以归结为基础设施总是被购买(我想可能是因为我个人真的不擅长基础设施)。对我来说，任何需要维护的东西在一天结束时都是值得购买的。甚至衍生设置中的维护。
例如，我的公司 Tooso 就是建立在 EMR 和 Spark 之上，用于我们的数据处理。我是世界上最幸福的人之一，雪花被发明出来，因为我不用再和火花打交道了。我非常乐意购买所有的计算工具，只是为了更好地抽象出所有的问题，比如分布查询等等。
也是为了训练。我不能被一个或两个 GPU 所困扰。那真的没有好好利用我的时间。
在端点方面，正如我们所讨论的，在某个特定点之前，仅仅因为端点在那里就购买端点也是可以的。在一定程度上，这变得非常昂贵。还是那句话，事情会变的。对我来说，永远买计算。总是卸载事物如何运行和维护以及它们如何扩展。
因为说到底，我工作的价值是在 Python 的线中，在我的元流步骤中。这就是我得到的报酬。
然后，为了完成这项工作，我需要计算，我需要实验跟踪，我需要部署-但我的工作，在一天结束时，是我在这些生产线上投入的东西，对我来说，其他一切几乎都是购买。
我知道我在这方面很极端。但是，如果你再想想:
Then to do that job, I need to have computing, I need to have experiment tracking, I need to have deployment – but my job, at the end of the day, is what I put in those lines and everything else for me is almost always a buy.
1 今天在美国，
一名 ML 工程师的费用是多少
2 还有我更换它们要花多少钱，
- 3 以及我对我团队中的这些人投入了多少，
- 最终，尽管过去的解决方案可能会花费很多，但它们只花费了我的团队的幸福对我的公司实际花费的一小部分。
- Stephen: 您如何比较这些解决方案的定价？比方说，一个开源解决方案和一个典型的 SaaS 解决方案。你有看的东西吗？您是否有一个框架来比较您用于堆栈的工具的成本？
雅各:t1]
我们使用的一些工具没有其他选择，例如雪花。雪花的竞争只是你改变你的架构。比如你上了 Spark。这是我们所做的一个很大的拒绝。这是一方面。
对于其他东西，它真的取决于用例。对于 SaaS 实验平台来说，进入的门槛很小。他们让团队非常开心。这是代码库的一个小变化，让团队非常高兴，通常他们在合理的规模下花费了非常合理的金额。你可以从很少开始。这是我每次都会建议购买的东西。
- 其他的，比如说，提督，一个管弦乐队。这是你筹码中非常重要的一部分。它要么为你自己开源，要么作为一个平台。你是做什么的？取决于你的感受，但这些工具中的大多数都是入门级的，在 SaaS 这边非常小。你可以从那开始，然后你可以随时回去。
- 我最后的建议是从某件事开始。如果:
- 你不知道你想要什么，或者你知道你想要什么，
但是你还没有达到能够在一天之内完成一个端到端的新模型的成熟水平(这就是我们现在的情况)，
- 但你还在起步阶段，
- 先买东西，看看你是否喜欢。
- 然后，如果你真的喜欢 Prefect，并且有 100 个人想在你的公司里使用它，好吧，也许你可以把它放在内部，自己维护它。
我们不要把马车放在马的前面。先看看喜不喜欢。然后如果我们喜欢它，我们总是可以决定在规模上做什么。
这就是我说 SageMaker 的原因——在 Kubernetes 上构建自己的部署之前，先构建一个现代的 SageMaker，看看它是否可行，看看它是否能提供价值。在那之后，你可以随时回去在 Kubernetes 重做这个。
我想很多人都害怕 SaaS 成本，因为实际上预先构建你甚至不知道是否需要的东西在预期中要昂贵得多。
从 SaaS 开始，然后你可以随时回去做别的事情，因为那会是一个“快乐的问题”。如果你建立的模型如此成功，以至于现在有数百万人在使用它 StageMaker 的问题是一个“快乐的问题”。
然而，如果我们已经教会了两位数据科学家如何使用 Kubernetes(这需要花费六个月的工资)，而现在这个模型没有人使用，那么我们浪费了六个月的时间，这将是非常糟糕的。这些人会离开是因为他们不开心。而不是只买现成的。
合理规模的界限
萨宾:合理规模的界限是什么？什么时候你大到不讲理了？你认为这是团队规模、模型数量或模型准确性、相关性的问题吗？
雅格布:在我和我的同事 Andrea 和 Ciro 共同编辑的 TDS 系列中，我们有很多维度。他们在某种程度上是相互关联的。这不是一个精确的定义，但它让你感觉到你在哪里。
一个是数据大小，当然，如果你一天有 1pb 的数据，合理的规模并不真正适用于你。
一个是团队规模——直到你有 5、6、7、10 个人，维护东西的开销几乎永远不会给你的团队生产力和快乐带来回报。所以合理规模完全适用。当然，当你变得更大时，事情可能会改变。
- 另一点是用例——同样，我认为很多人(我这么说——没有伤害，就没有犯规),但很多人高估了他们的模型在第一天需要有多好才能产生价值。对于这个世界的亚马逊来说，这是个问题。这对大多数公司来说不是问题，当然，对大多数规模合理的公司来说也不是问题。
大多数人现在正在启动 ML，一些最激动人心的 ML 用例现在都在企业内部。当要敲打的栏是 Excel 电子表格，当要敲打的栏是笨重的工作流程。
如果你不在这五家公司中的任何一家工作，这就是价值所在。对你的 ML 来说，最重要的是它能工作。如果它在没有维护、良好监控和良好扩展的情况下工作，那实际上就是 90%的价值。我认为很多人认为他们没有达到合理的规模，因为他们有点想太多了。
要达到的目标是以合理的成本提供相对于现状的商业价值。这实际上限定了大约 90%的用例。可惜不是你在网上看到的那样。我的比喻总是这样，“我们都在努力学习如何打网球，我们唯一看的就是罗杰·费德勒的训练。这很鼓舞人心，但是: - 我们不是罗杰费德勒；没有人是，
- 即使现在我们不是罗杰·费德勒，在训练结束后成为罗杰·费德勒的人仍然很少。
- 看看 YouTube、Lyft 和优步是怎么做的。那里有很多教训。但是不要试图把它们一一映射到你的生活中。因为你的生活很不一样。在某些限制方面非常不同，但在某些机会方面也很不同，因为你可以使用很多在优步规模下没有意义的工具。
- 其他问题
Graph showing area covered by the reasonable scale | Source
Sabine: 我们有一个来自 Chimoubi 的关于电子商务的问题。当建立一个图像分类模型对大约九个产品类别的图像进行分类时，我们是否需要为每个产品类别建立不同的模型，或者是否有其他的出路？
雅格布:你的意思是:我给你一张产品的图片，它要么是鞋，要么是包，要么是 t 恤？不，它只是一个模型中的标准多类分类。最终，将会有九个可能的标签，您只需要根据您想要构建的模型，从九个标签中选择最佳的标签。所以你完全可以和一个模特在一起。
如果你正在做图像分类，有一些新的工作，其中一些来自我的团队，是关于使用 CLIP 的。做分类是开放的 AI 通用模型。我们实际上做了什么，我想我们上周发布了论文。实际上，你可以使用这个预训练模型，这个来自社区的大型模型，对他们进行微调以适应电子商务，然后你甚至不用做任何培训就可以免费获得这个分类。
如果你对产品分类的概念感兴趣，建议你去查一下。我们的论文叫做 FashionCLIP 。我们也将很快发布代码。
学习 MLOps 的资源
Sabine: 我们有一个关于不同话题的问题。Shrikant 想知道您是否有任何关于获得改善机器学习交付生命周期的新视角的阅读建议。有书吗？
雅格布:有两本很神奇的书。
一个已经出局了。它是由 Ville Tuulos，一个芬兰人共同创建的 Metaflow，叫做“有效的数据科学基础设施
此外，Chip Huyen 即将出版一本关于 ML 系统的书。
- 这是我热情推荐的两本书。
- 如果你想从开源的、可获得的内容开始:
Made with ML 是我朋友悟空提供的一个非常非常非常不可思议的资源。
Chip 在斯坦福大学的课程也是开源的，这是一门关于 ML 系统的课程。
- 我在 NYU 大学的一部分课程也是开源的。你可以在 GitHub 上找到。
- 这些是更多的课程，所以幻灯片和代码片段，比书多，但它们是免费的，你可以明天开始。
- A part of my course at NYU is also open-source. You can find it on GitHub.
These are more courses, so slides and snippets of code, more than books, but they’re free, and you can start tomorrow.**
这是我们的 MLOps 工具堆栈:连续产业
原文：https://web.archive.org/web/https://neptune.ai/blog/mlops-tool-stack-continuum-industries
Continuum Industries 是一家基础设施行业的公司，希望自动化和优化线性基础设施资产的设计，如水管、架空传输线、海底电力线或电信电缆。
它的核心产品 Optioneer 允许客户输入工程设计假设和地理空间数据，并使用进化优化算法来寻找可能的解决方案，以在给定约束的情况下连接 A 点到 B 点。
“建造像电力线这样的东西是一个巨大的项目，所以你必须在开始之前获得正确的设计。你看到的设计越合理，你就能做出更好的决定。Optioneer 可以在几分钟内为您提供设计资产，而成本只是传统设计方法的一小部分。”
但是，创建和操作 Optioneer 引擎比看起来更具挑战性:
- 目标函数不代表现实；
- 有大量土木工程师事先不知道的假设；
- 不同的客户会给它提出完全不同的问题，算法需要足够健壮来处理这些问题。
与其构建完美的解决方案，不如向他们展示一系列有趣的设计选项，以便他们做出明智的决策。
作为一个工程师团队，我们利用来自机械工程、电气工程、计算物理、应用数学和软件工程的各种技能来实现这一目标。我们还使用各种工具和框架。
目前，我们的目标是开发和采用强大的 QA 流程，确保返回给最终用户的解决方案:
- 好，意味着这是一个土木工程师可以看到并同意的结果。
- 正确，意味着计算并返回给最终用户的所有不同的工程数量尽可能正确。
对我们发动机性能的持续监控和可重复测试将是这些流程的核心。
“引擎”代码是用 Python 编写的，我们在那里使用通常的嫌疑对象:scipy、numpy、pandas 和 matplotlib 。
我们有一组“测试问题”,算法就是针对这些问题运行的。每个测试问题都由一个配置和一个包含所需地理空间数据的相对较大的文件来定义。代码使用 git 版本化，地理空间数据使用 DVC 版本化。
通常，当我们试图对算法进行改进时，我们从这些测试问题中的一个开始，然后用我们希望进行的任何修改来运行它。我们通常在这部分过程中使用 【海王星】 ，以便跟踪实验。这使我们能够轻松回顾到目前为止我们已经尝试过的内容，并计划接下来的步骤。
一旦我们设法在那个测试问题中产生更好的结果，我们就将测试扩展到整个测试问题集。开发人员可以运行完整的测试管道(见下图)，然后将结果与主分支上的最新运行进行比较。这让我们知道在我们做出改变后，是否在我们所有的测试问题上有显著的统计改进。这条管道运行在 Github Actions 上，并使用一个名为 CML 的工具来部署 EC2 实例。
Continuum Industries MLOps pipeline | Click to enlarge the image
如果我们对结果满意，我们就开始“生产”我们写的任何代码:我们清理它，写单元测试，等等。对于单元测试，我们使用 pytest 和 假设 。后者是 python 单元测试的一个聪明的数据生成器，通常允许我们找到破坏代码的边缘情况并处理它们。
对于算法本身，我们使用的是 python 中 鸭嘴兽 库的大幅修改版本。我们进行了广泛的修改，以实现更好的并行计算，并更好地适应我们的总体用例。
最后，我们使用 射线 来并行计算。我们发现它比 python 中的多处理模块要快得多，并且它有可能轻松地跨多台机器进行水平伸缩(尽管我们还没有利用这一功能)。
对于我们的云，我们也使用 Kubernetes ，以及 Argo 工作流。
Continuum Industries tool stack | Click to enlarge the image
我们喜欢当前设置的什么
- 整个测试管道都经过每个 PR 的单元测试，这意味着它运行可靠，不会在我们身上失败。
- 所有相关数据都记录在一个地方:git 版本、多次运行的度量、配置数据等。
- 通过 CUSTOM_RUN_ID 功能，我们可以在 CI/CD 管道的不同阶段轻松处理和聚合数据，然后更新相关的运行。
- Neptune 的 UI 相当光滑，它使得跟踪、标记和管理跑步非常容易。
- 由于一切都是版本化的(用 git 编码，通过 DVC 的地理空间数据)，可重复性更容易实现。
我们不喜欢当前的设置
- 我们的 runners 是 spot 实例，因此它们被 AWS 杀死的频率比我们希望的要高，这意味着我们需要重启管道。
- 因为完整的管道需要几个小时来运行，并且因为我们的 CI/CD 的其余部分是如何设置的，所以它不部署任何东西。更确切地说，它是一个“健全检查”,看看我们是否在上周破坏了什么。理想情况下，我们希望将结果的批准与新版本算法的部署联系起来。
- 该过程的最后一步仍然是手动的。一个人必须进入并运行一个脚本，从两次运行中下载数据，并在它们之间执行统计比较，以便告诉我们哪一次更好。因为它是手动的，它不是真正的管道的一部分，因此信息没有存储在 Neptune 中，这是一个遗憾。
安德烈亚斯·马莱科斯
首席科学家@Continuum Industries
阅读下一篇
最佳 MLOps 工具以及如何评估它们
12 分钟阅读| Jakub Czakon |年 8 月 25 日更新
在我们的一篇文章中——机器学习团队实际使用的最好的工具、库、框架和方法——我们从 41 家 ML 初创公司学到的东西——Acerta 的 CTO Jean-Christophe Petkovich 解释了他们的 ML 团队如何接近 MLOps。
据他所说，一个完整的 MLOps 系统有几个要素:
- 您需要能够构建包含预处理数据和生成结果所需的所有信息的模型工件。
- 一旦您能够构建模型工件，您必须能够跟踪构建它们的代码，以及它们被训练和测试的数据。
- 您需要跟踪所有这三样东西，模型、它们的代码和它们的数据，是如何关联的。
- 一旦您可以跟踪所有这些内容，您还可以将它们标记为准备就绪，进行生产，并通过 CI/CD 流程运行它们。
- 最后，为了在该过程的最后实际部署它们，您需要某种方法来基于该模型工件旋转服务。
这是对如何在公司中成功实施 MLOps 的高度概括。但是理解高层需要什么只是拼图的一部分。另一个是采用或创建适当的工具来完成工作。
这就是为什么我们编制了一份最佳 MLOps 工具的清单。我们将它们分为六类，以便您可以为您的团队和业务选择合适的工具。让我们开始吧！
NLP 项目的 MLOps 工具
原文：https://web.archive.org/web/https://neptune.ai/blog/mlops-tools-for-nlp-projects
聊天机器人、总结应用、Siri、Alexa——这些只是一些已经被大规模采用的很酷的自然语言处理(T2)项目。你有没有想过它们是如何管理、持续改进和维护的？这正是我们在本文中要回答的问题。
例如，谷歌的自动更正每次都变得更好，但不是因为他们想出了一个不需要任何维护的超级好的模型。每次都变得更好，因为有一个管道，在早期通过在获得新数据时反复执行所有 ML 任务来自动化和改进模型。这是 MLOps 最好的例子。
在本文中，我将告诉您可以用于 NLP 项目的各种 MLOps 工具。这包括很酷的开源平台，以及一些帮助您入门的代码。我还将对所有工具进行比较，以帮助您导航并为您想要使用的任何框架选择最佳工具。
以下是我们将要讨论的内容:
以下是我写这篇文章时所做的假设，只是为了让我们达成共识:
- 你知道什么是 NLP。你不需要知道很多，只要知道一点基本的和一些流程就够了。
- 您熟悉构建机器学习项目的过程。还是那句话，不需要知道太多。你之前至少应该建立一个机器学习项目，这样你就知道我将使用的术语。
- 你思想开放，乐于学习！
如果您是 MLOps 专家，您可以跳过介绍，直接使用工具。
什么是 MLOps？
数据会随着时间的推移而变化，这使得机器学习模型变得陈旧。ML 模型学习数据中的模式，但是这些模式随着趋势和行为的改变而改变。
我们不能阻止数据总是变化，但是我们可以让我们的模型随着新的趋势和变化而更新。为此，我们需要一个自动化的管道。这个自动化过程被称为 MLOps 。
MLOps 是数据科学家和运营专业人员之间进行协作和沟通的一套实践。
请注意 MLOps 还没有完全自动化，至少还没有。你还是要手动做一些事情，但是比起完全没有工作流来说，要轻松无比。
MLOps 是如何工作的？
MLOps，即机器学习运算，与 DevOps 不同。
DevOps 是开发和操作大型软件系统的一种流行实践。它在软件系统开发中有两个概念:
典型的 DevOps 周期是:
- 代码，
- 测试，
- 部署，
- 监视器。
在 ML 项目中，有许多其他过程，如数据收集和处理、特征工程、培训和评估 ML 模型，DevOps 无法处理所有这些。
在 MLOps 中，您有:
- 进入系统的数据通常是条目，
- 预处理数据和选择有用特征的代码，
- 训练模型和评估模型的代码，
- 测试和验证它的代码，
- 要部署的代码，
- 诸如此类。
要将您的模型部署到生产中，您需要通过 CI/CD 管道来推动它。
一旦投入生产:
- 你需要经常检查性能，确保它是可靠的，
- 您需要一个自动警报或触发系统来通知您问题，并确保这些更改解决了出现的问题。
MLOps automated pipeline | Source
我们为什么需要 MLOps？
无论您尝试部署哪种解决方案，MLOps 都是项目成功的基础。
MLOps 不仅有助于协作和将 ML 集成到技术中，它还帮助数据科学家做他们最擅长的事情，开发模型。MLOps 自动执行由数据科学家手动完成的再培训、测试和部署。
机器学习有助于部署解决方案，通过创建更高效的工作流、利用数据分析进行决策和改善客户体验来释放以前未开发的收入来源、节省时间和降低成本。如果没有像 MLOps 这样的坚实框架，这些目标很难实现。
为您的 NLP 项目选择合适的 MLOps 工具取决于您的解决方案的工具。
您的选择取决于您的项目需求、成熟度和部署规模。你的项目必须结构合理( Cookie Cutter 是一个很好的项目结构工具，可以帮助你做到这一点)。
Verta 的创始人兼首席执行官 Manasi Vartak，指出了您在选择任何 MLOps 工具之前应该问自己的一些问题:
- 它应该对数据科学家友好，而不是限制您的数据科学团队使用特定的工具和框架。
- 它应该易于安装，易于设置，易于定制。
- 它应该可以与您现有的平台自由集成。
- 它应该能够重现结果；无论您是与团队成员合作，调试产品故障，还是迭代现有模型，再现性都是至关重要的。
- 它应该具有良好的伸缩性；选择一个能够满足您当前需求的平台，该平台可以针对实时和批处理工作负载进行扩展以满足未来需求，支持高吞吐量场景，随着流量的增加而自动扩展，并具有简单的成本管理和安全的部署和发布实践。
NLP 项目的最佳开源 MLOps 工具
每个 MLOps 工具都有自己的工具。下面列出的开源平台是特定于 NLP 项目的，并根据它们拥有的 Github 星级数进行评级。一些商业化的平台专门用于 NLP 项目，但是其他的通常可以用于任何 ML 项目。
适配 NLP (329 Github stars)
它是一个高级框架和库，用于运行、培训和部署最先进的自然语言处理(NLP)模型，以执行端到端任务。它建立在 Zalando Research 的天赋和拥抱脸的变形金刚库之上。
AdaptNLP 为机器学习研究人员和科学家提供了一种模块化和自适应的方法来完成各种 NLP 任务，并提供了一种简单 API 来训练、推理和部署基于 NLP 的微服务。您可以使用 Fast-api 在本地或使用 docker 部署 Adapt-NLP 模型。
AdaptNLP 特性:
- 该 API 针对具有 SOTA 预训练模型的 NLP 任务进行了统一。您可以将它与 Flair 和 Transformer 模型一起使用。
- 提供用于训练和微调模型的界面。
- 使用 FastAPI 框架轻松即时地部署您的 NLP 模型。
- 您可以使用 Docker 在 GPU 上轻松构建和运行 AdaptNLP 容器。
Linux/Mac 的安装要求:
我建议您将它安装在新的虚拟环境中，以防止依赖性集群问题。如果您安装了 Python 3.7 版，您需要安装 Pytorch 的最新稳定版本(1.7 版)，如果您安装了 Python 3.6 版，您需要将 Pytorch 降级到< =1.6 版。
【Windows 的安装要求:
如果你还没有安装 Pytorch，你必须从 Pytorch 手动安装。
使用画中画，
pip install adaptnlp
或者如果你想为发展做贡献，
pip install adaptnlp[dev]
auto gulon(3.5k Github stars)
自动登录是简单的文本，图像和表格数据的自动标记。它使您能够轻松地将 AutoML 扩展到深度学习、堆栈组装和其他现实世界的应用程序等领域。它自动执行机器学习任务，并在您的应用中为您的模型提供强大的预测性能。
只需几行代码，就可以在文本、图像和表格数据上训练和部署高精度的机器学习和深度学习模型。目前，它只为 Linux 和 MacOS 用户提供支持。
自动登录功能:
- 只需几行代码，就可以创建深度学习和 ML 解决方案的快速原型。
- 无需专业知识，自动使用最先进的技术。
- 您可以自动执行数据预处理、工具搜索、模型选择/集成和超参数调整。
- AutoGulon 完全可以根据您的使用情况进行定制。
安装:
它要求您拥有 Python 3.6、3.7 或 3.8。目前只支持 Linux 和 MacOS。根据您的系统，您可以下载 CPU 版本或 GPU 版本。
使用画中画:
对于 MacOS :
python3 -m pip install -U pip
python3 -m pip install -U setuptools wheel
python3 -m pip install -U "mxnet<2.0.0"
python3 -m pip install autogluon
目前不可用
对于 Linux :
python3 -m pip install -U pip
python3 -m pip install -U setuptools wheel
python3 -m pip install -U "mxnet<2.0.0"
python3 -m pip install autogluon
python3 -m pip install -U pip
python3 -m pip install -U setuptools wheel
python3 -m pip install -U "mxnet_cu101<2.0.0"
python3 -m pip install autogluon
教程:
gluonlp(2.3k github stars)
它是一个支持 NLP 过程的框架，比如加载文本数据、预处理文本数据和训练 NLP 模型。Linux 和 MACOS 上都有。您也可以将其他形式的 NLP 模型转换成 GulonNLP。您可以转换的此类模型的几个示例包括 BERT、ALBERT、ELECTRA、MobileBERT、RoBERTa、XLM-R、BART、GPT-2 和 T5。
GulonNLP 特性:
- 易于使用的文本处理工具和模块化 API
- 预训练模型动物园
- 用 Numpy 之类的 API 编写模型
- 通过 Apache TVM 进行快速推理(孵化)(实验)
- AWS 与 SageMaker 的集成
安装 :
在开始安装之前，请确保您的系统上有 MXNet 2 版本。以防万一，你可以从你的终端安装它。从以下选项中选择一个:
python3 -m pip install -U --pre "mxnet-cu102>=2.0.0a"
python3 -m pip install -U --pre "mxnet-cu110>=2.0.0a"
python3 -m pip install -U --pre "mxnet>=2.0.0a"
现在，您可以继续安装 GulonNLP 了。打开您的终端并键入:
python3 -m pip install -U -e
您也可以通过键入以下命令来安装所有额外的要求:
python3 -m pip install -U -e ."[extras]"
如果您在安装过程中遇到任何与用户权限相关的问题，请参考本指南。
教程:
喀什噶尔 (2.1k github 星星)
强大的 NLP 迁移学习框架，可用于在 5 分钟内为命名实体识别(NER)、词性标注(POS)和模型分类构建最先进的模型。初学者、学者和研究人员都可以使用它。
喀什特点:
- 易于定制、有据可查且简单明了。
- Kashgari 允许您在自然语言处理项目中使用最先进的模型。
- 它允许您构建多标签分类模型，创建定制模型，等等。点击了解更多
- 允许你调整你的模型的超参数，使用定制的优化器和回调，创建定制的模型，和其他的。
- Kashgari 有内置的预训练模型，这使得迁移学习非常容易。
- Kashagri 简单、快速且可扩展
- 您可以导出您的模型，并使用 tensorflow 服务将它们直接部署到云中。
安装
Kashgari 要求您在系统上安装 Python 3.6+版本。
使用画中画
pip install 'kashgari>=2.0.0
pip install 'kashgari>=2.0.0
pip install 'kashgari<1.0.0
教程:
LexNLP (460 颗 Github 星星)
由 LexPredict 开发的 LexNLP 是一个 Python 库，用于处理真实的非结构化法律文本，包括合同、政策、程序和其他类型的材料、分类器和条款类型、用于构建新的聚类和分类方法的工具、真实法律文档的数百个单元测试。
特性:
- 它提供了预训练的模型，用于分段、单词嵌入和主题模型，以及用于文档和子句类型的分类器。
- 事实提取。
- 构建新的聚类和分类方法的工具。
安装:
要求您已经安装了 Python 3.6
pip install lexnlp
教程:
TensorFlow Text 提供了一组与文本相关的类和操作，可用于 TensorFlow 2.0。该库可以执行基于文本的模型所需的常规预处理，并包括 core TensorFlow 未提供的对序列建模有用的其他功能。
在文本预处理中使用这些操作的好处是它们是在张量流图中完成的。您不需要担心训练中的标记化与推理中的标记化不同，或者管理预处理脚本。
Tensorflow 文本特征:
- 为处理文本提供了一个大型工具包
- 允许与大量 Tensorflow 工具集成，以支持从问题定义到培训、评估和启动的项目
- 降低服务时间的复杂性并防止培训-服务偏差
安装:
使用画中画
请注意:使用 pip install 安装 TF Text 时，请注意您正在运行的 TensorFlow 的版本，因为您应该指定 TF Text 的相应次要版本(例如，对于 tensorflow2.3.x，请使用 tensorflow_text2.3.x) 。
pip install -U tensorflow-text==<version>
从源安装
请注意 TF Text 需要在与 TensorFlow 相同的环境下构建。因此，如果您手工构建 TF 文本，强烈建议您也构建 TensorFlow 。
如果在 MacOS 上构建，您必须安装 coreutils 。自制可能是最容易做到的。
构建并安装 TensorFlow。
- 克隆 TF 文本 repo: git 克隆https://github.com/tensorflow/text.git
- 运行构建脚本来创建 pip 包:。/oss_scripts/run_build.sh 这一步之后，应该会有一个*。当前目录中的 whl 文件。文件名类似 tensor flow _ text-2 . 5 . 0 rc0-cp38-cp38-Linux _ x86 _ 64 . whl。
- 将软件包安装到环境:pip install。/tensor flow _ text---*-OS _ platform . whl
教程:
文本预处理
文本分类
文本生成
通气管 (4.7k GitHub stars)
数据标记工具，您可以以编程方式标记、构建和管理培训数据。通气管管道的第一组件包括标记函数，其被设计为弱启发式函数，在给定未标记数据的情况下预测标记。
特点:
- 它支持 Tensorflow/Keras、Pytorch、Spark、Dask 和 Scikit-Learn。
- 它提供了用于标记、分析、预处理、切片、映射、实用程序和分类的 API。
安装:
通气管需要 Python 3.6 或更高版本。
使用画中画(推荐)
pip install snorkel
使用康达
conda install snorkel -c conda-forge
请注意:如果你使用的是 Windows，强烈推荐使用 Docker ( 教程示例)或 Linux 子系统。
教程:
Lingvo 是一个在 Tensorflow 中构建神经网络的框架，尤其是序列模型。
tensorlow lingvo 特征:
- Lingvo 支持自然语言处理(NLP)任务，但它也适用于用于图像分割和点云分类等任务的模型。
- Lingvo 可用于训练“生产规模”数据集。
- Lingvo 为同步和异步分布式训练提供了额外的支持。
- 量化支持已经直接内置到 Lingvo 框架中。
安装:
使用画中画:
pip3 install lingvo
从源安装:
检查您是否满足以下先决条件
- 系统上安装的 TensorFlow 2.5
- C++编译器(官方仅支持 g++ 7.3)
- 巴泽尔建筑系统。
参考 docker/dev.dockerfile 了解一组工作要求。
现在，git 克隆存储库，然后使用 bazel 直接构建和运行目标。codelab 中的 python -m 模块命令需要映射到 bazel run 命令上。
使用 docker :
Docker 配置可用于这两种情况。可以在每个文件顶部的注释中找到说明。
lib.dockerfile 预装了 Lingvo pip 包。
dev.dockerfile 可用于从源代码构建 Lingvo。
教程:
空间 (21k Github stars)
spaCy 是 Python 和 Cython 中的高级自然语言处理库。它建立在最新的研究基础上，从第一天起就被设计用于真实的产品。
spaCy 带有预训练的管道，目前支持 60 多种语言的标记化和训练。它具有最先进的速度和神经网络模型，用于标记、解析、命名实体识别、文本分类等，多任务学习，具有像 BERT 这样预先训练的转换器，以及生产就绪的培训系统和简单的模型打包、部署和工作流管理。
特性:
- 支持 PyTorch、TensorFlow 和其他框架中的定制模型。
- 支持 60 多种语言。
- 支持预先训练的单词向量和嵌入。
- 简单的模型打包、部署和工作流管理。
- 语言驱动的标记化。
安装:
它支持 macOS / OS X、Linux 和 Windows (Cygwin、MinGW、Visual Studio)。您还需要在系统上安装 Python 3.6+版本(仅 64 位)。
使用画中画
在继续安装之前，请确保您的 pip、setuptools 和 wheel 是最新的。
pip install -U pip setuptools wheel
pip install spacy
使用康达
conda install -c conda-forge spacy
教程:
天赋 (11k GitHub 明星)
Flair 是最先进的 NLP 的简单框架。它允许您使用最先进的模型来完成 NLP 任务，如命名实体识别(NER)、词性标注(POS)、词义消歧和分类。它为生物医学数据提供了特殊的支持，也支持数量迅速增长的语言。
天赋特性:
- 它完全建立在 Pytorch 上，因此您可以轻松地构建和训练您的天赋模型。
- 最先进的自然语言处理模型，可以用于你的文本。
- 允许你用简单的接口组合不同的单词和文档嵌入。
安装:
它要求你有 Pytorch 1.5+，目前支持 Python 3.6。下面是如何为 Ubuntu 16.04 。
pip install flair
教程:
适用于您的 NLP 项目的开源 MLOps 工具–比较
| Github stars | Windows 操作系统 | Linux 操作系统 | 马科斯 | Tensorflow | Pytorcht | 其他框架 | 数据标记 | 数据预处理 | 模型开发 | 模型部署 | |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 329 | |||||||||||
| 11k | |||||||||||
| 21k | |||||||||||
| 2.3k | |||||||||||
| 4.7k | |||||||||||
| 770 | |||||||||||
| 第 460 章 | |||||||||||
| 2.1k | |||||||||||
| 2.3k | |||||||||||
| 3.5k |
NLP 项目的最佳 MLOps 即服务工具
Neuro MLOps platform 为您提供成功的大规模 ML 开发所需的基础设施和流程的完整解决方案和管理。它提供完整的 MLOps 生命周期，包括数据收集、模型开发、模型培训、实验跟踪、部署和监控。Neu.ro 为成功的大规模 ML 开发提供基础设施和流程的管理。
设置
装置
建议首先创建一个新的虚拟环境。它要求您安装 Python 3.7。
pip install -U neuromation
或者
<pre class="hljs" style="display: block; overflow-x: auto; padding: 0.5em; color: rgb(51, 51, 51); background: rgb(248, 248, 248);">pip install -U neuromation
</pre>
如何:
- 在 neu.ro 注册
- 使用 webUI 或 CLI 上传数据
- 设置开发环境(允许您使用 GPU)
- 训练模型或下载预训练模型
- 运行笔记本(Jupyter)
看看这本 ML 食谱来帮助你开始一个 NLP 项目。
AutoNLP 提供了一种自动训练最先进的 NLP 模型的方法，与拥抱脸生态系统无缝集成，并自动将其部署在可扩展的环境中。这是一种为不同任务训练、评估和部署最先进的 NLP 模型的自动化方式。它会根据您提供的数据集自动调整部署的工作模型。
设置
安装:
要使用画中画:
pip install -U autonlp
请注意:您需要安装 git lfs 来使用 cli
如何:
- 登录您的帐户
- 创建新模型
- 上传数据集
- 训练你的自动模型
- 跟踪模型进度
- 做预测
- 部署您的模型
查看 AutoNLP 文档了解您的具体使用案例。
Neptune 跟踪机器学习实验，存储您的模型的元数据(日志度量、性能图表、视频、音频、文本、记录数据探索)，提供一个模型注册表，您可以在其中版本化、存储并让您随时查询您的模型，并为您的团队提供一种有效的协作方式。Neptune 允许您定制 UI 并管理本地环境或云环境中的用户。
设置
装置
pip install neptune-client
如何记录您的项目元数据，
- 创建一个海王星账户
- 在海王星上创建一个新项目
在代码编辑器中，
- 用您的 api 令牌初始化一次运行，并记录您想要的模型元数据。
- 运行您的代码，您在 Neptune 上的项目将自动更新！
查看 Neptune 文档,探索更多内容，无风险运行您的实验！
DataRobot 现在已经收购了 Algorithmia，它是一个平台，可以大规模地自动化构建、部署和维护机器学习(ML)和人工智能(AI)的端到端流程。它是一个无代码的应用构建器，是一个您可以在生产中部署、监控、管理和治理所有模型的平台，无论它们是如何创建的，何时何地部署的。
设置
- 它目前支持 python 2.7 和> =3.4
pip3 install datarobot
pip3 install requests requests-toolbelt
如何创建新项目:
- 登录您的帐户
- 安装依赖项
- 加载并分析您的数据
- 开始建模
- 审查和解释模型
- 部署模型
- 选择应用程序
查看此文档了解如何使用这些步骤的正确演练。
它有助于您简化和实施生产机器学习模型的工具最佳实践。它是一个可扩展的框架，为 AWS ML 服务和第三方服务提供管理 ML 管道的标准接口。解决方案模板允许您上传训练好的模型，配置管道的编排，并监控管道操作。它允许您利用预先配置的 ML 管道，还可以自动部署带有推理端点的训练模型。
如何设置新项目:
- 登录您的 AWS 帐户
- 创建新的 pagemaker 工作室
- 创建新项目
- 选择所需的 MLOps 架构(开发、评估或部署)。
- 将数据添加到 AWS S3 时段
- 创建管道和培训文件。
查看此文档了解如何建立一个新项目。你也可以看看这篇关于如何创建一个简单项目的教程。
Azure MLOps 允许您通过端到端的沿袭跟踪来试验、开发和将模型部署到生产中。它允许您创建可复制的 ML 管道，可重用的软件环境，从任何地方部署模型，管理 ML 生命周期，并密切监视生产中的模型的任何问题。它允许您使用管道自动化端到端的 ML 生命周期，这允许您更新模型、测试新模型，并持续部署新的 ML 模型。
设置
装置
你需要安装 Azure CLI
如何:
- 登录到 Azure devops
- 创建新项目
- 导入项目存储库
- 设置项目环境
- 创建管道
- 培训和部署模型
- 设置持续集成管道
查看此文档了解如何进行这些流程
Vertex AI 是一个机器学习平台，你可以在一个地方访问所有的谷歌云服务，以部署和维护 AI 模型。它将构建 ML 的 Google 云服务整合在一个统一的 UI 和 API 下。您可以使用 Vertex AI 通过 AutoML 或您的自定义代码轻松训练和比较模型，并将所有模型存储在一个中央模型库中。
设置
装置
你可以使用谷歌云控制台和云外壳，或者在你的系统中安装 T2 云软件开发工具包。
如何创建新项目(使用云壳):
- 登录您的账户
- 创建新项目(确保为您的帐户启用了计费)
- 激活云壳
- 创建一个存储桶
- 训练你的模型
- 部署到谷歌云
查看此文档以获得如何遵循这些步骤的演练。
NLP 项目的 MLOps 即服务工具—比较
| 数据收集和管理 | 数据准备和特征工程 | 模型培训和部署 | 模型监控和实验跟踪 | ML 元数据存储 | 模型注册和管理 | |
|---|---|---|---|---|---|---|
结论
我已经谈到了为什么您需要 MLOps，以及如何为您的项目选择一个好的工具。我还列出了一些 NLP MLOps 工具，并强调了一些很酷的特性。不确定要试用哪种工具？查看我做的对照表，看看哪个最适合你的项目。我希望你尝试一些列出的工具，并让我知道你的想法。感谢阅读！
附加参考
Additional references
MLOps 与 AIOps–有什么区别？
原文：https://web.archive.org/web/https://neptune.ai/blog/mlops-vs-aiops-differences
当我们作为一个团队来构建一个产品或服务时，我们需要遵循特定的步骤，以一种系统的、有组织的、有成本效益的方式来生产高质量的软件。许多框架可以帮助我们做到这一点，通常有相似的阶段(从需求引出到产品中的维护)。
一些框架是为独立工作的多个团队设计的，这会增加风险和延迟。为了跟上不断增长的需求并避免延误，我们希望摆脱封闭的孤岛。在 DevOps 模型下，我们可以合并两个或更多的团队，专注于持续集成和部署，使沟通更好，部署更快，并且安全——牢不可破。如果你使用的是敏捷软件开发，DevOps 是免费的。
我们现在已经在常规软件开发中使用 DevOps 有一段时间了，但我们也可以将它用于机器学习和人工智能。
我们为什么需要 DevOps？在 DevOps 之上分层机器学习和人工智能背后的原因是什么？ML Ops 和 AI Ops 有什么区别？请继续阅读，寻找答案。
什么是 MLOps？
许多行业将机器学习系统集成到他们现有的产品和服务中，因为 ML 对底线有好处，它可以增强你的竞争优势。
问题是机器学习过程很复杂，通常需要大量的时间和资源。为了避免超支，公司需要一个框架来统一 ML 系统的开发和部署。MLOps 就是这个框架。它标准化并简化了 ML 模型到产品的连续交付。
在探讨为什么需要使用 MLOps 之前，我们先来看看机器学习建模生命周期，了解一下重点是什么。
机器学习模型的生命周期
ML 项目从定义业务用例开始。一旦定义了用例，就采取以下步骤来将机器学习解决方案部署到生产中:
- 数据提取–整合各种来源的数据
- 探索性数据分析–了解底层数据及其属性
- 数据准备–为成功执行 ML 解决方案管理数据
- 创建 ML 模型/解决方案–使用 ML 算法创建和训练 ML 模型
- 模型评估和验证–根据测试数据集计算模型并验证性能
- 模型部署–在生产中部署 ML 模型
构建和处理 ML 系统是一个手工过程，大规模管理这样的系统并不容易。许多团队都在为部署和管理 ML 解决方案的传统手动方式而奋斗。
基于 DevOps 的 ML 分层–克服挑战
为了解决机器学习系统的手动实现和部署问题，团队需要采用现代实践，以便更容易高效地创建和部署企业应用程序。
MLOps 利用了与 DevOps 相同的原理，但是多了一层 ML 模型/系统。
建模代码、依赖性和任何其他运行时需求可以被打包以实现可再现的 ML。可重现的 ML 将有助于降低打包和维护模型版本的成本(给你权力来回答任何模型在其历史中的状态问题)。此外，由于它已经打包，大规模部署将容易得多。这一再现性步骤是 MLOps 旅程中的几个关键步骤之一。–尼尔分析
交付 ML 系统的传统方式在许多企业中很常见，尤其是当他们刚刚开始使用 ML 时。当模型很少改变时，手工实现和部署就足够了。模型在应用于现实世界数据时可能会失败，因为它无法适应环境或数据的变化。
MLOps 工具集
MLOps 框架提供了部署、管理和监控所有模型的单一位置。总的来说，这些工具简化了复杂的过程，节省了大量时间。市场上有几种工具可以提供相对相似的服务:
- 版本控制–跟踪数据集、特性及其转换中的任何变化。
- 跟踪模特训练–监控模特在训练中的表现
- 超参数整定–列车模型自动使用一组最优超参数。
- 模型部署–将机器学习模型部署到生产中。支票
- 模型监控–跟踪和管理部署到生产中的机器学习模型
在选择任何 MLOps 工具时，以上特性都值得在选择前考虑。企业也可能对允许免费试用的提供商感兴趣。让我们来看看几个 MLOps 工具:
- 亚马逊 Sage Maker–】亚马逊 Sage Maker 通过汇集一系列专门为机器学习构建的功能，帮助数据科学家和开发人员快速准备、构建、训练和部署高质量的机器学习(ML)模型
它通过提供自动驾驶仪来加速部署过程，自动驾驶仪可以为预测选择最佳算法，并可以自动构建、训练和调整模型。
- Neptune–】Neptune 帮助在一个地方维护模型构建元数据。记录、存储、显示、组织、比较和查询您所有的 MLOps 元数据。它专注于为运行大量实验的研究和生产团队构建的电子实验跟踪和模型注册。”
Neptune 专注于 ML 元数据的日志记录和存储，这使得查询数据以便以后分析变得更加容易。
Neptune 将 ML 元数据分为三个不同的领域:
- 实验和模型训练数据—这允许用户记录不同的指标、超参数、学习曲线、预测、诊断图表等。
- 工件元数据–这包含关于数据的信息，例如数据集的路径、特征细节、大小、最后更新的时间戳、数据集预览等。
- 模型元数据—模型元数据包含诸如谁创建或训练了模型、作为建模一部分的训练和实验的链接、多个数据集细节等信息。
以上捕获的数据稍后可用于:
- 实验追踪–使用 Neptune，团队可以对不同团队成员运行的 ML 实验有一个整体的看法。团队可以轻松维护和显示各种指标，帮助他们比较不同的 ML 实验性能。
- 模型注册表–模型注册表帮助用户了解 ML 包的结构，以及模型的创建者和创建时间等细节。团队可以轻松跟踪源、数据集和配置等方面的任何变化。Neptune 允许您对模型构建过程中产生的大部分元数据进行版本化、显示和查询。
Neptune 提供了一个易于使用的仪表板显示，用户可以轻松地对数据进行排序、过滤和查询。它让开发人员专注于模型构建，并负责所有的簿记工作。
点击此处查看仪表板示例。
- data robot–“data robot MLOps 为你的生产 AI 提供了一个卓越的中心。这为您提供了一个单一的位置来部署、监控、管理和治理您生产中的所有模型，而不管它们是如何创建的或者是何时何地部署的。”
在 DataRobot 中，用户可以导入使用不同语言和在其他可用的 ML 平台上构建的模型。然后在领先的 ML 执行环境中测试和部署模型。DataRobot 使用报告和警报系统监控服务运行状况、数据漂移和准确性。
- ML flow–】ML flow 是一个管理 ML 生命周期的开源平台，包括实验、可复制性、部署和中央模型注册。
MLflow 有四个主要组件:
- ML 流跟踪—ML 流跟踪组件是围绕代码执行的概念组织的。每个执行记录都包含信息，比如代码版本、开始和结束时间、代码源、输入参数、性能指标和输出文件工件。
- MLflow 项目—ml flow 项目提供了一种打包机器学习代码的便捷方式。每个项目都是一个简单的存储库，包含运行项目的多个文件和属性，例如项目名称、入口点和环境、库依赖项等。
- ml flow models–ml flow format 定义了一种标准格式，允许您以不同的风格保存模型，如 python-function、PyTorch、sklearn，它可以在不同的平台上使用，没有任何麻烦。
- MLflow Registry—ml flow 模型注册表是一个集中的位置，用于协作管理 ml flow 模型的生命周期。它有一套 API 和 UI 来注册模型，监控版本和阶段转换。开发人员可以通过提供对团队有用的描述和任何相关信息来轻松地注释这些模型。
在这些组件的帮助下，团队可以跟踪实验，并遵循标准的方式来打包和部署模型。这使得生成可重用的代码变得容易。MLflow 提供了一个集中的地方来管理模型的整个生命周期。
- kube flow–“kube flow 项目致力于使在 Kubernetes 上部署机器学习(ML)工作流变得简单、可移植和可扩展。我们的目标不是重新创建其他服务，而是提供一种简单的方法来将 ML 的最佳开源系统部署到不同的基础设施上。无论你在哪里运行 Kubernetes，你都应该能够运行 Kubeflow。”
Kubeflow 是一个帮助在 Kubernetes 上分层 ML 组件的平台。
Kubeflow 提供了许多组件，这些组件可以作为独立的服务使用，也可以组合使用
- 笔记本服务器—kube flow 笔记本有助于轻松与其他组件集成，并且易于共享，因为用户可以直接在集群中创建笔记本容器或单元。
- 管道—kube flow 管道平台由一个用户界面组成，用于管理和跟踪实验。在管道的帮助下，用户可以安排多步 ML 工作流和 Python 支持来操作管道和工作流。
- KFServing–KFServing 在 Kubernetes 上提供无服务器推理，并通过自动处理来自用户的复杂流程来封装它们。
- Katib–Katib 有助于优化用任何编程语言编写的应用程序的超参数。这是一个自动化的过程，在每次调优中会运行几个培训任务。支持 PyTorch、XGBoost、TensorFlow 等 ML 框架。
- 训练操作员—kube flow 支持使用 TensorFlow、PyTorch、MXNet、MPI 等不同框架对机器学习模型进行分布式训练。
- 多租户–kube flow 支持不同团队共享资源池，同时保证他们个人工作的安全。
- Azure****ML–“通过业界领先的 MLOps(机器学习操作，即机器学习的 DevOps)加快上市时间。在一个安全可信的平台上创新，专为负责任的机器学习而设计。”
Azure ML 是一个基于云的服务，用于创建和管理机器学习模型流。Azure ML 结合 Azure DevOps 有助于实现持续集成(CI)、持续交付(CD)和人工智能应用的再培训管道。
一个典型的 Azure MLOps 架构可以组合 Azure ML、Azure pipelines、容器注册表、容器实例、Kubernetes 或应用性能洞察等组件。
AIOps
根据 Gartner 的调查，一般企业 IT 基础架构每年生成的 IT 运营数据要多 2 到 3 倍。传统的 IT 管理解决方案无法处理如此大的数据量，也无法妥善解决问题。
企业需要一种自动化的解决方案，能够在出现重大风险时提醒 IT 人员。一个系统可以告诉他们哪里出了问题，并自行解决重复性问题，而不是由员工手动监控流程。
“ai ops结合大数据和机器学习来自动化 IT 运营流程，包括事件关联、异常检测和因果关系确定。”
在 AIOps 的帮助下，企业可以设计一个能够跨不同环境关联数据的解决方案。一个能够为 IT 运营团队提供实时洞察和预测分析的解决方案，帮助 IT 团队高效地应对问题并满足用户期望。
Gartner 预测，对于大型企业来说，专门使用 AIOps 和数字体验监控工具来监控应用和基础设施的比例将从 2018 年的 5%上升到 2023 年的 30%。
AIOps 的核心要素
AIOps 的定义是动态的，因为每个企业都有不同的需求，并相应地实施 AIOps 解决方案。人工智能解决方案的重点是有效地发现实时问题并做出反应。AIOps 的一些核心元素可以帮助企业在 IT 运营中实现 AI 解决方案。
- 机器学习-ai ops 或 IT 分析是关于寻找模式的。在机器学习的帮助下，我们可以应用机器的计算能力来发现 IT 数据中的这些模式。
- 异常检测–正常系统行为的任何变化都可能导致停机、系统无响应以及糟糕的客户体验。使用 AIOps，可以检测任何类型的异常行为或活动。
- 预测性洞察–ai ops 为 IT 运营带来了可预测性。它可以帮助 It 人员在问题发生前主动捕捉问题，并最终减少服务台票证的数量。
- 自动化根本原因分析—仅仅推动洞察是不够的。企业或 IT 团队也应该能够采取行动。在传统的管理环境中，IT 人员会监控系统，并在需要时采取措施。由于 IT 基础架构问题越来越多，员工很难按时管理和解决问题。当涉及多个系统时，需要花费大量时间来分析根本原因。有了 AIOps，根本原因可以在后台自动完成。
AI 在 DevOps 上分层
"AppDynamics就应用性能监控和 AIOps 调查了 6000 名全球 IT 领导者。"
IT 运营和开发运营的人工智能是两个独立的功能，但当它们结合在一起时，可以帮助增强系统的功能。管理 DevOps 环境可能很复杂。想象一下，通过大量数据来搜索触发事件的原因。团队最终会投入数小时。许多问题可能是已知的，有些可能是新的或与以前的事件相关。这种事件可以被自动识别和解决。
DevOps 是一种向客户/市场提供服务和产品的商业方法，人工智能可以帮助精确高效地简化测试、编码、发布和监控产品。
“IDC 预测，定制应用开发服务的全球市场预计将从 2018 年的 470 亿美元增长到 2023 年的 610 亿美元以上，五年内实现 5.3%的复合年增长率(CAGR)。”随着这些不断增长的需求，传统的 it 运营或开发管理将无法满足这些需求。
通过提高准确性、质量和可靠性，基于 DevOps 的人工智能将把传统的开发管理提升到另一个层次。据福布斯报道，“自动建议代码段，通过自动化测试改进软件质量保证技术，以及简化需求管理是 AI 今天为 DevOps 提供价值的核心领域。
AIOps 工具集
AIOps 工具消费来自各种服务的数据。他们收集应用程序日志，测量系统运行状况或性能，最终打破孤立的 IT 信息问题，并弥合软件、硬件和云之间的问题。
- dyna trace–“dyna trace ai ops 平台重新定义了绩效监控，让您的团队专注于主动行动、创新和更好的业务成果。”
Dynatrace 通过根本原因分析、事件关联和映射到云环境等应用程序来帮助 IT 运营，以支持持续自动化。动态跟踪函数可分为以下几类:
- 智能可观察性—使用上下文信息、人工智能和自动化的高级可观察性。了解问题的全部背景，并在精确的根本原因分析后提供可行的答案。
- 持续自动化–部署、配置和管理的人工努力不值得。Dynatrace 主动识别问题，并根据对用户和业务的影响确定问题的严重性。它帮助团队实现持续的发现、轻松的部署和自动的依赖映射。
- AI-assistance—执行无故障分析，进行根本原因分析。分析精确且可重复。人工智能引擎是 Dynatrace 各个方面的一部分。
- app dynamics–】app dynamics 有助于优先考虑对您的业务和员工最重要的事情，以便您可以实时查看、分享和采取行动。通过更深入地了解用户和应用行为，将性能转化为利润。”
它有不同的性能度量类别，有助于将不同类别的这些指标关联起来，以便在问题影响业务之前解决问题。它用于人工智能驱动的应用程序性能管理。
- 用户—监控任何设备、浏览器或第三方服务的关键指标，以主动识别最终用户问题。
- 应用–通过将影响业务关键绩效指标的代码的端到端可观察性联系起来，统一 IT 团队和业务。
- 基础设施–它有助于您关注底线。通过混合基础架构更智能地扩展，并创建主动基础架构。
- 网络—监控任何网络上的数字体验。用户可以将应用程序性能与网络相关联，以确定由网络中断引起的应用程序问题。
- BMC Helix–】BMC 解决方案将机器学习和高级分析部署为整体监控、事件管理、容量和自动化解决方案的一部分，以交付 AIOps 用例，帮助 IT 运营以数字业务要求的速度运行
BMC Helix 是用于运营管理的 BMC 产品。它帮助团队主动提高系统的可用性和性能。Helix 专注于服务监控、事件管理和可能原因分析。
BMC 产品可以帮助协调事件补救、智能票据解决、自动化变更和事件管理等工作流程。
- service Now–Now 平台–“Now 平台提供跨企业的数字化工作流，将人员、职能和系统连接起来，以加速创新、提高灵活性和生产力。”
它通过释放人工智能的力量，帮助团队更快、更智能地工作。Now 平台支持高效数字化工作流程的核心功能包括:
- 流程优化—Now platform 通过提供每个系统如何相互连接以及如何影响其他系统的清晰画面，最大限度地提高了整个企业的效率。一旦确定了问题，就有助于改进流程并对其进行监控。
- 性能分析—观察趋势，在瓶颈出现之前发现瓶颈，并根据需要提高性能。
- 预测智能–虽然现在平台使用机器学习来自动化日常任务并更快地解决问题，但团队可以专注于更有意义的工作。使用 ML 对事件进行分类，推荐解决方案，并主动标记任何关键问题。
- integration hub—integration hub 允许用户将 Now 平台与其他 ServiceNow 服务以及现成的辐条相集成。它有助于降低集成成本，提高团队的生产力。
- 虚拟代理–Now 平台提供了一个人工智能驱动的对话聊天机器人，以帮助团队和最终用户更快地解决问题。
- AI 搜索—利用语义搜索能力，提供精准、个性化的答案。
- 配置管理数据库—提供对您 IT 环境的可见性，以便做出更好的决策。在整个数字生命周期中连接产品，帮助团队了解影响和风险。
- IBM Watson AIOps–“Watson AI ops 是一款 AI ops 解决方案，它在 ITOps 工具链中部署了先进的、可解释的人工智能，因此您可以自信地评估、诊断和解决任务关键型工作负载中的事件。”
Watson AIOps 经过训练，能够实时连接数据源和常见 IT 行业工具之间的点。这有助于快速检测和识别问题，并通过 AIOps 和 ChatOps 转变 IT 运营。
Watson AIOps 采用一组指标、日志和事故相关数据来训练和构建无人监管的模型。这是一个 ChatOps 模型需要不断训练，以提高解决问题的准确性。
- Splunk–"Splunk 是唯一一款跨混合云环境提供端到端服务监控、预测性管理和全栈可见性的 AIOps 平台
Splunk 可以通过以下方式帮助您实现 IT 现代化:使用预测分析防止停机、简化事件解决方案，以及关联不同服务的指标以确定根本原因。
Splunk 的 在与领域无关、以服务为中心的 AIOps 方面的创新为运营团队中的每个人提供了扩展能力和工作效率，以实现更快的补救时间。
MLOps vs AIOps
从上面的解释中，可以清楚地看到这是两个不同的领域，彼此并不重叠。但是，人们经常混淆 MLOps 和 AIOps。困惑时，请记住:
- AIOps 是借助 ML 和大数据实现系统自动化的一种方式，
- MLOps 是一种标准化部署 ML 系统和填补团队之间的差距的方法，使所有项目利益相关者更加清晰。
在详细讨论差异之前，我们先来看一下 MLOps 和 AIOps 之间的比较:
| MLOps | AIOps |
|---|---|
规范 ML 系统开发流程
|
自动化 IT 运营和系统
|
|
提高团队的效率和生产力
|
自动化根本原因分析和解决
|
|
精简不同团队之间的协作
|
高效处理和管理大量数据
|
|
这是以可重复的方式大规模部署人工智能和数据科学的关键部分
|
它利用革命性的人工智能技术解决 It 挑战
|
|
–多源数据消耗 rn–源代码控制 rn–部署和测试服务–使用元数据跟踪 ML 模型 rn–自动化 ML 实验 rn–降低模型验证中的风险和偏差
|
–应用监控–自动化手动或重复流程 rn–异常检测 rn–预测性维护 rn–事件管理
|
AI Ops，或者说“IT 运营的人工智能”在一个方面与 MLOps 相反——它是 ML 对 DevOps 的应用，而不是 DevOps 对 ML 的应用。
现在让我们看看不同的用例以及实现 MLOps 和 AIOps 的好处。
MLOps 的优势
如上所述，MLOps 专注于创建可扩展的 ML 系统。让我们讨论一下它与开发 ML 系统的传统方式有何不同，以及为什么 MLOps 很重要。
1。多个管道的协调
机器学习模型开发是不同管道的组合(预处理、特征工程模型、模型验证等)。MLOps 可以帮助您编排这些管道来自动更新模型。
2。管理 ML 生命周期
模型开发有不同的步骤，使用传统的 DevOps 进行管理和维护可能会很有挑战性。MLOps 提供了在生产中快速优化和部署 ML 模型的优势。
3。扩展 ML 应用程序
当数据和使用增加时，真正的问题出现了，这会导致 ML 应用程序失败。借助 MLOps，当需求增加时，可以扩展 ML 应用。
4。监控 ML 系统
部署机器学习模型后，监控系统的性能至关重要。MLOps 通过启用模型和数据漂移的检测来提供方法。
5。持续集成和部署
DevOps 在软件开发中使用持续集成和部署，但是在 ML 系统的开发中使用同样的方法是困难的。MLOps 已经引入了不同的工具和技术，在这些工具和技术中，可以利用 CI 和 CD 来成功地部署机器学习系统。
MLOps 的真实使用案例
- 网络分析——美国电话电报公司比特币基地
- 推荐系统——OTT 和电子商务平台——这是一种基于用户行为并影响这些行为的推荐系统。在这种情况下，监控预测对于避免连锁反应至关重要。
- 彭博股票市场分析
- 体育分析——ESPN，天空体育
AIOps 的优势
AIOps 与 MLOps 有不同的使用案例和优势，因为它利用机器学习技术来改善 it 运营。
1。前瞻性 IT 运营
在竞争环境中，产品和服务的成功取决于客户的满意度。对一个问题做出反应是不够的，但是预测是否会发生失败也是至关重要的。It 运营必须能够预测和修复应用程序、系统和基础架构的问题。
2。数据驱动的决策制定
AIOps 在 IT 运营中使用 ML 技术，如模式匹配、历史数据分析和预测分析。使用这些 ML 技术，决策将完全由数据驱动，并将减少人为错误。这种自动响应将使 IT 运营专注于解决问题，而不是检测根本原因。
3。检测异常和偏离基线
使用像聚类这样的 ML 技术，IT 运营可以检测异常行为。AIOps 帮助构建这些监控技术，这些技术可用于网络流量的异常检测，并自动修改防火墙规则。
- 预测警报:Place Park 技术和 TDC 网络设计
- 避免服务中断:舍弗勒集团
- 正确监控系统:Enablis
- 事件的蓝图和分类:PostNord AB
结论
在本文中，我们了解了什么是 MLOps 和 AIOps，以及公司如何使用它们来创建有效的、可伸缩的和可持续的系统。我希望你现在明白这两者之间的区别，以及它们可以用在哪里。
虽然 AIOps 主要用于实时处理应用数据，但 MLOps 工具可以监控类似的数据，以构建机器学习模型。这些工具可以同时用于需要这两种功能集的企业。”–信任半径
感谢阅读！
MLOps:它是什么，为什么重要，以及如何实施
原文：https://web.archive.org/web/https://neptune.ai/blog/mlops
这是什么东西？
这是我脑海中的问题，但直到最近(我在 2020 年末写这篇文章)，我只在大型人工智能会议上听说过几次 MLOps，我在多年来阅读的论文中看到一些提及，但我不知道任何具体的东西。
有趣的是，大约在同一时间，我和一位在非洲莫桑比克工作的数据挖掘专家朋友进行了一次谈话。最近，他们开始创建自己的内部 ML 管道，巧合的是，我在对 MLOps 的神秘领域进行研究以将所有东西放在一个地方的同时，也开始写这篇文章。
在这一转变中，我了解到了传统公司(以及许多从事商业 ML 的科技公司)面临的许多棘手问题:
- 向云迁移；
- 创建和管理 ML 管道；
- 缩放；
- 大规模处理敏感数据；
- 以及无数其他问题。
因此，我把深入研究、进行广泛研究和尽可能多地学习作为我的职责，同时写下我自己的笔记和想法。
结果就是这篇文章。
但是为什么现在要研究这个话题呢？
据 techjury 报道，2020 年，每个人每秒至少创建 1.7 MB 的数据。对于像你我这样的数据科学家来说，这就像是提前过圣诞节，因为有太多的理论/想法需要探索、实验，有太多的发现和模型需要开发。
但是，如果我们想要认真对待，并让这些模型真正触及现实生活中的业务问题和真实的人，我们必须处理一些基本问题，如:
- 获取和清理大量数据；
- 为实验和模型训练运行设置跟踪和版本控制；
- 为投入生产的模型建立部署和监控管道。
我们需要找到一种方法来扩展我们的 ML 操作，以满足我们的 ML 模型的业务和/或用户的需求。
在过去，当我们需要扩展传统的软件系统以便更多的人可以使用它们时，也存在类似的问题。DevOps 的解决方案是一套开发、测试、部署和操作大规模软件系统的实践。有了 DevOps，开发周期变得更短，部署速度加快，系统发布变得可审计和可靠。
这就把我们带到了 MLOps 。它诞生于 DevOps 、数据工程、、机器学习的交汇点，与 DevOps 、是类似的概念但执行不同。ML 系统本质上是实验性的，并且有更多的组件，这些组件的构建和操作要复杂得多。
让我们开始吧！
什么是 MLOps？
MLOps (机器学习运营)是数据科学家和运营专业人员之间协作和沟通的一套实践。应用这些实践可以提高质量，简化管理流程，并在大规模生产环境中自动部署机器学习和深度学习模型。更容易将模型与业务需求以及法规要求结合起来。
MLOps 正在慢慢发展成为 ML 生命周期管理的独立方法。它适用于整个生命周期——数据收集、模型创建(软件开发生命周期、持续集成/持续交付)、编排、部署、健康、诊断、治理和业务指标。
MLOps 的关键阶段是:
- 数据采集
- 数据分析
- 数据转换/准备
- 模型培训和开发
- 模型验证
- 模型服务
- 模型监控
- 模特再培训。
DevOps 与 MLOps
DevOps 和 MLOps 有着基本的相似之处，因为 MLOps 原则源自 DevOps 原则。但是它们在执行上有很大的不同:
-
与 DevOps 不同， MLOps 本质上更具实验性。数据科学家和 ML/DL 工程师必须调整各种功能——超参数、参数和模型——同时还要跟踪和管理数据和代码库，以获得可重复的结果。除了所有的努力和工具，ML/DL 行业仍然在与实验的可重复性作斗争。这个主题超出了本文的范围，所以要了解更多信息，请查看参考资料最后的再现性小节。
-
混合团队的组成:在产品中构建和部署模型所需的团队不会只由软件工程师组成。在 ML 项目中，团队通常包括数据科学家或 ML 研究人员，他们专注于探索性数据分析、模型开发和实验。他们可能不是有经验的软件工程师，无法构建产品级的服务。
-
测试:测试一个 ML 系统包括模型验证，模型训练等等——除了常规的代码测试，比如单元测试和集成测试。
-
自动化部署:你不能仅仅将离线训练的 ML 模型作为预测服务来部署。您将需要一个多步骤的管道来自动重新训练和部署模型。这种管道增加了复杂性，因为您需要在部署之前自动执行数据科学家手动执行的步骤，以训练和验证新模型。
-
由于不断发展的数据配置文件或简单的培训服务偏差导致的系统生产性能下降:生产中的 ML 模型可能会降低性能，这不仅是因为次优编码，还因为不断发展的数据配置文件。与传统的软件系统相比，模型会以更多的方式衰退，您需要为此做好计划。这可能是由以下原因造成的:
- 培训管道和服务管道中数据处理方式的差异。
- 训练和服役期间的数据变化。
- 反馈循环-当您选择错误的假设(即目标)进行优化时，这使您收集有偏差的数据来训练您的模型。然后，在不知道的情况下，你使用这个有缺陷的假设收集新的数据点，它被反馈回来重新训练/微调模型的未来版本，使模型更加偏向，雪球越滚越大。更多信息请阅读 Fastbook 关于机器学习固有的限制的章节。
- 监控:需要对生产中的模型进行监控。类似地，需要监控构建模型的数据的汇总统计，以便您可以在需要时刷新模型。这些统计数据会随着时间的推移而改变，当值偏离您的预期时，您需要通知或回滚过程。
当涉及到源代码控制的持续集成、单元测试、集成测试以及软件模块或软件包的持续交付时，MLOps 和 DevOps 是相似的。
然而，在 ML 中有一些显著的区别:
- 持续集成 (CI)不再仅仅是测试和验证代码和组件，还包括测试和验证数据、数据模式和模型。
- 持续部署 (CD)不再是关于一个单独的软件包或服务，而是一个系统(一个 ML 训练管道)，它应该自动部署另一个服务(模型预测服务)或从一个模型回滚变更。
- 连续测试 (CT)是一个新的特性，是 ML 系统独有的，它涉及到自动重新训练和服务模型。
End-to-end machine learning platform | Source
MLOps vs 实验跟踪 vs ML 模型管理
我们已经定义了什么是 MLOps，那么实验跟踪和 ML 模型管理呢？
实验跟踪
实验跟踪是 MLOps 的一部分(或过程),重点是收集、组织和跟踪具有不同配置(超参数、模型大小、数据分割、参数等)的多次运行的模型训练信息。
如前所述，因为 ML/DL 本质上是实验性的，我们使用实验跟踪工具来对不同公司、团队或团队成员创建的不同模型进行基准测试。
模型管理
为了确保 ML 模型是一致的，并且所有的业务需求在规模上得到满足，一个逻辑的、易于遵循的模型管理策略是必不可少的。
MLOps 方法包括简化模型培训、打包、验证、部署和监控的流程。通过这种方式，您可以从端到端一致地运行 ML 项目。
通过为模型管理设置清晰、一致的方法，组织可以:
- 主动解决常见的业务问题(如法规遵从性)；
- 通过跟踪数据、模型、代码和模型版本，实现可复制的模型；
- 以可重复的配置打包和交付模型，以支持可重用性。
为什么 MLOps 很重要？
MLOps 是基础。机器学习帮助个人和企业部署解决方案，通过创建更高效的工作流、利用数据分析进行决策和改善客户体验来释放以前未开发的收入来源、节省时间和降低成本。
如果没有一个坚实的框架可以遵循，这些目标是很难实现的。借助 MLOps 实现模型开发和部署的自动化意味着更快的上市时间和更低的运营成本。它帮助管理人员和开发人员在决策时更加敏捷和更具战略性。
MLOps 作为一张地图，指导个人、小团队甚至企业实现他们的目标，而不管他们的限制是什么，敏感数据、更少的资源、小预算等等。
你决定你想要多大的地图，因为 MLOps 是实践，不是写在石头上的。您可以尝试不同的设置，只保留适合您的设置。
MLOps 最佳实践
起初，我想只列出 10 个最佳实践，但是经过一些研究，我得出结论，最好涵盖 ML 管道的不同组件的最佳实践，即:团队、数据、目标、模型、代码和部署。
以下列表摘自参考文献中提到的各种来源:
组
数据
目标(指标和 KPI)
模型
密码
部署
这些最佳实践将作为您构建 MLOps 解决方案的基础，也就是说，我们现在可以深入实施细节了。
如何实现 MLOps
根据 Google 的说法，有三种方法可以实现 MLOps:
- MLOps 级别 0(手动流程)
- MLOps 级(ML 管道自动化)
- MLOps 二级(CI/CD 管道自动化)
MLOps 级别 0
这对于刚刚开始 ML 的公司来说是典型的。如果您的模型很少被更改或训练，一个完全手工的 ML 工作流和数据科学家驱动的过程可能就足够了。
特性
- 手动、脚本驱动、交互流程:每一步都是手动的，包括数据分析、数据准备、模型训练、验证。它需要手动执行每个步骤，并从一个步骤手动转换到另一个步骤。
- ML 和运营之间的脱节:该流程将创建模型的数据科学家和为模型提供预测服务的工程师分开。数据科学家将一个经过训练的模型作为工件交给工程团队部署到他们的 API 基础设施上。
- 不频繁的发布迭代:假设您的数据科学团队管理一些不经常更改的模型，要么更改模型实现，要么用新数据重新训练模型。新的模型版本每年只部署几次。
- 无持续集成(CI): 因为很少假设实现变化，所以忽略 CI。通常，测试代码是笔记本或脚本执行的一部分。
- 无持续部署(CD): 因为没有频繁的模型版本部署，所以不考虑 CD。
- 部署是指预测服务(即带有 REST API 的微服务)
- 缺乏主动的性能监控:流程不跟踪或记录模型预测和行动。
工程团队可能有自己复杂的 API 配置、测试和部署设置，包括安全性、回归和 load + canary 测试。
挑战
实际上，模型在现实世界中部署时经常会崩溃。模型无法适应环境动态的变化或描述环境的数据的变化。《福布斯》在这方面有一篇很棒的文章:为什么机器学习模型在生产中崩溃和烧毁。
为了应对这一手动流程的挑战，最好对 CI/CD 和 CT 使用 MLOps 实践。通过部署 ML 培训管道，您可以启用 CT，并且可以设置 CI/CD 系统来快速测试、构建和部署 ML 管道的新实现
MLOps 一级
MLOps 级的目标是通过自动化 ML 管道来执行模型的连续训练(CT)。这样，您就实现了模型预测服务的持续交付。
这种场景可能有助于在不断变化的环境中运行并需要主动应对客户行为、价格和其他指标变化的解决方案。
特性
- 快速实验 : ML 实验步骤被编排并自动完成。
- 生产中模型的 CT:模型在生产中自动训练，使用基于实时管道触发器的新数据。
- 实验-操作对称:在开发或实验环境中使用的流水线实现在预生产和生产环境中使用，这是 MLOps 实践统一 DevOps 的一个关键方面。
- 组件和管道的模块化代码:为了构建 ML 管道，组件需要可重用、可组合，并且可能跨 ML 管道共享(即使用容器)。
- 模型的连续交付:模型部署步骤是自动化的，该步骤将经过训练和验证的模型作为在线预测的预测服务。
- 管道部署:在第 0 级中，您将一个经过训练的模型作为预测服务部署到生产中。对于级别 1，您将部署一个完整的训练管道，该管道会自动循环运行，以作为预测服务为已训练的模型提供服务。
附加组件
- 数据和模型验证:管道期望新的实时数据产生基于新数据训练的新模型版本。因此，在生产管道中需要自动化的数据验证和模型验证步骤。
- 特性存储:特性存储是一个集中的存储库，在这里您可以标准化特性的定义、存储和访问，以便进行培训和服务。
- 元数据管理:记录关于 ML 管道的每次执行的信息，以帮助数据和工件的传承、可再现性和比较。它还可以帮助您调试错误和异常
- ML 管道触发器:根据您的使用情况，您可以自动化 ML 生产管道，用新数据重新训练模型:
- 按需
- 按照时间表
- 关于新训练数据的可用性
- 论模型性能退化
- 数据分布的重大变化(不断发展的数据概况)。
挑战
当您基于新数据而不是基于新的 ML 思想部署新模型时，这种设置是合适的。
然而，您需要尝试新的 ML 思想，并快速部署 ML 组件的新实现。如果您在生产中管理许多 ML 管道，那么您需要一个 CI/CD 设置来自动化 ML 管道的构建、测试和部署。
MLOps 二级
为了快速可靠地更新生产中的管道，您需要一个强大的自动化 CI/CD 系统。借助这一自动化 CI/CD 系统，您的数据科学家可以快速探索有关特征工程、模型架构和超参数的新想法。
这一级别适合技术驱动型公司，这些公司必须每天(如果不是每小时)重新培训他们的模型，在几分钟内更新它们，并同时在数千台服务器上重新部署。如果没有端到端的 MLOps 周期，这样的组织将无法生存。
该 MLOps 设置包括以下组件:
- 源代码控制
- 测试和构建服务
- 部署服务
- 模型注册表
- 功能存储
- ML 元数据存储
- ML 管道编制器。
特性
- 开发和实验:你迭代地尝试新的 ML 算法和新的建模，其中实验步骤被编排。这个阶段的输出是 ML 管道步骤的源代码，然后这些源代码被推送到源存储库。
- 流水线持续集成:你构建源代码，运行各种测试。这个阶段的输出是将在稍后阶段部署的管道组件(包、可执行文件和工件)。
- 管道连续交付:您将 CI 阶段产生的工件部署到目标环境中。这个阶段的输出是一个部署了模型的新实现的管道。
- 自动触发:流水线在生产中根据时间表或响应触发自动执行。这个阶段的输出是新训练的模型，该模型被推送到模型注册处。
- 模型连续交付:你把训练好的模型作为预测的预测服务。此阶段的输出是一个已部署的模型预测服务。
- 监控:您基于实时数据收集模型性能的统计数据。这个阶段的输出是执行流水线或执行新的实验周期的触发器。
在管道开始新的实验迭代之前，数据分析步骤仍然是数据科学家的手动过程。模型分析步骤也是一个手动过程。
构建 vs 购买 vs 混合 MLOps 基础架构
云计算公司已经在基础设施和管理上投入了数千亿美元。
给你一点背景，canalys 的一份报告指出，公共云基础设施支出在 2018 年达到 778 亿美元，在 2019 年增长到 1070 亿美元。根据 IDC 的另一项研究，五年复合年增长率(CAGR)为 22.3%，预计到 2023 年云基础设施支出将增长至近 5000 亿美元。
2020 年第二季度，云基础设施服务的支出达到创纪录的 300 亿美元，亚马逊网络服务(AWS)、微软和谷歌云占客户支出的一半。
从供应商的角度来看，AWS 的市场份额保持在“长期的标志”?在 2020 年第二季度，约为 33%，其次是微软的 18%和谷歌云的 9%。与此同时，以阿里巴巴、腾讯和百度为首，中国云提供商现在占据了全球市场的 12%以上。
这些公司投资于专用硬件、软件和 SaaS 应用的研发，但也投资于 MLOps 软件。我想到了两个很好的例子:
- AWS 及其 Sagemaker，这是一个完全托管的端到端云 ML 平台，使开发人员能够在云、嵌入式系统和边缘设备中创建、训练和部署机器学习模型。
- 谷歌最近宣布了人工智能平台 Pipelines，用于建立和管理 ML 管道，利用 TensorFlow Extended (TFX)的预建组件和模板为您做了大量的模型部署工作。
现在，你应该建造还是购买你的基础设施？也许你应该去杂交？
想要长期生存的科技公司通常有自己的团队，并建立定制的解决方案。如果他们拥有解决复杂问题的技能、知识和工具，这种方法没有任何问题。但是还有其他值得考虑的因素，比如:
- 时间和努力
- 人力资源
- 获利时间
- 机会成本。
时间和努力
根据 cnvrg.io 的一项调查，数据科学家经常花费时间构建解决方案，以添加到他们现有的基础设施中，从而完成项目。他们 65%的时间花在工程繁重、非数据科学任务上，如跟踪、监控、配置、计算资源管理、服务基础架构、特征提取和模型部署。
这种浪费的时间通常被称为“隐藏的技术债务”，是机器学习团队的常见瓶颈。构建内部解决方案或维护表现不佳的解决方案可能需要 6 个月到 1 年的时间。即使您已经构建了一个正常运行的基础架构，仅仅是维护基础架构并使其与最新技术保持同步，就需要生命周期管理和专门的团队。
人力资源
实现机器学习需要大量的工程设计。为了实现顺畅的机器学习工作流，每个数据科学团队都必须有一个运营团队，该团队了解部署机器学习模型的独特要求。
投资端到端 MLOps 平台，这些流程可以完全自动化，使运营团队更容易专注于优化其基础设施。
费用
拥有一个专门的运营团队来管理模型本身就很昂贵。如果你想扩大你的实验和部署，你需要雇佣更多的工程师来管理这个过程。这是一项重大投资，找到合适的团队是一个缓慢的过程。
开箱即用的 MLOps 解决方案在构建时考虑了可扩展性，而成本只是其一小部分。在计算了与雇佣和入职整个工程师团队相关的所有不同成本后，你的投资回报率下降了，这就引出了我们的下一个因素。
获利时间
建立一个正常运行的机器学习基础设施可能需要一年多的时间。可能需要更长的时间来构建能够为您的组织创造价值的数据管道。
像优步、网飞和脸书这样的公司已经投入了多年和大量的工程努力来扩展和维护他们的机器学习平台，以保持竞争力。
对于大多数公司来说，这样的投资是不可能的，也是没有必要的。自从优步、网飞和脸书最初建立自己的内部解决方案以来，机器学习领域已经成熟。
还有更多预构建的解决方案，能够以极低的成本提供您所需的一切。比如 cnvrg.io 客户不到 1 个月就可以交付盈利的车型。数据科学家可以专注于研究和实验，为他们的业务问题提供最佳模型，而不是构建使他们的模型可操作所需的所有基础设施。
机会成本
如上所述，一项调查显示，数据科学家 65%的时间花在了非数据科学任务上。使用 MLOps 平台可以自动执行技术任务，并减少开发运维瓶颈。
数据科学家可以花时间做更多他们受雇做的事情——交付高影响力的模型——而云提供商则负责剩下的事情。
采用端到端的 MLOps 平台具有相当大的竞争优势，可以让您的机器学习开发大规模扩展。
混合 MLOps 基础架构如何？
一些公司受托管理私人和敏感数据。它不能离开他们的服务器，因为在一个小漏洞的机会，连锁反应将是灾难性的。这就是面向 MLOps 的混合云基础架构的用武之地。
目前，在大多数情况下，云基础设施与本地系统并存。
混合云管理很复杂，但通常是必要的。根据 Cloudcheckr 的《2020 年云基础设施报告》,今天的基础设施是云和本地的混合。
云基础设施越来越受欢迎，但仍然很难找到一家完全放弃内部基础设施的大公司(大多数是出于显而易见的原因，如敏感数据)。
另一项由 RightScale 进行的研究显示，混合云的采用率从 2018 年的 51%增长到了 2019 年的 58%。这是可以理解的，因为继续将基础架构保留在本地有多种原因。
为什么贵公司一直维护内部基础架构？
管理混合基础架构极具挑战性
管理任何类型的企业技术基础架构都不是一件轻而易举的事情。总会有与安全性、性能、可用性、成本等等相关的问题。
混合云环境增加了额外的复杂性，使管理 IT 变得更加困难。
绝大多数云利益相关方(96%)都面临着管理内部和云基础架构的挑战。
您的公司在管理内部和云基础架构方面面临哪些挑战？
报告的“其他”问题包括需要完全不同的技能组合，缺乏对专业计算和存储的访问。此外，必须转变现有员工的角色，让他们专门管理本地系统，并最终处理相同的持续可靠性问题(即超时、数据资源缺失、计算资源缺失、软件故障、数据库故障、硬件故障和网络故障)。
随着需求的增加，构建自己的平台和基础设施将会占据你越来越多的注意力。本可用于 model R & D 和数据收集的时间将被基础设施管理占用。除非这是你核心业务的一部分(如果你是一个云服务提供商，PaaS 或 IaaS)，否则这并不好。
购买完全托管的平台为您带来了极大的灵活性和可扩展性，但同时您也面临着合规性、法规和安全问题。
面向 MLOps 的混合云基础架构是两个世界中最好的，但它带来了独特的挑战，因此它是否适合您的业务模式取决于您。
注 :我对敏感数据的安全保护、流式传输和统计研究的未来发展方向有一些想法，但这可能是未来文章的不同主题。
结论
现在，您已经确定了贵公司所处的级别，您可以选择以下两种 MLOps 解决方案之一:
- 端到端
- 定制的 MLOps 解决方案(工具生态系统)
端到端 MLOps 解决方案
这些完全托管的服务为开发人员和数据科学家提供了快速构建、训练和部署 ML 模型的能力。顶级商业解决方案包括:
- 亚马逊 Sagemaker ，一套构建、训练、部署和监控机器学习模型的工具
- 微软 Azure MLOps 套件:
- 谷歌云 MLOps 套件:
端到端解决方案非常棒，但您也可以通过将 MLOps 管道划分为多个微服务，使用您喜欢的工具构建自己的解决方案。
这种方法可以帮助您避免单点故障 (SPOF)，并使您的管道健壮——这使您的管道更容易审计、调试，并且更加可定制。如果微服务提供商出现问题，您可以轻松更换新的微服务提供商。
SPOF 最近的一个例子是自动气象站服务中断，这非常罕见，但也有可能发生。即使是歌利亚也会倒下。
微服务确保每个服务是互联的，而不是嵌入在一起的。例如，您可以拥有用于模型管理和实验跟踪的独立工具。
最后，有许多 MLOps 工具可供使用，我将仅提及我的 7 个最佳选择和一个荣誉奖:
- 【Jupyter 项目
- Nbdev
- 气流
- Kubeflow
- MLflow
- Optuna
- 皮层
- 荣誉奖: neptune.ai (因其简单快捷的实验跟踪和兼容 Sagemaker、MLflow 等大量工具；如果没有集成指南或预构建的解决方案，您可以使用他们的 Python 客户端 API 来构建自定义集成)
通过利用这些和许多其他工具，您可以通过将各种微服务结合在一起来构建端到端的解决方案。
有关现有最佳 MLOps 工具的更多详细信息，请参见 Jakub Czakon 的最佳 MLOps 工具。
MLOps 是一个快速发展的新领域，不断有新的工具和流程出现。如果您现在就加入 MLOps，您将获得巨大的竞争优势。
为了帮助你做到这一点，下面是一吨的参考资料，供你检查和吞食。玩得开心！
承认
特别感谢我在介绍中提到的我亲爱的朋友 Richaldo Elias。他总是提出激发我创造力的话题或问题，如果没有他分享他在大规模构建 ML 项目时遇到的一些问题，这篇文章就不会一样。
参考
再现性
MLOps 最佳实践
构建 vs 购买 vs 混合
基于模型和无模型的强化学习:Pytennis 案例研究
强化学习是人工智能的一个领域，在这个领域中，你可以建立一个智能系统，通过交互从其环境中学习，并实时评估它所学习的内容。
自动驾驶汽车就是一个很好的例子，或者说 DeepMind 建立了我们今天所知的 AlphaGo、AlphaStar 和 AlphaZero。
AlphaZero 是一个旨在掌握国际象棋、日本兵棋和围棋的程序(AlphaGo 是第一个击败人类围棋大师的程序)。阿尔法星玩电子游戏星际争霸 2。
在本文中，我们将比较无模型和基于模型的强化学习。一路上，我们将探索:
- 强化学习的基本概念
a)马尔可夫决策过程/ Q 值/ Q 学习/深度 Q 网络 - 基于模型和无模型强化学习的区别。
- 打网球的离散数学方法-无模型强化学习。
- 使用深度 Q 网络的网球游戏——基于模型的强化学习。
- 比较/评估
- 参考资料了解更多信息
强化学习的基本概念
任何强化学习问题都包括以下要素:
- 代理–控制相关对象的程序(例如，机器人)。
- 环境–这以编程方式定义了外部世界。代理与之交互的一切都是环境的一部分。它是为代理人设计的，让它看起来像真实世界的案例。它需要证明一个代理的性能，意思是一旦在现实世界的应用程序中实现，它是否会做得很好。
- 奖励–这给我们一个关于算法在环境中表现如何的分数。它被表示为 1 或 0。‘1’表示策略网络做出了正确的举动，‘0’表示错误的举动。换句话说，奖励代表了得失。
- 策略–代理用来决定其动作的算法。这是可以基于模型或无模型的部分。
每个需要 RL 解决方案的问题都是从模拟代理的环境开始的。接下来，您将构建一个指导代理操作的策略网络。然后，代理可以评估该策略，看其相应的操作是否导致了收益或损失。
这项政策是我们这篇文章的主要讨论点。策略可以是基于模型的，也可以是无模型的。在构建时，我们关心的是如何通过政策梯度来优化政策网络。
PG 算法直接尝试优化策略增加奖励。为了理解这些算法，我们必须看一看马尔可夫决策过程(MDP)。
马尔可夫决策过程/ Q 值/ Q 学习/深度 Q 网络
MDP 是一个有固定数量状态的过程，它在每一步随机地从一个状态演化到另一个状态。它从状态 A 演化到状态 B 的概率是固定的。
许多具有离散动作的强化学习问题被建模为马尔可夫决策过程，代理对下一个转移状态没有初始线索。代理人也不知道奖励原则，所以它必须探索所有可能的状态，开始解码如何调整到一个完美的奖励系统。这将把我们引向我们所谓的 Q 学习。
Q-Learning 算法改编自 Q-Value 迭代算法，在这种情况下，智能体没有偏好状态和奖励原则的先验知识。q 值可以定义为 MDP 中状态动作值的最优估计。
人们经常说，Q-Learning 不能很好地扩展到具有许多状态和动作的大型(甚至中型)MDP。解决方法是近似任何状态-动作对(s，a)的 Q 值。这被称为近似 Q 学习。
DeepMind 提出使用深度神经网络，这种网络的效果要好得多，特别是对于复杂的问题——不需要使用任何特征工程。用于估计 Q 值的深度神经网络被称为深度 Q 网络(DQN)。使用 DQN 进行近似 Q 学习被称为深度 Q 学习。
基于模型和无模型强化学习的区别
RL 算法主要可以分为两类——基于模型和无模型。
基于模型，顾名思义，有一个代理试图理解它的环境，并根据它与这个环境的交互为它创建一个模型。在这样的系统中，偏好优先于行动的结果，即贪婪的代理人总是试图执行一个行动，以获得最大的回报，而不管该行动可能导致什么。
另一方面，无模型算法通过诸如策略梯度、Q-Learning 等算法，寻求通过经验学习其行为的结果。换句话说，这种算法将多次执行一个动作，并根据结果调整政策(动作背后的策略)以获得最佳回报。
可以这样想，如果代理可以在实际执行某个动作之前预测该动作的回报，从而计划它应该做什么，那么该算法就是基于模型的。而如果它真的需要执行动作来看看发生了什么并从中学习，那么它就是无模型的。
这导致了这两个类别的不同应用，例如，基于模型的方法可能非常适合下棋或产品装配线上的机器人手臂，其中环境是静态的，最有效地完成任务是我们的主要关注点。然而，在自动驾驶汽车等现实世界的应用中，基于模型的方法可能会促使汽车在更短的时间内碾过行人到达目的地(最大回报)，但无模型的方法会让汽车等到道路畅通无阻(最佳出路)。
为了更好地理解这一点，我们将用一个例子来解释一切。在示例中，我们将为网球游戏构建无模型和基于模型的 RL。为了建立这个模型，我们需要一个环境来实施政策。然而，我们不会在本文中构建环境，我们将导入一个环境用于我们的程序。
py 网球环境
我们将使用 Pytennis 环境来构建一个无模型和基于模型的 RL 系统。
网球比赛需要以下条件:
- 两个玩家意味着两个代理。
- 网球场——主要环境。
- 一个网球。
- 代理从左向右(或从右向左)移动。
Pytennis 环境规范包括:
- 有 2 名代理人(2 名球员)带着一个球。
- 有一个维度为(x，y)–( 300，500)的网球场
- 球被设计成沿直线移动，使得代理 A 决定 B 侧(代理 B 侧)的 x1 (0)和 x2 (300)之间的目标点，因此它相对于 20 的 FPS 显示球 50 次不同的时间。这使得球从起点到终点直线运动。这也适用于代理 b。
- 代理 A 和代理 B 的移动被限制在(x1= 100 到 x2 = 600)之间。
- 球的移动被限制在 y 轴上(y1 = 100 到 y2 = 600)。
- 球的移动被限制在 x 轴上(x1 = 100，到 x2 = 600)。
Pytennis 是一个模拟真实网球环境的环境。如下图，左图是无模型py tenness 游戏，右图是基于模型。
打网球的离散数学方法——无模型强化学习
为什么是“打网球的离散数学方法”？因为这个方法是 Pytennis 环境的逻辑实现。
下面的代码向我们展示了球在草坪上运动的实现。你可以在这里找到源代码。
import time
import numpy as np
import pygame
import sys
from pygame.locals import *
pygame.init()
class Network:
def __init__(self, xmin, xmax, ymin, ymax):
"""
xmin: 150,
xmax: 450,
ymin: 100,
ymax: 600
"""
self.StaticDiscipline = {
'xmin': xmin,
'xmax': xmax,
'ymin': ymin,
'ymax': ymax
}
def network(self, xsource, ysource=100, Ynew=600, divisor=50):
"""
For Network A
ysource: will always be 100
xsource: will always be between xmin and xmax (static discipline)
For Network B
ysource: will always be 600
xsource: will always be between xmin and xmax (static discipline)
"""
while True:
ListOfXsourceYSource = []
Xnew = np.random.choice([i for i in range(
self.StaticDiscipline['xmin'], self.StaticDiscipline['xmax'])], 1)
source = (xsource, ysource)
target = (Xnew[0], Ynew)
slope = (ysource - Ynew)/(xsource - Xnew[0])
intercept = ysource - (slope*xsource)
if (slope != np.inf) and (intercept != np.inf):
break
else:
continue
XNewList = [xsource]
if xsource < Xnew:
differences = Xnew[0] - xsource
increment = differences / divisor
newXval = xsource
for i in range(divisor):
newXval += increment
XNewList.append(int(newXval))
else:
differences = xsource - Xnew[0]
decrement = differences / divisor
newXval = xsource
for i in range(divisor):
newXval -= decrement
XNewList.append(int(newXval))
yNewList = []
for i in XNewList:
findy = (slope * i) + intercept
yNewList.append(int(findy))
ListOfXsourceYSource = [(x, y) for x, y in zip(XNewList, yNewList)]
return XNewList, yNewList
以下是网络初始化后的工作方式(代理 A 的网络 A 和代理 B 的网络 B):
net = Network(150, 450, 100, 600)
NetworkA = net.network(300, ysource=100, Ynew=600)
NetworkB = net.network(200, ysource=600, Ynew=100)
每个网络都以球的运动方向为界。网络 A 代表代理 A，它定义了球从代理 A 到代理 B 处沿 x 轴 100 到 300 之间的任何位置的移动。这也适用于网络 B(代理 B)。
当网络启动时。网络方法离散地为网络 A 生成 50 个 y 点(在 y1 = 100 和 y2 = 600 之间)和相应的 x 点(在 x1 和代理 B 侧随机选择的点 x2 之间)，这也适用于网络 B(代理 B)。
为了使每个代理的移动自动化，对方代理必须相对于球在相应的方向上移动。这只能通过将球的 x 位置设置为对方代理的 x 位置来实现，如下面的代码所示。
playerax = ballx
playerbx = ballx
同时，源代理必须从其当前位置移回其默认位置。下面的代码说明了这一点。
def DefaultToPosition(x1, x2=300, divisor=50):
XNewList = []
if x1 < x2:
differences = x2 - x1
increment = differences / divisor
newXval = x1
for i in range(divisor):
newXval += increment
XNewList.append(int(np.floor(newXval)))
else:
differences = x1 - x2
decrement = differences / divisor
newXval = x1
for i in range(divisor):
newXval -= decrement
XNewList.append(int(np.floor(newXval)))
return XNewList
现在，为了让代理递归地互相玩，这必须在一个循环中运行。每 50 次计数(球的 50 帧显示)后，对方球员成为下一名球员。下面的代码将所有这些放在一个循环中。
def main():
while True:
display()
if nextplayer == 'A':
if count == 0:
NetworkA = net.network(
lastxcoordinate, ysource=100, Ynew=600)
out = DefaultToPosition(lastxcoordinate)
bally = NetworkA[1][count]
playerax = ballx
count += 1
else:
ballx = NetworkA[0][count]
bally = NetworkA[1][count]
playerbx = ballx
playerax = out[count]
count += 1
if count == 49:
count = 0
nextplayer = 'B'
else:
nextplayer = 'A'
else:
if count == 0:
NetworkB = net.network(
lastxcoordinate, ysource=600, Ynew=100)
out = DefaultToPosition(lastxcoordinate)
bally = NetworkB[1][count]
playerbx = ballx
count += 1
else:
ballx = NetworkB[0][count]
bally = NetworkB[1][count]
playerbx = out[count]
playerax = ballx
count += 1
if count == 49:
count = 0
nextplayer = 'A'
else:
nextplayer = 'B'
DISPLAYSURF.blit(PLAYERA, (playerax, 50))
DISPLAYSURF.blit(PLAYERB, (playerbx, 600))
DISPLAYSURF.blit(ball, (ballx, bally))
lastxcoordinate = ballx
pygame.display.update()
fpsClock.tick(FPS)
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
return
这是基本的无模型强化学习。它是无模型的，因为你不需要任何形式的学习或建模来让两个代理同时准确地进行游戏。
使用深度 Q 网络的网球游戏——基于模型的强化学习
基于模型的强化学习的一个典型例子是深度 Q 网络。这项工作的源代码可在这里获得。
下面的代码说明了 Deep Q 网络，这是这项工作的模型架构。
from keras import Sequential, layers
from keras.optimizers import Adam
from keras.layers import Dense
from collections import deque
import numpy as np
class DQN:
def __init__(self):
self.learning_rate = 0.001
self.momentum = 0.95
self.eps_min = 0.1
self.eps_max = 1.0
self.eps_decay_steps = 2000000
self.replay_memory_size = 500
self.replay_memory = deque([], maxlen=self.replay_memory_size)
n_steps = 4000000
self.training_start = 10000
self.training_interval = 4
self.save_steps = 1000
self.copy_steps = 10000
self.discount_rate = 0.99
self.skip_start = 90
self.batch_size = 100
self.iteration = 0
self.done = True
self.model = self.DQNmodel()
return
def DQNmodel(self):
model = Sequential()
model.add(Dense(64, input_shape=(1,), activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(10, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=self.learning_rate))
return model
def sample_memories(self, batch_size):
indices = np.random.permutation(len(self.replay_memory))[:batch_size]
cols = [[], [], [], [], []]
for idx in indices:
memory = self.replay_memory[idx]
for col, value in zip(cols, memory):
col.append(value)
cols = [np.array(col) for col in cols]
return (cols[0], cols[1], cols[2].reshape(-1, 1), cols[3],cols[4].reshape(-1, 1))
def epsilon_greedy(self, q_values, step):
self.epsilon = max(self.eps_min, self.eps_max - (self.eps_max-self.eps_min) * step/self.eps_decay_steps)
if np.random.rand() < self.epsilon:
return np.random.randint(10)
else:
return np.argmax(q_values)
在这种情况下，我们需要一个策略网络来控制每个代理沿着 x 轴的移动。由于这些值是连续的，也就是从(x1 = 100 到 x2 = 300)，我们不可能有一个预测或处理 200 个状态的模型。
为了简化这个问题，我们可以把 x1 和 x2 拆分成 10 个状态/ 10 个动作，为每个状态定义一个上下限。
注意，我们有 10 个动作，因为一个状态有 10 种可能性。
下面的代码说明了每个状态的上限和下限的定义。
def evaluate_state_from_last_coordinate(self, c):
"""
cmax: 450
cmin: 150
c definately will be between 150 and 450.
state0 - (150 - 179)
state1 - (180 - 209)
state2 - (210 - 239)
state3 - (240 - 269)
state4 - (270 - 299)
state5 - (300 - 329)
state6 - (330 - 359)
state7 - (360 - 389)
state8 - (390 - 419)
state9 - (420 - 450)
"""
if c >= 150 and c <= 179:
return 0
elif c >= 180 and c <= 209:
return 1
elif c >= 210 and c <= 239:
return 2
elif c >= 240 and c <= 269:
return 3
elif c >= 270 and c <= 299:
return 4
elif c >= 300 and c <= 329:
return 5
elif c >= 330 and c <= 359:
return 6
elif c >= 360 and c <= 389:
return 7
elif c >= 390 and c <= 419:
return 8
elif c >= 420 and c <= 450:
return 9
实验性地用于这项工作的深度神经网络(DNN)是 1 个输入(其代表前一状态)、2 个各 64 个神经元的隐藏层和 10 个神经元的输出层(从 10 个不同状态的二进制选择)的网络。如下所示:
def DQNmodel(self):
model = Sequential()
model.add(Dense(64, input_shape=(1,), activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(10, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=self.learning_rate))
return model
现在，我们有了一个预测模型下一个状态/动作的 DQN 模型，Pytennis 环境也已经整理出了球的直线运动，让我们继续编写一个函数，根据 DQN 模型对其下一个状态的预测，由代理执行一个动作。
下面的详细代码说明了代理 A 如何决定球的方向(代理 B 这边，反之亦然)。如果代理 B 能够接到球，这个代码也会评估它。
def randomVal(self, action):
"""
cmax: 450
cmin: 150
c definately will be between 150 and 450.
state0 - (150 - 179)
state1 - (180 - 209)
state2 - (210 - 239)
state3 - (240 - 269)
state4 - (270 - 299)
state5 - (300 - 329)
state6 - (330 - 359)
state7 - (360 - 389)
state8 - (390 - 419)
state9 - (420 - 450)
"""
if action == 0:
val = np.random.choice([i for i in range(150, 180)])
elif action == 1:
val = np.random.choice([i for i in range(180, 210)])
elif action == 2:
val = np.random.choice([i for i in range(210, 240)])
elif action == 3:
val = np.random.choice([i for i in range(240, 270)])
elif action == 4:
val = np.random.choice([i for i in range(270, 300)])
elif action == 5:
val = np.random.choice([i for i in range(300, 330)])
elif action == 6:
val = np.random.choice([i for i in range(330, 360)])
elif action == 7:
val = np.random.choice([i for i in range(360, 390)])
elif action == 8:
val = np.random.choice([i for i in range(390, 420)])
else:
val = np.random.choice([i for i in range(420, 450)])
return val
def stepA(self, action, count=0):
if count == 0:
self.NetworkA = self.net.network(
self.ballx, ysource=100, Ynew=600)
self.bally = self.NetworkA[1][count]
self.ballx = self.NetworkA[0][count]
if self.GeneralReward == True:
self.playerax = self.randomVal(action)
else:
self.playerax = self.ballx
else:
self.ballx = self.NetworkA[0][count]
self.bally = self.NetworkA[1][count]
obsOne = self.evaluate_state_from_last_coordinate(
int(self.ballx))
obsTwo = self.evaluate_state_from_last_coordinate(
int(self.playerbx))
diff = np.abs(self.ballx - self.playerbx)
obs = obsTwo
reward = self.evaluate_action(diff)
done = True
info = str(diff)
return obs, reward, done, info
def evaluate_action(self, diff):
if (int(diff) <= 30):
return True
else:
return False
从上面的代码中，当 AgentA 必须播放时，函数 stepA 被执行。在比赛时，AgentA 使用 DQN 预测的下一个动作来估计目标(从球的当前位置 x1 开始，在 Agent B 处的 x2 位置，在自己一侧)，通过使用 Pytennis 环境开发的球轨迹网络来进行自己的移动。
例如，代理 A 能够通过使用函数 randomVal 在代理 B 侧获得一个精确的点 x2，如上所示，随机选择一个由 DQN 给出的动作所限定的坐标 x2。
最后，函数 stepA 通过使用函数 evaluate_action 来评估 AgentB 对目标点 x2 的响应。函数 evaluate_action 定义了 AgentB 应该受到惩罚还是奖励。正如对 AgentA 到 AgentB 的描述一样，它也适用于 AgentB 到 AgentA(不同变量名的相同代码)。
现在我们已经正确定义了策略、奖励、环境、状态和动作，我们可以继续递归地让两个代理相互玩游戏。
下面的代码显示了在 50 个球显示后每个代理如何轮流。注意，对于每一个球的展示，DQN 都要决定把球扔给下一个代理去哪里玩。
while iteration < iterations:
self.display()
self.randNumLabelA = self.myFontA.render(
'A (Win): '+str(self.updateRewardA) + ', A(loss): '+str(self.lossA), 1, self.BLACK)
self.randNumLabelB = self.myFontB.render(
'B (Win): '+str(self.updateRewardB) + ', B(loss): ' + str(self.lossB), 1, self.BLACK)
self.randNumLabelIter = self.myFontIter.render(
'Iterations: '+str(self.updateIter), 1, self.BLACK)
if nextplayer == 'A':
if count == 0:
q_valueA = self.AgentA.model.predict([stateA])
actionA = self.AgentA.epsilon_greedy(q_valueA, iteration)
obsA, rewardA, doneA, infoA = self.stepA(
action=actionA, count=count)
next_stateA = actionA
self.AgentA.replay_memory.append(
(stateA, actionA, rewardA, next_stateA, 1.0 - doneA))
stateA = next_stateA
elif count == 49:
q_valueA = self.AgentA.model.predict([stateA])
actionA = self.AgentA.epsilon_greedy(q_valueA, iteration)
obsA, rewardA, doneA, infoA = self.stepA(
action=actionA, count=count)
next_stateA = actionA
self.updateRewardA += rewardA
self.computeLossA(rewardA)
self.AgentA.replay_memory.append(
(stateA, actionA, rewardA, next_stateA, 1.0 - doneA))
if rewardA == 0:
self.restart = True
time.sleep(0.5)
nextplayer = 'B'
self.GeneralReward = False
else:
self.restart = False
self.GeneralReward = True
X_state_val, X_action_val, rewards, X_next_state_val, continues = (
self.AgentA.sample_memories(self.AgentA.batch_size))
next_q_values = self.AgentA.model.predict(
[X_next_state_val])
max_next_q_values = np.max(
next_q_values, axis=1, keepdims=True)
y_val = rewards + continues * self.AgentA.discount_rate * max_next_q_values
self.AgentA.model.fit(X_state_val, tf.keras.utils.to_categorical(
X_next_state_val, num_classes=10), verbose=0)
nextplayer = 'B'
self.updateIter += 1
count = 0
else:
q_valueA = self.AgentA.model.predict([stateA])
actionA = self.AgentA.epsilon_greedy(q_valueA, iteration)
obsA, rewardA, doneA, infoA = self.stepA(
action=actionA, count=count)
next_stateA = actionA
self.AgentA.replay_memory.append(
(stateA, actionA, rewardA, next_stateA, 1.0 - doneA))
stateA = next_stateA
if nextplayer == 'A':
count += 1
else:
count = 0
else:
if count == 0:
q_valueB = self.AgentB.model.predict([stateB])
actionB = self.AgentB.epsilon_greedy(q_valueB, iteration)
obsB, rewardB, doneB, infoB = self.stepB(
action=actionB, count=count)
next_stateB = actionB
self.AgentB.replay_memory.append(
(stateB, actionB, rewardB, next_stateB, 1.0 - doneB))
stateB = next_stateB
elif count == 49:
q_valueB = self.AgentB.model.predict([stateB])
actionB = self.AgentB.epsilon_greedy(q_valueB, iteration)
obs, reward, done, info = self.stepB(
action=actionB, count=count)
next_stateB = actionB
self.AgentB.replay_memory.append(
(stateB, actionB, rewardB, next_stateB, 1.0 - doneB))
stateB = next_stateB
self.updateRewardB += rewardB
self.computeLossB(rewardB)
if rewardB == 0:
self.restart = True
time.sleep(0.5)
self.GeneralReward = False
nextplayer = 'A'
else:
self.restart = False
self.GeneralReward = True
X_state_val, X_action_val, rewards, X_next_state_val, continues = (
self.AgentB.sample_memories(self.AgentB.batch_size))
next_q_values = self.AgentB.model.predict(
[X_next_state_val])
max_next_q_values = np.max(
next_q_values, axis=1, keepdims=True)
y_val = rewards + continues * self.AgentB.discount_rate * max_next_q_values
self.AgentB.model.fit(X_state_val, tf.keras.utils.to_categorical(
X_next_state_val, num_classes=10), verbose=0)
nextplayer = 'A'
self.updateIter += 1
else:
q_valueB = self.AgentB.model.predict([stateB])
actionB = self.AgentB.epsilon_greedy(q_valueB, iteration)
obsB, rewardB, doneB, infoB = self.stepB(
action=actionB, count=count)
next_stateB = actionB
self.AgentB.replay_memory.append(
(stateB, actionB, rewardB, next_stateB, 1.0 - doneB))
tateB = next_stateB
if nextplayer == 'B':
count += 1
else:
count = 0
iteration += 1
比较/评估
玩了这个无模型和基于模型的游戏后，我们需要注意以下几点差异:
| 序列号 | 无模型 | 基于模型的 |
|---|---|---|
奖励不入账(因为这是自动化的，奖励= 1)
|
奖励占
|
| |
【无建模(不需要决策策略)
|
【造型要求】(政策网)
|
| |
这不需要利用初始状态来预测下一个状态
|
这就需要使用策略网络
使用初始状态来预测下一个状态 |
| |
失球率相对于时间为零
|
失球率相对于时间趋近于零
|
如果你感兴趣，下面的视频展示了这两种打网球的技巧:
1.无模型
视频
2.基于模型的
视频
结论
与自动驾驶汽车相比，网球可能很简单，但希望这个例子向你展示了一些你不知道的关于 RL 的事情。
无模型 RL 和基于模型 RL 的主要区别是策略网络，基于模型 RL 需要策略网络，无模型不需要策略网络。
值得注意的是，通常情况下，基于模型的 RL 需要大量的时间让 DNN 在不出错的情况下完美地学习状态。
但是每种技术都有它的缺点和优点，选择正确的技术取决于你到底需要你的程序做什么。
感谢阅读，我留下了一些额外的参考资料，如果你想进一步探讨这个话题，可以参考。
参考
- AlphaGo 纪录片:https://www.youtube.com/watch?v=WXuK6gekU1Y
- 强化学习环境列表:https://medium . com/@ mauriciofadelargerich/reinforcement-learning-environments-CFF 767 BC 241 f
- 创建自己的强化学习环境:https://towards data science . com/create-your-own-reinforcement-learning-environment-beb 12 f 4151 ef
- RL 环境的类型:https://subscription . packtpub . com/book/big _ data _ and _ business _ intelligence/9781838649777/1/ch 01 LV 1 sec 14/types-of-RL-environment
- 基于模型的深度 Q 网:https://github . com/elishatofunmi/py tennis-Deep-Q-Network-DQN
- 离散数学方法 youtube 视频:https://youtu.be/iUYxZ2tYKHw
- 深 Q 网途径 YouTube 视频:https://youtu.be/FCwGNRiq9SY
- 无模型离散数学实现:https://github . com/elishatofunmi/py tennis-离散-数学-方法-
- 用 scikit-learn 和 TensorFlow 动手进行机器学习:https://www . Amazon . com/Hands-Machine-Learning-Scikit-Learn-tensor flow/DP/1491962291
模型调试策略:机器学习指南
原文：https://web.archive.org/web/https://neptune.ai/blog/model-debugging-strategies-machine-learning
你不能基于一个错误的模型来部署软件。调试是机器学习中模型开发和部署的一个重要部分。
有没有一种银弹策略适用于所有类型的模型和应用程序？不尽然，有许多不同的模型调试策略，我们将在本文中探讨其中的 10 种。
模型调试说明
当您调试模型时，您会发现并修复工作流和结果中的错误。例如，调试可以揭示模型行为不当的情况，即使它的规范没有内部错误——调试也可以向您展示如何改进这样的问题。
为什么我们需要调试？
调试是软件开发的关键部分，不管它是什么类型的软件——因此，自然地，它也适用于机器学习。
在机器学习中，模型性能差可能有多种原因，调试可能需要大量工作。没有预测能力或次优值会导致模型表现不佳。因此，我们调试我们的模型以找到问题的根本原因。
模型被部署在越来越大的任务和数据集上，规模越大，调试模型就越重要。
调试的一般步骤是什么？
软件世界中的调试步骤
Created by author with Canva
- 识别错误:要修复问题，您首先需要知道您有问题。有很多方法可以识别错误，比如性能监控和用户反馈。
- 定位错误:是时候看看错误到底发生在哪里了。彻底检查系统以找到它。
- 分析错误:分析代码以识别更多的问题，并估计错误产生的风险。
- 验证分析:使用自动化测试，在分析完 bug 之后，你可能会在应用程序中发现更多的错误。
- 处理损坏:收集程序中所有需要修改的测试单元。现在您可以运行测试单元并监控它们的性能。
- 修复和验证:修复问题，运行所有测试单元，监控性能。
这些调试步骤在传统的软件世界中非常有效。机器学习或 AI 中的调试有区别吗？
当你调试一个 ML 或者 AI 模型的时候，你不会那么关注代码。你必须更深入地确定为什么你的模型表现很差。
由于超参数中的次优值、数据集问题或缺乏预测能力，可能会出现性能不佳的情况。模型性能不好的原因有很多，调试机器学习模型的策略也有很多。
我们将探索开发人员和数据科学家使用的流行技术，以发现机器学习模型中的错误和改进它们的方法。但在此之前，我们先来探索不同类型的 bug。
机器学习模型中的常见错误
模型中最常见的问题是维度，这是由线性代数的性质决定的。大多数流行的库可以发现不一致的形状。在处理矩阵时，假设我们使用 shape(n1，n2)(n3，n4)，那么在矩阵乘法中，匹配 n1 和 n3 维对于矩阵运算非常重要。找到它们来自哪里也很重要。
如果您想要 PyTorch 中 Keras 的 Tensorflow 之类的模型摘要，只需使用:
!pip install torchsummary
它将以表格格式显示每个图层的结果。
数据会经历一个漫长的过程，从准备、清理等开始。在这个过程中，开发人员经常会感到困惑或忘记正确的数据变量。因此，为了保持在正确的道路上，在构建我们的模型之前使用数据流图是一个好的实践。这将帮助我们找到正确的数据变量名、模型流和预期结果。
为了弄清楚我们的模型是否包含预测信息，首先在人类身上进行尝试。如果人类无法预测数据(图像或文本)，那么我们的 ML 模型就不会有任何作用。如果我们试图给它更多的输入，它仍然不会有所作为。该模型可能会失去其准确性。
一旦我们获得足够的预测信息，我们需要知道我们的数据是否足以训练模型并获得信号。一般来说，我们每个类至少需要 30 个样本，特定功能需要 10 个样本。
数据集的大小∝模型中参数的数量
上面等式的确切形状取决于你的机器学习应用。
当你从事机器学习项目时，你可能没有足够的数据。解决这个问题的一个好方法是扩充你的数据。您可以使用创成式模型和创成式对抗网络(如自动编码器)生成新数据。自动编码器有助于以无人监督的方式学习结构化数据编码。
外部数据，比如说在互联网上找到的或开源的数据，可能是有用的。一旦您收集了数据并对其进行了标记，您就可以将其用于培训。它还可以用于许多其他任务。就像外部数据一样，我们也可以使用由他人训练的外部模型，并在我们的任务中重用它。
使用高质量但较小的数据集是训练简单模型的最佳方式。有时，当您使用大型训练数据集时，您可能会浪费太多的资源和金钱。
- 准备数据并避免常见问题
准备要素时，测量测试数据集的比例因子、平均值和标准差至关重要。测量这些将提高测试数据集的性能。标准化将帮助您确保所有数据的标准差为 1，平均值为 0。如果数据有异常值，这种方法会更有效，并且是缩放要素的最有效方法。
超参数调整是关于改进超参数。这些参数控制学习算法的行为。例如，学习速率(α)或梯度下降优化中的复杂度参数(m)。
一个常见的超参数优化案例是通过使用交叉验证来选择最佳值，以便选择对看不见的数据最有效的方法。这评估了模型参数在训练期间是如何更新的。通常，这项任务是使用简单的试错法手动执行的。有很多不同的方法来调整超参数，例如网格搜索、随机搜索方法、贝叶斯优化方法和简单的有根据的猜测。
记录是监控任何问题的一种方式，但是最好不要记录无用的信息。有时候，评论/记录所有的决策和交换的信息是非常重要的。这可能很困难，但是应该可以规划出所有可能的场景，并使用日志来解决这个问题。
例如，重要的细节是参数的值、类的运行时类型、软件决策等等。这取决于您的问题类型。
通过验证策略，我们可以发现与实际模型无关的问题。我们可以验证模型的完整性(即验证它没有被更改或破坏)，或者模型是否正确和可维护。许多实践已经发展为验证，例如测试数据序列的自动生成，使用不同的输入值集运行多个分析，以及在将数据导入文件时执行验证检查。
让我们更深入地探讨一下开发人员和数据科学家用来发现机器学习模型中的 bug 的最常用和最重要的策略。
最常用的模型调试策略
灵敏度分析
敏感性分析是一种统计技术，用于估计模型、参数或其他量对输入参数相对于其标称值的变化有多敏感。这种分析显示了模型如何对看不见的数据做出反应，以及它从给定的数据中预测出什么。开发人员经常称之为“假设”分析。
假设我们有一个模型，在特定区域房价上涨 10%的情况下，该模型预测房价将上涨 10%。为了验证这一点，我们模拟了人口增长 10%的数据。如果预测正确，房价上涨 10%，就大功告成了。但是，如果预测是关闭的，例如，住房的预测值不变，则模型对其一个或多个输入变量的变化很敏感。通过敏感性分析，我们可以找出是哪个(哪些)输入变量导致了问题。如果价格上涨 10%、20%或 50%会怎么样？这将有助于我们证明价格对买家流量的变化很敏感。
上面的例子是对一个未知量(房价)的预测。对于预测已知数量的模型(如股票市场)，敏感性分析甚至更为重要。 What-if-tool 是可视化监控经过训练的 ML 模型行为的最佳方式，只需最少的编码。
敏感性分析将帮助我们深入研究所有变量。正因为如此，预测变得更加可信。它还帮助开发人员认识到未来可以改进的地方。
残差分析
数据科学家和开发人员最常用的方法。这是对模型误差以及观察结果和预测结果之间差异的数值评估。残差图非常有助于确定模型的错误之处(错误分类数据点)。简单地说，残差可以通过从观测值中减去预测值来计算。
Created by author with Canva
残差=观察值(上图的膨胀)-预测值
所以，我们以 2020 年 6 月为例。通货膨胀的观察值为 2.2%，模型的预测值为 1.9，因此残差为 0.3。残值小往往意味着模型正确，残值大往往意味着模型有问题。
残差分析图可以很容易地理解为 2D 图，其中横轴表示输入数据，纵轴表示预测或预测结果。本质上，残差分析描绘了不同数字之间的相似性，以确定是否存在异常。通常，这些异常是重要的 bug，可以利用断点等模型调试技术。残差图便于直观显示数据集中两个变量之间的距离。它们还让我们深入了解质量问题，例如异常值，如果不加以检查，这些异常值可能会扭曲预测并造成更大的伤害。寻找为残值创建的模式。我们将能够通过这些模式了解我们的模型。
在评估模型质量时，残差是至关重要的。当残差为零时，意味着模型预测是完美的。更多或更少的值意味着模型的准确性更低。当平均残差不为零时，意味着模型有偏差或可能有问题。诊断线性回归模型中的残差图通常使用以下两种图形方法。
-
分位数图:分位数图是一种图形表示，用于查看残差的分布是否标准。这是实际分布和正态分布的分位数图。如果图表在对角线上重叠，那么它是正态分布的。它帮助我们测试许多分布方面。
-
散点图:散点图是评估方差和线性的图形表示。这两个点描述了两个不同的值。它们可以帮助我们想象两个或更多的变量是如何相互关联的。这通常是分析数据和评估两个或多个项目之间关系的有效方法。另一个优点是，构建散点图只需要很少的数学技能，并且可以很好地理解我们在数据中看到的内容。
基准模型
基准模型是最易于使用、可靠、透明和可解释的模型，您可以用它来比较您的模型。最佳实践是检查您的新机器学习模型在测试数据集中的表现是否优于已知基准。
基准模型易于实现，不需要太多时间。使用任何标准算法找到合适的基准模型，然后将结果与模型预测进行比较。如果标准算法和最大似然算法之间有许多共同特征，那么简单的回归可能已经揭示了算法可能存在的问题。
此外，基准模型可以用来评估我们的 ML 模型在不同数据类上的表现。例如，如果我们对我们的 ML 模型过度拟合某些数据感到惊讶，基准模型可以帮助我们理解这是否是因为数据是特殊的。
安全审计
有许多针对机器学习模型的攻击会影响模型结果和数据集。常用的评估实践不能告诉我们一个模型是否安全。
有很多方法可以审计机器学习模型，以确保它们是安全的。一些攻击可以使用合成数据发起，当它们与真实的机器学习模型结合时，它们的分析变得非常具有挑战性。
这最适用于攻击者能够访问用于开发模型的训练集的情况。所有的数据、文档和信息应该只对授权成员开放。所有的数据都应该保持准确。我们需要确保进行常规备份、版本控制和所有的安全措施来保证数据的安全。
数据扩充
数据扩充是一种机器学习技术，可以帮助我们实现缺失数据。从最基本的定义来看，数据扩充是一种添加新的训练样本来填充数据集中有缺口的地方的方法。
我们可以增加:
- 声音的
- 文本
- 形象
- 任何其他类型的数据
机器学习解决方案将一组数据与数学方程相结合，将这些可用数据转化为关于我们想要找到的答案的结论。
数据扩充最常见的用途之一是填补我们训练数据集中缺失的数据缺口。在 ML 问题中，有一个训练数据集(也可能有一个验证数据集)没有所有可能的答案(或算法的参数)是很常见的。
但可能有许多答案或参数可以从可用数据中正确“预测”，这些答案或参数在我们的数据集中缺失，但却是模型所需要的。例如，对于图像，我们可以使用
- 几何变换，
- 色彩空间转换，
- 内核过滤器，
- 随机擦除，
- 混合图像。
对于文本，有单词重排、替换和语法操作。用于音频噪声注入—移位、音频速度等。
模型编辑和监控
模型编辑是一种技术，其中机器学习模型是为人类用户设计的，以便能够理解它们如何工作并编辑它们。这样做是为了模型在未来表现良好，因为一些 ML 变体被设计为可以被人类解释，如决策树和 GA2M。其他模型可能很难编辑，但是如果它们能够生成可读的结果，它们是可以编辑的。
监控和管理我们的机器学习模型是工作流程的重要组成部分。我们必须记录谁在什么时候训练了这些模型。我们必须保留所有数据集、输入和预测的记录。
这些事情不是一成不变的，会随着时间发生剧烈变化，因此监控我们的模型非常重要。假设我们的模型看起来运行得很好——我们有没有想过如果不是这样会发生什么？当我们的模型不再与现实一致时，我们怎么知道呢？
没有人喜欢惊喜，所以最好不要用监测和校准来等待。可能我们有了一个包含新信息的新数据集，我们想看看它如何改变我们的模型。或者也许我们的模型有一个严重的问题需要纠正。无论情况如何，我们都需要一种方法来检查我们是否应该重新优化和校准。
模型断言
模型断言有助于实时改进或覆盖模型预测。在机器学习建模的上下文中，业务规则可以通过检测模型何时未能预测或行为异常来帮助模型达到其指定的目标。由于许多原因，这可能是有益的，但主要的好处是面向目标的业务规则允许模型根据当时需要的操作提供不同级别的响应，因此它们更有可能在不可预测的情况下按预期行事。
与其他实现方法相比，模型断言有很多优点。与应用程序集成方法相比，它们很容易处理向已经部署的模型添加新规则，因为不需要对机器或机器上的任何其他应用程序进行更改。通过评估断言实施的规则是否被遵循，以及它们的准确性如何，也可以很容易地对断言进行评估。因此，与通过应用程序集成实现的业务规则相比，模型断言可以更加准确，而且更加省力。
异常检测
异常检测是一种强大的安全措施，它允许组织在异常行为发展的过程中对其进行检测。异常可能包括从组织的金融网络中发生的异常交易到黑客从公司窃取金钱或数据的任何事情。它与其他欺诈检测方法非常相似，但它不仅仅是寻找已知的欺诈交易或模式，还寻找这些模式中的异常和异常值。这意味着异常现象即使以前没有被发现，也能被检测出来。
用 Neptune 进行模型可视化和调试
Neptune 是为研究和生产团队开发的 MLOps 的元数据存储。它为我们提供了一个记录、存储、显示、组织、比较和查询机器学习生命周期中生成的所有元数据的中心。研究人员和工程师使用海王星进行实验跟踪和模型注册，以控制他们的实验和模型开发。
可视化如何帮助调试？
许多程序员都会同意调试是编程中最困难的部分之一。这需要高度的专注、对细节的持续关注和相当大的耐心。这也非常耗时。可视化技术通常通过发现代码中从他们的角度来看像是一个谜的区域来极大地帮助程序员。
可视化是计算机编程的重要组成部分，它允许数据科学家观察程序执行产生的输入和输出值。开发的一个常见问题是当程序产生不正确的结果时，缺乏对程序如何工作的理解。调试工具有助于这一点，它让我们了解程序实际在做什么以及它的输出——特别是对于可视化来说，我们可以洞察不同的数据点看起来像什么，让我们看到为什么我们代码的某些部分工作正常或不正常。使用正确的可视化技术，我们可以准确地看到错误来自哪里，以及在运行期间修改了哪些数据，从而使我们能够在为时已晚之前修复代码。
使用 Neptune，您可以登录:
- 模型预测
- 损失和指标
- 工件(数据版本、模型二进制文件)
- Git 信息、代码或笔记本检查点
- 硬件利用率
- 培训完成后，在笔记本上进行错误分析
- 绩效可视化如 ROC 曲线或混淆矩阵(在培训期间或之后)或任何其他东西(它变得交互式)‘metric _ charts’有很好的示例图表
- 交互式可视化来自牛郎星、散景、 Plotly 或其他 HTML 对象
- 使用智能比较表比较多次运行的超参数和指标，该表突出显示了不同之处。
让我们举一个使用 Altair 的简单例子:
Altair 是一个针对 Python 的声明式统计可视化库，基于 Vega 和 Vega-Lite ，源码在 GitHub 上。这种集成让我们可以将 Altair 中生成的交互式图表记录到 Neptune 中。
让我们从初始化 Neptune 开始:
import neptune.new as neptune
run = neptune.init(api_token='<API_KEY>',
project='<PROJECT_NAME>')
记录牛郎星图。
首先通过安装 vega_datasets 创建一个样例图形:
pip install --upgrade --quiet vega_datasets==0.9.0
使用数据创建样图:
import altair as alt
from vega_datasets import data
source = data.cars()
brush = alt.selection(type='interval')
points = alt.Chart(source).mark_point().encode(
x='Horsepower:Q',
y='Miles_per_Gallon:Q',
color=alt.condition(brush, 'Origin:N', alt.value('lightgray'))
).add_selection(
brush
)
bars = alt.Chart(source).mark_bar().encode(
y='Origin:N',
color='Origin:N',
x='count(Origin):Q'
).transform_filter(
brush
)
chart = points & bars
chart
记录数字:
run['interactive_img'] = neptune.types.File.as_html(chart)
探索海王星的结果:
使用 run.stop() 停止记录。
现在让我们将 Matplotlib 数字记录到 Neptune:
按照上面第一步所示初始化 Neptune，从在环境中创建一个样例图形开始。确保安装了正确的版本。
import matplotlib.pyplot as plt
import numpy as np
np.random.seed(42)
data = np.random.randn(2, 100)
记录为静态图像:
run['static-img'] = neptune.types.File.as_image(figure)
将日志记录为交互式图表:
run['interactive-img'] = neptune.types.File.as_html(figure)
使用简单的 run.stop() 停止日志记录。
海王星对个人是免费的，你可以在这里生成 API 密匙
提高模型性能的方法
有许多方法可以提高模型性能，但我们将只讨论几种顶级方法。
更多数据:增加更多数据是提高模型性能的最好方法。重采样、清理和获取更多数据也会提高性能。有时，您无法添加更多数据，但您仍然可以创建更多数据或从外部来源获取数据。添加更多数据是提高模型性能的最佳方式。特征工程:在统计或机器学习技术的帮助下，将原始观察数据转化为所需特征的简单过程。向模型中添加新特征总是一个好主意，因为这可以提高灵活性并减少差异。使用特征工程时，您需要确保拥有大量数据和充足的预算。你应该买得起这个。
特性选择:想象你的数据就像一大片树木的森林。特征选择是遍历森林并根据高度、宽度或颜色等特征决定要保留哪些树的过程。这个类比可以应用于你正在分析、过滤或筛选信息的数据。为了从数据集中提取有用的信息，确定我们要进一步分析数据集中的哪些要素非常重要。我们可能不需要所有的功能。我们可能只需要许多中的一两个，所以重要的是我们要明智地选择，并在它们占用我们机器学习训练算法的宝贵处理时间之前丢弃其余的。
多种算法:这里的目标是通过使用多种算法并聚合它们的输出来提高性能。一个众所周知的例子是谷歌的搜索引擎，它对搜索结果使用许多不同的统计模型。你可能会认为，如果所有模型都会产生相似的答案，那么使用多个模型就没有意义，但事实证明，这样做有一些令人惊讶的好处——即使是一天的数据。
算法调优:模型开发是一个试错的过程。这个过程中最重要的部分之一是调整你的算法，找到最适合你的算法。调整算法需要大量的时间，可能需要几周或几个月才能发现一个性能良好的算法。最终，你投入的所有时间和精力都是值得的。
合奏:最常用、最有效的方法。它结合弱模型的预测数据并产生更好的结果。这个方法有很多种。您可以使用相同或不同的算法创建多个模型，也可以为定型数据生成多个子样本并组合预测以获得性能更好的算法。
交叉验证:术语交叉验证用于描述采用一种算法并将其应用于尚未用于训练该算法的测试数据的过程。在机器学习中，这通常意味着采用一个未经学习的模型，并在一组验证数据上运行它，然后与原始训练集进行比较。交叉验证可以使用“留一法”或重复交叉验证方案来完成。
结论
模型调试可能是一项困难、耗时的任务。模型是用许多不同的变量构建的，并且通常具有抽象层，这使得调试很困难。
我们看到了什么是模型调试，以及我们为什么需要它。我们还讨论了一些常见的错误类型，以及最常用的模型调试实践。你可以尝试这些技术，让你的机器学习模型更值得信赖，性能更好。
希望你喜欢这篇文章，保持安全！
额外研究和推荐阅读
哈希尔·帕特尔
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.
