tensorrt使用教程（查看tensorrt安装位置）

tensorflow-tensorrt (tf-trt) 是 tensorflow 和 tensorrt 的集成，可在 tensorflow 生态系统中对 nvidia gpu 的推理进行优化。它提供的简单 api 能够轻而易举地在使用 nvidia gpu 时带来巨大性能提升。该集成使 tensorrt 中的优化可被使用，并在遇到 tensorrt 不支持的模型部分算子时提供到原生 tensorflow 的回退。

• tensorrt
  https://developer.nvidia.com/tensorrt

先前关于 tf-trt 集成的文章中，我们介绍了 tensorflow 1.13 和更早版本的工作流。这篇文章将介绍 tensorflow 2.x 中的 tensorrt 集成，并展示最新 api 的示例工作流。如果您刚接触此集成，这并无大碍，本文包含所有入门所需的信息。与 nvidia t4 gpu 上的使用原生 tensorflow 推理相比，使用 tensorrt 集成可以将性能提高 2.4 倍。

• 文章
  https://blog.tensorflow.org/2019/06/high-performance-inference-with-tensorrt.html

tf-trt 集成

启用 tf-trt 后，第一步解析经过训练的模型，将计算图分为 tensorrt 支持的子计算图和不支持的子计算图。然后，每个 tensorrt 支持的子计算图都被封装在一个特殊的 tensorflow 运算 (trtengineop) 中。第二步，为每个 trtengineop 节点构建一个优化的 tensorrt 引擎。tensorrt 不支持的子计算图保持不变，由 tensorflow 运行时处理。如图 1 所示。

• tf-trt
  https://github.com/tensorflow/tensorrt
• tensorrt 支持的
  https://docs.nvidia.com/deeplearning/frameworks/tf-trt-user-guide/index.html?ncid=partn-31097#supported-ops

tf-trt 既可以利用 tensorflow 的灵活性，同时还可以利用可应用于 tensorrt 支持的子计算图的优化。tensorrt 只优化和执行计算图的一部分，剩余的计算图由 tensorflow 执行。

在图 1 所示推理示例中，tensorflow 执行了 reshape 运算和 cast 运算。然后，tensorflow 将预构建的 tensorrt 引擎 trtengineop_0 的执行传递至 tensorrt 运行时。

图 1：计算图分区和在 tf-trt 中构建 trt 引擎的示例

工作流

在这一部分中，我们将通过一个示例研究典型的 tf-trt 工作流。

图 2仅在 tensorflow中执行推理，以及在tensorflow-tensorrt中使用转换后的savedmodel执行推理时的工作流图

图 2 显示了原生 tensorflow 中的标准推理工作流，并与 tf-trt 工作流进行了对比。savedmodel 格式包含共享或部署经过训练的模型所需的所有信息。在原生 tensorflow 中，工作流通常涉及加载保存的模型并使用 tensorflow 运行时运行推理。在 tf-trt 中还涉及一些额外步骤，包括将 tensorrt 优化应用到 tensorrt 支持的模型子计算图，以及可选地预先构建 tensorrt 引擎。

• savedmodel
  https://tensorflow.google.cn/guide/saved_model

首先，创建一个对象来存放转换参数，包括一个精度模式。精度模式用于指示 tf-trt 可以用来实现 tensorflow 运算的最低精度（例如 fp32、fp16 或 int8）。然后创建一个转换器对象，它从保存的模型中获取转换参数和输入。注意，在 tensorflow 2.x 中，tf-trt 仅支持以 tensorflow savedmodel 格式保存的模型。

接下来，当我们调用转换器 convert() 方法时，tf-trt 将用 trtengineops 替换 tensorrt 兼容的部分以转换计算图。如需在运行时获得更好的性能，可以使用转换器 build() 方法提前创建 tensorrt 执行引擎。build() 方法要求，在构建优化的 tensorrt 执行引擎之前必须已知输入数据形状。如果输入数据形状未知，则在输入数据可用时，可以在运行时构建 tensorrt 执行引擎。要在 gpu 上构建 tensorrt 执行引擎，gpu 的设备类型应与执行推理的设备类型相同，因为构建过程特定于 gpu。例如，为 nvidia a100 gpu 构建的执行引擎将无法在 nvidia t4 gpu 上运行。

