Pytorch导出onnx模型并在C++环境中调用（含python和C++工程）

原创 已于 2025-01-12 22:04:43 修改
· 1.8k 阅读 · 34 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #pytorch #c++

于 2025-01-12 21:58:04 首次发布

Pytorch导出onnx模型并在C++环境中调用（含python和C++工程）

工程下载链接：Pytorch导出onnx模型并在C++环境中调用（python和C++工程）

机器学习多层感知机MLP的Pytorch实现-以表格数据为例-含数据集和PyCharm工程中简单介绍了在python中使用pytorch搭建神经网络模型的步骤和代码工程，此处介绍AI模型的跨平台调用问题，即使用跨平台的ONNX框架，在C++代码中进行模型调用。

参考：pytorch导出模型并使用onnxruntime C++部署加载模型推理

目录

1、pkl权重文件转换为onnx模型

在机器学习多层感知机MLP的Pytorch实现-以表格数据为例-含数据集和PyCharm工程中，我们对训练完成的模型进行了模型的保存：

torch.save(model.state_dict(),
           'weights/mlp_weights-epoch%d-Total_loss%.4f-val_loss%.4f.pkl' % (
               (epoch + 1), train_loss, val_loss / (iteration + 1)))

此处我们需要先加载保存的模型，如何再将其导出为onnx格式。

1.1、加载保存的模型

这一步主要是要把保存的模型恢复出来：

import numpy as np
import onnxruntime
import torch
from torch import nn
import torch.nn.functional as F


# 定义多层感知机（MLP）类，继承自nn.Module
class MLP(nn.Module):
    # 类的初始化方法
    def __init__(self):
        # 调用父类nn.Module的初始化方法
        super(MLP, self).__init__()
        self.hidden1 = nn.Linear(in_features=8, out_features=50, bias=True)
        self.hidden2 = nn.Linear(50, 50)
        self.hidden3 = nn.Linear(50, 50)
        self.hidden4 = nn.Linear(50, 50)
        self.predict = nn.Linear(50, 1)

    # 定义前向传播方法
    def forward(self, x):
        # x是输入数据，通过第一个隐藏层并应用ReLU激活函数
        x = F.relu(self.hidden1(x))
        x = F.relu(self.hidden2(x))
        x = F.relu(self.hidden3(x))
        x = F.relu(self.hidden4(x))
        output = self.predict(x)
        # 将输出展平为一维张量
        # out = output.view(-1)
        return output


# 检查是否有可用的GPU
# device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device = "cpu"
# 定义模型并将其转移到GPU
model = MLP().to(device)
model.load_state_dict(torch.load('weights/mlp_weights-epoch1000-Total_loss0.0756-val_loss0.0105.pkl',
                                 weights_only=True))
model.eval()

1.2、pytorch调用加载的模型进行测试

先简单测试一下这个模型，定义一个输入全为0的数组作为输入，打印输出的结果：

# 初始化一个输入全为0的数组进行测试
x = (torch.from_numpy(np.array([0, 0, 0, 0, 0, 0, 0, 0]).astype(np.float32)).to(device))
y = model(x).cpu().detach().numpy()[0]
print(f"pytorch直接测试结果为: {y}")

在这里插入图片描述

1.3、导出onnx模型

使用下面的代码将原来的模型model导出为onnx的模型，其中x是上面定义的案例输入：

batch_size = 1  # 批处理大小
export_onnx_file = "test.onnx"  # 目的ONNX文件名
torch.onnx.export(model,
                  (x),
                  export_onnx_file,
                  opset_version=10,
                  do_constant_folding=True,  # 是否执行常量折叠优化
                  input_names=["input"],  # 输入名
                  output_names=["output"],  # 输出名
                  dynamic_axes={"input": {0: "batch_size"},  # 批处理变量
                                "output": {0: "batch_size"}})

这个函数的具体定义可以参考：从pytorch转换到onnx

1.4、在python中调用onnx模型测试

使用下面代码加载onnx模型并进行测试：

