Onnxruntime + c++实现滑动窗口预测

已于 2024-11-28 11:16:38 修改
阅读量331 收藏
点赞数 3
分类专栏： ONNX 文章标签： c++ 深度学习
于 2024-09-02 17:10:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49795811/article/details/141824002
版权

在部署onnxruntime的时候发现在对tensor进行slice 的时候，加不加contiguous()对结果的影响非常大。了解之后发现之所以会导致结果的巨大差异，是因为内存布局的处理方式不同。

当在 torch 中对一个张量进行切片时，结果张量可能并不是连续的内存块。这意味着这个张量是原始张量的一个视图，通过步长来实现切片布局，我觉得类似用view观察数据，不改变数据底层排列。

在进行张量切片、转置等操作后，如果不调用 contiguous()，将这个非连续的张量传递给一个期望连续内存的函数（例如某些 ONNX 推理操作，ONNX Runtime 和其他推理引擎通常假设输入数据是连续的），ONNX 导出可能会遇到内存布局不一致的问题，导致推理阶段的数据不正确或效率低下。

调用 .contiguous() 会确保张量以标准的内存布局（在 PyTorch 中是行优先顺序）存储在一个连续的内存块中。

顺便记录一下onnxruntime + c++实现的滑动窗口预测

torch::Tensor OnnxInference(const ORTCHAR_T* onnx_path, const itk::Size<3>& image_size,const torch::Tensor& image_tensor, float step_size = 0.9) {
    //Session 构造
    Ort::Env env(OrtLoggingLevel::ORT_LOGGING_LEVEL_WARNING, "test");
    Ort::SessionOptions session_options;
    OrtCUDAProviderOptions cuda_options{};
    session_options.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_EXTENDED);
    session_options.AppendExecutionProvider_CUDA(cuda_options);
    std::cout << "CUDA Provider has been appended." << std::endl;

    Ort::Session session(env, onnx_path, session_options);
    Ort::AllocatorWithDefaultOptions allocator;

    //输入输出信息
    auto [numInputNodes, inputNameStr, inputType, inputDims] = GetInputInfo(session, allocator);
    auto [numOutputNodes, outputNameStr, outputType, outputDims] = GetOutputInfo(session, allocator);
    
    //输入输出
    size_t inputTensorSize = vectorProduct(inputDims);
    std::cout << "Size of inputTensorSize: " << inputTensorSize << std::endl;
    std::vector<const char*> inputNames{ "input" };   

    size_t outputTensorSize = vectorProduct(outputDims);
    std::vector<float> outputTensorValues(outputTensorSize);
    std::vector<const char*> outputNames{ "output" };

    Ort::MemoryInfo memoryInfo = Ort::MemoryInfo::CreateCpu(
        OrtAllocatorType::OrtArenaAllocator, OrtMemType::OrtMemTypeDefault);

    //Warm up
    auto startt = std::chrono::high_resolution_clock::now();
    std::cout << "Starting warm-up..." << std::endl;
    std::vector<float> dummyInput(inputTensorSize, 0.0f);
    std::vector<Ort::Value> warmupInputTensors;
    warmupInputTensors.push_back(Ort::Value::CreateTensor<float>(
        memoryInfo, dummyInput.data(), inputTensorSize,
        inputDims.data(), inputDims.size()));

    std::vector<float> dummyOutput(outputTensorSize, 0.0f);
    std::vector<Ort::Value> warmupOutputTensors;
    warmupOutputTensors.push_back(Ort::Value::CreateTensor<float>(
        memoryInfo, dummyOutput.data(), outputTensorSize,
        outputDims.data(), outputDims.size()));

    for (int i = 0; i < 8; ++i) { 
        session.Run(Ort::RunOptions{ nullptr }, inputNames.data(),
            warmupInputTensors.data(), warmupInputTensors.size(),
            outputNames.data(), warmupOutputTensors.data(), warmupOutputTensors.size());
    }
    auto endt = std::chrono::high_resolution_clock::now();

    std::cout << "Warm-up time: " << duration_cast<milliseconds>(endt - startt).count() / 1000.0 << std::endl;
    std::cout << "Warm-up completed." << std::endl;

    //计算滑动窗口步数
    std::vector<int64_t> patch_size(inputDims.begin() + 2, inputDims.end()); //128, 196, 196
    std::vector<std::vector<int64_t>> steps = Compute_steps_for_sliding_window(patch_size, image_size, step_size);
    //打印steps
    //std::cout << "Computing steps" << std::endl;
    //for (int dim = 0; dim < 3; ++dim) {
    //    std::cout << "Dimension " << dim << " steps: ";
    //    for (int i = 0; i < steps[dim].size(); ++i) {
    //        std::cout << steps[dim][i] << " ";
    //    }
    //    std::cout << std::endl;
    //}

    int num_tiles = steps[0].size() * steps[1].size() * steps[2].size();
    std::cout << "Num_tiles :" << num_tiles << std::endl;
    std::cout << std::endl;

    torch::Tensor aggregated_results = torch::empty({ 1, outputDims[1], static_cast<long long>(image_size[0]), static_cast<long long>(image_size[1]), 
         static_cast<long long>(image_size[2])}, torch::kFloat32);

    std::vector<long long> durations;

    for (int x : steps[0]) {
        int lb_x = x;
        int ub_x = x + patch_size[0];

        for (int y : steps[1]) {
            int lb_y = y;
            int ub_y = y + patch_size[1];

            for (int z : steps[2]) {
                int lb_z = z;
                int ub_z = z + patch_size[2];

                auto start = std::chrono::high_resolution_clock::now();
                torch::Tensor sliced_tensor = image_tensor.slice(2, lb_x, ub_x)
                    .slice(3, lb_y, ub_y)
                    .slice(4, lb_z, ub_z)
                    .contiguous()
                    .to(torch::kFloat32);

                std::vector<float> inputTensorValues(sliced_tensor.data_ptr<float>(),
                    sliced_tensor.data_ptr<float>() + sliced_tensor.numel());

                std::vector<Ort::Value> inputTensors;

                inputTensors.push_back(Ort::Value::CreateTensor<float>(
                    memoryInfo, inputTensorValues.data(), inputTensorSize,
                    inputDims.data(), inputDims.size()));

                std::vector<Ort::Value> outputTensors;
                outputTensors.push_back(Ort::Value::CreateTensor<float>(
                    memoryInfo, outputTensorValues.data(), outputTensorSize,
                    outputDims.data(), outputDims.size()));

                session.Run(Ort::RunOptions{ nullptr }, inputNames.data(),
                    inputTensors.data(), inputTensors.size(),
                    outputNames.data(), outputTensors.data(), outputTensors.size());

                float* predicted_patch = outputTensors[0].GetTensorMutableData<float>(); //1,2,128,192,192

                torch::Tensor pred = torch::from_blob(predicted_patch, outputDims, torch::kFloat32).contiguous().clone();

                aggregated_results
                    .slice(2, lb_x, ub_x)
                    .slice(3, lb_y, ub_y)
                    .slice(4, lb_z, ub_z) = pred;

                auto end = std::chrono::high_resolution_clock::now();
                std::cout << "one tile: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() / 1000.0 << std::endl;

                auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
                durations.push_back(duration);
            }
        }

    }


    // Calculate average duration
    long long sum = std::accumulate(durations.begin(), durations.end(), 0LL);
    double average_duration = sum / static_cast<double>(num_tiles);
    std::cout << "All prediction time over " << num_tiles << " runs: " << sum / 1000.0 << " seconds." << std::endl;
    std::cout << "Average prediction time over " << num_tiles << " runs: " << average_duration / 1000.0 << " seconds." << std::endl;


    auto start_arg = std::chrono::high_resolution_clock::now();
    auto argmax_tensor = torch::argmax(aggregated_results.to(torch::kCUDA),1, true).squeeze();

    std::cout << argmax_tensor.sizes() << std::endl;
    auto end_arg = std::chrono::high_resolution_clock::now();
    std::cout << "Argmax time: " << duration_cast<std::chrono::milliseconds>(end_arg - start_arg).count() / 1000.0 << std::endl;

    std::cout << "Prediction done" << std::endl;
    return argmax_tensor.to(torch::kCPU).to(torch::kFloat32);

}

