从ONNX到TensorRT引擎:Python与C++模型转换实战教程

onnx模型部署 python_ONNX 介绍及TensorRT部署 ONNX简介Open Neural Network Exchange(ONNX,开放神经网络交换)格式,是一个用于表示深度学习模型的标准,可使模型在不同框架之间进行转移。【ONNX是一种针对机器学习所设计的开放式的文件格式,用于存储训练好的模型。它使得不同的人工智能框架(如Pytorch, MXNet)可以采用相同格式存储模型数据并交互。 ONNX的规范及代码主要由微软,亚马逊 ,Facebook... 阅读详情

从ONNX到TensorRT引擎:Python与C++模型转换实战教程

在模型部署的最后一公里,我们常常会遇到一个核心矛盾:训练框架(如PyTorch、TensorFlow)生成的模型,如何在生产环境中实现极致的推理性能?如果你的答案是“直接上原框架”,那么你可能会错过一个数量级的加速潜力。今天,我们深入探讨的,正是解决这一矛盾的“硬核”技术路径——将标准的ONNX模型,转换为NVIDIA TensorRT引擎。这不仅仅是格式转换,而是一次从通用计算到高度定制化硬件加速的深度优化之旅。

对于需要处理实时视频流、高并发在线服务或边缘设备上部署复杂模型的AI工程师而言,TensorRT带来的性能提升往往是决定性的。它通过层融合、精度校准、内核自动调优等技术,将模型“重塑”为最适合特定GPU架构的执行计划。本教程将摒弃泛泛而谈,聚焦于Python和C++两种最主流的工程化实现方式,手把手带你走过从环境搭建、模型解析、引擎构建到最终推理的完整闭环。无论你是希望将研究模型产品化的算法工程师,还是负责优化线上服务性能的后端开发者,这里都有你需要的实战细节。

1. 环境准备与TensorRT生态初探

在开始转换之前,一个稳定、版本匹配的TensorRT环境是基石。许多初学者遇到的第一个“拦路虎”就是环境配置,其复杂性主要源于TensorRT与CUDA、cuDNN乃至操作系统版本之间紧密的耦合关系。

首先,明确你的起点。你手头应该已经有一个训练好并导出为ONNX格式的模型文件(.onnx)。同时,请确认你开发机的NVIDIA驱动、CUDA Toolkit以及cuDNN的版本。一个常见的误区是认为TensorRT安装包会包含CUDA,实际上它只包含必要的运行时库,主CUDA环境仍需独立安装。

提示:强烈建议通过 nvidia-smi 查看驱动版本,通过 nvcc --version 查看CUDA编译工具链版本,并使用 cat /usr/local/cuda/version.txt 或 cat /usr/include/cudnn_version.h | grep CUDNN_MAJOR -A 2 来确认cuDNN。确保这三者与你要安装的TensorRT版本官方兼容。

TensorRT的安装方式多样,对于追求环境纯净和可复现性的团队,我推荐使用Tar包安装,而非系统级的deb或rpm包。这能有效避免污染系统路径,也便于在同一台机器上管理多个版本。以下是一个基于Tar包的安装与验证流程:

# 假设已将 TensorRT-8.6.1.6.Linux.x86_64-gnu.cuda-11.8.tar.gz 下载至 /opt
cd /opt
tar -xzf TensorRT-8.6.1.6.Linux.x86_64-gnu.cuda-11.8.tar.gz

# 设置环境变量(可将以下内容加入 ~/.bashrc 持久化)
export TENSORRT_ROOT=/opt/TensorRT-8.6.1.6
export LD_LIBRARY_PATH=$TENSORRT_ROOT/lib:$LD_LIBRARY_PATH
export PATH=$TENSORRT_ROOT/bin:$PATH

# 安装Python wheel包
cd $TENSORRT_ROOT/python
pip install tensorrt-8.6.1.6-cp38-none-linux_x86_64.whl  # 请根据你的Python版本选择对应的whl文件

# 验证安装
python3 -c "import tensorrt; print(tensorrt.__version__)"
# 预期输出:8.6.1.6

如果上述命令成功输出版本号,恭喜你,Python环境已就绪。对于C++开发者,还需要确保编译器能找到头文件和库。你可以通过编译并运行一个简单的示例程序来测试。

// test_trt_install.cpp
#include <NvInfer.h>
#include <iostream>

int main() {
    nvinfer1::ILogger* logger = nullptr; // 实际使用时应实现一个logger
    nvinfer1::IBuilder* builder = nvinfer1::createInferBuilder(*logger);
    if (builder) {
        std::cout << "TensorRT C++ API 初始化成功!" << std::endl;
        builder->destroy();
        return 0;
    } else {
        std::cerr << "TensorRT C++ API 初始化失败!" << std::endl;
        return -1;
    }
}

