读取pcap文件中的csi（python读取pcap文件）



原文：PaperSpace Blog

协议：CC BY-NC-SA 4.0

原文：https://blog.paperspace.com/how-to-implement-a-yolo-v3-object-detector-from-scratch-in-pytorch-part-3/

图片来源:凯罗尔·马杰克。查看他的 YOLO v3 实时检测视频这里

这是从头开始实现 YOLO v3 检测器教程的第 3 部分。在最后一部分中，我们实现了 YOLO 架构中使用的层，在这一部分中，我们将在 PyTorch 中实现 YOLO 的网络架构，这样我们就可以在给定图像的情况下产生一个输出。
我们的目标是设计网络的前向通路。

本教程的代码旨在运行在 Python 3.5 和 PyTorch 0.4 上。在这个 Github repo 可以找到它的全部内容。

本教程分为 5 个部分:

1. 第一部分:了解 YOLO 是如何运作的
2. 第 2 部分:创建网络架构的各层
3. 第 3 部分(这一部分):实现网络的前向传递
4. 第 4 部分:目标置信度阈值和非最大值抑制
5. 第五部分:设计输入和输出管道

先决条件

• 教程的第 1 部分和第 2 部分。
• PyTorch 的基本工作知识，包括如何使用、和类创建定制架构。
• 在 PyTorch 中处理图像

定义网络

正如我之前指出的，我们使用类在 PyTorch 中构建定制架构。让我们为检测器定义一个网络。在文件中，我们添加了下面的类。

在这里，我们对类进行了子类化，并将我们的类命名为。我们用成员、、和初始化网络。

实现网络的前向传递

网络的前向传递是通过重写类的方法来实现的。

有两个目的。第一，计算输出，第二，以更容易处理的方式变换输出检测特征图(例如变换它们，使得跨多个尺度的检测图可以连接，否则这是不可能的，因为它们具有不同的维度)。

接受三个参数，，输入和，如果为真，将使用 GPU 加速向前传递。

在这里，我们迭代而不是，因为的第一个元素是一个块，它不是向前传递的一部分。

由于路线和快捷方式层需要前一层的输出地图，我们在 dict 中缓存每一层的输出特征地图。关键字是层的索引，值是特征图

与使用函数的情况一样，我们现在迭代包含网络模块的。这里要注意的是，模块是按照它们在配置文件中出现的顺序添加的。这意味着，我们可以简单地通过每个模块运行我们的输入来获得我们的输出。

卷积和上采样层

如果模块是卷积或上采样模块，这就是正向传递的工作方式。

路径层/快捷方式层

如果您查看路由层的代码，我们必须考虑两种情况(如第 2 部分所述)。对于我们必须连接两个特征图的情况，我们使用第二个参数为 1 的函数。这是因为我们想要沿着深度连接特征图。(在 PyTorch 中，卷积层的输入和输出具有格式 B X C X H X W。深度对应于信道维度)。

YOLO(探测层)

YOLO 的输出是一个卷积要素地图，它包含沿要素地图深度的边界框属性。由像元预测的属性边界框一个接一个地堆叠在一起。因此，如果您必须访问(5，6)处单元格的第二个边界，那么您必须通过对其进行索引。这种形式对于输出处理来说非常不方便，例如通过对象置信度进行阈值处理、向中心添加网格偏移、应用锚点等。

另一个问题是，由于检测发生在三个尺度上，预测图的维度将是不同的。虽然三个特征图的尺寸不同，但是对它们进行的输出处理操作是相似的。如果必须在单个张量上进行这些操作，而不是在三个独立的张量上，那就太好了。

为了解决这些问题，我们引入了函数

转换输出

函数位于文件中，当我们在类的中使用它时，我们将导入该函数。

将导入添加到的顶部

接受 5 个参数；预测(我们的输出)、 inp_dim (输入图像尺寸)、锚点、 num_classes ，以及一个可选的 CUDA 标志

函数获取一个检测特征图，并将其转换成一个二维张量，其中张量的每一行对应于一个边界框的属性，顺序如下。

下面是完成上述转换的代码。

锚的尺寸与块的和属性一致。这些属性描述了输入图像的尺寸，它比检测图大(大了步距倍)。因此，我们必须根据检测特征图的步幅来划分锚点。

现在，我们需要根据我们在第 1 部分中讨论的等式来转换我们的输出。

Sigmoid，y 坐标和客观性分数。

将网格偏移量添加到中心坐标预测中。

将锚点应用于边界框的尺寸。

将 sigmoid 激活应用于课程分数

这里我们要做的最后一件事是将检测图的大小调整为输入图像的大小。这里的边界框属性的大小是根据特征图确定的(比如 13 x 13)。如果输入图像是 416 x 416，我们将属性乘以 32，即变量的步幅。

这就结束了循环体。

在函数结束时返回预测值。

重新访问检测层

既然我们已经转换了输出张量，我们现在可以将三个不同尺度的检测图连接成一个大张量。请注意，这在我们的转换之前是不可能的，因为我们不能连接具有不同空间维度的特征地图。但是从现在开始，我们的输出张量仅仅作为一个表格，用边界框作为它的行，连接是非常可能的。

我们道路上的一个障碍是我们不能初始化一个空张量，然后连接一个非空的(不同形状的)张量。因此，我们延迟收集器(保存检测的张量)的初始化，直到我们获得第一个检测图，然后在我们获得后续检测时连接到它的映射。

注意函数中循环之前的行。标志用于指示我们是否遇到了第一次检测。如果为 0，表示采集器还没有初始化。如果它是 1，这意味着收集器已经初始化，我们可以将我们的检测图连接到它。

现在，我们已经用函数武装了自己，我们在函数中编写处理检测特征图的代码。

在您的文件的顶部，添加以下导入。

然后，在功能中。

现在，只需返回检测结果。

测试向前传球

这是一个创建虚拟输入的函数。我们将把这些信息传递给我们的网络。在我们编写这个函数之前，将这个图像保存到您的工作目录中。如果你在 linux 上，那么输入。

现在，在文件的顶部定义函数，如下所示:

然后，我们键入以下代码:

您将看到如下输出。

这个张量的形状是。第一个维度是批量大小，简单地说就是 1，因为我们使用了单个图像。对于一批中的每个图像，我们有一个 10647 x 85 的表格。每个表格的行代表一个边界框。(4 个 bbox 属性、1 个对象分数和 80 个类别分数)

此时，我们的网络具有随机的权重，不会产生正确的输出。我们需要在网络中加载一个权重文件。为此，我们将使用官方重量文件。

下载预先训练的重量

将砝码文件下载到您的检测机目录中。从这里抓取权重文件。或者如果你在 linux 上，

了解砝码文件

官方重量文件是二进制文件，包含以串行方式存储的重量。

读取重量时必须非常小心。权重只是作为浮点数存储，没有任何东西来指导我们它们属于哪一层。如果你搞砸了，没有什么可以阻止你，比如说，把一个批范数层的权重加载到一个卷积层的权重中。因为您读取的只是浮动，所以无法区分哪个权重属于哪个层。因此，我们必须了解权重是如何存储的。

首先，权重只属于两种类型的层，或者是批范数层，或者是卷积层。

这些层的权重完全按照它们在配置文件中出现的顺序存储。所以，如果一个后面跟着一个块，然后一个块后面跟着另一个块，你会期望文件包含前一个块的权重，然后是后一个块的权重。

当批次标准层出现在块中时，不存在偏差。然而，当没有批规范层时，偏差"权重"必须从文件中读取。

下图总结了权重如何存储权重。

装船重量

让我们写一个函数加载权重。它将是类的成员函数。它需要一个参数，而不是权重文件的路径。

权重文件的前 160 个字节存储 5 个值，这些值构成了文件的标题。

其余的位现在按照上述顺序表示权重。权重存储为或 32 位浮点数。让我们在一个中装载其余的重量。

现在，我们迭代权重文件，并将权重加载到网络的模块中。

进入循环，我们首先检查块的是否为真。在此基础上，我们加载重量。

我们保留一个名为的变量来跟踪我们在权重数组中的位置。现在，如果为真，我们如下加载权重。

如果 batch_norm 不为真，只需加载卷积层的偏差。

最后，我们加载卷积层的权重。

我们已经完成了这个函数，现在你可以通过调用 darknet 对象上的函数在你的对象中加载权重。

这就是这一部分的全部内容，随着模型的建立和权重的加载，我们终于可以开始检测物体了。在下一个部分中，我们将介绍使用目标置信度阈值和非最大值抑制来产生我们的最终检测集。

进一步阅读

1. PyTorch 教程
2. 用 NumPy 读取二进制文件
3. nn。模块，nn。参数类别

