TensorRT使用（Tensorflow/Keras/Pytorch）

最新推荐文章于 2024-01-04 16:27:22 发布
最新推荐文章于 2024-01-04 16:27:22 发布
阅读量1.6k 收藏 9
点赞数 2
文章标签： 人工智能 python 深度学习 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/favorxin/article/details/117229810
版权

本文旨在记录TensorRT使用情况，本人实测TensorRT加速Tensorflow，Keras，Pytorch模型，同时还对比了腾讯的Forward框架，当然Forward框架使用情况本篇文章不做记录。

环境（一）：
（1）cuda：11.0
（2）cudnn：8.0.4
（3）TensorRT：7.2.1.6
（4）pycuda：2019.1.2

环境（二）：
（1）cuda：10.0
（2）cudnn：7.6.3
（3）TensorRT：7.0.0.11
（4）pycuda：2019.1.2

一、TensorRT使用

（一）利用TensortRT加速Tensorflow模型

TensorRT官方样例：基于手写数字体识别MNIST数据集的Lenet5模型为例。

主体思想： Tensorflow->TensorRT（pb->uff）

具体流程：（1）下载MNIST数据集；（2）训练Lenet5模型；（3）将保存的模型（Lenet5.pb）转为Lenet.uff模型。

# 下载MNIST数据集
cd <TensorRT Path>/data/mnist
python download_pgms.py 

# 开始训练Lenet5模型
cd <TensorRT Path>/samples/python/end_to_end_tensorflow_mnist/
python model.py
# 可得到模型Lenet5.pb

# 转换Lenet5.pb模型为Lenet5.uff模型
convert-to-uff ./models/Lenet5.pb ./models/Lenet5.uff

最后为TensorRT加载Lenet5.uff并加速推理代码。

# -*- coding:UTF-8 -*-
from random import randint
from PIL import Image
import numpy as np
import pycuda.driver as cuda
import pycuda.autoinit
import tensorrt as trt
import sys, os
# 导入<TensorRT Path>/samples/python/common.py
sys.path.insert(1, os.path.join(sys.path[0], ".."))
import common

TRT_LOGGER = trt.Logger(trt.Logger.WARNING)

class ModelData(object):
    MODEL_FILE = "lenet5.uff"  # 模型路径
    INPUT_NAME ="input_1"  # 输入层名称 （convert-to-uff时可显示）
    INPUT_SHAPE = (1, 28, 28)  # 输入尺寸
    OUTPUT_NAME = "dense_1/Softmax"  # 输出层名称（convert-to-uff时可显示）

def build_engine(model_file):
    # For more information on TRT basics, refer to the introductory samples.
    with trt.Builder(TRT_LOGGER) as builder, builder.create_network() as network, trt.UffParser() as parser:
        builder.max_workspace_size = common.GiB(1)
        # Parse the Uff Network
        parser.register_input(ModelData.INPUT_NAME, ModelData.INPUT_SHAPE)
        parser.register_output(ModelData.OUTPUT_NAME)
        parser.parse(model_file, network)
        # Build and return an engine.
        return builder.build_cuda_engine(network)

# Loads a test case into the provided pagelocked_buffer.
def load_normalized_test_case(data_paths, pagelocked_buffer, case_num=randint(0, 9)):
    test_case_path = os.path.join(data_paths, str(case_num) + ".pgm")
    # Flatten the image into a 1D array, normalize, and copy to pagelocked memory.
    img = np.array(Image.open(test_case_path)).ravel()
    np.copyto(pagelocked_buffer, 1.0 - img / 255.0)
    return case_num

def main():
    data_paths = './data'
    model_path = os.environ.get("MODEL_PATH") or os.path.join(os.path.dirname(__file__), "models")
    model_file = os.path.join(model_path, ModelData.MODEL_FILE)

    with build_engine(model_file) as engine:
        inputs, outputs, bindings, stream = common.allocate_buffers(engine)
        with engine.create_execution_context() as context:
            case_num = load_normalized_test_case(data_paths, pagelocked_buffer=inputs[0].host)
            [output] = common.do_inference(context, bindings=bindings, inputs=inputs, outputs=outputs, stream=stream)
            pred = np.argmax(output)
            print("Test Case: " + str(case_num))
            print("Prediction: " + str(pred))