使用如下命令编译(请根据你的实际路径调整):

g++ -std=c++14 test_trt_install.cpp -o test_trt_install \
-I$TENSORRT_ROOT/include \
-L$TENSORRT_ROOT/lib -lnvinfer -lcudart

2. 核心转换器:Python接口深度解析

使用Python接口进行转换,其优势在于原型验证快速、与训练框架(PyTorch)结合紧密,非常适合算法工程师进行模型部署的初步探索和自动化流水线构建。整个过程可以概括为三个核心步骤:构建器(Builder)与网络定义、解析ONNX模型、配置与构建引擎。

让我们从一个具体的例子出发。假设我们有一个简单的卷积神经网络,并已导出为 resnet18.onnx。以下代码展示了完整的转换流程,并包含了关键的异常处理和配置选项。

import tensorrt as trt
import pycuda.driver as cuda
import pycuda.autoinit  # 用于初始化CUDA上下文
import numpy as np

def build_engine_from_onnx(onnx_file_path, engine_file_path, fp16_mode=True, max_workspace_size=1<<30):
    """
    从ONNX文件构建TensorRT引擎并序列化保存。
    
    参数:
        onnx_file_path: ONNX模型文件路径。
        engine_file_path: 输出的TensorRT引擎文件路径。
        fp16_mode: 是否启用FP16精度优化。
        max_workspace_size: 最大工作空间大小(字节),用于层实现选择。
    """
    # 1. 创建日志记录器、构建器和网络
    TRT_LOGGER = trt.Logger(trt.Logger.WARNING)  # 使用WARNING级别减少输出噪音
    builder = trt.Builder(TRT_LOGGER)
    network = builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH))
    config = builder.create_builder_config()
    
    # 2. 配置构建参数
    config.max_workspace_size = max_workspace_size
    if fp16_mode and builder.platform_has_fast_fp16:
        config.set_flag(trt.BuilderFlag.FP16)
        print("FP16 模式已启用。")
    
    # 3. 使用ONNX解析器填充网络
    parser = trt.OnnxParser(network, TRT_LOGGER)
    with open(onnx_file_path, 'rb') as model:
        if not parser.parse(model.read()):
            print("ONNX解析失败:")
            for error in range(parser.num_errors):
                print(parser.get_error(error))
            return None
    
    # 4. 处理动态形状(如果模型输入是动态的)
    profile = builder.create_optimization_profile()
    input_tensor = network.get_input(0)
    input_name = input_tensor.name
    input_shape = input_tensor.shape
    
    # 假设我们处理的是最常见的动态Batch维度(-1)
    if input_shape[0] == -1:
        # 定义最小、最优、最大的Batch大小
        min_shape = (1, *input_shape[1:])
        opt_shape = (4, *input_shape[1:])  # 典型推理批次
        max_shape = (16, *input_shape[1:]) # 支持的最大批次
        profile.set_shape(input_name, min_shape, opt_shape, max_shape)
        config.add_optimization_profile(profile)
        print(f"已配置动态输入形状: {input_name}, min{min_shape}, opt{opt_shape}, max{max_shape}")
    
    # 5. 构建并序列化引擎
    print("开始构建引擎,这可能需要几分钟...")
    serialized_engine = builder.build_serialized_network(network, config)
    
    if serialized_engine is None:
        print("引擎构建失败。")
        return None
    
    # 6. 保存引擎文件
    with open(engine_file_path, "wb") as f:
        f.write(serialized_engine)
    print(f"引擎已成功保存至: {engine_file_path}")
    
    return serialized_engine

# 使用函数
if __name__ == "__main__":
    onnx_path = "./models/resnet18.onnx"
    engine_path = "./engines/resnet18_fp16.engine"
    build_engine_from_onnx(onnx_path, engine_path, fp16_mode=True)

在这段代码中,有几个极易出错但至关重要的细节:

  • 显式批处理(EXPLICIT_BATCH):现代ONNX模型(opset >= 7)通常使用显式批处理维度。创建网络时必须使用对应的标志,否则解析会失败。
  • 动态形状配置:这是支持可变尺寸输入(如不同批次的图片、可变长度的序列)的关键。set_shape 必须为每个动态维度提供最小、最优、最大值,TensorRT会为这个范围内的所有形状生成优化内核。
  • 工作空间(Workspace):max_workspace_size 限制了层实现算法可使用的临时GPU内存。给得太小可能阻止某些融合优化,给得太大则浪费内存。1 << 30(1GB)是一个常见的起始值。

