DLology-博客中文翻译-一-

DLology 博客中文翻译（一）

原文：DLology Blog

协议：CC BY-NC-SA 4.0

从你的浏览器加速深度学习推理

原文：https://www.dlology.com/blog/accelerated-deep-learning-inference-from-your-browser/

发帖人:程维两年零六个月前

(评论)

数据科学家和 ML 工程师现在可以从他们的浏览器中使用 FPGA 加速器的能力来加速他们的深度学习应用程序。

FPGAs 是适应性强的硬件平台，可以为机器学习、视频处理、定量金融等应用提供出色的性能、低延迟和更低的运营支出。然而，对于没有 FPGA 相关知识的用户来说，轻松高效的部署是一个挑战。

应用加速领域的先驱 InAccel 让您可以从浏览器中获得 FPGA 加速的强大功能。数据科学家和 ML 工程师现在可以轻松部署和管理 FPGAs，加速计算密集型工作负载，并通过零代码更改降低总拥有成本。

InAccel 提供了一个 FPGA 资源管理器，允许对 FPGA 进行即时部署、扩展和资源管理，使 FPGA 在机器学习、数据处理、数据分析等应用中的应用比以往任何时候都更容易。用户可以从 Python、Spark、Jupyter 笔记本甚至终端部署他们的应用。

通过 JupyterHub 集成，用户现在可以享受 JupyterHub 提供的所有好处，例如轻松访问计算环境以即时执行 Jupyter 笔记本。同时，用户现在可以享受 FPGA 的优势，例如更低的延迟、更短的执行时间和更高的性能，而无需事先了解 FPGA。InAccel 的框架允许使用 Xilinx 的 Vitis 开源优化库或第三方^(IP 核(用于深度学习、机器学习、数据分析、基因组学、压缩、加密和计算机视觉应用。))

InAccel 的 FPGA orchestrator 提供的加速机器学习平台既可以在内部使用，也可以在云上使用。这样，用户可以享受 Jupyter 笔记本的简单性，同时体验应用程序的显著加速。

用户可以通过以下链接免费测试 InAccel 集群上的可用库:

https://inaccel.com/accelerated-data-science/

加速推理 ResNet50 上的一个用例

任何用户现在都可以从浏览器中享受 FPGA 加速器的加速。在 DL 示例中，我们展示了用户如何从相同的 Keras python 笔记本中享受更快的 ResNet50 推理，而没有任何代码更改。

用户可以在https://labs.inaccel.com:8000使用谷歌账户登录 InAccel 门户网站

他们可以在 Resnet50 上找到现成的 Keras 示例。

用户可以看到 python 代码与在任何 CPU/处理器上运行的代码完全一样。然而，在本例中，用户可以在 ResNet50 上体验高达 2，000 FPS 的推断，而没有任何代码更改。

用户可以使用可用的数据集(22，000 幅图像)测试加速的 Keras ResNet50 推理示例，也可以下载自己的数据集。

他们还可以使用如下所示的验证码来确认结果是否正确。

注意:该平台可用于演示目的。多个用户可以使用 2 个 Alveo 卡访问可用集群，这可能会影响平台的性能。如果您有兴趣使用多个 FPGA 卡部署自己的数据中心，或者专门在云上运行您的应用程序，请致电 【电子邮件保护】 联系我们。

图一。使用 Jupyter 从浏览器加速 ML、vision、finance 和数据分析

你也可以在这里查看网络视频:【https://www.youtube.com/watch?v=42bsjdXVmFg】T2

关于 InAccel 公司

InAccel 通过使用自适应硬件加速器，帮助企业加快应用速度。它为无缝利用 Spark 和 Jupyter 等高级框架中的硬件加速器提供了一个独特的框架。InAccel 还为机器学习、压缩和数据分析等应用开发高性能加速器。欲了解更多信息，请访问https://inaccel.com

可用代码:

Share on Twitter Share on Facebook

• ←如何在 Jetson Nano 上以 20+ FPS 运行 SSD Mobilenet V2 物体检测

使用 Keras 模型构建新张量流数据集和估计量的简单指南

原文：https://www.dlology.com/blog/an-easy-guide-to-build-new-tensorflow-datasets-and-estimator-with-keras-model/

发布者:程维五年零一个月前

(评论)

更新:

• 2019 年 5 月 29 日:源代码更新运行在 TensorFlow 1.13 上。

TensorFlow r1.4 于不久前 10 月下旬发布。

如果你还没有更新，

pip3 install --upgrade tensorflow-gpu

一些变化值得注意，

• Keras 现在是核心 TensorFlow 包的一部分
• 数据集 API 成为核心包的一部分
• 对估算器的一些增强允许我们将 Keras 模型转换为 TensorFlow 估算器，并利用其数据集 API。

在这篇文章中，我将向您展示如何将 Keras 图像分类模型转换为 TensorFlow estimator，并使用数据集 API 训练它来创建输入管道。

如果你没有读过 TensorFlow 团队的介绍 TensorFlow 数据集和估值器的帖子。现在就阅读它，了解我们为什么在这里工作。

看到你刚好在一个你不能访问任何谷歌网站的地区，这很糟糕，所以我在这里为你总结了一下。

TensorFlow 数据集 API 和估算器概述

数据集 API

您应该使用 Dataset API 为 TensorFlow 模型创建输入管道。这是最佳实践方式，因为:

• 数据集 API 提供了比旧 API(feed_dict或基于队列的管道)更多的功能。
• 性能更好。
• 它更干净，更容易使用。
• 它的图像模型管道可以从分布式文件系统中的文件聚集数据，对每个图像应用随机扰动，并将随机选择的图像合并成一批用于训练。
• 我还有用于文本模型的管道

估计量

Estimators 是一个高级 API，它减少了您以前在训练 TensorFlow 模型时需要编写的大量样板代码。

创建估算器的两种可能方式:预先制作估算器以生成特定类型的模型，另一种是使用其基类创建自己的估算器。

Keras 与其他核心 TensorFlow 功能顺利集成，包括估算器 API

好了，介绍够了，让我们开始构建我们的 Keras 估计器吧。

认真对待代码

为了简单起见，让我们为著名的狗与猫图像分类建立一个分类器。

作为 2013 年末计算机视觉竞赛的一部分，Kaggle.com 提供了猫和狗的数据集。您可以在 https://www.kaggle.com/c/dogs-vs-cats/download/train.zip的 下载原始数据集

我们只使用了一小部分训练数据。

下载并解压缩后，我们将创建一个包含三个子集的新数据集:一个包含每个类 1000 个样本的训练集，一个包含每个类 500 个样本的测试集。这里省略了这部分代码，看看我的 GitHub 就知道了。

Build Keras model

我们正在利用预训练的 VGG16 模型的卷积层。又名模型的“卷积基础”。然后我们添加自己的分类器全连接层来做二元分类(猫 vs 狗)。

注意，由于我们不想触及“卷积基”中预训练的参数，所以我们将它们设置为不可训练。想深入了解这种模式的工作原理吗？看看这个伟大的 jupyter 笔记本 作者 Keras。

张量流估计的 Keras 模型

model_dir 将是我们存储经过训练的 tensorflow 模型的位置。训练进度可以通过 TensorBoard 查看。
我发现我必须指定完整的路径，否则，否则 Tensorflow 会在以后的训练中抱怨它。

图像输入功能

当我们训练我们的模型时，我们需要一个读取输入图像文件/标签并返回图像数据和标签的函数。评估人员要求您创建以下格式的函数:

返回值必须是由两个元素组成的元组，如下所示:

-第一个元素必须是一个字典，其中每个输入特征都是一个键。这里我们只有一个“ input_1 ”，它是模型的输入层名称，该模型将处理后的图像数据作为训练批次的输入。
-第二个元素是训练批次的标签列表。

这里有个重要的代码，它为我们的模型创建了输入函数。

此函数的参数

• 文件名，图像文件名的数组
• labels=None ，模型的图像标签数组。为推断设置为“无”
• perform_shuffle=False ，在训练时有用，读取 batch_size 记录，然后打乱(随机化)它们的顺序。
• repeat_count=1 ，在训练时有用，在每个历元重复输入数据几次
• batch_size=1 ，一次读取 batch_size 条记录

作为健全性检查，让我们试运行 imgs_input_fn()并查看它的输出。

它输出我们图像的形状和图像本身

(20, 150, 150, 3)

对于我们的模型，看起来颜色通道“RGB”已经变成了“BGR ”,形状大小调整为(150，150)。这就是 VGG16 的“卷积库”所期望的正确的输入格式。

训练和评估

tensor flow 1.4 版本还引入了实用程序函数 tf.estimator.train_and_evaluate ，该函数简化了训练、评估和导出估计器模型。

此功能支持培训和评估的分布式执行，同时仍支持本地执行。

模型训练结果将被保存到。/models/ catvsdog 目录。有兴趣可以看看 TensorBoard 里的总结

tensorboard --logdir=./models/catvsdog

预测

这里我们只预测 test_files 中的前 10 个图像。

为了进行预测，我们可以将标签设置为无，因为这就是我们将要预测的。 dense_2 是我们模型的输出层名称，prediction['dense_2'][0]将是一个介于 0~1 之间的浮点数，其中 0 表示猫的图像，1 表示狗的图像。

检查预测结果

它输出

Predict dog: [False, False, True, False, True, True, False, False, False, False]
Actual dog : [False, False, True, False, True, True, False, False, False, False]

该模型正确地对所有 10 幅图像进行了分类。

摘要

我们构建一个 Keras 图像分类器，将其转换为张量流估计器，为数据集管道构建输入函数。最后，对模型进行训练和评估。请继续查看我的 GitHub repo 中这篇文章的完整源代码。

进一步阅读

tensor flow 数据集和估算器简介-谷歌开发者博客

宣布 tensor flow r 1.4-谷歌开发者博客

TensorFlow r1.40 发行说明

数据集 API 指南

估算师 API 指南

Share on Twitter Share on Facebook

• ←如何对新闻类别进行多类多标签分类
• 如何利用 TensorFlow 的 TFRecord 训练 Keras 模型→

利用端到端深度学习的自动缺陷检查

原文：https://www.dlology.com/blog/automatic-defect-inspection-with-end-to-end-deep-learning/

发帖人:程维三年零两个月前

(评论)

在本教程中，我将向您展示如何建立一个深度学习模型来查找表面上的缺陷，这是许多工业检测场景中的一个流行应用。

由英伟达提供

建立模型

我们将使用 U-Net 作为 2D 工业缺陷检查的 DL 模型。当缺少标记数据，并且需要快速性能时，U-net 是一个很好的选择。基本架构是一个带跳跃连接的编码器-解码器对，用于将低级特征映射与高级特征映射相结合。为了验证我们模型的有效性，我们将使用 DAGM 数据集。使用 U-Net 的好处是它不包含任何密集层，因此训练的 DL 模型通常是缩放不变的，这意味着它们不需要跨图像大小重新训练，就可以对多种输入大小有效。

这是模型结构。

如您所见，我们使用了四次 2x2 max 池操作进行下采样，从而将分辨率降低了一半，降低了四倍。在右侧，2 x2 conv 2d 转置(称为去卷积)将图像升采样回其原始分辨率。为了使下采样和上采样工作，图像分辨率必须能被 16 整除(或 2⁴)，这就是为什么我们将输入图像和蒙版的大小从原来的 500x500 大小的 DAGM 数据集调整为 512x512 分辨率。

来自网络中较早层的这些跳跃连接(在下采样操作之前)应该提供必要的细节，以便为分割边界重建精确的形状。事实上，通过添加这些跳跃连接，我们可以恢复更精细的细节。

在 Keras functional API 中构建这样的模型很简单。

损失和指标

图像分割任务最常用的损失函数是逐像素交叉熵损失。这种损失单独检查每个像素，将类别预测(深度方向像素向量)与我们的独热编码目标向量进行比较。

因为交叉熵损失单独评估每个像素向量的分类预测，然后对所有像素进行平均，所以我们基本上主张对图像中的每个像素进行平等学习。如果您的各种类在图像中具有不平衡的表示，这可能是一个问题，因为训练可能由最普遍的类主导。在我们的例子中，这是前景到背景的不平衡。

用于图像分割任务的另一个流行的损失函数是基于骰子系数，其本质上是两个样本之间重叠的度量。该度量的范围从 0 到 1，其中 Dice 系数为 1 表示完全重叠。Dice 系数最初是针对二进制数据开发的，可以计算如下:

其中|A∩B|表示集合 A 和 B 之间的公共元素，而|A|表示集合 A 中元素的数量(对于集合 B 也是如此)。

关于神经网络输出，分子与我们的预测和目标掩模之间的共同激活有关，而分母与每个掩模中单独激活的数量有关。这具有根据目标遮罩的大小来归一化我们的损失的效果，使得软骰子损失不会从图像中具有较小空间表示的类中学习。

这里我们使用加一或拉普拉斯平滑，它只是在每个计数上加一。加一平滑可以被解释为均匀的先验，这减少了过度拟合并使模型更容易收敛。

实现平滑的骰子系数损失。

这里我们比较了二进制交叉熵损失和平滑 Dice 系数损失的性能。

可以看出，利用 Dice 系数损耗训练的模型收敛速度更快，最终 IOU 精度更高。关于最终的测试预测结果，用 D ice 系数损失训练的模型提供了比用交叉熵损失训练的模型更清晰的分割边缘。

结论和进一步阅读

在这个快速教程中，您已经学习了如何建立一个深度学习模型，该模型可以进行端到端的训练，并检测工业应用的缺陷。本文中使用的 DAGM 数据集相对简单，便于快速原型制作和验证。然而，在现实世界中，图像数据可能包含更丰富的上下文，这需要更深入和更复杂的模型来理解，实现这一点的一个简单方法是通过试验增加 CNN 层的内核数量。虽然有其他选择，如本文，但作者建议用密集块替换每个 CNN 块，这样在学习复杂的上下文特征时更有能力。

你可以用免费的 GPU 在 Google Colab 上运行这个笔记本来重现这篇文章的结果。

在我的 GitHub 上有源代码。

• 标签:
• keras ,
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←如何使用自定义 COCO 数据集训练检测器 2
• 如何在 Jetson Nano 上以 20+ FPS 运行 SSD Mobilenet V2 物体检测→

Keras 中卷积神经网络用于图像分类的技巧包

原文：https://www.dlology.com/blog/bag-of-tricks-for-image-classification-with-convolutional-neural-networks-in-keras/

发帖人:程维四年前

(评论)

本教程向你展示了如何在 Keras API 中实现一些图像分类任务的技巧，如论文中所述。这些技巧适用于各种 CNN 模型，如 ResNet-50、Inception-V3 和 MobileNet。

大批量训练

对于相同数量的时期，与使用较小批量训练的模型相比，使用较大批量训练的模型会导致验证准确性下降。四种启发式方法有助于最大限度地减少大批量训练的负面影响，提高准确性和训练速度。

线性缩放学习率

随着批量大小线性增加学习率

例如

| 批量大小 | 学习率 |
| Two hundred and fifty-six | Zero point one |
| 256 * 2 = 512 | 0.1 * 2 = 0.2 |

在 Keras API 中，您可以像这样缩放学习速率和批量大小。

学习率预热

使用太大的学习率可能会导致数值不稳定，尤其是在训练的最开始，这里参数是随机初始化的。在最初的 N 个时期或 m 个批次期间，预热策略 i 将学习率从 0 线性增加到初始学习率。

尽管 Keras 附带了 LearningRateScheduler 能够更新每个训练时期的学习率，但为了更好地更新每个批次，这里有一个方法，你可以实现一个定制的 Keras 回调来完成这个任务。

warm_up_lr.learning_rates现在包含了每个训练批次的预定学习率的数组，让我们将它可视化。

零 γ 每个 ResNet 块的最后一批归一化层

批量归一化用γ缩放一批输入，用β移位，两个 γ 和 β 是可学习的参数，其元素在 Keras 中默认分别初始化为 1 和 0。

在零γ初始化试探法中，我们为位于残差块末端的所有 BN 层初始化γ = 0。因此，所有残差块仅返回它们的输入，模仿具有较少层数并且在初始阶段更容易训练的网络。

给定一个恒等 ResNet 块，当最后一个 BN 的 γ初始化为零时，这个块只将快捷输入传递给下游层。

你可以看到这个 ResNet 块是如何在 Keras 中实现的，唯一的变化是行， BatchNormalization 层的gamma_initializer='zeros'。

无偏衰变

标准的权重衰减 对所有参数应用 L2 正则化将它们的值推向 0。它包括对层权重应用惩罚。然后将惩罚应用于损失函数。

建议仅对权重应用正则化，以避免过拟合。其他参数，包括 BN 层中的偏压和γ和β，保持不变。

在 Keras 中，将 L2 正则化应用于核权重是毫不费力的。选项bias _ regulator也可用，但不推荐。

训练改进

余弦学习率衰减

在前面描述的学习率预热阶段之后，我们通常会从初始学习率开始稳步降低其值。与一些广泛使用的策略(包括指数衰减和阶跃衰减)相比，余弦衰减在开始时缓慢降低学习速率，然后
在中间变得几乎线性降低，并在结束时再次减慢。它潜在地提高了训练进度。

这是一个完整的带有预热阶段的余弦学习率调度程序的例子。在 Keras 中，调度程序在每个更新步骤的粒度上更新学习率。

您选择使用调度器中的保持 _ 基本 _ 速率 _ 步数参数，顾名思义，它在进行余弦衰减之前保持特定步数的基本学习速率。由此产生的学习率时间表将有一个平台，如下所示。

标签平滑

与原始的独热编码输入相比，标签平滑将真实概率的构造改变为，

其中ε 为小常数，K 为总类数。标签平滑鼓励全连接层的有限输出，以使模型更好地泛化，不容易过度拟合。对于标签噪声，这也是一种高效的和理论上接地的解决方案。你可以在这里阅读更多关于讨论的内容。 以下是在训练分类器之前，如何对单热点标签应用标签平滑。

结果

结论和进一步阅读

在这篇文章中，还有两个培训优化没有涉及到，即，

• 知识提炼利用预先训练的较大模型的输出来训练较小的模型。
• Mixup 训练，某种意义上类似于增强，它通过对两个样本进行加权线性插值，形成新的样本，从而创造更多的数据。看看在另一个帖子中实现这个。

阅读报纸https://arxiv.org/abs/1812.01187v2了解每一个技巧的详细信息。

源代码可在 my GitHub 上获得。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←不平衡数据集的聚焦损失多类分类
• 如何从 Keras 中的图像文件进行混音训练→

博客

原文：https://www.dlology.com/blog/

文章

从你的浏览器加速深度学习推理

发帖人:程维在深度学习、边缘计算 2 年 6 个月前

如何在 Jetson Nano 上以 20+ FPS 运行 SSD Mobilenet V2 物体检测

发帖人:程维在深度学习、边缘计算、 tensorflow 3 年前

采用端到端深度学习的自动缺陷检查

发帖人:程维在深度学习， Keras ， python ， tensorflow 3 年 2 个月前

如何使用自定义 COCO 数据集训练检测器 2

发帖人:程维在深度学习， python ， PyTorch 3 年 2 个月前

VS 代码远程开发入门

发帖人:程维三年三个月前

• 第 1 页，共 17 页

• 1

• 2

• 3

• 4

• 5

• 6

• 7

• 8

• 9

• 10

• →

用神经计算棒制作一个 DIY 安全摄像机(第 1 部分)

原文：https://www.dlology.com/blog/build-a-diy-security-camera-with-neural-compute-stick-part-1/

发帖人:程维四年零五个月前

(评论)

1933 年，一个养鸡人兼业余摄影师决定找到偷他鸡蛋的罪犯。自问世以来，如今安全摄像头无处不在，大多数所谓的“智能摄像头”都是通过将视频流回显示器或服务器来工作的，以便有人或一些软件可以分析视频帧，并有望从中找到一些有用的信息。它们消耗大量的网络带宽和电力来传输视频，尽管我们只需要 10 帧图像就可以知道谁在偷鸡蛋。当网络不稳定，图像无法分析，“智能”变成“哑”时，他们还面临着服务中断的困境。

边缘计算是一种网络模型，支持在摄像头所在的网络边缘进行数据处理，无需将视频发送到中央服务器进行处理。在边缘处理图像数据减少了系统等待时间、视频传输所消耗的功率和带宽成本，并且由于将传输较少的可能被黑客攻击的信息而提高了私密性。简单的概念，但为什么它还没有流行起来？简单的回答，硬件和软件还没有准备好。众所周知，图像处理一直渴望处理能力和高级算法，以便从中提取有用的信息。随着深度学习算法的最新进展，以及价格友好的推理硬件的出现，为相机上更高级的边缘计算打开了大门。

自己做这么酷的相机怎么样？本教程的最终目标是向您展示如何构建这样一个安全摄像机，它使用高级对象检测算法在本地处理镜头，并实时从数小时的视频帧中过滤出重要图像。要进行构建，您需要以下基本工具和硬件。

1. 树莓 Pi 3 型，5V 电源供电的单板电脑。
2. 英特尔的神经计算棒。
3. NCSDK2 :这款英特尔 Movidius Neural Compute 软件开发者套件 v2 来自 GitHub，免费下载。
4. 一个 USB 摄像头，任何品牌都应该工作，而一个广角镜头脱颖而出，因为我们正在建立一个安全摄像头。

可选使相机运行在电池上。

• 12V 锂电池模块和 DC-DC 模块将电压降低到 5V。
• 或者带有 USB 端口的电池组提供 5V/2A。

可选建立一个额外的炮塔来转动相机，覆盖更广泛的视野范围。

1. 业余爱好伺服电机
2. Arduino Pro Micro 或其他 Arduino 可比主板
3. 一些焊丝

建造项目房屋的可选材料，纸板、实木板等。

在这篇文章中，你将学习如何为 Movidius NCS 在 Raspberry Pi 上安装必要的软件，并在网络摄像头帧上实时进行对象检测。

在 Raspberry Pi 上安装 NCSDK2

树莓 Pi 的基本安装和配置已经在 Movidius 文档中列出，注意树莓 Pi 3 必须运行 NCSDK2 的最新 Raspbian Stretch，建议使用 SD 卡大小的 16G +。

安装 NCSDK2 后，安装 NCAPI v2 的 ncappzoo ，其中包含了 Movidius 神经计算棒的例子。

git clone -b ncsdk2 https://github.com/movidius/ncappzoo.git

然后将CD 成 ncappzoo/apps ，删除或者重命名文件夹 video_objects 到别的地方，在那里克隆我的 video_objects repo。

git clone https://github.com/Tony607/video_objects

以最简单的方式安装 OpenCV3

运行这个演示需要安装 opencv3。虽然官方的标准方法是从源代码构建，但我尝试了几次都没有成功，这导致了我的替代解决方案，在 raspberry Pi 上安装预构建的 OpenCV3 库只需几分钟，而从源代码构建需要几个小时。只需在终端中运行以下四行代码。

sudo pip3 install opencv-python==3.3.0.10
sudo apt-get update
sudo apt-get install libqtgui4
sudo apt-get install python-opencv

你刚刚为树莓派安装了 python wheels 的 opencv -python 包版本 3.3.10！下面的两个 apt-get 安装确保没有缺失的依赖项。

要检查 python3 中的安装，可以像这样运行。期待看到 OpenCV3 版本字符串“3.3.0”。

[email protected]:~/workspace/ncappzoo/apps/video_objects $ python3
Python 3.5.3 (default, Jan 19 2017, 14:11:04) 
[GCC 6.3.0 20170124] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import cv2
>>> cv2.__version__
'3.3.0'
>>> 

所以不要再抱怨“我的代码正在编译”。

运行对象检测演示

将您的 NCS 和网络摄像头插入您的 Raspberry Pi 的 USB 端口，连接 HDMI 监视器或使用 VNC 访问您的 Pi 桌面。让我们开始演示吧。在终端中，将光盘放入 video_objects 目录中你刚刚从我的 GitHub repo 中克隆出来然后运行。

make run_cam

第一次运行时，make 脚本将下载 SSD mobileNet 深度学习模型定义文件和权重，因此预计会有一些延迟。之后，会弹出一个新窗口，显示实时摄像机画面，以及探测到的物体的覆盖边框。软件只会将两帧之间识别人数变化的关键图像帧保存到 文件夹 images 中。在下一篇文章中会有更多的介绍。

结论和进一步阅读

作为安全摄像机项目的第一篇文章，它展示了如何构建一个最小的“更智能”的摄像机，该摄像机可以实时检测人，并只保存有用的关键帧。上一节中介绍的在 Raspberry Pi 上安装 NCSDK2 是这个项目中最困难和最耗时的部分，希望我的一些技巧能帮助您加快这一过程。在下一篇帖子中，我将解释你刚才运行的代码，并向你展示如何添加一个 Arduino 炮塔来转动相机，相机跟随周围的人，如我上传的这个 视频 所示。

最后一个提示，如果你计划在 Ubuntu 16.04 PC 上运行 NCS 和 NCSDK2，我的建议是使用物理机而不是虚拟机，我遇到了 NCS 设备未被检测到的问题，还没有解决方案。

有用的资源

Movidius 神经计算棒简介

Movidius 官方博客

树莓 PI 文档

• 标签:
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←如何在浏览器上训练神经网络
• 用神经计算棒制作 DIY 安全摄像机(第二部分)→

用神经计算棒构建 DIY 安全摄像机(第 2 部分)

原文：https://www.dlology.com/blog/build-a-diy-security-camera-with-neural-compute-stick-part-2/

发帖人:程维四年零五个月前

(评论)

上一篇文章向你展示了如何构建一个由 Raspberry Pi 和 Movidius neural compute stick 驱动的安全摄像头，可以实时检测人并只保存有用的图像帧。这一次，我将向您展示如何理解足够的源代码来添加一个 Arduino 伺服转台，使相机自动跟随它检测到的人。

当前代码是如何工作的？

无论您是来自 Arduino 的 C 编程背景，还是来自 Python 的舒适编码背景，掌握代码如何工作都不会太难。考虑到我们的目的是修改代码并添加一些伺服逻辑。在深入研究代码并对其进行定制之前，没有对深度学习知识的预先要求，因为深度学习模型已经打包到计算图中，神经计算棒理解如何获取输入图像并生成对象检测输出的特殊格式的文件。前面调用make run_cam命令，后面调用mvNCCompile命令，计算图就编译好了。

进入 video_objects_camera.py ，启动时发现并连接 NCS。然后将编译后的计算图分配到它的存储器中。Python OpenCV 库打开了系统中第一个可用的摄像头，因为摄像头索引为 0。至此，所有设置都已完成。在主循环中，对于每个捕捉到的网络摄像头图像，都会按照特定的分辨率进行处理，并按照模型的预期对其值进行标准化。

接下来，所有繁重的目标检测都在两行中完成，图像进入 NCS，检测结果出来。在最后一节中，您将看到以非同步方式实现这一点的替代 API 调用。

此处应用的 SSD MobileNet 对象检测模型可以检测 20 种不同的对象，如人、瓶子、汽车和狗。由于我们只对像安全摄像机一样检测人感兴趣，我们告诉检测器忽略其他类，这可以在object_classifications_mask变量中完成。

输出是一个浮点数数组，格式如下。

从那里开始，代码根据您设置的最低分数和分类掩码对结果进行过滤，然后在图像上创建边界框的覆盖。

这基本上就是代码所做的。添加计算在图像中检测到多少人的功能并在这个数字改变时保存它是很简单的，因此我们知道一个人何时进入或离开我们的视野。

添加伺服系统

假设您的安全摄像头是电池供电的，支持 WIFI，安装在一个最佳位置，可以监控 300 度的宽视角，并且可以同时覆盖您的车库、院子和街道。一些安全摄像机有可控的转台来手动转动摄像机以面对不同的角度，但当对象移出其视野时，它们不会自己转动。我们现在正在建造的这个安全摄像头即使在没有互联网的情况下也能实时检测到人，它足够智能，可以知道人在哪里，以及如何转向面对目标，但是我们还缺少一个东西，移动的部分，一个炮塔！

Arduino 草图与伺服系统对话

像 SG90 这样的廉价业余伺服电机应该可以完成这项工作，因为它不需要太多的扭矩来转动摄像头。伺服系统是如何工作的？脉冲的长度决定了伺服电机的位置。伺服系统预计大约每 20 毫秒接收一次脉冲。如果该脉冲为高 1 毫秒，那么伺服角度将为零，如果为 1.5 毫秒，那么它将位于其中心位置，如果为 2 毫秒，则它将位于 180 度。

使用 Arduino 控制器来控制伺服角度有三个好处，即使 Raspberry Pi 已经带有 PWM 引脚。

1. 使用 Arduino 使主要的 Python 代码可以跨其他平台进行比较，例如，你可以连接到 Arduino 并在 Ubuntu PC 上运行相同的演示。
2. 我们可以每隔 20 毫秒对 Arduino 上的伺服系统进行精确的速度控制，这对于 raspberry 来说是一个开销。
3. 它为 raspberry Pi 的数字引脚提供了额外的一层保护。

伺服有三个引脚，通常带有棕色，红色和橙色，代表接地，电源和信号。将接地(棕色)连接到 Arduino 的 GND，将电源(红色)连接到 Arduino 的 5V 或外部 5V 电池，将信号(橙色)连接到 Arduino 的引脚 4，如我的草图所示。请记住，如果您有一个高扭矩伺服系统，它可能需要更高的电压和电流，因此更安全的做法是由外部电源供电，如 12V 锂电池组，其电压通过 DC-DC 转换器(如 LM2596 模块)降低到所需的水平。

我选择了一个 Arduino Pro 微型板，它基本上是 Arduino Leonardo 的最小版本，小巧但功能多样，而其他 Arduino 兼容板应该也可以工作。Arduino 的代码可以在我的 GitHub 上免费获得。它接受串行端口命令，以相对角度或绝对角度转动伺服机构。

它在后面的技巧是通过控制在特定间隔内转动多少度来使伺服的运动更平滑。请随意试一试，说明包含在自述文件中。

按照此图连接所有部件。

用蟒蛇皮转动炮塔

拥有 Arduino 协处理器让 Raspberry Pi 的生活变得更加轻松。它需要做的只是发送命令告诉 Arduino 将伺服系统向左或向右转动一些角度。左转或右转的决定来自于计算被检测的人或多人的中心相对于视图中心的偏移，如果偏移大于某个阈值，将发出调谐的命令。这就是逻辑的本质，超级简单，但是行得通。

Python 代码通过枚举可用串行端口的描述来自动定位 Arduino 串行端口。确保您的 Raspberry Pi 上安装了 pySerial 库。

pip3 install pyserial

通过在 Pi 的控制台中键入以下命令来运行演示，并观察神奇的事情发生。

make run_gimbal

结论和进一步阅读

由于您正在试验相机演示，它可能只有每秒 6 帧(fps)左右。然而，通过利用 NCSDK2 附带的异步 FIFO API，这个数字可以提高到大约 8.69 fps。这超出了这个简单教程的范围，虽然它在我的 GitHub repo-video _ objects _ threaded上可用，但它是基于文件夹ncappzoo/apps/video_objects_threaded中的官方示例。希望以类似于您在video_objects中运行之前演示的方式运行它。如果你还没有看过演示视频，请点击这里观看。如果你被卡住了，不要犹豫发表评论。

有用的链接

【Arduino 和正版产品入门

ncsdkpython API 2 . x FIFO

GitHub 仓库

ncsdk 2-https://github . com/move ius/ncsdk/tree/ncsdk 2

NCSDK2 分支 ncappzoo-https://github.com/movidius/ncappzoo.git

我的视频对象检测报告-https://github.com/Tony607/video_objects

线程和 FIFO 的视频对象检测在 Pi-【https://github.com/Tony607/video_objects_threaded】的上实现 8.69 fps

• 标签:
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←用神经计算棒制作 DIY 安全摄像机(第一部分)
• 如何在 Movidius 神经计算棒上运行 Keras 模型→

你能相信一个 Keras 模型能区分非洲象和亚洲象吗？

原文：https://www.dlology.com/blog/can-you-trust-keras-to-tell-african-from-asian-elephant/

发帖人:程维四年零九个月前

(评论)

我不会撒谎，但我不久前刚刚学会区分非洲象和亚洲象。

**-电子慈善

---

*另一方面，最先进的 ImageNet 分类模型可以以 82.7%的准确率检测 1000 类对象，当然包括这两种类型的大象。ImageNet 模型经过超过 1400 万张图像的训练，可以找出对象之间的差异。

你想知道当看图像时模型聚焦在哪里，或者我们应该问我们应该相信模型吗？

有两种方法可以解决这个难题。

艰难的方式。通过研究论文，计算数学，实现模型，并希望最终理解它是如何工作的，来破解 ImageNet 模型的艺术状态。

或者

简单的方法。成为模型不可知论者，我们将模型视为黑盒。我们控制了输入图像，所以我们调整它。我们改变或隐藏图像中对我们有意义的部分。然后，我们将调整后的图像提供给模型，看看它会怎么想。

第二种方法是我们将要用和来试验的。这个奇妙的 Python 库 LIME 使它变得很容易，LIME 是本地可解释模型不可知解释的缩写。

像往常一样用 pip 安装，

pip install lime

让我们直接开始吧。

选择你想与之建立信任的模式

有许多用于图像分类的 Keras 模型，其权重是在 ImageNet 上预先训练的。您可以在可用型号中选择一款。

我打算用第三代试试我的运气。首次下载预训练体重可能需要一段时间。

使用输入图像查找前 5 个预测

我们选择了两只大象并肩行走的照片，这是测试我们模型的一个很好的例子。

代码为模型预处理图像，模型进行预测。

输出并不令人惊讶，亚洲又名印度大象站在前面，占据了图像的相当大的空间，难怪它得到最高分。

('n02504013', 'Indian_elephant', 0.9683744)
('n02504458', 'African_elephant', 0.01700191)
('n01871265', 'tusker', 0.003533815)
('n06359193', 'web_site', 0.0007669711)
('n01694178', 'African_chameleon', 0.00036488983)

向我解释你在看什么

这个模型正在做出正确的预测，现在让我们请它给我们一个解释。

我们首先创建一个 LIME 解释器，它只要求我们的测试图像和 model.predict 函数。

让我们看看这个模型是如何预测印度象的。model.predict函数将输出 0~999 范围内的各类指数的概率。

并且时间解释器需要知道我们想要哪个类的解释。

我写了一个简单的函数来简化它

原来“印度象”的阶级指数等于 385。让我们请解释者展示一下这个模型的神奇之处。

这很有意思，模特也在关注印度象的小耳朵。

非洲象呢？

酷，模型预测的时候也在看非洲象的大耳朵。它也在查看文本“AF RIC 一只大象蚂蚁”的一部分。这是巧合还是模型足够聪明，可以通过阅读图像上的注释来找出线索？

最后，让我们来看看当模型预测一只印度象时有什么“利弊”。

(绿色表示赞成，红色表示反对)

看起来这个模型也在关注我们做的事情。

总结和进一步阅读

到目前为止，你可能仍然不知道模型是如何工作的，但至少对它产生了一些信任。这可能不是一件可怕的事情，因为现在您又多了一个工具来帮助您区分好的模型和差的模型。一个坏模型的例子可能是在预测物体时关注于无意义的背景。

我对 LIME 能够做的事情还只是皮毛，我鼓励你探索其他的应用，比如文本模型，LIME 会告诉你在做决定时模型关注的是文本的哪一部分。

现在继续，在一些深度学习模型背叛你之前，重新检查它们。

LIME GitHub 仓库

局部可解释模型不可知解释介绍(LIME)

我的这个实验的完整源代码可以在我的 GitHub 库中找到。

• 标签:
• 深度学习，
• keras

Share on Twitter Share on Facebook

• ←YOLO 对象定位如何与 Keras 协同工作的简明指南(第 1 部分)
• 如何免费快速运行视频中的对象检测和分割→***

DIY 对象检测涂鸦相机与树莓派(第一部分)

原文：https://www.dlology.com/blog/diy-object-detection-doodle-camera-with-raspberry-pi-part-1/

发帖人:程维四年零四个月前

(评论)

让我们创建一个可以创建和打印一些艺术作品的相机。查看演示视频看看结果。

看完这个教程，把下面几块拼起来，你就知道怎么做这样一个相机了。

• 用豪猪的声音激活来触发图像捕捉。
• 在 Raspberry Pi 中捕捉网络摄像头图像。
• 使用 TensorFlow 对象检测 API 进行对象检测
• 涂鸦检测到的物体
• 用微型热敏收据打印机打印绘图
• 在你的 Pi 上添加一个快门按钮和一个 LED 指示灯

在开始之前，确保你已经准备好以下材料。

1. 树莓 Pi 型号 3 或以上，安装 Raspbian 9(拉伸)。其他模型未经测试，可能需要对源代码进行一些调整。
2. 带有内置麦克风的 USB 网络摄像头，如 Logitech C920。
3. 一台迷你热敏收据打印机，就像Adafruit.com上的那台。
4. 一个 USB 转 TTL 适配器，用于将迷你热敏收据打印机连接到 Pi，就像亚马逊上基于 CP2102 芯片组的适配器一样。

可选的东西，你可能没有，但可以使你的相机看起来光滑。

1. 7.4V 2c lipo 电池和额定 3A 或以上输出电流的 DC-DC 转换器模块将电压降低至 5V。像亚马逊上的 LM2596 DC 到 DC 降压转换器。
2. 打开/关闭相机的电源开关
3. 单个 LED 模块显示当前状态。
4. 手动触发图像捕捉快门的单按钮模块。

所有的源代码和数据资源都打包到一个文件中，从我的 GitHub 版本下载，然后用下面的命令解压到您的 Pi 中。

wget https://github.com/Tony607/voice-camera/archive/V1.1.tar.gz
tar -xzf v1.1.tar.gz

现在我们已经准备好把这些碎片拼在一起了。

豪猪语音激活

我们正在谈论的这只豪猪不是长着尖刺的可爱啮齿动物，而是一个由深度学习驱动的设备上唤醒单词检测引擎。如果你读过我以前的帖子- 如何用 Keras 做实时触发词检测，你就会知道我在说什么。但是这一次它是如此的轻量级，甚至可以在树莓 Pi 上运行，具有非常好的精确度。Porcupine 是一个跨平台软件，可以在其他操作系统上运行，比如 Android、iOS、watchOS、Linux、Mac 和 Windows。不需要特殊的训练，通过将文本字符串传递到优化器来指定一个您希望引擎检测的关键字，并生成一个关键字文件。引擎可以采用多个激活字来触发程序中的不同动作。在我们的例子中，我们将使用语音命令“蓝莓”来触发对象检测涂鸦风格，并使用“菠萝”来触发另一种边缘检测涂鸦风格。

要安装 Porcupine 的依赖项，请在 Pi 的终端中运行以下命令。

如果一切顺利，你会看到这样的东西，它在等你说出关键词“菠萝”。

在中有一个您可以使用的其他预优化关键字的列表。/porcupine/resources/keyword _ files文件夹。

一个边注，豪猪库本身是相当准确的，而结果会受到麦克风相当大的影响。一些只有一个内置麦克风的网络摄像头只能在有限的范围内清晰地捕捉语音，而由两个麦克风组成的罗技 C920 网络摄像头上的麦克风阵列可以消除环境中的噪音，即使在延长的距离内也能清晰地记录您的声音。

TF 使用实时网络摄像头进行物体检测

一旦该应用程序被语音激活，该软件将让网络摄像头捕捉图像，并试图找到里面的物体。

从网络摄像头捕捉图像需要在您的 Pi 上安装 OpenCV3 库。人们过去常常花费数小时编译源代码并将其安装在 Pi 上，现在在终端上运行这三行代码就可以避免这种情况。

pip3 install opencv-python==3.3.0.10
sudo apt-get install libqtgui4
sudo apt-get install python-opencv

捕获的照片进入 TensorFlow 对象检测 API，模型返回四条信息，

1. 图像上检测到的物体的边界框，
2. 每个箱子的检测置信度得分
3. 每个对象的类别标签
4. 检测的总数。

我们用于对象检测的模型是从 TensorFlow 检测模型 zoo 下载的 SSD lite MobileNet V2。我们使用它是因为它很小，即使在 Raspberry Pi 上也能快速运行。我一直在 Pi 上以每秒最多 1 帧的速度实时测试运行该模型，如果你想在你的 Pi 上将帧速率提高到 8 FPS 或更高，这对这个应用程序来说是多余的，请随时查看我的另一个教程关于如何用 Movidius 神经计算棒做到这一点。

要将最新的预建 TensorFlow 1.9.0 和对象检测 API 依赖项安装到您的 PI，请在终端中运行这些命令。

sudo apt install libatlas-base-dev protobuf-compiler python-pil python-lxml python-tk
pip3 install tensorflow

这里需要注意的是，没有必要下载 TensorFlow 模型库，因为您通常会使用对象检测 API，这会占用您 PI 的 SD 卡上大约 1GB 的空间，并且会浪费宝贵的下载时间。完成本教程所需的所有 Python 源代码都已经打包在你之前从我的 repo 下载的 27MB GitHub 版本中。

到 验证 你的安装和相机正在工作，运行这个命令行。

python3 ./image_processor/examples/test_object_detection.py

模型的加载可能需要 30 秒左右，如果一切正常，您将会看到类似这样的内容。

结论和进一步阅读

到目前为止，你已经了解了语音激活和物体检测在项目中的应用，在下一篇文章中，我将向你展示其余部分的组合。

这个项目在很大程度上受到了danmacnish/cartonify的影响，而你可以看到我的版本，增加了语音激活，紧凑的卡通绘图数据集，对象检测 API 和优化的 Python 热敏打印机库都在一个 27 MB 的发布文件中，相比之下，原作者的 ~5GB 卡通数据集，~100MB TensorFlow 模型和应用程序源代码。

继续上 第二部分 的教程。

有用的资源

为您的树莓派安装操作系统映像

使用访问您 Pi 的桌面

• 标签:
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←如何在 Movidius 神经计算棒上运行 Keras 模型
• 用树莓派 DIY 物体检测涂鸦相机(第二部分)→

用树莓派 DIY 物体检测涂鸦相机(第二部分)

原文：https://www.dlology.com/blog/diy-object-detection-doodle-camera-with-raspberry-pi-part-2/

发帖人:程维四年零四个月前

(评论)

上一篇走过了这个项目的前几个部分，即语音激活和物体检测。这一次，我们将总结其余的软件和硬件组件，以建立一个完整的对象检测涂鸦相机。

• 涂鸦检测到的物体
• 用微型热敏收据打印机打印绘图
• 在你的 Pi 上添加一个快门按钮和一个 LED 指示灯

绘制检测到的对象

在前面的对象检测步骤之后，每个检测的边界框、类和分数都将可用。对象的大小和中心位置可以进一步从边界框值中获得。创建几乎不重复的高分辨率绘图的诀窍是应用谷歌快速绘制数据集，其中每个绘图都被记录为画布上的笔画坐标。在这里看看网上真人做的103031 张猫图。

下面的代码片段向您展示了如何将第一个“猫”画的笔画转换成图像。

dataset.get_drawing()法位于。/drawing _ dataset/drawing dataset . py文件通过名称和索引获取绘图。在这种情况下，我们得到的名称“猫”的索引为 0，对应于第一只猫画的笔画。在每一个笔画里面，都有多个点，它们被连接在一起，由 Gizeh Python 库在画布上绘制成一条折线。

例如，这只猫的第二个笔画从右向左画了 3 个点。

由于SSDliteMobileNet V2对象检测模型只能检测有限类别的对象，而快速绘制数据集上有 345 个类别的 5000 万个图形，我决定预处理原始数据集，并保留每个可识别类别的前 100 个图形。每个类的绘图都被保存为更容易阅读的 Python 3 pickle 格式的路径。/data/quick_draw_pickles/。

用微型热敏收据打印机打印

热敏打印机也被称为收据打印机。它们是你去自动取款机或杂货店时得到的东西。它的工作原理是加热热敏纸上的点，热敏纸上涂有受热时会变色的材料，因此不需要墨水。该打印机是 Raspberry Pi 等小型嵌入式系统甚至微控制器的理想选择，因为它通过 TTL 串行端口与应用处理器通信，并在打印期间由 5-9 VDC @ 1.5Amp 供电。只要你的系统有一个额外的串口，就不需要额外的打印机驱动，这意味着你可以跨操作系统使用 Python 打印机库，无论是 Ubuntu PC，Windows PC 还是 Raspberry Pi。

与最初的 Adafruit 库相比，我的 Python 打印机库在打印大型位图图像的速度和稳定性方面都有了一些改进。

图像将首先被转换成二进制位图，然后逐行打印。一行越密，打印机需要的加热时间就越长，否则就会出现空行。动态计算每行的打印时间可实现最佳速度和稳定性。

以这个 8×8 二进制位图为例，第 1 行有 4 个点要打印，第 5 行只有 2 个点，打印第 1 行比第 5 行需要的时间稍长。由于热敏纸上可以打印的最大宽度是 384 像素，我们将首先将绘图图像翻转 90 度，以逐行垂直打印。

由于通过串行端口发送完整的 384×512 位图需要很大的带宽，因此还需要将其波特率从默认的 19200 或 9600 调整到 115200，以便在热敏打印机上实现更快的位图打印。我在我的 GitHub 上附加了一个工具来完成这个。

添加快门按钮和指示灯 LED

没有任何响应或反馈的语音激活会破坏用户体验，这就是为什么我们添加了单个 LED 以不同的模式闪烁，以显示是否检测到语音命令。一个额外的按钮还提供了一个额外的选项来触发相机捕捉，对象检测，绘图和打印工作流程。

与 Raspberry Pi 系统一起提供的 gpio zero Python 库提供了一个与 IO 引脚接口的快速解决方案。它允许你以各种方式脉冲或闪烁发光二极管，并使用一个背景线程处理时间，而无需进一步的交互。一个按钮只需两行就可以触发一个函数调用。

所有的 GPIO 用法都在中定义。/raspberry _ io/raspberry . py文件，以防您想要更改 LED 闪烁和脉冲的方式。

不用电线，由电池供电

虽然有可能在 3 安培时获得强大的 5V 电源，但它可能太笨重，不适合放在我们的相机盒中。使用紧凑型两节 7.4 v 脂电池同时为 Raspberry Pi 和热敏打印机供电似乎是一种可行的方式。你可以直接用 7.4 V 电池给热敏打印机供电，而树莓 Pi 采用 5V 电源，这就是 DC-DC 降压模块发挥作用的地方。它是一个开关电源从输入到输出逐步降低电压。我正在使用一个 LM2596 DC 到 DC 降压转换器 ，你可以在亚马逊上看到。

模块上有一个小电位器，用来调节输出电压。将电池连接到输入电源和接地引脚，转动电位计上的小旋钮，同时用万用表监控输出电压，直到输出电压达到 5V。

结论和进一步阅读

这是最终的完整图表，向您展示了各部分是如何连接的。

如果你有关于建立你的物体探测和涂鸦相机的问题，请随意发表评论。

Share on Twitter Share on Facebook

• ←带树莓派的 DIY 物体检测涂鸦相机(第 1 部分)
• 《如果我是女孩》StarGAN 的魔镜→

使用 TensorFlow Hub DELF 模块轻松识别地标图像

原文：https://www.dlology.com/blog/easy-landmark-image-recognition-with-tensorflow-hub-delf-module/

发帖人:程维四年零六个月前

(评论)

你有没有想过谷歌图片搜索是如何在幕后工作的？我将向您展示如何以最少的配置构建一个利用 TensorFlow Hub 的 DELF(深度本地功能)模块的地标图像识别管道的迷你版本。

阅读时，请随意浏览 Colab 笔记本。

图像识别/检索简介

图像检索是在大型数据库中搜索数字图像的任务。它可以分为两类:基于文本的图像检索和基于内容的图像检索。在基于文本的图像检索方法中，我们只需在搜索栏中输入一个查询(或相关词)就可以得到图像结果。在基于内容的图像检索中，我们在搜索域中提供一个样本(但相关的)图像，以获得相似图像的结果。

这篇文章关注的是基于内容的图像检索，其中图像通过特征提取过程自动标注其视觉内容。视觉内容包括颜色、形状、纹理或任何其他可以从图像本身得到的信息。 提取代表视觉内容的特征，通过高维索引技术进行索引，实现大规模图像检索。

如果你读过我之前的文章“T0:构建一个旅游推荐引擎 T1:T2”，这实际上是一个图像检索模型，依赖于提取的全局图像特征 T3，因此很难处理部分可见性和无关的图像特征。或者，更健壮的图像检索系统是基于局部特征的。它能够处理背景杂波、部分遮挡、多个地标、不同比例的物体等。

以大峡谷中的这两幅马蹄铁图像为例，它们处于不同的光照和尺度下。

什么是 DELF(深度局部特征)模块？

tensor flow Hub上提供的预训练 DELF(深度局部特征)模块可用于图像检索，作为其他关键点检测器和描述符的替代。它用被称为特征描述符的 40 维向量来描述给定图像中每个值得注意的点。

下图显示了两幅图像的 DELF 对应关系。

DELF 使用 Google-Landmarks 数据集进行训练，该数据集包含来自 12 、 894 地标的 1、 060 、 709 图像以及针对地标优化的 036 附加查询图像

DELF 图像检索系统可以分解为四个主要模块:

1. 密集局部化特征提取，
2. 关键点选择
3. 降维，
4. 标引和检索。

前 3 个块被包装到 TensorFlow Hub DELF 模块中。即便如此，打开黑匣子看看里面还是很有意思的。

dense 局部特征提取块由用分类损失训练的 ResNet50 CNN 特征提取层形成。所获得的特征图被视为局部描述符的密集网格。

特征基于它们的感受域被定位，这可以通过考虑全卷积网络(FCN)的卷积层和汇集层的配置来计算。他们使用感受野中心的像素坐标作为特征位置。下图显示了 256x256 分辨率输入图像的聚合唯一位置。

他们采用了两步训练策略，首先将原来的 ResNet50 层微调到 增强局部描述符的区分度，随后训练注意力得分函数来评估模型提取特征的相关性。

在降维块中，特征维数通过 PCA 降低到 40，一种紧凑性和区分性的权衡。 至于索引和检索，我们将在下一节构建。

建立图像识别管道

为了进行演示，我们将创建这样一个地标图像识别系统，它将一幅图像作为输入，并判断它是否与 50 个世界著名建筑之一相匹配。

索引数据库图像

我们首先从 50 个数据库地标建筑图像中提取特征描述符，并聚集它们的描述符和位置。在我们的例子中，总共有 9953 个聚集的描述符-位置对。

我们的图像检索系统是基于最近邻搜索的，为了促进这一点，我们用所有聚集的描述符建立了一个 KD 树。

索引是离线执行的，并且只构建一次，除非我们将来想要索引更多的数据库映像。请注意，在下面的代码片段中，我们还创建了一个索引边界查找数组，用于在给定聚合描述符索引的情况下反向定位数据库映像索引。

运行时查询图像

在运行时，查询图像首先被调整大小并裁剪为 256x256 分辨率，然后 DELF 模块计算其描述符和位置。然后，我们查询 KD 树，为查询图像的每个描述符找到 K 个最近的邻居。接下来，汇总每个数据库映像的所有匹配。最后，我们使用 RANSAC 执行几何验证，并采用内联体的数量作为检索图像的分数。

下图说明了查询管道。

关于应用 RANSAC 进行几何验证，有一点值得一提。我们希望确保所有匹配都符合全局几何变换；但是，有许多不正确的匹配。以下图为例，在没有几何验证的情况下，有许多不一致的匹配，而在应用 RANSAC 后，我们可以同时估计几何变换和一致匹配集。

在我们的查询演示中，在 K 最近邻搜索之后，我们总共聚集了 23 个试验性的数据库图像，而在对每个试验性的查询图像应用 RANSAC 之后，只剩下 13 个候选图像。

以下代码片段使用 RANSAC 和可视化执行几何验证。

管道最终通过索引为每个数据库候选生成内联器计数分数。

然后打印出最匹配图像的描述及其索引就很简单了

哪些输出:

Best guess for this image: 18\. The Colosseum — Rome, Italy

总结和进一步阅读

我们首先简要介绍图像识别/检索任务和 TensorFlow Hub 的 DELF 模块，然后构建一个演示图像识别管道来检索 50 个世界著名建筑。

最初的 DELF 论文给了我写这篇文章最大的灵感。

虽然有一些相关的资源，你可能会觉得有帮助。

Kaggle - Google 地标识别挑战赛

Kaggle - Google 地标检索挑战赛

张量低集线器上的 DELF 模块

Coursera - RANSAC:随机样本共识

最后，别忘了在我的 GitHub 上查看这篇文章的源代码，并尝试一下可运行的 Colab 笔记本。

• 标签:
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ← Keras +通用语句编码器=针对文本数据的迁移学习
• 利用深度方向可分离卷积的简单语音关键词检测→

使用 Keras 从网络摄像头视频中轻松实时预测性别年龄

原文：https://www.dlology.com/blog/easy-real-time-gender-age-prediction-from-webcam-video-with-keras/

发布者:程维 4 年 12 个月前

(评论)

你曾经有过猜测另一个人年龄的情况吗？也许这个简单的神经网络模型可以为您完成这项工作。

你马上要运行的演示将从网络摄像头获取一个实时视频流，并用年龄和性别标记它找到的每张脸。猜猜看，放置一个这样的网络摄像头会有多酷，比如说在你的前门放置一个这样的摄像头，以获得所有访客的年龄/性别统计数据。

我在装有 Python 3.5 的 Windows PC 上运行了这个模型。也可以在其他操作系统上运行。

它是如何工作的

让我们大致了解一下它是如何工作的。

首先，照片是由**cv2**模块从网络摄像头实时拍摄的。

其次，我们将图像转换为灰度，并使用cv2模块的CascadeClassifier类来检测图像中的人脸

由detectMultiScale方法返回的变量 faces 是一个检测到的面部坐标列表[x，y，w，h]。

在知道了人脸的坐标之后，我们需要在输入神经网络模型之前裁剪这些人脸。

我们在面部区域增加了 40%的余量，这样整个头部都包括在内了。

然后，我们准备将这些裁剪过的面输入到模型中，这就像调用predict方法一样简单。

对于年龄预测，模型的输出是与年龄概率范围从 0~100 相关联的 101 个值的列表，所有 101 个值加起来是 1(或者我们称之为 softmax)。因此，我们将每个值与相关的年龄相乘，并将它们相加，得到最终的预测年龄。

最后但同样重要的是，我们绘制结果并渲染图像。

性别预测是一项二元分类任务。该模型输出 0~1 之间的值，其中该值越高，该模型认为该人脸是男性的置信度越高。

我的完整源代码以及下载预训练模型权重的链接可在 my GitHub repo 中找到。

更深入

对于那些不满意的演示，并有更多的了解模型是如何建立和培训。这部分是给你的。

数据集来自IMD b-WIKI–500k+带有年龄和性别标签的人脸图像。在把每张图片输入模型之前，我们做了和上面一样的预处理步骤，检测人脸并添加边缘。

神经网络的特征提取部分使用 WideResNet 架构，是宽残差网络的缩写。它利用卷积神经网络(简称 ConvNets)的能力来学习人脸的特征。从不太抽象的特征如棱角到更抽象的特征如眼睛和嘴巴。

WideResNet 架构的独特之处在于作者降低了原始残差网络的深度并增加了其宽度，因此其训练速度提高了数倍。链接到论文这里。

进一步阅读

模型的可能性是无限的，这真的取决于你把什么数据输入其中。假设你有很多照片被贴上了吸引力的标签，你可以教模型从网络摄像头的直播流中辨别一个人的性感程度。

这是一个相关项目的列表，为那些好奇的人准备的数据集。

tensor flow 中的年龄/性别检测

IMD b-WIKI–50 万张以上带有年龄和性别标签的人脸图像

数据:性别和年龄分类未过滤的人脸
Github:keras-vgg face

自拍:一种理解自拍之美的方法

结束

Share on Twitter Share on Facebook

• ←如何教会 AI 向在线卖家建议产品价格
• 用预训练的 VGGFace2 模型进行活体人脸识别→

YOLO 对象本地化如何与 Keras 协同工作的简明指南(第 2 部分)

原文：https://www.dlology.com/blog/gentle-guide-on-how-yolo-object-localization-works-with-keras-part-2/

发帖人:程维 4 年 8 个月前

(评论)

编者按:本系列第 1 部分发表于《黑客正午》。查看 这里

欢迎回到本系列的第二部分。在这一节中，我们将深入研究 YOLO 对象本地化模型。

虽然你可能听说过 YOLO 这个缩写，但这个不同。代表“YouOonlyLookOnce”。

你可能想知道为什么“看一次”？因为还有其他看起来“不止一次”的对象位置模型，我们将在后面讨论。正如你已经预料到的，YOLO 的“看一次”特性使模型运行得非常快。

YOLO 模型详情

在这一部分，我们将介绍一些概念:一些是 YOLO 算法特有的，一些是其他物体定位模型共有的。

网格单元

与其他目标定位解决方案相比，将图像分解为网格单元的概念在 YOLO 是独一无二的。例如，在现实中，一个图像可以被切割成 19×19 的网格单元。但是出于解释的目的，我们将使用一个 3 x 3 的网格。

在上图中，我们有两辆汽车，我们用红色标记了它们的边界框。

接下来，对于每个网格单元，我们有以下标签用于训练。与我们之前在 系列 第一部中展示的一样。

那么，我们如何将对象与个体细胞联系起来呢？

对于最右边的车，很容易。它属于中间右边的单元格，因为它的边界框在该网格单元格内。

对于图像中间的卡车，它的包围盒与几个网格单元相交。YOLO 算法采用边界框的中点，并将其与包含它的网格单元相关联。

结果，这里是每个网格单元的输出标签。

注意，对于那些没有检测到对象的网格单元，它是 p[c] = 0，我们不关心其余的其他值。那是什么"？"图中的意思是。

和边界框参数的定义定义如下:

• b[x]:x坐标，对象的中心对应于网格单元的左上角，取值范围从 0~1，
  *** b[y]:y坐标，对象的中心对应于网格单元的左上角，取值范围从 0~1，*** b[h]:边框的高度 ，该值可能大于 1，* b[w]:边框的宽度 ，该值可以大于 1。****

****对于类别标签，我们检测 3 种类型的目标，

1. 行人
2. 汽车
3. 摩托车

与“汽车”同属第二类，所以 c[2] = 1，其他类= 0。

在现实中，我们可能会探测到 80 种不同类型的目标。因此，每个网格单元输出 y 将有 5 + 80 = 85 个标签，而不是这里显示的 8 个。

考虑到这一点，组合所有网格单元的目标输出具有 3 x 3 x 8 的大小。

但是只有网格单元是有限制的。

假设我们在同一个网格单元中有多个对象。例如，有一个人站在一辆汽车前面，他们的边界框中心非常接近。我们选人还是选车？

为了解决这个问题，我们先介绍一下 的概念，锚盒 。

锚箱

锚定框使得 YOLO 算法能够检测位于一个网格单元中心的多个对象。

注意，在上图中，汽车和行人都位于中间网格单元的中心。

锚框的概念通过预定义多个锚框，为输出标签增加了一个“维度”。所以我们可以给每个定位框分配一个对象。为了便于说明，我们将选择两种形状的两个锚盒。

每个网格单元现在有两个锚定框，每个锚定框就像一个容器。这意味着现在每个网格单元可以预测多达 2 个对象。

但是为什么要选择两个不同形状的锚盒呢——这真的重要吗？直觉是，当我们决定将哪个对象放在哪个锚定框中时，我们会查看它们的形状，注意一个对象的边界框形状与锚定框的形状有多相似。对于上面的例子，该人将与高锚箱相关联，因为他们的形状更相似。

因此，一个网格单元的输出将被扩展以包含两个锚定框的信息。

例如，上图中的中心网格单元现在总共有 8 x 2 个输出标签，如下所示。

选择各种锚盒形状的另一个原因是为了让模型更好地专门化。一些输出将被训练以检测宽的物体，如汽车，另一个输出被训练以检测高且瘦的物体，如行人，等等。

为了对 【形似】 的直觉有更正式的理解，我们需要了解它是如何被评价的。这就是 Union 上的交集 — 发挥作用的地方。

并集上的交集

在并集上求交的概念非常简单。它经常被用来作为一个评估指标，以衡量一个对象定位器的准确性。

但是实施可能会有点伤脑筋。所以让我们通过一个简单的借据实现来详细了解一下。

不要用它的中心点、宽度和高度来定义一个盒子，让我们用它的两个角(左上角和右下角)来定义它:(x1，y1，x2，y2)

为了计算两个盒子的交集，我们从寻找交集区域的两个角开始。想法是这样的:

然后，为了计算交叉点的面积，我们用它的高度乘以它的宽度。

为了得到两个盒子的并集，我们使用下面的等式:

union_area = box1_area + box2_area - intersection_area

这里有一个计算 IoU 的函数:

交集大于并集( IoU )的用处不仅仅局限于我们在准备训练数据集时分配锚盒。在预测过程中也很重要。让我们来看看物体定位任务中流行的非最大值抑制算法。

非最大抑制

非最大值抑制是一种常用的算法，用于在为同一对象预测多个框时进行清理。

在我们之前的例子中，我们使用 3×3 的边界框。实际上，19×19 的边界框用于实现更精确的预测。因此，更有可能为同一个对象预测多个框。

在下面的例子中，模型输出了位于中间的卡车的三个预测值。有三个边界框，但我们只需要一个。预测的边界框越厚，预测就越有把握——这意味着 p[c] 值越高。

我们的目标是移除主要预测框周围的那些“阴影”框。

这就是非最大抑制在 3 个步骤中的作用:

1. 丢弃 p[c] 小于或等于 0.6 的所有盒子。
2. 挑选 p[c] 输出最大的盒子作为预测。
3. 丢弃任何剩余的 IoU 大于或等于 0.5 的盒子。

最后，清理后的预测如下:

训练 YOLO 模型

YOLO 模型现在应该准备好用大量图像和大量标记输出进行训练了。像 COCO 数据集 。但是你不会想这么做的，因为有一个预先训练好的模型等着我们去玩！

在我们进入有趣的部分之前，让我们看看 YOLO 模型是如何做出预测的。

用 YOLO 模型预测

给定一幅图像，YOLO 模型将生成形状(3，3，2，8)的输出矩阵。这意味着每个网格单元将有两个预测，即使是那些内部没有任何对象的网格单元。

在应用非最大值抑制来清理预测之前，还有另一个步骤，即通过 利用“类分数” 的阈值进行过滤来减少最终输出框。

类分数是通过将 p[c] 乘以单个类的输出(C[1] ，C[2]，C[3])来计算的。

这是说明预测过程的图表。注意，在“按类分数过滤”之前，每个网格单元有 2 个预测的边界框。

Keras + TensorFlow Implementation

记住前面的概念，你会对阅读 YOLO 模型代码充满信心。

完整的源代码可以在我的 GitHub repo 中找到。我们来看看一些值得一提的部分。

tensorflow 非最大抑制

代替实现我们自己的 IoU 和非 max 抑制，TensorFlow 有 其 tf.image.non_max_suppression() 准备使用。

等等，我们用的是 Keras 模型吗？

不要担心。 这次我们使用的是 Keras 后端 API，它允许你编写的 Keras 模块兼容 TensorFlow API， 所以所有 TensorFlow 操作符都由我们支配。

非 max 抑制的 TensorFlow+Keras 实现可以是这样的。注意我们在这里使用了一个 Keras 变量和一个 TensorFlow 操作符。

函数的输入输出大多是输入输出张量。输出张量可以成为另一个类似函数的输入， 流向管道的下游 。你猜怎么着？TensorFlow 的名字就是由此而来。

下面是构建预测计算图的代码:

然后，我们可以运行 TensorFlow 会话来计算输出，并最终在图像上绘制预测的边界框。

这是我不久前拍摄的一张照片生成的输出:

总结和进一步阅读

在这篇文章中，我们介绍了一些关键概念，这些概念使得 YOLO 目标定位算法能够快速准确地工作。然后，我们介绍了 Keras+TensorFlow 中 YOLO 输出管道实现的一些亮点。

在结束之前，我想提出 YOLO 算法的两个局限性。

• 由于每个网格单元的锚盒有限，YOLO 在探测像一群鸟或一群人这样的小物体时会遇到困难。
• 模型输出被训练以识别不同的锚形盒子形状的 T2 物体。具有奇怪长宽比的物体很难被探测到，比如一根长鱼竿。

【YOLO】:实时物体检测 。本页包含一个可下载的预训练 YOLO 模型重量文件。我还将在我的 GitHub repo 中包含如何使用它的说明。

艾伦·泽伦纳- 亚德 2K:又一个暗网 2 克拉斯 。Keras+TensorFlow 的实现很大程度上是受这个回购的启发。

还有其他有竞争力的目标定位算法，如 fast-CNN 和 SSD。正如本帖中所解释的，它们共享一些关键概念。请继续关注另一篇文章，并排比较这些算法。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←设置 Keras 深度学习框架和构建旅游推荐引擎的温和指南(第二部分)
• 如何为 Keras 分类器生成 ROC 图的简单指南→****

YOLO 对象本地化如何与 Keras 协同工作的简明指南(第 1 部分)

原文：https://www.dlology.com/blog/gentle-guide-on-how-yolo-object-localization-works-with-keras/

发帖人:程维四年零九个月前

(评论)

博士，我们将深入一点，了解 YOLO 物体定位算法是如何工作的。

我见过一些令人印象深刻的对象本地化实时演示。其中一个是带有 TensorFlow 物体检测 API ，你可以自定义它来检测你的可爱宠物——一只浣熊。

玩了一会儿 API 后，我开始想知道为什么对象本地化工作得这么好。

很少有网上资源以明确易懂的方式向我解释。所以我决定为那些对物体定位算法 如何工作感兴趣的人写这篇文章。

这篇文章可能包含一些高级的主题，但是我会尽可能友好地解释它。

到对象定位

什么是对象定位，它与对象分类相比如何？

你可能听说过 ImageNet 模型，它们在图像分类方面做得很好。一个模型被训练来辨别在给定的图像中是否有特定的物体，例如汽车。

对象定位模型类似于分类模型。但是经过训练的定位模型也可以通过在物体周围绘制一个边界框来预测物体在图像中的位置。例如，一辆汽车位于下图中。边界框、中心点坐标、宽度和高度的信息也包括在模型输出中。

让我们看看我们有 3 种类型的目标要检测

• 1-行人
• 两辆车
• 3 -摩托车

对于分类模型，输出将是代表每个类别概率的 3 个数字的列表。上图中只有一辆汽车，输出可能看起来像 [0.001, 0.998, 0.001]。第二类是汽车的概率最大。

本地化模型的输出将包括边界框的信息，因此输出将如下所示

• p[c]:1 表示检测到任何物体。如果为 0，输出的其余部分将被忽略。
• b[x]:x 坐标，物体的中心对应图像的左上角
• b[y]:y 坐标，物体的中心对应图像的左上角
• b[h] :边框的高度
• b[w] :边框宽度

至此，你可能已经想出了一种简单的方法来进行物体定位，即在整个输入图像上应用一个滑动窗口。就像我们用放大镜一次看地图的一个区域，看看那个区域是否有我们感兴趣的东西。这种方法易于实现，甚至不需要我们训练另一个定位模型，因为我们可以使用流行的图像分类器模型，并让它查看图像的每个选定区域，并输出每类目标的概率。

但是这种方法非常慢，因为我们必须预测大量的区域，并尝试大量的盒子尺寸来获得更准确的结果。它是计算密集型的，因此很难实现像自动驾驶汽车这样的应用程序所需的良好的实时对象定位性能。

这里有一个小技巧可以让它变得更快一点。

如果你熟悉卷积网络的工作原理，它可以通过为你拿着虚拟放大镜来模拟滑动窗口效应。因此，它在网络的一次前向传递中为给定的边界框大小生成所有预测，这在计算上更有效。但是，基于我们如何选择步幅和尝试多少不同大小的边界框，边界框的位置不会非常精确。

鸣谢:Coursera deeplearning.ai

在上图中，我们有形状为 16 x 16 像素和 3 个颜色通道(RGB)的输入图像。然后卷积滑动窗口显示在左上角蓝色方块中，大小为 14×14，步距为 2。意味着窗口一次垂直或水平滑动 2 个像素。如果在 14 x 14 区域中检测到 4 种类型的目标对象中的任何一种，输出的左上角会显示左上角的 14 x 14 图像结果。

如果你不完全确定我刚刚谈到的滑动窗口的卷积实现，没有问题，因为我们稍后解释的 YOLO 算法将处理它们。

为什么我们需要对象本地化？

一个明显的应用，自动驾驶汽车，实时检测和定位其他汽车，路标，自行车是至关重要的。

它还能做什么？

一个安全摄像头来跟踪和预测一个可疑的人进入你的财产？

或者在水果包装和配送中心。我们可以建立一个基于图像的体积传感系统。它甚至可以使用边界框的大小来接近传送带上的橙子大小，并进行一些智能分类。

你能想到物体定位的其他有用的应用吗？请在下面分享你的新鲜想法！

系列文章的第二部分“YOLO 对象定位如何与 Keras 协同工作的简明指南(第二部分)”。

Share on Twitter Share on Facebook

• ←如何利用深度学习诊断电机健康状况
• 你能相信一个 Keras 模型能区分非洲象和亚洲象吗？→

设置 Keras 深度学习框架和构建旅游推荐引擎的简明指南(第 2 部分)

原文：https://www.dlology.com/blog/gentle-guide-to-setup-keras-deep-learning-framework-and-build-a-travel-recommendation-engine-part-2/

发帖人:程维 4 年 8 个月前

(评论)

让我们继续构建旅游推荐引擎的旅程。你可以在我的博客上找到这个系列的第一部分。读完这篇文章后，你会知道如何将一个为分类而训练的模型变成一个提取图像特征向量的模型。然后，我们将通过它们的特征向量来研究如何计算两幅图像之间的相似性。最后，我们将生成具有最相似图像的旅行推荐。

为了获得最佳的学习体验，我建议在阅读本教程时打开 Colab 笔记本。

我们要打造的引擎是一个基于内容的推荐引擎。如果用户喜欢目的地照片，那么系统将向他/她显示类似的旅行目的地图像。

从分类器到特征提取器

在我们之前的帖子中，构建了一个模型来将输入图像分类为 365 个地点/场景名称中的一个。

我们将删除负责生成位置逻辑的最后 4 层，只保留网络的“特征提取器”部分。

在 Keras 中，我们可以像这样弹出最后 4 层。

上面的最后一行将模型权重保存到一个文件中，供以后使用。下一次，我们只需要定义没有 4 个分类器层的模型，并用保存的权重初始化网络。

如果您再次运行mode.predict，您会注意到输出不再是 365 浮点数的向量。相反，它现在是 4096 个浮点数的向量。这是特征向量，输入图像的抽象表示。

推荐相似图片

我们的推荐引擎获取用户喜欢的查询图像并推荐相似的地方。

通过测量两个特征向量之间的距离来计算两个图像之间的相似性。

你可以想象在 4096 维的空间里测量两个特征向量之间的距离。距离越小，两幅图像越相似。

预计算图像特征

我们可以在运行时计算所有已知图像的特征向量，并与查询图像的特征向量进行比较。但是这将是无效的，因为我们基本上是一次又一次地计算这些值。另一种更快的方法是预先计算这些特征向量，并将它们存储在存储器中。在运行时，我们只需要计算查询图像的特征向量，如果它以前没有被计算过，这节省了很多时间，特别是当你有很多图像要比较的时候。

这是通过调用特征提取器模型的预测函数来计算图像特征向量的函数。

我们还有另一个功能来预先计算所有已知的图像特征向量，并将它们存储到存储器中，这只需要做一次。

获得最相似的图像

下面是我们在运行时执行的函数，用于搜索和显示与新查询图像最相似的图像。

让我们通过运行下面的代码来尝试一下。

这是结果，我们的模型推荐了一张与查询图像相似的照片。

进一步的改进

如果您使用推荐引擎，您可能会注意到它偶尔会生成错误的推荐。

有两个原因，

1.该模型被训练用于分类，并且网络的图像特征提取器部分被优化用于将图像分类为 356 类，而不是用于区分相似的图像。

2.该模型在分布于 365 类地点的图像数据集上进行训练。训练集可能没有足够的图像用于特定类型的海滩或不同季节的一个地方。

第一个问题的一个解决方案是使用具有三重丢失的的连体网络，这在人脸验证任务中很流行。该模型将被训练以识别两个图像是否来自同一个地方。你可以查看一下 Coursera 上关于这个概念的视频介绍，我觉得很有帮助。

第二个问题的解决方案是通过“冻结”一些早期的卷积层，将迁移学习应用于我们的模型，并用我们的自定义图像数据集训练其余的模型参数。在训练新图像模型时，迁移学习是利用从大型图像数据集学习的一般特征的一种很好的方式。

结论

现在，您已经尝到了深度学习的无限潜力，并且可能对亲手构建和运行 Keras 模型留下了深刻的印象。掌握任何技术的旅程都不容易，深度学习也不例外。这就是最初激励我创建这个博客网站的原因，我通过分享和教授我在这个过程中所学到的东西，来更好地将深度学习应用于现实生活中的问题。如果您正在寻找解决方案或只是打个招呼，请不要犹豫，直接联系我。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←设置 Keras 深度学习框架和构建旅游推荐引擎的温和指南(第一部分)
• YOLO 物体定位如何与 Keras 协同工作的简明指南(第二部分)→

设置 Keras 深度学习框架和构建旅游推荐引擎的简明指南(第 1 部分)

原文：https://www.dlology.com/blog/gentle-guide-to-setup-keras-deep-learning-framework-and-build-a-travel-recommendation-engine/

发帖人:程维四年零九个月前

(评论)

TL；这篇文章将带你开始使用 Keras 深度学习框架，而不会有安装上的麻烦。我将向您展示在云上免费运行您的代码是多么容易。

我知道在 Keras 有很多教程可以帮助你开始深度学习。它们通常带有图像分类器，用于 MNIST 手写数字或猫/狗分类。在这里，我想采取一种不同但可能更有趣的方法，向您展示如何构建一个模型，在给定您喜欢的源图像的情况下，推荐您可能感兴趣的地方。

我们开始吧！

在云上运行，无需安装

如果你来自一个普通的编程背景，你可能曾经遭受过当你第一次开始一件新事物时的痛苦。

安装 IDE、库依赖、硬件驱动程序支持...在“你好，世界”第一次成功运行之前，它们可能已经花了你很多时间。

深度学习也是一样，它依赖于许多东西来使模型工作。比如，为了有一个深度学习模型训练和运行得更快，你需要一个显卡。对于初学者来说，这可能很容易需要几个小时来设置，更不用说您必须选择和购买显卡本身，这可能非常昂贵。

今天你可以消除深度学习的初始学习曲线。现在可以完全在云中运行您的代码，并且已经为您预装了所有必要的依赖项。更重要的是，你可以免费在显卡上更快地运行你的模型。

在这一点上，我想介绍一下Google Colab因为我发现与他人分享我的深度学习代码非常有用，他们可以在几秒钟内复制结果。

你所需要的只是一个 Gmail 账户和一个互联网连接。繁重的计算将由 Google Colab 服务器处理。

您需要熟悉 Colab 上的 Jupyter 笔记本环境。这很简单，你点击单元格左边的播放按钮来运行里面的代码。如果需要，您可以多次运行一个单元。

让我们通过激活 colab 上的 GPU 来加速深度学习模型的运行速度。

点击 运行时 菜单按钮，然后 改变运行时类型 ，在 硬件加速器 下拉列表中选择 GPU。

我们已经为旅行做好了准备！现在系好安全带，因为我们将要进入深度学习世界的狂野西部。

对地点进行分类的深度学习模型

我们介绍的模型可以分辨出一幅图像包含哪些地方。

或者更正式地描述，模型的输入是图像数据，输出将是具有不同概率的地点列表。概率越高，图像包含相应场景/地点的可能性越大。

该模型可以对 365 个不同的地方进行分类，包括咖啡店、博物馆、户外等。

这里是用于本教程的 Colab 笔记本，您可以在阅读本文的同时尝试使用它。Keras _ travel _ place _ re commendation-part 1 . ipynb

我们模型最重要的积木是 卷积网络 ，它将起到提取图像特征的作用。从更一般的低级特征，如边/角，到更特定领域的高级特征，如图案和零件。

该模型将由几个卷积网络块一个接一个地堆叠而成。卷积层越深，提取的特征越抽象，层次越高。

这里有一张展示这个想法的图片。

现在有了卷积网络的直觉就够了。让我们通过构建一个模型来实现它。

用 Keras 框架搭建一个定制的深度学习模型真的很容易。Keras 是为人类设计的，不是机器。也是目前最流行的深度学习库——tensor flow 的官方高级 API。如果你刚入门，寻找深度学习框架。Keras 是正确的选择。

建立模型

如果您是第一次看到下面的 Keras 型号代码，请不要惊慌。其实理解起来挺简单的。该模型有几个卷积层块。正如我们前面解释的，每个块提取不同级别的图像特征。例如，“块 1”处于输入级别，它提取像边缘和拐角这样的入门级特征。越深入，每个块提取的抽象特征越多。你也注意到了由两个完全连接的层形成的最终分类块，它们负责做出最终预测。

**### 预测图像的标签

让模型预测图像的标签。

该模型预期图像输入的固定形状为 244 x 244 像素，具有三个颜色通道(RGB)。但是如果我们有另一个不同分辨率的图像呢？Keras 有一些助手功能派上用场。

下面的代码将一幅图像转换成数据数组，然后在输入到模型之前进行一些数据值标准化。

然后我们将处理过的 shape 数组(3，244，244)输入到模型中，‘【preds】’变量是一个 365 个浮点数的列表，对应 365 个地点/场景。

选择前 5 个预测，并将它们的索引映射到地点/场景的实际名称。

这是结果。

['beach', 'lagoon', 'coast', 'ocean', 'islet']

请随意尝试其他图像。

总结和进一步阅读

我们已经了解到，使用 Google Colab 快速获得预测地点/场景的深度学习模型是多么容易。阅读教程的第二部分 ，我将向你展示如何从图像中提取原始特征，并使用它来构建一个旅游推荐引擎。

与此同时，查看一些可能有用的资源。

Keras 文档，尤其是 时序模型 API 部分。

如果你想上传你的自定义图像到 Colab，请阅读我以前的一篇文章中的“ 用自定义图像预测 ”部分。

Share on Twitter Share on Facebook

• ←如何处理 Keras 中的消失/爆炸渐变
• 设置 Keras 深度学习框架和构建旅游推荐引擎的温和指南(第二部分)→**

VS 代码远程开发入门

原文：https://www.dlology.com/blog/getting-started-with-vscode-remote-development/

发帖人:程维三年三个月前

(评论)

假设您在云或无头物理机上有一个 GPU 虚拟实例，有几个选项，如远程桌面或 Jupyter notebook，可以为您提供类似桌面的开发体验，但是，VS CODE 远程开发扩展可以比 Jupyter Notebook 更灵活，比远程桌面响应更快。我将一步一步地向你展示如何在 Windows 上设置它。

启动 OpenSSH 服务

首先，让我们确保您已经在您的服务器上设置了 SSH，很可能您的在线服务器实例将预先配置 OpenSSH 服务器，下面的命令可以检查它是否正在运行。

service sshd status

如果您看到类似这样的内容，您就可以开始了，否则，安装或启动 OpenSSH 服务器

● ssh.service - OpenBSD Secure Shell server
 Loaded: loaded (/lib/systemd/system/ssh.service; enabled; vendor preset: enabled)
 Active: active (running) since Tue 2019-09-17 19:58:43 CST; 4 days ago
 Main PID: 600 (sshd)
 Tasks: 1 (limit: 1109)
 CGroup: /system.slice/ssh.service
 └─600 /usr/sbin/sshd -D

对于 Ubuntu 系统，您可以安装 OpenSSH 服务器，并有选择地像这样更改默认的 22 端口

设置好之后，从您的开发机器使用 IP 地址、用户名和密码 ssh 到这个服务器，只是为了验证没有小故障。

Windows 上的 OpenSSH 客户端

这一步是无痛的，对于 Windows 10 用户来说，它只是在设置页面中启用一个功能，它可能已经被启用了。无论如何，下面是验证该特性是否启用的步骤。

在设置页面，转到应用程序，然后点击“管理可选功能”，向下滚动并检查“OpenSSH 客户端”已安装。

设置 SSH 密钥

你不想每次登录服务器时都输入用户名和密码吧？

在 Windows(你的开发机)

这里我们将在命令提示符下生成一个 SSH 密钥，

ssh-keygen -t rsa

接受默认值，按照提示操作时，您可以将关键阶段留空。

复制该命令的输出，

cat ~/.ssh/id_rsa.pub

然后使用用户名和密码 ssh 到服务器(如果还没有的话),然后运行下面的命令行，打开刚才复制到服务器上~/.ssh/authorized_keys的内容。

如果你不熟悉 vi，“Shift+END”到最后，键入“a”进入追加模式，右键粘贴剪贴板的内容。完成后，按“Shift +”然后打“wq”写并相当。希望在此之后，我们不需要在 vi 中以同样的方式编辑代码。

要验证 SSH 是否设置好了，在您的 Windows 机器上启动一个新的命令行提示符并键入ssh <username>@<server ip>，它应该会自动登录而不需要询问密码。

*## 安装远程开发 VS 代码扩展

打开 VSCOD，单击 Extension 选项卡，然后搜索“远程开发”并安装它。

一旦安装完毕，你会看到一个名为“远程浏览器”的新标签，点击它和齿轮按钮。

选择第一个条目，在我的例子中，它就像C:\Users\hasee\.ssh\config，一旦你打开它，填写别名、主机名和用户。别名可以是任何有助于记忆的文本，主机名可能是远程机器的 IP 地址。

一旦你这样做了，只需点击“连接到新窗口中的主机”按钮。

最后一步，在新窗口中点击侧边栏中的“打开文件夹”来选择远程机器上的文件夹路径，然后输入“Ctrl +`”来打开远程机器上的终端，就像在本地做的一样。

结论和进一步阅读

现在你有了它，一个快速的教程向你展示如何从头开始设置 VS 代码远程开发，让你在一个无头的远程服务器上享受桌面开发的体验。

官方 VS 代码远程开发页面请参考网站。

• 标签:
• 教程

Share on Twitter Share on Facebook

• ←物体检测深度学习的最新进展-第二部分
• 如何使用自定义 COCO 数据集训练检测器 2→*

如何选择最后一层激活和损失函数

原文：https://www.dlology.com/blog/how-to-choose-last-layer-activation-and-loss-function/

发布者:程维五年零一个月前

(评论)

不多说了，下面是不同任务的末层激活和损失函数对的不同组合。

二元分类-狗对猫

Kaggle 上的这个竞赛是你写一个算法来分类图像是包含一只狗还是一只猫。这是一个二进制分类任务，其中模型的输出是一个范围从 0 到 1 的单个数字，其中较低的值表示图像更像“猫”,而较高的值表示图像更像“狗”。

以下是最后一个完全连接层的代码和用于模型的损失函数

如果你对这个狗对猫任务的完整源代码感兴趣，可以看看 GitHub 上的这个牛逼教程。

多类单标签分类- MNIST

任务是将手写数字的灰度图像(28 像素乘 28 像素)分类为 10 个类别(0 到 9)。该数据集带有 Keras 包，因此很容易尝试。

最后一层使用“ softmax ”激活，这意味着它将返回 10 个概率得分的数组(总和为 1)。每个分数将是当前数字图像属于我们的 10 个数字类之一的概率。

同样，GitHub 上提供了 MNIST 分类的完整源代码。

多类别、多标签分类-新闻标签分类

Reuters-21578 是大约 20000 条新闻的集合，分为 672 个标签。它们分为五大类:

• 主题
• 地方
• 人
• 组织
• 交换

例如，一条新闻可以有 3 个标签

• 地点:美国、中国
• 主题:贸易

你可以在我的 GitHub 上看看这个任务的源代码。

我也为这个任务写了另一篇详细的博客，如果你感兴趣的话可以看看。

回归任意值——博斯腾房价预测

目标是用给定的数据预测单个连续值，而不是离散的房价标签。

网络以没有任何激活的密集结束，因为应用任何激活函数(如 sigmoid)都会将值约束为 0~1，我们不希望这种情况发生。

mse 损失函数，它计算预测值和目标值之差的平方，这是一个广泛用于回归任务的损失函数。

完整的源代码可以在同一个 GitHub repo 中找到。

回归到 0 和 1 之间的值

对于像评估喷气发动机的健康状况这样的任务，提供几个传感器记录。我们希望输出是一个从 0 到 1 的连续值，其中 0 表示发动机需要更换，1 表示发动机状况良好，而 0 到 1 之间的值可能表示需要某种程度的维护。与之前的回归问题相比，我们将“sigmoid”激活应用于最后一个密集层，以将值限制在 0 到 1 之间。

如果你有任何问题，请留言。

• 标签:
• keras ,
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←如何将内容“粘贴”到不支持复制粘贴的 VNC 控制台
• 如何对新闻类别进行多类多标签分类→

如何使用 TensorFlow 模型优化将 Keras 模型 x5 压缩得更小

原文：https://www.dlology.com/blog/how-to-compress-your-keras-model-x5-smaller-with-tensorflow-model-optimization/

发帖人:程维 3 年 7 个月前

(评论)

本教程将演示如何使用 TensorFlow 模型优化将 Keras 模型的大小减少 5 倍，这对资源受限环境中的部署尤为重要。

来自官方 TensorFlow 模型优化文档。 权重剪枝是指剔除权重张量中不必要的值。我们将神经网络参数的值设置为零，以移除我们估计的神经网络各层之间不必要的连接。这是在训练过程中完成的，以允许神经网络适应这些变化。

这里有一个如何采用这种技术的分解。

1. 一如既往地训练 Keras 模型以达到可接受的精度。
2. 使 Keras 层或模型准备好被修剪。
3. 创建修剪计划，并为更多时期训练模型。
4. 通过从模型中剥离修剪包装器来导出修剪后的模型。
5. 使用可选量化将 Keras 模型转换为 TensorFlow Lite。

修剪你预先训练好的 Keras 模型

您的预训练模型已经达到理想的精度，您希望在保持性能的同时缩减其大小。修剪 API 可以帮助你做到这一点。

使用剪枝 API，安装tensorflow-model-optimization 和 tf-nightly 软件包。

然后你可以加载你之前训练好的模型，让它“可修剪”。基于 Keras 的 API 可以在单个层或整个模型中应用。因为您已经预先训练了整个模型，所以将修剪应用到整个模型更容易。该算法将应用于所有能够进行权重修剪的图层。

对于修剪时间表，我们从 50%的稀疏度开始，并逐渐训练模型以达到 90%的稀疏度。X%的稀疏性意味着 X%的权重张量将被删除。

此外，我们在每个修剪步骤之后给模型一些时间来恢复，因此修剪不会在每个步骤上都发生。我们将修剪设置为 100。类似于修剪盆景，我们逐渐修剪它，以便树可以充分愈合修剪过程中产生的伤口，而不是在一天内砍掉 90%的树枝。

鉴于模型已经达到了令人满意的精度，我们可以立即开始修剪。因此，我们在这里将begin_step设置为 0，并且只训练另外四个纪元。

在给定训练样本数、批量大小和总训练期的情况下，计算结束步骤。

如果您在new_pruned_model摘要中发现更多可训练参数，请不要惊慌，这些参数来自我们稍后将移除的修剪包装器。

现在让我们开始训练和修剪模型。

修剪后的模型的测试损失和准确性应该与原始的 Keras 模型相似。

导出修剪后的模型

那些 剪枝包装器可以这样轻松的去掉，之后参数总数应该和你原来的模型一样。

现在你可以通过与零比较来检查权重被削减的百分比。

这是结果，正如你所看到的，90%的卷积、密集和批量规范层的权重被修剪。

| 名字 | 段落总计 | 修剪百分比 |
| conv2d _ 2/内核:0 | eight hundred | 89.12% |
| conv2d_2/bias:0 | Thirty-two | 0.00% |
| 批处理 _ 规范化 _ 1/伽玛:0 | Thirty-two | 0.00% |
| batch_normalization_1/beta:0 | Thirty-two | 0.00% |
| conv2d _ 3/内核:0 | Thirty-two | 0.00% |
| conv2d_3/bias:0 | Thirty-two | 0.00% |
| 密集 _ 2/内核:0 | Fifty-one thousand two hundred | 89.09% |
| 密集 _ 2/偏差:0 | Sixty-four | 0.00% |
| 密集 _ 3/内核:0 | Three million two hundred and eleven thousand two hundred and sixty-four | 89.09% |
| 密集 _ 3/偏差:0 | One thousand and twenty-four | 0.00% |
| batch _ normalization _ 1/移动平均值:0 | Ten thousand two hundred and forty | 89.09% |
| batch _ normalization _ 1/moving _ variance:0 | Ten | 0.00% |

现在，只需使用通用文件压缩算法(如 zip ), Keras 模型将缩小 5 倍。

这是你得到的，5 倍小的模型。

压缩前修剪模型的大小: 12.52 Mb
压缩后修剪模型的大小: 2.51 Mb

Convert Keras model to TensorFlow Lite

Tensorflow Lite 是一种可用于部署到移动设备的示例格式。要转换成 Tensorflow Lite 图形，需要使用如下的TFLiteConverter:

然后，您可以使用类似的技术来压缩tflite文件，并将大小缩小 x5 倍。

训练后量化将权重转换为 8 位精度，作为从 keras 模型到 TFLite 的平面缓冲区的模型转换的一部分，导致模型大小又减少了 4 倍。在调用convert()之前，只需将下面一行代码添加到前面的代码片段中。

与原始 Keras 模型的 12.52 Mb 相比，压缩的 8 位 tensorflow lite 模型仅占用 0.60 Mb，同时保持相当的测试精度。这完全是 x16 倍的尺寸缩减。

您可以像这样评估转换后的 TensorFlow Lite 模型的准确性，其中您向eval_model提供测试数据集。

结论和进一步阅读

在本教程中，我们向您展示了如何使用 TensorFlow 模型优化工具包权重修剪 API 创建稀疏模型。现在，这允许您创建占用磁盘空间少得多的模型。得到的模型也可以更有效地实现以避免计算；未来，TensorFlow Lite 将提供这样的功能。

*查看官方 TensorFlow 模型优化页面和他们的 GitHub 页面了解更多信息。

这篇文章的源代码可以在我的 Github 上获得，也可以在 Google Colab 笔记本上运行。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←如何在 Jupyter 笔记本内运行 PyTorch 1.1.0 的 Tensorboard】
• 如何使用 Efficientnet 进行迁移学习→*

如何将训练好的 Keras 模型转换为单个张量流？pb 文件并进行预测

原文：https://www.dlology.com/blog/how-to-convert-trained-keras-model-to-tensorflow-and-make-prediction/

发帖人:程维四年零一个月前

(评论)

您将一步一步地学习如何将您训练的 Keras 模型冻结并转换为单个 TensorFlow pb 文件。

与 TensorFlow 相比，Keras API 可能看起来不那么令人畏惧，而且更容易使用，特别是当您正在进行快速实验并使用标准图层构建模型时。而当您计划跨不同编程语言将模型部署到不同平台时，TensorFlow 更加通用。虽然有许多方法可以将 Keras 模型转换成它的 TenserFlow 对应物，但我将向您展示一种最简单的方法，您只需要在部署情况下使用转换后的模型进行预测。

这是将要涵盖的内容的概述。

• Keras to single TensorFlow .pb file
• 加载。用 TensorFlow 做 pb 文件并做预测。
• (可选)在 Jupyter 笔记本中可视化图形。

这篇文章的源代码可以在我的 GitHub 上找到。

Keras to TensorFlow .pb file

训练好 Keras 模型后，最好先将其保存为单个 HDF5 文件，以便在训练后将其加载回来。

如果您在使用包含批处理化层的模型(如 DenseNet)时遇到了“与预期资源不兼容”问题，请确保在新会话中加载 Keras 模型之前将学习阶段设置为 0。

然后，您可以加载模型并找到模型的输入和输出张量的名称。

如您所见，我们的简单模型只有单个输入和输出，而您的模型可能有多个输入/输出。

我们跟踪它们的名字，因为我们将在推断过程中通过名字在转换的张量流图中定位它们。

第一步是获得 TensorFlow 后端的计算图，它表示 Keras 模型，其中包括前向传递和训练相关的操作。

然后，该图将被转换为 GraphDef 协议缓冲区，之后，它将被修剪，从而移除计算所请求的输出(例如训练操作)所不需要的子图。这个步骤被称为冻结图形。

frozen_graph是一个序列化的 GraphDef 原型，我们可以使用下面的函数调用将其保存为一个二进制 pb 文件。

加载。pb 文件并进行预测

现在，我们有了所有需要预测的东西，图表保存为一个单一的。pb 文件。

要重新加载它，可以通过重启 Jupyter Notebook 内核或在新的 Python 脚本中运行来启动一个新的会话。

以下几行代码反序列化来自。pb 文件并将其恢复为默认图形到当前运行的 TensorFlow 会话。

找到输入张量，这样我们就可以用一些输入数据来填充它，并从输出张量中获取预测，我们将按名称获取它们。唯一不同的是，所有张量的名称都以字符串“import/”为前缀，因此输入张量现在是名为 "import/conv2d_1_input:0" 的，而输出张量是 "import/dense_2/Softmax:0" 。

要做一个预测，可以很简单，

predictions是在这种情况下的 softmax 值，shape (20，10)代表 20 个样本，每个样本具有 10 个类的 logits 值。

如果您的模型有多个输入/输出，您可以这样做。

在笔记本中可视化图形(可选)

你想知道模型冻结步骤对你的模型做了什么吗，比如哪些操作被删除了？

让我们通过加载 TensorBoard 的最小版本来显示图形结构，从而在 Jupyter 笔记本中并排比较这两个图形。

这里我包含了一个 show_graph.py 模块来允许你这样做。

您可以运行这个块两次，一次在 Keras 模型训练/加载之后，一次在加载和恢复之后。pb 文件，这里是结果。

列车图表:

冻结图表:

你可以很容易地看到相关的训练操作在冻结图中被删除。

结论和进一步阅读

您已经学习了如何将 Keras 模型转换为张量流。pb 文件仅用于推断目的。请务必在我的 GitHub 上查看这篇文章的源代码。

这里有一些相关的资源，你可能会觉得有帮助。

tensor flow 模型文件工具开发者指南

导出和导入元图

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←如何在 Python 3 中加载 Python 2 PyTorch 检查点
• 如何免费在 TPU 上更快地执行 Keras 超参数优化 x3→

如何为实例分割创建自定义 COCO 数据集

原文：https://www.dlology.com/blog/how-to-create-custom-coco-data-set-for-instance-segmentation/

发帖人:程维三年零五个月前

(评论)

在这篇文章中，我将向您展示使用 Google Colab 的 GPU 免费快速创建自定义 COCO 数据集和训练实例分割模型是多么简单。

如果你只是想知道如何为对象检测创建自定义 COCO 数据集，可以查看我的之前的教程。

实例分割不同于对象检测注释，因为它需要多边形注释而不是边界框。这里有很多免费的工具，比如 labelme 和 coco-annotator。 labelme 易于安装并在所有主流操作系统上运行，但是，它缺乏对导出 COCO 数据格式注释的原生支持，而这些注释是许多模型训练框架/管道所需要的。 coco-annotator ，另一方面，是一个基于 web 的应用程序，它需要额外的努力才能在您的机器上运行。这样一来最省力了？

这里概述了如何为实例分割创建自己的 COCO 数据集。

• 下载 labelme，运行应用程序并在图像上标注多边形。
• 运行我的脚本，将 labelme 注释文件转换为 COCO 数据集 JSON 文件。

用标签标注数据

labelme 和label mg在边界标注上颇为相似。所以任何熟悉 labelimg 的人，开始用 labelme 注释应该不会花太多时间。

你可以像下面这样安装 labelme，或者在发布版中找到预构建的可执行文件，或者下载我之前构建的最新的Windows 64 位可执行文件。

当你打开这个工具时，点击“打开目录”按钮，导航到你的图像文件夹，所有的图像文件都在这里，然后你就可以开始画多边形了。要画完一个多边形，按“Enter”键，工具会自动连接第一个和最后一个点。注释完一幅图像后，按键盘上的快捷键“D”将带您进入下一幅图像。我注释了 18 幅图像，每幅图像包含多个对象，花了我大约 30 分钟。

一旦对所有图像进行了注释，您就可以在 images 目录中找到一个具有相同基本文件名的 JSON 文件列表。这些是 labelimg 注释文件，我们将在下一步将它们转换成一个单独的 COCO 数据集注释 JSON 文件。(或者两个用于训练/测试分割的 JSON 文件。)

将 labelme 注释文件转换为 COCO 数据集格式

你可以在我的 GitHub 上找到 labelme2coco.py 文件。要应用转换，只需传入一个参数，即图像目录路径。

python labelme2coco.py images

该脚本依赖于三个 pip 包:labelme、numpy 和 pillow。如果您缺少其中的任何一个，请继续使用 pip 安装它们。执行完脚本后，你会发现当前目录下有一个名为trainval.json的文件，那就是 COCO 数据集标注 JSON 文件。

然后可选地，您可以通过打开COCO _ Image _ viewer . ipynbjupyter 笔记本来验证注释。

如果一切正常，它应该显示如下。

用 mmdetection 框架训练实例分割模型

如果你对 mmdetection 框架不熟悉，建议试试我之前的帖子——“如何用 mmdetection 训练一个物体检测模型”。该框架允许您通过同一管道使用可配置的主干网络训练许多对象检测和实例分割模型，唯一需要修改的是模型配置 python 文件，您可以在其中定义模型类型、训练时期、数据集的类型和路径等。例如分割模型，有几个选项可用，你可以用掩码 RCNN 或级联掩码 RCNN 和预训练的主干网络进行迁移学习。为了让初学者更加友好，只需使用免费的 GPU 资源在线运行Google Colab 笔记本，并下载最终的训练模型。笔记本和之前的物体检测演示挺像的，我就让你运行它玩玩吧。

下面是一个 mask RCNN 模型训练 20 个历元后的最终预测结果，训练时用了不到 10 分钟。

请随意尝试其他模型配置文件，或者通过增加训练时段来调整现有的模型配置文件，更改批处理大小，看看它如何改善结果。还要注意，为了演示数据集的简单性和小尺寸，我们跳过了训练/测试分割，您可以通过手动将 labelme JSON 文件分割成两个目录并为每个目录运行labelme2coco.py脚本来生成两个 COCO annotation JSON 文件。

结论和进一步阅读

训练实例分段可能看起来令人畏惧，因为这样做可能需要大量的计算和存储资源。但这并没有阻止我们用大约 20 张带注释的图片和 Colab 的免费 GPU 来创建一个。

你可能会发现有用的资源

我的 GitHub repo for thelabel me 2 COCO脚本，COCO image viewer 笔记本，以及我的演示数据集文件。

labelme Github repo 在这里你可以找到更多关于注释工具的信息。

笔记本你可以运行在 Google Colab 上训练一个 mmdetection 实例分割模型。

去 mmdetection GitHub repo 了解更多关于框架的信息。

我之前的帖子- 如何用 mmdetection 训练一个物体检测模型

• 标签:
• 教程、
• 深度学习

Share on Twitter Share on Facebook

• ←如何为对象检测创建自定义 COCO 数据集
• 如何在 Nvidia Docker 容器中的 Jetson Nano 上运行 Keras 模型→

如何创建用于对象检测的自定义 COCO 数据集

原文：https://www.dlology.com/blog/how-to-create-custom-coco-data-set-for-object-detection/

发帖人:程维三年零五个月前

(评论)

在之前的中，我们已经用 Pascal VOC 数据格式的自定义注释数据集训练了一个 mmdetection 模型。如果你的对象检测训练管道需要 COCO 数据格式，你就不走运了，因为我们使用的 labelImg 工具不支持 COCO 注释格式。如果你仍然想继续使用注释工具，然后将注释转换成 COCO 格式，这篇文章是为你准备的。

我们将首先简要介绍两种注释格式，然后介绍将 VOC 转换为 COCO 格式的转换脚本，最后，我们将通过绘制边界框和类标签来验证转换结果。

Pascal VOC 和 COCO 注释

Pascal VOC 注释保存为 XML 文件，每个图像一个 XML 文件。对于由 labelImg 工具生成的 XML 文件。它包含了<路径>元素中图像的路径。每个边界框都存储在一个<对象的>元素中，示例如下。

如你所见，边界框由两个点定义，左上角和右下角。

对于 COCO 数据格式，首先，一个数据集中的所有注释只有一个 JSON 文件，或者数据集的每个分割(Train/Val/Test)都有一个 JSON 文件。

包围盒表示为左上角的起始坐标和盒子的宽度和高度，和"bbox" :[x,y,width,height]一样。

这是一个 COCO 数据格式 JSON 文件的例子，它只包含一个图像，如在顶级“图像”元素中看到的，在顶级“类别”元素中看到的总共 3 个唯一的类别/类，以及在顶级“注释”元素中看到的图像的 2 个带注释的边界框。

将 Pascal VOC 转换为 COCO 注释

一旦你有了一些带注释的 XML 和图像文件，把它们放在类似下面的文件夹结构中，

data
 └── VOC2007
 ├── Annotations
 │ ├── 0.xml
 │ ├── ...
 │ └── 9.xml
 └── JPEGImages
 ├── 0.jpg
 ├── ...
 └── 9.jpg

然后你可以像这样从我的 GitHub 运行 voc2coco.py 脚本，这会为你生成一个 coco 数据格式的 JSON 文件。

python voc2coco.py ./data/VOC/Annotations ./data/coco/output.json

一旦我们有了 JSON 文件，我们就可以通过在图像上绘制边界框和类标签来可视化 COCO 注释。打开 Jupyter 笔记本中的 COCO_Image_Viewer.ipynb 。在笔记本中找到下面的单元格，它调用display_image方法在笔记本中生成 SVG 图。

第一个参数是图像 id，对于我们的演示数据集，总共有 18 个图像，因此您可以尝试将其设置为 0 到 17。

结论和进一步阅读

在这个快速教程中，您已经学习了如何坚持使用流行的 labelImg 进行自定义数据集注释，并在稍后将 Pascal VOC 转换为 COCO 数据集，以训练需要 COCO 格式数据集的对象检测模型管道。

您可能会发现以下链接很有用，

如何用 mmdetection 训练一个对象检测模型——我之前的帖子关于创建自定义 Pascal VOC 注释文件，用 PyTorch mmdetection 框架训练一个对象检测模型。

COCO 数据格式

Pascal VOC 文档

下载 labelImg 用于边界框注释。

获取这篇文章的源代码，查看我的 GitHub 报告。

• 标签:
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←如何用 mmdetection 训练物体检测模型
• 如何为实例分割创建自定义 COCO 数据集→

如何处理 Keras 中的消失/爆炸渐变

原文：https://www.dlology.com/blog/how-to-deal-with-vanishingexploding-gradients-in-keras/

发帖人:程维四年零九个月前

(评论)

如果你已经训练了你的深度学习模型一段时间，并且它的准确率仍然相当低。你可能想检查它是否正在遭受消失或爆炸梯度。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←如何免费快速运行视频中的对象检测和分割
• 设置 Keras 深度学习框架和构建旅游推荐引擎的温和指南(第一部分)→

如何用贝叶斯优化进行 Keras 模型的超参数搜索

原文：https://www.dlology.com/blog/how-to-do-hyperparameter-search-with-baysian-optimization-for-keras-model/

发帖人:程维三年零九个月前

(评论)

与网格搜索和随机搜索等更简单的超参数搜索方法相比，贝叶斯优化建立在贝叶斯推理和高斯过程的基础上，试图以尽可能少的迭代次数找到未知函数的最大值。它特别适合于优化高成本函数，如深度学习模型的超参数搜索，或其他探索和利用之间的平衡很重要的情况。

我们要用的贝叶斯优化包是 BayesianOptimization ，可以用下面的命令安装，

pip install bayesian-optimization

首先，我们将指定要优化的函数，在我们的例子中是超参数搜索，该函数将一组超参数值作为输入，并输出贝叶斯优化器的评估精度。在该函数中，将使用指定的超参数构建一个新模型，对多个时期进行训练，并根据一组指标进行评估。每个新评估的准确度将成为贝叶斯优化器的新观察，其有助于下一次搜索超参数的值。

让我们首先创建一个助手函数，它用各种参数构建模型。

然后，这里是要用贝叶斯优化器优化的函数，部分函数负责两个参数-fit_with中的input_shape和verbose，它们在运行时具有固定值。

该函数采用两个超参数进行搜索，即“dropout_2”层的辍学率和学习率值，它为 1 个时期训练模型，并输出贝叶斯优化器的评估精度。

****贝叶斯优化对象将开箱即用，无需太多调整。构造函数接受要优化的函数以及要搜索的超参数的边界。您应该知道的主要方法是maximize，它完全按照您的想法工作，在给定超参数的情况下最大化评估精度。

**这里有许多您可以传递给maximize的参数，然而，最重要的是:

• n_iter:你要执行多少步贝叶斯优化。步数越多，你就越有可能找到一个好的最大值。
• init_points:你要执行多少步的随机探索。随机探索有助于探索空间的多样化。

|   iter    |  target   | dropou... |    lr     |
-------------------------------------------------
468/468 [==============================] - 4s 8ms/step - loss: 0.2575 - acc: 0.9246
Test loss: 0.061651699058711526
Test accuracy: 0.9828125
|  1        |  0.9828   |  0.2668   |  0.007231 |
468/468 [==============================] - 4s 8ms/step - loss: 0.2065 - acc: 0.9363
Test loss: 0.04886047407053411
Test accuracy: 0.9828125
|  2        |  0.9828   |  0.1      |  0.003093 |
468/468 [==============================] - 4s 8ms/step - loss: 0.2199 - acc: 0.9336
Test loss: 0.05553104653954506
Test accuracy: 0.98125
|  3        |  0.9812   |  0.1587   |  0.001014 |
468/468 [==============================] - 4s 9ms/step - loss: 0.2075 - acc: 0.9390
Test loss: 0.04128134781494737
Test accuracy: 0.9890625
|  4        |  0.9891   |  0.1745   |  0.003521 |

经过 4 次搜索，用找到的超参数建立的模型仅用一个历元的训练就达到了 98.9%的评估精度。

与其他搜索方法相比

与在有限数量的离散超参数组合中进行搜索的网格搜索不同，高斯过程的贝叶斯优化本质不允许以简单/直观的方式处理离散参数。

例如，我们想从选项列表中搜索一个密集层的神经元数目。为了应用贝叶斯优化，有必要在构建模型之前将输入参数显式地转换为离散参数。

你可以这样做。

在构建模型之前，密集层神经元将被映射到 3 个唯一的离散值，128、256 和 384。

在贝叶斯优化中，每下一个搜索值依赖于以前的观测值(以前的评估精度)，整个优化过程可能很难像网格或随机搜索方法那样分布式或并行化。

结论和进一步阅读

这个快速教程介绍了如何使用贝叶斯优化进行超参数搜索，与网格或随机等其他方法相比，它可能更有效，因为每次搜索都是从以前的搜索结果中"引导的。

一些你可能会觉得有用的材料

贝叶斯优化——本教程中使用的高斯过程全局优化的 Python 实现。

如何在 TPU 上更快地免费执行 Keras 超参数优化 x3——我之前的关于用 Colab 的免费 TPU 执行网格超参数搜索的教程。

在我的 GitHub 上查看完整的源代码。

• 标签:
• keras ,
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←如何在 Jupyter 笔记本中运行 tensor board
• 如何在 Jetson Nano 上运行 Keras 模型→****

如何从 Keras 中的图像文件进行混音训练

原文：https://www.dlology.com/blog/how-to-do-mixup-training-from-image-files-in-keras/

发帖人:程维 3 年 11 个月前

(评论)

之前，我们在 Keras 中介绍了一系列技巧来提高卷积网络的图像分类性能，这一次，我们将更仔细地看看最后一个叫做 mixup 的技巧。

什么是mix训练？

论文混音:BEYONDE经验性的RISKM去伪化为缩放和旋转等传统的图像增强技术提供了替代方案。B y 通过两个现有示例的加权线性插值形成新示例。

(x[I]；y[I])(x[j]；y[j])是从我们的训练数据中随机抽取的两个例子，λ∈【0； 1】，实际中 λ是从贝塔分布中随机抽样的，即 贝塔(α；α ) 。

【α∈【0。1； 0。【4】导致性能提高，较小的 α产生较少的混合效应，反之，对于较大的 α 、导致欠拟合。

正如您在下图中看到的，给定一个小的α = 0.2 ，beta 分布采样更多更接近 0 和 1 的值，使得混合结果更接近两个示例中的任何一个。

混搭训练有什么好处？

虽然像 Keras ImageDataGenerator 类中提供的那些传统的数据扩充一直导致改进的泛化，但是该过程依赖于数据集，因此需要使用专家知识。

此外，数据扩充并不对不同类别的实例之间的关系进行建模。

反之，

• Mixup 是一个数据不可知的数据扩充例程。
• 它使决策边界从一个类线性过渡到另一个类，提供了更平滑的不确定性估计。
• 它减少了对腐败标签的记忆，
• 增加了对对抗实例的鲁棒性， 稳定了生成对抗网络的训练。

Keras 中的 Mixup 图像数据生成器

试图给 mixup 一个旋转？让我们实现一个图像数据生成器，它从文件中读取图像，并开箱即用Kerasmodel.fit_generator()。

混合生成器的核心由一对迭代器组成，这些迭代器从目录中随机抽取图像，一次一批，混合在__next__方法中执行。

然后，您可以创建用于拟合模型的训练和验证生成器，请注意，我们在验证生成器中没有使用 mixup。

我们可以用 Jupyter 笔记本中的以下片段来可视化一批混淆的图像和标签。

下图说明了 mixup 的工作原理。

结论和进一步的想法

你可能认为一次混合两个以上的例子可能会导致更好的训练，相反，三个或更多个例子的组合与从β分布的多元泛化中采样的权重并不能提供进一步的增益，而是增加了 混合的计算成本。此外，仅在具有相同标号的输入之间进行插值不会导致的性能增益。T12

在我的 Github 上查看完整的源代码。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←Keras 中卷积神经网络图像分类的锦囊妙计
• 如何利用 CPU 和英特尔 OpenVINO 将 Keras 模型推理运行速度提高 x3 倍→

新闻类别如何做多类多标签分类

原文：https://www.dlology.com/blog/how-to-do-multi-class-multi-label-classification-for-news-categories/

发布者:程维五年零一个月前

(评论)

我的上一篇展示了如何为不同的任务选择最后一层激活和损失函数。本帖我们重点关注多类多标签分类。

任务概述

我们将使用路透社-21578 新闻数据集。对于给定的新闻，我们的任务是给它一个或多个标签。数据集分为五个主要类别:

• 主题
• 地方
• 人
• 组织
• 交换

例如，一个给定的新闻可能有属于两个类别的 3 个标签

• 地点:美国，中国
• 主题:贸易

代码的结构

• Prepare documents and categories

  1. 读取类别文件，从这 5 个类别中获取所有可用的 672 个标签。

  2. 阅读所有的新闻文件，并找出我们将用于分类的 672 个标签中最常见的 20 个。这是这 20 个标签的列表。为了清楚起见，每一个都以其类别为前缀。例如“pl _ USA”表示标签“地点:美国”，“T4”【to _ trade】是“主题:贸易”等。类型 新闻专线 地方 六百零一地方 主题 第八百零一章 主题 主题 地方 主题 至 _ 兴趣 主题 地方 地方 主题 主题 地方 主题 地方

     名字

     第六百一十九章

     三十五

     零

     十六

     五百四十二

     四百八十九

     第七十三章

     二十八

     第四十五

     第六百二十五章

     第一百二十六章

     五十五

     第五百一十四章

     第四百一十二章

     第四百八十一

     一百三十

     一百零八

     四百六十八

     十九

     第四百九十五

• Clean up the data of the model

在前面的步骤中，我们读取新闻内容并存储在一个列表中

一则新闻是这样的

average yen cd rates fall in latest week
    tokyo, feb 27 - average interest rates on yen certificates
of deposit, cd, fell to 4.27 pct in the week ended february 25
from 4.32 pct the previous week, the bank of japan said.
    new rates (previous in brackets), were -
    average cd rates all banks 4.27 pct (4.32)
    money market certificate, mmc, ceiling rates for the week
starting from march 2          3.52 pct (3.57)
    average cd rates of city, trust and long-term banks
    less than 60 days          4.33 pct (4.32)
    60-90 days                 4.13 pct (4.37)
    average cd rates of city, trust and long-term banks
    90-120 days             4.35 pct (4.30)
    120-150 days            4.38 pct (4.29)
    150-180 days            unquoted (unquoted)
    180-270 days            3.67 pct (unquoted)
    over 270 days           4.01 pct (unquoted)
    average yen bankers' acceptance rates of city, trust and
long-term banks
    30 to less than 60 days unquoted (4.13)
    60-90 days              unquoted (unquoted)
    90-120 days             unquoted (unquoted)
 reuter

我们开始清理工作

• 只接受 A-Za-z0-9 中的字符
• 删除停用词(如“in”、“on”、“from”等实际上不包含任何特殊信息的词)
• 词汇化(例如，将单词“rates”变成“rate”)

在这之后，我们的新闻将会看起来更加“友好”,每个单词都用空格隔开。

average yen cd rate fall latest week tokyo feb 27 average interest rate yen certificatesof deposit cd fell 427 pct week ended february 25from 432 pct previous week bank japan said new rate previous bracket average cd rate bank 427 pct 432 money market certificate mmc ceiling rate weekstarting march 2 352 pct 357 average cd rate city trust longterm bank le 60 day 433 pct 432 6090 day 413 pct 437 average cd rate city trust longterm bank 90120 day 435 pct 430 120150 day 438 pct 429 150180 day unquoted unquoted 180270 day 367 pct unquoted 270 day 401 pct unquoted average yen banker acceptance rate city trust andlongterm bank 30 le 60 day unquoted 413 6090 day unquoted unquoted 90120 day unquoted unquoted reuter

因为即使在清理之后，一小部分新闻仍然很长，让我们将最大输入序列限制为 88 个单词，这将覆盖 70%的完整长度的新闻。我们可以设置更大的输入序列限制来覆盖更多的新闻，但这也将增加模型训练时间。

最后，我们将把单词转换成 id 的形式，如果它更短，就把序列填充到输入限制(88)中。

Keras 文本处理使这变得微不足道。

同样的新闻会是这样的，每个数字代表词汇表中唯一的一个词。

array([ 6943,     5,  5525,   177,    22,   699, 13146,  1620,    32,
       35130,     7,   130,  6482,     5,  8473,   301,  1764,    32,
         364,   458,   794,    11,   442,   546,   131,  7180,     5,
        5525, 18247,   131,  7451,     5,  8088,   301,  1764,    32,
         364,   458,   794,    11, 21414,   131,  7452,     5,  4009,
       35131,   131,  4864,     5,  6712, 35132,   131,  3530,  3530,
       26347,   131,  5526,     5,  3530,  2965,   131,  7181,     5,
        3530,   301,   149,   312,  1922,    32,   364,   458,  9332,
          11,    76,   442,   546,   131,  3530,  7451, 18247,   131,
        3530,  3530, 21414,   131,  3530,  3530,     3])

• Create and train a model

• 嵌入层嵌入大小为 256 的向量序列

• 处理序列数据的 GRU 层(递归网络)

• 密集层输出 20 个类别的分类结果

• Visualize training performance

在大约 5 分钟内对我们的模型进行 10 个时期的训练后，我们获得了以下结果。

loss: 0.1062 - acc: 0.9650 - val_loss: 0.0961 - val_acc: 0.9690

下面的代码将生成一个漂亮的图形来可视化每个训练时期的进度。

• Make a prediction

将一个清理过的新闻(每个单词由空格分隔)放入同一个输入标记器，将其转换为 ids。

调用模型预测方法，输出将是 20 个浮点数的列表，表示这 20 个标签的概率。为了演示的目的，让我们取任何概率大于 0.2 的标签。

这产生了三个标签

pl_uk
pl_japan
to_money-fx

事实是

pl_japan
to_money-fx
to_interest

对于给定的新闻，模型得到了 3 分之 2 的正确答案。

总结

我们从清理模型输入的原始新闻数据开始。构建了一个 Keras 模型做多类多标签分类。将训练结果可视化并进行预测。还可以做进一步的改进

• 更好地清理数据
• 使用更长的输入序列限制
• 更多训练时期

如果你感兴趣，可以在我的 GitHubrepo 上找到 jupyter 笔记本的源代码。

• 标签:
• 情感分析

Share on Twitter Share on Facebook

• ←如何选择最后一层激活和丢失功能
• 使用 Keras 模型构建新张量流数据集和估算器的简单指南→

如何利用生成对抗网络在 Keras 中进行新颖性检测(下)

原文：https://www.dlology.com/blog/how-to-do-novelty-detection-in-keras-with-generative-adversarial-network-part-2/

发帖人:程维四年零三个月前

(评论)

前一部分介绍了用于新奇检测的 ALOCC 模型如何工作，以及一些关于 autoencoder 和 GANs 的背景信息，在本文中，我们将在 Keras 中实现它。

建议在继续之前对模型的工作原理有一个大致的了解。这里可以阅读第一部分， 如何用生成对抗网络在 Keras 中做新颖性检测(第一部分)

从 我的 GitHub 下载源代码。

建立模型

我们从上图所示的 R 网络开始。该模型在 Keras functional API 中实现。

一些值得一提的要点。

• 为了提高网络的稳定性，我们在这个网络中使用步长卷积而不是池层。
• 在每一个卷积层之后，利用批量归一化操作，这增加了我们的结构的稳定性。要了解更多，你可以参考我专门针对该主题的帖子，一个用批量归一化更快训练 Keras 模型的简单技巧。
• 采用 UpSampling层代替Conv2DTranspose层，减少产生的伪影，使输出形状更具确定性。
• 我们建议使用LeakyReLU层代替ReLU激活层。它类似于 ReLU，但是它通过允许较小的负激活值来放松稀疏性约束。

D 或鉴别器的架构是一系列卷积层，这些卷积层被训练以最终在没有任何监督的情况下区分新样本或异常样本。

D 网络 输出一个单浮点数范围在 0~1 之间相对于输入属于目标类的可能性。

训练模型

为了简单和可再现的原因，我们选择教导模型将标记为“1”的 MNIST 手写数字识别为目标或正常图像，而模型将能够在测试阶段将其他数字区分为新奇/异常。

我们以对抗的程序训练R+D神经网络。

在训练 D 网络时，将重构图像和原始图像作为输入，它们的输出分别标记为 0 和 1。d 网络通过最小化这两种类型数据的binary_crossentropy损失来学习辨别真实图像和生成图像。

在训练 R 网络时，将从标准偏差采样的统计噪声添加到输入中，以使 R 对输入图像中的噪声和失真具有鲁棒性。这就是上图中的 η 所代表的意思。R 被训练以共同减少重构损失和“愚弄 R 网络以输出目标类”损失。有一个权衡超参数控制这两个术语的相对重要性。

下面的代码构造并连接鉴别器和生成器模块。

注意，在编译组合adversarial_model之前，我们将鉴别器的权重设置为不可训练，因为对于组合模型，我们只想训练生成器，您很快就会发现这一点。不会妨碍已经编译好的鉴别器模型进行训练。另外，self.r_alpha是一个小浮点数，用于权衡两个发电机/R 网络损耗的相对重要性。

随着模型的构建和编译，我们可以开始训练。

首先，仅提取 MNIST 训练集中的“1 ”,将统计噪声应用于发电机/ R 输入的“1”的副本。

下面是训练一批数据的代码。首先在具有不同输出标签的真实和生成的图像上训练 3d 网络。

然后 R 网络对同一批有噪数据进行两次训练，使其损失最小。

输出g_loss变量的最后一个提示，由于组合的adversarial_model是具有两个损失函数且没有附加度量的compiled，g_loss将是 3 个数字的列表，[total_weighted_loss, loss_1, loss_2]，其中loss_1是重建损失，loss_2是“愚弄 R 网络损失”。训练 GAN 网络的时间越长，通常会产生更好的结果，而在我们的情况下，过早地使 s 超过训练会导致学习到的网络权重不成熟，而过度训练网络会使 R 网络 混乱，并产生不期望的输出。我们必须定义一个合适的训练停止标准。

作者提出当 R 能够以最小误差重构其输入时，训练过程停止 ，这可以通过跟踪loss_1/重构损失来监控。

新颖性检测

下图显示了 5 个时段的训练阶段期间的 R 网络重建损失，看起来重建损失在时段 3 结束时达到其最小值，因此让我们使用在时段 3 之后保存的模型权重来进行我们的新颖性检测。您可以从我的 GitHub 资源库下载并运行测试阶段 Jupyter notebooktest . ipynb。

我们可以测试重建损耗和鉴频器输出。新/异常图像具有较大的重建损失和较小的鉴别器输出值，如下所示。其中手写“1”的图像为目标，其他数字为新奇/异常情况。

结论和进一步阅读

我们介绍了如何使用生成对抗网络和编码-解码网络在 Keras 中构建一个新奇检测 ALOCC 模型。

查看原文:【https://arxiv.org/abs/1802.09088】T2。

下面是 Quora 上一个有趣的问题&关于 GAN 是否可以做异常/新奇检测，由 GAN 的创造者 Ian Goodfellow 回答。

别忘了从 my GitHub 下载源代码。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←如何用生成对抗网络进行 Keras 中的新颖性检测(上)
• 如何使用 Keras 稀疏分类交叉熵→

如何利用生成对抗网络在 Keras 中进行新颖性检测(上)

原文：https://www.dlology.com/blog/how-to-do-novelty-detection-in-keras-with-generative-adversarial-network/

发帖人:程维四年零三个月前

(评论)

新颖性检测的任务是对测试数据进行分类，这些测试数据在某些方面不同于训练期间可用的数据。这可以被视为“一类分类”，其中构建模型来描述“正常的”训练数据。当可用的“异常”数据的数量不足以构建非正常类的显式模型时，通常使用新颖性检测方法。应用程序包括来自关键系统的数据集中的推断，其中可用的正态数据的数量是巨大的，使得“正态性”可以被精确地建模。

这些包括医疗诊断问题的检测、复杂工业系统中的故障和失效检测、结构损坏、电子安全系统中的入侵，例如信用卡或移动电话欺诈检测、视频监控、移动机器人、传感器网络、天文目录和文本挖掘。

在本系列教程中，我将向您展示如何使用 Keras 框架实现一个用于新颖性检测的生成式对抗网络。第 1 部分介绍了该模型的一般工作原理，而第 2 部分介绍了 Keras 的实现。

模型结构

我们要建立的模型被命名为对抗学习单类分类器或简称为 ALOCC，如我的源代码所示。下图显示了该模型包含一个连接到 CNN 分类器的自动编码器，作为您可能在 GAN 中听说过的鉴别器。在继续之前，让我们快速回顾一下这两种独立的网络架构。

自动编码器回顾

Autoencoder 是一种数据压缩算法，有两个主要部分，编码器和解码器。

编码器的工作是将输入数据压缩成低维特征。例如，28x28 MNIST 图像的一个样本总共有 784 个像素，我们构建的编码器可以将其压缩到一个只有 10 个浮点数的数组，也称为图像的特征。另一方面，解码器部分将压缩的特征作为输入，并重建尽可能接近原始图像的图像。Autoencoder 本质上是一种无监督学习算法，因为在训练过程中，它只需要图像本身，而不需要标签。由于它是一种无监督的学习算法，所以它可以用于未标记数据的聚类，正如我在以前的帖子如何使用 Keras 进行无监督聚类中看到的那样。

以前的，对来自目标类的样本进行训练的自动编码器的重构误差，已经被证明是新颖样本检测的有用度量。

甘评

虽然 GANs 非常高级，对初学者来说可能看起来令人生畏，但我发现新手画家(生成器)和新手鉴赏家(鉴别器)的类比很容易理解。

两个雄心勃勃的人，一个画家和一个鉴赏家，正在向艺术行业迈出第一步。画家想哄骗鉴赏家给自己的画尽可能高的评分，而鉴赏家则想尽可能准确地辨别好画和坏画。所以他们一遍又一遍地重复这三个步骤，玩一个无限的游戏。

1. 画家根据自己以前的经验和鉴赏家的反馈(如果有的话)画了几幅画。
2. **鉴赏家学会分辨好的(例如梵高的杰作)和坏的(画家的画)。
   *** 画家学会欺骗鉴赏家，让他给自己的画打分，和梵高的一样好——这里鉴别器网络(鉴赏家)权重被冻结，只训练生成器(画家)。

**经过数百甚至数千轮的相互竞争后，新手画家变成了印刷大师，他的画几乎与梵高的画不可同日而语，而新的鉴赏家变成了专家，他能以无与伦比的精确度从成吨的复制品中识别出真正的真迹。

这个比喻告诉我们，在 GAN 中有两个独立的网络，生成器和鉴别器，它们被分别训练以最小化它们的损失，同时对抗性地改进彼此。

模型——对抗式学习单类量词

与 GANs 类似，所提出的体系结构包括两个模块，这两个模块在相互协作完成检测任务的同时竞争学习。

表示为 R 的第一模块或重建模块看起来类似于自动编码器，同时被对抗性地训练以联合最小化两个损失函数，

1. 正常输入的重建损失，重建的数据尽可能接近输入。
2. 诱骗鉴别器预测 其生成的图像为真实图像，即诱骗鉴别器输出类别标签一。

表示为 D 或鉴别器的第二模块学习区分原始的正常的(类别标签 1)样本和重建的样本(类别标签 0)。

R 学会有效地重构正态样本，而对于负样本或新样本，它不能准确地重构输入，因此，对于负样本，它充当抽取器或非正式地充当失真器。

在测试阶段，D 充当实际的新奇检测器，而 R 通过充分重构阳性或目标样本以及抽取(或扭曲)任何给定的阴性或新奇样本来提高检测器的性能。

结论和进一步阅读

在这篇文章中，我们介绍了对抗性学习的一类分类器，首先快速回顾了两个紧密相关的模型结构，auto-encoder 和 GAN，然后介绍了我们将在下一篇文章中使用 Keras 实现的主要模型架构。

我的 Keras 实现很大程度上受作者论文https://arxiv.org/abs/1802.09088的影响

准备好真正的 Keras 实现了吗？继续下一部分 如何用生成对抗网络在 Keras 中做新颖性检测(下)

• 标签:
• keras ,
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←如何使用 Keras TimeseriesGenerator 处理时序数据
• 如何利用生成对抗网络在 Keras 中进行新颖性检测(下)→**

如何使用 Keras 进行实时触发词检测

原文：https://www.dlology.com/blog/how-to-do-real-time-trigger-word-detection-with-keras/

发帖人:程维 4 年 10 个月前

(评论)

这周刚完成 Coursera 深度学习在线课程。最后一个编程作业是关于触发字检测，又名。唤醒/热词检测。就像你对着亚马逊 Alexa 或者 Google Home 大喊大叫把他们吵醒一样。

自己造一个然后在实时运行会不会很酷？

在这篇文章中，我将向您展示如何构建一个 Keras 模型来从头开始做同样的事情。不需要第三方语音 API 或网络连接来使其正常工作。

Coursera 课程中展示了大量的背景信息。如果你是新手，不要担心，我将有一个足够的概述，让你明白接下来会发生什么。

准备训练数据集

为了简单起见，我们把单词“激活作为我们的触发词。

训练数据集需要尽可能与真实的测试环境相似。例如，在训练期间，模型需要暴露于语音中的非触发单词和背景噪声，因此当我们说其他单词或只有背景噪声时，它不会生成触发信号。

如你所料，训练一个好的语音模型需要大量的带标签的训练样本。我们是否只需记录每段音频并标记触发词的位置？这里有一个简单的窍门来解决这个问题。

我们创造了它们！

首先，我们有三种录音，

1.不同背景的录音。它们可能只是简单的两个背景噪音片段，每个 10 秒钟，咖啡店和起居室。

2.触发词“激活”的录音。他们可能只是你用不同的语调把这个词说了 10 遍，每次 1 秒钟。

3.负面词汇的录音。他们可能是你在说其他的词，比如“宝贝”，“咖啡”，每段录音一秒钟。

这是生成训练输入音频剪辑的步骤，

• 随机选取一个 10 秒钟的背景音频剪辑
• 随机叠加 0-4 个“激活”的音频片段到这个 10 秒的片段中
• 随机叠加 0-2 个负面词汇的音频片段到这个 10 秒的片段中

我们选择叠加,因为我们想把口语和背景噪音混合起来，听起来更真实。

对于输出标签，我们希望它表示某人是否刚刚说完“激活”。

我们首先将输出标签的所有时间步长初始化为“0”。然后，对于我们覆盖的每个“激活”,我们还通过将后续的 50 个时间步长分配为“1”来更新目标标签。

为什么我们有 50 个时间步长“1”？

因为如果我们只在“激活”之后设置 1 个时间步长为“1”，那么目标标签中会有太多的 0。它创建了一个非常不平衡的训练集。

拥有 50 个“1”有点麻烦，但可以让他们更容易训练模型。这里有一幅插图向你展示这个想法。

学分:Coursera - deeplearning.ai

对于我们插入了“激活”、“无辜”、“激活”、“宝贝”的片段。请注意，阳性标签“1”仅与阳性单词相关联。

绿色/蓝色图是声谱图，是声波随时间变化的频率表示。x 轴是时间，y 轴是频率。颜色越黄/亮，特定频率越活跃(响亮)。

我们的输入数据将是每个生成音频的声谱图数据。目标将是我们之前创建的标签。

建立模型

没有进一步的预定，让我们来看看模型结构。

1D 卷积步长输入频谱图的 5511 时间步长(10 秒)，输出 1375 步长输出。它提取低级音频特征，类似于 2D 卷积提取图像特征的方式。还通过减少时间步长的数量来帮助加速模型。

两个 GRU 层从左到右读取输入序列，最终使用密集的+乙状结肠层进行预测。乙状结肠使每个标签的范围在 0~1 之间。为 1，对应刚才用户说“激活”。

这里是 Keras 的 functional API 中用写的代码。

触发词检测需要很长时间的训练。为了节省时间，Coursera 已经使用上面显示的架构和大约 4000 个例子的大型训练集，在 GPU 上训练了一个模型大约 3 个小时。让我们加载模型。

实时演示

到目前为止，我们的模型只能拍摄 10 秒钟的静态音频片段，并预测触发词的位置。

有趣的部分来了，我们换成现场音频流吧！

我们建立的模型期望 10 秒钟的音频剪辑作为输入。而训练另一个需要较短音频剪辑的模型是可能的，但需要我们在 GPU 上重新训练模型几个小时。

我们也不想等待 10 秒钟，因为模型会告诉我们触发词已被检测到。因此，一种解决方案是设置一个移动的 10 秒音频流窗口，步长为 0.5 秒。这意味着我们要求模型每 0.5 秒预测一次，这样可以减少延迟并提高响应速度。

我们还添加了静音检测机制，以便在响度低于阈值时跳过预测，这可以节省一些计算能力。

让我们看看如何构建它，

输入的 10 秒音频每 0.5 秒更新一次。这意味着每 0.5 秒，最老的 0.5 秒音频块将被丢弃，新的 0.5 秒音频将被移入。该模型的工作是判断在新的 0.5 秒音频块中是否检测到新的触发字。

这是实现它的代码。

为了获得音频流，我们使用了 pyaudio 库。其具有异步读取音频流的选项。这意味着音频流记录发生在另一个线程中，当新的固定长度的音频数据可用时，它通知我们的模型在主线程中处理它。

你可能会问为什么不直接读取固定长度的音频，然后在一个函数中进行处理呢？

由于模型生成预测需要相当长的时间，有时需要几十毫秒。这样做的话，我们在进行计算时，可能会在音频流中产生间隙。

下面是 pyaudio 库的回调代码，在回调函数中我们发送一个队列通知模型在主线程中处理数据。

当你运行它时，它每 0.5 秒输出 3 个字符中的一个。

“-”表示沉默，

"."意味着不是沉默和没有触发词，

“1”表示检测到新的触发字。

--.--......-1----.-..--...-1---..-------..1---------..-1---------.----.--------.----.---.--.-.------------.

当检测到触发字时，您可以随意将打印“1”字符替换为您希望发生的任何事情。启动应用程序，播放声音等。

总结和进一步阅读

本文演示了如何使用 Keras 深度学习框架从头开始构建一个实时触发词检测器。

以下是你应该记住的:

• 数据合成是为语音问题创建大型训练集的有效方法，特别是触发单词检测。
• 在将音频数据传送到 RNN、GRU 或 LSTM 之前，使用声谱图和可选的 1D conv 层是常见的预处理步骤。
• 可以使用端到端深度学习方法来构建非常有效的触发词检测系统。
• 深度学习模型预测需要时间。它异步处理来自输入音频流的音频数据,以避免中断音频流。
• 滑动/移动输入窗口是减少延迟的有效方法。

延伸阅读

嘿 Siri:苹果个人助理的 DNN 语音触发装置

触发词检测讲座- Coursera

现在，从 my GitHub repo 获取完整的源代码，构建一个令人敬畏的触发字应用程序。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←如何使用 Keras 生成真实的 yelp 餐厅评论
• 如何利用深度学习诊断电机的健康状况→

如何使用 Keras 进行无监督聚类

原文：https://www.dlology.com/blog/how-to-do-unsupervised-clustering-with-keras/

发帖人:程维 4 年 7 个月前

(评论)

深度学习算法擅长将输入映射到给定标记数据集的输出，这要归功于其表达非线性表示的非凡能力。这种任务被称为分类，而有人必须标记这些数据。无论是标记 x 射线图像还是新闻报道的主题，它都依赖于人的干预，并且随着数据集变大，成本会变得相当高。

聚类分析或聚类是一种不需要标记数据的无监督机器学习技术。它通过相似性对数据集进行分组来做到这一点。

为什么您应该关注聚类或聚类分析？让我给你看一些想法。

聚类的应用

• 推荐系统，通过学习用户的购买历史，聚类模型可以通过相似性对用户进行细分，帮助你找到志同道合的用户或相关产品。
• 在生物学中，序列聚类算法试图将有某种关联的生物序列分组。蛋白质根据它们的氨基酸含量进行分类。
• 图像或视频聚类分析，根据相似性将它们分组。
• 在医学数据库中，每个患者对于特定测试(例如，葡萄糖、胆固醇)可能具有不同的实值测量。首先对患者进行聚类可以帮助我们理解应该如何对实值特征进行宁滨，以减少特征稀疏性并提高分类任务(如癌症患者的生存预测)的准确性。
• 一般用例，为分类、模式发现、假设生成和测试生成一个简洁的数据摘要。

无论如何，聚类对于任何数据科学家来说都是一项宝贵的资产。

什么是好的集群

一个好的聚类方法将产生高质量的聚类，这些聚类应该具有:

• 类内相似性高:在类内具有内聚性
• 低类间相似性:聚类之间有区别

用 K 均值设定基线

传统的 K-means 算法速度快，适用范围广。然而，它们的距离度量被限制在原始数据空间，并且当输入维数很高时，例如图像，它往往是无效的。

让我们训练一个 K-Means 模型来将 MNIST 手写数字聚类成 10 个簇。

评估的 K-Means 聚类精度为 53.2% ，稍后我们将与我们的深度嵌入聚类模型进行比较。

我们即将介绍的模型由几个部分组成:

• 一个自动编码器，被预先训练以学习未标记数据集的初始压缩表示。
• 堆叠在编码器上的群集层，用于将编码器输出分配给群集。聚类层的权重基于当前评估用 K-Means’聚类中心初始化。
• 训练聚类模型以联合改进聚类层和编码器。

寻找源代码？拿到我的 GitHub 上。

预训练自动编码器

Autoencoder 是一种数据压缩算法，其中有两个主要部分，编码器和解码器。编码器的工作是将输入数据压缩到较低的维度特征。例如，28x28 MNIST 图像的一个样本总共有 784 个像素，我们构建的编码器可以将其压缩到一个只有 10 个浮点数的数组，也称为图像的特征。另一方面，解码器部分将压缩的特征作为输入，并重建尽可能接近原始图像的图像。Autoencoder 本质上是一种无监督学习算法，因为在训练过程中，它只需要图像本身，而不需要标签。

我们建立的自动编码器是一个完全连接的对称模型，对称于图像如何以完全相反的方式压缩和解压缩。

我们将为 300 个时期训练自动编码器，并为以后保存模型权重。

聚类模型

通过训练 autoencoder，我们让它的编码器部分学会了将每张图像压缩成十个浮点值。你可能会想，既然输入维数减少到 10，K-Means 应该能够从这里进行聚类？是的，我们将使用 K-Means 来生成聚类质心，这是 10 维特征空间中的 10 个聚类的中心。但是我们还将构建我们的自定义聚类层，以将输入要素转换为聚类标签概率。

概率由学生的 t 分布计算得出。与 t-SNE 算法中使用的相同，t-分布测量嵌入点和质心之间的相似性。正如您可能猜到的那样，聚类层的作用类似于 K-means 聚类，层的权重表示可以通过训练 K-means 来初始化的聚类质心。

如果你是第一次使用在 Keras 中构建定制层，有三个方法是你必须实现的。

• build(input_shape)，定义层的权重，在我们的例子中是 10 维特征空间中的 10 个簇，即 10x10 个权重变量。
• 层逻辑存在的地方，也是从特性到聚类标签的神奇映射发生的地方。
• compute_output_shape(input_shape)，在此指定从输入形状到输出形状的形状转换逻辑。

下面是自定义聚类层代码，

接下来，我们在预训练的编码器之后堆叠一个聚类层，以形成聚类模型。对于聚类层，我们正在初始化其权重，聚类中心使用 k-means 对所有图像的特征向量进行训练。

训练聚类模型

辅助目标分布和 KL 发散损失

下一步是同时改进聚类分配和特征表示。为此，我们将定义基于质心的目标概率分布，并最小化其相对于模型聚类结果的 KL 散度。

我们希望目标分布具有以下属性。

• 加强预测，即提高聚类纯度。
• 更加重视被赋予高置信度的数据点。
• 防止大簇扭曲隐藏特征空间。

通过首先将 q(编码的特征向量)提高到二次幂，然后通过每个聚类的频率进行归一化，来计算目标分布。

有必要在辅助目标分布的帮助下，通过从高置信度分配中学习来迭代地改进聚类。在特定次数的迭代之后，目标分布被更新，并且聚类模型将被训练以最小化目标分布和聚类输出之间的 KL 发散损失。训练策略可以被看作是自我训练的一种形式。在自我训练中，我们采用一个初始分类器和一个未标记的数据集，然后用分类器标记数据集，以训练其高可信度预测。

损失函数，KL 散度或kull back–lei bler 散度它是两种不同分布之间行为差异的度量。我们希望将其最小化，以便目标分布尽可能接近聚类输出分布。

在下面的代码片段中，目标分布每 140 次训练迭代更新一次。

在每次更新后，您将看到聚类的准确性稳步提高。

评估指标

该指标表示，它已经达到了 96.2% 的聚类精度，考虑到输入是未标记的图像，这已经相当不错了。让我们仔细看看它的精度是如何得出的。

该指标采用来自无监督算法的聚类分配和基础事实分配，然后找到它们之间的最佳匹配。

最佳映射可以通过匈牙利算法有效计算，该算法在 scikit 学习库中实现为线性分配。

看混淆矩阵更直接。

在这里，您可以手动快速匹配聚类分配，例如，聚类 1 匹配真实标签 7 或手写数字“7”和 vise visa。

下面显示了混淆矩阵的绘图代码片段。

应用卷积自动编码器(实验)

因为我们处理的是图像数据集，所以值得尝试使用卷积自动编码器，而不是只使用完全连接的层。

值得一提的是，为了重建图像，你可以选择去卷积层( Conv2DTranspose 在 Keras)或上采样( UpSampling2D )层，以减少伪影问题。卷积自动编码器的实验结果可在我的 GitHub 上获得。

结论和进一步阅读

我们已经学习了如何构建一个 keras 模型来对未标记的数据集执行聚类分析。预训练的 autoencoder 在降维和参数初始化中发挥了重要作用，然后根据目标分布训练定制的聚类层以进一步提高精度。

进一步阅读

在 Keras 中构建自动编码器

用于聚类分析的无监督深度嵌入——启发我写了这篇文章。

完整的源代码在我的 GitHub 上，请阅读到笔记本的末尾，因为您将发现另一种替代方法来同时最小化聚类和自动编码器损失，这被证明有助于提高卷积聚类模型的聚类精度。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←利用 Keras 中的新闻数据进行简单的股票情绪分析
• 如何训练 Keras 模型生成颜色→

如何用 Keras 生成真实的 yelp 餐馆评论

原文：https://www.dlology.com/blog/how-to-generate-realistic-yelp-restaurant-reviews-with-keras/

发帖人:程维 4 年 10 个月前

(评论)

TL；速度三角形定位法(dead reckoning)

看完这篇文章。你将能够建立一个模型来生成像这样的 5 星 Yelp 评论。

【生成评审文本样本(未修改)】

<SOR>I had the steak, mussels with a side of chicken parmesan. All were very good. We will be back.<EOR>
<SOR>The food, service, atmosphere, and service are excellent. I would recommend it to all my friends<EOR>
<SOR>Good atmosphere, amazing food and great service.Service is also pretty good. Give them a try!<EOR>

我将向您展示如何，

• 获取并准备培训数据。
• 构建字符级语言模型。
• 训练模型时的提示。
• 生成随机评论。

即使在 GPU 上，训练模型也很容易需要几天时间。幸运的是，预先训练的模型重量是可用的。所以我们可以直接跳到有趣的部分来生成评论。

准备好数据

Yelp 数据集以 JSON 格式免费提供。

下载并解压后，你会在数据集文件夹中找到我们需要的 2 个文件，

• 评论. json
• 商务. json

那两个文件相当大，尤其是 review.json 文件(3.7 GB)。

review.json 文件的每一行都是对 json 字符串的回顾。这两个文件没有 JSON 开始和结束方括号“[ ]”。所以 JSON 文件的内容作为一个整体不是一个有效的 JSON 字符串。另外，可能很难将整个 review.json 文件内容放入内存。所以，让我们先用助手脚本一行一行地把它们转换成 CSV 格式。

python json_converter.py ./dataset/review.json
python json_converter.py ./dataset/business.json

之后，您会在数据集文件夹中找到这两个文件，

• 点评. csv
• business.csv

这两个是有效的 CSV 文件，我们可以通过熊猫图书馆打开。

这是我们将要做的。我们只从类别中带有“餐厅标签的商家中提取 5 星评论文本。

接下来，让我们删除评论中的换行符和任何重复的评论。

向模型展示评审的起点和终点。我们需要在复习课文中添加特殊标记。

因此，最终准备好的评论中的一行将如您所料。

"<SOR>Hummus is amazing and fresh! Loved the falafels. I will definitely be back. Great owner, friendly staff<EOR>"

建立模型

我们在这里构建的模型是一个字符级语言模型，这意味着最小的可区分符号是一个字符。您还可能遇到单词级模型，其中输入是单词标记。

字符级语言模型有一些优点和缺点。

亲:

• 不用担心未知词汇。
• 能够学习大量词汇。

反对:

• 以非常长的序列结束。在捕捉句子前半部分如何影响句子后半部分之间的长期依赖关系方面，不如单词级语言模型。
• 和角色级别模型也只是训练起来更加计算昂贵。

该模型与官方的lstm _ text _ generation . py演示代码非常相似，除了我们正在堆叠 RNN 单元，允许在输入和输出层之间的整个隐藏状态中存储更多信息。它能产生更真实的 Yelp 评论。

在展示该模型的代码之前，让我们更深入地了解一下堆叠 RNN 是如何工作的。

你可能在标准神经网络中见过。(即喀拉斯的致密层)

第一层取输入 x 计算激活值a^{(【1】)**，堆栈下一层计算下一个激活值**a}(【2】)。

堆叠 RNN 有点像标准的神经网络和“及时展开”。

对于符号a^(【l】t)表示激活分配给层 l，和 t 表示时间步长 t 。

让我们来看一看激活值是如何计算的。

要计算a[2]^{3**，有两个输入，**a[2]}2和a[1]^3

g 为激活函数，w[a]^2，b[a]2 为第二层参数。

我们可以看到，要堆栈 RNNs，前面的 RNN 需要将所有时间步长 a^(t) 返回给后面的 RNN。

默认情况下，Keras 中的 RNN 层如 LSTM 只返回最后一个时间步长激活值 a^(T) 。为了返回所有时间步长的激活值，我们将return_sequences参数 设置为 True 。

这就是我们如何在 Keras 中建立模型。每个输入样本是 60 个字符的一键表示，总共有 95 个可能的字符。

每个输出是每个字符的 95 个预测概率的列表。

这是一个图形化的模型结构，可以帮助你把它可视化。

训练模型

训练模型的想法很简单，我们用输入/输出对来训练它。每个输入是 60 个字符，对应的输出是紧随其后的字符。

在数据准备步骤中，我们创建了一个干净的五星评论文本列表。总共 1，214，016 行评论。为了简化训练，我们只对长度等于或小于 250 个字符的评论进行训练，最终得到 418，955 行评论。

然后我们打乱评论的顺序，这样我们就不会连续对同一家餐馆的 100 条评论进行训练。

我们以一个长文本串的形式阅读所有评论。然后创建一个 python 字典(即哈希表)，将每个字符映射到从 0 到 94 的索引(总共 95 个唯一字符)。

文本语料库共有 72，662，807 个字符。很难把它作为一个整体来处理。因此，让我们把它分成每个 90k 字符的块。

对于语料库的每一块，我们将生成成对的输入和输出。通过将指针从块的开头移动到结尾，如果 step 设置为 1，则每次移动一个字符。

在 GPU (GTX1070)上为一个时期训练一个组块需要 219 秒，因此训练完整的语料库将需要大约 2 天。

72662807 / 90000 * 219 /60 / 60/ 24 = 2.0 days

两个 Keras 回调派上了用场， ModelCheckpoint 和 ReduceLROnPlateau 。

模型检查点帮助我们保存每次改进的权重。

ReduceLROnPlateau 回调在损失指标停止下降时自动降低学习率。它的主要好处是我们不需要手动调整学习速度。它的主要弱点是学习率总是在降低和衰减。

为模型定型 20 个时期的代码如下所示。

正如你所猜测的，这需要一个月左右的时间。但是对我来说，大约两个小时的训练已经产生了一些有希望的结果。请随意尝试一下。

生成 5 星评价

不管你是直接跳到这一节，还是已经读过前面的到。有趣的部分来了！

使用预先训练的模型权重或您自己训练的权重，我们可以生成一些有趣的 yelp 评论。

这里的想法是，我们用最初的 60 个字符“播种”模型，并要求模型预测下一个字符。

“抽样指数”过程将通过给定的预测产生一些随机性来给最终结果 增加一些变化。

如果温度很低，它总是选择预测概率最高的指数。

生成 300 个字符，代码如下

总结和进一步阅读

在这篇文章中，你从头到尾了解了如何构建和训练一个字符级的文本生成模型。源代码可以在我的 GitHub repo 上找到，也可以在训练前的模型上玩。

这里显示的模型是以多对一的方式训练的。还有另一种多对多方式的可选实现。考虑输入序列为长度为 7 的字符cak，期望输出为hecake。可以在这里查看，char _ rnn _ karpathy _ keras。

作为建立单词级模型的参考，请查看我的另一个博客:简单的股票情绪分析，包含 Keras 中的新闻数据。

• 标签:
• keras ,
• 深度学习

Share on Twitter Share on Facebook

• ←如何在 Keras 中缺失标签的情况下进行多任务学习
• 如何使用 Keras 进行实时触发词检测→

如何利用 TensorFlow 的 TFRecord 训练 Keras 模型

原文：https://www.dlology.com/blog/how-to-leverage-tensorflows-tfrecord-to-train-keras-model/

发布者:程维五年零一个月前

(评论)

更新:

• 2019 年 5 月 29 日: 源代码 更新运行在 TensorFlow 1.13 上。

在我们之前的帖子中，我们发现了如何使用 Keras 模型为最新的 TensorFlow 1.4.0 构建新的 TensorFlow 数据集和估计器。输入函数将原始图像文件作为输入。在本帖中，我们将继续我们的旅程，利用 Tensorflow TFRecord 减少 21%的培训时间。

我会给你看

• 如何把我们的图像文件变成一个 TFRecord 文件？
• 修改我们的输入函数来读取 TFRecord 数据集。

在继续阅读之前，如果你还没有看完我们的上一篇文章，建议你去看看。以便您熟悉将 Keras 模型转换为张量流估计量的过程，以及数据集 API 的基础知识。

将图像文件转换为 TFRecord 文件

一旦我们有了图像文件和相关标签的列表(0-猫，1-狗)。

['./data/dog_vs_cat_small\\train\\cats\\cat.954.jpg'
 './data/dog_vs_cat_small\\train\\dogs\\dog.240.jpg'
 './data/dog_vs_cat_small\\train\\dogs\\dog.887.jpg'
 './data/dog_vs_cat_small\\train\\cats\\cat.770.jpg'
 './data/dog_vs_cat_small\\train\\dogs\\dog.802.jpg'
 './data/dog_vs_cat_small\\train\\dogs\\dog.537.jpg'
 './data/dog_vs_cat_small\\train\\cats\\cat.498.jpg'
 './data/dog_vs_cat_small\\train\\cats\\cat.554.jpg'
 './data/dog_vs_cat_small\\train\\cats\\cat.589.jpg'
 './data/dog_vs_cat_small\\train\\dogs\\dog.685.jpg' ...]
[0 1 1 0 1 1 0 0 0 1 ...]

我们可以编写从磁盘读取图像的函数，并将它们和类标签一起写入 TFRecord 文件。

注意，在convert函数中，我们将所有图像的大小调整为(150，150 ),这样我们就不必像上一篇文章那样在训练过程中这样做了，这也使得生成的 TFRecord 文件的大小变小了。

如果我们调用convert函数，它将为我们生成训练和测试 TFRecord 文件。

输入函数读取 TFRecord 数据集

我们的估计器需要一个新的输入函数来读取 TFRecord 数据集文件，我们调用 tf.data.TFRecordDataset函数来读取我们之前创建的 TFRecord 文件。

注意，由于图像数据是序列化的，所以我们需要用tf.reshape将它转换回原始形状(150，150，3)。

训练和评估模型

与前一篇文章类似，imgs_input_fn函数获取 TFRecord 文件的路径，并且没有用于标签的参数，因为它们已经包含在 TFRecord 文件中。

结果

为了向您展示训练速度提升的结果，我们对tf.estimator.train_and_evaluate调用的执行进行了计时。

前一篇文章阅读原始图像和标签。

--- 185.2788429260254 seconds ---

此帖子以 TFRecord 文件作为数据集。

--- 146.32020020484924 seconds ---

未来工作

我们在这里使用的猫和狗的数据集相对较小。如果我们正在处理不适合我们的内存的大型数据集。我们在文章中使用的同一个tf.data.TFRecordDataset类也使我们能够将多个 TFRecord 文件的内容作为输入管道的一部分进行流式传输。

查看我的 GitHub 中的 完整源代码

进一步阅读

Tensorflow 指南-数据集-消费 TFRecord 数据

Share on Twitter Share on Facebook

• ←使用 Keras 模型构建新张量流数据集和估计量的简单指南
• 一个简单的技巧，通过批量标准化更快地训练 Keras 模型→

如何在 Python 3 中加载 Python 2 PyTorch 检查点

原文：https://www.dlology.com/blog/how-to-load-python-2-pytorch-checkpoint-in-python-3-1/

发帖人:程维 4 年 2 个月前

(评论)

本教程展示了一个快速转换 Python 2 中训练的 PyTorch 检查点文件的方法。x 转换成 Python 3.x 兼容格式。当您尝试调用 torch.load() 时，它会解决类似这样的错误信息。

UnicodeDecodeError: 'ascii' codec can't decode byte 0x8c in position 16: ordinal not in range(128)

第一步

加载并保存 Python 2.X 中的 state_dict 中的

在下面的例子中，我们使用 Kaggle 数据科学碗 2017 年获奖者模型进行演示，该模型可在https://github.com/lfz/DSB2017/tree/master/model找到。

第二步

load_state_dict在 Python 3.X 中

casenet是torch.nn.``Module的子类实例。

可选步骤 3

或者，您可以将整个检查点文件转换为 Python 3。x 兼容。

1.从 Python 2 加载并清理检查点文件。x 转换为二进制格式。

2.在 Python 3 中加载 pickled 检查点。X

3.迭代解码和转换所有二进制字典键。

这里有一个完整的例子来展示它是如何做的。

下面是 Google Colab 上的 Python 2.x 笔记本供你参考。

• 标签:
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←如何在 TensorFlow 中运行 GPU 加速信号处理
• 如何将训练好的 Keras 模型转换成单个 TensorFlow。pb 文件并进行预测→

如何使用 OpenCV 测量网络摄像头的延迟

原文：https://www.dlology.com/blog/how-to-measure-the-latency-of-a-webcam-with-opencv/

发帖人:程维四年零一个月前

(评论)

在这个快速教程中，您将了解如何测量网络摄像头的延迟，以评估它是否能够处理实时要求比静态图像捕捉更高的图像捕捉任务。

想象一条饮料生产线沿着传送带快速灌装瓶子。部署了一个摄像头来验证每个瓶子的质量，如液体的体积和形状，每个有缺陷的产品都必须被挑选出来。图像捕捉的实时要求是至关重要的，因为任何延长的等待时间都可能导致不同的瓶子被转移到错误的路径。

潜伏期从何而来？

通过调用 Python cv2 库中的 camera.read() 来读取网络摄像头中的一帧似乎很简单，然而，许多事情发生在幕后，这可能会引入不可预测的延迟，这在实时应用中是不可取的。

从上图可以看出，捕捉到的图像经过“很长”的一段路到达你的电脑，然后被解码并显示在屏幕上。

测量延迟

为了测量实际图像被捕获和显示在屏幕上之间的延迟，我们将快速编写一个简单的 Python 脚本，以尽可能快的速度从摄像机读取图像，并在管道末端检测到之前的颜色变化时立即翻转显示颜色。

前面的序列表明等待时间可能比几帧长。

这是这个实验的逻辑图。

完整的脚本如下图所示。

将您的相机指向弹出窗口，观察每秒钟黑白之间的几次颜色翻转，这反映了延迟。

你可以将你的相机镜头尽可能靠近屏幕，它不需要有一个清晰的焦点，只需要平均强度就可以使颜色翻转。

我已经在我的罗技 C930e USB 网络摄像头上测试了它，下面是结果。

测试了两种图像分辨率，您可以看到较低的分辨率产生的延迟稍低。

该值以毫秒为单位，平均值约为 200 毫秒。假设传送带以 1 米/秒的恒定速度运行，瓶子已经移动了 20 厘米远。

解决方法是什么？

如果您的应用需要更多的预测和更低延迟的图像捕捉，一个简单有效的解决方案是将您的相机升级为具有外部触发信号的工业相机，其中可以连接一个光电眼传感器或数字控制 IO。

在这种情况下，可以在更具预测性的时间戳捕获图像，该时间戳可以由阻挡光电眼传感器的东西或来自计算机的实时信号触发。

• 标签:
• 教程

Share on Twitter Share on Facebook

• ←如何免费在 TPU 上更快的执行 Keras 超参数优化 x3
• 不平衡数据集的聚焦损失多类分类→

Keras 中标签缺失的多任务学习

原文：https://www.dlology.com/blog/how-to-multi-task-learning-with-missing-labels-in-keras/

发帖人:程维 4 年 10 个月前

(评论)

多任务学习使我们能够训练一个模型同时完成几项任务。

例如，假设一张照片是由自动驾驶汽车拍摄的，我们希望检测图像中不同的东西。停车标志、交通灯、汽车等。

在没有多任务学习的情况下，我们必须为我们想要检测的每个对象训练模型，并且利用一个输出来检测或不检测目标对象。

但是使用多任务学习，我们可以只训练一次模型，通过 3 个输出标签来检测是否有任何目标对象被检测到。

模型输入是图像，输出有 3 个标签，1 表示检测到特定对象。

对于在像图像这样的数据集上训练的模型，训练一个模型来执行多个任务比单独训练来单独检测对象的模型执行得更好，因为在训练期间学习的较低级图像特征可以在所有对象类型之间共享。

多任务学习的另一个好处是它允许训练数据输出被部分标记。比方说，我们不标记前面的 3 个物体，而是希望人类标记器在所有给定的图像中标记另外 3 个不同的物体，行人、骑自行车的人、路障。他/她可能最终会感到厌倦，也懒得去标记是否有停车标志或是否有路障。

因此，带标签的训练输出可能看起来像这样，其中我们将未加标签的表示为-1 "。

那么，我们如何用这样的数据集训练我们的模型呢？

关键是损失函数我们要用【掩码】标注数据。意味着对于未标记的输出，我们在计算的时不考虑损失函数。

多任务学习演示

让我们通过一个具体的例子来训练一个可以执行多任务的 Keras 模型。出于演示的目的，我们建立我们的玩具数据集，因为它更容易训练和可视化的结果。

这里，我们在 2D 空间中随机生成 100，000 个数据点。每个轴都在 0 到 1 的范围内。

对于输出 Y，我们在以下逻辑中有 3 个标签

我们将建立一个模型来发现 X 和 Y 之间的这种关系，

为了让问题更复杂，我们将模拟贴标机掉落一些输出标签。

让我们建立一个 4 层的简单模型，

这里是重要的部分，在这里我们定义了我们的自定义损失函数来“屏蔽”仅仅标记数据。

掩码将是一个张量，为每个训练样本存储 3 个值，不管标签是否等于我们的掩码 _ 值 (-1)，

然后，在计算二进制交叉熵损失的过程中，我们只计算那些被屏蔽的损失。

训练很简单，我们先把最后生成的 3000 个数据留作最后的评测测试。

然后在训练期间将剩余的数据分成 90%用于训练，10%用于开发。

经过 2000 个纪元的训练，让我们用预留的评估测试数据来检验模型性能。

损失/精确度为

0.908/0.893

为了帮助形象化模型的想法，让我们为我们的 3 个标签中的每一个画出它的决策边界。

看起来我们的模型搞清楚了 X 和 Y 之间的逻辑；)

如果你不相信我们的自定义损失函数的有效性，让我们并排比较一下。

要禁用我们的自定义损失函数，只需将损失函数改回默认的'binary_crossentropy'就像这样。

然后再次运行模型训练和评估。

最终评估的准确度只有 0.527 左右，这比我们之前使用自定义损失函数的模型差得多。

0.909/0.527

在我的 GitHub repo 上查看源代码。

总结和进一步思考

通过多任务学习，我们可以在一组任务上训练模型，这些任务可以受益于共享的低级特征。

通常情况下，你每个任务的数据量都是差不多的。

训练数据中某种程度的标签缺失不是问题，可以用自定义损失函数来处理，只屏蔽有标签的数据。

我们可以做得更多，我想到的一个可能的数据集是 (MBTI)迈尔斯-布里格斯人格类型数据集。

输入是给定人员发布的文本。

有 4 个输出标签。

• 内向(I)-外向(E)
• 直觉(N)–感觉(S)
• 思考(T)-感受(F)
• 判断(J)-感知(P)

我们可以把每一个都当作一个二元标签。

我们可以允许标注者为给定的人的帖子留下任何未标注的人格类型。

模型应该还是能够用我们自定义的损失函数算出输入和输出之间的关系。

如果你尝试过这个，请在下面留下评论，让我们知道它是否有效。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←如何在 Keras 中选择优化器的快速说明
• 如何使用 Keras 生成真实的 yelp 餐厅评论→

如何将内容“粘贴”到不支持复制和粘贴的 VNC 控制台

原文：https://www.dlology.com/blog/how-to-paste-content-to-a-vnc-console-which-does-not-support-copy-and-paste/

发布者:程维五年零一个月前

(评论)

在本教程中，我们将构建一个自动输入的 python GUI。

我最初的用例是使用 noVNC/QEMU 终端的服务器设置，其中复制粘贴不可用。点击这里查看 YouTube 视频。

它是如何工作的

随着 自动开关 功能开启。你在底部的文本框中输入一些内容，然后点击发送按钮。

• 它通过提供的图像功能直观地定位 VNC 浏览器窗口坐标
• 在图像特征中间点击鼠标左键，切换到 VNC 窗口
• 它将你的文本输入 VNC 窗口。
• 它将鼠标光标改回到原来的位置

快速启动

安装依赖项

该应用程序依赖于两个库

pyautogui 用于模拟键盘和鼠标以及在屏幕上直观定位窗口

wx 是 Python 前端用户界面库。

我们用 Python 3 pip3 命令安装它们。

pip3 install pyautogui wx

获取代码

从我的 GitHub 中克隆或下载源代码。

运行 GUI

一旦安装了依赖项并下载了源代码。在 TypeApp 文件夹中打开一个终端窗口，然后键入。

python3 type_app.py

我们首先需要的是我们将要输入的 VNC 窗口的图像特征。让我们捕捉它的一个截图，并保存为一个 png 文件。该工具稍后将在您的屏幕上定位该图像，并单击鼠标为您切换到该窗口。

这是我的浏览器 VNC 窗口的截图。

从该窗口捕获的

在应用程序中您可以通过点击 浏览 按钮来选择您的图像，同时一定要选中 自动切换 复选框。

在我们尝试在“输入”文本框中键入内容之前，请确保 VNC 浏览器窗口在主屏幕上可见(如果您使用多台显示器)。

源代码的亮点

• wx 事件类型和“键入”线程
• pyautogui 功能，神奇的事情发生了

wx 事件类型和“键入”线程

为了保持我们的 GUI 响应性，我们应该避免在主 GUI 线程中运行任何计算密集型或者任何花费相当长时间的动作。

在我们的例子中，需要一段时间才能完成的动作是输入动作。我们将在与 GUI 线程并行的另一个线程中执行它。但是第二个打字线程如何在打字完成或失败时通知 GUI 线程呢？这就是 wx 事件类型发挥作用的地方。

首先，我们创建一个 NewEventType 的实例，它将用于创建一个事件对象。

自定义事件类 TypingEvent 将用于将事件从类型化线程发送到主 GUI 线程。

定义我们将在其中运行我们的类型代码的类型线程。在 run 方法结束时，线程将生成一个事件来告诉 GUI 输入已经完成。

当点击“发送”时，从 GUI 线程启动线程。

在通过“绑定”一个“监听器”来监听事件的 GUI 线程中，每次 TypingThread 发布事件时，GUI 线程都会调用 on_type_over 。

pyautogui 功能，神奇的事情发生了

pyautogui.position 读取当前鼠标在屏幕上的位置。

pyautogui . locate center screen将我们的截图图像作为参数，并返回图像在屏幕上的坐标

pyautogui.click 顾名思义，在上一步找到的坐标上点击鼠标左键

pyautogui . typeet键入文本

pyautogui.moveTo 将鼠标移回原来的位置。

Share on Twitter Share on Facebook

• ←一个改进马达声学分类器的简单技巧
• 如何选择最后一层激活和丢失功能→

如何免费在 TPU 上更快地执行 Keras 超参数优化 x3

原文：https://www.dlology.com/blog/how-to-perform-keras-hyperparameter-optimization-on-tpu-for-free/

发帖人:程维四年零一个月前

(评论)

你是一个数据驱动的科学家或数据工程师，想要完全控制你的 Keras 模型，并希望从盲目的参数跳跃和搜索中解脱出来吗？

超参数优化通常需要使用不同的配置多次训练模型，这意味着需要一台带有多个显卡的快速计算机，通过更快地训练模型来减少滞后时间。读完这篇文章后，与在我的单个 GTX1070 上运行相同的设置相比，您将能够更快地为超参数优化实验 x3 配置您的 Keras 模型，并免费在 TPU 上产生最先进的设置。

根据我在 Keras 支持下的几个开源超参数优化解决方案的经验， Talos 为重要的超参数优化功能提供了最直观、最易于学习和最宽松的访问方式。让我们建立一个实验来搜索最佳的 CNN 模型参数，以使用 Talos 预测时尚 MNIST 数据集。

在我的单个 GTX1070 GPU 上运行超参数优化的基线笔记本和 TPU 版本都可以在我的 GitHub 上获得。

为超参数优化准备一个 Keras 模型

与 Auto-Keras 等其他一些神经架构搜索工具不同，超参数优化过程中没有黑盒，由您来指定参数搜索的选项。

考虑一个在 Keras 的候选 CNN 模特来完成你通常写的时尚 MNIST 分类任务。

要为 Talos 扫描准备模型以获得最佳超参数，只需将您希望包含在扫描中的参数替换为对您的参数字典的引用，如下所示，

params的值将作为一个字典，在 Talos 扫描运行时，在扫描期间动态地传递给fashion_mnist_fn函数。实现该函数将连同模型本身一起返回model.fit()的历史度量输出，以便 Talos 扫描器可以在训练后评估模型的性能。

以下是定义超参数列表并开始搜索的方法。

Talos 支持几种常见的优化策略，对于最简单的网格搜索，参数组合将被插入到fashion_mnist_fnyou之前定义的模型训练中。

在 TPU 上运行超参数扫描

如果您运行之前的扫描，它将仅在您的默认 TensorFlow 设备上运行，无论是 CPU 还是 GPU。

然而，要使用云 TPU 更快地运行整个过程，在您构建模型并将模型转换为 TPU 模型之后，必须执行一些额外的步骤。

了解步骤 1、3 和 4 中发生的差异。1024 的批量大小将被平均分割成 8 个 TPU 核心，每个核心在 128 个输入样本批量上进行训练。

扫描完成后，您可以恢复具有最高验证准确性或您选择的其他指标的最佳模型索引。

基准和结论

与在我的 GTX 1070 上的 40:18 训练相比，在 TPU 上用可变超参数完全训练 CNN 的 8 个变体需要 12:29 。

TPU 搜索:

GPU 搜索:

请务必查看本教程的可运行的 Colab 笔记本和我的 GitHub 上的 GPU/CPU 对等物 Jupyter 笔记本。

想用 TPU 训练一辆速度快 20 倍的 RNN Keras 吗？阅读我以前的帖子- 如何免费用 TPU 训练 Keras 模型快 20 倍。

另外，在 Github 上阅读更多关于 Talos 的内容。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←如何将训练好的 Keras 模型转换成单个 TensorFlow。pb 文件并进行预测
• 如何使用 OpenCV 测量网络摄像头的延迟→

如何用 CMSIS-NN 在微控制器上运行深度学习模型(下)

原文：https://www.dlology.com/blog/how-to-run-deep-learning-model-on-microcontroller-with-cmsis-nn-part-2/

发帖人:程维四年零五个月前

(评论)

在之前的中，我已经向您展示了如何在 ARM 微控制器上运行图像分类模型，这一次让我们更深入地了解该软件是如何工作的，并熟悉 CMSIS-NN 框架。

处理内存限制

源文件arm_nnexamples_cifar10.cpp，为了在计算期间将数据放入 192 千字节的 RAM 中，创建了两个缓冲变量，并在各层之间重复使用。

• col_buffer为卷积层存储 im2col(图像到列)输出，
• scratch_buffer存储激活数据(中间层输出)

在下面的代码片段中，你会发现这两个缓冲区是如何应用于 3 个连续的层的。

arm_convolve_HWC_q7_fast 函数创建一个卷积层，将 img_buffer2 的内容作为输入数据，并将输出到 img_buffer1 。 它也使用 col_buffer 作为它的内部存储器来运行卷积图像到列的算法。下面的 ReLu 激活层作用于img_buffer1本身 ，然后相同的缓冲区将作为下面的 max pool 层的输入，其中该层输出 到 img_buffer2 等等。

由于 RAM 空间有限，我们无法慷慨地将一大块内存分配给这两个缓冲区。

相反，我们只分配足够模型使用的内存空间。

为了找出所有卷积层所需的col_buffer大小，应用下面的公式。

2*2*(conv # of filters)*(kernel width)*(kernel height)

在我们的例子中，我们有三个卷积层和 conv1 层需要最大数量的 2*2*32*5*5 = 3200 字节缓冲空间来进行其图像到列的计算，因此我们将该数量的空间分配给 col_buffer 以及在所有其他卷积层之间共享的。

对于分成两部分的暂存缓冲区，对于给定的图层，一部分可用作输入，另一部分可用作输出。

类似地，它的最大尺寸可以通过迭代所有层来确定。

上图显示了一个等效的模型结构，其中我们在所有的层中搜索 img_buffer1 和 img_buffer2 所需的最大尺寸，然后将两个缓冲区连接在一起，形成总尺寸scratch_buffe。

选择神经网络层函数

在 CMSIS-NN 中，2D 卷积层有几种选择

1. arm _ 卷积 _ HWC _ Q7 _ 基本
2. arm _ 卷积 _HWC_q7_fast
3. arm _ 卷积 _HWC_q7_RGB
4. arm _ 卷积 _ HWC _ Q7 _ 快速 _ 非方

它们中的每一个都在不同程度上针对速度和大小进行了优化，但是也有不同的限制。

arm_convolve_HWC_q7_basic函数是设计用于任何方形输入张量和权重维度的最基本版本。

arm_convolve_HWC_q7_fast函数顾名思义运行速度比前一个快，但要求输入张量通道是 4 的倍数，输出张量通道(滤波器数量)是 2 的倍数。

arm_convolve_HWC_q7_RGB专为与输入张量通道等于 3 的卷积而构建，这通常应用于将 RGB 图像数据作为输入的第一个卷积层。

arm_convolve_HWC_q7_fast_nonsquare类似于到 arm_convolve_HWC_q7_fast ，但可以取非正方形的输入张量。

对于完全连接的层，有两种截然不同的选择，

1. arm _ 完全连接 _q7
2. arm _ 完全连接 _q7_opt

第一个使用常规权重矩阵，另一个使用后缀“_opt”来优化速度，但是层的权重矩阵必须预先以交错方式排序。重新排序可以在代码生成器脚本的帮助下无缝实现，我将在下一篇文章中讨论。

4.6 倍的速度提升从何而来？

简答，ARM Cortex-M4，M7 微控制器支持特殊的 SIMD 指令，尤其是 16 位乘加(MAC)指令(例如 SMLAD ) 加速矩阵乘法。当你看一看基本的全连接层实现源代码 arm_fully_connected_q7.c 时，这个实现会自我检讨。带有 DSP 指令的微控制器在特殊指令下运行更快。

要了解卷积层是如何加速的，必须了解 img2col 的基本原理，img 2 col 使用 im2col()函数将卷积转换为矩阵乘法，该函数以通过矩阵乘法实现卷积输出的方式排列数据。

CMU 15-418/618 双方的功劳。

im2col 通过使用微控制器的 SIMD 特性来提高卷积的并行性，但由于原始图像被放大了 (numInputChannels * kernel width * kernel height) 的因子，因此会引入内存开销。

结论和进一步的思考

这篇文章介绍了一些基本概念，比如重用缓冲区和 NN 层函数的不同实现，当你用 CMSIS-NN 框架构建一个应用时，你可能会发现这些很有用。在下一节课中，我将向您展示从培训到将模型部署到您的微控制器是多么容易。

• 标签:
• 教程，
• 深度学习

Share on Twitter Share on Facebook

• ←如何用 CMSIS-NN 在微控制器上运行深度学习模型(第一部分)
• 如何用 CMSIS-NN 在微控制器上运行深度学习模型(第三部分)→

如何用 CMSIS-NN 在微控制器上运行深度学习模型(三)

原文：https://www.dlology.com/blog/how-to-run-deep-learning-model-on-microcontroller-with-cmsis-nn-part-3/

发帖人:程维四年零五个月前

(评论)

您已经学习了如何在 ARM 微控制器上运行图像分类模型，以及 CMSIS-NN 框架的基础知识。这篇文章展示了如何从头开始训练和部署一个新的模型。

建立并训练一个咖啡馆模型

当选择深度学习框架时，Keras 是我最喜欢的，因为它简单而优雅，但是这次我们将使用 Caffe，因为 ARM 的团队已经发布了两个有用的脚本来为我们生成为 Caffe 模型构建的代码。如果你像我一样是咖啡新手，不用担心。模型结构和训练参数都以易于理解的文本文件格式定义。

Caffe 的安装可能会很有挑战性，尤其是对初学者来说，这就是为什么我用 Caffe 的安装和教程代码创建了这个可运行的 Google Colab 笔记本。

Caffe 图像分类模型在文件cifar 10 _ M4 _ train _ test _ small . proto txt中定义，其模型结构图如下所示。它包含三个卷积层，由 ReLU 激活层和 max-pooling 层穿插，最后是一个全连接层，用于生成十个输出类之一的分类结果。

在cifar 10 _ M4 _ train _ test _ small . proto txt模型定义文件中

• 具有“数据”类型的层必须命名为“数据”，因为我们稍后使用的代码生成脚本是通过名称来定位层的。这一层 产生两个“斑点”，一个是data斑点包含图像数据，一个是label斑点代表输出类标签。
• lr_mult s 是该层可学习参数的学习速率调整。在我们的例子中，它会将权重学习率设置为与运行时求解器给出的学习率相同，并将偏差学习率设置为两倍大——这通常会导致更好的收敛率。
• 全连通层在 Caffe 中称为anInnerProduct层 。
• 图层定义可以包括关于是否以及何时将其包含在网络定义中的规则，如下所示:

layer {
  // ...layer definition...
  include: { phase: TRAIN }
} 

在上面的例子中，这一层将只包括TRAIN阶段中的。

检查求解器文件cifar 10 _ small _ solver。prototxt 它定义了训练模型的迭代次数，我们用测试数据集评估模型的频率等等。

最后运行脚本train _ small _ colab . sh将开始训练，当它完成时权重将被保存。在我们的例子中，脚本运行两个解算器文件，对于第二个解算器文件中定义的最后 1000 次训练迭代，学习率降低了 10 倍。最终训练的权重将被保存到文件cifar 10 _ small _ ITER _ 5000 . caffemodel . H5表示模型已经被训练了 5000 次迭代。如果你来自 Keras 或其他不同的深度学习框架背景，这里的一次迭代不是说模型已经用整个训练数据集训练过一次，而是一批大小为 100 的训练数据，如cifar 10 _ M4 _ train _ test _ small . proto txt中所定义。

很简单，对吧？构建和训练 Caffe 模型不需要编码。

量化模型

关于 q 的快速事实量化，

• Q 将 32 位浮点权重量化为 8 位定点权重进行部署，将模型大小缩小了 4 倍、
• 典型微控制器中定点整数运算比浮点运算运行速度快得多
• 在推理过程中，具有量化整数权重和偏差的模型不会表现出任何性能损失(即准确性)。

由于训练后权重是固定的，我们知道它们的最小/最大范围。使用它们的范围将它们量化或离散化为 256 级。下面是一个快速演示，将权重量化为定点数。假设一个层的权重最初只包含 5 个浮点数。

它输出，

quantization format: 	 Q5.2
Orginal weights:   [-31.63  -6.54   0.45   0.9   31\.  ]
Quantized weights: [-127\.   -26\.    2\.     4\.    124\. ]
Recovered weights: [-31.75  -6.5    0.5    1\.    31\.  ]

在本演示中，权重被量化为 Q5.2 定点数格式，这意味着用 8 位表示带符号的浮点数，

• 一位作为符号(正/负)，
• 5 位表示整数部分
• 小数部分 2 位。

Qm.n 格式的m和n一般可以用前面演示的最小/最大范围来计算，但是如果权重矩阵中包含一个离群值呢？

如果您使用这个新的权重值重新运行前面的脚本，量化 Q8，-1 恢复的权重将如下所示，不太好，小的权重值丢失了！

array([-32.,  -6.,   0.,   0.,  32., 200.])

这就是为什么 ARM 团队开发了一个助手脚本，在测试数据集上以最小的准确度损失进行权重量化，这意味着它还会运行模型，以在最初的 计算的值周围搜索最佳 Q m 和 n 值。

nn _ quantizer . py脚本取模型 定义(cifar 10 _ M4 _ train _ test _ small . proto txt)文件和训练好的模型文件(cifar 10 _ small _ ITER _ 5000 . caffemodel . H5)然后逐层迭代做三件事。

• 量化权重矩阵值
• 量化层的激活值(包括值范围在 0~255 之间的输入图像数据)
• 量化偏差矩阵值

该脚本最终将网络图的连通性、量化参数转储到 pickle 文件中，以供下一步使用。

生成代码

如果有“代码生成器”，谁还需要写代码？code_gen.py 从上一步得到量化参数和网络图连通性，生成由 NN 个函数调用组成的代码。【T2

目前支持以下层:卷积、InnerProduct(全连接)、Pooling(最大/平均)和 ReLu。它生成三个文件、、、

1. weights.h : 模型权重和偏差。
2. parameter.h:量化范围，从 Qm 计算的偏置和输出偏移值，n 格式的权重、偏置和激活、
3. main.cpp : 网络代码。

生成器相当复杂，它根据前一篇文章中讨论的各种约束选择最佳的层实现。

部署到微控制器

如果模型结构不变，我们只需要更新weights.h和parameter.h中的那些数据。这些是偏差和输出偏移值，用于替换项目源文件中的值。如果你的项目是基于 官方 CMSIS-NN cifar10 例子像我的，那些值都是在 文件arm_nnexamples_cifar10_weights.h里面定义的。

一些定义的命名略有不同，但很容易理清。

现在，在微控制器上构建并运行它！

结论和进一步的思考

到目前为止，您使用的是纯预定义的输入数据来运行神经网络，这在考虑各种传感器选择时并不有趣，仅举几个例子，摄像头、麦克风、加速度计都可以轻松地与微控制器集成，以从环境中获取实时数据。当这个神经网络框架被用来处理这些数据并提取有用的信息时，有无限的可能性。让我们讨论一下你想用这种技术构建什么样的应用。

不要忘记查看这个可运行的 Google Colab 笔记本来学习本教程。

• 标签:
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←如何用 CMSIS-NN 在微控制器上运行深度学习模型(第二部分)
• 如何在浏览器上训练神经网络→

如何用 CMSIS-NN 在微控制器上运行深度学习模型(上)

原文：https://www.dlology.com/blog/how-to-run-deep-learning-model-on-microcontroller-with-cmsis-nn/

发帖人:程维四年零六个月前

(评论)

TL；DR 您将学习如何在 ARM 微控制器上运行 CIFAR10 图像分类模型，如 STM32F4 Discovery board 或类似产品上的微控制器。

为什么要在微控制器上运行深度学习模型？

如果你以前玩过 Arduino，很容易有这样的印象:它们是计算和内存资源有限的小芯片，但在从各种传感器收集数据或控制机器人手上的伺服系统时却非常出色。

许多微控制器要么运行在 FreeRTOS 等实时操作系统上，要么运行在没有操作系统的裸机上。这两种方式都使它们非常稳定且响应迅速，尤其是在任务关键的情况下。

然而，随着传感器收集的数据越来越多，声音和图像这两种最常见的数据类型需要大量的计算资源来处理，以生成有用的结果。这项任务通常是通过要求微控制器将数据上传到网络连接的服务器来完成的，服务器将处理后的结果发送回边缘，然后微控制器将进行特定的行为，如问候和开灯。

你可能已经注意到这个计划的一些缺点。

• 敏感数据会传到云端、照片和录音中。
• 出售这些数据的公司可能会收取服务费，甚至出售你的私人数据。
• 如果没有与服务器的网络连接，它将无法工作。
• 数据在设备和服务器之间来回传输会带来延迟。
• 在电路设计上需要网络和无线硬件组件，这增加了成本。
• 发送无用的数据可能会浪费带宽。

如果一切都独立于微控制器之内，不仅节省带宽、功耗和成本，还具有低延迟、令人难以置信的可靠性和隐私性，那岂不是很好？

CMSIS-NN 概述

CMSIS-NN 是一组针对 ARM Cortex-M 内核微控制器优化的神经网络功能，支持将神经网络和机器学习推入物联网应用的终端节点。

它实现了流行的神经网络层类型，如卷积、深度可分离卷积、全连接、轮询和激活。利用它的效用函数，还可以构造更复杂的神经网络模块，如 LSTM 和格鲁

对于用 TensorFlow、Caffe 等流行框架训练的模型。权重和偏差将首先量化为 8 位或 16 位整数，然后部署到微控制器进行推理。

基于 CMSIS-NN 内核的神经网络推理据称在运行时间/吞吐量方面实现了 4.6 倍的提升，与基线实施相比实现了 4.9 倍的提升。最佳性能是通过利用 CPU 的 SIMD 指令特性来提高 Cortex-M4 和 Cortex- M7 内核微控制器的并行性实现的，尽管 Cortex-M0 和 Cortex-M3 的参考实现也可以在没有 DSP 指令的情况下实现。

在微控制器上运行模型

在本节中，我们将在一个STM 32 f 4 Discovery board或类似的 Keil MDK-ARM 上运行 CIRAR10 图像分类模型。

在继续之前，您需要，

• 安装了基尔·MDK-ARM 的 Windows 电脑。您可以在 my GitHub repo 中找到获取和安装软件的说明。
• 本教程选择的 Cortex-M4 或 Cortex-M7 内核微控制器板最好是 STM32F4 发现板。

第一次上电板

• 做 不做 连接板卡到 PC！转到C:\ Keil _ V5 \ ARM \ STLink \ USB driver，双击STLink _ win USB _ install . bat安装板载 USB ST-Link/V2 的驱动程序。
• 用迷你 USB 线将 USB 电源 USB ST-Link/V2 端口连接到电脑。Windows 识别 ST-Link/V2 设备并自动安装驱动程序。

板载 STM32F407VGT6 微控制器采用 32 位 ARM Cortex -M4，带 FPU 内核、1 兆字节闪存和 192 千字节 RAM，最大功耗上限为 465mW。

尽管我的 GitHub 中的项目已经配置好并准备好在板上运行，但是如果你想知道它是如何配置的或者你想在不同的目标上运行，这还是很有帮助的。

该项目基于官方的 CMSIS-NN CIFAR10 示例，因此请从 GitHub 下载整个 CMSIS_5 repo 。

您可以在以下位置访问示例项目

.\CMSIS\NN\Examples\ARM\arm_nn_examples\cifar10

添加新目标

用基尔·MDK-ARM 打开arm_nnexamples_cifar10.uvprojx项目。该项目最初被配置为仅在模拟器上运行，我们将从添加一个新目标开始。该项目可以配置为在不同的微控制器/板上运行，基尔·MDK-ARM 正在通过“目标”组织它们。

右击当前目标，然后从菜单中点击“管理项目项按钮。

创建一个新目标，并将其命名为“STM32F407DISCO ”,以帮助您记住其用途。突出显示您的新目标，点击“设为当前目标”，然后点击“确定”。

配置目标选项

打开目标选项，转到“设备选项卡，选择目标微控制器。如果您无法搜索“STM32F407”，则有必要从 pack installer 中手动获取它，或者通过打开一个配置了 STM32F4 DISCO 板的现有项目，然后 IDE 将提示安装它。

转到“目标选项卡，将外部晶振频率更改为 8MHz，并将片内存储区更改为与板上的相匹配。

在“C/C++”选项卡中，添加“HSE_VALUE=8000000”作为预定义符号，告诉编译器外部晶振频率为 8MHz。这与在 C/C++源代码中定义下面的代码行是一样的，只是预定义的符号允许您在不修改源代码的情况下为不同的目标配置编译项目。

或者，关闭编译器优化以改善调试体验。更高级别的编译器优化一方面通过使软件消耗更少的资源来改进代码，但另一方面减少了调试信息并改变了代码的结构，这使得代码更难调试。

在 Debug 选项卡中，选择 STM32F4 DISCO 板上的“ST-Link Debugger”，点击按钮进行配置。

如果您的主板插上电源，ST-LINK/V2 调试器适配器将出现在新窗口中，并检查端口“SW”是否被选中。

在【Trace】选项卡中，输入正确的 CPU 核心时钟 速度，如您的项目中所指定。勾选 追踪启用 框。 Trace 允许您通过 SWO(单线输出)查看 printf 消息，其中是 Cortex-M3/M4/M7 上可用的单引脚异步串行通信通道，由主调试器探针支持。该功能类似于 Arduino 的" Serial.printf "功能，用于打印调试信息，但不需要 UART 端口。

在 Flash 下载选项卡中添加“STM32F4xx Flash”编程算法，这样您就可以将二进制文件下载到其 Flash 存储器中。

现在确认更改并关闭目标窗口的选项。

配置运行在 168MHz

在微控制器的启动文件中，还有一个步骤来配置微控制器以 168MHz 运行。

简单的方法是用你的启动文件替换 GitHub 中我的启动文件，同时有几点值得一提，以了解微控制器系统时钟一般是如何工作的。

为了获得最终的 168MHz 系统时钟，我们需要将“PLL_M”参数设置为 8。

《美少女的谎言》缩写为 PLL，等等，我的意思是锁相环是微控制器中的一个时钟产生引擎，用来产生远高于内部或外部晶振频率的时钟速度。如果你玩过 Arduino 板，如 Leonardo，你就已经见过 PLL，尽管你的 Arduino 代码运行在 16MHz 系统时钟，但其 USB2.0 总线从其片内 PLL 提升了 48MHz。设置好 PLL 参数后，这里是 STM32F4 的整体时钟配置图。它显示了 168Mhz 系统时钟是如何从最初的 8Mhz 高语音外部(HSE)时钟获得的。

构建和调试

现在我们已经准备好了，将开发板连接到您的 PC，只需构建和调试应用程序。

启用 printf 消息的跟踪视图并运行代码，您将看到 CIFAR10 模型的输出。

以一幅 32×32 像素的彩色图像作为输入，然后由模型将其分类为 10 个输出类别之一。

由于该值是 softmax 层的输出，每个数字表示 10 个图像类别之一的概率。在下面的例子中，标签 5 对应于具有最高数字的“狗”标签，这意味着模型在输入图像中找到了狗。

在下一节中，我将向您展示如何用您的自定义图像来填充模型。

创建新的输入图像

中的IMG _ 数据定义了输入的图像数据。图像数组存储为 HWC 格式或高-宽-通道，这是一个 32x32 RGB 彩色图像，具有 32 x 32 x 3 = 3072 个值。

我们可以有一个更高分辨率的图像作为输入吗？是的，但是必须首先调整图像的大小并进行裁剪，这可以通过下面的 python 代码片段来实现。

该函数将返回一个包含 3072 个数字的 numpy 数组，然后该数组将被裁剪为 int8 数字，并以正确的格式写入一个头文件。

总结和进一步阅读

想要深入源代码并了解一切是如何工作的吗？这将是我的下一篇博文。

同时，这里有一些我认为有用的资源来学习 ARM Cortex-M 微控制器、STM32、CMSIS-NN 和 Keil-MDK 等。

ARM Cortex-M WiKi

STM 32 f 4-发现快速入门指南

STM 32 f 4 发现板示例代码

CMSIS NN 软件库文档

Arm 的项目 Trillium - Processors 机器学习

别忘了从我的 GitHub 页面查看源代码。

• 标签:
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←利用深度方向可分离卷积的简单语音关键词检测
• 如何用 CMSIS-NN 在微控制器上运行深度学习模型(第二部分)→

如何在 TensorFlow 中运行 GPU 加速信号处理

原文：https://www.dlology.com/blog/how-to-run-gpu-accelerated-signal-processing-in-tensorflow/

发帖人:程维 4 年 2 个月前

(评论)

TensorFlow 框架内部深处存在一个很少被注意到的模块: tf.contrib.signal 它可以帮助为你的 TensorFlow/Keras 模型构建 GPU 加速的音频/信号处理管道。在本帖中，我们将采用一种实用的方法来检验一些最流行的信号处理操作，并将结果可视化。

你可以在 my GitHub 上找到这篇文章的源代码，以及一个可运行的 Google Colab 笔记本。

开始

我们将在 TensorFlow 中构建一个完整的计算图，它采用 wav 文件名并输出 MFCC 特征。有一些中间输出/音频特性可能很有趣，因此我们将启用 TensorFlow eager execution，它允许我们立即评估操作，而无需构建完整的图形。如果你是第一次接触 TensorFlow 渴望执行，你会发现它比 graph API 更直观。

下面的代码片段将带您开始 TensorFlow 中的热切执行。

解码 WAV 文件

tf.contrib.ffmpeg.decode_audio 依靠本地安装的 FFmpeg 库来解码音频文件。

要在基于 Linux 的系统上安装 FFmpeg，请运行以下命令。

之后，我们可以下载一个小样本的警笛声 wav 文件，用 TensorFlow 解码。

waveform是一个张量，在急切执行的帮助下，我们可以立即评估它的值并将其可视化。

从原始波形中，我们几乎看不到任何警报声的特征，加上可能有太多的数据直接输入神经网络。接下来的几个步骤将提取音频信号的频域签名。

Declaimer:Windows 不支持使用tf.contrib.ffmpeg解码音频文件。指 https://github.com/tensorflow/tensorflow/issues/8271 问题。

Windows 上的另一种方法是用 scipy 解码 wav 文件。

计算光谱图

光谱图新手？查看酷炫的 Chrome 音乐实验室实验，将你的声音实时可视化为频谱图。

计算光谱图最常用的方法是采用 STFT 的幅度(短时傅立叶变换)。

任何音频波形都可以用不同频率、相位和幅度的正弦波组合来表示。当信号随时间变化时，STFT 可以确定信号局部的正弦频率和相位内容。

tf.contrib.signal.stft``signals。该操作接受形状为 (批量大小，样本) 的张量“信号”。

stfts张量的形状为 (batch_size，frames，fft_unique_bins) ，每个值包含一个具有实部和虚部的 *a* + *bi *形式的复数。

能量谱图是复值 STFT 的幅度，即 sqrt{a^2 + b^2}。

在 TensorFlow 中，它可以简单地计算为:

我们可以绘制能量谱图，我们可以发现图像顶部显示的一些模式，其中频率上下波动，类似于警笛声的音调变化。

计算梅尔频率倒谱系数

如你所见，在计算的能量谱图中有 513 个频率组，许多是“空白”的。当处理音频的频谱表示时，Mel 频率倒谱系数(MFCCs)被广泛用于自动语音和说话人识别 ，这导致了音频的低维且更感知相关的表示。

我们可以在 TensorFlow 中将能量/星等谱图转换成 Mel 谱图，并将其结果绘制成这样。

如果需要，我们可以指定包含在 Mel 频谱中的频率的下限和上限。

num_mel_bins 指定得到的 Mel-光谱中有多少个波段。

为了进一步压缩 Mel 频谱图幅度，您可以应用压缩非线性，如对数压缩，这有助于平衡频谱的低能量和高能量区域中细节的重要性，这更符合人类的听觉灵敏度。

log_offset是添加的一个小数字，以避免在极少数情况下对零应用 log() 。

最后一步， tf.contrib.signal.mfccs_from_log_mel_spectrograms 计算MFCC从 log_mel_spectrograms。

一起构建一切

将所有内容放入 TensorFlow 管道中。

结论和进一步阅读

在这篇文章中，我们介绍了如何在 TensorFlow 中进行 GPU 支持的信号处理。我们走过了从解码 WAV 文件到计算波形的 MFCCs 特征的每一步。构建最终管道，您可以应用到现有的 TensorFlow/Keras 模型，以制作端到端的音频处理计算图。

一些你可能会觉得有用的相关资源。

梅尔频率倒谱系数(MFCC)教程

Chrome 音乐实验室声谱图实验

GitHub 上这篇文章的源代码。

• 标签:
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←如何免费用 TPU 训练出速度快 20 倍的 Keras 车型
• 如何在 Python 3 中加载 Python 2 PyTorch 检查点→

如何利用 CPU 和英特尔 OpenVINO 将 Keras 模型推理运行速度提高 x3 倍

原文：https://www.dlology.com/blog/how-to-run-keras-model-inference-x3-times-faster-with-cpu-and-intel-openvino-1/

发帖人:程维 3 年 11 个月前

(评论)

在这个快速教程中，您将学习如何设置 OpenVINO，并在不增加任何硬件的情况下使您的 Keras 模型推断速度至少提高 3 倍。

虽然有多种选择可以加速你在边缘设备上的深度学习推理，举几个例子，

• 添加低端 Nvidia GPU，如 GT1030
  • 优点:易于集成，因为它也利用 Nvidia 的 CUDA 和 CuDNN 工具包来加速与您的开发环境相同的推理，不需要重大的模型转换。
  • 缺点:PCI-E 插槽必须存在于目标设备的主板上，以便与图形卡接口，这增加了边缘设备的额外成本和空间。
• 使用面向加速神经网络推理的 ASIC 芯片，如 Movidius 神经计算棒、 Lightspeeur 2801 神经加速器。
  • 优点:
    • 就像 u 盘一样，它们也工作在不同的主机上，无论是采用 Intel/AMD CPU 的台式电脑，还是采用 ARM Cortex-A 的 Raspberry Pi 单板电脑。
    • 神经网络计算被卸载到这些 u 盘上，使得主机的 CPU 只需担心更多的通用计算，如图像预处理。
    • 随着边缘设备上吞吐量需求的增加，扩展可以像插入更多 USB 棒一样简单。
    • 与 CPU/Nvidia GPU 相比，它们通常具有更高的性能功耗比。
  • 缺点:
    • 由于它们是 ASIC(专用集成电路),预计对某些 TensorFlow 层/操作的支持有限。
    • 它们还需要特殊的模型转换来创建特定 ASIC 可理解的指令。
• 嵌入式 SoC 带有 NPU(神经处理单元)，如 Rockchip RK3399Pro。
  • NPU 类似于 ASIC 芯片，需要特殊的指令和模型转换。不同之处在于，它们与 CPU 位于同一个硅芯片中，这使得外形尺寸更小。

前面提到的所有加速选项都需要额外的成本。但是，如果一个边缘设备已经有了英特尔的 CPU，你还不如用英特尔的 OpenVINO toolkit 免费加速它的深度学习推理速度 x3 倍。

OpenVINO 和设置简介

您可能想知道，如果没有额外的硬件，额外的加速从何而来？

首先，因为 OpenVINO 是英特尔的产品，所以它针对其处理器进行了优化。

OpenVINO 推理引擎可以推理具有不同输入精度支持的 CPU 或英特尔集成 GPU 模型。

CPU 支持 FP32 和 Int8，而其 GPU 支持 FP16 和 FP32。

CPU 插件利用面向深度神经网络(MKL-DNN)的英特尔数学内核库以及 OpenMP 来并行化计算。

下面是 OpenVINO 2019 R1.01 支持的插件和量化精度矩阵。

| 插件 | FP32 | FP16 | I8 |
| CPU plugin | 支持和首选 | 不支持 | 支持 |
| GPU 插件 | 支持 | 支持和首选 | 不支持 |
| FPGA plugin | 支持 | 支持 | 不支持 |
| VPU 插件 | 不支持 | 支持 | 不支持 |
| GNA 插件 | 支持 | 不支持 | 不支持 |

您将在本教程的后面部分看到模型优化，在此过程中，会采取额外的步骤来使模型更加紧凑，以便进行推理。

• 群卷积的合并。
• 用 ReLU 或 eLU 融合卷积。
• 融合卷积+和或卷积+和+ ReLu。
• 移除电源层。

现在，让我们在你的机器上安装 OpenVINO，在这一页上选择你的操作系统，按照说明下载并安装它。

系统需求

• 第六至第八代英特尔酷睿
• 英特尔至强 v5 家族
• 英特尔至强 v6 家族

操作系统

• Ubuntu* 16.04.3 长期支持(LTS)，64 位
• CentOS* 7.4，64 位
• 64 位 Windows* 10
• macOS* 10.14

如果您已经安装了 Python 3.5+，则可以安全地忽略安装 Python 3.6+的通知。

安装完成后，查看 Linux 、 Window 10 或 macOS 安装指南，完成安装。

OpenVINO 中的 InceptionV3 模型推理

你可以从 my GitHub 下载本教程的完整源代码，它包括一个 all in one Jupyter 笔记本你通过转换一个用于 OpenVINO 的 Keras 模型，对所有三种环境——Keras、TensorFlow 和 open vino——进行预测以及基准推理速度。

运行setupvars.bat调用jupyter notebook来设置环境。

C:\Program Files (x86)\IntelSWTools\openvino\bin\setupvars.bat 

或者在 Linux 中添加下面一行到 ~/.bashrc

source /opt/intel/openvino/bin/setupvars.sh

以下是将 Keras 模型转换为 OpenVINO 模型并进行预测的工作流程概述。

1. 将 Keras 模型另存为单个 .h5 文件。
2. 加载.h5文件并将图形冻结为单个张量流 .pb 文件。
3. 运行 OpenVINO mo_tf.py 脚本将 .pb 文件转换为模型 XML 和 bin 文件。
4. 用 OpenVINO 推理引擎加载模型 XML 和 bin 文件，并进行预测。

将 Keras 模型保存为一个单独的.h5文件

对于本教程，我们将从 Keras 加载一个预训练的 ImageNet 分类 InceptionV3 模型，

将图形冻结到单个 张量流.pb 文件中

这一步将删除推理不需要的任何层和操作。

OpenVINO 模型优化

下面的代码片段运行在 Jupyter 笔记本中，它根据您的操作系统(Windows 或 Linux)定位mo_tf.py脚本，您可以相应地更改img_height。data_type也可以设置为 FP16，以便在英特尔集成 GPU 上进行推理时获得额外的加速，但进动性能会有所下降。

运行脚本后，你会发现在 目录下生成了两个新文件./model``frozen_model.xml和 frozen_model.bin 。它们是基于训练好的网络拓扑、权重和偏差值的模型的优化中间表示(IR)。

使用 OpenVINO 推理引擎(IE)进行推理

如果环境设置正确， 路径 如同C:\Intel\computer_vision_sdk\python\python3.5或~/intel/computer_vision_sdk/python/python3.5将 存在于PYTHONPATH。这是在运行时加载 Python openvino 包所必需的。

以下代码片段使用 CPU 运行推理引擎，如果您之前选择使用 FP16 data_type，它也可以在英特尔 GPU 上运行。

速度基准

基准设置，

• TensorFlow 版本:1.12.0
• 操作系统:Windows 10，64 位
• CPU:英特尔酷睿 i7-7700HQ
• 计算平均结果的推断次数:20。

所有三种环境的基准测试结果——Keras、TensorFlow 和 OpenVINO 如下所示。

Keras          average(sec):0.079, fps:12.5
TensorFlow     average(sec):0.069, fps:14.3
OpenVINO(CPU)  average(sec):0.024, fps:40.6

结果可能因您正在试验的英特尔处理器而异，但与在 CPU 后端使用 TensorFlow / Keras 运行推理相比，预计会有显著的加速。

结论和进一步阅读

在本教程中，您学习了如何使用英特尔处理器和 OpenVINO toolkit 运行模型推理，其速度比股票 TensorFlow 快几倍。虽然 OpenVINO 不仅可以加速 CPU 上的推理，但本教程中介绍的相同工作流可以很容易地适应一个 Movidius neural compute 棒，只需做一些更改。

OpenVINO 文档可能对您有所帮助。

安装英特尔 open vino toolkit for Windows * 10 分发版

安装英特尔发布的 OpenVINO toolkit for Linux *

open vino-Advanced Topics-CPU Plugin在这里你可以了解更多关于各种模型优化技术的知识。

从 my GitHub 下载本教程的完整源代码。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←如何从 Keras 中的图像文件进行混音训练
• 如何免费训练一个简单的物体检测模型→

如何在 Nvidia Docker 容器中的 Jetson Nano 上运行 Keras 模型

原文：https://www.dlology.com/blog/how-to-run-keras-model-on-jetson-nano-in-nvidia-docker-container/

发帖人:程维三年零四个月前

(评论)

不久前，我写了“如何在 Jetson Nano 上运行 Keras 模型”，其中模型在主机操作系统上运行。在本教程中，我将向您展示如何重新开始，并让模型在 Nvidia docker 容器内的 Jetson Nano 上运行。

你可能想知道为什么要为 Jetson Nano 上的 docker 费心？我想出了几个理由。

1.与自己安装依赖项/库相比，用 docker 容器来重现结果要容易得多。因为你从 docker Hub 下载的 Docker 映像已经预装了所有的依赖项，这可以节省你从源代码构建的大量时间。

2.它不太可能搞乱 Jetson Nano 主机操作系统，因为您的代码和依赖项与它是隔离的。即使你遇到麻烦，解决问题也只是重新启动一个新的容器。

3.您可以通过创建一个新的 docker 文件，以一种更加可控的方式，基于预安装了 TensorFlow 的我的基本映像构建您的应用程序。

4.您可以用一台更强大的计算机(如基于 X86 的服务器)交叉编译 Docker 映像，节省宝贵的时间。

5.最后，你猜对了，在 Docker 容器中运行代码几乎和在有 GPU 加速的主机操作系统上运行一样快。

希望你相信，这里有一个如何做到这一点的简要概述。

• 在 Jetson Nano 上安装新的 JetPack 4.2.1。
• 在 X86 机器上交叉编译 Docker 构建设置。
• 用 TensorFlow GPU 搭建一个 Jetson Nano docker。
• 构建覆盖 Docker 图像(可选)。
• 在 Docker 容器中运行冻结的 Keras TensorRT 模型。

在 Jetson Nano 上安装新的 JetPack 4.2.1

从 Nvidia 下载 JetPack 4.2.1 SD 卡镜像。从 zip 中解压 sd-blob-b01.img 文件。用 Rufus 把它闪存到 10 级 32GB 最小 SD 卡。我的 SD 卡是 SanDisk class10 U1 64GB 型号。

你可以试试另一个闪光器，比如蚀刻机，但是我用蚀刻机闪的 SD 卡不能在 Jetson Nano 上启动。我也试着用 SDK 管理器安装 JetPack，但是遇到了一个关于“系统配置向导”的问题。还有我在 Nvidia 开发者论坛上开的线程，他们的技术支持很有反应。

插入 SD 卡，插上 HDMI 显示器电缆、USB 键盘和鼠标，然后打开主板电源。按照系统配置向导完成系统配置。

在 X86 机器上交叉编译 Docker 构建设置

即使 Nvidia Docker 运行时预装在操作系统上，允许您在硬件上构建 Docker 容器。然而，考虑到更大的处理能力和网络速度，在基于 X86 的机器上交叉编译 Docker 可以节省大量的构建时间。所以为交叉编译环境设置一次是非常值得的。docker 容器将在服务器上构建，推送到 Docker 注册中心，如 Docker Hub，然后从 Jetson Nano 中取出。

在您的 X86 机器上，可能是您的笔记本电脑或 Linux 服务器，首先按照官方说明安装 Docker 。

然后从命令行安装 qemu ，qemu 在构建 Docker 容器时会在你的 X86 机器上模拟 Jetson Nano CPU 架构(也就是 aarch64)。

sudo apt-get install -y qemu binfmt-support qemu-user-static
wget http://archive.ubuntu.com/ubuntu/pool/main/b/binfmt-support/binfmt-support_2.1.8-2_amd64.deb
sudo apt install ./binfmt-support_2.1.8-2_amd64.deb
rm binfmt-support_2.1.8-2_amd64.deb

最后安装波德曼。我们将使用它来构建容器，而不是默认的 docker 容器命令行界面。

sudo apt update
sudo apt -y install software-properties-common
sudo add-apt-repository -y ppa:projectatomic/ppa
sudo apt update
sudo apt -y install podman

使用 TensorFlow GPU 构建 Jetson Nano Docker

我们基于官方的nvcr.io/nvidia/l4t-base:r32.2映像构建我们的 TensorFlow GPU Docker 映像。

这里是 Dockerfile 的内容。

FROM nvcr.io/nvidia/l4t-base:r32.2
WORKDIR /
RUN apt update && apt install -y --fix-missing make g++
RUN apt update && apt install -y --fix-missing python3-pip libhdf5-serial-dev hdf5-tools
RUN apt update && apt install -y python3-h5py
RUN pip3 install --pre --no-cache-dir --extra-index-url https://developer.download.nvidia.com/compute/redist/jp/v42 tensorflow-gpu
RUN pip3 install -U numpy
CMD [ "bash" ]

然后，您可以像这样提取基本映像，构建容器映像并将其推送到 Docker Hub。

podman pull nvcr.io/nvidia/l4t-base:r32.2
podman build -v /usr/bin/qemu-aarch64-static:/usr/bin/qemu-aarch64-static -t docker.io/zcw607/jetson:0.1.0 . -f ./Dockerfile
podman push docker.io/zcw607/jetson:0.1.0

根据需要将 zcw607 更改为您自己的 Docker Hub 帐户名称，您可能需要在推送至注册表之前先执行docker login docker.io操作。

构建覆盖 Docker 图像(可选)

通过构建一个覆盖 Docker 映像，您可以基于以前的 Docker 映像添加您的代码依赖项/库。

例如，您想要安装 Python pillow 库并设置一些其他东西，您可以创建一个像这样的新 other 文件。

FROM zcw607/jetson:0.1.0
WORKDIR /home
ENV TZ=Asia/Hong_Kong
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone \
 apt update && apt install -y python3-pil
CMD [ "bash" ]

然后运行这两行代码来构建和推送新的容器。

podman build -v /usr/bin/qemu-aarch64-static:/usr/bin/qemu-aarch64-static -t docker.io/zcw607/jetson:r1.0.1 . -f ./Dockerfile
podman push docker.io/zcw607/jetson:r1.0.1

现在您的两个 Docker 容器驻留在 Docker Hub 中，让我们在 Jetson Nano 上同步。

在 Docker 容器中运行 TensorRT 模型

在 Jetson Nano 命令行中，像这样从 Docker Hub 中拉出 Docker 容器。

docker pull docker.io/zcw607/jetson:r1.0.1

然后用下面的命令启动容器。

docker run --runtime nvidia --network host -it -e DISPLAY=$DISPLAY -v /tmp/.X11-unix/:/tmp/.X11-unix zcw607/jetson:r1.0.1

检查是否安装了 TensorFlow GPU，然后在命令中键入“python3 ”,

如果一切正常，应该可以打印出来

要运行 TensorRT 模型推理基准，请使用 my Python 脚本。该模型由用于图像分类的 Keras MobilNet V2 模型转换而来。它在 244×244 彩色图像输入的情况下实现了 30 FPS。这是在 Docker 容器中运行的，与没有 Docker 容器运行的 27.18FPS 相比，它甚至略快。

阅读我之前的博客了解更多关于如何从 Keras 创建 TensorRT 模型的信息。

结论和进一步阅读

本教程展示了在 Nvidia Docker 容器中获得运行在 Jetson Nano 上的 Keras 模型的完整过程。您还可以了解如何在 X86 机器上构建 Docker 容器，推送至 Docker Hub，以及从 Jetson Nano 拉取。查看我的 GitHub repo 获取更新的 Dockerfile、构建脚本和推理基准脚本。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←如何为实例分割创建自定义 COCO 数据集
• 用于物体检测的深度学习的最新进展-第 1 部分→

如何在捷成纳米上运行 Keras 模型

原文：https://www.dlology.com/blog/how-to-run-keras-model-on-jetson-nano/

发帖人:程维三年零八个月前

(评论)

杰特森纳米开发者套件在 2019 年 GTC 上宣布售价 99 美元，为边缘计算硬件领域带来了一个新的竞争对手，以及更昂贵的前辈杰特森 TX1 和 TX2。Jetson Nano 的到来使该公司比其他平价产品更具竞争优势，仅举几个例子， Movidius 神经计算棒，运行 OpenVINO 的英特尔显卡和谷歌 edge TPU 。

在这篇文章中，我将向你展示如何在 Jetson Nano 上运行 Keras 模型。

下面是如何实现这一点的分解。

1. 冻结 Keras 模型到 TensorFlow 图，然后用 TensorRT 创建推理图。
2. 在 Jetson Nano 上加载tensort 推理图并进行预测。

我们将在开发机器上完成第一步，因为它的计算和资源密集程度远远超出了 Jetson Nano 的处理能力。

让我们开始吧。

设置 Jetson Nano

按照官方入门指南来刷新最新的 SD 卡镜像、设置和引导。

需要记住的一点是，Jetson Nano 不像最新的 Raspberry Pi 那样配备 WIFI 无线电，所以建议准备一个像这个这样的 USB WIFI 转换器，除非你打算用硬连线的方式连接它的以太网插孔。

在 Jetson Nano 上安装 TensorFlow

Nvidia 开发者论坛上有一个关于官方支持 Jetson Nano 上 TensorFlow 的帖子，这里有一个如何安装它的快速运行。

启动到 Jetson Nano 的终端或 SSH，然后运行这些命令。

如果您遇到下面的错误，

Cannot compile 'Python.h'. Perhaps you need to install python-dev|python-devel

试着跑

sudo apt install python3.6-dev

Python3 将来可能会更新到更高的版本。你总是可以先用 python3 - version 检查你的版本，并相应地修改之前的命令。

安装 Jupyter Notebook 也很有帮助，这样您就可以从开发机器远程连接到它。

pip3 install jupyter

另外，请注意 Python OpenCV 版本 3.3.1 已经安装，这减轻了交叉编译的痛苦。您可以通过从 Python3 命令行界面导入 cv2 库来验证这一点。

步骤 1:冻结 Keras 模型并转换成 TensorRT 模型

在你的开发机器上运行这个步骤，Tensorflow nightly builds 默认包含 TF-TRT，或者在 Colab 笔记本的免费 GPU 上运行。

首先让加载一个 Keras 模型。对于本教程，我们使用 Keras 附带的预培训 MobileNetV2，必要时可以随意用您的自定义模型替换它。

一旦将 Keras 模型保存为单个.h5文件，就可以将其冻结为一个张量流图用于推理。

记下输出中打印的输入和输出节点名称。我们在转换 TensorRT 图和预测图时会需要它们的推断。

对于 Keras MobileNetV2 车型，分别是，['input_1'] ['Logits/Softmax']。

通常，这个冻结的图表是您用于部署的。然而，它没有优化运行在 Jetson Nano 上的速度和资源效率。这就是 TensorRT 发挥作用的地方，它将模型从 FP32 量化到 FP16，有效地减少了内存消耗。它还将层和张量融合在一起，进一步优化了 GPU 内存和带宽的使用。所有这些都很少或没有明显降低准确性。

这可以在一次呼叫中完成，

结果也是一个张量流图，但经过优化，可以在装有 TensorRT 的 Jetson Nano 上运行。让我们将它保存为一个单独的.pb文件。

将 tensort graph.pb文件从 colab 或您的本地机器下载到您的 Jetson Nano 中。您可以使用 scp/ sftp 远程复制文件。对于 Windows，你可以使用 WinSCP ，对于 Linux/Mac 你可以从命令行尝试 scp/sftp。

第二步:加载 张量图并进行预测

在你的 Jetson Nano 上，用命令jupyter notebook --ip=0.0.0.0启动一个 Jupyter 笔记本，在那里你已经将下载的图形文件保存到了./model/trt_graph.pb。下面的代码将加载 TensorRT 图，并为推理做好准备。

对于您选择的 Keras 型号而非 MobileNetV2，输出和输入名称可能会有所不同。

现在，我们可以用大象图片进行预测，看看模型是否正确。

基准测试结果

让我们运行几次推理，看看它能跑多快。

它得到了 27.18 FPS，可以认为是实时预测。此外，Keras 模型可以在 Colab 的 Tesla K80 GPU 上以 60 FPS 的速度推理，比 Jetson Nano 快一倍，但那是数据中心卡。

结论和进一步阅读

在本教程中，我们介绍了如何使用 TensorRT 转换、优化 Keras 图像分类模型，并在 Jetson Nano 开发套件上运行推理。现在，尝试另一个 Keras ImageNet 模型或您的定制模型，将 USB 网络摄像头/ Raspberry Pi 摄像头连接到它，并进行实时预测演示，请务必在下面的评论中与我们分享您的结果。

未来，我们将研究其他应用程序的运行模型，例如对象检测。如果你对其他负担得起的边缘计算选项感兴趣，请查看我的上一篇文章，如何使用 CPU 和英特尔 OpenVINO 将 Keras 模型推理运行速度提高 x3 倍也适用于 Linux/Windows 和 Raspberry Pi 上的 Movidius neural compute stick。

本教程的源代码可在我的 GitHub repo 上获得。你也可以跳过第一步模型转换，直接从 GitHub repo 版本下载 trt_graph.pb 文件。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←如何使用贝叶斯优化对 Keras 模型进行超参数搜索
• 如何在 Jetson Nano 上运行 TensorFlow 对象检测模型→

如何在 Movidius 神经计算棒上运行 Keras 模型

原文：https://www.dlology.com/blog/how-to-run-keras-model-on-movidius-neural-compute-stick/

发帖人:程维四年零四个月前

(评论)

Movidius neural compute stick(NCS)以及其他一些硬件设备，如 UP AI Core、AIY vision bonnet 和最近发布的谷歌 edge TPU 正在逐步将深度学习引入资源受限的 IOT 设备。我们离制造你一直期待的 DIY 猎杀无人机又近了一步吗？过去用于实现严重深度学习图像处理的强大 GPU 可以缩小到更即插即用的大小，可以将其视为一种移动中的迷你神经网络。如果这开始听起来有点太“终结者”了，请阻止我。

作为一名熟悉 Keras 深度学习框架的开发者和程序员，你很有可能能够将你训练的模型部署到 NCS 上。在本教程中，我将向您展示训练一个简单的 MNIST Keras 模型并将其部署到 NCS 是多么容易，NCS 可以连接到 PC 或 Raspberry Pi。

有几个步骤，

1. 在 Keras (TensorFlow 后端)中训练模型
2. 在 Keras 中保存模型文件和权重
3. Turn Keras model to TensorFlow
4. 将张量流模型编译成 NCS 图
5. 在 NCS 上部署和运行图形

让我们逐一看看。

这篇文章的源代码可以在我的 GitHub repo-keras _ mnist上找到。

培训和保存 Keras 模型

就像“你好世界！”首先在你的控制台上打印，训练一个手写数字 MNIST 模型相当于深度学习程序员。

这是一个 Keras 模型，它有几个卷积层，后面有一个最终输出级。完整的 train-mnist.py 代码在我的 GitHub 上，这里有一个简短的片段向您展示这一点。

在 GPU 上训练可能需要 3 分钟，在 CPU 上可能需要更长时间，顺便说一句，如果你现在没有可用的 GPU 训练机，你可以免费查看我之前的教程如何在谷歌的 GPU 上训练你的模型，你需要的只是一个 Gmail 帐户。

无论哪种方式，在训练之后，将模型和权重保存到两个独立的文件中，如下所示。

或者，您可以调用model.save('model.h5', include_optimizer=False)到将模型保存在一个文件中，注意，我们通过将include_optimizer设置为False， 来排除优化器，因为优化器仅用于训练。

Turn Keras to TensorFlow model

由于 Movidius NCSDK2 只编译 TensorFlow 或 Caffe 模型，我们将剥离绑定到 TensorFlow 图的 Keras。下面的代码处理这项工作，让我们看看它是如何工作的，以防将来您可能想要定制它。

首先，我们关闭学习阶段，然后从我们之前保存的两个单独的文件中以标准的 Keras 方式加载模型。

通过从具有 TensorFlow 后端的 Keras 调用 K.get_session() ，一个默认 TensorFlow 会话将可用。您甚至可以通过调用 sess.graph.get_operations() 来进一步探索张量流图内部的内容，其中返回您的模型中的张量流操作列表。这对于搜索 NCS 不支持的操作很有用，您可以从列表中找到它。最后，TensorFlow Saver 类将模型保存到指定路径的四个文件中。

每个文件都有不同的用途，

1. 检查点定义了模型检查点路径，在我们的例子中是“tf_model”。
2. 。meta 存储图形结构，
3. 。数据存储图表中每个变量的值
4. T1。索引标识检查点。

用 mvNCCompile 编译张量流模型

NCSDK2 工具包附带的 mvNCCompile 命令行工具将 Caffe 或 Tensorflow 网络转换为可由 Movidius 神经计算平台 API 使用的图形文件。在图形生成期间，我们将输入和输出节点指定为 mvNCCompile 的 TensorFlow 操作名称。通过 调用 sess.graph.get_operations() ，可以找到 TensorFlow 操作的列表，如前一节所示。在我们的例子中，我们将' conv2d_1_input '作为输入节点，将' dense_2/Softmax '作为输出节点。

最后，编译命令看起来像这样，

mvNCCompile TF_Model/tf_model.meta -in=conv2d_1_input -on=dense_2/Softmax

将在当前目录下生成一个名为“graph”的默认图形文件。

展开图表并做出预测

NCSDK2 Python API 接管，找到 NCS 设备，连接，将图形分配到其内存中，并进行预测。

下面的代码展示了本质部分，而input_img是将预处理后的图像作为 numpy 数组的形状(28，28)。

输出与 Keras 相同，十个数字代表十个数字中每一个的分类概率，我们应用 argmax 函数 找到最可能预测的索引。

Keras 模型现在在 NCS 上运行！你可以在这里调用它，或者通过添加一个网络摄像头来读取实时图像并在 Raspberry Pi 单板计算机而不是 Ubuntu PC 上运行来进一步增强演示。点击查看视频演示。

树莓派上的网络摄像头实时图像预测奖金

在 Pi 上安装 NCSDK2 可能需要几十分钟，这对那些没有耐心的人来说不是个坏消息。但是好消息是，您可以选择只在您的 Pi 上安装 NCSDK2 的必要部分，以便使用在您的 Ubuntu PC 上编译的图形来运行推断。

不要将 NCSDK2 库克隆到您的 Pi，这可能需要很长时间，下载 NCSDK2 的发布版本 zip 文件,这可以节省大量磁盘空间，因为所有 git 版本控制文件都被跳过了。

其次，通过修改 ncsdk.conf 文件中的，在 NCSDK2 安装过程中跳过 TensorFlow 和 Caffe 安装。

运行一个实时网络摄像头需要安装 OpenCV3，在终端中运行下面四行代码就可以了。

sudo pip3 install opencv-python==3.3.0.10
sudo apt-get update
sudo apt-get install libqtgui4
sudo apt-get install python-opencv

一旦 NCSDK2 和 OpenCV 3 安装完成，将您生成的图文件复制到您的 Pi 中。请记住，由于我们跳过了相当多的东西， mvNC** 命令不会在您的 Pi 上运行，因为它们依赖于 Caffe 和 TensorFlow 安装。

训练 MNIST 模型以识别 28×28 分辨率的灰度图像的黑色背景中的白色手写数字，为了转换捕获的图像，一些预处理步骤是必要的。

1. 裁剪图像的中心区域
2. 进行边缘检测以找到图像的边缘，这一步也将图像转换为灰度
3. 扩张边缘，使边缘变得更厚，以填充两条紧密平行边缘之间的区域。
4. 将图像大小调整为 28 x 28

记住这一点，Python OpenCV 3 的类似实现可以在文件 ImageProcessor.py 中找到。为了结束网络摄像头演示，对于捕获的每一帧，我们将其传递给图像预处理函数，然后馈送给 NCS graph，后者像以前一样返回最终的预测概率。从那里，我们将最终的预测结果显示在显示器上的图像上。

结论和进一步阅读

现在您已经向 NCS 部署了一个 Keras 模型。请记住，由于 NCS 是以“视觉处理单元”的目的构建的，它支持卷积层和其他一些层，而 LSTM 和 GRU 等递归神经网络层可能无法在 NCS 上工作。在我们的演示中，我们告诉 mvNCCompile 获取最终的分类输出节点，同时可以使用中间层作为输出节点，在这种意义上，使用模型作为特征提取器，这类似于 NCS 的 faceNet 面部验证演示的工作方式。

一些有用的资源，

TensorFlow 保存和恢复

用神经计算棒系列制作 DIY 安全摄像机

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←用神经计算棒制作 DIY 安全摄像机(第二部分)
• 用树莓派 DIY 物体检测涂鸦相机(第一部分)→

如何在 RK3399Pro 上运行 Keras 模型

原文：https://www.dlology.com/blog/how-to-run-keras-model-on-rk3399pro/

发帖人:程维三年零八个月前

(评论)

此前，我们已经推出了多种嵌入式边缘计算解决方案并对其进行了基准测试，包括用于英特尔神经计算棒的 OpenVINO 、用于 ARM 微控制器的 CMSIS-NN 以及用于 Jetson Nano 的 TensorRT 模型。

它们的共同点是每个硬件提供商都有自己的工具和 API 来量化张量流图，并结合相邻层来加速推理。

这一次，我们将看看 RockChip RK3399Pro SoC，它内置 NPU(神经计算单元)，在 8 位精度下的推理速度为 2.4 次，能够以超过 28 FPS 的速度运行 Inception V3 模型。您将会看到，在电路板上部署 Keras 模型与前面提到的解决方案非常相似。

1. 将 Keras 模型冻结为张量流图，并用 RKNN 工具包创建推理模型。
2. 将 RKNN 模型加载到 RK3399Pro 开发板上并进行预测。

让我们开始第一次设置。

设置 RK3399Pro 板

任何带有 RK3399Pro SoC 的开发板，如 Rockchip Toybrick RK3399PRO 板或 Firefly Core-3399Pro 都应该可以工作。我有一个 Rockchip Toybrick RK3399PRO 板，6GB 内存(2GB 专用于 NPU)。

该板带有许多类似于 Jetson Nano 的连接器和接口。值得一提的是，HDMI 连接器无法与我的显示器一起工作，但是，我可以让 USB Type-C 转 HDMI 适配器工作。

它预装了 Fedora Linux release 28，默认用户名和密码为“toybrick”。

RK3399Pro 有 6 个内核 64 位 CPU，采用 aarch64 架构与杰特森纳米相同的架构，但与只有 ARMv7 32 位的树莓 3B+截然不同。这意味着任何针对 Raspberry Pi 的预编译 python wheel 包都不太可能与 RK3399Pro 或 Jetson Nano 一起工作。不过不要绝望，可以从我的aarch 64 _ python _ packagesrepo 下载预编译的 aarch64 python wheel 包文件包括 scipy、onnx、tensorflow 和 rknn_toolkit 从他们的官方 GitHub 下载。

将这些 wheel 文件传输到 RK3399Pro 板上，然后运行以下命令。

sudo dnf update -y
sudo dnf install -y cmake gcc gcc-c++ protobuf-devel protobuf-compiler lapack-devel
sudo dnf install -y python3-devel python3-opencv python3-numpy-f2py python3-h5py python3-lmdb
sudo dnf install -y python3-grpcio

sudo pip3 install scipy-1.2.0-cp36-cp36m-linux_aarch64.whl
sudo pip3 install onnx-1.4.1-cp36-cp36m-linux_aarch64.whl
sudo pip3 install tensorflow-1.10.1-cp36-cp36m-linux_aarch64.whl
sudo pip3 install rknn_toolkit-0.9.9-cp36-cp36m-linux_aarch64.whl 

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←如何在 Jetson Nano 上运行 TensorFlow 对象检测模型
• 如何在 Jupyter 笔记本中运行 PyTorch 1.1.0 的 tensor board→

如何免费快速运行视频中的对象检测和分割

原文：https://www.dlology.com/blog/how-to-run-object-detection-and-segmentation-on-video-fast-for-free/

发帖人:程维四年零九个月前

(评论)

TL；博士读完这篇文章后，你将学习如何运行艺术状态的对象检测和视频文件分割快速。即使是在集成显卡、旧 CPU、只有 2G 内存的旧笔记本电脑上。

这就是问题所在。这只有在你有互联网连接和谷歌 Gmail 账户的情况下才有效。既然你在读这篇文章，很有可能你已经合格了。

帖子中的所有代码都完全运行在云中。感谢谷歌的合作实验室又名谷歌实验室！

我将免费向您展示如何在具有服务器级 CPU、> 10 GB RAM 和强大 GPU 的 Colab 上运行我们的代码！是的，你没听错。

使用启用 GPU 的 Google Colab

Colab 的建立是为了促进机器学习专业人员更无缝地相互协作。我已经为这个帖子分享了我的 Python 笔记本，点击打开。

如果您还没有登录，请登录右上角的 Google Gmail 帐户。它会让你在屏幕上方用 Colab 打开它。然后你要做一个拷贝，这样你就可以编辑它。

现在你应该可以点击“运行时菜单按钮来选择 Python 的版本以及是否使用 GPU/CPU 来加速计算。

环境都准备好了。这么简单不是吗？没有安装 Cuda 和 cudnn 让 GPU 在本地机器上工作的麻烦。

运行此代码以确认 TensorFlow 可以看到 GPU。

它输出:

Found GPU at: /device:GPU:0

太好了，我们可以走了！

如果你很好奇你用的是什么 GPU 型号。是一款英伟达特斯拉 K80，内存 24G。相当厉害。

运行这段代码自己找出答案。

您稍后会看到 24G 显存确实有所帮助。它可以一次处理更多的帧，以加速视频处理。

屏蔽 R-CNN 演示

该演示基于 Mask R-CNN GitHub repo 。是 Mask R-CNN 在 Keras+TensorFlow 上的实现。它不仅为检测到的对象生成边界框，而且还在对象区域上生成遮罩。

安装依赖项并运行演示

在我们运行演示之前，需要安装一些依赖项。Colab 允许你通过 pip 安装 Python 包，通过 apt-get 安装一般的 Linux 包/库。

以防你还不知道。您当前的 Google Colab 实例运行在 Ubuntu 虚拟机上。您可以在 Linux 机器上运行几乎所有的 Linux 命令。

屏蔽 R-CNN 依赖于 pycocotools ，我们正在用下面的单元格安装。

它从 GitHub 克隆了 coco 存储库。安装生成依赖项。最后，构建并安装 coco API 库。

所有这些都发生在云虚拟机中，而且速度相当快。

我们现在准备将 Mask_RCNN repo 从 GitHub 和 cd 克隆到目录中。

请注意我们是如何使用 Python 脚本而不是运行 shell“CD”命令来更改目录的，因为我们是在当前笔记本中运行 Python 的。

现在，您应该能够像在本地机器上一样在 colab 上运行 Mask R-CNN 演示了。因此，请继续在您的 Colab 笔记本上运行它。

到目前为止，这些样本图像来自 GitHub repo。但是如何用自定义图像进行预测呢？

用自定义图像预测

要上传一张图片到 Colab notebook，我想到的有三个选项。

1.使用像 imgbb 这样的免费图像托管提供商。

2 。创建一个 GitHub repo，然后从 colab 下载图片链接。

通过这两个选项中的任何一个上传图像后，您将获得一个到图像的链接，可以使用 Linux wget 命令将其下载到您的 colab VM。它将一个图像下载到。/images 文件夹。

!wget https://preview.ibb.co/cubifS/sh_expo.jpg -P ./images

如果你只是想上传 1 或 2 张图片，而不在乎互联网上的其他人也能看到它的链接，前两个选项将是理想的。

3.使用 Google Drive

如果您有私人图像/视频/其他文件要上传到 colab，该选项是理想的。

运行此块来验证虚拟机以连接到您的 Google Drive。

在运行期间，它将要求两个验证代码。

然后执行此单元将驱动器挂载到目录' drive '

您现在可以访问目录中的 Google drive 内容。/驱动

!ls drive/

希望到目前为止你玩得开心，为什么不在一个视频文件上试试呢？

处理视频

处理一个视频文件需要三个步骤。

1.视频到图像帧。

2.处理图像

3.将处理后的图像转换为输出视频。

在我们之前的演示中，我们要求模型一次只处理一幅图像，就像在IMAGES_PER_GPU中配置的那样。

如果我们要一帧一帧地处理整个视频，那将需要很长时间。因此，我们将利用 GPU 来并行处理多个帧。

Mask R-CNN 的流水线计算量相当大，占用大量 GPU 内存。我发现 24G 内存的 Colab 上的 Tesla K80 GPU 可以安全地一次处理 3 张图像。如果超出这个范围，笔记本电脑可能会在处理视频的过程中崩溃。

所以在下面的代码中，我们将batch_size设置为 3，并使用【cv2】库在用模型处理它们之前一次暂存 3 个图像。

运行这段代码后，您现在应该将所有处理过的图像文件放在一个文件夹 ./videos/save 中。

下一步很简单，我们需要从这些图像中生成新的视频。我们将使用 cv2 的视频作者来完成这个任务。

但是你要确定两件事:

1.这些帧需要按照从原始视频中提取的相同方式进行排序。(如果您喜欢这样看视频，也可以倒着看)

2 。帧速率匹配原始视频。您可以使用下面的代码来检查视频的帧速率，或者直接打开 file 属性。

最后，这里是从处理过的图像帧生成视频的代码。

如果您已经完成了这一步，经过处理的视频现在应该可以下载到您的本地机器上了。

免费免费尝试你最喜欢的视频剪辑。可能在重建视频时有意降低帧速率，以慢动作观看。

总结和进一步阅读

在文章中，我们介绍了如何使用 GPU 加速在 Google Colab 上运行您的模型。

您已经学习了如何对视频进行对象检测和分割。由于 Colab 上强大的 GPU，使得并行处理多个帧以加快处理速度成为可能。

进一步阅读

如果您想了解更多关于对象检测和分割算法背后的技术，这里是 Mask R-CNN 的原始论文，详细介绍了该模型。

或者，如果您刚刚开始使用异议检测，请查看我的对象检测/定位指南系列了解许多模型之间共享的基本知识。

这里再来 本帖的 Python 笔记本和 GitHub repo 为您提供方便。

Share on Twitter Share on Facebook

• ←你能相信一个 Keras 模型能区分非洲象和亚洲象吗？
• 如何处理 Keras 中的消失/爆炸渐变→

如何在 Google Colab 上运行支持 GPU 和 CUDA 9.2 的 PyTorch

原文：https://www.dlology.com/blog/how-to-run-pytorch-with-gpu-and-cuda-92-support-on-google-colab/

发帖人:程维四年零三个月前

(评论)

自从我写了第一篇关于在谷歌的 GPU 支持的 Jupyter 笔记本界面- Colab 上运行深度学习实验的教程以来，已经有一段时间了。从那以后，我的几个博客都是通过 GPU 加速在 Colab 上运行 Keras、TensorFlow 或 Caffe。

1. “如何免费快速运行视频上的对象检测和分割”——我在 Colab 上的第一个教程， colab 笔记本直接链接。
2. "在 Google Colab 中运行 TensorBoard 的快速指南"，- Colab 笔记本直达链接。
3. 在 Colab - 上运行caffe-cuda Colab 笔记本直连。

Colab 上缺少的一个框架是 PyTorch。最近，我正在检查一个需要在 Linux 上运行的视频到视频合成模型，此外，在我可以带着这个闪亮的模型兜风之前，还有数千兆字节的数据和预先训练的模型要下载。我在想，为什么不利用 Colab 惊人的下载速度和免费的 GPU 来尝试一下呢？

享受本教程的 Colab 笔记本链接。

让我们从在 Colab 上安装 CUDA 开始。

安装 CUDA 9.2

为什么不是其他 CUDA 版本？这里有三个原因。

1. 截至 2018 年 9 月 7 日，CUDA 9.2 是 Pytorch 在其网站pytorch.org上看到的官方支持的最高版本。
2. 有些人可能认为安装 CUDA 9.2 可能会与 TensorFlow 冲突，因为 TF 目前只支持 CUDA 9.0。放松，把 Colab 笔记本当成一个沙箱，即使你弄坏了它，也可以通过几个按钮轻松重置，让 TensorFlow 在安装 CUDA 9.2 后工作正常，因为我测试过。
3. 如果你安装了 CUDA 9.0 版本，你可能会在编译 Pytorch 的本地 CUDA 扩展时遇到问题。一些复杂的 Pytorch 项目包含定制 c++ CUDA 扩展，用于定制层/操作，比它们的 Python 实现运行得更快。不利的一面是，您需要从单个平台的源代码中编译它们。在运行于 Ubuntu Linux 机器上的 Colab 案例中，使用 g++编译器来编译本地 CUDA 扩展。但是 CUDA 9.0 版在使用 g++编译器编译原生 CUDA 扩展时有一个错误，这就是为什么我们选择 CUDA 9.2 版来修复这个错误。

回到安装，Nvidia 开发者网站会询问你想要运行 CUDA 的 Ubuntu 版本。要找到答案，请在 Colab 笔记本中运行下面的单元格。

它会返回您想要的信息。

VERSION="17.10 (Artful Aardvark)"

之后，您将能够浏览目标平台选择，使安装程序键入“deb(local)”，然后右键点击“下载(1.2 GB)”按钮复制链接地址。

回到 Colab 笔记本，粘贴链接后发出 wget 命令下载文件。在 Colab 上下载一个 1.2GB 的文件只需要大约 10 秒钟，这意味着没有咖啡休息时间-_-。

!wget https://developer.nvidia.com/compute/cuda/9.2/Prod2/local_installers/cuda-repo-ubuntu1710-9-2-local_9.2.148-1_amd64

运行以下单元来完成 CUDA 安装。

如果您在输出的末尾看到这些行，这意味着安装成功了。

Setting up cuda (9.2.148-1) ... Processing triggers for libc-bin (2.26-0ubuntu2.1) ...

继续 Pytorch。

安装 PyTorch

非常简单，去pytorch.org，这里有一个选择器，你可以选择如何安装 Pytorch，在我们的例子中，

• OS: Linux
• 包管理器: pip
• Python: 3.6 ，你可以通过在一个 shell 中运行 python --version 来验证。
• CUDA: 9.2

它将让您运行下面这一行，之后，安装就完成了！

pip3 install torch torchvision

在演示时运行 vid 2

出于好奇，Pytorch 在 Colab 上启用 GPU 后表现如何，让我们尝试一下最近发布的 视频到视频合成演示，这是一个 Pytorch 实现我们的高分辨率真实感视频到视频翻译方法。那个视频演示把姿势变成了一个看起来很诱人的舞蹈身体。

此外，演示还依赖于定制的 CUDA 扩展，提供了测试已安装的 CUDA 工具包的机会。

下面的单元完成了从获取代码到使用预先训练好的模型运行演示的所有工作。

生成的帧会转到目录results/label 2 city _ 1024 _ G1/test _ latest/images中，您可以通过调用下面的单元格来显示一个。

本教程到此结束。

结论和进一步的思考

这篇短文向你展示了如何让 GPU 和 CUDA 后端 Pytorch 在 Colab 上快速自由地运行。不幸的是， vid2vid 的作者还没有得到可测试的侧脸，pose-dance demo 也还没有贴出，我在焦急地等待着。到目前为止，它只是作为一个演示来验证我们在 Colab 上安装 Pytorch。请随时在社交媒体上与我联系，我会让你了解我未来的项目和其他实用的深度学习应用。

• 标签:
• 教程，
• 深度学习

Share on Twitter Share on Facebook

• ↓《如果我是女孩》StarGAN 的魔镜
• 如何使用 Keras 时间序列生成器生成时间序列数据→

如何在 Jetson Nano 上以 20+ FPS 运行 SSD Mobilenet V2 物体检测

原文：https://www.dlology.com/blog/how-to-run-ssd-mobilenet-v2-object-detection-on-jetson-nano-at-20-fps/

发帖人:程维三年前

(评论)

泰勒:博士

首先，确保你已经在你的 Jetson Nano 开发 SD 卡上闪存了最新的 JetPack 4.3。

然后你会看到类似这样的结果。

现在进行一个稍微长一点的描述。

大约 8 个月前，我发布了如何在 Jetson Nano 上运行 TensorFlow 对象检测模型，意识到仅仅在 Jetson Nano 上以大约 10FPS 的速度运行 SSD MobileNet V1 对于一些应用来说可能是不够的。此外，这种方法消耗了太多内存，没有空间让其他内存密集型应用程序并行运行。

这一次，更大的 SSD MobileNet V2 对象检测模型以 20+FPS 的速度运行。速度提高了一倍，内存消耗也减少到只有 Jetson Nano 上总 4GB 内存的 32.5%(即大约 1.3GB)。有足够的内存来运行其他的花哨的东西。您还注意到 CPU 使用率也很低，仅比四核高 10%左右。

据我所知，有许多技巧有助于提高性能。

• 什么带来了 JetPack 4.3 ，TensorRT 版本 6.0.1 对比之前的 TensorRT 版本 5。
• TensorFlow 对象检测图是在硬件上优化和转换的，我指的是我现在使用的 Jetson Nano 开发套件。这是因为 TensorRT 通过使用可用的 GPU 来优化图形，因此优化的图形在不同的 GPU 上可能表现不佳。
• 该模型现在被转换为一种更特定于硬件的格式，TensorRT 引擎文件。但缺点是它不够灵活，受到运行它的硬件和软件堆栈的限制。稍后会详细介绍。
• 一些节省内存和提高速度的技巧。

它是如何工作的？

您刚才运行的命令行启动了一个 docker 容器。如果您是 Docker 的新手，可以把它想象成一个超级 Anaconda 或 Python 虚拟环境，它包含了重现 mine 结果所需的一切。如果您仔细查看一下我的 GitHub repo 上的 Dockerfile ，它描述了容器映像是如何构建的，您可以看到所有的依赖项是如何设置的，包括所有的 apt 和 Python 包。

docker 映像是基于最新的 JetPack 4.3 - L4T R32.3.1 基础映像构建的。要使用 TensorRT 引擎文件进行推理，需要两个重要的 Python 包，TensorRT 和 Pycuda。在 Jetson Nano 上从源代码构建 Pycuda Python 包可能需要一些时间，所以我决定将预构建包打包到一个 wheel 文件中，并使 Docker 构建过程更加流畅。请注意，用 JetPack 4.3 预构建的 Pycuda 与旧版本的 JetPack 和 vers visa 不兼容。在 TensorRT python 包中，它来自目录/usr/lib/python3.6/dist-packages/tensorrt/中的 Jetson Nano。我所做的只是将该目录压缩到一个tensorrt.tar.gz文件中。你猜怎么着，推理时不需要 TensorFlow GPU Python 包。考虑一下，通过跳过导入 TensorFlow GPU Python 包，我们可以节省多少内存。

你可以在我的 GitHub 库找到用 JetPack 4.3 构建的名为TRT _ SSD _ mobilenet _ v2 _ coco . bin的 TensorRT 引擎文件。有时，您可能还会看到 TensorRT 引擎文件，其扩展名为*.engine,就像 JetBot 系统映像中那样。如果想自己转换文件，可以看看 JK Jung 的 build_engine.py 脚本。

现在，对于 TensorRT 引擎文件方法的限制。它不能跨不同版本 JetPack 工作。原因在于引擎文件是如何通过搜索 CUDA 内核构建的，以获得可用的最快实现，因此有必要使用相同的 GPU 和软件堆栈(CUDA、CuDnn、TensorRT 等)。)用于构建优化引擎将在其上运行的那种结构。TensorRT engine file 就像一件专门为设置量身定制的衣服，但当安装在正确的人员/开发板上时，它的性能令人惊叹。

随着速度的提高和更低的内存占用带来的另一个限制是精度的损失，以下面的预测结果为例，一只狗被错误地预测为一只熊。这可能是从 FP32 到 FP16 的模型权重量化或其他优化折衷的结果。

节省内存和提高速度的一些技巧

关闭 GUI 并在命令行模式下运行。如果您已经在 GUI 桌面环境中，只需按“Ctrl+Alt+F2”进入非 GUI 模式，从那里登录您的帐户并键入“service gdm stop”，这将停止 Ubuntu GUI 环境并为您节省大约 8%的 4GB 内存。

通过在命令行中键入“jetson_clocks”来强制 CPU 和 GPU 以最大时钟速度运行。如果你有一个 PWM 风扇连接到主板上，并被风扇的噪音所困扰，你可以通过创建一个新的设置文件来降低它。

结论和进一步阅读

本指南向您展示了重现我在 Jetson Nano 上以 20+ FPS 运行 SSD Mobilenet V2 物体检测的结果的最简单方法。解释它是如何工作的，以及在将它应用到实际应用程序之前需要注意的限制。

别忘了在我的 GitHub 上获取这篇文章的源代码。

Share on Twitter Share on Facebook

• ←端到端深度学习自动缺陷检查
• 从你的浏览器加速深度学习推理→

如何在 Jupyter 笔记本中运行用于 PyTorch 1.1.0 的 Tensorboard

原文：https://www.dlology.com/blog/how-to-run-tensorboard-for-pytorch-110-inside-jupyter-notebook/

发帖人:程维三年零八个月前

(评论)

脸书推出了支持 TensorBoard 的 PyTorch 1.1。让我们在 Colab 的 Jupyter 笔记本上快速尝试一下。

不需要在您的开发机器上本地安装任何东西。即使升级了特斯拉 T4 GPU，谷歌的 Colab 也能免费派上用场。

首先，让我们创建一个 Colab 笔记本或者打开 这个我做的 。

在第一个单元格中键入以检查 PyTorch 的版本是否至少为 1.1.0

然后你要像这样安装尖端的张量板。

输出可能会提醒您重新启动运行时以使新的 TensorBoard 生效。可以点开Runtime -> Restart runtime...。

接下来，用这条魔线加载 TensorBoard 笔记本扩展。

之后你可以开始探索火炬。UTILS.TENSORBOARD API，这些实用程序允许您将 PyTorch 模型和指标记录到一个目录中，以便在 TensorBoard UI 中可视化。PyTorch 模型和张量都支持标量、图像、直方图、图形和嵌入可视化。

SummaryWriter类是记录供 TensorBoard 使用和可视化的数据的主要入口。让我们为 MNIST 数据集和 ResNet50 模型运行这个官方演示。

你刚刚写了一张图片和模型图数据到 TensorBoard summary。编写器将输出文件写入到”。/runs "目录。

让我们运行张量板来可视化它们

就这样，你成功了！

总结和进一步阅读

这个非常短的教程让你在 Jupyter 笔记本上用最新的 Pytorch 1.1.0 开始运行 TensorBoard。继续尝试 PyTorch TensorBoard 支持的其他功能。

点击这里阅读官方 API 文档- TORCH。UTILS.TENSORBOARD

• 标签:
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←如何在 RK3399Pro 上运行 Keras 模型
• 如何使用 TensorFlow 模型优化将您的 Keras 模型 x5 压缩得更小→

如何在 Jupyter 笔记本中运行 TensorBoard

原文：https://www.dlology.com/blog/how-to-run-tensorboard-in-jupyter-notebook/

发帖人:程维三年零九个月前

(评论)

TensorBoard 是一个很好的工具，它提供了评估 TensorFlow 模型训练所需的许多指标的可视化。过去很难使用这个工具，尤其是在托管的 Jupyter 笔记本环境中，如 Google Colab、Kaggle notebook 和 Coursera 的 Notebook 等。在本教程中，我将向您展示如何无缝运行和查看 TensorBoard，就在一个托管的或本地的 Jupyter 笔记本电脑中，使用最新的 TensorFlow 2.0。

你可以在阅读这篇文章的同时运行这个 Colab 笔记本。

开始安装 TF 2.0，加载 TensorBoard 笔记本扩展:

或者，要运行本地笔记本，可以创建一个 conda 虚拟环境，安装 TensorFlow 2.0。

然后你可以在训练前启动 TensorBoard 来监控它的进展:在笔记本内使用 魔法。

现在您可以看到一个空的 TensorBoard 视图，显示消息“当前数据集没有活动的仪表板”，这是因为日志目录当前是空的。

让我们用一个非常简单的 Keras 模型来创建、训练和记录一些数据。

现在回到之前的 TensorBoard 输出，用右上角的按钮刷新它，并观察更新视图。

通过发出相同的命令，相同的 TensorBoard 后端被重用。如果选择不同的日志目录，将会打开一个新的 TensorBoard 实例。端口被自动管理。

任何值得一提的有趣的新特性是“概念图”。要查看概念图，请选择“keras”标签。对于本例，您将看到一个折叠的序列 节点。双击节点可以看到模型的结构:

结论与延伸阅读

在本快速教程中，我们将介绍如何在 Jupyter 笔记本电脑中启动和查看盛开的 TensorBoard。有关如何在 TensorFlow 2.0 中利用 TensorBoard 的其他新功能的更多说明，请务必查看这些资源。

张量板标量:在 Keras 中记录训练指标

使用 HParams 仪表盘调节超参数

使用假设分析工具仪表板了解模型

• 标签:
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←如何使用英特尔显卡更快地运行 TensorFlow 对象检测模型
• 如何使用贝叶斯优化对 Keras 模型进行超参数搜索→

如何借助英特尔显卡更快地运行 TensorFlow 对象检测模型

原文：https://www.dlology.com/blog/how-to-run-tensorflow-object-detection-model-faster-with-intel-graphics/

发帖人:程维 3 年 10 个月前

(评论)

在本教程中，我将向您展示如何使用 OpenVINO toolkit 在英特尔显卡上运行定制训练的 TensorFlow 对象检测模型的推理，与 TensorFlow CPU 后端相比，速度至少快 2 倍。我的基准测试还显示，与采用 GTX1070 卡的 TensorFlow GPU 后端相比，该解决方案仅慢 22%。

如果你是 OpenVINO toolkit 新手，建议看一下之前的教程关于如何用 OpenVINO 转换一个 Keras 图像分类模型，加快推理速度。这一次，我们将进一步使用对象检测模型。

先决条件

要将 TensorFlow 冻结对象检测图形转换为 OpenVINO 中间表示(IR)文件，您需要准备好这两个文件，

• 标签:
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←如何免费训练一个简单的物体检测模型
• 如何在 Jupyter 笔记本中运行 tensor board→

如何在 Jetson Nano 上运行 TensorFlow 对象检测模型

原文：https://www.dlology.com/blog/how-to-run-tensorflow-object-detection-model-on-jetson-nano/

发帖人:程维三年零八个月前

(评论)

之前，您已经学习了如何在 Jetson Nano 上运行 Keras 图像分类模型，这次您将了解如何在其上运行 Tensorflow 对象检测模型。它可以是 Tensorflow 检测模型 zoo 中的预训练模型，用于检测人/车/狗等日常对象，也可以是自定义训练的对象检测模型，用于检测您的自定义对象。

在本教程中，我们将转换在 coco 数据集上训练的 SSD MobileNet V1 模型，用于常见对象检测。

这里有一个分解如何使它发生，与以前的图像分类教程略有不同。

1. 下载预先训练好的模型检查点，建立张量流检测图，然后用张量创建推理图。
2. 在 Jetson Nano 上加载tensort 推理图并进行预测。

这两个步骤将在两个独立的 Jupyter 笔记本上处理，第一个在开发机器上运行，第二个在 Jetson Nano 上运行。

在继续之前，请确保您已经设置了 Jetson Nano 并安装了 Tensorflow。

步骤 1:创建 TensorRT 模型

在带有tensor flow nightly builds的开发机器上运行这个步骤，默认情况下它包含 TF-TRT 或者你可以在 这个 Colab notebook 的免费 GPU 上运行。

在笔记本中，您将从安装 Tensorflow 对象检测 API 和设置相关路径开始。它的官方安装文档对初学者来说可能令人望而生畏，但是你也可以通过运行一个笔记本电池来完成。

接下来，您将从预先训练的 ssd_mobilenet_v1_coco 检查点下载并构建检测图，或者从笔记本提供的列表中选择另一个检查点。

最初，默认 Tensorflow 对象检测模型采用可变批量大小，现在固定为 1，因为 Jetson Nano 是资源受限的设备。在build_detection_graph调用中，其他几个变化也适用于 Tensorflow 图，

• 分数阈值设置为 0.3，因此模型将删除置信度分数低于阈值的任何预测结果。
• IoU(并集上的交集)阈值被设置为 0.5，使得任何检测到的具有相同类别重叠的对象都将被移除。你可以在这里阅读更多关于 IoU( 交集超过并集)和非最大抑制的内容。
• 对冻结对象检测图形应用修改，以提高速度并减少内存消耗。

接下来，我们创建一个 TensorRT 推理图，就像图像分类模型。

一旦你有了 TensorRT 推理图，你可以把它保存为 pb 文件，并根据需要从 Colab 或你的本地机器下载到你的 Jetson Nano 中。

步骤 2:加载 TensorRT 图并进行预测

在你的杰特森 Nano 上，用命令 jupyter notebook --ip=0.0.0.0 启动一个 Jupyter 笔记本，在那里你已经把下载的图形文件保存到 ./model/trt_graph.pb 。下面的代码将加载 TensorRT 图，并为推理做好准备。

现在，我们可以用一幅图像进行预测，看看模型是否正确。请注意，我们将图像的大小调整为 300 x 300，但是，您可以尝试其他大小或保持大小不变，因为图形可以处理可变大小的输入。但是请记住，因为与台式机相比，Jetson 的内存非常小，所以它几乎不能拍摄大图像。

如果您以前玩过 Tensorflow 对象检测 API，这些输出应该看起来很熟悉。

这里，结果可能仍然包含具有不同类别标签的重叠预测。例如，同一对象可以在两个重叠的边界框中标记两个类。

我们将使用自定义的非最大值抑制函数来移除具有较低预测分数的重叠边界框。

让我们通过绘制边界框和标签叠加来可视化结果。

下面是创建覆盖图并显示在 Jetson Nano 笔记本上的代码。

在 coco 标签图中，18 级代表一只狗，23 级代表一只熊。坐在那里的两只狗被错误地归类为熊。也许在 coco 数据集中，坐着的熊比站着的狗多。

进行了类似的速度基准测试，Jetson Nano 使用 SSD MobileNet V1 模型和 300 x 300 输入图像实现了 11.54 FPS 。

如果您遇到内存不足的问题，尝试在不连接任何显示器的情况下启动主板，并使用 SSH 登录到 shell，这样您可以从 GUI 中节省一些内存。

结论和进一步阅读

在本教程中，您学习了如何转换 Tensorflow 对象检测模型并在 Jetson Nano 上运行推理。

查看更新的 GitHub repo 获取源代码。

如果你对结果不满意，还有其他预训练的模型供你看看，我建议你从 SSD MobileNet V2(SSD _ MobileNet _ v2 _ coco)开始，或者如果你喜欢冒险，尝试 ssd_inception_v2_coco ，这可能会推动 Jetson Nano 的内存极限。

您可以在 Tensorflow 检测模型动物园中找到这些模型，“速度(毫秒)”度量将为您提供模型复杂性的指导。

考虑用免费的数据中心 GPU 训练你的自定义对象检测模型，看看我之前的教程- 如何免费轻松训练对象检测模型。

• 标签:
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←如何在杰特森纳米上运行 Keras 模型
• 如何在 RK3399Pro 上运行 Keras 模型→

如何教人工智能向在线卖家建议产品价格

原文：https://www.dlology.com/blog/how-to-teach-ai-to-suggest-product-prices-to-online-sellers/

发帖人:程维 5 年前

(评论)

给定产品的品牌、名称、类别和一两句简短的描述，然后我们就可以预测它的价格。有这么简单吗？

在这场比赛中，我们做着完全相同的事情。全世界的开发者都在为“Mercari Prize:价格建议挑战”而战，奖金总额为 10 万美元(第一名:6 万美元，第二名:3 万美元，第三名:1 万美元)。

在这篇文章中，我将带你构建一个简单的模型来解决深度学习库中的挑战。

如果你是 Kaggle 的新手，为了下载数据集，你需要注册一个账户，完全没有痛苦。拥有帐户后，进入 Mercari 价格建议挑战赛的“数据”选项卡。

将这三个文件下载到您的本地计算机，解压并保存到一个名为“ input 的文件夹中，在根文件夹下创建一个名为“ scripts 的文件夹，我们将在这里开始编码。

现在你应该有类似这样的目录结构。

。/Pricing_Challenge
| - 输入| |-test . tsv
| |-sample _ submission . CSV
| -train . tsv -脚本

准备数据

首先，让我们花些时间来理解手头的数据集

train.tsv，test.tsv

这些文件由产品列表组成。这些文件用制表符分隔。

• train_id 或 test_id -清单的 id
• name -清单的标题。请注意，我们已经清理了数据，删除了看起来像价格(例如$20)的文本，以避免泄漏。这些被删除的价格被表示为 [rm]
• item_condition_id -卖方提供的物品的状况
• category_name -清单的类别
• brand_name
• price -物品的售价。这是你要预测的目标变量。单位是美元。这个栏目不存在于 test.tsv 既然是你会预测的。
• shipping - 1 表示运费由卖家支付，0 表示由买家支付
• item_description -物品的完整描述。请注意，我们已经清理了数据，删除了看起来像价格(例如$20)的文本，以避免泄漏。这些被删除的价格被表示为 [rm]

对于价格列，输入取值范围相差很大的神经网络值是有问题的。网络也许能够自动适应这种异构数据，但这肯定会使学习更加困难。

处理这类数据的一个普遍的最佳实践是进行特征标准化:对于输入数据(输入数据矩阵中的一列)中的每个特征，我们对其应用 log(x+1)。

让我们看看新的“目标”列的分布。

文本预处理

替换收缩

我们将替换如下所示的缩写对，目的是统一词汇，以便更容易训练模型。

"what's" → "what is",
"who'll" → "who will",
"wouldn't" → "would not",
"you'd" → "you would",
"you're" → "you are"

在我们这样做之前，让我们计算一下在“item_description”列中有多少行包含任何缩写。

下面列出了 5 个最重要的，这并不奇怪。

can't - 6136
won't - 4867
that's - 4806
it's - 26444
don't - 32645
doesn't - 8520

下面是在训练和测试数据集中删除“item_description”和“name”列的缩写的代码。

Handel 缺失值

为了成功地管理数据，理解缺失值的概念非常重要。如果研究人员没有正确处理缺失值，那么他/她可能会对数据做出不准确的推断。

首先看一下缺少多少数据，以及哪一列。

在输出中，我们知道有 42%的 brand_name 丢失，“category_name”和“item_description”列也丢失了不到 1%的数据。

train_id             0.000000
name                 0.000000
item_condition_id    0.000000
category_name        0.004268
brand_name           0.426757
price                0.000000
shipping             0.000000
item_description     0.000003
dtype: float64

假设缺失值的情况非常少；然后，专家研究员可能会从分析中丢弃或忽略这些值。用统计学的语言来说，如果案例的数量少于样本的 5%,那么研究者可以放弃它们。在我们的例子中，我们可以删除带有、 category_name 或 item_description 列缺失值的行。

但是为了简单起见，让我们用字符串“ missing ”替换所有缺失的文本值。

创建分类列

有两个文本列具有特殊含义，

• 类别名称
• 品牌名称

不同的产品可能有相同的类别名称或品牌名称，因此从它们创建分类列会很有帮助。

为此，我们将使用 sklearn 的 LabelEncoder。转换之后，我们将有两个新的整数类型的列“category”和“brand”。

将文本标记为序列

对于词汇表中的每个唯一单词，我们将把它转换成一个整数来表示。所以一个句子会变成一个整数列表。

首先，我们需要从将要标记的文本列中收集词汇列表。即那 3 列，

• 类别名称
• 项目 _ 描述
• 名字

我们将使用 Keras 的文本处理标记器类。

fit_on_texts()方法将训练标记器生成词汇单词索引映射。而 texts_to_sequences()方法实际上将从文本中生成序列。

填充序列

上一步生成的单词序列长度不同。因为我们网络中的第一层对于那些序列来说是 tEmbedding层。每个嵌入层将形状为 (samples, sequence_length) 的整数的 2D 张量作为输入

一批中的所有序列必须具有相同的长度，因为我们需要将它们打包成一个张量。因此，比其他序列短的序列应该用零填充，而长的序列应该被截断。

首先，我们需要为sequence_length我们的每个序列列选择。如果太长的话，模型训练就要花很长时间。如果太短，我们就有截断重要信息的风险。在我们做这个决定之前，最好能看到序列长度的分布。

这一行代码将绘制直方图中“seq_item_description”列的序列长度分布。

让我们选择 60 作为最大序列长度，因为它覆盖了大多数序列。

在下面的代码中，我们使用 Keras 的序列处理pad_sequences()方法为每一列填充长度相同的序列。

建立模型

对于这些输入，这将是一个多输入模型

• 名称':转换成序列的文本
• item_desc ': 文字转换成 序列
• brand ':转换成整数的文本
• 类别 ': 文本转换成 整数
• 类别 _ 名称 ': 文本转换成 序列
• item_condition ': 整数
• 出货 ': 整数 1 或 0

除“shipping”之外的所有输入将首先进入嵌入层

对于那些序列输入，我们需要将它们提供给Embedding层。Embedding层将整数索引(代表特定单词)转化为密集向量。它接受整数作为输入，在内部字典中查找这些整数，然后返回相关的向量。这实际上是一种字典查找。

嵌入的序列然后将馈送到GRU层，像其他类型的递归网络一样，它擅长学习数据序列中的模式。

非顺序数据嵌入层将被Flatten层展平为二维。

包括“船运”在内的所有层将被连接成一个大的二维张量。

接着是几个密集层，最终输出密集层采用“线性激活回归到任意价格值，与为activation参数指定无相同。

我喜欢可视化，所以我也绘制模型结构。

如果你好奇的话，这两行代码就可以完成。

需要安装 Graphviz 可执行文件。pip 在尝试绘图之前安装了 graphviz 和 pydot 软件包。

训练模型很简单，我们来训练 2 个历元，X_train是我们之前创建的字典，将输入名称映射到 Numpy 数组。

评估模型

Kaggle 挑战页面选择了“均方根对数误差”作为损失函数。

下面的代码将采用我们训练好的模型，并在给定验证数据的情况下计算损失值。

生成提交文件

如果你计划为测试数据集生成实际价格，并在 Kaggle 上试试运气。这段代码将反转我们之前讨论的特性规范化过程，并将价格写入一个 CSV 文件。

摘要

我们演练了如何在给定多个输入特征的情况下预测价格。如何对文本数据进行预处理，处理缺失数据，最后建立、训练和评估模型。

完整的源代码贴在我的 GitHub 上。

Share on Twitter Share on Facebook

• ←在你的浏览器上运行的十大深度学习体验
• 使用 Keras 从网络摄像头视频中轻松实时预测性别年龄→

如何训练 Keras 模型生成颜色

原文：https://www.dlology.com/blog/how-to-train-a-keras-model-to-generate-colors/

发帖人:程维 4 年 7 个月前

(评论)

想知道油漆颜色是如何命名的吗？"象牙公主"，"公牛奶油。"而“喀拉斯红”呢？原来 人就是靠给那些颜色取名谋生的。在这篇文章中，我将向你展示如何建立一个简单的深度学习模型来做类似的事情——给模型一个颜色名称作为输入，并让模型提出颜色的名称。

这个帖子是初学者友好的。我给大家介绍一下深度学习处理文本数据的基本概念。

概述

1. 选择最能代表输入文本的语言模型
2. 清理和准备培训数据
3. 建立一个基本的 Keras 序列神经网络模型。
4. 应用递归神经网络(RNN)处理字符序列。
5. 生成 3 通道 RGB 彩色输出。

让我们来看看我们将要构建的大图，

语言模型

语言建模有两个通用选项:单词级模型和字符级模型。各有利弊。让我们现在过一遍。

单词级语言模型

单词级语言模型可以处理相对长且干净的句子。所谓“干净”，我的意思是文本数据集中的单词没有错别字，并且几乎没有英语词汇之外的单词。单词级语言模型将每个唯一的单词编码成相应的整数，并且有一个预定义的固定大小的词汇字典来查找单词到整数的映射。单词级语言模型的一个主要好处是它能够利用预先训练的单词嵌入，如 Word2Vec 或 GLOVE。这些嵌入将单词表示为具有有用属性的向量。上下文中相近的词在欧几里德距离上是相近的，可以用来理解类似“男人之于女人，之于国王之于王后”的比喻。使用这些想法，您可以用相对较小的标记训练集来训练单词级模型。

字符级语言模型

但是有一个更简单的语言模型，它将一个文本字符串分割成多个字符，并将一个唯一的整数与每个字符相关联。您可能会选择使用字符级语言模型而不是更流行的单词级模型，这有一些原因:

• 您的文本数据集包含大量不在词汇表中的单词或不常用的单词。在我们的例子中，一些合法的颜色名称可能是“ aquatone ”、“黄绿色”和“紫红色”。对我来说，我必须查字典，找出它们的意思，传统的单词级嵌入可能不包含它们。
• 大多数文本字符串都是长度有限的短字符串。如果您正在寻找一个特定的长度限制，我一直在处理一个字符级编码字符长度为 60 的 Yelp 评论生成模型，并且仍然得到了不错的结果。你可以在这里找到博文: 如何用 Keras 生成逼真的 yelp 餐厅评论。通常，字符级语言生成模型可以创建更多样化的文本，因为它的想象力不受预定义词汇词典的约束。

您可能也意识到了采用字符级语言的局限性:

• 长序列可能不像单词级语言模型那样捕捉长距离依赖性。
• 字符级模型的训练在计算上也更昂贵——给定相同的文本数据集，这些模型序列更长，因此需要更长的训练时间。

幸运的是，这些限制不会对我们的颜色生成任务构成威胁。我们将颜色名称的长度限制在 25 个字符以内，而且我们只有 14157 个训练样本。

我们提到我们将颜色名称限制在 25 个字符以内。为了得出这个数字，我们检查了所有训练样本中颜色名称的长度分布，并将其可视化，以确保我们选择的长度限制是合理的。

这给了我们这个图，你可以清楚地看到，大多数颜色名称字符串的长度小于或等于 25，即使最大长度达到 30。

在我们的例子中，我们可以选择最大长度 30，但是我们将要构建的模型也需要在更长的序列上训练更长的时间。我们选择较短序列长度的折衷降低了模型训练的复杂性，同时不损害训练数据的完整性。

在做出最大长度的艰难决定后，字符级数据预处理的下一步是将每个颜色名称字符串转换为 25 个整数值的列表，这通过 Keras 文本标记化实用程序变得很容易。

现在将具有(14157，25)的形状，其中 14157 是总训练样本的数量，25 是最大序列长度。如果字符串少于 25 个字符，将从序列的开始处用值0s 填充。

**您可能会想，现在所有的输入都是整数形式，我们的模型应该能够处理它。但是我们还可以多走一步，让后期的模型训练更加有效。

一键编码

我们可以通过检查 Keras 的 Tokenizer 实例的 t.word_index 属性来查看字符到整数的映射。

{' ': 4,  'a': 2, 'b': 18, 'c': 11, 'd': 13, 'e': 1, 'f': 22, 'g': 14, 'h': 16, 'i': 5, 'j': 26, 'k': 21, 'l': 7, 'm': 17, 'n': 6, 'o': 8, 'p': 15, 'q': 25, 'r': 3, 's': 10, 't': 9,'u': 12, 'v': 23, 'w': 20, 'x': 27, 'y': 19, 'z': 24}

整数值之间没有自然的有序关系，我们的模型可能无法从中获益。更糟糕的是，我们的模型最初会假设这些字符之间的这种排序关系(即“a”是 2，“e”是 1，但这不应该表示一种关系)，这可能导致不希望的结果。我们将使用独热编码来表示输入序列。

每个整数将由一个布尔数组表示，其中只有一个元素的值为 1。最大整数值将决定字符字典中布尔数组的长度。

在我们的例子中，最大整数值是【x】:27，所以一个独热布尔数组的长度将是 28(考虑到最小值从 0 开始，这是填充)。

例如，我们不使用整数值 2 来表示字符“a ”,而是使用独热数组[0，0，1，0 ……..0].

在 Keras 中也可以使用一键编码。

生成的 one_hot_names 的形状为(14157，25，28)，代表(#个训练样本，最大序列长度，#个唯一令牌)

数据标准化

请记住，我们预测的是 3 个颜色通道值，每个值的范围在 0–255 之间。数据规范化没有金科玉律。数据规范化纯粹是实用的，因为在实践中，如果训练数据值过于分散，模型可能会永远收敛。一种常见的归一化技术是将值缩放到[-1，1]。在我们的模型中，我们在最后一层使用了 ReLu 激活函数。由于 ReLu 输出非负数，我们将把这些值规范化为[0，1]。

建立模型

为了建立我们的模型，我们将使用两种类型的神经网络，一个前馈神经网络和一个递归神经网络。前馈神经网络是迄今为止最常见的神经网络类型。在这种神经网络中，信息进入输入单元，并通过隐藏层沿一个方向流动，直到每个信息到达输出单元。

在循环神经网络中，信息可以循环流动。这些网络可以长时间记忆信息。递归网络是建模顺序数据的一种非常自然的方式。在我们的特定模型中，我们使用了一个最强大的循环网络，名为长短期记忆(LSTM)。

在 Keras 中建立深度学习模型最简单的方法是使用它的顺序 API，我们只需通过调用它的 model.add()函数来连接每个神经网络层，就像连接乐高积木一样。

通过调用 model.fit()函数来训练模型再简单不过了。请注意，我们将保留 10%的样品用于验证目的。如果结果表明模型在训练集上实现了很高的准确性，但在验证集上却低得多，则很可能模型过拟合。你可以在我的另一个博客上获得更多关于处理过度合身的信息: 过度合身模特的两个简单食谱 。

生成 RGB 颜色

让我们定义一些函数来生成和显示预测的颜色。

对于一个颜色名称输入，我们需要将其转换成同一个 hot 表示。为了实现这一点，我们使用与处理训练数据相同的标记器将字符标记为整数，将其填充到最大序列长度 25，然后对整数序列应用一键编码。

对于输出的 RGB 值，我们需要将其缩放回 0–255，这样我们才能正确显示它们。

让我们试试 predict()函数。

“喀拉斯红”看起来比我们熟悉的颜色要深一点，但不管怎样，这就是我们提出的模型。

结论和进一步阅读

在这篇文章中，我们讨论了如何构建一个 Keras 模型，它可以采用任何颜色名称，并得出一个 RGB 颜色值。更具体地说，我们研究了如何将一键编码应用于字符级语言模型，用一个前馈神经网络和递归神经网络构建一个神经网络模型。

这里有一个图表来总结我们在帖子中构建的内容，从底部开始，显示数据流的每一步。

如果你是深度学习或 Keras 图书馆的新手，有一些很好的资源，阅读或实验起来既简单又有趣。

TensorFlow playground :在浏览器上运行的神经网络的交互式可视化。

Coursera 深度学习课程:学习深度学习的基础和大量实用建议。

Keras 入门指南:用户友好、模块化 deep Python 深度学习库的官方指南。

另外，在 我的 GitHub repo 中查看这篇文章的源代码。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←如何用 Keras 做无监督聚类
• Keras +通用语句编码器=文本数据的迁移学习→**

如何训练 Keras 模型识别可变长度的文本

原文：https://www.dlology.com/blog/how-to-train-a-keras-model-to-recognize-variable-length-text/

发帖人:程维 4 年 7 个月前

(评论)

我玩了 Keras 官方的 image_ocr.py 例子有一段时间了，想在这篇文章中分享一下我的心得。

官方的例子只对模型进行了训练，而忽略了预测部分，我的最终源代码既可以在我的 GitHub 上获得，也可以在 T2 的可运行的 Google Colab 笔记本上获得。OCR(光学字符识别)的更多技术细节，包括模型结构和 CTC 损失，也将在下面的章节中简要说明。

从我的 GitHub获取源代码

*## OCR 任务声明

输入将是一个包含单行文本的图像，文本可以在图像中的任何位置。模型的任务是输出给定图像的实际文本。

举个例子，

官方 image_ocr.py 示例源代码相当长，可能看起来令人望而生畏。它可以分解成几个部分。

• 作为训练样本的生成器，这部分源代码将生成生动的文本图像，类似于带有人工斑点、随机位置和各种正面的扫描文档。
• 模型回调保存模型权重，并在每个训练时期后使用一些生成的文本图像可视化当前模型的性能。
• 模型构建和训练部分。我们将在下一节详细阐述这一部分。

模型结构

模型输入是图像数据，我们首先将数据馈送到两个卷积网络以提取图像特征，然后进行整形和密集以降低特征向量的维度，然后让双向 GRU 处理顺序数据。供给 GRU 的顺序数据是水平划分的图像特征。最终的输出密集层将给定图像的输出转换为一个形状为(32，28)的数组，表示(#水平步长，#字符标签)。

下面是构建 Keras 模型的部分代码。

CTC 损失

正如我们在示例图像中看到的，文本可以位于任何位置，模型如何在输入和输出之间对齐以定位图像中的每个字符并将它们转换为文本？这就是 CTC 发挥作用的地方，CTC 代表连接主义时间分类。

注意，模型的输出有 32 个时间步长，但是输出可能没有 32 个字符。CTC 成本函数允许 RNN 生成如下输出:

CTC 引入了“空白”标记，它本身并不翻译成任何字符，它所做的是分隔单个字符，以便我们可以折叠没有被空白分隔的重复字符。

因此前一序列的解码输出将是“一个游戏”。

我们再来看另一个文字“速度”的例子。

根据解码原则，我们首先折叠未被空白标记分隔的重复字符，然后删除空白标记本身。请注意，如果没有空白标记来分隔两个“e ”,它们将合并为一个。

在 Keras 中，CTC 解码可以在单个函数K.ctc_decode中执行。

out是模型输出，它由来自 a~z、空格和空白记号的 28 个记号中的每一个的 28 个 softmax 概率值的 32 个时间步长组成。我们设置参数greedy来执行贪婪搜索，这意味着该函数将只返回最可能的输出令牌序列。

或者，如果我们想让 CTC 解码器返回前 N 个可能的输出序列，我们可以要求它以给定的波束宽度执行波束搜索。

值得一提的是，如果您是波束搜索算法的新手，top_paths参数不会大于beam_width参数，因为波束宽度告诉波束搜索算法在迭代所有时间步长时要跟踪多少个顶部结果。

现在，解码器的输出将是一个令牌序列，我们只需要将数字类翻译回字符。

到目前为止，我们只讨论了 CTC 的解码部分。你可能想知道模型是怎么用 CTC 丢失训练的？

为了计算 CTC 损失，不仅需要模型的真实标签和预测输出，还需要输出序列长度和每个真实标签的长度。

• y_true。它的一个例子可能看起来像文本序列‘abcde z’的【0，1，2，3，4，26，25】s
• y_pred 是 softmax 层的输出，它的一个样本有形状(32，28)，32 个时间步长，28 个类别，即‘a-z’，空格和空白令牌。
• input_length 是输出序列长度 img _ w//down sample _ factor–2 = 128/4-2 = 30，2 表示前 2 个丢弃的 RNN 输出时间步长，因为 RNN 的第一对输出往往是垃圾。
• label_length 将 7 为前一个 y_true 样本，

在 Keras 中，CTC 损失打包在一个函数K.ctc_batch_cost中。

结论

训练模型 25 个时期后的检查点结果。

如果你已经读到这里，并在 Google Colab 上进行实验，你现在应该有一个 Keras OCR 演示在运行。如果您仍然渴望获得更多关于 CTC 和 beam search 的信息，请随时查看以下资源。

使用 CTC 进行序列建模 -深入阐述 CTC 算法和其他可以应用 CTC 的应用，如语音识别、视频唇读等。

Coursera 光束搜索视频讲座。快速且易于理解。

别忘了从 我的 GitHub 以及 一个可运行的 Google Colab 笔记本 中获取源代码。

• 标签:
• keras ,
• 教程，
• 深度学习

Share on Twitter Share on Facebook

• ←如何在 Keras 中使用 return_state 或 return _ sequences
• 利用 Keras 中的新闻数据进行简单的股票情绪分析→*

如何免费训练一个简单的物体检测模型

原文：https://www.dlology.com/blog/how-to-train-an-object-detection-model-easy-for-free/

发帖人:程维 3 年 10 个月前

(评论)

在本教程中，您将学习如何使用 TensorFlow 对象检测 API 和 Google Colab 的免费 GPU 轻松训练自定义对象检测模型。

包括注释图像和源代码来完成本教程。

TL :博士；打开Colab 笔记本，开始探索。

否则，让我们从创建带注释的数据集开始。

• 标签:
• 教程，
• 深度学习

Share on Twitter Share on Facebook

• ←如何用 CPU 和 Intel OpenVINO 运行 Keras 模型推理快 x3 倍
• 如何使用英特尔显卡更快地运行 TensorFlow 对象检测模型→

如何使用 mmdetection 训练对象检测模型

原文：https://www.dlology.com/blog/how-to-train-an-object-detection-model-with-mmdetection/

发帖人:程维三年零六个月前

(评论)

不久前，你已经学习了如何使用 TensorFlow 对象检测 API 和 Google Colab 的免费 GPU 来训练对象检测模型，如果你还没有，请查看帖子中的。TensorFlow 对象检测中的模型已经相当过时，缺少对 Cascade RCNN 和 RetinaNet 等最新模型的更新。虽然 Pytorch 有一个类似于 mmdetection 的对应物，它包括更多预先训练的最先进的对象检测模型，供我们训练自定义数据，但是设置它需要花费大量的时间来安装环境、设置配置文件和正确格式的数据集。好消息是你可以跳过那些无聊的东西，直接跳到有趣的部分来训练你的模型。

这里有一个如何实现它的概述，

1.注释一些图像，并进行训练/测试分割。

2.运行Colab 笔记本来训练你的模型。

步骤 1: 注释一些图像并进行训练/测试分割

如果你想使用你的图片而不是那些自带的图片，只需要我我的库 。从分叉 my repository 开始，删除项目目录中的data文件夹，这样您就可以使用您的定制数据重新开始。

如果你是用手机拍摄的，图像分辨率可能是 2K 或 4K，这取决于你手机的设置。在这种情况下，我们将缩小图像以减少整体数据集大小，并加快训练速度。

你可以使用调整图片大小。存储库中的 py 脚本来调整图像的大小。

首先，将你所有的照片保存到项目目录之外的一个文件夹中，这样它们就不会被意外上传到 GitHub。理想情况下，所有照片都是用jpg扩展。然后运行这个脚本来调整所有照片的大小，并将它们保存到项目目录中。

python resize_images.py --raw-dir <photo_directory> --save-dir ./data/VOCdevkit/VOC2007/ImageSets --ext jpg --target-size "(800, 600)"

你可能想知道为什么“VOC”在 path 中，那是因为我们使用的注释工具生成了 Pascal VOC 格式的注释 XML 文件。没有必要深究 XML 文件的实际格式，因为注释工具会处理所有这些。你猜对了，这就是我们之前使用的， LabelImg 的工具，在 Windows 和 Linux 上都可以工作。

下载 LabelImg 并打开，

1.确认选择了“ PascalVOC ”，这是默认的注释格式。

2.打开已调整大小的图像文件夹“./data/VOCdevkit/VOC2007/ImageSets”进行注释。

3.将 XML 注释文件的保存目录更改为“./data/VOCdevkit/VOC2007/Annotations”。

照常使用快捷键(w:画 框 ，d:下一档，a:上一档等等。)加速标注。

一旦完成，你会发现这些 XML 文件位于./data/VOCdevkit/VOC2007/Annotations文件夹中，它们的文件名与你的图像文件的文件名相同。

对于训练/测试分割，您将创建两个文件，每个文件包含一个文件基础名称列表，每行一个名称。这两个文本文件将分别位于名为trainval.txt和test.txt的文件夹data/VOC2007/ImageSets/Main中。如果您不想手动键入所有文件名，请尝试将 cd 放入“Annotations”目录并运行 shell，

这将给你一个排序良好的文件库名列表，只需将它们分成两部分，然后粘贴到这两个文本文件中。

现在您有了类似于下面这个的data目录结构。

用您标记的数据集更新您在 GitHub 存储库中的分支，这样您就可以用 Colab 克隆它。

在 Colab 笔记本上训练模型

我们准备推出 Colab 笔记本并启动培训。类似于 TensorFlow 对象检测 API，不是从零开始训练模型，我们将从预先训练的主干进行迁移学习，比如模型配置文件中指定的 resnet50。

笔记本允许您选择模型配置并设置训练时期的数量。

目前，我只测试了两种型号配置， faster_rcnn_r50_fpn_1x，和 cascade_rcnn_r50_fpn_1x ，其他配置可以按照笔记本中的演示进行整合。

笔记本在训练模型之前处理几件事情，

1. 正在安装 mmdetection 及其依赖项。
2. 用您的自定义数据集类标签替换 voc.py 文件中的类。
3. 修改选定的模型配置文件。比如更新类的数量以匹配您的数据集，将数据集类型更改为 VOCDataset ，设置总训练历元数等等。

之后，它将重新运行 mmdetection 包安装脚本，因此对 voc.py 文件的更改将被更新到系统 python 包中。

由于您的数据目录位于 mmdetection 目录之外，我们在笔记本中有以下单元格，它创建了一个到项目数据目录的符号链接。

然后开始训练。

训练时间取决于数据集的大小和训练时期的数量，我的演示使用 Colab 的特斯拉 T4 GPU 需要几分钟才能完成。

训练之后，您可以使用测试集中的图像来试驾模型，如下所示。

这是你所期望的结果，

结论和进一步阅读

本教程向您展示如何使用您的自定义数据集训练 Pytorch mmdetection 对象检测模型，并在 Google Colab 笔记本上进行最小的努力。

如果您正在使用我的 GitHub repo，您可能已经注意到 mmdetection 作为一个子模块被包含在内，为了在将来更新它，运行这个命令。

考虑用另一种模型配置进行训练？你可以在这里找到一个配置文件列表以及它们的规格比如复杂度( Mem(GB) )和准确度( box AP )。然后在笔记本的开头将配置文件添加到 MODELS_CONFIG 中。

你可能会觉得有用的资源，

• mmdetection - GitHub 库。
• LabelImg -本教程中使用的注释工具。
• 本教程的我的存储库。

在未来的帖子中，我们将研究这些定制模型的基准测试，以及它们在边缘计算设备上的部署，敬请关注，祝编码愉快！

• 标签:
• 深度学习，
• 教程，
• 指针

Share on Twitter Share on Facebook

• ←如何用 Efficientnet 进行迁移学习
• 如何创建用于对象检测的自定义 COCO 数据集→

如何使用自定义 COCO 数据集训练 Detectron2

原文：https://www.dlology.com/blog/how-to-train-detectron2-with-custom-coco-datasets/

发帖人:程维三年零两个月前

(评论)

随着最新的 PyTorch 1.3 发布而来的是对之前的对象检测框架的下一代彻底重写，现在称为 Detectron2。本教程将通过使用自定义 COCO 数据集训练实例分割模型来帮助您开始使用该框架。如果你想知道如何创建 COCO 数据集，请阅读我之前的帖子- 如何为实例分割创建自定义 COCO 数据集。

作为一个快速的开始，我们将在一台 Colab 笔记本电脑上做我们的实验，因此在熟悉 Pytorch 1.3 和 Detectron2 之前，您不需要担心在您自己的机器上设置开发环境。

安装检测器 2

在 Colab 笔记本中，只需运行这 4 行即可安装最新的 Pytorch 1.3 和 Detectron2。

单击单元输出中的“重新启动运行时”,让安装生效。

注册 COCO 数据集

为了告诉 Detectron2 如何获取数据集，我们将对其进行“注册”。

为了演示这个过程，我们使用 水果坚果分割数据集 ，它只有 3 个类:数据、无花果和榛子。我们将从现有的在 COCO 数据集上预训练的模型中训练一个分割模型，该数据集可在 detectron2 的模型动物园中获得。

你可以像这样下载数据集。

或者您可以从这里上传自己的数据集。

按照 detectron2 自定义数据集教程 将 fruits_nuts 数据集注册到 detectron2。

每个数据集都与一些元数据相关联。在我们的例子中，可以通过调用 fruits_nuts_metadata = MetadataCatalog.get("fruits_nuts")来访问它，你将得到

要获得关于数据集的目录存储信息的实际内部表示以及如何获得它们，可以调用dataset_dicts = DatasetCatalog.get("fruits_nuts")。内部 fformat 使用一个 dict 来表示一个图像的注释。

为了验证数据加载是否正确，让我们可视化数据集中随机选择的样本的注释:

其中一张图片可能会显示这一点。

训练模型

现在，让我们在 fruits_nuts 数据集上微调 coco 预训练的 R50-FPN 掩模 R-CNN 模型。在 Colab 的 K80 GPU 上训练 300 次迭代需要~6 分钟。

如果您切换到自己的数据集，请相应地更改类的数量、学习率或最大迭代次数。

做一个预测

现在，我们用训练好的模型在 fruits_nuts 数据集上进行推理。首先，让我们使用刚刚训练的模型创建一个预测器:

然后，我们随机选择几个样本来可视化预测结果。

这是你得到的预测覆盖的样本图像。

结论和进一步的思考

你可能已经读过我的上一篇教程，它是关于一个类似的物体检测框架，名为 MMdetection，也是基于 PyTorch 构建的。那么 Detectron2 和它相比怎么样呢？以下是我的几点想法。

这两个框架都很容易配置，只需一个描述如何训练模型的配置文件。Detectron2 的 YAML 配置文件效率更高有两个原因。首先，您可以通过首先创建一个“基础”配置来重用配置，并在这个基础配置文件的基础上构建最终的训练配置文件，从而减少重复代码。第二，可以首先加载配置文件，并允许在 Python 代码中根据需要进行任何进一步的修改，这使得它更加灵活。

推理速度呢？简单来说，对于相同的掩模 RCNN Resnet50 FPN 模型，Detectron2 比 MMdetection 稍快。MMdetection 的速度为 2.45 FPS，而 Detectron2 的速度为 2.59 FPS，即推理单幅图像的速度提高了 5.7%。基于以下代码的基准测试。

所以，你有了它，Detectron2 让你用自定义数据集训练自定义实例分割模型变得超级简单。您可能会发现以下资源很有帮助。

我之前的帖子 - 如何为实例分割 创建自定义 COCO 数据集。

我之前的帖子- 如何用 mmdetection 训练一个物体检测模型。

Detectron2 GitHub 库。

本帖可运行的 Colab 笔记本。

• 标签:
• 深度学习，
• 指针，
• 教程

Share on Twitter Share on Facebook

• ←VS 代码远程开发入门
• 采用端到端深度学习的自动缺陷检查→

如何免费用 TPU 训练 Keras 车型速度快 20 倍

原文：https://www.dlology.com/blog/how-to-train-keras-model-x20-times-faster-with-tpu-for-free/

发帖人:程维 4 年 2 个月前

(评论)

在相当长的一段时间里，我对在单个 GTX 1070 显卡上训练我的模型感到满意，该显卡的单次精度约为 8.18 TFlops，然后谷歌在 Colab 上开放了免费的 Tesla K80 GPU，该 GPU 配有 12GB RAM，额定速度略快于 8.73 TFlops。直到最近，具有 180 TFlops 的云 TPU 选项才在 Colab 的运行时类型选择器中弹出。在这个快速教程中，您将学习如何将您现有的 Keras 模型转化为 TPU 模型，并在 Colab x20 上进行训练，与在我的 GTX1070 上进行免费训练相比，速度更快。

我们将构建一个易于理解但足够复杂的 Keras 模型，以便我们可以稍微预热一下云 TPU。在 IMDB 情感分类任务上训练 LSTM 模型可能是一个很好的例子，因为训练 LSTM 可能比其他层(如密集层和卷积层)在计算上更昂贵。

工作流程的概述，

• 用静态输入 batch_size 在函数 API 中建立一个用于训练的 Keras 模型。
• 将 Keras 模型转换为 TPU 模型。
• 用batch_size * 8和训练 TPU 模型，将权重保存到文件中。
• 构建一个 Keras 模型进行推理，具有相同的结构，但批量输入大小可变。
• 加载模型重量。
• 使用推理模型进行预测。

你可以一边阅读一边玩 Colab Jupyter 笔记本- Keras_LSTM_TPU.ipynb 。

首先，按照下图中的说明在 Colab 运行时激活 TPU。

静态输入批量

在 CPU 和 GPU 上运行的输入管道大多不受静态形状要求的约束，而在 XLA/TPU 环境中，静态形状和批量大小是必须的。

can TPU 包含 8 个 TPU 内核，它们作为独立的处理单元运行。除非使用全部八个内核，否则 TPU 不会得到充分利用。为了充分加快矢量化的训练速度，与在单个 GPU 上训练相同的模型相比，我们可以选择更大的批量。总批量大小为 1024(每个内核 128)通常是一个好的起点。

如果您要训练一个批量过大的较大模型，请尝试慢慢减少批量，直到它适合 TPU 内存，只需确保总批量是 64 的倍数(每个内核的批量应该是 8 的倍数)。

在大批量训练时也值得一提；提高优化器的学习速度以允许更快的收敛通常是安全的。你可以在这篇论文里找到一个参考——精准，大迷你批量 SGD:1 小时训练 ImageNet。

在 Keras 中，为了定义一个静态批量大小，我们使用它的函数 API，然后为输入层指定batch_size参数。请注意，该模型构建在一个采用batch_size参数的函数中，因此我们可以稍后回来创建另一个在 CPU 或 GPU 上运行的推理模型，该模型采用可变的批处理大小输入。

此外，usetf.train.Optimizer代替了标准 Keras 优化器的，因为 Keras 优化器对 TPU 的支持仍处于试验阶段。

将 Keras 模型转换为 TPU 模型

tf.contrib.tpu.keras_to_tpu_model功能将一个tf.keras型号转换成一个等效的 TPU 版本。

然后，我们使用标准的 Keras 方法来训练、保存权重和评估模型。注意，batch_size被设置为模型输入 batch_size 的八倍，因为输入样本被平均分配到 8 个 TPU 内核上运行。

我设置了一个实验来比较在我的 Windows PC 上运行的单个 GTX1070 和在 Colab 上运行的 TPU 之间的训练速度，下面是结果。

GPU 和 TPU 都采用 128 的输入批量，

GPU: 每历元 179 秒。20 个时期达到 76.9%的验证准确度，总共 3600 秒。

TPU: 每个时期 5 秒除了第一个时期用了 49 秒。20 个时期达到 95.2%的验证准确度，总共 150 秒。

20 个历元后 TPU 的验证精度高于 GPU 可能是由于一次训练 8 批 128 个样本的小批量造成的。

CPU 上的推理

一旦我们有了模型权重，我们就可以像往常一样加载它，并在另一个设备(如 CPU 或 GPU)上进行预测。我们还希望推理模型能够接受灵活的输入批量，这可以通过之前的 make_model() 函数来实现。

您可以看到推理模型现在采用可变的输入样本，

_________________________________________________________________
Layer (type) Output Shape Param # 
=================================================================
Input (InputLayer) (None, 500) 0 
_________________________________________________________________
Embedding (Embedding) (None, 500, 128) 1280000 
_________________________________________________________________
LSTM (LSTM) (None, 32) 20608 
_________________________________________________________________
Output (Dense) (None, 1) 33 
=================================================================

然后，您可以在推理模型中使用标准 fit() 、 evaluate()函数。

结论和进一步阅读

这个快速教程向您展示了如何利用 Google Colab 上的免费云 TPU 资源更快地训练 Keras 模型。

云 TPU 文档

云 TPU 性能指南

云 TPU 故障排除指南

XLA 概况

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←如何使用 Keras 稀疏分类交叉熵
• 如何在 TensorFlow 中运行 GPU 加速信号处理→

如何在浏览器上训练神经网络

原文：https://www.dlology.com/blog/how-to-train-neural-network-on-browser/

发帖人:程维四年零五个月前

(评论)

无论你是深度学习的新手还是经验丰富的老手，建立一个训练神经网络的环境有时会很痛苦。让训练一个神经网络变得像加载一个网页，然后点击几下，你就可以马上用它进行推理一样简单，这是不是很棒？

在本教程中，我将向您展示如何使用浏览器上的框架 TensorFlow.js 以及从您的网络摄像头收集的数据和在您的浏览器上的训练来构建模型。为了让这个模型有用，我们将把一个网络摄像头变成传奇游戏“乒乓”的控制器。

让我们先玩游戏

指令在您的计算机上本地提供 web 应用程序，

• 下载 dist.zip 并解压到你的本地机器。
• 安装一个 HTTP 服务器，我的建议是 npm 全局安装 http-server ，

将预训练模型导出到 tfjs

如果只是想学习 web 应用部分，可以跳过这一节。

让我们首先将一个预先训练好的卷积网络导出为 TensorFlow.js(tfjs)格式。在本教程中，我选择了用 ImageNet 数据集训练的 DenseNet，但你也可以使用其他模型，如 MobileNet。尽量避免大型深度卷积网络，如 ResNets 和 VGGs，即使它们可能提供稍高的精度，但不适合边缘设备，如我们在浏览器上运行的情况。

第一步是用 Python 脚本将预先训练好的 DenseNet Keras 模型保存到一个 .h5 文件中。

然后，我们运行转换脚本，将. h5 文件转换为针对浏览器缓存优化的 tfjs 文件。在继续之前，通过 pip3 安装 tensorflowjs 转换脚本 python 包。

pip3 install tensorflowjs

我们现在可以通过运行以下命令来生成 tfjs 文件，

你会看到一个名为 model 的文件夹，里面有几个文件。 model.json 文件定义了模型结构和权重文件的路径。并且预先训练的模型准备好为 web 应用服务。例如，您可以将模型文件夹重命名为 serveDenseNet 并复制到您的 web app served 文件夹，然后模型就可以这样加载了。

window.location.origin是 web 应用程序的 URL，或者如果您在 1234 端口本地提供它，它将是localhost:1234。await声明只是允许 web 应用程序在后台加载模型，而不冻结主用户界面。

此外，要认识到，由于我们加载的模型是一个图像分类模型，我们不需要顶部的图层，我们只需要模型的特征提取部分。解决方案是找到最顶层的卷积层，并截断前面代码片段中显示的模型。

从网络摄像头生成训练数据

为了准备回归模型的训练数据，我们将从网络摄像头中抓取一些图像，并使用 web 应用程序中的预训练模型提取它们的特征。为了简化用于采集训练数据的用户界面，我们仅使用三个值[-1，0，1]中的一个来标记图像。

对于通过网络摄像头获取的每幅图像，它将被输入预先训练的 DenseNet，以提取特征并保存为训练样本。在将图像通过特征提取器模型之后，224×224 的彩色图像将使其维数减少到形状为[7，7，1024]的图像特征张量。形状取决于你选择的预先训练好的模型，可以通过调用我们在上一节中选择的图层上的outputShape来获得，就像这样。

使用提取的图像特征而不是原始图像作为训练数据的原因有两个。首先，它节省了存储训练数据的内存，其次，它通过不运行特征提取模型来减少训练时间。

下面的片段展示了如何通过网络摄像头捕捉图像，并提取和汇总其特征。请注意，所有图像特征都以张量的形式保存，这意味着如果您的模型与浏览器的 WebGL 后端一起运行，它在 GPU 内存中一次可以安全包含多少训练样本是有限制的。所以不要指望用数千甚至数百个图像样本训练你的模型取决于你的硬件。

建立和训练神经网络

建立和训练你的神经网络，而不上传到任何云服务保护你的隐私，因为数据永远不会离开你的设备，看着它在你的浏览器上发生，使它更酷。

回归模型将图像特征作为输入，将其展平为向量，然后跟随两个完全连接的层，并生成一个浮点数来控制游戏。最后一个完全连接的层没有激活函数，因为我们希望它产生-1 到 1 之间的实数。我们选择的损失函数是训练期间的均方误差，以最小化损失。更多关于选择，看我的帖子- 如何选择最后一层激活和损失函数 。

以下代码将构建、编译和拟合模型。看起来很像 Keras 的工作流程吧？

将网络摄像头变成乒乓控制器

正如您可能期望的那样，使用图像进行预测也类似于 Keras 语法。图像首先被转换成图像特征，然后被传递到训练好的回归神经网络，该网络输出-1 到 1 之间的控制器值。

一旦你训练好了模型，游戏开始运行，预测值就会传递下来，通过这个调用 pong.updatePlayerSpeed(value) 来控制玩家的球拍以可变速度向左或向右移动的速度。你可以通过调用、 来开始和停止游戏

结论和进一步的思考

在本教程中，您学习了如何使用 TensorFlow.js 在浏览器上训练神经网络，并将您的网络摄像头变成 Pong 控制器，识别您的动作。请随意检查我的源代码，并对它进行实验，修改它，看看结果如何，如激活函数，损失函数和交换到另一个预先训练的模型等。在具有即时反馈的浏览器上训练神经网络的美妙之处在于，它使我们能够尝试新的想法，更快地获得结果，因为我们的原型也使它更容易被大众接受。在我的 GitHub repo 网络摄像头上查看完整源代码——pong。

• 标签:
• keras ,
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←如何用 CMSIS-NN 在微控制器上运行深度学习模型(第三部分)
• 用神经计算棒制作 DIY 安全摄像机(第一部分)→

如何使用 Keras 稀疏分类交叉熵

原文：https://www.dlology.com/blog/how-to-use-keras-sparse_categorical_crossentropy/

发帖人:程维 4 年 2 个月前

(评论)

在这个快速教程中，我将向您展示两个简单的示例，在编译 Keras 模型时使用sparse_categorical_crossentropy损失函数和sparse_categorical_accuracy度量。

例子一——MNIST 分类

作为多类、单标签分类数据集之一，任务是将手写数字的灰度图像(28 像素×28 像素)分类到它们的十个类别(0 到 9)。让我们构建一个 Keras CNN 模型来处理它，最后一层应用了“softmax”激活，它输出一个十个概率分数的数组(总和为 1)。每个分数将是当前数字图像属于我们的 10 个数字类之一的概率。

对于这种输出形状为(None，10)的模型，传统的方法是将目标输出转换为一位热码编码数组以匹配输出形状，但是，借助于sparse_categorical_crossentropyloss函数，我们可以跳过这一步，保留整数作为目标。

你需要的就是把 categorical_crossentropy 换成sparse_categorical_crossentropy这样编译模型。

之后，你可以用整数目标训练模型，也就是像一样的一维数组

array([5, 0, 4, 1, 9 ...], dtype=uint8)

请注意，这不会影响模型输出形状，它仍会为每个输入样本输出十个概率得分。

示例双字符级序列到序列预测

我们将根据威廉·莎士比亚的综合作品训练一个模型，然后用它来创作一部风格相似的戏剧。

文本 blob 中的每个字符首先通过调用 Python 的内置 ord() 函数转换成一个整数，该函数返回一个表示字符的整数作为其 ASCII 值。例如，ord('a') 返回整数97。因此，我们有一个整数列表来表示整个文本。

给定序列长度为 100 的移动窗口，模型学习预测未来一个时间步长的序列。换句话说，给定序列中时间步长 T0~T99 的字符，该模型预测时间步长 T1~T100 的字符。

让我们在 Keras 中构建一个简单的序列对序列模型。

我们可以进一步可视化模型的结构，以分别理解其输入和输出形状。

即使模型具有三维输出，当用损失函数 sparse_categorical_crossentropy ，编译时，我们可以将训练目标作为整数序列。与前面的例子类似，如果没有sparse_categorical_crossentropy中的的帮助，首先需要将输出的整数转换成 one-hot 编码形式以适应模型。

训练模式为，

• 无状态
• seq_len =100
• batch_size = 128
• 模型输入形状:(批处理大小，序列长度)
• 模型输出形状:(批处理大小，序列长度，最大令牌数)

一旦训练好模型，我们就可以让它“有状态”，一次预测五个字符。通过使其有状态，LSTMs 在一个批次中的每个样本的最后状态将被用作下一个批次中的样本的初始状态，或者简单地说，一次预测的那五个字符和下一个预测批次是一个序列中的字符。

预测模型加载训练好的模型权重并一次预测五个字符，

• 宏伟威严的
• seq_len =1，一个字符/批次
• batch_size = 5
• 模型输入形状:(批处理大小，序列长度)
• 模型输出形状:(批处理大小，序列长度，最大令牌数)
• 需要在预测之前调用 reset_states() 来重置 LSTMs 的初始状态。

关于模型的更多实现细节，请参考我的 GitHub 库。

结论和进一步阅读

本教程探讨了两个例子使用 sparse_categorical_crossentropy 到保持整数为字符/多类分类标签，而不转换为单热标签。因此，当标签是整数时，模型的输出将是类似 softmax one-hot 的形状。

要了解keras . back end . sparse _ category _ cross entropy和sparse _ category _ accuracy的实际实现，可以在 TensorFlow repository 上找到。别忘了在 my GitHub 上下载本教程的源代码。

• 标签:
• keras ,
• 教程，
• 深度学习

Share on Twitter Share on Facebook

• ←如何用生成对抗网络进行 Keras 中的新颖性检测(下)
• 如何免费用 TPU 训练速度快 20 倍的 Keras 车型→

如何使用 Keras TimeseriesGenerator 处理时序数据

原文：https://www.dlology.com/blog/how-to-use-keras-timeseriesgenerator-for-time-series-data/

发帖人:程维四年零三个月前

(评论)

您可能遇到过预测模型，其任务是根据历史数据预测未来值。给定时间序列数据，准备输入和输出对是乏味的。我最近遇到了 Keras 内置的实用程序 TimeseriesGenerator ，它可以准确地完成我想要的功能。

在下面的演示中，您将了解如何将其应用到您的数据集。

源代码可以在我的 GitHub 库上找到。

*想象一下，你是一位拥有敏锐的数据科学意识的基金经理，想要根据公开的股票价格预测今天的道琼斯指数。

我们将使用日变化值作为时间序列数据，而不是使用在过去几年中增加了 60%的绝对 DJI 指数值。由于数据集 _DJI 代表绝对 DJI 指数，日变化值可通过下式计算

我们可以进一步归一化所有值，并将它们分成训练/测试数据集。

单一时间序列预测

你知道 RNN，或者更准确地说，LSTM 网络捕捉时间序列模式，我们可以建立这样一个模型，输入是过去三天的变化值，输出是当天的变化值。第三个是回看长度，可以针对不同的数据集和任务进行调整。简单地说，第 T 天的值是由第 T-3、T-2 和 T-1 天的值预测的。但是我们如何为模型构造训练和测试输入/输出对呢？Keras 的TimeseriesGenerator通过消除我们用来完成这一步骤的样板代码，使我们的生活变得更加轻松。

让我们构建两个时间序列生成器，一个用于训练，一个用于测试。我们使用一个采样率，因为我们不想跳过数据集中的任何样本。

在一个简单的 Keras 模型到位后，我们可以启动培训过程。

训练后的评估和最后的预测也可以这样做。

在此基础上，我们可以从预测的日变化值中重建预测的 DJI 绝对值，方法是首先反转最小-最大归一化过程，并将预测的日变化值与前一天的绝对值相加。

多个时间序列作为输入

您可能已经注意到所有以前的时间序列生成器的“数据”和“目标”参数都是相同的，这意味着输入和输出都来自相同的时间序列。如果在现实生活中，今天 DJI 的收盘价可能会受到一些大公司如苹果和亚马逊之前股价的影响呢？我们还想将这些股票日变化值合并到模型输入中。为了实现这一点，您可以首先将所有三个时间序列连接起来，形成一个(T，3)形状的 numpy 数组，然后将预处理后的结果传递给 TimeseriesGenerator 的“数据”参数。

最后，确保更改模型输入形状以匹配(None，look_back，3)的输入形状。

结论

本快速教程向您展示了如何使用 Keras 的 TimeseriesGenerator 来减轻处理时间序列预测任务时的工作量。它允许您将相同或不同的时间序列作为输入和输出来训练模型。源代码可以在我的 GitHub 库上找到。

Share on Twitter Share on Facebook

• ←如何在 Google Colab 上运行支持 GPU 和 CUDA 9.2 的 py torch
• 如何利用生成对抗网络在 Keras 中进行新颖性检测(上)→*

如何在 Keras 中使用 return_state 或 return_sequences

原文：https://www.dlology.com/blog/how-to-use-return_state-or-return_sequences-in-keras/

发帖人:程维 4 年 8 个月前

(评论)

你可能注意到了，在几个 Keras 轮回层中，有两个参数、、、return_state、、、、、、、return_sequences、。在这篇文章中，我将向你展示它们的含义以及在现实生活中何时使用它们。

为了理解他们的意思，我们首先需要打开一个循环层，比如最常用的 LSTM 和格鲁

简而言之 RNN

Keras 中实现的递归层的最原始版本, SimpleRNN ,它受到消失梯度问题的困扰，使其难以捕捉长程相关性。或者，LSTM 和 GRU 都装有独特的“门”，以避免长期信息“消失”掉。

在上图中，我们可以看到给定一个 RNN 层的输入序列，与每个时间步长相关的每个 RNN 单元将生成称为隐藏状态的输出，即^(t) 。

取决于你使用哪一个 RNN，它在如何计算 a^(t) 上有所不同。

c^(t) 以上公式中的每个 RNN 单元称为单元状态。对于 GRU，给定时间步长的单元状态等于其输出隐藏状态。对于 LSTM 来说，输出隐藏状态a^(t>是由“门控”单元状态 c^(t) 由输出门γ[o]产生的，所以 a^(t) 和 c^(t) 是不一样的。不要担心其余的公式。对 RNN 的基本了解应该足够了。)

返回序列

返回序列是指返回隐藏状态^(<>)。默认情况下，Keras RNN 图层中的return_sequences被设置为 False，这意味着 RNN 图层将只返回最后一个隐藏状态输出 a^(T) 。最后一个隐藏状态输出捕获输入序列的抽象表示。在某些情况下，这就是我们所需要的，例如分类或回归模型，其中 RNN 后面是密集层，以生成用于新闻主题分类的逻辑或用于情感分析的分数，或者在生成模型中生成下一个可能字符的 softmax 概率。

在其他情况下，我们需要完整的序列作为输出。设定 return_sequences 为真有必要。

让我们定义一个只包含一个 LSTM 层的 Keras 模型。使用常量初始值设定项，以便输出结果可重复用于演示目的。

输出:

[[[0.00767819]
  [0.01597687]
  [0.02480672]]] (1, 3, 1)

我们可以看到 LSTM 图层的输出数组形状为(1，3，1)，代表(#样本数、#时间步长数、#LSTM 单位数)。与 return_sequences 设置为 False 时相比，形状将为 (#Samples，#LSTM 单位)，这仅返回最后一个时间步长的隐藏状态。

输出:

[[0.02480672]] (1, 1)

在两种主要情况下，您可以应用return_sequences到返回完整序列。

1. 堆叠 RNN，前一个或多个 RNN 层应将 return_sequences 设置为真，以便随后的一个或多个 RNN 层可以具有作为输入的完整序列。
2. 我们想为每个时间步生成分类。
   1. 如语音识别或更简单的形式- 触发词检测，其中我们为每个时间步长生成一个介于 0~1 之间的值，表示触发词是否存在。
   2. 用 CTC 进行 OCR(光学字符识别)序列建模。

返回状态

返回序列指返回单元格状态 c^(t) 。对于 GRU，正如我们在“RNN 简括”一节中讨论的，a^(t)= c^(t)，所以你可以不用这个参数。但是对 LSTM 来说，隐藏状态和细胞状态是不一样的。

在 Keras 中，通过设置 return_state 为真，我们可以输出 RNN 除隐藏状态之外的最后一个单元格状态。

输出:

[array([[0.02480672]], dtype=float32), array([[0.02480672]], dtype=float32), array([[0.04864851]], dtype=float32)]
(1, 1)
(1, 1)
(1, 1)

LSTM 层的输出有三个分量，它们是( a^(T) ， a^(T) ，c^(T) )，“T”代表最后一个时间步，每个都有形状(#个样本，#个 LSTM 单位)。

您想要设置return_state的主要原因是RNN 可能需要在共享权重时用先前的时间步长初始化其单元状态，例如在编码器-解码器模型中。下面显示了编码器-解码器模型的一段代码。

你已经注意到对于上面的编解码器型号来说 return_sequences 和 return_state 都被设置为真。在那种情况下，LSTM 的输出将有三个分量，(一一^(一< 1)...T >) ，a^(t)，c(t))。如果我们从前面的例子中做同样的事情，我们可以更好地理解它的区别。

输出

[array([[[0.00767819],
        [0.01597687],
        [0.02480672]]], dtype=float32), array([[0.02480672]], dtype=float32), array([[0.04864851]], dtype=float32)]
(1, 3, 1)
(1, 1)
(1, 1)

值得一提的是，如果我们用 GRU 代替 LSTM，输出将只有两个分量。 ( 一^(1...T >) ，c^(t))自从在 GRU 出现了一个^(t)= c^(t)。

结论

为了理解如何使用return_sequences 和 return_state ，我们先简单介绍两个常用的递归层，LSTM 和 GRU，以及它们的单元格状态和隐藏状态是如何导出的。接下来，我们深入研究了应用两个参数中的每一个的一些案例，以及当你可以考虑在你的下一个模型中使用它们时的技巧。

你可以在 my GitHub repo 上找到这篇文章的源代码。

Share on Twitter Share on Facebook

• ←在 Google Colab 中运行 TensorBoard 的快速指南
• 如何训练 Keras 模型识别可变长度的文本→

《如果我是个女孩》-斯塔根的魔镜

原文：https://www.dlology.com/blog/if-i-were-a-girl-magic-mirror-by-stargan/

发帖人:程维四年零四个月前

(评论)

有没有想过如果你是女孩，你会是什么样子？

想象一下。我跳下床，看着镜子。我是金发的！

你问:“那是你作为一个女孩的样子吗？”

我说:“是的，天哪，是的，是的，是的！这是我一直想要的！

魔镜由 StarGAN 提供支持，这是一个用于多领域图像到图像翻译的统一生成对抗网络。这篇文章将向你展示这个模型是如何工作的，以及你如何建造魔镜。

在这里欣赏 YouTube 上的演示。

我的 GitHub 页面上有完整的源代码。

星际之门简介

图像到图像的翻译是将一个给定图像的某一方面改变为另一方面，例如将一个人的性别从男性改变为女性。随着生成对抗网络(GANs)的引入，这项任务经历了重大改进，结果包括从边缘地图生成照片，改变风景图像的季节，以及从莫奈的画作 重建照片。【T8

给定来自两个不同领域的训练数据，这些模型学习以单向方式将图像从一个领域翻译到另一个领域。例如，一个生成模型被训练成将黑头发的人翻译成金发。任何单个现有的 GAN 模型都不能“向后”翻译，就像前面的例子中从金色头发到黑色头发。此外，单一模型无法处理灵活的多领域图像翻译任务。比如性别和头发颜色的可配置转换。这就是 StarGAN 脱颖而出的地方，一种新颖的生成式对抗网络，仅使用单个生成器和鉴别器来学习多个域之间的映射，从所有域的图像中进行有效训练。StarGAN 的模型不是学习一种固定的翻译(例如，从黑人到金发)，而是将图像和领域信息都作为输入，并学习将输入图像灵活地翻译到相应的领域。
预训练的 StarGAN 模型由两个网络组成，像其他 GAN 模型一样，生成网络和判别网络。虽然只需要生成网络来构建魔镜，但是理解完整的模型来自哪里仍然是有用的。

生成网络 以两条信息作为输入，原始 RGB 图像为 256×256 分辨率，目标标签生成一幅相同分辨率的假图像，判别网络 学习区分真假图像，并将真实图像分类到其对应的域。

我们要使用的预训练模型是在 CelebA 数据集上训练的，该数据集包含 202，599 张名人的面部图像，每张图像都用 40 个二元属性进行了注释，而研究人员使用以下属性选择了七个域:头发颜色( 黑色 、 金发 、 棕色 )、性别( 男/女

建筑魔镜

StarGAN 的研究人员在我们的魔镜项目所在的 GitHub 上发布了他们的代码。我也是第一次处理 PyTorch 框架，到目前为止进展顺利。如果你像我一样是 PyTorch 框架的新手，你会发现很容易上手，尤其是有了 Keras 或 TensorFlow 等深度学习框架的经验之后。

完成该项目只需要 PyTorch 框架的最基本知识，如 PyTorch 张量、加载预定义的模型权重等。

让我们从安装框架开始。在我的情况下，在 Windows 10 上，这是最新的 PyTorch 官方支持的。

要使魔镜实时运行，并将可察觉的延迟降至最低，请使用游戏电脑的 Nvidia 显卡(如果有)来加速模型执行。

从 Nvidia 开发者网站上的这个链接安装 CUDA 9。

之后安装 PyTorch 与 CUDA 9.0 支持以下其官方网站的指示。

当 PyTorch 和其他 Python 依赖项安装好后，我们就可以开始编写代码了。

为了实现简单的实时人脸跟踪和裁剪效果，我们将使用 Python 的 OpenCV 库中的轻量级 CascadeClassifier 模块。该模块从网络摄像头帧中获取灰度图像，并返回检测到的人脸的边界框信息。如果在给定的帧中检测到多个面部，我们将采用具有最大计算边界框面积的“主要”面部。

由于 StarGAN 生成网络期望图像的像素值在-1 到 1 之间，而不是在 0 到 255 之间，我们将使用 PyTorch 的内置图像转换实用程序来处理图像预处理。

生成网络子类 PyTorch 的 nn.Module 其中表示可以通过传入输入张量作为自变量直接调用。

labels变量是一个 PyTorch 张量，有 5 个值，每个值设置为 0 或 1，表示 5 个目标标签。

将代码包装成一个函数调用 MagicMirror() ，其中带几个可选参数。

• videoFile:保留默认值 0 使用第一个网络摄像头，或者传入一个视频文件路径。
• setHairColor:三者之一，“黑色”、“金发”、“棕色”。
• setMale:变身男性？设置为真或假。
• setYoung:变身年轻人？设置为真或假。

结论和进一步的思考

本教程向您展示了使用 PyTorch 这样的新框架并用预先训练好的 StarGAN 网络构建一些有趣的东西是多么容易和有趣。

生成的图像可能看起来还不是非常真实，而 StarGAN 的论文显示了一个与 CelebA + RaFD 数据集联合训练的模型可以通过利用这两个数据集来改善面部关键点检测和分割等共享的低级任务，从而生成伪影更少的图像。你可以跟随他们的官方 GitHub 下载数据集并训练这样一个模型，只要你有一台结实的机器和额外的周来运行训练。

Share on Twitter Share on Facebook

• ←带树莓派的 DIY 物体检测涂鸦相机(下)
• 如何在 Google Colab 上运行支持 GPU 和 CUDA 9.2 的 py torch→

Keras +通用语句编码器=文本数据的迁移学习

原文：https://www.dlology.com/blog/keras-meets-universal-sentence-encoder-transfer-learning-for-text-data/

发帖人:程维四年零六个月前

(评论)

我们将构建一个 Keras 模型，利用预先训练的“通用句子编码器”将给定的问题文本分类到六个类别之一。

TensorFlow Hub 模块可应用于各种迁移学习任务和数据集，无论是图像还是文本。 “通用句子编码器”是众多新发布的 TensorFlow Hub 可重用模块之一，TensorFlow 图形的一个独立部分，包含预先训练好的权重值。

一个可运行的 Colab 笔记本已经上市，你可以边读边试验代码。

什么是通用语句编码器，它是如何被训练的

虽然您可以选择将所有 TensorFlow Hub 模块视为黑盒，不知道内部发生了什么，但仍然能够构建功能迁移学习模型。这将有助于加深理解，让你对每个模块的能力、限制以及迁移学习结果的潜力有一个新的认识。

通用语句编码器 VS 文字嵌入

如果你还记得我们之前的教程中的手套单词嵌入向量，它将单词转换成 50 维向量，通用句子编码器要强大得多，它不仅能够嵌入单词，还能够嵌入短语和句子。即它以变长英文文本为输入，输出一个 512 维向量。处理可变长度的文本输入听起来很棒，但问题是随着句子越来越长，嵌入结果可能会越来越模糊。由于模型是在单词级别训练的，它可能会发现错别字和难以处理的单词。更多关于世界级和角色级语言模型的区别，可以看我的以前的教程。

有两种通用语句编码器可供选择，它们具有不同的编码器架构，以实现不同的设计目标，一种基于 transformer 架构，目标是以更大的模型复杂性和资源消耗为代价获得高精度。另一个目标是通过深度平均网络(DAN)以稍微降低的准确度进行有效的推断。

并列式变压器和单句编码器的模型架构比较。

原来的变压器模型构成了编码器和解码器，但这里我们只用到了它的编码器部分。

编码器由 N = 6 个相同层的堆叠组成。每层有两个子层。第一种是多头自关注机制，第二种是简单的、位置式全连接前馈网络。他们还在两个子层中的每一个周围采用了剩余连接，然后进行层归一化。由于模型不包含递归和卷积，为了使模型利用序列的顺序，它必须注入一些关于序列中 记号的相对或绝对位置的信息，这就是“位置编码所做的。T 基于变压器的编码器实现了最佳的整体传输任务性能。然而，这是以计算时间和内存使用随句子长度急剧增加为代价的。

深度平均网络(DAN)要简单得多，其中单词和二元模型的输入嵌入首先一起平均，然后通过前馈深度神经网络(DNN)产生句子嵌入。DAN 编码器的主要优点是计算时间与输入序列的长度成线性关系。

根据培训数据的类型和所选的培训指标，它会对迁移学习结果产生重大影响。

这两个模型都是用斯坦福自然语言推理(SNLI)语料库训练的。 SNLI 语料库是 570，000 个人类书写的英语句子对的集合，这些句子对被手动标记为平衡分类，具有标签蕴涵、矛盾和中性，支持自然语言推理(NLI)的任务，也称为识别文本蕴涵(RTE)。本质上，模型被训练来学习句子对之间的语义相似性。

考虑到这一点， 句子嵌入可以简单地用于计算句子级语义相似度得分。

生成相似性热图的源代码在我的 Colab 笔记本和 GitHub repo 中都有。基于任意两个句子的编码内积进行着色。这意味着两个句子越相似，颜色就越深。

加载通用语句编码器并计算某些文本的嵌入可以像下面这样简单。

首次加载模块可能需要一段时间，因为它会下载重量文件。

message_embeddings的值是 两个数组对应两个句子的嵌入，每个都是 512 个浮点数的数组。

array([[ 0.06587551, 0.02066354, -0.01454356, ..., 0.06447642, 0.01654527, -0.04688655], [ 0.06909196, 0.01529877, 0.03278331, ..., 0.01220771, 0.03000253, -0.01277521]], dtype=float32)

问题分类任务和数据预处理

在作为检索任务的问答中，为了正确回答给定的大量文本中的问题，将问题分类成细粒度的类别是至关重要的。我们的目标是将问题分为不同的语义类别，这些类别对潜在答案施加约束，以便它们可以在问答过程的后期阶段使用。比如在考虑问题Q:加拿大哪个城市人口最多？ 希望将这个问题归类为有答案类型 地点 ，暗示只有是地点的候选答案需要考虑。

我们使用的数据集是 TREC 问题分类数据集，总共有 5452 个训练样本和 500 个测试样本，即 5452 + 500 个问题，每个问题被归入六个标签中的一个。

1. 【ABBR———‘缩写’:表达缩写等。
2. DESC -【描述和抽象概念】:动作的方式，对某事物的描述。等等。
3. ENTY -【实体】:动物、颜色、事件、食物等。
4. HUM -【人类】:一群人或一个组织，个人等。
5. 【地点】:城市、国家等。
6. NUM-‘数值’:邮编、日期、速度、温度等

我们希望我们的模型是一个多类分类模型，将字符串作为 6 个类标签中每一个的输入和输出概率。记住这一点，你就知道如何为它准备训练和测试数据。

第一步是将原始文本文件转换成 pandas DataFrame，并将“label”列设置为 categorical 列，这样我们就可以进一步以数值形式访问标签。

前 5 个训练样本如下所示。

下一步，我们将为模型准备输入/输出数据，输入为一列问题字符串，输出为一列一次性编码标签。如果你对一键编码还不熟悉，我在之前的文章中已经介绍过了。

如果你瞥一眼train_label的值，你会看到它以一键编码的形式出现。

array([[0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 0, 0] ...], dtype=int8)

现在我们已经准备好构建模型了。

Keras 遇上通用句子编码器

我们之前已经将通用语句编码器加载为变量“embed”，为了让它与 Keras 很好地配合，有必要将其包装在 Keras Lambda 层中，并将其输入显式转换为字符串。

然后我们在它的标准功能 API 、中构建 Keras 模型

我们可以查看模型摘要，并意识到只有 Keras 层是可训练的，这就是迁移学习任务如何通过确保通用句子编码器权重不变来工作的。

_________________________________________________________________
Layer (type) Output Shape Param # 
=================================================================
input_1 (InputLayer) (None, 1) 0 
_________________________________________________________________
lambda_1 (Lambda) (None, 512) 0 
_________________________________________________________________
dense_1 (Dense) (None, 256) 131328 
_________________________________________________________________
dense_2 (Dense) (None, 6) 1542 
=================================================================
Total params: 132,870
Trainable params: 132,870
Non-trainable params: 0
_________________________________________________________________

在下一步中，我们使用训练数据集训练模型，并在每个训练时期结束时使用测试数据集验证其性能。

最终验证结果显示，经过 10 个时期的训练，最高准确率达到 97%左右。

在我们对模型进行训练并将其权重保存到文件中之后，实际上是对新问题进行预测。

在这里，我们提出了 3 个新问题供模型进行分类。

分类结果看起来不错。

['NUM', 'LOC', 'HUM']

结论和进一步阅读

恭喜你！您已经建立了一个由通用句子编码器支持的 Keras 文本迁移学习模型，并在问题分类任务中取得了很好的结果。通用句子编码器可以嵌入更长的段落，因此可以随意试验其他数据集，如新闻主题分类、情感分析等。

一些你可能会觉得有用的相关资源。

TensorFlow Hub

TensorFlow Hub 示例笔记本

关于使用 Google Colab notebook 的介绍，你可以免费阅读我的文章的第一部分- 如何在视频上快速运行对象检测和分割。

my GitHub 中的源代码和一个可运行的 Colab 笔记本。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←如何训练 Keras 模型生成颜色
• 使用 TensorFlow Hub DELF 模块轻松识别地标图像→

利用预训练的 VGGFace2 模型进行实时人脸识别

原文：https://www.dlology.com/blog/live-face-identification-with-pre-trained-vggface2-model/

发帖人:程维 4 年 11 个月前

(评论)

人脸识别的一个挑战是当你想在现有的列表中添加一个新的人时。你会用大量这个新人的脸和其他人的脸来重新训练你的网络吗？如果我们建立一个分类模型，模型如何对一个未知的人脸进行分类？

在这个演示中，我们通过计算两张人脸的相似度来解决这个问题，一张人脸在我们的数据库中，一张人脸图像在网络摄像头上拍摄。

VGGFace 模型将一张脸“编码”成 2048 个数字的表示。

然后，我们计算两个“编码”人脸之间的欧几里德距离。如果他们是同一个人，距离值将会很低，如果他们来自两个不同的人，距离值将会很高。

在人脸识别期间，如果该值低于阈值，我们将预测这两张照片是同一个人。

该模型本身基于 RESNET50 架构，该架构在处理图像数据方面很流行。

我们先来看看演示。

演示源代码包含两个文件。第一个文件将预先计算“编码”人脸的特征，并将结果与人名一起保存。

第二个将是现场演示，从网络摄像头捕捉图像帧，并识别是否有任何已知的面孔。

让我们开始吧。

预计算面特征

向模型中添加新人的一个标准方法是调用一次性学习。在一次性学习问题中，你必须只从一个例子中学习来再次识别这个人。

我可能有风险，因为这张照片可能光线不好，或者脸部的姿势很糟糕。因此，我的方法是从一个短视频剪辑中提取人脸，只包含这个人，并通过平均每个图像的所有计算特征来计算“平均特征”。

你可以找到我的完整源代码 precompute_features.py 。但这是让奇迹发生的重要部分。

我们为每个人准备了一个或多个视频文件。FaceExtractor的 extract_faces方法取一个视频文件，逐帧读取。

对于每一帧，它裁剪面部区域，然后将面部保存到图像文件中的save_folder。

在extract_faces方法中，我们调用 VGGFace 特征提取器来生成这样的人脸特征，

我们对所有人的视频都这样做。然后，我们提取这些面部图像的特征，并计算每个人的“平均面部特征”。然后将它保存到演示部分的文件中。

现场演示部分

因为我们已经预先计算了现场演示部分中每个人的面部特征。它只需要加载我们刚刚保存的特征文件。

提取面部，计算特征，将它们与我们预先计算的特征进行比较，看是否有匹配的。如果我们找到任何匹配的脸，我们在框架覆盖图中画出这个人的名字。

下面的方法从网络摄像头图像中的人脸计算出特征，并与我们已知的每个人脸的特征进行比较

如果这个人的面部特征离我们所有已知的面部特征“很远”，我们显示“？”在最终的图像覆盖上签名，表明这是一张未知的脸。

下面展示了一个演示，

总结和进一步阅读

我在这个演示中只包括了 3 个人。可以想象，随着人数的增加，这个模型很可能会混淆两张相似的脸。

如果发生这种情况，你可以考虑探索如 Coursera 课程所示的三联体缺失的暹罗网络。

FaceNet 就是一个很好的例子。

对于那些感兴趣的人。完整的源代码列在 my GitHub repo 中。尽情享受吧！

Share on Twitter Share on Facebook

• ←使用 Keras 从网络摄像头视频中轻松实时预测性别年龄
• 教老狗新招——训练面部识别模型理解面部情绪→

不平衡数据集的聚焦损失多类分类

原文：https://www.dlology.com/blog/multi-class-classification-with-focal-loss-for-imbalanced-datasets/

发帖人:程维四年前

(评论)

焦损失是今年年初提出的密集物体探测任务。它使得能够在 1:1000 的比例下训练前景和背景类别之间不平衡的高度精确的密集物体检测器。本教程将向您展示如何应用焦点损失来训练给定高度不平衡数据集的多类分类器模型。

背景

让我们先来看看不平衡数据集的其他处理方法，以及聚焦损失是如何解决这个问题的。

在多类分类中，平衡数据集具有均匀分布的目标标签。I 如果一个类比另一个类有更多的样本，它可以被看作是一个不平衡的数据集。这种不平衡导致两个问题:

• 训练是低效的，因为大多数样本是简单的例子，没有贡献有用的学习信号；
• 简单的例子会淹没训练并导致退化的模型。

一种常见的解决方案是执行某种形式的硬负挖掘，在训练或更复杂的采样/重新加权方案中对硬样本进行采样。

对于特定的图像分类，数据扩充技术也是可变的，以便为代表性不足的类别创建合成数据。

焦点损失旨在通过降低内联体(简单的例子)的权重来解决类别不平衡，这样即使它们的数量很大，它们对总损失的贡献也很小。它侧重于训练一组稀疏的硬例子。

将焦点损失应用于欺诈检测任务

为了进行演示，我们将为 Kaggle 上的欺诈检测数据集构建一个分类器，该数据集具有极端的类别不平衡，共有 6354407 个正常案例和 8213 个欺诈案例，即 733:1。对于这种高度不平衡的数据集，该模型可以采取简单的方法，通过猜测所有输入的“正常”来实现 733/(733+1) = 99.86% 的准确性。但是，我们希望该模型能够检测出罕见的欺诈案例。

为了证明焦点损失比通常应用的技术更有效，让我们建立一个用 class_weight 训练的基线模型，它告诉该模型“更多地关注”来自代表性不足的欺诈类别的样本。

基线模型实现了 99.87% 的准确率，仅仅比通过猜测所有正常的“简单路线”稍好一点。

我们还绘制混淆矩阵来描述给定保留测试集的分类器的性能。你可以看到总共有 1140+480=1620 个误分类案例。

现在让我们将焦点损失应用于同一模型。您可以在下面看到如何将焦点损失定义为 Keras 的自定义损失函数。

焦点损失有两个可调参数。

• 聚焦参数γ(gamma)平滑地调整简单示例向下加权的速率。当γ = 0 时，焦损失相当于分类交叉熵，并且随着γ的增加，调制因子的影响同样增加(γ = 2 在实验中效果最好)。
• α(alpha): 平衡焦点损失，比非α-平衡形式的精度略有提高。

现在让我们比较一下与之前分类器的性能。

焦点损失模型:

• 准确率:99.94%
• 总误分类测试集样本: 766+23=789 ，将错误减少一半。

结论和进一步阅读。

在这个快速教程中，我们为您介绍了一个处理高度不平衡数据集的新工具——焦点丢失。一个具体的例子向您展示如何在 Keras API 中将焦点损失应用到您的分类模型中。

你可以在我的 GitHub 上找到这篇文章的完整源代码。

关于焦损的详细描述，可以阅读论文，https://arxiv.org/abs/1708.02002。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←如何用 OpenCV 测量网络摄像头的延迟
• Keras 中卷积神经网络图像分类的锦囊妙计→

改进马达声学分类器的一个简单技巧

原文：https://www.dlology.com/blog/one-simple-trick-to-improve-the-motor-acoustic-classifier/

发布者:程维 5 年 2 个月前

(评论)

在我们之前的帖子中，我们制作了一个模型，通过音频记录数据预测电机是否有故障。我们将音频时间序列数据输入到模型中，获得了 0.9839 的测试精度。在这篇文章中，我们将发现如何从时间序列数据中提取特征来填充模型。使用我们的测试 WAV 文件，最终的预测准确率提高到了 100%。

介绍 MFCC

梅尔频率倒谱(MFC)是声音的短期功率谱的表示，梅尔频率倒谱系数(MFCC)是共同构成 MFC 的系数， MFC wiki 。

理论够了，我们来直观的看一下。

为了从我们的音频数据中提取 MFCC 特征，我们将使用 Python librosa 库。

首先，用 pip 安装它

pip install librosa

我们将使用一个警报器声音 WAV 文件进行演示。从 Github 这里下载 siren_mfcc_demo.wav 放到你的目录下

在 Python 控制台/笔记本中，让我们先导入我们需要的东西

然后让我们提取 MFCC 特征

feature_normalize 函数与上次 post 相同，将音频时间序列归一化到 0 左右，标准差为 1。

• 帧:41，一帧包括 512 个样本
• 跳跃长度:512，连续帧之间的样本数
• window_size: 512 * (41-1) = 20480。计算 MFCCs 特性的总样本数。给定采样率 22kHz，总时间约 1 秒。

让我们来看一下 MFCC 特征，它是一个形状为(带、帧)的 numpy 数组，在本例中为(20，41)

这是 siren WAV 文件第一秒的 MFCC 特征。X 轴是时间，它被分成 41 帧，Y 轴是 20 个波段。你注意到图表中的模式了吗？稍后我们将教我们的模型也看到这种模式。

建立我们的新模型

由于模型输入更改为，模型结构将与之前的帖子不同

MFCC 的特色。

注意一个模型输入形状与一个 MFCC 特征转置形状(帧，带)匹配，即(41，20)。由于 RNN 模型需要时间主输入，因此 Mfcc 功能被调换。

关于完整的源代码，请查看我更新的 GitHub。如果您有任何问题，请随时发表评论。

Share on Twitter Share on Facebook

• ←如何用 Tensorflow 总结亚马逊评论
• 如何将内容“粘贴”到不支持复制粘贴的 VNC 控制台→

一个简单的技巧来训练 Keras 模型更快与批处理规范化

原文：https://www.dlology.com/blog/one-simple-trick-to-train-keras-model-faster-with-batch-normalization/

发帖人:程维 5 年前

(评论)

免责声明:批量正常化确实是一种帮助训练更快的优化，所以你不应该把它当成一种让你的网络更好的方法。

什么是批量正常化？

论文中首先介绍:通过减少内部协变量移位加速深度网络训练。

随着数据流经深度网络，权重和参数会调整这些值，有时会使数据再次变得过大或过小——作者将这一问题称为“内部协变量移位”。通过标准化每个小批量的数据，这个问题在很大程度上得以避免。批次标准化通过均值和方差参考对每个批次进行标准化。

批量标准化的好处

• 网络训练越快，收敛越快，
• 允许更高的学习率。梯度下降通常需要较小的学习速率来使网络收敛。
• 使权重更容易初始化
• 使更多的激活功能可行。因为批量标准化调节进入每个激活函数的值，在深度网络中似乎不太适用的非线性实际上又变得可行了。
• 可能会产生更好的整体效果。

实施要点

• 批量标准化照常使用权重，但是没有添加偏差项。这是因为它的计算包括伽玛和贝塔变量，使得偏差项变得不必要。在 Keras 中，可以做 Dense(64, use_bias=False) 或者 Conv2D(32, (3, 3), use_bias=False)
• 我们在调用激活函数之前添加了规范化。

启用了批量规范化的 Keras 模型

致密层

一个正常的密集的全连接层看起来是这样的

要使其批量标准化启用，我们必须告诉密集层不使用偏差，因为它不是必需的，它可以节省一些计算。此外，将激活层放在BatchNormalization()层之后

Conv2D 图层

正常的 Keras Conv2D 层可以定义为

将其批量规格化为 Conv2D 图层，我们添加BatchNormalization() 图层类似于上面的密集图层

比较培训绩效

通常，模型需要足够复杂，以便训练可以从批量标准化中获得明显的好处。

出于演示的目的，我们选择了 MNIST 的手写数字数据集

• 数据集附带 Keras，因此不需要额外下载
• 它的训练速度相对较快
• 模型架构很容易理解

这是一个简单的模型结构，具有 3 个堆叠的 Conv2D 层，用于从手写数字图像中提取特征。将数据从 3 维扁平化为 1 维，然后进行两次密集分层，生成最终的分类结果。

我们将对所有致密和 Conv2D 层进行批量归一化，并将结果与原始模型进行比较。

我们用不同的参数训练模型，并并排比较两个模型

• 学习率(高或低)
• 激活(relu 或 sigmoid)

正如我们所看到的，使用批次归一化的模型的验证准确度曲线略高于未使用批次归一化的原始模型。

让我们用 10 倍的学习率来训练这两个模型，

没有批量归一化的原始模型根本无法以这种学习速率进行学习。

如果我们使用非线性 relu 激活函数来代替相同的 x10 学习速率，

最后，未经批量归一化的原始模型可以训练，而经过批量归一化的模型在训练过程中具有更高的验证精度。

摘要

这篇文章展示了对现有的 Keras 模型应用批处理规范化是多么容易，并展示了一些训练结果，比较了有和没有批处理规范化的两个模型。值得注意的是，批量标准化在相对较大的学习速率下工作良好。

最后一点，批量标准化处理训练和测试是不同的，但是它在 Keras 中是自动处理的，所以你不必担心。

在我的 GitHub repo 上查看这篇文章的源代码。

进一步阅读

论文 经常性批量归一化

BatchNormalization Keras doc

【Tensorflow 演示 -向您展示培训和测试的不同

在 Tensorflow 中实现批量归一化

Share on Twitter Share on Facebook

• ←如何利用 TensorFlow 的 TFRecord 训练 Keras 模型
• 在浏览器上运行的十大深度学习体验→

在 Google Colab 中运行 TensorBoard 的快速指南

原文：https://www.dlology.com/blog/quick-guide-to-run-tensorboard-in-google-colab/

发帖人:程维 4 年 8 个月前

(评论)

更新:如果您使用最新的 TensorFlow 2.0，请阅读此贴，了解任何 Jupyter 笔记本中的 TensorBoard 原生支持- 如何在 Jupyter 笔记本中运行 tensor board

*无论你是刚刚开始深度学习，还是经验丰富，想要快速实验，Google Colab 都是一个非常棒的免费工具，可以满足小众需求。如果你还没有看过我以前的教程的话，可以看看它的简短介绍。

您可能还知道 TensorBoard，这是一个在您训练模型时进行可视化的优秀工具。

更有趣的是，如果你正在用 TensorFlow 后端在 Keras API 中构建你的深度学习模型，它会附带基本的 TensorBoard 可视化。

我们将在 Colab 上训练一个 Keras 模型，并在用 TensorBoard 训练时可视化它。

但是有一件事我们需要先解决。您的 Google Colab 虚拟机运行在位于 Google 服务器机房的本地网络上，而您的本地机器可能在世界上的任何其他地方。

如何从本地机器访问 TensorBoard 页面？

我们将使用一个名为 ngrok 的免费服务通过隧道连接到您的本地机器。

这里有一个图表显示它是如何工作的。

你可能有过在 Linux 上建立网络隧道经验，这需要大量的配置和安装。然而，我发现用 ngrok 建立一个可靠的隧道连接非常容易。

您可以在阅读本教程的同时打开本 Colab 笔记本，享受最佳的学习体验。

在 Colab 上设置 ngrok 并运行 TensorBoard

Ngrok 可执行文件可以直接下载到你的 Colab 笔记本上，运行那两行代码。

在此之后，可执行文件 ngrok 将被解压到当前目录。

接下来，让我们像这样启动背景中的张量板:

它假设张量板日志路径是”。/log”，这里我们要告诉 Keras 要日志文件。

然后，我们可以运行 ngrok 将 TensorBoard 端口 6006 隧道化到外部世界。该命令也在后台运行。

最后一步，我们获取公共 URL，在那里我们可以访问 colab TensorBoard 网页。

这将输出一个您可以点击的 URL，但是请等待！我们还没有训练我们的模型，所以你还没有从 TensorBoard 得到任何信息。

Keras 的张量板

在本节中，我们将开始训练一个 Keras 模型，并要求 Keras 将 TensorBoard 日志文件输出到。/log 目录。

Keras 通过回调输出 TensorBoard 日志文件，这允许您可视化您的训练和测试指标的动态图表，以及您的模型中不同层的激活直方图。您可以选择是否可视化单个组件，甚至可以选择希望 Keras 激活和加权直方图的频率。下面的代码将允许您可视化我们的 Keras 模型的所有可用组件。该模型本身是一个简单的两层 3×3 卷积，然后是两个密集层，以分类 MNIST 手写数字数据集。

当这个模型正在训练时，你可以打开之前的 ngrok 链接，它应该会显示 TensorBoard 页面。

如果你是 TensorBoard 的新手，在接下来的部分，我将向你展示一些想法，每一个组件意味着什么，什么时候它们会有用。

TensorBoard 短途旅行

模型训练时，TensorBoard 会定期自动更新视图。

数量

在此选项卡中，您可以看到四个图表，acc、loss、acc_val 和 loss_val，分别代表训练准确性、训练损失、验证准确性和验证损失。在一个理想的训练过程中，我们期望精确度会随着时间的推移而增加，而损失会随着时间的推移而减少。但是，如果您看到在经过一些特定时期的训练后，验证准确性开始下降。您的模型可能会在训练集上过度拟合。我有两个简单的方法来快速制作过度合身的模特 。虽然模型过度拟合还有其他原因，但一个明显的原因是训练数据太小，解决方法是找到或生成更多数据。

我们模型的损耗和精确度符合我们的预期。

直方图

此选项卡显示模型中不同层的激活权重、偏差、梯度直方图的分布。这个图表有用的一个方法是通过可视化梯度的值，我们可以告诉一个模型是否受到 v 消失/爆炸梯度的影响，给我以前的帖子一个阅读如何处理 Keras 中的消失/爆炸梯度。

对于其他选项卡,“图形”选项卡显示计算图形，这在构建自定义图层或损失函数时更有用。图像选项卡将模型权重可视化为图像。

总结和进一步阅读

您学习了如何在 Google Colab 笔记本上运行 TensorBoard，并通过利用免费的 ngrok 隧道服务在本地机器上访问它。

另外，您也可以在 Colab 中运行下面的代码，使用 localtunnel 代替 ngrok。

要进一步了解如何使用 Keras 配置 TensorBoard，请参考官方文档，您可以禁用一些不需要的功能来加速训练，因为为 TensorBoard 生成日志需要大量时间。

此外，如果你正在 TensorFlow 上直接建立模型，但还不太熟悉 TensorBoard，可以在 YouTube 上查看这个动手 tensor board(tensor flow Dev Summit 2017)。

Share on Twitter Share on Facebook

• ←如何为 Keras 分类器生成 ROC 图的简单指南
• 如何在 Keras 中使用 return_state 或 return _ sequences→*

如何在 Keras 中选择优化器的快速说明

原文：https://www.dlology.com/blog/quick-notes-on-how-to-choose-optimizer-in-keras/

发帖人:程维 4 年 11 个月前

(评论)

TL；博士 亚当 在实践中效果很好，胜过其他自适应技术。

对浅层网络使用 SGD+内斯特罗夫，对深网使用 Adam 或 RMSprop。

我参加了 Coursera 的课程 2:改善深度神经网络。

这门课的第二周是关于最优化算法的。我发现这有助于发展对不同优化算法如何工作的更好的直觉，即使我们只对将深度学习应用于现实生活中的问题感兴趣。

以下是我从一些研究中学到的一些东西。

亚当

亚当:自适应力矩估计

亚当= RMSprop +动量

Adam 的一些优势包括:

• 相对较低的内存需求(尽管高于梯度下降和带动量的梯度下降)
• 即使对超参数进行小的调整，通常也能很好地工作。

在 Keras，我们可以这样定义。

**#### 什么是气势？

动量将过去的梯度考虑在内，以平滑梯度下降的步骤。它可以应用于批量梯度下降、小批量梯度下降或随机梯度下降。

随机梯度下降(SGD)

在 Keras 中，我们可以这样做来启用 SGD +内斯特罗夫，它适用于浅层网络。

什么是内斯特罗夫的气势？

涅斯捷罗夫加速梯度(nag)

直觉如何加速梯度下降。

我们希望有一个更智能的球，一个知道自己要去哪里的球，这样它就知道在山坡再次向上倾斜之前减速。

这是一个动画梯度下降与多个优化。

图片来源:cs 231n

注意这两个基于动量的优化器(-绿色动量 ，-紫色动量 ) 有过冲行为，类似于一个球滚下山坡。

与标准动量相比，内斯特罗夫动量的超调较小，因为它采用了下面所示的“ gamble- > correction ”方法。

阿达格勒

它对不频繁的参数进行大的更新，对频繁的参数进行小的更新。因此，非常适合处理稀疏数据。

Adagrad 的主要好处是我们不需要手动调整学习速率。大多数实现使用默认值 0.01，并保持不变。

缺点 —

它的主要弱点是学习率总是在降低和衰减。

阿达德尔塔

它是 AdaGrad 的扩展，旨在消除其学习率下降的问题。

AdaDelta 的另一个特点是我们甚至不需要设置默认的学习速率。

进一步阅读

CS231n Convolutional Neural Networks for Visual RecognitionKeras doc Usage of optimizersCourse 2 Improving Deep Neural Networks from CourseraShare on Twitter Share on Facebook

• ←过拟合模型的两个简单配方
• 如何在 Keras 中缺失标签的情况下进行多任务学习→**

用于物体检测的深度学习的最新进展——第二部分

原文：https://www.dlology.com/blog/recent-advances-in-deep-learning-for-object-detection-part-2/

发帖人:程维三年零四个月前

(评论)

在对象检测的深度学习最新进展系列的第二部分中，我们将总结对象检测的三个方面，提议生成、特征表示学习和学习策略。

提案生成

建议生成器生成一组矩形边界框，它们是潜在的对象。

特征表征学习

三类:多尺度特征学习、上下文推理、可变形特征学习。

学习策略

解决不平衡采样、定位、加速等问题。

结论和进一步的思考

本系列概述了深度学习中用于对象检测的几个关键部分，以及它们如何相互建立。最后，让我们用 FPN 更快的 RCNN 的网络结构来结束这个系列。

• 标签:
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←物体检测深度学习的最新进展-第一部分
• VS 代码远程开发入门→

用于物体检测的深度学习的最新进展(1)

原文：https://www.dlology.com/blog/recent-advances-in-deep-learning-for-object-detection/

发帖人:程维三年零四个月前

(评论)

在训练自定义对象检测模型时， TensorFlow 对象检测 API 和 MMdetection (PyTorch)是两个现成的选项，我已经向您展示了如何在 Google Colab 的免费 GPU 资源上完成这项工作。

这两个框架易于使用，配置接口简单，让框架源代码来完成繁重的工作。但是你有没有想过这些年来深度学习对象检测算法是如何进化的，它们的优缺点是什么？

我发现这篇论文- 物体检测深度学习的最新进展很好地回答了这个问题。让我总结一下我所学到的，希望能以更直观的方式阐述。

文字颜色: pro / cons

检测范例

两级检测器

一级检测器

主干架构

Conclusion and further reading

这篇快速帖子从三个方面总结了深度学习对象检测的最新进展，两阶段检测器、一阶段检测器和主干架构。下次您使用第三方开源框架训练自定义对象检测时，您将更有信心通过检查它们的优缺点来为您的应用程序选择最佳选项。

在下一篇文章中，我将完成我们在论文中留下的内容，即建议生成、特征表示学习和学习策略。如果你感兴趣，强烈建议看一下论文，它将非常值得你花时间去读。

• 标签:
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←如何在 Nvidia Docker 容器中的 Jetson Nano 上运行 Keras 模型
• 用于物体检测的深度学习的最新进展-第二部分→

如何为 Keras 分类器生成 ROC 图的简单指南

原文：https://www.dlology.com/blog/simple-guide-on-how-to-generate-roc-plot-for-keras-classifier/

发帖人:程维 4 年 8 个月前

(评论)

阅读本指南后，您将知道如何通过 ROC 和 AUC 评估 Keras 分类器:

• 为二元分类器生成 ROC 图；在此过程中应用交叉验证。
• 计算 AUC 并使用它来比较分类器性能。
• 将 ROC 分析应用于多类分类。创建 ROC 来评估单个类和整体分类性能。

ROC 和 AUC 是什么，能做什么？

它们是什么？

来自维基百科:接收机工作特性曲线又名 ROC 是一个图形图说明了一个 二元分类器 系统在其区分阈值变化时的诊断能力。这里的临界点是“二元分类器”和“可变阈值”。我还将向您展示如何通过一对一方法绘制多标签分类器的 ROC。

曲线下面积，又名 AUC 是该面积在该 ROC 曲线下的百分比，范围在 0~1 之间。

他们能做什么？

ROC 是可视化二元分类器性能的一种很好的方式，AUC 是一个单一的数字，通过评估关于两类分离的排名来总结分类器的性能。T3 越高越好。

在接下来的两节中，我将向您展示如何绘制 ROC 并计算 Keras 分类器的 AUC，包括二元和多标签分类器。

二元分类器的 ROC，AUC

首先，我们用 Sklearn 的 make_classification() 函数生成一些训练/测试数据。

接下来，让我们像往常一样构建和训练一个 Keras 分类器模型。

然后我们对保留的测试数据调用 model.predict 来生成概率值。之后，使用概率和地面真实标签生成绘制 ROC 曲线所需的两个数据数组对:

• fpr: 每个可能阈值的假阳性率
• tpr: 每个可能阈值的真阳性率 s

我们可以调用 sklearn 的 roc_curve() 函数来生成这两个。下面是实现它们的代码。

AUC 值也可以这样计算。

为了使图看起来更有意义，让我们训练另一个二元分类器，并在同一图中稍后将其与我们的 Keras 分类器进行比较。

现在，让我们为这两个分类器绘制 ROC 图。

结果如下:

如您所见，给定 AUC 度量，Keras 分类器优于其他分类器。

类别分类器的 ROC，AUC

ROC 曲线延伸到三类或更多类的问题，这就是所谓的一对多方法。

例如，如果我们有三个类，我们将创建三条 ROC 曲线，

对于每一个类，我们将其作为正类，其余类共同分组为负类。

• 一班对二班&三班
• 二级对一级&三级
• 三班对一班&二班

让我们从创建一些具有 3 类输出的训练/测试数据开始。

然后，我们像以前一样建立和训练分类 Keras 分类器。

训练模型后，我们可以用它来预测测试输入，并绘制 3 个类别的 ROC 图。

在此之前，让我们定义度量标准来评估所有类的整体性能。有两个略有不同的指标，微观和宏观平均。

在“微平均”中，我们将从 k 类模型的各个真阳性、真阴性、假阳性和假阴性计算性能，例如精度:

在宏观平均法中，我们对每个班级的表现进行平均:

下面是绘制 ROC 曲线和 AUC 值的代码。

这是结果，第二个图是图表左上角的放大图。

你可以看到，对于每个类别，它们的 ROC 和 AUC 值略有不同，这很好地表明了我们的模型在分类单个类别方面有多好。

总结和进一步阅读

在本教程中，我们介绍了如何使用 ROC 曲线和 AUC 值评估二元和分类 Keras 分类器。

ROC 曲线将测试集上的排名器或概率模型的质量可视化，而不承诺分类阈值。我们还学习了如何计算 AUC 值，以帮助我们评估分类器的性能。

如果你想了解更多关于 ROC 的知识，你可以阅读它的维基百科页面，接收器工作特性，它向你展示了如何通过迭代不同的阈值来绘制曲线。

另外，在计算 ROC 上查看 Sklearn 的 API 文档有助于进一步了解如何使用该功能。

你可以在我的 GitHub repo 中找到本教程的源代码。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←YOLO 对象定位如何与 Keras 协同工作的简明指南(第二部分)
• 在 Google Colab 中运行 TensorBoard 的快速指南→

基于深度可分卷积的简单语音关键词检测

原文：https://www.dlology.com/blog/simple-speech-keyword-detecting-with-depthwise-separable-convolutions/

发帖人:程维四年零六个月前

(评论)

关键字检测或语音命令可以被视为语音识别系统的最小版本。如果我们能够制造出精确的模型，同时消耗足够小的内存和计算空间，甚至可以在裸机(没有操作系统)的微控制器上实时运行，那会怎么样？如果这成为现实，想象一下哪些传统的消费电子设备会因为启用了永远在线语音命令而变得更加智能。

在这篇文章中，我们将采取第一步来建立和训练这样一个深度学习模型，在有限的内存和计算资源的情况下进行关键词检测。

关键词检测系统

与通常基于云并且可以识别几乎任何口语单词的完整语音识别系统相比，另一方面，关键字检测可以检测预定义的关键字，如“Alexa”、“Ok Google”、“嘿 Siri”等。哪个是“一直开”。关键词的检测触发了特定的动作，例如激活全面语音识别系统。在一些其他的用例中，这样的关键字可以用于激活启用语音的灯泡。

关键词检测系统由两个基本部分组成。

1. 特征提取器，用于将音频剪辑从时域波形转换为频域语音特征。
2. 基于神经网络的分类器，用于处理频域特征并预测所有预定义关键字加上“未知”单词和“无声”的可能性。

我们的系统采用梅尔倒谱系数 或 MFCCs 作为特征提取器来获取音频的 2D‘指纹’。由于神经网络的输入是像 2D 音频指纹这样的图像，横轴表示时间，纵轴表示频率系数，因此选择基于卷积的模型似乎是一个自然的选择。

深度可分卷积

标准卷积运算的问题可能仍然需要太多来自微控制器的存储器和计算资源，考虑到甚至一些最高性能的微控制器只有大约 320KB 的 SRAM 和大约 1MB 的闪存。满足约束条件同时仍然保持高精度的一种方法是应用深度方向可分离卷积来代替传统的卷积神经网络。

它首先在 Xception ImageNet 模型中引入，然后被 MobileNet 和 ShuffleNet 等其他一些模型采用，旨在降低模型复杂性，以部署在智能手机、无人机和机器人等资源受限的目标上。

深度方向可分离卷积神经网络在于首先执行深度方向空间卷积，其分别作用于每个输入通道，随后是点方向卷积(即，1x1 卷积)，其混合所得的输出通道。直观上，可分卷积可以理解为将卷积核分解成两个更小的核的一种方式。

一个标准的卷积运算一步就把输入过滤合并成一组新的输出。与传统的卷积运算相比，深度方向可分离卷积将其分为两层，一层用于滤波，另一层用于合并。这种因子分解具有显著减少计算和模型大小的效果。 深度方向可分卷积在参数数量和运算上都更高效，这使得更深更宽的架构甚至在资源受限的器件中也成为可能。

下一节我们将通过 TensorFlow 用深度方向可分离的 CNN 架构实现该模型。

构建模型

第一步是将原始音频波形转换为 MFCC 特征，可以像这样在 TensorFlow 中完成。

如果输入音频和特征提取器有以下参数，

• 输入音频采样率:16000 赫兹
• 输入音频剪辑长度:1000 毫秒(长)
• 谱图窗口大小:40 毫秒(长)
• 谱图窗口步幅:20 毫秒
• MFCC 系数计数:10 (F)

那么张量self.mfcc_的 形状将为(None，T，F)，其中帧数:T = (L-l) / s +1 = (1000 - 40) / 20 + 1 = 49。self.mfcc_然后成为深度学习模型的fingerprint_input。

基于 MobileNet 的实现，我们采用了一个深度方向可分离的 CNN，完整的实现可以在我的 GitHub 上获得。

在最后使用一个全连接层之后的平均池来提供全局交互并减少最终层中的参数总数。

模型表现如何？

预先训练好的模型已经准备好供您使用，包括标准的 CNN、DS_CNN(深度方向可分离卷积)和各种其他模型架构。对于每个体系结构，将搜索各种超参数，如内核大小/步幅，并分别训练不同规模的模型，以便您可以权衡更小、更快的模型，以在精度稍低的资源受限设备上运行。

用深度方向可分离卷积构建的模型比具有相似运算次数的 DNN 模型获得了更好的精度，但是对内存的需求却降低了 10 倍。

注意，表中显示的所需内存是在将浮点权重量化为 8 位定点后的，我将在以后的帖子中解释这一点。

通过已训练的 DS_CNN 模型运行音频文件，并获得顶部预测，

结论和进一步阅读

在这篇文章中，我们探讨了如何实现一个简单而强大的关键字检测模型，该模型有可能在微控制器等资源受限的设备上运行。

一些你可能会觉得有用的相关资源。

1. TensorFlow 教程- 简单音频识别
2. GitHub 中的 TensorFlow 语音命令示例代码
3. 博客- 微控制器关键词识别
4. Keras 中的深度方向可分离卷积神经网络 可分离卷积 2D
5. Paper - 例外:深度可分卷积深度学习
6. 论文- MobileNets:用于移动视觉应用的高效卷积神经网络

在以后的帖子中，我将解释如何应用模型权重量化过程来减小模型大小，并向您展示如何在微控制器上运行模型。

查看我的 GitHub repo 和更多信息，包括培训和测试模型。

Share on Twitter Share on Facebook

• ←使用 TensorFlow Hub DELF 模块轻松识别地标图像
• 如何用 CMSIS-NN 在微控制器上运行深度学习模型(第一部分)→

利用 Keras 中的新闻数据进行简单的股票情绪分析

原文：https://www.dlology.com/blog/simple-stock-sentiment-analysis-with-news-data-in-keras/

发帖人:程维 4 年 7 个月前

(评论)

你想知道每天的新闻会对股票市场产生什么影响吗？在本教程中，我们将探索并构建一个模型，该模型从 Reddit 用户那里读取排名前 25 位的投票世界新闻，并预测道琼斯指数在某一天是上涨还是下跌。

读完这篇文章，你会了解到，

• 深度学习序列模型如何预处理文本数据？
• 如何使用预先训练的手套嵌入向量初始化 Keras 嵌入层。
• 建立一个 GRU 模型，可以处理单词序列，并能够考虑词序。

现在让我们开始，读到最后，因为将有一个秘密奖金。

文本数据预处理

对于输入文本，我们将把每天的所有 25 条新闻连接成一个长字符串。

之后，我们将把所有的句子转换成小写字母，去掉数字和标点这样的字符，因为这些字符不能用手套嵌入来表示。

下一步是将所有的训练句子转换成索引列表，然后用零填充所有这些列表，使它们的长度相同。

在决定最大序列长度之前，可视化所有输入样本的长度分布是有帮助的。

请记住，我们选择的最大长度越长，训练模型所需的时间就越长，因此，我们没有选择数据集中大约 700 的最长序列长度，而是选择 500 作为折衷，以覆盖所有样本的大部分文本，同时保持相对较短的训练时间。

嵌入层

在 Keras 中，嵌入矩阵被表示为“层”,并将正整数(对应于单词的索引)映射到固定大小的密集向量(嵌入向量)中。可以用预训练的嵌入来训练或初始化它。在这一部分，你将学习如何在 Keras 中创建一个嵌入层，用 GloVe 50 维向量初始化它。因为我们的训练集很小，所以我们不会更新单词 embeddings，而是将它们的值保持不变。我将向您展示 Keras 如何允许您设置嵌入是否可训练。

Embedding()层以一个大小为(批量大小，最大输入长度)的整数矩阵作为输入，这对应于转换成索引(整数)列表的句子，如下图所示。

下面的函数处理将句子字符串转换成索引数组的第一步。单词到索引的映射取自 GloVe 嵌入文件，因此我们可以在以后无缝地将索引转换为单词向量。

之后，我们可以像这样实现预训练的嵌入层。

• 将嵌入矩阵初始化为具有正确形状的 numpy 个零数组。(vocab_len，字向量的维度
• 用所有单词嵌入填充嵌入矩阵。
• 通过将 trainable 设置为假，定义 Keras 嵌入层并使其不可训练。
• 将嵌入层的权重设置为嵌入矩阵。

让我们通过询问单词“cat”的矢量表示来快速检查一下嵌入层。

结果是一个 50 维的数组。您可以进一步探索单词向量并使用余弦相似度来测量相似度，或者解决单词类比问题，例如男人对女人就像国王对 __。

构建和评估模型

该模型的任务是获取新闻字符串序列，并对道琼斯收盘值与前一收盘值相比是上涨还是下跌进行二元分类。如果值上升或保持不变，则输出“1”，如果值下降，则输出“0”。

我们正在构建一个简单的模型，在预训练的嵌入层之后包含两个堆叠的 GRU 层。密集层通过 softmax 激活生成最终输出。GRU 是一种处理和考虑序列顺序的递归网络，它在功能和性能方面类似于 LSTM，但训练起来计算成本更低。

接下来，我们可以训练评估模型。

生成 ROC 或我们的二元分类器来直观地评估其性能也是有帮助的。

我们的模型比市场趋势的随机猜测要好 2.8%左右。

关于 ROC 和 AUC 的更多信息，可以阅读我的另一篇博客- 关于如何为 Keras 分类器生成 ROC 图的简单指南。

结论和进一步的思考

在这篇文章中，我们介绍了一种快速简单的方法来建立一个 Keras 模型，嵌入层用预先训练的手套嵌入进行初始化。读完这篇文章后你可以尝试的东西，

• 使嵌入层权重可训练，从一开始就训练模型，然后比较结果。
• 增加最大序列长度，看看这会如何影响模型性能和训练时间。
• 纳入其他投入，以形成一个多投入 Keras 模型，因为其他因素可能与股票指数波动相关。比如有 MACD (均线收敛/发散振荡器)动量指标供你考虑。为了有多输入，你可以使用 Keras 功能 API 。

有什么改进模型的想法吗？评论并分享你的想法。

你可以在 my Github repo 中找到完整的源代码和训练数据。

投资者的红利

如果你像我几年前一样是整个投资界的新手，你可能想知道从哪里开始，最好是零佣金的免费投资。通过学习如何免费交易股票，你不仅可以省钱，而且你的投资可能会以更快的速度复利。最好的投资应用之一 Robinhood 就是这么做的，不管你是只买一股还是 100 股，都没有佣金。它是从零开始建造的，通过去除脂肪并把节省下来的钱交给顾客，尽可能地提高效率。加入 Robinhood，我们两个都会免费得到一只苹果，福特，或者 Sprint 这样的股票。确保你使用我的共享链接。

• 标签:
• 深度学习，
• keras ,
• 情感分析，
• 教程

Share on Twitter Share on Facebook

• ←如何训练 Keras 模型识别长度可变的文本
• 如何使用 Keras 进行无监督聚类→

[解决方案]py installer unicode decode 错误:“utf-8”编解码器无法解码字节

原文：https://www.dlology.com/blog/solution-pyinstaller-unicodedecodeerror-utf-8-codec-cant-decode-byte/

发布者:程维 5 年 3 个月前

(评论)

[解决方案]py installer unicode decode 错误:“utf-8”编解码器无法解码字节

问题描述

scipy 版本:0.19.1

操作系统:Windows

Python 3.5

pyInstaller 版本:3.2.1

要重现该问题，请创建一个 python 文件

scipy _ test . py

在同一个目录中运行命令

pyinstaller --onefile -c -a -y --clean **scipy_test.py** --debug > output.txt

它会产生这个错误

...
return exec_command(*cmdargs, **kwargs)
File "c:\users\hasee\appdata\local\programs\python\python35\lib\site-packages\PyInstaller\compat.py", line 356, in exec_command
out = out.decode(encoding)
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xce in position 151: invalid continuation byte

解决方案

在我的例子中，导航到 PyInstaller 目录

c:\ Users **hasee**\ AppData \ Local \ Programs \ Python \ Python 35 \ Lib \ site-packages \ py installer

首先移除 pycache 文件夹，它包含一些我们要修改的预编译 python 文件

将第 356 行python 35 \ lib \ site-packages \ py installer \ compat . py改成这个处理异常的。

运行 pyInstaller 命令，它应该工作了！

Share on Twitter Share on Facebook

• 利用酒店点评数据进行中文情感分析的简易指南→

教老狗新招——训练面部识别模型理解面部情绪

原文：https://www.dlology.com/blog/teach-old-dog-new-tricks-train-facial-identification-model-to-understand-facial-emotion/

发帖人:程维 4 年 11 个月前

(评论)

上周，我们探索了使用预先训练好的 VGG-Face2 模型通过面部识别一个人。因为我们知道模型被训练来识别 8631 个名人和运动员。

原始数据集足够大，则由预训练网络学习的空间特征层次可以有效地充当我们的面部识别任务的通用模型。尽管我们的新任务可能需要识别完全不同的人的面孔。

有两种方法来利用预训练的网络:特征提取和微调。

我们上周做的是一个 特征提取的例子，因为我们选择使用提取的一张脸的特征来计算到另一张脸的距离。如果距离小于阈值，则我们识别它们来自同一个人。

本周，我们将利用相同的预训练模型来识别面部表情，我们将对这 7 种情绪进行分类。

{0:'angry',1:'disgust',2:'fear',3:'happy', 4:'sad',5:'surprise',6:'neutral'}

你可以从 Kaggle 下载 fer2013 数据集。每张照片是 48x48 像素的人脸灰度图像。

首次尝试使用要素提取图层

我能想到的最简单的方法是把 CNN 特征提取层的输出叠加到一个分类器上。

分类器将是两个密集的完全连接的层，最后的密集层具有表示 7 种情绪的概率的输出形状 7。

我们冻结了 CNN 层的重量，使他们不可训练。因为我们想保留以前由卷积基学习的表示。

结果是这个模型不能很好地概括，并且总是预测一张“快乐”的脸。为什么“快乐”的脸，是模型更喜欢快乐的脸比其他脸像我们吗？不真的。

如果我们仔细看看 fer2013 训练数据集。模型要训练的开心脸比其他情绪多。所以如果模型只能挑一种情绪来预测，当然是挑笑脸。

但是为什么模特总是只选择一张脸呢？这一切都来自于训练前的模型。因为预先训练的模型被训练来识别一个人，而不管他/她穿着什么样的情绪。因此最终的特征提取层将包含抽象信息以告诉不同的人。这些抽象的信息包括一个人眼睛的大小和位置、肤色以及其他信息。但有一点可以肯定，预先训练好的模型并不关心这个人的情绪。

那么我们能做的是，我们还能利用预训练模型的权重为我们做点什么吗？

答案是肯定的，我们要对模型进行“微调”。

微调预训练模型

微调包括解冻用于特征提取的冻结模型库的几个顶层，并联合训练模型的新添加部分(在我们的情况下，全连接分类器)和这些顶层。这被称为“微调”,因为它稍微调整了被重用的模型的更抽象的表示，以便使它们与我们手头的任务更相关。

像预训练的 resnet50 face 模型这样的大型卷积网络有许多一个接一个的“Conv 块”堆栈。

下图显示了一个残差块示例。

图片来源:http://torch.ch/blog/2016/02/04/resnets.html

卷积基础中的早期层编码更通用、可重用的特征。在我们的例子中，第一个 conv 块可以提取边缘，一些图像模式，如曲线和简单的形状。对于不同的图像处理任务，这些都是非常通用的功能。再深入一点，conv 块可以提取一个人的眼睛和嘴巴，这是更抽象和不太通用的特征，用于不同的图像处理任务。

最后的 conv 块可以表示与预训练模型任务相关联的更抽象的信息，以识别人。记住这一点，让我们解冻它的权重，并在我们用面部情绪图像训练时更新它。

我们通过定位层来解冻模型权重。在我们的例子中，命名为“activation_46”的层如下所示。

准备和训练模型

我们得到的是 35887 48x48 像素的人脸灰度图像。并且我们的预训练模型期望 224x224 彩色输入图像。

将所有 35887 图像转换为 224x224 大小并存储到 RAM 将占用大量空间。我的解决方案是一次将一幅图像转换并存储到一个 TFRecord 文件中，稍后我们可以用 TensorFlow 轻松加载该文件。

使用 TFRecord 作为训练数据集格式，它的训练速度也更快。你可以看看我之前的实验。

下面是让对话发生的代码。

在上面的代码中，train_data[0]包含每个都具有形状(48，48)的面部图像阵列的列表，并且 train_data[1]是独热格式的实际情感标签的列表。

例如，一种情绪被编码为

[0, 0, 1, 0, 0, 0, 0]

指数 2 为 1，我们映射中的指数 2 是情绪“恐惧”。

为了用 TFRecord 数据集训练我们的 Keras 模型，我们首先需要用tf.keras.estimator.model_to_estimator方法将其转化为 TF 估计量。

我们已经在我之前的二进制分类任务中介绍了如何为 TF Estimator 编写图像输入函数。这里我们有 7 类情绪要分类。所以输入函数看起来有点不同。

下面的代码片段显示了主要的区别。

现在我们准备通过调用train_and_evaluate来训练和评估我们的模型。

总共花了 2 分钟，实现了 0.55 的验证精度。考虑到一张脸可能同时包含不同的情绪，这并不坏。比如既惊讶又开心。

总结与进一步思考

在这篇文章中，我们尝试了两种不同的方法来训练情绪分类任务的 VGG-Face2 模型。特征提取和微调。

特征提取方法不能概括面部情绪，因为原始模型被训练来识别不同的人而不是不同的情绪。

微调最后一个 conv 模块达到了预期的效果。

您可能想知道，如果我们微调更多的 conv 模块，会提高模型性能吗？

我们训练的参数越多，过度拟合的风险就越大。所以试图在我们的小数据集上训练它是有风险的。

源代码可以在我的 GitHub repo 上获得。

我也在考虑让这成为一个现场演示。敬请关注。

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←预训练 VGGFace2 模型的活体人脸识别
• 过拟合模型的两个简单配方→

在浏览器上运行的 10 大深度学习体验

原文：https://www.dlology.com/blog/top-10-deep-learning-experiences-run-on-your-browser/

发帖人:程维 5 年前

(评论)

今天没有编码教程。只是分享我最近发现的运行在浏览器上的 10 大深度学习体验。

享受旅程，不需要编码经验。

图像相关

1 快速绘制

一个游戏，你被要求画一个东西，比如一个甜甜圈，然后让神经网络猜你在画什么。我第一次尝试就答对了 6 个中的 4 个。让我们看看你能画得多好。

它是如何工作的

在引擎盖下，该模型将你在画布上绘制的笔画序列输入到卷积层和递归网络的组合中。最后，将从 softmax 输出图层中生成类别数字。

这是模型结构的示意图。

你可能想知道这些训练数据是从哪里来的。你猜对了！它收集了来自玩家的 345 个类别的 5000 万幅图画。

2 可示教机器

来自谷歌的另一个人工智能体验者建立在 deeplearn.js 库上。

教会机器识别你的手势并触发事件，无论是声音还是 gif。确保在足够多的样本和不同的角度上进行训练，否则，模型可能会发现很难概括你的手势。

3 石头剪刀布

这种基于 TensorFire 的体验使用 WebGL 在浏览器中运行神经网络，这意味着它是 GPU 加速的。它允许你通过网络摄像头与计算机实时竞争。

4 TensorFire 快速风格转换

TensorFilre 的另一个演示，GPU 加速风格转移。它拍下你的一张照片，然后把它变成一件令人惊叹的艺术品。

如果您熟悉 Keras 库，您可能已经见过它的样式转换演示，它在训练模型时计算两个损失“内容”和“样式”。生成一幅像样的图像需要很长时间。

虽然这个在你的浏览器上运行不到 10 秒钟，甚至可以播放视频。

5 东西翻译器

这个演示基于谷歌云视觉 API ，这意味着浏览器向谷歌服务器发送请求。亲切地喜欢当你使用谷歌图片搜索来搜索相似的图片。

6 RNN 基础笔迹生成

这个演示使用 LSTM 递归神经网络进行手写合成。源代码可用。

7 Pix2Pix

你画了一只猫，模型会为你生成照片，很可能是一只令人毛骨悚然的猫。

它是如何工作的

演示与运行 TensorFlow 模型的后端服务器对话，后端服务器自行运行或转发到由 Google 运行的 Cloud ML 托管的 TensorFlow 服务。

猫模型在 2k 猫照片上训练，并从猫照片自动生成边缘。所以是“边缘”到“照片”。该模型本身使用条件生成对抗网络(cGAN)。

如果您对实现细节感兴趣，请查看原始的论文，它展示了更多 cGAN 的示例用法，如“从地图到空中”、“从白天到夜晚”等。

文本相关

8 天火电子人作家

另一种浏览器内体验建立在硬件加速 TensorFire 库的基础上，让您自动完成句子，如泰勒斯威夫特、莎士比亚等。

原作者的目标不是让结果“更好”，而是让它“更怪异”。

该模型建立在rnn-writer之上，要了解更多，可以阅读作者的页面。

音乐相关

9 表演 RNN

欣赏在浏览器中创建的实时钢琴演奏。

这种模型用类似于 MIDI 本身的语言创作音乐，但使用音符开和音符关事件，而不是明确的时间长度。因此，该模型能够产生具有更自然的时序和动态的性能。

深度学习游乐场

10 TensorFlow 游乐场

在你的浏览器中修补神经网络。通过使用不同的学习率、激活函数等来调整模型。把模型想象成它的训练。

让我们先睹为快神经网络的大脑。

你准备好再体验一次了吗？

+1 鼓机 AI 实验

又一个谷歌人工智能实验。实验本身可能没有运行任何深度学习模型，这就是为什么它没有被计算在内。但是它太酷了，我忍不住把它放在这里。

它允许你用每天的声音像狗叫和婴儿啼哭来建造你的鼓机。使用 T-SNE 将数据可视化，这意味着相似的声音被分组在一起，使其非常容易挑选。

它是如何工作的

首先，将数千个日常声音音频文件收集到一个数组中，并从所有音频样本到音频精灵表创建一个大的 wave 文件。然后生成音频指纹，并把指纹变成 T-SNE 地图。

原来如此。你有什么很酷的深度学习经验想分享吗？请留下评论，让我们继续旅程。

• 标签:
• 深度学习

Share on Twitter Share on Facebook

• ←一个简单的技巧，通过批量标准化更快地训练 Keras 模型
• 如何教人工智能向在线卖家建议产品价格→

如何利用 Efficientnet 进行迁移学习

原文：https://www.dlology.com/blog/transfer-learning-with-efficientnet/

发帖人:程维三年零六个月前

(评论)

在本教程中，您将学习如何创建图像分类神经网络来对您的自定义图像进行分类。该网络将基于最新的 EfficientNet，它在 ImageNet 上实现了最先进的精确度，同时比 小8.4 倍，比 快 6.1 倍。

为什么选择 EfficientNet？

与达到类似 ImageNet 精度的其他型号相比，EfficientNet 要小得多。例如，您可以在 Keras 应用程序中看到的 ResNet50 型号总共有 23，534，592 个参数，尽管如此，它的性能仍然低于最小的 EfficientNet，后者总共只使用了 5，330，564 个参数。

为什么这么高效？为了回答这个问题，我们将深入研究它的基本模型和构建模块。您可能听说过经典 ResNet 模型的构造块是恒等式和卷积块。

对于 EfficientNet 来说，它的主要积木是移动倒瓶颈 MBConv，最早是在 MobileNetV2 推出的。通过在瓶颈之间直接使用快捷方式，其与扩展层相比连接更少数量的通道，结合d****ee可分离卷积，其与传统层相比有效地将计算减少了几乎一个因子 k²。其中 k 代表内核大小，指定 2D 卷积窗口的高度和宽度。

作者还增加了压缩和激励 (SE)优化，这有助于进一步性能的提高。 efficient net 的第二个优势是，它通过仔细平衡网络深度、宽度和分辨率来提高扩展效率，从而带来更好的性能。

如您所见，从最小的有效网络配置 B0 到最大的 B7，精度稳步提高，同时保持相对较小的尺寸。

用 EfficientNet 转移学习

如果你不完全确定我在上一节所讲的内容，没关系。用于图像分类的迁移学习或多或少是模型不可知的。如果你愿意，你可以选择任何其他预先训练的 ImageNet 模型，如 MobileNetV2 或 ResNet50 作为的替代。

预先训练的网络只是先前在大型数据集(如 ImageNet)上训练的保存的网络。学习到的特征可以证明对许多不同的计算机视觉问题是有用的，即使这些新问题可能涉及与原始任务完全不同的类别。例如，一个人可以在 ImageNet 上训练一个网络(其中的类主要是动物和日常物品)，然后重新利用这个训练好的网络做一些像识别图像中的汽车型号这样的远程工作。对于本教程，我们希望该模型能够在样本数量相对较少的情况下，很好地解决猫和狗的分类问题。

最简单的开始方式是在 Colab 中打开这个笔记本,我会在这篇文章中解释更多细节。

首先克隆我的存储库，它包含 EfficientNet 的 Tensorflow Keras 实现，然后将 cd 放入目录。

EfficientNet 是为 ImageNet 分类构建的，包含 1000 个类别标签。对于我们的数据集，我们只有 2 个。这意味着分类的最后几层对我们没有用。通过将include_top参数指定为 False，可以在加载模型时排除它们，这也适用于在 Keras 应用中可用的其他 ImageNet 模型。

在 EfficientNet 卷积基础模型之上创建我们自己的分类层堆栈。我们采用GlobalMaxPooling2D将 4D 的 (batch_size, rows, cols, channels)张量转换成形状为(batch_size, channels)的 2D 张量。与Flatten层相比，GlobalMaxPooling2D产生数量少得多的特征，这有效地减少了参数的数量。

为了保持卷积基的权重不变，我们将冻结它，否则，先前从 ImageNet 数据集学习的表示将被破坏。

然后你可以从微软下载并解压dog_vs_cat数据。

笔记本中有几个数据块，专用于从原始数据集中抽取图像子集，以形成训练/验证/测试集，之后您将看到。

然后你可以用 Keras 的ImageDataGenerator对模型进行编译和训练，它在训练过程中增加了各种数据增广选项，以减少过拟合的机会。

另一种使模型表示与当前问题更相关的技术叫做微调。那是基于下面的直觉。

卷积基础中的早期层编码更通用、可重用的特征，而较高层编码更专业的特征。

微调网络的步骤如下:

• 1)在已经训练好的基础网络上添加您的自定义网络。
• 2)冻结基础网络。
• 3)训练你加的部分。
• 4)解冻基础网络中的一些层。
• 5)联合训练这些层和你添加的部分。

我们已经完成了前三个步骤，为了找出要解冻的图层，绘制 Keras 模型很有帮助。

这是卷积基础模型中最后几层的放大视图。

设置“multiply_16”和可训练的连续层。

然后，您可以为更多的时期再次编译和训练模型。最后，您将拥有一个经过微调的模型，验证准确性提高了 9%。

结论和进一步阅读

这篇文章首先简要介绍了 EfficientNet，以及为什么它比传统的 ResNet 模型更有效。Colab Notebook 上的 runnable 示例向您展示了如何构建一个模型来重用 EfficientNet 的卷积库，并对自定义数据集的最后几层进行微调。

完整的源代码可以在我的 GitHub repo 上找到。

你可能会发现以下资源很有帮助。

EfficientNet:反思卷积神经网络的模型缩放

MobileNetV2:反向残差和线性瓶颈

挤压和激励网络

TensorFlow 实现 EfficientNet

• 标签:
• 深度学习，
• keras ,
• 教程

Share on Twitter Share on Facebook

• ←如何用 TensorFlow 模型优化将你的 Keras 模型 x5 压缩得更小
• 如何用 mmdetection 训练物体检测模型→

如何使用深度学习来诊断电机的健康状况

原文：https://www.dlology.com/blog/try-this-model-to-quickly-tell-if-it-is-a-faulty-motor-by-listening/

发帖人:程维四年零九个月前

(评论)

TL；博士

我们正在构建一个 TensorFlow 模型，以获取电机上的音频记录输入，并预测它是否“健康”。

我们为什么要这么做？

想象一下，在一个类似仓库配送中心的生产环境中，有数百台交流电机日夜驱动传送带和分拣机。比方说，一个关键节点的一台电机发生故障，可能会导致整条生产线停工。一个有经验的维护工程师可以通过听声音来识别故障电机，并在为时已晚之前采取措施予以纠正。

在这个演示中，我们将训练我们的模型成为专家。它可以通过听声音来判断电机是否有故障。

关于 WAV 文件

训练数据包含在 2 个位置的 3 种类型的电机上记录的 6 个 WAV 文件。

在实验室环境中用夹在两块磁铁之间的接触压电圆盘麦克风进行记录。然后将磁铁安装到交流电机的外壳上。

你可能会奇怪为什么我们不用普通的非接触式麦克风呢？

如果你参观过大型配送中心的车间。你可能会看到有许多电机/致动器因各种原因而运行，有些在移动盒子，有些在盒子上贴标签，有些在打包/拆包。这意味着这是一个非常嘈杂的环境。

使用由压电盘制成的接触式麦克风，确保记录的大部分音频信号是由我们连接的马达产生的。类似于医生将听诊器放在你的胸部。

• 电机类型:Baldor SuperE VEUHM3558T 单元搬运电机
• 驱动器类型:VFD
• VFD 频率:60HZ
• 信号采样率:22050 赫兹
• 信号采样时间:每个 10 秒

我们放置麦克风的位置

• de:电机驱动端(驱动轴连接到从动装置的一端)
• re:电机后端(通常是冷却风扇所在的位置)

这里有一个图像来说明这个想法。

要分类的电机类型

出于演示目的，让我们将任务简化为将一台电机归类为这三种类型之一。

• 新的:新的发动机，状况良好。
• 用过的:一个电机已经用了一段时间，但还能用。
• 红色:从生产线上捡出的已识别的不良电机。

例如 用过 _ 60Hz _ re _ 10s _ 22k Hz . wav的意思是，

• 旧发动机
• VFD 频率为 60Hz
• 麦克风，连接到马达外壳的后端
• 录制 10 秒钟
• 采样速率为 22 千赫

让我们把任务分成以下几个部分，随意跳到你最感兴趣的部分。

• 准备数据
• 构建模型
• 训练模型
• 用新的 WAV 文件预测电机类型

准备数据

读取 WAV 文件

我们用 module librosa.load() 函数读取数据，该函数带一个参数 WAV 文件路径，返回一个元组，第一个元素是一个 numpy 数组的音频时间序列，第二个元素是采样率。

规范化数据集

将音频时间序列归一化为 0 左右，标准差为 1。这有助于我们的模型以后学习得更快。

分割数据集

分割音频时间序列。

我们的模型将使用 LSTM 递归层，它期望固定长度的序列作为输入数据。E 每个生成的序列包含 100 个时间步的录音。

构建模型

该图说明了模型的结构。

LSTM 层读取输入序列，最后使用全连接层+ softmax 进行预测。

LSTM 层是一种处理音频时间序列数据的递归网络层。

我发现下面这篇文章非常有用，可以让更好地了解 LSTM 是如何运作的。

了解 LSTM人脉- 科拉的博客

训练模型

训练 30 个周期，最终训练精度达到 0.9843，测试精度达到 0.9839

让我们看看结果的混淆矩阵。它描述了经过训练的分类器的性能。

用新的 WAV 文件预测电机类型

在我们预测我们的新记录之前，我们需要将训练好的模型保存到文件中，所以下次我们只需要简单地加载它。

下面是将我们训练好的模型“冻结”到一个文件中的代码

这里是加载“冻结”模型的副本，因此我们可以使用它来做一些预测。

之后，我们将访问加载的图的输入和输出节点。

我们的新记录也将是一个 WAV 文件，所以让我们用函数将它转换成我们的模型输入数据。

让我们也有一个助手函数，这样我们可以很容易地调用来做预测

咻，代码真多。让我们用我们的新 WAV 文件来测试一下，这是另一个“新”马达的录音。

predicted, prob = predict_recording(sound_file_full_path)
print("Recording \"{}\" is predicted to be a \"{}\" motor with probability {}".format(sound_file_full_path, predicted, prob))

它以概率 0.8227 正确地预测该 WAV 文件是“新”马达的记录，

Sampling rate for file "test_new_60Hz.wav" is: 22050Hz
Recording "./data/test_new_60Hz.wav" is predicted to be a "new" motor with probability 0.8227010881160657

摘要

我们使用 Tensorflow 建立了一个在 3 种不同类型的电机上记录的 6 个 WAV 文件上训练的模型。该模型可以将新的音频记录分类到正确的电机类型。

数据集非常小，可能只适用于运行在 60Hz 上的这一个电机型号。为了克服这一限制，可以将更多具有各种电机型号以及不同 VFD 频率的数据添加到训练数据集中。

查看我的 GitHub 获取源代码。如果您有任何问题或疑虑，请留下您的评论。

Share on Twitter Share on Facebook

• ←如何使用 Keras 进行实时触发词检测
• YOLO 物体定位如何与 Keras 协同工作的简明指南(第一部分)→

利用酒店评论数据进行中文情感分析的简易指南

原文：https://www.dlology.com/blog/tutorial-chinese-sentiment-analysis-with-hotel-review-data/

发布者:程维 5 年 3 个月前

(评论)

本教程使用的源代码和数据集，请查看我的githubrepo。

依赖性

Python 3.5、numpy、pickle、keras、tensorlow、【jiba】

关于日期

客户酒店评论，包括

2916 条正面评价和 3000 条负面评价

绘图可选

皮拉布， scipy

与英文数据集相比的关键差异

文件编码

有些数据文件包含编码 GB2312 会报错的异常编码字符。解决方案:按字节读取，然后逐行解码为 GB2312，跳过编码异常的行。我们还将任何繁体中文字符转换为简体中文字符。

从繁体中文转换为简体中文(繁体转简体)

从下载这两个文件

朗康夫。py

zh_wiki 。py

下面这两行将把字符串" line" 从繁体中文转换成简体中文。

记号

使用 街霸 对中文句子进行标记，然后加入标记列表，用空格分隔。

然后我们将字符串输入 Keras Tokenizer，Keras Tokenizer】期望每个句子都有单词记号用空格分隔。

中文停用词

首先从文件 中获取停用词列表 ，然后对照该列表检查每个分词后的中文词

结果

Keras 训练 20 个纪元，用 GPU (GTX 1070)耗时 7 分 14 秒

升息:0.9726

尝试一些新的评论

对于 Python Jupyter 笔记本源代码和数据集，查看我的 github repo 。

对于一个更新的单词级英语模型，看看我的另一个博客: 简单的股票情绪分析与 Keras 的新闻数据。

• 标签:
• 情感分析

Share on Twitter Share on Facebook

• ↓【解决方案】Pyinstaller UnicodeDecodeError 错误:“utf-8”编解码器无法解码字节
• 如何使用 Keras 对患者查询进行分类(1 分钟培训)→

如何使用 Keras 对患者问题进行分类(1 分钟培训)

原文：https://www.dlology.com/blog/tutorial-medical-triage-with-patient-query/

发布者:程维 5 年 2 个月前

(评论)

在本教程中，我们将构建一个基于患者查询文本数据的分诊模型。

例如

| 查询(输入) | 分流(输出) |
| 皮肤很痒。 | 皮肤病学 |
| 喉咙痛发烧疲劳。 | 嘴脸 |
| 后腰疼，好疼。 | 背部 |

我们将使用 Keras 和 Tensorflow(版本 1.3.0)后端来构建模型

对于本教程中使用的源代码和数据集，请查看我的 GitHub repo 。

依赖性

Python 3.5, numpy, pickle, keras, tensorflow, nltk, pandas

关于日期

1261 个患者查询，phrases _ embed . CSV来自 巴比伦博客《聊天机器人如何理解句子》。

查看数据可视化 这里。

准备数据

我们将执行以下步骤来准备用于训练模型的数据。

1.从 CSV 文件读取数据到 Pandas 数据框，只保留 2 列“疾病”和“类别”

2.将 Pandas 数据帧转换为 numpy 数组对

"疾病"栏== >文档

" class" columns ==> body_positions

3.清理数据

对于每个句子，我们将所有字母转换为小写，只保留英文字母和数字，删除停用词，如下所示。

4.Input tokenizer 将输入单词转换为 id，如果输入序列较短，则将每个输入序列填充到最大输入长度。

保存输入标记器，因为我们需要在预测过程中使用同一个标记器来标记任何新的输入数据。

5.将输出单词转换为 id，然后转换为类别(一键向量)

7.maketarget _ reverse _ word _ index将谓词类 id 转换为文本。

建立模型

模型结构将如下所示

_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
embedding_1 (Embedding)      (None, 18, 256)           232960    
_________________________________________________________________
gru_1 (GRU)                  (None, 18, 256)           393984    
_________________________________________________________________
gru_2 (GRU)                  (None, 256)               393984    
_________________________________________________________________
dense_1 (Dense)              (None, 19)                4883      
=================================================================

嵌入层将单词 id 转换成它们对应的单词嵌入，来自嵌入层的每个输出将具有(18×256)的大小，这是最大输入序列填充长度乘以嵌入维度。

数据被传递到一个递归层来处理输入序列，我们在这里使用 GRU ，你也可以试试 LSTM。

所有的中间输出被收集，然后传递到第二 GRU 层。

然后输出被发送到一个完全连接的层，这将给出我们最终的预测类别。我们使用“soft max”activation来给出每个职业的概率。

使用标准的‘分类 _ 交叉熵’损失函数进行多类分类。

使用 " 亚当 " 优化器，因为它适应学习率。

然后，我们将训练该模型，并保存它以供以后预测。

预测新数据

1.加载我们之前保存的模型。

2.加载输入标记器，标记新的患者查询文本，将序列填充到最大长度

3.将序列输入模型，模型将输出类别 id 和概率，我们使用“target_reverse_word_index”将类别 id 转换为实际的分类结果文本。

以下是一些预测结果

摘要

Keras 训练 40 个纪元，用 GPU (GTX 1070)不到 1 分钟最终 acc:0.9146

训练数据的大小相对较小，拥有较大的数据集可能会提高最终的准确性。

查看我的 GitHub repo 获取 Jupyter 笔记本源代码和数据集。

Share on Twitter Share on Facebook

• ←利用酒店点评数据进行中文情感分析的简易指南
• 如何用 Tensorflow 总结亚马逊评论→

如何用 Tensorflow 总结亚马逊评论

原文：https://www.dlology.com/blog/tutorial-summarizing-text-with-amazon-reviews/

发布者:程维 5 年 2 个月前

(评论)

这个项目的目标是建立一个模型，可以为亚马逊上销售的美食评论创建相关的摘要。该数据集包含超过 50 万条评论，托管在 Kaggle 上。

这里有两个例子来展示数据的样子

Review # 1
Good Quality Dog Food
I have bought several of the Vitality canned dog food products and have found them all to be of good quality. The product looks more like a stew than a processed meat and it smells better. My Labrador is finicky and she appreciates this product better than  most.

Review # 2
Not as Advertised
Product arrived labeled as Jumbo Salted Peanuts...the peanuts were actually small sized unsalted. Not sure if this was an error or if the vendor intended to represent the product as "Jumbo".

为了构建我们的模型，我们将使用两层双向 RNN，对输入数据使用 LSTM，对目标数据使用 LSTM。

本工程的标段有:
1。检查数据
2。准备数据
3。建立模型
4。训练模型
5。做我们自己的总结

受带有亚马逊评论的 post 文本摘要的启发，通过一些改进和更新来与最新的 TensorFlow 版本 1.3 配合使用，这些改进获得了更好的准确性。

改进摘要

1.更好地修饰句子

原始代码通过 text.split() 对单词进行标记，这不是万无一失的，

例如单词后跟标点符号“你在开玩笑吗？我觉得你是。”会被错误地标记为

【‘是’，‘你’，‘开玩笑？“我”、“想”、“你”、“是”]

我们用这条线代替

这将正确地生成单词列表

['是'，'你'，'开玩笑'，'我'，'想'，'你'，'是']

2.增加数据 p 修复 f 过滤和分类速度

最初的作者使用了两个 for 循环来排序和过滤数据，这里我们使用 Python 内置的排序和过滤函数来做同样的事情，但是速度更快。

过滤 为长度限制， <UNK>为数量限制

排序 摘要和文本按 文本 中元素的长度从最短到最长排序

3。连接编码器中的 RNN 层

原始代码缺少下面这一行，这就是我们如何通过将当前层的输出馈送到下一层的输入来连接层。因此，原始代码仅表现为编码器中的单个双向 RNN 层。

4.解码层使用 MultiRNNCell

原作者使用 for 循环将 num_layers 的 LSTMCell 连接在一起，这里我们使用由多个简单单元格( BasicLSTMCell )顺序组成的 MultiRNNCell 到来简化代码。

培训结果

经过 2 个小时的 GPU 训练，亏损降到 1 以下，固定在 0.707。

下面是用训练好的模型生成的一些摘要。

- Review:
 The coffee tasted great and was at such a good price! I highly recommend this to everyone!
- Summary:
 great great coffee

- Review:
 love individual oatmeal cups found years ago sam quit selling sound big lots quit selling found target expensive buy individually trilled get entire case time go anywhere need water microwave spoon know quaker flavor packets
- Summary:
 great taste

在我的 GitHub 上查看完整的源代码。

Share on Twitter Share on Facebook

• ←如何使用 Keras 对患者查询进行分类(1 分钟培训)
• 改进马达声学分类器的一个简单技巧→

过拟合模型的两个简单方法

原文：https://www.dlology.com/blog/two-simple-recipes-for-over-fitted-model/

发帖人:程维 4 年 11 个月前

(评论)

过度拟合可能是一个严重的问题，特别是对于小的训练数据集。该模型可能会达到很高的训练精度，但当它带着从未见过的新数据进入现实世界时，它不能很好地概括新的示例。

第一个也是最直观的解决方案肯定是使用更大、更全面的数据集来训练模型，或者对现有数据集应用数据扩充，尤其是对于图像。但是如果我们只有这些数据呢？

在这篇文章中，我们将探索两种简单的技术来处理这个问题，在深度学习模型中使用正则化。

假设你刚刚被法国足球公司聘为人工智能专家。他们想让你推荐法国队守门员应该踢球的位置，这样法国队的球员就可以用头踢球了。

图片来源:Coursera -改进深度神经网络

下面是法国队过去 10 场比赛的 2D 数据。

你的目标是建立一个深度学习模型，找到场上守门员应该踢球的位置。

这个数据集有点嘈杂，但看起来像是一条对角线，将左上方(蓝色)和右下方(红色)分开，效果会很好。

让我们建立一个简单的 Keras 模型，有 3 个隐藏层。

让我们用 1000 个时期的训练和测试数据集来训练和验证我们的模型。

它实现了如下所示的最终训练和验证准确性。看起来模型在训练期间比验证期间表现得更好。

train acc:0.967, val acc: 0.930

让我们绘制训练/验证准确性和损失图。

正如我们可以看到的，在大约 600 个纪元后，验证损失停止下降，反而开始增加。模型开始过度适应训练数据集是正常的迹象。

为了清楚地了解最终训练好的模型“思考”的是什么，让我们画出它的决策边界。

如图所示，边界不清晰，模型过于努力地去拟合那些异常样本。对于深度神经网络来说，这可能变得非常明显，因为它能够学习数据点之间的完整关系，但与此同时，如果我们只用一个小数据集来训练它，它会过度拟合那些有噪声的离群值。

配方一——L2 正规化

避免过度拟合的标准方法称为【L2 正则化】 。它包括对层权重应用惩罚。然后将惩罚应用于损失函数。

因此，最终正则化的损失函数将包含交叉熵成本以及 L2 正则化成本。

例如，我们可以将层“2”的 L2 正则化成本计算为

np.sum(np.square(W2))

其中“W2”是密集层“2”的权重矩阵。我们必须对 W2、W3 这样做，然后将它们相加并乘以正则化因子，正则化因子控制正则化的强度。

在 Keras 中，很容易将 L2 正则化应用于核权重。

我们为我们的 Keras 模型选择了因子 0.003，最终达到了的训练和验证精度

train acc:0.943, val acc: 0.940

请注意，最终验证精度非常接近训练精度，这是一个好迹象，表明旅游模型不太可能过度拟合训练数据。

与之前没有正则化的模型相比，决策边界也相当清晰。

食谱二-辍学

Dropout 是深度学习中普遍使用的正则化技术。它在每次迭代中随机关闭一些神经元。

任何神经元被关闭的概率由退出率参数控制。放弃的想法是，在每次迭代中，模型只使用神经元的子集，因此，模型对任何特定神经元变得不太敏感。

有一点要记住。我们只在训练时应用 dropout，因为我们希望使用之前学习的所有神经元的权重进行测试或推理。别担心，当我们调用fit() evaluate() 或 predict() 时，这在 Keras 中是自动处理的。

但是我们如何选择辍学率参数呢？

简短回答:如果你不确定，0.5 是一个很好的起点，因为它提供了最大的正则化量。

逐层使用不同的退出率也是可行的。如果前一层具有较大的权重矩阵，我们可以对其应用较大的丢弃。在我们的示例中，我们在 dense_3 层之后应用更大的下降，因为它具有最大的权重矩阵 40x40。我们可以在 dense_2 层之后应用更小的丢失，比如丢失率 0.4，，因为它具有更小的权重矩阵 20x40。

让我们来看看将辍学应用到我们的模型后的结果。

决赛

train acc:0.938, val acc: 0.935

决定也相当顺利。

摘要

我们探索了两种简单的正则化方法来解决深度学习模型在用小数据集训练时遭受过拟合问题。正则化将使权重降低。L2 正则化和丢失是两种有效的正则化技术。在 my GitHub repo 中查看这篇文章的完整源代码。尽情享受吧！

• 标签:
• keras ,
• 深度学习，
• 教程

Share on Twitter Share on Facebook

• ←教老狗新招——训练面部识别模型理解面部情绪
• 如何在 Keras 中选择优化器的快速说明→