Merge branch 'develop' of https://github.com/PaddlePaddle/FluidDoc into develop

.gitignore

@@ -2,3 +2,4 @@
 /doc/fluid/menu.zh.json
 /doc/fluid/menu.en.json
 .idea
+build

doc/fluid/advanced_usage/development/write_docs_cn.md → doc/fluid/advanced_guide/addon_development/contribute-docs/write_docs_cn.md

@@ -177,7 +177,7 @@ pip install -r requirements.txt
 
 ## 提交修改
 
-如果您希望修改代码，请在`Paddle`仓库下参考[如何贡献代码](../development/contribute_to_paddle/index_cn.html)执行操作。
+如果您希望修改代码，请在`Paddle`仓库下参考[如何贡献代码](../contribute_code/index_cn.html)执行操作。
 
 如果您仅修改文档：
 
@@ -198,7 +198,7 @@ pip install -r requirements.txt
 
 	3.在`FluidDoc`仓库下为您的修改提交PR
 
-提交修改与PR的步骤可以参考[如何贡献代码](../development/contribute_to_paddle/index_cn.html)
+提交修改与PR的步骤可以参考[如何贡献代码](../contribute_code/index_cn.html)
 
 ## 帮助改进预览工具
 

doc/fluid/advanced_usage/development/write_docs_en.md → doc/fluid/advanced_guide/addon_development/contribute-docs/write_docs_en.md

@@ -178,7 +178,7 @@ After completing the installation, you will also need to do:
 
 ## Submit changes
 
-If you wish to modify the code, please refer to [How to contribute code](../development/contribute_to_paddle/index_en.html) under the `Paddle` repository.
+If you wish to modify the code, please refer to [How to contribute code](../contribute_code/index_en.html) under the `Paddle` repository.
 
 If you just modify the document:
 
@@ -199,7 +199,7 @@ If you just modify the document:
 
 3.  Pull Request for your changes in the `FluidDoc` repository
 
-The steps to submit changes and PR can refer to [How to contribute code](../development/contribute_to_paddle/index_en.html)
+The steps to submit changes and PR can refer to [How to contribute code](../contribute_code/index_en.html)
 
 ## Help improve preview tool
 

doc/fluid/advanced_usage/development/contribute_to_paddle/local_dev_guide.md → doc/fluid/advanced_guide/addon_development/contribute_code/local_dev_guide.md

@@ -78,8 +78,8 @@ no changes added to commit (use "git add" and/or "git commit -a")
 
 ## 编译和单元测试
 
