Skip to content

F
FluidDoc

PaddlePaddle / FluidDoc

通知 5
Star 2
Fork 0
F
FluidDoc
提交 69a338f1 编写于 作者: J jiweibo
浏览文件
操作

update for 2.0 inference api. test=develop test=documentfix

上级 54501570
隐藏空白更改
内联 并排
Showing with 1381 addition and 580 deletion
doc/paddle/advanced_guide/inference_deployment/inference/native_infer.md
浏览文件 @ 69a338f1
# C++ 预测 API介绍
为了更简单方便地预测部署，PaddlePaddle 提供了一套高层 C++ API 预测接口。
下面是详细介绍。
为了更简单方便地预测部署，PaddlePaddle 提供了一套高层 C++ API 预测接口。下面是详细介绍。
如果您在使用2.0之前的Paddle，请参考[旧版API](https://www.paddlepaddle.org.cn/documentation/docs/zh/1.8/advanced_guide/inference_deployment/inference/native_infer.html)文档，升级到新版API请参考[推理升级指南](#推理升级指南)。
## 内容
- [使用Config管理预测配置(2.0)](#使用Config管理预测配置)
- [使用Tensor管理输入/输出(2.0)](#使用Tensor管理输入/输出(2.0))
- [使用Predictor进行高性能预测(2.0)](#使用Predictor进行高性能预测)
- [使用AnalysisPredictor进行高性能预测](#使用AnalysisPredictor进行高性能预测)
- [使用AnalysisConfig管理预测配置](#使用AnalysisConfig管理预测配置)
- [使用ZeroCopyTensor管理输入/输出](#使用ZeroCopyTensor管理输入/输出)
- [使用Predictor进行高性能预测](#使用Predictor进行高性能预测)
- [使用Config管理预测配置](#使用Config管理预测配置)
- [使用Tensor管理输入/输出](#使用Tensor管理输入/输出)
- [使用PredictorPool在多线程下进行预测](#使用PredictorPool在多线程下进行预测)
- [C++预测样例编译测试](#C++预测样例编译测试)
- [性能调优](#性能调优)
- [推理升级指南](#推理升级指南)
- [C++ API](#C++_API)
## <a name="使用Config管理预测配置(2.0)"> 使用Config管理预测配置(2.0)</a>
2.0之后统一使用Config来管理Predictor的预测配置，提供了模型路径设置、预测引擎运行设备选择以及多种优化预测流程的选项。配置方法如下：
#### 通用优化配置
``` c++
config->SwitchIrOptim(true); // 开启计算图分析优化，包括OP融合等
config->EnableMemoryOptim(); // 开启内存/显存复用
```
#### 设置模型和参数路径
从磁盘加载模型时，根据模型和参数文件存储方式不同，设置Config加载模型和参数的路径有两种形式：
* 非combined形式：模型文件夹`model_dir`下存在一个模型文件和多个参数文件时，传入模型文件夹路径，模型文件名默认为`__model__`。
``` c++
config->SetModel("./model_dir");
```
* combined形式：模型文件夹`model_dir`下只有一个模型文件`model`和一个参数文件`params`时，传入模型文件和参数文件路径。
``` c++
config->SetModel("./model_dir/model", "./model_dir/params");
```
#### 配置CPU预测
``` c++
config->DisableGpu(); // 禁用GPU
config->EnableMKLDNN(); // 开启MKLDNN，可加速CPU预测
config->SetCpuMathLibraryNumThreads(4); // 设置CPU Math库线程数，CPU核心数支持情况下可加速预测
```
#### 配置GPU预测
``` c++
config->EnableUseGpu(100, 0); // 初始化100M显存，使用GPU ID为0
config->GpuDeviceId(); // 返回正在使用的GPU ID
// 开启TensorRT预测，可提升GPU预测性能，需要使用带TensorRT的预测库
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*/);
```
## <a name="使用Tensor管理输入/输出(2.0)"> 使用Tensor管理输入/输出(2.0)</a>
2.0之后统一使用Tensor作为Predictor的输入/输出数据结构。
``` c++
// 通过创建的Predictor获取输入和输出的tensor
auto input_names = predictor->GetInputNames();
auto input_t = predictor->GetInputHandle(input_names[0]);
auto output_names = predictor->GetOutputNames();
auto output_t = predictor->GetOutputHandle(output_names[0]);
// 对tensor进行reshape
input_t->Reshape({batch_size, channels, height, width});
// 通过CopyFromCpu接口，将cpu数据输入；通过CopyToCpu接口，将输出数据copy到cpu
input_t->CopyFromCpu<float>(input_data /*数据指针*/);
output_t->CopyToCpu(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="使用Predictor进行高性能预测"> 使用Predictor进行高性能预测</a>
## <a name="使用Predictor进行高性能预测(2.0)"> 使用Predictor进行高性能预测(2.0)</a>
2.0之后，统一使用 Predictor 进行预测。Predictor 是一个高性能预测引擎，该引擎通过对计算图的分析，完成对计算图的一系列的优化（如OP的融合、内存/显存的优化、 MKLDNN，TensorRT 等底层加速库的支持等），能够大大提升预测性能。
Paddle Inference采用 Predictor 进行预测。Predictor 是一个高性能预测引擎，该引擎通过对计算图的分析，完成对计算图的一系列的优化（如OP的融合、内存/显存的优化、 MKLDNN，TensorRT 等底层加速库的支持等），能够大大提升预测性能。
为了展示完整的预测流程，下面是一个使用 Predictor 进行预测的完整示例。
为了展示完整的预测流程，下面是一个使用 Predictor 进行预测的完整示例，其中涉及到的具体概念和配置会在后续部分展开详细介绍。
#### Predictor 预测示例
......@@ -114,9 +43,9 @@ void CreateConfig(Config* config, const std::string& model_dirname) {
config->SetCpuMathLibraryNumThreads(10);
*/
config->SwitchIrDebug(true); // 可视化调试选项，若开启，则会在每个图优化过程后生成dot文件
// config->SwitchIrOptim(false); // 默认为true。如果设置为false，关闭所有优化
// config->EnableMemoryOptim(); // 开启内存/显存复用
config->SwitchIrDebug(true); // 可视化调试选项，若开启，则会在每个图优化过程后生成dot文件
// config->SwitchIrOptim(false); // 默认为true。如果设置为false，关闭所有优化
// config->EnableMemoryOptim(); // 开启内存/显存复用
}
void RunAnalysis(int batch_size, std::string model_dirname) {
......@@ -155,106 +84,24 @@ void RunAnalysis(int batch_size, std::string model_dirname) {
int main() {
// 模型下载地址 http://paddle-inference-dist.cdn.bcebos.com/tensorrt_test/mobilenet.tar.gz
paddle::RunAnalysis(1, "./mobilenet");
paddle_infer::RunAnalysis(1, "./mobilenet");
return 0;
}
```
## <a name="使用AnalysisPredictor进行高性能预测"> 使用AnalysisPredictor进行高性能预测</a>
Paddle Fluid采用 AnalysisPredictor 进行预测。AnalysisPredictor 是一个高性能预测引擎，该引擎通过对计算图的分析，完成对计算图的一系列的优化（如OP的融合、内存/显存的优化、 MKLDNN，TensorRT 等底层加速库的支持等），能够大大提升预测性能。
## <a name="使用Config管理预测配置"> 使用Config管理预测配置</a>
为了展示完整的预测流程，下面是一个使用 AnalysisPredictor 进行预测的完整示例，其中涉及到的具体概念和配置会在后续部分展开详细介绍。
#### AnalysisPredictor 预测示例
``` c++
#include "paddle_inference_api.h"
namespace paddle {
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(100 /*设定GPU初始显存池为MB*/, 0 /*设定GPU ID为0*/); //开启GPU预测
/* for cpu
config->DisableGpu();
config->EnableMKLDNN(); // 开启MKLDNN加速
config->SetCpuMathLibraryNumThreads(10);
*/
// 使用ZeroCopyTensor，此处必须设置为false
config->SwitchUseFeedFetchOps(false);
// 若输入为多个，此处必须设置为true
config->SwitchSpecifyInputNames(true);
config->SwitchIrDebug(true); // 可视化调试选项，若开启，则会在每个图优化过程后生成dot文件
// config->SwitchIrOptim(false); // 默认为true。如果设置为false，关闭所有优化
// config->EnableMemoryOptim(); // 开启内存/显存复用
}
void RunAnalysis(int batch_size, std::string model_dirname) {
// 1. 创建AnalysisConfig
AnalysisConfig config;
CreateConfig(&config, model_dirname);
// 2. 根据config 创建predictor，并准备输入数据，此处以全0数据为例
auto predictor = CreatePaddlePredictor(config);
int channels = 3;
int height = 224;
int width = 224;
float input[batch_size * channels * height * width] = {0};
// 3. 创建输入
// 使用了ZeroCopy接口，可以避免预测中多余的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());
// 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() {
// 模型下载地址 http://paddle-inference-dist.cdn.bcebos.com/tensorrt_test/mobilenet.tar.gz
paddle::RunAnalysis(1, "./mobilenet");
return 0;
}
```
## <a name="使用AnalysisConfig管理预测配置"> 使用AnalysisConfig管理预测配置</a>
AnalysisConfig管理AnalysisPredictor的预测配置，提供了模型路径设置、预测引擎运行设备选择以及多种优化预测流程的选项。配置方法如下：
Config管理Predictor的预测配置，提供了模型路径设置、预测引擎运行设备选择以及多种优化预测流程的选项。配置方法如下：
#### 通用优化配置
``` c++
config->SwitchIrOptim(true); // 开启计算图分析优化，包括OP融合等
config->EnableMemoryOptim(); // 开启内存/显存复用
```
**Note:** 使用ZeroCopyTensor必须设置：
``` c++
config->SwitchUseFeedFetchOps(false); // 关闭feed和fetch OP使用，使用ZeroCopy接口必须设置此项
```
#### 设置模型和参数路径
从磁盘加载模型时，根据模型和参数文件存储方式不同，设置AnalysisConfig加载模型和参数的路径有两种形式：
从磁盘加载模型时，根据模型和参数文件存储方式不同，设置Config加载模型和参数的路径有两种形式：
* 非combined形式：模型文件夹`model_dir`下存在一个模型文件和多个参数文件时，传入模型文件夹路径，模型文件名默认为`__model__`。
``` c++
......@@ -270,43 +117,41 @@ config->SetModel("./model_dir/model", "./model_dir/params");
#### 配置CPU预测
``` c++
config->DisableGpu(); // 禁用GPU
config->EnableMKLDNN(); // 开启MKLDNN，可加速CPU预测
config->SetCpuMathLibraryNumThreads(10); // 设置CPU Math库线程数，CPU核心数支持情况下可加速预测
config->DisableGpu(); // 禁用GPU
config->EnableMKLDNN(); // 开启MKLDNN，可加速CPU预测
config->SetCpuMathLibraryNumThreads(10); // 设置CPU Math库线程数，CPU核心数支持情况下可加速预测
```
#### 配置GPU预测
``` c++
config->EnableUseGpu(100, 0); // 初始化100M显存，使用GPU ID为0
config->GpuDeviceId(); // 返回正在使用的GPU ID
// 开启TensorRT预测，可提升GPU预测性能，需要使用带TensorRT的预测库
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*/);
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*/);
```
## <a name="使用ZeroCopyTensor管理输入/输出"> 使用ZeroCopyTensor管理输入/输出</a>
ZeroCopyTensor是AnalysisPredictor的输入/输出数据结构。ZeroCopyTensor的使用可以避免预测时候准备输入以及获取输出时多余的数据copy，提高预测性能。
## <a name="使用Tensor管理输入/输出"> 使用Tensor管理输入/输出</a>
**Note:** 使用ZeroCopyTensor，务必在创建config时设置`config->SwitchUseFeedFetchOps(false);`。
Tensor是Predictor的输入/输出数据结构。
``` c++
// 通过创建的AnalysisPredictor获取输入和输出的tensor
// 通过创建的Predictor获取输入和输出的tensor
auto input_names = predictor->GetInputNames();
auto input_t = predictor->GetInputTensor(input_names[0]);
auto input_t = predictor->GetInputHandle(input_names[0]);
auto output_names = predictor->GetOutputNames();
auto output_t = predictor->GetOutputTensor(output_names[0]);
auto output_t = predictor->GetOutputHandle(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 /*数据指针*/);
// 通过CopyFromCpu接口，将cpu数据输入；通过CopyToCpu接口，将输出数据copy到cpu
input_t->CopyFromCpu<float>(input_data /*数据指针*/);
output_t->CopyToCpu(out_data /*数据指针*/);
// 设置LOD
std::vector<std::vector<size_t>> lod_data = {{0}, {0}};
......@@ -318,13 +163,29 @@ int output_size;
float *output_d = output_t->data<float>(PaddlePlace::kGPU, &output_size);
```
## <a name="使用PredictorPool在多线程下进行预测"> 使用PredictorPool在多线程下进行预测</a>
`PredictorPool`对`Predictor`进行管理。`PredictorPool`对`Predictor`进行了简单的封装，通过传入config和thread的数目来完成初始化，在每个线程中，根据自己的线程id直接从池中取出对应的`Predictor`来完成预测过程。
```c++
# 服务初始化时，完成PredictorPool的初始化
PredictorPool pool(config, thread_num);
# 根据线程id来获取Predictor
auto predictor = pool.Retrive(thread_id);
# 使用Predictor进行预测
...
```
## <a name="C++预测样例编译测试"> C++预测样例编译测试</a>
1. 下载或编译paddle预测库，参考[安装与编译C++预测库](./build_and_install_lib_cn.html)。
2. 下载[预测样例](https://paddle-inference-dist.bj.bcebos.com/tensorrt_test/paddle_inference_sample_v1.7.tar.gz)并解压，进入`sample/inference`目录下。
`inference` 文件夹目录结构如下：
`inference` 文件夹目录结构如下：
``` shell
``` shell
inference
├── CMakeLists.txt
├── mobilenet_test.cc
......@@ -334,12 +195,12 @@ float *output_d = output_t->data<float>(PaddlePlace::kGPU, &output_size);
│ └── params
├── run.sh
└── run_impl.sh
```
```
- `mobilenet_test.cc` 为单线程预测的C++源文件
- `thread_mobilenet_test.cc` 为多线程预测的C++源文件
- `mobilenetv1` 为模型文件夹
- `run.sh` 为预测运行脚本文件
- `mobilenet_test.cc` 为单线程预测的C++源文件
- `thread_mobilenet_test.cc` 为多线程预测的C++源文件
- `mobilenetv1` 为模型文件夹
- `run.sh` 为预测运行脚本文件
3. 配置编译与运行脚本
......@@ -363,11 +224,12 @@ float *output_d = output_t->data<float>(PaddlePlace::kGPU, &output_size);
4. 编译与运行样例
``` shell
sh run.sh
```
``` shell
sh run.sh
```
## <a name="性能调优"> 性能调优</a>
### CPU下预测
1. 在CPU型号允许的情况下，尽量使用带AVX和MKL的版本。
2. 可以尝试使用Intel的 MKLDNN 加速。
......@@ -377,7 +239,7 @@ float *output_d = output_t->data<float>(PaddlePlace::kGPU, &output_size);
1. 可以尝试打开 TensorRT 子图加速引擎, 通过计算图分析，Paddle可以自动将计算图中部分子图融合，并调用NVIDIA的 TensorRT 来进行加速，详细内容可以参考 [使用Paddle-TensorRT库预测](../../performance_improving/inference_improving/paddle_tensorrt_infer.html)。
### 多线程预测
Paddle Fluid支持通过在不同线程运行多个AnalysisPredictor的方式来优化预测性能，支持CPU和GPU环境。
Paddle Inference支持通过在不同线程运行多个Predictor的方式来优化预测性能，支持CPU和GPU环境。
使用多线程预测的样例详见[C++预测样例编译测试](#C++预测样例编译测试)中下载的[预测样例](https://paddle-inference-dist.bj.bcebos.com/tensorrt_test/paddle_inference_sample_v1.7.tar.gz)中的
`thread_mobilenet_test.cc`文件。可以将`run.sh`中`mobilenet_test`替换成`thread_mobilenet_test`再执行
......@@ -387,3 +249,1233 @@ sh run.sh
```
即可运行多线程预测样例。
## <a name="推理升级指南"> 推理升级指南</a>
2.0对API做了整理，简化了写法，以及去掉了历史上冗余的概念。
新的 API 为纯增，原有 API 保持不变，在后续版本会逐步删除。
重要变化：
- 命名空间从 `paddle` 变更为 `paddle_infer`
- `PaddleTensor`, `PaddleBuf` 等被废弃，`ZeroCopyTensor` 变为默认 Tensor 类型，并更名为 `Tensor`
- 新增 `PredictorPool` 工具类简化多线程 predictor 的创建，后续也会增加更多周边工具
- `CreatePredictor` (原 `CreatePaddlePredictor`) 的返回值由 `unique_ptr` 变为 `shared_ptr` 以避免 Clone 后析构顺序出错的问题
API 变更
| 原有命名 | 现有命名 | 行为变化 |
| ---------------------------- | ---------------------------- | ----------------------------- |
| 头文件 `paddle_infer.h` | 无变化 | 包含旧接口，保持向后兼容 |
| 无 | `paddle_inference_api.h` | 新API，可以与旧接口并存 |
| `CreatePaddlePredictor` | `CreatePredictor` | 返回值变为 shared_ptr |
| `ZeroCopyTensor` | `Tensor` | 无 |
| `AnalysisConfig` | `Config` | 无 |
| `TensorRTConfig` | 废弃 | |
| `PaddleTensor` + `PaddleBuf` | 废弃 | |
| `Predictor::GetInputTensor` | `Predictor::GetInputHandle` | 无 |
| `Predictor::GetOutputTensor` | `Predictor::GetOutputHandle` | 无 |
| | `PredictorPool` | 简化创建多个 predictor 的支持 |
使用新 C++ API 的流程与之前完全一致，只有命名变化
```c++
#include "paddle_infernce_api.h"
using namespace paddle_infer;
Config config;
config.SetModel("xxx_model_dir");
auto predictor = CreatePredictor(config);
// Get the handles for the inputs and outputs of the model
auto input0 = predictor->GetInputHandle("X");
auto output0 = predictor->GetOutputHandle("Out");
for (...) {
// Assign data to input0
MyServiceSetData(input0);
predictor->Run();
// get data from the output0 handle
MyServiceGetData(output0);
}
```
## <a name="C++_API"> C++ API</a>
##### CreatePredictor
```c++
std::shared_ptr<Predictor> CreatePredictor(const Config& config);
```
`CreatePredictor`用来根据`Config`构建预测引擎。
示例：
```c++
// 设置Config
Config config;
config.SetModel(FLAGS_model_dir);
// 根据Config创建Predictor
std::shared_ptr<Predictor> predictor = CreatePredictor(config);
```
参数：
- `config(Config)` - 用于构建Predictor的配置信息
返回：`Predictor`智能指针
返回类型：`std::shared_ptr<Predictor>`
##### GetVersion()
```c++
std::string GetVersion();
```
打印Paddle Inference的版本信息。
参数：
- `None`
返回：版本信息
返回类型：`std::string`
##### PlaceType
```c++
enum class PaddlePlace { kUNK };
using PlaceType = paddle::PaddlePlace;
```
PlaceType为目标设备硬件类型，用户可以根据应用场景选择硬件平台类型。
枚举行变量`PlaceType`的所有可能取值包括：
`{kUNK, kCPU, kGPU}`
##### PrecisionType
```c++
enum class Precision { kFloat32 };
using PrecisionType = paddle::AnalysisConfig::Precision;
```
`PrecisionType`设置模型的运行精度，默认值为kFloat32(float32)。
枚举型变量`PrecisionType`的所有可能取值包括：
`{kFloat32, kInt8, kHalf}`
##### DataType
```c++
enum class PaddleDType { FLOAT32 };
using DataType = paddle::PaddleDType;
```
`DataType`为模型中Tensor的数据精度，默认值为FLOAT32(float32)。
枚举行变量`DataType`的所有可能取值包括：
`{FLOAT32, INT64, INT32, UINT8}`
##### GetNumBytesOfDataType
```c++
int GetNumBytesOfDataType(DataType dtype);
```
获取各个`DataType`对应的字节数。
参数：
- `dtype` - DataType枚举
返回：字节数
返回类型：`int`
##### Predictor
```c++
class Predictor;
```
`Predictor`是Paddle Inference的预测器，由`CreatePredictor`根据`Config`进行创建。用户可以根据Predictor提供的接口设置输入数据、执行模型预测、获取输出等.
示例：
```c++
using namespace paddle_infer;
Config config;
config.SetModel("xxx_model_dir");
auto predictor = CreatePredictor(config);
// Get the handles for the inputs and outputs of the model
auto input0 = predictor->GetInputHandle("X");
auto output0 = predictor->GetOutputHandle("Out");
for (...) {
// Assign data to input0
MyServiceSetData(input0);
predictor->Run();
// get data from the output0 handle
MyServiceGetData(output0);
}
```
###### GetInputNames()
获取所有输入Tensor的名称。
参数：
- `None`
返回：所有输入Tensor的名称
返回类型：`std::vector<std::string>`
###### GetOutputNames()
获取所有输出Tensor的名称。
参数：
- `None`
返回：所有输出Tensor的名称
返回类型：`std::vector<std::string>`
###### GetInputHandle(const std::string& name)
根据名称获取输入Tensor的句柄。
参数：
- `name` - Tensor的名称
返回：指向`Tensor`的指针
返回类型：`std::unique_ptr<Tensor>`
###### GetOutputHandle(const std::string& name)
根据名称获取输出Tensor的句柄。
参数：
- `name` - Tensor的名称
返回：指向`Tensor`的指针
返回类型：`std::unique_ptr<Tensor>`
###### Run()
执行模型预测，需要在***设置输入数据后***调用。
参数：
- `None`
返回：`None`
返回类型：`void`
###### ClearIntermediateTensor()
释放中间tensor。
参数：
- `None`
返回：`None`
返回类型：`void`
###### Clone()
根据该Predictor，克隆一个新的Predictor，两个Predictor之间共享权重。
参数：
- `None`
返回：新的Predictor
返回类型：`std::unique_ptr<Predictor>`
##### Tensor
```c++
class Tensor;
```
Tensor是Paddle Inference的数据组织形式，用于对底层数据进行封装并提供接口对数据进行操作，包括设置Shape、数据、LoD信息等。
*注意：用户应使用`Predictor`的`GetInputHandle`和`GetOuputHandle`接口获取输入/输出的`Tensor`。*
示例：
```c++
// 通过创建的Predictor获取输入和输出的tensor
auto input_names = predictor->GetInputNames();
auto input_t = predictor->GetInputHandle(input_names[0]);
auto output_names = predictor->GetOutputNames();
auto output_t = predictor->GetOutputHandle(output_names[0]);
// 对tensor进行reshape
input_t->Reshape({batch_size, channels, height, width});
// 通过CopyFromCpu接口，将cpu数据输入；通过CopyToCpu接口，将输出数据copy到cpu
input_t->CopyFromCpu<float>(input_data /*数据指针*/);
output_t->CopyToCpu(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>(PlaceType::kGPU); // CPU下使用PlaceType::kCPU
int output_size;
float *output_d = output_t->data<float>(PlaceType::kGPU, &output_size);
```
###### Reshape(shape)
设置Tensor的维度信息。
参数：
- `shape(const std::vector<int>&)` - 维度信息
返回：`None`
返回类型：`void`
###### shape()
获取Tensor的维度信息。
参数：
- `None`
返回：Tensor的维度信息
返回类型：`std::vector<int>`
###### CopyFromCpu(data)
```c++
template <typename T>
void CopyFromCpu(const T* data);
```
从cpu获取数据，设置到tensor内部。
示例：
```c++
// float* data = ...;
auto in_tensor = predictor->GetInputHandle("in_name");
in_tensor->CopyFromCpu(data);
```
参数：
- `data(const T*)` - cpu数据指针
返回：`None`
返回类型：`void`
###### CopyToCpu(data)
```c++
template <typename T>
void CopyToCpu(T* data);
```
示例：
```c++
std::vector<float> data(100);
auto out_tensor = predictor->GetOutputHandle("out_name");
out_tensor->CopyToCpu(data.data());
```
参数：
- `data(T*)` - cpu数据指针
返回：`None`
返回类型：`void`
###### data<T>(place, size)
```c++
template <typename T>
T* data(PlaceType* place, int* size) const;
```
获取Tensor的底层数据的常量指针，用于读取Tensor数据。
示例：
```c++
PlaceType place;
int size;
auto out_tensor = predictor->GetOutputHandle("out_name");
float* data = out_tensor->data<float>(&place, &size);
```
参数：
- `place(PlaceType*)` - 获取tensor的PlaceType
- `size(int*)` - 获取tensor的size
返回：数据指针
返回类型：`T*`
###### mutable_data<T>(place)
```c++
template <typename T>
T* mutable_data(PlaceType place);
```
获取Tensor的底层数据的指针，用于设置Tensor数据。
```c++
auto in_tensor = predictor->GetInputHandle("in_name");
float* data = out_tensor->mutable_data<float>(PlaceType::kCPU);
data[0] = 1.;
```
参数：
- `place(PlaceType)` - 设备信息
返回：`Tensor`底层数据指针
返回类型：`T*`
###### SetLoD(lod)
设置Tensor的LoD信息。
参数：
- `lod(const std::vector<std::vector<size_t>>)` - Tensor的LoD信息
返回：`None`
返回类型：`void`
###### lod()
获取Tensor的LoD信息
参数：
- `None`
返回：`Tensor`的LoD信息
返回类型：`std::vector<std::vector<size_t>>`
###### type()
tensor的DataType信息。
参数：
- `None`
返回：`Tensor`的DataType信息
返回类型：`DataType`
###### name()
tensor对应的name。
参数：
- `None`
返回：`Tensor`对应的name
返回类型：`std::string`
##### Config
```c++
class Config;
```
`Config`用来配置构建`Predictor`的配置信息，如模型路径、是否开启gpu等等。
示例：
```c++
Config config;
config.SetModel(FLAGS_model_dir);
config.DisableGpu();
config->SwitchIrOptim(false); // 默认为true。如果设置为false，关闭所有优化
config->EnableMemoryOptim(); // 开启内存/显存复用
```
###### SetModel(const std::string& model_dir)
设置模型文件路径，当需要从磁盘加载非combine模式时使用。
参数：
- `model_dir` - 模型文件夹路径
返回：`None`
返回类型：`void`
###### model_dir()
获取模型文件夹路径。
参数：
- `None`
返回：模型文件夹路径
返回类型：`string`
###### SetModel(const std::string& prog, const std::string& params)
设置模型文件路径，当需要从磁盘加载combine模式时使用。
参数：
- `prog` - 模型文件路径
- `params` - 模型参数文件路径
返回：`None`
返回类型：`void`
###### SetProgFile(const std::string& prog)
设置模型文件路径。
参数：
- `prog` - 模型文件路径
返回：`None`
返回类型：`void`
###### prog_file()
获取模型文件路径。
参数：
- `None`
返回：模型文件路径
返回类型：`string`
###### SetParamsFile(const std::string& params)
设置模型参数文件路径。
参数：
- `params` - 模型文件路径
返回：`None`
返回类型：`void`
###### params_file()
获取模型参数文件路径。
参数：
- `None`
返回：模型参数文件路径
返回类型：`string`
###### SetModelBuffer(const char* prog_buffer, size_t prog_buffer_size, const char* params_buffer, size_t params_buffer_size)
从内存加载模型。
参数：
- `prog_buffer` - 内存中模型结构数据
- `prog_buffer_size` - 内存中模型结构数据的大小
- `params_buffer` - 内存中模型参数数据
- `params_buffer_size` - 内存中模型参数数据的大小
返回：`None`
返回类型：`void`
###### model_from_memory()
判断是否从内存中加载模型。
参数：
- `None`
返回：是否从内存中加载模型
返回类型：`bool`
###### SetOptimCacheDir(const std::string& opt_cache_dir)
设置缓存路径。
参数：
- `opt_cache_dir` - 缓存路径
返回：`None`
返回类型：`void`
###### DisableFCPadding（）
关闭fc padding。
参数：
- `None`
返回：`None`
返回类型：`void`
###### use_fc_padding()
判断是否启用fc padding。
参数：
- `None`
返回：是否启用fc padding
返回类型：`bool`
###### EnableUseGpu(uint64_t memory_pool_init_size_mb, int device_id = 0)
启用gpu。
参数：
- `memory_pool_init_size_mb` - 初始化分配的gpu显存，以MB为单位
- `device_id` - 设备id
返回：`None`
返回类型：`void`
###### DisableGpu()
禁用gpu。
参数：
- `None`
返回：`None`
返回类型：`void`
###### use_gpu()
是否启用gpu。
参数：
- `None`
返回：是否启用gpu
返回类型：`bool`
###### gpu_device_id()
获取gpu的device id。
参数：
- `None`
返回：gpu的device id
返回类型：`int`
###### memory_pool_init_size_mb()
获取gpu的初始显存大小。
参数：
- `None`
返回：初始的显存大小
返回类型：`int`
###### fraction_of_gpu_memory_for_pool()
初始化显存占总显存的百分比
参数：
- `None`
返回：初始的显存占总显存的百分比
返回类型：`float`
###### EnableCUDNN()
启用cudnn。
参数：
- `None`
返回：`None`
返回类型：`void`
###### cudnn_enabled()
是否启用cudnn。
参数：
- `None`
返回：是否启用cudnn
返回类型：`bool`
###### EnableXpu(int l3_workspace_size)
启用xpu。
参数：
- `l3_workspace_size` - l3 cache分配的显存大小
返回：`None`
返回类型：`void`
###### SwitchIrOptim(int x=true)
设置是否开启ir优化。
参数：
- `x` - 是否开启ir优化，默认打开
返回：`None`
返回类型：`void`
###### ir_optim()
是否开启ir优化。
参数：
- `None`
返回：是否开启ir优化
返回类型：`bool`
###### SwitchUseFeedFetchOps(int x = true)
设置是否使用feed，fetch op，仅内部使用。
参数：
- `x` - 是否使用feed, fetch op
返回：`None`
返回类型：`void`
###### use_feed_fetch_ops_enabled()
是否使用feed，fetch op。
参数：
- `None`
返回：是否使用feed，fetch op
返回类型：`bool`
###### SwitchSpecifyInputNames(bool x = true)
设置是否需要指定输入tensor的name。
参数：
- `x` - 是否指定输入tensor的name
返回：`None`
返回类型：`void`
###### specify_input_name()
是否需要指定输入tensor的name。
参数：
- `None`
返回：是否需要指定输入tensor的name
返回类型：`bool`
###### EnableTensorRtEngine(int workspace_size = 1 << 20, int max_batch_size = 1, int min_subgraph_size = 3, Precision precision = Precision::kFloat32, bool use_static = false, bool use_calib_mode = true)
设置是否启用TensorRT。
参数：
- `workspace_size` - 指定TensorRT使用的工作空间大小
- `max_batch_size` - 设置最大的batch大小，运行时batch大小不得超过此限定值
- `min_subgraph_size` - Paddle-TRT是以子图的形式运行，为了避免性能损失，当子图内部节点个数大于min_subgraph_size的时候，才会使用Paddle-TRT运行
- `precision` - 指定使用TRT的精度，支持FP32（kFloat32），FP16（kHalf），Int8（kInt8）
- `use_static` - 如果指定为true，在初次运行程序的时候会将TRT的优化信息进行序列化到磁盘上，下次运行时直接加载优化的序列化信息而不需要重新生成
- `use_calib_mode` - 若要运行Paddle-TRT int8离线量化校准，需要将此选项设置为true
返回：`None`
返回类型：`void`
###### tensorrt_engine_enabled()
是否启用tensorRT。
参数：
- `None`
返回：是否启用tensorRT
返回类型：`bool`
###### SetTRTDynamicShapeInfo(std::map<std::string, std::vector<int>> min_input_shape, std::map<std::string, std::vector<int>> max_input_shape, std::map<std::string, std::vector<int>> optim_input_shape, bool disable_trt_plugin_fp16 = false)
设置tensorRT的动态shape。
参数：
- `min_input_shape` - tensorRT子图支持动态shape的最小shape
- `max_input_shape` - tensorRT子图支持动态shape的最大shape
- `optim_input_shape` - tensorRT子图支持动态shape的最优shape
- `disable_trt_plugin_fp16` - 设置tensorRT的plugin不在fp16精度下运行
返回：`None`
返回类型：`void`
###### EnableLiteEngine(AnalysisConfig::Precision precision_mode = Precsion::kFloat32, bool zero_copy = false, const std::vector<std::string>& passes_filter = {}, const std::vector<std::string>& ops_filter = {})
启用lite子图。
参数：
- `precision_mode` - lite子图的运行精度
- `zero_copy` - 启用zero_copy，lite子图与paddle inference之间共享数据
- `passes_filter` - 设置lite子图的pass
- `ops_filter` - 设置不使用lite子图运行的op
返回：`None`
返回类型：`void`
###### lite_engine_enabled()
是否启用lite子图。
参数：
- `None`
返回：是否启用lite子图
返回类型：`bool`
###### SwitchIrDebug(int x = true)
设置是否在图分析阶段打印ir，启用后会在每一个pass后生成dot文件。
参数：
- `x` - 是否打印ir
返回：`None`
返回类型：`void`
###### EnableMKLDNN()
启用mkldnn。
参数：
- `None`
返回：`None`
返回类型：`void`
###### SetMkldnnCacheCapacity(int capacity)
设置mkldnn针对不同输入shape的cache容量大小，MKLDNN cache设计文档请参考[链接](https://github.com/PaddlePaddle/FluidDoc/blob/develop/doc/fluid/design/mkldnn/caching/caching.md)
参数：
- `capacity` - cache容量大小
返回：`None`
返回类型：`void`
###### mkldnn_enabled()
是否启用mkldnn。
参数：
- `None`
返回：是否启用mkldnn
返回类型：`bool`
###### SetMKLDNNOp(std::unordered_set<std::string> op_list)
指定优先使用mkldnn加速的op列表。
参数：
- `op_list` - 优先使用mkldnn的op列表
返回：`None`
返回类型：`void`
###### EnableMkldnnQuantizer()
启用mkldnn量化。
参数：
- `None`
返回：`None`
返回类型：`void`
###### mkldnn_quantizer_enabled()
是否启用mkldnn量化。
参数：
- `None`
返回：是否启用mkldnn量化
返回类型：`bool`
###### EnableMkldnnBfloat16()
启用mkldnn bf16。
参数：
- `None`
返回：`None`
返回类型：`void`
###### mkldnn_bfloat16_enabled()
是否启用mkldnn bf16。
参数：
- `None`
返回：是否启用mkldnn bf16
返回类型：`bool`
###### mkldnn_quantizer_config()
返回mkldnn量化config。
参数：
- `None`
返回：mkldnn量化config
返回类型：`MkldnnQuantizerConfig`
###### SetCpuMathLibraryNumThreads(int cpu_math_library_num_threads)
设置cpu blas库计算线程数。
参数：
- `cpu_math_library_num_threads` - blas库计算线程数
返回：`None`
返回类型：`void`
###### cpu_math_library_num_threads()
cpu blas库计算线程数。
参数：
- `None`
返回：cpu blas库计算线程数。
返回类型：`int`
###### ToNativeConfig()
转化为NativeConfig，不推荐使用。
参数：
- `None`
返回：当前Config对应的NativeConfig
返回类型：`NativeConfig`
###### EnableGpuMultiStream()
开启线程流，目前的行为是为每一个线程绑定一个流，在将来该行为可能改变。
参数：
- `None`
返回：`None`
返回类型：`void`
###### thread_local_stream_enabled()
是否启用线程流。
参数：
- `None`
返回：是否启用线程流。
返回类型：`bool`
###### EnableMemoryOptim()
开启内/显存复用，具体降低内存效果取决于模型结构。
参数：
- `None`
返回：`None`
返回类型：`void`
###### enable_memory_optim()
是否开启内/显存复用。
参数：
- `None`
返回：是否开启内/显存复用。
返回类型：`bool`
###### EnableProfile()
打开profile，运行结束后会打印所有op的耗时占比。
参数：
- `None`
返回：`None`
返回类型：`void`
###### profile_enabled()
是否开启profile。
参数：
- `None`
返回：是否开启profile
返回类型：`bool`
###### DisableGlogInfo()
去除Paddle Inference运行中的log。
参数：
- `None`
返回：`None`
返回类型：`void`
###### glog_info_disabled()
是否禁用了log。
参数：
- `None`
返回：是否禁用了log
返回类型：`bool`
###### SetInValid()
设置Config为无效状态，仅内部使用，保证每一个Config仅用来初始化一次Predictor。
参数：
- `None`
返回：`None`
返回类型：`void`
###### is_valid()
当前Config是否有效。
参数：
- `None`
返回：Config是否有效
返回类型：`bool`
###### pass_builder()
返回pass_builder，用来自定义图分析阶段选择的ir。
示例:
```c++
Config config;
auto pass_builder = config.pass_builder()
pass_builder->DeletePass("fc_fuse_pass") // 去除fc_fuse
```
参数：
- `None`
返回：pass_builder
返回类型：`PassStrategy`
##### PredictorPool
```c++
class PredictorPool;
```
`PredictorPool`对`Predictor`进行了简单的封装，通过传入config和thread的数目来完成初始化，在每个线程中，根据自己的线程id直接从池中取出对应的`Predictor`来完成预测过程。
示例：
```c++
Config config;
// init config
int thread_num = 4;
PredictorPool pool(config, thread_num);
auto predictor0 = pool.Retrive(0);
...
auto predictor3 = pool.Retrive(3);
```
###### Retrive(idx)
根据线程id取出该线程对应的Predictor。
参数：
- `idx(int)` - 线程id
返回：线程对应的Predictor
返回类型：`Predictor*`
doc/paddle/advanced_guide/inference_deployment/inference/python_infer_cn.md
浏览文件 @ 69a338f1
# Python 预测 API介绍
Fluid提供了高度优化的[C++预测库](./native_infer.html)，为了方便使用，我们也提供了C++预测库对应的Python接口，下面是详细的使用说明。
Paddle提供了高度优化的[C++预测库](./native_infer.html)，为了方便使用，我们也提供了C++预测库对应的Python接口，下面是详细的使用说明。
如果您在使用2.0之前的Paddle，请参考[旧版API](https://www.paddlepaddle.org.cn/documentation/docs/zh/1.8/advanced_guide/inference_deployment/inference/python_infer_cn.html)文档。
## Python预测相关数据结构
使用Python预测API与C++预测API相似，主要包括`PaddleTensor`, `PaddleDType`, `AnalysisConfig`和`PaddlePredictor`，分别对应于C++ API中同名的类型。
自2.0之后，提供了更直观易懂的封装，主要包括`Tensor`, `DataType`, `PrecisionType`, `Config`和`Predictor`，分别对应于C++ API中的同名类型。
使用Python预测API与C++预测API相似，主要包括`Tensor`, `DataType`, `Config`和`Predictor`，分别对应于C++ API中同名的类型。
### DataType
class paddle.fluid.inference.DataType
class paddle.inference.DataType
`DataType`定义了`Tensor`的数据类型，由传入`Tensor`的numpy数组类型确定，包括以下成员
......@@ -22,7 +20,7 @@ class paddle.fluid.inference.DataType
### PrecisionType
class paddle.fluid.inference.PrecisionType
class paddle.3.inference.PrecisionType
`PrecisionType`定义了`Predictor`运行的精度模式，包括一下成员
......@@ -32,7 +30,7 @@ class paddle.fluid.inference.PrecisionType
### Tensor
class paddle.fluid.inference.Tensor
class paddle.inference.Tensor
`Tensor`是`Predictor`的一种输入/输出数据结构，通过`predictor`获取输入/输出handle得到，主要提供以下方法
......@@ -46,7 +44,7 @@ class paddle.fluid.inference.Tensor
``` python
# 创建predictor
predictor = create_paddle_predictor(config)
predictor = create_predictor(config)
# 获取输入的名称
input_names = predictor.get_input_names()
......@@ -67,7 +65,7 @@ output_data = output_tensor.copy_to_cpu() # numpy.ndarray类型
### Config
class paddle.fluid.inference.Config
class paddle.inference.Config
`Config`是创建预测引擎的配置，提供了模型路径设置、预测引擎运行设备选择以及多种优化预测流程的选项，主要包括以下方法
......@@ -100,18 +98,18 @@ config = Config("./model/model", "./model/params")
``` python
config.enable_use_gpu(100, 0) # 初始化100M显存，使用gpu id为0
config.gpu_device_id() # 返回正在使用的gpu id
config.disable_gpu() # 禁用gpu
config.disable_gpu() # 禁用gpu
config.switch_ir_optim(True) # 开启IR优化
config.enable_tensorrt_engine(precision_mode=AnalysisConfig.Precision.Float32,
config.enable_tensorrt_engine(precision_mode=PrecisionType.Float32,
use_calib_mode=True) # 开启TensorRT预测，精度为fp32，开启int8离线量化
config.enable_mkldnn() # 开启MKLDNN
config.enable_mkldnn() # 开启MKLDNN
```
### Predictor
class paddle.fluid.inference.Predictor
class paddle.inference.Predictor
`Predictor`是运行预测的引擎，由`paddle.fluid.inference.create_predictor(config)`创建，主要提供以下方法
`Predictor`是运行预测的引擎，由`paddle.inference.create_predictor(config)`创建，主要提供以下方法
* `run()`: 运行预测引擎，返回预测结果
* `get_input_names()`: 获取输入的名称
......@@ -142,258 +140,11 @@ output_names = predictor.get_output_names()
output_handle = predictor.get_output_handle(output_names[0])
```
### PaddleTensor
class paddle.fluid.core.PaddleTensor
`PaddleTensor`是预测库输入和输出的数据结构，包括以下字段
* `name`(str): 指定输入的名称
* `shape`(tuple|list): Tensor的shape
* `data`(numpy.ndarray): Tensor的数据，可在PaddleTensor构造的时候用`numpy.ndarray`直接传入
* `dtype`(PaddleDType): Tensor的类型
* `lod`(List[List[int]]): [LoD](../../../user_guides/howto/basic_concept/lod_tensor.html)信息
`PaddleTensor`包括以下方法
* `as_ndarray`: 返回`data`对应的numpy数组
#### 代码示例
``` python
tensor = PaddleTensor(name="tensor", data=numpy.array([1, 2, 3], dtype="int32"))
```
调用`PaddleTensor`的成员字段和方法输出如下：
``` python
>>> tensor.name
'tensor'
>>> tensor.shape
[3]
>>> tensor.dtype
PaddleDType.INT32
>>> tensor.lod
[]
>>> tensor.as_ndarray()
array([1, 2, 3], dtype=int32)
```
### PaddleDType
class paddle.fluid.core.PaddleDType
`PaddleDType`定义了`PaddleTensor`的数据类型，由传入`PaddleTensor`的numpy数组类型确定，包括以下成员
* `INT64`: 64位整型
* `INT32`: 32位整型
* `FLOAT32`: 32位浮点型
### AnalysisConfig
class paddle.fluid.core.AnalysisConfig
`AnalysisConfig`是创建预测引擎的配置，提供了模型路径设置、预测引擎运行设备选择以及多种优化预测流程的选项，主要包括以下方法
* `set_model`: 设置模型的路径
* `model_dir`: 返回模型文件夹路径
* `prog_file`: 返回模型文件路径
* `params_file`: 返回参数文件路径
* `enable_use_gpu`: 设置GPU显存(单位M)和Device ID
* `disable_gpu`: 禁用GPU
* `gpu_device_id`: 返回使用的GPU ID
* `switch_ir_optim`: IR优化(默认开启)
* `enable_tensorrt_engine`: 开启TensorRT
* `enable_mkldnn`: 开启MKLDNN
* `disable_glog_info`: 禁用预测中的glog日志
* `delete_pass`: 预测的时候删除指定的pass
#### 代码示例
设置模型和参数路径有两种形式：
* 当模型文件夹下存在一个模型文件和多个参数文件时，传入模型文件夹路径，模型文件名默认为`__model__`
``` python
config = AnalysisConfig("./model")
```
* 当模型文件夹下只有一个模型文件和一个参数文件时，传入模型文件和参数文件路径
``` python
config = AnalysisConfig("./model/model", "./model/params")
```
使用`set_model`方法设置模型和参数路径方式同上
其他预测引擎配置选项示例如下
``` python
config.enable_use_gpu(100, 0) # 初始化100M显存，使用gpu id为0
config.gpu_device_id() # 返回正在使用的gpu id
config.disable_gpu() # 禁用gpu
config.switch_ir_optim(True) # 开启IR优化
config.enable_tensorrt_engine(precision_mode=AnalysisConfig.Precision.Float32,
use_calib_mode=True) # 开启TensorRT预测，精度为fp32，开启int8离线量化
config.enable_mkldnn() # 开启MKLDNN
```
### PaddlePredictor
class paddle.fluid.core.PaddlePredictor
`PaddlePredictor`是运行预测的引擎，由`paddle.fluid.core.create_paddle_predictor(config)`创建，主要提供以下方法
* `run`: 输入和返回值均为`PaddleTensor`列表类型，功能为运行预测引擎，返回预测结果
#### 代码示例
``` python
# 设置完AnalysisConfig后创建预测引擎PaddlePredictor
predictor = create_paddle_predictor(config)
# 设置输入
x = numpy.array([1, 2, 3], dtype="int64")
x_t = fluid.core.PaddleTensor(x)
y = numpy.array([4], dtype = "int64")
y_t = fluid.core.PaddleTensor(y)
# 运行预测引擎得到结果，返回值是一个PaddleTensor的列表
results = predictor.run([x_t, y_t])
# 获得预测结果，并应用到自己的应用中
```
### 使用ZeroCopyTensor管理输入/输出
`ZeroCopyTensor`是`AnalysisPredictor`的一种输入/输出数据结构，与`PaddleTensor`等同。`ZeroCopyTensor`相比于`PaddleTensor`，可以避免预测时候准备输入以及获取输出时多余的数据拷贝，提高预测性能。
注意: 需要注意的是，使用`ZeroCopyTensor`，务必在创建`config`时设置`config.switch_use_feed_fetch_ops(False)`用于显式地在模型运行的时候删去`feed`和`fetch`ops，不会影响模型的效果，但是能提升性能。
``` python
# 创建predictor
predictor = create_paddle_predictor(config)
# 获取输入的名称
input_names = predictor.get_input_names()
input_tensor = predictor.get_input_tensor(input_names[0])
# 设置输入
fake_input = numpy.random.randn(1, 3, 318, 318).astype("float32")
input_tensor.copy_from_cpu(fake_input)
# 运行predictor
predictor.zero_copy_run()
# 获取输出
output_names = predictor.get_output_names()
output_tensor = predictor.get_output_tensor(output_names[0])
output_data = output_tensor.copy_to_cpu() # numpy.ndarray类型
```
### AnalysisPredictor
class paddle.fluid.core.AnalysisPredictor
`AnalysisPredictor`是运行预测的引擎，继承于`PaddlePredictor`，同样是由`paddle.fluid.core.create_paddle_predictor(config)`创建，主要提供以下方法
* `zero_copy_run()`: 运行预测引擎，返回预测结果
* `get_input_names()`: 获取输入的名称
* `get_input_tensor(input_name: str)`: 根据输入的名称获取对应的`ZeroCopyTensor`
* `get_output_names()`: 获取输出的名称
* `get_output_tensor(output_name: str)`: 根据输出的名称获取对应的`ZeroCopyTensor`
#### 代码示例
``` python
# 设置完AnalysisConfig后创建预测引擎PaddlePredictor
predictor = create_paddle_predictor(config)
# 获取输入的名称
input_names = predictor.get_input_names()
input_tensor = predictor.get_input_tensor(input_names[0])
# 设置输入
fake_input = numpy.random.randn(1, 3, 318, 318).astype("float32")
input_tensor.reshape([1, 3, 318, 318])
input_tensor.copy_from_cpu(fake_input)
# 运行predictor
predictor.zero_copy_run()
# 获取输出
output_names = predictor.get_output_names()
output_tensor = predictor.get_output_tensor(output_names[0])
```
## 支持方法列表
* Tensor
* `copy_from_cpu(input: numpy.ndarray) -> None`
* `copy_to_cpu() -> numpy.ndarray`
* `reshape(input: numpy.ndarray|List[int]) -> None`
* `shape() -> List[int]`
* `set_lod(input: numpy.ndarray|List[List[int]]) -> None`
* `lod() -> List[List[int]]`
* `type() -> DataType`
* Config
* `set_model(model_dir: str) -> None`
* `set_model(prog_file: str, params_file: str) -> None`
* `model_dir() -> str`
* `prog_file() -> str`
* `params_file() -> str`
* `enable_use_gpu(memory_pool_init_size_mb: int, device_id: int) -> None`
* `gpu_device_id() -> int`
* `switch_ir_optim(x: bool = True) -> None`
* `enable_tensorrt_engine(workspace_size: int = 1 << 20,
max_batch_size: int,
min_subgraph_size: int,
precision_mode: PrecisionType,
use_static: bool,
use_calib_mode: bool) -> None`
* `enable_mkldnn() -> None`
* `disable_glog_info() -> None`
* `delete_pass(pass_name: str) -> None`
* Predictor
* `zero_copy_run() -> None`
* `get_input_names() -> List[str]`
* `get_input_tensor(input_name: str) -> ZeroCopyTensor`
* `get_output_names() -> List[str]`
* `get_output_tensor(output_name: str) -> ZeroCopyTensor`
* PaddleTensor
* `as_ndarray() -> numpy.ndarray`
* ZeroCopyTensor
* `copy_from_cpu(input: numpy.ndarray) -> None`
* `copy_to_cpu() -> numpy.ndarray`
* `reshape(input: numpy.ndarray|List[int]) -> None`
* `shape() -> List[int]`
* `set_lod(input: numpy.ndarray|List[List[int]]) -> None`
* `lod() -> List[List[int]]`
* `type() -> PaddleDType`
* AnalysisConfig
* `set_model(model_dir: str) -> None`
* `set_model(prog_file: str, params_file: str) -> None`
* `model_dir() -> str`
* `prog_file() -> str`
* `params_file() -> str`
* `enable_use_gpu(memory_pool_init_size_mb: int, device_id: int) -> None`
* `gpu_device_id() -> int`
* `switch_ir_optim(x: bool = True) -> None`
* `enable_tensorrt_engine(workspace_size: int = 1 << 20,
max_batch_size: int,
min_subgraph_size: int,
precision_mode: AnalysisConfig.precision,
use_static: bool,
use_calib_mode: bool) -> None`
* `enable_mkldnn() -> None`
* `disable_glog_info() -> None`
* `delete_pass(pass_name: str) -> None`
* PaddlePredictor
* `run(input: List[PaddleTensor]) -> List[PaddleTensor]`
* AnalysisPredictor
* `zero_copy_run() -> None`
* `get_input_names() -> List[str]`
* `get_input_tensor(input_name: str) -> ZeroCopyTensor`
* `get_output_names() -> List[str]`
* `get_output_tensor(output_name: str) -> ZeroCopyTensor`
可参考对应的[C++预测接口](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/pybind/inference_api.cc)，其中定义了每个接口的参数和返回值
## 完整使用示例
下面是使用Fluid Python API进行预测的一个完整示例，使用resnet50模型
下面是使用Paddle Inference Python API进行预测的一个完整示例，使用resnet50模型
下载[resnet50模型](http://paddle-inference-dist.bj.bcebos.com/resnet50_model.tar.gz)并解压，运行如下命令将会调用预测引擎
......@@ -403,13 +154,11 @@ python resnet50_infer.py --model_file ./model/model --params_file ./model/params
`resnet50_infer.py` 的内容是
### Config+Predictor+Tensor的完整使用示例(2.0支持)
``` python
import argparse
import numpy as np
from paddle.fluid.inference import Config
from paddle.fluid.inference import create_predictor
from paddle.inference import Config
from paddle.inference import create_predictor
def main():
......@@ -460,116 +209,76 @@ if __name__ == "__main__":
main()
```
### PaddleTensor的完整使用示例
``` python
import argparse
import numpy as np
from paddle.fluid.core import PaddleTensor
from paddle.fluid.core import AnalysisConfig
from paddle.fluid.core import create_paddle_predictor
def main():
args = parse_args()
# 设置AnalysisConfig
config = AnalysisConfig(args.model_file, args.params_file)
config.disable_gpu()
# 创建PaddlePredictor
predictor = create_paddle_predictor(config)
# 设置输入，此处以随机输入为例，用户可自行输入真实数据
inputs = fake_input(args.batch_size)
# 运行预测引擎
outputs = predictor.run(inputs)
output_num = 512
# 获得输出并解析
output = outputs[0]
print(output.name)
output_data = output.as_ndarray() #return numpy.ndarray
assert list(output_data.shape) == [args.batch_size, output_num]
for i in range(args.batch_size):
print(np.argmax(output_data[i]))
def fake_input(batch_size):
shape = [batch_size, 3, 318, 318]
data = np.random.randn(*shape).astype("float32")
image = PaddleTensor(data)
return [image]
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("--model_file", type=str, help="model filename")
parser.add_argument("--params_file", type=str, help="parameter filename")
parser.add_argument("--batch_size", type=int, default=1, help="batch size")
return parser.parse_args()
if __name__ == "__main__":
main()
```
### ZeroCopyTensor的完整使用示例
``` python
import argparse
import numpy as np
from paddle.fluid.core import AnalysisConfig
from paddle.fluid.core import create_paddle_predictor
def main():
args = parse_args()
# 设置AnalysisConfig
config = set_config(args)
# 创建PaddlePredictor
predictor = create_paddle_predictor(config)
# 获取输入的名称
input_names = predictor.get_input_names()
input_tensor = predictor.get_input_tensor(input_names[0])
# 设置输入
fake_input = np.random.randn(1, 3, 318, 318).astype("float32")
input_tensor.reshape([1, 3, 318, 318])
input_tensor.copy_from_cpu(fake_input)
# 运行predictor
predictor.zero_copy_run()
# 获取输出
output_names = predictor.get_output_names()
output_tensor = predictor.get_output_tensor(output_names[0])
output_data = output_tensor.copy_to_cpu() # numpy.ndarray类型
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("--model_file", type=str, help="model filename")
parser.add_argument("--params_file", type=str, help="parameter filename")
parser.add_argument("--batch_size", type=int, default=1, help="batch size")
return parser.parse_args()
def set_config(args):
config = AnalysisConfig(args.model_file, args.params_file)
config.disable_gpu()
config.switch_use_feed_fetch_ops(False)
config.switch_specify_input_names(True)
return config
## 支持方法列表
* Tensor
* `copy_from_cpu(input: numpy.ndarray) -> None`
* `copy_to_cpu() -> numpy.ndarray`
* `reshape(input: numpy.ndarray|List[int]) -> None`
* `shape() -> List[int]`
* `set_lod(input: numpy.ndarray|List[List[int]]) -> None`
* `lod() -> List[List[int]]`
* `type() -> PaddleDType`
* Config
* `set_model(model_dir: str) -> None`
* `set_model(prog_file: str, params_file: str) -> None`
* `set_model_buffer(model: str, model_size: int, param: str, param_size: int) -> None`
* `model_dir() -> str`
* `prog_file() -> str`
* `params_file() -> str`
* `model_from_memory() -> bool`
* `set_cpu_math_library_num_threads(num: int) -> None`
* `enable_use_gpu(memory_pool_init_size_mb: int, device_id: int) -> None`
* `use_gpu() -> bool`
* `gpu_device_id() -> int`
* `switch_ir_optim(x: bool = True) -> None`
* `switch_ir_debug(x: int=True) -> None`
* `ir_optim() -> bool`
* `enable_tensorrt_engine(workspace_size: int = 1 << 20,
max_batch_size: int,
min_subgraph_size: int,
precision_mode: AnalysisConfig.precision,
use_static: bool,
use_calib_mode: bool) -> None`
* `set_trt_dynamic_shape_info(min_input_shape: Dict[str, List[int]]={}, max_input_shape: Dict[str, List[int]]={}, optim_input_shape: Dict[str, List[int]]={}, disable_trt_plugin_fp16: bool=False) -> None`
* `tensorrt_engine_enabled() -> bool`
* `enable_mkldnn() -> None`
* `enable_mkldnn_bfloat16() -> None`
* `mkldnn_enabled() -> bool`
* `set_mkldnn_cache_capacity(capacity: int=0) -> None`
* `set_mkldnn_op(ops: Set[str]) -> None`
* `set_optim_cache_dir(dir: str) -> None`
* `disable_glog_info() -> None`
* `pass_builder() -> paddle::PassStrategy`
* `delete_pass(pass_name: str) -> None`
* `cpu_math_library_num_threads() -> int`
* `disable_gpu() -> None`
* `enable_lite_engine(precision: PrecisionType, zero_copy: bool, passes_filter: List[str]=[], ops_filter: List[str]=[]) -> None`
* `lite_engine_enabled() -> bool`
* `enable_memory_optim() -> None`
* `enable_profile() -> None`
* `enable_quantizer() -> None`
* `quantizer_config() -> paddle::MkldnnQuantizerConfig`
* `fraction_of_gpu_memory_for_pool() -> float`
* `memory_pool_init_size_mb() -> int`
* `glog_info_disabled() -> bool`
* `gpu_device_id() -> int`
* `specify_input_name() -> bool`
* `switch_specify_input_names(x: bool=True) -> None`
* `specify_input_name(q) -> bool`
* `switch_use_feed_fetch_ops(x: int=True) -> None`
* `use_feed_fetch_ops_enabled() -> bool`
* `to_native_config() -> paddle.fluid.core_avx.NativeConfig`
* `create_predictor(config: Config) -> Predictor`
* Predictor
* `run() -> None`
* `get_input_names() -> List[str]`
* `get_input_handle(input_name: str) -> Tensor`
* `get_output_names() -> List[str]`
* `get_output_handle(output_name: str) -> Tensor`
* `clear_intermediate_tensor() -> None`
* `clone() -> Predictor`
* PredictorPool
* `retrive(idx: int) -> Predictor`
if __name__ == "__main__":
main()
```
可参考对应的[C++预测接口](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/pybind/inference_api.cc)，其中定义了每个接口的参数和返回值
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或