注意:builder.build_serialized_network 是较新API(TensorRT 8.0+),它直接返回序列化后的引擎缓冲区。旧版API使用 builder.build_engine(network, config) 返回一个 ICudaEngine 对象,然后再调用 engine.serialize()。

3. 工业级部署:C++接口的稳健实现

当你的模型需要集成到C++生产服务中,或者对推理延迟有极致要求时,使用C++接口进行转换和推理是更专业的选择。C++实现避免了Python解释器的开销,内存控制更精细,并且能更好地与现有C++基础设施集成。

C++的转换流程与Python在逻辑上完全对应,但API风格更底层,资源管理(创建与销毁)需要开发者手动负责,这既是挑战也是优势。下面,我们构建一个健壮的C++转换类。

// TensorRTEngineBuilder.h
#pragma once
#include <string>
#include <memory>
#include <NvInfer.h>
#include <NvOnnxParser.h>

class Logger : public nvinfer1::ILogger {
public:
    void log(Severity severity, const char* msg) noexcept override {
        // 仅打印错误和警告信息,忽略冗余的INFO
        if (severity <= Severity::kWARNING) {
            std::cout << "[TensorRT] ";
            switch (severity) {
                case Severity::kINTERNAL_ERROR: std::cout << "INTERNAL_ERROR: "; break;
                case Severity::kERROR: std::cout << "ERROR: "; break;
                case Severity::kWARNING: std::cout << "WARNING: "; break;
                default: break;
            }
            std::cout << msg << std::endl;
        }
    }
};

class TensorRTEngineBuilder {
public:
    TensorRTEngineBuilder();
    ~TensorRTEngineBuilder();

    // 从ONNX文件构建引擎并保存
    bool buildEngineFromONNX(const std::string& onnxFilePath,
                             const std::string& engineFilePath,
                             bool enableFP16 = true,
                             size_t maxWorkspaceSize = 1ULL << 30); // 默认1GB

    // 直接加载已构建的引擎文件
    std::shared_ptr<nvinfer1::ICudaEngine> loadEngine(const std::string& engineFilePath);

private:
    Logger m_logger;
    std::shared_ptr<nvinfer1::ICudaEngine> m_engine;
};
// TensorRTEngineBuilder.cpp
#include "TensorRTEngineBuilder.h"
#include <fstream>
#include <cassert>

TensorRTEngineBuilder::TensorRTEngineBuilder() {}
TensorRTEngineBuilder::~TensorRTEngineBuilder() {
    // 智能指针会自动管理引擎生命周期
}

bool TensorRTEngineBuilder::buildEngineFromONNX(const std::string& onnxFilePath,
                                                const std::string& engineFilePath,
                                                bool enableFP16,
                                                size_t maxWorkspaceSize) {
    // 1. 创建构建器和配置
    std::unique_ptr<nvinfer1::IBuilder> builder(nvinfer1::createInferBuilder(m_logger));
    if (!builder) {
        m_logger.log(nvinfer1::ILogger::Severity::kERROR, "创建IBuilder失败。");
        return false;
    }

    const auto explicitBatch = 1U << static_cast<uint32_t>(nvinfer1::NetworkDefinitionCreationFlag::kEXPLICIT_BATCH);
    std::unique_ptr<nvinfer1::INetworkDefinition> network(builder->createNetworkV2(explicitBatch));
    std::unique_ptr<nvinfer1::IBuilderConfig> config(builder->createBuilderConfig());

    // 2. 解析ONNX模型
    std::unique_ptr<nvonnxparser::IParser> parser(nvonnxparser::createParser(*network, m_logger));
    if (!parser->parseFromFile(onnxFilePath.c_str(), static_cast<int>(nvinfer1::ILogger::Severity::kWARNING))) {
        m_logger.log(nvinfer1::ILogger::Severity::kERROR, "解析ONNX文件失败。");
        return false;
    }

    // 3. 配置构建参数
    config->setMaxWorkspaceSize(maxWorkspaceSize);
    if (enableFP16 && builder->platformHasFastFp16()) {
        config->setFlag(nvinfer1::BuilderFlag::kFP16);
        std::cout << "FP16 模式已启用。" << std::endl;
    }

    // 4. 处理动态输入(示例:动态Batch)
    if (network->getNbInputs() > 0) {
        auto* input = network->getInput(0);
        nvinfer1::Dims dims = input->getDimensions();
        if (dims.d[0] == -1) { // 动态Batch维度
            std::string inputName = input->getName();
            auto profile = builder->createOptimizationProfile();
            // 设置最小、最优、最大形状
            nvinfer1::Dims4 minDims(1, dims.d[1], dims.d[2], dims.d[3]);
            nvinfer1::Dims4 optDims(4, dims.d[1], dims.d[2], dims.d[3]);
            nvinfer1::Dims4 maxDims(16, dims.d[1], dims.d[2], dims.d[3]);
            profile->setDimensions(inputName.c_str(), nvinfer1::OptProfileSelector::kMIN, minDims);
            profile->setDimensions(inputName.c_str(), nvinfer1::OptProfileSelector::kOPT, optDims);
            profile->setDimensions(inputName.c_str(), nvinfer1::OptProfileSelector::kMAX, maxDims);
            config->addOptimizationProfile(profile);
        }
    }

    // 5. 构建引擎
    std::unique_ptr<nvinfer1::IHostMemory> serializedModel(builder->buildSerializedNetwork(*network, *config));
    if (!serializedModel) {
        m_logger.log(nvinfer1::ILogger::Severity::kERROR, "构建序列化网络失败。");
        return false;
    }

    // 6. 保存引擎到文件
    std::ofstream outFile(engineFilePath, std::ios::binary);
    if (!outFile) {
        m_logger.log(nvinfer1::ILogger::Severity::kERROR, "无法打开引擎文件进行写入。");
        return false;
    }
    outFile.write(reinterpret_cast<const char*>(serializedModel->data()), serializedModel->size());
    outFile.close();

    std::cout << "TensorRT引擎已成功构建并保存至: " << engineFilePath << std::endl;
    return true;
}

