TensorFlow+OpenVINO工具套件介绍_长篇

概述

目标检测（Object Detection）的任务是找出图像中所有感兴趣的目标（物体），确定它们的类别和位置，是计算机视觉领域的核心问题之一。由于各类物体有不同的外观、形状和姿态，加上成像时光照、遮挡等因素的干扰，目标检测一直是计算机视觉领域最具有挑战性的问题。目标检测分为两大系列——RCNN 系列和YOLO 系列，RCNN 系列是基于区域检测的代表性算法，YOLO 是基于区域提取的代表性算法，另外还有著名的 SSD 是基于前两个系列的改进。

R-CNN( 全称 Regions with CNN features) ，是 R-CNN 系列的第一代算法，将“深度学习”和传统的“计算机视觉”的知识相结合，Ross B. Girshick 在 2016 年提出了新的 Faster RCNN，在结构上，Faster RCNN 已经将特征抽取 (feature extraction)，proposal 提取，bounding box regression(rect refine)，classification 都整合在了一个网络中，使得综合性能有较大提高，在检测速度方面尤为明显。在本系列第一篇文章中详细介绍了 YOLOv3 目标检测算法的原理和应用，本文将主要介绍 FasterRCNN 目标检测算法。本 文 基 于 TensorFlow Object Detection API 框 架 搭 建 基 于 深 度 学 习 的 目 标 检 测 应 用 的 开 发 环 境。TensorFlow 是 Google 开源深度学习框架，可以用于机器学习、语音识别、目标检测等多种人工智能算法的开发。TensorFlow Object Detection API 是 TensorFlow 框架中专门用于目标检测应用的深度学习框架，使用该框架可以快速训练出不同种类的深度学习目标检测模型。

本文使用 TensorFlow Object Detection API 框架训练目标检测模型，使用 OpenVINO™工具套件为目标检测模型优化部署的框架，介绍了 TensorFlow Object Detection API 框架和 OpenVINO™ 工具套件的安装和使用，以及 FasterRCNN 目标检测模型训练的全部流程。并详细介绍了 OpenVINO™ Inference Engine 应用程序典型开发流程，以及怎样使用 C++ 编程语言开发 AI 推理应用程序。

1. 安装 Python 和 Anaconda

1.1 Python 和 Anaconda 简介

Python 是一种解释型高级通用编程语言，其在人工智能编码语言中发挥着至关重要的作用，人工智能领域的相关库或框架( 如 scikit-learn、Tensorflow、Caffe 以及 PaddlePaddle 等 )都是基于 Python 编程语言开发的。Python 虽然强大好用，但管理其数量庞大的第三方库，并解决其依赖关系是非常复杂的事情。

Anaconda 作为虚拟环境和 Python 库的管理工具，极大的方便了 Python 开发者管理 Python 所需要的虚拟环境和第三方库，而且解决了各种库之间的依赖关系。

1.2 下载并安装 Anaconda

首先下载并安装 Anaconda，具体步骤如下。第 一 步， 通 过 网 址 https://www.anaconda.com/products/individual 进入 Anaconda 官网，点击 Download 进入下载界面，根据需求选择合适的下载文件，如图 1-2 所示。

第二步， 找 到 Anaconda 下 载 文 件 Anaconda3-2020.11-Windowns-x86_64.exe 并双击安装，进入用户选项界面默认选择 Just Me，再点击 Next> 按钮，如图 1-3 所示。

第三步，设置安装路径，尽量保持默认路径，然后点击 Next>按钮安装，如图 1-4 所示。

第四步，进入高级安装选项设置，一定要勾选 Add Anaconda3to my PATH environment variable，将 Anaconda3 的路径添加到环境变量中，然后点击 Install 按钮，Anaconda 安装完成，如图 1-5 所示。

1.3 测试 Anaconda 安装

全部安装完毕后，在 Windows“开始”菜单中选择 AnacondaNavigator ， 进 入 主 界 后 点 击 Environments 选 项 卡， 如下图 1-6 所示可以看到当前的 Anaconda 默认虚拟环境是
base(root)，单击 base(root) 右侧的绿色箭头，在弹出的菜单中选择 Open with Python。

在 弹 出 Windows 命 令 行 窗 口 中， 输 入 代 码 <print(“helloworld!”)>，得到如下图 1-7 的结果证明 Anaconda 和 Python全部安装成功。

2. 安装 Visual Studio Code

2.1 Visual Studio Code 简介

