第二章 TensorRT Workflows

下列表格列出了TensorRT特点一支持的API以及解析器。

 

表2 特点与支持的API’s

 

下列表格列出了TensorRT特点以及支持的平台

表3 特点与支持的平台

注：序列化引擎不能再不同TensorRT版本间与不同平台间交叉使用。

 

2.1 Key Concepts

请确保你知悉以下关键概念：

UFF

UFF(Universal Framework Format)是一种描述DNN执行图的数据格式。绑定执行图的是输入与输出。UFF有严格规定的语法，并且支持核心运算的扩展，与完全用户自定义的运算。

包括以下内容：

Ø  具体序列化的格式，采用protobuf格式。

Ø  各种运算的有效定义，以python描述符来表述。

Ø  每个核心运算符执行文档。

 

PLANfile

PLAN文件是运行引擎用于执行网络的序列化数据。包含权重，网络中执行步骤以及用来决定如何绑定输入与输出缓存的网络信息。

NEF(NetworkExchange Format)

NEF是用来交换神经网络信息的数据格式。Caffe,UFF与ONNX是各种格式网络交换格式的样例。

Parser

TensorRT中设计用来解析NEF格式数据，建立运行引擎的前端。

Execution Context

运行上下文是前向引擎运行时需要的执行环境。

Engine

Engine是ICudaEngine的实例，Engine是前向运算示例。

NetworkDefinition

网络定义是由运算或者tensor组成的计算图。再TensorRT中是INetworkDefinition类型的示例，

CaffeFormat

Caffe格式的网络参数交换格式。

ONNX

ONNX格式的网络参数交换格式。

 

2.2 Workflow Diagrams

图1展示了典型的部署工作流程，用户在数据集上训练模型，训练好的网络可以用来进行前向运算。

图1 典型部署工作流

 

图1表示将训练网络导入到TensorRT中。用户将训练好的网络导入到TensorRT中，优化网络产生PLAN。PLAN用于前向运算，例如，验证优化是否正确的进行。

PLAN可以序列化到硬盘上以便之后TensorRT后续无需再次进行优化步骤就可以进行调用（见图2）。

图2 典型生产流程

 

2.3 Exporting From Frameworks

使用TensorRT的第一步是建立一个用户网络的TensorRT表达。一旦这个网络建立好了，TensorRT可以由此建立一个网络优化的运行引擎。由两种建立TensorRT网络的方式。

1、  使用Builder API从头开始建立。

2、  从现有的NVCaffe，ONNX或者TensorFlow网络模型使用ParserAPI加载（选择性的使用插件API加载部分TensorRT不支持的网络结构）。

两种方式都在下文中有介绍，以C++或者Python例程的形式展示。

有些网络模块TensorRT不支持。因此，你可以通过使用Plugin API或者修改原始网络结构，使用类似的模块替代。

2.3.1 NVCaffe Workflow

2.3.1.1 NVCaffe C++ Workflow

TensorRT可以直接加载NVCaffe的模型，通过NvCaffeParser接口。

使用NvCaffeParser的使用例程可以在SampleMNIST中找到。TensorRT网络定义结构直接从NVCaffe模型中通过NvCaffeParser库解析出来：

INetworkDefinition* network =builder->createNetwork();

CaffeParser* parser = createCaffeParser();

std::unordered_map<std::string, infer1::Tensor>blobNameToTensor;

const IBlobNameToTensor* blobNameToTensor =

parser->parse(locateFile(deployFile).c_str(),

locateFile(modelFile).c_str(),

*network,

DataType::kFLOAT);

 

NvCaffeParser通过指令生成32-bit float权重的网络，我们可以通过DataType::kHALF来生成16位的模型。

    与主流的网络定义方式一样，解析器返回从NVCaffe blob名字映射到TensorRT tensors的maps。

注： TensorRT网络定义中没有原位操作的概念，例如ReLU的输入输出tensors是不同的。当NVCaffe网络中进行原位操作时，TensorRT的tensor返回blob中最后一次写入的内容对应的字典。例如，如果卷积层生成了一个blob，紧接着一个原位操作的ReLU，blob的名字将会映射到ReLU对应的TensorRT tensor。

由于NVCaffe模型并没有指定那个tensors时网络的输出，我们需要在解析后明确指定：

for (auto& s : outputs)

network->markOutput(*blobNameToTensor->find(s.c_str()));

对于输出tensors的个数没有限制，但是将tensor标记为输出可能会影响对tensor的一些优化操作。

注：

不要立即释放解析器实例，因为网络定义的参数是由NVCaffe模型引用过来的。只有在build过程时权重从NVCaffe模型中加载。

 

2.3.1.2 NVCaffe Python Workflow

TensorRT提供了Python接口，用于加载与优化NVCaffe模型，NVCaffe模型可以执行与存储与PLAN文件中。下列例子展示了实现的工作流程。例子中，你将学习如何在python中使用TensorRT来优化NVCaffe模型。

Python中TensorRT库由tensorrt表示。

你可以像加载其它任何包一样加载tensorrt。例如：、

import tensorrt as trt

有些工具会经常与python接口TensorRT同时使用，例如PyCUDA，NumPy。PyCUDA处理CUDA操作，比如在GPU上申请内显存，将数据传输到GPU上，结果回传到CPU。NumPy是存储与转移数据的常用工具。

import pycuda.driver as cuda

import pycuda.autoinit

import numpy as np

本例中，我们导入一个图像处理库（以pillow库为例）与randint。

from random import randint

from PIL import Image

由于我们需要转换NVCaffe模型，我们还需要使用位于tensorrt.parsers的caffeparser。

from tensorrt.parsers import caffeparser