resnet_session = onnxruntime.InferenceSession(export_onnx_file)
inputs = {resnet_session.get_inputs()[0].name: x.cpu().detach().numpy()}
outs = resnet_session.run(None, inputs)[0][0]
print(f"py onnx直接测试结果为: {outs}")

可以看到pytorch的结果和onnx的结果是基本一致的：
在这里插入图片描述

1.5、全部代码

import numpy as np
import onnxruntime
import torch
from torch import nn
import torch.nn.functional as F


# 定义多层感知机（MLP）类，继承自nn.Module
class MLP(nn.Module):
    # 类的初始化方法
    def __init__(self):
        # 调用父类nn.Module的初始化方法
        super(MLP, self).__init__()
        self.hidden1 = nn.Linear(in_features=8, out_features=50, bias=True)
        self.hidden2 = nn.Linear(50, 50)
        self.hidden3 = nn.Linear(50, 50)
        self.hidden4 = nn.Linear(50, 50)
        self.predict = nn.Linear(50, 1)

    # 定义前向传播方法
    def forward(self, x):
        # x是输入数据，通过第一个隐藏层并应用ReLU激活函数
        x = F.relu(self.hidden1(x))
        x = F.relu(self.hidden2(x))
        x = F.relu(self.hidden3(x))
        x = F.relu(self.hidden4(x))
        output = self.predict(x)
        # 将输出展平为一维张量
        # out = output.view(-1)
        return output


# 检查是否有可用的GPU
# device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device = "cpu"
# 定义模型并将其转移到GPU
model = MLP().to(device)
model.load_state_dict(torch.load('weights/mlp_weights-epoch1000-Total_loss0.0756-val_loss0.0105.pkl',
                                 weights_only=True))
model.eval()

# 初始化一个输入全为0的数组进行测试
x = (torch.from_numpy(np.array([0, 0, 0, 0, 0, 0, 0, 0]).astype(np.float32)).to(device))
y = model(x).cpu().detach().numpy()[0]
print(f"pytorch直接测试结果为: {y}")



batch_size = 1  # 批处理大小
export_onnx_file = "test.onnx"  # 目的ONNX文件名
torch.onnx.export(model,
                  (x),
                  export_onnx_file,
                  opset_version=10,
                  do_constant_folding=True,  # 是否执行常量折叠优化
                  input_names=["input"],  # 输入名
                  output_names=["output"],  # 输出名
                  dynamic_axes={"input": {0: "batch_size"},  # 批处理变量
                                "output": {0: "batch_size"}})

resnet_session = onnxruntime.InferenceSession(export_onnx_file)
inputs = {resnet_session.get_inputs()[0].name: x.cpu().detach().numpy()}
outs = resnet_session.run(None, inputs)[0][0]
print(f"py onnx直接测试结果为: {outs}")

2、C++调用onnx模型

2.1、库的下载安装和官方手册

这个整个库的下载还是要到官方的github仓库去：microsoft/onnxruntime
具体的使用方式参考英文的手册：https://onnxruntime.ai/docs/】

此处下载的window版本的，下载下来可以得到头文件和库文件：
在这里插入图片描述在这里插入图片描述
因此在实际编程的时候我使用的Cmakelist来链接到相关的库，我是使用VS code + gcc构成的C++编译环境：

if (WIN32)
    include_directories(${CMAKE_CURRENT_SOURCE_DIR}/onnxruntime-1.14.0/onnxruntime-win-x64-1.14.0/include)
else()
    include_directories(${CMAKE_CURRENT_SOURCE_DIR}/onnxruntime-1.14.0/onnxruntime-linux-x64-1.14.0/include)
endif()

if (WIN32)
    link_directories(
        ${CMAKE_CURRENT_SOURCE_DIR}/onnxruntime-1.14.0/onnxruntime-win-x64-1.14.0/lib
    )
else()
    link_directories(
        ${CMAKE_CURRENT_SOURCE_DIR}/onnxruntime-1.14.0/onnxruntime-linux-x64-1.14.0/lib
    )
