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

fc7da52f · sandyhouse · c22fc8b3 · 88707316 · fc7da52f · fc7da52f
142 changed file
--- a/doc/fluid/advanced_guide/evaluation_debugging/debug/visualdl.md
+++ b/doc/fluid/advanced_guide/evaluation_debugging/debug/visualdl.md
-
 # VisualDL 工具简介


@@ -8,14 +7,26 @@



-VisualDL是深度学习模型可视化分析工具，以丰富的图表呈现训练参数变化趋势、模型结构、数据样本、高维数据分布等。可帮助用户更清晰直观地理解深度学习模型训练过程及模型结构，进而实现高效的模型优化。
+VisualDL是飞桨可视化分析工具，以丰富的图表呈现训练参数变化趋势、模型结构、数据样本、直方图、PR曲线及高维数据分布。可帮助用户更清晰直观地理解深度学习模型训练过程及模型结构，进而实现高效的模型优化。
+
+具体功能使用方式请参见**VisualDL使用指南**。项目正处于高速迭代中，敬请期待新组件的加入。

-VisualDL提供丰富的可视化功能，支持实时训练参数分析、图结构、数据样本可视化及高维数据降维呈现等诸多功能。具体功能使用方式，请参见 **VisualDL 使用指南**。项目正处于高速迭代中，敬请期待新组件的加入。
+VisualDL支持浏览器种类：Chrome（81和83）、Safari 13、FireFox（77和78）、Edge（Chromium版）。

 VisualDL原生支持python的使用， 通过在模型的Python配置中添加几行代码，便可为训练过程提供丰富的可视化支持。