通常，第一件事是建立一个日志模块，在模型转换与前向运算时许多地方都会使用。在tensorrt.infer.ConsolueLogger里有个简单的日志模块。

G_LOGGER = trt.infer.ConsoleLogger(trt.infer.LogSeverity.ERROR)

    第二步，定义一些你模型相关的常量。本例中，我们利用DIGITS训练MNIST数据集的模型。

INPUT_LAYERS = ['data']

OUTPUT_LAYERS = ['prob']

INPUT_H = 28

INPUT_W = 28

OUTPUT_SIZE = 10

此外，定义一些路径。将下列路径映射到例子中你放数据的位置。

MODEL_PROTOTXT = '/data/mnist/mnist.prototxt'

CAFFE_MODEL = '/data/mnist/mnist.caffemodel'

DATA = '/data/mnist/'

IMAGE_MEAN = '/data/mnist/mnist_mean.binaryproto'

    这一步开始建立引擎。TensorRT的python接口提供了一些实用工具是的这一步变得十分简单。我们使用tensorrt.utils中NVCaffe模型转换工具。我们提供一个日志模块，模型prototxt路径，模型路径，最大batchsize，最大workspace大小，输出层与权重的数据类型。

engine = tensorrt.utils.caffe_to_trt_engine(G_LOGGER,

MODEL_PROTOTXT,

CAFFE_MODEL,

1,

1 << 20,

OUTPUT_LAYERS,

trt.infer.DataType.FLOAT)

下一步，对输入图片进行均值处理。我们使用caffeparser读取.binaryproto文件。

parser = caffeparser.create_caffe_parser()

mean_blob = parser.parse_binary_proto(IMAGE_MEAN)

parser.destroy()

mean = mean_blob.get_data(INPUT_W ** 2) #NOTE: This is different than theC++

API, you must provide the size of the data

data = np.empty([INPUT_W ** 2])

for i in range(INPUT_W ** 2):

data[i] = float(img[i]) - mean[i]

mean_blob.destroy()

    建立一个前向运算的运行环境，创建一个引擎的运行上下文。

runtime = trt.infer.create_infer_runtime(G_LOGGER)

context = engine.create_execution_context()

运行前向运算。第一步确认数据类型是否正确（本例中是FP32）。第二步，创建一个CPU下的array空间，存储前向运算的结果。

assert(engine.get_nb_bindings() == 2)

#convert input data to Float32

img = img.astype(np.float32)

#create output array to receive data

output = np.empty(OUTPUT_SIZE, dtype = np.float32)

    第三步，使用PyCUDA申请GPU显存并在引擎中注册。申请的大小是整个batchsize大小的输入以及期望的输出指针大小。

d_input = cuda.mem_alloc(1 * img.size * img.dtype.itemsize)

d_output = cuda.mem_alloc(1 * output.size * output.dtype.itemsize)

引擎需要绑定GPU显存的指针。PyCUDA通过分配成ints实现内存申请。

bindings = [int(d_input), int(d_output)]

我们还需要建立一个CUDAstream前向运算。

stream = cuda.Stream()

下一步，将数据传输到GPU上，运行前向运算，复制结果回掉。

#transfer input data to device

cuda.memcpy_htod_async(d_input, img, stream)

#execute model

context.enqueue(1, bindings, stream.handle, None)

#transfer predictions back

cuda.memcpy_dtoh_async(output, d_output, stream)

#synchronize threads

stream.synchronize()

    现在我们以及得到结果了，我们可以运行ArgMax得到最终预测的结果。

print("Test Case: " + str(rand_file))

print ("Prediction: " + str(np.argmax(output)))

我们也可以将我们的引擎存在文件中以备之后调用。

trt.utils.write_engine_to_file("/data/mnist/new_mnist.engine",

engine.serialize())

    我们可以之后将通过以下命令将引擎加载运行。

new_engine =

trt.utils.load_engine(G_LOGGER,

"/data/mnist/new_mnist.engine")

最后一步，清理context,engine与runtime:

context.destroy()

engine.destroy()

new_engine.destroy()

runtime.destroy()

 

2.3.1.3 NvCaffeParser

尽管TensorRT独立于任何其它框架，TensorRT还是包含一个NVCaffe模型的解析器，叫做NvCaffeParser。

NvCaffeParser提供了一种简单的加载网络定义的机制。NvCaffeParser使用TensorRT层实现NVCaffe中的层。例如：

Ø  Convolution

Ø  Rectified Linear Unit(ReLU)

Ø  Sigmoid

Ø  Hyperbolic Tangent(tanh)

Ø  Pooling

Ø  Power

Ø  BatchNorm

Ø  ElementEise(Eltwise)

Ø  Local Response Normalization(LRN)

Ø  InnerProduct(在NVCaffe中称为FullyConnected层)

Ø  SoftMax

Ø  Scale

Ø  Deconvolution

Ø  Reduction

TensorRT中不支持的NVCaffe功能包括：

Ø  Parammetric Rectified Linear Unit(PReLU)

Ø  Leaky Rectified Linear Unit(Leaky ReLU)

Ø  Scale(除了per-channel scaling)

Ø  多于两个输入的ElementWise(Eltwise)

注：

NvCaffeParser不支持原版NVCaffe的prototxt格式。特别注意的是，prototxt中层的类型需要由双引号括起来。

 

2.3.2 ONNX Workflow

TensorRT可以直接通过NvParser接口导入ONNX格式模型。解析器接口可以使用C++与Python代码。

2.3.2.1 ONNX C++ Workflow

在sampleONNXMNIST中，TensorRT网络定义结构利用ONNX解析器直接从ONNX模型中读取，在libnvparsers库中定义。ONNX解析器使用辅助参数管理器SampleConfig实例来将输入参数传到执行程序中来解析，例如：