if __name__ == '__main__':
    main()

（二）利用TensortRT加速Keras模型

主体思想： Keras->ONNX->TensorRT（h5->onnx->engine）

以Densenet为例，该模型为数字识别模型。注： 本人动态输入（Batch-size, channels, height, width）为：(1, 1, 32, -1)，动态输出（识别模型为19个类别）为：（1，-1，19）。
首先，待转换的模型需要包含图结构以及模型参数，利用keras2onnx工具，将keras模型转存为onnx模型；

import keras
import keras2onnx
import onnx
from tensorflow.keras.models import load_model

model = load_model('./models/densenet_num18.h5')
onnx_model = keras2onnx.convert_keras(model, model.name)
temp_model_file = './models/densenet_num18.onnx'
onnx.save_model(onnx_model, temp_model_file)

接下来有两种方法将onnx模型转换为TensorRT模型 ：

法一：利用第三方工具onnx2trt将onnx模型转为uff模型。（目前因为动态输入问题未走通）
法二：利用TensorRT自带工具trtexec将onnx模型转为engine模型。（已走通固定尺寸输入）
cd <TensorRT Path>/bin

# 利用trtexec工具转换onnx模型为TensorRT可加载的engine模型
./trtexec \
--onnx=./keras/models/densenet_num18.onnx \ 
--shapes=the_input:1x32x148x1 \
--workspace=4096 \
--saveEngine=./keras/densenet_num18.engine

# 关于如何解决动态输入尺寸问题
# 将输入尺寸固定未每个不同batch_size进行保存engine，后续需修改--minShapes= \ 
# --optShapes= --maxShapes= 来进行动态尺寸输入。
# 如需16Bit量化，--fp16即可

最后加载engine模型并推理加速。

import os
import time
import numpy as np
import tensorrt as trt
from PIL import Image
import pycuda.driver as cuda
import pycuda.autoinit

class load_engine_inference(object):
    def __init__(self, file_path):
        self.engine = self.loadEngine2TensorRT(file_path)

    def loadEngine2TensorRT(self, filepath):
        G_LOGGER = trt.Logger(trt.Logger.WARNING)
        # 反序列化引擎
        with open(filepath, "rb") as f, trt.Runtime(G_LOGGER) as runtime:
            engine = runtime.deserialize_cuda_engine(f.read())
            return engine

    def do_inference(self, img_path, do_print=False):
        img = Image.open(img_path)
        img = img.convert('L')
        X = img.reshape([1, 32, width, 1])

        input = X

        # start_time = time.time()
        output = np.empty((1, 18, 19), dtype=np.float32)

        #创建上下文
        self.context = self.engine.create_execution_context()
        # 分配内存
        d_input = cuda.mem_alloc(1 * input.size * input.dtype.itemsize)
        d_output = cuda.mem_alloc(1 * output.size * output.dtype.itemsize)
        bindings = [int(d_input), int(d_output)]

        # pycuda操作缓冲区
        self.stream = cuda.Stream()

        # 将输入数据放入device
        start_time = time.time()
        self.pred_img(input, d_input, bindings, output, d_output)
        end_time = time.time()
        # 线程同步
        self.stream.synchronize()
		# 释放内存
        self.context.__del__()
        return output, end_time - start_time

    def pred_img(self, input, d_input, bindings, output, d_output):
        cuda.memcpy_htod_async(d_input, input, self.stream)
        # 执行模型
        self.context.execute_async(1, bindings, self.stream.handle, None)
        # 将预测结果从从缓冲区取出
        cuda.memcpy_dtoh_async(output, d_output, self.stream)
        self.stream.synchronize()


img_path = '../tf/num_1_true.bmp'

engine_infer = load_engine_inference('./densenet_num18.engine')

## 第一次推理
res_1, use_time = engine_infer.do_inference(img_path)
print('first inference time: ', np.round((use_time)*1000, 2), 'ms')
法三：直接在代码中通过载入onnx模型并创建engine即可。（已走通动态输入）
# -*- coding:UTF-8 -*-
# @Time    : 2021/5/24
# @Author  : favorxin
# @Func    : 利用TensorRT对ONNX模型进行加速的推理代码