Ayoosh Kathuria 目前是印度国防研究与发展组织的实习生，他致力于改进粒状视频中的物体检测。当他不工作的时候，他不是在睡觉就是在用吉他弹奏平克·弗洛伊德。你可以在 LinkedIn 上和他联系，或者在GitHubT5 上看看他做了些什么

原文：https://blog.paperspace.com/how-to-implement-a-yolo-v3-object-detector-from-scratch-in-pytorch-part-4/

图片来源:凯罗尔·马杰克。查看他的 YOLO v3 实时检测视频这里

这是从头开始实现 YOLO v3 检测器教程的第 4 部分。在最后一部分，我们实现了网络的前向传递。在这一部分中，我们通过对象置信度以及随后的非最大抑制来设定检测阈值。

本教程的代码旨在运行在 Python 3.5 和 PyTorch 0.4 上。在这个 Github repo 可以找到它的全部内容。

本教程分为 5 个部分:

1. 第一部分:了解 YOLO 是如何运作的
2. 第 2 部分:创建网络架构的各层
3. 第三部分:实现网络的前向传递
4. 第 4 部分(这一部分):置信阈值和非最大值抑制
5. 第五部分:设计输入和输出管道

先决条件

1. 教程的第 1-3 部分。
2. PyTorch 的基本工作知识，包括如何使用 nn 创建定制架构。模块，nn。Sequential 和 torch.nn.parameter 类。
3. NumPy 的基础知识

如果你在任何方面有所欠缺，这篇文章下面有一些链接供你参考。

在前面的部分中，我们已经建立了一个模型，该模型在给定输入图像的情况下输出几个对象检测。准确地说，我们的输出是一个形状为的张量。b 是一批图像的数量，10647 是每个图像预测的边界框的数量，85 是边界框属性的数量。

然而，如第 1 部分所述，我们必须对我们的输出进行客观分数阈值处理和非最大抑制，以获得我在本文剩余部分称为真检测的结果。为此，我们将在文件中创建一个名为的函数

这些函数将、(客观分数阈值)、(在我们的例子中是 80)和(NMS IoU 阈值)作为输入。

目标置信度阈值

我们的预测张量包含关于包围盒的信息。对于每个具有低于阈值的对象性分数的边界框，我们将它的每个属性(代表边界框的整行)的值设置为零。

执行非最大抑制

注意:我假设你理解什么是 IoU(交集/并集),什么是非最大抑制。如果不是这样，请参考文章末尾的链接)。

我们现在拥有的边界框属性由中心坐标以及边界框的高度和宽度来描述。然而，使用每个盒子的一对对角的坐标，更容易计算两个盒子的 IoU。因此，我们将盒子的(中心 x，中心 y，高度，宽度)属性转换为(左上角 x，左上角 y，右下角 x，右下角 y)。

每个图像中的真检测的数量可能不同。例如，一批大小为 3 的图像 1、2 和 3 分别具有 5、2、4 个真检测。因此，必须一次对一幅图像进行置信阈值处理和 NMS。这意味着，我们不能对所涉及的操作进行矢量化，必须循环遍历第一维度的(包含一批图像的索引)。

如前所述，标志用于指示我们还没有初始化，我们将使用这个张量来收集整个批次的真检测。

一旦进入循环，让我们稍微清理一下。注意每个边界框行有 85 个属性，其中 80 个是类分数。此时，我们只关心具有最大值的类分数。因此，我们从每一行中删除了 80 个类分数，取而代之的是添加具有最大值的类的索引，以及该类的类分数。

还记得我们已经将对象置信度小于阈值的边界框行设置为零吗？让我们摆脱他们。

try-except 块用于处理没有检测到的情况。在这种情况下，我们使用来跳过这个图像的其余循环体。

现在，让我们在图像中检测类别。

由于同一个类可能有多个真检测，我们使用一个名为的函数来获取任何给定图像中存在的类。

然后，我们按班级表演 NMS。

一旦我们进入循环，我们做的第一件事就是提取特定类的检测(用变量表示)。

下面的代码在原始代码文件中缩进了三个块，但是我没有在这里缩进，因为这一页的空间有限。

现在，我们表演 NMS。

这里，我们使用一个函数。第一个输入是由循环中的变量索引的边界框行。

的第二个输入是多行边界框的张量。函数的输出是包含由第一输入表示的边界框的 IoUs 的张量，每个边界框出现在第二输入中。

如果我们有两个相同类别的边界框，其 IoU 大于阈值，那么具有较低类别置信度的边界框被消除。我们已经挑选出了包围盒，具有较高置信度的包围盒位于顶部。

在循环体中，下面几行给出了框的 IoU，由索引，所有边界框的索引都高于。

每次迭代，如果索引大于的任何边界框具有大于阈值的 IoU(由索引的框)，则该特定框被消除。

还要注意，我们将计算的代码行放在了一个 try-catch 块中。这是因为循环被设计成运行次迭代(T2 中的行数)。然而，随着循环的进行，一些边界框可能会从中移除。这意味着，即使从中移除一个值，我们也不能进行次迭代。因此，我们可能会尝试索引一个越界的值()，或者切片可能会返回一个空张量，指定哪个触发了。在这一点上，我们可以确定 NMS 不能删除更多的边界框，我们打破了循环。

计算欠条

下面是函数。

写预测

函数输出形状为 D×8 的张量。这里 D 是所有图像中的真检测，每一个由一行表示。每个检测有 8 个属性，即检测所属批次中图像的索引、 4 个角坐标、客观分数、最大置信度类的分数以及该类的索引。

就像以前一样，我们不初始化我们的输出张量，除非我们有一个检测分配给它。一旦它被初始化，我们就将后续的检测连接到它。我们使用标志来表示张量是否已经初始化。在遍历类的循环结束时，我们将得到的检测结果添加到张量中。

在函数结束时，我们检查是否已经初始化。如果没有，意味着在该批次的任何图像中没有一个检测到。在这种情况下，我们返回 0。

这就是这篇文章的内容。在这篇文章的最后，我们终于有了一个张量形式的预测，它以行的形式列出了每个预测。现在唯一剩下的就是创建一个输入管道来从磁盘读取图像，计算预测，在图像上绘制边界框，然后显示/写入这些图像。这是我们在下一个部分要做的事情。

进一步阅读

1. PyTorch 教程
2. 借据
3. 非最大抑制
4. 非最大抑制

Ayoosh Kathuria 目前是印度国防研究与发展组织的实习生，他致力于改进粒状视频中的物体检测。当他不工作的时候，他不是在睡觉就是在用吉他弹奏平克·弗洛伊德。你可以在 LinkedIn 上和他联系，或者在GitHubT5 上看看他做了些什么

原文：https://blog.paperspace.com/how-to-implement-a-yolo-v3-object-detector-from-scratch-in-pytorch-part-5/

图片来源:凯罗尔·马杰克。查看他的 YOLO v3 实时检测视频这里

这是从头开始实现 YOLO v3 检测器教程的第 5 部分。在最后一部分中，我们实现了一个函数来将网络的输出转换成检测预测。有了可用的检测器，剩下的工作就是创建输入和输出管道。

本教程的代码旨在运行在 Python 3.5 和 PyTorch 0.4 上。在这个 Github repo 可以找到它的全部内容。

本教程分为 5 个部分:

1. 第一部分:了解 YOLO 是如何运作的
2. 第 2 部分:创建网络架构的各层
3. 第三部分:实现网络的前向传递
4. 第 4 部分:置信阈值和非最大值抑制
5. 第 5 部分(这一部分):设计输入和输出管道

先决条件

1. 教程的第 1-4 部分。
2. PyTorch 的基本工作知识，包括如何使用 nn 创建定制架构。模块，nn。Sequential 和 torch.nn.parameter 类。
3. OpenCV 的基础知识

编辑:如果你在 2018 年 3 月 30 日之前访问过这篇文章，我们将任意大小的图像调整到 Darknet 的输入大小的方法就是简单地重新调整尺寸。然而，在最初的实现中，图像被调整大小，保持纵横比不变，并填充被省略的部分。例如，如果我们要将一个 1900 x 1280 的图像调整为 416 x 415，调整后的图像将如下所示。

准备输入的这种差异导致早期实现的性能比最初的稍差。不过，帖子已经更新，加入了最初实现中的调整大小方法

在这一部分中，我们将构建检测器的输入和输出管道。这包括从磁盘上读取图像，进行预测，使用预测在图像上绘制边界框，然后将它们保存到磁盘上。我们还将介绍如何让检测机在摄像头或视频上实时工作。我们将引入一些命令行标志，以允许对网络的各种超参数进行一些实验。让我们开始吧。

注意:你需要为这部分安装 OpenCV 3。

在巡回检测器文件中创建一个文件。在它的顶部添加必要的进口商品。

创建命令行参数