float16 版

torch::Tensor OnnxInference_f16(const ORTCHAR_T* onnx_path, const itk::Size<3>& image_size, const at::IntArrayRef& ori_dims, const torch::Tensor& image_tensor, const torch::Tensor& gmap, float step_size) {

    auto start1 = std::chrono::high_resolution_clock::now();
    Ort::Env env(OrtLoggingLevel::ORT_LOGGING_LEVEL_WARNING, "test");
    Ort::SessionOptions session_options;
    OrtCUDAProviderOptions cuda_options{};
    session_options.SetGraphOptimizationLevel(GraphOptimizationLevel::ORT_ENABLE_EXTENDED);
    session_options.AppendExecutionProvider_CUDA(cuda_options);
    std::cout << "CUDA Provider has been appended." << std::endl;
    Ort::Session session(env, onnx_path, session_options);
    Ort::AllocatorWithDefaultOptions allocator;
    //auto endt1 = std::chrono::high_resolution_clock::now();


    //auto start1 = std::chrono::high_resolution_clock::now();
    auto [numInputNodes, inputNameStr, inputType, inputDims] = GetInputInfo(session, allocator);
    auto [numOutputNodes, outputNameStr, outputType, outputDims] = GetOutputInfo(session, allocator);

    size_t inputTensorSize = vectorProduct(inputDims);
    //std::cout << "Size of inputTensorSize: " << inputTensorSize << std::endl;
    std::vector<const char*> inputNames{ "input" };

    size_t outputTensorSize = vectorProduct(outputDims);
    std::vector<Ort::Float16_t> outputTensorValues(outputTensorSize);
    std::vector<const char*> outputNames{ "output" };

    Ort::MemoryInfo memoryInfo = Ort::MemoryInfo::CreateCpu(
        OrtAllocatorType::OrtArenaAllocator, OrtMemType::OrtMemTypeDefault);

    std::vector<int64_t> patch_size(inputDims.begin() + 2, inputDims.end());
    std::vector<std::vector<int64_t>> steps = Compute_steps_for_sliding_window(patch_size, image_size, step_size);

    int num_tiles = steps[0].size() * steps[1].size() * steps[2].size();
    std::cout << "Num_tiles :" << num_tiles << std::endl;
    std::cout << std::endl;


    torch::Tensor aggregated_results = torch::empty({ 1, outputDims[1], static_cast<long long>(image_size[0]), static_cast<long long>(image_size[1]),
         static_cast<long long>(image_size[2]) }, torch::kFloat16).to(torch::kCUDA);
    auto endt1 = std::chrono::high_resolution_clock::now();

    std::cout << "load model time: " << duration_cast<milliseconds>(endt1 - start1).count() / 1000.0 << std::endl;
    std::cout << "model load completed." << std::endl;
    std::cout << std::endl;

    torch::Tensor aggregated_nb_of_predictions = torch::empty({ 1, outputDims[1], static_cast<long long>(image_size[0]), static_cast<long long>(image_size[1]),
         static_cast<long long>(image_size[2]) }, torch::kFloat16).to(torch::kCUDA);
    std::vector<long long> durations;

    for (int x : steps[0]) {
        int lb_x = x;
        int ub_x = x + patch_size[0];

        for (int y : steps[1]) {
            int lb_y = y;
            int ub_y = y + patch_size[1];

            for (int z : steps[2]) {
                int lb_z = z;
                int ub_z = z + patch_size[2];

                auto start_p = std::chrono::high_resolution_clock::now();
                torch::Tensor sliced_tensor = image_tensor.slice(2, lb_x, ub_x)
                    .slice(3, lb_y, ub_y)
                    .slice(4, lb_z, ub_z)
                    .contiguous()
                    .to(torch::kFloat16);

                std::vector<Ort::Float16_t> inputTensorValues(sliced_tensor.data_ptr<at::Half>(),
                    sliced_tensor.data_ptr<at::Half>() + sliced_tensor.numel());

                std::vector<Ort::Value> inputTensors;
                inputTensors.push_back(Ort::Value::CreateTensor<Ort::Float16_t>(
                    memoryInfo, inputTensorValues.data(), inputTensorSize,
                    inputDims.data(), inputDims.size()));

                std::vector<Ort::Value> outputTensors;
                outputTensors.push_back(Ort::Value::CreateTensor<Ort::Float16_t>(
                    memoryInfo, outputTensorValues.data(), outputTensorSize,
                    outputDims.data(), outputDims.size()));

                session.Run(Ort::RunOptions{ nullptr }, inputNames.data(),
                    inputTensors.data(), inputTensors.size(),
                    outputNames.data(), outputTensors.data(), outputTensors.size());

               auto predicted_patch = outputTensors[0].GetTensorMutableData<Ort::Float16_t>();

                torch::Tensor pred = torch::from_blob(predicted_patch, outputDims, torch::kFloat16).contiguous().to(torch::kCUDA);

                aggregated_results
                    .slice(2, lb_x, ub_x)
                    .slice(3, lb_y, ub_y)
                    .slice(4, lb_z, ub_z)
                    .add_(pred * gmap);

                //aggregated_nb_of_predictions
                //    .slice(2, lb_x, ub_x)
                //    .slice(3, lb_y, ub_y)
                //    .slice(4, lb_z, ub_z) += gmap;

                auto end_p = std::chrono::high_resolution_clock::now();
                std::cout << "one tile: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_p - start_p).count() / 1000.0 << std::endl;

                auto duration_p = std::chrono::duration_cast<std::chrono::milliseconds>(end_p - start_p).count();
                durations.push_back(duration_p);
            }
        }

    }

    //aggregated_results /= aggregated_nb_of_predictions;

    long long sum = std::accumulate(durations.begin(), durations.end(), 0LL);
    std::cout << "All prediction time over " << num_tiles << " runs: " << sum / 1000.0 << " seconds." << std::endl;

    namespace F = torch::nn::functional;


    std::vector<int64_t> size_vec = { static_cast<int64_t>(ori_dims[0]),
                                  static_cast<int64_t>(ori_dims[1]),
                                  static_cast<int64_t>(ori_dims[2]) };

    auto start_ = std::chrono::high_resolution_clock::now();
    torch::Tensor result = torch::softmax(aggregated_results.to(torch::kCUDA), 1);
   

    torch::Tensor reampled_tensor = F::interpolate(
        aggregated_results,
        F::InterpolateFuncOptions().size(size_vec).mode(torch::kTrilinear).align_corners(false)
    );
    torch::cuda::synchronize();
    auto end_ = std::chrono::high_resolution_clock::now();
    std::cout << "r: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_ - start_).count() / 1000.0 << std::endl;


    auto s = std::chrono::high_resolution_clock::now();
    auto argmax_tensor = torch::argmax(reampled_tensor, 1, true).squeeze();
    torch::cuda::synchronize();
    auto e = std::chrono::high_resolution_clock::now();
    std::cout << "p1: " << std::chrono::duration_cast<std::chrono::milliseconds>(e - s).count() / 1000.0 << std::endl;

    auto start_arg = std::chrono::high_resolution_clock::now();
    torch::cuda::synchronize();
    auto end_arg = std::chrono::high_resolution_clock::now();
    std::cout << "p2: " << std::chrono::duration_cast<std::chrono::milliseconds>(end_arg - start_arg).count() / 1000.0 << std::endl;
    std::cout << "Prediction done" << std::endl;
    auto argmax_tensor_cpu = argmax_tensor.detach().cpu();

    return argmax_tensor_cpu;

}

