pytorch模型部署到springbootweb（pytorch模型部署到web）



原文：NeptuneAI Blog

协议：CC BY-NC-SA 4.0

原文：https://web.archive.org/web/https://neptune.ai/blog/moving-from-tensorflow-to-pytorch

深度学习框架、库和众多工具的概念的存在是为了减少否则必须计算的大量手动计算。TensorFlow 和 PyTorch 是目前构造神经网络架构最流行的两种框架。

虽然 TensorFlow 比 PyTorch 早一年发布，但最近大多数开发人员都倾向于转向 PyTorch。在本文中，我们将探讨如何从 TensorFlow 切换到 PyTorch 的大部分细节。我们将首先理解使用这两种深度学习框架的原因。

然后，我们将更深入地研究这些库的安装过程以及成功过渡的实践方法。我们还将研究 PyTorch 库在 MNIST 的执行情况，并最终理解 PyTorch 在所有情况下是否都是最好的。

在文章的这一部分，我们将简要概述这两个深度学习框架，即 TensorFlow 和 PyTorch 。我们还将尝试理解为什么人们会从 TensorFlow 过渡到 PyTorch，并给出一些实际的解释，然后再用更实际的方法来解决这个问题。

TensorFlow

TensorFlow 是谷歌在 2015 年推出的用于开发神经网络的深度学习框架的较老解释之一。谷歌大脑团队的产品总是最值得信赖的方法之一，用于开始任何类型的复杂任务。

TensorFlow 是一个开源库，使用它可以开发和构建大多数机器学习和人工智能模型。TensorFlow 2.0 的更新版本也集成了 Keras，是相应地培训、开发、操作和运行机器学习模型的一个很好的选择。

PyTorch

PyTorch 由脸书人工智能研究(FAIR)团队于 2016 年 9 月开发。它已经获得了很多关注，尤其是最近，大多数数据科学家和研究人员都试图从 TensorFlow 成功过渡到 PyTorch。它与 Python 编程语言无缝集成，大多数开发人员发现使用它非常自然。

PyTorch 可以被认为是一个平台，在这个平台上，你可以与张量(类似于 NumPy 这样的库，我们使用数组)一起使用 GPU 加速来计算深度学习模型。在 PyTorch 的帮助下，您还能够获得动态图表，使用这些图表您可以动态地分析您的模型的工作方法。

虽然 TensorFlow 似乎是您的军火库中用于大多数深度学习任务的一个很好的工具，但大多数人现在更喜欢从 TensorFlow 切换到 PyTorch。让我们讨论一下从一个深度学习框架过渡到另一个框架的一些主要原因。

• Tensorflow 创建静态图，而 PyTorch 创建动态图。在 TensorFlow 中，机器学习模型的大多数计算图都应该完全从头开始定义
• 在 PyTorch 中，您可以定义、操作和适应特定的工作图，这在像 RNNs 中的可变长度输入这样的场景中特别有用。
• 使用 PyTorch 处理模型更加直观，因为它主要是用 Python 开发的，并且它与 Python 编程语言的自然工作方式无缝结合。
• 另一方面，TensorFlow 的学习曲线很陡，大多数用户乍一看会觉得很难掌握。即使当你学习张量流时，一些概念也需要重新审视。
• PyTorch 最适合开发快速原型和研究项目，这就是为什么大多数人选择从 TensorFlow 过渡到 PyTorch。

在文章的这一部分，我们将关注从 TensorFlow 切换到 PyTorch 是否容易。从任何深度学习框架转换的第一步是安装过程。该库必须易于安装，以便开发人员可以开始构建模型，而不必太担心安装过程的复杂细节。

虽然安装 TensorFlow 和 PyTorch 库的 CPU 版本非常简单，但是使用 CPU 来训练复杂的模型是很原始的。让我们来看看他们的 GPU 安装程序之间的快速概述和比较。

探索张量流安装的复杂过程

如果你试图在你的 Windows 操作系统或任何 Linux 系统上安装 TensorFlow 的 GPU 版本，整个过程相当复杂。即使您正在使用 Anaconda 软件来开发您的深度学习项目，获得 TensorFlow 最新版本的过程也比您预期的要长一些。但是，如果您对使用任何版本的 TensorFlow 感兴趣，可以使用以下命令在您的虚拟环境中安装 TensorFlow 2.0。

然而，TensorFlow 的版本不断更新，上面的安装并不总是这样。因此，在共享代码或从事研究项目时，可能会引发许多问题。

要在您的系统上安装最新版本的 TensorFlow，您需要确保下载了安装过程所需的特定驱动程序。您需要查看官方的 TensorFlow 文档,了解您需要下载并安装到系统上的 CUDA 文件和 CuDNN 版本的具体信息。

CUDA 和 CuDNN 版本由 Nvidia 不断更新，类似于它们的驱动程序。每当有 TensorFlow 最新版本的新发布，他们通常也会更新 CUDA 和 CuDNN 需求。

一些功能在新版本中被贬低，因此，下载新版本以保持更新变得至关重要。但是每次我们需要安装新的 TensorFlow 版本时，Cuda 和 CuDNN 更新都必须单独下载和安装。整个过程非常繁琐，每次更新都需要重复。

了解更简单的 PyTorch 安装

与 TensorFlow 安装相比，PyTorch 安装要简单得多。为了成功安装 PyTorch，您需要做的就是访问 PyTorch 官方网站获取安装指南，您可以通过此链接选择您的软件需求类型、您的开发包和您的计算平台。该网站将自动为您提供准确的命令，您可以复制粘贴在您的默认或虚拟环境中开始安装。安装语句示例如下:

对于 TensorFlow 的专家来说，可能想知道从一个库切换到另一个库的区别。从 TensorFlow 转换到 PyTorch 并不复杂，因为 PyTorch 提供了一种python 式的方法来解决大多数问题。在本节中，我们将介绍从 TensorFlow 成功转换到 PyTorch 的一些主要基础知识。

我们将了解如何在这两个深度学习框架中实现张量并与之合作。然后我们将了解他们的图形工作机制，即 TensorFlow 中的静态图形方法和 PyTorch 中的动态图形。最后，在本节中，我们还将比较 TensorFlow 和 PyTorch 的训练循环。

理解如何实现张量

张量是 n 维数组，通过它你可以开发和构造大部分的机器学习项目。大多数深度学习框架的核心方面是张量的概念，张量是向量和矩阵的推广。在您的系统上安装 PyTorch 后，您可以继续比较 TensorFlow 和 PyTorch 的编码过程之间的一些基本差异。

让我们比较并实现一些基本实现，开始从一个库到另一个库的转换。我们将首先看看如何导入这两个库，初始化张量，并用这些张量执行一些基本操作。初始化张量的张量流代码如下:

在 PyTorch 中，同样的实现可以按如下方式完成:

在这两个框架中，库的导入和张量的定义都非常简单。让我们分析一下如何在这两个库中执行一些基本的张量计算。首先，让我们看看下面的 TensorFlow 实现示例(注意，如果需要，您也可以将示例中显示的值直接定义为变量)。

在 PyTorch 中，以下实现可以解释如下:

现在，我们已经简要了解了如何在这两个深度学习框架中与张量合作，让我们通过实践方法来理解它们的工作机制。

它们的工作机制(理解各自的图表)

大多数深度学习框架都利用了计算图。这些计算图定义了必须执行计算的顺序，以便我们可以相应地获得最佳结果。

通常有两个解释器用于深度学习问题的计算，其中每个解释器服务于不同的目的。其中一个解释器用于编程语言(大多数情况下是 Python)，另一个解释器根据需要管理计算图形。

因此，大多数深度学习框架利用像 Python 这样的编程语言来设置计算图，并且还设置了执行机制，这与宿主语言大不相同。

这种奇怪的设置主要是出于效率和优化的原因。计算图形可以在目标 GPU 中优化和并行运行。因此，由于并行性和依赖性驱动调度，整个计算过程被加速并且更高效。

在 TensorFlow 中，我们使用静态计算图。这些工作遵循典型的“定义并运行”惯例。？在这样的构建中，我们在开始时创建并连接所有的变量，并将它们初始化成一个静态的(不变的)会话。

然而，有必要在静态图中定义一些可变参数，这有时被认为是不方便的，尤其是对于使用 RNN 型网络的任务。我建议查看下面的网站，了解更多关于这些静态图如何工作的详细信息。让我们看看静态张量流图的实现。

输出

图表

The computational graph | Source

在 PyTorch 中，我们利用了动态图，其中计算图是在我们键入代码时构建的。当用户最初声明变量时，直接构建计算图，并且在每次迭代训练后重新构建计算图。动态图和静态图都有其特定的用例，在特定的场景中，一个比另一个更好。

动态图通常比静态图更好，因为我们可以相应地修改感兴趣的元素，而无需强调其他因素，从而在训练和模型构建过程中实现更高的灵活性。使用这种方法的唯一缺点是，有时需要更长的时间来重建图形。下面显示的 GIF 表示是 PyTorch 中一个项目如何工作的最好例子之一。

训练循环的比较

在 TensorFlow 中，创建训练循环的过程有点复杂，而且不是很直观。我们通常使用一个 tf.function，它作为一个装饰器，根据静态图来编译模型。

TensorFlow 中的正常执行使用的是急切执行，这对于调试来说是好的，但是对于模型的更快的性能和实现来说是不好的。因此，我们利用 tf.function 使框架能够应用全局性能优化。

然后，我们定义训练步骤，在该步骤中，我们通常使用梯度带函数，该函数执行自动微分。然后，我们可以定义培训过程将要发生的模型，并相应地计算损失。

应用梯度值，经历反向传播过程，最后更新训练度量。在模型完成训练后，我们可以返回我们想要的指标和值。

这种训练循环的 PyTorch 实现非常简单和直观。我们可以动态地创建变量和定义动态图，然后继续训练我们的模型。我们可以将我们的数据和目标分配给设备(CPU 或 GPU)的状态，并继续计算前向传播，这是神经网络的前馈计算。

一旦模型完成前馈训练过程，我们就可以在 PyTorch 中一些预定义实体的帮助下计算元素的反向传播。我们计算梯度，应用反向传播方法，并执行参数更新。以下计算的代码如下所示。

现在，我们已经理解了从 TensorFlow 切换到 PyTorch 的一些基本要求，让我们借助 PyTorch 深度学习框架来理解深度学习项目的代码演练。

在本文的这一部分，我们将了解 TensorFlow 和 PyTorch 之间的一些主要差异。进一步了解他们工作程序的最好方法之一是亲自动手实施一个项目。我们将在这个代码演练比较中对 MNIST 数据集中的数字进行分类，我们将在 PyTorch 的帮助下训练一个模型，对数字从 0 到 9 进行分类。

第一步是导入计算 MNIST 项目所需的所有基本库。因为我们正在从 TensorFlow 过渡到 PyTorch，所以我们将为这个项目导入所有需要的 PyTorch 库。使用这个深度学习框架，我们可以在我们将要构建的神经网络架构中构建所有需要的层。PyTorch 的必要导入在下面的代码块中描述如下。

我们的下一步是相应地设置设备参数。我们可以选择是否要将 PyTorch 中用于训练的默认设备设置为 CPU 或 GPU。如果你有一个可以使用的 GPU，那么使用它总是更好。然而，对于这个项目，即使一个 CPU 设备也能满足要求，培训不需要太长时间。在 TensorFlow 中，默认设备通常根据您的安装设置为 GPU 版本。

我们的下一步是定义一些超参数，用于模型的构建和训练。定义了添加到总共 10 个类别中的类别数(0-9)。我们将设置默认输入大小为 784 (28×28 是 MNIST 数据的图像大小)，学习率为 0.0001，批量大小为 64，并且我们将在总共 3 个时期上训练构建的模型。

下一步，我们将加载我们的数据。PyTorch 框架类似于 TensorFlow 库，可以访问一些默认数据集，MNIST 就是其中之一。我们将以训练和测试数据集的形式分离图像(大约 60000 个)。DataLoader 函数在加载我们的数据时提供了非常好的工具。下面的代码片段展示了如何在 PyTorch 中加载数据。

现在我们已经收集了所需的数据，我们终于可以使用 PyTorch 深度学习框架来构建神经网络架构了。我们将使用完全连接的层类型构建来解决我们的问题。

使用 PyTorch 构建深度学习模型的过程非常简单，并且遵循 Pythonic 方法。我们将为神经网络定义一个类，并为我们的模型声明完全连接的层。功能。注意，在张量流的情况下，我们将对完全连接的层使用稠密函数。

既然我们已经用 PyTorch 完成了数据收集和深度学习模型的构建，我们可以继续定义我们将利用的损失类型和最适合该任务的优化器类型。交叉熵损失对于像 MNIST 项目这样的多类分类问题来说是一个非常好的选择。

Adam 是最好的默认优化器之一，几乎可以在任何场景中找到效用。我们将为指定数量的纪元训练我们的模型。对于训练过程，我们将使用前馈完全卷积网络，然后应用反向传播来学习相应的最佳权重。

最后，现在我们的训练方法已经完成，我们可以继续训练和评估构建的模型，并相应地检查训练和测试的准确性。完成以下操作的步骤也非常简单，因为我们可以在正确分类的图像和错误分类的图像之间进行评估，并相应地计算准确度。

通过这个构建模型来解决深度学习任务的简单过程，您可以在测试和训练数据上实现大约 91%的准确率。即使我们只利用了一个简单的全连接神经网络结构，我们也能够获得不错的结果。更重要的是，我们明白在 PyTorch 的帮助下，构建几乎任何类型的研究项目都非常简单。