endif()

实际的工程目录结构如下所示：
在这里插入图片描述

2.2、C++调用代码实现

下面代码实现和1.4、在python中调用onnx模型测试相同的效果，输入是全0的数组，进行计算并返回相关结果：

#include <iostream>
#include <array>
#include <algorithm>
#include "onnxruntime_cxx_api.h"

#define ONNX_IN_OUT_SIZE_MAX 20

int main(int argc, char* argv[])
{
    //print hello
    printf("hello");
    std::vector<float> input_matrix_vector={0, 0, 0, 0, 0, 0, 0, 0};
    int onnx_input_shape = 8;
    int onnx_output_shape = 1;




    // --- define model path
    #if _WIN32
        const wchar_t* model_path = L"./model.onnx"; // you can use string to wchar_t* function to convert
    #else
        const char* model_path = "./model.onnx";
    #endif

    // --- init onnxruntime env
    Ort::Env env(ORT_LOGGING_LEVEL_WARNING, "Default");

    auto memory_info = Ort::MemoryInfo::CreateCpu(OrtDeviceAllocator, OrtMemTypeCPU);

    // set options
    Ort::SessionOptions session_option;
    session_option.SetIntraOpNumThreads(1); // extend the number to do parallel
    session_option.SetGraphOptimizationLevel(ORT_ENABLE_ALL);

    // --- prepare data
    const char* input_names[] = { "input" }; // must keep the same as model export
    const char* output_names[] = { "output" };

    std::array<float, ONNX_IN_OUT_SIZE_MAX> input_matrix;
    std::array<float, ONNX_IN_OUT_SIZE_MAX> output_matrix;
    if(input_matrix_vector.size()>ONNX_IN_OUT_SIZE_MAX)
    {
        throw std::runtime_error("input_matrix_vector.size()<ONNX_IN_OUT_SIZE_MAX");
    }

    std::copy(input_matrix_vector.begin(),input_matrix_vector.end(),input_matrix.begin());

    // must use int64_t type to match args
    std::array<int64_t, 1> input_shape{ onnx_input_shape };
    std::array<int64_t, 1> output_shape{ onnx_output_shape };

    

    Ort::Value input_tensor = Ort::Value::CreateTensor<float>(memory_info, input_matrix.data(), input_matrix.size(), input_shape.data(), input_shape.size());
    Ort::Value output_tensor = Ort::Value::CreateTensor<float>(memory_info, output_matrix.data(), output_matrix.size(), output_shape.data(), output_shape.size());

    // --- predict
    Ort::Session session(env, model_path, session_option); // FIXME: must check if model file exist or valid, otherwise this will cause crash
    session.Run(Ort::RunOptions{ nullptr }, input_names, &input_tensor, 1, output_names, &output_tensor, 1); // here only use one input output channel
    
    std::vector<float> outputVector(onnx_output_shape);
    std::copy(output_matrix.begin(),output_matrix.begin()+onnx_output_shape,outputVector.begin());

    std::cout << "--- predict result ---" << std::endl;
    // matrix output
    std::cout << "ouput matrix: ";
    for (int i = 0; i < outputVector.size(); i++)
        std::cout << outputVector[i] << " ";
    std::cout << std::endl;
    // argmax value
    // int argmax_value = std::distance(output_matrix.begin(), std::max_element(output_matrix.begin(), output_matrix.end()));
    // std::cout << "output argmax value: " << argmax_value << std::endl;

    // getchar();

    return 0;
}

可以看到最终的返回结果为：
在这里插入图片描述
和之前在python中的结果是一致的！！！

2.3、注意，模型文件和onnx的dll要在exe同一级目录

在这里插入图片描述

3、运行时遇到的一些问题

编译报错—error: ‘Frees_ptr_opt‘ has not been declared

在编译器命令行或者代码中定义这些宏，使其在非MSVC环境中被忽略。在代码的开头（ onnxruntime_c_api.h 文件中）添加以下代码：