import os
import sys
import time
import math
import copy
import numpy as np
import tensorrt as trt
import pycuda.autoinit
import pycuda.driver as cuda
from PIL import Image

### 正常TensorRT定义变量
TRT_LOGGER = trt.Logger(trt.Logger.INFO)
a = (int)(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)
EXPLICIT_BATCH = 1 << (int)(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)
device = 'cuda:0'

### 分配内存不超过30G
def GiB(val):
    return val * 1 << 30

### 读取onnx模型并构建engine
def build_engine(onnx_path, using_half,engine_file,dynamic_input=True):
    trt.init_libnvinfer_plugins(None, '')
    with trt.Builder(TRT_LOGGER) as builder, builder.create_network(EXPLICIT_BATCH) as network, trt.OnnxParser(network, TRT_LOGGER) as parser:
        builder.max_batch_size = 1 # always 1 for explicit batch
        config = builder.create_builder_config()
        config.max_workspace_size = GiB(4)  # 设置4G的创建engine的显存占用
        if using_half:
            config.set_flag(trt.BuilderFlag.FP16) # 半精度FP6
        # Load the Onnx model and parse it in order to populate the TensorRT network.
        with open(onnx_path, 'rb') as model:
            if not parser.parse(model.read()):
                print ('ERROR: Failed to parse the ONNX file.')
                for error in range(parser.num_errors):
                    print (parser.get_error(error))
                return None
        ### 设置动态输入尺寸设置三个尺寸，依次最小尺寸，最佳尺寸，最大尺寸。
        ### （Batch-size, channel, height, width）输入最好按照该顺序，本人尝试通道数放最后未走通，动态输入会报错。
        if dynamic_input:
            profile = builder.create_optimization_profile();
            profile.set_shape("the_input", (1,1,32,80), (1,1,32,148), (1,1,32,250))
            config.add_optimization_profile(profile)

        return builder.build_engine(network, config)

### 为输入，输出分配内存
def allocate_buffers(engine, is_explicit_batch=False, input_shape=None, output_shape=18):
    inputs = []
    outputs = []
    bindings = []

    class HostDeviceMem(object):
        def __init__(self, host_mem, device_mem):
            self.host = host_mem
            self.device = device_mem

        def __str__(self):
            return "Host:\n" + str(self.host) + "\nDevice:\n" + str(self.device)

        def __repr__(self):
            return self.__str__()

    for binding in engine:
        dims = engine.get_binding_shape(binding)
        ### 此处是动态输入和动态输出所需设置的输入和输出尺寸大小。
        if dims[-1] == -1 and len(dims) == 4:
            assert (input_shape is not None)
            dims[-1] = input_shape
        elif dims[-2] == -1 and len(dims) == 3:
            assert (output_shape is not None)
            dims[-2] = output_shape
        size = trt.volume(dims) * engine.max_batch_size  # 设置推理所需的最大batch-size.
        dtype = trt.nptype(engine.get_binding_dtype(binding))
        # 分配内存
        host_mem = cuda.pagelocked_empty(size, dtype)
        device_mem = cuda.mem_alloc(host_mem.nbytes)
        bindings.append(int(device_mem))
        if engine.binding_is_input(binding):
            inputs.append(HostDeviceMem(host_mem, device_mem))
        else:
            outputs.append(HostDeviceMem(host_mem, device_mem))
    return inputs, outputs, bindings

### 输入图片的预处理，输出预处理过后图片以及该图片预处理过后的宽。
def preprocess_image(imagepath):
    img = Image.open(imagepath)
    img = img.convert('L')
    width, height = img.size[0], img.size[1]
    scale = height * 1.0 / 32
    new_width = int(width / scale)

    img = img.resize([new_width, 32], Image.ANTIALIAS)
    img = np.array(img).astype(np.float32) / 255.0 - 0.5
    X = img.reshape([1, 1, 32, new_width])

    return X, new_width