yolov5 yolov8 yolov10 Ultralytics 奇奇怪怪的错误汇总:【版本兼容，模型训练，数据加载，模型加速】
shiter编写程序的艺术
09-20 2025
用起来这么火的库，问题这么多么？
【国产大模型 × 房地产】智能选址与市场动态预测系统搭建全流程实战
最新发布
在信息的熵增中，记录结构、重建秩序。 技术思想者的笔记，系统构建者的注释。
05-05 27
随着房地产行业进入“存量竞争 + 精准运营”阶段，智能化选址与市场动态预测能力成为核心竞争力。传统依赖人工经验与静态报表的模式已难以应对复杂的城市发展格局与多维数据交织的地块价值评估需求。本文基于国产大模型 DeepSeek 与千问（Qwen）构建一套具备多因子融合建模、房价预测、市场热度追踪、自然语言选址解释能力的全链路系统。系统实现了从区域数据采集 → 空间要素提取 → 大模型建模 → 智能策略生成的完整工程闭环，已在多个地产运营机构中完成试点，显著提升选址效率与市场研判能力，为构建地产领域的数据驱动型
ONNX：C++通过onnxruntime使用.onnx模型进行前向计算【下载的onnxruntime是编译好的库文件，可直接使用】
u013250861的博客
11-13 9457
利用onnx和onnxruntime实现深度框架使用C++推理进行服务器部署，模型推理的性能是比python快很多的。
onnxruntime C++部署floa16模型yolov5 7.0
qq_53014782的博客
04-25 745
将float都改为Ort::Float16_t
onnxruntime对bfloat16的支持
lbai7134的博客
11-16 2061
onnxruntime对bfloat16的支持
onnxruntime cuda
4月16！的博客
12-02 2032
#include <onnxruntime_cxx_api.h> #include <onnxruntime_c_api.h> #include <cuda_provider_factory.h> #include <iostream> #include <vector> struct MNIST { MNIST() { env = Ort::Env(ORT_LOGGING_LEVEL_VERBOSE, "test.
【onnxruntime推理】LSTM时序预测模型（含多输入）C++部署（CMake编译）
qq_40734883的博客
12-07 2049
本文主要介绍在linux开发环境中如何使用C++和Cmake对LSTM进行部署推理。之所以不在vscode等编译软件上直接进行设置，是因为笔者认为CMake更好，可以编辑对应的语法，也可以避免路径设置（CMake直接传入指定路径）等相关问题。
OCR 跨平台工程化onnxruntime gpu c++代码
weixin_42280271的博客
07-22 2856
OCR 跨平台工程化onnxruntime gpu c++代码 网上关于onnxruntime运行在gpu环境下运行OCR模型的代码较少，经过查阅，其实就是在初始化模型的时候这样写就可以了 void DbNet::setNumThread(int numOfThread) { numThread = numOfThread; //===session options=== // Sets the number of threads used to parallelize the ex
YOLOv5模型ONNX部署实战：OpenCV实现目标检测（附性能优化技巧）
[YOLOv5模型ONNX部署实战：OpenCV实现目标检测（附性能优化技巧）](https://img-blog.csdnimg.cn/20210411160817688.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9...
人脸检测源码FaceDetection
05-05
5. 滑动窗口搜索：在图像上以不同大小和位置的窗口遍历，应用分类器进行人脸检测。 6. 后处理：合并相邻的检测框，去除重复或过小的检测结果，提高检测精度。 7. OpenCV库支持：OpenCV是一个强大的计算机视觉库，...
C++ OnnxRuntime部署yolov8模型
12-09
C++部署YOLO模型 C++ OnnxRuntime部署yolov8模型
边缘计算+大数据：传感器数据处理新范式
大数据洞察的博客
04-23 887
物联网（IoT）时代，全球传感器设备数量预计2025年突破270亿台，每天产生超过500ZB的异构数据。时延瓶颈：云端处理往返时延通常>100ms，无法满足自动驾驶（<10ms）等实时性需求带宽浪费：原始传感器数据包含大量无效噪声，直接上传云端导致网络拥塞隐私风险：医疗、金融等领域原始数据上云存在泄露风险可靠性不足：网络中断时系统完全瘫痪本文聚焦边缘计算如何与大数据技术融合，构建"本地实时处理+云端深度分析"的分层架构，解决传统架构痛点，定义传感器数据处理的新范式。基础理论。
机器视觉系列5：C++部署pytorch模型onnxruntime
热门推荐
axe的博客
10-12 1万+
环境：visual studio 2019；pytorch1.8；
[C++][onnxruntime]攻克onnxruntime之自动切换CPU和GPU
FL1623863129的博客
06-21 3474
要求：如果你用的onnxruntime是cpu版本的就用cpu，如果你用onnxruntime是gpu版本则自动使用GPU，这样就不用每次换个库来回修改代码了。这个怎么实现呢，具体看下面代码。
人体姿态估计 HRNet C++版
xz1203的博客
04-25 4205
最近由于项目原因，需要用到HRNet网络，加上前面的目标检测部分，使用python版本的代码运行太慢，于是想到了用c++来重写HRNet，将pytorch的模型文件转换为onnx，采用onnx的c++的推理库。然后目标检测网络采用轻量级的nanodet，同时也采用onnx进行推理。最后，在我的笔记本电脑上（GTX960M）进行单人的姿态估计也跑到了20帧左右。其中nanodet是0.01s左右，hrnet是0.04s左右，hrnet是w32_256*192的模型转换而来的。多人的话时间就是成倍增长。
onnxruntime和tensorrt多batch推理
taifyang的博客
12-10 2843
【代码】onnxruntime和tensorrt多batch推理。
onnxruntime gpu/cpu 推理onnx vs2019c++
weixin_46433743的博客
05-15 429
onnx onnxruntime cuda cudnn对应关系。
onnxruntim的使用方法
qq_44089890的博客
05-09 7172
ONNX Runtime 是一个用于高效推理 ONNX 模型的开源引擎。ONNX 是一种开放的深度学习模型交换格式，可以用于将深度学习模型从一个框架转换到另一个框架，从而实现跨平台和跨框架的模型部署和推理。ONNX Runtime 提供了一个高度优化的推理引擎，可在多种硬件平台上以低延迟和高吞吐量运行 ONNX 模型。
pytorch深度学习入门（16）之-使用onnx模型混合精度Float16量化
ajunbin859的专栏
11-17 2231
将模型转换为使用 float16 而不是 float32 可以减小模型大小（最多一半）并提高某些 GPU 上的性能。可能会有一些精度损失，但在许多模型中，新的精度是可以接受的。ORT 将在运行时优化这对，因此结果将保持全精度。混合精度工具的工作原理是将操作集群转换为 float16。如果 float16 转换的结果很差，您可以将大部分操作转换为 float16，但保留一些操作为 float32。由于 ONNX Runtime 的 CPU 版本不支持 float16 运算，并且该工具需要测量精度损失，因此。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值