Skip to content

F
FluidDoc

PaddlePaddle / FluidDoc

通知 4
Star 2
Fork 0
F
FluidDoc

体验新版 GitCode，发现更多精彩内容 >>

未验证 提交 45f142c0 编写于 作者: Z Zhaolong Xing 提交者： GitHub
浏览文件
操作

refine inference api (#888) 

* refine inference api

test=develop

* fix typo

* fix typo

* fix comments
上级 4c9c3d75
隐藏空白更改
内联 并排
Showing with 252 addition and 206 deletion
doc/fluid/advanced_usage/deploy/inference/native_infer.md
浏览文件 @ 45f142c0
# C++ 预测 API介绍
为了更简单方便的预测部署，Fluid 提供了一套高层 API 用来隐藏底层不同的优化实现。
为了更简单方便的预测部署，PaddlePaddle 提供了一套高层 API 预测接口。
预测库包含:
- 头文件 `paddle_inference_api.h` 定义了所有的接口
- 库文件`libpaddle_fluid.so` 或 `libpaddle_fluid.a`
- 头文件主要包括：
- `paddle_analysis_config.h `
- `paddle_api.h `
- `paddle_inference_api.h`
- 库文件：
- `libpaddle_fluid.so`
- `libpaddle_fluid.a`
下面是详细介绍
下面是详细介绍。
## PaddleTensor
PaddleTensor 定义了预测最基本的输入输出的数据格式，常用字段：
## 内容
- [NativePredictor使用](#NativePredictor使用)
- [AnalysisPredictor使用](#AnalysisPredictor使用)
- [输入输出的管理](#输入输出的管理)
- [多线程预测](#多线程预测)
- [性能建议](#性能建议)
- `name` 用于指定输入数据对应的 模型中variable 的名字
- `shape` 表示一个 Tensor 的 shape
- `data` 数据以连续内存的方式存储在`PaddleBuf` 中，`PaddleBuf` 可以接收外面的数据或者独立`malloc`内存，详细可以参考头文件中相关定义。
- `dtype` 表示 Tensor 的数据类型
## <a name="NativePredictor使用">NativePredictor使用</a>
## 利用Config 创建不同引擎
高层 API 底层有多种优化实现，我们称之为 engine；不同 engine 的切换通过传递不同的 Config 实现重载。
`Config` 有两种，`NativeConfig` 较简单和稳定，`AnalysisConfig` 功能更新，性能更好
- `NativeConfig` 原生 engine，由 paddle 原生的 forward operator
组成，可以天然支持所有paddle 训练出的模型
`NativePredictor`为原生预测引擎，底层由 PaddlePaddle 原生的 forward operator
组成，可以天然**支持所有Paddle 训练出的模型**。
- `AnalysisConfig`
- 支持计算图的分析和优化
- 支持最新的各类 op fuse，性能一般比 `NativeConfig` 要好
- 支持 TensorRT mixed engine 用于 GPU
加速，用子图的方式支持了 [TensorRT] ，支持所有paddle
模型，并自动切割部分计算子图到 TensorRT 上加速，具体的使用方式可以参考[这里](http://paddlepaddle.org/documentation/docs/zh/1.1/user_guides/howto/inference/paddle_tensorrt_infer.html)
## 基于 NativeConfig 的预测部署过程
总体上分为以下步骤
1. 用合适的配置创建 `PaddlePredictor`
2. 创建输入用的 `PaddleTensor`，传入到 `PaddlePredictor` 中
3. 获取输出的 `PaddleTensor` ，将结果取出
下面完整演示一个简单的模型，部分细节代码隐去
```c++
#### NativePredictor 使用样例
```c++
#include "paddle_inference_api.h"
// 创建一个 config，并修改相关设置
paddle::NativeConfig config;
config.model_dir = "xxx";
config.use_gpu = false;
// 创建一个原生的 PaddlePredictor
auto predictor =
paddle::CreatePaddlePredictor<paddle::NativeConfig>(config);
// 创建输入 tensor
int64_t data[4] = {1, 2, 3, 4};
paddle::PaddleTensor tensor;
tensor.shape = std::vector<int>({4, 1});
tensor.data.Reset(data, sizeof(data));
tensor.dtype = paddle::PaddleDType::INT64;
// 创建输出 tensor，输出 tensor 的内存可以复用
std::vector<paddle::PaddleTensor> outputs;
// 执行预测
CHECK(predictor->Run(slots, &outputs));
// 获取 outputs ...
```
编译时，联编 `libpaddle_fluid.a/.so` 便可。
## 高阶使用
### 输入输出的内存管理
namespace paddle {
// 配置NativeConfig
void CreateConfig(NativeConfig *config, const std::string& model_dirname) {
config->use_gpu=true;
config->device=0;
config->fraction_of_gpu_memory=0.1;
/* for cpu
config->use_gpu=false;
config->SetCpuMathLibraryNumThreads(1);
*/
// 设置模型的参数路径
config->prog_file = model_dirname + "model";
config->param_file = model_dirname + "params";
// 当模型输入是多个的时候，这个配置是必要的。
config->specify_input_name = true;
}
`PaddleTensor` 的 `data` 字段是一个 `PaddleBuf`，用于管理一段内存用于数据的拷贝。
void RunNative(int batch_size, const std::string& model_dirname) {
// 1. 创建NativeConfig
NativeConfig config;
CreateConfig(&config);
// 2. 根据config 创建predictor
auto predictor = CreatePaddlePredictor(config);
int channels = 3;
int height = 224;
int width = 224;
float data[batch_size * channels * height * width] = {0};
// 3. 创建输入 tensor
PaddleTensor tensor;
tensor.name = "image";
tensor.shape = std::vector<int>({batch_size, channels, height, width});
tensor.data = PaddleBuf(static_cast<void *>(data),
sizeof(float) * (batch_size * channels * height * width));
tensor.dtype = PaddleDType::FLOAT32;
std::vector<PaddleTensor> paddle_tensor_feeds(1, tensor);
// 4. 创建输出 tensor
std::vector<PaddleTensor> outputs;
// 5. 预测
predictor->Run(paddle_tensor_feeds, &outputs, batch_size);
const size_t num_elements = outputs.front().data.length() / sizeof(float);
auto *data = static_cast<float *>(outputs.front().data.data());
}
} // namespace paddle
`PaddleBuf` 在内存管理方面有两种模式：
int main() {
// 模型下载地址 http://paddle-inference-dist.cdn.bcebos.com/tensorrt_test/mobilenet.tar.gz
paddle::RunNative(1, "./mobilenet");
return 0;
}
```
1. 自动分配和管理内存
## <a name="AnalysisPredictor使用"> AnalysisPredictor使用</a>
AnalysisConfig 创建了一个高性能预测引擎。该引擎通过对计算图的分析，完成对计算图的一系列的优化（Op 的融合, MKLDNN，TRT等底层加速库的支持 etc），大大提升预测引擎的性能。
```c++
int some_size = 1024;
PaddleTensor tensor;
tensor.data.Resize(some_size);
```
#### AnalysisPredictor 使用样例
2. 外部内存传入
```c++
void CreateConfig(AnalysisConfig* config, const std::string& model_dirname) {
// 模型从磁盘进行加载
config->SetModel(model_dirname + "/model",
model_dirname + "/params");
// config->SetModel(model_dirname);
// 如果模型从内存中加载，可以使用SetModelBuffer接口
// config->SetModelBuffer(prog_buffer, prog_size, params_buffer, params_size);
config->EnableUseGpu(10 /*the initial size of the GPU memory pool in MB*/, 0 /*gpu_id*/);
/* for cpu
config->DisableGpu();
config->EnableMKLDNN(); // 可选
config->SetCpuMathLibraryNumThreads(10);
*/
// 当使用ZeroCopyTensor的时候，此处一定要设置为false。
config->SwitchUseFeedFetchOps(false);
// 当多输入的时候，此处一定要设置为true
config->SwitchSpecifyInputNames(true);
config->SwitchIrDebug(true); // 开关打开，会在每个图优化过程后生成dot文件，方便可视化。
// config->SwitchIrOptim(false); // 默认为true。如果设置为false，关闭所有优化，执行过程同 NativePredictor
// config->EnableMemoryOptim(); // 开启内存/显存复用
}
```c++
int some_size = 1024;
// 用户外部分配内存并保证 PaddleTensor 使用过程中，内存一直可用
void* memory = new char[some_size];
tensor.data.Reset(memory, some_size);
// ...
// 用户最后需要自行删除内存以避免内存泄漏
void RunAnalysis(int batch_size, std::string model_dirname) {
// 1. 创建AnalysisConfig
AnalysisConfig config;
CreateConfig(&config);
// 2. 根据config 创建predictor
auto predictor = CreatePaddlePredictor(config);
int channels = 3;
int height = 224;
int width = 224;
float input[batch_size * channels * height * width] = {0};
// 3. 创建输入
// 同NativePredictor样例一样，此处可以使用PaddleTensor来创建输入
// 以下的代码中使用了ZeroCopy的接口，同使用PaddleTensor不同的是：此接口可以避免预测中多余的cpu copy，提升预测性能。
auto input_names = predictor->GetInputNames();
auto input_t = predictor->GetInputTensor(input_names[0]);
input_t->Reshape({batch_size, channels, height, width});
input_t->copy_from_cpu(input);
// 4. 运行
CHECK(predictor->ZeroCopyRun());
delete[] memory;
```
两种模式中，第一种比较方便；第二种则可以严格控制内存的管理，便于与 `tcmalloc` 等库的集成。
### 基于 AnalysisConfig 提升性能
`AnalysisConfig` 是目前我们重点优化的版本。
// 5. 获取输出
std::vector<float> out_data;
auto output_names = predictor->GetOutputNames();
auto output_t = predictor->GetOutputTensor(output_names[0]);
std::vector<int> output_shape = output_t->shape();
int out_num = std::accumulate(output_shape.begin(), output_shape.end(), 1, std::multiplies<int>());
out_data.resize(out_num);
output_t->copy_to_cpu(out_data.data());
}
} // namespace paddle
类似 `NativeConfig` ， `AnalysisConfig` 可以创建一个经过一系列优化的高性能预测引擎。 其中包含了计算图的分析和优化，以及对一些重要 Op 的融合改写等，比如对使用了 While, LSTM, GRU 等模型性能有大幅提升 。
int main() {
// 模型下载地址 http://paddle-inference-dist.cdn.bcebos.com/tensorrt_test/mobilenet.tar.gz
paddle::RunAnalysis(1, "./mobilenet");
return 0;
}
`AnalysisConfig` 的使用方法也和 `NativeConfig` 类似
```c++
AnalysisConfig config(dirname); // dirname 是模型的路径
// 对于不同的模型存储格式，也可以用 AnalysisConfig config(model_file, params_file)
config.EnableUseGpu(100/*初始显存池大小(MB)*/, 0 /*gpu id*/); // 使用GPU， CPU下使用config.DisableGpu();
config.SwitchIrOptim(); // 打开优化开关，运行时会执行一系列的计算图优化
```
这里需要注意的是，输入的 PaddleTensor 需要指定，比如之前的例子需要修改为
## <a name="输入输出的管理"> 输入输出的管理</a>
### PaddleTensor 的使用
PaddleTensor可用于NativePredictor和AnalysisPredictor，在 NativePredictor样例中展示了PaddleTensor的使用方式。
PaddleTensor 定义了预测最基本的输入输出的数据格式，常用字段如下：
```c++
auto predictor = paddle::CreatePaddlePredictor(config); // 注意这里需要 AnalysisConfig
// 创建输入 tensor
int64_t data[4] = {1, 2, 3, 4};
paddle::PaddleTensor tensor;
tensor.shape = std::vector<int>({4, 1});
tensor.data.Reset(data, sizeof(data));
tensor.dtype = paddle::PaddleDType::INT64;
```
- `name`，类型：string，用于指定输入数据对应的模型中variable的名字
- `shape`，类型：`vector<int>`, 表示一个Tensor的shape
- `data`，类型：`PaddleBuf`, 数据以连续内存的方式存储在`PaddleBuf`中，`PaddleBuf`可以接收外面的数据或者独立`malloc`内存，详细可以参考头文件中相关定义。
- `dtype`，类型：`PaddleType`, 有`PaddleDtype::FLOAT32`, `PaddleDtype::INT64`, `PaddleDtype::INT32`三种, 表示 Tensor 的数据类型。
- `lod`，类型：`vector<vector<size_t>>`，在处理变长输入的时候，需要对 `PaddleTensor`设置LoD信息。可以参考[LoD-Tensor使用说明](../../../user_guides/howto/basic_concept/lod_tensor.html)
后续的执行过程与 `NativeConfig` 完全一致。
### 变长序列输入
在处理变长输入的时候，需要对 `PaddleTensor` 设置LoD信息
### ZeroCopyTensor的使用
ZeroCopyTensor的使用可避免预测时候准备输入以及获取输出时多余的数据copy，提高预测性能。**只可用于AnalysisPredictor**。
``` c++
# 假设序列长度依次为 [3, 2, 4, 1, 2, 3]
tensor.lod = {{0,
/*0 + 3=*/3,
/*3 + 2=*/5,
/*5 + 4=*/9,
/*9 + 1=*/10,
/*10 + 2=*/12,
/*12 + 3=*/15}};
```
**Note:**使用ZeroCopyTensor，务必在创建config时设置`config->SwitchUseFeedFetchOps(false)`
更详细的例子可以参考[LoD-Tensor使用说明](../../../user_guides/howto/basic_concept/lod_tensor.html)
```
// 通过创建的AnalysisPredictor获取输入和输出的tensor
auto input_names = predictor->GetInputNames();
auto input_t = predictor->GetInputTensor(input_names[0]);
auto output_names = predictor->GetOutputNames();
auto output_t = predictor->GetOutputTensor(output_names[0]);
// 对tensor进行reshape
input_t->Reshape({batch_size, channels, height, width});
// 通过copy_from_cpu接口，将cpu数据输入；通过copy_to_cpu接口，将输出数据copy到cpu
input_t->copy_from_cpu<float>(input_data /*数据指针*/);
output_t->copy_to_cpu(out_data /*数据指针*/);
// 设置LOD
std::vector<std::vector<size_t>> lod_data = {{0}, {0}};
input_t->SetLoD(lod_data);
// 获取tensor数据指针
float *input_d = input_t->mutable_data<float>(PaddlePlace::kGPU); // CPU下使用PaddlePlace::kCPU
int output_size;
float *output_d = output_t->data<float>(PaddlePlace::kGPU, &output_size);
```
### 多线程预测的建议
## <a name="多线程预测"> 多线程预测</a>
#### 数据并行的服务
这种场景下，每个服务线程执行同一种模型，支持 CPU 和 GPU。
多线程场景下，每个服务线程执行同一种模型，支持 CPU 和 GPU。
Paddle 并没有相关的接口支持，但用户可以简单组合得出，下面演示最简单的实现，用户最好参考具体应用场景做调整
下面演示最简单的实现，用户需要根据具体应用场景做相应的调整
```c++
auto main_predictor = paddle::CreatePaddlePredictor(config);
......@@ -164,11 +218,12 @@ const int num_threads = 10; // 假设有 10 个服务线程
std::vector<std::thread> threads;
std::vector<decl_type(main_predictor)> predictors;
// 最好初始化时把所有predictor都创建好
// 线程外创建所有的predictor
predictors.emplace_back(std::move(main_predictor));
for (int i = 1; i < num_threads; i++) {
predictors.emplace_back(main_predictor->Clone());
}
// 创建线程并执行
for (int i = 0; i < num_threads; i++) {
threads.emplace_back([i, &]{
......@@ -178,7 +233,7 @@ for (int i = 0; i < num_threads; i++) {
});
}
// 结尾
// 线程join
for (auto& t : threads) {
if (t.joinable()) t.join();
}
......@@ -186,48 +241,12 @@ for (auto& t : threads) {
// 结束
```
#### 模型并行的服务
这种场景，使用多个线程/CPU核加速单个模型的预测，**目前只支持 CPU下使用 MKL/MKLDNN 的情况**。
使用 `AnalysisConfig` 的对应接口来设置底层科学计算库使用线程的数目，具体参考 [SetCpuMathLibraryNumThreads](https://github.com/PaddlePaddle/Paddle/blob/release/1.3/paddle/fluid/inference/api/paddle_analysis_config.h#L159)
```c++
config.SetCpuMathLibraryNumThreads(8); // 一个模型使用 8 个线程加速预测
// 查询状态，可以使用如下接口
config.cpu_math_library_num_threads(); // return an int
```
### 性能建议
1. 在 CPU型号允许的情况下，尽量使用带 AVX 和 MKL 的版本
2. 复用输入和输出的 `PaddleTensor` 以避免频繁分配内存拉低性能
3. CPU或GPU预测，可以尝试把 `NativeConfig` 改成成 `AnalysisConfig` 来进行优化
#### CPU下可以尝试使用 Intel 的 `MKLDNN` 加速
MKLDNN 对 `CNN` 类的模型预测有不错的加速效果，可以尝试对比与 `MKLML` 的性能。
使用方法：
```c++
// AnalysisConfig config(...);
config.EnableMKLDNN();
// 查看 mkldnn 是否已经打开，可以用如下代码
config.mkldnn_enabled(); // return a bool
```
#### GPU 下可以尝试打开 `TensorRT` 子图加速引擎
通过计算图分析，Paddle 可以自动将计算图中部分子图切割，并调用 NVidia 的 `TensorRT` 来进行加速。
详细内容可以参考 [TensorRT 子图引擎](./paddle_tensorrt_infer.html)
## 详细代码参考
`AnalysisConfig` 完整接口可以参考 [这里](https://github.com/PaddlePaddle/Paddle/blob/release/1.3/paddle/fluid/inference/api/paddle_analysis_config.h#L35)
[inference demos](https://github.com/PaddlePaddle/Paddle/tree/develop/paddle/fluid/inference/api/demo_ci)
## <a name="性能建议"> 性能建议</a>
1. 在CPU型号允许的情况下，尽量使用带AVX和MKL的版本
2. CPU或GPU预测，可以尝试把`NativeConfig`改成`AnalysisConfig`来进行优化
3. 尽量使用`ZeroCopyTensor`避免过多的内存copy
4. CPU下可以尝试使用Intel的`MKLDNN`加速
5. GPU 下可以尝试打开`TensorRT`子图加速引擎, 通过计算图分析，Paddle可以自动将计算图中部分子图切割，并调用NVidia的 `TensorRT` 来进行加速。
详细内容可以参考 [Paddle-TRT 子图引擎](./paddle_tensorrt_infer.html)
doc/fluid/advanced_usage/deploy/inference/paddle_tensorrt_infer.md
浏览文件 @ 45f142c0
# 使用Paddle-TensorRT库预测
NVIDIA TensorRT 是一个高性能的深度学习预测库，可为深度学习推理应用程序提供低延迟和高吞吐量。PaddlePaddle 采用了子图的形式对TensorRT进行了集成，即我们可以使用该模块来提升Paddle模型的预测性能。该模块依旧在持续开发中，目前已支持的模型有：AlexNet, MobileNet, ResNet50, VGG19, ResNext, Se-ReNext, GoogleNet, DPN, ICNET, Deeplabv3, MobileNet-SSD等。在这篇文档中，我们将会对Paddle-TensorRT库的获取、使用和原理进行介绍。
NVIDIA TensorRT 是一个高性能的深度学习预测库，可为深度学习推理应用程序提供低延迟和高吞吐量。PaddlePaddle 采用了子图的形式对TensorRT进行了集成，即我们可以使用该模块来提升Paddle模型的预测性能。该模块依旧在持续开发中，目前已支持的模型有：AlexNet, MobileNetV1, ResNet50, VGG19, ResNext, Se-ReNext, GoogLeNet, DPN, ICNET, Deeplabv3, MobileNet-SSD等。在这篇文档中，我们将会对Paddle-TensorRT库的获取、使用和原理进行介绍。
## 内容
- [编译Paddle-TRT预测库](#编译Paddle-TRT预测库)
- [Paddle-TRT接口使用](#Paddle-TRT接口使用)
- [Paddle-TRT参数介绍](#Paddle-TRT参数介绍)
- [Paddle-TRT样例编译测试](#Paddle-TRT样例编译测试)
- [Paddle-TRT INT8使用](#Paddle-TRT_INT8使用)
- [Paddle-TRT子图运行原理](#Paddle-TRT子图运行原理)
......@@ -36,10 +37,10 @@ TensorRT预测库目前仅支持使用GPU编译。
mkdir build
cd build
# TENSORRT_ROOT为TRT的路径，默认为 /usr，根据自己需求进行改动
# MKL 可以根据自己的需求自行打开
# MKLDNN 可以根据自己的需求自行打开
cmake .. \
-DWITH_FLUID_ONLY=ON \
-DWITH_MKL=OFF \
-DWITH_MKL=ON \
-DWITH_MKLDNN=OFF \
-DCMAKE_BUILD_TYPE=Release \
-DWITH_PYTHON=OFF \
......@@ -70,13 +71,11 @@ TensorRT预测库目前仅支持使用GPU编译。
## <a name="Paddle-TRT接口使用">Paddle-TRT接口使用</a>
[`paddle_inference_api.h`]('https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/inference/api/paddle_inference_api.h') 定义了使用TensorRT的所有接口。
总体上分为以下步骤：
Paddle-TRT预测使用总体上分为以下步骤：
1. 创建合适的配置AnalysisConfig.
2. 根据配合创建 `PaddlePredictor`.
3. 创建输入的tensor.
4. 获取输出的tensor，输出结果.
2. 根据配置创建 `PaddlePredictor`.
3. 创建输入tensor.
4. 获取输出tensor，输出结果.
以下的代码展示了完整的过程：
......@@ -87,39 +86,43 @@ namespace paddle {
using paddle::AnalysisConfig;
void RunTensorRT(int batch_size, std::string model_dirname) {
// 1. 创建MixedRTConfig
// 1. 创建AnalysisConfig
AnalysisConfig config(model_dirname);
// config->SetModel(model_dirname + "/model",
// model_dirname + "/params");
config->EnableUseGpu(100, 0 /*gpu_id*/);
config->EnableTensorRtEngine(1 << 20 /*work_space_size*/, batch_size /*max_batch_size*/);
// model_dirname + "/params");
config->EnableUseGpu(10, 0 /*gpu_id*/);
// 我们在这里使用了 ZeroCopyTensor, 因此需要将此设置成false
config->SwitchUseFeedFetchOps(false);
config->EnableTensorRtEngine(1 << 20 /*work_space_size*/, batch_size /*max_batch_size*/, AnalysisConfig::Precision::kFloat32, false /*use_static*/);
// 2. 根据config 创建predictor
auto predictor = CreatePaddlePredictor(config);
// 3. 创建输入 tensor
int channels = 3;
int height = 224;
int width = 224;
float data[batch_size * 3 * height * width] = {0};
PaddleTensor tensor;
tensor.shape = std::vector<int>({batch_size, 3, height, width});
tensor.data = PaddleBuf(static_cast<void *>(data),
sizeof(float) * (batch_size * 3 * height * width));
tensor.dtype = PaddleDType::FLOAT32;
std::vector<PaddleTensor> paddle_tensor_feeds(1, tensor);
// 4. 创建输出 tensor
std::vector<PaddleTensor> outputs;
// 5. 预测
predictor->Run(paddle_tensor_feeds, &outputs, batch_size);
const size_t num_elements = outputs.front().data.length() / sizeof(float);
auto *data = static_cast<float *>(outputs.front().data.data());
for (size_t i = 0; i < num_elements; i++) {
std::cout << "output: " << data[i] << std::endl;
}
}
float *input = new float[input_num];
memset(input, 0, input_num * sizeof(float));
auto input_names = predictor->GetInputNames();
auto input_t = predictor->GetInputTensor(input_names[0]);
input_t->Reshape({batch_size, channels, height, width});
input_t->copy_from_cpu(input);
// 4. 运行
predictor->ZeroCopyRun()
// 5. 获取输出
std::vector<float> out_data;
auto output_names = predictor->GetOutputNames();
auto output_t = predictor->GetOutputTensor(output_names[0]);
std::vector<int> output_shape = output_t->shape();
int out_num = std::accumulate(output_shape.begin(), output_shape.end(), 1, std::multiplies<int>());
out_data.resize(out_num);
output_t->copy_to_cpu(out_data.data());
}
} // namespace paddle
int main() {
......@@ -129,11 +132,34 @@ int main() {
}
```
## <a name="Paddle-TRT参数介绍">Paddle-TRT参数介绍</a>
在使用AnalysisPredictor时，我们通过配置
```c++
config->EnableTensorRtEngine(1 << 20 /* workspace_size*/,
batch_size /*max_batch_size*/,
3 /*min_subgraph_size*/,
AnalysisConfig::Precision::kFloat32 /*precision*/,
false /*use_static*/,
false /* use_calib_mode*/);
```
的方式来指定使用Paddle-TRT子图方式来运行。以下我们将对此接口中的参数进行详细的介绍：
- **`workspace_size`**，类型：int，默认值为`1 << 20`。
- **`max_batch_size`**，类型：int，默认值1。需要提前设置最大的batch的大小，运行时batch数目不得超过此大小。
- **`min_subgraph_size`**，类型：int，默认值3。Paddle-TRT是以子图的形式运行，为了避免性能损失，当子图内部节点个数大于`min_subgraph_size`的时候，才会使用Paddle-TRT运行。
- **`precision`**，类型：`enum class Precision {kFloat32 = 0, kInt8,};`, 默认值为`AnalysisConfig::Precision::kFloat32`。如果需要使用Paddle-TRT calib int8的时候，需要指定precision为 `AnalysisConfig::Precision::kInt8`, 且`use_calib_mode` 为true
- **`use_static`**，类型：bool, 默认值为false。如果指定为true，在初次运行程序的时候会将TRT的优化信息进行序列化，下次运行的时候直接加载优化的序列化信息而不需要重新生成。
- **`use_calib_mode`**，类型：bool, 默认值为false。如果需要运行Paddle-TRT calib int8的时候，需要将此设置为true。
**Note：** Paddle-TRT目前只支持固定shape的输入，不支持变化shape的输入。
## <a name="Paddle-TRT样例编译测试">Paddle-TRT样例编译测试</a>
1. 下载样例
```
wget http://paddle-inference-dist.cdn.bcebos.com/tensorrt_test/paddle_trt_samples.tar.gz
https://paddle-inference-dist.cdn.bcebos.com/tensorrt_test/paddle_trt_samples_v1.5.tar.gz
```
解压后的目录如下：
......@@ -185,8 +211,9 @@ int main() {
sh run_impl.sh BASE_DIR/fluid_inference_install_dir/ fluid_generate_calib_test SAMPLE_BASE_DIR/sample/mobilenetv1
```
运行结束后，在 `SAMPLE_BASE_DIR/sample/build/mobilenetv1` 模型目录下会多出一个名字为trt_calib_*的文件，即校准表。
运行结束后，在 `SAMPLE_BASE_DIR/sample/build/mobilenetv1/_opt_cache` 模型目录下会多出一个名字为trt_calib_*的文件，即校准表。
``` shell
# 执行INT8预测
# 将带校准表的模型文件拷贝到特定地址
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或