因为是我们将执行来运行我们的检测器的文件，所以最好有我们可以传递给它的命令行参数。我已经用 python 的模块做到了。

其中重要的标志有(用于指定输入图像或图像目录)(保存检测的目录)(输入图像的分辨率，可用于速度-精度的权衡)(备选配置文件)。

加载网络

从这里下载文件，这个文件包含 COCO 数据集中对象的名称。在探测器目录下创建一个文件夹。同样，如果你在 linux 上，你可以输入。

然后，我们在程序中加载类文件。

是在中定义的一个函数，它返回一个字典，该字典将每个类的索引映射到它的名称字符串。

初始化网络并加载权重。

读取输入图像

从磁盘或目录中读取图像。图像的路径存储在一个名为的列表中。

是用来测量时间的检查点。(我们会遇到几个这样的例子)

如果由标志定义的保存检测的目录不存在，则创建它。

我们将使用 OpenCV 来加载图像。

又是一个检查站。

OpenCV 将图像作为 numpy 数组加载，BGR 作为颜色通道的顺序。PyTorch 的图像输入格式为(批次 x 通道 x 高度 x 宽度)，通道顺序为 RGB。因此，我们在中编写函数，将 numpy 数组转换成 PyTorch 的输入格式。

在我们写这个函数之前，我们必须写一个函数来调整我们的图像，保持长宽比一致，并用颜色(128，128，128)填充剩下的区域

现在，我们编写一个获取 OpenCV 图像并将其转换为网络输入的函数。

除了转换后的图像之外，我们还维护一个原始图像列表和一个包含原始图像尺寸的列表。

创建批处理

检测回路

我们迭代批次，生成预测，并连接我们必须对其执行检测的所有图像的预测张量(形状为 D×8，是函数的输出)。

对于每一批，我们测量检测所需的时间，即从获取输入到产生函数的输出所花费的时间。在返回的输出中，其中一个属性是批量图像的索引。我们以这样一种方式转换这个特定的属性，它现在表示图像在中的索引，这个列表包含所有图像的地址。

之后，我们打印每次检测所用的时间以及每幅图像中检测到的对象。

如果批处理的函数的输出是一个 (0)，意味着没有检测，我们使用来跳过剩余的循环。

第行确保 CUDA 内核与 CPU 同步。否则，一旦 GPU 作业排队，CUDA 内核就会在 GPU 作业完成之前将控制权返回给 CPU(异步调用)。如果在 GPU 作业实际结束之前被打印，这可能会导致误导时间。

现在，我们有了张量输出中所有图像的检测。让我们在图像上画出边界框。

在图像上绘制边界框

我们使用一个 try-catch 块来检查是否进行了单次检测。如果不是这样，退出程序。

在我们绘制边界框之前，包含在输出张量中的预测符合网络的输入大小，而不是图像的原始大小。因此，在我们绘制边界框之前，让我们将每个边界框的角属性转换为图像的原始尺寸。

在我们绘制边界框之前，输出张量中包含的预测是对填充图像的预测，而不是对原始图像的预测。仅仅将它们重新缩放到输入图像的尺寸在这里是行不通的。我们首先需要根据包含原始图像的填充图像上的区域边界来转换要测量的框的坐标。

现在，我们的坐标与填充区域的图像尺寸一致。然而，在函数中，我们用一个比例因子调整了图像的两个维度(记住两个维度都用一个公共因子划分以保持纵横比)。我们现在取消这种重新缩放，以获得原始图像上边界框的坐标。

现在，让我们将任何可能具有图像外部边界的边界框裁剪到图像的边缘。

如果图像中有太多的边界框，用一种颜色绘制它们可能不是一个好主意。将此文件下载到您的探测器文件夹中。这是一个腌制的文件，包含许多颜色可以随机选择。

现在让我们写一个画方框的函数。

上面的函数用从中随机选择的颜色绘制了一个矩形。它还在边界框的左上角创建一个填充矩形，并在填充矩形上写入检测到的对象的类。函数的参数用于创建填充矩形。

我们在本地定义了函数，这样它就可以访问列表。我们也可以把作为一个参数，但是那会让我们每张图片只使用一种颜色，这违背了我们想要做的目的。

一旦我们定义了这个函数，现在让我们在图像上绘制边界框。

上面的代码片段在中修改了 中的图像。

通过在图像名称前加上前缀“det_”来保存每个图像。我们创建一个地址列表，用于保存我们的检测图像。

最后，将检测到的图像写入中的地址。

打印时间摘要

在检测器的最后，我们将打印一份摘要，其中包含代码的哪一部分执行了多长时间。当我们必须比较不同的超参数如何影响检测机的速度时，这是很有用的。当在命令行上执行脚本时，可以设置超参数，如批量大小、对象置信度和 NMS 阈值(分别用、、标志传递)。

测试对象检测器

例如，在终端上运行，

产生输出

下面的代码在 CPU 上运行。预计 GPU 上的检测时间要快得多。在特斯拉 K80 上大约是 0.1 秒/图像。

名为的图像保存在目录中。

在视频/网络摄像头上运行检测机

为了在视频或网络摄像头上运行检测器，代码几乎保持不变，只是我们不需要迭代批次，而是视频的帧。

在视频上运行检测器的代码可以在 github 存储库中的文件中找到。代码与非常相似，除了一些变化。

首先，我们在 OpenCV 中打开视频/摄像机提要。

我们以类似于迭代图像的方式迭代帧。

许多代码在许多地方都得到了简化，因为我们不再需要处理批处理，而是一次只处理一个图像。这是因为一次只能出现一帧。这包括用一个元组代替张量用于和在函数中的微小变化。

每次迭代，我们都在一个名为的变量中记录捕获的帧数。然后，我们将这个数字除以从第一帧开始打印视频的 FPS 所经过的时间。

代替使用将检测图像写入磁盘，我们使用显示其上绘制有边界框的帧。如果用户按下按钮，就会导致代码中断循环，视频结束。

结论

在这一系列教程中，我们已经从头实现了一个对象检测器，并为达到这一步而欢呼。我仍然认为，能够生成高效代码是深度学习实践者可能拥有的最被低估的技能之一。无论你的想法多么具有革命性，除非你能检验它，否则毫无用处。为此，你需要有很强的编码技能。

我还了解到，了解深度学习中任何主题的最佳方式是实现代码。它迫使你浏览一个你在阅读论文时可能会错过的主题的细微但基本的微妙之处。我希望这一系列教程能够锻炼你作为深度学习实践者的技能。

进一步阅读

1. PyTorch 教程
2. OpenCV 基础知识
3. Python ArgParse

Ayoosh Kathuria 目前是印度国防研究与发展组织的实习生，他致力于改进粒状视频中的物体检测。当他不工作的时候，他不是在睡觉就是在用吉他弹奏平克·弗洛伊德。你可以在 LinkedIn 上和他联系，或者在GitHubT5 上看看他做了些什么

原文：https://blog.paperspace.com/how-to-maximize-gpu-utilization-by-finding-the-right-batch-size/

在建立机器学习模型时，我们总是在为我们的模型和训练配置寻找最有效的参数。这些设置可能包括优化器、批量大小、层堆栈设置，甚至数据形状。在本文中，我们将讨论在训练神经网络架构时可能遇到的批量大小约束。我们还将看到这个元素如何受到 GPU 的能力及其可用内存的影响。然后，我们将看看如何为我们的 GPU/模型组合找到最佳批量。

样品

一个样本代表一个数据元素。它包括用于训练算法的输入以及用于通过与预测进行比较来计算误差的输出。也可以叫做:观测，一个输入向量，或者一个特征向量。

批量

批量指的是在更新其可训练模型变量或权重和偏差之前，用于训练模型的样本的数量。也就是说，一批样本在每个训练步骤通过模型，然后反向传递以确定每个样本的梯度。为了确定可训练模型变量的更新，然后根据所使用的优化器的类型，对所有样本的梯度进行平均或相加。参数更新后，将对后续批次的样本重复此过程。

世

历元数，这是一个超参数，控制学习算法将在整个训练数据集中运行多少次。
一个时期表示内部模型参数有机会为训练数据集中的每个样本更新一次。根据配置，在一个时期内可以有一个或多个批次。

循环

一次迭代就是完成一个时期所需的批数。例如，如果一个数据集包含被分成 20 批的 10000 个样本。然后，我们需要多次 500 次迭代(10 000 = 500 × 20)来遍历一个历元。

GPU 使用和内存

首先，让我们来评估不同的批处理大小对 GPU 使用和 GPU 内存的影响。机器学习俄亥俄大学的研究人员实际评估了增加批量大小对 GPU 利用率的影响。他们使用了 3 个最常用的机器学习框架(TensorFlow、PyTorch 和 MXnet ),然后记录了结果:

TensorFlow :

指针 :

MXNet :