在本节中，我们将权衡 PyTorch 的利弊，以得出最终结论，即是否值得从 TensorFlow 转换到 PyTorch。为了深度学习神经网络的研究和开发，研究人员花费所有时间从 TensorFlow 过渡到 PyTorch，这值得吗？让我们开始分析 PyTorch 的利弊。

PyTorch 的优点

1.自然界中的蟒蛇

PyTorch 的构建方式直观易懂，易于开发机器学习项目。PyTorch 中部署的大部分代码都是 Python 化的，这意味着过程化编码类似于 Python 的大部分元素。当使用 TensorFlow 时，代码更低级，更难理解，即使您对框架有很好的理解。

因此，现在有一个额外的 Keras 高级 API 集成到 TensorFlow 2.0 中，您可以在其中更轻松地开发模型。PyTorch 的功能可以很容易地用其他神奇的库实现，比如 Numpy、Scipy 和 Cython。因为 Pytorch 的大部分语法和应用程序与传统的 Python 编程非常相似，所以学习起来也非常容易。

2.良好的文档和社区支持

PyTorch 拥有最好的文档之一,可用于掌握大多数基本概念。他们有详细的描述，在那里你可以理解大部分的核心话题:火炬。张量，张量属性，张量视图，火炬。亲笔签名，等等。你也有一些深度学习项目的博客和教程支持。除了默认文档之外，整个社区都高度支持 PyTorch 及其相关项目。

3.动态图表

正如在本文前面一节中详细讨论的，PyTorch 支持动态图，而不是 TensorFlow 的静态图。这个特性对于动态创建图表特别有用。当您无法预先确定特定计算的内存分配或其他细节时，动态创建的图形最有用。它们为用户开发项目提供了更高的灵活性。

4.许多开发人员选择 PyTorch 进行项目

最近，开发人员和研究人员倾向于更多地转向 PyTorch 来构建深度学习项目。大多数研究人员更喜欢在 GitHub 等网站上分享他们的代码和他们的 PyTorch 项目实现。

这个社区充满了奇妙的资源，当人们对某个特定的话题有任何困惑时，他们愿意伸出援助之手。在研究项目中，工作、共享和开发 PyTorch 项目更加容易。

PyTorch 的缺点

1.缺乏可视化技术

在 Tensorboard 的帮助下，TensorFlow 为其开发的模型的工作可视化提供了最佳选择之一。Tensorboard 是一个非常棒的数据可视化工具包，通过它您可以监控一些功能，如训练和验证的准确性和损失、模型图、查看构建的直方图、显示图像等等。PyTorch 在可视化方面没有太大的选择，通常最好将 Tensorboard 与 PyTorch 一起使用。

2.生产所需的 API 服务器

TensorFlow 相对于 PyTorch 的另一个优势是，它有许多生产工具，可以随时部署已开发的模型。TensorFlow 提供的可伸缩性很高，因为它是为生产准备的。

TensorFlow 服务为针对生产环境设计的机器学习模型提供了一个灵活的高性能服务系统。它处理大多数推理方面，并管理训练模型的生命周期。

另一方面，我们有 TorchServe，它灵活且易于使用，但它没有 TensorFlow 的紧凑性，在与高级部署工具竞争之前还有很长的路要走。

在本文中，我们已经涵盖了从 TensorFlow 深度学习框架成功过渡到 PyTorch 所需的大部分要素。PyTorch 非常适合快速原型的开发。现代的开发人员在大多数研究项目中使用 PyTorch 来产生快速有效的结果。

直截了当的蟒方法

用于高质量可视化的张量板

|

在这方面稍有欠缺

复低阶张量流码

| |
| | | |
| | |

研究型快速原型开发

|

深度神经网络实现的多功能性、Pythonic 性质、巨大的灵活性和构造的高速度使得该框架成为研究和开发的最佳选择之一。

相关来源

原文：https://web.archive.org/web/https://neptune.ai/blog/multi-gpu-model-training-monitoring-and-optimizing

你是否纠结于在多个 GPU 上监控和优化深度神经网络的训练？如果是的话，你来对地方了。

在本文中，我们将讨论 Pytorch Lightning 的多 GPU 训练，并找出优化训练过程应该采用的最佳实践。我们还将看到如何在训练过程中监控所有 GPU 的使用情况。

让我们从一些基础知识开始。

有时对于复杂的任务，如在计算机视觉或自然语言处理中，训练一个深度神经网络 (DNN)涉及到解决数百万或数十亿参数的梯度下降，因此它成为一个计算复杂的过程，可能需要几天甚至几周才能完成。

例如，生成式预训练变压器 3 (GPT-3)是一个自回归语言模型，具有 1750 亿个参数，在单个 NVIDIA Tesla V100 GPU 上训练它需要大约 355 年。但是如果用 1024 个 NVIDIA A100 GPUs 并行训练同一个模型，我们可以估计训练时间在 34 天左右。因此，在 GPU 上进行并行训练是目前广泛使用的加速过程的方法。

另请查看:https://Neptune . ai/blog/distributed-training-frameworks-and-tools

为了清楚地了解我们如何能够使用多个 GPU 来训练深度神经网络，让我们简单地看看神经网络是如何训练的:

• 深度神经网络模型通常使用小批量梯度下降进行训练，其中训练数据被随机采样为小批量。
• 将小批量输入模型，分两个阶段遍历模型:
  • 前进传球
  • 偶数道次
• 正向传递生成预测，并计算预测和地面实况之间的损失。
• 反向传递通过网络的层传递误差(称为反向传播),以获得梯度来更新模型权重。
• 通过正向和反向阶段的小批量被称为迭代，并且时期被定义为通过整个训练数据集执行正向-反向传递。
• 训练过程持续多个时期，直到模型收敛。

如果这对你来说似乎是压倒性的，我会建议这篇文章来更深入地了解神经网络是如何被训练的。

为了加快训练过程，我们使用多个 GPU 来并行化训练过程，并且数据并行和模型并行是用于并行化任务的两种技术。

数据并行性

在数据并行中，每个 GPU 保存模型的副本，并且数据被分成 n 个分区，其中每个分区用于在每个 GPU 上训练模型的副本。

当应用异步数据并行时，参数服务器负责权重更新。每个 GPU 将其梯度发送到参数服务器，然后参数服务器更新权重，并将更新后的权重发送回该 GPU。

这样，GPU 之间就没有同步了。这种方法解决了分布式计算环境中不稳定的网络问题，但是它引入了不一致性问题。此外，这种方法不会减少 GPU 之间的数据传输次数。

模型并行性

模型并行性在多个 GPU 之间划分模型，其中每个 GPU 负责模型的指定层的权重更新。中间数据，例如用于前向传递的神经网络层的输出和用于后向传递的梯度，在 GPU 之间传送。

由于这些分区具有依赖性，在模型并行性的简单实现中，一次只有一个 GPU 是活动的，导致 GPU 利用率低。为了实现并行执行，流水线并行将输入小批分成多个微批，并在多个 GPU 之间流水线执行这些微批。下图对此进行了概述:

Pipeline parallelism |  Source

上图表示的是一个模型，有 4 个层放在 4 个不同的 GPU 上(纵轴)。横轴表示随着时间的推移对该模型进行训练，表明 GPU 得到了更高效的利用。但是，仍然存在一个气泡(如图所示),其中某些 GPU 没有得到利用。

为了对模型并行性和数据并行性有一个完整的了解，我强烈建议阅读分布式培训:数据科学家指南。

在本节中，我们将重点讨论如何使用 PyTorch Lightning 在多个 GPU 上进行训练，因为它在去年越来越受欢迎。PyTorch Lightning 使用起来非常简单方便，它帮助我们缩放模型，没有样板文件。样板代码是大多数人在缩放模型时容易出错的地方。

有一些编码实践可以帮助您毫无问题地将代码迁移到 GPU。你应该参考 PyTorch Lightning 文档来获得更多关于这个的信息。

分布式模式

在本节中，我们将介绍 Pytorch lightning 提供的不同分布式模式。

数据并行

我们可以在一台拥有多个 GPU 的机器上训练一个模型。使用 DataParallel (DP)方法，一个批处理会在一个节点的所有选定 GPU 之间平均分配，之后根节点会聚合所有结果。但是 Pytorch lightning 开发人员不建议使用这种方法，因为它还不稳定，如果在 forward()或*_step()方法中为模块分配状态，您可能会看到错误或行为不当。

分布式数据并行

分布式数据并行(DDP)的工作方式如下:

• 每个节点上的每个 GPU 都有自己的进程。
• 每个 GPU 都可以看到整个数据集的子集。它只会看到那个子集。
• 每个进程初始化模型。
• 每个进程并行执行完整的向前和向后传递。
• 梯度在所有过程中被同步和平均。
• 每个进程更新它的优化器。

我们可以通过两种方式使用该方法，即“ddp”和“ddp_spawn”。在“ddp”方法中，使用正确的环境变量多次调用脚本。

虽然在大多数情况下这似乎是一个不错的选择，但它有一些局限性，因为它不能在 Jupyter Notebook、Google COLAB 和 Kaggle 等工具中工作。此外，当有一个没有根包的嵌套脚本时，它似乎不起作用。在这些情况下，首选“ddp_spawn”方法。

“ddp_spawn”除了使用 torch.multiprocessing.spawn()方法启动训练过程之外，与 ddp 完全一样。因此，人们可能会认为总是首选“ddp_spawn”方法而不是“ddp ”,但“ddp_spawn”也有这些限制:

• spawn 方法在子流程中训练模型，而主流程中的模型不会更新。
• Dataloader(num_workers=N)，其中 N 很大，使用 DDP 训练会遇到瓶颈，即它会非常慢或者根本不起作用。这是 PyTorch 的限制。
• 这个方法强制所有东西都是可选择的。

就速度和性能而言,“ddp”方法应始终优先于“ddp_spawn”。

分布式数据并行 2

DDP2 在单台机器上的行为类似于 DP，但在多个节点上使用时，它就相当于 DDP。有时，在同一台机器上使用所有批次而不是子集可能是有用的，ddp2 方法在这种情况下可能会很方便。DDP2 执行以下操作:

• 将数据的子集复制到每个节点。
• 在每个节点上初始化一个模型。
• 使用 DP 向前和向后传递。
• 跨节点同步渐变。
• 应用优化程序更新。

目前不建议使用这种技术，因为它对所有 PyTorch 版本> = 1.9 都不适用，不清楚如何使它适用于 PyTorch >= 1.9，并且没有对这种方法进行功能测试

霍罗沃德

Horovod 是一个用于 TensorFlow、Keras、PyTorch 和 Apache MXNet 的分布式深度学习培训框架，它使分布式深度学习变得快速和易于使用。

• 每个进程都使用单个 GPU 来处理固定的数据子集。
• 在反向过程中，梯度在所有 GPU 上并行平均。
• 在进入下一阶段之前，在开始下一步之前，同步应用这些梯度。
• 在训练脚本中，Horovod 将检测环境中的工作人员数量，并自动调整学习速率以补偿增加的总批量。

Horovod 使用相同的训练脚本支持单 GPU、多 GPU 和多节点训练。它可以在培训脚本中配置为与任意数量的 GPUs 进程一起运行，如下所示:

启动培训作业时，驱动程序应用程序将用于指定工作进程的总数:

共享培训

在训练大型模型或尝试较大批量时，您可能会遇到一些内存问题。人们可能会想到在这种情况下使用模型并行，但是目前，由于与之相关的复杂实现，我们使用分片训练来代替。

在底层，分片训练类似于数据并行训练，只是优化器状态和梯度是跨 GPU 分片的。在内存受限的多 GPU 设置中，或者在训练较大的模型(500M 以上的参数模型)时，强烈建议使用这种方法。

要使用分片训练，您需要首先使用下面的命令安装 FairScale 。

当使用分片训练策略时，在内存和性能之间存在折衷，因为由于设备之间的高度分布式通信，训练可能变得更慢。

当在多个 GPU 上训练具有大型数据集的大型模型时，我们可能会遇到一些内存或性能瓶颈问题。在本节中，我们将了解如何优化培训流程。

FairScale 激活检查点

激活检查点一旦在正向传递中不再需要激活，就从内存中释放激活。然后，根据需要为向后传递重新计算它们。当中间层产生大量激活时，激活检查点非常有用。

与 PyTorch 实现不同，FairScales 的检查点包装器还可以正确处理批处理规范层，确保由于多次转发而正确跟踪统计数据。

这在训练较大的模型时节省了内存，但是，需要包装您想要使用激活检查点的模块。你可以在这里阅读更多相关信息。

混合精度(16 位)定型

默认情况下，PyTorch 和大多数深度学习框架一样，使用 32 位浮点(FP32)算法。另一方面，许多深度学习模型可以通过 16 位等低位浮点实现完全的准确性。因为它们需要更少的存储器，所以有可能训练和部署大型神经网络，这导致由于更少的存储器带宽需求而增强数据传输操作。

但是要使用 16 位浮点，您必须:

• 支持 16 位精度的 GPU，如 NVIDIA pascal 架构或更新版本。
• 你的优化算法，即 training_step，应该是数值稳定的。

混合精度结合了 32 位和 16 位浮点的使用，提高了性能，并消除了我们可能面临的任何内存问题。Lightning 通过本机或 APEX amp 后端为 GPU 提供混合精度训练。

除非您需要更精细的控制，否则建议始终使用本机 amp_backend。

比起数据并行(DP ),更喜欢分布式数据并行(DDP)

正如前面提到的，我们应该更喜欢使用 DDP 策略而不是 DP。这背后的原因是 DP 每批使用 3 个转移步骤，而 DDP 仅使用 2 个转移步骤，因此速度更快。

