docs: update inference deployment docs

docs/zh_CN_tmp/inference_deployment/cpp_deploy.md

+# 服务器端C++预测
+
+本教程将介绍在服务器端部署PaddleClas模型的详细步骤。
+
+---
+
+## 1. 准备环境
+
+- Linux 环境，推荐使用 docker。
+- Windows 环境，目前支持基于 `Visual Studio 2019 Community` 进行编译；此外，如果您希望通过生成 `sln解决方案` 的方式进行编译，可以参考该文档：[https://zhuanlan.zhihu.com/p/145446681](https://zhuanlan.zhihu.com/p/145446681)
+
+* 该文档主要介绍基于 Linux 环境下的 PaddleClas C++ 预测流程，如果需要在 Windows 环境下使用预测库进行 C++ 预测，具体编译方法请参考 [Windows下编译教程](./docs/windows_vs2019_build.md)。
+
+### 1.1 编译opencv库
+
+* 首先需要从 opencv 官网上下载在 Linux 环境下源码编译的包，以 3.4.7 版本为例，下载及解压缩命令如下：
+
+```
+wget https://github.com/opencv/opencv/archive/3.4.7.tar.gz
+tar -xvf 3.4.7.tar.gz
+```
+
+执行完成上述命令后，会在当前目录下生成 `opencv-3.4.7/` 的目录。
+
+* 编译 opencv，首先设置 opencv 源码路径(`root_path`)以及安装路径(`install_path`)，`root_path` 为下载的 opencv 源码路径，`install_path` 为 opencv 的安装路径。在本例中，源码路径即为当前目录下的 `opencv-3.4.7/`。
+
+```shell
+cd ./opencv-3.4.7
+export root_path=$PWD
+export install_path=${root_path}/opencv3
+```
+
+* 然后在 opencv 源码路径下，按照下面的命令进行编译：
+
+```shell
+rm -rf build
+mkdir build
+cd build
+
+cmake .. \
+    -DCMAKE_INSTALL_PREFIX=${install_path} \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DBUILD_SHARED_LIBS=OFF \
+    -DWITH_IPP=OFF \
+    -DBUILD_IPP_IW=OFF \
+    -DWITH_LAPACK=OFF \
+    -DWITH_EIGEN=OFF \
+    -DCMAKE_INSTALL_LIBDIR=lib64 \
+    -DWITH_ZLIB=ON \
+    -DBUILD_ZLIB=ON \
+    -DWITH_JPEG=ON \
+    -DBUILD_JPEG=ON \
+    -DWITH_PNG=ON \
+    -DBUILD_PNG=ON \
+    -DWITH_TIFF=ON \
+    -DBUILD_TIFF=ON
+
+make -j
+make install
+```
+
+* 执行完成上述命令后，会生成 opencv 头文件和库文件，用于后面的 PaddleClas 代码编译。
+
+以 opencv3.4.7 版本为例，最终在安装路径下的文件结构如下所示。**注意**：不同的 opencv 版本，下述的文件结构可能不同。
+
+```
+opencv3/
+|-- bin
+|-- include
+|-- lib64
+|-- share
+```
+
+### 1.2 获取 Paddle 预测库
+
+* 有 2 种方式获取 Paddle 预测库，下面进行详细介绍。
+
+#### 1.2.1 预测库源码编译
+如果希望获取最新预测库特性，可以从 GitHub 上克隆 Paddle 最新代码，从源码编译预测库。对于不同平台的编译流程，请参考[Paddle预测库官网](https://paddleinference.paddlepaddle.org.cn/v2.1/user_guides/source_compile.html)的说明。编译示例如下：
+
+1. 使用Git获取源代码：
+
+```shell
+git clone https://github.com/PaddlePaddle/Paddle.git
+cd Paddle
+```
+
+2. 进入 `Paddle` 目录后，开始进行编译：
+
+```shell
+rm -rf build
+mkdir build
+cd build
+
+cmake  .. \
+    -DWITH_CONTRIB=OFF \
+    -DWITH_MKL=ON \
+    -DWITH_MKLDNN=ON  \
+    -DWITH_TESTING=OFF \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DWITH_INFERENCE_API_TEST=OFF \
+    -DON_INFER=ON \
+    -DWITH_PYTHON=ON
+make -j
+make inference_lib_dist
+```
+
+关于编译参数选项可以参考 Paddle C++ 预测库官网：[编译选项表](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/install/Tables.html#bianyixuanxiangbiao)。
+
+
+3. 编译完成之后，可以在 `./build/paddle_inference_install_dir/` 文件下看到以下文件及目录：
+
+```
+build/paddle_inference_install_dir/
+|-- CMakeCache.txt
+|-- paddle
+|-- third_party
+|-- version.txt
+```
+
+#### 1.2.2 直接下载安装
+
+[Paddle预测库官网](https://paddleinference.paddlepaddle.org.cn/v2.1/user_guides/download_lib.html#c) 上提供了不同版本的 Paddle 预测库，包括多个操作系统平台和GPU、CPU等多个硬件平台的预编译库，可以在官网查找并选择合适的预测库版本进行下载，建议选择 `2.1.1` 版本。
+
+**注意**：在选择预测库时，所选预测库版本需要与后续编译选项一致：
+* CPU 预测库仅可用于 GPU 预测，具体又分为 `mkl` 和 `openblas`，分别对应其低层实现基于 `MKL` 数学运算库 和 `OpenBLAS` 数学运算库；
+* GPU 预测库支持 GPU 预测和 CPU 预测，其 GPU 预测功能底层实现基于 CUDA、cuDNN，CPU 预测功能底层基于 `MKL` 实现。
+
+以 `manylinux_cuda10.2_cudnn8.1_avx_mkl_trt7_gcc8.2` 的 `2.1.1` 版本为例，可使用下述命令下载并解压：
+
+```shell
+wget https://paddle-inference-lib.bj.bcebos.com/2.1.1-gpu-cuda10.2-cudnn8.1-mkl-gcc8.2/paddle_inference.tgz
+tar -xf paddle_inference.tgz
+```
+
+上述命令会在当前目录下生成 `paddle_inference/` 目录。
+
+## 2. 开始编译
+
+<a name="2.1"></a>
+
+### 2.1 编译 PaddleClas C++ 预测 demo
+
+编译命令如下，其中 Paddle C++ 预测库、OpenCV 等依赖库的路径需要根据机器上的实际位置进行修改。
+
+```shell
+sh tools/build_demo.sh
+```
+
+具体地，`tools/build_demo.sh`中内容如下：
+
+```shell
+OpenCV_DIR=path/to/opencv
+PADDLE_LIB_DIR=path/to/paddle
+CUDA_LIB_DIR=path/to/cuda
+CUDNN_LIB_DIR=path/to/cudnn
+TENSORRT_LIB_DIR=path/to/tensorrt
+CONFIG_LIB_PATH=path/to/config/library
+CLS_LIB_PATH=path/to/cls/library
+CMP_STATIC=ON
+
+BUILD_DIR=build
+rm -rf ${BUILD_DIR}
+mkdir ${BUILD_DIR}
+cd ${BUILD_DIR}
+cmake .. \
+    -DWITH_MKL=ON \
+    -DWITH_GPU=ON \
+    -DWITH_TENSORRT=OFF \
+    -DWITH_STATIC_LIB=OFF \
+    -DOpenCV_DIR=${OpenCV_DIR} \
+    -DPADDLE_LIB=${PADDLE_LIB_DIR} \
+    -DCUDA_LIB=${CUDA_LIB_DIR} \
+    -DCUDNN_LIB=${CUDNN_LIB_DIR} \
+    -DCONFIG_LIB=${CONFIG_LIB_PATH} \
+    -DCLS_LIB=${CLS_LIB_PATH} \
+    -DCMP_STATIC=OFF \
+
+make -j
+```
+
+上述命令中，各个编译选项的具体说明如下：
+* `DWITH_MKL`：是否使用 MKL 数学运算库，默认为 `ON`，注意需要与下载的预测库版本一致。如为 `OpenBLAS` 版本预测库，则需设置为 `OFF`；
+* `DWITH_GPU`：使用使用 GPU 预测库，默认为 `OFF`，当下载预测库版本为 GPU 预测库时，可置为 `ON`，同时请设置 `DCUDA_LIB` 与 `DCUDNN_LIB`，否则请设置为 `OFF`；
+* `DWITH_TENSORRT`：是否使用 TensorRT，默认为 `OFF`，当 `DWITH_GPU` 设置为 `ON` 时有效，同时请设置 `DTENSORRT_LIB`；
+* `DWITH_STATIC_LIB`：是否使用 Paddle 预测库中的静态链接库，默认为 `OFF`；
+* `DOpenCV_DIR`：OpenCV 编译库的路径，本例中为 `opencv-3.4.7/opencv3/share/OpenCV`，注意该路径下需要有 `OpenCVConfig.cmake` 文件；
+* `DPADDLE_LIB`：Paddle 预测库路径，一般使用下载并解压的预编译库路径 `paddle_inference` 即可，或编译生成的预测库的路径 `build/paddle_inference_install_dir`，注意该路径下需要有 `paddle` 和 `third_party` 两个子路径；
+* `DCUDA_LIB`：CUDA 库路径，当 `DWITH_GPU` 设置为 `ON` 时有效，在 docker 中通常为 `/usr/local/cuda/lib64`；
+* `DCUDNN_LIB`：cuDNN 库路径，当 `DWITH_GPU` 设置为 `ON` 时有效，在 docker 中通常为 `/usr/lib/x86_64-linux-gnu/`；
+* `DTENSORRT_LIB`：TensorRT 库路径，当 `DWITH_GPU` 与 `DUSE_TENSORRT` 均设置为 `ON` 时有效，在 dokcer 中通常为 `/usr/local/TensorRT6-cuda10.0-cudnn7/`；
+* `DCONFIG_LIB`：如需使用已编译好的 `config lib`，请设置为 `config lib` 的路径，否则请删除该选项；
+* `DCLS_LIB`：如需使用已编译好的 `cls lib`，请设置为 `cls lib` 的路径，否则请删除该选项；
+* `DCMP_STATIC`：是否将 `config lib` 和 `cls lib` 编译为静态链接库，默认为 `ON`，如需编译为动态链接库，请设置为 `OFF`。
+
+在执行上述命令，编译完成之后，会在当前路径下生成 `build` 目录，其中有可执行文件 `clas_system`。并且，如未设置 `DCONFIG_LIB` 与 `DCLS_LIB`，则会在 `.\lib\` 路径下生成 `config lib` 和 `cls lib` 两个库文件，根据 `DCMP_STATIC` 的设置，两个库文件将被编译为静态链接库（`libconfig.a`、`libcls.a`）或动态链接库（`libconfig.so`、`libcls.so`）。
+
+### 2.2 编译 config lib 预测库与 cls lib 预测库
+
+除了可以直接编译 demo，也同样可以仅编译 config lib 和 cls lib 预测库，只需运行如下命令：
+
+```shell
+sh tools/build_lib.sh
+```
+
+具体地，`tools/build_lib.sh`中内容如下：
+
+```shell
+OpenCV_DIR=path/to/opencv
+PADDLE_LIB_DIR=path/to/paddle
+
+BUILD_DIR=./lib/build
+rm -rf ${BUILD_DIR}
+mkdir ${BUILD_DIR}
+cd ${BUILD_DIR}
+cmake .. \
+    -DOpenCV_DIR=${OpenCV_DIR} \
+    -DPADDLE_LIB=${PADDLE_LIB_DIR} \
+    -DCMP_STATIC=ON \
+
+make
+```
+
+上述命令中，各个编译选项的具体说明如下：
+* `DOpenCV_DIR`：OpenCV 编译库的路径，本例中为 `opencv-3.4.7/opencv3/share/OpenCV`，注意该路径下需要有 `OpenCVConfig.cmake` 文件；
+* `DPADDLE_LIB`：Paddle 预测库路径，一般使用下载并解压的预编译库路径 `paddle_inference` 即可，或编译生成的预测库的路径 `build/paddle_inference_install_dir`，注意该路径下需要有 `paddle` 和 `third_party` 两个子路径；
+* `DCMP_STATIC`：是否将 `config lib` 和 `cls lib` 编译为静态链接库（`.a`），默认为 `ON`，如需编译为动态链接库（`.so`），请设置为 `OFF`。
+
+执行上述命令后，将在目录 `./lib/` 下生成 `config lib` 和 `cls lib` 的动态链接库（`libcls.so` 和 `libconfig.so`）或静态链接库（`libcls.a` 和 `libconfig.a`）。在[编译 PaddleClas C++ 预测 demo](#2.1)中，可以通过指定编译选项 `DCLS_LIB` 和 `DCONFIG_LIB` 指定已有链接库的路径，链接库同样也可用于二次开发。
+
+## 3. 运行 demo
+
+### 3.1 准备 inference model
+
+首先需要准备 inference model，关于将模型导出为 inference model 的具体步骤，可以参考[模型导出](../../docs/zh_CN/tutorials/getting_started.md#4-使用inference模型进行模型推理)文档。假设导出的预测模型文件放在`./inference`目录下，则目录结构如下。
+
+```
+inference/
+|--inference.pdmodel
+|--inference.pdiparams
+```
+
+**注意**：上述文件中，`cls_infer.pdmodel` 文件存储了模型网络结构信息，`cls_infer.pdiparams` 文件存储了模型参数权重信息。在运行预测时，注意两个文件的路径需要分别设置为配置文件 `tools/config.txt` 中的字段 `cls_model_path` 和 `cls_params_path` 的值。
+
+### 3.2 运行 demo
+
+首先修改 `tools/config.txt` 中对应字段：
+* use_gpu：是否使用GPU；
+* gpu_id：使用的GPU卡号；
+* gpu_mem：显存；
+* cpu_math_library_num_threads：底层科学计算库所用线程的数量；
+* use_mkldnn：是否使用MKLDNN加速；
+* use_tensorrt: 是否使用tensorRT进行加速；
+* use_fp16：是否使用半精度浮点数进行计算，该选项仅在use_tensorrt为true时有效；
+* cls_model_path：预测模型结构文件路径；
+* cls_params_path：预测模型参数文件路径；
+* resize_short_size：预处理时图像缩放大小；
+* crop_size：预处理时图像裁剪后的大小。
+
+然后修改`tools/run.sh`：
+  * `./build/clas_system ./tools/config.txt ./docs/imgs/ILSVRC2012_val_00000666.JPEG`
+  * 上述命令中分别为：编译得到的可执行文件 `clas_system`；运行时的配置文件 `config.txt`；待预测的图像。
+
+* 最后执行以下命令，完成对一幅图像的分类。
+
+```shell
+sh tools/run.sh
+```
+
+* 最终屏幕上会输出结果，如下图所示。
+
+<div align="center">
+    <img src="./docs/imgs/cpp_infer_result.png" width="600">
+</div>
+
+其中`class id`表示置信度最高的类别对应的id，score表示图片属于该类别的概率。

docs/zh_CN_tmp/inference_deployment/export_model.md

+# 模型导出
+
+PaddlePaddle 支持导出 inference 模型用于部署推理场景，相比于训练调优场景，inference 模型会将网络权重与网络结构进行持久化存储，并且 PaddlePaddle 支持使用预测引擎加载 inference 模型进行预测推理。
+
+---
+
+## 1. 环境准备
+
+首先请参考文档[安装PaddlePaddle](../installation/install_paddle.md)和文档[安装PaddleClas](../installation/install_paddleclas.md)配置运行环境。
+
+## 2. 分类模型导出
+
+进入 PaddleClas 目录下：
+
+```shell
+cd /path/to/PaddleClas
+```
+
+以 ResNet50_vd 分类模型为例，下载预训练模型：
+
+```shell
+wget -P ./cls_pretrain/ https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/legendary_models/ResNet50_vd_pretrained.pdparams
+```
+
+上述模型是使用 ResNet50_vd 在 ImageNet 上训练的模型，使用的配置文件为 `ppcls/configs/ImageNet/ResNet/ResNet50_vd.yaml`，将该模型转为 inference 模型只需运行如下命令：
+
+```shell
+python tools/export_model.py \
+    -c ./ppcls/configs/ImageNet/ResNet/ResNet50_vd.yaml \
+    -o Global.pretrained_model=./cls_pretrain/ResNet50_vd_pretrained \
+    -o Global.save_inference_dir=./deploy/models/class_ResNet50_vd_ImageNet_infer
+```
+
+## 3. 识别模型导出
+
+进入 PaddleClas 目录下：
+
+```shell
+cd /path/to/PaddleClas
+```
+
+以商品识别特征提取模型为例，下载预训练模型：
+
+```shell
+wget -P ./product_pretrain/ https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/pretrain/product_ResNet50_vd_Aliproduct_v1.0_pretrained.pdparams
+```
+
+上述模型是 ResNet50_vd 在 AliProduct 上训练的模型，训练使用的配置文件为 `ppcls/configs/Products/ResNet50_vd_Aliproduct.yaml`，将该模型转为 inference 模型只需运行如下命令：
+
+```shell
+python3 tools/export_model.py \
+    -c ./ppcls/configs/Products/ResNet50_vd_Aliproduct.yaml \
+    -o Global.pretrained_model=./product_pretrain/product_ResNet50_vd_Aliproduct_v1.0_pretrained \
+    -o Global.save_inference_dir=./deploy/models/product_ResNet50_vd_aliproduct_v1.0_infer
+```
+
+注意，此处保存的 inference 模型在 embedding 特征层做了截断，即导出后模型最终的输出为 n 维 embedding 特征。
+
+## 4. 命令参数说明
+
+在上述模型导出命令中，所使用的配置文件需要与该模型的训练文件相同，在配置文件中有以下字段用于配置模型导出参数：
+
+* `Global.image_shape`：用于指定模型的输入数据尺寸，该尺寸不包含 batch 维度；
+* `Global.save_inference_dir`：用于指定导出的 inference 模型的保存位置；
+* `Global.pretrained_model`：用于指定训练过程中保存的模型权重文件路径，该路径无需包含模型权重文件后缀名 `.pdparams`。。
+
+上述命令将生成以下三个文件：
+
+* `inference.pdmodel`：用于存储网络结构信息；
+* `inference.pdiparams`：用于存储网络权重信息；
+* `inference.pdiparams.info`：用于存储模型的参数信息，在分类模型和识别模型中可忽略。
+
+导出的 inference 模型文件可用于预测引擎进行推理部署，根据不同的部署方式/平台，可参考：
+
+* [Python 预测](./python_deploy.md)
+* [C++ 预测](./cpp_deploy.md)（目前仅支持分类模型）
+* [Python Whl 预测](./whl_deploy.md)（目前仅支持分类模型）
+* [PaddleHub Serving 部署](./paddle_hub_serving_deploy.md)（目前仅支持分类模型）
+* [PaddleServing 部署](./paddle_serving_deploy.md)（目前仅支持分类模型）
+* [PaddleLite 部署](./paddle_lite_deploy.md)（目前仅支持分类模型）

docs/zh_CN_tmp/inference_deployment/paddle_hub_serving_deploy.md

+# 基于PaddleHub Serving的服务部署
+
+PaddleClas 支持通过 PaddleHub 快速进行服务化部署。
+
+---
+
+## 1. 简介
+
+hubserving 服务部署配置服务包 `clas` 下包含 3 个必选文件，目录如下：
+
+```
+hubserving/clas/
+  └─  __init__.py    空文件，必选
+  └─  config.json    配置文件，可选，使用配置启动服务时作为参数传入
+  └─  module.py      主模块，必选，包含服务的完整逻辑
+  └─  params.py      参数文件，必选，包含模型路径、前后处理参数等参数
+```
+
+## 2. 准备环境
+```shell
+# 安装paddlehub,请安装2.0版本
+pip3 install paddlehub==2.1.0 --upgrade -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+## 3. 下载推理模型
+
+安装服务模块前，需要准备推理模型并放到正确路径，默认模型路径为：
+
+* 分类推理模型结构文件：`PaddleClas/inference/inference.pdmodel`
+* 分类推理模型权重文件：`PaddleClas/inference/inference.pdiparams`
+
+**注意**：
+* 模型文件路径可在 `PaddleClas/deploy/hubserving/clas/params.py` 中查看和修改：
+
+  ```python
+  "inference_model_dir": "../inference/"
+  ```
+需要注意，
+  * 模型文件（包括 `.pdmodel` 与 `.pdiparams`）名称必须为`inference`。
+  * 我们也提供了大量基于ImageNet-1k数据集的预训练模型，模型列表及下载地址详见[模型库概览](../../docs/zh_CN/models/models_intro.md)，也可以使用自己训练转换好的模型。
+
+## 4. 安装服务模块
+
+针对 Linux 环境和 Windows 环境，安装命令如下。
+
+* 在Linux环境下，安装示例如下：
+```shell
+cd PaddleClas/deploy
+# 安装服务模块：
+hub install hubserving/clas/
+```
+
+* 在Windows环境下(文件夹的分隔符为`\`)，安装示例如下：
+
+```shell
+cd PaddleClas\deploy
+# 安装服务模块：  
+hub install hubserving\clas\
+```
+
+## 5. 启动服务
+
+### 5.1 命令行命令启动
+
+该方式仅支持使用 CPU 预测。启动命令：
+
+```shell
+$ hub serving start --modules Module1==Version1 \
+                    --port XXXX \
+                    --use_multiprocess \
+                    --workers \
+```  
+
+**参数说明**：
+|参数|用途|  
+|-|-|  
+|--modules/-m| [**必选**] PaddleHub Serving预安装模型，以多个Module==Version键值对的形式列出<br>*`当不指定Version时，默认选择最新版本`*|  
+|--port/-p| [**可选**] 服务端口，默认为8866|  
+|--use_multiprocess| [**可选**] 是否启用并发方式，默认为单进程方式，推荐多核CPU机器使用此方式<br>*`Windows操作系统只支持单进程方式`*|
+|--workers| [**可选**] 在并发方式下指定的并发任务数，默认为`2*cpu_count-1`，其中`cpu_count`为CPU核数|  
+
+如按默认参数启动服务：```hub serving start -m clas_system```  
+
+这样就完成了一个服务化 API 的部署，使用默认端口号 8866。
+
+### 5.2 配置文件启动
+
+该方式仅支持使用 CPU 或 GPU 预测。启动命令：
+
+```hub serving start -c config.json```  
+
+其中，`config.json`格式如下：
+
+```json
+{
+    "modules_info": {
+        "clas_system": {
+            "init_args": {
+                "version": "1.0.0",
+                "use_gpu": true,
+                "enable_mkldnn": false
+            },
+            "predict_args": {
+            }
+        }
+    },
+    "port": 8866,
+    "use_multiprocess": false,
+    "workers": 2
+}
+```
+
+**参数说明**：
+* `init_args`中的可配参数与`module.py`中的`_initialize`函数接口一致。其中，
+  - 当`use_gpu`为`true`时，表示使用GPU启动服务。
+  - 当`enable_mkldnn`为`true`时，表示使用MKL-DNN加速。
+* `predict_args`中的可配参数与`module.py`中的`predict`函数接口一致。
+
+**注意**：
+* 使用配置文件启动服务时，将使用配置文件中的参数设置，其他命令行参数将被忽略；
+* 如果使用 GPU 预测(即，`use_gpu`置为`true`)，则需要在启动服务之前，设置 `CUDA_VISIBLE_DEVICES` 环境变量来指定所使用的 GPU 卡号，如：`export CUDA_VISIBLE_DEVICES=0`；
+* **`use_gpu` 不可与 `use_multiprocess` 同时为 `true`**；
+* **`use_gpu` 与 `enable_mkldnn` 同时为 `true` 时，将忽略 `enable_mkldnn`，而使用 GPU**。
+
+如使用 GPU 3号卡启动服务：
+
+```shell
+cd PaddleClas/deploy
+export CUDA_VISIBLE_DEVICES=3
+hub serving start -c hubserving/clas/config.json
+```
+
+## 6. 发送预测请求
+
+配置好服务端后，可使用以下命令发送预测请求，获取预测结果：
+
+```shell
+cd PaddleClas/deploy
+python hubserving/test_hubserving.py server_url image_path
+```  
+
+**脚本参数说明**：
+* **server_url**：服务地址，格式为  
+`http://[ip_address]:[port]/predict/[module_name]`  
+* **image_path**：测试图像路径，可以是单张图片路径，也可以是图像集合目录路径。
+* **batch_size**：[**可选**] 以`batch_size`大小为单位进行预测，默认为`1`。
+* **resize_short**：[**可选**] 预处理时，按短边调整大小，默认为`256`。
+* **crop_size**：[**可选**] 预处理时，居中裁剪的大小，默认为`224`。
+* **normalize**：[**可选**] 预处理时，是否进行`normalize`，默认为`True`。
+* **to_chw**：[**可选**] 预处理时，是否调整为`CHW`顺序，默认为`True`。
+
+**注意**：如果使用`Transformer`系列模型，如`DeiT_***_384`, `ViT_***_384`等，请注意模型的输入数据尺寸，需要指定`--resize_short=384 --crop_size=384`。
+
+访问示例：
+
+```shell
+python hubserving/test_hubserving.py --server_url http://127.0.0.1:8866/predict/clas_system --image_file ./hubserving/ILSVRC2012_val_00006666.JPEG --batch_size 8
+```
+
+**返回结果格式说明**：
+返回结果为列表（list），包含 top-k 个分类结果，以及对应的得分，还有此图片预测耗时，具体如下：
+```
+list: 返回结果
+└─ list: 第一张图片结果
+   └─ list: 前k个分类结果，依score递减排序
+   └─ list: 前k个分类结果对应的score，依score递减排序
+   └─ float: 该图分类耗时，单位秒
+```
+
+## 7. 自定义修改服务模块
+
+如果需要修改服务逻辑，需要进行以下操作：  
+
+1. 停止服务  
+```hub serving stop --port/-p XXXX```  
+
+2. 到相应的`module.py`和`params.py`等文件中根据实际需求修改代码。`module.py`修改后需要重新安装（`hub install hubserving/clas/`）并部署。在进行部署前，可通过`python hubserving/clas/module.py`测试已安装服务模块。
+
+3. 卸载旧服务包  
+```hub uninstall clas_system```  
+
+4. 安装修改后的新服务包  
+```hub install hubserving/clas/```  
+
+5.重新启动服务  
+```hub serving start -m clas_system```  
+
+**注意**：
+常用参数可在 [params.py](./clas/params.py) 中修改：
+  * 更换模型，需要修改模型文件路径参数:
+    ```python
+    "inference_model_dir":
+    ```
+  * 更改后处理时返回的`top-k`结果数量：
+    ```python
+    'topk':
+    ```
+  * 更改后处理时的lable与class id对应映射文件：
+    ```python
+    'class_id_map_file':
+    ```
+
+为了避免不必要的延时以及能够以 batch_size 进行预测，数据预处理逻辑（包括 `resize`、`crop` 等操作）均在客户端完成，因此需要在 [test_hubserving.py](./test_hubserving.py#L35-L52) 中修改。

docs/zh_CN_tmp/inference_deployment/paddle_lite_deploy.md

+# PaddleLite推理部署
+
+本教程将介绍基于[Paddle Lite](https://github.com/PaddlePaddle/Paddle-Lite)在移动端部署 PaddleClas 分类模型的详细步骤。
+
+Paddle Lite是飞桨轻量化推理引擎，为手机、IOT端提供高效推理能力，并广泛整合跨平台硬件，为端侧部署及应用落地问题提供轻量化的部署方案。如果希望直接测试速度，可以参考[Paddle-Lite移动端benchmark测试教程](../../docs/zh_CN/extension/paddle_mobile_inference.md)。
+
+---
+
+## 1. 准备环境
+
+Paddle Lite 目前支持以下平台部署：
+* 电脑（编译Paddle Lite）
+* 安卓手机（armv7或armv8）
+
+### 1.1 准备交叉编译环境
+
+交叉编译环境用于编译 Paddle Lite 和 PaddleClas 的 C++ demo。
+支持多种开发环境，不同开发环境的编译流程请参考对应文档。
+
+1. [Docker](https://paddle-lite.readthedocs.io/zh/latest/source_compile/compile_env.html#docker)
+2. [Linux](https://paddle-lite.readthedocs.io/zh/latest/source_compile/compile_env.html#linux)
+3. [MAC OS](https://paddle-lite.readthedocs.io/zh/latest/source_compile/compile_env.html#mac-os)
+
+### 1.2 准备预测库
+
+预测库有两种获取方式：
+1. [建议]直接下载，预测库下载链接如下：
+      |平台|预测库下载链接|
+      |-|-|
+      |Android|[arm7](https://paddlelite-data.bj.bcebos.com/Release/2.8-rc/Android/gcc/inference_lite_lib.android.armv7.gcc.c++_static.with_extra.with_cv.tar.gz) / [arm8](https://paddlelite-data.bj.bcebos.com/Release/2.8-rc/Android/gcc/inference_lite_lib.android.armv8.gcc.c++_static.with_extra.with_cv.tar.gz)|
+      |iOS|[arm7](https://paddlelite-data.bj.bcebos.com/Release/2.8-rc/iOS/inference_lite_lib.ios.armv7.with_cv.with_extra.tiny_publish.tar.gz) / [arm8](https://paddlelite-data.bj.bcebos.com/Release/2.8-rc/iOS/inference_lite_lib.ios.armv8.with_cv.with_extra.tiny_publish.tar.gz)|
+
+      **注**：
+      1. 如果是从 Paddle-Lite [官方文档](https://paddle-lite.readthedocs.io/zh/latest/quick_start/release_lib.html#android-toolchain-gcc)下载的预测库，
+      注意选择 `with_extra=ON，with_cv=ON` 的下载链接。
+      2. 如果使用量化的模型部署在端侧，建议使用 Paddle-Lite develop 分支编译预测库。
+
+2. 编译 Paddle-Lite 得到预测库，Paddle-Lite 的编译方式如下：
+
+```shell
+git clone https://github.com/PaddlePaddle/Paddle-Lite.git
+cd Paddle-Lite
+# 如果使用编译方式，建议使用develop分支编译预测库
+git checkout develop
+./lite/tools/build_android.sh  --arch=armv8  --with_cv=ON --with_extra=ON
+```
+
+**注意**：编译Paddle-Lite获得预测库时，需要打开`--with_cv=ON --with_extra=ON`两个选项，`--arch`表示`arm`版本，这里指定为armv8，更多编译命令介绍请参考[链接](https://paddle-lite.readthedocs.io/zh/latest/user_guides/Compile/Android.html#id2)。
+
+直接下载预测库并解压后，可以得到`inference_lite_lib.android.armv8/`文件夹，通过编译Paddle-Lite得到的预测库位于`Paddle-Lite/build.lite.android.armv8.gcc/inference_lite_lib.android.armv8/`文件夹下。
+预测库的文件目录如下：
+
+```
+inference_lite_lib.android.armv8/
+|-- cxx                                        C++ 预测库和头文件
+|   |-- include                                C++ 头文件
+|   |   |-- paddle_api.h
+|   |   |-- paddle_image_preprocess.h
+|   |   |-- paddle_lite_factory_helper.h
+|   |   |-- paddle_place.h
+|   |   |-- paddle_use_kernels.h
+|   |   |-- paddle_use_ops.h
+|   |   `-- paddle_use_passes.h
+|   `-- lib                                           C++预测库
+|       |-- libpaddle_api_light_bundled.a             C++静态库
+|       `-- libpaddle_light_api_shared.so             C++动态库
+|-- java                                     Java预测库
+|   |-- jar
+|   |   `-- PaddlePredictor.jar
+|   |-- so
+|   |   `-- libpaddle_lite_jni.so
+|   `-- src
+|-- demo                                     C++和Java示例代码
+|   |-- cxx                                  C++  预测库demo
+|   `-- java                                 Java 预测库demo
+```
+
+## 2. 开始运行
+
+### 2.1 模型优化
+
+Paddle-Lite 提供了多种策略来自动优化原始的模型，其中包括量化、子图融合、混合精度、Kernel 优选等方法，使用 Paddle-Lite 的 `opt` 工具可以自动对 inference 模型进行优化，目前支持两种优化方式，优化后的模型更轻量，模型运行速度更快。在进行模型优化前，需要先准备 `opt` 优化工具，有以下两种方式。
+
+**注意**：如果已经准备好了 `.nb` 结尾的模型文件，可以跳过此步骤。
+#### 2.1.1 [建议]pip安装paddlelite并进行转换
+
+Python下安装 `paddlelite`，目前最高支持 `Python3.7`。
+**注意**：`paddlelite` whl包版本必须和预测库版本对应。
+
+```shell
+pip install paddlelite==2.8
+```
+
+之后使用 `paddle_lite_opt` 工具可以进行 inference 模型的转换。`paddle_lite_opt` 的部分参数如下
+
+|选项|说明|
+|-|-|
+|--model_dir|待优化的PaddlePaddle模型（非combined形式）的路径|
+|--model_file|待优化的PaddlePaddle模型（combined形式）的网络结构文件路径|
+|--param_file|待优化的PaddlePaddle模型（combined形式）的权重文件路径|
+|--optimize_out_type|输出模型类型，目前支持两种类型：protobuf和naive_buffer，其中naive_buffer是一种更轻量级的序列化/反序列化实现。若您需要在mobile端执行模型预测，请将此选项设置为naive_buffer。默认为protobuf|
+|--optimize_out|优化模型的输出路径|
+|--valid_targets|指定模型可执行的backend，默认为arm。目前可支持x86、arm、opencl、npu、xpu，可以同时指定多个backend(以空格分隔)，Model Optimize Tool将会自动选择最佳方式。如果需要支持华为NPU（Kirin 810/990 Soc搭载的达芬奇架构NPU），应当设置为npu, arm|
+|--record_tailoring_info|当使用 根据模型裁剪库文件 功能时，则设置该选项为true，以记录优化后模型含有的kernel和OP信息，默认为false|
+
+`--model_file` 表示 inference 模型的 model 文件地址，`--param_file` 表示 inference 模型的 param 文件地址；`optimize_out` 用于指定输出文件的名称（不需要添加 `.nb` 的后缀）。直接在命令行中运行 `paddle_lite_opt`，也可以查看所有参数及其说明。
+
+#### 2.1.2 源码编译Paddle-Lite生成opt工具
+
+模型优化需要 Paddle-Lite 的 `opt` 可执行文件，可以通过编译 Paddle-Lite 源码获得，编译步骤如下：
+
+```shell
+# 如果准备环境时已经clone了Paddle-Lite，则不用重新clone Paddle-Lite
+git clone https://github.com/PaddlePaddle/Paddle-Lite.git
+cd Paddle-Lite
+git checkout develop
+# 启动编译
+./lite/tools/build.sh build_optimize_tool
+```
+
+编译完成后，`opt` 文件位于 `build.opt/lite/api/` 下，可通过如下方式查看 `opt` 的运行选项和使用方式：
+
+```shell
+cd build.opt/lite/api/
+./opt
+```
+
+`opt` 的使用方式与参数与上面的 `paddle_lite_opt` 完全一致。
+
+<a name="2.1.3"></a>
+
+#### 2.1.3 转换示例
+
+下面以PaddleClas的 `MobileNetV3_large_x1_0` 模型为例，介绍使用 `paddle_lite_opt` 完成预训练模型到inference模型，再到 Paddle-Lite 优化模型的转换。
+
+```shell
+# 进入PaddleClas根目录
+cd PaddleClas_root_path
+
+# 下载并解压inference模型
+wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/inference/MobileNetV3_large_x1_0_infer.tar
+tar -xf MobileNetV3_large_x1_0_infer.tar
+
+# 将inference模型转化为Paddle-Lite优化模型
+paddle_lite_opt --model_file=./MobileNetV3_large_x1_0_infer/inference.pdmodel --param_file=./MobileNetV3_large_x1_0_infer/inference.pdiparams --optimize_out=./MobileNetV3_large_x1_0
+```
+
+最终在当前文件夹下生成 `MobileNetV3_large_x1_0.nb` 的文件。
+
+**注意**：`--optimize_out` 参数为优化后模型的保存路径，无需加后缀 `.nb`；`--model_file` 参数为模型结构信息文件的路径，`--param_file` 参数为模型权重信息文件的路径，请注意文件名。
+
+### 2.2 与手机联调
+
+首先需要进行一些准备工作。
+1. 准备一台 arm8 的安卓手机，如果编译的预测库和 opt 文件是 armv7，则需要 arm7 的手机，并修改 Makefile 中 `ARM_ABI = arm7`。
+2. 电脑上安装 ADB 工具，用于调试。 ADB安装方式如下：
+
+    * MAC电脑安装ADB:
+    ```shell
+    brew cask install android-platform-tools
+    ```
+    * Linux安装ADB
+    ```shell
+    sudo apt update
+    sudo apt install -y wget adb
+    ```
+    * Window安装ADB
+    win上安装需要去谷歌的安卓平台下载ADB软件包进行安装：[链接](https://developer.android.com/studio)
+
+3. 手机连接电脑后，开启手机 `USB调试` 选项，选择 `文件传输` 模式，在电脑终端中输入：
+
+```shell
+adb devices
+```
+如果有 device 输出，则表示安装成功，如下所示：
+```
+List of devices attached
+744be294    device
+```
+
+4. 准备优化后的模型、预测库文件、测试图像和类别映射文件。
+
+```shell
+cd PaddleClas_root_path
+cd deploy/lite/
+
+# 运行prepare.sh
+# prepare.sh 会将预测库文件、测试图像和使用的字典文件放置在预测库中的demo/cxx/clas文件夹下
+sh prepare.sh /{lite prediction library path}/inference_lite_lib.android.armv8
+
+# 进入lite demo的工作目录
+cd /{lite prediction library path}/inference_lite_lib.android.armv8/
+cd demo/cxx/clas/
+
+# 将C++预测动态库so文件复制到debug文件夹中
+cp ../../../cxx/lib/libpaddle_light_api_shared.so ./debug/
+```
+
+`prepare.sh` 以 `PaddleClas/deploy/lite/imgs/tabby_cat.jpg` 作为测试图像，将测试图像复制到 `demo/cxx/clas/debug/` 文件夹下。
+将 `paddle_lite_opt` 工具优化后的模型文件放置到 `/{lite prediction library path}/inference_lite_lib.android.armv8/demo/cxx/clas/debug/` 文件夹下。本例中，使用 [2.1.3](#2.1.3) 生成的 `MobileNetV3_large_x1_0.nb` 模型文件。
+
+执行完成后，clas 文件夹下将有如下文件格式：
+
+```
+demo/cxx/clas/
+|-- debug/
+|   |--MobileNetV3_large_x1_0.nb                优化后的分类器模型文件
+|   |--tabby_cat.jpg                               待测试图像
+|   |--imagenet1k_label_list.txt                类别映射文件
+|   |--libpaddle_light_api_shared.so    C++预测库文件
+|   |--config.txt                       分类预测超参数配置
+|-- config.txt                                  分类预测超参数配置
+|-- image_classfication.cpp                图像分类代码文件
+|-- Makefile                                    编译文件
+```
+
+#### 注意：
+* 上述文件中，`imagenet1k_label_list.txt` 是 ImageNet1k 数据集的类别映射文件，如果使用自定义的类别，需要更换该类别映射文件。
+
+*  `config.txt` 包含了分类器的超参数，如下：
+
+```shell
+clas_model_file ./MobileNetV3_large_x1_0.nb # 模型文件地址
+label_path ./imagenet1k_label_list.txt         # 类别映射文本文件
+resize_short_size 256                       # resize之后的短边边长
+crop_size 224                                 # 裁剪后用于预测的边长
+visualize 0       # 是否进行可视化，如果选择的话，会在当前文件夹下生成名为clas_result.png的图像文件。
+```
+
+5. 启动调试，上述步骤完成后就可以使用ADB将文件夹 `debug/` push 到手机上运行，步骤如下：
+
+```shell
+# 执行编译，得到可执行文件clas_system
+make -j
+
+# 将编译得到的可执行文件移动到debug文件夹中
+mv clas_system ./debug/
+
+# 将上述debug文件夹push到手机上
+adb push debug /data/local/tmp/
+
+adb shell
+cd /data/local/tmp/debug
+export LD_LIBRARY_PATH=/data/local/tmp/debug:$LD_LIBRARY_PATH
+
+# clas_system可执行文件的使用方式为:
+# ./clas_system 配置文件路径  测试图像路径
+./clas_system ./config.txt ./tabby_cat.jpg
+```
+
+如果对代码做了修改，则需要重新编译并 push 到手机上。
+
+运行效果如下：
+
+<div align="center">
+    <img src="./imgs/lite_demo_result.png" width="600">
+</div>
+
+## FAQ
+Q1：如果想更换模型怎么办，需要重新按照流程走一遍吗？  
+A1：如果已经走通了上述步骤，更换模型只需要替换 `.nb` 模型文件即可，同时要注意修改下配置文件中的 `.nb` 文件路径以及类别映射文件（如有必要）。
+
+Q2：换一个图测试怎么做？  
+A2：替换 debug 下的测试图像为你想要测试的图像，使用 ADB 再次 push 到手机上即可。

docs/zh_CN_tmp/inference_deployment/paddle_serving_deploy.md

+# 模型服务化部署
+
+## 1. 简介
+[Paddle Serving](https://github.com/PaddlePaddle/Serving) 旨在帮助深度学习开发者轻松部署在线预测服务，支持一键部署工业级的服务能力、客户端和服务端之间高并发和高效通信、并支持多种编程语言开发客户端。
+
+该部分以 HTTP 预测服务部署为例，介绍怎样在 PaddleClas 中使用 PaddleServing 部署模型服务。
+
+
+## 2. Serving安装
+
+Serving 官网推荐使用 docker 安装并部署 Serving 环境。首先需要拉取 docker 环境并创建基于 Serving 的 docker。
+
+```shell
+nvidia-docker pull hub.baidubce.com/paddlepaddle/serving:0.2.0-gpu
+nvidia-docker run -p 9292:9292 --name test -dit hub.baidubce.com/paddlepaddle/serving:0.2.0-gpu
+nvidia-docker exec -it test bash
+```
+
+进入 docker 后，需要安装 Serving 相关的 python 包。
+
+```shell
+pip install paddlepaddle-gpu
+pip install paddle-serving-client
+pip install paddle-serving-server-gpu
+```
+
+* 如果安装速度太慢，可以通过 `-i https://pypi.tuna.tsinghua.edu.cn/simple` 更换源，加速安装过程。
+
+* 如果希望部署 CPU 服务，可以安装 serving-server 的 cpu 版本，安装命令如下。
+
+```shell
+pip install paddle-serving-server
+```
+
+## 3. 导出模型
+
+使用 `tools/export_serving_model.py` 脚本导出 Serving 模型，以 `ResNet50_vd` 为例，使用方法如下。
+
+```shell
+python tools/export_serving_model.py -m ResNet50_vd -p ./pretrained/ResNet50_vd_pretrained/ -o serving
+```
+
+最终在 serving 文件夹下会生成 `ppcls_client_conf` 与 `ppcls_model` 两个文件夹，分别存储了 client 配置、模型参数与结构文件。
+
+
+## 4. 服务部署与请求
+
+* 使用下面的方式启动 Serving 服务。
+
+```shell
+python tools/serving/image_service_gpu.py serving/ppcls_model workdir 9292
+```
+
+其中 `serving/ppcls_model` 为刚才保存的 Serving 模型地址，`workdir` 为工作目录，`9292` 为服务的端口号。
+
+
+* 使用下面的脚本向 Serving 服务发送识别请求，并返回结果。
+
+```
+python tools/serving/image_http_client.py  9292 ./docs/images/logo.png
+```
+
+`9292` 为发送请求的端口号，需要与服务启动时的端口号保持一致，`./docs/images/logo.png` 为待识别的图像文件。最终返回 Top1 识别结果的类别 ID 以及概率值。
+
+* 更多的服务部署类型，如 `RPC预测服务` 等，可以参考 Serving 的 github 官网：[https://github.com/PaddlePaddle/Serving/tree/develop/python/examples/imagenet](https://github.com/PaddlePaddle/Serving/tree/develop/python/examples/imagenet)

docs/zh_CN_tmp/inference_deployment/python_deploy.md

+# Python 预测推理
+
+---
+
+首先请参考文档[安装PaddlePaddle](../installation/install_paddle.md)和文档[安装PaddleClas](../installation/install_paddleclas.md)配置运行环境。
+
+## 1. 图像分类推理
+
+首先请参考文档[模型导出](./export_model.md)准备 inference 模型，然后进入 PaddleClas 的 `deploy` 目录下：
+
+```shell
+cd /path/to/PaddleClas/deploy
+```
+
+使用以下命令进行预测：
+
+```shell
+python python/predict_cls.py -c configs/inference_cls.yaml
+```
+
+在配置文件 `configs/inference_cls.yaml` 中有以下字段用于配置预测参数：
+* `Global.infer_imgs`：待预测的图片文件路径；
+* `Global.inference_model_dir`：inference 模型文件所在目录，该目录下需要有文件 `inference.pdmodel` 和 `inference.pdiparams` 两个文件；
+* `Global.use_tensorrt`：是否使用 TesorRT 预测引擎，默认为 `False`；
+* `Global.use_gpu`：是否使用 GPU 预测，默认为 `True`；
+* `Global.enable_mkldnn`：是否启用 `MKL-DNN` 加速库，默认为 `False`。注意 `enable_mkldnn` 与 `use_gpu` 同时为 `True` 时，将忽略 `enable_mkldnn`，而使用 GPU 预测；
+* `Global.use_fp16`：是否启用 `FP16` ，默认为 `False`；
+* `PreProcess`：用于数据预处理配置；
+* `PostProcess`：由于后处理配置；
+* `PostProcess.Topk.class_id_map_file`：数据集 label 的映射文件，默认为 `./utils/imagenet1k_label_list.txt`，该文件为 PaddleClas 所使用的 ImageNet 数据集 label 映射文件。
+
+**注意**:
+* 如果使用 VisionTransformer 系列模型，如 `DeiT_***_384`, `ViT_***_384` 等，请注意模型的输入数据尺寸，部分模型需要修改参数： `PreProcess.resize_short=384`, `PreProcess.resize=384`。
+* 如果你希望提升评测模型速度，使用gpu评测时，建议开启TensorRT加速预测，使用cpu评测时，建议开启MKL-DNN加速预测。
+
+## 2. 主体检测模型推理
+
+进入 PaddleClas 的 `deploy` 目录下：
+
+```shell
+cd /path/to/PaddleClas/deploy
+```
+
+准备 PaddleClas 提供的主体检测 inference 模型：
+
+```shell
+mkdir -p models
+# 下载通用检测 inference 模型并解压
+wget -P ./models/ https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/ppyolov2_r50vd_dcn_mainbody_v1.0_infer.tar
+tar -xf ./models/ppyolov2_r50vd_dcn_mainbody_v1.0_infer.tar -C ./models/
+```
+
+使用以下命令进行预测：
+
+```shell
+python python/predict_det.py -c configs/inference_det.yaml
+```
+
+在配置文件 `configs/inference_det.yaml` 中有以下字段用于配置预测参数：
+* `Global.infer_imgs`：待预测的图片文件路径；
+* `Global.use_gpu`： 是否使用 GPU 预测，默认为 `True`。
+
+## 3. 特征提取模型推理
+
+下面以商品特征提取为例，介绍特征提取模型推理。首先进入 PaddleClas 的 `deploy` 目录下：
+
+```shell
+cd /path/to/PaddleClas/deploy
+```
+
+准备 PaddleClas 提供的商品特征提取 inference 模型：
+
+```shell
+mkdir -p models
+# 下载商品特征提取 inference 模型并解压
+wget -P ./models/ https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/rec/models/inference/product_ResNet50_vd_aliproduct_v1.0_infer.tar
+tar -xf ./models/product_ResNet50_vd_aliproduct_v1.0_infer.tar -C ./models/
+```
+
+上述预测命令可以得到一个 512 维的特征向量，直接输出在在命令行中。
+
+## 4. 主体检测、特征提取和向量检索串联
+
+主体检测、特征提取和向量检索的串联预测，可以参考图像识别[快速体验](../quick_start/quick_start_recognition.md)。

docs/zh_CN_tmp/inference_deployment/whl_deploy.md

+# PaddleClas Whl 使用说明
+
+PaddleClas 支持 Python Whl 包方式进行预测，目前 Whl 包方式仅支持图像分类，暂不支持主体检测、特征提取及向量检索。
+
+---
+
+## 1. 安装
+
+* pip安装
+
+```bash
+pip3 install paddleclas==2.2.1
+```
+
+* 本地构建并安装
+
+```bash
+python3 setup.py bdist_wheel
+pip3 install dist/*
+```
+
+
+## 2. 快速开始
+* 使用`ResNet50`模型，以下图（`'docs/images/whl/demo.jpg'`）为例进行说明。
+
+<div align="center">
+<img src="../images/whl/demo.jpg"  width = "400" />
+</div>
+
+
+* 在Python代码中使用
+```python
+from paddleclas import PaddleClas
+clas = PaddleClas(model_name='ResNet50')
+infer_imgs='docs/images/whl/demo.jpg'
+result=clas.predict(infer_imgs)
+print(next(result))
+```
+
+**注意**：`PaddleClas.predict()` 为可迭代对象（`generator`），因此需要使用 `next()` 函数或 `for` 循环对其迭代调用。每次调用将以 `batch_size` 为单位进行一次预测，并返回预测结果。返回结果示例如下：
+
+```
+>>> result
+[{'class_ids': [8, 7, 136, 80, 84], 'scores': [0.79368, 0.16329, 0.01853, 0.00959, 0.00239], 'label_names': ['hen', 'cock', 'European gallinule, Porphyrio porphyrio', 'black grouse', 'peacock']}]
+```
+
+* 在命令行中使用
+```bash
+paddleclas --model_name=ResNet50  --infer_imgs="docs/images/whl/demo.jpg"
+```
+
+```
+>>> result
+filename: docs/images/whl/demo.jpg, top-5, class_ids: [8, 7, 136, 80, 84], scores: [0.79368, 0.16329, 0.01853, 0.00959, 0.00239], label_names: ['hen', 'cock', 'European gallinule, Porphyrio porphyrio', 'black grouse', 'peacock']
+Predict complete!
+```
+
+## 3. 参数解释
+以下参数可在命令行方式使用中通过参数指定，或在Python代码中实例化PaddleClas对象时作为构造函数的参数使用。
+* model_name(str): 模型名称，使用PaddleClas提供的基于ImageNet1k的预训练模型。
+* inference_model_dir(str): 本地模型文件目录，当未指定 `model_name` 时该参数有效。该目录下需包含 `inference.pdmodel` 和 `inference.pdiparams` 两个模型文件。
+* infer_imgs(str): 待预测图片文件路径，或包含图片文件的目录，或网络图片的URL。
+* use_gpu(bool): 是否使用GPU，默认为 `True`。
+* gpu_mem(int): 使用的GPU显存大小，当 `use_gpu` 为 `True` 时有效，默认为8000。
+* use_tensorrt(bool): 是否开启TensorRT预测，可提升GPU预测性能，需要使用带TensorRT的预测库，默认为 `False`。
+* enable_mkldnn(bool): 是否开启MKLDNN，当 `use_gpu` 为 `False` 时有效，默认 `False`。
+* cpu_num_threads(int): cpu预测时的线程数，当 `use_gpu` 为 `False` 且 `enable_mkldnn` 为 `True` 时有效，默认值为 `10`。
+* batch_size(int): 预测时每个batch的样本数量，默认为 `1`。
+* resize_short(int): 按图像较短边进行等比例缩放，默认为 `256`。
+* crop_size(int): 将图像裁剪到指定大小，默认为 `224`。
+* topk(int): 打印（返回）预测结果的前 `topk` 个类别和对应的分类概率，默认为 `5`。
+* class_id_map_file(str): `class id` 与 `label` 的映射关系文件。默认使用 `ImageNet1K` 数据集的映射关系。
+* save_dir(str): 将预测结果作为预标注数据保存的路径，默认为 `None`，即不保存。
+
+**注意**: 如果使用`Transformer`系列模型，如`DeiT_***_384`, `ViT_***_384`等，请注意模型的输入数据尺寸，需要设置参数`resize_short=384`, `crop_size=384`，如下所示。
+
+* 命令行中
+```bash
+from paddleclas import PaddleClas, get_default_confg
+paddleclas --model_name=ViT_base_patch16_384 --infer_imgs='docs/images/whl/demo.jpg' --resize_short=384 --crop_size=384
+```
+
+* Python代码中
+```python
+from paddleclas import PaddleClas
+clas = PaddleClas(model_name='ViT_base_patch16_384', resize_short=384, crop_size=384)
+```
+
+
+## 4. 使用示例
+
+PaddleClas提供两种使用方式：
+1. Python代码中使用；
+2. 命令行中使用。
+
+
+### 4.1 查看帮助信息
+
+* CLI
+```bash
+paddleclas -h
+```
+
+
+### 4.2 使用PaddleClas提供的预训练模型进行预测
+可以使用PaddleClas提供的预训练模型来预测，并通过参数`model_name`指定。此时PaddleClas会根据`model_name`自动下载指定模型，并保存在目录`~/.paddleclas/`下。
+
+* Python
+```python
+from paddleclas import PaddleClas
+clas = PaddleClas(model_name='ResNet50')
+infer_imgs = 'docs/images/whl/demo.jpg'
+result=clas.predict(infer_imgs)
+print(next(result))
+```
+
+* CLI
+```bash
+paddleclas --model_name='ResNet50' --infer_imgs='docs/images/whl/demo.jpg'
+```
+
+
+### 4.3 使用本地模型文件预测
+可以使用本地的模型文件进行预测，通过参数`inference_model_dir`指定模型文件目录即可。需要注意，模型文件目录下必须包含`inference.pdmodel`和`inference.pdiparams`两个文件。
+
+* Python
+```python
+from paddleclas import PaddleClas
+clas = PaddleClas(inference_model_dir='./inference/')
+infer_imgs = 'docs/images/whl/demo.jpg'
+result=clas.predict(infer_imgs)
+print(next(result))
+```
+
+* CLI
+```bash
+paddleclas --inference_model_dir='./inference/' --infer_imgs='docs/images/whl/demo.jpg'
+```
+
+
+### 4.4 批量预测
+当参数 `infer_imgs` 为包含图片文件的目录时，可以对图片进行批量预测，只需通过参数 `batch_size` 指定batch大小。
+
+* Python
+```python
+from paddleclas import PaddleClas
+clas = PaddleClas(model_name='ResNet50', batch_size=2)
+infer_imgs = 'docs/images/'
+result=clas.predict(infer_imgs)
+for r in result:
+    print(r)
+```
+
+* CLI
+```bash
+paddleclas --model_name='ResNet50' --infer_imgs='docs/images/' --batch_size 2
+```
+
+
+### 4.5 对网络图片进行预测
+可以对网络图片进行预测，只需通过参数`infer_imgs`指定图片`url`。此时图片会下载并保存在`~/.paddleclas/images/`目录下。
+
+* Python
+```python
+from paddleclas import PaddleClas
+clas = PaddleClas(model_name='ResNet50')
+infer_imgs = 'https://raw.githubusercontent.com/paddlepaddle/paddleclas/release/2.2/docs/images/whl/demo.jpg'
+result=clas.predict(infer_imgs)
+print(next(result))
+```
+
+* CLI
+```bash
+paddleclas --model_name='ResNet50' --infer_imgs='https://raw.githubusercontent.com/paddlepaddle/paddleclas/release/2.2/docs/images/whl/demo.jpg'
+```
+
+
+### 4.6 对`NumPy.ndarray`格式数据进行预测
+在Python中，可以对`Numpy.ndarray`格式的图像数据进行预测，只需通过参数`infer_imgs`指定即可。注意该图像数据必须为三通道图像数据。
+
+* python
+```python
+import cv2
+from paddleclas import PaddleClas
+clas = PaddleClas(model_name='ResNet50')
+infer_imgs = cv2.imread("docs/images/whl/demo.jpg")
+result=clas.predict(infer_imgs)
+print(next(result))
+```
+
+
+### 4.7 保存预测结果
+可以指定参数`pre_label_out_dir='./output_pre_label/'`，将图片按其top1预测结果保存到`pre_label_out_dir`目录下对应类别的文件夹中。
+
+* python
+```python
+from paddleclas import PaddleClas
+clas = PaddleClas(model_name='ResNet50', save_dir='./output_pre_label/')
+infer_imgs = 'docs/images/whl/' # it can be infer_imgs folder path which contains all of images you want to predict.
+result=clas.predict(infer_imgs)
+print(next(result))
+```
+
+* CLI
+```bash
+paddleclas --model_name='ResNet50' --infer_imgs='docs/images/whl/' --save_dir='./output_pre_label/'
+```
+
+
+### 4.8 指定label name
+可以通过参数`class_id_map_file`指定`class id`与`lable`的对应关系。PaddleClas默认使用ImageNet1K的label_name（`ppcls/utils/imagenet1k_label_list.txt`）。
+
+`class_id_map_file`文件内容格式应为：
+
+```
+class_id<space>class_name<\n>
+```
+
+例如：
+
+```
+0 tench, Tinca tinca
+1 goldfish, Carassius auratus
+2 great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
+......
+```
+
+* Python
+```python
+from paddleclas import PaddleClas
+clas = PaddleClas(model_name='ResNet50', class_id_map_file='./ppcls/utils/imagenet1k_label_list.txt')
+infer_imgs = 'docs/images/whl/demo.jpg'
+result=clas.predict(infer_imgs)
+print(next(result))
+```
+
+* CLI
+```bash
+paddleclas --model_name='ResNet50' --infer_imgs='docs/images/whl/demo.jpg' --class_id_map_file='./ppcls/utils/imagenet1k_label_list.txt'
+```