+## 目录
+
+* [核心亮点](#核心亮点)
+* [安装方式](#安装方式)
+* [使用方式](#使用方式)
+* [可视化功能概览](#可视化功能概览)
+* [开源贡献](#开源贡献)
+* [更多细节](#更多细节)
+* [技术交流](#技术交流)
+


 ## 核心亮点
@@ -26,7 +37,7 @@ API设计简洁易懂，使用简单。模型结构一键实现可视化。

 ### 功能丰富

-功能覆盖训练参数、图结构、数据样本及数据降维可视化。
+功能覆盖标量、数据样本、图结构、直方图、PR曲线及数据降维可视化。

 ### 高兼容性

@@ -40,13 +51,23 @@ API设计简洁易懂，使用简单。模型结构一键实现可视化。

 ## 安装方式

-使用pip安装 VisualDL 运行范例：
+### 使用pip安装

 ```shell
-pip install --upgrade visualdl==2.0.0a2
+pip install --upgrade --pre visualdl
 ```

+### 使用代码安装

+```
+git clone https://github.com/PaddlePaddle/VisualDL.git
+cd VisualDL
+
+python setup.py bdist_wheel
+pip install --upgrade dist/visualdl-*.whl
+```
+
+需要注意，官方自2020年1月1日起不再维护Python2，为了保障代码可用性，VisualDL现仅支持Python3

 ## 使用方式

@@ -57,15 +78,13 @@ VisualDL将训练过程中的数据、参数等信息储存至日志文件中后
 VisualDL的后端提供了Python SDK，可通过LogWriter定制一个日志记录器，接口如下：

 ```python
-class LogWriter(
-                logdir=None,
+class LogWriter(logdir=None,
                comment='',
                max_queue=10,
                flush_secs=120,
                filename_suffix='',
                write_to_disk=True,
-                **kwargs
-                )
+                **kwargs)
 ```

 #### 接口参数
@@ -103,16 +122,21 @@ with LogWriter(logdir="./log/scalar_test/train") as writer:
 使用命令行启动VisualDL面板，命令格式如下：

 ```python
-visualdl --logdir <dir_1, dir_2, ... , dir_n> --host <host> --port <port>
+visualdl --logdir <dir_1, dir_2, ... , dir_n> --host <host> --port <port> --cache-timeout <cache_timeout> --language <language> --public-path <public_path> --api-only
 ```

 参数详情：

 | 参数            | 意义                                                         |
-| -------- | ------------------------------------------------------------ |
+| --------------- | ------------------------------------------------------------ |
 | --logdir        | 设定日志所在目录，可以指定多个目录，VisualDL将遍历并且迭代寻找指定目录的子目录，将所有实验结果进行可视化 |
+| --model         | 设定模型文件路径(非文件夹路径)，VisualDL将在此路径指定的模型文件进行可视化，目前可支持PaddlePaddle、ONNX、Keras、Core ML、Caffe等多种模型结构，详情可查看[graph支持模型种类]([https://github.com/PaddlePaddle/VisualDL/blob/develop/docs/components/README.md#Graph--%E7%BD%91%E7%BB%9C%E7%BB%93%E6%9E%84%E7%BB%84%E4%BB%B6](https://github.com/PaddlePaddle/VisualDL/blob/develop/docs/components/README.md#Graph--网络结构组件)) |
 | --host          | 设定IP，默认为`127.0.0.1`                                    |
 | --port          | 设定端口，默认为`8040`                                       |
+| --cache-timeout | 后端缓存时间，在缓存时间内前端多次请求同一url，返回的数据从缓存中获取，默认为20秒 |
+| --language      | VisualDL面板语言，可指定为'EN'或'ZH'，默认为浏览器使用语言   |
+| --public-path   | VisualDL面板URL路径，默认是'/app'，即访问地址为'http://&lt;host&gt;:&lt;port&gt;/app' |
+| --api-only      | 是否只提供API，如果设置此参数，则VisualDL不提供页面展示，只提供API服务，此时API地址为'http://&lt;host&gt;:&lt;port&gt;/&lt;public_path&gt;/api'；若没有设置public_path参数，则默认为'http://&lt;host&gt;:&lt;port&gt;/api' |

 针对上一步生成的日志，启动命令为：

@@ -130,19 +154,26 @@ visualdl.server.app.run(logdir,
                        port=8080,
                        cache_timeout=20,
                        language=None,
+                        public_path=None,
+                        api_only=False,
                        open_browser=False)
 ```

-接口参数：
+请注意：除`logdir`外，其他参数均为不定参数，传递时请指明参数名。
+
+接口参数具体如下：

 | 参数          | 格式                                             | 含义                                                         |
 | ------------- | ------------------------------------------------ | ------------------------------------------------------------ |
 | logdir        | string或list[string_1, string_2, ... , string_n] | 日志文件所在的路径，VisualDL将在此路径下递归搜索日志文件并进行可视化，可指定单个或多个路径 |
+| model         | string                                           | 模型文件路径(非文件夹路径)，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面板 |
+| language      | string                                           | VisualDL面板语言，可指定为'en'或'zh'，默认为浏览器使用语言   |
+| public_path   | string                                           | VisualDL面板URL路径，默认是'/app'，即访问地址为'http://<host>:<port>/app' |
+| api_only      | boolean                                          | 是否只提供API，如果设置此参数，则VisualDL不提供页面展示，只提供API服务，此时API地址为'http://<host>:<port>/<public_path>/api'；若没有设置public_path参数，则默认为http://<host>:<port>/api' |
+| open_browser  | boolean                                          | 是否打开浏览器，设置为True则在启动后自动打开浏览器并访问VisualDL面板，若设置api_only，则忽略此参数 |

 针对上一步生成的日志，我们的启动脚本为：

@@ -155,7 +186,7 @@ app.run(logdir="./log")
 在使用任意一种方式启动VisualDL面板后，打开浏览器访问VisualDL面板，即可查看日志的可视化结果，如图：

 <p align="center">
-  <img src="http://visualdl.bj.bcebos.com/images/3points_demo.png" width="60%"/>
+  <img src="https://user-images.githubusercontent.com/48054808/82786044-67ae9880-9e96-11ea-8a2b-3a0951a6ec19.png" width="60%"/>
 </p>


@@ -163,27 +194,31 @@ app.run(logdir="./log")
 ## 可视化功能概览

 ### Scalar
+
 以图表形式实时展示训练过程参数，如loss、accuracy。让用户通过观察单组或多组训练参数变化，了解训练过程，加速模型调优。具有两大特点：

 #### 动态展示

-在启动VisualDL Board后，LogReader将不断增量的读取日志中数据并供前端调用展示，因此能够在训练中同步观测指标变化，如下图：
+在启动VisualDL后，LogReader将不断增量的读取日志中数据并供前端调用展示，因此能够在训练中同步观测指标变化，如下图：

 <p align="center">
  <img src="http://visualdl.bj.bcebos.com/images/dynamic_display.gif" width="60%"/>
 </p>


+
 #### 多实验对比

-只需在启动VisualDL Board的时将每个实验日志所在路径同时传入即可，每个实验中相同tag的指标将绘制在一张图中同步呈现，如下图：
+只需在启动VisualDL时将每个实验日志所在路径同时传入即可，每个实验中相同tag的指标将绘制在一张图中同步呈现，如下图：

 <p align="center">
  <img src="http://visualdl.bj.bcebos.com/images/multi_experiments.gif" width="100%"/>
 </p>


+
 ### Image
+
 实时展示训练过程中的图像数据，用于观察不同训练阶段的图像变化，进而深入了解训练过程及效果。

 <p align="center">
@@ -191,6 +226,56 @@ app.run(logdir="./log")
 </p>


+
+### Audio
+
+实时查看训练过程中的音频数据，监控语音识别与合成等任务的训练过程。
+
+<p align="center">
+<img src="https://user-images.githubusercontent.com/48054808/89017647-38605000-d34d-11ea-9d75-7d10b9854c36.gif" width="100%"/>
+</p>
+
+
+
+### Graph
+
+一键可视化模型的网络结构。可查看模型属性、节点信息、节点输入输出等，并支持节点搜索，辅助用户快速分析模型结构与了解数据流向。
+
+<p align="center">
+<img src="https://user-images.githubusercontent.com/48054808/84483052-5acdd980-accb-11ea-8519-1608da7ee698.png" width="100%"/>
+</p>
+
+
+
+### Histogram
+
+以直方图形式展示Tensor（weight、bias、gradient等）数据在训练过程中的变化趋势。深入了解模型各层效果，帮助开发者精准调整模型结构。
+
+- Offset模式
+
+<p align="center">
+<img src="https://user-images.githubusercontent.com/48054808/86551031-86647c80-bf76-11ea-8ec2-8c86826c8137.png" width="100%"/>
+</p>
+
+
+
+- Overlay模式
+
+<p align="center">
+<img src="https://user-images.githubusercontent.com/48054808/86551033-882e4000-bf76-11ea-8e6a-af954c662ced.png" width="100%"/>
+</p>
+
+
+
+### PR Curve
+
+精度-召回率曲线，帮助开发者权衡模型精度和召回率之间的平衡，设定最佳阈值。
+
+<p align="center">
+<img src="https://user-images.githubusercontent.com/48054808/86738774-ee46c000-c067-11ea-90d2-a98aac445cca.png" width="100%"/>
+</p>
+
+
 ### High Dimensional

 将高维数据进行降维展示，目前支持T-SNE、PCA两种降维方式，用于深入分析高维数据间的关系，方便用户根据数据特征进行算法优化。
@@ -201,9 +286,15 @@ app.run(logdir="./log")

 ## 开源贡献

-VisualDL 是由 [PaddlePaddle](http://www.paddlepaddle.org/) 和 [ECharts](http://echarts.baidu.com/) 合作推出的开源项目。欢迎所有人使用，提意见以及贡献代码。
+VisualDL 是由 [PaddlePaddle](https://www.paddlepaddle.org/) 和 [ECharts](https://echarts.apache.org/) 合作推出的开源项目。
+Graph 相关功能由 [Netron](https://github.com/lutzroeder/netron) 提供技术支持。
+欢迎所有人使用，提意见以及贡献代码。


 ## 更多细节

-想了解更多关于VisualDL可视化功能的使用详情介绍，请查看**Visual DL 使用指南**。
+想了解更多关于VisualDL可视化功能的使用详情介绍，请查看**VisualDL使用指南**。
+
+## 技术交流
+
+欢迎您加入VisualDL官方QQ群：1045783368 与飞桨团队以及其他用户共同针对VisualDL进行讨论与交流。
--- a/doc/fluid/advanced_guide/evaluation_debugging/debug/visualdl_usage.md
+++ b/doc/fluid/advanced_guide/evaluation_debugging/debug/visualdl_usage.md
--- a/doc/fluid/advanced_guide/flags/memory_cn.rst
+++ b/doc/fluid/advanced_guide/flags/memory_cn.rst
@@ -11,13 +11,14 @@ FLAGS_allocator_strategy

 取值范围
 ---------------
-String型，['naive_best_fit', 'auto_growth']中的一个。缺省值为'naive_best_fit'。
+String型，['naive_best_fit', 'auto_growth']中的一个。缺省值如果编译Paddle CMake时使用-DON_INFER=ON为'naive_best_fit'。
+其他默认情况为'auto_growth'。PaddlePaddle pip安装包的默认策略也是'auto_growth'

 示例
 --------
-FLAGS_allocator_strategy=naive_best_fit - 使用预分配best fit分配器。
+FLAGS_allocator_strategy=naive_best_fit - 使用预分配best fit分配器，PaddlePaddle会先占用大多比例的可用内存/显存，在Paddle具体数据使用时分配，这种方式预占空间较大，但内存/显存碎片较少(比如能够支持模型的最大batch size会变大)。

-FLAGS_allocator_strategy=auto_growth - 使用auto growth分配器。
+FLAGS_allocator_strategy=auto_growth - 使用auto growth分配器。PaddlePaddle会随着真实数据需要再占用内存/显存，但内存/显存可能会产生碎片（比如能够支持模型的最大batch size会变小）。


 FLAGS_eager_delete_scope

--- a/doc/fluid/advanced_guide/flags/memory_en.rst
+++ b/doc/fluid/advanced_guide/flags/memory_en.rst
@@ -11,13 +11,13 @@ Use to choose allocator strategy of PaddlePaddle.

 Values accepted
 ---------------
-String, enum in ['naive_best_fit', 'auto_growth']. The default value is 'naive_best_fit'.
+String, enum in ['naive_best_fit', 'auto_growth']. The default value will be 'naive_best_fit' if users compile PaddlePaddle with -DON_INFER=ON CMake flag, otherwise is 'auto_growth'. The default PaddlePaddle pip package uses 'auto_growth'.

 Example
 --------
-FLAGS_allocator_strategy=naive_best_fit would use the pre-allocated best fit allocator.
+FLAGS_allocator_strategy=naive_best_fit would use the pre-allocated best fit allocator. 'naive_best_fit' strategy would occupy almost all GPU memory by default but leads to less memory fragmentation (i.e., maximum batch size of models may be larger).

-FLAGS_allocator_strategy=auto_growth would use the auto growth allocator.
+FLAGS_allocator_strategy=auto_growth would use the auto growth allocator. 'auto_growth' strategy would allocate GPU memory on demand but may lead to more memory fragmentation (i.e., maximum batch size of models may be smaller).




--- a/doc/fluid/api/gen_doc.sh
+++ b/doc/fluid/api/gen_doc.sh
@@ -10,7 +10,7 @@ python gen_doc.py --module_name "" --module_prefix "" --output fluid --output_na
 python gen_module_index.py fluid  fluid

 # tensor
-for module in math random stat linalg
+for module in math random stat linalg search
 do
  python gen_doc.py --module_name ${module} --module_prefix ${module} --output ${module} --output_name tensor --to_multiple_files True --output_dir tensor
  python gen_module_index.py tensor.${module} ${module}

--- a/doc/fluid/api/gen_index.py
+++ b/doc/fluid/api/gen_index.py
@@ -27,14 +27,14 @@ API Reference
            file_names.extend(glob.glob(pattern))

        for file_name in sorted(file_names):
-            with open(file_name, 'r')as f:
+            with open(file_name, 'r') as f:
                for i in range(2):
                    line = f.readline().strip()
                    if line.find('paddle.') != -1:
-                        file_object.write('    '+file_name + "\n")
+                        file_object.write('    ' + file_name + "\n")
                        file_names.remove(file_name)

-        file_object.write('    '+'fluid.rst' + "\n")
+        file_object.write('    ' + 'fluid.rst' + "\n")
        for file_name in sorted(file_names):
-            if file_name not in ['index_en.rst', 'fluid.rst']:
-                file_object.write('    '+file_name + "\n")
+            if file_name not in ['index_en.rst']:
+                file_object.write('    ' + file_name + "\n")
--- a/doc/fluid/api/index_en.rst
+++ b/doc/fluid/api/index_en.rst
@@ -6,15 +6,30 @@ API Reference
    :maxdepth: 1

    ../api_guides/index_en.rst
-    paddle.rst
    dataset.rst
-    tensor.rst
-    nn.rst
-    imperative.rst
    declarative.rst
-    optimizer.rst
-    metric.rst
    framework.rst
+    imperative.rst
    io.rst
-    utils.rst
-    incubate.rst
+    metric.rst
+    nn.rst
+    optimizer.rst
+    tensor.rst
+    fluid.rst
+    backward.rst
+    clip.rst
+    data/data_reader.rst
+    data/dataset.rst
+    dygraph.rst
+    executor.rst
+    fluid.rst
+    initializer.rst
+    layers.rst
+    metrics.rst
+    nets.rst
+    paddle.rst
+    profiler.rst
+    regularizer.rst
+    transpiler.rst
+    unique_name.rst
+    review_tmp.rst
--- a/doc/fluid/api/nn.rst
+++ b/doc/fluid/api/nn.rst
@@ -49,6 +49,7 @@ paddle.nn
    nn/exponential_decay.rst
    nn/filter_by_instag.rst
    nn/fsp_matrix.rst
+    nn/functional.rst
    nn/gather_tree.rst
    nn/gelu.rst
    nn/generate_mask_labels.rst
@@ -67,6 +68,7 @@ paddle.nn
    nn/huber_loss.rst
    nn/image_resize.rst
    nn/image_resize_short.rst
+    nn/initializer.rst
    nn/inverse_time_decay.rst
    nn/iou_similarity.rst
    nn/kldiv_loss.rst
@@ -82,24 +84,22 @@ paddle.nn
    nn/logsigmoid.rst
    nn/loss.rst
    nn/lrn.rst
-    nn/margin_rank_loss.rst
+    nn/matrix_nms.rst
    nn/maxout.rst
    nn/mse_loss.rst
    nn/multiclass_nms.rst
-    nn/matrix_nms.rst
    nn/natural_exp_decay.rst
    nn/noam_decay.rst
    nn/npair_loss.rst
    nn/one_hot.rst
    nn/pad.rst
-    nn/pad_constant_like.rst
    nn/pad2d.rst
+    nn/pad_constant_like.rst
    nn/ParameterList.rst
    nn/piecewise_decay.rst
    nn/pixel_shuffle.rst
    nn/polygon_box_transform.rst
    nn/polynomial_decay.rst
-    nn/pool2d.rst
    nn/Pool2D.rst
    nn/pool3d.rst
    nn/prior_box.rst
@@ -149,3 +149,5 @@ paddle.nn
    nn/while_loop.rst
    nn/yolo_box.rst
    nn/yolov3_loss.rst
+    nn/functional/loss/margin_ranking_loss.rst
+    nn/layer/loss/MarginRankingLoss.rst
--- a/doc/fluid/api/nn/functional.rst
+++ b/doc/fluid/api/nn/functional.rst
+==========
+functional
+==========
+
+..  toctree::
+    :maxdepth: 1
+
+    functional/l1_loss.rst
+    functional/nll_loss.rst
--- a/doc/fluid/api/nn/functional/l1_loss.rst
+++ b/doc/fluid/api/nn/functional/l1_loss.rst
+.. _api_nn_functional_l1_loss:
+
+l1_loss
+------
+
+..  autoclass:: paddle.nn.functional.l1_loss
+    :members:
+    :inherited-members:
+    :noindex:
+
--- a/doc/fluid/api/nn/functional/loss/margin_ranking_loss.rst
+++ b/doc/fluid/api/nn/functional/loss/margin_ranking_loss.rst
+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_nn_functional_loss_margin_ranking_loss:
+
+margin_ranking_loss
+-------------------
+
+..  autofunction:: paddle.nn.functional.loss.margin_ranking_loss
+    :noindex:
+
--- a/doc/fluid/api/nn/functional/nll_loss.rst
+++ b/doc/fluid/api/nn/functional/nll_loss.rst
+.. _api_nn_functional_nll_loss:
+
+nll_loss
+-------------------------------
+
+..  autoclass:: paddle.nn.functional.nll_loss
+    :members:
+    :inherited-members:
+    :noindex:
+
--- a/doc/fluid/api/nn/layer/loss/MarginRankingLoss.rst
+++ b/doc/fluid/api/nn/layer/loss/MarginRankingLoss.rst
+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_nn_layer_loss_MarginRankingLoss:
+
+MarginRankingLoss
+-----------------
+
+..  autoclass:: paddle.nn.layer.loss.MarginRankingLoss
+    :members:
+    :inherited-members:
+    :noindex:
+
--- a/doc/fluid/api/nn/loss/NLLLoss.rst
+++ b/doc/fluid/api/nn/loss/NLLLoss.rst
+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_nn_loss_NLLLoss:
+
+NLLLoss
+-------------------------------
+
+..  autoclass:: paddle.nn.loss.NLLLoss
+    :members:
+    :inherited-members:
+    :noindex:
+
--- a/doc/fluid/api/nn/margin_rank_loss.rst
+++ b/doc/fluid/api/nn/margin_rank_loss.rst
-.. _api_nn_margin_rank_loss:
-
-margin_rank_loss
-------------------------------
-:doc_source: paddle.fluid.layers.margin_rank_loss
-
-
--- a/doc/fluid/api/nn/softmax.rst
+++ b/doc/fluid/api/nn/softmax.rst
+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
 .. _api_nn_softmax:

 softmax
-------------------------------
-:doc_source: paddle.fluid.layers.softmax
+-------

+..  autofunction:: paddle.nn.functional.softmax
+    :noindex:

--- a/doc/fluid/api/paddle.rst
+++ b/doc/fluid/api/paddle.rst
@@ -45,10 +45,7 @@ paddle
 	paddle/dot.rst
 	paddle/elementwise_add.rst
 	paddle/elementwise_div.rst
-	paddle/elementwise_equal.rst
 	paddle/elementwise_floordiv.rst
-	paddle/elementwise_max.rst
-	paddle/elementwise_min.rst
 	paddle/elementwise_mod.rst
 	paddle/elementwise_mul.rst
 	paddle/elementwise_pow.rst
@@ -56,6 +53,7 @@ paddle
 	paddle/elementwise_sum.rst
 	paddle/enable_imperative.rst
 	paddle/equal.rst
+	paddle/equal_all.rst
 	paddle/erf.rst
 	paddle/ExecutionStrategy.rst
 	paddle/Executor.rst
@@ -99,9 +97,11 @@ paddle
 	paddle/manual_seed.rst
 	paddle/matmul.rst
 	paddle/max.rst
+	paddle/maximum.rst
 	paddle/mean.rst
 	paddle/meshgrid.rst
 	paddle/min.rst
+	paddle/minimum.rst
 	paddle/mm.rst
 	paddle/mul.rst
 	paddle/multiplex.rst

--- a/doc/fluid/api/paddle/cumsum.rst
+++ b/doc/fluid/api/paddle/cumsum.rst
@@ -2,6 +2,6 @@

 cumsum
 -------------------------------
-:doc_source: paddle.fluid.layers.cumsum
+:doc_source: paddle.tensor.cumsum


--- a/doc/fluid/api/paddle/elementwise_equal.rst
+++ b/doc/fluid/api/paddle/elementwise_equal.rst
-.. _api_paddle_elementwise_equal:
-
-elementwise_equal
-------------------------------
-:doc_source: paddle.fluid.layers.equal
-
-
--- a/doc/fluid/api/paddle/elementwise_max.rst
+++ b/doc/fluid/api/paddle/elementwise_max.rst
-.. _api_paddle_elementwise_max:
-
-elementwise_max
-------------------------------
-:doc_source: paddle.fluid.layers.elementwise_max
-
-
--- a/doc/fluid/api/paddle/elementwise_min.rst
+++ b/doc/fluid/api/paddle/elementwise_min.rst
-.. _api_paddle_elementwise_min:
-
-elementwise_min
-------------------------------
-:doc_source: paddle.fluid.layers.elementwise_min
-
-
--- a/doc/fluid/api/paddle/equal_all.rst
+++ b/doc/fluid/api/paddle/equal_all.rst
+.. _api_paddle_equal_all
+
+equal_all
+-------------------------------
+:doc_source: paddle.tensor.equal_all
+
+
--- a/doc/fluid/api/paddle/greater_equal.rst
+++ b/doc/fluid/api/paddle/greater_equal.rst
@@ -2,6 +2,6 @@

 greater_equal
 -------------------------------
-:doc_source: paddle.fluid.layers.greater_equal
+:doc_source: paddle.tensor.greater_equal


--- a/doc/fluid/api/paddle/greater_than.rst
+++ b/doc/fluid/api/paddle/greater_than.rst
@@ -2,6 +2,6 @@

 greater_than
 -------------------------------
-:doc_source: paddle.fluid.layers.greater_than
+:doc_source: paddle.tensor.greater_than


--- a/doc/fluid/api/paddle/less_equal.rst
+++ b/doc/fluid/api/paddle/less_equal.rst
@@ -2,6 +2,6 @@

 less_equal
 -------------------------------
-:doc_source: paddle.fluid.layers.less_equal
+:doc_source: paddle.tensor.less_equal


--- a/doc/fluid/api/paddle/less_than.rst
+++ b/doc/fluid/api/paddle/less_than.rst
@@ -2,6 +2,6 @@

 less_than
 -------------------------------
-:doc_source: paddle.fluid.layers.less_than
+:doc_source: paddle.tensor.less_than


--- a/doc/fluid/api/paddle/max.rst
+++ b/doc/fluid/api/paddle/max.rst
@@ -2,6 +2,6 @@

 max
 -------------------------------
-:doc_source: paddle.fluid.layers.reduce_max
+:doc_source: paddle.tensor.max


--- a/doc/fluid/api/paddle/maximum.rst
+++ b/doc/fluid/api/paddle/maximum.rst
+.. _api_paddle_maximum:
+
+maximum
+-------------------------------
+:doc_source: paddle.tensor.maximum
+
+
--- a/doc/fluid/api/paddle/min.rst
+++ b/doc/fluid/api/paddle/min.rst
@@ -2,6 +2,6 @@

 min
 -------------------------------
-:doc_source: paddle.fluid.layers.reduce_min
+:doc_source: paddle.tensor.min


--- a/doc/fluid/api/paddle/minimum.rst
+++ b/doc/fluid/api/paddle/minimum.rst
+.. _api_paddle_minimum:
+
+minimum
+-------------------------------
+:doc_source: paddle.tensor.minimum
+
+
--- a/doc/fluid/api/paddle/not_equal.rst
+++ b/doc/fluid/api/paddle/not_equal.rst
@@ -2,6 +2,6 @@

 not_equal
 -------------------------------
-:doc_source: paddle.fluid.layers.not_equal
+:doc_source: paddle.tensor.not_equal


--- a/doc/fluid/api/review_tmp.rst
+++ b/doc/fluid/api/review_tmp.rst
+=================
+paddle.review_tmp
+=================
+
+..  toctree::
+    :maxdepth: 1
+
+    review_tmp/MarginRankingLoss.rst
+    review_tmp/margin_ranking_loss.rst
--- a/doc/fluid/api/review_tmp/MarginRankingLoss.rst
+++ b/doc/fluid/api/review_tmp/MarginRankingLoss.rst
+.. _api_nn_loss_MarginRankingLoss_tmp:
+
+MarginRankingLoss
+-----------------
+
+..  autoclass:: paddle.nn.loss.MarginRankingLoss
+    :members:
+    :inherited-members:
+    :noindex:
--- a/doc/fluid/api/review_tmp/margin_ranking_loss.rst
+++ b/doc/fluid/api/review_tmp/margin_ranking_loss.rst
+.. _api_nn_functional_margin_ranking_loss_tmp:
+
+margin_ranking_loss
+-------------------
+
+..  autofunction:: paddle.nn.functional.margin_ranking_loss
+    :noindex:
--- a/doc/fluid/api/tensor.rst
+++ b/doc/fluid/api/tensor.rst
@@ -26,14 +26,12 @@ paddle.tensor
    tensor/div.rst
    tensor/elementwise_add.rst
    tensor/elementwise_div.rst
-    tensor/elementwise_equal.rst
    tensor/elementwise_floordiv.rst
-    tensor/elementwise_max.rst
-    tensor/elementwise_min.rst
    tensor/elementwise_mod.rst
    tensor/elementwise_mul.rst
    tensor/elementwise_pow.rst
    tensor/elementwise_sub.rst
+    tensor/equal_all.rst
    tensor/erf.rst
    tensor/exp.rst
    tensor/expand.rst
@@ -64,8 +62,10 @@ paddle.tensor
    tensor/logical_xor.rst
    tensor/math.rst
    tensor/max.rst
+    tensor/maximum.rst
    tensor/mean.rst
    tensor/min.rst
+    tensor/minimum.rst
    tensor/mm.rst
    tensor/mul.rst
    tensor/multiplex.rst
@@ -93,6 +93,7 @@ paddle.tensor
    tensor/scatter.rst
    tensor/scatter_nd.rst
    tensor/scatter_nd_add.rst
+    tensor/search.rst
    tensor/shape.rst
    tensor/shard_index.rst
    tensor/shuffle.rst

--- a/doc/fluid/api/tensor/cumsum.rst
+++ b/doc/fluid/api/tensor/cumsum.rst
@@ -2,6 +2,6 @@

 cumsum
 -------------------------------
-:doc_source: paddle.fluid.layers.cumsum
+:doc_source: paddle.tensor.cumsum


--- a/doc/fluid/api/tensor/elementwise_equal.rst
+++ b/doc/fluid/api/tensor/elementwise_equal.rst
-.. _api_tensor_cn_elementwise_equal:
-
-elementwise_equal
-------------------------------
-:doc_source: paddle.fluid.layers.equal
-
-
--- a/doc/fluid/api/tensor/elementwise_max.rst
+++ b/doc/fluid/api/tensor/elementwise_max.rst
-.. _api_tensor_cn_elementwise_max:
-
-elementwise_max
-------------------------------
-:doc_source: paddle.fluid.layers.elementwise_max
-
-
--- a/doc/fluid/api/tensor/elementwise_min.rst
+++ b/doc/fluid/api/tensor/elementwise_min.rst
-.. _api_tensor_cn_elementwise_min:
-
-elementwise_min
-------------------------------
-:doc_source: paddle.fluid.layers.elementwise_min
-
-
--- a/doc/fluid/api/tensor/equal_all.rst
+++ b/doc/fluid/api/tensor/equal_all.rst
+.. _api_tensor_cn_equal_all:
+
+equal_all
+-------------------------------
+:doc_source: paddle.tensor.equal_all
+
+
--- a/doc/fluid/api/tensor/greater_equal.rst
+++ b/doc/fluid/api/tensor/greater_equal.rst
@@ -2,6 +2,6 @@

 greater_equal
 -------------------------------
-:doc_source: paddle.fluid.layers.greater_equal
+:doc_source: paddle.tensor.greater_equal


--- a/doc/fluid/api/tensor/greater_than.rst
+++ b/doc/fluid/api/tensor/greater_than.rst
@@ -2,6 +2,6 @@

 greater_than
 -------------------------------
-:doc_source: paddle.fluid.layers.greater_than
+:doc_source: paddle.tensor.greater_than


--- a/doc/fluid/api/tensor/less_equal.rst
+++ b/doc/fluid/api/tensor/less_equal.rst
@@ -2,6 +2,6 @@

 less_equal
 -------------------------------
-:doc_source: paddle.fluid.layers.less_equal
+:doc_source: paddle.tensor.less_equal


--- a/doc/fluid/api/tensor/less_than.rst
+++ b/doc/fluid/api/tensor/less_than.rst
@@ -2,6 +2,6 @@

 less_than
 -------------------------------
-:doc_source: paddle.fluid.layers.less_than
+:doc_source: paddle.tensor.less_than


--- a/doc/fluid/api/tensor/max.rst
+++ b/doc/fluid/api/tensor/max.rst
@@ -2,6 +2,6 @@

 max
 -------------------------------
-:doc_source: paddle.fluid.layers.reduce_max
+:doc_source: paddle.tensor.max


--- a/doc/fluid/api/tensor/maximum.rst
+++ b/doc/fluid/api/tensor/maximum.rst
+.. _api_tensor_cn_maximum:
+
+maximum
+-------------------------------
+:doc_source: paddle.tensor.maximum
+
+
--- a/doc/fluid/api/tensor/mean.rst
+++ b/doc/fluid/api/tensor/mean.rst
-.. _api_tensor_cn_mean:
+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_tensor_mean:

 mean
-------------------------------
-:doc_source: paddle.fluid.layers.mean
+---------

+..  autofunction:: paddle.tensor.mean
+    :noindex:

--- a/doc/fluid/api/tensor/min.rst
+++ b/doc/fluid/api/tensor/min.rst
@@ -2,6 +2,6 @@

 min
 -------------------------------
-:doc_source: paddle.fluid.layers.reduce_min
+:doc_source: paddle.tensor.min


--- a/doc/fluid/api/tensor/minimum.rst
+++ b/doc/fluid/api/tensor/minimum.rst
+.. _api_tensor_cn_minimum:
+
+minimum
+-------------------------------
+:doc_source: paddle.tensor.minimum
+
+
--- a/doc/fluid/api/tensor/not_equal.rst
+++ b/doc/fluid/api/tensor/not_equal.rst
@@ -2,6 +2,6 @@

 not_equal
 -------------------------------
-:doc_source: paddle.fluid.layers.not_equal
+:doc_source: paddle.tensor.not_equal


--- a/doc/fluid/api_cn/dygraph_cn/Conv2D_cn.rst
+++ b/doc/fluid/api_cn/dygraph_cn/Conv2D_cn.rst
@@ -46,7 +46,7 @@ Conv2D

 参数：
    - **num_channels** (int) - 输入图像的通道数。
-    - **num_fliters** (int) - 滤波器的个数，和输出特征图个数相同。
+    - **num_filters** (int) - 滤波器的个数，和输出特征图个数相同。
    - **filter_size** (int|tuple) - 滤波器大小。如果 ``filter_size`` 是一个元组，则必须包含两个整型数，分别表示滤波器高度和宽度。否则，表示滤波器高度和宽度均为 ``filter_size`` 。
    - **stride** (int|tuple, 可选) - 步长大小。如果 ``stride`` 为元组，则必须包含两个整型数，分别表示垂直和水平滑动步长。否则，表示垂直和水平滑动步长均为 ``stride`` 。默认值：1。
    - **padding** (int|tuple, 可选) - 填充大小。如果 ``padding`` 为元组，则必须包含两个整型数，分别表示竖直和水平边界填充大小。否则，表示竖直和水平边界填充大小均为 ``padding`` 。默认值：0。

--- a/doc/fluid/api_cn/dygraph_cn/no_grad_cn.rst
+++ b/doc/fluid/api_cn/dygraph_cn/no_grad_cn.rst
@@ -4,30 +4,33 @@ no_grad
 -------------------------------


-.. py:method:: paddle.fluid.dygraph.no_grad(func=None)
+.. py:class:: paddle.fluid.dygraph.no_grad

 :api_attr: 命令式编程模式（动态图)
-
+:alias_main: paddle.no_grad
+:alias: paddle.no_grad
+:old_api: paddle.fluid.dygraph.no_grad


 创建一个上下文来禁用动态图梯度计算。在此模式下，每次计算的结果都将具有stop_gradient=True。

-也可以用作一个装饰器（确保不要用括号来初始化）。
+也可以用作一个装饰器（需要创建实例对象作为装饰器）。

 **代码示例**

 ..  code-block:: python

-
    import numpy as np
    import paddle.fluid as fluid

+    paddle.enable_imperative()
+
    # 用作生成器
+
    data = np.array([[2, 3], [4, 5]]).astype('float32')
-    with fluid.dygraph.guard():
    l0 = fluid.Linear(2, 2)  # l0.weight.gradient() is None
    l1 = fluid.Linear(2, 2)
-        with fluid.dygraph.no_grad():
+    with fluid.no_grad():
        # l1.weight.stop_gradient is False
        tmp = l1.weight * 2  # tmp.stop_gradient is True
    x = fluid.dygraph.to_variable(data)
@@ -38,9 +41,9 @@ no_grad
    print(l0.weight.gradient() is None)  # False

    # 用作装饰器
-    @fluid.dygraph.no_grad
+
+    @fluid.no_grad()
    def test_layer():
-        with fluid.dygraph.guard():
        inp = np.ones([3, 1024], dtype='float32')
        t = fluid.dygraph.base.to_variable(inp)
        linear1 = fluid.Linear(1024, 4, bias_attr=False)

--- a/doc/fluid/api_cn/executor_cn/Executor_cn.rst
+++ b/doc/fluid/api_cn/executor_cn/Executor_cn.rst
@@ -39,7 +39,7 @@ Executor支持单GPU、多GPU以及CPU运行。
    train_program = fluid.Program()
    startup_program = fluid.Program()
    with fluid.program_guard(train_program, startup_program):
-        data = fluid.layers.data(name='X', shape=[1], dtype='float32')
+        data = fluid.data(name='X', shape=[None, 1], dtype='float32')
        hidden = fluid.layers.fc(input=data, size=10)
        loss = fluid.layers.mean(hidden)
        fluid.optimizer.SGD(learning_rate=0.01).minimize(loss)
@@ -130,7 +130,7 @@ Executor支持单GPU、多GPU以及CPU运行。
            place = fluid.CPUPlace() # fluid.CUDAPlace(0)
            exe = fluid.Executor(place)
     
-            data = fluid.layers.data(name='X', shape=[1], dtype='float32')
+            data = fluid.data(name='X', shape=[None, 1], dtype='float32')
            hidden = fluid.layers.fc(input=data, size=10)
            loss = fluid.layers.mean(hidden)
            adam = fluid.optimizer.Adam()
@@ -175,8 +175,8 @@ train_from_dataset可以非常容易扩展到大规模分布式在线和离线

        place = fluid.CPUPlace() # 通过设置place = fluid.CUDAPlace(0)使用GPU
        exe = fluid.Executor(place)
-        x = fluid.layers.data(name="x", shape=[10, 10], dtype="int64")
-        y = fluid.layers.data(name="y", shape=[1], dtype="int64", lod_level=1)
+        x = fluid.data(name="x", shape=[None, 10, 10], dtype="int64")
+        y = fluid.data(name="y", shape=[None, 1], dtype="int64", lod_level=1)
        dataset = fluid.DatasetFactory().create_dataset()
        dataset.set_use_var([x, y])
        dataset.set_thread(1)
@@ -210,12 +210,13 @@ train_from_dataset可以非常容易扩展到大规模分布式在线和离线
  import paddle.fluid as fluid
  place = fluid.CPUPlace() # 使用GPU时可设置place = fluid.CUDAPlace(0)
  exe = fluid.Executor(place)
-  x = fluid.layers.data(name="x", shape=[10, 10], dtype="int64")
-  y = fluid.layers.data(name="y", shape=[1], dtype="int64", lod_level=1)
+  x = fluid.data(name="x", shape=[None, 10, 10], dtype="int64")
+  y = fluid.data(name="y", shape=[None, 1], dtype="int64", lod_level=1)
  dataset = fluid.DatasetFactory().create_dataset()
  dataset.set_use_var([x, y])
  dataset.set_thread(1)
  filelist = [] # 您可以设置您自己的filelist，如filelist = ["dataA.txt"]
  dataset.set_filelist(filelist)
  exe.run(fluid.default_startup_program())
-  exe.infer_from_dataset(program=fluid.default_main_program(),dataset=dataset)
+  exe.infer_from_dataset(program=fluid.default_main_program(),
+                         dataset=dataset)
--- a/doc/fluid/api_cn/index_cn.rst
+++ b/doc/fluid/api_cn/index_cn.rst
@@ -107,3 +107,21 @@ Note。
    io_cn.rst
    utils_cn.rst
    incubate_cn.rst
+    fluid_cn.rst
+    backward_cn.rst
+    clip_cn.rst
+    data_cn/data_reader_cn.rst
+    data_cn/dataset_cn.rst
+    dataset_cn.rst
+    dygraph_cn.rst
+    executor_cn.rst
+    initializer_cn.rst
+    io_cn.rst
+    layers_cn.rst
+    metrics_cn.rst
+    nets_cn.rst
+    optimizer_cn.rst
+    profiler_cn.rst
+    regularizer_cn.rst
+    transpiler_cn.rst
+    unique_name_cn.rst
--- a/doc/fluid/api_cn/initializer_cn/MSRAInitializer_cn.rst
+++ b/doc/fluid/api_cn/initializer_cn/MSRAInitializer_cn.rst
@@ -11,7 +11,7 @@ MSRAInitializer
 该接口实现MSRA方式的权重初始化（a.k.a. Kaiming初始化）

 该接口为权重初始化函数，方法来自Kaiming He，Xiangyu Zhang，Shaoqing Ren 和 Jian Sun所写的论文: `Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification <https://arxiv.org/abs/1502.01852>`_ 。这是一个鲁棒性特别强的初始化方法，并且适应了非线性激活函数（rectifier nonlinearities）。
-可以选择使用均匀分布或者正太分布初始化权重；
+可以选择使用均匀分布或者正态分布初始化权重；
 在均匀分布中，范围为[-x,x]，其中：

 .. math::

--- a/doc/fluid/api_cn/layers_cn/concat_cn.rst
+++ b/doc/fluid/api_cn/layers_cn/concat_cn.rst
@@ -3,24 +3,24 @@
 concat
 -------------------------------

-.. py:function:: paddle.fluid.layers.concat(input,axis=0,name=None)
+.. py:function:: paddle.fluid.layers.concat(input, axis=0, name=None)

-:alias_main: paddle.concat
-:alias: paddle.concat,paddle.tensor.concat,paddle.tensor.manipulation.concat
-:old_api: paddle.fluid.layers.concat

-
-
-该OP对输入沿 ``axis`` 轴进行联结。
+该OP对输入沿 ``axis`` 轴进行联结，返回一个新的Tensor。

 参数：
-    - **input** (list) - 输入是待联结的多维 ``Tensor`` 组成的 ``list`` ，支持的数据类型为：float32、float64、int32、int64。
-    - **axis** (int|Variable，可选) - 整数或者形状为[1]的 ``Tensor``，数据类型为 ``int32``。指定对输入Tensor进行运算的轴， ``axis`` 的有效范围是[-R, R)，R是输入 ``input`` 中 ``Tensor`` 的维度， ``axis`` 为负值时与 :math:`axis + R` 等价。默认值为0。
+    - **input** (list|tuple|Tensor) - 待联结的Tensor list，Tensor tuple或者Tensor，支持的数据类型为：bool、float16、 float32、float64、int32、int64。 ``input`` 中所有Tensor的数据类型必须一致。
+    - **axis** (int|Tensor，可选) - 指定对输入Tensor进行运算的轴，可以是整数或者形状为[1]的Tensor，数据类型为int32或者int64。 ``axis`` 的有效范围是[-R, R)，R是输入 ``input`` 中Tensor 的维度， ``axis`` 为负值时与 :math:`axis + R` 等价。默认值为0。
    - **name** (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。

-返回：联结后的 ``Tensor`` ，数据类型和 ``input`` 相同。
+返回：联结后的 ``Tensor`` ，数据类型和 ``input`` 中的Tensor相同。
+

-返回类型：Variable
+抛出异常：
+    - ``TypeError``: - 当输入 ``input`` 的类型不是list、tuple或者Tensor的时候。
+    - ``TypeError``: - 当输入 ``input`` 的数据类型不是 bool，float16， float32， float64， int32， int64时。
+    - ``TypeError``: - 当 ``axis`` 的类型不是int或者Tensor时。当 ``axis`` 是Tensor的时候其数据类型不是int32或者int64时。
+    - ``TypeError``: - 当输入 ``input`` 中的Tensor存在数据类型不一致时。

 **代码示例**：

@@ -29,18 +29,18 @@ concat
  import paddle.fluid as fluid
  import numpy as np

-  in1 = np.array([[1,2,3],
-                  [4,5,6]])
-  in2 = np.array([[11,12,13],
-                  [14,15,16]])
-  in3 = np.array([[21,22],
-                  [23,24]])
+  in1 = np.array([[1, 2, 3],
+                  [4, 5, 6]])
+  in2 = np.array([[11, 12, 13],
+                  [14, 15, 16]])
+  in3 = np.array([[21, 22],
+                  [23, 24]])
  with fluid.dygraph.guard():
      x1 = fluid.dygraph.to_variable(in1)
      x2 = fluid.dygraph.to_variable(in2)
      x3 = fluid.dygraph.to_variable(in3)
-      out1 = fluid.layers.concat(input=[x1,x2,x3], axis=-1)
-      out2 = fluid.layers.concat(input=[x1,x2], axis=0)
+      out1 = fluid.layers.concat(input=[x1, x2, x3], axis=-1)
+      out2 = fluid.layers.concat(input=[x1, x2], axis=0)
      print(out1.numpy())
      # [[ 1  2  3 11 12 13 21 22]
      #  [ 4  5  6 14 15 16 23 24]]

--- a/doc/fluid/api_cn/layers_cn/cumsum_cn.rst
+++ b/doc/fluid/api_cn/layers_cn/cumsum_cn.rst
@@ -5,11 +5,6 @@ cumsum

 .. py:function:: paddle.fluid.layers.cumsum(x,axis=None,exclusive=None,reverse=None)

-:alias_main: paddle.cumsum
-:alias: paddle.cumsum,paddle.tensor.cumsum,paddle.tensor.math.cumsum
-:old_api: paddle.fluid.layers.cumsum
-
-

 沿给定轴(axis)的元素的累加和。默认结果的第一个元素和输入的第一个元素一致。如果exlusive为True，结果的第一个元素则为0。


--- a/doc/fluid/api_cn/layers_cn/equal_cn.rst
+++ b/doc/fluid/api_cn/layers_cn/equal_cn.rst
@@ -3,9 +3,7 @@
 equal
 -------------------------------

-.. py:function:: paddle.fluid.layers.equal(x,y,cond=None)
-
-
+.. py:function:: paddle.fluid.layers.equal(x, y, cond=None, name=None)


 该OP返回 :math:`x==y` 逐元素比较x和y是否相等，x和y的维度应该相同。
@@ -13,7 +11,8 @@ equal
 参数：
    - **x** (Variable) - 输入Tensor，支持的数据类型包括 float32， float64，int32， int64。
    - **y** (Variable) - 输入Tensor，支持的数据类型包括 float32， float64， int32， int64。
-    - **cond** (Variable，可选) - 逐元素比较的结果Tensor，可以是程序中已经创建的任何Variable。默认值为None，此时将创建新的Variable来保存输出结果。
+    - **cond** (Variable，可选) – 如果为None，则创建一个Tensor来作为进行比较的输出结果，该Tensor的shape和数据类型和输入x一致；如果不为None，则将Tensor作为该OP的输出，数据类型和数据shape需要和输入x一致。默认值为None。 
+    - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。

 返回：输出结果的Tensor，输出Tensor的shape和输入一致，Tensor数据类型为bool。


--- a/doc/fluid/api_cn/layers_cn/eye_cn.rst
+++ b/doc/fluid/api_cn/layers_cn/eye_cn.rst
@@ -3,25 +3,20 @@
 eye
 -------------------------------

-.. py:function:: paddle.fluid.layers.eye(num_rows, num_columns=None, batch_shape=None, dtype='float32')
+.. py:function:: paddle.fluid.layers.eye(num_rows, num_columns=None, batch_shape=None, dtype='float32', name=None)

-:alias_main: paddle.eye
-:alias: paddle.eye,paddle.tensor.eye,paddle.tensor.creation.eye
-:update_api: paddle.fluid.layers.eye

-
-
-该OP用来构建二维张量，或一个批次的二维张量。
+该OP用来构建二维Tensor，或一个批次的二维Tensor。

 参数：
-    - **num_rows** (int) - 该批次二维张量的行数，数据类型为非负int32。
-    - **num_columns** (int, 可选) - 该批次二维张量的列数，数据类型为非负int32。若为None，则默认等于num_rows。
-    - **batch_shape** (list(int), 可选) - 如若提供，则返回向量的主批次维度将为batch_shape。
-    - **dtype** (np.dtype|core.VarDesc.VarType|str，可选) - 返回张量的数据类型，可为int32，int64，float16，float32，float64，默认数据类型为float32。
+    - **num_rows** (int) - 该批次二维Tensor的行数，数据类型为非负int32。
+    - **num_columns** (int, 可选) - 该批次二维Tensor的列数，数据类型为非负int32。若为None，则默认等于num_rows。
+    - **batch_shape** (list(int), 可选) - 如若提供，则返回Tensor的主批次维度将为batch_shape。
+    - **dtype** (np.dtype|core.VarDesc.VarType|str，可选) - 返回Tensor的数据类型，可为int32，int64，float16，float32，float64，默认数据类型为float32。
+    - **name** (str) – 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，默认值为None。
    
-返回：shape为batch_shape + [num_rows, num_columns]的张量。
+返回： ``shape`` 为batch_shape + [num_rows, num_columns]的Tensor。

-返回类型：Variable（Tensor|LoDTensor）数据类型为int32，int64，float16，float32，float64的Tensor或者LoDTensor。

 抛出异常：
    - ``TypeError``: - 如果 ``dtype`` 的类型不是float16， float32， float64， int32， int64其中之一。

--- a/doc/fluid/api_cn/layers_cn/fill_constant_cn.rst
+++ b/doc/fluid/api_cn/layers_cn/fill_constant_cn.rst
@@ -44,6 +44,6 @@ fill_constant
    positive_2 = fluid.layers.fill_constant([1], "int32", 2)
    data3 = fluid.layers.fill_constant(shape=[1, positive_2], dtype='float32', value=1.5) # data3=[1.5, 1.5]

-    # attr shape is an Variable Tensor.
+    # attr shape is a Variable Tensor.
    shape = fluid.layers.fill_constant([1,2], "int32", 2) # shape=[2,2]
    data4 = fluid.layers.fill_constant(shape=shape, dtype='bool', value=True) # data4=[[True,True],[True,True]]
--- a/doc/fluid/api_cn/layers_cn/greater_equal_cn.rst
+++ b/doc/fluid/api_cn/layers_cn/greater_equal_cn.rst
@@ -3,7 +3,7 @@
 greater_equal
 -------------------------------

-.. py:function:: paddle.fluid.layers.greater_equal(x, y, cond=None)
+.. py:function:: paddle.fluid.layers.greater_equal(x, y, cond=None, name=None)

 :alias_main: paddle.greater_equal
 :alias: paddle.greater_equal,paddle.tensor.greater_equal,paddle.tensor.logic.greater_equal
@@ -18,6 +18,7 @@ greater_equal
    - **x** (Variable) – 进行比较的第一个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。 
    - **y** (Variable) – 进行比较的第二个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。
    - **cond** (Variable，可选) – 如果为None，则创建一个Tensor来作为进行比较的输出结果，该Tensor的shape，数据类型和输入x一致；如果不为None，则将Tensor作为该OP的输出，数据shape和数据类型需要和输入x一致。默认值为None。 
+    - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。

 返回：输出结果的Tensor，数据的shape和输入x一致。


--- a/doc/fluid/api_cn/layers_cn/greater_than_cn.rst
+++ b/doc/fluid/api_cn/layers_cn/greater_than_cn.rst
@@ -3,7 +3,7 @@
 greater_than
 -------------------------------

-.. py:function:: paddle.fluid.layers.greater_than(x, y, cond=None)
+.. py:function:: paddle.fluid.layers.greater_than(x, y, cond=None, name=None)

 :alias_main: paddle.greater_than
 :alias: paddle.greater_than,paddle.tensor.greater_than,paddle.tensor.logic.greater_than
@@ -17,6 +17,7 @@ greater_than
    - **x** (Variable) – 进行比较的第一个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。 
    - **y** (Variable) – 进行比较的第二个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。
    - **cond** (Variable，可选) – 如果为None，则创建一个Tensor来作为进行比较的输出结果，该Tensor的shape和数据类型和输入x一致；如果不为None，则将Tensor作为该OP的输出，数据类型和数据shape需要和输入x一致。默认值为None。 
+    - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。

 返回：输出结果的Tensor，数据的shape和输入x一致。


--- a/doc/fluid/api_cn/layers_cn/less_equal_cn.rst
+++ b/doc/fluid/api_cn/layers_cn/less_equal_cn.rst
@@ -3,7 +3,7 @@
 less_equal
 -------------------------------

-.. py:function:: paddle.fluid.layers.less_equal(x, y, cond=None)
+.. py:function:: paddle.fluid.layers.less_equal(x, y, cond=None, name=None)

 :alias_main: paddle.less_equal
 :alias: paddle.less_equal,paddle.tensor.less_equal,paddle.tensor.logic.less_equal
@@ -17,6 +17,7 @@ less_equal
    - **x** (Variable) – 进行比较的第一个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。 
    - **y** (Variable) – 进行比较的第二个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。
    - **cond** (Variable，可选) – 如果为None，则创建一个Tensor来作为进行比较的输出结果，该Tensor的shape和数据类型和输入x一致；如果不为None，则将Tensor作为该OP的输出，数据类型和数据shape需要和输入x一致。默认值为None。 
+    - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。

 返回：输出结果的Tensor，数据的shape和输入x一致。


--- a/doc/fluid/api_cn/layers_cn/less_than_cn.rst
+++ b/doc/fluid/api_cn/layers_cn/less_than_cn.rst
@@ -3,7 +3,7 @@
 less_than
 -------------------------------

-.. py:function:: paddle.fluid.layers.less_than(x, y, force_cpu=None, cond=None)
+.. py:function:: paddle.fluid.layers.less_than(x, y, force_cpu=None, cond=None, name=None)

 :alias_main: paddle.less_than
 :alias: paddle.less_than,paddle.tensor.less_than,paddle.tensor.logic.less_than
@@ -20,6 +20,7 @@ less_than
    - **y** (Variable) - 进行比较的第二个输入，是一个多维的LoDTensor/Tensor，数据类型可以是float32，float64，int32，int64。
    - **force_cpu** (bool) – 如果为True则强制将输出变量写入CPU内存中，否则将其写入目前所在的运算设备上。默认值为False。注意：该属性已弃用，其值始终是False。
    - **cond** (Variable，可选) – 指定算子输出结果的LoDTensor/Tensor，可以是程序中已经创建的任何Variable。默认值为None，此时将创建新的Variable来保存输出结果。
+    - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。


 返回：输出结果的LoDTensor/Tensor，数据的shape和输入x一致。

--- a/doc/fluid/api_cn/layers_cn/linspace_cn.rst
+++ b/doc/fluid/api_cn/layers_cn/linspace_cn.rst
@@ -3,22 +3,27 @@
 linspace
 -------------------------------

-.. py:function:: paddle.fluid.layers.linspace(start, stop, num, dtype)
+.. py:function:: paddle.fluid.layers.linspace(start, stop, num, dtype=None, name=None)




-该OP在给定区间内返回固定数目的均匀间隔的值。
+该OP返回一个Tensor，Tensor的值为在区间start和stop上均匀间隔的num个值，输出Tensor的长度为num。
+**注意：该OP不进行梯度计算**
 
 参数：
-    - **start** (float|Variable) – start是区间开始的变量，可以是一个浮点标量，或是一个shape为[1]的Tensor，该Tensor的数据类型可以是float32或者是float64。
-    - **stop** (float|Variable) – end是区间结束的变量，可以是一个浮点标量，或是一个shape为[1]的Tensor，该Tensor的数据类型可以是float32或者是float64。
-    - **num** (int|Variable) – num是给定区间内需要划分的区间数，可以是一个整型标量，或是一个shape为[1]的Tensor，该Tensor的数据类型需为int32。
-    - **dtype** (string) – 输出Tensor的数据类型，可以是‘float32’或者是‘float64’。
+    - **start** (float|Tensor) – ``start`` 是区间开始的变量，可以是一个浮点标量，或是一个shape为[1]的Tensor，该Tensor的数据类型可以是float32或者是float64。
+    - **stop** (float|Tensor) – ``end`` 是区间结束的变量，可以是一个浮点标量，或是一个shape为[1]的Tensor，该Tensor的数据类型可以是float32或者是float64。
+    - **num** (int|Tensor) – ``num`` 是给定区间内需要划分的区间数，可以是一个整型标量，或是一个shape为[1]的Tensor，该Tensor的数据类型需为int32。
+    - **dtype** (string, 可选) – 输出Tensor的数据类型，可以是float32或者是float64，如果dtype的数据类型为None，输出Tensor数据类型为float32。
+    - **name** （str， 可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。

 返回：表示等间隔划分结果的1-D Tensor，该Tensor的shape大小为 :math:`[num]` ，在mum为1的情况下，仅返回包含start元素值的Tensor。

-返回类型：Variable
+抛出异常：
+    - ``TypeError`` - 当start或者stop的数据类型不是float32或者float64。
+    - ``TypeError`` - 当num的数据类型不是float32或者float64。
+    - ``TypeError`` - 当dtype的类型不是float32或者float64。

 **代码示例**：


--- a/doc/fluid/api_cn/layers_cn/not_equal_cn.rst
+++ b/doc/fluid/api_cn/layers_cn/not_equal_cn.rst
@@ -3,7 +3,7 @@
 not_equal
 -------------------------------

-.. py:function:: paddle.fluid.layers.not_equal(x, y, cond=None)
+.. py:function:: paddle.fluid.layers.not_equal(x, y, cond=None, name=None)

 :alias_main: paddle.not_equal
 :alias: paddle.not_equal,paddle.tensor.not_equal,paddle.tensor.logic.not_equal
@@ -17,7 +17,7 @@ not_equal
    - **x** (Variable) – 进行比较的第一个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。 
    - **y** (Variable) – 进行比较的第二个输入，是一个多维的Tensor，数据类型可以是float32，float64，int32，int64。
    - **cond** (Variable，可选) – 如果为None，则创建一个Tensor来作为进行比较的输出结果，该Tensor的shape和数据类型和输入x一致；如果不为None，则将Tensor作为该OP的输出，数据类型和数据shape需要和输入x一致。默认值为None。 
-
+    - **name** （str，可选）- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
 返回：输出结果的Tensor，数据的shape和输入x一致。

 返回类型：变量（Variable），数据类型为bool类型。

--- a/doc/fluid/api_cn/layers_cn/ones_cn.rst
+++ b/doc/fluid/api_cn/layers_cn/ones_cn.rst
@@ -5,21 +5,18 @@ ones

 .. py:function:: paddle.fluid.layers.ones(shape,dtype,force_cpu=False)

-
-
-
-**ones**
-
-该OP创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为1的Tensor，该OP会将stop_gradient设置为True，即停止梯度更新。
+该OP创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为1的Tensor。

 参数：
-    - **shape** (tuple|list) - 输出Tensor的形状。
-    - **dtype** (np.dtype|core.VarDesc.VarType|str) - 输出Tensor的数据类型，数据类型必须为float16、float32、float64、int32或int64。
-    - **force_cpu** (bool) – 是否强制将输出Tensor写入CPU内存。如果 ``force_cpu`` 为False，则将输出Tensor写入当前所在运算设备的内存，默认为False。
+    - **shape** (tuple|list|Tensor) - 输出Tensor的形状， ``shape`` 的数据类型为int32或者int64。
+    - **dtype** (np.dtype|core.VarDesc.VarType|str) - 输出Tensor的数据类型，数据类型必须为bool、 float16、float32、float64、int32或int64。
+    - **force_cpu** (bool， 可选) – 是否强制将输出Tensor写入CPU内存。如果 ``force_cpu`` 为False，则将输出Tensor写入当前所在运算设备的内存，默认为False。

 返回：值全为1的Tensor，数据类型和 ``dtype`` 定义的类型一致。

-返回类型：Variable
+抛出异常：
+    - ``TypeError`` - 当 ``dtype`` 不是bool、 float16、float32、float64、int32、int64和None时。
+    - ``TypeError`` - 当 ``shape`` 不是tuple、list、或者Tensor时， 当 ``shape`` 为Tensor，其数据类型不是int32或者int64时。

 **代码示例**：


--- a/doc/fluid/api_cn/layers_cn/softmax_cn.rst
+++ b/doc/fluid/api_cn/layers_cn/softmax_cn.rst
@@ -5,12 +5,6 @@ softmax

 .. py:function:: paddle.fluid.layers.softmax(input, use_cudnn=False, name=None, axis=-1)

-:alias_main: paddle.nn.functional.softmax
-:alias: paddle.nn.functional.softmax,paddle.nn.functional.activation.softmax
-:old_api: paddle.fluid.layers.softmax
-
-
-
 该OP实现了softmax层。OP的计算过程如下：

 步骤1：输入 ``input`` 的 ``axis`` 维会被置换到最后一维；

--- a/doc/fluid/api_cn/layers_cn/split_cn.rst
+++ b/doc/fluid/api_cn/layers_cn/split_cn.rst
@@ -3,7 +3,7 @@
 split
 -------------------------------

-.. py:function:: paddle.fluid.layers.split(input,num_or_sections,dim=-1,name=None)
+.. py:function:: paddle.fluid.layers.split(input, num_or_sections, dim=-1, name=None)



@@ -11,18 +11,18 @@ split
 该OP将输入Tensor分割成多个子Tensor。

 参数：
-    - **input** (Variable) - 输入变量，数据类型为float32，float64，int32，int64的多维Tensor或者LoDTensor。
+    - **input** (Tensor) - 输入变量，数据类型为bool， float16，float32，float64，int32，int64的多维Tensor。
    - **num_or_sections** (int|list|tuple) - 如果 ``num_or_sections`` 是一个整数，则表示Tensor平均划分为相同大小子Tensor的数量。如果 ``num_or_sections`` 是一个list或tuple，那么它的长度代表子Tensor的数量，它的元素可以是整数或者形状为[1]的Tensor，依次代表子Tensor需要分割成的维度的大小。list或tuple的长度不能超过输入Tensor待分割的维度的大小。至多有一个元素值为-1，-1表示该值是由 ``input`` 待分割的维度值和 ``num_or_sections`` 的剩余元素推断出来的。
-    - **dim** (int|Variable，可选) - 整数或者形状为[1]的Tensor，数据类型为int32或int64。表示需要分割的维度。如果dim < 0，则划分的维度为rank(input) + dim。默认值为-1。
+    - **dim** (int|Tenspr，可选) - 整数或者形状为[1]的Tensor，数据类型为int32或int64。表示需要分割的维度。如果 ``dim < 0`` ，则划分的维度为 ``rank(input) + dim`` 。默认值为-1。
    - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。

 返回：分割后的Tensor列表。

-返回类型：列表(Variable(Tensor|LoDTensor))，数据类型为int32，int64，float32，float64。

 抛出异常：
-    - :code:`TypeError`：``num_or_sections`` 不是int、list 或 tuple。
-    - :code:`TypeError`：``dim`` 不是 int 或 Variable。
+    - :code:`TypeError`：``input`` 的数据类型不是bool、float16、float32、float64、int32或int64时 。
+    - :code:`TypeError`：``num_or_sections`` 不是int、list 或 tuple时。
+    - :code:`TypeError`：``dim`` 不是 int 或 Tensor时。当 ``dim`` 为Tensor，其数据类型不是int32或int64时。

 **代码示例**：

@@ -30,27 +30,31 @@ split

    import paddle.fluid as fluid

-    # 输入是维度为[3, 9, 5]的Tensor：
+    # input is a Tensor which shape is [3, 9, 5]
    input = fluid.data(
         name="input", shape=[3, 9, 5], dtype="float32")

-    # 传入num_or_sections为一个整数
-    x0, x1, x2 = fluid.layers.split(input, num_or_sections=3, dim=1)
-    x0.shape  # [3, 3, 5]
-    x1.shape  # [3, 3, 5]
-    x2.shape  # [3, 3, 5]
-
-    # 传入num_or_sections为一个整数列表
-    x0, x1, x2 = fluid.layers.split(input, num_or_sections=[2, 3, 4], dim=1)
-    x0.shape  # [3, 2, 5]
-    x1.shape  # [3, 3, 5]
-    x2.shape  # [3, 4, 5]
-
-    # 传入num_or_sections为一个整数列表，其中有一个元素为-1
-    x0, x1, x2 = fluid.layers.split(input, num_or_sections=[2, 3, -1], dim=1)
-    x0.shape  # [3, 2, 5]
-    x1.shape  # [3, 3, 5]
-    x2.shape  # [3, 4, 5]
+    out0, out1, out2 = fluid.layers.split(input, num_or_sections=3, dim=1)
+    # out0.shape [3, 3, 5]
+    # out1.shape [3, 3, 5]
+    # out2.shape [3, 3, 5]
+
+    out0, out1, out2 = fluid.layers.split(input, num_or_sections=[2, 3, 4], dim=1)
+    # out0.shape [3, 2, 5]
+    # out1.shape [3, 3, 5]
+    # out2.shape [3, 4, 5]
+
+    out0, out1, out2 = fluid.layers.split(input, num_or_sections=[2, 3, -1], dim=1)
+    # out0.shape [3, 2, 5]
+    # out1.shape [3, 3, 5]
+    # out2.shape [3, 4, 5]
+    
+    # dim is negative, the real dim is (rank(input) + axis) which real
+    # value is 1.
+    out0, out1, out2 = fluid.layers.split(input, num_or_sections=3, dim=-2)
+    # out0.shape [3, 3, 5]
+    # out1.shape [3, 3, 5]
+    # out2.shape [3, 3, 5]




--- a/doc/fluid/api_cn/layers_cn/unstack_cn.rst
+++ b/doc/fluid/api_cn/layers_cn/unstack_cn.rst
@@ -14,7 +14,7 @@ unstack
 该OP将单个dim为 ``D`` 的Tensor沿 ``axis`` 轴unpack为 ``num`` 个dim为 ``(D-1)`` 的Tensor

 参数:
-      - **x** (Variable) – 输入x为 ``dim > 0`` 的Tensor，
+      - **x** (Tensor) – 输入x为 ``dim > 0`` 的Tensor，
      支持的数据类型: float32，float64，int32，int64。

      - **axis** (int | 可选) – 输入Tensor进行unpack运算所在的轴，axis的范围为：``[-D, D)`` ，
@@ -24,7 +24,7 @@ unstack

 返回: 长度为num的Tensor列表, 数据类型与输入Tensor相同，dim为 ``(D-1)``。

-返回类型: list(Variable)
+返回类型: list(Tensor)

 抛出异常：
      - :code:`ValueError`：``x.shape[axis]`` <= 0 或 ``axis`` 不在[-D, D)范围内
@@ -34,7 +34,7 @@ unstack
 .. code-block:: python

    import paddle.fluid as fluid
-    x = fluid.layers.data(name='x', shape=[2, 3, 5], dtype='float32')  #创建一个shape=[2, 3, 5]的Tensor
+    x = fluid.data(name='x', shape=[2, 3, 5], dtype='float32')  #创建一个shape=[2, 3, 5]的Tensor
    y = fluid.layers.unstack(x, axis=1)  #沿着第1轴进行unpack, unpack后为3个shape=[2，5]的Tensor



--- a/doc/fluid/api_cn/layers_cn/zeros_cn.rst
+++ b/doc/fluid/api_cn/layers_cn/zeros_cn.rst
@@ -5,21 +5,18 @@ zeros

 .. py:function:: paddle.fluid.layers.zeros(shape,dtype,force_cpu=False)

-
-
-
-**zeros**
-
-该OP创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为0的Tensor，该OP会将stop_gradient设置为True，即停止梯度更新。
+该OP创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为0的Tensor。

 参数：
-    - **shape** (tuple|list) - 输出Tensor的形状。
-    - **dtype** (np.dtype|core.VarDesc.VarType|str) - 输出Tensor的数据类型，数据类型必须为float16、float32、float64、int32或int64。
-    - **force_cpu** (bool) - 是否强制将输出Tensor写入CPU内存。如果 ``force_cpu`` 为False，则将输出Tensor写入当前所在运算设备的内存，默认为False。
+    - **shape** (tuple|list|Tensor) - 输出Tensor的形状， ``shape`` 的数据类型为int32或者int64。
+    - **dtype** (np.dtype|core.VarDesc.VarType|str) - 输出Tensor的数据类型，数据类型必须为bool、 float16、float32、float64、int32或int64。
+    - **force_cpu** (bool， 可选) - 是否强制将输出Tensor写入CPU内存。如果 ``force_cpu`` 为False，则将输出Tensor写入当前所在运算设备的内存，默认为False。

 返回：值全为0的Tensor，数据类型和 ``dtype`` 定义的类型一致。

-返回类型：Variable
+抛出异常：
+    - ``TypeError`` - 当 ``dtype`` 不是bool、 float16、float32、float64、int32、int64。
+    - ``TypeError`` - 当 ``shape`` 不是tuple、list、或者Tensor时。 当 ``shape`` 为Tensor，其数据类型不是int32或者int64时。

 **代码示例**：


--- a/doc/fluid/api_cn/nn_cn.rst
+++ b/doc/fluid/api_cn/nn_cn.rst
@@ -18,6 +18,7 @@ paddle.nn
    nn_cn/Upsample_cn.rst
    nn_cn/activation_cn.rst
    nn_cn/loss_cn.rst
+    nn_cn/functional_cn.rst
    nn_cn/adaptive_pool2d_cn.rst
    nn_cn/adaptive_pool3d_cn.rst
    nn_cn/add_position_encoding_cn.rst
@@ -94,7 +95,7 @@ paddle.nn
    nn_cn/logsigmoid_cn.rst
    nn_cn/log_loss_cn.rst
    nn_cn/lrn_cn.rst
-    nn_cn/margin_rank_loss_cn.rst
+    nn_cn/margin_ranking_loss_cn.rst
    nn_cn/maxout_cn.rst
    nn_cn/mse_loss_cn.rst
    nn_cn/multiclass_nms_cn.rst
@@ -105,6 +106,7 @@ paddle.nn
    nn_cn/pad2d_cn.rst
    nn_cn/pad_cn.rst
    nn_cn/pad_constant_like_cn.rst
+    nn_cn/PairwiseDistance_cn.rst
    nn_cn/ParameterList_cn.rst
    nn_cn/piecewise_decay_cn.rst
    nn_cn/pixel_shuffle_cn.rst
@@ -160,3 +162,6 @@ paddle.nn
    nn_cn/while_loop_cn.rst
    nn_cn/yolov3_loss_cn.rst
    nn_cn/yolo_box_cn.rst
+    nn_cn/loss_cn/MarginRankingLoss_cn.rst
+    nn_cn/functional_cn/margin_ranking_loss_cn.rst
+     
--- a/doc/fluid/api_cn/nn_cn/PairwiseDistance_cn.rst
+++ b/doc/fluid/api_cn/nn_cn/PairwiseDistance_cn.rst
+.. _cn_api_nn_PairwiseDistance:
+
+PairwiseDistance
+-------------------------------
+
+.. py:class:: paddle.nn.PairwiseDistance(p=2., epsilon=1e-6, keepdim=False, name=None)
+
+该OP计算两个向量（输入 ``x``、``y`` ）之间pairwise的距离。该距离通过p范数计算：
+
+    .. math::
+
+            \Vert x \Vert _p = \left( \sum_{i=1}^n \vert x_i \vert ^ p \right ) ^ {1/p}.
+
+参数
+::::::::
+    - **p** （float，可选）- 指定p阶的范数。默认值为2。
+    - **epsilon** （float，可选）- 添加到分母的一个很小值，避免发生除零错误。默认值为1e-6。
+    - **keepdim** （bool，可选）- 是否保留输出张量减少的维度。输出结果相对于 ``|x-y|`` 的结果减少一维，除非 :attr:`keepdim` 为True，默认值为False。
+    - **name** （str，可选） - 操作的名称（可选，默认值为None）。更多信息请参见 :ref:`api_guide_Name` 。
+
+形状
+::::::::
+    - **x** (Tensor) - :math:`(N, D)` ，其中D是向量的维度，数据类型为float32或float64。
+    - **y** (Tensor) - :math:`(N, D)` ，与 ``x`` 的形状、数据类型相同。
+    - **output** (Tensor) - :math:`(N)` ，如果 :attr:`keepdim` 为True，则形状为 :math:`(N, 1)` 。数据类型与 ``x``、 ``y`` 相同。
+
+代码示例
+::::::::
+
+..  code-block:: python
+
+            import paddle
+            import numpy as np
+            paddle.disable_static()
+            x_np = np.array([[1., 3.], [3., 5.]]).astype(np.float64)
+            y_np = np.array([[5., 6.], [7., 8.]]).astype(np.float64)
+            x = paddle.to_variable(x_np)
+            y = paddle.to_variable(y_np)
+            dist = paddle.nn.PairwiseDistance()
+            distance = dist(x, y)
+            print(distance.numpy()) # [5. 5.]
+
--- a/doc/fluid/api_cn/nn_cn/activation_cn.rst
+++ b/doc/fluid/api_cn/nn_cn/activation_cn.rst
@@ -8,4 +8,5 @@ activation
 ..  toctree::
    :maxdepth: 1

+    activation_cn/LeakyReLU_cn.rst
    activation_cn/Sigmoid_cn.rst
--- a/doc/fluid/api_cn/nn_cn/activation_cn/LeakyReLU_cn.rst
+++ b/doc/fluid/api_cn/nn_cn/activation_cn/LeakyReLU_cn.rst
+.. _cn_api_nn_LeakyReLU:
+
+LeakyReLU
+-------------------------------
+.. py:class:: paddle.nn.LeakyReLU(alpha=0.01, name=None)
+
+ReLU (Rectified Linear Unit）激活层
+
+.. math::
+
+        \\Out = max(x, alpha*x)\\
+
+其中，:math:`x` 为输入的 Tensor
+
+参数
+::::::::::
+    - alpha (float，可选) - :math:`x < 0` 时的斜率。默认值为0.01。
+    - name (str, 可选) - 操作的名称(可选，默认值为None）。更多信息请参见 :ref:`api_guide_Name`。
+
+形状:
+    - input: 任意形状的Tensor。
+    - output: 和input具有相同形状的Tensor。
+
+代码示例
+:::::::::
+
+.. code-block:: python
+
+    import paddle
+    import numpy as np
+
+    paddle.enable_imperative()
+
+    lrelu = paddle.nn.LeakyReLU()
+    x = paddle.imperative.to_variable(np.array([-2, 0, 1], 'float32'))
+    out = lrelu(x)  # [-0.02, 0, 1]
--- a/doc/fluid/api_cn/nn_cn/functional_cn.rst
+++ b/doc/fluid/api_cn/nn_cn/functional_cn.rst
+=======================
+functional
+=======================
+
+
+
+
+..  toctree::
+    :maxdepth: 1
+
+    functional_cn/l1_loss_cn.rst
+    functional_cn/nll_loss_cn.rst
+    functional_cn/margin_ranking_loss_cn.rst
--- a/doc/fluid/api_cn/nn_cn/functional_cn/l1_loss_cn.rst
+++ b/doc/fluid/api_cn/nn_cn/functional_cn/l1_loss_cn.rst
+l1_loss
+-------------------------------
+
+.. py:function:: paddle.nn.functional.l1_loss(x, label, reduction='mean', name=None)
+
+该接口计算输入 ``x`` 和标签 ``label`` 间的 `L1 loss` 损失。
+
+该损失函数的数学计算公式如下：
+
+当 `reduction` 设置为 ``'none'`` 时，
+    
+    .. math::
+        Out = \lvert x - label\rvert
+
+当 `reduction` 设置为 ``'mean'`` 时，
+
+    .. math::
+       Out = MEAN(\lvert x - label\rvert)
+
+当 `reduction` 设置为 ``'sum'`` 时，
+    
+    .. math::
+       Out = SUM(\lvert x - label\rvert)
+
+
+参数
+:::::::::
+    - **x** (Tensor): - 输入的Tensor，维度是[N, *], 其中N是batch size， `*` 是任意数量的额外维度。数据类型为：float32、float64、int32、int64。
+    - **label** (Tensor): - 标签，维度是[N, *], 与 ``x`` 相同。数据类型为：float32、float64、int32、int64。
+    - **reduction** (str, 可选): - 指定应用于输出结果的计算方式，可选值有: ``'none'``, ``'mean'``, ``'sum'`` 。默认为 ``'mean'``，计算 `L1Loss` 的均值；设置为 ``'sum'`` 时，计算 `L1Loss` 的总和；设置为 ``'none'`` 时，则返回 `L1Loss`。
+    - **name** (str，可选): - 操作的名称(可选，默认值为None）。更多信息请参见 :ref:`api_guide_Name`。
+
+返回
+:::::::::
+``Tensor``, 输入 ``x`` 和标签 ``label`` 间的 `L1 loss` 损失。如果 :attr:`reduction` 是 ``'none'``, 则输出Loss的维度为 [N, *], 与输入 ``x`` 相同。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``, 则输出Loss的维度为 [1]。
+
+
+代码示例
+:::::::::
+
+.. code-block:: python
+
+        import paddle
+        import numpy as np
+        
+        paddle.disable_static()
+        x_data = np.array([[1.5, 0.8], [0.2, 1.3]]).astype("float32")
+        label_data = np.array([[1.7, 1], [0.4, 0.5]]).astype("float32")
+        x = paddle.to_variable(x_data)
+        label = paddle.to_variable(label_data)
+
+        l1_loss = paddle.nn.functional.l1_loss(x, label)
+        print(l1_loss.numpy())  
+        # [0.35]
+
+        l1_loss = paddle.nn.functional.l1_loss(x, label, reduction='none')
+        print(l1_loss.numpy())  
+        # [[0.20000005 0.19999999]
+        # [0.2        0.79999995]]
+
+        l1_loss = paddle.nn.functional.l1_loss(x, label, reduction='sum')
+        print(l1_loss.numpy())  
+        # [1.4]
--- a/doc/fluid/api_cn/nn_cn/functional_cn/margin_ranking_loss_cn.rst
+++ b/doc/fluid/api_cn/nn_cn/functional_cn/margin_ranking_loss_cn.rst
+.. _cn_api_nn_cn_margin_ranking_loss:
+
+margin_ranking_loss
+-------------------------------
+
+.. py:function:: paddle.nn.functional.margin_ranking_loss(input, other, label, margin=0.0, reduction='mean', name=None)
+
+该算子计算输入input，other 和 标签label间的 `margin rank loss` 损失。该损失函数的数学计算公式如下：
+
+ .. math:: 
+     margin\_rank\_loss = max(0, -label * (input - other) + margin)
+
+当 `reduction` 设置为 ``'mean'`` 时，
+
+    .. math::
+       Out = MEAN(margin\_rank\_loss)
+
+当 `reduction` 设置为 ``'sum'`` 时，
+    
+    .. math::
+       Out = SUM(margin\_rank\_loss)
+
+当 `reduction` 设置为 ``'none'`` 时，直接返回最原始的 `margin_rank_loss` 。
+
+参数
+::::::::
+    - **input** （Tensor）：第一个输入的 `Tensor` ，数据类型为：float32、float64。
+    - **other** （Tensor）：第二个输入的 `Tensor` ，数据类型为：float32、float64。
+    - **label** （Tensor）：训练数据的标签，数据类型为：float32, float64。
+    - **margin** （float，可选）： - 用于加和的margin值，默认值为0。  
+    - **reduction** （string，可选）： - 指定应用于输出结果的计算方式，可选值有: ``'none'`` 、 ``'mean'`` 、 ``'sum'`` 。如果设置为 ``'none'`` ，则直接返回 最原始的 ``margin_rank_loss`` 。如果设置为 ``'sum'`` ，则返回 ``margin_rank_loss`` 的总和。如果设置为 ``'mean'`` ，则返回 ``margin_rank_loss`` 的平均值。默认值为 ``'none'`` 。
+    - **name** （str，可选） - 操作的名称(可选，默认值为None）。更多信息请参见 :ref:`api_guide_Name`。  
+
+返回
+::::::::
+Tensor, 如果 :attr:`reduction` 为 ``'sum'`` 或者是 ``'mean'`` ，则形状为 :math:`[1]` ，否则shape和输入 `input` 保持一致 。数据类型与 ``input``、 ``other`` 相同。
+
+代码示例
+::::::::
+
+.. code-block:: python
+
+    import numpy as np 
+    import paddle 
+    
+    paddle.disable_static()
+     
+    input = paddle.to_variable(np.array([[1, 2], [3, 4]]).astype('float32'))
+    other = paddle.to_variable(np.array([[2, 1], [2, 4]]).astype('float32'))
+    label = paddle.to_variable(np.array([[1, -1], [-1, -1]]).astype('float32'))
+    loss = paddle.nn.functional.margin_ranking_loss(input, other, label) 
+    print(loss.numpy()) # [0.75]
--- a/doc/fluid/api_cn/nn_cn/functional_cn/nll_loss_cn.rst
+++ b/doc/fluid/api_cn/nn_cn/functional_cn/nll_loss_cn.rst
+.. _cn_api_nn_functional_nll_loss:
+
+nll_loss
+-------------------------------
+.. py:function:: paddle.nn.functional.nll_loss(input, label, weight=None, ignore_index=-100, reduction='mean', name=None)
+
+该接口返回 `negative log likelihood` 。可在 :ref:`cn_api_nn_loss_NLLLoss` 查看详情。
+
+参数
+:::::::::
+    - **input** (Tensor): - 输入 `Tensor`, 其形状为 :math:`[N, C]` , 其中 `C` 为类别数。但是对于多维度的情形下，它的形状为 :math:`[N, C, d_1, d_2, ..., d_K]` 。数据类型为float32或float64。
+    - **label** (Tensor): - 输入x对应的标签值。其形状为 :math:`[N,]` 或者 :math:`[N, d_1, d_2, ..., d_K]`, 数据类型为int64。
+    - **weight** (Tensor, 可选): - 手动指定每个类别的权重。其默认为 `None` 。如果提供该参数的话，长度必须为 `num_classes` 。数据类型为float32或float64。
+    - **ignore_index** (int64, 可选): - 指定一个忽略的标签值，此标签值不参与计算。默认值为-100。数据类型为int64。
+    - **reduction** (str, 可选): - 指定应用于输出结果的计算方式，可选值有: `none`, `mean`, `sum` 。默认为 `mean` ，计算 `mini-batch` loss均值。设置为 `sum` 时，计算 `mini-batch` loss的总和。设置为 `none` 时，则返回loss Tensor。数据类型为string。
+    - **name** (str, 可选） - 操作的名称(可选，默认值为None）。更多信息请参见 :ref:`api_guide_Name` 。
+
+返回
+:::::::::
+`Tensor` ，返回存储表示 `negative log likelihood loss` 的损失值。
+
+代码示例
+:::::::::
+
+.. code-block:: python
+
+        import paddle
+        import numpy as np
+        from paddle.nn.functional import nll_loss
+        log_softmax = paddle.nn.LogSoftmax(axis=1)
+        
+        input_np = np.array([[0.88103855, 0.9908683 , 0.6226845 ],
+                         [0.53331435, 0.07999352, 0.8549948 ],
+                         [0.25879037, 0.39530203, 0.698465  ],
+                         [0.73427284, 0.63575995, 0.18827209],
+                         [0.05689114, 0.0862954 , 0.6325046 ]]).astype(np.float32)
+        label_np = np.array([0, 2, 1, 1, 0]).astype(np.int64)
+
+        place = paddle.CPUPlace()
+        paddle.disable_static(place)
+        input = paddle.to_variable(input_np)
+        log_out = log_softmax(input)
+        label = paddle.to_variable(label_np)
+        result = nll_loss(log_out, label)
+        print(result.numpy()) # [1.0720209]
--- a/doc/fluid/api_cn/nn_cn/loss_cn.rst
+++ b/doc/fluid/api_cn/nn_cn/loss_cn.rst
@@ -11,5 +11,6 @@ loss
    loss_cn/BCELoss_cn.rst
    loss_cn/CrossEntropyLoss_cn.rst
    loss_cn/L1Loss_cn.rst
+    loss_cn/MarginRankingLoss_cn.rst
    loss_cn/MSELoss_cn.rst
    loss_cn/NLLLoss_cn.rst
--- a/doc/fluid/api_cn/nn_cn/loss_cn/L1Loss_cn.rst
+++ b/doc/fluid/api_cn/nn_cn/loss_cn/L1Loss_cn.rst
 L1Loss
 -------------------------------

-.. py:function:: paddle.nn.loss.L1Loss(reduction='mean')
+.. py:class:: paddle.nn.loss.L1Loss(reduction='mean', name=None)

-该接口用于创建一个L1Loss的可调用类，L1Loss计算输入input和标签label间的 `L1 loss` 损失。
+该接口用于创建一个L1Loss的可调用类，L1Loss计算输入x和标签label间的 `L1 loss` 损失。

 该损失函数的数学计算公式如下：

 当 `reduction` 设置为 ``'none'`` 时，
    
    .. math::
-        Out = |input - label|
+        Out = \lvert x - label\rvert

 当 `reduction` 设置为 ``'mean'`` 时，

    .. math::
-       Out = MEAN(|input - label|)
+       Out = MEAN(\lvert x - label\rvert)

 当 `reduction` 设置为 ``'sum'`` 时，
    
    .. math::
-       Out = SUM(|input - label|)
+       Out = SUM(\lvert x - label\rvert)

-输入input和标签label的维度是[N, *], 其中N是batch_size， `*` 是任意其他维度。
-如果 :attr:`reduction` 是 ``'none'``, 则输出Loss的维度为 [N, *], 与输入input相同。
-如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``, 则输出Loss的维度为 [1]。

-参数：
-    - **reduction** (string, 可选): - 指定应用于输出结果的计算方式，可选值有: ``'none'``, ``'mean'``, ``'sum'`` 。默认为 ``'mean'``，计算 `L1Loss` 的均值；设置为 ``'sum'`` 时，计算 `L1Loss` 的总和；设置为 ``'none'`` 时，则返回L1Loss。数据类型为string。
+参数
+:::::::::
+    - **reduction** (str, 可选): - 指定应用于输出结果的计算方式，可选值有: ``'none'``, ``'mean'``, ``'sum'`` 。默认为 ``'mean'``，计算 `L1Loss` 的均值；设置为 ``'sum'`` 时，计算 `L1Loss` 的总和；设置为 ``'none'`` 时，则返回 `L1Loss`。
+    - **name** (str，可选): - 操作的名称(可选，默认值为None）。更多信息请参见 :ref:`api_guide_Name`。

-返回：返回计算L1Loss的可调用对象。
+形状
+:::::::::
+    - **x** (Tensor): - 输入的Tensor，维度是[N, *], 其中N是batch size， `*` 是任意数量的额外维度。数据类型为：float32、float64、int32、int64。
+    - **label** (Tensor): - 标签，维度是[N, *], 与 ``x`` 相同。数据类型为：float32、float64、int32、int64。
+    - **output** (Tensor): - 输入 ``x`` 和标签 ``label`` 间的 `L1 loss` 损失。如果 :attr:`reduction` 是 ``'none'``, 则输出Loss的维度为 [N, *], 与输入 ``x`` 相同。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``, 则输出Loss的维度为 [1]。

-**代码示例**
+代码示例
+:::::::::

 .. code-block:: python

-        # declarative mode
-        import paddle.fluid as fluid
-        import numpy as np
        import paddle
-        input = fluid.data(name="input", shape=[1])
-        label = fluid.data(name="label", shape=[1])
-        l1_loss = paddle.nn.loss.L1Loss(reduction='mean')
-        output = l1_loss(input,label)
-        place = fluid.CPUPlace()
-        exe = fluid.Executor(place)
-        exe.run(fluid.default_startup_program())
-
-        input_data = np.array([1.5]).astype("float32")
-        label_data = np.array([1.7]).astype("float32")
-        output_data = exe.run(fluid.default_main_program(),
-                feed={"input":input_data, "label":label_data},
-                fetch_list=[output],
-                return_numpy=True)
-
-        print(output_data)  # [array([0.2], dtype=float32)]
-        
-        # imperative mode
-        import paddle.fluid.dygraph as dg
-        with dg.guard(place) as g:
-            input = dg.to_variable(input_data)
-            label = dg.to_variable(label_data)
-            l1_loss = paddle.nn.loss.L1Loss(reduction='mean')
-            output = l1_loss(input,label)
-            print(output.numpy())  # [0.2]
+        import numpy as np
+
+        paddle.disable_static()
+        x_data = np.array([[1.5, 0.8], [0.2, 1.3]]).astype("float32")
+        label_data = np.array([[1.7, 1], [0.4, 0.5]]).astype("float32")
+        x = paddle.to_variable(x_data)
+        label = paddle.to_variable(label_data)
+
+        l1_loss = paddle.nn.loss.L1Loss()
+        output = l1_loss(x, label)
+        print(output.numpy())  
+        # [0.35]
+
+        l1_loss = paddle.nn.loss.L1Loss(reduction='sum')
+        output = l1_loss(x, label)
+        print(output.numpy())  
+        # [1.4]
+
+        l1_loss = paddle.nn.loss.L1Loss(reduction='none')
+        output = l1_loss(x, label)
+        print(output.numpy())  
+        # [[0.20000005 0.19999999]
+        # [0.2        0.79999995]]

--- a/doc/fluid/api_cn/nn_cn/loss_cn/MSELoss_cn.rst
+++ b/doc/fluid/api_cn/nn_cn/loss_cn/MSELoss_cn.rst
 MSELoss
 -------------------------------

-.. py:function:: paddle.nn.loss.MSELoss(input,label)
+.. py:function:: paddle.nn.loss.MSELoss(reduction='mean')

 该OP用于计算预测值和目标值的均方差误差。

@@ -23,13 +23,15 @@ MSELoss
    Out = \operatorname{sum}((input - label)^2)

 参数：
-    - **input** (Variable) - 预测值，维度为 :math:`[N_1, N_2, ..., N_k, D]` 的多维Tensor，其中最后一维D是类别数目。数据类型为float32或float64。
-    - **label** (Variable) - 目标值，维度为 :math:`[N_1, N_2, ..., N_k, D]` 的多维Tensor，其中最后一维D是类别数目。数据类型为float32或float64。
    - **reduction** (str, 可选) - 约简方式，可以是 'none' | 'mean' | 'sum'。设为'none'时不使用约简，设为'mean'时返回loss的均值，设为'sum'时返回loss的和。

-返回：预测值和目标值的均方差
+形状:
+    - **input** (Tensor) - 预测值，维度为 :math:`[N_1, N_2, ..., N_k]` 的多维Tensor。数据类型为float32或float64。
+    - **label** (Tensor) - 目标值，维度为 :math:`[N_1, N_2, ..., N_k]` 的多维Tensor。数据类型为float32或float64。
+    
+
+返回：变量（Tensor）, 预测值和目标值的均方差, 数值类型与输入相同

-返回类型：变量（Variable）

 **代码示例**：

@@ -37,32 +39,32 @@ MSELoss

    import numpy as np
    import paddle
-    from paddle import fluid
-    import paddle.fluid.dygraph as dg

+
+    # static graph mode
+    paddle.enable_static()
    mse_loss = paddle.nn.loss.MSELoss()
-    input = fluid.data(name="input", shape=[1])
-    label = fluid.data(name="label", shape=[1])
-    place = fluid.CPUPlace()
+    input = paddle.data(name="input", shape=[1])
+    label = paddle.data(name="label", shape=[1])
+    place = paddle.CPUPlace()
    input_data = np.array([1.5]).astype("float32")
    label_data = np.array([1.7]).astype("float32")

-    # declarative mode
    output = mse_loss(input,label)
-    exe = fluid.Executor(place)
-    exe.run(fluid.default_startup_program())
+    exe = paddle.static.Executor(place)
+    exe.run(paddle.static.default_startup_program())
    output_data = exe.run(
-        fluid.default_main_program(),
+        paddle.static.default_main_program(),
        feed={"input":input_data, "label":label_data},
        fetch_list=[output],
        return_numpy=True)
    print(output_data)
    # [array([0.04000002], dtype=float32)]

-    # imperative mode
-    with dg.guard(place) as g:
-        input = dg.to_variable(input_data)
-        label = dg.to_variable(label_data)
+    # dynamic graph mode
+    paddle.disable_static()
+    input = paddle.to_variable(input_data)
+    label = paddle.to_variable(label_data)
    output = mse_loss(input, label)
    print(output.numpy())
    # [0.04000002]
--- a/doc/fluid/api_cn/nn_cn/loss_cn/MarginRankingLoss_cn.rst
+++ b/doc/fluid/api_cn/nn_cn/loss_cn/MarginRankingLoss_cn.rst
+.. _cn_api_nn_loss_MarginRankingLoss:
+
+MarginRankingLoss
+-------------------------------
+
+.. py:class:: paddle.nn.loss.MarginRankingLoss(margin=0.0, reduction='mean', name=None)
+
+该接口用于创建一个 ``MarginRankingLoss`` 的可调用类，计算输入input，other 和 标签label间的 `margin rank loss` 损失。
+
+该损失函数的数学计算公式如下：
+
+ .. math:: 
+     margin\_rank\_loss = max(0, -label * (input - other) + margin)
+
+当 `reduction` 设置为 ``'mean'`` 时，
+
+    .. math::
+       Out = MEAN(margin\_rank\_loss)
+
+当 `reduction` 设置为 ``'sum'`` 时，
+    
+    .. math::
+       Out = SUM(margin\_rank\_loss)
+
+当 `reduction` 设置为 ``'none'`` 时，直接返回最原始的 `margin_rank_loss` 。
+
+参数
+::::::::
+    - **margin** （float，可选）： - 用于加和的margin值，默认值为0。  
+    - **reduction** （string，可选）： - 指定应用于输出结果的计算方式，可选值有: ``'none'`` 、 ``'mean'`` 、 ``'sum'`` 。如果设置为 ``'none'`` ，则直接返回 最原始的 ``margin_rank_loss`` 。如果设置为 ``'sum'`` ，则返回 ``margin_rank_loss`` 的总和。如果设置为 ``'mean'`` ，则返回 ``margin_rank_loss`` 的平均值。默认值为 ``'none'`` 。
+    - **name** （str，可选） - 操作的名称(可选，默认值为None）。更多信息请参见 :ref:`api_guide_Name`。
+
+形状
+::::::::
+    - **input** - N-D Tensor, 维度是[N，*] 其中N 是batch size，`*` 是任意数量的额外维度，数据类型为float32或float64。
+    - **other** - 与 ``input`` 的形状、数据类型相同。
+    - **label** - 与 ``input`` 的形状、数据类型相同。
+    - **output** - 如果 :attr:`reduction` 为 ``'sum'`` 或者是 ``'mean'`` ，则形状为 :math:`[1]` ，否则shape和输入 `input` 保持一致 。数据类型与 ``input``、 ``other`` 相同。
+
+返回
+::::::::
+返回计算MarginRankingLoss的可调用对象。
+
+代码示例
+::::::::
+
+.. code-block:: python
+
+
+     import numpy as np 
+     import paddle 
+     
+     paddle.disable_static()
+      
+     input = paddle.to_variable(np.array([[1, 2], [3, 4]]).astype("float32"))
+     other = paddle.to_variable(np.array([[2, 1], [2, 4]]).astype("float32"))
+     label = paddle.to_variable(np.array([[1, -1], [-1, -1]]).astype("float32"))
+     margin_rank_loss = paddle.nn.MarginRankingLoss()
+     loss = margin_rank_loss(input, other, label) 
+     print(loss.numpy()) # [0.75]
--- a/doc/fluid/api_cn/nn_cn/loss_cn/NLLLoss_cn.rst
+++ b/doc/fluid/api_cn/nn_cn/loss_cn/NLLLoss_cn.rst
+.. _cn_api_nn_loss_NLLLoss:
+
 NLLLoss
 -------------------------------

-.. py:function:: paddle.nn.loss.NLLLoss(weight=None, reduction='mean', ignore_index=-100)
+.. py:class:: paddle.nn.loss.NLLLoss(weight=None, ignore_index=-100, reduction='mean', name=None)

-该OP计算输入input和标签label间的 `negative log likelihood loss` 损失 ，可用于训练一个 `n` 类分类器。
+该接口可创建一个NLLLoss可调用类，计算输入x和标签label间的 `negative log likelihood loss` 损失 ，可用于训练一个 `n` 类分类器。

 如果提供 `weight` 参数的话，它是一个 `1-D` 的tensor, 里面的值对应类别的权重。当你的训练集样本
 不均衡的话，使用这个参数是非常有用的。
@@ -28,48 +30,41 @@ NLLLoss
            \text{if reduction} = \text{'sum'.}
        \end{cases}

-参数：
-    - **input** (Variable): - 输入 `Tensor`, 其形状为 :math:`[N, C]` , 其中 `C` 为类别数。但是对于多维度的情形下，它的形状为 :math:`[N, C, d_1, d_2, ..., d_K]` 。数据类型为float32或float64。
-    - **label** (Variable): - 输入input对应的标签值。其形状为 :math:`[N,]` 或者 :math:`[N, d_1, d_2, ..., d_K]`, 数据类型为int64。
-    - **weight** (Variable, 可选): - 手动指定每个类别的权重。其默认为 `None` 。如果提供该参数的话，长度必须为 `num_classes` 。数据类型为float32或float64。
-    - **reduction** (string, 可选): - 指定应用于输出结果的计算方式，可选值有: `none`, `mean`, `sum` 。默认为 `mean` ，计算 `mini-batch` loss均值。设置为 `sum` 时，计算 `mini-batch` loss的总和。设置为 `none` 时，则返回loss Tensor。数据类型为string。
+参数
+:::::::::
+    - **weight** (Tensor, 可选): - 手动指定每个类别的权重。其默认为 `None` 。如果提供该参数的话，长度必须为 `num_classes` 。数据类型为float32或float64。
    - **ignore_index** (int64, 可选): - 指定一个忽略的标签值，此标签值不参与计算。默认值为-100。数据类型为int64。
+    - **reduction** (str, 可选): - 指定应用于输出结果的计算方式，可选值有: `none`, `mean`, `sum` 。默认为 `mean` ，计算 `mini-batch` loss均值。设置为 `sum` 时，计算 `mini-batch` loss的总和。设置为 `none` 时，则返回loss Tensor。数据类型为string。
+    - **name** (str, 可选） - 操作的名称(可选，默认值为None）。更多信息请参见 :ref:`api_guide_Name` 。

-返回：返回存储表示 `negative log likihood loss` 的损失值。
-
-返回类型：Variable
+形状
+:::::::::
+    - **input** (Tensor): - 输入 `Tensor`, 其形状为 :math:`[N, C]` , 其中 `C` 为类别数。但是对于多维度的情形下，它的形状为 :math:`[N, C, d_1, d_2, ..., d_K]` 。数据类型为float32或float64。
+    - **label** (Tensor): - 输入 `input` 对应的标签值。其形状为 :math:`[N,]` 或者 :math:`[N, d_1, d_2, ..., d_K]`, 数据类型为int64。
+    - **output** (Tensor): - 输入 `input` 和 `label` 间的 `negative log likelihood loss` 损失。如果 `reduction` 为 `'none'` ，则输出Loss形状为 `[N, *]` 。 如果 `reduction` 为 `'sum'` 或者 `'mean'` ，则输出Loss形状为 `'[1]'` 。

-**代码示例**
+代码示例
+:::::::::

 .. code-block:: python

-            # declarative mode
-            import paddle.fluid as fluid
-            import numpy as np
        import paddle
-            input_np = np.random.random(size=(10, 10)).astype(np.float32)
-            label_np = np.random.randint(0, 10, size=(10,)).astype(np.int64)
-            prog = fluid.Program()
-            startup_prog = fluid.Program()
-            place = fluid.CPUPlace()
-            with fluid.program_guard(prog, startup_prog):
-                input = fluid.data(name='input', shape=[10, 10], dtype='float32')
-                label = fluid.data(name='label', shape=[10], dtype='int64')
-                nll_loss = paddle.nn.loss.NLLLoss()
-                res = nll_loss(input, label)
-                exe = fluid.Executor(place)
-                static_result = exe.run(
-                    prog,
-                    feed={"input": input_np,
-                          "label": label_np},
-                    fetch_list=[res])
-            print(static_result)
-            
-            # imperative mode
-            import paddle.fluid.dygraph as dg
-            with dg.guard(place) as g:
-                input = dg.to_variable(input_np)
-                label = dg.to_variable(label_np)
-                output = nll_loss(input, label)
-                print(output.numpy())
+        import numpy as np

+        nll_loss = paddle.nn.layer.NLLLoss()
+        log_softmax = paddle.nn.LogSoftmax(axis=1)
+
+        input_np = np.array([[0.88103855, 0.9908683 , 0.6226845 ],
+                         [0.53331435, 0.07999352, 0.8549948 ],
+                         [0.25879037, 0.39530203, 0.698465  ],
+                         [0.73427284, 0.63575995, 0.18827209],
+                         [0.05689114, 0.0862954 , 0.6325046 ]]).astype(np.float32)
+        label_np = np.array([0, 2, 1, 1, 0]).astype(np.int64)
+
+        place = paddle.CPUPlace()
+        paddle.disable_static(place)
+        input = paddle.to_variable(input_np)
+        log_out = log_softmax(input)
+        label = paddle.to_variable(label_np)
+        result = nll_loss(log_out, label)
+        print(result.numpy()) # [1.0720209]
--- a/doc/fluid/api_cn/nn_cn/margin_rank_loss_cn.rst
+++ b/doc/fluid/api_cn/nn_cn/margin_rank_loss_cn.rst
-.. _cn_api_nn_cn_margin_rank_loss:
-
-margin_rank_loss
-------------------------------
-:doc_source: paddle.fluid.layers.margin_rank_loss
-
-
--- a/doc/fluid/api_cn/nn_cn/softmax_cn.rst
+++ b/doc/fluid/api_cn/nn_cn/softmax_cn.rst
@@ -2,6 +2,118 @@

 softmax
 -------------------------------
-:doc_source: paddle.fluid.layers.softmax
+.. py:class:: paddle.nn.functional.softmax(x, axis=-1, name=None)

+该OP实现了softmax层。OP的计算过程如下：

+步骤1：输入 ``x`` 的 ``axis`` 维会被置换到最后一维；
+
+步骤2：将输入 ``x`` 在逻辑上变换为二维矩阵。二维矩阵第一维（列长度）是输入除最后一维之外的其他维度值的乘积，第二维（行长度）和输入 ``axis`` 维的长度相同；对于矩阵的每一行，softmax操作对其进行重新缩放，使得该行的每个元素在 \[0,1\] 范围内，并且总和为1；
+
+步骤3：softmax操作执行完成后，执行步骤1和步骤2的逆运算，将二维矩阵恢复至和输入 ``x`` 相同的维度。
+
+上述步骤2中softmax操作计算过程如下：
+
+    - 对于二维矩阵的每一行，计算K维向量（K是输入第 ``axis`` 维的长度）中指定位置的指数值和全部位置指数值的和。
+
+    - 指定位置指数值与全部位置指数值之和的比值就是softmax操作的输出。
+
+对于二维矩阵中的第i行和第j列有：
+
+.. math::
+
+
+    Out[i,j] = \frac{exp(X[i,j])}{\sum_j exp(X[i,j])}
+
+- 示例1（矩阵一共有三维。axis = -1，表示沿着最后一维（即第三维）做softmax操作）
+
+.. code-block:: python
+
+  输入
+
+    x.shape = [2, 3, 4] 
+
+    x.data = [[[2.0, 3.0, 4.0, 5.0],
+               [3.0, 4.0, 5.0, 6.0],
+               [7.0, 8.0, 8.0, 9.0]],
+              [[1.0, 2.0, 3.0, 4.0],
+               [5.0, 6.0, 7.0, 8.0],
+               [6.0, 7.0, 8.0, 9.0]]]
+
+    axis = -1
+
+  输出
+
+    out.shape = [2, 3, 4]
+
+    out.data = [[[0.0320586 , 0.08714432, 0.23688282, 0.64391426],
+                 [0.0320586 , 0.08714432, 0.23688282, 0.64391426],
+                 [0.07232949, 0.19661193, 0.19661193, 0.53444665]],
+                [[0.0320586 , 0.08714432, 0.23688282, 0.64391426],
+                 [0.0320586 , 0.08714432, 0.23688282, 0.64391426],
+                 [0.0320586 , 0.08714432, 0.23688282, 0.64391426]]]
+
+- 示例2（矩阵一共有三维。axis = 1，表示沿着第二维做softmax操作）
+
+.. code-block:: python
+
+  输入
+
+    x.shape = [2, 3, 4] 
+
+    x.data = [[[2.0, 3.0, 4.0, 5.0],
+               [3.0, 4.0, 5.0, 6.0],
+               [7.0, 8.0, 8.0, 9.0]],
+              [[1.0, 2.0, 3.0, 4.0],
+               [5.0, 6.0, 7.0, 8.0],
+               [6.0, 7.0, 8.0, 9.0]]]
+
+    axis = 1
+
+  输出
+
+    out.shape = [2, 3, 4]
+
+    out.data = [[[0.00657326, 0.00657326, 0.01714783, 0.01714783],
+                 [0.01786798, 0.01786798, 0.04661262, 0.04661262],
+                 [0.97555875, 0.97555875, 0.93623955, 0.93623955]],
+                [[0.00490169, 0.00490169, 0.00490169, 0.00490169],
+                 [0.26762315, 0.26762315, 0.26762315, 0.26762315],
+                 [0.72747516, 0.72747516, 0.72747516, 0.72747516]]] 
+
+
+参数
+::::::::::
+    - x (Tensor) - 输入的多维 ``Tensor`` ，数据类型为：float32、float64。
+    - axis (int, 可选) - 指定对输入 ``x`` 进行运算的轴。``axis`` 的有效范围是[-D, D)，D是输入 ``x`` 的维度， ``axis`` 为负值时与 :math:`axis + D` 等价。默认值为-1。
+    - name (str, 可选) - 操作的名称(可选，默认值为None）。更多信息请参见 :ref:`api_guide_Name`。
+
+返回
+::::::::::
+    ``Tensor`` ，数据类型和形状同 ``x`` 一致。
+
+代码示例
+::::::::::
+
+.. code-block:: python
+
+    import paddle
+    import paddle.nn.functional as F
+    import numpy as np
+
+    paddle.enable_imperative()
+
+    x = np.array([[[2.0, 3.0, 4.0, 5.0],
+                    [3.0, 4.0, 5.0, 6.0],
+                    [7.0, 8.0, 8.0, 9.0]],
+                    [[1.0, 2.0, 3.0, 4.0],
+                    [5.0, 6.0, 7.0, 8.0],
+                    [6.0, 7.0, 8.0, 9.0]]], 'float32')
+    x = paddle.imperative.to_variable(x)
+    out = F.softmax(x)
+    # [[[0.0320586 , 0.08714432, 0.23688282, 0.64391426],
+    #   [0.0320586 , 0.08714432, 0.23688282, 0.64391426],
+    #   [0.07232949, 0.19661193, 0.19661193, 0.53444665]],
+    # [[0.0320586 , 0.08714432, 0.23688282, 0.64391426],
+    #   [0.0320586 , 0.08714432, 0.23688282, 0.64391426],
+    #   [0.0320586 , 0.08714432, 0.23688282, 0.64391426]]]
--- a/doc/fluid/api_cn/paddle_cn.rst
+++ b/doc/fluid/api_cn/paddle_cn.rst
@@ -44,8 +44,6 @@ paddle
 	paddle_cn/elementwise_add_cn.rst
 	paddle_cn/elementwise_div_cn.rst
 	paddle_cn/elementwise_floordiv_cn.rst
-	paddle_cn/elementwise_max_cn.rst
-	paddle_cn/elementwise_min_cn.rst
 	paddle_cn/elementwise_mod_cn.rst
 	paddle_cn/elementwise_mul_cn.rst
 	paddle_cn/elementwise_pow_cn.rst
@@ -95,11 +93,16 @@ paddle
 	paddle_cn/log_cn.rst
 	paddle_cn/manual_seed_cn.rst
 	paddle_cn/matmul_cn.rst
+        paddle_cn/max_cn.rst
+        paddle_cn/maximum_cn.rst
 	paddle_cn/mean_cn.rst
 	paddle_cn/meshgrid_cn.rst
+        paddle_cn/min_cn.rst
+        paddle_cn/minimum_cn.rst
 	paddle_cn/multiplex_cn.rst
 	paddle_cn/mul_cn.rst
    paddle_cn/name_scope_cn.rst
+    paddle_cn/no_grad_cn.rst
 	paddle_cn/nonzero_cn.rst
 	paddle_cn/not_equal_cn.rst
 	paddle_cn/ones_cn.rst

--- a/doc/fluid/api_cn/paddle_cn/cumsum_cn.rst
+++ b/doc/fluid/api_cn/paddle_cn/cumsum_cn.rst
@@ -2,6 +2,6 @@

 cumsum
 -------------------------------
-:doc_source: paddle.fluid.layers.cumsum
+:doc_source: paddle.tensor.cumsum


--- a/doc/fluid/api_cn/paddle_cn/elementwise_equal_cn.rst
+++ b/doc/fluid/api_cn/paddle_cn/elementwise_equal_cn.rst
-.. _cn_api_paddle_cn_elementwise_equal:
-
-elementwise_equal
-------------------------------
-:doc_source: paddle.fluid.layers.equal
-
-
--- a/doc/fluid/api_cn/paddle_cn/elementwise_max_cn.rst
+++ b/doc/fluid/api_cn/paddle_cn/elementwise_max_cn.rst
-.. _cn_api_paddle_cn_elementwise_max:
-
-elementwise_max
-------------------------------
-:doc_source: paddle.fluid.layers.elementwise_max
-
-
--- a/doc/fluid/api_cn/paddle_cn/elementwise_min_cn.rst
+++ b/doc/fluid/api_cn/paddle_cn/elementwise_min_cn.rst
-.. _cn_api_paddle_cn_elementwise_min:
-
-elementwise_min
-------------------------------
-:doc_source: paddle.fluid.layers.elementwise_min
-
-
--- a/doc/fluid/api_cn/paddle_cn/equal_all_cn.rst
+++ b/doc/fluid/api_cn/paddle_cn/equal_all_cn.rst
+.. _cn_api_paddle_cn_equal_all:
+
+equal_all
+-------------------------------
+:doc_source: paddle.tensor.equal_all
+
+
--- a/doc/fluid/api_cn/paddle_cn/greater_equal_cn.rst
+++ b/doc/fluid/api_cn/paddle_cn/greater_equal_cn.rst
@@ -2,6 +2,6 @@

 greater_equal
 -------------------------------
-:doc_source: paddle.fluid.layers.greater_equal
+:doc_source: paddle.tensor.greater_equal


--- a/doc/fluid/api_cn/paddle_cn/greater_than_cn.rst
+++ b/doc/fluid/api_cn/paddle_cn/greater_than_cn.rst
@@ -2,6 +2,6 @@

 greater_than
 -------------------------------
-:doc_source: paddle.fluid.layers.greater_than
+:doc_source: paddle.tensor.greater_than


--- a/doc/fluid/api_cn/paddle_cn/less_equal_cn.rst
+++ b/doc/fluid/api_cn/paddle_cn/less_equal_cn.rst
@@ -2,6 +2,6 @@

 less_equal
 -------------------------------
-:doc_source: paddle.fluid.layers.less_equal
+:doc_source: paddle.tensor.less_equal


--- a/doc/fluid/api_cn/paddle_cn/less_than_cn.rst
+++ b/doc/fluid/api_cn/paddle_cn/less_than_cn.rst
@@ -2,6 +2,6 @@

 less_than
 -------------------------------
-:doc_source: paddle.fluid.layers.less_than
+:doc_source: paddle.tensor.less_than


--- a/doc/fluid/api_cn/paddle_cn/no_grad_cn.rst
+++ b/doc/fluid/api_cn/paddle_cn/no_grad_cn.rst
+.. _cn_api_paddle_cn_name_scope:
+
+name_scope
+-------------------------------
+:doc_source: paddle.fluid.dygraph.no_grad
--- a/doc/fluid/api_cn/paddle_cn/not_equal_cn.rst
+++ b/doc/fluid/api_cn/paddle_cn/not_equal_cn.rst
@@ -2,6 +2,6 @@

 not_equal
 -------------------------------
-:doc_source: paddle.fluid.layers.not_equal
+:doc_source: paddle.tensor.not_equal


--- a/doc/fluid/api_cn/tensor_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn.rst
@@ -38,16 +38,14 @@ paddle.tensor
    tensor_cn/einsum_cn.rst
    tensor_cn/elementwise_add_cn.rst
    tensor_cn/elementwise_div_cn.rst
-    tensor_cn/elementwise_equal_cn.rst
    tensor_cn/elementwise_floordiv_cn.rst
-    tensor_cn/elementwise_max_cn.rst
-    tensor_cn/elementwise_min_cn.rst
    tensor_cn/elementwise_mod_cn.rst
    tensor_cn/elementwise_mul_cn.rst
    tensor_cn/elementwise_pow_cn.rst
    tensor_cn/elementwise_sub_cn.rst
    tensor_cn/elementwise_sum_cn.rst
    tensor_cn/equal_cn.rst
+    tensor_cn/equal_all_cn.rst
    tensor_cn/erf_cn.rst
    tensor_cn/exp_cn.rst
    tensor_cn/expand_as_cn.rst
@@ -89,9 +87,11 @@ paddle.tensor
    tensor_cn/math_cn.rst
    tensor_cn/matmul_cn.rst
    tensor_cn/max_cn.rst
+    tensor_cn/maximum_cn.rst
    tensor_cn/mean_cn.rst
    tensor_cn/meshgrid_cn.rst
    tensor_cn/min_cn.rst
+    tensor_cn/minimum_cn.rst
    tensor_cn/mm_cn.rst
    tensor_cn/mul_cn.rst
    tensor_cn/multiplex_cn.rst

--- a/doc/fluid/api_cn/tensor_cn/argsort_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/argsort_cn.rst
@@ -8,7 +8,7 @@ argsort
 :alias_main: paddle.argsort
 :alias: paddle.argsort,paddle.tensor.argsort,paddle.tensor.search.argsort

-对输入变量沿给定轴进行排序，输出排序好的数据的相应索引，其维度和输入相同。**默认升序排列，如果需要降序排列设置** ``descending=True`` 。
+对输入变量沿给定轴进行排序，输出排序好的数据的相应索引，其维度和输入相同。默认升序排列，如果需要降序排列设置 ``descending=True`` 。


 参数：
@@ -17,9 +17,8 @@ argsort
    - **descending** (bool，可选) - 指定算法排序的方向。如果设置为True，算法按照降序排序。如果设置为False或者不设置，按照升序排序。默认值为False。
    - **name** (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。

-返回：排序后索引信息（与 ``x`` 维度信息一致），数据类型为int64。
+返回：Tensor, 排序后索引信息（与 ``x`` 维度信息一致），数据类型为int64。

-返回类型：Tensor

 **代码示例**：


--- a/doc/fluid/api_cn/tensor_cn/concat_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/concat_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/cumsum_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/cumsum_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/elementwise_equal_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/elementwise_equal_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/elementwise_max_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/elementwise_max_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/elementwise_min_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/elementwise_min_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/equal_all_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/equal_all_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/equal_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/equal_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/eye_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/eye_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/full_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/full_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/full_like_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/full_like_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/greater_equal_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/greater_equal_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/greater_than_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/greater_than_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/index_select_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/index_select_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/less_equal_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/less_equal_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/less_than_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/less_than_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/linspace_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/linspace_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/log1p_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/log1p_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/log_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/log_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/max_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/max_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/maximum_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/maximum_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/mean_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/mean_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/min_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/min_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/minimum_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/minimum_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/norm_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/norm_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/not_equal_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/not_equal_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/ones_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/ones_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/sort_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/sort_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/split_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/split_cn.rst
--- a/doc/fluid/api_cn/tensor_cn/zeros_cn.rst
+++ b/doc/fluid/api_cn/tensor_cn/zeros_cn.rst
--- a/doc/fluid/api_guides/X2Paddle/TensorFlow-Fluid.rst
+++ b/doc/fluid/api_guides/X2Paddle/TensorFlow-Fluid.rst
--- a/doc/fluid/beginners_guide/basic_concept/broadcasting.rst
+++ b/doc/fluid/beginners_guide/basic_concept/broadcasting.rst
--- a/doc/fluid/beginners_guide/basic_concept/broadcasting_en.rst
+++ b/doc/fluid/beginners_guide/basic_concept/broadcasting_en.rst
--- a/doc/fluid/beginners_guide/basic_concept/index_cn.rst
+++ b/doc/fluid/beginners_guide/basic_concept/index_cn.rst
--- a/doc/fluid/beginners_guide/basic_concept/index_en.rst
+++ b/doc/fluid/beginners_guide/basic_concept/index_en.rst
--- a/doc/fluid/beginners_guide/basic_concept/operator.rst
+++ b/doc/fluid/beginners_guide/basic_concept/operator.rst
--- a/doc/fluid/install/compile/compile_CentOS.md
+++ b/doc/fluid/install/compile/compile_CentOS.md
--- a/doc/fluid/install/compile/compile_CentOS_en.md
+++ b/doc/fluid/install/compile/compile_CentOS_en.md
--- a/doc/fluid/install/compile/compile_Ubuntu.md
+++ b/doc/fluid/install/compile/compile_Ubuntu.md
--- a/doc/fluid/install/compile/compile_Ubuntu_en.md
+++ b/doc/fluid/install/compile/compile_Ubuntu_en.md
--- a/doc/templates/common_docs.py
+++ b/doc/templates/common_docs.py
--- a/gen_index.py
+++ b/gen_index.py
--- a/scripts/check_api_cn.sh
+++ b/scripts/check_api_cn.sh