TensorRT – 使用trtexec工具转换模型、运行模型、测试网络性能

转换模型将onnx转换为TensorRT:

方法一、trtexec

trtexec是在tensorrt包中自带的转换程序，该程序位于bin目录下，用起来比较方便，也是最简单的trt模型转换方式，在使用之前需要系统安装好cuda和cudnn，否则无法正常运行。使用示例如下：

首先将pytorch模型先转换成onnx模型，示例代码如下：

def torch2onnx(model_path,onnx_path):
    model = load_model(model_path)
    test_arr = torch.randn(1,3,32,448)
    input_names = ['input']
    output_names = ['output']
    tr_onnx.export(
        model,
        test_arr,
        onnx_path,
        verbose=False,
        opset_version=11,
        input_names=input_names,
        output_names=output_names,
        dynamic_axes={"input":{3:"width"}}            #动态推理W纬度，若需其他动态纬度可以自行修改，不需要动态推理的话可以注释这行
    )
    print('->>模型转换成功！')

trtexec转换命令如下：

固定尺寸模型转换：将ONNX模型转换为静态batchsize的TensorRT模型，启动所有精度以达到最佳性能，工作区大小设置为1024M

./trtexec --onnx=repvgg_a1.onnx --saveEngine=repvgg_a1.engine --workspace=1024  --fp16 --verbose

动态尺寸模型转换：将ONNX模型转换为动态batchsize的TensorRT模型，启动所有精度以达到最佳性能，工作区大小设置为1024M

./trtexec --onnx=repvgg_a1.onnx --saveEngine=repvgg_a1.engine --workspace=1024 --minShapes=input:1x3x32x32 --optShapes=input:1x3x32x320 --maxShapes=input:1x3x32x640 --fp16

注意:
–minShapes，–optShapes ，–maxShapes必须全部设置，设置的形式为：batchsize x 通道数 x 输入尺寸x x 输入尺寸y

例如：
--minShapes=input:1x3x416x416
--optShapes=input:8x3x416x416
--maxShapes=input:8x3x416x416

参看命名详解： ./trtexec –help, -h

trtexec的参数使用说明

1.1 Model Option 模型选项

–uff : UFF模型文件名–onnx : ONNX模型文件名–model : Caffe模型文件名，模式时无模型，使用随机权重–deploy : Caffe prototxt 文件名–output : 输出名称（可多次指定）；UFF和Caffe至少需要一个输出–uffInput : 输入blob名称及其维度（X、Y、Z=C、H、W），可以多次指定；UFF型号至少需要一个–uffNHWC : 设置输入是否在NHWC布局中而不是NCHW中（在–uffInput中使用X、Y、Z=H、W、C顺序）

1.2 Build Options 构建选项

