[DOC][cherry-pick] Update quick start and compile doc (#4247)

* [DOC] add quick start, test=develop, test=document_fix (#4235)

* [DOC] update compile doc dev (#4243)

README.md

@@ -24,16 +24,16 @@ Paddle Lite框架拥有优秀的加速、优化策略及实现，包含量化、
 
 **三. 下载或编译**
 
-Paddle Lite提供了Android/iOS/X86平台的官方Release预测库下载，我们优先推荐您直接下载 [Paddle Lite预编译库](https://paddle-lite.readthedocs.io/zh/latest/user_guides/release_lib.html)。
-您也可以根据目标平台选择对应的[源码编译方法](https://paddle-lite.readthedocs.io/zh/latest/user_guides/source_compile.html)。Paddle Lite 提供了源码编译脚本，位于 `lite/tools/`文件夹下，只需要 [准备环境](https://paddle-lite.readthedocs.io/zh/latest/user_guides/source_compile.html#id2) 和 [调用编译脚本](https://paddle-lite.readthedocs.io/zh/latest/user_guides/source_compile.html#paddlelite) 两个步骤即可一键编译得到目标平台的Paddle Lite预测库。
+Paddle Lite提供了Android/iOS/X86平台的官方Release预测库下载，我们优先推荐您直接下载 [Paddle Lite预编译库](https://paddle-lite.readthedocs.io/zh/latest/quick_start/release_lib.html)。
+您也可以根据目标平台选择对应的[源码编译方法](https://paddle-lite.readthedocs.io/zh/latest/quick_start/release_lib.html#id2)。Paddle Lite 提供了源码编译脚本，位于 `lite/tools/`文件夹下，只需要 [准备编译环境](https://paddle-lite.readthedocs.io/zh/latest/source_compile/compile_env.html) 和 [调用编译脚本](https://paddle-lite.readthedocs.io/zh/latest/quick_start/release_lib.html#id2) 两个步骤即可一键编译得到目标平台的Paddle Lite预测库。
 
 **四. 预测示例**
 
 Paddle Lite提供了C++、Java、Python三种API，并且提供了相应API的完整使用示例:
 
-- [C++完整示例](https://paddle-lite.readthedocs.io/zh/latest/demo_guides/cpp_demo.html)
-- [Java完整示例](https://paddle-lite.readthedocs.io/zh/latest/demo_guides/java_demo.html)
-- [Python完整示例](https://paddle-lite.readthedocs.io/zh/latest/demo_guides/python_demo.html)
+- [C++完整示例](https://paddle-lite.readthedocs.io/zh/latest/quick_start/cpp_demo.html)
+- [Java完整示例](https://paddle-lite.readthedocs.io/zh/latest/quick_start/java_demo.html)
+- [Python完整示例](https://paddle-lite.readthedocs.io/zh/latest/quick_start/python_demo.html)
 
 您可以参考示例中的说明快速了解使用方法，并集成到您自己的项目中去。
 

docs/api_reference/cv.md

 # CV图像预处理API
 
-请把编译脚本`Paddle-Lite/lite/too/build.sh`中`BUILD_CV`变量设置为`ON`， 其他编译参数设置请参考[源码编译](../user_guides/source_compile)， 以确保 Lite 可以正确编译。这样`CV`图像的加速库就会编译进去，且会生成`paddle_image_preprocess.h`的API文件
+请把编译脚本`Paddle-Lite/lite/tool/build_linux.sh`中`BUILD_CV`变量设置为`ON`， 其他编译参数设置请参考[Linux源码编译](../source_compile/compile_linux)， 以确保 Lite 可以正确编译。这样`CV`图像的加速库就会编译进去，且会生成`paddle_image_preprocess.h`的API文件
 
 - 硬件平台： `ARM`
 - 操作系统：`MAC` 和 `LINUX`

docs/demo_guides/android_app_demo.md

-# Android Demo
+# Android 工程示例
 
 ## 多种应用场景
 
@@ -36,7 +36,7 @@
 
 **需要的环境**： Android Studio、Android手机（开启USB调试模式）、下载到本地的[Paddle-Lite-Demo](https://github.com/PaddlePaddle/Paddle-Lite-Demo)工程
 
-**预先要求**：如果您的Android Studio尚未配置NDK，请根据Android Studio用户指南中的[安装及配置NDK和CMake](https://developer.android.com/studio/projects/install-ndk)内容，预先配置好NDK。您可以选择最新的NDK版本，或者与[Android编译环境配置](https://paddle-lite.readthedocs.io/zh/latest/user_guides/source_compile.html#android)中的NDK版本保持一致。
+**预先要求**：如果您的Android Studio尚未配置NDK，请根据Android Studio用户指南中的[安装及配置NDK和CMake](https://developer.android.com/studio/projects/install-ndk)内容，预先配置好NDK。您可以选择最新的NDK版本，或者与[Android编译环境配置](../source_compile/compile_env.html#android)中的NDK版本保持一致。
 
 **部署步骤**：
 

docs/demo_guides/baidu_xpu.md

@@ -95,7 +95,7 @@ Paddle Lite已支持百度XPU在x86和arm服务器（例如飞腾 FT-2000+/64）
 
 ### 准备本地编译环境
 
-- 为了保证编译环境一致，建议参考[源码编译](../user_guides/source_compile)中的Linux开发环境进行配置；
+- 为了保证编译环境一致，建议参考[编译环境准备](../source_compile/compile_env.html#linux)中的Linux开发环境进行配置；
 - 由于编译示例程序需要依赖OpenCV和CMake 3.10.3，请执行如下命令进行安装；
 
 ```shell

docs/demo_guides/cpp_demo.md

-# C++ Demo
-
-## 1. 下载最新版本预测库
-
-预测库下载界面位于[Paddle-Lite官方预编译库](../user_guides/release_lib)，可根据需求选择合适版本。
-
-以**Android-ARMv8架构**为例，可以下载以下版本：
-
-
-|ARM Version|build_extra|arm_stl|target|下载|
-|:-------:|:-----:|:-----:|:-----:|:-------:|
-|armv8|OFF|c++_static|tiny_publish|[release/v2.3](https://github.com/PaddlePaddle/Paddle-Lite/releases/download/v2.3.0/inference_lite_lib.android.armv8.gcc.c++_static.tiny_publish.tar.gz)|
-
-**解压后内容如下图所示：**
-
-![image](https://paddlelite-data.bj.bcebos.com/doc_images/cxx_demo/1inference_lib.png)
-
-## 2. 转化模型
-
-PaddlePaddle的原生模型需要经过[opt]()工具转化为Paddle-Lite可以支持的naive_buffer格式。
-
-以`mobilenet_v1`模型为例：
-
-（1）下载[mobilenet_v1模型](http://paddle-inference-dist.bj.bcebos.com/mobilenet_v1.tar.gz)后解压：
-
-```shell
-wget http://paddle-inference-dist.bj.bcebos.com/mobilenet_v1.tar.gz
-tar zxf mobilenet_v1.tar.gz
-```
-
-**如下图所示:**
-
-![image](https://paddlelite-data.bj.bcebos.com/doc_images/cxx_demo/3inference_model.png)
-
-（2）模型转换
-
-
-  - v2.6.0版本之前
-
-  下载[opt工具](https://github.com/PaddlePaddle/Paddle-Lite/releases/download/v2.3.0/opt)。放入同一文件夹，终端输入命令转化模型
-
-  ```shell
-  wget https://github.com/PaddlePaddle/Paddle-Lite/releases/download/v2.3.0/opt
-  chmod +x opt
-  ./opt --model_dir=./mobilenet_v1 --optimize_out_type=naive_buffer   --optimize_out=./mobilenet_v1_opt
-  ```
-  - v2.6.0版本以及后续版本
-
-  安装paddlelite，终端输入命令转化模型
- 
-  ```shell
-  python -m pip install paddlelite
-  paddle_lite_opt --model_dir=./mobilenet_v1 --optimize_out_type=naive_buffer   --optimize_out=./mobilenet_v1_opt
-  ```
-**结果如下图所示：**
-
-![image](https://paddlelite-data.bj.bcebos.com/doc_images/cxx_demo/2opt_model.png)
-
-
-
-## 3. 编写预测程序
-
-准备好预测库和模型，我们便可以编写程序来执行预测。我们提供涵盖图像分类、目标检测等多种应用场景的C++示例demo可供参考，位于`inference_lite_lib.android.armv8/demo/cxx`。
-
-以mobile net_v1预测为例：`mobile_light`为mobilenet_v1预测示例，可以直接调用。
-
-**示例如下图所示：**
-
-![image](https://paddlelite-data.bj.bcebos.com/doc_images/cxx_demo/4light_demo.png)
-
-
-
-## 4. 编译
-
-预测程序需要编译为Android可执行文件。
-
-以mobilenet_v1模型为例，C++示例位于`inference_lite_lib.android.armv8/demo/mobile_light`
-
-```shell
-cd inference_lite_lib.android.armv8/demo/mobile_light
-```
-
-编译demo
-
-```shell
-make
-```
-
-**结果如下图所示：**
-
-![image](https://paddlelite-data.bj.bcebos.com/doc_images/cxx_demo/5compile_demo.png)
-
-## 5. 执行预测
-
-通过adb工具将可执行文件推送到手机上执行预测
-
-（1）保证电脑已经安装adb工具，手机以"USB调试"、"文件传输模式"连接到电脑。
-
-``` shell
-adb deveices   #查看adb设备是否已被识别
-```
-
-**连接如下图所示：**
-
-![image](https://paddlelite-data.bj.bcebos.com/doc_images/cxx_demo/6adb_devices.png)
-
-（2）准备预测库、模型和预测文件
-
-1、将模型、动态库和预测文件放入同一文件夹：
-
-![image](https://paddlelite-data.bj.bcebos.com/doc_images/cxx_demo/7files.png)
-
-**注意**：动态预测库文件位于: `inference_lite_lib.android.armv8/cxx/liblibpaddle_light_api_shared.so`
-
-2、文件推送到手机：
-
-``` shell
-chmod +x mobilenetv1_light_api
-adb push mobilenet_v1_opt.nb /data/local/tmp
-adb push libpaddle_light_api_shared.so /data/local/tmp
-adb push mobilenetv1_light_api /data/local/tmp
-```
-**效果如下图所示：**
-
-![image](https://paddlelite-data.bj.bcebos.com/doc_images/cxx_demo/8push_file.png)
-
-（3）执行预测
-
-```shell
-adb shell 'cd /data/local/tmp && export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/data/local/tmp && mobilenetv1_light_api ./mobilenet_v1_opt.nb'
-```
-**结果如下图所示：**
-
-![image](https://paddlelite-data.bj.bcebos.com/doc_images/cxx_demo/9result.png)
-
-上图的`Output`为mobilenet_v1模型在全1输入时，得到的预测输出。至此，Paddle-Lite的C++ demo执行完毕。
-
-
-
-
-
-## 注：如何在代码中使用 API
-
-C++代码调用Paddle-Lite执行预测库仅需以下五步：
-
-（1）引用头文件和命名空间
-
-```c++
-#include "paddle_api.h"
-using namespace paddle::lite_api;
-```
-
-（2）指定模型文件，创建Predictor
-
-```C++
-// 1. Set MobileConfig, model_file_path is 
-// the path to model model file. 
-MobileConfig config;
-config.set_model_from_file(model_file_path);
-// 2. Create PaddlePredictor by MobileConfig
-std::shared_ptr<PaddlePredictor> predictor =
-    CreatePaddlePredictor<MobileConfig>(config);
-```
-
-（3）设置模型输入 (下面以全一输入为例)
-
-```c++
-std::unique_ptr<Tensor> input_tensor(std::move(predictor->GetInput(0)));
-input_tensor->Resize({1, 3, 224, 224});
-auto* data = input_tensor->mutable_data<float>();
-for (int i = 0; i < ShapeProduction(input_tensor->shape()); ++i) {
-  data[i] = 1;
-}
-```
-
-（4）执行预测
-
-```c++
-predictor->Run();
-```
-
-（5）获得预测结果
-
-```c++
-std::unique_ptr<const Tensor> output_tensor(
-    std::move(predictor->GetOutput(0)));
-// 转化为数据
-auto output_data=output_tensor->data<float>();
-```
-
-
-
-
-
-## 其他cxx_demo的编译与预期结果
-
-### Light API Demo
-
-```shell
-cd ../mobile_light
-make
-adb push mobilenetv1_light_api /data/local/tmp/
-adb shell chmod +x /data/local/tmp/mobilenetv1_light_api
-adb shell "/data/local/tmp/mobilenetv1_light_api --model_dir=/data/local/tmp/mobilenet_v1.opt  "
-```
-
-
-### 图像分类 Demo
-
-```shell
-cd ../mobile_classify
-wget http://paddle-inference-dist.bj.bcebos.com/mobilenet_v1.tar.gz
-tar zxvf mobilenet_v1.tar.gz
-make
-adb push mobile_classify /data/local/tmp/
-adb push test.jpg /data/local/tmp/
-adb push labels.txt /data/local/tmp/
-adb push ../../../cxx/lib/libpaddle_light_api_shared.so /data/local/tmp/
-adb shell chmod +x /data/local/tmp/mobile_classify
-adb shell "export LD_LIBRARY_PATH=/data/local/tmp/:$LD_LIBRARY_PATH && /data/local/tmp/mobile_classify /data/local/tmp/mobilenet_v1.opt /data/local/tmp/test.jpg /data/local/tmp/labels.txt"
-```
-
-### 目标检测 Demo
-
-```shell
-cd ../mobile_detection
-wget https://paddle-inference-dist.bj.bcebos.com/mobilenetv1-ssd.tar.gz
-tar zxvf mobilenetv1-ssd.tar.gz
-make
-adb push mobile_detection /data/local/tmp/
-adb push test.jpg /data/local/tmp/
-adb push ../../../cxx/lib/libpaddle_light_api_shared.so /data/local/tmp/
-adb shell chmod +x /data/local/tmp/mobile_detection
-adb shell "export LD_LIBRARY_PATH=/data/local/tmp/:$LD_LIBRARY_PATH && /data/local/tmp/mobile_detection /data/local/tmp/mobilenetv1-ssd /data/local/tmp/test.jpg"
-adb pull /data/local/tmp/test_detection_result.jpg ./
-```
-
-### light API Demo 运行结果
-
-运行成功后 ，将在控制台输出预测结果的前10个类别的预测概率：
-
-```shell
-Output dim: 1000
-Output[0]: 0.000191
-Output[100]: 0.000160
-Output[200]: 0.000264
-Output[300]: 0.000211
-Output[400]: 0.001032
-Output[500]: 0.000110
-Output[600]: 0.004829
-Output[700]: 0.001845
-Output[800]: 0.000202
-Output[900]: 0.000586
-```
-
-### 图像分类 Demo 运行结果
-
-运行成功后 ，将在控制台输出预测结果的前5个类别的类型索引、名字和预测概率：
-
-```shell
-parameter:  model_dir, image_path and label_file are necessary
-parameter:  topk, input_width,  input_height, are optional
-i: 0, index: 285, name:  Egyptian cat, score: 0.482870
-i: 1, index: 281, name:  tabby, tabby cat, score: 0.471593
-i: 2, index: 282, name:  tiger cat, score: 0.039779
-i: 3, index: 287, name:  lynx, catamount, score: 0.002430
-i: 4, index: 722, name:  ping-pong ball, score: 0.000508
-```
-
-### 目标检测 Demo 运行结果
-
-运行成功后 ，将在控制台输出检测目标的类型、预测概率和坐标：
-
-```shell
-running result:
-detection image size: 935, 1241, detect object: person, score: 0.996098, location: x=187, y=43, width=540, height=592
-detection image size: 935, 1241, detect object: person, score: 0.935293, location: x=123, y=639, width=579, height=597
-```

docs/demo_guides/fpga.md

@@ -22,7 +22,8 @@ CMAKE编译选项：
 
 - 设置`LITE_WITH_FPGA=ON`和`LITE_WITH_ARM=ON`
 
-其他编译选项与ARM编译相同，可以参考[“Paddle Lite在Docker下的ARM编译”](../user_guides/source_compile)。
+其他编译选项与ARM编译相同，可以参考[“Paddle Lite在Docker下的ARM编译”](../source_compile/compile_linux)。
+
 示例如下：
 ```shell
     cmake .. \

docs/demo_guides/ios_app_demo.md

-# iOS Demo
+# iOS 工程示例
 
 ## 多种应用场景
 

docs/demo_guides/java_demo.md

-# Java Demo
-
-本节中，Java demo 完整代码位于 [demo/java](https://github.com/PaddlePaddle/Paddle-Lite/tree/develop/lite/demo/java) 。
-
-要编译和跑起Android demo 程序 PaddlePredictor，你需要准备：
-
-1. 一台能运行安卓程序的安卓手机
-2. 一台带有AndroidStudio的开发机
-
-## 编译
-
-首先在PaddleLite的开发 [Docker镜像](../user_guides/source_compile) 中，拉取最新PaddleLite代码，编译对应你手机架构的预测库，
-下面我们以arm8 架构举例。进入paddlelite 目录，运行以下命令：
-
-```shell
-./lite/tools/build.sh        \
-    --arm_os=android         \
-    --arm_abi=armv8          \
-    --arm_lang=gcc           \
-    --android_stl=c++_static \
-    tiny_publish
-```
-
-命令完成后查看要存在
-
-```
-./build.lite.android.armv8.gcc/inference_lite_lib.android.armv8/java/so/libpaddle_lite_jni.so
-./build.lite.android.armv8.gcc/inference_lite_lib.android.armv8/java/jar/PaddlePredictor.jar
-./build.lite.android.armv8.gcc/inference_lite_lib.android.armv8/demo/java/android
-```
-
-libpaddle_lite_jni.so为 PaddleLite c++ 动态链接库，PaddlePredictor.jar为 Java jar 包，两者包含 PaddleLite Java API，接下来 Android Java 代码会使用这些api。android文件夹中则是Android demo。
-
-## 准备 demo 需要的其他文件
-
-Demo 除了代码，还需要准备在Android工程目录下配置好JNI .so 库（上节提到的`libpaddle_lite_jni.so`），Java .jar 包（上文提到的`PaddlePredictor.jar` ），和模型文件。我们提供了自动化的脚本和手动拷贝两种方法，用户可以根据自己需要选择：
-
-### 脚本方法
-
-进入 `build.lite.android.armv8.gcc/inference_lite_lib.android.armv8/demo/java/android`，我们准备了一个脚本`prepare_demo.bash`，脚本输入一个参数，为你要拷贝的.so 对应的架构文件夹名。
-
-例如运行
-
-```
-bash prepare_demo.bash arm8
-```
-
-该脚本自动下载并解压缩模型文件，拷贝了 .jar 包进demo，还有生成的.so包进`PaddlePredictor/app/src/main/jinLibs/架构文件夹下`，
-在我们这个例子里，armv8 就是架构文件夹。备注：这种方式构建的 demo 在 armv8 手机运行正常。如果要demo 程序在别的手机架构（如 armv7）上也运行正常，需要添加别的架构。
-
-### 手动拷贝方法
-
-接下来我们介绍手动拷贝，如果使用了脚本，那么可以跳过以下手动方法的介绍。
-
-### 把 .so 动态库和 .jar 拷贝进安卓demo程序：
-
-1. 将PaddlePredictor 载入到AndroidStudio。
-2. 将`libpaddle_lite_jni.so`拷贝进 `PaddlePredictor/app/src/main/jinLibs/架构文件夹下` ，比如文件夹arm8里要包含该 .so文件。
-3. 将 `PaddlePredictor.jar` 拷贝进 `PaddlePredictor/app/libs` 下
-
-### 把demo使用到的模型文件拷贝进安卓程序：
-
-下载我们的5个模型文件，并解压缩到 `PaddlePredictor/app/src/main/assets` 这个文件夹中
-需要拷贝的模型文件和下载地址：
-
-```
-inception_v4_simple_opt.nb http://paddle-inference-dist.bj.bcebos.com/inception_v4_simple_opt.nb.tar.gz
-lite_naive_model_opt.nb    http://paddle-inference-dist.bj.bcebos.com/lite_naive_model_opt.nb.tar.gz
-mobilenet_v1_opt.nb        http://paddle-inference-dist.bj.bcebos.com/mobilenet_v1_opt.nb.tar.gz
-mobilenet_v2_relu_opt.nb   http://paddle-inference-dist.bj.bcebos.com/mobilenet_v2_relu_opt.nb.tar.gz
-resnet50_opt.nb            http://paddle-inference-dist.bj.bcebos.com/resnet50_opt.nb.tar.gz
-```
-
-下载完后，assets文件夹里要包含解压后的上面五个模型文件夹，但demo里不需要保存原压缩.tar.gz 文件。
-
-注意：输入的模型要求为naive buffer存储格式，您可以通过 [**Model Optimize Tool**](../user_guides/model_optimize_tool) 将fluid模型转为naive buffer存储格式。
-
-## 运行 Android 程序结果
-
-以上准备工作完成，就可以开始Build 、安装、和运行安卓demo程序。当你运行PaddlePredictor 程序时，大概会等10秒，然后看到类似以下字样：
-
-```
-lite_naive_model output: 50.213173, -28.872887
-expected: 50.2132, -28.8729
-
-inception_v4_simple test:true
-time: xxx ms
-
-resnet50 test:true
-time: xxx ms
-
-mobilenet_v1 test:true
-time: xxx ms
-
-mobilenet_v2 test:true
-time: xxx ms
-```
-
-该 demo 程序跑我们的 5 个模型，第一个模型结果将真正的头两个数字输出，并在第二行附上期望的正确值。你应该要看到他们的误差小于0.001。后面四个模型如果你看到 `test:true` 字样，说明模型输出通过了我们在 demo 程序里对其输出的测试。time 代表该测试花费的时间。

docs/demo_guides/linux_arm_demo.md

-# Linux(ARM) Demo
+# Linux(ARM) 工程示例
 
 ## 多种应用场景
 
@@ -86,6 +86,6 @@ for (int i = 0; i < ShapeProduction(output_tensor->shape()); i += 100) {
 
 ## 使用Python接口预测
 
-1. Python预测库编译参考[编译Linux](../user_guides/Compile/Linux)，建议在开发版上编译。
-2. [Paddle-Lite Python API](https://paddle-lite.readthedocs.io/zh/latest/api_reference/python_api_doc.html)。
-3. 代码参考，[Python预测](python_demo)
+1. Python预测库编译参考[编译Linux](../source_compile/compile_linux)，建议在开发版上编译。
+2. [Paddle-Lite Python API](../api_reference/python_api_doc)。
+3. 代码参考，[Python完整示例](python_demo)

docs/demo_guides/mediatek_apu.md

@@ -42,7 +42,7 @@ Paddle Lite已支持MTK APU的预测部署。
 
 ### 准备交叉编译环境
 
-- 为了保证编译环境一致，建议参考[源码编译](../user_guides/source_compile)中的Docker开发环境进行配置。
+- 为了保证编译环境一致，建议参考[编译环境准备](../source_compile/compile_env)中的Docker开发环境进行配置。
 
 ### 运行图像分类示例程序
 

docs/demo_guides/python_demo.md

-# Python Demo
-
-## 1. 下载最新版本python预测库
-
-```shell
-python -m pip install paddlelite
-```
-
-## 2. 转化模型
-
-PaddlePaddle的原生模型需要经过[opt]()工具转化为Paddle-Lite可以支持的naive_buffer格式。
-
-以`mobilenet_v1`模型为例：
-
-（1）下载[mobilenet_v1模型](http://paddle-inference-dist.bj.bcebos.com/mobilenet_v1.tar.gz)后解压：
-
-```shell
-wget http://paddle-inference-dist.bj.bcebos.com/mobilenet_v1.tar.gz
-tar zxf mobilenet_v1.tar.gz
-```
-
-（2）使用opt工具：
-
- 从磁盘加载模型时，根据模型和参数文件存储方式不同，加载模型和参数的路径有两种形式。
-
-- Linux环境
-  - 非combined形式：模型文件夹model_dir下存在一个模型文件和多个参数文件时，传入模型文件夹路径，模型文件名默认为__model__。
-
-  ```shell
-  paddle_lite_opt --model_dir=./mobilenet_v1  \
-                  --optimize_out=mobilenet_v1_opt \
-                  --optimize_out_type=naive_buffer \
-                  --valid_targets=x86
-  ```
-  - combined形式：模型文件夹model_dir下只有一个模型文件__model__和一个参数文件__params__时，传入模型文件和参数文件路径
-
-  ```shell
-  paddle_lite_opt --model_file=./mobilenet_v1/__model__ \
-                  --param_file=./mobilenet_v1/__params__  \
-                  --optimize_out=mobilenet_v1_opt \
-                  --optimize_out_type=naive_buffer \
-                  --valid_targets=x86
-  ```
-
-- windows环境
-
-windows 暂不支持命令行方式直接运行模型转换器，需要编写python脚本
-
-```python
-import paddlelite.lite as lite
-
-a=lite.Opt()
-# 非combined形式
-a.set_model_dir("D:\\YOU_MODEL_PATH\\mobilenet_v1")
-
-# conmbined形式
-# a.set_model_file("D:\\YOU_MODEL_PATH\\mobilenet_v1\\__model__")
-# a.set_param_file("D:\\YOU_MODEL_PATH\\mobilenet_v1\\__params__")
-
-a.set_optimize_out("mobilenet_v1_opt")
-a.set_valid_places("x86")
-
-a.run()
-```
-
-- MAC 环境
-
-Opt工具使用方式同Linux（MAC环境暂不支持python端预测，下个版本会修复该问题）
-
-## 3. 编写预测程序
-
-准备好预测库和模型，我们便可以编写程序来执行预测。我们提供涵盖图像分类、目标检测等多种应用场景的C++示例demo可供参考，创建文件mobilenetV1_light_api.py，
-python demo 完整代码位于 [demo/python](https://github.com/PaddlePaddle/Paddle-Lite/blob/develop/lite/demo/python/mobilenetv1_light_api.py) 。
-
-(1) 设置config信息
-```python
-from paddlelite.lite import *
-
-config = MobileConfig()
-config.set_model_from_file(/YOU_MODEL_PATH/mobilenet_v1_opt.nb)
-```
-
-(2) 创建predictor
-
-```python
-predictor = create_paddle_predictor(config)
-```
-
-(3) 从图片读入数据
-
-```python
-image = Image.open('./example.jpg')
-resized_image = image.resize((224, 224), Image.BILINEAR)
-image_data = np.array(resized_image).flatten().tolist()
-```
-
-(4) 设置输入数据
-
-```python
-input_tensor = predictor.get_input(0)
-input_tensor.resize([1, 3, 224, 224])
-input_tensor.set_float_data(image_data)
-```
-
-(5) 执行预测
-```python
-predictor.run()
-```
-
-(6) 得到输出数据
-```python
-output_tensor = predictor.get_output(0)
-print(output_tensor.shape())
-print(output_tensor.float_data()[:10])
-```
-
-## 4. 运行文件
-```shell
-python mobilenetV1_light_api.py
-```

docs/demo_guides/rockchip_npu.md

@@ -48,7 +48,7 @@ Paddle Lite已支持RK NPU的预测部署。
 
 ### 准备交叉编译环境
 
-- 为了保证编译环境一致，建议参考[源码编译](../user_guides/source_compile)中的Docker开发环境进行配置。
+- 为了保证编译环境一致，建议参考[编译环境准备](../source_compile/compile_env)中的Docker开发环境进行配置。
 
 ### 运行图像分类示例程序
 

docs/demo_guides/x86.md

@@ -2,7 +2,7 @@
 
 ## 一、Docker或者Linux环境
 
-Paddle-Lite 支持在Docker或Linux环境编译x86预测库。环境搭建参考[环境准备](../user_guides/source_compile)。
+Paddle-Lite 支持在Docker或Linux环境编译x86预测库。环境搭建参考[编译环境准备](../source_compile/compile_env)。
 
 如果编译python库(`build_python=ON`)需要额外安装`python-dev`和`patchelf`
 

docs/index.rst

@@ -27,28 +27,32 @@ Welcome to Paddle-Lite's documentation!
 
 .. toctree::
   :maxdepth: 1
-  :caption: 使用方法
+  :caption: 快速开始
+  :name: sec-quick-start
+
+  quick_start/tutorial
+  quick_start/release_lib
+  quick_start/cpp_demo
+  quick_start/java_demo
+  quick_start/python_demo
+
+.. toctree::
+  :maxdepth: 1
+  :caption: 使用工具
   :name: sec-user-guides
 
-  user_guides/tutorial
-  user_guides/release_lib
-  user_guides/source_compile
   user_guides/x2paddle
   user_guides/model_optimize_tool
   user_guides/post_quant_with_data
   user_guides/post_quant_no_data
   user_guides/model_quantization
   user_guides/debug
-  user_guides/library_tailoring
 
 .. toctree::
   :maxdepth: 1
   :caption: 部署示例
   :name: sec-demo_guides
 
-  demo_guides/cpp_demo
-  demo_guides/java_demo
-  demo_guides/python_demo
   demo_guides/android_app_demo
   demo_guides/ios_app_demo
   demo_guides/linux_arm_demo
@@ -61,6 +65,18 @@ Welcome to Paddle-Lite's documentation!
   demo_guides/rockchip_npu
   demo_guides/mediatek_apu
 
+.. toctree::
+  :maxdepth: 1
+  :caption: 源码编译
+  :name: sec-source-compile
+
+  source_compile/compile_env
+  source_compile/compile_andriod
+  source_compile/compile_ios
+  source_compile/compile_linux
+  source_compile/compile_options
+  source_compile/library_tailoring
+
 .. toctree::
   :maxdepth: 1
   :caption: 训练示例（预览）
@@ -100,8 +116,4 @@ Welcome to Paddle-Lite's documentation!
 
   introduction/faq
 
-.. toctree::
-  :maxdepth: 1
-  :caption: paddle-mobile
-
 

docs/introduction/faq.md

@@ -5,4 +5,4 @@
 
 1. 在Host端采用交叉编译方式编译PaddleLite，将编译后的libpaddle_light_api_shared.so和可执行程序放到板卡上运行，出现了如下图所示的错误，怎么解决？ 
 ![host_target_compiling_env_miss_matched](https://user-images.githubusercontent.com/9973393/75761527-31b8b700-5d74-11ea-8a9a-0bc0253ee003.png)
-- 原因是Host端的交叉编译环境与Target端板卡的运行环境不一致，导致libpaddle_light_api_shared.so链接的GLIBC库高于板卡环境的GLIBC库。目前有四种解决办法（为了保证编译环境与官方一致，推荐第一种方式）：1）在Host端，参考[源码编译](../user_guides/source_compile)中的Docker方式重新编译libpaddle_light_api_shared.so；2）在Host端，使用与Target端版本一致的ARM GCC和GLIBC库重新编译libpaddle_light_api_shared.so；3）在Target端板卡上，参考[源码编译](../user_guides/source_compile)中的ARM Linux本地编译方式重新编译libpaddle_light_api_shared.so；4）在Target端板卡上，将GLIBC库升级到和Host端一致的版本，即GLIBC2.27。
+- 原因是Host端的交叉编译环境与Target端板卡的运行环境不一致，导致libpaddle_light_api_shared.so链接的GLIBC库高于板卡环境的GLIBC库。目前有四种解决办法（为了保证编译环境与官方一致，推荐第一种方式）：1）在Host端，参考[编译环境准备](../source_compile/compile_env)和[Linux源码编译](../source_compile/compile_linux)中的Docker方式重新编译libpaddle_light_api_shared.so；2）在Host端，使用与Target端版本一致的ARM GCC和GLIBC库重新编译libpaddle_light_api_shared.so；3）在Target端板卡上，参考[编译环境准备](../source_compile/compile_env)和[Linux源码编译](../source_compile/compile_linux)中的ARM Linux本地编译方式重新编译libpaddle_light_api_shared.so；4）在Target端板卡上，将GLIBC库升级到和Host端一致的版本，即GLIBC2.27。

docs/quick_start/cpp_demo.md

+# C++ 完整示例
+
+本章节包含2部分内容：(1) [C++ 示例程序](cpp_demo.html#id1); (2) [C++ 应用开发说明](cpp_demo.html#id11)。
+
+## C++ 示例程序
+
+本章节展示的所有C++ 示例代码位于 [demo/c++](https://github.com/PaddlePaddle/Paddle-Lite/tree/develop/lite/demo/cxx) 。
+
+### 1. 环境准备
+
+要编译和运行Android C++ 示例程序，你需要准备：
+
+1. 一台armv7或armv8架构的安卓手机
+2. 一台可以编译PaddleLite的电脑
+
+### 2. 下载预编译的预测库
+
+预测库下载界面位于[Lite预编译库下载](release_lib)，可根据您的手机型号选择合适版本。
+
+以**Android-ARMv8架构**为例，可以下载以下版本：
+
+| Arch  |with_extra|arm_stl|with_cv|下载|
+|:-------:|:-----:|:-----:|:-----:|:-------:|
+|armv8|OFF|c++_static|OFF|[release/v2.6.1](https://paddlelite-data.bj.bcebos.com/Release/2.6.1/Android/inference_lite_lib.android.armv8.gcc.c++_static.CV_OFF.tar.gz)|
+
+**解压后内容结构如下：**
+
+```shell
+inference_lite_lib.android.armv8          Paddle-Lite 预测库
+├── cxx                                       C++ 预测库
+│   ├── include                                   C++ 预测库头文件
+│   └── lib                                       C++ 预测库文件
+│       ├── libpaddle_api_light_bundled.a             静态预测库
+│       └── libpaddle_light_api_shared.so             动态预测库
+├── demo                                      示例 Demo
+│   ├── cxx                                       C++ 示例 Demo
+│   └── java                                      Java 示例 Demo
+└── java                                      Java 预测库
+```
+
+### 3. 准备预测部署模型
+
+(1) 模型下载：下载[mobilenet_v1](http://paddle-inference-dist.bj.bcebos.com/mobilenet_v1.tar.gz)模型后解压，得到Paddle非combined形式的模型，位于文件夹 `mobilenet_v1` 下。可通过模型可视化工具[Netron](https://lutzroeder.github.io/netron/)打开文件夹下的`__model__`文件，查看模型结构。
+
+```shell
+wget http://paddle-inference-dist.bj.bcebos.com/mobilenet_v1.tar.gz
+tar zxf mobilenet_v1.tar.gz
+```
+
+(2) 模型转换：Paddle的原生模型需要经过[opt](../user_guides/model_optimize_tool)工具转化为Paddle-Lite可以支持的naive_buffer格式。
+
+方式一: 下载[opt工具](../user_guides/model_optimize_tool)，放入与`mobilenet_v1`文件夹同级目录，终端输入以下命令转化模型
+
+```shell
+# Linux
+wget https://github.com/PaddlePaddle/Paddle-Lite/releases/download/v2.6.1/opt
+chmod +x opt
+./opt --model_dir=./mobilenet_v1 \
+      --optimize_out_type=naive_buffer \
+      --optimize_out=./mobilenet_v1_opt
+
+# Mac
+wget https://github.com/PaddlePaddle/Paddle-Lite/releases/download/v2.6.1/opt_mac
+chmod +x opt_mac
+./opt_mac --model_dir=./mobilenet_v1 \
+          --optimize_out_type=naive_buffer \
+          --optimize_out=./mobilenet_v1_opt
+```
+
+方式二: 通过pip安装paddlelite，终端输入命令转化模型
+
+```shell
+python -m pip install paddlelite
+paddle_lite_opt --model_dir=./mobilenet_v1 \
+                --optimize_out_type=naive_buffer \
+                --optimize_out=./mobilenet_v1_opt
+```
+
+以上命令执行成功之后将在同级目录生成名为`mobilenet_v1_opt.nb`的优化后模型文件。
+
+
+
+### 4. 编译预测示例程序
+
+准备好预测库和模型，就可以直接编译随着预测库一起发布的 C++ Demo，位于在第二步中下载的预测库文件目录下`inference_lite_lib.android.armv8/demo/cxx`。以mobilenet_v1为例，目录下的`mobile_light`为mobilenet_v1预测示例，预测程序需要编译为Android可执行文件。
+
+```shell
+cd inference_lite_lib.android.armv8/demo/mobile_light
+make
+```
+
+会在同级目录下生成名为`mobilenetv1_light_api`的可执行文件。
+
+### 5. 预测部署和执行
+
+(1) 设置手机：手机USB连接电脑，打开`设置 -> 开发者模式 -> USB调试 -> 允许（授权）当前电脑调试手机`。保证当前电脑已经安装[adb工具](https://developer.android.com/studio/command-line/adb)，运行以下命令，确认当前手机设备已被识别：
+
+``` shell
+adb devices
+# 如果手机设备已经被正确识别，将输出如下信息
+List of devices attached
+017QXM19C1000664	device
+```
+
+(2) 预测部署：第二步中的C++动态预测库文件`libpaddle_light_api_shared.so`，将第三步中生成的优化后模型文件`mobilenet_v1_opt.nb`和第四步中编译得到的预测示例程序`mobilenetv1_light_api`放入同一文件夹，并将这三个文件推送到手机：
+
+``` shell
+chmod +x mobilenetv1_light_api
+adb push mobilenet_v1_opt.nb /data/local/tmp
+adb push libpaddle_light_api_shared.so /data/local/tmp
+adb push mobilenetv1_light_api /data/local/tmp
+
+# 如果推送成功，将显示如下信息
+adb shell 'ls -l /data/local/tmp'
+total 24168
+-rwxrwxrwx 1 root root  1624280 2020-09-01 13:47 libpaddle_light_api_shared.so
+-rw-rw-rw- 1 root root 17018243 2020-09-01 12:28 mobilenet_v1_opt.nb
+-rwxrwxrwx 1 root root  6076144 2020-09-01 13:47 mobilenetv1_light_api
+```
+
+(3) 执行预测，以下输出为mobilenet_v1模型在全1输入时，得到的预测结果。
+
+```shell
+adb shell 'cd /data/local/tmp && export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/data/local/tmp && ./mobilenetv1_light_api mobilenet_v1_opt.nb'
+
+# 如果正确运行，将输出如下信息
+run_idx:1 / 10: 33.821 ms
+run_idx:2 / 10: 33.8 ms
+run_idx:3 / 10: 33.867 ms
+run_idx:4 / 10: 34.009 ms
+run_idx:5 / 10: 33.699 ms
+run_idx:6 / 10: 33.644 ms
+run_idx:7 / 10: 33.611 ms
+run_idx:8 / 10: 33.783 ms
+run_idx:9 / 10: 33.731 ms
+run_idx:10 / 10: 33.423 ms
+
+======= benchmark summary =======
+input_shape(NCHW):1 3 224 224
+model_dir:mobilenet_v1_opt.nb
+warmup:10
+repeats:10
+max_duration:34.009
+min_duration:33.423
+avg_duration:33.7388
+
+====== output summary ======
+output tensor num:1
+
+--- output tensor 0 ---
+output shape(NCHW):1 1000
+output tensor 0 elem num:1000
+output tensor 0 standard deviation:0.00219646
+output tensor 0 mean value:0.001
+```
+
+### 更多C++示例
+
+#### 图像分类示例
+
+```shell
+cd inference_lite_lib.android.armv8/demo/cxx/mobile_classify
+
+# 下载模型
+wget http://paddle-inference-dist.bj.bcebos.com/mobilenet_v1.tar.gz
+tar zxvf mobilenet_v1.tar.gz
+# 转化模型
+paddle_lite_opt --model_dir=./mobilenet_v1 \
+                --optimize_out_type=naive_buffer \
+                --optimize_out=./mobilenet_v1_opt
+# 编译预测程序
+make
+# 预测部署
+adb push mobile_classify /data/local/tmp/
+adb push mobilenet_v1_opt.nb /data/local/tmp/
+adb push mobilenet_v1/test.jpg /data/local/tmp/
+adb push mobilenet_v1/labels.txt /data/local/tmp/
+adb push ../../../cxx/lib/libpaddle_light_api_shared.so /data/local/tmp/
+adb shell 'chmod +x /data/local/tmp/mobile_classify'
+# 执行预测
+adb shell 'cd /data/local/tmp && export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/data/local/tmp &&  ./mobile_classify mobilenet_v1_opt.nb test.jpg labels.txt'
+
+# 运行成功后 ，将在控制台输出预测结果的前5个类别的类型索引、名字和预测概率
+parameter:  model_file, image_path and label_file are necessary
+parameter:  topk, input_width,  input_height, are optional
+i: 0, index: 287, name:  lynx, catamount, score: 0.317595
+i: 1, index: 285, name:  Egyptian cat, score: 0.308135
+i: 2, index: 281, name:  tabby, tabby cat, score: 0.161924
+i: 3, index: 282, name:  tiger cat, score: 0.093659
+i: 4, index: 283, name:  Persian cat, score: 0.060198
+```
+
+#### 目标检测示例
+
+```shell
+cd inference_lite_lib.android.armv8/demo/cxx/ssd_detection
+
+# 下载模型
+wget https://paddlelite-data.bj.bcebos.com/doc_models/ssd_mobilenet_v1.tar.gz
+tar zxvf ssd_mobilenet_v1.tar.gz
+# 转化模型
+paddle_lite_opt --model_dir=./ssd_mobilenet_v1 \
+                --optimize_out_type=naive_buffer \
+                --optimize_out=./ssd_mobilenet_v1_opt
+# 编译预测程序
+make
+# 预测部署
+adb push ssd_detection /data/local/tmp/
+adb push ssd_mobilenet_v1_opt.nb /data/local/tmp/
+adb push test.jpg /data/local/tmp/
+adb push ../../../cxx/lib/libpaddle_light_api_shared.so /data/local/tmp/
+adb shell 'chmod +x /data/local/tmp/ssd_detection'
+# 执行预测
+adb shell 'cd /data/local/tmp && export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/data/local/tmp && ./ssd_detection ssd_mobilenet_v1_opt.nb test.jpg'
+
+# 运行成功后 ，将在控制台输出检测目标的类型、预测概率和坐标
+detection, image size: 935, 1241, detect object: person, score: 0.995543, location: x=187, y=43, width=540, height=591
+detection, image size: 935, 1241, detect object: person, score: 0.929626, location: x=125, y=639, width=577, height=597
+
+# 获得目标检测结果图片，并查看
+adb pull /data/local/tmp/test_ssd_detection_result.jpg ./
+```
+
+#### 口罩检测示例
+
+```shell
+cd inference_lite_lib.android.armv8/demo/cxx/mask_detection
+
+# 准备预测部署文件
+bash prepare.sh
+
+# 执行预测
+cd mask_demo && bash run.sh
+
+# 运行成功后，将在控制台输出如下内容，可以打开test_img_result.jpg图片查看预测结果
+../mask_demo/: 9 files pushed, 0 skipped. 141.6 MB/s (28652282 bytes in 0.193s)
+Load detecion model succeed.
+Detecting face succeed.
+Load classification model succeed.
+detect face, location: x=237, y=107, width=194, height=255, wear mask: 1, prob: 0.987625
+detect face, location: x=61, y=238, width=166, height=213, wear mask: 1, prob: 0.925679
+detect face, location: x=566, y=176, width=245, height=294, wear mask: 1, prob: 0.550348
+write result to file: test_img_result.jpg, success.
+/data/local/tmp/mask_demo/test_img_result.jpg: 1 file pulled, 0 skipped. 13.7 MB/s (87742 bytes in 0.006s)
+```
+
+## C++ 应用开发说明
+
+C++代码调用Paddle-Lite执行预测库仅需以下五步：
+
+(1) 引用头文件和命名空间
+
+```c++
+#include "paddle_api.h"
+using namespace paddle::lite_api;
+```
+
+(2) 指定模型文件，创建Predictor
+
+```C++
+// 1. Set MobileConfig, model_file_path is 
+// the path to model model file. 
+MobileConfig config;
+config.set_model_from_file(model_file_path);
+// 2. Create PaddlePredictor by MobileConfig
+std::shared_ptr<PaddlePredictor> predictor =
+    CreatePaddlePredictor<MobileConfig>(config);
+```
+
+(3) 设置模型输入 (下面以全一输入为例)
+
+```c++
+std::unique_ptr<Tensor> input_tensor(std::move(predictor->GetInput(0)));
+input_tensor->Resize({1, 3, 224, 224});
+auto* data = input_tensor->mutable_data<float>();
+for (int i = 0; i < ShapeProduction(input_tensor->shape()); ++i) {
+  data[i] = 1;
+}
+```
+
+(4) 执行预测
+
+```c++
+predictor->Run();
+```
+
+(5) 获得预测结果
+
+```c++
+std::unique_ptr<const Tensor> output_tensor(
+    std::move(predictor->GetOutput(0)));
+// 转化为数据
+auto output_data=output_tensor->data<float>();
+```
+
+详细的C++ API说明文档位于[C++ API](../api_reference/cxx_api_doc)。更多C++应用预测开发可以参考位于位于[Paddle-Lite-Demo](https://github.com/PaddlePaddle/Paddle-Lite-Demo)的工程示例代码。

docs/quick_start/java_demo.md

+# Java 完整示例
+
+本章节包含2部分内容：(1) [Java 示例程序](java_demo.html#id1)；(2) [Java 应用开发说明](java_demo.html#id8)。
+
+## Java 示例程序
+
+本章节展示的所有Java 示例代码位于 [demo/java](https://github.com/PaddlePaddle/Paddle-Lite/tree/develop/lite/demo/java) 。
+
+### 1. 环境准备
+
+要编译和运行Android Java 示例程序，你需要准备：
+
+1. 一台armv7或armv8架构的安卓手机
+2. 一台装有AndroidStudio的开发机
+
+### 2. 下载预编译的预测库
+
+预测库下载界面位于[Lite预编译库下载](release_lib)，可根据您的手机型号选择合适版本。
+
+以**Android-ARMv8架构**为例，可以下载以下版本：
+
+| Arch  |with_extra|arm_stl|with_cv|下载|
+|:-------:|:-----:|:-----:|:-----:|:-------:|
+|armv8|OFF|c++_static|OFF|[release/v2.6.1](https://paddlelite-data.bj.bcebos.com/Release/2.6.1/Android/inference_lite_lib.android.armv8.gcc.c++_static.CV_OFF.tar.gz)|
+
+**解压后内容结构如下：**
+
+```shell
+inference_lite_lib.android.armv8    Paddle-Lite 预测库
+├── cxx                                 C++ 预测库
+│   ├── include                             C++ 预测库头文件
+│   └── lib                                 C++ 预测库文件
+├── demo                                示例 Demo
+│   ├── cxx                                 C++ 示例 Demo
+│   └── java                                Java 示例 Demo
+│       ├── README.md                           Java Demo Readme 文件
+│       └── android                             Java Andriod Demo
+└── java                                Java 预测库
+    ├── jar 
+    │   └── PaddlePredictor.jar                 Java JAR 包
+    ├── so 
+    │   └── libpaddle_lite_jni.so               Java JNI 动态链接库
+    └── src
+```
+
+### 3. 准备预测部署模型
+
+#### 自动化脚本方法
+
+在Java Andriod Demo文件夹下，我们准备了一个脚本`prepare_demo.bash`，输入手机架构参数例如`arm64-v8a`，即可自动打包所有预测部署所需文件。
+
+```
+cd inference_lite_lib.android.armv8/demo/java/android
+bash prepare_demo.bash arm8
+```
+
+以上命令自动进行了以下三步操作：
+
+1. 拷贝JNI动态链接库`libpaddle_lite_jni.so`到`PaddlePredictor/app/src/main/jniLibs/arm64-v8a/`
+2. 拷贝JAR包`PaddlePredictor.jar` 到 `PaddlePredictor/app/libs/`
+3. 自动下载并解压所有模型文件，拷贝到`PaddlePredictor/app/src/main/assets/`
+
+**注意：** 目前脚本输入手机架构参数仅支持 `arm7 | arm8 | armeabi-v7a | arm64-v8a`。
+
+#### 手动拷贝方法
+
+(1) 把Java JNI动态链接库和Java JAR包拷贝进安卓demo程序文件夹下：
+
+```shell
+cd inference_lite_lib.android.armv8/demo/java/android
+# 请替换<架构文件夹>为手机架构名称，例如 arm64-v8a
+cp ../../../java/so/libpaddle_lite_jni.so PaddlePredictor/app/src/main/jniLibs/<架构文件夹>
+cp ../../../java/jar/PaddlePredictor.jar PaddlePredictor/app/libs/
+```
+
+(2) 下载模型文件
+
+下载以下5个模型，并解压缩到 `PaddlePredictor/app/src/main/assets` 文件夹中。解压之后，assets文件夹里要包含解压后的五个以`.nb`结尾的模型文件，但不需要保存原压缩`.tar.gz`文件。
+
+| 模型| 下载地址|
+| :-- | :-- |
+| inception_v4_simple_opt.nb|  http://paddle-inference-dist.bj.bcebos.com/inception_v4_simple_opt.nb.tar.gz |
+| lite_naive_model_opt.nb | http://paddle-inference-dist.bj.bcebos.com/lite_naive_model_opt.nb.tar.gz |
+| mobilenet_v1_opt.nb | http://paddle-inference-dist.bj.bcebos.com/mobilenet_v1_opt.nb.tar.gz |
+| mobilenet_v2_relu_opt.nb|  http://paddle-inference-dist.bj.bcebos.com/mobilenet_v2_relu_opt.nb.tar.gz |
+| resnet50_opt.nb| http://paddle-inference-dist.bj.bcebos.com/resnet50_opt.nb.tar.gz |
+
+注意：模型要求为naive buffer格式，您可以通过 [opt工具](../user_guides/model_optimize_tool) 将Paddle模型转为naive buffer存储格式。
+
+### 4. 运行预测示例程序
+
+1. 用AndroidStudio打开`inference_lite_lib.android.armv8/demo/java/android/PaddlePredictor`文件夹（需要联网），打开后工程会自动build完成。
+2. 设置手机：手机USB连接电脑，打开`设置 -> 开发者模式 -> USB调试 -> 允许（授权）当前电脑调试手机`，并确认AndroidStudio可以识别接入的手机设备。
+3. 按下AndroidStudio的Run按钮，AndroidStudio会自动编译APP并安装到手机。在手机上打开安装成功的APP，大概会等10秒，然后看到类似以下输出：
+
+```
+lite_naive_model output: 50.213173, -28.872887
+expected: 50.2132, -28.8729
+
+inception_v4_simple test:true
+time: xxx ms
+
+resnet50 test:true
+time: xxx ms
+
+mobilenet_v1 test:true
+time: xxx ms
+
+mobilenet_v2 test:true
+time: xxx ms
+```
+
+该 demo 程序跑我们的 5 个模型，第一个模型结果将真正的头两个数字输出，并在第二行附上期望的正确值。你应该要看到他们的误差小于0.001。后面四个模型如果你看到 `test:true` 字样，说明模型输出通过了我们在 demo 程序里对其输出的测试。time 代表该测试花费的时间。
+
+**注意：** 在这一步中，如果遇到Andriod Studio编译/安装失败等问题，请参考[Andriod示例](../demo_guides/android_app_demo.html#android-demo)中部署方法章节的详细步骤和注意事项。
+
+## Java 应用开发说明
+
+Java代码调用Paddle-Lite执行预测库仅需以下五步：
+
+(1) 设置config信息
+
+```java
+MobileConfig config = new MobileConfig();
+config.setModelDir(modelPath);
+config.setPowerMode(PowerMode.LITE_POWER_HIGH);
+config.setThreads(1);
+```
+
+(2) 创建predictor
+
+```java
+PaddlePredictor predictor = PaddlePredictor.createPaddlePredictor(config);
+```
+
+(3) 设置模型输入 (下面以全一输入为例)
+
+```java
+float[] inputBuffer = new float[10000];
+for (int i = 0; i < 10000; ++i) {
+    inputBuffer[i] = i;
+}
+Tensor input = predictor.getInput(0);
+input.resize({100, 100});
+input.setData(inputBuffer);
+```
+
+(4) 执行预测
+
+```java
+predictor.run();
+```
+
+(5) 获得预测结果
+
+```java
+Tensor output = predictor.getOutput(0);
+```
+
+详细的Java API说明文档位于[Java API](../api_reference/java_api_doc)。更多Java应用预测开发可以参考位于位于[Paddle-Lite-Demo](https://github.com/PaddlePaddle/Paddle-Lite-Demo)的工程示例代码。

docs/quick_start/python_demo.md

+# Python 完整示例
+
+Python仅支持服务器端预测，目前支持 Windows / Mac / Linux (x86 | ARM)。
+
+本章节包含2部分内容：(1) [Python 示例程序](python_demo.html#id1)；(2) [Python 应用开发说明](python_demo.html#id6)。
+
+## Python 示例程序
+
+本章节展示的所有Python 示例代码位于 [demo/python](https://github.com/PaddlePaddle/Paddle-Lite/tree/develop/lite/demo/python) 。
+
+### 1. 环境准备
+
+要编译和运行Android Python 示例程序，你需要准备一台可以编译运行PaddleLite的电脑。
+
+### 2. 安装python预测库
+
+```shell
+python -m pip install paddlelite
+```
+
+**注意：** PyPI源目前仅提供Windows / Mac / Linux (x86) 三个平台pip安装包，如果您需要使用AMRLinux平台的Python预测功能，请参考[源码编译(ARMLinux)](../source_compile/compile_linux)。
+
+### 3. 准备预测部署模型
+
+(1) 模型下载：下载[mobilenet_v1](http://paddle-inference-dist.bj.bcebos.com/mobilenet_v1.tar.gz)模型后解压，得到Paddle非combined形式的模型，位于文件夹 `mobilenet_v1` 下。可通过模型可视化工具[Netron](https://lutzroeder.github.io/netron/)打开文件夹下的`__model__`文件，查看模型结构。
+
+
+```shell
+wget http://paddle-inference-dist.bj.bcebos.com/mobilenet_v1.tar.gz
+tar zxf mobilenet_v1.tar.gz
+```
+
+(2) 模型转换：Paddle的原生模型需要经过[opt](../user_guides/model_optimize_tool)工具转化为Paddle-Lite可以支持的naive_buffer格式。
+
+- Linux环境：通过pip安装paddlelite，即可获得paddle_lite_opt命令工具
+
+  ```shell
+  paddle_lite_opt --model_dir=./mobilenet_v1  \
+                  --optimize_out=mobilenet_v1_opt \
+                  --optimize_out_type=naive_buffer \
+                  --valid_targets=x86
+  ```
+
+- windows环境：windows 暂不支持命令行方式直接运行模型转换器，需要编写python脚本
+
+  ```python
+  import paddlelite.lite as lite
+
+  a=lite.Opt()
+  # 非combined形式
+  a.set_model_dir("D:\\YOU_MODEL_PATH\\mobilenet_v1")
+
+  # conmbined形式
+  # a.set_model_file("D:\\YOU_MODEL_PATH\\mobilenet_v1\\__model__")
+  # a.set_param_file("D:\\YOU_MODEL_PATH\\mobilenet_v1\\__params__")
+
+  a.set_optimize_out("mobilenet_v1_opt")
+  a.set_valid_places("x86")
+
+  a.run()
+  ```
+
+- MAC环境: paddle_lite_opt工具使用方式同Linux。
+
+以上命令执行成功之后将在同级目录生成名为`mobilenet_v1_opt.nb`的优化后模型文件。
+
+### 4. 下载和运行预测示例程序
+
+从[demo/python](https://github.com/PaddlePaddle/Paddle-Lite/tree/develop/lite/demo/python)下载预测示例文件`mobilenetv1_light_api.py`和`mobilenetv1_full_api.py`，并运行Python预测程序。
+
+```shell
+# light api的输入为优化后模型文件mobilenet_v1_opt.nb
+python mobilenetv1_light_api.py --model_dir=mobilenet_v1_opt.nb
+
+# full api的输入为优化千的模型文件夹mobilenet_v1
+python mobilenetv1_full_api.py --model_dir=./mobilenet_v1
+
+# 运行成功后，将在控制台输出如下内容
+[1L, 1000L]
+[0.00019130950386170298, 0.0005920541007071733, 0.00011230241216253489, 6.27333574811928e-05, 0.0001275067188544199, 0.0013214796781539917, 3.138116153422743e-05, 6.52207963867113e-05, 4.780858944286592e-05, 0.0002588215284049511]
+```
+## Python 应用开发说明
+
+Python代码调用Paddle-Lite执行预测库仅需以下六步：
+
+(1) 设置config信息
+```python
+from paddlelite.lite import *
+
+config = MobileConfig()
+config.set_model_from_file(/YOU_MODEL_PATH/mobilenet_v1_opt.nb)
+```
+
+(2) 创建predictor
+
+```python
+predictor = create_paddle_predictor(config)
+```
+
+(3) 从图片读入数据
+
+```python
+image = Image.open('./example.jpg')
+resized_image = image.resize((224, 224), Image.BILINEAR)
+image_data = np.array(resized_image).flatten().tolist()
+```
+
+(4) 设置输入数据
+
+```python
+input_tensor = predictor.get_input(0)
+input_tensor.resize([1, 3, 224, 224])
+input_tensor.set_float_data(image_data)
+```
+
+(5) 执行预测
+```python
+predictor.run()
+```
+
+(6) 得到输出数据
+```python
+output_tensor = predictor.get_output(0)
+print(output_tensor.shape())
+print(output_tensor.float_data()[:10])
+```
+
+详细的Python API说明文档位于[Python API](../api_reference/python_api_doc)。更多Python应用预测开发可以参考位于位于[Paddle-Lite-Demo](https://github.com/PaddlePaddle/Paddle-Lite-Demo)的工程示例代码。

docs/user_guides/release_lib.md → docs/quick_start/release_lib.md

 
-# 预编译库下载
+# Lite 预编译库下载
 
 ## 编译版本介绍
 
@@ -7,7 +7,7 @@
 - arm_os=`android\ios\armlinux`    安装平台，支持的arm端移动平台包括 `ios`、`armlinux`和`android`
 - toolchain=`gcc/clang`                                 源码编译时的编译器，默认为`gcc`编译器
 - android_stl=`c++_static/c++_shared`     Lite预测库链接STL库的方式，支持静态或动态链接
-- with_extra=`ON/OFF`                                     是否编译全量OP，OFF时只编译CV相关基础OP，[参数详情](./Compile/library)
+- with_extra=`ON/OFF`                                     是否编译全量OP，OFF时只编译CV相关基础OP，[参数详情](../source_compile/library)
 - with_cv=`ON/OFF`                                          是否编译编译Paddle-Lite CV 相关API
 
 
@@ -71,10 +71,14 @@ pip install paddlelite
 ## 对应源码编译方法
 
 - [opt源码编译](../user_guides/model_optimize_tool.html#opt)
-- [Android源码编译](./source_compile.html#paddlelite)
-- [iOS源码编译](./source_compile.html#paddlelite)
-- [ArmLinux源码编译](./source_compile.html#paddlelite)
+- [Android源码编译](../source_compile/compile_andriod)
+- [iOS源码编译](../source_compile/compile_ios)
+- [ArmLinux源码编译](../source_compile/compile_linux)
 - [x86源码编译](../demo_guides/x86)
 - [opencl源码编译](../demo_guides/opencl)
 - [CUDA源码编译](../demo_guides/cuda)
 - [FPGA源码编译](../demo_guides/fpga)
+- [华为NPU源码编译](../demo_guides/npu)
+- [百度XPU源码编译](../demo_guides/baidu_xpu)
+- [Rockchip NPU源码编译](../demo_guides/rockchip_npu)
+- [MediaTek APU源码编译](../demo_guides/mediatek_apu)

docs/user_guides/tutorial.md → docs/quick_start/tutorial.md

-# 使用流程
+# Lite 预测流程
 
 Lite是一种轻量级、灵活性强、易于扩展的高性能的深度学习预测框架，它可以支持诸如ARM、OpenCL、NPU等等多种终端，同时拥有强大的图优化及预测加速能力。如果您希望将Lite框架集成到自己的项目中，那么只需要如下几步简单操作即可。
 
@@ -9,9 +9,9 @@ Lite框架目前支持的模型结构为[PaddlePaddle](https://github.com/Paddle
 
 ## 二. 模型优化
 
-Lite框架拥有强大的加速、优化策略及实现，其中包含诸如量化、子图融合、Kernel优选等等优化手段，为了方便您使用这些优化策略，我们提供了[opt](model_optimize_tool)帮助您轻松进行模型优化。优化后的模型更轻量级，耗费资源更少，并且执行速度也更快。
+Lite框架拥有强大的加速、优化策略及实现，其中包含诸如量化、子图融合、Kernel优选等等优化手段，为了方便您使用这些优化策略，我们提供了[opt](../user_guides/model_optimize_tool)帮助您轻松进行模型优化。优化后的模型更轻量级，耗费资源更少，并且执行速度也更快。
 
-opt的详细介绍，请您参考 [模型优化方法](model_optimize_tool) 。
+opt的详细介绍，请您参考 [模型优化方法](../user_guides/model_optimize_tool)。
 
 下载opt工具后执行以下代码：
 
@@ -45,8 +45,8 @@ $ ./opt \
 
 ## 四. Lite API
 
-为了方便您的使用，我们提供了C++、Java、Python三种API，并且提供了相应的api的完整使用示例:[C++完整示例](../demo_guides/cpp_demo)、[Java完整示例](../demo_guides/java_demo)、[Python完整示例](../demo_guides/cuda)，您可以参考示例中的说明快速了解C++/Java/Python的API使用方法，并集成到您自己的项目中去。需要说明的是，为了减少第三方库的依赖、提高Lite预测框架的通用性，在移动端使用Lite API您需要准备Naive Buffer存储格式的模型，具体方法可参考第2节`模型优化`。
+为了方便您的使用，我们提供了C++、Java、Python三种API，并且提供了相应的api的完整使用示例:[C++完整示例](cpp_demo)、[Java完整示例](java_demo)、[Python完整示例](python_demo)，您可以参考示例中的说明快速了解C++/Java/Python的API使用方法，并集成到您自己的项目中去。需要说明的是，为了减少第三方库的依赖、提高Lite预测框架的通用性，在移动端使用Lite API您需要准备Naive Buffer存储格式的模型，具体方法可参考第2节`模型优化`。
 
 ## 五. 测试工具
 
-为了使您更好的了解并使用Lite框架，我们向有进一步使用需求的用户开放了 [Debug工具](debug) 和 [Profile工具](debug)。Lite Model Debug Tool可以用来查找Lite框架与PaddlePaddle框架在执行预测时模型中的对应变量值是否有差异，进一步快速定位问题Op，方便复现与排查问题。Profile Monitor Tool可以帮助您了解每个Op的执行时间消耗，其会自动统计Op执行的次数，最长、最短、平均执行时间等等信息，为性能调优做一个基础参考。您可以通过 [相关专题](debug) 了解更多内容。
+为了使您更好的了解并使用Lite框架，我们向有进一步使用需求的用户开放了 [Debug工具](../user_guides/debug) 和 [Profile工具](../user_guides/debug)。Lite Model Debug Tool可以用来查找Lite框架与PaddlePaddle框架在执行预测时模型中的对应变量值是否有差异，进一步快速定位问题Op，方便复现与排查问题。Profile Monitor Tool可以帮助您了解每个Op的执行时间消耗，其会自动统计Op执行的次数，最长、最短、平均执行时间等等信息，为性能调优做一个基础参考。您可以通过 [相关专题](../user_guides/debug) 了解更多内容。

docs/source_compile/compile_andriod.md

+
+# 源码编译 (Android) 
+
+Paddle Lite提供了Android平台的官方Release预测库下载，我们优先推荐您直接下载[Paddle Lite预编译库](../quick_start/release_lib.html#android-toolchain-gcc)。
+
+**注意：** 以下编译方法只适用于release/v2.6.0及之后版本(包括 v2.6.0)。release/v2.3及之前版本(包括 v2.3)请参考[release/v2.3源码编译方法](v2.3_compile.md)。
+
+如果您还没有配置好Andriod交叉编译环境，请先根据[编译环境准备](compile_env)中的内容，根据您的开发环境安装编译Android预测库所需的编译环境。运行编译脚本之前，请先检查环变量`NDK_ROOT`指向正确的Andriod NDK安装路径，之后可以下载并编译 Paddle-Lite源码。
+
+```shell
+# 1. 下载Paddle-Lite源码 并切换到release分支
+git clone https://github.com/PaddlePaddle/Paddle-Lite.git
+cd Paddle-Lite && git checkout release/v2.6
+
+# (可选) 删除此目录，编译脚本会自动从国内CDN下载第三方库文件
+# rm -rf third-party
+
+# 2. 编译Paddle-Lite Android预测库 (armv8, gcc编译, 静态链接ndk stl)
+./lite/tools/build_android.sh
+```
+
+**提示：** 编译过程中，如出现源码编译耗时过长，通常是第三方库下载过慢或失败导致。请在git clone完Paddle-Lite仓库代码后，手动删除本地仓库根目录下的third-party目录。编译脚本会自动下载存储于国内 CDN 的第三方依赖的压缩包，节省从git repo同步第三方库代码的时间。
+
+### 编译结果
+
+位于`Paddle-Lite/build.lite.android.armv8.gcc/inference_lite_lib.android.armv8`:
+
+```shell
+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                       Java JAR 包
+│   ├── so
+│   │   └── libpaddle_lite_jni.so                     Java JNI 动态链接库
+│   └── src
+│
+└── demo                                              C++ 和 Java 示例代码
+    ├── cxx                                           C++ 预测库demo
+    └── java                                          Java 预测库demo
+```
+
+### 编译命令
+
+- 默认编译方法: (armv8, gcc, c++_static)                                           
+```                                        shell
+./lite/tools/build_android.sh
+```
+
+- 打印 help 信息：
+
+```shell
+./lite/tools/build_android.sh help
+```
+
+- 其他可选编译命令：
+
+```shell
+--arch: (armv8|armv7)        arm版本，默认为armv8
+--toolchain: (gcc|clang)     编译器类型，默认为gcc
+--android_stl: (c++_static|c++_shared)   NDK stl库链接方法，默认为静态链接c++_static
+--with_java: (OFF|ON)        是否编译Java预测库, 默认为 ON
+--with_cv: (OFF|ON)          是否编译CV相关预处理库, 默认为 OFF
+--with_log: (OFF|ON)         是否输出日志信息, 默认为 ON
+--with_exception: (OFF|ON)   是否在错误发生时抛出异常，默认为 OFF   
+--with_extra: (OFF|ON)       是否编译OCR/NLP模型相关kernel&OP，默认为OFF，只编译CV模型相关kernel&OP
+```
+
+- 裁剪预测库方法（只编译模型中的kernel&OP，降低预测库体积），详情请参考:  [裁剪预测库](library_tailoring)
+
+```shell
+./lite/tools/build_android.sh --with_strip=ON --opt_model_dir=%YourOptimizedModelDir%
+
+# 编译选项说明
+--with_strip: (OFF|ON)   是否根据输入模型裁剪预测库，默认为OFF
+--opt_model_dir          输入模型的绝对路径，需要为opt转化之后的模型
+```
+
+
+
+- 编译 Android npu 预测库方法，详情请参考：[PaddleLite使用华为NPU预测部署](../demo_guides/npu)
+
+```shell
+./lite/tools/build_android.sh --with_huawei_kirin_npu=ON \
+                              --huawei_kirin_npu_sdk_root=%YourNpuSdkPath%
+
+# 编译选项说明
+--with_huawei_kirin_npu: (OFF|ON)   是否编译编译huawei_kirin_npu 的预测库，默认为OFF
+--huawei_kirin_npu_sdk_root         Huawei HiAi DDK文件的绝对路径，可从以下网址下载 
+                                    https://developer.huawei.com/consumer/cn/hiai/
+```
+
+
+- 编译Android opencl 预测库方法，详情请参考：[PaddleLite使用OpenCL预测部署](../demo_guides/opencl)
+
+```shell
+./lite/tools/build_android.sh --with_opencl=ON
+
+# 编译选项说明
+--with_opencl: (OFF|ON);  是否编译opencl预测库, 默认为 OFF
+```

docs/user_guides/source_compile.md → docs/source_compile/compile_env.md

 
-# 源码编译方法
+# 源码编译环境准备
 
-PaddleLite已经提供官方Release预测库下载，请参考[文档](release_lib)。
+Paddle Lite提供了Android/iOS/X86平台的官方Release预测库下载，如果您使用的是这三个平台，我们优先推荐您直接下载[Paddle Lite预编译库](../quick_start/release_lib)。
 
-PaddleLite 提供了移动端的一键源码编译脚本 `lite/tools/build.sh`，编译流程如下：
+您也可以根据目标平台选择对应的源码编译方法，Paddle Lite提供了源码编译脚本，位于`lite/tools/`文件夹下，只需要“准备环境”和“调用编译脚本”两个步骤即可一键编译得到目标平台的Paddle Lite预测库。
 
-1. 环境准备（选择其一）：Docker交叉编译环境、Linux交叉编译环境
-2. 编译：调用`build.sh`脚本一键编译
+目前支持四种编译开发环境：
 
-## 一、环境准备
+1. [Docker开发环境](compile_env.html#docker)
+2. [Linux开发环境](compile_env.html#linux)
+3. [Mac OS开发环境](compile_env.html#mac-os)
+4. [Windows开发环境](compile_env.html#windows)
 
-目前支持四种编译的环境：
+源码编译方法支持如下平台：
 
-1. Docker 容器环境，
-2. Linux（推荐 Ubuntu 16.04）环境，
-3. Mac OS 环境，
-4. [Windows 环境](../demo_guides/x86.html#windows)
+- [Android源码编译](../source_compile/compile_andriod)
+- [iOS源码编译](../source_compile/compile_ios)
+- [ArmLinux源码编译](../source_compile/compile_linux)
+- [x86源码编译](../demo_guides/x86)
+- [OpenCL源码编译](../demo_guides/opencl)
+- [CUDA源码编译](../demo_guides/cuda)
+- [FPGA源码编译](../demo_guides/fpga)
+- [华为NPU源码编译](../demo_guides/npu)
+- [百度XPU源码编译](../demo_guides/baidu_xpu)
+- [Rockchip NPU源码编译](../demo_guides/rockchip_npu)
+- [MediaTek APU源码编译](../demo_guides/mediatek_apu)
+- [模型优化工具opt源码编译](../user_guides/model_optimize_tool.html#opt)
 
-### 1、 Docker开发环境
+## 1. Docker开发环境
 
-[Docker](https://www.docker.com/) 是一个开源的应用容器引擎, 使用沙箱机制创建独立容器，方便运行不同程序。Docker初学者可以参考[Docker使用方法](https://thenewstack.io/docker-station-part-one-essential-docker-concepts-tools-terminology/)正确安装Docker。
+[Docker](https://www.docker.com/) 是一个开源的应用容器引擎, 使用沙箱机制创建独立容器，方便运行不同程序。Lite的Docker镜像基于Ubuntu 16.04，镜像中包含了开发Andriod/Linux等平台要求的软件依赖与工具。
 
-#### 准备Docker镜像
-
-有两种方式准备Docker镜像，推荐从Dockerhub直接拉取Docker镜像
+(1) 准备Docker镜像：有两种方式准备Docker镜像，推荐从Dockerhub直接拉取Docker镜像
 
 ```shell
 # 方式一：从Dockerhub直接拉取Docker镜像
@@ -40,9 +48,7 @@ docker build -t paddlepaddle/paddle-lite .
 # 镜像编译成功后，可用`docker images`命令，看到`paddlepaddle/paddle-lite`镜像。
 ```
 
-#### 进入Docker容器
-
-在拉取Paddle-Lite仓库代码的上层目录，执行如下代码，进入Docker容器：
+(2) 启动Docker容器：在拉取Paddle-Lite仓库代码的上层目录，执行如下代码，进入Docker容器：
 
 ```shell
 docker run -it \
@@ -52,9 +58,9 @@ docker run -it \
   paddlepaddle/paddle-lite /bin/bash
 ```
 
-该命令的含义：将容器命名为`paddlelite_docker`即`<container-name>`，将当前目录下的`Paddle-Lite`文件夹挂载到容器中的`/Paddle-Lite`这个根目录下，并进入容器中。至此，完成Docker环境的准备。
+该命令的含义：将容器命名为`paddlelite_docker`即`<container-name>`，将当前目录下的`Paddle-Lite`文件夹挂载到容器中的`/Paddle-Lite`这个根目录下，并进入容器中。
 
-#### Docker常用命令
+Docker初学者可以参考[Docker使用方法](https://thenewstack.io/docker-station-part-one-essential-docker-concepts-tools-terminology/)正确安装Docker。Docker常用命令参考如下：
 
 ```shell
 # 退出容器但不停止/关闭容器：键盘同时按住三个键：CTRL + q + p
@@ -75,19 +81,16 @@ docker restart <container-name>
 docker rm <container-name>
 ```
 
-### 2、Linux 开发环境
+## 2. Linux开发环境
 
-#### Android
-
-##### 交叉编译环境要求
+### 准备Android交叉编译环境
 
+交叉编译环境要求：
 - gcc、g++、git、make、wget、python、adb
 - Java environment
 - cmake（建议使用3.10或以上版本）
 - Android NDK (建议ndk-r17c)
 
-##### 具体步骤
-
 安装软件部分以 Ubuntu 为例，其他 Linux 发行版类似。
 
 ```shell
@@ -118,19 +121,16 @@ echo "export NDK_ROOT=/opt/android-ndk-r17c" >> ~/.bashrc
 source ~/.bashrc
 ```
 
-#### ARM Linux
+### 准备ARM Linux编译环境
 
 适用于基于 ARMv8 和 ARMv7 架构 CPU 的各种开发板，例如 RK3399，树莓派等，目前支持交叉编译和本地编译两种方式，对于交叉编译方式，在完成目标程序编译后，可通过 scp 方式将程序拷贝到开发板运行。
 
-##### 交叉编译
-
-###### 编译环境要求
+#### 交叉编译ARM Linux
 
+编译环境要求
 - gcc、g++、git、make、wget、python、scp
 - cmake（建议使用3.10或以上版本）
 
-###### 具体步骤
-
 安装软件部分以 Ubuntu 为例，其他 Linux 发行版类似。
 
 ```shell
@@ -153,15 +153,12 @@ wget -c https://mms-res.cdn.bcebos.com/cmake-3.10.3-Linux-x86_64.tar.gz && \
     ln -s /opt/cmake-3.10/bin/ccmake /usr/bin/ccmake
 ```
 
-##### 本地编译（直接在RK3399或树莓派上编译）
-
-###### 编译环境要求
+#### 本地编译ARM Linux（直接在RK3399或树莓派上编译）
 
+编译环境要求
 - gcc、g++、git、make、wget、python、pip、python-dev、patchelf
 - cmake（建议使用3.10或以上版本）
 
-###### 具体步骤
-
 安装软件部分以 Ubuntu 为例，其他 Linux 发行版本类似。
 
 ```shell
@@ -183,17 +180,14 @@ sudo make install
 
 至此，完成 Linux 交叉编译环境的准备。
 
-### 3、Mac OS 开发环境
-
-#### 交叉编译环境要求
+## 3. Mac OS开发环境
 
+交叉编译环境要求
 - gcc、git、make、curl、unzip、java
 - cmake（Android编译请使用3.10版本，IOS编译请使用3.15版本）
 - 编译Android: Android NDK (建议ndk-r17c)
 - 编译IOS: XCode(Version 10.1)
 
-#### 具体步骤
-
 ```bash
 # 1. Install basic software
 brew install  curl gcc git make unzip wget
@@ -231,54 +225,20 @@ brew cask install java
 # sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
 ```
 
-至此，完成 Mac 交叉编译环境的准备。
-
-**注意**: Mac上编译Paddle-Lite的full_publish版本时，Paddle-Lite所在路径中不可以含有中文字符
-
-## 二、编译PaddleLite
-
-`develop分支`和`release/v2.6.0`之后版本的源码编译请参考以下说明，release/v2.3之前版本（包括v2.3）源码编译请参考[release/v2.3源码编译方法](./Compile/v2.3_compile)。
-
-### Android 预测库编译方法
-
-Paddle-Lite支持在 “Docker 环境、Linux 环境、Mac 环境” 源码编译Android 预测库
-
-**编译方法参见**：[Android预测库编译方法](./Compile/Android)
+**注意**: Mac上编译Paddle-Lite的full_publish版本时，Paddle-Lite所在路径中不可以含有中文字符。
 
 
-### iOS 预测库编译方法
+## 4. Windows开发环境
 
-Paddle-Lite只支持在 “Mac 环境” 源码编译iOS 预测库
-
-**编译方法参见**：[iOS预测库编译方法](./Compile/iOS)
-
-
-### Linux 预测库编译方法
-
-**编译方法参见**：[Linux预测库编译方法](./Compile/Linux)
-
-
-### 加速第三方依赖库的下载
-
-如出现源码编译耗时过长，一般是第三方库下载过慢或失败导致：
-
-- 移动端相关编译所需的第三方库均位于 `<PaddleLite>/third-party` 目录下，默认编译过程中，会利用`git submodule update --init --recursive`链上相关的第三方依赖的仓库。
-
-- 为加速`full_publish`、`test`编译模式中对`protobuf`等第三方依赖的下载，`build.sh` 和 `ci_build.sh`支持了从国内 CDN 下载第三方依赖的压缩包。
-
-可使用本节方法加速第三方库下载过程，以加速编译：
-
-- **加速方法**：`git clone`完`Paddle-Lite`仓库代码后，手动删除本地仓库根目录下的`third-party`目录：
-
-```shell
-git clone https://github.com/PaddlePaddle/Paddle-Lite.git
-git checkout <release-version-tag>
-cd Paddle-Lite
-rm -rf third-party
-```
+编译环境需求，目前Windows暂不支持GPU编译，仅支持[X86平台](../demo_guides/x86.html#windows)预测库编译。
 
-之后再根据本文档，进行后续编译时，便会忽略第三方依赖对应的`submodule`，改为直接下载第三方压缩包。
+- Windows 10 专业版
+- *Python 版本 2.7/3.5.1+ (64 bit)*
+- *pip 或 pip3 版本 9.0.1+ (64 bit)*
+- *Visual Studio 2015 Update3*
 
-### 源码编译选项说明
+环境准备步骤为：
 
-源码编译中涉及的编译选项，请参考[编译选项说明](./Compile/compile_options.md)
+1. cmake 需要3.15版本, 可在官网[下载](https://cmake.org/download/)，并添加到环境变量中。
+2. python 需要2.7 及以上版本, 可在官网[下载](https://www.python.org/download/releases/2.7/)。
+3. git可以在官网[下载](https://gitforwindows.org/)，并添加到环境变量中

docs/user_guides/Compile/iOS.md → docs/source_compile/compile_ios.md

 
-# 编译iOS预测库
+# 源码编译 (iOS)
 
-**注意：本编译方法只适用于release/v2.6.0之后版本（包括 v2.6.0)**
+Paddle Lite提供了iOS平台的官方Release预测库下载，我们优先推荐您直接下载[Paddle Lite预编译库](../quick_start/release_lib.html#ios)。
 
-安装了iOS的编译环境，可以下载并编译 Paddle-Lite源码
+**注意：** 以下编译方法只适用于release/v2.6.0及之后版本(包括 v2.6.0)。release/v2.3及之前版本(包括 v2.3)请参考[release/v2.3源码编译方法](v2.3_compile.md)。
+
+如果您还没有配置好iOS编译环境，请先根据[编译环境准备](compile_env.html#mac-os)中的内容，根据您的开发环境安装编译iOS预测库所需的编译环境。
 
 ```shell
 # 1. 下载Paddle-Lite源码 并切换到release分支
 git clone https://github.com/PaddlePaddle/Paddle-Lite.git
-cd Paddle-Lite && git checkout release/v2.6.0
+cd Paddle-Lite && git checkout release/v2.6
+
+# (可选) 删除此目录，编译脚本会自动从国内CDN下载第三方库文件
+# rm -rf third-party
 
-# 2. 编译Paddle-Lite Android预测库 (armv8, gcc编译, 静态链接ndk stl)
+# 2. 编译Paddle-Lite iOS预测库 (armv8)
 ./lite/tools/build_ios.sh
 ```
 
-
+**提示：** 编译过程中，如出现源码编译耗时过长，通常是第三方库下载过慢或失败导致。请在git clone完Paddle-Lite仓库代码后，手动删除本地仓库根目录下的third-party目录。编译脚本会自动下载存储于国内 CDN 的第三方依赖的压缩包，节省从git repo同步第三方库代码的时间。
 
 ### 编译结果
 
 位于`Paddle-Lite/build.ios.ios64.armv8/inference_lite_lib.ios64.armv8`:
 
 ```shell
-inference_lite_lib.ios64.armv8                iOS预测库和头文件
-|-- 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
+inference_lite_lib.ios64.armv8
+├── 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
 ```
 
-
-
 ### 编译命令
 
 - 默认编译方法: (armv8)                                           
-```                                        shell
+```shell
 ./lite/tools/build_ios.sh
 ```
 
@@ -55,16 +58,16 @@ inference_lite_lib.ios64.armv8                iOS预测库和头文件
 --arch: (armv8|armv7)        arm版本，默认为armv8
 --with_cv: (OFF|ON)          是否编译CV相关预处理库, 默认为 OFF
 --with_log: (OFF|ON)         是否输出日志信息, 默认为 ON
---with_extra: (OFF|ON)       是否编译OCR或NLP相关模型的kernel&OP，默认为OFF，只编译CV模型相关kernel&OP
+--with_exception: (OFF|ON)   是否在错误发生时抛出异常，默认为 OFF
+--with_extra: (OFF|ON)       是否编译OCR/NLP模型相关kernel&OP，默认为OFF，只编译CV模型相关kernel&OP
 ```
 
-- 裁剪预测库方法（只编译模型中的kernel&OP，降低预测库体积）:
+- 裁剪预测库方法（只编译模型中的kernel&OP，降低预测库体积），详情请参考:  [裁剪预测库](library_tailoring)
 
 ```shell
-./lite/tools/build_ios.sh --with_strip=ON --opt_model_dir=YourOptimizedModelDir
-```
-```shell
+./lite/tools/build_ios.sh --with_strip=ON --opt_model_dir=%YourOptimizedModelDir%
+
+# 编译选项说明
 --with_strip: (OFF|ON);   是否根据输入模型裁剪预测库，默认为OFF
 --opt_model_dir:          输入模型的绝对路径，需要为opt转化之后的模型
 ```
-详情参考:  [裁剪预测库](https://paddle-lite.readthedocs.io/zh/latest/user_guides/library_tailoring.html)

docs/user_guides/Compile/Linux.md → docs/source_compile/compile_linux.md

 
-# 编译Linux预测库
+# 源码编译 (ARMLinux)
 
-**注意：本编译方法只适用于release/v2.6.0之后版本（包括 v2.6.0)**
-**注意：本编译方法暂时只适用于ARM的设备**
+**注意：** 以下编译方法只适用于release/v2.6.0及之后版本(包括 v2.6.0)。release/v2.3及之前版本(包括 v2.3)请参考[release/v2.3源码编译方法](v2.3_compile.md)。
 
-安装了ArmLinux的编译环境，可以下载并编译 Paddle-Lite源码
+**注意：** 本编译方法暂时只适用于ARM的设备。
+
+
+如果您还没有配置好ArmLinux编译环境，请先根据[编译环境准备](compile_env)中的内容，根据您的开发环境安装编译ArmLinux预测库所需的编译环境。
 
 ```shell
 # 1. 下载Paddle-Lite源码 并切换到release分支
 git clone https://github.com/PaddlePaddle/Paddle-Lite.git
 cd Paddle-Lite && git checkout release/v2.6
 
-# 2. 编译Paddle-Lite Android预测库 (armv8, gcc编译)
+# (可选) 删除此目录，编译脚本会自动从国内CDN下载第三方库文件
+# rm -rf third-party
+
+# 2. 编译Paddle-Lite Linux(arm)预测库 (armv8, gcc编译)
 ./lite/tools/build_linux.sh
 ```
 
+**提示：** 编译过程中，如出现源码编译耗时过长，通常是第三方库下载过慢或失败导致。请在git clone完Paddle-Lite仓库代码后，手动删除本地仓库根目录下的third-party目录。编译脚本会自动下载存储于国内 CDN 的第三方依赖的压缩包，节省从git repo同步第三方库代码的时间。
 
 ### 编译结果
 
 位于 `Paddle-Lite/build.lite.linux.armv8.gcc/inference_lite_lib.armlinux.armv8` :
 
 ```shell
-inference_lite_lib.armlinux.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++动态库
-|
-|-- demo                          
-|   `-- python                              python预测库demo
-|
-|-- python                                  Python预测库(需要打开with_python选项)
-|   |-- install
-|   |   `-- dist
-|   |       `-- paddlelite-*.whl            python whl包 
-|   |-- lib
-|       `-- lite.so                         python预测库   
+
+inference_lite_lib.armlinux.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++ 动态库
+├── demo
+│   └── python                                    Python 预测库demo
+│
+└── python                                        Python 预测库(需要打开with_python选项)
+    ├── install
+    │   └── dist
+    │       └── paddlelite-*.whl                  Python whl包
+    └── lib
+        └── lite.so                               Python 预测库
 ```
 
 
@@ -65,37 +71,36 @@ inference_lite_lib.armlinux.armv8/
 ```shell
 --arch: (armv8|armv7|armv7hf)   arm版本，默认为armv8
 --toolchain: (gcc|clang)        编译器类型，默认为gcc
---with_extra: (OFF|ON)          是否编译OCR或NLP相关模型的kernel&OP，默认为OFF，只编译CV模型相关kernel&OP
+--with_extra: (OFF|ON)          是否编译OCR/NLP模型相关kernel&OP，默认为OFF，只编译CV模型相关kernel&OP
 --with_python: (OFF|ON)         是否编译python预测库, 默认为 OFF
+--python_version: (2.7|3.5|3.7) 编译whl的Python版本，默认为 None
 --with_cv: (OFF|ON)             是否编译CV相关预处理库, 默认为 OFF
 --with_log: (OFF|ON)            是否输出日志信息, 默认为 ON
+--with_exception: (OFF|ON)      是否在错误发生时抛出异常，默认为 OFF   
 ```
 **注意：with_python现在仅支持armlinux的本地编译，尚不支持docker环境和ubuntu环境**
 
-- 裁剪预测库方法（只编译模型中的kernel&OP，降低预测库体积）:
+- 裁剪预测库方法（只编译模型中的kernel&OP，降低预测库体积），详情请参考:  [裁剪预测库](library_tailoring)
 
 ```shell
 ./lite/tools/build_linux.sh --with_strip=ON --opt_model_dir=YourOptimizedModelDir
-```
-```shell
+
+# 编译选项说明
 --with_strip: (OFF|ON);   是否根据输入模型裁剪预测库，默认为OFF
 --opt_model_dir:          输入模型的绝对路径，需要为opt转化之后的模型
 ```
-详情请参考:  [裁剪预测库](https://paddle-lite.readthedocs.io/zh/latest/user_guides/library_tailoring.html)
 
-
-- 使用 rockchip npu 方法：
+- 编译 Rockchip NPU 预测库方法，详情请参考：[PaddleLite使用RK NPU预测部署](../demo_guides/rockchip_npu)
 
 ```shell
---with_rockchip_npu: (OFF|ON);   是否编译编译 huawei_kirin_npu 的预测库，默认为OFF
---rockchip_npu_sdk_root:     `rockchip_npu DDK`文件的绝对路径
+--with_rockchip_npu: (OFF|ON)    是否编译编译 huawei_kirin_npu 的预测库，默认为OFF
+--rockchip_npu_sdk_root          Rockchip NP DDK文件的绝对路径
 ```
-详情请参考：[PaddleLite使用RK NPU预测部署](https://paddle-lite.readthedocs.io/zh/latest/demo_guides/rockchip_npu.html)
 
-- 使用 baidu xpu 方法：
+
+- 编译 Baidu XPU 预测库方法, 详情请参考：[PaddleLite使用百度XPU预测部署](../demo_guides/baidu_xpu)
 
 ```shell
---with_baidu_xpu: (OFF|ON);   是否编译编译 baidu_xpu 的预测库，默认为OFF
---baidu_xpu_sdk_root:     `baidu_xpu DDK`文件的绝对路径
+--with_baidu_xpu: (OFF|ON)    是否编译编译 baidu_xpu 的预测库，默认为OFF
+--baidu_xpu_sdk_root          Baidu XPU DDK文件的绝对路径
 ```
-详情请参考：[PaddleLite使用百度XPU预测部署](https://paddle-lite.readthedocs.io/zh/latest/demo_guides/baidu_xpu.html)

docs/user_guides/Compile/compile_options.md → docs/source_compile/compile_options.md

 # 编译选项说明
 
+
 | 编译选项 |  说明  | 默认值 |
 | :-- |  :-- |--: |
 | LITE_WITH_LOG |  是否输出日志信息 | ON |
-| LITE_WITH_EXCEPTION | 是否在错误发生时，抛出异常 | OFF |
-| LITE_WITH_TRAIN |  打开[模型训练功能](../../demo_guides/cpp_train_demo.html)，支持移动端模型训练 | OFF |
+| LITE_WITH_EXCEPTION | 是否在错误发生时抛出异常 | OFF |
+| LITE_WITH_TRAIN |  打开[模型训练功能](../demo_guides/cpp_train_demo.html)，支持移动端模型训练 | OFF |
 | LITE_BUILD_EXTRA |  编译[全量预测库](library.html)，包含更多算子和模型支持 | OFF |
-| LITE_BUILD_TAILOR | 编译时[根据模型裁剪预测库](../library_tailoring.html)，缩小预测库大小 | OFF |
+| LITE_BUILD_TAILOR | 编译时[根据模型裁剪预测库](library_tailoring.html)，缩小预测库大小 | OFF |
 | WITH_SYSTEM_BLAS |  编译时强制使用reference BLAS |  OFF |
 
 ### 轻量级编译选项
@@ -24,7 +25,7 @@
 
 | 编译选项 |  说明  | 默认值 |
 | :-- |  :-- | --: |
-| LITE_WITH_PROFILE |  编译[Profiler工具](../debug.html)，用于CPU上kernel耗时统计 | OFF |
+| LITE_WITH_PROFILE |  编译[Profiler工具](../user_guides/debug.html)，用于CPU上kernel耗时统计 | OFF |
 | LITE_WITH_PRECISION_PROFILE |  开启Profiler工具的模型精度分析功能 | OFF |
 | WITH_TESTING |  编译Lite单测模块 | OFF |
 
@@ -33,25 +34,25 @@
 | 编译选项 |  说明  | 适用平台 | 默认值 |
 | :-- |  :-- | --: | --: |
 | LITE_WITH_ARM |  编译支持Andriod或ARMLinux平台预测库 | Andriod / ARMLinux | OFF |
-| LITE_WITH_JAVA |  编译支持[Java API](../../api_reference/java_api_doc.html)的预测库 | Andriod / ARMLinux | OFF |
+| LITE_WITH_JAVA |  编译支持[Java API](../api_reference/java_api_doc.html)的预测库 | Andriod / ARMLinux | OFF |
 | LITE_WITH_ARM_CLANG | 使用clang编译ARM平台预测库 | Andriod / ARMLinux |OFF |
 | WITH_ARM_DOTPROD |  编译ARM点积指令优化的预测库 | Andriod / ARMLinux |ON |
-| LITE_WITH_CV |  编译[CV图像加速库](../../api_reference/cv.html) | Andirod / ARMLinux |OFF |
+| LITE_WITH_CV |  编译[CV图像加速库](../api_reference/cv.html) | Andirod / ARMLinux |OFF |
 | LITE_WITH_OPENMP |  编译时打开OpenMP | ARMLinux / X86 | ON |
-| LITE_WITH_X86 |  编译[X86平台](../../demo_guides/x86.html)预测库 | X86 | ON |
+| LITE_WITH_X86 |  编译[X86平台](../demo_guides/x86.html)预测库 | X86 | ON |
 | WITH_AVX |  编译有AVX指令优化的预测库 | X86 |ON IF ${AVX_FOUND} |
 | WITH_MKL | 编译有Intel MKL支持的预测库 | X86 |ON IF ${AVX_FOUND} |
-| LITE_ON_MODEL_OPTIMIZE_TOOL |  编译[模型优化工具opt](../model_optimize_tool.html) | X86 |OFF|
-| LITE_WITH_CUDA |  编译[CUDA平台](../../demo_guides/cuda.html)预测库 | CUDA | OFF |
+| LITE_ON_MODEL_OPTIMIZE_TOOL |  编译[模型优化工具opt](../user_guides/model_optimize_tool.html) | X86 |OFF|
+| LITE_WITH_CUDA |  编译[CUDA平台](../demo_guides/cuda.html)预测库 | CUDA | OFF |
 | WITH_DSO |  编译动态CUDA库 | CUDA | ON |
 | LITE_WITH_STATIC_CUDA |   编译静态CUDA库 | CUDA |OFF |
 | LITE_WITH_NVTX | 是否打开NVIDIA Tools Extension (NVTX) | CUDA |OFF |
 | CUDA_WITH_FP16 |  编译CUDA FP16支持| CUDA |OFF |
-| LITE_WITH_PYTHON |  编译支持[Python API](../../api_reference/python_api_doc.html)的预测库 | X86 / CUDA |OFF |
-| LITE_WITH_OPENCL |  编译[OpenCL平台](../../demo_guides/opencl.html)预测库 | OpenCL | OFF |
-| LITE_WITH_FPGA |  编译[FPGA平台](../../demo_guides/fpga.html)预测库 | FPGA | OFF |
-| LITE_WITH_NPU |  编译[华为NPU平台](../../demo_guides/npu.html)预测库 | NPU | OFF |
-| LITE_WITH_RKNPU |  编译[RK NPU平台](../../demo_guides/rockchip_npu.html)预测库 | RKNPU | OFF |
-| LITE_WITH_XPU |  编译[百度XPU平台](../../demo_guides/baidu_xpu.html)预测库 | XPU |OFF |
+| LITE_WITH_PYTHON |  编译支持[Python API](../api_reference/python_api_doc.html)的预测库 | X86 / CUDA |OFF |
+| LITE_WITH_OPENCL |  编译[OpenCL平台](../demo_guides/opencl.html)预测库 | OpenCL | OFF |
+| LITE_WITH_FPGA |  编译[FPGA平台](../demo_guides/fpga.html)预测库 | FPGA | OFF |
+| LITE_WITH_NPU |  编译[华为NPU平台](../demo_guides/npu.html)预测库 | NPU | OFF |
+| LITE_WITH_RKNPU |  编译[RK NPU平台](../demo_guides/rockchip_npu.html)预测库 | RKNPU | OFF |
+| LITE_WITH_XPU |  编译[百度XPU平台](../demo_guides/baidu_xpu.html)预测库 | XPU |OFF |
 | LITE_WITH_XTCL | 通过XTCL方式支持百度XPU，默认Kernel方式 | XPU |OFF IF LITE_WITH_XPU |
-| LITE_WITH_APU | 编译[MTK APU平台](../../demo_guides/mediatek_apu.html)预测库 | APU |OFF |
+| LITE_WITH_APU | 编译[MTK APU平台](../demo_guides/mediatek_apu.html)预测库 | APU |OFF |

docs/user_guides/Compile/library.md → docs/source_compile/library.md

@@ -5,12 +5,12 @@ Lite预测库分为**基础预测库**和**全量预测库(with_extra)**：基
 
 编译时由编译选项 `build_extra`(默认为OFF)控制，`--build_extra=OFF`时编译**基础预测库**，`--build_extra=ON`时编译**全量预测库**。
 
-## 基础预测库( [基础OP列表](../../introduction/support_operation_list.html#basic-operators) )
+## 基础预测库( [基础OP列表](../introduction/support_operation_list.html#basic-operators) )
 
 
 ### 支持功能
 
-（1）87个[基础OP](../../introduction/support_operation_list.html#basic-operators)       （2）9个基础模型       （3）3个in8量化模型
+（1）87个[基础OP](../introduction/support_operation_list.html#basic-operators)       （2）9个基础模型       （3）3个in8量化模型
 
 
 ### 支持的模型
@@ -39,12 +39,12 @@ mobilenet_v1   mobilenet_v2   resnet50
 ```
 
 
-## 全量预测库( [OP列表](../../introduction/support_operation_list.html#op) )
+## 全量预测库( [OP列表](../introduction/support_operation_list.html#op) )
 
 
 ### 支持功能
 
-   Paddle-Lite中的全量算子（ [基础OP](../../introduction/support_operation_list.html#basic-operators) + [Extra OP](../../introduction/support_operation_list.html#extra-operators-build-extra-on) ）
+   Paddle-Lite中的全量算子（ [基础OP](../introduction/support_operation_list.html#basic-operators) + [Extra OP](../introduction/support_operation_list.html#extra-operators-build-extra-on) ）
 
 ### 特点
    包含更多算子、支持更多模型，但体量更大。

docs/user_guides/library_tailoring.md → docs/source_compile/library_tailoring.md

@@ -62,7 +62,7 @@ Paddle-Lite支持**根据模型裁剪预测库**功能。Paddle-Lite的一般编
 
 ### 3、运行裁剪后的预测库文件
 
-注意：基于某一模型裁剪出的预测库只能支持优化工具转化后的该模型，例如根据mobilenetV1裁剪出的 full_api预测库只能运行以protobuf格式转化出的模型mobilenetV1_opt_nb， 裁剪出的light_api预测库只能运行以naive_buffer格式转化出的模型mobilenetV1_opt_nb， 运行其他模型可能会出现`segementation fault:undifined op or kernel`。  模型转化方法参考：[使用opt转化模型](./model_optimize_tool))。
+注意：基于某一模型裁剪出的预测库只能支持优化工具转化后的该模型，例如根据mobilenetV1裁剪出的 full_api预测库只能运行以protobuf格式转化出的模型mobilenetV1_opt_nb， 裁剪出的light_api预测库只能运行以naive_buffer格式转化出的模型mobilenetV1_opt_nb， 运行其他模型可能会出现`segementation fault:undifined op or kernel`。  模型转化方法参考：[使用opt转化模型](../user_guides/model_optimize_tool))。
 
 
 
@@ -78,7 +78,7 @@ Paddle-Lite支持**根据模型裁剪预测库**功能。Paddle-Lite的一般编
 
 `./mobilenetv1_light_api --model_dir=./mobilenetV1_NB`
 
-注意：`mobilenetV1_NB`是用`mobilenetV1`模型转化的naive_buffer格式模型(不需要设置` --record_tailoring_info =true`，转化流程参考：[使用opt转化模型](./model_optimize_tool))。
+注意：`mobilenetV1_NB`是用`mobilenetV1`模型转化的naive_buffer格式模型(不需要设置` --record_tailoring_info =true`，转化流程参考：[使用opt转化模型](../user_guides/model_optimize_tool))。
 
 
 
@@ -151,7 +151,7 @@ int main(int argc, char** argv) {
 
 `./mobilenetv1_full_api --model_dir=./mobilenetV1_PB`
 
-注意：`mobilenetV1_PB`是用`mobilenetV1`模型转化的protobuf格式模型(不需要设置` --record_tailoring_info =true`，转化流程参考：[使用opt转化模型](./model_optimize_tool))。
+注意：`mobilenetV1_PB`是用`mobilenetV1`模型转化的protobuf格式模型(不需要设置` --record_tailoring_info =true`，转化流程参考：[使用opt转化模型](../user_guides/model_optimize_tool))。
 
 ## 按模型集合裁剪预测库
 

docs/user_guides/Compile/v2.3_compile.md → docs/source_compile/v2.3_compile.md

 # release/v2.3 源码编译
-**说明：release/v2.3 之前版本（包括v2.3版本）的源码编译请参考本文档**
 
-**注意：OpenCL、华为NPU、FPGA、CUDA、X86预测库、CV模块的编译，请见进阶使用指南的对应章节。**
+**说明：** release/v2.3 之前版本（包括v2.3版本）的源码编译请参考本文档
+
+**注意：** OpenCL、华为NPU、FPGA、CUDA、X86预测库、CV模块的编译，请见进阶使用指南的对应章节。
+
+如果您还没有配置好相应的源码编译环境，请先根据[编译环境准备](compile_env)中的内容，根据您的开发环境安装源码编译所需的编译环境。
 
 ### 下载代码
 
@@ -30,12 +33,12 @@ git checkout <release-version-tag>
 | --arm_lang |arm_os=android时必选，选择编译器 | `gcc`、`clang`(`clang`当前暂不支持) |
 | --android_stl |arm_os=android时必选，选择静态链接STL或动态链接STL | `c++_static`、`c++_shared`|
 | --build_java | 可选，是否编译java预测库（默认为ON） | `ON`、`OFF` |
-| --build_extra | 可选，是否编译全量预测库（默认为OFF）。详情可参考[预测库说明](./library.html)。 | `ON`、`OFF` |
+| --build_extra | 可选，是否编译全量预测库（默认为OFF）。详情可参考[with_extra参数说明](./library.html)。 | `ON`、`OFF` |
 | target |必选，选择编译模式，`tiny_publish`为编译移动端部署库、`full_publish`为带依赖的移动端部署库、`test`为移动端单元测试、`ios`为编译ios端`tiny_publish` | `tiny_publish`、`full_publish`、`test`、 `ios` |
 
 ### 编译代码
 
-**<font color="orange" >注意</font>**<font color="orange" >：非开发者建议在编译前使用</font>[**“加速第三方依赖库的下载”**](#id22)<font color="orange" >的方法，加速工程中第三方依赖库的下载与编译。 </font>
+**提示：** 编译过程中，如出现源码编译耗时过长，通常是第三方库下载过慢或失败导致。请在git clone完Paddle-Lite仓库代码后，手动删除本地仓库根目录下的third-party目录。编译脚本会自动下载存储于国内 CDN 的第三方依赖的压缩包，节省从git repo同步第三方库代码的时间。
 
 #### 编译`tiny publish`动态库
 
@@ -49,25 +52,31 @@ git checkout <release-version-tag>
   --android_stl=c++_static \
   tiny_publish
 ```
-##### IOS
+##### iOS
+
+**注意：** mac环境编译iOS 时，cmake版本需要高于cmake 3.15；mac环境上编译Android时，cmake版本需要设置为cmake 3.10。
+
 ```shell
 ./lite/tools/build.sh \
   --arm_os=ios64 \
   --arm_abi=armv8 \
   --build_extra=OFF \
   ios
+
+# 编译选项说明
+--arm_os   可选ios或者ios64
+--arm_abi  可选armv7和armv8
+          （注意：当arm_os=ios时只能选择arm_abi=armv7，当arm_os=ios64时只能选择arm_abi=armv8）
 ```
-**注意：mac环境编译IOS 时，cmake版本需要高于cmake 3.15；mac环境上编译Android时，cmake版本需要设置为cmake 3.10。**
 
-ios tiny publish支持的编译选项：
+如果mac编译过程中报错："Invalid CMAKE_DEVELOPER_ROOT: does not exist", 运行：
 
-* `--arm_os`: 可选ios或者ios64
-* `--arm_abi`: 可选armv7和armv8（**注意**：当`arm_os=ios`时只能选择`arm_abi=armv7`，当`arm_os=ios64`时只能选择`arm_abi=armv8`）
-* 如果mac编译过程中报错："Invalid CMAKE_DEVELOPER_ROOT: does not exist", 运行：
 ```shell
 sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
 ```
+
 ##### ARMLinux
+
 ```shell
 ./lite/tools/build.sh \
   --build_extra=OFF \
@@ -75,8 +84,10 @@ sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
   --arm_abi=armv7hf \
   --arm_lang=gcc \
   tiny_publish
+
+# 编译选项说明
+--arm_abi     树莓派3b使用armv7hf，RK3399使用armv8
 ```
-- `--arm_abi`: 树莓派3b使用armv7hf，RK3399使用armv8
   
 #### 编译`full publish`动态库
 
@@ -90,6 +101,7 @@ sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
   --android_stl=c++_static \
   full_publish
 ```
+
 ##### ARMLinux
 ```shell
 ./lite/tools/build.sh \
@@ -98,8 +110,10 @@ sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
   --arm_lang=gcc \
   --build_extra=OFF \
   full_publish
+
+# 编译选项说明
+--arm_abi     树莓派3b使用armv7hf，RK3399使用armv8
 ```
-- `--arm_abi`: 树莓派3b使用armv7hf，RK3399使用armv8
   
 ### 编译结果说明
 
@@ -122,43 +136,45 @@ sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
 ![](https://user-images.githubusercontent.com/45189361/65375726-3bb99280-dccb-11e9-9903-8ce255371905.png)
 
 
+**具体内容**说明 (供参考)：
 
-**具体内容**说明：
-
-1、 `bin`文件夹：可执行工具文件 `paddle_code_generator`、`test_model_bin`
-
-2、 `cxx`文件夹：包含c++的库文件与相应的头文件
-
-- `include`  : 头文件
-- `lib` : 库文件
-  - 打包的静态库文件：
-    - `libpaddle_api_full_bundled.a`  ：包含 full_api 和 light_api 功能的静态库
-    - `libpaddle_api_light_bundled.a` ：只包含 light_api 功能的静态库
-  - 打包的动态态库文件：
-    - `libpaddle_full_api_shared.so` ：包含 full_api 和 light_api 功能的动态库
-    - `libpaddle_light_api_shared.so`：只包含 light_api 功能的动态库
-
-3、 `demo`文件夹：示例 demo ，包含 C++ demo 和  Java demo。
-
-- `cxx`   ： C++示例 demo
-  - `mobile_full` :  full_api 的使用示例
-  - `mobile_light` : light_api的使用示例
-- `java`  ：Java 示例 demo
-  - `android`  : Java的 Android 示例
-
-4、 `java` 文件夹：包含 Jni 的动态库文件与相应的 Jar 包
-
-- `jar` :  `PaddlePredictor.jar`
-- `so`  : Jni动态链接库  `libpaddle_lite_jni.so`
-
-5、 `third_party` 文件夹：第三方库文件`gflags`
+```shell
+inference_lite_lib.xxx.xxx
+├── bin                                           可执行工具文件
+│   ├── paddle_code_generator
+│   └── test_model_bin
+├── 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_full_bundled.a          包含 full_api 和 light_api 功能的静态库
+│       ├── libpaddle_api_light_bundled.a         只包含 light_api 功能的静态库
+│       ├── libpaddle_full_api_shared.so          包含 full_api 和 light_api 功能的动态库
+│       └── libpaddle_light_api_shared.so         只包含 light_api 功能的动态库
+│
+├── demo                                          C++ 和 Java 示例代码
+│   ├── cxx                                       C++ 预测库demo
+│   └── java                                      Java 预测库demo
+│
+├── java                                          Java 预测库
+│   ├── jar
+│   │   └── PaddlePredictor.jar                   Java JAR 包
+│   ├── so
+│   │   └── libpaddle_lite_jni.so                 Java JNI 动态链接库
+│   └── src
+│
+└── third_party                                   第三方库文件gflags
+```
 
 **注意：**
 
-1、 只有当`--arm_os=android` 时才会编译出：
-
-- Java库文件与示例：`Java`和`demo/java`
-
-- 动态库文件:`libpaddle_full_api_shared.so`,`libpaddle_light_api_shared.so`
-
-2、 `tiny_publish`编译结果不包括 C++ demo和 C++ 静态库，但提供 C++ 的 light_api 动态库、 Jni 动态库和Java demo
+- 只有当`--arm_os=android` 时才会编译出：
+  - Java库文件与示例：`Java`和`demo/java`
+  - 动态库文件:`libpaddle_full_api_shared.so`,`libpaddle_light_api_shared.so`
+- `tiny_publish`编译结果不包括 C++ demo和 C++ 静态库，但提供 C++ 的 light_api 动态库、 Jni 动态库和Java demo

docs/user_guides/Compile/Android.md

-
-# 编译Android预测库
-
-**注意：本编译方法只适用于release/v2.6.0之后版本（包括 v2.6.0)**
-
-如果您还没有配置好Andriod交叉编译环境，请先根据[环境准备](https://paddle-lite.readthedocs.io/zh/latest/user_guides/source_compile.html#id2)中的内容，根据您的开发环境安装编译Android预测库所需的编译环境。运行编译脚本之前，请先检查环变量`NDK_ROOT`指向正确的Andriod NDK安装路径，之后可以下载并编译 Paddle-Lite源码。
-
-```shell
-# 1. 下载Paddle-Lite源码 并切换到release分支
-git clone https://github.com/PaddlePaddle/Paddle-Lite.git
-cd Paddle-Lite && git checkout release/v2.3
-
-# 2. 编译Paddle-Lite Android预测库 (armv8, gcc编译, 静态链接ndk stl)
-./lite/tools/build_android.sh
-```
-
-> **提示：** 编译过程中，如果程序在下载第三方库时花费较多时间，请尝试删除Paddle-Lite下的`<lite-repo>/third-party`目录之后再次运行编译脚本，脚本会自动下载存储于百度云的第三方库代码包，节省从git repo下载第三方库代码的时间。
-
-
-### 编译结果
-
-位于`Paddle-Lite/build.lite.android.armv8.gcc/inference_lite_lib.android.armv8`:
-
-```shell
-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
-```
-
-
-
-### 编译命令
-
-- 默认编译方法: (armv8, gcc, c++_static)                                           
-```                                        shell
-./lite/tools/build_android.sh
-```
-
-- 打印 help 信息：
-
-```shell
-./lite/tools/build_android.sh help
-```
-
-- 其他可选编译命令：
-
-```shell
---arch: (armv8|armv7)        arm版本，默认为armv8
---toolchain: (gcc|clang)     编译器类型，默认为gcc
---android_stl: (c++_static|c++_shared)   NDK stl库链接方法，默认为静态链接c++_static
---with_java: (OFF|ON)        是否编译Java预测库, 默认为 ON
---with_cv: (OFF|ON)          是否编译CV相关预处理库, 默认为 OFF
---with_log: (OFF|ON)         是否输出日志信息, 默认为 ON
---with_extra: (OFF|ON)       是否编译OCR或NLP相关模型的kernel&OP，默认为OFF，只编译CV模型相关kernel&OP
-```
-
-- 裁剪预测库方法（只编译模型中的kernel&OP，降低预测库体积）:
-
-```shell
-./lite/tools/build_android.sh --with_strip=ON --opt_model_dir=YourOptimizedModelDir
-```
-```shell
---with_strip: (OFF|ON);   是否根据输入模型裁剪预测库，默认为OFF
---opt_model_dir:          输入模型的绝对路径，需要为opt转化之后的模型
-```
-详情请参考:  [裁剪预测库](https://paddle-lite.readthedocs.io/zh/latest/user_guides/library_tailoring.html)
-
-
-- 编译 Android npu 预测库方法：
-
-```shell
-./lite/tools/build_android.sh --with_huawei_kirin_npu=ON --huawei_kirin_npu_sdk_root=YourNpuSdkPath
-```
-```shell
---with_huawei_kirin_npu: (OFF|ON);   是否编译编译huawei_kirin_npu 的预测库，默认为OFF
---huawei_kirin_npu_sdk_root:     `huawei HiAi DDK`文件的绝对路径，可从下面网址下载：
-https://developer.huawei.com/consumer/cn/hiai/
-```
-详情请参考：[PaddleLite使用NPU(华为)预测部署](https://paddle-lite.readthedocs.io/zh/latest/demo_guides/npu.html)
-
-- 编译Android opencl 预测库方法：(armv8, gcc, c++_static)
-
-```shell
-./lite/tools/build_android.sh --with_opencl=ON
-```
-```shell
---with_opencl: (OFF|ON);  是否编译opencl预测库, 默认为 OFF
-```

docs/user_guides/debug.md

-# 调试
+# 调试工具
 
 ## Profiler工具
 
@@ -6,7 +6,7 @@ Basic profiler 用于 CPU 上kernel 耗时的统计。
 
 ### 开启方法:
 
-参照 [编译安装](../user_guides/source_compile) 中的**full_publish**部分进行环境配置，在 cmake 时添加 `-DLITE_WITH_PROFILE=ON` ，就可以开启相应支持。
+参照 [编译环境准备](../source_compile/compile_env) 进行环境配置，在编译脚本的 cmake 选项中添加 `-DLITE_WITH_PROFILE=ON` ，就可以开启相应支持。
 
 ### 使用示例：
 
@@ -39,7 +39,7 @@ Basic profiler 用于 CPU 上kernel 耗时的统计。
 
 ### 编译方法:
 
-1. 参照 [编译安装](../user_guides/source_compile) 中的**full_publish**部分进行环境配置和编译。
+1. 参照 [编译环境准备](../source_compile/compile_env) 进行环境配置和编译。
 2. 在生成的`build`目录下，执行`make lite_model_debug_tool`，`lite_model_debug_tool`产出在编译目录的`lite/tools/debug`目录下。
 
 ### 工作流程:

docs/user_guides/model_quantization.md

@@ -52,7 +52,7 @@
 
 ### 3.2 量化模型预测
 
-和FP32模型一样，转换后的量化模型可以在Android/IOS APP中加载预测，建议参考[C++ Demo](../demo_guides/cpp_demo)、[Java Demo](../demo_guides/java_demo)、[Android/IOS Demo](../demo_guides/android_app_demo)。
+和FP32模型一样，转换后的量化模型可以在Android/IOS APP中加载预测，建议参考[C++ Demo](../quick_start/cpp_demo)、[Java Demo](../quick_start/java_demo)、[Android/IOS Demo](../demo_guides/android_app_demo)。
 
 
 ## FAQ

docs/user_guides/post_quant_no_data.md

@@ -110,4 +110,4 @@ WeightQuantization.quantize_weight_to_int(self,
 
 ### 3.2 量化模型预测
 
-和FP32模型一样，转换后的量化模型可以在Android/IOS APP中加载预测，建议参考[C++ Demo](../demo_guides/cpp_demo)、[Java Demo](../demo_guides/java_demo)、[Android/IOS Demo](../demo_guides/android_app_demo)。
+和FP32模型一样，转换后的量化模型可以在Android/IOS APP中加载预测，建议参考[C++ Demo](../quick_start/cpp_demo)、[Java Demo](../quick_start/java_demo)、[Android/IOS Demo](../demo_guides/android_app_demo)。

docs/user_guides/post_quant_with_data.md

@@ -102,4 +102,4 @@ Demo请参考[文档](https://github.com/PaddlePaddle/PaddleSlim/tree/release/1.
 
 ### 3.2 量化模型预测
 
-和FP32模型一样，转换后的量化模型可以在Android/IOS APP中加载预测，建议参考[C++ Demo](../demo_guides/cpp_demo)、[Java Demo](../demo_guides/java_demo)、[Android/IOS Demo](../demo_guides/android_app_demo)。
+和FP32模型一样，转换后的量化模型可以在Android/IOS APP中加载预测，建议参考[C++ Demo](../quick_start/cpp_demo)、[Java Demo](../quick_start/java_demo)、[Android/IOS Demo](../demo_guides/android_app_demo)。

lite/demo/cxx/README.md

@@ -23,7 +23,7 @@
 
 **编译Demo并执行**
 
-参考[预测库编译](https://paddle-lite.readthedocs.io/zh/latest/user_guides/source_compile.html)准备编译环境。
+参考[编译环境准备](https://paddle-lite.readthedocs.io/zh/latest/source_compile/compile_env.html)准备编译环境。
 
 执行下面命令，下载PaddleLite代码，切换到2.6版本分支。
 ```shell