然后将这些结果绘制成图表进行比较

GPU Usage under 3 frameworks (Source)

我们看到，当批量相对较小时，TensorFlow 的 GPU 使用率最低，MXnet 的 GPU 使用率最高。而当批量相对较大时，TensorFlow 的 GPU 利用率最高，PyTorch 最低。此外，我们还可以观察到，随着批处理大小的增长，GPU 消耗也将大幅增长。

GPU Memory Usage under 3 frameworks (Source)

当批处理大小增加时，我们可以看到 MXnet 比其他两个占用了更多的内存，尽管它们几乎没有变化。大多数时候，MXnet 占用的内存最多。MXnet 将所有批量数据保存在 GPU RAM 中，然后在整个应用程序运行完毕后释放它们，这是一个潜在的解释。另一方面，批量数据处理是 TensorFlow 和 PyTorch 的操作方式。在处理单个时期后，与单个批次相关的数据将从存储器中移除。

增加批处理大小是提高 GPU 使用率的一种直接方法，尽管它并不总是成功的。批量大小的梯度通常在 GPU 上并行计算。因此，只要有足够的内存来容纳一切，大批量就可以提高 GPU 的使用率和训练性能。在 PyTorch 的情况下，GPU 和内存利用率基本保持不变。这是因为 PyTorch 采用了一种分配方法，当批量过大时，这种方法会降低 GPU 利用率、CPU 内存和训练速度，反之亦然。

一般来说，内存消耗随着批处理大小值的增加而增加。
使用的框架，模型的参数和模型本身以及每一批数据都会影响内存的使用。然而，这种效果很大程度上取决于使用的型号！

精确度和算法性能

同一篇学术论文还包括一些关于批量大小及其对训练算法准确性的影响的有趣发现。对于 TensorFlow 框架，研究人员评估了不同批量值的 10 个时期后的准确性:

然后我们可以在下图中绘制这种变化:

Accuracy after 10 epoches vs Batch size for Tensorflow framework (Source)

评估准确度时，采用不同的批次大小值可能会产生重要影响，在选择批次大小时应予以考虑。使用小批量或大批量可能有两个主要的负面影响。

Illustration of Underfitting, Overfitting and Ideal scenarios of model training

过拟合

批量大可能导致泛化能力差，模型甚至会陷入局部极小值。由于泛化，神经网络将在训练集之外的样本上表现得相当好。然而，也可能发生相反的情况，神经网络在训练集之外发现的样本上表现不佳，这实质上是过度拟合。从图表中可以看出这种影响；从批量大小 256 开始，该模型偏离绝对最小值，并且在新数据上表现出较低的准确性。一项关于深度学习的大批量训练的研究通过分析检验了同样的现象，并证实了这一发现。

欠拟合(缓慢收敛)

小批量可能是学习算法收敛缓慢的原因。在每个阶段执行并使用一批样本计算的变量更新将决定未来一批样本的起始点。因为每一步都涉及从训练集中随机选择训练样本，所以产生的梯度是基于不完整数据的噪声估计。我们在单个批次中使用的数据越少，梯度估计就越嘈杂，越不精确。换句话说，当批量很小时，单个样本对应用的变量更新有更大的影响。换句话说，较小的批量可能会导致学习过程更加嘈杂和不规则，从而延迟学习过程。在上面的例子中，我们可以看到，在 10 个时期后，批量大小为 4 只能使我们达到 32%的准确度，这不如批量大小为 128 所获得的准确度好。

如前一节所述，批量大小是一个重要的超参数，对模型的拟合或缺失有重大影响。它也可能对 GPU 的使用产生影响。我们可以预计，提高批量大小将提高训练速度(即 GPU 利用率)，但这种增益将受到前述收敛问题(过拟合)的限制。

因此，在本节中，我们将讨论一些用于确定最佳批处理大小的策略，这些策略利用了 GPU 所提供的一切，同时避免了过度拟合的极端情况。

数据扩充

可以考虑的技术之一是数据扩充。该方法将提供增加批量大小的可能性，同时保持每个时期良好且可接受的精度增加。虽然这项技术的应用因地区而异，但通常需要通过对训练数据进行仔细控制的更改来增加数据集。例如，在图像识别的情况下，可以通过平移、旋转、剪切、调整大小、裁剪甚至翻转训练数据中的图像来放大训练集。

保守训练

在大批量训练的情况下，一些优化器的收敛速度比其他的更好。关于随机优化技术效果的研究表明，标准随机梯度下降(SGD)优化器的收敛速度可以提高，特别是对于大批量。在前面提到的论文中介绍了一种基于每个小批量内保守正则化目标函数的近似优化的方法。此外，研究表明收敛速度不受小批量大小的影响。他们还表明，通过替代优化器的正确实现，我们可以胜过传统的 SGD，例如亚当。ADAM 优化方法是一种随机梯度下降扩展，最近在深度学习应用中，尤其是在计算机视觉和自然语言处理中，越来越受欢迎。

强健的训练

稳健训练是另一种自然的技术，可以防止在增加批量时出现不良泛化的后果。这些策略试图通过最大化最坏情况(稳健)成本而不是目标函数的名义成本来减少增加批量的影响。

Example of two minima with the different nominal and robust cost (Source)

在前面的例子中，最大稳健最坏情况的位置不同于目标函数的标称最小位置。

案例研究:猫狗图像分类

在本节中，我们将使用 TensorFlow/Keras 为猫和狗的图像构建一个分类器。然后，使用标准 SGD 优化器和默认数据格式，针对各种批量值评估模型的性能。然后，使用前面讨论的策略，我们将尝试增加批量大小，同时保持甚至提高精度。

让我们首先准备数据集

下载&解压

分割训练/验证/测试子集

首先，我们创建文件夹来存储调整后的图像

然后，使用 Keras 图像预处理库，我们加载图像，将它们调整为 200 像素/200 像素的文件，然后将结果保存在文件夹中。我们每个班总共取 1000 幅图像:600 幅用于训练，200 幅用于验证，200 幅用于测试。

培训&评估模型

对于模型，我们将使用 Tensorflow/Keras 序列模型。训练和评估过程嵌入在一个函数中，该函数将批量大小和优化器作为输入。这个函数稍后将用于评估优化器对批量大小的影响

比较优化器:SGD vs Adam

对于不同的批量大小值(16、32、64 和 128)，我们将在 5 个时期后评估 Adam 和 SGD 优化器的模型准确性。

然后，我们将使用 Matplotlib 绘制结果

Accuracy vs batch size for Adam & SGD optimizers

我们可以清楚地看到，对于批量 16， SGD 的准确度约为 62%,随着批量的增加，准确度开始迅速下降。这与亚当、T5 的情况不同，准确度下降不太明显，在批量 64 左右，准确度仍在 67%附近，这表示增加了四倍，同时仍保持可接受的准确度。

但是，我们也可以注意到，对于这两个优化器，从批量大小 128 开始，准确性急剧下降。因此，我们可以推导出，在这个模型中，Adam 的最佳批量是 64，SGD 的最佳批量是 16。

数据扩充的效果

让我们首先为扩充的训练和验证数据创建新的目录。

现在，让我们用原始数据和每个图像的新的调整大小和裁剪版本填充这些文件夹。这将导致最终数据集的大小是原始数据集的两倍。所述操作也通过图像预处理 Keras 库来完成:

现在我们引入一个新的训练和评估函数，它将训练/验证文件夹以及批量大小作为输入。该函数将对所有数据集使用 Adam 优化器。

然后，我们将评估不同批量的准确性。在原始数据和扩充数据集的两种情况下。

最后，我们绘制两个数据集的结果精度值。您可能会在一个免费的 GPU 上耗尽内存，因此考虑升级到我们的 Pro 或 Growth plan，以访问 Paperspace 上更强大的 GPU。

Accuracy vs batch size for Standard & Augmented data

使用增加的数据，我们可以增加批量大小，同时降低对准确性的影响。事实上，仅用 5 个历元进行训练，我们就可以以 58% 的准确度读取批量 128 ，以 57.5% 的准确度读取 256 。

由于结合了这两种策略(Adam optimizer 和数据扩充)，我们能够采用 128 而不是 16 的批量大小，这是 8 倍的收益，同时保持了可接受的准确率。

在本文中，我们讨论了在训练神经网络体系结构时可能出现的批量大小限制。我们还看到了 GPU 的能力和内存容量如何影响这一因素。然后，我们评估了批量增加对模型精度的影响。最后，我们研究了如何确定我们的 GPU/模型组合的理想批量大小。

通常存在一个阈值，超过该阈值，模型的质量会随着用于模型训练的批量的增加而降低。然而，通过一些正确的方法，如案例研究中所示，这种降级可能会传递到更大的批量，从而允许我们增加该参数并更好地利用现有的 GPU 功能。