### 根据输入图片的宽度计算最终模型输出的尺寸大小。（因本人模型为动态输入，动态输出，故需计算输出尺寸大小，并分配输出的内存占用）。
def compute_out_shape(input_shape):
    x2 = input_shape
    x2_ft = math.floor((x2 - 5 + 2 * 2) / 2) + 1
    for i in range(2):
        x2_ft = int(x2_ft/2) if x2_ft % 2 == 0 else int((x2_ft-1)/2)
    return x2_ft

### 根据engine推理代码
def profile_trt(engine, imagepath, batch_size):
    assert (engine is not None)

    ### 确定模型输出尺寸，从而为输入输出分配内存
    input_image, input_shape = preprocess_image(imagepath)
    output_shape = compute_out_shape(input_shape)

    segment_inputs, segment_outputs, segment_bindings = allocate_buffers(engine, True, input_shape, output_shape)

    stream = cuda.Stream()
    with engine.create_execution_context() as context:
        context.active_optimization_profile = 0
        origin_inputshape = context.get_binding_shape(0)
        # 本人此处输入图片的宽度为动态的，故最后一位为动态的，并根据输入图片尺寸进行固定
        if (origin_inputshape[-1] == -1 and len(origin_inputshape) == 4):
            origin_inputshape[-1] = input_shape
            context.set_binding_shape(0, (origin_inputshape))
        # 本人此处模型输出结果为动态 的，为倒数第二位为动态的，可以根据输入图片的宽度确定
        elif (origin_inputshape[-2] == -1 and len(origin_inputshape) == 3):
            origin_inputshape[-2] = output_shape
            context.set_binding_shape(0, (origin_inputshape))

        segment_inputs[0].host = input_image
        start_time = time.time()
        [cuda.memcpy_htod_async(inp.device, inp.host, stream) for inp in segment_inputs]
        context.execute_async(bindings=segment_bindings, stream_handle=stream.handle)
        [cuda.memcpy_dtoh_async(out.host, out.device, stream) for out in segment_outputs]
        stream.synchronize()
        use_time = time.time() - start_time
        infer_out = [out.host for out in segment_outputs]
        results = infer_out[0]
        return results, use_time

if __name__ == '__main__':
    onnx_path = './onnx_models/densenet_num18_rmnode1.onnx'
    usinghalf = True
    batch_size = 1
    imagepath = './data/num_5_true.bmp'
    engine_file = 'densenet_num18_t_dynamic.engine'
    init_engine = True
    load_engine = True

    ### 初始化并创建engine，根据onnx模型创建engine，该步骤较为费时，故正常会将engine保存下来，方便后期推理。
    if init_engine:
        trt_engine = build_engine(onnx_path, usinghalf, engine_file, dynamic_input=True)
        print('engine built successfully!')
        with open(engine_file, "wb") as f:
            f.write(trt_engine.serialize())
        print('save engine successfully')

    ### 利用上方创建的engine进行推理。平时推理时可以将init_engine设为False，因为engine已保存。
    if load_engine:
        trt.init_libnvinfer_plugins(None, '')
        with open(engine_file, "rb") as f, trt.Runtime(TRT_LOGGER) as runtime:
            trt_engine = runtime.deserialize_cuda_engine(f.read())

        trt_result, use_time = profile_trt(trt_engine, imagepath, batch_size)
        print(trt_result)

（三）利用TensortRT加速Pytorch模型

主体思想： Pytorch->onnx->TensorRT（pth->onnx->engine）

以图片二分类模型resnet18为例，输入为（1，3，224，224），输出为（1，2）。
首先，利用Pytorch自带onnx转换工具，将Pytorch模型转换为onnx模型；

import torch

resnet_model_path = './models/resnet_state.pth'
model = ResNet()
model.load_state_dict(torch.load(resnet_model_path))
model.eval()
model.cuda()

## 转换ONNX模型并保存
export_onnx_file = "./models/resnet18.onnx"
x=torch.onnx.export(model,  # 待转换的网络模型和参数
                torch.randn(1, 3, 224, 224, device='cpu'), # 虚拟的输入，用于确定输入尺寸和推理计算图每个节点的尺寸
                export_onnx_file,  # 输出文件的名称
                verbose=False,      # 是否以字符串的形式显示计算图
                input_names=["input"]+ ["params_%d"%i for i in range(120)],  # 输入节点的名称，这里也可以给一个list，list中名称分别对应每一层可学习的参数，便于后续查询
                output_names=["output"], # 输出节点的名称
                opset_version=10,   # onnx 支持采用的operator set
                do_constant_folding=True, # 是否压缩常量
                dynamic_axes={"input":{0: "batch_size"}, "output":{0: "batch_size"},} #设置动态维度，此处指明input节点的第0维度可变，命名为batch_size
                )

