【模型部署 01】C++实现GoogLeNet在OpenCV DNN、ONNXRuntime、TensorRT、OpenVINO上的推理部署

 


深度学习领域常用的基于CPU/GPU的推理方式有OpenCV DNN、ONNXRuntime、TensorRT以及OpenVINO。这几种方式的推理过程可以统一用下图来概述。整体可分为模型初始化部分和推理部分,后者包括步骤2-5。

以GoogLeNet模型为例,测得几种推理方式在推理部分的耗时如下:

结论:

  1. GPU加速首选TensorRT;
  2. CPU加速,单图推理首选OpenVINO,多图并行推理可选择ONNXRuntime;
  3. 如果需要兼具CPU和GPU推理功能,可选择ONNXRuntime。

下一篇内容:【模型部署 02】Python实现GoogLeNet在OpenCV DNN、ONNXRuntime、TensorRT、OpenVINO上的推理部署

1. 环境配置

1.1 OpenCV DNN

  【模型部署】OpenCV4.6.0+CUDA11.1+VS2019环境配置

1.2 ONNXRuntime

  【模型部署】在C++和Python中配置ONNXRuntime环境

1.3 TensorRT

  【模型部署】在C++和Python中搭建TensorRT环境 

1.4 OpenVINO2022

  【模型部署】在C++和Python中配置OpenVINO2022环境

2. PyTorch模型文件(pt/pth/pkl)转ONNX

2.1 pt/pth/pkl互转

PyTorch中支持导出三种后缀格式的模型文件:pt、pth和pkl,这三种格式在存储方式上并无区别,只是后缀不同。三种格式之间的转换比较简单,只需要创建模型并加载模型参数,然后再保存为其他格式即可。

以pth转pt为例:

1
2
3
4
5
6
7
8
9
10
import torch
import torchvision
 
# 构建模型
model = torchvision.models.googlenet(num_classes=2, init_weights=True)
# 加载模型参数,pt/pth/pkl三种格式均可
model.load_state_dict(torch.load("googlenet_catdog.pth"))
model.eval()
# 重新保存为所需要转换的格式
torch.save(model.state_dict(), 'googlenet_catdog.pt')

2.2 pt/pth/pkl转ONNX

PyTorch中提供了现成的函数torch.onnx.export(),可将模型文件转换成onnx格式。该函数原型如下:

1
2
3
4
5
export(model, args, f, export_params=True, verbose=False, training=TrainingMode.EVAL,
           input_names=None, output_names=None, operator_export_type=None,
           opset_version=None, do_constant_folding=True, dynamic_axes=None,
           keep_initializers_as_inputs=None, custom_opsets=None,
           export_modules_as_functions=False)