• build()
  https://tensorflow.google.cn/api_docs/python/tf/experimental/tensorrt/converter

最后，可以调用 save 方法将 tf-trt 转换的模型保存到磁盘。本部分提及的工作流步骤的对应代码如以下代码块所示：

from tensorflow.python.compiler.tensorrt import trt_convert as trt

# conversion parameters 
conversion_params = trt.trtconversionparams(
precision_mode=trt.trtprecisionmode.<fp32 or fp16>)

converter = trt.trtgraphconverterv2(
input_saved_model_dir=input_saved_model_dir,
conversion_params=conversion_params)

# converter method used to partition and optimize tensorrt compatible segments
converter.convert()

# optionally, build tensorrt engines before deployment to save time at runtime
# note that this is gpu specific, and as a rule of thumb, we recommend building at runtime
converter.build(input_fn=my_input_fn)

# save the model to the disk 
converter.save(output_saved_model_dir)

• save
  https://tensorflow.google.cn/api_docs/python/tf/experimental/tensorrt/converter

由以上代码示例可知，build() 方法需要一个与输入数据形状对应的输入函数。输入函数示例如下所示：

# input_fn: a generator function that yields input data as a list or tuple,
# which will be used to execute the converted signature to generate tensorrt
# engines. example:
def my_input_fn():
# let's assume a network with 2 input tensors. we generate 3 sets
# of dummy input data:
input_shapes = [[(1, 16), (2, 16)], # min and max range for 1st input list
[(2, 32), (4, 32)], # min and max range for 2nd list of two tensors
[(4, 32), (8, 32)]] # 3rd input list
for shapes in input_shapes:
# return a list of input tensors
yield [np.zeros(x).astype(np.float32) for x in shapes]

对 int8 的支持

相较于 fp32 和 fp16，int8 需要额外的校准数据来确定最佳量化阈值。当转换参数中的精度模式为 int8 时，需要为 convert() 方法调用提供输入函数。此输入函数类似于提供至 build() 方法的输入函数。此外，传递至 convert() 方法的输入函数所生成的校准数据应与推理过程中可见的实际数据在统计上相似。

from tensorflow.python.compiler.tensorrt import trt_convert as trt

conversion_params = trt.trtconversionparams(
precision_mode=trt.trtprecisionmode.int8)

converter = trt.trtgraphconverterv2(
input_saved_model_dir=input_saved_model_dir,
conversion_params=conversion_params)

# requires some data for calibration
converter.convert(calibration_input_fn=my_input_fn)

# optionally build tensorrt engines before deployment.
# note that this is gpu specific, and as a rule of thumb we recommend building at runtime
converter.build(input_fn=my_input_fn)

converter.save(output_saved_model_dir)

示例：resnet-50

本文其余部分的工作流将采用 tensorflow 2.x resnet-50 模型，对其进行训练、保存、使用 tf-trt 优化，以及最后部署，用于推理。我们还将在 fp32、fp16 和 int8 三种精度模式下使用 tensorflow 原生与 tf-trt 比较推理吞吐量。

示例的前提条件