C++版本代码体现了资源获取即初始化(RAII) 的思想,使用 std::unique_ptr 配合自定义删除器来管理TensorRT对象生命周期,有效防止了内存泄漏。与Python脚本相比,它更适用于需要长期运行、高稳定性的服务器端应用。

4. 性能调优与高级技巧

成功转换出引擎文件只是第一步,要让TensorRT发挥最大威力,还需要深入其调优机制。这里有几个在实践中被反复验证有效的策略。

精度策略的权衡:TensorRT支持FP32、FP16和INT8精度。选择哪种,取决于你的模型、硬件和对精度的要求。

精度模式性能提升精度损失风险适用场景额外步骤
FP32基准无对精度要求极高的任务(如某些科学计算)无
FP16显著 (1.5-3倍)轻微,大多数模型可接受绝大多数视觉、NLP模型, Ampere及更新架构GPU通常可直接启用
INT8极致 (2-5倍)明显,需校准对延迟极度敏感,且模型对量化友好的场景(如目标检测)需要校准数据集进行量化校准

启用FP16非常简单,如前面代码所示。而INT8量化则复杂得多,需要提供一个校准数据集,让TensorRT在构建引擎时分析各层激活值的分布,从而确定最优的量化参数。

# INT8量化校准示例(Python)
import tensorrt as trt
import numpy as np

class MyCalibrator(trt.IInt8EntropyCalibrator2):
    def __init__(self, calibration_data_path, batch_size, input_shape):
        super().__init__()
        self.batch_size = batch_size
        self.input_shape = input_shape
        self.calibration_data = self.load_calibration_data(calibration_data_path)
        self.current_index = 0
        self.device_input = cuda.mem_alloc(self.batch_size * np.prod(input_shape) * np.dtype(np.float32).itemsize)

    def get_batch_size(self):
        return self.batch_size

    def get_batch(self, names):
        if self.current_index >= len(self.calibration_data):
            return None  # 校准完成
        batch = self.calibration_data[self.current_index:self.current_index+self.batch_size]
        self.current_index += self.batch_size
        # 将数据复制到GPU(这里简化处理)
        cuda.memcpy_htod(self.device_input, np.ascontiguousarray(batch))
        return [int(self.device_input)]

    # ... 需要实现其他必要方法,如 read_calibration_cache, write_calibration_cache

层融合与内核选择:这是TensorRT自动优化的核心。构建器会尝试将多个层(如Conv + Bias + ReLU)融合为一个单一的内核,减少内存读写和内核启动开销。你可以通过设置不同的策略搜索参数来影响这个过程:

config = builder.create_builder_config()
# 1. 设置构建器级别(控制优化时间与效果)
# builder.builder_optimization_level = 5  # 最高级别优化(可能耗时很长)
# 2. 设置时序缓存(Tactic Timings Cache)
# 可以保存和重用不同层的内核性能测量结果,显著加速后续构建过程
config.set_timing_cache(timing_cache, ignore_mismatch=False)

Profile与性能分析:构建引擎后,不要急于投入生产。使用 trtexec 工具进行基准测试是极好的习惯。