–maxBatch ： 设置最大批处理大小并构建隐式批处理引擎（默认值=1）–explicitBatch ：构建引擎时使用显式批量大小（默认 = 隐式）–minShapes=spec ： 使用提供的最小形状的配置文件构建动态形状–optShapes=spec ： 使用提供的 opt 形状的配置文件构建动态形状–maxShapes=spec ： 使用提供的最大形状的配置文件构建动态形状–minShapesCalib=spec ： 使用提供的最小形状的配置文件校准动态形状–optShapesCalib=spec ： 使用提供的 opt 形状的配置文件校准动态形状–maxShapesCalib=spec ：使用提供的最大形状的配置文件校准动态形状注意：必须提供所有三个 min、opt 和 max 形状。但是，如果只提供了 opt 形状，那么它将被扩展，以便将最小形状和最大形状设置为与 opt 形状相同的值。此外，使用 动态形状意味着显式批处理。 输入名称可以用转义单引号括起来（例如：‘Input:0’）。示例输入形状规范：input0:1x3x256x256,input1:1x3x128x128 每个输入形状都作为键值对提供，其中 key 是输入名称 值是用于该输入的维度（包括批次维度）。 每个键值对都使用冒号 (😃 分隔键和值。 可以通过逗号分隔的键值对提供多个输入形状。–inputIOFormats=spec ： 每个输入张量的类型和格式（默认所有输入为fp32:chw）注意：如果指定此选项，请按照与网络输入ID相同的顺序为所有输入设置逗号分隔的类型和格式（即使只有一个输入需要指定IO格式）或设置一次类型和格式以进行广播。–outputIOFormats=spec : 每个输出张量的类型和格式（默认所有输入为fp32:chw）注意：如果指定此选项，请按照与网络输出ID相同的顺序为所有输出设置逗号分隔的类型和格式（即使只有一个输出需要指定IO格式）或设置一次类型和格式以进行广播。–workspace=N ： 以M为单位设置工作区大小（默认值 = 16）–noBuilderCache : 在构建器中禁用时序缓存（默认是启用时序缓存）–nvtxMode=mode : 指定 NVTX 注释详细程度。 mode ::= default|verbose|none–minTiming=M : 设置内核选择中使用的最小迭代次数（默认值 = 1）–avgTiming=M : 为内核选择设置每次迭代的平均次数（默认值 = 8）–noTF32 : 禁用 tf32 精度（默认是启用 tf32，除了 fp32）–refit : 将引擎标记为可改装。这将允许检查引擎内的可改装层和重量。–fp16 ： 除 fp32 外，启用 fp16 精度（默认 = 禁用）–int8 : 除 fp32 外，启用 int8 精度（默认 = 禁用）–best : 启用所有精度以达到最佳性能（默认 = 禁用）–calib= : 读取INT8校准缓存文件–safe : 仅测试安全受限流中可用的功能–saveEngine= : 保存序列化模型的文件名–loadEngine= ： 加载序列化模型的文件名–tacticSources=tactics ： 通过从默认策略源（默认 = 所有可用策略）中添加 (+) 或删除 (-) 策略来指定要使用的策略。

1.3 Inference Options 推理选项

–batch=N ： 为隐式批处理引擎设置批处理大小（默认值 = 1）–shapes=spec ： 为动态形状推理输入设置输入形状。注意：使用动态形状意味着显式批处理。 输入名称可以用转义的单引号括起来（例如：‘Input:0’）。 示例输入形状规范：input0:1x3x256x256, input1:1x3x128x128 每个输入形状都作为键值对提供，其中键是输入名称，值是用于该输入的维度（包括批次维度）。 每个键值对都使用冒号 (😃 分隔键和值。 可以通过逗号分隔的键值对提供多个输入形状。–loadInputs=spec ：从文件加载输入值（默认 = 生成随机输入）。 输入名称可以用单引号括起来（例如：‘Input:0’）–iterations=N ： 至少运行 N 次推理迭代（默认值 = 10）–warmUp=N ： 在测量性能之前运行 N 毫秒以预热（默认值 = 200）–duration=N ： 运行至少 N 秒挂钟时间的性能测量（默认值 = 3）–sleepTime=N ： 延迟推理以启动和计算之间的 N 毫秒间隔开始（默认 = 0）–streams=N ： 实例化 N 个引擎以同时使用（默认值 = 1）–exposeDMA ： 串行化进出设备的 DMA 传输。 （默认 = 禁用）–noDataTransfers ： 在推理过程中，请勿将数据传入和传出设备。 （默认 = 禁用）–useSpinWait ： 主动同步 GPU 事件。 此选项可能会减少同步时间，但会增加 CPU 使用率和功率（默认 = 禁用）–threads ： 启用多线程以驱动具有独立线程的引擎（默认 = 禁用）–useCudaGraph ： 使用 cuda 图捕获引擎执行，然后启动推理（默认 = 禁用）–separateProfileRun ： 不要在基准测试中附加分析器； 如果启用分析，将执行第二次分析运行（默认 = 禁用）–buildOnly ： 跳过推理性能测量（默认 = 禁用）

1.4 Build and Inference Batch Options 构建和推理批处理选项
使用隐式批处理时，引擎的最大批处理大小（如果未指定）设置为推理批处理大小； 使用显式批处理时，如果仅指定形状用于推理，它们也将在构建配置文件中用作 min/opt/max； 如果只为构建指定了形状，则 opt 形状也将用于推理； 如果两者都被指定，它们必须是兼容的； 如果启用了显式批处理但都未指定，则模型必须为所有输入提供完整的静态维度，包括批处理大小

1.5 Reporting Options 报告选项

–verbose ： 使用详细日志记录（默认值 = false）–avgRuns=N ： 报告 N 次连续迭代的平均性能测量值（默认值 = 10）–percentile=P ： 报告 P 百分比的性能（0<=P<=100，0 代表最大性能，100 代表最小性能；（默认 = 99%）–dumpRefit ： 从可改装引擎打印可改装层和重量–dumpOutput ： 打印最后一次推理迭代的输出张量（默认 = 禁用）–dumpProfile ： 每层打印配置文件信息（默认 = 禁用）–exportTimes= ： 将计时结果写入 json 文件（默认 = 禁用）–exportOutput= ： 将输出张量写入 json 文件（默认 = 禁用）–exportProfile= ： 将每层的配置文件信息写入 json 文件（默认 = 禁用）

1.6 System Options 系统选项

–device=N ：选择 cuda 设备 N（默认 = 0）–useDLACore=N ： 为支持 DLA 的层选择 DLA 核心 N（默认 = 无）–allowGPUFallback ： 启用 DLA 后，允许 GPU 回退不受支持的层（默认 = 禁用）–plugins ： 要加载的插件库 (.so)（可以多次指定）

1.7 Help 帮助
–help, -h ： 打印以上帮助信息

方法2、使用python脚本

参考官方给到的demo写一个脚本转：官方脚本位于下载的目录：TensorRT-7.2.3.4/samples/python/yolov3_onnx/onnx_to_tensorrt.py

import os 
import tensorrt as trt
os.environ["CUDA_VISIBLE_DEVICES"]='0'
TRT_LOGGER = trt.Logger()
onnx_file_path = 'Unet375-simple.onnx'
engine_file_path = 'Unet337.trt'

EXPLICIT_BATCH = 1 << (int)(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)
with trt.Builder(TRT_LOGGER) as builder, builder.create_network(EXPLICIT_BATCH) as network, trt.OnnxParser(network, TRT_LOGGER) as parser:
            builder.max_workspace_size = 1 << 28 # 256MiB
            builder.max_batch_size = 1
            # Parse model file
            if not os.path.exists(onnx_file_path):
                print('ONNX file {} not found, please run yolov3_to_onnx.py first to generate it.'.format(onnx_file_path))
                exit(0)
            print('Loading ONNX file from path {}...'.format(onnx_file_path))
            with open(onnx_file_path, 'rb') as model:
                print('Beginning ONNX file parsing')
                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))

            network.get_input(0).shape = [1, 3, 300, 400]
            print('Completed parsing of ONNX file')
            print('Building an engine from file {}; this may take a while...'.format(onnx_file_path))
            #network.mark_output(network.get_layer(network.num_layers-1).get_output(0))
            engine = builder.build_cuda_engine(network)
            print("Completed creating Engine")
            with open(engine_file_path, "wb") as f:
                f.write(engine.serialize())