//Create ONNX ParserConfiguration Object

nvonnxparser::IOnnxConfig*config = nvonnxparser::createONNXConfig();

//Copy relevant infofrom the Sample Config to ONNX Parser Config

sampleONNX::copyConfig(&apex,config);

//Create Parser

nvonnxparser::IONNXParser*parser = nvonnxparser::createONNXParser(*config);

//ONNX ParserIncludes a Logger object, it can be used for the sample

nvinfer1::ILogger*gLogger = parser->getLogger();

const char*onnx_filename = apex.getModelFileName();

constnvinfer1::DataType dataType = apex.getModelDtype();

//Parse the ONNXModel. The parser creates the equivalent TRT Network

if(!parser->parse(onnx_filename, dataType)) {

stringmsg("failed to parse onnx file");

gLogger->log(nvinfer1::ILogger::Severity::kERROR,msg.c_str());

exit(EXIT_FAILURE);

}

if(!parser->convertToTRTNetwork()) {

stringmsg("ERROR, failed to convert onnx network into TRT network");

gLogger->log(nvinfer1::ILogger::Severity::kERROR,msg.c_str());

exit(EXIT_FAILURE);

}

nvinfer1::INetworkDefinition*trtNetwork = parser->getTRTNetwork();

这里，如果trtNetwork是非空的，那么你成功的创建了trtNetwork。

下一步，我们建立一个engine builder：

nvinfer1::IBuildertrt_builder =

samples_common::infer_object(nvinfer1::createInferBuilder((*gLogger)));

给builder指定合适的参数：

trt_builder->setMaxBatchSize(apex.getMaxBatchSize());

trt_builder->setMaxWorkspaceSize(apex.getMaxWorkSpaceSize());

   ONNX parser生成网络的默认权重精度是32比特的浮点型。此外你还可以通过指令生成一个16位权重的模型。

if(apex.getModelDtype() == nvinfer1::DataType::kHALF) {

trt_builder->setHalf2Mode(true);

}

    当前INT8精度还不支持，也可以尝试使用以下方法：

if(apex.getModelDtype() == nvinfer1::DataType::kINT8)

{

stringmsg("Int8 mode not yet supported");

gLogger->log(nvinfer1::ILogger::Severity::kERROR,msg.c_str());

exit(EXIT_FAILURE);

}

nvinfer1::ICudaEngine*trt_engine = trt_builder->buildCudaEngine(*trtNetwork);

其它的使用方法与NVCaffe或者UFF一致。

2.3.2.2 ONNX Python Workflow

用户可以直接使用OnnxParser与Python接口来加载ONNX模型。你可以像加载其它任何包一样加载tensorrt包。例如：

Import tensorrt astrt

    加载ONNXParser直接将ONNX模型转换成TensorRT网络。与C++接口类似，sample_onnx的Python例子中使用config实例将用户参数传入解析器实例。

fromtensorrt.parsers import onnxparser

apex =onnxparser.create_onnxconfig()

本例中，我们将解析一个训练好的图像分类模型，生成用于前向运算TensorRT engine。

这里我们通过解析用户输入参数来生成config实例：

apex.set_model_filename(“model_file_path”)

apex.set_model_dtype(trt.infer.DataType.FLOAT)

apex.set_print_layer_info(True)// Optional debug option

apex.report_parsing_info()// Optional debug option

    为了控制debug的输出，有许多种控制冗余信息的方式，例如：

apex.add_verbosity()

apex.reduce_verbosity()

    或者，你可以指定调试信息等级，例如：

apex.set_verbosity_level(3)

    在config实例创建并且配置完成后，用户可以创建一个parser。此外，确保你从创建好的实例中可以检索出参数来解析输入的模型文件：

trt_parser =onnxparser.create_onnxparser(apex)

data_type =apex.get_model_dtype()

onnx_filename =apex.get_model_file_name()

    解析模型后生成TensorRT网络结构，例如：

trt_parser.parse(onnx_filename,data_type)

// retrieve thenetwork from the parser

trt_parser.convert_to_trtnetwork()

trt_network =trt_parsr.get_trt_network()

// create builderand engine

trt_builder =trt.infer.create_infer_builder(G_LOGGER)

    下一步，依据数据类型，设置合适的模式。当前，INT8模式不支持。

If(apex.get_model_dtype() == trt.infer.DataType_kHALF):

trt_builder.set_half_2mode(True)

elif

(apex.get_model_dtype()== trt.infer.DataType_kINT8):

msg = "Int8Model not supported"

G_LOGGER.log(trt.infer.Logger.Severity_kERROR,msg)

trt_engine =trt_builder.build_cuda_engine(trt_network)

其他的前向步骤与NVCaffe与UFFpython例子一致。

最后一步，清理parser，runtime，engine与builder，如下：

trt_parser.destroy()

trt_network.destroy()

trt_context.destroy()

trt_engine.destroy()

trt_builder.destroy()

2.3.3 TensorFlow Workflow

2.3.3.1 TensorFlow Python Workflow

TensorRT3.0引入了UFF（Universal Framework Format）解析器，可以载入UFF模型，并生成TensorRTengines。TensorRT中集成了UFF工具支持将TensorFlow模型转为UFF格式，因此，使得TensorFlow用户可以使用TensorRT来改善效率。本例中，你将学习如何使用使用TensorRT的Python接口将TensorFlow模型转成TensorRT格式。

使用TensorRT的Python接口，用户可以同一个python程序中完成TensorFlow训练与TensorRT部署。本例中，我们将在利用手写数据训练分类模型并生成TensorRT前向运算引擎。

在Python中，TensorRT库被称为tensorrt。

加载TensorFlow与其它相关库：