• ubuntu os
• docker (https://docs.docker.com/get-docker)
• 最新 tensorflow 2.x 容器：
  • docker pull tensorflow/tensorflow:latest-gpu
• nvidia container toolkit (https://github.com/nvidia/nvidia-docker)，这允许您在 docker 容器中使用 nvidia gpu。
• 安装在主机上的 nvidia driver >= 450（编写时，应检查最新 tensorflow 容器的要求）。您可以运行以下命令检查您的计算机上当前安装的版本：nvidia-smi | grep “driver version:”
• nvidia driver >= 450
  https://docs.nvidia.com/datacenter/tesla/tesla-installation-notes/index.html

使用 tensorflow 2.x 容器训练 resnet-50

首先，需要从 tensorflow github 仓库下载 resnet-50 模型的最新版本：

# adding the git remote and fetch the existing branches
$ git clone --depth 1 https://github.com/tensorflow/models.git .

# list the files and directories present in our working directory
$ ls -al

rwxrwxr-x user user 4 kib wed sep 30 15:31:05 2020 ./
rwxrwxr-x user user 4 kib wed sep 30 15:30:45 2020 ../
rw-rw-r-- user user 337 b wed sep 30 15:31:05 2020 authors
rw-rw-r-- user user 1015 b wed sep 30 15:31:05 2020 codeowners
rwxrwxr-x user user 4 kib wed sep 30 15:31:05 2020 community/
rw-rw-r-- user user 390 b wed sep 30 15:31:05 2020 contributing.md
rwxrwxr-x user user 4 kib wed sep 30 15:31:15 2020 .git/
rwxrwxr-x user user 4 kib wed sep 30 15:31:05 2020 .github/
rw-rw-r-- user user 1 kib wed sep 30 15:31:05 2020 .gitignore
rw-rw-r-- user user 1 kib wed sep 30 15:31:05 2020 issues.md
rw-rw-r-- user user 11 kib wed sep 30 15:31:05 2020 license
rwxrwxr-x user user 4 kib wed sep 30 15:31:05 2020 official/
rwxrwxr-x user user 4 kib wed sep 30 15:31:05 2020 orbit/
rw-rw-r-- user user 3 kib wed sep 30 15:31:05 2020 readme.md
rwxrwxr-x user user 4 kib wed sep 30 15:31:06 2020 research/

如前一部分所述，本示例将使用 docker 存储库中的最新 tensorflow 容器：由于容器中已经包含 tensorrt 集成，因此用户不需要执行任何其他安装步骤。容器的拉取和启动步骤如下：

$ docker pull tensorflow/tensorflow:latest-gpu

# please ensure that the nvidia container toolkit is installed before running the following command
$ docker run -it --rm 
--gpus="all" 
--shm-size=2g --ulimit memlock=-1 --ulimit stack=67108864 
--workdir /workspace/ 
-v "$(pwd):/workspace/" 
-v "</path/to/save/data/>:/data/"  # this is the path that will hold the training data
tensorflow/tensorflow:latest-gpu

随后即可在容器内部验证是否有权访问相关文件和要针对的 nvidia gpu：

# let's first test that we can access the resnet-50 code that we previously downloaded
$ ls -al
drwxrwxr-x 8 1000 1000 4096 sep 30 22:31 .git
drwxrwxr-x 3 1000 1000 4096 sep 30 22:31 .github
-rw-rw-r-- 1 1000 1000 1104 sep 30 22:31 .gitignore
-rw-rw-r-- 1 1000 1000 337 sep 30 22:31 authors
-rw-rw-r-- 1 1000 1000 1015 sep 30 22:31 codeowners
-rw-rw-r-- 1 1000 1000 390 sep 30 22:31 contributing.md
-rw-rw-r-- 1 1000 1000 1115 sep 30 22:31 issues.md
-rw-rw-r-- 1 1000 1000 11405 sep 30 22:31 license
-rw-rw-r-- 1 1000 1000 3668 sep 30 22:31 readme.md
drwxrwxr-x 2 1000 1000 4096 sep 30 22:31 community
drwxrwxr-x 12 1000 1000 4096 sep 30 22:31 official
drwxrwxr-x 3 1000 1000 4096 sep 30 22:31 orbit
drwxrwxr-x 23 1000 1000 4096 sep 30 22:31 research

# let's verify we can see our gpus:
$ nvidia-smi

+-----------------------------------------------------------------------------+
| nvidia-smi 450.xx.xx driver version: 450.xx.xx cuda version: 11.x |
|-------------------------------+----------------------+----------------------+
| gpu name persistence-m| bus-id disp.a | volatile uncorr. ecc |
| fan temp perf pwr:usage/cap| memory-usage | gpu-util compute m. |
| | | mig m. |
|===============================+======================+======================|
| 0 tesla t4 on | 00000000:1a:00.0 off | off |
| 38% 52c p8 14w / 70w | 1mib / 16127mib | 0% default |
| | | n/a |
+-------------------------------+----------------------+----------------------+

接下来开始训练 resnet-50。为了避免花费大量时间训练深度学习模型，本文将使用较小的mnist 数据集。不过，对于 imagenet 这样更先进的数据集，工作流也不会发生改变。

# install dependencies
$ pip install tensorflow_datasets tensorflow_model_optimization

# download mnist data and train
$ python -m "official.vision.image_classification.mnist_main" 
--model_dir=./checkpoints 
--data_dir=/data 
--train_epochs=10 
--distribution_strategy=one_device 
--num_gpus=1 
--download

# let’s verify that we have the trained model saved on our machine.
$ ls -al checkpoints/

-rw-r--r-- 1 root root 87 sep 30 22:34 checkpoint
-rw-r--r-- 1 root root 6574829 sep 30 22:34 model.ckpt-0001.data-00000-of-00001
-rw-r--r-- 1 root root 819 sep 30 22:34 model.ckpt-0001.index
[...]
-rw-r--r-- 1 root root 6574829 sep 30 22:34 model.ckpt-0010.data-00000-of-00001
-rw-r--r-- 1 root root 819 sep 30 22:34 model.ckpt-0010.index
drwxr-xr-x 4 root root 4096 sep 30 22:34 saved_model
drwxr-xr-x 3 root root 4096 sep 30 22:34 train
drwxr-xr-x 2 root root 4096 sep 30 22:34 validation

获取 tf-trt 将使用的 savedmodel

经过训练，google 的 resnet-50 代码将以 savedmodel 格式导出模型，路径如下：checkpoints/saved_model/。

以下示例代码可以作为参考，以将您自己的训练模型导出为 tensorflow savedmodel。

import numpy as np

import tensorflow as tf
from tensorflow import keras

def get_model():
# create a simple model.
inputs = keras.input(shape=(32,))
outputs = keras.layers.dense(1)(inputs)
model = keras.model(inputs, outputs)
model.compile(optimizer="adam", loss="mean_squared_error")
return model

model = get_model()

# train the model.
test_input = np.random.random((128, 32))
test_target = np.random.random((128, 1))
model.fit(test_input, test_target)

# calling `save('my_model')` creates a savedmodel folder `my_model`.
model.save("my_model")

• 代码
  https://tensorflow.google.cn/guide/keras/save_and_serialize#savedmodel_format

我们可以验证 google 的 resnet-50 脚本生成的 savedmodel 是否可读和正确：

$ ls -al checkpoints/saved_model

drwxr-xr-x 2 root root 4096 sep 30 22:49 assets
-rw-r--r-- 1 root root 118217 sep 30 22:49 saved_model.pb
drwxr-xr-x 2 root root 4096 sep 30 22:49 variables

$ saved_model_cli show --dir checkpoints/saved_model/ --tag_set serve --signature_def serving_default

metagraphdef with tag-set: 'serve' contains the following signaturedefs:

the given savedmodel signaturedef contains the following input(s):
inputs['input_1'] tensor_info:
dtype: dt_float
shape: (-1, 28, 28, 1)
name: serving_default_input_1:0
the given savedmodel signaturedef contains the following output(s):
outputs['dense_1'] tensor_info:
dtype: dt_float
shape: (-1, 10)
name: statefulpartitionedcall:0
method name is: tensorflow/serving/predict

验证 savedmodel 已正确保存后，我们可以使用 tf-trt 进行加载以开始推理。

推理

使用 tf-trt 执行 resnet-50 推理

本部分将介绍如何使用 tf-trt 在 nvidia gpu 上部署保存的 resnet-50 模型。如前所述，首先使用 convert 方法将 savedmodel 转换为 tf-trt 模型，然后加载模型。

# convert the savedmodel
converter = trt.trtgraphconverterv2(input_saved_model_dir=path)
converter.convert()

# save the converted model
converter.save(converted_model_path)

# load converted model and infer
model = tf.saved_model.load(converted_model_path)
func = root.signatures['serving_default']
output = func(input_tensor)

为简单起见，我们将使用脚本执行推理 (tf2_inference.py)。我们将从 github.com 下载脚本，并将其放在与先前相同的 docker 容器的工作目录 “/workspace/” 中。随后即可执行脚本：

$ wget https://raw.githubusercontent.com/tensorflow/tensorrt/master/tftrt/blog_posts/leveraging%20tensorflow-tensorrt%20integration%20for%20low%20latency%20inference/tf2_inference.py

$ ls
authors contributing.md license checkpoints data orbit tf2_inference.py
codeowners issues.md readme.md community official research

$ python tf2_inference.py --use_tftrt_model --precision fp16

=========================================
inference using: tf-trt …
batch size: 512
precision: fp16
=========================================

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
trtconversionparams(rewriter_config_template=none, max_workspace_size_bytes=8589934592, precision_mode='fp16', minimum_segment_size=3, is_dynamic_op=true, maximum_cached_engines=100, use_calibration=true, max_batch_size=512, allow_build_at_runtime=true)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


processing step: 0100 ...
processing step: 0200 ...
[...]
processing step: 9900 ...
processing step: 10000 ...

average step time: 2.1 msec
average throughput: 244248 samples/sec

• tf2_inference.py
  https://github.com/tensorflow/tensorrt/blob/master/tftrt/blog_posts/leveraging%20tensorflow-tensorrt%20integration%20for%20low%20latency%20inference/tf2_inference.py
• github.com
  https://raw.githubusercontent.com/tensorflow/tensorrt/master/tftrt/blog_posts/leveraging%20tensorflow-tensorrt%20integration%20for%20low%20latency%20inference/tf2_inference.py

同样，我们可为 int8 和 fp32 运行推理

$ python tf2_inference.py --use_tftrt_model --precision int8

$ python tf2_inference.py --use_tftrt_model --precision fp32

使用原生 tensorflow (gpu) fp32 执行推理

您也可以不采用 tf-trt 加速，运行未经修改的 savedmodel。

$ python tf2_inference.py --use_native_tensorflow

=========================================
inference using: native tensorflow …
batch size: 512
=========================================

processing step: 0100 ...
processing step: 0200 ...
[...]
processing step: 9900 ...
processing step: 10000 ...

average step time: 4.1 msec
average throughput: 126328 samples/sec

此运行使用 nvidia t4 gpu 执行。同样的工作流可以在任何 nvidia gpu 上运行。

原生 tf 2.x 与 tf-trt 推理性能对比

借助 tf-trt，只需进行少量代码修改可显著提高性能。例如，使用本文中的推理脚本，在 nvidia t4 gpu 上的批处理大小为 512，我们观察到 tf-trt fp16 的速度几乎比原生 tensorflow 提升了 2 倍，tf-trt int8 的速度提升了 2.4 倍。实际速度提升可能因各种因素而异，如使用的模型、批处理大小、数据集中图像的大小和格式以及 cpu 瓶颈。

我们在本文中展示了 tf-trt 提供的加速。此外，通过 tf-trt，我们可以使用完整的 tensorflow python api 和 jupyter notebook 或 google colab 等交互式环境。

支持的算子

tf-trt 用户指南列出了 tensorrt 兼容子计算图中支持的算子。列表之外的算子将由原生 tensorflow 运行时执行。

• 算子
  https://docs.nvidia.com/deeplearning/frameworks/tf-trt-user-guide/index.html?ncid=partn-31097#supported-ops

我们希望您能亲自尝试，如果遇到问题，请在 github 上提 issue。