原文：NeptuneAI Blog

协议：CC BY-NC-SA 4.0

如何组织你的 XGBoost 机器学习(ML)模型开发过程:最佳实践

原文：https://web.archive.org/web/https://neptune.ai/blog/how-to-organize-your-xgboost-machine-learning-ml-model-development-process

XGBoost 是一个顶级的渐变增强库，可以在 Python、Java、C++、R 和 Julia 中使用。

该库支持 GPU 培训、分布式计算、并行化和缓存优化。开发人员也喜欢它的执行速度、准确性、效率和可用性。

然而，当你在任何框架中开发机器学习模型时，包括 XGBoost，你可能最终会尝试一堆参数配置和功能版本，以获得满意的性能。使用电子表格和命名约定来管理所有这些配置确实令人头疼。

有一些工具可以帮助开发人员组织他们的机器学习模型开发过程。本文将重点向您展示如何在顶级 ML 实验管理工具之一的 Neptune 中实现这一点。

让我向您展示如何在您当前的模型开发设置之上添加实验管理。

如何跟踪 XGBoost 模型训练:海王星+ XGBoost 集成

使用 XGBoost 进行 ML 模型开发通常是什么样子

准备好数据集

在训练任何模型之前，我们需要一个数据集。对于这个示例，我们将使用 Scikit-learn 生成一个分类数据集。在现实生活中，你可能已经准备好了一些特性，你将会加载它们。

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

X, y = make_classification(n_samples=100000,n_features=10, n_redundant=0, n_informative=8,random_state=1)
import pandas as pd
X = pd.DataFrame(X,columns=["F1","F2","F3","F4","F5","F6","F7","F8","F9","F10"])
y = pd.DataFrame(y,columns=["Target"])

X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.33, random_state=42)

训练 XGBoost 模型

接下来，我们将导入 XGBoost，设置我们的参数。由于这是一个二元分类，我们使用logistic目标。之后，我们用这些参数初始化分类器。您也可以使用 YAML 文件传入参数。

params = {"objective":"binary:logistic",'colsample_bytree': 0.3,'learning_rate': 0.1,
                'max_depth': 5, 'alpha': 10}
classification = xgb.XGBClassifier(**params)

下一步是用训练测试来训练模型。

classification.fit(X_train, y_train)

培训之后，我们需要保存模型，以便在部署过程中使用它。

from sklearn.externals import joblib
joblib.dump(classification, 'classifier.pkl')

接下来，我们在测试集上评估模型，并显示分类报告。

from sklearn.metrics import classification_report

print(classification_report(predictions,y_test))

最后，我们将获得的预测转换成数据帧，并保存为 csv 文件以供将来参考，或者进行一些深层错误分析。

import pandas as pd
pd.DataFrame(predictions, columns=["Predictions"]).to_csv("predict.csv")

现在，让我向您展示如何对所有这些进行版本控制，并通过 Neptune 轻松管理。

在 Neptune 组织 ML 开发

安装软件包并设置 Neptune

我们将在 Jupyter 笔记本中使用 Neptune，所以我们需要 Neptune 客户端和 Neptune Jupyter 扩展。

在您的终端中运行以下命令来安装 Neptune:

pip install neptune-client

为 Jupyter 笔记本配置 Neptune 是必不可少的，因为它使我们能够将笔记本检查点保存到 Neptune。如果您不使用笔记本电脑，可以跳过这一部分。

接下来，设置笔记本扩展:

pip install neptune-notebooks

安装后，您必须启用扩展，以便与您的 Jupyter 笔记本电脑集成:

jupyter nbextension enable --py neptune-notebooks

如果你在 JupyterLab 上工作，你可以毫无问题地安装扩展。

因为我们正在安装软件包，所以让我们也把 Neptune Contrib 软件包去掉。它包含一个回调函数，让我们在训练 XGBoost 模型时记录度量、模型和特性对 Neptune 的重要性。

pip install neptune-contrib[monitoring]

将您的脚本连接到海王星

此时，您需要一个免费的 Neptune AI 帐户来初始化 Jupyter 笔记本中的 Neptune。为此，您需要一个 Neptune API 密钥。

登录后，您可以通过单击您的个人资料图像来获取密钥。

都准备好了吗？让我们跳到 Jupyter 笔记本上进行初始化。

第一步是通过点击 Neptune 图标将我们的笔记本连接到 Neptune。

现在将提示您输入 API 令牌。一旦连接成功，你可以通过点击上传按钮上传你的笔记本到 Neptune。

之后，我们使用‘neptune . init’来初始化通信，并将当前脚本/笔记本与您在 Neptune 中的项目连接起来。

import neptune

neptune.init(project_qualified_name='mwitiderrick/sandbox', api_token='YOUR_API_KEY')

在这种情况下，我使用的是在你注册时自动创建的“沙盒”项目。但是，您可以在“项目”标签中创建新项目。

创建实验并保存超参数

开始登录 Neptune 的第一件事是创建一个实验。这是一个命名空间，您可以在其中记录度量、预测、可视化和任何其他内容(参见您可以在 Neptune 中记录和显示的元数据类型的完整列表)。

让我们创建一个实验并记录模型超参数。

experiment = neptune.create_experiment(name='xgb', tags=['train'], params=params)

运行neptune.create_experiment输出海王星实验的链接。

可以点开看看训练过程直播。

现在，没有记录太多，但是我们可以在参数部分看到超参数。

“参数”选项卡显示用于训练 XGBoost 模型的参数。

在笔记本上工作时，一旦你完成了运行实验，确保你的运行neptune.stop()完成当前的工作(在脚本中实验自动停止)。

创建 Neptune 回调并将其传递给“fit”

为了将训练指标记录到 Neptune，我们使用了来自 neptune-contrib 库的现成回调。这很酷，因为这是我们在训练阶段唯一需要添加的东西。

有了回调设置，海王星照顾其余的。

from neptunecontrib.monitoring.xgboost import neptune_callback

我们通过调用fit方法并传入我们之前定义的参数来训练模型，包括 Neptune 回调。

classification.fit(X_train, y_train,callbacks=[neptune_callback()],eval_set=[(X_test, y_test)])

一旦训练完成，回到海王星，检查日志。

登录后，您可以单击当前正在进行的项目来查看您的所有实验。

在 monitoring 选项卡上，会实时显示 CPU 和 RAM 的使用情况。

单击单个实验将显示该特定实验的日志。在图表部分，您可以看到培训和验证图表。

使用 Neptune，您还可以放大培训的各个部分，对其进行详细分析。

“日志”部分显示了用于生成这些图形的日志。

注意使用 Neptune 回调后我们自动得到的特性重要性图。

一旦你的项目中有了几个实验，就可以对它们进行比较。你可以通过选择实验并点击比较按钮来完成。

版本数据集

在 Neptune 中对数据集哈希进行版本控制也非常有用。这将使您能够在执行实验时跟踪数据集的不同版本。这可以借助 Python 的hashlib模块和 Neptune 的set_property函数来完成。

import hashlib
neptune.set_property('x_train_version', hashlib.md5(X_train.values).hexdigest())
neptune.set_property('y_train_version', hashlib.md5(y_train.values).hexdigest())
neptune.set_property('x_test_version', hashlib.md5(X_test.values).hexdigest())
neptune.set_property('y_test_version', hashlib.md5(y_test.values).hexdigest())

之后，您可以在项目的 details 选项卡下看到版本。

版本模型二进制

您也可以使用neptune.log_artifact()将模型的各种版本保存到 Neptune，但是，由于我们使用的是neptune_callback(),所以模型会在最后一次增强迭代后自动登录到 Neptune。

我们还可以记录我们之前保存的模型。

neptune.log_artifact('classifier.pkl')

你认为你还需要的任何版本

Neptune 还提供了记录其他东西的能力，比如模型解释器和交互式图表，比如 ROC 曲线。

记录解释者是使用log_explainer函数完成的。

from neptunecontrib.api import log_explainer, log_global_explanations
import dalex as dx

expl = dx.Explainer(classification, X, y, label="XGBoost")

log_global_explanations(expl, numerical_features=["F1","F2","F3","F4","F5","F6","F7","F8","F9","F10"])

log_explainer('explainer.pkl', expl)

这样做之后，实验的工件部分将会有经过腌制的解释器和图表。

在仪表板中组织实验

海王星允许你选择你想在仪表盘上看到什么。您可以添加或删除列。通过单击管理列，您可以向仪表板添加新列。

如果您想删除某一列，只需单击它旁边的 x 按钮。您也可以使用某列旁边的向上和向下箭头按该列进行筛选。这些按钮指示您是按升序还是降序进行过滤。

该平台还允许您将实验分组到视图中。例如，您可以选择带有特定标签的实验，并将这些实验保存为新视图。一旦你这样做了，你就可以随时访问新的视图。

与您的团队合作进行 ML 实验

你可以通过邀请你的团队合作来分享你的 Neptune 实验。

您还可以通过公开项目来与全世界共享项目。一旦项目公开，你可以自由地与任何人分享链接。

使用团队计划时，您可以与队友分享您的私人项目。该团队计划对研究、非营利组织和 Kagglers 也是免费的。

你在 Neptune app 里做什么都可以分享，比如我发个链接就可以分享我的实验对比。

以编程方式下载模型工件

使用 Neptune，您可以从您的实验中下载文件，甚至直接从您的 python 代码中下载单个项目。例如，您可以使用download_artifact方法下载单个文件。我们可以通过获取实验对象并下载该实验的所有文件来下载模型。在这种情况下，我们下载之前上传的分类器。分类器存储在我们当前工作目录的模型文件夹中。

project = neptune.init('mwitiderrick/sandbox',api_token='YOUR_TOKEN',
)
my_exp = project.get_experiments(id='SAN-21')[0]
experiment.download_artifact("classifier.pkl","model"))

当你想操作你的模型并从你的实验报告中直接获取它们时，这是很有用的。但是将模型投入生产是另外一个故事🙂

结论

希望这已经向您展示了使用 Neptune 向 XGBoost 训练脚本添加实验跟踪和模型版本控制是多么容易。

具体来说，我们讲述了如何:

设置海王星

• 使用 Neptune 回调来记录我们的 XGBoost 培训课程
• 分析和比较海王星的实验
• 海王星上各种项目版本
• 与团队成员协作
• 从海王星下载你的神器
• 希望有了这些信息，XGBoost 模型现在会更清晰，更易于管理。

感谢阅读！

Thanks for reading!

如何运行机器学习项目:最佳实践

原文：https://web.archive.org/web/https://neptune.ai/blog/how-to-run-machine-learning-projects-best-practices

ML 和数据科学发展迅速。在过去的几年里，在集成不同的技术和业务工作流方面已经取得了很大的进展。

如果你正在做一个商业 ML 项目，你可能会在打电话前后做很多事情。fit()和。预测()。在本文中，我们将讨论端到端项目的不同方面，通过一些简单的步骤，您可以增加项目成功的机会。

什么时候用 ML？

在创建模型之前，最好问问我们自己:

“这个问题不用 ML 能解决吗？”

意思是，一个基于规则的系统能够很好地解决问题吗？

基于规则的方法具有独特的特征。规则是透明的，易于调试。你总是知道为什么预测会出错。当决策的解释和透明度至关重要时，这些信息就派上了用场。

然而，基于规则的系统很难维护。编写规则最初看起来很简单，但是随着产品的开发，它会变得很混乱。考虑规则的维护是至关重要的，而 ML 系统可以很容易地在新的数据集上重新训练。

例如，如果您正在构建发票解析软件，最初您可能会关注特定的发票模板。在那里很容易编写规则，因为文档结构几乎是一致的。然而，一旦您增加和处理更多的发票，基于 ML 的方法更有意义，因为它容易扩展。你只需要更多的数据和/或更复杂的模型，而不是更多的工程师来编写更多的规则。

启动 ML 项目前的清单

在你写第一行代码之前，你应该对你的进度有一个好的想法。这里有一个清单可能会有所帮助:

• 你的 ML 项目的目标是什么？为项目定义清晰的目标有助于集中注意力。例如，您可以构建一个 ML 模型来自动化信用卡审批。目的应该尽可能具体和透明。
• 你有数据吗？这一点我怎么强调都不为过！花更多时间收集高质量数据，而不是实施最先进的模型。实际上，每当您的模型表现不佳时，很可能是由于数据问题。你的公司可能没有任何数据，比如一些早期创业公司，所以你只能依靠第三方 ML 解决方案，直到你获得数据并训练你的模型。即使有了数据，也可能没有注释，注释需要一段时间。
• **您将如何衡量模型性能？**当然，在训练您的模型时，您将跟踪准确性、精确度或任何其他感兴趣的指标。但是，请记住，这些数字并不是最终目标。您的业务度量来自项目目标。例如，网飞推荐引擎是一个 ML 模型，它增加了每个用户观看的时间，或者减少了用户什么也没看 并关闭网站的访问次数。有两个级别的指标，模型指标和业务指标。
• **基础设施真的到位了吗？**机器学习是 10%机器学习，90%工程。

如上图所示，实际的 ML 代码只是整个系统的一小部分。在 ML 代码之前，我们需要考虑数据过程。这不仅仅是收集数据并将其存储在一个地方。该系统必须具有高度的容错能力。例如，如果你正在使用云服务收集数据，而服务失败了，应该有一个救援机制来避免数据丢失。

此外，ML 模型需要根据用例频繁更新。让开发人员在每次更新上花费大量时间并不是好的做法。因此，拥有系统和工具来节省时间并在整个过程中更加透明是有益的。一种方法是使用一个好的模型注册中心，它允许我们存储和管理多个经过训练的模型。有像 MLflow 和 ModelDB 这样的开源模型注册中心。对于更复杂和协作的解决方案，请检查 neptune.ai(对个人开发者免费使用)。

从 MLOps 的角度来看，使用 Docker 将您的 ML 推理代码封装起来并使用 Kubernetes 进行部署是一个很好的实践。容器化应用程序使您不必担心如何设置合适的环境，并使您能够在云中的任何地方一致地运行您的应用程序。

• **部署要求。**提前考虑部署策略通常是个好主意。云部署更好，还是边缘部署更好？延迟限制是什么？思考这些问题通常有助于决定您的模型应该有多大或多复杂。

糟糕的部署策略会降低用户体验。例如，如果你正在为一个用户生成餐馆推荐，在他/她打开应用程序的时候就这么做可能会花费很多时间。用户可能会退出应用程序。在这种情况下，当用户不活动时，可以在一夜之间生成推荐，并将它们缓存在他/她的设备上。

• 需要可解释性吗？任何模型背后的总体目标都是获得最佳指标。通常，这是以可解释性为代价的。越复杂，我们就越不知道模型内部发生了什么。然而，我们关心的是为什么模型在某些情况下做出了特定的预测。例如，在自动贷款申请系统中，申请人想要知道为什么他们的贷款申请被拒绝。在这种情况下，更简单的带有可解释参数的模型可能更好。

训练 ML 模型后的清单

你思考了上面几节的所有问题，训练了一个模型。那现在怎么办？你只是部署它吗？

没那么快。虽然您训练模型所依据的数据是经过仔细筛选的，但是您的模型还是有办法达到一个较高的指标。例如，考虑预测图像是熊猫还是北极熊的图像分类器。你以近乎完美的准确度训练了一个模型。

模型预测(下图)–熊猫

模型预测(下图)——北极熊

模型预测(下图)——北极熊

前两个预测有道理。第三个呢？应该是熊猫。

仔细查看模型后，发现该模型不是熊猫-北极熊分类器，而是雪草分类器。它经常在绿色的丛林中看到熊猫，在雪地里看到北极熊。

同样，NLP 中的数据泄漏也很常见。如果你正在构建一个情感分类器，确保模型是从代表情感的词中学习，而不是从停用词或任何其他不相关的词中学习。像 LIME 和 Shapley 这样的库有助于解释模型预测。

但是你如何评估一个无监督的模型呢？考虑一个句子嵌入模型。该模型的目标是为语义相似的句子生成高分，为不相似的句子生成低分，并在无监督或自我监督的设置中学习所有内容。在这种情况下，有一个定制的测试套件是很好的，就像手工策划的成对的正面(相似的)和负面(不相似的)例子。这些可以作为“单元测试”用于任何模型。设计多层次的测试。简单的检查模型健全性，例如:

(很好的冰淇淋，政治领袖必须团结起来，0

这是很好的冰淇淋，这甜点棒极了！，1

A/B 测试

一旦你的模型准备好了并且正常了，就差不多是时候把它放到野外了。请记住，您的模型是在本地的受限环境中构建和测试的。但是在生产中事情可能会有所不同。因此，首先进行试运行，然后进行全面部署是至关重要的。

简而言之，A/B 测试用于评估随机设置中变量的两个选项。在我们的电影推荐示例中，我们会随机挑选几千个用户，并仅为这些用户部署新的 ML 模型。几天后，我们将新旧模型在推荐接受率、总花费时间等方面进行比较。如果新模型看起来性能更好，我们就为所有用户部署它。

根据测试的目的，一个好的 A/B 测试有许多设计考虑。

在野外测量模型性能

训练时你有标签。但是在真实环境中搅动模型预测又如何呢？很可能你看不到那里的标签。那么，你应该如何衡量一个活生生的模型的表现呢？

在进入 it 之前，我们为什么要在部署之后测量模型的性能呢？我们不是在一个采样良好的测试集上测试过吗？是的，我们确实这样做了。但是，训练数据分布可能与模型在真实环境中看到的分布有很大不同。例如，在 COVID 之前和 COVID 期间生成的推文可能在词汇、情感和主题方面有不同的分布。因此，这个模型肯定会在它没见过的数据上犯更多的错误。这被称为数据漂移。

您可以跟踪一些代理指标来显示特性分布是否发生了变化。由于训练的 ML 模型在预测中是确定性的，所以数据分布的变化通过特征分布的变化来反映。此外，预测标签分布的变化也可能是警报。如果定型数据标签看到的是 40-60 分布，而模型预测的标签是 20-80 分布，那么您可能需要检查模型。

在某些情况下，监管不力是有可能的。例如，在聊天机器人中，在一些系统生成的消息之后，系统可以询问对话是否对用户有帮助。过于频繁地要求这种验证会损害用户体验。类似地，在搜索或推荐中，通过点击接受结果可以反馈给系统。这种系统可以在线重新训练。

在您检测到模型质量下降后，下一步是通过对新数据进行重新训练来恢复其性能。但是在重新训练之前有一些考虑:

**您应该多久对模型进行一次再培训？**取决于你期望的数据移位频率。请记住，再培训是有成本的，尤其是在再培训大型模型的时候。

**应该只重新训练深度学习模型的最后几层还是整个模型？**您应该使用多少旧数据和多少新数据进行再培训？

这些选择主要取决于您的用例。

偏见和公平

现代深度学习模型是黑箱。我们不知道他们真正学到了什么。一个模型通常赋予一个特征更大的重要性，使其损失最小。当一个模型更加突出某些会引起系统性偏见的词或特征时，问题就出现了。

考虑 word2vec，它可能是为数不多的著名早期语言模型之一。单词向量可以用简单的向量代数来表示语言语义。例如:

国王——男人+女人=王后

同一模型也显示了这种关系。

电脑程序员——男人+女人=家庭主妇

你注意到偏见了吗？

不久前，在谷歌图片搜索中搜索“护士”时，出现了异常多的女性图片。

另一个臭名昭著的例子是亚马逊基于 ML 的招聘系统。亚马逊设计了一种算法，从数百份简历中挑出一份工作的前 5 份简历。人们发现，该制度对女性申请人有偏见，拒绝她们的情况比男性申请人多。

这种系统给公司带来了坏名声和巨大的经济损失。如果一家银行使用 ML 来接受或拒绝贷款申请，该模型可能会对某些种族产生系统性偏见。这显然意味着银行失去了潜在客户和它创造的收入。

偏倚治疗策略

机器学习可以用来消除机器学习模型中的偏差。这类方法分为两类——使用最大似然法去除有偏差的信号，以及使用最大似然法包含减少数据集中偏差的信号。如果在数据集中包括 z 改变了模型预测，则称 ML 模型相对于附加变量 z 有偏差。

有算法被设计来检测 ML 模型中的偏差。像 IBM AI Fairness 360 这样的包提供了这些算法的开源实现。此外，像莱姆和 SHAP 这样的可解释性方法也有助于理解 ML 模型的决策过程。

另一个名为 FairML 的包使用了一个简单的想法，这个想法非常适合黑盒模型。由于模型采用特征的向量或矩阵并预测结果，如果改变特定的特征会彻底且一致地改变模型的结果，则该特征会引入一些偏差。FairML 评估输入特征的相对重要性，以检测输入数据中的偏差。根据该软件包的作者:

" FairML 利用模型压缩和四种输入排序算法来量化模型对其输入的相对预测依赖性

最近，去偏差模型的深度学习方法变得流行起来。在一种这样的方法中，为了从敏感变量 z 中消除分类器的偏差，要求模型预测任务标签 y 以及变量 z 。然而，在反向传播期间，相对于 z 的梯度被求反。因此，不是使用从 z 的梯度来减少损失，该模型现在学习更少地依赖 z 。

所以，这些问题是有解决办法的，你应该研究一下，以确保你的模型是公平的。

结论

总之，为业务用例开发 ML 解决方案是一个多变量的问题。

我们在本文中讨论的只是冰山一角。你的项目面临的挑战会根据你所解决的问题而有所不同。花点时间想想你的要求，然后着手执行。开始时，提前计划可能看起来很耗时，但将来会为你节省更多的时间。

参考

1. 毫升偏差
2. 亚马逊的招聘系统

如何扩展 ML 项目——从经验中吸取的教训

原文：https://web.archive.org/web/https://neptune.ai/blog/how-to-scale-ml-projects

在过去的十年中，机器学习负责将数据转化为组织最有价值的资产。利用 ML 应用构建商业解决方案由于计算云基础设施的进步，使用海量数据集比以往任何时候都更容易，在计算云基础设施中，您可以托管和运行 ML 算法。

在企业层面，ML 模型已被应用于支持许多不同的业务方面，从数据源集成/数据域扩充到定制服务或产品推荐、业务运营成本节约等等。

作为数据科学社区的成员，我们都喜欢在白板上对 ML 模型进行头脑风暴，然后在我们的机器上开发模型。只要数据和/或模型是可管理的，这个一般过程就可以工作。然而，大规模这样做可能会变得极具挑战性。

例如，管理和处理大量数据，选择最佳而高效的训练算法，以及最终部署和监控大规模模型，这些都不是可以在白板上解决的小事。

幸运的是，有更好的方法来扩展和加速 ML 工作负载。在这篇文章中，我将分享我和我的团队面临的最大挑战，以及从大规模 ML 项目中吸取的经验教训。具体来说，我们将讨论:

• 什么是可伸缩性，为什么它很重要？
• 挑战和经验教训/我在扩展 ML 项目中的最佳实践。

什么是可伸缩性，为什么它很重要？

类似于软件开发，建立一个为你和你的团队工作的 ML 模型是很容易的，但是当你需要这个模型为世界各地的人工作时，它会变得非常复杂。如今，人们期望数据团队构建可扩展的应用程序，为数百万用户、驻留在数百万地点、以合理的速度工作。

这导致了一个被称为 MLOps 的全新领域的兴起，致力于 ML 应用程序的容器化、编排和分发——所有这些都使得 ML 项目的扩展更加容易。

为什么可伸缩性很重要？用大量的数据和复杂的算法训练一个 ML 模型既耗费内存又耗费时间。通常不可能在本地计算机上完成。可伸缩性是指以经济高效的方式操作和计算庞大的数据集，这意味着处理大量数据更容易，同时还有其他好处:

在找到最佳模型之前，ML 模型开发包括大量的试验和错误。快速执行的无缝工作流将允许数据团队尝试更多想法并提高工作效率。

• 加强模块化和团队协作

大规模模块化使得复制和重用 ML 应用程序变得容易。因此，组织内的数据科学团队可以共享和协作，而不是各自为政地创建数百条管道。

• 促进 ML 自动化，降低成本:

具有最少人工干预的可扩展的自动化过程不仅使模型更不容易出错，而且还释放了资源来专注于更有影响力的任务。因此，扩展有助于最大限度地利用资源并降低业务成本。

现在，我们已经对 ML 可伸缩性及其给组织带来的好处有了基本的了解，让我们继续讨论我在开发可伸缩 ML 管道时面临的五个挑战，并讨论我在应对这些挑战时学到的经验。

挑战# 1——特性是最难做好的部分

ML 特征是作为系统输入的一组可测量的属性或特征。根据具体的项目，这些特征的来源可能无处不在，从存储在数据仓库中的表格数据表到人类语言和图像像素，最后到来自特征工程的衍生预测器。

为了服务于大规模的 ML 应用程序，我们需要访问和试验数十亿条记录，以创建我们的模型可以消化的有前途的特征的列表。我发现特征生成和存储的工作流程非常具有挑战性，尤其是在大规模完成时。诚然，有人可能会说，这可以通过拥有更强处理能力的机器或转向云服务器来轻松实现。

然而，以上所有只是冰山一角——对我的团队来说，最具挑战性的部分总是在模型在生产中实现的时候。在如此大的范围内，我们如何计算和连续监控特征以确保它们的统计属性保持相对稳定？最重要的是，随着更多的观察不断增加，我们如何存储这些特征以确保我们的模型在这个不断增长的数据集上得到适当的训练？

为了增加另一层挑战，一旦模型#1 投入生产，下一个模型出现，我的团队需要再次进行大规模的特征处理，因为它嵌入在之前的培训工作中。你可以想象这个 ML 基础设施导致了多少重复的工作！

经验教训

考虑到所有这些数据特征挑战，我的团队开始探索使用**(大规模)特征商店**的可能性，这是由优步的米开朗基罗平台在 2017 年引入的概念。一个特征库被称为一个集中的操作数据管理系统，它允许数据团队存储、共享和重用 ML 项目的策划特征。

Feature Store as an important part of ML scalability | Souce

人们普遍认为有两种类型的 ML 特性:离线和在线。离线特性主要用于离线批量操作，一般存储在传统的数据仓库中。相反，在线特性需要(近)实时计算和服务，并存储在键值格式的数据库中，以便快速查找值。大规模的特征存储，例如 Redis，具有支持(离线)批处理和(在线)低延迟服务的能力。

从模型监控的角度来看，要素存储以时间一致的方式维护所有历史数据以及最新值。这使得比较特征值和模型性能就像 API 调用一样简单。

此外，要素存储还有助于最大限度地减少重复工作，因为组织内的内部数据团队可以轻松访问存储在此集中位置的所有可用要素。一些数据科学专家甚至说，未来几年将是功能商店的时代。

挑战 2—数据科学编程语言可能会很慢，选择合适的处理器至关重要

一旦要素/输入预测值可供访问和使用(可能在要素存储中)，数据科学团队将启动模型开发流程。

大多数 ML 应用程序是用 Python 或 R 编写的，这是数据科学家中最流行的语言。对于我们的团队以及其他很多人来说，我们经常使用多种语言的组合来构建模型。

尽管我很喜欢用 Python 和 R 编写代码，但我不得不指出，出于速度的考虑，大规模的 ML 模型很少用这些语言进行产品化。与 Python 和 R 相比，更快的生产语言如 C/C++或 Java 更受青睐(与软件开发场景相同)。因此，将 Python 或 R 模型包装成 C/C++或 Java 给我们的团队带来了另一个挑战。

除了编程语言，还需要强大的处理器来执行迭代、繁重的计算操作。这使得硬件成为 ML 可扩展性中最关键的决策之一，尤其是关注矩阵乘法的快速执行。

经验教训

一句话:就大规模的 ML 应用程序而言，Java 可能不是最好的语言，CPU 也可能不是最优的！

Java 被认为是顶级的 ML 生产语言，主要是因为从业者认为它比 Python 或 r 执行得更快。Python 或 R 中的 ML 包经过优化，集成了 C/C++上的包装函数，这使得计算速度比原生 Java 更快。

同样的计算速度，从我的经验来看，由于顺序处理的性质，CPU 对于大规模的 ML 模型来说远非最佳。对于可能受益于并行处理的计算，GPU 是一个很好的选择。

CPUs are far from optimal for ML models at scale due to their sequential processing nature |Source

另一个进步是 ASICs(专用集成芯片)，例如，谷歌的 TPUs(张量处理单元)。为了降低计算复杂度和节省成本，TPU 被专门设计成在不访问存储器的情况下执行矩阵乘法。事实上，一个简单的 TPU 初始化是我的团队坚持使用 Google Tensorflow 框架的部分原因，即使考虑到不同版本 tensor flow 臭名昭著的兼容性问题。

挑战 3–分析数据太大和/或 ML 算法太复杂，单台机器无法处理

我的团队从事的项目之一是开发大规模图像分类算法。对于像这样有大规模数据和模型的项目，在单台计算机上进行 ML 的传统方法不再有效。这导致了分布式 ML 的解决方案，它可以以计算和内存可扩展的方式处理大数据和复杂算法。分布式 ML 背后的想法很直观:如果我们的算法不能在单个节点上完成，我们可以将计算工作量分布在多个节点上。

与分布式 ML 相关的一个概念是并行性或并行处理，它既指数据(处理)并行性，也指算法(构建)并行性。通过划分数据或 ML 模型并将计算工作分配给不同的工作人员，我们可以同时利用多个内核来获得更快的性能。事实上，在我们的图像分类项目中，我们能够通过分布式 ML 算法获得 10 倍的速度提升。

Parallelism cans work with big data and complex algorithms in a computation- and memory-scalable way | Source

最流行的开源分布式 ML 框架之一是 Apache Hadoop ，它提供了几种编程语言的 MapReduce API。另一个流行的是 Apache Spark ，它可以用来执行更快的内存计算。

就实现而言，大多数成熟的 ML 框架，如 Tensorflow 和 PyTorch ，提供 API 来执行分布式计算，以便您的团队开始使用。

经验教训

一般来说，分布式 ML 工作有效，尤其是数据并行。然而，就算法/模型并行性而言，它可能无法正常工作。

算法并行，在 ML 应用的背景下，主要是关于矩阵操作。对于多个工人同时计算，我们需要将一个巨大的矩阵分成几个更小的部分，将几个分配给每个工人，最后通过工人之间的通信将结果收集回来。最后一步称为同步。在某些情况下，同步可能比分布式计算本身需要更长的时间，因为工作人员通常不会在同一时间完成。

正因为如此，线性可伸缩性(获得与增加的资源百分比相同的性能增加百分比的能力)几乎从未在真正的 ML 项目中发生过(至少从我的经验来看)。

您可能希望花费额外的时间和精力来检查同步后的输出，以确保您的分布式系统的正确配置和 ML 应用程序的收敛。

挑战# 4——ML 部署的框架版本和依赖性问题

问问任何一位已经启动大规模 ML 应用的数据科学家，他们面临的最大挑战是什么。有可能包版本和依赖地狱会是其中之一，我们的团队也不例外。

当我们部署一个 ML 应用程序时，首先，我们必须确保产品化的模型一致地再现它的训练对应物。当 ML 模型涉及大量数据和/或复杂算法时，这一点尤为重要，因为它们可能需要更长的训练时间，并且如果出现任何问题，调试起来也更加困难。

对于我们的团队来说，包版本和依赖性问题是我们的 ML 模型在生产中运行时失败的主要原因。此外，由于对软件包版本的要求，我们过去在每个虚拟机上只托管一个产品化模型。

经验教训

如果你问软件开发人员，就编写大型程序而言，他们的最佳实践是什么，很可能将你的代码分成块是其中之一。

将这个想法应用到 ML 部署中，我建议利用 Docker 容器 ，将所有与模型相关的东西捆绑到一个运行在云中的包中。

We can scale up ML using Docker | Source

讨论如何使用 Docker 扩展 ML 超出了本博客的范围。尽管如此，值得强调的是，Docker 容器让我的团队可以在同一个容器环境中运行大规模的工作，并在同一台机器上部署多个应用程序实例。

作为一个旁注/提示，所有的 Docker 图片并不都是一样的。谷歌的 Tensorflow Docker images 经过了高度的性能优化，PyTorch 在 Tensorflow 图像中的运行速度要快于它们自己的 PyTorch 图像。当您为下一个大型 ML 应用程序选择数据科学框架时，这可能会很有用。

我们目前正在探索的另一个基础设施是微服务，这是一种使 ML 应用部署变得可访问的架构。我们将为 ML 管道的每个会话创建一个单独的微服务，这些微服务可以通过 RESTful APIs 访问。这将使我们的大型应用程序更有组织性和可管理性。

挑战# 5——大型 ML 应用从来都不是一次性交易，它需要高效的优化方法来通过迭代过程进行微调或再培训

我们已经建立了一个很好的模型并投入生产。现在是我们打开香槟瓶塞庆祝任务完成的时候了，对吗？很不幸，还没有。

这只是万里长征的第一步！随着我们的组织随着时间的推移获取新数据(在模型部署之后)，我们的应用程序将需要频繁的微调和再培训。

为了解决这个问题，我的团队提出了一个解决方案，当数据漂移(样本的统计属性发生变化)时，可以实现自动模型再训练。对于大规模的 ML 应用，由于时间和计算的高成本，模型调整或再训练可能是具有挑战性的；更不用说这是定期进行的。

诚然，ML 模型再训练的核心部分在于超参数调整。因此，选择和建立有效的超参数调整算法将是有益的。它将使我们能够使用更少的计算时间和成本实现高质量的模型，这是大规模 ML 应用程序的一个主要目标。

经验教训

在超参数搜索方法方面，有几种选择:随机搜索、网格搜索和 贝叶斯优化 。从我的经验来看，对于大规模的 ML 应用，贝叶斯优化优于网格搜索和随机搜索；数据集/参数网格越大，潜在的效率增益就越高。

The core component of ML model retraining lies in hyper-parameter tuning and it’s crucial for  ML applications at scale | Source

这不应该令人惊讶，因为贝叶斯优化基本上是一种智能搜索策略，其中下一个超参数是以一种知情的方式选择的。它有助于减少最佳超参数组合的搜索时间。

挑战	吸取的教训

特性是最难得到正确的组件

|

特征库为 ML 可扩展性提供特征存储、服务和管理支持

|
|

数据科学编程语言可能会很慢，选择合适的处理器至关重要

|

相对于 CPU

，GPU 和 TPU 是并行处理和复杂矩阵操作的更好选择 |
|

分析数据太大和/或 ML 算法太复杂，单台机器无法处理

|

分布式 ML 通过利用多个工人有效地工作

|
|

框架版本与 ML 部署的依赖问题

|

Docker 容器保持 ML 应用的封装，从而在所有部署环境中保持一致，便于扩展

|
|

大型 ML 应用从来都不是一蹴而就的，它需要高效的优化方法来通过迭代过程进行微调或再培训

| |

作为一个额外的提示，在整个组织中扩展性能良好的 ML 应用程序永远不可能通过筒仓工作来实现。它需要相互联系和协作的努力。数据科学、数据工程、数据架构师、DevOps 和所有其他相关团队之间的参与和沟通对于识别 ML 应用不同阶段的潜在风险至关重要。此外，预先定义角色和职责以避免跨 ML 管道的重复工作同样重要。

扩展 ML 应用程序并不容易！希望我在这篇文章中的经验和教训能让你的大规模 ML 应用之旅变得容易一些。感谢您的阅读！

如何用 TensorFlow 服务和 Docker 服务机器学习模型

原文：https://web.archive.org/web/https://neptune.ai/blog/how-to-serve-machine-learning-models-with-tensorflow-serving-and-docker

机器学习(ML)有可能极大地改善业务，但这只有在模型投入生产并且用户可以与之互动的情况下才能实现。

像亚马逊、微软、谷歌、苹果、脸书这样的全球性公司，都有数百款 ML 机型在生产。从更好的搜索到推荐引擎，到数据中心冷却费用降低 40%，这些公司已经开始在他们业务的许多关键方面依赖 ML。将模型投入生产并不是一件容易的事情，虽然该过程与传统软件相似，但它有一些微妙的差异，如模型再训练、数据偏斜或数据漂移，这些都应该考虑在内。

放置 ML 模型的过程不是一个单一的任务，而是许多子任务的组合，每个子任务都有其自身的重要性。这样的子任务之一是模型服务。

“模型服务就是展示一个经过训练的模型，以便端点可以访问它。这里的端点可以是直接用户或其他软件。

在本教程中，我将向您展示如何使用 Tensorflow Serving 来服务 ML 模型，这是一个高效、灵活、高性能的机器学习模型服务系统，专为生产环境而设计。

具体来说，您将学习:

• 如何使用 docker 安装 Tensorflow 服务
• 用 Tensorflow 训练并保存一个简单的图像分类器
• 使用 Tensorflow 服务服务保存的模型

在本教程结束时，您将能够获取任何保存的 Tensorflow 模型，并使其可供其他人使用。

开始之前(先决条件)

为了充分理解本教程，假设您:

以下是一些帮助您开始的链接:

现在简单说一下 Tensorflow 发球(TF 发球)。

Tensorflow 服务简介

“TensorFlow 服务是一个灵活、高性能的机器学习模型服务系统，专为生产环境而设计。TensorFlow 服务使部署新算法和实验变得容易，同时保持相同的服务器架构和 API。TensorFlow 服务提供与 TensorFlow 模型的现成集成，但可以轻松扩展以服务于其他类型的模型。”
— 来源

简单地说，TF Serving 允许您通过模型服务器轻松地公开一个经过训练的模型。它提供了一个灵活的 API，可以很容易地与现有系统集成。

大多数模型服务教程展示了如何使用 Flask 或 Django 构建的 web 应用程序作为模型服务器。虽然这对于演示来说没问题，但在生产场景中效率非常低。

根据 Oreily 的“构建机器学习管道”一书，你不应该依赖传统 web 应用来服务 ML 模型的一些原因包括:

1. **缺乏有效的模型版本控制:**对经过训练的模型进行正确的版本控制非常重要，而大多数为服务模型而构建的 web 应用程序可能会错过这一部分，或者如果存在的话，管理起来可能会非常复杂。
2. **缺乏代码分离:**数据科学/机器学习代码变得与软件/DevOps 代码交织在一起。这很糟糕，因为数据科学团队与软件/DevOps 团队有很大的不同，因此，当两个团队在相同的代码库上工作时，适当的代码管理会成为一种负担。
3. **低效的模型推理:**用 Flask/Django 构建的 web apps 中的模型推理通常是低效的。

Tensorflow 服务为您解决了这些问题。它处理模型服务、版本管理，让您基于策略服务模型，并允许您从不同的源加载您的模型。它在谷歌和世界各地的许多组织内部使用。

您是否知道，由于 TensorFlow + Neptune 集成，您可以跟踪您的模型训练？在我们的文档中了解更多信息。

张量流服务架构

在下图中，您可以看到 TF 服务架构的概述。这个高级架构显示了构成 TF 服务的重要组件。

Overview of the TensorFlow Serving architecture (Source)

在上图中从右到左，让我们从模型源开始:

• 模型源提供插件和功能来帮助你从多个位置(例如 GCS 或 AWS S3 桶)加载模型或 TF 服务术语服务。一旦模型被加载，下一个组件——模型加载器——就会得到通知。
• 模型加载器提供了从给定的源加载模型的功能，与模型类型无关，甚至与用例的数据类型无关。简而言之，模型加载器提供了从源代码加载和卸载模型(可服务的)的有效功能。
• 模型管理器处理模型的整个生命周期。也就是说，它管理何时进行模型更新、使用哪个版本的模型进行推理、推理的规则和策略等等。
• Servable 处理程序提供了与 TF 服务通信所必需的 API 和接口。TF serving 提供了两种重要的可服务处理程序——REST和 gRPC 。在本教程的后面部分，您将了解这两者之间的区别。

有关 TS 架构的更多详细信息，请访问下面的官方指南:

在下一节中，我将绕一点弯路来快速介绍 Docker。这是一个可选部分，我在这里介绍它是因为在安装 TF Serving 时您将使用 Docker。

Docker 简介和安装指南

Docker 是一个计算机程序，它使开发者能够以一种在另一台机器上容易复制的方式轻松打包应用程序或软件。Docker 使用容器，它允许您将应用程序及其库和依赖项打包成一个单独的包，可以在另一个环境中部署。

Docker 类似于虚拟机,只有一些细微的区别，其中之一是 Docker 使用相同的操作系统，而 VMs 使用不同的操作系统实例来将应用程序相互隔离。

Containerized Application (Source)

虽然我不会深入研究 Docker，但我会带您安装它并提取一个简单的 hello world Docker 映像。

首先，为您的操作系统下载并安装 Docker:

通过各自的安装程序下载并安装 Docker 后，在终端/命令提示符下运行以下命令，以确认 Docker 已成功安装:

 docker run hello-world

它应该输出:

Unable to find image ‘hello-world:latest’ locally
latest: Pulling from library/hello-world
0e03bdcc26d7: Pull complete
Digest: sha256:4cf9c47f86df71d48364001ede3a4fcd85ae80ce02ebad74156906caff5378bc
Status: Downloaded newer image for hello-world:latest
Hello from Docker!
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the “hello-world” image from the Docker Hub. (amd64)
3. The Docker daemon created a new container from that image which runs the executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it to your terminal.

如果您得到上面的输出，那么 Docker 已经成功安装在您的系统上。

安装 Tensorflow 服务

现在您已经正确安装了 Docker，您将使用它来下载 TF Serving。

没有 Docker 也可以安装 Tensorflow Serving，但是推荐使用 Docker，而且肯定是最简单的。

在您的终端中运行以下命令:

docker pull tensorflow/serving

这需要一些时间，完成后，将从 Docker Hub 下载 Tensorflow 服务图像。

如果您在具有 GPU 的实例上运行 Docker，您也可以安装 GPU 版本:

docker pull tensorflow/serving:latest-gpu

恭喜你。Tensorflow 服务已安装。在下一节中，您将使用 TensorFlow Keras 训练并保存一个简单的图像分类器。

构建、训练和保存影像分类模型

为了演示模型服务，您将使用 Tensorflow 为手写数字创建一个简单的图像分类器。如果您没有安装 TensorFlow，请在此处遵循本指南。

这不是一个模型优化教程，因此重点是简单性。因此，您不会进行任何大范围的超参数调整，并且构建的模型可能不是最佳的。

MNIST 手写数字分类数据集是一个非常流行的图像分类任务。它包含人类手写的数字，任务是将这些数字分类为 0 到 9 之间的数字。因为数据集非常受欢迎，Tensorflow 预装了它，因此，您可以轻松地加载它。

* MNIST Handwritten dataset (Source)*

下面，我将指导您加载数据集，然后构建一个简单的深度学习分类器。

步骤 1: 创建一个新的项目目录，并在代码编辑器中打开它。我调用我的 tf-server，，并在 VsCode 中打开它。

**第二步:**在项目文件夹中，创建一个名为 **model.py，**的新脚本，并粘贴下面的代码:

import matplotlib.pyplot as plt
import time
from numpy import asarray
from numpy import unique
from numpy import argmax
from tensorflow.keras.datasets.mnist import load_data
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Conv2D
from tensorflow.keras.layers import MaxPool2D
from tensorflow.keras.layers import Flatten
from tensorflow.keras.layers import Dropout

(x_train, y_train), (x_test, y_test) = load_data()
print(f'Train: X={x_train.shape}, y={y_train.shape}')
print(f'Test: X={x_test.shape}, y={y_test.shape}')

x_train = x_train.reshape((x_train.shape[0], x_train.shape[1], x_train.shape[2], 1))
x_test = x_test.reshape((x_test.shape[0], x_test.shape[1], x_test.shape[2], 1))

x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

input_shape = x_train.shape[1:]

n_classes = len(unique(y_train))

model = Sequential()
model.add(Conv2D(64, (3,3), activation='relu', input_shape=input_shape))
model.add(MaxPool2D((2, 2)))
model.add(Conv2D(32, (3,3), activation='relu'))
model.add(MaxPool2D((2, 2)))
model.add(Flatten())
model.add(Dense(50, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(n_classes, activation='softmax'))

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

model.fit(x_train, y_train, epochs=10, batch_size=128, verbose=1)

loss, acc = model.evaluate(x_test, y_test, verbose=0)
print('Accuracy: %.3f' % acc)

ts = int(time.time())
file_path = f"./img_classifier/{ts}/"
model.save(filepath=file_path, save_format='tf')

上面的代码非常简单，首先，导入将要使用的必要包，并加载预先打包了 Tensorflow 的 MNIST 数据集。然后，您将数据整形为使用单通道(黑白)，然后通过除以 1/255.0 进行归一化。

接下来，您创建一个简单的卷积神经网络(CNN ),在输出端有 9 个类，因为您要预测 10 个类(0–9)。然后，通过指定优化器、损失函数和指标来编译模型。

接下来，使用 128 的批量大小来拟合 10 个时期的模型。拟合后，你在测试数据上评估，打印精度，最后保存模型。

保存模型的代码是基于时间戳的。这是一个很好的做法，强烈推荐。

您可以检查文件夹中保存的模型。它应该类似于下图所示:

├── img_classifier
│ ├── 1600788643
│ │ ├── assets
│ │ ├── saved_model.pb
│ │ └── variables

使用 Tensorflow 服务服务保存的模型

一旦保存了模型，并且 Docker 正确安装了 Tensorflow Serving ，您就可以将其作为 API 端点。

值得一提的是，Tensorflow 服务支持两种类型的 API 端点— REST 和 gRPC。

• REST 是 web 应用使用的一种通信“协议”。它定义了客户端如何与 web 服务通信的通信方式。REST 客户机使用标准的 HTTP 方法(如 GET、POST、DELETE 等)与服务器通信。请求的有效负载大多以 JSON 格式编码
• gRPC 另一方面是最初在谷歌开发的通信协议。gRPC 使用的标准数据格式称为协议缓冲区。gRPC 提供了低延迟的通信和比 REST 更小的负载，在推理过程中处理非常大的文件时是首选。

在本教程中，您将使用 REST 端点，因为它更容易使用和检查。还应该注意的是，Tensorflow 服务将在您运行它时提供两个端点，因此您不需要担心额外的配置和设置。

按照以下步骤为您的模型提供服务:

首先在你的项目文件夹中**、**，打开一个终端，并在下面添加 Docker 命令:

docker run -p 8501:8501 --name tfserving_classifier
--mount type=bind,source=/Users/tf-server/img_classifier/,target=/models/img_classifier
-e MODEL_NAME=img_classifier -t tensorflow/serving

让我们来理解每一个论点:

• -p 8501:8501: 这是 REST 端点端口。每个预测请求都将发送到该端口。例如，您可以向 http://localhost:8501 发出一个预测请求。
• —名称 tfserving_classifier: 这是给予运行 tfserving 的 Docker 容器的名称。它可用于稍后启动和停止容器实例。
• — mount type=bind，source =/Users/TF-server/img _ classifier/，target =/models/img _ classifier:mount 命令只是将模型从指定路径(/Users/TF-server/img _ classifier/)复制到 Docker 容器( /models/img_classifier )中，这样 TF Serving 就可以访问它了。

如果遇到路径错误:

docker:来自守护程序的错误响应:类型“bind”的挂载配置无效:绑定源路径不存在:/User/TF-server/img _ classifier/。

然后指定模型文件夹的完整路径。记住，不是模型本身，而是模型文件夹。

• **-e MODEL _ NAME = img _ classifier:**要运行的模型名称。这是您用来保存模型的名称。
• -t tensorflow/serving: 要运行的 TF Serving Docker 容器。

运行上面的命令启动 Docker 容器，TF Serving 公开 gRPC (0.0.0.0:8500)和 REST (localhost:8501)端点。

既然端点已经启动并运行，您可以通过 HTTP 请求对它进行推理调用。下面我们来演示一下。

在您的项目文件夹中创建一个名为 **predict.py，**的新脚本，并添加以下代码行来导入一些包:

import matplotlib.pyplot as plt
import requests
import json
import numpy as np
from tensorflow.keras.datasets.mnist import load_data

requests 包用于构造 HTTP 调用并将其发送到服务器，而 json 包将用于在发送数据(图像)之前对其进行解析。

接下来，您将加载数据并对其进行预处理:

(_, _), (x_test, y_test) = load_data()

x_test = x_test.reshape((x_test.shape[0], x_test.shape[1], x_test.shape[2], 1))

x_test = x_test.astype('float32') / 255.0

注意，我们只关心这里的测试数据。您将加载它，并执行您在模型训练期间添加的相同预处理步骤。

接下来，定义 REST 端点 URL:

url = 'http://localhost:8501/v1/models/img_classifier:predict'

预测 URL 由几个重要部分组成。一般结构可能如下所示:

http://{ HOST }:{ PORT }/v1/models/{ MODEL _ NAME }:{ VERB }

• 主机:您的模型服务器的域名或 IP 地址
• 端口:你的 URL 的服务器端口。默认情况下，TF Serving 对 REST 端点使用 8501。
• MODEL_NAME :你服务的模特的名字。
• 动词:动词与你的模特签名有关。您可以指定预测、分类或回归之一。

接下来，添加一个向端点发出请求的函数:

def make_prediction(instances):
   data = json.dumps({"signature_name": "serving_default", "instances": instances.tolist()})
   headers = {"content-type": "application/json"}
   json_response = requests.post(url, data=data, headers=headers)
   predictions = json.loads(json_response.text)['predictions']
   return predictions

在上面的预测代码中，首先定义一个 JSON 数据负载。TF Serving 期望数据为 JSON，格式为:

{ “签名 _ 名称”:“<字符串>”，
“实例”:<值> }

“签名名”是可选的，可以忽略。“实例”另一方面是您想要预测的数据/输入/实例。你应该把它作为一个列表来传递。

构造完参数后，您向端点发送一个请求，并加载返回的响应。

为了测试这一点，您将对 4 幅测试图像进行预测，如下所示:

要运行 predict.py 文件，在新的终端窗口中运行python predict.py之前，确保 TF 服务容器仍然是活动的。

predictions = make_prediction(x_test[0:4])

//output
[[1.55789715e-12, 1.01289466e-08, 1.07480628e-06, 1.951177e-08, 1.01430878e-10,
5.59054842e-12, 1.90570039e-17, 0.999998927, 4.16908175e-10, 5.94038907e-09],
[6.92498414e-09, 1.17453965e-07, 0.999999762, 5.34944755e-09, 2.81366846e-10,
1.96253143e-13, 9.2470593e-08, 3.83119664e-12, 5.33368405e-10, 1.53420621e-14],
[3.00994889e-11, 0.999996185, 4.14686845e-08, 3.98606517e-08, 3.23575978e-06,
1.82125728e-08, 2.17237588e-08, 1.60862257e-07, 2.42824342e-07, 4.56675897e-09],
[0.999992132, 5.11100086e-11, 2.94807769e-08, 1.22479553e-11, 1.47668822e-09,
4.50467552e-10, 7.61841738e-06, 2.56232635e-08, 6.94065747e-08, 2.13664606e-07]] 

这将返回一个与您预测的 4 幅图像相对应的 4x 10 数组，以及每个类别的概率值(0–9)。

要获得实际的预测类，可以使用如下所示的“np.argmax”函数:

for pred in predictions:
    print(np.argmax(pred))

 7
2
1
0 

您还可以通过与真实值进行比较来检查预测的正确程度，如下所示:

for i, pred in enumerate(predictions):
    print(f"True Value: {y_test[i]}, Predicted Value: {np.argmax(pred)}")

//output
True Value: 7, Predicted Value: 7
True Value: 2, Predicted Value: 2
True Value: 1, Predicted Value: 1
True Value: 0, Predicted Value: 0

predict.py 的完整代码如下所示:

import matplotlib.pyplot as plt
import requests
import base64
import json
import numpy as np
from tensorflow.keras.datasets.mnist import load_data

(_, _), (x_test, y_test) = load_data()

x_test = x_test.reshape((x_test.shape[0], x_test.shape[1], x_test.shape[2], 1))

x_test = x_test.astype('float32') / 255.0

url = 'http://localhost:8501/v1/models/img_classifier:predict'

def make_prediction(instances):
   data = json.dumps({"signature_name": "serving_default", "instances": instances.tolist()})
   headers = {"content-type": "application/json"}
   json_response = requests.post(url, data=data, headers=headers)
   predictions = json.loads(json_response.text)['predictions']
   return predictions

predictions = make_prediction(x_test[0:4])

for i, pred in enumerate(predictions):
   print(f"True Value: {y_test[i]}, Predicted Value: {np.argmax(pred)}")

就是这样！您已经能够:

• 保存一个训练好的模型，
• 启动 TF 服务服务器，
• 并向其发送预测请求。

TF Serving 为您处理所有的模型和 API 基础设施，以便您可以专注于模型优化。

请注意，一旦新模型出现在 model 文件夹中，TF serving 就会自动加载它。例如，更改模型的一些参数，如历元大小，然后重新训练模型。

一旦训练完成并且您保存了模型，TF Serving 会自动检测这个新模型，卸载旧模型，并加载新版本。

模型的自动热交换非常有效，并且可以很容易地内置到 ML CI/CD 管道中，这样您就可以更专注于模型优化，而不是模型服务基础设施。

使用 Tensorflow 服务的最佳实践

• 通过 Docker 容器使用 TF 服务是明智的，也更容易，因为这可以很容易地与现有系统集成。如果需要更多的自定义构建或安装，可以从源代码构建 TF Serving。跟随向导到这里。
• 在推理过程中处理大型数据集时，使用 gRPC 作为端点会更有效。另外，请参见在 Kubernetes 上设置 TF 服务。
• 在 Docker 运行阶段加载模型时，可能会出现路径错误。您可以通过指定完整路径而不是绝对路径来解决这个问题。
• 建议将 TF 引入 TFX 管道。这样模特在由 TF 上菜前会被自动审查。
• 有时，默认端口 8501 可能不可用或被其他系统进程使用，您可以在运行 Docker 映像时轻松地将其更改为另一个端口。

结论

在本教程中，您学习了如何:

• 通过 Docker 安装 Tensorflow 服务
• 训练并保存张量流图像分类器
• 通过 REST 端点服务保存的模型
• 通过 TF 服务端点使用模型进行推理

有了这些知识，您就可以为生产环境构建高效的模型管道，不仅可以伸缩，而且可以适当伸缩！

将链接到 Github 上的项目代码

如何解决 ML 中的再现性

原文：https://web.archive.org/web/https://neptune.ai/blog/how-to-solve-reproducibility-in-ml

有可能你遇到了一篇机器学习论文，并试图复制它，却发现你得到了非常不同的结果。你调整你的代码，但总是出错。此时，您正在怀疑自己作为数据科学家的技能，但是不要担心。我在这里告诉你，这完全没关系，这不是你的错！

这是再现性挑战的经典案例，不是机器学习独有的问题。

在科学中，再现性是科学方法的一个主要原则。它表明，从实验或研究中获得的结果或观察结果应该用相同的方法但由不同的研究人员重复，并且这些不同的研究人员获得的结果必须与原始研究人员获得的结果相似。因为一个结果只有在不同的研究团队成功复制几次之后才能成为科学事实。

但是，让我们回到机器学习。ML 中的再现性到底是什么意思？

机器学习中的再现性是什么？

机器学习的可重复性意味着你可以在某些数据集上重复运行你的算法，并在特定项目上获得相同(或相似)的结果。

机器学习中的可再现性意味着能够复制在论文、文章或教程中执行的 ML 编排，并获得与原始工作相同或相似的结果。

大多数 ML 编排通常是端到端的，我指的是从数据处理到模型设计、报告、模型分析或评估到成功部署。

能够复制结果是非常重要的，因为这意味着项目是可扩展的，并准备好推动大规模部署的生产。

再现性来之不易。复杂的挑战使得从论文中复制 ML 结果看起来几乎是不可能的，我们马上就要探索这些挑战。

可以说，机器学习中的再现性取决于任何模型的三个核心要素:

代码:为了实现可重复性，你必须在实验过程中跟踪并记录代码和算法的变化。

**数据:**添加新数据集、数据分布和样本变化都会影响模型的结果。必须记录数据集版本和变更跟踪，以实现可再现性。

**环境:**对于一个可重现的项目，必须捕获构建它的环境。必须记录框架依赖性、版本、使用的硬件以及环境的所有其他部分，并且易于重现。我们的环境应符合以下标准:

• 使用最新的库和文档版本，
• 能够在不破坏设置的情况下返回到先前状态，
• 在多台机器上使用相同的版本，
• 设置随机化参数，
• 使用所有可用的计算能力。

这三个核心元素结合在一起就构成了你的模型。这三者之间的桥梁就是所谓的 ML 管道。

现在我们已经讨论了这些元素，让我们继续讨论机器学习中的再现性挑战。

机器学习中的再现性挑战

1.缺少记录

这可以说是 ML 中可重复实验的最大挑战。当输入和新的决策没有被记录时，通常很难复制所取得的结果。在试验过程中，超参数值、批量大小等参数会发生变化。如果没有这些参数变化的适当记录，理解和复制模型将变得困难。

2.数据的变化

当原始工作的数据被改变时，几乎不可能得到相同的结果。例如，在获得结果后，当新的训练数据被添加到数据集时，不可能获得相同的结果。

数据集上不正确的数据转换(清理等)、数据分布的变化等也会影响再现性的机会。

3.超参数不一致性

当默认的超参数在实验过程中被改变并且没有被正确记录时，它们将产生不同的结果。

4.随机性

ML 充满了随机化，尤其是在发生大量随机化的项目中(随机初始化、随机噪声引入、随机增强、选择隐藏层、丢弃、混洗数据等)。

5.实验

机器学习是实验性的，开发一个模型需要大量的迭代。算法、数据、环境、参数等的变化都是模型构建过程的一部分，虽然这很好，但它会带来丢失重要细节的困难。

6.ML 框架的变化

ML 框架和库在不断升级，用于实现某个特定结果的特定库版本可能不再可用。这些更新可能会导致结果发生变化。例如，Pytorch 1.7+支持来自 NVIDIA 的 apex 库的混合精度，但以前的版本不支持。

此外，从一个框架转换到另一个框架(比如从 Tensorflow 转换到 Pytorch)会产生不同的结果。

7.GPU 浮点差异

再现性的另一个挑战是由于硬件设置、软件设置或编译器而导致的与浮点不同的结果。GPU 架构的变化也使得再现性变得不可能，除非强制执行其中的一些操作。

8.非确定性算法

非确定性算法中，不同运行时同类输入的输出是不同的，这带来了更大的再现性挑战。在深度学习算法中，如随机梯度下降、蒙特卡罗方法等，在实验过程中经常会出现不确定性。深度强化学习也容易受到非确定性的影响，代理从某种程度上不稳定的经验分布中学习，这种学习大多数时候受到非确定性环境和非确定性策略的影响。不确定性的其他来源是 GPU、随机网络初始化和小批量采样。

为了应对这些挑战，我们这些数据科学家必须能够:

1. 跟踪实验过程中代码、数据和环境的变化。
2. 记录实验中使用的所有代码参数、数据和环境。
3. 重用实验中使用的所有代码参数、数据和环境。

现在，让我们来看看解决重现性挑战的解决方案和工具。

1.实验跟踪和记录

模型训练是一个迭代的过程，改变参数的值，检查每个算法的性能，并对其进行微调以获得理想的结果等。在这个过程中，如果没有适当的记录，细节将会丢失，就像他们说的“美在细节中”。

在模型训练和实验期间，你需要能够跟踪发生的每一个变化。让我们来看看一些工具:

• 通过 DVC ，dvc exp 命令跟踪项目的每一个度量，它有一个度量列表，其中存储了度量值以跟踪进度。因此，您可以使用自动版本控制和检查点日志记录来跟踪您的实验。比较参数、度量、代码和数据的差异。应用、删除、回滚、恢复或共享任何实验。

点击这里查看更多关于 DVC 实验的实用介绍。

• Neptune 允许您记录 ML 运行期间发生的任何事情，包括指标、超参数、学习曲线、训练代码、配置文件、预测(图像、表格等)、诊断图表(混淆矩阵、ROC 曲线等)和控制台日志。

了解更多信息

检查如何以自动化的方式版本化你的代码和数据。

• MLflow Tracking 使用 mlflow.autolog()函数自动跟踪和记录每个模型运行和部署的参数、指标和代码版本。这必须在培训之前完成，它可以在本地和远程保存每个实验日志。

• Pachyderm 自动报告匿名使用指标。它还跟踪模型开发过程中使用的所有代码和数据。

• WandB 允许您跟踪实验，提供一个仪表板，您可以在其中实时可视化实验，并允许您记录超参数和每次实验运行的输出指标。

• Comet 帮助数据科学团队跟踪实验代码、指标依赖等。它还有助于在模型的生命周期中比较、解释和优化实验指标和模型。

了解更多信息

你可以在这里获得更多你的 ml 追踪的追踪工具-> 15 个追踪机器学习实验的最佳工具。

2.元数据储存库

机器学习中的元数据是描述数据集、计算环境和模型的信息。ML 再现性取决于此，如果不记录和存储元数据，就无法重新创建实验。一些流行的工具可以帮助你记录和跟踪任何元数据和元数据的变化:

• DVC 通过创建元文件作为指向存储的数据集和模型的指针来进行数据和模型版本控制。这些图元文件是使用 Git 处理的。
• Neptune 有一个可定制的 UI，允许你比较和查询你所有的 MLOps 元数据。
• TensorFlow Extended (TFX) 使用 ML 元数据(MLMD) 库存储元数据，并使用 API 从存储后端记录和检索元数据；它也有现成的 SQLite 和 MySQL 的参考实现。
• Kubeflow 元数据存储库帮助数据科学家跟踪和管理其工作流程产生的大量元数据。

阅读更多

要了解有关元数据工具的更多信息，请查看此处-> 最佳元数据存储解决方案。

3.艺术品商店

机器学习中的工件是描述完全训练的模型的训练过程的输出的数据，或者用 ML 术语来说，模型检查点。工件存储记录了模型中的每个检查点。管理和存储每一个模型检查点在可再现性上是很重要的，因为工件使得模型很容易被 ML 团队成员复制和验证。工具，例如:

• DVC 可以从项目外部访问数据工件，以及如何从另一个 DVC 项目导入数据工件。这有助于将特定版本的 ML 模型下载到部署服务器，或者将模型导入到另一个项目中。
• Neptune 存储 ML 工件，例如到数据集或模型的路径(s3 桶、文件系统)、数据集散列/预测预览(表头、图像文件夹的快照)、描述、谁创建/修改、上次修改时间、数据集大小等。
• Amazon Sagemaker 提供了一个模型工件存储，它存储了模型的 s3 存储桶位置，其中包含了关于模型类型和内容的信息。Amazon Sagemaker 也为 AutoML 实验存储工件。
• Kubeflow 也将工件数据存储在其工件存储中；它使用工件来理解各种 Kubeflow 组件的管道是如何工作的。Kubeflow Pipeline 可以输出工件数据的简单文本视图和丰富的交互式可视化
• WandB 允许您使用下面的代码为实验运行创建一个工件存储。

artifact = wandb.Artifact('my-dataset', type='dataset')

• TFX 元数据也存储您的 ml 管道中生成的模型工件，并通过 SQLite 和 MySQL 存储它们。见下图

4.版本控制

这是一个软件开发工具，有助于管理对代码所做的更改。VCS 通过跟踪源代码中发生的每一个小变化来减少错误和冲突的可能性。

如果您正在处理启用了 VCS 的项目，您将拥有以下内容:

• 每次修改的版本都会被记录和存储，这样在出错的时候很容易恢复。
• 对于每个团队成员，都维护了源代码的不同副本。在得到其他团队成员的验证之前，它不会合并到主文件中。
• 记录了关于谁、为什么以及对项目做了什么更改的信息。

Git 是软件开发中 VCS 最流行的例子。Git 是一个免费的开源分布式版本控制系统，用于跟踪任何一组文件的变化。

5.模型版本控制

模型版本化是组织控件、跟踪模型中的更改以及实现模型策略的整个过程。有助于模型版本化的工具:

• DVC 通过创建元文件作为指向存储的数据集和模型的指针，同时将它们存储在本地或云中，来进行数据和模型版本控制。这些图元文件是使用 Git 处理的。git commit 等命令

• Neptune 可以让你在实验的时候存储和跟踪不同的模型版本。它允许您比较不同的模型版本，还允许您对模型进行过滤、分组和排序。

• MLflow Model Registry 是一个集中的模型存储库，允许您自动保存并跟踪注册模型的版本。您可以在 MLflow 中使用 log_model 方法来实现。一旦您记录了模型，您就可以通过 UI 或 API 在模型注册中心添加、修改、更新、转换或删除模型。

• WandB 为构建的每个模型提供自动保存和版本控制。每个模型版本的工件都被存储起来，从而创建一个开发历史，并允许我们使用模型的先前版本。您也可以通过索引或其他自定义别名使用任何其他版本。

Source: Author

6.数据版本化

在输入或添加更多训练数据的过程中，数据会不时发生变化。数据版本化意味着随时跟踪和记录每一个数据变化。数据集是可以更新的，试图用更新的数据集复制模型是不可能的。有了数据版本控制，您可以跟踪每一个数据

• DVC 在一个 XML 文件中单独存储有关数据的信息，并存储数据处理和加工，从而实现高效共享。对于大型数据集，DVC 使用一个共享缓存来高效地存储、版本化和访问数据集上的数据。同样对于外部数据，DVC 支持亚马逊 S3，宋承宪，HDFS。
• Neptune 支持多种记录和显示数据集元数据的方式。您可以使用名称空间和基本的日志记录方法来组织应用程序中的任何 ML 元数据。通常，人们会记录数据集的 md5 哈希、数据集的位置、类列表和功能名称列表。
• Delta Lake 为您的数据湖带来可靠性，在您的实验运行中统一批量数据处理，并且它在您现有的数据湖之上工作。它与 Apache Spark APIs 兼容。
• Pachyderm 版本在处理数据时控制数据。它跟踪数据修订并阐明数据沿袭和转换。它处理纯文本、二进制文件和非常大的数据集
• WandB 允许您将数据集存储在其工件存储中，并使用其工件引用直接指向系统中的数据，如 S3、GCP 或本地托管的数据集。
• Qri 是一个开源的分布式数据集版本控制系统，可以帮助你清理、版本化、组织和共享数据集。它可以通过命令行、桌面 UI(macOS 和 Windows)和云来使用。它记录对数据集所做的每一次更改，并通过戳记保存它们

7.数据沿袭跟踪

每个模型都是对其进行训练的数据的压缩版本，随着时间的推移，数据会发生变化，如新的训练数据或现有数据的变化会使模型的预测过时，因此必须跟踪这方面的变化。这可以通过数据沿袭来实现。

数据沿袭是理解、记录、可视化数据从其来源到最终消费的变化和转换的过程。它提供了关于数据如何转换、转换了什么以及为什么转换的每个细节。了解数据集的数据血统有助于再现性。

• MLflow 使用三角洲湖来跟踪模型中使用的大规模数据。
• Pachyderm 帮助您找到数据源，然后在模型开发过程中对其进行跟踪和版本化。Pachyderm 还允许您快速审计数据版本跟踪和回滚中的差异
• Apatar 使用可视化来显示数据从起点到终点的流动。这是一个开源的提取、转换和加载(ETL)项目，用于跨多种格式和来源移动数据。它提供了内置的数据集成工具和数据映射工具。
• Truedat ，一个开源的数据治理工具，提供从模型开始到结束的端到端数据可视化。
• CloverDX 通过开发人员友好的可视化设计器为您的数据集提供数据沿袭。它有利于自动化数据相关的任务，如数据迁移，而且速度很快。

可以使用基于模式的沿袭、数据标记和解析等技术来跟踪数据。

8.随机化管理

如前所述，机器学习中有很多随机性，例如随机初始化、随机噪声引入、随机增强、选择隐藏层、放弃，为了克服随机性，设置并保存您的环境种子。

您可以按如下方式设置种子值:

import os
os.environ['PYTHONHASHSEED'] = str(seed)
random.seed(seed)

或者使用 numpy 伪随机生成器来设置固定的种子值:

import numpy as np
np.random.seed(seed_value)
from comet_ml import Experiment

或者使用 TensorFlow 伪随机生成器来设置固定的种子值:

import tensorflow as tf
tf.set_random_seed(seed_value)

您还可以配置新的全局“tensorflow”会话:

from keras import backend as K
session_conf = tf.ConfigProto(intra_op_parallelism_threads=1, inter_op_parallelism_threads=1)
sess = tf.Session(graph=tf.get_default_graph(), config=session_conf)
K.set_session(sess)

In pytorch:

import torch
torch.manual_seed(0)

设置种子参数以避免随机初始化是很重要的，为你正在使用的框架设置种子参数。使用 GPU 时，种子参数可能会被忽略。但是，设定和记录你的种子仍然很重要。还有，请不要像超参数一样优化你的种子。为了克服拆分数据进行训练、测试和验证时的随机性，请在 test_split_train 代码中包含种子参数。

9.模型注册表

Model registry 是一种跟踪机制，它记录和存储所有的模型元数据、沿袭和版本化日志。它捕获了训练期间使用的数据集、谁训练了模型、模型训练时使用了什么指标以及何时将它部署到生产中。

• Neptune model registry 允许您将您的模型组织到一个中央模型注册表中，供进行大量实验的研究和生产团队使用。

• MLflow Model Registry 允许您用唯一的名称、版本、阶段和其他元数据注册您的模型。

• Comet 允许你通过用户界面或者 comet python SDK 注册你的模型。

Card view of registered models in Comet | Source

10.依赖性管理

如果不匹配与模型构建时相同的开发环境和软件库/框架，几乎不可能复制模型。正如你所知道的，ML 框架是不断升级的，所以存储和保存软件版本的信息以及在构建模型时使用的环境是很重要的。诸如 Conda、Docker、Kubeflow、Pipenv、Singularity 等工具将帮助您存储环境和软件依赖性。

• Docker 使得使用一个单一的环境变得很容易，这个环境包含了运行项目所需的所有依赖项、框架、工具和库。在 docker 中，团队可以使用预构建的 Docker 映像轻松构建环境，这些映像可以在 DockerHub 中找到。
• MLflow Projects 允许你为一个项目选择一个特定的环境并指定其参数。
• 使用 Kubeflow，您可以将环境的代码、依赖项和配置打包到一个名为 Dockerfile 的容器中
• Conda : Conda 是一个开源的环境和包管理系统。它允许您快速安装、运行和更新软件包及其依赖项。Conda 可以在本地计算机上轻松创建、保存、加载和切换环境。
• Pipenv :使用 Pipenv，您可以为您的 ml 项目自动创建和管理虚拟环境。

11.协作和交流

建立模型或进行研究需要团队合作，从数据工程师到研究人员以及参与该过程的每个人。缺乏沟通很容易导致建设过程中出现问题。所以团队必须使用工具来促进他们之间有效的合作和交流。像 DVC、Github、Neptune.ai、Comet.ml、Kubeflow、Pycharderm 和 WandB 这样的工具允许团队有效地远程协作和交流

• Neptune 帮助您的团队协作构建 ML 模型。
• Pachyderm 提供跨机器学习工作流程和项目的合作。
• WandB 允许协作，你可以很容易地邀请人们来编辑和评论一个项目。
• Comet 让你与其他人分享和合作项目。
• Colab、Deepnote 等笔记本也提供模型构建方面的协作。

12.避免不确定的算法

对于相同的输入，非确定性算法在不同的运行中显示不同的行为，这对可重复性来说是个坏消息。

• Pytorch 允许您通过使用torch . use _ deterministic _ algorithms()来避免非确定性算法。每当使用非确定性算法时，此方法都会返回错误。

import torch
torch.use_deterministic_algorithms(True)

• TensorFlow 具有 GPU 确定的功能，可以通过英伟达 NGC TensorFlow 容器或 TensorFlow 版本 1.14、1.15 或 2.0 访问，支持 GPU。

对于 NGC tensorflow 容器(版本 19.06–19.09)，通过以下方式实现:

import tensorflow as tf
import os
os.environ['TF_DETERMINISTIC_OPS'] = '1'

对于 TensorFlow 版本 1.14、1.15 和 2.0，它是这样实现的:

import tensorflow as tf
from tfdeterminism import patch
patch()

13.综合

大多数 MLOps 工具可能不具备成功的端到端模型编排(从模型设计到模型部署)所需的所有特性。工具的无缝集成对于再现性来说是一件好事。

此外，团队中缺乏对某些工具的专业知识也会导致一个项目使用不同的工具。然后，用于这样一个项目的工具相互之间适当地集成是有意义的。

例如:

• Docker 与 AWS、Tensorflow、Kubeflow 集成良好。
• Neptune 使用 neptune-client 与其他 ml 工具和库集成。海王星与牛郎星、Dalex、Fastai、MLflow、Pandas、Pytorch、Tensorflow 等整合良好。
• MLflow 提供了几种可能对您的应用程序有用的标准风格，如 Python 和 R 函数、H20、Keras、MLeap、PyTorch、Scikit-learn、Spark MLlib、TensorFlow 和 ONNX。
• Pachyderm 也可以在 5 分钟左右部署在 AWS/GCE/Azure 上。
• WandB 与 PyTorch、Keras、Hugging Face 等产品集成良好。WandB 支持 AWS、Azure、GCP 和 Kubernetes。

以下是一些可复制工具及其功能的总结:

在笔记本电脑上工作时，您可以查看以下链接，了解有关再现性的更多提示:

结论

再现性是更好的数据科学和 ML 研究的关键，它使你的项目灵活，适合大规模生产。

当你为你的下一个 ML 项目选择工具时，记住没有放之四海而皆准的解决方案(特别是如果你不喜欢 SageMaker 这样的端到端解决方案)。工具的正确选择总是取决于您独特的环境。只要确保您有工具来跟踪您的代码和计算环境，并且存储您的元数据、工件和模型版本。

可重复性，尤其是在研究中，使其他人更容易合作，使您的项目能够长期发展，并有助于正确建立机构知识。但它在商业中同样重要，它可以缩短你的上市时间，提高底线。

小野寺次郎

机器学习工程师和研究员，对人工智能和人类福祉(医疗保健和教育)之间的交叉充满热情。在我的空闲时间，我喜欢尝试新的菜肴和看动漫。

---

阅读下一篇

在 AILS 实验室建立可扩展的医学 ML 研究工作流程[案例研究]

8 分钟阅读| Ahmed Gad |发布于 2021 年 6 月 22 日

AILS Labs 是一个生物医学信息学研究小组，致力于使人类更加健康。这个任务就是建造模型，也许有一天可以拯救你的心脏病。它归结为应用机器学习来基于临床、成像和遗传学数据预测心血管疾病的发展。

四名全职和五名以上兼职团队成员。生物信息学家、内科医生、计算机科学家，许多人都有望获得博士学位。正经事。

虽然业务可能是一个错误的术语，因为面向用户的应用程序还没有在路线图上，但研究是主要的焦点。研究如此激烈，以至于需要一个定制的基础设施(花了大约一年时间建造)来从不同类型的数据中提取特征:

• 电子健康记录(EHR)，
• 诊断和治疗信息(时间-事件回归方法)，
• 图像(卷积神经网络)，
• 结构化数据和心电图。

通过融合这些特征，精确的机器学习模型可以解决复杂的问题。在这种情况下，这是心血管一级预防的*风险分层。*本质上，它是关于预测哪些患者最有可能患心血管疾病。

AILS 实验室有一套完整的研究流程。每个目标都有七个阶段:

1. 定义要解决的任务(例如，建立心血管疾病的风险模型)。
2. 定义任务目标(例如，定义预期的实验结果)。
3. 准备数据集。
4. 使用 Jupyter 笔记本以交互模式处理数据集；快速试验，找出任务和数据集的最佳特性，用 R 或 Python 编码。
5. 一旦项目规模扩大，使用像 Snakemake 或 Prefect 这样的工作流管理系统将工作转化为可管理的管道，并使其可重复。否则，复制工作流程或比较不同模型的成本会很高。
6. 使用 Pytorch Lightning 与 Neptune 集成创建机器学习模型，其中应用了一些初始评估。记录实验数据。
7. 最后，评估模型性能并检查使用不同特征和超参数集的效果。

扩大机器学习研究的 5 个问题

AILS Labs 最初是由一小群开发人员和研究人员组成的。一个人编写代码，另一个人审查代码。没有太多的实验。但是协作变得更具挑战性，随着新团队成员的到来，新问题开始出现:

1. 数据隐私，
2. 工作流程标准化，
3. 特征和模型选择，
4. 实验管理，
5. 信息记录。

Continue reading ->

---

如何构建和管理自然语言处理(NLP)项目

原文：https://web.archive.org/web/https://neptune.ai/blog/how-to-structure-and-manage-nlp-projects-templates

如果说我在 ML 行业工作中学到了什么的话，那就是:机器学习项目很乱。

这并不是说人们不想把事情组织起来，只是在项目过程中有很多事情很难组织和管理。

你可以从头开始，但有些事情会阻碍你。

一些典型的原因是:

• 笔记本中的快速数据探索，
• 取自 github 上的研究报告的模型代码，
• 当一切都已设置好时，添加新的数据集，
• 发现了数据质量问题并且需要重新标记数据，
• 团队中的某个人“只是快速地尝试了一些东西”,并且在没有告诉任何人的情况下改变了训练参数(通过 argparse 传递),
• 从高层推动将原型转化为产品“仅此一次”。

多年来，作为一名机器学习工程师，我学到了一堆东西，它们可以帮助你保持在事物的顶端，并检查你的 NLP 项目(就像你真的可以检查 ML 项目一样:)。

在这篇文章中，我将分享我在从事各种数据科学项目时学到的关键指针、指南、技巧和诀窍。许多东西在任何 ML 项目中都是有价值的，但有些是 NLP 特有的。

涵盖的要点:

• 创建良好的项目目录结构
• 处理变化的数据:数据版本化
• 跟踪 ML 实验
• 正确评估和管理指标和 KPI
• 模型部署:如何正确使用

让我们跳进来。

目录结构

数据科学工作流由多个元素组成:

• 数据，
• 模特，
• 报告，
• 培训脚本，
• 超参数，
• 诸如此类。

拥有一个跨团队一致的公共框架通常是有益的。很可能你有多个团队成员在同一个项目中工作。

有许多方法可以开始构建您的数据科学项目。您甚至可以根据团队的特定需求创建自定义模板。

然而，最简单快捷的方法之一就是使用千篇一律的模板。它会自动为您生成一个全面的项目目录。

├── LICENSE
├── Makefile           <- Makefile with commands like `make data` or `make train`
├── README.md          <- The top-level README for developers using this project.
├── data
│   ├── external       <- Data from third party sources.
│   ├── interim        <- Intermediate data that has been transformed.
│   ├── processed      <- The final, canonical data sets for modeling.
│   └── raw            <- The original, immutable data dump.
│
├── docs               <- A default Sphinx project; see sphinx-doc.org for details
│
├── models             <- Trained and serialized models, model predictions, or model summaries
│
├── notebooks          <- Jupyter notebooks. Naming convention is a number (for ordering),
│                         the creator's initials, and a short `-` delimited description, e.g.
│                         `1.0-jqp-initial-data-exploration`.
│
├── references         <- Data dictionaries, manuals, and all other explanatory materials.
│
├── reports            <- Generated analysis as HTML, PDF, LaTeX, etc.
│   └── figures        <- Generated graphics and figures to be used in reporting
│
├── requirements.txt   <- The requirements file for reproducing the analysis environment, e.g.
│                         generated with `pip freeze > requirements.txt`
│
├── setup.py           <- Make this project pip installable with `pip install -e`
├── src                <- Source code for use in this project.
│   ├── __init__.py    <- Makes src a Python module
│   │
│   ├── data           <- Scripts to download or generate data
│   │   └── make_dataset.py
│   │
│   ├── features       <- Scripts to turn raw data into features for modeling
│   │   └── build_features.py
│   │
│   ├── models         <- Scripts to train models and then use trained models to make
│   │   │                 predictions
│   │   ├── predict_model.py
│   │   └── train_model.py
│   │
│   └── visualization  <- Scripts to create exploratory and results oriented visualizations
│       └── visualize.py
│
└── tox.ini            <- tox file with settings for running tox; see tox.testrun.org

如您所见，它几乎涵盖了您工作流程中的每一个重要组成部分——数据、文档、模型、报告、可视化。

寻找可视化工具？

数据版本化

机器学习是一个迭代的过程。如果你是一名专业的数据科学家，你会注意到最大的不同是，数据不像在竞争或研究基准数据集中那样定义良好。

研究数据集应该是干净的。在研究中，目标是建立一个更好的架构。研究环境中更好的结果应该归功于新颖的架构，而不是聪明的数据清理技巧。

当涉及到生产中使用的数据时，需要做的不仅仅是简单地预处理数据和删除非 unicode 字符。还有更严重的问题，比如:

• 错误或不准确的注释–专业数据科学家花费大量时间了解数据生成过程，因为这几乎会影响他做出的任何进一步决策。人们应该知道以下问题的答案:

  • 谁注释了数据？
  • 在使用产品时，是否有一个独立的团队或由用户注释？
  • 您是否需要具备深厚的领域知识才能成功地注释数据？(例如，医疗保健相关数据就是这种情况)

• 数据的时间线–如果 90 万行数据是很久以前生成的，那么拥有 100 万行数据是没有用的。在消费产品中，用户行为随着趋势或产品修改而不断变化。数据科学家应该问这样的问题:

  • 数据生成的频率如何？
  • 数据生成过程中是否有任何差距(可能生成数据的产品功能被暂时取消了)？
  • 我如何知道我不是在用旧趋势的数据建模(例如在时尚服装推荐中)

• 数据中的任何偏差–数据中的偏差可以是各种类型。其中很多是由于定义不清的数据收集过程造成的。其中一些是:

  • 抽样偏倚–收集的数据不代表总体数据。如果数据具有“年龄”特征，偏见可能导致年轻人的比例过高。
  • 测量偏差–一部分数据用一种仪器测量，另一部分用不同的仪器测量。这可能发生在重工业，那里的机器经常更换和维修。
  • 标签中的偏差–情感分析任务中的标签可能非常主观。这还取决于标签是由专门的注释团队分配还是由最终用户分配。

考虑 NLP 中的文本分类任务，并假设您的产品在全球范围内工作。你可以收集来自世界各地的用户评论。假设印度的用户评论具有与主要语言是英语的美国或英国的用户相似的单词分布是不实际的。在这里，您可能想要创建一个单独的区域版本历史。

这些与您的数据科学工作流程有什么关系？

通常情况下，您开始使用的数据与您构建最终模型时使用的数据大相径庭。对于您在数据中所做的每一个更改，您都需要对其进行版本化。就像你用 Git 控制你的代码版本一样。为此，您可能需要查看一下数据版本控制( DVC )。

实验跟踪

构建模型有时很有趣，但实际上通常很无聊。考虑建立一个 LSTM(长短期记忆网络)进行分类。有学习率、堆叠层数、隐藏维度、嵌入维度、优化器超参数，以及更多要调整的参数。记录每一件事会让人不知所措。

为了节省时间，一个优秀的数据科学家会试图形成一种直觉，判断超参数的什么值有效，什么值无效。记住你已经形成的度量目标是很重要的。您可能想要跟踪哪些关键值？

• 超参数
• 模型大小(针对内存限制)
• 推理时间
• 超过基线的增益
• 优点和缺点(如果模型支持词汇外的单词(如 fasttext)或不支持(如 word2vec)
• 任何有用的注释(例如–)都使用了具有高初始学习率的调度器。比使用恒定的学习速率更有效。

通常，尝试越来越多的实验来从模型中榨取每一盎司的准确性是很诱人的。但是在商业环境中(与 kaggle 竞赛或研究论文相反),一旦指标达到，实验就应该暂停。

Neptune 的简单 API 可以让你追踪实验的每一个细节，并通过它的用户界面进行有效的分析。我第一次使用海王星，花了几分钟开始跟踪我的实验。

您可以查看您的实验，通过超参数值和指标进行筛选，甚至可以查询-“momentum = 0.9 和 lr<0.01”。

海王星记录你的。py 脚本，使你的损失曲线(或一般的任何曲线)交互式可视化，甚至测量你的 CPU/GPU 利用率。

另一个好处是，当你在团队中工作时，所有这些变得更加有用。有了 Neptune，分享成果和在想法上合作变得出奇的简单。

最棒的是，它有一个免费的个人计划，允许用户通过无限制的实验(公共或私人)和无限制的笔记本检查点存储高达 100 GB 的数据。

检查模型预测(误差分析)

下一步包括深入的错误分析。例如，在情绪分析任务中(有三种情绪——积极、消极和中立),问以下问题会有所帮助:

• 创建一个基线:在投入实验之前创建一个基线总是一个好主意。你不希望你的 BERT 模型比 TF-IDF +逻辑分类器的性能稍好。你想让它把你的底线打出水面。始终将您的模型与基线进行比较。我的基线在哪些方面比复杂模型表现得更好？因为基线通常是可解释的，你也可以洞察你的黑盒模型。

• **度量分析:**每个类的精度和召回率是多少？我的错误分类“泄露”到哪里去了？如果负面情绪的大多数错误分类被预测为中性，那么您的模型在区分这两个类别时会遇到困难。对此进行分析的一个简单方法是制作一个混淆矩阵。

• **低置信度预测分析:**模型正确但分类置信度低的例子是怎样的？在这种情况下，预测类别的最小概率可以是 0.33 (⅓):

  • 如果模型预测正确率为 0.35，检查那些例子，看看它们是否真的很难识别。
  • 如果该模型以 0.35 的概率正确预测了一个明显积极的评论，如“我很高兴我做了好工作”，那么事情就有猫腻了。

• 解释框架:你也可以看看像莱姆或 SHAP 这样的框架来解释你的模型预测。

• **看长度 vs 度量分数:**如果你在训练数据中的句子在长度上有很大的可变性，那么检查一下误分类率和长度之间是否有相关性。

• **检查偏差:**模型中有偏差吗？例如，如果在推特上训练，模型对种族言论的表现是否不同？在这种情况下，需要对训练数据进行彻底检查。互联网上的信息包含仇恨言论。然而，模型不应该学习这样的模式。现实生活中的一个例子是 **Tay，**一个由微软开发的推特机器人学习了推特的模式，并在仅仅 24 小时就开始发表种族言论。

如果您的模型在基线上表现不佳，请尝试找出问题所在:

• 是因为标注数据的质量低还是数量少？
• 您是否有更多可以注释的已标记数据或未标记数据？有很多开源注释工具可用于文本数据注释——比如 Doccano 。
• 如果你没有任何数据，可以使用任何现成的模型或者使用迁移学习吗？

回答这些关键问题需要你非常仔细地分析你的实验。

评估无监督的 NLP 模型

作为一个特例，让我们讨论一下你将如何评估一个无监督的 NLP 模型。让我们考虑一个特定于领域的语言模型。

您已经有了一些度量标准来衡量语言模型的性能。其中之一就是困惑。然而，大多数时候，语言模型的目的是学习领域词汇的高质量表示。你如何衡量表现的质量是好的？

一种方法是将嵌入用于下游任务，如分类或命名实体识别 (NER)。看看如果你使用有限的数据，你能保持和你的从头开始训练的 LSTM 一样的表现水平吗？

模型部署

尽管模型部署是在模型被训练之后进行的，但是有几点您需要从一开始就考虑。例如:

• 我需要近乎实时的推理吗？在广告定位等应用中，用户一登陆页面，广告就需要显示出来。因此，定位和排序算法需要实时工作。
• 模型将在哪里托管？–云、内部部署、边缘设备、浏览器？如果您是本地托管，基础架构的大部分构建都由您负责。云在基础架构部署中可以利用多种服务。例如，AWS 提供弹性 Kubernetes 服务( EKS ，无服务器触发功能如λ和 Sagemaker 来创建模型端点。还可以在普通的 EC2 服务器实例中添加自动伸缩策略，以便在需要时提供适当的资源。
• **模型太大？**如果模型很大，你可能想研究一下培训后的量化。这降低了模型参数的精度级别，从而节省了一些计算时间并减小了模型大小。
• 您想在 CPU 或 GPU 服务器上部署模型吗？

一般来说，直接用新模型替换现有模型并不是一个好的做法。您应该执行 A/B 测试来验证模型的健全性。你可能还想看看其他方法，如金丝雀部署或冠军挑战者设置。

摘要

我希望你能为下一个 NLP 项目找到新的思路。

总而言之，我们从为什么认真考虑一个好的项目管理工具很重要开始，数据科学项目由什么组成-数据版本控制、实验跟踪、错误分析和管理指标。最后，我们总结了关于成功模型部署的想法。

如果你喜欢这篇文章，那么下一步就是开始用所有相关的工具构建你自己的 NLP 项目结构。查看工具，如:

谢谢，训练愉快！

德鲁维尔·卡拉尼

i3systems India 的数据科学家
一位热爱数学和编程的数据科学家。他以前的经验使他能够处理大规模的自然语言处理问题，如聊天机器人和文档理解。他认为，教育大众了解技术及其影响与开发新技术同样重要。

---

阅读下一篇

ML 元数据存储:它是什么，为什么重要，以及如何实现它

13 分钟阅读|作者 Jakub Czakon |年 8 月 13 日更新

大多数找到这个页面的人都想改进他们的建模过程。

但是他们在存储和管理 ML 模型元数据方面的问题是不同的。

对一些人来说，问题在于杂乱的实验。

其他人已经将第一批模型部署到生产中，但是他们不知道这些模型是如何创建的，也不知道使用了哪些数据。

有些人已经在生产中有了许多模型，但是编排模型 A/B 测试，切换挑战者和冠军，或者触发、测试和监控再培训管道并不是很好。

如果你认为自己属于这些群体中的一员，或者介于两者之间，我可以告诉你，ML 元数据存储可以帮助你完成所有这些事情，甚至更多。

您可能需要将其连接到其他 MLOps 工具或您的 CI/CD 管道，但它将简化大多数工作流程中的模型管理。

…但是实验跟踪、模型注册、模型存储、模型目录和其他与模型相关的动物也是如此。

那么 ML 元数据存储到底是什么，它与其他模型有什么不同，它如何帮助您更自信地构建和部署模型？

这就是这篇文章的内容。

另外，如果你是那种喜欢摆弄东西来看看它们是什么的人，你可以在 Neptune ML 元数据存储库中查看这个示例项目。

但是首先…

元数据管理和什么是 ML 元数据？

在我们深入 ML 元数据存储之前，我可能应该告诉你我所说的“机器学习元数据”是什么意思。

当你做机器学习时，总会涉及到一个模型。这就是机器学习。

它可能是一个经典的监督模型，如 lightGBM 分类器、强化学习代理、贝叶斯优化算法或其他任何东西。

但它需要一些数据，通过一些数字运行，并输出一个决定。

…将它投入生产需要大量的工作。

Continue reading ->

---

如何构建、组织、跟踪和管理强化学习(RL)项目

原文：https://web.archive.org/web/https://neptune.ai/blog/how-to-structure-organize-track-and-manage-reinforcement-learning-rl-projects

构建和管理机器学习项目可能是一件棘手的事情。

当您投入到一个项目中时，您可能会很快意识到您淹没在 Python 脚本、数据、算法、函数、更新等等的海洋中。在某些时候，你会忘记你的实验，甚至说不出哪个脚本或更新产生了最好的结果。

因此，组织你的项目和跟踪实验 是成功的关键部分。

从这个角度来看，从事一个 ML 项目总体来说可能具有挑战性，但是有些领域比其他领域更复杂。强化学习 ( RL )就是其中比较复杂的一种**。**

本文致力于构建和管理 RL 项目。我会尽量精确，并提供一个全面的分步指南和一些有用的提示。

我们将涵盖:

• 一般提示—项目目录结构， Cookiecutter ，使用 Neptune 跟踪实验，适当评估
• 将问题定义为 RL 问题–强化学习、监督学习、优化问题、最大化和最小化
• 挑选 RL 环境–open ai 健身房
• 选择 RL 库和算法–RL _ 蔻驰、张量力、稳定基线、RL _ 蔻驰准则
• 测试代理的性能
• 准备发布–自述文件、需求、可读代码、可视化

让我们跳进来。

一般提示

首先，你必须回到基础，记住 可以应用于任何 ML 项目的提示。这些是:

1. 项目目录结构
2. 跟踪实验
3. 适当的模型评估

项目目录结构

总的来说，保持工作目录结构化并易于浏览的能力是一项了不起的技能。

当谈到数据科学工作流时，我们面临多种因素，例如:

• 数据
• 模型
• 日志
• 培训和测试脚本
• 超参数文件
• 其他的

有各种各样的实践和方法来构建你的工作目录。根据我个人的经验，最好、最快、最简单的方法是使用 Cookiecutter 模板。

Cookiecutter 是一个有着自己理念的强大工具。它提供了易于浏览的完整文档。

尝试使用 Cookiecutter 模板来构建您下一个 RL 项目的工作目录，您会发现这是多么方便。

跟踪实验

从我的角度来看，最重要的一般提示是跟踪实验。您可能想要跟踪许多关键值:

• 超参数
• 推理时间
• 超过基线的增益
• 任何注释(例如，实验的文本描述)
• 其他的

即使你的目录结构很差，适当的实验跟踪也是一个必须具备的特性。它将使你免于失去工作节奏和有价值的结果。

对于强化学习，由于有了 Neptune ，实验跟踪并不是一项具有挑战性的任务，它可以与大多数 RL 库一起使用。

还有其他的跟踪工具，但是它们不太适合 RL 项目。在选择你的 RL 库的时候记住这一点，并且总是仔细检查你是否可以使用你最喜欢的跟踪工具来跟踪一个特定的库。

尽管如此，海王星是一个稳定和伟大的工具来跟踪你的实验。它有大量有价值的例子和教程，既可以用于你自己的项目，也可以用于团队项目。

你绝对应该在下一个 RL 项目中尝试一下。

恰当的评价

最后但同样重要的是，在评估算法的性能时，您需要既小心又精确。在强化学习领域，评估指标和流程在很大程度上取决于您的问题和您使用的环境。

我建议先检查一下比赛和论坛，因为你可能会发现和你相似的问题，以及有价值的想法和建议。永远不要低估社区的力量，并且总是关注是否有新的有趣的东西。

请记住，在 RL 项目中工作时，如果可能的话，您应该总是查看您的代理执行的视频。当然，这不是一个合适的评估或实验跟踪技术，但它是对其他工具和度量标准的一个很好的补充。

我们已经讨论了基础知识，所以让我们继续讨论解决 RL 问题的所有主要步骤:

1. 将问题定义为 RL 问题
2. 选择一个 RL 环境
3. 选择一个 RL 库和算法
4. 测试代理的性能
5. 准备发布您的项目

将问题定义为 RL 问题

首先，我们需要决定强化学习是否适合我们的问题。这是非常重要的一步，因为我们不想通过使用不合适的学习模型或不相关的算法来使任务过于复杂。

RL 是关于探索和开发，以及它们之间的权衡。这是 RL 和许多其他类型学习的主要区别，比如监督学习。

RL 代理通过与环境互动来学习，尝试不同的行动，并为这些行动获得不同的奖励值，同时目标是在结束时最大化整体奖励。

这是一个与监督学习完全不同的概念，在监督学习中，代理通过将他们的预测与现有标签进行比较来学习，并在之后更新他们的策略。

这就是为什么你需要确定 RL 是否可以用来解决你的问题。

幸运的是，这很容易做到。

想想你的任务是不是一个优化问题。接下来，您必须弄清楚是否有您希望您的 RL 代理学会最大化或最小化的任何指标。

如果你的两个答案都是肯定的，那么强化学习可能是解决这个问题的一个很好的选择，你应该开始考虑一个 RL 环境。

选择一个 RL 环境

如果强化学习很好地解决了你的问题，那么是时候选择或构建运行 RL 算法的基础设施了。

这个基础设施被称为环境。它是用来训练特工的。基本上，环境是一个模拟真实环境的模拟，代理将在真实环境中部署。

有很多不同的 RL 环境:

这也是为什么，如果你不想自己搭建环境，我建议用最流行最常用的——open ai Gym。

如果您确实想构建自己的环境，您将面临一系列挑战。你需要考虑:

1. 环境结构–您想要构建什么类型的环境
2. 环境接口–将环境连接到 RL 算法的接口
3. 测试环境–确保您的实现完美运行，您的 RL 代理将正确学习

说实话，这些都不是在上工作的超级明显的事情。这就是为什么我建议使用有价值的文章和帖子和视频教程来打磨这个话题。希望这足以让你建立自己的 RL 环境。

然而，请记住不要让任务过于复杂，所以只有在必要时才设置自己的环境。使用预装的也没什么不好。

挑选一个 RL 库和算法

在这一点上，你有来选择一个 RL 库和你将用来解决问题的算法。

有很多 RL 库，选择正确的库是项目成功的关键。我推荐阅读“你实际想尝试的 Python 中强化学习的最佳工具”。这篇文章将帮助你做出选择。

总体来说，我强烈推荐 Tensorforce，稳定基线，或者 RL _ 蔻驰。它们似乎是最新的，实现了一组很好的算法，并提供了有价值的教程和完整的文档。此外，它们可以在多种环境下工作，因此设置应该不成问题。

至于 RL 算法的选择，我觉得你已经投入到任务中并选择了算法。如果是这样，那太好了，你应该开始训练你的经纪人了。

如果没有，请检查RL _ 蔻驰文档。在我看来，为如何为你的任务选择正确的算法提供了完美的指导。有这个问题应该对你有很大帮助。

测试代理的性能

现在，当你的 RL 代理被训练后，是时候评估它了。正如我之前提到的，这可能是一个棘手的过程，取决于您的问题和您使用的环境。

尽管如此，我还是想在这里提一些一般性的建议。

如果你的目标是最优控制，你应该使用一些奖励的综合措施。例如，每集的总报酬，或每个时间步长的平均报酬。这将有助于您了解代理在任务中的表现。

如果你正在处理一个视频游戏问题，或者一个设计得很容易识别的问题，使用一个基于奖励的衡量标准的最大界限。之后，您可以将您的代理与这个已知值进行比较。有理由期待一个好的代理会接近最大值。

在实践中，许多有趣的问题没有一个已知的奖励总数或平均值的上限。对于这些问题，通常您能做的最好的事情就是在代理之间进行比较。您可以比较:

• 随机行动的代理人–这通常只是一个基线，表明代理人已经学到了一些东西
• 自动化代理–代理使用简单的行动选择启发式，这可能是给定问题中自然或明显的东西
• 一个或多个人在同一项任务上
• 其他受过 ML 训练的代理包括同一代理的先前实例

如果政策或环境是随机的，你可能想要运行多个测试并平均结果，以尽可能多地评估具有期望值的代理。

在测试期间关闭任何探索也是非常重要的，如果你使用任何不符合政策的技术，比如 DQN，就可以公平地衡量训练有素的代理表现如何。

如果您的代理设计为不断学习和探索，和/或使用政策方法，您可以使用培训期间的结果来评估它。例如，你可以对过去 N 集的总奖励进行滚动平均，或者类似的方法。

此外，这对于监控培训来说是一个不错的指标，甚至对于非政策方法也是如此。尽管对于不符合策略的情况，与单独的测试运行相比，您可能会低估性能。

有其他方法和其他指标来评估代理。例如，代理需要学习多少经验或多少计算才能达到某一水平通常是感兴趣的。

如果你想断定代理人对于最优控制任务的训练是好是坏，这种对总报酬的评估可能就是你所需要的。

但是，您也可以查看任何神经网络内部的损失指标——您不会为了将代理分为更好或更差而这样做，但您可以这样做来识别问题。

这些损失度量通常与监督学习等同物相同。例如，在 DQN，或者对于 PPO 的批评部分，您会对任何状态的预测值是否与最终值匹配感兴趣，并使用 MSE 损失。

准备发布

这是最后一步，在这里你可以发挥创造力，展示你的个性。

不过，请记住，如果你计划向全世界发布你的项目，比如在 Github 上，你可能需要遵循一些简单的规则:

1. 自述文件–请在您的存储库中准备好一份自述文件，它将帮助那些不熟悉您的项目的人建立项目
2. requirements . txt–一个包含您用来制作这个项目的库和库版本的文件
3. 易于定制的可读代码——这对你和潜在用户都有好处
4. 一些有价值的可视化效果–如果是 RL 项目，这可以是你的代理工作的 gif

遵守这些规则是值得的，因为在数据科学社区，它们被认为是基本的礼仪。

就这样，你的项目完成了。恭喜你！

最后的想法

我希望你能为下一个强化学习项目找到新的思路。

总之，我们从构建和管理任何 ML 项目的一些通用技巧开始，并逐步指导如何在强化学习项目中构建您的工作。最后，我们讨论了项目发布的一些想法。

如果你喜欢这篇文章，那么下一步就是开始用所有相关的工具构建你自己的 RL 项目结构。查看工具，如:

感谢阅读，祝训练愉快！

资源

弗拉基米尔·利亚申科

年轻的人工智能爱好者，对医学中的教育技术和计算机视觉充满热情。我想通过帮助其他人学习，探索新的机会，并通过先进的技术跟踪他们的健康状况，让世界变得更美好。

---

阅读下一篇

ML 元数据存储:它是什么，为什么重要，以及如何实现它

13 分钟阅读|作者 Jakub Czakon |年 8 月 13 日更新

大多数找到这个页面的人都想改进他们的建模过程。

但是他们在存储和管理 ML 模型元数据方面的问题是不同的。

对一些人来说，问题在于杂乱的实验。

其他人已经将第一批模型部署到生产中，但是他们不知道这些模型是如何创建的，也不知道使用了哪些数据。

有些人已经在生产中有了许多模型，但是编排模型 A/B 测试，切换挑战者和冠军，或者触发、测试和监控再培训管道并不是很好。

如果你认为自己属于这些群体中的一员，或者介于两者之间，我可以告诉你，ML 元数据存储可以帮助你完成所有这些事情，甚至更多。

您可能需要将其连接到其他 MLOps 工具或您的 CI/CD 管道，但它将简化大多数工作流程中的模型管理。

…但是实验跟踪、模型注册、模型存储、模型目录和其他与模型相关的动物也是如此。

那么 ML 元数据存储到底是什么，它与其他模型有什么不同，它如何帮助您更自信地构建和部署模型？

这就是这篇文章的内容。

另外，如果你是那种喜欢摆弄东西来看看它们是什么的人，你可以在 Neptune ML 元数据存储库中查看这个示例项目。

但是首先…

元数据管理和什么是 ML 元数据？

在我们深入 ML 元数据存储之前，我可能应该告诉你我所说的“机器学习元数据”是什么意思。

当你做机器学习时，总会涉及到一个模型。这就是机器学习。

它可能是一个经典的监督模型，如 lightGBM 分类器、强化学习代理、贝叶斯优化算法或其他任何东西。

但它需要一些数据，通过一些数字运行，并输出一个决定。

…将它投入生产需要大量的工作。

Continue reading ->

---

如何测试推荐系统

原文：https://web.archive.org/web/https://neptune.ai/blog/how-to-test-recommender-system

推荐系统从根本上解决了人们想要什么的问题。

虽然这是一个广泛的问题，但在像电子商务这样的消费者应用程序的上下文中，答案可能是为消费者提供价格和质量最好的产品。对于一个新闻聚合网站，它可以显示可靠和相关的内容。

在用户不得不浏览成千上万的商品来找到他们想要的东西的情况下，推荐引擎是必不可少的。根据 lighthouselabs.ca 的一篇关于网飞使用数据科学的文章:

该引擎基于用户偏好，使用 1，300 个推荐聚类，一次过滤超过 3，000 个标题。它是如此准确，以至于来自引擎的个性化推荐驱动了 80%的网飞观众活动。

然而，与单一的 ML 模型相比，在设计决策、工程和度量方面，构建和评估推荐系统是非常不同的。在本文中，我们将重点测试一个推荐系统。我们还将讨论:

• 1 推荐系统的类型
• 2 最流行模式——协同过滤概述

推荐系统的类型

推荐系统基于三种主要模式工作:

1. **相似性-基于查询内容:**系统根据相似性检索内容。比如你喜欢一个足球视频，它会给你看另一个。或者，如果你搜索一件蓝色 t 恤，它会显示更多的蓝色 t 恤。匹配基于项目内容，如图像、描述、标题等。

2. **群众的智慧:**社交媒体中使用的现代推荐系统就是基于这一点。如果用户 A 喜欢电影 X、Y、Z，用户 B 喜欢电影 X、Z；那么用户 B 可能喜欢电影 y。这些推荐模型不依赖于项目内容，而是考虑用户偏好。这些模型之所以受欢迎，是因为它们超越了主题和内容。他们可以向刚刚喜欢足球视频的热爱体育的用户全面推荐棒球视频。

3. 基于会话:基于会话的系统捕捉用户在特定会话中的意图，并基于会话级上下文信息推荐项目。例如，如果您正在购买新的工作站，并打算购买显示器、键盘、鼠标、椅子等。您希望网站向您显示与在此会话中设置工作站相关的项目，即使您之前可能喜欢某本书。

第二个和第三个需要大量的用户-项目交互数据。如果没有，可以从第一种推荐系统开始。即使现有用户有大量数据，新用户也可能没有足够的数据。这种情况在推荐系统中被称为冷启动问题。在这种情况下，基于内容的推荐系统可以是一个很好的代理，直到有足够的新用户交互数据。

概述够了，现在让我们简单看看一个流行的推荐系统，看看我们如何测试它。

基于协同过滤的模型综述

协同过滤是最流行的经过实战检验的推荐模型之一。这里的目标是训练项目和用户的向量表示，使得具有表示(嵌入)Vu 的用户 U 更喜欢具有表示(嵌入)的项目I****VI的概率是

**

Collaborative filtering is one of the most popular battle-tested recommendation models | Source: Author

模特培训是如何进行的？

对于数据集中的 M 个唯一用户和 N 个唯一项目，我们创建一个嵌入表，维度为D。我们有 D(M+N)* 参数要学习。假设我们正在为 YouTube 构建这个系统，并希望预测用户是否会按下视频上的 like 按钮。我们的训练数据会有几十亿对像 (userId，postId) 如果那个 userId 的用户喜欢过那个 postId 的视频。

Train/test split under the case of recommendation | Source

我们随机初始化嵌入。然后，在训练期间，我们计算标签为 1 和交叉熵损失的概率。在多个时期分批进行这种操作可以训练用户和项目嵌入。

Model training in recommender systems | Source: Author

培训-验证分离发生在用户级别。这意味着，每个用户的 X%的喜欢在训练集中，100-X%在验证集中。x 通常为 80-90%。

推荐系统:目标设计

在前面的例子中，我们训练了一个模型来预测用户是否喜欢 YouTube 上的视频。预测的变量非常简单明了。然而，并不是所有的信号都是明确的。例如，考虑关于用户是否将观看视频长度的 95%的预测变量。如果是这样，我们在数据集中包含 (userId，postId) 。

如果我们有一个近乎完美的模型，预测观看概率> 95%，我们可以说我们在推荐用户喜欢的视频，对吗？

这里有一个问题——考虑一个一分钟的视频(V1)和一个三十分钟的视频(V30)。看完 V1 的 95%需要 57 秒，看完 V30 的 95%需要 1710 秒。V1 也可以是一个点击诱饵视频，而用户可以喜欢 V30，仍然可以观看 1600 秒的视频。那么我们的定义是否保证了正面标签代表了用户偏好？

其次，大多数平台都有多个信号——喜欢、分享、下载、点击等。应该使用哪个目标来训练模型？通常情况下，一个是不够的。假设我们基于不同的目标训练多个模型。我们有来自每个模型的多个 (userId，postId) 分数。然后，基于所有分数的聚合公式创建单个数字分数，用于创建最终排名。

关键是，如果培训目标没有精心设计，即使是近乎完美的模型也不会给出好的建议。

评估推荐系统

离线评估

在本地机器上离线训练一个推荐模型并不能保证它的在线性能。然而，有一些指标来分析预期的模型行为。

ROC-AUC

受试者操作者特征或 ROC 曲线在 Y 轴上测量真阳性率(TPR ),在 X 轴上测量假阳性率(FPR)。对于二元分类器，我们使用一个阈值，高于该阈值的实例被预测为阳性，否则为阴性。对于特定的阈值，

【TPR = %总正阈值以上= TP/(TP + FN)

【FPR = %高于阈值的总否定量= FP/(FP + TN)

在阈值=0 时，所有示例都被分类为阳性。因此，FN=0，因为没有例子被分类为负，并且 TPR=1。出于同样的原因，TN 也为零。因此，FPR 也是 1。这是图上的(1，1)点。

在阈值=1 时，没有示例被预测为阳性。因此 TP 和 FP 都是 0，在图上表示(0，0)。

通过计算[0，1]中不同阈值的 TPR 和 FPR 并绘制它们来绘制曲线。绘制的曲线如下所示:

曲线下的面积最大为 1。如果分类器将标签随机分配给实例，则沿着 x=y 的对角线是 ROC 曲线。

PR-AUC

Precision-Recall AUC 或 PR-AUC 类似于 ROC-AUC，只是在 Y 轴上，我们有 Precision，在 X 轴上，我们有 Recall。正如我们所知，精确度是模型预测的正确率。另一方面，回忆是模型正确分类的全部现存肯定的一部分。

为了更好地理解 PR 曲线，考虑一个二元分类器。如果我们保持低的分类阈值，比如 0.05，大多数例子被预测为阳性。所有现有的阳性将被正确地分类为阳性。尽管如此，我们仍会有许多假阳性，因为真正的阴性也被归类为阳性，这导致了高召回率和低精确度。

另一方面，如果我们保持一个非常高的阈值，该模型做出的大多数正面预测都将是正确的，因为该模型在其所谓的正面预测中非常保守。然而，我们会为了追求始终正确而错过许多实际的肯定，这导致了高精度和低召回率。

注意，在联合优化召回率和精确度之间有一个折衷。像 ROC-AUC 一样，一个完美的分类器应该具有 PR-AUC=1。这条曲线下的面积是 PR-AUC。

然而，在类别分离非常清楚的完美分类器中会存在阈值。所有的正面例子都会在这个阈值以上，所有的负面例子都在这个阈值以下。在这种情况下，AUC 最大，等于 1。

PR-AUC 相对于 ROC-AUC 的显著优势在于，当出现阶层失衡时，它不会产生误导。在不平衡的情况下，ROC-AUC 可以高于 PR-AUC。

排名指标

除了分类，我们还想了解分数的排名顺序。推荐系统的目标不仅仅是挑选出相关的项目，还要根据偏好对它们进行排序。根据福布斯的一篇文章:

谷歌的第一页捕获了 71%的搜索流量点击，据报道近年来高达 92%。第二页的结果远远没有接近第二，在所有网站点击量中不到 6%。

如果你选择了相关的项目，但没有订购它们，这是没有用的。那么我们如何测试我们的模型是否有排名能力呢？

• 归一化贴现累计收益(NDCG)

想象一下你的模型向用户提出的一系列十个建议。你希望看到获得最大点赞的最佳推荐顺序。以下是用户对这十个视频的回应

1，0，0，1，0，1，1，0，1，0，1，0 …(1)

用户喜欢第一、第四、第六、第七和第九条建议。这里订购的最佳案例是什么？

1，1，1，1，1，0，0，0，0 …… (2)

也就是说，如果我们推荐第一、第四、第六、第七、第九，然后是其他的，我们将会获得最好的排名。请注意，第一、第四、第六、第七和第九之间的任何排列都会产生相同的排名。

要计算 NDCG:

Normalised discounted cumulative gains (NDCG) | Source

reli 在我们的例子中表示项目 I-0 或 1 的相关性。p 是项目的总数。对于较低的级别(较低的 I ),总和下的术语比较高的级别具有更大的权重。IDCGp 仅获取相关项目并计算总和，这是通过将所有相关项目排在顶部(表达式 2)并将不相关项目排在底部可以获得的最大 DCG 分数。

注意，对于不相关的项目，分子是 0 (20-1=0)。DCGp 计算分数时，将所有的 p(相关和不相关)按照代表我们的模型在对项目评分后如何对它们进行排序的顺序(表达式 1)来计算。

请注意，NDCG 位于 0 和 1 之间。

如上所述，召回率是模型在全部现有的肯定信息中捕获的肯定信息的比例。对于一组排序的推荐，考虑在位置 k 的特定排序。在位置 1 到 k 中出现的肯定的数量除以肯定的总数量给出我们在 k 的召回

对于许多系统来说，获得所有相关的结果是必不可少的，即使是以一些不相关的结果为代价。在这种情况下，recall@k 给了我们一个关于覆盖率的概念。

与 recall@k 类似，precision@k 计算等级为 k 的模型的精度。这意味着它计算模型正确预测的阳性分数除以总阳性预测。

对于可能不需要全部，而只需要正确结果的情况，precision@k 有助于量化它。

深潜

推荐系统因有偏见而臭名昭著。在我们为 YouTube 建立推荐模型的例子中，我们可能会发现总体 AUC 是好的。然而，当我们在不同层面上分析这些指标时，例如，较长视频与较短视频的 AUC，我们发现较长视频的指标较差，这意味着模型没有很好地学习推荐较长视频。

类似的影响可能发生在任何属性上——地理位置、用户统计数据、主题。知道你的模型哪里做得好，哪里不好是有帮助的。

解决偏见

推荐系统通常比不太受欢迎的长尾内容更多地推送受欢迎的内容。因为受欢迎的内容更有可能被任何随机用户所偏好。这使得该模型能够找到一个“快速修复”的解决方案来最小化损失。然而，用户有许多未开发的兴趣，或者用户可能喜欢许多不太流行的东西。尽管如此，因为它们在训练数据集中出现的频率不高，所以它们的嵌入没有被准确地学习，从而导致偏差。想象一下，Spotify 上仅有的几个流行歌手会获得 Spotify 上数百万歌手中近 90%的播放量。

推荐系统在一个循环中被训练。如果系统向用户推荐有偏见的内容，将对这些有偏见的推荐进行以下训练。随着时间的推移，分布向流行项目倾斜，因为对这些项目的反馈比其他项目观察到的更多——偏差复合。

为什么解决偏见很重要？推荐热门内容有什么问题？如前所述，这使得探索用户的其他兴趣变得困难。从短期来看，流行的内容可能会留住用户，但最终，用户会发现应用程序上没有什么新奇的东西。其次，这使得新创作者很难在应用程序上获得牵引力。新的创作者将没有动力去创造吸引人的、多样化的内容。最终，他们可能会离开这个应用程序。

你如何衡量偏见？

一种简单的方法是查看视图分布。前 1%、5%、10%……的视频获得了多大比例的浏览量，与其他视频相比，这些视频被推荐给用户的频率如何。这种 80-20 效应可以在话题(特定话题主导 app)、创作者(少数热门创作者 vs 小众创作者)等方面看到。机器学习模型学习数据集中的偏差等。因此，如果您的数据集有偏差，那么您的推荐结果很可能会反映出来。

通常，模型会基于某个特征隐含地学习某些偏见。例如，不久前，如果你在谷歌上搜索“CEO”这个词，最上面的结果会是白人男性的照片。类似地，像“护士”这样的词的结果大部分是女性。然而，CEO 这个词是中性的。

根据 washington.edu 的一篇文章:

研究发现，在一些工作中，差异很明显。在谷歌搜索首席执行官的图片中，11%的人是女性，而美国的首席执行官中有 27%是女性。在针对作者的图片搜索结果中，25%的人是女性，相比之下，实际的美国作者中有 56%是女性。

相比之下，图片搜索结果中 64%的电话销售人员是女性，而这一职业男女各半。

测量由属性/特征引起的偏差的一种常用方法是统计奇偶性。简而言之，它测量给定受保护属性 p (例如性别)的模型结果(概率)与没有它的结果的差异。一个无偏的模型应该有:

拥有关于 p 的额外信息不会有什么不同。

如何减轻偏见？

创建更公平的推荐系统是一个活跃的研究领域。解决偏见的一个流行策略是负抽样。在我们的 YouTube 推荐示例中，我们有点击数据。如果我们想要创建一个基于点击预测的推荐模型，我们只有来自受欢迎程度影响的视频的点击数据。为了平衡这一点，我们通过为用户选择随机视频并给他们分配负类来创建样本。这个想法是用户喜欢随机视频的可能性非常低。通过这种方式，我们消除了数据分布的偏差。

除了负面抽样，许多评分机制衡量候选人的多样性。在基于会话的推荐中，可以通过获取用户观看的前 N 个项目并测量要推荐的更多样的主题来引入更多样的推荐。例如，如果有人阅读一些关于政治和电影行业的文章，下面的推荐可以包括一些体育行业的项目。

最大边缘相关度( MMR ) 是信息检索中使用的一种在相关性和多样性之间取得平衡的度量。根据这篇论文——

Maximum margin relevance (MMR) | Source

对于给定的 C 和 Q，C 是文档集合，Q 是查询，R 是由 IR 系统检索的文档的排序列表，S 是 R 中已经选择的文档的子集；RS 是 R 中而不是 S 中的文档集；Sim1 是在文档检索和文档(段落)与查询之间的相关性排序中使用的相似性度量；Sim2 可以与 Sim1 相同，也可以是不同的度量。当参数λ=1 时，MMR 递增地计算标准相关性排序列表，并且当λ=0 时，计算 R 中的文档之间的最大多样性排序。

在线评估

A/B 实验

我们训练模型的目标和我们测量的离线指标可能不是我们在现实中寻找的。例如，如果 YouTube 创建了最准确的模型来预测点击，这可能并不意味着用户流失会减少。尽管该模型推荐了用户喜欢的所有视频，但他们可能仍然会离开，第二天不会回来。

其次，精确地按照一个人想要的来训练一个模型是很难的。例如，训练一个模型来推荐视频以减少流失比基于点击推荐视频更复杂。

标准在线指标包括:

• 用户保持率
• 参与度(喜欢、书签、关注等。)
• 点击
• 购买
• 收入
• 花费的时间
• 建议的多样性。

对任何模型来说，最终的关键时刻是现场 A/B 测试。对照现有模型测试新的变化。例如，假设说学习速度应该是当前速度的 10 倍。我们为平台上的一组随机用户推出了一个新的学习率模型来测试这一点。由于当前模型和新版本运行在相同的用户分布上，在线指标的任何变化都只能归因于学习率的变化。人们可以根据净变化来决定新的变化是好是坏。

测试推荐系统

模型评估与测试

我们看到了如何使用各种度量和分析来评估推荐模型，以便我们的实验和假设成立。然而，当模型交付生产时，事情仍然可能出错。即使是很小的工程错误也会导致意想不到的推荐和糟糕的用户体验。因此，测试每个步骤——推理、重新训练周期、数据集创建和功能范围——对于在线部署至关重要。

在这一节中，我们将看看测试整个推荐系统的一些方法——从模型的行为到管道的健康状况。

推荐系统的行为检查

测量嵌入更新率

由于 RecSys 模型是建立在嵌入基础上的，因此确保正确训练嵌入是至关重要的。每次重新训练，用户和项目的嵌入都会更新。要检查的一个重要指标是不同用户/项目嵌入版本的平均漂移。可以通过测量余弦相似性来检查漂移。

例如，如果用户 A 昨天的嵌入是 e1，并且在重新训练之后是 e2，则漂移被测量为余弦(e1，e2)。理想情况下，该数值不应大于 0.9，但也不应太接近 1。如果太小，则表明嵌入没有收敛。如果它太接近 1，则表明该模型可能没有捕捉到用户的新兴趣。

不同切割的指标

如前所述，单个数字指标看起来可能具有欺骗性。例如，10%的流行项目可以构成 80%的数据集。测量整个数据集的 AUC 可以给出乐观的数字，因为模型必须很好地学习 10%的项目。但是，这意味着模型没有很好地学习项目的长尾。这种疏忽会导致差的多样性和新颖性。在这种情况下，可以分析项目级的度量，并检查所有项目是否都表现得相当好。这同样适用于许多其他属性，如用户、性别、地理位置等。

基于会话的模型的方差测试

基于会话的模型要求模型立即使用新信息来更新建议。一个好的基于会话的推荐模型能够快速准确地适应用户当前的兴趣。

考虑一个基于 RNN 的模型，该模型采用前 N 次交互来为第 N+1 个位置推荐物品。如果模型偏向于流行，势必会推荐 N-2，N-1，N 次交互后的流行单品。然而，一个好的模型会在每次交互后推荐一组不同的项目。在数学上，我们可以看到 RNN 模型中每个时间步长后隐藏状态的变化，就像我们计算嵌入漂移一样(如上所述)。

类似地，如果用户与 10 个跨不同主题(如人工智能、喜剧或足球)的视频进行交互，并对喜剧视频做出积极响应，对其他主题做出消极响应，则下一个推荐应该包括有趣的视频。人们可以在会话历史中测量对某些主题/流派的相似性，并在下一组推荐中测量其表现。

软件检查推荐系统

除了标准的单元和集成测试之外，还有一些 RecSys 特有的行为测试，您应该了解一下”

• 特征一致性:在模型训练过程中，我们可能会用到除嵌入之外的许多特征，比如用户位置、年龄、视频长度等。在使用这些功能之前，通常会对其应用缩放等变换。然而，由于对特征的错误处理，这增加了推断过程中出错的机会。例如，如果您在训练中缩放了某个要素，但在推理中没有缩放，则模型预测可能会发生变化。
• 泄漏特征:许多模型，如基于会话的模型，在每次交互中使用接近实时的信息。例如，用户与之交互的项目数量。如果用户与六个项目 A、B、C、D、E 和 F 交互；该特征的值可以是 0、1、2、3、4、5；因为用户在点击 A 之前与 0 个项目交互，在点击 B 之前与 1 个项目交互，以此类推。我们只使用事件发生前可获得的信息。在离线训练期间，我们应该问在从表中选择数据时，它是否会导致训练中的泄漏。
• 更新嵌入:推荐模型，定期训练。在每个训练周期之后，更新的嵌入应该用于推荐项目。使用旧的嵌入会导致不一致和不准确的推荐。

测试推荐系统的工具

以下是一些测试推荐系统不同阶段的相关工具:

1.数据集创建和特征工程

跟踪特征分布和特征值中的异常是需要跟踪的几个关键数字。通常，推荐模型训练是通过诸如 airflow 或 kedro 之类的工具在 DAGs 中执行的。创建数据集后，可以编写一个测试套件，根据数据中的统计信息测试预期的统计信息。根据可接受的误差范围，可以创建警报。Pytest 是编写这种单元测试的流行工具。

2.培训和部署

大多数推荐模型是使用基于梯度下降的优化以深度学习的方式训练的。自然，学习率和训练步数的重量衰减等超参数开始发挥作用。使用上面讨论的度量和训练-验证损失曲线可以发现训练中的突然性。像 Neptune 这样的工具允许用最小的代码变化来监控模型训练。使用 Neptune 的简单 API 可以记录曲线、指标、超参数和脚本。

像 RecList 这样的开源工具提供了一个易于使用的界面来计算推荐模型评估中最常见的指标。给定数据集和模型，RecList 可以在目标数据集上运行指定的测试。除了度量之外，它还基于不同的切片生成图表和深度聚合。

3.推理

推理需要特性的一致性、可用性、最小延迟以及对更新模型的访问。每一次代码变更，数据科学家都必须确保以上几点。软件工程实践，如代码审查、版本控制(如 Git ),以及自动化测试阶段的 CI/CD 流程(Jenkins，GitHub actions ),确保了安全的软件发布。

结论

在人工智能的许多领域中，如自然语言处理、计算机视觉等，推荐系统的研究相对不足。然而，它们是现代数字应用中最具影响力的应用之一。尽管评估它们并不简单，但是上面的度量标准和想法是一个很好的起点。记住，你应该建立一个推荐系统，而不是一个模型。从长远来看，投资建设坚实的基础设施比制造一个 SOTA 模式更有帮助。**

如何在您的项目中跟踪机器学习模型指标

原文：https://web.archive.org/web/https://neptune.ai/blog/how-to-track-machine-learning-model-metrics

跟踪机器学习模型的评估指标至关重要，以便:

• 了解您的模型做得如何
• 能够将它与以前的基线和想法进行比较
• 了解你离项目目标有多远

“如果你不衡量它，你就不能改进它。”

但是你应该跟踪什么呢？

我从来没有发现自己在这样的情况下，我认为我已经为我的机器学习实验记录了太多的指标。

此外，在现实世界的项目中，您所关心的指标可能会由于新的发现或不断变化的规范而改变，因此记录更多的指标实际上可以在将来为您节省一些时间和麻烦。

不管怎样，我的建议是:

“记录比你认为需要的更多的指标。”

好吧，但是你具体是怎么做的呢？

跟踪单一数字的指标

在许多情况下，您可以为机器学习模型的性能分配一个数值。您可以计算保留验证集的准确度、AUC 或平均精度，并将其用作模型评估指标。

在这种情况下，您应该跟踪每次实验运行的所有这些值。

借助 Neptune，您可以轻松做到这一点:

neptune.log_metric('train_auc', train_auc)
neptune.log_metric('valid_auc', train_auc)
neptune.log_metric('valid_f1', train_auc)
neptune.log_metric('valid_accuracy', train_auc)

跟踪训练数据集和验证数据集的度量可以帮助您评估模型在生产中表现不佳的风险。差距越小，风险越低。Jean-Fran ois Puget 的《kaggle days》是一个很好的资源。

也就是说，有时候，一个单一的值不足以告诉你你的模型是否运行良好。

这就是性能图表发挥作用的地方。

跟踪作为性能图表的指标

要了解您的模型是否有所改进，您可能需要查看图表、混淆矩阵或预测分布。

在我看来，这些仍然是指标，因为它们帮助你衡量你的机器学习模型的性能。

对于 Neptune 测井，这些图表是微不足道的:

neptune.log_image('diagnostics', 'confusion_matrix.png')
neptune.log_image('diagnostics', 'roc_auc.png')
neptune.log_image('diagnostics', 'prediction_dist.png')

如果您想要使用二进制分类指标，您可以记录:

• 所有主要指标，如 f1、f2、brier_loss、准确性等

t

• 所有主要的性能图表，如混淆矩阵、ROC 曲线、精确召回曲线

import neptunecontrib.monitoring.metrics as npt_metrics//r//n//r//nnpt_metrics.log_binary_classification_metrics(y_test, y_test_pred)

跟踪迭代级别的度量(学习曲线)

大多数机器学习模型迭代收敛。深度学习模型、梯度提升树和许多其他模型都是如此。

您可能希望在每次迭代之后跟踪训练集和验证集的评估度量，以查看您的模型是否监控过度拟合。

监控这些学习曲线很容易实现，但却是重要的习惯。

对于简单的基于迭代的训练，它可能是这样的:

for i in range(iterations):

   train_loss = loss(y_pred, y)
   neptune.log_metric('train_loss', train_loss)

在大多数深度学习框架中使用的回调系统的情况下:

class NeptuneLoggerCallback(Callback):
    ...
    def on_batch_end(self, batch, logs={}):
        for log_name, log_value in logs.items():
            neptune.log_metric(f'batch_{log_name}', log_value)

Neptune 集成了大多数主要的机器学习框架，您可以毫不费力地跟踪这些指标。在此检查可用的集成。

在每个时期后跟踪预测

有时，您可能希望在每个时期或迭代后查看一下模型预测。

这在训练需要大量时间收敛的图像模型时尤其有价值。

例如，在图像分割的情况下，您可能希望在每个时期后绘制预测遮罩、真实遮罩和原始图像。

在 Neptune 中你可以使用.log_image方法来做到这一点:

for epoch in epochs:
     …
     mask_preds = get_preds(model, images)
     overlayed_preds = overlay( images, masks_true, masks_pred)
     neptune.log_image('network_predictions', overlayed_preds)

培训完成后跟踪指标

在某些应用程序中，您无法跟踪培训脚本中所有重要的指标。

此外，在现实生活中的机器学习项目中，项目的范围以及您关心的度量标准可能会随着时间的推移而变化。

在这些情况下，您将需要更新实验指标，或者在您的培训工作已经完成时添加新的性能图表。

幸运的是，用海王星更新实验很容易:

exp = project.get_experiments(id='PROJ-421')[0]

exp.log_metric('test_auc'; 0.62)
exp.log_image('test_performance_charts', 'roc_curve_test.png')

请记住，为一个实验或模型引入新的指标意味着您可能需要重新计算和更新以前的实验。通常情况下，一个模型在一个度量上可能更好，而在另一个度量上可能更差。

最后的想法

在本文中，我们了解到:

你应该记录你的机器学习指标

• 如何跟踪单值指标并查看哪些模型表现更好
• 如何跟踪学习曲线以实时监控模型训练
• 如何跟踪性能图表以了解更多信息
• 如何在每个时期后记录图像预测，
• 如果在培训结束后计算评估指标，如何更新实验指标
• 快乐训练！

Happy training!

如何使用 TensorFlow 对象检测 API 训练自己的对象检测器

原文：https://web.archive.org/web/https://neptune.ai/blog/how-to-train-your-own-object-detector-using-tensorflow-object-detection-api

目标检测是一项计算机视觉任务，最近受到机器学习进展的影响。

在过去，创建一个定制的对象检测器看起来是一项耗时且具有挑战性的任务。现在，有了像 TensorFlow 对象检测 API 这样的工具，我们可以快速轻松地创建可靠的模型。

在本文中，我们将重点介绍第二代 TensorFlow 对象检测 API，它:

• 支持张量流 2，
• 允许您使用最先进的模型架构进行对象检测，
• 为您提供了一种配置模型的简单方法。

如果你有兴趣了解 TensorFlow 2 及其 API 中所有可用的特性，你可以在 Google 的官方公告中找到它们。

阅读完本文后，您应该能够创建自己的自定义对象检测器。

我们将使用基于 EfficientDet 的模型作为示例，但是您也将学习如何使用您选择的任何架构来启动并运行模型。敬请期待！你自己的物体探测器就在眼前。

开始之前

让我简单地谈谈开发您自己的对象检测器所必需的先决条件:

• 你应该在你的电脑上安装 Python。如果你需要安装它，我推荐遵循 Anaconda 的官方指南。
• 如果你的计算机有一个支持 CUDA 的 GPU(NVIDIA 制造的 GPU)，那么需要一些相关的库来支持基于 GPU 的训练。如果您需要启用 GPU 支持，请查看 NVIDIA 网站上的指南。您的目标是为您的操作系统安装 CUDA 工具包和 cuDNN 的最新版本。

安装和设置

让我们首先确保我们已经准备好开始使用 TensorFlow 对象检测 API 所需的一切。我将回顾整个设置过程，并解释每一步的工作原理。

如果您已经使用过 TF API，您仍然可以快速浏览一下这一部分，只是为了确保我们遵循相同的方向。

但是如果您是第一次安装 Tensorflow 对象检测 API，我强烈建议您完成本节中的所有步骤。让我们跳进来吧！

1。创建项目目录

在您选择的路径下，创建一个新文件夹。命名为Tensorflow。

2。创建新的虚拟环境

打开一个终端窗口，使用cd命令导航到步骤 1 中创建的Tensorflow文件夹。

• 使用venv库创建一个新的虚拟环境:

• 如果您的机器上已经安装了venv(或者您更喜欢使用另一个工具来管理环境，如*【Anaconda*)，那么直接进行新环境的创建。

如果你不知道什么是venv或者没有安装它，你可以在你的终端窗口中输入以下命令:

为了使用venv创建一个新环境，在您的终端窗口中键入以下命令:

pip install venv

一旦执行完毕，venv将创建一个名为tf2_api_env的新虚拟环境。

python -m venv tf2_api_env

激活新创建的虚拟环境:

• 为了激活我们刚刚创建的虚拟环境，您首先需要确保您当前的工作目录是Tensorflow。您可以通过在您的终端窗口中键入并执行以下命令来检查您当前的工作目录:

为了激活您的虚拟环境，从您的终端窗口运行以下命令:

pwd

如果您在您的终端窗口的命令行开头看到您的环境的名称，那么您就一切就绪了。它应该是这样的:

source tf2_api_env/bin/activate

是时候在我们的环境中安装 TensorFlow 了。确保您的环境已激活，并通过执行以下命令进行安装:

Successful virtual environment activation in the Terminal window

**注:**在我写这篇文章的时候，最新的 TensorFlow 版本是 2.3。您可以使用这个版本，但这不是必需的。我们在本指南中所做的一切都是与 2.3 兼容的，它也可能适用于以后的更新。这取决于你去尝试。如果有任何问题，您可以随时降级到 2.3 并继续前进。

pip install tensorflow==2.*

3。下载并提取 TensorFlow 模型花园

模型花园是 github.com 的官方张量流存储库。在这一步中，我们希望将这个回购克隆到我们的本地机器上。

确保在你的终端窗口中，你位于Tensorflow目录中。

• 在您的 web 浏览器中，转到 Model Garden Repo 并点击代码按钮，以便选择最适合您的克隆方法(选项有 HTTPS、SSH 或 GitHub CLI)。

• 选择克隆方法后，将存储库克隆到您的本地Tensorflow目录。如果你在克隆方面需要额外的帮助，请查看官方 GitHub 指南。

Selecting a cloning method for an official Model Garder Tensorflow repo

• 到现在为止，在Tensorflow目录下应该有如下结构:

4。下载、安装并编译 Protobuf

Tensorflow/
└─ tf2_api_env/
   ├─ bin/
   ├─ include/
   └── …
└─ models/
   ├─ community/
   ├─ official/
   ├─ orbit/
   └── …

默认情况下，TensorFlow 对象检测 API 使用 Protobuf 来配置模型和训练参数，因此我们需要这个库来继续。

前往官方协议发布页面下载与您的操作系统和处理器架构兼容的最新 protobuf 版本的档案。

• 比如我用的是 Ubuntu 。我的 CPU 是 AMD64 (64 位处理器)。当我写这篇文章时，最新的协议版本是 3.13.0 。鉴于所有这些信息，我将从官方协议发布页面下载protocol-3 . 13 . 0-Linux-x86 _ 64 . zip文件。

在Tensorflow项目目录中，创建一个名为protoc的新文件夹。将下载的档案内容解压到Tensorflow/protoc目录。

• 现在，您的Tensorflow目录结构应该如下所示:

确保在你的终端窗口中，你位于Tensorflow目录中。要编译 proto 文件，请执行以下命令:

Tensorflow/
└─ protoc/
   ├─ bin/
   ├─ include/
   ├─ readme.txt
└─ tf2_api_env/
   ├─ bin/
   ├─ include/
   └── …
└─ models/
   ├─ community/
   ├─ official/
   ├─ orbit/
   └── …

5。安装 COCO API

protoc/bin/protoc models/research/object_detection/protos/*.proto
--python_out=.

COCO API 是一个不直接与对象检测 API 相关的依赖项。您应该单独安装它。手动安装 COCO API 引入了一些新功能(例如，一组流行的检测或/和分割指标可用于模型评估)。安装过程如下:

如果您使用的是 Windows:

确保在你的终端窗口中，你位于Tensorflow目录中。逐一运行以下命令:

• 如果您使用的是 Linux:

pip install cython
pip install git+https://github.com/philferriere/cocoapi.git

确保在你的终端窗口中，你位于Tensorflow目录中。逐一运行以下命令:

• 在这一步结束时，您的Tensorflow目录结构应该如下所示:

pip install cython
git clone https://github.com/cocodataset/cocoapi.git
cd cocoapi/PythonAPI
make
cp -r pycocotools ./models/research/

6。对象检测 API 安装

Tensorflow/
└─ cocoapi/
   ├─ common/
   ├─ LuaAPI/
   └── …
└─ protoc/
   ├─ bin/
   ├─ include/
   ├─ readme.txt
└─ tf2_api_env/
   ├─ bin/
   ├─ include/
   └── …
└─ models/
   ├─ community/
   ├─ official/
   ├─ orbit/
   └── …

这是我们的安装和设置块的最后一步！我们将安装对象检测 API 本身。你可以通过安装 object_detection 包来实现。方法如下:

确保在你的终端窗口中，你位于Tensorflow目录中。

• 使用cd命令将当前工作目录从Tensorflow更改为Tensorflow/models/research

• 在您的终端窗口中逐一运行以下命令:

• **注意:**第二个命令可能会给你一个错误。一点也不担心。只需再运行一次，直到你看到一个完整的安装。

cp object_detection/packages/tf2/setup.py .
python -m pip install .

在终端窗口的Tensorflow/models/research目录下运行以下命令，测试安装是否成功:

• 一旦测试完成，您将在您的终端窗口中看到一条打印出来的消息。如果所有 20 个测试都运行了，并且它们的状态是“OK”(有些可能会被跳过，这完全没问题)，那么您就完成了安装！

python object_detection/builders/model_builder_tf2_test.py

工作量很大，所以恭喜你！干得好！

数据准备

当您完成所有安装步骤时，您需要考虑稍后将输入到自定义对象检测模型中的数据。

基于 TensorFlow 对象检测 API 的模型需要一种特殊的格式用于所有的输入数据，称为 TFRecord 。我们将讨论如何将您的数据转换成 TFRecord 格式(为了更好地理解什么是 TFRecord 格式，我强烈推荐阅读这篇文章)，但是首先让我们讨论一些关于您的数据可用性及其注释的假设。具体来说，我们假设:

您已经**收集了数据(图像)**用于模型训练、验证和测试，

• 您的图像被注释用于对象检测，这意味着您的数据集中可能出现的所有感兴趣对象的区域被手动定义为边界框，并且为每个框设置了基本事实标签。
• 如果这些假设对你来说是错误的，你将无法继续进行你的物体检测创作。很简单:没有数据，没有模型。

好消息是有许多公共图像数据集。我强烈建议花些时间搜索你感兴趣的数据集。很有可能你会找到值得你花时间去做的事情。

如果你需要注释，有吨的解决方案可用。挑一个你喜欢的。它们都会给你 JSON 或 XML 格式的注释。两者都适合我们的目的。

这里我不会在图像收集和注释上花太多时间——我希望您能够自己解决这个问题，这样我们就可以进入下一个重要步骤:数据转换。

https://web.archive.org/web/20221206004728im_/https://neptune.ai/wp-content/uploads/2022/11/image-annotation-process.mp4

Image Annotation Process | Source: Article by Rei Morikawa at lionbridge.ai

数据转换

我提到过您的输入数据需要 TFRecord 格式。这一步的目标是将每个数据集(训练、验证和测试)转换成 TFRecord 格式。

为了确保可比性，让我们在您的Tensorflow目录中创建一个名为workspace的子文件夹。我们将使用workspace文件夹来存储所有与模型相关的属性，包括数据。

为了存储所有的数据，让我们在Tensorflow/workspace中创建一个名为data的单独文件夹。我们最终得到的所有转换后的数据集都将被放置在Tensorflow/workspace/data中。

在这一步结束时，您的Tensorflow目录将如下所示:

现在回到数据转换。使用流行的图像注释工具创建的大多数注释文件都有两种格式:JSON 或 XML。

Tensorflow/
└─ cocoapi/
└─ protoc/
└─ tf2_api_env/
└─ models/
└─ workspace/
   └─ data/
      ├─ train.record
      ├─ validation.record
      ├─ test.record

弄清楚你的数据有什么格式的注释。你需要它来选择一个合适的工具来转换到 TFRecord 。

选项#1: 您的注释是 JSON 格式的。我的建议是:

选项#2: 你的注释采用的格式类似于 COCO、Kitti 或 Pascal 等流行数据集所采用的格式(注意:Pascal 注释采用的是我们已经知道的 XML 格式，并且之前在选项#1 中使用过)。在这种情况下，我建议你:

标签地图创建

标签地图是一种简单的。txt 文件(。确切的说是 pbtxt)。它将标签链接到一些整数值。TensorFlow 对象检测 API 需要此文件来进行训练和检测。

为了理解如何创建这个文件，让我们看一个简单的例子，其中我们只想检测两个类:汽车和自行车。别的都不重要，就这两个物件。让我们看看label_map.pbtxt对于这样一个任务会是什么样子:

现在您知道如何创建自己的标注地图了。选择您选择的文本编辑器(或 IDE)(我使用了 atom ，并创建一个标签映射文件，该文件反映了您将使用未来对象检测器检测的类的数量。给所有的类起一个有意义的名字，这样你就可以很容易的理解和区分它们。

Example of a label map file for two classes: car and bike

完成后，将新创建的label_map.pbtxt放入Tensorflow/workspace/data目录。你的Tensorflow/workspace/data目录现在应该包含 4 个文件:

train.record，

• validation.record，
• test.record，
• label_map.pbtxt。
• 数据准备到此为止！你向你的物体探测器又迈进了一大步。每一个机器学习项目最本质(可以说)的部分都完成了。您已经有了数据，并准备好输入到您的模型中。

接下来，我们将继续模型架构的选择和配置。继续前进！

型号选择和配置

在教程的这一部分，我们要做两件事:

首先，选择一个要使用的模型架构。幸运的是，有很多选择，而且都很棒。

• 第二，我们将致力于模型配置，因此它可以处理期望的任务，高效，在您可能经历的资源限制下工作，并且具有足够好的概括能力以用于现实世界。
• 这是我最喜欢的部分之一，因为这是机器学习开始的地方！我们开始吧！

型号选择

TensorFlow 对象检测 API 最酷的功能之一是有机会与一组先进的模型一起工作，这些模型是在 COCO 数据集上预先训练的！我们可以根据我们的目的微调这些模型，并获得很好的结果。

现在，您需要选择并下载模型:

单击您选择的型号名称开始下载。

• 在Tensorflow/workspace/目录中，创建一个名为pre_trained_models的新文件夹，并将下载的模型解压到这个新创建的目录中。

• 如果你想用不同的架构训练多个模型，然后比较它们的性能来选择一个胜出的模型(听起来是个好主意！)，您现在应该下载这些模型并将它们全部解压缩到pre_trained_models目录。

• 现在，您的项目目录应该如下所示:

Tensorflow/
└─ cocoapi/
└─ protoc/
└─ tf2_api_env/
└─ models/
└─ workspace/
   └─ data/
   └─ pre_trained_models/
      ├─ <folder with the 1st model of your choice>
      ├─ <folder with the 2nd model of your choice>
      ├─ …
      ├─ <folder with the N model of your choice>

车型配置介绍

我们下载并提取了一个预先训练好的模型。现在我们要对它进行配置。我们想这么做可能有多种原因。让我给你举几个例子，这样你就能明白为什么配置是必不可少的:

您的问题域和您的数据集与用于训练原始模型的不同:您需要一个自定义对象检测器(可能是您阅读本文的原因)，

• 您有不同数量的对象类别要检测，
• 您尝试检测的对象可能与预训练模型应该检测的对象完全不同，
• 你可能有较少的计算能力来训练一个模型，这也应该被考虑在内。
• 所以你明白为什么你需要配置你的模型了。原因不胜枚举，但让我们继续前进。我们稍后会用一个真实的例子详细讨论它。

现在，我希望大家记住，模型配置是一个让我们定制模型相关工件(例如超参数、损失函数等)的过程，以便可以对其进行训练(微调)来处理我们感兴趣的对象的检测。就是这样。

TensorFlow 对象检测 API 允许通过预训练模型附带的pipeline.config文件进行模型配置。

项目目录组织

在进入模型配置之前，让我们首先组织我们的项目目录。这是帮助我们保持整个项目结构整洁和易于理解的重要一步。

我们现在想要创建另一个目录，用于存储与不同模型架构及其配置相关的文件。

你可能会问:

“等等，安东，我们已经有了模型架构的pre_trained_models文件夹！我们究竟为什么不用它？”

这是一个公平的观点，但我的个人经验引导我找到了一个不同的、更干净的解决方案。相信我，最后你会喜欢的！你需要做的是:

转到Tensorflow/workspace并创建一个名为models的新目录。

• 在Tensorflow/workspace/models中，创建另一个目录，其名称对应于您决定使用的模型架构(您下载到Tensorflow/workspace/pre_trained_models的那些模型)。

• 例如，我想训练一个基于 EfficientDet 架构的对象检测器。我注意到在 TF 2 检测模型 Zoo 页面有多个 EfficientDets 可用，它们有不同的深度(从 D0 到 D7，更多信息可以在这里找到)。

我想我会首先使用最基本的一个，即 EfficientDet D0 512×512 ，但后来也尝试了 EfficientDet D1 640×640 ，它更深入，可能会获得更好的性能。因此，在我的例子中，我需要创建两个文件夹:efficientdet_d0和efficiendet_d1。

目录名的选择由你决定。重要的是为您想要使用的每个模型架构创建一个目录，并且在文件夹的名称中包含模型架构信息。就是这样。

到目前为止，您的项目目录结构应该类似于以下内容:

转到Tensorflow/workspace/pre_trained_models并打开包含您想要配置的模型的目录

Tensorflow/
└─ ...
└─ workspace/
   └─ data/
   └─ pre_trained_models/
   └─ models/
      ├─ <folder with the 1st model of your choice>
      ├─ <folder with the 2nd model of your choice>
      ├─ …
      ├─ <folder with the N model of your choice>	

• 在那里寻找pipeline.config文件。将该文件复制到Tensorflow/workspace/models/<folder with the model of your choice>/v1/内的相应文件夹中(您需要创建v1文件夹。我稍后会解释它的用途)。

• 复制后，使用文本编辑器或您选择的 IDE 从Tensorflow/workspace/models/<folder with the model of your choice>/v1/打开pipeline.config文件。打开后，您应该会看到类似这样的内容:

• 现在您已经准备好开始进行模型配置了！下一节将解释如何正确地做到这一点。

Example of an opened pipeline.config file for EfficientDet D1

除了适当的文件夹和命名结构之外，对组织使用实验跟踪工具也有助于保持整洁。

配置过程:基础

我决定将模型配置过程分为两个部分。

首先，我们来看看基础知识。我们将触及一组需要配置的最小参数，以便开始训练并获得结果……一个基线结果。

使用这种方法，开始工作非常容易，但是会牺牲最终模型的性能。这将是完全可行的，但不会尽如人意。

第二步，我们将重点调整各种可用的模型参数。我将为您提供一个框架，您可以使用它来调整您想要的每个模型参数。

你将有很大的权力来控制模型配置，并且能够使用不同的设置来进行测试，并获得最佳的模型性能。

听起来很刺激？是啊，它是！让我们开始吧。

查看您之前从Tensorflow/workspace/models/<folder with the model of your choice>/v1/打开的pipeline.config文件。无论您决定使用哪种型号，您的基本配置都应符合以下型号参数:

num_classes (int)。您必须提供您的模型将要检测的类的准确数量。默认情况下，它等于 90，因为预训练模型应该用于 COCO 数据集中的 90 个对象。

• 数量 _ 类别参数。效率检测 D1 的例子

batch_size (int，必须能被 2 整除)。这个值应该根据您有多少可用内存来设置。请记住，批量越大，您的机器/GPU 需要的内存就越多。如果你不知道最初该用哪个数字，我建议从batch_size = 8 开始

• 注意: batch_size参数需要在pipeline.config文件内的两个地方设置:在train_config和eval_config(见下图)

train _ config 中的 batch_size 参数效率检测 D1 的例子

eval _ config 中的 batch_size 参数。效率检测 D1 的例子

对于eval_config你必须用 1。对于train_confid,使用我上面描述的逻辑。

微调检查点。这里是您提供预训练模型检查点的路径的地方。

• 善意提醒，你需要的关卡位于Tensorflow/workspace/pre_trained_models/<folder with the model of your choice>/checkpoint/ckpt-0。

只需将<folder with the model of your choice>替换为预训练模型所在文件夹的名称。

fine_tune_checkpoint_type (str)。该字段应设置为detection，因为我们想要训练一个检测模型。

• use_bfloat16(布尔)。如果您不打算在 TPU 上训练模型，该字段应设置为false。否则设置为true。
• label_map_path (str)。在这里，您可以提供一个到先前创建的label_map.pbtxt的路径。
• 另一个善意的提醒:我们把label_map.pbtxt放到了Tensorflow/workspace/data目录下。

注意: label_map_path参数需要在pipeline.config文件中的两个地方设置:在train_input_reader和eval_input阅读器中(见下图)

train _ input _ reader 内的 label_map_path 参数。效率检测 D1 的例子

eval _ input _ reader 内的 label_map_path 参数。效率检测 D1 的例子

input_path (str)。在这里，您提供了一个到您之前创建的train.record和validation.record的路径。您可能已经猜到，到validation.record的路径应该设置在eval_input_reader内，而到train.record的路径应该设置在train_input_reader内。

• 我最后善意的提醒:我们还将所有的.record files放在了Tensorflow/workspace/data目录中。

我们刚刚完成基本配置，这是开始训练您的自定义对象检测器所必需的。很难吗？绝对不会。只要多行修改，你就可以开始了。

您可能已经注意到，与我们在基本配置过程中使用的几行相比，pipeline.config文件要长得多。配置空间大吗？绝对是！让我们看看还能做些什么来使我们的模型更健壮。

配置过程:高级

如何调整配置文件中的其他参数？

我应该尝试哪些参数值？

在哪里以及如何阅读关于参数及其含义的更多信息？

这些是我在开始使用 TensorFlow 对象检测 API 时遇到的问题。

如果你也觉得不清楚，不要担心！幸运的是，有一种通用的方法可以用于参数调整，我发现它非常方便易用。

让我用一个真实的例子向你展示它是怎么回事！

假设您在pipeline.config文件中看到一个默认的分类损失函数(对于 D1 效率检测器来说是weighted_sigmoid_focal)。定义为classification_loss参数)是你认为不是最优的，你想寻找其他可用的选项。

pipeline . config 中定义损失函数的行。效率检测 D1 的例子

以下是你寻找其他可用选项的方法:

根据以下请求模式进行搜索:

Place of the search window on the official TensorFlow API GitHub page

• 至于我们的例子，我们的 parameter_name 就是 classification_loss 。你需要从pipeline.config文件中粘贴一个精确的参数名。在我们的示例中，您的搜索请求如下:

parameter_name path:research/object_detection/protos

浏览搜索结果，寻找最能描述我们请求的参数( classification_loss )的一个。

Example for a search request if we would like to change classification loss

• 单击最能描述您所请求参数的文件的链接(如上图所示，我们的目标文件可能是research/object _ detection/protos/loss . proto)，然后等待加载包含该文件的页面。

Example of search results for a given query

• 加载时，只需使用[常规浏览器搜索](https://web.archive.org/web/20221206004728/https://www.howtogeek.com/671304/how-to-quickly-search-for-text-on-the-current-web-page/#:~:text=Press%20Ctrl%2BF%20(on%20Windows,right%20corner%20of%20the%20window.)找到我们想要的参数( classification_loss )所在的一行代码。当我这样做时，我发现了下面这段代码:

• 从上面的代码片段中可以得出以下结论:

Piece of code that shows the options for a parameter we interested in

> classification_loss 是一个参数，它可以是在
> 上面的图像上列出的(oneof)6 个预定义选项中的一个。

当您找到您的参数值时，只需将它复制到您的pipeline.config文件中的相应行。例如，我决定使用weighted_sigmoid损失进行分类，而不是默认的weighted_sigmoid_focal。为此，我在我的pipeline.config文件中做了一个更改，现在定义分类损失的行如下所示:

• 这就是了。您可以使用这种方法来调整您选择的每个参数。现在，您拥有了一种超能力来定制您的模型，使它完全按照您想要的方式运行。是不是很牛逼？绝对是。恭喜你！

Here is how lines for classification_loss look like after a change is made.

模特培训

为了走到这一步，我们做了很多工作。现在我们已经准备好开始训练了。下面是如何做到这一点:

您需要将提供的 python 脚本从Tensorflow/models/research/object_detection/model_main_tf2.py复制到Tensorflow/workspace/model_main_tf2.py进行训练

• 打开一个新的终端窗口，将Tensorflow/workspace/作为你当前的工作目录。

• 使用以下命令启动培训作业:

• 其中:

python model_main_tf2.py
  --pipeline_config_path=<path to your config file>
  --model_dir=<path to a directory with your model>
  --checkpoint_every_n=<int for the number of steps per checkpoint>
  --num_workers=<int for the number of workers to use>
  --alsologtostderr

> <path to your config file> 是当前培训作业要使用的配置文件的路径。应该是来自的配置文件。/models/ <文件夹与您选择的模型>/v1/
**><path to a directory with your model>**是一个目录的路径，您的所有未来模型属性将放置在该目录中。也应该是下面的:。/models/ <包含您选择的模型的文件夹>/v1/
**><int for the number of steps per checkpoint>**是一个整数，它定义了创建模型检查点需要按顺序完成多少个步骤。请记住，当进行单个步骤时，您的模型处理的图像数量等于您为训练定义的 batch_size。
**>****<int for the number of workers to use>**如果您有一个多核 CPU，该参数定义了可用于训练作业的核心数量。

在您执行上述命令之后，您的培训工作将开始。值得一提的是，如果你要使用 GPU 进行训练，你所有的 GPU 都会参与进来。如果您希望仅涉及选定的 GPU，请在启动培训作业脚本之前执行以下命令**😗*

其中根据订单编号定义要使用的 GPU。比如我有两个 GPU。第一个订单编号为 0，第二个订单编号为 1。如果我想在我的第 0 个 GPU 上训练一个模型，我执行以下命令:

export CUDA_VISIBLE_DEVICES= <GPUs>

如果我想在我的两个 GPU 上训练，我使用以下命令:

export CUDA_VISIBLE_DEVICES=0

如果我决定只使用 CPU 来训练我的模型，我的命令应该是这样的:

export CUDA_VISIBLE_DEVICES=0,1

现在，你该躺下来放松一下了。剩下的工作就交给电脑了！

export CUDA_VISIBLE_DEVICES=-1

最后的想法

这是一次漫长的旅行，不是吗？现在你有知识和实践技能来进口，定制和培训任何物体探测器你想要的。

TensorFlow 对象检测 API 是一个很好的工具，我很高兴您现在已经完全可以使用它了。让我们简要回顾一下我们所做的工作:

我们从需要启动的初始安装和设置开始:我们安装了所有的依赖项，组织了项目目录，启用了 GPU 支持。

1. 然后我们继续进行数据准备，了解 TFRecords 并将我们的数据转换成这种格式。我们还利用标签映射将类与其名称联系起来。
2. 然后我们进入模型选择并决定我们想要使用什么模型架构。现在我们知道每个模型都可以通过我们熟悉的配置文件进行定制。
3. 最后，我们直接进入培训工作，根据我们准备的配置，启动了模型培训。
4. 如果你一直做到最后，那就干得好！我希望你觉得这篇文章有趣并且有用。

在即将到来的第二篇中，我会讲到更酷的东西！特别是，我们将回答以下问题:

如何为您的模型启动评估作业，并检查其随时间推移的性能？

• 跟踪结果和比较不同模型配置的实验的最便捷方式是什么？
• 如何进一步提高模型质量及其性能？
• 如何克服可能出现的问题？
• 如何导出一个训练好的模型以便用于推理？
• How to export a trained model in order to use it for inference?**