然后利用TensorRT自带工具trtexec将onnx模型转化为engine模型。（同keras模型转engine模型一致）

cd <TensorRT Path>/bin

# 利用trtexec工具转换onnx模型为TensorRT可加载的engine模型
./trtexec \
--onnx=./torch/models/resnet18.onnx \ 
--shapes=input:1x3x224x224 \
--workspace=4096 \
--saveEngine=./torch/resnet18.engine

推理代码同keras推理代码一致。

二、实验结果

Keras：Densenet识别模型在2080Ti上的性能对比：

参数模型速度(ms)加速比显存占用(MB)
batch_size=1keras5.721 x2737
onnx2.532.26 x716
TensorRT1.364.21 x776
TensorRT（FP16）1.244.61 x774
batch_size=4keras5.731 x2847
onnx2.652.16 x722
TensorRT2.142.68 x798
TensorRT（FP16）1.473.9 x620
batch_size=8keras6.251 x2959
onnx2.982.1 x732
TensorRT2.582.42 x612
TensorRT（FP16）1.863.36 x624
batch_size=16keras6.261 x3179
onnx3.811.64 x796
TensorRT3.321.89 x824
TensorRT（FP16）2.592.42 x630
batch_size=32keras8.641 x3369
onnx6.231.39 x908
TensorRT5.061.71 x700
TensorRT（FP16）3.662.36 x646
batch_size=64keras16.431 x3949
onnx11.11.48 x1164
TensorRT9.361.76 x770
TensorRT（FP16）5.92.78 x842

Resnet18分类模型在2080Ti上的性能对比

参数模型速度(ms)加速比显存占用(MB)
batch_size=1pytorch6.341 x927
onnx2.053.09 x1035
TensorRT1.623.91 x887
Forward1.364.66 x2749
Forward（FP16）0.5212.19 x2749
batch_size=4pytorch6.161 x1187
onnx3.621.7 x1115
TensorRT2.872.15 x1036
Forward2.52.46 x2785
Forward（FP16）0.966.42 x2785
batch_size=16pytorch8.621 x2537
onnx12.500.69 x1495
TensorRT8.171.06 x910
Forward7.161.2 x2877
Forward（FP16）2.33.75 x2877
batch_size=64pytorch38.041 x6537
onnx48.800.78 x3071
TensorRT31.611.2 x1421
Forward26.991.41 x3881
Forward（FP16）6.635.74 x3881
keras_densenet_batch_size_comparation pytorch_resnet18_batch_size_comparation
keras_densenet_batch_size_comparation pytorch_resnet18_batch_size_comparation

三、总结

目前基于识别模型，TensorRT加速倍数在4倍以上，而16bit量化对于Batch-size较大时提升更为明显。对比Batch-size，随着batch-size的增大，tensorrt和onnx加速效果会逐步降低到1.5 ~ 2倍左右。而16Bit压缩的加速效果也会降低，逐步减小到2.6 ~ 3倍左右。

参考文章：
（1）https://zhuanlan.zhihu.com/p/64053177
（2）https://www.jianshu.com/p/3c2fb7b45cc7
（3）https://github.com/onnx/onnx-tensorrt/issues/638
（4）https://zhuanlan.zhihu.com/p/299845547