import tensorflow astf

fromtensorflow.examples.tutorials.mnist import input_data

    同样有一些公用库与TensorRT的python接口一起使用，典型的有，例如，PyCUDA与NumPy。PyCUDA       处理CUDA相关操作，例如在GPU上申请显存，将输出传到GPU上，将结构传回CPU。NumPy广泛用于存储于传递数据。

import pycuda.driveras cuda

importpycuda.autoinit

import numpy as np

from random importrandint # generate a random test case

from PIL importImage

import time #importsystem tools

import os

    最后，加载UFF工具，将TensorFlow中一系列frozen的图转为UFF格式。

import uff

    用户可以通过以下命令导入TensorRT以及相关解析器：

import tensorrt astrt

fromtensorrt.parsers import uffparser

    十分重要的一点是，确认UFF的版本符合TensorRT中要求的版本。TensorRT包中提供了接口来确认环境：

trt.utils.get_uff_version()

parser =uffparser.create_uff_parser()

defget_uff_required_version(parser):

returnstr(parser.get_uff_required_version_major()) + '.'

+str(parser.get_uff_required_version_minor()) + '.' +

str(parser.get_uff_required_version_patch())

iftrt.utils.get_uff_version() != get_uff_required_version(parser):

raiseImportError("""ERROR: UFF TRT Required versionmismatch""")

2.3.3.1.1 Training A Model In TensorFlow

本例中第一步定义一些超参数，之后定义一些帮助函数，使得代码简介。

STARTER_LEARNING_RATE= 1e-4

BATCH_SIZE = 10

NUM_CLASSES = 10

MAX_STEPS = 5000

IMAGE_SIZE = 28

IMAGE_PIXELS =IMAGE_SIZE ** 2

OUTPUT_NAMES =["fc2/Relu"]

    注意我们padding我们的Conv2d层，TensorRT期望对称的padding层。

def WeightsVariable(shape):

returntf.Variable(tf.truncated_normal(shape, stddev=0.1, name='weights'))

defBiasVariable(shape):

returntf.Variable(tf.constant(0.1, shape=shape, name='biases'))

def Conv2d(x, W, b,strides=1):

# Conv2D wrapper,with bias and relu activation

filter_size =W.get_shape().as_list()

pad_size =filter_size[0]//2

pad_mat =np.array([[0,0],

[pad_size,pad_size],

[pad_size,pad_size],

[0,0]])

x = tf.pad(x,pad_mat)

x = tf.nn.conv2d(x,

W,

strides=[1, strides,strides, 1],

padding='VALID')

x =tf.nn.bias_add(x, b)

return tf.nn.relu(x)

def MaxPool2x2(x,k=2):

# MaxPool2D wrapper

pad_size = k//2

pad_mat =np.array([[0,0],

[pad_size,pad_size],

[pad_size,pad_size],

[0,0]])

returntf.nn.max_pool(x,

ksize=[1, k, k, 1],

strides=[1, k, k,1],

padding='VALID')

    这一步我们将定义网络结构，并且定义我们的loss方法，训练与测试的steps，输入节点，与数据加载器：

def network(images):

# Convolution 1

withtf.name_scope('conv1'):

weights =WeightsVariable([5,5,1,32])

biases =BiasVariable([32])

conv1 =tf.nn.relu(Conv2d(images, weights, biases))

pool1 =MaxPool2x2(conv1)

# Convolution 2

withtf.name_scope('conv2'):

weights =WeightsVariable([5,5,32,64])

biases =BiasVariable([64])

conv2 =tf.nn.relu(Conv2d(pool1, weights, biases))

pool2 =MaxPool2x2(conv2)

pool2_flat =tf.reshape(pool2, [-1, 7 * 7 * 64])

Fully Connected 1

withtf.name_scope('fc1'):

weights =WeightsVariable([7 * 7 * 64, 1024])

biases =BiasVariable([1024])

fc1 =tf.nn.relu(tf.matmul(pool2_flat, weights) + biases)

# Fully Connected 2

withtf.name_scope('fc2'):

weights =WeightsVariable([1024, 10])

biases =BiasVariable([10])

fc2 =tf.reshape(tf.matmul(fc1,weights) + biases, shape= [-1,10] ,

name='Relu')

return fc2

defloss_metrics(logits, labels):

cross_entropy =tf.nn.sparse_softmax_cross_entropy_with_logits(

labels=labels,

logits=logits,

name='softmax')

returntf.reduce_mean(cross_entropy, name='softmax_mean')

def training(loss):

tf.summary.scalar('loss',loss)

global_step =tf.Variable(0, name='global_step', trainable=False)

learning_rate =tf.train.exponential_decay(STARTER_LEARNING_RATE,

global_step,

100000,

0.75,

staircase=True)

tf.summary.scalar('learning_rate',learning_rate)

optimizer =tf.train.MomentumOptimizer(learning_rate, 0.9)

train_op =optimizer.minimize(loss, global_step=global_step)

return train_op

defevaluation(logits, labels):

correct =tf.nn.in_top_k(logits, labels, 1)

returntf.reduce_sum(tf.cast(correct, tf.int32))

def do_eval(sess,

eval_correct,

images_placeholder,

labels_placeholder,

data_set,

summary):

true_count = 0

steps_per_epoch =data_set.num_examples // BATCH_SIZE

num_examples =steps_per_epoch * BATCH_SIZE

for step inrange(steps_per_epoch):

feed_dict =fill_feed_dict(data_set,

images_placeholder,

labels_placeholder)

log, correctness =sess.run([summary, eval_correct],

feed_dict=feed_dict)

true_count +=correctness

precision =float(true_count) / num_examples

tf.summary.scalar('precision',tf.constant(precision))