运行ONNX模型

• 在具有静态输入形状的全维模式下运行 ONNX 模型

trtexec --onnx=model.onnx

• 使用给定的输入形状在全维模式下运行 ONNX 模型

trtexec –onnx=model.onnx –shapes=input:32x3x244x244

• 使用一系列可能的输入形状对 ONNX 模型进行基准测试

trtexec --onnx=model.onnx --minShapes=input:1x3x244x244 --optShapes=input:16x3x244x244 --maxShapes=input:32x3x244x244 --shapes=input:5x3x244x244



trtexec --onnx=depth_feat_model.onnx --minShapes=input:1x4x128x128 --maxShapes=input:1x4x896x896 --shapes=input:1x4x512x512 --saveEngine=depth_feat_model.engine --verbose --workspace=1024 --fp32

网络性能测试

• 加载转换后的TensorRT模型进行性能测试，指定batch大小

trtexec --loadEngine=mnist16.trt --batch=1

打印输出：
trtexec会打印出很多时间，这里需要对每个时间的含义进行解释，然后大家各取所需，进行评测。总的打印如下：
[09/06/2021-13:50:34] [I] Average on 10 runs - GPU latency: 2.74553 ms - Host latency: 3.74192 ms (end to end 4.93066 ms, enqueue 0.624805 ms)  # 跑了10次，GPU latency: GPU计算耗时， Host latency：GPU输入+计算+输出耗时，end to end：GPU端到端的耗时，eventout - eventin，enqueue：CPU异步耗时
[09/06/2021-13:50:34] [I] Host Latency
[09/06/2021-13:50:34] [I] min: 3.65332 ms (end to end 3.67603 ms)
[09/06/2021-13:50:34] [I] max: 5.95093 ms (end to end 6.88892 ms)
[09/06/2021-13:50:34] [I] mean: 3.71375 ms (end to end 5.30082 ms)
[09/06/2021-13:50:34] [I] median: 3.70032 ms (end to end 5.32935 ms)
[09/06/2021-13:50:34] [I] percentile: 4.10571 ms at 99% (end to end 6.11792 ms at 99%)
[09/06/2021-13:50:34] [I] throughput: 356.786 qps
[09/06/2021-13:50:34] [I] walltime: 3.00741 s
[09/06/2021-13:50:34] [I] Enqueue Time
[09/06/2021-13:50:34] [I] min: 0.248474 ms
[09/06/2021-13:50:34] [I] max: 2.12134 ms
[09/06/2021-13:50:34] [I] median: 0.273987 ms
[09/06/2021-13:50:34] [I] GPU Compute
[09/06/2021-13:50:34] [I] min: 2.69702 ms
[09/06/2021-13:50:34] [I] max: 4.99219 ms
[09/06/2021-13:50:34] [I] mean: 2.73299 ms
[09/06/2021-13:50:34] [I] median: 2.71875 ms
[09/06/2021-13:50:34] [I] percentile: 3.10791 ms at 99%
[09/06/2021-13:50:34] [I] total compute time: 2.93249 s