https://etd.ohiolink.edu/apexprod/rws_etd/send_file/send?登录=osu70594

https://arxiv.org/pdf/1711.00489.pdf

https://arxiv.org/pdf/1609.04836.pdf

https://dl.acm.org/doi/10.1145/.

原文：https://blog.paperspace.com/how-to-run-tableau-on-chromebook/

Tableau Desktop 是一个商业分析解决方案，可以可视化数据并提供来自几乎任何数据源的见解。它是为协作而构建的，可以处理大量数据。Chromebooks 和其他瘦客户端为团队提供了廉价的硬件来支持协作，但不能满足 Tableau 桌面的要求。借助 Paperspace，数据分析师团队可以在 Chromebooks(和任何其他设备)上的安全云环境中轻松地进行远程协作。

想要更多曝光？

如果您希望您的数据科学工作流以 Paperspace 为特色，请给我们发送电子邮件至 ，或发推特给我们，包括标签#PoweredByPaperspace

• 发动机器
  1. 机器建议
• Tableau 桌面需求
  1. 推荐的纸张空间机器
• 找到您的产品密钥
  1. 客户门户
• 下载并安装 Tableau 桌面
  1. 注册
• GPU 加速用 Tableau 桌面
  1. 运动能力
• 结论

1。创造一种新的纸张空间机器

登录到 Paperspace 后，创建一台新机器。

• 选择最近的区域
• 选择一个 Windows 模板
• 根据您的需要选择每月或每小时。
• 选择你的计划:
  • 数据分析:由于 Tableau Desktop 不像其他平台那样利用 GPU 加速，我们建议至少采用标准计划。也可以参考下面的 GPU 加速数据库。
• 选择您的存储 —您可以在未来的任何时候增加您的存储，但我们强烈建议您使用 500GB 或更大的容量来管理大型数据集。
• 点击创建

2。 Tableau 桌面需求

要安装 Tableau Desktop，您需要:

• 安装程序
• 您的产品密钥。

  该字符串将您标识为 Tableau 客户，并且是激活产品所必需的。下面我们将讨论如何找到您的产品密钥。

  注意:如果您是学生或教师，您可以访问他们的学术计划页面申请许可证，并获得有关如何下载您自己的 Tableau Desktop 副本的说明。你也可以尝试 14 天的免费试用。

3。找到您的产品密钥

在您购买 Tableau Desktop 后，Tableau 会向您发送一封欢迎电子邮件，其中包含您登录其客户门户所需的信息。您的产品密钥位于客户门户网站中。安装过程完成后，您需要产品密钥来激活 Tableau Desktop。如果您在登录客户入口网站页面时遇到问题，或者如果您在检索产品密钥时需要帮助，请联系客户服务并提供您的姓名、公司、电话号码和电子邮件地址。

按照以下步骤找到您的产品密钥，以便您在进入激活步骤时做好准备。

查找您的产品密钥

• 使用您的电子邮件地址和 Tableau 提供的密码登录 Tableau 网站上的客户门户页面。
• 点击我的钥匙。
• 从表中的“密钥名称”列复制您的产品密钥。把这把钥匙准备好并保管好。
• 安装并激活 Tableau Desktop 后，您还可以从工具栏菜单的帮助>管理产品密钥下查看电脑上使用的产品密钥。

4。下载并安装 Tableau 桌面

要安装 Tableau Desktop:

1. 将安装程序下载到您的 Paperspace 计算机中。

   有关 Tableau Desktop 的最新版本，请访问客户门户网站页面。在“产品下载”部分，单击下载用于 Windows 64 位的 Tableau 桌面安装程序。
   
   

2. 运行安装程序。
   
   
3. 允许更改设备。
   
   
4. Tableau 桌面安装过程完成后，打开 Tableau。这将启动 Tableau 注册表单，您可以在其中注册并激活您的产品。
5. 填写注册表上的字段，然后单击激活 Tableau。
6. 删除激活面板中的任何现有文本，复制您的产品密钥(从您在查找产品密钥过程中保存它的位置)并将其粘贴到文本框中，然后单击激活。

6. 将出现第二个屏幕来完成激活过程。单击继续完成该过程。

5。【Tableau 桌面的 GPU 加速

虽然 Tableau Desktop 本身没有利用 GPU，但有 GPU 加速的数据库为 Tableau 提供集成和支持。我们在下面列出了几个例子。

• Kinetica
• MapD

6。结论

Tableau 提供强大的数据分析工具，可以利用 Paperspace 的同类最佳云桌面实现轻松协作。我们希望你能在与我们分享你自己的经历。

尽情享受吧！

要使用 Tableau 和 Paperspace 构建您自己的数据科学实验室，请在此注册。

我们需要你的帮助！

我们正在寻找专注于 IT 工作流和机器学习的内容作家、爱好者和研究人员，以帮助建立我们的社区。给 发电子邮件，附上写作范例和教学想法

原文：https://blog.paperspace.com/how-to-set-up-stylegan2-ada-pytorch-on-paperspace/

阅读本文后，您将能够设置、训练、测试和使用 PyTorch 的最新 StyleGAN2 实现。

这篇文章的结构如下。如果您只想开始运行 StyleGAN2-ADA，请直接跳到第 4 部分。

1. StyleGAN2 是什么？
2. 训练 StyleGAN2 有什么要求？
3. 最新的 StyleGAN2 (ADA-PyTorch)与以前的实现
4. 在图纸空间
   1 上设置。创建新笔记本
   2。配置笔记本
   3。等待笔记本启动
   4。创建笔记本文件
   5。安装依赖包
   6。生成种子
   7。开始训练
   
   
   
   
   
   
   
5. 进一步阅读

NVIDIA 的 StyleGAN2 基于一个生成式对抗网络(GAN)。gan 是由 Ian Goodfellow 和他的同事在 2014 年设计并推出的。

在 vanilla GAN 中，一个神经网络(生成器)生成数据，另一个神经网络(鉴别器)试图将生成的数据与原始数据(训练数据)区分开来。

换句话说——一个网络试图愚弄另一个网络，而另一个网络试图发现自己是否被愚弄了。通过这种机制，GANs 能够产生最先进的结果。

有很多 GAN 应用，从数据增强到文本到图像的翻译。GANs 的优势之一是图像生成。在撰写本文时，StyleGAN2-ADA 是用于图像生成的最先进的 GAN 实现( FID 得分为 2.42 )。

训练用于图像生成的 GAN 需要大量的计算能力。

建议至少使用一个 16GB 的 NVIDIA V100(更多 RAM 和/或更多 GPU 更好)。

更差的 GPU 可能会导致相同的结果，但会花费很多时间，即使是低分辨率。根据经验，16GB 内存的 NVIDIA Tesla P100 比 V100 多花了将近 4 倍的时间！

NVIDIA Tesla V100 上的预期培训时间。
来源:https://github . com/NV labs/style gan 2-ada-py torch/blob/main/readme . MD

通常，为了达到收敛(模型的最佳状态)，需要 25000 个 kimg(其中 1 个 kimg = 1,000 个图像)显示给鉴别器。

在 5000 kimg 左右可以得到合理的结果。

请注意，在接下来的教程中，文件指定了相当长的基本配置！

如果计算能力有限，将您的模型训练到 5000 kimg 是一个很好的策略，评估它，调整它，然后再次训练它。一旦你对你的结果感到满意，你可以试着把它训练到 25000 kimg。

此外，要使用您自己的数据集训练模型，您将需要图像。

虽然官方论文指出，一个人只需要几千张图像就可以获得良好的结果，但你将从更多的图像中获得更多样、更准确的结果。

在本教程中，我们将使用 Met Faces 图像数据集。请注意通过 NVIDIA 已经有了 metfaces 的预训练模型，所以我们从 metfaces repo 进行训练只是为了提供一个演示！

我们将在本教程中使用的 StyleGAN2-ADA Pytorch 实现代码是该算法的最新实现。

第一个实现是在 2017 年推出的渐进式 GAN。2018 年，StyleGAN 作为新版本紧随其后。StyleGAN2 于 2019 年发布，StyleGAN2-ADA 于 2020 年发布。

StyleGAN2-ADA 最初是使用 TensorFlow 实现的。在 2021 年，这个版本被我们将在这里使用的版本所取代 PyTorch 实现。

你可以在这里找到所有版本的完整列表。PyTorch 版本相对于 TensorFlow 版本的一个最重要的优势就是训练速度快了 5%-30%。

操作 StyleGAN2 代码最简单的方法就是使用笔记本。因此，我们将使用纸张空间渐变笔记本环境。

如果您不熟悉，Paperspace 的渐变笔记本只是托管在 Paperspace CPU 和 GPU 实例上的 Jupyter 笔记本。