favorxin
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【TensorRT】1、TensorRT、ONNX、PyTorch 互相转换
呆呆的猫的博客
03-21 8332
在深度学习模型落地的过程中，会面临将模型部署到边端设备的问题，模型训练使用不同的框架，则推理的时候也需要使用相同的框架，但不同类型的平台，调优和实现起来非常困难，因为每个平台都有不同的功能和特性。如果需要在该平台上运行多种框架，则会增加复杂性，所以 ONNX 便派上了用场。可以通过将不同框架训练的模型转换成通用的 ONNX 模型，再进而转换成各个平台支持的格式，就可以实现简化部署。 一、什么是 ONNX ONNX 是 Open Neural Network Exchange 的简称，也叫开放神经网络交换，.
TensorRT解析onnx模型
计算机视觉算法开发与落地
06-17 3014
TensorRT是tensor Runtime的缩写，表示多维数据的推理，在深度学习中，tensor表示多维数据，即二维以上的数据（一维数据是vector，二维数据为Matrix）。 TensorRT是nvidia公司针对nvidia训练的模型进行针对性的推理优化库，是一个c++库，仅支持推理，不支持训练，其优化主要源自以下几个方面： 1.待优化的模型准备。 目前Tensor只支持onnx,caffe,tensorflow框架下的模型，其中对caffe框架下训的模型支持的最好。在优化onnx模型.
4.5.tensorRT基础(1)-onnx文件及其结构的学习，编辑修改onnx
周同学的博客
07-16 1745
4.5.tensorRT基础(1)-onnx文件及其结构的学习，编辑修改onnx
TensorRT & ONNX
m0_55499682的博客
07-26 675
TensorRT & ONNX 简介
利用TensorRT实现神经网络提速(读取ONNX模型并运行)
热门推荐
老潘的博客
01-23 1万+
关于本文章的最新更新请查看:oldpan博客 前言 这篇文章接着上一篇继续讲解如何具体使用TensorRT。 在之前已经写到过一篇去介绍什么是TensorRT：利用TensorRT对深度学习进行加速，这篇文章中大概已经基本讨论了TensorRT究竟是个什么东西以及怎么使用它。 而在这篇文章中我们主要介绍如何使用它在我们的实际任务中进行加速。 在我这里的实验结论表明，在FP32的精度下，使用Tens...
tensorflow/keras笔记
01-20
一、tensorflow 1. flag https://www.jianshu.com/p/b4c2d43d81c6 2.TensorFlow的tf.random_uniform/normal()函数的用法 ...normal:正态分布，uniform:均匀分布 3.feed ...二、keras 1.model.predict(x)/mode
简单的神经网络实现，使用 Python 和 TensorFlow/Keras 库来实现
最新发布
06-13
# 导入必要的库 # 生成一些简单的数据 # 构建简单的神经网络 # 编译模型 # 训练模型 # 测试模型 详细内容见上传资源
Python /Tensorflow/Keras实现Parametric tSNE算法_代码_下载
06-08
这是一个实现参数 t-SNE 的 python 包。我们通过最小化高维空间中的高斯距离度量...默认情况下，我们使用与 van der Maaten 2009 类似的架构1，这是一个具有层的密集神经网络：[输入维度]、500、500、2000、[输出维度]
基于OpenCV和Tensorflow/Keras的计算机视觉和深度学习人脸检测系统
05-09
基于OpenCV和Tensorflow/Keras的计算机视觉和深度学习人脸检测系统 $ cd Face-Mask-Detection $ virtualenv test $ source test/bin/activate $ pip3 install -r requirements.txt 运行 $ python3 train_mask_...
解决tensorflow/keras时出现数组维度不匹配问题
09-16
主要介绍了解决tensorflow/keras时出现数组维度不匹配问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
KerasToTensorRT:这是一个简单的演示，演示了如何在具有TensorRT集成（TFTRT）的Tensorflow上或直接在TensorRT上运行Keras模型模型，而无需调用“ freeze_graph.py”
04-30
Keras到TensorRT的例子 这是在不使用情况下在具有TensorRT集成（TFTRT）的Tensorflow上或直接在TensorRT上运行Keras模型的简单演示。 注意：建议使用NVIDIA Tensorflow泊坞映像运行这些示例。 您可以从下载图像。 要求 Python（2和3都可以） TensorRT（> 3.0） 具有TensorRT集成的Tensorflow（> 1.7） 凯拉斯 如果您想直接在TensorRT上运行模型，则还需要Pycuda： 皮丘达（> 2017.1.1） 例子 演示了如何在TFTRT上运行Keras模型。 该方法支持NCHW和NHWC格式，因为Tensorflow可以处理格式问题。 $ python tftrt_example.py 演示了如何在TFTRT上运行Keras Applications ResNet50。 $ pyth
一文看懂pytorch转换ONNX再转换TenserRT
xian0710830114的专栏
04-08 3217
pytorch转换ONNX再转换TenserRT
TensorRT优化部署（一）--TensorRT和ONNX基础
小豆包的博客
01-04 1932
TensorRT模型优化部署相关笔记，专题内容后续有补充。
TensorRT部署流程
qxqsunshine的博客
07-23 827
第一种不够灵活，第三种比较麻烦，所以最省事方便的就是第二种方法。本文介绍第二种。ONNX 就是一个通用的神经网络格式，一个.onnx文件内包含了网络的结构和参数。甭管是用什么深度学习框架写的网络，只要把模型导出成 ONNX 格式，就跟原本的代码没有关系了。转成 ONNX 格式还没有被优化，需要再使用 TensorRT 读取它并优化成 TensorRT Engine。优化参数也在这一步指定。
(包含源码+模型数据)使用TensorFlow, ONNX和TensorRT加速深度学习推理
专注于人工智能领域的小何尚
05-22 2704
使用TensorFlow, ONNX和TensorRT加速深度学习推理 在这篇文章中，您将了解如何使用新的 TensorFlow-ONNX-TensorRT 工作流程部署经过 TensorFlow 训练的深度学习模型。 本教程使用 NVIDIA TensorRT 8.0.0.3 并提供两个代码示例，一个用于 TensorFlow v1，一个用于 TensorFlow v2。 TensorRT 是一个推理加速器。 首先，使用任何框架训练网络。 网络经过训练后，批大小和精度是固定的（精度为 FP32、FP16
关于 ONNX 及其用 TensorRT 7.0加载
lixuejun2008的博客
05-01 5249
1）Onnx简介 ONNX 定义了一种可扩展的计算图模型、一系列内置的运算单元（OP）和标准数据类型。每一个计算流图都定义为由节点组成的列表，并构建有向无环图。其中每一个节点都有一个或多个输入与输出，每一个节点称之为一个 OP。这相当于一种通用的计算图，不同深度学习框架构建的计算图都能转化为它。 现阶段 ONNX 只支持推理，所以导入的模型都需要在原框架完成训练。 部分框架已经内嵌了 ONN...
一文玩转pytorch转onnx-tensorRT ——（A）onnx转tensorRT
daniaokuye的专栏
11-15 3452
说明 onnx和tensorRT是分开的，onnx像是prototxt和weight的打包在一起的东西。所以由onnx转到tensorRT下，还需要让onnx能搜索到（或parsing）所对应的层。 caffeparsing有注册自定义层的函数，而onnx没有，下面会就onnx-tensorRT的源码详细说到。对于自定义的onnx层，需要修改后重新编译onnx-tensorRT，查到的资料也是这...
Pytorch通过保存为ONNX模型转TensorRT5
连正的博客
04-15 1万+
1 Pytorch以ONNX方式保存模型 def saveONNX(model, filepath): ''' 保存ONNX模型 :param model: 神经网络模型 :param filepath: 文件保存路径 ''' # 神经网络输入数据类型 dumm...
TensorRT5介绍及Pytorch转TensorRT5代码示例
连正的博客
04-12 1万+
1 TensorRT简介 TensorRT的核心是一个c++库，它促进了对NVIDIA图形处理单元(gpu)的高性能计算。它与TensorFlow，Pytorch等框架相辅相成。他可以快速高效的运行一个已经训练好的神经网络，并生成结果。它包括用于从Caffe、ONNX或TensorFlow导入现有模型的解析器，以及用于以编程方式构建模型的c++和Python api。TensorRT在所有支持的平...
https://storage.googleapis.com/tensorflow/keras-applications/mobilenet/mobilenet_1_0_224_tf_no_top.h5
07-15
我建议你在浏览器中打开给定的URL（https://storage.googleapis.com/tensorflow/keras-applications/mobilenet/mobilenet_1_0_224_tf_no_top.h5）并尝试手动下载文件。如果你无法下载文件，请确保你的网络连接正常...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值