print('Num examples%d, Num Correct: %d Precision @ 1: %0.04f' %

(num_examples,true_count, precision))

return log

defplaceholder_inputs(batch_size):

images_placeholder =tf.placeholder(tf.float32,

shape=(None, 28, 28,1))

labels_placeholder =tf.placeholder(tf.int32, shape=(None))

returnimages_placeholder, labels_placeholder

deffill_feed_dict(data_set, images_pl, labels_pl):

images_feed,labels_feed = data_set.next_batch(BATCH_SIZE)

feed_dict = {

images_pl:np.reshape(images_feed, (-1,28,28,1)),

labels_pl:labels_feed,

}

return feed_dict

    这一步我们将在函数中定义我们的训练流水线，使得训练完毕后输出frozen的模型，并删除训练nodes：

defrun_training(data_sets):

withtf.Graph().as_default():

images_placeholder,labels_placeholder = placeholder_inputs(BATCH_SIZE)

logits =network(images_placeholder)

loss =loss_metrics(logits, labels_placeholder)

train_op =training(loss)

eval_correct = evaluation(logits,labels_placeholder)

summary =tf.summary.merge_all()

init =tf.global_variables_initializer()

saver =tf.train.Saver()

gpu_options =tf.GPUOptions(

per_process_gpu_memory_fraction=0.5)

sess = tf.Session(

config=tf.ConfigProto(gpu_options=gpu_options))

summary_writer =tf.summary.FileWriter(

"/tmp/tensorflow/mnist/log",

graph=tf.get_default_graph())

test_writer =tf.summary.FileWriter(

"/tmp/tensorflow/mnist/log/validation",

graph=tf.get_default_graph())

sess.run(init)

for step inrange(MAX_STEPS):

start_time =time.time()

feed_dict =fill_feed_dict(data_sets.train,

images_placeholder,

labels_placeholder)

_, loss_value =sess.run([train_op, loss],

feed_dict=feed_dict)

duration =time.time() - start_time

if step % 100 == 0:

print('Step %d: loss= %.2f (%.3f sec)' %

(step, loss_value,duration))

summary_str =sess.run(summary, feed_dict=feed_dict)

summary_writer.add_summary(summary_str,step)

summary_writer.flush()

if (step + 1) % 1000== 0 or (step + 1) == MAX_STEPS:

Checkpoint_file =os.path.join(

"/tmp/tensorflow/mnist/log",

"model.ckpt")

saver.save(sess,checkpoint_file, global_step=step)

print('ValidationData Eval:')

log = do_eval(sess,

eval_correct,

images_placeholder,

labels_placeholder,

data_sets.validation,

summary)

test_writer.add_summary(log,step)

graphdef =tf.get_default_graph().as_graph_def()

frozen_graph =tf.graph_util.convert_variables_to_constants(sess,

graphdef,OUTPUT_NAMES)

returntf.graph_util.remove_training_nodes(frozen_graph)

    这一步骤中我们加载TensorFlow的MNIST数据加载器，并进行训练。生成的模型放在了一起，使得用户恶意通过TensorBoard监视训练。

MNIST_DATASETS =input_data.read_data_sets(

'/tmp/tensorflow/mnist/input_data')

tf_model =run_training(MNIST_DATASETS)

2.3.3.1.2 Converting A TensorFlow Model To UFF

本实例中，我们用uff.from_tensorflow中的UFF工具与帮助函数将TensorFlow模型转为序列化的UFF模型。为了进行模型转换，我们至少需要提供model stream与需要输出的节点名称。UFF工具还包含uff.from_tensorFlow_frozen_model函数来加载TensorFlowprotobuf文件路径。

两种工具，例如uff.from_tensorflow(serialized graph)与uff.from_tensorflow_frozen_model (protobuf file)都包含以下选项：

quiet

抑制转换日志

Input_node

在图中定义一系列输入节点。默认是placeholder节点。

text

使得用户可以在除二进制UFF文件外生成一个可读版本的UFF模型。

List_nodes

图中节点的列表。

Output_filename

如果设置了此参数，模型将输出到指定路径，而不是一系列模型。

为了将模型转为UFF格式，使用以下命令：

uff_model =uff.from_tensorflow(tf_model, ["fc2/Relu"])

2.3.3.1.3 Import A UFF Model Into TensorRT

    我们现在有了一个UFF模型，我们可以通过生成一个TensorRT的logger来生成TensorRTengine。

G_LOGGER =trt.infer.ConsoleLogger(trt.infer.LogSeverity.ERROR)

    创建一个UFF解析器，定义期望的输入与输出节点。

parser =uffparser.create_uff_parser()

parser.register_input("Placeholder",(1,28,28),0)

parser.register_output("fc2/Relu")

    通过logger，parser，UFF模型stream，以及其他一些设置（最大batchsize与最大workspace大小），最终创建engine。

engine =trt.utils.uff_to_trt_engine(G_LOGGER,

uff_model,

parser,

1,

1 << 20)

激活engine时在CPU上申请一些内存：

host_mem =parser.hidden_plugin_memory()

    销毁解析器：

parser.destroy()

利用TensorFlow数据加载器（将数据转为FP32）建立一个测试实例：

img, label =MNIST_DATASETS.test.next_batch(1)

img = img[0]

#convert input datato Float32

img =input_img.astype(np.float32)

label = label[0]

创建一个engine的运行环境与执行上下文：

runtime =trt.infer.create_infer_runtime(G_LOGGER)

context =engine.create_execution_context()

下一步，GPU上申请显存，申请CPU内存来存放前向运算后的结果。存储空间的大小是batchsize的输入与期望输出指针大小。

output =np.empty(10, dtype = np.float32)