DP 执行以下步骤:

1. 将模型复制到设备。
2. 将数据复制到设备。
3. 将每个器件的输出复制回主器件。

GPU data parallel strategy | Source

DDP 执行以下步骤:

1. 将数据移动到设备。
2. 传输和同步渐变。

GPU distributed data parallel strategy | Source

随着技术和策略的改变，我们也可以在代码中做一些改变来优化我们的训练过程，下面是其中的一些。

增加批量

如果您在训练时使用小批量，则更多的时间将花费在训练数据的加载和卸载上，而不是计算操作上，这会降低训练速度。因此，建议使用更大的批处理大小来提高 GPU 利用率。但是增加批量大小可能会对模型的准确性产生不利影响，因此我们应该用不同的批量大小进行实验，以找到最佳的批量大小。

使用 PyTorch 的 DataLoader 方法更快地加载数据

Pytorch 中的 DataLoader 类是加载和批处理数据的一种快速简便的方法。我们可以使用参数“num_workers ”,通过将它的值设置为一个以上来更快地为训练加载数据。使用 PyTorch lightning 时，它会为您推荐 num_workers 的最佳值。

但是，如果数据集非常大，因为加载器工作进程和父进程将为父进程中从工作进程访问的所有 Python 对象消耗相同数量的 CPU 内存，则可能会遇到内存问题。避免这个问题的一个方法是在 Dataloader getitem 方法中使用 Pandas、Numpy 或 PyArrow 对象，而不是 python 对象。

将梯度设置为无

我们可以通过覆盖 optimizer_zero_grad()方法并将其设置为 None 来提高性能和速度，而不是将梯度设置为零，这样通常会占用更少的内存。

模型切换

当我们必须在分布式设置中使用多个优化器执行梯度累积时，这种方法特别有用。当执行梯度累积时，将 sync_grad 设置为 False 将阻止此同步，并提高您的训练速度。

LightningOptimizer 为高级用户提供了一个 toggle_model()函数作为 contextlib.contextmanager()。这里有一个来自 PyTorch Lightning 官方文档的例子。

正如您在代码中看到的，我们将 sync_grad 参数设置为 False，并仅在一个时期结束时或每两个批次后将其设置为 True。通过这样做，我们实际上是在每两个批次之后或者在时期结束时累积梯度。

避免。item()，。numpy()，。cpu()调用

避免。item()，。numpy()，。cpu()调用代码。如果您必须删除连接的图调用，您可以使用。请改用 detach()方法。这是因为这些调用中的每一个都将导致数据从 GPU 传输到 CPU，并将导致性能大幅下降。

清除缓存

每次调用 torch.cuda.empty_cache()方法，所有的 GPU 都要等待同步。所以避免不必要的调用这个方法。

在训练模型时，监控 GPU 的使用是非常重要的，因为它可能会提供一些有用的见解来改进训练，如果 GPU 未得到充分利用，我们可以相应地处理它。有各种工具，如 Neptune 和 Wandb，可用于监控多个 GPU 上的训练。

在本节中，我们将使用 Neptune 来监控 GPU 和 GPU 内存，同时在多个 GPU 上进行训练。

用海王星监控训练

Neptune 是一个可以在任何 MLOps 工作流中使用的元数据存储库。它允许我们在训练时监控我们的资源，因此我们可以使用它来监控训练时使用的不同 GPU 的使用情况。

将 Neptune 并入 PyTorch Lightning 代码非常简单，您所要做的就是创建一个 NeptuneLogger 对象并将其传递给 Trainer 对象，如下所示:

如果这是你第一次接触 Neptune，我强烈建议你通过这个一步一步的指南来安装所有必要的库以使它工作。之后，查看海王星+ PyTorch 闪电集成文档。

运行该文件后，您应该会得到一个到控制台的链接。您可以看到监控部分(下图中的圆圈)，在这里您可以看到所有 GPU 在训练时的使用情况以及一些其他指标。

Monitor training on multiple GPUs | Source

让我们看看我们可以从 GPU 利用率图表中推断出什么样的有意义的见解。

Monitor training on multiple GPUs | Source

• 正如您在上面看到的，GPU 的使用是波动的，有一些短暂的时间没有被使用，解释其原因并不容易。
• 这可能发生在验证期间，因为我们在此阶段不计算梯度，或者这可能是由于一些其他瓶颈，例如，您可能使用 CPU 对数据使用一些数据预处理技术，这可能非常慢。
• 此外，在 Caffe 等一些框架中，默认情况下在验证阶段只使用一个 GPU，因此在这种情况下，您可能会发现只有一个 GPU 的使用率很高。
• 因此，根据您训练神经网络的方式，您可能会发现一个不同的图表，表明不同的 GPU 是如何被利用的。

本文讨论了我们为什么要用多个 GPU 来训练机器学习模型。我们还发现了使用 Pytorch lightning 在多个 GPU 上进行训练是多么容易，以及优化训练过程的最佳方法。最后，我们发现了如何在训练时使用 Neptune 来监控 GPU 的使用情况。

如果你正在寻找关于这个主题的深入知识，我建议你浏览这个广泛的资源改进共享计算环境中的 ML 应用或者这个研究论文。

参考

米尔扎·穆杰塔巴

经验丰富的机器学习工程师，具有金融服务行业的工作经历。精通分析技能、PHP、数据科学、数据分析和数据分析。拥有技术学士学位的优秀工程专业人士——来自克什米尔大学的 BTech 专注于计算机科学。

---

阅读下一篇

5 分钟阅读|作者 Jakub Czakon |年 7 月 19 日更新

使用 PyTorch Lightning 并想知道应该选择哪个记录器来跟踪您的实验？

考虑使用 PyTorch Lightning 来构建您的深度学习代码，并且不介意了解它的日志功能吗？

不知道闪电有一个相当可怕的海王星积分？

这篇文章(很可能)适合你。

如果你从未听说过，PyTorch Lightning 是 PyTorch 之上的一个非常轻量级的包装器，它更像是一个编码标准而不是框架。这种格式可以让你摆脱大量的样板代码，同时保持简单易懂。

其结果是一个框架，为研究人员、学生和生产团队提供了尝试疯狂想法的终极灵活性，而不必学习另一个框架，同时自动化掉所有的工程细节。

Continue reading ->

---

原文：https://web.archive.org/web/https://neptune.ai/blog/must-do-error-analysis

深度学习时代的繁荣始于 2012 年，当时 Alex Krizhevsky 创建了一个卷积神经网络，将图像分类的准确率提高了 10%以上。这一巨大成功很快被其他研究领域所效仿，很快其他企业——企业集团和初创企业——希望将这一前沿技术应用到自己的产品中:银行现在使用 ML 模型来检测欺诈；自动驾驶采用传感器结果，自动做出自信的决策。

然而，从研究到生产的快速转变往往会导致一些经常被忽视但却是必须考虑的差距。许多公司仅仅根据实验室结果，甚至简单的准确性来判断他们的机器学习模型，以加快展示他们的产品线的步伐，这实际上可能导致巨大的性能差距，甚至未知的偏差。

本文深入探讨了机器学习(ML)模型表面精度性能之外的现实场景，这是人们在将其投入生产之前应该考虑的。具体来说，虽然特定模型的训练精度可能看起来令人信服，但分析不同的数据集分布是否会保持性能是很重要的。我们提供了五个必做的分析，以确保您的模型在上线时能如预期一样运行。

在探索为什么每个错误分析是不同的并且必须完成之前，我们首先必须正确理解 ML 模型的核心概念，以实现其内在的约束。

在传统的工程环境中，我们希望设计将输入映射到指定输出的数学系统——这种数学建模并不总是可行的，尤其是当系统未知且过于复杂而难以找到时。这就是机器学习(特别是监督学习)发挥重要作用的时候。我们不是创建模型，而是基于一组已知的输入和输出来学习它。

为了充分训练和评估 ML 模型，典型的设置是将可用数据集分成训练集和验证集，其中在模型设置期间仅看到训练集，而验证仅用于评估。我们通常基于验证集的性能，作为我们的模型在真实世界设置下推广的基准。因此，了解验证数据集的构造方式以及模型投入生产时可能出现的潜在分布变化非常重要，因为所有的误差分析都围绕这一概念进行。

如前一节所述，模型的表现完全取决于训练和验证数据集。这导致每个人在生产之前必须进行的第一个也是最重要的错误分析:确定训练和验证数据集的大小是否足够。我们可以用一个狗和猫的图像识别模型来说明这一点的重要性。

假设我们希望创建一个 ML 模型，它可以确定图像中的动物是狗还是猫。为了训练模型，我们需要收集一组图像来进行训练和验证。现在考虑这样一种情况，有 50 种狗，然而我们只有 40 种用于训练和验证的图像。我们的模型可能在训练和验证上都表现得非常好，但我们永远不会知道它对 10 种未知物种的概括能力有多强，当模型投入生产进行真实世界测试时，这些物种是有效的例子。

这个案例听起来可能过于极端，导致人们质疑它是否真的会在现实中发生。然而，许多真实世界的数据包含更复杂的分布，超出了我们的知识范围——一个模型可能不会暴露出一个重要的特征，而我们甚至不会注意到！下面进一步描述了当训练/验证集太小时可能导致的问题。

• 当训练集太小的时候:我们可以把训练集想象成整个真实世界数据集的一个小群体。因此，如果我们希望 ML 模型是稳健的，我们会希望这个小群体从真实世界数据可能具有的所有可能性中提取样本。如果没有，模型将只学习可用数据的少量分布，使其在测试中几乎不可推广。
• 当验证集过小时:当验证集过小时，可能会出现不同的问题。一个小的验证集可能意味着不是所有的可能性都被测试过，而不是不可推广。这可能会给人以错误的印象；如果学习了当前的分布，我们可以看到一个非常好的结果，反之亦然。

“太小”的确切原因是一个困难的问题，因为答案基于许多未知因素，如任务的难度和数据集分布的复杂程度。但是，根据经验，如果影像数据集包含的影像少于几千幅，或者如果回归数据集包含的条目少于几千条，则模型通常不能很好地进行概化。如果你的 ML 模型是基于深度学习的(需要神经网络)，由于深度学习模型有大量的参数可用，你肯定需要更多的数据。

解决办法

解决方法很简单—增加数据集的大小。考虑你的模型将要应用到什么样的现实场景中。在相同的设置下收集更多的数据，并将它们放入训练和验证数据集中。虽然看起来很简单，但这实际上是许多公司(如谷歌、脸书)一直试图通过他们庞大的客户数据库实现的:他们不断收集所有数据(搜索历史的图像)，因为他们具体意识到数据集大小增加的好处是机器学习。

之后，考虑训练集和验证集的平衡。80/20 是标准的划分，但是根据数据集的大小，您可以减少验证集以使训练更加稳健，反之亦然，以便更好地了解模型的执行情况。

第二个错误分析挖掘数据集的内容，以找到标签的平衡。我们可以回到上面提到的狗/猫分类任务来说明这个问题。

考虑一个数据集，在 1000 幅图像中，990 幅是狗，剩下的 10 幅是猫。如果一个模型学会将所有东西都归类为狗(这是非常不准确的，基本上是无用的)，它将在整个数据集上获得 99%的准确率。如果不深入研究错误的形成，许多人会直截了当地认为模型训练有素，可以投入生产了。

这个问题可以很容易地通过研究每个类的样本数量来规避。在最佳情况下，我们希望每个单独的类拥有大致相同数量的数据。如果这样的设置是不可能的，那么我们至少应该关注每个类有足够数量的数据(几百个)。

然而，即使数据集完全平衡，网络也可能在某些类上表现得更好，而在其他类上表现得更差，或者如果您的任务是二元分类，则在检测阳性方面表现得比阴性更好。要意识到这一点，我们不能只直接看准确度，而是要通过不同的度量来看每个类的准确度和真/假阳性/阴性。以下是一些可用于准确性之外的进一步分析的指标。

• F1 得分:对于二元分类，我们可以计算 F1 得分(上面的公式)，这可以让我们了解我们给定模型的精度和召回率。请注意，我们还可以专门取出精度，并逐个召回进行评估。根据手头的任务，我们可能希望最大限度地提高精确度，或者回忆并放弃另一个。例如，如果您的目标是为您的产品找到一组目标客户，您可能希望召回量大一些，这样您就不会错过潜在客户，但是如果您找到的客户不完全是您的目标客户，精确度可能会受到影响。

Example of a confusion matrix on iris dataset to show the percentages
of predictions for each label | Source

• 混淆矩阵:(上图)显示每个类别被分类为所有类别的百分比。伴随着颜色编码，当我们试图理解哪一类更容易出错以及错误是如何产生的时候，这个矩阵就变成了一个很好的可视化工具。
• ROC 曲线:如果我们在做分类，可以通过改变阈值来区分阳性和阴性来构造一条曲线。这将使我们更好地了解哪个阈值更好。

解决办法

如果您遇到一个数据少得多或者性能比其他类差得多的类，那么增加这个特定类的数据量是明智的。如果无法获得真实世界的数据，也可以使用数据扩充等技巧作为替代(关于数据扩充的更多内容将在后一节中讨论)。此外，我们还可以对数据应用随机权重采样，或者直接对每个样本硬编码采样权重，以应对数据集的不平衡。

既然您可能计算的所有数字都显示了良好的结果，那么仍然有必要对细粒度的分类结果进行一些粗略的定性分析，以准确理解是什么导致了错误。