# 使用 trtexec 对构建好的引擎进行基准测试
$TENSORRT_ROOT/bin/trtexec --loadEngine=./engines/resnet18_fp16.engine \
  --shapes=input:4x3x224x224 \ # 指定输入形状
  --iterations=100 \            # 运行100次迭代
  --avgRuns=10 \               # 取10次运行的平均时间
  --duration=10 \              # 运行至少10秒
  --exportTimes=timing.json    # 导出详细时序信息

这个命令会输出详细的延迟(端到端、GPU计算)、吞吐量等信息,并生成一个JSON文件,里面包含了每一层操作的执行时间,是定位性能瓶颈的利器。

5. 常见陷阱与调试指南

即使按照教程一步步操作,你也可能会遇到各种问题。下面我整理了几个最常见的“坑”及其解决方案。

问题一:ONNX解析失败,报错“No importer registered for op ...”

  • 原因:TensorRT的ONNX解析器不支持模型中的某个算子。
  • 排查:
    1. 使用 polygraphy 工具检查ONNX模型:polygraphy inspect model model.onnx --mode=basic。
    2. 查看TensorRT官方文档的算子支持矩阵。
    3. 尝试简化模型,或用TensorRT原生API重写不支持的操作。
  • 临时方案:对于不支持的算子,可以尝试使用ONNX-TensorRT的插件机制,或者将该部分计算留在TensorRT外部(后处理)。

问题二:构建引擎时卡住或内存爆炸

  • 原因:max_workspace_size 设置过大,或者模型过于复杂,构建器在尝试大量不同的内核实现和融合策略。
  • 解决:
    1. 适当减小 max_workspace_size,例如从1GB减到256MB。
    2. 降低构建器优化级别:config.builder_optimization_level = 3。
    3. 使用时序缓存,避免重复测量。

问题三:动态形状模型推理时,性能远低于固定形状

  • 原因:TensorRT为动态形状的每个可能维度组合生成的内核可能不是最优的,或者profile设置的范围过宽。
  • 优化:
    1. 尽可能缩紧动态范围。如果你的业务场景中Batch size通常是1, 2, 4,就不要设置max为32。
    2. 考虑使用多个优化Profile。例如,为“高吞吐”场景(Batch=8)和“低延迟”场景(Batch=1)分别创建Profile,运行时根据需求选择。

问题四:FP16/INT8精度下模型输出异常或精度下降严重

  • 原因:模型中存在对数值范围敏感的算子(如Softmax, LayerNorm),或者激活值分布不均匀。
  • 调试:
    1. 逐层调试:在构建配置中启用调试输出,或使用polygraphy的debug模式,对比FP32和FP16/INT8每一层的输出差异。
    2. 选择性量化:对于敏感层,可以强制其保持FP32精度。这需要更底层的API操作或使用高级框架(如Torch-TensorRT)。
    3. 校准数据:对于INT8,确保校准数据具有代表性,覆盖了推理时可能遇到的各种输入分布。

掌握从ONNX到TensorRT的转换,本质上是在理解模型计算图的基础上,与硬件编译器进行一场深度对话。Python接口让你快速验证想法,而C++实现则赋予你构建坚如磐石生产系统的能力。记住,没有一劳永逸的配置,最好的引擎永远是针对你的具体模型、数据和硬件平台,经过反复迭代和调优得来的。在实际项目中,我习惯建立一个自动化测试流水线,每当模型更新时,自动触发不同精度、不同Profile的引擎构建和基准测试,从中选出在延迟和精度之间平衡最优的那个。这个过程本身,就是模型部署工程化的精髓所在。

onnx入门教程(六)——TensorRT 模型构建与推理 TensorRT 是由 NVIDIA 发布的深度学习框架,用于在其硬件上运行深度学习推理。TensorRT 提供量化感知训练和离线量化功能,用户可以选择 INT8 和 FP16 两种优化模式,将深度学习模型应用到不同任务的生产部署,如视频流、语音识别、推荐、欺诈检测、文本生成和自然语言处理。TensorRT 经过高度优化,可在 NVIDIA GPU 上运行, 并且可能是目前在 NVIDIA GPU 运行模型最快的推理引擎。关于 TensorRT 更具体的信息可以访问 TensorRT官网 了解。 阅读详情

相关推荐

onnx 转 tensorrt 的几种方法

onnx转tensoorrt的几种方法总结

ywfwyht的博客 3225

ONNX转TensorRT加速模型推理

