精通-TensorFlow-2-x-计算机视觉-全-
精通 TensorFlow 2.x 计算机视觉(全)
零、前言
计算机视觉是一种技术,机器可以通过这种技术获得人类级别的能力来可视化,处理和分析图像或视频。 本书将重点介绍如何使用 TensorFlow 开发和训练深度神经网络,以解决高级计算机视觉问题并将解决方案部署在移动和边缘设备上。
您将以计算机视觉和深度学习的关键原理开始,并了解各种模型和架构以及它们的优缺点。 您将涵盖各种架构,例如 VGG,ResNet,Inception,R-CNN,YOLO 等。 您将使用迁移学习来使用各种视觉搜索方法。 这本书将帮助您学习计算机视觉的各种高级概念,包括语义分割,图像修复,对象跟踪,视频分割和动作识别。 您将探索如何将各种机器学习和深度学习概念应用于计算机视觉任务,例如边缘检测和面部识别。 在本书的后面,您将重点关注表现优化以优化表现,部署动态模型以提高处理能力,以及扩展以应对各种计算机视觉挑战。
到本书结尾,您将对计算机视觉有深入的了解,并且将知道如何开发模型以自动执行任务。
这本书是给谁的
本书适用于计算机视觉专业人员,图像处理专业人员,机器学习工程师和 AI 开发人员,他们对机器学习和深度学习有一定的了解,并希望构建专家级的计算机视觉应用。 本书要求熟悉 Python 编程和 TensorFlow。
本书涵盖的内容
“第 1 章”,“计算机视觉和 TensorFlow 基础知识”讨论了计算机视觉和 TensorFlow 的基本概念,以为您为本书的后续更高级章节做准备。 我们将研究如何执行图像哈希和过滤。 然后,我们将学习特征提取和图像检索的各种方法。 接下来,我们将学习基于轮廓的对象检测,定向梯度的直方图以及各种特征匹配方法。 然后,我们将概述高级 TensorFlow 软件及其不同的组件和子系统。 本章提供了许多用于对象检测,图像过滤和特征匹配的动手编码练习。
“第 2 章”,“使用局部二进制模式的内容识别”讨论了局部二进制特征描述符和直方图,用于对带纹理的图像和非带纹理的图像进行分类。 您将学习调整本地二进制模式(LBP)参数,并计算 LBP 之间的直方图差异以匹配图像之间的相同模式。 本章提供了两个编码练习–一个用于匹配地板图案,另一个用于将面部颜色与基础色匹配。
“第 3 章”,“使用 OpenCV 和 CNN 进行面部检测”从 Viola-Jones 面部和关键特征检测开始,并继续介绍基于神经网络的面部关键点检测和面部表情识别的高级概念。 本章将以 3D 人脸检测的高级概念作为结尾。 本章提供了两种编码练习,一种用于网络摄像头中基于 OpenCV 的面部检测,另一种是基于 CNN 的端到端管线用于面部关键点检测。 端到端神经网络管道包括以下方面的面部图像收集:从网络摄像头裁剪面部图像,标注面部图像中的关键点,将数据摄取到 CNN 中,建立 CNN 模型,训练并最终针对面部图像评估经过训练的关键点模型 。
“第 4 章”,“图像深度学习”深入研究了如何使用边缘检测在整个体积上创建卷积运算,以及不同的卷积参数(例如过滤器大小,尺寸和运算类型)如何影响卷积。 本章将为您提供有关神经网络如何查看图像以及图像如何使用可视化对图像进行分类的非常详细的概述。 本章提供基于 TensorFlow Keras 的编码练习,以构建神经网络并在图像通过其不同层时对其进行可视化显示。 然后,您将网络模型的准确率和可视化与诸如 VGG 16 或 Inception 之类的高级网络进行比较。
“第 5 章”,“神经网络架构和模型”探索了不同的神经网络架构和模型。 通过更改卷积,池化,激活,全连接和 softmax 层的参数,您将了解如何将第一章和第四章中学到的概念应用于各种场景。 希望通过这些练习,您将了解一系列神经网络模型,从而为您成为计算机视觉工程师奠定坚实的基础。
“第 6 章”,“使用迁移学习的视觉搜索”是您要使用 TensorFlow 将数据输入模型并为现实情况开发视觉搜索方法的地方。 您将学习如何使用 Keras 数据生成器和 TensorFlow tf.data API 将图像及其类别输入到 TensorFlow 模型中,然后剪切一部分预训练的模型并在最后添加自己的模型内容来开发您自己的分类器。 这些练习背后的想法是学习如何在 TensorFlow 中为您在第四章和第五章中学到的神经网络模型进行编码。
“第 7 章”,“使用 YOLO 进行对象检测”,介绍了两种单阶段快速对象检测方法-只看一次(YOLO) 和 RetinaNet。 在本章中,您将学习不同的 YOLO 模型,了解如何更改其配置参数并进行推论。 您还将学习如何使用 Darknet 处理自己的图像,以训练自定义 YOLO v3 模型。
“第 8 章”,“语义分割和神经样式迁移”讨论了如何使用深度神经网络将图像分割为空间区域,从而生成人工图像并将样式从一个图像迁移到另一个。 我们将使用 TensorFlow DeepLab 进行动手进行语义分割,并在 Google Colab 中编写 TensorFlow 代码以进行神经样式迁移。 我们还将使用 DCGAN 生成人工图像,并使用 OpenCV 进行图像修复。
“第 9 章”,“使用多任务深度学习的动作识别”解释了如何开发多任务神经网络模型来识别动作,例如手,嘴,头或腿的动作 ,以使用基于视觉的系统检测动作的类型。 然后,将使用手机加速度计数据通过深度神经网络模型对它进行补充,以验证操作。
“第 10 章”,“使用 R-CNN,SSD 和 R-FCN”进行对象检测,标志着端对端(E2E)对象检测框架的开始,方法是为数据摄取和训练流水线建立坚实的基础,然后进行模型开发。 在这里,您将深入了解各种对象检测模型,例如 R-CNN ,单发检测器(SSD), 基于区域的全卷积网络(R-FCN)和遮罩 R-CNN ,并使用 Google Cloud 和 Google Colab 笔记本执行动手练习。 我们还将针对如何训练自己的自定义图像以使用 TensorFlow 对象检测 API 开发对象检测模型进行详细的练习。 我们将在本章结束时对各种对象跟踪方法进行深入概述,并使用 Google Colab 笔记本进行动手练习。
“第 11 章”,“通过 CPU/GPU 优化在边缘设备上进行深度学习”,讨论如何采用生成的模型并将其部署在边缘设备和生产系统上。 这将导致完整的端到端 TensorFlow 对象检测模型实现。 特别是,使用 TensorFlow Lite 和 Intel 开放视觉推理和神经网络优化(VINO)架构,并部署到 Raspberry Pi,Android 和 iPhone。 尽管本章主要关注 Raspberry Pi,Android 和 iPhone 上的对象检测,但是所讨论的方法可以扩展到图像分类,样式迁移和所考虑的任何边缘设备的动作识别。
“第 12 章”,“计算机视觉云计算平台”讨论了如何在 Google Cloud Platform(GCP), Amazon Web Services(AWS)和 Microsoft Azure 云平台。 您将学习如何准备数据,将数据上传到云数据存储并开始监视训练。 您还将学习如何将图像或图像向量发送到云平台进行分析并获得 JSON 响应。 本章讨论单个应用以及如何在计算引擎上运行分布式 TensorFlow。 训练结束后,本章将讨论如何评估模型并将其集成到应用中以进行大规模操作。
充分利用这本书
如果您是计算机视觉和 TensorFlow 的初学者,并且您想精通该主题,那么最好按顺序阅读本书的各个章节,而不是四处浏览。 本书以计算机视觉和神经网络的概念为基础,然后以代码示例结尾。 确保对所介绍的概念和架构有很好的了解,然后再应用代码示例。
由于大小限制,我们无法将图像数据上传到 GitHub。 您可以使用自己的相机中的图像,也可以从 Kaggle 下载图像数据集:
- 食物图像(用于汉堡和薯条样本):使用手机相机拍摄照片。
- Kaggle 家具检测器
如果您一开始不了解某个概念,请重新访问它,并阅读所有引用的论文。
大多数代码是在 Jupyter 笔记本环境中编写的,因此请确保已下载 Anaconda。 您还需要下载 TensorFlow 2.0 –为此,请按照“第 1 章”,“计算机视觉和 TensorFlow 基础知识”中的说明进行操作。
使用 Google Colab 进行了许多对象检测训练– “第 10 章”,“使用 R-CNN,SSD 和 R-FCN”进行对象检测,以及“第 11 章”“具有 CPU/GPU 优化功能的边缘深度学习”提供了有关如何使用 Google Colab 的说明。
如果您要将计算机视觉代码部署到边缘设备,并且正在考虑购买什么,请访问“第 11 章”,“具有 CPU/GPU 优化功能的边缘设备深度学习”, 各种设备的详细分析。
该书在很大程度上依赖于终端的用法-在阅读“第 7 章”,“使用 YOLO 进行对象检测”之前,请确保您已经对此有了基本的了解。
“第 12 章”,“计算机视觉云计算平台”处理云计算,因此您必须为此拥有 Amazon Web Services,Azure 或 Google Cloud Platform 帐户。 如果您不跟踪自己的时间,云计算可能会变得昂贵。 许多提供商会在一段时间内让您免费使用服务,但是在那之后,即使您的项目仍未开放,即使您没有接受训练,费用也会增加。 请记住,在结束帐户以停止产生费用之前,请先关闭您的项目。 如果您对云计算有技术问题并且感到困惑,则可以阅读相关云计算平台的文档。 另外,您可以付费打开技术工作票; 通常会在 1-2 个工作日内解决这些问题。
充分利用本书的最佳方法是阅读理论,了解为什么要以这种方式开发模型,尝试样例练习,然后更新代码以适合您的需求。
如果您对本书的任何部分有任何疑问并陷入困境,可以随时通过 LinkedIn 与我联系。
下载示例代码文件
您可以从 www.packt.com 的帐户中下载本书的示例代码文件。 如果您在其他地方购买了此书,则可以访问 www.packt.com/support 并注册以将文件直接通过电子邮件发送给您。
您可以按照以下步骤下载代码文件:
- 登录或注册 www.packt.com 。
- 选择“支持”选项卡。
- 单击“代码下载和勘误”。
- 在搜索框中输入书籍的名称,然后按照屏幕上的说明进行操作。
下载文件后,请确保使用以下最新版本解压缩或解压缩文件夹:
- Windows 的 WinRAR/7-Zip
- Mac 版 Zipeg/iZip/UnRarX
- 适用于 Linux 的 7-Zip/PeaZip
本书的代码包也托管在 GitHub 上。 如果代码有更新,它将在现有的 GitHub 存储库中进行更新。
我们还从这里提供了丰富的书籍和视频目录中的其他代码包。 去看一下!
下载彩色图像
我们还提供了 PDF 文件,其中包含本书中使用的屏幕截图/图表的彩色图像。 您可以在此处下载。
使用约定
本书中使用了许多文本约定。
CodeInText:指示文本,数据库表名称,文件夹名称,文件名,文件扩展名,路径名,虚拟 URL,用户输入和 Twitter 句柄中的代码字。 这是一个示例:“使用OpenCV BGR2GRAY命令将每个读取的图像转换为灰度”。
代码块设置如下:
faceresize = cv2.resize(detected_face, (img_size,img_size))
img_name = "dataset/opencv_frame_{}.jpg".format(img_counter)
cv2.imwrite(img_name, faceresize)
粗体:表示新术语,重要单词或您在屏幕上看到的单词。 例如,菜单或对话框中的单词会出现在这样的文本中。 这是一个示例:“卷积神经网络(CNN)是计算机视觉中用于分类和检测对象的最广泛使用的工具。”
警告或重要提示如下所示。
提示和技巧如下所示。
一、计算机视觉和 TensorFlow 基础知识
随着深度学习方法增强了传统技术(例如图像阈值,过滤和边缘检测)的应用,计算机视觉在许多不同的应用中正在迅速扩展。 TensorFlow 是 Google 创建的一种广泛使用的,功能强大的机器学习工具。 它具有用户可配置的 API,可用于在本地 PC 或云中训练和构建复杂的神经网络模型,并在边缘设备中进行大规模优化和部署。
在本章中,您将了解使用 TensorFlow 的高级计算机视觉概念。 本章讨论计算机视觉和 TensorFlow 的基本概念,以使您为本书的后续更高级章节做好准备。 我们将研究如何执行图像哈希和过滤。 然后,我们将学习特征提取和图像检索的各种方法。 接下来,我们将了解应用中的可视搜索,其方法以及我们可能面临的挑战。 然后,我们将概述高级 TensorFlow 软件及其不同的组件和子系统。
我们将在本章中介绍的主题如下:
- 使用图像哈希和过滤检测边缘
- 从图像中提取特征
- 使用轮廓和 HOG 检测器的对象检测
- TensorFlow,其生态系统和安装概述
技术要求
如果尚未安装,请从这里安装 Anaconda。 Anaconda 是 Python 的包管理器。 您还需要使用pip install opencv-python为要执行的所有计算机视觉工作安装 OpenCV。 OpenCV 是用于计算机视觉工作的内置编程函数的库。
使用图像哈希和过滤检测边缘
图像哈希是一种用于查找图像之间相似性的方法。 散列涉及通过转换将输入图像修改为固定大小的二进制向量。 使用不同的转换有多种用于图像哈希的算法:
- 永久哈希(phash):余弦变换
- 差异哈希(dhash):相邻像素之间的差异
经过哈希转换后,可以将图像与汉明距离快速比较。 以下代码显示了用于应用哈希转换的 Python 代码。 0的汉明距离表示相同的图像(重复),而较大的汉明距离表示图像彼此不同。 以下代码段导入 Python 包,例如PIL,imagehash和distance。 imagehash是支持各种哈希算法的 Python 包。 PIL是 Python 图像库,distance是 Python 包,用于计算两个散列图像之间的汉明距离:
from PIL import Image
import imagehash
import distance
import scipy.spatial
hash1 = imagehash.phash(Image.open(…/car1.png))
hash2 = imagehash.phash(Image.open(…/car2.png))
print hamming_distance(hash1,hash2)
图像过滤是一种基本的计算机视觉操作,它通过对输入图像的每个像素应用核或过滤器来修改输入图像。 以下是图像过滤所涉及的步骤,从进入相机的光到最终的变换图像开始:
- 使用拜耳过滤器形成彩色图案
- 创建图像向量
- 变换图像
- 线性过滤 - 使用核的卷积
- 混合高斯和拉普拉斯过滤器
- 检测图像边缘
使用拜耳过滤器形成彩色图案
拜耳过滤器通过应用去马赛克算法将原始图像转换为自然的,经过颜色处理的图像。 图像传感器由光电二极管组成,光电二极管产生与光的亮度成比例的带电光子。 光电二极管本质上是灰度的。 拜耳过滤器用于将灰度图像转换为彩色图像。 来自拜耳过滤器的彩色图像经过图像信号处理(ISP),该过程涉及数周的各种参数手动调整,以产生所需的人眼图像质量。 当前正在进行一些研究工作,以将手动 ISP 转换为基于 CNN 的处理以生成图像,然后将 CNN 与图像分类或对象检测模型合并以生成一个采用 Bayer 彩色图像并使用边界框检测对象的相干神经网络管道 。 此类工作的详细信息可以在 Sivalogeswaran Ratnasingam 在 2019 年发表的题为《深度相机:用于图像信号处理的全卷积神经网络》的论文中找到。 本文的链接显示在此处。
这是一个拜耳过滤器的示例:

在上图中,我们可以观察到以下内容:
- 拜耳过滤器由红色(
R),绿色(G)和蓝色(B)通道以预定义的模式,因此 G 通道的数量是 B 和 R 的两倍。 - G,R 和 B 通道交替分布。 大多数通道组合是 RGGB,GRGB 或 RGBG。
- 每个通道只会让一种特定的颜色通过,不同通道的颜色组合会产生如上图所示的图案。
创建图像向量
彩色图像是 R,G 和 B 的组合。颜色可以表示为强度值,范围从0到255。 因此,每个图像都可以表示为三维立方体,其中x和y轴表示宽度和高度,而z轴表示三种颜色通道(R,G,B),代表每种颜色的强度。 OpenCV 是一个具有为 Python 和 C++ 编写的用于图像处理和对象检测的内置编程函数的库。
我们将从编写以下 Python 代码开始以导入图像,然后我们将看到如何将图像分解为具有 RGB 的 NumPy 向量数组。 然后,我们将图像转换为灰度,并查看当我们仅从图像中提取一种颜色分量时图像的外观:
import numpy as np
import cv2
import matplotlib.pyplot as plt
%matplotlib inline
import matplotlib.pyplot as plt
from PIL import Image
image = Image.open('../car.jpeg'). # enter image path in ..
plt.imshow(image)
image_arr = np.asarray(image) # convert image to numpy array
image_arr.shape
前面的代码将返回以下输出:
Output:
(296, 465, 4)
gray = cv2.cvtColor(image_arr, cv2.COLOR_BGR2GRAY)
plt.imshow(gray, cmap='gray')
下图显示了基于上述变换的彩色图像和相应的灰度图像:

以下是我们将用于将图像转换为 R,G 和 B 颜色分量的 Python 代码:
plt.imshow(image_arr[:,:,0]) # red channel
plt.imshow(image_arr[:,:,1]) # green channel
plt.imshow(image_arr[:,:,2]) # blue channel
下图显示了仅提取一个通道(R,G 或 B)后的汽车变形图像:

上图可以表示为具有以下轴的 3D 体积:
x轴,代表宽度。y轴,代表高度。- 每个颜色通道代表图像的深度。
让我们看一下下图。 它以 3D 体积显示在x和y坐标不同的情况下汽车图像的 R,G 和 B 像素值; 值越高表示图像越亮:

变换图像
图像变换涉及图像的平移,旋转,放大或剪切。 如果(x,y)是图像像素的坐标,则新像素的变换后图像坐标(u,v)可以表示为:

- 转换:转换常数值的一些示例为
c11 = 1,c12 = 0,并且c13 = 10;c21 = 0,c22 = 1,c23 = 10。结果方程变为u = x + 10和v = y + 10:

- 旋转:一些旋转常数值的示例是
c11 = 1,c12 = 0.5,c13 = 0;c21 = -0.5,c22 = 1,c23 = 0。
所得的等式变为u = x + 0.5y和v = -0.5x + y:

- 旋转 + 平移:旋转和平移组合常数的一些示例为
c11 = 1,c12 = 0.5,c13 = 10;c21 = -0.5,c22 = 1,c23 = 10。结果方程变为u = x + 0.5y + 10和v = -0.5x + y + 10:

- 剪切:一些剪切常数值示例为
c11 = 10,c12 = 0和c13 = 0;c21 = 0,c22 = 10,c23 = 0。所得方程变为u = 10x和v = 10y:

图像转换在计算机视觉中特别有用,可以从同一图像中获取不同的图像。 这有助于计算机开发对平移,旋转和剪切具有鲁棒性的神经网络模型。 例如,如果在训练阶段仅在卷积神经网络(CNN)中输入汽车前部的图像,在测试阶段将汽车旋转 90 度的角度,则该模型将无法检测到该图像。
接下来,我们将讨论卷积运算的机制以及如何应用过滤器来变换图像。
线性过滤 - 使用核的卷积
计算机视觉中的卷积是两个数组(其中一个是图像,另一个是小数组)的线性代数运算,以生成形状与原始图像数组不同的已滤波图像数组。 卷积是累积和关联的。 它可以用数学方式表示如下:

前面的公式解释如下:
F(x,y)是原始图像。G(x,y)是过滤后的图像。U是图像核。
根据核类型U,输出映像将有所不同。 转换的 Python 代码如下:
import numpy as np
import cv2
import matplotlib.pyplot as plt
%matplotlib inline
import matplotlib.pyplot as plt
from PIL import Image
image = Image.open(‘…/carshort.png')
plt.imshow(image)
image_arr = np.asarray(image) # convert image to numpy array
image_arr.shape
gray = cv2.cvtColor(image_arr, cv2.COLOR_BGR2GRAY)
plt.imshow(gray, cmap='gray')
kernel = np.array([[-1,-1,-1],
[2,2,2],
[-1,-1,-1]])
blurimg = cv2.filter2D(gray,-1,kernel)
plt.imshow(blurimg, cmap='gray')
前面代码的图像输出如下:

左边是输入图像,右边是通过对图像应用水平核而获得的图像。 水平核仅检测水平边缘,这可以通过水平线的白色条纹看到。 有关水平核的详细信息,请参见“图像梯度”部分。
前面的代码导入了用于机器学习和计算机视觉工作的必要 Python 库,例如 NumPy 处理数组,cv2用于 openCV 计算机视觉工作,PIL 处理 Python 代码中的图像,以及 Matplotlib 绘制结果。 然后,它使用 PIL 导入图像,并使用 OpenCV BGr2GRAY缩放函数将其转换为灰度。 它使用 NumPy 数组创建用于边缘过滤的核,使用核模糊图像,然后使用imshow()函数显示图像。
过滤操作分为三类:
- 图像平滑
- 图像梯度
- 图像锐化
图像平滑
在图像平滑中,通过应用低通过滤器来消除图像中的高频噪声,例如:
- 均值过滤器
- 中值过滤器
- 高斯过滤器
这使图像模糊,并且通过施加其端值不改变正负号并且值没有明显不同的像素来执行。
图像过滤通常是通过在图像上滑动框式过滤器来完成的。 框式过滤器由n x m核除以(n * m)表示,其中n是行数,m是行数。 列。 对于3 x 3核,其外观如下:

假设此核已应用于先前描述的 RGB 图像。 作为参考,此处显示3 x 3图像值:

均值过滤器
在对图像执行盒核的卷积运算之后,均值过滤器会使用平均值过滤图像。 矩阵相乘后的结果数组如下:

平均值为42,它将替换图像中166的中心强度值,如下面的数组所示。 图像的剩余值将以类似的方式转换:

中值过滤器
在对图像执行盒核的卷积运算之后,中值过滤器用中值过滤图像值。 矩阵相乘后的结果数组如下:

中值是48,并替换图像中166的中心强度值,如下数组所示。 图像的剩余值将以类似的方式转换:

高斯过滤器
高斯核由以下方程式表示:

是分布的标准差,k是仁大小。
对于1的标准差(σ)和3 x 3核(k = 3),高斯核看起来如下:

在此示例中,当应用高斯核时,图像的转换如下:

因此,在这种情况下,中心强度值为54。 将该值与中值和均值过滤器值进行比较。
OpenCV 图像过滤
通过将过滤器应用于真实图像,可以更好地理解先前描述的图像过滤器概念。 OpenCV 提供了一种方法。 我们将使用的 OpenCV 代码可以在这个页面中找到。
重要代码在以下代码段中列出。 导入图像后,我们可以添加噪点。 没有噪声,图像过滤器效果将无法很好地显现。 之后,我们需要保存图像。 对于均值和高斯过滤器,这不是必需的,但是如果我们不使用中值过滤器保存图像,然后再次将其导回,则 Python 将显示错误。
请注意,我们使用plt.imsave而不是 OpenCV 保存图像。 使用imwrite直接保存将导致黑色图像,因为在保存之前需要将图像规格化为 255 比例。 plt.imsave没有该限制。
之后,我们使用blur,medianBlur和GaussianBlur通过均值,中值和高斯过滤器来转换图像:
img = cv2.imread('car.jpeg')
imgnoise = random_noise(img, mode='s&p',amount=0.3)
plt.imsave("car2.jpg", imgnoise)
imgnew = cv2.imread('car2.jpg')
meanimg = cv2.blur(imgnew,(3,3))
medianimg = cv2.medianBlur(imgnew,3)
gaussianimg = cv2.GaussianBlur(imgnew,(3,3),0)
下图显示了使用matplotlib pyplot绘制的结果图像:

请注意,在这三种情况下,过滤器都会去除图像中的噪点。 在此示例中,似乎中值过滤器是从图像中去除噪声的三种方法中最有效的方法。
图像梯度
图像梯度可计算给定方向上像素强度的变化。 像素强度的变化是通过对带有核的图像执行卷积运算获得的,如下所示:

选择核时,两个极端的行或列将具有相反的符号(正负),因此在对图像像素进行乘和求和时会产生差运算符。 让我们看下面的例子:
- 水平核:

- 垂直核:

此处描述的图像梯度是计算机视觉的基本概念:
- 可以在
x和y方向上计算图像梯度。 - 通过使用图像梯度,可以确定边缘和角落。
- 边缘和角落包含有关图像形状或特征的许多信息。
- 因此,图像梯度是一种将低阶像素信息转换为高阶图像特征的机制,卷积运算将其用于图像分类。
图像锐化
在图像锐化中,通过应用高通过滤器(差分算子)可以消除图像中的低频噪声,从而导致线条结构和边缘变得更加清晰可见。 图像锐化也称为拉普拉斯运算,由二阶导数表示,如下所示:

由于存在差异算符,因此相对于核中点的四个相邻单元始终具有相反的符号。 因此,如果核的中点为正,则四个相邻单元为负,反之亦然。 让我们看下面的例子:

请注意,二阶导数相对于一阶导数的优势在于,二阶导数将始终经过零交叉。 因此,可以通过查看零交叉点(0值)来确定边缘,而不是通过观察一阶梯度的梯度大小(可以在图像之间和给定图像内变化)来确定边缘。
混合高斯和拉普拉斯运算
到目前为止,您已经了解到高斯运算会使图像模糊,而拉普拉斯运算会使图像锐化。 但是为什么我们需要每个操作,在什么情况下使用每个操作?
图像由特征,特征和其他非特征对象组成。 图像识别就是从图像中提取特征并消除非特征对象。 我们将图像识别为诸如汽车之类的特定物体,因为与非特征相比,其特征更为突出。 高斯滤波是一种从特征中抑制非特征的方法,该方法会使图像模糊。
多次应用它会使图像更加模糊,并同时抑制特征和非特征。 但是由于特征更强,可以通过应用拉普拉斯梯度来提取它们。 这就是为什么我们将高斯核的 sigma 卷积两次或更多次,然后应用 Laplacian 运算来清晰显示特征的原因。 这是大多数卷积操作中用于对象检测的常用技术。
下图显示了输入3 x 3图像部分,核值,卷积运算后的输出值以及结果图像:

上图显示了各种高斯和倾斜核,以及如何通过应用核来转换图像的3 x 3截面。 下图是上一个的延续:

前面的表示根据卷积运算的类型清楚地显示了图像如何变得更加模糊或清晰。 对卷积运算的这种理解是基本的,因为我们了解更多有关在 CNN 各个阶段使用 CNN 优化核选择的信息。
检测图像边缘
边缘检测是计算机视觉中基于亮度和图像强度变化来查找图像特征的最基本处理方法。 亮度的变化是由于深度,方向,照明或角落的不连续而导致的。 边缘检测方法可以基于一阶或二阶:

下图以图形方式说明了边缘检测机制:

在这里,您可以看到图像的强度在中点附近从暗变亮,因此图像的边缘在中间点。 一阶导数(强度梯度)在中点先升后降,因此可以通过查看一阶导数的最大值来计算边缘检测。 但是,一阶导数方法的问题在于,取决于输入函数,最大值可能改变,因此不能预先确定最大值的阈值。 但是,如图所示,二阶导数始终在边缘处穿过零点。
Sobel 和 Canny 是一阶边缘检测方法,而二阶方法是 Laplacian 边缘检测器。
Sobel 边缘检测器
Sobel 运算符通过计算图像强度函数的梯度(以下代码中的Sobelx和Sobely)来检测边缘。 通过将核应用于图像来计算梯度。 在以下代码中,核大小(ksize)为5。 此后,通过取梯度的比率(sobely/sobelx)来计算 Sobel 梯度(SobelG):
Sobelx=cv2.Sobel(gray,cv2.CV_64F,1,0,ksize=5)
Sobely=cv2.Sobel(gray,cv2.CV_64F,0,1,ksize=5)
mag,direction = cv2.cartToPolar(sobelx,sobely,angleInDegrees =True)
sobelG = np.hypot(sobelx,sobely)
Canny 边缘检测仪
Canny 边缘检测器使用二维高斯过滤器去除噪声,然后应用具有非最大抑制的 Sobel 边缘检测来挑选x和y之间的最大比值。 在任何像素点进行梯度,最后应用边缘阈值检测是否存在边缘。 以下代码显示了灰度图像上的 Canny 边缘检测。 min和max值是用于比较图像梯度以确定边缘的阈值:
Canny = cv2.Canny(gray,minVal=100,maxVal=200)
下图显示了应用Sobel-x,Sobel-y和 Canny 边缘检测器后的汽车图像:

我们可以看到,Canny 在检测汽车方面的表现比 Sobel 好得多。 这是因为 Canny 使用二维高斯过滤器消除了噪声,然后应用具有非最大抑制的 Sobel 边缘检测来挑选x和y之间的最大比值。 在任何像素点上进行梯度,最后应用边缘阈值检测是否存在边缘。
从图像中提取特征
一旦我们知道了如何检测边缘,下一个任务就是检测特征。 许多边缘合并形成特征。 特征提取是识别图像中的视觉图案并提取与未知对象的图像匹配的任何可辨别局部特征的过程。 在进行特征提取之前,了解图像直方图很重要。 图像直方图是图像色彩强度的分布。
如果直方图相似,则图像特征与测试图像匹配。 以下是用于创建汽车图像直方图的 Python 代码:
import numpy as np
import cv2
import matplotlib.pyplot as plt
%matplotlib inline
import matplotlib.pyplot as plt
from PIL import Image
image = Image.open('../car.png')
plt.imshow(image)
image_arr = np.asarray(image) # convert image to numpy array
image_arr.shape
color = ('blue', 'green', 'red')
for i,histcolor in enumerate(color):
carhistogram = cv2.calcHist([image_arr],[i],None,[256],[0,256])
plt.plot(carhistogram,color=histcolor)
plt.xlim([0,256])
前面的 Python 代码首先导入必要的 Python 库,例如cv2(OpenCV),NumPy(用于数组计算),PIL(用于导入图像)和 Matplotlib(用于绘制图形)。 之后,它将图像转换成数组并循环遍历每种颜色,并绘制每种颜色(R,G 和 B)的直方图。
下图显示了汽车图像的直方图输出。x轴表示从0(黑色)到256(白色)的颜色强度值,y轴表示出现的频率:

直方图显示 R,G 和 B 的峰值颜色强度在100附近,第二个峰值在150附近。 这意味着汽车的平均颜色是灰色。 以200的强度值显示的0频率(在图像的最右侧)显示该车肯定不是白色的。 类似地,以50的强度值出现的0频率显示图像不是完全黑色。
OpenCV 图像匹配
图像匹配是一种将两个不同的图像匹配以找到共同特征的技术。 图像匹配技术具有许多实际应用,例如匹配指纹,使地毯颜色与地板或墙壁颜色匹配,使照片匹配以找到同一个人的两个图像,或者比较制造缺陷以将它们分为相似的类别以进行更快的分析。 本节概述了 OpenCV 中可用的图像匹配技术。 这里描述了两种常用的方法: 暴力破解(BFMatcher)和用于近似最近的邻居的快速库(FLANN**)。 在本书的稍后部分,我们还将讨论其他类型的匹配技术,例如“第 2 章”,“使用局部二进制模式的内容识别”中的直方图匹配和。 “第 6 章”,“使用迁移学习的视觉搜索”中的局部二进制模式。
在 BFMatcher 中,将比较测试图像和目标图像各部分之间的汉明距离,以实现最佳匹配。 另一方面,FLANN 速度更快,但只会找到最接近的邻居–因此,它找到了很好的匹配项,但不一定是最佳匹配项。 KNN 工具假定相似的事物彼此相邻。 它根据目标与源之间的距离找到最接近的第一近邻。 可以在这个页面上找到用于图像匹配的 Python 代码。
请注意,在下图中,BFMatcher 找到了更相似的图像。 该图是前面的代码(preface_SIFT.ipynb)返回的输出。 我们来看一下:

上图显示了如何应用 BFMatcher 和 FLANN 的 KNN 匹配器将单个瓷砖匹配到整个浴室地板。 显然,与 FLANN 匹配器(红线)相比,BFMatcher(蓝线)找到更多的平铺点。
前面描述的图像匹配技术还可以用于查找两点之间的相对距离-一个点可以是参考点,例如从中获取图像的汽车,而另一个可以是道路上的另一辆汽车。 然后使用该距离来开发防撞系统。
使用轮廓和 HOG 检测器的对象检测
轮廓是图像中形状相似的封闭区域。 在本节中,我们将使用轮廓来分类和检测图像中的简单对象。 我们将使用的图像由苹果和橙子组成,我们将使用轮廓和 Canny 边缘检测方法来检测对象并将图像类名称写在边界框上。 该部分的代码可以在这个页面中找到。
以下各小节介绍了该方法。
轮廓检测
我们首先需要导入图像,然后使用 Canny 边缘检测器在图像中找到边缘。 因为我们的对象的形状是带有圆角的圆,所以效果很好。 以下是所需的详细代码:
threshold =100
canny_output = cv2.Canny(img, threshold, threshold * 2)
contours, hierarchy = cv2.findContours(canny_output, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
如前面的代码所示,在 Canny 边缘检测之后,我们应用了 OpenCV findContours()方法。 此方法具有三个参数:
- 图像,在本例中为 Canny 边缘检测器输出。
- 检索方法,有很多选择。 我们正在使用的是一种外部方法,因为我们有兴趣在对象周围绘制边界框。
- 轮廓近似法。
检测边界框
该方法本质上包括理解图像及其各种类别的特征以及对图像类别进行分类的开发方法。
请注意,OpenCV 方法不涉及任何训练。 对于每个轮廓,我们使用 OpenCV boundingRect属性定义一个边界框。
我们将使用两个重要的特征来选择边界框:
- 兴趣区域的大小:我们将消除尺寸小于
20的所有轮廓。
请注意,20不是通用编号,它仅适用于此图像。 对于更大的图像,该值可以更大。
- 兴趣区域的颜色:在每个边界框中,我们需要定义宽度从
25%到75%的兴趣区域,以确保我们不考虑圈子外的矩形的空白区域。 这对于最小化变化很重要。 接下来,我们使用CV2.mean定义平均颜色。
我们将通过观察包围它的三个橙色图像来确定颜色的平均阈值和最大阈值。 以下代码使用 OpenCV 的内置方法通过cv2.boundingRect绘制边界框。 然后根据宽度和高度选择绘制兴趣区域(ROI),并找到该区域内的平均颜色:
count=0
font = cv2.FONT_HERSHEY_SIMPLEX
for c in contours:
x,y,w,h = cv2.boundingRect(c)
if (w >20 and h >20):
count = count+1
ROI = img[y+int(h/4):y+int(3*h/4), x+int(h/4):x+int(3*h/4)]
ROI_meancolor = cv2.mean(ROI)
print(count,ROI_meancolor)
if (ROI_meancolor[0] > 30 and ROI_meancolor[0] < 40 and ROI_meancolor[1] > 70 and ROI_meancolor[1] < 105
and ROI_meancolor[2] > 150 and ROI_meancolor[2] < 200):
cv2.putText(img, 'orange', (x-2, y-2), font, 0.8, (255,255,255), 2, cv2.LINE_AA)
cv2.rectangle(img,(x,y),(x+w,y+h),(255,255,255),3)
cv2.imshow('Contours', img)
else:
cv2.putText(img, 'apple', (x-2, y-2), font, 0.8, (0,0,255), 2, cv2.LINE_AA)
cv2.rectangle(img,(x,y),(x+w,y+h),(0,0,255),3)
cv2.imshow('Contours', img)
在前面的代码中,请注意两个if语句-基于大小的w,h和基于颜色的ROI_meancolor[0,1,2]:
- 基于大小的语句消除了所有小于
20的轮廓。 ROI_meancolor [0,1,2]表示平均颜色的 RGB 值。
在这里,第三,第四和第八行表示橙色,if语句将颜色限制为B组件在30和40之间,对于G则在70和105之间 ]组件,以及R组件的150和200。
输出如下。 在我们的示例中,3,4和8是橙色:
1 (52.949200000000005, 66.38640000000001, 136.2072, 0.0)
2 (43.677693761814744, 50.94659735349717, 128.70510396975425, 0.0)
3 (34.418282548476455, 93.26246537396122, 183.0893351800554, 0.0)
4 (32.792241946088104, 78.3931623931624, 158.78238001314926, 0.0)
5 (51.00493827160494, 55.09925925925926, 124.42765432098766, 0.0)
6 (66.8863771564545, 74.85960737656157, 165.39678762641284, 0.0)
7 (67.8125, 87.031875, 165.140625, 0.0)
8 (36.25, 100.72916666666666, 188.67746913580245, 0.0)
请注意,OpenCV 将图像处理为BGR而不是RGB。
HOG 检测器
定向梯度的直方图(HOG)是有用的特征,可用于确定图像的局部图像强度。 此技术可用于查找图像中的对象。 局部图像梯度信息可用于查找相似图像。 在此示例中,我们将使用 scikit-image 导入 HOG,并使用它绘制图像的 HOG。 如果尚未安装 scikit-image,则可能需要使用pip install scikit-image安装它:
from skimage.feature import hog
from skimage import data, exposure
fruit, hog_image = hog(img, orientations=8, pixels_per_cell=(16, 16),
cells_per_block=(1, 1), visualize=True, multichannel=True)
hog_image_rescaled = exposure.rescale_intensity(hog_image, in_range=(0, 10))
cv2.imshow('HOG_image', hog_image_rescaled)
下图说明了示例代码中前面代码的结果:

在上图中,我们可以观察到以下内容:
- 左侧显示边界框,而右侧显示图像中每个对象的 HOG 梯度。
- 请注意,每个苹果和橘子都可以正确检测到,并且包围水果的边界框没有任何重叠。
- HOG 描述符显示一个矩形的边界框,其中的梯度表示圆形图案。
- 桔子和苹果之间的梯度显示出相似的图案,唯一的区别是大小。
轮廓检测方法的局限性
在对象检测方面,上一节中显示的示例看起来非常好。 我们无需进行任何训练,并且只需对一些参数进行少许调整,就可以正确检测出橙子和苹果。 但是,我们将添加以下变体,并查看我们的检测器是否仍然能够正确检测对象:
- 我们将添加除苹果和橙子以外的对象。
- 我们将添加另一个形状类似于苹果和橙子的对象。
- 我们将改变光的强度和反射率。
如果我们执行上一部分中的相同代码,它将检测每个对象,就好像它是一个苹果一样。 这是因为所选的width和height参数太宽,并且包括所有对象以及 RGB 值,它们在此图像中的显示方式与以前不同。 为了正确检测对象,我们将对if语句的大小和颜色进行以下更改,如以下代码所示:
if (w >60 and w < 100 and h >60 and h <120):
if (ROI_meancolor[0] > 10 and ROI_meancolor[0] < 40 and ROI_meancolor[1] > 65 and ROI_meancolor[1] < 105
请注意,前面的更改对if语句施加了以前不存在的约束。
RGB 颜色如下:
1 (29.87429111531191, 92.01890359168242, 182.84026465028356, 0.0) 82 93
2 (34.00568181818182, 49.73605371900827, 115.44163223140497, 0.0) 72 89
3 (39.162326388888886, 62.77256944444444, 148.98133680555554, 0.0) 88 96
4 (32.284938271604936, 53.324444444444445, 141.16493827160494, 0.0) 89 90
5 (12.990362811791384, 67.3078231292517, 142.0997732426304, 0.0) 84 84
6 (38.15, 56.9972, 119.3528, 0.0) 82 100
7 (47.102716049382714, 80.29333333333334, 166.3264197530864, 0.0) 86 90
8 (45.76502082093992, 68.75133848899465, 160.64901844140394, 0.0) 78 82
9 (23.54432132963989, 98.59972299168975, 191.97368421052633, 0.0) 67 76
上面的代码在更改后的图像上的结果如下所示:

在上图中可以看到一个遥控器,叉子,刀子和一个塑料杯。 请注意,苹果,橘子和塑料杯的 HOG 功能如何相似,这是预期的,因为它们都是圆形的:
- 塑料杯周围没有包围框,因为未检测到。
- 与苹果和橘子相比,叉子和刀子的 HOG 角形非常不同。
- 遥控器具有矩形的 HOG 形状。
这个简单的示例表明,这种对象检测方法不适用于较大的图像数据集,我们需要调整参数以考虑各种照明,形状,大小和方向条件。 这就是为什么我们将在本书其余部分中讨论 CNN 的原因。 一旦我们使用此方法在不同条件下训练图像,无论对象的形状如何,它将在新的条件下正确检测到对象。 但是,尽管上述方法有局限性,我们还是学习了如何使用颜色和大小将一个图像与另一个图像分开。
ROI_meancolor是一种用于检测边界框内对象平均颜色的强大方法。 例如,您可以使用它根据边界框内的球衣颜色,绿色苹果与红色苹果或任何类型的基于颜色的分离方法,将一个团队的球员与另一个团队的球员区分开。
TensorFlow,生态系统和安装概述
在前面的部分中,我们介绍了计算机视觉技术的基础知识,例如图像转换,图像过滤,使用核进行卷积,边缘检测,直方图和特征匹配。 这种理解及其各种应用应该为深度学习的高级概念打下坚实的基础,这将在本书的后面部分进行介绍。
计算机视觉中的深度学习是通过许多中间(隐藏)层的卷积运算对许多不同图像特征(例如边缘,颜色,边界,形状等)的累积学习,以全面了解图像类型。 深度学习增强了计算机视觉技术,因为它堆叠了有关神经元行为的许多计算层。 通过组合各种输入以基于数学函数和计算机视觉方法(例如边缘检测)产生输出来完成此操作。
TensorFlow 是一个端到端(E2E)机器学习平台,其中图像和数据被转换为张量以由神经网络进行处理。 例如,大小为224 x 224的图像可以表示为等级4的张量为128, 224, 224, 3,其中128是神经网络的批量大小,224是高度和宽度, 3是颜色通道(R,G 和 B)。
如果您的代码基于 TensorFlow 1.0,那么将其转换为 2.0 版可能是最大的挑战之一。 请遵循这个页面上的说明,以转换为 2.0 版。 大多数时候,当您使用终端在 TensorFlow 中执行 Python 代码时,转换问题会在低级 API 中发生。
Keras 是 TensorFlow 的高级 API。 以下三行代码是安装 Keras 的起点:
from __future__ import absolute_import, division, print_function, unicode_literals
import tensorflow as tf
from tensorflow import keras
如果不使用最后一行,则可能必须对所有函数使用from tensorflow.keras导入。
TensorFlow 使用tf.data从简单的代码构建复杂的输入管道,从而简化并加快了数据输入过程。 您将在 “第 6 章”,“使用迁移学习的视觉搜索”中了解这一点。
在 Keras 中,模型的各层以顺序的形式堆叠在一起。 这由model=tf.keras.Sequential()引入,并使用model.add语句添加每一层。 首先,我们需要使用model.compile编译模型,然后可以使用model.train函数开始训练。
TensorFlow 模型将保存为检查点并保存模型。 检查点捕获模型使用的参数,过滤器和权重的值。 检查点与源代码关联。 另一方面,保存的模型可以部署到生产设置中,不需要源代码。
TensorFlow 针对多个 GPU 提供分布式训练。 TensorFlow 模型输出可以使用 Keras API 或 TensorFlow 图可视化。
TensorFlow 与 PyTorch
PyTorch 是另一个类似于 TensorFlow 的深度学习库。 它基于 Torch,由 Facebook 开发。 在 TensorFlow 创建静态图的同时,PyTorch 创建动态图。 在 TensorFlow 中,必须首先定义整个计算图,然后运行模型,而在 PyTorch 中,可以平行于模型构建来定义图。
TensorFlow 安装
要在 PC 上安装 TensorFlow 2.0,请在终端中键入以下命令。 确保单击Enter:
pip install --upgrade pip
pip install tensorflow
除 TensorFlow 之外,上述命令还将在终端中下载并提取以下包:
- Keras(用 Python 编写的高级神经网络 API,能够在 TensorFlow 的顶部运行)
protobuf(用于结构化数据的序列化协议)- TensorBoard(TensorFlow 的数据可视化工具)
- PyGPU(Python 功能,用于图像处理,GPU 计算以提高性能)
cctools(适用于 Android 的本地 IDE)c-ares(函数库)clang(C,C++,Objective-C,OpenCL 和 OpenCV 的编译器前端)llvm(用于生成前端和后端二进制代码的编译器架构)theano(用于管理多维数组的 Python 库)grpcio(用于 Python 的gRPC包,用于实现远程过程调用)libgpuarray(可用于 Python 中所有包的常见 N 维 GPU 数组)termcolor(Python 中的颜色格式输出)absl(用于构建 Python 应用的 Python 库代码集合)mock(用虚拟环境替换真实对象以帮助测试)gast(用于处理 Python 抽象语法的库)
在安装过程中,在询问时按y表示是:
Downloading and Extracting Packages
Preparing transaction: done
Verifying transaction: done
Executing transaction: done
如果一切都正确安装,您将看到前面的消息。
安装后,根据您的 PC 是 CPU 还是 CPU 和 GPU,输入以下两个命令之一检查 TensorFlow 版本。 请注意,对于所有计算机视觉工作,最好使用 GPU 来加速图像的计算。 对于 Python 3.6 或更高版本,请使用pip3,对于 Python 2.7,请使用pip:
pip3 show tensorflow
pip3 show tensorflow-gpu
pip show tensorflow
输出应显示以下内容:
Name: tensorflow
Version: 2.0.0rc0
Summary: TensorFlow is an open source machine learning framework for everyone.
Home-page: https://www.tensorflow.org/
Author: Google Inc.
Author-email: packages@tensorflow.org
License: Apache 2.0
Location: /home/.../anaconda3/lib/python3.7/site-packages
Requires: gast, google-pasta, tf-estimator-nightly, wrapt, tb-nightly, protobuf, termcolor, opt-einsum, keras-applications, numpy, grpcio, keras-preprocessing, astor, absl-py, wheel, six
Required-by: gcn
有时,您可能会注意到,即使在安装 TensorFlow 之后,Anaconda 环境也无法识别已安装 TensorFlow。 在这种情况下,最好在终端中使用以下命令卸载 TensorFlow,然后重新安装它:
python3 -m pip uninstall protobuf
python3 -m pip uninstall tensorflow-gpu
总结
在本章中,我们学习了图像过滤如何通过卷积运算修改输入图像,以产生检测特征的一部分(称为边缘)的输出。 这是计算机视觉的基础。 正如您将在以下各章中了解到的那样,图像过滤的后续应用会将边缘转换为更高级别的图案,例如特征。
我们还学习了如何计算图像直方图,如何使用 SIFT 进行图像匹配以及如何使用轮廓和 HOG 检测器绘制边界框。 我们学习了如何使用 OpenCV 的边界框颜色和大小方法将一个类与另一个类隔离。 本章以 TensorFlow 简介作为结束,这将为本书的其余章节奠定基础。
在下一章中,我们将学习另一种称为模式识别的计算机视觉技术,并将使用它来对具有模式的图像内容进行分类。
十、R-CNN,SSD 和 R-FCN 对象检测
在“第 7 章”,“使用 YOLO 进行对象检测”中,我们了解了 YOLO 对象检测,然后在前两章中,我们了解了动作识别和图像修补。 本章通过为数据摄取和训练流水线以及模型开发奠定坚实的基础,标志着端到端(E2E)对象检测框架的开始。 在这里,我们将深入了解各种对象检测模型,例如 R-CNN,单发检测器(SSD),基于区域的全卷积网络(R-FCN)和 Mask R-CNN,并使用 Google Cloud 和 Google Colab 笔记本执行动手练习。 我们还将针对如何训练自己的自定义图像以使用 TensorFlow 对象检测 API 开发对象检测模型进行详细的练习。 我们将在本章结束时对各种对象跟踪方法进行深入概述,并使用 Google Colab 笔记本进行动手练习。
本章分为八个小节:
- SSD 概述
- R-FCN 概述
- TensorFlow 对象检测 API 概述
- 在 Google Cloud 上使用 TensorFlow 检测对象
- 使用 TensorFlow Hub 检测对象
- 使用 TensorFlow 和 Google Colab 训练自定义对象检测器
- Mask R-CNN 概述和 Google Colab 演示
- 开发对象跟踪器模型来补充对象检测器
SSD 概述
SSD 是一种非常快速的对象检测器,非常适合部署在移动设备和边缘设备上以进行实时预测。 在本章中,我们将学习如何使用 SSD 开发模型,在下一章中,我们将评估在边缘设备上部署时的表现。 但是在详细介绍 SSD 之前,我们将快速了解到目前为止我们在本书中了解的其他对象检测器模型。
我们在“第 5 章”,“神经网络架构和模型”中了解到,Faster R-CNN 包含 21,500 个区域提议(60 x 40滑动窗口和 9 个锚定框),这些建议被扭曲为 2K 固定层。 这些 2K 层被馈送到全连接层和包围盒回归器,以检测图像中的包围盒。 9 个锚框来自 3 个比例尺,框面积分别为128^2,256^2,512^2和三个长宽比:1:1、1:2 和 2:1。
9 个锚点框的说明如下:
128x128:1:1; 128x128:1:2; 128x128:2:1
256x256:1:1; 256x256:1:2; 256x256:2:1
512x512:1:1; 512x512:1:2; 512x512:2:1
在“第 7 章”,“使用 YOLO 进行对象检测”中,我们了解到 YOLO 使用单个 CNN,该 CNN 同时预测整个图像中对象的多个边界框。 YOLO v3 检测分为三层。 YOLO v3 使用 9 个锚点:(10, 13),(16, 30),(33, 23),(30, 61),(62, 45),(59, 119),(116, 90),(156, 198),(373, 326)。 此外,YOLO v3 使用 9 个掩码,这些掩码链接到锚点,如下所述:
- 第一层:遮罩:6、7、8; 对应的锚点:
(116, 90),(156, 198),(373, 326) - 第二层:遮罩:3、4、5; 对应的锚点:
(30, 61),(62, 45),(59, 119) - 第三层:遮罩:0、1、2; 对应的锚点:
(10, 13),(16, 30),(33, 23)
SSD 于 2016 年由 Liu Wei,Dragomir Anguelov,Dumitru Erhan,Christian Szegedy,Scott Reed,傅成扬和 Alexander C.Berg 在题为《SSD:单发多框检测器》提出。
它的速度比 Faster R-CNN 快,但其准确率与 YOLO 相比。 改进来自消除区域提议并将小型卷积过滤器应用于特征映射,以预测不同比例的多层。
SSD 的主要功能概述如下:
- SSD 原始论文使用 VGG16 作为基础网络提取特征层,但也可以考虑使用其他网络,例如 Inception 和 ResNet。
- SSD 在基础网络之上添加了另外六个特征层,由
conv4_3,conv7(fc7),conv8_2,conv9_2,conv10_2和conv11_2组成,用于对象检测。 - 一组默认框与每个特征映射单元相关联,因此默认框位置相对于特征映射单元是固定的。 每个默认框都会预测
c类中每个类别的得分以及相对于地面真实情况的四个偏移,从而产生(c + 4)k过滤器。 这些过滤器应用于特征映射(大小为m x n),产生(c + 4)kmn输出。 下表说明了这一点。 SSD 的独特之处在于默认框适用于不同分辨率的多个特征映射:
| 层名称 | 检测 | 过滤器输出 |
|---|---|---|
Conv4_3 |
38 x 38 x 4 = 5776 |
3 x 3 x 4 x (c + 4) |
Conv7 |
19 x 19 x 6 = 2166 |
3 x 3 x 6 x (c + 4) |
Conv8_2 |
10 x 10 x 6 = 600 |
3 x 3 x 6 x (c + 4) |
Conv9_2 |
5 x 5 x 6 = 150 |
3 x 3 x 6 x (c + 4) |
Conv10_2 |
3 x 3 x 4 = 36 |
3 x 3 x 4 x (c + 4) |
Conv11_2 |
4 | |
| 总 | 8732 |
- 默认框的设计是使用比例因子和宽高比创建的,因此特定尺寸(基于真实情况预测)的特征映射与对象的特定比例相匹配。
- 比例范围可以从
smin(0.2)到smax(0.95)线性变化,而纵横比(ar)可以取五个值(1,2,0.5,3.0和0.33) ,其中k在1和m之间变化。 - 对于长宽比
1,添加了一个附加的默认框。 因此,每个特征映射位置最多有六个默认框。 - 默认框中心的坐标为
((i+0.5)/|fk|, (j+0.5)/|fk|),其中|fk|是kth正方形特征映射的大小,i和j的值从0到|fk|不等。 对六个默认框的每个重复此操作。 - SSD 通过将给定比例和宽高比的默认框与地面真实物体的默认框匹配,并消除不匹配的框,从而预测各种物体的大小和形状。 默认框与地面真值对象的匹配是通过 Jaccard 重叠(也称为交并比与 IOU)完成的,这在第 7 章,“使用 YOLO 进行对象检测”中。 例如,如果图像由
human和bus组成并且都具有不同的宽高比和比例,则 SSD 显然可以识别两者。 问题出现在两个类别彼此接近且纵横比相同时,我们将在后面看到。 - 使用 R-CNN,区域提议网络执行筛选以限制被视为 2K 的样本数量。 另一方面,SSD 没有区域提议,因此它会生成大量的边界框(如我们先前所知,为 8,732 个),其中许多都是负面示例。 SSD 拒绝了额外的负面示例,它使用硬性负面挖掘来使正面与负面之间的平衡保持至多 3:1。 硬否定挖掘是一种用于使用置信度损失进行排序以便保留最高值的技术。
- SSD 使用非最大抑制来选择给定类别具有最高置信度的单个边界框。 非最大抑制的概念在“第 7 章”,“使用 YOLO 进行对象检测”中。 非最大抑制算法以最高的概率选择对象类别,并丢弃 IOU 大于
0.5的所有边界框。 - SSD 还通过获取假阴性图像作为训练期间的输入来使用硬性阴性挖掘。 SSD 保持负数与正数之比为 3:1。
- 为了进行训练,使用以下参数:
300x300或512x512图像大小,10^(-3)的学习率为 40,000 次迭代,10^(-4)至10^(-5)的学习率为随后的 10,000 次迭代,衰减率为0.0005和0.9的势头。
R-FCN 概述
R-FCN 比 R-CNN 与 SSD 更相似。 R-FCN 由主要由 Microsoft Research 组成的团队于 2016 年开发,该团队由戴继峰,李毅,何凯明和孙健组成,题为《R-FCN:通过基于区域的全卷积网络进行对象检测》。 您可以在这个页面上找到该论文的链接。
R-FCN 也基于区域提议。 与 R-CNN 的主要区别在于,R-FCN 一直等到最后一层,然后应用选择性池提取特征以进行预测,而不是从 2K 区域提议网络开始。 在本章中,我们将使用 R-FCN 训练自定义模型,并将最终结果与其他模型进行比较。 下图描述了 R-FCN 的架构:

在上图中,汽车的图像通过 ResNet-101 生成了特征映射。 请注意,我们在“第 4 章”,“基于图像的深度学习”中使用,它介绍了如何可视化卷积神经网络(CNN)及其特征映射。 这种技术本质上是相同的。 然后,我们在特征映射内获取k x k核(在此图像中,k = 3),并将其在图像上滑动以创建k^2(C+1)得分图。 如果得分图包含一个对象,则我们投票yes,否则,我们投票no。 展平不同区域之间的投票以创建 softmax 层,该层被映射到对象类别以进行检测。
R-FCN 的主要功能如下所述:
- 类似于 R-CNN,在整个图像上计算出全卷积区域提议网络(RPN)。
- R-FCN 并未像 R-CNN 那样将 2K 扭曲区域发送到全连接层,而是在预测之前使用了特征的最后卷积层。
- 减去平均池化层和全连接层的 ResNet-101 用于特征提取。 因此,仅卷积层用于计算特征映射。 ResNet-101 中的最后一个卷积块具有 2,048 个维,将其传递到 1,024 维的
1×1卷积层以进行维降。 - 1,024 个卷积层产生一个
k^2得分图,它对应于k^2(C + 1)通道输出,带有C对象类别加上背景。 - 应用选择性合并从
k^2得分图中仅从得分图中提取响应。 - 这种从最后一层提取特征的方法可最大程度地减少计算量,因此 R-FCN 甚至比 Faster R-CNN 更快。
- 对于边界框回归,在
4k^2卷积层上使用平均池,从而为每个关注区域层生成4k^2维向量。 来自每个k^2层的4k^2向量被聚合为四维向量,该向量将边界框的位置和几何形状表征为x,y,宽度和高度 。 - 为了进行训练,使用以下参数:衰减率为
0.0005,动量为0.9,将图像调整为高度为600像素,20,000 批量的学习率为0.001和0.000110,000 个批量。
TensorFlow 对象检测 API 概述
可以在这里找到 TensorFlow 对象检测 API。 在撰写本书时,TensorFlow 对象检测 API 仅适用于 TensorFlow 版本 1.x。 在终端中下载 TensorFlow 1.x 时,它将models/research/object detection目录安装到您的 PC。 如果您的 PC 上装有 TensorFlow 2.0,则可以从 GitHub 下载研究目录。
TensorFlow 对象检测 API 具有预先训练的模型,您可以使用网络摄像头对其进行检测以及有关自定义图片的示例训练。 浏览前两个链接,然后自己尝试,然后返回下一部分。
在本章中,我们将使用 TensorFlow 对象检测器执行以下任务:
- 使用 Google Cloud 和 Coco 数据集上的预训练模型进行对象检测
- 使用 TensorFlow Hub 和 Coco 数据集上的预训练模型进行对象检测
- 使用迁移学习训练 Google Colab 中的自定义对象检测器
在所有这些示例中,我们将使用汉堡和薯条数据集进行检测和预测。
在 Google Cloud 上使用 TensorFlow 检测对象
以下说明介绍了如何使用 Google Cloud 上的 TensorFlow 对象检测 API 来检测对象。 为此,您必须具有 Gmail 和 Google Cloud 帐户。 提交信用卡信息后,根据地区的不同,Google Cloud 可以在有限的时间内免费提供访问权限。 此免费访问权限应涵盖此处列出的练习。 请按照以下步骤在 Google Cloud Console 中创建虚拟机(VM)实例。 需要 VM 来运行 TensorFlow 对象检测 API 并进行推断:
-
登录到您的 Gmail 帐户,然后转到 h ttps://cloud.google.com/solutions/creating-object-detection-application-tensorflow 。
-
创建一个项目,如下面的屏幕快照所示。 在这里,
R-CNN-trainingpack是我的项目的名称。 您的项目名称可能会有所不同。 -
按照[启动 VM 实例]下的 10 条说明进行操作-在“步骤 12”之后的屏幕快照中也进行了说明。
-
在 Google Cloud Console 中,导航到“VM 实例”页面。
-
点击顶部的“创建实例”。 它应该带您到另一个页面,您必须在其中输入实例名称。
-
以小写字母输入实例的名称。 请注意,实例名称与项目名称不同。
-
单击“计算机类型”,然后选择
n1-standard-8(8vCPU,30 GB 内存)。 -
单击“自定义”,然后调整水平条以将“计算机类型”设置为 8 个 vCPU,将“内存”设置为 8GB,如以下屏幕截图所示。
-
选择“防火墙”下的“允许 HTTP 通信”。
-
在防火墙下,您将看到管理,安全性,磁盘,网络,唯一租赁链接,如屏幕快照所示,该屏幕快照说明了创建 VM 实例的步骤。 单击它,然后单击“网络”选项卡。
-
在“网络”选项卡中,选择“网络接口”部分。 接下来,在“网络接口”部分中,我们将通过在“外部 IP”下拉列表中分配一个新 IP 地址来分配静态 IP 地址。 给它起一个名字(例如
staticip),然后单击“保留”。 -
完成所有这些步骤之后,请检查并确保已按照说明填充所有内容,然后单击“创建”(如以下屏幕截图所示)以创建 VM 实例。
以下屏幕快照显示了在 Google 云平台中创建名为R-CNN-trainingpack的项目:

创建项目是第一步,然后我们将在项目中创建一个实例,如下面的屏幕快照所示。 此屏幕快照说明了我们刚刚描述的 VM 实例创建的步骤:

然后,按照以下说明在测试图像上创建对象检测推断:
- 接下来,我们将使用安全套接字外壳(SSH)客户端通过互联网安全地访问实例。 您将需要输入用户名和密码。 将用户名设置为
username,将密码设置为passw0rd; 请记住,它不是o而是0,如零。 - 使用这个页面上描述的说明,安装 TensorFlow 对象检测 API 库和必备包。
正确遵循上述说明并上传图像后,您将获得如下所示的输出:

在此屏幕截图中,检测到了汉堡,酒杯和桌子,但未检测到炸薯条。 在下一节中,我们将看到为什么会这样,然后我们将训练自己的神经网络来检测这两者。
使用 TensorFlow Hub 检测对象
在此示例中,我们将从tfhub导入 TensorFlow 库,并使用它来检测对象。 TensorFlow Hub 是一个库,其中的代码可用并且可以用于计算机视觉应用。 该代码是从 TensorFlow Hub 中提取的,但图像是在本地插入的,而不是云端。
可以在这个页面中找到用于此练习的修改后的代码。
在这里,我们通过导入tensorflow_hub和six.moves安装 TensorFlow 库。 six.moves是一个 Python 模块,用于提供 Python 2 和 Python 3 之间的通用包。它显示图像并在图像上绘制边框。 在通过检测器之前,图像将转换为数组。 检测器是直接从集线器加载的模块,该模块在后台执行所有神经网络处理。 以下显示了在两种不同模型的tfhub上运行示例图像时的输出:

如您所见,具有 Inception 和 ResNet 作为特征提取器的 R-CNN 可以正确预测汉堡包和炸薯条以及许多其他对象。 具有 MobileNet 模型的 SSD 可以检测到汉堡,但无法检测到薯条-将其分类为snacks类别。 当我们训练自己的对象检测器并开发自己的模型并基于此进行推论时,我们将在下一部分中了解更多信息。
使用 TensorFlow 和 Google Colab 训练自定义对象检测器
在本练习中,我们将使用 TensorFlow 对象检测 API 使用四种不同的模型训练自定义对象检测器。 Google Colab 是在 Google 服务器上运行的 VM,因此 TensorFlow 的所有包都得到了适当的维护和更新:
| 序号 | 模型 | 特征提取器 |
|---|---|---|
| 1 | 更快的 R-CNN | Inception |
| 2 | SSD | MobileNet |
| 3 | SSD | Inception |
| 4 | R-FCN | ResNet-101 |
请注意,在撰写本书时,TensorFlow 对象检测 API 尚未迁移到 TensorFlow 2.x,因此请在 Google Colab 默认版本 TensorFlow 1.x 上运行此示例。 您可以通过键入%tensorflow_version 2.x在 Google Colab 中安装 TensorFlow 2.x,但是对象检测 API 会导致错误。 该演示练习安装了 TenorFlow 1.14 版和 numpy 1.16 版。
我们将在此练习中使用迁移学习,首先从在 Coco 数据集上训练的预训练模型开始,然后在通过我们自己的数据集进行训练的基础上建立迁移学习。 TensorFlow 已经在 ModelZoo GitHub 站点中存储了预训练的模型,该站点可从这里获取。 这些模型主要是具有不同特征提取器的 R-CNN,SSD 和 R-FCN。 相应的配置文件可以在这个页面中找到。
可可数据集具有以下类别:
Person, bicycle, car, motorcycle, airplane, bus, train, truck, boat, traffic light, fire hydrant, stop sign, parking meter, bench, bird, cat, dog, horse, sheep, cow, elephant, bear, zebra, giraffe, backpack, umbrella, handbag, tie, suitcase, frisbee, skis, snowboard, sports, ball, kite, baseball, bat, baseball, glove, skateboard, surfboard, tennis, racket, bottle, wine, glass, cup, fork, knife, spoon, bowl, banana, apple, sandwich, orange, broccoli, carrot, hot dog, pizza, donut, cake, chair, couch, potted plant, bed, dining table, toilet, tv, laptop, mouse, remote, keyboard, cell phone, microwave oven, toaster, sink, refrigerator, book, clock, vase, scissors, teddy bear, hair drier, toothbrush
如您所见,Coco 数据集没有burger或French fries作为类别。 形状接近这些的项目是sandwich,donut和carrot。 因此,我们将获得模型权重,并在我们自己的数据集上使用迁移学习来开发检测器。 GitHub 网站上的 Jupyter 笔记本具有执行 E2E 训练工作的 Python 代码。
训练工作使用 TensorFlow 对象检测 API,该 API 在执行期间调用各种 Python .py文件。 经过大量练习,我们发现,最好是使用 Google Colab 笔记本而不是您自己的 PC 来运行此工作。 这是因为许多库都是用 TensorFlow 1.x 版本编写的,需要进行转换才能在 TensorFlow 2.0 中工作。 此处显示了在本地 PC 上使用 Anaconda 运行作业时发生的一些错误示例:
module 'keras.backend' has no attribute 'image_dim_ordering'
self.dim_ordering = K.common.image_dim_ordering()
module 'tensorflow_core._api.v2.image' has no attribute 'resize_images'
rs = tf.image.resize(img[:, y:y+h, x:x+w, :], (self.pool_size, self.pool_size))
61 outputs.append(rs)
62
AttributeError: module 'tensorflow_core._api.v2.image' has no attribute 'resize_images'
当作业在 Colab 上的 TensorFlow 中运行时,模块之间的依存关系配置良好。 因此,不会花费很多时间解决许多简单的错误,您可以将时间花在训练开发上,而不是修正错误以开始训练。
在以下部分中,将提供逐步指南,以建立训练组合。 可以在这个页面中找到代码的详细信息。
将图像收集并格式化为.jpg文件
本节介绍如何处理图像,使其具有相同的格式和大小。 步骤在这里列出:
-
了解您要使用的类数量,并确保图像具有相等的类分布。 这意味着,例如,如果我们要使用两个类别(
burger和french fries),则图像应包含大约三分之一的汉堡包,三分之一的薯条,以及三分之一两者的混合。 仅具有汉堡的图像和炸薯条的图像而不包含组合的图像是不好的。 -
确保图像包含不同的方向。 对于具有均匀形状的图像(例如汉堡的圆形)或具有不均匀形状(例如炸薯条)的图像,方向无关紧要,但是对于特定形状(例如汽车,钢笔和船形),不同的方向至关重要。
-
将所有图像转换为
.jpg格式。 -
调整所有图像的大小以供神经网络快速处理。 在此示例中,考虑
416x416图像大小。 在 Linux 中,您可以使用 ImageMagick 批量调整图像大小。 -
转换
file.jpg-将其调整为416x416图像尺寸file.jpg。 -
将图像重命名为
classname_00x.jpg格式。
例如,dec2f2eedda8e9.jpg应该转换为burger_001.jpg。 将所有图像保存在一个文件夹中。 由于我们的图像包含一个汉堡,炸薯条和一个组合,并且我们的文件总数为 100,因此对于图像文件名,请创建burger_001 …burger_030.jpg,fries_031 …fries_060.jpg和comb_061 …comb_100.jpg三个类。
标注图像来创建.xml文件
在本节中,我们将描述如何创建标注文件。 每个图像文件对应一个标注文件。 标注文件通常为.xml格式。 此处描述了创建标注文件的步骤:
- 在此步骤中,使用
labelImg创建标注文件。 此步骤已经在“第 7 章”,“使用 YOLO 的对象检测”中进行了讨论,但此处再次重复。 使用终端命令pip install labelImg下载labelImg。 - 下载后,只需在终端中键入
labelImg即可打开。 - 定义源(
.jpg文件)和目标(.xml文件)目录。 - 选择每个图像并在其周围绘制一个矩形。 定义类名称并保存。
- 如果给定图像中有多个类别,则在每个图像周围绘制一个矩形,并为其分配相关的类别名称。
通常,人们会犯这样的错误:仅在一个类上绘制一个矩形,然后跳过另一个类。 这将导致在推理过程中仅检测到一个类别。
此屏幕快照显示了我们如何在一张图像中标记两个类:

这显示了两个类别-burger和fries-以及如何使用labelImg在它们周围绘制边框。 labelImg的输出是.xml文件,该文件存储在单独的文件夹中。
每个.xml文件中都有相应的.jpg文件。 因此,如果稍后手动更改labelImg文件名,则文件系统将无法工作,您必须再次重新运行labelImg。 同样,如果在labelImg操作之后调整图像大小,则标注文件的位置将更改,并且您将必须重新运行labelImg。
通过训练和测试文件夹分隔文件
在本节中,我们将数据集分为train和test文件夹。 这是必需的,因为train模型使用train数据集生成模型,并使用test数据集进行验证。 请注意,有时test和val名称可以互换使用来表示同一事物。 但是总的来说,我们需要第三个文件夹来检查最终模型是否与该模型以前未见过的一些未知图像相对应。 包含这些图像的文件夹称为val-稍后将进行讨论。
请按照此处列出的步骤将图像分成train和test文件夹。 请注意,这些任务将在 Google Colab 上完成:
- 如果执行上述步骤,则将有两个文件夹-一个用于图像,一个用于标注。 接下来,我们创建两个单独的文件夹-
train和test。 - 将所有
.jpg和.xml文件复制到任何文件夹中。 因此,现在该文件夹将包含背对背.jpg和.xml文件。 - 将文件名类的 70% 的文件(
.jpg和相应的.xml文件)复制到train文件夹中。 因此,完成本练习后,train文件夹中将有大约 140 个文件(70 个.jpg文件和 70 个.xml文件)。 - 将剩余的 30% 的文件复制到
test文件夹中。 - 将
train和test文件夹都上传到data下的 Google 云端硬盘。 - 创建一个标题为
val的验证文件夹,并将所有类中的一些图像插入其中。
请注意,在此示例中,在train和test文件夹之间使用了 70/30 的比例,但是通常,数字范围可以从 90/10 到 70/30。
- 在“我的云端硬盘”下(如以下屏幕截图所示),创建一个名为
Chapter10_R-CNN的文件夹,然后在其中创建一个名为data的文件夹:

- 创建
data文件夹后,在 Google 云端硬盘中在其中创建两个名为annotations和images的新文件夹,如图所示。 下一个任务是填充这些目录。
此屏幕快照显示了Chapter10_R-CNN中的目录结构和命名约定:

如上图所示的目录结构应在 Google 云端硬盘中建立。 请按照此处描述的格式开始使用:
- INPUT 代表
images文件夹,需要提供所有图像数据。 请记住要遵循前面的图中概述的命名约定,并将.jpg文件和.xml文件上传到相应的目录,如上图所示。
由于大小限制,我们无法将图像数据上传到 GitHub 站点。 因此,本部分中使用的图像可以从这里的 Kaggle 食品图像(用于汉堡和薯条样本)下载。 电话并上传。
annotations是输出文件夹,应为空,并将在下一部分中填写。 不要将annotations文件夹与标注图像混淆以创建.xml文件。 所有.xml文件都放在images文件夹中。
配置参数并安装所需的包
现在我们的图像准备工作已经完成,我们将开始在 Google Colab 笔记本中进行编码。 第一步是参数配置和获取训练工作所需的包,这涉及模型的类型,训练参数等等。 请按照以下步骤执行此操作:
- 在继续下一步之前,请将
Chapter10_Tensorflow-Training_a_Object_Detector_GoogleColab.ipynbPython 文件保存到 Google 云端硬盘,然后将其作为 Colab 笔记本打开。 - 运行单元格
Configure参数,然后通过按Shift + Enter安装所需的包。 - 如果一切正常,则应该在以下代码块中看到显示模型配置选择的输出。 以下输出从
config参数创建测试模型,这是开始构建数据并准备进行测试之前的先决条件:
Running tests under Python 3.6.9: /usr/bin/python3
[ RUN ] ModelBuilderTest.test_create_experimental_model
[ OK ] ModelBuilderTest.test_create_experimental_model
[ RUN ] ModelBuilderTest.test_create_faster_R-CNN_model_from_config_with_example_miner
[ OK ] ModelBuilderTest.test_create_faster_R-CNN_model_from_config_with_example_miner
[ RUN ] ModelBuilderTest.test_create_faster_R-CNN_models_from_config_faster_R-CNN_with_matmul
[ OK ] ModelBuilderTest.test_create_faster_R-CNN_models_from_config_faster_R-CNN_with_matmul
[ RUN ] ModelBuilderTest.test_create_faster_R-CNN_models_from_config_faster_R-CNN_without_matmul
[ OK ] ModelBuilderTest.test_create_faster_R-CNN_models_from_config_faster_R-CNN_without_matmul
[ RUN ] ModelBuilderTest.test_create_faster_R-CNN_models_from_config_mask_R-CNN_with_matmul
[ OK ] ModelBuilderTest.test_create_faster_R-CNN_models_from_config_mask_R-CNN_with_matmul
[ RUN ] ModelBuilderTest.test_create_faster_R-CNN_models_from_config_mask_R-CNN_without_matmul
[ OK ] ModelBuilderTest.test_create_faster_R-CNN_models_from_config_mask_R-CNN_without_matmul
[ RUN ] ModelBuilderTest.test_create_rfcn_model_from_config
[ OK ] ModelBuilderTest.test_create_rfcn_model_from_config
[ RUN ] ModelBuilderTest.test_create_ssd_fpn_model_from_config
[ OK ] ModelBuilderTest.test_create_ssd_fpn_model_from_config
[ RUN ] ModelBuilderTest.test_create_ssd_models_from_config
[ OK ] ModelBuilderTest.test_create_ssd_models_from_config
[ RUN ] ModelBuilderTest.test_invalid_faster_R-CNN_batchnorm_update
[ OK ] ModelBuilderTest.test_invalid_faster_R-CNN_batchnorm_update
[ RUN ] ModelBuilderTest.test_invalid_first_stage_nms_iou_threshold
[ OK ] ModelBuilderTest.test_invalid_first_stage_nms_iou_threshold
[ RUN ] ModelBuilderTest.test_invalid_model_config_proto
[ OK ] ModelBuilderTest.test_invalid_model_config_proto
[ RUN ] ModelBuilderTest.test_invalid_second_stage_batch_size
[ OK ] ModelBuilderTest.test_invalid_second_stage_batch_size
[ RUN ] ModelBuilderTest.test_session
[ SKIPPED ] ModelBuilderTest.test_session
[ RUN ] ModelBuilderTest.test_unknown_faster_R-CNN_feature_extractor
[ OK ] ModelBuilderTest.test_unknown_faster_R-CNN_feature_extractor
[ RUN ] ModelBuilderTest.test_unknown_meta_architecture
[ OK ] ModelBuilderTest.test_unknown_meta_architecture
[ RUN ] ModelBuilderTest.test_unknown_ssd_feature_extractor
[ OK ] ModelBuilderTest.test_unknown_ssd_feature_extractor
----------------------------------------------------------------------
Ran 17 tests in 0.157s
OK (skipped=1)
创建 TensorFlow 记录
这是非常重要的一步,我们许多人为此奋斗。 请按照以下步骤创建您的tfRecord文件。 您必须在上一步中安装所有必需的包,然后才能继续执行此步骤:
- 在上图中的
Chapter10_R-CNN文件夹下,data下有两个文件名为xml_to_csv.py并生成tfrecord.py。 这些文件应从本地驱动器复制到 Google 云端硬盘。 - 当您使用
pip install TensorFlow或pip install tensorflow-gpu安装 TensorFlow 时,它将在home目录下创建一个models-master目录。 在其中,导航到research文件夹,然后导航到object_detection文件夹,您将找到xml_to_csv.py并生成tfrecord.py。 如前所述,将它们复制并插入 Google 云端硬盘。 您还可以在本地运行以下步骤,但是使用 TensorFlow 2.0 在本地运行时,我注意到错误,因此对于本练习,我们将在 Google Colab 中运行它。 - 接下来,我们将 Google 云端硬盘中的
Chapter10_R-CNN文件夹链接到您的 Colab 笔记本。 这是通过使用以下命令完成的:
from google.colab import drive
drive.mount('/content/drive')
- 完成上述步骤后,系统将提示您输入 Google Drive 密钥,然后在输入密钥后将 Google Drive 装入 Colab 笔记本。
- 接下来,我们使用以下命令从 Colab 笔记本转到 Google 云端硬盘
Chapter10_R-CNN目录:
%cd /content/drive/My Drive/Chapter10_R-CNN
- 现在,您可以执行以下步骤来生成
tfRecord文件。 - 完全按照所示输入命令。 此命令将所有
.xml文件从train数据转换为data/annotations文件夹中的train_labels.csv文件:
!python xml_to_csv.py -i data/images/train -o data/annotations/train_labels.csv -l data/annotations
- 此命令将所有
.xml文件从test数据转换为data/annotations文件夹中的test_labels.csv文件:
!python xml_to_csv.py -i data/images/test -o data/annotations/test_labels.csv
- 该命令从
train_labels.csv生成train.record文件,从train文件夹生成图像jpg文件。 它还会生成lable_map.pbtxt文件:
!python generate_tfrecord.py --csv_input=data/annotations/train_labels.csv --output_path=data/annotations/train.record --img_path=data/images/train --label_map data/annotations/label_map.pbtxt
- 该命令从
test_labels.csv生成test.record文件,从test文件夹生成图像jpg文件。 它还会生成lable_map.pbtxt文件:
!python generate_tfrecord.py --csv_input=data/annotations/test_labels.csv --output_path=data/annotations/test.record --img_path=data/images/test --label_map data/annotations/label_map.pbtx
- 如果一切顺利,那么前面的代码行将生成以下输出。 这表示成功生成了训练和测试
tfRecord文件。 请注意,扩展名可以是tfRecord或record:
/content/drive/My Drive/Chapter10_R-CNN
Successfully converted xml to csv.
Generate `data/annotations/label_map.pbtxt`
Successfully converted xml to csv.
WARNING:tensorflow:From generate_tfrecord.py:134: The name tf.app.run is deprecated. Please use tf.compat.v1.app.run instead.
WARNING:tensorflow:From generate_tfrecord.py:107: The name tf.python_io.TFRecordWriter is deprecated. Please use tf.io.TFRecordWriter instead.
W0104 13:36:52.637130 139700938962816 module_wrapper.py:139] From generate_tfrecord.py:107: The name tf.python_io.TFRecordWriter is deprecated. Please use tf.io.TFRecordWriter instead.
WARNING:tensorflow:From /content/models/research/object_detection/utils/label_map_util.py:138: The name tf.gfile.GFile is deprecated. Please use tf.io.gfile.GFile instead.
W0104 13:36:52.647315 139700938962816 module_wrapper.py:139] From /content/models/research/object_detection/utils/label_map_util.py:138: The name tf.gfile.GFile is deprecated. Please use tf.io.gfile.GFile instead.
Successfully created the TFRecords: /content/drive/My Drive/Chapter10_R-CNN/data/annotations/train.record
WARNING:tensorflow:From generate_tfrecord.py:134: The name tf.app.run is deprecated. Please use tf.compat.v1.app.run instead.
WARNING:tensorflow:From generate_tfrecord.py:107: The name tf.python_io.TFRecordWriter is deprecated. Please use tf.io.TFRecordWriter instead.
W0104 13:36:55.923784 140224824006528 module_wrapper.py:139] From generate_tfrecord.py:107: The name tf.python_io.TFRecordWriter is deprecated. Please use tf.io.TFRecordWriter instead.
WARNING:tensorflow:From /content/models/research/object_detection/utils/label_map_util.py:138: The name tf.gfile.GFile is deprecated. Please use tf.io.gfile.GFile instead.
W0104 13:36:55.933046 140224824006528 module_wrapper.py:139] From /content/models/research/object_detection/utils/label_map_util.py:138: The name tf.gfile.GFile is deprecated. Please use tf.io.gfile.GFile instead.
Successfully created the TFRecords: /content/drive/My Drive/Chapter10_R-CNN/data/annotations/test.reco
准备模型并配置训练管道
接下来,使用以下命令下载并解压缩基本模型。 在“配置参数和安装所需包”部分的配置参数步骤中,已选择模型和相应的配置参数。 可以根据配置参数和批量大小选择四种不同的模型(SSD,Faster R-CNN 和 R-FCN 的两种变体)。 您可以从指示的批量大小开始,并在模型优化期间根据需要进行调整:
MODEL_FILE = MODEL + '.tar.gz'
DOWNLOAD_BASE = 'http://download.tensorflow.org/models/object_detection/'
DEST_DIR = '/content/models/research/pretrained_model'
在这里,目标目录是 Google Colab 笔记本本身,content/models/research目录就在其中-因此,无需自己创建一个目录。 当您安装所需的包部分时,便完成了此操作。
此步骤还将从您的label_map.pbtxt文件中自动下载许多类,并调整大小,比例,长宽比和卷积超参数,以准备进行训练。
使用 TensorBoard 监控训练进度
TensorBoard 是用于实时监控和可视化训练进度的工具。 它可以绘制训练损失和准确率的图表,因此无需手动绘制。 TensorBoard 允许您可视化模型图并具有许多其他功能。 访问这里,以了解有关 TensorBoard 功能的更多信息。
在本地计算机上运行的 TensorBoard
通过添加以下代码行,可以将 TensorBoard 添加到模型训练中。 检查 GitHub 页面上提供的代码以获取确切位置:
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)
history = model.fit(x=x_train, y=y_train, epochs=25, validation_data=(x_test, y_test), callbacks=[tensorboard_callback])
然后,可以在训练开始后通过在终端中键入以下内容来可视化 TensorBoard 图:
%tensorboard --logdir logs/fit
在 Google Colab 上运行的 TensorBoard
本节介绍如何在 Google Colab 上运行 TensorBoard。 这涉及以下步骤:
- 为了在 Google Colab 上运行 TensorBoard,必须从本地 PC 访问 TensorBoard 页面。 这是通过名为 ngrok 的服务完成的,该服务将您的本地 PC 链接到 TensorBoard。 Ngrok 使用以下两行代码下载并提取到您的 PC 中:
!wget https://bin.equinox.io/c/4VmDzA7iaHb/ngrok-stable-linux-amd64.zip
!unzip ngrok-stable-linux-amd64.zip
- 接下来,使用以下代码打开 TensorBoard:
LOG_DIR = model_dir
get_ipython().system_raw(
'tensorboard --logdir {} --host 0.0.0.0 --port 6006 &
.format(LOG_DIR))
- 之后,调用
ngrok以使用端口6006启动 TensorBoard,该端口是用于通信和交换数据的迁移通信协议:
get_ipython().system_raw('./ngrok http 6006 &')
- 最后一步是使用以下命令设置公共 URL 以访问 Google Colab TensorBoard:
! curl -s http://localhost:4040/api/tunnels | python3 -c \
"import sys, json; print(json.load(sys.stdin)['tunnels'][0]['public_url'])"
训练模型
完成上述所有步骤后,我们已准备好进行最重要的步骤-训练自定义神经网络。
训练模型是通过以下五个步骤执行的,这些步骤也在代码中概述:
- 指定配置文件。
- 指定输出模型目录。
- 指定发送
STDERR文件的位置。 - 指定训练步骤数。
- 指定验证步骤的数量:
!python /content/models/research/object_detection/model_main.py \
--pipeline_config_path={pipeline_fname} \
--model_dir={model_dir} \
--alsologtostderr \
--num_train_steps={num_steps} \
--num_eval_steps={num_eval_steps}
此代码的说明如下:
- 管道配置路径由
pipeline_fname定义,这是模型和配置文件。 Model_dir是training目录。 注意TensorBoard LOG_DIR也映射到model_dir,因此 TensorBoard 在训练期间获取数据。- 训练和评估步骤的数量是在配置设置期间预先定义的,可以根据需要进行调整。
训练成功开始后,您将开始在 Jupyter 笔记本中查看消息。 在某些包上的某些警告被弃用之后,您将开始看到有关训练步骤的注解并成功打开了动态库:
INFO:tensorflow:Maybe overwriting train_steps: 1000
Successfully opened dynamic library libcudnn.so.7
Successfully opened dynamic library libcublas.so.10
INFO:tensorflow:loss = 2.5942094, step = 0
loss = 2.5942094, step = 0
INFO:tensorflow:global_step/sec: 0.722117
global_step/sec: 0.722117
INFO:tensorflow:loss = 0.4186823, step = 100 (138.482 sec)
loss = 0.4186823, step = 100 (138.482 sec)
INFO:tensorflow:global_step/sec: 0.734027
global_step/sec: 0.734027
INFO:tensorflow:loss = 0.3267398, step = 200 (136.235 sec)
loss = 0.3267398, step = 200 (136.235 sec)
INFO:tensorflow:global_step/sec: 0.721528
global_step/sec: 0.721528
INFO:tensorflow:loss = 0.21641359, step = 300 (138.595 sec)
loss = 0.21641359, step = 300 (138.595 sec)
INFO:tensorflow:global_step/sec: 0.723918
global_step/sec: 0.723918
INFO:tensorflow:loss = 0.16113645, step = 400 (138.137 sec)
loss = 0.16113645, step = 400 (138.137 sec)
INFO:tensorflow:Saving checkpoints for 419 into training/model.ckpt.
model.ckpt-419
INFO:tensorflow:global_step/sec: 0.618595
global_step/sec: 0.618595
INFO:tensorflow:loss = 0.07212131, step = 500 (161.657 sec)
loss = 0.07212131, step = 500 (161.657 sec)
INFO:tensorflow:global_step/sec: 0.722247
] global_step/sec: 0.722247
INFO:tensorflow:loss = 0.11067433, step = 600 (138.457 sec)
loss = 0.11067433, step = 600 (138.457 sec)
INFO:tensorflow:global_step/sec: 0.72064
global_step/sec: 0.72064
INFO:tensorflow:loss = 0.07734648, step = 700 (138.765 sec)
loss = 0.07734648, step = 700 (138.765 sec)
INFO:tensorflow:global_step/sec: 0.722494
global_step/sec: 0.722494
INFO:tensorflow:loss = 0.088129714, step = 800 (138.410 sec)
loss = 0.088129714, step = 800 (138.410 sec)
INFO:tensorflow:Saving checkpoints for 836 into training/model.ckpt.
I0107 15:44:16.116585 14036592158
INFO:tensorflow:global_step/sec: 0.630514
global_step/sec: 0.630514
INFO:tensorflow:loss = 0.08999817, step = 900 (158.601 sec)
loss = 0.08999817, step = 900 (158.601 sec)
INFO:tensorflow:Saving checkpoints for 1000 into training/model.ckpt.
Saving checkpoints for 1000 into training/model.ckpt.
INFO:tensorflow:Skip the current checkpoint eval due to throttle secs (600 secs).
Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.505
Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.915
Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.493
Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000
Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.200
Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.509
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.552
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.602
Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.611
Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = -1.000
Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.600
Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.611
SavedModel written to: training/export/Servo/temp-b'1578412123'/saved_model.pb
INFO:tensorflow:Loss for final step: 0.06650969.
Loss for final step: 0.06650969.
请注意前面显示的输出。 根据您的 CPU/GPU 功能,执行此步骤将花费不同的时间。 在前面的训练输出中要注意的最重要的事情是训练期间的准确率和召回率值。
运行推理测试
此步骤涉及导出训练有素的推理图并运行推理测试。 推断是使用以下 Python 命令完成的:
!python /content/models/research/object_detection/export_inference_graph.py \
--input_type=image_tensor \
--pipeline_config_path={pipeline_fname} \
--output_directory={output_directory} \
--trained_checkpoint_prefix={last_model_path}
此处,last_model_path是model_dir,其中在训练期间存储模型检查点,而pipeline_fname是模型路径和配置文件。 检查点涵盖训练过程中模型使用的参数值。 下图显示了训练期间开发的四种不同模型的输出。 通过执行上述步骤并仅选择不同的模型类型,它们可以逐一运行:

请注意,前面提到的带有代码块的模型针对四种不同的模型运行。 在运行下一个模型之前,请单击 Google Colab 页面顶部的“运行时”,然后选择“工厂重置运行时”,以便为新模型重新开始。 请注意,SSD 模型仍然无法正确检测对象,而 R-CNN 和 R-FCN 则可以正确检测汉堡和薯条。 这可能是由于汉堡和薯条的大小几乎相同,并且我们从 SSD 概述中了解到 SSD 可以更好地检测不同比例的图像。
设置 TensorBoard 后,可以在 TensorBoard 中可视化输出。
TensorBoard 具有三个选项卡-标量,图像和图。 标量包括 mAP(精度),召回率和损失值,图像包括先前的视觉图像,图包括 TensorFlow 图frozen_inference_graph.pb文件。 请注意,精度和召回率之间的差异定义如下:
精度 = 真正 / (真正 + 假正)召回 = 真正 / (真正 + 假负)
使用神经网络模型时的注意事项
请注意,我们仅使用 68 张图像来训练我们的神经网络,它给了我们很好的预测。 这提出了四个问题:
- 我们开发的模型在所有情况下都能正确预测吗? 答案是不。 该模型只有
burger和fries两类,因此它可以检测其他与汉堡形状类似的对象,例如甜甜圈。 要解决此问题,我们需要加载类似于burger的图像并将其分类为非burger,然后使用这些其他图像集训练模型。 - 为什么我们听到我们需要成千上万张图像来训练神经网络? 如果您是从头开始训练神经网络,或者甚至是使用迁移学习从另一个模型(例如 Inception 或 ResNet)中获取权重,但是该模型之前从未看到过您的新图像,那么您将需要至少 1,000 幅图像。 1,000 个来自 ImageNet 数据集,每个类具有 1,000 个图像。
- 如果我们需要数千张图像进行训练,那么为什么在我们的案例中它可以工作? 在我们的案例中,我们使用了迁移学习并下载了 ImageNet 数据集的权重。 ImageNet 数据集已经将
cheeseburger作为一类,因此对少于 100 张图像的迁移学习效果很好。 - 在使用少于 1000 张图像开发模型的情况下,什么时候根本不会检测到任何物体? 在对象与 ImageNet 类中的任何对象都非常不同的情况下,例如,检测到车身上的刮擦,红外图像等时。
Mask R-CNN 概述和 Google Colab 演示
Mask R-CNN 由 Kaiming He,Georgia Gkioxari,Piotr Dollar 和 Ross Girshick 在 CVPR 2017 中提出。Mask R-CNN 使用 R-CNN 有效地检测图像中的对象,同时针对每个兴趣区域进行对象分割任务。 因此,分割任务与分类和边界框回归并行工作。 Mask R-CNN 的高级架构如下:

Mask R-CNN 实现的详细信息如下:
- 掩码 R-CNN 遵循 Faster R-CNN 的一般两阶段原理,但进行了修改—第一阶段 RPN 与 Faster R-CNN 相同。 第二阶段,快速 R-CNN,它从兴趣区域(RoI)中进行特征提取,分类和边界框回归开始,还为每个 RoI 输出二进制掩码 。
- 遮罩代表输入对象的空间形状。 掩码 R-CNN 使用完全卷积网络进行语义分割,为每个 RoI 预测一个(
M x N)掩码。 - 将特征映射划分为
M x N网格后,将 RoI Align 应用于区域提议网络的输出,然后在每个箱子中应用2 x 2箱子和四个采样点 ,使用双线性插值选择。 RoI Align 用于将提取的特征与输入对齐。 - 骨干神经网络通过提取第四阶段的最后卷积层来使用 ResNet-50 或 101。
- 重新调整训练图像的大小,使较短的边缘为 800 像素。 每个微型批量每个 GPU 具有两张图像,正样本与负样本的比例为 1:3。 训练持续进行 160,000 次迭代,学习率
0.02高达 120,000 次迭代,然后下降到0.002。 使用0.0001的权重衰减和0.9的动量。
Mask R-CNN 图像分割演示是用 Google Colab 编写的。
笔记本电脑加载示例图像并通过激活 TPU 创建 TensorFlow 会话。 然后加载预训练的模型蒙版 R-CNN,然后执行实例分割和预测。 该笔记本取自 Google Colab 网站,仅作了一项修改-图像加载函数。 下图显示了 Mask R-CNN 的输出:

Mask R-CNN 在前面概述的 Coco 数据集上进行了训练。 因此,human,car和traffic light已经是为此预定的类。 每个人,汽车和交通信号灯都使用边界框进行检测,并使用分段绘制形状。
开发对象跟踪器模型来补充对象检测器
对象跟踪从对象检测开始,为每次检测分配一组唯一的 ID,并在对象四处移动时保持该 ID。 在本节中,将详细描述不同类型的对象跟踪模型。
基于质心的跟踪
顾名思义,基于质心的跟踪涉及跟踪使用阈值处理开发的图像群集的质心。 在初始化时,将 ID 分配给边界框形心。 在下一帧中,通过查看两个帧之间的相对距离来分配 ID。 当对象相距很远时此方法有效,但是当对象彼此非常靠近时该方法不起作用。
SORT 跟踪
SORT 是由 Alex Bewley,Zongyuan Ge,Lionel Ott,Fabio Ramos 和 Ben Upcroft 在其名为《简单在线和实时跟踪》的论文中提出的。 本文使用 Faster R-CNN 进行检测,而卡尔曼过滤器和匈牙利算法用于多目标跟踪(MOT)进行实时。 跟踪实现的详细信息可以在这个页面中找到。
DeepSORT 跟踪
在 CVPR 2017 上,Nicolai Wojke,Alex Bewley 和 Dietrich Paulus 在他们的论文中提出了 DeepSORT 跟踪,其论文标题为《使用深度关联指标的简单在线和实时跟踪》。 可以在这个页面中找到该论文的详细信息。
DeepSORT 是 SORT 的扩展,并使用经过训练以区分行人的 CNN 将外观信息集成到边界框中。 跟踪实现的详细信息可以在这个页面中找到。
该架构的细节概述如下:
- 跟踪方案是在八维状态空间
(u, v, γ, h, x, y, γ, h)上定义的,其中(u, v)是边界框中心位置,γ是长宽比,h是高度。 - 卡尔曼过滤器根据当前位置和速度信息预测未来状态。 在 DeepSORT 中,基于位置和速度的卡尔曼过滤器用于查找下一个跟踪位置。
- 对于每个轨道
k,在卡尔曼过滤器预测期间对帧数进行计数和递增,并在对象检测期间将其重置为0。 删除在前三个帧内超过阈值或与检测无关的轨道。 - 预测的卡尔曼状态与新到达的测量值之间的关联通过两种状态(预测的测量值和新的测量值)之间的马氏距离和外观描述符之间的余弦相似度的组合来解决。
- 引入了一个匹配的级联,该优先级优先于更常见的对象。
- 计算 IoU 关联以说明场景中突然消失的情况。
- 减少深度和增加宽度的广泛 ResNet 神经网络已用于改善薄残差网络上的表现。 宽的 ResNet 层具有两个卷积层和六个残差块。
- DeepSort 使用对 1,251 位行人的 110 万张人类图像进行训练的模型,并为每个边界框提取 128 个暗淡向量,以进行特征提取。
OpenCV 跟踪方法
OpenCV 具有许多内置的跟踪方法:
- BOOSTING 跟踪器:基于 Haar 级联的旧跟踪器。
- MIL 跟踪器:比 BOOSTING 跟踪器具有更高的准确率。
- 核相关过滤器(KCF)跟踪器:这比 BOOSTING 和 MIL 跟踪器快。
- CSRT 跟踪器:这比 KCF 更为准确,但跟踪速度可能较慢。
- MedianFlow 跟踪器:当对象有规律的运动并且在整个序列中可见时,此跟踪器将起作用。
- TLD 跟踪器:请勿使用。
- MOSSE 跟踪器:非常快速的跟踪器,但不如 CSRT 或 KCF 准确。
- GOTURN 跟踪器:基于深度学习的对象跟踪器。
OpenCV 中上述方法的实现如下:
tracker = cv2.TrackerBoosting_create()
tracker = cv2.TrackerCSRT_create()
tracker = cv2.TrackerKCF_create()
tracker = cv2.TrackerMedianFlow_create()
tracker = cv2.TrackerMIL_create()
tracker = cv2.TrackerMOSSE_create()
tracker = cv2.TrackerTLD_create()
基于连体网络的跟踪
Luca Bertinetto,Jack Valmadre,Joao F. Henriques,Andrea Vedaldi 和 Philip HS Torr 在其具有里程碑意义的论文《用于目标跟踪的全卷积连体网络》中提出了基于连体网络的对象跟踪。 可以在这个页面上找到该论文的详细信息。
在本文中,作者训练了一个深度卷积网络以离线开发相似性函数,然后将其应用于实时对象跟踪。 相似度函数是连体 CNN,将测试边界框与训练边界框(真实情况)进行比较并返回高分。 如果两个边界框包含相同的对象且分数较低,则对象不同。
连体网络通过相同的神经网络传递两个图像。 它通过删除最后一个全连接层来计算特征向量,这在“第 6 章”,“使用迁移学习的视觉搜索”中进行了描述。 然后比较两个特征向量的相似性。 所使用的连体网络没有任何全连接层。 因此,仅使用卷积过滤器,因此网络相对于输入图像是完全卷积的。 全卷积网络的优点是它与大小无关。 因此,任何输入尺寸均可用于test和train图像。 下图说明了连体网络的架构:

在该图中,网络的输出是特征映射。 通过 CNN(f[θ])重复该过程两次,一次分别进行测试(x)和训练(z)。 图像,生成两个相互关联的特征映射,如下所示:
g[θ](z, x) = f[θ](z) * f[θ](x)
跟踪开始如下:
初始图像位置 = 先前的目标位置位移 = 跨步乘以最大得分相对于中心的位置新位置 = 初始位置 + 位移
因此,矩形边界框用于初始化目标。 在每个后续帧,使用跟踪来估计其位置。
基于 SiamMask 的跟踪
在 CVPR 2019 上,王强,张立,Luca Bertinetto,胡卫明和 Phillip H.S.Torr 在他们的论文《快速在线对象跟踪和分段:统一方法》中提出了 SiamMask。 有关本文的更多详细信息,请参见这里。
SiamMask 使用单个边界框初始化并以每秒 55 帧的速度跟踪对象边界框。
在此,将连体网络的简单互相关替换为深度相关,以生成多通道响应图:
- 使用简单的两层
1 x 1卷积神经网络hf设计w x h二元掩码(每个特征映射一个)。 第一层具有 256 个通道,第二层具有1 x 1通道。 - ResNet-50 用于 CNN,直到第三阶段结束为止,最后以
1 x 1卷积层结束。 请注意,ResNet-50 具有四个阶段,但仅考虑了前三个阶段,并且对跨步 1 的卷积进行了修改,以将输出跨步减小到 8。 - 在 DeepLab 中使用了扩张的(无意义的)卷积(在 “第 8 章”,“语义分割和神经样式迁移”中进行了详细描述)以增加接收场。 ResNet 第三阶段的最终输出附加了具有 256 个输出的
1 x 1卷积。
可在这里 上找到有关 SiamMask 实现以及训练的详细信息。 SiamMask 也可以在这个页面上使用。 请注意,为了使其成功运行,视频文件必须以人像开头。
总结
在本章中,您将从头到尾全面了解各种对象检测器方法以及使用自己的自定义图像训练对象检测器的实用方法。 学习到的一些关键概念包括如何与 Google Cloud 一起使用以评估对象检测器,如何使用labelImg创建标注文件,如何将 Google Drive 链接到 Google Colab 笔记本以读取文件,如何生成 TensorFlow .xml和.jpg文件中的tfRecord文件,如何开始训练过程并在训练过程中监控读数,如何创建 TensorBoard 以观察训练准确率,如何在训练后保存模型以及如何通过保存的模型进行推断。 使用这种方法,您可以选择对象类并创建用于推理的对象检测模型。 您还学习了各种对象跟踪技术,例如 Kalman 滤波和基于神经网络的跟踪,例如 DeepSORT 和基于连体网络的对象跟踪方法。 下一步,可以将对象检测模型连接到跟踪方法以跟踪检测到的对象。
在下一章中,我们将通过在边缘设备(例如手机)中优化和部署神经网络模型来学习边缘计算机视觉。 我们还将学习如何使用 Raspberry Pi 进行实时对象检测。
十一、带有 CPU/GPU 优化的边缘设备上的深度学习
到目前为止,我们已经学习了如何通过预处理数据,训练模型以及使用 Python PC 环境生成推论来开发深度学习模型。
在本章中,我们将学习如何采用生成的模型并将其部署在边缘设备和生产系统上。 这将导致完整的端到端 TensorFlow 对象检测模型实现。 本章将讨论许多边缘设备及其标称性能和加速技术。
特别是,使用 TensorFlow Lite 和 Intel 开放视觉推断和神经网络优化(VINO)架构,并部署到 Raspberry Pi,Android 和 iPhone。 尽管本章主要关注 Raspberry Pi,Android 和 iPhone 上的对象检测,但我们将介绍的方法可以扩展到图像分类,样式迁移和所考虑的任何边缘设备的动作识别。
本章分为以下几节:
- 边缘设备上的深度学习概述
- 用于 GPU/CPU 优化的技术
- MobileNet 概述
- 使用 Raspberry Pi 进行图像处理
- 使用 OpenVINO 进行模型转换和推理
- TensorFlow Lite 的应用
- 使用 TensorFlow Lite 在 Android 上进行对象检测
- 使用 TensorFlow Lite 在 Raspberry Pi 上进行对象检测
- 使用 TensorFlow Lite 和 Create ML 在 iPhone 上进行对象检测
- 各种标注方法的摘要
边缘设备上的深度学习概述
对于计算机而言,边缘是查看事物并测量参数的最终设备。 在边缘设备上进行深度学习意味着将 AI 注入到边缘设备中,以便与视觉一起还可以分析图像并报告其内容。 用于计算机视觉的边缘设备的示例是照相机。 边缘计算使本地图像识别快速有效。 摄像头内的 AI 组件由功能强大的微型处理器组成,该处理器具有深度学习功能。
取决于所使用的硬件和软件平台的选择,边缘的 AI 可以执行三种独立功能的组合:
- 硬件加速使设备运行更快
- 软件优化可减小模型尺寸并删除不必要的组件
- 与云交互来批量处理图像和张量
这样做的好处是提高了速度,减少了带宽,增加了数据保密性和网络可伸缩性。 这是通过在相机内部嵌入一个控制器来赋予相机所需的处理能力来完成的。
边缘计算意味着将工作负载从云转移到设备。 这就需要高效的边缘设备,优化的软件来执行检测而不会出现明显的延迟,以及高效的数据传输协议,以将选择的数据发送到云中进行处理,然后将输出反馈到边缘设备以进行实时决策。 选择正确的边缘设备取决于您的应用要求及其与子系统其余部分的接口方式。 边缘设备的一些示例如下:
- NVIDIA Jetson Nano
- Raspberry Pi + Intel 神经网络棒
- Coral 开发板 + Coral USB 加速器
- Orange Pi + Intel 神经网络棒
- ORDOID C2
- Android 手机
- iOS 手机
下表总结了前面列出的各种边缘设备的性能规格。 您可以使用此表来确定选择过程:
| 装置 | GPU | CPU | 内存 | 加速器 |
|---|---|---|---|---|
| NVIDIA Jetson Nano 69 毫米 x 45 毫米 | 128 核 NVIDIA Maxwell | 四核 ARM Cortex A57 | 4 GB RAM,16 GB 存储 | 并行处理器 |
| Raspberry Pi 4 85 毫米 x 56 毫米 | 1.5 GHz 时的 ARM Cortex A72 | 4 GB RAM,32 GB 存储 | ||
| Coral 开发板 48 毫米 x 40 毫米 | 集成的 GC7000 Lite 图形 | 四核 Cortex-A53,加上 Cortex-M4F | 1 GB LPDDR4 | Google Edge TPU ML 加速器协处理器 |
| Orange Pi 85 毫米 x 55 毫米 | ARM Mali-400 MP2 GPU @ 600MHz | 4 个 Cortex-A7 @ 1.6 GHz | 1 GB DDR3 SDRAM | |
| ORDOID C2 85 毫米 x 56 毫米 | Mali 450MP3 | ARM Cortex-A53 四核 @ 1.5 GHz | 2 GB DDR3 SDRAM | |
| 英特尔神经网络棒 | 英特尔 Movidius Myriad X 视觉处理单元(VPU),具有 16 个处理核心和一个网络硬件加速器 | 英特尔 OpenVINO 工具包 | ||
| Coral USB 加速器 | Google Edge TPU ML 加速器协处理器,支持 AUTOML Vision Edge | TensorFlow Lite 模型支持 | ||
| Android Pixel XL 155 毫米 x 76 毫米 | Ardeno 530 | 2 个 2.15 GHz Kryo 和 2 个 1.6 GHz Kryo | 4 GB 内存 | |
| iPhone XR 155 毫米 x 76 毫米 | A12 仿生芯片 | A12 仿生芯片 | 3 GB 内存 |
用于 GPU/CPU 优化的技术
中央处理器(CPU)主要执行串行处理,而图形处理器(GPU)并行运行进程并且可以一次执行大量操作,从而加快了处理速度。 GPU 中的数据称为线程。 使用计算统一设备架构(CUDA)和开放计算语言(OpenCL)对 GPU 进行编程。 CPU 执行许多不同类型的计算,而 GPU 专门处理给定的计算,例如图像处理。 为了使边缘设备提供无延迟的结果,它们必须伴随加速器,GPU 和软件优化。
以下是一些通常用于 GPU/CPU 优化的方法:
- 模型优化方法,例如图像大小,批量归一化,梯度下降等。
- 基于幅度的权重修剪通过将模型权重清零来使模型稀疏,从而使其更易于压缩。 请参阅以下链接以了解修剪技术。
- GPU 内存分区,例如 NVIDIA Jetson Nano。
- 使用用于英特尔神经网络棒的通用 API,在 CPU,GPU 和 FPGA 上进行异构计算。
- SWAP 空间为 RAM 内存分配磁盘空间。
- 将张量处理单元(TPU)与 CPU 或 GPU 结合使用。 CPU 依次执行算术运算,而 GPU 一次执行多个算术运算。 TPU 由 Google 开发,用于加速神经网络处理。 在 TPU 中,算术运算直接相互连接,而无需使用任何内存。
- 量化,即将权重从 32 位转换为 8 位。
- iOS 手机使用不同的金属来访问 GPU,以加快图像处理速度。 有关更多详细信息,请参阅这里。
- 对于 Android 手机,请参考 VR 性能基准以了解可用的 GPU/CPU 优化方法。
MobileNet 概述
Google 的一个团队在 CVPR 2017 中的题为《MobileNets:针对移动视觉应用的高效卷积神经网络》中介绍了 MobileNet。 您可以在这个页面上找到此 MobileNet 论文。
MobileNet 提出了一种深度可分离的卷积架构,该架构缩小了神经网络模型,以便可以处理边缘设备的资源限制问题。 MobileNet 架构包括两个主要部分:
- 深度可分离卷积
- 逐点
1 x 1卷积
请注意,我们在“第 4 章”,“图像深度学习”和“第 5 章”,“神经网络架构和模型”中描述了1 x 1卷积的重要性。 您可能需要重新阅读这些章节。
下图显示了深度卷积的工作方式:

在上图中,我们可以看到以下内容:
- 与普通卷积相比,我们减少了运算数量。
- 在 MobileNet 中,卷积层之后是批量归一化和 ReLU 非线性,最后一层除外,最后一层连接到 softmax 层进行分类。
- 可以通过深度乘法和分辨率乘法来减少 MobileNet 架构。
使用 Raspberry Pi 的图像处理
Raspberry Pi 是没有 GPU 的单板微型计算机,可以连接到外部相机和其他传感器模块,并且可以用 Python 编程以执行计算机视觉工作,例如目标检测。 Raspberry Pis 具有内置的 Wi-Fi,因此它们可以无缝连接到互联网以接收和传输数据。 由于其纤巧的外形和强大的计算能力,Raspberry Pi 是用于物联网和计算机视觉工作的边缘设备的完美示例。 可以在这个页面上找到有关 Raspberry Pi 的详细信息。 下图显示了 Raspberry Pi 的完整设置:

以下各节将介绍 Raspberry Pi 的详细硬件设置。
请注意,此图像将在以下设置部分中多次列出。
Raspberry Pi 硬件设置
以下是开始 Raspberry Pi 设置工作之前要考虑的一些重要点:
- 订购最新版本的 Raspberry Pi 4 –您可以直接从 Raspberry Pi 或从任何在线商店获取。
- 获得具有 4 GB RAM 和 32 GB MicroSD 卡的 Raspberry Pi。 在大多数情况下,Raspberry Pi 都带有用 NOOBS 编程的 MicroSD 卡。 订购前请检查一下。
- 如果您的 Raspberry Pi 没有随附编程的 MicroSD 卡,请购买 32 GB 的 MicroSD 卡,然后通过转到这里在其上安装 NOOBS。 为此,您必须在用于 PC 的 MicroSD 适配器中安装 MicroSD 卡,然后使用常规 PC 将 NOOBS 下载到该卡上。 编程后,从适配器中卸下 MicroSD 卡,然后将其插入 Raspberry Pi MicroSD 插槽,该插槽位于 Raspberry Pi 下方,在 USB 插槽的对角位置,靠近电源按钮。 有关更多信息,请参见上一节中显示的照片。
- 大多数 Raspberry Pi 都不随附相机模块,因此请单独订购。 摄像头模块端口位于 HDMI 端口旁边,HDMI 端口上有一个黑色塑料夹。 相机随附白色带状电缆。 您可以向上拉照相机模块中的黑色塑料夹,然后将白色带状电缆完全插入其中,以使发亮的表面朝向旁边的 HDMI 端口。 插入带状电缆后,将塑料夹完全向下推以将其关闭,以使带状电缆牢固地连接到摄像头模块端口。 有关更多信息,请参见上一节中的照片。
- 将鼠标电缆,键盘电缆和 HDMI 电缆连接到外接显示器。 请注意,这是可选的,因为您可以使用 PC 通过 Wi-Fi 连接来连接 Raspberry Pi。
- 购买 Intel Neural Network Stick 2 并将其插入 USB 端口之一。 请注意,英特尔神经网络棒占用了额外的宽度,因此您必须具有所有三个 USB 端口(神经网络棒,用于键盘的 USB 和用于鼠标的 USB)的创造力。
- 所有连接完成后,连接电源。 Raspberry Pi 中的红灯会亮起,旁边的绿灯会偶尔闪烁,表明 microSD 卡已打开电源。 这表明一切正常。 下一节将讨论如何设置相机。
Raspberry Pi 相机软件设置
在本节中,我们将研究为了建立用于计算机视觉的 Raspberry Pi 而需要的 Python 中的各个代码段。
我们可以将相机设置为视频播放器。 在 Raspberry Pi 终端中一一使用以下命令。 这些命令将进行必要的包更新,并启动新的 Raspbian 安装:
$sudo apt update
$sudo apt full-upgrade
$sudo raspi-config
输入最后一个命令后,Raspberry Pi 中将出现一些对话框。 选择必要的接口选项,选择一个摄像机,然后单击“是”是否要启用摄像机接口? 然后,重新启动 Raspberry Pi,并在启动后在终端中输入以下命令:
$raspivid -o video.h264 -t 10000
您会注意到视频录制了 10 秒钟并以video.h264格式保存。 第一次执行此操作时,您会发现相机未对准焦点。 调整相机上的圆帽(取下盖子后),直到其对准焦点。
到此结束如何设置相机软件。 如果要了解有关此过程的更多信息,请参考这里。
在 Raspberry Pi 中安装 OpenCV
有关详细说明,请转到这里。
在安装过程中,我发现必须在多个页面之间导航才能正确处理所有问题。 以下是对我有用的分步说明。 欢迎您使用官方网站或此处给出的说明以使所有东西正常运行:
以下每一行都是单独的指令。 这意味着要输入一个命令,请按Enter并等待其显示在控制台中,表明已完成,然后再输入下一个命令。
- 在终端中输入以下命令以安装 OpenCV 所需的组件:
$sudo su
$apt update && apt upgrade –y
$apt install build-essential
- 安装 CMake 来管理构建过程:
$wget https://github.com/Kitware/CMake/releases/download/v3.14.4/cmake-3.14.4.tar.gz
$tar xvzf cmake-3.14.4.tar.gz
$cd ~/cmake-3.14.4
- 安装任何其他依赖项,例如
bootstrap:
$./bootstrap
$make –j4
$make install
- 从 Raspberry Pi 驱动器中的源代码安装 OpenCV:
$git clone https://github.com/opencv/opencv.git
$cd opencv && mkdir build && cd build
$cmake –DCMAKE_BUILD_TYPE=Release –DCMAKE_INSTALL_PREFIX=/usr/local ..
$make –j4
$make install
上面的命令将安装 OpenCV。
- 要验证安装过程,请在保持当前终端打开的同时打开另一终端,然后输入以下命令:
$python3
>>> import cv2
>>> cv2.__version__
这应该显示系统上安装的最新 OpenCV 版本。
在 Raspberry Pi 中安装 OpenVINO
OpenVINO 是 Intel 的商标,代表 Open Visual Inference 和 Neural Network Optimization 工具包。 它为开发人员提供了基于 Intel 硬件的深度学习加速工具包,例如 CPU(Intel Core 和 Xeon 处理器),GPU(Intel Iris Pro 图形和 HD 图形),VPU(Intel Movidius 神经计算棒)和 FPGA(Intel Arria 10GX)。 。
要在桌面上下载 OpenVINO,请转到这里。
下载 OpenVINO 之后,您将必须输入您的姓名和电子邮件。 然后,您将能够下载 OpenVINO。 按照说明解压缩文件并安装依赖项。 请注意,此过程不适用于 Raspberry Pi。 因此,对于 Raspberry Pi,请使用以下命令:
$cd ~/dldt/inference-engine
$mkdir build && cd build
$cmake -DCMAKE_BUILD_TYPE=Release \
-DCMAKE_CXX_FLAGS='-march=armv7-a' \
-DENABLE_MKL_DNN=OFF \
-DENABLE_CLDNN=OFF \
-DENABLE_GNA=OFF \
-DENABLE_SSE42=OFF \
-DTHREADING=SEQ \
..
$make
前面的命令将在终端中返回一系列显示。
安装 OpenVINO 工具包组件
要安装 OpenVINO 工具包组件,请转到这里。
已列出以下步骤作为参考:
-
打开一个新的终端窗口,输入
sudo su,然后按Enter。 -
单击以下链接并下载
R3 l_openvino_toolkit_runtime_raspbian_p_2019.3.334.tgz。 请注意,p_和before.tgz之后的数字在将来的版本中可能会更改。 -
创建一个安装文件夹:
$sudo mkdir -p /opt/intel/openvino
- 解压缩下载的文件:
$sudo tar -xf l_openvino_toolkit_runtime_raspbian_p_2019.3.334.tgz --
$strip 1 -C /opt/intel/openvino
- 接下来,安装 CMake(如果尚未安装):
sudo apt install cmake
通过设置环境变量,每次启动终端时,OpenVINO 都会被初始化。 这使您不必每次都记住命令提示符。
设置环境变量
您可以在以下步骤的帮助下本地设置环境变量或全局设置环境变量:
- 要在本地设置它,请在终端中运行以下命令:
$source /opt/intel/openvino/bin/setupvars.sh
- 要在全局设置它,请在终端中运行以下命令:
$echo "source /opt/intel/openvino/bin/setupvars.sh" >> ~/.bashrc
- 要测试所做的更改,请打开一个新的终端。 您将看到以下输出:
[setupvars.sh] OpenVINO environment initialized
Pi$raspberripi: $
Type sudo su and you should get
root@raspberripi:
添加 USB 规则
需要 USB 规则才能在 Intel Movidius 神经计算棒上进行推理。 按着这些次序:
- 以下命令将帮助您将任何当前 Linux 用户添加到该组:
$sudo usermod -a -G users "$(whoami)"
- 现在,重新启动 Raspberry Pi,然后再次登录:
sh /opt/intel/openvino/install_dependencies/install_NCS_udev_rules.sh
使用 Python 代码运行推理
完成所有安装过程后,下一个任务是使用通过相机模块连接到 Raspberry Pi 的 Intel Movidius 神经计算棒进行推理。 此处的摄像头模块是边缘设备,而带有英特尔 Movidius 神经计算棒的 Raspberry Pi 是处理器单元。
请注意,Raspberry Pi 本身无法通过神经网络执行推理,因为处理速度非常慢。 使用英特尔 OpenVINO 神经计算棒,您会看到很少的延迟。 作为比较,请参考“使用 TensorFlow Lite 在 Raspberry Pi 上进行对象检测”,其中使用 tflite 在没有神经网络棒的情况下将 TensorFlow 模型部署到 Raspberry Pi。 您会注意到,在这种情况下,延迟是很大的。
让我们看一下以下命令:
$mkdir build && cd build
$cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_FLAGS="-march=armv7-a" /opt/intel/openvino/deployment_tools/inference_engine/samples
$make -j2 object_detection_sample_ssd
$wget --no-check-certificate https://download.01.org/opencv/2019/open_model_zoo/R1/models_bin/face-detection-adas-0001/FP16/face-detection-adas-0001.bin
$wget --no-check-certificate https://download.01.org/opencv/2019/open_model_zoo/R1/models_bin/face-detection-adas-0001/FP16/face-detection-adas-0001.xml
运行openvino_fd_myriad.py文件中提供的示例代码,如下所示:
python3 openvino_fd_myriad.py
请参阅以下 GitHub 页面以获取完整代码。 另外,查看out.png文件以查看在图像上绘制的边界框。
高级推理
到目前为止,我们刚刚使用 OpenVINO 工具包执行了面部检测。 在本节中,我们将学习如何使用连接到 Raspberry Pi 的 Intel Movidius 神经网络棒执行各种计算机视觉任务,例如行人检测,车辆和自行车检测,车牌检测,年龄和性别识别,面部标志识别 ,情感识别,姿势估计,动作识别,注视识别等。
英特尔开源技术中心提供了我们将使用的所有bin和xml文件的列表。 。
请注意,当您单击上一个链接时,将看到四个标记为R1, R2, R3, and R4的文件夹。 单击一个具有最新日期的日期,在这种情况下为R1。 在以下屏幕截图中可以看到:

然后,单击最新文件夹,在这种情况下为models_bin。 这将打开一个对话框,显示FP16,FP32或INT8。 对于某些模型,不提供INT8。
现在,让我们尝试了解这些参数的含义,以便我们可以根据自己的具体应用选择合适的参数。 FP16将 16 位而不是 32 位用于FP32,从而减少了训练和推理时间。 另一方面,INT8使用 8 位整数对神经网络进行权重,梯度和激活的训练。 因此,在这三种方法中,INT8应该是最快的一种,英特尔声称它仍然保持准确率。
如果您想了解有关英特尔使用的 8 位训练方法的更多信息,请参阅标题为《神经网络的 8 位训练的可扩展方法》的论文,该论文发表在这里。 为了在 Raspberry Pi 等边缘设备上更快地进行处理,建议的方法是使用FP16或INT8(如果有)。
先前描述的开放模型动物园具有各种预先构建的模型,例如用于人脸检测,人检测,自行车检测等的模型。 这些模型已经过训练,因此我们将在本章中仅出于推理目的使用这些模型。 如果您想了解训练方法,则可以按照“第 10 章”,“使用 R-CNN,SSD,和 R-FCN”。
接下来,我们将看一些将模型分为四种类型的表。
人脸检测,行人检测和车辆检测
下表描述了各种面部检测,人员检测以及车辆和自行车检测模型。 请仔细注意表中列出的每个模型的输入和输出,因为需要在 Python 代码中输入这些信息以进行推断:

我们可以看到,尽管模型类型不同,但输入本质上是相同的。 唯一的区别是输入图像的尺寸。 输出也相同–它们都生成一个矩形边界框。
地标模型
下表描述了用于年龄性别和情感识别,面部标志识别,车辆颜色和类型识别以及人的属性(例如衬衫,帽子和背包)的模型。 请注意表中列出的每个模型的输入和输出,因为这需要在 Python 代码中输入以进行推断:

在这里,输入是相同的:不同模型的尺寸不同,但是输出却不同。 对于地标,输出可以是面部轮廓的 5 点或 35 点。 对于人员属性,输出可以是八个属性中每个属性的二进制结果。 车辆属性可以是颜色或类型,而情感属性将导致五个类别中每个类别的概率。
动作识别模型
下表描述了用于姿势估计和动作识别的模型。 请注意表中列出的每个模型的输入和输出,因为这需要在 Python 代码中输入以进行推断:

上表显示,所有模型的输入结构均相同,只是图像形状有所变化。 姿势识别的输出显示三个角度:偏航,横摇和俯仰。
车牌,注视和人员检测
最后,下表显示了车牌,注视估计和人员检测的多输入 Blob:

以下代码概述了前两个表的主要组成部分; 即,用于面部检测,人物检测,汽车检测和地标检测。 让我们来看看:
-
导入 OpenCV 和视频捕获后,可以使用以下命令加载模型。 它将加载人脸检测模型:
cvNet = cv2.dnn.readNet('face-detection-adas-0001.xml', 'face-detection-adas-0001.bin')
cvNet.setPreferableTarget(cv2.dnn.DNN_TARGET_MYRIAD)
- 以下命令可用于加载界标检测模型。 可以使用此命令打开列出的任何其他模型。 要记住的唯一重要的事情是,模型应该位于执行以下代码的 Python 所在的目录中:
cvLmk = cv2.dnn.readNet('facial-landmarks-35-adas-0002.xml','facial-landmarks-35-adas-0002.bin')
cvLmk.setPreferableTarget(cv2.dnn.DNN_TARGET_MYRIAD)
- 接下来,我们使用以下命令读取视频帧并定义该帧的行和列:
ret, frame = cam.read()
rows = frame.shape[0]
cols = frame.shape[1]
- 接下来,我们使用 OpenCV 的
blobFromImage函数从给定大小和深度的帧中提取一个四维斑点。 请注意,斑点的大小应等于上表中列出的相应模型中指定的输入大小。 对于人脸检测,斑点输入大小为(672, 384),因此斑点表达式编写如下:
cvNet.setInput(cv2.dnn.blobFromImage(frame, size=(672, 384), ddepth=cv2.CV_8U))
cvOut = cvNet.forward()
对于界标检测,斑点输入大小为(60, 60),因此斑点表达可以表示为:
cvLmk.setInput(cv2.dnn.blobFromImage(frame, size=(60, 60), ddepth=cv2.CV_8U))
lmkOut = cvLmk.forward()
完成前面的步骤后,我们可以继续并绘制输出以进行可视化。 这是通过带有嵌套循环的两个for语句执行的:
- 第一个
for语句使用xmin, ymin, xmax, and ymax查找矩形边界框坐标,如果confidence > 0.5则使用cv2.rectangle创建矩形。 - 第二个
for语句在面边界框内绘制 35 个圆,其x和y坐标如下:
x = xmin + landmark output (i) * (xmax-xmin)
y = ymin + landmark output (i) * (ymax-ymin)
现在,我们可以使用cv2.circle绘制圆。 下面的代码总结了这一原理,在其中绘制了面部标志。 请注意我们前面讨论的两个for语句:
# Draw detected faces on the frame.
for detection in cvOut.reshape(-1,7):
confidence = float(detection[2])
xmin = int(detection[3] * cols)
ymin = int(detection[4] * rows)
xmax = int(detection[5] * cols)
ymax = int(detection[6] * rows)
if confidence > 0.5 :
frame = cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), color=(255, 255, 255),thickness = 4)
for i in range(0, lmkOut.shape[1], 2):
x, y = int(xmin+lmkOut[0][i]*(xmax-xmin)), ymin+int(lmkOut[0][i+1]*(ymax-ymin))
# Draw Facial key points
cv2.circle(frame, (x, y), 1, color=(255,255,255),thickness = 4)
尽管此处描述的代码讨论了面部标志和面部检测,但是可以更新相同的 Python 代码,以便我们可以执行其他任何类型的检测,例如车牌,人,自行车等。 您需要做的就是通过更改设置的输入来更改输入,然后调整for语句值。 此面部关键点检测示例是一个涉及面部和界标检测的复杂示例,这就是为什么使用两个for循环语句的原因。 例如,在车牌检测中,您只需要使用一个for循环语句。
现在,让我们学习使用 OpenVINO 进行推理。
使用 OpenVINO 的模型转换和推理
本节讨论如何使用预训练模型或定制训练模型来使用 OpenVINO 进行推理。 推理是使用模型执行对象检测或分类的过程,分为三个步骤:
- 使用来自 ncappzoo 的预训练模型进行推理。
- 将定制模型转换为 IR 格式以进行推断。
- 流程图中涉及的所有步骤的摘要。
以下各小节将详细讨论这些步骤。
使用 ncappzoo 在终端中运行推理
如前所述,OpenVINO 为 Raspberry Pi 安装的工具包与在普通 PC 上的安装方法不同。 Raspberry Pi 的安装不包括 Model Optimizer。 神经计算应用动物园(NCPAppZoo)是一个开放源代码存储库。 让我们看一下如何使用 ncappzoo:
- 要使用 ncappzoo,请克隆 OpenVINO 的开源版本和深度学习开发工具包(DLDT),然后更改 PYTHONPATH。 这样,模型优化器将安装在 Raspberry Pi 中。 以下代码块显示了这些步骤:
\(cd ~
\)git clone https://github.com/opencv/dldt.git
$ dldt/model-optimizer
\(pip3 install -r requirements_tf.txt
\)pip3 install -r requirements_caffe.txt
\(export PATH=~/dldt/model-optimizer:\)PATH
\(export PYTHONPATH=~/dldt/model-optmizer:\)PYTHONPATH
- 现在,使用以下命令克隆
repo:
$git clone https://github.com/movidius/ncappzoo.git
- 转到
/ncappzoo/apps/,找到相关的app文件夹目录,然后执行以下命令:
$make run
这将打开一个窗口,我们可以在该窗口上显示图像。
转换预训练模型来进行推断
本部分描述了转换自定义 TensorFlow 模型的步骤,它们使用我们在“第 6 章”,“使用迁移学习的视觉搜索”中开发的 TensorFlow Keras 对象分类模型,或使用 TensorFlow 对象检测 API,就像我们在上一章中所做的那样。 如果您已经计划使用来自英特尔开放源技术中心的经过预先训练的优化模型,那么上一节中描述的步骤将起作用。 在下一节中,我们将描述如何使用两种类型的 TensorFlow 模型执行转换。
转换使用 Keras 开发的 TensorFlow 模型
本节介绍如何将 TensorFlow 模型转换为 OpenVINO IR 格式。 有关更多信息,请参考以下链接。
这些步骤可以总结如下:
- 配置模型优化器。 如本章开头所述,必须对部署在边缘设备上的任何模型进行优化,这涉及在不牺牲精度的情况下删除所有不必要的组件。 以下代码在全局范围内执行此任务:
<INSTALL_DIR>/deployment_tools/model_optimizer/install_prerequisites directory and run: $install_prerequisites.sh
- 转换为冻结模型。 请注意,我们在“第 6 章”,“使用迁移学习的视觉搜索”中开发的模型并未冻结。
- 将冻结的 TensorFlow 模型转换为 IR 形式。 推理引擎读取模型的中间表示(IR)。 IR 是 OpenVINO 特定的图形表示。 IR 表示的输出是我们已经熟悉的
xml文件和bin文件。 转换是通过mo.py工具完成的,如以下代码所示:
Go to the <INSTALL_DIR>/deployment_tools/model_optimizer directoryin the Terminal and execute
$python3 mo_tf.py --input_model <INPUT_MODEL>.pb
在冻结模型开发过程中指定以下参数并理解它们非常重要,因为mo.py工具有时会在冻结模型中找不到时产生错误:
input_model:正在使用的预训练模型的名称input_shape:例如[1,300,300,3]
转换使用 TensorFlow 对象检测 API 开发的 TensorFlow 模型
本节介绍如何转换使用 TensorFlow 对象检测 API 创建的冻结图。 如果使用 TensorFlow 对象检测 API 开发模型,则详细过程与我们在上一节中介绍的过程不同。 可以在这里中找到更多信息。
我们已经冻结了使用 TensorFlow 对象检测 API 在“第 10 章”,“使用 R-CNN,SSD 和 R-FCN”进行对象检测的模型。 请按照以下步骤进行转换:
-
现在,我们准备进行转换。 准备三个文件,如下所示:
- 模型的冻结推理图:这是一个带有
.pb扩展名的文件,是通过使用自定义图像训练模型(R-CNN,SSD 或 R-FCN)而生成的。 在此示例中,它是frozen_inference_graph_fasterRCNN.pb。 - 配置
json文件:这是相应的json文件,该文件描述了冻结的 TensorFlow 图的自定义属性,节点,端口,端点和起点。 - 用于生成模型的配置文件:该文件与在“第 10 章”,“使用 R-CNN,SSD 和 R-FCN”。 例如,对于 R-CNN,我们使用了
faster_rcnn_inception_v2_pets.config.
完成上述步骤后,在终端中执行以下代码:
$python3 mo_tf.py --input_model frozen_inference_graph_fasterRCNN.pb --transformations_config faster_rcnn_support_api_v1.14.json --tensorflow_object_detection_api_pipeline_config faster_rcnn_inception_v2_pets.config
在这里,您需要将扩展名为.pb的文件替换为扩展名为.pb的特定模型文件名。 转换的结果将是xml和bin文件。
有了xml和bin文件后,我们就可以使用 Python 文件和“高级推断”部分中所述的说明来测试模型。
如果在调色时遇到问题,可以使用下面的 linbke 中显示的 OpenVINO 论坛,以查看类似问题的答案,也可以发布您的问题。
OpenVINO 模型推断过程总结
前面描述的整个模型推断过程可以用流程图表示:

上图表明该过程可以分为三个关键部分:
-
预处理步骤:在这里,我们安装 OpenCV 并设置环境变量。
-
模型准备:在这里,我们将模型转换为优化的模型格式。
-
推论:这可以分为两种独立的方法–通过在终端上执行推论,方法是转到相应的控制器并执行
make run或使用 Python 代码执行推论。 我发现在 Intel PC 上,所有这些步骤都很容易执行。 但是,在 Raspberry Pi 环境中,使用make Run命令在终端中进行操作会导致不同类型的错误。 例如,有时找不到.bin或.xml文件。 其他时间,环境变量未初始化或找不到CMakeLists.txt文件。 执行提供的 Python 代码不会在 Raspberry Pi 中产生任何这些问题。 这也使我们对计算机视觉环境有了更好的了解,因为我们要做的只是获取模型,了解输入和输出,然后生成一些代码以便我们可以显示结果。
在继续下一节之前,让我们总结到目前为止所学的模型优化技术:
1)批量归一化操作与卷积操作融合-OpenVINO 使用它
2)将步长大于 1 并且过滤器大小为 1 的卷积移动到上层卷积层。 添加池化层以对齐输入形状-OpenVINO 使用它
3)用两个小过滤器替换大过滤器,例如将3 x 3 x 3替换为#32,将3 x 3 x 1替换为#3,将1 x 1 x 3替换为#32-MobileNet 使用它。
TensorFlow Lite 的应用
TensorFlow Lite 是用于边缘设备推理的 TensorFlow 深度学习框架。 与 OpenVINO 相似,TensorFlow Lite 具有内置的预训练深度学习模块。 或者,可以将现有模型转换为 TensorFlow Lite 格式以进行设备上推理。 目前,TensorFlow Lite 为具有内置或外部摄像头的 PC,Android 设备,iOS 设备,Raspberry Pi 和微型微控制器提供推理支持。 访问这里了解有关 TensorFlow Lite 的详细信息。
TensorFlow Lite 转换器采用 TensorFlow 模型并生成FlatBuffer tflite文件。 FlatBuffer文件是高效的跨平台库,可用于访问二进制序列化数据而无需解析。 序列化的数据通常是文本字符串。 二进制序列化数据是以字符串格式写入的二进制数据。 有关FlatBuffer的详细信息,请参考以下链接。
TensorFlow 输出模型可以是以下类型:
- SavedModel 格式:
tf.saved_model执行保存的模型,输出为saved_model.pb。 它是完整的 TensorFlow 格式,其中包括学习的权重和图结构。 tf.keras模型格式:tf.kears模型是tf.keras.model.compile文件,我们在“第 4 章”,“图像深度学习”和“第 6 章”,“使用迁移学习的视觉搜索”。- 具体函数:具有单个输入和输出的 TensorFlow 图。
将 TensorFlow 模型转换为 tflite 格式
本节将描述如何将 TensorFlow 模型转换为tflite格式。 如果我们不这样做,那么我们开发的模型可以在本地 PC 中用于推理,但不能部署到边缘设备进行实时推理。 将针对此转换描述三种方法:
- Python API,在本地 PC 中用于
tflite转换 - 使用
tflite转换的 Google Colab - Google Colab 使用
toco
由于这是对象检测转换,因此我们的模型是根据 TensorFlow 对象检测 API 开发的,因此我们将在 Google Colab 中使用toco方法。
Python API
Python API 使我们可以轻松使用 TensorFlow Lite 转换器。 在本节中,我们将描述使用 tflite 转换器的 Python API。 有关更多信息,请参考以下链接。
根据所使用的转换器类型,建议了三种方法–保存的模型,Keras 模型或具体函数。 以下代码显示了如何从 Python API 调用tf.lite.TFLiteConverter来转换三个模型(保存模型,Keras 模型或具体函数)中的每个模型:
$import tensorflow as tf
$converter = tf.lite.TFLiteConverter.from_saved_model(export_dir)
$converter = tf.lite.TFLiteConverter.from_keras_model(model)
$converter = tf.lite.TFLiteConverter.from_concrete_functions([concrete_func])
tflite_model = converter.convert()
接下来,我们将学习如何使用 TensorFlow 对象检测 API 转换在“第 10 章”,“使用 R-CNN,SSD 和 R-FCN 的对象检测”中开发的训练模型。 Google Colab 使用两种不同的方法-tflite_convert和toco。
TensorFlow 对象检测 API – tflite_convert
在以下代码中,我们定义了冻结模型.pb文件和相应的tflite文件的位置。 然后,我们将三个 RGB 轴的每一个的输入彩色图像的大小调整为(300, 300),并将图像转换为归一化张量,然后将其变为转换的输入数组。 有四个输出数组,它们的定义如下:
TFLite_Detection_PostProcess—检测盒TFLite_Detection_PostProcess:1-检测类别TFLite_Detection_PostProcess:2-检测分数TFLite_Detection_PostProcess:3-检测次数
!tflite_convert \
--graph_def_file=/content/models/research/fine_tuned_model/tflite_graph.pb \
--output_file=/content/models/research/fine_tuned_model/burgerfries.tflite \
--output_format=TFLITE \
--input_shapes=1,300,300,3 \
--input_arrays=normalized_input_image_tensor \
--output_arrays= 'TFLite_Detection_PostProcess','TFLite_Detection_PostProcess:1','TFLite_Detection_PostProcess:2','TFLite_Detection_PostProcess:3' \
--change_concat_input_ranges=false \
--allow_custom_ops
TensorFlow 对象检测 API – TOCO
TOCO 代表 TensorFlow 优化转换器。 要了解对 TOCO 的详细了解,请访问以下 GitHub 页面。
以下代码描述了如何使用 TOCO 转换 TensorFlow 模型。 除了使用toco而不是tflite之外,代码的第一部分与之前的内容相同。 下一部分使用量化推断类型。 量化是一个过程,用于减小模型大小,同时改善硬件加速延迟。 有多种量化方法,如这个页面中所述。
在这种情况下,我们使用完整的整数量化。 没有使用反量化,但是平均值和标准差值用于确定推理代码中的定点乘数:
"!toco \\\n",
"--graph_def_file=\"/content/models/research/fine_tuned_model/tflite_graph.pb\" \\\n",
"--output_file=\"/content/models/research/fine_tuned_model/burgerfries_toco.tflite\" \\\n",
"--input_shapes=1,300,300,3 \\\n",
"--input_arrays=normalized_input_image_tensor \\\n",
"--output_arrays='TFLite_Detection_PostProcess','TFLite_Detection_PostProcess:1','TFLite_Detection_PostProcess:2','TFLite_Detection_PostProcess:3' \\\n",
"--inference_type=QUANTIZED_UINT8 \\\n",
"--mean_values=128 \\\n",
"--std_dev_values=128 \\\n",
"--change_concat_input_ranges=false \\\n",
"--allow_custom_ops"
可以在以下 GitHub 链接中找到用于训练和转换的 Google Colab 笔记本的详细信息。
注意,在两个模型之间,我们使用了 TOCO。 原因是使用 tflite 时,转换后的模型不会在 Android 手机上检测到边界框。
TensorFlow 模型可以表示为已保存的模型或 Keras 模型。 以下代码显示了如何将模型另存为已保存的模型或 Keras 模型:
- 保存的模型:保存的模型包括 TensorFlow 权重和检查点。 它由
model.save函数启动:
tf.saved_model.save(pretrained_model, "/tmp/mobilenet/1/")
tf.saved_model.save(obj, export_dir, signatures=None, options=None)
- Keras 模型:以下代码描述了如何使用
history.fit命令编译 Keras 模型并准备进行训练。 请注意,我们在“第 4 章”,“图像深度学习”和“第 6 章”,“使用迁移学习的视觉搜索”中对此进行了编码练习。 :
model.compile(loss='sparse_categorical_crossentropy', optimizer=keras.optimizers.RMSprop())
history = model.fit(x_train, y_train, batch_size=64, epochs=20)
model.save('path_to_my_model.h5')
模型优化
可以通过训练后量化来执行模型优化(也称为量化),以提高 CPU/GPU 性能,而不会牺牲准确率。 可以使用以下方法执行优化过程:
- 8 位精度的浮点(针对大小进行优化)
- 使用微控制器的整数输入和输出的完整量化
- 两者都有 - 动态量化为 8 位,但任何输出均以浮点形式存储
- 修剪是另一种动态优化方法,可在训练过程中从神经网络中消除低值权重。 可以通过以下代码行启动它:
from tensorflow_model_optimization.sparsity import keras as sparsity
pruning_params = {
'pruning_schedule': sparsity.PolynomialDecay(initial_sparsity=0.50,
final_sparsity=0.90,
begin_step=end_step/2,
end_step=end_step,
frequency=100)
}
l = tf.keras.layers
sparsity.prune_low_magnitude(l.Conv2D(64, (3, 3), activation='relu'),**pruning_params
有关详细信息,请访问 TensorFlow 网站。
请注意,在上一节中讨论了使用 Google Colab 对使用 TOCO 的对象检测模型进行的模型优化。
在以下代码中,我们正在优化保存的模型的大小,从而将最终输出模型减小到其原始大小的 1/3 或 1/4:
import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)converter.optimizations = [tf.lite.Optimize.OPTIMIZE_FOR_SIZE]
tflite_quant_model = converter.convert()
以下代码描述了完整的整数量化以及大小的优化:
import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.uint8
converter.inference_output_type = tf.uint8
converter.optimizations = [tf.lite.Optimize.OPTIMIZE_FOR_SIZE]
tflite_quant_model = converter.convert()
使用 TensorFlow Lite 的 Android 手机上的对象检测
本节将介绍部署 TensorFlow lite 转换模型所需的步骤。 或者,您可以按照这个页面上的说明来构建示例应用。 有关 Android 手机上对象检测的详细流程图如下:

我们需要两个文件:
- TensorFlow Lite 转换为
.tflite格式的文件 - 更新的 labelmap
.txt文件显示了该类
如果我们导出.tflite文件,则直接来自 Google Colab,如“TensorFlow 对象检测 API – TOCO”部分中所述。 lablemap.txt文件来自label_map.pbtxt文件,仅列出了类的名称。
在 Android 手机中采用tflite模型并生成推理的步骤如下:
- 在汉堡和薯条示例中,
.txt文件将具有一列和两行,如下所示:
burger
fries
-
将这两个文件放在 PC 的同一目录中。 打开 Android Studio。 如果您以前从未使用过 Android Studio,则必须从这里下载。 请按照网站上提供的下载说明进行操作。
-
下载后,在 Mac 或 Windows 上,双击打开它。 对于 Linux,您必须转到终端并导航到
android-studio/bin目录并键入./studio.h。 -
通过在终端中键入以下内容来下载一些示例示例:
git clone https://github.com/tensorflow/examples。 -
打开 Android Studio 并打开一个现有项目,将文件夹设置为
examples/lite/examples/object_detection/android。 -
在 Android Studio 项目中,转到应用,然后转到资产,如以下屏幕截图所示:

- 右键单击“资产”,然后从菜单列表中选择在文件中显示。 将我们在第一步中创建的
.tflite和.txt文件拖放到资产目录中。 关闭文件夹,然后返回 Android Studio。 - 双击
.txt文件将其打开,并在顶部添加新行。 用???填充它。 因此,.txt文件将为这两个类提供三行:
???
Burger
fries
- 选择
Java,然后选择跟踪,然后双击DetectorActivity。 将.tflite和.txt文件的名称更改为其实际名称,如以下屏幕截图所示。 然后,点击build gradle:
请注意,对于.txt文件,请保留路径,即file:///android_asset/burgerfries_labelmap.txt。 稍后,我们将提到,如果未使用toco生成.tflite文件,则保留先前的路径将导致应用崩溃。 为了防止崩溃,您可以仅保留文件名(例如burgerfries_labelmap.txt)。 但是,请注意,这不会为检测到的图像创建边界框。

-
注释掉
///apply from download_model.gradle。 验证依赖性是否出现,如前面的屏幕快照所示。 -
现在,使用 USB 电缆将 Android 设备连接到 PC。 转到您的设备,然后在“设置”下单击“开发人员选项”以确保其打开。 然后,打开 USB 调试。 对于许多 Android 手机,此选项会自动显示。
-
单击顶部的“生成”,然后单击“创建项目”。 在 Android Studio 完成编译后(查看屏幕底部以查看所有活动是否已完成),单击“运行”,然后单击“运行应用”。 该应用将下载到您的设备上。 设备上会出现一个选项框。 选择
ok即可运行该应用。 以下是该应用工作的图像:

如我们所见,该电话能够以非常高的准确率清晰地检测汉堡和薯条的真实图像。 至此,Android 应用部署练习结束。
使用 TensorFlow Lite 的 Raspberry Pi 上的对象检测
TensorFlow Lite 下列出的 Python quickstart包描述了如何为 Raspberry Pi 安装 TensorFlow Lite 包。 但是,有几个值得注意的例外。 因此,我们在此处列出了整个过程:
- 首先,请安装 TensorFlow Lite 解释器。 Raspberry Pi 已安装 ARM7 和 Python3.7,因此在终端中运行以下两个命令:
$sudo su
$pip3 install tflite_runtime-1.14.0-cp37-cp37m-linux_armv7l.whl
- 根据 TensorFlow Lite 官方文档,需要在
label_image.py文件中进行一些更改:
$import tflite_runtime.interpreter as tflite,
$interpreter = tf.lite.Interpreter(model_path=args.model_file)
请注意,当在 Raspberry Pi 4 中进行了这些更改并且在终端中通过键入python3 label_image.py执行代码时,将发生错误,指出即使安装了 Python,也找不到 TensorFlow Lite 解释器。 对 Raspberry Pi 3 重复了上述步骤,没有发生错误。
- 接下来,按照以下链接提供的步骤安装 TensorFlow Lite 目录和文件。
- 如果一切顺利,则应该在 Raspberry Pi 中有一个名为
pi/examples/lite/examples的目录。 在此文件夹中,您应该具有诸如image_classification,object_detection,image_segmentation,posenet和style_transfer等目录。 - 接下来,我们将在 Raspberry Pi 上执行两个示例-一个用于图像分类,另一个用于对象检测。
图片分类
现在,让我们执行以下步骤进行图像分类:
-
使用文件管理器转到
image_classification目录,即pi/examples/lite/examples/image_classification/raspberry_pi。 您将看到一个名为classify_picamera.py的文件。 现在,转到这里并下载对象检测模型以及名为mobilenet_v2_1.0_224.tflite和labels_mobilenet_v2_1.0_224.txt的label文件文件夹。 将这些文件复制到pi/examples/lite/examples/image_classification/raspberry_pi中。 -
接下来,使用
pi/examples/lite/examples/image_classification/raspberry_pi使用终端转到目录并执行以下命令:
$Python3 classify_picamera.py –model mobilenet_v2_1.0_224.tflite –labels labels_ mobilenet_v2_1.0_224.txt
- 您应该看到 Raspberry Pi 相机模块亮起并开始对图像进行分类。
对象检测
在 Raspberry Pi 上安装 TensorFlow lite 之后,我们现在可以执行对象检测。 按着这些次序:
- 使用文件管理器进入对象检测目录,即
pi/examples/lite/examples/object_detection/raspberry_pi。 您将看到一个名为detect_picamera.py的文件。 - 现在,转到这里并下载名为
coco_ssd_mobilenet_v1_1.0_quant_2018_06_29的对象检测模型和标签文件文件夹。 在此文件夹中,您将看到两个文件:detect.tflite和labelmap.txt。 - 将这些文件复制到
pi/examples/lite/examples/object_detection/raspberry_pi中。 - 接下来,使用
pi/examples/lite/examples/object_detection/raspberry_pi使用终端转到对象检测目录,并执行以下命令:
$Python3 detect_picamera.py –model detect.tflite –labels labelmap.txt
现在,您应该看到 Raspberry Pi 摄像头模块亮起并开始在图像周围显示边框。
- 接下来,将
burgerfries.tflite和labelmap文件复制到文件夹中。 然后,更改前面命令行中显示的 Python 路径以反映您的新文件名并执行它。 以下图像是用于object_detection的图像:

这里有几件事要注意:
- 我在 Raspberry Pi 中使用了广角相机,无法正确检测食物。
- 我转移到常规的 Raspberry Pi 相机上,能够检测到上图中看到的内容。
- 此处显示的检测效果不如使用手机时好,并且存在时滞。
该示例清楚地显示了相同模型在不同设备上的行为方式不同。
在 2020 TensorFlow 开发峰会上,TensorFlow 工程师宣布将显着改善延迟-浮点 CPU 执行为 55 ms 至 37 ms,定量定点 CPU 执行为 36 ms 至 13 ms,OpenCL 为 20 ms 至 5 ms 浮动 16 GPU 执行,2 ms 用于量化定点 Edge TPU 执行。 在进行此更改之前,对仅具有 CPU 的 Raspberry Pi 进行了测试。 因此,由于上述更改,您应该在 Raspberry Pi 上看到性能上的改进。 TF Lite 2.3 将带来进一步的改进。
使用 TensorFlow Lite 和 Create ML 的 iPhone 上的对象检测
到目前为止,我们已经学习了如何将 TensorFlow 模型转换为 tflite 格式并在 Android 手机和 Raspberry Pi 上进行推理。 在本节中,我们将使用 tflite 模型并在 iPhone 上执行推理。 iPhone 或 iPad 上的对象检测可以遵循两种不同的路径,如以下小节所述。
适用于 iPhone 的 TensorFlow Lite 转换模型
在本节中,我们将描述如何在 iPhone 上使用 tflite 模型进行对象检测。 有关详细信息,请参阅以下 GitHub 页面上概述的步骤。
本质上,该过程可以分为以下步骤:
- 此过程应在装有最新版本 Xcode 的 macOS 上完成。 您还应该具有 Apple Developer 证书。
- 在终端中,运行 Xcode 的命令行工具(
run xcode-select --install)。 请注意,即使您已经安装了 Xcode,也需要完成此步骤。 - 在终端中输入
git clonehttps://github.com/tensorflow/examples.git。 - 通过在终端中输入
$sudo gem install cocoapods来安装cocoapods。 - 调用将安装 TensorFlow 示例的最终目录
examples-master或examples。 相应地更改以下文件夹地址。 - 在终端中,键入以下命令:
$cd examples-master/lite/examples/object_detection/ios
$pod install
- 前面的过程将执行三个主要任务:
- 在 Xcode 中安装 TensorFlow Lite
- 在文件夹中创建一个名为
ObjectDetection.xcworkspace的文件 - 自动启动 Xcode 并打开
ObjectDetection文件
以下屏幕截图显示了在 pod 安装过程中您将在终端中看到的注解:

- 在 Xcode 的签名部分,选择您的开发团队。
- 对应用进行以下更改:

前面的屏幕快照中描述的更改说明了如何用您的更改替换基线detect.tflite和labelmap.txt文件。 请注意,如果您不进行任何更改,而是通过将手机连接到 macOS 来运行 Xcode,则它将显示一个常规检测器,如下图所示:

要更改您的特定模型,请右键单击以删除旧模型,然后通过拖放安装新模型。 对代码内的文件名进行必要的更改,如“步骤 4”中所示。 以下屏幕截图显示了您将看到的输出:

即使图像已旋转,前面的屏幕截图也清楚地显示出很好的检测效果。
Core ML
Core ML 是 Apple 的机器学习框架,该框架集成了来自 TensorFlow 等各种来源的神经网络模型,并在必要时进行了转换,然后优化了 GPU/CPU 性能以进行设备上的训练和推理,同时最大程度地减小了应用尺寸和功耗。 在 WWDC 2019 中引入的 Core ML 3 更新了设备上特定用户数据的神经网络模型,从而消除了设备到云的交互并最大程度地提高了用户隐私。 有关更多信息,请访问这里。 Core ML 本身建立在诸如 Accelerate 和 BNNS 以及 Metal Performance Shaders 之类的低级基元之上。 所有 Core ML 模型均具有.mlmodel扩展名。
Core ML 的核心部分是 Create ML,它是用于图像分类和对象检测的 Apple 机器学习框架。 该系统类似于 TensorFlow,但使用零编码生成模型更容易。 在 macOS 上,打开 Xcode 并输入.mlmodel,如以下屏幕截图所示:

现在,Create ML 中的整个模型开发过程仅涉及三个步骤:
- 准备数据 – 即输入文件
- 将数据拖到 Core ML 中,然后单击“训练”
- 保存模型(请注意,我找不到找到保存到桌面的方法,因此我通过电子邮件将其发送给自己并保存了文件)并分析了数据
以下屏幕截图显示了“创建 ML”中的训练过程:

有关上述屏幕截图的一些关键要点如下:
- 最终的训练损失为 0.83,这表明结果非常好–任何低于 1 的值都应表明检测良好。 请注意,仅使用 68 张图像即可获得该图像,这表明我们不需要大量图像即可开发出良好的神经网络模型。
- 请注意,与 TensorFlow 相比,使用 Create ML 开发模型非常容易-绝对零编码,无需转换,也无需前往单独的站点即可查看图表。 一切都紧凑且易于使用。
开发模型后,将其移植到以下用 Swift 编写的视觉框架。 它将检测带有边界框的对象。
以下是有关应用开发的一些注意事项:
- 您必须具有 Apple 开发人员帐户和团队才能登录 Xcode。
- 您需要删除现有模型并将最新模型拖到 Xcode 中,如以下屏幕截图的左侧所示:

- 完成此操作后,转到
ViewController.swift,并将默认模型名称重命名为您的模型名称,如上图右侧所示。 最后,建立模型并在 iPhone 上运行。
以下屏幕截图显示了模型输出。 它显示了我们使用 Create ML 开发的模型与我们使用 TensorFlow 开发并转换为.tflite形式的模型提供的检测结果的比较:

将 TensorFlow 模型转换为 Core ML 格式
转换器仅转换 TensorFlow 模型的一部分。 完整的 MobileNet-SSD TF 模型包含四个子图:Preprocessor,FeatureExtractor,MultipleGridAnchorGenerator和Postprocessor。 Core ML 工具仅转换模型中的FeatureExtractor子图; 其他任务必须由开发人员自行转换。
各种标注方法的摘要
图像标注是对象检测或分割的核心部分。 就神经网络开发中的手动工作而言,此部分最繁琐。 先前,我们描述了用于标注的三个工具:LebelImg,VGG Image Annotator和RectLabel。 但是,还有许多其他工具可用,例如 Supervisely 和 Labelbox。 其中一些工具会执行半自动标注。 最大的挑战是创建 100,000 个标注,并在像素级精度内正确地进行标注。 如果标注不正确,则开发的模型将不正确,并且在 100,000 张图像中找到不正确的标注就像在大海捞针中找针。 对于大型项目工作,标注工作流可以分为两类:
- 将标注工作外包给第三方
- 自动或半自动标注
在下一节中,我们将讨论这两种方法。
将标注工作外包给第三方
许多企业将标签工作作为其核心业务模型之一。 每个云服务提供商都与人类标签商合作,为神经网络开发工作执行准确的图像标签服务。 以下是有关在哪里可以找到第三方数据标签服务的一些信息。 请注意,此列表并不全面,因此请在此列表之外进行自己的研究,以找到适合您需求的数据标签服务:
- Google Cloud –数据标签。 有关详细信息,请转到这里。
- Amazon Sagemaker 真实情况–使用 Amazon Mechanical Turk 进行数据标记。 有关详细信息,请转到这里。
- Hive AI 数据标签服务。 有关详细信息,请转到这里。
- Cloud Factory 数据标签服务。 有关详细信息,请转到这里。
数据标记服务的成本可能会很高。
自动或半自动标注
在本节中,我们将讨论一个完全免费的自动标注工具,该工具应减少人工标记的程度。 这是英特尔的计算机视觉标注工具(CVAT)工具,它非常有前途,仅通过加载模型即可执行完整的自动标注作为起点。 您可以在这个页面中找到有关该工具的更多信息。 。
该工具能够为边界框,多边形和语义分段创建标注,并且还可以执行自动标注。 该工具可以将标注输出为 VOC XML,JSON TXT 或 TFRecord 文件。 这意味着,如果您使用该工具,则无需将图像转换为 TFRecord 形式–您可以直接训练神经网络。 请按照以下步骤学习如何使用该工具:
- 执行必要的安装。 所有说明均在终端中执行,包括安装 Docker,构建 Docker 映像以及克隆 CVAT 源代码。 可以在这个页面中找到更多信息。
- 通过转到这里,安装已在 coco 数据集上训练的 Faster R-CNN ResNet 初始 Atrous 模型。
- 安装 OpenVINO 模型。 如果您使用的是 TensorFlow,则无需安装 OpenVINO 模型-只需直接转到“步骤 4”。 但是,如果要使用 Intel Open Model Zoo 中的模型或您自己的自定义模型,请遵循此链接上的说明。
- 打开谷歌浏览器,然后输入
localhost:8080。 这将打开 CVAT。 请注意,CVAT 当前仅可在 Google Chrome 浏览器上使用。 - 从下拉列表中选择模型,如以下屏幕截图所示:

对于 TensorFlow,只有一种模型可供选择。 但是,您仍然需要从下拉列表中选择类,如前面的屏幕快照所示。 请注意,您可以选择多个类别,但不会显示选定的类别。
- 通过给它命名来创建任务。 然后,命名所有类并添加所有图像,如以下屏幕截图所示:

如前面的屏幕快照所示,已上传了九张图像。 然后,单击“提交”按钮,这将创建任务。 您可以将不同的人分配给不同的任务。
- 在“任务”下,在操作旁边的新菜单栏上单击鼠标左键,然后选择“自动标注”。 您将看到一个菜单栏,显示其进度。
- 完成自动标注后,单击“作业编号” –您会注意到所有图像都有标注。 以下屏幕截图显示了所有上传的九张图像的自动标注报告:

在前面的示例中,我们一次批量加载了所有九个图像,以演示自动化过程的有效性。 它正确检测了所有物体(汽车,人,卡车和摩托车)。 在某些情况下,该模型没有绘制交通信号灯和停车标志。 因此,在此示例中,只有交通信号灯和停车标志需要手动标注; 我们可以将工具用于所有其他对象。 接下来,我们以 VOC XML 格式获取该工具的输出,并将图像以及.xml文件加载到标签边界框的labelImg工具中。 以下屏幕截图显示了结果。 请注意,这是上述屏幕快照的左下图:

数据显示贴标工作非常准确。 该工具不断更新。 与其他任何工具一样,如果遇到此处未涉及的任何问题,请提交工作单。
我发现了与该工具有关的一个问题:输出不一致表示对于某些图像,它将绘制边界框标注,而对于其他图像,则不会。 我通过移至另一台 Linux PC 并重新安装 CVAT 来解决了此问题。 要在当前 PC 上解决此问题,可以在当前 CVAT 目录中卸载 Docker,删除 CVAT 文件夹,并确保端口8080没有被其他程序调用。 然后,您可以重新安装 CVAT。
总结
在本章中,您学习了如何在网络的最远端开发和优化卷积神经网络模型。 神经网络的核心是需要训练的大量数据,但最终,它提供了一个模型,该模型无需人工干预即可完成任务。 在前面的章节中,我们了解了必要的理论和实现的模型,但从未进行任何实际练习。 在实践中,摄像机可以用于监视,监视机器性能或评估手术过程。 在每种情况下,嵌入式视觉都用于实时设备上数据处理,这需要在边缘设备上部署更小,更有效的模型。
在本章中,您了解了各种单板计算机和加速器的性能,从而使您能够针对特定应用选择哪种设备做出明智的决定。 然后,我们学习了如何使用 OpenVINO 工具包和 TensorFlow Lite 来设置 Raspberry Pi 并在其上部署神经网络。 我们这样做是为了进行设备上的推断。 之后,我们学习了如何将 TensorFlow 模型转换为 TensorFlow Lite 模型并将其部署在 Android 和 iOS 设备上。 我们还了解了 Apple 的 Core ML 平台,并使用 Create ML 训练神经网络以开发对象检测器模型。 然后,我们将其与 TensorFlow Lite 对象检测器模型进行了比较。 我们在本章结束时概述了图像标注和自动标注方法。
在下一章中,我们将学习如何使用云处理来训练神经网络,然后将其部署在设备上。
十二、用于计算机视觉的云计算平台
云计算使用互联网从远程硬件普遍访问数据。 此类数据存储是使用云平台完成的。 对于计算机视觉,数据主要是图像,标注文件和结果模型。 云平台不仅存储数据,而且还执行训练,部署和分析。 云计算与边缘计算的不同之处在于,我们无需在基础设施上进行投资,就可拥有几乎瞬时的分析速度。
在本章中,您将学习如何在 Google Cloud Platform(GCP), Amazon Web Services(AWS)和 Microsoft Azure 云平台中打包应用以进行训练和部署。 您将学习如何准备数据,上传到云数据存储以及如何监视训练。 您还将学习如何将图像或图像向量发送到云平台进行分析并获得 JSON 响应。 本章讨论单个应用以及如何在计算引擎上运行分布式 TensorFlow。 训练结束后,本章将讨论如何评估模型并将其集成到应用中以进行大规模操作。
本章分为以下几节:
- 在 GCP 中训练对象检测器
- 在 AWS SageMaker 云平台中训练对象检测器
- 在 Microsoft Azure 云平台中训练对象检测器
- 大规模训练和包装
- 基于云的视觉搜索背后的总体思路
- 分析各种云平台中的图像和搜索机制
在 GCP 中训练对象检测器
在前两章中,我们学习了如何设置 Google Colab 以使用 SSD,R-CNN 和 R-FCN 以及 Inception 和 MobileNet 作为骨干预训练网络来训练自定义对象检测器。 我们的网络用于检测汉堡和薯条。 在本节中,我们将学习如何使用 GCP 执行相同的任务。 您也可以在这里。
我从上一篇文章开始,但是发现必须精简许多部分,并且需要添加其他详细信息才能使其在我的 Ubuntu PC 上运行。 以下小节提供了使用 GCP 训练目标探测器的分步过程。
请注意,本节涉及许多将本地终端连接到 GCP 的大步骤,有时信息流可能会造成混乱。建议您在本节开始之前仔细阅读本节结尾处提供的流程图。 在 AWS Sagemaker 云平台上训练对象检测器,以了解一般的信息流。
在 GCP 中创建项目
在本节中,将在 GCP 中创建一个项目。 一个项目包括账单,数据存储,API,认证和团队成员信息,以开始您的训练工作。 GCP 是 Google 的机器学习平台,用于存储,构建,训练和部署模型。 通过转到这里登录到 GCP 控制台。
首先,使用您的 Gmail ID 和密码登录,您将看到以下控制台:

进入控制台后,请花一些时间来熟悉各种选项。 特别是,您必须填写有关帐单,API 和项目设置的信息。 以下小节概述了详细的说明。
GCP 设置
转到这里设置 GCP 并使用您的 Gmail 帐户登录。 在上一节的屏幕快照中,有三个矩形框,它们是您需要设置的三个主要部分。 步骤概述如下:
-
首先,单击“转到项目设置”,为项目命名,然后分配团队成员(如果要由多个人从事该项目)。
-
然后,点击左侧的帐单并提供您的信用卡信息。 在撰写本文时,Google 提供了 300 美元的免费试用额度,但您仍需要提供信用卡信息。
-
完成此操作后,单击“API 和服务”,然后单击“启用 API 和服务”,然后在“机器学习”下选择“AI 平台训练和预测 API”。
-
单击“启用”,将启用 API。 以下屏幕截图显示了启用后的 AI Platform Training&Prediction API:

Google Cloud Storage 存储桶设置
存储桶是保存数据的容器。 所有云服务提供商都有存储桶。 存储桶的格式与 PC 的目录结构相同。 存储桶可以包含图像(.jpg文件),标注,TFRecord,检查点文件和模型输出。 在本部分中,我们将学习如何安装 Google Cloud Storage(GCS)存储桶以存储训练和测试数据。
使用 GCP API 设置存储桶
要使用 GCP API 设置存储桶,请按照以下步骤操作:
- 注册帐单后,向下滚动左侧菜单,单击“存储”,然后单击“创建桶”,并为其命名:

- 创建存储桶后,下一个任务是在存储桶中创建一个名为
data的文件夹,然后将文件上传到其中。 请看以下屏幕截图,了解如何执行此操作:

如前面的屏幕快照所示,首先创建一个名为data的文件夹。 然后,单击“数据”,单击“上载文件”,然后上载test.record,train.record,label_map.pbtxt,pipeline.config和model.ckpt*(三个文件)。 我们将在下一节中介绍如何获取这些文件。
使用 Ubuntu 终端设置存储桶
此过程涉及到设置 Google Cloud SDK,然后将 Google Cloud 项目和存储桶链接到您的终端,以便您可以在那里上传文件。 请记住,训练将由终端命令启动,因此,即使您使用前面的 API 进行了设置,您仍然需要执行以下部分中显示的步骤(从“开始设置 Google Cloud SDK”部分)以将终端链接到 GCP。
设置 Google Cloud SDK
Google Cloud SDK 是一组命令行工具,使您的 PC 可以与 Google Cloud 进行交互。 由于在本节中,我们将使用 Ubuntu 终端与 Google Cloud 进行交互,因此我们需要首先设置 SDK。 在终端中输入以下命令:
$ echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] http://packages.cloud.google.com/apt cloud-sdk main" | sudo tee -a /etc/apt/sources.list.d/google-cloud-sdk.list
$ curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key --keyring /usr/share/keyrings/cloud.google.gpg add -
$ sudo apt-get update && sudo apt-get install google-cloud-sdk
$ gcloud init
在前面的代码的前三行中,我们获得了 SDK 列表,然后使用apt-key对包进行认证,然后安装 SDK。 在第四行中,我们将使用gcloud.init设置gcloud配置。
同样,如前所述,如果您在遵循本节时遇到任何困难,可以查看本节末尾提供的流程图,以了解一般的信息流。
接下来,我们将您的本地 PC 链接到 Google Cloud 项目。
将您的终端链接到 Google Cloud 项目和存储桶
在上一节的步骤中,我们设置了 Google Cloud SDK。 现在,我们需要执行最重要的步骤,这是将 Ubuntu 终端接到 Google Cloud 项目以及您之前创建的存储桶。
为什么需要将 Ubuntu 终端链接到 Google Cloud 项目? 答案是我们使用本地 PC 上的终端启动训练命令,但是我们的数据存储在 GCP 的存储桶中,并且模型将在 GCP 中生成。 因此,我们需要将 PC 终端连接到 GCP 以完成训练任务。
在终端中按顺序输入以下步骤:
- 设置项目,在本例中为
rcnn-trainingpack:
$ gcloud config set project rcnn-trainingpack
- 要打开存储桶,请输入
gsutilPython 命令,如下所示:
$ gsutil mb gs://krish_burgerfries
- 接下来,我们设置环境变量以定义存储桶和文件所属的项目:
$ export PROJECT="rcnn-trainingpack"
$ export YOUR_GCS_BUCKET="krish_burgerfries"
- 通过输入以下命令来添加特定于 TPU 的服务帐户:
张量处理单元(TPU)是 Google 开发的一种 AI 加速器,用于快速处理大量数据以训练神经网络。
$ curl -H "Authorization: Bearer $(gcloud auth print-access-token)"
https://ml.googleapis.com/v1/projects/${PROJECT}:getConfig
前面的命令会将以下输出返回到“终端”窗口。 请注意,服务名称和项目名称将与您的应用不同:
{"serviceAccount": "service-444444444444@cloud-ml.google.com.iam.gserviceaccount.com",
"serviceAccountProject": "111111111111",
"config": {"tpuServiceAccount": "service-111111111111@cloud-tpu.iam.gserviceaccount.com" }}
{"serviceAccount": "service-444444444444@cloud-ml.google.com.iam.gserviceaccount.com",
"serviceAccountProject": "111111111111",
"config": {
"tpuServiceAccount": "service-111111111111@cloud-tpu.iam.gserviceaccount.com" }}
- 通过键入整个
tpuServiceAccount路径,将 TPU 帐户导出为环境变量,如下所示:
$ export TPU_ACCOUNT="service-111111111111@cloud-tpu.iam.gserviceaccount.com"
- 将
ml.serviceAgent角色授予 TPU 帐户:
$ gcloud projects add-iam-policy-binding $PROJECT --member serviceAccount:$TPU_ACCOUNT --role roles/ml.serviceAgent
这将在终端中产生一系列注解,从Updated IAM policy for the project [rcnn-trainingpack]开始。
安装 TensorFlow 对象检测 API
现在我们已经将终端链接到存储桶和 Google Cloud 项目,下一步是将其链接到 TensorFlow 对象检测 API。 请遵循这里提供的一组说明。
前面的安装链接包含许多未在此处列出的代码行。 您将能够正确执行大多数代码。 此过程的最后两行代码描述如下:
# From tensorflow/models/research/
export PYTHONPATH=$PYTHONPATH:'pwd':'pwd'/slim
python object_detection/builders/model_builder_test.py
该说明说,前面的步骤对于成功安装至关重要。 但是,如果您的 PC 上安装了 TensorFlow 2.0,则可能会出现以下错误:
AttributeError: module 'tensorflow' has no attribute 'contrib'
即使此错误已解决,也会导致另一个与 TensorFlow 2.0 与 TensorFlow 对象检测 API 不兼容有关的错误。 因此,我们将改为描述替代路径。 另一种选择是使用这里,类似于我们在第 10 章“使用 R-CNN,SSD 和 R-FCN 进行对象检测”,和第 11 章“在具有 CPU/GPU 优化功能的边缘设备上进行深度学习”中使用 TensorFlow 1.15 在 Google Colab 中运行它。
准备数据集
如“使用 GCP API”部分设置存储桶中所述,我们需要填充以下bucket: test.record,train.record,label_map.pbtxt,pipeline.config和model.ckpt*(三个文件 )。 在下面的小节中,我们将说明如何填充这些内容。
TFRecord 和标记地图数据
TFRecord 文件是高效的 TensorFlow 文件格式,用于以单一二进制格式存储图像和标注文件,以供 TensorFlow 模型超快速读取。 TFRecord 已在“第 10 章”,“使用 R-CNN,SSD 和 R-FCN”的对象检测中引入。 在本节中,我们将描述如何准备数据然后上传。
数据准备
首先,从“第 10 章”,“使用 R-CNN,SSD 和 R-FCN 进行对象检测”,和“第 11 章”,“通过 CPU/GPU 优化在边缘设备上进行深度学习”的 Google Colab 项目中复制 TFRecord 文件(即train.record和test.record),并将其放入 PC 上的目录中。 同样,将label_map.pbtxt复制到同一目录中的pbtxt文件中。
数据上传
在这里,我们将看一下使用终端的数据上传方法:
- 借助以下命令,我们将
train.record上传到 GCP。 这将使用gsutilPython 命令将文件从本地目录复制到 GCS 存储桶。 确保还包括该子目录。 例如,在这种情况下,YOUR_GCS_BUCKET将是您的存储桶的名称; 如果为burgerfries,则命令将为$burgerfries/data,其中data是burgerfries下的子目录,文件存储在其中:
$ gsutil -m cp -r /Documents/chapter12_cloud_computing/burgerfries/annotation/train.record gs://${YOUR_GCS_BUCKET}/data/
Copying file:///Documents/chapter12_cloud_computing/burgerfries/annotation/train.record [Content-Type=application/octet-stream]...
\ [1/1 files][ 2.6 MiB/ 2.6 MiB] 100% Done
- 接下来,以下命令将用于将
test.record上传到 GCP:
$ gsutil -m cp -r /Documents/chapter12_cloud_computing/burgerfries/annotation/test.record gs://${YOUR_GCS_BUCKET}/data/
Copying file:///Documents/chapter12_cloud_computing/burgerfries/annotation/test.record [Content-Type=application/octet-stream]...
\ [1/1 files][ 1.1 MiB/ 1.1 MiB] 100% Done
Operation completed over 1 objects/1.1 MiB.
- 以下命令将帮助我们将
label_map.pbtxt上传到 GCP:
$ gsutil -m cp -r /Documents/chapter12_cloud_computing/burgerfries/annotation/label_map.pbtxt gs://${YOUR_GCS_BUCKET}/data/
Copying file:///Documents/chapter12_cloud_computing/burgerfries/annotation/label_map.pbtxt [Content-Type=application/octet-stream]...
/ [1/1 files][ 75.0 B/ 75.0 B] 100% Done
Operation completed over 1 objects/75.0 B.
如果您不使用终端,则只需使用 Google Cloud 存储桶中的 Upload 命令上传文件,如“使用 GCP API”部分的屏幕截图所示。
model.ckpt文件
在本节中,我们将学习如何下载预训练模型的检查点文件。 检查点是模型的权重。 这些权重将被上传到 GCS 存储桶,以使用迁移学习来开始训练:
-
以下是我们下载的相应文件的解压缩版本:
ssd_mobilenet_v1_0.75_depth_300x300_coco14_sync_2018_07_03.tar.gz
检查点捕获模型使用的所有参数的确切值。 解压缩文件时,您会注意到文件类型如下:
model.ckpt.data-00000-of-00001:一个二进制数据文件,其中包含训练变量权重,梯度等的值model.ckpt.index:描述每个检查点的索引值的二进制文件model.ckpt.meta:描述保存的图结构; 它是一个协议缓冲区Checkpoint:记录最新的检查点文件
模型配置文件
模型config文件是一个文本文件,定义了模型的以下重要特征:
- 模型名称
- 类别数
- 图像最小/最大尺寸
- 模型参数
- 检查点,TFRecord 和
map.pbtxt的位置
在训练期间,模型使用config文件输入和设置参数。 您可以在 TensorFlow 目录中的以下路径下找到config文件的列表:
models-master/research/object-detection/samples/configs
请注意,在撰写本文时,仅在 TensorFlow 1.x 中提供了先前的目录,而在 2.x 中则没有。 因此,如果您的 PC 上安装了 TensorFlow 2.0,请使用下面讨论的替代步骤来获取config文件。
或者,您可以转到这里,然后在文本编辑器中复制config文件。 也可以从前面的链接下载相应的.config文件。
以下列表显示了config文件中需要进行的更改:

在前面的列表中,所有更改都用矩形标记。 左侧列表显示原始config文件,右侧列表显示更改的config文件。 这里,假设TFRecord文件名是train.record和test.record,pbtxt文件名是label_map.pbtxt,并且 Google 存储驱动器中的路径是krish_burgerfries/data。 如果文件名或路径不同,则可以进行相应更改。
现在,通过在终端中键入以下命令转到 TensorFlow research目录:
$cd models-master/research
有关包对象检测 API,pycocotools和tf-slim的信息,请参见以下命令:
models-master/research$ bash object_detection/dataset_tools/create_pycocotools_package.sh /tmp/pycocotools
models-master/research$ python setup.py sdist
models-master/research$ (cd slim && python setup.py sdist)
在云端训练
完成上述所有步骤后,我们将准备进行训练。 如前所述,通过执行以下命令在终端中开始训练:
- 该命令很长,但是将其复制到文本编辑器,仅将
{YOUR_GCS_BUCKET}更改为burgerfries(在您的情况下,如果名称不同,则将其更改为该名称)。 完成后,将其粘贴到终端中并点击Enter:
$ gcloud ml-engine jobs submit training `whoami`_object_detection_`date +%s` --job-dir=gs://${YOUR_GCS_BUCKET}/train --packages dist/object_detection-0.1.tar.gz,slim/dist/slim-0.1.tar.gz,/tmp/pycocotools/pycocotools-2.0.tar.gz --module-name object_detection.model_tpu_main --runtime-version 1.15 --scale-tier BASIC_TPU --region us-central1 -- --model_dir=gs://${YOUR_GCS_BUCKET}/train --tpu_zone us-central1 --pipeline_config_path=gs://${YOUR_GCS_BUCKET}/data/pipeline.config
- 与训练一样,在以下命令的帮助下执行验证。 该命令又很长,但是将其复制到文本编辑器,仅将
{YOUR_GCS_BUCKET}更改为burgerfries(在您的情况下,如果名称不同,则将其更改为该名称)。 完成此操作后,将其粘贴到终端中,然后单击Enter:
$ gcloud ml-engine jobs submit training `whoami`_object_detection_eval_validation_`date +%s` --job-dir=gs://${YOUR_GCS_BUCKET}/train --packages dist/object_detection-0.1.tar.gz,slim/dist/slim-0.1.tar.gz,/tmp/pycocotools/pycocotools-2.0.tar.gz --module-name object_detection.model_main --runtime-version 1.15 --scale-tier BASIC_GPU --region us-central1 -- --model_dir=gs://${YOUR_GCS_BUCKET}/train --pipeline_config_path=gs://${YOUR_GCS_BUCKET}/data/pipeline.config --checkpoint_dir=gs://${YOUR_GCS_BUCKET}/train
- 训练开始后,您可以通过执行以下命令来评估训练工作:
$ gcloud ai-platform jobs describe krishkar_object_detection_1111111111
在此,末尾的数字对于您的应用将有所不同,并将在终端中显示出来。 键入前面的命令后,您可以在这个页面中检查训练作业。
请注意,URL 的xxxxx和1111111111部分只是示例; 您的值将有所不同,并会在终端中显示出来。
在 TensorBoard 中查看模型输出
在“第 10 章”,“使用 R-CNN,SSD 和 R-FCN”进行对象检测中,我们学习了如何使用 Google Colab 在 TensorBoard 中查看 TensorFlow 模型输出结果。 在本节中,我们将向您展示如何通过在终端中执行命令从云平台启动 TensorBoard:
- 让我们从终端中输入以下命令开始:
tensorboard --logdir=gs://${YOUR_GCS_BUCKET}/train
运行上述命令后,如果遇到错误,例如ValueError: Duplicate plugins for name projector,则从这里并将其保存到您的目录中。
- 在终端中,转到
diagnose_tensorboard.py的安装目录并执行以下命令:
$ python diagnose_tensorboard.py
它将运行并提供可能的修复建议。 就我而言,它要求以下修复:
### Suggestion: Fix conflicting installations
"Conflicting package installations found. Depending on the order of installations and uninstallations, behavior may be undefined. Please uninstall ALL versions of TensorFlow and TensorBoard, then reinstall ONLY the desired version of TensorFlow, which will transitively pull
in the proper version of TensorBoard. (If you use TensorBoard without TensorFlow, just reinstall the appropriate version of TensorBoard directly.)
Namely:
pip uninstall tb-nightly tensorboard tensorflow-estimator tensorflow-estimator-2.0-preview tensorflow-gpu tf-nightly-gpu-2.0-preview
pip install tensorflow # or `tensorflow-gpu`, or `tf-nightly`, ..."
- 根据建议执行命令,TensorBoard 将正常工作。
- 导航到
localhost:6006以查看 TensorBoard 结果。
在 TensorBoard 中,您将看到所用神经网络的图以及在测试图像上显示边界框的图像。 请注意,在 TensorFlow 中,我们没有上传图像,但是它是从TFRecord文件获取图像的。 TensorBoard 还显示准确率和精度数据,如下所示:

精度数据不高,但可以通过添加更多图像来改进-在我们的示例示例中,我们仅使用 68 张图像进行训练。
现在我们已经创建了模型并观察了其输出,在下一部分中,我们将描述如何打包模型,以便您可以将其部署在边缘设备(例如手机)上以进行实时显示。 在此处打包模型意味着冻结模型,这意味着该模型不再受训练。
模型输出和到冻结图的转换
到目前为止,我们已经学习了如何将 TFRecord 格式的图像上传到 GCP,然后使用 SSD MobileNet 模型来训练针对汉堡和薯条的自定义模型。 在本节中,我们将回顾模型输出的组成部分,并学习如何冻结模型。 冻结模型涉及以某种格式保存 TensorFlow 图和权重,以后可用于推断。 模型输出存储在train文件夹中,并且包含以下文件:
graph.pbtxt:这是一个文本文件,描述了 TensorFlow 图上每个节点的值,列表和形状model.ckpt-xxxx.data-00000-of-00001:这是一个二进制文件,指示所有变量文件的值model.ckpt-xxxx.index:这是一个代表表的二进制文件,其中每个键是张量的名称及其值model.ckpt-xxxx.meta:这描述了保存的图结构train_pipeline.config:此文本文件描述了模型参数-在模型配置文件的前两个部分中也有说明
请注意,在前面的步骤中,我仅以xxxx为例。 您的值将有所不同。 输入该信息而不是xxxx。
抓取最新的数据文件(单击鼠标右键并下载),因此,在本示例中,抓取包含-2000的文件。
下一个任务是将检查点输出转换为冻结的推理图。 下节介绍了三种方法:
- 从 TensorFlow Core 执行
freeze_graph.py:
$ python freeze_graph.py --input_graph=train_graph.pbtxt -- input_checkpoint=train_model.ckpt-2000 -- output_graph=frozen_graph.pb --output_node_name=softmax
- 从 TensorFlow Python 工具执行
freeze_graph:
import tensorflow as tf
from tensorflow.python.tools import freeze_graph
checkpoint_path = './'+'train_model'+'.ckpt-2000'
freeze_graph.freeze_graph('train_graph.pbtxt', "", False, checkpoint_path, "output/softmax", "save/restore_all", "save/Const:0",'frozentensorflowModel.pb', True, "")
对于上述两种方法,我们都会得到两种类型的错误:
IndexError: tuple index out of range
AttributeError: module 'tensorflow_core.python.pywrap_tensorflow' has no attribute 'NewCheckpointReader'
- 从终端在
tflite graph.py上执行export函数,然后下载相关文件:
$export CONFIG_FILE=gs://${YOUR_GCS_BUCKET}/data/pipeline.config
$export CHECKPOINT_PATH=gs://${YOUR_GCS_BUCKET}/train/model.ckpt-2000
$export OUTPUT_DIR=/tmp/tflite
- 然后,根据这个页面中的描述,从 Docker 文件在终端中执行以下命令。
Docker 是一种虚拟机,使开发人员可以将应用及其所有组件打包在一起。 对于 TensorFlow,使用 Docker 的优势是将 TensorFlow 安装与 PC 操作系统隔离。 这种隔离消除了我们之前观察到的许多与 TensorFlow 相关的错误:
$python object_detection/export_tflite_ssd_graph.py \
--pipeline_config_path=$CONFIG_FILE \
--trained_checkpoint_prefix=$CHECKPOINT_PATH \
--output_directory=$OUTPUT_DIR \
--add_postprocessing_op=true
在以下部分中,我们将描述“第 11 章”,“在具有 CPU/GPU 优化功能的边缘设备上进行深度学习”提及的tflite转换过程。
从 Google Colab 执行导出 tflite graph.py
在“第 10 章”,“使用 R-CNN,SSD 和 R-FCN 的对象检测”和“第 11 章”,“在具有 CPU/GPU 优化的边缘设备上进行深度学习”,我们使用 Google Colab 将检查点转换为冻结图。 我们将在此处使用相同的方法,除了我们将导入配置,检查点和输出目录,如下所示:
CONFIG_FILE = '/content/sample_data/train_pipeline.config'
CHECKPOINT_PATH = '/content/sample_data/train_model.ckpt-2000'
OUTPUT_DIR = '/content/sample_data'
将文件上传到 Google 云端硬盘,然后将其拖到 Google Colab 中名为sample_data的文件夹中。 您可以创建一个不同的名称来代替sample_data。 之后,执行以下代码:
请注意,如果您没有通过将文件拖到 Google Colab 中来携带文件,而是将 Google Colab 链接到文件所在的 Google 云端硬盘,则可能会产生错误,因为在此期间无法找到文件来执行。
import re
import numpy as np
!python /content/models/research/object_detection/export_tflite_ssd_graph.py \
--input_type=image_tensor \
--pipeline_config_path={CONFIG_FILE} \
--output_directory={OUTPUT_DIR} \
--trained_checkpoint_prefix={CHECKPOINT_PATH} \
--add_postprocessing_op=true
因此,总而言之,下图表示在 GCP 上训练自定义对象检测器的流程图:

首先创建一个项目,然后创建账单,设置 API 和存储桶,准备 TensorFlow 对象检测 API,准备和上传数据集,然后开始训练。 虚线矩形内的两个圆角矩形表示完成同一任务的两种不同方法。 训练完成后,涉及的步骤包括生成冻结图,转换tflite表单并部署到移动设备。 部署到移动设备的过程与“第 11 章”,“具有 CPU/GPU 优化功能的边缘设备上的深度学习”中的方法相同,因此在此不进行描述。
在 AWS SageMaker 云平台中训练对象检测器
AWS 是用于在云中执行各种任务的 Amazon 云平台。 AWS SageMaker 是机器学习平台,用于使用 AWS 交互式平台训练和部署模型。 AWS SageMaker 与 AWS S3 存储桶进行交互以存储和检索数据。 下一节将介绍训练对象检测器的分步过程。
设置 AWS 账户,账单和限额
通过与 AWS 支持联系,将服务限制增加到ml.p3.2xlarge或类似的值。 请注意,实例类型最多可能需要两个工作日才能获得批准,因此请进行相应的计划。 如果不这样做,则会出现以下错误:
ResourceLimitExceeded
用于训练作业使用情况的帐户级别服务限制ml.p3.2xlarge为零实例,当前利用率为零实例,请求增量为一个实例。 请联系 AWS 支持以请求增加此限制。
将.xml文件转换为 JSON 格式
AWS SageMaker 标注数据使用 JSON 格式而不是我们之前使用的.xml。 通过以下步骤将.xml文件转换为 COCO JSON 格式:
-
从这里下载或克隆存储库。
-
克隆存储库并下载后,进入终端
voc2coco.pyPython 文件所在的目录。 -
创建一个名为
trainxml的目录,其中包含所有.xml文件。 该目录应与voc2coco.py位于相同的主目录中。 -
在同一主目录中,创建一个名为
trainlist.txt的文件,该文件应列出所有.xml文件名。 您可以在终端中复制此文件,然后将所有.xml文件复制并粘贴到文本文件中以创建此类文件。 -
接下来,创建一个
classname.txt文件,该文件应列出training文件夹中的所有类。 在此示例中,它将有两行-burger和fries。 -
然后,从主目录下的终端运行 Python 代码,如下所示:
$ python voc2coco.py --ann_dir trainxml --ann_ids trainlist.txt --labels classname.txt --output train_cocoformat.json
最终输出是cocoformat.JSON文件,它是所有.xml文件的一个组合 JSON 文件。
- 将
COCO JSON文件转换为单个 JSON 文件。 - 然后,使用
Chapter12_cocojson_AWSJSON_train.ipynbJupyter 笔记本将COCO JSON文件转换为单个 JSON 文件。 可以在这个页面上找到此文件。 这是对 Amazon 提供的对象检测代码的修改。 此代码不是从 GitHub 页面获取COCO JSON文件,而是从本地驱动器获取上一步中创建的cocoformat.JSON文件,然后将其转换为生成的文件夹中的多个.JSON文件。
将数据上传到 S3 存储桶
S3 存储桶是用于在 AWS 中存储数据的云存储容器。 本节介绍如何将数据从我们的 PC 上传到 S3 存储桶:
- 创建一个主文件夹以指示项目数据。
- 在该文件夹中,上传四个文件和一个输出文件夹,如下所示:
train_channel:train图片.jpg文件train_annotation_channel:train标注.JSON文件。 每个文件对应于每个train图像。validation_channel:validation图片.jpg文件validation_annotation_channel:validation标注.JSON文件。 每个文件对应于每个validation图像。
- 创建一个输出文件夹来存储检查点和输出模型文件。
创建笔记本实例并开始训练
让我们按照以下步骤操作:
- 选择实例类型(选择用于加速计算的实例,例如
ml.p2.nxlarge,其中n可以为 1、2、8,依此类推)。 请注意,如果实例类型是标准类型(例如ml.m5.nxlarge)或计算优化型(例如ml.c5.nxlarge),则训练将失败。 因此,如前所述,请求增加服务限制。 - 选择最大运行时间-从 1 小时开始,对于非常大的作业,增加它。
- 为前面描述的四个通道中的每个通道分配一个到 S3 存储桶的路径,以便算法知道从何处提取数据。
- 将路径分配到前面提到的输出文件夹。 在前面的代码块中显示了输出路径的示例。 在这种情况下,
sample1是 S3 存储桶名称,DEMO是其中包含sample1的文件夹,其中有六个文件夹-两个数据文件夹,其中包括.jpg图像,两个标注文件夹由.json文件,输出和检查点文件组成。 请注意,路径必须正确; 否则,可能会产生错误:
s3://sample1/DEMO/s3_train_data/
s3:// sample1/DEMO/s3_train_annotation/
s3:// sample1/DEMO/s3_validation_data/
s3:// sample1/DEMO/s3_validation_annotation/
s3:// sample1/DEMO/s3_checkpoint/
s3:// sample1/DEMO/s3_output_location/
- 通过 Python 笔记本或通过训练 API 设置训练。
- 训练结束后,输出将存储在先前代码中定义的
s3_output_location中,作为model.tar.gz文件。 检查点将存储在前面代码中定义的s3_checkpoint位置。 - 下一步将是建立推理模型。 AWS 拥有详细的推理分步说明,可在这个页面中找到。
修复训练中的一些常见故障
以下是一些在训练过程中失败的原因及其解决方法:
-
故障 1 - s3 存储桶相关问题:在输入数据源中给定的
s3://DEMO-ObjectDetection/s3_train_data/S3 URL 上找不到 S3 对象。 请确保存储桶位于所选区域(us-east-1)中,对象存在于该 S3 前缀下,并且arn:aws:iam::11111111:role/service-role/AmazonSageMaker-ExecutionRole-xxxxxxx角色对DEMO-ObjectDetection存储桶具有s3:ListBucket权限。 或者,来自 S3 的The specified bucket does not exist错误消息。 解决方案:更改 S3 存储桶路径,如前所述。 对train,validation,annotation和image数据文件各重复一个。 -
故障 2 - 批量大小问题:
ClientError:validation集没有足够的带标注文件。 请确保带有有效标注的文件数量大于mini_batch_size,并且实例中的 GPU 数量更大。 解决方案:要记住的重要一点是批量大小必须小于validation文件的数量。 因此,如果validation文件的数量为 32,批量大小为 32,则将微型批量大小从 32 更改为 12,以解决此错误。 -
故障 3 - 内容类型问题:
ClientError:无法初始化算法。train_annotation通道的ContentType为空。 请为train_annotation频道设置内容类型(由KeyError引起)。 由u'train_annotation'引起。 解决方案:确保内容类型不为空白。 将内容类型更改为application/x-image。 -
故障 4 - 通道命名问题:
ClientError:无法初始化算法。 无法验证输入数据配置(由ValidationError引起)。 由u'train'引起的是必需属性。 无法验证架构中的u'required':{u'$schema':u'http://json-schema.org/draft-04/schema#', u'additionalProperties':False,u'definitions': {u'data_channel': {u'properties': {u'ContentType': {u'type': u'string'},u'RecordWrapperType': {u'enum': [u'None', u'RecordIO'], u'type': u'string'}, u'S3DistributionType': {u'enum': [u'FullyReplicated', u'ShardedByS3Key'], u'type': u'string'}。 解决方案:AWS 希望通道名称为train_validation,train_annotation和validation_annotation。 如果您附加了_channel(train_channel,validation_channel,train_annotation_channel和validation_annotation_channel),则将导致错误。 因此,要解决此问题,请从文件名中删除_channel。
如果在此过程中遇到问题,请通过创建故障单来联系 AWS 支持人员。 解决所有错误后,成功的训练将具有以下参数:
base_network是resnet-50early_stopping是falseearly_stopping_min_epochs是10early_stopping_patience是5early_stopping_tolerance是0.0epochs是30freeze_layer_pattern是falseimage_shape是300label_width是350learning_rate是0.001lr_scheduler_factor是0.1mini_batch_size是12momentum是0.9nms_threshold是0.45num_classes是2num_training_samples是68optimizer是sgdoverlap_threshold是0.5use_pretrained_model是1weight_decay是0.0005
请注意,训练的输出将与检查点一起保存在 S3 输出位置。
完成上述练习后,您将熟悉在 GCP 和 AWS 中训练神经网络模型。 接下来,我们将使用 Microsoft Azure 云平台进行训练。
在 Microsoft Azure 云平台中训练对象检测器
在本节中,我们将使用 Azure 自定义视觉来训练对象检测器。 可以在这个页面中找到有关使用 Microsoft Azure 云平台训练对象检测器的详细说明:。
下一节将详细介绍训练对象检测器时的各种过程。
创建一个 Azure 帐户并设置 Custom Vision
在本节中,我们将设置一个 Azure 帐户和一个 Azure Custom Vision 平台。 以下步骤将帮助您配置 Azure 帐户并注册 Custom Vision 平台。 如针对 GCP 所述,此过程对于任何云平台都是相同的-设置帐单信息并设置项目-如以下屏幕快照所示:

设置训练的具体步骤如下:
- 注册一个 Microsoft 帐户并设置帐单信息。 在撰写本文时,Microsoft 将免费为美国地区的首次用户提供 200 美元的赠金(请针对您所在的地区进行检查)。
- 设置订阅。 在“订阅”选项卡中,单击“添加”,然后为您的订阅命名并设置帐单信息。
- 设置项目,然后选择并创建项目,并为其命名。
- 设置资源,然后从菜单中选择“资源”组。
- 选择“对象检测”,然后完成所有这些操作,然后使用“Custom Vision”创建对象检测。
设置帐户设置是非常重要的部分,如果操作不正确,将花费相当长的时间。 设置帐户后,接下来的步骤实际上将很快进行。
上传训练图像并标记它们
在本节中,我们将训练图像上传到 Azure Custom Vision 平台。 按着这些次序:
-
单击“添加图像”,然后添加所有
train和validation图像。 -
添加它们后,您的图像将显示在未标记的部分。
-
请注意,您将无处上载在先前项目中创建的标注
.xml或.JSON文件,但不要担心,Azure 使标记图像非常简单。 -
首先,请标注大约 10%(或大约 20)的图像。 您会注意到,即使在此之前,边界框也会自动转到感兴趣的对象,您要做的就是调整其大小。 如果找不到对象,请添加边界框并编写相应的类。 以下屏幕截图显示了智能标签选项:

-
标记图像后,它们将移至标记的部分。 在标记了 10%(或大约 20)张图像后,请对这些图像进行快速训练。 训练完成后,返回未加标签的图像,然后使用智能贴标签器选项标记所有未加标签的图像。
-
执行上一步后,您会注意到许多图像将被自动标记。 如果您认为标签正确无误,请接受更改,然后调整边界框的大小和位置。 如果图像具有多个类别,并且智能标签仅捕获其中的几个类别,请手动标记其他类别。 用这种方法标注大约 100 张图像后,就可以开始训练(如果有更多图像,则进行快速训练,如果最大图像数为 100,则进行高级训练),然后使用新生成的模型来训练其他图像。
-
继续前面的过程,直到所有图像都被标记。 然后,开始训练并使用高级训练选项。 以小时为单位设置时间(从 1 小时开始),以后再根据需要增加时间。 在云端的训练非常快-在不到 10 分钟的时间内即可训练约 100 张图像。
训练完成后,您将能够看到表现指标。 请注意,在上述快速训练之后,您将能够看到此内容。 以下屏幕截图显示了针对新训练的模型的精度,召回率和 mAP 方面的表现参数:

请注意,随着模型看到的图像越来越多,上一个屏幕快照中显示的 Precision 值可能会降低。 因此,在 20 张图像上开发的模型比在 100 张图像上开发的模型具有更高的精度。 这是因为在 20 张图像上开发的模型具有较少的训练误差,但具有较高的测试误差(在test图像中,无法识别汉堡-仅识别薯条)。 mAP 数是 11 个等距召回级别(0,0.1,...,1)上的平均平均精度。 mAP 值不受图像添加的影响。 Performance参数显示burger和fries的值。
- 现在,让我们带回旧的
validation图像并查看结果。 为此,请单击顶部的“预测”,然后插入validation图像。 它将在类周围绘制一个边界框,如下所示:

- 如图所示,预测是正确的。 接下来,我们将导出模型。 为此,请单击“导出”,如以下屏幕截图所示。 请注意,如果单击
TF,则可以选择导出为 TensorFlow Lite 或 TensorFlow。 同样,如果您单击iOS,则可以选择导出为 CoreML:

上面的屏幕截图显示了 TensorFlow Lite 中可用的各种导出选项。
大规模训练和包装
TensorFlow 有一个名为tf.distribute.Strategy的 API,可在多个 GPU 之间分配训练。 在这个页面上详细介绍了针对 Google Cloud 的大规模训练。
使用tf.distribute.Strategy API 涵盖了使用 TensorFlow 进行分布式训练。 使用此 API,可以使用多个 GPU 或 TPU 分发 TensorFlow 训练。 有关分布式训练的详细概述(包括示例),请访问这里。
也可以在云计算引擎中设置分布式训练。 为了启用此功能,请在 GCP 中启用 Cloud Shell。 在 TensorFlow 集群中,设置一个主服务器和多个工作程序的虚拟机实例,并在每个这些计算机上执行训练作业。 有关详细信息,您可以转到这里。
应用包装
应用打包涉及将代码,TFRecord文件和模型.confg文件上传到 GCP,模型在训练期间可以访问。 在“在 GCP 中训练对象检测器”的部分中,我们通过使用gcloud打包应用在 GCP 中进行了训练,如下所示:
$ gcloud ml-engine jobs submit training `whoami`_object_detection_`date +%s` --job-dir=gs://${YOUR_GCS_BUCKET}/train --packages dist/object_detection-0.1.tar.gz,slim/dist/slim-0.1.tar.gz,/tmp/pycocotools/pycocotools-2.0.tar.gz --module-name object_detection.model_tpu_main --runtime-version 1.15 --scale-tier BASIC_TPU --region us-central1 -- --model_dir=gs://${YOUR_GCS_BUCKET}/train --tpu_zone us-central1 --pipeline_config_path=gs://${YOUR_GCS_BUCKET}/data/pipeline.config
请注意,在前面的训练中,我们使用了gcloud ml-engine,它可以让您管理 AI 平台作业和训练模型。 还有另一个名为gcloud ai-platform的平台,也可以用来打包您的应用,如下所示:
gcloud ai-platform jobs submit training $JOB_NAME \
--staging-bucket $PACKAGE_STAGING_PATH \
--job-dir $JOB_DIR \
--package-path $TRAINER_PACKAGE_PATH \
--module-name $MAIN_TRAINER_MODULE \
--region $REGION \
-- \
--user_first_arg=first_arg_value \
--user_second_arg=second_arg_value
前面的代码的解释如下:
--staging-bucket:这是暂存training包的云存储路径--job-dir:这是输出文件位置的云存储路径--package-path:这指定应用目录的本地路径--module-name:这指定应用模块的名称--job-dir标志:这是作业目录
基于云的视觉搜索背后的总体思路
在 “第 6 章”,“使用迁移学习的视觉搜索”中,我们学习了如何在本地 PC 上进行视觉搜索。 该方法使用通过神经网络(例如 VGG16 或 ResNet)传递图像,并通过删除最后一个全连接层然后将其与数据库中已知类别的其他图像进行比较以将其转换为图像向量,以找到最近的邻居。 匹配,然后显示结果。
在示例中,我们从 200 张图像开始,但是如果图像数量达到 100 万张并且必须从网页访问结果,则在本地存储图像将毫无意义。 在这些情况下,云存储是最佳的。 在那种情况下,我们可以将图像向量存储,而不是将图像存储在云中,然后在用户上传图像时,将图像转换为向量并将其发送到云中进行处理。 在云中,我们执行 K 近邻搜索以找到并显示最接近的匹配项。 使用 REST API 或消息队列遥测传输(MQTT)服务将图像向量上传到云中。 每个服务都有自己的安全性验证。
在这里,我们将讨论将图像发送到云服务并以 JSON 消息形式接收的基本编码基础架构:
- 客户端请求基础结构:以下代码描述了如何将图像 URL 作为 POST 请求发送到外部 Web 服务器。 此处,
api_host是 Web 服务器地址。headers文件是操作参数,在这种情况下为图像。image_url是实际的图像位置:
api_host = 'https://…/'
headers = {'Content-Type' : 'image/jpeg'}
image_url = 'http://image.url.com/sample.jpeg'
img_file = urllib2.urlopen(image_url)
response = requests.post(api_host, data=img_file.read(),
headers=headers, verify=False)
print(json.loads(response.text))
- 服务器端请求的基础结构:以下代码描述了典型的服务器端代码。 数据库侧的服务器将使用
request.files.get方法请求图像(图片),并且picture.save用于保存图像:
@app.route('/', methods=['POST'])
def index():
picture = request.files.get('file')
picture.save('path/to/save')
return 'ok', 200
前面的代码架构展示了 REST API 方法从云发送和接收图像的基础。 GCP,AWS 和 Azure 具有适当的 API,可以执行视觉搜索,面部识别和许多其他任务。 在以下部分中,将对此进行详细描述。 每个云平台都有自己的向云发送图像数据的方式,这可能彼此不同,但是基本原理与前一个相同。 云网页将以 JSON 格式包含具有可视搜索结果的图像信息,该图像信息可以使用云服务器 URL 和认证方法从本地 PC 访问。
分析各种云平台中的图像和搜索机制
在本节中,我们将讨论使用三种不同的云平台(GCP,AWS 和 Azure)的可视搜索任务。 我们已经在“第 6 章”,“使用迁移学习进行视觉搜索”中,其中我们学习了如何将图像向量与 PC 目录中的大量图像进行比较,来查找基于欧几里得距离的最接近的匹配。 在本部分中,您将学习如何使用 REST API 从 PC 上载图像到云,云搜索引擎将搜索最接近的图像并将其显示。 因此,所有繁重的工作将由云引擎来完成。
请注意,在本节中,介绍了视觉搜索的基本概念。 内容可以更深入,您可以从 GCP,AWS 或 Azure 获取云 API,并将其插入用 Python,C++ 或 JavaScript 编写的应用中,以调用云引擎并执行搜索。
使用 GCP 的视觉搜索
GCP 具有视觉 API,可以执行基于云的图像信息,包括面部检测和图像内容分析。 有关更多详细信息,请访问这里。 在以下屏幕截图中查看为沙发上传的示例结果; 检测连同视觉上类似图像的几个示例一起进行:

正如我们在“第 6 章”,“使用迁移学习进行视觉搜索”时一样,对于视觉上相似的图像,必须在图像类内进行搜索。 如果图像不是来自网络,则很可能会检测到不同类别的相似视觉图像,如此处的沙发示例所示。 但是,如果图像是从网上获取的,则匹配是精确的或非常接近的。
在上一节中,我们学习了如何使用 GCP 进行训练。 AutoML Vision 是轻松完成此任务的另一种方法。 有关详细的分步说明,请转到这里。
要进行视觉搜索,请转到这里。
当您尝试使用 Python 脚本中的 API 时,您将需要以下内容:
- 一个 Google Cloud 帐户,用于设置项目并启用计费。
- 启用 Cloud Vision 产品搜索 API。
- Google 应用凭据 - 密钥文件。
- 选择一个服务帐户并创建它,以便将密钥下载到您的 PC。
- 通过导出以下三个项目在终端中设置环境变量:
GOOGLE_APPLICATION_CREDENTIAL:PC 中的关键路径PROJECT_IDLOCATION_ID- 创建
request.json,然后您将收到一个response.json文件。
使用 AWS 的视觉搜索
AWS 有许多用于计算机视觉的工具。 其中,两个主要工具是 Amazon Rekognition 和 AWS SageMaker。访问 AWS 网站以获取更多满足您需求的工具。 AWS Rekognition 是用于图像和视频分析的基于云的软件即服务(SaaS)平台。 它具有许多功能,例如面部检测和分析,面部搜索和验证以及名人识别。 就像 Google Cloud Vision API 一样,您可以上传图像,它可以提供图像信息的详细信息,如下所示:

在前面的屏幕截图中,正确检测了沙发以及不同的类别以及边界框和图像信息的相应 JSON。 您还可以上传面部图像,它可以提供有关面部表情,年龄和性别的详细信息,以及两个角度不同的面部是否属于同一个人,如下所示:

请注意,面部识别系统能够检测到属于同一个人的两张脸,无论有无太阳镜,它们都是从不同角度拍摄的。
AWS Rekognition 还可以使用boto分析本地 PC 上的图像,如这里所述。
训练期间引入了 AWS SageMaker。 通过将图像转换为向量,它也可以用于执行视觉搜索。 有关详细练习,请参阅这个页面中描述的 Python 笔记本。
请注意,执行此操作的最佳方法是从 AWS SageMaker 笔记本实例运行此操作。 将此文件(在上一链接中列出)上载到 Jupyter 笔记本,然后选择 MXNet Python 包。 引用您的 S3 存储桶并执行单元。 分析代码并将其与我们在“第 6 章”,“使用迁移学习的视觉搜索”中学到的内容进行比较。 您将看到基本原理是相同的,只是分析是在云平台上完成的,因此它将具有在“第 6 章”,“使用迁移学习的视觉搜索”中不必处理的多个认证级别。
使用 Azure 的视觉搜索
Azure 是 Microsoft 的云机器学习平台,用于构建,管理和部署应用。 与 GCP 和 AWS 一样,Azure 具有许多功能,但我们对计算机视觉工作感兴趣的功能是 Azure AI 和 Azure 机器学习。 在 AI 和机器学习中,与计算机视觉相关的应用是 Azure Bot 服务,Azure 认知搜索,Bing 图像搜索,Bing 视觉搜索和计算机视觉。 例如,如果要执行视觉搜索,请转到这里。
在 Azure 云平台中进行可视搜索的基本步骤如下:
- 获取一个 Azure 帐户,然后选择定价信息。
- 获取您的订阅密钥。
- 选择 PC 上
test图像的路径。 - 以
request.post的形式发送搜索请求:
response = requests.post(BASE_URI, headers=HEADERS, files=file)
response.raise_for_status()
在前面的代码中,raise_for_status方法表示如果请求不成功,则会引发异常,例如404 Client Error: NOT FOUND。
注意-由于必须提供信用卡详细信息进行计费,因此云平台的使用可能会变得昂贵。 要注意的关键是,即使您完成了训练工作并关闭了 PC,除非完全关闭云平台中的项目,否则您将继续产生费用。
总结
在本章中,您学习了如何将图像数据发送到云平台进行分析。 在之前的章节中,我们学习了如何在本地 PC 上进行训练,但是在本章中,您学习了如何使用云平台执行相同的任务,以及如何使用 Google Cloud Shell for distribution 在多个实例中触发训练。
本章包含许多示例和链接,通过查看这些链接并进行练习,您将获得更多知识。 然后,我们学习了如何将图像发送到云平台进行实例分析。 图像内容分析已扩展到可以在云平台中执行可视搜索。 我们还学习了如何使用所有三个云平台-GCP,AWS 和 Azure。 请记住,即使您尚未接受训练,也要确保在完成任务后关闭项目,以免产生不必要的费用。
二、使用局部二进制模式的内容识别
局部二进制模式(LBP)于 1994 年由 Timo Ojala,Matti Pietikäinen 和 David Harwood 在国际模式识别会议上,在论文《Performance evaluation of texture measures with classification based on Kullback discrimination of distributions》中首次提出。
在本章中,您将学习如何创建 LBP 图像类型的二进制特征描述符和 LBP 直方图,以对纹理图像和非纹理图像进行分类。 您将了解可用于计算直方图之间的差异以找到各种图像之间的匹配的不同方法,以及如何调整 LBP 参数以优化其表现。
本章将涵盖以下主题:
- 使用 LBP 处理图像
- 将 LBP 应用于纹理识别
- 使面部颜色与基础色匹配 - LBP 及其局限性
- 使用基础色匹配面部颜色 - 颜色匹配技术
使用 LBP 处理图像
LBP 是一种灰度图像阈值操作,用于基于不同的模式对图像进行分类。 通过将邻域像素值与中心像素值进行比较来开发二进制模式,并将其用于构建直方图块。 在以下部分中,我们将详细描述 LBP 操作。
生成 LBP 模式
LBP 模式生成的主要步骤如下:
- 将 RGB 图像
A转换为灰度图像G。 - 对于图像
G中每个具有强度I[c](x, y)的像素,选择P相邻点(p[0], p[1], ..., p[P-1]),其半径[I[0], I[1], ..., I[P-1]具有相应的强度。R。 半径以像素为单位定义为两个像素之间的差。 像素和相邻点代表图像G的滑动窗口W。对于半径R = 1,P变为 8,如下所示。
滑动窗口W₀用W[0] = [I[c], I[0], I[1], I[P-1]]表示为数组。 在这里,点 0 到P-1代表围绕中心像素c的P个点的强度:

确定半径R和相邻点P之间的关系,以使附近的每个像元恰好具有一个像素。 如上图中的前三个圆圈所示,周长中的每个像元恰好具有一个像素,而最后一个像元在周长中填充了多个像素。 从前三个圆圈,我们可以表示,为了使每个单元格都有一个像素,点数P可以表示为(8R + 16) / 3。 下图显示了线性关系和离群值,离群值由左起第四个圆圈显示,在相邻单元格中有重叠点:

- 计算相邻像素和中心像素之间的强度差,并删除第一个值 0。该数组可以表示如下:
W[1] ~ [I[0] - I[c], I[1] - I[c], ..., I[P-1] - I[c]]
- 现在,对图像进行阈值处理。 为此,如果强度差小于 0,则将值分配为 0;如果强度差大于 0,则将值分配为 1,如以下等式所示:

应用阈值函数f之后的差数组如下:
W[2] = [f(I[0] - I[c]), f(I[1] - I[c]), ..., f(I[P-1] - I[c])
例如,假设第一个差异小于 0 且第二个和最后一个差异大于 0,则数组可以表示如下:
W[2] = [0, 1, ... 1]
- 将差数组
W₂乘以二项式权重2^p,将二进制数组W₂转换为表示十进制数组W[LBP]的代码 3:

请注意,本节中描述的五个步骤将在接下来的几节中引用。
下图显示了在灰度图像的滑动窗口上 LBP 操作的图形表示:

在上图中,我们可以看到以下内容:
- 起始的
3 x 3核只是图像的一部分。 - 接下来的
3 x 3是二进制表示形式。 - 左上角的值为 1,因为我们正在比较 120 和 82。
- 顺时针旋转,因为我们将 51 与 82 进行了比较,所以最后一个值为 0。
- 接下来的
3 x 3核只是2^n操作。 - 第一个值是 1(
2^0),最后一个值是顺时针为 128(2^7)。
了解 LBP 直方图
LBP 数组W₃以直方图形式表示如下:
W4 = histogram(W3, bins=P, range=W3(min) to W3(max))
对训练后的图像和测试图像重复上一节中的“步骤 1”至 5,以创建图像(W_train, W_test)的 LBP 直方图,每个都包含P个箱子,然后使用直方图比较方法对其进行比较。
直方图比较方法
可以使用不同的直方图比较方法来计算直方图之间的距离。 这些如下:
- 交叉方法:

在 Python 中,这表示如下:
minima = np.minimum(test_hist,train_hist)
intersection = np.true_divide(np.sum(minima),np.sum(train_hist))
- 卡方方法:

- 欧几里得方法:

- 城市街区方法:

- Bhattacharya 方法:

- Wasserstein 方法:

- 给定
W_test = N(μ_test, σ_test)和W_train = N(μ_train, σ_train),此处μ是分布的平均值(第一矩),o(第二矩)是分布的标准差,而ρ[QQ]为两个分布W_test和W_train的分位数彼此之间的相关性。

前面的距离度量具有以下特征:
- 每种方法的距离绝对值都不相同。
- 除 Wasserstein 方法外,所有方法的测试直方图和训练直方图值之间的最小距离都相似。 Wasserstein 方法根据位置(均值差异),大小(标准差差异)和形状(相关系数)计算距离。
下面显示了给定半径R = 5时的原始灰度图像和相应的 LBP 图像:

接下来,我们将评估半径变化对图像清晰度的影响。 为此,需要通过将半径值从 1 更改为 10 来执行 Python 代码。下图显示了对 LBP 图像清晰度的最终影响。
根据相关性P = (8R + 16) / 3获得到多个点的半径。请注意,随着半径的增加,图像中的图案变得更加清晰。 围绕半径 5 和点 20-25,该图案在主拱的主要图案和次要图案之间变得更加清晰。 在很大的半径上,辅助图案变得不太明显:

从前面的图像中还可以清楚地看到以下内容:
- 选择
R和P对于模式识别很重要。 - 可以通过
P = (8R + 16) / 3来选择初始值,但是对于给定的R,超过此值的P的值并不意味着不良表现,如先前示例中的R = 5,P = 25所示。 - 选择的模式明显优于
R = 4,P = 16示例,并且与R = 5.5,P = 20非常相似。
另外,请注意,此处的示例仅提供适用于此图像的准则。 对于不同尺寸的图像,请从此示例中学习,首先选择P的初始值,然后调整R和P以获得所需模式。
LBP 的计算成本
与传统的神经网络方法相比,LBP 在计算上更便宜。 LBP 的计算成本由 Li Li,Paul Fieguth,Wang Xiaogang Wang,Matti Pietikäinen 和 Dewen Hu 在他们的论文《使用新的稳健性基准评估 LBP 和深纹理描述符》中提出。 论文的详细信息可以在这里找到。
作者确定了在 2.9 GHz Intel Quad-Core CPU 和 16 GB RAM 上对 480 张图像进行特征提取所花费的平均时间,这些图像的大小为128 x 128。 该时间不包括训练时间。 研究发现,与被认为中等的 AlexNet 和 VGG 相比,LBP 特征提取非常快。
将 LBP 应用于纹理识别
既然我们了解了 LBP 的基础知识,我们将把它应用于纹理识别示例。 对于此示例,已将 11 张训练后的图像和 7 张尺寸为50 x 50的测试图像分为以下几类:
- 训练图像
- 图案图像(7)
- 普通图像(4)
- 测试图像
- 图案图像(4)
- 普通图像(3)
执行“生成 LBP 模式”部分的“步骤 1”至 5 ,然后将每个测试图像的 LBP 直方图与所有训练图像进行比较,以找到最佳匹配。 尽管已使用了不同的直方图比较方法,但是对于此分析,将使用卡方检验作为确定匹配的主要方法。 具有正确匹配项的最终摘要输出用绿线显示,而错误匹配项将用红线显示。 实线是最短距离的第一个匹配项,而虚线是下一个最佳匹配项。 如果用于下一个最佳匹配的直方图之间的距离比最小距离远得多,则仅显示一个值(最小距离),这表明系统对此输出具有相当高的置信度。
下图显示了使用 LBP 在测试和训练灰度图像之间的匹配过程。 实线表示最接近的匹配,而虚线表示第二最接近的匹配。 第三张测试图像(从左起)只有一个匹配项,这意味着当图像转换为灰度时,模型对其预测非常有信心。 第二个,第三个和第六个训练图像(从右侧开始)没有相应的测试图像匹配:

在这里,我们可以看到,基于有限的训练数据(11 个样本),LBP 通常会产生很好的匹配,在考虑的七个测试样本中只有一个错误。 要了解在上一张图像中如何完成相关性,我们需要绘制 LBP 直方图并比较训练图像和测试图像之间的直方图。 下图分析每个测试图像,并将其直方图与相应测试图像的直方图进行比较,以找出最匹配的图像。
n_points = 25表示 LBP 中有 25 点。 使用 LBP 直方图的主要优点是可实现平移的归一化,从而使其旋转不变。 我们将逐一分析每个直方图。 直方图的x轴为 25,表示点数(25),而y轴为 LBP 直方图块。
下图中显示的两个图像都具有图案并且看起来相似:

先前图像的直方图分析显示了相似的模式,使用 LBP 可以显示正确的匹配。 下图中显示的两个图像都具有图案并且看起来相似。 实际上,它们是从不同的方向和不同的阴影获取的同一张地毯图像:

先前图像的直方图分析显示了相似的模式,使用 LBP 可以显示正确的匹配。 下图中显示的两个图像具有图案,但是它们来自不同的地毯:

先前图像的直方图分析显示了相似的模式。 它们的样式看起来相似,但图像实际上不同。 因此,这是匹配不良的一个示例。
下一张图像中的第一张图像具有图案(与我们已经看到的图像相比,它是一种较弱的图案),而经过训练的图像则完全没有图案,但是在地毯上似乎有污渍:

先前图像的直方图分析显示了相似的模式。 它们的样式看起来相似,但图像实际上不同。 这是比赛不佳的另一个例子。 由于红地毯上的污渍,LBP 似乎认为图像相似。
下图显示了 LBP 将灰色地毯与前面相同的红色地毯相匹配:

LBP 直方图显示了类似的趋势–这是合理的,因为 LBP 是一种灰度图像识别技术。
下图显示了 LBP 将硬木地板与地毯相匹配:

请注意,训练图像没有硬木地板,因此 LBP 发现具有叶子形状的地毯是与具有木纹的木地板最接近的匹配。
最后一个 LBP 图片显示相似的图片,几乎没有图案:

在这里,LBP 预测似乎是正确的。
比较顶部直方图和底部直方图,以可视化直方图如何比较测试图像和训练图像。 可以在这个页面中找到详细的 Python 代码。
使面部颜色与基础颜色匹配 - LBP 及其局限性
由于我们在纹理识别方面使用 LBP 取得了相对良好的成功,因此让我们尝试另一个示例来了解 LBP 的局限性。 在此示例中,从浅色到深色(测试)的七种面部颜色将与 10 种基础色(训练)相匹配,这些基础色是50 x 50的图像。
与纹理识别示例类似,将应用“生成 LBP 模式”部分中的“步骤 1”至 5,然后将每个面部彩色图像 LBP 直方图与与所有基础彩色图像 LBP 直方图一起比较来找到最佳匹配。 尽管已使用不同的直方图比较方法,但对于此分析,将使用卡方检验作为确定匹配的主要方法。 下图显示了最终的摘要输出:

如我们所见,LBP 的效果不佳,所有脸部颜色都导致底色为 4 或 8。 为了理解这种情况,已绘制了 RGB,灰度和 LBP 图像的两个级别(一个带有R2.5, P12,另一个带有R5.5, P20)。 这是由两个因素引起的:
- 面部颜色从 RGB 到灰度的转换会导致图像中不必要的亮度,这在比较过程中会产生误导。
- LBP 转换采用这些模式并生成无法正确解释的任意灰色阴影。
下图显示了两个图像-面部颜色 1 和 7-分别代表肤色和深色皮肤的颜色,以及 LBP 不同步骤的结果。 每个图像都会转换为灰度,这表明两个图像的中间都有一个亮点,而原始彩色图像无法看到该亮点。 然后,将两个 LBP 操作应用于图像:一个半径为 2.5,另一个半径为 5.5。 在这里,我们可以看到在应用 LBP 之后有很多相似之处,这是原始彩色图像所没有的。 让我们看一下下面的图片:

解决第一个问题的可能方法是应用高斯滤波,我们已在“第 1 章”,“计算机视觉和 TensorFlow 基本原理”中进行了研究,以抑制该模式。 下图可以看到应用高斯过滤器然后进行 LBP 的结果:

即使在应用过滤器之后,也无法清晰地区分浅灰和深灰这两种灰色阴影。 由此可以得出结论,LBP 并不是用于面部颜色识别的好方法。
使脸部颜色与基础颜色匹配 – 颜色匹配技术
对于这种方法,RGB 图像不会转换为灰度; 而是使用以下 Python 代码(针对每种情况重复)确定七种面部颜色和 10 种基础颜色中的每一种的颜色强度值:
facecol1img = Image.open('/…/faceimage/facecol1.JPG')
facecol1arr = np.asarray(facecol1img)
(mfc1, sfc1) = cv2.meanStdDev(facecol1arr)
statfc1 = np.concatenate([mfc1, sfc1]).flatten()
print ("%s statfc1" %(statfc1))
输出具有六个元素。 前三个是 RGB 平均值,而后三个是 RGB 值的标准差。
面部和底色之间的强度差计算如下:

让我们看一下下面的图像,它代表了脸部和底色:

矩阵中差异最小的值是最佳匹配。 我们可以看到,对于每种脸部颜色,匹配(如对角线上的最小限度点所示)可得出合理的值,这表明颜色匹配技术应该是与基础色进行脸部颜色匹配的首选方法 。
总结
在本章中,我们学习了如何获取图像像素并将其与给定半径内的相邻像素阈值化,然后执行二进制和积分运算以创建 LBP 模式。 LBP 模式是无监督机器学习的一个很好的例子,因为我们没有用输出训练分类器。 相反,我们学习了如何调整 LBP 的参数(半径和点数)以达到正确的输出。 发现 LBP 是用于纹理分类的非常强大且简单的工具。 但是,当图像为非纹理图像时,LBP 无法返回良好的结果,我们学习了如何开发 RGB 颜色匹配模型来匹配彩色的非纹理图像,例如面部和基础色。 要创建 LBP 表示,必须将图像转换为灰度。
在下一章中,我们将结合各种边缘检测方法来识别人脸,眼睛和耳朵,介绍积分图像的概念。 然后,我们将介绍卷积神经网络,并使用它来确定面部关键点和面部表情。
三、使用 OpenCV 和 CNN 的人脸检测
面部检测是计算机视觉的重要组成部分,并且是近年来发展迅速的领域。 在本章中,您将从 Viola-Jones 面部和关键特征检测的简单概念开始,然后继续介绍基于神经网络的面部关键点和面部表情检测的高级概念。 本章将以 3D 人脸检测的高级概念作为结尾。
本章将涵盖以下主题:
- 应用 Viola-Jones AdaBoost 学习和 Haar 级联分类器进行人脸识别
- 使用深度神经网络预测面部关键点
- 使用 CNN 预测面部表情
- 3D 人脸检测概述
应用 Viola-Jones AdaBoost 学习和 Haar 级联分类器进行人脸识别
2001 年,微软研究院的保罗·维奥拉和三菱电机的迈克尔·琼斯通过开发名为 Haar 级联分类器 的分类器,开发了一种检测图像中人脸的革命性方法。Haar 级联分类器基于 Haar 特征,这些特征是矩形区域中像素值差异的总和。 校准差值的大小以指示面部给定区域(例如,鼻子,眼睛等)的特征。 最终的检测器具有 38 个级联分类器,这些分类器具有 6,060 个特征,包括约 4,916 个面部图像和 9,500 个非面部图像。 总训练时间为数月,但检测时间非常快。
首先,将图像从 RGB 转换为灰度,然后应用图像过滤和分割,以便分类器可以快速检测到对象。 在以下各节中,我们将学习如何构造 Haar 级联分类器。
选择类似 Haar 的特征
Haar 级联分类器算法基于这样的思想,即人脸的图像在脸部的不同区域具有强度的独特特征,例如,脸部的眼睛区域比眼睑底部暗,鼻子区域比旁边的两个面部区域更亮。 类似于 Haar 的特征由黑色和白色的相邻矩形表示,如下图所示。 在此图像中,存在几个潜在的类似 Haar 的特征(两个矩形,三个矩形和四个矩形):

请注意,矩形部分放置在面部的特征上。 由于眼睛区域的强度比脸部暗,因此矩形的黑色区域靠近眼睛,白色区域低于眼睛。 同样,由于鼻子区域比周围的环境明亮,鼻子上出现白色矩形,而两侧则是黑色矩形。
创建一个完整的图像
积分图像可用于一次快速计算矩形特征像素值。 为了更好地理解积分图像,让我们看一下其计算的以下细分:
- 可以将 Haar 样特征的值计算为白色区域中的像素值之和与黑色区域中的像素值之和之差。
- 像素
I的总和(x,y)可以由当前像素位置左上方和上方所有像素的值[i(x,y),包括当前像素值,可以表示为:

在下图中,I(x, y)是由九个像素值组成的最终积分图像值(62,51,51,111,90,77,90,79和73)。 将所有这些总和得出 684 的值:

下图显示了脸部的眼睛区域的像素强度和相应的积分图像:

上图显示,矩形区域的像素强度总和是通过将上方和左侧的所有像素值相加得出的,例如,917通过将866(这是73, 79, 90, 111, ..., 68的总和)和10,14,9和18。 注意,917也可以通过将717求和,然后将其加到50,64和68和18的总和来获得。
前面的像素方程式的总和可以重写如下:

在积分图像中,可以通过将四个数组(如前面的方程式所示)相加来计算图像中任何矩形区域的面积,而不是针对所有单个像素的总和进行六个内存访问。 Haar 分类器的矩形总和可以从前面的方程式获得,如以下方程式所示:

前面的等式可以重新安排如下:

下图显示了转换为整数图像像素值的图像像素值:

右侧的积分图像就是左侧像素值的总和-所以113 = 62 + 51,依此类推。 黑色阴影区域像素值表示黑色 Haar 矩形,如前所述。 为了计算阴影区域的强度值,我们取整数强度值 1,063,然后从中减去 268。
进行 AdaBoost 训练
图像被划分为T窗口,在其中应用了类似 Haar 的特征,并如前所述计算其值。 AdaBoost 通过迭代T窗口的训练集,从大量弱分类器中构建出一个强分类器。 在每次迭代中,基于多个正样本(面部)和多个负样本(非面部)来调整弱分类器的权重,以评估分类错误的项目的数量。 然后,对于下一次迭代,将为错误分类的项目的权重分配更高的权重,以增加检测到这些权重的可能性。 最终的强分类器h(x)是根据弱分类器的误差加权的组合。
- 弱分类器:每个弱分类器都具有一个特征
f。 它具有极性p和阈值θ:

- 强分类器:最终的强分类器
h(x)具有最小的误差,Eₜ,并由以下给出:

在此,E[t] = log(1 / E[t])和E[t] = E[t] / (1 - E[t]):

权重(Wₜ)初始化如下:

在此,P和N分别是正样本和负样本的数量。 权重值更新如下:

每个弱分类器都会计算一个特征。 请注意,弱分类器无法单独进行分类,但是将其中几个组合在一起可以很好地进行分类。
注意级联分类器
前面描述的每个强分类器形成一个级联,其中每个弱分类器代表一个阶段,可以快速删除负子窗口并保留正子窗口。 来自第一个分类器的肯定响应表示已检测到脸部区域(例如,眼睛区域),然后算法继续进行下一个特征(例如,鼻子区域)以触发第二个区域的分类器的评估,依此类推。 任何时候的负面结果都会导致该阶段立即被拒绝。 下图说明了这一点:

此图显示负特征已被立即消除。 随着分类从左向右移动,其准确率会提高。
训练级联检测器
开发了整个训练系统,以最大程度地提高检测率并最大程度地降低假阳性率。 Viola 和 Jones 通过为级联检测器的每个阶段设置目标检测率和假阳性率,实现了以下目标:
- 级联检测器每一层中的特征数量都会增加,直到达到该层的目标检测率和假阳性目标为止。
- 如果总体假阳性率不够低,则添加另一个阶段。
- 矩形特征将添加到当前阶段,直到达到其目标速率。
- 当前阶段的假阳性目标被用作下一阶段的阴性训练集。
下图显示了 OpenCV Python Haar 级联分类器,用于分类正面和眼睛以检测面孔和眼睛。 左图和右图均显示它可以正确检测到脸部; 然而,在第一图像中,由于左眼的眩光而仅检测到右眼,而在第二图像中检测到双眼。 Viola-Jones 级联检测方法查找强度梯度(眼睛区域比下面的区域暗),在这种情况下,由于眼镜右镜片的眩光,它无法在右眼中检测到 :

可在这个页面中找到用于摄像头视频中的面部和眼睛检测的 OpenCV Python 代码。 请注意,为了使代码起作用,您需要在文件夹中指定 Haar 级联检测器所在的路径。
到目前为止,我们已经了解了 Haar 级联分类器,以及如何使用内置的 OpenCV 代码将 Haar 级联分类器应用于面部和眼睛检测。 前述概念基于使用积分图像检测类似 Haar 的特征。 该方法非常适合面部,眼睛,嘴巴和鼻子的检测。 但是,可以将不同的面部表情和皮肤纹理用于情感(快乐与悲伤)或年龄确定等。 Viola-Jones 方法不适用于处理这些不同的面部表情,因此我们需要使用 Viola-Jones 方法进行面部检测,然后应用神经网络确定面部边界框内的面部关键点。 在下一节中,我们将详细学习此方法。
使用深度神经网络预测面部关键点
在本节中,我们将讨论面部关键点检测的端到端管道。 面部关键点检测对于计算机视觉来说是一个挑战,因为它要求系统检测面部并获取有意义的关键点数据,将这些数据绘制在面部上,并开发出神经网络来预测面部关键点。 与对象检测或图像分类相比,这是一个难题,因为它首先需要在边界框内进行面部检测,然后再进行关键点检测。 正常的对象检测仅涉及检测代表对象周围矩形边界框的四个角的四个点,但是关键点检测需要在不同方向上的多个点(超过 10 个)。 可以在这个页面上找到大量的关键点检测数据及其使用教程。 Kaggle 关键点检测挑战涉及一个 CSV 文件,该文件包含指向 7,049 个图像(96 x 96)的链接,每个图像包含 15 个关键点。
在本部分中,我们将不使用 Kaggle 数据,但将向您展示如何准备自己的数据以进行关键点检测。 有关该模型的详细信息,请参见这里。
准备用于关键点检测的数据集
在本节中,您将学习如何创建自己的数据。 这涉及编写代码并执行代码,以使 PC 中的网络摄像头点亮。 将您的脸部移动到不同的位置和方向,然后按空格键,在裁剪掉图像中的所有其他内容后,它将保存您的脸部图像。 此过程的关键步骤如下:
- 首先,我们从指定 Haar 级联分类器的路径开始。 它应该位于您的
OpenCV/haarcascades目录中。 那里将有很多.xml文件,因此请包含frontalface_default.xml的路径:
face_cascade = cv2.CascadeClassifier('path tohaarcascade_frontalface_default.xml')
- 接下来,我们将使用
videoCapture(0)语句定义网络摄像头操作。 如果您的计算机已插入外部摄像机,则可以使用videoCapture(1):
cam = cv2.VideoCapture(0)
- 相机帧使用
cam.read()读取数据,然后在每个帧内,使用“步骤 1”中定义的 Haar 级联检测器检测面部。 使用(x,y,w,h)参数在检测到的面部周围绘制一个边框。 使用cv2.imshow参数,屏幕上仅显示检测到的面部:
while(True):
ret, frame = cam.read()
faces = face_cascade.detectMultiScale(frame, 1.3, 5)
for (x,y,w,h) in faces:
if w >130:
detected_face = frame[int(y):int(y+h), int(x):int(x+w)]
cv2.imshow("test", detected_face)
if not ret:
break
k = cv2.waitKey(1)
- 接下来,将图像调整为
img_size,将其定义为299,并将结果图像保存在数据集目录中。 注意,在本练习中我们使用299的图像大小,但是可以更改。 但是,如果您决定更改它,请确保在标注文件的创建以及最终模型中进行更改,以避免标注和图像之间的不匹配。 现在,在此 Python 代码所在的目录中创建一个名为dataset的文件夹。 请注意,每次按空格键时,图像文件号都会自动增加:
faceresize = cv2.resize(detected_face, (img_size,img_size))
img_name = "dataset/opencv_frame_{}.jpg".format(img_counter)
cv2.imwrite(img_name, faceresize)
为不同面部表情的不同人创建约 100 幅或更多图像(对于该测试,我总共拍摄了 57 张图像)。 如果您有更多图像,则检测会更好。 请注意,Kaggle 面部点检测使用 7,049 张图像。 拍摄所有图像并使用 VGG 标注器执行面部关键点标注,您可以从这里获得该标注器。 您可以使用其他选择的标注工具,但是我发现此工具(免费)非常有用。 它绘制边界框以及不规则形状和绘制点。 在本练习中,我加载了所有图像,并使用点标记在图像中绘制了 16 个点,如下图所示:

上图中的 16 个点代表左眼(1-3),右眼(4-6),鼻子(7),嘴唇(8-11)和外面(12-16)。 请注意,当我们以数组形式显示图像关键点时,它们将被表示为 0–15 而不是 1–16。 为了获得更高的准确率,您只能捕获面部图像,而不是任何周围环境。
处理关键点数据
VGG 标注器工具会生成一个输出 CSV 文件,该文件需要进行两次预处理才能为每个图像的 16 个关键点分别生成(x, y)坐标。 对于大数据处理来说,这是一个非常重要的概念,您可以将其用于其他计算机视觉任务,主要有以下三个原因:
- 我们的 Python 代码不会直接在目录中搜索大量图像文件,而是会在输入 CSV 中搜索数据路径。
- 对于每个 CSV 文件,有 16 个相应的关键点需要处理。
- 这是使用 Keras
ImageDataGenerator和flow_from_directory方法浏览目录中每个文件的替代方法。
为了澄清此内容,本节分为以下两个小节:
- 在输入 Keras-Python 代码之前进行预处理
- Keras–Python 代码中的预处理
让我们详细讨论每个。
输入 Keras-Python 代码之前的预处理
VGG 标注器工具会生成一个输出 CSV 文件,该文件需要以我们的 TensorFlow 代码可接受的格式进行预处理。 标注的输出是一个 CSV 文件,该 CSV 文件以行格式显示每个关键点,每个图像有 16 行。 我们需要对该文件进行预处理,以便每个图像有一行。 共有 33 列,指示 32 个关键点值和1图像值,如下所示:
(x0, y0), (x1, y1), (x2, y2), …, (x15, y15),图像文件名
您可以使用自定义 Python 程序对此进行转换,尽管此处未显示。 GitHub 页面包含已处理的 CSV 文件,在这里供您参考。
Keras–Python 代码中的预处理
在本节中,我们将以X和Y数据的形式读取 CSV 文件,其中X是与每个文件名相对应的图像,而Y具有 16 个关键点坐标的 32 个值。 然后,我们将每个关键点的Y数据切片为 16 Yx和Yy坐标。 详细步骤如下所示:
- 使用标准 Python 命令阅读上一部分的 CSV 文件。 在此,我们使用位于
faceimagestrain目录中的两个 CSVtrainimgface.csv和testimgface.csv。 如果需要,可以使用其他文件夹:
train_path = 'faceimagestrain/trainimgface.csv'
test_path = 'faceimagestrain/testimgface.csv'
train_data = pd.read_csv(train_path)
test_data = pd.read_csv(test_path)
- 接下来,我们在 CSV 文件中找到与图像文件相对应的列。 在以下代码中,图像文件的列名称为
'image':
coltrn = train_data['image']
print (coltrn.shape[0])
- 接下来,我们初始化两个图像数组
imgs和Y_train。 我们读取train_data数组以向image列添加路径,并在for循环中读取coltrn.shape[0]定义的 50 个图像文件中的每个图像文件,并将其附加到图像数组中。 使用OpenCV BGR2GRAY命令将读取的每个图像转换为灰度。 在同一for循环中,我们还使用training.iloc[i,:]命令读取 32 列中的每一列,并将其附加到Y_train的数组中:
imgs = []
training = train_data.drop('image',axis = 1)
Y_train = []
for i in range (coltrn.shape[0]):
p = os.path.join(os.getcwd(), 'faceimagestrain/'+str(coltrn.iloc[i]))
img = cv2.imread(p, 1)
gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
imgs.append(gray_img)
y = training.iloc[i,:]
Y_train.append(y)
- 最后,使用以下代码将图像转换为称为
X_train的 NumPy 数组,这是输入 Keras 模型所必需的:
X_train = np.asarray(imgs)
Y_train = np.array(Y_train,dtype = 'float')
print(X_train.shape, Y_train.shape)
- 对测试数据重复相同的过程。 现在我们已经准备好训练和测试数据。 在继续之前,我们应该可视化图像中的关键点,以确保它们看起来不错。 使用以下命令完成此操作:
x0=Y_trainx.iloc[0,:]
y0=Y_trainy.iloc[0,:]
plt.imshow(np.squeeze(X_train[0]),cmap='gray')
plt.scatter(x0, y0,color ='red')
plt.show()
在前面的代码中,np.squeeze用于删除最后一个尺寸,因此图像中只有x和y值。 plt.scatter在图像顶部绘制关键点。 输出如下图所示:

上图显示了叠加在图像顶部的 16 个关键点,表示图像和关键点对齐。 左图和右图表示训练和测试图。 此视觉检查对于确保所有预处理步骤都不会导致不正确的面对点对齐至关重要。
定义模型架构
该模型涉及使用卷积神经网络(CNN)处理面部图像及其 16 个关键点。 有关 CNN 的详细信息,请参阅“第 4 章”,“图像深度学习”。 CNN 的输入是训练图像和测试图像及其关键点,其输出将是与新图像相对应的关键点。 CNN 将学习预测关键点。 下图显示了模型架构的详细信息:

先前模型的代码如下:
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape=(299,299,1), padding='same', activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))
model.add(Conv2D(256, (3, 3), activation='relu'))
model.add(Conv2D(256, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(500, activation='relu'))
model.add(Dense(500, activation='relu'))
model.add(Dense(32))
该代码拍摄一张图像,并应用 32 个大小为(3, 3)的卷积过滤器,然后激活和最大池化层。 它重复相同的过程多次,并增加过滤器的数量,然后是平坦且密集的层。 最终的密集层包含 32 个元素,分别代表我们要预测的关键点的x和y值。
为关键点预测训练模型
现在我们已经定义了模型,在本小节中,我们将编译模型,重塑模型的输入,并通过执行以下步骤开始训练:
- 我们将从定义模型损失参数开始,如下所示:
adam = Adam(lr=0.001)
model.compile(adam, loss='mean_squared_error', metrics=['accuracy'])
- 然后,对数据进行整形以输入到 Keras 模型。 重塑数据很重要,因为 Keras 希望以 4D 形式显示数据-数据数(50),图像宽度,图像高度 1(灰度):
batchsize = 10
X_train= X_train.reshape(50,299,299,1)
X_test= X_test.reshape(7,299,299,1)
print(X_train.shape, Y_train.shape, X_test.shape, Y_test.shape)
模型X和Y参数说明如下:
X_train (50, 299, 299, 1)1 的训练数据,图像宽度,图像高度,灰度Y_train (50, 32)#训练数据,关键点数-在这里,我们有x和y值的 16 个关键点,使其成为 32X_test (7, 299, 299, 1)1 个测试数据,图像宽度,图像高度,灰度Y_test (7, 32)#测试数据,#关键点-在这里,我们为x和y值有 16 个关键点,使其成为 32
- 训练是通过
model.fit命令启动的,如下所示:
history = model.fit(X_train, Y_train, validation_data=(X_test, Y_test), epochs=20, batch_size=batchsize)
训练步骤的输出如下图所示:

该模型在大约 10 个时间周期内获得了相当好的准确率,但损失项约为 7000。我们需要收集更多的图像数据,以将损失项降至 1 以下:
- 我们将使用
model.predict根据测试数据X_test预测模型输出y_val。 测试数据X_test是图像,但是它们已经以模型可以理解的数组形式进行了预处理:
y_val = model.predict(X_test)
- 请注意,此处
y_val对于每个预处理的图像数组输入都有 32 个点。 接下来,我们将 32 个点细分为代表 16 个关键点的x和y列:
yvalx = y_val[::1,::2]
yvaly = y_val[:, 1::2]
- 最后,使用以下代码在图像上方绘制预测的 16 个关键点:
plt.imshow(np.squeeze(X_test[6]),cmap='gray')
plt.scatter(yvalx[6], yvaly[6], color = 'red')
plt.show()
请注意,对于 50 张图片,模型预测效果不是很好; 这里的想法是向您展示该过程,以便您随后可以通过收集更多图像在此代码的基础上进行构建。 随着图像数量的增加,模型精度将提高。 尝试为不同的人和不同的方向拍摄图像。 如“第 9 章”,“使用多任务深度学习的动作识别”中所述,可以将此处描述的技术扩展为与身体关键点检测一起使用。 此外,“第 11 章”,“通过 CPU/GPU 优化在边缘设备上进行深度学习”,在 Raspberry Pi 上针对 OpenVINO 提供了一个部分,其中提供了 Python 代码,基于 OpenVINO 工具包预训练模型的集成来预测和显示 35 个面部关键点 。
使用 CNN 预测面部表情
面部表情识别是一个具有挑战性的问题,因为面部,光线和表情(嘴巴,眼睛睁开的程度等)各不相同,并且还需要开发一种架构并选择可以持续获得较高对比度的参数。 准确率。 这意味着挑战不仅在于在一个照明条件下为一个人正确确定一个面部表情,而且要在所有照明条件下正确识别所有戴着或不戴眼镜,帽子等的人的所有面部表情。 以下 CNN 示例将情感分为七个不同的类别:愤怒,反感,害怕,快乐,悲伤,惊讶和中立。 面部表情识别所涉及的步骤如下:
- 导入函数-
Sequential,Conv2D,MaxPooling2D,AvgPooling2D,Dense,Activation,Dropout和Flatten。 - 导入
ImageDataGenerator-通过实时增强(定向)生成一批张量图像。 - 确定分类的批量大小和周期。
- 数据集-训练,测试和调整大小
(48, 48)。 - 建立 CNN 架构(如下图所示)。
- 使用
fit-generator()函数训练开发的模型。 - 评估模型。
下图显示了 CNN 架构:

下图显示了模型的结果。 在大多数情况下,它可以正确预测面部表情:

很清楚地检测到强烈的情感(笑脸或生气的脸)。 CNN 模型能够正确预测各种情感,甚至微妙的情感。
3D 人脸检测概述
3D 面部识别涉及测量面部中刚性特征的几何形状。 通常是通过使用飞行时间,测距相机生成 3D 图像或从对象的 360 度方向获取多个图像来获得的。 传统的 2D 相机将 3D 空间转换为 2D 图像,这就是为什么深度感应是计算机视觉的基本挑战之一的原因。 基于飞行时间的深度估计基于光脉冲从光源传播到物体再返回到相机所需的时间。 同步光源和图像获取深度。 飞行时间传感器能够实时估计全深度帧。 飞行时间的主要问题是空间分辨率低。 3D 人脸识别可以分为以下三个部分:
- 3D 重建的硬件设计概述
- 3D 重建和跟踪概述
- 参数化跟踪概述
3D 重建的硬件设计概述
3D 重建涉及相机,传感器,照明和深度估计。 3D 重建中使用的传感器可以分为三类:
- 多视图设置:具有受控照明的经过校准的密集立体摄像机数组。 从每个立体对中,使用三角剖分重构面部几何形状,然后在加强几何一致性的同时进行聚合。
- RGB 照相机:组合多个 RGB 照相机以基于飞行时间方法计算深度。
- RGBD 摄像机:RGBD 摄像机同时捕获颜色和深度-例如 Microsoft Kinect,Primesense Carmine 和 Intel Realsense。
3D 重建和跟踪概述
3D 面部重建包括通过构造 CNN 通过使深度回归来从对应的 2D 图像估计 3D 面部的坐标。 下图以图形方式说明了这一点:

实时 3D 曲面贴图的一些流行算法描述如下:
- Kinect Fusion:使用 Kinect 深度传感器的实时 3D 构造。 Kinect 是一种商品传感器平台,其中包含 30 Hz 的基于结构的飞行时间深度传感器。
- 动态融合:使用单个 Kinect 传感器使用体积 TSDF(截断有符号距离融合)技术的动态场景重建系统。 它需要一个嘈杂的深度图,并通过估计体积 6D 运动场来重建实时 3D 运动场景。
- Fusion4D:这使用多个实时 RGBD 摄像机作为输入,并使用体积融合以及使用密集对应字段的非刚性对齐来处理多个图像。 该算法可以处理较大的帧到帧运动和拓扑更改,例如,人们快速脱下外套或从左到右更改其面部方向。
- Motion2Fusion:此方法是用于实时(每秒 100 帧)重建的 360 度表现捕获系统。 它基于具有学习的 3D 嵌入的非刚性对齐策略,快速匹配策略,用于 3D 对应估计的机器学习以及用于复杂拓扑更改的后向/向前非刚性对齐策略。
参数化跟踪概述
面部跟踪模型将投影的线性 3D 模型用于摄像机输入。 它执行以下操作:
- 跟踪从前一帧到当前帧的视觉特征
- 对齐 2D 形状来跟踪特征
- 根据深度测量计算 3D 点云数据
- 最小化损失函数
总结
尽管由于各种肤色,方向,面部表情,头发颜色和光照条件而引起的复杂性,面部识别仍然是计算机视觉的成功故事。 在本章中,我们学习了面部检测技术。 对于每种技术,您都需要记住,面部检测需要大量训练有素的图像。 人脸检测已在许多视频监控应用中广泛使用,并且 Google,亚马逊,微软和英特尔等公司的基于云的设备和边缘设备均可使用标准 API。 我们将在“第 11 章”,“对具有 CPU/GPU 优化功能的边缘设备进行深度学习”中了解基于云的 API,并在“第 4 章”,“图像深度学习”,和第 5 章,“神经网络架构和模型”。 在本章中,简要介绍了用于面部检测和表情分类的 CNN 模型。
在下一章中,将详细说明 CNN。 这将帮助您了解 CNN 的构造块,为何选择某些功能块以及每个块在最终对象检测指标中的作用。 之后,我们将参考 “第 3 章”,“使用 OpenCV 和 CNN 进行面部检测”的示例,以评估如何优化 CNN 参数以更好地进行面部检测。
四、用于图像的深度学习
边缘检测的概念在“第 1 章”,“计算机视觉和 TensorFlow 基础知识”中进行了介绍。 在本章中,您将学习如何使用边缘检测在体积上创建卷积运算,以及不同的卷积参数(例如过滤器大小,尺寸和操作类型(卷积与池化))如何影响卷积体积(宽度与深度)。 本章将为您提供有关神经网络如何查看图像以及图像如何使用可视化对图像进行分类的非常详细的概述。 您将从建立第一个神经网络开始,然后在图像通过其不同层时对其进行可视化。 然后,您将网络模型的准确率和可视化与诸如 VGG 16 或 Inception 之类的高级网络进行比较。
请注意,本章和下一章将提供神经网络的基础理论和概念以及当今实际使用的各种模型。 但是,这个概念是如此广泛,以至于不可能将您需要了解的所有内容都放在这两章中。 因此,为了便于阅读,将为每章讨论的主题引入其他概念,从“第 6 章”,“使用迁移学习的视觉搜索”开始,请参考这些章节,以防您不得不阅读本书。
在本章中,我们将介绍以下主题:
- 了解 CNN 及其参数
- 优化 CNN 参数
- 可视化神经网络的各个层
了解 CNN 及其参数
卷积神经网络(CNN)是一种自学习网络,它通过观察不同类别的图像来对类似于人类大脑学习方式的图像进行分类。 CNN 通过应用图像滤波并处理各种过滤器大小,数量和非线性运算的方法来学习图像的内容。 这些过滤器和操作应用于多个层,以便在图像转换过程中,每个后续层的空间尺寸减小,并且其深度增大。
对于每个过滤应用,所学内容的深度都会增加。 首先从边缘检测开始,然后识别形状,然后识别称为特征的形状集合,依此类推。 当我们理解信息时,这类似于人脑。 例如,在阅读理解测试中,我们需要回答关于段落的五个问题,每个问题都可以视为一类,需要从段落中获得特定信息的必须回答的问题:
-
首先,我们浏览整个通道,这意味着空间维度是完整的通道,而深度(我们对通道的理解)很小,因为我们只是浏览了整个通道。
-
接下来,我们浏览问题以了解每个类的特征(问题),即在文章中寻找的内容。 在 CNN 中,这等效于考虑要使用哪些卷积和池化操作来提取特征。
-
然后,我们阅读文章的特定部分,以找到与全类相似的内容,并深入探讨这些部分–在这里,空间维度很小,但深度很大。 我们重复此过程 2 至 3 次,以回答所有问题。 我们将继续加深我们的理解深度,并更加专注于特定领域(缩小维度),直到我们有一个很好的理解为止。 在 CNN 中,这等效于逐渐增加深度并缩小尺寸–卷积操作通过更改过滤器数量来更改深度; 合并会缩小尺寸。
-
为了节省时间,我们倾向于跳过段落以找到与答案匹配的相关段落。 在卷积中,这等效于跨步,跨步会缩小尺寸,但不会更改深度。
-
下一步是将问题与文章的答案相匹配。 我们通过在精神上使问题的答案保持一致来做到这一点。 在这里,我们不会做得更深入–我们将问题和答案并排放置,以便我们进行匹配。 在 CNN 中,这等效于展平并使用全连接层。
-
在此过程中,我们可能会有过多的信息–我们将其删除,以便仅与段落中的问题相关的信息可供我们使用。 在 CNN 中,这等效于丢弃。
-
最后一个阶段实际上是进行匹配练习以回答问题。 在 CNN 中,这等效于 Softmax 操作。
CNN 的图像过滤和处理方法包括执行多种操作,所有这些操作都可以通过以下方式进行:
- 卷积(Conv2D)
- 卷积 –
3 x 3过滤器 - 卷积 –
1 x 1过滤器 - 池化
- 填充
- 跨步
- 激活
- 全连接层
- 正则化
- 丢弃
- 内部协方差平移和批量归一化
- Softmax
下图说明了 CNN 及其组件:

让我们研究一下每个组件的功能。
卷积
卷积是 CNN 的主要构建块。 它包括将图像的一部分与核(过滤器)相乘以产生输出。 卷积的概念在“第 1 章”,“计算机视觉和 TensorFlow 基础知识”中进行了简要介绍。 请参考该章以了解基本概念。 通过在输入图像上滑动核来执行卷积操作。 在每个位置执行逐元素矩阵乘法,然后在乘法范围内进行累加和。
每次卷积操作之后,CNN 都会从图像中学到更多信息–它首先是学习边缘,然后是下一次卷积中的形状,然后是图像的特征。 在卷积操作期间,过滤器的大小和过滤器的数量可以改变。 通常,在通过卷积,合并和跨步操作减小特征映射的空间尺寸之后,增加过滤器的数量。 当过滤器尺寸增加时,特征映射的深度也会增加。 下图说明了当我们有两个不同的边缘检测核选择时的 Conv2D:

上图显示了以下要点:
- 如何通过在输入图像上滑动
3 x 3窗口来执行卷积操作。 - 逐元素矩阵乘法和总和结果,用于生成特征映射。
- 随着多次卷积运算而堆叠的多个特征映射将生成最终输出。
卷积 – 3 x 3过滤器
在前面的示例中,我们在二维图像(灰度)上应用了3 x 3卷积。 在本节中,我们将学习具有三个通道(红色,绿色和蓝色(RGB)的三维图像,如何使用卷积运算的3 x 3边缘过滤器对)进行变换。 下图以图形方式显示了此转换:

上图显示了如何使用3 x 3过滤器(边缘检测器)在宽度减小和深度增加(从 3 到 32)方面转换3 x 3图像的图的一部分。 核(fᵢ)中 27 个(3 x 3 x 3)单元中的每一个都乘以输入(Aᵢ)。 然后,将这些值与整流线性单元(ReLU)激活函数(bᵢ)相加在一起,来形成单个元素(Z),如以下等式所示:

通常,在卷积层中,有许多执行不同类型边缘检测的过滤器。 在前面的示例中,我们有 32 个过滤器,这将导致 32 个不同的栈,每个栈由5 x 5层组成。
3 x 3过滤器将在本书的其余部分中广泛用于神经网络开发。 例如,您将在 ResNet 和 Inception 层中看到大量使用它,我们将在“第 5 章”,“神经网络架构和模型”中进行讨论。 TensorFlow 中可以将大小为3 x 3的 32 个过滤器表示为.tf.keras.layers.Conv2D(32, (3,3))。 在本章的后面,您将学习如何将此卷积与 CNN 的其他层一起使用。
卷积 – 1 x 1过滤器
在本节中,我们将学习1 x 1卷积的重要性及其用例。 1 x 1卷积过滤器是图像的直倍数,如下图所示:

在上图中,在上一节输出的5 x 5图像上使用了5 x 5卷积过滤器值 1,但实际上它可以是任何数字。 在这里,我们可以看到使用5 x 5过滤器可以保留其高度和宽度,而深度则增加到过滤器通道的数量。 这是5 x 5过滤器的基本优点。 三维核(fᵢ)中三个(1 x 1 x 3)单元中的每一个都与输入的相应三个单元相乘 (Aᵢ)。 然后,将这些值与 ReLU 激活函数(bᵢ)一起加在一起,以形成单个元素(Z):

上图显示1 x 1过滤器使深度增加,而相同的1 x 1过滤器可用于减小值,如下图所示:

上图显示了1 x 1 x 128图像过滤器如何将卷积深度减少到 32 个通道。
1 x 1卷积在所有 128 个通道中与5 x 5输入层执行逐元素乘法–将其在深度维度上求和,并应用 ReLU 激活函数在5 x 5输出中创建单个点,表示 128 的输入深度。本质上,通过使用这种机制(卷积 + 整个深度的和),它会将三维体积折叠为具有相同宽度和高度的二维数组。 然后,它应用 32 个过滤器以创建5 x 5 x 32输出,如前所示。 这是有关 CNN 的基本概念,因此请花一些时间来确保您理解这一点。
本书将使用1 x 1卷积。 稍后,您将了解到池化会减小宽度,而1 x 1卷积会保留宽度,但可以根据需要收缩或扩展深度。 例如,您将看到在网络和 Inception 层中使用了1 x 1卷积(在“第 5 章”,“神经网络架构和模型”中。具有1 x 1的 32 过滤器) 的卷积可以在 TensorFlow 中表示为.tf.keras.layers.Conv2D(32, (1,1))。
池化
池化是卷积之后的下一个操作。 它用于减小尺寸和特征映射的大小(宽度和高度),而无需更改深度。 轮询参数的数量为零。 池的两种最受欢迎的类型如下:
- 最大池化
- 平均池化
在最大池化中,我们在特征映射上滑动窗口并获取窗口的最大值,而在进行平均池化时,我们获取窗口中的平均值。 卷积层和池化层一起执行特征提取的任务。 下图显示了在7 x 7图像上使用的最大和平均池化操作:

请注意,由于合并,3 x 3窗口如何缩小(由绿线显示)为单个值,从而导致5 x 5矩阵尺寸更改为5 x 5矩阵。
填充
填充用于保留特征映射的大小。 通过卷积,可能会发生两个问题,并且填充会同时解决两个问题:
- 每次卷积操作时,特征映射的大小都会缩小。 例如,在上图中,由于卷积,一个
7 x 7的特征映射缩小为5 x 5。 - 由于边缘上的像素仅更改一次,因此边缘上的信息会丢失,而中间的像素会通过多次卷积操作进行多次更改。
下图显示了在7 x 7输入图像上使用大小为 1 的填充操作:

请注意填充如何保留尺寸,以便输出与输入的尺寸相同。
跨步
通常,在卷积中,我们将核移动一步,对那一步应用卷积,依此类推。 跨步使我们可以跳过一步。 让我们来看看:
- 当跨步为 1 时,我们应用普通卷积而不跳过。
- 当跨步为 2 时,我们跳过一步。 这会将图像大小从
7 x 7减小到3 x 3(请参见下图):

在这里,每个3 x 3窗口显示跳过一个步骤的结果。 大步的结果是缩小尺寸,因为我们跳过了可能的x,y位置。
激活
激活层为神经网络增加了非线性。 这是至关重要的,因为图像和图像中的特征是高度非线性的问题,而 CNN 中的大多数其他功能(Conv2D,池化,全连接层等)仅生成线性变换。 激活函数在将输入值映射到其范围时生成非线性。 没有激活函数,无论添加多少层,最终结果仍然是线性的。
使用了多种类型的激活函数,但最常见的激活函数如下:
- Sigmoid
- Tanh
- ReLU
下图显示了上述激活函数:

每个激活函数都显示非线性行为,当输入大于 3 时,Sigmoid 和 Tanh 接近 3,而 ReLU 继续增加。
下图显示了不同的激活函数对输入大小的影响:

与 Tanh 和 Sigmoid 激活函数相比,ReLU 激活函数具有以下优点:
- 与 ReLU 相比,Sigmoid 和 Tanh 的梯度问题(学习缓慢的人)消失了,因为它们在输入值大于 3 时都接近 1。
- 对于小于 0 的输入值,Sigmoid 激活函数仅具有正值。
- ReLU 函数对计算有效。
全连接层
全连接层(也称为密集层)通过对它们施加权重和偏差来将当前层中的每个连接神经元连接到上一层中的每个连接神经元。 权重和偏差的向量称为过滤器。 这可以用以下等式表示:

如“卷积”部分中所述,过滤器可以采用边缘过滤器的形式来检测边缘。 在神经网络中,许多神经元共享同一过滤器。 权重和过滤器允许全连接层充当分类器。
正则化
正则化是一种用于减少过拟合的技术。 为此,可以在模型误差函数中添加一个附加项(模型输出-训练值),以防止模型权重参数在训练过程中取极端值。 CNN 中使用三种类型的正则化:
- L1 正则化:对于每个模型权重,
w,一个附加参数,λ |w|添加到模型目标。 这种正则化过程使优化过程中的权重因子稀疏(接近零)。 - L2 正则化:对于每个模型权重,
w,附加参数1/2 λw^2被添加到模型目标 。 这种正则化使得权重因子在优化过程中扩散。 可以期望 L2 正则化比 L1 正则化具有更好的表现。 - 最大范数正则化:这种类型的正则化为 CNN 的权重添加了最大限制,因此
|w| < c,其中c可以为 3 或 4。即使学习率很高,最大范数约束也可以防止神经网络过拟合。
丢弃
丢弃是一种特殊的正则化类型,指的是忽略神经网络中的神经元。 具有dropout = 0.2的全连接层意味着仅 80% 的全连接神经元连接到下一层。 在当前步骤中神经元被丢弃,但在下一步中处于活动状态。 丢弃可防止网络依赖少量神经元,从而防止过拟合。 丢弃应用于输入神经元,但不应用于输出神经元。 下图显示了带有和不带有丢弃的神经网络:

以下是丢弃的优点:
- 丢弃迫使神经网络学习更强大的特征。
- 每个周期的训练时间较少,但是迭代次数增加了一倍。
- 丢弃可提高准确率-约 1-2%。
内部协方差平移和批量归一化
在训练过程中,每层输入的分布会随着上一层的权重因子的变化而变化,从而导致训练变慢。 这是因为它要求较低的学习率和权重因子选择。 谢尔盖·艾菲(Sergey Ioffe)和克里斯汀·塞格迪(Christian Szegedy)在题为《批量归一化:通过减少内部协方差漂移加速深度网络训练》的论文中称这种现象内部协方差漂移。 有关详细信息,请参阅这里。
批量归一化通过从当前输入中减去上一层的批量平均值并将其除以批量标准差来解决协方差移位的问题。 然后将此新输入乘以当前权重系数,再乘以偏置项以形成输出。 下图显示了带有和不带有批量规范化的神经网络的中间输出特征:

当应用批量归一化时,我们在大小为m的整个迷你批量中计算均值(μ)和方差(σ)。 然后,利用这些信息,我们计算归一化的输入。 微型批量的输出计算为比例(γ)乘以归一化输入,再加上偏移量(β)。 在 TensorFlow 中,这可以表示如下。 除方差ε外,所有项均在上图中进行了解释,方差ε是归一化输入计算中的ε项,以避免被零除:
tf.nn.batch_normalization(x,mean,variance,offset,scale,variance_epsilon,name=None)
麻省理工学院的 Shibani Santurkar,Dimitris Tsipras,Andrew Ilyas 和 Aleksander Madry 在其论文中详细阐述了批量规范化的优势。 可以在这个页面中找到该论文的详细信息。
该论文的作者发现,批量归一化并不能减少内部协方差漂移。 批量归一化的学习速度可以归因于归一化输入的平滑性,这归因于归一化输入而不是常规输入数据的使用,规则数据可能由于扭结,尖锐的边缘和局部最小值或最大值而具有较大的差异。 这使梯度下降算法更加稳定,从而允许它使用更大的步长以实现更快的收敛。 这样可以确保它不会出现任何错误。
Softmax
Softmax 是在 CNN 的最后一层中使用的激活函数。 它由以下等式表示,其中P是每个类别的概率,n是类别的总数:

下表显示了使用前面描述的 Softmax 函数时七个类中每个类的概率:

这用于计算每个类别的分布概率。
优化 CNN 参数
CNN 具有许多不同的参数。 训练 CNN 模型需要许多输入图像并执行处理,这可能非常耗时。 如果选择的参数不是最佳参数,则必须再次重复整个过程。 这就是为什么理解每个参数的功能及其相互关系很重要的原因:这样可以在运行 CNN 之前优化其值,以最大程度地减少重复运行。 CNN 的参数如下:
- 图像尺寸为
(n x n) - 过滤器为
(f[h], f[w]),f[h]为应用于图像高度的过滤器,f[w]为应用于图像宽度的过滤器 - 过滤器数量为
n[f] - 填充为
p - 跨步为
s - 输出大小为
{(n + 2p - f)/s +1} x {(n + 2p - f)/s + 1} - 参数数量为
(f[h] x f[w] + 1) x n[f]
关键任务是选择上述参数(过滤器大小(f),过滤器数量(nf),跨步(s),填充 CNN 每一层的值(p),激活(a)和偏差。 下表显示了各种 CNN 参数的特征映射:

上表的每个参数说明如下:
- 输入图像:第一输入层是大小为
(48 x 48)的灰度图像,因此深度为1。 特征映射大小48 x 48 x 1 = 2,304。 它没有参数。 - 第一卷积层:
CONV1 (filter shape =5*5, stride=1)层的高度,宽度为(48-5+1) =44,特征映射大小为44 x 44 x 64 = 123904,参数数为(5 x 5 + 1) x 64 = 1,664。 - 第一池化层(
POOL1):池化层没有参数。 - 剩余的卷积和池化层:剩余的计算 –
CONV2, CONV3, CONV4, CONV5, POOL2– 遵循与第一卷积层相同的逻辑。 - 全连接(
FC)层:对于全连接层(FC1, FC2),参数的数量为[(current layer n * previous layer n) + 1] = 128 * 1,024 + 1 = 131,073。 - 丢弃(
DROP):对于丢弃,将丢弃 20% 的神经元。 剩余的神经元为1,024 * 0.8 = 820。 第二次删除的参数数为820 x 820 + 1 = 672401。 - CNN 的最后一层始终是 Softmax:对于 Softmax,参数数为
7 x 820 + 1 = 5,741。
在“第 3 章”,“使用 OpenCV 和 CNN 进行面部检测”的第一张图中,用于面部表情识别的神经网络类别有 7 个类别,其准确率约为 54%。
在以下各节中,我们将使用 TensorFlow 输出优化各种参数。 我们从基准情况开始,然后尝试通过调整此处描述的参数进行五次迭代。 该练习应该使您对 CNN 的参数以及它们如何影响最终模型的输出有很好的了解。
基准案例
基线情况由神经网络的以下参数表示:
- 实例数:35,888
- 实例长度:2,304
- 28,709 个训练样本
- 3,589 个测试样本
模型迭代如下:
Epoch 1/5
256/256 [=======================] - 78s 306ms/step - loss: 1.8038 - acc: 0.2528
Epoch 2/5
256/256 [=======================] - 78s 303ms/step - loss: 1.6188 - acc: 0.3561
Epoch 3/5
256/256 [=======================] - 78s 305ms/step - loss: 1.4309 - acc: 0.4459
Epoch 4/5
256/256 [=======================] - 78s 306ms/step - loss: 1.2889 - acc: 0.5046
Epoch 5/5
256/256 [=======================] - 79s 308ms/step - loss: 1.1947 - acc: 0.5444
接下来,我们将优化 CNN 参数,以确定哪些参数在更改准确率时影响最大。 我们将分四次迭代运行此实验。
迭代 1 – CNN 参数调整
删除一个Conv2D 64 和一个Conv2D 128,以使 CNN 仅具有一个Conv2D 64 和一个Conv2D 128:
Epoch 1/5
256/256 [========================] - 63s 247ms/step - loss: 1.7497 - acc: 0.2805
Epoch 2/5
256/256 [========================] - 64s 248ms/step - loss: 1.5192 - acc: 0.4095
Epoch 3/5
256/256 [========================] - 65s 252ms/step - loss: 1.3553 -acc: 0.4832
Epoch 4/5
256/256 [========================] - 66s 260ms/step - loss: 1.2633 - acc: 0.5218
Epoch 5/5
256/256 [========================] - 65s 256ms/step - loss: 1.1919 - acc: 0.5483
结果:放下Conv2D层不会对表现产生不利影响,但也不能使其更好。
接下来,我们将保留我们在此处所做的更改,但是我们会将平均池转换为最大池。
迭代 2 – CNN 参数调整
删除一台Conv2D 64 和一台Conv2D 128,以使 CNN 仅具有一台Conv2D 64 和一台Conv2D 128。 另外,将平均池转换为最大池,如下所示:
Epoch 1/5
256/256 [========================] - 63s 247ms/step - loss: 1.7471 - acc: 0.2804
Epoch 2/5
256/256 [========================] - 64s 252ms/step - loss: 1.4631 - acc: 0.4307
Epoch 3/5
256/256 [========================] - 66s 256ms/step - loss: 1.3042 - acc: 0.4990
Epoch 4/5
256/256 [========================] - 66s 257ms/step - loss: 1.2183 - acc: 0.5360
Epoch 5/5
256/256 [========================] - 67s 262ms/step - loss: 1.1407 - acc: 0.5691
结果:同样,此更改对准确率没有明显影响。
接下来,我们将大大减少隐藏层的数量。 我们将更改输入层,并完全删除第二个Conv2D和关联的池。 在第一个Conv2D之后,我们将直接移至第三个Conv2D。
迭代 3 – CNN 参数调整
第二个卷积层完全掉落; 输入层从5 x 5更改为3 x 3:
model.add(Conv2D(64, (3, 3), activation='relu', input_shape=(48,48,1)))
第三卷积层保持不变。 该层如下:
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(AveragePooling2D(pool_size=(3,3), strides=(2, 2)))
密集层没有变化。 输出如下:
Epoch 1/5
256/256 [==========================] - 410s 2s/step - loss: 1.6465 - acc: 0.3500
Epoch 2/5
256/256 [==========================] - 415s 2s/step - loss: 1.3435 - acc: 0.4851
Epoch 3/5
256/256 [==========================] - 412s 2s/step - loss: 1.0837 - acc: 0.5938
Epoch 4/5
256/256 [==========================] - 410s 2s/step - loss: 0.7870 - acc: 0.7142
Epoch 5/5
256/256 [==========================] - 409s 2s/step - loss: 0.4929 - acc: 0.8242
结果:计算时间很慢,但精度达到最佳状态,即 82%。
迭代 4 – CNN 参数调整
在此迭代中,所有参数均与上一个迭代中的参数相同,除了strides = 2,它在第一个Conv2D之后添加。
接下来,我们将所有内容保持不变,但是在第一个Conv2D之后添加一个池化层:
model.add(Conv2D(64, (3, 3), activation='relu', input_shape=(48,48,1)))
model.add(AveragePooling2D(pool_size=(3,3), strides=(2, 2)))
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(AveragePooling2D(pool_size=(3,3), strides=(2, 2)))
在此迭代中,不会更改密集层。 计算时间更快,但准确率下降了:
Epoch 1/5
256/256 [========================] - 99s 386ms/step - loss: 1.6855 - acc: 0.3240
Epoch 2/5
256/256 [========================] - 100s 389ms/step - loss: 1.4532 - acc: 0.4366
Epoch 3/5
256/256 [========================] - 102s 397ms/step - loss: 1.3100 - acc: 0.4958
Epoch 4/5
256/256 [=======================] - 103s 402ms/step - loss: 1.1995 - acc: 0.5451
Epoch 5/5
256/256 [=======================] - 104s 407ms/step - loss: 1.0831 - acc: 0.5924
结果类似于基线迭代中的结果,即 1 和 2。
从这个实验中,我们可以得出以下有关 CNN 参数优化的结论:
- 减少
Conv2D的数量并以stride = 2消除一个合并层具有最显着的效果,因为它提高了准确率(大约 30%)。 但是,这是以速度为代价的,因为 CNN 的大小没有减小。 - 合并类型(平均合并与最大合并)对测试准确率的影响不明显。
产生最高准确率的 CNN 架构如下:

请注意,与原始架构相比,该架构要简单得多。 在下一章中,您将了解一些最新的卷积模型以及为什么要使用它们。 然后,我们将回到这个优化问题,并学习如何更有效地选择参数以获得更好的优化。
可视化神经网络的各个层
在本章中,我们了解了如何将图像转换为边缘然后转换为特征映射,并且通过这样做,神经网络能够通过组合许多特征映射来预测类。 在前几层中,神经网络可视化线和角,而在后几层中,神经网络识别复杂的模式,例如特征映射。 可以分为以下几类。
- 建立自定义图像分类器模型并可视化其层
- 训练现有的高级图像分类器模型并可视化其层
让我们看一下这些类别。
建立自定义图像分类器模型并可视化其层
在本节中,我们将开发自己的家具分类器网络。 这将分为三类:沙发,床和椅子。 基本过程描述如下。
请注意,在“第 6 章”,“使用迁移学习的视觉搜索”中,我们将执行更高级的编码,并使用相同的三个类提供详细的说明。
神经网络输入和参数
在本部分中,模型输入各种 Keras 库和 TensorFlow。 在下面的代码中可以看到。 现在,先加少许盐。 这将在“第 6 章”,“使用迁移学习的视觉搜索”中全面说明:
from __future__ import absolute_import, division, print_function, unicode_literals,
import tensorflow as tf,
from tensorflow.keras.applications import VGG16\n
from keras.applications.vgg16 import preprocess_input,
from keras import models
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.layers import Dense, Conv2D, Flatten, Dropout, GlobalAveragePooling2D, MaxPooling2D
from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
from tensorflow.keras.optimizers import SGD, Adam
import os
import numpy as np
import matplotlib.pyplot as plt
输入图像
在本节中,我们定义训练和验证目录路径,并使用os.path.join函数和类名在训练和验证目录中定义目录。 之后,我们使用len命令计算每个类目录中的图像总数:
train_dir = 'furniture_images/train'
train_bed_dir = os.path.join(train_dir, 'bed')
num_bed_train = len(os.listdir(train_bed_dir))
训练目录中的图像总数是通过将每个类别中的图像总数相加得出的。 验证使用相同的方法,最后导致输出为训练和验证目录中图像的总数。 训练期间神经网络将使用此信息。
定义训练和验证生成器
训练生成器和验证生成器使用一种称为图像数据生成和流的方法。 他们在目录上使用它输入张量图像。 有关此过程的详细信息,请参阅 Keras 文档。
一个典型的例子如下。 如 Keras 文档中所述,图像数据生成器具有许多参数,但此处仅使用其中一些。 预处理输入将图像转换为张量。 输入旋转范围将图像旋转 90 度并垂直翻转以进行图像增强。 我们可以使用在“第 1 章”,“计算机视觉和 TensorFlow 基础知识”中学习到的图像变换,并使用rotation命令。 图像增强可以增加训练数据集,从而在不增加测试数据量的情况下提高模型的准确率:
train_datagen = ImageDataGenerator(preprocessing_function=preprocess_input,rotation_range=90,horizontal_flip=True,vertical_flip=True)
构建模型
准备好图像后,我们就可以开始构建模型了。 Keras 顺序模型使我们能够做到这一点。 这是彼此堆叠的模型层的列表。 接下来,我们通过堆叠卷积,激活,最大池,丢弃和填充来构建顺序模型,如以下代码所示:
model = Sequential([Conv2D(96, 11, padding='valid', activation='relu',input_shape=(img_height, img_width,3)), MaxPooling2D(),Dropout(0.2),Conv2D(256, 5, padding='same', activation='relu'),MaxPooling2D(),Conv2D(384, 3, padding='same', activation='relu'),Conv2D(384, 3, padding='same', activation='relu'), Conv2D(256, 3, padding='same', activation='relu'),MaxPooling2D(), Dropout(0.2),Conv2D(1024, 3, padding='same', activation='relu'), MaxPooling2D(),Dropout(0.2),Flatten(),Dense(4096, activation='relu'), Dense(3)])
该模型的基本思想与 AlexNet 相似,将在“第 5 章”,“神经网络架构和模型”中进行介绍。 该模型大约有 16 层。
编译和训练模型
接下来,我们编译模型并开始训练。 编译option指定三个参数:
-
优化器:我们可以使用的优化器是
adam,rmsprop,sgd,adadelta,adagrad,adamax和nadam。 有关 Keras 优化器的列表,请参考这里:sgd代表随机梯度下降。 顾名思义,它使用梯度值作为优化程序。adam代表自适应力矩。 它在最后一步中使用梯度来调整梯度下降参数。 Adam 运作良好,几乎不需要调整。 在本书中将经常使用它。adagrad适用于稀疏数据,并且几乎不需要调整。 对于adagrad,不需要默认学习率。
-
损失函数:用于图像处理的最常用损失函数是二进制交叉熵,分类交叉熵,均方误差或
sparse_categorical交叉熵。 当分类任务是二进制时,例如处理猫和狗图像或停车标志与无停车标志图像时,将使用二进制交叉熵。 当我们有两个以上的类时(例如,配有床,椅子和沙发的家具店),将使用分类交叉熵。 稀疏分类交叉熵与分类交叉熵类似,不同之处在于,该类被其索引代替-例如,我们将传递 0、1 和 2 而不是将床,椅子和沙发作为类, 指定类时出现错误,可以使用稀疏分类交叉熵来解决此问题。 Keras 中还有许多其他损失函数。 有关更多详细信息,请参阅这里。 -
指标:这些指标用于设置准确率。
在下面的代码中,我们使用adam优化器。 编译模型后,我们使用 Keras model.fit()函数开始训练。 model.fit()函数将序列生成器用作我们先前定义的输入图像向量。 它还需要周期数(迭代参数),每个周期的步骤(每个周期的批量数),验证数据和验证步骤。 请注意,将在“第 6 章”,“使用迁移学习的视觉搜索”中详细描述每个参数:
model.compile(optimizer='adam',loss=tf.keras.losses.BinaryCrossentropy(from_logits=True), metrics=['accuracy'])
history = model.fit(train_generator,epochs=NUM_EPOCHS,steps_per_epoch=num_train_images // batchsize,validation_data=val_generator, validation_steps=num_val_images // batchsize)
训练持续 10 个周期。 在训练过程中,模型的准确率随周期数的增加而增加:
WARNING:tensorflow:sample_weight modes were coerced from
...
to
['...']
Train for 10 steps, validate for 1 steps
Epoch 1/10
10/10 [==============================] - 239s 24s/step - loss: 13.7108 - accuracy: 0.6609 - val_loss: 0.6779 - val_accuracy: 0.6667
Epoch 2/10
10/10 [==============================] - 237s 24s/step - loss: 0.6559 - accuracy: 0.6708 - val_loss: 0.5836 - val_accuracy: 0.6693
Epoch 3/10
10/10 [==============================] - 227s 23s/step - loss: 0.5620 - accuracy: 0.7130 - val_loss: 0.5489 - val_accuracy: 0.7266
Epoch 4/10
10/10 [==============================] - 229s 23s/step - loss: 0.5243 - accuracy: 0.7334 - val_loss: 0.5041 - val_accuracy: 0.7292
Epoch 5/10
10/10 [==============================] - 226s 23s/step - loss: 0.5212 - accuracy: 0.7342 - val_loss: 0.4877 - val_accuracy: 0.7526
Epoch 6/10
10/10 [==============================] - 226s 23s/step - loss: 0.4897 - accuracy: 0.7653 - val_loss: 0.4626 - val_accuracy: 0.7604
Epoch 7/10
10/10 [==============================] - 227s 23s/step - loss: 0.4720 - accuracy: 0.7781 - val_loss: 0.4752 - val_accuracy: 0.7734
Epoch 8/10
10/10 [==============================] - 229s 23s/step - loss: 0.4744 - accuracy: 0.7508 - val_loss: 0.4534 - val_accuracy: 0.7708
Epoch 9/10
10/10 [==============================] - 231s 23s/step - loss: 0.4429 - accuracy: 0.7854 - val_loss: 0.4608 - val_accuracy: 0.7865
Epoch 10/10
10/10 [==============================] - 230s 23s/step - loss: 0.4410 - accuracy: 0.7865 - val_loss: 0.4264 - val_accuracy: 0.8021
输入测试图像并将其转换为张量
到目前为止,我们已经开发了图像目录并准备和训练了模型。 在本节中,我们将图像转换为张量。 我们通过将图像转换为数组来从图像中生成张量,然后使用 NumPy 的expand_dims()函数扩展数组的形状。 随后,我们对输入进行预处理以准备图像,使其具有模型所需的格式:
img_path = 'furniture_images/test/chair/testchair.jpg'
img = image.load_img(img_path, target_size=(150, 150))
img_tensor = image.img_to_array(img)
img_tensor = np.expand_dims(img_tensor, axis=0)
img_tensor = preprocess_input(img_tensor)
featuremap = model.predict(img_tensor)
最后,我们使用 Keras model.predict()函数输入图像张量,然后将张量转换为特征映射。 现在您知道了如何通过将图像张量传递给我们刚刚开发的模型来计算特征映射。
可视化激活的第一层
为了计算激活,我们计算每个层的模型输出。 在此示例中,共有 16 层,因此我们使用model.layers[:16]指定所有 16 层。 我们用于执行此操作的代码如下:
layer_outputs = [layer.output for layer in model.layers[:16]]
activation_modelfig = Model(inputs=model.input, outputs=layer_outputs)
activationsfig = activation_modelfig.predict(img_tensor)
为了使用激活,我们使用 Keras Model函数式 API,当给定a时,该 API 计算计算b所需的所有层:
model = Model(inputs=[a1, a2], outputs=[b1, b2, b3])
对于我们的练习,输入是我们先前计算的图像张量,而输出是激活层。
接下来,我们使用以下命令可视化第一层,其中activationsfig[0]表示第一层。 要绘制它,我们使用plt.matshow()。 在这里,95是第一神经网络层的倒数第二个激活过滤器:
first_layer_activation = activationsfig[0]
print(first_layer_activation.shape)
plt.matshow(first_layer_activation[0, :, :, 95], cmap='viridis')
可视化多层激活
按照之前的操作,我们运行for循环并使用plt.imshow方法在给定神经网络层的第一个,中间和最后一个过滤器值中显示激活层:
for i in range(0,12):
current_layer_activation = activationsfig[i]
ns = current_layer_activation.shape[-1]
plt.imshow(current_layer_activation[0, :, :, 0], cmap='viridis')
plt.imshow(current_layer_activation[0, :, :, int(ns/2)], cmap='viridis')
plt.imshow(current_layer_activation[0, :, :, ns-1], cmap='viridis')
下图显示了椅子图像的最终输出值:

在上图中,n表示给定层的最大过滤器数。 n的值在不同的层可以不同。 例如,对于第一层,n的值为96,而对于第四层,其为256。 下表显示了自定义神经网络不同层的参数,输出形状和过滤器:

如您所见,每个层都有许多不同的激活过滤器,因此对于我们的可视化,我们正在查看给定层的第一个过滤器,中间过滤器和最后一个过滤器的可视化值。
最初的第一层代表椅子,但是随着我们深入模型的层,结构变得越来越抽象。 这意味着图像看起来不太像椅子,而更像代表类的东西。 此外,您可以看到某些层根本没有激活,这表明模型的结构变得复杂且效率不高。
自然而然产生的一个大问题是,神经网络如何处理来自最后一层的看似抽象的图像并从中提取出一个类? 这是人类无法做的事情。
答案在于全连接层。 如上表所示,共有 16 层,但是i的可视化代码在(0, 12)范围内,因此我们仅可视化前 12 层。 如果您尝试可视化更多,则会收到错误消息。 在第 12 层之后,我们展平该层并映射该层的每个元素-这称为全连接层。 这本质上是一个映射练习。 该神经网络将全连接层的每个元素映射到特定类别。 对所有类都重复此过程。 将抽象层映射到类是机器学习练习。 通过这样做,神经网络能够预测类别。
下图显示了床图像的输出值:

就像椅子的图像一样,初始激活从类似于床的输出开始,但是当我们深入网络时,我们开始看到床与椅子相比的独特特征。
下图显示了沙发图像的输出值:

就像椅子和床的示例一样,前面的图从具有不同特征的顶层开始,而最后几层则显示了特定于该类的非常抽象的图像。 请注意,第 4、5 和 6 层很容易被替换,因为这些层根本没有激活。
训练现有的高级图像分类器模型并可视化其层
我们发现,我们开发的模型约有 16 层,其验证准确率约为 80%。 由此,我们观察了神经网络如何看到不同层的图像。 这带来了两个问题:
- 我们的自定义神经网络与更高级的神经网络相比如何?
- 与我们的自定义神经网络相比,高级神经网络如何看待图像? 所有的神经网络都以相似或不同的方式看到图像吗?
为了回答这些问题,我们将针对两个高级网络 VGG16 和 InceptionV3 训练分类器,并在网络的不同层上可视化椅子图像。 “第 5 章”,“神经网络架构和模型”提供了网络的详细说明,而“第 6 章”,“使用迁移学习的视觉搜索”,提供了代码的详细说明。 因此,在本节中,我们将只专注于可视化部分。 在完成“第 5 章”,“神经网络架构和模型”和“第 6 章”之后,您可能需要重新访问编码部分 ,以便您对代码有深刻的了解。 VGG 16 中的层数为 26。您可以在这个页面上找到有关此代码的代码。
请注意,前面的代码同时运行自定义网络和 VGG 16 模型。 在此练习中,请勿运行标记为自定义网络的单元,以确保仅执行 VGG16 模型。 Keras 有一个简单的 API,可以在其中导入 VGG16 或 InceptionV3 模型。 这里要注意的关键是 VGG 16 和 InceptionV3 均在具有 1,000 个类的 ImageNet 数据集上进行了训练。 但是,在这种情况下,我们将使用三个类来训练该模型,以便我们可以仅使用 VGG 16 或 Inception 模型。 Keras 将针对不兼容的形状抛出错误:[128,1000]与[128,3]相对,其中128是批量大小。 要解决此问题,请在模型定义中使用include_top = False,该模型将删除最后的全连接层,并仅用三个类将它们替换为我们自己的层。 同样,“第 6 章”,“使用迁移学习的视觉搜索”对此进行了详细描述。 在训练 135 个步骤并验证 15 个步骤后,VGG 16 模型的验证准确率约为0.89:
Epoch 1/10
135/135 [==============================] - 146s 1s/step - loss: 1.8203 - accuracy: 0.4493 - val_loss: 0.6495 - val_accuracy: 0.7000
Epoch 2/10
135/135 [==============================] - 151s 1s/step - loss: 1.2111 - accuracy: 0.6140 - val_loss: 0.5174 - val_accuracy: 0.8067
Epoch 3/10
135/135 [==============================] - 151s 1s/step - loss: 0.9528 - accuracy: 0.6893 - val_loss: 0.4765 - val_accuracy: 0.8267
Epoch 4/10
135/135 [==============================] - 152s 1s/step - loss: 0.8207 - accuracy: 0.7139 - val_loss: 0.4881 - val_accuracy: 0.8133
Epoch 5/10
135/135 [==============================] - 152s 1s/step - loss: 0.8057 - accuracy: 0.7355 - val_loss: 0.4780 - val_accuracy: 0.8267
Epoch 6/10
135/135 [==============================] - 152s 1s/step - loss: 0.7528 - accuracy: 0.7571 - val_loss: 0.3842 - val_accuracy: 0.8333
Epoch 7/10
135/135 [==============================] - 152s 1s/step - loss: 0.6801 - accuracy: 0.7705 - val_loss: 0.3370 - val_accuracy: 0.8667
Epoch 8/10
135/135 [==============================] - 151s 1s/step - loss: 0.6716 - accuracy: 0.7906 - val_loss: 0.4276 - val_accuracy: 0.8800
Epoch 9/10
135/135 [==============================] - 152s 1s/step - loss: 0.5954 - accuracy: 0.7973 - val_loss: 0.4608 - val_accuracy: 0.8533
Epoch 10/10
135/135 [==============================] - 152s 1s/step - loss: 0.4926 - accuracy: 0.8152 - val_loss: 0.3550 - val_accuracy: 0.8933
下图显示了在椅子上使用 VGG 16 模型后神经网络的可视化效果:

上图显示了 VGG 16 模型如何在前 16 层看到椅子。 请注意,与我们的自定义模型相比,VGG 16 模型效率更高,因为每一层都在执行某种类型的图像激活。 不同层的图像特征不同,但总体趋势是相同的–随着我们深入层,图像将转换为更抽象的结构。
接下来,我们使用 Inception V3 模型执行相同的练习。 在“第 6 章”,“使用迁移学习的视觉搜索”中描述了此代码。 下图显示了 Inception V3 模型如何形象化椅子图像:

Inception V3 模型的验证准确率约为 99%。 如您所见,与 VGG16 相比,Inception V3 模型中的层数更多。 先前的图像难以可视化。 下图显示了第一层,最后一层和一些选择的中间层:

前面的图像清楚地显示了当我们更深入地进入神经网络时,椅子图像如何失去锐度并变得越来越模糊。 最终图像看起来不太像椅子。 神经网络可以看到许多相似的椅子图像,并根据它们来解释椅子。
在本节中,我们描述了如何在训练过程中查看中间激活层,以了解如何在神经网络上变换特征映射。 但是,如果您想了解神经网络如何将特征和隐藏层转换为输出,请参阅 TensorFlow 神经网络游乐场。
总结
CNN 是事实上的图像分类模型,这是因为 CNN 能够自己学习每个类别的独特特征,而无需推导输入和输出之间的任何关系。 在本章中,我们了解了 CNN 的组件,这些组件负责学习图像特征,然后将其分类为预定义的类。 我们了解了卷积层如何彼此堆叠以从简单的形状(例如边缘)学习以创建复杂的形状(例如眼睛),以及特征映射的维数如何因卷积和合并层而改变。 我们还了解了非线性激活函数,Softmax 和全连接层的功能。 本章重点介绍如何优化不同的参数以减少过拟合的问题。
我们还构建了用于分类目的的神经网络,并使用我们开发的模型来创建图像张量,该图像张量被神经网络用于开发可视化的激活层。 可视化方法可帮助我们了解如何在神经网络中变换特征映射,以及神经网络如何使用全连接层从此变换后的特征映射中分配类别。 我们还学习了如何将自定义神经网络可视化与高级网络(例如 VGG16 和 Inception V3)的可视化进行比较。
在下一章中,您将学习一些最著名的神经网络模型,以便对 CNN 参数选择有更深入的了解。
五、神经网络架构和模型
卷积神经网络(CNN)是计算机视觉中用于分类和检测对象的最广泛使用的工具。 CNN 通过堆叠许多不同的线性和非线性函数层,将输入图像映射到输出类别或边界框。 线性函数包括卷积,池化,全连接和 softmax 层,而非线性层是激活函数。 神经网络具有许多不同的参数和权重因子,需要针对给定的问题集进行优化。 随机梯度下降和反向传播是训练神经网络的两种方法。
在“第 4 章”,“图像深度学习”中,您学习了一些基本的编码技巧来构建和训练神经网络,并了解了特征映射在不同层次上的视觉转换。 神经网络。 在本章中,您将深入了解神经网络架构和模型背后的理论,并了解诸如神经网络深度饱和,梯度梯度消失,由于大参数集导致的过拟合等关键概念。 这将帮助您为自己的研究目的创建自己的有效模型,并遵循在代码中应用这些理论的下几章的主题。
本章涵盖的主题如下:
- AlexNet 概述
- VGG16 概述
- 初始模型概述
- ResNet 概述
- R-CNN 概述
- 快速 R-CNN 概述
- 更快的 R-CNN 概述
- GAN 概述
- GNN 概述
- 强化学习概述
- 迁移学习概述
AlexNet 概述
AlexNet 由 Alex Krizhevsky,Ilya Sutskever 和 Geoffrey E. Hinton 于 2012 年在名为《深度卷积神经网络的图像网络分类》中引入。 原始论文可以在这个页面中找到。
这是首次成功引入优化的 CNN 模型,以解决有关许多类别(超过 22,000 个)中的大量图像(超过 1,500 万个)的分类的计算机视觉问题。 在 AlexNet 之前,计算机视觉问题主要是通过传统的机器学习方法解决的,该方法通过收集更大的数据集并改进模型和技术以最大程度地减少过拟合来进行逐步改进。
CNN 模型根据前五位错误率对错误率进行分类,前五位错误率是指给定图像的真实类不在前五位预测类中的实例所占的百分比。 AlexNet 以 15.3% 的前五名错误率赢得了 2012 年 ILSVRC(ImageNet 大规模视觉识别挑战赛),与第二名的错误率 26.2% 的前五名遥遥领先。 下图显示了 AlexNet 架构:

AlexNet 的基本思想总结如下:
- 它包含 8 个学习层-5 个卷积层和 3 个全连接层。
- 它使用大型核过滤器-第一层有 96 个大小为
11 x 11的过滤器,第二层有 256 个大小为11 x 11的过滤器,第三层和第四层有 384 个大小为11 x 11的过滤器,以及第五层有 256 个大小为3 x 5的过滤器。 - ReLU 激活层在每个卷积和全连接层之后应用。 它的训练比 Tanh 快得多。
- 丢弃正则化应用于第一和第二全连接层。
- 两种数据扩充技术可减少过拟合:
- 根据
256 x 256的图像大小创建256 x 256的随机色块,并执行平移和水平反射 - 更改训练图像中 RGB 通道的强度
- 训练是在两个 GPU 上进行的,在 5 或 6 天内要进行 90 个周期的训练,以在两个 Nvidia GeForce 高端 GTX 580 GPU 上进行训练。
- softmax 层的 1,000 个输出映射到 1,000 个 ImageNet 类中的每一个,以预测类的输出。
以下代码导入了运行 TensorFlow 后端所需的所有函数。 此模型导入Sequential模型,它是 Keras 中的逐层模型结构:
from __future__ import print_function
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Conv2D, MaxPooling2D, ZeroPadding2D
from keras.layers.normalization import BatchNormalization
from keras.regularizers import l2
以下代码加载 CIFAR 数据集。
CIFAR 数据集具有 10 个不同的类别,每个类别有 6,000 张图像。 这些类别包括飞机,汽车,鸟类,猫,鹿,狗,青蛙,马,船和卡车。 TensorFlow 具有内置的逻辑来导入 CIFAR 数据集。
数据集包含训练和测试图像,这些图像将用于开发模型(训练)并验证其结果(测试)。 每个数据集都有两个参数,x和y,分别表示图像的宽度(x)和高度(y):
from keras.datasets import cifar10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
神经网络具有许多不同的参数,需要对其进行优化-这些参数也称为模型常数。 对于 AlexNet,这些如下:
batch_size是一次向前或向后通过的32训练示例数。num_classes是2。epochs是100训练将重复的次数。data_augmentation是True。num_predictions是20。
让我们将输入向量转换为二进制类矩阵,因为在此示例中有两个类:
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
# Initialize model
model = Sequential()
下表描述了不同 AlexNet 模型层的 TensorFlow 代码。 在随后的部分中,将介绍其他模型,但是创建模型的基本思想是相似的:
卷积和合并 1
model.add(Conv2D(96, (11, 11), input_shape=x_train.shape[1:],
padding='same', kernel_regularizer=l2(l2_reg)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2))
卷积和合并 5
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(1024, (3, 3), padding='same'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
卷积和合并 2
model.add(Conv2D(256, (5, 5), padding='same'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
全连接 1
model.add(Flatten())
model.add(Dense(3072))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.5))
卷积和合并 3
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(512, (3, 3), padding='same'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
全连接 2
model.add(Dense(4096))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.5))
卷积和合并 4
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(1024, (3, 3), padding='same'))
model.add(BatchNormalization())
model.add(Activation('relu'))
全连接 3
model.add(Dense(num_classes))
model.add(BatchNormalization())
model.add(Activation('softmax'))
下表描述了关键模型配置参数。 这应该为您概要概述需要优化以训练神经网络模型的参数:
- 模型编译:一旦开发了模型,下一步就是使用 TensorFlow 编译模型。 对于模型编译,我们需要定义两个参数:
- 损失函数:损失函数确定模型值与实际结果的接近程度。 分类交叉熵是最常见的损失函数,它使用对数值标度来确定损失,其输出值介于 0 到 1 之间,其中小输出表示小差异,大输出表示大差异。 也可以使用的另一个损失函数是 RMS(均方根)损失函数。
- 优化器:优化器微调模型的参数以最小化损失函数。 Adadelta 优化器根据过去梯度的移动窗口微调学习率。 常用的其他优化器是 Adam 优化器和 RMSprop 优化器。
以下代码显示了在 Keras 中进行模型编译时如何使用优化器:
model.compile(loss = 'categorical_crossentropy',
optimizer = keras.optimizers.Adadelta(),
metrics = ['accuracy'])
构建模型后,必须先通过前述方法编译模型,然后才能将其用于预测(model.predict())。
请注意,在本部分中,我们研究了 AlexNet,它在 2012 年赢得了 ILSVRC 竞赛。2013 年,开发了一个名为 ZFNet 的 AlexNet 更新版本,它使用 8 层像 AlexNet 一样,但是使用7 x 7过滤器而不是7 x 7过滤器。 在接下来的部分中,我们将发现使用较小的过滤器尺寸可以提高模型的准确率,因为保留了输入图像像素信息。
VGG16 概述
自 2012 年 AlexNet 成功以来,越来越多的研究人员致力于改进 AlexNet 的 CNN 架构以提高准确率。 焦点转移到较小的窗口大小,较小的过滤器和较小的跨步。 VGG16 是由 Karen Simonyan 和 Andrew Zisserman 于 2014 年在《用于大规模图像识别的超深度卷积网络》中引入的。 可以在这个页面上阅读该论文。
在 ILSVRC-2014 中,该模型在 ImageNet 中的前五名测试准确率达到 92.7%。
下图显示了 VGG16 架构:

VGG16 的基本思想总结如下:
- 过滤器的最大尺寸为
3 x 3,最小尺寸为1 x 1。这意味着与 AlexNet 的较大过滤器尺寸和较小的数量相比,使用较小的过滤器尺寸和较大的数量。 与 AlexNet 相比,这减少了参数。 - 对于
3 x 3卷积层,卷积跨步为 1,填充为 1。 最大合并在跨度为 2 的3 x 3窗口上执行。 - 使用了三个非线性 ReLU 函数,而不是每一层中的一个,这通过减少消失梯度问题并使网络能够深入学习,使决策函数更具判别力。 在这里深入学习意味着学习复杂的形状,例如边,特征,边界等。
- 参数总数为 1.38 亿。
初始模型概述
在引入初始层之前,大多数 CNN 架构都具有标准配置-堆叠(连接)卷积,规范化,最大池化和激活层,然后是全连接 softmax 层。 这种架构导致神经网络的深度不断增加,这具有两个主要缺点:
- 过拟合
- 增加计算时间
初始模型通过从密集网络转移到稀疏矩阵并将它们聚类以形成密集子矩阵来解决了这两个问题。
初始模型也称为 GoogLeNet。 它是由 Christian Szegedy,Wei Liu,贾阳清,Pierre Sermanet,Scott Reed,Dragmir Anguelov,Dumitru Erhan,Vincent Vanhoucke 和 Andrew Rabinovich 在名为《Going Deeper with Convolutions》的论文中介绍的。 Inception 的名称来自 Min Lin,陈强和 Shuicheng Yan 的论文《网络中的网络》和著名的网络模因《We need to go deeper》。 以下是指向 Inception 论文和《网络中的网络》论文的链接:
在论文《网络中的网络》中,作者没有在输入图像上使用常规的线性过滤器,而是构造了一个微神经网络,并以类似于 CNN 的方式在输入图像上滑动了该神经网络。 通过将这些层中的一些层堆叠在一起,可以构建一个深度神经网络。 微型神经网络(也称为多层感知器)由具有激活函数的多个全连接层组成,如下图所示:

左图显示了传统 CNN 中的线性过滤器,它将输入图像连接到下一层。 右图显示了微网络,该微网络由多个全连接层组成,然后是将输入图像连接到下一层的激活函数。 这里的初始层是 NIN 的逻辑顶点,描述如下:
-
初始架构的主要思想是基于发现如何用易于获得的密集分量(
3 x 3和5 x 5)补充 CNN 中的最佳局部稀疏(并行1 x 1多个)结构。 初始论文的作者找到了答案,方法是将1 x 1卷积与3 x 3、5 x 5卷积和池化层并行使用。 可以认为,附加的1 x 1卷积和 ReLU 相当于 NIN 微网络。1 x 1卷积可作为降维机制,还有助于增加网络的宽度(通过并排堆叠)以及深度。 在同一层(起始层)中同时并行部署具有多个过滤器和池化层的多个卷积会导致该层是稀疏层,并且宽度增加。1 x 1卷积由于较小的核大小而遭受了较少的过拟合。 -
目的是让神经网络在训练网络时学习最佳权重,并自动选择更有用的特征。
-
为了进一步减小尺寸,在
3 x 3和3 x 3卷积之前使用3 x 3卷积,如下图所示:

上图显示,在3 x 3和3 x 3层之前使用3 x 3层会导致尺寸减小约 30%,从 672(左图(a))减少到 480(右图(b)) 。 下图显示了完整的初始网络。 下图的中间部分中描述的完整的初始层太大,以致无法放入一页中,因此已被压缩。 不要在这里尝试阅读图表的每个元素,而应获得重复内容的整体思路。 初始层的关键重复模块已被放大,如下图的顶部和底部所示:

该网络包括以下部分:
1 x 1卷积,带 128 个过滤器,用于减小尺寸和校正线性激活- 具有 1,024 个单元和 ReLU 激活的全连接层
- 丢弃层,其丢弃比率为 70%
- 一个具有 softmax 损失的线性层作为分类器(预测与主分类器相同的 1,000 个分类,但在推理时将其删除)
下图说明了初始网络中的 CNN 过滤器及其对应的连接:

在上图中,深度连接层可以与最大池化层连接,也可以直接与1 x 1卷积层连接。 无论哪种方式,随后的计算都遵循与上图所示相同的模式。
GoogLeNet 概述
初始网络(也称为 GoogLeNet)在区域卷积神经网络(R-CNN)的两阶段提议(基于颜色,纹理,大小和形状的区域提议,然后是 CNN 用于分类)的基础上进行了改进。
首先,它以改进的 CNN 替代了 AlexNet。 接下来,通过将选择性搜索(在 R-CNN 中)方法与用于更高对象边界框召回率的多框预测相结合,改进了区域提议步骤。 区域提议书减少了约 60%(从 2,000 减少到 1200),而覆盖率从 92% 增加到 93%,从而使单个模型案例的平均平均精度提高了 1%。 总体而言,准确率从 40% 提高到 43.9%。
ResNet 概述
ResNet 由何凯敏,张向宇,任少卿和孙健在题为《图像识别的深度残差学习》的论文中介绍,目的是解决深度神经网络的精度下降问题。这种降级不是由过拟合引起的,而是由以下事实造成的:在某个临界深度之后,输出会松散输入的信息,因此输入和输出之间的相关性开始发散,从而导致精度增加。 可以在这个页面中找到该论文。
ResNet-34 的前五位验证错误为 5.71%,优于 BN-inception 和 VGG。 ResNet-152 的前五位验证错误为 4.49%。 由六个不同深度的模型组成的集合实现了 3.57% 的前五个验证误差,并在 ILSVRC-2015 中获得了第一名。 ILSVRC 代表 ImageNet 大规模视觉识别竞赛; 它评估了 2010 年至 2017 年的目标检测和图像分类算法。
ResNet 的主要功能描述如下:
- 通过引入深层的残差学习框架来解决降级问题。
- 该框架引入了快捷方式或跳过连接(跳过一个或多个层)的概念。
- 输入和下一层之间的基础映射为
H(x)。 - 非线性层为
F(x) = H(x) – x,可以将其重组为H(x) = F(x) + x,其中x是身份映射。 - 快捷方式连接仅执行身份映射,其输出将添加到堆叠层的输出中(请参见下图):

上图具有以下功能:
F(x) + x操作是通过快捷连接和元素添加来执行的。- 身份快捷方式连接既不会增加额外的参数,也不会增加计算复杂度。
下图显示了完整的 ResNet 模型:

与视觉几何组(VGG)网络相比,此处显示的 ResNet 模型具有更少的过滤器和更低的复杂度。 不使用丢弃。 以下屏幕快照显示了各种神经网络模型之间的表现比较:

上图显示了以下内容:
- ImageNet 大规模视觉识别挑战(ILSVRC)的各种 CNN 架构的得分和层数。
- 分数越低,表现越好。
- AlexNet 的得分比其任何前任都要好得多,然后在随后的每一年中,随着层数越来越大,CNN 的质量不断提高。
- 如此处所述,ResNet 得分最高,比 AlexNet 高出四倍。
R-CNN 概述
基于区域的 CNN(R-CNN)由 Ross Girshick,Jeff Donahue,Trevor Darrell 和 Jitendra Malik 在题为《可用于精确的对象检测和语义分割丰富特征层次结构》的论文中进行了介绍。 它是一种简单且可扩展的对象检测算法,与 VOC2012 上的最佳结果相比,其平均平均精度提高了 30% 以上。 可以在这里阅读本文。
VOC 代表视觉对象类,而 PASCAL 代表模式分析统计建模和计算学习。 从 2005 年到 2012 年,PASCAL VOC 在对象类识别方面面临挑战。 PASCAL VOC 标注广泛用于对象检测,并且使用.xml格式。
整个对象检测模型分为图像分割,基于选择性搜索的区域提议,使用 CNN 的特征提取和分类以及使用支持向量机(SVM)的包围盒形成,如下图所示 :

上图显示了将道路上的汽车和自行车的输入图像转换为对象检测边界框的各个步骤。
在以下部分中,将详细描述每个步骤。
图像分割
图像分割是图像在多个区域中的表示。 分割图像中的每个区域都具有相似的特征,例如颜色,纹理和强度。
基于聚类的分割
K-means 是一种无监督的机器学习技术,它基于质心将相似的数据分为几组。K 均值聚类算法的关键步骤概述如下:
- 选择
K数据点作为任意位置的群集的初始数目。 - 找到每个聚类质心和每个像素之间的距离,并将其分配给最近的聚类。
- 更新每个群集的平均值。
- 通过更改群集质心,重复此过程,直到最小化每个像素及其关联群集之间的总距离。
基于图的分割
有许多基于图的分割方法可用,但此处为 R-CNN 描述的一种方法是 Pedro Felzenszwalb 和 Daniel Huttenlocher 在题为《基于图的高效图像分割》的论文中介绍的方法。 可以在这个页面上阅读该论文。
此方法涉及将图像表示为图(在本章的“GNN 概述”部分中提供了详细说明),然后从图中选择边,其中每个像素都链接到图中的节点,并且通过边连接到相邻像素。 边上的权重代表像素之间的差异。 分割标准基于被边界分开的图像的相邻区域的变化程度。 通过评估阈值函数来定义边界,该阈值函数表示与相邻像素之间的强度差相比,沿着边界的像素之间的强度差。 基于区域之间边界的存在,将分割定义为粗略或精细。
选择性搜索
对象检测的主要挑战是在图像中找到物体的精确位置。 图像中多个对象在不同的空间方向上很难找到图像中对象的边界。 例如,一个物体可以被遮盖并且只能部分可见。例如,一个人站在汽车后面; 我们可以看到汽车和汽车上方的人的身体。 选择性搜索用于解决此问题。 它将整个图像分为许多分割区域。 然后,它使用自下而上的方法将相似的区域合并为较大的区域。 选择性搜索使用生成的区域来找到对象的位置。 选择性搜索使用贪婪算法,根据大小,颜色和纹理将区域迭代地分组在一起。 选择性搜索中使用的步骤说明如下:
- 首先,对两个最相似的区域进行评估并分组在一起。
- 接下来,在所得区域和新区域之间计算新的相似度以形成新的组。
- 重复对最相似区域进行分组的过程,直到该区域覆盖整个图像为止。
选择搜索之后是区域提议,下面的部分将对此进行描述。
区域提议
在此阶段,该算法使用前面描述的选择性搜索方法来提取大约 2,000 个与类别无关的区域提议。 与类别无关的区域提议用于识别图像中的多个区域,以使每个对象都能由图像中的至少一个区域很好地表示。 人类通过在图像中定位对象来自然地做到这一点,但是对于机器而言,需要确定对象的位置,然后将其与图像中的适当区域进行匹配以检测对象。
与图像分类不同,检测涉及图像定位,因此可以创建一个适当的区域来包围对象以检测该区域内的特征。 基于选择性搜索方法选择适当的区域,该方法通过基于颜色进行搜索,然后基于纹理,大小和形状进行搜索来计算相似区域。
特征提取
特征提取是将相似特征(例如边,角和线)分组为特征向量。 特征向量将图像的维数从227 x 227(约 51,529)降低到 4,096。 每个区域提议,无论其大小如何,都首先通过膨胀和翘曲将其转换为227 x 227的大小。 这是必需的,因为 AlexNet 的输入图像大小为227 x 227。使用 AlexNet 从每个区域提取 4,096 个特征向量。 特征矩阵为4,096 x 2,000,因为每个图像都有 2,000 个区域提议。
原则上,只要修改输入图像的大小以适合网络的图像大小,R-CNN 可以采用任何 CNN 模型(例如 AlexNet,ResNet,Inception 或 VGG)作为输入。 R-CNN 的作者比较了 AlexNet 和 VGG16 作为 R-CNN 的输入,发现 VGG16 的准确率高 8%,但比 AlexNet 的准确率高 7 倍。
图像分类
通过 AlexNet 提取特征后,图像的分类包括将特征向量通过特定于类别的线性 SVM 进行分类,以对区域提议中对象的存在进行分类。 使用 SVM 是一种受监督的机器学习方法,该方法将权重和偏差分配给每个特征向量,然后画一条线将对象分成特定的类。 通过确定每个向量与直线的距离,然后定位直线,使间距最大,从而完成分隔。
边界框回归
边界框回归可预测对象在图像中的位置。 在支持向量机之后,建立线性回归模型以预测边界框检测窗口的位置和大小。 对象的边界框由四个锚定值[x,y,w,h]定义,其中x是边界框原点的x坐标,y是边界框原点的y坐标,w是边框的宽度,h是边框的高度。
回归技术试图通过调整四个锚定值中的每个锚定值,将预测值与地面真实(目标)值进行比较,以使边界框预测中的误差最小化。
快速 R-CNN 概述
R-CNN 在对象检测方面比以前的任何一种方法都有了更显着的改进,但是它很慢,因为它对每个区域提议都对 CNN 进行了前向传递。 此外,训练是一个多阶段流程,包括首先针对区域提议优化 CNN,然后运行 SVM 进行对象分类,然后使用包围盒回归器绘制包围盒。 也是 R-CNN 的创建者的 Ross Girschick 提出了一种称为快速 R-CNN 的模型,以使用单阶段训练方法来改进检测。 下图显示了快速 R-CNN 的架构:

快速 R-CNN 中使用的步骤如下:
- 快速 R-CNN 网络使用多个卷积和最大池化层处理整个图像,以生成特征映射。
- 将特征映射输入到选择性搜索中以生成区域提议。
- 对于每个区域提议,使用兴趣区域(RoI)最大池来提取固定长度的特征向量(
h = 7 x w = 7)。 - 此特征向量值成为由两个分支分隔的全连接(FC)层的输入:
- 用于类别概率的 Softmax
- 每个对象类别的边界框位置和大小(
x,y,宽度,高度)。
所有网络权重都使用反向传播进行训练,并且在前向和后向路径之间共享计算和内存,以进行损失和权重计算; 这将大型网络中的训练时间从 84 小时(R-CNN)减少到 9.5 小时(快速 R-CNN)。 快速 R-CNN 使用 softmax 分类器代替 SVM(R-CNN)。 下表针对小型(S),中型(M)和大型(L)网络显示 softmax 的平均平均精度略胜于 SVM 的平均精度:
| VOC07 | S |
M |
L |
|---|---|---|---|
| SVM | 56.3 | 58.7 | 66.8 |
| Softmax | 57.1 | 59.2 | 66.9 |
SVM 和 softmax 之间的结果差异很小,这说明与使用 SVM 的多阶段训练相比,使用 softmax 的单次微调就足够了。 提案数量超过 4,000 个时,导致平均平均精度降低了大约 1%,而当提案数量达到 2,000 至 4,000 个时,实际上使精度提高了大约 0.5%。
更快的 R-CNN 概述
R-CNN 和 Fast R-CNN 都依赖于选择性搜索方法来开发 2,000 个区域的方案,这导致每幅图像的检测速度为 2 秒,而最有效的检测方法为 0.2 秒。 任少渠,何开明,罗斯·吉尔希克和孙健写了一篇名为 《Faster R-CNN:借助区域提议网络实现实时目标检测》的论文,以提高目标检测的速度和准确率。 您可以在这里阅读本文。
下图显示了更快的 R-CNN 的架构:

关键概念显示在以下列表中:
- 将输入图像引入区域提议网络(RPN),该网络为给定图像输出一组矩形区域提议。
- RPN 与最新的对象检测网络共享卷积层。
- RPN 通过反向传播和随机梯度下降(SGD)进行训练。
快速 R-CNN 中的对象检测网络类似于快速 R-CNN。 下图显示了使用更快的 R-CNN 进行的一些对象检测输出:

上图显示了使用更快的 R-CNN 模型进行的推理。 在“第 10 章”,“使用 R-CNN,SSD 和 R-FCN”进行对象检测中,您将学习如何自己生成这种类型的图形。 左图是使用 TensorFlow Hub 中的预训练模型生成的,而右图是通过训练自己的图像然后开发自己的模型来生成的。
通过遵循以下列表中概述的技术,可以获得上图中所示的高精度:
- 在两个网络之间共享卷积层:RPN 用于区域提议,快速 R-CNN 用于检测。
- 对于更快的 R-CNN,输入图像大小为
1,000 x 600。 - 通过在卷积特征映射输出上滑动大小为
60 x 40的小窗口来生成 RPN。 - 每个滑动窗口都映射到 9 个锚点框(3 个比例,框区域分别为 128、256 和 512 像素,而 3 个比例为 1:1、1:2 和 2:1)。
- 每个锚框都映射到一个区域提议。
- 每个滑动窗口都映射到 ZF 的 256-D 特征向量和 VGG 网络的 512-D 特征向量。
- 然后将此向量输入到两个全连接层中-框回归层和框分类层。
- 区域提议总数为 21,500(
60 x 40 x 9)。
为了训练 RPN,基于与训练数据重叠的交并比(IoU)为每个锚定框分配一个二进制类别标签。 IoU 用于测量对象检测的准确率。 在“第 7 章”,“使用 YOLO 的对象检测”中详细描述。 现在,您已经足够知道 IoU 是以两个边界框之间的重叠面积与其联合面积之比来衡量的。 这意味着IOU = 1,这意味着两个完整的边界框重叠,因此您只能看到一个,而当IoU = 0时,这意味着两个边界框彼此完全分开。
二进制类级别具有正样本和负样本,它们具有以下属性:
- 正样本:IoU 为最大值或大于 0.7
- 负样本:IoU 小于 0.3
用于回归的特征具有相同的空间大小(高度和宽度)。 在实际图像中,特征尺寸可以不同。 通过使用具有不同回归比例和纵横比的可变包围盒大小来考虑到这一点。 RPN 和对象检测之间的卷积特征使用以下原则共享:
- RPN 将二进制类别用于训练。
- 检测网络通过快速 R-CNN 方法进行训练,并通过使用 RPN 训练的 ImageNet 预训练模型进行初始化。
- 通过保持共享卷积层固定并仅微调 RPN 唯一的层来初始化 RPN 训练。
- 前面的步骤导致两个网络的共享。
- 最后,通过保持共享卷积层固定,可以对快速 R-CNN 的全连接层进行微调。
- 所有上述步骤的组合导致两个网络共享相同的卷积层。
下表显示了 R-CNN,快速 R-CNN 和更快的 R-CNN 之间的比较:
| 参数 | R-CNN | 快速 R-CNN | 更快的 R-CNN |
|---|---|---|---|
| 输入值 | 图片 | 图片 | 图片 |
| 输入图像处理 | 基于像素相似度的图像分割 | 输入图像被馈送到 CNN 以生成卷积特征映射。 | 输入图像被馈送到 CNN 以生成卷积特征映射。 |
| 区域提议 | 使用选择性搜索在分割的图像上生成 2K 区域提议。 | 使用卷积特征映射的选择性搜索生成 2K 区域提议。 | 区域提议是使用区域提议网络(RPN)生成的。 这个 CNN 使用60 x 40的滑动窗口,用于带有 9 个锚点框(3 个比例和 3 个宽高比)的特征映射的每个位置。 |
| 变形为固定大小 | 从区域提议中,每个区域都将变形为固定大小,以输入到 CNN。 | 使用 RoI 池化层中的最大池化,将区域提议扭曲为固定大小的正方形。 | 使用 RoI 池化层将区域提议扭曲为固定大小的正方形。 |
| 特征提取 | 每次将每个图像固定大小的 2K 变形区域提议送入 CNN。 | 2K 扭曲区域被馈送到两个分支,每个分支都包含一个全连接层。 | 2K 扭曲区域被馈送到全连接层。 |
| 侦测 | CNN 的输出传递到 SVM,以分类到边界框回归器以生成边界框。 | 全连接层的一个输出传递到 softmax 层进行分类,另一个输出传递到包围盒回归器以生成包围盒。 | 全连接层的一个输出传递到 softmax 层进行分类,另一个输出传递到包围盒回归器以生成包围盒。 |
| CNN 类型 | AlexNet | VGG 16 | ZFNet 或 VGGNet。 ZFNet 是 AlexNet 的修改版本。 |
| 区域提议 | 选择性搜索用于生成约 2,000 个区域提议。 | 选择性搜索用于生成约 2,000 个区域提议。 | CNN 用于生成约 21,500 个区域提议(60 x 40 x 9)。 |
| 卷积运算 | 每个图像进行 2K 次卷积操作。 | 每个图像进行一次卷积操作。 | 每个图像进行一次卷积操作。 |
| 区域提议和检测 | 区域提议和检测是分离的。 | 区域提议和检测是分离的。 | 区域提议和检测是耦合的。 |
| 训练时间 | 84 小时 | 9 小时 | 150 小时 |
| 测试时间 | 49 秒 | 2.43 秒 | 0.2 秒 |
| mAP(VOC 2007) | 66 | 66.9 | 66.9 |
上表清楚地显示了 R-CNN 算法的发展以及用于提高 R-CNN 算法准确率的方法。 这是我们从上表中学到的一些关键点:
- 图像分割和选择性搜索以确定像素相似度是一项耗时的操作,因为该操作是逐像素操作。
- 与选择搜索方法相比,使用滑动窗口的 CNN 操作在生成区域提议时要快得多。
- 将 CNN 应用于整个图像要比将 CNN 应用于图像中的区域,然后对给定图像重复此过程 2,000 次要快得多。
GAN 概述
生成对抗网络(GAN)是一类 CNN,可以学习估计数据的概率分布。 GAN 由两个相互竞争的相互连接的神经网络组成,称为生成器和判别器。 生成器基于图像特征的噪声输入生成人工图像,判别器将人工图像与真实图像进行比较,以确定图像真实的可能性。 概率信息将传递到图像输入以在下一阶段学习。 下图说明了 GAN 的机制:

GAN 算法的分步说明如下:
- 给定训练集
z,生成器网络会获取代表图像特征的随机向量,并通过 CNN 运行以生成人工图像G(z)。 - 判别器网络是一个二分类器。 它获取真实图像和人造图像,并生成创建人造图像的概率
P(Z)。 - 判别器将概率信息提供给生成器,生成器使用该信息来改进其对图像
G(z)的预测。
二分类器损失函数称为交叉熵损失函数,并表示为-ylog(p) - (1 - y)log(1 - p),其中p是概率,y是期望值。
- 判别器目标函数:

- 生成器目标函数:

GAN 已经存在许多类型(超过 20 种),并且几乎每个月都会开发出更多类型的 GAN。 以下列表涵盖了 GAN 的两个主要重要变化:
- DCGAN(深度卷积 GAN):如原始 GAN 中所述,CNN 既用于判别器,又用于生成器。
- CGAN(条件 GAN):表示标签的条件向量用作生成网络和判别网络的附加输入。 噪声与标记向量一起被添加到生成网络中,从而检测标记中的变化。
GAN 的一些实际用例如下:
- 生成人造人脸图像和图像数据集
- 合并图像以形成新的数据集
- 生成卡通人物
- 从 2D 图像生成 3D 人脸和对象
- 语义到图像翻译
- 从不同的彩色图像生成一组彩色图像
- 文字到图片翻译
- 人体姿势估计
- 照片编辑和修复
GNN 概述
图神经网络(GNN)将 CNN 学习扩展到图数据。 可以将图表示为节点和边的组合,其中节点代表图的特征,边连接相邻节点,如下图所示:

在此图像中,节点用实心白色点表示,边用连接点的线表示。
以下方程式描述了图的关键参数:
H = (N, E)N = {n[1], n[2], n[3], ...}E ⊆ N x N
将图转换为由节点,边和节点之间的关系组成的向量的过程称为图嵌入。 嵌入向量可以由以下等式表示:


以下列表描述了上述方程式的元素:
hₙ为当前节点n的状态嵌入h_ne[n]为节点n邻域的状态嵌入xₙ为节点n的特征xe[n]为节点n的边的特征x_ne[n]为节点n的邻域特征oₙ为节点n的输出
如果H,X是通过堆叠所有状态和所有特征而构建的向量,则可以为 GNN 迭代状态写以下方程式:

根据 GNN 的类型,前面的一般等式可以导出为各种形式。 主要有两种分类:频谱 GNN 和非频谱 GNN。
频谱神经网络
频谱 GNN 首先由 Joan Bruna,Wojciech Zaremba,Arthus Szlam 和 Yann LeCun 在题为《频谱网络和图上的深局部连接网络》的论文中提出。 您可以在这个页面中找到该论文的详细信息。
频谱 GNN 是傅立叶域中的卷积。 频谱 GNN 可用以下公式表示:

以下列表描述了上述方程式的元素:
g[θ]为过滤器参数,也可以视为卷积权重x为输入信号U为标准化图拉普拉斯L = I[N] - D^(-1/2) A D^(-1/2) = U Λ Uᐪ的特征向量矩阵
Kipf 和 Welling(在其文章《使用图卷积网络进行半监督分类》中)进一步简化了此方法,以解决诸如以下这样的过拟合问题:

使用以下重新规范化,可以进一步简化此操作:

在此,σ代表激活函数。
下图说明了 GNN 的架构:

GNN 层汇总了来自其邻居的特征信息,并应用 ReLU 激活,合并以及全连接层和 softmax 层对图像中的不同特征进行分类。
强化学习概述
强化学习是机器学习的一种类型,其中智能体根据当前累积的奖励信号的反馈来预测奖励(或结果),从而学会在当前环境中采取行动。 由克里斯托弗·沃特金斯(Christopher Watkins)在题为《从延迟奖励中学习》的论文中介绍的Q-学习是强化学习中最受欢迎的算法之一。Q表示质量-这是在产生奖励时特定行为的值:
- 在每个学习状态下,
Q表存储状态,操作和相应奖励的值。 - 智能体在
Q表中进行搜索,以执行使长期累积奖励最大化的下一个操作。 - 强化学习与有监督学习和无监督学习的主要不同之处在于:它不需要输入标签(有监督)或基础结构(无监督)就可以将对象分类。
下图说明了强化学习的概念。 智能体在某种状态下行动以产生行动,从而产生奖励。 动作值会随着时间的推移而不断提高,以最大化回报:

智能体以某种状态(sₜ)启动,观察一系列观察结果,采取行动(aₜ)并接收奖励。
最大化以下累积值函数,以在Q-学习方法中找到所需的输出:

以下列表描述了上述方程式的关键特征:
Q(s[t], a[t])是旧值α是学习率γ在立即奖励和预期延迟奖励之间进行折衷的折扣因子,α是学习率rₜ是奖励- 最大的
Q(s[t+1], a)是学习值
由于Q学习包括对估计的动作值的最大化步长,因此它倾向于高估值。
在强化学习中,可以使用卷积网络来创建能够在复杂情况下获得积极回报的主体行为。 这个概念最早由 Mnih 等人提出,在 2015 年发表在题为《通过深度强化学习进行人为控制》的文章中。该文章可以在这个页面中找到本文的详细信息。
这包括三个卷积层和一个全连接隐藏层。 请注意,在强化学习中,卷积网络得出的解释与监督学习中得出的解释不同。 在监督学习中,CNN 用于将图像分类为不同的类别。 在强化学习中,图片代表一种状态,而 CNN 用于创建智能体在该状态下执行的动作。
迁移学习概述
到目前为止,我们已经学会了通过隔离设计工作来解决特定任务来构造 CNN 架构。 神经网络模型是深度密集型的,需要大量的训练数据,训练运行以及进行调优的专家知识才能获得高精度; 但是,作为人类,我们不会从头开始学习所有内容,而是向他人学习,而从云(互联网)学习。 当数据不足以供我们尝试分析的新类使用时,迁移学习非常有用,但是在相似类中存在大量预先存在的数据。 每个 CNN 模型(AlexNet,VGG16,ResNet 和 Inception)都已在 ImageNet ILSVRC 比赛数据集中进行了训练。 ImageNet 是一个数据集,在 22,000 个类别中包含超过 1500 万张带标签的图像。 ILSVRC 使用 ImageNet 的子集,在 1,000 个类别中的每个类别中都有大约 1,000 个图像。
在迁移学习中,可以修改针对其他情况开发的预训练模型,以用于我们的特定情况来预测我们自己的类。 我们的想法是选择我们已经研究过的 CNN 架构,例如 AlexNet,VGG16,ResNet 和 Inception,冻结一层或两层,更改一些权重,并输入我们自己的数据来对类进行预测。 在“第 4 章”,“图像深度学习”中,我们了解了 CNN 如何查看和解释图像。
这些学习将用于构建迁移学习,因此,让我们在“第 4 章”,“图像深度学习”中总结在 CNN 可视化中学习的一些要点:
- 前几层基本上是汽车的通用特征(例如边检测,斑点检测等),中间层将边结合起来形成汽车的特征,例如轮胎,门把手,灯,仪表板, 等等,最后几层是非常抽象的,并且对于特定对象非常特定。
- 全连接层将其上一层的输出展平为单个向量,将其乘以不同的权重,然后在其上应用激活系数。 它使用机器学习支持向量机(SVM)类型的方法进行分类。
现在,我们理解了这些概念,我们将能够理解以下常用的迁移学习方法:
-
删除并交换 softmax 层:
-
使用 TensorFlow 取得在 ImageNet 上预先训练的 CNN,例如 VGG16,AlexNet,ResNet 或 Inception。
-
删除最后一个 softmax 层,并将 CNN 的其余部分视为新数据集的固定特征提取器。
-
用定义自己的类数的自定义 softmax 替换 softmax 层,并使用数据集训练结果模型。
-
微调 ConvNet。 为了减少过拟合,请保持一些较早的层固定,并且仅微调网络的较高层部分。 正如我们在“第 4 章”,“图像深度学习”的可视化示例中所看到的那样,最后一层非常抽象,并且针对特定数据集进行了调整,因此冻结整个模型,并将“步骤 1”的 softmax 更改为新的 softmax 可能会导致更高的准确率。 为了提高准确率,最好从 CNN 的中间训练您的自定义图像,这样,在全连接层之前的最后几层将具有特定于您的应用的特征,这将导致更高的预测准确率。 在“第 6 章”,“使用迁移学习的视觉搜索”中,我们将对此概念进行编码,并看到从 CNN 中部附近开始训练的准确率提高。
总结
在本章中,我们了解了不同卷积网络(ConvNet)的架构,以及如何将 ConvNet 的不同层堆叠在一起以将各种输入分类为预定义的类。 我们了解了不同的图像分类模型,例如 AlexNet,VGGNet,Inception 和 ResNet,它们为何不同,它们解决了哪些问题以及它们的整体相似性。
我们了解了对象检测方法(例如 R-CNN),以及如何将其随时间转换为快速,快速的 R-CNN 用于边界框检测。 本章介绍了两个新模型 GAN 和 GNN,作为两个新的神经网络集。 本章最后介绍了强化学习和迁移学习。 我们了解到,在强化学习中,智能体与环境交互以基于奖励学习最佳策略(例如,在十字路口向左或向右转),而在迁移学习中,通过优化 CNN 的后续层,预先训练的模型(例如 VGG16)可以根据新数据派生新类。
在下一章中,您将学习如何使用迁移学习来训练自己的神经网络,然后使用受过训练的网络进行视觉搜索。
六、使用迁移学习的视觉搜索
视觉搜索是一种显示与用户上传到零售网站的图像相似的图像的方法。 通过使用 CNN 将图像转换为特征向量,可以找到相似的图像。 视觉搜索在网上购物中具有许多应用,因为它补充了文本搜索,从而更好地表达了用户对产品的选择,并且更加精致。 购物者喜欢视觉发现,并发现它是传统购物体验所没有的独特东西。
在本章中,我们将使用在“第 4 章”,“图像深度学习”和“第 5 章”,“神经网络架构和模型”中学习的深度神经网络的概念。我们将使用迁移学习为图像类别开发神经网络模型,并将其应用于视觉搜索。 本章中的练习将帮助您开发足够的实践知识,以编写自己的神经网络代码和迁移学习。
本章涵盖的主题如下:
- 使用 TensorFlow 编码深度学习模型
- 使用 TensorFlow 开发迁移学习模型
- 了解视觉搜索的架构和应用
- 使用
tf.data处理视觉搜索输入数据管道
使用 TensorFlow 编码深度学习模型
我们在“第 5 章”,“神经网络架构和模型”中了解了各种深度学习模型的架构。 在本节中,我们将学习如何使用 TensorFlow/Keras 加载图像,浏览和预处理数据,然后应用三个 CNN 模型(VGG16,ResNet 和 Inception)的预训练权重来预测对象类别。
请注意,由于我们不是在构建模型,而是将使用已构建的模型(即具有预先训练的权重的模型)来预测图像类别,因此本部分不需要训练。
让我们深入研究代码并了解其每一行的目的。
下载权重
下载权重的代码如下:
from tensorflow.keras.applications import VGG16
from keras.applications.vgg16 import preprocess_input
from tensorflow.keras.applications.resnet50 import ResNet50, preprocess_input
from tensorflow.keras.applications import InceptionV3
from keras.applications.inception_v3 import preprocess_input
前面的代码执行以下两个任务:
- 权重将作为以下代码的输出的一部分按以下方式下载:
Download VGG16 weight, the *.h5 fileDownload Resnet50 weight, the *.h5 fileDownload InceptionV3 weight, the *.h5 file
- 它对图像进行预处理,以将当前图像标准化为
ImageNet RGB数据集。 由于该模型是在ImageNet数据集上开发的,因此,如果没有此步骤,该模型可能会导致错误的类预测。
解码预测
ImageNet 数据具有 1,000 个不同的类别。 诸如在 ImageNet 上训练的 Inception 之类的神经网络将以整数形式输出该类。 我们需要使用解码将整数转换为相应的类名称。 例如,如果输出的整数值为311,则需要解码311的含义。 通过解码,我们将知道311对应于折叠椅。
用于解码预测的代码如下:
from tensorflow.keras.applications.vgg16 import decode_predictions
from tensorflow.keras.applications.resnet50 import decode_predictions
from tensorflow.keras.applications.inception_v3 import decode_predictions
前面的代码使用decode_predictions命令将类整数映射到类名称。 没有此步骤,您将无法预测类名。
导入其他常用库
本节是关于导入 Keras 和 Python 的通用包的。 Keras preprocessing是 Keras 的图像处理模块。 导入其他常见库的代码如下所示:
from keras.preprocessing import image
import numpy as np
import matplotlib.pyplot as plt
import os
from os import listdir
您可以在前面的代码中观察以下内容:
- 我们加载了 Keras 图像预处理库。
numpy是 Python 数组处理库。matplotlib是 Python 绘图库。- 需要
os模块才能访问输入文件的目录。
建立模型
在本节中,我们将导入一个模型。 用于模型构建的代码如下所示(每个代码段的说明都在代码下方):
model = Modelx(weights='imagenet', include_top=True,input_shape=(img_height, img_width, 3))
Modelx = VGG16 or ResNet50 or InceptionV3
模型构建具有三个重要参数:
weights是我们在以前下载的 ImageNet 图像上使用的预训练模型。include_top参数指示是否应包含最终的密集层。 对于预训练模型的类别预测,始终为True; 但是,在本章的后面部分(“使用 TensorFlow 开发迁移学习模型”)中,我们将学习到,在迁移学习期间,此参数设置为False仅包含卷积层。input_shape是通道的高度,宽度和数量。 由于我们正在处理彩色图像,因此通道数设置为3。
从目录输入图像
从目录输入图像的代码如下所示:
folder_path = '/home/…/visual_search/imagecnn/'
images = os.listdir(folder_path)
fig = plt.figure(figsize=(8,8))
前面的代码指定图像文件夹路径,并定义了图像属性,以便能够在以后的部分中下载图像。 它还将图像尺寸指定为8 x 8。
使用 TensorFlow Keras 导入并处理多个图像的循环
本节介绍如何批量导入多个图像以一起处理所有图像,而不是一个一个地导入它们。 这是学习的一项关键技能,因为在大多数生产应用中,您不会一步一步地导入图像。 使用 TensorFlow Keras 导入和处理多个图像的循环函数的代码如下:
for image1 in images:
i+=1
im = image.load_img(folder_path+image1, target_size=(224, 224))
img_data = image.img_to_array(im)
img_data = np.expand_dims(img_data, axis=0)
img_data = preprocess_input(img_data)
resnet_feature = model_resnet.predict(img_data,verbose=0)
label = decode_predictions(resnet_feature)
label = label[0][0]
fig.add_subplot(rows,columns,i)
fig.subplots_adjust(hspace=.5)
plt.imshow(im)
stringprint ="%.1f" % round(label[2]*100,1)
plt.title(label[1] + " " + str(stringprint) + "%")
plt.show()
前面的代码执行以下步骤:
-
以
image1作为循环的中间值,循环遍历images属性。 -
image.load函数将每个新图像添加到文件夹路径。 请注意,对于 VGG16 和 ResNet,目标大小是224,对于启动,目标大小是299。 -
使用 NumPy 数组将图像转换为数组函数并扩展其尺寸,然后按照“下载权重”部分中的说明应用
preprocessing函数。 -
接下来,它使用
model.predict()函数计算特征向量。 -
然后,预测解码类别标签名称。
-
label函数存储为数组,并且具有两个元素:类名和置信度%。 -
接下来的几节涉及使用
matplotlib库进行绘图:
fig.add_subplot具有三个元素:rows,columns和i–例如,总共 9 幅图像分为三列三行,i项将从1变为9,1是第一张图片,9是最后一张图片。fig.subplots_adjust在图像之间添加垂直空间。plt.title将标题添加到每个图像。
为了验证模型,将九张不同的图像存储在目录中,并逐个通过每个模型以生成预测。 下表显示了使用三种不同的神经网络模型对每个目标图像的最终预测输出:
| 目标图片 | VGG16 | ResNet | Inception |
|---|---|---|---|
| 餐桌 | 餐桌 58% | 台球桌 30.1% | 桌子 51% |
| 炒锅 | 钢包 55% | 钢包 87% | 钢包 30% |
| 沙发 | 单人沙发 42% | 单人沙发 77% | 单人沙发 58% |
| 床 | 单人沙发 35% | 四海报 53% | 单人沙发 44% |
| 水壶 | 水壶 93% | 水壶 77% | 水壶 98% |
| 行李 | 折叠椅 39% | 背包 66% | 邮袋 35% |
| 背包 | 背包 99.9% | 背包 99.9% | 背包 66% |
| 长椅 | 单人沙发 79% | 单人沙发 20% | 单人沙发 48% |
| 越野车 | 小型货车 74% | 小型货车 98% | 小型货车 52% |
下图显示了九个类的 VGG16 输出:

在上图中,您可以观察到以下内容:
- 每个图像尺寸为
224 x 224,标签的顶部打印有置信度百分比。 - 三种错误的预测:炒锅(预测为钢包),床(预测为工作室沙发)和行李(预测为折叠椅)。
下图显示了这九类的 ResNet 预测输出:

在上图中,您可以观察到以下内容:
- 每个图像尺寸为
224 x 224,标签的顶部打印有置信度百分比。 - 有两个错误的预测:炒锅(预测为钢包)和行李(预测为背包)。
下图显示了这九类的初始预测输出:

由此,您可以观察到以下内容:
- 每个图像尺寸为
224 x 224,标签的顶部打印有置信度百分比。 - 有两个错误的预测:炒锅(预测为钢包)和床(预测为工作室沙发)。
通过本练习,我们现在了解了如何在不训练单个图像的情况下使用预先训练的模型来预测知名的类对象。 我们之所以这样做,是因为每个图像模型都使用 ImageNet 数据库中的 1,000 个类别进行了训练,并且计算机视觉社区可以使用该模型产生的权重,以供其他模型使用。
在下一节中,我们将学习如何使用迁移学习为自定义图像训练模型以进行预测,而不是从直接从 ImageNet 数据集开发的模型中进行推断。
使用 TensorFlow 开发迁移学习模型
我们在“第 5 章”,“神经网络架构和模型”中引入了迁移学习的概念,并在“使用 TensorFlow 编写深度学习模型”部分中,演示了如何基于预训练模型预测图像类别。 我们已经观察到,预训练模型在大型数据集上可以获得合理的准确率,但是我们可以通过在自己的数据集上训练模型来对此进行改进。 一种方法是构建整个模型(例如,ResNet)并在我们的数据集上对其进行训练-但是此过程可能需要大量时间才能运行模型,然后为我们自己的数据集优化模型参数。
另一种更有效的方法(称为迁移学习)是从基本模型中提取特征向量,而无需在 ImageNet 数据集上训练顶层,然后添加我们的自定义全连接层,包括激活,退出和 softmax,构成我们的最终模型。 我们冻结了基础模型,但是新添加的组件的顶层仍未冻结。 我们在自己的数据集上训练新创建的模型以生成预测。 从大型模型迁移学习的特征映射,然后通过微调高阶模型参数在我们自己的数据集上对其进行自定义的整个过程称为迁移学习。 在接下来的几节中,将从“分析和存储数据”开始,说明迁移学习工作流程以及相关的 TensorFlow/Keras 代码。
分析和存储数据
首先,我们将从分析和存储数据开始。 在这里,我们正在构建具有三个不同类别的家具模型:bed,chair和sofa。 我们的目录结构如下。 每个图像都是大小为224 x 224的彩色图像。
Furniture_images:
-
train(2,700 张图像)bed(900 张图像)chair(900 张图像)sofa(900 张图像)
-
val(300 张图像)bed(100 张图像)chair(100 张图像)sofa(100 张图像)
注意,图像数量仅是示例; 在每种情况下都是独一无二的。 要注意的重要一点是,为了进行良好的检测,我们每类需要约 1,000 张图像,并且训练和验证的比例为 90%:10%。
导入 TensorFlow 库
我们的下一步是导入 TensorFlow 库。 以下代码导入 ResNet 模型权重和预处理的输入,与上一节中的操作类似。 我们在“第 5 章”,“神经网络架构和模型”中了解了每个概念:
from tensorflow.keras.applications.resnet50 import ResNet50, preprocess_input
from tensorflow.keras.layers import Dense, Activation, Flatten, Dropout
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.optimizers import SGD, Adam
img_width, img_height = 224, 224
该代码还导入了几个深度学习参数,例如Dense(全连接层),Activation,Flatten和Dropout。 然后,我们导入顺序模型 API 以创建逐层模型,并使用随机梯度下降(SGD)和 Adam 优化器。 对于 ResNet 和 VGG,图像的高度和宽度为224,对于 Inception 模型,图像的高度和宽度为299。
设置模型参数
为了进行分析,我们设置模型参数,如以下代码块所示:
NUM_EPOCHS = 5
batchsize = 10
num_train_images = 900
num_val_images = 100
然后,基础模型的构建类似于上一节中的示例,不同之处在于,我们不通过设置include_top=False来包括顶级模型:
base_model = ResNet50(weights='imagenet',include_top=False,input_shape=(img_height, img_width, 3))
在此代码中,我们使用基本模型通过仅使用卷积层来生成特征向量。
建立输入数据管道
我们将导入一个图像数据生成器,该图像数据生成器使用诸如旋转,水平翻转,垂直翻转和数据预处理之类的数据扩充来生成张量图像。 数据生成器将重复训练和验证数据。
训练数据生成器
让我们看一下用于训练数据生成器的以下代码:
from keras.preprocessing.image import ImageDataGenerator
train_dir = '/home/…/visual_search/furniture_images/train'
train_datagen = ImageDataGenerator(preprocessing_function=preprocess_input,rotation_range=90,horizontal_flip=True,vertical_flip=True)
目录 API 的流程-用于从目录导入数据。 它具有以下参数:
Directory:这是文件夹路径,应设置为存在所有三个类的图像的路径。 在这种情况下,示例为train目录的路径。 要获取路径,您可以将文件夹拖到终端,它会向您显示路径,然后可以将其复制并粘贴。Target_size:将其设置为等于模型拍摄的图像大小,例如,对于 Inception 为 299 x 299,对于 ResNet 和 VGG16 为224 x 224。Color_mode:将黑白图像设置为grayscale,将彩色图像设置为RGB。Batch_size:每批图像的数量。class_mode:如果只有两个类别可以预测,则设置为二进制;否则,请设置为二进制。 如果不是,则设置为categorical。shuffle:如果要重新排序图像,请设置为True; 否则,设置为False。seed:随机种子,用于应用随机图像增强和混排图像顺序。
以下代码显示了如何编写最终的训练数据生成器,该数据将导入模型中:
train_generator = train_datagen.flow_from_directory(train_dir,target_size=(img_height, img_width), batch_size=batchsize)
验证数据生成器
接下来,我们将在以下代码中重复验证过程。 该过程与训练生成器的过程相同,除了我们将验证图像目录而不是训练图像目录:
from keras.preprocessing.image import ImageDataGenerator
val_dir = '/home/…/visual_search/furniture_images/val'
val_datagen = ImageDataGenerator(preprocessing_function=preprocess_input,rotation_range=90,horizontal_flip=True,vertical_flip=True)
val_generator = val_datagen.flow_from_directory(val_dir,target_size=(img_height, img_width),batch_size=batchsize)
前面的代码显示了最终的验证数据生成器。
使用迁移学习构建最终模型
我们首先定义一个名为build_final_model()的函数,该函数接收基本模型和模型参数,例如丢弃,全连接层以及类的数量。 我们首先使用layer.trainable = False冻结基本模型。 然后,我们将基础模型输出特征向量展平,以进行后续处理。 接下来,我们添加一个全连接层并将其放置到展平的特征向量上,以使用 softmax 层预测新类:
def build_final_model(base_model, dropout, fc_layers, num_classes):
for layer in base_model.layers:
layer.trainable = False
x = base_model.output
x = Flatten()(x)
for fc in fc_layers:
# New FC layer, random init
x = Dense(fc, activation='relu')(x)
x = Dropout(dropout)(x)
# New softmax layer
predictions = Dense(num_classes, activation='softmax')(x)
final_model = Model(inputs=base_model.input, outputs=predictions)
return final_model
class_list = ["bed", "chair", "sofa"]
FC_LAYERS = [1024, 1024]
dropout = 0.3
final_model = build_final_model(base_model,dropout=dropout,fc_layers=FC_LAYERS,num_classes=len(class_list))
使用带有分类交叉熵损失的adam优化器编译模型:
adam = Adam(lr=0.00001)
final_model.compile(adam, loss='categorical_crossentropy', metrics=['accuracy'])
使用model.fit_generator命令开发并运行最终模型。 历史记录存储周期,每步时间,损失,准确率,验证损失和验证准确率:
history = final_model.fit(train_dir,epochs=NUM_EPOCHS,steps_per_epoch=num_train_images // batchsize,callbacks=[checkpoint_callback],validation_data=val_dir, validation_steps=num_val_images // batchsize)
此处说明model.fit()的各种参数。 注意mode.fit_generator将来会被弃用,并由model.fit()函数代替,如上所示:
train_dir:输入训练数据; 其操作的详细信息已在上一节中进行了说明。epochs:一个整数,指示训练模型的周期数。 周期从1递增到epochs的值。steps_per_epoch:这是整数。 它显示了训练完成和开始下一个周期训练之前的步骤总数(样本批量)。 其最大值等于(训练图像数/batch_size)。 因此,如果有 900 张训练图像且批量大小为 10,则每个周期的步数为 90。workers:较高的值可确保 CPU 创建足够的批量供 GPU 处理,并且 GPU 永远不会保持空闲状态。shuffle:这是布尔类型。 它指示每个周期开始时批量的重新排序。 仅与Sequence(keras.utils.Sequence)一起使用。 当steps_per_epoch不是None时,它无效。Validation_data:这是一个验证生成器。validation_steps:这是validation_data生成器中使用的步骤总数(样本批量),等于验证数据集中的样本数量除以批量大小。
使用检查点保存模型
一个 TensorFlow 模型可以运行很长时间,因为每个周期都需要几分钟才能完成。 TensorFlow 有一个名为Checkpoint的命令,使我们能够在每个周期完成时保存中间模型。 因此,如果由于损失已经饱和而不得不在中间中断模型或将 PC 用于其他用途,则不必从头开始—您可以使用到目前为止开发的模型进行分析。 下面的代码块显示了对先前代码块的添加,以执行检查点:
from tensorflow.keras.callbacks import ModelCheckpoint
filecheckpath="modelfurn_weight.hdf5"
checkpointer = ModelCheckpoint(filecheckpath, verbose=1, save_best_only=True)
history = final_model.fit_generator(train_generator, epochs=NUM_EPOCHS, workers=0,steps_per_epoch=num_train_images // batchsize, shuffle=True, validation_data=val_generator,validation_steps=num_val_images // batchsize, callbacks = [checkpointer])
前面代码的输出如下:
89/90 [============================>.] - ETA: 2s - loss: 1.0830 - accuracy: 0.4011 Epoch 00001: val_loss improved from inf to 1.01586, saving model to modelfurn_weight.hdf5 90/90 [==============================] - 257s 3s/step - loss: 1.0834 - accuracy: 0.4022 - val_loss: 1.0159 - val_accuracy: 0.4800
Epoch 2/5 89/90 [============================>.] - ETA: 2s - loss: 1.0229 - accuracy: 0.5067 Epoch 00002: val_loss improved from 1.01586 to 0.87938, saving model to modelfurn_weight.hdf5 90/90 [==============================] - 253s 3s/step - loss: 1.0220 - accuracy: 0.5067 - val_loss: 0.8794 - val_accuracy: 0.7300
Epoch 3/5 89/90 [============================>.] - ETA: 2s - loss: 0.9404 - accuracy: 0.5719 Epoch 00003: val_loss improved from 0.87938 to 0.79207, saving model to modelfurn_weight.hdf5 90/90 [==============================] - 256s 3s/step - loss: 0.9403 - accuracy: 0.5700 - val_loss: 0.7921 - val_accuracy: 0.7900
Epoch 4/5 89/90 [============================>.] - ETA: 2s - loss: 0.8826 - accuracy: 0.6326 Epoch 00004: val_loss improved from 0.79207 to 0.69984, saving model to modelfurn_weight.hdf5 90/90 [==============================] - 254s 3s/step - loss: 0.8824 - accuracy: 0.6322 - val_loss: 0.6998 - val_accuracy: 0.8300
Epoch 5/5 89/90 [============================>.] - ETA: 2s - loss: 0.7865 - accuracy: 0.7090 Epoch 00005: val_loss improved from 0.69984 to 0.66693, saving model to modelfurn_weight.hdf5 90/90 [==============================] - 250s 3s/step - loss: 0.7865 - accuracy: 0.7089 - val_loss: 0.6669 - val_accuracy: 0.7700
输出显示每个周期的损失和准确率,并且相应的文件另存为hdf5文件。
绘制训练历史
使用 Python matplotlib函数显示了显示训练精度和每个周期的训练损失的折线图。 我们将首先导入matplotlib,然后为训练和验证损失以及准确率定义参数:
import matplotlib.pyplot as plt
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
以下代码是使用 Keras 和 TensorFlow 绘制模型输出的标准代码。 我们首先定义图像大小(8 x 8),并使用子图函数显示(2,1,1)和(2,1,2)。 然后,我们定义标签,限制和标题:
plt.figure(figsize=(8, 8))
plt.subplot(2, 1, 1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.ylabel('Accuracy')
plt.ylim([min(plt.ylim()),1])
plt.title('Training and Validation Accuracy')
plt.subplot(2, 1, 2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.ylabel('Cross Entropy')
plt.ylim([0,5.0])
plt.title('Training and Validation Loss')
plt.xlabel('epoch')
plt.show()
让我们看一下前面代码的输出。 以下屏幕截图显示了不同模型之间的精度比较。 它显示了 Inception 的训练参数:

在前面的屏幕截图中,您可以观察到 Inception 的准确率在五个周期内达到了约 90%。 接下来,我们绘制 VGG16 的训练参数:

上图显示 VGG16 的精度在五个周期内达到了约 80%。 接下来,我们绘制 ResNet 的训练参数:

前面的屏幕截图显示 ResNet 的准确率在四个周期内达到了约 80%。
对于所有三个模型,在四个周期内,精度始终达到至少 80%。 Inception 模型的结果具有最高的准确率。
了解视觉搜索的架构和应用
视觉搜索使用深度神经网络技术来检测和分类图像及其内容,并使用它在图像数据库内搜索以返回匹配结果列表。 视觉搜索与零售行业特别相关,因为它允许零售商显示大量类似于客户上传图像的图像以增加销售收入。视觉搜索可以与语音搜索结合使用,从而进一步增强搜索效果。 视觉信息比文本信息更相关,这导致视觉搜索更加流行。 许多不同的公司,包括 Google,Amazon,Pinterest,Wayfair,Walmart,Bing,ASOS,Neiman Marcus,IKEA,Argos 等,都建立了强大的视觉搜索引擎来改善客户体验。
视觉搜索的架构
诸如 ResNet,VGG16 和 Inception 之类的深度神经网络模型实质上可以分为两个部分:
- 第一个组件标识图像的低级内容,例如特征向量(边缘)。
- 第二部分表示图像的高级内容,例如最终的图像特征,它们是各种低级内容的集合。 下图说明了将七个类别分类的卷积神经网络:

上图显示了整个图像分类神经网络模型可以分为两个部分:卷积层和顶层。 在全连接层之前的最后一个卷积层是形状的特征向量(图像数, X, Y, 通道数),并且被展平(图像数 * X * Y * 通道数)以生成n维向量。
特征向量形状具有四个分量:
图像数表示训练图像的数量。 因此,如果您有 1,000 个训练图像,则该值为 1,000。X表示层的宽度。 典型值为 14。Y表示层的高度,可以是 14。通道数表示过滤器的数量或深度 Conv2D。 典型值为 512。
在视觉搜索中,我们通过使用欧几里得距离或余弦相似度等工具比较两个特征向量的相似度来计算两个图像的相似度。 视觉搜索的架构如下所示:

此处列出了各个步骤:
- 通过将顶层与知名模型(例如 ResNet,VGG16 或 Inception)分离,然后添加自定义顶层(包括全连接层,退出,激活和 softmax 层),使用迁移学习来开发新模型。
- 使用新的数据集训练新模型。
- 通过刚刚开发的新模型运行图像,上传图像并找到其特征向量和图像类。
- 为了节省时间,请仅在与上载图像相对应的目录类中进行搜索。
- 使用诸如欧几里得距离或余弦相似度的算法进行搜索。
- 如果余弦相似度
> 0.999,则显示搜索结果;否则,显示搜索结果。 如果不是,请使用上传的图像重新训练模型,或者调整模型参数并重新运行该过程。 - 为了进一步加快搜索速度,请使用生成的边界框检测上载图像内以及搜索图像数据库和目录内对象的位置。
上述流程图包含几个关键组件:
- 模型开发:这包括选择一个合适的预训练模型,除去其顶部附近的层,冻结之前的所有层,并添加一个新的顶层以匹配我们的类。 这意味着,如果我们使用在 1,000 个类的 ImageNet 数据集上训练的预训练模型,我们将删除其顶层,并仅用 3 类
bed,chair和sofa替换为新的顶层。 。 - 模型训练:这涉及首先编译模型,然后使用
model.fit()函数开始训练。 - 模型输出:将上传的图像和测试图像数据库中的每个图像传递给模型,以生成特征向量。 上载的图像也用于确定模型类别。
- 搜索算法:搜索算法在给定类别指定的测试图像文件夹中执行,而不是在整个测试图像集中执行,从而节省了时间。 搜索算法依赖于 CNN 模型选择的正确类别。 如果类匹配不正确,则最终的视觉搜索将导致错误的结果。 要解决此问题,可以采取几个步骤:
-
使用新的图像集重新运行模型,增加训练图像的大小,或改善模型参数。
-
但是,无论使用多少数据,CNN 模型都永远不会具有 100% 的准确率。 因此,为解决此问题,通常在视觉搜索结果中添加文本关键字搜索。 例如,客户可能会写,“您能找到一张与上图中显示的床相似的床吗?” 在这种情况下,我们知道上载的类是床。 这是使用自然语言处理(NLP)完成的。
-
解决该问题的另一种方法是针对多个预先训练的模型运行相同的上载图像,如果类别预测彼此不同,则采用模式值。
接下来,我们将详细说明用于视觉搜索的代码。
视觉搜索代码和说明
在本部分中,我们将解释用于视觉搜索的 TensorFlow 代码及其功能:
- 首先,我们将为上传的图像指定一个文件夹(共有三个文件夹,我们将针对每种图像类型切换文件夹)。 请注意,此处显示的图像仅是示例; 您的图片可能有所不同:
#img_path = '/home/…/visual_search/ test/bed/bed1.jpg'
#img_path ='/home/…/visual_search/test/chair/chair1.jpg'
#img_path ='/home/…/visual_search/test/sofa/sofa1.jpg'
- 然后,我们将上传图像,将图像转换为数组,并像之前一样对图像进行预处理:
img = image.load_img(img_path, target_size=(224, 224))
img_data = image.img_to_array(img)
img_data = np.expand_dims(img_data, axis=0)
img_data = preprocess_input(img_data)
前面的代码是在进一步处理之前将图像转换为数组的标准代码。
预测上传图像的类别
一旦上传了新图像,我们的任务就是找出它属于哪个类。 为此,我们计算图像可能属于的每个类别的概率,然后选择概率最高的类别。 此处的示例说明了使用 VGG 预训练模型进行的计算,但相同的概念在其他地方也适用:
vgg_feature = final_model.predict(img_data,verbose=0)
vgg_feature_np = np.array(vgg_feature)
vgg_feature1D = vgg_feature_np.flatten()
print (vgg_feature1D)
y_prob = final_model.predict(img_data)
y_classes = y_prob.argmax(axis=-1)
print (y_classes)
在前面的代码中,我们使用model.predict()函数计算了图像属于特定类别的概率,并使用probability.argmax计算了类别名称以指示具有最高概率的类别。
预测所有图像的类别
以下函数导入必要的包,以从目录和相似度计算中获取文件。 然后,根据上传图像的输入类别指定要定位的文件夹:
import os
from scipy.spatial import distance as dist
from sklearn.metrics.pairwise import cosine_similarity
if y_classes == [0]:
path = 'furniture_images/val/bed'
elif y_classes == [1]:
path = 'furniture_images/val/chair'
else:
path = 'furniture_images/val/sofa'
以下函数循环遍历测试目录中的每个图像,并将该图像转换为数组,然后使用训练后的模型将其用于预测特征向量:
mindist=10000
maxcosine =0
i=0
for filename in os.listdir(path):
image_train = os.path.join(path, filename)
i +=1
imgtrain = image.load_img(image_train, target_size=(224, 224))
img_data_train = image.img_to_array(imgtrain)
img_data_train = np.expand_dims(img_data_train, axis=0)
img_data_train = preprocess_input(img_data_train)
vgg_feature_train = final_model.predict(img_data_train)
vgg_feature_np_train = np.array(vgg_feature_train)
vgg_feature_train1D = vgg_feature_np_train.flatten()
eucldist = dist.euclidean(vgg_feature1D,vgg_feature_train1D)
if mindist > eucldist:
mindist=eucldist
minfilename = filename
#print (vgg16_feature_np)
dot_product = np.dot(vgg_feature1D,vgg_feature_train1D)#normalize the results, to achieve similarity measures independent #of the scale of the vectors
norm_Y = np.linalg.norm(vgg_feature1D)
norm_X = np.linalg.norm(vgg_feature_train1D)
cosine_similarity = dot_product / (norm_X * norm_Y)
if maxcosine < cosine_similarity:
maxcosine=cosine_similarity
cosfilename = filename
print ("%s filename %f euclediandist %f cosine_similarity" %(filename,eucldist,cosine_similarity))
print ("%s minfilename %f mineuclediandist %s cosfilename %f maxcosinesimilarity" %(minfilename,mindist, cosfilename, maxcosine))
您可以在前面的代码中观察以下内容:
- 将每个特征向量与上传的图像特征向量进行比较,以计算出欧几里得距离和余弦相似度。
- 通过确定欧几里得距离的最小值和余弦相似度的最大值来计算图像相似度。
- 确定并显示与最小距离相对应的图像文件。
可以在本书的 GitHub 存储库中找到包括迁移学习和可视搜索的完整代码。
下图显示了使用三种不同的模型和两种不同的搜索算法(欧几里得距离和余弦相似度)对一张床的上传图像的视觉搜索预测:

在上图中,可以观察到以下内容:
- Inception 模型预测的类别不准确,这导致可视搜索模型预测了错误的类别。
- 请注意,视觉搜索模型无法捕获预测错误类的神经网络。 我们还可以使用其他模型检查同一张上载图片的类别预测,以查看模式(多数)值-在这种情况下,ResNet 和 VGG 预测为
bed时为bed,而 Inception 预测为sofa。 - 综上所述,由于我们不知道给定的模型是否可以正确预测类别,因此建议的方法是同时使用三个或更多不同的模型预测上传图像的类别,然后选择具有多数值的预测类别。 使用这种方法,我们将增加我们预测的信心。
下图显示了使用其他上载图像的预测,这似乎是正确的:

下图显示了使用三种不同的模型和两种不同的搜索算法(欧几里得距离和余弦相似度)对椅子上载图像的视觉搜索预测:

您可以在上图中观察到以下内容:
- 尽管余弦相似度函数显示的图像与欧几里得距离函数的图像不同,但在所有情况下预测都是正确的。
- 两者似乎都非常接近,这两种显示方法为我们提供了一种显示多个图像的方法。 这意味着,如果用户上传一张椅子的图像并希望在在线目录中找到类似的椅子,我们的系统将显示两幅图像供用户选择,而不仅仅是一张图像,这将增加我们的椅子的销售机会。 如果两个图像相同,则算法将仅显示一个图像,否则将显示两个图像。 另一个选择是使用相同算法显示前两个匹配项。
下图显示了使用三种不同的模型和两种不同的搜索算法(欧几里得距离和余弦相似度)对沙发上载图像的视觉搜索预测:

您可以在上图中观察到以下内容:
- 尽管余弦相似度函数显示的图像与欧几里得距离函数的图像不同,但在所有情况下预测都是正确的。
- 两者似乎都非常接近,显示的两种方法为我们提供了一种显示多个图像的方法。 如前所述,对于与上载图像相似的两个图像,用户可以选择更多选项。
使用tf.data的视觉搜索输入管道
TensorFlow tf.data API 是一种高效的数据管道,其处理数据的速度比 Keras 数据输入过程快一个数量级。 它在分布式文件系统中聚合数据并对其进行批量。 有关更多详细信息,请参阅这里。
以下屏幕截图显示了tf.data与 Keras 图像输入过程的图像上传时间比较:

请注意,一千张图像大约需要 1.58 秒,比 Keras 图像输入过程快 90 倍。
这是tf.data的一些常见函数:
- 为了使该 API 起作用,您需要导入
pathlib库。 tf.data.Dataset.list_files用于创建与模式匹配的所有文件的数据集。tf.strings.splot基于定界符分割文件路径。tf.image.decode_jpeg将 JPEG 图像解码为张量(请注意,转换必须没有文件路径)。tf.image.convert_image_dtype将图像转换为dtype float32。
如前所述,该代码包含tf.data。 除了tf.data以外,它还通过在build_final_model中进行以下更改来解冻模型的顶部:
layer.trainable = True
layer_adjust = 100
for layer in base_model.layers[:layer_adjust]:
layer.trainable = False
前面的更改使模型可以在第一百层之后开始训练,而不是仅训练最后几层。 如下图所示,此更改提高了准确率:

训练花费更多时间,但是模型的准确率接近 100%,而不是 90%。
在总结本章之前,让我们回顾一下训练 CNN 的两个重要概念:准确率和损失性。 Keras 将y-pred和y-true定义为模型预测值和地面真实值。 准确率定义为将y-pred与y-true进行比较,然后平均差异。 损失项(也称为熵)定义为乘积类别概率与分类指数的负和。 可能还有其他损失项,例如 RMSProp。 通常,如果accuracy > 0.9和loss < 1,训练会给出正确的输出。
总结
在本章中,我们学习了如何使用 TensorFlow/Keras 为上一章研究的深度学习模型开发迁移学习代码。 我们学习了如何从包含多个类的目录中导入经过训练的图像,并使用它们来训练模型并进行预测。 然后,我们学习了如何使模型的基础层保持冻结状态,移除顶层并用我们自己的顶层替换它,并使用它来训练结果模型。
我们研究了视觉搜索的重要性以及如何使用迁移学习来增强视觉搜索方法。 我们的示例包括三种不同类别的家具-我们了解了模型的准确率以及如何改善由此造成的损失。 在本章中,我们还学习了如何使用 TensorFlow tf.data输入管道在训练期间更快地处理图像。
在下一章中,我们将研究 YOLO,以便在图像和视频上绘制边界框对象检测,并将其用于进一步改善视觉搜索。
七、YOLO 对象检测
在上一章中,我们详细讨论了各种神经网络图像分类和对象检测架构,这些架构利用多个步骤进行对象检测,分类和边界框优化。 在本章中,我们将介绍两种单阶段的快速对象检测方法-仅查看一次(YOLO)和 RetinaNet。 我们将讨论每个模型的架构,然后使用 YOLO v3 在真实的图像和视频中进行推理。 我们将向您展示如何使用 YOLO v3 优化配置参数和训练自己的自定义映像。
本章涵盖的主题如下:
- YOLO 概述
- 用于对象检测的 Darknet 简介
- 使用 Darknet 和 Tiny Darknet 进行实时预测
- 比较 YOLO – YOLO 与 YOLO v2 与 YOLO v3
- 什么时候训练模型?
- 使用 YOLO v3 训练自己的图像集以开发自定义模型
- 特征金字塔和 RetinaNet 概述
YOLO 概述
我们在“第 5 章”,“神经网络架构和模型”中了解到,每个已发布的神经网络架构都通过学习其架构和功能,然后开发一个全新的分类器来改进前一架构,从而改进它的准确率和检测时间。 YOLO 参加了计算机视觉和模式识别会议(CVPR),在 2016 年中,Joseph Redmon,Santosh Divvala,Ross Girshick 和 Ali Farhadi 的论文 《只看一次:统一的实时对象检测》。 YOLO 是一个非常快速的神经网络,可以以每秒 45 帧(基本 YOLO)到每秒 155 帧(快速 YOLO)的惊人速度一次检测多种物体。 相比之下,大多数手机相机以每秒 30 帧的速度捕获视频,而高速相机以每秒 250 帧的速度捕获视频。 YOLO 的每秒帧数等于大约 6 到 22 ms 的检测时间。 将此与人类大脑检测大约 13 毫秒图像所需的时间进行比较-YOLO 以与人类相似的方式立即识别图像。 因此,它为机器提供了即时目标检测功能。
在进一步研究细节之前,我们将首先讨论交并比(IOU)的概念。
IOU 的概念
IOU 是基于预测边界框和地面真实边界框(手工标记)之间的重叠程度的对象检测评估指标。 让我们看一下 IOU 的以下派生:

下图说明了 IOU,显示了一辆大型货车的预测和地面实况边界框:

在这种情况下,IOU 值接近0.9,因为重叠区域非常大。 如果两个边界框不重叠,则 IOU 值为0,如果它们确实重叠 100%,则 IOU 值为1。
YOLO 如何如此快速地检测物体?
YOLO 的检测机制基于单个卷积神经网络(CNN),该预测同时预测对象的多个边界框以及在每个边界框中检测给定对象类别的可能性。 下图说明了这种方法:

前面的照片显示了三个主要步骤,从边界框的开发到使用非最大抑制和最终边界框。 具体步骤如下:
- YOLO 中的 CNN 使用整个图像中的特征来预测每个边界框。 因此,预测是全局的,而不是局部的。
- 整个图像分为
S x S个网格单元,每个网格单元预测B个边界框以及边界框包含对象的概率(P)。 因此,总共有S x S x B个边界框,每个边界框都有相应的概率。 - 每个边界框包含五个预测(
x,y,w,h和c),以下内容适用:
o(x, y)是边界框中心相对于网格单元坐标的坐标。o(w, h)是边框相对于图像尺寸的宽度和高度。o(c)是置信度预测,表示预测框和地面真实框之间的 IOU。
- 网格单元包含对象的概率定义为类乘以 IOU 值的概率。 这意味着,如果网格单元仅部分包含一个对象,则其概率将较低,而 IOU 值将保持较低。 这将对该网格单元的边界框产生两个影响:
- 边界框的形状将小于完全包含对象的网格单元的边界框的大小,因为网格单元只能看到对象的一部分并从中推断出其形状。 如果网格单元仅包含对象的一小部分,则它可能根本无法识别该对象。
- 边界框类置信度将很低,因为部分图像产生的 IOU 值将不符合地面真实性预测。
- 通常,每个网格单元只能包含一个类,但是使用锚框原理,可以将多个类分配给一个网格单元。 锚框是预定义的形状,表示要检测的类的形状。 例如,如果我们检测到三个类别(汽车,摩托车和人),那么我们可能可以通过两个锚框形状来解决-一个代表摩托车和人,另一个代表汽车。 可以通过查看先前图像中最右边的图像来确认。 我们可以通过使用 K 均值聚类等算法分析每个类的形状来确定锚框形状以形成训练 CSV 数据。
让我们以前面的图像为例。 在这里,我们有三类:car,motorcycle和human。 我们假设一个5 x 5的网格具有 2 个锚定框和 8 个维度(5 个边界框参数(x,y,w,h和c)和 3 类(c1,c2和c3))。 因此,输出向量大小为5 x 5 x 2 x 8。
我们为每个锚框重复两次Y = [x, y, w, h, c, c1, c2, c3, x, y, w, h, c, c1, c2, c3]参数。 下图说明了边界框坐标的计算:

图像的大小为448 x 448。此处,出于说明目的,显示了human和car两类的计算方法。 请注意,每个锚定框的大小为448/5 ~ 89。
YOLO v3 神经网络架构
TYOLO v3 由 Joseph Redmon 和 Ali Farhadi 于 2018 年在论文《YOLOv3:增量改进》中引入。 下图显示了 YOLO v3 神经网络架构。 该网络具有 24 个卷积层和 2 个全连接层。 它没有任何 softmax 层。
下图以图形方式说明了 YOLO v3 架构:

YOLO v3 的最重要的功能是它的检测机制,它是在三种不同的规模上完成的-在第 82、94 和 106 层:
- 该网络由第 1 层和第 74 层之间的 23 个卷积和残差块组成,其中输入图像大小从
608降低到19,深度通过交替的3 x 3和1 x 1个过滤器从3增长到1,024。 - 除 5 种情况下,将跨步值
2与3 x 3过滤器一起用于减小尺寸外,跨步通常保持为1。 - 剩余的块之后是交替的
1 x 1和1 x 1过滤器的预卷积块,直到在第 82 层进行第一次检测为止。已经使用了两次短路-一个在第 61 和 85 层之间,另一个在第 36 和 97 层之间 。
YOLO 与 Faster R-CNN 的比较
下表显示了 YOLO 和 Faster R-CNN 之间的相似之处:
| YOLO | R-CNN |
|---|---|
| 预测每个网格单元的边界框。 | 选择性搜索会为每个区域提议(实际上是一个网格单元)生成边界框。 |
| 使用边界框回归。 | 使用边界框回归。 |
下表显示了 YOLO 和 Faster R-CNN 之间的区别:
| YOLO | R-CNN |
|---|---|
| 分类和边界框回归同时发生。 | 选择性搜索会为每个区域提议生成一个边界框-这些是单独的事件。 |
| 每个图像 98 个边界框。 | 每个图像约有 2,000 个区域提议边界框。 |
| 每个网格单元 2 个锚点。 | 每个网格单元 9 个锚点。 |
| 它无法检测到小物体和彼此相邻的物体。 | 检测小物体和彼此相邻的物体。 |
| 快速算法。 | 更快的 R-CNN 比 YOLO 慢。 |
因此,总而言之,如果您需要生产级的准确率并且不太关心速度,请选择 Faster R-CNN。 但是,如果需要快速检测,请选择 YOLO。 像任何神经网络模型一样,您需要有足够的样本(大约 1,000 个)以不同的角度,不同的颜色和形状定向以做出良好的预测。 完成此操作后,根据我的个人经验,YOLO v3 会给出非常合理且快速的预测。
用于对象检测的 Darknet 简介
Darknet 是一个开放的神经网络框架,由 C 编写,并由 YOLO 的第一作者 Joseph Redmon 管理。 有关 Darknet 的详细信息,请访问 pjreddie.com。 在本节中,我们将讨论用于对象检测的 Darknet 和 Tiny Darknet。
使用 Darknet 检测对象
在本节中,我们将从官方 Darknet 站点安装 Darknet,并将其用于对象检测。 请按照以下步骤在您的 PC 上安装 Darknet 并进行推断:
- 在终端中应输入以下五行。 在每个命令行之后点击
Enter。 这些步骤将从 GitHub 克隆 Darknet,这将在您的 PC 中创建 Darknet 目录,并获取 YOLO v3 权重,然后检测图像中的对象:
git clone https://github.com/pjreddie/darknet.git
cd darknet
make
wget https://pjreddie.com/media/files/yolov3.weights
./darknet detect cfg/yolov3.cfg yolov3.weights data/carhumanbike.png
- 执行
git clone命令后,您将在终端中获得以下输出:
Cloning into 'darknet'...
remote: Enumerating objects: 5901, done.
remote: Total 5901 (delta 0), reused 0 (delta 0), pack-reused 5901
Receiving objects: 100% (5901/5901), 6.16 MiB | 8.03 MiB/s, done.
Resolving deltas: 100% (3916/3916), done.
- 输入
wget yolov3权重后,将在终端中获得以下输出:
Resolving pjreddie.com (pjreddie.com)... 128.208.4.108
Connecting to pjreddie.com (pjreddie.com)|128.208.4.108|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 248007048 (237M) [application/octet-stream]
Saving to: 'yolov3.weights'
yolov3.weights 100%[======================================================>] 236.52M 8.16MB/s in 29s
… (8.13 MB/s) - 'yolov3.weights' saved [248007048/248007048]
- 然后,一旦输入
darknet$ ./darknet detect cfg/yolov3.cfg yolov3.weight data/carhumanbike.png,您将在终端中获得以下输出:
layer filters size input output
0 conv 32 3 x 3 / 1 608 x 608 x 3 -> 608 x 608 x 32 0.639 BFLOPs --> image size 608x608
1 conv 64 3 x 3 / 2 608 x 608 x 32 -> 304 x 304 x 64 3.407 BFLOPs
2 conv 32 1 x 1 / 1 304 x 304 x 64 -> 304 x 304 x 32 0.379 BFLOPs
3 conv 64 3 x 3 / 1 304 x 304 x 32 -> 304 x 304 x 64 3.407 BFLOPs
4 res 1 304 x 304 x 64 -> 304 x 304 x 64 --> this implies residual block connecting layer 1 to 4
5 conv 128 3 x 3 / 2 304 x 304 x 64 -> 152 x 152 x 128 3.407 BFLOPs
6 conv 64 1 x 1 / 1 152 x 152 x 128 -> 152 x 152 x 64 0.379 BFLOPs
7 conv 128 3 x 3 / 1 152 x 152 x 64 -> 152 x 152 x 128 3.407 BFLOPs
8 res 5 152 x 152 x 128 -> 152 x 152 x 128 --> this implies residual block connecting layer 5 to 8
...
...
...
83 route 79 --> this implies layer 83 is connected to 79, layer 80-82 are prediction layers
84 conv 256 1 x 1 / 1 19 x 19 x 512 -> 19 x 19 x 256 0.095 BFLOPs
85 upsample 2x 19 x 19 x 256 -> 38 x 38 x 256 --> this implies image size increased by 2X
86 route 85 61 --> this implies shortcut between layer 61 and 85
87 conv 256 1 x 1 / 1 38 x 38 x 768 -> 38 x 38 x 256 0.568 BFLOPs
88 conv 512 3 x 3 / 1 38 x 38 x 256 -> 38 x 38 x 512 3.407 BFLOPs
89 conv 256 1 x 1 / 1 38 x 38 x 512 -> 38 x 38 x 256 0.379 BFLOPs
90 conv 512 3 x 3 / 1 38 x 38 x 256 -> 38 x 38 x 512 3.407 BFLOPs
91 conv 256 1 x 1 / 1 38 x 38 x 512 -> 38 x 38 x 256 0.379 BFLOPs
92 conv 512 3 x 3 / 1 38 x 38 x 256 -> 38 x 38 x 512 3.407 BFLOPs
93 conv 255 1 x 1 / 1 38 x 38 x 512 -> 38 x 38 x 255 0.377 BFLOPs
94 yolo --> this implies prediction at layer 94
95 route 91 --> this implies layer 95 is connected to 91, layer 92-94 are prediction layers
96 conv 128 1 x 1 / 1 38 x 38 x 256 -> 38 x 38 x 128 0.095 BFLOPs
97 upsample 2x 38 x 38 x 128 -> 76 x 76 x 128 à this implies image size increased by 2X
98 route 97 36\. --> this implies shortcut between layer 36 and 97
99 conv 128 1 x 1 / 1 76 x 76 x 384 -> 76 x 76 x 128 0.568 BFLOPs
100 conv 256 3 x 3 / 1 76 x 76 x 128 -> 76 x 76 x 256 3.407 BFLOPs
101 conv 128 1 x 1 / 1 76 x 76 x 256 -> 76 x 76 x 128 0.379 BFLOPs
102 conv 256 3 x 3 / 1 76 x 76 x 128 -> 76 x 76 x 256 3.407 BFLOPs
103 conv 128 1 x 1 / 1 76 x 76 x 256 -> 76 x 76 x 128 0.379 BFLOPs
104 conv 256 3 x 3 / 1 76 x 76 x 128 -> 76 x 76 x 256 3.407 BFLOPs
105 conv 255 1 x 1 / 1 76 x 76 x 256 -> 76 x 76 x 255 0.754 BFLOPs
106 yolo --> this implies prediction at layer 106
执行代码后,您将看到完整的模型。 为简便起见,我们仅在前面的代码段中显示了模型的开头。
上面的输出描述了 YOLO v3 的详细神经网络构建块。 花一些时间来了解所有 106 个卷积层及其目的。 上一节提供了所有唯一代码行的说明。 前面的代码导致图像的以下输出:
Loading weights from yolov3.weights...Done!
data/carhumanbike.png: Predicted in 16.140244 seconds.
car: 81%
truck: 63%
motorbike: 77%
car: 58%
person: 100%
person: 100%
person: 99%
person: 94%
预测输出如下所示:

YOLO v3 模型在预测方面做得很好。 即使是很远的汽车也能正确检测到。 前面的汽车分为汽车(在图中看不到标签)和卡车。 所有四个人(两个步行摩托车和两个骑摩托车)被检测到。 在两辆摩托车中,检测到一辆摩托车。 请注意,尽管汽车的颜色是黑色,但模型不会错误地将阴影检测为汽车。
使用 Tiny Darknet 检测对象
Tiny Darknet 是一个小型且快速的网络,可以非常快速地检测到对象。 它的大小为 4 MB,而 Darknet 的大小为 28 MB。 您可以在这个页面中找到其实现的详细信息。
完成上述步骤后,Darknet 应该已经安装在您的 PC 上。 在终端中执行以下命令:
$ cd darknet
darknet$ wget https://pjreddie.com/media/files/tiny.weights
前面的命令会将 Darknet 权重安装在darknet文件夹中。 您还应该在cfg文件夹中包含tiny.cfg。 然后,执行以下命令以检测对象。 在这里,我们将使用与参考 Darknet 模型相同的图像进行检测。 我们只是将权重和cfg文件从 Darknet 更改为 Tiny Darknet:
darknet$ ./darknet detect cfg/tiny.cfg tiny.weights data /carhumanbike.png
与 Darknet 一样,前面的命令将显示 Tiny Darknet 模型的所有 21 层(Darknet 则为 106 层),如下所示:
layer filters size input output
0 conv 16 3 x 3 / 1 224 x 224 x 3 -> 224 x 224 x 16 0.043 BFLOPs
1 max 2 x 2 / 2 224 x 224 x 16 -> 112 x 112 x 16
2 conv 32 3 x 3 / 1 112 x 112 x 16 -> 112 x 112 x 32 0.116 BFLOPs
3 max 2 x 2 / 2 112 x 112 x 32 -> 56 x 56 x 32
4 conv 16 1 x 1 / 1 56 x 56 x 32 -> 56 x 56 x 16 0.003 BFLOPs
5 conv 128 3 x 3 / 1 56 x 56 x 16 -> 56 x 56 x 128 0.116 BFLOPs
6 conv 16 1 x 1 / 1 56 x 56 x 128 -> 56 x 56 x 16 0.013 BFLOPs
7 conv 128 3 x 3 / 1 56 x 56 x 16 -> 56 x 56 x 128 0.116 BFLOPs
8 max 2 x 2 / 2 56 x 56 x 128 -> 28 x 28 x 128
9 conv 32 1 x 1 / 1 28 x 28 x 128 -> 28 x 28 x 32 0.006 BFLOPs
10 conv 256 3 x 3 / 1 28 x 28 x 32 -> 28 x 28 x 256 0.116 BFLOPs
11 conv 32 1 x 1 / 1 28 x 28 x 256 -> 28 x 28 x 32 0.013 BFLOPs
12 conv 256 3 x 3 / 1 28 x 28 x 32 -> 28 x 28 x 256 0.116 BFLOPs
13 max 2 x 2 / 2 28 x 28 x 256 -> 14 x 14 x 256
14 conv 64 1 x 1 / 1 14 x 14 x 256 -> 14 x 14 x 64 0.006 BFLOPs
15 conv 512 3 x 3 / 1 14 x 14 x 64 -> 14 x 14 x 512 0.116 BFLOPs
16 conv 64 1 x 1 / 1 14 x 14 x 512 -> 14 x 14 x 64 0.013 BFLOPs
17 conv 512 3 x 3 / 1 14 x 14 x 64 -> 14 x 14 x 512 0.116 BFLOPs
18 conv 128 1 x 1 / 1 14 x 14 x 512 -> 14 x 14 x 128 0.026 BFLOPs
19 conv 1000 1 x 1 / 1 14 x 14 x 128 -> 14 x 14 x1000 0.050 BFLOPs
20 avg 14 x 14 x1000 -> 1000
21 softmax 1000
Loading weights from tiny.weights...Done!
data/carhumanbike.png: Predicted in 0.125068 seconds.
但是,该模型无法检测图像中的对象。 我将检测更改为分类,如下所示:
darknet$ ./darknet classify cfg/tiny.cfg tiny.weights data/dog.jpg
前面的命令生成的结果类似于 Tiny YOLO 链接中发布的结果(wget https://pjreddie.com/media/files/tiny.weights):
Loading weights from tiny.weights...Done!
data/dog.jpg: Predicted in 0.130953 seconds.
14.51%: malamute
6.09%: Newfoundland
5.59%: dogsled
4.55%: standard schnauzer
4.05%: Eskimo dog
但是,同一图像在通过对象检测时不会返回边界框。
接下来,我们将讨论使用 Darknet 对视频进行实时预测。
使用 Darknet 的实时预测
涉及 Darknet 的预测都可以使用终端中的命令行来完成。 有关更多详细信息,请参阅这里。
到目前为止,我们已经在图像上使用 Darknet 进行了推断。 在以下步骤中,我们将学习如何在视频文件上使用 Darknet 进行推理:
-
通过在终端中键入
cd darknet转到darknet目录(已在前面的步骤中安装)。 -
确保已安装 OpenCV。 即使您已安装 OpenCV,它仍可能会创建一个错误标志。 使用
sudo apt-get install libopencv-dev命令将 OpenCV 安装在darknet目录中。 -
在
darknet目录中,有一个名为Makefile的文件。 打开该文件,设置OpenCV = 1并保存。 -
通过转到这里从终端下载权重。
-
此时,由于更改了
Makefile,因此必须重新编译。 您可以通过在终端中键入make来执行此操作。 -
然后,通过在终端中键入以下命令来下载视频文件:
./darknet detector demo cfg/coco.data cfg/yolov3.cfg yolov3.weights data/road_video.mp4
- 如前所述,这里将编译具有 106 层的 YOLO 模型,并播放视频。 您会注意到视频播放非常慢。 可以通过以下两个步骤解决此问题。 它们应该一一执行,因为每个步骤都会产生影响。
- 再次打开
Makefile。 将GPU更改为1,保存Makefile,然后重复步骤 4 至 6。此时,我注意到步骤 6 提供了以下 CUDAout of memory错误:
…….
57 conv 512 3 x 3 / 1 38 x 38 x 256 -> 38 x 38 x 512 3.407 BFLOPs
58 res 55 38 x 38 x 512 -> 38 x 38 x 512
59 conv 256 1 x 1 / 1 38 x 38 x 512 -> 38 x 38 x 256 0.379 BFLOPs
60 CUDA Error: out of memory
darknet: ./src/cuda.c:36: check_error: Assertion `0' failed.
Aborted (core dumped)
通过两种机制解决了该错误:
- 更改图像尺寸。
- 将 NVIDIA CUDA 版本从 9.0 更改为 10.1。 请访问 NVIDIA 网站以更改 NVIDIA 版本。
首先,尝试更改图像尺寸。 如果这不起作用,则检查 CUDA 版本并更新(如果您仍在使用 9.0 版)。
- 在
darknet目录中,在cfg目录下有一个名为yolov3.cfg的文件。 打开该文件,并将宽度和高度从608更改为416或288。 我发现当将该值设置为304时,它仍然会失败。 保存文件并重复步骤 5 和 6。
这是将图像尺寸设置为304时将得到的错误代码:
.....
80 conv 1024 3 x 3 / 1 10 x 10 x 512 -> 10 x 10 x1024 0.944 BFLOPs
81 conv 255 1 x 1 / 1 10 x 10 x1024 -> 10 x 10 x 255 0.052 BFLOPs
82 yolo
83 route 79
84 conv 256 1 x 1 / 1 10 x 10 x 512 -> 10 x 10 x 256 0.026 BFLOPs
85 upsample 2x 10 x 10 x 256 -> 20 x 20 x 25
86 route 85 61
87 Layer before convolutional layer must output image.: File exists
darknet: ./src/utils.c:256: error: Assertion `0' failed.
Aborted (core dumped)
下图显示了带有交通标志标签和汽车检测的视频文件的屏幕截图:

请注意,所有汽车均被正确检测,甚至主交通灯和侧面交通灯也被检测到。
我们之前讨论了默认大小为608的 YOLO v3 层。 以下是相同的输出,其大小更改为416,以便正确显示视频文件:
layer filters size input output
0 conv 32 3 x 3 / 1 416 x 416 x 3 -> 416 x 416 x 32 0.299 BFLOPs
1 conv 64 3 x 3 / 2 416 x 416 x 32 -> 208 x 208 x 64 1.595 BFLOPs
2 conv 32 1 x 1 / 1 208 x 208 x 64 -> 208 x 208 x 32 0.177 BFLOPs
3 conv 64 3 x 3 / 1 208 x 208 x 32 -> 208 x 208 x 64 1.595 BFLOPs
4 res 1 208 x 208 x 64 -> 208 x 208 x 64
5 conv 128 3 x 3 / 2 208 x 208 x 64 -> 104 x 104 x 128 1.595 BFLOPs
6 conv 64 1 x 1 / 1 104 x 104 x 128 -> 104 x 104 x 64 0.177 BFLOPs
7 conv 128 3 x 3 / 1 104 x 104 x 64 -> 104 x 104 x 128 1.595 BFLOPs
8 res 5 104 x 104 x 128 -> 104 x 104 x 128
...
...
...
94 yolo
95 route 91
96 conv 128 1 x 1 / 1 26 x 26 x 256 -> 26 x 26 x 128 0.044 BFLOPs
97 upsample 2x 26 x 26 x 128 -> 52 x 52 x 128
98 route 97 36
99 conv 128 1 x 1 / 1 52 x 52 x 384 -> 52 x 52 x 128 0.266 BFLOP
100 conv 256 3 x 3 / 1 52 x 52 x 128 -> 52 x 52 x 256 1.595 BFLOPs
101 conv 128 1 x 1 / 1 52 x 52 x 256 -> 52 x 52 x 128 0.177 BFLOPs
102 conv 256 3 x 3 / 1 52 x 52 x 128 -> 52 x 52 x 256 1.595 BFLOPs
103 conv 128 1 x 1 / 1 52 x 52 x 256 -> 52 x 52 x 128 0.177 BFLOPs
104 conv 256 3 x 3 / 1 52 x 52 x 128 -> 52 x 52 x 256 1.595 BFLOPs
105 conv 255 1 x 1 / 1 52 x 52 x 256 -> 52 x 52 x 255 0.353 BFLOPs
106 yolo
Loading weights from yolov3.weights...Done!
video file: data/road_video.mp4
执行前面的代码后,您将看到完整的模型。 为简便起见,我们仅在前面的代码段中显示了模型的开头。
下表总结了两种不同图像尺寸的输出:
| 层 | 608 尺寸 | 416 尺寸 |
|---|---|---|
| 82 | 19 x 19 |
13 x 13 |
| 94 | 38 x 38 |
26 x 26 |
| 106 | 76 x 76 |
52 x 52 |
注意,原始图像尺寸和第 82 层输出尺寸之间的比率保持为 32。 到目前为止,我们已经比较了使用 Darknet 和 Tiny Darknet 的推论。 现在,我们将比较不同的 YOLO 模型。
YOLO 与 YOLO v2 与 YOLO v3
下表显示了三种 YOLO 版本的比较:
| YOLO | YOLO v2 | YOLO v3 | |
|---|---|---|---|
| 输入尺寸 | 224 x 224 |
448 x 448 |
|
| 构架 | Darknet 在 ImageNet-1,000 上接受了训练。 | Darknet-19,19 个卷积层和 5 个最大池化层。 | Darknet-53,53 个卷积层。 为了进行检测,增加了 53 层,总共有 106 层。 |
| 小尺寸检测 | 它找不到小图像。 | 在检测小图像方面比 YOLO 更好。 | 在小图像检测方面优于 YOLO v2。 |
| 使用锚框。 | 使用残差块。 |
下图比较了 YOLO v2 和 YOLO v3 的架构:

基本卷积层相似,但是 YOLO v3 在三个独立的层上执行检测:82、94 和 106。
您应该从 YOLO v3 中获取的最关键的项目是在三个不同的层级和三个不同的级别进行对象检测:82(最大),94(中级)和 106(最小)。
什么时候训练模型?
在迁移学习中,通过训练大量数据来开发训练模型。 因此,如果您的类属于以下类之一,则无需为这些类训练模型。 为 YOLO v3 训练的 80 个类如下:
Person, bicycle, car, motorbike, airplane, bus, train, truck, boat, traffic light, fire hydrant, stop sign, parking meter, bench, bird, cat, dog, horse, sheep, cow, elephant, bear, zebra, giraffe, backpack, umbrella, handbag, tie, suitcase, frisbee, skis, snowboard, sports ball, kite, baseball bat, baseball glove, skateboard, surfboard. tennis racket, bottle, wine glass, cup, fork, knife, spoon, bowl, banana, apple, sandwich, orange, broccoli, carrot, hot dog, pizza, donut, cake, chair, sofa, potted plant, bed, dining table, toilet, tv monitor, laptop, mouse, remote, keyboard, cell phone, microwave, oven, toaster, sink, refrigerator, book, clock, vase, scissors, teddy bear, hair drier, toothbrush
因此,如果您要检测食物的类型,YOLO v3 会很好地检测banana,apple,sandwich,orange,broccoli,carrot,hot dog, pizza,donut和cake,但无法检测到hamburger。
同样,在 PASCAL VOC 数据集上训练的 YOLO v3 将能够检测所有 20 个类别,即airplane,bicycle,bird,boat,bottle,bus和car ,cat,chair,cow,dining table,dog,horse,motorbike,person,potted plant,sheep,sofa,train和 tv monitor,但它无法检测到新类别hot dog。
因此,这就是训练您自己的图像集的地方,下一节将对此进行介绍。
使用 YOLO v3 训练自己的图像集来开发自定义模型
在本节中,我们将学习如何使用 YOLO v3 训练您自己的自定义检测器。 训练过程涉及许多不同的步骤。 为了清楚起见,以下流程图中显示了每个步骤的输入和输出。 YOLO 的《YOLOv3:Incremental Improvement》由 Redmon,Joseph,Farhadi 和 Ali 于 2018 年在 arXiv 上发布,其中包含许多训练步骤。这些训练步骤也包含在 VOC 的“训练 YOLO”部分。
下图显示了如何使用 YOLO v3 训练 VOC 数据集。 在我们的案例中,我们将使用我们自己的自定义家具数据,该数据用于在“第 6 章”,“使用迁移学习的视觉搜索”中使用 Keras 对图像进行分类:

在此描述第 1 至 11 部分的详细说明。
准备图像
请按照以下步骤准备图像:
-
研究您要检测的类数-在此示例中,我们将考虑在第 6 章“使用迁移学习的视觉搜索”中讨论的
bed,chair和sofa类。 -
确保每个类的图像数量相同。
-
确保您的类名称中没有空格; 例如,使用
caesar_salad代替caesar salad。 -
每个类至少收集 100 张图像以开始初始训练(因此,请完成步骤 1 至 10 以开发模型),然后随着图像数量的增加而增加数量。 理想情况下,1,000 张图像是训练的不错数目。
-
将所有图像批量调整为
416 x 416— 您可以在 macOS 预览窗格中选择选项,然后选择多个图像,然后批量调整大小,或者可以使用 Ubuntu 中的 ImageMagick 等程序在终端中批量调整大小。 之所以需要执行此步骤,是因为 YOLO v3 希望图像的尺寸为416 x 416,因此会自行调整图像的尺寸,但这可能会导致该图像的边界框出现不同的外观,从而在某些情况下无法检测到。
生成标注文件
此步骤涉及为数据集中每个图像中的每个对象创建边界框坐标。 此边界框坐标通常由四个参数表示:(x, y)用于确定初始位置以及宽度和高度。 边界框可以表示为.xml或.txt形式。 该坐标文件也称为标注文件。 请按照以下步骤完成本节:
- 许多图像标注软件应用都用于标记图像。 在面部关键点检测期间,我们已经在“第 3 章”,“使用 OpenCV 和 CNN 进行面部检测”中介绍了 VGG 图像标注器。 在“第 11 章”,“具有 CPU/GPU 优化功能的边缘设备深度学习”中,我们将介绍用于自动图像标注的 CVAT 工具。 在本章中,我们将介绍一个称为
labelImg的标注工具。 - 从这里下载
pypi的labelImg标注软件。 您可以按照此处的说明为操作系统安装labelImg-如果有任何问题,一种简单的安装方法是在终端中键入pip3 install lableImg。 然后,要运行它,只需在终端中键入labelImg。 - 在
labelImg中,在“打开目录”框中单击图像目录。 选择每个图像并通过单击Create/RectBox创建一个包围框,然后为包围框添加一个类名,例如bed,chair或sofa。 保存标注,然后单击右箭头转到下一张图像。 - 如果图片中图像中有多个类别或同一类别的多个位置,请在每个类别周围绘制矩形。 多个类别的示例是同一图像中的汽车和行人。 同一类别内多个位置的示例是同一图像中不同位置的不同汽车。 因此,如果图像由多把椅子和一张沙发组成,则在每把椅子周围绘制矩形,并在类名称中为每张沙发分别键入
chair,在其周围绘制一个矩形并键入sofa。 如果图像仅由沙发组成,则在沙发周围绘制一个矩形,并输入sofa作为类名。 下图说明了这一点:

此图显示了如何标记属于同一类的多个图像。
将.xml文件转换为.txt文件
YOLO v3 需要将标注文件另存为.txt文件而不是.xml文件。 本节介绍如何转换和排列.txt文件以输入模型。 有许多工具可用于此类转换-我们将在此处提及两个工具:
RectLabel:具有内置的转换器,可将.xml文件转换为.txt文件。- 命令行
xmltotxt工具:您可以在 GitHub 页面上找到此工具。
该过程的输出将是一个包含.jpg,.xml和.txt文件的目录。 每个图像.jpg文件将具有一个对应的.xml和.txt文件。 您可以从目录中删除.xml文件,因为我们将不再需要这些文件。
创建合并的train.txt和test.txt文件
顾名思义,此步骤涉及一个表示所有图像的.txt文件。 为此,我们将运行一个简单的 Python 文件(每个文件用于训练和测试图像)以创建combinedtrain.txt和combinedtest.txt文件。 转到这里获取 Python 文件。
以下屏幕快照显示了 Python 代码的示例输出:

每个文本文件由几行组成-每行包括图像文件的路径,如前所示。
创建类名列表文件
该文件包含所有类的列表。 因此,在我们的例子中,它是一个扩展名为.names的简单文本文件,如下所示:
bed
chair
sofa
创建一个 YOLO .data文件
这些步骤涉及train和valid文件夹的路径。 开始之前,请将合并的train,合并的test和.names文件复制到darknet目录。 以下代码块显示了典型的.data文件(在本示例中为furniture.data)的外观:
classes= 3
train = /home/krishkar/darknet/furniture_train.txt
valid = /home/krishkar/darknet/furniture_test.txt
names = /home/krishkar/darknet/furniture_label.names
backup = backup
这里,我们有三个类(bed,chair和sofa),因此classes的值设置为 3。train,valid和names文件夹显示了合并训练,合并测试和标签.names文件。 将此文件保存在cfg目录中。
调整 YOLO 配置文件
完成这些步骤后,文件排列部分完成,我们现在将致力于优化 YOLO 配置文件中的参数。 为此,请在 Darknet cfg目录下打开YOLO-VOC.cfg并进行以下更改。 生成的代码也可以从这里下载:
请注意,在以下部分中,我们将描述各种行号和要更改的值–这些行号对应于YOLO-VOC.cfg文件。
-
第 6 行-批量大小。 将此设置为
64。 这意味着在每个训练步骤中将使用 64 张图像来更新 CNN 参数。 -
第 7 行-
subdivisions。 这将按批量大小/细分划分批量,然后将其馈送到 GPU 中进行处理。 将对细分的数量重复该过程,直到完成批量大小(64)并开始新的批量为止。 因此,如果subdivisions设置为1,则所有 64 张图像都将发送到 GPU,以在给定批量中同时进行处理。 如果批量大小设置为8,则将 8 张图像发送到 GPU 进行处理,并在开始下一个批量之前重复此过程 8 次。 将该值设置为1可能会导致 GPU 出现故障,但可能会提高检测的准确率。 对于初始运行,将值设置为8。 -
第 11 行-
momentum。 这用于最小化批量之间的较大权重变化,因为在任何时间点都只处理少量图像(在此示例中为 64)。0.9的默认值是 OK。 -
第 12 行-
decay。 通过控制权重值以获取较大的值,可以将过拟合程度降至最低。0.005的默认值是 OK。 -
第 18 行-
learning_rate。 这表明了解当前批量的速度。 下图显示了学习率与批量的关系,下面将对其进行说明。0.001的默认值是一个合理的开始,如果值是不是数字(NaN),则可以减小默认值:

- 第 19 行-
burn_in。这表示学习率上升的初始时间。 将其设置为1000,如果减小max_batches,则将其降低。
请注意,如果您按照前面的步骤设置代码,并且注意到当周期在200至300左右时,您没有学到太多,原因可能是您当时的学习率很低。 您将开始看到学习率逐渐超过1000周期。
-
第 20 行-
max_batches。 最大批量数。 将其设置为 2,000 乘以类数。 对于3类,6000的值是合理的。 请注意,默认值为500200,该值非常高,如果保持不变,则训练将持续数天。 -
第 22 行-
steps。 这是将学习率乘以第 23 行中的标度之后的步骤。将其设置为max_batches的 80% 和 90%。 因此,如果批量大小为6000,则将值设置为4800和5400。 -
第 611、695、779 行。将
classes值从其默认值[20或80)更改为您的类值(在此示例中为3)。 -
605、689、773 行。这些是 YOLO 预测之前的最后卷积层。 将
filters值从其默认值255设置为(5+ # of classes)x3。 因此,对于 3 个类别,过滤器值应为 24。 -
线 610、694、778。这是锚点,是具有高宽比的预设边界框,如此处所示。 锚点的大小由(宽度,高度)表示,它们的值不需要更改,但是了解其上下文很重要。
(10, 13),(16, 30),(32, 23),(30, 61),(62, 45),(59, 119),(116, 90),(156, 198),(373 (326)。 总共有九个锚点,范围从10的高度到373的高度。 这表示从最小到最大的图像检测。 对于此练习,我们不需要更改锚点。 -
609、693、777 行。这些是蒙版。 他们指定我们需要选择哪些锚框进行训练。 如果较低级别的值为
0, 1, 2,并且您在区域94和106的输出中继续观察到NaN,请考虑增加该值。 选择该值的最佳方法是查看训练图像边界框从最小到最大图像的比例,了解它们的下落位置,并选择适当的蒙版来表示。 在我们的测试案例中,最小尺寸的边界框从62, 45, 40开始,因此我们选择5, 6, 7作为最小值。 下表显示了蒙版的默认值和调整后的值:
| 默认值 | 调整值 |
|---|---|
6, 7, 8 |
7, 8, 9 |
3, 4, 5 |
6, 7, 8 |
0, 1, 2 |
6, 7, 8 |
9的最大值表示bed,并且6的最小值表示chair。
请注意,如果图像中的边界框不同,则可以调整mask值以获得所需的结果。 因此,从默认值开始并进行调整以避免出现NaN结果。
为训练启用 GPU
在您的darknet目录中打开Makefile并按如下所示设置参数:
GPU = 1
CUDNN = 1
开始训练
在终端中一一执行以下命令:
-
下载预训练的
darknet53模型权重以加快训练速度。 在终端中运行这个页面中找到的命令。 -
完成预训练权重的下载后,在终端中执行以下命令:
./darknet detector train cfg/furniture.data cfg/yolov3-furniture.cfg darknet53.conv.74 -gpus 0
训练将开始并将继续,直到使用 82、94 和 106 层写入的值创建最大批量为止。 在下面的代码中,我们将显示两个输出-一个用于一切正常进行时的输出,另一个用于当训练未能正确进行时的输出:
Correct training
Region 82 Avg IOU: 0.063095, Class: 0.722422, Obj: 0.048252, No Obj: 0.006528, .5R: 0.000000, .75R: 0.000000, count: 1
Region 94 Avg IOU: 0.368487, Class: 0.326743, Obj: 0.005098, No Obj: 0.003003, .5R: 0.000000, .75R: 0.000000, count: 1
Region 106 Avg IOU: 0.144510, Class: 0.583078, Obj: 0.001186, No Obj: 0.001228, .5R: 0.000000, .75R: 0.000000, count: 1
298: 9.153068, 7.480968 avg, 0.000008 rate, 51.744666 seconds, 298 images
Incorrect training
Region 82 Avg IOU: 0.061959, Class: 0.404846, Obj: 0.520931, No Obj: 0.485723, .5R: 0.000000, .75R: 0.000000, count: 1
Region 94 Avg IOU: -nan, Class: -nan, Obj: -nan, No Obj: 0.525058, .5R: -nan, .75R: -nan, count: 0
Region 106 Avg IOU: -nan, Class: -nan, Obj: -nan, No Obj: 0.419326, .5R: -nan, .75R: -nan, count: 0
在前面的代码中,IOU描述联合之上的交集,Class表示对象分类-需要接近1的Class值。 Obj是检测到对象的概率,其值应接近1。 NoObj的值应接近0\. 0.5。 R是检测到的阳性样本除以图像中实际样本的比率。
到目前为止,我们已经学习了如何使用 Darknet 来对预训练的 YOLO 模型进行推理,并为自定义图像训练了我们自己的 YOLO 模型。 在下一部分中,我们将概述另一个称为 RetinaNet 的神经网络模型。
特征金字塔网络和 RetinaNet 概述
我们从“第 5 章”,“神经网络架构和模型”了解到,CNN 的每一层本身就是一个特征向量。 与此相关的有两个关键且相互依赖的参数,如下所示:
- 当我们通过各种卷积层将图像的 CNN 提升到全连接层时,我们会确定更多的特征(表面上很强),从简单的边缘到对象的特征再到完整的对象。 但是,这样做时,图像的分辨率会随着特征宽度和高度的减小而深度的增加而降低。
- 不同比例的对象(小到大)受此分辨率和尺寸的影响。 如下图所示,较小的对象在最高层将更难检测,因为其特征将变得非常模糊,以至于 CNN 将无法很好地检测到它:

如前所述,由于小物体的分辨率问题,很难同时检测不同比例的多幅图像。 因此,如上图所示,我们以金字塔形式而不是图像堆叠特征,顶部的尺寸较小,底部的尺寸较大。 这称为特征金字塔。
特征金字塔网络(FPN)由多个特征金字塔组成,这些特征金字塔由每个 CNN 层之间的较高维度和较低分辨率组成。 FPN 中使用此金字塔特征来检测不同比例的物体。 FPN 使用最后一个全连接层特征,该特征将基于其最近的邻居应用 2x 的上采样,然后将其添加到其先前的特征向量中,然后将3 x 3卷积应用于合并的层。 这个过程一直重复到第二个卷积层。 结果是在所有级别上都具有丰富的语义,从而导致不同级别的对象检测。
RetinaNet 由林宗义,Priya Goyal,Ross Girshick,Kakaiming He 在《密集对象检测的焦点损失》中引入, 和皮奥特·多拉尔(PiotrDollár)。 RetinaNet 是一个密集的一级网络,由一个基本的 ResNet 型网络和两个特定于任务的子网组成。 基本网络使用 FPN 为不同的图像比例计算卷积特征映射。 第一个子网执行对象分类,第二个子网执行卷积包围盒回归。
大多数 CNN 对象检测器可分为两类-一级和二级网络。 在诸如 YOLO 和 SSD 的单阶段网络中,单个阶段负责分类和检测。 在诸如 R-CNN 的两阶段网络中,第一阶段生成对象位置,第二阶段评估其分类。 一级网络以其速度而闻名,而二级网络以其准确率而闻名。
已知由于只有几个候选位置实际包含对象,因此一级网络遭受类不平衡的困扰。 该类不平衡使得训练在图像的大部分部分中无效。 RetinaNet 通过引入焦距损失(FL)来解决类别不平衡问题,该焦距微调交叉熵(CE)损失来专注于困难的检测问题。 损失 CE 的微调是通过对损失 CE 应用检测概率(pt)的调制因子(g)来完成的,如下所示:

RetinaNet 通过使用 FL 概念与一级网络的速度相匹配,而与二级网络的精度相匹配。
可以通过以下命令在终端中下载 RetinaNet 的 Keras 版本:
pip install keras-retinanet
在精度和速度方面,YOLO v3 保持平均精度超过 50,并且比 RetinaNet 更快。
总结
在本章中,我们了解了 YOLO 对象检测方法的基本组成部分,并了解了与其他对象检测方法相比,YOLO 如何能够如此快速,准确地检测到对象。 我们了解了 YOLO 的不同演变(原始版本的 YOLO,YOLO v2 和 YOLO v3)及其差异。 我们使用 YOLO 来检测图像和视频文件中的物体,例如交通标志。
我们学习了如何调试 YOLO v3,以便它可以生成正确的输出而不会崩溃。 我们了解了如何使用预训练的 YOLO 进行推断,并了解了使用我们的自定义图像开发新的 YOLO 模型的详细过程,以及如何调整 CNN 参数以生成正确的结果。 本章还向您介绍了 RetinaNet,以及它如何使用特征金字塔的概念来检测不同比例的对象。
在下一章中,我们将学习有关使用语义分割和图像修复的图像内容填充。
八、语义分割与神经样式迁移
深度神经网络的应用不仅限于在图像中找到对象(我们在前面的章节中已经学习过),还可以用于将图像分割成空间区域,从而生成人造图像并从一个图像中迁移样式。 形象给另一个。
在本章中,我们将使用 TensorFlow Colab 执行所有这些任务。 语义分割可预测图像的每个像素是否属于某个类别。 这是用于图像叠加的有用技术。 您将了解 TensorFlow DeepLab,以便可以对图像执行语义分割。 深度卷积生成对抗网络(DCGAN)是强大的工具,可用于生成人造图像,例如人脸和手写数字。 它们也可以用于图像修复。 我们还将讨论如何使用 CNN 将样式从一个图像迁移到另一个图像。
在本章中,我们将介绍以下主题:
- 用于语义分割的 TensorFlow DeepLab 概述
- 使用 DCGAN 生成人工图像
- 使用 OpenCV 修复图像
- 了解神经样式迁移
用于语义分割的 TensorFlow DeepLab 概述
语义分割是在像素级别理解和分类图像内容的任务。 与对象检测不同,在对象检测中,在多个对象类上绘制了一个矩形边界框(类似于我们从 YOLOV3 中学到的知识),语义分割可学习整个图像,并将封闭对象的类分配给图像中的相应像素。 因此,语义分段可以比对象检测更强大。 语义分段的基本架构基于编码器-解码器网络,其中编码器创建一个高维特征向量并在不同级别上对其进行聚合,而解码器在神经网络的不同级别上创建一个语义分段掩码。 编码器使用传统的 CNN,而解码器使用解池,解卷积和上采样。 DeepLab 是 Google 引入的一种特殊类型的语义分段,它使用空洞卷积,空间金字塔池而不是常规的最大池以及编码器-解码器网络。 DeepLabV3+ 是由 Liang-Chieh Chen,Yukun Zhu,George Papandreou,Florian Schro 和 Hartwig Adam 在他们的论文《用于语义图像分割的实用 Atrous 可分离卷积的编码器-解码器》中提出的。
DeepLab 于 2015 年开始使用 V1,并于 2019 年迅速移至 V3+。下表列出了不同 DeepLab 版本的比较:
| DeepLab V1 | DeepLab V2 | DeepLab V3 | DeepLab V3+ | |
|---|---|---|---|---|
| 论文 | 《具有深度卷积网络和全连接 CRF 的语义图像分割》,2015 | 《DeepLab:使用深度卷积网络,空洞卷积和全连接 CRF 进行语义图像分割》,2017 | 《重新思考原子卷积以进行语义图像分割》,2017 | 《具有可分割卷积的语义语义分割的编解码器》,2018 |
| 作者 | 陈良杰,乔治·帕潘德里欧,Iasonas Kokkinos,凯文·墨菲和艾伦·尤里 | 陈良杰,乔治·帕潘德里欧,Iasonas Kokkinos,凯文·墨菲和艾伦·尤里 | 陈良杰,乔治·帕潘德里欧,弗洛里安·施罗夫和哈特维格·Adam | 陈良杰,朱玉坤,乔治·帕潘德里欧,弗洛里安·施罗和哈特维格·Adam |
| 关键概念 | 原子卷积,全连接条件随机场(CRF) | 多孔空间金字塔池(ASPP) | ASPP,图像级特征和批量规范化 | ASPP 和编码器/解码器模块 |
DeepLabV3+ 使用空间金字塔池(SPP)的概念来定义其架构。
空间金字塔池化
我们在“第 5 章”,“神经网络架构和模型”中介绍的大多数 CNN 模型都需要固定的输入图像大小,这限制了输入图像的纵横比和比例。 固定大小约束不是来自卷积运算; 相反,它来自全连接层,该层需要固定的输入大小。 卷积操作从 CNN 的不同层中的图像的边缘,拐角和不同形状生成特征映射。 特征映射在不同的层中是不同的,并且是图像中形状的函数。 它们不会随着输入大小的变化而显着变化。 SPP 代替了最后一个合并层,紧接在全连接层之前,由并行排列的空间容器组成,其空间大小与输入图像的大小成正比,但其总数固定为全连接层数。 空间池化层通过保持过滤器大小固定但更改特征向量的大小来消除输入图像的固定大小约束。
DeepLabV3 的架构基于两种神经网络-空洞卷积和编码器/解码器网络。
空洞卷积
我们在“第 4 章”,“图像深度学习”中介绍了卷积的概念,但是我们没有涉及各种空洞卷积。空洞卷积,也称为膨胀卷积,增加了卷积的视野。 传统的 CNN 使用最大池化和跨步来快速减小层的大小,但这样做也会降低特征映射的空间分辨率。空洞卷积是一种用于解决此问题的方法。 它通过使用 Atrous 值修改跨步来实现此目的,从而有效地更改了过滤器的值字段,如下图所示:

上图显示了速率为 2 的空洞卷积。与深度卷积相比,它跳过了其他每个像元。 实际上,如果应用stride = 2,则3 x 3核就是3 x 3核。与简单的深度方向较小的特征映射相比,空洞卷积增加了视野并捕获了边界信息(与最大池化相比, 缺少对象边界),从而导致图像上下文丰富。 由于其在每个后续层中保持视野相同的特性,空洞卷积用于图像分割。
DeepLabV3 执行几个并行的空洞卷积,所有这些卷积以不同的速率运行,就像我们前面描述的空间池化层概念一样。 上图说明了空洞卷积模块和并行模块彼此相邻堆叠以形成 SPP。 与传统卷积不同,传统卷积与原始图像相比减少了最终特征向量的深度和宽度,而空洞卷积保留了图像大小。 因此,图像的精细细节不会丢失。 在构建具有丰富图像上下文的分割图时,这很有用。
编解码器网络
编码器是获取图像并生成特征向量的神经网络。 解码器执行与编码器相反的操作; 它采用特征向量并从中生成图像。 编码器和解码器一起训练以优化组合损失函数。
编码器-解码器网络可在编码器路径中实现更快的计算,因为不必在编码器路径中扩张特征,并且在解码器路径中恢复了清晰的物体。 编码器-解码器网络包含一个编码器模块,该模块捕获更高的语义信息,例如图像中的形状。 它通过逐渐缩小特征映射来实现。 另一方面,解码器模块保留空间信息和更清晰的图像分割。
编码器和解码器主要在多个比例上使用1 x 1和3 x 3空洞卷积。 让我们更详细地了解它们。
编码器模块
编码器模块的主要功能如下:
- 空洞卷积用于提取特征。
- 输出跨步是输入图像分辨率与最终输出分辨率之比。 其典型值为 16 或 8,这会导致特征提取更加密集。
- 在最后两个块中使用速率为 2 和 4 的空洞卷积。
- ASPP 模块用于在多个尺度上应用卷积运算。
解码器模块
解码器模块的主要功能如下:
1 x 1卷积用于减少来自编码器模块的低级特征映射的通道。3 x 3卷积用于获得更清晰的分割结果。- 4x 上采样。
DeepLab 中的语义分割 - 示例
可在以下由 TensorFlow 管理的 GitHub 页面上找到使用 TensorFlow 训练 DeepLab 的详细代码。
Google Colab 包含基于几个预先训练的模型的内置 DeepLab Python 代码。 可以在这个页面中找到。
Google Colab,Google Cloud TPU 和 TensorFlow
在深入研究示例代码之前,让我们了解 Google 机器学习的一些基本功能,所有这些功能都是免费提供的,以便我们可以开发强大的计算机视觉和机器学习代码:
- Google Colab:您可以从 Google 云端硬盘打开 Google Colab,如以下屏幕截图所示。 如果您是第一次使用它,则必须先单击“新建”,然后单击“更多”,才能将 Google Colab 安装到您的云端硬盘。 Google Colab 可让您无需安装即可打开 Jupyter 笔记本。 它还内置了 TensorFlow,这意味着处理包含给您的所有 TensorFlow 依赖项要容易得多:

上面的屏幕快照显示了 Google Colab 文件夹相对于 Google 云端硬盘的位置。 它使您可以处理.ipynb文件,然后进行存储。
- Google Cloud TPU:这是张量处理单元。 它使您可以更快地运行神经网络代码。 进入 Google Colab 笔记本后,您可以为 Python
.ipynb文件激活 TPU,如以下屏幕截图所示:

如前面的屏幕快照所示,打开 Cloud TPU 将有助于加快处理神经网络的训练和预测阶段的速度。
Google Colab DeepLab 笔记本包含三个示例图像,还为您提供获取 URL 的选项,以便您可以加载自定义图像。 当您获得图像的 URL 时,请确保 URL 末尾带有.jpg。 从互联网上提取的许多图像没有此扩展名,程序会说找不到它。 如果您有自己想要使用的图像,请将其存储在 GitHub 页面上,然后下载 URL。 以下屏幕截图显示了根据mobilenetv2_coco_voctrainaug接收到的输出:

上面的屏幕快照显示了四个不同的图像-停放的自行车,繁忙的纽约街道,城市道路和带家具的房间。 在所有情况下检测都非常好。 应当注意,该模型仅检测以下 20 个类别,以及背景类别:背景,飞机,自行车,鸟 ,船,瓶,公共汽车,车,猫,椅子,牛,餐桌,狗,马,摩托车,人, 盆栽植物,绵羊,沙发,火车,电视。 以下屏幕快照显示了使用不同模型xception_coco_voctrainval运行的相同四个图像:

与 MobileNet 模型相比,对象对异常模型的预测显示出更多的改进。 与 MobileNet 模型相比,对于例外模型,可以清楚地检测出自行车,人和桌子的细分。
MobileNet 是一种有效的神经网络模型,可用于手机和边缘设备。 与常规卷积相反,它使用深度卷积。 要详细了解 MobileNet 和深度卷积,请参阅“第 11 章”,“具有 GPU/CPU 优化功能的边缘深度学习”。
使用 DCGAN 生成人工图像
在“第 5 章”,“神经网络架构和模型”中,我们了解了 DCGAN。 它们由生成器模型和判别器模型组成。 生成器模型采用表示图像特征的随机向量,并通过 CNN 生成人工图像G(z)。 因此,生成器模型返回生成新图像及其类别的绝对概率具有可分割卷积的语义语义分割的编解码器。 判别器(D)网络是二分类器。 它从样本概率,图像分布(p_data)和来自生成器的人造图像中获取真实图像,以生成最终图像P(z)的概率。 从真实图像分布中采样。 因此,判别器模型返回条件概率,即最终图像的类别来自给定分布。
判别器将生成真实图像的概率信息馈送到生成器,生成器使用该信息来改进其预测,以创建人造图像G(z)。 随着训练的进行,生成器会更好地创建可以欺骗判别器的人工图像,并且判别器将发现很难将真实图像与人工图像区分开。 这两个模型相互对立,因此命名为对抗网络。 当判别器不再能够将真实图像与人工图像分离时,模型收敛。
GAN 训练遵循针对几个周期的判别器和生成器训练的替代模式,然后重复进行直到收敛为止。 在每个训练期间,其他组件保持固定,这意味着在训练生成器时,判别器保持固定,而在训练判别器时,生成器保持固定,以最大程度地减少生成器和判别器相互追逐的机会 。
前面的描述应该已经为您提供了 GAN 的高级理解。 但是,为了编码 GAN,我们需要更多地了解模型架构。 让我们开始吧。
生成器
下图显示了 DCGAN 的生成器网络的架构:

从上图中,我们可以看到以下内容:
- 所有具有跨步但没有最大池化的卷积网络都允许该网络在生成器中学习自己的上采样。 注意,最大池化被跨步卷积代替。
- 第一层从判别器获得概率
P(z),通过矩阵乘法连接到下一个卷积层。 这意味着不使用正式的全连接层。 但是,网络可以达到其目的。 - 我们将批量归一化到所有层以重新调整输入,生成器生成器层除外,以提高学习的稳定性。
判别器
下图显示了 DCGAN 判别器网络的架构:

从上图中,我们可以看到以下内容:
- 所有具有跨步但没有最大池化的卷积网络都允许网络在判别器中学习自己的下采样。
- 我们消除了全连接层。 最后的卷积层被展平并直接连接到单个 Sigmoid 输出。
- 我们对除判别器输入层以外的所有层应用批归一化,以提高学习的稳定性。
训练
训练时要考虑的关键特征如下:
- 激活:Tanh
- 随机梯度下降(SGD),最小批量为 128
- 泄漏 ReLU:斜率为 0.2
- 学习率为 0.0002 的 Adam 优化器
- 动量项 0.5:值 0.9 引起振荡
下图显示了训练阶段 DCGAN 的损失项:

当生成器接收到随机输入并且生成器损失定义为其产生假输出的能力时,训练便开始了。 判别器损失定义为其将实际输出与伪输出分离的能力。 梯度用于更新生成器和判别器。 在训练过程中,同时对生成器和判别器进行训练。 训练过程通常只要我们需要同时训练两个模型即可。 请记住,两个模型是相互同步的。
使用 DCGAN 修复图像
图像修补是根据来自相邻点的信息填充图像或视频缺失部分的过程。 图像修补工作流程涉及以下步骤:
-
图像中缺少片段。
-
收集相应缺失部分的像素信息。 这称为层蒙版。
-
向神经网络馈送步骤 1 和 2 中描述的图像,以确定需要填充图像的哪一部分。这意味着,首先对具有缺失部分的图像进行处理,然后对层蒙版进行处理。
-
输入图像经过类似的 DCGAN,如前所述(卷积和反卷积)。 层蒙版允许网络基于其相邻像素数据仅关注缺失部分,并丢弃图像中已经完成的部分。 生成器网络生成伪造的图像,而判别器网络确保最终绘画看起来尽可能真实。
TensorFlow DCGAN – 示例
TensorFlow.org 有一个很好的图像修复示例,您可以在 Google Colab 或您自己的本地计算机上运行。 该示例可以在 Google Colab。
此示例显示了根据 MNIST 数据集训练 GAN,然后生成人工数字的方法。 使用的模型与前面各节中描述的模型相似。
使用 OpenCV 修复图像
OpenCV 提供了两种图像修复方法,如下所示:
cv.INPAINT_TELEA基于论文《一种基于快速行进方法的图像修复技术》,2004 年由 Alexandru Telea 提出。该方法用所有图像的归一化加权和替换待修复邻域中的像素。 附近的已知像素。 那些位于该点附近和边界轮廓上的像素将获得更大的权重。 修复像素后,将使用快速行进方法将像素移动到下一个最近的像素:
import numpy as np
import cv2 as cv
img = cv.imread('/home/.../krishmark.JPG')
mask = cv.imread('/home/.../markonly.JPG',0)
dst = cv.inpaint(img,mask,3,cv.INPAINT_TELEA)
cv.imshow('dst',dst)
cv.waitKey(0)
cv.destroyAllWindows()
cv.INPAINT_NS基于 Bertalmio,Marcelo,Andrea L. Bertozzi 和 Guillermo Sapiro 在 2001 年发表的论文《Navier-Stokes,流体动态以及图像和视频修补》。它连接具有相同强度的点,同时在修复区域的边界匹配梯度向量。 此方法使用流体动态算法:
import numpy as np
import cv2 as cv
img = cv.imread('/home/.../krish_black.JPG')
mask = cv.imread('/home/.../krish_white.JPG',0)
dst = cv.inpaint(img,mask,3,cv.INPAINT_NS)
cv.imshow('dst',dst)
cv.waitKey(0)
cv.destroyAllWindows()
下图显示了最终输出:

如我们所见,这两个预测都部分成功,但并未完全删除该行。
了解神经样式迁移
神经样式迁移是一种技术,您可以通过匹配内容图像和样式图像的特征分布来混合它们,以生成与内容图像相似但在艺术上以样式化的图像样式绘制的最终图像。 可以在 TensorFlow 中以两种不同方式完成样式迁移:
- 在 TensorFlow Hub 中使用预训练的模型。 这是您上传图像和样式的地方,该工具包将生成样式输出。 您可以在这个页面上上传图像。 请注意,TensorFlow Hub 是许多预训练网络的来源。
- 通过训练神经网络来开发自己的模型。 为此,请按照下列步骤操作:
- 选择 VGG19 网络-它具有五个卷积(
Conv2D)网络,每个Conv2D具有四层,然后是全连接层。 - 通过 VGG19 网络加载内容图像。
- 预测前五个卷积。
- 加载没有顶层的 VGG19 模型(类似于我们在“第 6 章”,“使用迁移学习的视觉搜索”中所做的工作),并列出该层的名称。
- VGG19 中的卷积层具有特征提取功能,而全连接层执行分类任务。 如果没有顶层,则网络将仅具有顶层五个卷积层。 从前面的章节中我们知道,初始层传达原始图像的输入像素,而最终层捕捉图像的定义特征和图案。
- 这样,图像的内容就由中间特征映射表示–在这种情况下,这是第五个卷积块。
- 选择 VGG19 网络-它具有五个卷积(
gram 矩阵是向量G = I[i]ᐪ I[j]的内积的矩阵。 在此,Iᵢ和Iⱼ是原始图像和样式图像的特征向量。 内积代表向量的协方差,代表相关性。 这可以用样式来表示。
以下代码输入一个 VGG 模型,并从该模型中提取样式和内容层:
vgg = tf.keras.applications.VGG19(include_top=False, weights='imagenet')
vgg.trainable = False
for layer in vgg.layers:
print(layer.name)
以下结果显示了卷积块及其顺序:
input_2
block1_conv1
block1_conv2
block1_pool
block2_conv1
block2_conv2
block2_pool
block3_conv1
block3_conv2
block3_conv3
block3_conv4
block3_pool
block4_conv1
block4_conv2
block4_conv3
block4_conv4
block4_pool
block5_conv1
block5_conv2
block5_conv3
block5_conv4
block5_pool
我们将使用从前面的输出生成的卷积结果来开发内容层和样式层,如以下代码所示:
#Content layer: content_layers = ['block5_conv2']
#Style layer: style_layers = ['block1_conv1','block2_conv1','block3_conv1', 'block4_conv1', 'block5_conv1']
style_outputs = [vgg.get_layer(name).output for name in style_layers]
content_outputs = [vgg.get_layer(name).output for name in content_layers]
vgg.input = style_image*255
输入的四个维度是批量大小,图像的宽度,图像的高度和图像通道的数量。 255 乘数将图像强度转换为 0 到 255 的比例:
model = tf.keras.Model([vgg.input], outputs)
如前所述,这种样式可以用克矩阵表示。 在 TensorFlow 中,gram 矩阵可以表示为tf.linalg.einsum。
因此,我们可以编写以下代码:
for style_output in style_outputs:
gram_matrix = tf.linalg.einsum(‘bijc,bijd->bcd’, style_outputs,style_outputs)/tf.cast(tf.shape(style_outputs[1]*style_outputs[2]))
损失计算如下:
style_loss = tf.add_n([tf.reduce_mean((style_outputs[name]-style_targets[name])**2) for name in style_outputs.keys()])
style_loss *= style_weight / num_style_layers
content_loss = tf.add_n([tf.reduce_mean((content_outputs[name]-content_targets[name])**2) for name in content_outputs.keys()])
content_loss *= content_weight / num_content_layers
loss = style_loss + content_loss
可以从 TensorFlow 教程中获得最终代码。 代码结构如此处所述。 我在以下图像上运行它,其输出如下:

请注意,图像输出如何从沙漠中的少量石粒过渡到完全充满石头,同时又保持了沙漠的某些结构。 最后的迭代(迭代 1,000)确实显示出一种艺术融合。
总结
在本章中,我们学习了如何使用 TensorFlow 2.0 和 Google Colab 训练神经网络来执行许多复杂的图像处理任务,例如语义分割,图像修复,生成人工图像和神经样式迁移。 我们了解了生成器网络和判别器网络的功能,以及如何可以平衡地同时训练神经网络以创建伪造的输出图像。 我们还学习了如何使用空洞卷积,空间池和编码器/解码器网络来开发语义分割。 最后,我们使用 Google Colab 训练了一个神经网络来执行神经样式迁移。
在下一章中,我们将使用神经网络进行活动识别。
九、使用多任务深度学习的动作识别
动作识别是计算机视觉的关键部分,涉及识别人的手,腿,头和身体的位置,以检测特定的运动并将其分类为众所周知的类别。 困难在于视觉输入(例如,身体凌乱或衣服被覆盖)的变化,类似的动作,不同的类别(如饮用水或使用手持手机的通话)以及获得代表性的训练数据。
本章详细概述了可用于人体姿势估计和动作识别的关键方法。 动作识别将姿势估计方法与基于加速度的活动识别以及基于视频和三维点云的动作识别相结合。 该理论将通过使用 TensorFlow 2.0 的实现解释加以补充。
本章分为四个部分。 前三个讨论了可用于人体姿势估计的三种不同方法,而第四个全部涉及动作识别:
- 人体姿势估计 – OpenPose
- 人体姿势估计 – 栈式沙漏模型
- 人体姿势估计 - PoseNet
- 使用各种方法的动作识别
人体姿势估计 – OpenPose
人体姿势估计是深度神经网络取得巨大成功的另一个领域,并且近年来发展迅速。 在最后几章中,我们了解到深度神经网络结合使用线性(卷积)和非线性(ReLU)运算来预测给定输入图像集的输出。 在姿势估计的情况下,当提供一组输入图像时,深度神经网络会预测关节位置。 图像中的标记数据集由一个边界框组成,该边界框确定图像中的N个人和每人K关节。 随着姿势的改变,关节的方向也会改变,因此通过观察关节的相对位置来表征不同的位置。 在以下各节中,我们将描述可以使用的不同姿势估计方法。
OpenPose 背后的理论
OpenPose 是第一个针对图像或视频中的多个人的开源实时二维姿态估计系统。 它主要由卡内基梅隆大学(CMU)的学生和教职员工开发。 论文的标题是《OpenPose:使用部分亲和力字段进行实时多人 2D 姿势估计》,作者是 Zhe Cao,Gines Hidalgo,Tomas Simon,Shih-En-Wei 和 Yaser Sheikh。 您可以在这个页面上找到该论文。
请注意,OpenPose 首次出现在 CVPR 2017 中,题目为《使用部分亲和力字段进行实时多人 2D 姿势估计》,可在这个页面中找到。 接下来是 2018 年的论文《OpenPose:使用部分亲和力字段的实时多人 2D 姿势估计》,网络得到了进一步改善。
本文的主要发现如下:
- 网络的输入由 VGG-19 模型的前 10 层组成,用于生成一组特征映射
F。 下图显示了 OpenPose 网络的架构:

- OpenPose 网络将特征映射作为输入,并由 CNN 的两个阶段组成:第一阶段使用
T[p]编号预测部分相似性字段(PAF) 迭代次数,而第二阶段则以T[c]迭代次数预测置信度图。 由于以下两个关键指标,2018 年提出的 OpenPose 模型是对 2017 年提出的早期模型的总体改进: - 通过先计算 PAF,再计算置信度图,可将计算时间减少一半。 这不同于两者的同时计算以及用
3 x 3卷积代替3 x 3卷积。 - 改进的 PAF 估计(2018 年论文)通过增加神经网络的深度来改善常规 PAF(2017 年)的置信度图,从而提高了准确率。
- 在下一阶段中,将前一阶段的预测与原始图像特征
F合并在一起,以为图像中的所有人产生二维关键点预测。 在估计的预测,地面真实特征映射和 PAF 之间的每个阶段的末尾都应用了损失函数。 重复此过程几次迭代,从而得到最新的特征映射和 PAF 检测。 - 使用基于特征向量的自下而上的方法,无论图像中有多少人,都可以实现高精度。
- 置信度图是特定特征(身体部位)可以位于任何给定像素中的概率的二维表示。 另一方面,特征映射表示 CNN 给定层中给定过滤器的输出图。
- 网络架构由几个
1 x 1和1 x 1核组成。 每个1 x 1核的输出是连接的。 - OpenPose 是第一个实时多人系统,使用三个独立的 CNN 块检测 135 个关键点:(a)身体和脚部检测,(b)手部检测和(c)人脸检测。
- 在对象检测讨论(“第 5 章”,“神经网络架构和模型”和“第 7 章”,“使用 YOLO 进行对象检测”)中,我们发现,与诸如 SSD 或 YOLO 等单次检测方法相比,诸如 Faster R-CNN 之类的区域提议方法可带来更高的准确率,但速度却更低。 同样,对于人体姿势估计,自下而上的方法与自下而上的方法相比,具有较高的准确率,但速度较低。 自上而下的方法分别为每个由人组成的边界框提供图像。 自下而上的方法提供了由一个人的多个边界框组成的整个图像,从而产生了一个较小分辨率的人的图像。
在 2019 年,OpenPose 的作者以及其他一些人(Gines Hidalgo,Yaadhav Raaj,Haroon Idrees,Donglai Xiang,Hanbyul Joo,Tomas Simon1 和 Yaser Sheikh)提高了 OpenPose 的准确率和检测时间。 HTG0]单网络全身姿势估计。 您可以在这个页面上找到本文。
主要功能如下:
- 不需要重复进行手和脸姿势检测的网络,因此与 OpenPose 相比,它的速度更快。 多任务学习(MTL)用于从四个不同任务中训练单个全身估计模型:身体,面部,手和脚检测。
- 通过连接面部,手和脚的置信度图可以增强关键点置信度图。 使用这种方法,所有关键点都在同一模型架构下定义。
- 网络架构的输入分辨率和卷积层数增加了,以提高整体精度。
- 对于其中只有一个人的图像,检测时间输出比 OpenPose 快 10%。
了解 OpenPose 代码
CMU 使用 OpenPose 模型,而 OpenCV 在其新的深度神经网络(DNN)框架中集成了经过预训练的 OpenPose 模型。 可以从下面的 GitHub 页面下载整个代码块。 该模型使用 TensorFlow 示例,而不是 OpenPose 作者最初使用的 Caffe 模型,可以在这个页面中找到。
可以使用以下命令在终端中执行 OpenCV 的 OpenPose 代码:
python openpose.py --input image.jpg
要开始使用 PC 的网络摄像头,只需在终端中键入以下内容:
python openpose.py
下图显示了针对足球运动员图像的 OpenPose 实现:

该算法容易受到背景图像的影响,如以下棒球运动员的图像所示:

去除背景后,该算法的预测非常好。
让我们来看一下代码的主要功能。 我们将定义关键点,然后构建预测模型:
- 该模型输入 18 个身体部位和姿势对,如下所示:
BODY_PARTS = { "Nose": 0, "Neck": 1, "RShoulder": 2, "RElbow": 3, "RWrist": 4,"LShoulder": 5, "LElbow": 6, "LWrist": 7, "RHip": 8, "RKnee": 9,"RAnkle": 10, "LHip": 11, "LKnee": 12, "LAnkle": 13, "REye": 14,"LEye": 15, "REar": 16, "LEar": 17, "Background": 18 }
POSE_PAIRS = [ ["Neck", "RShoulder"], ["Neck", "LShoulder"], ["RShoulder", "RElbow"],["RElbow", "RWrist"], ["LShoulder", "LElbow"], ["LElbow", "LWrist"],["Neck", "RHip"], ["RHip", "RKnee"], ["RKnee", "RAnkle"], ["Neck", "LHip"],["LHip", "LKnee"], ["LKnee", "LAnkle"], ["Neck", "Nose"], ["Nose", "REye"],["REye", "REar"], ["Nose", "LEye"], ["LEye", "LEar"] ]
- 接下来,使用以下代码通过 TensorFlow 实现 OpenPose:
net = cv.dnn.readNetFromTensorflow("graph_opt.pb")
使用tf-pose-estimation在 TensorFlow 中实现 OpenPose。 TensorFlow/model/graph的实际 GitHub 页面可在这个页面中找到。 请注意,可以在这个页面中找到 MobileNetV1 的描述。
- 接下来,使用
cv.dnn.blobFromImage对图像进行预处理(执行减法和缩放):
net.setInput(cv.dnn.blobFromImage(frame, 1.0, (inWidth, inHeight), (127.5, 127.5, 127.5), swapRB=True, crop=False))
- 接下来,我们使用
out = net.forward()预测模型的输出,并获得 MobileNetV1 输出的前 19 个元素:
out = out[:, :19, :, :] .
- 以下代码计算热图,使用 OpenCV 的
minMaxLoc函数查找点值,并在其置信度高于阈值时添加点。 热图是用颜色表示的数据图:
for i in range(len(BODY_PARTS)):
# Slice heatmap of corresponding body's part.
heatMap = out[0, i, :, :]
# Originally, we try to find all the local maximums. To simplify a sample
# we just find a global one. However only a single pose at the same time
# could be detected this way.
_, conf, _, point = cv.minMaxLoc(heatMap)
x = (frameWidth * point[0]) / out.shape[3]
y = (frameHeight * point[1]) / out.shape[2]
# Add a point if it's confidence is higher than threshold.
points.append((int(x), int(y)) if conf > args.thr else None)
- 以下代码块在原始图像中使用
cv.line和cv.ellipse显示关键点:
for pair in POSE_PAIRS:
partFrom = pair[0]
partTo = pair[1]
assert(partFrom in BODY_PARTS)
assert(partTo in BODY_PARTS)
idFrom = BODY_PARTS[partFrom]
idTo = BODY_PARTS[partTo]
if points[idFrom] and points[idTo]:
cv.line(frame, points[idFrom], points[idTo], (0, 255, 0), 3)
cv.ellipse(frame, points[idFrom], (3, 3), 0, 0, 360, (0, 0, 255), cv.FILLED)
cv.ellipse(frame, points[idTo], (3, 3), 0, 0, 360, (0, 0, 255), cv.FILLED)
到目前为止,我们已经使用 OpenPose 通过自下而上的方法来确定多个身体姿势。 在下一节中,我们将使用堆叠的沙漏方法,该方法同时使用了自上而下和自下而上的方法。
人体姿势估计 – 栈式沙漏模型
栈式沙漏模型是由 Alejandro Newell,Kaiyu Yang 和 Jia Deng 于 2016 年在他们的论文“用于人体姿势估计的栈式沙漏网络”中开发的。 可以在这个页面中找到该模型的详细信息。
下图说明了该模型的架构:

该模型的主要功能如下:
- 通过将多个沙漏堆叠在一起,可在所有刻度上重复进行自下而上和自上而下的处理。 该方法导致能够验证整个图像的初始估计和特征。
- 该网络使用多个卷积和一个最大池化层,这导致最终分辨率较低,然后再进行上采样以提高分辨率。
- 在每个最大池化步骤中,平行于主网络添加其他卷积层。
- 输出结果将产生热图,表示每个像素出现关节的概率。
- 该架构充分利用了残差模型。 每个残差都有三层:
1 x 1 Conv2D,可将尺寸从 256 减少到 128 通道3 x 3 Conv2D的 128 个通道1 x 1 Conv2D,可将尺寸从 128 个通道增加到 256 个通道- 该架构从
7 x 7卷积开始,跨步为 2,将输入图像从7 x 7带到64 x 64,从而可以有效地使用 GPU 内存。 - 跨度为 2 的最大
2 x 2合并用于对图像进行下采样。 在执行每个最大池化之前和之后,将残余块添加,然后在上采样到原始大小后再添加回主块。 - 最后的标题块由两个
1 x 1 Conv2D组成。 - 表现最佳的是将八个沙漏模块堆叠在一起。 每个沙漏模块在每个分辨率下都有一个残差模块。
- 该模型大约需要进行 40,000 次迭代,以达到 70% 以上的精度。
- 训练过程需要 FLIC 约 5,000 张图像(用于训练的 4,000 张和用于测试的 1,000 张)和用于 MPII 的 40,000 张带标注的样本(用于训练的 28,000 张和用于测试的 12,000 张)。 FLIC 和 MPII 是两个姿势估计数据库。 FLIC 由从胶片中获取的 5003 张图像(用于训练的 3987 张图像和用于测试的 1,016 张图像)组成,而 MPII 由 40,000 个带标注的样本(用于训练的 28,000 张图像和用于测试的 12,000 张)组成。
- 该网络在 Torch 7 上进行了训练,学习率为
2.5e-4。 在 12 GB 的 NVIDIA Titan X GPU 上进行训练大约需要 3 天。
了解沙漏模型
沙漏模型在 MPII 人类姿态数据集中的所有关节上都达到了最先进的结果,但这是以占用资源密集型网络带宽为代价的。 这是由于每层通道数量众多而导致训练困难。 张峰,朱夏田和 Mao 在题为“快速人体姿态估计”的论文中,将 FastPose 蒸馏(FPD)引入 CVPR 2019。 与沙漏模型相比,FPD 可以实现更快,更经济的模型推断,同时达到相同的模型表现。 主要功能如下:
- 四个沙漏(而不是八个)可以预测 95% 的模型准确率。
- 从 256 个通道下降到 128 个通道只会导致精度降低 1%。
- 首先,在大型沙漏模型(也称为教师姿势模型)上进行训练。 然后,在教师姿势模型的帮助下训练目标学生模型(四个沙漏,128 个通道)。 定义了蒸馏损失函数,以从教师模型中提取知识并将其传递给学生模型。
- 姿势蒸馏损失函数如下:

在这里,K是关节总数,L[pd]是 FPD 的预测关节置信度图, m[ks]是学生模型预测的第k个关节的置信度图,而m[kt]是教师模型预测的第k个关节。
- 总体损失函数如下:

此处, L[fpd]是整体 FPD 损失函数,L[gt]是用于真实情况标注的置信度图,而M是权重函数。
- 使用前面描述的损失函数分别训练教师模型和目标模型。
可在这个页面中找到该模型的 Keras 实现。
请注意,下一部分的目的是详细解释沙漏网络的代码。 这是一个复杂的神经网络模型,其想法是,一旦掌握了这些代码,您就应该能够自己构建一个非常复杂的神经网络模型。 我们不会在前面的 GitHub 页面上详细说明如何运行代码。
在下一部分中,我们将描述模型的架构并进行详细说明。
编码沙漏模型
下图显示了沙漏模型的编码块:

让我们花一点时间来理解前面的图,因为我们将在以下部分中对其进行编码:
- 前模块将图像作为输入和通道数(每层的第三个尺寸,前两个尺寸是宽度和高度)。
- 图像穿过前模块的不同层,最后一个模块连接到左半块。
- 左半块具有四个瓶颈回旋块-
f1,f2,f4和f8,每个块分别具有 1、1/2、1/4 和 1/8 的分辨率。 如果查看架构图,就在堆叠的沙漏感应下,这应该很清楚。 - 每个块的最后一层–
f1,f2,f4和f8–创建一个对应的特征映射,即lf1,lf2,lf4和lf8。 - 特征映射
lf1,lf2,lf4和lf8连接到右半块。 该块的输出为rf1。 - 底部层也从左半块连接到
lf8特征映射。 - 头部快连接到
rf1。 总共有两个头部快。 每个使用1 x 1卷积。
让我们看一下不同的代码块。
argparse包
Python 命令行参数(通过终端输入)允许程序通过parser.add_argument命令获取有关神经网络操作的不同指令。 可以从argparse函数包中导入。
下图显示了 16 种不同的类:

上图使用的代码块如下:
0 - r ankle, 1 - r knee, 2 - r hip, 3 - l hip, 4 - l knee, 5 - l ankle, 6 - pelvis, 7 - thorax, 8 - upper neck, 9 - head top, 10 - r wrist, 11 - r elbow, 12 - r shoulder, 13 - l shoulder, 14 - l elbow, 15 - l wrist
以下代码导入argparse模块,TensorFlow 和 HourglassNet 模型。 它有两种类型的用户可选模型:用于小型网络的 128 个通道和用于大型网络的 256 个通道:
import argparse
import os
import tensorflow as tf
from keras import backend as k
from hourglass import HourglassNet
parser.add_argument("--resume", default=False, type=bool, help="resume training or not")
parser.add_argument("--resume_model", help="start point to retrain")
parser.add_argument("--resume_model_json", help="model json")
parser.add_argument("--init_epoch", type=int, help="epoch to resume")
parser.add_argument("--tiny", default=False, type=bool, help="tiny network for speed, inres=[192x128], channel=128")
args = parser.parse_args()
if args.tiny:
xnet = HourglassNet(num_classes=16, num_stacks=args.num_stack, num_channels=128, inres=(192, 192),outres=(48, 48))
else:
xnet = HourglassNet(num_classes=16, num_stacks=args.num_stack, num_channels=256, inres=(256, 256),outres=(64, 64))
if args.resume:
xnet.resume_train(batch_size=args.batch_size, model_json=args.resume_model_json,model_weights=args.resume_model,init_epoch=args.init_epoch, epochs=args.epochs)
else:
xnet.build_model(mobile=args.mobile, show=True)
xnet.train(epochs=args.epochs, model_path=args.model_path, batch_size=args.batch_size)
训练沙漏网络
沙漏网络已被描述。 在本节中,我们将解释训练网络背后的代码。
如果您想训练自己的沙漏网络,请按照这个页面上的说明进行操作。
训练沙漏网络的代码如下:
def build_model(self, mobile=False, show=False):
if mobile:
self.model = create_hourglass_network(self.num_classes, self.num_stacks, self.num_channels, self.inres, self.outres, bottleneck_mobile)
else:
self.model = create_hourglass_network(self.num_classes, self.num_stacks,self.num_channels, self.inres, self.outres, bottleneck_block)
# show model summary and layer name
if show:
self.model.summary(def train(self, batch_size, model_path, epochs):
train_dataset = MPIIDataGen("../../data/mpii/mpii_annotations.json", "../../data/mpii/images"
inres=self.inres, outres=self.outres, is_train=True)
#here MPIIDataGen is a data generator function (not shown here) - it takes in json file and the images to preapre data for training similar to how we use image data generator in Chapter6.
train_gen = train_dataset.generator(batch_size, self.num_stacks, sigma=1, is_shuffle=True,rot_flag=True, scale_flag=True, flip_flag=True)
csvlogger = CSVLogger(os.path.join(model_path, "csv_train_" + str(datetime.datetime.now().strftime('%H:%M')) + ".csv"))
modelfile = os.path.join(model_path, 'weights_{epoch:02d}_{loss:.2f}.hdf5')
checkpoint = EvalCallBack(model_path, self.inres, self.outres)
xcallbacks = [csvlogger, checkpoint]
self.model.fit_generator(generatepochs=epochs, callbacks=xcallbacks)
前面的代码是如何设置神经网络进行训练的典型示例。 我们在“第 6 章”,“使用迁移学习的视觉搜索”中对此进行了详细介绍。 主要函数如下:
create_hourglass_network是主要模型。train_dataset使用 MPIIDatagen,这是用于输入数据的外部模块。train_gen输入train_dataset并放大图像。- 它包含回调和检查点,因此我们可以在训练过程中了解模型的内部状态。
model.fit_generator开始训练过程。
创建沙漏网络
沙漏模型代码的实际实现将在此处说明。 用于此的代码称为create_hourglass_network。 如前所述,该代码具有以下组件。
前端模块
以下代码描述了前端模块:
def create_front_module(input, num_channels, bottleneck):
_x = Conv2D(64, kernel_size=(7, 7), strides=(2, 2), padding='same', activation='relu', name='front_conv_1x1_x1')(input)
_x = BatchNormalization()(_x)
_x = bottleneck(_x, num_channels // 2, 'front_residual_x1')
_x = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(_x)
_x = bottleneck(_x, num_channels // 2, 'front_residual_x2')
_x = bottleneck(_x, num_channels, 'front_residual_x3')
return _x
front_features = create_front_module(input, num_channels, bottleneck)
如前所述,它由一个 Conv2D 块组成,总共有 64 个过滤器,过滤器大小为7 x 7,跨步为 2。该块的输出为(None, 32, 32,6)。 接下来的几行贯穿批量规范化,瓶颈和最大池化层。 让我们定义瓶颈块。
左半块
左半块的代码如下:
def create_left_half_blocks(bottom, bottleneck, hglayer, num_channels):
# create left half blocks for hourglass module
# f1, f2, f4 , f8 : 1, 1/2, 1/4 1/8 resolution
hgname = 'hg' + str(hglayer)
f1 = bottleneck(bottom, num_channels, hgname + '_l1')
_x = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(f1)
f2 = bottleneck(_x, num_channels, hgname + '_l2')
_x = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(f2)
f4 = bottleneck(_x, num_channels, hgname + '_l4')
_x = MaxPool2D(pool_size=(2, 2), strides=(2, 2))(f4)
f8 = bottleneck(_x, num_channels, hgname + '_l8')
return (f1, f2, f4, f8)
前面的代码执行两个特定的操作:
- 它定义分辨率为
1, ½, ¼, and 1/8的过滤器系数(f1, f2, f4, and f8)。 - 对于每个过滤器块,它通过使用 2 的过滤器和 2 的跨度应用最大池化来生成最终输出。
接下来,下面的代码迭代从 0 到 2,以每个过滤器分辨率创建三个过滤器块:
for i in range(2):
head_next_stage, head_to_loss = create_left_half_blocks (front_features, num_classes, num_channels, bottleneck, i)
outputs.append(head_to_loss)
从左到右的连接
如果查看“编码沙漏模型部分开头的图像,您会注意到左右两个块由connect_left_to_right块连接。 用于将左侧块连接到右侧块的代码如下:
def connect_left_to_right(left, right, bottleneck, name, num_channels):
'''
:param left: connect left feature to right feature
:param name: layer name
:return:
'''
_xleft = bottleneck(left, num_channels, name + '_connect')
_xright = UpSampling2D()(right)
add = Add()([_xleft, _xright])
out = bottleneck(add, num_channels, name + '_connect_conv')
return out
注意,每个右块是通过上采样生成的,并被添加到左块以生成最终输出。 在前面的代码中,_xleft显示左侧块,_xright显示右侧块,add函数将两者相加。
右半块
右侧块的代码如下:
def create_right_half_blocks(leftfeatures, bottleneck, hglayer, num_channels):
lf1, lf2, lf4, lf8 = leftfeatures
rf8 = bottom_layer(lf8, bottleneck, hglayer, num_channels)
rf4 = connect_left_to_right(lf4, rf8, bottleneck, 'hg' + str(hglayer) + '_rf4', num_channels)
rf2 = connect_left_to_right(lf2, rf4, bottleneck, 'hg' + str(hglayer) + '_rf2', num_channels)
rf1 = connect_left_to_right(lf1, rf2, bottleneck, 'hg' + str(hglayer) + '_rf1', num_channels)
return rf1
在前面的代码中,lf8, lf4, lf2, and lf1具有左特征。 相应的右图块的特征rf8, rf4, rf2, and rf1是通过将左到右瓶颈图块应用到每个左图特征而生成的。 以下代码通过为每个左侧范围迭代 0 到 2 来应用此逻辑:
for i in range(2):
head_next_stage, head_to_loss = create_right_half_blocks (front_features, num_classes, num_channels, bottleneck, i)
outputs.append(head_to_loss)
头部快
头部快的代码如下:
def create_heads(prelayerfeatures, rf1, num_classes, hgid, num_channels):
# two head, one head to next stage, one head to intermediate features
head = Conv2D(num_channels, kernel_size=(1, 1), activation='relu', padding='same', name=str(hgid) + '_conv_1x1_x1')(rf1)
head = BatchNormalization()(head)
# for head as intermediate supervision, use 'linear' as activation.
head_parts = Conv2D(num_classes, kernel_size=(1, 1), activation='linear', padding='same',name=str(hgid) + '_conv_1x1_parts')(head)
# use linear activation
head = Conv2D(num_channels, kernel_size=(1, 1), activation='linear', padding='same',name=str(hgid) + '_conv_1x1_x2')(head)
head_m = Conv2D(num_channels, kernel_size=(1, 1), activation='linear', padding='same',name=str(hgid) + '_conv_1x1_x3')(head_parts)
head_next_stage = Add()([head, head_m, prelayerfeatures])
return head_next_stage, head_parts
头部有两个主要块,每个块由一个1 x 1 Conv2D过滤器组成。 它使用激活层和填充。 作为复习,请参考“人体姿势估计-沙漏模型”部分下显示的沙漏架构图,以了解以下组件之间的联系:
- 进入下一个阶段
- 前往中间特征
以下逻辑将头部快应用于 0 到 2 的每个范围,分别对应于左块和右块:
for i in range(2):
head_next_stage, head_to_loss = create_head_blocks (front_features, num_classes, num_channels, bottleneck, i)
outputs.append(head_to_loss)
训练沙漏
沙漏网络在 FLIC 人体姿势数据集上进行了训练,该数据集包含 5,000 张图像(用于训练的 4,000 和用于测试的 1,000)和具有 40,000 图片(用于训练的 28,000 和用于测试的 12,000)的 MPII 人体姿势数据集。
请注意,在本书中,我们没有使用 MPII 数据集来训练沙漏模型。 提供了有关 MPII 数据集的信息,以解释如何训练沙漏模型进行人体姿势估计。
在大约 20,000 次训练迭代中,所有关节的平均准确率达到大约 70%,最大准确率大约为 80%。
到目前为止,我们已经讨论了 OpenPose 和姿势估计的栈式沙漏方法。 在下一节中,我们将讨论 PoseNet。
人体姿势估计 - PoseNet
TensorFlow 发布了 PoseNet 模型,该模型用于使用浏览器检测人体姿势。 它可以用于单个姿势和多个姿势。
PoseNet 基于 Google 的两篇论文。 一种使用自上而下的方法,而另一种使用自下而上的方法。
自上而下的方法
第一篇论文的标题为《在野外进行精确的多人姿势估计》,由 George Papandreou,Tyler Zhu,Nori Kanazawa,Alexander Toshev,Jonathan Tompson,Chris Bregler 和 Kevin Murphy 撰写。 您可以在这个页面上找到该论文。
这是一种由上而下的两阶段方法:
- 使用带有 ResNet-101 网络主干的 Faster R-CNN 确定边界框坐标(
x, y, w, h)。 在“第 5 章”,“神经网络架构和模型”中引入了更快的 R-CNN 和 ResNet,但在“第 10 章”,“使用 R-CNN,SSD 和 R-FCN 进行对象检测”中将在实际实现中一起使用它们。这种分类仅针对人类进行。 调整返回的所有边界框,使其具有固定的纵横比,然后将其裁剪为353 x 257。 - 使用 ResNet-101 估计位于每个边界框内的人的 17 个关键点,用
3 x 17输出替换最后一层。 已经使用分类和回归相结合的方法来找到人体的每个位置与 17 个关键点位置中的每个位置之间的偏移向量或距离。 每 17 个关键点计算一次距离小于半径的概率,从而得出 17 个热图。 使用 Sigmoid 激活函数训练具有 17 个热图的 ResNet-101 模型。
自下而上的方法
第二篇论文的标题为《PersonLab:使用自下而上的,基于部分的几何嵌入模型的人员姿势估计和实例细分》,由第一篇论文的许多相同作者撰写; 分别是 George Papandreou,Tyler Zhu,Chen-Chieh Chen,Spyros Gidaris,Jonathan Tompson 和 Kevin Murphy。 您可以在这个页面上找到该论文。
在这种无框的,自下而上的方法中,作者使用卷积神经网络检测单个关键点及其相对位移,以将关键点分组为人的姿势实例。 另外,设计了几何嵌入描述符来确定人员分割。 该模型使用 ResNet-101 和 ResNet-152 架构进行训练。
像自顶向下方法一样,定义了一个 32 像素大小的半径,对应于 17 个关键点中的每一个。 然后,如果图像中的空间位置在关键点位置的半径之内,则以热图概率 1 定义 17 个独立的二元分类任务; 否则,将其设置为 0。与自顶向下方法一样,图像位置和关键点之间的距离也称为短距离偏移向量。 因此,存在 17 个这样的偏移向量。 与自顶向下方法一样,热图和偏移向量使用二维 Hough 得分图分组在一起。
在这种方法中,我们有一个与关键点相关联的人,但是当图像中存在多个人的实例时,这不允许我们对每个人的关键点进行分组。 为了解决这个问题,开发了 32 个独立的中距离二维偏移量字段来连接成对的关键点。 除此之外,还开发了一个由单个1 x 1 Conv2D层组成的简单语义分割模型,该模型可以执行密集逻辑回归并计算每个图像像素至少属于一个人的概率。 语义分段的详细信息在“第 8 章”,《语义分段和神经样式迁移》中进行了描述。
有关预测图像的信息,请参阅以下有关自上而下与自下而上的文章和这个。 这两篇论文都包含大量示例图像。
预测关键点在两种方法之间或多或少是相同的,但是自上而下的方法从绘制边界框开始,而自下而上的方法执行语义分割。
PoseNet 实现
到目前为止,我们已经讨论了 PoseNet 自上而下和自下而上方法背后的理论。 在本节中,我们将使用 PoseNet 识别这些操作。 有关如何实现 PoseNet 模型的详细信息,请参见这里。 查看此链接以了解 PoseNet 的文档。
接下来,我们将进行现场演示。 此实时演示是使用网络摄像头完成的,可以通过在网络浏览器中键入以下链接来启动。
尽管自上而下和自下而上的方法使用 ResNet-101 模型,但 PoseNet 模型使用 MobileNetV1 或 ResNet-50。 下表说明了它们之间的区别:
| MobileNet V1 | ResNet 50 | |
|---|---|---|
| 跨步 | 16 | 32 |
| 输入分辨率 | 宽度:640,高度:480 | 宽度:257,高度:200 |
PoseNet 网站说明了如何调整模型参数。 可以使用以下屏幕快照中显示的参数窗口来调整模型参数:

在前面的屏幕截图中,我们可以通过更改输入图像的分辨率来演示这两种模型,这似乎效果最好。
下图比较了八种不同配置(对于 MobileNetV1 和 ResNet,分辨率为 200 和 500 的上下姿势)的 PoseNet 输出:

上图显示,当人的手举起时,ResNet 平均比 MobileNetV1 更准确。 当手的位置向下时,表现大致相同。 同样,与 500 分辨率相比,200 分辨率可实现更好的关键点预测。 边界框选项可用,但未显示。 下图显示了用于其他配置的 ResNet 的边界框:

请注意边界框的大小和位置在不同方向上如何变化。 关键点存储在向量中。 生成的关键点之间的角度可用于预测动作。 上一个图像由三个不同的动作组成–侧向运动,向上和向下运动。 这些动作的关键角度不会重叠,因此预测将是可靠的。
将人体姿势应用于手势识别
到目前为止,我们已经学习了如何在给定的关键点上进行训练以生成人体姿势。 手势识别的过程类似。 请按照以下步骤执行手势识别以进行手部运动:
-
收集不同手的位置的图像 - 上,下,左和右。
-
调整图像大小。
-
此时,您可以用关键点标记图像。 如果为关键点标记图像,则每个图像都必须用相应的关键点表示。
-
将图像及其相应的标签加载到两个不同的数组中。
-
下一步是执行图像分类,类似于我们在“第 6 章”,“使用迁移学习进行视觉搜索”时所做的工作。
-
CNN 模型最多可以包含三个
Conv2D层,一个最大合并层和一个 ReLU 层。 -
对于关键点估计,而不是分类,我们将使用每个关键帧手势位置之间的距离,并选择具有最小距离的手势。
到目前为止,我们已经学习了如何开发用于训练的二维神经网络。 我们开发的网络也可以用于生产。
使用各种方法的动作识别
加速度计测量加速度的x,y和z分量,如下图所示:

加速度计的这一特性使其可以放置在可穿戴设备中,例如安装在腕带上的手腕上的手机,智能手表,甚至是鞋子中,以测量加速度的 XYZ 分量。 在本节中,我们将学习如何使用神经网络分析加速度计数据以识别人类活动。 我们将使用 TensorFlow 开发机器学习模型。 这是本书中唯一讨论无图像的原始数据以及如何将其传递到神经网络以开发模型并从中进行推断的章节。
人类活动识别涉及基于加速度计数据对不同类型的活动进行分类。 这里的挑战是关联从不同类型的人体运动生成的加速度计数据,并基于不同的人体运动和活动来区分相似的加速度计轨迹。 例如,当左手移动和右手移动安装到人的腰部时,可能会产生类似的加速度计数据。 这减轻了加速度计数据应与姿势估计或视频图像数据结合的事实。 在本节中,我们将讨论可用于人类活动识别的两种不同工具。
基于加速度计识别动作
此方法涉及以下步骤:
- 处理输入的加速度计数据:加速度计数据对其位置敏感。 例如,如果安装在腰部区域,则与安装在手臂中相比,手部运动不会在加速度计中看到很大的变化。 另外,对于不同的位置,需要收集不同的数据,然后进行组合。
- 准备数据以便可以将其输入到 TensorFlow 中:使用
tf.data.Dataset加载数据以开发简单,高效的数据管道。tensor_slices命令从输入中提取一片数据。 - 开发 CNN 模型并对其进行训练:一层或两层密集层,最后具有
flatten和 Softmax 函数。 - 检查测试数据:对照测试数据验证数据。
请参阅以下 GitHub 页面上的代码,以获取遵循这些步骤的代码示例。
在上一个链接中可以找到两个文件:Chapter9_TF_Accelerometer_activity.ipynb和sample.csv。 下载两个文件,并将它们放在同一文件夹下。
sample.csv文件是一个示例 CSV 文件,其中包含用于六个不同动作的加速度计(x, y, z)数据:慢跑(0),步行(1),楼上(2),楼下(3) ,坐(4)和站立(5),每个动作都包含 5,000 个数据点。 在您的实际情况下,这些数据值可能会根据放置位置和所使用的加速度计的类型而有所不同。 最好使用相同的加速度计进行训练数据进行推理,以避免推理错误。
接下来,根据索引文件将数据分为两部分:训练和测试。 在这里,我们将评估两个不同的分割 18 和 28,这意味着在一种情况下,如果索引文件小于 18,则数据属于train文件夹; 否则,它属于test文件夹。 该模型加载了三个密集(全连接)的层,分辨率为 128。 最终的 softmax 层被 Sigmoid 函数代替。 下图显示了在三种不同情况下模型的迭代:
- Softmax,训练与测试的索引为 18
- Sigmoid 函数,在索引 18 处分割,用于训练与测试
- Softmax,训练与测试的索引为 28:

前面的数据表明,每次迭代大约需要 40 秒,最终精度约为 0.97。 下图以图形方式说明了这一点:

前面的曲线表明,在所研究的三个条件下,训练的精度基本相同。 为了进一步分析这一点,让我们看一下下图中所示的置信度图:

混淆矩阵指示测试数据与预测数据的比较程度。 在这里,我们可以看到在索引 18 处进行了训练分割的 Softmax 函数比其他站立和步行案例提供了更好的结果。 不出所料,Softmax 与 Sigmoid 激活函数没有导致任何显着差异。 一旦开发了模型,就可以使用模型的预测函数来预测实际测试情况下的数据。
将基于视频的动作与姿势估计相结合
动作识别可以是二维的,也可以是三维的。 二维动作识别方法使用人体的关节信息,以关键点表示。 这些关键点以称为特征映射的向量表示。 另一方面,三维动作识别方法不仅需要特征映射,还需要全身的骨架数据。 可以使用深度传感器(例如 Microsoft Kinect 或 Intel RealSense)获得此数据。 在 2018 年,Diogo C.Luvizon,David Picard 和 Hedi Tabia 介绍了他们的论文 《使用多任务深度学习的 2D/3D 姿势估计和动作识别》。 可以在这里中找到本文的详细信息。
在本文中,作者在一个多任务框架中将基于高级人体关节的姿势信息与低级视觉特征(来自对象识别和特征识别)集成在一起。 该方法能够进行二维和三维动作识别。 使用体积表示将二维姿态图扩展为三维图。
这些技术的组合有助于使动作识别对类似身体的关节运动(如饮用水和打个电话)的抵抗力更强。
使用 4D 方法的动作识别
4D 动作识别意味着体积表示的三维动作是时间的函数。 可以将其视为对动作进行批量跟踪。 全全友和郝江提出了一种新颖的 4D 方法,名为《Action4D:人群和杂物中的在线动作识别》。可以在这个页面中找到本文的详细信息。
该方法使用 4D 表示跟踪人类,并在混乱和拥挤的环境中识别他们的行为。 本文的概念如下:
- 使用多个 RGBD 图像为每个场景创建三维点云。
- 在拥挤场景中的检测得到了创新的跟踪建议的补充,该提议不使用背景减法,这意味着它在拥挤空间中不太容易出错。
- 跟踪过程通过训练 3 维 CNN(具有 3 维卷积,ReLU 和池化层)来使用候选人提案,以将每个候选量分类为人与非人。
- 使用一系列三维体积识别动作,这些三维体积经过一系列三维卷积和池化层(称为 Action4D)。
总结
在本章中,我们了解并实现了三种不同的姿势估计方法-OpenPose,栈式沙漏和 PostNet。 我们学习了如何使用 OpenCV 和 TensorFlow 预测人类关键点。 然后,我们了解了栈式沙漏方法的详细理论和 TensorFlow 实现。 我们向您展示了如何在浏览器中评估人体姿势,以及如何使用网络摄像头实时估计关键点。 然后将人体姿势估计与动作识别模型链接,以演示如何使用两者来提高准确率。 基于加速的代码展示了如何使用 TensorFlow 2.0 加载数据,训练模型和预测动作。
在下一章中,我们将学习如何实现 R-CNN 并将其与其他 CNN 模型(如 ResNet,Inception 和 SSD)结合使用,以提高对象检测的预测,准确率和速度。
第 1 节:计算机视觉和神经网络概论
在本节中,您将加深对理论的理解,并学习有关卷积神经网络在图像处理中的应用的动手技术。 您将学习关键概念,例如图像过滤,特征映射,边缘检测,卷积运算,激活函数,以及与图像分类和对象检测有关的全连接和 softmax 层的使用。 本章提供了许多使用 TensorFlow,Keras 和 OpenCV 的端到端计算机视觉管道的动手示例。 从这些章节中获得的最重要的学习是发展对不同卷积运算背后的理解和直觉-图像如何通过卷积神经网络的不同层进行转换。
在本节结束之前,您将能够执行以下操作:
- 了解图像过滤器如何转换图像(第 1 章)
- 应用各种类型的图像过滤器进行边缘检测(第 1 章)
- 使用 OpenCV 轮廓检测和定向梯度直方图(HOG)检测简单对象(第 1 章)
- 使用尺度不变特征变换(SIFT),本地二进制模式(LBP)模式匹配以及颜色匹配来查找对象之间的相似性(第 1 章和第 2 章)
- 使用 OpenCV 级联检测器进行面部检测(第 3 章)
- 从 CSV 文件列表将大数据输入到神经网络中,并解析数据以识别列,然后可以将其作为
x和y值馈入神经网络(第 3 章) - 面部关键点和面部表情识别(第 3 章)
- 为面部关键点开发标注文件(第 3 章)
- 使用 Keras 数据生成器方法将大数据从文件输入到神经网络(第 4 章)
- 构建自己的神经网络并优化其参数以提高准确率(第 4 章)
- 编写代码以通过卷积神经网络的不同层来变换图像(第 4 章)
本节包括以下章节:
- “第 1 章”,“计算机视觉和 TensorFlow 基础知识”
- “第 2 章”,“使用本地二进制模式的内容识别”
- “第 3 章”,“使用 OpenCV 和 CNN 进行面部检测”
- “第 4 章”,“图像深度学习”
第 2 节:使用 TensorFlow 的计算机视觉高级概念
在本节中,您将基于在上一节中学到的知识来执行复杂的计算机视觉任务,例如视觉搜索,对象检测和神经样式迁移。 您将巩固对神经网络的理解,并使用 TensorFlow 进行许多动手的编码练习。
在本节结束之前,您将能够执行以下操作:
- 对各种神经网络模型有基本的了解,包括 AlexNet,VGG,ResNet,Inception,基于区域的 CNN(RCNN),生成对抗网络(GAN),强化学习和迁移学习(第 5 章)
- 学习一些著名模型用于图像识别和对象检测的技术(第 5 章)
- 使用 Keras 数据生成器和
tf.data将图像及其类别输入到 TensorFlow 模型中(第 6 章) - 使用迁移学习的家具图像开发 TensorFlow 模型,并使用该模型对家具图像进行视觉搜索(第 6 章)
- 对图像执行边界框标注以生成
.xml文件,并将其转换为.txt文件格式,以输入到 YOLO 对象检测器中(第 7 章) - 了解 YOLO 和 RetinaNet 的功能,并学习如何使用 YOLO 检测物体(第 7 章)
- 训练 YOLO 对象检测器并优化其参数以完成训练(第 7 章)
- 使用 TensorFlow DeepLab 执行语义分割,并编写 TensorFlow 代码以在 Google Colab 中进行神经样式迁移(第 8 章)
- 使用 DCGAN 生成人工图像,并使用 OpenCV 进行图像修复(第 8 章)
本节包括以下章节:
- “第 5 章”,“神经网络架构和模型”
- “第 6 章”,“使用迁移学习的视觉搜索”
- “第 7 章”,“使用 YOLO 的对象检测”
- “第 8 章”,“语义分割和神经样式迁移”
第 3 节:使用 TensorFlow 的计算机视觉的高级实现
在本节中,您将基于从上一节中获得的理解,并开发更新的概念并学习用于动作识别和对象检测的新技术。 在本节中,您将学习不同的 TensorFlow 工具,例如 TensorFlow Hub,TFRecord 和 TensorBoard。 您还将学习如何使用 TensorFlow 开发用于动作识别的机器学习模型。
在本节结束之前,您将能够执行以下操作:
- 理解理论并开发各种动作识别方法(例如 OpenPose,Stacked HourGlass 和 PoseNet)的直觉(第 9 章)
- 分析 OpenPose 和 Stacked HourGlass 代码,以加深对如何构建非常复杂的神经网络以及连接其不同模块的理解。 希望您可以通过这次学习来构建自己的复杂网络(第 9 章)
- 使用 TensorFlow PoseNet 通过网络摄像头进行动作识别(第 9 章)
- 了解各种类型的对象检测器,例如 SSD,R-FCN,更快的 R-CNN 和 MaskR-CNN(第 10 章)。
- 了解如何在 TFRecord 中转换图像和标注文件以输入到 TensorFlow 对象检测 API(第 10 章)
- 了解如何使用自己的图像来使用 TensorFlow 对象检测 API 训练模型并对其进行推理(第 10 章)
- 了解如何使用 TensorFlow 集线器进行对象检测以及如何使用 TensorBoard 可视化训练进度(第 10 章)
- 了解与对象检测相关的 IOU,ROI,RPN 和 ROI 对齐(第 10 章)。
- 了解如何使用 Mask R-CNN 对图像进行分割(第 10 章)
- 了解不同的 OpenCV 以及基于连体网络的对象跟踪方法,并将其用于视频文件(第 10 章)
本节包括以下章节:
- “第 9 章”,“使用多任务深度学习的动作识别”
- “第 10 章”,“使用 R-CNN,SSD 和 R-FCN 进行对象检测”
第 4 节:边缘和云端的 TensorFlow 实现
在本部分中,您将使用到目前为止获得的所有计算机视觉和 CNN 知识,在边缘设备中打包,优化和部署模型,以解决现实生活中的计算机视觉问题。 在本地计算机上训练大型数据集需要花费时间,因此您将学习如何打包数据并上传到云中的容器,然后开始训练。 您还将看到如何克服一些常见的错误以完成训练并成功生成模型。
在本节结束之前,您将能够执行以下操作:
- 了解边缘设备如何使用各种硬件加速和软件优化技术基于神经网络模型以最小的延迟进行推理(第 11 章)
- 了解 MobileNet 模型的理论,因为它的速度通常会部署在边缘设备中(第 11 章)
- 使用 Intel OpenVINO 工具包和 TensorFlow Lite 在 RaspBerry Pi 中部署神经网络模型进行对象检测(第 11 章)
- 通过在 Android Studio 和 Xcode 中使用 TensorFlow Lite 部署模型来在 Android 手机和 iPhone 上执行对象检测(第 11 章)
- 使用 Create ML 训练自定义对象检测器,并使用 Xcode 和 Swift 将其部署在 iPhone 上(第 11 章)
- 对各种云平台的基础结构有一个总体了解- Google 云平台(GCP), Amazon Web Services(AWS) ,以及 Microsoft Azure 云平台(第 12 章)
- 为使用 GCP,AWS 和 Azure 的自定义对象检测开发端到端机器学习平台(第 12 章)
- 了解如何使用 TensorFlow 进行大规模训练和打包(第 12 章)
- 使用 GCP,AWS 和 Azure 执行可视搜索(第 12 章)
本节包括以下章节:
- “第 11 章”,“通过 CPU/GPU 优化在边缘设备上进行深度学习”
- “第 12 章”,“用于计算机视觉的云计算平台”

浙公网安备 33010602011771号