#allocate devicememory

d_input =cuda.mem_alloc(1 * img.size * img.dtype.itemsize)

d_output =cuda.mem_alloc(1 * output.size * output.dtype.itemsize)

   engine需要绑定GPU显存的指针，PyCUDA通过将那些内存转为ints来申请内存空间。

bindings =[int(d_input), int(d_output)]

    创建一个CUDAstream来运行推理运算。

stream =cuda.Stream()

    将数据传输到GPU，运行推理运算，并取回结果。

#transfer input datato device

cuda.memcpy_htod_async(d_input,img, stream)

#execute model

context.enqueue(1,bindings, stream.handle, None)

#transferpredictions back

cuda.memcpy_dtoh_async(output,d_output, stream)

#synchronize threads

stream.synchronize()

    现在我们有运行结果了，运行ArgMax取得预测结果：

print("TestCase: " + str(label))

print("Prediction: " + str(np.argmax(output)))

    用户还可以将engine存到文件中以备后用。

trt.utils.write_engine_to_file("/data/mnist/tf_mnist.engine",

engine.serialize())

用户可以随后通过tensorrt.utils.load_engine来使用engine。

new_engine =trt.utils.load_engine(G_LOGGER, "/data/mnist/new_mnist.engine")

    最后一步后，清理context，engine与runtime。

context.destroy()

engine.destroy()

new_engine.destroy()

runtime.destroy()

2.3.3.2 Exporting TensorFlow To A UFF File

TensorRT有UFF解析器来加载.uff文件，创建推理引擎。因此，为了转换TensorFlow模型到TensorRT可以运行的文件，必须用convert-to-uff工具将TensorFlow代码freeze为.pb文件，并转换成.uff格式。Convert-to-uff工具包含在uff.whl文件中，作为TensorRT安装包的一部分。

尽管网络可以使用NHWC与NCHW格式，还是鼓励TensorFlow用户使用NCHW数据格式用于达到最佳的性能。

1.             对于TensorFlow或者Keras（TensorFlow作为后端），将图freeze生成.pb（protobuf）文件。请参考SampleCode 1: Freezing the Graph from TensorFlow to .pb 与Sample Code2: Freezing Keras Code to .pb得到更多使用信息。

2.             使用convert-to-uff.py工具，将.pb格式的图转换成.uff格式文件。请参考Sample Code 3: Running convert_to_uff.py得到跟多代码与使用信息。

2.3.3.2.1 Freezing The Graph From TensorFlow

TensorFlow提供freeze_graph函数，使用方式可在freeze_graph_test.py文件中查看。为了使用这种方法，图必须使用graph.io.write_graph保存为.pb文件。其次，freeze_graph可以调用来转换变量为const ops来阐述一个新的frozen.pb文件。更多的freeze_graph信息可以在以下链接找到。

2.3.3.2.2 Sample Code 1:Freezing Keras Code To .pb

转换Keras模型，使用以下代码：

from keras.modelsimport load_model

import keras.backendas K

fromtensorflow.python.framework import graph_io

fromtensorflow.python.tools import freeze_graph

fromtensorflow.core.protobuf import saver_pb2

fromtensorflow.python.training import saver as saver_lib

defconvert_keras_to_pb(keras_model, out_names, models_dir,

model_filename):

model =load_model(keras_model)

K.set_learning_phase(0)

sess =K.get_session()

saver =saver_lib.Saver(write_version=saver_pb2.SaverDef.V2)

checkpoint_path =saver.save(sess, 'saved_ckpt', global_step=0,

latest_filename='checkpoint_state')

graph_io.write_graph(sess.graph,'.', 'tmp.pb')

freeze_graph.freeze_graph('./tmp.pb','',

False,checkpoint_path, out_names,

"save/restore_all","save/Const:0",

models_dir+model_filename,False, "")

2.3.3.2.3 Sample Code 2:Running convert-to-uff

为了将.pb的frozen graph转成.uff格式文件，见下列例程代码：

convert-to-ufftensorflow -o name_of_output_uff_file --inputfile

name_of_input_pb_file-O name_of_output_tensor

为了确定name_of_output_tensor，用户可以列出TensorFlow层：

convert-to-ufftensorflow --input-file name_of_input_pb_file -l

2.3.3.2.4 Supported TensorFlow Operations

当前输出支持TensorFlow以下原生层：

Ø  placeholder转换成UFF输入层

Ø  Const转成UFF的Const层

Ø  Add，Sub，Mul，Div，Minimun与Maximum转成UFF二进制层

Ø  BiasAdd转成UFF二进制层

Ø  Negative，Abs，Sqrt，Rsqrt，Pow，Exp与Log转成UFF的Unary层

Ø  FusedBatchNorm转换成UFF BatchNorm层

Ø  Tanh，Relu，Sigmoid转换成UFF Activation层

Ø  SoftMax转换成SoftMax层

Ø  Mean转换成UFF Reduce层

Ø  ConcatV2转换成UFFConcat层

Ø  Reshape转换成UFFReshape层

Ø  Transpose层转换成UFF Transpose层

Ø  Conv2D与DepthwiseConv2dNative转换成UFF Conv层

Ø  ConvTranspose2D转换成UFFConvTranspose层

Ø  MaxPool与AvePool转换成UFF Pooling层

Ø  如果Pad是接在以下TensorFlow层后面则可以使用，Conv2D，DepthwiseConv2dNative，MaxPool与AvgPool

2.3.3.3 NvUffParser

    关于如何将UFF文件导入到TensorRT中，见例子SampleUffMNISTUFF

Usage。

2.3.4 Converting A Model From An Unsupported Framework ToTensorRT With The TensorRT Python API

