NeptuneAI-博客中文翻译-七-

NeptuneAI 博客中文翻译（七）

原文：NeptuneAI Blog

协议：CC BY-NC-SA 4.0

scikit Optimize:Python 中的贝叶斯超参数优化

原文：https://web.archive.org/web/https://neptune.ai/blog/scikit-optimize

需要调整机器学习模型的超参数，但不想手动完成？

正在考虑执行贝叶斯超参数优化，但您不确定具体如何操作？

听说过各种超参数优化库，想知道 Scikit Optimize 是否是适合您的工具？

你来对地方了。

在本文中，我将:

向您展示一个使用 skopt 在实际问题上运行贝叶斯超参数优化的示例，
根据 API、速度和实验结果等各种标准评估该库，
给你我的总评分和何时使用的建议。

我们开始吧，好吗？

评定标准

易用性和 API

API 太棒了。它是如此简单，以至于你几乎不用看文档就能猜到。说真的，让我给你看看。

您定义搜索空间:

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(2, 100, name='num_leaves'),
   skopt.space.Integer(10, 1000, name='min_data_in_leaf'),
   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):
    all_params = {**params, **STATIC_PARAMS}
    return -1.0 * train_evaluate(X, y, all_params)

并运行优化:

results = skopt.forest_minimize(objective, SPACE, **HPO_PARAMS)

就是这样。您需要的所有信息，比如每次迭代的最佳参数或分数，都保存在 results 对象中。这里是一个完整脚本的例子，带有一些额外的附加功能。

超级简单的设置和直观的 API。

10 / 10

选项、方法和(超级)参数

搜索空间

对于超参数搜索空间，您可以从三个选项中进行选择:

空间。实数-浮点参数由(a，b)范围内的均匀对数均匀采样，
空间。整数-整数参数从(a，b)范围内均匀采样，
空间。分类-用于分类(文本)参数。将从选项列表中抽取一个值。例如，如果你正在训练 lightGBM，你可以通过['gbdt '，' dart '，' goss']。

没有对嵌套搜索空间的支持，嵌套搜索空间考虑了超参数的一些组合完全无效的情况。有时候真的很方便。

优化方法

有四种优化算法可以尝试。

dummy_minimize

您可以对参数进行简单的随机搜索。这里没有什么特别的，但是如果需要的话，在同一个 API 中使用这个选项进行比较是很有用的。

forest_minimize 和 gbrt_minimize

这两种方法以及下一节中的方法都是贝叶斯超参数优化的例子，也称为基于序列模型的优化 SMBO。这种方法背后的思想是用随机森林、额外的树或者梯度增强树回归量来估计用户定义的目标函数 。

在目标函数上每次运行超参数后，算法进行有根据的猜测，哪组超参数最有可能提高分数，并且应该在下一次运行中尝试。它是通过获得许多点(超参数集)上的回归预测，并根据所谓的获取函数选择最佳猜测点来完成的。

有许多采集功能选项可供选择:

EI 和 PI :负预期改善和负概率改善。如果你选择其中一个，你也应该调整【Xi】参数。基本上，当您的算法寻找下一组超参数时，您可以决定您愿意在实际目标函数上尝试的预期改进有多小。该值越高，回归变量预期的改善(或改善概率)就越大。
【LCB】:置信下限。在这种情况下，你要谨慎选择你的下一个点，限制下行风险。你可以决定每次跑步要冒多大的风险。通过使κ参数变小，你倾向于利用你所知道的，通过使其变大，你倾向于探索搜索空间。

还有选项【EIPS】和 PIPS 考虑到目标函数产生的分数和执行时间，但我没有尝试过

gp_minimize

不使用树形回归，目标函数由高斯过程近似。

从用户的角度来看，这种方法的附加价值是，你可以让算法在每次迭代中选择 EI、PI 和 LCB 中最好的一个，而不是事先决定一个采集函数。只需将采集功能设置为 gp_hedge 并试用即可。

还有一点要考虑的是每次迭代使用的优化方法、采样或 lbfgs 。对于这两者，采集函数是在搜索空间中随机选择的点数( n_points )上计算的。如果进行采样，则选择具有最低值的点。如果您选择 lbfgs ，该算法将从一些(n _ restarts _ optimizer)最佳的、随机尝试的点中选取，并将从每个点开始运行 lbfgs 优化。所以如果你不在乎执行时间，基本上 lbfgs 方法只是对采样方法的一个改进。

回收

我真的很喜欢有一个通过回调的简单选项。例如，我可以通过简单地添加 3 行代码来监控我的训练:

def monitor(res):
    neptune.send_metric('run_score', res.func_vals[-1])
    neptune.send_text('run_parameters', 
                      str(to_named_params(res.x_iters[-1])))
...
results = skopt.forest_minimize(objective, SPACE, 
                                callback=[monitor], **HPO_PARAMS)

您可以使用此选项的其他事情是，在每次迭代中提前停止或保存结果。

请注意，由于最近的 API 更新，这篇文章也需要一些改变——我们正在努力！与此同时，请检查海王星文档，那里的一切都是最新的！🥳

持续和重新启动

有目的转储和目的加载函数处理结果对象的保存和加载；

results = skopt.forest_minimize(objective, SPACE, **HPO_PARAMS)
skopt.dump(results, 'artifacts/results.pkl')
old_results = skopt.load('artifacts/results.pkl')

您可以通过 x0 和 y0 参数从保存的结果重新开始训练。例如:

results = skopt.forest_minimize(objective, SPACE,
                                x0=old_results.x_iters,
                                y0=old_results.func_vals,
                                **HPO_PARAMS)

简单和工程没有问题。

总的来说，有很多调整(超)超参数的选项，您可以通过回调来控制训练。另一方面，您只能在平坦的空间中搜索，并且您需要自己处理那些被禁止的参数组合。

2010 年 7 月

证明文件

一件艺术品。

它有很多例子，所有函数和方法的文档字符串。我只花了几分钟就进入了最佳状态，并把事情做好了。

去文档网页自己看。

它可以更好一点，在 docstrings 中有更多的解释，但总体体验非常好。

9 / 10

形象化

这是这个图书馆我最喜欢的特色之一。在 skopt.plots 模块中有三个绘图工具，我非常喜欢:

plot _ convergence-它通过显示每次迭代的最佳结果来可视化您的优化进度。

import skopt.plots

skopt.plots.plot_convergence(results)

它的酷之处在于，你可以通过简单地传递一个 results 对象列表或者一个(name，results)元组的列表来比较许多策略的进展。

results = [('random_results', random_results),
           ('forest_results', forest_results),
           ('gbrt_results', gbrt_results),
           ('gp_results', gp_results)]

skopt.plots.plot_convergence(*results)

这个图让你看到搜索的发展。对于每个超参数，我们可以看到探测值的直方图。对于每一对超参数，采样值的散点图用颜色表示，从蓝色到黄色。

例如，当我们查看随机搜索策略时，我们可以看到没有进化。它只是随机搜索:

但是对于forest _ minimize策略，我们可以清楚地看到，它收敛到它探索得更多的空间的某些部分。

plot _ objective-它让你获得对超参数的分数敏感度的直觉。您可以决定空间的哪些部分可能需要更细粒度的搜索，以及哪些超参数几乎不影响分数，并且可能会从搜索中删除。

总的来说，可视化非常好。

10 / 10

注意:

我非常喜欢它，所以我创建了一组函数来帮助不同 HPO 库之间的转换，这样你就可以对每个库使用这些可视化。我已经把它们放在了 neptune-contrib 包中，你可以查看一下。

速度和并行化

每个优化函数都带有 n_jobs 参数，该参数被传递给 base_estimator 。这意味着，即使优化运行按顺序进行，您也可以通过利用更多的资源来加速每次运行。

我还没有为所有的优化方法和 n_jobs 运行一个合适的计时基准。然而，因为我记录了所有实验的总执行时间，所以我决定给出我运行的所有实验的平均时间:

显然，随机搜索方法是最快的，因为它在两次运行之间不需要任何计算。其次是梯度增强树回归器和随机森林方法。通过优化高斯过程是最慢的，但我只测试了 gp_hedge 采集函数，这可能就是原因。

因为没有在运行级别上，在一个工人集群上分配它的选项，所以我必须拿走几个点。

2010 年 6 月

实验结果

作为一个例子，让我们在一个表格，二元分类问题上调整 lightGBM 模型的超参数。如果您想像我一样使用相同的数据集，您应该:

为了让训练更快，我将的助推轮数固定为 300，并提前 30 轮停止。

import lightgbm as lgb
from sklearn.model_selection import train_test_split

NUM_BOOST_ROUND = 300
EARLY_STOPPING_ROUNDS = 30

def train_evaluate(X, y, params):
    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)

    model = lgb.train(params, train_data,
                      num_boost_round=NUM_BOOST_ROUND,
                      early_stopping_rounds=EARLY_STOPPING_ROUNDS,
                      valid_sets=[valid_data], 
                      valid_names=['valid'])

    score = model.best_score['valid']['auc']
    return score

所有的训练和评估逻辑都放在 train_evaluate 函数中。我们可以将其视为一个黑盒，它获取数据和超参数集并生成 AUC 评估分数。

注意:

你可以把每一个以参数为输入，输出分数的脚本都变成这样的 train_evaluate。完成后，您可以将其视为一个黑盒，并调整您的参数。

要根据一组参数训练模型，您可以运行如下内容:

import pandas as pd

N_ROWS=10000
TRAIN_PATH = '/mnt/ml-team/minerva/open-solutions/santander/data/train.csv'

data = pd.read_csv(TRAIN_PATH, nrows=N_ROWS)
X = data.drop(['ID_code', 'target'], axis=1)
y = data['target']

MODEL_PARAMS = {'boosting': 'gbdt',
                'objective':'binary',
                'metric': 'auc',
                'num_threads': 12,
                'learning_rate': 0.3,
                }

score = train_evaluate(X, y, MODEL_PARAMS)
print('Validation AUC: {}'.format(score))

对于这项研究，我将尝试在 100 次运行预算内找到最佳参数。

如果你在超参数上随机搜索，你可以得到 0.864 ，正如我在这个 ml 实验中所示。

为了找到最佳模型，我尝试了来自选项、方法和 hyper(超参数)部分的优化器和 hyper(超参数)的各种配置。您也可以在这里查看示例 skopt 参数调整脚本。

我总共进行了 87 次实验，让我们来看看前几项:

Experiments for different skopt configurations

如果你想更详细地探索所有这些实验，你可以简单地进入实验仪表板。

forest_minimize 方法是明显的赢家，但是为了获得好的结果，稍微调整一下(超级)超参数是至关重要的。对于 LCB 采集函数来说，κ(剥削)的值越低越好。让我们来看看这个实验的评估图:

它利用了低 num_leaves 子空间，但对于 max_depth 和 feature_fraction 来说，它非常具有探索性。值得一提的是，这些图在不同的实验中差别很大。这让你想知道陷入局部最小值有多容易。

然而，最佳结果是通过 EI 采集功能获得的。再次，调整 xi 参数是必要的。看这个实验的客观情节:

我觉得，通过删除一些不敏感的维度(子样本、最大深度)并对其他超参数进行更细粒度的搜索，我可能会得到更好的结果。

令我惊讶的是，当我使用 lbfgs 采集函数优化时，gp _ minimize的结果明显更差。他们不能打败随机搜索。将优化改为采样获得了更好的 AUC，但仍然比 forest_minimize 和 gbrt_minimize 差。去高斯工艺实验自己看。

总的来说，我能得到的最高分是 0.8566 ，比随机搜索的 0.8464 高出 0.01。我将把它翻译成 10 点 (0.01*100)。

10/10

结论

让我们来看看所有标准的结果:

总的来说，我非常喜欢 Scikit-Optimize 。这是一个愉快的使用，给你很大的结果，和有用的可视化。此外，它有许多选项，可以用强大的文档来指导您完成它。

另一方面，很难(如果不是不可能的话)将它并行化运行并分布在一个机器集群上。我认为今后，这将变得更加重要，并可能使这个库不适合某些应用程序。

**我的建议是，如果你不太关心速度和并行化，就使用它，但是如果这些对你的项目至关重要，就去别处看看。

雅各布·查肯

大部分是 ML 的人。构建 MLOps 工具，编写技术资料，在 Neptune 进行想法实验。

阅读下一篇

如何跟踪机器学习模型的超参数？

卡米尔·卡什马雷克|发布于 2020 年 7 月 1 日

机器学习算法可通过称为超参数的多个量规进行调整。最近的深度学习模型可以通过数十个超参数进行调整，这些超参数与数据扩充参数和训练程序参数一起创建了非常复杂的空间。在强化学习领域，您还应该计算环境参数。

数据科学家要控制好 超参数 空间，才能使进步。

在这里，我们将向您展示最近的 实践，提示&技巧，和工具以最小的开销高效地跟踪超参数。你会发现自己掌控了最复杂的深度学习实验！

为什么我应该跟踪我的超参数？也就是为什么这很重要？

几乎每一个深度学习实验指南，像这本深度学习书籍，都建议你如何调整超参数，使模型按预期工作。在实验-分析-学习循环中，数据科学家必须控制正在进行的更改，以便循环的“学习”部分正常工作。

哦，忘了说随机种子也是一个超参数(特别是在 RL 领域:例如检查这个 Reddit )。

超参数跟踪的当前实践是什么？

让我们逐一回顾一下管理超参数的常见做法。我们关注于如何构建、保存和传递超参数给你的 ML 脚本。

Continue reading ->

使用 Deoldify 和 Django API 在 IOS 应用程序中分割和着色图像

原文：https://web.archive.org/web/https://neptune.ai/blog/segmenting-and-colorizing-images-in-ios-app

图像分割属于涉及深度物体检测和识别的成像领域。如果我们通过按像素分离的方式将一幅图像分成多个区域，场景中的每个对象都允许我们为需要高标准图像分析和上下文解释的任务训练复杂的深度学习模型。以这种方式训练的模型可以确定检测到的物体的形状，预测检测到的物体将进入的方向，并产生许多其他见解。

我们将通过动手开发一个处理模型服务的后端 API 和一个使用服务的小型 IOS 应用程序来学习图像分割的工作原理。

API 将由在不同阶段处理输入图像的多个视图组成。后端服务的处理逻辑就像每个视图都是负责单个功能的嵌套微服务一样运行，从背景定制到背景灰度和旧图像着色。

图像分割可以用各种技术完成，每种技术都有其优点和缺点:

分割技术	描述	优势	不足之处

根据图像直方图峰值寻找特定阈值

最简单的方法。不需要以前的信息

空间细节考虑不周全，很大程度上取决于颜色变化和峰值

|
| |

应用间断检测技术

对物体间对比度好的图像表现很好

图像中有太多边缘时不适合

|
| |

同质图像分割以找到特定区域

当相似性标准可以很容易地定义时有用

在时间和空间复杂度方面相当昂贵

|
| |

基于模拟的学习过程进行决策

神经网络架构，无需编写复杂程序

要求大量的训练数据

有三种主要类型的图像分割:

语义分割:识别可训练对象类，相应地分离。
实例分割:检测每个对象类的实例数量。因此，它可以更准确地分离组件，并有助于将整个图像分解为多个标记区域，这些区域引用模型被训练的类别。
全景分割:语义和实例分割的统一版本。

我们还将看看最近的图像技术，这些技术可以准确地给旧的黑白照片上色。用于执行这种艺术任务的算法是特定的 生成对抗 网络【GANs】的组合，这些网络生成与图像中存在的对象相匹配的精确颜色颜料。模型分割图像，并根据它们被训练的类别对每个像素进行着色。

我们将使用的库是去文件夹。他们有一个配备齐全的 Github repo，里面有很多例子和教程，可以帮助你快速入门。

Deoldify example

Deoldify example from their github repo | Source

对于本文，我们将讨论以下内容:

关于图像分割的 DeepLab V3+的一些技术背景，
使用 DeepLab-ResNet101 的 Pytorch 实现，
测试 Deoldify 处理黑白图像并提出彩色版本，
将所有模型包装在一个 API 中为它们服务，
创建一个小的 IOS 应用程序来获取图像结果，
结论。

你可以在我的 Github repo 中查看这个项目的全部代码。

DeepLab V3+的技术背景

阿特鲁空间金字塔汇集卷积

大多数分割模型使用 FCNN 作为第一处理阶段，以在对象检测阶段之前正确地放置所需的遮罩和边界。DeepLab V3+是谷歌 DeepLab 细分模型的最新和最复杂的迭代。

开发 DeepLab 的众多原因之一是它能够实现众多应用，例如在 Pixel 2 智能手机的人像模式功能中使用的合成浅景深效果。

DeepLab V3+版本包括建立在 CNN 架构主干之上的模型，但该模型主要依赖于新引入的阿特鲁空间金字塔池卷积 (ASPP)。总体结构呈现以下阶段:

使用 CNN 主干提取图像特征。在我们的例子中，主干是 ResNet-101，它将识别和检测将被馈送到进一步阶段的掩模特征图。
控制输出的大小，使语义信息不会丢失太多。
在最后阶段，ASPP 对输出图像的不同像素进行分类，并通过 1×1 卷积层进行处理，以恢复正确的原始大小。

DeepLab-ResNet101 的 PyTorch 实现

为了快速体验 DeepLab，我们将使用 PyTorch 实现，该实现提出了一个以 ResNet101 为基础的 deeplab v3 版本，该版本在 COCO 数据集上进行了预先训练，并且可以从 torchvision 包中轻松加载。

我将尽可能详细地描述编写调用模型的 Python 模块所需的不同步骤。我们将从头开始。

启用您的 Python 虚拟环境

使用 virtualenv 或 anaconda 为项目创建一个虚拟环境，在其中您将安装所有需要的依赖项。请记住，我们将要测试的预训练版本是基于 GPU 的。

1.下载安装 Anaconda: 网站

2.创建您的虚拟环境:

conda create --name seg_env python=3.6

3.激活虚拟环境:

conda activate seg_env

4.安装所需的库:

conda install pytorch torchvision cudatoolkit=10.2 -c pytorch

pip install opencv-python

pip install numpy

pip install Pillow=2.2.1

安装验证要求

克隆 Deoldify Github repo 并安装 requirements.txt

https://github.com/jantic/DeOldify.git

实现数据加载器类

在开始编码 Python 模块来包装模型行为之前，我们需要编码一个数据加载器来处理输入图像文件。数据加载器的主要目的是预处理所有图像输入文件，将它们转换为具有特定属性和特性的高级对象，这将有助于在我们想要针对一批原始输入训练或评估模型时简化工作。

class SegmentationSample(Dataset):

    def __init__(self, root_dir, image_file, device):

        self.image_file = os.path.join(root_dir, image_file)
        self.image = Image.open(self.image_file)

        if device == 'cuda' and torch.cuda.is_available():
            self.device = 'cuda'
        if device == 'cpu':
            self.device = 'cpu'

        self.preprocessing = transforms.Compose([
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
        ])
        self.unload_tensor = transforms.ToPILImage()

        self.processed_image = self.preprocessing(self.image)
        self.processed_image = self.processed_image.unsqueeze(0).to(self.device)

    def __getitem__(self, item):
        return self.processed_image

    def print_image(self, title=None):
        image = self.image
        if title is not None:
            plt.title = title
        plt.imshow(image)
        plt.pause(5)
        plt.figure()

    def print_processed(self, title='After processing'):
        image = self.processed_image.squeeze(0).detach().cpu()
        image = self.unload_tensor(image)
        plt.title = title
        plt.imshow(image)
        plt.pause(5)
        plt.figure()

init 方法:获取 root_dir 和 image 文件，并将其转换为 Pillow image 对象，然后转换为 torch 张量。原始输入图像的像素值根据特定的平均值和标准值进行归一化。一旦所有的变换发生，我们就得到一个形状良好的量纲张量。因此，我们保证输入和模型维度完全匹配。

创建 Python 包装器来服务 DeepLab 模型

该模块必须初始化 deeplab-resnet101 型号版本的预训练权重。它还要求用户指定在推理期间是使用 CPU 还是 GPU 加速。

此外，该模型还将实现自定义背景的方法。

class SemanticSeg(nn.Module):
    def __init__(self, pretrained: bool, device):
        super(SemanticSeg, self).__init__()
        if device == 'cuda' and torch.cuda.is_available():
            self.device = 'cuda'
        if device == 'cpu':
            self.device = 'cpu'

        self.model = self.load_model(pretrained)

    def forward(self, input: SegmentationSample):

        with torch.no_grad():
            output = self.model(input.processed_image)['out']

        reshaped_output = torch.argmax(output.squeeze(), dim=0).detach().cpu()
        return reshaped_output

    def load_model(self, pretrained=False):
        if pretrained:
            model = models.deeplabv3_resnet101(pretrained=True)
        else:
            model = models.deeplabv3_resnet101()

        model.to(self.device)
        model.eval()
        return model

forward(self, input: SegmentationSample):对采样图像输入进行推理，并返回张量预测。
load_model(self, pretrained=**False**):加载 Pytorch cloud 中的 deeplabv3_resnet101 预训练版本。将模型检查点的 eval 模式保存到相应的设备。

之后，我们将添加后处理方法来帮助在模型预测的顶部重新映射定制的背景。请记住，输出张量有 21 个通道与模型训练的每个目标类的预测结果相匹配。因此，我们需要解码张量形状以输出正确的图像结果。

def background_custom(self, input_image, source, background_source,number_channels=21):

        label_colors = np.array([(0, 0, 0),  

                                 (128, 0, 0), (0, 128, 0), (128, 128, 0), (0, 0, 128), (128, 0, 128),

                                 (0, 128, 128), (128, 128, 128), (64, 0, 0), (192, 0, 0), (64, 128, 0),

                                 (192, 128, 0), (64, 0, 128), (192, 0, 128), (64, 128, 128), (192, 128, 128),

                                 (0, 64, 0), (128, 64, 0), (0, 192, 0), (128, 192, 0), (0, 64, 128)])

        r = np.zeros_like(input_image).astype(np.uint8)
        g = np.zeros_like(input_image).astype(np.uint8)
        b = np.zeros_like(input_image).astype(np.uint8)

        for l in range(0, number_channels):
            if l == 15:
                idx = input_image == l
                r[idx] = label_colors[l, 0]
                g[idx] = label_colors[l, 1]
                b[idx] = label_colors[l, 2]

        rgb = np.stack([r, g, b], axis=2)

        foreground = cv2.imread(source)
        foreground = cv2.resize(foreground, (r.shape[1], r.shape[0]))
        foreground = cv2.cvtColor(foreground, cv2.COLOR_BGR2RGB)

        background = cv2.imread(background_source, cv2.IMREAD_COLOR)
        background = cv2.resize(background, (rgb.shape[1], rgb.shape[0]), interpolation=cv2.INTER_AREA)
        background = cv2.cvtColor(background, cv2.COLOR_BGR2RGB)

        th, alpha = cv2.threshold(np.array(rgb), 0, 255, cv2.THRESH_BINARY)

        foreground = foreground.astype(float)
        background = background.astype(float)

        alpha = alpha.astype(float) / 255

        foreground = cv2.multiply(alpha, foreground)

        background = cv2.multiply(1.0 - alpha, background)

        outImage = cv2.add(foreground, background)

        return outImage / 255

background_custom(self, input_image, source, background_source, channels=21):该方法采用具有高度、宽度和 21 个特征图预测[1，21，H，W]的输出张量、图像源文件的路径和背景图像文件的路径。该逻辑包括从剩余特征中仅提取人物特征图(特征 15 ),并将所有剩余特征标记为属于背景。最后，将先前标记的特征作为背景与新的图像源文件合并。

将 Deoldify 添加到模块中

from deoldify import device
from deoldify.device_id import DeviceId
import torch
import fastai
from deoldify.visualize import *

def colorize_image(self, input_image, output_image, render_factor=35):
    torch.backends.cudnn.benchmark = True

    colorizer = get_image_colorizer(artistic=False)
    colorized_image = colorizer.get_transformed_image(input_image, render_factor, watermarked=False)
    colorized_image.save(output_image)

colorize_image(self，input_image，output_image):获取输入图像并调用 colorizer . get _ transformed _ image(input _ image)，后者运行推理并返回输出彩色图像。

将模型包装在一个 API 中

正如我们通常所做的那样，我们将使用 Django 来创建一个小型的 Restful API，它定义了本地托管的端点，以通过 forward POST 和 GET 调用来测试我们的模型。

通常，API 是数据库的一个窗口。API 后端处理数据库查询和响应格式化。您收到的是一个静态响应，通常是 JSON 格式的，是您请求的任何资源的静态响应。

让我们设置姜戈部分

安装 Django 和 Django Rest 框架:

pip install django djangorestframework

一旦正确安装了依赖项，转到根文件夹并初始化 Django 应用程序:

django-admin startproject semantic-seg

现在你的 Django 项目已经准备好了。剩下唯一要做的就是实例化 Django rest 框架 ，并在初始项目文件夹中为它创建一个特定的文件夹。

启动您的 api 应用程序:python manage.py startapp api
将新创建的 api 文件夹的路径添加到 general settings.py 文件中:

INSTALLED_APPS = [
'api.apps.ApiConfig',
'django.contrib.admin',
'django.contrib.auth',
...
]

API 文件夹的树结构应该如下所示:

Semantic-segmentation-API-folder-structure

Tree print of the project folder structure

一旦所有配置就绪，我们将继续对模型和序列化程序进行编码，这些模型和序列化程序将最终处理所有涉及来回请求的图像数据的事务性流程。

由于 API 将负责检索得到的修改图像，您可以利用 Neptune 的图像记录系统来跟踪和记录整个模型迭代中产生的不同图像版本。

基本上，每个输出图像都可以保存在您的 Neptune 平台中，并告知模型的性能和准确性。每一次迭代都会给出更好的结果，因此你可以用一种结构化的、组织良好的方式来比较所有的结果。

关于如何在 Neptune 中记录内容的更多信息，无论是表格、图表还是图像，我强烈建议您看看我以前的文章:

检查您可以在 Neptune 中记录和显示哪些元数据。

姜戈模具模块

为了简化 Django，我们正在构建一个 ML 后端的简化版本，我们可以依赖 Django 提供的 ORM 类。它们的重要性在于，我们需要第三方软件来管理和存储从 API 调用中生成的所有数据。对于我们的特殊情况，我们需要发布图像，应用模型推理来获得语义过滤器，然后恢复它们。

因此，我们需要两个主要组件:

模型表示图像对象互换的类，
输入和输出图像串行化器帮助将图像存储在数据库中。

模特班

继承自 django.db.models.Model 类的 Python 类，定义了一组与图像对象相关的属性和特征。

models.FileField:存储图像文件的路径
models.UUIDField:为每个图像实例生成一个特定的 id
models.CharField:命名每个对象实例的方法
models.DateTimeField:保存它们被存储或更新的准确时间

from django.db import models
from API.utils import get_input_image_path, get_output_image_path

class ImageSegmentation(models.Model):
    uuid = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    name = models.CharField(max_length=255, null=True, blank=True)
    input_image = models.FileField(upload_to=get_input_image_path, null=True, blank=True)
    output_image = models.FileField(upload_to=get_output_image_path, null=True, blank=True)
    verified = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    def __str__(self):
        return "%s" % self.name

编写完类的代码后，将您的更改迁移到 SQL 数据库:

python manage.py makemigrations

python manage.py migrate

输入和输出图像串行器

用 image 对象的相应属性定义 Django 序列化程序。我们将制作两个序列化器来处理传入和传出的图像对象。

class InputImageSerializer(serializers.ModelSerializer):
    class Meta:
        model = ImageSegmentation
        fields = ('uuid', 'name', )

class OutputImageSerializer(serializers.ModelSerializer):
    class Meta:
        model = ImageSegmentation
        fields = ('uuid', 'name', 'input_image', 'output_image', 'created_at', 'updated_at')

最后，在完成所有更改后，您需要在管理门户中注册您的新模型。只需转到 admin.py 文件并添加以下行即可:

admin.site.register(ImageSegmentation)

构建 API 端点

对于 POST 请求，将有两个部分。一种方法处理背景定制，另一种方法用于着色部分。

贴背景定制 :发送两张文件图片，原始照片，匹配背景。它处理它们并把它们保存到相应的文件夹中。

@api_view(['POST'])
@never_cache
def run_inference(request):
    property_id = request.POST.get('property_id')

    images = dict((request.data).lists())['image']
    flag = 1
    arr = []
    for img_name in images:
        modified_data = modify_input_for_multiple_files(property_id,
                                                        img_name)
        file_serializer = ImageSerializer(data=modified_data)
        if file_serializer.is_valid():
            file_serializer.save()
            arr.append(file_serializer.data)
        else:
            flag = 0

    if flag == 1:
        image_path = os.path.relpath(arr[0]['image'], '/')
        bg_path = os.path.relpath(arr[1]['image'], '/')
        input_image = ImageSegmentation.objects.create(input_image=image_path, name='image_%02d' % uuid.uuid1())
        bg_image = ImageSegmentation.objects.create(input_image=bg_path, name='image_%02d' % uuid.uuid1())
        RunDeepLabInference(input_image, bg_image).save_bg_custom_output()
        serializer = OutputImageSerializer(input_image)
        return Response(serializer.data)

@api_view(['POST'])
@never_cache
def run_grayscale_inference(request):
    file_ = request.FILES['image']
    image = ImageSegmentation.objects.create(input_image=file_, name='image_%02d' % uuid.uuid1())
    RunDeepLabInference(image).save_grayscale_output()
    serializer = OutputImageSerializer(image)
    return Response(serializer.data)

POST for the Colorizing de oldify model:解析请求，提取 base64 图像字符串。对 base64 字符串进行解码，并在将其保存到输出图像文件夹之前执行彩色化滤镜。

@api_view(['POST'])
@never_cache
def colorize_image(request):
    file_image = request.FILES['image']
    image = ImageSegmentation.objects.create(input_image=file_image, name='image_%02d' % uuid.uuid1())
    image_string = base64.b64decode(image)
    image_data = BytesIO(image_string)
    img = Image.open(image_data)
    img.save(INPUT_IMAGE)
    colorized_image = colorizer.get_transformed_image(file_image, render_factor=35, watermarked=False)
    colorized_image.save()
    serializer = OutputImageSerializer(image)
    return Response(serializer.data)

GET 方法 将简单地检索我们存储在数据库中的转换后的图像，并将它们作为静态文件提供。

@api_view(['GET'])
@never_cache
def get_images(request):
    property_id = request.POST.get('property_id')

    images = dict((request.data).lists())['image']
    flag = 1
    arr = []
    for img_name in images:
        modified_data = modify_input_for_multiple_files(property_id,
                                                        img_name)
        file_serializer = ImageSerializer(data=modified_data)
        if file_serializer.is_valid():
            file_serializer.save()
            arr.append(file_serializer.data)
        else:
            flag = 0

    if flag == 1:
        return Response(arr, status=status.HTTP_201_CREATED)
    else:
        return Response(arr, status=status.HTTP_400_BAD_REQUEST)

配置 API 路由

1.在 urls.py 文件中设置 URL 模式的路径:

app_name = 'api'

urlpatterns = [
    path(r'test/', views.test_api, name='test_api_communication'),
    path(r'images/', views.get_images, name='get_images'),
    path(r'inference/', views.run_inference, name='run_inference_on_images'),
    path(r'grayscale/', views.run_grayscale_inference, name='run_grayscale_inference_on_images'),
    path(r'colorize/', views.colorize_image, name='run_deoldify_colorize_filter_on_images'),
    path(r'clean/', views.clean_folders, name='clean_output_folder')
]

2.在 api.urls.py 文件中创建 API 端点的地址:

urlpatterns = [
 path(r'test/', views.test_api, name='test_api_communication'),
 path(r'images/', views.get_images, name='get_images'),
 path(r'api/', views.run_inference, name='run_inference_on_images'),
]

构建 IOS 应用程序

总结一下，现在我们的 API 已经完美地运行了，我们需要做的就是构建一个小的 IOS 应用程序，它有两个 viewcontrollers 来上传图片并取回它们漂亮的转换版本，带有背景定制和颜色过滤。

我们最终将在应用程序界面中获得的结果类似于 API 中的这些示例:

我喜欢完全以编程方式在 Swift 中编写代码，我承认我对故事板和任何与 XML 相关的 UI 开发有一种厌恶。因此，让我们通过移除主故事板并设置 SceneDelegate.swift 文件来保持事情的简单和娱乐性。

删除文件中的故事板名称
相应更改 SceneDelegate 文件:

func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
    guard let windowScene = (scene as? UIWindowScene) else { return }

    window = UIWindow(frame: windowScene.coordinateSpace.bounds)
    window?.windowScene = windowScene
    window?.rootViewController = ViewController()
    window?.makeKeyAndVisible()
}

创建入口点 ViewController

第一个 ViewController 将充当我们的应用程序的入口点。它将使用两个按钮定义基本布局，这两个按钮可以让用户拍照或从库中上传照片。

手动约束布局，避免自动布局自动元素定位。

该布局包含两个垂直对齐的按钮，顶部有一个 UIImageView 徽标。

徽标图像

小 UIImageView 作为应用程序的徽标

let logo: UIImageView = {
    let image = UIImageView(image: 
    image.translatesAutoresizingMaskIntoConstraints = false
   return image
}()

小跟班

lazy var openCameraBtn : CustomButton = {
   let btn = CustomButton()
    btn.translatesAutoresizingMaskIntoConstraints = false
    btn.setTitle("Camera", for: .normal)
    let icon = UIImage(named: "camera")?.resized(newSize: CGSize(width: 45, height: 45))
    let tintedImage = icon?.withRenderingMode(.alwaysTemplate)
    btn.setImage(tintedImage, for: .normal)
    btn.tintColor = 
    btn.addTarget(self, action: 
    return btn
}()

图片上传按钮:

lazy var openToUploadBtn : CustomButton = {
   let btn = CustomButton()
    btn.addTarget(self, action: 
    btn.translatesAutoresizingMaskIntoConstraints = false
    return btn
}()

为每个 UI 元素设置常规布局和约束

fileprivate func addButtonsToSubview() {
    view.addSubview(logo)
    view.addSubview(openCameraBtn)
    view.addSubview(openToUploadBtn)
}
fileprivate func setupView() {

    logo.centerXAnchor.constraint(equalTo: self.view.centerXAnchor).isActive = true
    logo.topAnchor.constraint(equalTo: self.view.safeAreaLayoutGuide.topAnchor, constant: 20).isActive = true

    openCameraBtn.centerXAnchor.constraint(equalTo: view.centerXAnchor).isActive = true
    openCameraBtn.widthAnchor.constraint(equalToConstant: view.frame.width - 40).isActive = true
    openCameraBtn.heightAnchor.constraint(equalToConstant: 60).isActive = true
    openCameraBtn.bottomAnchor.constraint(equalTo: openToUploadBtn.topAnchor, constant: -40).isActive = true

    openToUploadBtn.centerXAnchor.constraint(equalTo: view.centerXAnchor).isActive = true
    openToUploadBtn.widthAnchor.constraint(equalToConstant: view.frame.width - 40).isActive = true
    openToUploadBtn.heightAnchor.constraint(equalToConstant: 60).isActive = true
    openToUploadBtn.bottomAnchor.constraint(equalTo: view.bottomAnchor, constant: -120).isActive = true

}

处理打开相机动作:

@objc func openCamera() {
        if UIImagePickerController.isSourceTypeAvailable(.camera) {
            let imagePicker = UIImagePickerController()
            imagePicker.delegate = self
            imagePicker.sourceType = .camera
            imagePicker.allowsEditing = true
            self.present(imagePicker, animated: true, completion: nil)
        }
    }

处理从库上传操作:

@objc func uploadLibrary() {
        if UIImagePickerController.isSourceTypeAvailable(.photoLibrary) {
            let imagePicker = UIImagePickerController()
            imagePicker.delegate = self
            imagePicker.sourceType = .photoLibrary
            imagePicker.allowsEditing = false
            self.present(imagePicker, animated: true, completion: nil)
        }
    }

从UIImagePickerControllerDelegate中覆盖imagePickerController:

func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
        if let image = info[.originalImage] as? UIImage {
            let segmentationController = ImageSegmentationViewController()
            segmentationController.modalPresentationStyle = .fullScreen
            segmentationController.inputImage.image = image
            dismiss(animated: true, completion: nil)
            self.present(segmentationController, animated: true, completion: nil)

        }
    }

处理 API 回调

为了管理分段控制器中的 HTTP API 调用，我们将使用 Alamofire，这是一个广泛使用的 Swift 包，用于处理与 Swift 的优雅 HTTP 联网。用你喜欢的方法安装软件包，我用的是 CocoaPod。

POST 方法需要一个[String: String]类型的字典，键是图像，值是原始图像的 base64 格式。

实现回调的步骤如下:

将 UIImage 转换为无压缩比的 base64 编码，
创建将用于发送要编码的 POST 请求值的参数，
用 Alamofire 请求方法执行请求，
处理 API 结果，
用筛选后的图像更新 UIImageView。

func colorizeImages() {
    let imageDataBase64 = inputImage.image!.jpegData(compressionQuality: 1)!.base64EncodedString(options: .lineLength64Characters)
    let parameters: Parameters = ["image": imageDataBase64]

    AF.request(URL.init(string: self.apiEntryPoint)!, method: .post, parameters: parameters, encoding: JSONEncoding.default, headers: .none).responseJSON { (response) in

    switch response.result {
        case .success(let value):
                if let JSON = value as? [String: Any] {
                    let base64StringOutput = JSON["output_image"] as! String
                    let newImageData = Data(base64Encoded: base64StringOutput)
                    if let newImageData = newImageData {
                       let outputImage = UIImage(data: newImageData)
                        let finalOutputImage = outputImage
                        self.inputImage.image = finalOutputImage
                        self.colorizedImage = finalOutputImage
                    }
                }
            break
        case .failure(let error):
            print(error)
            break
        }
    }
}

结果

Semantic segmentation results

Results obtained applying the background customization and gray filtering

Image colorizer results

Results obtained from colorize filters, transforming old black and white photographs into fully colorized ones.
Top left corner original photo | Source: Old pictures Casablanca, bottom right original photograph | Source: Souvenirs, Souvenirs

结论

我们已经通过图像分割进行了一次全面的旅行，一些应用程序被证明是易于实现和相当有趣的。通过我提出的这个小应用程序，我希望我已经为你的创造力增加了一点活力。

我鼓励你用同样的画布测试其他应用程序。DeepLab V3 还可以实现其他一些很酷的特性。

最后，我推荐你查阅以下参考资料:

如何为时间序列预测任务选择模型[指南]

原文：https://web.archive.org/web/https://neptune.ai/blog/select-model-for-time-series-prediction-task

使用时间序列数据？这是给你的指南。在本文中，您将学习如何根据预测性能来比较和选择时间序列模型。

在第一部分中，你将被介绍到时间序列的众多模型。这一部分分为三个部分:

经典的时间序列模型，
监督模型，
和基于深度学习的模型。

在第二部分中，您将看到一个用例的应用，在这个用例中，您将为股票市场预测构建几个时间序列模型，并且您将了解一些时间序列建模技术。这些模型将互相比较，选出性能最好的一个。

时间序列数据集和预测简介

让我们从回顾时间序列到底是什么开始。时间序列是一种特殊类型的数据集，其中一个或多个变量随着时间的推移而被测量。

我们使用的大多数数据集都是基于独立的观察。例如，数据集的每一行(数据点)代表一个单独的观察值。例如，在一个网站上，你可以跟踪每个访问者。每个访问者都有一个用户 id，他或她将独立于其他访问者。

Time Series Data Examples. A dataset with independent observations

Time series data examples: a dataset with independent observations | Source: Author

然而，在时间序列中，观测值是随着时间推移而测量的。数据集中的每个数据点对应一个时间点。这意味着数据集的不同数据点之间存在关系。这对于可以应用于时间序列数据集的机器学习算法的类型具有重要的意义。

Time Series Data Examples. A dataset with dependent observations

Time series data examples: a dataset with dependent observations | Source: Author

在本文的下一部分，您将更详细地了解时间序列数据的特性。

时间序列模型细节

由于时间序列数据的性质，时间序列建模有许多与其他数据集无关的特性。

单变量与多变量时间序列模型

时间序列的第一个特性是标识数据的时间戳具有内在意义。单变量时间序列模型是只使用一个变量(目标变量)及其时间变化来预测未来的预测模型。单变量模型特定于时间序列。

在其他情况下，您可能有关于未来的附加说明性数据。例如，假设您想将天气预报纳入您的产品需求预测，或者您有一些其他数据会影响您的预测。在这种情况下，可以使用多元时间序列模型。多元时间序列模型是适用于整合外部变量的单变量时间序列模型。你也可以使用监督机器学习来完成这项任务。

单变量时间序列模型	多元时间序列模型

仅仅基于过去和现在的关系

基于过去与现在的关系，以及变量之间的关系

如果要对时间序列数据使用时态变化，首先需要了解可能出现的不同类型的时态变化。

时间序列分解

时间序列分解是一种从数据集中提取多种类型变化的技术。时间序列的时态数据有三个重要组成部分:季节性、趋势和噪声。

季节性是出现在你的时间序列变量中的循环运动。例如，一个地方的温度在夏季会高一些，在冬季会低一些。您可以计算月平均温度，并使用这种季节性作为预测未来值的基础。
趋势可以是长期向上或向下的形态。在温度时间序列中，趋势可能是由于全球变暖而呈现的。例如，除了夏季/冬季的季节性之外，随着时间的推移，你很可能会看到平均气温略有上升。
噪声是时间序列中既不能用季节性也不能用趋势来解释的可变性部分。当构建模型时，您最终会将不同的组件组合成一个数学公式。这个公式的两个部分可以是季节性和趋势性。一个结合了两者的模型永远不会完美地代表温度值:误差永远存在。这用噪声系数来表示。

Python 中的时间序列分解示例

让我们看一个简短的例子来理解如何使用来自 statsmodels 库的 CO2 数据集在 Python 中分解时间序列。

您可以按如下方式导入数据:

import statsmodels.datasets.co2 as co2
co2_data = co2.load(as_pandas=True).data
print(co2_data)

为了便于理解，数据集如下所示。它有一个时间索引(每周日期)，并记录二氧化碳测量值。

有几个 NA 值可以使用插值法移除，如下所示:

co2_data = co2_data.fillna(co2_data.interpolate())

您可以使用以下代码查看 CO2 值的时间演变:

co2_data.plot()

这将生成以下图:

Time series decomposition in Python

Plot of the CO2 time series | Source: Author

您可以使用 statsmodels 的季节性分解函数进行现成的分解。以下代码将生成一个图，将时间序列分为趋势、季节性和噪声(此处称为残差):

from statsmodels.tsa.seasonal import seasonal_decompose
result = seasonal_decompose(co2_data)
result.plot()

Time series decomposition in Python

Plot of the decomposed CO2 time series | Source: Author

二氧化碳数据的分解显示出上升趋势和很强的季节性。

自相关

让我们转到时间序列数据中可能存在的第二种类型的时间信息:自相关。

自相关是时间序列的当前值与过去值之间的相关性。如果是这种情况，您可以使用现值来更好地预测未来值。

自相关可以是正的也可以是负的:

正自相关意味着现在的高值可能会在未来产生高值，反之亦然。你可以想想股票市场:如果每个人都在买股票，那么价格就会上涨。当价格上涨时，人们认为这是一个值得购买的好股票，他们也会购买，从而推动价格进一步上涨。然而，如果价格下跌，那么每个人都害怕崩溃，卖掉他们的股票，价格变得更低。
负自相关则相反:今天的高值意味着明天的低值，今天的低值意味着明天的高值。一个常见的例子是自然环境中的兔子种群。如果一年的夏天有很多野兔，它们会吃掉所有可用的自然资源。到了冬天，就没什么可吃的了，所以很多兔子都会死掉，存活下来的兔子数量也会很少。在兔子数量很少的这一年里，自然资源会重新增长，并允许兔子数量在下一年增长。

两个著名的图表可以帮助您检测数据集中的自相关:ACF 图和 PACF 图。

ACF:自相关函数

自相关函数是一种有助于识别时间序列中是否存在自相关的工具。

您可以使用 Python 计算 ACF 图，如下所示:

from statsmodels.graphics.tsaplots import plot_acf
plot_acf(co2_data)

ACF: the autocorrelation function

Autocorrelation plot | Source: Author

在 x 轴上，您可以看到时间步长(回到过去)。这也被称为滞后数。在 y 轴上，您可以看到每个时间步长与“当前”时间的相关性。很明显，在这张图上有明显的自相关。

PACF:自相关函数

PACF 是 ACF 的替代品。它给出的不是自相关，而是偏相关。这种自相关被称为部分自相关，因为随着过去的每一步，只列出额外的自相关。这与 ACF 不同，因为当可变性可以由多个时间点解释时，ACF 包含重复相关性。

例如，如果今天的值与昨天的值相同，但也与前天的值相同，则 ACF 将显示两个高度相关的步骤。PACF 只会在昨天出现，前天就消失了。

您可以使用 Python 计算 PACF 图，如下所示:

from statsmodels.graphics.tsaplots import plot_pacf
plot_pacf(co2_data)

PACF: the autocorrelation function

Partial autocorrelation plot | Source: Author

你可以在下面看到，这张 PACF 图更好地展示了二氧化碳数据的自相关性。滞后 1 有很强的正自相关:现在的高值意味着你很有可能在下一步观察到高值。因为这里显示的自相关是部分的，你看不到任何早期滞后的重复效果，使 PACF 图更整洁和清晰。

平稳性

时间序列的另一个重要定义是平稳性。平稳时间序列是没有趋势的时间序列。一些时间序列模型不能够处理趋势(稍后将详细介绍)。您可以使用 Dickey-Fuller 测试来检测非平稳性，并使用差分来消除非平稳性。

迪基-富勒试验

Dickey-Fuller 检验是一种统计假设检验，允许您检测非平稳性。您可以使用以下 Python 代码对 CO2 数据进行 Dickey-Fuller 测试:

from statsmodels.tsa.stattools import adfuller
adf, pval, usedlag, nobs, crit_vals, icbest =  adfuller(co2_data.co2.values)
print('ADF test statistic:', adf)
print('ADF p-values:', pval)
print('ADF number of lags used:', usedlag)
print('ADF number of observations:', nobs)
print('ADF critical values:', crit_vals)
print('ADF best information criterion:', icbest)

结果如下所示:

ADF 检验的零假设是时间序列中存在单位根。另一个假设是数据是稳定的。

第二个值是 p 值。如果这个 p 值小于 0.05，您可以拒绝零假设(拒绝非平稳性)并接受替代假设(平稳性)。在这种情况下，我们不能拒绝零假设，将不得不假设数据是非平稳的。由于你看到了数据，知道有趋势，所以这也印证了我们得出的结果。

区别

您可以从时间序列中移除趋势。目标是只有季节性变化:这可以是使用某些模型的一种方式，这些模型只适用于季节性，而不适用于趋势。

prev_co2_value = co2_data.co2.shift()
differenced_co2 = co2_data.co2 - prev_co2_value
differenced_co2.plot()

不同的 CO2 数据如下所示:

Differencing

Differenced CO2 time series | Source: Author

如果对差异数据重新进行 ADF 测试，您将确认该数据现在确实是稳定的:

adf, pval, usedlag, nobs, crit_vals, icbest =  adfuller(differenced_co2.dropna())
print('ADF test statistic:', adf)
print('ADF p-values:', pval)
print('ADF number of lags used:', usedlag)
print('ADF number of observations:', nobs)
print('ADF critical values:', crit_vals)
print('ADF best information criterion:', icbest)

p 值很小，说明替代假设(平稳性)成立。

单步与多步时间序列模型

在开始建模之前，最后一个需要理解的重要概念是单步模型和多步模型的概念。

有些模型非常适合预测时间序列的下一步，但不具备同时预测多个步骤的能力。这些模型是单步模型。您可以通过在您的预测上设置窗口来使用它们创建多步模型，但这有一个风险:当使用预测值来进行预测时，您的误差可能会很快增加并变得非常大。

多步模型具有一次预测多个步骤的内在能力。它们通常是长期预测的更好选择，有时也是一步预测的更好选择。在开始构建模型之前，决定要预测的步数是很关键的。这完全取决于您的用例。

一步预测	多步预测

旨在只预测未来 1 步

旨在预测未来的多步

|
|

可以通过加窗预测生成多步预测

| 无需开窗预测 |
|

对于多步预测来说性能较差

更适合多步预测

时间序列模型的类型

既然您已经看到了时间序列数据的主要特性，那么是时候研究可用于预测时间序列的模型类型了。这项任务通常被称为预测。

经典时间序列模型

经典时间序列模型是传统上在许多预测领域中经常使用的模型族。它们强烈地基于一个时间序列内的时间变化，并且它们与单变量时间序列一起工作得很好。还有一些高级选项可以将外部变量添加到模型中。这些模型一般只适用于时间序列，对其他类型的机器学习没有用。

监督模型

监督模型是用于许多机器学习任务的模型族。当机器学习模型使用明确定义的输入变量和一个或多个输出(目标)变量时，它就会受到监督。

监督模型可以用于时间序列，只要你有办法提取季节性并将其放入变量中。示例包括为一年、一个月或一周中的某一天等创建变量。然后，这些被用作监督模型中的 X 变量，而“y”是时间序列的实际值。您还可以将 y 的滞后版本(y 的过去值)包含到 X 数据中，以便添加自相关效应。

深度学习和最新模型

过去几年深度学习越来越受欢迎，这也为预测打开了新的大门，因为已经发明了特定的深度学习架构，可以很好地处理序列数据。

云计算和人工智能作为一种服务的普及也在该领域提供了许多新发明。脸书、亚马逊和其他大型科技公司正在开源他们的预测产品，或者在他们的云平台上提供这些产品。这些新的“黑箱”模型的出现为预测从业者提供了尝试和测试的新工具，有时甚至可以击败以前的模型。

深入经典时间序列模型

在这一部分，你将深入发现经典的时间序列模型。

ARIMA 家族

ARIMA 系列模型是一组可以组合的较小模型。ARMIA 模型的每个部分都可以作为独立的组件使用，也可以将不同的构建模块组合起来使用。当所有单独的组件放在一起时，您就获得了 SARIMAX 模型。现在，您将分别看到每个构造块。

1.自回归(AR)

自回归是 SARIMAX 系列的第一个构件。您可以将 AR 模型视为一个回归模型，它使用变量的过去(滞后)值来解释变量的未来值。

AR 模型的阶数表示为 p，它代表模型中包含的滞后值的数量。最简单的模型是 AR(1)模型:它仅使用前一时间步的值来预测当前值。您可以使用的值的最大数量是时间序列的总长度(即，您使用所有以前的时间步长)。

2.移动平均线

均线是更大的 SARIMAX 模型的第二个组成部分。它的工作方式与 AR 模型类似:它使用过去的值来预测变量的当前值。

移动平均模型使用的过去值不是变量的值。更确切地说，移动平均线使用先前时间步骤中的预测误差来预测未来。

这听起来有些反直觉，但背后有一个逻辑。当一个模型有一些未知但有规律的外部扰动时，你的模型可能有季节性或其他模式的误差。MA 模型是一种捕捉这种模式的方法，甚至不需要确定它来自哪里。

MA 模型也可以使用多个时间回溯步骤。这在称为 q 的阶数参数中表示。例如，MA(1)模型的阶数为 1，并且仅使用一个时间步长。

3.自回归移动平均(ARMA)

自回归移动平均(ARMA)模型将之前的两个构建模块合并为一个模型。因此，ARMA 可以使用过去的值和预测误差。

对于 AR 和 MA 过程的滞后，ARMA 可以有不同的值。例如，ARMA(1，0)模型的 AR 阶为 1 ( p = 1)，MA 阶为 0 (q=0)。这其实只是一个 AR(1)模型。MA(1)模型与 ARMA(0，1)模型相同。其他组合也是可能的:例如，ARMA(3，1)具有 3 个滞后值的 AR 顺序，并对 MA 使用 1 个滞后值。

4.自回归综合移动平均(ARIMA)

ARMA 模型需要平稳的时间序列。正如你之前看到的，平稳性意味着时间序列保持稳定。您可以使用扩展的 Dickey-Fuller 测试来测试您的时间序列是否稳定，如果不稳定，则应用差分。

ARIMA 模型在 ARMA 模型中加入了自动差分。它有一个额外的参数，您可以将它设置为时间序列需要进行差分的次数。例如，需要进行一次微分的 ARMA(1，1)将产生以下符号:ARIMA(1，1，1)。第一个 1 用于 AR 订单，第二个 1 用于差额，第三个 1 用于 MA 订单。ARIMA(1，0，1)将与 ARMA(1，1)相同。

5.季节性自回归综合移动平均(SARIMA)

萨里玛在 ARIMA 模型中加入了季节效应。如果季节性出现在你的时间序列中，在你的预测中使用它是非常重要的。

萨里玛符号比 ARIMA 符号要复杂得多，因为每个组件都在常规参数的基础上接收一个季节性参数。

例如，让我们考虑之前看到的 ARIMA(p，d，q)。在 SARIMA 符号中，这变成了 SARIMA(p，D，q)(P，D，Q)m。

m 就是每年观察的次数:月数据的 m=12，季度数据的 m=4，等等。小写字母(p、d、q)代表非季节性订单。大写字母(P，D，Q)代表季节性订单。

6.带有外生回归量的季节性自回归综合移动平均(SARIMAX)

最复杂的变体是 SARIMAX 模型。它重新组合 AR、MA、差异和季节效应。除此之外，它还添加了 X:外部变量。如果你有任何可以帮助你的模型改进的变量，你可以用 SARIMAX 添加它们。

Python 中关于 CO2 的自动 Arima 示例

现在，您已经看到了 ARIMA 家族的所有单个构件，是时候将它应用到一个示例中了。让我们看看是否可以使用该模型为二氧化碳数据建立一个预测模型。

ARIMA 或萨里马克斯模型的困难之处在于，你有许多参数(pp，D，Q)甚至(P，D，q)(P，D，Q)需要选择。

在某些情况下，您可以检查自相关图并确定参数的逻辑选择。您可以使用 SARIMAX 的 statsmodels 实现，并使用您选择的参数尝试性能。

另一种方法是使用 auto-arima 函数，它可以自动优化超参数。金字塔 Python 库正是这样做的:它尝试不同的组合，并选择具有最佳性能的组合。

您可以按如下方式安装金字塔:

安装后，有必要进行训练/测试分割。您将在后面看到更多关于这方面的内容，但现在我们先继续。

import pmdarima as pm
from pmdarima.model_selection import train_test_split
import numpy as np
import matplotlib.pyplot as plt

然后，根据 CO2 训练数据拟合模型，并使用最佳选择的模型进行预测。

train, test = train_test_split(co2_data.co2.values, train_size=2200)

您可以用这里创建的图向他们展示:

model = pm.auto_arima(train, seasonal=True, m=52)
preds = model.predict(test.shape[0])

在该图中，蓝线是实际值(训练数据)，橙线是预测值。

x = np.arange(y.shape[0])
plt.plot(co2_data.co2.values[:2200], train)
plt.plot(co2_data.co2.values[2200:], preds)
plt.show()

Auto Arima in Python on CO2

Actual data in blue and forecasted data in orange | Source: Author

更多关于金字塔的信息和例子，你可以查看他们的文档。

向量自回归(VAR)及其导数 VARMA 和 VARMAX

你可以看到向量自回归，或 VAR 作为 Arima 的多变量替代。不是预测一个因变量，而是同时预测多个时间序列。当不同的时间序列之间有很强的关系时，这尤其有用。向量自回归和标准 AR 模型一样，只包含一个自回归分量。

VARMA 模型是 ARMA 模型的多元等价物。VARMA 对于 ARMA 就像 VAR 对于 AR 一样:它在模型中增加了一个移动平均分量。

如果想更进一步，可以用 VARMAX 。X 代表外部(外生)变量。外生变量是可以帮助您的模型做出更好预测的变量，但它们本身不需要预测。statsmodels VARMAX 实现是开始实现 VARMAX 模型的好方法。

存在更高级的版本，如季节性 VARMAX (SVARMAX ),但它们变得如此复杂和具体，以至于很难找到简单有效的实现。一旦模型变得如此复杂，就很难理解模型内部发生了什么，通常最好开始研究其他熟悉的模型。

缓和

指数平滑是一种基本的统计技术，可以用来平滑时间序列。时间序列模式通常有很多长期可变性，但也有短期(噪声)可变性。平滑允许你使你的曲线更平滑，这样长期的可变性变得更明显，短期的(有噪声的)模式被去除。

这个时间序列的平滑版本可以用于分析。

1.简单移动平均线

简单移动平均线是最简单的平滑技术。它包括用当前值和几个过去值的平均值替换当前值。要考虑的过去值的确切数量是一个参数。使用的值越多，曲线就越平滑。同时，你会失去越来越多的变异。

2.简单指数平滑(SES)

指数平滑是这种简单移动平均线的改编。它不是取平均值，而是取过去值的加权平均值。越往后的值越不重要，越近的值越重要。

3.双指数平滑

当时间序列数据中存在趋势时，应避免使用简单的指数平滑法:在这种情况下，该方法效果不佳，因为模型无法正确区分变化和趋势。不过可以用双指数平滑。

在 DES 中，有一个指数滤波器的递归应用。这允许您消除趋势问题。对于时间零点，这使用以下公式:

以及后续时间步长的下列公式:

其中α是数据平滑因子，β是趋势平滑因子。

4.霍尔特·温特的指数平滑法

如果想更进一步，可以用三重指数平滑法，也叫霍尔特温特指数平滑法。只有当您的时间序列数据中有三个重要信号时，您才应该使用它。例如，一个信号可以是趋势，另一个信号可以是每周季节性，第三个信号可以是每月季节性。

Python 中指数平滑的一个例子

在下面的示例中，您将看到如何对 CO2 数据应用简单的指数平滑。平滑级别表示曲线应该变得多平滑。在本例中，它设置得非常低，表示曲线非常平滑。随意使用这个参数，看看不太平滑的版本是什么样子。

蓝线代表原始数据，橙线代表平滑曲线。由于这是一个简单的指数平滑法，它只能捕捉一个信号:趋势。

from statsmodels.tsa.api import SimpleExpSmoothing
es = SimpleExpSmoothing(co2_data.co2.values)
es.fit(smoothing_level=0.01)
plt.plot(co2_data.co2.values)
plt.plot(es.predict(es.params, start=0, end=None))
plt.show()

Exponential smoothing in Python

Original data in blue and smoothed graph in orange | Source: Author

深入监督机器学习模型

监督机器学习模型的工作方式与经典机器学习模型非常不同。主要区别在于，他们认为变量要么是因变量，要么是自变量。因变量或目标变量是您想要预测的变量。自变量是帮助你预测的变量。

有监督的机器学习模型不是专门为时间序列数据制作的。毕竟时间序列数据中往往没有自变量。然而，通过将季节性(例如，基于您的时间戳)转换为独立变量，使它们适应时间序列是相当简单的。

线性回归

线性回归可以说是最简单的监督机器学习模型。线性回归估计线性关系:每个独立变量都有一个系数，表明该变量如何影响目标变量。

简单线性回归是只有一个自变量的线性回归。非时间序列数据中简单线性回归模型的一个示例如下:取决于外部温度(摄氏度)的热巧克力销售额。

温度越低，热巧克力的销量越高。从视觉上看，这可能如下图所示。

在多元线性回归中，不是只使用一个自变量，而是使用多个自变量。您可以想象二维图形转换成三维图形，其中第三个轴代表可变价格。在这种情况下，您将构建一个线性模型，使用温度和价格来解释销售额。您可以根据需要添加任意数量的变量。

Linear regression

Linear regression | Source: Author

现在，当然，这不是一个时间序列数据集:没有时间变量。那么，如何将这种技术用于时间序列呢？答案相当简单。除了在这个数据集中只使用温度和价格，您还可以添加年、月、星期几等变量。

如果你在时间序列上建立一个监督模型，你有一个缺点，你需要做一点特征工程，以某种方式将季节性提取到变量中。然而，一个优点是增加外生变量变得容易多了。

现在让我们看看如何对 CO2 数据集应用线性回归。您可以按如下方式准备 CO2 数据:

这样你就有了三个独立变量:日、月和周。你也可以考虑其他季节性变量，比如星期几、星期几等等。，但是现在，我们先这样吧。

import numpy as np

months = [x.month for x in co2_data.index]
years = [x.year for x in co2_data.index]
day = [x.day for x in co2_data.index]

X = np.array([day, months, years]).T

然后，您可以使用 scikit-learn 构建一个线性回归模型，并进行预测，以查看该模型了解了什么:

使用此代码时，您将获得下面的图，该图显示了与数据相对较好的拟合:

from sklearn.linear_model import LinearRegression

my_lr = LinearRegression()
my_lr.fit(X, co2_data.co2.values)

preds = my_lr.predict(X)

plt.plot(co2_data.index, co2_data.co2.values)
plt.plot(co2_data.index, preds)

随机森林

Linear regression

Linear regression forecast | Source: Author

线性模型非常有限:它只能拟合线性关系。有时这就足够了，但是在大多数情况下，最好使用更高性能的模型。随机森林是一种常用的模型，允许拟合非线性关系。还是很好用的。

scikit-learn 库有 RandomForestRegressor，您可以简单地使用它来替换前面代码中的 LinearRegression。

现在对训练数据的拟合甚至比以前更好:

from sklearn.ensemble import RandomForestRegressor

my_rf = RandomForestRegressor()
my_rf.fit(X, co2_data.co2.values)

preds = my_rf.predict(X)

plt.plot(co2_data.index, co2_data.co2.values)
plt.plot(co2_data.index, preds)

目前来看，理解这个随机森林已经能够更好地学习训练数据就足够了。在本文的后面部分，您将会看到更多的模型评估的定量方法。

Random forest

Random forest forecast | Source: Author

XGBoost

XGBoost 模型是您绝对应该知道的第三个模型。还有许多其他模型，但随机森林和 XGBoost 被认为是监督机器学习家族中的绝对经典。

XGBoost 是一个基于梯度推进框架的机器学习模型。这个模型是弱学习者的集合模型，就像随机森林一样，但是有一个有趣的优点。在标准梯度提升中，各个树按顺序拟合，并且每个连续的决策树以最小化先前树的误差的方式拟合。XGBoost 获得了相同的结果，但是仍然能够进行并行学习。

您可以使用 XGBoost 包，如下所示:

如你所见，这个模型也非常符合数据。在本文的后面部分，您将学习如何进行模型评估。

import xgboost as xgb

my_xgb = xgb.XGBRegressor()
my_xgb.fit(X, co2_data.co2.values)

preds = my_xgb.predict(X)

plt.plot(co2_data.index, co2_data.co2.values)
plt.plot(co2_data.index, preds)

Xgboost model

XGBoost forecast | Source: Author

深入研究高级和特定的时间序列模型

在这一部分中，您将发现两个更高级、更具体的时间序列模型，称为 GARCH 和 TBATS。

广义自回归条件异方差（GeneralizedAutoregressiveConditionalHeteroskedasticity）

GARCH 代表广义自回归条件异方差。这是一种估计金融市场波动性的方法，通常用于此用例。它很少用于其他用例。

该模型很好地解决了这一问题，因为它假设时间序列的误差方差为 ARMA 模型，而不是实际数据。这样，您可以预测可变性而不是实际值。

GARCH 模型家族存在许多变体，例如，检查这个出来。这个模型非常值得了解，但是应该只在需要预测可变性时使用，因此它与本文中介绍的其他模型相对不同。

TBATS

TBATS 代表以下部件的组合:

三角季节性

博克斯-考克斯变换
ARMA 误差
趋势
季节性成分
该模型创建于 2011 年，作为预测具有多个季节周期的时间序列的解决方案。由于它相对较新，也相对较先进，所以不像 ARIMA 系列中的车型那样普及和使用。

TBATS 的一个有用的 Python 实现可以在 Pythonsk time包中找到。

深入研究基于深度学习的时间序列模型

现在，您已经看到了两个相对不同的模型族，每个模型族都有其特定的模型拟合方式。经典的时间序列模型关注的是过去和现在之间的关系。监督机器学习模型专注于因果关系。

现在，您将看到另外三个可用于预测的最新模型。理解和掌握它们更加复杂，并且可能(也可能不会)产生更好的结果，这取决于数据和用例的细节。

LSTM(长短期记忆)

LSTMs 是递归神经网络。神经网络是非常复杂的机器学习模型，通过网络传递输入数据。网络中的每个节点学习一个非常简单的操作。神经网络由许多这样的节点组成。该模型可以使用大量简单节点的事实使得整体预测非常复杂。因此，神经网络可以适应非常复杂和非线性的数据集。

RNNs 是一种特殊类型的神经网络，其中网络可以从序列数据中学习。这对于多种用例非常有用，包括理解时间序列(显然是一段时间内的值序列)，也包括文本(句子是单词序列)。

LSTMs 是一种特定类型的 rnn。事实证明，它们在多种情况下对时间序列预测非常有用。它们需要一些数据，学习起来比监督模型更复杂。一旦你掌握了它们，根据你的数据和你的具体使用情况，它们会被证明是非常强大的。

要深入 LSTMs，Python 中的 Keras 库是一个很好的起点。

先知

Prophet 是一个时间序列库，由脸书开源。这是一个黑箱模型，因为它将在没有太多用户说明的情况下生成预测。这可能是一个优势，因为您几乎可以自动生成预测模型，而不需要太多的知识或努力。

另一方面，这里也有一个风险:如果您不够关注，您很可能会产生一个对自动化模型构建工具来说看起来不错的模型，但是实际上效果并不好。

当使用这种黑盒模型时，建议进行广泛的模型验证和评估，但是如果您发现它在您的特定用例中运行良好，您可能会发现这里有很多附加价值。

你可以在脸书的 GitHub 上找到很多资源。

更深

DeepAR 是亚马逊开发的另一个这样的黑盒模型。内心深处的功能是不一样的，但是从用户体验来说，相对等于 Prophet。这个想法还是要有一个 Python 库来帮你完成所有的繁重工作。

同样，需要谨慎，因为你永远不能指望任何黑盒模型是完全可靠的。在下一部分中，您将看到更多关于模型评估和基准测试的内容，这对于如此复杂的模型来说是极其重要的。一个模型越复杂，错误就越多！

DeepAR 的一个伟大且易于使用的实现可以在 Gluon 包中获得。

时间序列模型选择

在本文的前一部分，你已经看到了大量的时间序列模型，分为经典的时间序列模型，有监督的机器学习模型，以及最近的发展包括 LSTMs，Prophet 和 DeepAR。

时间序列预测任务的最终成果将是只选择一个模型。这必须是为您的用例交付最佳结果的模型。在本文的这一部分中，您将学习如何从大量可能的模型中选择一个模型。

时间序列模型评估

时间序列度量

选择模型时，首先要定义的是您想要查看的指标。在上一部分中，您已经看到了不同质量的多重拟合(想想线性回归与随机森林)。

为了进一步选择模型，您需要定义一个度量来评估您的模型。预测中经常使用的模型是均方差。该指标测量每个时间点的误差，并取其平方。这些平方误差的平均值称为均方误差。一种常用的替代方法是均方根误差:均方误差的平方根。

另一个常用的度量是平均绝对误差:这里不是取每个误差的平方，而是取绝对值。平均绝对百分比误差是在此基础上的变化，其中每个时间点的绝对误差表示为实际值的百分比。这产生了一个百分比度量，非常容易解释。

时间序列训练测试分割

评估机器学习时要考虑的第二件事是，考虑到在训练数据上工作良好的模型不一定在新的样本外数据上工作良好。这种模型被称为过拟合模型。

有两种常见的方法可以帮助您评估模型是否正确地概括:训练-测试-分割和交叉验证。

训练测试分割意味着在拟合模型之前删除一部分数据。例如，您可以从 CO2 数据库中删除最近 3 年的数据，并使用剩余的 40 年来拟合模型。然后，您预测三年的测试数据，并在您的预测和过去三年的实际值之间测量您选择的评估指标。

要进行基准测试和选择模型，您可以基于 40 年的数据构建多个模型，并对所有模型进行测试集评估。根据这个测试性能，您可以选择性能最好的型号。

当然，如果你正在建立一个短期预测模型，使用三年的数据是没有意义的:你应该选择一个与你在现实中预测的时期相当的评估时期。

时间序列交叉验证

训练测试分割的一个风险是你只能在一个时间点进行测量。在非时间序列数据中，测试集通常由随机选择的数据点生成。然而，在时间序列中，这在许多情况下是行不通的:当使用序列时，你不能去掉序列中的一个点而仍然期望模型工作。

因此，最好通过选择最后一段时间作为测试集来应用时间序列训练测试分割。这里的风险是，如果你的最后一次月经不太可靠，这可能会出错。在最近的 covid 期间，你可以想象许多商业预测已经完全关闭:潜在的趋势已经发生了变化。

交叉验证是一种重复训练测试评估的方法。它不是进行一次列车测试分割，而是进行多次分割(精确的数字是用户定义的参数)。例如，如果您使用三重交叉验证，您将把数据集分成三个相等的部分。然后，您将在三分之二的数据集上拟合三次相同的模型，并使用另外三分之一进行评估。最后，您有三个评估分数(每个在不同的测试集上)，您可以使用平均值作为最终的度量。

通过这样做，您避免了偶然选择一个在测试集上工作的模型:您现在已经确保它在多个测试集上工作。

然而，在时间序列中，您不能应用随机选择来获得多个测试集。如果你这样做，你将会得到有很多缺失数据点的序列。

可以在时间序列交叉验证中找到解决方案。它所做的是创建多个训练测试集，但是每个测试集都是周期的结束。例如，第一次训练测试分割可以建立在前 10 年的数据上(5 次训练，5 次测试)。第二个模型将在前 15 年的数据上完成(10 次训练，5 次测试)，等等。这可以很好地工作，但是缺点是每个模型在训练数据中不使用相同的年数。

一种替代方法是进行滚动分割(总是 5 年训练，5 年测试)，但这里的缺点是你永远不能使用超过 5 年的训练数据。

时间序列模型实验

总之，在进行时间序列模型选择时，以下问题是在开始实验之前定义的关键:

您使用的是哪个指标？

您要预测哪个期间？
如何确保你的模型对模型没有看到的未来数据点起作用？
一旦您有了上述问题的答案，您就可以开始尝试不同的模型，并使用定义的评估策略来选择和改进模型。

时间序列建模的用例示例

在本部分中，您将制作标准普尔 500 第二天的天气预报。你可以想象每天晚上运行你的模型，然后第二天你就会知道股票市场是上涨还是下跌。如果你有一个非常准确的模型来做这件事，你可以很容易地赚很多钱(不要把它当作财务建议；)).

股票市场预测数据和评估方法的定义

获取股票市场数据

您可以使用 Python 中的 Yahoo Finance 包来自动下载股票数据。

你可以在图中看到自 1980 年以来 S&P500 收盘价的演变:

!pip install yfinance

import yfinance as yf

sp500_data = yf.download('^GSPC', start="1980-01-01", end="2021-11-21")
sp500_data = sp500_data[['Close']]
sp500_data.plot(figsize=(12, 12))

对于股票数据，绝对价格实际上并不那么重要。股票交易者更感兴趣的是知道价格是上涨还是下跌，以及上涨的百分比。您可以将数据更改为百分比增加或减少，如下所示:

The evolution of the S&P500 closing prices since 1980

The evolution of the S&P500 closing prices since 1980 | Source: Author

定义实验方法

difs = (sp500_data.shift() - sp500_data) / sp500_data
difs = difs.dropna()
difs.plot(figsize=(12, 12))

Percentage of the price increase/ decrease

Plot of the percentage difference of the S&P | Source: Author

模型的目标是对第二天股票价格的变化做出最好的预测。有必要决定一种方法，这样您就可以在这里稍微自动化这个过程。

因为您只想预测一天，所以可以理解测试集将会非常小(只有一天)。因此，最好创建大量的测试分割，以确保有一个可接受的模型评估量。

这可以通过前面解释的时间序列分割来获得。例如，您可以设置一个将生成 100 个训练测试集的时间序列拆分，其中每个训练测试集使用三个月的训练数据和一天的测试数据。这将有助于本例理解时间序列中的模型选择原则。

构建经典时间序列模型

让我们从这个问题的经典时间序列模型开始:Arima 模型。在这段代码中，您将设置 Arima 模型的自动创建，其顺序范围从(0，0，0)到(4，4，4)。每个模型都将使用具有 100 个分割的时间序列分割来构建和评估，其中训练规模最大为三个月，测试规模始终为一天。

因为涉及到大量的运行，结果被记录到 neptune.ai 中以便于比较。为了跟进，你可以建立一个免费账户，从这个教程中获得更多信息。

您可以以表格形式查看结果:

import numpy as np
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import TimeSeriesSplit
import neptune.new as neptune

param_list = [(x, y, z) for x in range(5) for y in range(5) for z in range(5)]

for order in param_list:

    run = neptune.init(
        project="YOU/YOUR_PROJECT",
        api_token="YOUR_API_TOKEN",
    )

    run['order'] = order

    mses = []

    tscv = TimeSeriesSplit(n_splits=100,
                           max_train_size = 3*31,
                           test_size=1)
    for train_index, test_index in tscv.split(y):

        try:
          train = y[train_index]
          test = y[test_index]

          mod = sm.tsa.ARIMA(train, order=order)
          res = mod.fit()
          pred = res.forecast(1)[0]

          mse = mean_squared_error(test, pred)
          mses.append(mse)

        except:

          pass

    try:
        average_mse = np.mean(mses)
        std_mse = np.std(mses)
        run['average_mse'] = average_mse
        run['std_mse'] = std_mse

    except:
        run['average_mse'] = None
        run['std_mse'] = None

    run.stop()

平均 MSE 最低的模型是阶数为(0，1，3)的模型。但是，你可以看到，这个模型的标准差可疑地为 0。接下来的两个模型是 ARIMA(1，0，3)和 ARIMA(1，0，2)。它们非常相似，这表明结果是可靠的。这里的最佳猜测是将 ARIMA(1，0，3)作为最佳模型，其平均 MSE 为 0.00000131908，平均标准差为 0.00000197007。

如果您使用 Prophet， Neptune-Prophet 集成可以帮助您跟踪参数、预测数据帧、残差诊断图表和其他模型构建元数据。

构建有监督的机器学习模型

现在让我们转到一个监督模型，看看性能是否不同于经典的时间序列模型。

在用于预测的监督机器学习中，需要对特征工程做出决策。正如本文前面所解释的，监督模型使用因变量(预测变量)和自变量(预测变量)。

在一些用例中，你可能有很多关于未来的数据。例如，如果您想预测一家餐馆的顾客数量，您可以使用未来日期的预定数量的外部数据作为独立变量。

对于当前的股票市场用例，您没有这些数据:您只有一段时间内的股票价格。然而，监督模型不能仅使用目标变量来构建。你需要找到一种方法从数据中提取季节性，并使用特征工程来创建独立变量。众所周知，股票市场具有很多自相关效应，因此让我们尝试一个模型，该模型使用过去 30 天的值作为预测变量来预测第 31 天。

您可以创建一个数据集，其中包含 S&P500 的 30 个训练日和 1 个测试日(总是连续的)的所有可能组合，并且您可以通过以下方式创建一个巨大的训练数据库:

既然有了训练数据库，就可以使用常规的交叉验证:毕竟，数据集的行可以独立使用。它们都是 30 个训练日和 1 个“未来”测试日的集合。由于有了这些数据准备，您可以使用常规的 KFold 交叉验证。

import yfinance as yf

sp500_data = yf.download('^GSPC', start="1980-01-01", end="2021-11-21")
sp500_data = sp500_data[['Close']]

difs = (sp500_data.shift() - sp500_data) / sp500_data
difs = difs.dropna()

y = difs.Close.values

X_data = []
y_data = []
for i in range(len(y) - 31):
    X_data.append(y[i:i+30])
    y_data.append(y[i+30])

X_windows = np.vstack(X_data)

下表显示了使用此循环获得的一些分数:

import numpy as np
import xgboost as xgb
from sklearn.model_selection import KFold
import neptune.new as neptune
from sklearn.metrics import mean_squared_error

parameters={'max_depth': list(range(2, 20, 4)),
            'gamma': list(range(0, 10, 2)),
            'min_child_weight' : list(range(0, 10, 2)),
            'eta': [0.01,0.05, 0.1, 0.15,0.2,0.3,0.5]
    }

param_list = [(x, y, z, a) for x in parameters['max_depth'] for y in parameters['gamma'] for z in parameters['min_child_weight'] for a in parameters['eta']]

for params in param_list:

    mses = []

    run = neptune.init(
          project="YOU/YOUR_PROJECT",
          api_token="YOUR_API_TOKEN",
      )

    run['params'] = params

    my_kfold = KFold(n_splits=10, shuffle=True, random_state=0)

    for train_index, test_index in my_kfold.split(X_windows):

        X_train, X_test = X_windows[train_index], X_windows[test_index]
        y_train, y_test = np.array(y_data)[train_index], np.array(y_data)[test_index]

        xgb_model = xgb.XGBRegressor(max_depth=params[0],gamma=params[1], min_child_weight=params[2], eta=params[3])
        xgb_model.fit(X_train, y_train)
        preds = xgb_model.predict(X_test)

        mses.append(mean_squared_error(y_test, preds))

    average_mse = np.mean(mses)
    std_mse = np.std(mses)
    run['average_mse'] = average_mse
    run['std_mse'] = std_mse

    run.stop()

本次网格研究中测试的参数如下表所示:

参数名称

测试值	描述

树越深，越复杂。设置该参数可以帮助您避免模型

过于复杂(过度拟合) | 树越深，就越复杂。设置此参数可以帮助您避免模型过于复杂(过度拟合) |
| |

如果树分裂创建了一个总和低于该值的节点，模型将停止分裂。这是避免过于复杂模型的另一种方法

| 如果树拆分创建的节点的总和低于该值，则模型将停止拆分。这是避免过于复杂的模型的另一种方法 |
| |

用于防止过拟合的优化步长

| 用于防止过度拟合的优化步长 |
| |

允许节点进一步分裂的最小损失减少:该值越高，在树中分裂越少

| 允许进一步分裂节点的最小损失减少:该值越高，在树中进行的分裂越少 |

有关 XGBoost 调优的更多信息，请查看官方的 XGBoost 文档。

这个 XGBoost 获得的最佳(最低)MSE 是 0.000129982。有多个超参数组合获得此分数。正如您所看到的，XGBoost 模型的性能远不如经典的时间序列模型，至少在当前的配置中是这样。为了从 XGBoost 获得更好的结果，可能需要另一种组织数据的方法。

构建基于深度学习的时间序列模型

作为模型比较的第三个模型，让我们拿一个 LSTM，看看它是否能打败 ARIMA 模型。您也可以使用交叉验证进行模型比较。然而，这可能要运行相当长的时间。在这种情况下，您将看到如何使用训练/测试分割。

您可以使用以下代码构建 LSTM:

您将看到 10 个时期的以下输出:

import yfinance as yf
sp500_data = yf.download('^GSPC', start="1980-01-01", end="2021-11-21")
sp500_data = sp500_data[['Close']]
difs = (sp500_data.shift() - sp500_data) / sp500_data
difs = difs.dropna()
y = difs.Close.values

X_data = []
y_data = []
for i in range(len(y) - 3*31):
    X_data.append(y[i:i+3*31])
    y_data.append(y[i+3*31])
X_windows = np.vstack(X_data)

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X_windows, np.array(y_data), test_size=0.2, random_state=1)
X_train, X_val, y_train, y_val  = train_test_split(X_train, y_train, test_size=0.25, random_state=1)

from sklearn.model_selection import GridSearchCV
import numpy as np
import xgboost as xgb
from sklearn.model_selection import KFold
import neptune.new as neptune
from sklearn.metrics import mean_squared_error
archi_list = [
              [tf.keras.layers.LSTM(32, return_sequences=True,  input_shape=(3*31,1)),
               tf.keras.layers.LSTM(32, return_sequences=True),
               tf.keras.layers.Dense(units=1)
               ],
              [tf.keras.layers.LSTM(64, return_sequences=True,  input_shape=(3*31,1)),
               tf.keras.layers.LSTM(64, return_sequences=True),
               tf.keras.layers.Dense(units=1)
               ],
              [tf.keras.layers.LSTM(128, return_sequences=True,  input_shape=(3*31,1)),
               tf.keras.layers.LSTM(128, return_sequences=True),
               tf.keras.layers.Dense(units=1)
               ],
              [tf.keras.layers.LSTM(32, return_sequences=True,  input_shape=(3*31,1)),
               tf.keras.layers.LSTM(32, return_sequences=True),
               tf.keras.layers.LSTM(32, return_sequences=True),
               tf.keras.layers.Dense(units=1)
               ],
              [tf.keras.layers.LSTM(64, return_sequences=True,  input_shape=(3*31,1)),
               tf.keras.layers.LSTM(64, return_sequences=True),
               tf.keras.layers.LSTM(64, return_sequences=True),
               tf.keras.layers.Dense(units=1)
               ],

]

for archi in archi_list:
    run = neptune.init(
          project="YOU/YOUR_PROJECT",
          api_token="YOUR_API_TOKEN",
      )

    run['params'] = str(len(archi) - 1) + ' times ' + str(archi[0].units)
    run['Tags'] = 'lstm'

    lstm_model = tf.keras.models.Sequential(archi)
    lstm_model.compile(loss=tf.losses.MeanSquaredError(),
                      optimizer=tf.optimizers.Adam(),
                      metrics=[tf.metrics.MeanSquaredError()]
                      )
    history = lstm_model.fit(X_train, y_train, epochs=10, validation_data=(X_val, y_val))
    run['last_mse'] = history.history['val_mean_squared_error'][-1]
    run.stop()

LSTM 的表现与 XGBoost 型号相同。同样，如果您想在这方面做更多的工作，还可以有很多东西需要进一步调整。你可以考虑使用更长或更短的训练时间。您可能还希望以不同的方式标准化数据:这通常会影响神经网络的性能。

选择最佳模型

作为本案例研究的结论，您可以说最佳性能是由 ARIMA 模型获得的。这是基于对三个月培训期和一天预测期的比较数据。

后续步骤

如果你想进一步发展这个模式，有很多地方你可以改进。例如，你可以尝试更长或更短的训练时间。您还可以尝试添加额外的数据，如季节性数据(星期几、月份等。)或其他预测变量，如市场情绪或其他。在这种情况下，您需要切换到 SARIMAX 模型。

我希望这篇文章向您展示了如何在时间序列数据的情况下进行模型选择。现在，您已经对可能感兴趣的不同模型和模型类别有了一个概念。您还看到了专门针对时间序列模型评估的工具，如窗口和时间序列分割。

对于更高级的阅读，我建议以下来源:

For more advanced reading, I suggest the following sources:

带有卷积神经网络(CNN)的自动驾驶汽车

原文：https://web.archive.org/web/https://neptune.ai/blog/self-driving-cars-with-convolutional-neural-networks-cnn

人类等待自动驾驶汽车已经几十年了。由于技术的飞速发展，这个想法最近从“可能”变成了“在特斯拉汽车上实现商业化”。

深度学习是实现自动驾驶的主要技术之一。这是一个多功能的工具，几乎可以解决任何问题——它可以用于物理学，例如，大型强子对撞机中的质子-质子碰撞，以及在谷歌镜头中对图片进行分类。深度学习是一种可以帮助解决几乎任何类型的科学或工程问题的技术。

在本文中，我们将重点关注自动驾驶汽车中的深度学习算法——卷积神经网络 (CNN)。CNN 是这些系统用来识别和分类道路的不同部分并做出适当决定的主要算法。

在这个过程中，我们将看到特斯拉、Waymo 和英伟达如何使用 CNN 算法来使他们的汽车无人驾驶或自动驾驶。

自动驾驶汽车是如何工作的？

第一辆自动驾驶汽车发明于 1989 年，它是神经网络 (ALVINN)中的自动陆地车辆。它使用神经网络来检测线路，分割环境，自我导航和驾驶。它工作得很好，但是受到处理能力慢和数据不足的限制。

如今的高性能显卡、处理器、海量数据，自驾比以往任何时候都强大。如果成为主流，将减少交通拥堵，增加道路安全。

自动驾驶汽车是自主决策系统。它们可以处理来自相机、激光雷达、雷达、GPS 或惯性传感器等不同传感器的数据流。然后，使用深度学习算法对这些数据进行建模，然后做出与汽车所处环境相关的决策。

Self driving cars - pipeline

A modular perception-planning-action pipeline | Source

上图显示了用于做出驾驶决策的模块化感知-规划-行动管道。这种方法的关键部分是从环境中获取数据的不同传感器。

为了理解自动驾驶汽车的工作原理，我们需要考察四个主要部分:

感知
本地化
预测
决策制定
1. 高级路径规划
2. 行为仲裁
3. 运动控制器

感觉

自动驾驶汽车必须具备的最重要的属性之一是感知，它帮助汽车看到周围的世界，以及识别和分类它看到的东西。为了做出好的决策，汽车需要即时识别物体。

因此，汽车需要看到并分类红绿灯、行人、路标、人行道、停车点、车道等等。不仅如此，它还需要知道自己和周围物体的确切距离。感知不仅仅是看到和分类，它使系统能够评估距离，并决定减速或刹车。

为了实现如此高水平的感知，自动驾驶汽车必须有三个传感器:

照相机
激光雷达
雷达

照相机

摄像机为汽车提供视觉，实现多种任务，如分类、分割、和定位。相机需要高分辨率，并准确地呈现环境。

为了确保汽车接收到来自各个方向的视觉信息:前、后、左、右，摄像头被缝合在一起，以获得整个环境的 360 度视图。这些相机提供远至 200 米的宽视野，以及更集中感知的短视野。

Self driving cars - camera

Self-driving car’s camera | Source

在一些像停车这样的任务中，摄像头还可以提供全景视图，以便更好地做出决策。

尽管相机完成所有与感知相关的任务，但在极端条件下，如雾、大雨，尤其是晚上，它几乎没有任何用处。在极端条件下，摄像机捕捉到的只是噪音和差异，这可能会危及生命。

为了克服这些限制，我们需要既能在没有光线的情况下工作又能测量距离的传感器。

激光雷达

激光雷达代表光探测和测距，这是一种通过发射激光束，然后测量它被某物反射所需时间来测量物体距离的方法。

摄像机只能给汽车提供它周围的图像。当它与激光雷达传感器结合时，它可以增加图像的深度——它突然对汽车周围的情况有了 3D 感知。

所以，激光雷达感知空间信息。当这些数据被输入深度神经网络时，汽车可以预测靠近它的物体或车辆的行动。这种技术在复杂的驾驶场景中非常有用，比如在多出口的十字路口，汽车可以分析所有其他汽车，并做出适当、最安全的决定。

https://web.archive.org/web/20221201175445im_/https://neptune.ai/wp-content/uploads/2022/11/Self-driving-car-LiDAR.mp4

Object detection with LiDAR | Source

2019 年，埃隆·马斯克公开表示“任何依赖激光雷达的人都注定……”。为什么？好吧，激光雷达有可能是灾难性的局限性。例如，激光雷达传感器使用激光或光线来测量附近物体的距离。它可以在晚上和黑暗的环境中工作，但当有雨或雾的噪音时，它仍然会失败。这就是为什么我们还需要一个雷达传感器。

receivable accounts data-entry and retrieval system 可接受的账目数据登录及修复系统

无线电探测和测距(雷达)是许多军事和消费应用中的关键组件。它首先被军方用来探测物体。它使用无线电波信号计算距离。今天，它被用于许多车辆，并已成为自动驾驶汽车的主要组成部分。

雷达非常有效，因为它们使用无线电波而不是激光，所以它们在任何条件下都可以工作。

重要的是要明白雷达是噪声传感器。这意味着即使摄像头没有看到障碍物，雷达也会探测到一些障碍物。

上图显示了自动驾驶汽车(绿色)使用激光雷达检测周围的物体，并计算物体的距离和形状。对比同样的场景，但是用下面的雷达传感器捕捉到的，可以看到很多不必要的噪点。

为了做出好的决策和预测，应该对雷达数据进行清理。我们需要把弱信号和强信号分开；这被称为阈值。我们还使用快速傅立叶变换 (FFT)来过滤和解释信号。

如果你看上面的下图，你会注意到雷达和激光雷达信号是基于点的数据。应该对这些数据进行分类，以便更好地解释。诸如欧几里德聚类或 K 均值聚类之类的聚类算法被用于实现这一任务。

本地化

自动驾驶汽车中的定位算法计算车辆导航时的位置和方向，这种科学称为视觉里程计(VO)。

VO 通过匹配连续视频帧中的关键点来工作。对于每一帧，关键点被用作映射算法的输入。映射算法，例如同步定位和映射(SLAM)，计算附近每个对象相对于前一帧的位置和方向，并帮助对道路、行人和周围的其他对象进行分类。

深度学习一般用于提高 VO 的性能，对不同的对象进行分类。诸如 PoseNet 和 VLocNet++的神经网络是使用点数据来估计 3D 位置和方向的一些框架。这些估计的 3D 位置和方向可用于推导场景语义，如下图所示。

预言；预测；预告

理解人类司机是一项非常复杂的任务。它涉及情感而非逻辑，这些都是由反应推动的。附近的司机或行人的下一步行动变得非常不确定，因此可以预测其他道路使用者的行动的系统对于道路安全非常重要。

这款汽车拥有 360 度的环境视角，能够感知和捕捉所有信息并进行处理。一旦输入到深度学习算法中，它就可以提出其他道路使用者可能做出的所有可能的举动。这就像一个游戏，玩家有有限的移动次数，并试图找到最好的移动来击败对手。

自动驾驶汽车中的传感器使它们能够执行图像分类、物体检测、分割和定位等任务。通过各种形式的数据表示，汽车可以预测周围的物体。

深度学习算法可以在训练过程中对这些信息(来自激光雷达和雷达的图像和云数据点)进行建模。同样的模型，但在推理过程中，可以帮助汽车为所有可能的动作做准备，包括刹车、停止、减速、变道等等。

深度学习的作用是解释复杂的视觉任务，在环境中定位自己，增强感知，并在自动驾驶汽车中启动运动学机动。这确保了道路安全和方便通勤。

但是棘手的部分是从有限的动作中选择正确的动作。

决策

决策在自动驾驶汽车中至关重要。他们需要一个在不确定环境中动态精确的系统。它需要考虑到，并非所有的传感器读数都是真实的，人类在驾驶时可能会做出不可预测的选择。这些东西是无法直接衡量的。即使我们可以测量它们，我们也不能准确地预测它们。

Self driving cars - decision making

A self-driving car moving towards an intersection | Source

上图显示了一辆自动驾驶汽车正在向一个十字路口行驶。另一辆蓝色的车也向十字路口开去。在这种情况下，自动驾驶汽车必须预测另一辆汽车是直行、左转还是右转。在每种情况下，汽车必须决定应该采取什么样的策略来避免碰撞。

为了做出决定，汽车应该有足够的信息，以便它可以选择必要的行动。我们了解到，传感器可以帮助汽车收集信息，深度学习算法可以用于定位和预测。

概括地说，定位使汽车能够知道它的初始位置，而预测则根据环境创造出 n 个可能的行动或移动。问题是:在众多预测的行动中，哪一个选择是最好的？

在做决策时，我们使用深度强化学习(DRL)。更具体地说，一种被称为马尔可夫决策过程 (MDP)的决策算法位于 DRL 的核心(我们将在后面讨论强化学习的部分了解更多关于 MDP 的知识)。

通常，MDP 用于预测道路使用者的未来行为。我们应该记住，如果对象的数量增加，尤其是移动的对象，场景会变得非常复杂。这最终增加了自动驾驶汽车本身可能的移动次数。

为了解决为自己找到最佳移动的问题，深度学习模型使用贝叶斯优化进行优化。也有这样的情况，由隐马尔可夫模型和贝叶斯优化组成的框架被用于决策。

一般来说，自动驾驶汽车中的决策是一个分层的过程。这个过程有四个组成部分:

路径或路线规划:从本质上讲，路线规划是汽车必须做出的四个决定中的第一个。进入环境，汽车应该计划从其当前位置到请求的目的地的最佳可能路线。想法是在所有其他解决方案中找到一个最佳解决方案。
行为仲裁:一旦规划好路线，汽车需要在路线中自行导航。汽车知道静态元素，如道路、十字路口、平均道路拥堵等，但它无法确切知道其他道路使用者在整个旅程中会做什么。其他道路使用者行为中的这种不确定性通过使用像 MDPs 这样的概率规划算法来解决。
运动规划:一旦行为层决定如何导航通过某条路线，运动规划系统就会协调汽车的运动。轿厢的运动对于乘客来说必须是可行和舒适的。运动规划包括车速、变道等等，所有这些都应该与汽车所处的环境相关。
车辆控制:车辆控制用于执行运动规划系统的参考路径。

用于自动驾驶汽车的 CNN

卷积神经网络(CNN)用于模拟空间信息，如图像。CNN 非常擅长从图像中提取特征，它们通常被视为通用的非线性函数逼近器。

随着网络深度的增加，CNN 可以捕捉到不同的模式。例如，网络起始处的图层将捕捉边，而深层图层将捕捉更复杂的要素，如对象的形状(树上的叶子或车辆上的轮胎)。这也是 CNN 在自动驾驶汽车中作为主要算法的原因。

CNN 的关键部分是卷积层本身。它有一个卷积内核，通常称为滤波器矩阵。滤波器矩阵与输入图像的局部区域进行卷积，该局部区域可以定义为:

其中:

运算符*表示卷积运算，
w 是滤波器矩阵，b 是偏置，
x 是输入，
y 是输出。

实际中滤波器矩阵的尺寸通常是 3×3 或 5×5。在训练过程中，过滤器矩阵会不断更新自己，以获得合理的权重。CNN 的属性之一就是权重是可共享的。相同的权重参数可以用于表示网络中的两种不同的变换。共享参数节省了大量的处理空间；它们可以产生由网络学习的更多样的特征表示。

CNN 的输出通常被馈送到非线性激活函数。激活函数使网络能够解决线性不可分问题，这些函数可以在低维流形中表示高维流形。常用的激活函数有 Sigmoid、Tanh 和 ReLU，如下所示:

值得一提的是，ReLU 是首选的激活函数，因为它比其他激活函数收敛得更快。除此之外，卷积层的输出由 max-pooling 层修改，max-pooling 层保留关于输入图像的更多信息，如背景和纹理。

CNN 的三个重要属性使它们变得多才多艺，成为自动驾驶汽车的主要组成部分，这三个属性是:

局部感受野，
共享权重，
空间采样。

这些属性减少了过度拟合，并存储了对图像分类、分割、定位等至关重要的表示和特征。

接下来，我们将讨论开创无人驾驶汽车的三家公司使用的三个 CNN 网络:

特斯拉的 HydraNet
谷歌 Waymo 的司机网
英伟达自动驾驶汽车

HydraNet——自动驾驶汽车的语义分段

HydraNet 由 Ravi 等人于 2018 年推出。它是为语义分割开发的，用于提高推理时的计算效率。

HydraNets 是动态架构，所以它可以有不同的 CNN 网络，每个分配给不同的任务。这些块或网络被称为分支。HydraNet 的想法是获取各种输入，并将其输入到特定任务的 CNN 网络中。

以自动驾驶汽车为例。一个输入数据集可以是静态环境，如树木和道路栏杆，另一个可以是道路和车道，另一个是交通灯和道路，等等。这些输入在不同的分支中被训练。在推理时间内，门选择运行哪些分支，合并器汇总分支输出并做出最终决定。

在特斯拉的例子中，他们稍微修改了这个网络，因为在推理过程中很难分离各个任务的数据。为了克服这个问题，特斯拉的工程师开发了一种共享主干网。共享主干通常是经过修改的 ResNet-50 块。

这个 HydraNet 是在所有对象的数据上训练的。有特定于任务的标题，允许模型预测特定于任务的输出。标题基于语义分段架构，如 U-Net。

特斯拉 HydraNet 还可以投影鸟瞰图，这意味着它可以从任何角度创建环境的 3D 视图，为汽车提供更多维度来正确导航。要知道特斯拉并没有使用激光雷达传感器。它只有两个传感器，一个摄像头和一个雷达。虽然激光雷达明确地为汽车创造了深度感知，但特斯拉的 hydranet 非常高效，它可以将其中 8 个摄像头的所有视觉信息缝合起来，创造深度感知。

司机网:利用模仿学习训练自动驾驶汽车

司机网是谷歌 Waymo 使用的一个基于 RNN 的神经网络，然而，CNN 实际上是这里的核心组件之一，它用于从感知系统中提取特征。

司机网络中的 CNN 被描述为卷积特征网络，或特征网络，其提取由其他网络共享的上下文特征表示。然后，这些表示被输入到递归代理网络(AgentRNN ),该网络反复产生驾驶轨迹中连续点的预测。

这个网络背后的想法是使用模仿学习来训练自动驾驶汽车。在 Bansal 等人发布的论文《司机网:通过模仿最好的，综合最差的来学习驾驶》中，他们认为，即使有 3000 万个例子，训练一辆自动驾驶汽车也是不够的。为了解决这一限制，作者在合成数据中训练了汽车。这种合成数据引入了偏差，例如对轨迹路径引入扰动、添加障碍物、引入不自然的场景等。他们发现，这样的合成数据能够比正常数据更有效地训练汽车。

通常，自驾车有一个端到端的过程，正如我们前面看到的那样，感知系统是深度学习算法的一部分，与规划和控制一起。在司机网的情况下，感知系统不是端到端过程的一部分；相反，它是一个中级系统，其中网络可以有来自感知系统的不同变化的输入。

drick net 通过观察来自传感器的场景的中级表示来产生驾驶轨迹，使用输入和合成数据来模仿专家驾驶员。

上图中，青色路径描绘的是输入路线，绿色方框是自动驾驶汽车，蓝色圆点是智能体过去的路线或位置，绿色圆点是预测的未来路线或位置。

从本质上来说，中级表示不直接使用原始传感器数据作为输入，排除了感知任务，因此我们可以将真实和模拟数据结合起来，以便于迁移学习。这样，网络可以创建环境的高层次鸟瞰图，最终产生更好的决策。

英伟达自动驾驶汽车:自动驾驶汽车的极简主义方法

英伟达也使用卷积神经网络作为其自动驾驶汽车的主要算法。但与特斯拉不同的是，它使用 3 个摄像头，一边一个，前面一个。见下图。

该网络能够在没有车道标志的道路上运行，包括停车场。它还可以学习检测有用道路特征所必需的特征和表示。

与问题的显式分解(如车道标志检测、路径规划和控制)相比，这种端到端系统同时优化了所有处理步骤。

更好的性能是内部组件自我优化以最大化整体系统性能的结果，而不是优化人工选择的中间标准，如车道检测。可以理解的是，选择这样的标准是为了便于人工解释，这并不能自动保证最大的系统性能。较小的网络是可能的，因为系统学习用最少的处理步骤来解决问题。

用于自动驾驶汽车的强化学习

强化学习 (RL)是一种机器学习的类型，其中代理通过探索和与环境交互来学习。在这种情况下，自动驾驶汽车是一个代理。

我们之前讨论了神经网络如何根据感知数据预测一些动作。但是，选择适当的行动需要深度强化学习(DRL)。在 DRL 的核心，我们有三个重要变量:

状态描述给定时间内的当前情况。在这种情况下，它将是道路上的一个位置。
动作描述了汽车可能做出的所有动作。
奖励是每当汽车采取某个动作时收到的反馈。

通常，代理不会被告知要做什么或采取什么行动。到目前为止，我们已经看到，在监督学习中，算法将输入映射到输出。在 DRL，算法通过探索环境来学习，每次互动都会产生一定的回报。回报可以是正面的，也可以是负面的。DRL 的目标是最大化累积回报。

在自动驾驶汽车中，遵循相同的程序:网络根据感知数据进行训练，学习应该做出什么决定。因为 CNN 非常擅长从输入中提取表征的特征，所以 DRL 算法可以在这些表征上进行训练。在这些表示上训练 DRL 算法可以产生好的结果，因为这些提取的表示是高维流形到更简单的低维流形的转换。对较低表示的训练产生推理所需的效率。

需要记住的一个关键点是，自动驾驶汽车不能在现实世界的场景或道路中进行训练，因为它们将极其危险。相反，无人驾驶汽车在完全没有风险的模拟器上接受训练。

一些开源模拟器有:

Self driving car simulator - deepdrive

A snapshot from Voyage Deepdrive | Source

Voyage Deepdrive

A snapshot from Voyage Deepdrive | Source

这些汽车(代理)在部署到现实世界之前，经过了数千次高难度模拟训练。

在训练过程中，智能体(汽车)通过在特定状态下采取特定动作来学习。基于这个状态-动作对，它接收一个奖励。这个过程反复发生。每次代理更新它的奖励记忆时。这就是所谓的 T4 政策。

策略被描述为代理如何做出决策。这是一个决策规则。该策略定义了代理在给定时间的行为。

代理人每做出一个否定的决定，政策就会改变。所以为了避免负面的回报，代理人会检查某个动作的质量。这是由状态值函数测量的。状态值可以用贝尔曼期望方程来度量。

贝尔曼期望方程，连同马尔可夫决策过程(MDP)，构成了 DRL 的两个核心概念。但是当谈到自动驾驶汽车时，我们必须记住来自感知数据的观察应该与适当的动作相映射，而不仅仅是将底层状态映射到动作。这就是需要部分观察的决策过程或部分可观察马尔可夫决策过程(POMDP) 的地方，它可以根据观察做出决策。

用于自动驾驶汽车的部分可观测马尔可夫决策过程

马尔可夫决策过程给了我们一种将决策顺序化的方法。当代理与环境交互时，它会随时间顺序进行。每次代理与环境交互时，它都会给出环境状态的某种表示。给定状态的表示，代理选择要采取的动作，如下图所示。

所采取的动作被转换到某个新的状态，并且代理被给予奖励。这个评估状态、采取行动、改变状态、奖励的过程不断重复。在整个过程中，代理人的目标是最大化奖励总额。

让我们对整个过程有一个更有建设性的想法:

在给定时间 t，环境的状态为 St
代理观察当前状态 St，并在
然后，环境转换到新的状态 St+1，同时代理被奖励 Rt

在部分可观察马尔可夫决策过程 (POMDP)中，代理通过从感知数据接收的观察来感知环境状态，并采取特定的行动，然后接收奖励。

POMDP 有六个分量，可以表示为 POMDP M:= (I，S，A，R，P， γ)，其中，

一:意见
状态的有限集合
答:有限的一组动作
r:奖励函数
p:转移概率函数
γ——未来奖励的折现系数。

DRL 的目标是找到期望的政策，在每个给定的时间步最大化回报，或者换句话说，找到一个最优的价值-行动函数(Q 函数)。

用于自动驾驶汽车的 Q-learning

Q-learning 是自动驾驶汽车最常用的 DRL 算法之一。它属于无模型学习的范畴。在无模型学习中，代理将试图逼近最优状态-动作对。策略仍然决定哪些动作值对或 Q 值被访问和更新(见下面的等式)。目标是通过与环境交互找到最佳策略，同时在代理出错时修改环境。

有了足够的样本或观测数据，Q-learning 会学习到最优的状态-动作值对。在实践中，Q-learning 已经被证明以概率 1 收敛到 MDP 的最佳状态-动作值，假设所有状态中的所有动作是无限可用的。

Q-learning 可以用下面的等式来描述:

其中:

α ∈ [0，1]是学习率。它控制给定 t 下 Q 值的更新程度。

重要的是要记住，代理将通过反复试验发现好的和坏的行为。

结论

自动驾驶汽车旨在通过提高安全性和效率来彻底改变汽车旅行。在本文中，我们概述了一些关键组件，如激光雷达、雷达、相机，以及最重要的是——使无人驾驶汽车成为可能的算法。

虽然很有希望，但仍有很大的改进空间。例如，目前的自动驾驶汽车处于第五级发展中的第二级，这意味着在必要时仍然需要有人随时干预。

需要注意的事情很少:

所使用的算法还没有优化到足以感知道路和车道，因为一些道路缺乏标记和其他标志。
用于定位、绘图和感知的最佳感测模态仍然缺乏准确性和效率。
车对车通信仍然是一个梦想，但这方面的工作也正在进行。
人机交互领域的探索还不够，有很多开放的、未解决的问题。

尽管如此，我们迄今为止开发的技术仍然令人惊叹。通过协调一致的努力，我们可以确保自动驾驶系统是安全、稳健和革命性的。

通过自我监督学习利用未标记的图像数据，或者通过 Mateusz Opala 利用伪标记

原文：https://web.archive.org/web/https://neptune.ai/blog/self-supervised-learning-pseudo-labeling-with-mateusz-opala

这篇文章最初是 ML ops Live(T1)的一集，这是一个互动 Q(T2)环节，ML 从业者在这里回答其他 ML 从业者的问题。

每集都专注于一个特定的 ML 主题，在这一集里，我们与 Mateusz Opala 讨论了如何利用无标记图像数据进行自我监督学习或伪标记。

你可以在 YouTube 上观看:

https://web.archive.org/web/20220926093535if_/https://www.youtube.com/embed/XiOXgsVWnUw?version=3&rel=1&showsearch=0&showinfo=1&iv_load_policy=1&fs=1&hl=en-US&autohide=2&wmode=transparent

视频

或者作为播客在以下位置收听:

但是，如果你喜欢书面版本，这里有！

您将了解到:

1 什么是伪标记和自监督学习

2 伪标签应用:图像和文本数据
3 应用 SSL 或伪标签时的挑战、错误和潜在问题
4 如何用伪标签解决过拟合
5 如何创建和增强数据集？
6 使用伪标记技术时用于数据处理和训练的 MLOps 架构
7 还有更！
我们开始吧。

Sabine: 今天和我们在一起的是 Mateusz Opala ，他将回答关于利用未标记图像数据 进行自我监督学习或伪标记的问题。欢迎你，马修。

Mateusz Opala: 大家好。很高兴来到这里。

萨宾:有你真好。Mateusz 在像 Netguru 和 Brainly 这样的公司担任过许多机器学习的领导职位。Mateusz，你有计算机科学的背景，但你是如何更多地进入机器学习领域的呢？

Mateusz: 这一切都开始于我大学二年级的时候。我的一位教授告诉我，吴恩达正在 Coursera 上做著名的机器学习课程的第一次迭代。我差不多就是从那里开始的，然后做了一个深度无监督学习的学士论文，去了西门子从事深度学习的工作，然后我所有的岗位都是严格意义上的机器学习。

萨宾:从那以后你就一直走这条路？

是的，完全正确。我之前做过一段时间的后端工程师。但在我职业生涯的大部分时间里，我是一名机器学习工程师/数据科学家。

什么是伪标签？

Sabine: Mateusz，给你暖暖身子。你如何在一分钟内给我们解释伪标签？

https://web.archive.org/web/20220926093535if_/https://www.youtube.com/embed/tPtWBQMwyaU?version=3&rel=1&showsearch=0&showinfo=1&iv_load_policy=1&fs=1&hl=en-US&autohide=2&wmode=transparent

视频

Mateusz: 我们来试试。

想象一下，我们有大量的数据，只有少量的数据被标记，而大多数数据是未标记的，我们想训练我们最喜欢的神经网络，让我们称之为 ResNet 50。

在简化过程中，我们在一堆有标签的数据上训练了一个模型，然后利用这个模型，我们在一堆无标签的数据上预测标签。
我们使用预测的标签作为目标来计算未标记数据的损失函数。
我们将标记和未标记数据的损失结合起来，通过网络反向传播并更新权重。这样，我们就可以利用训练体系中未标记的数据。
是一分钟还是更长？

萨宾:干得好。我认为这绝对适合一分钟内，

Mateusz: 我可以给你一个关于计算机科学发展过程的类比，你会怎么想。

假设我们有一个软件开发团队，有几个高级工程师和一堆中级工程师。显然，高级工程师比初级或中级工程师能产生更好的代码质量，但是你可以雇佣有限数量的高级工程师，而且你也想培养中级和初级工程师。所以你需要建立一个两者兼而有之的团队，并使之高效。

如果您投资于代码审查和最佳实践、测试、自动化 CI 和 CD，那么初级工程师也能够将代码交付到产品中。

你可以认为高级工程师是这里的标签数据，

而初级工程师参考一次无标签伪标签。
投资代码评审就像扫描损失函数。在训练初期，你需要投入更多，所以实际上，你更在意的是被标注的数据。一旦网络开始做出好的预测，你也从未标记的数据中受益，所以当你的开发实践非常扎实时，从初级和中级工程师中受益。

萨宾:好吧。谢谢你的比喻。

什么是自我监督学习？

Sabine: 我们确实有一个社区问题:什么是自我监督？Mateusz，你介意做个总结吗？

Mateusz: 当然可以。自我监督，我会说这是无监督技术的子集，当你没有标签的时候。self 意味着您使用输入图像来生成标签。在这个简单对比学习的用例中，为了生成标签，你获取图像，对同一图像进行两次放大，你知道这是同一图像，这就是你的标签。如果你放大两张不同的图像，并把它们相互比较，那么你的标签就是它们不是相同的图像。

基本上，您从数据中生成标签。你在监督学习中训练，但是你没有像在监督学习中那样的注释标签，但是标签以某种方式从你的输入中产生。

伪标签应用:图像和文本数据

斯蒂芬:牛逼。正如你提到的，你目前在 Brainly 担任高级机器学习工程师。你能给我们介绍一些在 Brainly 中对图像数据应用伪标签的不同用例吗？

我知道 Snap 解决是大概用的产品之一。你知道，你可能有更多的想法。

https://web.archive.org/web/20220926093535if_/https://www.youtube.com/embed/X4Qkjym3ysw?version=3&rel=1&showsearch=0&showinfo=1&iv_load_policy=1&fs=1&hl=en-US&autohide=2&wmode=transparent

视频

是的，当然。快速解决是我的团队工作最多的功能。也许我会简短地解释它是关于什么的。

基本上，当你打开手机时，你可以快速想象你想要回答的问题。然后作为一个用户，你可以调整作物来选择问题，然后根据图像上的内容将其发送到文本搜索或我们的数学求解器，你会得到你需要的答案。

我们的团队从事的项目有

Case study with Brainly: How Snap to Solve works

How Snap to Solve works | Source

理解图像上的内容，理解问题的层次，

检测图像的质量问题，
试图告诉用户，他们可以以某种方式改善他们拍摄的图像，以获得更好的答案，
以及路由到该问题所需的特定服务。比如有数学的话，它可以，而不只是在数据库里搜索，它可以直接求解，比如。
去年，我们有一个项目叫做 VICE，是关于视觉内容提取的。

在那个项目中，我们想了解问题的布局。它只是一个对象检测模型，试图预测如下类别:

表，

问题，
图像，
图，
文字，
诸如此类，
问题布局上所有可见的东西。

问题是你的标签预算总是有限的。即使你有强大的预算，强大的公司，这家公司也不是一家初创公司——总有一个极限。不仅仅是钱的问题，还有时间的问题——你能等多久才能拿到标签。

在 Brainly 中，我们有许多来自用户的图像，我们真的喜欢利用所有这些未标记的数据。此外，当您希望开始标注用于训练目的时，您可能希望有一个或多或少平衡的分布。你想有一个类似数量的文本框和表格框，等等。很明显，你的数据通常很不平衡。

我们重用自我监督学习的第一种方法是实际进行一些非监督或半监督分类来生成用于标记的数据，以从我们所有的图像中向下采样数据。因此，我们可以仅为了训练的目的而标记，只是一个小的子集，它仍然是统一的。

在那个项目中，我们致力于一篇名为简单对比学习的论文。在这篇论文的顶部，有两个用于无监督分类的框架，称为:

简单的对比学习基本上就是对比两个图像，一个对另一个。你通过拍摄原始图像来完成，你对图像进行数据扩充和扰动。你对同一个图像做两次扰动。作为一种输入，你有不同的图像，但是你知道，它们是相同的，你学习这些图像的相似性，结果，你得到了那个图像的良好嵌入。

基于这种嵌入，有非常少量的标记数据，我们实际上可以很好地采样训练弱分类器，以最终获得标记的良好候选。这是我们 tem 的第一个自我监督学习方法。

在我们的情况下，伪标签是一个有趣的案例，因为在原始论文中，生成伪标签的是同一个网络。我们走的有点不同，因为在我们的例子中，我们有时有多模态输入，所以我们有文本和图像。但不是在所有阶段我们都有文本，所以有时候，我们只需要处理图像。

然而，当创建数据集和训练时，我们可能会重用历史上可用的文本。我们使用一种基于自然语言处理的方法来为模型生成一个伪标签，然后在产品中只对图像进行推理。

Stephen: 我想知道为什么我现在要回到 Brainly 的使用情形，因为 Snap 要解决。我想知道:

在自我监督学习技术之前，你是否尝试了所有的技术，

或者你只是知道这种特殊的技术是我们认为有效的，然后你就直接应用了它？
它和所有的技术相比怎么样？
Mateusz: 总的来说，我们使用的大多数技术仍然是监督学习，我们对数据进行标记，但这是有限的，而且很耗时。

对我们来说，应用自我监督学习的最佳用例是当我们想要从所有用于标注的数据中进行下采样时。我们实际上想要确保我们在那个标签中有不同种类的数据，并且我们也为我们覆盖所有有趣的情况。

我们可能没有 50-50 分布的笔迹和教科书的图像。在一些市场中，这可能是更多的笔迹，而在一些市场中，这可能只是一点点笔迹，但最终，如果我们有也包含笔迹的数据，则训练是最好的。

它包含不同种类的数据，因此我们可以:

It contains different kinds of data, so we can:

1 处理好了

2 它更好地概括了。
我们提出了用于聚类或无监督图像分类目的的自我监督学习。

我提到过一些例子，其中我们有文本和图像。具体来说，你可以想象用例，这不是一个真正的用例，但你可以想象，我们有一个图像，一个带有一些文本的图像，不像 Brainly 中的问题，但一般来说，你有一些商店的横幅，一般来说，有图像，有文本。

让我们假设您有某种方法可以从图像中生成文本。你有你的数据，你有图像和文本。课文说有一家 24 小时营业的商店，实际上有那家商店的图像。我们想要做的是基于文本为图像生成伪标签，以了解它是商店还是体育场。

我们可以利用一些 NLP 模型，我们可以重用 BERT 或类似的东西来做微调。我们可以做零镜头学习之类的事情来生成标签，我们可以将它们视为平滑标签，然后只在图像上训练模型。

目前，我们最感兴趣的是如何重用在推理过程中不可用的模态，而是重用它们来生成标签，因此我们不需要标记所有的东西。

斯蒂芬:牛逼。谢了。顺便说一句，如果你想了解罪恶是如何运作的，我们用 Brainly 做了一个案例研究。如果你想知道罪恶是如何运作的，我想那会让你明白更多。

Mateusz，在 Brainly 之前，你有从事伪标签工作的经验吗，对你来说怎么样？当时你在用什么应用？

https://web.archive.org/web/20220926093535if_/https://www.youtube.com/embed/NDh0QdXyOes?version=3&rel=1&showsearch=0&showinfo=1&iv_load_policy=1&fs=1&hl=en-US&autohide=2&wmode=transparent

视频

实际上，就在论文发表的时候(我想论文是 2014 年的)。2014 年，我在克拉科夫的一家小创业公司工作，我们为小创业公司做小项目。

有一家创业公司在做智能狗项圈。智能狗项圈装有传感器，如加速度计、陀螺仪、温度计等。我们的机器学习系统的目标是预测狗的行为——狗是在吃东西、喝水还是在跑。后来，我们可以自动发送一些提示给狗主人，警报会说有一个高温和狗很长时间没有喝水。

想象一下，从传感器获取数据很容易，因为你只需给狗戴上狗项圈，但标记这些数据却非常困难。这是一个有趣的故事，我们实际上是如何标记的，因为有这些人，为了他们的工作，他们带很多狗出去。我们只是把它和这些人联系起来，我们和这些人一起散步了很多次，带着狗，我们只是注意到从 2:10 到 2:15，狗在喝酒等等。

这不是收集大量注释的真正可行的方法，但是收集大量未标记的注释很容易。因为我们深受过拟合之苦，据我所知，我们当时探索了伪标签的角度，这对解决该模型的过拟合问题很有帮助。

Sabine: Maciej 想要得到提到的论文的标题或链接。

Mateusz:伪标原纸为董李。我觉得是 2013 年的。

Sabine: 我们实际上在聊天中有一个问题。您是如何选择图像增强来训练 SSL 模型的？您是使用了论文中的方法，还是通过实验找到了最适合您的数据的增强方法？"

https://web.archive.org/web/20220926093535if_/https://www.youtube.com/embed/IPijZroew5Q?version=3&rel=1&showsearch=0&showinfo=1&iv_load_policy=1&fs=1&hl=en-US&autohide=2&wmode=transparent

视频

我从研究论文中的数据扩充开始，所以这就是方案，但是我也尝试了不同种类的扩充。我记得我们的设置略有不同，因为我们的领域实际上与 ImageNet 不同。所以这是合理的，这是不同的东西。

例如，我们不做翻转，因为你不应该翻转文本，至少在英语中不应该，但我在 GPU 上使用 Nvidia DALI 进行数据增强。几乎可以说，我探索了该库中所有典型的增强。我知道，例如，在albuminations中有更多的输出，但它的速度较慢，所以通常我坚持使用 Nvidia DALI。

应用自我监督学习或伪标记时的挑战

Stephen: 说到挑战，你在 Brainly 的应用中应用自监督学习或伪标注时遇到过哪些挑战？

https://web.archive.org/web/20220926093535if_/https://www.youtube.com/embed/S-qezq1wQtA?version=3&rel=1&showsearch=0&showinfo=1&iv_load_policy=1&fs=1&hl=en-US&autohide=2&wmode=transparent

视频

Mateusz: 用简单的对比学习，这个算法需要大量的数据，甚至 100 万张图像。我认为训练这个算法并不容易。显然，在 Brainly，我们有更多的数据，我们可以在更多的数据上进行训练，但是，训练需要很多时间，而且这个项目有它的限制。

最后，我们得出结论，简单对比学习中的预训练嵌入并不比 ImageNet 中的预训练嵌入好多少。它更多的是关于选择标签候选人的任务。

最重要的部分实际上是:

The most important part was actually:

在预训练嵌入上尝试一些简单的东西，比如分离向量机

2 并通过优化超参数搜索重新调整它们，
这在最困难的情况下效果很好。

总的来说，我认为，要进行简单的对比学习，需要:

In general, for tunning the simple contrastive learning, I think, it requires:

1 非常强大的计算能力，

2 分发算法的好方法，
我记得报纸上写的批量也非常大。
他们最初在一堆 TPU 上训练它，我想这篇论文也是来自谷歌。根据内存大小和批处理大小，以您受限的大小复制 TPU 上的所有内容并不容易，例如，在 GPU 上。这些是我看到的挑战。

就伪标签而言，有点不一样。通常，您有一个非常小的标注数据集。如果太小，无法学习基本的群集结构，可以分离出有噪声但很好的初始示例。当你增加越来越多的无标签损耗系数时，你只是在给你的数据添加噪声。

第一个问题可能是一个小的标注数据集。

下一个是，当你做伪标记时，你有一个损失函数，它是标记数据损失和未标记数据损失的加权组合。通常，你从无标签数据的零损失开始，你喜欢在有标签的数据上预热你的网络。例如，在它实际学习聚类结构之前，你可以太快地从未标记开始增加损失函数。
还有，在神经网络中，通常会出现过度自信的现象。例如，预测非常接近 1，或者非常接近 0，特别是当你做伪标记时，预测显然有时是不正确的，这也加强了这种现象，给数据增加了更多的噪声，于是有一种叫做确认偏差的东西，你需要一些技术来解决这个问题。

通常，这是通过应用混合策略来完成的，因此这是一种强大的数据增强，结合了用于正则化目的的标签平滑，这可以减轻确认偏差。

斯蒂芬:牛逼。这个特殊的应用程序是一个小团队就能应用的，还是需要大量的资源？你能告诉我们，对于一个小团队来说，开始应用这个会有多乏味吗，特别是当他们有更小的数据集时，因为当他们没有 Google 大小的数据集时，这更有意义。

我会说，像简单对比学习这样的技术，一般来说，是自我监督的技术，通常需要:

Mateusz: I would say that techniques like simple contrastive learning, which, in general, are self-supervised techniques, usually require:

1 大量的计算，

2 很多 GPU
如果没有适当的基础设施，这对小团队或从事某项工作的个人来说肯定是困难的。

我不认为这个技术对小团队来说是最好的，大概是预先训练好的模型还是比较好用的。

此外，自我监督训练的模型有时也会发表，实际上在麻省理工学院的许可证上有一个很棒的库来自脸书，关于自我监督学习。它非常容易重用，并且是基于 PyTorch 构建的。

但伪标注是一种非常容易实现的东西，它对于对抗或过度拟合和正则化您的网络非常有用，当您有一个较小的数据集时，它可以发挥作用。

应用伪标签时的常见错误

Stephen: 你见过团队在尝试为他们的系统应用伪标签或者甚至尝试应用自我监督学习技术时犯的常见错误吗？

Mateusz: 伪标记的典型问题是当你的少量数据不足以满足聚类假设时。假设数据在低密度区域的决策边界中被很好地分离。

它的基本思想是，彼此靠近并且在同一个簇中的图像共享相同的标签。如果你没有足够的数据来快速学习潜在的聚类结构，这可能不是最优的，但对伪标记来说足够好，那么你最终只会给数据添加噪声。

此外，你可能做得很好，但你最初的小数据集可能不一致，标记的不一致会极大地影响伪标记训练的质量。

如何用伪标签解决过拟合问题

Stephen: 你之前提到过伪标签是一种用来克服过度拟合的特殊技术。在您的用例中，您是如何实现的？你能给我们详细描述一下你与过度拟合作斗争，然后伪标签来拯救你的场景吗？

Mateusz: 在过度拟合的时代，我的用例或多或少带有过去的经验，即带有狗项圈的用例，也更多带有 NLP 用例。

在 Brainly，我们目前有一个用例，我们正在探索应用伪标签的可能性。基本上，我们正在解决过度拟合的原因是我们正在解决的任务定义起来非常主观，并且我们在标签一致性方面很挣扎。此外，我们没有一个好的星期分类器，所以我们需要处理一些类别不平衡，我们没有太多的图像在我们想要检测的类别上。

实际上，对于半监督学习技术和伪标记来说，这是一个很好的例子，我们需要利用所有未标记的数据。

如何创建和增强数据集？

斯蒂芬:酷。放大这张照片。在某个时候，你碰到了这个路障，对吗？你是做什么的？你如何考虑增强你正在使用的这项技术，或者你只是探索其他技术？

因为您谈到了较小的数据集是使用伪标签的主要挑战。如何提高数据集的质量？你考虑过合成数据集吗？你能给我们介绍一下吗？

Mateusz: 我们试图在创建数据集的方式上有所创新。我们真的不需要重新创建像图像这样的数据，因为我们有太多的图像。如果我们有一张图片的标签，我们最好搜索相似的图片。我们有一些预先训练的相似性嵌入，如简单的对比学习。如果我们找到相似的图像，我们可以标记它们，就像有相同的标签一样。这是一方面。

我喜欢的另一件事是，通常，人们认为数据增强是图像或文本的增强，基本上不是目标，而是输入，对吗？

几年前，我在做姿势检测，给人类的姿势加标签也很耗时，因为你需要给 12 个身体关节加标签。我们也在过度适应中挣扎。

我们的想法是，如果你给姿势的身体关节加标签，然后把身体关节的标签移动几个像素，这基本上是相同的标签，因为你只是用一个点给整个头部加标签。我们做了目标增强。类似地，你可以想到我们有时试图在 Brainly 上做的数据扩充，我们试图改变输入图像，所以它们实际上反映了我们缺乏的不同目标。

这也是如何创造性地创建和增加数据集中图像数量的方法。在一天结束的时候，最好只是给你的图片贴上标签。有时候，这就是我个人在做的事情。我只是给更多的图片贴上标签:

That’s also the way how to creatively create and increase the number of images in datasets. At the end of the day, it’s best just to label your images. Sometimes, that’s what I’m just doing personally. I am just labeling more images to:

1 提高我的模型性能

或者改进我的方法，
但是在数据集的创建过程中保持创造性是很重要的。

我认为，在生产环境中创建数据集，就像在商业环境中一样，非常重要，甚至比培训更重要。

我认为 Brainly 的机器学习方法是一种非常以数据为中心的方法，我们试图以这样的方式构建我们的软件，如果我们需要改变数据集，我们可以重新运行一切，并在生产中快速更新新数据集上的模型。我真的相信有创造力和强调数据集的创建是非常重要的。

Stephen: 说到数据集，我们之前也谈到过小型团队，他们有权访问带标签的数据集。当然，我们有很多未标记的数据集，而且很可能不贵。

他们如何找到这种平衡，尤其是如果这对于他们的用例非常关键的话？

他们如何找到这种平衡，他们有这些小的标记数据集，但还有大量的未标记数据集，他们必须使用这种特殊的技术。

你会如何建议他们去寻找平衡，并适当地应用伪标签，甚至自我监督学习？

显然，我建议你需要考虑:

你有什么基础设施？

实际上你能训练多少数据？
您的问题的数据解决方案是什么？
你有多少时间？
当你唯一的限制是 GPU 的大小和培训的时间时，无论你是为云还是在你家的某个地方付费？
当你考虑所有这些的时候，我会从实际训练的最小的标记数据集开始。

这不是抛硬币那样的工作，而是实际上的训练。我会尽可能早地将它可视化，看看数据集中是否确实有一些由你的聚类创建的聚类，以及它们是否有意义。

如果他们做开始有意义，然后有一部分你可以添加未标记的数据。在最初的设置中，您可以同时对已标记和未标记的数据进行训练，但显然，您可以从少量的标签数据开始，看看它是否有一点点表现，看看可视化是否有意义，然后当您发现足够多的数据时，您可以进行两阶段训练。

如果你的数据不够并且没有看到任何聚类，也不是训练，那么你只需要在开始的时候多贴标签。一旦你在那里，然后你可以开始添加标签数据。你可以从头开始你的训练程序，并尝试同时进行。但是，即使你同时训练，你只是从训练未标记的部分和未标记损失的系数开始，这种方式在开始时为零，然后线性增加，直到它达到最终值，你仍然要训练一段时间。
应用伪标签时的潜在问题

Stephen: 除了数据集问题，您是否发现了一些问题会影响图像测试中伪标签的有效性？

Mateusz: 超越数据集问题。我会说，通常与训练问题相关的是神经网络预测的过度自信。这是很难解决的问题。这就是确认偏差的问题。你可以做混合策略等等。但是说到底，这很难。

实际上，为了理解我们的预测是否有意义，我们还使用了像 SHAP 值或更老的莱姆值这样的解释器，但它们不一定总是能很好地处理图像。有时会，有时不会。

神经网络的过度自信，即使你有很好的指标，如测试集，验证集，无论是精度，召回，F1，等等，如果你看到你的预测非常过度自信，这仍然不是很好，这可能是错误的。这无疑也会影响重用伪标签的能力。

斯蒂芬:逮到你了。我认为有这种特殊，我不知道它有多普遍，但它就像集群假设是伪标签工作的必要条件。你对这个特定的短语本身有什么看法？

Mateusz:聚类假设基本上是说，数据在分类时，应该形成单独的聚类和决策边界。当你思考类似的问题时，比如在 SVM 的情况下，决策边界需要在低区域密度。

他们在原始论文中所做的，实际上，是一个非常有趣的伪标签实验。他们在众所周知的 MNIST 数据集上训练，但是一些实验后来在 CFAR 等上重现。不仅仅是 MNIST 的设定，在 MNIST，他们训练了模型，他们使用 t-SNE 在 2D 平面上进行降维来可视化预测。

实际上，预测的分离，当它以纯监督的方式被训练时，它没有当你使用伪标签时那么好。

当您使用伪标签时，集群显然是从其自身推出的，因此集群之间有明确的边界。这表明，熵正则化，只是一个伪标记损失函数，只是正则化熵正则化，这意味着我们试图减少类的重叠。最后，当你把它形象化时，它确实减少了，阶级的集群确实被分开了。

斯蒂芬:完美。就偏见而言。使用伪标签时，你是否发现使用伪标签存在伦理问题？如果有，也许你能让我们知道？

我认为问题是从你正在使用的数据集中继承而来的。我觉得更多的不是受模型或者模型的技术影响。

如果偏差在数据集中，它们将被模型重现。如果您想要消除模型的偏差，您需要消除数据集的偏差。

斯蒂芬:完美。我相信相当多的伪标注和自监督学习还在积极研究中，对吧。

有没有特定的情况或场景，你实际应用这些技术，然后它们提高你的模型的稳健性或你的模型性能，无论是在 Brainly，甚至是你以前的公司？因为我们有团队分享这一点，并说，“嘿，我们可以尝试一下，但我们需要实际的数字来了解它如何帮助现实世界的生产？”

Mateusz: 在这种典型的伪标签场景中，当您使用来自训练模型的标签时，在狗项圈的情况下，我们的模型过度适应了它实际上不可部署的方式。即使它有足够好的性能，例如，分类，但训练集和验证之间的差距是巨大的，所以我不会相信这个模型。伪标签在某种程度上有助于限制间隙，间隙足够小，我看到它不再过度拟合。

也许它不是完美的度量，但它不是过度拟合，所以它开始可部署。这绝对有帮助，这是在最初的设置。伪标记，当我们使用原始论文中的实现(这在任何框架中都很容易实现，无论你使用 PyTorch 还是 TensorFlow )时，已经有了很多改进，使用确认偏差和混合策略来实现。

此外，在原始论文中，例如，对于伪标签，他们对模型的输出进行 arg max 。他们使用硬预测，特别是在 mix-up 论文中，他们表明硬预测也是神经网络过度自信的原因，因此，有一个小的混合，或者只是标签平滑，这有助于作为正则化来改善，以解决过度拟合。

使用伪标记技术时用于数据处理和训练的 MLOps 体系结构

Stephen: 我想简单地回到计算方面。

就你的计算机架构而言，在使用这些技术时，Brainly 是否应用了特定的架构？

你使用分布式计算吗，特别是在数据扩充方面，我相信这将是分布式的？

您如何为数据处理(这是一项巨大的任务)以及模型本身的培训建立架构？

大多数的东西，我们用的是 SageMaker 。对于实验跟踪，我们使用海王星。这更多是在开发方面，但我们在那里跟踪一切，如处理作业。我们试图跟踪一切，以便在创建数据集或类似的过程中不遗漏任何东西。在计算方面，我们只是使用了 SageMaker 估算器和 SageMaker 流水线，它们都支持多 GPU 实例和极端多节点实例。

我们还尝试在实例集群上进行训练，其中每个实例都有一个多 GPUinstance。我们主要使用 PyTorch，它支持一个叫做 Torch Distributed 的工具，我们用它来运行 PyTorch 上的分发。也有本地 SageMaker 的方式来编排。我们目前也在探索它是否能改善某些东西。

我认为，在优化方面还有一些工作要做。典型的设置是 Horovod 算法。在过去，我有一些比 Horovod 更好的分布式算法的经验，例如，弹性平均 SGD，在某些用例中，它实际上有时为训练收敛提供了超线性加速。这也是一个值得探讨的问题，但也需要一些自定义实现。

Stephen: 你能给我们介绍一下这个特定的数据基础设施吗？你把你所有的数据集存储在哪里，当然，如果是可公开的，你会如何积极地去做？你提到了 Nvidia DALI，这对于论证非常重要，我可以分享一下周围的另一个堆栈吗？

Continuous delivery pipeline

Continuous delivery pipeline | Source

Mateusz: 当然可以。我想我可以用简化的方式来做。通常，我们在 AWS 上使用 S3 来存储数据集。

实际上，我们已经为数据集版本化构建了我们的内部解决方案，因为到目前为止，我们还没有在这个领域找到任何足够适合我们的解决方案。每当我们在 SageMaker 上运行作业时，我们都使用该解决方案来获取数据集。我们建造了一些自己的筒仓来提取运行。

实际上，我们有相同的命令和相同的代码在本地环境中运行，在 EC2 上，但是在本地模式下，当你通过 SSH 连接时，这是在云中工作的数据科学家的完美设置。您只需打开一个终端，通过 SSH 连接，您面前就有 GPU 可供使用。通过 SageMaker 还可以以更具重现性的方式运行，因此您可以通过 SageMaker Estimator 来完成，或者在有多个步骤时作为 SageMaker 管道来完成。

通常，我们会在 SageMaker Pipeline 上运行更多的生产培训，以便我们可以对图像进行一些预处理，或者我们可以将培训推送到模型注册中心，我们也在 SageMaker 上使用过。

当我们把一些东西推送到模型注册中心时，我们有一些自动化的工作来评估我们在维持集上的性能。如果一切正常，如果作为一名数据科学家，您查看 Neptune 上的运行指标，这些指标是否正常，然后您进入代码管道，您批准模型，它将自动推向生产。

自我监督学习:研究与生产

斯蒂芬:我知道这个特殊的领域正在被积极地研究。在自我监督学习和伪标签方面，有没有什么正在积极研究的东西，你不能积极投入生产，或者你想这样做？

是的，他们是。T3

在那种商业环境下，你受到限制，你需要在有风险和无风险的事情之间取得平衡。在自我监督学习中，问题是训练需要很多时间和成本，所以你不能只是在参数上进行网格搜索，然后训练那个模型的 100 个变体，因为它会像 GPT 训练一样花费 200 万美元或类似的东西。

这是你需要认真努力的事情。但一般来说，使用这种自我监督的学习方法是我们肯定想用大脑探索的东西，因为我们有大量的数据。我们知道，我们的图像领域实际上与 ImageNet 甚至其他领域有很大不同。

例如，根据我们在 VICE 项目中的经验，当我们为问题布局进行对象检测时，我们试图重用医学出版物上的标签数据，这些数据实际上已经为边界框或一些数学论文进行了标记。

问题是这些数据实际上非常不同。根据数据训练的解决方案效果不好，甚至为了检测数据中的某些东西而重用数据也是随机的。这只是表明，深度学习在一天结束时只是训练一些在您的特定用例中工作得非常好的哈希映射。

最大的 MLOps 挑战

萨宾:我想把事情总结一下，马特乌斯。从您的角度来看，您认为目前您在 MLOps 方面面临的最大挑战是什么？

数学:T1

我现在最大的挑战是连接整个机器学习模型生命周期中的所有步骤。

我现在面临的许多挑战都与数据集的创建有关。

从数据版本控制部分开始，我们使用不同的技术创建了大量的数据集，这只是需要完成的一项工作。

对于创建，您还需要自动化，如我们用于培训的 SageMaker 管道，您可以使用 SageMaker 管道来自动化数据集创建。
与此同时，标签。我如何知道我有足够的数据被标记，我不需要标记更多，我不需要自己标记更多，或者我不需要支付自由职业者或标记更多，这就足够了？也可以考虑自动化主动学习技术，它在自动化数据集创建方面可能是有用的。
我目前在机器学习模型生命周期中面临的挑战主要围绕数据创建。我们在培训、生产和持续交付方面组织得非常好。

此外，我是一名机器学习工程师，但我更多地从事数据科学方面的工作。围绕数据集的挑战目前每天都是最具挑战性的。

还包括在没有标签的情况下，实际检测您的模型何时开始表现不佳的生产挑战:

分析预测变化，

输入发生了变化。
这些也是我目前正在探索的事情。

Sabine: 我相信你不会很快就面临挑战。

是的，我不是。

萨宾:马特乌斯，这是最后一个加分题。你到底想和谁共进午餐？

我认为这个世界上有很多有趣的人。也许我会提到来自 Databricks 的 to Matei Zaharia，他们正在做 MLflow 和 Spark 。这些都是非常有趣的解决方案。

萨宾:优秀。人们如何才能关注你在做什么并与你联系？也许在网上，你可以分享？

Mateusz: 我觉得在 LinkedIn 和 Twitter 上和我联系很好。我想两者都是，这只是 Mateusz Opala，我的手柄。这是在社交上接近我的最好方式。

马特乌斯·奥帕拉

Brainly 高级机器学习工程师| 2012 年起专业软件工程师，2013 年起做机器学习，2014 年起领导团队，频繁公开演讲包括 PyData Warsaw，DataSphere.it，MachineLearning@Enterprise。

阅读下一篇

Brainly 案例研究:如何管理 SageMaker 管道中的实验和模型

7 分钟阅读| 2022 年 8 月 18 日更新

7 mins read | Updated August 18th, 2022

Brainly 是全球领先的学习平台，拥有针对所有学校科目和年级的最广泛的知识库。每个月都有超过 3 . 5 亿的学生、家长和教育工作者依赖 Brainly 这个成熟的平台来加速理解和学习。

他们的核心产品和关键切入点之一就是 Snap 解决。

Snap to Solve 如何工作

Snap to Solve 是一款基于机器学习的产品，用户可以拍摄并上传照片；然后，Snap to Solve 会检测照片中的问题并提供解决方案。

Snap to Solve 通过将用户与其他智能产品功能相匹配来提供此类解决方案，如社区问答(问题和答案的知识库)或数学求解器(提供数学问题的分步解决方案)。

关于团队

Brainly 有一个人工智能服务部门，它投资于在不同领域(如内容、用户、课程和视觉搜索)生产人工智能服务。

这个案例研究显示了视觉搜索团队如何将 Neptune.ai 与亚马逊 SageMaker Pipelines 集成，以跟踪 Brainly 的 Snap to Solve 产品的视觉内容提取(VICE)系统开发阶段的一切。

团队详情

1 名首席数据科学家

2 名数据科学家
2 名机器学习工程师
1 名 MLOps(机器学习操作)工程师
1 名数据分析师
1 名数据标签主管
1 名交付经理
工作流程

该团队使用 Amazon SageMaker 来运行他们的计算工作负载，并为他们的模型提供服务。此外，他们已经采用 Tensorflow 和 PyTorch 来训练大量的计算机视觉模型，根据用例使用任一框架。最后，为了优化 GPU 的数据转换速度，他们将一些数据增强工作转移到了 NVIDIA DALI。

该团队在两周的冲刺中工作，并使用时间限制来保持他们的研究工作重点和管理实验。他们还保持工作流程的灵活性，因为他们经常适应实验结果。

The team works in two-week sprints and uses time-boxing to keep their research efforts focused and manage experimentation. They also keep their work processes flexible because they frequently adapt to the experiment results.

Continue reading ->

自我监督学习及其应用

原文：https://web.archive.org/web/https://neptune.ai/blog/self-supervised-learning

在过去的十年里，人工智能的研究和发展突飞猛进，特别是在 2012 年 ImageNet 比赛结果公布之后。焦点主要集中在监督学习方法上，这些方法需要大量的标记数据来为特定用例训练系统。

在本文中，我们将探索自我监督学习(SSL)——机器学习社区中的一个热门研究话题。

什么是自我监督学习(SSL)算法？

自我监督学习(SSL) 是一种不断发展的机器学习技术，旨在解决标签数据过度依赖带来的挑战。多年来，使用机器学习方法构建智能系统在很大程度上依赖于高质量的标记数据。因此，高质量注释数据的成本是整个训练过程中的一个主要瓶颈。

人工智能研究人员的首要任务之一是开发具有非结构化数据的自我学习机制，这些机制可以以低成本规模化通用人工智能系统的研发。实际上，要收集和标注各种各样的数据是不可能的。

为了解决这个问题，研究人员正在研究能够捕捉数据中细微差别的自我监督学习(SSL)技术。

在我们进入自我监督学习之前，让我们先了解一些在构建智能系统中使用的流行学习方法的背景。

1.监督学习

一种流行的学习技术，用于根据特定任务的标记数据训练神经网络。你可以把监督学习想象成一个教室，一个老师用许多例子教学生。例如用于对象分类。

2.无监督学习

无监督学习是一种深度学习技术，用于发现数据中的隐含模式，而无需对标记数据进行显式训练。与监督学习不同，它不需要注释和反馈回路来进行训练。例如用于聚类。

Unsupervised Learning

Unsupervised learning | Source

3.半监督学习

半监督学习是一种机器学习方法，其中我们有输入数据，输入数据的一部分被标记为输出。它是监督学习和非监督学习的混合。

Semi-supervised learning

Semi-supervised learning | Source

在我们只有少量标记数据点来训练模型的情况下，半监督学习可能是有用的。训练过程可以使用一小块已标记的数据，并对数据集的其余部分进行伪标记。

例如，一个学生被老师教了几个问题，他必须自己想出其余问题的答案。

4.强化学习

强化学习是一种利用奖励反馈策略训练 AI 智能体在特定情境下学习环境行为的方法。

举个例子:把它想象成一个在游戏中努力赢得舞台的孩子。

Reinforcement learning process

Reinforcement learning process | Source

什么是自我监督学习？

自我监督学习是一个机器学习过程，其中模型训练自己从输入的另一部分学习输入的一部分。它也被称为预测学习或借口学习。

在这个过程中，通过自动生成标签将无监督问题转化为有监督问题。为了利用大量的未标记数据，设置正确的学习目标以从数据本身获得监督是至关重要的。

自我监督学习方法的过程是从输入的任何未隐藏部分中识别输入的任何隐藏部分。

Self-supervised learning

Self-supervised learning | Source

例如，在自然语言处理中，如果我们有几个单词，使用自我监督学习我们可以完成句子的其余部分。同样，在视频中，我们可以根据可用的视频数据预测过去或未来的帧。自我监督学习使用数据的结构来利用大型数据集的各种监督信号——所有这些都不依赖于标签。

自我监督学习和无监督学习有什么区别？

许多人混淆了这两个术语，并互换使用。然而，这两种学习技巧有不同的目标。

自监督学习和无监督学习方法可以被认为是互补的学习技术，因为两者都不需要标记数据集。无监督学习可以被认为是自监督学习的超集，因为它没有任何反馈循环。相反，自我监督学习有许多监督信号，在训练过程中起反馈作用。

一种更简单的说法是,“无监督”学习技术非常关注模型而不是数据，而“自我监督学习”技术的工作方式正好相反。然而，无监督学习方法擅长聚类和降维，而自监督学习是用于回归和分类任务的借口方法。

为什么我们需要自我监督学习？

自我监督学习的出现是因为在其他学习过程中持续存在以下问题:

高成本:大部分学习方法都需要标注数据。就时间和金钱而言，高质量标记数据的成本非常高。
漫长的生命周期:数据准备生命周期是开发 ML 模型的漫长过程。它需要根据培训框架进行清理、过滤、注释、审查和重组。
Generic AI: 自我监督学习框架离将人类认知嵌入机器又近了一步。

现在让我们来谈谈自我监督学习在不同领域的效用。

自监督学习在计算机视觉中的应用

多年来，计算机视觉中学习方法的焦点一直是朝着完善模型架构和假设我们拥有高质量数据的方向发展。然而，在现实中，如果没有高成本的时间和精力，很难获得高质量的图像数据，从而导致次优的训练模型。

最近，研究重点的很大一部分已经放在开发跨不同应用的计算机视觉中的自监督方法上。用未标记的数据训练模型的能力加快了整体训练过程，并使模型能够在不引入标记偏差的情况下学习潜在的语义特征。

为了训练自监督模型，主要有两个阶段:

我们用于预训练的任务被称为借口任务。借口任务(也称为监督任务)的目的是指导模型学习数据的中间表示。它有助于理解潜在的结构意义，这对实际的下游任务是有益的。

生成模型可以被认为是自我监督的模型，但是具有不同的目标。例如，在 GANs 中，它们用于为鉴别器生成逼真的图像，而自我监督训练的目的是识别可用于各种任务的良好特征，而不仅仅是欺骗鉴别器。

下游任务是托词模型到具体任务的 知识转移过程 。向下游任务提供更少量的标记数据。

视觉领域中的下游任务也称为目标任务，可以是对象识别、对象分类、对象再识别等。在托词模型上做了微调。

研究人员已经为使用 SSL 方法训练不同的基于图像的任务提出了许多想法。

补丁定位

目的:托辞任务的目的是使用自我监督学习来识别图像中不同斑块之间的关系。

Patch localization in image

Patch localization in image | Source

训练算法 论文

**1. 从图像中随机抽取一块样本。
2. 最近邻:假设第一个面片位于 3×3 网格的中间，第二个面片从其 8 个相邻位置采样。
3. 引入增强功能，如补片之间的间隙、色差、补片的下采样和上采样，以处理像素化和色彩抖动。这有助于模型不过度拟合某些低电平信号。
4. 该任务的目的是识别 8 个相邻位置中的哪一个是第二块。该任务被设计成一个超过 8 类的分类问题。

在完成托词任务时，重要的是要确保它不是在学习与全局模式下的高级潜在特征相比微不足道的模式。例如，像面片之间的边界纹理这样的低级线索可以被认为是微不足道的特征。然而，对于某些图像，存在一个微不足道的解决方案。这是由于相机镜头效应造成的，称为色差，色差是由于不同波长的光的焦点不同而产生的。

卷积神经网络能够通过检测品红色(蓝色+红色)和绿色之间的差异来学习补丁的相对位置。最近邻实验证明，很少有小块从绝对相同的位置提取区域，因为小块显示相似的像差。

上下文感知像素预测

目的:使用编码器-解码器基于图像的整体上下文来预测图像中未知块的像素值。

训练算法 论文

**1. 使用普通的编码器-解码器架构来训练托词任务。
2. 编码器( Pathak 等人，2016 )使用具有涂黑区域的输入图像产生图像的潜在特征表示。
3. 解码器使用来自编码器的潜在特征表示，并使用重建损失(MSE)来估计丢失的图像区域。
4. 编码器和解码器之间的通道式全连接层允许解码器中的每个单元对整个图像内容进行推理。

Context encoder architecture

Context encoder architecture | Source

损失函数

训练中使用的损失函数是重建损失和对抗损失。

重建损失

重建(L2)损失负责捕获相对于完整图像背景的显著特征。
重建损失定义为输入图像的归一化屏蔽距离 x 。
- M :对应于被去除图像区域的二进制掩码，对于输入像素值为 0，不考虑像素时为 1。
- F: 产生编码器输出的函数

敌对损失

对手损失被建模以使预测看起来真实，并学习它被训练的输入数据的潜在空间。
因为鉴别器 D 能够利用修补区域和原始上下文中的永久不连续性，所以只有生成器 G 针对输入掩码进行调节。

关节损失

联合损失是通过结合重建和对抗损失发展起来的
然而，在实验中，作者意识到，只有在不利损失的情况下，修复效果最好。

语义修复是使用 SSL 方法通过辅助监督和学习强特征表示来实现的。早在 2016 年，这篇论文就是使用 SSL 方法训练竞争形象模型的早期先驱之一。

自监督学习在自然语言处理中的应用

在 SSL 成为主流计算机视觉研究的一部分之前，SSL 已经在自然语言处理(NLP)领域取得了巨大的进步。从文档处理应用程序、文本建议、句子完成等等，语言模型几乎无处不在。

然而，自从 2013 年发表了革新 NLP 领域的 Word2Vec 论文以来，这些模型的学习能力已经发生了演变。单词嵌入方法的想法很简单:我们不需要一个模型来预测下一个单词，我们可以让它根据之前的上下文来预测下一个单词。

由于这些进步，我们能够通过单词嵌入的分布来获得有意义的表示，这可以用于许多场景，如句子完成、单词预测等。如今，NLP 中最流行的 SSL 方法之一是 BERT。

在过去的十年中，NLP 领域的研究和开发不断涌现。让我们在下面提取一些重要的。

下一句预测

在下一句预测(NSP)中，我们从一个文档中选取两个同时出现的句子，并从相同或不同的文档中随机选取一个句子，比如句子 A、句子 B 和句子 c。然后我们询问模型句子 A 相对于句子 B 的相对位置？–并且模型输出 IsNextSentence 或 IsNotNextSentence。我们对所有组合都这样做。

考虑以下场景:

放学后，迈克回家了。
将近 50 年后，载人登月任务终于开始了。
一回到家，迈克看着网飞放松。

如果我们让一个人重新排列任何两个符合我们逻辑理解的句子，他们很可能会选择 句子 1 ，然后是 句子 3 。

这个模型的主要目的是基于长期的上下文依赖来预测句子。

来自变形金刚的双向编码器表示(BERT) 谷歌人工智能团队的研究人员发表的一篇论文已经成为自然语言推理(MNLI)、问答(SQuAD)等几项 NLP 任务的黄金标准。

对于这样的下游任务，BERT 提供了一种很好的方法来捕捉句子之间的关系，这是通过其他语言建模技术不可能实现的。下面是下一句预测的工作原理。

为了让 BERT 处理各种下游任务，输入表示能够明确地表示一对在单个序列中打包在一起的句子。“序列”是指 BERT 的输入令牌序列。
每个序列的第一个标记总是一个特殊的分类标记([CLS])。对应于该令牌的最终隐藏状态被用作分类任务的聚集序列表示。
我们用两种方法区分句子。首先，我们用一个特殊的标记([SEP])将它们分开。第二，我们向每个标记添加一个学习嵌入，指示它是属于句子 A 还是句子 b。
我们将输入嵌入表示为 E，将特殊[CLS]标记的最终隐藏向量表示为 C，将第 I 个^(输入标记的最终隐藏向量表示为 T[I .]该向量 C 用于下一句预测(NSP))

这个任务可以从下面的例子来理解:

如果你想利用 BERT 模型来完成这个任务，你可以参考拥抱脸文档。

自回归语言建模

虽然像 BERT 这样的自动编码模型利用自监督学习来完成像句子分类(next 或 not)这样的任务，但自监督方法的另一个应用是文本生成领域。

像 GPT(预训练生成转换器)这样的自回归模型是在经典的语言建模任务中预训练的——在阅读了所有前面的单词后预测下一个单词。这种模型对应于变压器的解码器部分，并且在整个句子的顶部使用了一个遮罩，以便注意力只能够看到文本中之前的内容，而不是之后的内容。

让我们通过查看 GPT 的训练框架来更深入地了解这些模型是如何工作的。

培训程序包括两个阶段:

无监督预训练

第一阶段是在大型文本语料库上学习高容量语言模型。

给定一个无监督的记号集 U = {u [1] ，。。。，u [n] }，我们使用标准语言建模目标来最大化以下可能性:

其中 k 是上下文窗口的大小，并且条件概率 P 使用具有参数θ的神经网络来建模。使用随机梯度下降来训练这些参数。

这里训练的模型是语言模型的多层 transformer 解码器，它是 transformer 的变体。该模型在输入上下文标记上应用多头自关注操作，随后是逐位置前馈层，以产生目标标记上的输出分布:

其中 U =(U[—k]，。。。，u[—1]是记号的上下文向量，n 是层数，W [e] 是记号嵌入矩阵，W [p] 是位置嵌入矩阵。这种受约束的自我关注(每个标记都可以关注其左侧的上下文)将自我监督的方法带入了画面。

在这一步中，我们假设一个带标签的数据集 C，其中每个实例由一系列输入标记 x ¹ 组成。。。输入通过我们预先训练的模型，以获得最终变压器块的激活 h^ml，然后将其馈送到添加的线性输出层，该输出层具有参数 W [y] 以预测 y:

这为我们提供了以下最大化目标:

将语言建模作为微调的辅助目标有助于学习——提高监督模型的泛化能力，加速收敛。具体来说，我们优化以下目标(权重为λ):

总的来说，在微调过程中，我们需要的唯一额外参数是 W [y] ，以及分隔符标记的嵌入。

(left) Transformer architecture and training objectives used in this work. (right) Input transformations for fine-tuning on different tasks

(left) Transformer architecture and training objectives used in this work
(right) Input transformations for fine-tuning on different tasks | Source

在上图中，左边是 Transformer 架构和培训目标，右边是针对不同任务进行微调的输入转换。我们将所有结构化输入转换为令牌序列，由我们预先训练的模型进行处理，然后是线性+softmax 层。对于不同的任务，需要不同的处理，就像对于文本蕴涵，我们连接前提(p)，包含文本和假设(h)，包含文本，标记序列，中间有分隔符标记($)。

对最初的 GPT 模型进行了多次改进，要了解如何将它用于您自己的用例，您可以参考此页。

自我监督学习应用:工业案例研究

到目前为止，我们已经讨论了如何使用自我监督的方法来训练流行的模型，以及如何自己训练或使用可用库中的模型。

现在，让我们来看看业界是如何利用这项技术来解决关键问题的。

1.脸书的仇恨言论检测

“我们认为，自我监督学习(SSL)是在人工智能系统中建立背景知识和近似常识形式的最有前途的方法之一。”

AI Scientists, Facebook

脸书不仅通过基础、开放的科学研究在许多领域推进自我监督学习技术,而且他们还将这一前沿工作应用于生产，以快速提高其产品中内容理解系统的准确性，从而确保人们在其平台上的安全。

一个这样的例子是 XLM，脸书人工智能的跨多种语言训练语言系统的方法，不依赖手动标记的数据集来提高仇恨言论检测。

Hate-speech detection at Facebook

Hate-speech detection at Facebook | Source

这种自我监督学习的应用使得他们的模型更加健壮，他们的平台更加安全。让我们简单谈谈 XLM 是什么，以及它是如何做出如此改变的。

XLM

型号

它是一个基于 Transformers 的架构，使用三个语言建模目标之一进行预训练:

随意语言建模(CLM): 根据句子中前面的单词，对一个单词的概率进行建模，即 P(w [t] |w [1] ，。。。，w[t1]，θ)。
掩蔽顾岚年龄建模(MLM):BERT 的掩蔽语言建模目标，即使用[MASK]关键字掩蔽随机选择的标记，并尝试预测它们。
翻译语言建模(TLM):MLM 的新增和扩展，它不考虑单语文本流，而是连接平行句子，如下图所示。源句子和目标句子中的单词都被屏蔽。为了预测英语句子中隐藏的单词，模型可以关注周围的英语单词或法语翻译，鼓励模型对齐英语和法语表示。如果英语上下文不足以推断被屏蔽的英语单词，该模型还可以利用法语上下文。

Cross-lingual language model pretraining

Cross-lingual language model pertaining | Source

因此，XLM 是一个跨语言的语言模型，其预训练可以在 CLM、MLM 或 MLM 与 TLM 结合使用的情况下进行。现在，让我们来看看 XLM 带来的好处。

性能分析

跨语言分类

XLM 为零射击跨语言分类提供了更好的句子编码器初始化，并能够通过 MLM 方法在相同的句子编码器上获得 71.5%的准确度，从而实现最先进的(SOTA)性能。结合 MLM 和 TLM 将性能进一步提高到 75.1%。

机器翻译系统

类似于第一点，它提供了监督和非监督神经机器翻译系统的更好的初始化。具有 MLM 目标的预训练显示了在无监督系统的情况下的显著改进，而相同的目标导致了在有监督系统中的 SOTA 性能，BLEU 得分为 38.5。

低资源语言的语言模型

对于资源较少的语言来说，利用类似但资源较多的语言中的数据通常是有益的，尤其是当它们共享很大一部分词汇表时。发现 XLM 通过利用来自印地语(一种相对流行的具有大量资源的语言)的信息来改进尼泊尔语语言模型(一种低资源语言)，因为它们共享相同的 Devnagari 文字。

无监督的跨语言单词嵌入

XLM 在跨语言单词嵌入方面优于先前的工作，在源单词和它们的翻译之间达到了 0.69 的 SOTA 水平皮尔逊相关分数。

有了这样的进步，XLM 确实在自然语言处理方面有所作为。

2.谷歌的医学影像分析模型

在医学领域，训练深度学习模型一直是一项困难的任务，因为标记的数据有限，而且标注这些数据既耗时又昂贵。为了解决这个问题，谷歌的研究团队引入了一种新的多实例对比学习(MICLe)方法，该方法使用每个患者病例的潜在病理的多个图像，为自我监督学习构建更多信息的阳性对。

Google’s medical imaging analysis model

Google’s medical imaging analysis model | Source

关于图示的方法，需要记住几件事:

第一步是使用 SimCLR 进行的，这是 Google 为图像的自我监督表示学习设计的另一个框架。我们将很快讨论它。
与步骤(1)不同，步骤(2)和(3)是特定于任务和数据集的。

所以还是一步一步来。

步骤 1:sim clr 框架

它代表了视觉表征对比学习的一个简单框架，极大地推动了自监督和半监督学习的发展，并在有限的类别标记数据下实现了图像分类的新纪录。

SimCLR 首先在未标记的数据集上学习图像的通用表示，然后可以用少量的标记图像进行微调，以实现给定分类任务的良好性能(就像医学成像任务一样)。
遵循一种称为对比学习的方法，通过同时最大化同一图像的不同变换视图之间的一致性和最小化不同图像的变换视图之间的一致性来学习通用表示。使用这种对比目标来更新神经网络的参数使得对应视图的表示彼此“吸引”,而不对应视图的表示彼此“排斥”。
首先，SimCLR 从原始数据集中随机抽取示例，使用简单扩充的组合将每个示例转换两次，创建两组对应的视图。
然后，它使用基于 ResNet 架构的 CNN 来计算图像表示。
最后，SimCLR 使用全连接网络(即，MLP)计算图像表示的非线性投影，这放大了不变特征并最大化了网络识别同一图像的不同变换的能力。

经训练的模型不仅在识别同一图像的不同变换方面做得很好，而且还学习相似概念的表示(例如，椅子对狗)，这些概念稍后可以通过微调与标签相关联。

米克尔

在用 SimCLR 对未标记的自然图像完成初始预训练之后，训练该模型以捕捉医学图像数据集的特殊特征。这也可以用 SimCLR 来完成，但是这种方法只能通过增强来构建阳性对，而不能轻易地利用患者的元数据来构建阳性对。因此这里使用 MICLe。

给定给定患者病例的多个图像，MICLe 通过从来自同一患者病例的两个不同图像中绘制两个裁剪来构建用于自我监督对比学习的正对。这种图像可以从不同的视角拍摄，并显示具有相同潜在病理的不同身体部位。
这为自监督学习算法提供了一个很好的机会，以直接方式学习对视点、成像条件和其他混淆因素的变化具有鲁棒性的表示。

第三步:微调

该模型在微调期间被端到端地训练，使用预训练网络的权重作为下游监督任务数据集的初始化。
对于微调期间的数据增强，在两个任务(皮肤病学和胸部 x 光)中对图像进行了随机颜色增强、带大小调整的裁剪、模糊、旋转和翻转。
对于预训练策略和下游微调任务的每个组合，执行广泛的超参数搜索。

技术性能分析

自监督学习利用未标记的特定领域医学图像，并且显著优于监督 ImageNet 预训练。

Comparison of supervised and self-supervised pre-training, followed by supervised fine-tuning using two architectures on dermatology and chest X-ray classification.

Comparison of supervised and self-supervised pre-training, followed by supervised fine-tuning using two architectures on dermatology and chest X-ray classification | Source

自我监督预训练模型可以更好地概括分布变化，其中最小预训练导致最大增益。这是一个有价值的发现，因为分布转移下的泛化对临床应用至关重要。

Evaluation of models on distribution-shifted datasets

Evaluation of models on distribution-shifted datasets | Source

使用自监督模型的预训练可以补偿医学图像分类的低标签效率，并且在采样的标签部分中，自监督模型始终优于监督基线。事实上，MICLe 仅使用 ResNet-50 (4x)的 20%的训练数据和 ResNet152 (2x)的 30%的训练数据就能够匹配基线。

$Top-1 accuracy for dermatology condition classification for MICLe, SimCLR, and supervised models under different unlabeled pretraining dataset and varied sizes of label fractions$

Top-1 accuracy for dermatology condition classification for MICLe, SimCLR, and supervised models under different unlabeled pretraining dataset and varied sizes of label fractions | Source

自我监督学习的挑战

到目前为止，我们已经讨论了自我监督学习如何在机器学习社区的几乎每个领域取得进展，但它也有一些缺点。自我监督学习试图实现“一种方法解决所有问题”的方法，但它远没有实现。SSL 领域的一些关键挑战是:

准确性:虽然 SSL 技术的前提是不使用带标签的数据，但这种方法的缺点是您要么需要大量数据来生成准确的伪标签，要么会牺牲准确性。需要注意的是，在初始步骤中进行训练时，生成的不准确标签会产生反作用。
计算效率:由于多阶段训练(1。生成伪标签 2。在伪标签上训练)与监督学习相比，训练模型所花费的时间较高。此外，当前的 SSL 方法需要大量的数据来实现接近监督学习的准确性。
托辞任务:为你的用例选择合适的托辞任务非常重要。例如，如果您选择 autoencoder 作为您的托词任务，其中图像被压缩，然后重新生成，它也会试图模仿原始图像的噪声，如果您的任务是生成高质量的图像，这种托词任务将弊大于利。

关键要点

在本文中，我们了解了什么是自我监督学习，为什么它越来越受欢迎，以及与它相关的风险和挑战是什么。我们还讨论了使用这种方法训练的流行模型，并深入探讨了大型科技公司如何利用自我监督学习来解决一些真正紧迫的问题。

总结一下我们目前所学的知识:

在我们处理与数据相关的挑战的用例中，自我监督学习是一种福气。从用于数据集准备的资源不足到耗时的标注问题，不一而足。
另一个好处是下游任务，即迁移学习。模型可以在未标记的数据集上以自我监督的方式进行预训练，然后可以针对特定的用例进行进一步的微调。
作为前两点的结果，如果你想建立一个可扩展的 ML 模型，自我监督学习显然是一种可行的方法。
然而与此同时，人们必须意识到使用这种方法所附带的条件。

虽然我们试图在本文中涵盖很多内容，但显然我们讨论的内容并不详尽。关于自我监督学习还有很多东西要学。如果您想了解更多有关其当前和潜在使用案例的信息，您可以参考以下资料:

快乐学习！

参考

德瓦尔·沙阿

对智能软件系统很好奇。作为我日常生活的一部分，我编写程序，写关于人工智能的新研究趋势，阅读关于技术、文化、政治和体育的书籍。

阿布舍克·贾

一个好奇的家伙，目前正在建造模型，希望有一天能建造天网。跟随这个空间，学习未被理清的数据科学概念，并站在未来的正确一边！

阅读下一篇

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

Dhruvil Karani |发布于 2020 年 10 月 12 日

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

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

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

一些典型的原因是:

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

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

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

Continue reading ->

Python 中的情感分析:TextBlob vs Vader 情感 vs 天赋 vs 从头构建

原文：https://web.archive.org/web/https://neptune.ai/blog/sentiment-analysis-python-textblob-vs-vader-vs-flair

情感分析是最广为人知的自然语言处理(NLP)任务之一。这篇文章的目的是让读者对情感分析有一个非常清晰的理解，以及在 NLP 中实现情感分析的不同方法。所以让我们开始吧。

在过去的五年里，自然语言处理领域有了很大的发展，像 Spacy、TextBlob 等开源包。为 NLP 提供随时可用的功能，如情感分析。有这么多免费的软件包，让你不知道该为你的应用程序使用哪一个。

在本文中，我将讨论最流行的 NLP 情感分析包:

最后，我还将在一个公共数据集上比较它们各自的性能。

什么是情感分析？

情感分析是确定自然语言中给定表达的情感值的任务。

它本质上是一个多类文本分类文本，其中给定的输入文本被分类为积极、中性或消极情绪。类别的数量可以根据训练数据集的性质而变化。

比如有时候会公式化为 1 为正面情感，0 为负面情感标签的二元分类问题。

情感分析的应用

情感分析在很多领域都有应用，包括分析用户评论、推特情感等。让我们来看看其中的一些:

电影评论:分析在线电影评论，以获得观众对电影的见解。

新闻舆情分析:针对特定机构分析新闻舆情，获取洞察。
社交媒体情绪分析:分析脸书帖子、twitter 推文等的情绪。
在线美食评论:从用户反馈中分析美食评论的情感。
python 中的情感分析

python 中有许多可用的包，它们使用不同的方法来进行情感分析。在下一节中，我们将介绍一些最流行的方法和软件包。

基于规则的情感分析

基于规则的情感分析是计算文本情感的基本方法之一。这种方法只需要很少的前期工作，而且思想非常简单，不需要使用任何机器学习来理解文本情感。例如，我们可以通过计算用户在他/她的推文中使用“悲伤”这个词的次数来计算出一个句子的情感。

现在，让我们看看一些使用这种方法的 python 包。

文本块

这是一个简单的 python 库，提供了对不同 NLP 任务的 API 访问，如情感分析、拼写纠正等。

Textblob 情感分析器返回给定输入句子的两个属性:

极性是介于[-1，1]之间的浮点数，-1 表示消极情绪，+1 表示积极情绪。

主观性也是一个位于[0，1]范围内的浮点数。主观句一般指个人观点、情感或判断。

让我们看看如何使用 Textblob:

Textblob 将忽略它不认识的单词，它将考虑它可以分配极性的单词和短语，并进行平均以获得最终分数。

VADER 情绪

用于情感推理的效价感知词典(VADER) 是另一个流行的基于规则的情感分析器。

from textblob import TextBlob

testimonial = TextBlob("The food was great!")
print(testimonial.sentiment)

 Sentiment(polarity=1.0, subjectivity=0.75)

它使用一系列词汇特征(例如单词)来计算文本情感，这些词汇特征根据它们的语义取向被标记为正面或负面。

Vader 情感返回给定输入句子被

积极、消极和中立。

例如:

“食物棒极了！”
阳性:99%
阴性:1%
中性:0%

这三个概率加起来是 100%。

让我们看看如何使用 VADER:

Vader 针对社交媒体数据进行了优化，当与来自 twitter、facebook 等的数据一起使用时，可以产生良好的结果。

基于规则的情感分析方法的主要缺点是，该方法只关心单个单词，而完全忽略了使用它的上下文。

例如，“the party wave”在被任何基于令牌的算法考虑时都将是否定的。

嵌入型模型

from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
analyzer = SentimentIntensityAnalyzer()
sentence = "The food was great!"
vs = analyzer.polarity_scores(sentence)
print("{:-<65} {}".format(sentence, str(vs)))

{'compound': 0.6588, 'neg': 0.0, 'neu': 0.406, 'pos': 0.594}

文本嵌入是 NLP 中单词表示的一种形式，其中同义词相似的单词使用相似的向量来表示，当在 n 维空间中表示时，这些向量将彼此接近。

基于嵌入的 python 包使用这种形式的文本表示来预测文本情感。这导致 NLP 中更好的文本表示，并产生更好的模型性能。

其中一个就是天赋。

天赋

Flair 是一个简单易用的 NLP 框架。

它提供了各种功能，例如:

预先训练的情感分析模型，

文本嵌入，

NER，

还有更多。

让我们看看如何使用 flair 非常简单有效地进行情感分析。

Flair 预训练情感分析模型在 IMDB 数据集上进行训练。要加载并使用它进行预测，只需:

如果您喜欢为您的领域定制一个情感分析器，可以使用 flair 使用您的数据集训练一个分类器。
使用 flair 预训练模型进行情感分析的缺点是，它是在 IMDB 数据上训练的，并且该模型可能不会很好地概括来自 twitter 等其他领域的数据。
从头开始构建情感分析模型

在本节中，您将学习何时以及如何使用 TensorFlow 从头开始构建情感分析模型。所以，我们来检查一下怎么做。

from flair.models import TextClassifier
from flair.data import Sentence

classifier = TextClassifier.load('en-sentiment')
sentence = Sentence('The food was great!')
classifier.predict(sentence)

print('Sentence above is: ', sentence.labels)

[POSITIVE (0.9961)

为什么要定制型号？

我们先来了解一下你什么时候会需要一个定制的情绪分析模型。例如，您有一个利基应用程序，如分析航空公司评论的情绪。

通过构建自定义模型，您还可以对输出进行更多的控制。

TFhub

TensorFlow Hub 是一个训练有素的机器学习模型库，可随时进行微调，并可部署在任何地方。

出于我们的目的，我们将使用通用语句编码器，它将文本编码为高维向量。您还可以使用任何您喜欢的文本表示模型，如 GloVe、fasttext、word2vec 等。

型号

因为我们使用一个通用的句子编码器来矢量化我们的输入文本，所以在模型中不需要嵌入层。如果你计划使用任何其他的嵌入模型，比如 GloVe，请随意关注我之前的帖子来获得一步一步的指导。在这里，我将为我们的目的构建一个简单的模型。

数据集

对于我们的例子，我将使用来自 Kaggle 的 twitter 情感分析数据集。这个数据集包含 140 万条带标签的推文。

你可以从这里下载数据集。

要在 Colab 中运行示例，只需在笔记本提示时上传 Kaggle API 密钥，它就会自动为您下载数据集。

示例:使用 Python 进行 Twitter 情感分析

这是 Colab 笔记本的链接。

举例:用 Python 进行 Twitter 情感分析。

在同一个笔记本里，我实现了我们上面讨论的所有算法。

比较结果

现在，让我们比较笔记本上的结果。

你可以看到我们的定制模型没有任何超参数调整产生最好的结果。

我只在 Twitter 数据上训练了使用模型，其他的都是现成的。

你可以看到上面的包没有一个能很好地概括 twitter 数据，我一直在做一个很酷的开源项目来开发一个专门针对 twitter 数据的包，这个项目正在积极开发中。

请随意查看我在 GitHub 上的项目。

最后的想法

在本文中，我讨论了情感分析以及用 python 实现它的不同方法。

我还在一个公共数据集上比较了它们的性能。

希望你会发现它们在你的一些项目中有用。

You can see that our custom model without any hyperparameter tuning yields the best results.

I have only trained the Use model on the Twitter data, the other ones come out-of-the-box.

You can see that none of the above packages are generalizing well on twitter data, I have been working on a cool open source project to develop a package especially for twitter data and this is under active contribution.

Feel free to check out my project on GitHub.

Final thoughts

In this article, I discussed sentiment analysis and different approaches to implement it in python.

I also compared their performance on a common dataset.

Hopefully, you will find them useful in some of your projects.

我们筹集了 800 万美元的 A 轮融资，继续建立“运转良好”的实验跟踪和模型注册

原文：https://web.archive.org/web/https://neptune.ai/blog/series-a-announcement

当我在 2016 年从软件工程来到机器学习领域时，我对杂乱的实验实践、对模型构建的缺乏控制以及帮助人们自信地交付模型的工具生态系统的缺失感到惊讶。

这与软件开发生态系统形成了鲜明的对比，在软件开发生态系统中，您拥有成熟的开发、可观察性或编排工具，可以在生产中高效地执行。

看到这一点，我和几个朋友在 2017 年创办了 Neptune.ai，让 ML 从业者在开发和部署模型时拥有与软件开发人员在发布应用程序时相同的信心。

从那时起，情况发生了很大变化:

变形金刚和 GPT 3 被创造出来，
Pytorch 成为了标准，
Theano 被弃用，然后又回来了，
“MLOps”这个词被创造出来，然后开始流行。

最重要的是，ML 社区意识到在笔记本上构建 POC 模型并不是最终目标。

今天，大大小小的公司都在生产中部署和运行这些模型。我们还没有达到“自信地开发和部署模型”的阶段，但是作为一个社区，我们已经取得了巨大的进步。

说到进展，我真的很高兴与大家分享我们刚刚筹集了 800 万美元的 A 轮融资，以继续建设 Neptune.ai 。

Almaz Capital 领投了这一轮，我们现有的投资者也参与了进来:btov Partners、Rheingau Founders 和 TDJ·皮坦戈。

在过去的几年里，我们已经走了这么长的路。今天我们有:

成千上万的用户，
数百个付费团队，
像 CB Insights 这样的地方将我们列为“2021 年 100 强人工智能初创公司”。

作为一名波兰工程师，只有一种方式来表达我的感受:不错。

我非常感激:

感谢所有用户和客户的宝贵反馈和支持，
团队每天都尽最大努力，
投资者相信我们的愿景。

虽然 MLOps 领域的大多数公司都试图走得更远，成为解决机器学习团队所有问题的平台，但我们希望走得更远，成为实验跟踪和模型注册的最佳工具。

我们希望“仅仅”很好地解决 MLOps 堆栈的这一部分。

为什么只有一个？

在更成熟的软件开发领域，几乎没有端到端的平台。那么，为什么更复杂的机器学习会有所不同呢？

我相信，通过专注于为实验跟踪和模型注册提供出色的开发人员体验，我们可以成为团队构建 MLOps 工具堆栈的支柱之一。

为了实现这一点，我们将在开发人员体验方面投入 800 万美元中的很大一部分。期望:

为特定 ML 用例构建的更多功能，
更具响应性的 UI 和 API，
改进了我们网络用户界面的 UX，
与 MLOps 生态系统中的工具进行更多集成，
通过网页挂钩和通知进行互动的新方式，
更好的文档，
对特征循环的更快反馈。

但最重要的是，我们将继续让实验跟踪和模型注册为世界各地的 ML 团队“工作”。

如果您有兴趣加入我们，试用该工具，或分享反馈，我希望收到您的来信:

工作:我们正在招聘工程、开发和成长类的职位
如果你还没有，试试 neptune 吧
请求演示:我们将为您的使用案例创建一个定制演示
分享反馈:告诉我们你的想法

熊彼得

CEO 兼创始人@neptune.ai

阅读下一篇

Hypefactors 案例研究:不总是运行实验的团队的元数据管理

7 分钟阅读| 2021 年 10 月 25 日更新

Hypefactors 是一家从事媒体情报和声誉跟踪领域的技术公司。它们提供了一个基于 ML 的公共关系(PR)自动化平台，包括支持 PR 工作流和可视化结果的所有工具。

我们采访了 Hypefactors 的首席技术官 Viet Yen Nguyen，他领导着技术团队，负责公司的技术方面。他对这项业务的解释是:

“苹果公司价值约 2 万亿美元，但如果你去他们的仓库、商店，把他们所有的东西加起来，你不会得到 2 万亿美元。你可能会得到价值 600 亿美元的实物商品。

那么反映在股票价格上的 1.94 万亿的价值在哪里呢？是未来的前景，是品牌的潜力，是声誉，是无形的东西。

我们帮助团队实际测量和跟踪它。”

这个项目是关于什么的？

Hypefactors 的数据管道监控从社交媒体管道到印刷媒体、电视、广播等整个媒体领域，以分析客户品牌声誉的变化。这一壮举分两个阶段实现:

从各处获取数据
2 用基于 ML 的特征丰富数据

为了分析图像、文本和表格等各种形式的数据，他们研究了各种各样的 ML 问题:

NLP 分类
计算机视觉(例如分割)
业务指标的回归

当他们使用不同的 ML 技术训练和改进许多丰富模型时，这自然包括运行许多实验和阐明存储由这些实验生成的元数据的方法。

在数据和人工智能团队中有称职的工程师，Viet 的团队能够在管道中的所有组件上取得良好的结果，除了实验跟踪。让我们来窥视一下他们在这个过程中所面临的问题，以及他们采取了哪些措施来解决这些问题。

Continue reading ->

用 Docker 服务机器学习模型:你应该避免的 5 个错误

原文：https://web.archive.org/web/https://neptune.ai/blog/serving-ml-models-with-docker-mistakes

正如您已经知道的， Docker 是一个工具，它允许您使用容器来创建和部署隔离的环境，以便运行您的应用程序及其依赖项。既然这样，在进入主题之前，让我们简单回顾一下 Docker 的一些基本概念。

数据科学家为什么要容器化 ML 模型？

你是否曾经训练过一个机器学习模型，然后决定与同事分享你的代码，但后来发现你的代码不断出错，尽管它在你的笔记本电脑上工作得很好。大多数情况下，这可能是包兼容性问题或环境问题。解决这个问题的好办法是使用容器。

Why should data scientists containerize ML models?

Source: Author

集装箱优惠:

再现性——通过将你的机器学习模型容器化，你可以将你的代码运送到任何其他安装了 Docker 的系统，并期望你的应用程序能给你类似于你在本地测试时的结果。

** 协作开发–容器化的机器学习模型允许团队成员协作，这也使得版本控制更加容易。

使用 Docker 服务于您的机器学习模型

既然你知道为什么你需要容器化你的机器学习模型，接下来的事情就是理解你如何容器化你的模型。

一些您可能已经知道并在本文中遇到的与 Docker 相关的术语:

Dockerfile :你可以把 Dockerfile 想象成一个描述你想要如何设置你想要运行的系统的操作系统安装的文件。它包含了设置 Docker 容器所需的所有代码，从下载 Docker 映像到设置环境。
Docker image :它是一个只读模板，包含创建 Docker 容器的指令列表。
Docker 容器:容器是 Docker 映像的一个可运行实例。

Basic Docker commands

Basic Docker commands | Source: Author

创建 Docker 文件时，可以考虑一些最佳实践，比如在构建 Docker 映像时避免安装不必要的库或包，减少 Docker 文件的层数等等。查看以下文章，了解使用 Docker 的最佳实践。

如何为机器学习模型服务？

模型服务的重要概念是托管机器学习模型(内部或云中)，并通过 API 提供其功能，以便公司可以将人工智能集成到他们的系统中。

通常有两种模型服务:批处理和在线。

批量预测表示模型的输入是大量的数据，通常是预定的操作，预测可以以表格的形式发布。

在线部署需要部署带有端点的模型，以便应用程序可以向模型提交请求，并以最小的延迟获得快速响应。

服务 ML 模型时需要考虑的重要要求

交通管理

根据目标服务的不同，端点上的请求会采用不同的路径。为了同时处理请求，流量管理还可以部署负载平衡功能。

监视

监控在生产中部署的机器学习模型是很重要的。通过监控最大似然模型，我们可以检测模型的性能何时恶化以及何时重新训练模型。没有模型监控，机器学习生命周期是不完整的。

数据预处理

对于实时服务，机器学习模型要求模型的输入具有合适的格式。应该有一个专用的转换服务用于数据预处理。

您可以使用不同的工具来为生产中的机器学习模型提供服务。你可以查看这篇文章，获得关于你可以用于模型服务的不同机器学习工具/平台的全面指导。

使用 Docker 服务机器学习模型时应该避免的错误

现在您已经理解了模型服务的含义以及如何使用 Docker 来服务您的模型。在使用 Docker 为您的机器学习模型提供服务时，知道做什么和不做什么是很重要的。

操作错误是数据科学家在使用 Docker 部署他们的机器学习模型时最常见的错误。这种错误通常会导致应用程序的 ML 服务性能很差。一个 ML 应用程序是通过它的整体服务性能来衡量的——它应该具有低推理延迟、低服务延迟和良好的监控架构。

错误一:用 TensorFlow Serving 和 Docker 服务机器学习模型时使用 REST API 而不是 gRPC

TensorFlow 服务是由 Google 开发人员开发的，它提供了一种更简单的方法来部署您的算法和运行实验。

要了解更多关于如何使用 TensorFlow 服务 Docker 来服务您的 ML 模型，请查看这篇帖子。

当使用 TensorFlow 服务为机器学习模型提供服务时，您需要了解 Tensorflow 服务提供的不同类型的端点以及何时使用它们。

gRPC 和 REST API 端点

gRPC

是由谷歌发明的一种通讯协议。它使用一个协议缓冲区作为它的消息格式，它是高度打包的，对于序列化结构化数据是高效的。借助对负载平衡、跟踪、运行状况检查和身份验证的可插拔支持，它可以高效地连接数据中心内部和数据中心之间的服务。

休息

大多数 web 应用程序使用 REST 作为通信协议。它说明了客户端如何与 web 服务通信。尽管 REST 仍然是客户机和服务器之间交换数据的好方法，但它也有缺点，那就是速度和可伸缩性。

gRPC 和 REST API 的区别

gRPC 和 REST API 在操作方式上有不同的特点。下表比较了两种 API 的不同特征

特性	gRPC	休息

【协议缓冲区】

| |
| | | |

如下图所示，大多数服务 API 请求都是使用 REST 到达的。在使用RESTful API或gRPC API进行预测，将预处理数据发送到 Tensorflow 服务器之前，预处理和后处理步骤在 API 内部进行。

How to use gRPC for model serving

How to use gRPC for model serving | Source: Author

大多数数据科学家经常利用 REST API 进行模型服务，然而，它也有缺点。主要是速度和可伸缩性。你的模型在被输入后做出预测所花费的时间被称为 ML 推理延迟。为了改善应用程序的用户体验，ML 服务快速返回预测是非常重要的。

对于较小的有效载荷，这两种 API 都可以产生类似的性能，同时 AWS Sagemaker 证明，对于图像分类和对象检测等计算机视觉任务，在 Docker 端点中使用 gRPC 可以将整体延迟减少 75%或更多。

使用 gRPC API 和 Docker 部署您的机器学习模型

步骤 1: 确保您的电脑上安装了 Docker

步骤 2: 要使用 Tensorflow 服务，您需要从容器存储库中提取 Tensorflow 服务图像。

docker pull tensorflow/serving

第三步:建立并训练一个简单的模型

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)

第四步:保存模型

保存 TensorFlow 模型时，可以将其保存为协议缓冲文件，通过在 save_format 参数中传递“tf”将模型保存到协议缓冲文件中。

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

可以使用 saved_model_cli 命令对保存的模型进行调查。

!saved_model_cli show --dir {export_path} --all

步骤 5 :使用 gRPC 服务模型

您需要安装 gRPC 库。

Import grpc
from tensorflow_serving.apis import predict_pb2
from tensorflow_serving.apis import prediction_service_pb2_grpc
from tensorboard.compat.proto import types_pb2

您需要使用端口 8500 在客户端和服务器之间建立一个通道。

channel = grpc.insecure_channel('127.0.0.1:8500')
stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)

服务器的请求有效负载需要通过指定模型的名称、存储模型的路径、预期的数据类型以及数据中的记录数来设置为协议缓冲区。

request = predict_pb2.PredictRequest()
request.model_spec.name = 'mnist-model'
request.inputs['flatten_input'].CopyFrom(tf.make_tensor_proto(X_test[0],dtype=types_pb2.DT_FLOAT,  shape=[28,28,1]))

最后，要用 Docker 部署您的模型，您需要运行 Docker 容器。

docker run -p 8500:8500 --mount type=bind,source=<absolute_path>,target=/models/mnist-model/ -e MODEL_NAME=mnist -t tensorflow/serving

现在服务器可以接受客户端请求了。从存根调用 Predict 方法来预测请求的结果。

stub.Predict(request, 10.0)

按照上述步骤，您将能够使用 gRPC API 为 TensorFlow 服务模型提供服务。

错误 2:在使用 Docker 为机器学习模型提供服务时，对数据进行预处理

开发人员在使用 Docker 服务于他们的机器学习模型时犯的另一个错误是在做出预测之前实时预处理他们的数据。在 ML 模型提供预测之前，它期望数据点必须包括在训练算法时使用的所有输入特征。

例如，如果您训练一个线性回归算法来根据房子的大小、位置、年龄、房间数量和朝向来估计房子的价格，则训练好的模型将需要这些要素的值作为推断过程中的输入，以便提供估计的价格。

在大多数情况下，需要对输入数据进行预处理和清理，甚至需要对某些要素进行工程设计。现在想象一下，每次触发模型端点时都要实时地做这件事，这意味着对一些特性进行重复的预处理，尤其是静态特性和高 ML 模型延迟。在这种情况下，特性存储库被证明是一个无价的资源。

什么是功能商店？

功能存储与存储相关，用于跨多个管道分支存储和服务功能，从而实现共享计算和优化。

在 Docker 中为 ml 模型提供服务时使用特征库的重要性

数据科学家可以使用要素存储来简化要素的维护方式，为更高效的流程铺平道路，同时确保要素得到正确存储、记录和测试。
在整个公司的许多项目和研究任务中都使用了相同的功能。数据科学家可以使用要素存储来快速访问他们需要的要素，并避免重复工作。

为机器学习模型提供服务时，为了调用模型进行预测，会实时获取两种类型的输入要素:

静态参考:这些特征值是需要预测的实体的静态或渐变属性。这包括描述性属性，如客户人口统计信息。它还包括客户的购买行为，如他们花了多少钱，多久消费一次等。
实时动态特性:这些特性值是基于实时事件动态捕获和计算的。这些特征通常是在事件流处理管道中实时计算的。

要素服务 API 使要素数据可用于生产中的模型。创建服务 API 时考虑到了对最新特性值的低延迟访问。要更好地理解特性存储，了解可用的不同特性存储，请查看本文:特性存储:数据科学工厂的组件。

错误 3:使用 IP 地址在 Docker 容器之间通信

最后，您已经使用 Docker 部署了您的机器学习模型，并且您的应用程序正在生产环境中返回预测，但是由于某些原因，您需要对容器进行更新。在进行必要的更改并重启容器化的应用程序后，您会不断地得到 “错误:连接失败”。

您的应用程序无法建立到数据库的连接，即使它以前工作得非常好。每个容器都有自己的内部 IP 地址，该地址在容器重新启动时会发生变化。数据科学家犯的错误是使用 Docker 的默认网络驱动程序 bridge 在容器之间进行通信。同一桥接网络中的所有容器可以通过 IP 地址相互通信。因为 IP 地址会波动，这显然不是最好的方法。

不使用 IP 地址，如何在 Docker 容器之间进行通信？

为了与容器通信，您应该使用环境变量来传递主机名，而不是 IP 地址。您可以通过创建用户定义的桥接网络来实现这一点。

How to create a user-defined bridge network

How to create a user-defined bridge network | Source

您需要创建自己的自定义桥接网络。您可以通过运行 Docker network create 命令来实现这一点。这里我们创建一个名为“虚拟网络”的网络。

Docker network create dummy-network

用 docker run 命令正常运行你的容器。使用—网络选项 将其添加到您自定义的桥接网络中。您还可以使用–name 选项添加别名。

docker run --rm --net dummy-network --name tulipnginx -d nginx

将另一个容器连接到您创建的自定义桥接网络。

docker run --net dummy-network -it busybox

现在，您可以使用容器主机名连接到任何容器，只要它们在同一个自定义桥接网络上，而不用担心重启。

错误 4:作为根用户运行您的流程

许多数据科学家在作为根用户运行他们的流程时犯了这样的错误，我将解释为什么这是错误的，并推荐解决方案。在设计系统时，坚持最小特权原则是很重要的。这意味着应用程序应该只能访问完成任务所需的资源。授予进程执行所需的最少特权是保护自己免受任何意外入侵的最佳策略之一。

因为大多数容器化的流程是应用程序服务，所以它们不需要 root 访问。容器不需要 root 才能运行，但是 Docker 需要。编写良好、安全且可重用的 Docker 映像不应该以 root 用户身份运行，而应该提供一种可预测且简单的方法来限制访问。

默认情况下当你运行你的容器时，它假定根用户。我也犯过这样的错误，总是以 root 用户身份运行我的进程，或者总是使用 sudo 来完成工作。但是我了解到，拥有不必要的权限会导致灾难性的问题。

让我通过一个例子来说明这一点。这是我过去用于一个项目的 docker 文件样本。

FROM tiangolo/uvicorn-gunicorn:python3.9

RUN mkdir /fastapi

WORKDIR /fastapi

COPY requirements.txt /fastapi

RUN pip install -r /fastapi/requirements.txt

COPY . /fastapi

EXPOSE 8000

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

第一件事是构建一个 Docker 映像并运行 Docker 容器，您可以用这个命令来完成

docker build -t getting-started .

docker run -d p 8000:8000 getting-started

接下来是获取 containerID，你可以通过用 docker ps 检查你的 Docker 容器进程来做到这一点，然后你可以运行 whoami 命令来查看哪个用户可以访问容器。

Running your processes as root users

Source: Author

如果应用程序存在漏洞，攻击者就可以获得容器的超级用户访问权限。用户在容器中拥有 root 权限，可以做任何他们想做的事情。攻击者不仅可以利用这一点来干扰程序，还可以安装额外的工具来转到其他设备或容器。

如何以非根用户身份运行 Docker

使用 dockerfile 文件:


FROM debian:stretch

RUN useradd -u 1099 user-tesla

USER user-tesla

作为一个容器用户，对改变用户的支持程度取决于容器维护者。使用-user 参数，Docker 允许您更改用户(或 docker-compose.yml 中的用户密钥)。应将进程更改到的用户的用户 id 作为参数提供。这限制了任何不必要的访问。

错误 5:用 Docker 服务 ML 模型时没有监控模型版本

数据科学家犯的一个操作错误是，在将 ML 系统部署到生产环境之前，没有跟踪对其进行的更改或更新。模型版本化帮助 ML 工程师了解模型中发生了什么变化，研究人员更新了哪些特性，以及特性是如何变化的。了解进行了哪些更改，以及在集成多个功能时，这些更改如何影响部署的速度和简易性。

模型版本化的优势

模型版本控制有助于跟踪您先前已经部署到生产环境中的不同模型文件，通过这样做，您可以实现:

模型谱系可追溯性:如果最近部署的模型在生产中表现不佳，您可以重新部署表现更好的模型的先前版本。
模型注册表:像 Neptune AI 和 MLFlow 这样的工具可以作为模型注册表，方便你记录它们的模型文件。每当您需要服务的模型时，您可以获取模型和特定的版本。

使用 Neptune.ai 进行模型版本控制并使用 Docker 进行部署

Neptune.ai 允许您跟踪您的实验，超参数值，用于特定实验运行的数据集，以及模型工件。Neptune.ai 提供了一个 python SDK，您可以在构建机器学习模型时使用它。

第一步是确保您已经安装了 neptune python 客户端。根据您的操作系统，打开您的终端并运行以下命令:

pip install neptune-client

在训练好你的模型之后，你可以在 Neptune 中注册它来追踪任何相关的元数据。首先，需要初始化一个 Neptune 模型对象。模型对象适用于保存在训练过程中由所有模型版本共享的通用元数据。

import neptune.new as neptune
model = neptune.init_model(project='<project name>’',
    name="<MODEL_NAME>",
    key="<MODEL>",
    api_token="<token>"
)

这将生成一个到 Neptune 仪表板的 URL，在这里您可以看到您已经创建的不同模型。查看工作区。

ML model logged in Neptune.ai | Source

为了在 Neptune 中创建模型版本，您需要在同一个 Neptune 项目中注册您的模型，并且您可以在仪表板上的 models 选项卡下找到您的模型。

要在 Neptune 上创建模型版本，您需要运行以下命令:

import neptune.new as neptune
model_version = neptune.init_model_version(
    model="MODEL_ID",
)

下一件事是存储任何相关的模型元数据和工件，您可以通过将它们分配给您创建的模型对象来完成。要了解如何记录模型元数据，请查看这个文档页面。

Different versions of the model are visible in the Neptune’s UI | Source

现在您可以看到您已经创建的模型的不同版本，每个模型版本的相关元数据，以及模型度量。您还可以管理每个模型版本的模型阶段。从上图来看， DOC-MODEL-1 已经部署到生产中。这样，您可以看到当前部署到生产环境中的模型版本以及该模型的相关元数据。

在构建您的机器学习模型时，您不应该将关联的元数据(如超参数、注释和配置数据)作为文件存储在 Docker 容器中。当容器被停止、销毁和替换时，您可能会丢失容器中的所有相关数据。使用 Neptune-client，您可以记录和存储每次运行的所有相关元数据。

在 Docker 与 Neptune 一起服务时如何监控模型版本

因为 Neptune 通过创建模型、创建模型版本和管理模型阶段转换来管理您的数据，所以您可以使用 Neptune 作为模型注册表来查询和下载您存储的模型。

创建一个新脚本来提供和导入必要的依赖项。您所需要做的就是指定您需要在生产中使用的模型版本。您可以通过将您的 NEPTUNE_API_TOKEN 和您的 MODEL_VERSION 作为 Docker 环境变量来运行您的 Docker 容器:

import neptune.new as neptune
import pickle,requests

api_token = os.environ['NEPTUNE_API_TOKEN']
model_version = os.environ['MODEL_VERSION']

def load_pickle(fp):

   """
   Load pickle file(data, model or pipeline object).
   Parameters:
       fp: the file path of the pickle files.

   Returns:
       Loaded pickle file
   """
   with open(fp, 'rb') as f:
       return pickle.load(f)

def predict(data):

   input_data = requests.get(data)

   model_version = neptune.init_model_version(project='docker-demo',
   version=model_version,
   api_token=api_token
   )
   model_version['classifier']['pickled_model'].download()
   model = load_pickle('xgb-model.pkl')
   predictions = model.predict(data)
   return predictions

通过创建 Docker 文件并提供 requirements.txt 文件上的依赖项列表，可以使用 Docker 将机器学习模型服务容器化。

neptune-client
sklearn==1.0.2

FROM python:3.8-slim-buster

RUN apt-get update
RUN apt-get -y install gcc

COPY requirements.txt requirements.txt
RUN pip3 install -r requirements.txt

COPY . .
CMD [ "python3", "-W ignore" ,"src/serving.py"]

要从上面的 Docker 文件构建 Docker 映像，您需要运行以下命令:

docker build --tag <image-name> . 

docker run -e NEPTUNE_API_TOKEN="<YOUR_API_TOKEN>"  -e MODEL_VERSION =”<YOUR_MODEL_VERSION>” <image-name>

在 Docker 容器上管理数据有几种替代方法，您可以在开发期间绑定挂载目录。这是调试代码的一个很好的选择。您可以通过运行以下命令来实现这一点:

docker run -it <image-name>:<image-version> -v /home/<user>/my_code:/code

现在，您可以同时调试和执行容器中的代码，所做的更改将反映在主机上。这让我们回到了在容器中使用相同的主机用户 ID 和组 ID 的优势。您所做的所有修改都将显示为来自主机用户。

要启动 Docker 容器，您需要运行以下命令:

docker run -d -e NEPTUNE_API_TOKEN="<YOUR_API_TOKEN>"  -e MODEL_VERSION =”<YOUR_MODEL_VERSION>” <image-name>

-d 选项指定容器应该以守护模式启动。

最后的想法

可再现性和协作开发是数据科学家应该用 Docker 容器部署他们的模型的最重要的原因。 TensorFlow serving 是流行的模型服务工具之一，您可以扩展它来服务其他类型的模型和数据。此外，当使用 TensorFlow 服务机器学习模型时，您需要了解不同的客户端 API，并选择最适合您的用例。

Docker 是在生产中部署和服务模型的好工具。尽管如此，找出许多数据科学家犯的错误并避免犯类似的错误是至关重要的。

数据科学家在用 Docker 服务机器学习模型时犯的错误围绕着模型延迟、应用程序安全和监控。模型延迟和模型管理是你的 ML 系统的重要部分。一个好的 ML 应用程序应该在收到请求时返回预测。通过避免这些错误，您应该能够使用 Docker 有效地部署一个工作的 ML 系统。

参考

生产中该不该用 Jupyter 笔记本？

原文：https://web.archive.org/web/https://neptune.ai/blog/should-you-use-jupyter-notebooks-in-production

在过去的几年里，笔记本电脑已经成为数据科学和机器学习、科学研究、基因组学等领域的流行工具。

Jupyter 笔记本已经存在很长时间了。它们在机器学习中被大量使用，主要用于实验和可视化。然而，最近笔记本电脑在生产环境方面取得了进展。

在本文中，我们将讨论 Jupyter 笔记本电脑以及笔记本电脑在生产环境中的使用。

生产是什么意思？

“生产”对不同的人有不同的含义。对我们来说，它意味着一些最终用户正在使用或消费的代码。许多组织在生产中使用笔记本电脑，特别是当他们想要与其他人或非技术用户共享笔记本电脑的功能时。

通常，我们在生产中会看到两种类型的笔记本电脑:

静态报告笔记本
瞧，应用

静态报告笔记本是在造纸厂的帮助下制作的。这是一个以编程方式参数化和执行笔记本的工具。此外，它将笔记本转换为数据工作流工具，线性执行每个单元，而不必打开笔记本界面。它为每次执行生成一份报告，并收集所有笔记本的指标。

通过自动化笔记本执行过程，使用 Jupyter 笔记本作为模板来生成报告变得更加容易。

瞧，这是一个开源的成熟的 Python 仪表盘框架。用户可以将他们的笔记本电脑转换成一个独立的交互式 web 仪表板应用程序。在 Voila 的帮助下，您可以将您的工作作为 web 应用程序进行共享，并将其部署在任何云服务上，这样人们就可以看到并使用仪表板。

生产笔记本也意味着以某种自动化的方式运行笔记本。它们不再是快速迭代或试验的便笺本。您使用这些工具将一些库与一些数据结合在一起，并将其与文本和 markdown 一起呈现，以获得一些最终结果或报告。

生产的需要

笔记本电脑一直是原型开发的好帮手，但近年来，我们已经看到了不同的业务问题和技术挑战。一个突出的挑战是生产分析和实验的需求，另一个挑战是云的快速采用。

多年来，对生产和创建数据产品的需求不断增长。

Jupyter 笔记本是用来做原型和探索的，而不是用来生产的。但是这些年来，生态系统已经成长了。我们现在有一套不同的工具，JupyterLab，插件，新的内核，以及许多其他的。

这些年来的变化得益于:

云上的实验–许多人开始更喜欢使用云进行大型计算和更大的数据集。
开发人员工作流程–许多机器学习团队开始采用软件工程实践，如版本控制、git-flow、容器化等等。
生产分析–如果分析代码是按照最佳实践编写的，那么它应该很容易在生产中重用。

在生产中使用笔记本电脑的利与弊

优点

您可以使用 voilà制作独立的应用程序和仪表盘，并为最终用户提供服务。
Jupyter 笔记本可以被安排为云上的作业。
你可以制作模板化的笔记本，并通过造纸厂执行它们。

缺点

没有正确的代码版本。
由于依赖于状态的执行，再现性可能是一个问题。
单元测试很难。
依赖关系管理不正确。
缓存是一个问题。
没有 CI/CD。

缺点并不是一个巨大的限制，因为有许多方法来处理它们。让我们来谈谈所有这些问题及其解决方案。

生产中的笔记本电脑问题

朱庇特对降价很在行。它使用 base64 进行图像序列化，我们可以使用它的功能，比如代码执行，所有这些都通过一个 web 界面完成。

但是它也有自己的问题:

版本控制和文件大小
模块化和代码重用
隐藏状态
测试/调试

版本控制和文件大小

Jupyter 笔记本，扩展名为。包含 Python 代码的 ipynb 不是 Python 文件。它们基本上是大型 JSON 对象。它们不太适合类似 Git 的工作流。如果我们在变更后提交笔记本，差异会变得很大，很难检查它们或者合并到主分支中。这使得在团队中使用它们具有挑战性。

如果笔记本包括图像和大量的绘图，那么文件大小会大大增加。

解决方案:

这是一个帮助生成不同笔记本视图的工具。
它从笔记本中提取输出，这可以帮助我们更容易地进行解析和比较。

模块化和代码重用

模块化是创建健壮应用程序的最重要的概念之一。

代码模块化很重要。但是对于笔记本来说，我们将大部分代码放入单元格中。在 Python 中重用代码的好方法是通过函数和类。此外，笔记本不允许适当的包装。

解决方案:

我们可以用不重复自己(干)的原则。你应该尽可能地概括和巩固你的代码。例如，函数应该只有一个任务，抽象你的逻辑而不过度工程化。但是，您应该注意创建太多的模块。

隐藏状态

Jupyter 笔记本是一个用于编写和试验代码的界面。但是朱庇特有一个弱点。你看到的并不总是你得到的。

很多人说笔记本有利于再现性。当你从头到尾以线性顺序运行代码时，这是正确的。但是我们也可以以非线性的顺序运行细胞。

Jupyter 按照您执行代码的顺序运行代码。它会记住任务，不管它们是否还在。下图说明了这一点。

左边的小方框代表隐藏状态。这是您已经执行的代码。在下一帧中，我们删除了变量，但它仍然加载在内存中。这可能会导致非常奇怪的情况。

Jupyter notebooks: What you see is not always what you get

解决方案:

如果您的代码行为异常，最好的第一步是重启内核。
用模块化和线性顺序编写代码，这对生产很有好处。

测试/调试

笔记本很难调试和测试，即使它们是线性的。那是因为两个原因。首先，当你在做一个项目，笔记本变得足够大时，有太多的东西需要跟踪(变量、函数等)，很难弄清楚执行流程。

第二个原因是很难进行单元测试，因为我们不能直接将笔记本中定义的功能导入测试模块。有很多方法可以做到，但并不简单。

解决方案:

testbook–一个单元测试框架，它将帮助我们测试笔记本内部的代码。
nbval ，pytest-notebook–nbval 是一个非常棒的可复制笔记本库。它将笔记本电脑存储的输出与笔记本电脑生成的输出进行比较。

对于生产笔记本电脑，我们希望鼓励最佳实践，并希望避免本节中提到的许多陷阱和反模式。

在生产中拥抱笔记本电脑

当你只是在玩和做实验的时候，笔记本是不错的选择。但是，一旦你需要分享你的代码或在生产中部署机器学习系统，笔记本电脑就变得非常具有挑战性。

我们想要一款可测试、可部署、可扩展的生产笔记本。

还有，这些笔记本都是线性执行的笔记本。当我们以自动化方式运行笔记本电脑时，我们是从上到下执行一次。

在进入生产流程之前，以下是需要考虑的事项。

数据:你是怎么得到数据的？

你从哪里得到数据？你使用的是实时数据还是摘录数据？还是连接到数据库并获取数据？或者从 S3 桶或其他数据存储中提取？
数据集是已经准备好了，还是需要准备？

代码:你的代码是如何组织的？

就如何组织代码而言，有很多选择。比如你是把东西记在笔记本里还是导出到标准的 Python 脚本里？
你把你的代码分成模块还是包？或者你只是把它放在一个地方。
你是把 Python 叫做 Jupyter 内核，还是把它转换成标准的 Python 脚本？
你所有的代码都在一个文件里吗？你在使用不同的功能吗？班级？你在做包装吗？

代码在哪里运行？

它是运行在你的个人笔记本电脑上还是服务器上？你会在笔记本上部署 Lambda 这样的服务吗？
你是如何处理你的代码依赖的？你在创造环境吗？使用 Docker 容器？

这些事情很重要。例如，仅仅因为你可以在你的笔记本电脑上运行一些东西并不意味着你应该这样做。你应该总是考虑长远，为可持续性做计划。

此外，如果你更多的是在软件开发方面，考虑容器化，或者仅仅是处理你不同的环境和依赖，这是进入生产的一大步。

输出:你的输出去了哪里？

一旦你运行完你的代码，输出到哪里去了？你想记在笔记本里吗？可以在笔记本里吗？还是要将其导出到不同的文件中？也许你想把它导出到不同的系统？
您如何做出这一决定实际上会影响您的产品代码的工作流。

建议的生产流程

这里有一些模式的建议，它们可能会根据您的需求而有所不同。

数据准备

首先要考虑的是你如何处理你的数据准备工作。您可以用 Python 或您选择的任何其他语言做大量的数据准备，但是当您处理数据库或任何其他数据库中的大量数据时，以原始形式提取所有数据是没有意义的。相反，您可以在生产周期的开始运行 ETL 步骤，最终在数据库端完成繁重的工作。或者，您甚至可以使用完全独立的管道来检索数据。

版本控制和 CI

你可能还想考虑一下版本控制和持续集成。因为我们看到的是生产中的批处理工作流，其中有一些数据，你对这些数据做些什么，然后就有了结果。然后也许你会重复这个过程。这是一个非常简单的过程，你在生产中构建的很多东西远没有那么简单。尤其是当你考虑构建 API 或者提供流媒体服务的时候。在这种情况下，您必须拆分可交付成果。假设您正在训练一个模型，并且您想要按需进行预测。事情变得有点棘手了。您可能需要非常频繁地投入到开发和生产中。

通常在开发和生产之间划分工作并不容易。你可能需要在他们两个之间来来回回。像 Jenkins 或 Travis 这样的工具有助于这些过程。那么开始在代码中构建测试就变得非常重要了。这些是生产流程的一些关键部分。

容器和环境

当你进入生产阶段时，容器和环境也变得非常重要。假设您正在从命令行运行该脚本，但是您可能希望首先将其打包成 docker 容器，或者定义一个 anaconda 环境。只要确保生产工作流将具有所有相同的依赖关系，并且它将在未来更加可靠地运行，特别是如果这是您将长期使用的东西。

如果您计划自动化，您可能希望将您的依赖项与您的脚本打包在一起。

服务和部署

您可以采用不同的方式来部署笔记本电脑。如果你要为 API 构建东西或者在 AWS lambda 这样的无服务器架构上运行它们，它们有自己的一套需求。这意味着当你进入生产过程时，你需要考虑更多的复杂性。

那么，你如何做出这些选择呢？

选择生产流程时需要考虑什么

可靠性:Jupyter 笔记本比几年前更加稳定。尽管如此，如果您没有在生产中正确设置笔记本电脑，它还是会破坏您的代码。例如，如果您没有为每个项目单独启动笔记本服务器，这可能会中断代码的工作流。
可访问性:有许多应用程序和工具可以轻松共享笔记本。但是，在将输出或结果导出到文本文件、数据库、电子表格或保存的图像方面，仍然有更多的灵活性。
可重用性:各种各样的包和模块让我们的生活变得更加简单。复制粘贴的代码很难复制，也很难维护。
可解释性:笔记本使得将文档和结果放在代码旁边变得更加容易。它可以很容易地帮助我们，如果我们在未来看它，我们将知道代码做什么，这对生产是有价值的。
灵活性:你几乎可以用它们完成大部分数据科学工作，但它们并不是每项工作的最佳工具。
敏捷:我们都喜欢笔记本电脑，因为它们让数据科学变得更简单、更快速。将新产品快速投入生产通常是一件大事。

笔记本电脑在生产中的未来

笔记本成为应用:笔记本越来越成为应用。笔记本才是重点，它不仅仅是你获得你正在构建的任何产品的途径。相反，笔记本可能就是产品本身。随着笔记本电脑从开发环境发展到可共享的应用程序，它们本身也成为了最终产品。
数据科学平台:有很多数据科学平台，比如 Anaconda。他们将笔记本电脑作为其工具包的优先选择，帮助并简化部署。
容器的兴起:容器继续扩大其在数据科学生态系统中的地位，因此笔记本电脑正在成为生产部署的更实用工具，即使对于 Lambda 这样的无服务器架构也是如此。
新的 Jupyter 功能: JupyterLab 进一步模糊了生产应用和许多开发工具之间的界限——例如，用扩展代替传统的模块和包。

最后的想法

笔记本在生产中的使用一直是一个有争议的话题。许多人认为 Jupyter 笔记本只是用于实验和原型制作，并认为这是不可否认的事实，但我不完全同意他们的观点。

笔记本是处理数据的绝佳工具，尤其是在利用 papermill、airflow 或 nbdev 等开源工具时。Jupyter 允许我们在生产系统中可靠地执行笔记本。

参考文献

普拉巴特·库马尔·萨胡

机器学习工程师

阅读下一篇

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

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

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

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

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

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

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

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

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

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

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

这就是这篇文章的内容。

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

但是首先…

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

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

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

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

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

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

Continue reading ->

Streamlit 指南:如何构建机器学习应用程序

原文：https://web.archive.org/web/https://neptune.ai/blog/streamlit-guide-machine-learning

构建机器学习应用程序变得越来越容易。有了 Streamlit ，你可以快速轻松地开发机器学习应用。您还可以使用 Streamlit 共享平台，只需点击几下鼠标即可部署您的应用。

使用 Streamlit 开始开发并不需要很长时间，因为您甚至不需要任何前端 web 开发经验。有了 Streamlit，你可以用 Python 编写任何东西。Streamlit 还与您可能知道的数据科学库兼容。

在本文中，我们将了解如何利用 Streamlit 开发您的机器学习应用程序。

细流安装

准备好 Python 环境后，Streamlit 的安装非常简单:

$ pip install streamlit

如果您只是尝试一下，您可以运行 hello world 示例:

$ streamlit hello

在官方回购中还有更大的例子。使用 Streamlit 时，您通常会将其作为“st”导入。

如何运行细流应用程序

假设您已经在一个名为“app.py”的文件中编写了 Streamlit 代码，您可以使用以下命令运行该应用程序:

$ streamlit run app.py

“运行 app.py”将开始在您的本地计算机上运行应用程序，并提供一个链接，您可以使用该链接在网络上访问应用程序。

Streamlit 通过提供小部件使开发 web 应用程序变得容易。让我们来看看其中的一些。

在细流中显示文本

Streamlit 有几个用于显示文本的小部件，例如:

` st.text '显示固定宽度和预格式化的文本
` st.markdown '显示降价文本
` st.latex '显示 latex 格式的数学表达式
“st.write”根据给它的输入有不同的行为。例如:
- 当您将数据框传递给它时，它会将数据框打印为表格
- 当向函数传递函数时，显示有关函数的信息
- 当一个 Keras 模型传递给它时，显示该模型
- st.title以标题格式显示文本
- st.header以页眉格式显示文本
- ` st.code '显示代码

这里有一个例子说明了它们的作用:

import streamlit as st
st.code("st.text()", language='python')
st.text('Neptune AI Blog')
st.code("st.markdown()", language='python')
st.markdown('# This is Heading 1 in Markdown')
st.code("st.title()", language='python')
st.title('This is a title')
st.code("st.header()", language='python')
st.header('Header')
st.code("st.subheader()", language='python')
st.subheader('Sub Header')
st.code("st.latex()", language='python')
st.latex(r'''
...     a + ar + a r^2 + a r^3 + cdots + a r^{n-1} =
...     sum_{k=0}^{n-1} ar^k =
...     a left(frac{1-r^{n}}{1-r}right)
...     ''')
st.code("st.write()", language='python')
st.write('Can display many things')

Streamlit widgets

在细流中显示数据

Streamlit 也可以显示数据。数据可以显示为 JSON、表或数据框。

df = pd.read_csv("data.csv")
st.dataframe(df)
st.table(df)
st.json(json_data)

在细流中显示媒体

Streamlit 还允许您向应用程序添加媒体。您可以添加音频、视频或图像。为此，您可以使用“音频”、“视频”和“图像”小部件。

from PIL import Image
icon = Image.open("icon.png")
image = Image.open("logo.png")
st.image(image)

video_file = open("video.mp4", "rb")
video_bytes = video_file.read()
st.video(video_bytes)

audio_file = open("video.wav", "rb")
audio_bytes = audio_file.read()
st.audio(audio_bytes)

在 Streamlit 中显示代码

使用' with st.echo()'命令显示其后的代码。例如，此代码将显示代码，然后显示数据框:

with st.echo():
    df = pd.read_csv("data.csv")
    st.dataframe(df)

在 Streamlit 中显示进度和状态

构建应用程序时，显示用户进度或某些状态总是一个好习惯。例如，加载大型数据集时，可以显示进度条。您可以在 Streamlit 中使用的一些其他状态和进度小部件包括:

st.spinner()在执行代码块时显示临时消息
st.balloons()显示庆祝气球
st.error()显示错误消息
` st.warning '显示警告信息
` st.info '显示信息性消息
` st.success '显示成功消息
` st.exception '在应用程序中传达一个异常

import time
my_bar = st.progress(0)
for percent_complete in range(100):
    time.sleep(0.1)
    my_bar.progress(percent_complete + 1)
st.spinner()
with st.spinner(text='In progress'):
    time.sleep(5)
    st.success('Done')
st.balloons()
st.error('Error message')
st.warning('Warning message')
st.info('Info message')
st.success('Success message')
e = RuntimeError('This is an exception of type RuntimeError')
st.exception(e)

在细流中显示图表

Streamlit 支持以下库中的可视化:

Streamlit 还提供了几个函数来执行基本的可视化:

折线图的“st.line_chart(data)”
面积图的“st.area_chart(data)”
st.bar_chart(data)显示条形图
st.map(data)用于在地图上绘制数据

细流中的交互式小部件

Streamlit 还有一些小部件，让用户可以与您的应用程序进行交互，例如:

您可以使用选择框让用户在几个选项之间进行选择(比如，允许用户根据某个类别过滤数据)
多选小部件类似于选择框，但允许多重选择
文本区域和文本输入小部件可以用来收集用户输入
日期和时间输入可用于收集时间和日期输入
您还可以让用户使用文件上传器小部件上传文件(当您已经构建了图像分类器或对象检测模型，并且希望用户上传图像并查看结果时，这可能会很方便)

st.button('Click here')
st.checkbox('Check')
st.radio('Radio', [1,2,3])
st.selectbox('Select', [1,2,3])
st.multiselect('Multiple selection', [21,85,53])
st.slider('Slide', min_value=10, max_value=20)
st.select_slider('Slide to select', options=[1,2,3,4])
st.text_input('Enter some text')
st.number_input('Enter a number')
st.text_area('Text area')
st.date_input('Date input')
st.time_input('Time input')
st.file_uploader('File uploader')
st.color_picker('Color Picker')

细流中的缓存

在任何应用程序中，缓存服务器通过确保数据和某些功能在用户需要时可用来改善用户体验。例如，您可以让应用程序缓存数据，以减少获取数据所花费的时间。您还可以缓存返回数据的函数的结果。

@st.cache
def fetch_data():
    df = pd.read_csv("data.csv")
    return df

data = fetch_data()

第一次使用“@st.cache”运行函数时，结果将存储在本地缓存中。如果下次调用函数时，代码、输入参数和函数名称没有改变，Streamlit 将跳过执行并读取缓存的结果。

个性化细流应用

在 Streamlit 中，您可以个性化:

页面的标题
页面的图标
页面布局(居中或宽)
是否最初加载侧边栏

icon = Image.open("icon.png")
st.set_page_config(
    page_title="Data Application",
    page_icon=icon,
    layout="centered",
    initial_sidebar_state="auto",
)

细流配置

Streamlit 在默认配置下运行良好。您可以使用下面的命令检查您当前的配置。

$ streamlit config show

但是，有时您会遇到迫使您添加或更改默认设置的情况。有四种不同的方法。

在全局文件中

在这种情况下` ~/。编辑了适用于 macOS/Linux 的 streamlit/config.toml。在 Windows 中，将为“%userprofile%/”。例如，您可以更改运行 streamlit 的默认端口。


port = 8502

在每个项目的配置文件中

在这种情况下，配置被传递到＄CWD/streamlit/config.toml 文件，其中 CWD 是运行 streamlit 的文件夹。

通过环境变量

这里,“STREAMLIT_*”环境变量通过终端传递:

$ export STREAMLIT_SERVER_PORT=8502

作为命令行上的标志

您也可以在执行 Streamlit“run”命令时使用标志来设置配置。

$ streamlit run app.py --server.port 8502

将可视化库集成到细流

让我们看看如何将 Streamlit 与常见的可视化库结合使用。

在 Streamlit 中使用 Matplotlib 和 Seaborn

在 Streamlit 中使用 Matplotlib 和 Seaborn 时，您唯一要做的事情就是定义一个图形并将其传递给' st.pyplot'。

fig = plt.figure(figsize=(12, 5))
st.pyplot(fig)

在细流中进行 plotly 集成

使用 Plotly 时，您将定义一个图形，并将其传递给' plotly _ chart` Streamlit 函数。

fig = px.scatter(
      ….
    )
    st.plotly_chart(fig)

在 Streamlit 中使用 Vega-Lite

如果您正在使用 Vega-Lite，您将使用“vega_lite_chart”函数，如下所示:

st.vega_lite_chart(
        df,
        {
            "mark": {...},
            "width": width,
            "height": height,
            "encoding": {
                "x": {...},
                "y": {...},
                "size": {...},
                "color": {...},
            },
        },
    )

在细流中使用 altair

使用 Altair 时，您将使用 altair.Chart()'定义一个图表，然后使用 st.altair_chart()'显示它:

chart = (
            alt.Chart(data)
            .mark_bar()
            .encode(x=alt.X(...)
            .properties(...)
            .interactive()
        )
st.altair_chart(chart)

用细流可视化地图

您可以使用' st.map()'在地图上绘制数据。它是“st.pydeck_chart”的包装器，在地图上创建散点图:

map_data = df[["lat", "lon"]]
st.map(map_data)

使用此功能时，您必须使用一个个人地图框令牌。您可以在~/中设置它。streamlit/config.toml:

[mapbox]
token = "YOUR_MAPBOX_TOKEN"

细流组件

您可能会发现 Streamlit 并不正式支持您需要的某种功能。这就是 Streamlit 组件派上用场的地方。这些是社区在 Streamlit 之上构建的一组包。例如，您可以使用 Streamlit embed code 组件来嵌入来自 Github Gist、CodePen snippets、Gitlab snippets 等的代码片段。

from streamlit_embedcode import github_gist
github_gist(gist_url)

Streamlit 还有一个 API，您可以使用它来构建您的组件。

布局您的 Streamlit 应用程序

Streamlit 允许您使用容器和列来布局应用程序。然而，这项功能仍处于测试阶段。正如您将看到的，方法有' beta_ '前缀。一旦这些特性变得稳定，你所要做的就是去掉 beta 前缀。` beta_columns '并排布置容器。

` beta_container '插入一个可用于保存多个元素的不可见容器。您可以使用的另一个函数是“beta_expander ”,它可以生成一个可以展开和折叠的多元素容器。下面是所有这些项目的一个实例。

with left_column:
    st.altair_chart(chart)
with right_column:
    st.altair_chart(chart)
with st.beta_container():
    st.altair_chart(chart)
with st.beta_expander("Some explanation"):
    st.write("This is an explanation of the two graphs..")

认证 Streamlit 应用

目前，Streamlit 中还没有对身份验证的官方支持。但是，有一些变通办法。如果您熟悉 Flask，您可以编写您的身份验证函数并将其编织到 Streamlit 中。

另一种方法是使用这个会话状态要点来添加每个会话状态以简化它。您可以使用“st.empty”小部件来初始化单个元素容器。这很有用，因为一旦用户输入正确的密码，你就可以放弃它，显示你想要的功能。

PASSWORD = config('PASSWORD')
session_state = SessionState.get(username='', password='')
if (session_state.password == PASSWORD):
    your_function()

elif ( session_state.password != PASSWORD):
    password_placeholder = st.empty()
    password = password_placeholder.text_input("Enter Password:", type="password")
    session_state.password = password

    if (password and session_state.password == PASSWORD):
        password_placeholder.empty()
        st.success("Logged in successfully")
        your_function()
    elif(password and session_state.password != PASSWORD):
        st.error("Wrong password")

在细流中上传和处理文件

让我们看看如何在 Streamlit 中上传和处理文件。虽然您可以上传其他文件，如 CSV 文件等，但是这个示例将集中在图像数据上。

使用 Streamlit 构建影像分类应用程序

对于这个示例，让我们使用一个预先训练的 TensorFlow Hub 模型来构建一个应用程序，该应用程序可以根据植物的叶子图像来识别疾病的类型。这是这个应用程序的一个演示。稍后，您将致力于将其投入生产。

对于这个应用程序，您需要以下软件包:

显然是“简化”
[pillow](/web/20221207112623/https://neptune.ai/blog/pil-image-tutorial-for-machine-learning)用于调整用户将要上传的图像的大小
用于显示图像的“matplotlib”
用于加载预训练模型的“tensorflow_hub”
用于扩展图像尺寸的“numpy”

import streamlit as st
from PIL import Image
import matplotlib.pyplot as plt
import tensorflow as tf
import tensorflow_hub as hub
import numpy as np
from tensorflow.keras import preprocessing

该应用程序将有两个主要功能:

主要功能:让用户上传图片
预测功能:对上传的图像进行推理

先说主要功能。如前所述，您可以使用“header”来设置应用程序标题。

在 main 函数中，您使用“st.file_uploader”让用户上传图像。您也可以在文件上传程序中指定可接受的文件类型。上传图像后，枕头上的“图像”被用来打开它。接下来，运行预测函数并显示结果。您可以在结果下方绘制图像。

st.header("Predict if plant is healthy")

def main():
    file_uploaded = st.file_uploader("Choose File", type=["png","jpg","jpeg"])

    if file_uploaded is not None:
        image = Image.open(file_uploaded)
        fig = plt.figure()
        plt.imshow(image)
        plt.axis("off")
        predictions = predict(image)
        st.write(predictions)
        st.pyplot(fig)

现在来看预测函数。在这个函数中，您需要做几件事情:

从 TensorFlow Hub 加载预训练模型
将用户上传的图像调整到所需的大小(此型号需要 300 x 300 的图像)
将图像转换为数组，并将其标准化
在图像维度中包含批量大小(这只是一个图像，因此批量大小为 1)
运行预测并将它们映射到类名

def predict(image):
    classifier_model = "https://tfhub.dev/agripredict/disease-classification/1"
    IMAGE_SHAPE = (300, 300,3)
    model = tf.keras.Sequential([
    hub.KerasLayer(classifier_model,input_shape=IMAGE_SHAPE)])
    test_image = image.resize((300,300))
    test_image = preprocessing.image.img_to_array(test_image)
    test_image = test_image / 255.0
    test_image = np.expand_dims(test_image, axis=0)
    class_names = [
          'Tomato Healthy',
          'Tomato Septoria Leaf Spot',
          'Tomato Bacterial Spot',
          'Tomato Blight',
          'Cabbage Healthy',
          'Tomato Spider Mite',
          'Tomato Leaf Mold',
          'Tomato_Yellow Leaf Curl Virus',
          'Soy_Frogeye_Leaf_Spot',
          'Soy_Downy_Mildew',
          'Maize_Ravi_Corn_Rust',
          'Maize_Healthy',
          'Maize_Grey_Leaf_Spot',
          'Maize_Lethal_Necrosis',
          'Soy_Healthy',
          'Cabbage Black Rot']
    predictions = model.predict(test_image)
    scores = tf.nn.softmax(predictions[0])
    scores = scores.numpy()
    results = {
          'Tomato Healthy':0,
          'Tomato Septoria Leaf Spot':0,
          'Tomato Bacterial Spot':0,
          'Tomato Blight':0,
          'Cabbage Healthy':0,
          'Tomato Spider Mite':0,
          'Tomato Leaf Mold':0,
          'Tomato_Yellow Leaf Curl Virus':0,
          'Soy_Frogeye_Leaf_Spot':0,
          'Soy_Downy_Mildew':0,
          'Maize_Ravi_Corn_Rust':0,
          'Maize_Healthy':0,
          'Maize_Grey_Leaf_Spot':0,
          'Maize_Lethal_Necrosis':0,
          'Soy_Healthy':0,
          'Cabbage Black Rot':0
}

    result = f"{class_names[np.argmax(scores)]} with a { (100 * np.max(scores)).round(2) } percent confidence."
    return result

最后一步是运行主函数。

if __name__ == "__main__":
    main()

点击查看完整示例。

用 Streamlit 开发一个自然语言处理应用

再来看另一个例子:用拥抱脸构建自然语言处理 app。这个应用程序使用“拥抱脸”的“变形金刚”包，所以不要忘记通过“pip”安装它。

您可以使用该软件包执行的一些功能包括:

文本摘要
文本翻译
文本分类
问题回答
命名实体识别

让我们转换一些句子。

您可以从导入本例所需的两个包开始，然后创建一个选择框，让用户选择一个任务。

import streamlit as st
from transformers import pipeline

option = st.selectbox(
    "Select Option",
    [
        "Classify Text",
        "Question Answering",
        "Text Generation",
        "Named Entity Recognition",
        "Summarization",
        "Translation",
    ],
)

运行任何任务都需要在任务的同时初始化“管道”。下面是一个文本分类和问答的例子。为了可读性，其他的都被省略了。

if option == "Classify Text":
    text = st.text_area(label="Enter a text here")
    if text:
        classifier = pipeline("sentiment-analysis")
        answer = classifier(text)
        st.write(answer)
elif option == "Question Answering":
    q_a = pipeline("question-answering")
    context = st.text_area(label="Enter the context")
    question = st.text_area(label="Enter the question")
    if context and question:
        answer = q_a({"question": question, "context": context})
        st.write(answer)

你可以在这里找到完整的拥抱脸示例。

部署细流应用程序

构建应用程序后，您希望将其托管在某个地方，以便用户可以访问它。让我们看看如何托管我们之前开发的植物病害应用程序。有几个选项可以做到这一点:

细流共享

Streamlit 共享是将您的 Streamlit 应用程序投入生产的最简单快捷的方式。有一个警告——它必须在 Github 上公开托管。

如果您的应用程序是公开的，那么这是一个很好的选择。然而，目前，在您可以访问 Streamlit 共享平台之前，您需要请求邀请。

收到邀请后，只需点击一个按钮，即可完成部署您的 Streamlit 应用程序。您只需选择回购，然后单击“部署”。你需要确保你把你的应用程序和你的应用程序在 requirements.txt 文件中的需求一起推送到 Github。

Heroku

要将您的 Streamlit 应用程序部署到 Heroku，您需要三个文件:

告知 Heroku 应用程序类型的 Procfile(在本例中是 Python)
requirement.txt 包含应用程序所需的所有包
包含有关 Streamlit 配置信息的“setup.sh”文件

准备就绪后，您将继续您通常的 Heroku 部署过程。检查该关联回购的部署文件夹，查看上述文件的内容。

细流和海王星 ai

您还可以使用 Streamlit 为您的 Neptune 实验构建自定义可视化。让我们假设您有一个 LightGBM 实验，并且想要可视化运行时间与参数提升类型。当然，您可以根据需要可视化任意多的项目；这只是如何做到这一点的一个例子。

好的，首先，你需要从 Neptune 获取仪表板数据。第一步是用 API 键初始化 Neptune:

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

接下来，定义一个从 Neptune 加载数据的函数。您还可以根据实验的频率来缓存数据。在这种情况下，使用 60 秒，这意味着缓存将在 60 秒后过期。该函数返回一个数据帧，该数据帧随后存储在一个“df”变量中。

@st.cache(ttl=60)
def get_leaderboard_data():
    leaderboard = project.get_leaderboard()
    return leaderboard

df = get_leaderboard_data()

下一步是使用您最喜欢的可视化工具绘制数据框中的列。这里就用 Plotly 吧。

def visualize_leaderboard_data():
    fig = px.pie(
        df,
        hole=0.2,
        values="running_time",
        names="parameter_boosting_type",
        title="Running time vs Parameter boosting type",
        color_discrete_sequence=px.colors.sequential.Blackbody,
    )
    st.plotly_chart(fig)

if __name__ == "__main__":
    visualize_leaderboard_data()

点击查看完整示例。

用细流可视化 neptune 项目进度

有了这些背景知识，让我们看看如何使用 Streamlit 来可视化海王星实验的进展。这个例子将建立在前一个例子的基础上，因为这里仍然需要排行榜数据。

对于这个例子，你需要安装 neptunecontrib。

之后，您可以从排行榜数据框中提取进度信息。为此，您可以使用“neptunecontrib.api.utils”中的“extract_project_progress_info”函数。

def get_progress_data():
    leaderboard = project.get_leaderboard()
    progress_df = extract_project_progress_info(leaderboard,
                                            metric_colname='running_time',
                                            time_colname='created')
    return progress_df

该函数需要您选择的度量列和时间戳格式的时间列。然后，它提取与分析项目进度相关的信息。

这是进度数据帧的视觉效果:

然后，可以使用“neptunecontrib.viz.projects”中的“project_progress”功能来显示进度数据框。

该函数创建一个交互式项目进度探索图。由于它返回一个 Altair 图表，您可以使用“st.altair_chart”在您的 Streamlit 应用程序中显示它。

progress_df = get_progress_data()

def visualize_progress():
    plot = project_progress(progress_df, width=400, heights=[50, 200])
    st.altair_chart(plot)

点击查看完整的示例。

最后的想法

在本文中，我们探讨了如何使用 Streamlit 构建应用程序，并执行了几个示例。为了可读性，完整的例子被省略了，否则这篇文章会太长。

但是，您可以查看本报告中所有完整的示例。由于它们是 Streamlit 应用程序，您可以克隆它们并将其部署到 Streamlit 共享上进行查看。或者，您可以在本地机器上运行它们。

我等不及要看你造的东西了！

其他资源:

从电子表格切换到 Neptune.ai，以及它如何将我的模型构建过程推向下一个层次

原文：https://web.archive.org/web/https://neptune.ai/blog/switching-from-spreadsheets-to-neptune-ai

许多 ML 项目，包括 Kaggle 竞赛，都有类似的工作流程。您从一个带有基准模型的简单管道开始。

接下来，您开始合并改进:添加特性、扩充数据、调整模型……在每次迭代中，您评估您的解决方案并保留改进目标度量的更改。

Iterative improvement process ML

*The figure illustrates the iterative improvement process in ML projects. *
Green lines indicate an improvement, red lines – a decrease in the score.

这个工作流程包括运行大量的实验。随着时间的推移，很难跟踪进展和积极的变化。

你不去想新点子，而是花时间去思考:

“我已经试过这个东西了吗？”,
"上周运行良好的超参数值是多少？"

你最终会多次运行相同的东西。如果你还没有跟踪你的实验，我强烈建议你开始！

在我之前的 Kaggle 项目中，我曾经依赖电子表格进行跟踪。一开始它工作得很好，但是很快我意识到用实验元数据建立和管理电子表格需要大量的额外工作。我厌倦了每次实验后手动填写模型参数和性能值，非常想切换到自动化解决方案。

[Neptune.ai]让我节省了大量时间，并专注于建模决策，这帮助我在 Kaggle 比赛中赢得了三枚奖牌。

这是我发现 Neptune.ai 的时候，这个工具让我节省了很多时间，专注于建模决策，帮助我在 Kaggle 比赛中获得了三枚奖牌。

在这篇文章中，我将分享我从电子表格切换到海王星进行实验跟踪的故事。我将描述电子表格的一些缺点，解释 Neptune 如何帮助解决这些缺点，并给出一些使用 Neptune 进行 Kaggle 的技巧。

电子表格用于实验跟踪有什么问题？

电子表格有很多用途。要跟踪实验，您可以简单地设置一个电子表格，其中包含不同的列，包含管道的相关参数和性能。与队友分享这个电子表格也很容易。

ML experiment tracking with spreadsheets

The figure illustrates ML experiment tracking with spreadsheets.

听起来很棒，对吧？

不幸的是，这有一些问题。

手工作业

做了一段时间后，你会注意到维护一个电子表格开始消耗太多时间。您需要为每个新实验手动填充一行元数据，并为每个新参数添加一列。一旦你的管道变得更加复杂，这种将会失去控制。

也很容易出现错别字，从而导致糟糕的决策。

在一次深度学习竞赛中，我在一次实验中错误地输入了学习率。看着电子表格，我得出结论，高学习率降低了准确性，并继续从事其他工作。直到几天后，我才意识到有一个错别字，糟糕的表现实际上来自于学习率低。基于一个错误的结论，我花了两天时间在错误的方向上投资。

没有实时跟踪

使用电子表格，你需要等到实验完成才能记录性能。

除了每次都要手动完成而感到沮丧之外，这也不允许您比较实验的中间结果，这有助于查看新的运行是否有希望。

当然，您可以在每个时期后登录模型性能，但是为每个实验手动进行需要更多的时间和精力。我从来没有足够的勤奋来定期做这件事，结果花费了一些计算资源。

附件限制

电子表格的另一个问题是它们只支持可以在单元格中输入的文本元数据。

如果您想要附加其他元数据，比如:

模型重量，
源代码，
带有模型预测的图，
输入数据版本？

您需要手动将这些内容存储在电子表格之外的项目文件夹中。

在实践中，在本地机器、Google Colab、Kaggle 笔记本和您的队友可能使用的其他环境之间组织和同步实验输出变得很复杂。将这样的元数据附加到跟踪电子表格看起来很有用，但是很难做到。

从电子表格切换到 Neptune

几个月前，我们的团队正在进行木薯叶疾病竞赛，并使用谷歌电子表格进行实验跟踪。挑战开始一个月后，我们的电子表格已经很混乱了:

有些跑步表现不佳，因为我们中的一个人忘记了登录，并且不再有结果。
带有损失曲线的 pdf 散布在 Google Drive 和 Kaggle 笔记本上。
有些参数可能输入不正确，但是恢复和仔细检查旧的脚本版本太费时间了。

基于我们的电子表格很难做出好的数据驱动型决策。

尽管只剩下四周时间，我们还是决定转到海王星。我惊讶地发现，我们实际上花了很少的力气就设置好了。简而言之，有三个主要步骤:

注册一个 Neptune 帐户并创建一个项目，
在您的环境中安装 neptune 包，
包括流水线中的几行，以便能够记录相关的元数据。

查看文档，了解如何在 Neptune 组织人工智能实验，或者跳转到的示例项目并探索应用程序(不需要注册)。

海王星有什么好的？

Spreadsheets vs Neptune

The figure illustrates ML experiment tracking with Neptune.

更少的手工工作

与电子表格相比，Neptune 的一个关键优势是它为您节省了大量手工工作。使用 Neptune，您可以使用管道中的 API 在代码运行时自动上传和存储元数据。

import neptune.new as neptune

run = neptune.init(project='#', api_token='#') 

config = {
    "batch_size": 64,
    "learning_rate": 0.001,
    "optimizer": "Adam"
    }
run["parameters"] =  config

for epoch in range(100):
    run["train/accuracy"].log(epoch * 0.6)

run["f1_score"] = 0.66

您不必手动将它放入结果表中，并且您也避免了打错字。因为元数据是直接从代码发送到 Neptune 的，所以无论数字有多少位，你都会得到正确的数字。

…在每次实验中登录节省的时间积累得非常快，并带来切实的收益…这给了你一个机会…更好地专注于建模决策。

这听起来可能是一件小事，但是从每次实验中节省下来的时间积累得非常快，并在项目结束时带来切实的收益。这给你一个机会，不要过多考虑实际的跟踪过程，更好地关注建模决策。在某种程度上，这就像雇用一名助理来处理一些无聊(但非常有用)的日志任务，以便您可以更专注于创造性的工作。

实时跟踪

我喜欢 Neptune 的一点是，它允许你进行实时跟踪。如果您使用的是神经网络或梯度增强等模型，这些模型在收敛之前需要进行大量迭代，那么您知道及早查看损失动态对于检测问题和比较模型非常有用。

在电子表格中跟踪中间结果太令人沮丧了。Neptune API 可以在每个时期甚至每个批次之后记录性能，这样您就可以在实验仍在运行时开始比较学习曲线。

…很多 ML 实验的结果都是否定的…用 Neptune dashboard 对比中间的图和前几个性能值，可能就足以意识到你需要停止实验，改变一些东西了。

这证明是非常有用的。正如你所料，许多 ML 实验都有负面结果(抱歉，但你花了几天时间研究的这个伟大想法实际上降低了准确性)。

这完全没问题，因为这就是 ML 的工作方式。

不好的是，您可能需要等待很长时间，直到从您的管道中获得负面信号。用 Neptune dashboard 对比中间的图和前几个性能值，可能就足以意识到你需要停止实验，改变一些东西了。

附加输出

海王星的另一个优势是能够在每次实验中附加几乎任何东西。这确实有助于将模型权重和预测等重要输出保存在一个地方，并且可以从您的实验表中轻松访问它们。

如果您和您的同事在不同的环境中工作并且必须手动上传输出以同步文件，这尤其有用。

我还喜欢将源代码附加到每次运行的能力，以确保您有产生相应结果的笔记本版本。如果您想恢复一些没有提高性能的更改，并想回到以前的最佳版本，这将非常有用。

使用 Neptune 提高 Kaggle 性能的技巧

当在 Kaggle 比赛中工作时，我可以给你一些提示来进一步改善你的跟踪体验。

在 Kaggle 笔记本或 Google Colab 中使用 Neptune

首先， Neptune 对于在使用 GPU/TPU 时有会话时间限制的 Kaggle 笔记本或 Google Colab 中工作非常有帮助。我记不清有多少次，当培训时间只比允许的 9 小时限制多几分钟时，由于笔记本电脑崩溃，我丢失了所有的实验结果！

为了避免这种情况，我强烈建议设置 Neptune，以便在每个时期后存储模型权重和损失度量。这样，即使你的 Kaggle 笔记本超时，你也会有一个检查点上传到 Neptune 服务器来继续你的训练。您还将有机会将您在会话崩溃之前的中间结果与其他实验进行比较，以判断它们的潜力。

用 Kaggle 排行榜分数更新跑步记录

第二，Kaggle 项目中需要跟踪的一个重要指标是排行榜分数。有了 Neptune，你可以自动跟踪你的交叉验证分数，但在代码中获取排行榜分数是不可能的，因为它需要你通过 Kaggle 网站提交预测。

将您的实验的排行榜分数添加到 Neptune 跟踪表的最便捷方式是使用“恢复跑步”功能。它允许你用几行代码用一个新的指标更新任何完成的实验。这个特性也有助于恢复跟踪崩溃的会话，我们在上一段中已经讨论过了。

import neptune.new as neptune

run = neptune.init(project=’Your-Kaggle-Project’, run="SUN-123")

run[“LB_score”] = 0.5

model = run["train/model_weights"].download()

下载实验元数据

最后，我知道许多 Kagglers 喜欢对他们的提交进行复杂的分析，比如估计 CV 和 LB 分数之间的相关性，或者绘制最佳分数相对于时间的动态图。

虽然在网站上做这些事情还不可行，但是 Neptune 允许你使用一个简单的 API 调用将所有实验的元数据直接下载到你的笔记本中。这使得更深入地研究结果或导出元数据表并在外部与使用不同跟踪工具或不依赖任何实验跟踪的人共享变得容易。

import neptune.new as neptune

my_project = neptune.get_project('Your-Workspace/Your-Kaggle-Project')

sophia_df = my_project.fetch_runs_table(owner='sophia').to_pandas()
sophia_df.head()

最后的想法

在这篇文章中，我分享了我从电子表格切换到海王星来跟踪 ML 实验的故事，并强调了海王星的一些优势。我想再次强调，在基础设施工具上投入时间——无论是实验跟踪、代码版本控制，还是其他任何东西——总是一个好的决定，并且可能会随着生产力的提高而得到回报。

用电子表格跟踪实验元数据比不做任何跟踪要好得多。它将帮助您更好地看到您的进展，了解哪些修改改进了您的解决方案，并帮助您做出建模决策。用电子表格做同样会花费你额外的时间和精力。像 Neptune 这样的工具将实验跟踪提升到了一个新的水平，允许您自动记录元数据并专注于建模决策。

希望你觉得我的故事有用。祝你未来的 ML 项目好运！

表格数据二进制分类:来自 5 个 Kaggle 竞赛的所有提示和技巧

原文：https://web.archive.org/web/https://neptune.ai/blog/tabular-data-binary-classification-tips-and-tricks-from-5-kaggle-competitions

在本文中，我将讨论一些提高结构化数据二进制分类模型性能的技巧和诀窍。这些技巧是从 Kaggle 的一些顶级表格数据竞赛的解决方案中获得的。没有太多的延迟，让我们开始吧。

为了创作这篇文章，我经历了五场竞赛:

处理更大的数据集

你在任何机器学习竞赛中可能面临的一个问题是数据集的大小。如果您的数据量很大，对于 kaggle 内核和更基本的笔记本电脑来说是 3GB +,您会发现在有限的资源下很难加载和处理。这里是我发现在这种情况下有用的一些文章和内核的链接。

数据探索

数据探索总是有助于更好地理解数据并从中获得洞察力。在开始开发机器学习模型之前，顶级竞争对手总是会针对数据阅读/做大量探索性的数据分析。这有助于特征工程和数据清理。

数据准备

数据探索之后，首先要做的就是用那些洞察去准备数据。解决诸如类别不平衡、分类数据编码等问题。让我们看看用来做这件事的方法。

特征工程

接下来，您可以查看这些顶级 kaggle 比赛中使用的最受欢迎的功能和功能工程技术。特征工程部分因领域的不同而不同。

特征选择

根据数据生成许多要素后，您需要决定在模型中使用哪些要素，以获得模型的最大性能。这一步还包括识别每个特征对模型的影响。让我们看看一些最流行的特征选择方法。

建模

在手工制作和选择您的特征之后，您应该选择正确的机器学习算法来进行您的预测。这些是结构化数据分类挑战中一些最常用的 ML 模型的集合。

超参数调谐

估价

选择一个合适的验证策略是非常重要的，以避免模型在私有测试集中的巨大变动或不良性能。

传统的 80:20 分割在很多情况下并不适用。在大多数情况下，交叉验证比传统的单一训练验证分割更有效，以评估模型性能。

k 折叠交叉验证有不同的变体，如应相应选择的 k 折叠组。

其他训练技巧

全体

如果你在竞争环境中，没有集合，你就不会在排行榜上名列前茅。选择合适的组装/堆叠方法对于充分发挥模型的性能非常重要。

让我们来看看一些在 kaggle 比赛中使用的流行组合技术:

最后的想法

在本文中，您看到了许多流行且有效的方法来提高表格数据二进制分类模型的性能。希望你会发现它们对你的项目有用。

沙胡尔 ES

数据科学家，非常熟悉机器学习、NLP 和音频处理领域。他是 Kaggle 大师，也喜欢做开源。

阅读下一篇

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.

Continue reading ->

深入研究 TensorBoard:示例教程

原文：https://web.archive.org/web/https://neptune.ai/blog/tensorboard-tutorial

有一个常见的商业说法是你不能改进你没有测量的东西。机器学习也是如此。有各种工具可以衡量深度学习模型的性能:Neptune AI、MLflow、Weights and Biases、Guild AI，仅举几个例子。在这篇文章中，我们将重点介绍 TensorFlow 的开源可视化工具包 TensorBoard 。

该工具使您能够跟踪各种指标，如训练集或验证集的准确性和日志丢失。正如我们将在这篇文章中看到的，TensorBoard 提供了几个我们可以在机器学习实验中使用的工具。这个工具也很容易使用。

以下是我们将在本文中涉及的一些内容:

在 TensorBoard 中可视化图像
在张量板上检查模型重量和偏差
可视化模型的架构
将混淆矩阵的图像发送到 TensorBoard
剖析您的应用程序，以便查看其性能，以及
使用张量板与 Keras 、 PyTorch 和 XGBoost

我们开始吧。

如何使用 TensorBoard

本节将重点帮助您了解如何在您的机器学习工作流程中使用 TensorBoard。

如何安装张量板****

在开始使用 TensorBoard 之前，您必须通过 pip 或 conda 安装它

pip install tensorboard
conda install -c conda-forge tensorboard

使用 TensorBoard 搭配 Jupyter 笔记本和 Google Colab

安装 TensorBoard 后，您现在可以将它加载到您的笔记本中。请注意，你可以在 Jupyter 笔记本或谷歌的 Colab 中使用它。

%load_ext tensorboard

一旦完成，你必须设置一个日志目录。这是 TensorBoard 存放所有日志的地方。它将从这些日志中读取数据，以显示各种可视化效果。

log_folder = 'logs'

如果你想重新加载 TensorBoard 扩展，下面的命令将会变魔术——没有双关语。

%reload_ext tensorboard

您可能希望清除当前日志，以便可以将新日志写入该文件夹。你可以通过在 Google Colab 上运行这个命令来实现

!rm -rf /logs/

在 Jupyter 笔记本上

rm -rf logs

如果您正在运行多个实验，您可能想要存储所有日志，以便您可以比较它们的结果。这可以通过创建带有时间戳的日志来实现。为此，请使用下面的命令:

import datetime
log_folder = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")

如何运行 TensorBoard

运行 Tensorboard 只需要一行代码。在本节中，您将看到如何做到这一点。

现在让我们看一个例子，在这个例子中，您将使用 TensorBoard 来可视化模型指标。为此，您需要构建一个简单的图像分类模型。

import tensorflow as tf

mnist = tf.keras.datasets.mnist
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train, X_test = X_train / 255.0, X_test / 255.0

model = tf.keras.models.Sequential([
   tf.keras.layers.Flatten(input_shape=(28, 28)),
   tf.keras.layers.Dense(512, activation='relu'),
   tf.keras.layers.Dropout(0.2),
   tf.keras.layers.Dense(10, activation='softmax')])

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

接下来，加载 TensorBoard 笔记本扩展并创建一个指向日志文件夹的变量。

%load_ext tensorboard
log_folder = 'logs'

如何使用 TensorBoard 回调

下一步是在模型的拟合方法中指定 TensorBoard 回调。为了做到这一点，你首先要导入 TensorBoard 回调。

该回调负责记录事件，例如激活直方图、 度量概要图、剖析图和训练图可视化图。

from tensorflow.keras.callbacks import TensorBoard

准备就绪后，您现在可以创建 TensorBoard 回调并使用 log_dir 指定日志目录。TensorBoard 回调还接受其他参数:

histogram_freq 是计算模型层的激活和权重直方图的频率。将此项设置为 0 意味着将不计算直方图。为了实现这一点，您必须设置验证数据或验证分割。
write_graph 指示图形是否将在 TensorBoard 中可视化
write_images 设置为 true 时，模型权重在 TensorBoard 中显示为图像
update_freq 决定如何将损失和指标写入 TensorBoard。如果设置为整数，比如 100，则每 100 批记录一次损耗和指标。当设置为批处理时，损失和指标在每次批处理后设置。当设置为纪元时，它们在每个纪元后被写入
profile_batch 决定要评测哪些批次。默认情况下，会分析第二批。例如，您也可以设置为从 5 到 10，以分析批次 5 到 10，即 profile_batch='5，10 '。将 profile_batch 设置为 0 将禁用分析。
embeddings_freq 嵌入层可视化的频率。将此项设置为零意味着嵌入不会被可视化

callbacks = [TensorBoard(log_dir=log_folder,
                         histogram_freq=1,
                         write_graph=True,
                         write_images=True,
                         update_freq='epoch',
                         profile_batch=2,
                         embeddings_freq=1)]

下一项是拟合模型并传入回调。

model.fit(X_train, y_train,
          epochs=10,
          validation_split=0.2,
          callbacks=callbacks)

如何启动冲浪板

如果您通过 pip 安装了 TensorBoard，您可以通过命令行启动它

tensorboard -- logdir=log

在笔记本电脑上，您可以使用以下方式启动它:

%tensorboard -- logdir={log_folder}

TensorBoard 也可通过以下网址通过浏览器获得

http://localhost:6006

远程运行 TensorBoard】

在远程服务器上工作时，可以使用 SSH 隧道将远程服务器的端口转发到本地机器的端口(在本例中是端口 6006)。这看起来是这样的:

ssh -L 6006:127.0.0.1:6006 your_user_name@my_server_ip

有了它，你就可以用正常的方式运行 TensorBoard 了。

请记住，您在 tensorboard 命令中指定的端口(默认为 6006)应该与 ssh 隧道中的端口相同。

tensorboard --logdir=/tmp  --port=6006

注意:如果您使用默认端口 6006，您可以丢弃–port = 6006。您将能够在本地计算机上看到 TensorBoard，但 TensorBoard 实际上是在远程服务器上运行的。

张量板仪表板

现在让我们看看 TensorBoard 上的各个选项卡。

张量板标量

标量选项卡显示了各时期的损耗和指标变化。它可用于跟踪其他标量值，如学习率和训练速度。

张量板图像

这个仪表盘有显示重量的图像。调整滑块显示不同时期的权重。

张量图

此选项卡显示模型的层。您可以使用它来检查模型的架构是否符合预期。

张量板分布

“分布”选项卡显示张量的分布。例如，在下面的密集层中，您可以看到每个时期的权重和偏差分布。

张量板直方图

直方图显示了张量随时间的分布。例如，查看下面的 dense_1，您可以看到偏差在每个时期的分布。

使用 TensorBoard 投影仪

您可以使用 TensorBoard 的投影仪来可视化任何矢量表示，例如文字嵌入和图像。

单词嵌入是捕获它们的语义关系的单词的数字表示。投影仪帮助你看到这些图像。你可以在非活动下拉列表中找到它。

使用 TensorBoard 绘制训练示例

您可以使用 TensorFlow 图像摘要 API 来可视化训练图像。这在处理像这样的图像数据时特别有用。

现在，为图像创建一个新的日志目录，如下所示。

logdir = "logs/train_data/"

下一步是创建一个文件写入器，并将其指向这个目录。

file_writer = tf.summary.create_file_writer(logdir)

在本文开始时(在“如何运行 TensorBoard”一节中)，您指定图像形状为 28 x 28。在将图像写入 TensorBoard 之前对其进行整形时，这是非常重要的信息。您还需要将通道指定为 1，因为图像是灰度的。然后，使用 file_write 将图像写入 TensorBoard。

在本例中，索引为 10 到 30 的图像将被写入 TensorBoard。

import numpy as np

with file_writer.as_default():
    images = np.reshape(X_train[10:30], (-1, 28, 28, 1))
    tf.summary.image("20 Digits", images, max_outputs=25, step=0)

在 TensorBoard 中可视化图像

除了可视化图像张量，您还可以在 TensorBoard 中可视化实际图像。为了说明这一点，您需要使用 Matplotlib 将 MNIST 张量转换为图像。之后，您需要使用' tf.summary.image '在 Tensorboard 中绘制图像。

从清除日志开始，或者您可以使用带有时间戳的日志文件夹。之后，指定日志目录并创建一个“tf.summary.create_file_writer ”,用于将图像写入 TensorBoard

!rm -rf logs

import io
import matplotlib.pyplot as plt

class_names = ['Zero','One','Two','Three','Four','Five','Six','Seven','Eight','Nine']
logdir = "logs/plots/"
file_writer = tf.summary.create_file_writer(logdir)

接下来，创建一个包含图像的网格。在这种情况下，网格将容纳 36 位数字。

def image_grid():
    figure = plt.figure(figsize=(12,8))

    for i in range(36):
        plt.subplot(6, 6, i + 1)
        plt.xlabel(class_names[y_train[i]])
        plt.xticks([])
        plt.yticks([])
        plt.grid(False)
        plt.imshow(X_train[i], cmap=plt.cm.coolwarm)

    return figure

figure = image_grid()

现在将这些数字转换成一个单独的图像，在张量板上可视化。

def plot_to_image(figure):
    buf = io.BytesIO()
    plt.savefig(buf, format='png')
    plt.close(figure)
    buf.seek(0)

    digit = tf.image.decode_png(buf.getvalue(), channels=4)
    digit = tf.expand_dims(digit, 0)

    return digit

下一步是使用 writer 和‘plot _ to _ image’在 TensorBoard 上显示图像。

with file_writer.as_default():
    tf.summary.image("MNIST Digits", plot_to_image(figure), step=0)

%tensorboard -- logdir logs/plots

将混淆矩阵记录到张量板上

使用相同的示例，您可以记录所有时期的混淆矩阵。首先，定义一个函数，该函数将返回一个 Matplotlib 图，其中保存着混淆矩阵。

import itertools

def plot_confusion_matrix(cm, class_names):
    figure = plt.figure(figsize=(8, 8))
    plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Accent)
    plt.title("Confusion matrix")
    plt.colorbar()
    tick_marks = np.arange(len(class_names))
    plt.xticks(tick_marks, class_names, rotation=45)
    plt.yticks(tick_marks, class_names)

    cm = np.around(cm.astype('float') / cm.sum(axis=1)[:, np.newaxis], decimals=2)
    threshold = cm.max() / 2.

    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
        color = "white" if cm[i, j] > threshold else "black"
        plt.text(j, i, cm[i, j], horizontalalignment="center", color=color)

    plt.tight_layout()
    plt.ylabel('True label')
    plt.xlabel('Predicted label')

    return figure

接下来，清除以前的日志，为混淆矩阵定义日志目录，并创建一个写入日志文件夹的 writer 变量。

!rm -rf logs

logdir = "logs"
file_writer_cm = tf.summary.create_file_writer(logdir)

接下来的步骤是创建一个函数，该函数将根据模型进行预测，并将混淆矩阵记录为图像。

之后，使用“文件写入器 cm”将混淆矩阵写入日志目录。

from tensorflow import keras
from sklearn import metrics

def log_confusion_matrix(epoch, logs):
    predictions = model.predict(X_test)
    predictions = np.argmax(predictions, axis=1)

    cm = metrics.confusion_matrix(y_test, predictions)
    figure = plot_confusion_matrix(cm, class_names=class_names)
    cm_image = plot_to_image(figure)

    with file_writer_cm.as_default():
        tf.summary.image("Confusion Matrix", cm_image, step=epoch)

接下来是 TensorBoard 回调和LambdaCallback的定义。

LambdaCallback将记录每个时期的混淆矩阵。最后使用这两个回调函数来拟合模型。

由于您之前已经拟合了模型，建议您重新启动运行时，并确保只拟合一次模型。

callbacks = [
   TensorBoard(log_dir=log_folder,
               histogram_freq=1,
               write_graph=True,
               write_images=True,
               update_freq='epoch',
               profile_batch=2,
               embeddings_freq=1),
   keras.callbacks.LambdaCallback(on_epoch_end=log_confusion_matrix)
]

model.fit(X_train, y_train,
          epochs=10,
          validation_split=0.2,
          callbacks=callbacks)

现在运行 TensorBoard 并检查图像选项卡上的混淆矩阵。

%tensorboard -- logdir logs

用张量板调整超参数

你可以用 TensorBoard 做的另一件很酷的事情是用它来可视化参数优化。以同一个 MNIST 为例，您可以尝试调整模型的超参数(手动或使用自动超参数优化)并在 TensorBoard 中可视化它们。

这是你期望得到的最终结果。仪表板位于参数选项卡下。

为此，您必须清除以前的日志并导入 hparams 插件。

!rm -rvf logs

logdir = "logs"

from tensorboard.plugins.hparams import api as hp

下一步是定义要调整的参数。在这种情况下，密集层中的单位、辍学率和优化器函数将被调整。

HP_NUM_UNITS = hp.HParam('num_units', hp.Discrete([300, 200,512]))
HP_DROPOUT = hp.HParam('dropout', hp.RealInterval(0.1,0.5))
HP_OPTIMIZER = hp.HParam('optimizer', hp.Discrete(['adam', 'sgd', 'rmsprop']))

接下来，使用 tf.summary.create_file_writer 定义存储日志的文件夹。

METRIC_ACCURACY = 'accuracy'

with tf.summary.create_file_writer('logs/hparam_tuning').as_default():
    hp.hparams_config(
        hparams=[HP_NUM_UNITS, HP_DROPOUT, HP_OPTIMIZER],
        metrics=[hp.Metric(METRIC_ACCURACY, display_name='Accuracy')],)

这样一来，您需要像以前一样定义模型。唯一的区别是，第一个密集层的神经元数量、辍学率和优化器函数不会被硬编码。

这将在稍后运行实验时使用的函数中完成。

def create_model(hparams):
    model = tf.keras.models.Sequential([
        tf.keras.layers.Flatten(input_shape=(28, 28)),
        tf.keras.layers.Dense(hparams[HP_NUM_UNITS],  activation='relu'),
        tf.keras.layers.Dropout(hparams[HP_DROPOUT]),
        tf.keras.layers.Dense(10, activation='softmax')])

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

    model.fit(X_train, y_train, epochs=5)
    loss, accuracy = model.evaluate(X_test, y_test)

    return accuracy

您需要创建的下一个函数将使用前面定义的参数运行上面的函数。然后它会记录精确度。

def experiment(experiment_dir, hparams):

    with tf.summary.create_file_writer(experiment_dir).as_default():
        hp.hparams(hparams)
        accuracy = create_model(hparams)
        tf.summary.scalar(METRIC_ACCURACY, accuracy, step=1)

之后，您需要对上面定义的所有参数组合运行该函数。每个实验都将存储在自己的文件夹中。

experiment_no = 0

for num_units in HP_NUM_UNITS.domain.values:
    for dropout_rate in (HP_DROPOUT.domain.min_value, HP_DROPOUT.domain.max_value):
        for optimizer in HP_OPTIMIZER.domain.values:
            hparams = {
                HP_NUM_UNITS: num_units,
                HP_DROPOUT: dropout_rate,
                HP_OPTIMIZER: optimizer,}

            experiment_name = f'Experiment {experiment_no}'
            print(f'Starting Experiment: {experiment_name}')
            print({h.name: hparams[h] for h in hparams})
            experiment('logs/hparam_tuning/' + experiment_name, hparams)
            experiment_no += 1

最后，运行 TensorBoard 来查看您在本节开始时看到的可视化效果。

%tensorboard -- logdir logs/hparam_tuning

在 HPARAMS 选项卡上，****表格视图显示所有的模型运行及其相应的准确性、丢失率和密集层神经元。平行坐标视图将每次运行显示为一条穿过每个超参数和精度指标轴的直线。

单击其中一个将显示试验和超参数，如下所示。

散点图视图将超参数和指标之间的比较可视化。

TensorFlow Profiler

您还可以使用 分析器 跟踪 TensorFlow 模型的性能。分析对于理解 TensorFlow 操作的硬件资源消耗至关重要。在此之前，您必须安装 profiler 插件。

pip install -U tensorboard-plugin-profile

安装完成后，它将出现在非活动下拉列表中。这是侧写器上众多视觉效果之一的快照。

现在您唯一要做的事情就是定义一个回调，并包含将要分析的批处理。

之后，当你符合模型时，你通过回调。别忘了给 TensorBoard 打电话，这样你就可以看到可视化效果。

callbacks = [tf.keras.callbacks.TensorBoard(log_dir=log_folder,
                                            profile_batch='10,20')]

model.fit(X_train, y_train,
          epochs=10,
          validation_split=0.2,
          callbacks=callbacks)

%tensorboard --logdir=logs

概览页面

档案选项卡上的概览页面显示了该型号性能的高级概览。从下图可以看出，性能总结显示了:

编译内核所花费的时间，
读取数据所花费的时间，
启动内核所花费的时间，
生产产出所花费的时间，
设备上的计算时间，以及
主机计算时间

步进时间图显示了所有已采样步进的器件步进时间。图表上的不同颜色描述了花费时间的不同类别:

红色部分对应于器件在等待输入数据时空闲的步进时间。
绿色的部分显示设备实际工作的时间。

不过，在概览页面上，您可以看到运行时间最长的 TensorFlow 操作。

运行环境显示使用的主机数量、设备类型、设备内核数量等环境信息。在这种情况下，您可以看到在 Colab 的运行时，有一台主机的 GPU 包含一个内核。

从这一页你可以看到的另一件事是优化模型性能的建议。

跟踪查看器

跟踪查看器可用于了解输入管道中的性能瓶颈。它显示了在评测期间 GPU 或 CPU 上发生的不同事件的时间线。

纵轴显示各种事件组，横轴显示事件轨迹。在下图中，我使用了快捷键 w 来放大事件。要缩小，使用键盘快捷键 S 。 A 和 D 可分别用于向左和向右移动。

您可以单击单个事件来进一步分析它。使用浮动工具栏上的光标或使用键盘快捷键 1 。

下图显示了对显示开始和墙壁持续时间的SparseSoftmaxCrossEntropyWithLogits事件(一批数据的损失计算)的分析结果。

您还可以通过按住 Ctrl 键并选择它们来检查各种事件的摘要。

输入管道分析器

输入管道分析器可用于分析模型输入管道中的低效问题。

该功能显示输入流水线分析的摘要、设备端分析细节和主机端分析细节。

输入管道分析总结显示了总输入管道。它是通知应用程序是否被输入绑定以及绑定多少的部分。

器件侧分析细节显示器件步进时间和器件等待输入数据的时间。

主机端分析显示主机端的分析，如主机上输入处理时间的分解。

在输入流水线分析器上，你还可以看到关于单个输入操作、花费的时间及其类别的统计。以下是各列所代表的内容:

输入操作 —输入操作的张量流操作名
Count —分析期间操作执行的实例数
总时间 —在上述每个实例上花费的累计时间总和
总时间% —是花费在操作上的总时间占花费在输入处理上的总时间的百分比
总自我时间 —在每个实例上花费的自我时间的累计总和。
总自我时间% —总自我时间占输入处理总时间的百分比
类别 —输入操作的处理类别

张量流统计

该仪表板显示了在主机上执行的每个 TensorFlow 操作的性能。

第一张 饼状图展示了主机上每个操作自执行时间的分布。
第二个显示主机上每个操作类型的自执行时间分布。
第第三显示设备上每个操作的自执行时间分布。
第四个显示设备上每个操作类型的自执行时间分布。

饼图下方的表格显示了张量流操作。每个行都是一个操作。栏显示了每个操作的各个方面。您可以使用任何列对表进行过滤。

在上表下方，您可以看到按类型分组的各种张量流操作。

GPU 内核统计数据

该页面显示了性能统计数据以及每个 GPU 加速内核的原始操作。

内核统计数据下面是一个表格，其中显示了内核和各种操作花费的时间。

内存配置文件页面

该页面显示了在分析期间内存的利用率。它包含以下几个部分:内存配置文件摘要、内存时间线图和内存细分表。

内存配置文件摘要显示 TensorFlow 应用程序的内存配置文件摘要。
内存时间线图显示了内存使用量(以 gib 为单位)和碎片百分比(以毫秒为单位)与时间的关系图。这
内存细分表显示在性能分析间隔内存使用率最高的点的活动内存分配。

如何在 TensorBoard 上启用调试

您也可以将调试信息转储到您的 TensorBoard。要做到这一点，你必须启用调试——它仍然处于实验模式

tf.debugging.experimental.enable_dump_debug_info(
   logdir,
   tensor_debug_mode="FULL_HEALTH",
   circular_buffer_size=-1)

仪表板可以在调试器 V2 的非活动下拉菜单下查看。

调试器 V2 GUI 有告警、 Python 执行时间线、图形执行、和图形结构。警报部分显示程序的异常情况。Python 执行时间线部分显示了操作和图形的热切执行的历史。

图形执行显示所有在图形中计算过的浮点型张量的历史。图形结构部分包含源代码和堆栈跟踪，它们是在您与 GUI 交互时填充的。

将 TensorBoard 与深度学习框架结合使用

你不局限于单独使用 TensorFlow 的 TensorBoard。您还可以将它与其他框架一起使用，如 Keras、PyTorch 和 XGBoost 等。

py torch 中的张量板

您首先通过定义一个 writer 来指向您想要写入日志的文件夹。

from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter(log_dir='logs')

下一步是使用 summary writer 添加您希望在 TensorBoard 上看到的项目。

from torch.utils.tensorboard import SummaryWriter
import numpy as np

for n_iter in range(100):
    writer.add_scalar('Loss/train', np.random.random(), n_iter)
    writer.add_scalar('Loss/test', np.random.random(), n_iter)
    writer.add_scalar('Accuracy/train', np.random.random(), n_iter)
    writer.add_scalar('Accuracy/test', np.random.random(), n_iter)

喀拉斯的 tensor board

由于 TensorFlow 使用 Keras 作为官方高级 API，TensorBoard 的实现类似于它在 TensorFlow 中的实现。我们已经看到了如何做到这一点:

创建回拨:

from tensorflow.keras.callbacks import TensorBoard

tb_callback = TensorBoard(log_dir=log_folder,...)

将它传递给“model.fit ”:

model.fit(X_train, y_train,
          epochs=10,
          validation_split=0.2,
          callbacks=[tb_callback])

XG boost 中的 tensor board

使用 XGBoost 时，还可以将事件记录到 TensorBoard。为此需要使用 tensorboardX 包。例如，要记录度量和损失，您可以使用“SummaryWriter”和日志标量。

from tensorboardX import SummaryWriter

def TensorBoardCallback():
    writer = SummaryWriter()

    def callback(env):
        for k, v in env.evaluation_result_list:
            writer.add_scalar(k, v, env.iteration)

    return callback

xgb.train(callbacks=[TensorBoardCallback()])

Tensorboard.dev

Tensorboard.dev 是一个托管的 Tensorboard 平台，可以轻松托管、跟踪和共享 ML 实验。它允许人们发布他们的 TensorBoard 实验，排除故障以及与团队成员合作。一旦你有了一个 TensorBoard 实验，把它上传到 TensorBoard.dev 是非常简单的。

tensorboard dev upload --logdir logs
    --name "(optional) My latest experiment"
    --description "(optional) Simple comparison of several      hyperparameters"

一旦你运行这个命令，你会得到一个提示，要求你用谷歌账户授权 TensorBoard.dev。一旦你这样做，你会得到一个验证码，你将进入认证。

这将产生一个独特的张量板。开发链接给你。这里有一个这样的链接的例子。如你所见，这非常类似于在本地主机上查看 TensorBoard，只是现在你是在线查看。

一旦你在这里着陆，你就可以和冲浪板互动，就像你在这个作品的前几部分一样。

需要注意的是，这个 TensorBoard 对互联网上的每个人都是可见的，所以请确保您没有上传任何敏感数据。

使用 TensorBoard 的限制

正如你所看到的，TensorBoard 给了你很多很棒的功能。也就是说，使用 TensorBoard 并非一帆风顺。

它有一些限制:

难以在需要协作的团队环境中使用
没有用户和工作区管理:大型组织通常需要这些功能
您不能执行数据和模型版本化来跟踪各种实验
无法将其扩展到百万次运行；运行太多次，你会开始遇到 UI 问题
用于记录图像的界面有点笨拙
您不能记录和可视化其他数据格式，如音频/视频或自定义 html

最后的想法

这篇文章中有几件事我们没有涉及到。值得一提的两个有趣特性是:

公平指标仪表板(目前处于测试阶段)。它允许计算二进制和多类分类器的公平性度量。
What-If 工具 (WIT)使你能够探索和研究经过训练的机器学习模型。这是使用不需要任何代码的可视化界面来完成的。

希望你在这里学到的一切能帮助你监控和调试你的训练，并最终建立更好的模型！

TensorFlow 对象检测 API:培训、评估和部署的最佳实践

原文：https://web.archive.org/web/https://neptune.ai/blog/tensorflow-object-detection-api-best-practices-to-training-evaluation-deployment

本文是学习 TensorFlow 对象检测及其 API 的端到端工作流系列的第二部分。在第一篇文章中，您学习了如何从头开始创建一个定制的对象检测器，但是仍然有很多事情需要您的注意才能真正精通。

我们将探索与我们已经经历过的模型创建过程同样重要的主题。以下是我们将要回答的一些问题:

如何评估我的模型，并对其性能进行评估？
我可以使用哪些工具来跟踪模型性能并比较多个实验的结果？
如何导出我的模型以在推理模式中使用它？
有没有一种方法可以进一步提升模型性能？

模型评估

很想知道我们的模特在野外会有怎样的表现。为了了解我们的模型在真实数据上的表现，我们需要做一些事情:

选择一组评估指标，

获取单独的数据集来验证和测试您的模型，
使用一组适当的参数启动评估流程。
评估，步骤 1:指标

让我们从一组评估指标开始。你可能还记得在第一篇文章中，我们安装了一个名为 COCO API 的依赖项。

我们需要它来访问一组用于对象检测的有用指标:平均精度和召回率。如果您不记得这些指标，您一定要阅读一下。计算机视觉工程师经常使用它们。

要使用平均精度和召回率，您应该配置 pipeline.config 文件。eval_config块中的metrics_set参数应设置为“coco_detection_metrics”。

这是该参数的默认选项，因此您很可能已经有了它。检查您的eval_config行是否像这样:

To use mean average precision and recall, you should configure your pipeline.config file. The metrics_set parameter in the eval_config block should be set to “coco_detection_metrics”.

当我们使用metrics_set中设置的“coco_detection_metrics”时，以下是可用的内容:

This is a place within the pipeline.config file where we specify metrics we want to use for evaluation

您对这组指标的选择不限于精度和召回率。TensorFlow API 中还有一些其他选项。花点时间选择您想要的选项来跟踪您的特定模型。

Mean average precision

Mean average precision (mAP) shown as a plot after we enable it for model validation. Note that mAP is calculated for different IOU values. Average recall is not shown but also becomes available.

评估，步骤 2:数据集

如果您仔细遵循了第一篇文章中的说明，那么数据集准备应该听起来很熟悉。
作为提醒，我们准备了模型评估需要的两个文件(validation.record 和 test.record)放在 Tensorflow/workspace/data 中。如果您的数据文件夹中的文件数量与下面的相同，那么您就可以开始下一步了！

以防你错过了。将文件记录在您的数据文件夹中，但仍想进行评估，以下是一些需要考虑的事项:

`validation.record`需要在培训期间评估您的模型；

需要使用test.record来检查已经训练过的最终模型的性能。

Tensorflow/
└─ cocoapi/
└─ ...
└─ workspace/
   └─ data/
      ├─ train.record 
      ├─ validation.record 
      ├─ test.record

机器学习的传统方法需要 3 个独立的集合:用于训练、评估和测试。我强烈建议你遵循它，但是如果你有充分的理由避免这些，那么就只准备这些。记录与你的目的相关的文件。

评估，步骤 3:流程启动

如前所述，您可以在两个不同的时间戳进行模型评估:在训练期间或者在模型被训练之后。

培训期间的模型评估称为验证。TensorFlow 对象检测 API 的验证作业被视为一个独立的过程，应与培训作业并行启动。

并行启动时，验证作业将等待训练作业在模型训练过程中生成的检查点，并逐个使用这些检查点在单独的数据集上验证模型。

validation.record表示模型用于验证的独立数据集。eval_confi块中的metrics_set参数定义了一组评估指标。

为了启动验证作业，打开一个新的终端窗口，导航到 Tensorflow/workspace/，并启动以下命令:

其中:

<配置文件的路径> 是用于训练您想要评估的模型的配置文件的路径。应该是来自的配置文件。/models/ <文件夹中放着您选择的车型> /v1/，

<模型目录路径> 是评估作业写入日志(评估结果)的目录路径。我的建议是使用以下路径:。/models/ <文件夹中放着您选择的型号> /v1/。鉴于此，您的评估结果将放在培训日志旁边，

python model_main_tf2.py
  --pipeline_config_path=<path to your config file>
  --model_dir=<path to a directory with your model>
  --checkpoint_dir=<path to a directory with checkpoints>
  --num_workers=<int for the number of workers to use>
  --sample_1_of_n_eval_examples=1

<带有检查点的目录路径> 是您的培训作业写入检查点的目录。也应该是下面的:。/models/ <文件夹中放着您选择的车型> /v1/，

< int 表示要使用的工作线程数量> 如果您有一个多核 CPU，该参数定义了可用于评估作业的内核数量。请记住，您的培训作业已经占用了您为其分配的内核数量。考虑到这一点，适当地设置用于评估的内核数量。
在执行上述命令后，您的评估工作将立即开始。与我们对培训作业所做的类似，如果您想要在 GPU 上进行评估，请在启动评估作业之前通过执行以下命令来启用它:
其中定义了您想要使用的 GPU 的订单编号。请注意，订单计数从零开始。对于 CPU 上的验证，使用-1，如下面的命令所示:
模型性能跟踪

模型性能跟踪简介

export CUDA_VISIBLE_DEVICES= <GPU number>

在机器学习中，对于给定的任务，很难事先告诉你哪个模型会给你最好的结果。开发人员通常使用试错法来测试多个假设。

export CUDA_VISIBLE_DEVICES=-1

您可以检查不同的模型架构，或者坚持使用一种架构，但尝试不同的参数设置。每一个配置都应该通过单独的培训工作启动来测试，因此跟踪和比较多个实验的工具就派上了用场。

TensorFlow API 使用 tfevents 格式写入与模型性能相关的日志和优化器状态。您需要跟踪的 TF 事件主要有两个:与培训相关的和与评估相关的。

培训 tfevent 仅限于损失和学习率跟踪。它记录每个时期的步数，所以你可以看到你的训练工作进行得有多快。

当您为模型启动训练作业时，会自动记录此类实验元数据。日志存储在 tensor flow/workspace/models//v1/train。当使用 Tensorboard (我们马上会谈到)可视化时，它看起来是这样的:

请注意，您可以看到组件级别分解的损失(分别针对分类和本地化)，也可以看到总计值。当您面临一个问题，并且想要检查您的模型以找到问题的根本原因时，它变得特别有用。

如前所述，我们还可以跟踪学习率如何随时间变化，以及你的训练工作每秒完成多少步。

与培训 tfevent 类似，评估 tfevent 也包含一个具有相同细分的损失部分。除此之外，它还跟踪我们在之前谈到的 评估指标。

跟踪工具

Training tf-event

Training tf-event (logs) visualized using Tensorboard

有多种工具可以帮助您跟踪和比较与模型相关的日志。TensorFlow API 中已经内置的是 Tensorboard 。

Tensorboard 比较好用。为了启动您的 TensorBoard，请打开一个终端窗口，导航至 tensor flow/workspace/models/<文件夹，其中包含您选择的型号> /目录。

在那里，使用以下命令启动 Tensorboard:

您可以向–logdir 传递一个文件夹路径，该文件夹包含多个实验的日志(例如:Tensorflow/workspace/models/)。

您还可以通过提供特定实验的日志路径来限制可访问的数据(例如:tensor flow/workspace/models//)。

在任何情况下，Tensorboard 都会自动找到所有包含日志的目录，并使用这些数据来构建绘图。你可以在官方指南中了解更多 Tensorboard 可以做的事情。

Neptune.ai 是一款可供你考虑的替代追踪工具。与 Tensorboard 相比，它提供了更广泛的功能。以下是我发现特别方便的:

Neptune 完全兼容 tfevent (TensorBoard)格式。你所需要做的就是在你的终端窗口中启动一个单命令行，

tensorboard --logdir=<path to a directory with your experiment / experiments>

您可以只导入那些您认为重要的实验。它允许您过滤掉那些您想要从比较中排除的启动。考虑到这一点，您最终的仪表板将保持整洁，不会因为过多的实验而过载，

你的作品(笔记本、实验结果)可以通过一种非常简单的方式与他人分享(只需发送一个链接)，

你可以追踪任何你想追踪的东西。当您还想要跟踪模型参数和/或它的工件时，它变得特别方便。您的硬件利用率也是可见的，所有这些都可以在一个位置获得。

模型导出

好了，你的模型现在已经训练好了，你对它的性能很满意，现在想用它来进行推理。让我告诉你怎么做。这将是一个两步走的过程:
1.第一步–模型导出。为此，您应该:
将导出脚本从 tensor flow/models/research/object _ detection/exporter _ main _ v2 . py
复制粘贴到
tensor flow/workspace/exporter _ main _ v2 . py，
在 Tensorflow/workspace 中，创建一个名为 exported_models 的新文件夹。这将是您放置所有导出模型的地方，

在 tensor flow/workspace/exported _ models 中创建一个子文件夹，用于存储特定的导出模型。将此文件夹命名为您在 tensor flow/workspace/models/中使用的名称，

打开一个新的终端窗口，将 Tensorflow/workspace 作为当前工作目录，启动以下命令:

其中:

<配置文件路径> 是您想要导出的模式的配置文件路径。应该是来自的配置文件。/models/ <文件夹中有您选择的型号> /v1/
<训练模型目录路径> 是训练过程中放置模型检查点的目录路径。也应该是下面的:。/models/ <文件夹中有您选择的型号> /v1/
<导出模型的目录路径> 是保存导出模型的路径。应该是:。/exported_models/ <文件夹中有您选择的车型>

2.第二步——在推理模式下运行您的模型。

python exporter_main_v2.py
  --pipeline_config_path=<path to a config file>
  --trained_checkpoint_dir=<path to a directory with your trained model>
  --output_directory=<path to a directory where to export a model>
  --input_type=image_tensor

为了方便你，我做了一个 jupyter 笔记本，里面有你做推理所需的所有代码。你的目标是检查它，并为 TODO s 填充所有缺失的值

在 jupyter 笔记本中，你会发现两个可以根据你的目标使用的推理函数:inference_with_plot和inference_as_raw_output。
当您只想将模型输出可视化为绘制在输入图像对象上的边界框时，使用inference_with_plot。在这种情况下，函数输出将是如下图所示的图形:
或者，您可以使用inference_as_raw_output而不是绘图，返回一个包含 3 个键的字典:

在detection_classes键下，有一个包含所有被检测到的类的数组。类作为整数返回，

使用detection_scores(数组)查看每个检测类的检测置信度得分。

最后，detection_boxes是一个数组，包含每个检测到的对象的边界框的坐标。每个盒子有以下格式-【y1，x1，y2，x2】。左上角定义为 y1 和 x1 ，而右下角定义为 y2 和 x2 。

模型改进的机会

在这一部分，我想和你分享一些很酷的方法，可以提升你的模型性能。我在这里的目标是向您提供 TensorFlow API 及其武库中可用内容的高级概述。我也会给你一个实现这些方法的直觉。我们开始吧！
图像预处理
你应该知道你给你的模型输入了什么。图像预处理在任何计算机视觉应用中都是至关重要的一步。

TensorFlow 在幕后执行图像标准化步骤(如果您喜欢，也可以称为标准化步骤，标准化和标准化之间的差异在这里有很好的描述),我们不能影响它。但是我们可以控制如何调整图像的大小，以及将其调整到哪个尺寸。
为了更好地理解 TensorFlow API 是如何做到这一点的，让我们来看一下 EfficientDet D-1 模型的 pipeline.config 代码片段:

EfficientDet D-1 负责调整图像大小的默认方法是`keep_aspect_ratio_resizer`。

这个方法，如上面例子中的min_dimension和max_dimension参数所定义的，将把一个图像的较小边调整到 640 像素。另一边将被调整大小，以保持原来的长宽比。

存储为 true 将允许填充，这可能需要在调整大小时保持原始纵横比。

查看这个调整大小方法的输出很有趣。如果您的原始图像是矩形的，那么在调整大小时，您可能会得到一个被过度填充的图像。如果您通过自己选择的追踪工具进行检查，您的最终图像可能是这样的:

使用 keep_aspect_ratio_resizer 方法时可能会出现的填充图像示例。|图片来源:Jakub CIE likT3【如何进行图像分割和对象检测的数据探索(我不得不艰难地学习的东西】

我们绝对不想给我们的网络提供这样的图片。显然，它有太多无意义的信息被编码为黑色像素。我们怎样才能让它变得更好？我们可以使用不同的调整大小方法。

image resizer

*Code snippet within pipeline.config file that defines image resizing step in EfficientDet D-1 model. *

在第一篇文章中，您了解了如何以高级方式进行参数调整。使用这种方法，您会发现 TensorFlow API 中还有其他调整大小的方法。

我们可能特别感兴趣的一个是fixed_shape_resizer，它将图像整形为由height和width参数定义的给定大小的矩形。

看看它在 pipeline.config 文件中的实现:

上图中有两件事值得你注意。

首先，从一种方法切换到另一种方法是多么容易:几行修改，没什么复杂的。

其次，您现在可以完全控制您的输入图像。尝试调整大小的方法和输入图像的大小有助于保留解决对象检测任务所必需的功能。

请记住，你的输入图像越小，网络就越难检测到物体！当您想要检测比原始图像尺寸小的对象时，这就成了一个问题。

图像放大

让我们继续探索与图像相关的方法，还有另一个改进的机会——图像增强。

image resizer

Fixed_shape_resizer method implementation for EfficientDet D-1

图像增强是一种对输入图像随机应用变换的方法，会在训练数据集中引入额外的方差。反过来，额外的方差导致更好的模型泛化，这对于良好的性能是必不可少的。

TensorFlow API 为我们提供了多种选择！让我们看一下 pipeline.config 文件，以了解增强的默认选项:

正如我们所看到的，有两个默认选项。您必须仔细检查您的问题域，并决定哪些增强选项与您的特定任务相关。

例如，如果你期望所有的输入图像总是在一个特定的方向，random_horizontal_flip将会伤害而不是帮助，因为它随机翻转输入图像。扔掉它，因为它与你的案子无关。将类似的逻辑应用于选择其他增强选项。

您可能对 TensorFlow API 中可用的其他选项感兴趣。为了方便起见，这里有一个到脚本的链接，其中列出了所有的方法并做了很好的描述。

值得一提的是，在任何会影响图像方向的变换(旋转、翻转、缩放等)的情况下，TensorFlow 不仅变换图像本身，还变换边界框的坐标。你没有必要为标签转化做任何事情。

锚点生成

图像中对象的边框形状是什么样的？它们大多是方形的还是长方形的？边界框有没有一个特定的长宽比能最好地捕捉到你感兴趣的对象？

image augmentation options

Default image augmentation options for EfficientDet D-1.

您应该问自己这些问题，以使您的对象检测能够找到最适合您的对象的盒子。

这对于单阶段对象检测器(如 EfficientDet)变得特别方便，因为预设的锚集用于提出建议。

我们可以将锚点改为自定义数据集中对象的最佳形状吗？肯定的，是的！以下是 pipeline.config 文件中负责锚点设置的代码行:

image augmentation options in Tensorflow

List of options for image augmentation available in TensorFlow API

有一个我们最感兴趣的参数，那就是aspect_ratios。它定义了矩形锚边的比率。

让我们以`aspect_ratios: 2.0`为例，这样你就能对它的工作原理有所了解。`2.0`值表示锚点的高度=其宽度的 2 倍。这种锚几何图形将最适合那些水平拉伸两倍于其垂直尺寸的对象。

如果我们的物体被水平拉伸 10 倍会怎样？让我们设置一个锚来捕捉这些物体:aspect_ratios: 10.0将完成这项工作。

相反，如果您的对象在垂直维度上被拉伸，请将aspect_ratios设置在 0 和 1 之间。介于 0 和 1 之间的值将定义锚的宽度比其高度小多少。你可以设置你想要多少锚。只要你觉得有意义就继续加aspect_ratios就好。

你甚至可以事先做好功课，为你的机器学习项目经历一个探索阶段，分析你的物体的几何形状。就我个人而言，我喜欢创建两个图来观察高宽比和高宽比的分布。这有助于我了解哪种纵横比最适合我的模型锚:

后处理和防止过拟合

anchor generator

Lines within pipeline.config futile that are responsible for a set of model’s anchors

与预处理类似，后处理步骤也会影响模型的行为。物体探测器往往会产生数百个建议。大部分不会被录取，会被一些标准淘汰。

TensorFlow 允许您定义一组标准来控制模型建议。让我们看看 pipeline.config 文件中的代码片段:

有一种叫做非最大抑制 (NMS)的方法用于 EfficientDet D-1 内的处理。该方法本身已被证明对绝大多数计算机视觉任务是成功的，所以我不会探索任何替代方法。

这里重要的是与batch_non_max_suppression方法一起使用的一组参数。这些参数很重要，可能会对模型的最终性能产生很大影响。让我们看看他们如何做到这一点:

score_threshold是一个参数，它定义了分类的最小置信度得分，应达到该得分，这样建议才不会被过滤掉。在默认配置中，它被设置为一个接近 0 的值，这意味着所有建议都被接受。这听起来像是一个合理的值吗？我的个人实践表明，最小过滤最终会给出更好的结果。消除那些最有可能不正确的建议导致更稳定的训练、更好的收敛和更低的过度拟合的机会。考虑将该参数至少设置为 0.2。当您的跟踪工具显示您的网络在评估集上的建议很差，或者/和您的评估指标没有随着时间的推移而改进时，这一点尤其重要；

width-to-height ratio distribution

Example for width-to-height ratio distribution that I plot when looking for the best shape for my anchors.

`iou_threshold`是一个参数，让 NMS 对重叠的盒子进行适当的过滤。如果您的模型为对象生成重叠的框，请考虑降低该分数。如果你的图像上有密集分布的物体，考虑增加这个参数；

从名字上来看很简单。你希望每个类有多少个对象？几个，十几个，还是几百个？这个参数将帮助你的网络了解这一点。我在这里的建议是将这个值设置为等于单个类的最大对象数乘以你拥有的 anchors 数(number of aspect_ratios);

max_total_detections应设置为max_detections_per_class *班级总数。将max_number_of_boxes设置为与max_total_detections相同的数字也很重要。max_number_of_boxes位于 pipeline.config 文件的train_config部分。

post processing

Piece of code (default values are kept) that defines post-processing parameters for
EfficientDet D-1

给定上述设置参数的方法，您将让您的模型知道预期有多少对象以及它们的密度是多少。这将导致更好的最终性能，也将降低过度拟合的机会。

既然我们已经谈到过拟合问题，我也将分享另一个消除它的常用工具——dropout层，它是这样实现的:

Dropout 实现强制您的模型寻找那些最能描述您想要检测的对象的特征。它有助于提高泛化能力。更好的泛化有助于模型更好地抵抗过度拟合。
最后但并非最不重要的一点是，您可以通过先进的学习速率控制方法来避免过度拟合并获得更好的模型性能。具体来说，我们感兴趣的是如何推动我们的训练工作，为给定的损失函数找到真正的全局最小值。
学习率计划对这一目标至关重要。让我们看看 TensorFlow 在 EfficientDet D-1 的默认配置中为学习率调度提供了什么:
余弦学习率衰减是一个伟大的调度程序，允许你的学习率在整个训练时间内增长和减少。

为什么这种调度方法可以给你更好的模型性能和防止过度拟合？出于几个原因:

以较低的学习率开始可以让您在训练模型的最开始就控制渐变。我们不希望它们变得非常大，所以原始模型的权重不会发生剧烈变化。请记住，我们在自定义数据集上微调我们的模型，没有必要改变神经网络已经学习的低级特征。对于我们的模型，它们很可能保持不变；

box predictor

Dropout with probability = 0.2 set for box_predictor net within EfficientDet D-1

学习率的初始增加将有助于你的模型有足够的能力不陷入局部最小值，并能够摆脱它；

dropout layer

Illustration for a dropout layer (with probability = 0.5) implemented within a simple neural net. | Source: primo.ai

随着时间的推移，平滑的学习率衰减将导致稳定的训练，并且还将让您的模型找到最适合您的数据的可能。

你现在确信学习率计划很重要吗？如果是，下面是正确配置的方法:

learning rate

Learning rate scheduler implementation in a default configuration for EfficientDet D-1

learning_rate_base是您的模型开始训练的初始学习率；

total_steps定义你的模型将要训练的总步数。请记住，在培训工作的最后阶段，学习率计划程序将使学习率值接近于零；

warmup_learning_rate是学习率开始下降前将达到的最大值；
warmup_steps定义将学习率从learning_rate_base提高到warmup_learning_rate的步数
损失函数操作

您可能遇到过这样的情况:您的模型在定位对象方面表现出色，但在分类方面表现很差。相比之下，分类可能非常好，但对象定位可能更好。

当对象检测器被包括到服务流水线中时，这变得尤其重要，其中每个服务都是机器学习模型。在这种情况下，每个模型的输出都应该足够好，以便后续模型将其作为输入进行消化。
请这样想:您试图检测图像上的所有文本片段，以便将每个文本片段传递给下一个 OCR 模型。如果您的模型检测到所有文本，但有时由于本地化不佳而截断文本，该怎么办？
这对于后面的 OCR 来说是个问题，因为它无法读取整个文本。OCR 将能够处理一段剪切的文本，但它的输出对我们来说将毫无意义。我们怎么能这样做呢？
TensorFlow 为您提供了一个选项，通过损失函数中的权重来确定对您来说重要的事情的优先级。看看这段代码:

您可以更改这些参数的值，为对您最重要的内容赋予更高的权重。或者，您可以降低总损失中特定零件的值。这两种方法最终完成了相同的工作。

如果你决定改变权重值，我个人的建议是从 0.1-0.3 之间的值开始增加权重。更大的值可能会导致严重的不平衡。

结论

您对 TensorFlow API 的熟练程度已达到一个新的水平。你现在可以完全控制你的实验，并且知道如何评估和比较它们，所以只有最好的才会投入生产！

您还熟悉如何将您的模型转移到生产中。您知道如何导出模型，并拥有执行推理所需的所有代码。

希望您现在已经有了进一步改进模型的机会的感觉。试试看。当您看到您的指标增长时，您会喜欢它的。对你的假设设定要有创造性，不要害怕尝试新的想法。也许你的下一个配置会为我们所有人树立一个标杆！谁知道呢？

weights

Initial set up for weights within loss function. Equal values for classification and localization.

下次见！

If you decide to play around with weight values, my personal recommendation would be to start incrementing weights by values around between [0.1-0.3]. Bigger values might lead to a significant imbalance.

Conclusions

Your proficiency with the TensorFlow API has reached a new level. You’re now in full control of your experiments and know how to evaluate and compare them, so only the best will go to production!

You’re also familiar with how to move your model to production. You know how to export a model and have all code necessary to perform inference.

Hopefully, you now have a feeling of what your opportunities are for further model improvement. Give it a shot. You’ll love it when you see your metrics grow. Be creative with your hypothesis setting, and don’t be afraid to try new ideas. Maybe your next configuration will set a benchmark for all of us! Who knows?

See you next time!

文本分类:来自 5 场 Kaggle 比赛的所有提示和技巧

原文：https://web.archive.org/web/https://neptune.ai/blog/text-classification-tips-and-tricks-kaggle-competitions

在本文中，我将讨论一些提高文本分类模型性能的技巧和诀窍。这些技巧是从 Kaggle 的一些顶级 NLP 竞赛的解决方案中获得的。

也就是说，我经历了:

发现了很多好主意。

没有太多的延迟，让我们开始吧。

处理更大的数据集

你在任何机器学习竞赛中可能面临的一个问题是数据集的大小。如果您的数据量很大，对于 Kaggle 内核和更基本的笔记本电脑来说是 3GB +,您会发现在有限的资源下很难加载和处理。这里是我发现在这种情况下有用的一些文章和内核的链接。

小型数据集和外部数据

但是，如果数据集很小，我们该怎么办呢？让我们来看看解决这种情况的一些技巧。

提高任何机器学习模型的性能的一种方法是使用一些包含一些影响谓词变量的变量的外部数据框架。

让我们看看一些外部数据集。

数据探索和获得洞察力

数据清理

数据清理是任何自然语言处理问题的重要组成部分之一。文本数据总是需要一些预处理和清理，然后才能以合适的形式表示出来。

文本表示

在我们将文本数据输入到神经网络或 ML 模型之前，文本输入需要以合适的格式表示。这些表示在很大程度上决定了模型的性能。

语境嵌入模型

来自变压器的双向编码器表示
GPT
Roberta 稳健优化的 BERT
一个用于自我监督语言表达学习的 Lite BERT
伯特的一个较轻版本
XLNET

建模

模型架构

选择正确的架构对于开发适当的机器学习模型非常重要，像 LSTMs、GRUs 这样的序列对序列模型在 NLP 问题中表现良好，总是值得尝试。堆叠两层 LSTM/GRU 网络是一种常见的方法。

损失函数

为你的神经网络模型选择一个合适的损失函数，通过允许它在表面上很好地优化，确实增强了你的模型的性能。

您可以尝试不同的损失函数，甚至编写一个与您的问题相匹配的自定义损失函数。一些流行的损失函数有

优化者

回调方法

在训练时，回调对于监控模型的性能总是有用的，并触发一些可以增强模型性能的必要操作。

评估和交叉验证

选择一个合适的验证策略是非常重要的，以避免模型在私有测试集中的巨大变动或不良性能。

传统的 80:20 分割在很多情况下并不适用。在大多数情况下，交叉验证比传统的单一训练验证分割更有效，以评估模型性能。

k 折叠交叉验证有不同的变体，如应相应选择的 k 折叠组。

运行时技巧

您可以执行一些技巧来减少运行时间，并在运行时提高模型性能。

模型组装

如果你在竞争环境中，没有集合，你就不会在排行榜上名列前茅。选择合适的组装/堆叠方法对于充分发挥模型的性能非常重要。

让我们来看看一些在 Kaggle 比赛中使用的流行组合技术:

最后的想法

在本文中，您看到了许多改进 NLP 分类模型性能的流行而有效的方法。希望你会发现它们对你的项目有用。

沙胡尔 ES

数据科学家，非常熟悉机器学习、NLP 和音频处理领域。他是 Kaggle 大师，也喜欢做开源。

阅读下一篇

自然语言处理的探索性数据分析:Python 工具完全指南

11 分钟阅读|作者 Shahul ES |年 7 月 14 日更新

探索性数据分析是任何机器学习工作流中最重要的部分之一，自然语言处理也不例外。但是你应该选择哪些工具来高效地探索和可视化文本数据呢？

在这篇文章中，我们将讨论和实现几乎所有的主要技术，你可以用它们来理解你的文本数据，并给你一个完成工作的 Python 工具的完整之旅。

开始之前:数据集和依赖项

在本文中，我们将使用来自 Kaggle 的百万新闻标题数据集。如果您想一步一步地进行分析，您可能需要安装以下库:

pip install \
   pandas matplotlib numpy \
   nltk seaborn sklearn gensim pyldavis \
   wordcloud textblob spacy textstat

现在，我们可以看看数据。

news= pd.read_csv('data/abcnews-date-text.csv',nrows=10000)
news.head(3)

jupyter output

数据集只包含两列，发布日期和新闻标题。

为了简单起见，我将探索这个数据集中的前 10000 行。因为标题是按发布日期排序的，所以实际上从 2003 年 2 月 19 日到 2003 年 4 月 7 日有两个月。

好了，我想我们已经准备好开始我们的数据探索了！

Continue reading ->

合成数据相对于真实数据的优势

原文：https://web.archive.org/web/https://neptune.ai/blog/the-advantages-of-synthetic-data-over-real-data

人工智能在 2020 年风靡一时，但许多有抱负的技术专家遇到了一个问题:训练数据。

对于大多数人工智能/机器学习应用程序来说，拥有一个大型的精选数据集是必要的。获取这些数据通常是一项挑战。

你不仅要从现实世界中收集数据，还必须为你的模型做注释和准备。对于学生、小型研究团队和早期创业公司来说，训练数据是一个需要克服的重大障碍。

这就是合成训练数据派上用场的地方。合成数据是模仿真实数据的假数据。

对于某些 ML 应用程序，创建合成数据比收集和注释真实数据更容易。

这有三个主要原因:

您可以根据需要生成任意多的合成数据，
您可以生成在现实中收集起来可能很危险的数据，
合成数据被自动注释。

让我们进入细节。

什么是合成数据？

机器学习的一个基本规律是，你需要大量的数据。您需要的数据量从一万个示例到数十亿个数据点不等。

对于自动驾驶汽车等复杂应用来说，收集大量高质量的训练数据是一项挑战。幸运的是，合成数据最适合大型数据集。

了解真实训练数据最重要的一点是，你以线性方式收集数据。

在大多数情况下，每个额外的训练示例与前一个示例花费的收集时间大致相同。合成数据就不是这样了。

合成数据的特别之处在于它可以被大量生成。一万个训练例子？没问题。一百万个例子？没问题。十亿？嗯，你可能需要一个更强大的 GPU，但这是可行的。

相比之下，十亿个真实的训练例子可能根本不可能。

为什么使用合成数据(合成数据与真实数据)

收集真实数据可能很危险。例如，自动驾驶汽车 AI 不能完全依赖真实数据。从事这项技术的公司，如 Alphabet 的 Waymo，必须进行模拟。

想想看:为了训练一个人工智能避免车祸，你需要关于车祸的训练数据。但是收集真实车祸的大型数据集成本太高，风险太大，所以你只能模拟车祸。

真实数据可不多见

危险收集的原则也适用于很少能收集到的数据。

例如，如果你的人工智能算法正在寻找一个“大海捞针”，合成数据可以生成足够数量的罕见事件，以准确训练一个人工智能模型。

考虑到这一点，人工智能的一些最有益的用途集中在“罕见”的事件上。由于这些问题的性质，很难收集罕见的事件。

回到汽车的例子，车祸不会经常发生，你也很少有机会收集这些数据。使用合成数据，您可以选择要模拟多少次碰撞。

合成数据完全由用户控制

合成数据模拟中的一切都是可以控制的。是福是祸。

这可能是一个诅咒，因为有些情况下，合成数据会遗漏真实数据集中可以捕捉到的边缘情况。

对于这些应用程序，您可能希望利用迁移学习在您的合成数据集里加入一些真实数据。

但这也是一件幸事——事件频率、对象分布等等都取决于你。

合成数据被完美注释

合成数据的另一个优势是完美的注释。您再也不需要手动收集数据。

可以为场景中的每个对象自动生成各种注释。这听起来没什么大不了的，但这是合成数据比真实数据便宜的一个重要原因。

你不用为数据标签付费。相反，合成数据的主要成本是建立模拟的前期投资。在此之后，生成数据比真实数据的成本效率要高得多。

合成数据可以是多光谱的

自动驾驶汽车公司已经意识到注释不可见数据具有挑战性。这就是为什么他们是合成数据的最大支持者。

Alphabet 的 Waymo 和通用汽车的 Cruise 等公司使用模拟来生成合成激光雷达数据。由于这些数据是合成的，所以基本事实是已知的，并且数据被自动标记。

同样，合成数据非常适合红外或雷达计算机视觉应用，在这些应用中，人类无法完全解读图像。

哪里可以应用合成数据？

合成数据有很多用途。目前，合成数据有两大领域:计算机视觉和表格数据。

计算机视觉是指人工智能算法用于检测图像中的对象和模式。相机越来越多地用于许多行业，从汽车到无人机，再到医学。

合成数据结合更先进的人工智能意味着计算机视觉的技术才刚刚起步。

合成数据的另一个用途是在表格数据中。表格合成数据引起了研究人员的极大关注。麻省理工学院的研究人员最近发布了合成数据库，这是一个基于电子表格的合成数据开源工具集。

健康和隐私数据尤其适合采用合成方法。这些领域受到隐私法的高度限制。合成数据可以帮助研究人员在不侵犯人们隐私的情况下获得他们需要的数据。

随着新工具和教程的发布，合成数据将能够在人工智能的发展中发挥越来越大的作用。

结论

高质量的数据、危险的真实数据收集和完美的注释是使用合成数据的三大原因。

如果你想检查一个真实的产品，我和我的合作伙伴为虚幻引擎发布了一个免费插件，使其更容易生成合成数据。

还有很多其他工具可以生成合成数据。无论你选择哪一种，合成数据都可能是获得训练数据的一种很好的方式，并可能成为下一代人工智能的巨大推动力。

If you want to check out a real product, my partners and I released a free plugin for Unreal Engine to make it easier to generate synthetic data.

There are a lot of other tools to generate synthetic data. Whichever you choose, synthetic data can be a great way to get training data, and will likely be a big moving force for the next generation of AI.

最好的 Comet.ml 替代品

原文：https://web.archive.org/web/https://neptune.ai/blog/the-best-comet-ml-alternatives

Comet 是从事机器学习实验的人最常用的工具之一。它是一个自托管和基于云的元机器学习平台，允许数据科学家和团队跟踪、比较、解释和优化实验和模型。

Comet 提供了一个 Python 库，允许数据科学家将他们的代码与 Comet 集成，并开始在应用程序中跟踪工作。由于它提供了云托管和自托管两种方式，你应该能够管理你整个团队的 ML 实验。

Comet 正在向 ML 的更多自动化方法靠拢，增加了预测提前停止(该软件的免费版本不提供)并宣布了神经架构搜索(将在未来推出)。

彗星最显著的一些特征包括:

支持团队共享工作，并提供用户管理
集成了许多 ML 库
让您比较实验——代码、超参数、度量、预测、依赖性、系统度量等等
让您用专用于图像、音频、文本和表格数据的模块来可视化样本

而且虽然 Comet 是一个很棒的解决方案，但是没有一个工具是对所有人都完美的(至少我没听说过这样的工具)。

可能会遗漏一些对你和你的团队至关重要的点。可能是:

缺少某些功能:比如无法记录“细节图/散景图”
您的个人偏好:比如 UI 中的图表视图，或者比较表，或者其他特定于您的用例的特性；
定价:也许你更喜欢基于使用定价模式的工具，或者是开源的；
可扩展性:可能在可扩展性方面没有满足你的需求，你的团队每个月运行的实验越来越多。

无论如何，还有许多其他工具可用，为了帮助您找到合适的工具，我们列出了最佳的 Comet 替代工具。

Neptune 是 MLOps 的一个元数据存储库，主要关注实验跟踪和模型注册。它是为进行大量实验的研究和生产团队而构建的。它的主要目标是让他们的生活更轻松，让他们做自己真正想做的事情，也就是 ML(而不是手动将数字插入 excel 表)。

因此，数据科学家和 ML 工程师可以使用 Neptune 在一个地方记录、存储、组织、显示、比较和查询所有建模元数据。这包括元数据，如模型度量和参数、模型检查点、图像、视频、音频文件、数据版本、交互式可视化等。

稍后在团队中共享这些被跟踪的元数据也很容易。Neptune 允许您为项目创建工作区，管理用户访问，并与内部和外部的利益相关者共享仪表板的链接。

海王星–主要特征:

Neptune 允许您以任何想要的结构记录和显示模型元数据。无论是模型的嵌套参数结构，训练和验证度量的不同子文件夹，还是打包模型或生产工件的单独空间。怎么组织就看你自己了。
然后，您可以创建定制的仪表板以一种首选的方式组合不同的元数据类型。
Neptune 的定价是基于使用的。整个团队的固定月费相对较低(不管有多少人)，但除此之外，你只需为你使用的东西付费。
该应用程序可以处理数千次运行，并且在您越来越多地使用它时不会变慢。它随着你的团队和项目的规模而扩展。

如果你想看海王星在行动，检查这个现场笔记本或这个例子项目(不需要注册)，只是玩它。

海王星 vs 彗星

Neptune 和 Comet ML 都在相同的市场空间中运营，但是，它们的功能主张因技术和非技术产品而异。

这两种工具都是专有软件，提供托管和内部设置，有不同的定价选项可供选择。Neptune 提供了一个基于使用的定价模型，不同于其他固定的产品，在这个模型中，你可以根据你正在使用的实验和功能的数量来调整价格。另一方面，Comet 有严格的一维定价结构。

在功能上也有一些不同。例如，如果你正在寻找一个工具，可以让你跟踪你的数据集版本，那么海王星是你的选择，因为彗星缺乏这个功能。

TensorBoard-experiment-tracking

Example dashboard in TensorBoard | Source

TensorBoard 是 TensorFlow 的可视化工具包，可让您分析模型训练运行。它是开源的，为机器学习模型的可视化和调试提供了一套工具。

它允许您可视化机器学习实验的各个方面，如度量、可视化模型图、查看张量直方图等。

如果你正在寻找一个彗星的替代品来可视化你的实验并深入研究它们，这是一个很好的工具。

tensor board—主要特点** 😗*

您可以在一个地方记录整个团队的实验
跟踪不是基于 TensorFlow 或深度学习的实验
备份整个实验历史
为项目干系人快速制作报告
将跟踪系统与技术堆栈中的其他工具相集成
可用的可视化功能

张量板 vs 彗星

如果您正在寻找一个工具来可视化您的项目的 ML 模型元数据，那么 TensorBoard 可能是您的正确选择。它是开源的，它的可视化非常强大，但它运行在本地服务器上，所以你不能和你的团队成员分享，不像 Comet。

然而，TensorBoard 为您提供了很多可视化数据的技术选项，这是 Comet 所没有的。例如，它提供了对度量图表的平滑，并提供了一个步骤(时期)滑块来比较不同时期的结果。

Guild-AI-experiment-tracking

Example dashboard in Guild AI | Source

Guild AI 是机器学习工程师和研究人员用来运行、跟踪和比较实验的开源工具。通过 Guild AI，您可以利用您的实验结果来建立更深层次的直觉，解决问题，并自动化模型架构和超参数优化。

Guild AI 是跨平台和框架独立的——你可以使用任何库用任何语言训练和捕捉实验。公会人工智能运行你未修改的代码，所以你可以使用你想要的库。该工具不需要数据库或其他基础设施来管理实验，简单易用。

帮会 AI-主要特色** 😗*

实验跟踪:任何模型训练，任何编程语言
自动化机器学习过程
与任何语言和库集成
远程培训和备份的可能性
你可以复制你的结果或重现实验

公会 AI vs 彗星

如果你正在寻找一个不需要你改变代码的开源实验跟踪工具，那么 Guild AI 将是一个不错的选择。如上所述，您将拥有可视化、超参数调整和许多其他功能。然而，由于它是开源的，它错过了面向可伸缩性和团队工作的关键特性。

如果你是一个团队，你的首要任务是分享结果和扩展到大量的实验，那么不幸的是公会人工智能不适合它。

MLflow-experiment-tracking

Example dashboard in MLflow | Source

MLflow 是一个开源平台，有助于管理整个机器学习生命周期，包括实验、再现性、部署和中央模型注册。

MLflow 适合个人和任何规模的团队。

该工具与库无关。你可以用任何机器学习库和任何编程语言来使用它

MLflow 包括四个主要功能:

ml flow Tracking——一个 API 和 UI，用于在运行机器学习代码时记录参数、代码版本、指标和工件，并在以后可视化和比较结果
MLflow 项目——将 ML 代码打包成可重用、可复制的形式，以便与其他数据科学家共享或转移到生产中
MLflow 模型——从不同的 ML 库中管理和部署模型到各种模型服务和推理平台
MLflow Model Registry–一个中央模型存储库，用于协作管理 ml flow 模型的整个生命周期，包括模型版本控制、阶段转换和注释

MLflow vs 彗星

MLflow 是 Comet 的另一个开源替代方案。它提供了与 Comet 相同的功能，并且在大数据上也能很好地扩展。如果您的团队使用 Apache Spark，那么 MLflow 将是一个很好的选择，因为它可以很好地与 Spark 一起提供大数据的模型跟踪和模型注册。

但是 Comet 附带了用户管理特性，并允许在团队内部共享项目——这是 MLflow 所缺少的。它还提供托管和内部设置，而 MLflow 仅作为开源解决方案提供，需要您在服务器上维护它。

WandB - experiment tracking

Example dashboard in W&B | Source

WandB 专注于深度学习。用户使用 Python 库跟踪应用程序的实验，并且作为一个团队，可以看到彼此的实验。它允许他们记录实验，并可视化研究的每一部分。WandB 是一项托管服务，允许您在一个地方备份所有实验

Wandb—主要特点** 😗*

处理用户管理
出色的用户界面允许用户很好地可视化、比较和组织他们的跑步
团队共享工作:团队共享的多种功能
与其他工具的集成:几个可用的开源集成

WandB vs 彗星

WandB 是 Comet 的闭源解决方案替代方案。它提供了与 Comet 非常相似的特性，除了与不同语言和框架的集成。例如，WandB 集成了 fastai 和 Catalyst 进行模型训练，而 Comet 没有。两者的定价模式根据需求也有很大不同，你可以查看 Comet 的这里和 WandB 的这里。

神圣是一个开源工具，由研究机构 IDSIA(瑞士人工智能实验室)开发。Sacred 是一个 Python 库，帮助配置、组织、记录和复制实验。

该工具提供了一种使用配置的编程方式。观察者的概念允许您跟踪与实验相关的各种类型的数据。

此外，神圣有自动播种——当需要重现一个实验时非常有用。

神圣——主要特征** 😗*

最适合个人用户，因为不支持团队共享工作
实验跟踪:任何模型训练
与其他工具集成:不支持
额外收获:神圣的前端很少，可以挑一个最符合自己需求的。看一看 这个与海王星特别融合的。

神圣 vs 彗星

神圣是另一个开源替代彗星。如果你是一个正在寻找一个简单易用的实验跟踪工具的人，那么神圣将是一个很好的选择。它是一个独立的 pip 包，前端用户界面取决于其他来源，你可以在这里查看这些来源。

神圣不支持团队协作，所以它最适合个人使用。如果你是一个致力于生产规格项目的团队，那么 Comet 将是一个比神圣更好的选择。

摘要

在任何机器学习项目中，找到满足您需求的正确跟踪工具总是证明卓有成效的。它帮助你比任何传统方法更快地达到预期的效果。因此，分配足够的时间和资源来选择正确的工具将会节省大量的时间和资源。

不要忘了选择一个符合你的需求和工作方式的工作，给你足够的灵活性来充分利用你的时间。

愉快地体验您的 ML 项目！

最佳 Kubeflow 替代品

原文：https://web.archive.org/web/https://neptune.ai/blog/the-best-kubeflow-alternatives

Kubeflow 是 Kubernetes 的 ML 工具包。它有助于维护机器学习系统——管理所有的应用程序、平台和资源考虑事项。它通过使机器学习工作流的运行编排和部署更容易来促进机器学习模型的扩展。这是一个开源项目，包含一组专门针对各种 ML 任务的兼容工具和框架。

Kubeflow 围绕三个原则构建:

可组合性——你可以选择整个 ML 项目中你想要使用的组件，并使它们作为独立的系统工作
可移植性——在多样化的基础设施上运行项目的所有部分
可扩展性——您的项目可以在需要时访问更多资源，并在不需要时释放它们

Kubeflow 是一个处理整个 ML 生命周期的庞然大物。但是您可能会在其他 ML 工具中寻找一些更小的功能子集，它们可能更适合您的 ML 过程的特定步骤。

因此，如果您需要 Kubeflow 替代方案来处理诸如数据版本化、实验跟踪或模型服务之类的事情，我们会全力支持您。以下是按类别分组的最佳选择。

数据和管道版本控制

DVC，或数据版本控制，是一个机器学习项目的开源版本控制系统。这是一个实验工具，不管你使用什么语言，它都可以帮助你定义你的管道。

当您在 ML 模型的前一版本中发现问题时，DVC 通过利用代码、数据版本化和可再现性来帮助节省时间。您还可以训练您的模型，并通过 DVC 管道与您的队友分享。

DVC 可以处理大量数据的版本和组织，并以一种组织良好、易于访问的方式存储它们。它侧重于数据和管道版本化和管理，但也有一些(有限的)实验跟踪功能。

DVC–摘要:

可以使用不同类型的存储—不受存储限制
完整的代码和数据来源有助于跟踪每个 ML 模型的完整发展
通过始终如一地维护输入数据、配置和最初用于运行实验的代码的组合来实现可重复性
跟踪指标
一种将 ML 步骤连接到 DAG 并端到端运行整个管道的内置方式

Pachyderm 是一个将数据谱系与 Kubernetes 上的端到端管道相结合的平台。

它有三个版本，社区版(开源，可以在任何地方使用)、企业版(完整的版本控制平台)和中心版(仍是测试版，结合了前两个版本的特点)。

您需要将 Pachyderm 与您的基础架构/私有云相集成。

因为在本节中我们讨论的是数据和管道版本，所以我们将讨论这两者，但是 Pachyderm 的内容不止于此(查看网站了解更多信息)。

谈到数据版本化，厚皮动物数据版本化系统有以下几个主要概念:

存储库–厚皮动物存储库是最高级别的数据对象。通常，Pachyderm 中的每个数据集都有自己的存储库
提交–回购在特定时间点的不可变快照
分支–特定提交的别名或指针，在提交新数据时自动移动
文件–文件和目录是存储库中的实际数据。Pachyderm 支持任何类型、大小和数量的文件
出处——表达各种提交、分支和存储库之间的关系。它帮助您跟踪每个提交的来源

Neptune 是为运行大量实验的研究和生产团队构建的 MLOps 的元数据存储。它非常灵活，可以与许多其他框架一起工作，并且由于其稳定的用户界面，它实现了巨大的可伸缩性(达到数百万次运行)。

这是一个强大的软件，可以存储、检索和分析大量数据。Neptune 拥有高效团队协作和项目监督的所有工具。

海王星——概要:

为用户和组织管理提供不同的组织、项目和用户角色
快速美观的用户界面，具有多种功能来分组组织跑步，保存自定义仪表板视图并与团队共享
您可以使用托管应用程序来避免维护另一个工具的所有麻烦(或者将其部署在您的内部基础架构上)
您的团队可以跟踪在脚本(Python、R、other)、笔记本(local、Google Colab、AWS SageMaker)中执行的实验，并在任何基础设施(云、笔记本电脑、集群)上执行
广泛的实验跟踪和可视化功能(资源消耗、图像列表滚动)

MLflow 是一个开源平台，有助于管理整个机器学习生命周期，包括实验、再现性、部署和中央模型注册。

MLflow 适合个人和任何规模的团队。

该工具与库无关。你可以用任何机器学习库和任何编程语言来使用它

MLflow 包含四个主要功能:

ml flow Tracking——一个 API 和 UI，用于在运行机器学习代码时记录参数、代码版本、指标和工件，并在以后可视化和比较结果
MLflow 项目——将 ML 代码打包成可重用、可复制的形式，以便与其他数据科学家共享或转移到生产中
MLflow 模型——从不同的 ML 库中管理和部署模型到各种模型服务和推理平台
MLflow Model Registry–一个中央模型存储库，用于协作管理 ml flow 模型的整个生命周期，包括模型版本控制、阶段转换和注释

培训运行流程编排

亚马逊 SageMaker 是一个平台，使数据科学家能够构建、训练和部署机器学习模型。它拥有用于整个机器学习工作流的所有集成工具，在单个工具集中提供了用于机器学习的所有组件。

SageMaker 是一个适合安排、协调和管理机器学习模型的工具。它有一个基于 web 的可视化界面来执行所有 ML 开发步骤(笔记本、实验管理、自动模型创建、调试和模型漂移检测)

亚马逊 SageMaker–摘要:

Autopilot 自动检查原始数据，应用功能处理器，挑选最佳算法集，训练和调整多个模型，跟踪它们的性能，然后根据性能对模型进行排序——它有助于部署性能最佳的模型
SageMaker Ground Truth 帮助您快速构建和管理高度准确的训练数据集
SageMaker Experiments 通过自动捕获输入参数、配置和结果，并将其存储为“实验”，来帮助组织和跟踪机器学习模型的迭代
SageMaker Debugger 在训练期间自动捕获实时指标(如训练和验证、混淆、矩阵和学习梯度)，以帮助提高模型准确性。当检测到常见的培训问题时，调试器还可以生成警告和补救建议
SageMaker Model Monitor 允许开发人员检测和修复概念漂移。它会自动检测已部署模型中的概念漂移，并给出详细的警报，帮助识别问题的根源

Polyaxon 是一个平台，用于复制和管理机器学习项目的整个生命周期，以及深度学习应用。

该工具可以部署到任何数据中心、云提供商，并且可以由 Polyaxon 托管和管理。它支持所有主要的深度学习框架，如 Torch、Tensorflow、MXNet。

说到流程编排，Polyaxon 允许您通过 CLI、dashboard、SDK 或 REST API 调度作业和实验，从而最大限度地利用集群。

poly axon–概要:

支持整个生命周期，包括运行流程编排，但可以做的远不止这些
有一个开源版本，您可以立即使用，但为企业提供了选项
它与 Kubeflow 集成，因此您可以一起使用两者。

超参数调谐

Optuna 是一个自动超参数优化框架，可用于机器学习/深度学习和其他领域。它有一套最先进的算法，你可以选择(或连接)，它是非常容易的分布训练到多台机器，并让你很好地可视化你的结果。

它集成了流行的机器学习库，如 PyTorch、TensorFlow、Keras、FastAI、scikit-learn、LightGBM 和 XGBoost。

Optuna–摘要:

支持在一台机器(多进程)和一个集群(多节点)上进行分布式培训
支持各种修剪策略，以更快地收敛(并使用更少的计算)
拥有一套强大的可视化工具，如平行坐标、等高线图或切片图

SigOpt 旨在加速和放大机器学习、深度学习和模拟模型的影响。它有助于通过自动化过程节省时间，使其成为超参数调整的合适工具。

您可以将 SigOpt 无缝集成到任何模型、框架或平台中，而无需担心您的数据、模型和基础架构——一切都是安全的。

该工具还允许您监控、跟踪和分析您的优化实验，并将其可视化。

SigOpt–摘要:

多指标优化便于同时探索两个不同的指标
条件参数允许定义和调整架构参数，并自动选择模型
高并行性使您能够充分利用大规模计算机基础设施，并在多达 100 名工作人员中运行优化实验

模型服务

Cortex 是一个开源的替代方案，可以使用 SageMaker 提供模型服务，或者在 AWS 服务(如 Elastic Kubernetes Service (EKS)、Lambda 或 Fargate)和开源项目(如 Docker、Kubernetes、TensorFlow Serving 和 TorchServe)的基础上构建自己的模型部署平台。

这是一个多框架工具，允许您部署所有类型的模型。

皮层–总结:

自动扩展 API 以处理生产工作负载
对任何 AWS 实例类型运行推理
在单个 API 中部署多个模型，并在不停机的情况下更新已部署的 API
监控 API 性能和预测结果

Seldon 是一个开源平台，允许你在 Kubernetes 上部署机器学习模型。它在云中和内部都可用。

谢顿–摘要:

利用 canary deployment 等各种选项简化模型部署
出现问题时，使用警报系统监控生产中的模型
使用模型解释器来理解为什么会做出某些预测。谢顿还开源了一个模型解释器包

把它包起来

我们希望您能找到 Kubeflow 的最佳替代方案，帮助您高效工作并提供最佳结果。毕竟一个好的工具可以改善你的工作流程。

快乐实验！

Scikit 的最佳 ML 框架和扩展-学习

原文：https://web.archive.org/web/https://neptune.ai/blog/the-best-ml-framework-extensions-for-scikit-learn

许多包实现了sci kit-learnestimator API。

如果您已经熟悉 Scikit-learn，您会发现这些库的集成非常简单。

有了这些包，我们可以扩展 Scikit-learn 估算器的功能，我将在本文中向您展示如何使用它们。

数据格式

在这一节中，我们将探索可用于处理和转换数据的库。

您可以使用这个包将“DataFrame”列映射到 Scikit-learn 转换。然后，您可以将这些列组合成功能。

要开始使用该软件包，请通过 pip 安装“sklearn-pandas”。“DataFrameMapper”可用于将 pandas 数据框列映射到 Scikit-learn 转换。让我们看看它是怎么做的。

首先，创建一个虚拟数据帧:

data =pd.DataFrame({
    'Name':['Ken','Jeff','John','Mike','Andrew','Ann','Sylvia','Dorothy','Emily','Loyford'],
    'Age':[31,52,56,12,45,50,78,85,46,135],
    'Phone':[52,79,80,75,43,125,74,44,85,45],
    'Uni':['One','Two','Three','One','Two','Three','One','Two','Three','One']
})

“DataFrameMapper”接受元组列表——第一项的名称是数据帧中的列名。

第二个传递的项是将应用于该列的转换类型。

例如，' LabelBinarizer 可应用于' Uni '列，而' Age '列则使用' StandardScaler 进行缩放。

from sklearn_pandas import DataFrameMapper
mapper = DataFrameMapper([
     ('Uni', sklearn.preprocessing.LabelBinarizer()),
     (['Age'], sklearn.preprocessing.StandardScaler())
 ])

定义映射器后，接下来我们用它来拟合和转换数据。

mapper.fit_transform(data)

映射器的“transformed_names_”属性可用于显示转换后的结果名称。

mapper.transformed_names_

scikit-learn extensions

向映射器传递“df_out=True”将会以熊猫数据帧的形式返回您的结果。

mapper = DataFrameMapper([
     ('Uni', sklearn.preprocessing.LabelBinarizer()),
     (['Age'], sklearn.preprocessing.StandardScaler())

 ],df_out=True)

scikit-learn extensions

这个包结合了来自 xarray 的 n 维标签数组和 Scikit-learn 工具。

您可以将 Scikit-learn 估值器应用于“xarrays ”,而不会丢失它们的标签。您还可以:

确保 Sklearn 估算器与 xarray 数据阵列和数据集之间的兼容性，
使估计者能够改变样本数，
有预处理变压器。

Sklearn-xarray 基本上是 xarray 和 Scikit-learn 之间的桥梁。为了使用其功能，请通过 pip 或“conda”安装“sklearn-xarray”。

这个包有包装器，允许您在 xarray 数据数组和数据集上使用 sklearn 估计器。为了说明这一点，让我们首先创建一个“数据阵列”。

import numpy as np
import xarray as xr
data = np.random.rand(16, 4)
my_xarray = xr.DataArray(data)

scikit-learn extensions

从 Sklearn 中选择一个转换以应用于此“数据阵列”。在这种情况下，让我们应用“标准缩放器”。

from sklearn.preprocessing import StandardScaler
Xt = wrap(StandardScaler()).fit_transform(X)

scikit-learn extensions

包装估计器可以无缝地用于 Sklearn 管道中。

pipeline = Pipeline([
    ('pca', wrap(PCA(n_components=50), reshapes='feature')),
    ('cls', wrap(LogisticRegression(), reshapes='feature'))
])

当安装这个管道时，您只需传入 DataArray。

类似地，DataArrays 可以用于交叉验证的网格搜索。

为此，您需要从“sklearn-xarray”创建一个“CrossValidatorWrapper”实例。

from sklearn_xarray.model_selection import CrossValidatorWrapper
from sklearn.model_selection import GridSearchCV, KFold
cv = CrossValidatorWrapper(KFold())
pipeline = Pipeline([
     ('pca', wrap(PCA(), reshapes='feature')),
     ('cls', wrap(LogisticRegression(), reshapes='feature'))
 ])
gridsearch = GridSearchCV(
     pipeline, cv=cv, param_grid={'pca__n_components': [20, 40, 60]}
)

之后，您将使“gridsearch”适合“DataArray”数据类型中的 X 和 y。

自动毫升

有没有整合 Sklearn 的工具和库来更好的 Auto-ML？是的，这里有一些例子。

有了这个，你就可以用 Scikit-learn 进行自动化的机器学习了。对于设置，您需要手动安装一些依赖项。

$ curl https://raw.githubusercontent.com/automl/auto-sklearn/master/requirements.txt | xargs -n 1 -L 1 pip install

接下来，通过 pip 安装“auto-sklearn”。

使用该工具时，您不需要担心算法选择和超参数调整。Auto-sklearn 会为您完成所有这些工作。

这要归功于贝叶斯优化、元学习和集成构建方面的最新进展。

要使用它，您需要选择一个分类器或回归器，并使其适合训练集。

from autosklearn.classification import AutoSklearnClassifier
cls = AutoSklearnClassifier()
cls.fit(X_train, y_train)
predictions = cls.predict(X_test)

Auto _ ViML–自动变量可解释机器学习”(读作“Auto_Vimal”)

给定一个特定的数据集，Auto_ViML 尝试不同的模型和不同的特性。它最终选定了性能最佳的模型。

该软件包还在构建模型时选择尽可能少的特征。这给了你一个不太复杂和可解释的模型。该套件还:

通过建议更改缺少的值、格式和添加变量来帮助您清理数据。
自动分类变量，无论是文本，数据，还是数字；
当 verbose 设置为 1 或 2 时，自动生成模型性能图；
允许您使用“功能工具”进行功能工程；
当“不平衡标志”设置为“真”时，处理不平衡数据

要查看它的运行，请通过 pip 安装“autoviml”。

from sklearn.model_selection import train_test_split, cross_validate

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1, random_state=42)
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.25, random_state=54)

train, test = X_train.join(y_train), X_val.join(y_val)
model, features, train, test = Auto_ViML(train,"target",test,verbose=2)

TPOT—基于采油树的管道优化工具

这是一个基于 Python 的自动 ml 工具。它使用遗传编程来优化机器学习管道。

它会探索多个管道，以便为您的数据集选择最佳管道。

通过 pip 安装“tpot ”,开始修改它。运行“tpot”后，可以将生成的管道保存在一个文件中。一旦浏览过程完成或您终止该过程，文件将被导出。

下面的代码片段展示了如何在 digits 数据集上创建分类管道。

from tpot import TPOTClassifier
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split

digits = load_digits()
X_train, X_test, y_train, y_test = train_test_split(digits.data, digits.target,
                                                    train_size=0.75, test_size=0.25, random_state=42)

tpot = TPOTClassifier(generations=5, population_size=50, verbosity=2, random_state=42)
tpot.fit(X_train, y_train)
print(tpot.score(X_test, y_test))
tpot.export('tpot_digits_pipeline.py')

这是一个自动化特征工程的工具。它的工作原理是将时态和关系数据集转换成特征矩阵。

通过 pip 安装“featuretools[complete]”开始使用它。

深度特征合成(DFS)可用于自动化特征工程。

首先，定义一个包含数据集中所有实体的字典。在“featuretools”中，实体是单个表格。之后，定义不同实体之间的关系。

下一步是将实体、关系列表和目标实体传递给 DFS。这将为您提供特性矩阵和相应的特性定义列表。

import featuretools as ft

entities = {
   "customers" : (customers_df, "customer_id"),
  "sessions" : (sessions_df, "session_id", "session_start"),
   "transactions" : (transactions_df, "transaction_id", "transaction_time")
 }

relationships = [("sessions", "session_id", "transactions", "session_id"),
               ("customers", "customer_id", "sessions", "customer_id")]

feature_matrix, features_defs = ft.dfs(entities=entities,
                                                 relationships = relationships,
                                                  target_entity = "customers")

您可以使用 Neuraxle 进行超参数调整和 AutoML。通过 pip 安装“neuraxle”以开始使用它。

除了 Scikit-learn，Neuraxle 还兼容 Keras、TensorFlow 和 PyTorch。它还具有:

并行计算和串行化，
通过提供这类项目的关键抽象来处理时间序列。

要使用 Neuraxle 进行自动 ml，您需要:

定义的管道
验证拆分器
通过“计分回调”定义计分指标
选定的“超参数”存储库
选定的“超参数”优化器
“自动”循环

点击查看完整的示例。

实验框架

现在是时候使用一些 SciKit 工具来进行机器学习实验了。

SciKit-Learn Laboratory 是一个命令行工具，可以用来运行机器学习实验。要开始使用它，请通过 pip 安装“skll”。

之后，您需要获得一个“SKLL”格式的数据集。
接下来，为实验创建一个配置文件，并在终端中运行实验。

$ run_experimen experiment.cfg

当实验完成时，多个文件将被存储在结果文件夹中。您可以使用这些文件来检查实验。

海王星

Neptune 与 Scikit-learn 的集成让你可以使用 Neptune 记录你的实验。例如，您可以记录 Scikit-learn 回归器的摘要。

from neptunecontrib.monitoring.sklearn import log_regressor_summary

log_regressor_summary(rfr, X_train, X_test, y_train, y_test)

查看本笔记本获取完整示例。

型号选择

现在让我们换个话题，看看专注于模型选择和优化的 SciKit 库。

这个库实现了基于顺序模型的优化方法。通过 pip 安装“scikit-optimize ”,开始使用这些功能。

Scikit-optimize 可用于通过基于贝叶斯定理的贝叶斯优化来执行超参数调整。

您使用“BayesSearchCV”来获得使用该定理的最佳参数。一个 Scikit-learn 模型作为第一个参数传递给它。

拟合后，您可以通过' best_params_ '属性获得模型的最佳参数。

from skopt.space import Real, Categorical, Integer
from skopt import BayesSearchCV
regressor = BayesSearchCV(
    GradientBoostingRegressor(),

     {
         'learning_rate': Real(0.1,0.3),
         'loss': Categorical(['lad','ls','huber','quantile']),
   'max_depth': Integer(3,6),
    },
     n_iter=32,
     random_state=0,
      verbose=1,
      cv=5,n_jobs=-1,
 )
regressor.fit(X_train,y_train)

Sklearn-deap 是一个用来实现进化算法的包。它减少了为模型寻找最佳参数所需的时间。

它不会尝试每一种可能的组合，而只会改进产生最佳性能的组合。通过 pip 安装“sklearn-deap”。

用于生产的模型出口

from evolutionary_search import EvolutionaryAlgorithmSearchCV
cv = EvolutionaryAlgorithmSearchCV(estimator=SVC(),
                                   params=paramgrid,
                                   scoring="accuracy",
                                   cv=StratifiedKFold(n_splits=4),
                                   verbose=1,
                                   population_size=50,
                                   gene_mutation_prob=0.10,
                                   gene_crossover_prob=0.5,
                                   tournament_size=3,
                                   generations_number=5,
                                   n_jobs=4)
cv.fit(X, y)

接下来，让我们来看看 Scikit 工具，您可以使用这些工具来导出您的生产模型。

sklearn-onnx 支持将 sklearn 模型转换为 ONNX 。

要使用它，您需要通过 pip 获得‘skl 2 onnx’。一旦你的管道准备好了，你就可以使用‘to _ onnx’函数将模型转换成 ONNX。

这是一个决策树集成的模型编译器。

from skl2onnx import to_onnx
onx = to_onnx(pipeline, X_train[:1].astype(numpy.float32))

它处理各种基于树的模型，如随机森林和梯度增强树。

您可以使用它来导入 Scikit-learn 模型。这里，“模型”是一个 scikit-learn 模型对象。

模型检查和可视化

import treelite.sklearn
model = treelite.sklearn.import_model(model)

在这一节中，让我们看看可用于模型可视化和检查的库。

dtreeviz 用于决策树可视化和模型解释。

eli5 是一个可以用来调试和检查机器学习分类器的包。你也可以用它来解释他们的预测。

from dtreeviz.trees import dtreeviz
viz = dtreeviz(
              model,
               X_train,
               y_train,
               feature_names=boston.feature_names,
               fontname="Arial",
               title_fontsize=16,
               colors = {"title":"red"}
              )

例如，Scikit-learn 估计器权重的解释如下所示:

dabl–数据分析基线库

import eli5
eli5.show_weights(model)

scikit-learn extensions

dabl 为常见的机器学习任务提供了样板代码。它仍在积极开发中，所以不推荐用于生产系统。

Skorch 是 PyTorch 的 Scikit-learn 包装器。

import dabl
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_digits
X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)
sc = dabl.SimpleClassifier().fit(X_train, y_train)
print("Accuracy score", sc.score(X_test, y_test))

它允许你在 Scikit-learn 中使用 PyTorch。它支持多种数据类型，如 PyTorch 张量、NumPy 数组和 Python 字典。

最后的想法

from skorch import NeuralNetClassifier
net = NeuralNetClassifier(
    MyModule,
    max_epochs=10,
    lr=0.1,
    iterator_train__shuffle=True,
)
net.fit(X, y)

在本文中，我们探索了一些扩展 Scikit-learn 生态系统的流行工具和库。

如您所见，这些工具可用于:

处理和转换数据，

实现自动化机器学习，
执行自动特征选择，
运行机器学习实验，
为您的问题选择最佳的模型和管道，
为生产导出模型…
…还有更多！

在您的 Scikit-learn 工作流程中试用这些包，您可能会惊讶于它们有多么方便。

Try out these packages in your Scikit-learn workflow, and you might be surprised how convenient they are.

最佳物流替代方案(2022 年更新)

原文：https://web.archive.org/web/https://neptune.ai/blog/the-best-mlflow-alternatives

MLflow 是一个帮助管理整个机器学习生命周期的开源平台。这包括实验，也包括再现性、部署和存储。这四个元素中的每一个都由一个 MLflow 组件表示:跟踪、项目、模型和注册。

这意味着与 MLflow 合作的数据科学家能够跟踪实验，组织实验，为其他 ML 工程师描述实验，并将其打包到机器学习模型中。在本文中，我们主要关注 MLflow 的实验跟踪功能，并概述其最佳替代方案。

虽然 MLflow 是一个很好的工具，但有些东西可能会更好，尤其是在大型团队中和/或您运行的实验数量非常大的情况下。

你最关心的是什么？MLflow 的主要弱点是什么？

缺少用户管理能力使得难以处理对不同项目或角色(经理/机器学习工程师)的访问权限。正因为如此，而且没有与他人共享 UI 链接的选项，团队协作在 MLflow 中也很有挑战性。
尽管最近有所改进，但在保存实验仪表板视图或按实验参数(模型架构)或属性(数据版本)对运行进行分组时，并没有提供完全的可定制性。当你有很多人在同一个项目上工作或者你正在运行数以千计的实验时，这些是非常有用的。
说到大量的实验，当你真的想探索你所有的跑步时，UI 会变得相当慢。
除非您想使用 Databricks 平台,否则您需要自己维护 MLflow 服务器。这带来了典型的障碍，如访问管理、备份等，更不用说这非常耗时。
开源社区充满活力，但是没有专门的用户支持在你需要的时候伸出援手。
MLflow 非常适合通过 Python 或 R 脚本运行实验，但 Jupyter 笔记本体验并不完美，尤其是如果您想要跟踪机器学习生命周期的一些附加部分，如探索性数据分析或结果探索。
一些功能，如记录资源消耗(CPU，GPU，内存)或滚动大量的图像预测或图表还没有出现。

ML 实验跟踪ML flow 中的功能为那些愿意维护实验数据后端、跟踪 UI 服务器并且不运行大量实验的个人用户或团队带来了巨大的价值。

如果上面提到的一些东西对你和你的团队很重要，你可能想要寻找补充的或者替代的工具。幸运的是，有许多工具可以提供这些缺失的部分或大部分。

在这篇文章中，基于 reddit 上的一些讨论和 T2 的比较，我们给出了 MLflow 的最佳替代方案。

我们认为，以下是 MLflow 的最佳替代方案:

海王星
权重&偏差
Comet.ml
Valohai
张量板

https://web.archive.org/web/20221208050817im_/https://neptune.ai/wp-content/uploads/Example-dashboard-metadata-structure.mp4

Source

Neptune 是一个元数据存储库——它充当从数据版本化、实验跟踪到模型注册和监控的 MLOps 工作流不同部分之间的连接器。Neptune 使得存储、组织、显示和比较 ML 模型生命周期中生成的所有元数据变得容易。

Neptune 使得存储、组织、显示和比较 ML 模型生命周期中生成的所有元数据变得容易。

您可以记录指标、超参数、交互式可视化、视频、代码、数据版本、和更多，并以定制的结构对其进行组织。一旦登录，一切都在一个直观和干净的用户界面中可见，您可以在那里进行分析和比较。

您还可以创建包含所有这些元数据的定制仪表板，并与您的同事、团队经理甚至外部利益相关者共享它们。以下是这种仪表板的一个示例:

有四种不同的比较视图可用——图表、平行坐标、并列表格仪表板和工件比较部分。因此，您可以轻松地评估模型并选择性能最佳的模型。

海王星在生产阶段也非常有用。有了所有记录的元数据，您就知道模型是如何创建的，以及如何再现它。

海王星——概要:

如果你想看海王星在行动，检查这个现场笔记本或这个例子项目(不需要注册)，只是玩它。

MLflow vs 海王星

这些工具之间的主要区别是 MLflow 是一个开源解决方案，而 Neptune 是一个托管云服务。它影响了 MLflow 和 Neptune 工作的各个方面。如果你正在寻找一个免费的开源工具，涵盖了广泛的 ML 生命周期步骤，MLflow 可能是你正确的选择。但是您应该记住，尽管 MLflow 可以免费下载，但它确实会产生与维护整个基础设施相关的成本。

如果你更喜欢专注于 ML 过程，而把托管工作留给其他人，Neptune 是一个不错的选择。对于月费，您可以获得出色的用户支持，快速和简单的设置，您不必担心维护，并且该工具伸缩性良好。另外，Neptune 具有用户管理功能，因此它在团队环境中会工作得更好。

查看 Neptune 和 MLflow 的深入对比。

阅读 Zoined 的案例研究，了解他们为什么选择 Neptune 而不是 MLflow。

WandB 专注于深度学习。用户使用 Python 库跟踪应用程序的实验，并且作为一个团队，可以看到彼此的实验。

与 MLflow 不同，WandB 是一种托管服务，允许您在一个地方备份所有实验，并与团队合作完成一个项目-工作共享功能可供使用。

与 MLflow 类似，在 WandB 中，用户可以记录和分析多种数据类型。

权重&偏差—汇总:

处理用户管理
出色的用户界面让用户可以很好地可视化、比较和组织他们的跑步。
团队共享工作:团队共享的多种特性。
与其他工具的集成:几个可用的开源集成
SaaS/本地实例可用:是/是
额外的好处:WandB 记录了模型图，因此您可以在以后检查它。

MLflow 与重量和偏差

与 Neptune 类似，Weight & Biases 提供了其工具的托管版本。与 MLflow 相反，ml flow 是开源的，需要在自己的服务器上维护。Weights & Biases 提供了实验跟踪、数据集版本控制和模型管理功能，而 MLflow 几乎涵盖了整个 ML 生命周期。最后，WandB 提供了用户管理特性，当你在团队中工作时，这些特性可能对你很重要。

Comet 是一个元机器学习平台，用于跟踪、比较、解释和优化实验和模型。

就像许多其他工具一样——例如 Neptune(Neptune-client specific)或 WandB——Comet 提出了一个开源 Python 库，允许数据科学家将他们的代码与 Comet 集成，并开始在应用程序中跟踪工作。

由于它提供云托管和自托管，用户可以有团队项目，并保存实验历史的备份。

Comet 正在通过预测性早期停止(免费版软件不提供)和神经结构搜索(未来)向更自动化的 ML 方法靠拢。

彗星—摘要:

处理用户管理
团队共享工作:团队共享的多种特性。
与其他工具的集成:应该由用户手动开发
SaaS/本地实例可用:是/是
额外收获:显示平行图来检查参数和指标之间的关系模式

MLflow vs 彗星

Comet 附带了用户管理特性，并允许在团队内部共享项目——这是 MLfow 中所缺少的。它还提供托管和内部设置，而 MLflow 仅作为开源解决方案提供，需要您在自己的服务器上进行维护。

当涉及到跟踪和可视化实验时，Valohai 采取了一种稍微不同的方法。

该平台为机器学习提出了编排、版本控制和管道管理——简单来说，它们涵盖了 MLflow 在日志记录方面的工作，并额外管理您的计算基础设施。

与 MLflow 一样，用户可以轻松检查和比较多次运行。同时，与众不同的是能够自动启动和关闭用于培训的云机器。

Valohai 允许您使用任何编程语言进行开发——包括 Python 和 R——这对于在固定技术堆栈中工作的团队来说非常方便。

瓦罗海—摘要:

处理用户管理
团队共享工作:多种特性
与其他工具的集成:文档中提供的集成示例
SaaS/本地实例可用:是/是
额外收获:有了训练的基础设施，你可以在瓦罗海管理的环境中进行实验。

MLflow vs Valohai

根据 Valohai 自己的对比，Valohai 在没有任何设置的情况下提供了类似 MLflow 的实验跟踪。与 MLflow 类似，Valohai 涵盖了 MLOps 领域的很大一部分(包括实验跟踪、模型管理、机器编排和流水线自动化)，但它是一个托管平台，而不是一个开源解决方案。

TensorBoard 是一个用于 TensorFlow 的开源可视化工具包，允许您分析模型训练运行。往往是 TensorFlow 用户的首选。TensorBoard 允许您可视化机器学习实验的各个方面，如度量或模型图，以及查看 tensors 的直方图等。

除了流行的开源版 TensorBoard，还有 TensorBoard.dev，它可以在托管服务器上免费使用。

TensorBoard.dev 允许你上传并与任何人分享你的 ML 实验结果。与 TensorBoard 相比，这是一个重要的升级，协作功能在那里是缺失的。

tensor board—摘要:

与处理图像相关的成熟功能
假设工具(WIT)，这是一个易于使用的界面，用于扩展对黑盒分类和回归 ML 模型的理解
提供社区支持的强大用户社区。

MLflow 与 TensorBoard

这两个工具都是开源的，在处理任何问题方面都受到各自社区的支持。主要区别似乎在于它们各自提供的功能范围。TensorBoard 被描述为 TensorFlow 的可视化工具包，因此它很好地服务于可视化，它允许您跟踪实验并比较它们(有限的功能)。另一方面，MLflow 被证明在 ML 生命周期的更多阶段是有用的。这两个工具都缺乏用户管理和团队共享功能(TensorBoard.dev 提供共享功能，但无法管理数据隐私)。

结论

MLflow 是一个很棒的工具，但是有一些它不具备的功能。所以有必要看看外面还有什么。在这个概述中，我们提到了 5 个可能是很好的替代工具，并检查了缺少的框。

如果你寻找 MLflow 替代品的主要原因是缺少协作和用户管理功能，你应该检查 Neptune、Weights & Biases、Comet 或 Valohai。如果您不想自己维护实验跟踪工具，所有这些工具都可以作为托管应用程序使用。

如果你想坚持使用开源工具，TensorBoard 可能是适合你的工具，但你应该记住，就功能而言，它不如 MLflow 先进。

最后，如果你不需要一个几乎覆盖整个 ML 生命周期的工具(像 MLflow 或者 Valohai)，我们推荐你去查 Neptune，Weight & Biases，或者 Comet。

在任何情况下，确保替代解决方案符合您的需求并改进您的工作流程。希望这篇文章能帮你找到。祝你好运！

最佳厚皮动物替代品

原文：https://web.archive.org/web/https://neptune.ai/blog/the-best-pachyderm-alternatives

Pachyderm 是一个数据科学平台，有助于控制端到端的机器学习生命周期。它有三个不同的版本，社区版(开源，可以在任何地方部署)、企业版(完整的版本控制平台)和中心版(托管版，仍处于测试阶段)。

简而言之，你可以对厚皮动物做些什么:

Pachyderm 允许您不断更新 repo 主分支中的数据，同时在单独的分支中试验特定的数据提交
它支持任何类型、大小和数量的文件，包括二进制和纯文本文件
您可以将提交的历史存储在一个集中的位置，这样当您尝试合并您的。git 历史与回购的主副本
集中式和事务性提交分支没有在源代码版本控制系统中广泛使用
出处使团队能够在彼此工作的基础上构建、共享、转换和更新数据集，同时自动维护完整的审计跟踪，以便所有结果都是可重复的

它无疑是一个 ML 实验的发电站，但如果你正在寻找一个更专注于机器学习项目的特定方面(生命周期的一部分)的不同解决方案，或者需要一个更轻量级的工具，Pachyderm 可能不是你的完美工具。

这就是我们需要帮助的地方——这里有所有最好的厚皮动物替代品。看一看，选择你最喜欢的替代品！

数据和管道版本控制

DVC，或数据版本控制，是一个机器学习项目的开源版本控制系统。这是一个实验工具，不管你使用什么语言，它都可以帮助你定义你的管道。

DVC–摘要:

可以使用不同类型的存储—不受存储限制
完整的代码和数据来源有助于跟踪每个 ML 模型的完整发展
通过始终如一地维护输入数据、配置和最初用于运行实验的代码的组合来实现可重复性
跟踪指标
一种将 ML 步骤连接到 DAG 并端到端运行整个管道的内置方式

Kubeflow 是 Kubernetes 的 ML 工具包。它有助于维护机器学习系统——管理所有的应用程序、平台和资源考虑事项。它通过使机器学习工作流的运行编排和部署更容易来促进机器学习模型的扩展。

这是一个开源项目，包含一组专门针对各种 ML 任务的兼容工具和框架。

kube flow–摘要:

用于管理和跟踪实验、作业和运行的用户界面(UI)
使用 SDK 与系统交互的笔记本电脑
重用组件和管道来快速创建端到端解决方案，而不必每次都重新构建
Kubeflow Pipelines 可作为 Kubeflow 的核心组件或独立安装使用

这是一个强大的软件，可以存储、检索和分析大量数据。Neptune 拥有高效团队协作和项目监督的所有工具。

海王星——概要:

为用户和组织管理提供不同的组织、项目和用户角色
快速美观的用户界面，具有多种功能来分组组织跑步，保存自定义仪表板视图并与团队共享
您可以使用托管应用程序来避免维护另一个工具的所有麻烦(或者将其部署在您的内部基础架构上)
您的团队可以跟踪在脚本(Python、R、other)、笔记本(local、Google Colab、AWS SageMaker)中执行的实验，并在任何基础设施(云、笔记本电脑、集群)上执行
广泛的实验跟踪和可视化功能(资源消耗、图像列表滚动)

MLflow 是一个开源平台，有助于管理整个机器学习生命周期，包括实验、再现性、部署和中央模型注册。

MLflow 适合个人和任何规模的团队。

该工具与库无关。你可以用任何机器学习库和任何编程语言来使用它

MLflow 包含四个主要功能:

ml flow Tracking——一个 API 和 UI，用于在运行机器学习代码时记录参数、代码版本、指标和工件，并在以后可视化和比较结果
MLflow 项目——将 ML 代码打包成可重用、可复制的形式，以便与其他数据科学家共享或转移到生产中
MLflow 模型——从不同的 ML 库中管理和部署模型到各种模型服务和推理平台
MLflow Model Registry–一个中央模型存储库，用于协作管理 ml flow 模型的整个生命周期，包括模型版本控制、阶段转换和注释

培训运行流程编排

SageMaker 是一个适合组织、训练、部署和管理机器学习模型的工具。它有一个基于 web 的可视化界面来执行所有 ML 开发步骤，包括笔记本、实验管理、自动模型创建、调试和模型漂移检测

亚马逊 SageMaker–摘要:

Autopilot 自动检查原始数据，应用功能处理器，挑选最佳算法集，训练和调整多个模型，跟踪它们的性能，然后根据性能对模型进行排序——它有助于部署性能最佳的模型
SageMaker Ground Truth 帮助您快速构建和管理高度准确的训练数据集
SageMaker Experiments 通过自动捕获输入参数、配置和结果，并将其存储为“实验”，来帮助组织和跟踪机器学习模型的迭代
SageMaker Debugger 在训练期间自动捕获实时指标(如训练和验证、混淆、矩阵和学习梯度)，以帮助提高模型准确性。当检测到常见的培训问题时，调试器还可以生成警告和补救建议
SageMaker Model Monitor 允许开发人员检测和排除概念漂移故障。它会自动检测已部署模型中的概念漂移，并给出详细的警报，帮助识别问题的根源

Polyaxon 是一个平台，用于复制和管理机器学习项目的整个生命周期，以及深度学习应用。

该工具可以部署到任何数据中心、云提供商，并且可以由 Polyaxon 托管和管理。它支持所有主要的深度学习框架，如 Torch、Tensorflow、MXNet。

说到流程编排，Polyaxon 允许您通过 CLI、dashboard、SDK 或 REST API 调度作业和实验，从而最大限度地利用集群。

poly axon–摘要:

支持整个生命周期，包括运行流程编排，但可以做的远不止这些
有一个开源版本，您可以立即使用，但也为企业提供了选项
文档非常完整的平台，包括技术参考文档、入门指南、学习资源、指南、教程、变更日志等等
使用实验洞察仪表板监控、跟踪和分析每个优化实验

包装它

为厚皮动物找到合适的替代品可能并不容易。每个工具都很棒，都提供有用的功能。但是一旦你知道你到底在找什么，你就会找到最合适的。尝试、混合和实验。毕竟这就是机器学习的意义所在。

快乐实验！

有哪些最好的、定期更新的机器学习博客或资源？

原文：https://web.archive.org/web/https://neptune.ai/blog/the-best-regularly-updated-machine-learning-blogs-or-resources

在机器学习中，如果你不发展，你迟早会被淘汰。这是一门困难且要求很高的学科，需要不断成长和拓展技能。

始终保持在最新机器学习趋势顶端的最好方法之一是关注专门针对这一特定专业的博客、论坛和网站。这是一个向他人学习的好方法，通常是向他们领域的知名专家学习，发现最新的发现和技巧，帮助你成为更好的数据科学家。

如果你正在寻找总是最新的最好的机器学习资源，一定要看看这个列表。你可以根据类别找到不同的资源。它们都包括人工智能、机器学习、IT、技术和通用数据科学等领域。

快速导航

" id": "block_5ecbb46dce2b8 "，" name ":" ACF/目录"，" data": { "title ":" "，" _title": "field_5e80aca602d23 "，" table _ of _ contents _ 0 _ name ":" Forums & communities "，" table _ of _ contents _ 0 _ name ":" field _ 5e 80 AC 1a 4d 87 b "，" table _ of _ contents _ 0 _ id _ section ":" 1 "，" _ table _ of _ of _ of _ of

论坛和社区

Reddit–Reddit 是机器学习、深度学习和数据科学领域最强大的知识来源。你可以找到许多有趣信息的不同线索，包括资源——网站、博客、人们面临的问题，以及常见困难的巧妙解决方案。试试这些线程，从 Reddit 中榨出你能榨出的一切: r/MachineLearning ， r/DeepLearning ， r/DataScience ， r/learnmachinelearning 。

Stack Overflow——这是一个开放的社区，面向那些毕生从事编码工作、寻找各种问题的答案或者只是喜欢搜索有趣线索的人。这是一个分享知识和发现新事物的绝佳平台。

Quora–Quora 是另一个人们寻求帮助或分享知识的论坛。它没有 Reddit 那么详细，但是你仍然可以用它来寻找一些有趣的资源。确保查看与机器学习相关的不同空间，以获取最新信息。

——有问题？卡格尔会帮你的。与 Kaggle 社区分享您的问题，您将会得到解决。Kaggle 提供了一个庞大的代码和数据存储库，让您的工作变得更加轻松。利用社区获得灵感、解决问题或发展技能。

**Jupyter 社区——使用 Jupyter 的人的社区，他们需要找到问题的解决方案，帮助其他人修复错误和问题，或者分享他们的工作。

DEV——软件开发者社区。用它来为你的困境、实验或分享你的知识找到解决方案。

ODS . ai–Open Data Science是一个出色的俄罗斯论坛，它将从事数据科学工作的研究人员、工程师和开发人员团结在一起。一个非常吸引人的地方，在这里你可以与其他人建立和改善关系，互相学习。

fast.ai——与 ods.ai 类似，fast . ai 是一个为想要学习、分享想法、与他人合作的人提供的地方。它为程序员提供免费课程、软件库、前沿研究和社区。

课程

——在这里，你可以找到数据科学领域的众多课程。GreyCampus 上的其他资源包括可以学习编码的 Codelabs，可以访问大型资源库的 OpenCampus，以及定期发布有趣文章的博客。

**Data flair——在这里，你会找到关于大数据的有用课程。DataFlair 是一个将培训课程与论坛、作业和测验相结合的平台。您还可以找到不同主题的有趣且广泛的博客帖子。

Coursera——在这个链接下，你会发现斯坦福大学提供的最受欢迎、评分最高的机器学习课程之一。Coursera 是一个广受欢迎的在线课程平台。你可以搜索它寻找其他有趣的课程来扩大你的知识面。

麻省理工学院开放式课程–开放式课程是一个免费开放的在线出版物，内容来自数以千计的麻省理工学院课程，涵盖了整个麻省理工学院的课程，从入门课程到最高级的研究生课程。你可以查看他们的 YouTube 频道寻找有用的视频。

edX–edX 是另一个提供有用课程的平台，在这里你可以获得认证。

哈佛在线课程——这是一个哈佛的网站，提供涵盖各种学科的优质课程。每个人都可以在这个知识来源中找到一些有帮助的东西。

斯坦福课程——如果你正在寻找斯坦福大学的机器学习课程，一定要查看他们网站上的在线培训片段。

数据科学道场—该平台提供在线和面对面的数据科学实践培训。他们的目标是教学生如何在运用课程中学到的概念和技术的同时，处理不同的商业问题并进行批判性思考。

Udemy 上的 机器学习课程——大量精选的在线视频课程，每月都有新内容发布。

博客和有用的网站

安德斯·平克——与其说是博客，不如说是产品。Anders Pink 提供了一个内容管理工具。

这是一个非常有用的工具，尤其是如果你没有太多时间在互联网上搜索相关文章，Anders Pink 有助于了解大数据的最新趋势内容。他们的人工智能算法可以学习你的偏好，为你和你的团队提供完全相关的内容。

Neptune . ai–浏览我们的网站，寻找感兴趣的东西。我们定期发布，让您了解机器学习领域正在发生的事情。学习并获得灵感！

机器学习博客——有见地的文章消磨一些空闲时间(如果你有的话)。

《科学日报》——科技行业所有最新研究新闻，而不仅仅是。

黑客正午——一个为科技爱好者提供轻松内容的独立科技媒体网站。

提炼——关于机器学习的最新文章。完全专业，适合要求最苛刻的数据科学家。

Medium 的机器学习供稿——在机器学习版块，来自世界各地的专家提供的有益有趣的文章。

跳板博客——在他们的博客上，跳板写了关于数据科学、机器学习和其他相关话题。

OpenAI 博客–open ai 是一家位于加州三藩市的研究实验室。他们提供全面的人工智能资源——博客、研究论文和有趣的文章。每样东西都是他们领域的专家提供的最新信息。

谷歌人工智能博客——来自谷歌研究人员和工程师的所有最新更新。在博客上，你可以看到谷歌是如何将人工智能和人工智能技术融入其产品的。

KD nuggets——人工智能、分析、大数据、数据挖掘、数据科学和机器学习领域的领先网站。Gregory Piatetsky-Shapiro 和 Matthew Mayo 编辑。

拜尔——伯克利人工智能研究。BAIR 博客为 BAIR 的研究人员提供了一个可访问的、面向大众的媒介，以交流研究发现、该领域的观点和各种更新。帖子由 BAIR 的学生、博士后和教师撰写，旨在为专家和普通观众提供相关和及时的研究发现和结果的讨论。在 BAIR 学习的各种主题的帖子大约每两周会在出现一次。

Salmon Run——一系列关于应用程序开发和系统设计的文章、技巧和随想。

【deep mind】——一些关于公司最新消息及其成就的有趣文章。

奥赖利–奥赖利的博客值得关注，因为他们发表了关于让数据发挥作用的想法、信息和工具的高质量文章。

黑客新闻——你想知道却不敢问的一切。由 Y Combinator 提供的全面的主题来源。

Flipboard——Flipboard 聚集的无数关于机器学习的文章。

人工律师——一个对从事法律工作的人有用的博客。通过这个博客，你可以了解与法律相关的最新技术趋势，以及如何实现法律机构工作的自动化。

**Lionbridge–Lionbridge 定期发布涵盖机器学习或人工智能等主题的文章。

谷歌新闻——获取所有来自机器学习世界的最新热点新闻。

走向数据科学——围绕数据科学、机器学习、人工智能、编程等有趣话题，更多帮助你学习和发展技能。

SPD 集团博客——关于机器学习行业的真知灼见文章。

研究论文和学术资源

麻省理工新闻——直接来自 MIT(麻省理工学院)来自机器学习世界的所有最新新闻。

——让你探索科学、技术和医学研究。

**Nature.com——关于机器学习的有趣研究。

——学术界让人们与在机器学习领域工作的其他人分享他们的研究论文。

**带代码的论文——一个免费开放的资源，里面有机器学习的论文、代码、评估表。

【arXiv】——一项免费的分发服务和一个开放的档案库，提供物理、数学、计算机科学领域的学术文章。

牛津大学——牛津大学的研究论文。

CIT——加州理工学院的研究论文。

Machine Learning @ Berkley-加州大学伯克利分校的一个学生管理的组织，致力于工业和学术研究领域的人工智能应用，并使人工智能教育更容易为所有人所接受。

其他资源

The Batch——来自 deeplearning.ai 的每周时事通讯，Batch 以精心策划、易于阅读的报告形式，为工程师和商业领袖呈现最重要的人工智能事件和观点。每周三，这一批文章会重点介绍最实用的研究论文、塑造行业的应用程序和影响力大的商业新闻。

书籍——如果你是个书虫，你可以在亚马逊上搜索，找到一本你感兴趣的书。

——伊恩·古德菲勒、约舒阿·本吉奥和亚伦·库维尔的麻省理工出版社书籍。深度学习教材是一本免费的在线书籍。它旨在帮助学生和从业者进入机器学习领域，特别是深度学习领域。也可以在亚马逊上订购。

****《数据科学周刊》**-免费的每周时事通讯，提供与数据科学相关的精选新闻、文章和工作。一定要订阅！

Data Elixir——一份免费的每周时事通讯，提供来自网络的顶级数据科学精选。涵盖机器学习、数据可视化、分析和策略。绝对值得订阅！

把它包起来

你能在这个列表上找到的所有东西都是根据受欢迎程度和用户推荐挑选出来的。

我会不断更新列表中有用的链接，这样你就能掌握机器学习的最新消息。如果你认为某些东西应该被包含或排除，一定要留下评论。分享你的观点，我很想听听你的意见！**************

最好的神圣+全方位的选择

原文：https://web.archive.org/web/https://neptune.ai/blog/the-best-sacred-omniboard-alternatives

在本帖中，我们将向你展示神圣+全能的最佳替代方案。既然您看到了这篇文章，您可能已经知道这些工具的用途了。但是让我们简短地分析一下，因为这可能有助于更好地定义您的需求，并为您选择最佳的替代方案。

提到一个工具而不提到另一个工具是一种罪过。那是因为他们有点合作。

让我们从神圣开始。Sacred 是瑞士人工智能实验室 IDSIA (Dalle Molle 人工智能研究所)开发的一款工具，可以帮助配置、组织、记录和复制实验。

这里的神圣简单来说就是:

跟踪使用任何 Python 库开发的任何模型训练
从每个功能访问配置的所有参数
您可以使用强大的命令行界面:对于每个实验，您可以使用它来更改参数和运行不同的变体
为各种数据库后端提供“观察者”,这些后端记录关于实验、其依赖项、使用的配置、运行它的机器以及结果的各种信息。这些可以保存到 MongoDB、文件系统、托管的实验跟踪工具和其他东西中
自动播种有助于控制实验中的随机性，从而保持结果的可重复性
没有自带合适的 UI，但是有一些 dashboarding 工具可以连接到它(比如 Omniboard)。

现在，让我们来看看 Omniboard。Omniboard 是一个神圣的网络仪表板。它连接到 Sacred 使用的 MongoDB 数据库，并帮助可视化实验和为每个实验收集的指标/日志。Omniboard 是用 React，Node.js，Express，Bootstrap 写的。

这里是对你能用 Omniboard 做什么的一个简短概述:

您可以访问实验管理功能，例如以可定制的表格格式列出所有实验运行
您可以在 UI 中比较实验
您可以访问实验的详细数据(度量图、源文件、工件、git 散列/版本控制信息等等)
仅支持连接到 MongoDB >= 4.0

这两个是一个伟大的组合，但有时，这是不够的，或者你可能只是不喜欢它。有一种方法可以组合工具或者用更适合你的解决方案来代替它们。你只需要知道外面有什么。以下是最好的神圣+全能替代品。让我们深入了解一下。

全方位替代方案

Omniboard 是神圣(这是一个实验数据库)的主要前端(UI)。但是您可以使用其他选项，尤其是如果您想要更大的灵活性。

有些人可能想继续使用神圣的日志 API，但是使用其他的 UI。这里有两个很好的选择。

Neptune 是为运行大量实验的研究和生产团队构建的 MLOps 的元数据存储。Neptune 提供了一个开源的 Python 库，允许用户记录任何实验，因此它不局限于深度学习。

Neptune 中的项目可以有多个角色不同的成员(查看者、贡献者、管理员)，因此所有登陆 Neptune 的机器学习实验都可以被每个团队成员查看、共享和讨论。Neptune 旨在提供一种易于使用和快速学习的方法来跟踪 ML 生命周期中生成的所有元数据。

海王星适合任何工作流程，并提供了很大的灵活性。说到神圣， Neptune 拥有神圣的集成，用自己的观察者取代了 Omniboard 和 MongoDB 后端。通过集成，您可以记录神圣的实验，并直接在 Neptune 中管理它们:

您不必设置数据库，
您的所有数据都记录到云中，或者，如果您愿意，也可以记录到本地
你所要做的就是简单地将 NeptuneObserver 添加到实验中:

ex = Experiment('image_classification', interactive=True)

ex.observers.append(NeptuneObserver(run=neptune_run))

就像 Omniboard 一样，Sacredboard 是一个神圣的网络仪表板。它可以让你访问和监控你过去所有的 ML 实验。

该工具连接到由 Sacred 使用的 MongoDB 数据库，并显示实验列表、它们的状态、Sacred 配置和运行程序的标准输出。

如果你想让它正常工作，你需要 Python 3.5 和一个现代化的网络浏览器。

与 Omniboard 相比，它的功能可能有点有限，因为它的改进是一个缓慢的过程。但是如果你正在寻找一个不同的解决方案，你会发现圣木板足够了。

以下是的一些主要特点:

您可以直接从 web 控制台运行 Tensorboard 来查看详细信息、图表和 Tensorflow 图形可视化
你可以过滤实验
您可以在表格中了解正在进行的和已完成的实验的概况

神圣的选择

神圣和 Omniboard 是很好的组合，但是你也可以完全替换神圣，使用不同的日志 API。看看这两个例子。

MLflow 是一个开源平台，有助于管理整个机器学习生命周期——实验、再现性、部署和中央模型注册。

该工具与库无关。你可以用任何机器学习库和任何编程语言来使用它。

ml flow—摘要:

您可以在运行机器学习代码时记录参数、代码版本、指标和工件，以便以后可视化和比较结果
可重复使用、可复制的 ML 代码打包形式允许您与其他数据科学家共享它或将其转移到生产中
您可以从不同的 ML 库中管理和部署模型到各种模型服务和推理平台
中央模型存储允许您协作管理 MLflow 模型的整个生命周期，包括模型版本控制、阶段转换和注释

Guild AI 是一个运行、跟踪和比较实验的工具。Guild AI 是跨平台和框架独立的——你可以使用任何库用任何语言训练和捕捉实验。公会人工智能运行你未修改的代码，所以你可以使用你想要的库。该工具不需要数据库或其他基础设施来管理实验，简单易用。

帮会 AI–总结:

让您跟踪任何模型训练和任何编程语言的实验
拥有自动化的机器学习流程
与任何语言和库集成
远程培训和备份的可能性
你可以复制你的结果或重现实验

把它包起来

在神圣+ Omniboard 中进行机器学习实验肯定是高效的。但是结合不同的工具会给你更多的灵活性和自由，这样你就可以在工作中获得最好的效果。尝试不同的组合是值得的，这样你就可以坚持最有效的组合。

我们希望你能找到感兴趣的东西。快乐实验！

最佳的冲浪板替代品

原文：https://web.archive.org/web/https://neptune.ai/blog/the-best-tensorboard-alternatives

TensorBoard 是 TensorFlow 的开源可视化工具包，可以让您分析模型训练运行。它允许您跟踪和可视化机器学习实验的各个方面，如度量或模型图，查看张量的权重和偏差直方图等。

为此，TensorBoard 符合对工具的持续需求的趋势，以跟踪和可视化机器学习实验。虽然它可以让你深入研究实验，但有一些 TensorBoard 没有的功能，这些功能在实验跟踪过程中非常有用。

使用 TensorBoard 时，您可能面临的主要挑战包括:

TensorBoard 在更多的实验中没有很好地扩展；
当你想比较多次运行时，用户体验远非完美；
TensorBoard 在本地工作，所以当你在不同的机器上操作时，很难跟踪所有的事情；
与他人分享结果是一件痛苦的事情——你只需要找到一个解决方法(比如截图)，因为没有现成的解决方案。

总的来说，当你刚刚开始实验跟踪和可视化，或者你没有运行大量实验时，TensorBoard 似乎是一个很好的工具。用 TensorFlow 训练的时候也很方便(不然没那么好设置)。但是，它不如市场上的其他工具先进，并且不能在团队环境中提供最佳体验。

如果你在 TensorBoard 工作时遇到了这些问题中的任何一个，或者只是想看看外面还有什么，那么你来对地方了。

以下是你应该看看的 TensorBoard 的最佳选择:

海王星
公会 AI
神圣的
权重&偏差
彗星

https://web.archive.org/web/20221208211451im_/https://neptune.ai/wp-content/uploads/Example-dashboard-metadata-structure.mp4

Source

Neptune 是为进行大量实验的研究和生产团队构建的 MLOps 的元数据存储库。

它为您提供了一个记录、存储、显示、组织、比较和查询所有模型构建元数据的单一位置。这包括指标和参数，还包括模型检查点、图像、视频、音频文件、数据版本、交互式可视化、和更多。您还可以创建包含所有这些元数据的定制仪表板，并与您的同事、团队经理甚至外部利益相关者共享它们。以下是这种仪表板的一个示例:

如果你在团队中工作，海王星是完美的。它允许您与多个团队成员一起创建项目，管理用户访问，共享工作，并将所有结果备份在一个位置。

评估模型和比较运行也很容易，因为有四种不同的比较视图可用——图表、平行坐标、并排表格仪表板和工件比较部分。

海王星——概要:

通过成千上万次运行进行扩展——无论您有 5 次还是 100 次实验，Neptune 都能提供同样出色的用户体验；
UI 很干净，易于导航，非常直观；
在本地版本中可用，但也作为托管的应用；
快速简单的设置和出色的客户支持；
团队中的协作受到多种特性的有力支持。

如果你想看海王星在行动，检查这个现场笔记本或这个例子项目(不需要注册)，只是玩它。

TensorBoard vs 海王星

TensorBoard 是一个开源工具，可以帮助跟踪和可视化 ML 运行。另一方面，Neptune 是一个托管解决方案，它在实验跟踪领域提供了更多的特性，并且还提供了模型注册、模型监控和数据版本控制功能。Neptune 支持团队协作，比 TensorBoard 更具可扩展性。

检查 TensorBoard 和 Neptune 之间的深度比较。

阅读 InstaDeep 的案例研究，了解他们为什么从 TensorBoard 转行到 Neptune。

这是一个开源的机器学习平台，用于运行和比较模型训练例程。

它主要是一个 CLI 工具，让你以系统的方式运行和比较训练作业，而 Guild AI 则捕获源代码、日志和生成的文件。

与 TensorBoard 不同，它不限于 tensor flow/深度学习工作。相反，Guild AI 是平台和编程语言不可知的，所以你可以在你当前的技术栈中自由使用它。

如果你是一个 CLI 爱好者，这可以成为你的一个工具，大多数使用是通过终端中的命令。

帮会 AI——总结:

实验跟踪:任何模型训练，任何编程语言
在团队中共享工作:不支持
与其他工具集成:不支持
SaaS/本地实例是否可用:否/是
奖励:准备充分的文档

TensorBoard vs 公会 AI

公会 AI 的范围比 TensorBoard 的要广得多。Guild AI 允许您跟踪实验、调整超参数、自动化管道等，而 TensorBoard 主要用于跟踪和可视化运行。公会人工智能可以运行在任何云或本地环境。另一方面，TensorBoard 是本地托管的。

研究机构 IDSIA (瑞士人工智能实验室)开发的另一个开源工具。Sacred 是一个 Python 库，帮助配置、组织、记录和复制实验。

Sacred 提供了一种使用配置的编程方式。观察者的概念允许用户跟踪与实验相关的各种类型的数据。

神圣的一个好处是它有自动播种功能——在需要重现实验时非常有用。

与 TensorBoard 不同——与本次比较中的工具相似 Sacred 的优势在于它能够跟踪用任何 Python 库开发的任何模型训练。

神圣——摘要:

实验跟踪:任何模型训练
在团队中共享工作:不支持
与其他工具集成:不支持
SaaS/本地实例是否可用:否/是

注意:神圣没有自带合适的用户界面，但有一些你可以连接到它的仪表板工具，如 Omniboard，Sacredboard，或 Neptune via integration 。

TensorBoard vs 神圣

TensorBoard 和 Sacred 都是开源的，适合相当不高级的项目(就可伸缩性而言)。TensorBoard 附带了 UI，而您需要将神圣与仪表板工具配对，因此 TensorBoard 附带了更好的开箱即用可视化功能。

WandB 专注于深度学习。用户使用 Python 库跟踪应用程序的实验，并且作为一个团队，可以看到彼此的实验。

与 TensorBoard 不同，WandB 是一种托管服务，允许您在一个地方备份所有实验，并与团队合作完成一个项目——可以使用工作共享功能。

与 TensorBoard 类似，在 WandB 中，用户可以记录和分析多种数据类型。

权重&偏差—汇总:

实验跟踪:任何模型训练
团队共享工作:团队共享的多种特性。
与其他工具的集成:几个可用的开源集成
SaaS/本地实例可用:是/是
额外的好处:WandB 记录了模型图，因此您可以在以后检查它。

张量板与重量和偏差

第一个，TensorBoard 是一个本地运行的开源工具。WandB 提供的托管服务既可以在内部部署，也可以在云中运行。这里，Weight & Biases 提供了比 TensorBoard 更广泛的功能，包括实验跟踪、数据集版本化和模型管理。除此之外，WandB 还有很多支持团队协作的功能，这是 TensorBoard 所没有的。

Comet 是一个元机器学习平台，用于跟踪、比较、解释和优化实验和模型。

就像许多其他工具一样——例如 Neptune 或 WandB——Comet 提出了一个开源的 Python 库，允许数据科学家将他们的代码与 Comet 集成，并开始在应用程序中跟踪工作。

由于它提供云托管和自托管，用户可以有团队项目，并保存实验历史的备份。

Comet 正在通过预测性早期停止(免费版软件不提供)和神经结构搜索(未来)向更自动化的 ML 方法靠拢。

彗星—摘要:

实验跟踪:任何模型训练
团队共享工作:团队共享的多种特性。
与其他工具的集成:应该由用户手动开发
SaaS/本地实例可用:是/是
额外收获:显示平行图来检查参数和指标之间的关系模式。

张量板 vs 彗星

Comet 是一种托管服务，可以在内部提供，也可以作为托管应用程序提供。TensorBoard 是一个开源的可视化和跟踪工具，可以在本地使用。虽然 Comet 旨在使数据科学家能够在整个模型生命周期(从研究到生产)中建立更好的模型，但 TensorBoard 专注于实验阶段。

总结一下

第一次寻找实验追踪和可视化工具时，TensorBoard 往往似乎是一个不错的选择。它是开源的，提供了所有必要的特性。但是你越是使用它，你的需求就越是增长，你就会注意到一些缺失的部分。这就是为什么最好检查一下还有什么可用的工具，看看其他工具是否能在您的需求列表上勾选更多的框。

如果你是这种情况——你正在寻找一个更先进的工具，类似于使用 TensorBoard 后的下一步——我们建议检查 Neptune 或 Weights & Biases。这些都是出色的托管服务，具有大量功能和团队协作能力。如果你只是想切换到另一个开源解决方案，神圣的可能是正确的选择。

不管你的动机是什么，希望你在这里找到了一些值得检查的 TensorBoard 替代品，我们帮助你做出正确的选择！

机器学习模型可视化的最佳工具

原文：https://web.archive.org/web/https://neptune.ai/blog/the-best-tools-for-machine-learning-model-visualization

“每个模型都是错的，但有些是有用的”这句话在机器学习中尤其成立。在开发机器学习模型的时候，你要时刻明白它在哪里按预期工作，在哪里惨败。

理解模型的一个重要方法是通过模型可视化。可视化模型架构对于以下方面非常重要:

模型可解释性
结果解释
模型调试
模型比较

阅读有关模型可视化的更多信息

一旦你对一个模型有了一定的了解，你就很棒了，对吗？错误的🙂

通常，你需要做一些或者很多模型改进想法的实验，并且可视化不同 ML 实验之间的差异变得至关重要。

有许多方法可以让你理解这一点:

查看评估指标(此外，您应该知道如何为您的问题选择评估指标
看看性能图表，如 ROC、升力曲线、混淆矩阵等
查看学习曲线以估计过度拟合
查看最佳/最差情况下的模型预测
看看模型训练和推理的资源密集程度(它们转化为严重的成本，并且对业务方面的事情至关重要)
使用模型解释工具和技术来审查预测(进一步阅读)

你可以自己完成所有这些(或者大部分)，但是今天有一些工具你可以使用。如果你正在寻找能够帮助你可视化机器学习实验和模型的最佳工具，那么你来对地方了。

机器学习实验可视化工具

*Example of model training metadata displayed in a dashboard | *See in the app

Neptune 是 MLOps 的元数据存储库，为运行大量实验的团队而构建。‌它为您提供了一个单一的位置来记录、存储、显示、组织、比较和查询您所有的模型构建元数据。

海王星是用 for:‌

实验跟踪:在一个地方记录、显示、组织和比较 ML 实验。
模型注册:对训练好的模型和建模元数据进行版本化、存储、管理和查询。
实时监控 ML 运行:实时记录和监控模型培训、评估或生产运行。

海王星如何帮助你可视化实验和模型？

记录任何元数据类型，包括参数和指标，以及丰富的对象，如图像、视频、音频和交互式可视化。
可视化记录的元数据并以首选方式分析结果——以运行表、图表、仪表板或文件夹结构的形式。
使用智能对照表对比多次运行的超参数和指标，该对照表突出显示了不同之处。
查看不同的参数和配置如何影响结果，并调试和优化模型。
自动监控硬件利用率 (GPU、CPU、内存)。
注册模型和与之相关的元数据。

Weights & Biases 是一个机器学习平台，供开发人员更快地建立更好的模型。它可以让您快速跟踪实验、对数据集进行版本控制和迭代、评估模型性能、重现模型、可视化结果和发现回归，并与同事分享发现。

权重&偏差如何帮助你可视化实验和模型？

监控训练运行信息，如损失、准确性(学习曲线)
查看权重和偏差(没有双关语)或梯度的直方图
在培训期间记录丰富的对象，如图表、视频、音频或交互式图表
使用各种比较工具，如显示自动差异的表格、平行坐标图等
交互式预测对象检测模型的包围盒可视化
交互式预测掩码语义分割模型的可视化
可视化实时指标，如 GPU 和 CPU 利用率
构建数据集依赖关系图
可视化参数重要性

Comet 是一个元机器学习平台，用于跟踪、比较、解释和优化实验和模型。它还允许您实时监控、检测和警报以及调试生产模型。您还可以基于实验和模型数据构建自己的或使用社区提供的自定义可视化和应用程序。

彗星如何帮助你可视化实验和模型？

使用视觉、音频、文本和表格数据的专用模块可视化样本，以检测过度拟合并轻松识别数据集的问题
您可以自定义和组合您的可视化
你可以监控你的学习曲线
Comet 灵活的实验和可视化套件允许您记录、比较和可视化许多工件类型
构建您自己的或使用社区构建的“面板”来可视化您的模型和实验
实时监控生产模型

TensorBoard 提供了机器学习实验所需的可视化和工具。它是开源的，为机器学习模型的可视化和调试提供了一套工具。TensorBoard 是市场上最受欢迎的解决方案；因此，它与许多其他工具和应用程序广泛集成。

更重要的是，它有一个广泛的工程师网络使用这个软件，分享他们的经验和想法。这使得一个强大的社区准备解决任何问题。然而，该软件本身最适合个人用户。

TensorBoard 如何帮助你可视化实验和模型？

跟踪和可视化损失和准确性等指标
可视化模型图(操作和层)
查看权重、偏差或其他张量随时间变化的直方图
将嵌入投影到低维空间
显示图像、文本和音频数据
剖析张量流程序

5.神圣+全能

神圣+ Omniboard 堆栈实际上由两个开源组件组成——Sacred，一个实验管理工具，和 Omniboard，一个神圣的网络仪表板。神圣记录实验数据到 MongoDB 后端，Omniboard 连接到这个后端来可视化实验。

神圣给你一个强大的命令行界面，观察员记录实验信息，并自动播种控制实验的随机性，使结果是可重复的。Omniboard 通过它的一套实验管理、深入研究和比较功能对此进行了补充。

神圣+ Omniboard 如何帮助你可视化实验和模型？

神圣的 CLI 可用于更新参数和运行同一实验的不同变体
在 MongoDB 数据库中保存实验配置
在 Omniboard 仪表板上比较不同的实验
上滚或下钻实验，以查看集合或单个细节

MLflow 是一个管理端到端机器学习生命周期的开源平台。它是目前使用最广泛的 ML 实验跟踪器，因此得到了各种语言、框架和平台的广泛支持。MLflow 支持通过 Python、R、Java 和 REST APIs 进行日志记录。

作为一个开源项目，MLflow 个人使用没有直接成本。然而，如果您希望使用 MLflow 在大型团队之间进行协作，基础设施成本将会增加，因为您需要拥有自己的远程跟踪服务器。Databricks 的托管 MLflow 为您提供托管服务。

ml flow 如何帮助你可视化实验和模型？

对照表:ML 实验可视化工具

实验跟踪是所有上述产品的核心用例，因此，大多数产品都提供类似的功能。但是，有些功能并非所有工具都支持。下表强调了上述工具在功能上的一些差异。

海王星

W&B

彗星

张量板

神圣+全能

MLflow

Sacred + Omniboard:

计算机编程语言

可以汇总记录的指标吗？

可以记录硬件消耗吗？

用于实验比较的表格格式差异？

实验参数分组依据？

平行坐标图？

MLflow:

仅在托管版本中

数据的并排比较？

Neptune:

图像、表格、文本

W&B:

音频、HTML、图像、表格、文本、视频

Comet:

绘图、表格、文本

机器学习模型可视化工具

dtreeviz 是一个用于决策树可视化和模型解释的 python 库。目前支持 scikit-learn 、 XGBoost 、 Spark MLlib 和 Lig htGBM 树。从 1.3 版本开始，还支持任何具有 predict_proba()的模型的特征空间插图。

dtreevix 如何帮助您可视化模型？

可视化基于树的模型
说明支持的分类器的特征空间
突出显示树中单个观察值的预测路径，并获得相同的简单英语解释
可视化叶片指标，如纯度、样品和目标分布
在特征空间中可视化分类边界。

Netron 可用于生成神经网络模型的交互式可视化。它以 Python 包、独立应用程序和浏览器应用程序的形式提供。

Netron 如何帮你可视化模型？

生成神经网络的交互式可视化
展开节点以查看图层详细信息
支持几乎所有广泛使用的框架
无需安装即可使用浏览器应用

NN-SVG 是一个托管应用程序，用于参数化而非手动创建神经网络(NN)架构图。它还提供了将这些绘图导出到可缩放矢量图形(SVG)文件的能力，适合包含在学术论文或网页中。

NN-SVG 如何帮助你可视化模型？

完全托管的应用程序，无需安装
支持 FCNN、LeNet 和 AlexNet 样式
高度可定制
将生成的原理图导出为 SVG 图像

TensorBoard 主要是一个实验可视化工具，但它也显示 TensorFlow 模型的模型图。

tensor board 如何帮助你可视化模型？

可视化张量流模型图
跟踪和记录张量流实验
提供了一个完全管理的版本—tensor board . dev——它允许您托管、跟踪和共享您的 ML 实验

摘要

在这篇博客中，我们介绍并比较了一些目前最流行的模型和可视化工具。与 ML 领域的大多数工具一样，没有一种工具是万能的，使用哪种工具在很大程度上取决于您的具体用例。

您希望可视化什么样的模型？你可视化的目的是什么？

大多数模型可视化工具都是针对特定的架构和用例而构建的。

对于基于树的模型， dtreeviz 是一个不错的选择。
TensorBoard 与 Tensorflow/Keras 模型集成得非常好。
如果你只是想为你的神经网络模型创建一个非交互式的可视化的例子， NN-SVG 可能会节省你一些时间。
Netron 制作详细的神经网络模型的交互式可视化，这对调试和优化有很大帮助。

你是一个预算有限的小团队吗？

如果是的话，一些开源和免费工具可能是不错的开始。但是，请记住，随着您的团队的增长，您的自托管成本也会增长。您也可以考虑定价不取决于用户数量的 SaaS 解决方案(例如 Neptune)。这样，当你的需求增加时，你会有更好的准备。

您是一个寻求协作开发的大型团队吗？

大多数 SaaS 解决方案具有丰富的协作功能，如基于 URL 的共享、协作仪表板、报告、用户管理等。

无论如何，希望这篇文章能帮助你做出选择，你会找到你一直在寻找的东西。

快乐观想！

西达丹·萨达特

我目前是 Neptune.ai 的一名开发人员，我坚信最好的学习方式是边做边教。

阅读下一篇

ML 实验跟踪和管理的 15 个最佳工具

10 分钟阅读|作者 Patrycja Jenkner |年 8 月 25 日更新

在进行机器学习项目时，从单次模型训练中获得好的结果是一回事。但是，让你所有的机器学习实验保持良好的组织，并有一个让你从中得出有效结论的过程，则完全是另一回事。

这些需求的答案就是实验追踪。在机器学习中，实验跟踪是保存所有实验相关信息的过程，这些信息是你在每次实验中所关心的。

ML 团队以不同的方式实现实验跟踪，可能是通过使用电子表格、GitHub 或自建平台。然而，最有效的选择是使用专门为跟踪和管理 ML 实验而设计的工具。

在这篇文章中，我们概述并比较了 15 个最好的工具，它们可以让你跟踪并管理你的 ML 实验。你将了解它们的主要特征，并看到它们之间的不同之处。希望这将有助于您评估它们，并根据您的需求选择合适的产品。

如何评价一个实验跟踪工具？

“最好的实验跟踪工具是什么？”这个问题没有答案。当你单独工作或在团队中工作时，你的动机和需求可能完全不同。根据您的角色，您可能会寻找各种功能。

如果你是数据科学家或研究人员，你应该考虑:

如果该工具带有 web 用户界面或基于控制台；
如果您能够将该工具与您首选的模型培训框架相集成；
您可以记录、显示和比较哪些元数据(代码、文本、音频、视频等。);
你能容易地比较多次跑步吗？如果是，以什么格式——只有表格，还是还有图表；
如果通过实验来组织和搜索是用户友好的；
如果您可以自定义元数据结构和仪表板；
如果该工具让您跟踪硬件消耗；
与其他团队成员合作有多容易——你能分享一个实验的链接吗，或者你必须使用截图作为解决方法？

作为一名 ML 工程师，你应该检查这个工具是否让你:

轻松重现和重新运行实验；
跟踪和搜索实验谱系(下游使用的数据/模型/实验)；
保存、获取和缓存实验数据集；
将它与您的 CI/CD 渠道集成；
轻松地与同事协作和共享工作。

最后，作为一名 ML 团队领导，你会对以下内容感兴趣:

一般业务相关的东西，如定价模型、安全性和支持；
该工具需要多少基础设施，将其集成到您当前工作流的难易程度；
产品是作为商业软件、开源软件还是托管云服务交付的？
它具有什么样的协作、共享和审阅功能。

在回顾市场上的工具时，我确保牢记这些动机。所以让我们仔细看看它们。

Continue reading ->

Python 中强化学习的最佳工具是你真正想尝试的

原文：https://web.archive.org/web/https://neptune.ai/blog/the-best-tools-for-reinforcement-learning-in-python

如今，深度强化学习 (RL)是数据科学界最热门的话题之一。快速开发的快速发展导致了对易于理解和方便使用的快速开发工具的需求不断增长。

近年来，大量的 RL 库被开发出来。这些库被设计成拥有实现和测试强化学习模型的所有必要工具。

尽管如此，他们还是有很大的不同。这就是为什么选择一个快速、可靠、与你的 RL 任务相关的库是很重要的。

在本文中，我们将涵盖:

选择深度强化学习库的标准，
RL 库: Pyqlearning ， KerasRL ， Tensorforce ，RL _ 蔻驰， TFAgents ， MAME RL ， MushroomRL 。

用于强化学习的 Python 库

有很多 RL 库，因此为您的情况选择正确的库可能是一项复杂的任务。我们需要形成标准来评估每个库。

标准

本文中的每个 RL 库都将基于以下标准进行分析:

实施的最先进的(【SOTA】)RL 算法的数量——我认为最重要的一个
官方文档、简单教程和示例的可用性
易于定制的可读代码
支持环境的数量——这是强化学习库的关键决定因素
记录和跟踪工具支持——例如 Neptune 或 TensorBoard
矢量化环境 ( VE )特征——进行多进程训练的方法。使用并行环境，你的代理将会经历比单一环境更多的情况
定期更新–RL 发展非常迅速，您希望使用最新技术

我们将讨论以下库:

角膜的

KerasRL 是一个深度强化学习 Python 库。它实现了一些最先进的 RL 算法，并与深度学习库 Keras 无缝集成。

此外， KerasRL 与 OpenAI Gym 开箱即用。这意味着你可以很容易地评估和使用不同的算法。

要安装 KerasRL ，只需使用一个 pip 命令:

pip install keras-rl

让我们看看 KerasRL 是否符合标准:

实施的 SOTA RL 算法的数量

到今天为止，KerasRL 已经实现了以下算法:

深度 Q-Learning ( DQN )及其改进(双和对决)
深度确定性政策梯度 ( DDPG )
连续 DQN ( CDQN 或 NAF )
交叉熵方法 ( CEM )
深 SARS

你可能已经注意到了， KerasRL 忽略了两个重要因素:行动者批评方法和邻近政策优化(PPO)。

官方文档、教程和示例的可用性

代码很容易阅读，并且充满了注释，这非常有用。尽管如此，文档似乎不完整，因为它错过了参数和教程的解释。此外，实际例子也有许多不足之处。

易于定制的可读代码

非常容易。您需要做的就是按照示例创建一个新的代理，然后将其添加到 rl.agents 。

支持的环境数量

KerasRL 被要求只与开放健身馆合作。因此，如果要使用任何其他环境，您需要修改代理。

日志和跟踪工具支持

未实现日志和跟踪工具支持。不过，你可以用 海王星来追踪你的实验。

矢量化环境特征

包括矢量化的环境特征。

定期更新

该库似乎不再维护，因为上次更新是在一年多以前。

综上所述， KerasRL 有一套很好的实现。不幸的是，它错过了有价值的点，如可视化工具，新的架构和更新。你应该使用另一个图书馆。

Pyqlearning

Pyqlearning 是实现 RL 的 Python 库。重点介绍了 Q-Learning 和多智能体深度 Q-Network。

Pyqlearning 为设计师提供组件，而不是为最终用户提供最先进的黑匣子。因此，这个库很难使用。你可以用它来设计信息搜索算法，比如 GameAI 或者 web crawlers。

要安装 Pyqlearning ，只需使用一个 pip 命令:

pip install pyqlearning

让我们看看 Pyqlearning 是否符合标准:

实施的 SOTA RL 算法的数量

到今天为止，Pyqlearning 已经实现了以下算法:

深度 Q 学习 ( DQN )及其改进(ε贪心和玻尔兹曼)

您可能已经注意到， Pyqlearning 只有一个重要的代理。这个图书馆还有许多需要改进的地方。

官方文档、教程和示例的可用性

Pyqlearning 有几个不同任务的例子和两个由 Deep Q-Network 开发的迷宫解决和追逃游戏教程。你可以在官方文件中找到它们。文档似乎不完整，因为它关注的是数学，而不是库的描述和使用。

易于定制的可读代码

Pyqlearning 是一个开源库。源代码可以在 Github 上找到。代码缺少注释。定制它可能是一项复杂的任务。不过，教程可能会有所帮助。

支持的环境数量

因为这个库是不可知的，所以添加到任何环境都相对容易。

日志和跟踪工具支持

作者在教程中使用了一个简单的日志包。 Pyqlearning 不支持其他测井和跟踪工具，例如 TensorBoard 。

矢量化环境特征

Pyqlearning 不支持矢量化环境功能。

定期更新

图书馆得到了维护。最后一次更新是在两个月前。尽管如此，开发过程似乎是一个缓慢的过程。

总而言之，学习还有许多不足之处。这不是一个你通常会用到的库。因此，您可能应该使用其他东西。

张量力

Tensorforce 是一个基于谷歌 Tensorflow 框架构建的开源深度 RL 库。它的用法很简单，有可能成为最好的强化学习库之一。

Tensorforce 拥有与其他 RL 库不同的关键设计选择:

基于组件的模块化设计:最重要的是，功能实现往往尽可能地具有通用性和可配置性。
RL 算法与应用的分离:算法不知道输入(状态/观察)和输出(动作/决策)的类型和结构，以及与应用环境的交互。

要安装 Tensorforce ，只需使用一个 pip 命令:

pip install tensorforce

让我们看看 Tensorforce 是否符合标准:

实施的 SOTA RL 算法的数量

截至今天， Tensorforce 已经实施了以下算法:

深度 Q-Learning ( DQN )及其改进(双和对决)
香草政策梯度 ( PG
深度确定性政策梯度 ( DDPG )
连续 DQN ( CDQN 或 NAF )
演员评论家 ( A2C 和 A3C )
信任区域政策优化 ( TRPO
近端策略优化 ( PPO )

你可能已经注意到了， Tensorforce 错过了软演员评论家 ( SAC )实现。此外，它是完美的。

官方文档、教程和示例的可用性

由于有各种简单的例子和教程，开始使用 Tensorforce 非常容易。官方文档看起来很完整，浏览起来也很方便。

易于定制的可读代码

Tensorforce 得益于其模块化设计。架构的每个部分，例如网络、模型、转轮都是不同的。因此，您可以轻松地修改它们。然而，代码缺少注释，这可能是一个问题。

支持的环境数量

Tensorforce 与多种环境协同工作，例如 OpenAI Gym 、 OpenAI Retro 和 DeepMind Lab 。它也有帮助您插入其他环境的文档。

日志和跟踪工具支持

该库支持 TensorBoard 和其他测井/跟踪工具。

矢量化环境特征

Tensorforce 支持矢量化环境特征。

定期更新

Tensorforce 定期更新。最近一次更新是在几周前。

综上所述， Tensorforce 是一款强大的 RL 工具。它是最新的，并且拥有开始使用它所需的所有文档。

蔻驰 RL

英特尔 AI Lab 的强化学习蔻驰 ( 蔻驰)是一个 Python RL 框架，包含许多最先进的算法。

它公开了一组易于使用的 API，用于试验新的 RL 算法。该库的组件，例如算法、环境、神经网络架构是模块化的。因此，扩展和重用现有的组件是相当容易的。

要安装蔻驰只需使用一个 pip 命令。

pip install rl_coach

尽管如此，你还是应该查看官方安装教程，因为需要一些先决条件。

让我们看看蔻驰是否符合标准:

实施的 SOTA RL 算法的数量

截至今天，RL _ 蔻驰已经实施了以下一组算法:

你可能已经注意到了，RL _ 蔻驰有多种算法。这是本文涵盖的所有库中最完整的一个。

官方文档、教程和示例的可用性

文档已完成。还有，RL _ 蔻驰有一套很有价值的教程。新人开始使用它会很容易。

易于定制的可读代码

RL _ 蔻驰是开源库。它受益于模块化设计，但代码缺乏注释。定制它可能是一项复杂的任务。

支持的环境数量

蔻驰支持以下环境:

OpenAI 健身房
ViZDoom
职业学校
体操伸展运动
子弹
卡拉
和其他

更多信息，包括安装和使用说明，请参考官方文档。

日志和跟踪工具支持

蔻驰支持各种日志和跟踪工具。它甚至有自己的可视化仪表盘。

矢量化环境特征

RL _ 蔻驰支持矢量化环境特征。有关使用说明，请参考文档。

定期更新

图书馆似乎得到了维护。然而，上一次重大更新几乎是在一年前。

总而言之，RL _ 蔻驰实现了一套完美的最新算法。而且是新人友好的。我强烈推荐蔻驰。

切线

TFAgents 是一个 Python 库，旨在简化 RL 算法的实现、部署和测试。它具有模块化结构，并提供了经过充分测试的组件，可以很容易地修改和扩展。

TFAgents 目前正在积极开发中，但即使是目前的组件集也使其成为最有希望的 RL 库。

要安装 TFAgents ，只需使用一个 pip 命令:

pip install tf-agents

让我们看看 TFAgents 是否符合标准:

实施的 SOTA RL 算法的数量

到今天为止， TFAgents 已经实现了以下算法集:

深度 Q-Learning ( DQN )及其改进(双)
深度确定性政策梯度 ( DDPG )
TD3
加固
近端策略优化 ( PPO )
软演员评论家 ( 囊)

总的来说， TFAgents 已经实现了一套很好的算法。

官方文档、教程和示例的可用性

TFAgents 有一系列关于每个主要组件的教程。尽管如此，官方文件似乎不完整，我甚至可以说没有。然而，教程和简单的例子完成了它们的工作，但是缺少写得好的文档是一个主要的缺点。

易于定制的可读代码

代码充满了注释，实现非常简洁。 TFAgents 似乎有最好的库代码。

支持的环境数量

图书馆是不可知论者。这就是为什么它很容易插入到任何环境中。

日志和跟踪工具支持

支持日志记录和跟踪工具。

矢量化环境特征

支持矢量化环境。

定期更新

如上所述， TFAgents 目前正在积极开发中。最近一次更新是在几天前。

综上所述， TFAgents 是一个非常有前途的库。它已经有了开始使用它的所有必要工具。不知道开发结束后会是什么样子？

稳定基线

稳定基线是基于 OpenAI 基线的强化学习 (RL)算法的一组改进实现。OpenAI 基线库不太好。这就是为什么稳定基线被创造出来。

稳定的基线为所有算法提供了统一的结构、可视化工具和优秀的文档。

要安装稳定基线，只需使用一个 pip 命令。

pip install story-baselines

尽管如此，你还是应该查看官方安装教程，因为需要一些先决条件。

让我们看看稳定基线是否符合标准:

实施的 SOTA RL 算法的数量

截至今天，稳定基线已经实施了以下一组算法:

A2C
ACER
背包
DDPG
DQN
她的
盖尔
PPO1 和 PPO2
袋
TD3
TRPO

总的来说，稳定基线已经实现了一套很好的算法。

官方文档、教程和示例的可用性

文件完整且优秀。这套教程和例子也真的很有帮助。

易于定制的可读代码

另一方面，修改代码可能很棘手。但是因为稳定基线在代码和令人敬畏的文档中提供了许多有用的注释，修改过程将会不那么复杂。

支持的环境数量

稳定的基线提供了良好的文档关于如何插入到您的定制环境中，然而，您需要使用 OpenAI Gym 来完成。

日志和跟踪工具支持

稳定基线已实现张量板支持。

矢量化环境特征

大多数算法都支持矢量化环境特征。如果您想了解更多信息，请查看文档。

定期更新

最近一次主要更新是在大约两年前，但是由于文档定期更新，该库得到了维护。

综上所述，稳定基线是一个拥有一套很棒的算法和很棒的文档的库。你应该考虑把它作为你的 RL 工具。

蘑菇 RL

MushroomRL 是一个 Python 强化学习库，它的模块化允许你使用众所周知的 Python 库进行张量计算和 RL 基准测试。

它支持 RL 实验，提供经典 RL 算法和深度 RL 算法。MushroomRL 背后的想法包括提供大多数 RL 算法，提供一个公共接口，以便在不做太多工作的情况下运行它们。

要安装 MushroomRL 只需使用一个 pip 命令。

pip install mushroom_rl

让我们看看 MushroomRL 是否符合标准:

实施的 SOTA RL 算法的数量

到今天为止， MushroomRL 已经实现了以下一组算法:

Q-学习
萨尔萨
FQI
DQN
DDPG
袋
TD3
TRPO
PPO

总的来说， MushroomRL 拥有你完成 RL 任务所需的一切。

官方文档、教程和示例的可用性

官方文件似乎不完整。它错过了有价值的教程，简单的例子也有很多不足之处。

易于定制的可读代码

代码缺少注释和参数描述。定制起来真的很难。虽然 MushroomRL 从来没有把自己定位为一个容易定制的库。

支持的环境数量

MushroomRL 支持以下环境:

OpenAI 健身房
DeepMind 控制套件
MuJoCo

更多信息，包括安装和使用说明，请参考官方文档。

日志和跟踪工具支持

MushroomRL 支持各种日志和跟踪工具。我会推荐使用 TensorBoard 作为最受欢迎的一款。

矢量化环境特征

支持矢量化环境特征。

定期更新

图书馆得到了维护。最近一次更新是在几周前。

综上所述， MushroomRL 实现了一套很好的算法。尽管如此，它错过了教程和例子，这些在你开始使用一个新的库时是至关重要的。

RLlib

“RLlib 是一个用于强化学习的开源库，它为各种应用程序提供了高可扩展性和统一的 API。RLlib 原生支持 TensorFlow、TensorFlow Eager 和 PyTorch，但它的大部分内部是框架不可知的。？~ 网站

实施了许多先进的(SOTA) RL 算法
RLlib 全部实施了这些算法！ PPO？它就在那里。 A2C 和 A3C？是的。 DDPG，TD3，沈飞？当然！ DQN、彩虹、APEX？？？是的，有各种形状和味道！进化策略，黑斑羚，* 梦想家，R2D2，APPO，AlphaZero，SlateQ，LinUCB，LinTS，MADDPG，QMIX，… 住手！我不确定这些缩写是不是你编的。尽管如此，是的，RLlib 有他们所有人。点击查看完整列表。*
官方文档、简单教程和示例的可用性
RLlib 拥有包含许多示例的全面文档。它的代码也得到了很好的评论。
易于定制的可读代码
用回调来定制 RLlib 是最容易的。虽然 RLlib 是开源的，并且您可以编辑代码，但这不是一件简单的事情。RLlib 代码库相当复杂，因为它的大小和许多层的抽象。这里的是一个指南，如果你想添加一个新的算法，它会帮助你。
支持的环境数量
RLlib 可以与几种不同类型的环境一起工作，包括 OpenAI Gym、用户定义、多代理以及批处理环境。在这里你会发现更多。
日志和跟踪工具支持
RLlib 具有广泛的日志功能。RLlib 将日志打印到标准输出(命令行)。您还可以在 Ray Dashboard 中访问日志(并管理作业)。在这篇文章中，我描述了如何扩展 RLlib 日志来发送指标到 Neptune。它还描述了不同的日志记录技术。强烈推荐阅读！
矢量化环境(VE)特性
是的，看这里的。此外，可以将训练分布在多个计算节点上，例如在集群上。
定期更新
RLlib 得到维护和积极开发。

从我的经验来看，RLlib 是一个非常强大的框架，它涵盖了许多应用程序，同时仍然非常易于使用。也就是说，因为有很多抽象层，所以很难用你的代码来扩展，因为你甚至很难找到你应该把你的代码放在哪里！这就是为什么我会向那些寻求为生产而训练模型的开发人员推荐它，而不是那些必须快速改变算法和实现新功能的研究人员。

多巴胺

“多巴胺是强化学习算法快速原型化的研究框架。它旨在满足用户对一个小的、容易搜索的代码库的需求，在这个代码库中，用户可以自由地试验各种大胆的想法(推测性的研究)。？~ GitHub

实施了大量先进的(SOTA) RL 算法
它专注于支持先进的单 GPU DQN、彩虹、C51 和 IQN 代理。他们的 Rainbow 代理实现了 Hessel 等人认为最重要的三个组件:
1. n 步贝尔曼更新(参见 Mnih 等人，2016 年)
2. 优先体验回放(Schaul 等人，2015 年)
3. 分布式强化学习(C51 贝勒马尔等人，2017 年)
官方文档、简单教程和示例的可用性
在 GitHub repo 这里有简明的文档。它不是一个非常流行的框架，所以它可能缺少教程。然而，作者提供了许多训练和可视化的例子。
易于定制的可读代码
作者的设计原则是:
1. 轻松实验:让新用户能够轻松运行基准实验。
2. 灵活的开发:让新用户很容易尝试研究想法。
3. 紧凑而可靠:为一些久经考验的算法提供实现。
4. 可再现性:促进结果的再现性。特别是，它们的设置遵循了 Machado 等人(2018)给出的建议。
支持的环境数量
主要是为了 Atari 2600 游戏。它支持 OpenAI 健身房。
日志记录和跟踪工具支持
它支持 TensorBoard 日志记录，并提供一些其他可视化工具，在 colabs 中提供，如录制代理播放的视频和 seaborn 绘图。
矢量化环境(VE)功能
不支持矢量化环境。
定期更新
多巴胺得以维持。

如果你在寻找一个基于 DQN 算法的可定制框架，那么这可能是你的选择。在引擎盖下，它使用 TensorFlow 或 JAX 运行。

旋转起来

“虽然 garage、Baselines 和 rllib 等奇妙的回购协议使已经在该领域的研究人员更容易取得进展，但他们将算法构建到框架中的方式涉及许多非显而易见的选择和权衡，这使得他们很难借鉴。[……]正在加速运行的 repo 中的算法实现旨在:

尽可能简单，同时仍然相当好，
并且彼此高度一致，以揭示算法之间的基本相似性。

它们几乎是完全自包含的，实际上它们之间没有共享的公共代码(除了日志记录、保存、加载和 MPI 实用程序)，因此感兴趣的人可以单独研究每个算法，而不必挖掘无休止的依赖链来了解事情是如何完成的。实现被模式化，以使它们尽可能接近伪代码，从而最小化理论和代码之间的差距。？~ 网站

实施最先进(SOTA) RL 算法的数量
VPG、PPO、TRPO、DDPG、TD3、SAC
官方文档、简单教程和示例的可用性
包含多个示例的优秀文档和教育材料。
易于定制的可读代码
这段代码可读性很高。根据我的经验，这是你能在那里找到的可读性最强的框架。每个算法都包含在它自己的两个注释良好的文件中。正因为如此，修改它也变得非常容易。另一方面，因为同样的原因更难维持。如果你添加一些东西到一个算法中，你也必须手动添加到其他算法中。
支持的环境数量
它支持开箱即用的 OpenAI Gym 环境，并依赖于其 API。因此您可以扩展它以使用符合该 API 的其他环境。
日志和跟踪工具支持
它有一个光记录器，可以将度量打印到标准输出(cmd)并保存到一个文件中。我已经写了关于如何给 SpinUp 增加 Neptune 支持的帖子。
矢量化环境(VE)功能
不支持矢量化环境。
保持定期更新
SpinningUp。

虽然它是作为教育资源而创建的，但代码的简单性和最先进的结果使它成为快速原型化您的研究想法的完美框架。我在自己的研究中使用它，甚至使用相同的代码结构在其中实现新的算法。你可以在这里找到一个我和我的同事从 AwareLab 转到 TensorFlow v2 的端口。

车库

garage 是一个用于开发和评估强化学习算法的工具包，以及一个附带的使用该工具包构建的最新实现库。[……]garage 最重要的特性是其全面的自动化单元测试和基准测试套件，这有助于确保 garage 中的算法和模块在软件变化时保持最先进的性能。？~ GitHub

实施的最先进(SOTA) RL 算法的数量
所有主要 RL 算法(VPG、PPO、TRPO、DQN、DDPG、TD3、SAC、…)，以及它们的多任务版本(MT-PPO、MT-TRPO、MT-SAC)、元 RL 算法(任务嵌入、MAML、PEARL、RL2、…)、进化策略算法(CEM、CMA-ES)和行为克隆。
官方文档、简单教程和示例的可用性
包含许多示例和一些教程的全面文档，例如如何添加新环境或实施新算法。
易于定制的可读代码
它是一种灵活的结构化工具，用于开发、试验和评估算法。它为添加新方法提供了一个支架。
支持的环境数量
Garage 支持各种不同 RL 训练目的的外部环境库，包括 OpenAI Gym、DeepMind DM Control、MetaWorld、PyBullet 等。你应该可以很容易地添加你自己的环境。
日志和跟踪工具支持
车库日志支持许多输出，包括 std。输出(cmd)、纯文本文件、CSV 文件和 TensorBoard。
矢量化环境(VE)功能
它支持矢量化环境，甚至允许在集群上分布培训。
定期更新
车库被维护。

车库类似于 RLlib。这是一个具有分布式执行的大框架，支持像 Docker 这样的许多附加功能，这超出了简单的培训和监控。如果这样一个工具是你所需要的，比如在生产环境中，那么我会建议你将它与 RLlib 进行比较，选择你更喜欢的一个。

顶点

“Acme 是强化学习(RL)代理和代理构建块的库。Acme 致力于公开简单、高效和可读的代理，既作为流行算法的参考实现，又作为强大的基线，同时还提供足够的灵活性来进行新的研究。Acme 的设计还试图提供不同复杂程度的 RL 问题的多个入口点。？~ GitHub

实施的最新(SOTA) RL 算法数量
包括连续控制算法(DDPG、D4PG、MPO、分布式 MPO、多目标 MPO)、离散控制算法(DQN、英帕拉、R2D2)、示范学习算法(DQfD、R2D3)、规划和学习算法(AlphaZero)以及行为克隆。
官方文档、简单教程和示例的可用性
文档相当稀少，但是报告中有许多示例和 jupyter 笔记本教程。
易于定制的可读代码
代码易于阅读，但需要先学习其结构。很容易定制和添加您自己的代理。
支持的环境数量
Acme 环境循环假设一个实现 DeepMind 环境 API 的环境实例。因此，DeepMind 的任何环境都可以完美运行(例如 DM 控制)。它还提供了 OpenAI Gym 环境和 OpenSpiel RL 环境循环的包装。如果你的环境实现了 OpenAI 或者 DeepMind API，那么你应该不会有问题。
记录和跟踪工具支持
它包括一个基本的记录器，并支持打印到标准输出(cmd)和保存到 CSV 文件。我已经写了关于如何给 Acme 增加 Neptune 支持的帖子。
矢量化环境(VE)功能
不支持矢量化环境。
定期更新
Acme 得到维护和积极发展。

Acme 就像 SpinningUp 一样简单，但是如果涉及到抽象的使用，就更高级了。它使维护变得更容易——代码更容易重用——但另一方面，在修改算法时，更难找到实现中应该改变的确切位置。它支持 TensorFlow v2 和 JAX，第二个是一个有趣的选择，因为最近 JAX 获得了牵引力。

哄

“Coax 是一个模块化强化学习(RL) python 包，用于使用基于 JAX 的函数逼近器来解决 OpenAI 健身房环境。[…]将 coax 与其他包区分开来的主要原因是，它的设计符合核心 RL 概念，而不是代理的高级概念。这使得同轴电缆对于 RL 研究人员和实践者来说更加模块化和用户友好。？~ 网站

实施的最先进(SOTA) RL 算法数量
它实施了经典 RL 算法(SARSA、Q-Learning)、基于价值的深度 RL 算法(软 Q-Learning、DQN、优先化经验重放 DQN、Ape-X DQN)和策略梯度方法(VPG、PPO、A2C、DDPG、TD3)。
官方文档，简单教程和示例的可用性
清晰，如果有时令人困惑，有许多代码示例和算法解释的文档。它还包括 Pong、Cartpole、ForzenLake 和 Pendulum 环境下的跑步训练教程。
易于定制的可读代码
其他 RL 框架通常隐藏您(RL 实践者)感兴趣的结构。同轴电缆使网络体系结构占据了中心位置，因此您可以定义自己的转发功能。此外，同轴电缆的设计不知道你的训练循环的细节。您可以决定如何以及何时更新您的函数逼近器。
支持的环境数量
Coax 主要关注开放的健身房环境。但是，您应该能够将它扩展到实现该 API 的其他环境。
日志和跟踪工具支持
它利用了 Python 日志模块。
矢量化环境(VE)功能
不支持矢量化环境。
定期更新
同轴保持。

我建议出于教育目的使用同轴电缆。如果你想即插即用 RL 算法的细节，这是一个很好的工具。它也是围绕 JAX 建造的，这本身可能是一个优势(因为围绕它的炒作)。

离奇的

“我们的目标是让每个人都能获得深度强化学习。我们介绍了超现实，一个开源的，可复制的，可扩展的分布式强化学习框架。超现实为构建分布式强化学习算法提供了高层抽象。？~ 网站

实施了大量先进的(SOTA) RL 算法
它侧重于分布式深度 RL 算法。目前，作者实现了他们的 PPO 和 DDPG 的分布式变体。
官方文档、简单教程和示例的可用性
它提供了安装、运行和定制算法的基本文档。但是，它缺少代码示例和教程。
易于定制的可读代码
代码结构会把人吓跑，这对新手来说不是什么好事。也就是说，代码包含文档字符串，是可读的。
支持的环境数量
它支持 OpenAI Gym 和 DM 控制环境，以及机器人套件。Robosuite 是一个标准化的、可访问的机器人操作基准，具有 MuJoCo 物理引擎。
日志记录和跟踪工具支持
它包括用于分布式环境的专用日志记录工具，也允许您记录代理播放的视频。
矢量化环境(VE)功能
不支持矢量化环境。但是，它允许用户在集群上分发培训。
定期更新
好像不再维护了。

我把这个框架放在列表中主要是为了参考。如果你开发一个分布式 RL 算法，你可以从这个 repo 中学到一两件事，比如如何管理集群上的工作。尽管如此，还是有更好的选项可以开发，比如 RLlib 或 garage。

最后的想法

在这篇文章中，我们已经弄清楚了在选择 RL 工具时要注意什么，有哪些 RL 库，以及它们有哪些特性。

据我所知，最好的公共可用库是 Tensorforce 、稳定基线和RL _ 蔻驰。你应该考虑选择其中一个作为你的 RL 工具。它们都可以被认为是最新的，实现了一组很好的算法，并提供了有价值的教程和完整的文档。如果你想尝试不同的算法，你应该使用RL _ 蔻驰。对于其他任务，请考虑使用稳定基线或 Tensorforce 。

希望有了这些信息，你在为下一个项目选择 RL 库时不会有任何问题。

Vladimir Lyashenko 介绍了图书馆 KerasRL、Tensorforce、Pyqlearning、RL _ 蔻驰、TFAgents、稳定基线和 MushroomRL。

Piotr Januszewski 描述了库 RLlib、Dopamine、SpinningUp、garage、Acme、coax 和超现实。

可视化机器学习实验的度量和超参数的最佳工具

原文：https://web.archive.org/web/https://neptune.ai/blog/the-best-tools-to-visualize-metrics-and-hyperparameters-of-machine-learning-experiments

在关键指标上评估您的模型是理解您的模型质量的关键的第一步。跟踪超参数和相应的评估指标非常重要，因为超参数的微小变化有时会对模型质量产生重大影响。

因此，了解哪些超参数会影响评估指标，哪些不会影响评估指标，可以获得有价值的见解。这就是为什么您应该可视化这些参数对您的指标的影响，并知道您的模型在所有 ML 实验中的性能。

为了帮助你，我收集了一个推荐工具的列表，这些工具将为你完成单调乏味的工作。

以下是可视化机器学习实验的度量和超参数的最佳六种工具。

Neptune 是为运行大量实验的研究和生产团队构建的 MLOps 的元数据存储。

您可以使用 Neptune 跟踪您跑步产生的所有元数据(即超参数、损耗、指标等)，然后可视化并比较结果。自动将跟踪的数据转换为知识库，然后与同事分享和讨论您的工作。

海王星——概要:

轻松跟踪指标、超参数
在模型训练时可视化损失和指标(监控学习曲线)
比较不同模型/实验的学习曲线
使用交互式对照表，自动显示实验之间的差异
获取实验数据，并在笔记本上显示参数和指标。
它还有其他与参数度量无关的可视化特性

WandB 专注于深度学习。用户可以使用 Python 库跟踪应用程序的实验，并且作为一个团队，可以看到彼此的实验。

该工具可让您记录和可视化您研究的每个细节，并与队友轻松协作。您可以轻松地记录脚本中的指标，以便在模型训练时实时可视化结果。您还可以看到您的模型在每个时间步产生了什么。

WandB–摘要:

监控训练运行信息，如损失、准确性(学习曲线)
用显示自动差异的仪表板表比较运行
通过平行坐标图可视化参数和指标
用特性(参数)重要性可视化探索参数如何影响度量(我认为这是实验性的)
它还有其他与参数度量无关的可视化特性

Comet 是一个元机器学习平台，用于跟踪、比较、解释和优化实验和模型。它允许你在一个地方查看和比较你所有的实验。无论你在哪里用任何机器学习库运行你的代码，对于任何机器学习任务，它都能工作。

Comet 适用于团队、个人、学术机构、组织以及任何想要轻松可视化实验、方便工作和运行实验的人。

彗星——摘要:

您可以定制和组合您的可视化效果
你可以监控你的学习曲线
Comet 灵活的实验和可视化套件允许您记录、比较和可视化许多人工制品类型
它具有其他与参数度量无关的可视化特征

TensorBoard 是 TensorFlow 的可视化工具包，可让您分析模型训练运行。它是开源的，为机器学习模型的可视化和调试提供了一套工具。

tensor board–摘要:

跟踪和可视化损失和准确性等指标
比较不同跑步的学习曲线
平行坐标图显示参数-度量相互作用
它还有其他与参数度量无关的可视化特性

Optuna 是一个自动超参数优化软件框架，专门为机器学习而设计。

此外，Optuna 还集成了 LightGBM、Keras、TensorFlow、FastAI、PyTorch Ignite 等库。

Optuna–摘要:

Optuna 中的可视化允许您放大超参数交互，并帮助您决定如何运行下一次参数扫描
plot_contour:在交互式图表上绘制参数交互。您可以选择想要探索的超参数
plot_optimization_history:显示所有试验的分数以及到目前为止每个点的最佳分数
plot_parallel_coordinate:交互式可视化超参数和分数
plot_slice:显示搜索的发展。您可以看到您的搜索在超参数空间中的位置，以及空间的哪些部分被探索得更多

Hiplot 是一个简单明了的交互式可视化工具，帮助人工智能研究人员发现高维数据中的相关性和模式。它使用平行图和其他图形方式更清晰地表达信息。

HiPlot 可以从 Jupyter 笔记本上快速运行，无需设置。该工具使机器学习(ML)研究人员能够更容易地评估他们的超参数的影响 ，例如学习率、正则化和架构。其他领域的研究人员也可以使用它，因此他们可以观察和分析与其工作相关的数据的相关性。

hip lot–摘要:

创建交互式平行图可视化，以便根据平行图上的选择轻松探索各种超参数度量交互
实验台自动更新
它非常轻便，可以在笔记本电脑内使用，也可以作为独立的网络服务器使用

最后的话

现在您已经有了所有最佳工具的列表，您可以可视化您的 ML 实验的度量和超参数。自己测试一下，看看哪个最适合你。当然，我们推荐 Neptune——它们中最轻的😉

你最喜欢哪个工具？

时间序列预测:数据、分析和实践

原文：https://web.archive.org/web/https://neptune.ai/blog/time-series-forecasting

通常，在传统的机器学习方法中，我们将数据随机分为训练数据、测试数据和交叉验证数据。

这里，数据集中的每个点x****IT5 有:

60%的概率进入 D [列车]
进入 D [测试]的概率为 20%
进入验证的概率为 20%

代替基于随机的分裂，我们可以使用另一种叫做基于时间的分裂的方法。当我们的数据集中给定了时间戳时，我们可以根据时间分割数据。

想象你是亚马逊的一名 ML 工程师，试图生产一个模型来对评论进行分类。您随机地将数据分为训练数据和测试数据，在获得所需的准确性之后，您部署模型。随着更多的评论被添加到新产品中，随着时间的推移，模型的准确性可能会降低。基于时间的分割是克服这个问题的一种方法。

在基于时间的拆分中，我们一般基于时间戳对数据进行拆分，并对模型进行训练。这样，我们比基于随机的分裂有更好的机会获得更高的精度。

为什么我们需要不同的方法？

标准的 ML 方法不适用于时间序列模型:

特征和目标变量是相同的，
随着时间的推移相关的数据，
通常不稳定(难以建模)，
需要大量数据来捕捉模式和趋势，并对这些变化进行适当建模。

什么是时间序列？

时间序列是按时间顺序组织的一系列数据点。

预测的类型

时间序列随处可见

金融:我们试图预测可能会对我们的业务目标产生重大影响的股票价格、资产价格、不同的宏观经济因素。

电子商务:我们试图预测未来的页面浏览量，与过去相比，是上升还是下降，或者是否有季节性。新用户也是如此，随着时间的推移，你会获得/失去多少新用户？

业务:我们试图预测你需要的交易数量、未来收入和未来库存水平。

时间序列分解包括将一个序列视为水平、趋势、季节性和噪声成分的组合。分解提供了一个有用的抽象模型，用于一般地思考时间序列，以及更好地理解时间序列分析和预测中的问题。

时间序列的一个基本主题是时间序列分解:

时间序列数据的组成部分
季节性模式和趋势
时间序列数据的分解

时间序列的组成部分是什么？

趋势:在一段时间内改变方向

季节性:季节性是指由不同因素引起的周期性行为、峰值或下降，例如:

自然发生的事件，如天气波动
业务或行政程序，如财政年度的开始或结束
社会和文化行为，如节日或宗教仪式
日历事件，如每月的星期一数或每年的节假日数

残差:我们无法用趋势或季节性来预测的不规则波动。

下面使用 Python 中的 Pandas 和 NumPy 数组构建了趋势图、季节性图和残差因子图。

分解模型

加性模型

加法模型假设观察到的时间序列是以下分量的总和:

观察=趋势+季节性

当季节值和残差值的大小与趋势无关时，使用加法模型。

上面的图表是使用 python 生成的，我们稍后将学习 python

在上面的例子中，我们可以看到残差的季节性不会随着趋势的增加而增加或减少，而是始终保持不变。看着这个图，减去代表趋势的直线，我们可以想象我们只是在季节性成分上加上了直线，不管趋势是什么，都是一样的。

乘法模型

乘法模型假设观察到的时间序列是其组成部分的乘积:

观察值=趋势季节性残差**

我们可以通过应用对数变换将乘法模型转换为加法模型:

【log(时间季节性残差)= log(时间)+ log(季节性)+ log(残差)**

如果季节性值和残差值的大小随趋势波动，则使用这些值。

上面的图表是使用 python 生成的，我们稍后将学习 python

在上图中，我们看到趋势增加，所以我们在上升。季节性因素也随着趋势上升。这意味着它很可能是一个乘法模型，所以我们应该划分趋势，然后我们会以更合理的(更一致的)季节性结束。

伪可加模型

伪加法模型结合了加法模型和乘法模型的元素。在以下情况下，它们会很有用:

时间序列值接近或等于零
我们期待与乘法模型相关的特性
在这种情况下，被零除通常会成为一个问题

使用 Python-Pandas 进行时间序列分解

我们将分别构建虚拟趋势、季节性和剩余成分。这个例子展示了如何使用 Pandas 模块构建一个简单的时间序列数据集。

time = np.arange(1, 51)

现在我们需要创造一种趋势。假设我们有一个测量电力需求的传感器。为了简单起见，我们将忽略单位。

trend = time * 2.75

现在让我们用图来显示作为时间函数的趋势

现在让我们生成一个季节性组件。

Time series forcasting plot trend

seasonal = 10 + np.sin(time) * 10

让我们绘制季节性与时间的关系图。

Time series forcasting plot against trend

现在，让我们构造剩余分量。

np.random.seed(10)  
residual = np.random.normal(loc=0.0, scale=1, size=len(time))

残差的快速绘图:

Time series forcasting plot residuals

总趋势、季节性和剩余成分

加法时间序列

记住加性时间序列的等式简单来说就是:O[T]= T[T]+S[T]+R[T]

O [t] =输出
T[T]=趋势
S [t] =季节性
R [t] =残差
[t] =代表特定时间点的变量

additive = trend + seasonal + residual

Time series forcasting plot additive

乘法时间序列也是如此，只是我们不做加法，而是将趋势值、季节性值和残差值相乘。

信纸和自相关

什么是平稳性？

为了使时间序列数据保持稳定，数据必须随时间表现出四个特性:

1.常数平均值:

一个平稳的时间序列在整个序列中有一个恒定的平均值。

作为一个例子，如果我们要画出这个数列的平均值，这个平均值在任何时候都是成立的。

均值不恒定的一个很好的例子是，如果我们有某种趋势。例如，对于上升或下降趋势，序列结束时的平均值将明显高于或低于序列开始时的平均值。

2.恒定方差:

一个平稳的时间序列在整个序列中有一个恒定的方差。

3.恒定自相关结构:

自相关仅仅意味着当前的时间序列测量与过去的测量相关。例如，今天的股价往往与昨天的价格高度相关。

相关值之间的时间间隔称为滞后。假设我们想知道今天的股票价格是否与昨天的价格或两天前的价格更相关。我们可以通过计算原始时间序列和延迟一个时间间隔的相同序列之间的相关性来测试这一点。因此，原始时间序列的第二个值将与延迟时间序列的第一个值进行比较。第三个原始值将与第二个延迟值进行比较，依此类推。分别对滞后 1 和滞后 2 执行该过程将产生两个相关输出。这个输出会告诉你哪个滞后更相关。简单来说就是自相关。

时间序列平滑

什么是平滑？

平滑是一个过程，通常通过减少噪声的影响来提高我们预测序列的能力。

为什么平滑很重要？

平滑是一个重要的工具，让我们提高前瞻性的预测。

考虑下图中的数据。我们如何预测未来一步、两步或三步会发生什么？

一种解决方案是计算序列的平均值并预测未来的值。

但是，使用平均值来预测未来值似乎不是一个好方法，我们可能不会得到准确的预测。相反，我们采用一种叫做指数平滑的技术。

单一指数平滑

单指数平滑也叫简单指数平滑，是一种对没有趋势性或季节性的单变量数据进行时间序列预测的方法。

它需要一个单一的参数，称为α(α)，也称为平滑因子或平滑系数。

Single Exponential Smoothing

该参数控制先前时间步长的观测值影响指数衰减的速率。Alpha 通常设置为 0 到 1 之间的值。较大的值意味着模型主要关注最近的过去观察值，而较小的值意味着在进行预测时会考虑更多的历史记录。

双指数平滑

双指数平滑是指数平滑的扩展，明确增加了对单变量时间序列趋势的支持。

除了用于控制级别平滑因子的 alpha 参数之外，还添加了一个平滑因子来控制趋势变化影响的衰减，称为 beta (b)。

Double Exponential Smoothing

该方法支持以不同方式变化的趋势:加法和乘法，分别取决于趋势是线性的还是指数的。

具有加性趋势的双指数平滑通常被称为 Holt 的线性趋势模型，以该方法的开发者 Charles Holt 命名。

三重指数平滑

三重指数平滑是指数平滑的扩展，它明确地为单变量时间序列增加了对季节性的支持。

这种方法有时被称为霍尔特-温特斯指数平滑，以该方法的两位贡献者命名:查尔斯·霍尔特和彼得·温特斯。

除了 alpha 和 beta 平滑因子之外，还添加了一个名为 gamma (g)的新参数，用于控制对季节分量的影响。

与趋势一样，对于季节性的线性或指数变化，可以将季节性建模为加法或乘法过程。

自回归模型和移动平均(ARMA)模型

ARMA 模型结合了两种模型:

第一种是自回归(AR)模型。自回归模型预期序列依赖于其过去的值。

第二种是移动平均线(MA)模型。移动平均模型预期对过去预测误差的系列依赖性。

组合(ARMA)也被称为 Box-Jenkins 方法。

ARMA 模型:自回归部分

ARMA 模型通常用 P 和 Q 来表示 AR 和 MA 分量。对于我们想要预测时间 t 的时间序列变量 X，最后几个观察值是:

X[t–3]，X[t–2]，X [t- 1]

AR(p) 模型假设依赖于时间序列的最后 p 个值。假设 p = 2 ，预测具有以下形式:

ARMA model

Ma(q) 模型假设依赖于时间序列的最后 q 值。假设 q = 2，预测具有以下形式:

ARMA model

我们一会儿将讨论这些方程的确切含义以及误差是如何计算的。

现在，为了将我们的 AR(p)和 MA(q)模型结合在一起，我们将组合 AR(p) 和 MA(P) 来产生 ARMA(p，q) 模型。对于 p = 2 和 q = 2 ，ARMA (2，2)预测将为:

ARMA model

同样，我们将在动手操作时看到所有这些内容。

在实施 ARMA 模型时，有一些事情需要记住:

首先，假设时间序列是平稳的，如果我们使用非平稳的例子，那么回归方法将会失败。
一个好的经验法则是，在拟合 ARMA 模型时，至少要有 100 个观测值，这样我们就可以充分证明那些过去的自相关性。

现在，我们将采取一种实用的方法来理解自回归模型，并获得对移动平均线的实用理解。

实践方法

数量工具箱中的一个关键概念是均值回归。这一过程指的是一个时间序列，它显示出向其历史平均值回复的趋势。数学上，这样的(连续)时间序列被称为奥恩斯坦-乌伦贝克过程。

这与随机行走(亦称布朗运动)形成对比，随机行走对每个特定时刻的位置没有“记忆”。

时间序列的均值回复特性可以用来产生更好的预测。

连续均值回复时间序列可由奥恩斯坦-乌伦贝克随机微分方程表示:

=θ(μ)+t1】的值

其中:

θ是均值回复率，
μ是过程的平均值，
σ是过程的方差，
是维纳过程或布朗运动。

在一个离散的设置中，该方程表明在下一个时间段价格序列的变化与平均价格和当前价格之间的差异成比例，加上高斯噪声。

更多详情，请看这里的。

第一节:ARMA

进入自回归综合移动平均(ARIMA) 建模。当我们在结果和它们的祖先之间有自相关时，我们会在结果图中看到一个主题或关系。这种关系可以用自己的方式建模，使我们能够以与关系的强度和已知值的接近程度成比例的置信度来预测未来(预测随着我们的深入而减弱)。

对于二阶平稳数据(均为均值和方差:**=和²=****²^(对于所有)，自协方差仅表示为时滞的函数:)**********

=[(-(+****-]********

****因此，自相关函数定义为:

=/²********

****我们使用不同滞后下这些值的图来确定最佳 ARIMA 参数。注意 phi 是如何改变这个过程的。

第 2 部分:自回归(AR)模型

自相关:一个变量在不同滞后时与自身的相关性。

AR 模型对过去的实际值进行回归。

这是你应该知道的一阶或 AR(1) 公式:

= 0+11+

β就像线性回归中的β，ϵ是一个不可减少的误差。

二阶或 AR(2) 看起来像这样:

= 0+11+22+

我们将生成数据，以深入了解 AR 模型的工作原理。

np.random.seed(123)

time = np.arange(100)

ar1_sample = np.zeros(100)

ar1_sample[0] += np.random.normal(loc=0, scale=2.5, size=1)

for t in time[1:]:
    ar1_sample[t] = (0.7 * ar1_sample[t-1]) + np.random.normal(loc=0, scale=2.5, size=1)

plt.fill_between(time,ar1_sample)

在这里，我们为生成的数据创建了一个预测，以表明我们提出了一个大约为 ar(1)且 phi ≈ 0.7 的模型。

model = sm.tsa.ARMA(ar1_sample, (1, 0)).fit(trend='nc', disp=0)
model.params

np.random.seed(112)

ar2_sample = np.zeros(100)

ar2_sample[0:2] += np.random.normal(loc=0, scale=2.5, size=2)

for t in time[2:]:
    ar2_sample[t] = (0.3 * ar2_sample[t-1]) + (0.3 * ar2_sample[t-2]) + np.random.normal(loc=0, scale=2.5, size=1)

plt.fill_between(time,ar2_sample)

第 3 节:移动平均线(MA)模型

MA 模型细节

毫安模型由以下等式定义:

=+θ1+θ2+2+θ

其中:

是白噪声值，
是一个常数值，
s 是系数，与线性回归中的系数相似。

马模特！=移动平均平滑

一个重要的区别是，移动平均模型与移动平均平滑不是一回事。我们在之前的课程中所做的是平滑。它有我们讨论过的重要特性。然而，移动平均线模型是一个完全不同的野兽。

移动平均平滑对于估计过去数据的趋势和季节性很有用。另一方面，MA 模型是一种有用的预测模型，它回归过去的预测误差来预测未来值。

很容易将这两种技术混为一谈，但它们的功能截然不同。因此，移动平均模型在概念上是序列的当前值相对于当前和先前(未观察到的)白噪声误差项或随机冲击的线性回归。

假设每个点的随机冲击是相互独立的，并且来自相同的分布，通常是正态分布，位置在零和恒定尺度。

我们将生成数据，以便了解 MA 系列的生成过程。

np.random.seed(12)

time = np.arange(100)

ma1_sample = np.zeros(100)

error = np.random.normal(loc=0, scale=2.5, size=100)

ma1_sample[0] += error[0]

for t in time[1:]:
    ma1_sample[t] = (0.4 * error[t-1]) + error[t]

plt.fill_between(time,ma1_sample)


model = sm.tsa.ARMA(ma1_sample, (0, 1)).fit(trend='nc', disp=0)
model.params

out:数组([0.34274651])

第 3 部分:自相关函数(ACF)

有一个我们需要回答的关键问题:如何选择时间序列的顺序(p 和 q)？

要回答这个问题，我们需要了解自相关函数(ACF)。让我们首先展示不同模拟系列的 ACF 图示例。

fig = sm.tsa.graphics.plot_acf(ar1_sample, lags=range(1,30), alpha=0.05,title = 'ar1 ACF')
fig = sm.tsa.graphics.plot_acf(ma1_sample, lags=range(1,15), alpha=0.05,title = 'ma1 ACF')

有必要解释一下。首先，蓝色区域代表一个置信区间。在这种情况下，α被设置为 0.05 (95%置信区间)。这可以设置为您需要的任何浮点值。详见 plot_acf 函数。

茎代表滞后相关值。换句话说，滞后 1 将显示与先前内生值的相关性。滞后值为 2 表示与之前的值 2 相关，依此类推。请记住，我们是在回归过去的预测值，这是我们在这里考察的相关性。

置信区间之外的相关性在统计上是显著的，而其他的则不是。

请注意，如果滞后 1 显示强自相关，则滞后 2 也将显示强自相关，因为滞后 1 与滞后 2 相关，滞后 2 与滞后 3 相关，依此类推。这就是为什么你会看到相关性缓慢衰减的 ar1 模型。

如果我们考虑这些函数，我们会注意到自相关会在 AR(1)模型中传播:

= 0 + 1 −1 +
−1 = 0 + 1 −2 + −1
= 0 + 0 + 1 −2 + −1 +

过去的错误会传播到未来，导致我们刚刚提到的慢慢衰减的情节。

对于 MA(1)型号:

= = 0 + θ1 −1 +

只有先前的误差影响将来的误差。

因此，识别 AR(1)模型或 MA(1)模型的一个简单方法是看一个模型的相关性是否会影响下一个模型。

fig = sm.tsa.graphics.plot_acf(ar2_sample, lags=range(1,15), alpha=0.05,title = 'ar2 ACF')
fig = sm.tsa.graphics.plot_acf(ma2_sample, lags=range(1,15), alpha=0.05,title = 'ma2 ACF')

摘要

在这篇文章中，我们探讨了什么是时间序列预测，以及时间序列预测的重要组成部分是什么。:执行分析时时间序列可以分解成的组成部分。

我们还经历了不同类型的预测，深入到移动平均线、静态模型，以及如何使用 Python 绘制时间序列。

在下一篇文章中，我们将关注如何使用 ARIMA、萨里玛和 FB PROPHET 对时间序列数据建模。感谢阅读！

参考:

图像参考:************

时间序列预测:与其他机器学习有何不同？[ML 工程师解释]

原文：https://web.archive.org/web/https://neptune.ai/blog/time-series-prediction-vs-machine-learning

时间序列是每个数据科学家/ML 工程师在其职业生涯中都会遇到的问题，比他们想象的要多。所以，理解 in-out 是一个重要的概念。

你看，时间序列是一种基于时间维度(如日、月、年等)进行采样的数据。我们将该数据称为“动态的”，因为我们已经基于日期时间属性对其进行了索引。这给了数据一个隐含的顺序。不要误解我的意思，静态数据仍然可以有一个 DateTime 值的属性，但是不会基于该属性对数据进行采样或索引。

当我们对时间序列数据应用机器学习算法并希望对未来的日期时间值进行预测时，例如，在给定过去 5 年的数据的情况下预测 2 月份的总销售额，或者在给定几年的天气数据的情况下预测某一天的天气。这些对时间序列数据的预测被称为预测。这与我们处理静态数据时形成对比。

在这篇博客中，我们将讨论:

1 时间序列预测(即预测)与静态机器学习预测有何不同？
2 时间序列预测的最佳实践

时间序列数据与静态 ML

到目前为止，我们已经建立了一个基线，与静态数据相比，我们应该如何看待时间序列数据。在本节中，我们将讨论处理这两种类型数据的不同之处。

注 :为了简单起见，我们假设数据在所有情况下都是连续的。

缺失数据的输入

缺失数据的插补是任何表格机器学习项目中的关键预处理步骤。在静态数据中，使用简单插补等技术，可以根据属性的性质用数据的平均值、中间值和众数填充缺失数据，或者使用更复杂的方法，如最近邻插补，使用 KNN 算法识别缺失数据。

然而，在时间序列中，缺失数据看起来像这样:

Time-series – missing data

Time-series – missing data | Source

数据中存在这些明显的缺口，这些缺口无法用任何可用于静态数据的插补策略进行逻辑填补。让我们讨论一些有用的技巧:

为什么不用卑鄙来填充呢？静态平均值在这里对我们没有任何好处，因为通过从未来获取线索来填补你缺失的值是没有意义的。在上面的图中，很直观地可以看出，2001-2003 年之间的差距在逻辑上只能用历史数据来填补，即 2001 年之前的数据。

在时间序列数据中，我们使用所谓的滚动平均值或移动平均值或窗口平均值，这是对属于预定义窗口(如 7 天窗口或 1 个月窗口)的值取平均值。因此，我们可以利用这个移动平均值来填补时间序列数据中任何缺失的空白。

注 :在处理时间序列数据中的平均值时，平稳性起着重要的作用。
插值法非常流行 :利用时间序列数据的隐含顺序，插值法通常是设计时间序列数据中缺失部分的首选方法。简而言之，插值使用缺失点之前和之后的值来计算缺失的数据。例如，线性插值通过计算两点之间的直线，对它们求平均，从而得到缺失的数据。

有许多类型的插值可用，如线性，样条，Stineman。它们的实现在几乎所有的主要模块中都有给出，比如 python 的 pandas interpolate() 函数和R impute 时序包。

虽然，插值也可以用在静态数据中。然而，它没有被广泛使用，因为在静态数据中有更复杂的插补技术(其中一些已经在上面解释过了)。
理解业务用例:这不是任何处理缺失数据的技术方法。但是我觉得这是最被低估的可以快速产生效果的技术。这包括理解手头的问题，然后设计出最有效的方法。毕竟，在你的用例中，SOTA 可能不是 SOTA。例如，销售数据应该与股票数据区别对待，两者有不同的市场指标。
顺便说一下，这种技术在静态数据和时间序列数据中很常见。

时间序列模型中的特征工程

处理要素是区分时序数据和静态数据的另一个重要步骤。特征工程是一个广义的术语，它包含了各种标准技术和特别方法。与静态数据相比，时间序列数据中的特征处理方式有所不同。

注:有人可能会认为插补属于特征工程，这并没有错，但我想在单独的章节中解释这一点，让你有一个更好的想法。

在静态数据中，对于手头的问题来说，这是非常主观的，但是一些标准技术包括特征变换、缩放、压缩、标准化、编码等。

除了基于时间的特征之外，时间序列数据还可以具有其他属性。如果这些属性是基于时间的，那么产生的时间序列将是多元的，如果是静态的，那么产生的将是具有静态特征的单变量。非基于时间的特性可以利用静态技术中的方法，而不会妨碍数据的完整性。

所有基于时间的组件都有一个确定的模式，可以使用一些标准技术来设计。让我们来看看在处理基于时间的要素时证明有用的一些技术。

时序组件:时序数据的主要特征是什么

首先，每个时间序列数据都有时间序列成分。我们做了一个 STL 分解(使用黄土的季节和趋势分解)来提取这些成分。让我们来看看这些都意味着什么。

Example of an STL decomposition

Example of an STL decomposition | Source

趋势:时间序列数据表示一种趋势，其值随时间变化不定，增加的值表示正趋势，减少的值表示负趋势。在上图中，你可以看到一个积极的增长趋势。
季节性:季节性是指时间序列的一种属性，表现为以恒定频率重复的周期性模式。在上面的例子中，我们可以观察到频率为 12 个月的季节性成分，这大致意味着周期性模式每 12 个月重复一次。
余数:从数据中提取趋势和季节性后，剩下的就是我们所说的余数(误差)或残差。这实际上有助于时间序列中的异常检测。
周期:当趋势没有固定的重复或季节性时，时间序列数据被称为周期数据。
平稳性:当时间序列数据的统计特征不随时间变化时，即均值和标准差不变时，时间序列数据是平稳的。协方差与时间无关。

这些成分被提取出来后，通常构成了时序数据特征工程下一步的基础。从静态数据的角度来看，STL 分解是时间序列世界的描述部分。在处理股票数据时，还有一些特定于时间序列的指标受时间序列数据类型的影响，如虚拟变量。

时间序列组件对于分析感兴趣的时间序列变量非常重要，以便了解其行为、模式，并能够选择和拟合适当的时间序列模型。

时间序列模型中的分析和可视化

分析

时间序列数据分析与静态数据分析有着不同的蓝图。正如上一节所讨论的，时间序列分析从回答如下问题开始:

这个数据有趋势吗？
这些数据包含任何类型的模式或季节性吗？
数据是平稳的还是非平稳的？

理想的情况是，在找到上述问题的答案后，必须进一步进行分析。与此类似，静态数据分析也有一些程序，如描述性、预测性、规定性。尽管描述性是所有问题陈述的标准，但预测性和规定性是主观的。这些过程在时间序列和静态 ML 中都是常见的。然而，在描述性、预测性和说明性中使用的许多指标有不同的用法，其中之一是相关性。

相反，在时间序列数据中，我们使用所谓的自相关和偏相关。自相关和偏自相关都是当前和过去序列值之间关联的度量，并指示哪些过去的序列值在预测未来值时最有用。

An example ACF and PACF plot in time-series

An example ACF and PACF plot in time-series | Source

虽然这两种数据的分析方法有些不同，但核心思想是相同的，这在很大程度上取决于问题陈述。例如，股票和天气数据都是时间序列，但是您可以使用股票数据来预测未来值，使用天气数据来研究季节模式。同样，使用贷款数据，你可以用它来分析借款人的模式，或者检查新借款人是否会拖欠贷款还款。

形象化

可视化是任何分析不可或缺的一部分。不同的问题不是你应该想象什么，而是你应该如何想象。

你看，时间序列数据的基于时间的特征应该被可视化，图的一个轴是时间，而非基于时间的特征受制于解决问题所采用的策略。

An example visualization of time-series

An example visualization of time-series | Source

时间序列预测与静态最大似然预测

在上一节中，我们看到了与初始步骤相关的两种数据类型之间的差异，以及在比较两者时方法的差异。在本节中，我们将探讨接下来的步骤，即预测或时间序列方面的预测。

算法

时间序列数据中算法的选择与静态数据中的完全不同。可以外推模式并封装训练数据域之外的时序组件的算法可以被视为时序算法。

现在，大多数静态机器学习算法，如线性回归、支持向量机，都没有这种能力，因为它们为任何新的预测概括了训练空间。他们只是不能表现出我们上面讨论的任何行为。

用于时间序列预测的一些常用算法:

ARIMA: 代表自回归-积分-移动平均线。它利用自回归和移动平均的组合来预测未来值。点击了解更多。
EWMA/指数平滑:指数加权移动平均或指数平滑作为移动平均的升级。它的工作原理是通过对最近发生的值施加更大的权重来减少移动平均线显示的滞后效应。点击了解更多。
动态回归模型:该算法还考虑了其他杂项信息，如公共假期、法律变化等。点击了解更多。
Prophet : Prophet 由脸书核心数据科学团队发布，是脸书开发的一个开源库，旨在对单变量时间序列数据进行自动预测。
LSTM :长短期记忆(LSTM)是一种递归神经网络，可以学习序列中项目之间的顺序依赖关系。它常用于解决时间序列预测问题。

这个清单当然不是详尽无遗的。许多复杂的模型或方法，如广义自回归条件异方差 (GARCH)和贝叶斯结构时间序列 (BS 时间序列)在某些情况下可能非常有用。还有像神经网络自回归 (NNAR)这样的神经网络模型，可以应用于使用滞后预测器的时间序列，并且可以处理特征。

时间序列模型中的评价指标

预测评估包括度量标准，如标度相关误差，如均方误差(MSE)和均方根误差(RMSE)，百分比误差，如平均绝对百分比误差(MAPE)，标度误差，如平均绝对标度误差(MASE)等等。这些指标实际上类似于静态 ML 指标。

然而，虽然评估指标有助于确定拟合值与实际值的接近程度，但它们不能评估模型是否适合时间序列。为此，我们做了一些叫做残差诊断的事情。详细了解这里。

处理异常值/异常情况

离群值困扰着几乎所有真实世界的数据。时间序列和静态数据从识别到处理异常值/异常值采取了两条完全不同的路线。

识别

对于静态数据中的识别，我们使用从 Z 得分、箱线图分析到一些高级统计技术(如假设检验)的技术。
在时间序列中，我们使用了一系列的技术和算法，从 STL 分析到隔离森林等算法。你可以在这里阅读更多细节。

处理

我们在静态数据中使用诸如修整、基于分位数的下限和上限以及均值/中值插补等方法，具体取决于容量和手头的问题陈述。
在时间序列数据中，有许多选项对您的用例来说是高度主观的。其中一些是:
- 使用替换:我们可以计算出可以替换离群值的值，并使其更适合数据。R 中的 tsclean()函数将使用黄土拟合稳健趋势(对于非季节性序列)，或者使用 STL 拟合稳健趋势和季节性分量(对于季节性序列)来计算替换值。
- 研究业务:这不是一种技术方法，而是一种特别的方法。你看，识别和研究问题背后的业务真的可以帮助处理离群值。放弃或取代它是否是一个明智的选择，首先要从里到外研究它。

处理时序数据和预测时的最佳实践

虽然在处理时间序列和预测时没有固定的步骤可以遵循，但仍然有一些可以用来获得最佳结果的好方法。

没有放之四海而皆准的方法:没有一种预测方法对所有时间序列都是最佳的。在开始预测之前，您需要了解问题陈述、功能类型和目标。您可以根据需要选择算法的一些领域(计算+目标):
- 统计模型，
- 机器学习，
- 和混合方法。
特性选择:特性的选择会影响最终的预测误差。换句话说，选择必须仔细进行。有不同的方法，如相关性分析，也称为过滤器、包装器(即迭代添加或移除特征)，以及嵌入(即选择已经是预测方法的一部分)。
应对过度拟合:在模型训练期间，可能会出现过度拟合的风险，因为最佳模型并不总是导致最佳预测。为了解决过度拟合问题，可以将历史数据分为训练和测试数据，并进行内部验证。
数据预处理 :首先要对数据进行分析和预处理，使其干净，便于预测。数据可能包含缺失值，由于大多数预测方法无法处理缺失值，因此必须对值进行估算。
牢记维度的诅咒:当训练中的模型呈现出许多维度和许多潜在因素时，它们可能会遇到维度的诅咒，这意味着当我们拥有有限数量的训练数据，并且我们向这些数据添加更多维度时，我们在准确性方面的回报开始递减。
使用季节性数据模式:如果时间序列数据中存在季节性，则需要包含该季节性模式的多个周期才能做出正确的预测。否则，模型没有办法学习模式。
在进行预测之前处理异常现象:异常现象会在模型学习中产生巨大的偏差，更常见的情况是结果总是低于标准。
仔细研究问题陈述:这可能是最被低估的实践，尤其是当你刚刚开始处理一个时序问题的时候。确定基于时间和非基于时间的特征，在使用任何标准技术之前先研究数据。

你已经到达终点了！

我们成功地理解了时间序列和静态数据在结构和方法上的差异。本博客中列出的部分绝非详尽无遗。当我们针对每个领域中的具体数据问题进行更细致的分析时，可能会有更多的差异。在研究时间序列时，你可以参考以下一些我最喜欢的资源:

参考

时序项目:有帮助的工具、包和库

原文：https://web.archive.org/web/https://neptune.ai/blog/time-series-tools-packages-libraries

既然你在这里，你大概知道时间序列数据和静态 ML 数据有点不同。因此，当从事时间序列项目时，数据科学家或 ML 工程师通常会使用特定的工具和库。或者他们使用众所周知的工具，这些工具已经被证明可以很好地适应时间序列项目。

我们认为把这些工具集中在一个地方会很有用，所以我们来了。这篇文章是一个时间序列工具和软件包的数据库。其中有些是众所周知的，有些可能对你来说是新的。希望你会发现整个列表有用！

在我们深入研究工具之前，让我们先了解一些基础知识。

什么是时间序列？

时间序列是按时间顺序排列的数据点序列。它是对同一变量在连续时间点的观察。换句话说，这是一组在一段时间内观察到的数据。

数据通常被绘制成图表上的一条线，x 轴是时间，y 轴是每个点的值。此外，时间序列有四个主要组成部分:

1 趋势

2 季节变化

3 周期性变化
4 不规则或随机变化
趋势简单来说就是数据在许多时期内的总体变化方向，它是数据的长期模式。趋势通常会出现一段时间，然后消失或改变方向。例如，在金融市场中,“看涨趋势”表示金融资产价格总体上升的上升趋势，而“看跌趋势”表示价格下降。
广义而言，时间序列的趋势可以是:

上升趋势:一个时间序列在一个观察周期内上升。

下降趋势:一个时间序列在一个观察周期内下降。

恒定或水平趋势:一个时间序列在一段观察时间内没有显著的上升或下降。
季节性变化或季节性是查看时间序列时要考虑的一个重要因素，因为它可以根据过去的数据提供未来可能发生的事情的信息。它是指一个或多个季节(如冬季和夏季)中某个度量值的变化，但也可能是每天、每周或每月的变化。例如，温度具有季节性，因为夏季较高，冬季较低。
与季节性变化相反，周期性变化没有精确的时间段，可能会有一些时间漂移。例如，金融市场倾向于在高值和低值之间循环，但是在它们之间没有预先确定的时间段。此外，一个时间序列可以有季节性和周期性的变化。例如，众所周知，房地产市场有周期性和季节性模式。季节性模式显示，春季的交易量比夏季多。循环模式反映了人们的购买力，这意味着在危机中，与繁荣时期相比，销售会减少。

不规则或随机变化是在趋势、季节和周期成分被去除后剩下的。因此，它也被称为剩余成分。这是一个完全随机且无法预测的时间序列中的非系统部分。

In contrast to seasonal variations, cyclic variations don’t have precise time periods and might have some drifts in time. For instance, financial markets tend to cycle between periods of high and low values, but there is no predetermined period of time between them. Besides that, a time series can have both seasonal and cyclic variations. For instance, it’s known that the real estate market has both cyclic and seasonal patterns. The seasonal pattern shows that there are more transactions in the spring rather than in the summer. The cyclic pattern reflects the purchasing power of the people, which means that in a crisis there are fewer sales in contrast to the time when there is prosperity.

一般来说，时间序列经常被用于许多领域，如经济学、数学、生物学、物理学、气象学等。具体来说，时间序列数据的一些例子是:

道琼斯工业平均指数价格

Time series components |Source

纽约市的气温

比特币价格
心电图信号
术语 MLOps 的 Google 趋势
美国的失业率
通过时间和类似的网站流量
在本文中，我们将看看前面提到的几个例子。
时序项目示例

股票市场预测

股票市场预测是一个具有挑战性和吸引力的话题，其主要目标是开发预测未来股票价格的不同方法和策略。有很多不同的技术，从经典的算法和统计方法到复杂的神经网络架构。共同点是它们都利用不同的时间序列来实现准确的预测。业余投资者、金融科技初创公司和大型对冲基金广泛使用股市预测方法。

在实践中使用股市预测方法的方式有很多，但最流行的可能是交易。证券交易所的自动交易数量正在上升，据估计，美国证券交易所交易的股票中约有 75%来自算法系统。预测股票未来表现的方法主要有两种:基本面分析和技术分析。

基本面分析着眼于公司的财务报表、管理和行业趋势等因素。此外，它还考虑了一些宏观经济指标，如通货膨胀率、国内生产总值、经济状况等。所有这些指标都与时间有关，因此可以用时间序列来表示。

与基本面分析相反，技术分析利用交易量、价格变化的模式以及来自市场本身的其他信息来预测股票未来的表现。投资者在做出投资决定之前了解这两种方法是很重要的。

比特币价格预测

比特币是一种价格大幅波动的数字货币。它也是世界上最不稳定的资产之一。比特币的价格是由供求决定的。当对比特币的需求增加时，价格就会上涨，当需求下降时，价格就会下跌。随着近年来需求的增加，价格也在上涨。由于其非常不稳定的性质，预测比特币的未来价格是一项非常具有挑战性的任务。

总的来说，这个问题和股市预测很像，几乎可以用同样的方法来解决。甚至比特币也被证明与标准普尔 500 和道琼斯等指数相关。这意味着，在某种程度上，比特币的价格跟随上述指数的价格。你可以在这里了解更多信息:

Technical indicators example | Source

心电图异常检测

心电图异常检测是一种检测心电图异常的技术。心电图是一种监测心脏电活动的测试。基本上，它是由心脏产生的电信号，并表示为时间序列。

ECG 异常检测是通过比较 ECG 的正常模式和异常模式来完成的。心电图中有许多类型的异常，它们可以分类如下:

心率异常:这是指心率偏离正常范围的任何变化。这可能是由于心脏的问题或刺激方式的问题。

心律异常:心律异常是指任何与其正常模式不同的心律变化。这可能是由于脉冲通过心脏传导的方式有问题，或者脉冲通过心脏传导的速度有问题。

在这个课题上已经做了很多工作，从学术研究到商用心电图机，都有一些很有前景的成果。最大的问题是，该系统应该具有高水平的准确性，并且不应该有任何假阳性或假阴性。这是由于问题的性质和错误预测的后果。

**Heart rate anomalies: ** this refers to any change in heart rate from its normal range. This may be due to a problem with the heart or a problem with how it is being stimulated.
既然现在我们已经有了一些关于时间序列在行业中的重要性的背景知识，那么让我们来看看一些流行的工具、包和库，它们对任何时间序列项目都是有帮助的。此外，由于大多数与时间序列相关的数据科学和机器学习项目都是用 Python 完成的，因此讨论 Python 支持的工具是有意义的。

我们将主要从四个类别来讨论工具:

ECG anomalies detection | Source

1 数据准备和特征工程工具

2 数据分析和可视化包

3 实验跟踪工具

4 时间序列预测包
时间序列的数据准备和特征工程工具
数据准备和特征工程是数据科学管道中两个非常重要的步骤。数据准备通常是任何数据科学项目的第一步。它是将数据转换成可用于分析和进一步处理的形式的过程。
特征工程是从原始数据中提取特征以使其对建模和预测更有用的过程。下面，我们将提到一些用于这些任务的最流行的工具。

熊猫时间系列项目

Pandas 是一个用于数据操作和分析的 Python 库。它包括数据结构和处理数字表格和时间序列的方法。此外，它还包含用于处理所有领域的时间序列数据的广泛功能和特性。

它支持各种文件类型的数据输入，包括 CSV、JSON、Parquet、SQL 数据库表和查询以及 Microsoft Excel。此外，Pandas 允许各种数据操作特性，如合并、整形、选择以及数据清理和争论。

一些有用的时间序列特征是:

日期范围生成和频率转换

移动窗口统计

移动窗口线性回归

日期转换
滞后和更多
时间序列的更多相关内容可在下面找到:
使用 NumPy 的时序项目
NumPy 是一个 Python 库，它增加了对巨大的多维数组和矩阵的支持，以及可能在这些数组上使用的大量高级数学函数。它有一个与 MATLAB 非常相似的语法，包括一个高性能的多维数组对象以及处理这些数组的功能。

NumPy 的 datetime64 数据类型和数组可以非常紧凑地表示时间序列中的日期。使用 NumPy 还使得使用线性代数运算进行各种时间序列运算变得简单。

NumPy 文档和教程:

带日期时间的时序项目

Datetime 是一个 Python 模块，它允许我们处理日期和时间。本模块包含处理以下情况所需的方法和功能:

日期和时间的表示

日期和时间的算术

日期和时间的比较

使用这个工具处理时间序列很简单。它允许用户将日期和时间转换成对象并操纵它们。例如，只需几行代码，我们就可以将一种日期时间格式转换为另一种格式，添加到日期的天数、月数或年数，或者计算两个时间对象之间的秒差。
关于如何开始学习本模块的有用文档:
使用 Tsfresh 的时间序列项目

Tsfresh 是一个 Python 包。它自动计算大量的时间序列特征，称为特征。该软件包将统计学、时间序列分析、信号处理和非线性动力学中的既定算法与稳健的特征选择算法相结合，以提供系统的时间序列特征提取。

Tsfresh 包包含一个过滤过程，以防止提取不相关的特征。这个过滤过程评估每个特征对回归或分类任务的解释能力和重要性。

高级时间序列功能的一些示例如下:

傅立叶变换分量

小波变换

部分自相关和其他

有关 Tsfresh 软件包的更多信息，请参见以下内容:
时间序列的数据分析和可视化软件包
数据分析和可视化包是帮助数据分析师根据数据创建图形和图表的工具。数据分析被定义为对数据进行清理、转换和建模的过程，目的是发现对商业决策有用的信息。数据分析的目标是从数据中提取有用的信息，并根据这些信息做出决策。

数据的图形表示被称为数据可视化。数据可视化工具使用图表和图形等可视化元素，提供了一种查看和理解数据趋势和模式的简单方法。

有各种各样的时间序列数据分析和可视化软件包，我们将浏览其中的几个。

使用 Matplotlib 的时序项目

可能最流行的数据可视化 Python 包是 Matplotlib。它用于创建静态、动画和交互式可视化。使用 Matplotlib 可以做一些事情，例如:

制作适合出版的情节

创建可以放大、平移和更新的交互式图形

更改视觉样式和布局

此外，它还为绘制时间序列图表提供了各种选项。更多信息请点击下面的链接:
Create interactive figures that can be zoomed in, panned, and updated
使用 Plotly 的时间序列项目

Plotly 是一个用于 Python 和 r 的交互式、开源和基于浏览器的图形库。它是一个高级的、声明性的图形库，有 30 多种图表类型，包括科学图表、3D 图表、统计图表、SVG 地图、金融图表等等。

除此之外，使用 Plotly 还可以绘制基于时间序列的交互式图表，如线条、gantts、散点图等。文档中提供了关于此包的更多信息:

Example of the Matplotlib chart with time series | Source: Author

Time series projects with Plotly

具有统计模型的时间序列项目

Statsmodels 是一个 Python 包，它提供了用于估计各种统计模型以及运行统计测试和统计数据分析的类和函数。

我们将在关于预测的章节中更详细地介绍这个库，但这里值得一提的是，它为时间序列分解及其可视化提供了一个非常方便的方法。有了这个软件包，我们可以很容易地分解任何时间序列，并分析其组成部分，如趋势，季节性成分，残差或噪音。教程中对此有更多描述:

Example of the Plotly chart with time series | Source

时间序列的实验跟踪工具

实验跟踪工具通常是高级工具，可用于各种目的，如跟踪实验结果，显示如果改变实验中的参数会发生什么，模型管理等。

它们通常比低级包更加用户友好，并且在开发机器学习模型时可以节省大量时间。这里只提到其中的两个，因为它们很可能是最受欢迎的。

对于时间序列，有一个方便的环境来跟踪定义的度量和超参数尤其重要，因为我们很可能需要运行许多不同的实验。通常，与一些卷积神经网络相比，时间序列模型并不大，并且作为输入，具有几百或几千个数值，因此模型训练得相当快。此外，它们通常需要相当长的时间来进行超参数调整。

最后，在一个地方连接来自不同包以及可视化工具的模型是非常有益的。

使用 Neptune.ai 的时间序列项目

Neptune.ai 是一个由超过 20，000 名数据科学家、机器学习工程师和研究人员使用的实验跟踪工具。它为在单一位置组织和控制模型提供了一个方便的界面。

有了 Neptune.ai，就有可能

记录关于每个模型的数据集、参数和代码的信息。

将所有的指标、图表和任何其他 ML 元数据组织在一个地方。

轻松的可重复模型训练并进行比较。

备份云上的所有内容。
将它与超过 25 个库集成，如 PyTorch、TensorFlow、Matplotlib 等。
对于任何类型的数据，时间序列也不例外，任何包含时间序列的项目都可以在 Neptune.ai 上跟踪。
处理时间序列时有用的资源:
具有权重和偏差的时间序列项目

weights & bias(W & B)是一个机器学习平台，类似于 Neptune.ai，旨在帮助开发者更快地建立更好的模型。它旨在支持和优化关键的 MLOps 生命周期步骤，如模型管理、实验跟踪和数据集版本控制。

Example Neptune.ai dashboard for a time series run | Source

它只为个人项目提供有限的免费选项，而其他选项每月 50 美元起。作为 Neptune.ai，这个工具在处理时间序列项目时非常有用，为跟踪和管理时间序列模型提供了有用的功能。

Time series projects with Weights & Biases

他们的文档中提供了更多关于权重和偏差的信息。

时间序列预测包

时间序列项目最重要的部分可能是预测。预测是根据当前和过去的数据预测未来事件的过程。这是基于未来可以从过去实现的假设。此外，它还假设数据中有一些模式可以用来预测接下来会发生什么。

ML experiment tracking with Weights and Biases | Source

时间序列预测有许多方法，从简单的线性回归和基于 ARIMA 的方法，到复杂的多层神经网络或集成模型。在这里，我们将展示一些支持不同类型模型的包。

基于统计模型的时间序列预测

Statsmodels 是一个包，我们已经在关于数据可视化工具的部分提到过。但是，这是一个更适合预测的软件包。基本上，这个软件包提供了一系列的统计模型和假设检验。

Statsmodels 包还包括用于时间序列分析的模型类和函数。自回归移动平均模型(ARMA)和向量自回归模型(VAR)是基本模型的例子。马尔可夫转换动态回归和自回归是非线性模型的例子。它还包括时间序列描述统计，如自相关，部分自相关函数，周期图，以及 ARMA 或相关过程的理论性质。

下面介绍了如何使用 Statsmodels 包开始使用时间序列:

Pmdarima 时间序列预测

Pmdarima 是一个统计库，它使用基于 arima 的方法为时间序列建模提供了便利。除此之外，它还有其他功能，例如:

平稳性和季节性的一组统计检验

各种内源和外源变换，包括 Box-Cox 和傅立叶变换

季节性时间序列的分解、交叉验证工具和其他工具

也许这个库最有用的工具是 Auto-Arima 模块，它在提供的约束条件下搜索所有可能的 Arima 模型，并根据 AIC 或 BIC 值返回最佳模型。
有关 Pmdarima 的更多信息，请参见:
用 Sklearn 进行时间序列预测

Sklearn 或 Scikit-Learn 肯定是 Python 中最常用的机器学习包之一。它提供了各种分类、回归和聚类方法，包括随机森林、支持向量机、k-means 等。除此之外，它还提供了一些与降维、模型选择、数据预处理等相关的实用工具。

除了各种模型之外，对于时间序列，还有一些有用的功能，如管道、时间序列交叉验证功能、测量结果的各种度量标准等。

Time series forecasting with Sklearn

关于这个库的更多信息可以在下面找到:

用 PyTorch 进行时间序列预测

PyTorch 是一个基于 Python 的深度学习库，用于快速灵活的实验。它最初是由脸书人工智能研究团队的研究人员和工程师开发的，然后开源。深度学习软件如 Tesla Autopilot、优步的 Pyro 和 Hugging Face 的 Transformers 都建立在 PyTorch 之上。

Time series split using Sklearn | Source

使用 PyTorch，可以建立强大的递归神经网络模型，如 LSTM 和 GRU，并预测时间序列。此外，还有一个 PyTorch 预测包，具有最先进的网络架构。它还包括一个时间序列数据集类，抽象处理变量转换、缺失值、随机子采样、多个历史长度和其他类似问题。关于这一点的更多信息如下:

基于张量流的时间序列预测

TensorFlow 是一个用于机器学习的开源软件库，基于数据流图。它最初由 Google Brain 团队开发，供内部使用，但后来作为开源项目发布。该软件库提供了一组高级数据流运算符，这些运算符可以组合起来以自然的方式表达涉及多维数据数组、矩阵和高阶张量的复杂计算。它还提供了一些底层原语，比如内核，用于构造自定义操作符或加速常见操作的执行。

Keras 是一个构建在 TensorFlow 之上的高级 API。使用 Keras 和 TensorFlow 可以为时间序列预测建立神经网络模型。下面的教程解释了使用天气时间序列数据集的时间序列项目的一个示例:

利用 Sktime 进行时间序列预测

Sktime 是一个用于时间序列和机器学习的开源 Python 库。它包括有效解决时间序列回归、预测和分类任务所需的算法和转换工具。创建 Sktime 是为了与 scikit-learn 一起工作，并使其易于为相关的时间序列任务调整算法以及构建复合模型。

总的来说，该套件提供:

时间序列预测的最新算法

时间序列的转换，如去趋势化或去季节化等

模型和转换的管道，模型调整工具，以及其他有用的功能

下面介绍了如何开始使用该库:
用 Prophet 进行时间序列预测
Prophet 是由脸书的核心数据科学团队发布的开源库。简而言之，它包括一个用于预测时间序列数据的程序，该程序基于一个加法模型，该模型将几个非线性趋势与年度、周和日季节性以及假日效应结合起来。它最适用于具有强烈季节性影响的时间序列和多个季节的历史数据。它能够处理缺失数据、趋势变化和异常值。

关于先知图书馆的更多信息如下:

用 Pycaret 进行时间序列预测

PyCaret 是 Python 中的一个开源机器学习库，可以自动化机器学习工作流。使用 PyCaret，可以用最少的工作和几行代码构建和测试几个机器学习模型。

基本上，用最少的代码，不深究细节，就可以构建一个从 EDA 到部署的端到端的机器学习项目。

这个库有一些有用的时间序列模型，其中包括:

季节性天真预测者

ARIMA

多项式趋势预测器

套索网有去季节化和去趋势化选项和许多其他选项
ARIMA
有关 PyCaret 的更多信息，请点击此处:
用 AutoTS 进行时间序列预测

AutoTS 是 Python 的时间序列包，旨在自动进行时间序列预测。它可用于寻找单变量和多变量时间序列的最佳时间序列预测模型。此外，AutoTS 本身会清除任何 NaN 值或异常值。

Anomaly detection using PyCaret | Source

近 20 个预定义的模型，如 ARIMA，ETS，VECM 可用，并使用遗传算法，为给定的数据集找到最佳的模型，预处理和集成。

关于这个包的一些教程是:

用飞镖进行时间序列预测

Darts 是一个 Python 库，允许对时间序列进行简单的操作和预测。它包括各种各样的模型，从经典的 es 和 ARIMA 到 RNN 和变形金刚。所有模型的使用方式都与 scikit-learn 包中的方式相同。

该库还允许对模型进行简单的回溯测试，合并来自多个模型的预测，以及合并外部数据。它支持单变量和多变量模型。所有可用型号的列表以及几个示例可在此处找到:

基于 Kats 的时间序列预测

Kats 是由脸书基础设施数据科学团队发布的软件包，旨在执行时间序列分析。这个包的目标是提供时间序列分析所需的一切，包括检测、预测、特征提取/嵌入、多变量分析等等。

Kats 提供了一套全面的预测工具，如集成、元学习模型、回溯测试、超参数调整和经验预测区间。此外，它还包括检测时间序列数据中的季节性、异常值、变化点和缓慢趋势变化的功能。使用 TSFeature 选项，可以生成 65 个具有清晰统计定义的特征，这些特征可用于大多数机器学习模型。

关于 Kats 包的更多信息描述如下:

预测库比较

为了便于比较预测包并有一个高层次的概述，下面是一个具有一些共同特征的表格。它显示了一些指标，如 GitHub 星级、发布年份、支持特性等。

More about Kats package is described below:

发行年份

GitHub stars

统计学和计量经济学

机器学习

深度学习

✅ ✅

深度学习:

✅

Statistics & econometrics:

深度学习:

✅

Statistics & econometrics:

统计学&计量经济学:

Statistics & econometrics:

✅

深度学习:

✅

Statistics & econometrics:

深度学习:

✅

Statistics & econometrics:

✅

深度学习:

Statistics & econometrics:

✅

Statistics & econometrics:

✅

深度学习:

Statistics & econometrics:

结论

Statistics & econometrics:

在这篇文章中，我们描述了时序项目最常用的工具、包和库。有了这个工具列表，就有可能涵盖几乎所有与时间序列相关的项目。除此之外，我们还提供了预测库的比较，显示了一些有趣的统计数据，比如发布年份、流行程度以及它支持哪种模型。

如果您想更深入地了解时间序列领域，可以使用一组不同的包来处理时间序列:“ Github:使用 Python 处理时间序列数据”。

对于那些想从理论上了解更多时间序列的人来说，Helmut Lütkepohl 教授的书《多时间序列分析新入门》是一个很好的选择。

你搞砸了

Enes 是一名拥有三年多经验的数据科学家。Enes 在数学、计算机科学和机器学习方面有很强的背景，并且热衷于学习和探索与机器学习相关的任何领域。你可以在 Linkedin 上和他联系。

阅读下一篇

使用机器学习预测股票价格

9 分钟阅读|作者凯瑟琳(易)李| 2022 年 1 月 25 日更新

READ NEXT

众所周知，股票市场是不稳定的，动态的，非线性的。由于多种(宏观和微观)因素，如政治、全球经济状况、意外事件、公司财务表现等，准确的股价预测极具挑战性。

但是，所有这些也意味着有大量的数据可以从中发现模式。因此，金融分析师、研究人员和数据科学家不断探索分析技术，以检测股市趋势。这就产生了算法交易的概念，它使用自动化的、预编程的交易策略来执行订单。

在本文中，我们将使用传统的量化金融方法和机器学习算法来预测股票走势。我们将讨论以下主题:

股票分析:基本面与技术面分析

作为时间序列数据的股票价格及相关概念

用移动平均技术预测股票价格

LSTMs 简介
用 LSTM 模型预测股票价格
对新方法的最终想法，如 ESN
Introduction to LSTMs
Predicting stock prices with an LSTM model
Final thoughts on new methodologies, such as ESN

Continue reading ->

MLOps 设置技巧——我们从 7 ML 专家那里学到的东西

原文：https://web.archive.org/web/https://neptune.ai/blog/tips-for-mlops-setup

与两年前相比，术语“MLOps”现在已经获得了更多的关注，当时它主要被认为是一个“流行语”。今天，机器学习(ML)开发人员通常会通过与 DevOps 的概念进行比较，对该术语有一个清晰的概念，而不是模糊的解释。

这种发展可以归功于 ML 解决方案数量的增加以及随之而来的竞争优势需求的增加。但是 MLOps 如何帮助实现这一目标呢？

MLOps 帮助 ML 团队开发解决方案，并以标准化、快速和最少出错的方式将它们投入生产。这是通过安装在 ML 管道中的一组指导方针和自动化功能来实现的，这些指导方针和自动化功能可以帮助不同的团队轻松地相互协作。

考虑到这一点，在现有渠道的基础上利用和设置 MLOps 的最佳方式是什么？为了最好地回答这个问题，我们收集了 7 位 MLOps 专家的见解！

以下是我们对他们建议的分类:

治理准则
团队协作
时间作为一种度量
版本控制和数据记录
变形 MLOps 功能

创建可靠的治理指导方针

一套标准的规则设定了机器学习团队在共同基础上合作的方式。如果没有适当的指导方针，您可能会在项目中原地打转。治理指南涵盖了 ML 管道的每个阶段，从构思和数据收集阶段到再培训和监控。

Imtiaz Adam 指出了建立可靠的 MLOps 渠道的治理需求:

“良好的治理和清晰性有助于数据科学模型和绩效反馈的顺利集成。所以，处理数据漂移的能力，干净清晰的 API，便携干净的 docker 映像，自动化文档。”–Imtiaz Adam,深度学习策略有限公司的创始人兼策略和数据科学总监

良好的治理规则也为标准化铺平了道路，标准化是减少重复劳动和时间损失的关键因素。简单来说，标准化指的是一组通用的核心流程，允许开发人员最大化代码和通信的价值。事实上，正如亚马逊的技术经理 Greg Coquillo 所说，标准化的沟通渠道也是必不可少的。想象一下，当您知道在任何给定的沟通阶段需要交换的确切信息时，可以节省多少时间。

“我会说，在 ML 开发过程中，基于数据质量和可用性以及与业务团队的沟通循环，实施标准化的功能工程和选择程序。”–Greg Coquillo,亚马逊的技术经理| LinkedIn 2020 年数据科学和人工智能的最高呼声

在个人贡献者身上播下 MLOps 的种子

在公司部门开始采用 AI/ML 解决方案的最初几年，MLOps 甚至不是一个合适的术语。然而，随着公司开始从概念验证项目中看到巨大的成果，他们希望将人工智能功能添加到他们的产品中。这意味着 ML 代码的无错快速生产，团队能够生产这些代码，因为他们只需要管理一次性的 ML 项目。

随着时间的推移，管理的 ML 项目的数量显著增加，但是一些开发人员的方法仍然停滞不前。因此，即使 MLOps 能力支持 ML 团队标准化生产高容量和高质量的 ML 解决方案，仍有开发者可能对采用新技术犹豫不决。

“就像大多数事情一样，实践背后的人是最重要的。要正确实施 MLOps，团队中的每个人都需要同意有正确的做事方法。为了与软件开发相提并论，需要一个忽视测试覆盖率的流氓开发人员来发布损坏的代码。当每个人都同意机器学习应该是协作的、可重复的和持续的，系统和实践将会更容易实现。”–托尼·佩尔姆基,瓦罗海的首席运营官

就像来自 Valohai 的 Toni perm ki 与软件开发做了一个非常相关的类比，也有计算机安全的类似场景。一个组织的安全性取决于其最薄弱的资源。一个员工甚至一个系统不遵守设定的安全准则，最终会破坏价值可观的安全性。

为了获得团队中每个贡献者对任何 MLOps 指导方针的认同，首先教育团队并指出不实现特定 MLOps 功能的成本是很重要的。通常，为了消除采用 MLOps 可能带来的惰性，降低性能的想法可能比收益的想法更有效。

将时间作为衡量标准进行优先排序

拟阵的创始人礼萨·扎德提出，让一个濒临死亡的机器学习模型起死回生所需的时间至关重要。重新训练一个模型所需的周转时间绝对是一个比首先构建解决方案所需的时间更重要的度量。这主要是因为一旦解决方案投入生产，只要修复还在进行，最终客户就将面临停机。

“MLOps 中最重要的实践是最大限度地减少用户处理模型漂移所需的时间。当模型(不可避免地)漂移时，您必须能够快速更新模型。时间越长，生产受到的影响就越大。这就是为什么拟阵优化的事情之一是端到端的重新训练和重新部署，允许我们的用户在几分钟内修复漂移。”–礼萨·扎德,拟阵的创始人兼首席执行官

为了能够减少模型更新的周转时间，监控、再培训和特征工程等 ML 流水线阶段必须尽可能标准化和自动化。

此外，减少周转时间需要一个装备良好的监控能力，可以跟踪主要的模型漂移并立即警告团队。为了使模型监控过程有效，可以使用一系列度量标准，例如数据漂移、元数据和模型漂移。

版本控制和数据记录

版本化是机器学习实验和结果得以重现的唯一途径。ML 团队在选择最佳实验时，甚至在排除故障时，结果的再现性都是至关重要的。版本化可以分为两种类型:

数据版本化:跟踪和存储用于不同 ML 实验的不同数据集及其元数据。
模型版本化:跨各种 ML 实验跟踪和存储模型的参数和元数据。

类似地，日志记录是在构建解决方案的过程中跟踪变化的一种方式。

在减少周转时间方面，当 ML 解决方案中出现问题或者如果模型需要重新训练时，模型版本控制和数据记录可以帮助开发人员通过检查不适当元素的 ML 阶段来快速排除故障。这就是为什么跟踪 ML 流水线中的变化对于减少时间投入以及提高生产过程的质量至关重要。

版本控制和数据记录的重要性得到了进一步强调，因为我们的两位 ML 专家在推荐设置 MLOps 的最佳技巧时意见一致:

“将显著改进任何 MLOps 实现的最简单的实践是特定于数据的日志记录。如果您只是在 ML 管道的每一步记录数据帧的统计属性，并在推断过程中连续记录，您将立即加快调试速度，减少解决任何问题的时间，并显著简化所有错误分析笔记本。日志记录是任何软件开发中的最佳实践，对于通常缺乏透明性和可再现性的 ML 系统，日志记录是您能用几行代码对您的管道所做的最有影响力的事情。尝试一个开源库，让日志记录变得更容易。”–阿莱西娅·维森吉奇,why labs的首席执行官兼联合创始人

“我认为在模型库中收集和维护起源可能是 MLOps 实现中最有用和最关键的实践。当当前部署的模型出现问题时，您需要有能力倒回到模型的以前版本，或者至少有能力比较和解释模型的不同版本之间的不同结果，特别是当利益相关者问为什么事情会不同时，他们会问。”–柯克·伯恩，博士，数据犯罪公司的首席科学官

变形 MLOps 功能以适应流程

菲尔·温德(Phil Winder)提供了一个禅宗式的最佳实践技巧，为思考提供了重要的食物。这条建议可能类似于亚里士多德的名言:“了解你自己是所有智慧的开始”。将同样的方法应用于 MLOps 的采用，考虑 MLOps 只不过是增强现有 ML 管道的一种方式，并且如果没有对组织的 ML 架构的透彻理解，MLOps 的用途是最小的。

“我的第一条建议是，MLOps 不是一种工具。它不是一个产品。它描述了自动化和简化构建人工智能相关产品和服务的过程的尝试。因此，花时间定义您的过程，然后找到适合该过程的工具和技术。例如，银行的流程与科技创业公司的流程大相径庭。因此，最终的 MLOps 实践和堆栈也会非常不同。”–菲尔·温德,温德研究公司首席执行官

在您的组织中设置 MLOps 的更多最佳实践

如果计划不周，随着时间的推移，运行端到端的 ML 管道会使组织的资源紧张。因此，在设置 MLOps 指导方针时，务必注意可用的财务、人工和机器资源，以便能够创建分配计划。

CI/CD 管道自动化

CI 代表持续集成，这个模块负责在自动化的帮助下跨各种测试用例、运行时和环境持续构建和测试解决方案。CD 代表持续部署，负责自动处理生产环境。在建立 MLOps 渠道时，CI/CD 自动化应该是最终目标，即使一开始并不可行。

跟踪运营指标

定期跟踪 ML 管道的性能是非常有益的。前面我们讨论了再培训的周转时间，还有几个其他指标，当结合起来时，可以准确地反映管道的健康状况。这些指标包括部署时间、处理时间、再培训频率等等。

最后一个音符

稳定可靠的 MLOps 管道现在是当务之急，尤其是对于那些希望大规模实现机器学习的组织。ML 项目、工具和团队总是随着领域的指数级发展而变化，MLOps 提供了优化变更管理的正确手段。在最少扰动的情况下，质量、数量和时间等因素不会因为 MLOps 而受到影响。

借助来自行业精英的最佳技巧，您无疑离构建适合您组织的 MLOps 更近了一步。

萨马德里塔·戈什

一个内容营销和 AI 爱好者。她的使命是帮助基于人工智能的公司建立品牌知名度，并通过高质量的内容抓住网民的巨大市场，无论是信息丰富的博客还是教育播客！

阅读下一篇

最佳 MLOps 工具以及如何评估它们

12 分钟阅读| Jakub Czakon |年 8 月 25 日更新

在我们的一篇文章中——机器学习团队实际使用的最好的工具、库、框架和方法——我们从 41 家 ML 初创公司学到的东西——Acerta 的 CTO Jean-Christophe Petkovich 解释了他们的 ML 团队如何接近 MLOps。

据他所说，一个完整的 MLOps 系统有几个要素:

您需要能够构建包含预处理数据和生成结果所需的所有信息的模型工件。
一旦您能够构建模型工件，您必须能够跟踪构建它们的代码，以及它们被训练和测试的数据。
您需要跟踪所有这三样东西，模型、它们的代码和它们的数据，是如何关联的。
一旦您可以跟踪所有这些内容，您还可以将它们标记为准备就绪，进行生产，并通过 CI/CD 流程运行它们。
最后，为了在该过程的最后实际部署它们，您需要某种方法来基于该模型工件旋转服务。

这是对如何在公司中成功实施 MLOps 的高度概括。但是理解高层需要什么只是拼图的一部分。另一个是采用或创建适当的工具来完成工作。

这就是为什么我们编制了一份最佳 MLOps 工具的清单。我们将它们分为六类，以便您可以为您的团队和业务选择合适的工具。让我们开始吧！

Continue reading ->

训练最先进的 NLP 模型的技巧和诀窍

原文：https://web.archive.org/web/https://neptune.ai/blog/tips-to-train-nlp-models

这是基于最先进的变压器的时代 NLP 模型。随着 huggingface 推出像变形金刚这样的软件包，为任何给定的任务训练 NLP 模型变得非常方便。但是，当每个人都在做同样的事情时，你如何获得额外的优势呢？如何从模特身上获得让你脱颖而出的额外表现？

在本文中，我将讨论一些方法、技巧和诀窍，它们可以帮助您在自然语言处理(NLP)项目中实现这一目标。

但是在此之前，让我们讨论一下 transformer 模型以及在训练它们时出现的挑战。

最先进的变压器模型

转换器是一种深度学习模型，它使用一堆编码器和解码器来处理输入数据。它使用注意机制对输入序列数据进行加权。

基于变压器的模型可以大致分为:

自回归模型:这些模型依赖于变换器的解码器部分，并使用注意屏蔽，使得在每个位置，模型只能看到当前记号之前的记号。例如，GPT。
自动编码模型:这些模型依赖于转换器的编码器部分，不使用注意屏蔽，因此模型可以看到输入序列中的所有其他标记。比如伯特。
序列到序列:型号同时使用变压器的编码器和解码器部分。

Transformers 可用于各种各样的 NLP 任务，如问题回答、序列分类、命名实体识别等。基于 transformer 的模型带来的性能也带来了一些其他挑战，如高计算量、对更大数据集的需求、训练样本中令牌数量的限制、训练不稳定性等。

你如何应对这些挑战？你可以用什么方法、技巧和窍门来训练最先进的 NLP 模型？

技巧 NLP 的迁移学习

将知识从一个模型转移到另一个模型的过程称为迁移学习。有几个任务中可用于训练的数据量非常少。由于现在使用的深度神经网络的参数数量非常大，它们非常渴望训练数据，并且很难用小的训练数据集训练出概括良好的模型。在这种情况下，迁移学习可以解决问题。

我们可以在有大量训练数据可用的类似任务上训练这些深度模型，然后使用学习到的参数对可用训练数据稀缺的目标任务进行进一步训练。通过这样做，模型的表现要比从头开始训练时好得多。有效利用迁移学习有两种可能性。就像烘烤前预热烤箱一样，我们可以在有大量训练数据的相关任务上训练模型，然后:

特征提取器:我们可以使用这个预训练的模型作为特征提取器(因此冻结模型的参数),并为我们的特定任务训练另一个简单的线性模型，该模型具有少得多的可用训练数据。
微调:或者我们可以替换特定于任务的层，以适应我们的特定任务，并继续训练整个模型。因此，基本上，预训练模型的最终参数值被用作我们特定任务训练的初始起点。

好了，我们现在熟悉了迁移学习的概念，它广泛应用于计算机视觉任务，如图像分割、物体检测等。但是这对 NLP 有用吗？如何在 NLP 中应用同样的概念？

为了回答这些问题，OpenAI 的研究人员发现，在文章 中介绍的 transformer 模型是您所需要的全部注意力 ，在大型数据语料库(如维基百科或图书语料库数据)上为语言建模任务进行预训练时，是将学习转移到各种 NLP 任务的理想选择。语言建模是给单词序列分配概率，并根据之前的单词上下文预测即将出现的单词的任务。前馈神经语言模型是标准的前馈网络，其在时间“ t 将一定数量的先前单词的表示作为输入，并输出可能的下一个单词的概率分布。

技巧 2:训练中的不稳定性

微调变压器模型的最大挑战之一是不稳定的训练。随着训练中的微小变化，例如改变随机种子，变压器模型收敛到完全不同的结果，这种现象就是我们所说的不稳定训练。不稳定的培训在工业界和学术界都是一个非常重要的问题。由于这种不稳定性，从业者经常使用不同的随机种子进行多次训练，并评估每 n 次迭代(是的，你没看错，不是每 n 个时期，而是每 n 次迭代)，其中 n 可以低至 5 次迭代，并保存最佳模型。所有这些因素都大大增加了培训时间、成本和维护费用。

这是一个在 CoLA 数据集上训练了两次的 bert-large-uncased 模型的截图。只有应用于模型的丢弃的随机种子从 12345 变化到 12346，我们注意到性能从 0.56 变化到 0.62。请随意使用我们在 Neptune dashboard 中的日志对此进行更深入的研究。

NLP Comparison of validation scores

Comparison of validation scores with different seeds

如此剧烈的不稳定性使得科学比较变得不可能。因此，研究人员正在研究使训练稳定的技术。这个问题没有通用的解决方法，但是有一些技术可以提供一些有希望的解决方案。我们已经在一个名为 Stabilizer 的开源包中实现了其中的一些技术。你可以在这里找到它。接下来，我们将向您展示一些减轻这种不稳定训练的技巧。

重新初始化

在该技术中，变换器编码器模型的最后 n 层被重新初始化。这种技术背后的想法是，由于这些变压器模型是在 MLM 和 NSP 任务上预先训练的，更接近输出的变压器的顶层学习预先训练特定于任务的参数，这些参数可能不是最适合我们自己的任务。因此，更接近输出的最后 n 层被重新初始化。这里有伪代码向你展示它是如何做到的。如果你想用一个方便的函数来做这件事，那么请使用稳定库。

分层学习率衰减

一般来说，神经网络是用应用于其所有层的统一学习速率来训练的。但是当预训练的变压器模型的顶层学习对于它被预训练的任务来说是理想的参数时，它们不提供用于微调的好的初始点。

为了减轻这种情况，我们可以对转换器的每一层应用不同的学习率。例如，我们可以对顶层应用非常高的学习率，而对底层应用小得多的学习率。为了用一个超参数轻松控制学习速率，我们使用了一种叫做分层学习速率衰减的技术。在这种技术中，当我们从顶层移动到底层时，我们以指数方式降低学习速率。这样，与可跨任务转移的较低层相比，针对 MLM 或 NSP 目标预先训练的顶层的参数变化很快。这里是伪代码，向你展示它是如何做到的。如果你想用一个方便的功能来做到这一点，那么请使用稳定库。

技巧 4:用未标记的文本数据进行预训练

现在让我们来看看一些可以用来预训练模型的目标。正如我们之前看到的，在 GPT 的情况下，模型基于变压器解码器，而在 BERT 的情况下，模型基于变压器编码器。

掩蔽语言模型目标

当用屏蔽语言模型目标进行预训练时，该模型被训练成基于单词的左右上下文来预测单词。为了用 MLM 目标进行训练，随机屏蔽一小部分输入标记，即，用特殊的[屏蔽]标记替换要屏蔽的标记。

因果语言模型目标:

当用语言模型目标进行预训练时，该模型被训练成在给定左上下文中的单词的情况下预测句子中的下一个单词。

用于预训练变压器模型的另一个常见任务是下一句预测(NSP)。在 NSP，该模型可以接受由特殊符号[SEP]分隔的一对句子作为输入，并预测二进制标签。训练数据集通过采用文档的语料库来准备，然后句子标记器将文档标记成句子。为了建立一个平衡的数据集，50%的句子时间对是从相互跟随的实际句子中创建的，而另外 50%的时间随机句子被配对在一起。这里有一个示例代码向您展示它是如何完成的。

技巧 5:用标签数据进行预训练

在上面的部分中，我们看到了基于 transformer 的模型是如何在任务独立的 LM 目标上使用文本语料库进行预训练的。这不会帮助模型学习特定于任务的特征。这造成了预训练和微调之间的差距。为了解决这个问题，我们可以进行特定任务的预训练或使用标记数据的预训练。

在这种方法中，我们在相似的数据集上训练变压器完成相似的任务。然后，我们使用这些训练好的权重来初始化模型权重，并在我们的特定任务数据集上进一步训练模型。该概念类似于计算机视觉中的转移学习，其中我们使用来自在类似任务上训练的一些模型的模型权重来初始化权重。这里你必须调整你想要初始化权重的层数。这项技术的主要挑战是找到解决类似任务的类似数据集。

让我们整合一下完成此任务的步骤:

选择基本变压器型号。让我们说，伯特
查找与给定任务和数据匹配的外部数据集。
在外部数据集上训练基础模型并保存模型权重。
使用这些训练的模型权重再次初始化基础模型。
现在，针对给定的任务，使用您的数据集训练该模型。
调整初始化的层数以获得更好的性能。

这里有伪代码向你展示它是如何做到的。

对未标记数据的预训练仅帮助模型学习一般语言领域特定的特征。与使用未标记的数据进行预训练相比，使用标记的数据进行预训练使模型学习到更多特定于任务的特征。

技巧 6:伪标签

在任何深度学习模型中提高泛化能力和鲁棒性的一个简单方法是使用更多的数据进行模型训练。大多数情况下，您可以访问一些您可以使用的未标记的数据，但是标记它是一项缓慢的任务。这时伪标签就大有帮助了。

伪标记是一种半监督方法，将大量未标记数据与标记数据相结合，用于模型训练。在这种方法中，我们不是手动标记未标记的数据，而是使用一个经过训练的模型来近似标记，然后将这个新标记的数据与训练集一起输入，以重新训练模型。

Flowchart for pseudo labeling

Flowchart for pseudo labeling | Source: Author

我们现在可以合并步骤来进行伪标记:

用训练数据训练和评估初始模型
收集未标记的数据用于伪标记
使用初始模型对未标记的数据进行预测
组合训练集和新标记的数据，并用该集训练新模型。

如果您正在为分类任务进行训练，您可以使用模型的置信度(预测概率)对伪标签数据进行采样。假设您使用初始二元分类器模型对 1000 个样本的未标记数据进行预测。在此之后，您已经预测了所有这些样本的概率，从中您可以使用大于 0.95 的置信度筛选出样本。通过这样做，您可以减少伪标记过程中可能出现的噪声。

影响模型性能的另一个因素是采样率，采样率是用于伪标记的未标记样本的百分比。您可以通过在保留的验证数据集上绘制采样率与评分度量图来调整采样率。

如果您使用 K-fold 方法来训练和评估您的模型，请确保在应用伪标记时没有数据泄漏。假设您在训练集上训练了一个 5 折叠模型，该模型使用 5 个折叠中的每一个在未标记的数据上创建伪标签。最后，如果您聚合这 5 个折叠预测以创建伪标记数据集并重新训练该模型，则验证分数将会过于乐观，因为用于创建伪标记的 5 个模型中有 4 个在训练时也看到了来自该验证集的样本。为了避免这种间接的数据泄漏，在每个折叠中独立地进行伪标记和再训练。****

技巧 7:实验跟踪对变压器培训的重要性

让我们承认我们都经历过电子表格噩梦。10 年前，当模型简单而确定时，实验记录表还可以。但是在当今世界，我们处理的模型有几百万个(例如，BERT 基本模型有 1.1 亿个参数，BERT 大型模型有 3.45 亿个参数)，有些事情很容易出错。正如我们之前看到的，由于变压器模型训练的不稳定性，可视化验证模型并比较运行中的配置以清楚地了解实验之间的差异非常重要。

因此，实验跟踪可以帮助我们做以下重要的事情:

对结果进行目视检查

这是我们在 Kaggle Commonlit 可读性数据集上训练一个模型时获得的两次训练运行的截图。当我们仔细观察时，我们可以注意到，其中一次运行比另一次运行多训练了几次迭代，在训练结束时，模型的性能急剧上升。鉴于 transformer 模型是如此脆弱，实验跟踪仪表板立即允许我们观察这种异常行为，并且通过它们的配置和代码跟踪功能，我们可以很容易地对此进行调查。

NLP Validation scores

Validation scores with and without SWA

训练运行的比较

使用任何可用的实验跟踪工具，如 Neptune、Wandb 或 Comet，你可以比较关于你正在跟踪的不同指标的不同实验。我们不再需要编写脚本来保存、跟踪和读取配置文件或实验日志，以便对结果进行深入分析。快速进行比较所需的大多数选项都可以通过几次点击获得，因此我们可以交互式地运行分析和训练模型。使用 Neptune 的最大优势之一是，它使这个过程变得非常容易，只需按一下按钮，就能生成视觉上吸引人的图表。下面是 Neptune 的截图，它向我们揭示了哪个参数影响了模型的性能。

Comparing different experiments in Neptune | See in the app

鉴于我们可以通过几行代码获得所有这些好处，训练大型 transformer 模型变得轻而易举！这是海王星项目的链接。快来看看！

结论

训练 NLP 模型的 SOTA 就像是在冒险乘坐过山车。该领域正在急剧发展，研究人员每天都在发现新的技巧来可靠地训练这些模型。虽然本文中提到的大多数技巧和诀窍都是高级概念，但我们希望本文中提到的伪代码可以作为一个良好的起点，来提高您当前的 NLP 模型的性能。我们希望通过这篇文章，你能够掌握很好的技术和工具，自信地训练和跟踪稳定的最先进的 NLP 模型。

自然语言处理中的标记化:类型、挑战、例子、工具

原文：https://web.archive.org/web/https://neptune.ai/blog/tokenization-in-nlp

在任何 NLP 项目中，您需要做的第一件事是文本预处理。预处理输入文本仅仅意味着将数据转换成可预测和可分析的形式。这是构建令人惊叹的 NLP 应用程序的关键一步。

预处理文本有不同的方法:

停止单词删除，
符号化，
堵塞。

其中，最重要的一步是标记化。它是将文本数据流分解成单词、术语、句子、符号或其他一些有意义的元素(称为标记)的过程。有很多开源工具可以用来执行令牌化过程。

在本文中，我们将深入探讨标记化的重要性和不同类型的标记化，探索一些实现标记化的工具，并讨论面临的挑战。

为什么我们需要标记化？

标记化是任何 NLP 流水线的第一步。它对你管道的其他部分有着重要的影响。记号赋予器将非结构化数据和自然语言文本分解成可以被视为离散元素的信息块。文档中出现的标记可以直接用作表示该文档的向量。

这就立刻把一个非结构化的字符串(文本文档)变成了适合机器学习的数值数据结构。它们也可以被计算机直接用来触发有用的动作和响应。或者它们可以在机器学习管道中用作触发更复杂决策或行为的功能。

标记化可以分隔句子、单词、字符或子词。当我们将文本拆分成句子时，我们称之为句子标记化。对于单词，我们称之为单词标记化。

句子标记化的例子

单词标记化的例子

虽然 Python 中的标记化可能很简单，但我们知道它是开发良好模型和帮助我们理解文本语料库的基础。本节将列出一些可用于标记文本内容的工具，如 NLTK、TextBlob、spacy、Gensim 和 Keras。

空白标记化

标记文本最简单的方法是在字符串中使用空格作为单词的“分隔符”。这可以通过 Python 的 split 函数来实现，该函数可用于所有 string 对象实例以及 string 内置类本身。您可以根据需要任意更改分隔符。

正如您所注意到的，这个内置的 Python 方法在标记一个简单的句子方面已经做得很好了。它的“错误”在最后一个词上，在那里它包括了带有符号“1995”的句尾标点符号。我们需要将标记与句子中相邻的标点符号和其他重要标记分开。

在下面的例子中，我们将使用逗号作为分隔符来执行句子标记化。

NLTK 单词标记化

NLTK (自然语言工具包)是一个用于自然语言处理的开源 Python 库。它为 50 多个语料库和词汇资源(如 WordNet)提供了易于使用的界面，以及一组用于分类、标记化、词干提取和标记的文本处理库。

您可以使用 NLTK 的 tokenize 模块轻松地对文本中的句子和单词进行标记。

首先，我们将从 NLTK 库中导入相关的函数:

单词和句子分词器

注意:sent_tokenize 使用来自 token izers/punkt/English . pickle 的预训练模型

基于标点符号的分词器

这个分词器根据空格和标点符号将句子拆分成单词。

我们可以注意到考虑“Amal。m " word _ token ize 中的一个单词，并在 wordpunct_tokenize 中将其拆分。

这个分词器包含了各种英语单词分词的通用规则。它分隔像(？！。；，)从相邻的标记中分离出来，并将十进制数保留为单个标记。此外，它还包含英语缩写的规则。

例如，“不”被标记为[“做”，“不”]。您可以在这个链接中找到 Treebank 标记器的所有规则。

当我们想要在像 tweets 这样的文本数据中应用标记化时，上面提到的标记化器无法产生实用的标记。通过这个问题，NLTK 有了一个专门针对 tweets 的基于规则的标记器。如果我们需要像情感分析这样的任务，我们可以将表情符号分成不同的单词。

NLTK 的多词表达式标记器(MWETokenizer)提供了一个函数 add_mwe()，允许用户在对文本使用标记器之前输入多个词表达式。更简单地说，它可以将多词表达式合并成单个令牌。

TextBlob 单词标记化

TextBlob 是一个用于处理文本数据的 Python 库。它提供了一个一致的 API，用于处理常见的自然语言处理(NLP)任务，如词性标注、名词短语提取、情感分析、分类、翻译等。

让我们从安装 TextBlob 和 NLTK 语料库开始:

$pip install -U textblob 
$python3 -m textblob.download_corpora

在下面的代码中，我们使用 TextBlob 库执行单词标记化:

我们可以注意到 TextBlob 标记器删除了标点符号。此外，它还有英语缩写的规则。

空间记号化器

SpaCy 是一个开源的 Python 库，可以解析和理解大量文本。提供适合特定语言(英语、法语、德语等)的型号。)，它以最高效的常用算法实现来处理 NLP 任务。

spaCy tokenizer 提供了指定特殊标记的灵活性，这些标记不需要分段，或者需要使用每种语言的特殊规则进行分段，例如，句子末尾的标点符号应该分开，而“U.K .”应该保留为一个标记。

在使用 spaCy 之前，您需要安装它，下载英语语言的数据和模型。

$ pip install spacy
$ python3 -m spacy download en_core_web_sm

Gensim 单词标记器

Gensim 是一个 Python 库，用于大型语料库的主题建模、文档索引和相似性检索。目标受众是自然语言处理(NLP)和信息检索(IR)社区。它为标记化提供了实用函数。

使用 Keras 的标记化

Keras 开源库是最可靠的深度学习框架之一。为了执行标记化，我们使用 Keras.preprocessing.text 类中的 text_to_word_sequence 方法。Keras 最大的优点是在标记之前将字母表转换成小写字母，这样可以节省大量时间。

注意:你可以在这里找到所有的代码示例。

可能有用

检查如何跟踪您的 TensorFlow / Keras 模型训练元数据(指标、参数、硬件消耗等)。

挑战和局限

让我们讨论一下标记化任务的挑战和局限性。

通常，该任务用于用英语或法语编写的文本语料库，其中这些语言通过使用空格或标点符号来分隔单词，以定义句子的边界。不幸的是，这种方法不适用于其他语言，如汉语、日语、朝鲜语、印地语、乌尔都语、泰米尔语等。这个问题产生了开发一个结合所有语言的通用标记化工具的需求。

另一个限制是阿拉伯文本的标记化，因为阿拉伯语作为一种语言具有复杂的形态。例如，一个阿拉伯单词可能包含多达六个不同的标记，如单词“عقد”(eaqad)。

Tokenization challenges

*One Arabic word gives the meanings of 6 different words in the English language. | Source *

在自然语言处理方面有很多研究正在进行。你需要选择一个挑战或问题，并开始寻找解决方案。

结论

通过这篇文章，我们已经了解了来自各种库和工具的不同记号赋予器。

我们看到了这项任务在任何 NLP 任务或项目中的重要性，并且我们还使用 Python 和 Neptune 实现了跟踪。您可能会觉得这是一个简单的主题，但是一旦深入到每个记号赋予器模型的细节，您会注意到它实际上非常复杂。

从上面的例子开始练习，并在任何文本数据集上尝试它们。你练习得越多，你就越能理解标记化是如何工作的。

如果你陪我到最后——谢谢你的阅读！

阿迈勒·门兹利

创新、足智多谋、自我激励的数据科学家。我热衷于用数据解决难题，我相信它是我们今天最强大的工具，来回答宇宙中最模糊的问题。此外，我喜欢教学、指导和写技术博客。

阅读下一篇

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

Dhruvil Karani |发布于 2020 年 10 月 12 日

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

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

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

一些典型的原因是:

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

Continue reading ->

ML 模型治理、起源和谱系的最佳工具

原文：https://web.archive.org/web/https://neptune.ai/blog/tools-for-ml-model-governance-provenance-lineage

ML 软件开发复杂；建立一个 ML 模型是一回事，改进和维护它是另一回事。如果你想让你的机器学习模型健壮、合规，并给出可重现的结果，你必须在质量模型管理上投入时间和金钱。

模型治理、模型起源和模型沿袭工具通过跟踪模型活动、记录数据和模型中的所有变更，以及概述数据管理和处理的最佳实践来帮助您做到这一点。

在本帖中，让我们讨论一下这些工具是什么，以及如何选择最好的工具。虽然这三种实践的目的不同，但它们有很多共同点。因此，一个对模型治理有益的工具，通常对其他两个也是有益的。

我将引导您了解一些在开发人员中最流行的模型治理工具，并解释您应该根据您的特定用例选择哪一个。

什么是模型治理？

模型治理，正如您可能从术语中理解的那样，是一组实践和技术，用于控制模型开发和实现的过程。任何 ML 模型都必然符合某些期望。它们应该满足技术要求，符合法律要求，并且不存在任何道德问题。

为什么要建模治理？

部署模型后，现实世界中的结果与您预期的大相径庭，这是很常见的。为了理解哪里可能出错并快速修复，您需要模型治理。

你一定很熟悉关于 ML 模型，尤其是深度学习模型的‘黑盒’这个术语。它们被描述为神秘的，无法调试的。然而，一旦您有了曾经发生的所有修改的目录，确保模型的正常运行就变得容易多了。

例如，在过去几年中，一个引起社区强烈反对的常见问题是，模型在获得美联储有偏见的数据时会产生有偏见的结果。亚马逊人工智能招聘系统经常被引用为有偏见的人工智能的一个例子。这个系统会惩罚简历中包含“女性”一词的人，就像“女子象棋俱乐部”一样，因为从历史上看，男性占据了大多数职位。

如果你不想让你的公司和亚马逊、谷歌和脸书一样被列入“黑名单”，这些公司因其歧视性的模式而受到广泛批评，那么跟踪数据漂移、异常和偏差的能力可能是有益的。

此外，偏见并不是你的模型可能面临的唯一问题。另一个挑战是保证模型的安全性，尤其是当我们谈论企业级公司时。如果一个模型意外地暴露给你公司内部的另一个部门或者第三方，会有很多不确定性。例如，模型可能被篡改，这可能会给企业带来风险。

模型治理的好处

模型治理有明显的好处。然而，从零开始实施并不总是容易的。你需要首先回顾 ML 团队的工作流程，以评估有效性和成本需求。关于模型治理实现最重要的事情是一致性。您必须在所有模型和部门中使用模型治理，而不仅仅是针对少数业务单元。标准化是有效模型治理的关键。

什么是模型出处？

模型起源与模型治理过程紧密相连，并描述了模型的起源和应用于它的处理步骤。

为什么要对出处建模？

通常，在您开始使用 ML 模型之前，您必须准备训练数据，这些数据必须沿着机器学习开发管道经历一个漫长的转换过程。数据起源的想法是跟踪转换的每一步:数据来自哪里，谁改变了它，以及以什么方式改变了它。数据获取、合并、清理和特征提取属于数据起源的范畴。

模型起源的好处

在最终版本部署之前，模型会经历很多变化。这个过程通常包括对不同的 ML 技术和架构进行实验，以获得最佳结果。你不能总是预测你的下一个方法是否会有成果。如果没有模型的检查点，很难回到最佳性能点。模型起源工具帮助您跟踪所有的输入(包括数据)、超参数、依赖性等等。

记录所有这些事情可能是一个解决方案，但是对于大型项目来说不是很方便。此外，人为因素总是会将您的模型出处置于风险之中:开发人员经常忘记记录一些小东西，比如元数据注释，他们的疏忽会导致巨大的金钱损失。

因此，以模型起源工具的形式投资自动化解决方案是值得的。对公司特别有帮助，因为有助于提升知名度。你手头有你的模型的地图，可以忘记'可见性债务。

什么是模型血统？

模型谱系是增强模型可见性的另一种技术。它可以检查模型的历史。如果您使用自动化工具，这是日常任务的强烈建议，记录将在每次新版本的模型被训练时自动生成。

模型沿袭工具允许您保留的信息包括用于构建模型的数据类型和算法、用于训练的管道以及所选参数。

为什么要模拟血统？

ML 模型开发是一个需要实验的领域。通常需要几周，甚至几个月的时间，才能得出模型配置和超参数的正确组合。通常，研究人员在迭代中工作，从模型的先前版本中保留最好的工作，并改变需要改变的内容。此外，通常会涉及许多训练数据集，这些数据集可以沿着 ML 开发管道进行更改。

当你最终确定模型的最终版本时，可能很难找到是什么改变促成了这一成功。然而，理解这一点很重要，这不仅是为了研究目的，也是为了模型的连续可再现结果。此外，研究人员通常作为团队的一部分工作，有时甚至与其他团队和部门合作。将记录保存在电子表格中不太可持续，也不太容易扩展。

当协作的需求增加时，使用版本控制工具来获得更好的模型可追溯性总是更好的。了解模型的历史使得实验结果具有可重复性，这在商业和学术领域都具有很高的价值。通过模型沿袭工具，可以追踪模型及其组件之间的关系，包括实验、数据集、容器等。它们有助于表示工件和核心之间的关联，并以直观、可视化的方式显示结构。

模型谱系的好处

模型血统对于任何公司的透明性和可追溯性都是至关重要的。今天，你的 ML 模型不能简单地代表一个“黑箱”。例如，如果第三方提出法律或道德问题，您将能够分享该模型的所有基本细节。你应该能够追溯到有问题的部分是由谁引入的，并且能够解释和修复它。

此外，模型血统在科学和商业中是至关重要的。你的模型显示的结果应该是可重复的。您的客户或您的同事应该能够运行该模型并获得相同的结果。当您拥有关于其历史和发展的所有数据时，构建和部署一个稳定的模型要容易得多。

既然模型治理、模型起源和模型传承之间的区别和相似之处已经很清楚了，那么让我们来讨论如何为您的公司选择正确的工具。

如果您已经决定转换到模型治理工具，您要做的第一件事就是不要联系软件供应商。事实上，这是你最不应该做的事情。以下是你可以一步一步做的事情:

模型治理采用:慢慢来，评估您的组织试图实现什么结果。最佳答案是具体的答案，例如，“交付高质量的数据以增加 X 千美元的收入”。你的里程碑应该是精确的和可测量的；只有这样，您才能在一段时间后监控您的模型治理采用的效率。
运营模型发现:运营模型是一种工具，它将帮助您概述与模型治理相关的角色、职责和业务术语。例如，它将建立数据所有者、决定公司应如何使用数据的个人以及负责数据收集和处理的数据管理员。您还需要开发一套数据治理策略，也就是您的团队必须遵循的规则。
最佳工具的选择:最佳的数据治理工具将尽可能自动化，并提供最大化的定制，因为每个公司都是不同的。不要害怕与供应商交谈，请他们演示他们的解决方案，并强调重要的功能。有备而来:你有自己的目标和需求，并询问产品将如何帮助你实现它们。

通常你不得不妥协。例如，包含您需要的所有功能以及更多功能的解决方案可能太贵了。在这种情况下，请考虑该零件对您的 ML 工程团队有多重要。提前对特性进行排序是很好的:对于一些团队来说，解决方案支持云是至关重要的；对其他人来说，不尽然。仅仅因为每个人都在云中工作并不意味着你必须这样做。

区分特性优先级的一个好方法是问你自己和你的团队你是否经常执行你想要自动化的任务。如果答案是否定的，也许手动实现它们的成本比自动化要低。

由于模型治理、模型起源和模型传承是紧密相连的，这里有一个统一的工具列表来帮助 ML 团队进行这些实践。

1.数据机器人

Tools for ml model governance - datarobot

You can easily set up model governance from the start with DataRobot | Source

许多人认为 DataRobot 是一个平台，业务分析师可以在没有深入编程知识的情况下构建预测分析解决方案。DataRobot 的一个关键特性是 AutoML，可以快速、轻松地生成模型。

不过 DataRobot 也为 MLOps 开发了可以和 DataRobot AI 云平台一起使用的产品。DataRobot MLOps 允许简化模型部署，并在其生命周期的每个阶段监控 ML 开发。以下是该工具的主要功能:

角色和职责: DataRobot 具有从一开始就建立模型治理并在模型生命周期中定义明确角色的必要功能。例如，您可以分配一个生产模型经理、模型管理员、模型验证者等等。您可以为每个角色添加描述，包括所需的资格或其他要求。每个用户可以被分配多个角色。
访问控制:您可能希望在不同部门甚至团队成员之间建立不同级别的访问控制。这将允许您保护模型环境，并使开发过程更加可控。通过 DataRobot，您可以使用基于角色的访问控制快速实现限制。
审计日志: DataRobot 有一个自动化的工具，它会记录所有的更改，以避免遗漏任何重要的内容。为了遵守法律法规，安全日志记录是必要的。它将允许您跟踪系统中的每个更改，并了解更改是何时由谁进行的，这使得故障排除更加容易。
注解:仅仅从日志记录来判断，理解变更的背景是有挑战性的。这就是为什么用户能够留下关于他们动机的笔记是至关重要的。在 DataRobot 中，用户可以轻松地为他们的操作添加注释，以获得更好的可解释性和透明度。
模型谱系:当你有了模型的演化历史，更新和维护它就变得容易了。DataRobot 为开发人员提供了跟踪模型历史的可能性，包括模型工件和变更日志。
可追溯的结果:您的模型提供给您的结果应该总是可追溯到模型版本。记录请求数据和对这些请求的响应值以及相关数据是必不可少的。如果您想要保持您的模型的可追溯性，尤其是如果您继续更新模型，请使用 DataRobot 的内置工具进行模型响应跟踪。
生产模型生命周期管理: DataRobot 可以在模型生命周期管理的每个阶段为您提供帮助。可以用来做模型再训练；该工具自动发现模型性能问题，并在投入生产之前开始测试过程。它还可以帮助您预热模型，并允许您将模型置于预热模式，以观察其在现实条件下的性能。

2.大太酷

Dataiku 是一个用于数据处理、分析和机器学习的一站式平台。Dataiku 允许您创建、共享和重用使用数据和机器学习来扩展和自动化决策的应用程序。

Dataiku 还将自己定位为一个强大的模型治理工具，借助高级权限管理、SSO 和 LDAP 集成，帮助您管理风险并确保合规性。几个特性使得 Dataiku 成为模型治理的首选工具之一:

监控&MLOps 中的漂移检测:大台库可以为你监控模型的流水线，确保每个人都按计划进行。如果检测到任何异常，它将向工程师发送有关该问题的警报。它会自动检查评分数据和训练数据是否保持一致，以获得可靠的结果。

Tools for ml model governance - dataiku

Dataiku has in-built tools for monitoring and drift detection I Source

自动模型文档: Dataiku 通过使用标准模板的自动模型文档生成器，使模型文档更容易。它还跟踪模型版本，以减少协作模型开发中的任何差异。

Tools for ml model governance - dataiku

Dataiku is a tool for automated documentation generation and version control I Source

权限管理:大台库允许您控制模型的可访问性。不同的用户角色对应不同的权限。团队成员可以属于多个用户组，并在不同的项目上拥有不同的权限。

Tools for ml model governance - dataiku

Permission management with Dataiku I Source

SSO 和 LDAP: Dataiku 为用户认证提供了不同的选项。您可以集成单点登录或目录服务(SSO)，包括 LDAP 认证服务，如 Microsoft Active Directory。当您允许人们访问您的关键系统时，正确的身份认证是必不可少的，并且对于您的公司遵守内部和外部法规控制也是必要的。
审计: Dataiku 为所有用户活动创建日志，并为系统中的对象更改提供丰富的审计跟踪。如果出现任何问题，团队将很容易发现问题的根源，因为日志包含所有用户操作的数据，包括他们的 ID、IP 地址和身份验证方法。

Tools for ml model governance - dataiku

Audit trail for increased traceability with Dataiku | Source

安全的 API 访问: Dataiku 通过提供 API 访问控制来增强灵活性。这将允许您为您的业务应用程序设计端点服务，如风险评估评分。API 密钥和多级认证安全 API 集成。

Tools for ml model governance - dataiku

Dataiku provides secure API access | Source

3.多米诺数据实验室

Tools for ml model governance - domino data lab

Streamline model governance with Domino Data Lab platform | Source

Domino Data Lab 是一个功能丰富的 MLOps 和模型监控中心。它通过支持企业范围的数据科学安全性来帮助企业成功扩展。

使用 Domino Data Lab，数据科学家可以很容易地在同一个平台上同时协作完成多个不同的项目。Domino Data Lab 没有在数据、工具或语言方面限制它们，所以它们不必遭受基础设施的摩擦。

统一模型监控 : Domino Data Lab 让你在一个界面中轻松监控你的机器学习模型的不同方面。它自动检测变化，跟踪性能，并保留所有用户活动的记录。Domino Lab 甚至可以在业务受到严重影响之前排除潜在的问题。
增强的可再现性:由于 Domino Data Lab 自动跟踪代码、使用的工具、框架和包的变化，显示可再现的结果变得更加容易。您可以向客户端团队提供在他们那边部署模型或在将来更新模型所需的所有信息。
企业级安全:机器学习模型有一个复杂的架构，这使得它更难保护它们免受漏洞和恶意攻击。Domino Data Lab 提供了一个环境，在这个环境中，可定制的权限可以安全地保护每个数据科学操作、单点登录(SAML 或 OIDC)和凭证传播。
可审计的环境: Domino Data Lab 使监控模型如何随时间变化变得容易。它跟踪变更的历史，并使您能够追溯到管道的任何阶段，以满足必要的法规。****
强大的集成:该工具集成了许多流行的协作、数据科学和项目管理工具，如吉拉、谷歌云、AWS、英伟达等。