前言 TensorRT是NVIDIA推出的一款高效深度学习模型推理框架,其包括了深度学习推理优化器和运行时,能够让深度学习推理应用拥有低时延和高吞吐的优点。 本质上来讲,就是通过采用对模型中的部分算子进行融合、对特定尺寸的算子选用更好的实现方法,以及使用混合精度等方式,最终加速整个网络的推理速度。 在使用PyTorch训练得到网络模型后,我们希望在模型部署时通过TensorRT加速模型推理,那么可以先将PyTorch模型转为ONNX,然后再讲ONNX转为TensorRT的engine。 实现步骤 PyT

TracelessLe的专栏 1万+

TensorRT C++部署全流程:从ONNX模型到高性能GPU推理引擎

深度学习模型部署是算法落地生产环境的关键环节,其核心目标在于将训练好的模型高效、稳定地集成到实际应用中。模型推理性能直接决定了服务的响应速度和吞吐量,尤其在实时性要求高的场景。为了突破Python框架在推理时的性能瓶颈,NVIDIA推出了TensorRT,这是一个专为NVIDIA GPU设计的高性能深度学习推理SDK。其核心原理是通过编译优化技术,对模型进行层融合、精度校准和内核自动调优,生成高度定制化的推理引擎,从而在硬件层面实现极致加速。这项技术的核心价值在于显著降低推理延迟、提升吞吐量,并减少资源占用

weixin_31774841的博客 343

【TensorRT C++ API模型加速】TensorRT环境配置、模型转换、CUDA C++加速、TensorRT C++ 加速

TensorRT(Tensor Runtime,TRT):由 NVIDIA 开发,专为 NVIDIA GPU 设计的,用于深度学习高性能推理的SDK (software development kit ,软件开发工具包),可为推理应用程序提供低延迟和高吞吐量。

📷 图像处理践行者 | 传统算法 · 深度学习 · 多模态 | 分享实战经验与技术洞见,探索从像素到智能的无限可能。 2881

【高分子材料工程】嵌件注塑结构设计与工艺优化:金属-塑料复合件界面强度及失效预防技术规范

内容概要:本文系统阐述了嵌件注塑(Insert Molding)的设计参数、模具关键技术及失效预防措施,聚焦黄铜H62或304不锈钢与PA66-GF30材料组合的基准工况,提供可用于工程图纸、DFM检查、模具验收和工艺规程的量化依据。内容涵盖工艺边界界定、材料匹配与界面力学分析、结构设计参数(如包覆壁厚、滚花、倒角)、模具设计要点(定位、浇口、排气、冷却)、工艺参数窗口、八大失效模式及其对策、验证验收标准以及量产控制要求,强调通过DFM仿真、模流分析和DOE试模优化工艺,并列出常见设计误区与纠正方案。; 适合人群:从事注塑产品设计、模具开发、工艺工程及质量管理的工程技术人员,尤其适用于汽车、电子、医疗等行业中具备1-3年及以上相关经验的研发人员; 使用场景及目标:①指导嵌件注塑零件的可制造性设计与结构优化;②支持模具设计评审与验收;③制定试模调机与量产工艺规范;④开展失效分析与质量改进; 阅读建议:此资源兼具理论机制与工程实践,建议结合实际项目对照查阅,重点关注包覆壁厚、预热温度、浇口布置等关键参数的取值边界,并在应用非基准材料时进行线膨胀系数与收缩率的换算修正,避免直接套用数据。

Linux 隐藏进程

这种方式属于DKoM(Direct Kernel Object Manipulation)攻击方式了,即直接内核对象操作技术。关于第一种hook方式可以参考上一篇文章。最后推荐一个rootkit工具。

chi's blog 2051

YOLOv8 Tensorrt Python/C++部署教程

利用Tensorrt部署YOLOv8

weixin_45747759的博客 1万+

基于STM32单片机智能循迹小车毕业设计

本文介绍了一种利用STM32F103C8T6单片机为控制核心,结合多种传感器以及PID算法实现循迹避障功能的智能小车。随着我国高科技水平的不断提高和工业自动化进程的不断推进,智能小车被广泛应用于各种玩具和其他产品的设计中,极大地丰富了人们的生活。本次设计利用反射式红外光电传感器探测路面黑线实现小车循迹,利用超声波测距传感器探测路径上的障碍,控制小车自动避障,整个系统具有自动循迹、自动避障、速度检测和无线遥控功能。其中,控制部分采用STM32F103C8T6单片机,STM32F103C8T6单片机是一

qq_48771816的博客 3975

从ONNX到TensorRT引擎:Python/C++双语言模型转换全攻略

本文详细介绍了如何将ONNX模型高效转换为TensorRT引擎,涵盖Python和C++双语言实现方案。内容包含环境配置、ONNX模型预处理、动态形状处理、精度优化及生产级C++部署等关键环节,旨在帮助开发者解决实际转换中的常见问题,实现GPU推理性能的极致优化。