随着UFF版本的发布，将兼容框架的模型转换为TensorRT引擎变得十分容易。然而，也有些框架当前或者后续不会支持UFF加载器。TensorRT的Python接口提供了一种前向算法的方式，使得基于Python的框架可以使用NumPy兼容层参数。

以PyTorch为例，我们将展示如何训练一个模型，并且手动将模型转换为TensorRT的engine。

在Python中TensorRT库表示为tenssort。

    同样有些工具配合TensorRT的Python接口，典型的工具，例如PyCUDA与NumPy。PyCUDA负责处理CUDA操作，用于GPU显存申请，将数据传送到GPU上，结构回传CPU上。NumPy是一种通用的数据转存工具。

import pycuda.driver as cuda

import pycuda.autoinit

import numpy as np

    载入PyTorch以及相关包：

import torch

import torch.nn as nn

import torch.nn.functional as F

import torch.optim as optim

from torchvision import datasets, transforms

from torch.autograd import Variable

    用户可以像使用其他包一样载入tensorrt。例如：

import tensorrt as trt

2.3.4.1 Training A Model In PyTorch

    本例中，通过设置一些超参数，创建一个数据加载器，定义你的网络结构，设置优化方式，定义训练与测试的steps。

BATCH_SIZE = 64

TEST_BATCH_SIZE = 1000

EPOCHS = 3

LEARNING_RATE = 0.001

SGD_MOMENTUM = 0.5

SEED = 1

LOG_INTERVAL = 10 #Enable Cuda

torch.cuda.manual_seed(SEED) #Dataloader

kwargs = {'num_workers': 1, 'pin_memory': True}

train_loader = torch.utils.data.DataLoader(

datasets.MNIST('/tmp/mnist/data', train=True,download=True,

transform=transforms.Compose([

transforms.ToTensor(),

transforms.Normalize((0.1307,), (0.3081,))

])),

batch_size=BATCH_SIZE,

shuffle=True,

**kwargs)

test_loader = torch.utils.data.DataLoader(

datasets.MNIST('/tmp/mnist/data', train=False,

transform=transforms.Compose([

transforms.ToTensor(),

transforms.Normalize((0.1307,), (0.3081,))

])),

batch_size=TEST_BATCH_SIZE,

shuffle=True,

**kwargs) #Network

class Net(nn.Module):

def __init__(self):

super(Net, self).__init__()

self.conv1 = nn.Conv2d(1, 20, kernel_size=5)

self.conv2 = nn.Conv2d(20, 50, kernel_size=5)

self.conv2_drop = nn.Dropout2d()

self.fc1 = nn.Linear(800, 500)

self.fc2 = nn.Linear(500, 10)

def forward(self, x):

x = F.max_pool2d(self.conv1(x), kernel_size=2,stride=2)

x = F.max_pool2d(self.conv2(x), kernel_size=2,stride=2)

x = x.view(-1, 800)

x = F.relu(self.fc1(x))

x = self.fc2(x)

return F.log_softmax(x)

model = Net()

model.cuda() optimizer = optim.SGD(model.parameters(),

lr=LEARNING_RATE,

momentum=SGD_MOMENTUM)

def train(epoch):

model.train()

for batch, (data, target) in enumerate(train_loader):

data, target = data.cuda(), target.cuda()

data, target = Variable(data), Variable(target)

optimizer.zero_grad()

output = model(data)

loss = F.nll_loss(output, target)

loss.backward()

optimizer.step()

if batch % LOG_INTERVAL == 0:

print('Train Epoch: {} [{}/{} ({:.0f}%)]tLoss:{:.6f}'

.format(epoch,

batch * len(data),

len(train_loader.dataset),

100. * batch / len(train_loader),

loss.data[0]))

def test(epoch):

model.eval()

test_loss = 0

correct = 0

for data, target in test_loader:

data, target = data.cuda(), target.cuda()

data, target = Variable(data, volatile=True),Variable(target)

output = model(data)

test_loss += F.nll_loss(output, target).data[0]

pred = output.data.max(1)[1]

correct += pred.eq(target.data).cpu().sum()

test_loss /= len(test_loader)

print('Test: Average loss: {:.4f}, Accuracy: {}/{}({:.0f}%)n'

.format(test_loss,

correct,

len(test_loader.dataset),

100. * correct / len(test_loader.dataset)))

    下一步，训练模型

for e in range(EPOCHS):

train(e + 1)

test(e + 1)

2.3.4.2 Converting The Model Into A TensorRT Engine

我们现在有训练好的模型了，我们需要利用state_dict提取层参数作为模型转换的第一步。

weights = model.state_dict()

为了将模型转成TensorRT使用，首先，建立一个builder与一个logger。

G_LOGGER =trt.infer.ConsoleLogger(trt.infer.LogSeverity.ERROR)

builder = trt.infer.create_infer_builder(G_LOGGER)

下一步，通过复制上述网络结构，并且从PyTorch模型中提取NumPy格式存储的权重。PyTorch中的NumPy矩阵展示了层的维度，然而我们对参数进行flatten操作。

注：TensorRT权重的格式是NCHW，因此，如果你的框架使用的是其他格式，你肯定需要在flatten前进行一些预处理。

network = builder.create_network()

#Name for the input layer, data type, tuple fordimension

data = network.add_input("data",

trt.infer.DataType.FLOAT,

(1, 28, 28))

assert(data)

#-------------

conv1_w =weights['conv1.weight'].cpu().numpy().reshape(-1)

conv1_b =weights['conv1.bias'].cpu().numpy().reshape(-1)

conv1 = network.add_convolution(data, 20, (5,5),conv1_w, conv1_b)

assert(conv1)

conv1.set_stride((1,1))

#-------------