-关于编译 PaddlePaddle 的源码，请参见[从源码编译](../../../beginners_guide/install/compile/fromsource.html) 选择对应的操作系统。
-关于单元测试，可参考[Op单元测试](../../../advanced_usage/development/new_op/new_op.html#id7) 的运行方法。
+关于编译 PaddlePaddle 的源码，请参见[从源码编译](../../../install/compile/fromsource.html) 选择对应的操作系统。
+关于单元测试，可参考[Op单元测试](../new_op/new_op.html#id7) 的运行方法。
 
 ## 提交（commit）
 

doc/fluid/advanced_usage/development/contribute_to_paddle/local_dev_guide_en.md → doc/fluid/advanced_guide/addon_development/contribute_code/local_dev_guide_en.md

@@ -78,8 +78,8 @@ no changes added to commit (use "git add" and/or "git commit -a")
 
 ## Build and test
 
-Please refer to [Compile From Source Code](../../../beginners_guide/install/compile/fromsource_en.html) about more information of building PaddlePaddle source codes.
-Please refer to [Op Unit Tests](../../../advanced_usage/development/new_op/new_op_en.html#unit-tests) about more information of running unit tests.
+Please refer to [Compile From Source Code](../../../install/compile/fromsource_en.html) about more information of building PaddlePaddle source codes.
+Please refer to [Op Unit Tests](../new_op/new_op_en.html#unit-tests) about more information of running unit tests.
 
 ## Commit
 

doc/fluid/advanced_usage/design_idea/fluid_design_idea.md → doc/fluid/advanced_guide/addon_development/design_idea/fluid_design_idea.md

@@ -213,7 +213,7 @@ outs = exe.run(
 
 
 ## 代码实例
-本节通过[编程指南](../../beginners_guide/programming_guide/programming_guide.html)中简单的线性回归例子，为您介绍上述内容如何在代码中实现。
+本节通过[编程指南](../../../beginners_guide/basic_concept/programming_guide/programming_guide.html)中简单的线性回归例子，为您介绍上述内容如何在代码中实现。
 
 **定义Program**
 
@@ -360,5 +360,4 @@ Paddle使用Executor.run来运行一段Program。
        [6.099215 ]], dtype=float32), array([1.6935859], dtype=float32)]
 ```
 
-至此您已经了解了Paddle内部的执行流程的核心概念，更多框架使用细节请参考[使用指南](../../user_guides/index_cn.html)相关内容，[模型库](../../user_guides/models/index_cn.html
-)中也为您提供了丰富的模型示例以供参考。
+至此您已经了解了Paddle内部的执行流程的核心概念，更多框架使用细节可以参考[典型案例](../../../user_guides/index_cn.html)。

doc/fluid/advanced_usage/design_idea/fluid_design_idea_en.md → doc/fluid/advanced_guide/addon_development/design_idea/fluid_design_idea_en.md

@@ -214,7 +214,7 @@ outs = exe.run(
 
 
 ## Code Instance
-This section introduces how the above is implemented in your code through a simple linear regression example in the [Fluid Programming Guide](../../beginners_guide/programming_guide/programming_guide.html).
+This section introduces how the above is implemented in your code through a simple linear regression example in the [Fluid Programming Guide](../../../beginners_guide/basic_concept/programming_guide/programming_guide_en.html).
 
 **Define Program**
 
@@ -361,5 +361,4 @@ The output is:
        [6.099215 ]], dtype=float32), array([1.6935859], dtype=float32)]
 ```
 
-Till now you have already be notified of the core concepts of the internal execution process of Fluid. For more details on the usage of the framework, please refer to the [User Guide](../../user_guides/index_en.html) related content, [Model Library](../../user_guides/models/index_en.html
-) also provides you with a wealth of model examples for reference.
+Till now you have already be notified of the core concepts of the internal execution process of Fluid. For more details on the usage of the framework, please refer to the [User Guide](../../../user_guides/index_en.html).

doc/fluid/advanced_guide/addon_development/index_cn.rst

+..  _addon_development:
+
+########
+二次开发
+########
+
+..  toctree::
+    :maxdepth: 1
+
+    design_idea/fluid_design_idea.md
+    new_op/index_cn.rst
+    contribute_code/index_cn.rst
+
+

doc/fluid/advanced_guide/addon_development/index_en.rst

+..  _addon_development_en:
+
+
+################
+Addon Development
+################
+
+..  toctree::
+    :maxdepth: 1
+
+    design_idea/fluid_design_idea_en.md
+    new_op/index_en.rst
+    contribute_code/index_en.rst
+
+
+

doc/fluid/advanced_usage/development/new_op/custom_op.md → doc/fluid/advanced_guide/addon_development/new_op/custom_op.md

@@ -72,18 +72,19 @@ class Relu2Kernel : public framework::OpKernel<T> {
 };
 
 // 定义反向OP的输入Y和dY、输出dX、属性:
-class Relu2GradMaker : public framework::SingleGradOpDescMaker {
+template <typename T>
+class Relu2GradMaker : public framework::SingleGradOpMaker<T> {
  public:
-  using framework::SingleGradOpDescMaker::SingleGradOpDescMaker;
+  using framework::SingleGradOpMaker<T>::SingleGradOpMaker;
 
-  std::unique_ptr<framework::OpDesc> Apply() const override {
-    auto* op = new framework::OpDesc();
+  std::unique_ptr<T> Apply() const override {
+    auto* op = new T();
     op->SetType("relu2_grad");
-    op->SetInput("Y", Output("Y"));
-    op->SetInput(framework::GradVarName("Y"), OutputGrad("Y"));
-    op->SetAttrMap(Attrs());
-    op->SetOutput(framework::GradVarName("X"), InputGrad("X"));
-    return std::unique_ptr<framework::OpDesc>(op);
+    op->SetInput("Y", this->Output("Y"));
+    op->SetInput(framework::GradVarName("Y"), this->OutputGrad("Y"));
+    op->SetAttrMap(this->Attrs());
+    op->SetOutput(framework::GradVarName("X"), this->InputGrad("X"));
+    return std::unique_ptr<T>(op);
   }
 };
 
@@ -124,7 +125,11 @@ namespace ops = paddle::operators;
 using CPU = paddle::platform::CPUDeviceContext;
 // 注册前向和反向op
 // 为了和框架内部的relu区分，这里注册的OP type为relu2
-REGISTER_OPERATOR(relu2, ops::Relu2Op, ops::Relu2OpMaker, ops::Relu2GradMaker);
+REGISTER_OPERATOR(relu2,
+                  ops::Relu2Op,
+                  ops::Relu2OpMaker,
+                  ops::Relu2GradMaker<paddle::framework::OpDesc>,
+                  ops::Relu2GradMaker<paddle::imperative::OpBase>);
 REGISTER_OPERATOR(relu2_grad, ops::Relu2GradOp);
 // 注册CPU的Kernel
 REGISTER_OP_CPU_KERNEL(relu2,
@@ -252,24 +257,15 @@ echo $include_dir
 echo $lib_dir
 
 # PaddlePaddel >=1.6.1, 仅需要include ${include_dir} 和 ${include_dir}/third_party
-nvcc relu_op.cu -c -o relu_op.cu.o -ccbin cc -DPADDLE_WITH_CUDA -DEIGEN_USE_GPU -DPADDLE_USE_DSO -Xcompiler -fPIC -std=c++11 -Xcompiler -fPIC -w --expt-relaxed-constexpr -O3 -DNVCC \
+nvcc relu_op.cu -c -o relu_op.cu.o -ccbin cc -DPADDLE_WITH_CUDA -DEIGEN_USE_GPU -DPADDLE_USE_DSO -DPADDLE_WITH_MKLDNN -Xcompiler -fPIC -std=c++11 -Xcompiler -fPIC -w --expt-relaxed-constexpr -O3 -DNVCC \
     -I ${include_dir} \
     -I ${include_dir}/third_party \
 
-g++ relu_op.cc relu_op.cu.o -o relu2_op.so -shared -fPIC -std=c++11 -O3 \
+g++ relu_op.cc relu_op.cu.o -o relu2_op.so -shared -fPIC -std=c++11 -O3 -DPADDLE_WITH_MKLDNN \
   -I ${include_dir} \
   -I ${include_dir}/third_party \
   -L /usr/local/cuda/lib64 \
   -L ${lib_dir} -lpaddle_framework -lcudart
-
-# PaddlePaddel 1.6.0, 需要include的third_party如下:
-#  -I ${include_dir}/third_party/install/protobuf/include \
-#  -I ${include_dir}/third_party/install/glog/include \
-#  -I ${include_dir}/third_party/install/gflags/include \
-#  -I ${include_dir}/third_party/install/xxhash/include \
-#  -I ${include_dir}/third_party/boost \
-#  -I ${include_dir}/third_party/eigen3 \
-#  -I ${include_dir}/third_party/dlpack/include \
 ```
 
 
@@ -277,7 +273,9 @@ g++ relu_op.cc relu_op.cu.o -o relu2_op.so -shared -fPIC -std=c++11 -O3 \
 注意点:
 
 1. NVCC编译GPU OP的cu文件时，需要加 `-DPADDLE_WITH_CUDA -DEIGEN_USE_GPU -DPADDLE_USE_DSO` 。
-2. 可多个OP编译到同一个动态库中。
+2. 如果安装的PaddlePaddle不包含MKLDNN，则需要去掉编译选项`-DPADDLE_WITH_MKLDNN`。默认的安装包已包含MKLDNN。
+3. 可多个OP编译到同一个动态库中。
+4. 通过pip方式安装的PaddlePaddle由GCC 4.8编译得到，由于GCC 4.8和GCC 5以上**C++11 ABI不兼容**，您编写的自定义OP，需要通过GCC 4.8编译。若是GCC 5及以上的环境上使用自定义OP，推荐使用[Docker安装PaddlePaddle](https://www.paddlepaddle.org.cn/install/doc/docker)，使得编Paddle和编译自定义OP的GCC版本相同。
 
 
 

doc/fluid/advanced_usage/development/new_op/index_en.rst → doc/fluid/advanced_guide/addon_development/new_op/index_en.rst

@@ -2,6 +2,8 @@
 Write New Operators
 ###################
 
+This section will guide you how to add an operator, and it also includes some necessary notes.
+
 - `How to write new operator <new_op_en.html>`_ ：guides to write new operators
 
 - `op notes <op_notes_en.html>`_ ：notes on developing new operators

doc/fluid/advanced_usage/development/new_op/new_python_op.md → doc/fluid/advanced_guide/addon_development/new_op/new_python_op.md

 # 如何写新的Python OP
 
-PaddlePaddle Fluid通过 `py_func` 接口支持在Python端编写op。 
+PaddlePaddle Fluid通过 `py_func` 接口支持在Python端自定义OP。 py_func的设计原理在于Paddle中的LodTensor可以与numpy数组可以方便的互相转换，从而可以使用Python中的numpy API来自定义一个Python OP。
 
 
 ## py_func接口概述
@@ -14,12 +14,12 @@ def py_func(func, x, out, backward_func=None, skip_vars_in_backward_input=None):
 
 其中，
 
-- `x` 是Python Op的输入变量，可以是单个 `Variable` 或者 `List[Variable]` 。
-- `out` 是Python Op的输出变量，可以是单个 `Variable` 或者 `List[Variable]` 。
-- `func` 是Python Op的前向函数。在运行网络前向时，框架会调用 `out = func(*x)` ，根据前向输入 `x` 和前向函数 `func` 计算前向输出 `out`。
+- `x` 是Python Op的输入变量，可以是单个 `Variable` | `tuple[Variable]` | `list[Variable]` 。多个Variable以tuple[Variable]或list[Variale]的形式传入，其中Variable为LoDTensor或Tenosr。
+- `out` 是Python Op的输出变量，可以是单个 `Variable` | `tuple[Variable]` | `list[Variable]` 。其中Variable既可以为LoDTensor或Tensor，也可以为numpy数组。
+- `func` 是Python Op的前向函数。在运行网络前向时，框架会调用 `out = func(*x)` ，根据前向输入 `x` 和前向函数 `func` 计算前向输出 `out`。在 ``func`` 建议先主动将LoDTensor转换为numpy数组，方便灵活的使用numpy相关的操作，如果未转换成numpy，则可能某些操作无法兼容。
 - `backward_func` 是Python Op的反向函数。若 `backward_func` 为 `None` ，则该Python Op没有反向计算逻辑；
   若 `backward_func` 不为 `None`，则框架会在运行网路反向时调用 `backward_func` 计算前向输入 `x` 的梯度。
-- `skip_vars_in_backward_input` 为反向函数 `backward_func` 中不需要的输入，可以是单个 `Variable` 或者 `List[Variable]` 。
+- `skip_vars_in_backward_input` 为反向函数 `backward_func` 中不需要的输入，可以是单个 `Variable` | `tuple[Variable]` | `list[Variable]` 。
 
 
 ## 如何使用py_func编写Python Op
@@ -28,7 +28,7 @@ def py_func(func, x, out, backward_func=None, skip_vars_in_backward_input=None):
 
 - 第一步：定义前向函数和反向函数
 
-前向函数和反向函数均由Python编写。
+前向函数和反向函数均由Python编写，可以方便地使用Python与numpy中的相关API来实现一个自定义的OP。
 
 若前向函数的输入为 `x_1`, `x_2`, ..., `x_n` ，输出为`y_1`, `y_2`, ..., `y_m`，则前向函数的定义格式为：
 ```Python
@@ -46,25 +46,52 @@ def backward_func(x_1, x_2, ..., x_n, y_1, y_2, ..., y_m, dy_1, dy_2, ..., dy_m)
 
 若反向函数不需要某些前向输入变量或前向输出变量，可设置 `skip_vars_in_backward_input` 进行排除（步骤三中会叙述具体的排除方法）。
 
-此处我们利用numpy库完成tanh的前向函数和反向函数编写。
+注：，x_1, ..., x_n为输入的多个LodTensor，请以tuple(Variable)或list[Variable]的形式在py_func中传入。建议先主动将LodTensor通过numpy.array转换为数组，否则Python与numpy中的某些操作可能无法兼容使用在LodTensor上。
+
+此处我们利用numpy的相关API完成tanh的前向函数和反向函数编写。下面给出多个前向与反向函数定义的示例：
 
 ```Python
 import numpy as np
 
-def my_tanh(x):
+# 前向函数1：模拟tanh激活函数
+def tanh(x):
+    # 可以直接将LodTensor作为np.tanh的输入参数
     return np.tanh(x)
 
-def my_tanh_grad(x, y, dy):
+# 前向函数2：将两个2-D LodTenosr相加，输入多个LodTensor以list[Variable]或tuple(Variable)形式
+def element_wise_add(x, y):
+    # 必须先手动将LodTensor转换为numpy数组，否则无法支持numpy的shape操作
+    x = np.array(x)  
+    y = np.array(y)
+
+    if x.shape != y.shape:
+        raise AssertionError("the shape of inputs must be the same!")
+
+    result = np.zeros(x.shape, dtype='int32')
+    for i in range(len(x)):
+        for j in range(len(x[0])):
+            result[i][j] = x[i][j] + y[i][j]
+
+    return result
+
+# 前向函数3：可用于调试正在运行的网络（打印值）
+def debug_func(x):
+    # 可以直接将LodTensor作为print的输入参数
+    print(x)
+
+# 前向函数1对应的反向函数，默认的输入顺序为：x、out、out的梯度
+def tanh_grad(x, y, dy):
+    # 必须先手动将LodTensor转换为numpy数组，否则"+/-"等操作无法使用
     return np.array(dy) * (1 - np.square(np.array(y)))
 ```
 
 注意，前向函数和反向函数的输入均是 `LoDTensor` 类型，输出可以是Numpy Array或 `LoDTensor`。
-由于 `LoDTensor` 实现了Python的buffer protocol协议，因此我们既可通过 `numpy.array` 直接将 `LoDTensor` 转换为Numpy Array，也可直接将 `LoDTensor` 作为Numpy函数的输入参数。
+由于 `LoDTensor` 实现了Python的buffer protocol协议，因此即可通过 `numpy.array` 直接将 `LoDTensor` 转换为numpy Array来进行操作，也可直接将 `LoDTensor` 作为numpy函数的输入参数。但建议先主动转换为numpy Array，则可以任意的使用python与numpy中的所有操作（例如"numpy array的+/-/shape"）。
 
 tanh的反向函数不需要前向输入x，因此我们可定义一个不需要前向输入x的反向函数，并在后续通过 `skip_vars_in_backward_input` 进行排除 :
 
 ```Python
-def my_tanh_grad_without_x(y, dy):
+def tanh_grad_without_x(y, dy):
     return np.array(dy) * (1 - np.square(np.array(y)))
 ```
 
@@ -89,13 +116,13 @@ out_var = create_tmp_var(fluid.default_main_program(), name='output', dtype='flo
 `py_func` 的调用方式为：
 
 ```Python
-fluid.layers.py_func(func=my_tanh, x=in_var, out=out_var, backward_func=my_tanh_grad)
+fluid.layers.py_func(func=tanh, x=in_var, out=out_var, backward_func=tanh_grad)
 ```
 
 若我们不希望在反向函数输入参数中出现前向输入，则可使用 `skip_vars_in_backward_input` 进行排查，简化反向函数的参数列表。
 
 ```Python
-fluid.layers.py_func(func=my_tanh, x=in_var, out=out_var, backward_func=my_tanh_grad_without_x,
+fluid.layers.py_func(func=tanh, x=in_var, out=out_var, backward_func=tanh_grad_without_x,
     skip_vars_in_backward_input=in_var)
 ```
 
@@ -111,4 +138,3 @@ fluid.layers.py_func(func=my_tanh, x=in_var, out=out_var, backward_func=my_tanh_
 
 - 若某个前向输出变量没有梯度，则 `backward_func` 将接收到 `None` 的输入。若某个前向输入变量没有梯度，则我们应在 `backward_func` 中主动返回
   `None`。
-  

doc/fluid/advanced_usage/development/new_op/op_notes.md → doc/fluid/advanced_guide/addon_development/new_op/op_notes.md

@@ -9,7 +9,7 @@ Op的核心方法是Run，Run方法需要两方面的资源：数据资源和计
 Fluid框架的设计理念是可以在多种设备及第三方库上运行，有些Op的实现可能会因为设备或者第三方库的不同而不同。为此，Fluid引入了OpKernel的方式，即一个Op可以有多个OpKernel，这类Op继承自`OperatorWithKernel`，这类Op的代表是conv_op，conv_op的OpKernel有：`GemmConvKernel`、`CUDNNConvOpKernel`、`ConvMKLDNNOpKernel`，且每个OpKernel都有double和float两种数据类型。不需要OpKernel的代表有`WhileOp`等。
 
 Operator继承关系图：
-![op_inheritance_relation_diagram](../../pics/op_inheritance_relation_diagram.png)
+![op_inheritance_relation_diagram](./op_inheritance_relation_diagram.png)
 
 进一步了解可参考：[multi_devices](https://github.com/PaddlePaddle/FluidDoc/tree/develop/doc/fluid/design/multi_devices)，[scope](https://github.com/PaddlePaddle/FluidDoc/blob/develop/doc/fluid/design/concepts/scope.md)，[Developer's_Guide_to_Paddle_Fluid](https://github.com/PaddlePaddle/FluidDoc/blob/release/1.2/doc/fluid/getstarted/Developer's_Guide_to_Paddle_Fluid.md)
 
@@ -148,7 +148,7 @@ GetExpectedKernelType方法是OperatorWithKernel类中用于获取指定设备
 如果未使用带有初始化检查的方法，直接使用了`Tensor->type()`，可能会导致报出`holder_ should not be null. Tensor not initialized yet when Tensor::type()`的错误，例如[Paddle issue #19522](https://github.com/PaddlePaddle/Paddle/issues/19522) ，用户仅凭该错误信息将无法得知具体出错的Op，不利于调试。
 
 ### 5.Op兼容性问题
-对Op的修改需要考虑兼容性问题，要保证Op修改之后，之前的模型都能够正常加载及运行。<font color="#FF0000">**所以现在不允许对已有的Op新增输入或者输出，不允许减去Op的已有属性及修改默认值**</font> 。
+对Op的修改需要考虑兼容性问题，要保证Op修改之后，之前的模型都能够正常加载及运行，即新版本的Paddle预测库能成功加载运行旧版本训练的模型。<font color="#FF0000">**所以，需要保证Op的Input、Output和Attribute不能被修改（文档除外）或删除，可以新增Input、Output和Attribute，但是新增的Input，Output必须设置AsDispensable，新增的Attribute必须设置默认值。更多详细内容请参考[OP修改规范：Input/Output/Attribute只能做兼容修改](https://github.com/PaddlePaddle/Paddle/wiki/OP-Input-Output-Attribute-Compatibility-Modification)**</font> 。
 
 ### 6.ShareDataWith的调用
 ShareDataWith的功能是使两个Tensor共享底层buffer，在调用这个操作的时候需要特别注意，在Op内部不能将ShareDataWith作用在Op的输出上，即Op输出的Tensor必须是Malloc出来的。

doc/fluid/advanced_usage/development/new_op/op_notes_en.md → doc/fluid/advanced_guide/addon_development/new_op/op_notes_en.md

@@ -9,7 +9,7 @@ The core method of Op is Run. The Run method requires two resources: data resour
 The Fluid framework is designed to run on a variety of devices and third-party libraries, and some Op implementations may vary on different the devices or third-party libraries. Therefore, Fluid introduced the OpKernel's approach, which means an Op can have multiple OpKernels. Such Ops are derived from `OperatorWithKernel`, and the representative of such Ops is conv, the OpKernels of conv_op are: `GemmConvKernel`, `CUDNNConvOpKernel`, `ConvMKLDNNOpKernel`, and each OpKernel has two data types, double and float. Ops that do not need OpKernel inclue `WhileOp` and so on.
 
 Operator inheritance diagram:
-![op_inheritance_relation_diagram](../../pics/op_inheritance_relation_diagram.png)
+![op_inheritance_relation_diagram](./op_inheritance_relation_diagram.png)
 
 For further information, please refer to: [multi_devices](https://github.com/PaddlePaddle/FluidDoc/tree/develop/doc/fluid/design/multi_devices) , [scope](https://github.com/PaddlePaddle/FluidDoc/blob/develop/doc/fluid/design/concepts/scope.md) , [Developer's_Guide_to_Paddle_Fluid](https://github.com/PaddlePaddle/FluidDoc/blob/release/1.2/doc/fluid/getstarted/Developer's_Guide_to_Paddle_Fluid.md)
 
@@ -110,7 +110,7 @@ Never make any modification of the input data inside Op, as there may be other O
 Currently all OpKernel are required to register double and float data types.
 
 ### 4.Op compatibility issue
-The modification of Op needs to consider the compatibility problem. Please ensure that the previous model can be loaded and run normally after the modification of Op. <font color="#FF0000">**So it is not allowed to add input or output to the existing Ops. It is not allowed to remove the existing properties of Op and modify the default value**</font>.
+The modification of Op needs to consider the compatibility problem. Please ensure that the previous model can be loaded and run normally after the modification of Op which means that the model trained by the old version can be loaded and run with Paddle inference library of new version. <font color="#FF0000">**So developers should ensure that the Input, Output and Attribute of OPs cannot be modified (except for documents) or deleted. And developers can add Input, Output and Attribute, but the added Input and Output must be set to be dispensable, and the default value of added Attribute must be set. For more details, please refer to [OP Input/Output/Attribute Compatibility Modification](https://github.com/PaddlePaddle/Paddle/wiki/OP-Input-Output-Attribute-Compatibility-Modification(English-Version))**</font>.
 
 ### 5.Call ShareDataWith
 The function of ShareDataWith is to make the two Tensors share the underlying buffer. When calling this operation, special attention should be paid. In the Op, the ShareDataWith cannot be applied to the output of Op. In other words, the Tensor of the Op output must be from Malloc.
@@ -184,4 +184,3 @@ def fc(input,
        is_test=False,
        name=None)
 ```
-

doc/fluid/advanced_guide/distributed_training/index_cn.rst

+##########
+分布式训练
+##########
+
+..  toctree::
+    :maxdepth: 1
+
+    cluster_quick_start.rst
+    cluster_howto.rst
+    fleet_api_howto_cn.rst

doc/fluid/advanced_guide/distributed_training/index_en.rst

+..  _user_guide_distribute_en:
+
+######################
+Distributed Training
+######################
+
+.. toctree::
+   :maxdepth: 1
+
+   cluster_quick_start_en.rst
+   cluster_howto_en.rst
+

doc/fluid/user_guides/howto/training/multi_node.rst → doc/fluid/advanced_guide/distributed_training/multi_node.rst

-########
+########
 多机训练
 ########
 
@@ -8,5 +8,3 @@
     cluster_quick_start.rst
     cluster_howto.rst
     fleet_api_howto_cn.rst
-    train_on_baidu_cloud_cn.rst
-    deploy_ctr_on_baidu_cloud_cn.rst

doc/fluid/user_guides/howto/training/src/dist_train_demo.py → doc/fluid/advanced_guide/distributed_training/src/dist_train_demo.py

@@ -27,6 +27,7 @@ import paddle.fluid as fluid
 BATCH_SIZE = 64
 PASS_NUM = 1
 
+
 def loss_net(hidden, label):
     prediction = fluid.layers.fc(input=hidden, size=10, act='softmax')
     loss = fluid.layers.cross_entropy(input=prediction, label=label)
@@ -34,6 +35,7 @@ def loss_net(hidden, label):
     acc = fluid.layers.accuracy(input=prediction, label=label)
     return prediction, avg_loss, acc
 
+
 def conv_net(img, label):
     conv_pool_1 = fluid.nets.simple_img_conv_pool(
         input=img,
@@ -79,8 +81,7 @@ def train(use_cuda, role, endpoints, current_endpoint, trainer_id, trainers):
         exe = fluid.Executor(place)
 
         train_reader = paddle.batch(
-            paddle.reader.shuffle(
-                paddle.dataset.mnist.train(), buf_size=500),
+            paddle.reader.shuffle(paddle.dataset.mnist.train(), buf_size=500),
             batch_size=BATCH_SIZE)
         test_reader = paddle.batch(
             paddle.dataset.mnist.test(), batch_size=BATCH_SIZE)
@@ -88,20 +89,23 @@ def train(use_cuda, role, endpoints, current_endpoint, trainer_id, trainers):
         exe.run(fluid.default_startup_program())
         for pass_id in range(PASS_NUM):
             for batch_id, data in enumerate(train_reader()):
-                acc_np, avg_loss_np = exe.run(prog,
-                                            feed=feeder.feed(data),
-                                            fetch_list=[acc, avg_loss])
+                acc_np, avg_loss_np = exe.run(
+                    prog, feed=feeder.feed(data), fetch_list=[acc, avg_loss])
                 if (batch_id + 1) % 10 == 0:
                     print(
                         'PassID {0:1}, BatchID {1:04}, Loss {2:2.2}, Acc {3:2.2}'.
                         format(pass_id, batch_id + 1,
-                                float(avg_loss_np.mean()), float(acc_np.mean())))
+                               float(avg_loss_np.mean()), float(
+                                   acc_np.mean())))
+
 
 if __name__ == '__main__':
     if len(sys.argv) != 6:
-        print("Usage: python %s role endpoints current_endpoint trainer_id trainers" % sys.argv[0])
+        print(
+            "Usage: python %s role endpoints current_endpoint trainer_id trainers"
+            % sys.argv[0])
         exit(0)
     role, endpoints, current_endpoint, trainer_id, trainers = \
         sys.argv[1:]
-    train(True, role, endpoints, current_endpoint, int(trainer_id), int(trainers))
-
+    train(True, role, endpoints, current_endpoint,
+          int(trainer_id), int(trainers))

doc/fluid/user_guides/howto/evaluation_and_debugging/debug/visualdl.md → doc/fluid/advanced_guide/evaluation_debugging/debug/visualdl.md

@@ -246,4 +246,3 @@ VisualDL 是由 [PaddlePaddle](http://www.paddlepaddle.org/) 和
 ## 更多细节
 
 想了解更多关于VisualDL的使用介绍，请查看[文档](https://github.com/PaddlePaddle/VisualDL/tree/develop/demo)
-

doc/fluid/user_guides/howto/evaluation_and_debugging/debug/visualdl_en.md → doc/fluid/advanced_guide/evaluation_debugging/debug/visualdl_en.md

@@ -262,4 +262,3 @@ We welcome everyone to use, comment and contribute to VisualDL :)
 ## More details
 
 For more details about how to use VisualDL, please take a look at [documents](https://github.com/PaddlePaddle/VisualDL/tree/develop/demo)
-