通常，一些错误可能非常明显，但仅仅从类信息中是看不出来的。例如，在我们的狗/猫问题中，我们可能会注意到，通过简单地可视化所有错误分类的猫，所有的白猫都被错误分类了，然而猫的整体类别表现得非常好。这种错误分析变得至关重要，因为白猫可能是现实世界案例的主要部分(再次是验证和现实世界测试之间的分布差异问题)。然而，由于 labels 本身根本不能反映这样的问题，研究这个问题的唯一方法是通过人在回路中的定性分析。

解决办法

细粒度错误分类的解决方案非常类似于不平衡数据集的解决方案，其中直接且唯一的解决方案是向数据集添加更多内容。然而，为了定位一个特定的细粒度类，我们应该只添加那些性能很差的子类。

当模型学习仅出现在训练集中的模式/数据分布时，会发生过度拟合。当将模型转移到测试时，使用这些模式会降低模型的性能。

过度拟合可能以两种方式出现，一种更常见，另一种不太常见。下面描述了这两个问题及其各自的解决方案。

过度适应训练集

当网络从训练集中学习到不适用于验证集的东西时，就会发生这种情况。在每个时期之后，借助于绘制用于训练和验证的损失曲线，该问题很容易观察到。如果在验证变得停滞后，训练损失继续下降(导致性能差距扩大)，则过度拟合正在发生。

解决办法

训练集过拟合有多种解决方案，下面我们列出了 6 种可行的解决方案。

• 提前停止:我们在每个历元/a 一定数量的迭代之后绘制训练和验证损失。如果验证损失在一定数量的时期内停止下降，我们就完全停止训练。这可以防止模型在训练集中学习不需要的模式。
• 降低 ML 模型的复杂性:当一个模型太复杂(参数太多)时，它很可能会学习模式，特别是当手头的任务实际上很简单时(例如，如果我们正在学习一个函数 y = wx，但我们有 100 个参数{w1，w2 …，w100}，那么很可能 w2 到 w100 实际上学习的是数据中的噪声，而不是真实的函数)。如果您正在训练神经网络，这相当于减少层的深度和宽度。如果你正在训练决策树/森林，那将会限制树的深度或数量。
• 添加 L1/L2 正则化:这些正则化防止特定参数过大，过拟合时经常出现这种情况。具体来说，L1 正则化旨在最小化每个权重的绝对值，而 L2 正则化则最小化每个权重的平方值。因此，平方曲线会将所有值推到接近 0 的状态。本质上，这两个正则化确保了每个因素对最终预测的贡献是相似的。

Comparison of a neural network with and without dropout | Picture retrieved
from the original dropout paper from JMLR

• 加入退出项:对于一个神经网络，我们可以随机地退出某些神经元，不考虑它们的输出。这将使我们的模型对输入数据的微小变化不太敏感，从而防止过度拟合。

Visualization of a data augmentation technique called “mixup” | Source: Author

• 数据扩充:增加更多的训练数据将使得某个模式不太可能存在于训练集中而不存在于验证集中。数据扩充是一种综合当前可用条目中的数据并将其用作训练的附加数据的技术。例如，我们可以裁剪、旋转和移动图像，并将它们视为“新”图像，以添加到训练中，并使模型更加健壮。一些更复杂和最新的增强技术还包括 mixup、cutout、cutmix 等。
• 集成学习:如果计算资源可用，人们可以训练多个模型，并将它们的预测组合在一起，以做出最终的预测。不太可能所有模型都过度适应相同的模式。因此，预测将更加平滑，进一步防止过度拟合。事实上，集成模型有多种方式，从简单的打包和提升到更复杂的深度模型组合——所有这些都取决于手头案例所用的场景和模型。

过度适应验证集

这不是一个常见的问题，因为实际上只有训练数据用于调整模型。但是，如果您基于验证执行早期停止，仍然有可能您实际上为该特定集合而不是为整个真实总体选择了最佳模型。

解决办法

防止这种情况的一种方法是通过交叉验证等方法采用多重验证。交叉验证将整个数据集分成多个片段，每次我们取其中一个片段用于验证，其余的用于训练。此外，我们还应该确保验证集足够大，并且当我们手动增加验证集的大小时，精确度保持大致相同。

最后，在您可以使用培训和验证集进行所有详细分析之后，是时候模拟您的模型将如何应用的场景并测试实际结果了。

我们可以通过狗/猫的分类问题再次说明这一点。假设你正在为 iPhone 用户创建一个给狗和猫分类的 app 你根据从网上获得的一堆狗和猫的图片，经过仔细分析，训练了你的模型。对于这最后一部分，您可能希望通过在不同的 iPhone 相机上进行测试来模拟真实场景。换句话说，我们希望确保在测试集上进行评估时，您训练和验证的模型之间的分布差距很小。

解决办法

由于这是误差分析的最后阶段，并且假设其他一切都表明您的模型具有巨大的潜力，您可以潜在地将您的模型投入生产，但添加在线学习机制以继续模型的微调。

在线学习是一种学习机制，通过将新的测试数据添加到训练中来不断改进模型。随着添加越来越多的数据来微调模型，准确性可能会增加，因为模型将开始更符合您最终目标的测试分布。许多应用程序(如 Siri、面部识别)实际上都采用了这种方案，这就是当你继续使用手机时，它们如何慢慢适应你的外观和声音。

只有上述错误分析的理论支持，人们实际上可能会怀疑这种数据分析的实用性和必要性:如果没有这些修复，机器学习模型真的会出错吗？要回答这个，我们其实可以深挖一个 AI 工具失败的两个经典案例:2014 年亚马逊 AI 招聘的偏差和 2019 年 FB 广告。

亚马逊 AI 招聘

为了加快招聘过程，亚马逊在 2014 年致力于开发一种人工智能驱动的招聘工具，以审查和筛选简历。然而，在投入生产一年后，他们在 2015 年意识到性别偏见的严重问题，尽管性别不是投入因素的一部分，特别是对于软件开发人员或其他技术角色。

这是怎么发生的？

这个问题的答案实际上深深植根于模型数据集最初是如何收集的:使用过去 10 年的简历，这些简历最终以男性为主。事实上，美国顶级科技公司技术岗位的男女员工比例约为 3:1。

Tech Industry is dominated by men | Source

正因为如此，这种模式天生就给人一种错误的印象，即男性候选人更受青睐，因此更多地与男性相关的词汇联系在一起，从而摧毁了包含“女子象棋俱乐部队长”等词汇的简历的价值。

如何才能避免这种情况？

实际上，我们可以将这种情况追溯到错误 2 和错误 5，在这两种情况下，数据集中的严重不平衡(男女比例)以及未能模拟真实的评估场景。因此，为了在生产之前避免这些严重的错误，必须考虑数据集的平衡，并且潜在地对特定类别的样本/扩充增加权重，以避免这样的问题。

脸书广告偏见

类似地，脸书推出了一个机器学习和推荐系统，但这种推荐最终将女性排除在某些广告之外，反之亦然，这是由于一般人群的一般化和相关的刻板印象，正如南加州大学的研究所表明的。

如何才能避免这种情况？

同样，通过大量测试来平衡和发现细粒度错误，同时通过在实际投入大规模生产之前拥有一组测试用户来模拟现实世界中可能发生的场景，通过详细和严格的错误分析，这样的问题不太可能发生。

现在你知道了！在你可以说你的模型已经完全准备好投入生产之前，你必须做五种不同的误差分析。这里有一些其他有用的文章，你可以进一步深入研究，使你的机器学习模型在生产中有效和值得尊敬:

请记住，在测试阶段小心谨慎可能会节省很多精力！

原文：https://web.archive.org/web/https://neptune.ai/blog/natural-language-processing-with-hugging-face-and-transformers

NLP 是机器学习的一个分支，旨在帮助计算机和智能系统像人类一样理解文本和口语。

NLP 驱动计算机程序执行各种各样非常有用的任务，如文本翻译、响应口头命令或在眨眼之间总结大量文本。您很有可能以下列形式与 NLP 技术进行过交互:

• 声控全球定位系统
• 智能机器人和数字助理
• 客服聊天机器人
• 基本上，任何涉及使用 STT 和 TTS 技术的数字服务

我们将讨论 NLP 的两个关键技术，但首先是 NLP 的基础——抽象层。

从书面文本中提取意义涉及几个抽象层，这些抽象层通常与不同的研究领域相关，但相互之间有很好的协同作用。

这些研究领域包括:

• 形态学 层次，研究词的结构和构词。
• 词汇分析正是着眼于词汇和标记的构成，以及它们各自的词性。
  句法 分析负责使用词法分析阶段输出的词性标注将单词分组为连贯的短语。* 语义处理然后通过将句法特征与给定的上下文相关联以及消除具有多个定义的单词的歧义来评估所形成的句子的意义和含义。 最后是 语篇 层面，这里的处理是关于对文本结构和意义的分析，而不仅仅是单个句子，在单词和句子之间建立联系。
  

当前最先进的 NLP 技术将所有这些层结合起来，产生非常类似于人类语音的出色结果。最重要的是，NLP 将人类语言的多种基于规则的建模与统计和深度学习模型相结合。

最近需求量很大的深度学习方法需要大量带注释的数据来学习和识别相关的相关性。像 BERT，GPT2，GPT3 或 RoBERTA 这样的著名模型消耗了大量的训练数据，它们只能由负担得起成本的大规模公司进行训练。例如，训练 GPT-3 据报道花费了 12，000，000 美元…一次训练运行。

注意力机制

2018 年出现的一个趋势是基于注意力的算法，这是一个由谷歌 R&D 部门研究和开发的概念，并于 2017 年在著名的“注意力是你所需要的全部”论文中首次发布。

注意力是一种模仿我们大脑内部认知结构的技术。它增强并本能地关注数据的特定部分，而淡化其余部分。因此，当面对复杂和大量的数据时，这种机制节省了时间和能量处理。

变形金刚网络大量利用注意力机制来实现高端表现力。因此，变压器在许多领域的 NLP 深度学习模型的架构中被广泛采用。

单词嵌入

在每个 NLP 模型的中心，都有一个预处理阶段，将有意义的单词和句子转换成实数向量。换句话说，嵌入是一种允许具有相似意思的单词具有相似表示的单词表示类型。

它们是文本的分布式表示，也许是深度学习方法在挑战自然语言处理问题上令人印象深刻的表现的关键突破之一。

单词嵌入的根源 分布语义学 理论试图根据单词周围的上下文来表征单词。例如，单词“演员”在句子“演员崩溃”中的意思与在句子“我的演员朋友给我发了这个链接”中的意思不同。共享相似上下文的单词也共享相似的意思。

单词嵌入有几种方法。它们可以追溯到人工智能的早期，并且是基于降维的方法。这些方法(称为“n-gram”或“k-means”)获取文本语料库，并通过在单词共现矩阵中找到聚类来将其缩减到固定的维数。目前最受欢迎的方法是基于 Word2Vec，最初是由谷歌研究人员托马斯·米科洛夫、程凯、格雷格·科拉多和 Quoc Le 在 2013 年推出的。

BERT 代表 B 方向En 编码器 R 代表来自 T 变压器。这是谷歌人工智能在 2018 年底开发的一种架构，提供以下功能:

• 设计成深度双向的。从令牌的左右上下文中有效地捕获信息。
• 与前辈相比，在学习速度方面效率极高。
• 它结合了掩码语言模型(MLM)和下一句预测(NSP)。
• 这是一个通用的深度学习模型，可用于分类、问答、翻译、摘要等。

最初，用未标记的数据对 BERT 进行预训练。之后，模型输出输入的特定表示。

再训练过程可以以各种方式完成，或者通过从零开始构建判别或生成模型，或者对公共数据库中的现有模型进行微调。通过利用预先训练的模型，有可能将学习从一个领域转移到另一个领域，而无需花费从头开始学习所需的时间和精力。

注 :我已经简要描述了实际的机制是如何工作的，更多细节我推荐’ BERT 解释:NLP 语言模型的现状 ’

用 BERT 迁移学习

微调 BERT 以执行特定任务的方法相对简单。虽然 BERT 可用于各种 NLP 应用，但微调过程需要在核心模型中添加一个小层。例如:

分类任务—在变压器模块上使用分类层(情感分析)。

Q & A 相关任务——模型收到一个关于文本序列的问题，并被要求在命题中标出正确答案。伯特被训练学习两个向量，它们标记了答案的开始和结束。例如:班，1.1 版

命名实体识别 NER: 模型被输入一个文本序列，并被要求识别特定的实体(国家、组织、人、动物等)。)，并给它们贴上标签。这同样适用于这里，预先训练以识别实体的分类层与变换器块“组装”在一起以适合整个架构。

为什么抱脸？

拥抱脸是一个大型开源社区，它迅速成为预先训练的深度学习模型的诱人中心，主要针对 NLP。他们自然语言处理的核心操作模式围绕着转换器的使用。

用 Python 编写的 Transformers 库公开了一个配置良好的 API，以利用过多的深度学习架构来完成像前面讨论的那些最先进的 NLP 任务。

正如您可能已经猜到的，一个核心的启动价值是可重用性——所有可用的模型都带有一组预先训练好的权重，您可以针对您的特定用途进行微调。

从拥抱脸开始

在官方文档中，您可以找到所有具有相关库结构的组件。

拥抱脸轮毂 Repos

它们有基于 git 的存储库，可以作为存储，并且可以包含项目的所有文件，提供类似 github 的特性，例如:

• 版本控制，
• 提交历史记录和分支差异。

它们还提供了优于常规 Github 回购的重要优势:

• 关于已启动任务、模型训练、指标等的有用元数据，
• 测试推理的浏览器预览，
• 用于生产就绪环境的 API，
• HUB 中有 10 多个框架:Transformers、Asteroid、ESPnet 等等。

查看这里: 抱抱脸库

拥抱面部小工具

一组现成的预训练模型，用于在 web 预览中测试推理。

一些例子:

查看这里: 抱脸小工具

拥抱脸的伯特模型

现在，让我们试着做我们一直在谈论的事情。我们想要微调 BERT 来分析亚马逊上购买商品的一些商业评论，并确定评论的正面、负面、和中立。

亚马逊产品评论数据集

该数据集包括超过 1480 万条来自购买、评级、文本、有用性投票等的产品评论。这些数据将证明对我们的任务非常有用，因为评论是由人们真实地做出的，以反映他们对给定产品的意见。文本倾向于主观性，因此本质上可以分为积极的，消极的和中性的类别。

下载数据集的链接 : 亚马逊商品评论

数据集的示例如下所示:

为了确定每个类别，我们将依靠亚马逊评级系统。“总体”键值表示该产品的总体评级。我们可以为每个类别建立一个可测量的范围:

• 正面反馈:4-5 颗星
• 负面反馈:从 0-2 星
• 中性:3 颗星

由于数据涵盖了大量不同的主题和类别，建议缩小范围，只选择其中的一小部分。我选择了这些:

• 汽车的
• 服装、鞋子和珠宝
• 电子学
• 手机和配件

最后，我们将使用小版本的数据集，以避免处理能力过载。

变形金刚图书馆

安装抱脸变形金刚库

1. 使用 conda 创建您的虚拟环境:

2. 安装支持 cuda 的 Pytorch(如果您有专用的 GPU，或者没有专用的 CPU 版本):

3. 从 conda 通道安装变压器版本 4.0.0:

4. 安装火炬视觉:

5. 安装 pytorch-nlp 包中的 Bert 预训练版本:

我们将使用 Pytorch 版本的 BERT uncased，由 Hugging Face 提出。

训练模型

从预处理数据开始

对于训练数据，我们只需要“总体”和“回顾”属性。我们将使用包含 1 (正值)、 2 (负值)和 0 (中性)的“情绪数据”创建一个新列。根据总体得分，每一行都将标有这些数字。

启动 NSP 进程

将[CLS]和[SEP]标签放在每个复习句子的前面。

BERT 令牌嵌入

在深入这部分代码之前，我们需要解释一下令牌嵌入及其工作原理。嵌入令牌提供了关于文本内容的信息。首先要做的是将我们的文本转换成一个向量。

BERT 使用内部算法将输入的单词分解成记号。BERT 实施的流程包括三个阶段:

• 令牌嵌入
• 嵌入位置
• 嵌入段

PyTorch 的 BertTokenizer 模块将负责内部的所有逻辑。将每个输入句子分成合适的记号，然后将它们编码成数字向量。

填充输入标记，并使用 BERT 标记器将标记转换为它们在 BERT 词汇表中的索引号:

创建注意掩码，每个标记的掩码为 1，后跟填充的 0:

分离数据并为训练做准备

拆分列车并测试拆分:

将数据转换为 torch 张量，并使用特定的 batch_size 创建 Dataloader 迭代器:

实例化模型:

定义优化的超参数:

定义训练循环:

开始跟踪培训损失，看看模型实际上如何改进。

将模型置于评估模式，评估一个批次的预测:

可以通过绘制 train_loss_set 列表来看一下训练损耗。

Training loss plot

训练完成后，您可以使用 torch.save()将其保存为检查点。

本节的目标是向您展示一个简单的演示，说明如何使用 Hugging Face 提供的预训练版本的 BERT，并使用特定的数据集对其进行微调，以执行所需的任务。

一旦保存了您的检查点，您就可以(例如)在 API 中使用它作为服务来将 tweets 或其他类似的文本内容分为正面、负面或中性类别。

要了解更多，请查看我以前关于对话人工智能的文章，在那里我使用 Django API 作为后端服务来服务模型推理→Nvidia 支持的对话人工智能架构:工具指南

我在下面给你留了 google Colab 笔记本的链接，在那里你会找到运行这个实验的所有代码:情感分析 BERT

我真诚地推荐你检查拥抱脸的工作，他们有优秀的教程和文章来快速自信地让你开始 NLP 和深度学习。

还有，用 Fastai 和 PyTorch 看《程序员深度学习》这本书。他们有关于深度学习 NLP 方法的精彩章节，完全用 Pytorch 和 Fast AI 编码。这很容易，你将很快开始编写你的模型。

一如既往，如有任何问题，请随时通过我的电子邮件联系我:

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

首先，我们很抱歉！在过去的几个月里，我们在产品更新方面非常安静。您已经看到了 web 界面中的一个更新或 Python 客户端库中的一个 bug 修复，但仅此而已。

发生了什么事？

随着时间的推移，我们从您那里获得了大量的反馈。您询问了如何在 spot 实例和管道中使用 Neptune，如何以一种更加层次化的方式组织事物，以及许多其他问题，我们希望做到这一点。但是将这些改进一点一点地添加到当前产品中变得越来越困难(也越来越慢)。不要误解我，我们喜欢迭代，但有时你需要深呼吸，后退一步，重建基础。

简而言之，这就是当时的情况。然而，相信我——等待是值得的🙂

今天，我们很高兴地宣布，一个全新版本的 Neptune 已经为您准备好了，它具有许多新特性和改进的 Python API！

更好的组织，更大的灵活性，更多的定制

通常，当训练一个只有几个参数的简单模型时，你可以从头开始背诵它们。它们都可以显示在一个屏幕上。

然而，一旦添加了这个太多的参数，问题就出现了。当您除了按字母顺序对复杂的参数配置进行排序之外，还不能轻松地管理它们时，这就成了一种真正的痛苦。

你们对此都有不同的解决方案:

• 明确上传几个参数，其余的上传为 YAML 配置文件，
• 前缀的巧妙运用，
• 还有很多很多其他人。

所有这些都是海王星本身缺乏组织性和灵活性的权宜之计。这改变了！

有了新的 Neptune API，您可以将所有的元数据分层组织到组织整齐的名称空间(文件夹)中。对于所有元数据，我指的是所有元数据，不仅是参数，还包括日志、验证指标、二进制工件等。

你如何用代码做到这一点？新的 Neptune API 依赖于一个类似字典的接口。您可以用一种统一的方式跟踪所有元数据，而不是在那里传递参数，在那里传递属性，以这种方式传递度量，以那种方式传递工件。

哦，这也意味着您不再需要担心预先设置参数—您可以在方便的时间和地点更新它们！

支持更多工作流:离线模式、恢复运行和 ML 管道

有时候你运行你的脚本，分析结果，然后继续前进。通常情况下，事情没那么简单:

• 也许你需要多训练几个纪元？
• 也许在第一次分析之后，您需要计算更多的验证指标？
• 也许你的 spot 实例死了，你需要恢复训练？

不要害怕。海王星已经为此做好了准备。更多🙂

使用新的 Python API，您可以恢复对任何现有运行的跟踪。您可以获取所有记录的元数据，更新它并记录新的。更重要的是，它现在是线程安全的，您可以将不同脚本的输出连接成一个。有了这些，你就可以在并行和分布式计算中，使用带有 spot 实例的 Neptune，以及多步 ML 流水线。

最后，如果你在无法永久访问互联网的地方训练你的模型，你会很高兴听到我们增加了离线模式。被跟踪的元数据将被保存在本地，您可以在方便的时候批量上传。如果您的互联网连接有点不稳定或发生意外中断——Neptune 现在会在多次重试后自动切换到离线模式，以确保您的数据始终安全。

更好的 web 界面:文件夹结构、更好的比较和拆分视图

您将注意到的第一件事是，新的 UI 利用了被跟踪元数据的组织的灵活性。以前，您必须在不同的部分之间跳转，才能完全理解生成模型的输入是什么。现在你可以在一个对你最方便的层次结构中组织元数据。

您将注意到的第二件事是，您可以看到所有运行及其元数据的表发生了变化。以前，比较不同运行的选项不仅有点难找到，而且变化意味着来回切换。最后，它只允许同时比较 10 次运行。现在，你可以:

• 比较方式更多次运行(比如 100 次或更多)，
• 添加和删除您想要实时显示的内容，
• 在表格视图和比较之间切换或同时保持两者可见。

酷吧？嘶，还有一件事。当您浏览特定跑步的详细信息时，您可能会注意到“添加新仪表板”按钮。现在还有点早，我们将添加更多类型的小部件，但你已经可以构建自己的仪表板，以最适合你的方式可视化元数据。请检查它，并让我们知道你的想法！

跑，跑，跑(再见实验)

从这篇文章开始，我就一直用‘跑’这个词代替‘实验’，这不是巧合。随着我们行业的发展，越来越多的 Neptune 用户关心 ML 模型的可操作性，我们需要与它一起发展。

当然，实验阶段是重要的(并且贴近我们的内心)，并且实验跟踪将仍然是 Neptune 的主要用例之一，但是越来越多的人将它用于其他事情，例如:

• 模型注册表
• 监控模型再训练管道
• 监控生产中运行的模型

我们希望更好地服务于您现有的使用案例。我们希望与您用来描述您的作品的命名更加一致。

称它为“实验”已经没有意义了，所以我们把它改成了“运行”。您将看到从实验到在 web 界面和新的 Python API 中运行的变化。

等等，我需要修改我的代码吗？

简而言之——不，你现在不需要做任何事情，你的跑步记录会被海王星跟踪，不会有任何问题。

新的 Python API 和改进的用户界面需要改变数据结构。在接下来的几周里，我们将把现有的项目迁移到新的结构，但是你已经可以尝试了，因为所有的新项目都是使用新的结构创建的。

当前的 Python API 将在迁移后继续工作，因此您不需要更改任何一行代码。在后台，我们悄悄地做我们的魔术，并确保事情为你工作。然而，新的 Python API 只与新的数据结构兼容，因此它只在项目迁移后才可用于项目。同样，改进的 web 界面也需要新的数据结构。您已经可以在一个新项目中试用它，并且一旦您的现有项目被迁移，它将可用于它们。

在未来的某个时候，我们计划在客户端库 1.0 版中，将新的 Python API 作为默认 API。然而，我们将在很长一段时间内支持当前的 Python API，这样你就可以在方便的时候进行切换。这是值得的转变，虽然，这是相当可怕的🙂我们准备了一本方便的移民指南来帮助你完成这个过程。

我想用 neptune.new，我现在该怎么做？

这非常简单:

第一步:

创建一个新项目–您会注意到它有一个标记，表明它是用新结构创建的

第二步:

将 Neptune 客户端库至少更新到 0.9 版本。只需在您的环境中运行:

第三步:

查看 新文档 。如果你想尝试一下，重新开始——快速入门部分是你最好的朋友。如果您想更新您现有的代码，我们准备了迁移指南来帮助您。

第四步:

享受跟踪元数据的新方式！

我们将在接下来的几周内将现有项目迁移到新的结构中，一旦您的项目被迁移，您也将能够使用新的 Python API。

新来海王星？

首先，你好，欢迎，感谢你读到这里！

如果你想知道到底是怎么回事，你可以:

…或者您可以:

1。创建免费账户

2。安装 Neptune 客户端库

3。将日志添加到您的脚本中

4。在海王星看到它

就这样吗？

类似 Dict 的 API，文件夹结构，离线模式，更好的比较，Neptune 团队去海滩喝 pia coladas(当然是通过 Zoom)？

不，我们很快会有更多的东西，这次会更快。

正如我之前提到的，越来越多的 Neptune 用户正在将他们的模型推向生产(恭喜你们！).我们不仅要支持它，而且要让事情变得更简单，就像我们对实验跟踪所做的那样。

在接下来的几个月里:

• 我们将通过对工件版本控制(数据和模型)的支持，使人们使用 Neptune 作为模型注册表的体验变得更好。
• 我们将添加对更多元数据类型的支持，这样您可以在 Neptune 中轻松地记录、显示和比较它；
• 我们将添加与来自 MLOps 生态系统的更多库的集成。

但总的来说，总的来说，我们将努力使 MLOps 工作流中的元数据的存储、显示、组织和查询更加容易。我们将继续为 MLOps 构建一个 元数据存储。

原文：https://web.archive.org/web/https://neptune.ai/blog/neural-network-guide

这是一个关于为乳腺癌分类建立自己的神经网络的实践指南。我将从基础开始，然后通过实现。

准确识别和分类乳腺癌亚型的任务是一项至关重要的临床任务，训练有素的病理学家可能需要数小时才能完成。因此，我们将尝试通过分析乳腺组织学图像，使用图像分类、PyTorch 和深度学习来自动进行乳腺癌分类。

我的重点将是为新的数据科学家或那些想要修改基础知识的人提供指南，并继续构建自己的神经网络。我们将涵盖:

1. 神经网络是如何工作的？
2. 卷积神经网络如何工作？
3. 从零开始用 CNN 实现乳腺癌分类

为了理解神经网络，我们必须从感知机开始。

感知器或人工神经元是模仿生物神经元的数学模型。像神经元一样，感知器接受几个二进制输入，给出一个二进制输出。简单！

每个输入的重要性可以通过向输入添加权重来表示。神经元的输出，0 或 1，取决于加权和是大于还是小于*阈值。*从数学上讲，它是:

其中 w 是每个输入的权重， x 是输入。

通过改变权重和阈值，我们可以得到不同的模型。现在，为了简化我们表达感知机的方式，让我们把阈值移到不等式的另一边，用感知机的偏差 b =-阈值来代替。使用偏差代替阈值，感知器规则可以写成:

其中 W 和 x 为向量，其分量分别为权重和输入。

现在，当这些神经元排列在多个层次上时，它被称为神经网络。神经元并不是一个完整的决策模型，但它说明了神经元如何权衡不同种类的证据以做出决策。一个复杂的神经元网络可以做出非常微妙的决定，这似乎是合理的。

激活函数是用来获取神经元输出的函数。有两种类型的激活函数:线性和非线性(上面的函数是线性激活函数)。非线性函数是最常用的，因为它可以使模型更好地概括各种各样的数据——我们将在本文中使用一个。一些最常用的激活功能有:

1. Sigmoid 函数
2. Tanh 激活函数
3. 整流器线性单元或 relu
4. 李奇注意到了

Different activation functions and their graphs | Source

这是一个简单的神经网络的样子:

Simple two layer Neural Network | Source

第一层称为输入层，最右边的一层是输出层。这两层之间的层称为隐藏层。在这个网络中，第一层感知器通过权衡输入做出决策。输出被馈送到第二层，依此类推，直到最后一层。

由于每个感知器都是通过权衡来自前一层的输入来做出决策，因此决策的复杂性会随着层的降低而增加。这样，多层感知器网络参与复杂的决策任务。一层的输出用作下一层的输入的神经网络称为前馈网络。

现在，我们知道什么是神经网络，所以让我们讨论它们如何学习给出正确的输出。当我们说网络学习时，这意味着通过计算或遵循一些过程，网络已经找到了正确的权重和偏差集，从而使其损失最小。

损失是目标和我们从 w 和 b 的值得到的预测输出之间的差异。我们的目标是最小化该误差，以获得最精确的 w 和b值。让我们使用均方误差函数来计算我们的误差函数。

计算均方误差有三个步骤:

1. 对于给定的 x，找出实际 y 值和预测 y 值之间的差值(y = wx + b)。
2. 平方这个差值。
3. 求 x 中每个值的平方的平均值。

这里 yᵢ是实际值，ȳᵢ是预测值。让我们代入ȳᵢ:的值

所以我们求误差的平方，然后求平均值。因此得名均方误差。

为什么要引入误差函数？毕竟，我们主要感兴趣的不是网络正确分类的图像数量吗？为什么不尝试直接最大化这个数字，而不是最小化一个像误差函数这样的代理测量？

问题在于，正确分类的图像数量不是网络中权重和偏差的平滑函数。在大多数情况下，对权重和偏差进行小的改变根本不会导致正确分类的训练图像的数量发生任何变化。请进入这个博客进一步阅读。

这使得很难找出如何改变权重和偏差来提高性能。如果我们改为使用平滑的成本函数，如上面定义的误差函数，则很容易找出如何对权重和偏差进行小的改变，以获得成本的改善。这就是为什么我们首先关注最小化误差函数，只有在这之后我们才会检查分类精度。

既然已经定义了损失函数，那就进入有趣的部分——最小化，求 w 和 b. 现在，梯度下降算法是一种求函数最小值的迭代优化算法。这里我们的函数是我们之前定义的误差函数。我将使用标量值解释梯度下降，并在稍后讨论图像分类时跳转到矩阵运算，因为图像基本上是一个矩阵。

让我们尝试对 w 和 b 应用梯度下降，并逐步接近它:

1.最初设 w = 4，b = 0。设 L 为我们的学习率。这控制了每一步 w 的值变化的程度。 L 可以是 0.0001 这样的小值，以获得良好的精度。请记住，权重 w 应始终随机初始化，而不是 1 或 0 [ 更多详情 ]

2.计算损失函数相对于 w 的偏导数，将 x、y、w、b 的当前值代入其中，得到导数值 D 。

现在 Dw 是相对于 w 计算的值。让我们相对于 b 来计算 D，即 Db。

3.现在，我们使用以下等式更新 w 和 b 的当前值:

w = w–L * D[w]

b = b–L * D[b]

4.我们重复这个过程，直到我们的损失函数是一个非常小的值或理想的 0(这意味着 0 误差或 100%的准确性)。我们现在剩下的 w 和 b 的值将是最佳值。现在有了 w 和 b 的最佳值，我们的模型就可以进行预测了！请注意，找到最佳值的“正确集合”至关重要。请查看本文中的以了解数据的过拟合和欠拟合，它们会干扰找到最佳值的“正确集合”。

为了使梯度下降正确工作，我们需要选择一个足够小的学习速率 L ，以便上面的方程是一个很好的近似，但不能太小，否则梯度下降将工作得太慢。

梯度下降通常工作得非常好，在神经网络中，我们会发现这是最小化成本函数和帮助网络学习的一种强有力的方法。

现在，应用梯度下降规则有一个挑战。快速浏览一下误差函数:

告诉我们这是单个训练样本误差的平均值。实际上，为了计算梯度 D ，我们需要为每个训练输入 x 分别计算梯度 D x，然后将它们平均。不幸的是，当训练输入的数量非常大时，这可能需要很长时间，因此学习发生得很慢。

为了处理这个问题，可以使用随机梯度下降。这里，不是计算精确的梯度 D，，而是为随机选择的训练输入的小样本或小批量计算估计的梯度。通过对这个小批量求平均，我们可以很快得到真实梯度的良好估计，这有助于加速梯度下降和学习。

这与神经网络中的学习有什么联系？让 w 和 b 成为我们网络中的权重和偏差。随机梯度下降的工作原理是挑选出一个随机选择的小批训练输入，并用它们进行训练。然后它随机挑选出另一批，用这些来训练。这一直持续到训练输入被耗尽，也就是说完成了一个时期的训练。此时，一个新的训练时代开始了。

有一种计算误差函数梯度的快速算法，称为反向传播。

反向传播是关于改变网络中的权重和偏差如何改变误差函数。反向传播的目标是计算误差函数 E 相对于网络中任何权重 w 或偏差 b 的偏导数 Dw 和 db。

Visual representation of backpropagation | Source

为了计算这些，让我引入一个中间值δ^lT2 j，它将是 l ^第层中第 j ^{第个神经元的误差。反向传播将给我们一个计算δl}(t【9】t 10】j 的过程，然后将与 Dw 和 Db 相关联。)

让我们来理解这个误差是如何影响我们的神经网络的。错误出现在第 l ^(层的第 j ^{个个神经元上。当神经元的输入进来时，错误扰乱了神经元的操作。它给神经元的加权输入增加了一点变化∏e}l[j]，所以神经元输出的不是 y(e^lj)，而是 y(e^lj+∏elj)。这种变化通过网络中的后续层传播，最终导致总成本变化 D[e^lj]∏el[j]。)

反向传播基于四个基本方程:

1.输出层错误

其中 E 是误差函数，σ是激活函数。∂e/∂a^lj 测量t5】误差函数作为 j ^(th) 输出激活的函数变化有多快。第二项σ’e ^l [j] ，测量激活函数在 e^lj 的变化速度。为了简化，让我们把 E 看作一个向量，重写上面的表达式(等式 1):

2.误差就下一层的误差而言 (等式 2)

其中(w ^(l+1) ) ^T 是第(l+1)^(层的权重矩阵 w ^(l+1) 的转置。这看起来很复杂，但是让我来分解一下。假设我们知道第(l+1) ^(层的误差δ ^(l+1) 。当我们应用转置权重矩阵时，(w ^(l+1) ) ^T ，我们可以认为这是通过网络将误差向后移动，从而在第 l ^层层的输出端提供某种误差测量。然后我们取点积，O 代表点积。这通过层 l 中的激活函数向后移动误差，给出层 l 的加权输入中的误差δ ^l 。通过组合(等式 1) 和(等式 2) ，我们可以计算网络中任何层的误差δ ^l 。我们首先使用δ ^(L-1) ，然后再次使用(等式 2) 来计算δ ^(L-2) ，以此类推，一直通过网络返回。))

3.误差函数相对于网络中任何偏差的变化率(等式 3)

即误差δ⁽l[j])正好等于变化率∂E / ∂b ^l [j] 。(eq 1)(eq 2)已经给了我们δ ^(l [j]) 。我们可以把 (eq 3) 简化为:

其中可以理解，δ在与偏差 b. 相同的神经元处被评估

4.误差相对于网络中任何权重的变化率(等式 4)

这显示了如何根据我们已经知道如何计算的量δ ^l 和 al-1 计算偏导数∂e/∂w^lJK。这里 a ^(l-1) 是神经元输入到权值 w 的激活，δ ^l 是神经元输出到权值w的误差通过查看 (eq 4)，我们可以说当a ^(l-1) ≈ 0 时，梯度项也会趋于小，这意味着权值学习得慢，或者梯度换句话说，我们可以说(等式 4) 的结果是低激活神经元输出的权重学习缓慢。

总之，现在你已经看到，如果输入神经元是低激活的，或者输出神经元已经饱和，即高或低激活，权重将学习缓慢。

这四个基本方程适用于任何激活函数，不仅仅是标准的 sigmoid 函数或我们在开始讨论的感知器。让我们以伪算法的形式写出来:

1. 输入 x : 设置输入层对应的激活 a ¹ 。
2. 前馈:对于每个 l = 2，3，…，L 计算 e^L= w^La(L-1)+b^L和 a ^l =σ(e ^l )。
3. 输出误差δ ^L : 计算矢量δ^{L=∈[a]EOσ’(e}L)。
4. 反向传播误差:对于每个 l=L-1，L-2，…，2 计算δ^L=((w(L+1))^Tδ(L+1))oσ’(e^L)。
5. 输出:误差函数的梯度由∂e/∂w^lJK= a^(l-1)[k]l[j]和∂e/∂b^l[j]=δ(^l[j])给出。

检查该算法，您可以看到为什么它被称为 back propagation。我们从最后一层开始，反向计算误差向量δ^L。看起来很奇怪，我们在网络中倒退。但是如果你考虑反向传播的证据，反向传播是成本是网络输出的函数这一事实的结果。为了理解成本如何随着先前的权重和偏差而变化，我们需要重复应用链式法则，通过各层反向工作以获得可用的表达式。如果你不熟悉链式法则，请看看这个由 Josh Starmer 制作的视频。

如果你仍然不清楚反向传播的本质，我建议你看看这个视频和这个视频来了解反向传播演算。

对于博客的其余部分，我将使用 PyTorch 的 loss.backward()，因为它已经过优化。为了使用它，您需要使用 zero_grad()函数清除现有的渐变，否则渐变将会累积。

如何用 Neptune-PyTorch 集成跟踪模型训练元数据？

我们一直专注于前馈神经网络。现在，对于乳腺癌分类的任务，我们来看一个以图像分类闻名的神经网络。

MNIST Data flow in CNN | Source

先说为什么我们需要卷积神经网络(ConvNets，CNN)而不是前馈神经网络。

考虑一个小图像，大小为 。对于前馈神经网络，第二层中的每个神经元有 10000 个权重。这使得网络容易过拟合数据。还有，把图像扁平化，缩小到 10000 权重，就失去了图像的本质。

CNN 是前馈神经网络(全连接神经网络)的正则化版本。常规的正则化方法包括随着损失函数的最小化而改变权重，同时随机调整连通性。

CNN 利用图像数据中的分层模式；在每一层中，它们捕捉小的局部特征(相对于前一层)，但是随着深度的增加，这些特征相对于输入图像的复杂性增加。因此，这种局部过滤器(在一个小区域上局部连接的神经元)的堆叠使 CNN 能够捕捉复杂和空间不变的特征，如狗、猫、汽车等。与完全连接的网络相比，具有较少数量的可训练参数。我们可以说，它们在从图像中捕捉相关特征方面比完全连接的网络更有效。要了解更多关于 CNN 在图像分类中的重要性，请看这个由计算机爱好者制作的视频。

卷积神经网络是一种特殊类型的神经网络，它在至少一层中使用卷积(滤波器/内核与输入图像卷积以生成激活)而不是常规的矩阵乘法。CNN 的架构类似于全连接神经网络的架构。有一个输入层，隐藏层和最终输出层。

这里，隐藏层执行卷积。接下来是执行其他功能的其他层，如汇集层、全连接层和标准化层。让我们详细看看这些部分。

卷积层

正如我前面提到的，卷积发生在隐藏层中。准确地说，核心或者我们这里称之为滤波器，移动到图像中的不同位置，改变图像上卷积的步幅。对于过滤器的每个位置，计算过滤器和过滤器下的图像像素之间的点积，这导致输出图像中的单个像素。

因此，在整个输入图像上移动滤波器会产生新的图像。这些图像被称为特征地图。在第一卷积层中生成的特征图被下采样。这些特征图然后通过第二卷积层。这里，对于这些新生成的图像中的每一个，需要滤波器权重。结果图像被进一步下采样。如果你有兴趣深入了解卷积如何作用于图像，可以参考这篇关于执行卷积运算的博客。

汇集层

现在，除了通过改变卷积的步幅来进行下采样，还有其他可靠的方法来对图像进行下采样，如使用池层。池层通过将一层的神经元簇的输出合并到下一层的单个神经元中来减少数据维度。本地池合并小型集群，通常为 2 x 2。这进一步降低了分辨率。有两种类型的池:

1. 最大池化–为每个特征图选取前一层的每个神经元簇的最大值
2. 平均池化–为每个特征图选取每个神经元集群的平均值

Difference between max pooling and average pooling | Source

最大池通常是首选，因为它执行去噪和降维。

汇集有助于提取位置不变的主要特征。此外，维度的减少降低了处理数据所需的计算能力。

完全连接的层