pool1 = network.add_pooling(conv1.get_output(0),

trt.infer.PoolingType.MAX,

(2,2))

assert(pool1)

pool1.set_stride((2,2))

#-------------

conv2_w =weights['conv2.weight'].cpu().numpy().reshape(-1)

conv2_b =weights['conv2.bias'].cpu().numpy().reshape(-1)

conv2 = network.add_convolution(pool1.get_output(0),50, (5,5), conv2_w,

conv2_b)

assert(conv2)

conv2.set_stride((1,1))

#-------------

pool2 = network.add_pooling(conv2.get_output(0),trt.infer.PoolingType.MAX,

(2,2))

assert(pool2)

pool2.set_stride((2,2))

#-------------

fc1_w = weights['fc1.weight'].cpu().numpy().reshape(-1)

fc1_b = weights['fc1.bias'].cpu().numpy().reshape(-1)

fc1 = network.add_fully_connected(pool2.get_output(0),500, fc1_w, fc1_b)

assert(fc1)

#-------------

relu1 = network.add_activation(fc1.get_output(0),trt.infer.ActivationType.RELU)

assert(relu1)

#-------------

fc2_w =weights['fc2.weight'].cpu().numpy().reshape(-1)

fc2_b = weights['fc2.bias'].cpu().numpy().reshape(-1)

fc2 = network.add_fully_connected(relu1.get_output(0),10, fc2_w, fc2_b)

assert(fc2)

    标记处输出层。

fc2.get_output(0).set_name("prob")

network.mark_output(fc2.get_output(0))

    创建一个算法引擎并且利用torch的数据加载器创建一个测试实例。

runtime = trt.infer.create_infer_runtime(G_LOGGER)

img, target = next(iter(test_loader))

img = img.numpy()[0]

target = target.numpy()[0]

print("Test Case: " + str(target))

img = img.ravel()

    为算法引擎创建一个运行上下文。

context = engine.create_execution_context()

    在GPU上申请显存，在CPU上申请用来存储推理运算结果的内存。申请的大小是batchsize大小的输入与输出指针的大小。

output = np.empty(10, dtype = np.float32)

#allocate device memory

d_input = cuda.mem_alloc(1 * img.size *img.dtype.itemsize)

d_output = cuda.mem_alloc(1 * output.size *output.dtype.itemsize)

   engine需要绑定GPU的显存。PyCUDA使得用户可以通过ints的方式进行内存申请。

bindings = [int(d_input), int(d_output)]

    将数据传送到GPU上，运行推理，将结果传回。

#transfer input data to device

cuda.memcpy_htod_async(d_input, img, stream)

#execute model

context.enqueue(1, bindings, stream.handle, None)

#transfer predictions back

cuda.memcpy_dtoh_async(output, d_output, stream)

#synchronize threads

stream.synchronize()

    现在我们得到了处理的结果，进行ArgMax就可以得到预测结果。

print("Test Case: " + str(target))

print ("Prediction: " +str(np.argmax(output)))

    也可以将engine保存为文件以备后用。

trt.utils.write_engine_to_file("/data/mnist/pyt_mnist.engine",

engine.serialize())

     后续可以使用tensorrt.util.load_engine来加载engine。

new_engine = trt.utils.load_engine(G_LOGGER,

"/data/mnist/new_mnist.engine")

     最后，清理context，engine与runtime。

context.destroy()

engine.destroy()

new_engine.destroy()

runtime.destroy()

2.4 Build Phase

在build阶段，TensorRT载入网络定义，进行性能优化并生成推理引擎。

build阶段会消耗较多的时间，特别是在嵌入式平台上。因此，一般应用的时候会build意思engine，之后以serialize的方式使用。

build阶段在层图上进行了一下优化：

Ø  消除层输出没有被使用的层

Ø  融合卷积、偏置与非线性映射操作

Ø  将使用类似参数运算与相同源tensor（例如googleNetv5的inception模块中的1乘1卷积）进行聚合。

Ø  通过将层输出直接输出到正确的最终位置进行串联层合并

此外，build阶段还在虚拟数据上运行层以选择最快的核类型，进行权重的预格式化与适当的内存优化。

2.5 Execution Phase

在execution阶段，进行以下任务：

Ø  运行时库执行优化过的engine

Ø  engine使用GPU输入与输出buffer运行推理任务

2.6 Command Line Wrapper

在samples目录下包含TensorRT的command linewrapper，称为giexec。可以用来作为网络在随机数据集上的benchmark，用于产生模型对应的系列engines。

命令行的参数如下：

Mandatory params:

--deploy=<file> Caffe deploy file

--output=<name> Output blob name (can bespecified

multiple times)

Optional params:

--model=<file> Caffe model file (default = nomodel,

random weights

used)

--batch=N Set batch size (default = 1)

--device=N Set cuda device to N (default = 0)

--iterations=N Run N iterations (default = 10)

--avgRuns=N Set avgRuns to N - perf is measured as an

average of

avgRuns (default=10)

--workspace=N Set workspace size in megabytes (default=

16)

--half2 Run in paired fp16 mode (default = false)

--int8 Run in int8 mode (default = false)

--verbose Use verbose logging (default = false)

--hostTime Measure host time rather than GPU time

(default =

false)

--engine=<file> Generate a serialized GIE engine

--calib=<file> Read INT8 calibration cache file

例如：

giexec --deploy=mnist.prototxt--model=mnist.caffemodel --

output=prob

    如果没有提供模型，会使用随机权值。

最后

以上就是追寻含羞草为你收集整理的TensorRT4.0开发手册（2）第二章 TensorRT Workflows的全部内容，希望文章能够帮你解决TensorRT4.0开发手册（2）第二章 TensorRT Workflows所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。