test=develop, test=document_fix (#2126)

doc/fluid/advanced_guide/addon_development/new_op/new_op.md

@@ -168,7 +168,7 @@ class MulOpGradMaker : public framework::SingleGradOpMaker<T> {
 - 有些Op的前向逻辑和反向逻辑是一样的，比如[`ScaleOp`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/operators/scale_op.cc).这种情况下，前向Op和反向Op的Kernel可以为同一个。
 - 有些前向Op所对应的反向Op可能有多个，比如[`SumOp`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/operators/sum_op.cc)，这种情况下，`GradMaker`需要继承`framework::GradOpDescMakerBase`。
 - 有些Op的反向对应另一个Op的前向，比如[`SplitOp`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/operators/split_op.h)，这种情况下，[`SplitGradMaker`](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/operators/split_op.h#L157)中定义的`SplitOp`反向Op的Type就是`concat`，
-- 为高效地同时支持动态图和静态图，`SingleGradOpMaker`是一个模板类，在注册Operator时需要同时注册`MulOpGradMaker<OpDesc>`（静态图使用）和`MulOpGradMaker<OpBase>`（动态图使用）。
+- 为高效地同时支持命令式编程模式(动态图)和声明式编程模式(静态图)，`SingleGradOpMaker`是一个模板类，在注册Operator时需要同时注册`MulOpGradMaker<OpDesc>`（声明式编程模式使用）和`MulOpGradMaker<OpBase>`（命令式编程模式使用）。
 
 ### 定义Operator类
 
@@ -303,7 +303,7 @@ MulOp(const std::string &type, const framework::VariableNameMap &inputs,
 通常`OpProtoMaker`和`Op`类的定义写在`.cc`文件中，和下面将要介绍的注册函数一起放在`.cc`中
 
 ### InferShape区分 compile time 和 run time
-在我们的静态图网络中，`InferShape`操作在[编译时(compile time)和运行时(run time)](https://github.com/PaddlePaddle/FluidDoc/blob/release/1.2/doc/fluid/getstarted/Developer's_Guide_to_Paddle_Fluid.md#%E8%AE%A9%E6%88%91%E4%BB%AC%E5%9C%A8fluid%E7%A8%8B%E5%BA%8F%E5%AE%9E%E4%BE%8B%E4%B8%AD%E5%8C%BA%E5%88%86%E7%BC%96%E8%AF%91%E6%97%B6%E5%92%8C%E8%BF%90%E8%A1%8C%E6%97%B6)都会被调用，在compile time时，由于真实的维度未知，框架内部用-1来表示，在run time时，用实际的维度表示，因此维度的值在compile time和 run time时可能不一致，如果存在维度的判断和运算操作，InferShape就需要区分compile time 和 run time。
+在我们的声明式编程模式网络中，`InferShape`操作在[编译时(compile time)和运行时(run time)](https://github.com/PaddlePaddle/FluidDoc/blob/release/1.2/doc/fluid/getstarted/Developer's_Guide_to_Paddle_Fluid.md#%E8%AE%A9%E6%88%91%E4%BB%AC%E5%9C%A8fluid%E7%A8%8B%E5%BA%8F%E5%AE%9E%E4%BE%8B%E4%B8%AD%E5%8C%BA%E5%88%86%E7%BC%96%E8%AF%91%E6%97%B6%E5%92%8C%E8%BF%90%E8%A1%8C%E6%97%B6)都会被调用，在compile time时，由于真实的维度未知，框架内部用-1来表示，在run time时，用实际的维度表示，因此维度的值在compile time和 run time时可能不一致，如果存在维度的判断和运算操作，InferShape就需要区分compile time 和 run time。
 
 以下两种情况需要区分compile time和 run time。
 
@@ -491,7 +491,7 @@ class MulKernel : public framework::OpKernel<T> {
                   ops::MulGradKernel<paddle::platform::CPUDeviceContext, double>);
     ```
 
-    在上面的代码中，使用`REGISTER_OPERATOR`注册了`ops::MulOp`类，类型名为`mul`，该类的`ProtoMaker`为`ops::MulOpMaker`，其`GradOpMaker`分别是`ops::MulOpGradMaker<paddle::framework::OpDesc>`（静态图使用）和`ops::MulOpGradMaker<paddle::imperative::OpBase>`(动态图使用)，并使用`REGISTER_OPERATOR`注册`ops::MulGradOp`，类型名为`mul_grad`。然后，使用`REGISTER_OP_CPU_KERNEL`注册了`ops::MulKernel`类，并特化模板参数为设备为`paddle::platform::CPUPlace`、数据类型为`float`类型和`double`类型；同理，注册`ops::MulGradKernel`类。
+    在上面的代码中，使用`REGISTER_OPERATOR`注册了`ops::MulOp`类，类型名为`mul`，该类的`ProtoMaker`为`ops::MulOpMaker`，其`GradOpMaker`分别是`ops::MulOpGradMaker<paddle::framework::OpDesc>`（声明式编程模式使用）和`ops::MulOpGradMaker<paddle::imperative::OpBase>`(命令式编程模式使用)，并使用`REGISTER_OPERATOR`注册`ops::MulGradOp`，类型名为`mul_grad`。然后，使用`REGISTER_OP_CPU_KERNEL`注册了`ops::MulKernel`类，并特化模板参数为设备为`paddle::platform::CPUPlace`、数据类型为`float`类型和`double`类型；同理，注册`ops::MulGradKernel`类。
 
 
 - 在 `.cu`文件中注册CUDA Kernel。

doc/fluid/advanced_guide/evaluation_debugging/debug/visualdl.md

+
 # VisualDL 工具简介
+
+
 <p align="center">
-  <img src="https://raw.githubusercontent.com/PaddlePaddle/VisualDL/develop/docs/images/vs-logo.png" width="60%" />
+  <img src="http://visualdl.bj.bcebos.com/images/vdl-logo.png" width="70%"/>
 </p>
 
-## 介绍
-VisualDL是一个面向深度学习任务设计的可视化工具，包含了scalar、参数分布、模型结构、图像可视化等功能，项目正处于高速迭代中，新的组件会不断加入。
 
-目前大多数DNN平台均使用Python作为配置语言，VisualDL原生支持python的使用，
-通过在模型的Python配置中添加几行，便可以为训练过程提供丰富的可视化支持。
 
-除了Python SDK之外，VisualDL底层采用C++编写，其暴露的C++ SDK也可以集成到其他平台中，
-实现原生的性能和定制效果。
+VisualDL是深度学习模型可视化分析工具，以丰富的图表呈现训练参数变化趋势、模型结构、数据样本、高维数据分布等。可帮助用户更清晰直观地理解深度学习模型训练过程及模型结构，进而实现高效的模型优化。
 
-## 组件
-VisualDL 目前支持以下组件：
+VisualDL提供丰富的可视化功能，支持实时训练参数分析、图结构、数据样本可视化及高维数据降维呈现等诸多功能。具体功能使用方式，请参见 **VisualDL 使用指南**。项目正处于高速迭代中，敬请期待新组件的加入。
 
-- scalar
-- histogram
-- image
-- audio
-- graph
-- high dimensional
+VisualDL原生支持python的使用， 通过在模型的Python配置中添加几行代码，便可为训练过程提供丰富的可视化支持。
 
-### Scalar
-可以用于展示训练测试的误差趋势
 
-<p align="center">
-<img src="https://raw.githubusercontent.com/daming-lu/large_files/master/loss_scalar.gif" width="60%"/>
-</p>
 
-### Histogram
 
-用于可视化任何tensor中元素分布的变化趋势
 
-<p align="center">
-<img src="https://raw.githubusercontent.com/daming-lu/large_files/master/histogram.gif" width="60%"/>
-</p>
+## 核心亮点
 
-### Image
-可以用于可视化任何tensor，或模型生成的图片
+### 简单易用
 
-<p align="center">
-<img src="https://raw.githubusercontent.com/daming-lu/large_files/master/loss_image.gif" width="60%"/>
-</p>
+API设计简洁易懂，使用简单。模型结构一键实现可视化。
 
-### Audio
-可用于播放输入或生成的音频样本
+### 功能丰富
 
-### Graph
+功能覆盖训练参数、图结构、数据样本及数据降维可视化。
 
-VisualDL的graph支持paddle program的展示，同时兼容 ONNX(Open Neural Network Exchange)[https://github.com/onnx/onnx]，通过与 python SDK的结合，VisualDL可以兼容包括 PaddlePaddle, pytorch, mxnet在内的大部分主流DNN平台。
+### 高兼容性
 
-<p align="center">
-  <img src="https://raw.githubusercontent.com/PaddlePaddle/VisualDL/develop/docs/images/graph_demo.gif" width="60%" />
-</p>
+全面支持Paddle、ONNX、Caffe等市面主流模型结构可视化，广泛支持各类用户进行可视化分析。
 
-要进行paddle模型的展示，需要进行以下两步操作：
+### 全面支持
 
-1. 在paddle代码中，调用`fluid.io.save_inference_model()`接口保存模型
-2. 在命令行界面，使用`visualdl --model_pb [paddle_model_dir]` 加载paddle模型
+与飞桨服务平台及工具组件全面打通，为您在飞桨生态系统中提供最佳使用体验。
 
 
-### High Dimensional
-用高维度数据映射在2D/3D来可视化嵌入
 
-<p align="center">
-<img src="https://raw.githubusercontent.com/PaddlePaddle/VisualDL/develop/docs/getting_started/high_dimensional_3d.png" width="60%"/>
-</p>
+## 安装方式
 
-## 快速尝试
-请使用下面的命令，来快速测试 VisualDL。
+使用pip安装 VisualDL 运行范例：
 
+```shell
+pip install --upgrade visualdl==2.0.0a2
 ```
-# 安装，建議是在虚拟环境或anaconda下。
-pip install --upgrade visualdl
 
-# 运行一个例子，vdl_create_scratch_log 将创建测试日志
-vdl_create_scratch_log
-visualdl --logdir=scratch_log --port=8080
 
-# 访问 http://127.0.0.1:8080
-```
 
-如果出现`TypeError: __init__() got an unexpected keyword argument 'file'`, 是因为protobuf不是3.5以上，运行`pip install --upgrade protobuf`就能解决。
+## 使用方式
 
-如果以上步骤还有出现其他问题，很可能是因为python或pip不同版本或不同位置所致，以下安装方法能解决。
+VisualDL将训练过程中的数据、参数等信息储存至日志文件中后，启动面板即可查看可视化结果。
 
-## 使用 virtualenv 安装
+### 1. 记录日志
 
-[Virtualenv](https://virtualenv.pypa.io/en/stable/) 能创建独立Python环境，也能确保Python和pip的相对位置正确。
+VisualDL的后端提供了Python SDK，可通过LogWriter定制一个日志记录器，接口如下：
 
-在macOS上，安装pip和virtualenv如下：
-```
-sudo easy_install pip
-pip install --upgrade virtualenv
+```python
+class LogWriter(
+                logdir=None,
+                comment='',
+                max_queue=10,
+                flush_secs=120,
+                filename_suffix='',
+                write_to_disk=True,
+                **kwargs
+                )
 ```
 
-在Linux上，安装pip和virtualenv如下:
-```
-sudo apt-get install python3-pip python3-dev python-virtualenv
-```
+#### 接口参数
 
-然后创建一个虚拟环境：
-```
-virtualenv ~/vdl  # for Python2.7
-virtualenv -p python3 ~/vdl for Python 3.x
-```
+| 参数            | 格式    | 含义                                                         |
+| --------------- | ------- | ------------------------------------------------------------ |
+| logdir          | string  | 日志文件所在的路径，VisualDL将在此路径下建立日志文件并进行记录，如果不填则默认为`runs/${CURRENT_TIME}` |
+| comment         | string  | 为日志文件夹名添加后缀，如果制定了logdir则此项无效           |
+| max_queue       | int     | 日志记录消息队列的最大容量，达到此容量则立即写入到日志文件   |
+| flush_secs      | int     | 日志记录消息队列的最大缓存时间，达到此时间则立即写入到日志文件 |
+| filename_suffix | string  | 为默认的日志文件名添加后缀                                   |
+| write_to_disk   | boolean | 是否写入到磁盘                                               |
 
-```~/vdl``` 是你的Virtualenv目录, 你也可以选择任一目录。
+#### 示例
 
-激活虚拟环境如下：
-```
-source ~/vdl/bin/activate
-```
+设置日志文件并记录标量数据：
 
-现在再安装 VisualDL 和运行范例：
+```python
+from visualdl import LogWriter
 
+# 在`./log/scalar_test/train`路径下建立日志文件
+with LogWriter(logdir="./log/scalar_test/train") as writer:
+    # 使用scalar组件记录一个标量数据
+    writer.add_scalar(tag="acc", step=1, value=0.5678)
+    writer.add_scalar(tag="acc", step=2, value=0.6878)
+    writer.add_scalar(tag="acc", step=3, value=0.9878)
 ```
-pip install --upgrade visualdl
 
-# 运行一个例子，vdl_create_scratch_log 将创建测试日志
-vdl_create_scratch_log
-visualdl --logdir=scratch_log --port=8080
+### 2. 启动面板
 
-# 访问 http://127.0.0.1:8080
-```
+在上述示例中，日志已记录三组标量数据，现可启动VisualDL面板查看日志的可视化结果，共有两种启动方式：
+
+#### 在命令行启动
 
-如果在虚拟环境下仍然遇到安装问题，请尝试以下方法。
+使用命令行启动VisualDL面板，命令格式如下：
 
+```python
+visualdl --logdir <dir_1, dir_2, ... , dir_n> --host <host> --port <port>
+```
 
-## 使用 Anaconda 安装
+参数详情：
 
-Anaconda是一个用于科学计算的Python发行版，提供了包管理与环境管理的功能，可以很方便地解决多版本python并存、切换以及各种第三方包安装问题。
+| 参数     | 意义                                                         |
+| -------- | ------------------------------------------------------------ |
+| --logdir | 设定日志所在目录，可以指定多个目录，VisualDL将遍历并且迭代寻找指定目录的子目录，将所有实验结果进行可视化 |
+| --host   | 设定IP，默认为`127.0.0.1`                                    |
+| --port   | 设定端口，默认为`8040`                                       |
 
-请根据[Anaconda下载网站](https://www.anaconda.com/download) 的指示去下载和安装Anaconda.
-下载Python 3.6版本的command-Line installer.
+针对上一步生成的日志，启动命令为：
 
-创建conda环境名字为```vdl```或任何名字:
 ```
-conda create -n vdl pip python=2.7 # or python=3.3, etc.
+visualdl --logdir ./log
 ```
 
-激活conda环境如下:
-```
-source activate vdl
-```
+#### 在Python脚本中启动
 
-现在再安装 VisualDL 和运行范例：
+支持在Python脚本中启动VisualDL面板，接口如下：
 
+```python
+visualdl.server.app.run(logdir,
+                        host="127.0.0.1",
+                        port=8080,
+                        cache_timeout=20,
+                        language=None,
+                        open_browser=False)
 ```
-pip install --upgrade visualdl
 
-# 运行一个例子，vdl_create_scratch_log 将创建测试日志
-vdl_create_scratch_log
-visualdl --logdir=scratch_log --port=8080
+接口参数：
 
-# 访问 http://127.0.0.1:8080
-```
+| 参数          | 格式                                             | 含义                                                         |
+| ------------- | ------------------------------------------------ | ------------------------------------------------------------ |
+| logdir        | string或list[string_1, string_2, ... , string_n] | 日志文件所在的路径，VisualDL将在此路径下递归搜索日志文件并进行可视化，可指定单个或多个路径 |
+| host          | string                                           | 指定启动服务的ip，默认为`127.0.0.1`                          |
+| port          | int                                              | 启动服务端口，默认为`8040`                                   |
+| cache_timeout | int                                              | 后端缓存时间，在缓存时间内前端多次请求同一url，返回的数据从缓存中获取，默认为20秒 |
+| language      | string                                           | VisualDL面板语言，可指定为'EN'或'CN'，默认自动匹配操作系统使用语言 |
+| open_browser  | boolean                                          | 是否打开浏览器，设置为True则在启动后自动打开浏览器并访问VisualDL面板 |
 
-如果仍然遇到安装问题，请尝试以下用源代码安装方法。
+针对上一步生成的日志，我们的启动脚本为：
 
-### 使用代码安装
-```
-#建議是在虚拟环境或anaconda下。
-git clone https://github.com/PaddlePaddle/VisualDL.git
-cd VisualDL
+```python
+from visualdl.server import app
 
-python setup.py bdist_wheel
-pip install --upgrade dist/visualdl-*.whl
+app.run(logdir="./log")
 ```
 
-如果打包和安装遇到其他问题，不安装只想运行Visual DL可以看[这里](https://github.com/PaddlePaddle/VisualDL/blob/develop/docs/develop/how_to_dev_frontend_cn.md)
+在使用任意一种方式启动VisualDL面板后，打开浏览器访问VisualDL面板，即可查看日志的可视化结果，如图：
 
+<p align="center">
+  <img src="http://visualdl.bj.bcebos.com/images/3points_demo.png" width="60%"/>
+</p>
 
-## SDK
-VisualDL 同时提供了python SDK 和 C++ SDK 来实现不同方式的使用。
 
-### Python SDK
-VisualDL 现在支持 Python 2和 Python 3。
 
-以最简单的Scalar组件为例，尝试创建一个scalar组件并插入多个时间步的数据：
+## 可视化功能概览
 
-```python
-import random
-from visualdl import LogWriter
+### Scalar
+以图表形式实时展示训练过程参数，如loss、accuracy。让用户通过观察单组或多组训练参数变化，了解训练过程，加速模型调优。具有两大特点：
 
-logdir = "./tmp"
-logger = LogWriter(logdir, sync_cycle=10000)
+#### 动态展示
 
-# mark the components with 'train' label.
-with logger.mode("train"):
-    # create a scalar component called 'scalars/scalar0'
-    scalar0 = logger.scalar("scalars/scalar0")
+在启动VisualDL Board后，LogReader将不断增量的读取日志中数据并供前端调用展示，因此能够在训练中同步观测指标变化，如下图：
 
-# add some records during DL model running.
-for step in range(100):
-    scalar0.add_record(step, random.random())
-```
+<p align="center">
+  <img src="http://visualdl.bj.bcebos.com/images/dynamic_display.gif" width="60%"/>
+</p>
 
-### C++ SDK
-上面 Python SDK 中代码完全一致的C++ SDK用法如下
-```c++
-#include <cstdlib>
-#include <string>
-#include "visualdl/sdk.h"
 
-namespace vs = visualdl;
-namespace cp = visualdl::components;
+#### 多实验对比
 
-int main() {
-  const std::string dir = "./tmp";
-  vs::LogWriter logger(dir, 10000);
+只需在启动VisualDL Board的时将每个实验日志所在路径同时传入即可，每个实验中相同tag的指标将绘制在一张图中同步呈现，如下图：
 
-  logger.SetMode("train");
-  auto tablet = logger.AddTablet("scalars/scalar0");
+<p align="center">
+  <img src="http://visualdl.bj.bcebos.com/images/multi_experiments.gif" width="100%"/>
+</p>
 
-  cp::Scalar<float> scalar0(tablet);
 
-  for (int step = 0; step < 1000; step++) {
-    float v = (float)std::rand() / RAND_MAX;
-    scalar0.AddRecord(step, v);
-  }
+### Image
+实时展示训练过程中的图像数据，用于观察不同训练阶段的图像变化，进而深入了解训练过程及效果。
 
-  return 0;
-}
-```
-## 启动Board
-当训练过程中已经产生了日志数据，就可以启动board进行实时预览可视化信息
+<p align="center">
+<img src="http://visualdl.bj.bcebos.com/images/image-eye.gif" width="60%"/>
+</p>
 
-```
-visualdl --logdir <some log dir>
-```
 
-board 还支持一下参数来实现远程的访问：
+### High Dimensional
+
+将高维数据进行降维展示，目前支持T-SNE、PCA两种降维方式，用于深入分析高维数据间的关系，方便用户根据数据特征进行算法优化。
+
+<p align="center">
+<img src="http://visualdl.bj.bcebos.com/images/high_dimensional_test.png" width="100%"/>
+</p>
 
-- `--host` 设定IP
-- `--port` 设定端口
-- `-m / --model_pb` 指定 ONNX 格式的模型文件
+## 开源贡献
 
-### 贡献
+VisualDL 是由 [PaddlePaddle](http://www.paddlepaddle.org/) 和 [ECharts](http://echarts.baidu.com/) 合作推出的开源项目。欢迎所有人使用，提意见以及贡献代码。
 
-VisualDL 是由 [PaddlePaddle](http://www.paddlepaddle.org/) 和
-[ECharts](http://echarts.baidu.com/) 合作推出的开源项目。我们欢迎所有人使用，提意见以及贡献代码。
 
 ## 更多细节
 
-想了解更多关于VisualDL的使用介绍，请查看[文档](https://github.com/PaddlePaddle/VisualDL/tree/develop/demo)
+想了解更多关于VisualDL可视化功能的使用详情介绍，请查看**Visual DL 使用指南**。

doc/fluid/beginners_guide/basic_concept/dygraph/DyGraph.md

-# 动态图机制-DyGraph
+# 命令式编程模式(动态图)机制-DyGraph
 
 PaddlePaddle的DyGraph模式是一种动态的图执行机制，可以立即执行结果，无需构建整个图。同时，和以往静态的执行计算图不同，DyGraph模式下您的所有操作可以立即获得执行结果，而不必等待所构建的计算图全部执行完成，这样可以让您更加直观地构建PaddlePaddle下的深度学习任务，以及进行模型的调试，同时还减少了大量用于构建静态计算图的代码，使得您编写、调试网络的过程变得更加便捷。
 
@@ -6,9 +6,9 @@ PaddlePaddle DyGraph是一个更加灵活易用的模式，可提供：
 
 * 更加灵活便捷的代码组织结构：使用python的执行控制流程和面向对象的模型设计
 * 更加便捷的调试功能：直接使用python的打印方法即时打印所需要的结果，从而检查正在运行的模型结果便于测试更改
-* 和静态执行图通用的模型代码：同样的模型代码可以使用更加便捷的DyGraph调试，执行，同时也支持使用原有的静态图模式执行
+* 和静态执行图通用的模型代码：同样的模型代码可以使用更加便捷的DyGraph调试，执行，同时也支持使用原有的声明式编程模式(静态图)模式执行
 
-有关的动态图机制更多的实际模型示例请参考[Paddle/models/dygraph](https://github.com/PaddlePaddle/models/tree/develop/dygraph)
+有关的命令式编程模式机制更多的实际模型示例请参考[Paddle/models/dygraph](https://github.com/PaddlePaddle/models/tree/develop/dygraph)
 
 ## 设置和基本用法
 
@@ -157,7 +157,7 @@ if __name__ == '__main__':
 相反，只有当OP的所有输入都不需要梯度时，该OP的输出也不需要梯度。
 在所有的 ``Variable`` 都不需要梯度的子图中，反向计算就不会进行计算了。
 
-在动态图模式下，除参数以外的所有 ``Variable`` 的 ``stop_gradient`` 属性默认值都为 ``True``，而参数的 ``stop_gradient`` 属性默认值为 ``False``。
+在命令式编程模式模式下，除参数以外的所有 ``Variable`` 的 ``stop_gradient`` 属性默认值都为 ``True``，而参数的 ``stop_gradient`` 属性默认值为 ``False``。
 该属性用于自动剪枝，避免不必要的反向运算。
 
 例如：
@@ -495,7 +495,7 @@ with fluid.dygraph.guard(place):
                 print("epoch: {}, batch_id: {}, loss is: {}".format(epoch, batch_id, avg_loss.numpy()))
 ```
 
-动态图单卡训练转多卡训练需要修改的地方主要有四处：
+命令式编程模式单卡训练转多卡训练需要修改的地方主要有四处：
 1. 需要从环境变量获取设备的ID，即：
 
     ```python
@@ -528,7 +528,7 @@ with fluid.dygraph.guard(place):
     mnist.apply_collective_grads()
     ```
 
-Paddle动态图多进程多卡模型训练启动时需要指定使用的GPU，即如果使用`0,1,2,3`卡，启动方式如下：
+Paddle命令式编程模式多进程多卡模型训练启动时需要指定使用的GPU，即如果使用`0,1,2,3`卡，启动方式如下：
 
 ```
 python -m paddle.distributed.launch --selected_gpus=0,1,2,3 --log_dir ./mylog train.py
@@ -606,7 +606,7 @@ Loss at epoch 0 step 0: [0.5767452]
 
 ## 模型参数的保存
 
-动态图由于模型和优化器在不同的对象中存储，模型参数和优化器信息要分别存储。
+命令式编程模式由于模型和优化器在不同的对象中存储，模型参数和优化器信息要分别存储。
 
 
在模型训练中可以使用 `paddle.fluid.dygraph.save_dygraph(state_dict, model_path)` 来保存模型参数的dict或优化器信息的dict。
 
@@ -817,7 +817,7 @@ Inference result of image/infer_3.png is: 3
 
 ## 编写兼容的模型
 
-以上一步中手写数字识别的例子为例，动态图的模型代码可以直接用于静态图中作为模型代码，执行时，直接使用PaddlePaddle静态图执行方式即可，这里以静态图中的`executor`为例, 模型代码可以直接使用之前的模型代码，执行时使用`Executor`执行即可
+以上一步中手写数字识别的例子为例，命令式编程模式的模型代码可以直接用于声明式编程模式中作为模型代码，执行时，直接使用PaddlePaddle声明式编程模式执行方式即可，这里以声明式编程模式中的`executor`为例, 模型代码可以直接使用之前的模型代码，执行时使用`Executor`执行即可
 
 ```python
 epoch_num = 1

doc/fluid/beginners_guide/basic_concept/index_cn.rst

@@ -11,7 +11,7 @@
 - `Operator <operator.html>`_ : Operator表示对数据的操作。
 - `Program <program.html>`_ : Program表示对计算过程的描述。
 - `Executor <executor.html>`_ : Executor表示执行引擎。
-- `动态图机制-DyGraph <./dygraph/DyGraph.html>`_ : 介绍飞桨动态图执行机制。
+- `命令式编程模式(动态图)机制-DyGraph <./dygraph/DyGraph.html>`_ : 介绍飞桨命令式编程模式执行机制。
 
 ..  toctree::
     :hidden:

doc/fluid/beginners_guide/basic_concept/programming_guide/programming_guide.md

 
 # 编程指南
 
-目前飞桨（PaddlePaddle，以下简称Paddle）已经同时支持动态图和静态图两种编程方式，
-本文主要侧重于介绍静态图的编程方法，关于动态图编程方法，请参考[动态图机制-DyGraph](../dygraph/DyGraph.html)。
+目前飞桨（PaddlePaddle，以下简称Paddle）已经同时支持命令式编程模式(动态图)和声明式编程模式(静态图)两种编程方式，
+本文主要侧重于介绍声明式编程模式的编程方法，关于命令式编程模式编程方法，请参考[命令式编程模式机制-DyGraph](../dygraph/DyGraph.html)。
 
-阅读完本文档，您将了解在Paddle静态图编程方式中，如何表示和定义数据变量，以及如何完整的组建一个深度学习网络并进行训练。
+阅读完本文档，您将了解在Paddle声明式编程模式编程方式中，如何表示和定义数据变量，以及如何完整的组建一个深度学习网络并进行训练。
 
 ## 数据的表示和定义
 
@@ -38,7 +38,7 @@ data = fluid.layers.fill_constant(shape=[3, 4], value=16, dtype='int64')
 
 以上例子中，我们只使用了一种数据类型"int64"，即有符号64位整数数据类型，更多Paddle目前支持的数据类型请查看：[支持的数据类型](../../../advanced_guide/data_preparing/feeding_data.html#fluid)。
 
-需要注意的是，在静态图编程方式中，上述定义的Tensor并不具有值（即使创建常量的时候指定了value），
+需要注意的是，在声明式编程模式编程方式中，上述定义的Tensor并不具有值（即使创建常量的时候指定了value），
 它们仅表示将要执行的操作，在网络执行时（训练或者预测）才会进行真正的赋值操作，
 如您直接打印上例代码中的data将会得对其信息的描述：
 
@@ -166,7 +166,7 @@ print outs
 
 ## 组建更加复杂的网络
 
-某些场景下，用户需要根据当前网络中的某些状态，来具体决定后续使用哪一种操作，或者重复执行某些操作。在动态图中，可以方便的使用Python的控制流语句（如for，if-else等）来进行条件判断，但是在静态图中，由于组网阶段并没有实际执行操作，也没有产生中间计算结果，因此无法使用Python的控制流语句来进行条件判断，为此静态图提供了多个控制流API来实现条件判断。这里以[fluid.layers.while_loop](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/api_cn/layers_cn/while_loop_cn.html)为例来说明如何在静态图中实现条件循环的操作。
+某些场景下，用户需要根据当前网络中的某些状态，来具体决定后续使用哪一种操作，或者重复执行某些操作。在命令式编程模式中，可以方便的使用Python的控制流语句（如for，if-else等）来进行条件判断，但是在声明式编程模式中，由于组网阶段并没有实际执行操作，也没有产生中间计算结果，因此无法使用Python的控制流语句来进行条件判断，为此声明式编程模式提供了多个控制流API来实现条件判断。这里以[fluid.layers.while_loop](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/api_cn/layers_cn/while_loop_cn.html)为例来说明如何在声明式编程模式中实现条件循环的操作。
 
 while_loop API用于实现类似while/for的循环控制功能，使用一个callable的方法cond作为参数来表示循环的条件，只要cond的返回值为True，while_loop就会循环执行循环体body（也是一个callable的方法），直到 cond 的返回值为False。对于while_loop API的详细定义和具体说明请参考文档[fluid.layers.while_loop](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/api_cn/layers_cn/while_loop_cn.html)。
 
@@ -180,7 +180,7 @@ while i < ten:
 print('i =', i)
 ```
 
-在静态图中使用while_loop API实现以上代码的逻辑：
+在声明式编程模式中使用while_loop API实现以上代码的逻辑：
 
 ```python
 # 该代码要求安装飞桨1.7+版本
@@ -210,7 +210,7 @@ print(res) #[array([10])]
 
 ```
 
-限于篇幅，上面仅仅用一个最简单的例子来说明如何在静态图中实现循环操作。循环操作在很多应用中都有着重要作用，比如NLP中常用的Transformer模型，在解码（生成）阶段的Beam Search算法中，需要使用循环操作来进行候选的选取与生成，可以参考[Transformer](https://github.com/PaddlePaddle/models/tree/develop/PaddleNLP/PaddleMT/transformer)模型的实现来进一步学习while_loop在复杂场景下的用法。
+限于篇幅，上面仅仅用一个最简单的例子来说明如何在声明式编程模式中实现循环操作。循环操作在很多应用中都有着重要作用，比如NLP中常用的Transformer模型，在解码（生成）阶段的Beam Search算法中，需要使用循环操作来进行候选的选取与生成，可以参考[Transformer](https://github.com/PaddlePaddle/models/tree/develop/PaddleNLP/PaddleMT/transformer)模型的实现来进一步学习while_loop在复杂场景下的用法。
 
 除while_loop之外，飞桨还提供fluid.layers.cond API来实现条件分支的操作，以及fluid.layers.switch_case和fluid.layers.case API来实现分支控制功能，具体用法请参考文档：[cond](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/api_cn/layers_cn/cond_cn.html)，[switch_case](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/api_cn/layers_cn/switch_case_cn.html)和[case](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/api_cn/layers_cn/case_cn.html#case)
 
@@ -218,7 +218,7 @@ print(res) #[array([10])]
 
 一个典型的模型通常包含4个部分，分别是：输入数据定义，搭建网络（模型前向计算逻辑），定义损失函数，以及选择优化算法。
 
-下面我们通过一个非常简单的数据预测网络（线性回归），来完整的展示如何使用Paddle静态图方式完成一个深度学习模型的组建和训练。
+下面我们通过一个非常简单的数据预测网络（线性回归），来完整的展示如何使用Paddle声明式编程模式方式完成一个深度学习模型的组建和训练。
 
 问题描述：给定一组数据 $<X,Y>$，求解出函数 $f$，使得 $y=f(x)$，其中$X$,$Y$均为一维张量。最终网络可以依据输入$x$，准确预测出$y_{\_predict}$。
 

doc/fluid/beginners_guide/basic_concept/variable.rst

@@ -32,7 +32,7 @@ Paddle 为大部分常见的神经网络基本计算模块都提供了封装。
 
 **2. 占位 Variable**
 
-在静态图模式下，组网的时候通常不知道实际输入的信息，此刻需要一个占位的 :code:`Variable`，表示一个待提供输入的 :code:`Variable`
+在声明式编程模式(静态图)模式下，组网的时候通常不知道实际输入的信息，此刻需要一个占位的 :code:`Variable`，表示一个待提供输入的 :code:`Variable`
 
 Paddle 中使用 :code:`fluid.data` 来接收输入数据， :code:`fluid.data` 需要提供输入 Tensor 的形状信息，当遇到无法确定的维度时，相应维度指定为 None ，如下面的代码片段所示：