Host Latency gpu： 输入+计算+输出 三部分的耗时
Enqueue Time：CPU异步的时间（该时间不具有参考意义，因为GPU的计算可能还没有完成）
GPU Compute：GPU计算的耗时
综上，去了Enqueue Time时间都是有意义的

• 收集和打印时序跟踪信息

trtexec --deploy=data/AlexNet/AlexNet_N2.prototxt --output=prob --exportTimes=trace.json

• 使用多流调整吞吐量

调整吞吐量可能需要运行多个并发执行流。例如，当实现的延迟完全在所需阈值内时，我们可以增加吞吐量，即使以一些延迟为代价。例如，为批量大小 1 和 2 保存引擎并假设两者都在 2ms 内执行，延迟阈值：

trtexec --deploy=GoogleNet_N2.prototxt --output=prob --batch=1 --saveEngine=g1.trt --int8 --buildOnly
trtexec --deploy=GoogleNet_N2.prototxt --output=prob --batch=2 --saveEngine=g2.trt --int8 --buildOnly

• 保存的引擎可以尝试找到低于 2 ms 的组合批次/流，以最大化吞吐量：

trtexec --loadEngine=g1.trt --batch=1 --streams=2
trtexec --loadEngine=g1.trt --batch=1 --streams=3
trtexec --loadEngine=g1.trt --batch=1 --streams=4
trtexec --loadEngine=g2.trt --batch=2 --streams=2