#pragma once
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
//add code here
#ifndef _Frees_ptr_opt_ 
#define _Frees_ptr_opt_ 
#endif 
#ifndef _In_ 
#define _In_ 
#endif 
#ifndef _Out_ 
#define _Out_ 
#endif 
#ifndef _Inout_ 
#define _Inout_
#endif

运行报错—The given version [14] is not supported, only version 1 to 10 is supported in this build.

将onnxruntime-1.14.0\onnxruntime-win-x64-1.14.0\lib的onnxruntime.dll复制一份到exe的目录下面，这是因为路径默认索引的是System32中的老版本库文件：
在这里插入图片描述
System32中存在老版本的onnx动态库：
在这里插入图片描述

pytorch 49 GroundingDINO导出为onnx模型实现python与c++部署
a486259的博客
11-23 975
本博文实现了在win环境下，将GroundingDINO模型导出为onnx模型，并基于cmakelist生成c++项目实现模型的部署。并分析了官方项目为什么不能直接导出onnx，主要基于https://github.com/wenyi5608/GroundingDINO项目公开的代码实现项目，只是补充了c++配置项，实现了模型转tensorrt格式。在600x600的输入下，3060显卡，torch推理、python-onnx、c+±onxx推理速度均在0.1s左右。
模型部署 - onnx 的导出和分析 - PyTorch 导出 ONNX - 学习记录
点云算法工程师
03-03 4842
上面是 onnx 可以直接被导出的情况，是因为对应的 pytorch 和 onnx 版本都有相应支持的算子在里面。与上面例子不同的是，这个注册方式跟底层文件的写法是一样的（文件在虚拟环境中的 torch/onnx/symbolic_opset*.py ）比如下面的这个报错，提示当前 onnx 的 opset 版本不支持这个算子，那我们可以去官方手册搜索一下是否在高的版本支持了这个算子。有些算子在 onnx 中是有的，但是在 pytorch 中没被登记，则需要。（实际上就是一个矩阵乘法）
使用C++部署应用onnx模型
Justin_JGT的博客
04-17 4246
在C++下部署onnx模型的示例程序，包含各个API的解释。
PyTorch 模型转换为 ONNX并C++推理
最新发布
weixin_43724177的博客
03-17 1100
PyTorch 模型转换为 ONNX 以及推理
pytorch学习（十二）c++调用minist训练的onnx模型
hero_heart的博客
07-20 626
在实际使用过程中，使用python速度不够快，并且不太好嵌入到c++程序中，因此可以把pytorch训练的模型转成onnx模型，然后使用opencv进行调用。所需要用到的库有：opencv。
开放世界目标检测-onnxruntime部署GroundingDINO算法C++源码+onnx模型（含python版本）.zip
12-06
【项目说明】 1.多数小白下载后，在使用过程，可能会遇到些小问题，若自己解决不了，请及时私信描述你的问题，我会第一时间提供帮助，也可以远程指导 2.项目代码完整可靠，但难度适中，满足一些毕设、课设要求，且属于易上手的优质项目，项目内基本都有说明文档，按照操作即可，遇到困难也可私信交流 3.适用人群：各大计算机相关专业行业的在校学生、高校老师、公司程序员等下载使用 4.特别是那种爱钻研学习的学霸，强烈推荐此项目，可以二次开发提升自己。如果确定自己是学渣，拿来作毕设、课设直接用也无妨，但建议自己还是尽可能弄懂项目最好！ 【特别强调】 项目下载解压后，项目名字和项目路径不要用中文，建议解压重命名为英文名字后再运行！项目易上手运行 使用过程遇到问题先搜索下，一般都是环境问题，当然也可以私信沟通，欢迎交流学习，祝顺利！
深度学习-Python调用ONNX模型
热门推荐
captain
09-20 1万+
例如，如果您的模型期望的输入形状是(batch_size, 10)，您可以将示例代码中的input_size变量设置为10。在您给出的代码中，您正在尝试将一个形状为(batch_size, 784)的输入张量提供给模型，但是模型期望输入张量的形状为(batch_size, 10)。因此，ONNX是一种强大的深度学习模型转换和部署工具，可以大大加速深度学习模型的开发和部署过程。导出模型：在训练好深度学习模型后，通过ONNX的支持的框架，比如PyTorch、TensorFlow等将模型导出为ONNX格式。
Pytorch导出onnx模型并在C++环境中调用（python和C++工程）
01-12
Pytorch导出onnx模型并在C++环境中调用（含python和C++工程） 机器学习多层感知机MLP的Pytorch实现-以表格数据为例-含数据集和PyCharm工程中简单介绍了在python中使用pytorch搭建神经网络模型的步骤和代码工程，此处...
Pytorch网络模型转Onnx格式，多种方法（opencv、onnxruntime、c++）调用Onnx
qq_44747572的博客
10-18 7335
文章目录1. Torchvison模型推理2. Pytorch -> Onnx3. Opencv 调用 Onnx4. Onnxruntime 调用 Onnx5. C++调用Onnx 1. Torchvison模型推理 import torch import torchvision import cv2 import onnx import numpy as np import timm import os from PIL import Image from torchvision import tr
pytorch转onnx使用C++ onnxuntime加载推理
02-28
PyTorch是一款广泛使用的深度学习框架，而ONNX（Open Neural Network Exchange）则提供了一个统一的模型交换格式，使得不同框架训练的模型可以方便地在其他支持ONNX的环境中运行。本示例主要涉及将PyTorch模型转换为...
面向Windows在C++中调用Pytorch模型（MNIST手写体数字识别）
11-01
在本教程中，我们将深入探讨如何在Windows操作系统中使用C++调用预先训练好的PyTorch模型，以实现MNIST手写体数字识别任务。这个过程涵盖了从PyTorch环境的构建、模型训练，到利用libtorch库将模型转换为C++可执行...
【深度学习】【Opencv】【CPU】Python/C++调用onnx模型
yangyu0515的博客
09-26 7871
【深度学习】【Opencv】【CPU】Python/C++调用onnx模型
【深度学习】【Opencv】【GPU】python/C++调用onnx模型
yangyu0515的博客
10-16 7073
【深度学习】【Opencv】【GPU】python/C++调用onnx模型
pytorch从python转 c++涉及到的数据保存加载问题；libtorch
IT探险者-returningprodigal
08-13 651
python代码c++代码charchar。
使用C++调用PyTorch模型的弯弯绕绕，推荐LibTorch加载，C++处理
稳健的我的博客
08-19 1403
本人莎莎的以为要重写PyTorch模型网络架构，于是使用C++的LibTorch和gpt重写了一下，结果一致卡在load不上，非常奇怪，于是检查两个网络的架构，其实非常类似，忘记截图载下来了，就下面一张图。.pth保存的是模型参数，通过字符字典进行保存，在加载该类文件时应该先实例化一个具体的模型，然后对新建立的空模型，进行参数赋予。cv 2，numpy，pillow等包都是如此，统一conda，或者统一使用pip，推荐使用pip。需要重写图像处理的一些代码，保持和Python一致，输入模型进行预测。
如何用C#调用onnx模型
灵魂钥匙的博客
03-15 7114
这里注意resultsArray的类型是onnx_tensor不能直接转为float[]，因此这里需要调用函数进行处理，将resultsArray的数组提取出来，通过AsEnumerable()结合ToArray()方法来实现，这个shuchu就是我们预测得到的一个1x112的数组。此时的tensor就是{{2,54,1,1,1}},inputMeta[name].Dimensions是2，因为输入是1x5的，所以Dimensions其中1个是1,1个是5，表示输入的维度是[1,5]
人工智能混合编程实践：C++调用Python ONNX进行YOLOv8推理
FriendshipTang的博客
03-11 361
C++、Python、ONNX、人工智能、目标检测
【深度学习】【onnxruntime】C++调用onnx
yangyu0515的博客
09-09 6671
【深度学习】【onnxruntime】C++调用onnx
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

怡步晓心l

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值