今天，我们将使用 Paperspace V100 实例，但也可以使用任何 GPU 实例，包括 Paperspace 的免费 GPU 实例——只是要注意，StyleGAN2 是非常计算密集型的，可能需要非常长的时间来训练较少的 GPU。

我们开始吧！

首先，你需要在 Gradient 中创建新的笔记本。

这里我们使用的是我们的团队工作空间，而不是我们的个人工作空间。我们将通过导航到选项卡并选择来创建一个笔记本。

Select the team you’d like to use, navigate to the Notebooks tab, and then create a new notebook

接下来，我们将为笔记本命名并选择 PyTorch 1.8 运行时，它将预装许多 PyTorch 助手。我们还将指定我们想要手动使用的 PyTorch 版本。

Give your notebook a name and select the PyTorch runtime

然后我们应该选择 V100 GPU 并配置一个至少 12 小时的自动关闭周期。如果你想从头开始训练你的网络，考虑至少 12-24 小时。

请注意，一旦达到自动关机时间间隔，无论您是否仍在笔记本中工作，它都会保存并停止您的笔记本。

Select the V100 instance and at least 12 hours for auto-shutdown interval

接下来我们将打开高级选项，这样我们就可以插入一个自定义的。这将告诉 Paperspace 将 GitHub repo 的所有内容提取到新笔记本中。

在这里，我们将输入:

梯度笔记本现在将自动下载整个回购到我们的新笔记本！

Add the StyleGAN2-ADA PyTorch GitHub repository to the custom workspace field

接下来，Paperspace 需要几分钟时间来复制 GitHub 存储库并启动 PyTorch 1.8 容器。耐心点！

It will take a few minutes to copy over the repository and build the notebook from the PyTorch container

现在容器正在运行，我们可以切换到实例选择器，查看 CPU 和 RAM 的使用情况。此信息也可以在底部状态栏上找到。

System metrics are available in the instance selector panel

接下来，我们将创建一个新的。ipynb 文件来执行我们的工作。确保创建一个以结尾的文件。

Select the button in the file manager in the sidebar and give your new file a name

在撰写本文时，存储库的最新提交使用以下依赖关系:

• 64 位 Python 3.7 和 PyTorch 1.7.1
• 包:点击请求 tqdm pyspng 忍者 imageio-ffmpeg==0.4.3

Paperspace 笔记本附带 Python 3.8 和 Anaconda。让我们确认这个事实:

First we check to see what version of Python is installed in our notebook

好极了。看起来我们在这个实例上有 Python 3.8.5，所以我们应该降级到 Python 3.7 以避免任何冲突。

这里我们包含了标签，以确保我们提前确认了安装选项。我们这样做是因为我们从笔记本而不是从终端运行这个命令。

We downgrade to Python 3.7

现在，我们再次检查以确保 Python 安装正确

这应该会返回一个 Python 3.7.x 版本。如果没有，请再次尝试上述命令或重新创建笔记本。

我们还可以检查我们的 GPU，看看我们的 GPU 设置是否成功。为此，请执行以下命令:

您的输出应该如下所示:

Check to make sure the notebook has GPU attached

你应该会看到 GPU 名称“Tesla V100-PCIE”。如果您看不到此 GPU(或您选择的 GPU)，请重新创建您的笔记本并确保您选择了 GPU。

接下来，我们将创建一个名为的文件，在一个地方管理我们的依赖关系。

再次使用“新建文件”按钮，并将文件命名为:

Create a new file in the root called “requirements.txt”

接下来，我们切换到刚刚创建的文件，并添加我们的依赖项:

确保使用 CMD + S 保存文件！

Save the .txt file with CMD + S

一旦我们保存了,我们运行命令:

这告诉笔记本安装依赖项列表。

Install dependencies from requirements.txt file

太好了！

为了检查一切是否正常，让我们使用预训练的 metfaces 模型并创建几个样本:

Generate seed images using the pre-trained metfaces model

在新创建的文件夹中，您可以找到您的样本！太棒了。

Sample image created via the pretrained metfaces model that comes with this repository.

要开始我们自己的训练，我们应该首先上传您的数据集。

如前所述，出于本教程的目的，我们将使用 Metfaces 数据集，但请记住已经有一个使用 metfaces 的预训练模型，因此在该数据集上的训练不一定会有成效。

为了方便起见，我们在这里上传了 metfaces 数据的 zip 文件，我们将使用这个端点将图像集上传到我们的笔记本中。

首先，我们从链接上传压缩数据集:

上传 zip 文件后，我们将使用三个变量:

然后，我们可以将我们的图像转换成正确的格式。

官方存储库提供了一个工具，因为宽度和高度应该是 x 值。如果你最初的图像不是方形的，这会导致奇怪的图像。

不同的图像尺寸有不同的解决方案(请阅读官方文档)。

现在，我们将创建宽度和高度为 64px 的图像:

对于更高的分辨率，这可能需要相当长的时间。

做完了，现在是时候从头开始训练我们的网络了！

当我们在 V100 上运行本教程时，需要几个 小时 才能达到 kimg = 1000。

所以请注意，这个模型可能需要一些时间来训练-特别是如果你使用的东西没有 V100 强大。

也就是说，我们现在可以通过运行以下命令从头开始训练网络:

在“log_folder”文件夹中，我们可以找到不同的文件。最有趣的是 fakesxxxxxx.png 档案。这个文件向我们展示了由我们新训练的模型创建的不同样本。

Images within log_folder get better and better each 200 kimg sample

随着你越来越多地训练模型，你会看到那些图像变得越来越好。

默认情况下，每 200 kimg 创建一个样本和检查点。这也意味着你不必担心失去你的进步。您可以随时使用标志继续训练(点击了解更多信息)。

为了充分利用您的模型，您应该阅读 StyleGAN 资源库的官方文档。他们非常详细地解释了不同的功能以及如何应用它们。

感谢您的阅读！

除了官方资料库，我强烈推荐你查看 YouTube 频道人工图像。他有很多很好的教程和讲解。

更技术性的理解，我推荐阅读官方研究论文。

原文：https://blog.paperspace.com/how-to-stream-on-youtube-twitch-with-obs/

开放广播软件(OBS)是最流行的视频录制和直播工具之一。它是免费和开源的，易于设置，并内置了对 Twitch 和 YouTube 等最常见的直播平台的支持。在本指南中，我们将从头到尾介绍如何使用 OBS Studio 开始直播。

Open Broadcaster 软件(即 OBS)是最流行的视频录制和直播工具之一。OBS 是免费和开源的，易于设置，并内置了对 Twitch 和 YouTube 等最常见的直播平台的支持。在本指南中，我们将从头到尾介绍如何使用 OBS Studio 开始流媒体播放。

想要更多曝光？

如果你想让你的信息流被 Paperspace 收录，请给我们发邮件到 ，或者发推特给我们，附上#PoweredByPaperspace 的标签

• 推出一款机子
  • 高性能:游戏流媒体
  1. 基本:音频和简单应用流
• 安装 OBS
  • 下载安装 OBS
  1. 下载并安装 Visual Studio 2013 运行时
• 配置 OBS
  • 比特率
  • 编码
  • 设置您的场景
  1. 解决
• 连接到 Twitch
  • 配置 OBS 连接到 Twitch
  1. 找到您的流密钥
• 连接 YouTube
  • 配置 OBS 连接 YouTube
  1. 找到您的流密钥
• 结论

---

1。创造一种新的纸张空间机器

登录到 Paperspace 后，创建一台新机器。

• 选择最近的区域
• 选择一个 Windows 模板
• 选择每月或每小时取决于你的流媒体播放频率
• 选择你的计划:
  • 音频和非图形密集型应用(基本)😗*如果您正在传输非密集型应用，如代码编辑器、在线扑克游戏或音频混音等。，这些标准 GPU 机器( Air 、标准、高级和 Pro )工作起来棒极了。在这种情况下，您将在 OBS 中使用软件编码。您无法在这一层上运行任何高端游戏，也无法获得与 GPU 编码一样高的比特率。如果这听起来像你想要的设置，那么高级计划是最受欢迎的。
  • 游戏流(高性能)😗*如果您正在运行图形密集型游戏，如《巫师》、《守望先锋》等。，并希望向您的观众交付高比特率流，需要一台专用 GPU 机器( GPU+ 、 P5000 和 P6000 )。 GPU+ 是中端游戏的理想选择，而 P5000 和 P6000 旨在实现最高性能。
• 选择您的存储空间 —您可以在未来随时增加存储空间
• 点击创建

2。安装 OBS

步骤 1 -先决条件

请下载并运行所需的 Vistual Studio 运行时的两个，以便继续设置:

Visual Studio 2013 运行时[64 位] - vcredist_x64.exe

Visual Studio 2013 运行时[32 位] - vcredist_x86.exe