Visual Studio Code 是微软公司的一款开源免费跨平台代码编 辑 器， 其 具 有 丰 富 的 其 他 语 言 ( 例 如 C++，C#，Java，Python，PHP，Go) 和运行时 ( 例如 .NET 和 Unity) 扩展的生态系统。Visual Studio Code 具有语法高亮、代码补全以及多插件支持等功能，本文将以 Visual Studio Code 作为 Python代码的集成开发环境。

2.2 Visual Studio Code 安装

下载并安装 Visual Studio Code 的具体步骤如下。第一步，通过网址 https://code.visualstudio.com 进入 VisualStudio Code 官 网， 点 击 Download for Windows 进 入下 载 界 面， 根 据 需 求 选 择 合 适 的 下 载 文 件， 本 文 章 使 用VSCodeUserSetup-x64-1.55.2 版本 , 如图 2-1 所示。

第二步，找到 VSCodeUserSetup-x64-1.55.2 下载文件双击安装，在许可协议界面勾选我同意此协议 (A)，点击“下一步 (N)>”按钮到安装路径界面，在安装路径设置界面，尽量保持默认设置，然后再点击“下一步 (N)>”按钮，如图 2-2 所示。

第三步，默认选择开始文件夹菜单后，点击“下一步 (N)>”按钮进入安装高级选项界面，勾选“添加到 PATH( 重启后生效 )”复选 框， 添 加 Visual Studio Code 路 径 到 Windows PATH 环境变量，之后点击“下一步 (N)>”按钮，再点击“安装”按钮完成Visual Studio Code 安装，如图 2-3 所示。

2.3 Visual Studio Code 配置

2.3.1 安装插件
启动 Visual Studio Code，点击左侧网格图标，在输入栏中输入 Python，在弹出的菜单中选择 Python，再选择 Install 按钮，如图 2-4 安装 Python 插件所示，完成 Python 插件的安装，同样步骤可完成 Python Path 插件、Chinese 中文插件的安装。

2.3.2 关联 Anaconda
启动 Visual Studio Code，在 File 菜单中选择 Preferences，在 弹 出 的 菜 单 中 选 择 Settings， 在 搜 索 栏 search settings中 输 入 Python.PythonPath, 在 下 方 的 方 框 中 输 入 安 装 的Anaconda 路径，如图 2-5 所示。

2.3.3 在 Visual Studio Code 中运行 Python 代码
启 动 Visual Studio Code， 在 File 菜 单 中 选 择 New File，新建代码文件。由于 Visual Studio Code 当前不清楚新建文件的类别，所以此时文件名默认为 Unititled-1。输入代码
<print(“hello world!”)>，在 File 菜单中选择 Save 选项，在弹出的弹框中修改文件名为 test 后，在“保存类型（T）”中选择Python，本文中的文件既保存成文件名为 test.py 的 Python源代码文件，点击主界面右上角的绿色箭头，或者按下快捷键<Ctro+F5> 即可运行 Python 代码。

3. 安装 TensorFlow Object DetectionAPI 框架

3.1 TensorFlow 简介

TensorFlow 是一个免费的软件库，专注于由 Google 创建的机器学习。TensorFlow 最初作为 Apache 2.0 开源许可证的一部分发布，最初由 Google 大脑团队的工程师和研究人员开发，主要供内部使用。TensorFlow 被认为是首次认真实施以深度学习为重点的框架。

TensorFlow 是 一 个 端 到 端 的 平 台， 无 论 是 专 家 还 是 初 学者，都可以轻松的构建和部署深度学习模型。到目前为止，TensorFlow 是最流行的机器学习平台，社区参与人数最多、最活跃、演进也越快。如图 3-1 所示。

3.2 TensorFlow Object Detection API 框架 简介

TensorFlow Object Detection API 是一个在 TensorFlow 框架基础上开发出来的，应用于计算机视觉领域，实现图像中的检测并定位多个目标物体的软件框架。如图 3-2 示，基于TensorFlow Object Detection API 开源软件框架，开发者可以快速创建、训练和部署目标检测模型。

3.3 下载并安装

3.3.1 下载 TensorFlow 代码库
TensorFlow Object Detection API 的下载安装步骤如下：第一步，新建一个 tf_train（文件夹的名字可按照个人喜好来取）文件夹用于 TensorFlow 训练，在 tf_train 文件夹下，分别创建 addons 和 workspaces 文件夹，addons 文件夹用存放附加组件或着 cocoapi 等其它软件工具，workspaces 文件夹用于存放每个具体项目的文件。第二步，在 tf_train 文件夹的空白处单击右键，在右键的菜单中点击“Git Bash Here”，启动 Git Hish 中输入 git clone 命令：git clone https://github.com/tensorflow/models.git 下 载TensorFlow models 代码库，如图 3-3 所示。

3.3.2 编译 proto 文件
第一步，编译 proto 文件。从网址 https://github.com/protocolbuffers/protobuf/releases 中下载最新版的 ProtocolBuffers工具，本文下载的版本为 protoc-3.17.3-win64。解压后放入
C:\Program Files 文件下，把 protoc 文件的 bin 文件路径加入到 Path 环境变量中。如图 3-4 所示。

第二步，进入 models\research 文件夹，在文件夹地址栏中输入 cmd，启动 Windows 命令行终端，通过命令 activatetensorflow 激 活 tensorflow 虚 拟 环 境。 输 入 命 令：protocobject_detection\protos*.proto –python_out=. 完 成 对proto 文件的编译。如图 3-5 所示。

3.3.3 运行 setup.py 文件完成安装
运行 setup.py 文件完成安装的步骤如下：第一步，修改 visualization_utils.py 文件。在 models\research\object_detection\utils 文件夹下打开 visualization_utils.py文 件， 将 第 29 行 import matplotlib;matplotlib.use(‘Agg’)注释掉，如图 3-6 所示。

第 二 步， 运 行 setup.py 文 件 完 成 安 装。 首 先 将 models\research\object_detection\packages\tf2\setup.py 文 件 复制 到 models\research 文 件 夹 下， 最 后 运 行 命 令：python-m pip install. , 完成 TensorFlow Object Detection API 的安装。如图 3-7 所示。

3.4 安装 CUDA 和 cuDNN 库

安装 CUDA 和 cuDNN 库的步骤如下：
第 一 步， 进 入 D:\tf_train\models\research 文 件 路 径 的 命令 行 终 端， 激 活 tensorflow 虚 拟 环 境， 输 入 命 令：condainstall cudatoolkit=11.0 完成 CUDA 的安装。如图 3-8 所示。

第二步，本文的 anaconda 服务器上没有 cudnn=8.0.4，无法 cudnn=8.0.4 一键安装，需要手动下载 cudnn=8.0.4，并复制安装。

进入网址 https://developer.nvidia.com/rdp/cudnn-archive下载 cudnn-11.0-windows-x64-v8.0.4.30, 解压后把 cuda\bin 文件夹中所有的 dll 文件复制到 tensorflow 虚拟环境的Labrary\bin 文件夹下，完成 cudnn8.0.4 的安装，如图 3-9所示。

3.5 安装 COCO API

在训练过程中，使用 COCO API 评估指标，安装 COCO API的具体步骤如下：
第一步，在 tf_train\addons 文件夹空白处右键单击，点击Git Bash Here，启动 Git Bash 输入命令：git clone https://github.com/philferriere/cocoapi.git，下载 cocoapi 源代码，
如图 3-10 所示。

第二步，在任务栏中搜索“Anaconda Prompt(Anaconda3)”,右 键 单 击 并 以 管 理 员 身 份 运 行， 如 图 3-11 所 示。 启 动Anaconda 命令行终端 。

第 三 步， 在 Anaconda 管 理 员 命 令 行 终 端 激 活 tensorflow虚拟环境，输入命令 d: 进入 D 盘，输入命令 cd D:\tf_train\addons\cocoapi\PythonAPI 进入 PythonAPI 文件夹，最后输入命令：python setup.py install 完成 COCO API 的安装，如图 3-12 所示。

第四步，验证 COCO API 的安装，在命令行终端输入 python进入 python 解释器，输入语句“import pycocotools”，如果import 成功如图 3-13 所示，证明 COCO API 安装成功。

3.6 测试安装

进入 D:\tf_train\models\research 路径的 Windows 命令行终端，激活 tensorflow 虚拟环境。输入测试安装命令：pythonobject_detection\builder\model_builder_tf2_test.py ， 如
果出现如图 3-14 所示信息，则证明安装成功。

4. 训练模型

本章节基于猫狗数据集，使用 TensorFlow Object DetectionAPI 框架和 TensorFlow 2 Detection Model Zoo 中的预训练模型，完成猫狗数据集目标检测模型的训练。

4.1 使用 TensorFlow 预训练模型

4.1.1 选择预训练模型
TensorFlow Models Zoo 提 供 多 个 在 coco 数 据 集 上 完成 训 练 的 目 标 检 测 模 型， 可 以 进 入 网 址：https://github.com/tensorflow/models/blob/master/research/object_
detection/g3doc/tf2_detection_zoo.md 自行下载需要的预训练模型，如图 4-1 所示。

4.1.2 预训练模型的文件构成
本 文 以 下 载 faster_rcnn_resnet50_v1_640*640_coco17_tpu-8 模型为例，模型下载解压后，得到如图 4-2 所示多个文件。

Checkpoint 文 件 夹 中 包 含 TensorFlow 的 检 查 点 文 件，Saved_model 文件夹中包含以 SavedModel 格式存储的模型架构与参数，pipeline.config 是文本格式的模型配置文件，在进行迁移学习配置模型文件时需要修改其内部参数。

4.1.3 一个典型的深度学习模型训练流程
一个典型的深度学习应用模型训练流程为，准备数据集，标注数据集，训练模型，导出模型四个步骤，如图 4-3 所示，本文根据四个步骤详细介绍深度学习模型的训练流程。

4.2 准备猫狗数据集

4.2.1 Kaggle 猫狗数据集下载
本文从 Kaggle 直接下载猫狗数据集，下载步骤如下。
首 先 点 击 地 址：
https://www.kaggle.com/account/login?phase=startSignInTab&returnUrl=%2F。
进 入 Kaggle 账 户注册页，根据提示注册账户。完成注册后，直接进入地址：
https://www.kaggle.com/c/dogs-vs-cats-redux-kernelsedition/data。
如图 4-4 所示，进入猫狗数据集下载界面，点击 Download All 下载全部数据集。

4.2.2 建立猫狗数据集文件夹结构
在对数据集进行标注之前，在 D:\tf_train\workspaces 文件夹下创建一个 cats_dogs 文件夹，在其基础上依次建立如图 4-5所示猫狗项目文件夹目录结构。

Cats_dogs 文件夹下的依次新建文件夹的作用如下：
● annotations 文件夹：用于存放标签映射文件和生成的 TFR-
ecord 文件。
● backup 文件夹：用于存放备份文件和项目。
● exported_model 文件夹：用于存放生成的 saved_model
格式模型文件。
● images 文件夹：其中有 eval、test、train 三个子文件夹，
分别用来存放评估图片、测试图片和训练图片。
● inference 文件夹：用来存放用于 OpenVINO™ 推理的文件。
● IR_model 文件夹：用于存放使用 OpenVINO™ 模型优化器
转化后的 IR 文件。
● Pre_trained_model 文件夹：用于存放预训练模型。
● training 文件夹：用于存放训练配置文件 pipeline.config,
以及训练过程中产生的检查点 (checkpoint) 文件。

4.3 使用 LabelImg 标注猫狗数据集

4.3.1 标注文件
第一步，打开虚拟环境 tensorflow 的 Open Terminal，进入Windows 命令行窗口输入命令命令 安装 Labelimg, 安装结果如图 4-6 所示：

第二步，启动 Labelimg，打开 Anaconda 虚拟环境 tensorflow的 Open Terminal， 进 入 Windows 命 令 行 窗 口 输 入 命 令 即可启动 Labelimg，点击左侧 Open Dir，选择需要标注的图像所在的文件夹 (D:\tf_train\workspaces\cats_dogs\images\train) 打开。本文选择 Kaggle 猫狗数据集的猫狗各 100 张共 200 张图片，放 在 D:\tf_train\workspaces\cats_dogs\images\train 文 件夹内。在右下角的 File List 对话框中会显示文件夹中所可以遍历的图像，进行遍历工作。在标记目标图片时右键单击图片，点击 Create RectBox 打开矩形框标注工具，如图 4-7 所示。

第三步，使用拖拉的方式，用矩形框对目标物体进行标注，在弹出的对话框里写明对应的 label( 当 label 已存在时，直接点击即可，注意 label 名字不要使用中文 )，如下图 4-8 所示，标注完毕后再点击左侧的 Save，将标注后的 .xml 文件依然保 存 在 D:\tf_train\workspaces\cats_dogs\images\train 路径中。

4.3.2 复制 10% 的数据到 eval 文件夹
在深度学习中，一般将数据集分为训练集、测试集和验证集。在模型的训练过程中使用训练集和验证集，比例一般为 7：3或者 8：2，由于本文使用的数据集数量不多，所以本文选择训练集和验证机的比例为 9：1. 即从 train 文件夹中将标注好的文件和原文件复制十分之一到 eval 文件夹。如图 4-9 所示。

4.3.3 复制数据到 test 文件夹
test 文件夹中的数据，作为执行推理计算时使用，所以无需标注。即从猫狗数据集中复制 20 张 jpg 图片到 test 文件夹，如图 4-10 所示。

4.4 依据标注类型创建标签映射文件

标注图片结束后，需要根据标注文件的标签类型创建标签映射文件：label_map.pbtxt, 创建标签映射文件的代码如代码清单4-1 所示：

其中，每个标注类型对应一个 item 项，每个项有两个属性，id 和 name。id 是整形数据本文标签有猫和狗两个类型，id的编号便从 1 到 2。name 是字符串，方便阅读，本文类型为猫和狗 2 类，则 neme 分别问‘cat’和‘dog’。

4.5 创建 TensorFlow TFRecord 文件

TFRecord格式文件是向TensorFlow模型输入数据速度最快，效率最高的格式文件。TensorFlow 的很多处理机制，根据TFRecord 做的处理优化。创建 TFRecord 格式文件的具体步骤为：
第一步，从本文提供的 generate_tfrecord.py 文件，保存到tf_train\scripts 路径下，进入其路径下的命令行终端，通过命令 激活 tensorflow 虚拟环境。
第二步，使用 generate_tfrecord.py 脚本生成 *.tfrecord 格式文件 .
生成 train.tfrecord 文件的命令为 :
<python generate_tfrecord.py -x …\workspaces\cats_
dogs\images\train -l …\workspaces\cats_dogs
annotations\label_map.pbtxt -o …\workspaces\cats_
dogs\annotations\train.tfrecord>
生成 eval.tfrecord 文件的命令为 :
<python generate_tfrecord.py -x …\workspaces\cats_
dogs\images\eval -l …\workspaces\cats_dogs
annotations\label_map.pbtxt -o …\workspaces\cats_
dogs\annotations\eval.tfrecord>
运行结果如图 4-11 所示。

4.6 修改预训练模型的配置文件

TensorFlow Object Detection API 框架使用 training.pipeline配置文件获得训练和评估过程中的参数。
4.6.1 预训练模型的配置文件
将本文 5.1.2 节中下载的 faster_rcnn_resnet50_v1_640*640_coco17_tpu-8 预训练模型，解压后再其文件夹内，可以看到一个 pipeline.config 文件，在 D:\tf_train\workspaces\cats_dogs\training 文件夹中新建一个 my_faster_rcnn 文件，将
预训练模型的 pipeline.config 文件复制到 my_faster_rcnn 文件夹内，如图 4-12 所示。

4.6.2 修改 pipeline.config 配置文件
修改 pipeline.config 配置文件的步骤如下：
第一步，将 num_class 对应的数值修改为 num_class:2 。其数值与标注类型的数量相同，本文只有猫和狗两种标注类型，故设置为 2。如图 4-13 所示。

第二步，将 batch_size 对应的数值修改为 batch_size:2。该参数大小根据现存来调整其大小，本文设置为 2。如图 5-14所示。

第三步，将 num_steps 对应的数值修改为 2000，建议修改为 2000，可根据 Loss 调整 num_stamps, 如果 Loss 值过大，可适当增加 num_steps 的值。如图 4-14 所示。

第四步，配置 fine_tune_checkpoint 的路径，将预训练模型的 checkpoint 文件的路径配置 fine_tune_checkpoint，如图4-15 所示。

第 五 步， 配 置 fine_tune_checkpoint_type, 将 其 类 型 改 为‘detection’。如图 5-15 所示。

第 六 步， 配 置 label_map_path 路 径， 将 label_map.pbtxt的路径配置到 label_map_path。

第七步，配置 input_path 路径，将 train.tfrecord 的路径配置到 input_path，如图 4-16 所示。

第八步，配置 label_map_path 路径，将 label_map.pbtxt 的路径配置到 label_map_path。

第九步，配置 input_path 路径，将 eval.tfrecord 的路径配置到 input_path，如图 4-17 所示。

以上共使用 9 个步骤完成 pipeline.config 配置文件的修改工作。

4.7 训练模型

配置完毕 pipeline.config 文件后，训练模型的具体步骤如下：
第一步，在路径 D:\tf_train\models\research\object_detection文 件 夹 中， 把 model_main_tf2.py 文 件 复 制 到 D:\tf_train\workspaces\cats_dogs 路径下。

第二步，进入 D:\tf_train\workspaces\cats_dogs 路径下的命令行终端，激活 tensorflow 虚拟环境，输入命令 <pythonmodel_main_tf2.py --model_dir=training\my_faster_rcnn --pipeline_ config_path=training\my_faster_rcnn\pipeline.config> 启动训练，如图 4-18 所示。

如果启动训练成功，则会获得如图 4-19 所示信息显示结果：

4.8 导出 SavedModel 模型

在训练的过程中会产生一系列如所示的 checkpoint 文件，在训练模型过程中，所涉及到的参数和权重值，全部记录在检查点文件中。但是检查点文件没有关于模型计算的源代码。所以在模型推理计算阶段，需要将 checkpoint 文件和模型计算的描述一起打包成可以部署的 SavedModel 格式。从训练获得的检查点文件导出 SavedModel 格式模型的步骤如下：
第一步，从路径 D:\tf_train\models\research\object_detection文件夹中，将 exporter_main_v2.py 文件复制到 D:\tf_train\workspaces\cats_dogs 路径下。

第二步，进入 D:\tf_train\workspaces\cats_dogs 路径下的命 令行 终 端， 激 活 tensorflow 虚 拟 环 境， 输 入 命 令 < pythonexporter_main_v2.py --input_type image_tensor–pipeline_config_path training\my_faster_rcnn\pipeline.config --trained_checkpoint_dir training\my_faster_rcnn–output_directory exported_model\my_faster_rcnn > 导出 SavedModel 模型，如图 4-20 所示。

在 D:\tf_train\workspaces\cats_dogs\exported_model\my_faster_rcnn\saved_model 路 径 中 生 成 的 SavedModel文件夹如图 4-21 所示：

4.9 用 SavedModel 格式模型执行推理计算

生成 SavedModel 后即可执行推理计算，具体步骤为：
第一步，将本文附带的 object_detection_example_2.py 文
件下载并存放到 D:\tf_train\workspaces\cats_dogs 路径下。
第二步，打开 object_detection_example_2.py 文件，根据实际路径情况修改 PATH_TO_IMAGES_DIR,PATH_TO_SAVED_MODEL,PATH_TO_LABELS 三处，如图 4-22 所示。

第三步，在 D:\tf_train\workspaces\cats_dogs 路径的命令行终端启动 tensorflow 虚拟环境，输入命令

5. 使用 OpenVINO™ 工具套件部署

5.1 OpenVINO™ 工具套件简介

OpenVINO™ 工 具 套 件 全 称 是 Open Visual Inference &Neural Network Optimization，是英特尔® 于 2018 年发布的开源工具包，专注于优化神经网络推理。OpenVINO™ 工具套件主要包括 Model Optimizer( 模型优化器 ) 和 InferenceEngine( 推理引擎 ) 两个部分。Model Optimizer 是用于优化神经网络模型的工具，Inference Engine 是用于加速推理计算的软件包。如图 5-1 所示，即为 OpenVINO™ 工具套件的主要组成部分。

5.2 OpenVINO™ 工具套件安装

5.2.1 OpenVINO™ 工具套件下载和安装
下载并安装 OpenVINO™ 工具套件的具体步骤如下。第一步，通过网址 https://software.intel.com/content/www/us/en/develop/tools/openvino-toolkit/download.html 进文选择 2021.4 版本的 OpenVINO™ 工具套件，按照如图 5-2所示选择，再点击 Download 按钮即可下载 OpenVINO™ 工具套件 2021.4 版本的安装程序。

第二步，找到 OpenVINO™ 工具套件的安装文件 w_openvino_toolkit_p_2021.4.582.exe，双击下载安装，安装步骤全部默认安装即可，如图 5-3 所示。

第三步，安装过程中会有 CMake 和 Mircrosoft Visual Studio 依赖软件安装的提示，下面我们继续安装 CMake 和 MircrosoftVisual Studio 软件，如图 5-4 所示。

5.2.2 CMake 下载和安装
CMake 作 为 一 个 跨 平 台 的 C/C++ 程 序 编 译 开 源 配 置 工具， 在 OpenVINO™ 工 具 套 件 的 应 用 中，CMake 用 来 管 理OpenVINO™ 工 具 套 件 中 的 演 示 程 序 (Demos) 和 范 例 程 序(Samples)。

下载并安装 Cmake 的步骤如下所示。
第一步，通过网址 https://cmake.org/download/ 进入 CMake官 网 下 载 界 面， 下 载 安 装 文 件， 选 择 的 CMake 版 本 大 于等 于 3.4 版 本 即 可， 本 文 的 版 本 选 择 为 cmake-3.20.2-windows-x86_64.msi，如图 5-5 所示。

第二步，双击安装文件，默认选项完成安装，在 Install Options页面选择 Add Cmake to the system PATH for all users 将CMake 添加到系统变量 PATH 中。如图 5-6 所示。

5.2.3 Mircrosoft Visual Studio 下载和安装
OpenVINO™ 工具套件支持 Mircrosoft Visual Studio 2015、2017 和 2019。由于 Mircrosoft Visual Studio 2017 是目前Windows 操作系统下应用最广泛的 C++ IDE，本文选择使用Mircrosoft Visual Studio 2017 版本。Mircrosoft Visual Studio 2017 安装步骤如下 :第 一 步， 通 过 网 址 https://visualstudio.microsoft.com/zhhans/vs/older-downloads/ 进 入 Mircrosoft Visual Studio旧版本下载地址，单击 2017，在展开的下载选项中点击“下载”按钮进入 Mircrosoft Visual Studio 2017 下载页面，在左侧选择 Visual Studio 2017(version 15.9), 在右侧的选择页面中选 择 Visual Studio Community 2017(version 15.9)， 单 击Download 下载，如图 5-7 所示。

第二步，找到安装文件双击打开，在安装配置中选择“.NET 桌面开发”、“使用 C++ 的桌面开发”、“通用 Windows 平台开发”三个选项后，再选择右下角的“安装”按钮开始安装，如图 5-8所示。

6. 使用 OpenVINO™ 工具套件部署 FasterRCNN 模型

6.1 使用 Model_Optimizer 优化模型

Model_Optimizer 工 具 是 OpenVINO™ 工 具 套 件 中 用 于 深度学习优化的 Python 脚本，支持从各种深度学习框架导入训练后的模型，并将其转换为 IR 格式文件。在本文中，将TensorFlow Object Detection API 模型转换为 IR 格式文件的
具体步骤如下：
第一步，进入 C:\Program Files (x86)\Intel\openvino_2021.4.582\deployment_tools\model_optimizer 路 径 下 命 令 行 终
端， 启 动 tensorflow 虚 拟 环 境。 输 入 命 令

6.2 Inference Engine 应用程序典型开发流程

Inference Engine 典型的开发流程一共有八步，每一步都对应着相应的 C++ API，如图 6-4 所示：

● 初始化 IECore 实例：使用 Inference Engine::Core core; 初始化 Core 对象，管理可用设备和读取网络对象，同时输 出版本信息
● 读入一个 IR(ONNX) 模型：将 IR 模型或 ONNX 模 型 读入InferenceEngine::CNNNetwork 类的对象中
● 配置输入和输出：将模型载入内存后，使用 InferenceEngine::CNNNetWork::getInputsInfo()和 InferenceEngine::CNNNetwork::getOutputsInfo() 方法请求输入和输出
● 将网络加载到设备：使用 InferenceEngine::Core::LoadNe twork() 将模型加载到设备，载入的硬件由 LoadNetwork() 方法的 DEVICE 参数决定
● 创建推理请求：模型载入 AI 计算硬件后，会获得一个 InferenceEngine::ExecutableNetwork 对象，使用该对象创建一个InferenceEngine::InferRequest 对象，用于执行 AI 推理计算
● 输入数据：使用 InferenceEngine::InferRequest::GetBl ob() 获取由推断请求分配的 Blob，并将图像和数据提供给 blob
● 执行推理：第八步，执行推理计算，使用 InferenceEngine ::InferRequest::Infer 方法进行同步请求，或者使用 Inferen ceEngine::InferRequest::StartAsync 和 InferenceEngine::
InferRequst::Wait 方法进行异步请求推理
● 输出结果：通过 buffer() 和 as() 方法访问数据，使用 Infere
nceEngine::InferRequest::GetBlob()方法获得推理计算结果。

6.3 编写 OpenVINO™ AI 推理计算 C++ 范例

本节将基于 7.1 节生成的 IR 文件 saved_model.xml 和 saved_model.bin, 从零开始，实现完整的 OpenVINO™ AI 推理计算C++ 程序。
6.3.1 设置环境变量和 Visual Studio 项目属性
在开发 AI 推理计算应用程序前，首先应该完成 Visual Studio项目属性和环境变量的配置，具体步骤如下：
第一步，首先设置环境变量，保证在进行模型部署推理时，能找到 Inference Engine 和 OpenCV 库，如图 6-5 所示：

第二步，打开 Visual Studio 2017，在起始页左上角依次点击“文件”—“新建”—“项目”选项，新建项目。在弹出的“新建项目”对话框中，新建一个 C++ Windows 桌面项目，再选择“控制台应用”，本文将项目名称设置为“cats_dogs”, 如图 6-6 所示：

第三步，右键单击项目名称 cas_dogs，单击弹框最下方的“属性”按键，启动 cats_dogs 属性对话框，在属性对话框中选择“C++”—“常规”，本文选择 Release 配置，由于 Inference Engine 和OpenCV 函数库都是 64 位的，所以将“平台 §”配置为“x64”，然后在“附加包含目录”，输入如图 6-7 所示的路径，然后单击“确定”，配置附加包含目录。

第四步，配置附加库目录，在 cats_dogs 属性页对话框中点击“链接器”—“常规”，在“附加库目录”中，配置如下路径，如图 6-8所示。

第 五 步， 配 置 附 加 依 赖 项， 在“cats_dogs” 属 性 页 对 话 框中，点击“链接器”—“输入”，在附加依赖项中添加 opencv_
calib3d453.lib;opencv_core453.lib;opencv_dnn453.
lib;opencv_features2d453.lib;opencv_flann453.
lib;opencv_gapi453.lib;opencv_highgui453.lib;opencv_
imgcodecs453.lib;opencv_imgproc453.lib;opencv_
ml453.lib;opencv_objdetect453.lib;opencv_photo453.
lib;opencv_stitching453.lib;opencv_video453.
lib;opencv_videoio453.lib;C:\Program Files (x86)\Intel
openvino_2021.4.582\inference_engine\lib\intel64
Release\inference_engine.lib,
如图 6-9 所示。然后单击“确定”按钮，即完成 Visual Studio 的属性配置。

6.3.2 开发 AI 推理计算 C++ 应用程序
在成功配置环境变量和项目属性后，使用 C++ 编程语言开发OpenVINO™ 推理应用程序。
第一步，在执行 main() 函数之前引入相应库函数，配置推理计算设备，IR 文件路径，媒体文件路径，如代码清单 6-1 所示：代码清单 6-1 引入相应库和配置路径
#include
#include <inference_engine.hpp>
#include <opencv2/opencv.hpp>
#include <utils/ocv_common.hpp>
using namespace InferenceEngine;
std::string DEVICE = “CPU”;
std::string MODEL_FILE = “saved_model.xml”;
std::string IMAGE_FILE = “images/test/3.jpg”;
其中，各头文件的用途如下：
● , 定义了标准的输入输出流对象。
● <inference_engine.hpp>Inference Engine 库，定义和实现 Inference Engine 的类、方法以及函数。
● <opencv2/opencv.hpp>OpenCV 库，包含 OpenCV 各个模块的头文件
● <utils/ocv_common.hpp> 包含了 OpenCV Mat 对象图像数据转换为 OpenVINO™ Blob 对象图像数据的工具函数 matU8ToBlob。
第二步：使用 Inference Engine::Core core; 初始化 Core 对象，管理可用设备和读取网络对象，同时输出版本信息，如代码清单 6-2 所示。
代码清单 6-2 初始化 Core 对象
int main()
{
// ----- Step 1. 初始化 Core 对象 --------
// -------------------------------------
std::cout << “Step 1. Initialize inference engine Core.” <<
std::endl;
Core core;
// 输出 IE 版本信息
auto v = core.GetVersions(DEVICE)[DEVICE];
std::cout << "Build Number: " << v.buildNumber <<
std::endl;
std::cout << "Description: " << v.description << “; IE_
Version:” << IE_VERSION_MAJOR << “.” << IE_VERSION_
MINOR << “.” << IE_VERSION_PATCH << std::endl;
第三步，使用读取 IR 模型 ( 支持 .xml 格式 ) 或 ONNX 模型 ( 支
持 .onnx 和 .prototxt 格式 )，将 IR 模型或 ONNX 模型读入
InferenceEngine::CNNNetwork 类的对象中去。如代码清单
6-3 所示：
代码清单 6-3 读入 IR 模型或 ONNX 模型
// ----- Step 2. 读取 IR 模型 或 ONNX 模型 ------
// -------------------------------------------
std::cout << “Step 2. Read a IR or ONNX model.” <<
std::endl;
CNNNetwork network = core.ReadNetwork(MODEL_FILE);
第四步，配置模型输入和输出，将模型载入内存后，使用 InferenceEngine::CNNNetWork::getInputsInfo() 和 InferenceEngine::CNNNetwork::getOutputsInfo() 方法请求输入和输出，
如代码清单 6-4 所示：
代码清单 6-4 配置输入和输出
// ----- Step 3. 配置模型输入 & 输出 ----------------
// ------------------------------------------------
// 参 考 资 料：https://docs.openvinotoolkit.org/latest/
openvino_docs_IE_DG_Integrate_with_customer_
application_new_API.html
std::cout << “Step 3. Configure input & output.” <<
std::endl;
// 获得网络输入信息 ( 键值对 )
InferenceEngine::InputsDataMap inputs_info = network.
getInputsInfo();
// 获得网络输出信息 ( 键值对 )
InferenceEngine::OutputsDataMap output_info = network.
getOutputsInfo();
std::string image_info_name = “”;
// 存储 image_info 的名字
std::string input_tensor_name = “”;
// 存储 input_tensor 的名字
auto item = inputs_info.begin();
image_info_name = item->first;
// 获取 image_info 输入的名字
auto image_info_ptr = item->second;
// 获取 image_info 输入的指针
item++;
input_tensor_name = item->first;
// 获取 input_tensor 输入的名字
auto input_tensor_ptr = item->second;
// 获取 input_tensor 输入的指针
std::cout << “image_info_name:” << image_info_name << “;
input_tensor_name:” << input_tensor_name << std::endl;
// 配置 input_tensor 输入：U8,NCHW, 保持默认的禁止自动放缩输入图像和禁止自动转换颜色通道
input_tensor_ptr->setPrecision(InferenceEngine::Precision::U8);
// U8 最 通 用 , 参 考 资 料：https://docs.openvinotoolkit.
org/latest/openvino_docs_IE_DG_supported_plugins_
Supported_Devices.html
input_tensor_ptr->setLayout(InferenceEngine::Layout::NC
HW);
第五步，使用 InferenceEngine::Core::LoadNetwork() 将模型加载到设备，载入的硬件由 LoadNetwork() 方法的 DEVICE参数决定。如代码清单 6-5 所示：
代码清单 6-5 载入模型到硬件
// ----- Step 4. 载入模型到执行硬件 ----------
// -------------------------------------------
std::cout << “Step 4.Loading model to the device.” <<
std::endl;
ExecutableNetwork executable_network = core.
LoadNetwork(network, DEVICE);
第六步，创建推理请求，模型载入 AI 计算硬件后，会获得一个InferenceEngine::ExecutableNetwork 对象，使用该对象创建一个 InferenceEngine::InferRequest 对象，用于执行 AI推理计算。如代码清单 6-6 所示：
代码清单 6-6 创建推理请求
// ----- Step 5. 创建推理请求 ----------------
// -------------------------------------------
std::cout << “Step 5.Create infer request.” << std::endl;
InferRequest infer_request = executable_network.CreateInferRequest();
第七步，准备输入数据，使用 InferenceEngine::InferRequest::GetBlob() 获取由推断请求分配的 Blob，并将图像和数据提供给 blob。在这种情况下，输入的数据必须与给定的 blob 大小对其（手动调整大小）以及正确的颜色格式。如代码清单 6-7
所示：
代码清单 6-7 准备输入数据
// ----- Step 6. 准备输入数据 ----------------
// -------------------------------------------
std::cout << “Step 6.Prepare input data.” << std::endl;
/* 读取图片 /
cv::Mat image = cv::imread(IMAGE_FILE);
/ 记录图片原始 H，W /
auto original_height = image.rows;
auto original_width = image.cols;
/ 获得模型的 input_tensor 输入的数据缓冲 /
Blob: :Ptr input_tensor_blob = infer_request.
GetBlob(input_tensor_name);
/ 将 OpenCV Mat 数据填入模型的 input_tensor 输入的数据缓冲 /
matU8ToBlob<uint8_t>(image, input_tensor_blob);
/ 获得模型的 image_info 输入的数据缓冲 /
Blob::Ptr image_info_blob = infer_request.GetBlob(image_info_name);
/* 向模型的 image_info 输入的数据缓冲填入数据 : height,width, scale=1.0 */
LockedMemory blobMapped = as(image_info_blob)->wmap();
auto data = blobMapped.as<float>();
data[0] = static_cast(input_tensor_ptr-

getTensorDesc().getDims()[2]); // 填入 height
data[1] = static_cast(input_tensor_ptr-
getTensorDesc().getDims()[3]); // 填入 width
data[2] = 1.0f; // 填入 Scale = 1.0
第八步，执行推理计算，使用 InferenceEngine::InferReques
t::Infer 方法进行同步请求，或者使用 InferenceEngine::Infer
Request::StartAsync 和 InferenceEngine::InferRequst::Wait
方法进行异步请求推理，本文使用同步推理方法，如代码清单
6-8 所示：
代码清单 6-8 执行推理计算
// ----- step 7. 执行推理计算 ----------------
// -------------------------------------------
std::cout << “step 7.do inference…” << std::endl;
infer_request.Infer();
第九步，处理推理计算结果，查看输出 blob 并处理结果。请
注意，不推荐通过 std::dynamic_pointer_cast 将 Blob 转换
为 TBlob。最好通过 buffer() 和 as() 方法访问数据。如代码清
单 6-9 所示 :
代码清单 6-9 处理推理计算结果
// ----- Step 8. 处理推理计算结果 ------------
// -------------------------------------------
std::cout << “Step 8.Process the results of inference…” <<
std::endl;
auto output_item = output_info.begin();
std::string output_name = output_item->first;
// 获取模型输出的名字
std::cout << “output_name:” << output_name << std::endl;
auto output_blob = infer_request.GetBlob(output_name);
// 获取模型输出的缓冲区
const float* detections = output_blob->buffer().as<Precisi
onTraitPrecision::FP32::value_type*>();
size_t max_proposal_count = output_blob->getTensorDesc().
getDims()[2];
size_t proposal_size = output_blob->getTensorDesc().
getDims()[3];
std::cout << “max_proposal_count:” << max_proposal_
count << “; proposal_size:” << proposal_size << std::endl;
/* 每个检测结果的格式为 : [image_id, label, conf, x_min, y_
min, x_max, y_max] */
for (size_t i = 0; i < max_proposal_count; i++) {
int label = static_cast(detections[i * proposal_size +
1]);
float conf = detections[i * proposal_size + 2];
float x_min = detections[i * proposal_size + 3] * original_
width; // 将比例值还原为图片像素坐标
float y_min = detections[i * proposal_size + 4] * original_
height;
float x_max = detections[i * proposal_size + 5] * original_
width;
float y_max = detections[i * proposal_size + 6] * original_
height;
if (conf > 0.85) {
std::ostringstream confidence;
confidence << “conf:” << std::fixed << std::setprecision(3)
<< conf;
cv::putText(image, confidence.str(), cv::Point2f(x_min,
y_min - 5), cv::FONT_HERSHEY_COMPLEX_SMALL, 1,
cv::Scalar(0, 0, 255));
cv::rectangle(image, cv::Point2f(x_min, y _min),
cv::Point2f(x_max, y_max), cv::Scalar(0, 0, 255));
}
}
std:: cout<< “Infer done!” << std::endl;
cv::imshow(“Detection results”, image);
cv::waitKey();
cv::destroyAllWindows();
return 0;
}
第十步，编译好程序 cats_dogs.cpp 后，将解决方案配置设置
为 Release 和 X64，然后单击右侧的“本地 Windows 调试器”，
编译并运行 cats_dogs 程序，编译成功后的结果如图 6-10
所示 :

6.4 性能测评

6.4.1 推理计算性能评价指标
响应延迟 (Latency) 和吞吐量 (Throughput) 是评价 AI 模型推理优化性能的两个重要指标 , 响应延迟和吞吐量通常用于测量网络性能和提高加载时间。响应延迟可视为执行一次推理
计算所需的时间，而吞吐量可视为在一个单位时间内执行的推理计算次数。换句话说，延迟衡量的是推理计算的速度，响应延迟越小，推理计算的越快；吞吐量是处理多少数据，
在单位时间内，吞吐量越高性能越好。
6.4.2 性能测试
本文将使用 FasterRCNN IR 模型为 7.1 节训练并发布的，saved_model.xml 和 saved_model.bin 来做性能测试。具体步骤如下。
第 一 步， 进 入 openvino 默 认 安 装 路 径 的 C:\Program File(x86)\Intel\openvino_2021.2.185\deployment_tools\tools\benchmark_tool 的 Windows 命 令 行 窗 口，通 过 命 令 命 令 打 开 tensorflow虚 拟 环 境， 再 通 过 命 令 <“c:\Program Files (x86)\Intel\openvino_2021.2.185\bin\setupvars.bat”> 初 始 化 OpenVINO环境，如下图 6-11 所示。

第二步，在 Windows 命令行窗口输入命令 <python benchmark_app.py -m D:\tf_train\workspaces\cats_dogs\IR_model\saved_model.xml -d CPU> 指定 CPU 进行性能测试，如图6-12 所示。
测试结果如图 6-13 所示。

第三步，在 Windows 命令行窗口输入命令 < python benchmark_app.py -m D:\tf_train\workspaces\cats_dogs\IR_model\saved_model.xml -d GPU > 指定 GPU 进行性能测试，如图 6-14 所示。
测试结果如图 6-15 所示。

6.4.3 性能对比
本文基于幻影峡谷的中央处理器第 11 代英特尔® 酷睿™ i7-1165G7 和英特尔® Iris® Xe Graphics 集成显卡，所得到的FasterRCNN IR 模型性能测试结果见表 6-1。
由上述数据可以看到，FasterRCNN IR 模型经过 OpenVINO™工具套件优化后，在 Iris® Xe Graphics 集成显卡上的吞吐量可以达到 2.32FPS，该速度完全满足大部分 AI 工程实践应用。

7. 总结

本文通过从零开始训练猫狗数据集目标检测模型，详细介绍了基于TensorFlow Object Detection API框架和预训练模型，使用 Python 编程语言训练猫狗 FasterRCNN 目标检测模型的完整流程，在模型部署模块中，详细介绍了 OpenVINO™工具套件及其两个重要组件：Model Optimizer 和 InferenceEngine 的安装和使用，将训练完毕的 FasterRCNN 模型转换为 IR 格式文件后，使用 C++ 编程语言进行 AI 应用程序的开发方法。在使用 Inference Engine 进行模型推理部署是，OpenVINO™ 工具套件提供了八个统一的 API 接口，流程化的开发方式极大降低了 AI 应用程序开发的难度，对于不同模型的不同输入输出节点，只需少量改动应用程序，便可快速独立开发属于自己的 AI 应用程序。