g2h3i4j5的博客 580

国社科基金申报书“选题与说明依据”用AI怎么写?借助Gemini 3 Pro一次理清研究演进逻辑

研究进展部分要明确指出已有研究的不足与局限,比如方法不足、数据或材料受限、研究视角单一等等局限,之后要找准研究切入点,自然引申出自己的研究问题。为提升课题申报书的质量,学术史梳理要遵循述评结合、中外结合、新老结合的原则,不仅“述”,更要“评”,兼顾国内研究与国际学术动态,统筹经典研究与最新成果。它是对选题的整体概述,需阐明研究的具体问题、视角以及核心概念。2)存在问题或争议:结合已有研究或实践现状,指出该领域在理论建构、测量工具、实践应用或研究结论方面仍存在的不足、空白或争议,明确研究的必要性;

智能AI让学术科研更容易 943

Altium Designer(AD)仿真实验操作指南

1:运行仿真2:设置仿真3:放置电源模块4:放置器件模块5:探针。

XU157303764的博客 8905

yolort模型转换完全指南:从PyTorch到ONNX再到TensorRT的完整流程

yolort是一个针对YOLOv5在专用加速器(如TensorRT、LibTorch、ONNX Runtime等)上的运行时栈,本文将详细介绍如何使用yolort实现从PyTorch模型到ONNX格式,再到TensorRT引擎的完整转换流程,帮助开发者快速部署高性能目标检测应用。 ## 一、准备工作:环境搭建与项目获取 在开始模型转换之前,需要先搭建好必要的开发环境并获取yolort项目源码。

gitblog_00816的博客 863

【OpenClaw企业级智能体实战】第11篇:制造业设备预测性维护实战——OpenClaw+DeepSeek+Prometheus从零搭建(附完整代码)

本文聚焦制造业设备预测性维护的核心痛点,基于OpenClaw v2026.2.1、DeepSeek智能诊断、Prometheus监控等工具,拆解“设备状态监控→智能故障诊断→预测性维护”三大核心场景。从技术原理、算法构建、实操流程到完整代码实现,提供“数据采集→模型训练→智能调度→自动处置”的全链路方案。方案遵循工业安全规范,采用“只读优先、权限最小化”原则,适配中小制造企业落地需求。通过虚拟案例验证,可使设备非计划停机时间下降65%、平均修复时间缩短47%,既适合新手快速入门,也为进阶读者提供架构优化思路

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 608

模型部署入门教程(七):TensorRT 模型构建与推理

模型部署入门教程继续更新啦!相信经过前几期的学习,大家已经对 ONNX 这一中间表示有了一个比较全面的认识,但是在具体的生产环境中,ONNX 模型常常需要被转换成能被具体推理后端使用的模型格式。本篇教程我们就和大家一起来认识大名鼎鼎的推理后端 TensorRT。...

qq_39967751的博客 6692

Field Characteristics 深入解析,理解 SAP ABAP Analytics 中 Dimension 与 Measure 的真正边界