注意:即使您有 64 位版本的 Windows，也应该安装 32 位和 64 位版本。

现在您已经准备好安装 OBS Studio 了:

步骤 2 -安装 OBS Studio

下载链接

使用默认设置运行安装程序。在最后一步，取消选中“运行 OBS studio”

为什么？默认情况下，OBS 以 32 位模式启动，没有 64 位选项快。单击开始菜单并启动 64 位版本:

当 OBS 启动时，您可以忽略自动配置向导，因为我们将手动配置 OBS。如果您想在以后启动该向导，可以在工具下拉列表中找到它:

3。配置 OBS

要启动一个基本流，您只需要在 OBS 中配置一些东西。对于 OBS 中更高级的定制，查看他们的指南或其他在线教程。

我们将从选择流的分辨率开始。单击右下方的设置图标:

在视频选项卡上，选择所需的基本分辨率和输出分辨率:

接下来，我们将跳转到输出选项卡，选择视频比特率和编码器。

默认比特率 2，500 足以满足大多数情况，但可以根据您的喜好增加/减少。

编码器取决于运行的机器的类型。

• 如果您使用的是标准 GPU 机器( Air 、标准、高级和 Pro )，您需要选择 软件(x264) 选项，该选项将使用 CPU 对流进行编码(较慢)。
• 如果您使用的是专用 GPU 机器( GPU+ 、 P5000 和 P6000 )，您应该选择 硬件(NVENC) 选项，该选项将使用 GPU 来编码流(更快)。

关闭设置菜单，我们将创建一个信号源。这基本上是我们将要捕获的屏幕的一部分。单击“+”号开始:

对于各种类型的流，这里有几个选项:

• 显示捕获将捕获整个显示，但不是全屏游戏
• 游戏捕捉用于全屏捕捉游戏
• 窗口捕获用于捕获您正在运行的特定窗口(应用程序)

其他模式不太常见。更多信息请参考 OBS 工作室的文档。在这个演示中，我们将使用显示捕捉模式。单击“确定”添加源:

再次单击“确定”接受属性:

通过抓取红色轮廓并将其拉进以适应黑盒(场景)来完成流的合成:

就是这样！您现在可以开始流式播放了。

4。连着抽动

首先导航到抽动设置页面。在这里，您将看到一个显示您的密钥的选项，我们会将该密钥插入 OBS:

请注意: 确保不要与任何人共享您的流密钥，否则他们将能够流至您的 Twitch 频道。

复制密钥并导航回 OBS 中的流选项卡。在服务下，选择抽动。然后选择最近的服务器(在本例中，美国东部:纽约，NY ，然后将您的流密钥粘贴到流密钥字段:

你都准备好了！只需点击“开始播放”即可开始播放:

5。连接到 YouTube

首先导航到 YouTube 直播仪表盘。在页面底部的编码器设置部分，你会找到你的流键。

请注意: 确保不要与任何人共享您的流密钥，否则他们将能够传输到您的 YouTube 频道。

复制密钥并导航回 OBS 中的流选项卡。在服务下，选择 YouTube / YouTube 游戏。在服务器下，选择主 YouTube 摄取服务器，然后将您的流密钥粘贴到流密钥字段:

你都准备好了！只需点击“开始播放”即可开始播放:

6。结论

在短短几分钟内，我们就能够使用 OBS Studio 和 Twitch/YouTube 启动并运行实时流。如您所见，OBS 消除了屏幕捕获组件的麻烦。尽管 OBS 使用起来非常简单，但它仍然具有值得探索的高级功能。尽情享受吧！

要开始自己的直播，请在此注册。

原文：https://blog.paperspace.com/how-to-train-question-answering-machine-learning-models/

问答模型是机器或深度学习模型，可以在给定一些上下文的情况下回答问题，有时没有任何上下文(例如开放域 QA)。他们可以从段落中提取答案短语，概括地解释答案，或者从给定选项列表中选择一个选项，等等。这完全取决于它被训练的数据集(例如小队、 CoQA 等)。)或者它被训练的问题，或者在某种程度上神经网络架构。因此，举例来说，如果你将这一段(上下文)输入到你的模型中，该模型被训练来从上下文中提取答案短语，并问一个类似“什么是问答模型？”，它应该输出这一段的第一行。

这种模型需要理解语言的结构，对上下文和问题有语义理解，有能力定位回答短语的位置，等等。所以毫无疑问，训练执行这些任务的模型是很困难的。幸运的是，神经网络中的注意力概念已经成为这种困难任务的救命稻草。自从为序列建模任务引入以来，出现了许多具有复杂注意机制的 RNN 网络，如 R-NET 、 FusionNet 等。在 QA 任务中表现出很大的改进。然而，一种基于注意力，特别是自我注意力的全新神经网络架构，称为 Transformer ，已经成为 NLP 中真正的游戏规则改变者。在这里，我将讨论一个名为 BERT 的 Transformer 架构的变体，简要概述其架构，如何执行问答任务，然后编写代码来训练这样一个模型，以回答研究论文中与新冠肺炎相关的问题。

你可以从 ML Showcase 跟随代码，并在渐变社区笔记本中免费运行它。让我们开始吧。

在跳到 BERT 之前，让我们了解一下什么是语言模型，变形金刚是如何进入画面的。

语言模型是一种概率模型，它基于在训练期间看到的文本示例来学习句子或标记序列出现的概率。例如:

P( 没有杀死我们的使我们更强大)= P(That)P(which | That)P(does | That，which )P( not|That，which，does …

P( 没有杀死我们的东西让我们更强大 ) = 0.65

如果这些语言模型足够大，并在足够大的数据集上进行训练，它们可以很好地理解任何语言及其复杂性。传统上，由于语言的顺序结构，rnn 被用于训练这种模型，但是它们训练缓慢(由于每个标记的顺序处理)，并且有时难以收敛(由于消失/爆炸梯度)。

然而，变形金刚的不同变体，凭借其并行处理令牌的能力以及由于自我注意机制和不同的预训练目标而产生的令人印象深刻的性能，已经使得训练大型模型(有时非常非常大型的模型)成为可能，这些模型理解自然语言非常好。不同的基于 Transformer 的语言模型，在架构和预训练目标上有微小的变化，在不同类型的任务上表现不同。 BERT (来自变压器的双向编码器表示)就是这样一个模型。BERT 已经使用 Transformer 编码器架构进行了训练，具有掩蔽语言建模(MLM)和下一句预测(NSP)预训练目标。

BERT Architecture (source)

现在我们已经知道了 BERT 是什么，让我们简单了解一下它的体系结构和培训前目标。BERT 使用来自原始变压器纸的变压器编码器。一个编码器有一堆编码器模块(其中一个模块的输出作为下一个模块的输入)，每个编码器模块由两个神经网络层组成。首先是自我关注层(这是使变形金刚如此强大的神奇操作),然后是简单的前馈层。每一层之后都有一个残差连接和一个图层归一化操作，如下图所示。

One Encoder Block (source). Here X1, X2 are input vectors. One vector for each token.

因此，对于每个编码器层，输入向量和输出向量的数量(最大限制为 512)总是相同的。并且在第一编码器层之前，通过添加记号嵌入、位置嵌入和片段嵌入来获得每个记号的输入向量。使用矩阵乘法在每个编码器层内并行处理这些向量，并将获得的输出向量馈送到下一个编码器块。通过 N 这样的块顺序处理后，得到的输出向量开始很好的理解自然语言。

这是对 BERT 架构的一个非常压缩的概述，只关注我们理解博客其余部分所需的想法。关于各层如何发生不同操作、多头自我关注以及理解并行令牌处理的更详细讨论，请查看 Jay Alammar 的博客。

培训前目标

预训练目标是一项任务，在为最终任务进行微调之前，对模型进行训练。GPT 模型在生成性预训练任务(因此命名为 GPT)上被训练，即在被微调到例如 SST-2(句子分类数据)上以分类句子之前，在给定先前记号的情况下生成下一个记号。

同样，BERT 将 MLM 和 NSP 作为其预培训目标。它使用一些特殊的令牌，如 CLS、SEP 和 MASK 来完成这些目标。在我们完成培训前目标时，我们将看到这些令牌的使用。但是在继续之前，我们应该知道，馈送到 BERT 的每个标记化样本在开始时附加有 CLS 标记，并且来自 BERT 的 CLS 的输出向量用于不同的分类任务。现在让我们从 MLM 开始。

在 MLM 目标中，一定百分比的标记被屏蔽，即被特殊的标记屏蔽代替，并且模型被要求预测正确的标记来代替屏蔽。为了实现这一点，在最终编码器块上增加了屏蔽语言模型头，它只为屏蔽标记的输出向量(从最终编码器块输出)计算词汇上的概率分布。在《NSP》中，两个被标记化的句子和附加在它们末尾的 SEP 标记被连接起来，并被送给 BERT。然后，使用 CLS 令牌的输出向量来计算句子对中的第二个句子是否是原始文档中的后续句子的概率。对于这两个目标，使用 AdamW 优化器的标准交叉熵损失来训练权重。

与其他预训练目标(例如，生成性预训练目标)相比，上述预训练目标在捕捉自然语言的语义方面非常强大。因此，许多具有类似或稍微调整的预训练目标的模型，具有或多或少与 BERT 相同的架构，已经被训练以在许多 NLP 任务上实现 SOTA 结果。罗伯塔、斯潘伯特、迪翁伯特、艾伯特等。是其中的几个。

在对这些预训练目标进行训练后，这些模型在特殊任务上进行微调，如问题回答、命名实体识别等。在这里，我们将看到如何训练伯特回答问题的目标。

数据集

如前所述，QA 任务可以用不同的方式构建。在这里，我将重点关注基于上下文的问题回答，即从给定的段落中提出问题。SQuAD 是这项任务的一个流行数据集，它包含许多文本段落、与段落相关的不同问题、它们的答案以及段落中答案的起始索引。SQuAD 有两个版本，SQuAD1.1 和 SQuAD2.0，主要区别在于 SQuAD2.0 包含超过 50，000 个无法回答的问题，这些问题看起来与可回答的问题相似。因此，要在 SQuAD2.0 上做得好，系统不仅必须尽可能地回答问题，还必须确定段落何时不支持任何答案，并放弃回答。这两个数据集都是公开的，可以从这里下载。在这里，我将使用 SQuAD2.0。

伯特班建筑

为了执行问答任务，我们在 BERT 上添加了一个新的问题回答头，就像我们添加了一个掩蔽语言模型头来执行 MLM 任务一样。该问答头的目的是找到给定段落的答案的开始标记和结束标记，例如:

BERT-large 真的很大…它有 24 层，嵌入大小为 1024，总共有 340M 个参数！总共有 1.34GB，所以预计下载需要几分钟。
问题:BERT-large 有几个参数？
回答 : 340M 参数
开始令牌 : 340
结束令牌:参数

介于两者之间的所有内容，包括开始和结束标记，都被视为答案。

在问答头部中有两组权重，一组用于开始标记，另一组用于结束标记，它们与输出嵌入具有相同的维数。所有标记的输出嵌入被馈送到这个头部，并且分别计算它们与开始和结束标记的权重集之间的点积。换句话说，取开始标记权重和输出嵌入之间的点积，也取结束标记权重和输出嵌入之间的点积。然后，应用 softmax 激活，以在开始和结束记号集(每个集合也是单独的)的所有记号上产生概率分布。具有最大概率的记号被分别选为开始和结束记号。在此过程中，可能会出现结束标记出现在开始标记之前的情况。在这种情况下，输出一个空字符串作为预测答案。下面的数字应该使操作更加清晰。

Question Answering Head Separately for Start and End Token (source)

在流行的实现中，这个头被实现为前馈层，它接受与 BERT 输出嵌入相同维度的输入，并返回一个二维向量，该向量然后被馈送到 softmax 层。使用开始和结束令牌的交叉熵损失来微调完整的 BERT 小队模型。

我们将使用拥抱脸的变形金刚库来训练我们的 QA 模型。我们还将使用 BioBERT，这是一种基于 BERT 的语言模型，唯一的区别是它已经根据 MLM 和 NSP 的目标对一般&生物医学领域语料库的不同组合进行了微调。不同的领域有特定的术语，这些术语在标准英语中很少出现，如果它们出现，可能意味着不同的事情，或者意味着不同的上下文。因此，像 BioBERT，LegalBERT 等模型。已经被训练来学习特定领域文本的这种细微差别，使得特定领域的 NLP 任务可以更准确地执行。

在这里，我们旨在使用质量保证模型从新冠肺炎研究文献中提取相关信息。因此，我们将使用拥抱脸的变形金刚库对 SQuADv2 数据进行微调。

在变形金刚库的示例部分，Hugging Face 已经提供了一个脚本，用于在小队数据上训练 QA 模型。使用下面的命令可以很容易地运行这个脚本。

您也可以从 ML Showcase 的渐变社区笔记本中免费运行代码。

人们可以从它们的名字中理解大多数参数。关于参数的更多细节和可以调整的参数的详尽列表，可以参考 脚本。

使用这个脚本，可以很容易地对模型进行微调，以执行 QA 任务。然而，运行这个脚本占用大量内存，因为试图一次处理完整的队伍数据，需要超过 12GB 的内存。所以，我修改了，增加了一个名为的新功能，可以批量处理阵容数据。你可以看看下面的这些方法。

:

:

基本上，添加的修改在小批量数据上运行相同的方法,并将创建的特征保存在一个文件夹中。可以通过在的第 660 行添加下面一行，并在我上面提到的命令中提供一个参数，来定义迷你批处理的大小。

修改后的可以从这里下载。

使用 脚本中提到的默认超参数，我们训练的模型能够在 4 个时期后在 SQuADv2 数据上获得 70 的 F1 分数和 67.8 的精确匹配。现在，让我们看看这个经过训练的模型在来自新冠肺炎开放研究数据集挑战(CORD-19) 的一些研究文章上的表现。以下是从研究文章中获得的一些示例文本、对示例文本提出的问题以及预测的答案。

背景: 结论:本研究首先展示了重庆市新冠肺炎的地区差异，并进一步深入比较了重症患者与非重症患者的差异。重庆市 3 所定点医院新冠肺炎患者的 28 天死亡率为 1。5 %，低于湖北省和包括湖北省在内的 mainland China。然而，重症患者的 28 -死亡率相对较高，当出现并发症时死亡率更高。值得注意的是，并发严重 ARDS 的危重患者的死亡率高达 44%。4 %.因此，对重症新冠肺炎病例，尤其是合并急性呼吸窘迫综合征的病例，早期诊断和加强监护对降低死亡率至关重要。
问题*:*ARDS 的死亡率是多少？
预测答案 : 44.4 %

背景: 这是 2020 年 1 月 31 日至 2 月 6 日武汉市 COVID - 2019 定点医院武汉大学人民医院收治的 3 例 2019 - nCoV 感染患者的回顾性研究。所有患者均根据中国国家卫生委员会发布的《新型冠状病毒肺炎的诊断和治疗》(第 6 版)进行诊断和分类。我们详细记录了流行病学史、人口统计学特征、临床特征、症状和体征、治疗和临床结果。此外，我们发现益生菌的比例明显减少，如双歧杆菌、乳酸杆菌和真细菌，条件致病菌的比例明显增加，如放线菌的棒状杆菌和厚壁菌门的黑鲁氏菌。值得注意的是，所有患者都死亡了。
问题 : 病毒感染引起的 ARDS 死亡率是多少？
预测答案: 患者全部死亡。

背景: 同时，新冠肺炎感染者中有一定数量的患者存在慢性共病，主要为高血压、糖尿病和心血管疾病，与 MERS - COV 人群相似。这些结果表明，患有慢性基础疾病的老年男性可能更容易感染新冠肺炎或 COV 中东呼吸综合征…CC - BY - NC - ND 4。在实验室检测方面，新冠肺炎和 MERS - COV 患者的淋巴细胞减少，CRP 增加。这一结果表明，新冠肺炎可能与细胞免疫反应有关，主要作用于淋巴细胞，就像 MERS - COV 那样。被病毒感染的细胞在体内诱导大量促炎细胞因子的释放和炎症风暴。此外，细胞因子增加可能会对相关器官造成损害，如肝脏。我们的研究结果表明，在 MERS - COV 人群中发现了 AST 异常值，而在新冠肺炎人群中没有发现。可能的原因是新冠肺炎人群的随访时间太短，而肝脏。
问题: 什么样的细胞因子在宿主反应中起主要作用？
预测答案: 促炎

在本文中，我们简要介绍了 BERT 的架构，了解了 BERT 在问答任务中的表现，使用(这减少了 RAM 的使用)在 SQuADv2 数据上训练了一个版本的 BERT 模型(Bio-BERT)，并了解了训练后的模型在 COVID 相关研究文章的文本上的性能。这种模型的性能在很大程度上取决于提供给模型的上下文和相关问题。在这里，上下文是从文章中手动提取出来并输入到模型中的。在后面的文章中，我们将看到一种基于深度学习的方法，在给定特定问题的情况下，从研究文章中找到最合适的段落。

到此这篇读取pcap文件中的csi（python读取pcap文件）的文章就介绍到这了,更多相关内容请继续浏览下面的相关推荐文章，希望大家都能在编程的领域有一番成就！

版权声明：

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

转载请注明出处，原文链接：https://www.xkablog.com/pythonbc/14439.html