add 2.0 api test=develop. test=document_fix

doc/paddle/advanced_guide/inference_deployment/inference/native_infer.md

@@ -6,7 +6,9 @@
 
 
 ## 内容
-
+- [使用Config管理预测配置(2.0)](#使用Config管理预测配置)
+- [使用Tensor管理输入/输出(2.0)](#使用Tensor管理输入/输出(2.0))
+- [使用Predictor进行高性能预测(2.0)](#使用Predictor进行高性能预测)
 - [使用AnalysisPredictor进行高性能预测](#使用AnalysisPredictor进行高性能预测)
 - [使用AnalysisConfig管理预测配置](#使用AnalysisConfig管理预测配置)
 - [使用ZeroCopyTensor管理输入/输出](#使用ZeroCopyTensor管理输入/输出)
@@ -14,6 +16,150 @@
 - [性能调优](#性能调优)
 
 
+## <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进行高性能预测(2.0)"> 使用Predictor进行高性能预测(2.0)</a>
+2.0之后，统一使用 Predictor 进行预测。Predictor 是一个高性能预测引擎，该引擎通过对计算图的分析，完成对计算图的一系列的优化（如OP的融合、内存/显存的优化、 MKLDNN，TensorRT 等底层加速库的支持等），能够大大提升预测性能。
+
+为了展示完整的预测流程，下面是一个使用 Predictor 进行预测的完整示例。
+
+#### Predictor 预测示例
+
+``` c++
+#include "paddle_inference_api.h"
+
+namespace paddle_infer {
+void CreateConfig(Config* 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);
+  */
+
+  config->SwitchIrDebug(true); 		// 可视化调试选项，若开启，则会在每个图优化过程后生成dot文件
+  // config->SwitchIrOptim(false); 	// 默认为true。如果设置为false，关闭所有优化
+  // config->EnableMemoryOptim(); 	// 开启内存/显存复用
+}
+
+void RunAnalysis(int batch_size, std::string model_dirname) {
+  // 1. 创建AnalysisConfig
+  Config config;
+  CreateConfig(&config, model_dirname);
+
+  // 2. 根据config 创建predictor，并准备输入数据，此处以全0数据为例
+  auto predictor = CreatePredictor(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->GetInputHandle(input_names[0]);
+  input_t->Reshape({batch_size, channels, height, width});
+  input_t->CopyFromCpu(input);
+
+  // 4. 运行预测引擎
+  CHECK(predictor->Run());
+
+  // 5. 获取输出
+  std::vector<float> out_data;
+  auto output_names = predictor->GetOutputNames();
+  auto output_t = predictor->GetOutputHandle(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->CopyToCpu(out_data.data());
+}
+}  // namespace paddle_infer
+
+int main() {
+  // 模型下载地址 http://paddle-inference-dist.cdn.bcebos.com/tensorrt_test/mobilenet.tar.gz
+  paddle::RunAnalysis(1, "./mobilenet");
+  return 0;
+}
+
+```
 
 ## <a name="使用AnalysisPredictor进行高性能预测"> 使用AnalysisPredictor进行高性能预测</a>
 Paddle Fluid采用 AnalysisPredictor 进行预测。AnalysisPredictor 是一个高性能预测引擎，该引擎通过对计算图的分析，完成对计算图的一系列的优化（如OP的融合、内存/显存的优化、 MKLDNN，TensorRT 等底层加速库的支持等），能够大大提升预测性能。

doc/paddle/advanced_guide/inference_deployment/inference/python_infer_cn.md

@@ -8,6 +8,140 @@ Fluid提供了高度优化的[C++预测库](./native_infer.html)，为了方便
 
 使用Python预测API与C++预测API相似，主要包括`PaddleTensor`, `PaddleDType`, `AnalysisConfig`和`PaddlePredictor`，分别对应于C++ API中同名的类型。
 
+自2.0之后，提供了更直观易懂的封装，主要包括`Tensor`, `DataType`, `PrecisionType`, `Config`和`Predictor`，分别对应于C++ API中的同名类型。
+
+### DataType
+
+class paddle.fluid.inference.DataType
+
+`DataType`定义了`Tensor`的数据类型，由传入`Tensor`的numpy数组类型确定，包括以下成员
+
+* `INT64`: 64位整型
+* `INT32`: 32位整型
+* `FLOAT32`: 32位浮点型
+
+### PrecisionType
+
+class paddle.fluid.inference.PrecisionType
+
+`PrecisionType`定义了`Predictor`运行的精度模式，包括一下成员
+
+* `Float32`: fp32模式运行
+* `Half`: fp16模式运行
+* `Int8`: int8模式运行
+
+### Tensor
+
+class paddle.fluid.inference.Tensor
+
+`Tensor`是`Predictor`的一种输入/输出数据结构，通过`predictor`获取输入/输出handle得到，主要提供以下方法
+
+* `copy_from_cpu`: 从cpu获取模型运行所需输入数据
+* `copy_to_cpu`: 获取模型运行输出结果
+* `lod`: 获取lod信息
+* `set_lod`: 设置lod信息
+* `shape`: 获取shape信息
+* `reshape`: 设置shape信息
+* `type`: 获取DataType信息
+
+``` python
+# 创建predictor
+predictor = create_paddle_predictor(config)
+
+# 获取输入的名称
+input_names = predictor.get_input_names()
+input_tensor = predictor.get_input_handle(input_names[0])
+
+# 设置输入
+fake_input = numpy.random.randn(1, 3, 318, 318).astype("float32")
+input_tensor.copy_from_cpu(fake_input)
+
+# 运行predictor
+predictor.run()
+
+# 获取输出
+output_names = predictor.get_output_names()
+output_tensor = predictor.get_output_handle(output_names[0])
+output_data = output_tensor.copy_to_cpu() # numpy.ndarray类型
+```
+
+### Config
+
+class paddle.fluid.inference.Config
+
+`Config`是创建预测引擎的配置，提供了模型路径设置、预测引擎运行设备选择以及多种优化预测流程的选项，主要包括以下方法
+
+* `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 = Config("./model")
+```
+* 当模型文件夹下只有一个模型文件和一个参数文件时，传入模型文件和参数文件路径
+``` python
+config = Config("./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
+```
+
+### Predictor
+
+class paddle.fluid.inference.Predictor
+
+`Predictor`是运行预测的引擎，由`paddle.fluid.inference.create_predictor(config)`创建，主要提供以下方法
+
+* `run()`: 运行预测引擎，返回预测结果
+* `get_input_names()`: 获取输入的名称
+* `get_input_handle(input_name: str)`: 根据输入的名称获取对应的`Tensor`
+* `get_output_names()`: 获取输出的名称
+* `get_output_handle(output_name: str)`: 根据输出的名称获取对应的`Tensor`
+
+#### 代码示例
+
+``` python
+# 设置完AnalysisConfig后创建预测引擎PaddlePredictor
+predictor = create_predictor(config)
+
+# 获取输入的名称
+input_names = predictor.get_input_names()
+input_handle = predictor.get_input_handle(input_names[0])
+
+# 设置输入
+fake_input = numpy.random.randn(1, 3, 318, 318).astype("float32")
+input_handle.reshape([1, 3, 318, 318])
+input_handle.copy_from_cpu(fake_input)
+
+# 运行predictor
+predictor.run()
+
+# 获取输出
+output_names = predictor.get_output_names()
+output_handle = predictor.get_output_handle(output_names[0])
+```
+
 ### PaddleTensor
 
 class paddle.fluid.core.PaddleTensor
@@ -45,7 +179,7 @@ array([1, 2, 3], dtype=int32)
 
 ### PaddleDType
 
-class paddle.fluid.core.PaddleTensor
+class paddle.fluid.core.PaddleDType
 
 `PaddleDType`定义了`PaddleTensor`的数据类型，由传入`PaddleTensor`的numpy数组类型确定，包括以下成员
 
@@ -186,6 +320,38 @@ 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
@@ -237,6 +403,63 @@ 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
+
+
+def main():
+    args = parse_args()
+
+    # 设置AnalysisConfig
+    config = set_config(args)
+
+    # 创建PaddlePredictor
+    predictor = create_predictor(config)
+
+    # 获取输入的名称
+    input_names = predictor.get_input_names()
+    input_handle = predictor.get_input_handle(input_names[0])
+
+    # 设置输入
+    fake_input = np.random.randn(1, 3, 318, 318).astype("float32")
+    input_handle.reshape([1, 3, 318, 318])
+    input_handle.copy_from_cpu(fake_input)
+
+    # 运行predictor
+    predictor.run()
+
+    # 获取输出
+    output_names = predictor.get_output_names()
+    output_handle = predictor.get_output_handle(output_names[0])
+    output_data = output_handle.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 = Config(args.model_file, args.params_file)
+    config.disable_gpu()
+    config.switch_use_feed_fetch_ops(False)
+    config.switch_specify_input_names(True)
+    return config
+
+
+if __name__ == "__main__":
+    main()
+```
+
 ### PaddleTensor的完整使用示例
 
 ``` python