在SAP ABAP Analytics数据模型中,字段应建模为Dimension还是Measure,关键在于业务语义而非数据类型。Dimension提供分析上下文,构成数据坐标系,支持钻取与切片;Measure则需具备明确聚合语义(如#SUM、#MIN、#MAX),且必须满足Distinct(无重复)与Complete(无缺失)原则,确保聚合结果准确。错误的建模会导致聚合偏差,根源常在事实粒度不清或关联关系不当。因此,正确划分字段角色,本质是让Analytical Engine准确理解业务数据的分析逻辑。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 62

使用静态库在嵌入式系统中进行开发

静态库是一种包含预编译对象代码的文件,它可以与应用程序链接在一起,并在编译时将库的代码复制到最终的可执行文件中。静态库是包含预编译对象代码的文件,可以与应用程序链接在一起,并在编译时将库的代码复制到最终的可执行文件中。需要注意的是,由于嵌入式系统的资源限制,开发人员应该仔细选择需要包含在静态库中的功能,并避免引入不必要的依赖关系。需要注意的是,由于嵌入式系统的资源限制,开发人员应该仔细选择需要包含在静态库中的功能,并避免引入不必要的依赖关系。的静态库文件,可以在嵌入式系统的应用程序中使用它了。

ZrElixir的博客 206

TensorRT 推理 (onnx->engine)

TensorRT 推理 (onnx->engine)【Win10+cuda11.0+cudnn8.2.1+TensorRT8.2.5.1】

红叶谷 wsp_1138886114的博客 1万+

【RT-DETR涨点改进】全网独家首发Conv改进篇 | SCI一区 2025 | RT-DETR引入轻量级CGHalfConv通道分组半卷积模块,含多种创新改进、有效提升检测精度

本文介绍引入 GC Half-convolution 模块可以显著提升 RT-DETR 在资源受限环境下的性能。该模块通过通道分组与半卷积结合,有效减少了参数量与计算量,增强了模型对不同尺度和复杂背景下目标的特征提取能力。在保持模型轻量化的同时,GC Half-convolution 能够更细致地区分目标的边缘纹理、颜色、结构等关键信息,从而提升检测精度。特别是在面对小目标、多类别、形态相近的目标时,该模块能提取更具判别性的局部与全局特征,优化 RT-DETR 的检测效果,并加快推理速度。

Ai缝合怪、助力小伙伴高效发论文 747

从PyTorch导出ONNX使用TensorRT模型加速

LInux下TensorRT加速流程

qq_51533157的博客 2051

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

pytorch C++部署模型 ONNX tensorRT

(1) C++部署pytorch模型(上) (2) TensorRT5介绍及Pytorch转TensorRT5代码示例 TensorRT的使用步骤:(假设以及有一个训练好的模型) (1) 根据模型创建TensorRT网络定义 (2) 调用TensorRT构建器从网络创建优化的运行引擎 (3) 序列化和反序列化引擎,以便在运行时快速创建引擎 (4) 为引擎提供数据以执行计算 (3) 一般流程是这样的。 cpu: pytorch -> onnx -> onnxruntime gpu:pytorc

Dontla的博客 2585

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

【模型部署】入门教程(七):TensorRT 模型构建与推理

TensorRT 是由 NVIDIA 发布的深度学习框架,用于在其硬件上运行深度学习推理。TensorRT 提供量化感知训练和离线量化功能,用户可以选择 INT8 和 FP16 两种优化模式,将深度学习模型应用到不同任务的生产部署,如视频流、语音识别、推荐、欺诈检测、文本生成和自然语言处理。TensorRT 经过高度优化,可在 NVIDIA GPU 上运行, 并且可能是目前在 NVIDIA GPU 运行模型最快的推理引擎。关于 TensorRT 更具体的信息可以访问TensorRT官网了解。

qq_43456016的博客 2519

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

ONNX-TensorRT 安装和配置指南

### 项目介绍 ONNX-TensorRT 是一个用于将 ONNX(Open Neural Network Exchange)模型转换为 NVIDIA TensorRT 引擎的开源项目。TensorRT 是 NVIDIA 提供的高性能深度学习推理库,能够显著加速深度学习模型的推理速度。ONNX-TensorRT 项目的主要目标是提供一个高效的桥梁,使得开发者能够轻松地将 ONNX 模型部署到 T...

gitblog_09086的博客 883

ONNX-TensorRT 完整安装教程:从源码编译到 Python 包部署

ONNX-TensorRT 是一款强大的 TensorRT 后端工具,能够帮助开发者高效地将 ONNX 模型部署到 TensorRT 运行时环境中。本教程将为你提供从源码编译到 Python 包部署的完整流程,让你快速掌握这一工具的安装方法。 ## 一、准备工作:安装必要依赖 在开始安装 ONNX-TensorRT 之前,需要确保系统中已经安装了以下必要的依赖项: 1. **CMake**:

gitblog_01056的博客 913

PointPillars部署实战:ONNX与TensorRT加速推理全流程

PointPillars是一种高效的3D LiDAR目标检测算法,本指南将带你完成从模型导出到TensorRT加速的完整部署流程,帮助新手快速掌握工业级3D检测模型的优化技巧。 ## 一、环境准备与项目搭建 ### 1.1 快速克隆项目代码 ```bash git clone https://gitcode.com/gh_mirrors/po/PointPillars cd PointPill

gitblog_01025的博客 616

TensorRT C++ API:现代高性能GPU推理库完全指南

TensorRT C++ API是一个现代化、无异常抛出的C++库,专为使用NVIDIA TensorRT进行CNN模型的高性能GPU推理而设计,还提供可选的零拷贝Python绑定。它将ONNX模型转换为缓存的优化TensorRT引擎,并通过简洁的API运行,实现了边界处的名称键控张量、调用者拥有的CUDA流、显式的主机/设备传输以及`Status`/`Result<T>`错误模型,公共头文件中不

gitblog_01051的博客 1094
上一篇: MFC线程优先级全解析:如何用AfxBeginThread参数优化CPU资源分配
下一篇: RS485与CAN总线实战对比:如何根据项目需求选择最佳通信方案?
sql99
博客等级 码龄19年 168粉丝 1905原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值