A three layer fully connected multilayer perceptron structure that is identical to a fully connected layer in convolutional neural networks with only difference being the input layer | Source

最后一层是一个完全连接的层，它对我们的图像进行分类。卷积网络的输出然后被展平成列向量，并被馈送到完全连接的神经网络；反向传播应用于训练的每次迭代。

在一系列时期内，该模型能够区分图像中的主要和低级特征，并使用 softmax 分类技术对其进行分类。我不会详细介绍 softmax，但用几句话来说，softmax 分类器给出了每个类别的概率。要了解更多关于 softmax 分类的信息，请浏览 Adrian Rosebrock 的博客，他在博客中精彩地解释了 softmax 分类。

现在，我们已经完成了基本知识，让我们构建自己的 CNN，看看它在 MNIST 数据集上的表现如何，在 Colab 中使用 Pytorch，使用 GPU。

首先，导入库。

下载培训和测试数据集。

让我们想象一下我们将要用作输入的训练图像。

现在，是时候建立我们的 cnn 了。

是时候让模型接受训练了！

我们上一个巴赫的输出是:

损失少，预测准确，现在可以停止训练，用这个模型做预测了。

整个测试集达到的精度为:

关于数据集的信息:乳腺组织病理学图像

乳腺组织病理学图片可以从 Kaggle 的网站下载。图像数据由 1，77，010 个 50×50 像素的小块组成，提取自以 40°扫描的乳腺癌样本的 162 个完整载片图像。数据包含阴性和阳性样本的图像。

让我们把数据从 kaggle 下载到我们的硬盘上，这样我们就可以使用它了。我发现文档含糊不清，所以我将用自己的话来解释如何做。希望有帮助。这是一次性设置:

1.设置 Kaggle API 访问:收集您的 Kaggle API 访问令牌。导航到您的 Kaggle 个人资料“帐户”页面。找到“创建您的 API 令牌”。下载包含用户名和密钥的 JSON 文件形式的令牌。

2.在 Drive 中保存 API 令牌:在你的 Google Drive 中为 Kaggle 创建一个文件夹。将 API 令牌的副本作为私有文件保存在该文件夹中，以便于访问。

3.将 Google Drive 安装到 Colab :这将确保您不必在每次重启运行时下载数据。

4.使用操作系统配置“Kaggle 环境”:这将把 API 键和值存储为操作系统环境对象t/变量。当您运行 Kaggle 终端命令时(在下一步中)，您的机器将通过您的 API 令牌链接到您的帐户。链接到驱动器中的私有目录可以确保您的令牌信息保持隐藏。

5.下载数据

现在我们有了数据集，让我们开始构建我们的网络吧！

将图像转换为张量。

检查数据集，找出每个类中的样本数。

输出:

现在，将数据集分成 75%的训练集和 25%的测试集。

现在，看看我们的数据集。

输出:

使用 GPU。

建立乳腺癌分类神经网络。

使用二元交叉熵损失，就像我们做二元分类一样。

该训练了！

最后，在所有数据集上测试我们训练的模型并计算准确性。

输出:

现在，这个精度似乎比我们之前达到的要低，但是请注意，我们使用了一个更复杂的数据集，并且我们从头开始构建了这个模型。尽管如此，我们仍然达到了 20 个时期的良好精度。

为了实现更高的准确性，您可以使用在数百万数据集上训练的预训练网络作为基础，并在此基础上构建您的分类模型，即通过应用迁移学习。

我们从定义神经网络发展到建立自己的乳腺癌分类神经网络。让我们回顾一下我们所学的内容:

• 我们首先研究了神经网络的定义。神经元代表什么，它们是如何形成网络的？
• 然后转到他们是如何工作的。简要了解激活函数后，我们进入误差函数，以及梯度下降如何帮助减少误差。
• 我们进一步研究了反向传播，我对它的数学做了简单的解释。
• 然后我们转向 CNN 及其每一层，然后从头开始构建我们自己的 CNN 来对 MNIST 数据集进行分类。
• 凭借我们对神经网络的集体知识，我们为乳腺癌分类建立了自己的神经网络。

资源

我向您展示了如何构建自己的乳腺癌分类网络，但我希望这篇博客将有助于为任何数据集构建自己的分类神经网络。

我希望你喜欢这次旅行！感谢阅读。

原文：https://web.archive.org/web/https://neptune.ai/blog/object-detection-algorithms-and-libraries

对象检测在图像中找到并识别事物，这是深度学习和图像处理的最大成就之一。为对象创建本地化的一种常用方法是借助边界框。您可以训练一个对象检测模型来识别和检测多个特定对象，因此它是通用的。

物体检测模型通常被训练来检测特定物体的存在。所构建的模型可用于图像、视频或实时操作。即使在深度学习方法和现代图像处理技术之前，对象检测也有很高的兴趣范围。某些方法(如 SIFT 和 HOG 及其特征和边缘提取技术)在对象检测方面取得了成功，该领域的其他竞争者相对较少。

随着卷积神经网络(CNN)的引入和计算机视觉技术的适应，对象检测在当前一代变得更加普遍。具有深度学习方法的对象检测的新浪潮打开了看似无限的可能性。

对象检测利用每个类的特殊和唯一属性来识别所需的对象。在寻找正方形形状时，对象检测模型可以寻找将导致正方形形状的垂直角，每个边具有相同的长度。在寻找圆形对象时，对象检测模型将寻找中心点，从这些中心点可以创建特定的圆形实体。这种识别技术用于面部识别或物体跟踪。

在这篇文章中，我们将探索不同的对象检测算法和库，但首先，一些基础知识。

在我们的日常生活中，物体检测已经无处不在。比如你的智能手机用人脸检测解锁的时候。或者在商店或仓库的视频监控中，它可以识别可疑活动。

以下是物体检测的几个主要应用:

• 车牌识别–使用物体检测和光学字符识别(OCR)技术来识别车辆上的字母数字字符。您可以使用对象检测来捕捉图像并检测特定图像中的车辆。一旦模型检测到车牌，OCR 技术就会将二维数据转换成机器编码的文本。
• 人脸检测和识别——如前所述，物体检测的主要应用之一是人脸检测和识别。在现代算法的帮助下，我们可以检测图像或视频中的人脸。由于一次性学习方法，现在甚至可以只用一张经过训练的图像来识别人脸。
• 物体追踪——观看棒球或板球比赛时，球可能会打到很远的地方。在这些情况下，跟踪球的运动以及它所经过的距离是很好的。为此，目标跟踪可以确保我们获得关于球运动方向的连续信息。
• 自动驾驶汽车——对于自动驾驶汽车来说，在驾驶时研究汽车周围的不同元素至关重要。在多个类别上训练以识别不同实体的对象检测模型对于自主车辆的良好性能变得至关重要。
• 机器人–许多任务，如提升重物、取放操作以及其他实时工作都由机器人完成。物体检测对于机器人检测事物和自动化任务是必不可少的。

自从深度学习在 2010 年代早期普及以来，用于解决对象检测的算法的质量一直在不断进步和提高。我们将探索最流行的算法，同时了解它们的工作原理、优点以及它们在特定场景中的缺陷。

1.方向梯度直方图(HOG)

→简介

方向梯度直方图是最古老的物体检测方法之一。它于 1986 年首次推出。尽管在接下来的十年中有一些发展，但这种方法直到 2005 年才开始在许多与计算机视觉相关的任务中使用。HOG 使用特征提取器来识别图像中的对象。

HOG 中使用的特征描述符是图像的一部分的表示，我们只提取最必要的信息，而忽略其他任何东西。特征描述符的功能是将图像的整体大小转换成数组或特征向量的形式。在 HOG 中，我们使用梯度方向过程来定位图像的最关键部分。

→架构概述

HOG – Object Detection Algorithm | Source

在我们理解 HOG 的整体架构之前，先来看看它是如何工作的。对于图像中的特定像素，通过考虑垂直和水平值来计算梯度的直方图，以获得特征向量。借助于梯度幅度和梯度角度，我们可以通过探索水平和垂直环境中的其他实体来获得当前像素的明确值。

如上图所示，我们将考虑一个特定大小的图像片段。第一步是通过将图像的整个计算分成 8×8 个单元的梯度表示来找到梯度。在获得的 64 个梯度向量的帮助下，我们可以将每个单元分割成角度箱，并计算特定区域的直方图。该过程将 64 个向量的大小减少到 9 个值的较小大小。

一旦我们获得每个单元的 9 点直方图值(仓)的大小，我们就可以选择为单元块创建重叠。最后的步骤是形成特征块，归一化获得的特征向量，并收集所有的特征向量以获得整体 HOG 特征。查看以下链接了解更多信息:【1】和【2】。

HOG 的成就

1. 创建对执行对象检测有用的特征描述符。
2. 能够与支持向量机(SVMs)相结合，实现高精度的物体检测。
3. 为每个位置的计算创建滑动窗口效果。

→需要考虑的要点

1. 限制–虽然梯度方向直方图(HOG)在物体检测的初始阶段具有革命性，但这种方法存在许多问题。对于图像中复杂的像素计算来说，这是非常耗时的，并且在某些空间较紧的对象检测场景中是无效的。
2. 什么时候用 HOG？–HOG 应经常被用作对象检测的第一种方法，以测试其他算法及其各自的性能。无论如何，HOG 在大多数对象检测和面部标志识别中具有相当高的准确度。
3. 示例用例–HOG 最受欢迎的用例之一是行人检测，因为它边缘平滑。其他一般应用包括特定对象的对象检测。更多信息，请参考下面的链接。

2.基于区域的卷积神经网络

→简介

基于区域的卷积神经网络是对之前 HOG 和 SIFT 方法的对象检测过程的改进。在 R-CNN 模型中，我们试图通过使用选择性特征来提取最基本的特征(通常大约 2000 个特征)。选择最重要的提取的过程可以在选择性搜索算法的帮助下计算，该算法可以实现这些更重要的区域提议。

→R-CNN 的工作过程

R-CNN – Object Detection Algorithm | Source

用于选择最重要的区域建议的选择性搜索算法的工作程序是确保您在特定图像上生成多个子分割，并为您的任务选择候选条目。然后，可以利用贪婪算法来相应地组合有效条目，用于循环过程，以将较小的片段组合成合适的较大片段。

一旦选择性搜索算法成功完成，我们接下来的任务就是提取特征并做出适当的预测。然后，我们可以做出最终的候选提议，并且卷积神经网络可以用于创建 n 维(2048 或 4096)特征向量作为输出。在预先训练好的卷积神经网络的帮助下，我们可以轻松地完成特征提取的任务。

R-CNN 的最后一步是对图像进行适当的预测，并相应地标记相应的边界框。为了获得每个任务的最佳结果，通过计算每个任务的分类模型来进行预测，同时使用回归模型来校正提议区域的边界框分类。有关该主题的更多阅读和信息，请参考以下链接。

→R-CNN 的问题

1.尽管利用预先训练的 CNN 模型产生了有效的特征提取结果，但是利用当前算法提取所有区域提议以及最终最佳区域的整体过程极其缓慢。
2。R-CNN 模型的另一个主要缺点不仅是训练速度慢，而且预测时间长。该解决方案需要使用大量的计算资源，增加了该过程的整体可行性。因此，整体架构可以认为是相当昂贵的。
3。有时，由于在这一特定步骤中缺乏改进，在初始步骤中可能会出现糟糕的候选人选择。这可能会导致训练模型中的许多问题。

→需要考虑的要点

1. 何时使用 R-CNN？–与 HOG 物体检测方法类似的 R-CNN 必须用作测试物体检测模型性能的第一基线。预测图像和物体所花费的时间可能比预期的要长一点，所以通常更现代版本的 R-CNN 更受欢迎。
2. 示例用例–R-CNN 有几种应用，用于解决与对象检测相关的不同类型的任务。例如，从无人机安装的摄像头跟踪对象，在图像中定位文本，以及在谷歌镜头中启用对象检测。查看以下链接了解更多信息。

3.更快的 R-CNN

→简介

虽然 R-CNN 模型能够执行对象检测的计算并获得期望的结果，但是有一些主要的不足之处，尤其是模型的速度。因此，必须引入更快的方法来解决这些问题，以克服 R-CNN 中存在的问题。首先，快速 R-CNN 被引入以对抗 R-CNN 的一些预先存在的问题。

在快速 R-CNN 方法中，整个图像通过预先训练的卷积神经网络，而不是考虑所有的子片段。感兴趣区域(RoI)池是一种特殊的方法，它采用预训练模型和选择性搜索算法的两个输入来提供一个具有输出的全连接图层。在本节中，我们将了解更快的 R-CNN 网络，它是对快速 R-CNN 模型的改进。

→了解更快的 R-CNN

Faster R-CNN – Object Detection Algorithm | Source

更快的 R-CNN 模型是 R-CNN 家族中最好的版本之一，与它的前辈相比极大地提高了性能速度。虽然 R-CNN 和快速 R-CNN 模型利用选择性搜索算法来计算区域提议，但是更快的 R-CNN 方法用更好的区域提议网络来代替这种现有方法。区域提议网络(RPN)计算来自大范围和不同尺度的图像，以产生有效的输出。

→需要考虑的要点

1. 限制–更快的 R-CNN 方法的主要限制之一是不同对象的命题中的时间延迟量。有时，速度取决于所用系统的类型。
2. 什么时候用更快的 R-CNN？–与其他 CNN 方法相比，预测时间更快。虽然 R-CNN 通常需要大约 40-50 秒来预测图像中的对象，但快速 R-CNN 需要大约 2 秒，但更快的 R-CNN 只需大约 0.2 秒即可返回最佳结果。
3. 用例示例–更快 R-CNN 的用例示例与 R-CNN 方法中描述的相似。然而，有了更快的 R-CNN，我们可以更好地执行这些任务，更有效地取得成果。