主要参数含义:

  • model (torch.nn.Module, torch.jit.ScriptModule or torch.jit.ScriptFunction:需要转换的模型。
  • args (tuple or torch.Tensor) :args可以被设置为三种形式:
    • 一个tuple,这个tuple应该与模型的输入相对应,任何非Tensor的输入都会被硬编码入onnx模型,所有Tensor类型的参数会被当做onnx模型的输入。
      1
      args = (x, y, z)
    • 一个Tensor,一般这种情况下模型只有一个输入。
      1
      args = torch.Tensor([1, 2, 3])
    • 一个带有字典的tuple,这种情况下,所有字典之前的参数会被当做“非关键字”参数传入网络,字典中的键值对会被当做关键字参数传入网络。如果网络中的关键字参数未出现在此字典中,将会使用默认值,如果没有设定默认值,则会被指定为None。
      1
      2
      3
      args = (x,
              {'y': input_y,
               'z': input_z})

      NOTE:一个特殊情况,当网络本身最后一个参数为字典时,直接在tuple最后写一个字典则会被误认为关键字传参。所以,可以通过在tuple最后添加一个空字典来解决。

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      # 错误写法:
      torch.onnx.export(
          model,
          (x,
           # WRONG: will be interpreted as named arguments
           {y: z}),
          "test.onnx.pb")
        
      # 纠正
      torch.onnx.export(
          model,
          (x,
           {y: z},
           {}),
          "test.onnx.pb"
  • f:一个文件类对象或一个路径字符串,二进制的protocol buffer将被写入此文件,即onnx文件。
  • export_params (bool, default False) :如果为True则导出模型的参数。如果想导出一个未训练的模型,则设为False。
  • verbose (bool, default False) :如果为True,则打印一些转换日志,并且onnx模型中会包含doc_string信息。
  • training (enum, default TrainingMode.EVAL) :枚举类型包括:
    • TrainingMode.EVAL - 以推理模式导出模型。
    • TrainingMode.PRESERVE - 如果model.training为False,则以推理模式导出;否则以训练模式导出。
    • TrainingMode.TRAINING - 以训练模式导出,此模式将禁止一些影响训练的优化操作。
  • input_names (list of str, default empty list) :按顺序分配给onnx图的输入节点的名称列表。
  • output_names (list of str, default empty list) :按顺序分配给onnx图的输出节点的名称列表。
  • operator_export_type (enum, default None) :默认为OperatorExportTypes.ONNX, 如果Pytorch built with DPYTORCH_ONNX_CAFFE2_BUNDLE,则默认为OperatorExportTypes.ONNX_ATEN_FALLBACK。枚举类型包括:
    • OperatorExportTypes.ONNX - 将所有操作导出为ONNX操作。
    • OperatorExportTypes.ONNX_FALLTHROUGH - 试图将所有操作导出为ONNX操作,但碰到无法转换的操作(如onnx未实现的操作),则将操作导出为“自定义操作”,为了使导出的模型可用,运行时必须支持这些自定义操作。支持自定义操作方法见链接
    • OperatorExportTypes.ONNX_ATEN - 所有ATen操作导出为ATen操作,ATen是Pytorch的内建tensor库,所以这将使得模型直接使用Pytorch实现。(此方法转换的模型只能被Caffe2直接使用)
    • OperatorExportTypes.ONNX_ATEN_FALLBACK - 试图将所有的ATen操作也转换为ONNX操作,如果无法转换则转换为ATen操作(此方法转换的模型只能被Caffe2直接使用)。例如:
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      # 转换前:
      graph(%0 : Float):
        %3 : int = prim::Constant[value=0]()
        # conversion unsupported
        %4 : Float = aten::triu(%0, %3)
        # conversion supported
        %5 : Float = aten::mul(%4, %0)
        return (%5)
       
       
      # 转换后:
      graph(%0 : Float):
        %1 : Long() = onnx::Constant[value={0}]()
        # not converted
        %2 : Float = aten::ATen[operator="triu"](%0, %1)
        # converted
        %3 : Float = onnx::Mul(%2, %0)
        return (%3)
  • opset_version (int, default 9) :取值必须等于_onnx_main_opset或在_onnx_stable_opsets之内。具体可在torch/onnx/symbolic_helper.py中找到。例如:
    1
    2
    3
    4
    _default_onnx_opset_version = 9
    _onnx_main_opset = 13
    _onnx_stable_opsets = [7, 8, 9, 10, 11, 12]
    _export_onnx_opset_version = _default_onnx_opset_version
  • do_constant_folding (bool, default False) :是否使用“常量折叠”优化。常量折叠将使用一些算好的常量来优化一些输入全为常量的节点。
  • example_outputs (T or a tuple of T, where T is Tensor or convertible to Tensor, default None) :当需输入模型为ScriptModule 或 ScriptFunction时必须提供。此参数用于确定输出的类型和形状,而不跟踪(tracing)模型的执行。
  • dynamic_axes (dict<string, dict<python:int, string>> or dict<string, list(int)>, default empty dict) :通过以下规则设置动态的维度:
    • KEY(str) - 必须是input_names或output_names指定的名称,用来指定哪个变量需要使用到动态尺寸。
    • VALUE(dict or list) - 如果是一个dict,dict中的key是变量的某个维度,dict中的value是我们给这个维度取的名称。如果是一个list,则list中的元素都表示此变量的某个维度。

代码实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import torch
import torchvision
 
weight_file = 'googlenet_catdog.pt'
onnx_file = 'googlenet_catdog.onnx'
 
model = torchvision.models.googlenet(num_classes=2, init_weights=True)
model.load_state_dict(torch.load(weight_file, map_location=torch.device('cpu')))
 
model.eval()
 
# 单输入单输出,固定batch
input = torch.randn(1, 3, 224, 224)
input_names = ["input"]
output_names = ["output"]
torch.onnx.export(model=model,
                  args=input,
                  f=onnx_file,
                  input_names=input_names,
                  output_names=output_names,
                  opset_version=11,
                  verbose=True)

通过netron.app可视化onnx的输入输出: 

如果需要多张图片同时进行推理,可以通过设置export的dynamic_axes参数,将模型输入输出的指定维度设置为变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import torch
import torchvision
 
weight_file = 'googlenet_catdog.pt'
onne_file = 'googlenet_catdog.onnx'
 
model = torchvision.models.googlenet(num_classes=2, init_weights=True)
model.load_state_dict(torch.load(weight_file, map_location=torch.device('cpu')))
 
model.eval()
 
# 单输入单输出,动态batch
input = torch.randn(1, 3, 224, 224)
input_names = ["input"]
output_names = ["output"]
torch.onnx.export(model=model,
                  args=input,
                  f=onnx_file,
                  input_names=input_names,
                  output_names=output_names,
                  opset_version=11,
                  verbose=True,
                  dynamic_axes={'input': {0: 'batch'}, 'output': {0: 'batch'}})

动态batch的onnx文件输入输出在netron.app可视化如下,其中batch维度是变量的形式,可以根据自己需要设置为大于0的任意整数。

如果模型有多个输入和输出,按照以下形式导出:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 模型有两个输入和两个输出,动态batch
input1 = torch.randn(1, 3, 256, 192).to(opt.device)
input2 = torch.randn(1, 3, 256, 192).to(opt.device)
input_names = ["input1", "input2"]
output_names = ["output1", "output2"]
torch.onnx.export(model=model,
                  args=(input1, input2),
                  f=opt.onnx_path,
                  input_names=input_names,
                  output_names=output_names,
                  opset_version=16,
                  verbose=True,
                  dynamic_axes={'input1': {0: 'batch'},
                                'input2': {0: 'batch'},
                                'output1': {0: 'batch'},
                                'output2': {0: 'batch'}})

3. OpenCV DNN部署GoogLeNet

3.1 推理过程及代码实现

整个推理过程可分为前处理、推理、后处理三部分。具体细节请阅读代码,包括单图推理、动态batch推理的实现。

3.2 选择CPU/GPU

OpenCV DNN切换CPU和GPU推理,只需要通过下边两行代码设置计算后台和计算设备。

CPU推理

1
2
net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV);
net.setPreferableTarget(cv::dnn::DNN_TARGET_CPU);

GPU推理

1
2
net.setPreferableBackend(cv::dnn::DNN_BACKEND_CUDA);
net.setPreferableTarget(cv::dnn::DNN_TARGET_CUDA); 

以下两点需要注意:

  • 在不做任何设置的情况下,默认使用CPU进行推理。
  • 在设置为GPU推理时,如果电脑没有搜索到CUDA环境,则会自动转换成CPU进行推理。

3.3 多输出模型推理

当模型有多个输出时,使用forward的重载方法,返回Mat类型的数组:

1
2
3
4
5
6
// 模型多输出
std::vector<cv::Mat> preds;
net.forward(preds);
 
cv::Mat pred1 = preds[0];
cv::Mat pred2 = preds[1];

4. ONNXRuntime部署GoogLeNet

4.1 推理过程及代码实现

代码:

注意:ORT支持多图并行推理,但是要求转出onnx的时候batch就要使用固定数值。动态batch(即batch=-1)的onnx文件是不支持推理的。

4.2 选择CPU/GPU

使用GPU推理,只需要添加一行代码:

1
2
3
4
if (useCuda) {
    // 开启CUDA加速
    OrtSessionOptionsAppendExecutionProvider_CUDA(*sessionOptions, deviceId);
} 

4.3 多输入多输出模型推理

推理步骤和单图推理基本一致,需要在输入tensor中依次添加所有的输入。假设模型有两个输入和两个输出:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// 创建session
session2 = new Ort::Session(env1, onnxPath, sessionOptions1);
 
// 获取模型输入输出信息
inputCount2 = session2->GetInputCount();
outputCount2 = session2->GetOutputCount();
 
// 输入和输出各有两个
Ort::AllocatorWithDefaultOptions allocator;
const char* inputName1 = session2->GetInputName(0, allocator);
const char* inputName2 = session2->GetInputName(1, allocator);
const char* outputName1 = session2->GetOutputName(0, allocator);
const char* outputName2 = session2->GetOutputName(1, allocator);
intputNames2 = { inputName1, inputName2 };
outputNames2 = { outputName1, outputName2 };
 
// 获取输入输出维度信息,返回类型std::vector<int64_t>
inputShape2_1 = session2->GetInputTypeInfo(0).GetTensorTypeAndShapeInfo().GetShape();
inputShape2_2 = session2->GetInputTypeInfo(1).GetTensorTypeAndShapeInfo().GetShape();
outputShape2_1 = session2->GetOutputTypeInfo(0).GetTensorTypeAndShapeInfo().GetShape();
outputShape2_2 = session2->GetOutputTypeInfo(1).GetTensorTypeAndShapeInfo().GetShape();
 
...
 
// 创建输入tensor
auto memoryInfo = Ort::MemoryInfo::CreateCpu(OrtAllocatorType::OrtArenaAllocator, OrtMemType::OrtMemTypeDefault);
std::vector<Ort::Value> inputTensors;
inputTensors.emplace_back(Ort::Value::CreateTensor<float>(memoryInfo,
    blob1.ptr<float>(), blob1.total(), inputShape2_1.data(), inputShape2_1.size()));
inputTensors.emplace_back(Ort::Value::CreateTensor<float>(memoryInfo,
    blob2.ptr<float>(), blob2.total(), inputShape2_2.data(), inputShape2_2.size()));
     
// 推理
auto outputTensors = session2->Run(Ort::RunOptions{ nullptr },
    intputNames2.data(), inputTensors.data(), inputCount2, outputNames2.data(), outputCount2);
 
// 获取输出
float* preds1 = outputTensors[0].GetTensorMutableData<float>();
float* preds2 = outputTensors[1].GetTensorMutableData<float>();

5. TensorRT部署GoogLeNet

TRT推理有两种常见的方式:

  1. 通过官方安装包里边的提供的trtexec.exe工具,从onnx文件转换得到trt文件,然后执行推理;
  2. 由onnx文件转化得到engine文件,再执行推理。

两种方式原理一样,这里我们只介绍第二种方式。推理过程可分为两阶段:使用onnx构建推理engine和加载engine执行推理。

5.1 构建推理引擎(engine文件) 

engine的构建是TensorRT推理至关重要的一步,它特定于所构建的确切GPU模型,不能跨平台或TensorRT版本移植。举个简单的例子,如果你在RTX3060上使用TensorRT 8.2.5构建了engine,那么推理部署也必须要在RTX3060上进行,且要具备TensorRT 8.2.5环境。engine构建的大致流程如下:

engine的构建有很多种方式,这里我们介绍常用的三种。我一般会选择直接在Python中构建,这样模型的训练、转onnx、转engine都在Python端完成,方便且省事。

方法一:在Python中构建

生成fp16模型:参数precision设置为fp16即可。int8模型生成过程比较复杂,且对模型精度影响较大,用的不多,这里暂不介绍。

1
2
parser.add_argument("-p", "--precision", default="fp16", choices=["fp32", "fp16", "int8"],
                        help="The precision mode to build in, either 'fp32', 'fp16' or 'int8', default: 'fp16'")

方法二:在C++中构建

方法三:使用官方安装包bin目录下的trtexec.exe工具构建

1
trtexec.exe --onnx=googlenet-pretrained_batch.onnx --saveEngine=googlenet-pretrained_batch_from_trt_trt853.engine --shapes=input:25x3x224x224

fp16模型:在后边加--fp16即可

1
trtexec.exe --onnx=googlenet-pretrained_batch.onnx --saveEngine=googlenet-pretrained_batch_from_trt_trt853.engine --shapes=input:25x3x224x224 --fp16 

5.2 读取engine文件并部署模型

推理代码:

5.3 fp32、fp16模型对比测试

fp16模型推理结果几乎和fp32一致,但是却较大的节约了显存和内存占用,同时推理速度也有明显的提升。

6. OpenVINO部署GoogLeNet

6.1 推理过程及代码

代码:

注意:OV支持多图并行推理,但是要求转出onnx的时候batch就要使用固定数值。动态batch(即batch=-1)的onnx文件会报错。

6.2 遇到的问题

理论:OpenVINO是基于CPU推理最佳的方式。

实测:在测试OpenVINO的过程中,我们发现OpenVINO推理对于CPU的利用率远没有OpenCV DNN和ONNXRuntime高,这也是随着batch数量增加,OV在CPU上的推理速度反而不如DNN和ORT的主要原因。尝试过网上的多种优化方式,比如设置线程数并发数等等,未取得任何改善。如下图,在OpenVINO推理过程中,始终只有一半的CPU处于活跃状态;而OnnxRuntime或者OpenCV DNN推理时,所有的CPU均处于活跃状态。

 

7. 四种推理方式对比测试

深度学习领域常用的基于CPU/GPU的推理方式有OpenCV DNN、ONNXRuntime、TensorRT以及OpenVINO。这几种方式的推理过程可以统一用下图来概述。整体可分为模型初始化部分和推理部分,后者包括步骤2-5。

以GoogLeNet模型为例,测得几种推理方式在推理部分的耗时如下:

基于CPU推理:

基于GPU推理:

不论采用何种推理方式,同一网络的前处理和后处理过程基本都是一致的。所以,为了更直观的对比几种推理方式的速度,我们抛去前后处理,只统计图中实际推理部分,即3、4、5这三个过程的执行时间。

同样是GoogLeNet网络,步骤3-5的执行时间对比如下:

注:OpenVINO-CPU测试中始终只使用了一半数量的内核,各种优化设置都没有改善。

最终结论:

  1. GPU加速首选TensorRT;
  2. CPU加速,单图推理首选OpenVINO,多图并行推理可选择ONNXRuntime;
  3. 如果需要兼具CPU和GPU推理功能,可选择ONNXRuntime。

参考资料

1. openvino2022版安装配置与C++SDK开发详解

2. https://github.com/NVIDIA/TensorRT

3. https://github.com/wang-xinyu/tensorrtx

4. 【TensorRT】TensorRT 部署Yolov5模型(C++)

posted @   最菜程序员Sxx  阅读(1850)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型,支持深度思考和联网搜索!
· 基于 Docker 搭建 FRP 内网穿透开源项目(很简单哒)
· ollama系列1:轻松3步本地部署deepseek,普通电脑可用
· 按钮权限的设计及实现
· Apache Tomcat RCE漏洞复现(CVE-2025-24813)
点击右上角即可分享
微信分享提示

目录导航