python调用 TensorRT模型的推理

推理依旧分为动态尺寸的和固定尺寸的，动态推理这一块C++版本的资料比较多，python接口的比较少，固定尺寸的推理官方也有demo，分为异步同步推理。

python推理接收numpy格式的数据输入。

动态推断：

import tensorrt as trt
import pycuda.driver as cuda
#import pycuda.driver as cuda2
import pycuda.autoinit
import numpy as np
import cv2
def load_engine(engine_path):
    #TRT_LOGGER = trt.Logger(trt.Logger.WARNING)  # INFO
    TRT_LOGGER = trt.Logger(trt.Logger.ERROR)
    with open(engine_path, 'rb') as f, trt.Runtime(TRT_LOGGER) as runtime:
        return runtime.deserialize_cuda_engine(f.read())
 
path ='/home/caidou/trt_python/model_1_-1_-1_3.engine'
#这里不以某个具体模型做为推断例子.
 
# 1. 建立模型，构建上下文管理器
engine = load_engine(path)
context = engine.create_execution_context()
context.active_optimization_profile = 0
 
#2. 读取数据，数据处理为可以和网络结构输入对应起来的的shape，数据可增加预处理
imgpath = '/home/caidou/test/aaa.jpg'
image = cv2.imread(imgpath)
image = np.expand_dims(image, 0)  # Add batch dimension.  
 
 
#3.分配内存空间，并进行数据cpu到gpu的拷贝
#动态尺寸，每次都要set一下模型输入的shape，0代表的就是输入，输出根据具体的网络结构而定，可以是0,1,2,3...其中的某个头。
context.set_binding_shape(0, image.shape)
d_input = cuda.mem_alloc(image.nbytes)  #分配输入的内存。
 
 
output_shape = context.get_binding_shape(1) 
buffer = np.empty(output_shape, dtype=np.float32)
d_output = cuda.mem_alloc(buffer.nbytes)    #分配输出内存。
cuda.memcpy_htod(d_input,image)
bindings = [d_input ,d_output]
 
#4.进行推理，并将结果从gpu拷贝到cpu。
context.execute_v2(bindings)  #可异步和同步
cuda.memcpy_dtoh(buffer,d_output)  
output = buffer.reshape(output_shape)
 
#5.对推理结果进行后处理。这里只是举了一个简单例子，可以结合官方静态的yolov3案例完善。

静态推断:

静态推断和动态推断差不多，只不过不需要每次都分配输入和输出的内存空间。

import tensorrt as trt
import pycuda.driver as cuda
#import pycuda.driver as cuda2
import pycuda.autoinit
import numpy as np
import cv2
path ='/home/caidou/trt_python/model_1_4_256_256.engine'
engine = load_engine(path)
imgpath = 'aaa.jpg'
context = engine.create_execution_context()
image1 = cv2.write(imgpath)
image1 = cv2.resize(image1,(256,256))
image2 = image1.copy()
image3 = image1.copy()
image4 = image1.copy()
image = np.concatenate((image1,image2,image3,image4))
image = image.reshape(-1,256,256)
 
# image = np.expand_dims(image, axis=1)
image = image.astype(np.float32)
 
image = image.ravel()#数据平铺
outshape= context.get_binding_shape(1) 
output = np.empty((outshape), dtype=np.float32)
d_input = cuda.mem_alloc(1 * image.size * image.dtype.itemsize)
d_output = cuda.mem_alloc(1*output.size * output.dtype.itemsize)
bindings = [int(d_input), int(d_output)]
stream = cuda.Stream()
for i in tqdm.tqdm(range(600)):
    cuda.memcpy_htod(d_input,image)
    context.execute_v2(bindings)
    cuda.memcpy_dtoh(output, d_output)

更新：