4.单发探测器(SSD)

→简介

用于多框预测的单次检测器是实现物体检测任务实时计算的最快方法之一。虽然更快的 R-CNN 方法可以实现高精度的预测，但是整个过程非常耗时，并且需要实时任务以大约每秒 7 帧的速度运行，这是远远不理想的。

单镜头检测器(SSD)通过将每秒帧数提高到比更快的 R-CNN 模型快近五倍来解决这个问题。它不再使用区域建议网络，而是使用多尺度特征和默认框。

→架构概述

SSD – Object Detection Algorithm | Source

单次触发多盒探测器架构可分为三个主要部分。单次检测器的第一阶段是特征提取步骤，选择所有关键的特征图。这个架构区域仅由完全卷积层组成，没有其他层。提取完所有的本质特征图后，接下来就是检测人头的过程。这一步也包括完全卷积神经网络。

然而，在探测头的第二阶段，任务不是找到图像的语义。相反，主要目标是为所有特征图创建最合适的边界图。一旦我们计算了两个基本阶段，最后一个阶段是使其通过非最大抑制层，以减少由重复的边界框引起的错误率。

→固态硬盘的局限性

1. SSD 虽然显著提升了性能，但会降低图像的分辨率，从而降低图像质量。
2. 对于小规模对象，SSD 架构的性能通常比更快的 R-CNN 差。

→需要考虑的要点

1. 什么时候用 SSD？–单次检测器通常是首选方法。使用单次检测器的主要原因是因为我们更喜欢对图像进行更快的预测，以检测更大的对象，在这种情况下精度不是非常重要的问题。然而，为了更准确地预测更小和更精确的物体，必须考虑其他方法。
2. 示例用例–单次检测器可以在多种数据集上进行训练和实验，如 PASCAL VOC、COCO 和 ILSVRC 数据集。它们可以很好地执行较大的对象检测，如人、桌子、椅子和其他类似实体的检测。

5.YOLO(你只看一眼)

→简介

你只看一次( YOLO )是物体检测最流行的模型架构和算法之一。通常，在谷歌上搜索物体检测算法的第一个概念是 YOLO 架构。YOLO 有几个版本，我们将在接下来的章节中讨论。YOLO 模型使用最好的神经网络原型之一来产生高精度和整体处理速度。这种速度和准确性是其受欢迎的主要原因。

→YOLO 的工作过程

YOLO – Object Detection Algorithm | Source

YOLO 体系结构利用三个主要术语来实现其目标检测。理解这三种技术对于了解为什么与其他对象检测算法相比，该模型执行得如此快速和准确是非常重要的。YOLO 模型中的第一个概念是残差块。在第一个建筑设计中，他们使用 7×7 的剩余块在特定的图像中创建网格。

这些网格中的每一个充当中心点，并且相应地对这些网格中的每一个做出特定的预测。在第二种技术中，考虑特定预测的每个中心点来创建边界框。虽然分类任务对每个格网都很有效，但是为每个预测分离边界框会更复杂。第三种也是最后一种技术是使用并集的交集(IOU)来计算特定对象检测任务的最佳边界框。

→YOLO 的优势

1. YOLO 的计算和处理速度是相当高的，特别是与大多数其他训练方法和目标检测算法相比实时性更好。
2. 除了快速的计算速度之外，YOLO 算法还设法提供整体的高精度，同时减少了在其他方法中看到的背景误差。
3. YOLO 的建筑允许模型更有效地学习和发展对众多物体的理解。

→YOLO 的局限性

1. 由于召回率较低，无法检测图像或视频中的较小对象。
2. 由于边界框的限制，无法检测两个彼此非常接近的对象。

→YOLO 的版本

YOLO 架构是最有影响力和最成功的对象检测算法之一。随着 2016 年 YOLO 架构的推出，他们的连续版本 YOLO v2 和 YOLO v3 于 2017 年和 2018 年问世。虽然 2019 年没有新版本，但 2020 年有三个快速版本:YOLO v4、YOLO v5 和 PP-YOLO。YOLO 的每一个新版本都比前一个版本稍有改进。微小的 YOLO 也被发布，以确保嵌入式设备可以支持对象检测。

→需要考虑的要点

1. 什么时候使用 YOLO？–虽然之前讨论的所有方法在图像和视频目标检测分析中表现都很好，但 YOLO 架构是实时目标检测的首选方法之一。它在大多数实时处理任务上实现了很高的准确性，具有相当快的速度和每秒帧数，具体取决于运行该程序的设备。
2. 示例用例–除了对众多对象进行对象检测之外，YOLO 架构的一些流行用例还包括车辆检测、动物检测和人员检测。更多信息，请参考以下链接。

6.RetinaNet

→简介

2017 年推出的 RetinaNet 模型成为这段时间内单次物体检测能力能够超越其他流行物体检测算法的最佳模型之一。当 RetinaNet 架构发布时，对象检测能力超过了 Yolo v2 和 SSD 模型。在保持与这些型号相同的速度的同时，它还能够在准确性方面与 R-CNN 家族竞争。由于这些原因，RetinaNet 模型在通过卫星图像探测物体方面有很高的使用率。

→架构概述

RetineNet – Object Detection Algorithm | Source

RetinaNet 架构的构建方式使得以前的单次检测器问题得到某种程度的平衡，从而产生更有效和高效的结果。在这种模型架构中，以前模型中的交叉熵损失被焦点损失代替。焦点损耗处理 YOLO 和 SSD 等架构中存在的类不平衡问题。RetinaNet 模型是三个主要实体的组合。

RetinaNet 使用三个因素构建，即 ResNet 模型(特别是 ResNet-101)、特征金字塔网络(FPN)和焦点损失。特征金字塔网络是克服先前架构的大部分缺点的最佳方法之一。它有助于将低分辨率图像的语义丰富的特征与高分辨率图像的语义较弱的特征相结合。

在最终输出中，我们可以创建分类和回归模型，类似于前面讨论的其他对象检测方法。分类网络用于适当的多类预测，而回归网络被构建来预测分类实体的适当边界框。关于这个主题的更多信息和阅读，请分别从以下链接查看文章或视频指南，【1】和【2】。

→需要考虑的要点

1. 何时使用 RetinaNet？–retina net 是目前众多不同任务中物体检测的最佳方法之一。它可以作为单次检测器的替代品，用于多种任务，以获得快速准确的图像结果。
2. 示例用例–re Tina net 对象检测算法可用于多种应用。RetinaNet 的一个高级应用程序用于航空和卫星图像中的物体检测。

1.ImageAI

→简介

ImageAI 库旨在为开发人员提供大量的计算机视觉算法和深度学习方法，以完成与对象检测和图像处理相关的任务。ImageAI 库的主要目标是提供一种用几行代码编写对象检测项目的有效方法。

关于这个主题的更多信息，请务必通过下面的链接访问 ImageAI 库的官方文档。大多数可用的代码块都是在 Python 编程语言和流行的深度学习框架 Tensorflow 的帮助下编写的。截至 2021 年 6 月，该库使用 PyTorch 后端来计算图像处理任务。

→概述

ImageAI 库支持大量与对象检测相关的操作，即图像识别、图像对象检测、视频对象检测、视频检测分析、自定义图像识别训练和推理以及自定义对象检测训练和推理。图像识别功能可以识别特定图像中多达 1000 个不同的对象。

图像和视频对象检测任务将有助于检测日常生活中最常见的 80 个对象。视频检测分析将有助于计算在视频中或实时检测到的任何特定对象的及时分析。也可以引入自定义图像来训练该库中的样本。在更新的图像和数据集的帮助下，您可以为对象检测任务训练更多的对象。

→ GitHub 参考

有关 ImageAI 库的更多信息和阅读，请参考以下 GitHub 参考。

2.格鲁恩科夫

→简介

GluonCV 是最好的库框架之一，拥有各种计算机视觉应用的深度学习算法的大多数最先进的实现。这个库的主要目标是帮助这个领域的爱好者在更短的时间内获得富有成效的结果。它拥有一些最好的特性，包括大量的训练数据集、实现技术和精心设计的 API。

→概述

GluonCV 库框架支持您可以用它完成的大量任务。这些项目包括图像分类任务、图像、视频或实时中的对象检测任务、语义分割和实例分割、用于确定特定身体姿势的姿势估计，以及用于检测正在执行的人类活动类型的动作识别。这些特性使这个库成为最好的对象检测库之一，可以更快地获得结果。

这个框架提供了执行前面提到的任务所需的所有最新技术。它支持 MXNet 和 PyTorch，并且有大量的教程和额外的支持，您可以从中开始探索许多概念。它包含大量的训练模型，您可以从中探索和创建您选择的特定机器学习模型来执行特定的任务。

在虚拟环境中安装了 MXNet 或 PyTorch 之后，您可以通过这个链接开始简单安装这个对象检测库。您可以选择库的特定设置。它还允许您访问模型动物园，这是轻松部署机器学习模型的最佳平台之一。所有这些特性使得 GluonCV 成为一个伟大的对象检测库。

→ GitHub 参考

关于这个库的更多信息和阅读，请查看下面的 GitHub 参考资料。

3.检测器 2

→简介

由脸书人工智能研究(FAIR)团队开发的 Detectron2 框架被认为是下一代库，支持大多数最先进的检测技术、对象检测方法和分割算法。 Detectron2 库是一个基于 PyTorch 的对象检测框架。该库具有高度的灵活性和可扩展性，为用户提供了多种高质量的实现算法和技术。它还支持脸书上的许多应用和生产项目。

→概述

FaceBook 在 PyTorch 上开发的 Detectron2 库有着巨大的应用，可以在单个或多个 GPU 上进行训练，以产生快速有效的结果。在这个库的帮助下，您可以实现几种高质量的对象检测算法，以达到最佳效果。该库支持的这些最先进的技术和对象检测算法包括

DensePose、panoptic 功能金字塔网络，以及开创性的 Mask R-CNN 模型系列的许多其他变体。【1】

Detectron2 库还允许用户轻松训练自定义模型和数据集。以下内容的安装过程非常简单。您需要的唯一依赖项是 PyTorch 和 COCO API。一旦您满足了以下要求，您就可以开始安装 Detectron2 模型，并轻松训练多个模型。要了解更多并理解如何使用下面的库，您可以使用下面的指南。

→ GitHub 参考

关于这个库的更多信息和阅读，请查看下面的 GitHub 参考资料。

4. YOLOv3_TensorFlow

→简介

YOLO v3 车型是 2018 年发布的 YOLO 系列的成功实现之一。YOLO 的第三个版本是对以前型号的改进。这个模型的性能在速度和准确性方面都优于它的前辈。与其他架构不同，它还可以在较小的对象上以良好的精度运行。与其他主要算法相比，唯一主要关注的是速度和准确性之间的权衡。

→概述

YOLOv3_TensorFlow 库是用于对象检测处理和计算的 YOLO 体系结构的最早实现之一。它提供了极快的 GPU 计算，有效的结果和数据管道，重量转换，更快的训练时间，等等。虽然可以从下一节提供的链接中获得该库，但对该框架的支持已经停止(与大多数其他框架类似)，现在由 PyTorch 支持。

→ GitHub 参考

有关 YOLO 的更多信息和阅读，请参考下面的 GitHub 参考。

5.暗流

→简介

Darkflow 的灵感来自于 darknet 框架，基本上是一个翻译，以适应 Python 编程语言和 TensorFlow，使其可以被更广泛的受众访问。Darknet 是一个用 C 和 CUDA 实现的对象检测库的早期实现。这个库的安装和工作过程非常简单，易于执行。该框架还支持对象检测任务的 CPU 和 GPU 计算，以在任一场景中获得最佳结果。

→概述

暗流框架的实现需要一些基本的必需品。这些基本需求包括 Python3、TensorFlow、Numpy 和 Opencv。有了这些依赖，您可以轻松地开始与对象检测相关的计算任务。有了暗流库，可以实现很多任务。暗流框架可以访问 YOLO 模型，您可以下载各种模型的自定义权重。

darkflow 库帮助您完成的一些任务包括解析注释、根据特定配置设计网络、绘制流图、训练新模型、训练自定义数据集、创建实时或视频文件、为其他类似应用程序使用 Darkflow 框架，最后，它还允许您将这些模型保存在 protobuf(.pb)格式。

→ GitHub 参考

有关更多信息和阅读，请参考以下 GitHub 参考。

物体检测仍然是迄今为止最重要的深度学习和计算机视觉应用之一。我们已经看到了物体检测方法的许多改进和进步。

它始于像梯度方向直方图这样的算法，这种算法早在 1986 年就被引入，用于以相当高的精度对图像进行简单的对象检测。现在，我们有了现代架构，如更快的 R-CNN、Mask R-CNN、YOLO 和 RetinaNet。

对象检测的限制不限于图像，因为它们可以在视频和实时镜头上以高精度有效地执行。在未来，更多成功的物体检测算法和库仍在等待着我们。

到此这篇pytorch模型部署到springbootweb（pytorch模型部署到web）的文章就介绍到这了,更多相关内容请继续浏览下面的相关推荐文章，希望大家都能在编程的领域有一番成就！

版权声明：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若内容造成侵权、违法违规、事实不符，请将相关资料发送至xkadmin@xkablog.com进行投诉反馈，一经查实，立即处理！

转载请注明出处，原文链接：https://www.xkablog.com/rgzn-ptkj/18262.html