diff --git a/docs/api/paddle/CPUPlace_cn.rst b/docs/api/paddle/CPUPlace_cn.rst
index 75b19e21482..9db6da44d13 100644
--- a/docs/api/paddle/CPUPlace_cn.rst
+++ b/docs/api/paddle/CPUPlace_cn.rst
@@ -8,7 +8,7 @@ CPUPlace
 
 
 
-``CPUPlace`` 是一个设备描述符，指定 ``CPUPlace`` 则 ``Tensor`` 将被自动分配在该设备上，并且模型将会运行在该设备上。
+ ``CPUPlace``  是一个设备描述符，指定  ``CPUPlace``  则  ``Tensor``  将被自动分配在该设备上，并且模型将会运行在该设备上。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/CUDAPinnedPlace_cn.rst b/docs/api/paddle/CUDAPinnedPlace_cn.rst
index 6f97f82a844..effbc825daf 100644
--- a/docs/api/paddle/CUDAPinnedPlace_cn.rst
+++ b/docs/api/paddle/CUDAPinnedPlace_cn.rst
@@ -8,8 +8,8 @@ CUDAPinnedPlace
 
 
 
-``CUDAPinnedPlace`` 是一个设备描述符，它所指代的页锁定内存由 CUDA 函数 ``cudaHostAlloc()`` 在主机内存上分配，主机的操作系统将不会对这块内存进行分页和交换操作，可以通过直接内存访问技术访问，加速主机和 GPU 之间的数据拷贝。
-有关 CUDA 的数据转移和 ``pinned memory``，参见 `官方文档 <https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#pinned-memory>`_ 。
+ ``CUDAPinnedPlace``  是一个设备描述符，它所指代的页锁定内存由 CUDA 函数  ``cudaHostAlloc()``  在主机内存上分配，主机的操作系统将不会对这块内存进行分页和交换操作，可以通过直接内存访问技术访问，加速主机和 GPU 之间的数据拷贝。
+有关 CUDA 的数据转移和  ``pinned memory`` ，参见 `官方文档 <https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#pinned-memory>`_ 。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/CUDAPlace_cn.rst b/docs/api/paddle/CUDAPlace_cn.rst
index 561a7146d87..7185027b852 100644
--- a/docs/api/paddle/CUDAPlace_cn.rst
+++ b/docs/api/paddle/CUDAPlace_cn.rst
@@ -9,12 +9,12 @@ CUDAPlace
 
 
 
-``CUDAPlace`` 是一个设备描述符，表示一个分配或将要分配 ``Tensor`` 的 GPU 设备。
-每个 ``CUDAPlace`` 有一个 ``dev_id`` （设备 id）来表明当前的 ``CUDAPlace`` 所代表的显卡编号，编号从 0 开始。
-``dev_id`` 不同的 ``CUDAPlace`` 所对应的内存不可相互访问。
+ ``CUDAPlace``  是一个设备描述符，表示一个分配或将要分配  ``Tensor``  的 GPU 设备。
+每个  ``CUDAPlace``  有一个  ``dev_id``  （设备 id）来表明当前的  ``CUDAPlace``  所代表的显卡编号，编号从 0 开始。
+ ``dev_id``  不同的  ``CUDAPlace``  所对应的内存不可相互访问。
 这里编号指的是可见显卡的逻辑编号，而不是显卡实际的编号。
-可以通过 ``CUDA_VISIBLE_DEVICES`` 环境变量限制程序能够使用的 GPU 设备，程序启动时会遍历当前的可见设备，并从 0 开始为这些设备编号。
-如果没有设置 ``CUDA_VISIBLE_DEVICES``，则默认所有的设备都是可见的，此时逻辑编号与实际编号是相同的。
+可以通过  ``CUDA_VISIBLE_DEVICES``  环境变量限制程序能够使用的 GPU 设备，程序启动时会遍历当前的可见设备，并从 0 开始为这些设备编号。
+如果没有设置  ``CUDA_VISIBLE_DEVICES`` ，则默认所有的设备都是可见的，此时逻辑编号与实际编号是相同的。
 
 参数
 ::::::::::::
diff --git a/docs/api/paddle/DataParallel_cn.rst b/docs/api/paddle/DataParallel_cn.rst
index dea7f30d2c3..459e58423b7 100644
--- a/docs/api/paddle/DataParallel_cn.rst
+++ b/docs/api/paddle/DataParallel_cn.rst
@@ -8,19 +8,19 @@ DataParallel
 
 通过数据并行模式执行动态图模型。
 
-目前，``DataParallel`` 仅支持以多进程的方式执行动态图模型。
+目前， ``DataParallel``  仅支持以多进程的方式执行动态图模型。
 
 支持两种使用方式：
 
-1. 使用 ``paddle.distributed.spawn`` 方法启动，例如：
+1. 使用  ``paddle.distributed.spawn``  方法启动，例如：
 
- ``python demo.py`` (spawn need to be called in ``__main__`` method)
+  ``python demo.py``  (spawn need to be called in  ``__main__``  method)
 
-2. 使用 ``paddle.distributed.launch`` 方法启动，例如：
+2. 使用  ``paddle.distributed.launch``  方法启动，例如：
 
-``python -m paddle.distributed.launch –selected_gpus=0,1 demo.py``
+ ``python -m paddle.distributed.launch –selected_gpus=0,1 demo.py`` 
 
-其中 ``demo.py`` 脚本的代码可以是下面的示例代码。
+其中  ``demo.py``  脚本的代码可以是下面的示例代码。
 
 参数
 ::::::::::::
@@ -33,7 +33,7 @@ DataParallel
 
 返回
 ::::::::::::
-支持数据并行的 ``Layer``。
+支持数据并行的  ``Layer`` 。
 
 代码示例
 ::::::::::::
@@ -64,7 +64,7 @@ state_dict(destination=None, include_sublayers=True)
 
 **参数**
 
-    - **destination** (dict，可选) - 如果提供 ``destination``，则所有参数和持久的 buffers 都将存放在 ``destination`` 中。默认值：None。
+    - **destination** (dict，可选) - 如果提供  ``destination`` ，则所有参数和持久的 buffers 都将存放在  ``destination``  中。默认值：None。
     - **include_sublayers** (bool，可选) - 如果设置为 True，则包括子层的参数和 buffers。默认值：True。
 
 **返回**
@@ -78,7 +78,7 @@ COPY-FROM: paddle.DataParallel.state_dict
 set_state_dict(state_dict, use_structured_name=True)
 '''''''''
 
-根据传入的 ``state_dict`` 设置 parameters 和持久的 buffers。所有 parameters 和 buffers 将由 ``state_dict`` 中的 ``Tensor`` 设置。
+根据传入的  ``state_dict``  设置 parameters 和持久的 buffers。所有 parameters 和 buffers 将由  ``state_dict``  中的  ``Tensor``  设置。
 
 **参数**
 
diff --git a/docs/api/paddle/LazyGuard_cn.rst b/docs/api/paddle/LazyGuard_cn.rst
index b7c42e61c32..16393dc83d9 100644
--- a/docs/api/paddle/LazyGuard_cn.rst
+++ b/docs/api/paddle/LazyGuard_cn.rst
@@ -7,7 +7,7 @@ LazyGuard
 
 
 
-LazyGuard 是一个用于设置模型（继承自 ``paddle.nn.Layer`` ） 中参数延迟初始化的上下文管理器。配合使用 python 的 ``with`` 语句来将 ``with LazyGuard():`` 代码块下所有模型在实例化时，其内部的参数均不会立即申请内存空间。
+LazyGuard 是一个用于设置模型（继承自  ``paddle.nn.Layer``  ） 中参数延迟初始化的上下文管理器。配合使用 python 的  ``with``  语句来将  ``with LazyGuard():``  代码块下所有模型在实例化时，其内部的参数均不会立即申请内存空间。
 
 
 代码示例
diff --git a/docs/api/paddle/Model_cn.rst b/docs/api/paddle/Model_cn.rst
index faf55095662..76d033472c9 100644
--- a/docs/api/paddle/Model_cn.rst
+++ b/docs/api/paddle/Model_cn.rst
@@ -5,20 +5,20 @@ Model
 
 .. py:class:: paddle.Model(network, inputs=None, labels=None)
 
-``Model`` 对象是一个具备训练、测试、推理的神经网络。该对象同时支持静态图和动态图模式，飞桨框架默认为动态图模式，通过 ``paddle.enable_static()`` 来切换到静态图模式。需要注意的是，需要在实例化 ``Model`` 对象之前完成切换。
+ ``Model``  对象是一个具备训练、测试、推理的神经网络。该对象同时支持静态图和动态图模式，飞桨框架默认为动态图模式，通过  ``paddle.enable_static()``  来切换到静态图模式。需要注意的是，需要在实例化  ``Model``  对象之前完成切换。
 
-在 GPU 上训练时，高层 API 支持自动混合精度（AMP）训练，并且在静态图下使用 Adam、AdamW、Momentum 优化器时还支持纯 float16 的训练。在使用纯 float16 训练之前，优化器初始化时 ``multi_precision`` 参数可以设置为 True，这样可以避免性能变差或是收敛变慢的问题。并且，在组网中可以使用 ``paddle.static.amp.fp16_guard`` 来限定使用纯 float16 训练的范围，否则需要把 ``use_fp16_guard`` 手动设置为 False 以开启全局纯 float16 训练。使用纯 float16 训练前，可能需要手动将 dtype 为 float32 的输入转成 float16 的输入。然而，使用自动混合精度训练（AMP）时，不支持限定混合精度训练的范围。
+在 GPU 上训练时，高层 API 支持自动混合精度（AMP）训练，并且在静态图下使用 Adam、AdamW、Momentum 优化器时还支持纯 float16 的训练。在使用纯 float16 训练之前，优化器初始化时  ``multi_precision``  参数可以设置为 True，这样可以避免性能变差或是收敛变慢的问题。并且，在组网中可以使用  ``paddle.static.amp.fp16_guard``  来限定使用纯 float16 训练的范围，否则需要把  ``use_fp16_guard``  手动设置为 False 以开启全局纯 float16 训练。使用纯 float16 训练前，可能需要手动将 dtype 为 float32 的输入转成 float16 的输入。然而，使用自动混合精度训练（AMP）时，不支持限定混合精度训练的范围。
 
 参数
 :::::::::
 
-    - **network** (paddle.nn.Layer) - 是 ``paddle.nn.Layer`` 的一个实例。
-    - **inputs** (InputSpec|list|tuple|dict|None，可选) - ``network`` 的输入，可以是 ``InputSpec`` 的实例，或者是一个 ``InputSpec`` 的 ``list``，或者是格式为 ``{name: InputSpec}`` 的 ``dict``，或者为 ``None``。默认值为 ``None``。
-    - **labels** (InputSpec|list|tuple|None，可选) - ``network`` 的标签，可以是 ``InputSpec`` 的实例，或者是一个 ``InputSpec`` 的 ``list``，或者为 ``None``。 默认值为 ``None``。
+    - **network** (paddle.nn.Layer) - 是  ``paddle.nn.Layer``  的一个实例。
+    - **inputs** (InputSpec|list|tuple|dict|None，可选) -  ``network``  的输入，可以是  ``InputSpec``  的实例，或者是一个  ``InputSpec``  的  ``list`` ，或者是格式为  ``{name: InputSpec}``  的  ``dict`` ，或者为  ``None`` 。默认值为  ``None`` 。
+    - **labels** (InputSpec|list|tuple|None，可选) -  ``network``  的标签，可以是  ``InputSpec``  的实例，或者是一个  ``InputSpec``  的  ``list`` ，或者为  ``None`` 。 默认值为  ``None`` 。
 
 .. note::
 
-    在动态图中，``inputs`` 和 ``labels`` 都可以设置为 ``None``。但是，在静态图中，``input`` 不能设置为 ``None``。而如果损失函数需要标签（label）作为输入，则必须设置 ``labels``，否则，可以为 ``None``。
+    在动态图中， ``inputs``  和  ``labels``  都可以设置为  ``None`` 。但是，在静态图中， ``input``  不能设置为  ``None`` 。而如果损失函数需要标签（label）作为输入，则必须设置  ``labels`` ，否则，可以为  ``None`` 。
 
 
 代码示例
@@ -102,13 +102,13 @@ COPY-FROM: paddle.Model.predict_batch
 save(path, training=True)
 '''''''''
 
-将模型的参数和训练过程中优化器的信息保存到指定的路径，以及推理所需的参数与文件。如果 training=True，所有的模型参数都会保存到一个后缀为 ``.pdparams`` 的文件中。
-所有的优化器信息和相关参数，比如 ``Adam`` 优化器中的 ``beta1`` ， ``beta2`` ，``momentum`` 等，都会被保存到后缀为 ``.pdopt``。如果优化器比如 SGD 没有参数，则该不会产生该文件。如果 training=False，则不会保存上述说的文件。只会保存推理需要的参数文件和模型文件。
+将模型的参数和训练过程中优化器的信息保存到指定的路径，以及推理所需的参数与文件。如果 training=True，所有的模型参数都会保存到一个后缀为  ``.pdparams``  的文件中。
+所有的优化器信息和相关参数，比如  ``Adam``  优化器中的  ``beta1``  ，  ``beta2``  ， ``momentum``  等，都会被保存到后缀为  ``.pdopt`` 。如果优化器比如 SGD 没有参数，则该不会产生该文件。如果 training=False，则不会保存上述说的文件。只会保存推理需要的参数文件和模型文件。
 
 **参数**
 
 
-    - **path** (str) - 保存的文件名前缀。格式如 ``dirname/file_prefix`` 或者 ``file_prefix`` 。
+    - **path** (str) - 保存的文件名前缀。格式如  ``dirname/file_prefix``  或者  ``file_prefix``  。
     - **training** (bool，可选) - 是否保存训练的状态，包括模型参数和优化器参数等。如果为 False，则只保存推理所需的参数与文件。默认值：True。
 
 **返回**
@@ -128,9 +128,9 @@ load(path, skip_mismatch=False, reset_optimizer=False)
 **参数**
 
 
-    - **path** (str) - 保存参数或优化器信息的文件前缀。格式如 ``path.pdparams`` 或者 ``path.pdopt`` ，后者是非必要的，如果不想恢复优化器信息。
-    - **skip_mismatch** (bool，可选) - 是否需要跳过保存的模型文件中形状或名称不匹配的参数，设置为 ``False`` 时，当遇到不匹配的参数会抛出一个错误。默认值：False。
-    - **reset_optimizer** (bool，可选) - 设置为 ``True`` 时，会忽略提供的优化器信息文件。否则会载入提供的优化器信息。默认值：False。
+    - **path** (str) - 保存参数或优化器信息的文件前缀。格式如  ``path.pdparams``  或者  ``path.pdopt``  ，后者是非必要的，如果不想恢复优化器信息。
+    - **skip_mismatch** (bool，可选) - 是否需要跳过保存的模型文件中形状或名称不匹配的参数，设置为  ``False``  时，当遇到不匹配的参数会抛出一个错误。默认值：False。
+    - **reset_optimizer** (bool，可选) - 设置为  ``True``  时，会忽略提供的优化器信息文件。否则会载入提供的优化器信息。默认值：False。
 
 **返回**
 
@@ -148,7 +148,7 @@ parameters(*args, **kwargs)
 
 **返回**
 
-在静态图中返回一个包含 ``Parameter`` 的列表，在动态图中返回一个包含 ``ParamBase`` 的列表。
+在静态图中返回一个包含  ``Parameter``  的列表，在动态图中返回一个包含  ``ParamBase``  的列表。
 
 **代码示例**
 
@@ -165,31 +165,31 @@ prepare(optimizer=None, loss=None, metrics=None, amp_configs=None)
     - **optimizer** (OOptimizer|None，可选) - 当训练模型的，该参数必须被设定。当评估或测试的时候，该参数可以不设定。默认值：None。
     - **loss** (Loss|Callable|None，可选) - 当训练模型的，该参数必须被设定。默认值：None。
     - **metrics** (Metric|list[Metric]|None，可选) - 当该参数被设定时，所有给定的评估方法会在训练和测试时被运行，并返回对应的指标。默认值：None。
-    - **amp_configs** (str|dict|None，可选) - 混合精度训练的配置，通常是个 dict，也可以是 str。当使用自动混合精度训练或者纯 float16 训练时，``amp_configs`` 的 key ``level`` 需要被设置为 O1 或者 O2，float32 训练时则默认为 O0。除了 ``level`` ，还可以传入更多的和混合精度 API 一致的参数，例如：``init_loss_scaling``、 ``incr_ratio`` 、 ``decr_ratio``、 ``incr_every_n_steps``、 ``decr_every_n_nan_or_inf``、 ``use_dynamic_loss_scaling``、 ``custom_white_list``、 ``custom_black_list`` ，在静态图下还支持传入 ``custom_black_varnames`` 和 ``use_fp16_guard`` 。详细使用方法可以参考参考混合精度 API 的文档 :ref:`auto_cast <cn_api_paddle_amp_auto_cast>`  和 :ref:`GradScaler <cn_api_paddle_amp_GradScaler>` 。为了方便起见，当不设置其他的配置参数时，也可以直接传入 ``'O1'`` 、``'O2'`` 。在使用 float32 训练时，该参数可以为 None。默认值：None。
+    - **amp_configs** (str|dict|None，可选) - 混合精度训练的配置，通常是个 dict，也可以是 str。当使用自动混合精度训练或者纯 float16 训练时， ``amp_configs``  的 key  ``level``  需要被设置为 O1 或者 O2，float32 训练时则默认为 O0。除了  ``level``  ，还可以传入更多的和混合精度 API 一致的参数，例如： ``init_loss_scaling`` 、  ``incr_ratio``  、  ``decr_ratio`` 、  ``incr_every_n_steps`` 、  ``decr_every_n_nan_or_inf`` 、  ``use_dynamic_loss_scaling`` 、  ``custom_white_list`` 、  ``custom_black_list``  ，在静态图下还支持传入  ``custom_black_varnames``  和  ``use_fp16_guard``  。详细使用方法可以参考参考混合精度 API 的文档 :ref:`auto_cast <cn_api_paddle_amp_auto_cast>`  和 :ref:`GradScaler <cn_api_paddle_amp_GradScaler>` 。为了方便起见，当不设置其他的配置参数时，也可以直接传入  ``'O1'``  、 ``'O2'``  。在使用 float32 训练时，该参数可以为 None。默认值：None。
 
 
 fit(train_data=None, eval_data=None, batch_size=1, epochs=1, eval_freq=1, log_freq=10, save_dir=None, save_freq=1, verbose=2, drop_last=False, shuffle=True, num_workers=0, callbacks=None, accumulate_grad_batches=1, num_iters=None)
 '''''''''
 
-训练模型。当 ``eval_data`` 给定时，会在 ``eval_freq`` 个 ``epoch`` 后进行一次评估。
+训练模型。当  ``eval_data``  给定时，会在  ``eval_freq``  个  ``epoch``  后进行一次评估。
 
 **参数**
 
-    - **train_data** (Dataset|DataLoader，可选) - 一个可迭代的数据源，推荐给定一个 ``paddle paddle.io.Dataset`` 或 ``paddle.io.Dataloader`` 的实例。默认值：None。
-    - **eval_data** (Dataset|DataLoader，可选) - 一个可迭代的数据源，推荐给定一个 ``paddle paddle.io.Dataset`` 或 ``paddle.io.Dataloader`` 的实例。当给定时，会在每个 ``epoch`` 后都会进行评估。默认值：None。
-    - **batch_size** (int，可选) - 训练数据或评估数据的批大小，当 ``train_data`` 或 ``eval_data`` 为 ``DataLoader`` 的实例时，该参数会被忽略。默认值：1。
+    - **train_data** (Dataset|DataLoader，可选) - 一个可迭代的数据源，推荐给定一个  ``paddle paddle.io.Dataset``  或  ``paddle.io.Dataloader``  的实例。默认值：None。
+    - **eval_data** (Dataset|DataLoader，可选) - 一个可迭代的数据源，推荐给定一个  ``paddle paddle.io.Dataset``  或  ``paddle.io.Dataloader``  的实例。当给定时，会在每个  ``epoch``  后都会进行评估。默认值：None。
+    - **batch_size** (int，可选) - 训练数据或评估数据的批大小，当  ``train_data``  或  ``eval_data``  为  ``DataLoader``  的实例时，该参数会被忽略。默认值：1。
     - **epochs** (int，可选) - 训练的轮数。默认值：1。
-    - **eval_freq** (int，可选) - 评估的频率，多少个 ``epoch`` 评估一次。默认值：1。
-    - **log_freq** (int，可选) - 日志打印的频率，多少个 ``step`` 打印一次日志。默认值：10。
+    - **eval_freq** (int，可选) - 评估的频率，多少个  ``epoch``  评估一次。默认值：1。
+    - **log_freq** (int，可选) - 日志打印的频率，多少个  ``step``  打印一次日志。默认值：10。
     - **save_dir** (str|None，可选) - 保存模型的文件夹，如果不设定，将不保存模型。默认值：None。
-    - **save_freq** (int，可选) - 保存模型的频率，多少个 ``epoch`` 保存一次模型。默认值：1。
+    - **save_freq** (int，可选) - 保存模型的频率，多少个  ``epoch``  保存一次模型。默认值：1。
     - **verbose** (int，可选) - 可视化的模型，必须为 0，1，2。当设定为 0 时，不打印日志，设定为 1 时，使用进度条的方式打印日志，设定为 2 时，一行一行地打印日志。默认值：2。
     - **drop_last** (bool，可选) - 是否丢弃训练数据中最后几个不足设定的批次大小的数据。默认值：False。
-    - **shuffle** (bool，可选) - 是否对训练数据进行洗牌。当 ``train_data`` 为 ``DataLoader`` 的实例时，该参数会被忽略。默认值：True。
-    - **num_workers** (int，可选) - 启动子进程用于读取数据的数量。当 ``train_data`` 和 ``eval_data`` 都为 ``DataLoader`` 的实例时，该参数会被忽略。默认值：0。
-    - **callbacks** (Callback|list[Callback]|None，可选) -  ``Callback`` 的一个实例或实例列表。该参数不给定时，默认会插入 :ref:`cn_api_paddle_callbacks_ProgBarLogger` 和 :ref:`cn_api_paddle_callbacks_ModelCheckpoint` 这两个实例。默认值：None。
-    - **accumulate_grad_batches** (int，可选) -  训练过程中，在优化器更新之前累积梯度的批次数。通过改变该参数可以模拟大的 ``batch_size``。默认值：1。
-    - **num_iters** (int，可选) -  训练模型过程中的迭代次数。如果设置为 None，则根据参数 ``epochs`` 来训练模型，否则训练模型 ``num_iters`` 次。默认值：None。
+    - **shuffle** (bool，可选) - 是否对训练数据进行洗牌。当  ``train_data``  为  ``DataLoader``  的实例时，该参数会被忽略。默认值：True。
+    - **num_workers** (int，可选) - 启动子进程用于读取数据的数量。当  ``train_data``  和  ``eval_data``  都为  ``DataLoader``  的实例时，该参数会被忽略。默认值：0。
+    - **callbacks** (Callback|list[Callback]|None，可选) -   ``Callback``  的一个实例或实例列表。该参数不给定时，默认会插入 :ref:`cn_api_paddle_callbacks_ProgBarLogger` 和 :ref:`cn_api_paddle_callbacks_ModelCheckpoint` 这两个实例。默认值：None。
+    - **accumulate_grad_batches** (int，可选) -  训练过程中，在优化器更新之前累积梯度的批次数。通过改变该参数可以模拟大的  ``batch_size`` 。默认值：1。
+    - **num_iters** (int，可选) -  训练模型过程中的迭代次数。如果设置为 None，则根据参数  ``epochs``  来训练模型，否则训练模型  ``num_iters``  次。默认值：None。
 
 
 **返回**
@@ -215,17 +215,17 @@ evaluate(eval_data, batch_size=1, log_freq=10, verbose=2, num_workers=0, callbac
 
 **参数**
 
-    - **eval_data** (Dataset|DataLoader) - 一个可迭代的数据源，推荐给定一个 ``paddle.io.Dataset`` 或 ``paddle.io.Dataloader`` 的实例。默认值：None。
-    - **batch_size** (int，可选) - 训练数据或评估数据的批大小，当 ``eval_data`` 为 ``DataLoader`` 的实例时，该参数会被忽略。默认值：1。
-    - **log_freq** (int，可选) - 日志打印的频率，多少个 ``step`` 打印一次日志。默认值：10。
+    - **eval_data** (Dataset|DataLoader) - 一个可迭代的数据源，推荐给定一个  ``paddle.io.Dataset``  或  ``paddle.io.Dataloader``  的实例。默认值：None。
+    - **batch_size** (int，可选) - 训练数据或评估数据的批大小，当  ``eval_data``  为  ``DataLoader``  的实例时，该参数会被忽略。默认值：1。
+    - **log_freq** (int，可选) - 日志打印的频率，多少个  ``step``  打印一次日志。默认值：10。
     - **verbose** (int，可选) - 可视化的模型，必须为 0，1，2。当设定为 0 时，不打印日志，设定为 1 时，使用进度条的方式打印日志，设定为 2 时，一行一行地打印日志。默认值：2。
-    - **num_workers** (int，可选) - 启动子进程用于读取数据的数量。当 ``eval_data`` 为 ``DataLoader`` 的实例时，该参数会被忽略。默认值：0。
-    - **callbacks** (Callback|list[Callback]|None，可选) -  ``Callback`` 的一个实例或实例列表。该参数不给定时，默认会插入 ``ProgBarLogger`` 和 ``ModelCheckpoint`` 这两个实例。默认值：None。
-    - **num_iters** (int，可选) -  训练模型过程中的迭代次数。如果设置为 None，则根据参数 ``epochs`` 来训练模型，否则训练模型 ``num_iters`` 次。默认值：None。
+    - **num_workers** (int，可选) - 启动子进程用于读取数据的数量。当  ``eval_data``  为  ``DataLoader``  的实例时，该参数会被忽略。默认值：0。
+    - **callbacks** (Callback|list[Callback]|None，可选) -   ``Callback``  的一个实例或实例列表。该参数不给定时，默认会插入  ``ProgBarLogger``  和  ``ModelCheckpoint``  这两个实例。默认值：None。
+    - **num_iters** (int，可选) -  训练模型过程中的迭代次数。如果设置为 None，则根据参数  ``epochs``  来训练模型，否则训练模型  ``num_iters``  次。默认值：None。
 
 **返回**
 
-dict, key 是 ``prepare`` 时 Metric 的的名称，value 是该 Metric 的值。
+dict, key 是  ``prepare``  时 Metric 的的名称，value 是该 Metric 的值。
 
 **代码示例**
 
@@ -239,12 +239,12 @@ predict(test_data, batch_size=1, num_workers=0, stack_outputs=False, verbose=1,
 
 **参数**
 
-    - **test_data** (Dataset|DataLoader) - 一个可迭代的数据源，推荐给定一个 ``paddle.io.Dataset`` 或 ``paddle.io.Dataloader`` 的实例。默认值：None。
-    - **batch_size** (int，可选) - 训练数据或评估数据的批大小，当 ``test_data`` 为 ``DataLoader`` 的实例时，该参数会被忽略。默认值：1。
-    - **num_workers** (int，可选) - 启动子进程用于读取数据的数量。当 ``test_data`` 为 ``DataLoader`` 的实例时，该参数会被忽略。默认值：0。
-    - **stack_outputs** (bool，可选) - 是否将输出进行堆叠。比如对于单个样本输出形状为 ``[X, Y]``，``test_data`` 包含 N 个样本的情况，如果 ``stack_outputs`` 设置为 True，那么输出的形状将会是 ``[N, X, Y]``，如果 ``stack_outputs`` 设置为 False，那么输出的形状将会是 ``[[X, Y], [X, Y], ..., [X, Y]]``。将 ``stack_outputs`` 设置为 False 适用于输出为 DenseTensor 的情况，如果输出不包含 DenseTensor，建议将其设置为 True。默认值：False。
+    - **test_data** (Dataset|DataLoader) - 一个可迭代的数据源，推荐给定一个  ``paddle.io.Dataset``  或  ``paddle.io.Dataloader``  的实例。默认值：None。
+    - **batch_size** (int，可选) - 训练数据或评估数据的批大小，当  ``test_data``  为  ``DataLoader``  的实例时，该参数会被忽略。默认值：1。
+    - **num_workers** (int，可选) - 启动子进程用于读取数据的数量。当  ``test_data``  为  ``DataLoader``  的实例时，该参数会被忽略。默认值：0。
+    - **stack_outputs** (bool，可选) - 是否将输出进行堆叠。比如对于单个样本输出形状为  ``[X, Y]`` ， ``test_data``  包含 N 个样本的情况，如果  ``stack_outputs``  设置为 True，那么输出的形状将会是  ``[N, X, Y]`` ，如果  ``stack_outputs``  设置为 False，那么输出的形状将会是  ``[[X, Y], [X, Y], ..., [X, Y]]`` 。将  ``stack_outputs``  设置为 False 适用于输出为 DenseTensor 的情况，如果输出不包含 DenseTensor，建议将其设置为 True。默认值：False。
     - **verbose** (int，可选) - 可视化的模型，必须为 0，1，2。当设定为 0 时，不打印日志，设定为 1 时，使用进度条的方式打印日志，设定为 2 时，一行一行地打印日志。默认值：1。
-    - **callbacks** (Callback|list[Callback]|None，可选) -  ``Callback`` 的一个实例或实例列表。默认值：None。
+    - **callbacks** (Callback|list[Callback]|None，可选) -   ``Callback``  的一个实例或实例列表。默认值：None。
 
 **返回**
 
@@ -262,8 +262,8 @@ summary(input_size=None, dtype=None)
 
 **参数**
 
-    - **input_size** (tuple|InputSpec|list[tuple|InputSpec]，可选) - 输入 Tensor 的大小。如果网络只有一个输入，那么该值需要设定为 tuple 或 InputSpec。如果模型有多个输入。那么该值需要设定为 list[tuple|InputSpec]，包含每个输入的 shape 。如果该值没有设置，会将 ``self._inputs`` 作为输入。默认值：None。
-    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输入 Tensor 的数据类型，如果没有给定，默认使用 ``float32`` 类型。默认值：None。
+    - **input_size** (tuple|InputSpec|list[tuple|InputSpec]，可选) - 输入 Tensor 的大小。如果网络只有一个输入，那么该值需要设定为 tuple 或 InputSpec。如果模型有多个输入。那么该值需要设定为 list[tuple|InputSpec]，包含每个输入的 shape 。如果该值没有设置，会将  ``self._inputs``  作为输入。默认值：None。
+    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输入 Tensor 的数据类型，如果没有给定，默认使用  ``float32``  类型。默认值：None。
 
 **返回**
 
diff --git a/docs/api/paddle/Overview_cn.rst b/docs/api/paddle/Overview_cn.rst
index 4e694011551..07df7fd02e4 100755
--- a/docs/api/paddle/Overview_cn.rst
+++ b/docs/api/paddle/Overview_cn.rst
@@ -91,7 +91,7 @@ tensor 数学操作
     " :ref:`paddle.log <cn_api_paddle_log>` ", "Log 激活函数（计算自然对数）"
     " :ref:`paddle.log10 <cn_api_paddle_log10>` ", "Log10 激活函数（计算底为 10 的对数）"
     " :ref:`paddle.log2 <cn_api_paddle_log2>` ", "计算 Log1p（加一的自然对数）结果"
-    " :ref:`paddle.logaddexp <cn_api_paddle_logaddexp>` ", "计算 ``x`` 和 ``y`` 的以 e 为底的指数的和的自然对数"
+    " :ref:`paddle.logaddexp <cn_api_paddle_logaddexp>` ", "计算  ``x``  和  ``y``  的以 e 为底的指数的和的自然对数"
     " :ref:`paddle.logcumsumexp <cn_api_paddle_logcumsumexp>` ", "计算 x 的指数的前缀和的对数"
     " :ref:`paddle.logical_and <cn_api_paddle_logical_and>` ", "逐元素的对 x 和 y 进行逻辑与运算"
     " :ref:`paddle.logical_not <cn_api_paddle_logical_not>` ", "逐元素的对 X Tensor 进行逻辑非运算"
@@ -125,9 +125,9 @@ tensor 数学操作
     " :ref:`paddle.ldexp <cn_api_paddle_ldexp>` ", "计算 x 乘以 2 的 y 次幂"
     " :ref:`paddle.multigammaln <cn_api_paddle_multigammaln>` ", "计算多元伽马函数的对数"
     " :ref:`paddle.nan_to_num <cn_api_paddle_nan_to_num>` ", "替换 x 中的 NaN、+inf、-inf 为指定值"
-    " :ref:`paddle.quantile <cn_api_paddle_quantile>` ", "沿给定的轴 ``axis`` 计算 ``x`` 中元素的分位数"
-    " :ref:`paddle.nanmean <cn_api_paddle_nanmean>` ", "沿 ``axis`` 计算 ``x`` 的平均值，且忽略掉 ``NaNs`` 值"
-    " :ref:`paddle.nanquantile <cn_api_paddle_nanquantile>` ", "沿给定的轴 ``axis`` 计算 ``x`` 中元素的分位数, 忽略元素中的 ``NaN``"
+    " :ref:`paddle.quantile <cn_api_paddle_quantile>` ", "沿给定的轴  ``axis``  计算  ``x``  中元素的分位数"
+    " :ref:`paddle.nanmean <cn_api_paddle_nanmean>` ", "沿  ``axis``  计算  ``x``  的平均值，且忽略掉  ``NaNs``  值"
+    " :ref:`paddle.nanquantile <cn_api_paddle_nanquantile>` ", "沿给定的轴  ``axis``  计算  ``x``  中元素的分位数, 忽略元素中的  ``NaN`` "
     " :ref:`paddle.nansum <cn_api_paddle_nansum>` ", "计算给定轴上的元素之和，并将非数字元素（NaNs）视为 0"
     " :ref:`paddle.neg <cn_api_paddle_neg>` ", "计算输入 x 的相反数并返回"
     " :ref:`paddle.nextafter <cn_api_paddle_nextafter>` ", "逐元素将 x 之后的下一个浮点值返回"
@@ -343,7 +343,7 @@ tensor 创建相关
 
     " :ref:`paddle.arange <cn_api_paddle_arange>` ", "返回以步长 step 均匀分隔给定数值区间[start, end)的 1-D Tensor，数据类型为 dtype"
     " :ref:`paddle.diag <cn_api_paddle_diag>` ", "如果 x 是向量（1-D Tensor），则返回带有 x 元素作为对角线的 2-D 方阵；如果 x 是矩阵（2-D Tensor），则提取 x 的对角线元素，以 1-D Tensor 返回。"
-    " :ref:`paddle.diag_embed <cn_api_paddle_diag_embed>` ", "创建一个 Tensor，其在指定的 2D 平面（由 ``dim1`` 和 ``dim2`` 指定）上的对角线由输入 ``input`` 填充"
+    " :ref:`paddle.diag_embed <cn_api_paddle_diag_embed>` ", "创建一个 Tensor，其在指定的 2D 平面（由  ``dim1``  和  ``dim2``  指定）上的对角线由输入  ``input``  填充"
     " :ref:`paddle.diagflat <cn_api_paddle_diagflat>` ", "如果 x 是一维 Tensor，则返回带有 x 元素作为对角线的二维方阵；如果 x 是大于等于二维的 Tensor，则返回一个二维 Tensor，其对角线元素为 x 在连续维度展开得到的一维 Tensor 的元素。"
     " :ref:`paddle.empty <cn_api_paddle_empty>` ", "创建形状大小为 shape 并且数据类型为 dtype 的 Tensor"
     " :ref:`paddle.empty_like <cn_api_paddle_empty_like>` ", "根据 x 的 shape 和数据类型 dtype 创建未初始化的 Tensor"
@@ -363,9 +363,9 @@ tensor 创建相关
     " :ref:`paddle.zeros_like <cn_api_paddle_zeros_like>` ", "返回一个和 x 具有相同的形状的全零 Tensor，数据类型为 dtype 或者和 x 相同"
     " :ref:`paddle.complex <cn_api_paddle_complex>` ", "给定实部和虚部，返回一个复数 Tensor"
     " :ref:`paddle.create_parameter <cn_api_paddle_create_parameter>` ", "创建一个参数,该参数是一个可学习的变量, 拥有梯度并且可优化"
-    " :ref:`paddle.clone <cn_api_paddle_clone>` ", "对输入 Tensor ``x`` 进行拷贝，并返回一个新的 Tensor，并且该操作提供梯度回传"
+    " :ref:`paddle.clone <cn_api_paddle_clone>` ", "对输入 Tensor  ``x``  进行拷贝，并返回一个新的 Tensor，并且该操作提供梯度回传"
     " :ref:`paddle.batch <cn_api_paddle_batch>` ", "一个 reader 的装饰器。返回的 reader 将输入 reader 的数据打包成指定的 batch_size 大小的批处理数据（不推荐使用）"
-    " :ref:`paddle.polar <cn_api_paddle_polar>`", "对于给定的模 ``abs`` 和相位角 ``angle``，返回一个对应复平面上的坐标复数 Tensor"
+    " :ref:`paddle.polar <cn_api_paddle_polar>`", "对于给定的模  ``abs``  和相位角  ``angle`` ，返回一个对应复平面上的坐标复数 Tensor"
     " :ref:`paddle.range <cn_api_paddle_range>` ，返回一个 1-D Tensor，包含在区间 [start, end] 内按给定步长 step 均匀排列的数值，数据类型为 dtype。"
     " :ref:`paddle.vander <cn_api_paddle_vander>` ", "生成范德蒙德矩阵。"
 
@@ -513,9 +513,9 @@ tensor 元素操作相关（如：转置，reshape 等）
     " :ref:`paddle.gather <cn_api_paddle_gather>` ", "根据索引 index 获取输入 x 的指定 axis 维度的条目，并将它们拼接在一起"
     " :ref:`paddle.gather_nd <cn_api_paddle_gather_nd>` ", "paddle.gather 的高维推广"
     " :ref:`paddle.reshape <cn_api_paddle_reshape>` ", "在保持输入 x 数据不变的情况下，改变 x 的形状"
-    " :ref:`paddle.atleast_1d <cn_api_paddle_atleast_1d>` ", "将输入转换为张量并返回至少为 ``1`` 维的视图"
-    " :ref:`paddle.atleast_2d <cn_api_paddle_atleast_2d>` ", "将输入转换为张量并返回至少为 ``2`` 维的视图"
-    " :ref:`paddle.atleast_3d <cn_api_paddle_atleast_3d>` ", "将输入转换为张量并返回至少为 ``3`` 维的视图"
+    " :ref:`paddle.atleast_1d <cn_api_paddle_atleast_1d>` ", "将输入转换为张量并返回至少为  ``1``  维的视图"
+    " :ref:`paddle.atleast_2d <cn_api_paddle_atleast_2d>` ", "将输入转换为张量并返回至少为  ``2``  维的视图"
+    " :ref:`paddle.atleast_3d <cn_api_paddle_atleast_3d>` ", "将输入转换为张量并返回至少为  ``3``  维的视图"
     " :ref:`paddle.roll <cn_api_paddle_roll>` ", "沿着指定维度 axis 对输入 x 进行循环滚动，当元素移动到最后位置时，会从第一个位置重新插入"
     " :ref:`paddle.scatter <cn_api_paddle_distributed_scatter>` ", "通过基于 updates 来更新选定索引 index 上的输入来获得输出"
     " :ref:`paddle.scatter_nd <cn_api_paddle_scatter_nd>` ", "根据 index ，将 updates 添加到一个新的张量中，从而得到输出的 Tensor"
@@ -576,7 +576,7 @@ tensor 元素操作相关原位（inplace）版本
 
     " :ref:`paddle.cast_ <cn_api_paddle_cast_>` ", "Inplace 版本的 cast API，对输入 x 采用 Inplace 策略"
     " :ref:`paddle.index_add_ <cn_api_paddle_index_add_>` ", "Inplace 版本的 :ref:`cn_api_paddle_index_add` API，对输入 `x` 采用 Inplace 策略"
-    " :ref:`paddle.index_put_ <cn_api_paddle_index_put_>` ", "依据索引 ``indices`` ，将指定位置的 ``x`` 重新赋值为 ``value`` "
+    " :ref:`paddle.index_put_ <cn_api_paddle_index_put_>` ", "依据索引  ``indices``  ，将指定位置的  ``x``  重新赋值为  ``value``  "
     " :ref:`paddle.reshape_ <cn_api_paddle_reshape_>` ", "Inplace 版本的 reshape API，对输入 x 采用 Inplace 策略"
     " :ref:`paddle.scatter_ <cn_api_paddle_scatter_>` ", "Inplace 版本的 scatter API，对输入 x 采用 Inplace 策略 "
     " :ref:`paddle.squeeze_ <cn_api_paddle_squeeze_>` ", "Inplace 版本的 squeeze API，对输入 x 采用 Inplace 策略"
@@ -615,7 +615,7 @@ framework 相关
     " :ref:`paddle.get_rng_state <cn_api_paddle_get_rng_state>` ", "获取指定设备的随机数生成器的所有随机状态。"
     " :ref:`paddle.grad <cn_api_paddle_grad>` ", "对于每个 inputs ，计算所有 outputs 相对于其的梯度和"
     " :ref:`paddle.in_dynamic_mode <cn_api_paddle_in_dynamic_mode>` ", "查看 paddle 当前是否在动态图模式中运行"
-    " :ref:`paddle.LazyGuard <cn_api_paddle_LazyGuard>` ", "用于设置模型（继承自 ``paddle.nn.Layer`` ） 中参数延迟初始化的上下文管理器"
+    " :ref:`paddle.LazyGuard <cn_api_paddle_LazyGuard>` ", "用于设置模型（继承自  ``paddle.nn.Layer``  ） 中参数延迟初始化的上下文管理器"
     " :ref:`paddle.load <cn_api_paddle_load>` ", "从指定路径载入可以在 paddle 中使用的对象实例"
     " :ref:`paddle.no_grad <cn_api_paddle_no_grad>` ", "创建一个上下文来禁用动态图梯度计算"
     " :ref:`paddle.ParamAttr <cn_api_paddle_ParamAttr>` ", "创建一个参数属性对象"
diff --git a/docs/api/paddle/ParamAttr_cn.rst b/docs/api/paddle/ParamAttr_cn.rst
index 745daa47edb..a3b8a7c3d00 100644
--- a/docs/api/paddle/ParamAttr_cn.rst
+++ b/docs/api/paddle/ParamAttr_cn.rst
@@ -8,7 +8,7 @@ ParamAttr
 
 
 .. note::
-    该类中的 ``gradient_clip`` 属性在 2.0 版本会废弃，推荐使用 ``need_clip`` 来设置梯度裁剪范围，并在初始化 ``optimizer`` 时设置梯度裁剪。
+    该类中的  ``gradient_clip``  属性在 2.0 版本会废弃，推荐使用  ``need_clip``  来设置梯度裁剪范围，并在初始化  ``optimizer``  时设置梯度裁剪。
     共有三种裁剪策略： :ref:`cn_api_paddle_nn_ClipGradByGlobalNorm` 、 :ref:`cn_api_paddle_nn_ClipGradByNorm` 、 :ref:`cn_api_paddle_nn_ClipGradByValue` 。
 
 创建一个参数属性对象，用户可设置参数的名称、初始化方式、学习率、正则化规则、是否需要训练、梯度裁剪方式、是否做模型平均等属性。
@@ -20,8 +20,8 @@ ParamAttr
     - **initializer** (Initializer，可选) - 参数的初始化方式。默认值为 None，表示权重参数采用 Xavier 初始化方式，偏置参数采用全 0 初始化方式。
     - **learning_rate** (float，可选) - 参数的学习率。实际参数的学习率等于全局学习率乘以参数的学习率，再乘以 learning rate schedule 的系数。
     - **regularizer** (WeightDecayRegularizer，可选) - 正则化方法。支持两种正则化策略：:ref:`api_paddle_regularizer_L1Decay` 、
-      :ref:`api_paddle_regularizer_L2Decay`，如果在 ``optimizer`` (例如 :ref:`api_paddle_optimizer_SGD` ) 中也
-      设置了正则化，``optimizer`` 中的正则化将被忽略。默认值为 None，表示没有正则化。
+      :ref:`api_paddle_regularizer_L2Decay`，如果在  ``optimizer``  (例如 :ref:`api_paddle_optimizer_SGD` ) 中也
+      设置了正则化， ``optimizer``  中的正则化将被忽略。默认值为 None，表示没有正则化。
     - **trainable** (bool，可选) - 参数是否需要训练。默认值为 True，表示需要训练。
     - **do_model_average** (bool，可选) - 是否做模型平均。默认值为 True。仅在 :ref:`ExponentialMovingAverage` 下使用。
     - **need_clip** (bool，可选) - 参数是否需要进行梯度裁剪。默认值为 True，表示该参数的梯度会根据优化器中设置的裁剪规则进行裁剪。
diff --git a/docs/api/paddle/Tensor__upper_cn.rst b/docs/api/paddle/Tensor__upper_cn.rst
index 18651def532..f0cd2e95cdc 100755
--- a/docs/api/paddle/Tensor__upper_cn.rst
+++ b/docs/api/paddle/Tensor__upper_cn.rst
@@ -6,14 +6,14 @@ Tensor
 .. py:class:: paddle.Tensor
 
 
-``Tensor`` 是 Paddle 中最为基础的数据结构，请参考 `Tensor 介绍 <https://www.paddlepaddle.org.cn/documentation/docs/guides/beginner/tensor_cn.html>`_
+ ``Tensor``  是 Paddle 中最为基础的数据结构，请参考 `Tensor 介绍 <https://www.paddlepaddle.org.cn/documentation/docs/guides/beginner/tensor_cn.html>`_
 
-- 用预先存在的 ``data`` 数据创建 1 个 Tensor，请参考 :ref:`cn_api_paddle_tensor`
-- 创建一个指定 ``shape`` 的 Tensor，请参考 :ref:`cn_api_paddle_ones` 、 :ref:`cn_api_paddle_zeros`、 :ref:`cn_api_paddle_full`
-- 创建一个与其他 Tensor 具有相同 ``shape`` 与 ``dtype`` 的 Tensor，请参考 :ref:`cn_api_paddle_ones_like` 、 :ref:`cn_api_paddle_zeros_like` 、 :ref:`cn_api_paddle_full_like`
+- 用预先存在的  ``data``  数据创建 1 个 Tensor，请参考 :ref:`cn_api_paddle_tensor`
+- 创建一个指定  ``shape``  的 Tensor，请参考 :ref:`cn_api_paddle_ones` 、 :ref:`cn_api_paddle_zeros`、 :ref:`cn_api_paddle_full`
+- 创建一个与其他 Tensor 具有相同  ``shape``  与  ``dtype``  的 Tensor，请参考 :ref:`cn_api_paddle_ones_like` 、 :ref:`cn_api_paddle_zeros_like` 、 :ref:`cn_api_paddle_full_like`
 
 .. note::
-    支持与 torch 相同的构造函数，但不鼓励使用构造函数直接构建，推荐使用 ``paddle.tensor`` 构建 Tensor，详细请参考 :ref:`cn_api_paddle_tensor`。
+    支持与 torch 相同的构造函数，但不鼓励使用构造函数直接构建，推荐使用  ``paddle.tensor``  构建 Tensor，详细请参考 :ref:`cn_api_paddle_tensor`。
 
     **代码示例**
 
@@ -29,21 +29,21 @@ Tensor
             paddle.Tensor(data=[1,2,3])
             paddle.Tensor(data=[1,2,3], device="cpu")
 
-    支持与 torch 相同的 ``[Dtype]Tensor``，其使用方式与 ``Tensor`` 相同，但不鼓励使用该构造方式，推荐使用 ``paddle.tensor`` 与 ``dtype`` 参数结合的方式构造 Tensor，详细请参考 :ref:`cn_api_paddle_tensor`。
+    支持与 torch 相同的  ``[Dtype]Tensor`` ，其使用方式与  ``Tensor``  相同，但不鼓励使用该构造方式，推荐使用  ``paddle.tensor``  与  ``dtype``  参数结合的方式构造 Tensor，详细请参考 :ref:`cn_api_paddle_tensor`。
 
     ======================================= ===========================================
     Data type                               \[Dtype\]Tensor
     ======================================= ===========================================
-    32-bit floating point                   ``paddle.FloatTensor``
-    64-bit floating point                   ``paddle.DoubleTensor``
-    16-bit floating point                   ``paddle.HalfTensor``
-    16-bit floating point                   ``paddle.BFloat16Tensor``
-    8-bit integer (unsigned)                ``paddle.ByteTensor``
-    8-bit integer (signed)                  ``paddle.CharTensor``
-    16-bit integer (signed)                 ``paddle.ShortTensor``
-    32-bit integer (signed)                 ``paddle.IntTensor``
-    64-bit integer (signed)                 ``paddle.LongTensor``
-    Boolean                                 ``paddle.BoolTensor``
+    32-bit floating point                    ``paddle.FloatTensor`` 
+    64-bit floating point                    ``paddle.DoubleTensor`` 
+    16-bit floating point                    ``paddle.HalfTensor`` 
+    16-bit floating point                    ``paddle.BFloat16Tensor`` 
+    8-bit integer (unsigned)                 ``paddle.ByteTensor`` 
+    8-bit integer (signed)                   ``paddle.CharTensor`` 
+    16-bit integer (signed)                  ``paddle.ShortTensor`` 
+    32-bit integer (signed)                  ``paddle.IntTensor`` 
+    64-bit integer (signed)                  ``paddle.LongTensor`` 
+    Boolean                                  ``paddle.BoolTensor`` 
     ======================================= ===========================================
 
 create_tensor(dtype, name=None, persistable=False)
@@ -257,12 +257,12 @@ COPY-FROM: paddle.Tensor.layout
 requires_grad
 :::::::::
 
-查看一个 Tensor 是否计算并传播梯度。``requires_grad`` 属性与 ``stop_gradient`` 属性含义相反：
+查看一个 Tensor 是否计算并传播梯度。 ``requires_grad``  属性与  ``stop_gradient``  属性含义相反：
 
-- 当 ``requires_grad`` 为 ``True`` 时，该 Tensor 会计算梯度并参与梯度传播
-- 当 ``requires_grad`` 为 ``False`` 时，该 Tensor 不会计算梯度，并会阻止 Autograd 的梯度传播
+- 当  ``requires_grad``  为  ``True``  时，该 Tensor 会计算梯度并参与梯度传播
+- 当  ``requires_grad``  为  ``False``  时，该 Tensor 不会计算梯度，并会阻止 Autograd 的梯度传播
 
-用户自行创建的 Tensor，``requires_grad`` 默认为 ``False``；模型参数的 ``requires_grad`` 默认为 ``True``。
+用户自行创建的 Tensor， ``requires_grad``  默认为  ``False`` ；模型参数的  ``requires_grad``  默认为  ``True`` 。
 
 **代码示例**
 
@@ -695,7 +695,7 @@ asin(name=None)
 astype(dtype)
 :::::::::
 
-将 Tensor 的类型转换为 ``dtype``，并返回一个新的 Tensor。
+将 Tensor 的类型转换为  ``dtype`` ，并返回一个新的 Tensor。
 
 参数：
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 转换后的 dtype，支持'bool'，'float16'，'float32'，'float64'，'int8'，'int16'，
@@ -716,7 +716,7 @@ astype(dtype)
 bfloat16()
 :::::::::
 
-如果当前 Tensor 已经是 ``bfloat16`` 类型，则返回该 Tensor。否则，返回一个新的 ``bfloat16`` 类型的 Tensor 副本。
+如果当前 Tensor 已经是  ``bfloat16``  类型，则返回该 Tensor。否则，返回一个新的  ``bfloat16``  类型的 Tensor 副本。
 
 返回： 转换后的 Tensor
 
@@ -733,7 +733,7 @@ bfloat16()
 bool()
 :::::::::
 
-如果当前 Tensor 已经是 ``bool`` 类型，则返回该 Tensor。否则，返回一个新的 ``bool`` 类型的 Tensor 副本。
+如果当前 Tensor 已经是  ``bool``  类型，则返回该 Tensor。否则，返回一个新的  ``bool``  类型的 Tensor 副本。
 
 返回： 转换后的 Tensor
 
@@ -750,7 +750,7 @@ bool()
 byte()
 :::::::::
 
-如果当前 Tensor 已经是 ``byte`` 类型，则返回该 Tensor。否则，返回一个新的 ``byte`` 类型的 Tensor 副本。
+如果当前 Tensor 已经是  ``byte``  类型，则返回该 Tensor。否则，返回一个新的  ``byte``  类型的 Tensor 副本。
 
 返回： 转换后的 Tensor
 
@@ -767,7 +767,7 @@ byte()
 char()
 :::::::::
 
-如果当前 Tensor 已经是 ``char`` 类型，则返回该 Tensor。否则，返回一个新的 ``char`` 类型的 Tensor 副本。
+如果当前 Tensor 已经是  ``char``  类型，则返回该 Tensor。否则，返回一个新的  ``char``  类型的 Tensor 副本。
 
 返回： 转换后的 Tensor
 
@@ -784,7 +784,7 @@ char()
 double()
 :::::::::
 
-如果当前 Tensor 已经是 ``double`` 类型，则返回该 Tensor。否则，返回一个新的 ``double`` 类型的 Tensor 副本。
+如果当前 Tensor 已经是  ``double``  类型，则返回该 Tensor。否则，返回一个新的  ``double``  类型的 Tensor 副本。
 
 返回： 转换后的 Tensor
 
@@ -801,7 +801,7 @@ double()
 float()
 :::::::::
 
-如果当前 Tensor 已经是 ``float`` 类型，则返回该 Tensor。否则，返回一个新的 ``float`` 类型的 Tensor 副本。
+如果当前 Tensor 已经是  ``float``  类型，则返回该 Tensor。否则，返回一个新的  ``float``  类型的 Tensor 副本。
 
 返回： 转换后的 Tensor
 
@@ -818,7 +818,7 @@ float()
 half()
 :::::::::
 
-如果当前 Tensor 已经是 ``half`` 类型，则返回该 Tensor。否则，返回一个新的 ``half`` 类型的 Tensor 副本。
+如果当前 Tensor 已经是  ``half``  类型，则返回该 Tensor。否则，返回一个新的  ``half``  类型的 Tensor 副本。
 
 返回： 转换后的 Tensor
 
@@ -847,7 +847,7 @@ type_as(other)
 int()
 :::::::::
 
-如果当前 Tensor 已经是 ``int`` 类型，则返回该 Tensor。否则，返回一个新的 ``int`` 类型的 Tensor 副本。
+如果当前 Tensor 已经是  ``int``  类型，则返回该 Tensor。否则，返回一个新的  ``int``  类型的 Tensor 副本。
 
 返回： 转换后的 Tensor
 
@@ -864,7 +864,7 @@ int()
 long()
 :::::::::
 
-如果当前 Tensor 已经是 ``long`` 类型，则返回该 Tensor。否则，返回一个新的 ``long`` 类型的 Tensor 副本。
+如果当前 Tensor 已经是  ``long``  类型，则返回该 Tensor。否则，返回一个新的  ``long``  类型的 Tensor 副本。
 
 返回： 转换后的 Tensor
 
@@ -881,7 +881,7 @@ long()
 short()
 :::::::::
 
-如果当前 Tensor 已经是 ``short`` 类型，则返回该 Tensor。否则，返回一个新的 ``short`` 类型的 Tensor 副本。
+如果当前 Tensor 已经是  ``short``  类型，则返回该 Tensor。否则，返回一个新的  ``short``  类型的 Tensor 副本。
 
 返回： 转换后的 Tensor
 
@@ -898,7 +898,7 @@ short()
 cfloat()
 :::::::::
 
-如果当前 Tensor 已经是 ``cfloat`` 类型，则返回该 Tensor。否则，返回一个新的 ``cfloat`` 类型的 Tensor 副本。
+如果当前 Tensor 已经是  ``cfloat``  类型，则返回该 Tensor。否则，返回一个新的  ``cfloat``  类型的 Tensor 副本。
 
 返回： 转换后的 Tensor
 
@@ -915,7 +915,7 @@ cfloat()
 cdouble()
 :::::::::
 
-如果当前 Tensor 已经是 ``cdouble`` 类型，则返回该 Tensor。否则，返回一个新的 ``cdouble`` 类型的 Tensor 副本。
+如果当前 Tensor 已经是  ``cdouble``  类型，则返回该 Tensor。否则，返回一个新的  ``cdouble``  类型的 Tensor 副本。
 
 返回： 转换后的 Tensor
 
@@ -944,7 +944,7 @@ backward(grad_tensor=None, retain_graph=False)
 从当前 Tensor 开始计算反向的神经网络，传导并计算计算图中 Tensor 的梯度。
 
 参数：
-    - **grad_tensor** (Tensor, 可选) - 当前 Tensor 的初始梯度值。如果 ``grad_tensor`` 是 None，当前 Tensor 的初始梯度值将会是值全为 1.0 的 Tensor；如果 ``grad_tensor`` 不是 None，必须和当前 Tensor 有相同的长度。默认值：None。
+    - **grad_tensor** (Tensor, 可选) - 当前 Tensor 的初始梯度值。如果  ``grad_tensor``  是 None，当前 Tensor 的初始梯度值将会是值全为 1.0 的 Tensor；如果  ``grad_tensor``  不是 None，必须和当前 Tensor 有相同的长度。默认值：None。
 
     - **retain_graph** (bool, 可选) - 如果为 False，反向计算图将被释放。如果在 backward()之后继续添加 OP，
       需要设置为 True，此时之前的反向计算图会保留。将其设置为 False 会更加节省内存。默认值：False。
@@ -1058,7 +1058,7 @@ broadcast_to(shape, name=None)
 
 bucketize(sorted_sequence, out_int32=False, right=False, name=None)
 :::::::::
-返回: 根据给定的一维 Tensor ``sorted_sequence`` ，输入 ``x`` 对应的桶索引。
+返回: 根据给定的一维 Tensor  ``sorted_sequence``  ，输入  ``x``  对应的桶索引。
 
 返回类型：Tensor。
 
@@ -1211,7 +1211,7 @@ COPY-FROM: paddle.cosh
 count_nonzero(axis=None, keepdim=False, name=None)
 :::::::::
 
-返回：沿给定的轴 ``axis`` 统计输入 Tensor ``x`` 中非零元素的个数。
+返回：沿给定的轴  ``axis``  统计输入 Tensor  ``x``  中非零元素的个数。
 
 返回类型：Tensor
 
@@ -1366,7 +1366,7 @@ diff(x, n=1, axis=-1, prepend=None, append=None, name=None)
 element_size()
 :::::::::
 
-返回 Tensor 单个元素在计算机中所分配的 ``bytes`` 数量。
+返回 Tensor 单个元素在计算机中所分配的  ``bytes``  数量。
 
 返回：整数 int
 
@@ -1452,21 +1452,21 @@ expand_as(y, name=None)
 exponential_(lam=1.0, name=None)
 :::::::::
 
-该 OP 为 inplace 形式，通过 ``指数分布`` 随机数来填充该 Tensor。
+该 OP 为 inplace 形式，通过  ``指数分布``  随机数来填充该 Tensor。
 
-``lam`` 是 ``指数分布`` 的 :math:`\lambda` 参数。随机数符合以下概率密度函数：
+ ``lam``  是  ``指数分布``  的 :math:`\lambda` 参数。随机数符合以下概率密度函数：
 
 .. math::
 
     f(x) = \lambda e^{-\lambda x}
 
 .. note::
-    别名支持: 参数名 ``lambd`` 可替代 ``lam``，如 ``lambd=1.0`` 等价于 ``lam=1.0``。
+    别名支持: 参数名  ``lambd``  可替代  ``lam`` ，如  ``lambd=1.0``  等价于  ``lam=1.0`` 。
 
 参数：
     - **x** (Tensor) - 输入 Tensor，数据类型为 float32/float64。
     - **lam** (float) - 指数分布的 :math:`\lambda` 参数。
-      别名： ``lambd``
+      别名：  ``lambd`` 
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
@@ -1694,7 +1694,7 @@ gcd(x, y, name=None)
 gradient()
 :::::::::
 
-与 ``Tensor.grad`` 相同，查看一个 Tensor 的梯度，数据类型为 numpy\.ndarray。
+与  ``Tensor.grad``  相同，查看一个 Tensor 的梯度，数据类型为 numpy\.ndarray。
 
 返回：该 Tensor 的梯度
 返回类型：numpy\.ndarray
@@ -2131,7 +2131,7 @@ mean(axis=None, keepdim=False, name=None)
 median(axis=None, keepdim=False, name=None)
 :::::::::
 
-返回：沿着 ``axis`` 进行中位数计算的结果
+返回：沿着  ``axis``  进行中位数计算的结果
 
 返回类型：Tensor
 
@@ -2140,7 +2140,7 @@ median(axis=None, keepdim=False, name=None)
 nanmedian(axis=None, keepdim=False, name=None)
 :::::::::
 
-返回：沿着 ``axis`` 忽略 NAN 元素进行中位数计算的结果
+返回：沿着  ``axis``  忽略 NAN 元素进行中位数计算的结果
 
 返回类型：Tensor
 
@@ -2203,7 +2203,7 @@ mode(axis=-1, keepdim=False, name=None)
 mul_(y, name=None)
 :::::::::
 
-``multiply`` 的 inplace 版本，请参考 :ref:`cn_api_paddle_multiply`
+ ``multiply``  的 inplace 版本，请参考 :ref:`cn_api_paddle_multiply`
 
 multiplex(index)
 :::::::::
@@ -2226,7 +2226,7 @@ multiply(y, axis=-1, name=None)
 mv(vec, name=None)
 :::::::::
 
-返回：当前 Tensor 向量 ``vec`` 的乘积
+返回：当前 Tensor 向量  ``vec``  的乘积
 
 返回类型：Tensor
 
@@ -2409,7 +2409,7 @@ register_hook(hook)
 参数：
     - **hook** (function) - 一个需要注册到 Tensor.grad 上的 hook 函数
 
-返回：一个能够通过调用其 ``remove()`` 方法移除所注册 hook 的对象
+返回：一个能够通过调用其  ``remove()``  方法移除所注册 hook 的对象
 
 返回类型：TensorHookRemoveHelper
 
@@ -2561,14 +2561,14 @@ Inplace 版本的 :ref:`cn_api_paddle_scatter` API，对输入 `x` 采用 Inplac
 scatter_add(index, updates, overwrite=True, name=None)
 :::::::::
 
-``put_along_axis`` 的别名
+ ``put_along_axis``  的别名
 
 请参考 :ref:`cn_api_paddle_put_along_axis`
 
 scatter_add_(index, updates, overwrite=True, name=None)
 :::::::::
 
-``put_along_axis_`` 的别名
+ ``put_along_axis_``  的别名
 
 请参考 :ref:`cn_api_paddle_put_along_axis_`
 
@@ -2593,7 +2593,7 @@ scatter_nd_add(index, updates, name=None)
 scatter_reduce(dim, index, src, reduce, \*, include_self=True)
 :::::::::
 
-``put_along_axis`` 的别名
+ ``put_along_axis``  的别名
 
 请参考 :ref:`cn_api_paddle_put_along_axis`
 
@@ -2920,16 +2920,16 @@ COPY-FROM: paddle.Tensor.repeat
 to(*args, **kwargs)
 :::::::::
 
-转换 Tensor 的设备或/和数据类型，并且返回转换后的 Tensor。该函数将会从 ``args`` 以及 ``kwargs`` 中解析出要转换到的目标类型 dtype 以及目标设备 place。
+转换 Tensor 的设备或/和数据类型，并且返回转换后的 Tensor。该函数将会从  ``args``  以及  ``kwargs``  中解析出要转换到的目标类型 dtype 以及目标设备 place。
 目前支持一下三种方式调用该方法：
 
     1. to(dtype, blocking=True)
     2. to(device, dtype=None, blocking=True)
     3. to(other, blocking=True)
 
-其中， ``dtype`` 可以是 ``paddle.dtype``, ``numpy.dtype`` 类型或者是 ``["bfloat16", "float16", "float32", "float64", "int8", "int16", "int32",
-"int64", "uint8", "complex64", "complex128", "bool"]`` 中的任意一个 ``str``。 ``device`` 可以是 ``paddle.CPUPlace()``, ``paddle.CUDAPlace()``,
-``paddle.CUDAPinnedPlace()``, ``paddle.XPUPlace()``, ``paddle.CustomPlace()`` 或者 ``str``。 ``other`` 需要是 ``Tensor`` 类型。
+其中，  ``dtype``  可以是  ``paddle.dtype`` ,  ``numpy.dtype``  类型或者是 ``["bfloat16", "float16", "float32", "float64", "int8", "int16", "int32",
+"int64", "uint8", "complex64", "complex128", "bool"] `` 中的任意一个 `` str ``。 `` device `` 可以是 `` paddle.CPUPlace() ``, `` paddle.CUDAPlace()``,
+ ``paddle.CUDAPinnedPlace()`` ,  ``paddle.XPUPlace()`` ,  ``paddle.CustomPlace()``  或者  ``str`` 。  ``other``  需要是  ``Tensor``  类型。
 
 返回：类型转换后的新的 Tensor
 
@@ -3203,7 +3203,7 @@ take_along_dim(indices, axis, broadcast=True)
 put_along_axis(indices, value, axis, reduce="assign", include_self=True, broadcast=True)
 :::::::::
 
-基于输入 indices 矩阵，将输入 value 沿着指定 axis 放置入 tensor 矩阵。索引矩阵和 value 必须和 tensor 矩阵有相同的维度，如果 ``broadcast`` 为 ``True``，则需要能够 broadcast 与 tensor 矩阵对齐。
+基于输入 indices 矩阵，将输入 value 沿着指定 axis 放置入 tensor 矩阵。索引矩阵和 value 必须和 tensor 矩阵有相同的维度，如果  ``broadcast``  为  ``True`` ，则需要能够 broadcast 与 tensor 矩阵对齐。
 
 返回：计算后的 Tensor
 
@@ -3689,25 +3689,25 @@ Inplace 版本的 :ref:`cn_api_paddle_masked_scatter` API，对输入 `x` 采用
 
 atleast_1d(name=None)
 :::::::::
-将输入转换为张量并返回至少为 ``1`` 维的视图。 ``1`` 维或更高维的输入会被保留。
+将输入转换为张量并返回至少为  ``1``  维的视图。  ``1``  维或更高维的输入会被保留。
 
-返回至少为 ``1`` 维视图的 Tensor 。
+返回至少为  ``1``  维视图的 Tensor 。
 
 请参考 :ref:`cn_api_paddle_atleast_1d`
 
 atleast_2d(name=None)
 :::::::::
-将输入转换为张量并返回至少为 ``2`` 维的视图。 ``2`` 维或更高维的输入会被保留。
+将输入转换为张量并返回至少为  ``2``  维的视图。  ``2``  维或更高维的输入会被保留。
 
-返回至少为 ``2`` 维视图的 Tensor 。
+返回至少为  ``2``  维视图的 Tensor 。
 
 请参考 :ref:`cn_api_paddle_atleast_2d`
 
 atleast_3d(name=None)
 :::::::::
-将输入转换为张量并返回至少为 ``3`` 维的视图。 ``3`` 维或更高维的输入会被保留。
+将输入转换为张量并返回至少为  ``3``  维的视图。  ``3``  维或更高维的输入会被保留。
 
-返回至少为 ``3`` 维视图的 Tensor 。
+返回至少为  ``3``  维视图的 Tensor 。
 
 请参考 :ref:`cn_api_paddle_atleast_3d`
 diagonal_scatter(x, y, offset=0, axis1=0, axis2=1, name=None)
@@ -3723,7 +3723,7 @@ diagonal_scatter(x, y, offset=0, axis1=0, axis2=1, name=None)
 select_scatter(x, values, axis, index, name=None)
 :::::::::
 
-将 ``values`` 矩阵的值嵌入到 ``x`` 矩阵的第 ``axis`` 维的 ``index`` 列, ``values`` 的形状需要与 ``x`` 矩阵除去第 ``axis`` 维后的形状一致
+将  ``values``  矩阵的值嵌入到  ``x``  矩阵的第  ``axis``  维的  ``index``  列,  ``values``  的形状需要与  ``x``  矩阵除去第  ``axis``  维后的形状一致
 
 返回：计算后的 Tensor
 
@@ -3779,18 +3779,18 @@ ormqr(x, tau, other, left=True, transpose=False)
 set_(source=None, shape=None, stride=None, offset=0, name=None)
 :::::::::
 
-将 ``self`` 设置为 ``source`` 的数据内存，形状，步长以及偏移量。
+将  ``self``  设置为  ``source``  的数据内存，形状，步长以及偏移量。
 
-仅在动态图下可用，设置后 ``self`` 将与 ``source`` 共享内存。
+仅在动态图下可用，设置后  ``self``  将与  ``source``  共享内存。
 
 参数：
-    - **source** (Tensor，可选) - 设置的目标 Tensor，可选的数据类型为 'bfloat16'、'float16'、'float32'、'float64'、'bool'、'int8'、'int16'、'int32'、'int64'、'uint8'、'complex64'、'complex128'。默认值为 None，表示将 ``self`` 设置为一个 empty tensor。
-    - **shape** (list|tuple，可选) - 设置的目标 shape，每个元素需为整数。默认值为 None，表示用 ``source`` 的形状作为目标 shape。
-    - **stride** (list|tuple，可选) - 设置的目标 stride，每个元素需为整数。默认值为 None，当 ``shape`` 也是 None 时，使用 ``source`` 的步长作为目标 stride；当 ``shape`` 不是 None 时，使用该形状的默认步长。
+    - **source** (Tensor，可选) - 设置的目标 Tensor，可选的数据类型为 'bfloat16'、'float16'、'float32'、'float64'、'bool'、'int8'、'int16'、'int32'、'int64'、'uint8'、'complex64'、'complex128'。默认值为 None，表示将  ``self``  设置为一个 empty tensor。
+    - **shape** (list|tuple，可选) - 设置的目标 shape，每个元素需为整数。默认值为 None，表示用  ``source``  的形状作为目标 shape。
+    - **stride** (list|tuple，可选) - 设置的目标 stride，每个元素需为整数。默认值为 None，当  ``shape``  也是 None 时，使用  ``source``  的步长作为目标 stride；当  ``shape``  不是 None 时，使用该形状的默认步长。
     - **offset** (int，可选) - 设置的目标 offset，指偏移数字对应存储位置的偏移量（以 byte 为单位）。默认值为 0。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
-返回：设置后的 ``self``。
+返回：设置后的  ``self`` 。
 
 返回类型：Tensor
 
@@ -3800,14 +3800,14 @@ COPY-FROM: paddle.Tensor.set_
 resize_(shape, fill_zero=False, name=None)
 :::::::::
 
-将 ``self`` 的形状重置为 ``shape``。
+将  ``self``  的形状重置为  ``shape`` 。
 
 参数：
     - **shape** (list|tuple) - 设置的目标形状，每个元素需为整数。
-    - **fill_zero** (bool，可选) - 当目标形状的元素个数大于 ``self`` 的元素个数时，若 ``fill_zero`` 设为 True 则新元素将用 0 填充。默认值为 False，此时新元素的值不确定。
+    - **fill_zero** (bool，可选) - 当目标形状的元素个数大于  ``self``  的元素个数时，若  ``fill_zero``  设为 True 则新元素将用 0 填充。默认值为 False，此时新元素的值不确定。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
-返回：重置形状后的 ``self``。
+返回：重置形状后的  ``self`` 。
 
 返回类型：Tensor
 
@@ -3817,23 +3817,23 @@ COPY-FROM: paddle.Tensor.resize_
 new_full(size, fill_value, \*, dtype=None, device=None, requires_grad=False, pin_memory=False)
 :::::::::
 
-创建一个与 ``self`` 数据类型和设备相同的新 Tensor，并将其形状重置为 ``shape``，元素值全部填充为 ``fill_value``。
+创建一个与  ``self``  数据类型和设备相同的新 Tensor，并将其形状重置为  ``shape`` ，元素值全部填充为  ``fill_value`` 。
 
 参数：
-    - **size** (list|tuple|Tensor) - 设置的目标形状，可以是整数列表、元组，或 1-D Tensor（数据类型为 ``int32`` 或 ``int64``）。
+    - **size** (list|tuple|Tensor) - 设置的目标形状，可以是整数列表、元组，或 1-D Tensor（数据类型为  ``int32``  或  ``int64`` ）。
       若为列表或元组，其中元素需为整数或 0 维 Tensor。
     - **fill_value** (Scalar|Tensor) - 用于填充的常量值。若为 Tensor，则应为标量（0 维 Tensor）。
 
 关键字参数:
-    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，可选：``float16``、``float32``、``float64``、``int32``、``int64``、``complex64``、``complex128``。
-      若为 None，则默认与 ``self`` 的 dtype 一致。
+    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，可选： ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 、 ``int64`` 、 ``complex64`` 、 ``complex128`` 。
+      若为 None，则默认与  ``self``  的 dtype 一致。
     - **out** (Tensor，可选) - 用于保存输出结果的 Tensor，默认值为 None。
-    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。若为 None，则与 ``self`` 保持一致。
+    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。若为 None，则与  ``self``  保持一致。
     - **requires_grad** (bool，可选) - 是否需要为返回的 Tensor 记录梯度信息。默认值为 False。
     - **pin_memory** (bool，可选) - 若为 True，返回的 CPU Tensor 将分配在锁页内存中。仅对 CPU Tensor 生效。默认值为 False。
 
 返回：
-    - **Tensor**，其形状为 ``shape``，元素值为 ``fill_value``，数据类型为 ``dtype``（若未指定，则与 ``self`` 一致）。
+    - **Tensor**，其形状为  ``shape`` ，元素值为  ``fill_value`` ，数据类型为  ``dtype`` （若未指定，则与  ``self``  一致）。
 
 **代码示例**
 
@@ -3842,22 +3842,22 @@ COPY-FROM: paddle.Tensor.new_full
 new_ones(size, \*, dtype=None, device=None, requires_grad=False, pin_memory=False)
 :::::::::
 
-创建一个与 ``self`` 数据类型和设备相同的新 Tensor，并将其形状重置为 ``shape``，元素值全部填充为 ``fill_value``。
+创建一个与  ``self``  数据类型和设备相同的新 Tensor，并将其形状重置为  ``shape`` ，元素值全部填充为  ``fill_value`` 。
 
 参数：
-    - **size** (list|tuple|Tensor) - 设置的目标形状，可以是整数列表、元组，或 1-D Tensor（数据类型为 ``int32`` 或 ``int64``）。
+    - **size** (list|tuple|Tensor) - 设置的目标形状，可以是整数列表、元组，或 1-D Tensor（数据类型为  ``int32``  或  ``int64`` ）。
       若为列表或元组，其中元素需为整数或 0 维 Tensor。
 
 关键字参数:
-    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，可选：``float16``、``float32``、``float64``、``int32``、``int64``、``complex64``、``complex128``。
-      若为 None，则默认与 ``self`` 的 dtype 一致。
+    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，可选： ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 、 ``int64`` 、 ``complex64`` 、 ``complex128`` 。
+      若为 None，则默认与  ``self``  的 dtype 一致。
     - **out** (Tensor，可选) - 用于保存输出结果的 Tensor，默认值为 None。
-    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。若为 None，则与 ``self`` 保持一致。
+    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。若为 None，则与  ``self``  保持一致。
     - **requires_grad** (bool，可选) - 是否需要为返回的 Tensor 记录梯度信息。默认值为 False。
     - **pin_memory** (bool，可选) - 若为 True，返回的 CPU Tensor 将分配在锁页内存中。仅对 CPU Tensor 生效。默认值为 False。
 
 返回：
-    - **Tensor**，其形状为 ``shape``，元素值为 ``1``，数据类型为 ``dtype``（若未指定，则与 ``self`` 一致）。
+    - **Tensor**，其形状为  ``shape`` ，元素值为  ``1`` ，数据类型为  ``dtype`` （若未指定，则与  ``self``  一致）。
 
 **代码示例**
 
@@ -3866,22 +3866,22 @@ COPY-FROM: paddle.Tensor.new_ones
 new_zeros(size, \*, dtype=None, device=None, requires_grad=False, pin_memory=False)
 :::::::::
 
-创建一个与 ``self`` 数据类型和设备相同的新 Tensor，并将其形状重置为 ``shape``，元素值全部填充为 ``fill_value``。
+创建一个与  ``self``  数据类型和设备相同的新 Tensor，并将其形状重置为  ``shape`` ，元素值全部填充为  ``fill_value`` 。
 
 参数：
-    - **size** (list|tuple|Tensor) - 设置的目标形状，可以是整数列表、元组，或 1-D Tensor（数据类型为 ``int32`` 或 ``int64``）。
+    - **size** (list|tuple|Tensor) - 设置的目标形状，可以是整数列表、元组，或 1-D Tensor（数据类型为  ``int32``  或  ``int64`` ）。
       若为列表或元组，其中元素需为整数或 0 维 Tensor。
 
 关键字参数:
-    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，可选：``float16``、``float32``、``float64``、``int32``、``int64``、``complex64``、``complex128``。
-      若为 None，则默认与 ``self`` 的 dtype 一致。
+    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，可选： ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 、 ``int64`` 、 ``complex64`` 、 ``complex128`` 。
+      若为 None，则默认与  ``self``  的 dtype 一致。
     - **out** (Tensor，可选) - 用于保存输出结果的 Tensor，默认值为 None。
-    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。若为 None，则与 ``self`` 保持一致。
+    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。若为 None，则与  ``self``  保持一致。
     - **requires_grad** (bool，可选) - 是否需要为返回的 Tensor 记录梯度信息。默认值为 False。
     - **pin_memory** (bool，可选) - 若为 True，返回的 CPU Tensor 将分配在锁页内存中。仅对 CPU Tensor 生效。默认值为 False。
 
 返回：
-    - **Tensor**，其形状为 ``shape``，元素值为 ``0``，数据类型为 ``dtype``（若未指定，则与 ``self`` 一致）。
+    - **Tensor**，其形状为  ``shape`` ，元素值为  ``0`` ，数据类型为  ``dtype`` （若未指定，则与  ``self``  一致）。
 
 **代码示例**
 
@@ -3890,22 +3890,22 @@ COPY-FROM: paddle.Tensor.new_zeros
 new_empty(size, \*, dtype=None, device=None, requires_grad=False, pin_memory=False)
 :::::::::
 
-创建一个与 ``self`` 数据类型和设备相同的新 Tensor，并将其形状重置为 ``shape``，元素值全部填充为 ``fill_value``。
+创建一个与  ``self``  数据类型和设备相同的新 Tensor，并将其形状重置为  ``shape`` ，元素值全部填充为  ``fill_value`` 。
 
 参数：
-    - **size** (list|tuple|Tensor) - 设置的目标形状，可以是整数列表、元组，或 1-D Tensor（数据类型为 ``int32`` 或 ``int64``）。
+    - **size** (list|tuple|Tensor) - 设置的目标形状，可以是整数列表、元组，或 1-D Tensor（数据类型为  ``int32``  或  ``int64`` ）。
       若为列表或元组，其中元素需为整数或 0 维 Tensor。
 
 关键字参数:
-    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，可选：``float16``、``float32``、``float64``、``int32``、``int64``、``complex64``、``complex128``。
-      若为 None，则默认与 ``self`` 的 dtype 一致。
+    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，可选： ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 、 ``int64`` 、 ``complex64`` 、 ``complex128`` 。
+      若为 None，则默认与  ``self``  的 dtype 一致。
     - **out** (Tensor，可选) - 用于保存输出结果的 Tensor，默认值为 None。
-    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。若为 None，则与 ``self`` 保持一致。
+    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。若为 None，则与  ``self``  保持一致。
     - **requires_grad** (bool，可选) - 是否需要为返回的 Tensor 记录梯度信息。默认值为 False。
     - **pin_memory** (bool，可选) - 若为 True，返回的 CPU Tensor 将分配在锁页内存中。仅对 CPU Tensor 生效。默认值为 False。
 
 返回：
-    - **Tensor**，其形状为 ``shape``，元素值为 ``0``(一般情况下为 ``0``，但也有可能为随机值)，数据类型为 ``dtype``（若未指定，则与 ``self`` 一致）。
+    - **Tensor**，其形状为  ``shape`` ，元素值为  ``0`` (一般情况下为  ``0`` ，但也有可能为随机值)，数据类型为  ``dtype`` （若未指定，则与  ``self``  一致）。
 
 **代码示例**
 
diff --git a/docs/api/paddle/abs_cn.rst b/docs/api/paddle/abs_cn.rst
index 83fa2c88d48..b500451c745 100644
--- a/docs/api/paddle/abs_cn.rst
+++ b/docs/api/paddle/abs_cn.rst
@@ -20,7 +20,7 @@ abs
 
 返回
 :::::::::
-输出 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出 Tensor，与  ``x``  维度相同、数据类型相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/acos_cn.rst b/docs/api/paddle/acos_cn.rst
index 38e1ff3cdbb..566b20aeb3a 100644
--- a/docs/api/paddle/acos_cn.rst
+++ b/docs/api/paddle/acos_cn.rst
@@ -20,7 +20,7 @@ arccosine 函数。
 
 返回
 :::::::::
-输出 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出 Tensor，与  ``x``  维度相同、数据类型相同。
 
 
 代码示例
diff --git a/docs/api/paddle/acosh_cn.rst b/docs/api/paddle/acosh_cn.rst
index 2e030bc032b..221088a8ae1 100644
--- a/docs/api/paddle/acosh_cn.rst
+++ b/docs/api/paddle/acosh_cn.rst
@@ -20,7 +20,7 @@ Arccosh 函数。
 
 返回
 :::::::::
-输出 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出 Tensor，与  ``x``  维度相同、数据类型相同。
 
 
 
diff --git a/docs/api/paddle/add_cn.rst b/docs/api/paddle/add_cn.rst
index 8dccd02a9d6..9523548deef 100644
--- a/docs/api/paddle/add_cn.rst
+++ b/docs/api/paddle/add_cn.rst
@@ -7,11 +7,11 @@ add
 
 
 
-逐元素相加算子，输入 ``x`` 与输入 ``y`` 逐元素相加，并将各个位置的输出元素保存到返回结果中。
+逐元素相加算子，输入  ``x``  与输入  ``y``  逐元素相加，并将各个位置的输出元素保存到返回结果中。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``other`` 可替代 ``y`` ，如 ``add(input=tensor_x, other=tensor_y, ...)`` 等价于 ``add(x=tensor_x, y=tensor_y, ...)`` 。
-    输入 ``x`` 与输入 ``y`` 必须和广播为相同形状，关于广播规则，请参见 `Tensor 介绍`_ .
+    别名支持: 参数名  ``input``  可替代  ``x`` ，参数名  ``other``  可替代  ``y``  ，如  ``add(input=tensor_x, other=tensor_y, ...)``  等价于  ``add(x=tensor_x, y=tensor_y, ...)``  。
+    输入  ``x``  与输入  ``y``  必须和广播为相同形状，关于广播规则，请参见 `Tensor 介绍`_ .
 
         .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
@@ -25,23 +25,23 @@ add
 - :math:`Y`：多维 Tensor。
 
 以下情况使用该算子，该情况为：
-1. ``X`` 与 ``Y`` 的形状一样。
-2. ``Y`` 的形状是 ``X`` 的一部分连续的形状。
+1.  ``X``  与  ``Y``  的形状一样。
+2.  ``Y``  的形状是  ``X``  的一部分连续的形状。
 
 
 参数
 :::::::::
     - **x** (Tensor) - 输入的 Tensor，数据类型为：bool、bfloat16、float16、float32、float64、int8、int16、int32、int64、uint8、complex64、complex128。
-      ``别名: input``
+       ``别名: input`` 
     - **y** (Tensor) - 输入的 Tensor，数据类型为：bool、bfloat16、float16、float32、float64、int8、int16、int32、int64、uint8、complex64、complex128。
-      ``别名: other``
+       ``别名: other`` 
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
-    - **alpha** (Number, 可选) - 对 ``y`` 的缩放因子，默认值为 1。
+    - **alpha** (Number, 可选) - 对  ``y``  的缩放因子，默认值为 1。
     - **out** (Tensor, 可选) - 输出 Tensor，默认值为 None。
 
 返回
 :::::::::
-多维 Tensor，数据类型与 ``x`` 相同，维度为广播后的形状。
+多维 Tensor，数据类型与  ``x``  相同，维度为广播后的形状。
 
 
 代码示例
diff --git a/docs/api/paddle/add_n_cn.rst b/docs/api/paddle/add_n_cn.rst
index 54407ced7c8..329fcf25ac4 100644
--- a/docs/api/paddle/add_n_cn.rst
+++ b/docs/api/paddle/add_n_cn.rst
@@ -48,7 +48,7 @@ add_n
 
 返回
 ::::::::::::
-Tensor，输入 ``inputs`` 求和后的结果，shape 和数据类型与 ``inputs`` 一致。
+Tensor，输入  ``inputs``  求和后的结果，shape 和数据类型与  ``inputs``  一致。
 
 
 代码示例
diff --git a/docs/api/paddle/all_cn.rst b/docs/api/paddle/all_cn.rst
index 2d884316d59..67d6708b434 100644
--- a/docs/api/paddle/all_cn.rst
+++ b/docs/api/paddle/all_cn.rst
@@ -8,14 +8,14 @@ all
 对指定维度上的 Tensor 元素进行逻辑与运算，并输出相应的计算结果。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``， ``dim`` 可替代 ``axis``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，  ``dim``  可替代  ``axis`` 。
 
 参数
 :::::::::
     - **x** （Tensor）- 输入变量为多维 Tensor，数据类型为 bool、float32、float64、int32、int64。
-      别名： ``input``
+      别名：  ``input`` 
     - **axis** （int | list | tuple，可选）- 计算逻辑与运算的维度。如果为 None，则计算所有元素的逻辑与并返回包含单个元素的 Tensor 变量，否则必须在 :math:`[−rank(x),rank(x)]` 范围内。如果 :math:`axis [i] <0`，则维度将变为 :math:`rank+axis[i]`，默认值为 None。
-      别名： ``dim``
+      别名：  ``dim`` 
     - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。除非 keepdim 为 True，否则输出 Tensor 的维度将比输入 Tensor 小一维，默认值为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
     - **out** （Tensor，可选） - 指定输出结果的 `Tensor`，默认值为 None。
diff --git a/docs/api/paddle/amax_cn.rst b/docs/api/paddle/amax_cn.rst
index 238a1a0bd9b..6c165c2c746 100644
--- a/docs/api/paddle/amax_cn.rst
+++ b/docs/api/paddle/amax_cn.rst
@@ -11,14 +11,14 @@ amax
 .. note::
 
     对输入有多个最大值的情况下，max 将梯度完整传回到最大值对应的位置，amax 会将梯度平均传回到最大值对应的位置
-    别名支持: 参数名 ``input`` 可替代 ``x``， ``dim`` 可替代 ``axis``
+    别名支持: 参数名  ``input``  可替代  ``x`` ，  ``dim``  可替代  ``axis`` 
 
 参数
 :::::::::
    - **x** (Tensor) - Tensor，支持数据类型为 float32、float64、int32、int64，维度不超过 4 维。
-     ``别名：input``
+      ``别名：input`` 
    - **axis** (int|list|tuple，可选) - 求最大值运算的维度。如果为 None，则计算所有元素的最大值并返回包含单个元素的 Tensor 变量，否则必须在 :math:`[-x.ndim, x.ndim]` 范围内。如果 :math:`axis[i] <0`，则维度将变为 :math:`x.ndim+axis[i]`，默认值为 None。
-     ``别名：dim``
+      ``别名：dim`` 
    - **keepdim** (bool，可选)- 是否在输出 Tensor 中保留减小的维度。如果 keepdim 为 False，结果 Tensor 的维度将比输入 Tensor 的小，默认值为 False。
    - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
    - **out** (Tensor，可选)- 输出的结果。该参数为仅关键字参数，默认值为 None。
diff --git a/docs/api/paddle/amin_cn.rst b/docs/api/paddle/amin_cn.rst
index 5465deede08..7b4af5d1e8f 100644
--- a/docs/api/paddle/amin_cn.rst
+++ b/docs/api/paddle/amin_cn.rst
@@ -11,14 +11,14 @@ amin
 .. note::
 
     对输入有多个最小值的情况下，min 将梯度完整传回到最小值对应的位置，amin 会将梯度平均传回到最小值对应的位置
-    别名支持: 参数名 ``input`` 可替代 ``x``， ``dim`` 可替代 ``axis``
+    别名支持: 参数名  ``input``  可替代  ``x`` ，  ``dim``  可替代  ``axis`` 
 
 参数
 :::::::::
    - **x** (Tensor) - Tensor，支持数据类型为 float32、float64、int32、int64，维度不超过 4 维。
-     ``别名：input``
+      ``别名：input`` 
    - **axis** (int|list|tuple，可选) - 求最小值运算的维度。如果为 None，则计算所有元素的最小值并返回包含单个元素的 Tensor 变量，否则必须在 :math:`[−x.ndim, x.ndim]` 范围内。如果 :math:`axis[i] < 0`，则维度将变为 :math:`x.ndim+axis[i]`，默认值为 None。
-     ``别名：dim``
+      ``别名：dim`` 
    - **keepdim** (bool，可选)- 是否在输出 Tensor 中保留减小的维度。如果 keepdim 为 False，结果 Tensor 的维度将比输入 Tensor 的小，默认值为 False。
    - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
    - **out** (Tensor，可选)- 输出的结果。该参数为仅关键字参数，默认值为 None。
diff --git a/docs/api/paddle/amp/GradScaler_cn.rst b/docs/api/paddle/amp/GradScaler_cn.rst
index 73b95363def..ee4f01e82c6 100644
--- a/docs/api/paddle/amp/GradScaler_cn.rst
+++ b/docs/api/paddle/amp/GradScaler_cn.rst
@@ -7,15 +7,15 @@ GradScaler
 
 
 
-GradScaler 用于动态图模式下的"自动混合精度"的训练。它控制 loss 的缩放比例，有助于避免浮点数溢出的问题。这个类具有 ``scale()``、 ``unscale_()``、 ``step()``、 ``update()``、 ``minimize()``和参数的``get()/set()``等方法。
+GradScaler 用于动态图模式下的"自动混合精度"的训练。它控制 loss 的缩放比例，有助于避免浮点数溢出的问题。这个类具有  ``scale()`` 、  ``unscale_()`` 、  ``step()`` 、  ``update()`` 、  ``minimize()`` 和参数的 ``get()/set()`` 等方法。
 
-``scale()`` 用于让 loss 乘上一个缩放的比例。
-``unscale_()`` 用于让 loss 除去一个缩放的比例。
-``step()`` 与 ``optimizer.step()`` 类似，执行参数的更新，不更新缩放比例 loss_scaling。
-``update()`` 更新缩放比例。
-``minimize()`` 与 ``optimizer.minimize()`` 类似，执行参数的更新，同时更新缩放比例 loss_scaling，等效与``step()``+``update()``。
+ ``scale()``  用于让 loss 乘上一个缩放的比例。
+ ``unscale_()``  用于让 loss 除去一个缩放的比例。
+ ``step()``  与  ``optimizer.step()``  类似，执行参数的更新，不更新缩放比例 loss_scaling。
+ ``update()``  更新缩放比例。
+ ``minimize()``  与  ``optimizer.minimize()``  类似，执行参数的更新，同时更新缩放比例 loss_scaling，等效与 ``step()`` + ``update()`` 。
 
-通常，GradScaler 和 ``paddle.amp.auto_cast`` 一起使用，来实现动态图模式下的"自动混合精度"。
+通常，GradScaler 和  ``paddle.amp.auto_cast``  一起使用，来实现动态图模式下的"自动混合精度"。
 
 
 参数
@@ -60,15 +60,15 @@ COPY-FROM: paddle.amp.GradScaler.scale
 minimize(optimizer, *args, **kwargs)
 '''''''''
 
-这个函数与 ``optimizer.minimize()`` 类似，用于执行参数更新。
+这个函数与  ``optimizer.minimize()``  类似，用于执行参数更新。
 如果参数缩放后的梯度包含 NAN 或者 INF，则跳过参数更新。否则，首先让缩放过梯度的参数取消缩放，然后更新参数。
 最终，更新 loss scaling 的比例。
 
 **参数**
 
     - **optimizer** (Optimizer) - 用于更新参数的优化器。
-    - **args** - 参数，将会被传递给 ``optimizer.minimize()`` 。
-    - **kwargs** - 关键词参数，将会被传递给 ``optimizer.minimize()`` 。
+    - **args** - 参数，将会被传递给  ``optimizer.minimize()``  。
+    - **kwargs** - 关键词参数，将会被传递给  ``optimizer.minimize()``  。
 
 **代码示例**
 
@@ -77,9 +77,9 @@ COPY-FROM: paddle.amp.GradScaler.minimize
 step(optimizer)
 '''''''''
 
-这个函数与 ``optimizer.step()`` 类似，用于执行参数更新。
+这个函数与  ``optimizer.step()``  类似，用于执行参数更新。
 如果参数缩放后的梯度包含 NAN 或者 INF，则跳过参数更新。否则，首先让缩放过梯度的参数取消缩放，然后更新参数。
-该函数与 ``update()`` 函数一起使用，效果等同于 ``minimize()``。
+该函数与  ``update()``  函数一起使用，效果等同于  ``minimize()`` 。
 
 **参数**
 
@@ -102,8 +102,8 @@ unscale_(optimizer)
 '''''''''
 
 将参数的梯度除去缩放比例。
-如果在 ``step()`` 调用前调用 ``unscale_()``，则 ``step()`` 不会重复调用 ``unscale()``，否则 ``step()`` 将先执行 ``unscale_()`` 再做参数更新。
-``minimize()`` 用法同上。
+如果在  ``step()``  调用前调用  ``unscale_()`` ，则  ``step()``  不会重复调用  ``unscale()`` ，否则  ``step()``  将先执行  ``unscale_()``  再做参数更新。
+ ``minimize()``  用法同上。
 
 **参数**
     - **optimizer** (Optimizer) - 用于更新参数的优化器。
@@ -288,7 +288,7 @@ load_state_dict(state_dict)
 
 **参数**
 
-- **state_dict** (dict) - 用于设置或更新 GradScaler 对象的属性参数，dict 需要是``GradScaler.state_dict()``的返回值。
+- **state_dict** (dict) - 用于设置或更新 GradScaler 对象的属性参数，dict 需要是 ``GradScaler.state_dict()`` 的返回值。
 
 **代码示例**
 
diff --git a/docs/api/paddle/amp/auto_cast_cn.rst b/docs/api/paddle/amp/auto_cast_cn.rst
index 43824f3098b..dd15f720176 100644
--- a/docs/api/paddle/amp/auto_cast_cn.rst
+++ b/docs/api/paddle/amp/auto_cast_cn.rst
@@ -8,7 +8,7 @@ auto_cast
 
 创建一个上下文环境，来支持动态图模式下执行的算子的自动混合精度策略（AMP）。
 如果启用 AMP，使用 autocast 算法确定每个算子的输入数据类型（float32、float16 或 bfloat16），以获得更好的性能。
-通常，它与 ``decorate`` 和 ``GradScaler`` 一起使用，来实现动态图模式下的自动混合精度。
+通常，它与  ``decorate``  和  ``GradScaler``  一起使用，来实现动态图模式下的自动混合精度。
 
 
 参数
@@ -16,7 +16,7 @@ auto_cast
 - **enable** (bool，可选) - 是否开启自动混合精度。默认值为 True。
 - **custom_white_list** (set|list，可选) - 飞桨有默认的白名单，通常不需要设置自定义白名单。自定义白名单中的算子在计算时会被认为是数值安全的，并且对性能至关重要。如果设置了该名单，其中的算子会使用 float16/bfloat16 计算。
 - **custom_black_list** (set|list，可选) - 飞桨有默认的黑名单，可以根据模型特点设置自定义黑名单。自定义黑名单中的算子在计算时会被认为是数值危险的，它们的影响也可能会在下游算子中观察到。该名单中的算子不会转为 float16/bfloat16 计算。
-- **level** (str，可选) - 混合精度训练的优化级别，可为 ``O1`` 、``O2`` 或者 ``OD`` 模式。在 O1 级别下，在白名单中的算子将使用 float16/bfloat16 计算，在黑名单中的算子将使用 float32 计算。在 O2 级别下，模型的参数需要调用 ``decorate`` 转换为 float16/bfloat16， 如果算子的浮点型输入全是 float16/bfloat16，算子才会采用 float16/bfloat16 计算，若任意浮点型输入是 float32 类型，算子将采用 float32 计算。在 OD 级别下，飞桨默认的白名单中的算子，如卷积和矩阵乘运算使用 float16/bfloat16 计算，其他算子均使用 float32 计算。默认为 O1。
+- **level** (str，可选) - 混合精度训练的优化级别，可为  ``O1``  、 ``O2``  或者  ``OD``  模式。在 O1 级别下，在白名单中的算子将使用 float16/bfloat16 计算，在黑名单中的算子将使用 float32 计算。在 O2 级别下，模型的参数需要调用  ``decorate``  转换为 float16/bfloat16， 如果算子的浮点型输入全是 float16/bfloat16，算子才会采用 float16/bfloat16 计算，若任意浮点型输入是 float32 类型，算子将采用 float32 计算。在 OD 级别下，飞桨默认的白名单中的算子，如卷积和矩阵乘运算使用 float16/bfloat16 计算，其他算子均使用 float32 计算。默认为 O1。
 - **dtype** (str|paddle.dtype|np.dtype，可选) - 使用的数据类型，可以是 float16 或 bfloat16。默认为 float16。
 - **use_promote** (bool，可选) - 当一个算子存在 float32 类型的输入时，按照 Promote to the Widest 原则，选择 float32 数据类型进行计算。仅在 AMP-O2 训练时可配置。默认为 True。
 
diff --git a/docs/api/paddle/amp/debugging/check_numerics_cn.rst b/docs/api/paddle/amp/debugging/check_numerics_cn.rst
index 1d53383e1d0..03f5e17d92f 100644
--- a/docs/api/paddle/amp/debugging/check_numerics_cn.rst
+++ b/docs/api/paddle/amp/debugging/check_numerics_cn.rst
@@ -14,7 +14,7 @@ check_numerics
 - **tensor** (Tensor) – 需要检查的目标 Tensor 。
 - **op_type** (str) – 产生目标 Tensor 的 OP 或 API 。
 - **var_name** (str) – 目标 Tensor 的名字。
-- **debug_mode** (paddle.amp.debugging.DebugMode, 可选) - 要使用的调试类型。默认值为 ``paddle.amp.debugging.DebugMode.CHECK_NAN_INF_AND_ABORT``。
+- **debug_mode** (paddle.amp.debugging.DebugMode, 可选) - 要使用的调试类型。默认值为  ``paddle.amp.debugging.DebugMode.CHECK_NAN_INF_AND_ABORT`` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/amp/decorate_cn.rst b/docs/api/paddle/amp/decorate_cn.rst
index c50248ce10e..14c192d4887 100644
--- a/docs/api/paddle/amp/decorate_cn.rst
+++ b/docs/api/paddle/amp/decorate_cn.rst
@@ -7,21 +7,21 @@ decorate
 
 
 装饰神经网络参数，来支持动态图模式下执行的算子的自动混合精度策略（AMP）。
-在 ``O1`` 模式下，该函数不做任何处理，直接返回输入的 models 和 optimizers。在 ``O2`` 模式下，将对输入的网络参数数据类型由 float32 转为 float16 或 bfloat16，（除 BatchNorm 和 LayerNorm）。
-通过该函数可为支持 master weight 策略的优化器开启 master weight 策略，以保证训练精度。通过 ``save_dtype`` 可指定 ``paddle.save`` 和 ``paddle.jit.save`` 存储的网络参数数据类型。
+在  ``O1``  模式下，该函数不做任何处理，直接返回输入的 models 和 optimizers。在  ``O2``  模式下，将对输入的网络参数数据类型由 float32 转为 float16 或 bfloat16，（除 BatchNorm 和 LayerNorm）。
+通过该函数可为支持 master weight 策略的优化器开启 master weight 策略，以保证训练精度。通过  ``save_dtype``  可指定  ``paddle.save``  和  ``paddle.jit.save``  存储的网络参数数据类型。
 
 
 参数
 ::::::::::::
 
-    - **models** (Layer|list of Layer) - 网络模型。在 ``O2`` 模式下，输入的模型参数将由 float32 转为 float16 或 bfloat16。
+    - **models** (Layer|list of Layer) - 网络模型。在  ``O2``  模式下，输入的模型参数将由 float32 转为 float16 或 bfloat16。
     - **optimizers** (Optimizer|list of Optimizer，可选) - 优化器，默认值为 None，若传入优化器或由优化器组成的 list 列表，将依据 master_weight 对优化器的 master_weight 属性进行设置。
-    - **level** (str，可选) - 混合精度训练模式，默认 ``O1`` 模式。
+    - **level** (str，可选) - 混合精度训练模式，默认  ``O1``  模式。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 混合精度训练数据类型使用 float16 还是 bfloat16，默认为 float16 类型。
-    - **master_weight** (bool|None，可选) - 是否使用 master weight 策略。支持 master weight 策略的优化器包括 ``adam``、``adamW``、``momentum``，默认值为 None，在 ``O2`` 模式下使用 master weight 策略。
-    - **save_dtype** (str|None，可选) - 网络存储类型，可为 float16、bfloat16、float32、float64。通过 ``save_dtype`` 可指定通过 ``paddle.save`` 和 ``paddle.jit.save`` 存储的网络参数数据类型。默认为 None，采用现有网络参数类型进行存储。
-    - **master_grad** (bool, 可选) - 在 ``O2`` 模式下是否使用 float32 类型的权重梯度进行梯度裁剪、权重衰减、权重更新等计算。如果被启用，在反向传播结束后权重的梯度将会是 float32 类型。默认值：False，模型仅保存一份 float16 类型的权重梯度。
-    - **excluded_layers** (Layer|list of Layer, 可选) - 指定不需要被转换的层，在 ``O2`` 模式下，这些层的权重将始终保持 float32 类型。 `excluded_layers` 可以指定为 Layer 的实例/类型，或 Layer 的实例/类型的列表。默认为 None，整个模型的权重将转换为 float16 或 bfloat16 类型。
+    - **master_weight** (bool|None，可选) - 是否使用 master weight 策略。支持 master weight 策略的优化器包括  ``adam`` 、 ``adamW`` 、 ``momentum`` ，默认值为 None，在  ``O2``  模式下使用 master weight 策略。
+    - **save_dtype** (str|None，可选) - 网络存储类型，可为 float16、bfloat16、float32、float64。通过  ``save_dtype``  可指定通过  ``paddle.save``  和  ``paddle.jit.save``  存储的网络参数数据类型。默认为 None，采用现有网络参数类型进行存储。
+    - **master_grad** (bool, 可选) - 在  ``O2``  模式下是否使用 float32 类型的权重梯度进行梯度裁剪、权重衰减、权重更新等计算。如果被启用，在反向传播结束后权重的梯度将会是 float32 类型。默认值：False，模型仅保存一份 float16 类型的权重梯度。
+    - **excluded_layers** (Layer|list of Layer, 可选) - 指定不需要被转换的层，在  ``O2``  模式下，这些层的权重将始终保持 float32 类型。 `excluded_layers` 可以指定为 Layer 的实例/类型，或 Layer 的实例/类型的列表。默认为 None，整个模型的权重将转换为 float16 或 bfloat16 类型。
 
 
 代码示例
diff --git a/docs/api/paddle/amp/is_bfloat16_supported_cn.rst b/docs/api/paddle/amp/is_bfloat16_supported_cn.rst
index 32698748153..022a21a7a03 100644
--- a/docs/api/paddle/amp/is_bfloat16_supported_cn.rst
+++ b/docs/api/paddle/amp/is_bfloat16_supported_cn.rst
@@ -11,7 +11,7 @@ is_bfloat16_supported
 参数
 ::::::::::::
 
-    - **device** (str|None，可选) - 指定要查询的设备，它可以是 cpu、 gpu、 xpu、gpu:x、xpu:x。其中，x 是 GPU、 XPU 的编号。如果 ``device`` 为 None， 则查询当前设备（与飞桨安装版本保持一致），默认为 None。
+    - **device** (str|None，可选) - 指定要查询的设备，它可以是 cpu、 gpu、 xpu、gpu:x、xpu:x。其中，x 是 GPU、 XPU 的编号。如果  ``device``  为 None， 则查询当前设备（与飞桨安装版本保持一致），默认为 None。
 
 
 代码示例
diff --git a/docs/api/paddle/amp/is_float16_supported_cn.rst b/docs/api/paddle/amp/is_float16_supported_cn.rst
index 8b3e0ad6b4a..4719f2da24d 100644
--- a/docs/api/paddle/amp/is_float16_supported_cn.rst
+++ b/docs/api/paddle/amp/is_float16_supported_cn.rst
@@ -11,7 +11,7 @@ is_float16_supported
 参数
 ::::::::::::
 
-    - **device** (str|None，可选) - 指定要查询的设备，它可以是 cpu、 gpu、 xpu、gpu:x、xpu:x。其中，x 是 GPU、 XPU 的编号。如果 ``device`` 为 None， 则查询当前设备（与飞桨安装版本保持一致）， 默认为 None。
+    - **device** (str|None，可选) - 指定要查询的设备，它可以是 cpu、 gpu、 xpu、gpu:x、xpu:x。其中，x 是 GPU、 XPU 的编号。如果  ``device``  为 None， 则查询当前设备（与飞桨安装版本保持一致）， 默认为 None。
 
 
 代码示例
diff --git a/docs/api/paddle/angle_cn.rst b/docs/api/paddle/angle_cn.rst
index 2a586f30aec..92ab96a5007 100644
--- a/docs/api/paddle/angle_cn.rst
+++ b/docs/api/paddle/angle_cn.rst
@@ -19,7 +19,7 @@ angle
 
 返回
 :::::::::
-输出实数 Tensor，与 ``x`` 的数值精度一致。
+输出实数 Tensor，与  ``x``  的数值精度一致。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/any_cn.rst b/docs/api/paddle/any_cn.rst
index 46b63c4277e..a5e25edeea2 100644
--- a/docs/api/paddle/any_cn.rst
+++ b/docs/api/paddle/any_cn.rst
@@ -8,12 +8,12 @@ any
 对指定维度上的 Tensor 元素进行逻辑或运算，并输出相应的计算结果。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``dim`` 可替代 ``axis``，如 ``any(input=tensor_x, dim=1, ...)`` 等价于 ``any(x=tensor_x, axis=1, ...)``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，参数名  ``dim``  可替代  ``axis`` ，如  ``any(input=tensor_x, dim=1, ...)``  等价于  ``any(x=tensor_x, axis=1, ...)`` 。
 
 参数
 :::::::::
-    - **x** (Tensor) - 输入变量为多维 Tensor，数据类型为 bool、float32、float64、int32、int64。别名： ``input``。
-    - **axis** (int|list|tuple，可选) - 计算逻辑或运算的维度。如果为 None，则计算所有元素的逻辑或并返回包含单个元素的 Tensor，否则必须在 :math:`[−rank(x),rank(x)]` 范围内。如果 :math:`axis [i] <0`，则维度将变为 :math:`rank+axis[i]`，默认值为 None。别名： ``dim``。
+    - **x** (Tensor) - 输入变量为多维 Tensor，数据类型为 bool、float32、float64、int32、int64。别名：  ``input`` 。
+    - **axis** (int|list|tuple，可选) - 计算逻辑或运算的维度。如果为 None，则计算所有元素的逻辑或并返回包含单个元素的 Tensor，否则必须在 :math:`[−rank(x),rank(x)]` 范围内。如果 :math:`axis [i] <0`，则维度将变为 :math:`rank+axis[i]`，默认值为 None。别名：  ``dim`` 。
     - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留输入的维度。除非 keepdim 为 True，否则输出 Tensor 的维度将比输入 Tensor 小一维，默认值为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/arange_cn.rst b/docs/api/paddle/arange_cn.rst
index 308ef5c531b..03c16f2514e 100644
--- a/docs/api/paddle/arange_cn.rst
+++ b/docs/api/paddle/arange_cn.rst
@@ -5,29 +5,29 @@ arange
 
 .. py:function:: paddle.arange(start=0, end=None, step=1, dtype=None, *, out=None, device=None, requires_grad=False, pin_memory=False, name=None)
 
-返回以步长 ``step`` 均匀分隔给定数值区间[ ``start`` , ``end`` )的 1-D Tensor，数据类型为 ``dtype`` 。
+返回以步长  ``step``  均匀分隔给定数值区间[  ``start``  ,  ``end``  )的 1-D Tensor，数据类型为  ``dtype``  。
 
-当 ``dtype`` 表示浮点类型时，为了避免浮点计算误差，建议给 ``end`` 加上一个极小值 epsilon，使边界可以更加明确。
+当  ``dtype``  表示浮点类型时，为了避免浮点计算误差，建议给  ``end``  加上一个极小值 epsilon，使边界可以更加明确。
 
 参数
 ::::::::::
 
-  - **start** (float|int|Tensor) - 区间起点（且区间包括此值）。当 ``start`` 类型是 Tensor 时，是形状为[]且数据类型为 int32、int64、float32、float64 的 0-D Tensor。如果仅指定 ``start``，而 ``end`` 为 None，则区间为[0, ``start``)。默认值为 0。
-  - **end** (float|int|Tensor，可选) - 区间终点（且通常区间不包括此值）。当 ``end`` 类型是 Tensor 时，是形状为[]且数据类型为 int32、int64、float32、float64 的 0-D Tensor。默认值为 None。
-  - **step** (float|int|Tensor，可选) - 均匀分割的步长。当 ``step`` 类型是 Tensor 时，是形状为[]且数据类型为 int32、int64、float32、float64 的 0-D Tensor。默认值为 1。
+  - **start** (float|int|Tensor) - 区间起点（且区间包括此值）。当  ``start``  类型是 Tensor 时，是形状为[]且数据类型为 int32、int64、float32、float64 的 0-D Tensor。如果仅指定  ``start`` ，而  ``end``  为 None，则区间为[0,  ``start`` )。默认值为 0。
+  - **end** (float|int|Tensor，可选) - 区间终点（且通常区间不包括此值）。当  ``end``  类型是 Tensor 时，是形状为[]且数据类型为 int32、int64、float32、float64 的 0-D Tensor。默认值为 None。
+  - **step** (float|int|Tensor，可选) - 均匀分割的步长。当  ``step``  类型是 Tensor 时，是形状为[]且数据类型为 int32、int64、float32、float64 的 0-D Tensor。默认值为 1。
   - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，支持 int32、int64、float32、float64。当该参数值为 None 时，输出 Tensor 的数据类型为 int64。默认值为 None。
 
 关键字参数
 ::::::::::::
   - **out** (Tensor，可选) - 用于存储结果的 Tensor。若指定，将直接写入该 Tensor，默认值为 None。
-  - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。默认值为 None，表示使用当前全局设备（可通过 ``paddle.device.set_device`` 设置）。
+  - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。默认值为 None，表示使用当前全局设备（可通过  ``paddle.device.set_device``  设置）。
   - **requires_grad** (bool，可选) - 是否需要为返回的 Tensor 记录梯度信息。默认值为 False。
   - **pin_memory** (bool，可选) - 若为 True，返回的 CPU Tensor 将分配在锁页内存中。仅对 CPU Tensor 生效。默认值为 False。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-  Tensor，以步长 ``step`` 均匀分割给定数值区间[start, end)后得到的 1-D Tensor，数据类型为 ``dtype`` 。
+  Tensor，以步长  ``step``  均匀分割给定数值区间[start, end)后得到的 1-D Tensor，数据类型为  ``dtype``  。
 
 
 代码示例
diff --git a/docs/api/paddle/argmax_cn.rst b/docs/api/paddle/argmax_cn.rst
index 5f8755ddebc..08fb5499164 100644
--- a/docs/api/paddle/argmax_cn.rst
+++ b/docs/api/paddle/argmax_cn.rst
@@ -6,25 +6,25 @@ argmax
 .. py:function:: paddle.argmax(x, axis=None, keepdim=False, dtype='int64', name=None)
 
 
-沿参数 ``axis`` 计算输入 ``x`` 的最大元素的索引。
+沿参数  ``axis``  计算输入  ``x``  的最大元素的索引。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``， ``dim`` 可替代 ``axis``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，  ``dim``  可替代  ``axis`` 。
 
 
 参数
 ::::::::
-    - **x** (Tensor) - 输入的多维 ``Tensor``，支持的数据类型：float16、float32、float64、int16、int32、int64、uint8。
-      别名： ``input``
-    - **axis** (int，可选) - 指定对输入 Tensor 进行运算的轴，``axis`` 的有效范围是[-R, R），R 是输入 ``x`` 的维度个数，``axis`` 为负数时，进行计算的 ``axis`` 与 ``axis`` + R 一致。默认值为 None，将会对输入的 `x` 进行平铺展开，返回最大值的索引。
-      别名： ``dim``
+    - **x** (Tensor) - 输入的多维  ``Tensor`` ，支持的数据类型：float16、float32、float64、int16、int32、int64、uint8。
+      别名：  ``input`` 
+    - **axis** (int，可选) - 指定对输入 Tensor 进行运算的轴， ``axis``  的有效范围是[-R, R），R 是输入  ``x``  的维度个数， ``axis``  为负数时，进行计算的  ``axis``  与  ``axis``  + R 一致。默认值为 None，将会对输入的 `x` 进行平铺展开，返回最大值的索引。
+      别名：  ``dim`` 
     - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如果 keepdim 为 True，则输出 Tensor 和 x 具有相同的维度（减少的维度除外，减少的维度的大小为 1），默认值为 False。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，可选值为 int32，int64，默认值为 int64，将返回 int64 类型的结果。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::
-``Tensor``，如果设置 :attr:`dtype` 为 int32 时，返回的 Tensor 的数据类型为 int32，其它情况将返回的 Tensor 的数据类型为 int64。
+ ``Tensor`` ，如果设置 :attr:`dtype` 为 int32 时，返回的 Tensor 的数据类型为 int32，其它情况将返回的 Tensor 的数据类型为 int64。
 
 
 示例代码
diff --git a/docs/api/paddle/argmin_cn.rst b/docs/api/paddle/argmin_cn.rst
index 81b0c347802..86d54eed891 100644
--- a/docs/api/paddle/argmin_cn.rst
+++ b/docs/api/paddle/argmin_cn.rst
@@ -6,24 +6,24 @@ argmin
 .. py:function:: paddle.argmin(x, axis=None, keepdim=False, dtype='int64', name=None)
 
 
-沿参数 ``axis`` 计算输入 ``x`` 的最小元素的索引。
+沿参数  ``axis``  计算输入  ``x``  的最小元素的索引。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``， ``dim`` 可替代 ``axis``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，  ``dim``  可替代  ``axis`` 。
 
 参数
 ::::::::
-    - **x** (Tensor) - 输入的多维 ``Tensor``，支持的数据类型：float16、float32、float64、int16、int32、int64、uint8。
-      别名： ``input``
-    - **axis** (int，可选) - 指定对输入 Tensor 进行运算的轴， ``axis`` 的有效范围是[-R, R），R 是输入 ``x`` 的维度个数， ``axis`` 为负数时，进行计算的 ``axis`` 与 ``axis`` + R 一致。默认值为 None，将会对输入的 `x` 进行平铺展开，返回最小值的索引。
-      别名： ``dim``
+    - **x** (Tensor) - 输入的多维  ``Tensor`` ，支持的数据类型：float16、float32、float64、int16、int32、int64、uint8。
+      别名：  ``input`` 
+    - **axis** (int，可选) - 指定对输入 Tensor 进行运算的轴，  ``axis``  的有效范围是[-R, R），R 是输入  ``x``  的维度个数，  ``axis``  为负数时，进行计算的  ``axis``  与  ``axis``  + R 一致。默认值为 None，将会对输入的 `x` 进行平铺展开，返回最小值的索引。
+      别名：  ``dim`` 
     - **keepdim** (bool，可选) - 是否保留进行最小值索引操作的轴，默认值为 False。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，可选值为 int32、int64，默认值为'int64'，将返回 int64 类型的结果。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::
-``Tensor``，如果设置 :attr:`dtype` 为 ``int32`` 时，返回的 Tensor 的数据类型为 ``int32`` ，其它情况将返回的 Tensor 的数据类型为 ``int64`` 。
+ ``Tensor`` ，如果设置 :attr:`dtype` 为  ``int32``  时，返回的 Tensor 的数据类型为  ``int32``  ，其它情况将返回的 Tensor 的数据类型为  ``int64``  。
 
 示例代码
 ::::::::
diff --git a/docs/api/paddle/argsort_cn.rst b/docs/api/paddle/argsort_cn.rst
index 09587a7e4d7..577d848d555 100644
--- a/docs/api/paddle/argsort_cn.rst
+++ b/docs/api/paddle/argsort_cn.rst
@@ -6,23 +6,23 @@ argsort
 .. py:function:: paddle.argsort(x, axis=-1, descending=False, stable=False, name=None)
 
 
-对输入变量沿给定轴进行排序，输出排序好的数据的相应索引，其维度和输入相同。默认升序排列，如果需要降序排列设置 ``descending=True`` 。
+对输入变量沿给定轴进行排序，输出排序好的数据的相应索引，其维度和输入相同。默认升序排列，如果需要降序排列设置  ``descending=True``  。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``dim`` 可替代 ``axis``，如 ``argsort(input=tensor_x, dim=1, ...)`` 等价于 ``argsort(x=tensor_x, axis=1, ...)``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，参数名  ``dim``  可替代  ``axis`` ，如  ``argsort(input=tensor_x, dim=1, ...)``  等价于  ``argsort(x=tensor_x, axis=1, ...)`` 。
 
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 输入的多维 ``Tensor``，支持的数据类型：float16、bfloat16、float32、float64、int16、int32、int64、uint8。别名： ``input``。
-    - **axis** (int，可选) - 指定对输入 Tensor 进行运算的轴，``axis`` 的有效范围是 [-R, R)，R 是输入 ``x`` 的 Rank， ``axis`` 为负时与 ``axis`` + R 等价。默认值为 -1。别名： ``dim``。
+    - **x** (Tensor) - 输入的多维  ``Tensor`` ，支持的数据类型：float16、bfloat16、float32、float64、int16、int32、int64、uint8。别名：  ``input`` 。
+    - **axis** (int，可选) - 指定对输入 Tensor 进行运算的轴， ``axis``  的有效范围是 [-R, R)，R 是输入  ``x``  的 Rank，  ``axis``  为负时与  ``axis``  + R 等价。默认值为 -1。别名：  ``dim`` 。
     - **descending** (bool，可选) - 指定算法排序的方向。如果设置为 True，算法按照降序排序。如果设置为 False 或者不设置，按照升序排序。默认值为 False。
     - **stable** (bool，可选) - 是否使用稳定排序算法。若设置为 True，则使用稳定排序算法，即相同元素的顺序在排序结果中将会被保留。默认值为 False，此时的算法不一定是稳定排序算法。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
-Tensor，排序后索引信息（与 ``x`` 维度信息一致），数据类型为 int64。
+Tensor，排序后索引信息（与  ``x``  维度信息一致），数据类型为 int64。
 
 
 代码示例
diff --git a/docs/api/paddle/argwhere_cn.rst b/docs/api/paddle/argwhere_cn.rst
index 5488e4513f7..b070367f5f3 100644
--- a/docs/api/paddle/argwhere_cn.rst
+++ b/docs/api/paddle/argwhere_cn.rst
@@ -8,7 +8,7 @@ argwhere
 
 
 
-返回输入 ``x`` 中非零元素的坐标。如果输入 ``x`` 有 ``n`` 维，共包含 ``z`` 个非零元素，返回结果是一个 ``shape`` 等于 ``[z x n]`` 的 ``Tensor``，第 ``i`` 行代表输入中第 ``i`` 个非零元素的坐标。
+返回输入  ``x``  中非零元素的坐标。如果输入  ``x``  有  ``n``  维，共包含  ``z``  个非零元素，返回结果是一个  ``shape``  等于  ``[z x n]``  的  ``Tensor`` ，第  ``i``  行代表输入中第  ``i``  个非零元素的坐标。
 
 参数
 :::::::::
diff --git a/docs/api/paddle/as_complex_cn.rst b/docs/api/paddle/as_complex_cn.rst
index b3c7138d707..415eb5e8a8f 100644
--- a/docs/api/paddle/as_complex_cn.rst
+++ b/docs/api/paddle/as_complex_cn.rst
@@ -10,7 +10,7 @@ as_complex
 
 输入 Tensor 的数据类型是 'float32' 或者 'float64'，输出 Tensor 的数据类型相应为 'complex64' 或者 'complex128'。
 
-输入 Tensor 的形状是 ``(*, 2)`` (其中 ``*`` 表示任意形状)，亦即，输入的最后一维的大小必须是 2，这对应着复数的实部和虚部。输出 Tensor 的形状是 ``(*,)``。
+输入 Tensor 的形状是  ``(*, 2)``  (其中  ``*``  表示任意形状)，亦即，输入的最后一维的大小必须是 2，这对应着复数的实部和虚部。输出 Tensor 的形状是  ``(*,)`` 。
 
 下图展示了一个 as_complex 简单的使用情形。一个形状为[2, 3, 2]的实数 Tensor 经过 as_complex 转换，最后一个长度为 2 的维度被合并为复数，形状变为[2, 3]。
 
@@ -25,7 +25,7 @@ as_complex
 
 返回
 :::::::::
-输出 Tensor，数据类型是 'complex64' 或 'complex128'，与 ``x`` 的数值精度一致。
+输出 Tensor，数据类型是 'complex64' 或 'complex128'，与  ``x``  的数值精度一致。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/as_real_cn.rst b/docs/api/paddle/as_real_cn.rst
index ccaefc41293..947318904ea 100644
--- a/docs/api/paddle/as_real_cn.rst
+++ b/docs/api/paddle/as_real_cn.rst
@@ -10,7 +10,7 @@ as_real
 
 输入 Tensor 的数据类型是 'complex64' 或者 'complex128'，输出 Tensor 的数据类型相应为 'float32' 或者 'float64'。
 
-输入 Tensor 的形状是 ``(*,)`` (其中 ``*`` 表示任意形状)，输出 Tensor 的形状是 ``(*, 2)``，亦即，输出的形状是在输入形状后附加一个 ``2``，因为一个复数的实部和虚部分别表示为一个实数。
+输入 Tensor 的形状是  ``(*,)``  (其中  ``*``  表示任意形状)，输出 Tensor 的形状是  ``(*, 2)`` ，亦即，输出的形状是在输入形状后附加一个  ``2`` ，因为一个复数的实部和虚部分别表示为一个实数。
 
 下图展示了一个 as_real 简单的使用情形。一个形状为[2, 3]的复数 Tensor 经过 as_real 转换，拆分出一个长度为 2 的维度，形状变为[2, 3, 2]。
 
@@ -26,7 +26,7 @@ as_real
 
 返回
 :::::::::
-输出 Tensor，数据类型是 'float32' 或 'float64'，与 ``x`` 的数值精度一致。
+输出 Tensor，数据类型是 'float32' 或 'float64'，与  ``x``  的数值精度一致。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/asin_cn.rst b/docs/api/paddle/asin_cn.rst
index 6b6e572c3ce..23721689a8c 100644
--- a/docs/api/paddle/asin_cn.rst
+++ b/docs/api/paddle/asin_cn.rst
@@ -21,7 +21,7 @@ arcsine 函数。
 
 返回
 ::::::::::::
-输出 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出 Tensor，与  ``x``  维度相同、数据类型相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/asinh_cn.rst b/docs/api/paddle/asinh_cn.rst
index c37a7f43224..68c6a9e5702 100644
--- a/docs/api/paddle/asinh_cn.rst
+++ b/docs/api/paddle/asinh_cn.rst
@@ -17,7 +17,7 @@ Arcsinh 函数。
 
 返回
 :::::::::
-输出 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出 Tensor，与  ``x``  维度相同、数据类型相同。
 
 
 
diff --git a/docs/api/paddle/assign_cn.rst b/docs/api/paddle/assign_cn.rst
index 83a897e8ccd..5791d023771 100644
--- a/docs/api/paddle/assign_cn.rst
+++ b/docs/api/paddle/assign_cn.rst
@@ -18,7 +18,7 @@ assign
 
 返回
 ::::::::::::
-Tensor，形状、数据类型和值与 ``x`` 一致。
+Tensor，形状、数据类型和值与  ``x``  一致。
 
 
 代码示例
diff --git a/docs/api/paddle/atan2_cn.rst b/docs/api/paddle/atan2_cn.rst
index 55f800f35a0..95b502a6858 100644
--- a/docs/api/paddle/atan2_cn.rst
+++ b/docs/api/paddle/atan2_cn.rst
@@ -30,7 +30,7 @@ atan2
 返回
 :::::::::
 
-输出 Tensor，与 ``x`` 维度相同、数据类型相同（输入为 int 时，输出数据类型为 float64）。
+输出 Tensor，与  ``x``  维度相同、数据类型相同（输入为 int 时，输出数据类型为 float64）。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/atan_cn.rst b/docs/api/paddle/atan_cn.rst
index 153b4401b49..4748e3ec10d 100644
--- a/docs/api/paddle/atan_cn.rst
+++ b/docs/api/paddle/atan_cn.rst
@@ -21,7 +21,7 @@ arctangent 函数。
 
 返回
 ::::::::::::
-输出 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出 Tensor，与  ``x``  维度相同、数据类型相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/atanh_cn.rst b/docs/api/paddle/atanh_cn.rst
index 0e652e5cf2c..c95ca06a05b 100644
--- a/docs/api/paddle/atanh_cn.rst
+++ b/docs/api/paddle/atanh_cn.rst
@@ -17,7 +17,7 @@ Arctanh 函数。
 
 返回
 :::::::::
-输出 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出 Tensor，与  ``x``  维度相同、数据类型相同。
 
 
 
diff --git a/docs/api/paddle/atleast_1d_cn.rst b/docs/api/paddle/atleast_1d_cn.rst
index 74de52a0f7d..27a89c9f13e 100644
--- a/docs/api/paddle/atleast_1d_cn.rst
+++ b/docs/api/paddle/atleast_1d_cn.rst
@@ -5,12 +5,12 @@ atleast_1d
 
 .. py:function:: paddle.atleast_1d(*inputs, name=None)
 
-将输入转换为张量并返回至少为 ``1`` 维的视图。标量输入会被转换， ``1`` 维或更高维的输入则会被保留。
+将输入转换为张量并返回至少为  ``1``  维的视图。标量输入会被转换，  ``1``  维或更高维的输入则会被保留。
 
 参数
 ::::::::::::
 
-    - **inputs** (Tensor|list(Tensor)) - 一个或多个 Tensor，数据类型为： ``float16``, ``float32``, ``float64``, ``int16``, ``int32``, ``int64``, ``int8``, ``uint8``, ``complex64``, ``complex128``, ``bfloat16`` 或 ``bool``。
+    - **inputs** (Tensor|list(Tensor)) - 一个或多个 Tensor，数据类型为：  ``float16`` ,  ``float32`` ,  ``float64`` ,  ``int16`` ,  ``int32`` ,  ``int64`` ,  ``int8`` ,  ``uint8`` ,  ``complex64`` ,  ``complex128`` ,  ``bfloat16``  或  ``bool`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/atleast_2d_cn.rst b/docs/api/paddle/atleast_2d_cn.rst
index 129cdc7e677..c6b839151ca 100644
--- a/docs/api/paddle/atleast_2d_cn.rst
+++ b/docs/api/paddle/atleast_2d_cn.rst
@@ -5,7 +5,7 @@ atleast_2d
 
 .. py:function:: paddle.atleast_2d(*inputs, name=None)
 
-将输入转换为张量并返回至少为 ``2`` 维的视图。 ``2`` 维或更高维的输入会被保留。
+将输入转换为张量并返回至少为  ``2``  维的视图。  ``2``  维或更高维的输入会被保留。
 
 下图分别展示了 `atleast_2d` 在不同数据类型下，对 1 个 `0` 维张量输入、1 个 `0` 维张量输入和 1 个 `1` 维张量输入，以及 1 个 `0` 维张量输入和 1 个 `3` 维张量输入，将其返回为至少为 `2` 维视图的张量或张量 list 的情形。
 
@@ -16,7 +16,7 @@ atleast_2d
 参数
 ::::::::::::
 
-    - **inputs** (Tensor|list(Tensor)) - 一个或多个 Tensor，数据类型为： ``float16``, ``float32``, ``float64``, ``int16``, ``int32``, ``int64``, ``int8``, ``uint8``, ``complex64``, ``complex128``, ``bfloat16`` 或 ``bool``。
+    - **inputs** (Tensor|list(Tensor)) - 一个或多个 Tensor，数据类型为：  ``float16`` ,  ``float32`` ,  ``float64`` ,  ``int16`` ,  ``int32`` ,  ``int64`` ,  ``int8`` ,  ``uint8`` ,  ``complex64`` ,  ``complex128`` ,  ``bfloat16``  或  ``bool`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/atleast_3d_cn.rst b/docs/api/paddle/atleast_3d_cn.rst
index db6fd8116fd..6e5e0900c57 100644
--- a/docs/api/paddle/atleast_3d_cn.rst
+++ b/docs/api/paddle/atleast_3d_cn.rst
@@ -5,12 +5,12 @@ atleast_3d
 
 .. py:function:: paddle.atleast_3d(*inputs, name=None)
 
-将输入转换为张量并返回至少为 ``3`` 维的视图。 ``3`` 维或更高维的输入会被保留。
+将输入转换为张量并返回至少为  ``3``  维的视图。  ``3``  维或更高维的输入会被保留。
 
 参数
 ::::::::::::
 
-    - **inputs** (Tensor|list(Tensor)) - 一个或多个 Tensor，数据类型为： ``float16``, ``float32``, ``float64``, ``int16``, ``int32``, ``int64``, ``int8``, ``uint8``, ``complex64``, ``complex128``, ``bfloat16`` 或 ``bool``。
+    - **inputs** (Tensor|list(Tensor)) - 一个或多个 Tensor，数据类型为：  ``float16`` ,  ``float32`` ,  ``float64`` ,  ``int16`` ,  ``int32`` ,  ``int64`` ,  ``int8`` ,  ``uint8`` ,  ``complex64`` ,  ``complex128`` ,  ``bfloat16``  或  ``bool`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/audio/backends/get_current_backend_cn.rst b/docs/api/paddle/audio/backends/get_current_backend_cn.rst
index 9dfc3cd5246..29cfe18e648 100644
--- a/docs/api/paddle/audio/backends/get_current_backend_cn.rst
+++ b/docs/api/paddle/audio/backends/get_current_backend_cn.rst
@@ -13,7 +13,7 @@ get_current_backend
 返回
 :::::::::
 
-``str``，语音 I/O 的后端名称。
+ ``str`` ，语音 I/O 的后端名称。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/audio/backends/list_available_backends_cn.rst b/docs/api/paddle/audio/backends/list_available_backends_cn.rst
index e3d9ec3c9a9..c42f8053d1b 100644
--- a/docs/api/paddle/audio/backends/list_available_backends_cn.rst
+++ b/docs/api/paddle/audio/backends/list_available_backends_cn.rst
@@ -13,7 +13,7 @@ list_available_backends
 返回
 :::::::::
 
-``List[str]``，可用的音频 I/O 后端集合。
+ ``List[str]`` ，可用的音频 I/O 后端集合。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/audio/backends/set_backend_cn.rst b/docs/api/paddle/audio/backends/set_backend_cn.rst
index 62c9e635d4f..9d44b8ad348 100644
--- a/docs/api/paddle/audio/backends/set_backend_cn.rst
+++ b/docs/api/paddle/audio/backends/set_backend_cn.rst
@@ -10,7 +10,7 @@ set_backend
 参数
 ::::::::::::
 
-    - **backend_name** (str) - 语音 I/O 后端名称，现支持 ``'wave_backend'`` ，如果安装了 paddleaudio >=1.0.2，则也支持 ``'soundfile'`` 。
+    - **backend_name** (str) - 语音 I/O 后端名称，现支持  ``'wave_backend'``  ，如果安装了 paddleaudio >=1.0.2，则也支持  ``'soundfile'``  。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/audio/datasets/ESC50_cn.rst b/docs/api/paddle/audio/datasets/ESC50_cn.rst
index 53349ec146a..b0248dba7d2 100644
--- a/docs/api/paddle/audio/datasets/ESC50_cn.rst
+++ b/docs/api/paddle/audio/datasets/ESC50_cn.rst
@@ -11,7 +11,7 @@ ESC50
 参数
 :::::::::
 
-  - **mode** (str，可选) - ``'train'`` 或 ``'dev'`` 模式两者之一，默认值为 ``'train'``。
+  - **mode** (str，可选) -  ``'train'``  或  ``'dev'``  模式两者之一，默认值为  ``'train'`` 。
   - **split** (int，可选) - 默认是 1，指定 dev 的文件夹。
   - **feat_type** (str，可选) - 默认是 raw，raw 是原始语音，支持 mfcc，spectrogram，melspectrogram，logmelspectrogram。指定从音频提取的语音特征。
   - **archive** (dict，可选) - 默认是 None，类中已经设置默认 archive，指定数据集的下载链接和 md5 值。
diff --git a/docs/api/paddle/audio/datasets/TESS_cn.rst b/docs/api/paddle/audio/datasets/TESS_cn.rst
index 80052cca646..ec34059b414 100644
--- a/docs/api/paddle/audio/datasets/TESS_cn.rst
+++ b/docs/api/paddle/audio/datasets/TESS_cn.rst
@@ -11,7 +11,7 @@ TESS
 参数
 :::::::::
 
-  - **mode** (str，可选) - ``'train'`` 或 ``'dev'`` 模式两者之一，默认值为 ``'train'``。
+  - **mode** (str，可选) -  ``'train'``  或  ``'dev'``  模式两者之一，默认值为  ``'train'`` 。
   - **n_folds** (int，可选) - 默认是 5，指定把数据集分为的文件夹数目， 1 个文件夹是 dev，其他是 train。
   - **split** (int，可选) - 默认是 1，指定 dev 的文件夹。
   - **feat_type** (str，可选) - 默认是 raw，raw 是原始语音，支持 mfcc，spectrogram，melspectrogram，logmelspectrogram。指定从音频提取的语音特征。
diff --git a/docs/api/paddle/audio/features/LogMelSpectrogram_cn.rst b/docs/api/paddle/audio/features/LogMelSpectrogram_cn.rst
index 35eb65f58ab..8b484db13de 100644
--- a/docs/api/paddle/audio/features/LogMelSpectrogram_cn.rst
+++ b/docs/api/paddle/audio/features/LogMelSpectrogram_cn.rst
@@ -14,7 +14,7 @@ LogMelSpectrogram
     - **n_fft** (int，可选) - 离散傅里叶变换中频率窗大小，默认 512。
     - **hop_length**  (int，可选) - 帧移，默认 512。
     - **win_length**  (int，可选) - 短时 FFT 的窗长，默认为 None。
-    - **window**  (str，可选) - 窗函数名，支持的窗函数类型'hamming'，'hann'，'gaussian'，'general_gaussian'，'exponential'，'triang'，'bohman'，'blackman'，'cosine'，'tukey'，'taylor'，'bartlett'，'kaiser'，'nuttall'，默认``hann``。
+    - **window**  (str，可选) - 窗函数名，支持的窗函数类型'hamming'，'hann'，'gaussian'，'general_gaussian'，'exponential'，'triang'，'bohman'，'blackman'，'cosine'，'tukey'，'taylor'，'bartlett'，'kaiser'，'nuttall'，默认 ``hann`` 。
     - **power**  (float，可选) - 幅度谱的指数，默认是 2.0。
     - **center**  (bool，可选) - 对输入信号填充，如果 True，那么 t 以 t*hop_length 为中心，如果为 False，则 t 以 t*hop_length 开始，默认是 True。
     - **pad_mode**  (str，可选) - 如果 center 是 True，选择填充的方式，默认值是'reflect'。
@@ -22,17 +22,17 @@ LogMelSpectrogram
     - **f_min** (float，可选) - 最小频率(hz)，默认 50.0。
     - **f_max** (float，可选) - 最大频率(hz)，默认为 None。
     - **htk** (bool，可选) - 在计算 fbank 矩阵时是否用在 HTK 公式缩放，默认是 False。
-    - **norm** (Union[str，float]，可选) - 计算 fbank 矩阵时正则化的种类，默认是``slaney``，你也可以 norm=0.5，使用 p-norm 正则化。
+    - **norm** (Union[str，float]，可选) - 计算 fbank 矩阵时正则化的种类，默认是 ``slaney`` ，你也可以 norm=0.5，使用 p-norm 正则化。
     - **ref_value** (float，可选) - 参照值，如果小于 1.0，信号的 db 会被提升，相反 db 会下降，默认值为 1.0。
     - **amin** (float，可选) - 输入的幅值的最小值，默认是 1e-10。
     - **top_db** (float，可选) - log-mel 谱的最大值(db)，默认是 None。
-    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输入和窗的数据类型，默认是``float32``。
+    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输入和窗的数据类型，默认是 ``float32`` 。
 
 
 返回
 :::::::::
 
-计算 ``LogMelSpectrogram`` 的可调用对象。
+计算  ``LogMelSpectrogram``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/audio/features/MFCC_cn.rst b/docs/api/paddle/audio/features/MFCC_cn.rst
index ea5d0f2430e..b933a772a82 100644
--- a/docs/api/paddle/audio/features/MFCC_cn.rst
+++ b/docs/api/paddle/audio/features/MFCC_cn.rst
@@ -32,7 +32,7 @@ MFCC
 返回
 :::::::::
 
-计算 ``MFCC`` 的可调用对象。
+计算  ``MFCC``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/audio/features/MelSpectrogram_cn.rst b/docs/api/paddle/audio/features/MelSpectrogram_cn.rst
index fe089298b5a..c49ad60cca5 100644
--- a/docs/api/paddle/audio/features/MelSpectrogram_cn.rst
+++ b/docs/api/paddle/audio/features/MelSpectrogram_cn.rst
@@ -29,7 +29,7 @@ MelSpectrogram
 返回
 :::::::::
 
-计算 ``MelSpectrogram`` 的可调用对象。
+计算  ``MelSpectrogram``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/audio/features/Spectrogram_cn.rst b/docs/api/paddle/audio/features/Spectrogram_cn.rst
index bb24a471d3b..9d060a7d84e 100644
--- a/docs/api/paddle/audio/features/Spectrogram_cn.rst
+++ b/docs/api/paddle/audio/features/Spectrogram_cn.rst
@@ -23,7 +23,7 @@ Spectrogram
 返回
 :::::::::
 
-计算 ``Spectrogram`` 的可调用对象.
+计算  ``Spectrogram``  的可调用对象.
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/audio/functional/compute_fbank_matrix_cn.rst b/docs/api/paddle/audio/functional/compute_fbank_matrix_cn.rst
index 36d4d6ab243..424edb1b1ff 100644
--- a/docs/api/paddle/audio/functional/compute_fbank_matrix_cn.rst
+++ b/docs/api/paddle/audio/functional/compute_fbank_matrix_cn.rst
@@ -16,13 +16,13 @@ compute_fbank_matrix
     - **f_min** (float，可选) - 最小频率(hz)，默认是 0.0。
     - **f_max** (Optional[float]，可选) - 最大频率(hz)，默认是 None。
     - **htk** (bool，可选) - 是否使用 htk 缩放，默认是 False。
-    - **norm** (Union[str, float]，可选) - norm 的类型，默认是``slaney``。
-    - **dtype** (str|paddle.dtype|np.dtype，可选) - 返回矩阵的数据类型，默认``float32``。
+    - **norm** (Union[str, float]，可选) - norm 的类型，默认是 ``slaney`` 。
+    - **dtype** (str|paddle.dtype|np.dtype，可选) - 返回矩阵的数据类型，默认 ``float32`` 。
 
 返回
 :::::::::
 
-``paddle.Tensor``，Tensor shape (n_mels, n_fft//2 + 1)。
+ ``paddle.Tensor`` ，Tensor shape (n_mels, n_fft//2 + 1)。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/audio/functional/create_dct_cn.rst b/docs/api/paddle/audio/functional/create_dct_cn.rst
index 62b6c82d3b5..4bc5c266989 100644
--- a/docs/api/paddle/audio/functional/create_dct_cn.rst
+++ b/docs/api/paddle/audio/functional/create_dct_cn.rst
@@ -18,7 +18,7 @@ create_dct
 返回
 :::::::::
 
-``paddle.Tensor``，Tensor 形状 (n_mels, n_mfcc)。
+ ``paddle.Tensor`` ，Tensor 形状 (n_mels, n_mfcc)。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/audio/functional/fft_frequencies_cn.rst b/docs/api/paddle/audio/functional/fft_frequencies_cn.rst
index 51a6f5e06b0..4bbf5b97724 100644
--- a/docs/api/paddle/audio/functional/fft_frequencies_cn.rst
+++ b/docs/api/paddle/audio/functional/fft_frequencies_cn.rst
@@ -17,7 +17,7 @@ fft_frequencies
 返回
 :::::::::
 
-``paddle.Tensor``，Tensor 形状 (n_fft//2 + 1,)。
+ ``paddle.Tensor`` ，Tensor 形状 (n_fft//2 + 1,)。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/audio/functional/get_window_cn.rst b/docs/api/paddle/audio/functional/get_window_cn.rst
index 0c4c69d6de6..5f0e71c4d60 100644
--- a/docs/api/paddle/audio/functional/get_window_cn.rst
+++ b/docs/api/paddle/audio/functional/get_window_cn.rst
@@ -18,7 +18,7 @@ get_window
 返回
 :::::::::
 
-``paddle.Tensor``，对应窗表征的 Tensor 。
+ ``paddle.Tensor`` ，对应窗表征的 Tensor 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/audio/functional/hz_to_mel_cn.rst b/docs/api/paddle/audio/functional/hz_to_mel_cn.rst
index 4f27f432f6b..76a4bfba875 100644
--- a/docs/api/paddle/audio/functional/hz_to_mel_cn.rst
+++ b/docs/api/paddle/audio/functional/hz_to_mel_cn.rst
@@ -16,7 +16,7 @@ hz_to_mel
 返回
 :::::::::
 
-``paddle.Tensor 或 float``，mels 值。
+ ``paddle.Tensor 或 float`` ，mels 值。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/audio/functional/mel_frequencies_cn.rst b/docs/api/paddle/audio/functional/mel_frequencies_cn.rst
index e3017e4d41e..a7599df68dd 100644
--- a/docs/api/paddle/audio/functional/mel_frequencies_cn.rst
+++ b/docs/api/paddle/audio/functional/mel_frequencies_cn.rst
@@ -19,7 +19,7 @@ mel_frequencies
 返回
 :::::::::
 
-``paddle.Tensor``，Tensor 形状 (n_mels,)。
+ ``paddle.Tensor`` ，Tensor 形状 (n_mels,)。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/audio/functional/mel_to_hz_cn.rst b/docs/api/paddle/audio/functional/mel_to_hz_cn.rst
index 33ee394f73e..48f1c3d54e3 100644
--- a/docs/api/paddle/audio/functional/mel_to_hz_cn.rst
+++ b/docs/api/paddle/audio/functional/mel_to_hz_cn.rst
@@ -16,7 +16,7 @@ mel_to_hz
 返回
 :::::::::
 
-``paddle.Tensor 或 float``，hz 为单位的频率。
+ ``paddle.Tensor 或 float`` ，hz 为单位的频率。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/audio/functional/power_to_db_cn.rst b/docs/api/paddle/audio/functional/power_to_db_cn.rst
index 758ff7970d0..e836e3a34bb 100644
--- a/docs/api/paddle/audio/functional/power_to_db_cn.rst
+++ b/docs/api/paddle/audio/functional/power_to_db_cn.rst
@@ -18,7 +18,7 @@ power_to_db
 返回
 :::::::::
 
-``paddle.Tensor 或 float``，db 单位的能量谱。
+ ``paddle.Tensor 或 float`` ，db 单位的能量谱。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/audio/info_cn.rst b/docs/api/paddle/audio/info_cn.rst
index 538afae197e..d81c0c7a74e 100644
--- a/docs/api/paddle/audio/info_cn.rst
+++ b/docs/api/paddle/audio/info_cn.rst
@@ -14,7 +14,7 @@ info
 返回
 :::::::::
 
-``AudioInfo``, 音频相关信息。
+ ``AudioInfo`` , 音频相关信息。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/audio/load_cn.rst b/docs/api/paddle/audio/load_cn.rst
index ceeecdab422..b9ed4d68a44 100644
--- a/docs/api/paddle/audio/load_cn.rst
+++ b/docs/api/paddle/audio/load_cn.rst
@@ -18,7 +18,7 @@ load
 返回
 :::::::::
 
-``Tuple[paddle.Tensor, int]``，音频数据值，采样率。
+ ``Tuple[paddle.Tensor, int]`` ，音频数据值，采样率。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/autograd/Function_cn.rst b/docs/api/paddle/autograd/Function_cn.rst
index a5f882e8904..b05398ec311 100644
--- a/docs/api/paddle/autograd/Function_cn.rst
+++ b/docs/api/paddle/autograd/Function_cn.rst
@@ -5,4 +5,4 @@ Function
 
 .. py:class:: paddle.autograd.Function
 
-``paddle.autograd.PyLayer`` 的别名，请参考 :ref:`cn_api_paddle_autograd_PyLayer`。
+ ``paddle.autograd.PyLayer``  的别名，请参考 :ref:`cn_api_paddle_autograd_PyLayer`。
diff --git a/docs/api/paddle/autograd/Overview_cn.rst b/docs/api/paddle/autograd/Overview_cn.rst
index c166cf2c597..c6918f31355 100644
--- a/docs/api/paddle/autograd/Overview_cn.rst
+++ b/docs/api/paddle/autograd/Overview_cn.rst
@@ -18,8 +18,8 @@ paddle.autograd 目录下包含飞桨框架支持的自动微分相关的 API 
     :widths: 10, 30
 
     " :ref:`backward <cn_api_paddle_autograd_backward>` ", "计算给定的 Tensors 的反向梯度"
-    " :ref:`hessian <cn_api_paddle_autograd_hessian>` ", "计算因变量 ``ys`` 对 自变量 ``xs`` 的海森矩阵"
-    " :ref:`jacobian <cn_api_paddle_autograd_jacobian>` ", "计算因变量 ``ys`` 对 自变量 ``xs`` 的雅可比矩阵"
+    " :ref:`hessian <cn_api_paddle_autograd_hessian>` ", "计算因变量  ``ys``  对 自变量  ``xs``  的海森矩阵"
+    " :ref:`jacobian <cn_api_paddle_autograd_jacobian>` ", "计算因变量  ``ys``  对 自变量  ``xs``  的雅可比矩阵"
     " :ref:`saved_tensors_hooks <cn_api_paddle_autograd_saved_tensors_hooks>` ", "用于动态图中为保存的 Tensor 注册一对 pack / unpack hook"
 
 
@@ -32,6 +32,6 @@ paddle.autograd 目录下包含飞桨框架支持的自动微分相关的 API 
     :header: "类名称", "辅助类功能"
     :widths: 10, 30
 
-    " :ref:`PyLayer <cn_api_paddle_autograd_PyLayer>` ", "通过创建 ``PyLayer`` 子类的方式实现 Python 端自定义算子"
-    " :ref:`Function <cn_api_paddle_autograd_Function>` ", "``PyLayer`` 的别名"
-    " :ref:`PyLayerContext <cn_api_paddle_autograd_PyLayerContext>` ", "``PyLayerContext`` 对象能够辅助 :ref:`cn_api_paddle_autograd_PyLayer` 实现某些功能"
+    " :ref:`PyLayer <cn_api_paddle_autograd_PyLayer>` ", "通过创建  ``PyLayer``  子类的方式实现 Python 端自定义算子"
+    " :ref:`Function <cn_api_paddle_autograd_Function>` ", " ``PyLayer``  的别名"
+    " :ref:`PyLayerContext <cn_api_paddle_autograd_PyLayerContext>` ", " ``PyLayerContext``  对象能够辅助 :ref:`cn_api_paddle_autograd_PyLayer` 实现某些功能"
diff --git a/docs/api/paddle/autograd/PyLayerContext_cn.rst b/docs/api/paddle/autograd/PyLayerContext_cn.rst
index 80682eb9870..d75d06f84d6 100644
--- a/docs/api/paddle/autograd/PyLayerContext_cn.rst
+++ b/docs/api/paddle/autograd/PyLayerContext_cn.rst
@@ -5,7 +5,7 @@ PyLayerContext
 
 .. py:class:: paddle.autograd.PyLayerContext
 
-``PyLayerContext`` 对象能够辅助 :ref:`cn_api_paddle_autograd_PyLayer` 实现某些功能。
+ ``PyLayerContext``  对象能够辅助 :ref:`cn_api_paddle_autograd_PyLayer` 实现某些功能。
 
 
 代码示例
@@ -19,14 +19,14 @@ COPY-FROM: paddle.autograd.PyLayerContext
 save_for_backward(*tensors)
 '''''''''
 
-用于暂存 ``backward`` 需要的  ``Tensor``，在 ``backward`` 中调用 ``saved_tensor`` 获取这些 ``Tensor`` 。
+用于暂存  ``backward``  需要的   ``Tensor`` ，在  ``backward``  中调用  ``saved_tensor``  获取这些  ``Tensor``  。
 
 .. note::
-  这个 API 只能被调用一次，且只能在 ``forward`` 中调用。
+  这个 API 只能被调用一次，且只能在  ``forward``  中调用。
 
 **参数**
 
- - **tensors** (list of Tensor) - 需要被暂存的 ``Tensor``
+ - **tensors** (list of Tensor) - 需要被暂存的  ``Tensor`` 
 
 
 **返回**
@@ -41,12 +41,12 @@ COPY-FROM: paddle.autograd.PyLayerContext.save_for_backward
 saved_tensor()
 '''''''''
 
-获取被 ``save_for_backward`` 暂存的 ``Tensor`` 。
+获取被  ``save_for_backward``  暂存的  ``Tensor``  。
 
 
 **返回**
 
-如果调用 ``save_for_backward`` 暂存了一些 ``Tensor``，则返回这些 ``Tensor``，否则，返回 None。
+如果调用  ``save_for_backward``  暂存了一些  ``Tensor`` ，则返回这些  ``Tensor`` ，否则，返回 None。
 
 **代码示例**
 
@@ -57,15 +57,15 @@ mark_not_inplace(self, *tensors)
 '''''''''
 
 标记一些输入是不需要 inplace 的。
-如果 ``forward`` 的输入输出是同一个 ``Tensor`` ，并且这个 ``Tensor`` 被标记为 not_inplace 的。Paddle 会替用户创建一个新的 Tensor 作为输出。
-这样可以防止输入的 ``Tensor`` 的 auto grad 信息被错误的篡改。
+如果  ``forward``  的输入输出是同一个  ``Tensor``  ，并且这个  ``Tensor``  被标记为 not_inplace 的。Paddle 会替用户创建一个新的 Tensor 作为输出。
+这样可以防止输入的  ``Tensor``  的 auto grad 信息被错误的篡改。
 
 .. note::
-  这个函数最多只能在 ``forward`` 调用一次,并且所有的参数必须是 ``forward`` 输入的 ``Tensor`` 。
+  这个函数最多只能在  ``forward``  调用一次,并且所有的参数必须是  ``forward``  输入的  ``Tensor``  。
 
 **参数**
 
- - **tensors** (list of Tensor) - 需要标记 not inplace 的 ``Tensor``
+ - **tensors** (list of Tensor) - 需要标记 not inplace 的  ``Tensor`` 
 
 **返回**
 
@@ -79,16 +79,16 @@ mark_non_differentiable(self, *tensors)
 '''''''''
 
 标记一些输出是不需要反向的。
-如果 ``forward`` 的输入输出是同一个 ``Tensor`` ，并且这个 ``Tensor`` 被标记为 not_inplace 的。Paddle 会替用户创建一个新的 Tensor 作为输出。
-将不需要反向的 ``Tensor`` 标记为 non-differentiable，可以提升反向的性能。但是你在 ``backward`` 函数的输入参数中，仍要为其留有反向梯度的位置。
-只是这个反向梯度是 1 个全为 0 的、shape 和 ``forward`` 的输出一样的 ``Tensor`` .
+如果  ``forward``  的输入输出是同一个  ``Tensor``  ，并且这个  ``Tensor``  被标记为 not_inplace 的。Paddle 会替用户创建一个新的 Tensor 作为输出。
+将不需要反向的  ``Tensor``  标记为 non-differentiable，可以提升反向的性能。但是你在  ``backward``  函数的输入参数中，仍要为其留有反向梯度的位置。
+只是这个反向梯度是 1 个全为 0 的、shape 和  ``forward``  的输出一样的  ``Tensor``  .
 
 .. note::
-  这个函数最多只能在 ``forward`` 调用一次,并且所有的参数必须是 ``forward`` 输出的 ``Tensor`` 。
+  这个函数最多只能在  ``forward``  调用一次,并且所有的参数必须是  ``forward``  输出的  ``Tensor``  。
 
 **参数**
 
- - **tensors** (list of Tensor) - 需要标记不需要反向的 ``Tensor``
+ - **tensors** (list of Tensor) - 需要标记不需要反向的  ``Tensor`` 
 
 
 **返回**
@@ -103,11 +103,11 @@ set_materialize_grads(self, value)
 '''''''''
 
 设置是否要框架来初始化未初始化的反向梯度。默认是 True。
-如果设置为 True，框架会将未初始化的反向梯度数据初始化为 0，然后再调用 ``backward`` 函数。
-如果设置为 False，框架会将未初始化的反向梯度以 None 向 ``backward`` 函数传递。
+如果设置为 True，框架会将未初始化的反向梯度数据初始化为 0，然后再调用  ``backward``  函数。
+如果设置为 False，框架会将未初始化的反向梯度以 None 向  ``backward``  函数传递。
 
 .. note::
-  这个函数最多只能在 ``forward`` 中调用。
+  这个函数最多只能在  ``forward``  中调用。
 
 **参数**
 
diff --git a/docs/api/paddle/autograd/PyLayer_cn.rst b/docs/api/paddle/autograd/PyLayer_cn.rst
index 35befd769f7..8fc3c199e75 100644
--- a/docs/api/paddle/autograd/PyLayer_cn.rst
+++ b/docs/api/paddle/autograd/PyLayer_cn.rst
@@ -5,15 +5,15 @@ PyLayer
 
 .. py:class:: paddle.autograd.PyLayer
 
-Paddle 通过创建 ``PyLayer`` 子类的方式实现 Python 端自定义算子，这个子类必须遵守以下规则：
+Paddle 通过创建  ``PyLayer``  子类的方式实现 Python 端自定义算子，这个子类必须遵守以下规则：
 
-1. 子类必须包含静态的 ``forward`` 和 ``backward`` 函数，它们的第一个参数必须是 :ref:`cn_api_paddle_autograd_PyLayerContext`，如果 ``backward`` 的某个返回值在 ``forward`` 中对应的 ``Tensor`` 是需要梯度，这个返回值必须为 ``Tensor`` 。
+1. 子类必须包含静态的  ``forward``  和  ``backward``  函数，它们的第一个参数必须是 :ref:`cn_api_paddle_autograd_PyLayerContext`，如果  ``backward``  的某个返回值在  ``forward``  中对应的  ``Tensor``  是需要梯度，这个返回值必须为  ``Tensor``  。
 
-2. ``backward`` 除了第一个参数以外，其他参数都是 ``forward`` 函数的输出 ``Tensor`` 的梯度，因此，``backward`` 输入的 ``Tensor`` 的数量必须等于 ``forward`` 输出 ``Tensor`` 的数量。如果你需在 ``backward`` 中使用 ``forward`` 的输入 ``Tensor``，你可以将这些 ``Tensor`` 输入到 :ref:`cn_api_paddle_autograd_PyLayerContext` 的 ``save_for_backward`` 方法，之后在 ``backward`` 中使用这些 ``Tensor`` 。
+2.  ``backward``  除了第一个参数以外，其他参数都是  ``forward``  函数的输出  ``Tensor``  的梯度，因此， ``backward``  输入的  ``Tensor``  的数量必须等于  ``forward``  输出  ``Tensor``  的数量。如果你需在  ``backward``  中使用  ``forward``  的输入  ``Tensor`` ，你可以将这些  ``Tensor``  输入到 :ref:`cn_api_paddle_autograd_PyLayerContext` 的  ``save_for_backward``  方法，之后在  ``backward``  中使用这些  ``Tensor``  。
 
-3. ``backward`` 的输出可以是 ``Tensor`` 或者 ``list/tuple(Tensor)``，这些 ``Tensor`` 是 ``forward`` 输出 ``Tensor`` 的梯度。因此，``backward`` 的输出 ``Tensor`` 的个数等于 ``forward`` 输入 ``Tensor`` 的个数。
+3.  ``backward``  的输出可以是  ``Tensor``  或者  ``list/tuple(Tensor)`` ，这些  ``Tensor``  是  ``forward``  输出  ``Tensor``  的梯度。因此， ``backward``  的输出  ``Tensor``  的个数等于  ``forward``  输入  ``Tensor``  的个数。
 
-构建完自定义算子后，通过 ``apply`` 运行算子。
+构建完自定义算子后，通过  ``apply``  运行算子。
 
 
 代码示例
@@ -27,7 +27,7 @@ COPY-FROM: paddle.autograd.PyLayer
 forward(ctx, *args, **kwargs)
 '''''''''
 
-``forward`` 函数必须被子类重写，它的第一个参数是 :ref:`cn_api_paddle_autograd_PyLayerContext` 的对象，其他输入参数的类型和数量任意。
+ ``forward``  函数必须被子类重写，它的第一个参数是 :ref:`cn_api_paddle_autograd_PyLayerContext` 的对象，其他输入参数的类型和数量任意。
 
 **参数**
 
@@ -46,16 +46,16 @@ COPY-FROM: paddle.autograd.PyLayer.forward
 backward(ctx, *args, **kwargs)
 '''''''''
 
-``backward`` 函数的作用是计算梯度，它必须被子类重写，其第一个参数为 :ref:`cn_api_paddle_autograd_PyLayerContext` 的对象，其他输入参数为 ``forward`` 输出 ``Tensor`` 的梯度。它的输出 ``Tensor`` 为 ``forward`` 输入 ``Tensor`` 的梯度。
+ ``backward``  函数的作用是计算梯度，它必须被子类重写，其第一个参数为 :ref:`cn_api_paddle_autograd_PyLayerContext` 的对象，其他输入参数为  ``forward``  输出  ``Tensor``  的梯度。它的输出  ``Tensor``  为  ``forward``  输入  ``Tensor``  的梯度。
 
 **参数**
 
- - **\*args** (tuple) - ``forward`` 输出 ``Tensor`` 的梯度。
- - **\*\*kwargs** (dict) - ``forward`` 输出 ``Tensor`` 的梯度。
+ - **\*args** (tuple) -  ``forward``  输出  ``Tensor``  的梯度。
+ - **\*\*kwargs** (dict) -  ``forward``  输出  ``Tensor``  的梯度。
 
 **返回**
 
- ``forward`` 输入 ``Tensor`` 的梯度。
+  ``forward``  输入  ``Tensor``  的梯度。
 
 **代码示例**
 
@@ -65,7 +65,7 @@ COPY-FROM: paddle.autograd.PyLayer.backward
 apply(cls, *args, **kwargs)
 '''''''''
 
-构建完自定义算子后，通过 ``apply`` 运行算子。
+构建完自定义算子后，通过  ``apply``  运行算子。
 
 **参数**
 
diff --git a/docs/api/paddle/autograd/backward_cn.rst b/docs/api/paddle/autograd/backward_cn.rst
index 2d8046bfde5..a7776391ba0 100644
--- a/docs/api/paddle/autograd/backward_cn.rst
+++ b/docs/api/paddle/autograd/backward_cn.rst
@@ -12,7 +12,7 @@ backward
 ::::::::::::
 
   - **tensors** (list[Tensor]) – 将要计算梯度的 Tensors 列表。Tensors 中不能包含有相同的 Tensor。
-  - **grad_tensors** (None|list[Tensor|None]，可选) – ``tensors`` 的初始梯度值。如果非 None，必须和 ``tensors`` 有相同的长度，并且如果其中某一 Tensor 元素为 None，则该初始梯度值为填充 1.0 的默认值；如果是 None，所有的 ``tensors`` 的初始梯度值为填充 1.0 的默认值。默认值：None。
+  - **grad_tensors** (None|list[Tensor|None]，可选) –  ``tensors``  的初始梯度值。如果非 None，必须和  ``tensors``  有相同的长度，并且如果其中某一 Tensor 元素为 None，则该初始梯度值为填充 1.0 的默认值；如果是 None，所有的  ``tensors``  的初始梯度值为填充 1.0 的默认值。默认值：None。
   - **retain_graph** (bool，可选) – 如果为 False，反向计算图将被释放。如果在 backward()之后继续添加 OP，需要设置为 True，此时之前的反向计算图会保留。将其设置为 False 会更加节省内存。默认值：False。
 
 
diff --git a/docs/api/paddle/autograd/hessian_cn.rst b/docs/api/paddle/autograd/hessian_cn.rst
index 3fcbe7e6b4d..d5b849146d0 100644
--- a/docs/api/paddle/autograd/hessian_cn.rst
+++ b/docs/api/paddle/autograd/hessian_cn.rst
@@ -5,35 +5,35 @@ hessian
 
 .. py:class:: paddle.autograd.hessian(ys, xs, batch_axis=None)
 
-计算因变量 ``ys`` 对 自变量 ``xs`` 的海森矩阵。
+计算因变量  ``ys``  对 自变量  ``xs``  的海森矩阵。
 
-其中 ``ys`` 表示 ``xs`` 经过某种运算得到的输出， ``ys`` 只能是单个 Tensor， ``xs`` 可以是 Tensor 或 Tensor 元组，``batch_axis`` 表示参数数据的 batch 维度的位置。
+其中  ``ys``  表示  ``xs``  经过某种运算得到的输出，  ``ys``  只能是单个 Tensor，  ``xs``  可以是 Tensor 或 Tensor 元组， ``batch_axis``  表示参数数据的 batch 维度的位置。
 
-当输入 ``xs`` 为 Tensor 元组时，返回结果为 ``Hessian`` 元组，假设 ``xs`` 元组的内部形状构成为 ``([M1, ], [M2, ])``，则返回结果的形状构成 ``(([M1, M1], [M1, M2]), ([M2, M1], [M2, M2]))``
+当输入  ``xs``  为 Tensor 元组时，返回结果为  ``Hessian``  元组，假设  ``xs``  元组的内部形状构成为  ``([M1, ], [M2, ])`` ，则返回结果的形状构成  ``(([M1, M1], [M1, M2]), ([M2, M1], [M2, M2]))`` 
 
-- 在 ``batch_axis=None`` 时，只支持 0 维 Tensor 或 1 维 Tensor，假设 ``xs`` 的形状为 ``[N, ]``， ``ys`` 的形状为 ``[]`` (0 维 Tensor)，则最终输出单个海森矩阵，其形状为 ``[N, N]`` 。
+- 在  ``batch_axis=None``  时，只支持 0 维 Tensor 或 1 维 Tensor，假设  ``xs``  的形状为  ``[N, ]`` ，  ``ys``  的形状为  ``[]``  (0 维 Tensor)，则最终输出单个海森矩阵，其形状为  ``[N, N]``  。
 
-- 在 ``batch_axis=0`` 时，只支持 1 维 Tensor 或 2 维 Tensor，假设 ``xs`` 的形状为 ``[B, N]``， ``ys`` 的形状为 ``[B, ]``，则最终输出雅可比矩阵形状为 ``[B, N, N]`` 。
+- 在  ``batch_axis=0``  时，只支持 1 维 Tensor 或 2 维 Tensor，假设  ``xs``  的形状为  ``[B, N]`` ，  ``ys``  的形状为  ``[B, ]`` ，则最终输出雅可比矩阵形状为  ``[B, N, N]``  。
 
-``Hessian`` 对象被创建后，并没有发生完整的计算过程，而是采用部分惰性求值方法进行计算，可以对其进行多维索引来获取整个海森矩阵或子矩阵，此时会进行实际求值计算并返回结果。同时在实际求值的过程中，会对计算完毕的子矩阵进行缓存，以避免在后续的索引过程中产生重复计算。
+ ``Hessian``  对象被创建后，并没有发生完整的计算过程，而是采用部分惰性求值方法进行计算，可以对其进行多维索引来获取整个海森矩阵或子矩阵，此时会进行实际求值计算并返回结果。同时在实际求值的过程中，会对计算完毕的子矩阵进行缓存，以避免在后续的索引过程中产生重复计算。
 
 更多索引方式可以参考 Paddle 官网 `索引和切片 <https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/guides/beginner/tensor_cn.html#suoyinheqiepian>`_ 。
 
 .. note::
-  当前暂不支持省略号索引，且暂时只支持 ``batch_axis=None`` 和 ``batch_axis=0``。
+  当前暂不支持省略号索引，且暂时只支持  ``batch_axis=None``  和  ``batch_axis=0`` 。
 
 参数
 :::::::::
 
-- **ys** (Tensor) - 因变量 ``ys`` ，数据类型为单个 Tensor。
-- **xs** (Tensor|Tuple[Tensor, ...]) - 自变量 ``xs`` ，数据类型为 Tensor 或 Tensor 元组。
-- **batch_axis** (int，可选) - ``0`` 表示参数包含 batch 维度，且第 0 维为 batch 维，
-  ``None`` 表示参数不包含 batch。默认值为 ``None`` 。
+- **ys** (Tensor) - 因变量  ``ys``  ，数据类型为单个 Tensor。
+- **xs** (Tensor|Tuple[Tensor, ...]) - 自变量  ``xs``  ，数据类型为 Tensor 或 Tensor 元组。
+- **batch_axis** (int，可选) -  ``0``  表示参数包含 batch 维度，且第 0 维为 batch 维，
+   ``None``  表示参数不包含 batch。默认值为  ``None``  。
 
 返回
 :::::::::
 
-用于计算海森矩阵的 ``Hessian`` 实例。
+用于计算海森矩阵的  ``Hessian``  实例。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/autograd/jacobian_cn.rst b/docs/api/paddle/autograd/jacobian_cn.rst
index 379d1bda837..98c417e77f5 100644
--- a/docs/api/paddle/autograd/jacobian_cn.rst
+++ b/docs/api/paddle/autograd/jacobian_cn.rst
@@ -5,40 +5,40 @@ jacobian
 
 .. py:class:: paddle.autograd.jacobian(ys, xs, batch_axis=None)
 
-计算因变量 ``ys`` 对 自变量 ``xs`` 的雅可比矩阵。
+计算因变量  ``ys``  对 自变量  ``xs``  的雅可比矩阵。
 
-其中 ``ys`` 表示 ``xs`` 经过某种运算得到的输出， ``ys`` 和 ``xs`` 可以是 Tensor 或 Tensor 元组， ``batch_axis`` 表示参数数据的 batch 维度的位置。
+其中  ``ys``  表示  ``xs``  经过某种运算得到的输出，  ``ys``  和  ``xs``  可以是 Tensor 或 Tensor 元组，  ``batch_axis``  表示参数数据的 batch 维度的位置。
 
-当输入为 Tensor 元组时，返回结果为具有与 ``xs`` 相同嵌套层数的 ``Jacobian`` 对象，且每个 Jacobian 的形状与 ``xs`` 元组一一对应相同。
+当输入为 Tensor 元组时，返回结果为具有与  ``xs``  相同嵌套层数的  ``Jacobian``  对象，且每个 Jacobian 的形状与  ``xs``  元组一一对应相同。
 
-- 在 ``batch_axis=None`` 时，只支持 0 维 Tensor 或 1 维 Tensor，假设 ``xs`` 的形状为 ``[N, ]`` ， ``ys`` 的形状为 ``[M, ]``，则最终输出雅可比矩阵形状为 ``[M, N]`` 。
+- 在  ``batch_axis=None``  时，只支持 0 维 Tensor 或 1 维 Tensor，假设  ``xs``  的形状为  ``[N, ]``  ，  ``ys``  的形状为  ``[M, ]`` ，则最终输出雅可比矩阵形状为  ``[M, N]``  。
 
-- 在 ``batch_axis=0`` 时，只支持 1 维 Tensor 或 2 维 Tensor，假设 ``xs`` 的形状为 ``[B, N]``， ``ys`` 的形状为 ``[B, M]``，则最终输出雅可比矩阵形状为 ``[B, M, N]`` 。
+- 在  ``batch_axis=0``  时，只支持 1 维 Tensor 或 2 维 Tensor，假设  ``xs``  的形状为  ``[B, N]`` ，  ``ys``  的形状为  ``[B, M]`` ，则最终输出雅可比矩阵形状为  ``[B, M, N]``  。
 
-``Jacobian`` 对象被创建后，并没有发生实际的计算过程，而是采用惰性求值方法进行计算，可以对其进行多维索引来获取整个雅可比矩阵或子矩阵，此时会进行实际求值计算并返回结果。同时在实际求值的过程中，会对计算完毕的子矩阵进行缓存，以避免在后续的索引过程中产生重复计算。
+ ``Jacobian``  对象被创建后，并没有发生实际的计算过程，而是采用惰性求值方法进行计算，可以对其进行多维索引来获取整个雅可比矩阵或子矩阵，此时会进行实际求值计算并返回结果。同时在实际求值的过程中，会对计算完毕的子矩阵进行缓存，以避免在后续的索引过程中产生重复计算。
 
-例如，假设 ``Jacobian`` 的实例 ``J`` 形状为 ``[B, M, N]``，假设 ``M > 4`` ,
-则 ``J[:, 1:4:1, :]`` 表示获取 ``J`` 的第 ``1`` 行到第 ``3`` 行值。实际计算时，仅会对
-第 ``1`` 行到第 ``3`` 进行求值，并且 ``1`` 到 ``3`` 行的计算结果会以行的粒度进行缓存，下次再
+例如，假设  ``Jacobian``  的实例  ``J``  形状为  ``[B, M, N]`` ，假设  ``M > 4``  ,
+则  ``J[:, 1:4:1, :]``  表示获取  ``J``  的第  ``1``  行到第  ``3``  行值。实际计算时，仅会对
+第  ``1``  行到第  ``3``  进行求值，并且  ``1``  到  ``3``  行的计算结果会以行的粒度进行缓存，下次再
 获取上述某一行或多行结果时，已经计算过的部分不会被重复计算。
 
 更多索引方式可以参考 Paddle 官网 `索引和切片 <https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/guides/beginner/tensor_cn.html#suoyinheqiepian>`_ 。
 
 .. note::
-  当前暂不支持省略号索引，且暂时只支持 ``batch_axis=None`` 和 ``batch_axis=0``。
+  当前暂不支持省略号索引，且暂时只支持  ``batch_axis=None``  和  ``batch_axis=0`` 。
 
 参数
 :::::::::
 
-- **ys** (Tensor|Tuple[Tensor, ...]) - 因变量 ``ys`` ，数据类型为 Tensor 或 Tensor 元组。
-- **xs** (Tensor|Tuple[Tensor, ...]) - 自变量 ``xs`` ，数据类型为 Tensor 或 Tensor 元组。
-- **batch_axis** (int，可选) - ``0`` 表示参数包含 batch 维度，且第 0 维为 batch 维，
-  ``None`` 表示参数不包含 batch。默认值为 ``None`` 。
+- **ys** (Tensor|Tuple[Tensor, ...]) - 因变量  ``ys``  ，数据类型为 Tensor 或 Tensor 元组。
+- **xs** (Tensor|Tuple[Tensor, ...]) - 自变量  ``xs``  ，数据类型为 Tensor 或 Tensor 元组。
+- **batch_axis** (int，可选) -  ``0``  表示参数包含 batch 维度，且第 0 维为 batch 维，
+   ``None``  表示参数不包含 batch。默认值为  ``None``  。
 
 返回
 :::::::::
 
-用于计算雅可比矩阵的 ``Jacobian`` 实例。
+用于计算雅可比矩阵的  ``Jacobian``  实例。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/autograd/saved_tensors_hooks_cn.rst b/docs/api/paddle/autograd/saved_tensors_hooks_cn.rst
index ffb2c2310c3..bb814791913 100644
--- a/docs/api/paddle/autograd/saved_tensors_hooks_cn.rst
+++ b/docs/api/paddle/autograd/saved_tensors_hooks_cn.rst
@@ -11,8 +11,8 @@ saved_tensors_hooks 用于动态图，注册一对 pack / unpack hook，用于
 
 **参数**
 
-  - **pack_hook** (function) – 当某个算子的前向执行时，存在 Tensor 需要保留给反向计算梯度使用时， ``pack_hook`` 将会被调用。 ``pack_hook`` 可以将 Tensor 临时存放到内存或者硬盘上。 ``pack_hook`` 的输入是 1 个要被保留的 Tensor。 ``pack_hook`` 的输出是恢复被保留 Tensor 所需要的信息。当 ``PyLayerContext.save_for_backward`` 被调用时， ``pack_hook`` 也会被调用。如果一个 Tensor 是 no need buffer 的（即反向不需要数据内容，只需要数据的 meta 信息）， ``pack_hook`` 则不会被调用。只有需要保留的 Tensor 带有 LoD 信息， ``pack_hook`` 才会被调用。
-  - **unpack_hook** (function) – 当反向执行，需要用到前向保留的 Tensor 时， ``unpack_hook`` 会被调用 ``unpack_hook`` 的输入是 ``pack_hook `` 输出的用于恢复 Tensor 所需的信息。 ``unpack_hook`` 的输出是恢复后的 Tensor，这个 Tensor 的数据内容应该和 ``pack_hook`` 的输入严格一致。
+  - **pack_hook** (function) – 当某个算子的前向执行时，存在 Tensor 需要保留给反向计算梯度使用时，  ``pack_hook``  将会被调用。  ``pack_hook``  可以将 Tensor 临时存放到内存或者硬盘上。  ``pack_hook``  的输入是 1 个要被保留的 Tensor。  ``pack_hook``  的输出是恢复被保留 Tensor 所需要的信息。当  ``PyLayerContext.save_for_backward``  被调用时，  ``pack_hook``  也会被调用。如果一个 Tensor 是 no need buffer 的（即反向不需要数据内容，只需要数据的 meta 信息），  ``pack_hook``  则不会被调用。只有需要保留的 Tensor 带有 LoD 信息，  ``pack_hook``  才会被调用。
+  - **unpack_hook** (function) – 当反向执行，需要用到前向保留的 Tensor 时，  ``unpack_hook``  会被调用  ``unpack_hook``  的输入是  ``pack_hook ``  输出的用于恢复 Tensor 所需的信息。  ``unpack_hook``  的输出是恢复后的 Tensor，这个 Tensor 的数据内容应该和  ``pack_hook``  的输入严格一致。
 
 **返回**
 
diff --git a/docs/api/paddle/batch_cn.rst b/docs/api/paddle/batch_cn.rst
index e5d13bbe68d..c1dd8186857 100644
--- a/docs/api/paddle/batch_cn.rst
+++ b/docs/api/paddle/batch_cn.rst
@@ -8,7 +8,7 @@ batch
 一个 reader 的装饰器。返回的 reader 将输入 reader 的数据打包成指定的 batch_size 大小的批处理数据（batched data）。
 
 .. warning::
-    不推荐使用这个 API，如有数据加载需求推荐使用支持多进程并发加速的 ``paddle.io.DataLoader``
+    不推荐使用这个 API，如有数据加载需求推荐使用支持多进程并发加速的  ``paddle.io.DataLoader`` 
 
 参数
 ::::::::::::
diff --git a/docs/api/paddle/bernoulli_cn.rst b/docs/api/paddle/bernoulli_cn.rst
index 38bf2b6e495..b3ddc432e9d 100644
--- a/docs/api/paddle/bernoulli_cn.rst
+++ b/docs/api/paddle/bernoulli_cn.rst
@@ -5,7 +5,7 @@ bernoulli
 
 .. py:function:: paddle.bernoulli(x, p=None, name=None)
 
-对输入 ``x`` 的每一个元素 :math:`x_i`，从以 :math:`x_i` 为参数的伯努利分布（又名两点分布或者 0-1 分布）中抽取一个样本。以 :math:`x_i` 为参数的伯努利分布的概率密度函数是
+对输入  ``x``  的每一个元素 :math:`x_i`，从以 :math:`x_i` 为参数的伯努利分布（又名两点分布或者 0-1 分布）中抽取一个样本。以 :math:`x_i` 为参数的伯努利分布的概率密度函数是
 
 .. math::
     p(y)=\begin{cases}
@@ -17,13 +17,13 @@ bernoulli
 ::::::::::::
 
     - **x** (Tensor) - 输入的 Tensor，数据类型为 float32、float64、int32 或 int64。
-    - **p** (float，可选) - 若指定 ``p``，伯努利分布的参数将全部设为 ``p``。默认值为 None，此时伯努利分布的参数由 ``x`` 决定。
+    - **p** (float，可选) - 若指定  ``p`` ，伯努利分布的参数将全部设为  ``p`` 。默认值为 None，此时伯努利分布的参数由  ``x``  决定。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
 
-    Tensor，由伯努利分布中的样本组成的 Tensor，形状和数据类型与输入 ``x`` 相同。
+    Tensor，由伯努利分布中的样本组成的 Tensor，形状和数据类型与输入  ``x``  相同。
 
 
 代码示例
diff --git a/docs/api/paddle/binomial_cn.rst b/docs/api/paddle/binomial_cn.rst
index c2ffb8197ca..85f02384bf7 100644
--- a/docs/api/paddle/binomial_cn.rst
+++ b/docs/api/paddle/binomial_cn.rst
@@ -5,7 +5,7 @@ binomial
 
 .. py:function:: paddle.binomial(count, prob, name=None)
 
-以输入参数 ``count`` 和 ``prob`` 分别为二项分布的 `n` 和 `p` 参数，生成一个二项分布的随机数 Tensor ，支持 Tensor 形状广播。输出 Tensor 的 dtype 为 ``int64`` 。
+以输入参数  ``count``  和  ``prob``  分别为二项分布的 `n` 和 `p` 参数，生成一个二项分布的随机数 Tensor ，支持 Tensor 形状广播。输出 Tensor 的 dtype 为  ``int64``  。
 
 .. math::
 
@@ -14,14 +14,14 @@ binomial
 参数
 ::::::::::::
 
-    - **count** (Tensor) - Tensor 的每个元素代表一个二项分布的总试验次数。数据类型支持 ``int32`` 、``int64`` 。
-    - **prob** (Tensor) - Tensor 的每个元素代表一个二项分布的试验成功概率。数据类型支持 ``bfloat16`` 、``float16`` 、``float32`` 、``float64`` 。
+    - **count** (Tensor) - Tensor 的每个元素代表一个二项分布的总试验次数。数据类型支持  ``int32``  、 ``int64``  。
+    - **prob** (Tensor) - Tensor 的每个元素代表一个二项分布的试验成功概率。数据类型支持  ``bfloat16``  、 ``float16``  、 ``float32``  、 ``float64``  。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
 
-    Tensor，二项分布采样得到的随机 Tensor，形状为 ``count`` 和 ``prob`` 进行广播后的 Tensor 形状， dtype 为 ``int64`` 。
+    Tensor，二项分布采样得到的随机 Tensor，形状为  ``count``  和  ``prob``  进行广播后的 Tensor 形状， dtype 为  ``int64``  。
 
 
 代码示例
diff --git a/docs/api/paddle/bitwise_and_cn.rst b/docs/api/paddle/bitwise_and_cn.rst
index fb98f3ec05b..9210ea70106 100644
--- a/docs/api/paddle/bitwise_and_cn.rst
+++ b/docs/api/paddle/bitwise_and_cn.rst
@@ -5,13 +5,13 @@ bitwise_and
 
 .. py:function:: paddle.bitwise_and(x, y, out=None, name=None)
 
-对 Tensor ``x`` 和 ``y`` 逐元素进行 ``按位与`` 运算。
+对 Tensor  ``x``  和  ``y``  逐元素进行  ``按位与``  运算。
 
 .. math::
         Out = X \& Y
 
 .. note::
-    ``paddle.bitwise_and`` 遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
+     ``paddle.bitwise_and``  遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
 
     .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 参数
@@ -24,7 +24,7 @@ bitwise_and
 
 返回
 ::::::::::::
- ``按位与`` 运算后的结果 ``Tensor``，数据类型与 ``x`` 相同。
+  ``按位与``  运算后的结果  ``Tensor`` ，数据类型与  ``x``  相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/bitwise_invert_cn.rst b/docs/api/paddle/bitwise_invert_cn.rst
index 101720248ee..4ae2c287bf5 100644
--- a/docs/api/paddle/bitwise_invert_cn.rst
+++ b/docs/api/paddle/bitwise_invert_cn.rst
@@ -5,13 +5,13 @@ bitwise_invert
 
 .. py:function:: paddle.bitwise_invert(x, out=None, name=None)
 
-对 Tensor ``x`` 逐元素进行 ``按位取反`` 运算。
+对 Tensor  ``x``  逐元素进行  ``按位取反``  运算。
 
 .. math::
        Out = \sim X
 
 .. note::
-       ``bitwise_invert`` 和 ``bitwise_not`` 执行相同的操作，功能等效。
+        ``bitwise_invert``  和  ``bitwise_not``  执行相同的操作，功能等效。
 
 参数
 ::::::::::::
@@ -22,7 +22,7 @@ bitwise_invert
 
 返回
 ::::::::::::
- ``按位取反`` 运算后的结果 ``Tensor``，数据类型与 ``x`` 相同。
+  ``按位取反``  运算后的结果  ``Tensor`` ，数据类型与  ``x``  相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/bitwise_left_shift_cn.rst b/docs/api/paddle/bitwise_left_shift_cn.rst
index 8ecb9b50b17..8e8851268da 100644
--- a/docs/api/paddle/bitwise_left_shift_cn.rst
+++ b/docs/api/paddle/bitwise_left_shift_cn.rst
@@ -5,7 +5,7 @@ bitwise_left_shift
 
 .. py:function:: paddle.bitwise_left_shift(x, y, is_arithmetic=True, out=None, name=None)
 
-对 Tensor ``x`` 和 ``y`` 逐元素进行 ``按位算术(或逻辑)左移`` 运算。
+对 Tensor  ``x``  和  ``y``  逐元素进行  ``按位算术(或逻辑)左移``  运算。
 
 关于 **有符号数的符号位** 在不同情景下的行为：
   1. 算术左移时，符号位同其他位一样，一起左移，右边补 0；
@@ -42,7 +42,7 @@ bitwise_left_shift
         Out = X \ll Y
 
 .. note::
-    ``paddle.bitwise_left_shift`` 遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
+     ``paddle.bitwise_left_shift``  遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
 
     .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 参数
@@ -57,7 +57,7 @@ bitwise_left_shift
 
 返回
 ::::::::::::
- ``按位算术(逻辑)左移`` 运算后的结果 ``Tensor``，数据类型与 ``x`` 相同。
+  ``按位算术(逻辑)左移``  运算后的结果  ``Tensor`` ，数据类型与  ``x``  相同。
 
 代码示例 1
 ::::::::::::
diff --git a/docs/api/paddle/bitwise_not_cn.rst b/docs/api/paddle/bitwise_not_cn.rst
index f273bc5a385..c809f305c09 100644
--- a/docs/api/paddle/bitwise_not_cn.rst
+++ b/docs/api/paddle/bitwise_not_cn.rst
@@ -5,13 +5,13 @@ bitwise_not
 
 .. py:function:: paddle.bitwise_not(x, out=None, name=None)
 
-对 Tensor ``x`` 逐元素进行 ``按位取反`` 运算。
+对 Tensor  ``x``  逐元素进行  ``按位取反``  运算。
 
 .. math::
        Out = \sim X
 
 .. note::
-    ``paddle.bitwise_not`` 遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
+     ``paddle.bitwise_not``  遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
 
     .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
@@ -24,7 +24,7 @@ bitwise_not
 
 返回
 ::::::::::::
- ``按位取反`` 运算后的结果 ``Tensor``，数据类型与 ``x`` 相同。
+  ``按位取反``  运算后的结果  ``Tensor`` ，数据类型与  ``x``  相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/bitwise_or_cn.rst b/docs/api/paddle/bitwise_or_cn.rst
index e87d5165d61..033cd37b872 100644
--- a/docs/api/paddle/bitwise_or_cn.rst
+++ b/docs/api/paddle/bitwise_or_cn.rst
@@ -5,32 +5,32 @@ bitwise_or
 
 .. py:function:: paddle.bitwise_or(x, y, out=None, name=None)
 
-对 Tensor ``x`` 和 ``y`` 逐元素进行 ``按位或`` 运算。
+对 Tensor  ``x``  和  ``y``  逐元素进行  ``按位或``  运算。
 
 .. math::
        Out = X | Y
 
 .. note::
-    ``paddle.bitwise_or`` 遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
+     ``paddle.bitwise_or``  遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
 
     .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x`` 和 ``other`` 可替代 ``y``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``， ``other=tensor_y`` 等价于 ``y=tensor_y``。
+    别名支持: 参数名  ``input``  可替代  ``x``  和  ``other``  可替代  ``y`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` ，  ``other=tensor_y``  等价于  ``y=tensor_y`` 。
 
 参数
 ::::::::::::
 
         - **x** （Tensor）- 输入的 N-D `Tensor`，数据类型为：bool，uint8，int8，int16，int32，int64。
-          别名： ``input``
+          别名：  ``input`` 
         - **y** （Tensor）- 输入的 N-D `Tensor`，数据类型为：bool，uint8，int8，int16，int32，int64。
-          别名： ``other``
+          别名：  ``other`` 
         - **out** （Tensor，可选）- 输出的结果 `Tensor`，是与输入数据类型相同的 N-D `Tensor`。默认值为 None，此时将创建新的 Tensor 来保存输出结果。
         - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
- ``按位或`` 运算后的结果 ``Tensor``，数据类型与 ``x`` 相同。
+  ``按位或``  运算后的结果  ``Tensor`` ，数据类型与  ``x``  相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/bitwise_right_shift_cn.rst b/docs/api/paddle/bitwise_right_shift_cn.rst
index 5ae0c9c1e64..8fd7c1bcc53 100644
--- a/docs/api/paddle/bitwise_right_shift_cn.rst
+++ b/docs/api/paddle/bitwise_right_shift_cn.rst
@@ -5,13 +5,13 @@ bitwise_right_shift
 
 .. py:function:: paddle.bitwise_right_shift(x, y, is_arithmetic=True, out=None, name=None)
 
-对 Tensor ``x`` 和 ``y`` 逐元素进行 ``按位算术(或逻辑)右移`` 运算。
+对 Tensor  ``x``  和  ``y``  逐元素进行  ``按位算术(或逻辑)右移``  运算。
 
 .. math::
         Out = X \gg Y
 
 .. note::
-    ``paddle.bitwise_right_shift`` 遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
+     ``paddle.bitwise_right_shift``  遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
 
     .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 参数
@@ -25,7 +25,7 @@ bitwise_right_shift
 
 返回
 ::::::::::::
- ``按位算术(逻辑)右移`` 运算后的结果 ``Tensor``，数据类型与 ``x`` 相同。
+  ``按位算术(逻辑)右移``  运算后的结果  ``Tensor`` ，数据类型与  ``x``  相同。
 
 代码示例 1
 ::::::::::::
diff --git a/docs/api/paddle/bitwise_xor_cn.rst b/docs/api/paddle/bitwise_xor_cn.rst
index e5d7a9f3fe8..23d490b5d77 100644
--- a/docs/api/paddle/bitwise_xor_cn.rst
+++ b/docs/api/paddle/bitwise_xor_cn.rst
@@ -5,13 +5,13 @@ bitwise_xor
 
 .. py:function:: paddle.bitwise_xor(x, y, out=None, name=None)
 
-对 Tensor ``x`` 和 ``y`` 逐元素进行 ``按位异或`` 运算。
+对 Tensor  ``x``  和  ``y``  逐元素进行  ``按位异或``  运算。
 
 .. math::
         Out = X ^\wedge Y
 
 .. note::
-    ``paddle.bitwise_xor`` 遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
+     ``paddle.bitwise_xor``  遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
 
     .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
@@ -25,7 +25,7 @@ bitwise_xor
 
 返回
 ::::::::::::
- ``按位异或`` 运算后的结果 ``Tensor``，数据类型与 ``x`` 相同。
+  ``按位异或``  运算后的结果  ``Tensor`` ，数据类型与  ``x``  相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/block_diag_cn.rst b/docs/api/paddle/block_diag_cn.rst
index 28852dbf908..c0fcb6a784e 100644
--- a/docs/api/paddle/block_diag_cn.rst
+++ b/docs/api/paddle/block_diag_cn.rst
@@ -15,7 +15,7 @@ block_diag
 返回
 :::::::::
 
-Tensor， 与 ``inputs`` 数据类型相同。
+Tensor， 与  ``inputs``  数据类型相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/bmm_cn.rst b/docs/api/paddle/bmm_cn.rst
index f982f6099d9..73872bf7ef3 100644
--- a/docs/api/paddle/bmm_cn.rst
+++ b/docs/api/paddle/bmm_cn.rst
@@ -17,14 +17,14 @@ bmm
 参数
 :::::::::
 
-    - **x** (Tensor) - 输入变量，类型为 Tensor。别名 ``input``。
-    - **y** (Tensor) - 输入变量，类型为 Tensor。别名 ``other``。
+    - **x** (Tensor) - 输入变量，类型为 Tensor。别名  ``input`` 。
+    - **y** (Tensor) - 输入变量，类型为 Tensor。别名  ``other`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/broadcast_tensors_cn.rst b/docs/api/paddle/broadcast_tensors_cn.rst
index 06f853d373c..66301b79382 100644
--- a/docs/api/paddle/broadcast_tensors_cn.rst
+++ b/docs/api/paddle/broadcast_tensors_cn.rst
@@ -5,7 +5,7 @@ broadcast_tensors
 
 .. py:function:: paddle.broadcast_tensors(input, name=None)
 
-根据 Broadcast 规范对一组输入 ``input`` 进行 Broadcast 操作
+根据 Broadcast 规范对一组输入  ``input``  进行 Broadcast 操作
 输入应符合 Broadcast 规范
 
 .. note::
@@ -34,7 +34,7 @@ broadcast_tensors
 
 返回
 :::::::::
-``list(Tensor)``，一组 Broadcast 后的 ``Tensor``，其顺序与 ``input`` 一一对应。
+ ``list(Tensor)`` ，一组 Broadcast 后的  ``Tensor`` ，其顺序与  ``input``  一一对应。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/broadcast_to_cn.rst b/docs/api/paddle/broadcast_to_cn.rst
index 32aa3c153fc..0a6e6d3f90c 100644
--- a/docs/api/paddle/broadcast_to_cn.rst
+++ b/docs/api/paddle/broadcast_to_cn.rst
@@ -5,31 +5,31 @@ broadcast_to
 
 .. py:function:: paddle.broadcast_to(x, shape, name=None)
 
-根据 ``shape`` 指定的形状广播 ``x``，广播后，``x`` 的形状和 ``shape`` 指定的形状一致。
+根据  ``shape``  指定的形状广播  ``x`` ，广播后， ``x``  的形状和  ``shape``  指定的形状一致。
 
-``x`` 的维数和 ``shape`` 的元素数应小于等于 6，并且 ``shape`` 中的元素数应该大于等于 ``x`` 的维数。扩展的维度的维度值应该为 1。
+ ``x``  的维数和  ``shape``  的元素数应小于等于 6，并且  ``shape``  中的元素数应该大于等于  ``x``  的维数。扩展的维度的维度值应该为 1。
 
-下图展示了一个形状为[3]的一维张量根据 ``shape`` 指定的形状广播为[2,3]的二维张量这一过程。
+下图展示了一个形状为[3]的一维张量根据  ``shape``  指定的形状广播为[2,3]的二维张量这一过程。
 
 .. figure:: ../../images/api_legend/broadcast_to.png
     :width: 500
     :align: center
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x`` 和 ``size`` 可替代 ``shape``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``， ``size=[2, 3]`` 等价于 ``shape=[2, 3]``。
+    别名支持: 参数名  ``input``  可替代  ``x``  和  ``size``  可替代  ``shape`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` ，  ``size=[2, 3]``  等价于  ``shape=[2, 3]`` 。
 
 参数
 :::::::::
 
     - **x** (Tensor) - 输入的 Tensor，数据类型为：bool、float16、float32、float64、int32、int64、uint8 或 uint16。
-      别名： ``input``
-    - **shape** (tuple|list|Tensor) - 给定输入 ``x`` 扩展后的形状，若 ``shape`` 为 list 或者 tuple，则其中的元素值应该为整数或者是形状为 1-D 或 0-D 的 Tensor，若 ``shape`` 类型为 Tensor，则其应该为 1-D Tensor。
-      别名： ``size``
+      别名：  ``input`` 
+    - **shape** (tuple|list|Tensor) - 给定输入  ``x``  扩展后的形状，若  ``shape``  为 list 或者 tuple，则其中的元素值应该为整数或者是形状为 1-D 或 0-D 的 Tensor，若  ``shape``  类型为 Tensor，则其应该为 1-D Tensor。
+      别名：  ``size`` 
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-``Tensor``，数据类型与 ``x`` 相同。
+ ``Tensor`` ，数据类型与  ``x``  相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/bucketize_cn.rst b/docs/api/paddle/bucketize_cn.rst
index bc5fdbb83b6..ffb37c778ac 100644
--- a/docs/api/paddle/bucketize_cn.rst
+++ b/docs/api/paddle/bucketize_cn.rst
@@ -4,19 +4,19 @@ bucketize
 -------------------------------
 
 .. py:function:: paddle.bucketize(x, sorted_sequence, out_int32=False, right=False, name=None)
-将根据给定的一维 Tensor ``sorted_sequence`` 返回输入 ``x`` 对应的桶索引。
+将根据给定的一维 Tensor  ``sorted_sequence``  返回输入  ``x``  对应的桶索引。
 
 参数
 ::::::::::
     - **x** (Tensor) - 输入的 N 维 Tensor，支持的数据类型：int32、int64、float32、float64。
     - **sorted_sequence** (Tensor) - 输入的一维 Tensor，支持的数据类型：int32、int64、float32、float64。该 Tensor 的数值在其最后一个维度递增。
     - **out_int32** (bool，可选) - 输出的数据类型支持 int32、int64。默认值为 False，表示默认的输出数据类型为 int64。
-    - **right** (bool，可选) - 根据给定 ``x`` 在 ``sorted_sequence`` 查找对应的上边界或下边界。如果 ``sorted_sequence``的值为 nan 或 inf，则返回最内层维度的大小。默认值为 False，表示在 ``sorted_sequence`` 的查找给定 ``x`` 的下边界。
+    - **right** (bool，可选) - 根据给定  ``x``  在  ``sorted_sequence``  查找对应的上边界或下边界。如果  ``sorted_sequence`` 的值为 nan 或 inf，则返回最内层维度的大小。默认值为 False，表示在  ``sorted_sequence``  的查找给定  ``x``  的下边界。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-Tensor(与 ``x`` 维度相同)，如果参数 ``out_int32`` 为 False，则返回数据类型为 int64 的 Tensor，否则将返回 int32 的 Tensor。
+Tensor(与  ``x``  维度相同)，如果参数  ``out_int32``  为 False，则返回数据类型为 int64 的 Tensor，否则将返回 int32 的 Tensor。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/callbacks/Callback_cn.rst b/docs/api/paddle/callbacks/Callback_cn.rst
index 66f0afb90d6..a122b67a60e 100644
--- a/docs/api/paddle/callbacks/Callback_cn.rst
+++ b/docs/api/paddle/callbacks/Callback_cn.rst
@@ -5,7 +5,7 @@ Callback
 
 .. py:class:: paddle.callbacks.Callback()
 
- ``Callback`` 是一个基类，用于实现用户自定义的 callback。如果想使用除 :ref:`EarlyStopping <cn_api_paddle_callbacks_EarlyStopping>` 外的自定义策略终止训练，可以通过在自定义的 callback 类中设置 ``model.stop_training=True`` 来实现。
+  ``Callback``  是一个基类，用于实现用户自定义的 callback。如果想使用除 :ref:`EarlyStopping <cn_api_paddle_callbacks_EarlyStopping>` 外的自定义策略终止训练，可以通过在自定义的 callback 类中设置  ``model.stop_training=True``  来实现。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/callbacks/EarlyStopping_cn.rst b/docs/api/paddle/callbacks/EarlyStopping_cn.rst
index 6835dda76cb..153bec4ab00 100644
--- a/docs/api/paddle/callbacks/EarlyStopping_cn.rst
+++ b/docs/api/paddle/callbacks/EarlyStopping_cn.rst
@@ -5,18 +5,18 @@ EarlyStopping
 
 .. py:class:: paddle.callbacks.EarlyStopping(monitor='loss', mode='auto', patience=0, verbose=1, min_delta=0, baseline=None, save_best_model=True)
 
-在模型评估阶段，模型效果如果没有提升，``EarlyStopping`` 会通过设置 ``model.stop_training=True`` 让模型提前停止训练。
+在模型评估阶段，模型效果如果没有提升， ``EarlyStopping``  会通过设置  ``model.stop_training=True``  让模型提前停止训练。
 
 参数
 ::::::::::::
 
   - **monitor** (str，可选) - 监控量。该量作为模型是否停止学习的监控指标。默认值：'loss'。
-  - **mode** (str，可选) - 可以是'auto'、'min'或者'max'。在 min 模式下，模型会在监控量的值不再减少时停止训练；max 模式下，模型会在监控量的值不再增加时停止训练；auto 模式下，实际的模式会从 ``monitor`` 推断出来。如果 ``monitor`` 中有'acc'，将会认为是 max 模式，其它情况下，都会被推断为 min 模式。默认值：'auto'。
+  - **mode** (str，可选) - 可以是'auto'、'min'或者'max'。在 min 模式下，模型会在监控量的值不再减少时停止训练；max 模式下，模型会在监控量的值不再增加时停止训练；auto 模式下，实际的模式会从  ``monitor``  推断出来。如果  ``monitor``  中有'acc'，将会认为是 max 模式，其它情况下，都会被推断为 min 模式。默认值：'auto'。
   - **patience** (int，可选) - 多少个 epoch 模型效果未提升会使模型提前停止训练。默认值：0。
   - **verbose** (int，可选) - 可以是 0 或者 1，0 代表不打印模型提前停止训练的日志，1 代表打印日志。默认值：1。
-  - **min_delta** (int|float，可选) - 监控量最小改变值。当 evaluation 的监控变量改变值小于 ``min_delta``，就认为模型没有变化。默认值：0。
-  - **baseline** (int|float，可选) - 监控量的基线。如果模型在训练 ``patience`` 个 epoch 后效果对比基线没有提升，将会停止训练。如果是 None，代表没有基线。默认值：None。
-  - **save_best_model** (bool，可选) - 是否保存效果最好的模型（监控量的值最优）。文件会保存在 ``fit`` 中传入的参数 ``save_dir`` 下，前缀名为 best_model，默认值：True。
+  - **min_delta** (int|float，可选) - 监控量最小改变值。当 evaluation 的监控变量改变值小于  ``min_delta`` ，就认为模型没有变化。默认值：0。
+  - **baseline** (int|float，可选) - 监控量的基线。如果模型在训练  ``patience``  个 epoch 后效果对比基线没有提升，将会停止训练。如果是 None，代表没有基线。默认值：None。
+  - **save_best_model** (bool，可选) - 是否保存效果最好的模型（监控量的值最优）。文件会保存在  ``fit``  中传入的参数  ``save_dir``  下，前缀名为 best_model，默认值：True。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/callbacks/LRScheduler_cn.rst b/docs/api/paddle/callbacks/LRScheduler_cn.rst
index 69c73aa1b54..286c0b476bd 100644
--- a/docs/api/paddle/callbacks/LRScheduler_cn.rst
+++ b/docs/api/paddle/callbacks/LRScheduler_cn.rst
@@ -5,7 +5,7 @@ LRScheduler
 
 .. py:class:: paddle.callbacks.LRScheduler(by_step=True, by_epoch=False)
 
- ``LRScheduler`` 是一个学习率回调函数。
+  ``LRScheduler``  是一个学习率回调函数。
 
 参数
 ::::::::::::
diff --git a/docs/api/paddle/callbacks/ModelCheckpoint_cn.rst b/docs/api/paddle/callbacks/ModelCheckpoint_cn.rst
index 961965289ce..728a59d947f 100644
--- a/docs/api/paddle/callbacks/ModelCheckpoint_cn.rst
+++ b/docs/api/paddle/callbacks/ModelCheckpoint_cn.rst
@@ -5,7 +5,7 @@ ModelCheckpoint
 
 .. py:class:: paddle.callbacks.ModelCheckpoint(save_freq=1, save_dir=None)
 
- ``ModelCheckpoint`` 回调类和 model.fit 联合使用，在训练阶段，保存模型权重和优化器状态信息。当前仅支持在固定的 epoch 间隔保存模型，不支持按照 batch 的间隔保存。
+  ``ModelCheckpoint``  回调类和 model.fit 联合使用，在训练阶段，保存模型权重和优化器状态信息。当前仅支持在固定的 epoch 间隔保存模型，不支持按照 batch 的间隔保存。
 
    子方法可以参考基类。
 
diff --git a/docs/api/paddle/callbacks/ProgBarLogger_cn.rst b/docs/api/paddle/callbacks/ProgBarLogger_cn.rst
index ac208d655b8..c45de577260 100644
--- a/docs/api/paddle/callbacks/ProgBarLogger_cn.rst
+++ b/docs/api/paddle/callbacks/ProgBarLogger_cn.rst
@@ -5,7 +5,7 @@ ProgBarLogger
 
 .. py:class:: paddle.callbacks.ProgBarLogger(log_freq=1, verbose=2)
 
- ``ProgBarLogger`` 是一个日志回调类，用来打印损失函数和评估指标。支持静默模式、进度条模式、每次打印一行三种模式，详细的参考下面参数注释。
+  ``ProgBarLogger``  是一个日志回调类，用来打印损失函数和评估指标。支持静默模式、进度条模式、每次打印一行三种模式，详细的参考下面参数注释。
 
 参数
 ::::::::::::
@@ -13,7 +13,7 @@ ProgBarLogger
   - **log_freq** (int，可选) - 损失值和指标打印的频率。默认值：1。
   - **verbose** (int，可选) - 打印信息的模式。设置为 0 时，不打印信息；
     设置为 1 时，使用进度条的形式打印信息；设置为 2 时，使用行的形式打印信息。
-    设置为 3 时，会在 2 的基础上打印详细的计时信息，比如 ``average_reader_cost``。
+    设置为 3 时，会在 2 的基础上打印详细的计时信息，比如  ``average_reader_cost`` 。
     默认值：2。
 
 
diff --git a/docs/api/paddle/callbacks/VisualDL_cn.rst b/docs/api/paddle/callbacks/VisualDL_cn.rst
index 1a368a4f51a..ad7db0ac114 100644
--- a/docs/api/paddle/callbacks/VisualDL_cn.rst
+++ b/docs/api/paddle/callbacks/VisualDL_cn.rst
@@ -5,7 +5,7 @@ VisualDL
 
 .. py:class:: paddle.callbacks.VisualDL(log_dir)
 
- ``VisualDL`` 是一个 visualdl( `飞桨可视化分析工具 <https://github.com/PaddlePaddle/VisualDL>`_ )的回调类。该类将训练过程中的损失值和评价指标储存至日志文件中后，启动面板即可查看可视化结果。
+  ``VisualDL``  是一个 visualdl( `飞桨可视化分析工具 <https://github.com/PaddlePaddle/VisualDL>`_ )的回调类。该类将训练过程中的损失值和评价指标储存至日志文件中后，启动面板即可查看可视化结果。
 
 参数
 ::::::::::::
diff --git a/docs/api/paddle/cast__cn.rst b/docs/api/paddle/cast__cn.rst
index 8210204bb44..60cfc108e7e 100644
--- a/docs/api/paddle/cast__cn.rst
+++ b/docs/api/paddle/cast__cn.rst
@@ -4,7 +4,7 @@ cast\_
 -------------------------------
 
 .. py:function:: paddle.cast_(x, dtype)
-Inplace 版本的 :ref:`cn_api_paddle_cast` API，对输入 ``x`` 采用 Inplace 策略。
+Inplace 版本的 :ref:`cn_api_paddle_cast` API，对输入  ``x``  采用 Inplace 策略。
 
 更多关于 inplace 操作的介绍请参考 `3.1.3 原位（Inplace）操作和非原位操作的区别`_ 了解详情。
 
diff --git a/docs/api/paddle/cast_cn.rst b/docs/api/paddle/cast_cn.rst
index 4fac8e36c77..ef2af744322 100644
--- a/docs/api/paddle/cast_cn.rst
+++ b/docs/api/paddle/cast_cn.rst
@@ -8,7 +8,7 @@ cast
 
 
 
-将 ``x`` 的数据类型转换为 ``dtype`` 并输出。支持输出和输入的数据类型相同。
+将  ``x``  的数据类型转换为  ``dtype``  并输出。支持输出和输入的数据类型相同。
 
 下图展示了一个例子：将输入的 float64 类型 Tensor 转化为 uint8 类型 Tensor
 
@@ -23,7 +23,7 @@ cast
 
 返回
 ::::::::::::
-Tensor，维度与 ``x`` 相同，数据类型为 ``dtype``。
+Tensor，维度与  ``x``  相同，数据类型为  ``dtype`` 。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/cat_cn.rst b/docs/api/paddle/cat_cn.rst
index 28e8d131c48..a2a8b8154a1 100644
--- a/docs/api/paddle/cat_cn.rst
+++ b/docs/api/paddle/cat_cn.rst
@@ -5,4 +5,4 @@ cat
 
 .. py:function:: paddle.cat(x, axis=0, name=None, *, out=None)
 
-``concat`` 的别名，请参考 :ref:`cn_api_paddle_concat`。
+ ``concat``  的别名，请参考 :ref:`cn_api_paddle_concat`。
diff --git a/docs/api/paddle/cauchy__cn.rst b/docs/api/paddle/cauchy__cn.rst
index abff7ef72dc..33d989cb5cf 100644
--- a/docs/api/paddle/cauchy__cn.rst
+++ b/docs/api/paddle/cauchy__cn.rst
@@ -7,7 +7,7 @@ cauchy\_
 
 
 
-直接修改输入张量 ``x``，将所有元素替换为从柯西分布中随机采样的数值。
+直接修改输入张量  ``x`` ，将所有元素替换为从柯西分布中随机采样的数值。
 
 参数
 ::::::::::::
@@ -19,7 +19,7 @@ cauchy\_
 
 返回
 ::::::::::::
-Tensor，对输入的张量 ``x`` 直接进行了修改，数据类型与输入时相同。
+Tensor，对输入的张量  ``x``  直接进行了修改，数据类型与输入时相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/cdist_cn.rst b/docs/api/paddle/cdist_cn.rst
index 8a0dd10d986..89ba0e8b250 100644
--- a/docs/api/paddle/cdist_cn.rst
+++ b/docs/api/paddle/cdist_cn.rst
@@ -19,11 +19,11 @@ cdist
   - **p** (float, 可选) - 计算每个向量对之间的 p 范数距离的值。默认值为 :math:`2.0`。
   - **compute_mode** (str, 可选) - 选择计算模式。
 
-    - ``use_mm_for_euclid_dist_if_necessary``: 对于 p = 2.0 且 P > 25, R > 25 ，如果可能，将使用矩阵乘法计算欧氏距离。
-    - ``use_mm_for_euclid_dist``: 对于 p = 2.0 ，使用矩阵乘法计算欧几里得距离。
-    - ``use_loop_for_euclid_dist``: 不使用矩阵乘法计算欧几里得距离。
+    -  ``use_mm_for_euclid_dist_if_necessary`` : 对于 p = 2.0 且 P > 25, R > 25 ，如果可能，将使用矩阵乘法计算欧氏距离。
+    -  ``use_mm_for_euclid_dist`` : 对于 p = 2.0 ，使用矩阵乘法计算欧几里得距离。
+    -  ``use_loop_for_euclid_dist`` : 不使用矩阵乘法计算欧几里得距离。
 
-    默认值为 ``use_mm_for_euclid_dist_if_necessary``。
+    默认值为  ``use_mm_for_euclid_dist_if_necessary`` 。
   - **name** (str, 可选) - 具体用法请参见  :ref:`api_guide_Name` ，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/ceil_cn.rst b/docs/api/paddle/ceil_cn.rst
index 6bb5df9ee4e..1013c7c05ca 100644
--- a/docs/api/paddle/ceil_cn.rst
+++ b/docs/api/paddle/ceil_cn.rst
@@ -15,19 +15,19 @@ ceil
 
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` 。
 
 参数
 ::::::::::::
 
     - **x** (Tensor) - 输入的 Tensor，数据类型支持 float32, float64, float16, bfloat16, uint8, int8, int16, int32, int64。
-      别名： ``input``
+      别名：  ``input`` 
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
     - **out** （Tensor，可选） - 指定输出结果的 `Tensor`，默认值为 None。
 
 返回
 ::::::::::::
-输出 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出 Tensor，与  ``x``  维度相同、数据类型相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/chunk_cn.rst b/docs/api/paddle/chunk_cn.rst
index ab514395160..00a26cc398b 100644
--- a/docs/api/paddle/chunk_cn.rst
+++ b/docs/api/paddle/chunk_cn.rst
@@ -8,14 +8,14 @@ chunk
 将输入 Tensor 分割成多个子 Tensor。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``dim`` 可替代 ``axis``，如 ``chunk(input=tensor_x, chunks=2, dim=1)`` 等价于 ``chunk(x=tensor_x, chunks=2, axis=1)``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，参数名  ``dim``  可替代  ``axis`` ，如  ``chunk(input=tensor_x, chunks=2, dim=1)``  等价于  ``chunk(x=tensor_x, chunks=2, axis=1)`` 。
 
 参数
 :::::::::
 
-       - **x** (Tensor) - 输入变量，数据类型为 bool, float16, float32，float64，int32，int64 的多维 Tensor。别名： ``input``。
-       - **chunks** (int) - ``chunks`` 是一个整数，表示将输入 Tensor 划分成多少个相同大小的子 Tensor。
-       - **axis** (int|Tensor，可选) - 整数或者形状为[]的 0-D Tensor，数据类型为 int32 或 int64。表示需要分割的维度。如果 ``axis < 0``，则划分的维度为 ``rank(x) + axis``。默认值为 0。别名： ``dim``。
+       - **x** (Tensor) - 输入变量，数据类型为 bool, float16, float32，float64，int32，int64 的多维 Tensor。别名：  ``input`` 。
+       - **chunks** (int) -  ``chunks``  是一个整数，表示将输入 Tensor 划分成多少个相同大小的子 Tensor。
+       - **axis** (int|Tensor，可选) - 整数或者形状为[]的 0-D Tensor，数据类型为 int32 或 int64。表示需要分割的维度。如果  ``axis < 0`` ，则划分的维度为  ``rank(x) + axis`` 。默认值为 0。别名：  ``dim`` 。
        - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 下图展示了一个例子，设 x 的尺寸为(3,3,3)，chunks 值为 3，axis 值为 0。
diff --git a/docs/api/paddle/clamp_cn.rst b/docs/api/paddle/clamp_cn.rst
index 47ff0b3bb7a..1fb612da7e4 100644
--- a/docs/api/paddle/clamp_cn.rst
+++ b/docs/api/paddle/clamp_cn.rst
@@ -5,4 +5,4 @@ clamp
 
 .. py:function:: paddle.clamp(x, min=None, max=None, name=None, *, out=None)
 
-``clip`` 的别名，请参考 :ref:`cn_api_paddle_clip`。
+ ``clip``  的别名，请参考 :ref:`cn_api_paddle_clip`。
diff --git a/docs/api/paddle/clip_cn.rst b/docs/api/paddle/clip_cn.rst
index 31dc1a55b20..08d6d09a98f 100644
--- a/docs/api/paddle/clip_cn.rst
+++ b/docs/api/paddle/clip_cn.rst
@@ -15,12 +15,12 @@ clip
         Out = MIN(MAX(x, min), max)
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``clip(input=tensor_x, min=0.3, max=0.7)`` 等价于 ``clip(x=tensor_x, min=0.3, max=0.7)``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``clip(input=tensor_x, min=0.3, max=0.7)``  等价于  ``clip(x=tensor_x, min=0.3, max=0.7)`` 。
 
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 输入的 Tensor，数据类型为：bfloat16、float16、float32、float64、int32、int64。别名： ``input``。
+    - **x** (Tensor) - 输入的 Tensor，数据类型为：bfloat16、float16、float32、float64、int32、int64。别名：  ``input`` 。
     - **min** (float|int|Tensor，可选) - 裁剪的最小值，输入中小于该值的元素将由该元素代替，若参数为空，则不对输入的最小值做限制。数据类型可以是 float32 或形状为[]的 0-D Tensor，类型可以为 bfloat16、float16、float32、float64、int32，默认值为 None。
     - **max** (float|int|Tensor，可选) - 裁剪的最大值，输入中大于该值的元素将由该元素代替，若参数为空，则不对输入的最大值做限制。数据类型可以是 float32 或形状为[]的 0-D Tensor，类型可以为 bfloat16、float16、float32、float64、int32，默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
@@ -31,7 +31,7 @@ clip
 
 返回
 ::::::::::::
-输出 Tensor，与 ``x`` 维度相同。当 ``x`` 数据类型为 int32 或 int64 并且 ``min`` 或 ``max`` 有一个为 float 类型时，输出 Tensor 的数据类型为 float32，否则与输入 ``x`` 的数据类型相同。
+输出 Tensor，与  ``x``  维度相同。当  ``x``  数据类型为 int32 或 int64 并且  ``min``  或  ``max``  有一个为 float 类型时，输出 Tensor 的数据类型为 float32，否则与输入  ``x``  的数据类型相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/clone_cn.rst b/docs/api/paddle/clone_cn.rst
index cd0692f6a47..563040826e9 100644
--- a/docs/api/paddle/clone_cn.rst
+++ b/docs/api/paddle/clone_cn.rst
@@ -17,7 +17,7 @@ clone
 返回
 :::::::::
 
-``Tensor``，从输入 :attr:`x` 拷贝的 Tensor。
+ ``Tensor`` ，从输入 :attr:`x` 拷贝的 Tensor。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/column_stack_cn.rst b/docs/api/paddle/column_stack_cn.rst
index 40b60db1f13..c357f85fd9d 100644
--- a/docs/api/paddle/column_stack_cn.rst
+++ b/docs/api/paddle/column_stack_cn.rst
@@ -5,7 +5,7 @@ column_stack
 
 .. py:function:: paddle.column_stack(x, name=None)
 
-沿水平轴堆叠输入 ``x`` 中的所有张量。 ``x`` 中的每个张量 ``tensor`` 如果在堆叠之前 ``tensor.ndim < 2`` ，则首先被整形为 ``(tensor.numel(), 1)``。所有张量必须具有相同的数据类型。
+沿水平轴堆叠输入  ``x``  中的所有张量。  ``x``  中的每个张量  ``tensor``  如果在堆叠之前  ``tensor.ndim < 2``  ，则首先被整形为  ``(tensor.numel(), 1)`` 。所有张量必须具有相同的数据类型。
 
 下图展示了一个 column_stack 的情形，将一个形状为（3，1）的二维张量与一个形状为（3，）的一维张量进行 column_stack 操作，其中一维张量首先被整形为（3，1），然后再沿水平轴堆叠输入所有张量。通过图例能很好看出张量的变化。
 
@@ -16,7 +16,7 @@ column_stack
 参数
 ::::::::::::
 
-    - **x** (list[Tensor]|tuple[Tensor]) - 输入 ``x`` 可以是张量的 list 或 tuple， ``x`` 中张量的数据类型必须相同。支持的数据类型： ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 、 ``int64`` 或 ``bfloat16`` 。
+    - **x** (list[Tensor]|tuple[Tensor]) - 输入  ``x``  可以是张量的 list 或 tuple，  ``x``  中张量的数据类型必须相同。支持的数据类型：  ``float16``  、  ``float32``  、  ``float64``  、  ``int32``  、  ``int64``  或  ``bfloat16``  。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/combinations_cn.rst b/docs/api/paddle/combinations_cn.rst
index 851490cbfa4..b755b6ec5a3 100644
--- a/docs/api/paddle/combinations_cn.rst
+++ b/docs/api/paddle/combinations_cn.rst
@@ -17,7 +17,7 @@ combinations
 
 返回
 ::::::::::
-    - ``out`` (Tensor)：由组合数拼接而成的 Tensor ，和输入 x 类型相同。
+    -  ``out``  (Tensor)：由组合数拼接而成的 Tensor ，和输入 x 类型相同。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/compat/Overview_cn.rst b/docs/api/paddle/compat/Overview_cn.rst
index 2cd9e7ccf14..b2bd6318031 100644
--- a/docs/api/paddle/compat/Overview_cn.rst
+++ b/docs/api/paddle/compat/Overview_cn.rst
@@ -33,4 +33,4 @@ PyTorch 兼容模块
     :header: "类名称", "类功能"
     :widths: 10, 30
 
-    " :ref:`Unfold <cn_api_paddle_compat_Unfold>` ", "允许 Tensor 输入的 ``paddle.nn.Unfold`` 兼容版本"
+    " :ref:`Unfold <cn_api_paddle_compat_Unfold>` ", "允许 Tensor 输入的  ``paddle.nn.Unfold``  兼容版本"
diff --git a/docs/api/paddle/compat/Unfold_cn.rst b/docs/api/paddle/compat/Unfold_cn.rst
index 5b302db0b3f..91401b7af7f 100644
--- a/docs/api/paddle/compat/Unfold_cn.rst
+++ b/docs/api/paddle/compat/Unfold_cn.rst
@@ -7,9 +7,9 @@ Unfold
 
 
 PyTorch 兼容的 :ref:`cn_api_paddle_nn_Unfold` 版本：
-    - 关键字参数使用单数形式（例如：``kernel_size`` 而非 kernel_sizes）
-    - ``padding`` 仅支持输入长度为 1（整数）或 2 的列表，禁止使用 Size4 格式。如需更灵活的输入版本，请使用 :ref:`cn_api_paddle_nn_Unfold`
-    - 所有输入参数支持 ``Tensor`` 或 ``pir.Value`` 类型（将自动转换为列表）
+    - 关键字参数使用单数形式（例如： ``kernel_size``  而非 kernel_sizes）
+    -  ``padding``  仅支持输入长度为 1（整数）或 2 的列表，禁止使用 Size4 格式。如需更灵活的输入版本，请使用 :ref:`cn_api_paddle_nn_Unfold`
+    - 所有输入参数支持  ``Tensor``  或  ``pir.Value``  类型（将自动转换为列表）
     - 其他特性与 :ref:`cn_api_paddle_nn_Unfold` 完全一致
 
 使用前请详细参考：`【仅参数名不一致】torch.nn.Unfold`_ 以确定是否使用此模块。
@@ -31,21 +31,21 @@ PyTorch 兼容的 :ref:`cn_api_paddle_nn_Unfold` 版本：
 
 功能说明
 :::::::::::
-实现卷积中的 im2col 操作，将卷积核覆盖区域的元素重排列为列向量。输入形状为 [N, C, H, W] 的 ``x`` 将输出形状为 [N, Cout, Lout] 的张量。
+实现卷积中的 im2col 操作，将卷积核覆盖区域的元素重排列为列向量。输入形状为 [N, C, H, W] 的  ``x``  将输出形状为 [N, Cout, Lout] 的张量。
 
 
 参数
 :::::::::::
 
-        - **kernel_size** (int|list|tuple|Tensor) - 卷积核尺寸。接受 ``[k_h, k_w]`` 或整数 ``k`` （视为  ``[k, k]``）
-        - **dilation** (int|list|tuple|Tensor, 可选) - 卷积膨胀系数。接受单整数或 ``[dilation_h, dilation_w]``。单整数 ``dilation`` 视为 ``[dilation, dilation]``。默认为 1
-        - **padding** (int|list|tuple|Tensor, 可选) - 各维度填充大小。接受单整数或 ``[padding_h, padding_w]``。``[padding_h, padding_w]`` 将扩展为 ``[padding_h, padding_w, padding_h, padding_w]``。单整数 ``padding`` 将转为 ``[padding, padding, padding, padding]``。默认为 0
-        - **stride** (int|list|tuple|Tensor, 可选) - 滑动步长。接受单整数或 ``[stride_h, stride_w]``。单整数 ``stride`` 视为 ``[stride, stride]``。默认为 1
+        - **kernel_size** (int|list|tuple|Tensor) - 卷积核尺寸。接受  ``[k_h, k_w]``  或整数  ``k``  （视为   ``[k, k]`` ）
+        - **dilation** (int|list|tuple|Tensor, 可选) - 卷积膨胀系数。接受单整数或  ``[dilation_h, dilation_w]`` 。单整数  ``dilation``  视为  ``[dilation, dilation]`` 。默认为 1
+        - **padding** (int|list|tuple|Tensor, 可选) - 各维度填充大小。接受单整数或  ``[padding_h, padding_w]`` 。 ``[padding_h, padding_w]``  将扩展为  ``[padding_h, padding_w, padding_h, padding_w]`` 。单整数  ``padding``  将转为  ``[padding, padding, padding, padding]`` 。默认为 0
+        - **stride** (int|list|tuple|Tensor, 可选) - 滑动步长。接受单整数或  ``[stride_h, stride_w]`` 。单整数  ``stride``  视为  ``[stride, stride]`` 。默认为 1
 
 形状
 :::::::::
  - **输入** : 4-D Tensor，形状为[N, C, H, W]，数据类型为 float32 或者 float64
- - **输出**：形状如上面所描述的[N, Cout, Lout]，Cout 每一个滑动 block 里面覆盖的元素个数，Lout 是滑动 block 的个数，数据类型与 ``x`` 相同
+ - **输出**：形状如上面所描述的[N, Cout, Lout]，Cout 每一个滑动 block 里面覆盖的元素个数，Lout 是滑动 block 的个数，数据类型与  ``x``  相同
 
 
 代码示例
diff --git a/docs/api/paddle/compat/max_cn.rst b/docs/api/paddle/compat/max_cn.rst
index e7d802637bc..1d5ca9c775a 100644
--- a/docs/api/paddle/compat/max_cn.rst
+++ b/docs/api/paddle/compat/max_cn.rst
@@ -27,7 +27,7 @@ max
 
 .. note::
 
-    对输入有多个最大值的情况下，``paddle.compat.max`` 的梯度表现与 ``paddle.amax`` 一致：会将梯度平均传回到最大值对应的位置。``out`` 返回方法与静态图联合使用是被禁止的行为，静态图下将报错。
+    对输入有多个最大值的情况下， ``paddle.compat.max``  的梯度表现与  ``paddle.amax``  一致：会将梯度平均传回到最大值对应的位置。 ``out``  返回方法与静态图联合使用是被禁止的行为，静态图下将报错。
 
 参数
 :::::::::
@@ -47,18 +47,18 @@ max
 
 .. note::
 
-    对输入有多个最大值的情况下，`paddle.compat.max` 将只返回梯度值给 ``indices`` 中选择的位置。``out`` 返回方法与静态图联合使用是被禁止的行为，静态图下将报错。
+    对输入有多个最大值的情况下，`paddle.compat.max` 将只返回梯度值给  ``indices``  中选择的位置。 ``out``  返回方法与静态图联合使用是被禁止的行为，静态图下将报错。
 
 参数
 :::::::::
    - **x** （Tensor）- Tensor，支持数据类型为 bfloat16、float16、float32、float64、int32、int64（CUDA GPU），而 uint8, int32, int64, float32, float64 在 CPU 设备上被支持。
-   - **dim** （list|tuple|int，可选）- 求最大值运算的维度。必须在 :math:`[−x.ndim, x.ndim]` 范围内。如果 :math:`dim[i] < 0`，则维度将变为 :math:`x.ndim+dim[i]`，默认值为 None。注意，手动传入 ``dim=None`` 是不允许的，``dim`` 不可显式被指定为 None。如果需要对整个 tensor 求解全局最大值，请使用第一种参数写法。
-   - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留输入的维度。除非 keepdim 为 True，否则输出 Tensor 的维度将比输入 Tensor 小一维，默认值为 False。注意，不传入 ``dim`` 时传入本参数是不允许的！
-   - **out** (tuple(Tensor, Tensor)，可选) - 用于引用式传入输出值。``values`` 在前，``indices`` 在后。注意：动态图下 out 可以是任意 Tensor，默认值为 None。
+   - **dim** （list|tuple|int，可选）- 求最大值运算的维度。必须在 :math:`[−x.ndim, x.ndim]` 范围内。如果 :math:`dim[i] < 0`，则维度将变为 :math:`x.ndim+dim[i]`，默认值为 None。注意，手动传入  ``dim=None``  是不允许的， ``dim``  不可显式被指定为 None。如果需要对整个 tensor 求解全局最大值，请使用第一种参数写法。
+   - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留输入的维度。除非 keepdim 为 True，否则输出 Tensor 的维度将比输入 Tensor 小一维，默认值为 False。注意，不传入  ``dim``  时传入本参数是不允许的！
+   - **out** (tuple(Tensor, Tensor)，可选) - 用于引用式传入输出值。 ``values``  在前， ``indices``  在后。注意：动态图下 out 可以是任意 Tensor，默认值为 None。
 
 返回
 :::::::::
-MinMaxRetType(Tensor, Tensor)，此处的 ``MinMaxRetType`` 是一个具名元组，含有 ``values`` （在前）和 ``indices`` （在后）两个域，用法与 tuple 一致。
+MinMaxRetType(Tensor, Tensor)，此处的  ``MinMaxRetType``  是一个具名元组，含有  ``values``  （在前）和  ``indices``  （在后）两个域，用法与 tuple 一致。
 
 
 =====
@@ -67,21 +67,21 @@ MinMaxRetType(Tensor, Tensor)，此处的 ``MinMaxRetType`` 是一个具名元
 .. py:function:: paddle.compat.max(x, other, out=None)
 
 
-与 ``other`` Tensor 计算逐元素最大值。见 `paddle.maximum` :ref:`cn_api_paddle_maximum`
+与  ``other``  Tensor 计算逐元素最大值。见 `paddle.maximum` :ref:`cn_api_paddle_maximum`
 
 .. note::
 
-    ``out`` 返回方法与静态图联合使用是被禁止的行为，静态图下将报错。
+     ``out``  返回方法与静态图联合使用是被禁止的行为，静态图下将报错。
 
 参数
 :::::::::
    - **x** （Tensor）- Tensor，支持数据类型为 bfloat16、float16、float32、float64、int32、int64（CUDA GPU），而 uint8, int32, int64, float32, float64 在 CPU 设备上被支持。
-   - **other** （Tensor）- Tensor，支持类型见 ``x``。注意，``other`` 的 shape 必须可以被广播到 ``x`` 的 shape。
+   - **other** （Tensor）- Tensor，支持类型见  ``x`` 。注意， ``other``  的 shape 必须可以被广播到  ``x``  的 shape。
    - **out** (Tensor，可选) - 用于引用式传入输出值，注意：动态图下 out 可以是任意 Tensor，默认值为 None。
 
 返回
 :::::::::
-   Tensor，逐元素最大的结果，形状、数据类型与 place 与 ``x`` 一致。
+   Tensor，逐元素最大的结果，形状、数据类型与 place 与  ``x``  一致。
 
 
 =====
diff --git a/docs/api/paddle/compat/median_cn.rst b/docs/api/paddle/compat/median_cn.rst
index 4a86ef96aee..69efa11f4ba 100644
--- a/docs/api/paddle/compat/median_cn.rst
+++ b/docs/api/paddle/compat/median_cn.rst
@@ -6,23 +6,23 @@ median
 .. py:function:: paddle.compat.median(input, dim=None, keepdim=False, *, out=None)
 
 PyTorch 兼容的 :ref:`cn_api_paddle_median` 版本，提供完全一致的函数签名与行为：
-- 当 ``dim`` 为 ``None`` 时，返回所有元素的中位数。
-- 当 ``dim`` 指定维度时，返回该维度的中位数与对应索引。
+- 当  ``dim``  为  ``None``  时，返回所有元素的中位数。
+- 当  ``dim``  指定维度时，返回该维度的中位数与对应索引。
 
 .. note::
-   此 API 遵循 ``torch.median`` 的函数签名和行为以实现 PyTorch 兼容。如需使用 Paddle 原生实现，请参考 :ref:`cn_api_paddle_median`。
+   此 API 遵循  ``torch.median``  的函数签名和行为以实现 PyTorch 兼容。如需使用 Paddle 原生实现，请参考 :ref:`cn_api_paddle_median`。
 
 参数
 ::::::::::
 - **input** (Tensor) - 输入 N 维 Tensor，支持 bool、bfloat16、float16、float32、float64、int32、int64 数据类型。
-- **dim** (int，可选) - 指定计算中位数的维度。为 ``None`` 时计算全局中位数。默认 ``None``。
-- **keepdim** (bool，可选) - 是否保留被约简的维度。默认 ``False``。
-- **out** (tuple(Tensor, Tensor)|Tensor，可选) - 关键字参数。当指定 ``dim`` 时，可传入二元组 ``(values, indices)`` 用于原位写回中位数与索引；当未指定 ``dim`` 时，可传入单个 ``Tensor`` 用于写回标量结果。默认 ``None``。
+- **dim** (int，可选) - 指定计算中位数的维度。为  ``None``  时计算全局中位数。默认  ``None`` 。
+- **keepdim** (bool，可选) - 是否保留被约简的维度。默认  ``False`` 。
+- **out** (tuple(Tensor, Tensor)|Tensor，可选) - 关键字参数。当指定  ``dim``  时，可传入二元组  ``(values, indices)``  用于原位写回中位数与索引；当未指定  ``dim``  时，可传入单个  ``Tensor``  用于写回标量结果。默认  ``None`` 。
 
 返回
 ::::::::::
-- 当 ``dim`` 为 ``None``：返回一个标量 ``Tensor``，为 ``input`` 的中位数。
-- 当 ``dim`` 指定：返回具名元组 ``(values, indices)``，分别是中位数与其索引。
+- 当  ``dim``  为  ``None`` ：返回一个标量  ``Tensor`` ，为  ``input``  的中位数。
+- 当  ``dim``  指定：返回具名元组  ``(values, indices)`` ，分别是中位数与其索引。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/compat/min_cn.rst b/docs/api/paddle/compat/min_cn.rst
index e2a58812fee..c4133defbad 100644
--- a/docs/api/paddle/compat/min_cn.rst
+++ b/docs/api/paddle/compat/min_cn.rst
@@ -27,7 +27,7 @@ min
 
 .. note::
 
-    对输入有多个最小值的情况下，``paddle.compat.min`` 的梯度表现与 ``paddle.amin`` 一致：会将梯度平均传回到最小值对应的位置。``out`` 返回方法与静态图联合使用是被禁止的行为，静态图下将报错。
+    对输入有多个最小值的情况下， ``paddle.compat.min``  的梯度表现与  ``paddle.amin``  一致：会将梯度平均传回到最小值对应的位置。 ``out``  返回方法与静态图联合使用是被禁止的行为，静态图下将报错。
 
 参数
 :::::::::
@@ -47,18 +47,18 @@ min
 
 .. note::
 
-    对输入有多个最小值的情况下，`paddle.compat.min` 将只返回梯度值给 ``indices`` 中选择的位置。``out`` 返回方法与静态图联合使用是被禁止的行为，静态图下将报错。
+    对输入有多个最小值的情况下，`paddle.compat.min` 将只返回梯度值给  ``indices``  中选择的位置。 ``out``  返回方法与静态图联合使用是被禁止的行为，静态图下将报错。
 
 参数
 :::::::::
    - **x** （Tensor）- Tensor，支持数据类型为 bfloat16、float16、float32、float64、int32、int64（CUDA GPU），而 uint8, int32, int64, float32, float64 在 CPU 设备上被支持。
-   - **dim** （list|tuple|int，可选）- 求最小值运算的维度。必须在 :math:`[−x.ndim, x.ndim]` 范围内。如果 :math:`dim[i] < 0`，则维度将变为 :math:`x.ndim+dim[i]`，默认值为 None。注意，手动传入 ``dim=None`` 是不允许的，``dim`` 不可显式被指定为 None。如果需要对整个 tensor 求解全局最小值，请使用第一种参数写法。
-   - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留输入的维度。除非 keepdim 为 True，否则输出 Tensor 的维度将比输入 Tensor 小一维，默认值为 False。注意，不传入 ``dim`` 时传入本参数是不允许的！
-   - **out** (tuple(Tensor, Tensor)，可选) - 用于引用式传入输出值。``values`` 在前，``indices`` 在后。注意：动态图下 out 可以是任意 Tensor，默认值为 None。
+   - **dim** （list|tuple|int，可选）- 求最小值运算的维度。必须在 :math:`[−x.ndim, x.ndim]` 范围内。如果 :math:`dim[i] < 0`，则维度将变为 :math:`x.ndim+dim[i]`，默认值为 None。注意，手动传入  ``dim=None``  是不允许的， ``dim``  不可显式被指定为 None。如果需要对整个 tensor 求解全局最小值，请使用第一种参数写法。
+   - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留输入的维度。除非 keepdim 为 True，否则输出 Tensor 的维度将比输入 Tensor 小一维，默认值为 False。注意，不传入  ``dim``  时传入本参数是不允许的！
+   - **out** (tuple(Tensor, Tensor)，可选) - 用于引用式传入输出值。 ``values``  在前， ``indices``  在后。注意：动态图下 out 可以是任意 Tensor，默认值为 None。
 
 返回
 :::::::::
-MinMaxRetType(Tensor, Tensor)，此处的 ``MinMaxRetType`` 是一个具名元组，含有 ``values`` （在前）和 ``indices`` （在后）两个域，用法与 tuple 一致。
+MinMaxRetType(Tensor, Tensor)，此处的  ``MinMaxRetType``  是一个具名元组，含有  ``values``  （在前）和  ``indices``  （在后）两个域，用法与 tuple 一致。
 
 
 =====
@@ -67,21 +67,21 @@ MinMaxRetType(Tensor, Tensor)，此处的 ``MinMaxRetType`` 是一个具名元
 .. py:function:: paddle.compat.min(x, other, out=None)
 
 
-与 ``other`` Tensor 计算逐元素最小值。见 `paddle.minimum` :ref:`cn_api_paddle_minimum`
+与  ``other``  Tensor 计算逐元素最小值。见 `paddle.minimum` :ref:`cn_api_paddle_minimum`
 
 .. note::
 
-    ``out`` 返回方法与静态图联合使用是被禁止的行为，静态图下将报错。
+     ``out``  返回方法与静态图联合使用是被禁止的行为，静态图下将报错。
 
 参数
 :::::::::
    - **x** （Tensor）- Tensor，支持数据类型为 bfloat16、float16、float32、float64、int32、int64（CUDA GPU），而 uint8, int32, int64, float32, float64 在 CPU 设备上被支持。
-   - **other** （Tensor）- Tensor，支持类型见 ``x``。注意，``other`` 的 shape 必须可以被广播到 ``x`` 的 shape。
+   - **other** （Tensor）- Tensor，支持类型见  ``x`` 。注意， ``other``  的 shape 必须可以被广播到  ``x``  的 shape。
    - **out** (Tensor，可选) - 用于引用式传入输出值，注意：动态图下 out 可以是任意 Tensor，默认值为 None。
 
 返回
 :::::::::
-   Tensor，逐元素最小的结果，形状、数据类型与 place 与 ``x`` 一致。
+   Tensor，逐元素最小的结果，形状、数据类型与 place 与  ``x``  一致。
 
 
 =====
diff --git a/docs/api/paddle/compat/nanmedian_cn.rst b/docs/api/paddle/compat/nanmedian_cn.rst
index 60290a1703d..02a9915c1fe 100644
--- a/docs/api/paddle/compat/nanmedian_cn.rst
+++ b/docs/api/paddle/compat/nanmedian_cn.rst
@@ -7,23 +7,23 @@ nanmedian
 
 PyTorch 兼容的 :ref:`cn_api_paddle_nanmedian` 版本，提供完全一致的函数签名与行为：
 - 忽略 NaN 元素计算中位数。
-- 当 ``dim`` 为 ``None`` 时，返回所有非 NaN 元素的中位数；
-- 当 ``dim`` 指定维度时，返回该维度上非 NaN 元素的中位数与对应索引；若某个切片全为 NaN，则返回 NaN 和索引 0。
+- 当  ``dim``  为  ``None``  时，返回所有非 NaN 元素的中位数；
+- 当  ``dim``  指定维度时，返回该维度上非 NaN 元素的中位数与对应索引；若某个切片全为 NaN，则返回 NaN 和索引 0。
 
 .. note::
-   此 API 遵循 ``torch.nanmedian`` 的函数签名和行为以实现 PyTorch 兼容。如需使用 Paddle 原生实现，请参考 :ref:`cn_api_paddle_nanmedian`。
+   此 API 遵循  ``torch.nanmedian``  的函数签名和行为以实现 PyTorch 兼容。如需使用 Paddle 原生实现，请参考 :ref:`cn_api_paddle_nanmedian`。
 
 参数
 ::::::::::
 - **input** (Tensor) - 输入 N 维 Tensor，支持 bfloat16、float16、float32、float64 数据类型。
-- **dim** (int，可选) - 指定计算中位数的维度。为 ``None`` 时计算全局中位数。默认 ``None``。
-- **keepdim** (bool，可选) - 是否保留被约简的维度。默认 ``False``。
-- **out** (tuple(Tensor, Tensor)|Tensor，可选) - 关键字参数。当指定 ``dim`` 时，可传入二元组 ``(values, indices)`` 用于原位写回中位数与索引；当未指定 ``dim`` 时，可传入单个 ``Tensor`` 用于写回标量结果。默认 ``None``。
+- **dim** (int，可选) - 指定计算中位数的维度。为  ``None``  时计算全局中位数。默认  ``None`` 。
+- **keepdim** (bool，可选) - 是否保留被约简的维度。默认  ``False`` 。
+- **out** (tuple(Tensor, Tensor)|Tensor，可选) - 关键字参数。当指定  ``dim``  时，可传入二元组  ``(values, indices)``  用于原位写回中位数与索引；当未指定  ``dim``  时，可传入单个  ``Tensor``  用于写回标量结果。默认  ``None`` 。
 
 返回
 ::::::::::
-- 当 ``dim`` 为 ``None``：返回一个标量 ``Tensor``，为忽略 NaN 后的中位数。
-- 当 ``dim`` 指定：返回具名元组 ``(values, indices)``，分别是中位数与其索引。
+- 当  ``dim``  为  ``None`` ：返回一个标量  ``Tensor`` ，为忽略 NaN 后的中位数。
+- 当  ``dim``  指定：返回具名元组  ``(values, indices)`` ，分别是中位数与其索引。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/compat/pad_cn.rst b/docs/api/paddle/compat/pad_cn.rst
index 2a28b9d0e3f..0ff111cc583 100644
--- a/docs/api/paddle/compat/pad_cn.rst
+++ b/docs/api/paddle/compat/pad_cn.rst
@@ -11,33 +11,33 @@ PyTorch 兼容的 :ref:`cn_api_paddle_nn_functional_pad` 版本
 
 .. _【paddle 参数更多】torch.nn.functional.pad: https://www.paddlepaddle.org.cn/documentation/docs/en/guides/model_convert/convert_from_pytorch/api_difference/functional/torch.nn.functional.pad.html
 
-根据 ``'pad'`` 和 ``'mode'`` 对输入张量进行 padding 操作。所有操作都是从 **最右侧的维度** （最后一个维度）开始。
+根据  ``'pad'``  和  ``'mode'``  对输入张量进行 padding 操作。所有操作都是从 **最右侧的维度** （最后一个维度）开始。
 
 .. note::
-    此 API 遵循 ``torch.nn.functional.pad`` 的函数签名和行为以实现 PyTorch 兼容。
+    此 API 遵循  ``torch.nn.functional.pad``  的函数签名和行为以实现 PyTorch 兼容。
     如需使用 Paddle 原生实现，请参考 :ref:`cn_api_paddle_nn_functional_pad`
 
 参数
 :::::::::
        - **input** (Tensor) - 输入 N 维 Tensor，支持 float32、float64、int32、int64、complex64、complex128
-       - **pad** (Tensor|list[int]|tuple[int]) - 填充大小，基本数据类型是 ``int32``。
-       - **mode** (str, 可选) - - padding 的四种模式，分别为 ``'constant'``、``'reflect'``、``'replicate'`` 和 ``'circular'``，默认值为 ``constant``
+       - **pad** (Tensor|list[int]|tuple[int]) - 填充大小，基本数据类型是  ``int32`` 。
+       - **mode** (str, 可选) - - padding 的四种模式，分别为  ``'constant'`` 、 ``'reflect'`` 、 ``'replicate'``  和  ``'circular'`` ，默认值为  ``constant`` 
 
-         - ``'constant'`` 表示填充常数 ``value``；
-         - ``'reflect'`` 表示填充以 ``input`` 边界值为轴的映射；
-         - ``'replicate'`` 表示填充 ``input`` 边界值；
-         - ``'circular'`` 为循环填充 ``input``。
+         -  ``'constant'``  表示填充常数  ``value`` ；
+         -  ``'reflect'``  表示填充以  ``input``  边界值为轴的映射；
+         -  ``'replicate'``  表示填充  ``input``  边界值；
+         -  ``'circular'``  为循环填充  ``input`` 。
 
-       - **value** (float, 可选) - 以 ``'constant'`` 模式填充区域时填充的值，使用其他模式时此值不被使用。默认值为 :math:`0.0`。
+       - **value** (float, 可选) - 以  ``'constant'``  模式填充区域时填充的值，使用其他模式时此值不被使用。默认值为 :math:`0.0`。
 
 .. note::
 
-    对于非 ``'constant'``, ``pad`` 的尺寸不能超过 ``min(2 * input.ndim - 2, 6)``。
-    此外非 ``'constant'`` 中只有 2D、3D、4D 以及 5D 张量受到支持，且至多仅能操作最后三个维度（当 ``ndim>=3`` 时）。
+    对于非  ``'constant'`` ,  ``pad``  的尺寸不能超过  ``min(2 * input.ndim - 2, 6)`` 。
+    此外非  ``'constant'``  中只有 2D、3D、4D 以及 5D 张量受到支持，且至多仅能操作最后三个维度（当  ``ndim>=3``  时）。
 
 返回
 :::::::::
-Tensor，对 ``input`` 进行 ``'pad'`` 的结果，数据类型和 ``input`` 相同。
+Tensor，对  ``input``  进行  ``'pad'``  的结果，数据类型和  ``input``  相同。
 
 
 代码示例
diff --git a/docs/api/paddle/compat/softmax_cn.rst b/docs/api/paddle/compat/softmax_cn.rst
index 0a22b9d5fd6..c4c97264cc4 100644
--- a/docs/api/paddle/compat/softmax_cn.rst
+++ b/docs/api/paddle/compat/softmax_cn.rst
@@ -8,7 +8,7 @@ softmax
 
 步骤 1：输入 :attr:`input` 的 :attr:`dim` 维会被置换到最后一维；
 
-步骤 2：将输入 :attr:`input` 在逻辑上变换为二维矩阵。二维矩阵第一维（列长度）是输入除最后一维之外的其他维度值的乘积，第二维（行长度）和输入 ``dim`` 维的长度相同；对于矩阵的每一行，softmax 操作对其进行重新缩放，使得该行的每个元素在 :math:`[0, 1]` 范围内，并且总和为 :math:`1`；
+步骤 2：将输入 :attr:`input` 在逻辑上变换为二维矩阵。二维矩阵第一维（列长度）是输入除最后一维之外的其他维度值的乘积，第二维（行长度）和输入  ``dim``  维的长度相同；对于矩阵的每一行，softmax 操作对其进行重新缩放，使得该行的每个元素在 :math:`[0, 1]` 范围内，并且总和为 :math:`1`；
 
 步骤 3：softmax 操作执行完成后，执行步骤 1 和步骤 2 的逆运算，将二维矩阵恢复至和输入 :attr:`input` 相同的维度。
 
@@ -84,7 +84,7 @@ softmax
 参数
 ::::::::::
 
-    - **input** (Tensor) - 输入的 ``Tensor``，数据类型为 bfloat16 、 float16 、 float32 或 float64。
+    - **input** (Tensor) - 输入的  ``Tensor`` ，数据类型为 bfloat16 、 float16 、 float32 或 float64。
     - **dim** (int，可选) - 指定对输入 :attr:`input` 进行运算的轴。:attr:`dim` 的有效范围是 :math:`[-D, D)`，:math:`D` 是输入 :attr:`input` 的维度，:attr:`dim` 为负值时与 :math:`dim + D` 等价。默认值为 None。
     - **dtype** (str，可选) - 输出 `Tensor` 的数据类型，支持 bfloat16、 float16、 float32、float64。
     - **out** (Tensor，可选) - 指定输出结果的 `Tensor`，默认值为 None。
@@ -92,7 +92,7 @@ softmax
 返回
 ::::::::::
 
-    ``Tensor``，形状和 :attr:`input` 相同，数据类型为 :attr:`dtype` 或者和 :attr:`input` 相同。
+     ``Tensor`` ，形状和 :attr:`input` 相同，数据类型为 :attr:`dtype` 或者和 :attr:`input` 相同。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/compat/sort_cn.rst b/docs/api/paddle/compat/sort_cn.rst
index 95aa599e551..b2a42d3f35d 100644
--- a/docs/api/paddle/compat/sort_cn.rst
+++ b/docs/api/paddle/compat/sort_cn.rst
@@ -5,7 +5,7 @@ sort
 
 .. py:function:: paddle.compat.sort(input, dim=-1, descending=False, stable=False, out=None)
 
-PyTorch 兼容的 :ref:`cn_api_paddle_sort` 版本，同时返回排序的值结果以及索引值。对输入变量沿给定轴进行排序，输出排序好的数据，其维度和输入相同。默认升序排列，如果需要降序排列设置 ``descending=True`` 。
+PyTorch 兼容的 :ref:`cn_api_paddle_sort` 版本，同时返回排序的值结果以及索引值。对输入变量沿给定轴进行排序，输出排序好的数据，其维度和输入相同。默认升序排列，如果需要降序排列设置  ``descending=True``  。
 
 使用前请详细参考：`【返回参数类型不一致】torch.sort`_ 以确定是否使用此模块。
 
@@ -15,15 +15,15 @@ PyTorch 兼容的 :ref:`cn_api_paddle_sort` 版本，同时返回排序的值结
 参数
 ::::::::::::
 
-    - **input** (Tensor) - 输入的多维 ``Tensor``，支持的数据类型：float32, float64, int16, int32, int64, uint8, float16, bfloat16。
-    - **dim** (int，可选) - 指定对输入 Tensor 进行运算的轴，``dim`` 的有效范围是[-R, R)，R 是输入 ``x`` 的 Rank， ``dim`` 为负时与 ``dim`` +R 等价。默认值为-1。
+    - **input** (Tensor) - 输入的多维  ``Tensor`` ，支持的数据类型：float32, float64, int16, int32, int64, uint8, float16, bfloat16。
+    - **dim** (int，可选) - 指定对输入 Tensor 进行运算的轴， ``dim``  的有效范围是[-R, R)，R 是输入  ``x``  的 Rank，  ``dim``  为负时与  ``dim``  +R 等价。默认值为-1。
     - **descending** (bool，可选) - 指定算法排序的方向。如果设置为 True，算法按照降序排序。如果设置为 False 或者不设置，按照升序排序。默认值为 False。
     - **stable** (bool，可选) - 是否使用稳定排序算法。若设置为 True，则使用稳定排序算法，即相同元素的顺序在排序结果中将会被保留。默认值为 False，此时的算法不一定是稳定排序算法。
-    - **out** (tuple(Tensor, Tensor)，可选) - 用于引用式传入输出值。``values`` 在前，``indices`` 在后。注意：动态图下 out 可以是任意 Tensor，默认值为 None。``out`` 返回方法与静态图联合使用是被禁止的行为，静态图下将报错。
+    - **out** (tuple(Tensor, Tensor)，可选) - 用于引用式传入输出值。 ``values``  在前， ``indices``  在后。注意：动态图下 out 可以是任意 Tensor，默认值为 None。 ``out``  返回方法与静态图联合使用是被禁止的行为，静态图下将报错。
 
 返回
 ::::::::::::
-SortRetType(Tensor, Tensor)，此处的 ``SortRetType`` 是一个具名元组，含有 ``values`` （在前）和 ``indices`` （在后）两个域，用法与 tuple 一致。
+SortRetType(Tensor, Tensor)，此处的  ``SortRetType``  是一个具名元组，含有  ``values``  （在前）和  ``indices``  （在后）两个域，用法与 tuple 一致。
 
 
 代码示例
diff --git a/docs/api/paddle/compat/split_cn.rst b/docs/api/paddle/compat/split_cn.rst
index 89901fe5166..4addf16df18 100644
--- a/docs/api/paddle/compat/split_cn.rst
+++ b/docs/api/paddle/compat/split_cn.rst
@@ -6,21 +6,21 @@ split
 .. py:function:: paddle.compat.split(tensor, split_size_or_sections, dim=0)
 
 
-PyTorch 兼容的 :ref:`cn_api_paddle_split` 版本，允许了非整除的 ``split_size_or_sections`` 输入
+PyTorch 兼容的 :ref:`cn_api_paddle_split` 版本，允许了非整除的  ``split_size_or_sections``  输入
 
 使用前请详细参考：`【输入参数用法不一致】torch.split`_ 以确定是否使用此模块。
 
 .. _【输入参数用法不一致】torch.split: https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/guides/model_convert/convert_from_pytorch/api_difference/torch/torch.split.html
 
 .. note::
-    此 API 遵循 ``torch.split`` 的函数签名和行为以实现 PyTorch 兼容。
+    此 API 遵循  ``torch.split``  的函数签名和行为以实现 PyTorch 兼容。
     如需使用 Paddle 原生实现，请参考 :ref:`cn_api_paddle_split`
 
 参数
 :::::::::
        - **tensor** (Tensor) - 输入 N 维 Tensor，支持 bool、bfloat16、float16、float32、float64、uint8、int8、int32 或 int64 数据类型
-       - **split_size_or_sections** (int|list|tuple) - 若为整数，则将 Tensor 均匀分割为指定大小的块，与 :ref:`cn_api_paddle_split` 不同，本 API 不要求此参数整除对应维度的通道数：非整除情况下输出元组的最后一个 tensor 对应维度将为余数大小，小于此值。若为列表/元组，则按指定尺寸分割，禁止使用负值（例如对 9 通道的维度，``[2,3,-1]`` 会被拒绝）
-       - **dim** (int|Tensor, 可选) - 分割维度，可为整数或形状为[]的 0-D Tensor（数据类型需为 ``int32`` 或 ``int64``）。若 ``dim < 0``，则实际维度为 ``rank(x) + dim``。默认值：0
+       - **split_size_or_sections** (int|list|tuple) - 若为整数，则将 Tensor 均匀分割为指定大小的块，与 :ref:`cn_api_paddle_split` 不同，本 API 不要求此参数整除对应维度的通道数：非整除情况下输出元组的最后一个 tensor 对应维度将为余数大小，小于此值。若为列表/元组，则按指定尺寸分割，禁止使用负值（例如对 9 通道的维度， ``[2,3,-1]``  会被拒绝）
+       - **dim** (int|Tensor, 可选) - 分割维度，可为整数或形状为[]的 0-D Tensor（数据类型需为  ``int32``  或  ``int64`` ）。若  ``dim < 0`` ，则实际维度为  ``rank(x) + dim`` 。默认值：0
 
 返回
 :::::::::
diff --git a/docs/api/paddle/complex_cn.rst b/docs/api/paddle/complex_cn.rst
index 413e78887c7..be3efc192cc 100644
--- a/docs/api/paddle/complex_cn.rst
+++ b/docs/api/paddle/complex_cn.rst
@@ -12,20 +12,20 @@ complex
 参数
 :::::::::
     - **real** (Tensor) - 实部，数据类型为：float32 或 float64。
-    - **imag** (Tensor) - 虚部，数据类型和 ``real`` 相同。
+    - **imag** (Tensor) - 虚部，数据类型和  ``real``  相同。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 返回
 :::::::::
-输出 Tensor，数据类型是 complex64 或者 complex128，与 ``real`` 和 ``imag`` 的数值精度一致。
+输出 Tensor，数据类型是 complex64 或者 complex128，与  ``real``  和  ``imag``  的数值精度一致。
 
 .. note::
-    ``paddle.complex`` 遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
+     ``paddle.complex``  遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
 
     .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
diff --git a/docs/api/paddle/concat_cn.rst b/docs/api/paddle/concat_cn.rst
index 76063cb3c5c..e55d7fee780 100644
--- a/docs/api/paddle/concat_cn.rst
+++ b/docs/api/paddle/concat_cn.rst
@@ -6,32 +6,32 @@ concat
 .. py:function:: paddle.concat(x, axis=0, name=None, *, out=None)
 
 
-对输入沿参数 ``axis`` 轴进行联结，返回一个新的 Tensor。该 API 不支持输入 0-D Tensor，因为其必须指定沿着某个轴拼接，而 0-D Tensor 没有轴。
+对输入沿参数  ``axis``  轴进行联结，返回一个新的 Tensor。该 API 不支持输入 0-D Tensor，因为其必须指定沿着某个轴拼接，而 0-D Tensor 没有轴。
 
-下图展示了 concat 操作的典型情况——两个形状为 [2, 3, 4] 的三维张量通过 concat 操作沿着不同的 ``axis`` 轴拼接为不同形状的三维张量，我们可以清晰地看到不同维度拼接的效果。
+下图展示了 concat 操作的典型情况——两个形状为 [2, 3, 4] 的三维张量通过 concat 操作沿着不同的  ``axis``  轴拼接为不同形状的三维张量，我们可以清晰地看到不同维度拼接的效果。
 
 .. image:: ../../images/api_legend/concat.png
    :width: 500
    :alt: 图例
 
 .. note::
-    别名支持: 参数名 ``tensors`` 可替代 ``x``，参数名 ``dim`` 可替代 ``axis`` ，如 ``concat(tensors=tensor_x, dim=1, ...)`` 等价于 ``concat(x=tensor_x, axis=1, ...)`` 。
+    别名支持: 参数名  ``tensors``  可替代  ``x`` ，参数名  ``dim``  可替代  ``axis``  ，如  ``concat(tensors=tensor_x, dim=1, ...)``  等价于  ``concat(x=tensor_x, axis=1, ...)``  。
 
 参数
 ::::::::::::
 
-    - **x** (list|tuple) - 待联结的 Tensor list 或者 Tensor tuple，支持的数据类型为：bool、float16、bfloat16、float32、float64、int8、uint8、int16、uint16、int32、int64、complex64、complex128， ``x`` 中所有 Tensor 的数据类型应该一致。别名： ``tensors``。
-    - **axis** (int|Tensor，可选) - 指定对输入 ``x`` 进行运算的轴，可以是整数或者形状为[]的 0-D Tensor，数据类型为 int32 或者 int64。 ``axis`` 的有效范围是 [-R, R)，R 是输入 ``x`` 中 Tensor 的维度，``axis`` 为负值时与 :math:`axis + R` 等价。默认值为 0。别名： ``dim``。
+    - **x** (list|tuple) - 待联结的 Tensor list 或者 Tensor tuple，支持的数据类型为：bool、float16、bfloat16、float32、float64、int8、uint8、int16、uint16、int32、int64、complex64、complex128，  ``x``  中所有 Tensor 的数据类型应该一致。别名：  ``tensors`` 。
+    - **axis** (int|Tensor，可选) - 指定对输入  ``x``  进行运算的轴，可以是整数或者形状为[]的 0-D Tensor，数据类型为 int32 或者 int64。  ``axis``  的有效范围是 [-R, R)，R 是输入  ``x``  中 Tensor 的维度， ``axis``  为负值时与 :math:`axis + R` 等价。默认值为 0。别名：  ``dim`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 返回
 ::::::::::::
-联结后的 Tensor，数据类型和 ``x`` 中的 Tensor 相同。
+联结后的 Tensor，数据类型和  ``x``  中的 Tensor 相同。
 
 
 代码示例
diff --git a/docs/api/paddle/concatenate_cn.rst b/docs/api/paddle/concatenate_cn.rst
index faa13a77f69..1e0bcba77dc 100644
--- a/docs/api/paddle/concatenate_cn.rst
+++ b/docs/api/paddle/concatenate_cn.rst
@@ -5,4 +5,4 @@ concatenate
 
 .. py:function:: paddle.concatenate(x, axis=0, name=None, *, out=None)
 
-``concat`` 的别名，请参考 :ref:`cn_api_paddle_concat`。
+ ``concat``  的别名，请参考 :ref:`cn_api_paddle_concat`。
diff --git a/docs/api/paddle/cos_cn.rst b/docs/api/paddle/cos_cn.rst
index dd6114addf0..8f9e35320c2 100644
--- a/docs/api/paddle/cos_cn.rst
+++ b/docs/api/paddle/cos_cn.rst
@@ -19,17 +19,17 @@ cos
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 输入的 Tensor，数据类型为：float32、float64 、float16、complex64、complex128。别名 ``input``。
+    - **x** (Tensor) - 输入的 Tensor，数据类型为：float32、float64 、float16、complex64、complex128。别名  ``input`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 返回
 ::::::::::::
-输出 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出 Tensor，与  ``x``  维度相同、数据类型相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/cosh_cn.rst b/docs/api/paddle/cosh_cn.rst
index 6fe521f31a4..c57356b8e9c 100644
--- a/docs/api/paddle/cosh_cn.rst
+++ b/docs/api/paddle/cosh_cn.rst
@@ -24,7 +24,7 @@ cosh
 
 返回
 ::::::::::::
-输出 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出 Tensor，与  ``x``  维度相同、数据类型相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/count_nonzero_cn.rst b/docs/api/paddle/count_nonzero_cn.rst
index 5c998347cae..a3f53eabd37 100644
--- a/docs/api/paddle/count_nonzero_cn.rst
+++ b/docs/api/paddle/count_nonzero_cn.rst
@@ -5,19 +5,19 @@ count_nonzero
 
 .. py:function:: paddle.count_nonzero(x, axis=None, keepdim=False, name=None)
 
-沿给定的轴 ``axis`` 统计输入 Tensor ``x`` 中非零元素的个数。
+沿给定的轴  ``axis``  统计输入 Tensor  ``x``  中非零元素的个数。
 
 参数
 ::::::::::
    - **x** (Tensor) - 输入的 Tensor，数据类型为：bool、float16、float32、float64、int32、int64。
-   - **axis** (None|int|list|tuple，可选) - 指定对 ``x`` 进行计算的轴。``axis`` 可以是 int 或者 int 元素的列表。``axis`` 值应该在范围[-D， D)内，D 是 ``x`` 的维度。如果 ``axis`` 或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果 ``axis`` 是 None，则对 ``x`` 的全部元素计算中位数。默认值为 None。
-   - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如果 ``keepdim`` 为 True，则输出 Tensor 和 ``x`` 具有相同的维度(减少的维度除外，减少的维度的大小为 1)。否则，输出 Tensor 的形状会在 ``axis`` 上进行 squeeze 操作。默认值为 True。
+   - **axis** (None|int|list|tuple，可选) - 指定对  ``x``  进行计算的轴。 ``axis``  可以是 int 或者 int 元素的列表。 ``axis``  值应该在范围[-D， D)内，D 是  ``x``  的维度。如果  ``axis``  或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果  ``axis``  是 None，则对  ``x``  的全部元素计算中位数。默认值为 None。
+   - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如果  ``keepdim``  为 True，则输出 Tensor 和  ``x``  具有相同的维度(减少的维度除外，减少的维度的大小为 1)。否则，输出 Tensor 的形状会在  ``axis``  上进行 squeeze 操作。默认值为 True。
    - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 ::::::::::
-    ``Tensor``，沿着 ``axis`` 统计输入 Tensor 中非零元素的个数，数据类型 int64。
+     ``Tensor`` ，沿着  ``axis``  统计输入 Tensor 中非零元素的个数，数据类型 int64。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/cross_cn.rst b/docs/api/paddle/cross_cn.rst
index 570cd67ffa9..31eb378576a 100644
--- a/docs/api/paddle/cross_cn.rst
+++ b/docs/api/paddle/cross_cn.rst
@@ -6,20 +6,20 @@ cross
 .. py:function:: paddle.cross(x, y, axis=9, name=None)
 
 
-计算 Tensor ``x`` 和 ``y`` 在 ``axis`` 维度上的向量积（叉积）。
+计算 Tensor  ``x``  和  ``y``  在  ``axis``  维度上的向量积（叉积）。
 
-``x`` 和 ``y`` 必须有相同的形状，且指定的 ``axis`` 的长度必须为 3。如果未指定 ``axis``，默认选取第一个长度为 3 的 ``axis`` 。
+ ``x``  和  ``y``  必须有相同的形状，且指定的  ``axis``  的长度必须为 3。如果未指定  ``axis`` ，默认选取第一个长度为 3 的  ``axis``  。
 
 参数
 :::::::::
     - **x** (Tensor) - 第一个输入 Tensor，数据类型为：float16、float32、float64、int32、int64、complex64、complex128。
     - **y** (Tensor) - 第二个输入 Tensor，数据类型为：float16、float32、float64、int32、int64、complex64、complex128。
-    - **axis** (int，可选) - 沿着此维进行向量积操作。默认值是 9，意思是选取第一个长度为 3 的 ``axis`` 。
+    - **axis** (int，可选) - 沿着此维进行向量积操作。默认值是 9，意思是选取第一个长度为 3 的  ``axis``  。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-计算后的 Tensor，数据类型与输入 ``x`` 相同。
+计算后的 Tensor，数据类型与输入  ``x``  相同。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/cummax_cn.rst b/docs/api/paddle/cummax_cn.rst
index 2a482f6b589..7b370b46e62 100644
--- a/docs/api/paddle/cummax_cn.rst
+++ b/docs/api/paddle/cummax_cn.rst
@@ -5,7 +5,7 @@ cummax
 
 .. py:function:: paddle.cummax(x, axis=None, dtype='int64', name=None)
 
-沿给定 ``axis`` 计算 Tensor ``x`` 的累积最大值。
+沿给定  ``axis``  计算 Tensor  ``x``  的累积最大值。
 
 .. note::
     结果的第一个元素和输入的第一个元素相同。
@@ -19,8 +19,8 @@ cummax
 
 返回
 ::::::::::
-    - ``out`` (Tensor)：返回累积最大值操作的结果，累积最大值结果类型和输入 x 相同。
-    - ``indices`` (Tensor)：返回对应累积最大值操作的的索引结果。
+    -  ``out``  (Tensor)：返回累积最大值操作的结果，累积最大值结果类型和输入 x 相同。
+    -  ``indices``  (Tensor)：返回对应累积最大值操作的的索引结果。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/cummin_cn.rst b/docs/api/paddle/cummin_cn.rst
index 233a9f93ef1..248d305a753 100644
--- a/docs/api/paddle/cummin_cn.rst
+++ b/docs/api/paddle/cummin_cn.rst
@@ -5,7 +5,7 @@ cummin
 
 .. py:function:: paddle.cummin(x, axis=None, dtype='int64', name=None)
 
-沿给定 ``axis`` 计算 Tensor ``x`` 的累积最小值。
+沿给定  ``axis``  计算 Tensor  ``x``  的累积最小值。
 
 .. note::
     结果的第一个元素和输入的第一个元素相同。
@@ -18,8 +18,8 @@ cummin
     - **name** (str，可选) - 具体用法请参见  :ref:`api_guide_Name` ，一般无需设置，默认值为 None。
 返回
 ::::::::::
-    - ``out`` (Tensor)：返回累积最小值操作的结果，累积最小值结果类型和输入 x 相同。
-    - ``indices`` (Tensor)：返回对应累积最小值操作的的索引结果。
+    -  ``out``  (Tensor)：返回累积最小值操作的结果，累积最小值结果类型和输入 x 相同。
+    -  ``indices``  (Tensor)：返回对应累积最小值操作的的索引结果。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/cumprod_cn.rst b/docs/api/paddle/cumprod_cn.rst
index 28aea6a3ed1..0f875a5ca0b 100644
--- a/docs/api/paddle/cumprod_cn.rst
+++ b/docs/api/paddle/cumprod_cn.rst
@@ -7,7 +7,7 @@ cumprod
 
 
 
-沿给定维度 ``dim`` 计算输入 tensor ``x`` 的累乘。
+沿给定维度  ``dim``  计算输入 tensor  ``x``  的累乘。
 
 .. note::
     结果的第一个元素和输入的第一个元素相同。
@@ -21,7 +21,7 @@ cumprod
 
 返回
 :::::::::
-``Tensor``，累乘操作的结果。
+ ``Tensor`` ，累乘操作的结果。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/cumsum_cn.rst b/docs/api/paddle/cumsum_cn.rst
index 770ff62b70a..2ea064632f0 100644
--- a/docs/api/paddle/cumsum_cn.rst
+++ b/docs/api/paddle/cumsum_cn.rst
@@ -7,28 +7,28 @@ cumsum
 
 
 
-沿给定 ``axis`` 计算 Tensor ``x`` 的累加和。
+沿给定  ``axis``  计算 Tensor  ``x``  的累加和。
 
 **注意**：结果的第一个元素和输入的第一个元素相同。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x`` 和 ``dim`` 可替代 ``axis``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``， ``dim=2`` 等价于 ``axis=2``。
+    别名支持: 参数名  ``input``  可替代  ``x``  和  ``dim``  可替代  ``axis`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` ，  ``dim=2``  等价于  ``axis=2`` 。
 
 参数
 :::::::::
-    - **x** (Tensor) - 累加的输入，需要进行累加操作的 Tensor。别名 ``input``。
-    - **axis** (int，可选) - 指明需要累加的维度。-1 代表最后一维。默认：None，将输入展开为一维变量再进行累加计算。别名 ``dim``。
+    - **x** (Tensor) - 累加的输入，需要进行累加操作的 Tensor。别名  ``input`` 。
+    - **axis** (int，可选) - 指明需要累加的维度。-1 代表最后一维。默认：None，将输入展开为一维变量再进行累加计算。别名  ``dim`` 。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，支持 int32、int64、bfloat16、float16、float32、float64、complex64、complex128。当输入 `x` 的类型是 int8/int16/int32 时，默认值是 int64；否则默认值是 None。如果不为 None，那么在执行操作之前，输入 Tensor 将被转换为 dtype。这对于防止数据类型溢出非常有用。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 返回
 :::::::::
-``Tensor``，累加的结果。
+ ``Tensor`` ，累加的结果。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/cumulative_trapezoid_cn.rst b/docs/api/paddle/cumulative_trapezoid_cn.rst
index 3636f1c4838..8dfd6cf47e6 100644
--- a/docs/api/paddle/cumulative_trapezoid_cn.rst
+++ b/docs/api/paddle/cumulative_trapezoid_cn.rst
@@ -12,13 +12,13 @@ cumulative_trapezoid
 :::::::::
 
     - **y** (Tensor) - 输入多维 Tensor，可选的数据类型为 float16、float32、float64。
-    - **x** (Tensor，可选) - ``y`` 中数值对应的浮点数所组成的 Tensor，类型与 ``y`` 相同，形状与 ``y`` 的形状相匹配；若 ``x`` 有输入，已知 ``y`` 的尺寸为 `[d_1, d_2, ... , d_n]` 且 `axis=k`，则 ``x`` 的尺寸只能为 `[d_k]` 或 `[d_1, d_2, ... , d_n]`；如果 ``x`` 为 None，则假定采样点均匀分布 ``dx``。
-    - **dx** (float，可选) - 相邻采样点之间的常数间隔；当 ``x`` 和 ``dx`` 均未指定时，``dx`` 默认为 1.0。
-    - **axis** (int，可选) - 计算 trapezoid rule 时 ``y`` 的维度。默认值 -1。
+    - **x** (Tensor，可选) -  ``y``  中数值对应的浮点数所组成的 Tensor，类型与  ``y``  相同，形状与  ``y``  的形状相匹配；若  ``x``  有输入，已知  ``y``  的尺寸为 `[d_1, d_2, ... , d_n]` 且 `axis=k`，则  ``x``  的尺寸只能为 `[d_k]` 或 `[d_1, d_2, ... , d_n]`；如果  ``x``  为 None，则假定采样点均匀分布  ``dx`` 。
+    - **dx** (float，可选) - 相邻采样点之间的常数间隔；当  ``x``  和  ``dx``  均未指定时， ``dx``  默认为 1.0。
+    - **axis** (int，可选) - 计算 trapezoid rule 时  ``y``  的维度。默认值 -1。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 返回
 :::::::::
-Tensor，按 trapezoidal rule 计算出 ``y`` 等于 N 维张量时的定积分，结果为 N 维张量。
+Tensor，按 trapezoidal rule 计算出  ``y``  等于 N 维张量时的定积分，结果为 N 维张量。
 
 
 代码示例
diff --git a/docs/api/paddle/deg2rad_cn.rst b/docs/api/paddle/deg2rad_cn.rst
index ed90d946542..4b9390e97fd 100644
--- a/docs/api/paddle/deg2rad_cn.rst
+++ b/docs/api/paddle/deg2rad_cn.rst
@@ -20,7 +20,7 @@ deg2rad
 返回
 :::::::::
 
-输出 Tensor，与 ``x`` 维度相同、数据类型相同（输入为 int 时，输出数据类型为 float32）。
+输出 Tensor，与  ``x``  维度相同、数据类型相同（输入为 int 时，输出数据类型为 float32）。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/device/IPUPlace_cn.rst b/docs/api/paddle/device/IPUPlace_cn.rst
index 1e23c4cd425..338a44f3d8f 100644
--- a/docs/api/paddle/device/IPUPlace_cn.rst
+++ b/docs/api/paddle/device/IPUPlace_cn.rst
@@ -8,7 +8,7 @@ IPUPlace
 
 
 
-``IPUPlace`` 是一个设备描述符，指定 ``IPUPlace`` 则模型将会运行在该设备上。
+ ``IPUPlace``  是一个设备描述符，指定  ``IPUPlace``  则模型将会运行在该设备上。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/device/Overview_cn.rst b/docs/api/paddle/device/Overview_cn.rst
index 2807177a593..c91a5ddf43b 100644
--- a/docs/api/paddle/device/Overview_cn.rst
+++ b/docs/api/paddle/device/Overview_cn.rst
@@ -42,12 +42,12 @@ paddle.device 目录下包含 cuda 目录和 xpu 目录， cuda 目录中存放
     :header: "API 名称", "API 功能"
     :widths: 10, 30
 
-    " :ref:`is_compiled_with_cinn <cn_api_paddle_device_is_compiled_with_cinn>` ", "检查 ``whl`` 包是否可以被用来在 CINN 上运行模型"
-    " :ref:`is_compiled_with_cuda <cn_api_paddle_device_is_compiled_with_cuda>` ", "检查 ``whl`` 包是否可以被用来在 GPU 上运行模型"
-    " :ref:`is_compiled_with_custom_device <cn_api_paddle_device_is_compiled_with_custom_device>` ", "检查 ``whl`` 包是否可以被用来在指定类型的自定义新硬件上运行模型"
-    " :ref:`is_compiled_with_ipu <cn_api_paddle_device_is_compiled_with_ipu>` ", "检查 ``whl`` 包是否可以被用来在 Graphcore IPU 上运行模型"
-    " :ref:`is_compiled_with_rocm <cn_api_paddle_device_is_compiled_with_rocm>` ", "检查 ``whl`` 包是否可以被用来在 AMD 或海光 GPU(ROCm) 上运行模型"
-    " :ref:`is_compiled_with_xpu <cn_api_paddle_device_is_compiled_with_xpu>` ", "检查 ``whl`` 包是否可以被用来在 Baidu Kunlun XPU 上运行模型"
+    " :ref:`is_compiled_with_cinn <cn_api_paddle_device_is_compiled_with_cinn>` ", "检查  ``whl``  包是否可以被用来在 CINN 上运行模型"
+    " :ref:`is_compiled_with_cuda <cn_api_paddle_device_is_compiled_with_cuda>` ", "检查  ``whl``  包是否可以被用来在 GPU 上运行模型"
+    " :ref:`is_compiled_with_custom_device <cn_api_paddle_device_is_compiled_with_custom_device>` ", "检查  ``whl``  包是否可以被用来在指定类型的自定义新硬件上运行模型"
+    " :ref:`is_compiled_with_ipu <cn_api_paddle_device_is_compiled_with_ipu>` ", "检查  ``whl``  包是否可以被用来在 Graphcore IPU 上运行模型"
+    " :ref:`is_compiled_with_rocm <cn_api_paddle_device_is_compiled_with_rocm>` ", "检查  ``whl``  包是否可以被用来在 AMD 或海光 GPU(ROCm) 上运行模型"
+    " :ref:`is_compiled_with_xpu <cn_api_paddle_device_is_compiled_with_xpu>` ", "检查  ``whl``  包是否可以被用来在 Baidu Kunlun XPU 上运行模型"
 
 .. _cn_device_descriptor:
 
@@ -58,8 +58,8 @@ paddle.device 目录下包含 cuda 目录和 xpu 目录， cuda 目录中存放
     :header: "API 名称", "API 功能"
     :widths: 10, 30
 
-    " :ref:`IPUPlace <cn_api_paddle_device_IPUPlace>` ", "``IPUPlace`` 是一个设备描述符，指定 ``IPUPlace`` 则模型将会运行在该设备上"
-    " :ref:`XPUPlace <cn_api_paddle_device_XPUPlace>` ", "``XPUPlace`` 是一个设备描述符，表示一个分配或将要分配 ``Tensor`` 的 Baidu Kunlun XPU 设备"
+    " :ref:`IPUPlace <cn_api_paddle_device_IPUPlace>` ", " ``IPUPlace``  是一个设备描述符，指定  ``IPUPlace``  则模型将会运行在该设备上"
+    " :ref:`XPUPlace <cn_api_paddle_device_XPUPlace>` ", " ``XPUPlace``  是一个设备描述符，表示一个分配或将要分配  ``Tensor``  的 Baidu Kunlun XPU 设备"
 
 .. _cn_device_stream_event:
 
@@ -70,8 +70,8 @@ Stream 与 Event 辅助类
     :header: "类名称", "辅助类功能"
     :widths: 10, 30
 
-    " :ref:`Stream <cn_api_paddle_device_Stream>` ", "``StreamBase`` 的设备流包装器"
-    " :ref:`Event <cn_api_paddle_device_Event>` ", "``StreamBase`` 的设备事件包装器"
+    " :ref:`Stream <cn_api_paddle_device_Stream>` ", " ``StreamBase``  的设备流包装器"
+    " :ref:`Event <cn_api_paddle_device_Event>` ", " ``StreamBase``  的设备事件包装器"
 
 
 .. _cn_device_stream_event_api:
@@ -99,8 +99,8 @@ CUDA 相关
     :header: "API 名称", "API 功能"
     :widths: 10, 30
 
-    " :ref:`Stream <cn_api_paddle_device_cuda_Stream>` ", "CUDA ``StreamBase`` 的设备流包装器，该 API 未来计划废弃，不推荐使用"
-    " :ref:`Event <cn_api_paddle_device_cuda_Event>` ", "CUDA ``StreamBase`` 的设备事件包装器，该 API 未来计划废弃，不推荐使用"
+    " :ref:`Stream <cn_api_paddle_device_cuda_Stream>` ", "CUDA  ``StreamBase``  的设备流包装器，该 API 未来计划废弃，不推荐使用"
+    " :ref:`Event <cn_api_paddle_device_cuda_Event>` ", "CUDA  ``StreamBase``  的设备事件包装器，该 API 未来计划废弃，不推荐使用"
     " :ref:`current_stream <cn_api_paddle_device_cuda_current_stream>` ", "通过 device 返回当前的 CUDA stream"
     " :ref:`device_count <cn_api_paddle_device_cuda_device_count>` ", "返回值是 int，表示当前程序可用的 GPU 数量"
     " :ref:`empty_cache <cn_api_paddle_device_cuda_empty_cache>` ", "用于释放显存分配器中空闲的显存"
@@ -126,8 +126,8 @@ XPU 相关
     :header: "API 名称", "API 功能"
     :widths: 10, 30
 
-    " :ref:`Stream <cn_api_paddle_device_xpu_Stream>` ", "XPU ``StreamBase`` 的设备流包装器，该 API 未来计划废弃，不推荐使用"
-    " :ref:`Event <cn_api_paddle_device_xpu_Event>` ", "XPU ``EventBase`` 的设备事件包装器，该 API 未来计划废弃，不推荐使用"
+    " :ref:`Stream <cn_api_paddle_device_xpu_Stream>` ", "XPU  ``StreamBase``  的设备流包装器，该 API 未来计划废弃，不推荐使用"
+    " :ref:`Event <cn_api_paddle_device_xpu_Event>` ", "XPU  ``EventBase``  的设备事件包装器，该 API 未来计划废弃，不推荐使用"
     " :ref:`device_count <cn_api_paddle_device_xpu_device_count>` ", "返回值是 int，表示当前程序可用的 XPU 数量"
     " :ref:`empty_cache <cn_api_paddle_device_xpu_empty_cache>` ", "用于释放显存分配器中空闲的显存"
     " :ref:`max_memory_allocated <cn_api_paddle_device_xpu_max_memory_allocated>` ", "返回给定设备上分配给 Tensor 的显存峰值统计"
diff --git a/docs/api/paddle/device/XPUPlace_cn.rst b/docs/api/paddle/device/XPUPlace_cn.rst
index c266dc587ed..46d0cea017f 100644
--- a/docs/api/paddle/device/XPUPlace_cn.rst
+++ b/docs/api/paddle/device/XPUPlace_cn.rst
@@ -9,14 +9,14 @@ XPUPlace
 
 
 
-``XPUPlace`` 是一个设备描述符，表示一个分配或将要分配 ``Tensor`` 的 Baidu Kunlun XPU 设备。
-每个 ``XPUPlace`` 有一个 ``dev_id`` （设备 id）来表明当前的 ``XPUPlace`` 所代表的显卡编号，编号从 0 开始。
-``dev_id`` 不同的 ``XPUPlace`` 所对应的内存不可相互访问。
+ ``XPUPlace``  是一个设备描述符，表示一个分配或将要分配  ``Tensor``  的 Baidu Kunlun XPU 设备。
+每个  ``XPUPlace``  有一个  ``dev_id``  （设备 id）来表明当前的  ``XPUPlace``  所代表的显卡编号，编号从 0 开始。
+ ``dev_id``  不同的  ``XPUPlace``  所对应的内存不可相互访问。
 
 参数
 ::::::::::::
 
-  - **id** (int，可选) - XPU 的设备 ID。如果为 ``None``，则默认会使用 id 为 0 的设备。默认值为 ``None``。
+  - **id** (int，可选) - XPU 的设备 ID。如果为  ``None`` ，则默认会使用 id 为 0 的设备。默认值为  ``None`` 。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/device/cuda/empty_cache_cn.rst b/docs/api/paddle/device/cuda/empty_cache_cn.rst
index 0737b494387..3c87af01b66 100644
--- a/docs/api/paddle/device/cuda/empty_cache_cn.rst
+++ b/docs/api/paddle/device/cuda/empty_cache_cn.rst
@@ -6,7 +6,7 @@ empty_cache
 .. py:function:: paddle.device.cuda.empty_cache()
 
 
-该函数用于释放显存分配器中空闲的显存，这样其他的 GPU 应用程序就可以使用释放出来的显存，并在 ``nvidia-smi`` 中可见。大多数情况下您不需要使用该函数，当您删除 GPU 上的 Tensor 时，Paddle 框架并不会将显存释放，而是将显存保留起来，以便在下一次申明显存时可以更快的完成分配。
+该函数用于释放显存分配器中空闲的显存，这样其他的 GPU 应用程序就可以使用释放出来的显存，并在  ``nvidia-smi``  中可见。大多数情况下您不需要使用该函数，当您删除 GPU 上的 Tensor 时，Paddle 框架并不会将显存释放，而是将显存保留起来，以便在下一次申明显存时可以更快的完成分配。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/device/cuda/get_device_properties_cn.rst b/docs/api/paddle/device/cuda/get_device_properties_cn.rst
index e044387783f..559a767c260 100644
--- a/docs/api/paddle/device/cuda/get_device_properties_cn.rst
+++ b/docs/api/paddle/device/cuda/get_device_properties_cn.rst
@@ -10,7 +10,7 @@ get_device_properties
 参数
 ::::::::
 
-    - **device** (paddle.CUDAPlace or int or str) - 设备、设备 ID 和类似于 ``gpu:x`` 的设备名称。如果 ``device`` 为空，则 ``device`` 为当前的设备。默认值为 None。
+    - **device** (paddle.CUDAPlace or int or str) - 设备、设备 ID 和类似于  ``gpu:x``  的设备名称。如果  ``device``  为空，则  ``device``  为当前的设备。默认值为 None。
 
 
 返回
diff --git a/docs/api/paddle/device/cuda/max_memory_allocated_cn.rst b/docs/api/paddle/device/cuda/max_memory_allocated_cn.rst
index 4076e94b21d..584dfc6e5d0 100644
--- a/docs/api/paddle/device/cuda/max_memory_allocated_cn.rst
+++ b/docs/api/paddle/device/cuda/max_memory_allocated_cn.rst
@@ -13,7 +13,7 @@ max_memory_allocated
 参数
 ::::::::
 
-    - **device** (paddle.CUDAPlace|int|str，可选) - 设备、设备 ID 或形如 ``gpu:x`` 的设备名称。如果 ``device`` 为 None，则 ``device`` 为当前的设备。默认值为 None。
+    - **device** (paddle.CUDAPlace|int|str，可选) - 设备、设备 ID 或形如  ``gpu:x``  的设备名称。如果  ``device``  为 None，则  ``device``  为当前的设备。默认值为 None。
 
 
 返回
diff --git a/docs/api/paddle/device/cuda/max_memory_reserved_cn.rst b/docs/api/paddle/device/cuda/max_memory_reserved_cn.rst
index 9b26a9a1d24..50db203d2a5 100644
--- a/docs/api/paddle/device/cuda/max_memory_reserved_cn.rst
+++ b/docs/api/paddle/device/cuda/max_memory_reserved_cn.rst
@@ -10,7 +10,7 @@ max_memory_reserved
 参数
 ::::::::
 
-    - **device** (paddle.CUDAPlace|int|str，可选) - 设备、设备 ID 或形如 ``gpu:x`` 的设备名称。如果 ``device`` 为 None，则 ``device`` 为当前的设备。默认值为 None。
+    - **device** (paddle.CUDAPlace|int|str，可选) - 设备、设备 ID 或形如  ``gpu:x``  的设备名称。如果  ``device``  为 None，则  ``device``  为当前的设备。默认值为 None。
 
 
 返回
diff --git a/docs/api/paddle/device/cuda/memory_allocated_cn.rst b/docs/api/paddle/device/cuda/memory_allocated_cn.rst
index 91404a5e0dc..1ee6bb4fc24 100644
--- a/docs/api/paddle/device/cuda/memory_allocated_cn.rst
+++ b/docs/api/paddle/device/cuda/memory_allocated_cn.rst
@@ -13,7 +13,7 @@ memory_allocated
 参数
 ::::::::
 
-    - **device** (paddle.CUDAPlace|int|str，可选) - 设备、设备 ID 或形如 ``gpu:x`` 的设备名称。如果 ``device`` 为 None，则 ``device`` 为当前的设备。默认值为 None。
+    - **device** (paddle.CUDAPlace|int|str，可选) - 设备、设备 ID 或形如  ``gpu:x``  的设备名称。如果  ``device``  为 None，则  ``device``  为当前的设备。默认值为 None。
 
 
 返回
diff --git a/docs/api/paddle/device/cuda/memory_reserved_cn.rst b/docs/api/paddle/device/cuda/memory_reserved_cn.rst
index 7e58e4ee816..70d794df760 100644
--- a/docs/api/paddle/device/cuda/memory_reserved_cn.rst
+++ b/docs/api/paddle/device/cuda/memory_reserved_cn.rst
@@ -10,7 +10,7 @@ memory_reserved
 参数
 ::::::::
 
-    - **device** (paddle.CUDAPlace|int|str，可选) - 设备、设备 ID 或形如 ``gpu:x`` 的设备名称。如果 ``device`` 为 None，则 ``device`` 为当前的设备。默认值为 None。
+    - **device** (paddle.CUDAPlace|int|str，可选) - 设备、设备 ID 或形如  ``gpu:x``  的设备名称。如果  ``device``  为 None，则  ``device``  为当前的设备。默认值为 None。
 
 
 返回
diff --git a/docs/api/paddle/device/cuda/reset_max_memory_allocated_cn.rst b/docs/api/paddle/device/cuda/reset_max_memory_allocated_cn.rst
index 776153197e7..ed47ffa8367 100644
--- a/docs/api/paddle/device/cuda/reset_max_memory_allocated_cn.rst
+++ b/docs/api/paddle/device/cuda/reset_max_memory_allocated_cn.rst
@@ -10,7 +10,7 @@ reset_max_memory_allocated
 参数
 ::::::::
 
-    - **device** (paddle.CUDAPlace|int|str，可选) - 设备、设备 ID 或形如 ``gpu:x`` 的设备名称。如果 ``device`` 为 None，则 ``device`` 为当前的设备。默认值为 None。
+    - **device** (paddle.CUDAPlace|int|str，可选) - 设备、设备 ID 或形如  ``gpu:x``  的设备名称。如果  ``device``  为 None，则  ``device``  为当前的设备。默认值为 None。
 
 
 返回
diff --git a/docs/api/paddle/device/cuda/reset_max_memory_reserved_cn.rst b/docs/api/paddle/device/cuda/reset_max_memory_reserved_cn.rst
index 51adbbb1b4b..db330924325 100644
--- a/docs/api/paddle/device/cuda/reset_max_memory_reserved_cn.rst
+++ b/docs/api/paddle/device/cuda/reset_max_memory_reserved_cn.rst
@@ -10,7 +10,7 @@ reset_max_memory_reserved
 参数
 ::::::::
 
-    - **device** (paddle.CUDAPlace|int|str，可选) - 设备、设备 ID 或形如 ``gpu:x`` 的设备名称。如果 ``device`` 为 None，则 ``device`` 为当前的设备。默认值为 None。
+    - **device** (paddle.CUDAPlace|int|str，可选) - 设备、设备 ID 或形如  ``gpu:x``  的设备名称。如果  ``device``  为 None，则  ``device``  为当前的设备。默认值为 None。
 
 
 返回
diff --git a/docs/api/paddle/device/get_device_cn.rst b/docs/api/paddle/device/get_device_cn.rst
index cb2d3f9ff93..e7c9c6785e7 100644
--- a/docs/api/paddle/device/get_device_cn.rst
+++ b/docs/api/paddle/device/get_device_cn.rst
@@ -6,7 +6,7 @@ get_device
 .. py:function:: paddle.device.get_device()
 
 
-该功能返回当前程序运行的全局设备，返回的是一个类似于 ``cpu``、 ``gpu:x``、 ``xpu:x``、 ``mlu:x`` 或者 ``npu:x`` 字符串，如果没有设置全局设备，当 cuda 可用的时候返回 ``gpu:0``，当 cuda 不可用的时候返回 ``cpu`` 。
+该功能返回当前程序运行的全局设备，返回的是一个类似于  ``cpu`` 、  ``gpu:x`` 、  ``xpu:x`` 、  ``mlu:x``  或者  ``npu:x``  字符串，如果没有设置全局设备，当 cuda 可用的时候返回  ``gpu:0`` ，当 cuda 不可用的时候返回  ``cpu``  。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/device/is_compiled_with_cinn_cn.rst b/docs/api/paddle/device/is_compiled_with_cinn_cn.rst
index 04b3d63886e..29f58a8b38e 100644
--- a/docs/api/paddle/device/is_compiled_with_cinn_cn.rst
+++ b/docs/api/paddle/device/is_compiled_with_cinn_cn.rst
@@ -5,7 +5,7 @@ is_compiled_with_cinn
 
 .. py:function:: paddle.device.is_compiled_with_cinn()
 
-检查 ``whl`` 包是否可以被用来在 CINN 上运行模型。
+检查  ``whl``  包是否可以被用来在 CINN 上运行模型。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/device/is_compiled_with_cuda_cn.rst b/docs/api/paddle/device/is_compiled_with_cuda_cn.rst
index ed6aa49ae49..d2d6e14d571 100644
--- a/docs/api/paddle/device/is_compiled_with_cuda_cn.rst
+++ b/docs/api/paddle/device/is_compiled_with_cuda_cn.rst
@@ -8,7 +8,7 @@ is_compiled_with_cuda
 
 
 
-检查 ``whl`` 包是否可以被用来在 GPU 上运行模型。
+检查  ``whl``  包是否可以被用来在 GPU 上运行模型。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/device/is_compiled_with_custom_device_cn.rst b/docs/api/paddle/device/is_compiled_with_custom_device_cn.rst
index 0c072154ace..c88b36a5eeb 100644
--- a/docs/api/paddle/device/is_compiled_with_custom_device_cn.rst
+++ b/docs/api/paddle/device/is_compiled_with_custom_device_cn.rst
@@ -5,7 +5,7 @@ is_compiled_with_custom_device
 
 .. py:function:: paddle.device.is_compiled_with_custom_device(device_type)
 
-检查 ``whl`` 包是否可以被用来在指定类型的自定义新硬件上运行模型
+检查  ``whl``  包是否可以被用来在指定类型的自定义新硬件上运行模型
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/device/is_compiled_with_ipu_cn.rst b/docs/api/paddle/device/is_compiled_with_ipu_cn.rst
index 7442cc58728..2f0c9c316a3 100644
--- a/docs/api/paddle/device/is_compiled_with_ipu_cn.rst
+++ b/docs/api/paddle/device/is_compiled_with_ipu_cn.rst
@@ -8,7 +8,7 @@ is_compiled_with_ipu
 
 
 
-检查 ``whl`` 包是否可以被用来在 Graphcore IPU 上运行模型
+检查  ``whl``  包是否可以被用来在 Graphcore IPU 上运行模型
 
 返回
 ::::::::::
diff --git a/docs/api/paddle/device/is_compiled_with_rocm_cn.rst b/docs/api/paddle/device/is_compiled_with_rocm_cn.rst
index 4e8535a7930..d0ff6b40599 100644
--- a/docs/api/paddle/device/is_compiled_with_rocm_cn.rst
+++ b/docs/api/paddle/device/is_compiled_with_rocm_cn.rst
@@ -8,7 +8,7 @@ is_compiled_with_rocm
 
 
 
-检查 ``whl`` 包是否可以被用来在 AMD 或海光 GPU(ROCm)上运行模型。
+检查  ``whl``  包是否可以被用来在 AMD 或海光 GPU(ROCm)上运行模型。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/device/is_compiled_with_xpu_cn.rst b/docs/api/paddle/device/is_compiled_with_xpu_cn.rst
index 8541779f272..b3f1fda57bd 100644
--- a/docs/api/paddle/device/is_compiled_with_xpu_cn.rst
+++ b/docs/api/paddle/device/is_compiled_with_xpu_cn.rst
@@ -8,7 +8,7 @@ is_compiled_with_xpu
 
 
 
-检查 ``whl`` 包是否可以被用来在 Baidu Kunlun XPU 上运行模型。
+检查  ``whl``  包是否可以被用来在 Baidu Kunlun XPU 上运行模型。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/device/set_device_cn.rst b/docs/api/paddle/device/set_device_cn.rst
index 9f7385a13ae..f0748f5cbe2 100644
--- a/docs/api/paddle/device/set_device_cn.rst
+++ b/docs/api/paddle/device/set_device_cn.rst
@@ -11,7 +11,7 @@ Paddle 支持包括 CPU 和 GPU 在内的多种设备运行，设备可以通过
 参数
 ::::::::::::
 
-    - **device** (str)- 此参数确定特定的运行设备，它可以是 ``cpu``、 ``gpu``、 ``xpu``、 ``mlu``、 ``npu``、 ``gpu:x``、 ``xpu:x``、 ``mlu:x`` 或者是 ``npu:x``。其中，``x`` 是 GPU、 XPU、 MLU 或者是 NPU 的编号。当 ``device`` 是 ``cpu`` 的时候，程序在 CPU 上运行，当 device 是 ``gpu:x`` 的时候，程序在 GPU 上运行，当 device 是 ``mlu:x`` 的时候，程序在 MLU 上运行，当 device 是 ``npu:x`` 的时候，程序在 NPU 上运行。
+    - **device** (str)- 此参数确定特定的运行设备，它可以是  ``cpu`` 、  ``gpu`` 、  ``xpu`` 、  ``mlu`` 、  ``npu`` 、  ``gpu:x`` 、  ``xpu:x`` 、  ``mlu:x``  或者是  ``npu:x`` 。其中， ``x``  是 GPU、 XPU、 MLU 或者是 NPU 的编号。当  ``device``  是  ``cpu``  的时候，程序在 CPU 上运行，当 device 是  ``gpu:x``  的时候，程序在 GPU 上运行，当 device 是  ``mlu:x``  的时候，程序在 MLU 上运行，当 device 是  ``npu:x``  的时候，程序在 NPU 上运行。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/device/xpu/empty_cache_cn.rst b/docs/api/paddle/device/xpu/empty_cache_cn.rst
index 02062cb1a9c..8146f3580a8 100644
--- a/docs/api/paddle/device/xpu/empty_cache_cn.rst
+++ b/docs/api/paddle/device/xpu/empty_cache_cn.rst
@@ -6,7 +6,7 @@ empty_cache
 .. py:function:: paddle.device.xpu.empty_cache()
 
 
-该函数用于释放显存分配器中空闲的显存，这样其他的 XPU 应用程序就可以使用释放出来的显存，并在 ``xpu-smi`` 中可见。大多数情况下您不需要使用该函数，当您删除 XPU 上的 Tensor 时，Paddle 框架并不会将显存释放，而是将显存保留起来，以便在下一次申明显存时可以更快的完成分配。
+该函数用于释放显存分配器中空闲的显存，这样其他的 XPU 应用程序就可以使用释放出来的显存，并在  ``xpu-smi``  中可见。大多数情况下您不需要使用该函数，当您删除 XPU 上的 Tensor 时，Paddle 框架并不会将显存释放，而是将显存保留起来，以便在下一次申明显存时可以更快的完成分配。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/device/xpu/max_memory_allocated_cn.rst b/docs/api/paddle/device/xpu/max_memory_allocated_cn.rst
index 8d9af61dce9..922ae1cc17d 100644
--- a/docs/api/paddle/device/xpu/max_memory_allocated_cn.rst
+++ b/docs/api/paddle/device/xpu/max_memory_allocated_cn.rst
@@ -13,7 +13,7 @@ max_memory_allocated
 参数
 ::::::::
 
-    - **device** (paddle.XPUPlace|int|str，可选) - 设备、设备 ID 或形如 ``xpu:x`` 的设备名称。如果 ``device`` 为 None，则 ``device`` 为当前的设备。默认值为 None。
+    - **device** (paddle.XPUPlace|int|str，可选) - 设备、设备 ID 或形如  ``xpu:x``  的设备名称。如果  ``device``  为 None，则  ``device``  为当前的设备。默认值为 None。
 
 
 返回
diff --git a/docs/api/paddle/device/xpu/max_memory_reserved_cn.rst b/docs/api/paddle/device/xpu/max_memory_reserved_cn.rst
index 6b854cacc83..3642a594e68 100644
--- a/docs/api/paddle/device/xpu/max_memory_reserved_cn.rst
+++ b/docs/api/paddle/device/xpu/max_memory_reserved_cn.rst
@@ -10,7 +10,7 @@ max_memory_reserved
 参数
 ::::::::
 
-    - **device** (paddle.XPUPlace|int|str，可选) - 设备、设备 ID 或形如 ``xpu:x`` 的设备名称。如果 ``device`` 为 None，则 ``device`` 为当前的设备。默认值为 None。
+    - **device** (paddle.XPUPlace|int|str，可选) - 设备、设备 ID 或形如  ``xpu:x``  的设备名称。如果  ``device``  为 None，则  ``device``  为当前的设备。默认值为 None。
 
 
 返回
diff --git a/docs/api/paddle/device/xpu/memory_allocated_cn.rst b/docs/api/paddle/device/xpu/memory_allocated_cn.rst
index 837831c5380..2cc623222e3 100644
--- a/docs/api/paddle/device/xpu/memory_allocated_cn.rst
+++ b/docs/api/paddle/device/xpu/memory_allocated_cn.rst
@@ -13,7 +13,7 @@ memory_allocated
 参数
 ::::::::
 
-    - **device** (paddle.XPUPlace|int|str，可选) - 设备、设备 ID 或形如 ``xpu:x`` 的设备名称。如果 ``device`` 为 None，则 ``device`` 为当前的设备。默认值为 None。
+    - **device** (paddle.XPUPlace|int|str，可选) - 设备、设备 ID 或形如  ``xpu:x``  的设备名称。如果  ``device``  为 None，则  ``device``  为当前的设备。默认值为 None。
 
 
 返回
diff --git a/docs/api/paddle/device/xpu/memory_reserved_cn.rst b/docs/api/paddle/device/xpu/memory_reserved_cn.rst
index cc5649e7532..b25616e6eeb 100644
--- a/docs/api/paddle/device/xpu/memory_reserved_cn.rst
+++ b/docs/api/paddle/device/xpu/memory_reserved_cn.rst
@@ -10,7 +10,7 @@ memory_reserved
 参数
 ::::::::
 
-    - **device** (paddle.XPUPlace|int|str，可选) - 设备、设备 ID 或形如 ``xpu:x`` 的设备名称。如果 ``device`` 为 None，则 ``device`` 为当前的设备。默认值为 None。
+    - **device** (paddle.XPUPlace|int|str，可选) - 设备、设备 ID 或形如  ``xpu:x``  的设备名称。如果  ``device``  为 None，则  ``device``  为当前的设备。默认值为 None。
 
 
 返回
diff --git a/docs/api/paddle/device/xpu/memory_total_cn.rst b/docs/api/paddle/device/xpu/memory_total_cn.rst
index 7c2a946bb8a..19fef6cc50a 100644
--- a/docs/api/paddle/device/xpu/memory_total_cn.rst
+++ b/docs/api/paddle/device/xpu/memory_total_cn.rst
@@ -10,7 +10,7 @@ memory_total
 参数
 ::::::::
 
-    - **device** (paddle.XPUPlace|int|str，可选) - 设备、设备 ID 或形如 ``xpu:x`` 的设备名称。如果 ``device`` 为 None，则 ``device`` 为当前的设备。默认值为 None。
+    - **device** (paddle.XPUPlace|int|str，可选) - 设备、设备 ID 或形如  ``xpu:x``  的设备名称。如果  ``device``  为 None，则  ``device``  为当前的设备。默认值为 None。
 
 
 返回
diff --git a/docs/api/paddle/device/xpu/memory_used_cn.rst b/docs/api/paddle/device/xpu/memory_used_cn.rst
index 1f1fb0e73f0..b5897267dff 100644
--- a/docs/api/paddle/device/xpu/memory_used_cn.rst
+++ b/docs/api/paddle/device/xpu/memory_used_cn.rst
@@ -13,7 +13,7 @@ memory_used
 参数
 ::::::::
 
-    - **device** (paddle.XPUPlace|int|str，可选) - 设备、设备 ID 或形如 ``xpu:x`` 的设备名称。如果 ``device`` 为 None，则 ``device`` 为当前的设备。默认值为 None。
+    - **device** (paddle.XPUPlace|int|str，可选) - 设备、设备 ID 或形如  ``xpu:x``  的设备名称。如果  ``device``  为 None，则  ``device``  为当前的设备。默认值为 None。
 
 
 返回
diff --git a/docs/api/paddle/device/xpu/reset_max_memory_allocated_cn.rst b/docs/api/paddle/device/xpu/reset_max_memory_allocated_cn.rst
index 981ab19e05c..bb1573a989c 100644
--- a/docs/api/paddle/device/xpu/reset_max_memory_allocated_cn.rst
+++ b/docs/api/paddle/device/xpu/reset_max_memory_allocated_cn.rst
@@ -10,7 +10,7 @@ reset_max_memory_allocated
 参数
 ::::::::
 
-    - **device** (paddle.XPUPlace|int|str，可选) - 设备、设备 ID 或形如 ``xpu:x`` 的设备名称。如果 ``device`` 为 None，则 ``device`` 为当前的设备。默认值为 None。
+    - **device** (paddle.XPUPlace|int|str，可选) - 设备、设备 ID 或形如  ``xpu:x``  的设备名称。如果  ``device``  为 None，则  ``device``  为当前的设备。默认值为 None。
 
 
 返回
diff --git a/docs/api/paddle/device/xpu/reset_max_memory_reserved_cn.rst b/docs/api/paddle/device/xpu/reset_max_memory_reserved_cn.rst
index b908ba363d9..11a9ca1b621 100644
--- a/docs/api/paddle/device/xpu/reset_max_memory_reserved_cn.rst
+++ b/docs/api/paddle/device/xpu/reset_max_memory_reserved_cn.rst
@@ -10,7 +10,7 @@ reset_max_memory_reserved
 参数
 ::::::::
 
-    - **device** (paddle.XPUPlace|int|str，可选) - 设备、设备 ID 或形如 ``xpu:x`` 的设备名称。如果 ``device`` 为 None，则 ``device`` 为当前的设备。默认值为 None。
+    - **device** (paddle.XPUPlace|int|str，可选) - 设备、设备 ID 或形如  ``xpu:x``  的设备名称。如果  ``device``  为 None，则  ``device``  为当前的设备。默认值为 None。
 
 
 返回
diff --git a/docs/api/paddle/diag_cn.rst b/docs/api/paddle/diag_cn.rst
index f03105b580f..391d84cbbba 100644
--- a/docs/api/paddle/diag_cn.rst
+++ b/docs/api/paddle/diag_cn.rst
@@ -6,15 +6,15 @@ diag
 .. py:function:: paddle.diag(x, offset=0, padding_value=0, name=None)
 
 
-如果 ``x`` 是向量（1-D Tensor），则返回带有 ``x`` 元素作为对角线的 2-D 方阵。
+如果  ``x``  是向量（1-D Tensor），则返回带有  ``x``  元素作为对角线的 2-D 方阵。
 
-如果 ``x`` 是矩阵（2-D Tensor），则提取 ``x`` 的对角线元素，以 1-D Tensor 返回。
+如果  ``x``  是矩阵（2-D Tensor），则提取  ``x``  的对角线元素，以 1-D Tensor 返回。
 
-参数 ``offset`` 控制对角线偏移量：
+参数  ``offset``  控制对角线偏移量：
 
-- 如果 ``offset`` = 0，则为主对角线。
-- 如果 ``offset`` > 0，则为上对角线。
-- 如果 ``offset`` < 0，则为下对角线。
+- 如果  ``offset``  = 0，则为主对角线。
+- 如果  ``offset``  > 0，则为上对角线。
+- 如果  ``offset``  < 0，则为下对角线。
 
 参数
 :::::::::
@@ -25,7 +25,7 @@ diag
 
 返回
 :::::::::
-``Tensor``，方阵或向量。输出数据类型与输入数据类型相同。
+ ``Tensor`` ，方阵或向量。输出数据类型与输入数据类型相同。
 
 
 代码示例 1
diff --git a/docs/api/paddle/diag_embed_cn.rst b/docs/api/paddle/diag_embed_cn.rst
index 7eb0cc8e291..58b2e0e4bfd 100644
--- a/docs/api/paddle/diag_embed_cn.rst
+++ b/docs/api/paddle/diag_embed_cn.rst
@@ -5,9 +5,9 @@ diag_embed
 
 .. py:function:: paddle.diag_embed(input, offset=0, dim1=-2, dim2=-1)
 
-创建一个 Tensor，其在指定的 2D 平面（由 ``dim1`` 和 ``dim2`` 指定）上的对角线由输入 ``input`` 填充。默认的，指定的 2D 平面由返回 Tensor 的最后两维组成。
+创建一个 Tensor，其在指定的 2D 平面（由  ``dim1``  和  ``dim2``  指定）上的对角线由输入  ``input``  填充。默认的，指定的 2D 平面由返回 Tensor 的最后两维组成。
 
-参数 ``offset`` 确定在指定的二维平面中填充对角线的位置：
+参数  ``offset``  确定在指定的二维平面中填充对角线的位置：
 
  - 如果 offset = 0，则填充主对角线。
  - 如果 offset > 0，则填充主对角线右上的对角线。
diff --git a/docs/api/paddle/diagflat_cn.rst b/docs/api/paddle/diagflat_cn.rst
index 5333ab4af3a..39c2b66faa7 100644
--- a/docs/api/paddle/diagflat_cn.rst
+++ b/docs/api/paddle/diagflat_cn.rst
@@ -6,15 +6,15 @@ diagflat
 .. py:function:: paddle.diagflat(x, offset=0, name=None)
 
 
-如果 ``x`` 是一维 Tensor，则返回带有 ``x`` 元素作为对角线的二维方阵。
+如果  ``x``  是一维 Tensor，则返回带有  ``x``  元素作为对角线的二维方阵。
 
-如果 ``x`` 是大于等于二维的 Tensor，则返回一个二维方阵，其对角线元素为 ``x`` 在连续维度展开得到的一维 Tensor 的元素。
+如果  ``x``  是大于等于二维的 Tensor，则返回一个二维方阵，其对角线元素为  ``x``  在连续维度展开得到的一维 Tensor 的元素。
 
-参数 ``offset`` 控制对角线偏移量：
+参数  ``offset``  控制对角线偏移量：
 
-- 如果 ``offset`` = 0，则为主对角线。
-- 如果 ``offset`` > 0，则为上对角线。
-- 如果 ``offset`` < 0，则为下对角线。
+- 如果  ``offset``  = 0，则为主对角线。
+- 如果  ``offset``  > 0，则为上对角线。
+- 如果  ``offset``  < 0，则为下对角线。
 
 参数
 :::::::::
@@ -24,7 +24,7 @@ diagflat
 
 返回
 :::::::::
-``Tensor``，方阵。输出数据类型与输入数据类型相同。
+ ``Tensor`` ，方阵。输出数据类型与输入数据类型相同。
 
 
 代码示例 1
diff --git a/docs/api/paddle/diagonal_scatter_cn.rst b/docs/api/paddle/diagonal_scatter_cn.rst
index 5ec01662d6d..6bddc0b7876 100644
--- a/docs/api/paddle/diagonal_scatter_cn.rst
+++ b/docs/api/paddle/diagonal_scatter_cn.rst
@@ -6,11 +6,11 @@ diagonal_scatter
 .. py:function:: paddle.diagonal_scatter(x, y, offset=0, axis1=0, axis2=1, name=None)
 
 
-根据参数 ``offset``、``axis1``、``axis2``，将张量 ``y`` 填充到张量 ``x`` 的对应位置。
+根据参数  ``offset`` 、 ``axis1`` 、 ``axis2`` ，将张量  ``y``  填充到张量  ``x``  的对应位置。
 
-这个函数将会返回一个新的 ``Tensor``。
+这个函数将会返回一个新的  ``Tensor`` 。
 
-参数 ``offset`` 确定从指定的二维平面中获取对角线的位置：
+参数  ``offset``  确定从指定的二维平面中获取对角线的位置：
 
     - 如果 offset = 0，则嵌入主对角线。
     - 如果 offset > 0，则嵌入主对角线右上的对角线。
@@ -34,7 +34,7 @@ diagonal_scatter
 
 返回
 ::::::::::::
-``Tensor``，返回一个根据给定的轴 ``axis`` 和偏移量 ``offset``，将张量 ``y`` 填充到张量 ``x`` 对应位置的新 ``Tensor``。
+ ``Tensor`` ，返回一个根据给定的轴  ``axis``  和偏移量  ``offset`` ，将张量  ``y``  填充到张量  ``x``  对应位置的新  ``Tensor`` 。
 
 
 代码示例
diff --git a/docs/api/paddle/diff_cn.rst b/docs/api/paddle/diff_cn.rst
index 5072dea83c5..1517b11f860 100644
--- a/docs/api/paddle/diff_cn.rst
+++ b/docs/api/paddle/diff_cn.rst
@@ -14,14 +14,14 @@ diff
     高阶的前向差值可以通过递归的方式进行计算，`n`的值支持任意正整数。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x`` 和 ``dim`` 可替代 ``axis``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``， ``dim=1`` 等价于 ``axis=1``。
+    别名支持: 参数名  ``input``  可替代  ``x``  和  ``dim``  可替代  ``axis`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` ，  ``dim=1``  等价于  ``axis=1`` 。
 
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 待计算前向差值的输入 `Tensor`，支持 bool、int32、int64、float16、float32、float64 数据类型。别名 ``input``。
+    - **x** (Tensor) - 待计算前向差值的输入 `Tensor`，支持 bool、int32、int64、float16、float32、float64 数据类型。别名  ``input`` 。
     - **n** (int，可选) - 需要计算前向差值的次数，`n`的值支持任意正整数，默认值为 1。
-    - **axis** (int，可选) - 沿着哪一维度计算前向差值，默认值为-1，也即最后一个维度。别名 ``dim``。
+    - **axis** (int，可选) - 沿着哪一维度计算前向差值，默认值为-1，也即最后一个维度。别名  ``dim`` 。
     - **prepend** (Tensor，可选) - 在计算前向差值之前，沿着指定维度 axis 附加到输入 x 的前面，它的维度需要和输入一致，并且除了 axis 维外，其他维度的形状也要和输入一致，默认值为 None。
     - **append** (Tensor，可选) - 在计算前向差值之前，沿着指定维度 axis 附加到输入 x 的后面，它的维度需要和输入一致，并且除了 axis 维外，其他维度的形状也要和输入一致，默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
@@ -29,7 +29,7 @@ diff
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/digamma_cn.rst b/docs/api/paddle/digamma_cn.rst
index 61fc8fa12cf..304af7e6a9c 100644
--- a/docs/api/paddle/digamma_cn.rst
+++ b/docs/api/paddle/digamma_cn.rst
@@ -19,7 +19,7 @@ digamma
 
 返回
 :::::::::
-``Tensor``, digamma 函数计算结果，数据类型和维度大小与输入一致。
+ ``Tensor`` , digamma 函数计算结果，数据类型和维度大小与输入一致。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/disable_static_cn.rst b/docs/api/paddle/disable_static_cn.rst
index 497ecc2a0a8..f3a023daa7a 100644
--- a/docs/api/paddle/disable_static_cn.rst
+++ b/docs/api/paddle/disable_static_cn.rst
@@ -14,7 +14,7 @@ disable_static
 参数
 ::::::::::::
 
-  - **place** (paddle.CPUPlace|paddle.CUDAPlace，可选) - 动态图运行时的设备。默认值为 ``None``，此时，会根据 paddle 的版本自动判断。
+  - **place** (paddle.CPUPlace|paddle.CUDAPlace，可选) - 动态图运行时的设备。默认值为  ``None`` ，此时，会根据 paddle 的版本自动判断。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/distributed/ColWiseParallel_cn.rst b/docs/api/paddle/distributed/ColWiseParallel_cn.rst
index 53475808ad1..76d93c50b3b 100644
--- a/docs/api/paddle/distributed/ColWiseParallel_cn.rst
+++ b/docs/api/paddle/distributed/ColWiseParallel_cn.rst
@@ -5,15 +5,15 @@ ColWiseParallel
 
 .. py:class:: paddle.distributed.ColWiseParallel(gather_output=False)
 
-按列切分策略是模型并行中的一个并行策略。本策略会尝试对标识 Layer 的 ``weight`` （如有）在第二维切分，
-对标识 Layer 的 ``bias`` （如有）在第一维度切分。本策略是针对 ``paddle.nn.Linear`` 与 ``paddle.nn.Embedding`` 设计，
-如果标识的 Layer 不属于这两个类，本策略会尝试切分 Layer 中的 ``weight`` 与 ``bias`` （如有）。
+按列切分策略是模型并行中的一个并行策略。本策略会尝试对标识 Layer 的  ``weight``  （如有）在第二维切分，
+对标识 Layer 的  ``bias``  （如有）在第一维度切分。本策略是针对  ``paddle.nn.Linear``  与  ``paddle.nn.Embedding``  设计，
+如果标识的 Layer 不属于这两个类，本策略会尝试切分 Layer 中的  ``weight``  与  ``bias``  （如有）。
 
 
 .. note::
-    ``weight`` 需要有两个纬度。
+     ``weight``  需要有两个纬度。
 
-    ``bias`` 需要有一个纬度。
+     ``bias``  需要有一个纬度。
 
 
 参数
diff --git a/docs/api/paddle/distributed/DistModel_cn.rst b/docs/api/paddle/distributed/DistModel_cn.rst
index f7502bb380f..d6b8b9558e5 100644
--- a/docs/api/paddle/distributed/DistModel_cn.rst
+++ b/docs/api/paddle/distributed/DistModel_cn.rst
@@ -6,22 +6,22 @@ DistModel
 .. py:class:: paddle.distributed.DistModel()
 
 .. note::
-    不推荐直接使用这个 API 生成实例，建议使用 ``paddle.distributed.to_static``。
+    不推荐直接使用这个 API 生成实例，建议使用  ``paddle.distributed.to_static`` 。
 
-DistModel 是一个由 ``paddle.nn.Layer`` 转换而来的静态图模型，其中的参数是分布式张量。DistModel 包含了一个由 ``paddle.nn.Layer`` 转换而来的静态图，并提供了模型训练、评估和推理的 API。
+DistModel 是一个由  ``paddle.nn.Layer``  转换而来的静态图模型，其中的参数是分布式张量。DistModel 包含了一个由  ``paddle.nn.Layer``  转换而来的静态图，并提供了模型训练、评估和推理的 API。
 
-DistModel 通过自身的 ``__call__`` 方法来执行模型训练、评估和推理。在执行对应的流程前，请先使用 ``train()/eval()/predict()`` 方法将 DistModel 设置为对应的模式。
+DistModel 通过自身的  ``__call__``  方法来执行模型训练、评估和推理。在执行对应的流程前，请先使用  ``train()/eval()/predict()``  方法将 DistModel 设置为对应的模式。
 
 详细的使用方法请参考 :ref:`cn_api_paddle_distributed_to_static` API 中的示例代码。
 
 参数
 :::::::::
 
-    - **layer** (paddle.nn.Layer) - 动态图中所使用的 ``paddle.nn.Layer`` 实例，其参数包含由 ``paddle.distributed.shard_tensor`` 生成的分布式张量。
+    - **layer** (paddle.nn.Layer) - 动态图中所使用的  ``paddle.nn.Layer``  实例，其参数包含由  ``paddle.distributed.shard_tensor``  生成的分布式张量。
 
-    - **loader** (paddle.io.DataLoader) - 动态图模式下所使用的 ``paddle.io.DataLoader`` 实例，用于生成静态图训练所需要的 ``DistributedDataloader``。
+    - **loader** (paddle.io.DataLoader) - 动态图模式下所使用的  ``paddle.io.DataLoader``  实例，用于生成静态图训练所需要的  ``DistributedDataloader`` 。
 
-    - **loss** (Loss|Callable|None, 可选) - 损失函数。可以是 ``paddle.nn.Layer`` 实例或任何可调用函数。如果 loss 不为 None，则 DistModel 会默认设置为 "train"（当 optimizer 不为 None 时）或 "eval" 模式（当 optimizer 为 None 时）。如果 loss 为 None，则 DistModel 会默认设置为 "predict" 模式。默认值：None。
+    - **loss** (Loss|Callable|None, 可选) - 损失函数。可以是  ``paddle.nn.Layer``  实例或任何可调用函数。如果 loss 不为 None，则 DistModel 会默认设置为 "train"（当 optimizer 不为 None 时）或 "eval" 模式（当 optimizer 为 None 时）。如果 loss 为 None，则 DistModel 会默认设置为 "predict" 模式。默认值：None。
 
     - **optimizer** (paddle.optimizer.Optimizer|None, 可选) - 优化器。如果同时设置了 optimizer 和 loss，DistModel 会默认设置为 "train" 模式。默认值：None。
 
@@ -40,72 +40,72 @@ COPY-FROM: paddle.distributed.to_static
 train()
 ''''''''
 
-将 DistModel 设置为 "train" 模式。在 "train" 模式下，执行 ``__call__`` 方法会更新模型的参数并返回 loss。
+将 DistModel 设置为 "train" 模式。在 "train" 模式下，执行  ``__call__``  方法会更新模型的参数并返回 loss。
 
 
 eval()
 '''''''
 
-将 DistModel 设置为 "eval" 模式。在 "eval" 模式下，执行 ``__call__`` 方法会返回 loss。
+将 DistModel 设置为 "eval" 模式。在 "eval" 模式下，执行  ``__call__``  方法会返回 loss。
 
 
 predict()
 '''''''
 
-将 DistModel 设置为 "predict" 模式。在 "predict" 模式下，执行 ``__call__`` 方法会以字典的格式返回模型的输出。
+将 DistModel 设置为 "predict" 模式。在 "predict" 模式下，执行  ``__call__``  方法会以字典的格式返回模型的输出。
 
 
 dist_main_program(mode=None)
 '''''''
 
-获取指定 ``mode`` 的分布式 ``main_program``。 ``main_program`` 用于存储模型中变量和计算的描述信息。分布式 ``main_program`` 存储了每个进程上局部模型的描述信息。每个 ``mode`` 都有自己的分布式 ``main_program``，用于执行模型的训练、评估或推理。 ``dist_main_program`` 返回指定 ``mode`` 的对应分布式 ``main_program``。
+获取指定  ``mode``  的分布式  ``main_program`` 。  ``main_program``  用于存储模型中变量和计算的描述信息。分布式  ``main_program``  存储了每个进程上局部模型的描述信息。每个  ``mode``  都有自己的分布式  ``main_program`` ，用于执行模型的训练、评估或推理。  ``dist_main_program``  返回指定  ``mode``  的对应分布式  ``main_program`` 。
 
 **参数**
 
-    - **mode** (str|None, 可选) - 指定需要返回的 ``main_program`` 的模式，可以是 "train"、"eval" 或 "predict"，如果未设置，则使用 DistModel 的当前模式。默认值：None。
+    - **mode** (str|None, 可选) - 指定需要返回的  ``main_program``  的模式，可以是 "train"、"eval" 或 "predict"，如果未设置，则使用 DistModel 的当前模式。默认值：None。
 
 **返回**
 
-    指定 ``mode`` 的分布式 ``main_program``。
+    指定  ``mode``  的分布式  ``main_program`` 。
 
 
 dist_startup_program(mode=None)
 '''''''
 
-获取指定 ``mode`` 的分布式 ``startup_program``。 ``startup_program`` 用于存储模型初始化的描述信息。分布式 ``startup_program`` 存储了每个进程上局部模型的初始化操作。每个 ``mode`` 都有自己的分布式 ``startup_program``，用于模型训练、评估或推理时的初始化。
+获取指定  ``mode``  的分布式  ``startup_program`` 。  ``startup_program``  用于存储模型初始化的描述信息。分布式  ``startup_program``  存储了每个进程上局部模型的初始化操作。每个  ``mode``  都有自己的分布式  ``startup_program`` ，用于模型训练、评估或推理时的初始化。
 
 **参数**
 
-    - **mode** (str|None, 可选) - 指定需要返回的 ``startup_program`` 的模式，可以是 "train"、 "eval" 或 "predict"，如果未设置，则使用 DistModel 的当前模式。默认值：None。
+    - **mode** (str|None, 可选) - 指定需要返回的  ``startup_program``  的模式，可以是 "train"、 "eval" 或 "predict"，如果未设置，则使用 DistModel 的当前模式。默认值：None。
 
 **返回**
 
-    指定 ``mode`` 的分布式 ``startup_program``。
+    指定  ``mode``  的分布式  ``startup_program`` 。
 
 
 serial_main_program(mode=None)
 '''''''
 
-获取指定 ``mode`` 的串行 ``main_program``。串行 ``main_program`` 是包含了完整模型的变量和计算描述信息。
+获取指定  ``mode``  的串行  ``main_program`` 。串行  ``main_program``  是包含了完整模型的变量和计算描述信息。
 
 **参数**
 
-    - **mode** (str|None, 可选) - 指定需要返回的 ``main_program`` 的模式，可以是 "train"、 "eval" 或 "predict"，如果未设置，则使用 DistModel 的当前模式。默认值：None。
+    - **mode** (str|None, 可选) - 指定需要返回的  ``main_program``  的模式，可以是 "train"、 "eval" 或 "predict"，如果未设置，则使用 DistModel 的当前模式。默认值：None。
 
 **返回**
 
-    指定 ``mode`` 的串行 ``main_program``。
+    指定  ``mode``  的串行  ``main_program`` 。
 
 
 serial_startup_program(mode=None)
 '''''''
 
-获取指定 ``mode`` 的串行 ``startup_program``，包含了完整的初始化操作。
+获取指定  ``mode``  的串行  ``startup_program`` ，包含了完整的初始化操作。
 
 **参数**
 
-    - **mode** (str|None, 可选) - 指定需要返回的 ``startup_program`` 的模式，可以是 "train "、"eval" 或 "predict"，如果未设置，则使用 DistModel 的当前模式。默认值：None。
+    - **mode** (str|None, 可选) - 指定需要返回的  ``startup_program``  的模式，可以是 "train "、"eval" 或 "predict"，如果未设置，则使用 DistModel 的当前模式。默认值：None。
 
 **返回**
 
-    指定 ``mode`` 的串行 ``startup_program``。
+    指定  ``mode``  的串行  ``startup_program`` 。
diff --git a/docs/api/paddle/distributed/InMemoryDataset_cn.rst b/docs/api/paddle/distributed/InMemoryDataset_cn.rst
index 0442f0eb63c..5a42ccb7b54 100644
--- a/docs/api/paddle/distributed/InMemoryDataset_cn.rst
+++ b/docs/api/paddle/distributed/InMemoryDataset_cn.rst
@@ -35,7 +35,7 @@ init(**kwargs)
     - **input_type** (int) - 输入到模型训练样本的类型。0 代表一条样本，1 代表一个 batch。默认值为 0。
     - **fs_name** (str) - hdfs 名称。默认值为""。
     - **fs_ugi** (str) - hdfs 的 ugi。默认值为""。
-    - **pipe_command** (str) - 在当前的 ``dataset`` 中设置的 pipe 命令用于数据的预处理。pipe 命令只能使用 UNIX 的 pipe 命令，默认为"cat"。
+    - **pipe_command** (str) - 在当前的  ``dataset``  中设置的 pipe 命令用于数据的预处理。pipe 命令只能使用 UNIX 的 pipe 命令，默认为"cat"。
     - **download_cmd** (str) - 数据下载 pipe 命令。pipe 命令只能使用 UNIX 的 pipe 命令，默认为"cat"。
 
 
@@ -66,14 +66,14 @@ update_settings(**kwargs)
     - **input_type** (int) - 输入到模型训练样本的类型。0 代表一条样本，1 代表一个 batch。默认值为 0。
     - **fs_name** (str) - hdfs 名称。默认值为""。
     - **fs_ugi** (str) - hdfs 的 ugi。默认值为""。
-    - **pipe_command** (str) - 在当前的 ``dataset`` 中设置的 pipe 命令用于数据的预处理。pipe 命令只能使用 UNIX 的 pipe 命令，默认为"cat"。
+    - **pipe_command** (str) - 在当前的  ``dataset``  中设置的 pipe 命令用于数据的预处理。pipe 命令只能使用 UNIX 的 pipe 命令，默认为"cat"。
     - **download_cmd** (str) - 数据下载 pipe 命令。pipe 命令只能使用 UNIX 的 pipe 命令，默认为"cat"。
     - **merge_size** (int) - 通过样本 id 来设置合并，相同 id 的样本将会在 shuffle 之后进行合并，你应该在一个 data 生成器里面解析样本 id。merge_size 表示合并的最小数量，默认值为-1，表示不做合并。
     - **parse_ins_id** (bool) - 是否需要解析每条样的 id，默认值为 False。
     - **parse_content** (bool) 是否需要解析每条样本的 content，默认值为 False。
     - **fleet_send_batch_size** (int) - 设置发送 batch 的大小，默认值为 1024。
     - **fleet_send_sleep_seconds** (int) - 设置发送 batch 后的睡眠时间，默认值为 0。
-    - **fea_eval** (bool) - 设置特征打乱特征验证模式，来修正特征级别的重要性，特征打乱需要 ``fea_eval`` 被设置为 True。默认值为 False。
+    - **fea_eval** (bool) - 设置特征打乱特征验证模式，来修正特征级别的重要性，特征打乱需要  ``fea_eval``  被设置为 True。默认值为 False。
     - **candidate_size** (int) - 特征打乱特征验证模式下，用于随机化特征的候选池大小。默认值为 10000。
 
 **返回**
@@ -113,7 +113,7 @@ COPY-FROM: paddle.distributed.InMemoryDataset.preload_into_memory
 wait_preload_done()
 '''''''''
 
-等待 ``preload_into_memory`` 完成。
+等待  ``preload_into_memory``  完成。
 
 **代码示例**
 
diff --git a/docs/api/paddle/distributed/Overview_cn.rst b/docs/api/paddle/distributed/Overview_cn.rst
index 9e58e0c9c33..9a3caa9c4d4 100644
--- a/docs/api/paddle/distributed/Overview_cn.rst
+++ b/docs/api/paddle/distributed/Overview_cn.rst
@@ -19,7 +19,7 @@ paddle.distributed 目录包含的 API 支撑飞桨框架大规模分布式训
 Fleet 分布式高层 API
 ::::::::::::::::::::::::::
 
-``paddle.distributed.fleet`` 是分布式训练的统一入口 API，用于配置分布式训练。
+ ``paddle.distributed.fleet``  是分布式训练的统一入口 API，用于配置分布式训练。
 
 .. csv-table::
     :header: "API 名称", "API 功能"
@@ -62,7 +62,7 @@ Fleet 分布式高层 API
     " :ref:`get_group <cn_api_paddle_distributed_get_group>` ", "通过通信组 id 获取通信组实例"
     " :ref:`destroy_process_group <cn_api_paddle_distributed_destroy_process_group>` ", "销毁分布式通信组"
     " :ref:`get_backend <cn_api_paddle_distributed_get_backend>` ", "获取指定分布式通信组后端的名称"
-    " :ref:`gloo_init_parallel_env <cn_api_paddle_distributed_gloo_init_parallel_env>` ", "初始化 ``GLOO`` 上下文用于 CPU 间的通信"
+    " :ref:`gloo_init_parallel_env <cn_api_paddle_distributed_gloo_init_parallel_env>` ", "初始化  ``GLOO``  上下文用于 CPU 间的通信"
     " :ref:`gloo_release <cn_api_paddle_distributed_gloo_release>` ", "释放当前并行环境的 gloo 上下文"
     " :ref:`ParallelEnv <cn_api_paddle_distributed_ParallelEnv>` ", "这个类用于获取动态图模型并行执行所需的环境变量值"
 
@@ -115,7 +115,7 @@ Fleet 分布式高层 API
 Stream 集合通信高级 API
 ::::::::::::::::::::::
 
-``paddle.distributed.stream`` 在集合通信 API 的基础上，提供更统一的语义和对计算流的更精细的控制能力，有助于在特定场景下提高性能。
+ ``paddle.distributed.stream``  在集合通信 API 的基础上，提供更统一的语义和对计算流的更精细的控制能力，有助于在特定场景下提高性能。
 
 .. csv-table::
     :header: "API 名称", "API 功能"
diff --git a/docs/api/paddle/distributed/ParallelEnv_cn.rst b/docs/api/paddle/distributed/ParallelEnv_cn.rst
index ef37f309a15..4834c5f428f 100644
--- a/docs/api/paddle/distributed/ParallelEnv_cn.rst
+++ b/docs/api/paddle/distributed/ParallelEnv_cn.rst
@@ -6,11 +6,11 @@ ParallelEnv
 .. py:class:: paddle.distributed.ParallelEnv()
 
 .. note::
-    不推荐使用这个 API，如果需要获取 rank 和 world_size，建议使用 ``paddle.distributed.get_rank()`` 和  ``paddle.distributed.get_world_size()`` 。
+    不推荐使用这个 API，如果需要获取 rank 和 world_size，建议使用  ``paddle.distributed.get_rank()``  和   ``paddle.distributed.get_world_size()``  。
 
 这个类用于获取动态图模型并行执行所需的环境变量值。
 
-动态图并行模式现在需要使用 ``paddle.distributed.launch`` 模块或者 ``paddle.distributed.spawn`` 方法启动。
+动态图并行模式现在需要使用  ``paddle.distributed.launch``  模块或者  ``paddle.distributed.spawn``  方法启动。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/QueueDataset_cn.rst b/docs/api/paddle/distributed/QueueDataset_cn.rst
index 1795d7b1c1b..dddca42ff05 100644
--- a/docs/api/paddle/distributed/QueueDataset_cn.rst
+++ b/docs/api/paddle/distributed/QueueDataset_cn.rst
@@ -36,7 +36,7 @@ init(**kwargs)
     - **input_type** (int) - 输入到模型训练样本的类型。0 代表一条样本，1 代表一个 batch。默认值为 0。
     - **fs_name** (str) - hdfs 名称。默认值为""。
     - **fs_ugi** (str) - hdfs 的 ugi。默认值为""。
-    - **pipe_command** (str) - 在当前的 ``dataset`` 中设置的 pipe 命令用于数据的预处理。pipe 命令只能使用 UNIX 的 pipe 命令，默认为"cat"。
+    - **pipe_command** (str) - 在当前的  ``dataset``  中设置的 pipe 命令用于数据的预处理。pipe 命令只能使用 UNIX 的 pipe 命令，默认为"cat"。
     - **download_cmd** (str) - 数据下载 pipe 命令。pipe 命令只能使用 UNIX 的 pipe 命令，默认为"cat"。
 
 
diff --git a/docs/api/paddle/distributed/RowWiseParallel_cn.rst b/docs/api/paddle/distributed/RowWiseParallel_cn.rst
index fd1f55f95ab..d917baf97d9 100644
--- a/docs/api/paddle/distributed/RowWiseParallel_cn.rst
+++ b/docs/api/paddle/distributed/RowWiseParallel_cn.rst
@@ -5,13 +5,13 @@ RowWiseParallel
 
 .. py:class:: paddle.distributed.RowWiseParallel(is_input_parallel=True)
 
-按行切分策略是模型并行中的一个并行策略。本策略会尝试对标识 Layer 的 ``weight`` （如有）在第一维切分，
-本策略是针对 ``paddle.nn.Linear`` 与 ``paddle.nn.Embedding`` 设计，
-如果标识的 Layer 不属于这两个类，本策略会尝试切分 Layer 中的 ``weight`` （如有）。
+按行切分策略是模型并行中的一个并行策略。本策略会尝试对标识 Layer 的  ``weight``  （如有）在第一维切分，
+本策略是针对  ``paddle.nn.Linear``  与  ``paddle.nn.Embedding``  设计，
+如果标识的 Layer 不属于这两个类，本策略会尝试切分 Layer 中的  ``weight``  （如有）。
 
 
 .. note::
-    ``weight`` 需要有两个纬度。
+     ``weight``  需要有两个纬度。
 
 
 参数
diff --git a/docs/api/paddle/distributed/SequenceParallelBegin_cn.rst b/docs/api/paddle/distributed/SequenceParallelBegin_cn.rst
index dbde4d87607..1d6bfcdcf07 100644
--- a/docs/api/paddle/distributed/SequenceParallelBegin_cn.rst
+++ b/docs/api/paddle/distributed/SequenceParallelBegin_cn.rst
@@ -14,9 +14,9 @@ SequenceParallelBegin
 
 参数
 :::::::::
-    - **need_transpose** (bool，可选) - 是否在策略中进行 ``transpose`` 操作。
-      如果为 True，本策略会讲形状为 ``[b, s, h]`` 的输入张量变为形状为 ``[s/mp, b, h]`` 的输出张量。
-      反之，本策略会将形状为 ``[s, b, h]`` 的输入张量变为形状为 ``[s/mp, b, h]`` 的输出张量。默认为 True。
+    - **need_transpose** (bool，可选) - 是否在策略中进行  ``transpose``  操作。
+      如果为 True，本策略会讲形状为  ``[b, s, h]``  的输入张量变为形状为  ``[s/mp, b, h]``  的输出张量。
+      反之，本策略会将形状为  ``[s, b, h]``  的输入张量变为形状为  ``[s/mp, b, h]``  的输出张量。默认为 True。
 
 
 **代码示例**
diff --git a/docs/api/paddle/distributed/SequenceParallelDisable_cn.rst b/docs/api/paddle/distributed/SequenceParallelDisable_cn.rst
index 0ebd90eb729..e6061c8dbd8 100644
--- a/docs/api/paddle/distributed/SequenceParallelDisable_cn.rst
+++ b/docs/api/paddle/distributed/SequenceParallelDisable_cn.rst
@@ -10,11 +10,11 @@ SequenceParallelDisable
 
 参数
 :::::::::
-    - **need_transpose** (bool，可选) - 是否在策略中进行 ``transpose`` 操作。
-      如果为 True，本策略会将形状为 ``[s/mp, b, h]`` 的输入张量变为形状为 ``[b, s, h]`` 的张量来传递给标识 Layer 进行运算，
-      并将标识 Layer 形状为 ``[b, s, h]`` 的输出张量变为形状为 ``[s/mp, b, h]`` 的张量来输出。
-      如果为 False，本策略会将形状为 ``[s/mp, b, h]`` 的输入变为形状为 ``[s, b, h]`` 的张量来传递给标识 Layer 进行运算，
-      并将标识 Layer 形状为 ``[s, b, h]`` 的输出张量变为形状为 ``[s/mp, b, h]`` 的张量来输出。
+    - **need_transpose** (bool，可选) - 是否在策略中进行  ``transpose``  操作。
+      如果为 True，本策略会将形状为  ``[s/mp, b, h]``  的输入张量变为形状为  ``[b, s, h]``  的张量来传递给标识 Layer 进行运算，
+      并将标识 Layer 形状为  ``[b, s, h]``  的输出张量变为形状为  ``[s/mp, b, h]``  的张量来输出。
+      如果为 False，本策略会将形状为  ``[s/mp, b, h]``  的输入变为形状为  ``[s, b, h]``  的张量来传递给标识 Layer 进行运算，
+      并将标识 Layer 形状为  ``[s, b, h]``  的输出张量变为形状为  ``[s/mp, b, h]``  的张量来输出。
       默认为 True。
 
 
diff --git a/docs/api/paddle/distributed/SequenceParallelEnable_cn.rst b/docs/api/paddle/distributed/SequenceParallelEnable_cn.rst
index 1d61eceafd1..ddf1f3dc5d0 100644
--- a/docs/api/paddle/distributed/SequenceParallelEnable_cn.rst
+++ b/docs/api/paddle/distributed/SequenceParallelEnable_cn.rst
@@ -8,7 +8,7 @@ SequenceParallelEnable
 对标识 Layer 进行序列并行策略。
 
 .. note::
-    被标识的 Layer 的输入张量的形状应该为 ``[b, s, h]``。
+    被标识的 Layer 的输入张量的形状应该为  ``[b, s, h]`` 。
 
 **代码示例**
 
diff --git a/docs/api/paddle/distributed/SequenceParallelEnd_cn.rst b/docs/api/paddle/distributed/SequenceParallelEnd_cn.rst
index c7c5b83634c..509457cd7e9 100644
--- a/docs/api/paddle/distributed/SequenceParallelEnd_cn.rst
+++ b/docs/api/paddle/distributed/SequenceParallelEnd_cn.rst
@@ -14,9 +14,9 @@ SequenceParallelEnd
 
 参数
 :::::::::
-    - **need_transpose** (bool，可选) - 是否在策略中进行 ``transpose`` 操作。
-      如果为 True，本策略会讲形状为 ``[s/mp, b, h]`` 的输入张量变为形状为 ``[b, s, h]`` 的输出张量。
-      反之，本策略会将形状为 ``[s/mp, b, h]`` 的输入张量变为形状为 ``[s, b, h]`` 的输出张量。默认为 True。
+    - **need_transpose** (bool，可选) - 是否在策略中进行  ``transpose``  操作。
+      如果为 True，本策略会讲形状为  ``[s/mp, b, h]``  的输入张量变为形状为  ``[b, s, h]``  的输出张量。
+      反之，本策略会将形状为  ``[s/mp, b, h]``  的输入张量变为形状为  ``[s, b, h]``  的输出张量。默认为 True。
 
 
 **代码示例**
diff --git a/docs/api/paddle/distributed/SplitPoint_cn.rst b/docs/api/paddle/distributed/SplitPoint_cn.rst
index 1013bf76e17..b525ec19351 100644
--- a/docs/api/paddle/distributed/SplitPoint_cn.rst
+++ b/docs/api/paddle/distributed/SplitPoint_cn.rst
@@ -5,11 +5,11 @@ SplitPoint
 
 .. py:class:: paddle.distributed.SplitPoint
 
-用于流水线并行下切分位置的确认。目前支持 ``BEGINNING`` 和 ``END`` 。
+用于流水线并行下切分位置的确认。目前支持  ``BEGINNING``  和  ``END``  。
 
-``BEGINNING`` 表明在标识的 Layer 之前进行切分。
+ ``BEGINNING``  表明在标识的 Layer 之前进行切分。
 
-``END`` 表明在标识的 Layer 之后进行切分。
+ ``END``  表明在标识的 Layer 之后进行切分。
 
 
 **代码示例**
diff --git a/docs/api/paddle/distributed/Strategy_cn.rst b/docs/api/paddle/distributed/Strategy_cn.rst
index 2f4909104ba..77064e1d133 100644
--- a/docs/api/paddle/distributed/Strategy_cn.rst
+++ b/docs/api/paddle/distributed/Strategy_cn.rst
@@ -5,21 +5,21 @@ Strategy
 
 .. py:class:: paddle.distributed.Strategy
 
-用于配置静态图分布式训练时所使用的并行策略和优化策略。目前支持 ``sharding``、 ``fused_passes``、 ``gradient_merge`` 和 ``pipeline``，未来将支持更多的策略。
+用于配置静态图分布式训练时所使用的并行策略和优化策略。目前支持  ``sharding`` 、  ``fused_passes`` 、  ``gradient_merge``  和  ``pipeline`` ，未来将支持更多的策略。
 
-``sharding`` 用于配置优化器的分片策略，可以节省 GPU 显存。
+ ``sharding``  用于配置优化器的分片策略，可以节省 GPU 显存。
 
-``fused_passes`` 用于配置模型的计算融合策略。
+ ``fused_passes``  用于配置模型的计算融合策略。
 
-``gradient_merge`` 用于配置训练时的梯度融合。
+ ``gradient_merge``  用于配置训练时的梯度融合。
 
-``pipeline`` 用于配置流水线并行策略。
+ ``pipeline``  用于配置流水线并行策略。
 
 
 参数
 :::::::::
 
-    - **config** (dict|None, 可选) - 策略配置。若 ``config`` 参数为 ``None``，则使用默认配置。若 ``config`` 为字典，则将字典中包含的项设置为用户自定义的配置，字典中不包含的项依旧使用默认配置。默认：None。
+    - **config** (dict|None, 可选) - 策略配置。若  ``config``  参数为  ``None`` ，则使用默认配置。若  ``config``  为字典，则将字典中包含的项设置为用户自定义的配置，字典中不包含的项依旧使用默认配置。默认：None。
 
 
 **代码示例**
@@ -35,11 +35,11 @@ sharding
 
 优化器分片策略，包含以下配置项：
 
-    - **``enable``** (bool) - 是否启用优化器分片策略。默认：False。
+    - ** ``enable`` ** (bool) - 是否启用优化器分片策略。默认：False。
 
-    - **``stage``** (int) - 可以设置为 1、2 或 3。1 表示切分优化器状态，2 代表切分优化器状态和梯度，3 表示切分优化器状态、梯度和参数。默认：1。
+    - ** ``stage`` ** (int) - 可以设置为 1、2 或 3。1 表示切分优化器状态，2 代表切分优化器状态和梯度，3 表示切分优化器状态、梯度和参数。默认：1。
 
-    - **``degree``** (int) - 分片的数量。默认：8。
+    - ** ``degree`` ** (int) - 分片的数量。默认：8。
 
 **代码示例**
 
@@ -51,11 +51,11 @@ fused_passes
 
 计算融合策略，包含以下配置项：
 
-    - **``enable``** (bool) - 是否启用计算融合策略。默认：False。
+    - ** ``enable`` ** (bool) - 是否启用计算融合策略。默认：False。
 
-    - **``gemm_epilogue``** (bool) - 是否融合 ``Linear`` 层中的 ``matmul`` 和 ``add`` 计算。默认：False。
+    - ** ``gemm_epilogue`` ** (bool) - 是否融合  ``Linear``  层中的  ``matmul``  和  ``add``  计算。默认：False。
 
-    - **``dropout_add``** (bool) - 是否融合 ``dropout`` 和 ``add`` 计算。默认：False。
+    - ** ``dropout_add`` ** (bool) - 是否融合  ``dropout``  和  ``add``  计算。默认：False。
 
 **代码示例**
 
@@ -67,11 +67,11 @@ gradient_merge
 
 梯度融合策略，包含以下配置项：
 
-    - **``enable``** (bool) - 是否启用梯度融合策略。默认：False。
+    - ** ``enable`` ** (bool) - 是否启用梯度融合策略。默认：False。
 
-    - **``k_steps``** (int) - 梯度融合的步数。默认：1。
+    - ** ``k_steps`` ** (int) - 梯度融合的步数。默认：1。
 
-    - **``avg``** (bool) - 是否平均梯度。默认：True。
+    - ** ``avg`` ** (bool) - 是否平均梯度。默认：True。
 
 **代码示例**
 
@@ -83,13 +83,13 @@ pipeline
 
 流水线并行策略，包含以下配置项：
 
-    - **``enable``** (bool) - 是否启用流水线并行策略。默认：False。
+    - ** ``enable`` ** (bool) - 是否启用流水线并行策略。默认：False。
 
-    - **``schedule_mode``** (str) - 流水线并行的调度模式。默认：1F1B。
+    - ** ``schedule_mode`` ** (str) - 流水线并行的调度模式。默认：1F1B。
 
-    - **``micro_batch_size``** (int) - mini-batch 中包含的每个 micro-batch 的大小。默认：1。
+    - ** ``micro_batch_size`` ** (int) - mini-batch 中包含的每个 micro-batch 的大小。默认：1。
 
-    - **``accumulate_steps``** (int) - 累积步数。默认：1。
+    - ** ``accumulate_steps`` ** (int) - 累积步数。默认：1。
 
 **代码示例**
 
diff --git a/docs/api/paddle/distributed/all_gather_cn.rst b/docs/api/paddle/distributed/all_gather_cn.rst
index 8831ee694bd..7efacc6fe11 100644
--- a/docs/api/paddle/distributed/all_gather_cn.rst
+++ b/docs/api/paddle/distributed/all_gather_cn.rst
@@ -20,7 +20,7 @@ all_gather
 :::::::::
     - **tensor_list** (List[Tensor]) - 用于保存聚合结果的 tensor 列表。若不为空，其中每个 tensor 的数据类型必须与输入的 tensor 保持一致。
     - **tensor** (Tensor) - 待聚合的 tensor。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16、complex64、complex128。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
 
 返回
diff --git a/docs/api/paddle/distributed/all_gather_object_cn.rst b/docs/api/paddle/distributed/all_gather_object_cn.rst
index 6a36c57eba6..9a6300da277 100644
--- a/docs/api/paddle/distributed/all_gather_object_cn.rst
+++ b/docs/api/paddle/distributed/all_gather_object_cn.rst
@@ -7,7 +7,7 @@ all_gather_object
 .. py:function:: paddle.distributed.all_gather_object(object_list, obj, group=None)
 
 组聚合，聚合进程组内指定的 picklable 对象，随后将聚合后的对象列表发送到每个进程。
-过程与 ``all_gather`` 类似，但可以传入自定义的 python 对象。
+过程与  ``all_gather``  类似，但可以传入自定义的 python 对象。
 
 .. note::
   该 API 只支持动态图模式。
@@ -16,7 +16,7 @@ all_gather_object
 :::::::::
     - **object_list** (List[Any]) - 用于保存聚合结果的列表。
     - **object** (Any) - 待聚合的对象。需要保证该对象是 picklable 的。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/distributed/all_reduce_cn.rst b/docs/api/paddle/distributed/all_reduce_cn.rst
index 71197448865..ed25855c132 100644
--- a/docs/api/paddle/distributed/all_reduce_cn.rst
+++ b/docs/api/paddle/distributed/all_reduce_cn.rst
@@ -20,12 +20,12 @@ all_reduce
 :::::::::
     - **tensor** (Tensor) - 输入的 tensor。返回结果也将保存到该 tensor 中。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
     - **op** (ReduceOp.SUM|ReduceOp.MAX|ReduceOp.MIN|ReduceOp.PROD，可选) - 归约的操作类型，包括求和、取最大值、取最小值和求乘积。默认为求和。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
 
 返回
 :::::::::
-``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+ ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/alltoall_cn.rst b/docs/api/paddle/distributed/alltoall_cn.rst
index 2e9fb443814..30cc4e12ee9 100644
--- a/docs/api/paddle/distributed/alltoall_cn.rst
+++ b/docs/api/paddle/distributed/alltoall_cn.rst
@@ -22,7 +22,7 @@ alltoall
 :::::::::
     - **out_tensor_list** (List[Tensor]) - 用于保存操作结果的 tensor 列表。其中每个 tensor 的数据类型必须与输入的 tensor 保持一致。
     - **in_tensor_list** (List[Tensor]) - 输入的 tensor 列表。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
 
 返回
diff --git a/docs/api/paddle/distributed/alltoall_single_cn.rst b/docs/api/paddle/distributed/alltoall_single_cn.rst
index 677d44f51c2..0287f418116 100644
--- a/docs/api/paddle/distributed/alltoall_single_cn.rst
+++ b/docs/api/paddle/distributed/alltoall_single_cn.rst
@@ -17,12 +17,12 @@ alltoall_single
     - **in_tensor** (Tensor): 输入的 tensor。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
     - **in_split_sizes** (List[int]，可选): 对 in_tensor 的 dim[0] 进行切分的大小。默认为 None，即将 in_tensor 均匀地分发到各个进程中（需要确保 in_tensor 的大小能够被组中的进程数整除）。
     - **out_split_sizes** (List[int]，可选): 对 out_tensor 的 dim[0] 进行切分的大小。默认为 None，即 out_tensor 将均匀地聚合来自各个进程的数据（需要确保 out_tensor 的大小能够被组中的进程数整除）。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
 
 返回
 :::::::::
-若为同步操作，无返回值；若为异步操作，返回 ``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+若为同步操作，无返回值；若为异步操作，返回  ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/barrier_cn.rst b/docs/api/paddle/distributed/barrier_cn.rst
index 031f5ee9a46..46df30e72f0 100644
--- a/docs/api/paddle/distributed/barrier_cn.rst
+++ b/docs/api/paddle/distributed/barrier_cn.rst
@@ -10,7 +10,7 @@ barrier
 
 参数
 :::::::::
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/distributed/broadcast_cn.rst b/docs/api/paddle/distributed/broadcast_cn.rst
index c1554e4d646..ca31096308c 100644
--- a/docs/api/paddle/distributed/broadcast_cn.rst
+++ b/docs/api/paddle/distributed/broadcast_cn.rst
@@ -20,12 +20,12 @@ broadcast
 :::::::::
     - **tensor** (Tensor) - 在目标进程上为待广播的 tensor，在其他进程上为用于接收广播结果的 tensor。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16、complex64、complex128。
     - **src** (int) - 目标进程的 rank，该进程传入的 tensor 将被发送到其他进程上。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
 
 返回
 :::::::::
-动态图模式下，若为同步操作，无返回值；若为异步操作，返回 ``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+动态图模式下，若为同步操作，无返回值；若为异步操作，返回  ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 静态图模式下，无返回值。
 
diff --git a/docs/api/paddle/distributed/broadcast_object_list_cn.rst b/docs/api/paddle/distributed/broadcast_object_list_cn.rst
index 7ab4ef01812..bccd9758593 100644
--- a/docs/api/paddle/distributed/broadcast_object_list_cn.rst
+++ b/docs/api/paddle/distributed/broadcast_object_list_cn.rst
@@ -7,7 +7,7 @@ broadcast_object_list
 .. py:function:: paddle.distributed.broadcast_object_list(object_list, src, group=None)
 
 将一个 picklable 对象发送到每个进程。
-过程与 ``broadcast`` 类似，但可以传入自定义的 python 对象。
+过程与  ``broadcast``  类似，但可以传入自定义的 python 对象。
 
 .. note::
   该 API 只支持动态图模式。
@@ -16,7 +16,7 @@ broadcast_object_list
 :::::::::
     - **object_list** (List[Any]) - 在目标进程上为待广播的 object 列表，在其他进程上为用于接收广播结果的 object 列表。
     - **src** (int) - 目标进程的 rank，该进程传入的 object 列表将被发送到其他进程上。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/distributed/fleet/Fleet_cn.rst b/docs/api/paddle/distributed/fleet/Fleet_cn.rst
index a2db6cd6473..9191353440b 100644
--- a/docs/api/paddle/distributed/fleet/Fleet_cn.rst
+++ b/docs/api/paddle/distributed/fleet/Fleet_cn.rst
@@ -265,17 +265,17 @@ COPY-FROM: paddle.distributed.fleet.Fleet.stop_worker
 save_inference_model(executor, dirname, feeded_var_names, target_vars, main_program=None, export_for_deployment=True)
 '''''''''
 
-修剪指定的 ``main_program`` 以构建一个专门用于预测的 ``Inference Program`` （ ``Program`` 含义详见 :ref:`api_guide_Program` ）。所得到的 ``Inference Program`` 及其对应的所>有相关参数均被保存到 ``dirname`` 指定的目录中。
+修剪指定的  ``main_program``  以构建一个专门用于预测的  ``Inference Program``  （  ``Program``  含义详见 :ref:`api_guide_Program` ）。所得到的  ``Inference Program``  及其对应的所>有相关参数均被保存到  ``dirname``  指定的目录中。
 
 
 **参数**
 
-  - **executor** (Executor) –  用于保存预测模型的 ``executor``，详见 :ref:`api_guide_executor` 。
+  - **executor** (Executor) –  用于保存预测模型的  ``executor`` ，详见 :ref:`api_guide_executor` 。
   - **dirname** (str) – 指定保存预测模型结构和参数的文件目录。
   - **feeded_var_names** (list[str]) – 字符串列表，包含着 Inference Program 预测时所需提供数据的所有变量名称（即所有输入变量的名称）。
-  - **target_vars** (list[Tensor]) – ``Tensor`` （详见 :ref:`api_guide_Program` ）类型列表，包含着模型的所有输出变量。通过这些输出变量即可得到模型的预测结果。
-  - **main_program** (Program，可选) – 通过该参数指定的 ``main_program`` 可构建一个专门用于预测的 ``Inference Program``。若为 None，则使用全局默认的  ``_main_program_`` 。>默认值为 None。
-  - **export_for_deployment** (bool，可选) – 若为 True，则 ``main_program`` 指定的 Program 将被修改为只支持直接预测部署的 Program。否则，将存储更多的信息，方便优化和再训练。目前
+  - **target_vars** (list[Tensor]) –  ``Tensor``  （详见 :ref:`api_guide_Program` ）类型列表，包含着模型的所有输出变量。通过这些输出变量即可得到模型的预测结果。
+  - **main_program** (Program，可选) – 通过该参数指定的  ``main_program``  可构建一个专门用于预测的  ``Inference Program`` 。若为 None，则使用全局默认的   ``_main_program_``  。>默认值为 None。
+  - **export_for_deployment** (bool，可选) – 若为 True，则  ``main_program``  指定的 Program 将被修改为只支持直接预测部署的 Program。否则，将存储更多的信息，方便优化和再训练。目前
 只支持设置为 True，且默认值为 True。
 
 
@@ -295,9 +295,9 @@ save_persistables(executor, dirname, main_program=None)
 
 **参数**
 
- - **executor**  (Executor) – 用于保存持久性变量的 ``executor``，详见 :ref:`api_guide_executor` 。
+ - **executor**  (Executor) – 用于保存持久性变量的  ``executor`` ，详见 :ref:`api_guide_executor` 。
  - **dirname**  (str) – 用于储存持久性变量的文件目录。
- - **main_program**  (Program，可选) – 需要保存持久性变量的 Program（ ``Program`` 含义详见 :ref:`api_guide_Program` ）。如果为 None，则使用 default_main_Program。默认值为 None>。
+ - **main_program**  (Program，可选) – 需要保存持久性变量的 Program（  ``Program``  含义详见 :ref:`api_guide_Program` ）。如果为 None，则使用 default_main_Program。默认值为 None>。
 
 **返回**
 无
@@ -441,10 +441,10 @@ state_dict()
 
   **1. 该 API 只在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
 
-以 ``dict`` 返回当前 ``optimizer`` 使用的所有 Tensor。比如对于 Adam 优化器，将返回 beta1, beta2, momentum 等 Tensor。
+以  ``dict``  返回当前  ``optimizer``  使用的所有 Tensor。比如对于 Adam 优化器，将返回 beta1, beta2, momentum 等 Tensor。
 
 **返回**
-dict，当前 ``optimizer`` 使用的所有 Tensor。
+dict，当前  ``optimizer``  使用的所有 Tensor。
 
 
 **代码示例**
@@ -479,7 +479,7 @@ set_state_dict(state_dict)
 
   **1. 该 API 只在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
 
-加载 ``optimizer`` 的 Tensor 字典给当前 ``optimizer`` 。
+加载  ``optimizer``  的 Tensor 字典给当前  ``optimizer``  。
 
 **返回**
 None
@@ -520,7 +520,7 @@ set_lr(value)
 
   **1. 该 API 只在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
 
-手动设置当前 ``optimizer`` 的学习率。
+手动设置当前  ``optimizer``  的学习率。
 
 **参数**
 
@@ -573,7 +573,7 @@ set_lr_scheduler(scheduler)
 
   **1. 该 API 只在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
 
-手动设置当前 ``optimizer`` 的学习率为 LRScheduler 类。
+手动设置当前  ``optimizer``  的学习率为 LRScheduler 类。
 
 **参数**
 
diff --git a/docs/api/paddle/distributed/fleet/UtilBase_cn.rst b/docs/api/paddle/distributed/fleet/UtilBase_cn.rst
index 2db7a38a6ea..c17f215430b 100644
--- a/docs/api/paddle/distributed/fleet/UtilBase_cn.rst
+++ b/docs/api/paddle/distributed/fleet/UtilBase_cn.rst
@@ -16,11 +16,11 @@ all_reduce(input, mode="sum", comm_world="worker")
 
     - **input** (list|tuple|numpy.array) – 归约操作的输入。
     - **mode** (str) - 归约操作的模式，包含求和，取最大值和取最小值，默认为求和归约。
-    - **comm_world** (str) - 归约操作的通信集合，包含：server 集合(``server``)，worker 集合(``worker``)及所有节点集合(``all``)，默认为 worker 集合。
+    - **comm_world** (str) - 归约操作的通信集合，包含：server 集合( ``server`` )，worker 集合( ``worker`` )及所有节点集合( ``all`` )，默认为 worker 集合。
 
 **返回**
 
-Numpy.array|None：一个和``input``形状一致的 numpy 数组或 None。
+Numpy.array|None：一个和 ``input`` 形状一致的 numpy 数组或 None。
 
 **代码示例**
 
@@ -32,7 +32,7 @@ barrier(comm_world="worker")
 
 **参数**
 
-   - **comm_world** (str) - 阻塞操作的通信集合，包含：server 集合(``server``)，worker 集合(``worker``)及所有节点集合(``all``)，默认为 worker 集合。
+   - **comm_world** (str) - 阻塞操作的通信集合，包含：server 集合( ``server`` )，worker 集合( ``worker`` )及所有节点集合( ``all`` )，默认为 worker 集合。
 
 **代码示例**
 
@@ -45,7 +45,7 @@ all_gather(input, comm_world="worker")
 **参数**
 
    - **input** (int|float) - 聚合操作的输入。
-   - **comm_world** (str) - 聚合操作的通信集合，包含：server 集合(``server``)，worker 集合(``worker``)及所有节点集合(``all``)，默认为 worker 集合。
+   - **comm_world** (str) - 聚合操作的通信集合，包含：server 集合( ``server`` )，worker 集合( ``worker`` )及所有节点集合( ``all`` )，默认为 worker 集合。
 
 **返回**
 
diff --git a/docs/api/paddle/distributed/get_backend_cn.rst b/docs/api/paddle/distributed/get_backend_cn.rst
index d5081cf7311..4555d8c9854 100644
--- a/docs/api/paddle/distributed/get_backend_cn.rst
+++ b/docs/api/paddle/distributed/get_backend_cn.rst
@@ -13,7 +13,7 @@ get_backend
 
 返回
 :::::::::
-``str``，通信组后端的名称。
+ ``str`` ，通信组后端的名称。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/distributed/get_mesh_cn.rst b/docs/api/paddle/distributed/get_mesh_cn.rst
index 47ea997f1fa..6deaede0a86 100644
--- a/docs/api/paddle/distributed/get_mesh_cn.rst
+++ b/docs/api/paddle/distributed/get_mesh_cn.rst
@@ -5,11 +5,11 @@ get_mesh
 
 .. py:function:: paddle.distributed.get_mesh()
 
-获取用户通过 ``set_mesh`` 接口设定的全局 mesh。
+获取用户通过  ``set_mesh``  接口设定的全局 mesh。
 
 返回
 :::::::::
-paddle.distributed.ProcessMesh：通过 ``set_mesh`` 接口设定的全局 mesh。
+paddle.distributed.ProcessMesh：通过  ``set_mesh``  接口设定的全局 mesh。
 
 
 代码示例
diff --git a/docs/api/paddle/distributed/get_world_size_cn.rst b/docs/api/paddle/distributed/get_world_size_cn.rst
index f9af5e93d79..882f8cb5a35 100644
--- a/docs/api/paddle/distributed/get_world_size_cn.rst
+++ b/docs/api/paddle/distributed/get_world_size_cn.rst
@@ -16,7 +16,7 @@ get_world_size
 (int) 返回指定通信组中的进程数，如果当前进程不在该通信组中，则返回-1。
 
 .. warning::
-    参数 ``group`` 仅在动态图模式下支持
+    参数  ``group``  仅在动态图模式下支持
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/gloo_init_parallel_env_cn.rst b/docs/api/paddle/distributed/gloo_init_parallel_env_cn.rst
index e31a4735964..b6e7c699cc8 100644
--- a/docs/api/paddle/distributed/gloo_init_parallel_env_cn.rst
+++ b/docs/api/paddle/distributed/gloo_init_parallel_env_cn.rst
@@ -4,7 +4,7 @@ gloo_init_parallel_env
 -----------------
 
 .. py:function:: paddle.distributed.gloo_init_parallel_env(rank_id, rank_num, server_endpoint)
-该函数仅初始化 ``GLOO`` 上下文用于 CPU 间的通信。
+该函数仅初始化  ``GLOO``  上下文用于 CPU 间的通信。
 
 参数
 :::::::::
diff --git a/docs/api/paddle/distributed/init_parallel_env_cn.rst b/docs/api/paddle/distributed/init_parallel_env_cn.rst
index 495b2fa2803..c7676ec0efb 100644
--- a/docs/api/paddle/distributed/init_parallel_env_cn.rst
+++ b/docs/api/paddle/distributed/init_parallel_env_cn.rst
@@ -8,7 +8,7 @@ init_parallel_env
 初始化动态图模式下的并行训练环境。
 
 .. note::
-    目前同时初始化 ``NCCL`` 和 ``GLOO`` 上下文用于通信。
+    目前同时初始化  ``NCCL``  和  ``GLOO``  上下文用于通信。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/distributed/irecv_cn.rst b/docs/api/paddle/distributed/irecv_cn.rst
index 6b5ab903eb1..f47bb383680 100644
--- a/docs/api/paddle/distributed/irecv_cn.rst
+++ b/docs/api/paddle/distributed/irecv_cn.rst
@@ -15,12 +15,12 @@ irecv
 :::::::::
     - **tensor** (Tensor) - 用于接收数据的 tensor。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
     - **src** (int) - 目标进程的 rank，将接收来自该进程的 tensor。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
 
 
 返回
 :::::::::
-``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+ ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/is_available_cn.rst b/docs/api/paddle/distributed/is_available_cn.rst
index c8c4b04384f..483bcfbb45a 100644
--- a/docs/api/paddle/distributed/is_available_cn.rst
+++ b/docs/api/paddle/distributed/is_available_cn.rst
@@ -13,7 +13,7 @@ is_available
 
 返回
 :::::::::
-``bool``，如果分布式环境可用，返回 True；反之返回 False。
+ ``bool`` ，如果分布式环境可用，返回 True；反之返回 False。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/isend_cn.rst b/docs/api/paddle/distributed/isend_cn.rst
index 05fd94908ef..1dce1618637 100644
--- a/docs/api/paddle/distributed/isend_cn.rst
+++ b/docs/api/paddle/distributed/isend_cn.rst
@@ -15,12 +15,12 @@ isend
 :::::::::
     - **tensor** (Tensor) - 待发送的 Tensor。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
     - **dst** (int) - 目标进程的 rank，传入的 tensor 将发送到该进程。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
 
 
 返回
 :::::::::
-``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+ ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/launch_cn.rst b/docs/api/paddle/distributed/launch_cn.rst
index 0f201b6641b..2cf555f722a 100644
--- a/docs/api/paddle/distributed/launch_cn.rst
+++ b/docs/api/paddle/distributed/launch_cn.rst
@@ -5,7 +5,7 @@ launch
 
 .. py:function:: paddle.distributed.launch()
 
-使用 ``python -m paddle.distributed.launch`` 方法启动分布式训练任务。
+使用  ``python -m paddle.distributed.launch``  方法启动分布式训练任务。
 
 Launch 模块是在每个节点运行，负责分布式协同和本地进程管理的模块。使用 launch 启动分布式训练可以简化参数配置，进行稳定可靠的分布式组网训练，同时使用优化的调试和日志收集功能。另外一些高级的分布式功能如容错和弹性都依赖 launch 启动。
 
@@ -27,88 +27,88 @@ Launch 模块是在每个节点运行，负责分布式协同和本地进程管
 
 基础参数
 :::::::::
-    - ``--master``：主节点，支持缺省 ``http://`` 和 ``etcd://``，默认缺省 ``http://``。例如 ``--master=127.0.0.1:8080``。默认值 ``--master=None``。
+    -  ``--master`` ：主节点，支持缺省  ``http://``  和  ``etcd://`` ，默认缺省  ``http://`` 。例如  ``--master=127.0.0.1:8080`` 。默认值  ``--master=None`` 。
 
-    - ``--rank``：节点序号，可以通过主节点进行分配。默认值 ``--rank=-1``。
+    -  ``--rank`` ：节点序号，可以通过主节点进行分配。默认值  ``--rank=-1`` 。
 
-    - ``--log_level``：日志级别，可选值为 CRITICAL/ERROR/WARNING/INFO/DEBUG/NOTSET，不区分大小写。默认值 ``--log_level=INFO``。
+    -  ``--log_level`` ：日志级别，可选值为 CRITICAL/ERROR/WARNING/INFO/DEBUG/NOTSET，不区分大小写。默认值  ``--log_level=INFO`` 。
 
-    - ``--nnodes``：节点数量，支持区间设定以开启弹性模式，比如 ``--nnodes=2:3``。默认值 ``--nnodes=1``。
+    -  ``--nnodes`` ：节点数量，支持区间设定以开启弹性模式，比如  ``--nnodes=2:3`` 。默认值  ``--nnodes=1`` 。
 
-    - ``--nproc_per_node``：每个节点启动的进程数，在 GPU 训练中，应该小于等于系统的 GPU 数量。例如 ``--nproc_per_node=8``
+    -  ``--nproc_per_node`` ：每个节点启动的进程数，在 GPU 训练中，应该小于等于系统的 GPU 数量。例如  ``--nproc_per_node=8`` 
 
-    - ``--log_dir``：日志输出目录。例如 ``--log_dir=output_dir``。默认值 ``--log_dir=log``。
+    -  ``--log_dir`` ：日志输出目录。例如  ``--log_dir=output_dir`` 。默认值  ``--log_dir=log`` 。
 
-    - ``--run_mode``：启动任务的运行模式，可选有 collective/ps/ps-heter。例如 ``--run_mode=ps``。默认值 ``--run_mode=collective``。
+    -  ``--run_mode`` ：启动任务的运行模式，可选有 collective/ps/ps-heter。例如  ``--run_mode=ps`` 。默认值  ``--run_mode=collective`` 。
 
-    - ``--job_id``：任务唯一标识，缺省将使用 default，会影响日志命名。例如 ``--job_id=job1``。默认值 ``--job_id=default``。
+    -  ``--job_id`` ：任务唯一标识，缺省将使用 default，会影响日志命名。例如  ``--job_id=job1`` 。默认值  ``--job_id=default`` 。
 
-    - ``--devices``：节点上的加速卡设备，支持 gpu/xpu/npu/mlu。例如 ``--devices=0,1,2,3``，这会启动 4 个进程，每个进程绑定到 1 个设备上。
+    -  ``--devices`` ：节点上的加速卡设备，支持 gpu/xpu/npu/mlu。例如  ``--devices=0,1,2,3`` ，这会启动 4 个进程，每个进程绑定到 1 个设备上。
 
-    - ``training_script``：需要运行的任务脚本，例如 ``training.py``。
+    -  ``training_script`` ：需要运行的任务脚本，例如  ``training.py`` 。
 
-    - ``training_script_args``: ``training_script`` 的输入参数，与普通起任务时输入的参数一样，例如 ``--lr=0.1``。
+    -  ``training_script_args`` :  ``training_script``  的输入参数，与普通起任务时输入的参数一样，例如  ``--lr=0.1`` 。
 
 Collective 参数
 :::::::::
-    - ``--ips``: [DEPRECATED] 需要运行分布式环境的节点 IP 地址，例如 ``--ips=192.168.0.16,192.168.0.17``。单机默认值是 ``--ips=127.0.0.1``。
+    -  ``--ips`` : [DEPRECATED] 需要运行分布式环境的节点 IP 地址，例如  ``--ips=192.168.0.16,192.168.0.17`` 。单机默认值是  ``--ips=127.0.0.1`` 。
 
 Parameter-Server 参数
 :::::::::
-    - ``--servers``：多机分布式任务中，指定参数服务器服务节点的 IP 和端口，例如 ``--servers="192.168.0.16:6170,192.168.0.17:6170"``。
+    -  ``--servers`` ：多机分布式任务中，指定参数服务器服务节点的 IP 和端口，例如  ``--servers="192.168.0.16:6170,192.168.0.17:6170"`` 。
 
-    - ``--trainers``：多机分布式任务中，指定参数服务器训练节点的 IP 和端口，也可只指定 IP，例如 ``--trainers="192.168.0.16:6171,192.168.0.16:6172,192.168.0.17:6171,192.168.0.17:6172"``。
+    -  ``--trainers`` ：多机分布式任务中，指定参数服务器训练节点的 IP 和端口，也可只指定 IP，例如  ``--trainers="192.168.0.16:6171,192.168.0.16:6172,192.168.0.17:6171,192.168.0.17:6172"`` 。
 
-    - ``--workers``: [DEPRECATED] 同 trainers。
+    -  ``--workers`` : [DEPRECATED] 同 trainers。
 
-    - ``--heter_workers``：在异构集群中启动分布式任务，指定参数服务器异构训练节点的 IP 和端口，例如 ``--heter_workers="192.168.0.16:6172,192.168.0.17:6172"``。
+    -  ``--heter_workers`` ：在异构集群中启动分布式任务，指定参数服务器异构训练节点的 IP 和端口，例如  ``--heter_workers="192.168.0.16:6172,192.168.0.17:6172"`` 。
 
-    - ``--trainer_num``：指定参数服务器训练节点的个数。
+    -  ``--trainer_num`` ：指定参数服务器训练节点的个数。
 
-    - ``--worker_num``: [DEPRECATED] 同 trainer_num。
+    -  ``--worker_num`` : [DEPRECATED] 同 trainer_num。
 
-    - ``--server_num``：指定参数服务器服务节点的个数。
+    -  ``--server_num`` ：指定参数服务器服务节点的个数。
 
-    - ``--heter_worker_num``：在异构集群中启动单机模拟分布式任务，指定参数服务器异构训练节点的个数。
+    -  ``--heter_worker_num`` ：在异构集群中启动单机模拟分布式任务，指定参数服务器异构训练节点的个数。
 
-    - ``--gloo_port``：参数服务器模式中，用 Gloo 启动时设置的连接端口。同 http_port. Default ``--gloo_port=6767``。
+    -  ``--gloo_port`` ：参数服务器模式中，用 Gloo 启动时设置的连接端口。同 http_port. Default  ``--gloo_port=6767`` 。
 
-    - ``--with_gloo``：是否使用 gloo。默认值 ``--with_gloo=0``。
+    -  ``--with_gloo`` ：是否使用 gloo。默认值  ``--with_gloo=0`` 。
 
 
 Elastic 参数
 :::::::::
-    - ``--max_restart``：最大重启次数。默认值 ``--max_restart=3``。
+    -  ``--max_restart`` ：最大重启次数。默认值  ``--max_restart=3`` 。
 
-    - ``--elastic_level``：弹性级别设置，-1：不开启，0：错误节点退出，1：节点内重启。默认值 ``--elastic_level=-1``。
+    -  ``--elastic_level`` ：弹性级别设置，-1：不开启，0：错误节点退出，1：节点内重启。默认值  ``--elastic_level=-1`` 。
 
-    - ``--elastic_timeout``：弹性超时时间，经过该时间达到最小节点数即开启训练。默认值 ``--elastic_timeout=30``。
+    -  ``--elastic_timeout`` ：弹性超时时间，经过该时间达到最小节点数即开启训练。默认值  ``--elastic_timeout=30`` 。
 
 IPU 参数
 :::::::::
-    IPU 分布式训练只需要 3 个参数：``--devices``，``training_script`` 和 ``training_script_args``。对于 IPU 的参数说明如下：
-    ``--devices`` 表示设备个数，例如 ``--devices=4`` 表示当前的训练程序需要 4 个 IPUs。
-    ``training_script`` 只允许设置为 ``ipu`` 。
-    ``training_script_args`` 表示启动 IPU 分布式训练的相关参数。请参看如下各项参数说明。
-    请参考 ``代码实例十``。
+    IPU 分布式训练只需要 3 个参数： ``--devices`` ， ``training_script``  和  ``training_script_args`` 。对于 IPU 的参数说明如下：
+     ``--devices``  表示设备个数，例如  ``--devices=4``  表示当前的训练程序需要 4 个 IPUs。
+     ``training_script``  只允许设置为  ``ipu``  。
+     ``training_script_args``  表示启动 IPU 分布式训练的相关参数。请参看如下各项参数说明。
+    请参考  ``代码实例十`` 。
 
-    - ``--hosts``：IPU 分布式训练的主机 ip，一个主机可包含多个进程。
+    -  ``--hosts`` ：IPU 分布式训练的主机 ip，一个主机可包含多个进程。
 
-    - ``--nproc_per_host``： 每个主机的进程数量。一个进程可包含多个实例。
+    -  ``--nproc_per_host`` ： 每个主机的进程数量。一个进程可包含多个实例。
 
-    - ``--ipus_per_replica``：每个实例包含的 IPU 数量。一个实例可包含多个 IPUs。
+    -  ``--ipus_per_replica`` ：每个实例包含的 IPU 数量。一个实例可包含多个 IPUs。
 
-    - ``--ipu_partition``：分布式训练中使用的 IPU 分区名称。
+    -  ``--ipu_partition`` ：分布式训练中使用的 IPU 分区名称。
 
-    - ``--vipu_server``：IPU 设备管理服务的 ip。
+    -  ``--vipu_server`` ：IPU 设备管理服务的 ip。
 
-    - ``training_script``：分布式训练任务脚本的绝对路径，例如 ``training.py`` 。
+    -  ``training_script`` ：分布式训练任务脚本的绝对路径，例如  ``training.py``  。
 
-    - ``training_script_args``：``training_script`` 的输入参数，与普通起任务时输入的参数一样，例如 ``--lr=0.1``。
+    -  ``training_script_args`` ： ``training_script``  的输入参数，与普通起任务时输入的参数一样，例如  ``--lr=0.1`` 。
 
 返回
 :::::::::
-    ``None``
+     ``None`` 
 
 代码示例零 (主节点，ip/port 自动识别)
 :::::::::
diff --git a/docs/api/paddle/distributed/parallelize_cn.rst b/docs/api/paddle/distributed/parallelize_cn.rst
index 48fcdc01c14..f9ed3e38fbe 100644
--- a/docs/api/paddle/distributed/parallelize_cn.rst
+++ b/docs/api/paddle/distributed/parallelize_cn.rst
@@ -5,11 +5,11 @@ parallelize
 
 .. py:function:: paddle.distributed.parallelize(model, optimizer=None, mesh=None, config=None)
 
-基于用户提供的 ``mesh`` 将单卡视角的模型与优化器（如提供）进行并行化处理，转为分布式视角的模型与优化器（如提供）。
+基于用户提供的  ``mesh``  将单卡视角的模型与优化器（如提供）进行并行化处理，转为分布式视角的模型与优化器（如提供）。
 
 
 .. note::
-    如果提供的 ``config`` 的键中不包含 ``dp_config``，``mp_config`` 与 ``pp_config`` 中的任何字段，则本函数会直接返回 model 与 optimizer。
+    如果提供的  ``config``  的键中不包含  ``dp_config`` ， ``mp_config``  与  ``pp_config``  中的任何字段，则本函数会直接返回 model 与 optimizer。
 
 
 参数
@@ -18,30 +18,30 @@ parallelize
     - **model** (paddle.nn.Layer) - 单卡视角的模型。
     - **optimizer** (paddle.optimizer.Optimizer，可选) - 单卡视角的优化器。默认值为 None。如不提供优化器，则仅对模型进行并行化处理。
     - **mesh** (paddle.distributed.ProcessMesh，可选) - 模型与优化器（如提供）并行所发生的进程空间。最佳用法：在调用本 API 之前，通过
-      调用 ``paddle.distributed.set_mesh`` 方法来配置 mesh 信息，并将本 API 的 mesh 参数设置为 None。注意，如果您通过本 API 传递
+      调用  ``paddle.distributed.set_mesh``  方法来配置 mesh 信息，并将本 API 的 mesh 参数设置为 None。注意，如果您通过本 API 传递
       了 mesh 信息，传入的 mesh 会覆盖外部设置的 mesh。
-    - **config** (dict，可选) - 用来指导并行化的配置。该配置是一个字典，键的值可以从``dp_config``，``mp_config`` 与
-      ``pp_config`` 中进行选择，分别来指导数据并行、模型并行与流水线并行的并行化。一个合法的 config 可以是： ``{"dp_config":
+    - **config** (dict，可选) - 用来指导并行化的配置。该配置是一个字典，键的值可以从 ``dp_config`` ， ``mp_config``  与
+       ``pp_config``  中进行选择，分别来指导数据并行、模型并行与流水线并行的并行化。一个合法的 config 可以是： ``{"dp_config":
       请参考本文档 dp_config 部分以获取更多内容, "mp_config": 请参考本文档 mp_config 部分以获取更多内容,
       "pp_config": 请参考本文档 pp_config 部分以获取更多内容}``。
 
-      dp_config (dict)：指导数据并行的配置。该配置是一个字典，字典的键为 ``sharding_level`` 对应的值可以从 ``0/1/2/3`` 中选择。
-      分别代表数据并行、sharding 并行 stage 1/2/3。一个合法的 dp_config 可以是：``{"sharding_level": 2}``.
+      dp_config (dict)：指导数据并行的配置。该配置是一个字典，字典的键为  ``sharding_level``  对应的值可以从  ``0/1/2/3``  中选择。
+      分别代表数据并行、sharding 并行 stage 1/2/3。一个合法的 dp_config 可以是： ``{"sharding_level": 2}`` .
 
-      mp_config (dict)：指导模型并行的配置。该配置是一个字典，字典的键为 ``parallelize_plan`` 对应值仍然为一个字典，将标识的 Layer 的
+      mp_config (dict)：指导模型并行的配置。该配置是一个字典，字典的键为  ``parallelize_plan``  对应值仍然为一个字典，将标识的 Layer 的
       名字或一个参数的名字与对应的策略进行映射。注意：这里被标识的 Layer 的名字可以按照正则字符串的格式来书写。注意：如果将一个参数的名字与
-      策略进行映射，该参数的名字必须以 weight 或者 bias 结尾。所有合法的策略包含：``ColWiseParallel``，``RowWiseParallel``，
-      ``SequenceParallelBegin``，``SequenceParallelDisable``，``SequenceParallelEnable``，``SequenceParallelEnd``，
-      ``PrepareLayerInput`` 和 ``PrepareLayerOutput``。一个合法的 mp_config 可以是： ``{"parallelize_plan":
+      策略进行映射，该参数的名字必须以 weight 或者 bias 结尾。所有合法的策略包含： ``ColWiseParallel`` ， ``RowWiseParallel`` ，
+       ``SequenceParallelBegin`` ， ``SequenceParallelDisable`` ， ``SequenceParallelEnable`` ， ``SequenceParallelEnd`` ，
+       ``PrepareLayerInput``  和  ``PrepareLayerOutput`` 。一个合法的 mp_config 可以是： ``{"parallelize_plan":
       {"llama.embed_tokens": ColWiseParallel(), "llama.norm": SequenceParallelEnable(),
       "lm_head.weight": ColWiseParallel()}}``。
 
-      pp_config (dict)：指导流水线并行的配置。该配置是一个字典，字典的键为 ``split_spec`` 与 ``global_spec`` （可选）。``split_spec``
-      可以是一个字典或者是一个字符串。如果 ``split_spec`` 是一个字典，它将标识的 Layer 的名字与一个 ``SplitPoint`` 的值进行映射。
-      注意：这里被标识的 Layer 的名字可以按照正则字符串的格式来书写。流水线并行将严格按照 ``split_spec`` 中指定的 Layer 进行切分。如果
-      ``split_spec`` 是一个字符串，它会包含一系列 Layer 名字的前缀。流水线并行会根据流水线并行的规模自动在目标 Layer 集中切分模型。
-      ``global_spec`` 是一个可选择的键，它的值是一个字符串，标明被标识的 Layer 包含需要在各个流水线层间被全局复制的全局张量。一些合法的
-      pp_config 可以是：``{"split_spec": "llama.layers", "global_spec": "llama.global_layer"}`` 或者 ``{"split_spec":
+      pp_config (dict)：指导流水线并行的配置。该配置是一个字典，字典的键为  ``split_spec``  与  ``global_spec``  （可选）。 ``split_spec`` 
+      可以是一个字典或者是一个字符串。如果  ``split_spec``  是一个字典，它将标识的 Layer 的名字与一个  ``SplitPoint``  的值进行映射。
+      注意：这里被标识的 Layer 的名字可以按照正则字符串的格式来书写。流水线并行将严格按照  ``split_spec``  中指定的 Layer 进行切分。如果
+       ``split_spec``  是一个字符串，它会包含一系列 Layer 名字的前缀。流水线并行会根据流水线并行的规模自动在目标 Layer 集中切分模型。
+       ``global_spec``  是一个可选择的键，它的值是一个字符串，标明被标识的 Layer 包含需要在各个流水线层间被全局复制的全局张量。一些合法的
+      pp_config 可以是： ``{"split_spec": "llama.layers", "global_spec": "llama.global_layer"}``  或者 ``{"split_spec":
       {"llama.layers.1": SplitPoint.END}}``。
 
 返回
diff --git a/docs/api/paddle/distributed/recv_cn.rst b/docs/api/paddle/distributed/recv_cn.rst
index 9b9a11a17a5..621c5a48b77 100644
--- a/docs/api/paddle/distributed/recv_cn.rst
+++ b/docs/api/paddle/distributed/recv_cn.rst
@@ -12,12 +12,12 @@ recv
 :::::::::
     - **tensor** (Tensor) - 用于接收数据的 tensor。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
     - **src** (int，可选) - 目标进程的 rank，将接收来自该进程的 tensor。默认为 0，即接收来自 rank=0 的进程的 tensor。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
 
 返回
 :::::::::
-动态图模式下，若为同步操作，无返回值；若为异步操作，返回 ``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+动态图模式下，若为同步操作，无返回值；若为异步操作，返回  ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 静态图模式下，无返回值。
 
diff --git a/docs/api/paddle/distributed/reduce_cn.rst b/docs/api/paddle/distributed/reduce_cn.rst
index 8fc410af55a..5a347476284 100644
--- a/docs/api/paddle/distributed/reduce_cn.rst
+++ b/docs/api/paddle/distributed/reduce_cn.rst
@@ -21,12 +21,12 @@ reduce
     - **tensor** (Tensor) - 输入的 tensor。在目标进程上，返回结果将保存到该 tensor 中。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
     - **dst** (int) - 目标进程的 rank，规约结果将发送到该进程。
     - **op** (ReduceOp.SUM|ReduceOp.MAX|ReduceOp.MIN|ReduceOp.PROD，可选) - 归约的操作类型，包括求和、取最大值、取最小值和求乘积。默认为求和。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
 
 返回
 :::::::::
-动态图模式下，若为同步操作，无返回值；若为异步操作，返回 ``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+动态图模式下，若为同步操作，无返回值；若为异步操作，返回  ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 静态图模式下，无返回值。
 
diff --git a/docs/api/paddle/distributed/reduce_scatter_cn.rst b/docs/api/paddle/distributed/reduce_scatter_cn.rst
index 125c3de238e..d6c6b4b1597 100644
--- a/docs/api/paddle/distributed/reduce_scatter_cn.rst
+++ b/docs/api/paddle/distributed/reduce_scatter_cn.rst
@@ -16,13 +16,13 @@ reduce_scatter
     - **tensor** (Tensor) – 用于接收数据的 tensor，数据类型必须与输入的 tensor 列表保持一致。
     - **tensor_list** (List[Tensor]) – 将被规约和分发的 tensor 列表。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
     - **op** (ReduceOp.SUM|ReduceOp.MAX|ReduceOp.MIN|ReduceOp.PROD，可选) - 归约的操作类型，包括求和、取最大值、取最小值和求乘积。默认为求和。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
 
 
 返回
 :::::::::
-若为同步操作，无返回值；若为异步操作，返回 ``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+若为同步操作，无返回值；若为异步操作，返回  ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/reshard_cn.rst b/docs/api/paddle/distributed/reshard_cn.rst
index a5107774d7b..90054e8065c 100644
--- a/docs/api/paddle/distributed/reshard_cn.rst
+++ b/docs/api/paddle/distributed/reshard_cn.rst
@@ -5,9 +5,9 @@ reshard
 
 .. py:function:: paddle.distributed.reshard(dist_tensor, mesh, placements)
 
-根据新的分布式信息 ``placements`` ，对一个带有分布式信息的 Tensor 进行 reshard 操作，重新进行 Tensor 的分布/切片，返回一个新的分布式 Tensor 。
+根据新的分布式信息  ``placements``  ，对一个带有分布式信息的 Tensor 进行 reshard 操作，重新进行 Tensor 的分布/切片，返回一个新的分布式 Tensor 。
 
-``dist_tensor`` 需要是一个具有分布式信息的 paddle\.Tensor。
+ ``dist_tensor``  需要是一个具有分布式信息的 paddle\.Tensor。
 
 
 参数
diff --git a/docs/api/paddle/distributed/scatter_cn.rst b/docs/api/paddle/distributed/scatter_cn.rst
index 0309487e921..f8e33579f12 100644
--- a/docs/api/paddle/distributed/scatter_cn.rst
+++ b/docs/api/paddle/distributed/scatter_cn.rst
@@ -21,12 +21,12 @@ scatter
     - **tensor** (Tensor) - 用于接收数据的 tensor，数据类型必须与输入的 tensor 列表保持一致。
     - **tensor_list** (List[Tensor]，可选) - 将被分发的 tensor 列表。默认为 None。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
     - **src** (int，可选) - 目标进程的 rank，该进程的 tensor 列表将被分发到其他进程中。默认为 0，即分发 rank=0 的进程上的 tensor 列表。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
 
 返回
 :::::::::
-动态图模式下，若为同步操作，无返回值；若为异步操作，返回 ``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+动态图模式下，若为同步操作，无返回值；若为异步操作，返回  ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 静态图模式下，无返回值。
 
diff --git a/docs/api/paddle/distributed/scatter_object_list_cn.rst b/docs/api/paddle/distributed/scatter_object_list_cn.rst
index 5e193abd6e9..987763f81f0 100644
--- a/docs/api/paddle/distributed/scatter_object_list_cn.rst
+++ b/docs/api/paddle/distributed/scatter_object_list_cn.rst
@@ -7,7 +7,7 @@ scatter_object_list
 .. py:function:: paddle.distributed.scatter_object_list(out_object_list, in_object_list, src=0, group=None)
 
 将一组来自指定进程的 picklable 对象分发到每个进程
-过程与 ``scatter`` 类似，但可以传入自定义的 python 对象。
+过程与  ``scatter``  类似，但可以传入自定义的 python 对象。
 
 .. note::
   该 API 只支持动态图模式。
@@ -17,7 +17,7 @@ scatter_object_list
     - **out_object_list** (List[Any]) - 用于接收数据的 object 列表。
     - **in_object_list** (List[Any]，可选) - 将被分发的 object 列表。默认为 None，因为 rank != src 的进程上的该参数将被忽略。
     - **src** (int，可选) - 目标进程的 rank，该进程的 object 列表将被分发到其他进程中。默认为 0，即分发 rank=0 的进程上的 object 列表。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/distributed/send_cn.rst b/docs/api/paddle/distributed/send_cn.rst
index db03b88b9f0..ad88e58eb71 100644
--- a/docs/api/paddle/distributed/send_cn.rst
+++ b/docs/api/paddle/distributed/send_cn.rst
@@ -12,12 +12,12 @@ send
 :::::::::
     - **tensor** (Tensor) - 待发送的 Tensor。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
     - **dst** (int，可选) - 目标进程的 rank，传入的 tensor 将发送到该进程。默认为 0，即发送到 rank=0 的进程。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
 
 返回
 :::::::::
-动态图模式下，若为同步操作，无返回值；若为异步操作，返回 ``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+动态图模式下，若为同步操作，无返回值；若为异步操作，返回  ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 静态图模式下，无返回值。
 
diff --git a/docs/api/paddle/distributed/shard_tensor_cn.rst b/docs/api/paddle/distributed/shard_tensor_cn.rst
index a2e61acff26..7a8e5788cc8 100644
--- a/docs/api/paddle/distributed/shard_tensor_cn.rst
+++ b/docs/api/paddle/distributed/shard_tensor_cn.rst
@@ -5,10 +5,10 @@ shard_tensor
 
 .. py:function:: paddle.distributed.shard_tensor(data, mesh, placements, dtype=None, place=None, stop_gradient=True)
 
-通过已知的 ``data`` 来创建一个带有分布式信息的 Tensor，Tensor 类型为 ``paddle.Tensor``。
-``data`` 可以是 scalar，tuple，list，numpy\.ndarray，paddle\.Tensor。
+通过已知的  ``data``  来创建一个带有分布式信息的 Tensor，Tensor 类型为  ``paddle.Tensor`` 。
+ ``data``  可以是 scalar，tuple，list，numpy\.ndarray，paddle\.Tensor。
 
-如果 ``data`` 已经是一个 Tensor，将其转换为一个分布式 Tensor。
+如果  ``data``  已经是一个 Tensor，将其转换为一个分布式 Tensor。
 
 
 参数
@@ -18,13 +18,13 @@ shard_tensor
     - **mesh** (paddle.distributed.ProcessMesh) - 表示进程拓扑信息的 ProcessMesh 对象。
     - **placements** (list(Placement)) - 分布式 Tensor 的切分表示列表，描述 Tensor 在 mesh 上如何切分。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 创建 Tensor 的数据类型，可以是 bool、float16、float32、float64、int8、int16、int32、int64、uint8、complex64、complex128。
-      默认值为 None，如果 ``data`` 为 python 浮点类型，则从 :ref:`cn_api_paddle_get_default_dtype` 获取类型，如果 ``data`` 为其他类型，则会自动推导类型。
+      默认值为 None，如果  ``data``  为 python 浮点类型，则从 :ref:`cn_api_paddle_get_default_dtype` 获取类型，如果  ``data``  为其他类型，则会自动推导类型。
     - **place** (CPUPlace|CUDAPinnedPlace|CUDAPlace，可选) - 创建 tensor 的设备位置，可以是 CPUPlace、CUDAPinnedPlace、CUDAPlace。默认值为 None，使用全局的 place。
     - **stop_gradient** (bool，可选) - 是否阻断 Autograd 的梯度传导。默认值为 True，此时不进行梯度传传导。
 
 返回
 :::::::::
-通过 ``data`` 创建的带有分布式信息的 Tensor。
+通过  ``data``  创建的带有分布式信息的 Tensor。
 
 
 代码示例
diff --git a/docs/api/paddle/distributed/spawn_cn.rst b/docs/api/paddle/distributed/spawn_cn.rst
index 94657ba6cea..535c84ed457 100644
--- a/docs/api/paddle/distributed/spawn_cn.rst
+++ b/docs/api/paddle/distributed/spawn_cn.rst
@@ -5,23 +5,23 @@ spawn
 
 .. py:function:: paddle.distributed.spawn(func, args=(), nprocs=-1, join=True, daemon=False, **options)
 
-使用 ``spawn`` 方法启动多进程任务。
+使用  ``spawn``  方法启动多进程任务。
 
 .. note::
-    ``spawn`` 目前仅支持 GPU 和 XPU 的 collective 模式。GPU 和 XPU 的 collective 模式不能同时启动，因此 `gpus` 和 `xpus` 这两个参数不能同时配置。
+     ``spawn``  目前仅支持 GPU 和 XPU 的 collective 模式。GPU 和 XPU 的 collective 模式不能同时启动，因此 `gpus` 和 `xpus` 这两个参数不能同时配置。
 
 参数
 :::::::::
-    - **func** (function) - 由 ``spawn`` 方法启动的进程所调用的目标函数。该目标函数需要能够被 ``pickled`` (序列化)，所以目标函数必须定义为模块的一级函数，不能是内部子函数或者类方法。
-    - **args** (tuple，可选) - 传入目标函数 ``func`` 的参数。
-    - **nprocs** (int，可选) - 启动进程的数目。默认值为-1。当 ``nproc`` 为-1 时，模型执行时将会从环境变量中获取当前可用的所有设备进行使用：如果使用 GPU 执行任务，将会从环境变量 ``CUDA_VISIBLE_DEVICES`` 中获取当前所有可用的设备 ID；如果使用 XPU 执行任务，将会从环境变量 ``XPU_VISIBLE_DEVICES`` 中获取当前所有可用的设备 ID。
-    - **join** (bool，可选) - 对所有启动的进程执行阻塞的 ``join``，等待进程执行结束。默认为 True。
-    - **daemon** (bool，可选) - 配置启动进程的 ``daemon`` 属性。默认为 False。
-    - **options (dict，可选) - 其他初始化并行执行环境的配置选项。目前支持以下选项：(1) start_method (string) - 启动子进程的方法。进程的启动方法可以是 ``spawn`` ， ``fork`` , ``forkserver``。因为 CUDA 运行时环境不支持 ``fork`` 方法，当在子进程中使用 CUDA 时，需要使用 ``spawn`` 或者 ``forkserver`` 方法启动进程。默认方法为 ``spawn`` ； (2) gpus (string) - 指定训练使用的 GPU ID，例如 "0,1,2,3"，默认值为 None ； (3) xpus (string) - 指定训练使用的 XPU ID，例如 "0,1,2,3"，默认值为 None ； (4) ips (string) - 运行集群的节点（机器）IP，例如 "192.168.0.16,192.168.0.17"，默认值为 "127.0.0.1" 。
+    - **func** (function) - 由  ``spawn``  方法启动的进程所调用的目标函数。该目标函数需要能够被  ``pickled``  (序列化)，所以目标函数必须定义为模块的一级函数，不能是内部子函数或者类方法。
+    - **args** (tuple，可选) - 传入目标函数  ``func``  的参数。
+    - **nprocs** (int，可选) - 启动进程的数目。默认值为-1。当  ``nproc``  为-1 时，模型执行时将会从环境变量中获取当前可用的所有设备进行使用：如果使用 GPU 执行任务，将会从环境变量  ``CUDA_VISIBLE_DEVICES``  中获取当前所有可用的设备 ID；如果使用 XPU 执行任务，将会从环境变量  ``XPU_VISIBLE_DEVICES``  中获取当前所有可用的设备 ID。
+    - **join** (bool，可选) - 对所有启动的进程执行阻塞的  ``join`` ，等待进程执行结束。默认为 True。
+    - **daemon** (bool，可选) - 配置启动进程的  ``daemon``  属性。默认为 False。
+    - **options (dict，可选) - 其他初始化并行执行环境的配置选项。目前支持以下选项：(1) start_method (string) - 启动子进程的方法。进程的启动方法可以是  ``spawn``  ，  ``fork``  ,  ``forkserver`` 。因为 CUDA 运行时环境不支持  ``fork``  方法，当在子进程中使用 CUDA 时，需要使用  ``spawn``  或者  ``forkserver``  方法启动进程。默认方法为  ``spawn``  ； (2) gpus (string) - 指定训练使用的 GPU ID，例如 "0,1,2,3"，默认值为 None ； (3) xpus (string) - 指定训练使用的 XPU ID，例如 "0,1,2,3"，默认值为 None ； (4) ips (string) - 运行集群的节点（机器）IP，例如 "192.168.0.16,192.168.0.17"，默认值为 "127.0.0.1" 。
 
 返回
 :::::::::
- ``MultiprocessContext`` 对象，持有创建的多个进程。
+  ``MultiprocessContext``  对象，持有创建的多个进程。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/stream/all_gather_cn.rst b/docs/api/paddle/distributed/stream/all_gather_cn.rst
index 9937ddb529c..5ff924a7f5a 100644
--- a/docs/api/paddle/distributed/stream/all_gather_cn.rst
+++ b/docs/api/paddle/distributed/stream/all_gather_cn.rst
@@ -17,13 +17,13 @@ all_gather
 :::::::::
     - **tensor_or_tensor_list** (Tensor|List[Tensor]) - 用于保存聚合结果。若为 tensor，该 tensor 的大小必须与所有待聚合的 tensor 沿 dim[0] 拼接后的大小相同。若为 tensor 列表，其中每个 tensor 的数据类型必须与输入的 tensor 保持一致。
     - **tensor** (Tensor) - 待聚合的 tensor。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16、complex64、complex128。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
     - **use_calc_stream** (bool，可选) - 该操作是否在计算流上进行。默认为 False，即不在计算流上进行。该参数旨在提高同步操作的性能，请确保在充分了解其含义的情况下调整该参数的值。
 
 返回
 :::::::::
-``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+ ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/stream/all_reduce_cn.rst b/docs/api/paddle/distributed/stream/all_reduce_cn.rst
index 935280a75cb..f6b2f357ba2 100644
--- a/docs/api/paddle/distributed/stream/all_reduce_cn.rst
+++ b/docs/api/paddle/distributed/stream/all_reduce_cn.rst
@@ -17,13 +17,13 @@ all_reduce
 :::::::::
     - **tensor** (Tensor) - 输入的 tensor。返回结果也将保存到该 tensor 中。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
     - **op** (ReduceOp.SUM|ReduceOp.MAX|ReduceOp.MIN|ReduceOp.PROD|ReduceOp.AVG，可选) - 归约的操作类型，包括求和、取最大值、取最小值、求乘积和求平均值。默认为求和。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
     - **use_calc_stream** (bool，可选) - 该操作是否在计算流上进行。默认为 False，即不在计算流上进行。该参数旨在提高同步操作的性能，请确保在充分了解其含义的情况下调整该参数的值。
 
 返回
 :::::::::
-``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+ ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/stream/alltoall_cn.rst b/docs/api/paddle/distributed/stream/alltoall_cn.rst
index 097dcccf25c..926f5981a70 100644
--- a/docs/api/paddle/distributed/stream/alltoall_cn.rst
+++ b/docs/api/paddle/distributed/stream/alltoall_cn.rst
@@ -17,13 +17,13 @@ alltoall
 :::::::::
     - **out_tensor_or_tensor_list** (Tensor|List[Tensor]) - 用于保存操作结果。若输入数据为 tensor，该参数必须为 tensor，且大小与所有输入的 tensor 沿 dim[0] 拼接后的大小相同。若输入数据为 tensor 列表，该参数必须为 tensor 列表，其中每个 tensor 的数据类型必须与输入的 tensor 保持一致。
     - **in_tensor_or_tensor_list** (Tensor|List[Tensor]) - 输入的数据，可以是一个 tensor 或 tensor 列表。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
     - **use_calc_stream** (bool，可选) - 该操作是否在计算流上进行。默认为 False，即不在计算流上进行。该参数旨在提高同步操作的性能，请确保在充分了解其含义的情况下调整该参数的值。
 
 返回
 :::::::::
-``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+ ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/stream/alltoall_single_cn.rst b/docs/api/paddle/distributed/stream/alltoall_single_cn.rst
index d4499c09805..4b4243b7a4a 100644
--- a/docs/api/paddle/distributed/stream/alltoall_single_cn.rst
+++ b/docs/api/paddle/distributed/stream/alltoall_single_cn.rst
@@ -6,7 +6,7 @@ alltoall_single
 
 .. py:function:: paddle.distributed.stream.alltoall_single(out_tensor, in_tensor, out_split_sizes=None, in_split_sizes=None, group=None, sync_op=True, use_calc_stream=False)
 
-将一个 tensor 分发到每个进程，随后在每个进程上聚合分发结果。与 ``alltoall`` 相比，可以更精细地控制分发过程。
+将一个 tensor 分发到每个进程，随后在每个进程上聚合分发结果。与  ``alltoall``  相比，可以更精细地控制分发过程。
 
 参见 :ref:`paddle.distributed.alltoall_single<cn_api_paddle_distributed_alltoall_single>`。
 
@@ -19,13 +19,13 @@ alltoall_single
     - **in_tensor** (Tensor): 输入的 tensor。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
     - **out_split_sizes** (List[int]，可选): 对 out_tensor 的 dim[0] 进行切分的大小。默认为 None，即 out_tensor 将均匀地聚合各个进程的数据（需要确保 out_tensor 的大小能够被组中的进程数整除）。
     - **in_split_sizes** (List[int]，可选): 对 in_tensor 的 dim[0] 进行切分的大小。默认为 None，即将 in_tensor 均匀地分发到各个进程中（需要确保 in_tensor 的大小能够被组中的进程数整除）。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
     - **use_calc_stream** (bool，可选) - 该操作是否在计算流上进行。默认为 False，即不在计算流上进行。该参数旨在提高同步操作的性能，请确保在充分了解其含义的情况下调整该参数的值。
 
 返回
 :::::::::
-``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+ ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/stream/broadcast_cn.rst b/docs/api/paddle/distributed/stream/broadcast_cn.rst
index bf1542a9af4..e0f99a306bc 100644
--- a/docs/api/paddle/distributed/stream/broadcast_cn.rst
+++ b/docs/api/paddle/distributed/stream/broadcast_cn.rst
@@ -17,13 +17,13 @@ broadcast
 :::::::::
     - **tensor** (Tensor) - 在目标进程上为待广播的 tensor，在其他进程上为用于接收广播结果的 tensor。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
     - **src** (int，可选) - 目标进程的 rank，该进程传入的 tensor 将被发送到其他进程上。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
     - **use_calc_stream** (bool，可选) - 该操作是否在计算流上进行。默认为 False，即不在计算流上进行。该参数旨在提高同步操作的性能，请确保在充分了解其含义的情况下调整该参数的值。
 
 返回
 :::::::::
-``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+ ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/stream/recv_cn.rst b/docs/api/paddle/distributed/stream/recv_cn.rst
index 016d6bd66f7..fb4cdda9f5b 100644
--- a/docs/api/paddle/distributed/stream/recv_cn.rst
+++ b/docs/api/paddle/distributed/stream/recv_cn.rst
@@ -17,13 +17,13 @@ recv
 :::::::::
     - **tensor** (Tensor) - 用于接收数据的 tensor。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
     - **src** (int，可选) - 目标进程的 rank，将接收来自该进程的 tensor。默认为 0，即接收来自 rank=0 的进程的 tensor。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
     - **use_calc_stream** (bool，可选) - 该操作是否在计算流上进行。默认为 False，即不在计算流上进行。该参数旨在提高同步操作的性能，请确保在充分了解其含义的情况下调整该参数的值。
 
 返回
 :::::::::
-``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+ ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/stream/reduce_cn.rst b/docs/api/paddle/distributed/stream/reduce_cn.rst
index c761db966fe..5675d063315 100644
--- a/docs/api/paddle/distributed/stream/reduce_cn.rst
+++ b/docs/api/paddle/distributed/stream/reduce_cn.rst
@@ -18,13 +18,13 @@ reduce
     - **tensor** (Tensor) - 输入的 tensor。在目标进程上，返回结果将保存到该 tensor 中。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
     - **dst** (int，可选) - 目标进程的 rank，规约结果将发送到该进程。默认为 0，即结果将发送到 rank=0 的进程。
     - **op** (ReduceOp.SUM|ReduceOp.MAX|ReduceOp.MIN|ReduceOp.PROD|ReduceOp.AVG，可选) - 归约的操作类型，包括求和、取最大值、取最小值、求乘积和求平均值。默认为求和。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
     - **use_calc_stream** (bool，可选) - 该操作是否在计算流上进行。默认为 False，即不在计算流上进行。该参数旨在提高同步操作的性能，请确保在充分了解其含义的情况下调整该参数的值。
 
 返回
 :::::::::
-``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+ ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/stream/reduce_scatter_cn.rst b/docs/api/paddle/distributed/stream/reduce_scatter_cn.rst
index 75b17a013e3..a702d4fde37 100644
--- a/docs/api/paddle/distributed/stream/reduce_scatter_cn.rst
+++ b/docs/api/paddle/distributed/stream/reduce_scatter_cn.rst
@@ -18,14 +18,14 @@ reduce_scatter
     - **tensor** (Tensor) – 用于接收数据的 tensor，数据类型必须与输入保持一致。
     - **tensor_or_tensor_list** (Tensor|List[Tensor]) - 输入的数据，可以是一个 tensor 或 tensor 列表。若为 tensor，该 tensor 的大小必须与所有用于接收数据的 tensor 沿 dim[0] 拼接后的大小相同。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
     - **op** (ReduceOp.SUM|ReduceOp.MAX|ReduceOp.MIN|ReduceOp.PROD|ReduceOp.AVG，可选) - 归约的操作类型，包括求和、取最大值、取最小值、求乘积和求平均值。默认为求和。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
     - **use_calc_stream** (bool，可选) - 该操作是否在计算流上进行。默认为 False，即不在计算流上进行。该参数旨在提高同步操作的性能，请确保在充分了解其含义的情况下调整该参数的值。
 
 
 返回
 :::::::::
-``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+ ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/stream/scatter_cn.rst b/docs/api/paddle/distributed/stream/scatter_cn.rst
index 7753cb0c7f5..edad0985ebf 100644
--- a/docs/api/paddle/distributed/stream/scatter_cn.rst
+++ b/docs/api/paddle/distributed/stream/scatter_cn.rst
@@ -18,13 +18,13 @@ scatter
     - **tensor** (Tensor) - 用于接收数据的 tensor，数据类型必须与输入保持一致。
     - **tensor_or_tensor_list** (Tensor|List[Tensor]，可选) - 待分发的数据，可以是一个 tensor 或 tensor 列表。若为 tensor，该 tensor 的大小必须与所有用于接收数据的 tensor 沿 dim[0] 拼接后的大小相同。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。默认为 None，因为非目标进程上的该参数将被忽略。
     - **src** (int，可选) - 目标进程的 rank，该进程的 tensor 列表将被分发到其他进程中。默认为 0，即分发 rank=0 的进程上的 tensor 列表。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
     - **use_calc_stream** (bool，可选) - 该操作是否在计算流上进行。默认为 False，即不在计算流上进行。该参数旨在提高同步操作的性能，请确保在充分了解其含义的情况下调整该参数的值。
 
 返回
 :::::::::
-``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+ ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/stream/send_cn.rst b/docs/api/paddle/distributed/stream/send_cn.rst
index af11ac3cf8e..f368b71084e 100644
--- a/docs/api/paddle/distributed/stream/send_cn.rst
+++ b/docs/api/paddle/distributed/stream/send_cn.rst
@@ -17,13 +17,13 @@ send
 :::::::::
     - **tensor** (Tensor) - 待发送的 Tensor。支持的数据类型包括：float16、float32、float64、int32、int64、int8、uint8、bool、bfloat16。
     - **dst** (int，可选) - 目标进程的 rank，传入的 tensor 将发送到该进程。默认为 0，即发送到 rank=0 的进程。
-    - **group** (Group，可选) - 执行该操作的进程组实例（通过 ``new_group`` 创建）。默认为 None，即使用全局默认进程组。
+    - **group** (Group，可选) - 执行该操作的进程组实例（通过  ``new_group``  创建）。默认为 None，即使用全局默认进程组。
     - **sync_op** (bool，可选) - 该操作是否为同步操作。默认为 True，即同步操作。
     - **use_calc_stream** (bool，可选) - 该操作是否在计算流上进行。默认为 False，即不在计算流上进行。该参数旨在提高同步操作的性能，请确保在充分了解其含义的情况下调整该参数的值。
 
 返回
 :::::::::
-``Task``。通过 ``Task``，可以查看异步操作的执行状态以及等待异步操作的结果。
+ ``Task`` 。通过  ``Task`` ，可以查看异步操作的执行状态以及等待异步操作的结果。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/distributed/to_distributed_cn.rst b/docs/api/paddle/distributed/to_distributed_cn.rst
index 1dba1736807..fce9fca7136 100644
--- a/docs/api/paddle/distributed/to_distributed_cn.rst
+++ b/docs/api/paddle/distributed/to_distributed_cn.rst
@@ -16,9 +16,9 @@ to_distributed
 :::::::::
 
     - **model** (paddle.nn.Layer) - 单卡视角的模型，没有包含任何分布式代码。
-    - **optimizer** (paddle.optimizer.Optimizer) - 单卡视角的优化器，通过常规优化器 API 构造，如 ``paddle.optimizer.Adam``。
-    - **dataloader** (paddle.io.DataLoader) - 单卡视角的数据加载器，通过常规方式沟通，如 ``paddle.io.Dataset`` 及 ``paddle.io.Sampler``, 无需使用 ``paddle.io.DistributedBatchSampler``。
-    - **config** (ToDistributedConfig，可选) - 可以用来配置 输入数据信息 和 是否使用序列并行。配置时使用数据类 ``paddle.distributed.auto_parallel.high_level_api.ToDistributedConfig`` 来完成。
+    - **optimizer** (paddle.optimizer.Optimizer) - 单卡视角的优化器，通过常规优化器 API 构造，如  ``paddle.optimizer.Adam`` 。
+    - **dataloader** (paddle.io.DataLoader) - 单卡视角的数据加载器，通过常规方式沟通，如  ``paddle.io.Dataset``  及  ``paddle.io.Sampler`` , 无需使用  ``paddle.io.DistributedBatchSampler`` 。
+    - **config** (ToDistributedConfig，可选) - 可以用来配置 输入数据信息 和 是否使用序列并行。配置时使用数据类  ``paddle.distributed.auto_parallel.high_level_api.ToDistributedConfig``  来完成。
 
       配置 输入数据信息，是提供模型训练时最有可能输入数据的 shape、dtype 和 stop_gradient 信息，便于更快更准地自动选择最优的分布式策略。
 
diff --git a/docs/api/paddle/distributed/to_static_cn.rst b/docs/api/paddle/distributed/to_static_cn.rst
index 091359cde18..24679e6001c 100644
--- a/docs/api/paddle/distributed/to_static_cn.rst
+++ b/docs/api/paddle/distributed/to_static_cn.rst
@@ -5,9 +5,9 @@ to_static
 
 .. py:function:: paddle.distributed.to_static(layer, loader, loss=None, optimizer=None, strategy=None)
 
-将带有分布式切分信息的动态图 ``layer`` 转换为静态图分布式模型, 可在静态图模式下进行分布式训练；同时将动态图下所使用的数据迭代器 ``loader`` 转换为静态图分布式训练所使用的数据迭代器。
+将带有分布式切分信息的动态图  ``layer``  转换为静态图分布式模型, 可在静态图模式下进行分布式训练；同时将动态图下所使用的数据迭代器  ``loader``  转换为静态图分布式训练所使用的数据迭代器。
 
-``paddle.distributed.to_static`` 返回 ``DistModel`` 实例和 ``DistributedDataLoader`` 实例。 ``DistModel`` 实例包含了转换后的静态图模型，同时提供了训练、评估和预测的接口。 ``DistributedDataLoader`` 实例用于在静态图分布式训练中加载数据。
+ ``paddle.distributed.to_static``  返回  ``DistModel``  实例和  ``DistributedDataLoader``  实例。  ``DistModel``  实例包含了转换后的静态图模型，同时提供了训练、评估和预测的接口。  ``DistributedDataLoader``  实例用于在静态图分布式训练中加载数据。
 
 
 参数
@@ -21,9 +21,9 @@ to_static
 
 返回
 :::::::::
-DistModel: 用于静态图分布式训练的模型，通过 ``__call__`` 方法进行训练、评估和预测。需要执行训练、评估或预测时，需要先使用 ``DistModel`` 实例的 ``train()/eval()/predict()`` 方法将其转换为对应的模式。  ``DistModel`` 实例的默认模式会根据 ``paddle.distributed.to_static`` 的输入设置，当 ``loss`` 和 ``optimizer`` 均给定时，默认模式为 ``train``；当 ``optimizer`` 为空时，默认模式为 ``eval``；当 ``loss`` 和 ``optimizer`` 均为空时，默认模式为 ``predict``。
+DistModel: 用于静态图分布式训练的模型，通过  ``__call__``  方法进行训练、评估和预测。需要执行训练、评估或预测时，需要先使用  ``DistModel``  实例的  ``train()/eval()/predict()``  方法将其转换为对应的模式。   ``DistModel``  实例的默认模式会根据  ``paddle.distributed.to_static``  的输入设置，当  ``loss``  和  ``optimizer``  均给定时，默认模式为  ``train`` ；当  ``optimizer``  为空时，默认模式为  ``eval`` ；当  ``loss``  和  ``optimizer``  均为空时，默认模式为  ``predict`` 。
 
-DistributedDataLoader: 用于静态图分布式训练的数据迭代器，和 ``paddle.io.DataLoader`` 用法一致。
+DistributedDataLoader: 用于静态图分布式训练的数据迭代器，和  ``paddle.io.DataLoader``  用法一致。
 
 
 代码示例
diff --git a/docs/api/paddle/distributed/unshard_dtensor_cn.rst b/docs/api/paddle/distributed/unshard_dtensor_cn.rst
index 55f71aef0e4..694119f689c 100644
--- a/docs/api/paddle/distributed/unshard_dtensor_cn.rst
+++ b/docs/api/paddle/distributed/unshard_dtensor_cn.rst
@@ -15,7 +15,7 @@ unshard_dtensor
 
 返回
 :::::::::
-paddle.Tensor: 不带分布式信息的普通 Tensor，包含 ``dist_tensor`` 的全局数据。
+paddle.Tensor: 不带分布式信息的普通 Tensor，包含  ``dist_tensor``  的全局数据。
 
 
 代码示例
diff --git a/docs/api/paddle/distribution/AbsTransform_cn.rst b/docs/api/paddle/distribution/AbsTransform_cn.rst
index f76daabbdc4..4f333d0bd1c 100644
--- a/docs/api/paddle/distribution/AbsTransform_cn.rst
+++ b/docs/api/paddle/distribution/AbsTransform_cn.rst
@@ -7,12 +7,12 @@ AbsTransform
 
 取绝对值变换 :math:`y = |x|` 。
 
-``AbsTransform`` 不是双射变换，其逆变换处理逻辑如下：
+ ``AbsTransform``  不是双射变换，其逆变换处理逻辑如下：
 
-* 当 :math:`y \in (0, +\infty )` , ``AbsTransform.inverse(y)`` 返回元组 ``(-y, y)`` 。
-* 当 :math:`y=0` , ``AbsTransform.inverse(y)`` 返回 ``(0, 0)`` 。
-* 当 :math:`y \in (-\infty, 0)`，为了避免对 ``Tensor`` 数据进行判断带来性能下降，
-  ``AbsTransform.inverse(y)`` 仍返回 ``(-y, y)``，注意这本质上是一个错误结果，仅仅出于
+* 当 :math:`y \in (0, +\infty )` ,  ``AbsTransform.inverse(y)``  返回元组  ``(-y, y)``  。
+* 当 :math:`y=0` ,  ``AbsTransform.inverse(y)``  返回  ``(0, 0)``  。
+* 当 :math:`y \in (-\infty, 0)`，为了避免对  ``Tensor``  数据进行判断带来性能下降，
+   ``AbsTransform.inverse(y)``  仍返回  ``(-y, y)`` ，注意这本质上是一个错误结果，仅仅出于
   性能考虑。
 
 
@@ -57,7 +57,7 @@ forward_log_det_jacobian(x)
 
 计算正变换雅可比行列式绝对值的对数。
 
-如果变换不是一一映射，则雅可比矩阵不存在，返回 ``NotImplementedError`` 。
+如果变换不是一一映射，则雅可比矩阵不存在，返回  ``NotImplementedError``  。
 
 **参数**
 
@@ -73,7 +73,7 @@ inverse_log_det_jacobian(y)
 
 计算逆变换雅可比行列式绝对值的对数。
 
-与 ``forward_log_det_jacobian`` 互为负数。
+与  ``forward_log_det_jacobian``  互为负数。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/AffineTransform_cn.rst b/docs/api/paddle/distribution/AffineTransform_cn.rst
index f9e35b1525f..d9c3bfeb7b1 100644
--- a/docs/api/paddle/distribution/AffineTransform_cn.rst
+++ b/docs/api/paddle/distribution/AffineTransform_cn.rst
@@ -55,7 +55,7 @@ forward_log_det_jacobian(x)
 
 计算正变换雅可比行列式绝对值的对数。
 
-如果变换不是一一映射，则雅可比矩阵不存在，返回 ``NotImplementedError`` 。
+如果变换不是一一映射，则雅可比矩阵不存在，返回  ``NotImplementedError``  。
 
 **参数**
 
@@ -71,7 +71,7 @@ inverse_log_det_jacobian(y)
 
 计算逆变换雅可比行列式绝对值的对数。
 
-与 ``forward_log_det_jacobian`` 互为负数。
+与  ``forward_log_det_jacobian``  互为负数。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/Bernoulli_cn.rst b/docs/api/paddle/distribution/Bernoulli_cn.rst
index 5b0867efccd..9248c5440e9 100644
--- a/docs/api/paddle/distribution/Bernoulli_cn.rst
+++ b/docs/api/paddle/distribution/Bernoulli_cn.rst
@@ -75,19 +75,19 @@ rsample(shape=[], temperature=1.0)
 
 重参数化采样，生成指定维度的样本。
 
-``rsample`` 是连续近似的伯努利分布重参数化样本方法。
+ ``rsample``  是连续近似的伯努利分布重参数化样本方法。
 
 [1] Chris J. Maddison, Andriy Mnih, and Yee Whye Teh. The Concrete Distribution: A Continuous Relaxation of Discrete Random Variables. 2016.
 
 [2] Eric Jang, Shixiang Gu, and Ben Poole. Categorical Reparameterization with Gumbel-Softmax. 2016.
 
 .. note::
-   ``rsample`` 后面需要跟一个 ``sigmoid``，从而将样本的值转换为单位间隔 :math:`(0, 1)`。
+    ``rsample``  后面需要跟一个  ``sigmoid`` ，从而将样本的值转换为单位间隔 :math:`(0, 1)`。
 
 **参数**
 
     - **shape** (Sequence[int]，可选) - 指定生成样本的维度。
-    - **temperature** (float) - ``rsample`` 的温度，必须为正值。
+    - **temperature** (float) -  ``rsample``  的温度，必须为正值。
 
 **返回**
 
@@ -100,7 +100,7 @@ COPY-FROM: paddle.distribution.Bernoulli.rsample
 cdf(value)
 '''''''''
 
-``value`` 的累积分布函数 （CDF）
+ ``value``  的累积分布函数 （CDF）
 
 .. math::
 
@@ -117,7 +117,7 @@ cdf(value)
 
 **返回**
 
-Tensor， ``value`` 的累积分布函数。
+Tensor，  ``value``  的累积分布函数。
 
 **代码示例**
 
@@ -134,7 +134,7 @@ log_prob(value)
 
 **返回**
 
-Tensor， ``value`` 的对数概率密度函数。
+Tensor，  ``value``  的对数概率密度函数。
 
 **代码示例**
 
@@ -143,7 +143,7 @@ COPY-FROM: paddle.distribution.Bernoulli.log_prob
 prob(value)
 '''''''''
 
-``value`` 的概率密度函数。
+ ``value``  的概率密度函数。
 
 .. math::
 
@@ -159,7 +159,7 @@ prob(value)
 
 **返回**
 
-Tensor， ``value`` 的概率密度函数。
+Tensor，  ``value``  的概率密度函数。
 
 **代码示例**
 
@@ -197,7 +197,7 @@ kl_divergence(other)
 
 **参数**
 
-    - **other** (Bernoulli) - ``Bernoulli`` 的实例。
+    - **other** (Bernoulli) -  ``Bernoulli``  的实例。
 
 **返回**
 
diff --git a/docs/api/paddle/distribution/Beta_cn.rst b/docs/api/paddle/distribution/Beta_cn.rst
index 8278e305862..715e5236f26 100644
--- a/docs/api/paddle/distribution/Beta_cn.rst
+++ b/docs/api/paddle/distribution/Beta_cn.rst
@@ -26,10 +26,10 @@ Beta
 :::::::::
 
 - **alpha** (float|Tensor) - 即上述公式中 :math:`\alpha` 参数，大于零，支持 Broadcast
-  语义。当参数类型为 Tensor 时，表示批量创建多个不同参数的分布，``batch_shape`` (参考 :ref:`cn_api_paddle_distribution_Distribution` 基类) 为参数
+  语义。当参数类型为 Tensor 时，表示批量创建多个不同参数的分布， ``batch_shape``  (参考 :ref:`cn_api_paddle_distribution_Distribution` 基类) 为参数
   Broadcast 后的形状。
 - **beta** (float|Tensor) - 即上述公式中 :math:`\beta` 参数，大于零，支持 Broadcast 语
-  义。当参数类型为 Tensor 时，表示批量创建多个不同参数的分布，``batch_shape`` (参考 :ref:`cn_api_paddle_distribution_Distribution` 基类) 为参数 Broadcast
+  义。当参数类型为 Tensor 时，表示批量创建多个不同参数的分布， ``batch_shape``  (参考 :ref:`cn_api_paddle_distribution_Distribution` 基类) 为参数 Broadcast
   后的形状。
 
 代码示例
@@ -87,7 +87,7 @@ sample(shape=[])
 
 **参数**
 
-- **shape** (Sequence[int]，可选)：采样次数。最终生成样本形状为 ``shape+batch_shape`` 。
+- **shape** (Sequence[int]，可选)：采样次数。最终生成样本形状为  ``shape+batch_shape``  。
 
 **返回**
 
diff --git a/docs/api/paddle/distribution/Binomial_cn.rst b/docs/api/paddle/distribution/Binomial_cn.rst
index f17648dc681..41a207b262b 100644
--- a/docs/api/paddle/distribution/Binomial_cn.rst
+++ b/docs/api/paddle/distribution/Binomial_cn.rst
@@ -90,7 +90,7 @@ Tensor，value 的对数概率。数据类型与 :attr:`probs` 相同。
 sample(shape=[])
 '''''''''
 
-从 Binomial 分布中生成满足特定形状的样本数据。最终生成样本形状为 ``shape+batch_shape`` 。
+从 Binomial 分布中生成满足特定形状的样本数据。最终生成样本形状为  ``shape+batch_shape``  。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/Categorical_cn.rst b/docs/api/paddle/distribution/Categorical_cn.rst
index b64e959f60c..3b21c0a91a2 100644
--- a/docs/api/paddle/distribution/Categorical_cn.rst
+++ b/docs/api/paddle/distribution/Categorical_cn.rst
@@ -87,9 +87,9 @@ probs(value)
 '''''''''
 
 所选择类别的概率。
-如果 ``logits`` 是 2-D 或更高阶的 Tensor，那么其最后一个维度表示不同类别的概率，其它维度被看做不同的概率分布。
-同时，如果 ``value`` 是 1-D Tensor，那么 ``value`` 会 broadcast 成与 ``logits`` 具有相同的概率分布数量。
-如果 ``value`` 为更高阶 Tensor，那么 ``value`` 应该与 ``logits`` 具有相同的概率分布数量。也就是说，``value.shape[:-1] = logits.shape[:-1]`` 。
+如果  ``logits``  是 2-D 或更高阶的 Tensor，那么其最后一个维度表示不同类别的概率，其它维度被看做不同的概率分布。
+同时，如果  ``value``  是 1-D Tensor，那么  ``value``  会 broadcast 成与  ``logits``  具有相同的概率分布数量。
+如果  ``value``  为更高阶 Tensor，那么  ``value``  应该与  ``logits``  具有相同的概率分布数量。也就是说， ``value.shape[:-1] = logits.shape[:-1]``  。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/Cauchy_cn.rst b/docs/api/paddle/distribution/Cauchy_cn.rst
index d49619b874c..d222e6a03b5 100644
--- a/docs/api/paddle/distribution/Cauchy_cn.rst
+++ b/docs/api/paddle/distribution/Cauchy_cn.rst
@@ -100,7 +100,7 @@ COPY-FROM: paddle.distribution.Cauchy.rsample
 prob(value)
 '''''''''
 
-``value`` 的概率密度函数。
+ ``value``  的概率密度函数。
 
 .. math::
 
@@ -112,7 +112,7 @@ prob(value)
 
 **返回**
 
-Tensor， ``value`` 的概率密度函数。
+Tensor，  ``value``  的概率密度函数。
 
 **代码示例**
 
@@ -129,7 +129,7 @@ log_prob(value)
 
 **返回**
 
-Tensor， ``value`` 的对数概率密度函数。
+Tensor，  ``value``  的对数概率密度函数。
 
 **代码示例**
 
@@ -138,7 +138,7 @@ COPY-FROM: paddle.distribution.Cauchy.log_prob
 cdf(value)
 '''''''''
 
-``value`` 的累积分布函数 （CDF）
+ ``value``  的累积分布函数 （CDF）
 
 .. math::
 
@@ -150,7 +150,7 @@ cdf(value)
 
 **返回**
 
-Tensor， ``value`` 的累积分布函数。
+Tensor，  ``value``  的累积分布函数。
 
 **代码示例**
 
@@ -183,7 +183,7 @@ kl_divergence(other)
 
 **参数**
 
-    - **other** (Cauchy) - ``Cauchy`` 的实例。
+    - **other** (Cauchy) -  ``Cauchy``  的实例。
 
 **返回**
 
diff --git a/docs/api/paddle/distribution/ChainTransform_cn.rst b/docs/api/paddle/distribution/ChainTransform_cn.rst
index 9ff5b64943a..e20479fd870 100644
--- a/docs/api/paddle/distribution/ChainTransform_cn.rst
+++ b/docs/api/paddle/distribution/ChainTransform_cn.rst
@@ -7,7 +7,7 @@ ChainTransform
 
 变换的链式组合。
 
-``ChainTransform`` 将一些列变换以链式组合方式作用于一个随机变量，计算变换后的结果。
+ ``ChainTransform``  将一些列变换以链式组合方式作用于一个随机变量，计算变换后的结果。
 
 参数
 :::::::::
@@ -56,7 +56,7 @@ forward_log_det_jacobian(x)
 
 计算正变换雅可比行列式绝对值的对数。
 
-如果变换不是一一映射，则雅可比矩阵不存在，返回 ``NotImplementedError`` 。
+如果变换不是一一映射，则雅可比矩阵不存在，返回  ``NotImplementedError``  。
 
 **参数**
 
@@ -72,7 +72,7 @@ inverse_log_det_jacobian(y)
 
 计算逆变换雅可比行列式绝对值的对数。
 
-与 ``forward_log_det_jacobian`` 互为负数。
+与  ``forward_log_det_jacobian``  互为负数。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/Chi2_cn.rst b/docs/api/paddle/distribution/Chi2_cn.rst
index 0c575790213..7c5b45a87ef 100644
--- a/docs/api/paddle/distribution/Chi2_cn.rst
+++ b/docs/api/paddle/distribution/Chi2_cn.rst
@@ -17,7 +17,7 @@ Chi2
 参数
 ::::::::::::
 
-    - **df** (float|Tensor) - 参数表示自由度，该值必须大于零。支持 Broadcast 语义。当参数类型为 Tensor 时，表示批量创建多个不同参数的分布，``batch_shape`` (参考 :ref:`cn_api_paddle_distribution_Distribution` 基类) 为参数。
+    - **df** (float|Tensor) - 参数表示自由度，该值必须大于零。支持 Broadcast 语义。当参数类型为 Tensor 时，表示批量创建多个不同参数的分布， ``batch_shape``  (参考 :ref:`cn_api_paddle_distribution_Distribution` 基类) 为参数。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/distribution/ContinuousBernoulli_cn.rst b/docs/api/paddle/distribution/ContinuousBernoulli_cn.rst
index ac7c8051c35..625685962dc 100644
--- a/docs/api/paddle/distribution/ContinuousBernoulli_cn.rst
+++ b/docs/api/paddle/distribution/ContinuousBernoulli_cn.rst
@@ -148,7 +148,7 @@ Tensor，ContinuousBernoulli 随机变量在对应 quantile 下的值。数据
 sample(shape=[])
 '''''''''
 
-从 ContinuousBernoulli 分布中生成满足特定形状的样本数据。最终生成样本形状为 ``shape+batch_shape`` 。
+从 ContinuousBernoulli 分布中生成满足特定形状的样本数据。最终生成样本形状为  ``shape+batch_shape``  。
 
 **参数**
 
@@ -162,7 +162,7 @@ Tensor，样本数据。其维度为 :math:`\text{sample shape} + \text{batch sh
 rsample(shape=[])
 '''''''''
 
-重参数化采样，生成指定维度的样本。最终生成样本形状为 ``shape+batch_shape`` 。
+重参数化采样，生成指定维度的样本。最终生成样本形状为  ``shape+batch_shape``  。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/Dirichlet_cn.rst b/docs/api/paddle/distribution/Dirichlet_cn.rst
index 7c85d203885..d98489fa42d 100644
--- a/docs/api/paddle/distribution/Dirichlet_cn.rst
+++ b/docs/api/paddle/distribution/Dirichlet_cn.rst
@@ -29,8 +29,8 @@ Gamma 函数。
 
 - **concentration** (Tensor) - 浓度参数，即上述公式 :math:`\alpha` 参数。当
   concentration 维度大于 1 时，最后一维表示参数，参数形状
-  ``event_shape=concentration.shape[-1:]``，其余维为 Batch 维，
-  ``batch_shape=concentration.shape[:-1]`` .
+   ``event_shape=concentration.shape[-1:]`` ，其余维为 Batch 维，
+   ``batch_shape=concentration.shape[:-1]``  .
 
 
 代码示例
@@ -88,7 +88,7 @@ sample(shape=[])
 
 **参数**
 
-- **shape** (Sequence[int]，可选) - 采样次数，最终生成样本形状为 ``shape+batch_shape+event_shape`` 。
+- **shape** (Sequence[int]，可选) - 采样次数，最终生成样本形状为  ``shape+batch_shape+event_shape``  。
 
 **返回**
 
diff --git a/docs/api/paddle/distribution/Distribution_cn.rst b/docs/api/paddle/distribution/Distribution_cn.rst
index 3879aca666e..f5eb93765dd 100644
--- a/docs/api/paddle/distribution/Distribution_cn.rst
+++ b/docs/api/paddle/distribution/Distribution_cn.rst
@@ -10,10 +10,10 @@ Distribution
 参数
 :::::::::
 
-- **batch_shape** - 概率分布参数批量形状。一元分布 ``batch_shape=param.shape``，多元分
-  布 ``batch_shape=param.shape[:-1]``，其中 param 表示分布参数，支持 broadcast 语义。
-- **event_shape** - 多元概率分布维数形状。一元分布 ``event_shape=()``，多元分布
-  ``event_shape=param.shape[-1:]``，其中 param 表示分布参数，支持 broadcast 语义。
+- **batch_shape** - 概率分布参数批量形状。一元分布  ``batch_shape=param.shape`` ，多元分
+  布  ``batch_shape=param.shape[:-1]`` ，其中 param 表示分布参数，支持 broadcast 语义。
+- **event_shape** - 多元概率分布维数形状。一元分布  ``event_shape=()`` ，多元分布
+   ``event_shape=param.shape[-1:]`` ，其中 param 表示分布参数，支持 broadcast 语义。
 
 
 方法
diff --git a/docs/api/paddle/distribution/ExpTransform_cn.rst b/docs/api/paddle/distribution/ExpTransform_cn.rst
index 44d21e572e9..567b7a5d301 100644
--- a/docs/api/paddle/distribution/ExpTransform_cn.rst
+++ b/docs/api/paddle/distribution/ExpTransform_cn.rst
@@ -50,7 +50,7 @@ forward_log_det_jacobian(x)
 
 计算正变换雅可比行列式绝对值的对数。
 
-如果变换不是一一映射，则雅可比矩阵不存在，返回 ``NotImplementedError`` 。
+如果变换不是一一映射，则雅可比矩阵不存在，返回  ``NotImplementedError``  。
 
 **参数**
 
@@ -66,7 +66,7 @@ inverse_log_det_jacobian(y)
 
 计算逆变换雅可比行列式绝对值的对数。
 
-与 ``forward_log_det_jacobian`` 互为负数。
+与  ``forward_log_det_jacobian``  互为负数。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/ExponentialFamily_cn.rst b/docs/api/paddle/distribution/ExponentialFamily_cn.rst
index c59365bf14c..3cda31bbe32 100644
--- a/docs/api/paddle/distribution/ExponentialFamily_cn.rst
+++ b/docs/api/paddle/distribution/ExponentialFamily_cn.rst
@@ -5,7 +5,7 @@ ExponentialFamily
 
 .. py:class:: paddle.distribution.ExponentialFamily()
 
-指数型分布族的基类，继承 ``paddle.distribution.Distribution``。概率密度/质量函数满足下述
+指数型分布族的基类，继承  ``paddle.distribution.Distribution`` 。概率密度/质量函数满足下述
 形式
 
 .. math::
diff --git a/docs/api/paddle/distribution/Gamma_cn.rst b/docs/api/paddle/distribution/Gamma_cn.rst
index 24d22986dde..f979ccd2e20 100644
--- a/docs/api/paddle/distribution/Gamma_cn.rst
+++ b/docs/api/paddle/distribution/Gamma_cn.rst
@@ -25,9 +25,9 @@ Gamma
 参数
 ::::::::::::
 
-    - **concentration** (float|Tensor) - 率参数，该值必须大于零。支持 Broadcast 语义。当参数类型为 Tensor 时，表示批量创建多个不同参数的分布，``batch_shape`` (参考 :ref:`cn_api_paddle_distribution_Distribution` 基类) 为参数。
+    - **concentration** (float|Tensor) - 率参数，该值必须大于零。支持 Broadcast 语义。当参数类型为 Tensor 时，表示批量创建多个不同参数的分布， ``batch_shape``  (参考 :ref:`cn_api_paddle_distribution_Distribution` 基类) 为参数。
 
-    - **rate** (float|Tensor) - 率参数，该值必须大于零。支持 Broadcast 语义。当参数类型为 Tensor 时，表示批量创建多个不同参数的分布，``batch_shape`` (参考 :ref:`cn_api_paddle_distribution_Distribution` 基类) 为参数。
+    - **rate** (float|Tensor) - 率参数，该值必须大于零。支持 Broadcast 语义。当参数类型为 Tensor 时，表示批量创建多个不同参数的分布， ``batch_shape``  (参考 :ref:`cn_api_paddle_distribution_Distribution` 基类) 为参数。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/distribution/IndependentTransform_cn.rst b/docs/api/paddle/distribution/IndependentTransform_cn.rst
index 22d9ae970f9..a40618ff1ac 100644
--- a/docs/api/paddle/distribution/IndependentTransform_cn.rst
+++ b/docs/api/paddle/distribution/IndependentTransform_cn.rst
@@ -6,11 +6,11 @@ IndependentTransform
 .. py:class:: paddle.distribution.IndependentTransform(base, reinterpreted_batch_rank)
 
 
- ``IndependentTransform`` 将一个基础变换 :attr:`base` 的部分批（batch）维度 ``reinterpreted_batch_rank`` 扩展为事件（event）维度。
+  ``IndependentTransform``  将一个基础变换 :attr:`base` 的部分批（batch）维度  ``reinterpreted_batch_rank``  扩展为事件（event）维度。
 
- ``IndependentTransform`` 不改变基础变换 ``forward`` 以及 ``inverse`` 计算结果，但会对 ``forward_log_det_jacobian`` 以及 ``inverse_log_det_jacobian`` 计算结果沿着扩展的维度进行求和。
+  ``IndependentTransform``  不改变基础变换  ``forward``  以及  ``inverse``  计算结果，但会对  ``forward_log_det_jacobian``  以及  ``inverse_log_det_jacobian``  计算结果沿着扩展的维度进行求和。
 
-例如，假设基础变换为 ``ExpTransform``，其输入为一个随机采样结果 ``x``，形状为 :math:`(S=[4], B=[2,2], E=[3])` , :math:`S`、:math:`B`、:math:`E` 分别表示采样形状、批形状、事件形状，``reinterpreted_batch_rank=1``。则 ``IndependentTransform(ExpTransform)`` 变换后，``x`` 的形状为 :math:`(S=[4], B=[2], E=[2,3])`，即将最右侧的批维度作为事件维度。此时 ``forward`` 和 ``inverse`` 输出形状仍是 :math:`[4, 2, 2, 3]`，但 ``forward_log_det_jacobian`` 以及 ``inverse_log_det_jacobian`` 输出形状为 :math:`[4, 2]`。
+例如，假设基础变换为  ``ExpTransform`` ，其输入为一个随机采样结果  ``x`` ，形状为 :math:`(S=[4], B=[2,2], E=[3])` , :math:`S`、:math:`B`、:math:`E` 分别表示采样形状、批形状、事件形状， ``reinterpreted_batch_rank=1`` 。则  ``IndependentTransform(ExpTransform)``  变换后， ``x``  的形状为 :math:`(S=[4], B=[2], E=[2,3])`，即将最右侧的批维度作为事件维度。此时  ``forward``  和  ``inverse``  输出形状仍是 :math:`[4, 2, 2, 3]`，但  ``forward_log_det_jacobian``  以及  ``inverse_log_det_jacobian``  输出形状为 :math:`[4, 2]`。
 
 
 参数
@@ -60,7 +60,7 @@ forward_log_det_jacobian(x)
 
 计算正变换雅可比行列式绝对值的对数。
 
-如果变换不是一一映射，则雅可比矩阵不存在，返回 ``NotImplementedError`` 。
+如果变换不是一一映射，则雅可比矩阵不存在，返回  ``NotImplementedError``  。
 
 **参数**
 
@@ -76,7 +76,7 @@ inverse_log_det_jacobian(y)
 
 计算逆变换雅可比行列式绝对值的对数。
 
-与 ``forward_log_det_jacobian`` 互为负数。
+与  ``forward_log_det_jacobian``  互为负数。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/Independent_cn.rst b/docs/api/paddle/distribution/Independent_cn.rst
index b8540487435..30b92227877 100644
--- a/docs/api/paddle/distribution/Independent_cn.rst
+++ b/docs/api/paddle/distribution/Independent_cn.rst
@@ -5,7 +5,7 @@ Independent
 
 .. py:class:: paddle.distribution.Independent(base, reinterpreted_batch_rank)
 
-将一个基础分布 ``base`` 的最右侧 ``reinterpreted_batch_rank`` 批维度转换为事件维度。
+将一个基础分布  ``base``  的最右侧  ``reinterpreted_batch_rank``  批维度转换为事件维度。
 
 
 参数
@@ -70,7 +70,7 @@ sample(shape=[])
 
 **参数**
 
-- **shape** (Sequence[int]，可选)：采样次数。最终生成样本形状为 ``shape+batch_shape`` 。
+- **shape** (Sequence[int]，可选)：采样次数。最终生成样本形状为  ``shape+batch_shape``  。
 
 **返回**
 
diff --git a/docs/api/paddle/distribution/Multinomial_cn.rst b/docs/api/paddle/distribution/Multinomial_cn.rst
index 909135b2c79..2befe083a09 100644
--- a/docs/api/paddle/distribution/Multinomial_cn.rst
+++ b/docs/api/paddle/distribution/Multinomial_cn.rst
@@ -5,7 +5,7 @@ Multinomial
 
 .. py:class:: paddle.distribution.Multinomial(total_count, probs)
 
-``Multinomial`` 表示实验次数为 :attr:`total_count`，概率为 :attr:`probs` 的多项分布。
+ ``Multinomial``  表示实验次数为 :attr:`total_count`，概率为 :attr:`probs` 的多项分布。
 
 在概率论中，多项分布是二项分布的多元推广，表示具有 :math:`k` 个类别的事件重复实验 :math:`n` 次，每个类别出现次数的概率。当 :math:`k=2` 且 :math:`n=1` 时，为伯努利分布，当 :math:`k=2` 且 :math:`n>1` 时，为二项分布，当 :math:`k>2` 且 :math:`n=1` 时，为分类分布。
 
diff --git a/docs/api/paddle/distribution/MultivariateNormal_cn.rst b/docs/api/paddle/distribution/MultivariateNormal_cn.rst
index 24cb8637cf4..6b6f07cfdf6 100644
--- a/docs/api/paddle/distribution/MultivariateNormal_cn.rst
+++ b/docs/api/paddle/distribution/MultivariateNormal_cn.rst
@@ -94,7 +94,7 @@ Tensor，:attr:`value` 的对数概率。数据类型与 `self.loc` 相同。
 sample(shape=[])
 '''''''''
 
-从 MultivariateNormal 分布中生成满足特定形状的样本数据。最终生成样本形状为 ``sample_shape + batch_shape + event_shape`` 。
+从 MultivariateNormal 分布中生成满足特定形状的样本数据。最终生成样本形状为  ``sample_shape + batch_shape + event_shape``  。
 
 **参数**
 
@@ -108,7 +108,7 @@ Tensor，样本数据。其维度为 :math:`\text{sample shape} + \text{batch sh
 rsample(shape=[])
 '''''''''
 
-重参数化采样，生成指定维度的样本。最终生成样本形状为 ``sample_shape + batch_shape + event_shape`` 。
+重参数化采样，生成指定维度的样本。最终生成样本形状为  ``sample_shape + batch_shape + event_shape``  。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/Poisson_cn.rst b/docs/api/paddle/distribution/Poisson_cn.rst
index ec5370a0abc..6335951720e 100644
--- a/docs/api/paddle/distribution/Poisson_cn.rst
+++ b/docs/api/paddle/distribution/Poisson_cn.rst
@@ -83,7 +83,7 @@ Tensor，value 的对数概率。数据类型与 :attr:`rate` 相同。
 sample(shape=[])
 '''''''''
 
-从 Poisson 分布中生成满足特定形状的样本数据。最终生成样本形状为 ``shape+batch_shape`` 。
+从 Poisson 分布中生成满足特定形状的样本数据。最终生成样本形状为  ``shape+batch_shape``  。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/PowerTransform_cn.rst b/docs/api/paddle/distribution/PowerTransform_cn.rst
index be466b518d3..7baa1e51d78 100644
--- a/docs/api/paddle/distribution/PowerTransform_cn.rst
+++ b/docs/api/paddle/distribution/PowerTransform_cn.rst
@@ -56,7 +56,7 @@ forward_log_det_jacobian(x)
 
 计算正变换雅可比行列式绝对值的对数。
 
-如果变换不是一一映射，则雅可比矩阵不存在，抛出 ``NotImplementedError`` 。
+如果变换不是一一映射，则雅可比矩阵不存在，抛出  ``NotImplementedError``  。
 
 **参数**
 
@@ -72,7 +72,7 @@ inverse_log_det_jacobian(y)
 
 计算逆变换雅可比行列式绝对值的对数。
 
-与 ``forward_log_det_jacobian`` 互为负数。
+与  ``forward_log_det_jacobian``  互为负数。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/ReshapeTransform_cn.rst b/docs/api/paddle/distribution/ReshapeTransform_cn.rst
index 511b294bbb2..b1756ff0584 100644
--- a/docs/api/paddle/distribution/ReshapeTransform_cn.rst
+++ b/docs/api/paddle/distribution/ReshapeTransform_cn.rst
@@ -5,7 +5,7 @@ ReshapeTransform
 
 .. py:class:: paddle.distribution.ReshapeTransform(in_event_shape, out_event_shape)
 
-``ReshapeTransform`` 将输入 Tensor 的事件形状 ``in_event_shape`` 改变为 ``out_event_shape``。其中，``in_event_shape``、``out_event_shape`` 需要包含相同的元素个数。
+ ``ReshapeTransform``  将输入 Tensor 的事件形状  ``in_event_shape``  改变为  ``out_event_shape`` 。其中， ``in_event_shape`` 、 ``out_event_shape``  需要包含相同的元素个数。
 
 
 参数
@@ -55,7 +55,7 @@ forward_log_det_jacobian(x)
 
 计算正变换雅可比行列式绝对值的对数。
 
-如果变换不是一一映射，则雅可比矩阵不存在，抛出 ``NotImplementedError``。
+如果变换不是一一映射，则雅可比矩阵不存在，抛出  ``NotImplementedError`` 。
 
 **参数**
 
@@ -71,7 +71,7 @@ inverse_log_det_jacobian(y)
 
 计算逆变换雅可比行列式绝对值的对数。
 
-与 ``forward_log_det_jacobian`` 互为负数。
+与  ``forward_log_det_jacobian``  互为负数。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/SigmoidTransform_cn.rst b/docs/api/paddle/distribution/SigmoidTransform_cn.rst
index a6f52b7f9db..ec3fae6e681 100644
--- a/docs/api/paddle/distribution/SigmoidTransform_cn.rst
+++ b/docs/api/paddle/distribution/SigmoidTransform_cn.rst
@@ -48,7 +48,7 @@ forward_log_det_jacobian(x)
 
 计算正变换雅可比行列式绝对值的对数。
 
-如果变换不是一一映射，则雅可比矩阵不存在，返回 ``NotImplementedError`` 。
+如果变换不是一一映射，则雅可比矩阵不存在，返回  ``NotImplementedError``  。
 
 **参数**
 
@@ -64,7 +64,7 @@ inverse_log_det_jacobian(y)
 
 计算逆变换雅可比行列式绝对值的对数。
 
-与 ``forward_log_det_jacobian`` 互为负数。
+与  ``forward_log_det_jacobian``  互为负数。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/SoftmaxTransform_cn.rst b/docs/api/paddle/distribution/SoftmaxTransform_cn.rst
index 366b1cba9e8..e880f9288d1 100644
--- a/docs/api/paddle/distribution/SoftmaxTransform_cn.rst
+++ b/docs/api/paddle/distribution/SoftmaxTransform_cn.rst
@@ -10,7 +10,7 @@ Softmax 变换，首先进行 :math:`y = exp(x)` 变换，然后归一化。
 Softmax 变换将向量变换为单纯形。
 
 .. note::
-   Softmax 不是双射函数，所以 ``forward_log_det_jacobian``、``inverse_log_det_jacobian`` 未实现。
+   Softmax 不是双射函数，所以  ``forward_log_det_jacobian`` 、 ``inverse_log_det_jacobian``  未实现。
 
 代码示例
 :::::::::
@@ -52,7 +52,7 @@ forward_log_det_jacobian(x)
 
 计算正变换雅可比行列式绝对值的对数。
 
-如果变换不是一一映射，则雅可比矩阵不存在，返回 ``NotImplementedError`` 。
+如果变换不是一一映射，则雅可比矩阵不存在，返回  ``NotImplementedError``  。
 
 **参数**
 
@@ -68,7 +68,7 @@ inverse_log_det_jacobian(y)
 
 计算逆变换雅可比行列式绝对值的对数。
 
-与 ``forward_log_det_jacobian`` 互为负数。
+与  ``forward_log_det_jacobian``  互为负数。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/StackTransform_cn.rst b/docs/api/paddle/distribution/StackTransform_cn.rst
index d109a71a978..70d91ff35ea 100644
--- a/docs/api/paddle/distribution/StackTransform_cn.rst
+++ b/docs/api/paddle/distribution/StackTransform_cn.rst
@@ -5,7 +5,7 @@ StackTransform
 
 .. py:class:: paddle.distribution.StackTransform(transforms, axis=0)
 
-``StackTransform`` 将一系列变换沿着某个特定轴作用于一个输入 Tensor 上。
+ ``StackTransform``  将一系列变换沿着某个特定轴作用于一个输入 Tensor 上。
 
 参数
 :::::::::
@@ -53,7 +53,7 @@ forward_log_det_jacobian(x)
 
 计算正变换雅可比行列式绝对值的对数。
 
-如果变换不是一一映射，则雅可比矩阵不存在，抛出 ``NotImplementedError``。
+如果变换不是一一映射，则雅可比矩阵不存在，抛出  ``NotImplementedError`` 。
 
 **参数**
 
@@ -69,7 +69,7 @@ inverse_log_det_jacobian(y)
 
 计算逆变换雅可比行列式绝对值的对数。
 
-与 ``forward_log_det_jacobian`` 互为负数。
+与  ``forward_log_det_jacobian``  互为负数。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/StickBreakingTransform_cn.rst b/docs/api/paddle/distribution/StickBreakingTransform_cn.rst
index 54635b014a8..6e89652569d 100644
--- a/docs/api/paddle/distribution/StickBreakingTransform_cn.rst
+++ b/docs/api/paddle/distribution/StickBreakingTransform_cn.rst
@@ -5,7 +5,7 @@ StickBreakingTransform
 
 .. py:class:: paddle.distribution.StickBreakingTransform()
 
-``StickBreakingTransform`` 将一个长度为 K 的向量通过 StackBreaking 构造过程变换为标准 K-单纯形。
+ ``StickBreakingTransform``  将一个长度为 K 的向量通过 StackBreaking 构造过程变换为标准 K-单纯形。
 
 
 代码示例
@@ -49,7 +49,7 @@ forward_log_det_jacobian(x)
 
 计算正变换雅可比行列式绝对值的对数。
 
-如果变换不是一一映射，则雅可比矩阵不存在，返回 ``NotImplementedError`` 。
+如果变换不是一一映射，则雅可比矩阵不存在，返回  ``NotImplementedError``  。
 
 **参数**
 
@@ -65,7 +65,7 @@ inverse_log_det_jacobian(y)
 
 计算逆变换雅可比行列式绝对值的对数。
 
-与 ``forward_log_det_jacobian`` 互为负数。
+与  ``forward_log_det_jacobian``  互为负数。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/StudentT_cn.rst b/docs/api/paddle/distribution/StudentT_cn.rst
index df6f9a68fa7..f6e143b4f4c 100644
--- a/docs/api/paddle/distribution/StudentT_cn.rst
+++ b/docs/api/paddle/distribution/StudentT_cn.rst
@@ -92,7 +92,7 @@ Tensor，value 的对数概率。数据类型与 :attr:`df` 相同。
 sample(shape=[])
 '''''''''
 
-从学生 t 分布中生成满足特定形状的样本数据。最终生成样本形状为 ``shape+batch_shape`` 。
+从学生 t 分布中生成满足特定形状的样本数据。最终生成样本形状为  ``shape+batch_shape``  。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/TanhTransform_cn.rst b/docs/api/paddle/distribution/TanhTransform_cn.rst
index d705e4d0551..66533686adc 100644
--- a/docs/api/paddle/distribution/TanhTransform_cn.rst
+++ b/docs/api/paddle/distribution/TanhTransform_cn.rst
@@ -50,7 +50,7 @@ forward_log_det_jacobian(x)
 
 计算正变换雅可比行列式绝对值的对数。
 
-如果变换不是一一映射，则雅可比矩阵不存在，返回 ``NotImplementedError`` 。
+如果变换不是一一映射，则雅可比矩阵不存在，返回  ``NotImplementedError``  。
 
 **参数**
 
@@ -66,7 +66,7 @@ inverse_log_det_jacobian(y)
 
 计算逆变换雅可比行列式绝对值的对数。
 
-与 ``forward_log_det_jacobian`` 互为负数。
+与  ``forward_log_det_jacobian``  互为负数。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/Transform_cn.rst b/docs/api/paddle/distribution/Transform_cn.rst
index b068754bd4b..eeb2b7db944 100644
--- a/docs/api/paddle/distribution/Transform_cn.rst
+++ b/docs/api/paddle/distribution/Transform_cn.rst
@@ -7,11 +7,11 @@ Transform
 
 随机变量变换的基类。
 
-``Transform`` 表示将一个随机变量，经过一个或一些列可微且可逆的映射后，变换为另一个随机变量，
+ ``Transform``  表示将一个随机变量，经过一个或一些列可微且可逆的映射后，变换为另一个随机变量，
 并提供变换前后相应概率密度计算方法。主要应用于对一个分布
 :ref:`cn_api_paddle_distribution_Distribution` 的随机采样结果进行变换。
 
-假设 :math:`X` 为 ``K`` 元随机变量，概率密度为 :math:`p_X(x)`。映射
+假设 :math:`X` 为  ``K``  元随机变量，概率密度为 :math:`p_X(x)`。映射
 :math:`f: x \rightarrow y` 为可微且可逆映射，则 :math:`Y` 的概率密度为
 
 .. math::
@@ -34,36 +34,36 @@ Transform
     &{\cdots} &{\frac{\partial x_K}{\partial y_K}}
     \end{bmatrix}
 
-通过上述描述易知，变换 ``Transform`` 主要包含下述三个操作：
+通过上述描述易知，变换  ``Transform``  主要包含下述三个操作：
 
-    1.正变换( ``forward`` ):
+    1.正变换(  ``forward``  ):
 
        表示正向变换 :math:`x \rightarrow f(x)` 。
 
-    2.逆变换( ``inverse`` ):
+    2.逆变换(  ``inverse``  ):
 
        表示逆向变换 :math:`y \rightarrow f^{-1}(y)` 。
 
-    3.雅可比行列式绝对值的对数( ``log_det_jacobian`` ):
+    3.雅可比行列式绝对值的对数(  ``log_det_jacobian``  ):
 
-       又可以细分为正变换雅可比行列式绝对值的对数 ``forward_log_det_jacobian`` 和逆变换雅
-       可比行列式绝对值的对数 ``inverse_log_det_jacobian``，两者互为负数关系，只实现一种
+       又可以细分为正变换雅可比行列式绝对值的对数  ``forward_log_det_jacobian``  和逆变换雅
+       可比行列式绝对值的对数  ``inverse_log_det_jacobian`` ，两者互为负数关系，只实现一种
        即可。
 
 子类通常通过重写如下方法实现变换功能：
 
-    * ``_forward``
-    * ``_inverse``
-    * ``_forward_log_det_jacobian``
-    * ``_inverse_log_det_jacobian`` (可选)
+    *  ``_forward`` 
+    *  ``_inverse`` 
+    *  ``_forward_log_det_jacobian`` 
+    *  ``_inverse_log_det_jacobian``  (可选)
 
-通常情况下，``_forward_log_det_jacobian`` 与 ``_inverse_log_det_jacobian`` 实现其中
+通常情况下， ``_forward_log_det_jacobian``  与  ``_inverse_log_det_jacobian``  实现其中
 一个即可。仅在某些特定情况下，为了追求更高性能以及数值稳定性，需要实现两者。
 
 如果子类变换改变了输入数据形状，还需要重写：
 
-    * ``_forward_shape``
-    * ``_inverse_shape``
+    *  ``_forward_shape`` 
+    *  ``_inverse_shape`` 
 
 
 方法
@@ -102,7 +102,7 @@ forward_log_det_jacobian(x)
 
 计算正变换雅可比行列式绝对值的对数。
 
-如果变换不是一一映射，则雅可比矩阵不存在，返回 ``NotImplementedError`` 。
+如果变换不是一一映射，则雅可比矩阵不存在，返回  ``NotImplementedError``  。
 
 **参数**
 
@@ -118,7 +118,7 @@ inverse_log_det_jacobian(y)
 
 计算逆变换雅可比行列式绝对值的对数。
 
-与 ``forward_log_det_jacobian`` 互为负数。
+与  ``forward_log_det_jacobian``  互为负数。
 
 **参数**
 
diff --git a/docs/api/paddle/distribution/register_kl_cn.rst b/docs/api/paddle/distribution/register_kl_cn.rst
index 69bb37685f0..70d2d3fd5d6 100644
--- a/docs/api/paddle/distribution/register_kl_cn.rst
+++ b/docs/api/paddle/distribution/register_kl_cn.rst
@@ -7,7 +7,7 @@ register_kl
 
 用于注册 KL 散度具体计算函数装饰器。
 
-调用 ``kl_divergence(p,q)`` 计算 KL 散度时，会通过多重派发机制，即根据 p 和 q 的类型查找通过 ``register_kl`` 注册的实现函数，如果找到返回计算结果，否则，抛出 ``NotImplementError``。用户可通过该装饰器自行注册 KL 散度计算函数。
+调用  ``kl_divergence(p,q)``  计算 KL 散度时，会通过多重派发机制，即根据 p 和 q 的类型查找通过  ``register_kl``  注册的实现函数，如果找到返回计算结果，否则，抛出  ``NotImplementError`` 。用户可通过该装饰器自行注册 KL 散度计算函数。
 
 参数
 :::::::::
diff --git a/docs/api/paddle/divide_cn.rst b/docs/api/paddle/divide_cn.rst
index d3f959216c9..8b96bfbe78d 100644
--- a/docs/api/paddle/divide_cn.rst
+++ b/docs/api/paddle/divide_cn.rst
@@ -5,11 +5,11 @@ divide
 
 .. py:function:: paddle.divide(x, y, name=None, *, rounding_mode=None, out=None)
 
-逐元素相除算子，输入 ``x`` 与输入 ``y`` 逐元素相除，并将各个位置的输出元素保存到返回结果中。
+逐元素相除算子，输入  ``x``  与输入  ``y``  逐元素相除，并将各个位置的输出元素保存到返回结果中。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``other`` 可替代 ``y`` ，如 ``divide(input=tensor_x, other=tensor_y, ...)`` 等价于 ``divide(x=tensor_x, y=tensor_y, ...)`` 。
-    输入 ``x`` 与输入 ``y`` 必须和广播为相同形状，关于广播规则，请参见 `Tensor 介绍`_ .
+    别名支持: 参数名  ``input``  可替代  ``x`` ，参数名  ``other``  可替代  ``y``  ，如  ``divide(input=tensor_x, other=tensor_y, ...)``  等价于  ``divide(x=tensor_x, y=tensor_y, ...)``  。
+    输入  ``x``  与输入  ``y``  必须和广播为相同形状，关于广播规则，请参见 `Tensor 介绍`_ .
 
     .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
@@ -24,18 +24,18 @@ divide
 参数
 :::::::::
         - **x** (Tensor) - 多维 Tensor。数据类型为 bool、bfloat16、float16、float32、float64、int8、int16、int32、int64、uint8、complex64、complex128。
-          ``别名: input``
+           ``别名: input`` 
         - **y** (Tensor) - 多维 Tensor。数据类型为 bool、bfloat16、float16、float32、float64、int8、int16、int32、int64、uint8、complex64、complex128。
-          ``别名: other``
+           ``别名: other`` 
         - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
-        - **rounding_mode** (str，可选) - 指定舍入模式。可选值为 ``None``、``"trunc"`` 或 ``"floor"``。如果 ``rounding_mode=None``，则不进行舍入操作；如果 ``rounding_mode="trunc"``，则向零截断；如果 ``rounding_mode="floor"``，则向负无穷舍入。
+        - **rounding_mode** (str，可选) - 指定舍入模式。可选值为  ``None`` 、 ``"trunc"``  或  ``"floor"`` 。如果  ``rounding_mode=None`` ，则不进行舍入操作；如果  ``rounding_mode="trunc"`` ，则向零截断；如果  ``rounding_mode="floor"`` ，则向负无穷舍入。
         - **out** (Tensor，可选) - 输出 Tensor，默认值为 None。
 
 
 返回
 :::::::::
 
-   ``Tensor``，存储运算后的结果。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
+    ``Tensor`` ，存储运算后的结果。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
 
 
 
diff --git a/docs/api/paddle/dot_cn.rst b/docs/api/paddle/dot_cn.rst
index c5a24f2c96d..e192b6d0ed1 100644
--- a/docs/api/paddle/dot_cn.rst
+++ b/docs/api/paddle/dot_cn.rst
@@ -13,15 +13,15 @@ dot
    支持 1 维和 2 维 Tensor。如果是 2 维 Tensor，矩阵的第一个维度是 batch_size，将会在多个样本上进行点积计算。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``， ``tensor`` 可替代 ``y``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，  ``tensor``  可替代  ``y`` 。
 
 参数
 :::::::::
 
-        - **x** （Tensor） - 1 维或 2 维 ``Tensor``。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 、 ``int64`` 、 ``complex64`` 或 ``complex128`` 。
-          别名： ``input``
-        - **y** （Tensor） - 1 维或 2 维 ``Tensor``。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 、 ``int64`` 、 ``complex64`` 或 ``complex128`` 。
-          别名： ``tensor``
+        - **x** （Tensor） - 1 维或 2 维  ``Tensor`` 。数据类型为  ``float32``  、  ``float64``  、  ``int32``  、  ``int64``  、  ``complex64``  或  ``complex128``  。
+          别名：  ``input`` 
+        - **y** （Tensor） - 1 维或 2 维  ``Tensor`` 。数据类型为  ``float32``  、  ``float64``  、  ``int32``  、  ``int64``  、  ``complex64``  或  ``complex128``  。
+          别名：  ``tensor`` 
         - **name** （str，可选） - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
@@ -31,7 +31,7 @@ dot
 
 返回
 :::::::::
-``Tensor``，数据类型与 ``x`` 相同。
+ ``Tensor`` ，数据类型与  ``x``  相同。
 
 
 
diff --git a/docs/api/paddle/dsplit_cn.rst b/docs/api/paddle/dsplit_cn.rst
index 1a8c29c16b4..ec1463921bd 100644
--- a/docs/api/paddle/dsplit_cn.rst
+++ b/docs/api/paddle/dsplit_cn.rst
@@ -6,12 +6,12 @@ dsplit
 .. py:function:: paddle.dsplit(x, num_or_indices, name=None)
 
 
-``dsplit`` 全称 Depth Split ，即深度分割，将输入 Tensor 沿着深度轴分割成多个子 Tensor，等价于将 :ref:`cn_api_paddle_tensor_split` API 的参数 axis 固定为 2。
+ ``dsplit``  全称 Depth Split ，即深度分割，将输入 Tensor 沿着深度轴分割成多个子 Tensor，等价于将 :ref:`cn_api_paddle_tensor_split` API 的参数 axis 固定为 2。
 
 .. note::
-   请确保使用 ``paddle.dsplit`` 进行变换的 Tensor 维度数量不少于 3。
+   请确保使用  ``paddle.dsplit``  进行变换的 Tensor 维度数量不少于 3。
 
-如下图，Tenser ``x`` 的 shape 为[4, 4, 4]，经过 ``paddle.dsplit(x, num_or_indices=2)`` 变换后，得到 ``out0`` 和 ``out1`` 两个 shape 均为[4, 4, 2]的子 Tensor :
+如下图，Tenser  ``x``  的 shape 为[4, 4, 4]，经过  ``paddle.dsplit(x, num_or_indices=2)``  变换后，得到  ``out0``  和  ``out1``  两个 shape 均为[4, 4, 2]的子 Tensor :
 
 .. image:: ../../images/api_legend/dsplit/dsplit.png
    :alt: dsplit 图例
@@ -19,7 +19,7 @@ dsplit
 参数
 :::::::::
        - **x** (Tensor) - 输入变量，数据类型为 bool、bfloat16、float16、float32、float64、uint8、int8、int32、int64 的多维 Tensor，其维度必须大于 2。
-       - **num_or_indices** (int|list|tuple) - 如果 ``num_or_indices`` 是一个整数 ``n`` ，则 ``x`` 拆分为 ``n`` 部分。如果 ``num_or_indices`` 是整数索引的列表或元组，则在每个索引处分割 ``x`` 。
+       - **num_or_indices** (int|list|tuple) - 如果  ``num_or_indices``  是一个整数  ``n``  ，则  ``x``  拆分为  ``n``  部分。如果  ``num_or_indices``  是整数索引的列表或元组，则在每个索引处分割  ``x``  。
        - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/dstack_cn.rst b/docs/api/paddle/dstack_cn.rst
index f58573a8162..12c4e9eceb2 100644
--- a/docs/api/paddle/dstack_cn.rst
+++ b/docs/api/paddle/dstack_cn.rst
@@ -5,19 +5,19 @@ dstack
 
 .. py:function:: paddle.dstack(x, name=None)
 
-沿深度轴堆叠输入 ``x`` 中的所有张量。所有张量必须具有相同的数据类型。
+沿深度轴堆叠输入  ``x``  中的所有张量。所有张量必须具有相同的数据类型。
 
 参数
 ::::::::::::
 
-    - **x** (list[Tensor]|tuple[Tensor]) - 输入 ``x`` 可以是张量的 list 或 tuple， ``x`` 中张量的数据类型必须相同。支持的数据类型： ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 、 ``int64`` 或 ``bfloat16`` 。
+    - **x** (list[Tensor]|tuple[Tensor]) - 输入  ``x``  可以是张量的 list 或 tuple，  ``x``  中张量的数据类型必须相同。支持的数据类型：  ``float16``  、  ``float32``  、  ``float64``  、  ``int32``  、  ``int64``  或  ``bfloat16``  。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
 Tensor，与输入数据类型相同的堆叠张量。
 
-也可以参考下方的图示来理解 ``dstack`` 是如何对张量进行变换的。图片展示了两个个形状为 [3] 的一维张量以及两个形状为 [3, 2] 的二维张量，这些张量在深度方向上堆叠后的结果。其中，形状为 [3] 的一维张量在堆叠时会被扩展为形状为[1, 3]的二维张量。
+也可以参考下方的图示来理解  ``dstack``  是如何对张量进行变换的。图片展示了两个个形状为 [3] 的一维张量以及两个形状为 [3, 2] 的二维张量，这些张量在深度方向上堆叠后的结果。其中，形状为 [3] 的一维张量在堆叠时会被扩展为形状为[1, 3]的二维张量。
 
 .. image:: ../../images/api_legend/dstack.png
    :width: 500
diff --git a/docs/api/paddle/empty_cn.rst b/docs/api/paddle/empty_cn.rst
index dc4a8fa2bf4..5aa3848ddda 100644
--- a/docs/api/paddle/empty_cn.rst
+++ b/docs/api/paddle/empty_cn.rst
@@ -10,33 +10,33 @@ empty
 创建形状大小为 shape 并且数据类型为 dtype 的 Tensor，其中元素值是未初始化的。
 
 .. note::
-    别名支持: 参数名 ``size`` 可替代 ``shape``。
-    ``shape`` 支持可变参数类型。
+    别名支持: 参数名  ``size``  可替代  ``shape`` 。
+     ``shape``  支持可变参数类型。
     使用实例：
-        ``paddle.empty(1, 2, 3, dtype=paddle.float32)``
-        ``paddle.empty(size=[1, 2, 3], dtype=paddle.float32)``
+         ``paddle.empty(1, 2, 3, dtype=paddle.float32)`` 
+         ``paddle.empty(size=[1, 2, 3], dtype=paddle.float32)`` 
 
 参数
 ::::::::::::
 
     - **shape** (list|tuple|Tensor|*shape) - 生成的 Tensor 的形状。数据类型为 int32 或 int64。
-      如果 ``shape`` 是 list、tuple，则其中的元素可以是 int，或者是形状为 [] 且数据类型为 int32、int64 的 0-D Tensor。
-      如果 ``shape`` 是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor，表示一个列表。
-      如果 ``shape`` 是 \*shape，则可以直接以可变参数的形式传入多个整数（例如 ``randn(2, 3)``）。
-      该参数的别名为 ``size``。
+      如果  ``shape``  是 list、tuple，则其中的元素可以是 int，或者是形状为 [] 且数据类型为 int32、int64 的 0-D Tensor。
+      如果  ``shape``  是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor，表示一个列表。
+      如果  ``shape``  是 \*shape，则可以直接以可变参数的形式传入多个整数（例如  ``randn(2, 3)`` ）。
+      该参数的别名为  ``size`` 。
     - **dtype** (str|paddle.dtype|np.dtype，可选)- 输出变量的数据类型，可以是 bool、float16、float32、float64、int32、int64、complex64、complex128。若为 None，则输出变量的数据类型为系统全局默认类型，默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 ::::::::::::
     - **out** (Tensor，可选) - 用于存储结果的 Tensor。若指定，将直接写入该 Tensor，默认值为 None。
-    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。默认值为 None，表示使用当前全局设备（可通过 ``paddle.device.set_device`` 设置）。
+    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。默认值为 None，表示使用当前全局设备（可通过  ``paddle.device.set_device``  设置）。
     - **requires_grad** (bool，可选) - 是否需要为返回的 Tensor 记录梯度信息。默认值为 False。
     - **pin_memory** (bool，可选) - 若为 True，返回的 CPU Tensor 将分配在锁页内存中。仅对 CPU Tensor 生效。默认值为 False。
 
 返回
 ::::::::::::
-返回一个根据 ``shape`` 和 ``dtype`` 创建并且尚未初始化的 Tensor。
+返回一个根据  ``shape``  和  ``dtype``  创建并且尚未初始化的 Tensor。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/empty_like_cn.rst b/docs/api/paddle/empty_like_cn.rst
index c93e26bf8c3..4c3ced454c6 100644
--- a/docs/api/paddle/empty_like_cn.rst
+++ b/docs/api/paddle/empty_like_cn.rst
@@ -6,27 +6,27 @@ empty_like
 .. py:function:: paddle.empty_like(x, dtype=None, name=None, *, device=None, requires_grad=False, pin_memory=False)
 
 
-根据参数 ``x`` 的 shape 和数据类型 ``dtype`` 创建未初始化的 Tensor。如果 ``dtype`` 为 None，则 Tensor 的数据类型与 ``x`` 相同。
+根据参数  ``x``  的 shape 和数据类型  ``dtype``  创建未初始化的 Tensor。如果  ``dtype``  为 None，则 Tensor 的数据类型与  ``x``  相同。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``empty_like(input=tensor_x)`` 等价于 ``empty_like(x=tensor_x)`` 。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``empty_like(input=tensor_x)``  等价于  ``empty_like(x=tensor_x)``  。
 
 参数
 ::::::::::::
 
-    - **x** (Tensor) – 输入 Tensor，输出 Tensor 和 x 具有相同的形状，x 的数据类型可以是 bool、float16、float32、float64、int32、int64。别名： ``input``。
+    - **x** (Tensor) – 输入 Tensor，输出 Tensor 和 x 具有相同的形状，x 的数据类型可以是 bool、float16、float32、float64、int32、int64。别名：  ``input`` 。
     - **dtype** （str|paddle.dtype|np.dtype，可选）- 输出变量的数据类型，可以是 bool、float16、float32、float64、int32、int64。若参数为 None，则输出变量的数据类型和输入变量相同，默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 ::::::::::::
-    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。若为 None，则与 ``x`` 保持一致。
+    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。若为 None，则与  ``x``  保持一致。
     - **requires_grad** (bool，可选) - 是否需要为返回的 Tensor 记录梯度信息。默认值为 False。
     - **pin_memory** (bool，可选) - 若为 True，返回的 CPU Tensor 将分配在锁页内存中。仅对 CPU Tensor 生效。默认值为 False。
 
 返回
 ::::::::::::
-返回一个根据 ``x`` 和 ``dtype`` 创建并且尚未初始化的 Tensor。
+返回一个根据  ``x``  和  ``dtype``  创建并且尚未初始化的 Tensor。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/eq_cn.rst b/docs/api/paddle/eq_cn.rst
index 94735895955..cf3be378c8e 100644
--- a/docs/api/paddle/eq_cn.rst
+++ b/docs/api/paddle/eq_cn.rst
@@ -5,4 +5,4 @@ eq
 
 .. py:function:: paddle.eq(x, y, name=None, *, out=None)
 
-``equal`` 的别名，请参考 :ref:`cn_api_paddle_equal`。
+ ``equal``  的别名，请参考 :ref:`cn_api_paddle_equal`。
diff --git a/docs/api/paddle/exp_cn.rst b/docs/api/paddle/exp_cn.rst
index 375ae21b3e2..adb6103b2f7 100644
--- a/docs/api/paddle/exp_cn.rst
+++ b/docs/api/paddle/exp_cn.rst
@@ -21,7 +21,7 @@ exp
 
 返回
 ::::::::::::
-输出为 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出为 Tensor，与  ``x``  维度相同、数据类型相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/expand_as_cn.rst b/docs/api/paddle/expand_as_cn.rst
index 6fb1c616d10..30f6a48251d 100644
--- a/docs/api/paddle/expand_as_cn.rst
+++ b/docs/api/paddle/expand_as_cn.rst
@@ -5,9 +5,9 @@ expand_as
 
 .. py:function:: paddle.expand_as(x, y, name=None)
 
-根据 ``y`` 的形状扩展 ``x``，扩展后，``x`` 的形状和 ``y`` 的形状相同。
+根据  ``y``  的形状扩展  ``x`` ，扩展后， ``x``  的形状和  ``y``  的形状相同。
 
-``x`` 的维数和 ``y`` 的维数应小于等于 6，并且 ``y`` 的维数应该大于等于 ``x`` 的维数。扩展的维度的维度值应该为 1。
+ ``x``  的维数和  ``y``  的维数应小于等于 6，并且  ``y``  的维数应该大于等于  ``x``  的维数。扩展的维度的维度值应该为 1。
 
 下图展示了一个一维张量通过 expand_as 操作转变为形状为[2,3]的张量。目标张量的形状为[2,3]，通过 expand_as，一维张量扩展成形状为[2,3]的张量。
 
@@ -16,18 +16,18 @@ expand_as
    :alt: 图例
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``， ``other`` 可替代 ``y``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，  ``other``  可替代  ``y`` 。
 
 参数
 :::::::::
     - **x** (Tensor) - 输入的 Tensor，数据类型为：bool、float32、float64、int32 或 int64。
-      别名： ``input``
-    - **y** (Tensor) - 给定输入 ``x`` 扩展后的形状。
-      别名： ``other``
+      别名：  ``input`` 
+    - **y** (Tensor) - 给定输入  ``x``  扩展后的形状。
+      别名：  ``other`` 
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 返回
 :::::::::
-Tensor，数据类型与 ``x`` 相同。
+Tensor，数据类型与  ``x``  相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/expand_cn.rst b/docs/api/paddle/expand_cn.rst
index 1ec5c03292c..1ba2751d5fc 100644
--- a/docs/api/paddle/expand_cn.rst
+++ b/docs/api/paddle/expand_cn.rst
@@ -5,12 +5,12 @@ expand
 
 .. py:function:: paddle.expand(x, shape, name=None)
 
-根据 ``shape`` 指定的形状扩展 ``x``，扩展后，``x`` 的形状和 ``shape`` 指定的形状一致。
+根据  ``shape``  指定的形状扩展  ``x`` ，扩展后， ``x``  的形状和  ``shape``  指定的形状一致。
 
-``x`` 的维数和 ``shape`` 的元素数应小于等于 6，并且 ``shape`` 中的元素数应该大于等于 ``x`` 的维数。扩展的维度的维度值应该为 1。
+ ``x``  的维数和  ``shape``  的元素数应小于等于 6，并且  ``shape``  中的元素数应该大于等于  ``x``  的维数。扩展的维度的维度值应该为 1。
 
 **示例图解说明**：
-    Original Tensor 显示了一个形状为 [3] 的一维张量 [1, 2, 3]。通过 paddle.expand 方法（参数 ``shape = [2, 3]``）被广播扩展为一个形状为 [2, 3] 的二维张量。
+    Original Tensor 显示了一个形状为 [3] 的一维张量 [1, 2, 3]。通过 paddle.expand 方法（参数  ``shape = [2, 3]`` ）被广播扩展为一个形状为 [2, 3] 的二维张量。
 
     .. figure:: ../../images/api_legend/expand.png
        :width: 500
@@ -18,26 +18,26 @@ expand
        :align: center
 
 .. note::
-    别名支持: 别名支持: 参数名 ``input`` 可替代 ``x`` 和 ``size`` 可替代 ``shape``。
-    ``shape`` 支持可变参数类型。
+    别名支持: 别名支持: 参数名  ``input``  可替代  ``x``  和  ``size``  可替代  ``shape`` 。
+     ``shape``  支持可变参数类型。
     使用实例：
-        ``paddle.expand(tensor_x, shape=[3, 4], name=None)``
-        ``tensor_x.expand([3, 4]) -> paddle.expand(tensor_x, [3, 4])``
-        ``tensor_x.expand(3, 4) -> paddle.expand(tensor_x, 3, 4)``
-        ``tensor_x.expand(size=[3, 4]) -> paddle.expand(tensor_x, size=[3, 4])``
+         ``paddle.expand(tensor_x, shape=[3, 4], name=None)`` 
+         ``tensor_x.expand([3, 4]) -> paddle.expand(tensor_x, [3, 4])`` 
+         ``tensor_x.expand(3, 4) -> paddle.expand(tensor_x, 3, 4)`` 
+         ``tensor_x.expand(size=[3, 4]) -> paddle.expand(tensor_x, size=[3, 4])`` 
 
 
 参数
 :::::::::
     - **x** (Tensor) - 输入的 Tensor，数据类型为：bool、float16、float32、float64、int32、int64、uint8 或 uint16。
-      别名： ``input``
-    - **shape** (tuple|list|Tensor) - 给定输入 ``x`` 扩展后的形状，若 ``shape`` 为 list 或者 tuple，则其中的元素值应该为整数或者是形状为 1-D 或 0-D 的 Tensor，若 ``shape`` 类型为 Tensor，则其应该为 1-D Tensor。值为-1 表示保持相应维度的形状不变。支持可变参数类型。
-      别名： ``size``
+      别名：  ``input`` 
+    - **shape** (tuple|list|Tensor) - 给定输入  ``x``  扩展后的形状，若  ``shape``  为 list 或者 tuple，则其中的元素值应该为整数或者是形状为 1-D 或 0-D 的 Tensor，若  ``shape``  类型为 Tensor，则其应该为 1-D Tensor。值为-1 表示保持相应维度的形状不变。支持可变参数类型。
+      别名：  ``size`` 
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-``N-D Tensor``，数据类型与 ``x`` 相同。
+ ``N-D Tensor`` ，数据类型与  ``x``  相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/expm1_cn.rst b/docs/api/paddle/expm1_cn.rst
index a75876ce6dd..d4b0515bb8a 100644
--- a/docs/api/paddle/expm1_cn.rst
+++ b/docs/api/paddle/expm1_cn.rst
@@ -22,7 +22,7 @@ expm1
 返回
 :::::::::
 
-输出为 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出为 Tensor，与  ``x``  维度相同、数据类型相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/eye_cn.rst b/docs/api/paddle/eye_cn.rst
index e0e8f932528..e53512c0d73 100644
--- a/docs/api/paddle/eye_cn.rst
+++ b/docs/api/paddle/eye_cn.rst
@@ -8,12 +8,12 @@ eye
 构建二维 Tensor(主对角线元素为 1，其他元素为 0)。
 
 .. note::
-    别名支持: 参数名 ``n`` 可替代 ``num_rows`` 和 ``m`` 可替代 ``num_columns``，如 ``n=1`` 等价于 ``num_rows=1``， ``m=2`` 等价于 ``num_columns=2``。
+    别名支持: 参数名  ``n``  可替代  ``num_rows``  和  ``m``  可替代  ``num_columns`` ，如  ``n=1``  等价于  ``num_rows=1`` ，  ``m=2``  等价于  ``num_columns=2`` 。
 
 参数
 ::::::::::::
-  - **num_rows** (int|Tensor) - 生成 2-D Tensor 的行数，数据类型为非负 int32。别名：``n``。
-  - **num_columns** (int|Tensor|None，可选) - 生成 2-D Tensor 的列数，数据类型为非负 int32。若为 None，则默认等于 ``num_rows``。别名：``m``。
+  - **num_rows** (int|Tensor) - 生成 2-D Tensor 的行数，数据类型为非负 int32。别名： ``n`` 。
+  - **num_columns** (int|Tensor|None，可选) - 生成 2-D Tensor 的列数，数据类型为非负 int32。若为 None，则默认等于  ``num_rows`` 。别名： ``m`` 。
   - **dtype** (str|paddle.dtype|np.dtype，可选) - 返回 Tensor 的数据类型。支持 int32、int64、float16、float32、float64、complex64、complex128。
     默认值为 None，此时返回 Tensor 的数据类型为 float32。
   - **name** (str，可选) - 操作的名称，具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
@@ -21,14 +21,14 @@ eye
 关键字参数
 ::::::::::::
   - **out** (Tensor，可选) - 用于保存输出结果的 Tensor，默认值为 None。
-  - **device** (PlaceLike|None，可选) - 指定返回 Tensor 所在的设备。默认值为 None，表示使用当前全局设备（可通过 ``paddle.device.set_device`` 设置）。
+  - **device** (PlaceLike|None，可选) - 指定返回 Tensor 所在的设备。默认值为 None，表示使用当前全局设备（可通过  ``paddle.device.set_device``  设置）。
     对于 CPU Tensor，设备为 CPU；对于 CUDA Tensor，设备为当前 CUDA 设备。默认值为 None。
   - **requires_grad** (bool，可选) - 是否在返回的 Tensor 上记录 autograd 的操作。默认值为 False。
   - **pin_memory** (bool，可选) - 若设置为 True，则返回的 Tensor 将分配在锁页内存中。仅对 CPU Tensor 生效。默认值为 False。
 
 返回
 ::::::::::::
- ``shape`` 为 [num_rows, num_columns]的 Tensor。
+  ``shape``  为 [num_rows, num_columns]的 Tensor。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/fft/Overview_cn.rst b/docs/api/paddle/fft/Overview_cn.rst
index bd419597f40..0b664fe4212 100644
--- a/docs/api/paddle/fft/Overview_cn.rst
+++ b/docs/api/paddle/fft/Overview_cn.rst
@@ -64,7 +64,7 @@ paddle.fft 目录下包含飞桨框架支持的快速傅里叶变换的相关 AP
     :header: "API 名称", "API 功能"
 
     " :ref:`paddle.fft.fftfreq <cn_api_paddle_fft_fftfreq>` ", "计算傅里叶变换采样频率"
-    " :ref:`paddle.fft.rfftfreq <cn_api_paddle_fft_rfftfreq>` ", "计算傅里叶变换采样频率，用于 ``rfft``, ``irfft``"
+    " :ref:`paddle.fft.rfftfreq <cn_api_paddle_fft_rfftfreq>` ", "计算傅里叶变换采样频率，用于  ``rfft`` ,  ``irfft`` "
     " :ref:`paddle.fft.fftshift <cn_api_paddle_fft_fftshift>` ", "移动零频率项至频谱中心"
     " :ref:`paddle.fft.ifftshift <cn_api_paddle_fft_ifftshift>` ", "fftshift 的逆变换"
 
@@ -101,20 +101,20 @@ n 为傅里叶变换点数，亦即傅里叶变换轴的长度。
 :math:`\sigma` 为缩放系数，和变换的方向以及缩放方案有关。paddle.fft 中缩放方案有三种：
 "forward"，"backward"，"ortho" 之一，默认值为 "backward"。三种缩放模式对应的行为如下：
 
-- "backward": 正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``;
-- "forward": 正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``;
-- "ortho": 正向和逆向变换的缩放系数均为 ``1/sqrt(n)``;
+- "backward": 正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ;
+- "forward": 正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ;
+- "ortho": 正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ;
 
 输出的结果遵循“标准”排布：
 
-如果 ``X = fft(x, n)``, 那么 ``X[0]`` 包含 0 频率项（亦即直流分量），对于实数输入来说，
-这一项总是实数。``X[1: n//2]`` 包含正频率项，频率以递增顺序排列。``X[n//2 + 1:]`` 包含负
-频率项，频率以绝对值从大到小排列。对于傅里叶变换点数为偶数的情况，``X[n//2]`` 同时包含了正和
-负的奈奎斯特（Nyquist）频率项，对于实数输入来说，这一项也总是实数。``X[(n-1)//2]`` 为频率最
+如果  ``X = fft(x, n)`` , 那么  ``X[0]``  包含 0 频率项（亦即直流分量），对于实数输入来说，
+这一项总是实数。 ``X[1: n//2]``  包含正频率项，频率以递增顺序排列。 ``X[n//2 + 1:]``  包含负
+频率项，频率以绝对值从大到小排列。对于傅里叶变换点数为偶数的情况， ``X[n//2]``  同时包含了正和
+负的奈奎斯特（Nyquist）频率项，对于实数输入来说，这一项也总是实数。 ``X[(n-1)//2]``  为频率最
 大的正频率项，`X[(n+1)//2]`为频率绝对值最大的负频率项。
 
-``paddle.fft.fftfreq(n)`` 可以返回频谱中每一项对应的频率值。``paddle.fft.fftshift(X)``
-可以对频谱进行偏移，将零频率移动到中心位置，``paddle.fft.fftshift(X)`` 则是这个变换的逆变
+ ``paddle.fft.fftfreq(n)``  可以返回频谱中每一项对应的频率值。 ``paddle.fft.fftshift(X)`` 
+可以对频谱进行偏移，将零频率移动到中心位置， ``paddle.fft.fftshift(X)``  则是这个变换的逆变
 换。
 
 多维离散傅里叶变换
@@ -134,9 +134,9 @@ d 是傅里叶变换维数。 :math:`n_{1}, n_{2}, \cdots, n_{d}` 是每个傅
 :math:`\sigma` 为缩放系数，和变换的方向以及缩放方案有关。paddle.fft 中缩放方案有三种：
 "forward"，"backward"，"ortho" 之一，默认值为 "backward"。三种缩放模式对应的行为如下：
 
-- "backward": 正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``;
-- "forward": 正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``;
-- "ortho": 正向和逆向变换的缩放系数均为 ``1/sqrt(n)``;
+- "backward": 正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ;
+- "forward": 正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ;
+- "ortho": 正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ;
 
 其中
 
@@ -151,13 +151,13 @@ d 是傅里叶变换维数。 :math:`n_{1}, n_{2}, \cdots, n_{d}` 是每个傅
 
 当输入信号为实数信号时，傅里叶变换的结果具有厄米特对称性，亦即频率 :math:`f_{k}` 上的分量和
 :math:`-f_{k}` 上的分量互为共轭。因此可以利用对称性来减少计算量。实数傅里叶变换
-(``rfft``) 系列的函数是用于实数输入的，并且利用了对称性，只计算正频率项，直到奈奎斯特频率项。
-因此，对于实数傅里叶变换，``n`` 个复数输入点只产生 ``n//2 + 1`` 个实数输出点。这一系列变换
-的逆变换也预设了输入数据具有厄米特对称性，要产生 ``n`` 个实数输出点，只需要使用
-``n//2 + 1`` 个复数输入点。
+( ``rfft`` ) 系列的函数是用于实数输入的，并且利用了对称性，只计算正频率项，直到奈奎斯特频率项。
+因此，对于实数傅里叶变换， ``n``  个复数输入点只产生  ``n//2 + 1``  个实数输出点。这一系列变换
+的逆变换也预设了输入数据具有厄米特对称性，要产生  ``n``  个实数输出点，只需要使用
+ ``n//2 + 1``  个复数输入点。
 
-与此相对应，当频谱是纯实数时，输入信号具有厄米特对称性。厄米特傅里叶变换（``hfft``）系列同样
-利用对称性，产生 ``n`` 个实数输出点，只需要使用 ``n//2 + 1`` 个复数输入点。
+与此相对应，当频谱是纯实数时，输入信号具有厄米特对称性。厄米特傅里叶变换（ ``hfft`` ）系列同样
+利用对称性，产生  ``n``  个实数输出点，只需要使用  ``n//2 + 1``  个复数输入点。
 
 
 自动微分与 Wertinger Calculus
diff --git a/docs/api/paddle/fft/fft2_cn.rst b/docs/api/paddle/fft/fft2_cn.rst
index 6400a227482..300ee0f8c31 100644
--- a/docs/api/paddle/fft/fft2_cn.rst
+++ b/docs/api/paddle/fft/fft2_cn.rst
@@ -15,27 +15,27 @@ fft2
 
 - **x** (Tensor) - 输入 Tensor，数据类型为实数或复数。
 - **s** (Sequence[int]，可选) - 输出 Tensor 在每一个傅里叶变换轴上的长度（类似一维傅里
-  叶变换中的参数 ``n``）。对于每一个傅里叶变换的轴，如果 ``s`` 中该轴的长度比输入 Tensor
-  中对应轴的长度小，输入 Tensor 会被截断。如果 ``s`` 中该轴的长度比输入 Tensor 中对应轴
-  的长度大，则输入会被补零。如果 ``s`` 没有指定，则使用输入 Tensor 中由 ``axes`` 指定的各
+  叶变换中的参数  ``n`` ）。对于每一个傅里叶变换的轴，如果  ``s``  中该轴的长度比输入 Tensor
+  中对应轴的长度小，输入 Tensor 会被截断。如果  ``s``  中该轴的长度比输入 Tensor 中对应轴
+  的长度大，则输入会被补零。如果  ``s``  没有指定，则使用输入 Tensor 中由  ``axes``  指定的各
   个轴的长度。
 - **axes** (Sequence[int]，可选) - 傅里叶变换的轴。如果没有指定，默认使用最后两个轴。
 - **norm** (str，可选) - 傅里叶变换的缩放模式，缩放系数由变换的方向和缩放模式同时决定。取
   值必须是 "forward"，"backward"，"ortho" 之一，默认值为 "backward"。三种缩放模式对应
   的行为如下：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
-  其中 ``n`` 为 ``s`` 中每个元素连乘。
+  其中  ``n``  为  ``s``  中每个元素连乘。
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 :::::::::
 Tensor，形状和输入 Tensor 相同，数据类型为复数。由输入 Tensor（可能被截断或者补零之后）在
-指定维度进行傅里叶变换的输出。二维傅里叶变换为 N 维傅里叶(``fftn``)变换的特例。
+指定维度进行傅里叶变换的输出。二维傅里叶变换为 N 维傅里叶( ``fftn`` )变换的特例。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/fft/fft_cn.rst b/docs/api/paddle/fft/fft_cn.rst
index 127866d53bb..b5154e47f56 100644
--- a/docs/api/paddle/fft/fft_cn.rst
+++ b/docs/api/paddle/fft/fft_cn.rst
@@ -13,15 +13,15 @@ fft
 :::::::::
 
 - **x** (Tensor) - 输入 Tensor，数据类型为实数或复数。
-- **n** (int，可选) - 输出 Tensor 中傅里叶变换轴的长度。如果 ``n`` 比输入 Tensor 中对应轴的长度小，输入数据会被截断。如果 ``n`` 比输入 Tensor 中对应轴的长度大，则输入会被补零。如果 ``n`` 没有被指定，则使用输入 Tensor 中由 ``axis`` 指定的轴的长度。
+- **n** (int，可选) - 输出 Tensor 中傅里叶变换轴的长度。如果  ``n``  比输入 Tensor 中对应轴的长度小，输入数据会被截断。如果  ``n``  比输入 Tensor 中对应轴的长度大，则输入会被补零。如果  ``n``  没有被指定，则使用输入 Tensor 中由  ``axis``  指定的轴的长度。
 - **axis** (int，可选) - 傅里叶变换的轴。如果没有指定，默认使用最后一维。
 - **norm** (str，可选) - 傅里叶变换的缩放模式，缩放系数由变换的方向和缩放模式同时决定。取
   值必须是 "forward"，"backward"，"ortho" 之一，默认值为 "backward"。三种缩放模式对应
   的行为如下：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/fft/fftfreq_cn.rst b/docs/api/paddle/fft/fftfreq_cn.rst
index c5b7d7d17ec..170fd3899cc 100644
--- a/docs/api/paddle/fft/fftfreq_cn.rst
+++ b/docs/api/paddle/fft/fftfreq_cn.rst
@@ -19,14 +19,14 @@ fftfreq
 - **n** (int) - 窗长度（傅里叶变换点数）。
 - **d** (float，可选) - 采样间隔，采样率的倒数，默认值为 1。
 - **dtype** (str|paddle.dtype|np.dtype，可选) - 返回 Tensor 的数据类型，默认为
-  ``paddle.get_default_dtype()`` 返回的类型。
+   ``paddle.get_default_dtype()``  返回的类型。
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 :::::::::
 
-Tensor，形状为 ``[n]``，数据类型为 ``dtype`` 指定的数据类型，包含频率窗口中心序列。
+Tensor，形状为  ``[n]`` ，数据类型为  ``dtype``  指定的数据类型，包含频率窗口中心序列。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/fft/fftn_cn.rst b/docs/api/paddle/fft/fftn_cn.rst
index 454574dacba..b5fd0379f85 100644
--- a/docs/api/paddle/fft/fftn_cn.rst
+++ b/docs/api/paddle/fft/fftn_cn.rst
@@ -14,21 +14,21 @@ fftn
 
 - **x** (Tensor) - 输入数据，其数据类型可以为实数或复数。
 - **s** (Sequence[int]，可选) - 输出 Tensor 在每一个傅里叶变换轴上的长度（类似一维傅里
-  叶变换中的参数 ``n``）。对于每一个傅里叶变换的轴，如果 ``s`` 中该轴的长度比输入 Tensor
-  中对应轴的长度小，输入 Tensor 会被截断。如果 ``s`` 中该轴的长度比输入 Tensor 中对应轴
-  的长度大，则输入会被补零。如果 ``s`` 没有指定，则使用输入 Tensor 中由 ``axes`` 指定的各
+  叶变换中的参数  ``n`` ）。对于每一个傅里叶变换的轴，如果  ``s``  中该轴的长度比输入 Tensor
+  中对应轴的长度小，输入 Tensor 会被截断。如果  ``s``  中该轴的长度比输入 Tensor 中对应轴
+  的长度大，则输入会被补零。如果  ``s``  没有指定，则使用输入 Tensor 中由  ``axes``  指定的各
   个轴的长度。
 - **axes** (Sequence[int]，可选) - 计算快速傅里叶变换的轴。如果没有指定，默认是使用最后
-  ``len(s)`` 个轴，如果 ``s`` 也没有指定则使用输入 Tensor 的全部的轴。
+   ``len(s)``  个轴，如果  ``s``  也没有指定则使用输入 Tensor 的全部的轴。
 - **norm** (str，可选) - 指定傅里叶变换的缩放模式，缩放系数由变换的方向和模式同时决定。取
   值必须是 "forward", "backward", "ortho"之一，默认值为 "backward"。三种缩放模式对应
   的行为如下：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
-  其中 ``n`` 为 ``s`` 中每个元素连乘。
+  其中  ``n``  为  ``s``  中每个元素连乘。
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
diff --git a/docs/api/paddle/fft/fftshift_cn.rst b/docs/api/paddle/fft/fftshift_cn.rst
index 3e6e1c92f1d..88d3ed1d4ba 100644
--- a/docs/api/paddle/fft/fftshift_cn.rst
+++ b/docs/api/paddle/fft/fftshift_cn.rst
@@ -18,7 +18,7 @@ fftshift
 返回
 :::::::::
 
-Tensor，形状和数据类型与输入 Tensor 相同，沿着 ``axes`` 移动后的输出。
+Tensor，形状和数据类型与输入 Tensor 相同，沿着  ``axes``  移动后的输出。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/fft/hfft2_cn.rst b/docs/api/paddle/fft/hfft2_cn.rst
index e7a838bd775..e420bd3b8f3 100644
--- a/docs/api/paddle/fft/hfft2_cn.rst
+++ b/docs/api/paddle/fft/hfft2_cn.rst
@@ -13,24 +13,24 @@ hfft2
 
 - **x** (Tensor) - 输入数据，其数据类型为复数类型。
 - **s** (Sequence[int]，可选) - 输出 Tensor 在傅里叶变换轴的长度（类似一维傅里叶变换中
-  的参数 ``n``）。
+  的参数  ``n`` ）。
 - **axes** (Sequence[int]，可选) - 傅里叶变换的轴。如果没有指定，默认使用最后两个轴。
 - **norm** (str，可选) - 傅里叶变换的缩放模式，缩放系数由变换的方向和缩放模式同时决定。取
   值必须是 "forward"，"backward"，"ortho" 之一，默认值为 "backward"。三种缩放模式对应
   的行为如下：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
-  其中 ``n`` 为 ``s`` 中每个元素连乘。
+  其中  ``n``  为  ``s``  中每个元素连乘。
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 :::::::::
 Tensor，数据类型为实数。由输入 Tensor（可能被截断或者补零之后）在指定维度进行傅里叶变换的输
-出。二维傅里叶变换为 N 维傅里叶(``hfftn``)变换的特例。
+出。二维傅里叶变换为 N 维傅里叶( ``hfftn`` )变换的特例。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/fft/hfft_cn.rst b/docs/api/paddle/fft/hfft_cn.rst
index 275b148b846..e608e444dd4 100644
--- a/docs/api/paddle/fft/hfft_cn.rst
+++ b/docs/api/paddle/fft/hfft_cn.rst
@@ -14,17 +14,17 @@ hfft
 
 - **x** (Tensor) - 输入数据，其数据类型为复数。
 - **n** (int，可选) - 输出 Tensor 在傅里叶变换轴的长度。输入 Tensor 在该轴的长度必须为
-  ``n//2+1``，如果输入 Tensor 的长度大于 ``n//2+1``，输入 Tensor 会被截断。如果输入
-  Tensor 的长度小于 ``n//2+1``，则输入 Tensor 会被补零。如果 ``n`` 没有被指定，则取
-  ``2*(m-1)``，其中，``m`` 是输入 Tensor 在 ``axis`` 维的长度。
+   ``n//2+1`` ，如果输入 Tensor 的长度大于  ``n//2+1`` ，输入 Tensor 会被截断。如果输入
+  Tensor 的长度小于  ``n//2+1`` ，则输入 Tensor 会被补零。如果  ``n``  没有被指定，则取
+   ``2*(m-1)`` ，其中， ``m``  是输入 Tensor 在  ``axis``  维的长度。
 - **axis** (int，可选) - 傅里叶变换的轴。如果没有指定，默认是使用最后一维。
 - **norm** (str，可选) - 傅里叶变换的缩放模式，缩放系数由变换的方向和缩放模式同时决定。取
   值必须是 "forward", "backward", "ortho" 之一，默认值为 "backward"。三种缩放模式对
   应的行为如下：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
@@ -32,8 +32,8 @@ hfft
 返回
 :::::::::
 Tensor，数据类型为实数。由输入 Tensor（可能被截断或者补零之后）在指定维度进行傅里叶变换的输
-出。如果指定 n，则输出 Tensor 在傅立叶变换轴的长度为 n，否则为 ``2*(m-1)``，其中``m``
-是输入 Tensor 在 ``axis`` 维的长度。
+出。如果指定 n，则输出 Tensor 在傅立叶变换轴的长度为 n，否则为  ``2*(m-1)`` ，其中 ``m`` 
+是输入 Tensor 在  ``axis``  维的长度。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/fft/hfftn_cn.rst b/docs/api/paddle/fft/hfftn_cn.rst
index b6e331af183..63915feae73 100644
--- a/docs/api/paddle/fft/hfftn_cn.rst
+++ b/docs/api/paddle/fft/hfftn_cn.rst
@@ -13,35 +13,35 @@ hfftn
 
 - **x** (Tensor) - 输入数据，其数据类型为复数类型。
 - **s** (Sequence[int]，可选) - 输出 Tensor 在每一个傅里叶变换轴上的长度（类似一维傅里
-  叶变换中的参数 ``n``）。对于傅里叶变换的最后一个轴，输入长度要求是 ``s[-1]//2+1``，如果
-  输入 Tensor 的长度大于 ``s[-1]//2+1``，输入 Tensor 会被截断。如果输入 Tensor 的长度
-  小于 ``s[-1]//2+1``，则输入 Tensor 会被补零；
+  叶变换中的参数  ``n`` ）。对于傅里叶变换的最后一个轴，输入长度要求是  ``s[-1]//2+1`` ，如果
+  输入 Tensor 的长度大于  ``s[-1]//2+1`` ，输入 Tensor 会被截断。如果输入 Tensor 的长度
+  小于  ``s[-1]//2+1`` ，则输入 Tensor 会被补零；
 
-  - 对于傅里变换其他每一个轴 ``i``，如果输入 Tensor 的长度大于 ``s[i]``，输入 Tensor 会被截断。如果输入 Tensor 的长度小于 ``s[i]``，则输入 Tensor 会被补零；
-  - 如果未指定 `s`，则 ``s`` 在最后一个傅里叶变换轴取值为 ``2*(m-1)``，其中 ``m`` 是输入 Tensor 在最后一个傅里叶变换轴的长度，其余轴为输入 Tensor 在该轴的长度。
+  - 对于傅里变换其他每一个轴  ``i`` ，如果输入 Tensor 的长度大于  ``s[i]`` ，输入 Tensor 会被截断。如果输入 Tensor 的长度小于  ``s[i]`` ，则输入 Tensor 会被补零；
+  - 如果未指定 `s`，则  ``s``  在最后一个傅里叶变换轴取值为  ``2*(m-1)`` ，其中  ``m``  是输入 Tensor 在最后一个傅里叶变换轴的长度，其余轴为输入 Tensor 在该轴的长度。
 
 - **axes** (Sequence[int]，可选) - 计算快速傅里叶变换的轴。如果没有指定，默认是使用最
-  后 ``len(s)`` 个轴，如果 ``s`` 也没有指定则使用输入数据的全部的轴。
+  后  ``len(s)``  个轴，如果  ``s``  也没有指定则使用输入数据的全部的轴。
 - **norm** (str，可选) - 指定傅里叶变换的缩放模式，缩放系数由变换的方向和模式同时决定。取
   值必须是 "forward"，"backward"，"ortho"之一，默认值为 "backward"。三种缩放模式对应的
   行为如下：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
-  其中 ``n`` 为 ``s`` 中每个元素连乘。
+  其中  ``n``  为  ``s``  中每个元素连乘。
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 :::::::::
 Tensor，数据类型为实数。输入数据（可能被截断或者补零之后）在指定维度进行傅里叶变换的输出。
-如果指定 ``s``，则输出 Tensor 在傅里叶变换维度的长度为 ``s``。否则输出 Tensor 在最后一个
-傅里叶变换轴的长度为 ``2*(m-1)``，其中 ``m`` 是输入 Tensor 在最后一个傅里叶变换轴的长度，
+如果指定  ``s`` ，则输出 Tensor 在傅里叶变换维度的长度为  ``s`` 。否则输出 Tensor 在最后一个
+傅里叶变换轴的长度为  ``2*(m-1)`` ，其中  ``m``  是输入 Tensor 在最后一个傅里叶变换轴的长度，
 其余轴为输入 Tensor 在对应轴的长度。
 
-如果未指定 ``s``，则输出在最后一个傅里叶变换轴上的长度一定为偶数。
+如果未指定  ``s`` ，则输出在最后一个傅里叶变换轴上的长度一定为偶数。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/fft/ifft2_cn.rst b/docs/api/paddle/fft/ifft2_cn.rst
index d44745b3c5c..b4ea4197429 100644
--- a/docs/api/paddle/fft/ifft2_cn.rst
+++ b/docs/api/paddle/fft/ifft2_cn.rst
@@ -5,7 +5,7 @@ ifft2
 
 .. py:function:: paddle.fft.ifft2(x, s=None, axes=(-2, -1), norm="backward", name=None)
 
-二维傅里叶变换(``fft2``)的逆变换。在一定的误差范围内，``ifft2(fft2(x)) == x``。
+二维傅里叶变换( ``fft2`` )的逆变换。在一定的误差范围内， ``ifft2(fft2(x)) == x`` 。
 
 
 参数
@@ -13,27 +13,27 @@ ifft2
 
 - **x** (Tensor) - 输入 Tensor，数据类型为实数或复数。
 - **s** (Sequence[int]，可选) - 输出 Tensor 在每一个傅里叶变换轴上的长度（类似一维逆向傅
-  里叶变换中的参数 ``n``）。对于每一个傅里叶变换的轴，如果 ``s`` 中该轴的长度比输入 Tensor
-  中对应轴的长度小，输入 Tensor 会被截断。如果 ``s`` 中该轴的长度比输入 Tensor 中对应轴
-  的长度大，则输入会被补零。如果 ``s`` 没有指定，则使用输入 Tensor 中由 ``axes`` 指定的各
+  里叶变换中的参数  ``n`` ）。对于每一个傅里叶变换的轴，如果  ``s``  中该轴的长度比输入 Tensor
+  中对应轴的长度小，输入 Tensor 会被截断。如果  ``s``  中该轴的长度比输入 Tensor 中对应轴
+  的长度大，则输入会被补零。如果  ``s``  没有指定，则使用输入 Tensor 中由  ``axes``  指定的各
   个轴的长度。
 - **axes** (Sequence[int]，可选) - 傅里叶变换的轴。如果没有指定，默认使用最后两维。
 - **norm** (str，可选) - 傅里叶变换的缩放模式，缩放系数由变换的方向和缩放模式同时决定。取值
   必须是 "forward"，"backward"，"ortho" 之一，默认值为 "backward"。三种缩放模式对
   应的行为如下：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
-  其中 ``n`` 为 ``s`` 中每个元素连乘。
+  其中  ``n``  为  ``s``  中每个元素连乘。
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 :::::::::
 Tensor，形状和输入 Tensor 相同，数据类型为复数。由输入 Tensor（可能被截断或者补零之后）在
-指定维度进行傅里叶变换的输出。二维傅里叶变换是 N 维傅里叶变换的特例，参考 ``ifftn``。
+指定维度进行傅里叶变换的输出。二维傅里叶变换是 N 维傅里叶变换的特例，参考  ``ifftn`` 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/fft/ifft_cn.rst b/docs/api/paddle/fft/ifft_cn.rst
index 3987ada21e2..5728014e5fe 100644
--- a/docs/api/paddle/fft/ifft_cn.rst
+++ b/docs/api/paddle/fft/ifft_cn.rst
@@ -5,23 +5,23 @@ ifft
 
 .. py:function:: paddle.fft.ifft(x, n=None, axis=-1, norm="backward", name=None)
 
-一维傅里叶变换（``fft``）的逆变换。在一定的误差范围内，``ifft(fft(x)) == x``。
+一维傅里叶变换（ ``fft`` ）的逆变换。在一定的误差范围内， ``ifft(fft(x)) == x`` 。
 
 参数
 :::::::::
 
 - **x** (Tensor) - 输入 Tensor，数据类型为实数或复数。
-- **n** (int，可选) - 输出 Tensor 中在傅里叶变换轴的长度。如果 ``n`` 比输入 Tensor 中
-  对应轴的长度小，输入数据会被截断。如果 ``n`` 比输入 Tensor 中对应轴的长度大，则输入会被
-  补零。如果 ``n`` 没有被指定，则使用输入 Tensor 中由 ``axis`` 指定的轴的长度。
+- **n** (int，可选) - 输出 Tensor 中在傅里叶变换轴的长度。如果  ``n``  比输入 Tensor 中
+  对应轴的长度小，输入数据会被截断。如果  ``n``  比输入 Tensor 中对应轴的长度大，则输入会被
+  补零。如果  ``n``  没有被指定，则使用输入 Tensor 中由  ``axis``  指定的轴的长度。
 - **axis** (int, 可选) - 傅里叶变换的轴。如果没有指定，默认使用最后一维。
 - **norm** (str，可选) - 傅里叶变换的缩放模式，缩放系数由变换的方向和缩放模式同时决定。取值
   必须是 "forward"，"backward"，"ortho" 之一，默认值为 "backward"。三种缩放模式对
   应的行为如下：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/fft/ifftn_cn.rst b/docs/api/paddle/fft/ifftn_cn.rst
index ee4ccee8c6d..d9e69d8055a 100644
--- a/docs/api/paddle/fft/ifftn_cn.rst
+++ b/docs/api/paddle/fft/ifftn_cn.rst
@@ -5,7 +5,7 @@ ifftn
 
 .. py:function:: paddle.fft.ifftn(x, s=None, axes=None, norm="backward", name=None)
 
-N 维离散傅里叶变换的逆变换。在一定的误差范围内，``ifftn(fftn(x)) == x``。
+N 维离散傅里叶变换的逆变换。在一定的误差范围内， ``ifftn(fftn(x)) == x`` 。
 
 
 参数
@@ -13,21 +13,21 @@ N 维离散傅里叶变换的逆变换。在一定的误差范围内，``ifftn(f
 
 - **x** (Tensor) - 输入 Tensor，数据类型为实数或复数。
 - **s** (Sequence[int]，可选) - 输出 Tensor 在每一个傅里叶变换轴上的长度（类似一维逆向傅
-  里叶变换中的参数 ``n``）。对于每一个傅里叶变换的轴，如果 ``s`` 中该轴的长度比输入 Tensor
-  中对应轴的长度小，输入 Tensor 会被截断。如果 ``s`` 中该轴的长度比输入 Tensor 中对应轴
-  的长度大，则输入会被补零。如果 ``s`` 没有指定，则使用输入 Tensor 中由 ``axes`` 指定的各
+  里叶变换中的参数  ``n`` ）。对于每一个傅里叶变换的轴，如果  ``s``  中该轴的长度比输入 Tensor
+  中对应轴的长度小，输入 Tensor 会被截断。如果  ``s``  中该轴的长度比输入 Tensor 中对应轴
+  的长度大，则输入会被补零。如果  ``s``  没有指定，则使用输入 Tensor 中由  ``axes``  指定的各
   个轴的长度。
 - **axes** (Sequence[int]，可选) - 傅里叶变换的轴。如果没有指定，默认是使用最后
-  ``len(s)`` 个轴，如果 ``s`` 也没有指定则使用输入 Tensor 的全部的轴。
+   ``len(s)``  个轴，如果  ``s``  也没有指定则使用输入 Tensor 的全部的轴。
 - **norm** (str，可选) - 傅里叶变换的缩放模式，缩放系数由变换的方向和缩放模式同时决定。取值
   必须是 "forward"，"backward"，"ortho" 之一，默认值为 "backward"。三种缩放模式对
   应的行为如下：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
-  其中 ``n`` 为 ``s`` 中每个元素连乘。
+  其中  ``n``  为  ``s``  中每个元素连乘。
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
diff --git a/docs/api/paddle/fft/ifftshift_cn.rst b/docs/api/paddle/fft/ifftshift_cn.rst
index 482d051d668..49821f49296 100644
--- a/docs/api/paddle/fft/ifftshift_cn.rst
+++ b/docs/api/paddle/fft/ifftshift_cn.rst
@@ -5,7 +5,7 @@ ifftshift
 
 .. py:function:: paddle.fft.ifftshift(x, axes=None, name=None)
 
-``fftshift`` 的逆变换。
+ ``fftshift``  的逆变换。
 
 参数
 :::::::::
@@ -17,7 +17,7 @@ ifftshift
 返回
 :::::::::
 
-Tensor，形状和数据类型与输入 Tensor 相同，沿着 ``axes`` 移动后的输出。
+Tensor，形状和数据类型与输入 Tensor 相同，沿着  ``axes``  移动后的输出。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/fft/ihfft2_cn.rst b/docs/api/paddle/fft/ihfft2_cn.rst
index b9ef16d5329..17bf79a14f4 100644
--- a/docs/api/paddle/fft/ihfft2_cn.rst
+++ b/docs/api/paddle/fft/ihfft2_cn.rst
@@ -16,26 +16,26 @@ ihfft2
 
 - **x** (Tensor) - 输入 Tensor，数据类型为实数。
 - **s** (Sequence[int]，可选) - 傅里叶变换轴的长度（类似一维傅里叶变
-  换中的参数 ``n``）。对于每一个傅里叶变换的轴，如果 ``s`` 中该轴的长度比输入 Tensor 中对应轴
-  的长度小，输入 Tensor 会被截断。如果 ``s`` 中该轴的长度比输入 Tensor 中对应轴的长度大，则
-  输入会被补零。如果 ``s`` 没有指定，则使用输入 Tensor 中由 ``axes`` 指定的各个轴的长度。
+  换中的参数  ``n`` ）。对于每一个傅里叶变换的轴，如果  ``s``  中该轴的长度比输入 Tensor 中对应轴
+  的长度小，输入 Tensor 会被截断。如果  ``s``  中该轴的长度比输入 Tensor 中对应轴的长度大，则
+  输入会被补零。如果  ``s``  没有指定，则使用输入 Tensor 中由  ``axes``  指定的各个轴的长度。
 - **axes** (Sequence[int]，可选) - 傅里叶变换的轴。如果没有指定，默认使用最后两个轴。
 - **norm** (str，可选) - 傅里叶变换的缩放模式，缩放系数由变换的方向和缩放模式同时决定。取值必
   须是 "forward"，"backward"，"ortho" 之一，默认值为 "backward"。三种缩放模式对应的行为
   如下：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
-  其中 ``n`` 为 ``s`` 中每个元素连乘
+  其中  ``n``  为  ``s``  中每个元素连乘
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 :::::::::
 Tensor，数据类型为复数。由输入 Tensor（可能被截断或者补零之后）在指定维度进行傅里叶变换的输出。
-二维傅里叶变换为 ``N`` 维傅里叶变换特例，参考 ``ihfftn``。
+二维傅里叶变换为  ``N``  维傅里叶变换特例，参考  ``ihfftn`` 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/fft/ihfft_cn.rst b/docs/api/paddle/fft/ihfft_cn.rst
index a7c34fe502f..5c79655d9b2 100644
--- a/docs/api/paddle/fft/ihfft_cn.rst
+++ b/docs/api/paddle/fft/ihfft_cn.rst
@@ -12,17 +12,17 @@ ihfft
 :::::::::
 
 - **x** (Tensor) - 输入 Tensor，数据类型为实数。
-- **n** (int，可选) - 傅里叶变换点数。如果 ``n`` 比输入 Tensor 中对应轴
-  的长度小，输入数据会被截断。如果 ``n`` 比输入 Tensor 中对应轴的长度大，则输入会被补零。如果
-  ``n`` 没有被指定，则使用输入 Tensor 中由 ``axis`` 指定的轴的长度。
+- **n** (int，可选) - 傅里叶变换点数。如果  ``n``  比输入 Tensor 中对应轴
+  的长度小，输入数据会被截断。如果  ``n``  比输入 Tensor 中对应轴的长度大，则输入会被补零。如果
+   ``n``  没有被指定，则使用输入 Tensor 中由  ``axis``  指定的轴的长度。
 - **axis** (int，可选) - 傅里叶变换的轴。如果没有指定，默认使用最后一维。
 - **norm** (str，可选) - 傅里叶变换的缩放模式，缩放系数由变换的方向和缩放模式同时决定。取值必
   须是 "forward"，"backward"，"ortho" 之一，默认值为 "backward"。三种缩放模式对应的行为
   如下：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
@@ -30,7 +30,7 @@ ihfft
 返回
 :::::::::
 Tensor，数据类型为复数。由输入 Tensor（可能被截断或者补零之后）在指定
-维度进行傅里叶变换的输出，傅里叶变换轴的输出长度为 ``(n//2)+1``，其余轴长度与输入一致。
+维度进行傅里叶变换的输出，傅里叶变换轴的输出长度为  ``(n//2)+1`` ，其余轴长度与输入一致。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/fft/ihfftn_cn.rst b/docs/api/paddle/fft/ihfftn_cn.rst
index 7cf9ce9281d..d8088df6bce 100644
--- a/docs/api/paddle/fft/ihfftn_cn.rst
+++ b/docs/api/paddle/fft/ihfftn_cn.rst
@@ -16,26 +16,26 @@ N 维厄米特（Hermitian）傅里叶变换的逆变换。
 
 - **x** (Tensor) - 输入数据，数据类型为实数。
 - **s** (Sequence[int]，可选) - 傅里叶变换轴的长度（类似一维傅里叶变
-  换中的参数 ``n``）。对于每一个傅里叶变换的轴，如果 ``s`` 中该轴的长度比输入 Tensor 中对应轴
-  的长度小，输入 Tensor 会被截断。如果 ``s`` 中该轴的长度比输入 Tensor 中对应轴的长度大，则
-  输入会被补零。如果 ``s`` 没有指定，则使用输入 Tensor 中由 ``axes`` 指定的各个轴的长度。
+  换中的参数  ``n`` ）。对于每一个傅里叶变换的轴，如果  ``s``  中该轴的长度比输入 Tensor 中对应轴
+  的长度小，输入 Tensor 会被截断。如果  ``s``  中该轴的长度比输入 Tensor 中对应轴的长度大，则
+  输入会被补零。如果  ``s``  没有指定，则使用输入 Tensor 中由  ``axes``  指定的各个轴的长度。
 - **axes** (Sequence[int]，可选) - 计算快速傅里叶变换的轴。如果没有指定，默认是使用最后
-  ``len(s)`` 个轴，如果 ``s`` 也没有指定则使用输入数据的全部的轴。
+   ``len(s)``  个轴，如果  ``s``  也没有指定则使用输入数据的全部的轴。
 - **norm** (str，可选) - 指定傅里叶变换的缩放模式，缩放系数由变换的方向和模式同时决定。取值必
   须是 "forward"，"backward"，"ortho"之一，默认值为 "backward"。三种缩放模式对应的行为如下：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
-  其中 ``n`` 为 ``s`` 中每个元素连乘
+  其中  ``n``  为  ``s``  中每个元素连乘
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 :::::::::
 Tensor，复数类型，输入数据（可能被截断或者补零之后）在指定维度进行傅里叶变换的输出。最后一个傅立
-叶变换轴的长度为 ``s[-1]//2+1``，其余变换轴的长度与 ``s`` 相同。
+叶变换轴的长度为  ``s[-1]//2+1`` ，其余变换轴的长度与  ``s``  相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/fft/irfft2_cn.rst b/docs/api/paddle/fft/irfft2_cn.rst
index 81d054ec34d..d20811d4ed5 100644
--- a/docs/api/paddle/fft/irfft2_cn.rst
+++ b/docs/api/paddle/fft/irfft2_cn.rst
@@ -13,24 +13,24 @@ irfft2
 
 - **x** (Tensor) - 输入数据，其数据类型为复数。
 - **s** (Sequence[int]，可选) - 输出 Tensor 在傅里叶变换轴的长度（类似一维傅里叶变换中
-  的参数 ``n``）。
+  的参数  ``n`` ）。
 - **axes** (Sequence[int]，可选) - 傅里叶变换的轴。如果没有指定，默认使用最后两个轴。
 - **norm** (str，可选) - 傅里叶变换的缩放模式，缩放系数由变换的方向和缩放模式同时决定。取
   值必须是 "forward"，"backward"，"ortho" 之一，默认值为 "backward"。三种缩放模式对应
   的行为如下：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
-  其中 ``n`` 为 ``s`` 中每个元素连乘。
+  其中  ``n``  为  ``s``  中每个元素连乘。
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 :::::::::
 Tensor，数据类型为实数。由输入 Tensor（可能被截断或者补零之后）在指定维度进行傅里叶变换的输出。
-二维厄米特傅里叶变换为 N 维厄米特傅里（``irfftn``）变换的特例。
+二维厄米特傅里叶变换为 N 维厄米特傅里（ ``irfftn`` ）变换的特例。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/fft/irfft_cn.rst b/docs/api/paddle/fft/irfft_cn.rst
index d4193356421..8d8652b53a7 100644
--- a/docs/api/paddle/fft/irfft_cn.rst
+++ b/docs/api/paddle/fft/irfft_cn.rst
@@ -14,17 +14,17 @@ irfft
 
 - **x** (Tensor) - 输入数据，其数据类型为复数。
 - **n** (int，可选) - 输出 Tensor 在傅里叶变换轴的长度。输入 Tensor 在该轴的长度必须为
-  ``n//2+1``，如果输入 Tensor 的长度大于 ``n//2+1``，输入 Tensor 会被截断。如果输入
-  Tensor 的长度小于 ``n//2+1``，则输入 Tensor 会被补零。如果 ``n``
-  没有被指定，则取 ``2*(m-1)``，其中，``m`` 是输入 Tensor 在 ``axis`` 维的长度。
+   ``n//2+1`` ，如果输入 Tensor 的长度大于  ``n//2+1`` ，输入 Tensor 会被截断。如果输入
+  Tensor 的长度小于  ``n//2+1`` ，则输入 Tensor 会被补零。如果  ``n`` 
+  没有被指定，则取  ``2*(m-1)`` ，其中， ``m``  是输入 Tensor 在  ``axis``  维的长度。
 - **axis** (int，可选) - 傅里叶变换的轴。如果没有指定，默认是使用最后一维。
 - **norm** (str，可选) - 傅里叶变换的缩放模式，缩放系数由变换的方向和缩放模式同时决定。取
   值必须是 "forward", "backward", "ortho" 之一，默认值为 "backward"。三种缩放模式对
   应的行为如下：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
@@ -32,8 +32,8 @@ irfft
 返回
 :::::::::
 Tensor，数据类型为实数。由输入 Tensor（可能被截断或者补零之后）在指定维度进行傅里叶变换的输
-出。如果指定 n，则输出 Tensor 在傅立叶变换轴的长度为 n，否则为 ``2*(m-1)``，其中``m``
-是输入 Tensor 在 ``axis`` 维的长度。
+出。如果指定 n，则输出 Tensor 在傅立叶变换轴的长度为 n，否则为  ``2*(m-1)`` ，其中 ``m`` 
+是输入 Tensor 在  ``axis``  维的长度。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/fft/irfftn_cn.rst b/docs/api/paddle/fft/irfftn_cn.rst
index 0774e649a3f..d0190788aeb 100644
--- a/docs/api/paddle/fft/irfftn_cn.rst
+++ b/docs/api/paddle/fft/irfftn_cn.rst
@@ -7,7 +7,7 @@ irfftn
 
 通过快速傅里叶变换(FFT)算法计算 N 维实数傅里叶变换 （rfftn）的逆变换。
 
-该函数通过快速傅立叶变换（FFT）计算 M-D 矩阵中任意轴上实输入的 N-D 离散傅立叶变换的逆。即，在计算精度内 ``irfftn(rfftn(x), x.shape) == x`` 成立。（ ``x.shape`` 的信息是必要的，其存在原因与 `irfft` 中的 ``len(x)`` 相同）。
+该函数通过快速傅立叶变换（FFT）计算 M-D 矩阵中任意轴上实输入的 N-D 离散傅立叶变换的逆。即，在计算精度内  ``irfftn(rfftn(x), x.shape) == x``  成立。（  ``x.shape``  的信息是必要的，其存在原因与 `irfft` 中的  ``len(x)``  相同）。
 
 此函数输入的排序方式应与 rfftn 返回的方式相同。
 
@@ -16,34 +16,34 @@ irfftn
 
 - **x** (Tensor) - 输入数据，其数据类型为复数。
 - **s** (Sequence[int]，可选) - 输出 Tensor 在每一个傅里叶变换轴上的长度（类似一维傅里
-  叶变换中的参数 ``n``）。
+  叶变换中的参数  ``n`` ）。
 
-  - 对于傅里叶变换的最后一个轴，输入长度要求是 ``s[-1]//2+1``，如果输入 Tensor 的长度大于``s[-1]//2+1``，输入 Tensor 会被截断。如果输入 Tensor 的长度小于 ``s[-1]//2+1``，则输入 Tensor 会被补零；
-  - 对于傅里变换其他每一个轴 ``i``，如果输入 Tensor 的长度大于 ``s[i]``，输入 Tensor 会被截断。如果输入 Tensor 的长度小于 ``s[i]``，则输入 Tensor 会被补零；
-  - 如果未指定 `s`，则 ``s`` 在最后一个傅里叶变换轴取值为 ``2*(m-1)``，其中 ``m`` 是输入 Tensor 在最后一个傅里叶变换轴的长度，其余轴为输入 Tensor 在该轴的长度。
+  - 对于傅里叶变换的最后一个轴，输入长度要求是  ``s[-1]//2+1`` ，如果输入 Tensor 的长度大于 ``s[-1]//2+1`` ，输入 Tensor 会被截断。如果输入 Tensor 的长度小于  ``s[-1]//2+1`` ，则输入 Tensor 会被补零；
+  - 对于傅里变换其他每一个轴  ``i`` ，如果输入 Tensor 的长度大于  ``s[i]`` ，输入 Tensor 会被截断。如果输入 Tensor 的长度小于  ``s[i]`` ，则输入 Tensor 会被补零；
+  - 如果未指定 `s`，则  ``s``  在最后一个傅里叶变换轴取值为  ``2*(m-1)`` ，其中  ``m``  是输入 Tensor 在最后一个傅里叶变换轴的长度，其余轴为输入 Tensor 在该轴的长度。
 
 - **axes** (Sequence[int]，可选) - 计算快速傅里叶变换的轴。如果没有指定，默认是使用最后
-  ``len(s)`` 个轴，如果 ``s`` 也没有指定则使用输入数据的全部的轴。
+   ``len(s)``  个轴，如果  ``s``  也没有指定则使用输入数据的全部的轴。
 - **norm** (str，可选) - 指定傅里叶变换的缩放模式，缩放系数由变换的方向和模式同时决定。取
   值必须是 "forward"，"backward"，"ortho"之一，默认值为 "backward"。三种缩放模式对应的
   行为如下：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
-  其中 ``n`` 为 ``s`` 中每个元素连乘。
+  其中  ``n``  为  ``s``  中每个元素连乘。
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 :::::::::
 Tensor，数据类型为实数。输入数据（可能被截断或者补零之后）在指定维度进行傅里叶变换的输出。
-如果指定 ``s``，则输出 Tensor 在傅里叶变换维度的长度为 ``s``。否则输出 Tensor 在最后一个
-傅里叶变换轴的长度为 ``2*(m-1)``，其中 ``m`` 是输入 Tensor 在最后一个傅里叶变换轴的长
+如果指定  ``s`` ，则输出 Tensor 在傅里叶变换维度的长度为  ``s`` 。否则输出 Tensor 在最后一个
+傅里叶变换轴的长度为  ``2*(m-1)`` ，其中  ``m``  是输入 Tensor 在最后一个傅里叶变换轴的长
 度，其余轴为输入 Tensor 在对应轴的长度。
 
-如果未指定 ``s``，则输出在最后一个傅里叶变换轴上的长度一定为偶数。
+如果未指定  ``s`` ，则输出在最后一个傅里叶变换轴上的长度一定为偶数。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/fft/rfft2_cn.rst b/docs/api/paddle/fft/rfft2_cn.rst
index c43dac7c23e..9306b945de4 100644
--- a/docs/api/paddle/fft/rfft2_cn.rst
+++ b/docs/api/paddle/fft/rfft2_cn.rst
@@ -16,17 +16,17 @@ rfft2
 
 - **x** (Tensor) - 输入 Tensor，数据类型为实数。
 - **s** (Sequence[int]，可选) - 傅里叶变换轴的长度（类似一维傅里叶变
-  换中的参数 ``n``）。对于每一个傅里叶变换的轴，如果 ``s`` 中该轴的长度比输入 Tensor 中对应轴
-  的长度小，输入 Tensor 会被截断。如果 ``s`` 中该轴的长度比输入 Tensor 中对应轴的长度大，则
-  输入会被补零。如果 ``s`` 没有指定，则使用输入 Tensor 中由 ``axes`` 指定的各个轴的长度。
+  换中的参数  ``n`` ）。对于每一个傅里叶变换的轴，如果  ``s``  中该轴的长度比输入 Tensor 中对应轴
+  的长度小，输入 Tensor 会被截断。如果  ``s``  中该轴的长度比输入 Tensor 中对应轴的长度大，则
+  输入会被补零。如果  ``s``  没有指定，则使用输入 Tensor 中由  ``axes``  指定的各个轴的长度。
 - **axes** (Sequence[int]，可选) - 傅里叶变换的轴。如果没有指定，默认使用最后两个轴。
 - **norm** (str，可选) - 傅里叶变换的缩放模式，缩放系数由变换的方向和缩放模式同时决定。取值必
   须是 "forward"，"backward"，"ortho" 之一，默认值为 "backward"。三种缩放模式对应的行为
-  如下，其中 ``n`` 为 ``s`` 中每个元素连乘：
+  如下，其中  ``n``  为  ``s``  中每个元素连乘：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
@@ -34,7 +34,7 @@ rfft2
 返回
 :::::::::
 Tensor，数据类型为复数。由输入 Tensor（可能被截断或者补零之后）在指定维度进行傅里叶变换的输出。
-二维傅里叶变换为 ``N`` 维傅里叶变换特例，参考 ``rfftn``。
+二维傅里叶变换为  ``N``  维傅里叶变换特例，参考  ``rfftn`` 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/fft/rfft_cn.rst b/docs/api/paddle/fft/rfft_cn.rst
index 50605418481..2d6f994aa52 100644
--- a/docs/api/paddle/fft/rfft_cn.rst
+++ b/docs/api/paddle/fft/rfft_cn.rst
@@ -7,22 +7,22 @@ rfft
 
 通过快速傅里叶变换(FFT)算法计算一维实数傅里叶变换。
 
-当输入是实数时，输出是厄米特对称的。由于该函数不计算负频率项，因此输出的变换轴长度为 ``n//2 + 1`` 。
+当输入是实数时，输出是厄米特对称的。由于该函数不计算负频率项，因此输出的变换轴长度为  ``n//2 + 1``  。
 
 
 参数
 :::::::::
 
 - **x** (Tensor) - 输入 Tensor，数据类型为实数。
-- **n** (int，可选) - 傅里叶变换点数。如果 ``n`` 比输入 Tensor 中对应轴
-  的长度小，输入数据会被截断。如果 ``n`` 比输入 Tensor 中对应轴的长度大，则输入会被补零。如果
-  ``n`` 没有被指定，则使用输入 Tensor 中由 ``axis`` 指定的轴的长度。
+- **n** (int，可选) - 傅里叶变换点数。如果  ``n``  比输入 Tensor 中对应轴
+  的长度小，输入数据会被截断。如果  ``n``  比输入 Tensor 中对应轴的长度大，则输入会被补零。如果
+   ``n``  没有被指定，则使用输入 Tensor 中由  ``axis``  指定的轴的长度。
 - **axis** (int，可选) - 傅里叶变换的轴。如果没有指定，默认使用最后一维。
 - **norm** (str，可选) - 傅里叶变换的缩放模式，缩放系数由变换的方向和缩放模式同时决定。取值必须是 "forward"，"backward"，"ortho" 之一，默认值为 "backward"。三种缩放模式对应的行为如下：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/fft/rfftfreq_cn.rst b/docs/api/paddle/fft/rfftfreq_cn.rst
index 2371d795489..76a52c82fa3 100644
--- a/docs/api/paddle/fft/rfftfreq_cn.rst
+++ b/docs/api/paddle/fft/rfftfreq_cn.rst
@@ -6,7 +6,7 @@ rfftfreq
 .. py:function:: paddle.fft.rfftfreq(n, d=1.0, dtype=None, name=None)
 
 返回离散傅里叶变换的频率窗口(frequency bins)中心，以 "循环/采样间隔" 为单位。例如，采样间
-隔以秒为单位，则频谱的单位是 "循环/秒"。用于 ``rfft`` 和 ``irfft``。
+隔以秒为单位，则频谱的单位是 "循环/秒"。用于  ``rfft``  和  ``irfft`` 。
 
 对于窗口长度 n 和采样间隔 d，输出的频率序列 f 排布如下：
 
@@ -21,14 +21,14 @@ rfftfreq
 - **n** (int) - 窗长度（傅里叶变换点数）。
 - **d** (float，可选) - 采样间隔，采样率的倒数，默认值为 1。
 - **dtype** (str|paddle.dtype|np.dtype，可选) - 返回 Tensor 的数据类型，默认为
-  ``paddle.get_default_dtype()`` 返回的类型。
+   ``paddle.get_default_dtype()``  返回的类型。
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 :::::::::
 
-Tensor，形状为 ``[n // 2 + 1]``，数据类型为 ``dtype`` 指定的数据类型，包含频率窗口中心序列。
+Tensor，形状为  ``[n // 2 + 1]`` ，数据类型为  ``dtype``  指定的数据类型，包含频率窗口中心序列。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/fft/rfftn_cn.rst b/docs/api/paddle/fft/rfftn_cn.rst
index 428837743b9..591a4d9b3f9 100644
--- a/docs/api/paddle/fft/rfftn_cn.rst
+++ b/docs/api/paddle/fft/rfftn_cn.rst
@@ -16,26 +16,26 @@ N 维实数傅里叶变换。
 
 - **x** (Tensor) - 输入数据，数据类型为实数。
 - **s** (Sequence[int]，可选) - 傅里叶变换轴的长度（类似一维傅里叶变
-  换中的参数 ``n``）。对于每一个傅里叶变换的轴，如果 ``s`` 中该轴的长度比输入 Tensor 中对应轴
-  的长度小，输入 Tensor 会被截断。如果 ``s`` 中该轴的长度比输入 Tensor 中对应轴的长度大，则
-  输入会被补零。如果 ``s`` 没有指定，则使用输入 Tensor 中由 ``axes`` 指定的各个轴的长度。
+  换中的参数  ``n`` ）。对于每一个傅里叶变换的轴，如果  ``s``  中该轴的长度比输入 Tensor 中对应轴
+  的长度小，输入 Tensor 会被截断。如果  ``s``  中该轴的长度比输入 Tensor 中对应轴的长度大，则
+  输入会被补零。如果  ``s``  没有指定，则使用输入 Tensor 中由  ``axes``  指定的各个轴的长度。
 - **axes** (Sequence[int]，可选) - 计算快速傅里叶变换的轴。如果没有指定，默认是使用最后
-  ``len(s)`` 个轴，如果 ``s`` 也没有指定则使用输入数据的全部的轴。
+   ``len(s)``  个轴，如果  ``s``  也没有指定则使用输入数据的全部的轴。
 - **norm** (str，可选) - 指定傅里叶变换的缩放模式，缩放系数由变换的方向和模式同时决定。取值必
   须是 "forward"，"backward"，"ortho"之一，默认值为 "backward"。三种缩放模式对应的行为如下：
 
-  - "backward"：正向和逆向变换的缩放系数分别为 ``1`` 和 ``1/n``；
-  - "forward"：正向和逆向变换的缩放系数分别为 ``1/n`` 和 ``1``；
-  - "ortho"：正向和逆向变换的缩放系数均为 ``1/sqrt(n)``；
+  - "backward"：正向和逆向变换的缩放系数分别为  ``1``  和  ``1/n`` ；
+  - "forward"：正向和逆向变换的缩放系数分别为  ``1/n``  和  ``1`` ；
+  - "ortho"：正向和逆向变换的缩放系数均为  ``1/sqrt(n)`` ；
 
-  其中 ``n`` 为 ``s`` 中每个元素连乘。
+  其中  ``n``  为  ``s``  中每个元素连乘。
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 :::::::::
 Tensor，复数类型，输入数据（可能被截断或者补零之后）在指定维度进行傅里叶变换的输出。最后一个傅立
-叶变换轴的长度为 ``s[-1]//2+1``，其余变换轴的长度与 ``s`` 相同。
+叶变换轴的长度为  ``s[-1]//2+1`` ，其余变换轴的长度与  ``s``  相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/finfo_cn.rst b/docs/api/paddle/finfo_cn.rst
index 58bc33d5b1c..fc9826fb796 100644
--- a/docs/api/paddle/finfo_cn.rst
+++ b/docs/api/paddle/finfo_cn.rst
@@ -7,21 +7,21 @@ finfo
 
 
 
-返回一个 ``finfo`` 对象，该对象包含了输入 ``dtype`` 的各种相关的数值信息。其中输入 ``dtype`` 只能是整数类型的 ``paddle.dtype`` 。
+返回一个  ``finfo``  对象，该对象包含了输入  ``dtype``  的各种相关的数值信息。其中输入  ``dtype``  只能是整数类型的  ``paddle.dtype``  。
 
 其功能类似 `numpy.finfo <https://numpy.org/doc/stable/reference/generated/numpy.finfo.html#numpy-finfo>`_ 。
 
 .. note::
-   别名支持: 参数名 ``type`` 可替代 ``dtype``，如 ``type=paddle.float32`` 等价于 ``dtype=paddle.float32``。
+   别名支持: 参数名  ``type``  可替代  ``dtype`` ，如  ``type=paddle.float32``  等价于  ``dtype=paddle.float32`` 。
 
 
 参数
 :::::::::
-    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输入的数据类型，可以是：paddle.float16、 paddle.float32、 paddle.float64、 paddle.bfloat16、 paddle.complex64、 paddle.complex128 或这些类型的字符串形式。别名： ``type``。
+    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输入的数据类型，可以是：paddle.float16、 paddle.float32、 paddle.float64、 paddle.bfloat16、 paddle.complex64、 paddle.complex128 或这些类型的字符串形式。别名：  ``type`` 。
 
 返回
 :::::::::
-一个 ``finfo`` 对象，其中包含 8 个属性，如下所示：
+一个  ``finfo``  对象，其中包含 8 个属性，如下所示：
 
     - **min** (double) - 该数据类型所能表示的最小的数。
     - **max** (double) - 该数据类型所能表示的最大的数。
diff --git a/docs/api/paddle/flatten_cn.rst b/docs/api/paddle/flatten_cn.rst
index b20f7e53f16..41a988cd634 100644
--- a/docs/api/paddle/flatten_cn.rst
+++ b/docs/api/paddle/flatten_cn.rst
@@ -11,7 +11,7 @@ flatten
 根据给定的 start_axis 和 stop_axis 将连续的维度展平。
 
 .. note::
-  在动态图模式下，输出 Tensor 将与输入 Tensor 共享数据，并且没有 Tensor 数据拷贝的过程。如果不希望输入与输出共享数据，请使用 ``Tensor.clone``，例如 ``flatten_clone_x = x.flatten().clone()`` 。
+  在动态图模式下，输出 Tensor 将与输入 Tensor 共享数据，并且没有 Tensor 数据拷贝的过程。如果不希望输入与输出共享数据，请使用  ``Tensor.clone`` ，例如  ``flatten_clone_x = x.flatten().clone()``  。
 
 例如：
 
@@ -48,23 +48,23 @@ flatten
    :width: 700
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x`` 、 ``start_dim`` 可替代 ``start_axis`` 和 ``ehd_dim`` 可替代 ``stop_axis``。
-    如 ``input=tensor_x`` 等价于 ``x=tensor_x``， ``start_dim=1`` 等价于 ``start_axis=1`` 和 ``ehd_dim=1`` 等价于 ``stop_axis=1``。
+    别名支持: 参数名  ``input``  可替代  ``x``  、  ``start_dim``  可替代  ``start_axis``  和  ``ehd_dim``  可替代  ``stop_axis`` 。
+    如  ``input=tensor_x``  等价于  ``x=tensor_x`` ，  ``start_dim=1``  等价于  ``start_axis=1``  和  ``ehd_dim=1``  等价于  ``stop_axis=1`` 。
 
 参数
 ::::::::::::
 
   - **x** (Tensor) - 多维 Tensor，数据类型可以为 float16、float32、float64、int8、int32 或 int64。
-    别名： ``input``
+    别名：  ``input`` 
   - **start_axis** (int) - flatten 展开的起始维度。
-    别名： ``start_dim``
+    别名：  ``start_dim`` 
   - **stop_axis** (int) - flatten 展开的结束维度。
-    别名： ``end_dim``
+    别名：  ``end_dim`` 
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
- ``Tensor``，一个 Tensor，它包含输入 Tensor 的数据，但维度发生变化。输入将按照给定的 start_axis 和 stop_axis 展开。数据类型与输入 x 相同。
+  ``Tensor`` ，一个 Tensor，它包含输入 Tensor 的数据，但维度发生变化。输入将按照给定的 start_axis 和 stop_axis 展开。数据类型与输入 x 相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/flip_cn.rst b/docs/api/paddle/flip_cn.rst
index 98fb8b0e058..54f301d2e17 100644
--- a/docs/api/paddle/flip_cn.rst
+++ b/docs/api/paddle/flip_cn.rst
@@ -20,7 +20,7 @@ flip
 ::::::::::::
 
     - **x** (Tensor) - 输入的 Tensor。维度为多维，数据类型为 bool、int32、int64、float32 或 float64。
-    - **axis** (list|tuple|int) - 需要翻转的轴。当 axis 是 int 型时，且 axis<0，实际的计算维度为 ndim(x) + axis；axis 是 list 或 tuple 时，``axis[i] < 0`` 时，实际的计算维度为 ndim(x) + axis[i]，其中 i 为 axis 的索引。
+    - **axis** (list|tuple|int) - 需要翻转的轴。当 axis 是 int 型时，且 axis<0，实际的计算维度为 ndim(x) + axis；axis 是 list 或 tuple 时， ``axis[i] < 0``  时，实际的计算维度为 ndim(x) + axis[i]，其中 i 为 axis 的索引。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/floor_cn.rst b/docs/api/paddle/floor_cn.rst
index c80ae7066d4..80459706736 100644
--- a/docs/api/paddle/floor_cn.rst
+++ b/docs/api/paddle/floor_cn.rst
@@ -16,17 +16,17 @@ floor
 参数
 ::::::::::::
 
-    - **x** - 输入为多维 Tensor。数据类型支持 float32, float64, float16, bfloat16, uint8, int8, int16, int32, int64。别名 ``input``。
+    - **x** - 输入为多维 Tensor。数据类型支持 float32, float64, float16, bfloat16, uint8, int8, int16, int32, int64。别名  ``input`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 返回
 ::::::::::::
-输出为 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出为 Tensor，与  ``x``  维度相同、数据类型相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/floor_divide_cn.rst b/docs/api/paddle/floor_divide_cn.rst
index 409b7bab405..58facd41569 100644
--- a/docs/api/paddle/floor_divide_cn.rst
+++ b/docs/api/paddle/floor_divide_cn.rst
@@ -5,10 +5,10 @@ floor_divide
 
 .. py:function:: paddle.floor_divide(x, y, name=None)
 
-逐元素整除算子，将输入 ``x`` 与输入 ``y`` 逐元素整除（商被朝 -inf 方向舍入到最接近的整数值），并将各个位置的输出元素保存到返回结果中。
+逐元素整除算子，将输入  ``x``  与输入  ``y``  逐元素整除（商被朝 -inf 方向舍入到最接近的整数值），并将各个位置的输出元素保存到返回结果中。
 
 .. note::
-    输入 ``x`` 与输入 ``y`` 必须和广播为相同形状，关于广播规则，请参见 `Tensor 介绍`_ .
+    输入  ``x``  与输入  ``y``  必须和广播为相同形状，关于广播规则，请参见 `Tensor 介绍`_ .
 
     .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
@@ -21,22 +21,22 @@ floor_divide
 - :math:`Y`：多维 Tensor。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x`` 和 ``other`` 可替代 ``y``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``， ``other=tensor_y`` 等价于 ``y=tensor_y``。
+    别名支持: 参数名  ``input``  可替代  ``x``  和  ``other``  可替代  ``y`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` ，  ``other=tensor_y``  等价于  ``y=tensor_y`` 。
 
 
 参数
 :::::::::
         - **x** (Tensor) - 多维 Tensor。数据类型为 int8 int16 int32 int64 float32 float64 float16 或 bfloat16。
-          别名： ``input``
+          别名：  ``input`` 
         - **y** (Tensor) - 多维 Tensor。数据类型为 int8 int16 int32 int64 float32 float64 float16 或 bfloat16。
-          别名： ``other``
+          别名：  ``other`` 
         - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
         - **out** （Tensor，可选） - 指定输出结果的 `Tensor`，默认值为 None。
 
 
 返回
 :::::::::
-多维 Tensor，数据类型与 ``x`` 相同，维度为广播后的形状。
+多维 Tensor，数据类型与  ``x``  相同，维度为广播后的形状。
 
 
 代码示例
diff --git a/docs/api/paddle/flops_cn.rst b/docs/api/paddle/flops_cn.rst
index 12e93b4c7ff..41dd768e408 100644
--- a/docs/api/paddle/flops_cn.rst
+++ b/docs/api/paddle/flops_cn.rst
@@ -11,7 +11,7 @@ flops
 :::::::::
   - **net** (paddle.nn.Layer|paddle.static.Program) - 网络实例，必须是 paddle.nn.Layer 的子类或者静态图下的 paddle.static.Program。
   - **input_size** (list) - 输入 Tensor 的大小。注意：仅支持 batch_size=1。
-  - **custom_ops** (dict，可选) - 字典，用于实现对自定义网络层的统计。字典的 key 为自定义网络层的 class，value 为统计网络层 flops 的函数，函数实现方法见示例代码。此参数仅在 ``net`` 为 paddle.nn.Layer 时生效。默认值：None。
+  - **custom_ops** (dict，可选) - 字典，用于实现对自定义网络层的统计。字典的 key 为自定义网络层的 class，value 为统计网络层 flops 的函数，函数实现方法见示例代码。此参数仅在  ``net``  为 paddle.nn.Layer 时生效。默认值：None。
   - **print_detail** (bool，可选) - bool 值，用于控制是否打印每个网络层的细节。默认值：False。
 
 返回
diff --git a/docs/api/paddle/fmax_cn.rst b/docs/api/paddle/fmax_cn.rst
index 4d288488214..e7978c7c41a 100644
--- a/docs/api/paddle/fmax_cn.rst
+++ b/docs/api/paddle/fmax_cn.rst
@@ -14,19 +14,19 @@ fmax
         out = fmax(x, y)
 
 .. note::
-   ``paddle.fmax`` 遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
+    ``paddle.fmax``  遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
 
    .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
 参数
 :::::::::
-   - **x** （Tensor）- 输入的 Tensor。数据类型为 ``bfloat16`` 、 ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 或  ``int64`` 。
-   - **y** （Tensor）- 输入的 Tensor。数据类型为 ``bfloat16`` 、 ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 或  ``int64`` 。
+   - **x** （Tensor）- 输入的 Tensor。数据类型为  ``bfloat16``  、  ``float16``  、  ``float32``  、  ``float64``  、  ``int32``  或   ``int64``  。
+   - **y** （Tensor）- 输入的 Tensor。数据类型为  ``bfloat16``  、  ``float16``  、  ``float32``  、  ``float64``  、  ``int32``  或   ``int64``  。
    - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-   ``Tensor``，存储运算后的结果。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
+    ``Tensor`` ，存储运算后的结果。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
 
 
 代码示例
diff --git a/docs/api/paddle/fmin_cn.rst b/docs/api/paddle/fmin_cn.rst
index 40db0a1a1b4..2a928f0099f 100644
--- a/docs/api/paddle/fmin_cn.rst
+++ b/docs/api/paddle/fmin_cn.rst
@@ -14,19 +14,19 @@ fmin
         out = fmin(x, y)
 
 .. note::
-   ``paddle.fmin`` 遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
+    ``paddle.fmin``  遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
 
    .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
 参数
 :::::::::
-   - **x** （Tensor）- 输入的 Tensor。数据类型为 ``bfloat16`` 、 ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 或  ``int64`` 。
-   - **y** （Tensor）- 输入的 Tensor。数据类型为 ``bfloat16`` 、 ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 或  ``int64`` 。
+   - **x** （Tensor）- 输入的 Tensor。数据类型为  ``bfloat16``  、  ``float16``  、  ``float32``  、  ``float64``  、  ``int32``  或   ``int64``  。
+   - **y** （Tensor）- 输入的 Tensor。数据类型为  ``bfloat16``  、  ``float16``  、  ``float32``  、  ``float64``  、  ``int32``  或   ``int64``  。
    - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-   ``Tensor``，存储运算后的结果。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
+    ``Tensor`` ，存储运算后的结果。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
 
 
 代码示例
diff --git a/docs/api/paddle/from_dlpack_cn.rst b/docs/api/paddle/from_dlpack_cn.rst
index dc675018b70..43addc780ef 100644
--- a/docs/api/paddle/from_dlpack_cn.rst
+++ b/docs/api/paddle/from_dlpack_cn.rst
@@ -8,17 +8,17 @@ from_dlpack
 将 DLPack 格式的 Tensor 解码为 Paddle Tensor，DLPACK 是一种通用稳定的内存数据结构，可用于不同深度学习框架之间的 Tensor 共享。
 
 .. note::
-    一个 dlpack 只能被 ``from_dlpack`` 解码一次。
+    一个 dlpack 只能被  ``from_dlpack``  解码一次。
 
 参数
 :::::::::
-  - **dlpack** (SupportDLPack | PyCapsule) - 一个实现了 ``__dlpack__`` 与 ``__dlpack_device__`` 方法的对象，或者是一个带有 dltensor 的 ``PyCapsule`` 对象。
+  - **dlpack** (SupportDLPack | PyCapsule) - 一个实现了  ``__dlpack__``  与  ``__dlpack_device__``  方法的对象，或者是一个带有 dltensor 的  ``PyCapsule``  对象。
   - **device** (PlaceLike, 可选) - 返回的 Tensor 所在的设备。如果不指定，返回的 Tensor 将与输入的 `dlpack` 位于同一设备上。
-  - **copy** (bool, 可选) - 是否复制输入的内容。如果为 True，则输出的 Tensor 总是被复制。如果为 False，则输出的 Tensor 永远不会被复制，如果需要复制则会引发 ``BufferError`` 异常。如果为 None，则在可能的情况下重用现有的内存缓冲区，否则进行复制。默认值为 None。
+  - **copy** (bool, 可选) - 是否复制输入的内容。如果为 True，则输出的 Tensor 总是被复制。如果为 False，则输出的 Tensor 永远不会被复制，如果需要复制则会引发  ``BufferError``  异常。如果为 None，则在可能的情况下重用现有的内存缓冲区，否则进行复制。默认值为 None。
 
 返回
 :::::::::
-  - **out** (Tensor) - 从 `dlpack` 中解码得到的 Paddle Tensor，支持的数据类型为： bool，float16，float32，float64，uint8，int8，int16，int32，int64，complex64，complex128，支持的设备类型为： ``CPU``， ``CUDAPlace``， ``CUDAPinnedPlace``。
+  - **out** (Tensor) - 从 `dlpack` 中解码得到的 Paddle Tensor，支持的数据类型为： bool，float16，float32，float64，uint8，int8，int16，int32，int64，complex64，complex128，支持的设备类型为：  ``CPU`` ，  ``CUDAPlace`` ，  ``CUDAPinnedPlace`` 。
 
 代码示例 1
 :::::::::
diff --git a/docs/api/paddle/full_cn.rst b/docs/api/paddle/full_cn.rst
index ab19540f03e..6f59f65761e 100644
--- a/docs/api/paddle/full_cn.rst
+++ b/docs/api/paddle/full_cn.rst
@@ -7,19 +7,19 @@ full
 
 
 
-创建形状大小为 ``shape`` 并且数据类型为 ``dtype``  的 Tensor，其中元素值均为 ``fill_value`` 。
+创建形状大小为  ``shape``  并且数据类型为  ``dtype``   的 Tensor，其中元素值均为  ``fill_value``  。
 
 .. note::
-    别名支持: 参数名 ``size`` 可替代 ``shape``，如 ``full(size=[2, 3], …)`` 等价于 ``full(shape=[2, 3], …)`` 。
+    别名支持: 参数名  ``size``  可替代  ``shape`` ，如  ``full(size=[2, 3], …)``  等价于  ``full(shape=[2, 3], …)``  。
 
 参数
 ::::::::::::
 
     - **shape** (list|tuple|Tensor|*shape) - 生成的 Tensor 的形状。数据类型为 int32 或 int64。
-      如果 ``shape`` 是 list、tuple，则其中的元素可以是 int，或者是形状为 [] 且数据类型为 int32、int64 的 0-D Tensor。
-      如果 ``shape`` 是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor，表示一个列表。
-      如果 ``shape`` 是 \*shape，则可以直接以可变参数的形式传入多个整数（例如 ``randn(2, 3)``）。
-      该参数的别名为 ``size``。
+      如果  ``shape``  是 list、tuple，则其中的元素可以是 int，或者是形状为 [] 且数据类型为 int32、int64 的 0-D Tensor。
+      如果  ``shape``  是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor，表示一个列表。
+      如果  ``shape``  是 \*shape，则可以直接以可变参数的形式传入多个整数（例如  ``randn(2, 3)`` ）。
+      该参数的别名为  ``size`` 。
     - **fill_value** (bool|float|int|Tensor) - 用于初始化输出 Tensor 的常量数据的值。如果 fill_value 是一个 Tensor ，它应该是一个表示标量的 0-D Tensor。注意：该参数不可超过输出变量数据类型的表示范围。
     - **dtype** （str|paddle.dtype|np.dtype，可选）- 输出变量的数据类型，可以是 float16、float32、float64、int32、int64。如果 dytpe 为 None，则创建的 Tensor 的数据类型为 float32。默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
@@ -27,7 +27,7 @@ full
 关键字参数
 ::::::::::::
     - **out** (Tensor，可选) - 用于存储结果的 Tensor。若指定，将直接写入该 Tensor，默认值为 None。
-    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。默认值为 None，表示使用当前全局设备（可通过 ``paddle.device.set_device`` 设置）。
+    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。默认值为 None，表示使用当前全局设备（可通过  ``paddle.device.set_device``  设置）。
     - **requires_grad** (bool，可选) - 是否需要为返回的 Tensor 记录梯度信息。默认值为 False。
     - **pin_memory** (bool，可选) - 若为 True，返回的 CPU Tensor 将分配在锁页内存中。仅对 CPU Tensor 生效。默认值为 False。
 
diff --git a/docs/api/paddle/full_like_cn.rst b/docs/api/paddle/full_like_cn.rst
index 25ca7e14c93..f30e240513d 100644
--- a/docs/api/paddle/full_like_cn.rst
+++ b/docs/api/paddle/full_like_cn.rst
@@ -6,29 +6,29 @@ full_like
 .. py:function:: paddle.full_like(x, fill_value, dtype=None, name=None, *, device=None, requires_grad=False, pin_memory=False)
 
 
-创建一个和 ``x`` 具有相同的形状并且数据类型为 ``dtype`` 的 Tensor，其中元素值均为 ``fill_value``，当 ``dtype`` 为 None 的时候，Tensor 数据类型和输入 ``x`` 相同。
+创建一个和  ``x``  具有相同的形状并且数据类型为  ``dtype``  的 Tensor，其中元素值均为  ``fill_value`` ，当  ``dtype``  为 None 的时候，Tensor 数据类型和输入  ``x``  相同。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` 。
 
 参数
 ::::::::::::
 
     - **x** (Tensor) – 输入 Tensor，输出 Tensor 和 x 具有相同的形状，x 的数据类型可以是 bool、float16、float32、float64、int32、int64。
-      别名： ``input``
+      别名：  ``input`` 
     - **fill_value** (bool|float|int) - 用于初始化输出 Tensor 的常量数据的值。注意：该参数不可超过输出变量数据类型的表示范围。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出变量的数据类型。若参数为 None，则输出变量的数据类型和输入变量相同，默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 ::::::::::::
-    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。若为 None，则与 ``x`` 保持一致。
+    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。若为 None，则与  ``x``  保持一致。
     - **requires_grad** (bool，可选) - 是否需要为返回的 Tensor 记录梯度信息。默认值为 False。
     - **pin_memory** (bool，可选) - 若为 True，返回的 CPU Tensor 将分配在锁页内存中。仅对 CPU Tensor 生效。默认值为 False。
 
 返回
 ::::::::::::
-返回一个根据 ``x`` 、``fill_value`` 、 ``dtype`` 创建的 Tensor。
+返回一个根据  ``x``  、 ``fill_value``  、  ``dtype``  创建的 Tensor。
 
 
 代码示例
diff --git a/docs/api/paddle/gammaln_cn.rst b/docs/api/paddle/gammaln_cn.rst
index f836b656ab8..3067dce5058 100644
--- a/docs/api/paddle/gammaln_cn.rst
+++ b/docs/api/paddle/gammaln_cn.rst
@@ -15,7 +15,7 @@ gammaln
 
 返回
 ::::::::::::
-输出为 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出为 Tensor，与  ``x``  维度相同、数据类型相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/gather_cn.rst b/docs/api/paddle/gather_cn.rst
index 8f32caf41d2..f33239678e8 100644
--- a/docs/api/paddle/gather_cn.rst
+++ b/docs/api/paddle/gather_cn.rst
@@ -13,7 +13,7 @@ gather
 
 .. py:function:: paddle.gather(x, index, axis=None, name=None)
 
-根据索引 index 获取输入 ``x`` 的指定 ``axis`` 维度的条目，并将它们拼接在一起。
+根据索引 index 获取输入  ``x``  的指定  ``axis``  维度的条目，并将它们拼接在一起。
 
 .. code-block:: text
 
@@ -40,9 +40,9 @@ gather
 
 参数
 ::::::::::::
-        - **x** (Tensor) - 输入 Tensor，秩 ``rank >= 1``，支持的数据类型包括 int32、int64、float32、float64、complex64、complex128 和 uint8 (CPU)、float16（GPU） 。
-        - **index** (Tensor) - 索引 Tensor，秩 ``rank = 0`` 或者 ``rank = 1``，数据类型为 int32 或 int64。
-        - **axis** (Tensor) - 指定 index 获取输入的维度，``axis`` 的类型可以是 int 或者 Tensor，当 ``axis`` 为 Tensor 的时候其数据类型为 int32 或者 int64。默认值为 None，当``axis``为 None 的时候其值为 0。
+        - **x** (Tensor) - 输入 Tensor，秩  ``rank >= 1`` ，支持的数据类型包括 int32、int64、float32、float64、complex64、complex128 和 uint8 (CPU)、float16（GPU） 。
+        - **index** (Tensor) - 索引 Tensor，秩  ``rank = 0``  或者  ``rank = 1`` ，数据类型为 int32 或 int64。
+        - **axis** (Tensor) - 指定 index 获取输入的维度， ``axis``  的类型可以是 int 或者 Tensor，当  ``axis``  为 Tensor 的时候其数据类型为 int32 或者 int64。默认值为 None，当 ``axis`` 为 None 的时候其值为 0。
         - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
@@ -59,7 +59,7 @@ COPY-FROM: paddle.gather
 
 .. py:function:: paddle.gather(input, dim, index, out=None)
 
-PyTorch 兼容的 ``gather`` 操作：根据索引 index 获取输入 ``input`` 的指定 ``dim`` 维度的条目，并将它们拼接在一起。行为与 ``cn_api_paddle_take_along_axis`` 在 ``broadcast=False`` 情况下一致。
+PyTorch 兼容的  ``gather``  操作：根据索引 index 获取输入  ``input``  的指定  ``dim``  维度的条目，并将它们拼接在一起。行为与  ``cn_api_paddle_take_along_axis``  在  ``broadcast=False``  情况下一致。
 
 接口对比可见 `【torch 参数更多】torch.gather`_ 。
 
@@ -68,18 +68,18 @@ PyTorch 兼容的 ``gather`` 操作：根据索引 index 获取输入 ``input``
 参数
 ::::::::::::
         - **input** (Tensor) - 输入 Tensor，支持的数据类型包括 int32、int64、float32、float64、int16、uint8、float16（GPU）以及 bfloat16（GPU） 。
-        - **dim** (int) - 指定 index 获取输入的维度，``dim`` 的类型可以是 int 或者。
-        - **index** (Tensor) - 索引 Tensor，``index`` 张量的各维度需要小于等于 ``input`` 张量的各维度（除 ``dim`` 维度外），且值需要在 ``input.shape[dim]`` 范围内。数据类型为 int32 或 int64。
+        - **dim** (int) - 指定 index 获取输入的维度， ``dim``  的类型可以是 int 或者。
+        - **index** (Tensor) - 索引 Tensor， ``index``  张量的各维度需要小于等于  ``input``  张量的各维度（除  ``dim``  维度外），且值需要在  ``input.shape[dim]``  范围内。数据类型为 int32 或 int64。
         - **out** (Tensor，可选) - 用于引用式传入输出值，注意：动态图下 out 可以是任意 Tensor，默认值为 None。
 
 .. caution::
 
-        本接口没有实现 PyTorch 的 ``sparse_grad`` 参数！梯度默认是稠密的，等效于 ``sparse_grad=False``。
+        本接口没有实现 PyTorch 的  ``sparse_grad``  参数！梯度默认是稠密的，等效于  ``sparse_grad=False`` 。
 
 
 返回
 ::::::::::::
-Tensor，与 input 有数据类型，与 ``index`` 有相同的形状。
+Tensor，与 input 有数据类型，与  ``index``  有相同的形状。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/geometric/reindex_graph_cn.rst b/docs/api/paddle/geometric/reindex_graph_cn.rst
index e0c4a308b77..b3aa7644ff4 100644
--- a/docs/api/paddle/geometric/reindex_graph_cn.rst
+++ b/docs/api/paddle/geometric/reindex_graph_cn.rst
@@ -8,14 +8,14 @@ reindex_graph
 主要应用于图学习领域，需要与图采样相关的 API 配合使用，主要处理同构图场景。其主要目的是对输入的中心节点信息和邻居信息进行从 0 开始的重新编号，以方便后续的图模型子图训练。
 
 .. note::
-    输入 ``x`` 中的元素需保证是独有的，否则可能会带来一些潜在的错误。输入的节点将会和邻居节点一同从 0 进行编号。
+    输入  ``x``  中的元素需保证是独有的，否则可能会带来一些潜在的错误。输入的节点将会和邻居节点一同从 0 进行编号。
 
 以输入 x = [0, 1, 2] 作为例子解释。假设我们有邻居 neighbors = [8, 9, 0, 4, 7, 6, 7]，以及邻居数量 count = [2, 3, 2]。
 则可以得知节点 0 的邻居为 [8, 9]，节点 1 的邻居为 [0, 4, 7]，节点 2 的邻居为 [6, 7]。经过此 API 计算后，共计会返回三个结果：
     1. reindex_src: [3, 4, 0, 5, 6, 7, 6]
     2. reindex_dst: [0, 0, 1, 1, 1, 2, 2]
     3. out_nodes: [0, 1, 2, 8, 9, 4, 7, 6]
-可以看到 ``reindex_src`` 和 ``reindex_dst`` 中的值实际上是各个节点在 ``out_nodes`` 中对应的下标索引。
+可以看到  ``reindex_src``  和  ``reindex_dst``  中的值实际上是各个节点在  ``out_nodes``  中对应的下标索引。
 
 参数
 :::::::::
@@ -23,7 +23,7 @@ reindex_graph
     - **neighbors** (Tensor) - 中心节点的邻居节点编号，数据类型为：int32、int64。
     - **count** (Tensor) - 中心节点各自的邻居数目，数据类型为：int32。
     - **value_buffer** (Tensor，可选) - 用于快速哈希索引的缓存 Tensor，可加速重编号过程。数据类型为 int32，并且应当事先填充为-1。默认值为 None。
-    - **index_buffer** (Tensor，可选) - 用于快速哈希索引的缓存 Tensor，可加速重编号过程。数据类型为 int32，并且应当事先填充为-1。默认值为 None。如果需要使用加速重编号过程，则 ``value_buffer`` 和 ``index_buffer`` 均不可为空。
+    - **index_buffer** (Tensor，可选) - 用于快速哈希索引的缓存 Tensor，可加速重编号过程。数据类型为 int32，并且应当事先填充为-1。默认值为 None。如果需要使用加速重编号过程，则  ``value_buffer``  和  ``index_buffer``  均不可为空。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/geometric/reindex_heter_graph_cn.rst b/docs/api/paddle/geometric/reindex_heter_graph_cn.rst
index 9193deedf8f..9cd83325c08 100644
--- a/docs/api/paddle/geometric/reindex_heter_graph_cn.rst
+++ b/docs/api/paddle/geometric/reindex_heter_graph_cn.rst
@@ -8,7 +8,7 @@ reindex_heter_graph
 主要应用于图学习领域，需要与图采样相关的 API 配合使用，主要处理异构图场景。其主要目的是对输入的中心节点信息和邻居信息进行从 0 开始的重新编号，以方便后续的图模型子图训练。
 
 .. note::
-    输入 ``x`` 中的元素需保证是独有的，否则可能会带来一些潜在的错误。输入的节点将会和邻居节点一同从 0 进行编号。
+    输入  ``x``  中的元素需保证是独有的，否则可能会带来一些潜在的错误。输入的节点将会和邻居节点一同从 0 进行编号。
 
 以输入 x = [0, 1, 2] 作为例子解释。对于异构图 A ，假设我们有邻居 neighbors = [8, 9, 0, 4, 7, 6, 7]，以及邻居数量 count = [2, 3, 2]；
 则可以得知节点 0 的邻居为 [8, 9]，节点 1 的邻居为 [0, 4, 7]，节点 2 的邻居为 [6, 7]。对于异构图 B，假设有邻居 neighbors = [0, 2, 3, 5, 1]，
@@ -16,7 +16,7 @@ reindex_heter_graph
     1. reindex_src: [3, 4, 0, 5, 6, 7, 6, 0, 2, 8, 9, 1]
     2. reindex_dst: [0, 0, 1, 1, 1, 2, 2, 0, 1, 1, 1, 2]
     3. out_nodes: [0, 1, 2, 8, 9, 4, 7, 6, 3, 5]
-可以看到 ``reindex_src`` 和 ``reindex_dst`` 中的值实际上是各个节点在 ``out_nodes`` 中对应的下标索引。
+可以看到  ``reindex_src``  和  ``reindex_dst``  中的值实际上是各个节点在  ``out_nodes``  中对应的下标索引。
 
 参数
 :::::::::
@@ -24,7 +24,7 @@ reindex_heter_graph
     - **neighbors** (list | tuple) - 中心节点对应到各个异构图中的邻居节点编号，数据类型为：int32、int64。
     - **count** (list | tuple) - 中心节点对应到各个异构图中的邻居数目，数据类型为：int32。
     - **value_buffer** (Tensor，可选) - 用于快速哈希索引的缓存 Tensor，可加速重编号过程。数据类型为 int32，并且应当事先填充为-1。默认值为 None。
-    - **index_buffer** (Tensor，可选) - 用于快速哈希索引的缓存 Tensor，可加速重编号过程。数据类型为 int32，并且应当事先填充为-1。默认值为 None。如果需要使用加速重编号过程，则 ``value_buffer`` 和 ``index_buffer`` 均不可为空。
+    - **index_buffer** (Tensor，可选) - 用于快速哈希索引的缓存 Tensor，可加速重编号过程。数据类型为 int32，并且应当事先填充为-1。默认值为 None。如果需要使用加速重编号过程，则  ``value_buffer``  和  ``index_buffer``  均不可为空。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/geometric/sample_neighbors_cn.rst b/docs/api/paddle/geometric/sample_neighbors_cn.rst
index c102d5f37e0..6b4425ee621 100644
--- a/docs/api/paddle/geometric/sample_neighbors_cn.rst
+++ b/docs/api/paddle/geometric/sample_neighbors_cn.rst
@@ -5,24 +5,24 @@ sample_neighbors
 
 .. py:function:: paddle.geometric.sample_neighbors(row, colptr, input_nodes, sample_size=-1, eids=None, return_eids=False, perm_buffer=None, name=None)
 
-主要应用于图学习领域，主要目的是提供高性能图邻居采样方法。通过输入图的 CSC（Compressed Sparse Column，压缩列信息），分别对应 ``row`` 和 ``colptr``，从而将图转换为适用于邻居采样的格式，再输入需要进行采样的中心节点 ``input_nodes``，以及采样的邻居个数 ``sample_size``，从而可以获得对应中心节点采样后的邻居。另外，在 GPU 版本提供了 Fisher-yates 高性能图采样方法。
+主要应用于图学习领域，主要目的是提供高性能图邻居采样方法。通过输入图的 CSC（Compressed Sparse Column，压缩列信息），分别对应  ``row``  和  ``colptr`` ，从而将图转换为适用于邻居采样的格式，再输入需要进行采样的中心节点  ``input_nodes`` ，以及采样的邻居个数  ``sample_size`` ，从而可以获得对应中心节点采样后的邻居。另外，在 GPU 版本提供了 Fisher-yates 高性能图采样方法。
 
 参数
 :::::::::
     - **row** (Tensor) - 输入原始图的 CSC 格式的行信息，数据类型为：int32、int64，形状为[num_edges, 1] 或 [num_edges]。
-    - **colptr** (Tensor) - 输入原始图的 CSC 格式的压缩列信息，数据类型应当与 ``row`` 一致，形状为[num_nodes + 1, 1]或 [num_nodes + 1]。
-    - **input_nodes** (Tensor) - 需进行邻居采样的中心节点信息，数据类型应当与 ``row`` 一致。
+    - **colptr** (Tensor) - 输入原始图的 CSC 格式的压缩列信息，数据类型应当与  ``row``  一致，形状为[num_nodes + 1, 1]或 [num_nodes + 1]。
+    - **input_nodes** (Tensor) - 需进行邻居采样的中心节点信息，数据类型应当与  ``row``  一致。
     - **sample_size** (int) - 采样邻居个数。默认值为-1，表示采样输入中心节点的所有邻居。
-    - **eids** (Tensor，可选) - 输入原始图在 CSC 格式下的边编号信息。如果 ``return_eids`` 为 True，则不能为空。数据类型应当与 ``row`` 一致。默认为 None，表示不需要返回边编号信息。
+    - **eids** (Tensor，可选) - 输入原始图在 CSC 格式下的边编号信息。如果  ``return_eids``  为 True，则不能为空。数据类型应当与  ``row``  一致。默认为 None，表示不需要返回边编号信息。
     - **return_eids** (bool) - 是否返回采样后对应的原始边编号信息，默认为 False。
-    - **perm_buffer** (Tensor，可选) - Fisher-yates 采样方法需要用到的缓存 Tensor。如果需使用高性能图采样方法，则不能为空。数据类型应当与 ``row`` 一致，形状为[num_edges]，填充内容为 0 至 num_edges 的顺序递增序列。
+    - **perm_buffer** (Tensor，可选) - Fisher-yates 采样方法需要用到的缓存 Tensor。如果需使用高性能图采样方法，则不能为空。数据类型应当与  ``row``  一致，形状为[num_edges]，填充内容为 0 至 num_edges 的顺序递增序列。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
     - out_neighbors (Tensor) - 返回采样后的邻居节点。
-    - out_count (Tensor) - 返回中心节点各自对应的采样邻居数目，形状应该与 ``input_nodes`` 一致。
-    - out_eids (Tensor) - 如果 ``return_eids`` 为 True，则会返回采样边对应的编号信息，否则不返回。
+    - out_count (Tensor) - 返回中心节点各自对应的采样邻居数目，形状应该与  ``input_nodes``  一致。
+    - out_eids (Tensor) - 如果  ``return_eids``  为 True，则会返回采样边对应的编号信息，否则不返回。
 
 
 代码示例
diff --git a/docs/api/paddle/geometric/segment_max_cn.rst b/docs/api/paddle/geometric/segment_max_cn.rst
index 5873d7889ee..886f2ea4dd4 100644
--- a/docs/api/paddle/geometric/segment_max_cn.rst
+++ b/docs/api/paddle/geometric/segment_max_cn.rst
@@ -8,20 +8,20 @@ segment_max
 
 分段求最大值函数。
 
-此运算符，将 ``segment_ids`` 中相同索引对应的 ``data`` 的元素，进行求最大值操作。其中 ``segment_ids`` 是一个单调非减序列。
-具体而言，该算子计算一个 Tensor ``out``，使得
+此运算符，将  ``segment_ids``  中相同索引对应的  ``data``  的元素，进行求最大值操作。其中  ``segment_ids``  是一个单调非减序列。
+具体而言，该算子计算一个 Tensor  ``out`` ，使得
 
 .. math::
 
     out_i = \max_{j \in \{segment\_ids_j == i \} } data_{j}
 
-其中求最大值的索引 ``j``，是符合 ``segment_ids[j] == i`` 的所有 ``j`` 。
+其中求最大值的索引  ``j`` ，是符合  ``segment_ids[j] == i``  的所有  ``j``  。
 
 
 参数
 :::::::::
     - **data** (Tensor) - Tensor，数据类型为 float32、float64。
-    - **segment_ids** (Tensor) - 一维 Tensor，与输入数据 ``data`` 的第一维大小相同，表示 ``data`` 分段位置，单调非减。合法的数据类型为 int32、int64。
+    - **segment_ids** (Tensor) - 一维 Tensor，与输入数据  ``data``  的第一维大小相同，表示  ``data``  分段位置，单调非减。合法的数据类型为 int32、int64。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/geometric/segment_mean_cn.rst b/docs/api/paddle/geometric/segment_mean_cn.rst
index c891b3e3a61..1238025801b 100644
--- a/docs/api/paddle/geometric/segment_mean_cn.rst
+++ b/docs/api/paddle/geometric/segment_mean_cn.rst
@@ -8,20 +8,20 @@ segment_mean
 
 分段求均值函数。
 
-此运算符，将 ``segment_ids`` 中相同索引对应的 ``data`` 的元素，进行求均值操作。其中 ``segment_ids`` 是一个单调非减序列。
-具体而言，该算子计算一个 Tensor ``out``，使得
+此运算符，将  ``segment_ids``  中相同索引对应的  ``data``  的元素，进行求均值操作。其中  ``segment_ids``  是一个单调非减序列。
+具体而言，该算子计算一个 Tensor  ``out`` ，使得
 
 .. math::
 
     out_i = \mathop{mean}_{j \in \{segment\_ids_j == i \} } data_{j}
 
-其中求均值的索引 ``j``，是符合 ``segment_ids[j] == i`` 的所有 ``j`` 。
+其中求均值的索引  ``j`` ，是符合  ``segment_ids[j] == i``  的所有  ``j``  。
 
 
 参数
 :::::::::
     - **data** (Tensor) - Tensor，数据类型为 float32、float64。
-    - **segment_ids** (Tensor) - 一维 Tensor，与输入数据 ``data`` 的第一维大小相同，表示 ``data`` 分段位置，单调非减。合法的数据类型为 int32、int64。
+    - **segment_ids** (Tensor) - 一维 Tensor，与输入数据  ``data``  的第一维大小相同，表示  ``data``  分段位置，单调非减。合法的数据类型为 int32、int64。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/geometric/segment_min_cn.rst b/docs/api/paddle/geometric/segment_min_cn.rst
index 3e4d0c4ea8a..47ed84d3ee8 100644
--- a/docs/api/paddle/geometric/segment_min_cn.rst
+++ b/docs/api/paddle/geometric/segment_min_cn.rst
@@ -8,20 +8,20 @@ segment_min
 
 分段求最小值函数。
 
-此运算符，将 ``segment_ids`` 中相同索引对应的 ``data`` 的元素，进行求最小值操作。其中 ``segment_ids`` 是一个单调非减序列。
-具体而言，该算子计算一个 Tensor ``out``，使得
+此运算符，将  ``segment_ids``  中相同索引对应的  ``data``  的元素，进行求最小值操作。其中  ``segment_ids``  是一个单调非减序列。
+具体而言，该算子计算一个 Tensor  ``out`` ，使得
 
 .. math::
 
     out_i = \min_{j \in \{segment\_ids_j == i \} } data_{j}
 
-其中求最小值的索引 ``j``，是符合 ``segment_ids[j] == i`` 的所有 ``j`` 。
+其中求最小值的索引  ``j`` ，是符合  ``segment_ids[j] == i``  的所有  ``j``  。
 
 
 参数
 :::::::::
     - **data** (Tensor) - Tensor，数据类型为 float32、float64。
-    - **segment_ids** (Tensor) - 一维 Tensor，与输入数据 ``data`` 的第一维大小相同，表示 ``data`` 分段位置，单调非减。合法的数据类型为 int32、int64。
+    - **segment_ids** (Tensor) - 一维 Tensor，与输入数据  ``data``  的第一维大小相同，表示  ``data``  分段位置，单调非减。合法的数据类型为 int32、int64。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/geometric/segment_sum_cn.rst b/docs/api/paddle/geometric/segment_sum_cn.rst
index e461fa1c1ed..d15e6fc019d 100644
--- a/docs/api/paddle/geometric/segment_sum_cn.rst
+++ b/docs/api/paddle/geometric/segment_sum_cn.rst
@@ -8,21 +8,21 @@ segment_sum
 
 分段求和函数。
 
-此运算符，将 ``segment_ids`` 中相同索引对应的 ``data`` 的元素，进行求和操作。其中 ``segment_ids`` 是一个单调非减序列。
-具体而言，该算子计算一个 Tensor ``out``，使得
+此运算符，将  ``segment_ids``  中相同索引对应的  ``data``  的元素，进行求和操作。其中  ``segment_ids``  是一个单调非减序列。
+具体而言，该算子计算一个 Tensor  ``out`` ，使得
 
 .. math::
 
     out_i = \sum_{j \in \{segment\_ids_j == i \} } data_{j}
 
-其中求和的索引 ``j``，是符合 ``segment_ids[j] == i`` 的所有 ``j`` 。
+其中求和的索引  ``j`` ，是符合  ``segment_ids[j] == i``  的所有  ``j``  。
 
 
 参数
 :::::::::
 
     - **data** (Tensor) - Tensor，数据类型为 float32、float64。
-    - **segment_ids** (Tensor) - 一维 Tensor，与输入数据 ``data`` 的第一维大小相同，表示 ``data`` 分段位置，单调非减。合法的数据类型为 int32、int64。
+    - **segment_ids** (Tensor) - 一维 Tensor，与输入数据  ``data``  的第一维大小相同，表示  ``data``  分段位置，单调非减。合法的数据类型为 int32、int64。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/geometric/send_u_recv_cn.rst b/docs/api/paddle/geometric/send_u_recv_cn.rst
index 1307519aa5e..020430a788d 100644
--- a/docs/api/paddle/geometric/send_u_recv_cn.rst
+++ b/docs/api/paddle/geometric/send_u_recv_cn.rst
@@ -5,7 +5,7 @@ send_u_recv
 
 .. py:function:: paddle.geometric.send_u_recv(x, src_index, dst_index, reduce_op="sum", out_size=None, name=None)
 
-主要应用于图学习领域，目的是为了减少在消息传递过程中带来的中间变量显存或内存的损耗。其中，``x`` 作为输入的节点特征 Tensor，首先利用 ``src_index`` 作为索引来 gather 出在 ``x`` 中相应位置的数据，随后再将 gather 出的结果利用 ``dst_index`` 来更新到对应的输出结果中，其中 ``reduce_op`` 表示不同的更新方式，包括 sum、mean、max、min 共计 4 种处理模式。另外，提供了 ``out_size`` 参数，用于设置实际输出的形状，有利于减少实际显存占用。
+主要应用于图学习领域，目的是为了减少在消息传递过程中带来的中间变量显存或内存的损耗。其中， ``x``  作为输入的节点特征 Tensor，首先利用  ``src_index``  作为索引来 gather 出在  ``x``  中相应位置的数据，随后再将 gather 出的结果利用  ``dst_index``  来更新到对应的输出结果中，其中  ``reduce_op``  表示不同的更新方式，包括 sum、mean、max、min 共计 4 种处理模式。另外，提供了  ``out_size``  参数，用于设置实际输出的形状，有利于减少实际显存占用。
 
 .. code-block:: text
 
@@ -31,14 +31,14 @@ send_u_recv
 :::::::::
     - **x** (Tensor) - 输入的节点特征 Tensor，数据类型为：float32、float64、int32、int64。另外，我们在 GPU 计算中支持 float16。
     - **src_index** (Tensor) - 1-D Tensor，数据类型为：int32、int64。
-    - **dst_index** (Tensor) - 1-D Tensor，数据类型为：int32、int64。注意：``dst_index`` 的形状应当与 ``src_index`` 一致。
+    - **dst_index** (Tensor) - 1-D Tensor，数据类型为：int32、int64。注意： ``dst_index``  的形状应当与  ``src_index``  一致。
     - **reduce_op** (str) - 不同更新方式，包括 sum、mean、max、min。默认值为 sum。
-    - **out_size** (int64 | Tensor | None) - 可以通过根据实际需求设置 ``out_size`` 来改变实际输出形状。默认值为 None，表示这个参数将不会被使用。注意，``out_size`` 的值必须等于或大于 ``max(dst_index) + 1`` 。
+    - **out_size** (int64 | Tensor | None) - 可以通过根据实际需求设置  ``out_size``  来改变实际输出形状。默认值为 None，表示这个参数将不会被使用。注意， ``out_size``  的值必须等于或大于  ``max(dst_index) + 1``  。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-``Tensor`` ，维度和数据类型都与 ``x`` 相同，存储运算后的结果。如果 ``out_size`` 参数正确设置了，则输出结果的第 0 维大小是 ``out_size`` ，其余维度大小与 ``x`` 相同。
+ ``Tensor``  ，维度和数据类型都与  ``x``  相同，存储运算后的结果。如果  ``out_size``  参数正确设置了，则输出结果的第 0 维大小是  ``out_size``  ，其余维度大小与  ``x``  相同。
 
 
 代码示例
diff --git a/docs/api/paddle/geometric/send_ue_recv_cn.rst b/docs/api/paddle/geometric/send_ue_recv_cn.rst
index b9ed7fd0d3f..cdf60830a5d 100644
--- a/docs/api/paddle/geometric/send_ue_recv_cn.rst
+++ b/docs/api/paddle/geometric/send_ue_recv_cn.rst
@@ -5,7 +5,7 @@ send_ue_recv
 
 .. py:function:: paddle.geometric.send_ue_recv(x, y, src_index, dst_index, message_op="add", reduce_op="sum", out_size=None, name=None)
 
-主要应用于图学习领域，目的是为了减少在消息传递过程中带来的中间变量显存或内存的损耗。其中，``x`` 作为输入节点特征 Tensor，首先利用 ``src_index`` 作为索引来 gather 出在 ``x`` 中相应位置的数据，接着与边特征 Tensor ``e`` 进行计算，计算方式包括 add、sub、mul、div。随后再将计算的结果利用 ``dst_index`` 来更新到对应的输出结果中，其中 ``message_op`` 表示输入 ``x`` 和 ``e`` 之间的计算方式， ``reduce_op`` 表示不同的结果更新方式，包括 sum、mean、max、min 共计 4 种处理模式。另外，提供了 ``out_size`` 参数，用于设置实际输出的形状，有利于减少实际显存占用。
+主要应用于图学习领域，目的是为了减少在消息传递过程中带来的中间变量显存或内存的损耗。其中， ``x``  作为输入节点特征 Tensor，首先利用  ``src_index``  作为索引来 gather 出在  ``x``  中相应位置的数据，接着与边特征 Tensor  ``e``  进行计算，计算方式包括 add、sub、mul、div。随后再将计算的结果利用  ``dst_index``  来更新到对应的输出结果中，其中  ``message_op``  表示输入  ``x``  和  ``e``  之间的计算方式，  ``reduce_op``  表示不同的结果更新方式，包括 sum、mean、max、min 共计 4 种处理模式。另外，提供了  ``out_size``  参数，用于设置实际输出的形状，有利于减少实际显存占用。
 
 .. code-block:: text
 
@@ -34,17 +34,17 @@ send_ue_recv
 参数
 :::::::::
     - **x** (Tensor) - 输入的节点特征 Tensor，数据类型为：float32、float64、int32、int64。另外，我们在 GPU 计算中支持 float16。
-    - **y** (Tensor) - 输入的边特征 Tensor，数据类型为：float32、float64、int32、int64。数据类型需与 ``x`` 相同。另外，我们在 GPU 计算中支持 float16。
+    - **y** (Tensor) - 输入的边特征 Tensor，数据类型为：float32、float64、int32、int64。数据类型需与  ``x``  相同。另外，我们在 GPU 计算中支持 float16。
     - **src_index** (Tensor) - 1-D Tensor，数据类型为：int32、int64。
-    - **dst_index** (Tensor) - 1-D Tensor，数据类型为：int32、int64。注意：``dst_index`` 的形状应当与 ``src_index`` 一致。
+    - **dst_index** (Tensor) - 1-D Tensor，数据类型为：int32、int64。注意： ``dst_index``  的形状应当与  ``src_index``  一致。
     - **message_op** (str) - 不同计算方式，包括 add、sub、mul、div。默认值为 add。
     - **reduce_op** (str) - 不同更新方式，包括 sum、mean、max、min。默认值为 sum。
-    - **out_size** (int64 | Tensor | None) - 可以通过根据实际需求设置 ``out_size`` 来改变实际输出形状。默认值为 None，表示这个参数将不会被使用。注意，``out_size`` 的值必须等于或大于 ``max(dst_index) + 1`` 。
+    - **out_size** (int64 | Tensor | None) - 可以通过根据实际需求设置  ``out_size``  来改变实际输出形状。默认值为 None，表示这个参数将不会被使用。注意， ``out_size``  的值必须等于或大于  ``max(dst_index) + 1``  。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-``Tensor`` ，维度和数据类型都与 ``x`` 相同，存储运算后的结果。如果 ``out_size`` 参数正确设置了，则输出结果的第 0 维大小是 ``out_size`` ，其余维度大小与 ``x`` 相同。
+ ``Tensor``  ，维度和数据类型都与  ``x``  相同，存储运算后的结果。如果  ``out_size``  参数正确设置了，则输出结果的第 0 维大小是  ``out_size``  ，其余维度大小与  ``x``  相同。
 
 
 代码示例
diff --git a/docs/api/paddle/geometric/send_uv_cn.rst b/docs/api/paddle/geometric/send_uv_cn.rst
index 39bc01541f8..9c8f8d1dc54 100644
--- a/docs/api/paddle/geometric/send_uv_cn.rst
+++ b/docs/api/paddle/geometric/send_uv_cn.rst
@@ -5,7 +5,7 @@ send_uv
 
 .. py:function:: paddle.geometric.send_uv(x, y, src_index, dst_index, message_op="add", name=None)
 
-主要应用于图学习领域，目的是为了减少在消息传递过程中带来的中间变量显存或内存的损耗。其中，``x`` 作为输入的节点特征 Tensor，首先利用 ``src_index`` 作为索引来 gather 出在 ``x`` 中相应位置的数据，接着利用 ``dst_index`` gather 出 ``y`` 中相应位置的数据，再通过 ``message_op`` 确认计算方式，最终返回。其中，``message_op`` 包括另外 add、sub、mul、div 共计四种计算方式。
+主要应用于图学习领域，目的是为了减少在消息传递过程中带来的中间变量显存或内存的损耗。其中， ``x``  作为输入的节点特征 Tensor，首先利用  ``src_index``  作为索引来 gather 出在  ``x``  中相应位置的数据，接着利用  ``dst_index``  gather 出  ``y``  中相应位置的数据，再通过  ``message_op``  确认计算方式，最终返回。其中， ``message_op``  包括另外 add、sub、mul、div 共计四种计算方式。
 
 .. code-block:: text
 
@@ -29,13 +29,13 @@ send_uv
 :::::::::
     - **x** (Tensor) - 输入的节点特征 Tensor，数据类型为：float32、float64、int32、int64。另外，我们在 GPU 计算中支持 float16。
     - **src_index** (Tensor) - 1-D Tensor，数据类型为：int32、int64。
-    - **dst_index** (Tensor) - 1-D Tensor，数据类型为：int32、int64。注意：``dst_index`` 的形状应当与 ``src_index`` 一致。
+    - **dst_index** (Tensor) - 1-D Tensor，数据类型为：int32、int64。注意： ``dst_index``  的形状应当与  ``src_index``  一致。
     - **message_op** (str) - 不同计算方式，包括 add、sub、mul、div。默认值为 add。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-``Tensor`` ，输出更新后的边特征。
+ ``Tensor``  ，输出更新后的边特征。
 
 
 代码示例
diff --git a/docs/api/paddle/geometric/weighted_sample_neighbors_cn.rst b/docs/api/paddle/geometric/weighted_sample_neighbors_cn.rst
index 30bb1198d37..9a6f2ebb0b5 100644
--- a/docs/api/paddle/geometric/weighted_sample_neighbors_cn.rst
+++ b/docs/api/paddle/geometric/weighted_sample_neighbors_cn.rst
@@ -5,28 +5,28 @@ weighted_sample_neighbors
 
 .. py:function:: paddle.geometric.weighted_sample_neighbors(row, colptr, edge_weight, input_nodes, sample_size=- 1, eids=None, return_eids=False, name=None)
 
-此 API 主要用于图学习领域，其主要目的是提供高性能图加权邻居采样方法。例如，我们获取输入图的 CSC（Compressed Sparse Column，压缩列信息），分别对应 ``row`` 和 ``colptr``，从而将图转换为适用于邻居采样的格式，并且输入的 ``edge_weight`` 也应该与 CSC 格式匹配。
+此 API 主要用于图学习领域，其主要目的是提供高性能图加权邻居采样方法。例如，我们获取输入图的 CSC（Compressed Sparse Column，压缩列信息），分别对应  ``row``  和  ``colptr`` ，从而将图转换为适用于邻居采样的格式，并且输入的  ``edge_weight``  也应该与 CSC 格式匹配。
 
-再输入需要进行采样的中心节点 ``input_nodes``，以及采样的邻居个数 ``sample_size``，从而可以获得对应中心节点采样后的邻居。
+再输入需要进行采样的中心节点  ``input_nodes`` ，以及采样的邻居个数  ``sample_size`` ，从而可以获得对应中心节点采样后的邻居。
 
 此 API 最终将返回加权采样的邻居数目，被选为邻居的概率与其权重相关，权重越高，被选概率越高。
 
 参数
 :::::::::
     - **row** (Tensor) - 输入原始图的 CSC 格式的行信息，数据类型为：int32、int64，形状为[num_edges, 1] 或 [num_edges]。
-    - **colptr** (Tensor) - 输入原始图的 CSC 格式的压缩列信息，数据类型应当与 ``row`` 一致，形状为[num_nodes + 1, 1]或 [num_nodes + 1]。
+    - **colptr** (Tensor) - 输入原始图的 CSC 格式的压缩列信息，数据类型应当与  ``row``  一致，形状为[num_nodes + 1, 1]或 [num_nodes + 1]。
     - **edge_weight** (Tensor) - 输入原始图边缘的 CSC 格式边权重。形状应为[num_edges, 1]或[num_edges]。可用的数据类型为 float32。
-    - **input_nodes** (Tensor) - 需进行邻居采样的中心节点信息，数据类型应当与 ``row`` 一致。
+    - **input_nodes** (Tensor) - 需进行邻居采样的中心节点信息，数据类型应当与  ``row``  一致。
     - **sample_size** (int) - 采样邻居个数。默认值为-1，表示采样输入中心节点的所有邻居。
-    - **eids** (Tensor，可选) - 输入原始图在 CSC 格式下的边编号信息。如果 ``return_eids`` 为 True，则不能为空。数据类型应当与 ``row`` 一致。默认为 None，表示不需要返回边编号信息。
+    - **eids** (Tensor，可选) - 输入原始图在 CSC 格式下的边编号信息。如果  ``return_eids``  为 True，则不能为空。数据类型应当与  ``row``  一致。默认为 None，表示不需要返回边编号信息。
     - **return_eids** (bool) - 是否返回采样后对应的原始边编号信息，默认为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
     - out_neighbors (Tensor) - 返回采样后的邻居节点。
-    - out_count (Tensor) - 返回中心节点各自对应的采样邻居数目，形状应该与 ``input_nodes`` 一致。
-    - out_eids (Tensor) - 如果 ``return_eids`` 为 True，则会返回采样边对应的编号信息，否则不返回。
+    - out_count (Tensor) - 返回中心节点各自对应的采样邻居数目，形状应该与  ``input_nodes``  一致。
+    - out_eids (Tensor) - 如果  ``return_eids``  为 True，则会返回采样边对应的编号信息，否则不返回。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/ger_cn.rst b/docs/api/paddle/ger_cn.rst
index d6d6b281eca..f181180d7d4 100644
--- a/docs/api/paddle/ger_cn.rst
+++ b/docs/api/paddle/ger_cn.rst
@@ -5,4 +5,4 @@ ger
 
 .. py:function:: paddle.ger(x, y, name=None, *, out=None)
 
-``outer`` 的别名，请参考 :ref:`cn_api_paddle_outer`。
+ ``outer``  的别名，请参考 :ref:`cn_api_paddle_outer`。
diff --git a/docs/api/paddle/get_autocast_gpu_dtype_cn.rst b/docs/api/paddle/get_autocast_gpu_dtype_cn.rst
index b8f48c92539..4057b198139 100644
--- a/docs/api/paddle/get_autocast_gpu_dtype_cn.rst
+++ b/docs/api/paddle/get_autocast_gpu_dtype_cn.rst
@@ -5,4 +5,4 @@ get_autocast_gpu_dtype
 
 .. py:function:: paddle.get_autocast_gpu_dtype(device_type=None)
 
-``get_autocast_dtype`` 的别名，请参考 :ref:`cn_api_paddle_get_autocast_dtype`。
+ ``get_autocast_dtype``  的别名，请参考 :ref:`cn_api_paddle_get_autocast_dtype`。
diff --git a/docs/api/paddle/get_rng_state_cn.rst b/docs/api/paddle/get_rng_state_cn.rst
index d24f480cdd4..600697fefb2 100644
--- a/docs/api/paddle/get_rng_state_cn.rst
+++ b/docs/api/paddle/get_rng_state_cn.rst
@@ -8,7 +8,7 @@ get_rng_state
 
 参数
 ::::::::::::
-    - **device** (str) - 此参数决定了具体的运行设备。可以是 ``cpu``、``gpu``、``xpu``。默认值为 None。如果为 None，则返回当前设备（由 ``set_device`` 指定）的生成器。
+    - **device** (str) - 此参数决定了具体的运行设备。可以是  ``cpu`` 、 ``gpu`` 、 ``xpu`` 。默认值为 None。如果为 None，则返回当前设备（由  ``set_device``  指定）的生成器。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/gt_cn.rst b/docs/api/paddle/gt_cn.rst
index 1753ae63609..6d9ca36234e 100644
--- a/docs/api/paddle/gt_cn.rst
+++ b/docs/api/paddle/gt_cn.rst
@@ -5,4 +5,4 @@ gt
 
 .. py:function:: paddle.gt(x, y, name=None, *, out=None)
 
-``greater_than`` 的别名，请参考 :ref:`cn_api_paddle_greater_than`。
+ ``greater_than``  的别名，请参考 :ref:`cn_api_paddle_greater_than`。
diff --git a/docs/api/paddle/heaviside_cn.rst b/docs/api/paddle/heaviside_cn.rst
index cc0fb26818b..2c5cb0c8397 100644
--- a/docs/api/paddle/heaviside_cn.rst
+++ b/docs/api/paddle/heaviside_cn.rst
@@ -19,7 +19,7 @@ heaviside
       \right.
 
 .. note::
-   ``paddle.heaviside`` 遵守广播机制，如您想了解更多，请参见 `Tensor 介绍`_ .
+    ``paddle.heaviside``  遵守广播机制，如您想了解更多，请参见 `Tensor 介绍`_ .
 
    .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
diff --git a/docs/api/paddle/histogram_bin_edges_cn.rst b/docs/api/paddle/histogram_bin_edges_cn.rst
index e4bee1c4907..58b5283c8a2 100644
--- a/docs/api/paddle/histogram_bin_edges_cn.rst
+++ b/docs/api/paddle/histogram_bin_edges_cn.rst
@@ -5,7 +5,7 @@ histogram_bin_edges
 
 .. py:function:: paddle.histogram_bin_edges(input, bins=100, min=0.0, max=0.0, name=None)
 
-只返回在计算 ``input`` 的直方图时所使用的 bins 的边界值 bin_edges。如果 min 和 max 都为 0.0，则利用数据中的最大最小值作为边界。
+只返回在计算  ``input``  的直方图时所使用的 bins 的边界值 bin_edges。如果 min 和 max 都为 0.0，则利用数据中的最大最小值作为边界。
 
 参数
 ::::::::::::
diff --git a/docs/api/paddle/hsplit_cn.rst b/docs/api/paddle/hsplit_cn.rst
index 4fb46ea958c..542e3a82069 100644
--- a/docs/api/paddle/hsplit_cn.rst
+++ b/docs/api/paddle/hsplit_cn.rst
@@ -7,7 +7,7 @@ hsplit
 
 
 
-``hsplit`` 全称 Horizontal Split ，即水平分割，将输入 Tensor 沿着水平轴分割成多个子 Tensor，存在以下两种情况：
+ ``hsplit``  全称 Horizontal Split ，即水平分割，将输入 Tensor 沿着水平轴分割成多个子 Tensor，存在以下两种情况：
 
 1. 当 x 的维度等于 1 时，等价于将 :ref:`cn_api_paddle_tensor_split` API 的参数 axis 固定为 0；
 
@@ -22,7 +22,7 @@ hsplit
 参数
 :::::::::
        - **x** (Tensor) - 输入变量，数据类型为 bool、bfloat16、float16、float32、float64、uint8、int8、int32、int64 的多维 Tensor，其维度必须大于 0。
-       - **num_or_indices** (int|list|tuple) - 如果 ``num_or_indices`` 是一个整数 ``n`` ，则 ``x`` 拆分为 ``n`` 部分。如果 ``num_or_indices`` 是整数索引的列表或元组，则在每个索引处分割 ``x`` 。
+       - **num_or_indices** (int|list|tuple) - 如果  ``num_or_indices``  是一个整数  ``n``  ，则  ``x``  拆分为  ``n``  部分。如果  ``num_or_indices``  是整数索引的列表或元组，则在每个索引处分割  ``x``  。
        - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/hstack_cn.rst b/docs/api/paddle/hstack_cn.rst
index e6a3b03e539..520e3b054d2 100644
--- a/docs/api/paddle/hstack_cn.rst
+++ b/docs/api/paddle/hstack_cn.rst
@@ -5,19 +5,19 @@ hstack
 
 .. py:function:: paddle.hstack(x, name=None)
 
-沿水平轴堆叠输入 ``x`` 中的所有张量。所有张量必须具有相同的数据类型。
+沿水平轴堆叠输入  ``x``  中的所有张量。所有张量必须具有相同的数据类型。
 
 参数
 ::::::::::::
 
-    - **x** (list[Tensor]|tuple[Tensor]) - 输入 ``x`` 可以是张量的 list 或 tuple， ``x`` 中张量的数据类型必须相同。支持的数据类型： ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 、 ``int64`` 或 ``bfloat16`` 。
+    - **x** (list[Tensor]|tuple[Tensor]) - 输入  ``x``  可以是张量的 list 或 tuple，  ``x``  中张量的数据类型必须相同。支持的数据类型：  ``float16``  、  ``float32``  、  ``float64``  、  ``int32``  、  ``int64``  或  ``bfloat16``  。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
 Tensor，与输入数据类型相同的堆叠张量。
 
-也可以参考下方的图示来理解 ``hstack`` 是如何对张量进行变换的。
+也可以参考下方的图示来理解  ``hstack``  是如何对张量进行变换的。
 
 .. image:: ../../images/api_legend/hstack.png
    :width: 500
diff --git a/docs/api/paddle/hub/help_cn.rst b/docs/api/paddle/hub/help_cn.rst
index b8170901de2..7268a07eb5a 100644
--- a/docs/api/paddle/hub/help_cn.rst
+++ b/docs/api/paddle/hub/help_cn.rst
@@ -20,7 +20,7 @@ help
 返回
 :::::::::
 
-    ``str`` ，repo 提供的指定模型的文档。
+     ``str``  ，repo 提供的指定模型的文档。
 
 
 代码示例
diff --git a/docs/api/paddle/hub/list_cn.rst b/docs/api/paddle/hub/list_cn.rst
index bfcc9ffad13..2e01519d332 100644
--- a/docs/api/paddle/hub/list_cn.rst
+++ b/docs/api/paddle/hub/list_cn.rst
@@ -20,7 +20,7 @@ list
 返回
 :::::::::
 
-    ``list`` ，repo 提供的模型/功能列表。
+     ``list``  ，repo 提供的模型/功能列表。
 
 
 代码示例
diff --git a/docs/api/paddle/hub/load_cn.rst b/docs/api/paddle/hub/load_cn.rst
index 584c20ce319..8578fa9eb4b 100644
--- a/docs/api/paddle/hub/load_cn.rst
+++ b/docs/api/paddle/hub/load_cn.rst
@@ -20,7 +20,7 @@ load
 返回
 :::::::::
 
-    ``paddle.nn.Layer`` ，repo 提供的指定模型实例。
+     ``paddle.nn.Layer``  ，repo 提供的指定模型实例。
 
 
 代码示例
diff --git a/docs/api/paddle/hypot_cn.rst b/docs/api/paddle/hypot_cn.rst
index d6d29711d48..45e2f44aa42 100644
--- a/docs/api/paddle/hypot_cn.rst
+++ b/docs/api/paddle/hypot_cn.rst
@@ -18,7 +18,7 @@ hypot
     - **name** (str，可选) - 具体用法请参见  :ref:`api_guide_Name` ，一般无需设置，默认值为 None。
 返回
 ::::::::::
-    - ``out`` (Tensor)：一个 n-d Tensor。如果 x、y 具有不同的形状并且是可广播的，则得到的张量形状是广播后 x 和 y 的形状。如果 x、y 具有相同的形状，则其形状与 x 和 y 相同。
+    -  ``out``  (Tensor)：一个 n-d Tensor。如果 x、y 具有不同的形状并且是可广播的，则得到的张量形状是广播后 x 和 y 的形状。如果 x、y 具有相同的形状，则其形状与 x 和 y 相同。
 
 
 代码示例
diff --git a/docs/api/paddle/i0_cn.rst b/docs/api/paddle/i0_cn.rst
index 418fa375c0d..43de7e4e369 100644
--- a/docs/api/paddle/i0_cn.rst
+++ b/docs/api/paddle/i0_cn.rst
@@ -6,7 +6,7 @@ i0
 .. py:function:: paddle.i0(x, name=None)
 
 
-对于给定 ``x`` 计算其每个元素的第一类零阶修正贝塞尔曲线函数，其中输入 ``x`` 大小无特殊限制。返回一个第一类零阶修正贝塞尔曲线函数上的 Tensor。
+对于给定  ``x``  计算其每个元素的第一类零阶修正贝塞尔曲线函数，其中输入  ``x``  大小无特殊限制。返回一个第一类零阶修正贝塞尔曲线函数上的 Tensor。
 
 .. math::
     I_0(x)=\sum^{\infty}_{k=0}\frac{(x^2/4)^k}{(k!)^2}
@@ -17,7 +17,7 @@ i0
     - **name** (str，可选) - 具体用法请参见  :ref:`api_guide_Name` ，一般无需设置，默认值为 None。
 返回
 ::::::::::
-    - ``Tensor`` (Tensor)：在 x 处的第一类零阶修正贝塞尔曲线函数的值。
+    -  ``Tensor``  (Tensor)：在 x 处的第一类零阶修正贝塞尔曲线函数的值。
 
 
 代码示例
diff --git a/docs/api/paddle/i0e_cn.rst b/docs/api/paddle/i0e_cn.rst
index 270428c9b62..58b357f65a2 100644
--- a/docs/api/paddle/i0e_cn.rst
+++ b/docs/api/paddle/i0e_cn.rst
@@ -6,7 +6,7 @@ i0e
 .. py:function:: paddle.i0e(x, name=None)
 
 
-对于给定 ``x`` 计算其每个元素的第一类指数缩放零阶修正贝塞尔曲线函数，其中输入 ``x`` 大小无特殊限制。返回一个第一类指数缩放零阶修正贝塞尔曲线函数上的 Tensor。
+对于给定  ``x``  计算其每个元素的第一类指数缩放零阶修正贝塞尔曲线函数，其中输入  ``x``  大小无特殊限制。返回一个第一类指数缩放零阶修正贝塞尔曲线函数上的 Tensor。
 
 .. math::
     I_0(x)=\sum^{\infty}_{k=0}\frac{(x^2/4)^k}{(k!)^2} \\
@@ -18,7 +18,7 @@ i0e
     - **name** (str，可选) - 具体用法请参见  :ref:`api_guide_Name` ，一般无需设置，默认值为 None。
 返回
 ::::::::::
-    - ``Tensor`` (Tensor)：在 x 处的第一类指数缩放零阶修正贝塞尔曲线函数的值。
+    -  ``Tensor``  (Tensor)：在 x 处的第一类指数缩放零阶修正贝塞尔曲线函数的值。
 
 
 代码示例
diff --git a/docs/api/paddle/i1_cn.rst b/docs/api/paddle/i1_cn.rst
index 89a820101b8..aaab053b9c0 100644
--- a/docs/api/paddle/i1_cn.rst
+++ b/docs/api/paddle/i1_cn.rst
@@ -4,7 +4,7 @@ i1
 -------------------------------
 
 .. py:function:: paddle.i1(x, name=None)
-对于给定 ``x`` 计算其每个元素的第一类一阶修正贝塞尔曲线函数，其中输入 ``x`` 大小无特殊限制。返回第一类一阶修正贝塞尔函数对应输出 Tensor。
+对于给定  ``x``  计算其每个元素的第一类一阶修正贝塞尔曲线函数，其中输入  ``x``  大小无特殊限制。返回第一类一阶修正贝塞尔函数对应输出 Tensor。
 
 .. math::
     I_1(x)=\frac{\left(\text { x }_{i}\right)}{2} * \sum_{k=0}^{\infty} \frac{\left(\text{x}_{i}^{2} / 4\right)^{k}}{(k !) *(k+1) !}
@@ -16,7 +16,7 @@ i1
 
 返回
 ::::::::::
-    - ``Tensor`` (Tensor)：在 x 处的第一类一阶修正贝塞尔曲线函数的值。
+    -  ``Tensor``  (Tensor)：在 x 处的第一类一阶修正贝塞尔曲线函数的值。
 
 
 代码示例
diff --git a/docs/api/paddle/i1e_cn.rst b/docs/api/paddle/i1e_cn.rst
index 1b78cf7b1fb..b879c006551 100644
--- a/docs/api/paddle/i1e_cn.rst
+++ b/docs/api/paddle/i1e_cn.rst
@@ -4,7 +4,7 @@ i1e
 -------------------------------
 
 .. py:function:: paddle.i1e(x, name=None)
-对于给定 ``x`` 计算其每个元素的第一类指数缩放的一阶修正贝塞尔曲线函数，其中输入 ``x`` 大小无特殊限制。返回第一类指数缩放的一阶修正贝塞尔函数对应输出 Tensor。
+对于给定  ``x``  计算其每个元素的第一类指数缩放的一阶修正贝塞尔曲线函数，其中输入  ``x``  大小无特殊限制。返回第一类指数缩放的一阶修正贝塞尔函数对应输出 Tensor。
 
 .. math::
     I_1e(x)=\exp (-|x|) * i 1(x)=\exp (-|x|) * \frac{\left(\text { input }_{i}\right)}{2} * \sum_{k=0}^{\infty} \frac{\left(\text { input }_{i}^{2} / 4\right)^{k}}{(k !) *(k+1) !}
@@ -16,7 +16,7 @@ i1e
 
 返回
 ::::::::::
-    - ``Tensor`` (Tensor)：在 x 处的第一类指数缩放的一阶修正贝塞尔曲线函数的值。
+    -  ``Tensor``  (Tensor)：在 x 处的第一类指数缩放的一阶修正贝塞尔曲线函数的值。
 
 
 代码示例
diff --git a/docs/api/paddle/iinfo_cn.rst b/docs/api/paddle/iinfo_cn.rst
index c72f59ff500..bb8fdda9711 100644
--- a/docs/api/paddle/iinfo_cn.rst
+++ b/docs/api/paddle/iinfo_cn.rst
@@ -7,7 +7,7 @@ iinfo
 
 
 
-返回一个 ``iinfo`` 对象，该对象包含了输入 ``dtype`` 的各种相关的数值信息。其中输入 ``dtype`` 只能是整数类型的 ``paddle.dtype`` 。
+返回一个  ``iinfo``  对象，该对象包含了输入  ``dtype``  的各种相关的数值信息。其中输入  ``dtype``  只能是整数类型的  ``paddle.dtype``  。
 
 其功能类似 `numpy.iinfo <https://numpy.org/doc/stable/reference/generated/numpy.iinfo.html#numpy-iinfo>`_ 。
 
@@ -18,7 +18,7 @@ iinfo
 
 返回
 :::::::::
-一个 ``iinfo`` 对象，其中包含 4 个属性，如下所示：
+一个  ``iinfo``  对象，其中包含 4 个属性，如下所示：
 
     - **min** (int) - 该数据类型所能表示的最小的整数；
     - **max** (int) - 该数据类型所能表示的最大的整数；
diff --git a/docs/api/paddle/in_dynamic_mode_cn.rst b/docs/api/paddle/in_dynamic_mode_cn.rst
index 00582397e11..cbbe1ee8eeb 100644
--- a/docs/api/paddle/in_dynamic_mode_cn.rst
+++ b/docs/api/paddle/in_dynamic_mode_cn.rst
@@ -14,7 +14,7 @@ in_dynamic_mode
 
 返回
 ::::::::::::
-bool，如果 paddle 当前是在动态图模式运行，则返回 ``True``，否则返回 ``False``。
+bool，如果 paddle 当前是在动态图模式运行，则返回  ``True`` ，否则返回  ``False`` 。
 
 
 代码示例
diff --git a/docs/api/paddle/increment_cn.rst b/docs/api/paddle/increment_cn.rst
index c97722a0985..cc6fcb7249a 100644
--- a/docs/api/paddle/increment_cn.rst
+++ b/docs/api/paddle/increment_cn.rst
@@ -8,19 +8,19 @@ increment
 
 
 
-在控制流程中用来让参数``x`` 的数值增加 ``value`` 。
+在控制流程中用来让参数 ``x``  的数值增加  ``value``  。
 
 参数
 :::::::::
 
   - **x** (Tensor) – 输入 Tensor，必须始终只有一个元素。支持的数据类型：float32、float64、int32、int64。
-  - **value** (float，可选) – ``x`` 的数值增量。默认值为 1.0。
+  - **value** (float，可选) –  ``x``  的数值增量。默认值为 1.0。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
 
-Tensor，形状和数据类型同输入 ``x`` 。
+Tensor，形状和数据类型同输入  ``x``  。
 
 
 代码示例
diff --git a/docs/api/paddle/incubate/LookAhead_cn.rst b/docs/api/paddle/incubate/LookAhead_cn.rst
index 06cfc95573d..8332e91c8fc 100644
--- a/docs/api/paddle/incubate/LookAhead_cn.rst
+++ b/docs/api/paddle/incubate/LookAhead_cn.rst
@@ -53,13 +53,13 @@ minimize(loss, startup_program=None, parameters=None, no_grad_set=None)
 **参数**
 
     - **loss** (Tensor) - 包含要最小化的值的 Tensor。
-    - **startup_program** (Program，可选) - :ref:`cn_api_paddle_static_Program`。在 ``parameters`` 中初始化参数。默认值为 None，此时将使用 :ref:`cn_api_paddle_static_default_startup_program` 。
-    - **parameters** (list，可选) - 列出更新最小化 ``loss`` 的 ``Tensor`` 或 ``Tensor.name``。默认值为 None，此时所有参数都会被更新。
-    - **no_grad_set** (set，可选) - 不需要更新的 ``Tensor`` 或 ``Tensor.name`` 的集合。默认值为 None。
+    - **startup_program** (Program，可选) - :ref:`cn_api_paddle_static_Program`。在  ``parameters``  中初始化参数。默认值为 None，此时将使用 :ref:`cn_api_paddle_static_default_startup_program` 。
+    - **parameters** (list，可选) - 列出更新最小化  ``loss``  的  ``Tensor``  或  ``Tensor.name`` 。默认值为 None，此时所有参数都会被更新。
+    - **no_grad_set** (set，可选) - 不需要更新的  ``Tensor``  或  ``Tensor.name``  的集合。默认值为 None。
 
 **返回**
 
-tuple: tuple (optimize_ops, params_grads)，由 ``minimize`` 添加的操作列表和 ``(param, grad)`` Tensor 对的列表，其中 param 是参数，grad 参数对应的梯度值。在静态图模式中，返回的元组可以传给 ``Executor.run()`` 中的 ``fetch_list`` 来表示程序剪枝。这样程序在运行之前会通过 ``feed`` 和 ``fetch_list`` 被剪枝，详情请参考 ``Executor`` 。
+tuple: tuple (optimize_ops, params_grads)，由  ``minimize``  添加的操作列表和  ``(param, grad)``  Tensor 对的列表，其中 param 是参数，grad 参数对应的梯度值。在静态图模式中，返回的元组可以传给  ``Executor.run()``  中的  ``fetch_list``  来表示程序剪枝。这样程序在运行之前会通过  ``feed``  和  ``fetch_list``  被剪枝，详情请参考  ``Executor``  。
 
 **代码示例**
 
diff --git a/docs/api/paddle/incubate/ModelAverage_cn.rst b/docs/api/paddle/incubate/ModelAverage_cn.rst
index e7a9ba4c475..d68e86726ed 100644
--- a/docs/api/paddle/incubate/ModelAverage_cn.rst
+++ b/docs/api/paddle/incubate/ModelAverage_cn.rst
@@ -5,20 +5,20 @@ ModelAverage
 
 .. py:class:: paddle.incubate.ModelAverage(average_window_rate, parameters=None, min_average_window=10000, max_average_window=10000, name=None)
 
-ModelAverage 优化器，在训练过程中累积特定连续的历史 ``Parameters``，累积的历史范围可以用传入的 ``average_window`` 参数来控制，在预测时使用平均后的 ``Parameters``，通常可以提高预测的精度。
+ModelAverage 优化器，在训练过程中累积特定连续的历史  ``Parameters`` ，累积的历史范围可以用传入的  ``average_window``  参数来控制，在预测时使用平均后的  ``Parameters`` ，通常可以提高预测的精度。
 
-在滑动窗口中累积 ``Parameters`` 的平均值，将结果将保存在临时变量中，通过调用 ``apply()`` 方法可应用于当前模型的 ``Parameters``，使用 ``restore()`` 方法恢复当前模型 ``Parameters`` 的值。
+在滑动窗口中累积  ``Parameters``  的平均值，将结果将保存在临时变量中，通过调用  ``apply()``  方法可应用于当前模型的  ``Parameters`` ，使用  ``restore()``  方法恢复当前模型  ``Parameters``  的值。
 
-计算平均值的窗口大小由 ``average_window_rate`` ， ``min_average_window`` ， ``max_average_window`` 以及当前 ``Parameters`` 更新次数（num_updates）共同决定。
+计算平均值的窗口大小由  ``average_window_rate``  ，  ``min_average_window``  ，  ``max_average_window``  以及当前  ``Parameters``  更新次数（num_updates）共同决定。
 
-累积次数（num_accumulates）大于特定窗口阈值（average_window）时，将累积的 ``Parameters`` 临时变量置为 0.0。
+累积次数（num_accumulates）大于特定窗口阈值（average_window）时，将累积的  ``Parameters``  临时变量置为 0.0。
 
-``num_accumulates`` 表示当前累积的次数，可以抽象理解为累积窗口的长度；窗口长度至少要达到 ``min_average_window`` 参数设定的长度，并且不能超过 ``max_average_window`` 参数或者 ``num_updates`` * ``average_window_rate`` 规定的长度，否则为 0；而其中 ``num_updates`` 表示当前 ``Parameters`` 更新的次数，``average_window_rate`` 是一个计算窗口长度的系数。
+ ``num_accumulates``  表示当前累积的次数，可以抽象理解为累积窗口的长度；窗口长度至少要达到  ``min_average_window``  参数设定的长度，并且不能超过  ``max_average_window``  参数或者  ``num_updates``  *  ``average_window_rate``  规定的长度，否则为 0；而其中  ``num_updates``  表示当前  ``Parameters``  更新的次数， ``average_window_rate``  是一个计算窗口长度的系数。
 
 参数
 :::::::::
-    - **average_window_rate** (float) - 相对于 ``Parameters`` 更新次数的窗口长度计算比率。
-    - **parameters** (list，可选) - 为了最小化 ``loss`` 需要更新的 Tensor 列表。动态图模式下该参数是必需的；静态图模型下该参数的默认值为 None，此时所有参数都会被更新。
+    - **average_window_rate** (float) - 相对于  ``Parameters``  更新次数的窗口长度计算比率。
+    - **parameters** (list，可选) - 为了最小化  ``loss``  需要更新的 Tensor 列表。动态图模式下该参数是必需的；静态图模型下该参数的默认值为 None，此时所有参数都会被更新。
     - **min_average_window** (int，可选) - 平均值计算窗口长度的最小值，默认值为 10000。
     - **max_average_window** (int，可选) - 平均值计算窗口长度的最大值，默认值为 10000。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
@@ -34,19 +34,19 @@ COPY-FROM: paddle.incubate.ModelAverage
 minimize(loss, startup_program=None, parameters=None, no_grad_set=None)
 '''''''''
 
-通过更新 ``Parameters`` 来最小化 ``loss`` 的方法。
+通过更新  ``Parameters``  来最小化  ``loss``  的方法。
 
 **参数**
 
     - **loss** (Tensor) - 一个包含需要最小化的损失值变量的 Tensor。
-    - **startup_program** (Program，可选) - 用于初始化 ``Parameters`` 中参数的 ``Program``，默认值为 None，此时将使用 ``default_startup_program``。
-    - **parameters** (list，可选) - 待更新的 ``Parameters`` 或者 ``Parameter.name`` 组成的列表，默认值为 None，此时将更新所有的 ``Parameters``。
-    - **no_grad_set** (set，可选) - 不需要更新的 ``Parameters`` 或者 ``Parameter.name`` 组成的集合，默认值为 None。
+    - **startup_program** (Program，可选) - 用于初始化  ``Parameters``  中参数的  ``Program`` ，默认值为 None，此时将使用  ``default_startup_program`` 。
+    - **parameters** (list，可选) - 待更新的  ``Parameters``  或者  ``Parameter.name``  组成的列表，默认值为 None，此时将更新所有的  ``Parameters`` 。
+    - **no_grad_set** (set，可选) - 不需要更新的  ``Parameters``  或者  ``Parameter.name``  组成的集合，默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 **返回**
 
-tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由 (param, param_grad) 组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。该返回值可以加入到 ``Executor.run()`` 接口的 ``fetch_list`` 参数中，若加入，则会重写 ``use_prune`` 参数为 True，并根据 ``feed`` 和 ``fetch_list`` 进行剪枝，详见 ``Executor`` 的文档。
+tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由 (param, param_grad) 组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。该返回值可以加入到  ``Executor.run()``  接口的  ``fetch_list``  参数中，若加入，则会重写  ``use_prune``  参数为 True，并根据  ``feed``  和  ``fetch_list``  进行剪枝，详见  ``Executor``  的文档。
 
 **代码示例**
 
@@ -70,12 +70,12 @@ COPY-FROM: paddle.incubate.ModelAverage.step
 apply(executor=None, need_restore=True)
 '''''''''
 
-将累积 ``Parameters`` 的平均值应用于当前网络的 ``Parameters``。
+将累积  ``Parameters``  的平均值应用于当前网络的  ``Parameters`` 。
 
 **参数**
 
     - **executor** (Executor) - 静态图模式下当前网络的执行器；动态图模式下默认值为 None。
-    - **need_restore** (bool) - 恢复标志变量；设为 True 时，执行完成后会将网络的 ``Parameters``恢复为网络默认的值，设为 False 将不会恢复。默认值为 True。
+    - **need_restore** (bool) - 恢复标志变量；设为 True 时，执行完成后会将网络的  ``Parameters`` 恢复为网络默认的值，设为 False 将不会恢复。默认值为 True。
 
 **代码示例**
 
@@ -85,7 +85,7 @@ COPY-FROM: paddle.incubate.ModelAverage.apply
 restore(executor=None)
 '''''''''
 
-恢复当前网络的 ``Parameters`` 值。
+恢复当前网络的  ``Parameters``  值。
 
 **参数**
 
diff --git a/docs/api/paddle/incubate/autograd/Hessian_cn.rst b/docs/api/paddle/incubate/autograd/Hessian_cn.rst
index 8c6df2de5fd..2dead1a4f4e 100644
--- a/docs/api/paddle/incubate/autograd/Hessian_cn.rst
+++ b/docs/api/paddle/incubate/autograd/Hessian_cn.rst
@@ -5,20 +5,20 @@ Hessian
 
 .. py:class:: paddle.incubate.autograd.Hessian(func, xs, is_batched=False)
 
-计算函数 ``func`` 在 ``xs`` 处的海森矩阵。
+计算函数  ``func``  在  ``xs``  处的海森矩阵。
 
-其中，函数 ``func`` 的输入可以为 Tensor 或 Tensor 序列，输出要求为只包含单个元素的 Tensor,
-``is_batched`` 表示是否支持 batch, ``True`` 表示支持并默认第零维作为 batch 维。
+其中，函数  ``func``  的输入可以为 Tensor 或 Tensor 序列，输出要求为只包含单个元素的 Tensor,
+ ``is_batched``  表示是否支持 batch,  ``True``  表示支持并默认第零维作为 batch 维。
 
 在计算海森矩阵时，所有输入 Tensor 会沿着 batch 维外的其它维度进行展平，且当输入为 Tensor 序列时，
-所有展平后的 Tensor 会被拼接成一个新的 Tensor。因此，``Hessian`` 最终的输出为一个二维（不包含
+所有展平后的 Tensor 会被拼接成一个新的 Tensor。因此， ``Hessian``  最终的输出为一个二维（不包含
 batch）或三维（包含 batch，第零维为 batch）的 Tensor。
 
-例如，假设 ``is_batched=True``，输入 Tensor 经过展平并拼接后的形状为 ``(B, M)``，输出
-Tensor 形状为 ``(B, 1)``，则最终输出海森矩阵形状为 ``(B, M, M)``。其中，``B`` 为 batch
-维大小，``M`` 为展平并拼接后的输入大小。
+例如，假设  ``is_batched=True`` ，输入 Tensor 经过展平并拼接后的形状为  ``(B, M)`` ，输出
+Tensor 形状为  ``(B, 1)`` ，则最终输出海森矩阵形状为  ``(B, M, M)`` 。其中， ``B``  为 batch
+维大小， ``M``  为展平并拼接后的输入大小。
 
-可以通过对 ``Hessian`` 对象多维索引获取整个矩阵或子矩阵的实际结果，子矩阵会以惰性求值方式计算，
+可以通过对  ``Hessian``  对象多维索引获取整个矩阵或子矩阵的实际结果，子矩阵会以惰性求值方式计算，
 并且已经计算结果会被缓存，详细参考 :ref:`cn_api_paddle_incubate_autograd_Jacobian` 。
 
 .. note::
@@ -30,18 +30,18 @@ Tensor 形状为 ``(B, 1)``，则最终输出海森矩阵形状为 ``(B, M, M)``
 参数
 :::::::::
 
-- **func** (Callable) - Python 函数，输入参数为 ``xs``，输出为只包含一个元素 Tensor，即
-  如果 ``is_batched=True``，输出形状为 ``(B, 1)`` , ``B`` 表示 batch 大小，
-  ``is_batched=False``，输出形状为 ``(1)`` 。
-- **xs** (Tensor|Sequence[Tensor]) - 函数 ``func`` 的输入参数，数据类型为 Tensor 或
+- **func** (Callable) - Python 函数，输入参数为  ``xs`` ，输出为只包含一个元素 Tensor，即
+  如果  ``is_batched=True`` ，输出形状为  ``(B, 1)``  ,  ``B``  表示 batch 大小，
+   ``is_batched=False`` ，输出形状为  ``(1)``  。
+- **xs** (Tensor|Sequence[Tensor]) - 函数  ``func``  的输入参数，数据类型为 Tensor 或
   Tensor 序列。
-- **is_batched** (bool) - ``True`` 表示包含 batch 维，且默认第零维为 batch 维，``False``
-  表示不包含 batch。默认值为 ``False`` 。
+- **is_batched** (bool) -  ``True``  表示包含 batch 维，且默认第零维为 batch 维， ``False`` 
+  表示不包含 batch。默认值为  ``False``  。
 
 返回
 :::::::::
 
-用于计算海森矩阵的 ``Hessian`` 实例。
+用于计算海森矩阵的  ``Hessian``  实例。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/incubate/autograd/Jacobian_cn.rst b/docs/api/paddle/incubate/autograd/Jacobian_cn.rst
index e0c3093f9a4..509ea608bc3 100644
--- a/docs/api/paddle/incubate/autograd/Jacobian_cn.rst
+++ b/docs/api/paddle/incubate/autograd/Jacobian_cn.rst
@@ -5,26 +5,26 @@ Jacobian
 
 .. py:class:: paddle.incubate.autograd.Jacobian(func, xs, is_batched=False)
 
-计算函数 ``func`` 在 ``xs`` 处的雅可比矩阵。
+计算函数  ``func``  在  ``xs``  处的雅可比矩阵。
 
-其中，函数 ``func`` 的输入、输出可以为 Tensor 或 Tensor 序列，``is_batched=True`` 表示是否支
-持 batch, ``True`` 表示输入和输出的第零维是 batch。
+其中，函数  ``func``  的输入、输出可以为 Tensor 或 Tensor 序列， ``is_batched=True``  表示是否支
+持 batch,  ``True``  表示输入和输出的第零维是 batch。
 
 在计算雅可比矩阵时，输入 Tensor batch 维外的其它维度会被展平，且当输入为 Tensor 序列时，
-所有展平后的 Tensor 会被拼接成一个新的 Tensor。输出按照同样规则进行处理。因此，``Jacobian`` 最终
+所有展平后的 Tensor 会被拼接成一个新的 Tensor。输出按照同样规则进行处理。因此， ``Jacobian``  最终
 的输出为一个二维（不包含 batch）或三维（包含 batch，第零维为 batch）的 Tensor。
 
-例如，假设 ``is_batched=True``，输入 Tensor 经过展平并拼接后的形状为 ``(B, M)``，输出
-Tensor 经过展平并拼接后的形状为 ``(B, N)``，则最终输出雅可比矩阵形状为 ``(B, M, N)`` 。
-其中，``B`` 为 batch 维大小，``M`` 为展平并拼接后的输入大小，``N`` 为展平并拼接后的输出大小。
+例如，假设  ``is_batched=True`` ，输入 Tensor 经过展平并拼接后的形状为  ``(B, M)`` ，输出
+Tensor 经过展平并拼接后的形状为  ``(B, N)`` ，则最终输出雅可比矩阵形状为  ``(B, M, N)``  。
+其中， ``B``  为 batch 维大小， ``M``  为展平并拼接后的输入大小， ``N``  为展平并拼接后的输出大小。
 
-``Jacobian`` 对象被创建后，并没有发生实际的计算过程，而是采用惰性求值方法进行计算，可以通过
-对 ``Jacobian`` 多维索引获取整个雅可比矩阵或子矩阵的实际结果，并且实际计算也发生在这一过程，已
+ ``Jacobian``  对象被创建后，并没有发生实际的计算过程，而是采用惰性求值方法进行计算，可以通过
+对  ``Jacobian``  多维索引获取整个雅可比矩阵或子矩阵的实际结果，并且实际计算也发生在这一过程，已
 经计算的子矩阵也会被缓存以避免重复计算。
 
-例如，假设 ``Jacobian`` 的实例 ``J`` 形状为 ``(B, M, N)``，假设 ``M>4`` ,
-则 ``J[:, 1:4:1, :]`` 表示获取 ``J`` 的第 ``1`` 行到第 ``3`` 行值，实际计算时，仅会对
-第 ``1`` 行到第 ``3`` 进行求值，并且 ``1`` 到 ``3`` 行的计算结果会以行的粒度进行缓存，下次再
+例如，假设  ``Jacobian``  的实例  ``J``  形状为  ``(B, M, N)`` ，假设  ``M>4``  ,
+则  ``J[:, 1:4:1, :]``  表示获取  ``J``  的第  ``1``  行到第  ``3``  行值，实际计算时，仅会对
+第  ``1``  行到第  ``3``  进行求值，并且  ``1``  到  ``3``  行的计算结果会以行的粒度进行缓存，下次再
 获取上述某一行或多行结果时不会发生重复计算。
 
 更多索引方式可以参考 Paddle 官网 `索引和切片 <https://www.paddlepaddle.org.cn/documentation/docs/zh/guides/01_paddle2.0_introduction/basic_concept/tensor_introduction_cn.html#suoyinheqiepian>`_ 。
@@ -38,16 +38,16 @@ Tensor 经过展平并拼接后的形状为 ``(B, N)``，则最终输出雅可
 参数
 :::::::::
 
-- **func** (Callable) - Python 函数，输入参数为 ``xs``，输出为 Tensor 或 Tensor 序列。
-- **xs** (Tensor|Sequence[Tensor]) - 函数 ``func`` 的输入参数，数据类型为 Tensor 或
+- **func** (Callable) - Python 函数，输入参数为  ``xs`` ，输出为 Tensor 或 Tensor 序列。
+- **xs** (Tensor|Sequence[Tensor]) - 函数  ``func``  的输入参数，数据类型为 Tensor 或
   Tensor 序列。
-- **is_batched** (bool) - ``True`` 表示包含 batch 维，且默认第零维为 batch 维，``False``
-  表示不包含 batch。默认值为 ``False`` 。
+- **is_batched** (bool) -  ``True``  表示包含 batch 维，且默认第零维为 batch 维， ``False`` 
+  表示不包含 batch。默认值为  ``False``  。
 
 返回
 :::::::::
 
-用于计算雅可比矩阵的 ``Jacobian`` 实例。
+用于计算雅可比矩阵的  ``Jacobian``  实例。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/incubate/autograd/Overview_cn.rst b/docs/api/paddle/incubate/autograd/Overview_cn.rst
index 8dc4000f5f2..6e756076995 100644
--- a/docs/api/paddle/incubate/autograd/Overview_cn.rst
+++ b/docs/api/paddle/incubate/autograd/Overview_cn.rst
@@ -3,7 +3,7 @@
 paddle.incubate.autograd
 _________________________
 
-``paddle.incubate.autograd`` 提供支持高阶的反向及前向自动微分相关 API，是飞桨框架对高阶自动微分进行探索与升级。当前处于孵化状态，API 签名及相关功能可能会发生变化，功能尚不完善，如果想自行实现相关模型、探索自动微分机制，请仔细阅读下述使用方法及使用限制。
+ ``paddle.incubate.autograd``  提供支持高阶的反向及前向自动微分相关 API，是飞桨框架对高阶自动微分进行探索与升级。当前处于孵化状态，API 签名及相关功能可能会发生变化，功能尚不完善，如果想自行实现相关模型、探索自动微分机制，请仔细阅读下述使用方法及使用限制。
 
 
 .. _autograd_recommended_usage:
@@ -11,7 +11,7 @@ _________________________
 推荐用法
 ::::::::::::::::::::
 
-第一步：导入依赖。使用 ``paddle.incubate.autograd.enable_prim()`` 打开自动微分开关。
+第一步：导入依赖。使用  ``paddle.incubate.autograd.enable_prim()``  打开自动微分开关。
 
 ..  code-block:: python
 
@@ -22,7 +22,7 @@ _________________________
         paddle.incubate.autograd.enable_prim()
 
 
-第二步：编写组网代码。以单层的全联接网络为例，``MyNet`` 继承自 ``paddle.nn.Layer`` ，在 ``__init__`` 方法中初始化网络参数，在 ``forward`` 方法中实现前向运行逻辑。注意，当前自动微分仅支持部分飞桨 API，主要覆盖全联接网络和一些激活函数，当前支持的飞桨 API 列表参考 :ref:`支持的飞桨 API <autograd_supported_api>`。
+第二步：编写组网代码。以单层的全联接网络为例， ``MyNet``  继承自  ``paddle.nn.Layer``  ，在  ``__init__``  方法中初始化网络参数，在  ``forward``  方法中实现前向运行逻辑。注意，当前自动微分仅支持部分飞桨 API，主要覆盖全联接网络和一些激活函数，当前支持的飞桨 API 列表参考 :ref:`支持的飞桨 API <autograd_supported_api>`。
 
 ..  code-block:: python
 
@@ -48,7 +48,7 @@ _________________________
         y = net(x)
 
 
-第四步：计算 Loss 并进行优化。为了演示高阶微分用法，此处 Loss 定义中使用了 ``paddle.incubate.autograd.grad`` API 计算 ``y`` 对 ``x`` 二阶微分，使用 L2 norm 归一化，然后用 Adam 优化器进行优化。
+第四步：计算 Loss 并进行优化。为了演示高阶微分用法，此处 Loss 定义中使用了  ``paddle.incubate.autograd.grad``  API 计算  ``y``  对  ``x``  二阶微分，使用 L2 norm 归一化，然后用 Adam 优化器进行优化。
 目前已支持高阶的反向微分和前向微分，相关 API 列表参考 :ref:`自动微分 API <autograd_apis>` 。
 
 ..  code-block:: python
diff --git a/docs/api/paddle/incubate/autograd/jvp_cn.rst b/docs/api/paddle/incubate/autograd/jvp_cn.rst
index 01949eb9c32..e4425355592 100644
--- a/docs/api/paddle/incubate/autograd/jvp_cn.rst
+++ b/docs/api/paddle/incubate/autograd/jvp_cn.rst
@@ -5,7 +5,7 @@ jvp
 
 .. py:function:: paddle.incubate.autograd.jvp(func, xs, v=None)
 
-计算函数 ``func`` 在 ``xs`` 处的雅可比矩阵与向量 ``v`` 的乘积。
+计算函数  ``func``  在  ``xs``  处的雅可比矩阵与向量  ``v``  的乘积。
 
 .. warning::
   该 API 目前为 Beta 版本，函数签名在未来版本可能发生变化。
@@ -13,18 +13,18 @@ jvp
 参数
 :::::::::
 
-- **func** (Callable) - Python 函数，输入参数为 ``xs``，输出为 Tensor 或 Tensor 序列。
-- **xs** (Tensor|Sequence[Tensor]） - 函数 ``func`` 的输入参数，数据类型为 Tensor 或
+- **func** (Callable) - Python 函数，输入参数为  ``xs`` ，输出为 Tensor 或 Tensor 序列。
+- **xs** (Tensor|Sequence[Tensor]） - 函数  ``func``  的输入参数，数据类型为 Tensor 或
   Tensor 序列。
-- **v** (Tensor|Sequence[Tensor]|None，可选) - 用于计算 ``jvp`` 的输入向量，形状要求
-  与 ``xs`` 一致。默认值为 ``None``，即相当于形状与 ``xs`` 一致，值全为 1 的 Tensor 或
+- **v** (Tensor|Sequence[Tensor]|None，可选) - 用于计算  ``jvp``  的输入向量，形状要求
+  与  ``xs``  一致。默认值为  ``None`` ，即相当于形状与  ``xs``  一致，值全为 1 的 Tensor 或
   Tensor 序列。
 
 返回
 :::::::::
 
-- **func_out** (Tensor|tuple[Tensor]) - 函数 ``func(xs)`` 的输出。
-- **jvp** (Tensor|tuple[Tensor]) - ``jvp`` 计算结果。
+- **func_out** (Tensor|tuple[Tensor]) - 函数  ``func(xs)``  的输出。
+- **jvp** (Tensor|tuple[Tensor]) -  ``jvp``  计算结果。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/incubate/autograd/vjp_cn.rst b/docs/api/paddle/incubate/autograd/vjp_cn.rst
index a6758cb3291..b85ee35a037 100644
--- a/docs/api/paddle/incubate/autograd/vjp_cn.rst
+++ b/docs/api/paddle/incubate/autograd/vjp_cn.rst
@@ -5,7 +5,7 @@ vjp
 
 .. py:function:: paddle.incubate.autograd.vjp(func, xs, v=None)
 
-计算向量 ``v`` 与函数 ``func`` 在 ``xs`` 处的雅可比矩阵乘积。
+计算向量  ``v``  与函数  ``func``  在  ``xs``  处的雅可比矩阵乘积。
 
 .. warning::
   该 API 目前为 Beta 版本，函数签名在未来版本可能发生变化。
@@ -13,18 +13,18 @@ vjp
 参数
 :::::::::
 
-- **func** (Callable) - Python 函数，输入参数为 ``xs``，输出为 Tensor 或 Tensor 序列。
-- **xs** (Tensor|Sequence[Tensor]） - 函数 ``func`` 的输入参数，数据类型为 Tensor 或
+- **func** (Callable) - Python 函数，输入参数为  ``xs`` ，输出为 Tensor 或 Tensor 序列。
+- **xs** (Tensor|Sequence[Tensor]） - 函数  ``func``  的输入参数，数据类型为 Tensor 或
   Tensor 序列。
-- **v** (Tensor|Sequence[Tensor]|None，可选) - 用于计算 ``vjp`` 输入向量，形状要求与
-  函数 ``func`` 的输出一致。默认值为 ``None``，此时相当于形状与 ``func`` 输出一致，值全为
+- **v** (Tensor|Sequence[Tensor]|None，可选) - 用于计算  ``vjp``  输入向量，形状要求与
+  函数  ``func``  的输出一致。默认值为  ``None`` ，此时相当于形状与  ``func``  输出一致，值全为
   1 的 Tensor 或 Tensor 序列。
 
 返回
 :::::::::
 
-- **func_out** (Tensor|tuple[Tensor]) - 函数 ``func(xs)`` 的输出。
-- **vjp** (Tensor|tuple[Tensor]) - ``vjp`` 计算结果。
+- **func_out** (Tensor|tuple[Tensor]) - 函数  ``func(xs)``  的输出。
+- **vjp** (Tensor|tuple[Tensor]) -  ``vjp``  计算结果。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/incubate/graph_khop_sampler_cn.rst b/docs/api/paddle/incubate/graph_khop_sampler_cn.rst
index 47496436c7d..c6b85f31741 100644
--- a/docs/api/paddle/incubate/graph_khop_sampler_cn.rst
+++ b/docs/api/paddle/incubate/graph_khop_sampler_cn.rst
@@ -10,10 +10,10 @@ graph_khop_sampler
 参数
 :::::::::
     - **row** (Tensor) - 输入原始图的 CSC 格式的行信息，数据类型为：int32、int64，形状为[num_edges, 1] 或 [num_edges]。
-    - **colptr** (Tensor) - 输入原始图的 CSC 格式的压缩列信息，数据类型应当与 ``row`` 一致，形状为[num_nodes + 1, 1]或 [num_nodes + 1]。
-    - **input_nodes** (Tensor) - 需进行邻居采样的中心节点信息，数据类型应当与 ``row`` 一致。
+    - **colptr** (Tensor) - 输入原始图的 CSC 格式的压缩列信息，数据类型应当与  ``row``  一致，形状为[num_nodes + 1, 1]或 [num_nodes + 1]。
+    - **input_nodes** (Tensor) - 需进行邻居采样的中心节点信息，数据类型应当与  ``row``  一致。
     - **sample_sizes** (list|tuple) - 表示每一层需要采样的邻居个数，数据类型为 int。
-    - **sorted_eids** (Tensor，可选) - 输入原始图在 CSC 格式下的边编号信息。如果 ``return_eids`` 为 True，则不能为空。数据类型应当与 ``row`` 一致。默认值为 None，表示不需要返回边编号信息。
+    - **sorted_eids** (Tensor，可选) - 输入原始图在 CSC 格式下的边编号信息。如果  ``return_eids``  为 True，则不能为空。数据类型应当与  ``row``  一致。默认值为 None，表示不需要返回边编号信息。
     - **return_eids** (bool) - 是否返回采样后对应的原始边编号信息，默认为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
@@ -22,8 +22,8 @@ graph_khop_sampler
     - edge_src (Tensor) - 返回采样后重索引的边对应的源节点信息。
     - edge_dst (Tensor) - 返回采样后重索引的边对应的目标节点信息。
     - sample_index (Tensor) - 返回去重后的输入中心节点信息和邻居信息，且为原始编号。
-    - reindex_nodes (Tensor) - 返回输入中心节点在 ``sample_index`` 中的下标索引位置。
-    - edge_eids (Tensor) - 如果 ``return_eids`` 为 True，则会返回采样边对应的编号信息，否则不返回。
+    - reindex_nodes (Tensor) - 返回输入中心节点在  ``sample_index``  中的下标索引位置。
+    - edge_eids (Tensor) - 如果  ``return_eids``  为 True，则会返回采样边对应的编号信息，否则不返回。
 
 
 代码示例
diff --git a/docs/api/paddle/incubate/graph_reindex_cn.rst b/docs/api/paddle/incubate/graph_reindex_cn.rst
index 12566098238..b3ed83087b6 100644
--- a/docs/api/paddle/incubate/graph_reindex_cn.rst
+++ b/docs/api/paddle/incubate/graph_reindex_cn.rst
@@ -36,8 +36,8 @@ graph_reindex
     - **x** (Tensor) - 输入的中心节点原始编号，数据类型为：int32、int64。
     - **neighbors** (Tensor) - 中心节点的邻居节点编号，数据类型为：int32、int64。
     - **count** (Tensor) - 中心节点各自的邻居数目，数据类型为：int32。
-    - **value_buffer** (Tensor，可选) - 用于快速哈希索引的缓存 Tensor，可加速重编号过程。数据类型为 int32，并且应当事先填充为-1。如果 ``flag_buffer_hashtable`` 为 True，则不可为空。默认值为 None。
-    - **index_buffer** (Tensor，可选) - 用于快速哈希索引的缓存 Tensor，可加速重编号过程。数据类型为 int32，并且应当事先填充为-1。如果 ``flag_buffer_hashtable`` 为 True，则不可为空。默认值为 None。
+    - **value_buffer** (Tensor，可选) - 用于快速哈希索引的缓存 Tensor，可加速重编号过程。数据类型为 int32，并且应当事先填充为-1。如果  ``flag_buffer_hashtable``  为 True，则不可为空。默认值为 None。
+    - **index_buffer** (Tensor，可选) - 用于快速哈希索引的缓存 Tensor，可加速重编号过程。数据类型为 int32，并且应当事先填充为-1。如果  ``flag_buffer_hashtable``  为 True，则不可为空。默认值为 None。
     - **flag_buffer_hashtable** (bool) - 是否采取快速哈希索引，默认为 False。只适用于 GPU 版本的 API。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/incubate/graph_sample_neighbors_cn.rst b/docs/api/paddle/incubate/graph_sample_neighbors_cn.rst
index 0e0ad6c07d3..72906e4e095 100644
--- a/docs/api/paddle/incubate/graph_sample_neighbors_cn.rst
+++ b/docs/api/paddle/incubate/graph_sample_neighbors_cn.rst
@@ -5,15 +5,15 @@ graph_sample_neighbors
 
 .. py:function:: paddle.incubate.graph_sample_neighbors(row, colptr, input_nodes, eids=None, perm_buffer=None, sample_size=-1, return_eids=False, flag_perm_buffer=False, name=None)
 
-主要应用于图学习领域，主要目的是提供高性能图邻居采样方法。通过输入图的 CSC（Compressed Sparse Column，压缩列信息），分别对应 ``row`` 和 ``colptr``，从而将图转换为适用于邻居采样的格式，再输入需要进行采样的中心节点 ``input_nodes``，以及采样的邻居个数 ``sample_size``，从而可以获得对应中心节点采样后的邻居。另外，在 GPU 版本提供了 Fisher-yates 高性能图采样方法。
+主要应用于图学习领域，主要目的是提供高性能图邻居采样方法。通过输入图的 CSC（Compressed Sparse Column，压缩列信息），分别对应  ``row``  和  ``colptr`` ，从而将图转换为适用于邻居采样的格式，再输入需要进行采样的中心节点  ``input_nodes`` ，以及采样的邻居个数  ``sample_size`` ，从而可以获得对应中心节点采样后的邻居。另外，在 GPU 版本提供了 Fisher-yates 高性能图采样方法。
 
 参数
 :::::::::
     - **row** (Tensor) - 输入原始图的 CSC 格式的行信息，数据类型为：int32、int64，形状为[num_edges, 1] 或 [num_edges]。
-    - **colptr** (Tensor) - 输入原始图的 CSC 格式的压缩列信息，数据类型应当与 ``row`` 一致，形状为[num_nodes + 1, 1]或 [num_nodes + 1]。
-    - **input_nodes** (Tensor) - 需进行邻居采样的中心节点信息，数据类型应当与 ``row`` 一致。
-    - **eids** (Tensor，可选) - 输入原始图在 CSC 格式下的边编号信息。如果 ``return_eids`` 为 True，则不能为空。数据类型应当与 ``row`` 一致。默认为 None，表示不需要返回边编号信息。
-    - **perm_buffer** (Tensor，可选) - Fisher-yates 采样方法需要用到的缓存 Tensor。如果 ``flag_perm_buffer`` 为 True，则不能为空。数据类型应当与 ``row`` 一致，形状为[num_edges]，填充内容为 0 至 num_edges 的顺序递增序列。
+    - **colptr** (Tensor) - 输入原始图的 CSC 格式的压缩列信息，数据类型应当与  ``row``  一致，形状为[num_nodes + 1, 1]或 [num_nodes + 1]。
+    - **input_nodes** (Tensor) - 需进行邻居采样的中心节点信息，数据类型应当与  ``row``  一致。
+    - **eids** (Tensor，可选) - 输入原始图在 CSC 格式下的边编号信息。如果  ``return_eids``  为 True，则不能为空。数据类型应当与  ``row``  一致。默认为 None，表示不需要返回边编号信息。
+    - **perm_buffer** (Tensor，可选) - Fisher-yates 采样方法需要用到的缓存 Tensor。如果  ``flag_perm_buffer``  为 True，则不能为空。数据类型应当与  ``row``  一致，形状为[num_edges]，填充内容为 0 至 num_edges 的顺序递增序列。
     - **sample_size** (int) - 采样邻居个数。默认值为-1，表示采样输入中心节点的所有邻居。
     - **return_eids** (bool) - 是否返回采样后对应的原始边编号信息，默认为 False。
     - **flag_perm_buffer** (bool) - 是否采用 Fisher-yates 采样方法，默认为 False。
@@ -22,8 +22,8 @@ graph_sample_neighbors
 返回
 :::::::::
     - out_neighbors (Tensor) - 返回采样后的邻居节点。
-    - out_count (Tensor) - 返回中心节点各自对应的采样邻居数目，形状应该与 ``input_nodes`` 一致。
-    - out_eids (Tensor) - 如果 ``return_eids`` 为 True，则会返回采样边对应的编号信息，否则不返回。
+    - out_count (Tensor) - 返回中心节点各自对应的采样邻居数目，形状应该与  ``input_nodes``  一致。
+    - out_eids (Tensor) - 如果  ``return_eids``  为 True，则会返回采样边对应的编号信息，否则不返回。
 
 
 代码示例
diff --git a/docs/api/paddle/incubate/graph_send_recv_cn.rst b/docs/api/paddle/incubate/graph_send_recv_cn.rst
index 55dfb3d2bde..68a60915681 100644
--- a/docs/api/paddle/incubate/graph_send_recv_cn.rst
+++ b/docs/api/paddle/incubate/graph_send_recv_cn.rst
@@ -5,7 +5,7 @@ graph_send_recv
 
 .. py:function:: paddle.incubate.graph_send_recv(x, src_index, dst_index, pool_type="sum", out_size=None, name=None)
 
-主要应用于图学习领域，目的是为了减少在消息传递过程中带来的中间变量显存或内存的损耗。其中，``x`` 作为输入 Tensor，首先利用 ``src_index`` 作为索引来 gather 出在 ``x`` 中相应位置的数据，随后再将 gather 出的结果利用 ``dst_index`` 来更新到对应的输出结果中，其中 ``pool_type`` 表示不同的更新方式，包括 sum、mean、max、min 共计 4 种处理模式。另外，提供了 ``out_size`` 参数，用于设置实际输出的形状，有利于减少实际显存占用。
+主要应用于图学习领域，目的是为了减少在消息传递过程中带来的中间变量显存或内存的损耗。其中， ``x``  作为输入 Tensor，首先利用  ``src_index``  作为索引来 gather 出在  ``x``  中相应位置的数据，随后再将 gather 出的结果利用  ``dst_index``  来更新到对应的输出结果中，其中  ``pool_type``  表示不同的更新方式，包括 sum、mean、max、min 共计 4 种处理模式。另外，提供了  ``out_size``  参数，用于设置实际输出的形状，有利于减少实际显存占用。
 
 .. code-block:: text
 
@@ -31,14 +31,14 @@ graph_send_recv
 :::::::::
     - **x** (Tensor) - 输入的 Tensor，数据类型为：float32、float64、int32、int64。
     - **src_index** (Tensor) - 1-D Tensor，数据类型为：int32、int64。
-    - **dst_index** (Tensor) - 1-D Tensor，数据类型为：int32、int64。注意：``dst_index`` 的形状应当与 ``src_index`` 一致。
+    - **dst_index** (Tensor) - 1-D Tensor，数据类型为：int32、int64。注意： ``dst_index``  的形状应当与  ``src_index``  一致。
     - **pool_type** (str) - scatter 结果的不同处理方式，包括 sum、mean、max、min。默认值为 sum。
-    - **out_size** (int64，可选) - 可以通过根据实际需求设置 ``out_size`` 来改变实际输出形状。默认值为 None，表示这个参数将不会被使用。注意，``out_size`` 的值必须等于或大于 ``max(dst_index) + 1`` 。
+    - **out_size** (int64，可选) - 可以通过根据实际需求设置  ``out_size``  来改变实际输出形状。默认值为 None，表示这个参数将不会被使用。注意， ``out_size``  的值必须等于或大于  ``max(dst_index) + 1``  。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-``Tensor``，维度和数据类型都与 ``x`` 相同，存储运算后的结果。
+ ``Tensor`` ，维度和数据类型都与  ``x``  相同，存储运算后的结果。
 
 
 代码示例
diff --git a/docs/api/paddle/incubate/identity_loss_cn.rst b/docs/api/paddle/incubate/identity_loss_cn.rst
index 70395c351cd..7b38ce8ecfd 100644
--- a/docs/api/paddle/incubate/identity_loss_cn.rst
+++ b/docs/api/paddle/incubate/identity_loss_cn.rst
@@ -24,7 +24,7 @@ identity_loss
 ::::::::::::
 
     - **x** (Variable) - 输入 Tensor。维度为[N, \*]的多维 Tensor，其中 N 是批大小，\*表示任何数量的附加维度。数据类型在 CPU 上为 float32 或 float64，在 IPU 上为 float16 或 float32。
-    - **reduction** (str|int，可选) - 指定应用于输出结果的计算方式，可选的 string 值有: ``'sum'``, ``'mean'``, ``'none'`` ，对应的 int 值分别为 0，1，2 。默认为 ``'none'``，直接返回输入 loss 的值。
+    - **reduction** (str|int，可选) - 指定应用于输出结果的计算方式，可选的 string 值有:  ``'sum'`` ,  ``'mean'`` ,  ``'none'``  ，对应的 int 值分别为 0，1，2 。默认为  ``'none'`` ，直接返回输入 loss 的值。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/incubate/nn/FusedFeedForward_cn.rst b/docs/api/paddle/incubate/nn/FusedFeedForward_cn.rst
index b8630276734..660c9aaf4ca 100644
--- a/docs/api/paddle/incubate/nn/FusedFeedForward_cn.rst
+++ b/docs/api/paddle/incubate/nn/FusedFeedForward_cn.rst
@@ -12,15 +12,15 @@ FusedFeedForward
     - **d_model** (int) - 输入输出的维度。
     - **dim_feedforward** (int) - 前馈神经网络中隐藏层的大小。
     - **dropout_rate** (float，可选) - 对本层的输出进行处理的 dropout 值，置零的概率。默认值：0.1。
-    - **activation** (str，可选) - 激活函数。默认值：``relu``。
-    - **act_dropout_rate** (float，可选) - 激活函数后的 dropout 置零的概率。如果为 ``None`` 则  ``act_dropout_rate = dropout_rate``。默认值：``None`` 。
-    - **normalize_before** (bool，可选) - 设置对输入输出的处理。如果为 ``True``，则对输入进行层标准化（Layer Normalization），否则（即为 ``False`` ），则对输入不进行处理，而是在输出前进行标准化。默认值：``False`` 。
-    - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值：``None``，表示使用默认的权重参数属性，即使用 0 进行初始化。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。如果该参数值是 ``ParamAttr``，则使用 ``ParamAttr``。如果该参数为 ``bool`` 类型，只支持为 ``False``，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **activation** (str，可选) - 激活函数。默认值： ``relu`` 。
+    - **act_dropout_rate** (float，可选) - 激活函数后的 dropout 置零的概率。如果为  ``None``  则   ``act_dropout_rate = dropout_rate`` 。默认值： ``None``  。
+    - **normalize_before** (bool，可选) - 设置对输入输出的处理。如果为  ``True`` ，则对输入进行层标准化（Layer Normalization），否则（即为  ``False``  ），则对输入不进行处理，而是在输出前进行标准化。默认值： ``False``  。
+    - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值： ``None`` ，表示使用默认的权重参数属性，即使用 0 进行初始化。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。如果该参数值是  ``ParamAttr`` ，则使用  ``ParamAttr`` 。如果该参数为  ``bool``  类型，只支持为  ``False`` ，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
 
 返回
 :::::::::
-    - Tensor，输出 Tensor，数据类型与 ``x`` 一样。
+    - Tensor，输出 Tensor，数据类型与  ``x``  一样。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/incubate/nn/FusedLinear_cn.rst b/docs/api/paddle/incubate/nn/FusedLinear_cn.rst
index c188ea2aaf7..e6446353d03 100644
--- a/docs/api/paddle/incubate/nn/FusedLinear_cn.rst
+++ b/docs/api/paddle/incubate/nn/FusedLinear_cn.rst
@@ -24,12 +24,12 @@ FusedLinear 层只接受一个 Tensor 作为输入，形状为 :math:`[batch\_si
 weight
 '''''''''
 
-本层的可学习参数，类型为 ``Parameter`` 。
+本层的可学习参数，类型为  ``Parameter``  。
 
 bias
 '''''''''
 
-本层的可学习偏置，类型为 ``Parameter`` 。
+本层的可学习偏置，类型为  ``Parameter``  。
 
 形状
 :::::::::
diff --git a/docs/api/paddle/incubate/nn/FusedMultiHeadAttention_cn.rst b/docs/api/paddle/incubate/nn/FusedMultiHeadAttention_cn.rst
index a4ccf7d36e2..719ef95bc03 100644
--- a/docs/api/paddle/incubate/nn/FusedMultiHeadAttention_cn.rst
+++ b/docs/api/paddle/incubate/nn/FusedMultiHeadAttention_cn.rst
@@ -13,11 +13,11 @@ FusedMultiHeadAttention
 
 细节可参考论文 `Attention is all you need <https://arxiv.org/pdf/1706.03762.pdf>`_ 。
 
-``FusedMultiHeadAttention`` 与已有的 ``MultiHeadAttention`` 有两处不同：
+ ``FusedMultiHeadAttention``  与已有的  ``MultiHeadAttention``  有两处不同：
 
-（1）表达的计算逻辑范围不同。相比 ``MultiHeadAttention`` ， ``FusedMultiHeadAttention`` 的前面在 ``normalize_before=True`` 时，多了 ``layer_norm`` 算子，后面多了 ``residual add`` ， ``dropout`` 和 ``layer_norm`` 的计算。
+（1）表达的计算逻辑范围不同。相比  ``MultiHeadAttention``  ，  ``FusedMultiHeadAttention``  的前面在  ``normalize_before=True``  时，多了  ``layer_norm``  算子，后面多了  ``residual add``  ，  ``dropout``  和  ``layer_norm``  的计算。
 
-（2）q, k, v 的 weight 的存储格式不同。``MultiHeadAttention`` 将 q, k, v 的 weight 存储在三个 Tensor 中。``FusedMultiHeadAttention`` 的 q, k, v 的 weight 被统一存在一个权重 Tensor 中，其维度为 ``[3, num_heads, head_dim, embed_dim]`` ，当开启 ``transpose_qkv_wb`` 后，其维度为 ``[embed_dim, 3 * embed_dim]``。
+（2）q, k, v 的 weight 的存储格式不同。 ``MultiHeadAttention``  将 q, k, v 的 weight 存储在三个 Tensor 中。 ``FusedMultiHeadAttention``  的 q, k, v 的 weight 被统一存在一个权重 Tensor 中，其维度为  ``[3, num_heads, head_dim, embed_dim]``  ，当开启  ``transpose_qkv_wb``  后，其维度为  ``[embed_dim, 3 * embed_dim]`` 。
 
 参数
 :::::::::
@@ -25,27 +25,27 @@ FusedMultiHeadAttention
     - **num_heads** (int) - 多头注意力机制的 Head 数量。
     - **dropout_rate** (float，可选) - Multi-Head Attention 后面的 dropout 算子的注意力目标的随机失活率。0 表示进行 dropout 计算。默认值：0.5。
     - **attn_dropout_rate** (float，可选) - Multi-Head Attention 中的 dropout 算子的注意力目标的随机失活率。0 表示不进行 dropout 计算。默认值：0.5。
-    - **kdim** (int，可选) - 键值对中 key 的维度。如果为 ``None`` 则 ``kdim = embed_dim``。默认值 ``None`` 。
-    - **vdim** (int，可选) - 键值对中 value 的维度。如果为 ``None`` 则 ``vdim = embed_dim``。默认值：``None`` 。
-    - **normalize_before** (bool，可选) - 是 pre_layer_norm 结构（True）还是 post_layer_norm 结构（False）。pre_layer_norm 结构中，``layer_norm`` 算子位于 multi-head attention 和 ffn 的前面，post_layer_norm 结构中，``layer_norm`` 位于两者的后面。默认值：``False`` 。
-    - **need_weights** (bool，可选) - 表明是否返回注意力权重。默认值：``False`` 。
-    - **qkv_weight_attr** (ParamAttr，可选) - 为 Attention 中计算 q, k, v 时的计算指定权重参数属性的对象。默认值：``None``，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **qkv_bias_attr** (ParamAttr，可选) - 为 Attention 中计算 q, k, v 时的计算指定偏置参数属性的对象。默认值：``None``，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **linear_weight_attr** (ParamAttr，可选) - 为 Multi-Head Attention 之后的线性计算指定权重参数属性的对象。默认值：``None``，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **linear_bias_attr** (ParamAttr，可选) - 为 Multi-Head Attention 之后的线性计算指定偏置参数属性的对象。默认值：``None``，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **pre_ln_scale_attr** (ParamAttr，可选) - 为 pre_layer_norm 结构的前置 layer norm 计算指定权重参数属性的对象。默认值：``None``，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **pre_ln_bias_attr** (ParamAttr，可选) - 为 pre_layer_norm 结构的前置 layer norm 计算指定偏置参数属性的对象。默认值：``None``，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **ln_scale_attr** (ParamAttr，可选) - 为 post_layer_norm 结构的后置 layer norm 计算指定权重参数属性的对象。默认值：``None``，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **ln_bias_attr** (ParamAttr，可选) - 为 post_layer_norm 结构的前置 layer norm 计算指定偏置参数属性的对象。默认值：``None``，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **kdim** (int，可选) - 键值对中 key 的维度。如果为  ``None``  则  ``kdim = embed_dim`` 。默认值  ``None``  。
+    - **vdim** (int，可选) - 键值对中 value 的维度。如果为  ``None``  则  ``vdim = embed_dim`` 。默认值： ``None``  。
+    - **normalize_before** (bool，可选) - 是 pre_layer_norm 结构（True）还是 post_layer_norm 结构（False）。pre_layer_norm 结构中， ``layer_norm``  算子位于 multi-head attention 和 ffn 的前面，post_layer_norm 结构中， ``layer_norm``  位于两者的后面。默认值： ``False``  。
+    - **need_weights** (bool，可选) - 表明是否返回注意力权重。默认值： ``False``  。
+    - **qkv_weight_attr** (ParamAttr，可选) - 为 Attention 中计算 q, k, v 时的计算指定权重参数属性的对象。默认值： ``None`` ，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **qkv_bias_attr** (ParamAttr，可选) - 为 Attention 中计算 q, k, v 时的计算指定偏置参数属性的对象。默认值： ``None`` ，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **linear_weight_attr** (ParamAttr，可选) - 为 Multi-Head Attention 之后的线性计算指定权重参数属性的对象。默认值： ``None`` ，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **linear_bias_attr** (ParamAttr，可选) - 为 Multi-Head Attention 之后的线性计算指定偏置参数属性的对象。默认值： ``None`` ，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **pre_ln_scale_attr** (ParamAttr，可选) - 为 pre_layer_norm 结构的前置 layer norm 计算指定权重参数属性的对象。默认值： ``None`` ，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **pre_ln_bias_attr** (ParamAttr，可选) - 为 pre_layer_norm 结构的前置 layer norm 计算指定偏置参数属性的对象。默认值： ``None`` ，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **ln_scale_attr** (ParamAttr，可选) - 为 post_layer_norm 结构的后置 layer norm 计算指定权重参数属性的对象。默认值： ``None`` ，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **ln_bias_attr** (ParamAttr，可选) - 为 post_layer_norm 结构的前置 layer norm 计算指定偏置参数属性的对象。默认值： ``None`` ，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **epsilon** (float，可选) - 为了数值稳定加在分母上的值。默认值：1e-05。
     - **nranks** (int，可选) - 分布式 tensor parallel 运行下该策略的并行度。默认值：-1，表示不使用 tensor parallel。
     - **ring_id** (int，可选) - 分布式 tensor parallel 运行下通讯所使用的 NCCL id。默认值：-1，表示不使用 tensor parallel。
-    - **transpose_qkv_wb** (bool，可选) - 生成 QKV 的映射计算的权重形状为 ``[3, num_heads, head_dim, embed_dim]`` (False) 还是 ``[embed_dim, 3 * embed_dim]`` (True)。仅支持 GPU 运算。默认值：``False``。
+    - **transpose_qkv_wb** (bool，可选) - 生成 QKV 的映射计算的权重形状为  ``[3, num_heads, head_dim, embed_dim]``  (False) 还是  ``[embed_dim, 3 * embed_dim]``  (True)。仅支持 GPU 运算。默认值： ``False`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
 :::::::::
-    - **x** (Tensor)：默认形状为 ``[batch_size, sequence_length, embed_dim]``，其数据类型为 float32，float64 或者 float16。
+    - **x** (Tensor)：默认形状为  ``[batch_size, sequence_length, embed_dim]`` ，其数据类型为 float32，float64 或者 float16。
     - **output** (Tensor)：其形状和数据类型与输入 x 相同。
 
 返回
diff --git a/docs/api/paddle/incubate/nn/FusedTransformerEncoderLayer_cn.rst b/docs/api/paddle/incubate/nn/FusedTransformerEncoderLayer_cn.rst
index 1061e356443..249deedd59e 100644
--- a/docs/api/paddle/incubate/nn/FusedTransformerEncoderLayer_cn.rst
+++ b/docs/api/paddle/incubate/nn/FusedTransformerEncoderLayer_cn.rst
@@ -5,7 +5,7 @@ FusedTransformerEncoderLayer
 .. py:class:: paddle.incubate.nn.FusedTransformerEncoderLayer(d_model, nhead, dim_feedforward, dropout_rate=0.1, activation='relu', attn_dropout_rate=None, act_dropout_rate=None, normalize_before=False, weight_attr=None, bias_attr=None)
 
 
-FusedTransformer 编码器层由两个子层组成：多头自注意力机制和前馈神经网络。如果 ``normalize_before`` 为 ``True``，则对每个子层的输入进行层标准化（Layer Normalization），对每个子层的输出进行 dropout 和残差连接（residual connection）。否则（即 ``normalize_before`` 为 ``False`` ），则对每个子层的输入不进行处理，只对每个子层的输出进行 dropout、残差连接（residual connection）和层标准化（Layer Normalization）。
+FusedTransformer 编码器层由两个子层组成：多头自注意力机制和前馈神经网络。如果  ``normalize_before``  为  ``True`` ，则对每个子层的输入进行层标准化（Layer Normalization），对每个子层的输出进行 dropout 和残差连接（residual connection）。否则（即  ``normalize_before``  为  ``False``  ），则对每个子层的输入不进行处理，只对每个子层的输出进行 dropout、残差连接（residual connection）和层标准化（Layer Normalization）。
 
 
 参数
@@ -14,17 +14,17 @@ FusedTransformer 编码器层由两个子层组成：多头自注意力机制和
     - **nhead** (int) - multi-head attention（MHA）的 Head 数量。
     - **dim_feedforward** (int) - 前馈神经网络中隐藏层的大小。
     - **dropout_rate** (float，可选) - 对两个子层的输出进行处理的 dropout 值，置零的概率。默认值：0.1。
-    - **activation** (str，可选) - 前馈神经网络的激活函数。默认值：``relu``。
-    - **attn_dropout_rate** (float，可选) - MHA 中对注意力目标的随机失活率。如果为 `None` 则 ``attn_dropout = dropout``。默认值：``None`` 。
-    - **act_dropout_rate** (float，可选) - 前馈神经网络的激活函数后的 dropout 置零的概率。如果为 ``None`` 则 ``act_dropout_rate = dropout_rate``。默认值：``None`` 。
-    - **normalize_before** (bool，可选) - 设置对每个子层的输入输出的处理。如果为 ``True``，则对每个子层的输入进行层标准化（Layer Normalization），否则（即为 ``False`` ），则对每个子层的输入不进行处理，而是在子层的输出前进行标准化。默认值：``False`` 。
-    - **weight_attr** (ParamAttr|tuple，可选) - 指定权重参数属性的对象。如果是 ``tuple`` ，MHA 的权重参数属性使用 ``weight_attr[0]``，前馈神经网络的权重参数属性使用 ``weight_attr[1]``。如果参数值是 ``ParamAttr``，则 MHA 和前馈神经网络的权重参数属性都使用 ``ParamAttr``。默认值：``None``，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** （ParamAttr|tuple|bool，可选）- 指定偏置参数属性的对象。如果是 ``tuple`` ，MHA 的偏置参数属性使用 ``bias_attr[0]``，前馈神经网络的偏置参数属性使用 ``bias_attr[1]``。如果该参数值是 ``ParamAttr``，则 MHA 和前馈神经网络的偏置参数属性都使用 ``ParamAttr``。如果该参数为 ``bool`` 类型，只支持为 ``False``，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **activation** (str，可选) - 前馈神经网络的激活函数。默认值： ``relu`` 。
+    - **attn_dropout_rate** (float，可选) - MHA 中对注意力目标的随机失活率。如果为 `None` 则  ``attn_dropout = dropout`` 。默认值： ``None``  。
+    - **act_dropout_rate** (float，可选) - 前馈神经网络的激活函数后的 dropout 置零的概率。如果为  ``None``  则  ``act_dropout_rate = dropout_rate`` 。默认值： ``None``  。
+    - **normalize_before** (bool，可选) - 设置对每个子层的输入输出的处理。如果为  ``True`` ，则对每个子层的输入进行层标准化（Layer Normalization），否则（即为  ``False``  ），则对每个子层的输入不进行处理，而是在子层的输出前进行标准化。默认值： ``False``  。
+    - **weight_attr** (ParamAttr|tuple，可选) - 指定权重参数属性的对象。如果是  ``tuple``  ，MHA 的权重参数属性使用  ``weight_attr[0]`` ，前馈神经网络的权重参数属性使用  ``weight_attr[1]`` 。如果参数值是  ``ParamAttr`` ，则 MHA 和前馈神经网络的权重参数属性都使用  ``ParamAttr`` 。默认值： ``None`` ，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** （ParamAttr|tuple|bool，可选）- 指定偏置参数属性的对象。如果是  ``tuple``  ，MHA 的偏置参数属性使用  ``bias_attr[0]`` ，前馈神经网络的偏置参数属性使用  ``bias_attr[1]`` 。如果该参数值是  ``ParamAttr`` ，则 MHA 和前馈神经网络的偏置参数属性都使用  ``ParamAttr`` 。如果该参数为  ``bool``  类型，只支持为  ``False`` ，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
 
 
 返回
 :::::::::
-    - Tensor，输出 Tensor，数据类型与 ``x`` 一样。
+    - Tensor，输出 Tensor，数据类型与  ``x``  一样。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/incubate/nn/functional/fused_feedforward_cn.rst b/docs/api/paddle/incubate/nn/functional/fused_feedforward_cn.rst
index 30c36e8255b..22c95caf4c2 100644
--- a/docs/api/paddle/incubate/nn/functional/fused_feedforward_cn.rst
+++ b/docs/api/paddle/incubate/nn/functional/fused_feedforward_cn.rst
@@ -19,15 +19,15 @@ fused_feedforward
 
 参数
 :::::::::
-    - **x** (Tensor) - 输入 Tensor，数据类型支持 float16， float32 和 float64，输入的形状是 ``[batch_size, sequence_length, d_model]`` 。
-    - **linear1_weight** (Tensor) - 第一个 linear 算子的权重数据，数据类型与 ``x`` 一样，形状是 ``[d_model, dim_feedforward]`` 。
-    - **linear2_weight** (Tensor) - 第二个 linear 算子的权重数据，数据类型与 ``x`` 一样，形状是 ``[dim_feedforward, d_model]`` 。
-    - **linear1_bias** (Tensor，可选) - 第一个 linear 算子的偏置数据，数据类型与 ``x`` 一样，形状是 ``[dim_feedforward]``。默认值为 None。
-    - **linear2_bias** (Tensor，可选) - 第二个 linear 算子的偏置数据，数据类型与 ``x`` 一样，形状是 ``[d_model]``。默认值为 None。
-    - **ln1_scale** (Tensor，可选) - 第一个 layer_norm 算子的权重数据，数据类型可以是 float32 或者 float64，形状和 ``x`` 一样。默认值为 None。
-    - **ln1_bias** (Tensor，可选) - 第一个 layer_norm 算子的偏置数据，数据类型和 ``ln1_scale`` 一样，形状是 ``x.shape[-1]``。默认值为 None。
-    - **ln2_scale** (Tensor，可选) - 第二个 layer_norm 算子的权重数据，数据类型可以是 float32 或者 float64，形状和  ``x`` 一样。默认值为 None。
-    - **ln2_bias** (Tensor，可选) - 第二个 layer_norm 算子的偏置数据，数据类型和 ``ln2_scale`` 一样，形状是 ``x.shape[-1]``。默认值为 None。
+    - **x** (Tensor) - 输入 Tensor，数据类型支持 float16， float32 和 float64，输入的形状是  ``[batch_size, sequence_length, d_model]``  。
+    - **linear1_weight** (Tensor) - 第一个 linear 算子的权重数据，数据类型与  ``x``  一样，形状是  ``[d_model, dim_feedforward]``  。
+    - **linear2_weight** (Tensor) - 第二个 linear 算子的权重数据，数据类型与  ``x``  一样，形状是  ``[dim_feedforward, d_model]``  。
+    - **linear1_bias** (Tensor，可选) - 第一个 linear 算子的偏置数据，数据类型与  ``x``  一样，形状是  ``[dim_feedforward]`` 。默认值为 None。
+    - **linear2_bias** (Tensor，可选) - 第二个 linear 算子的偏置数据，数据类型与  ``x``  一样，形状是  ``[d_model]`` 。默认值为 None。
+    - **ln1_scale** (Tensor，可选) - 第一个 layer_norm 算子的权重数据，数据类型可以是 float32 或者 float64，形状和  ``x``  一样。默认值为 None。
+    - **ln1_bias** (Tensor，可选) - 第一个 layer_norm 算子的偏置数据，数据类型和  ``ln1_scale``  一样，形状是  ``x.shape[-1]`` 。默认值为 None。
+    - **ln2_scale** (Tensor，可选) - 第二个 layer_norm 算子的权重数据，数据类型可以是 float32 或者 float64，形状和   ``x``  一样。默认值为 None。
+    - **ln2_bias** (Tensor，可选) - 第二个 layer_norm 算子的偏置数据，数据类型和  ``ln2_scale``  一样，形状是  ``x.shape[-1]`` 。默认值为 None。
     - **dropout1_rate** (float，可选) - 第一个 dropout 算子置零的概率。默认是 0.5。
     - **dropout2_rate** (float，可选) - 第二个 dropout 算子置零的概率。默认是 0.5。
     - **activation** (string，可选) - 激活函数，当前只支持 relu 和 gelu。默认值是 relu。
@@ -51,7 +51,7 @@ fused_feedforward
 
 返回
 :::::::::
-    - Tensor，输出 Tensor，数据类型与 ``x`` 一样。
+    - Tensor，输出 Tensor，数据类型与  ``x``  一样。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/incubate/nn/functional/fused_layer_norm_cn.rst b/docs/api/paddle/incubate/nn/functional/fused_layer_norm_cn.rst
index 3fefdeb1774..fb03961ef02 100644
--- a/docs/api/paddle/incubate/nn/functional/fused_layer_norm_cn.rst
+++ b/docs/api/paddle/incubate/nn/functional/fused_layer_norm_cn.rst
@@ -13,7 +13,7 @@ fused_layer_norm 算子目前只支持在 GPU 下运行。
 
 参数
 ::::::::::::
-    - **x** (Tensor) - 输入 ``Tensor``。
+    - **x** (Tensor) - 输入  ``Tensor`` 。
     - **norm_weight** (Tensor) - 用于仿射输出的权重张量。
     - **norm_bias** (Tensor) - 用于仿射输出的偏置张量。
     - **epsilon** (float) - 一个小的浮点数，用于避免除以零。
@@ -29,11 +29,11 @@ fused_layer_norm 算子目前只支持在 GPU 下运行。
 
 返回
 ::::::::::::
-输出 ``Tensor``
+输出  ``Tensor`` 
 
 形状
 ::::::::::::
-``Tensor``，形状同 ``x`` 一致。
+ ``Tensor`` ，形状同  ``x``  一致。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/incubate/nn/functional/fused_matmul_bias_cn.rst b/docs/api/paddle/incubate/nn/functional/fused_matmul_bias_cn.rst
index f02378fd47a..9422a347c9b 100644
--- a/docs/api/paddle/incubate/nn/functional/fused_matmul_bias_cn.rst
+++ b/docs/api/paddle/incubate/nn/functional/fused_matmul_bias_cn.rst
@@ -11,8 +11,8 @@ fused_matmul_bias
 
 参数
 ::::::::::::
-- **x** (Tensor) - 第一个输入 ``Tensor``，被乘 ``Tensor``。
-- **y** (Tensor) - 第二个输入 ``Tensor``，被乘 ``Tensor``。其秩必须为 2。
+- **x** (Tensor) - 第一个输入  ``Tensor`` ，被乘  ``Tensor`` 。
+- **y** (Tensor) - 第二个输入  ``Tensor`` ，被乘  ``Tensor`` 。其秩必须为 2。
 - **bias** (Tensor，可选) - 输入的偏置。如果为 None，则不执行偏置加法。否则，偏置将被加到矩阵乘法结果上。默认：None。
 - **transpose_x** (bool，可选) - 是否在乘积运算前转置 :math:`x`。默认：False。
 - **transpose_y** (bool，可选) - 是否在乘积运算前转置 :math:`y`。默认：False。
@@ -20,7 +20,7 @@ fused_matmul_bias
 
 返回
 ::::::::::::
-输出 ``Tensor``
+输出  ``Tensor`` 
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/incubate/nn/functional/fused_multi_head_attention_cn.rst b/docs/api/paddle/incubate/nn/functional/fused_multi_head_attention_cn.rst
index aefe992da37..4ea940dc178 100644
--- a/docs/api/paddle/incubate/nn/functional/fused_multi_head_attention_cn.rst
+++ b/docs/api/paddle/incubate/nn/functional/fused_multi_head_attention_cn.rst
@@ -50,22 +50,22 @@ fused_multi_head_attention 算子目前只支持在 GPU 下运行，其包含的
 ::::::::::::
 
 ::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，代表 Query，是一个三维 tensor，形状为 ``[batch_size, sequence_length, embed_dim]``。其中，batch_size 是一次训练所处理的样本个数（句子个数)；sequence_length 代表每一个样本序列（每句话）中的 word 个数；embed_dim 代表 word 经过 embedding 后得到的向量长度。
-    - **qkv_weight** (Tensor) - 代表 Attention 中计算 q, k, v 时的权重，是一个四维 tensor，当 ``transpose_qkv_wb`` 为 False 时形状为 ``[3, num_heads, head_dim, embed_dim]``。其中，3 代表 qkv_weight 是包含了 q, k, v 三个权重矩阵，num_heads 代表 multi-head attention 中的 head 数量，head_dim 代表 head 的维度。当 ``transpose_qkv_wb`` 为 True 时形状为 ``[embed_dim， 3 * embed_dim]``。
-    - **linear_weight** (Tensor) - 代表 linear 的权重，二维 tensor，形状为 ``[embed_dim, embed_dim]`` 。
-    - **pre_layer_norm** (bool，可选) - 代表是采用 pre_layer_norm 的结构（True）还是 post_layer_norm 的结构（False）。若为 True，则为 pre_layer_norm 结构，代表在 multi-head attention 和 ffn 之前各执行一次 ``layer_norm``。若为 False，则为 post_layer_norm 结构，代表在 multi-head attention 和 ffn 之后各执行一次 ``layer_norm``。默认值：``False`` 。
-    - **pre_ln_scale** (Tensor，可选) - 代表 normalize_before 为 True 时，multi-head attention 中第一个 ``layer_norm`` 的权重，一维 tensor，形状为 ``[embed_dim]`` 。
-    - **pre_ln_bias** (Tensor，可选) - 代表 normalize_before 为 True 时，multi_head attention 中第一个 ``layer_norm`` 的偏置，一维 tensor，形状为  ``[embed_dim]`` 。
-    - **ln_scale** (Tensor，可选) - 代表 normalize_before 为 True 时，multi-head attention 中第二个 （False 时的第一个） ``layer_norm`` 的权重，一维 tensor，形状为 ``[embed_dim]`` 。
-    - **ln_bias** (Tensor，可选) - 代表 normalize_before 为 True 时，multi-head attention 中第二个 （False 时的第一个） ``layer_norm`` 的偏置，一维 tensor，形状为 ``[embed_dim]`` 。
-    - **pre_ln_epsilon** (float，可选) - 代表 normalize_before 为 True 时，multi-head attention 中第一个 ``layer_norm`` 为了数值稳定加在分母上的值。默认值为 1e-05 。
-    - **qkv_bias** (Tensor，可选) - 代表 Attention 中计算 q, k, v 时的偏置，是一个三维 tensor，当 ``transpose_qkv_wb`` 为 False 时形状为 ``[3, num_heads, head_dim]`` 。当 ``transpose_qkv_wb`` 为 True 时形状为 ``[3 * embed_dim]`` 。
-    - **linear_bias** (Tensor，可选) - 代表 ``linear`` 的偏置，一维 tensor，形状为 ``[embed_dim]`` 。
-    - **cache_kv** (Tensor，可选) - 代表自回归生成模型中 cache 结构的部分，五维 tensor，形状为 ``[2, bsz, num_head, seq_len, head_dim]``。默认值为 None。
-    - **attn_mask** （Tensor，可选）- 用于限制 multi-head attention 中对当前词产生影响的其他词的范围。形状会被广播为 ``[batch_size, num_heads, sequence_length, sequence_length ]`` 。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，代表 Query，是一个三维 tensor，形状为  ``[batch_size, sequence_length, embed_dim]`` 。其中，batch_size 是一次训练所处理的样本个数（句子个数)；sequence_length 代表每一个样本序列（每句话）中的 word 个数；embed_dim 代表 word 经过 embedding 后得到的向量长度。
+    - **qkv_weight** (Tensor) - 代表 Attention 中计算 q, k, v 时的权重，是一个四维 tensor，当  ``transpose_qkv_wb``  为 False 时形状为  ``[3, num_heads, head_dim, embed_dim]`` 。其中，3 代表 qkv_weight 是包含了 q, k, v 三个权重矩阵，num_heads 代表 multi-head attention 中的 head 数量，head_dim 代表 head 的维度。当  ``transpose_qkv_wb``  为 True 时形状为  ``[embed_dim， 3 * embed_dim]`` 。
+    - **linear_weight** (Tensor) - 代表 linear 的权重，二维 tensor，形状为  ``[embed_dim, embed_dim]``  。
+    - **pre_layer_norm** (bool，可选) - 代表是采用 pre_layer_norm 的结构（True）还是 post_layer_norm 的结构（False）。若为 True，则为 pre_layer_norm 结构，代表在 multi-head attention 和 ffn 之前各执行一次  ``layer_norm`` 。若为 False，则为 post_layer_norm 结构，代表在 multi-head attention 和 ffn 之后各执行一次  ``layer_norm`` 。默认值： ``False``  。
+    - **pre_ln_scale** (Tensor，可选) - 代表 normalize_before 为 True 时，multi-head attention 中第一个  ``layer_norm``  的权重，一维 tensor，形状为  ``[embed_dim]``  。
+    - **pre_ln_bias** (Tensor，可选) - 代表 normalize_before 为 True 时，multi_head attention 中第一个  ``layer_norm``  的偏置，一维 tensor，形状为   ``[embed_dim]``  。
+    - **ln_scale** (Tensor，可选) - 代表 normalize_before 为 True 时，multi-head attention 中第二个 （False 时的第一个）  ``layer_norm``  的权重，一维 tensor，形状为  ``[embed_dim]``  。
+    - **ln_bias** (Tensor，可选) - 代表 normalize_before 为 True 时，multi-head attention 中第二个 （False 时的第一个）  ``layer_norm``  的偏置，一维 tensor，形状为  ``[embed_dim]``  。
+    - **pre_ln_epsilon** (float，可选) - 代表 normalize_before 为 True 时，multi-head attention 中第一个  ``layer_norm``  为了数值稳定加在分母上的值。默认值为 1e-05 。
+    - **qkv_bias** (Tensor，可选) - 代表 Attention 中计算 q, k, v 时的偏置，是一个三维 tensor，当  ``transpose_qkv_wb``  为 False 时形状为  ``[3, num_heads, head_dim]``  。当  ``transpose_qkv_wb``  为 True 时形状为  ``[3 * embed_dim]``  。
+    - **linear_bias** (Tensor，可选) - 代表  ``linear``  的偏置，一维 tensor，形状为  ``[embed_dim]``  。
+    - **cache_kv** (Tensor，可选) - 代表自回归生成模型中 cache 结构的部分，五维 tensor，形状为  ``[2, bsz, num_head, seq_len, head_dim]`` 。默认值为 None。
+    - **attn_mask** （Tensor，可选）- 用于限制 multi-head attention 中对当前词产生影响的其他词的范围。形状会被广播为  ``[batch_size, num_heads, sequence_length, sequence_length ]``  。
     - **dropout_rate** (float，可选) - 代表 multi-head attention 之后的 dropout 算子的 dropout 比例，默认为 0.5。
     - **attn_dropout_rate** (float，可选) - 代表 multi-head attention 中的 dropout 算子的 dropout 比例，默认为 0.5。
-    - **ln_epsilon** (float，可选) - 代表 normalize_before 为 True 时，multi-head attention 中第二个 （False 时的第一个） ``layer_norm`` 为了数值稳定加在分母上的值。默认值为 1e-05 。
+    - **ln_epsilon** (float，可选) - 代表 normalize_before 为 True 时，multi-head attention 中第二个 （False 时的第一个）  ``layer_norm``  为了数值稳定加在分母上的值。默认值为 1e-05 。
     - **training** (bool)：标记是否为训练阶段。默认：True。
     - **mode** (str)：丢弃单元的方式，有两种'upscale_in_train'和'downscale_in_infer'，默认：'upscale_in_train'。计算方法如下：
 
@@ -80,13 +80,13 @@ fused_multi_head_attention 算子目前只支持在 GPU 下运行，其包含的
             - inference: out = input * (1.0 - p)
     - **ring_id** (int，可选) - 分布式 tensor parallel 运行下通讯所使用的 NCCL id。默认值为 -1 。
     - **add_residual** (bool，可选) - 是否在计算最后对结果进行残差计算。默认值为 True。
-    - **num_heads** (int，可选) - 在 ``transpose_qkv_wb`` 设置为 True 的时候，必须提供该值，表示 Multi-Head Attention 的 head 的维度。默认值为 -1。
+    - **num_heads** (int，可选) - 在  ``transpose_qkv_wb``  设置为 True 的时候，必须提供该值，表示 Multi-Head Attention 的 head 的维度。默认值为 -1。
     - **transpose_qkv_wb** (bool，可选) - 是否在底层算子中对 Attention 中计算 q, k, v 时的权重与偏置进行 transpose 操作。默认值为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/incubate/nn/functional/fused_multi_transformer_cn.rst b/docs/api/paddle/incubate/nn/functional/fused_multi_transformer_cn.rst
index e26dc58353c..7d8134bb97c 100644
--- a/docs/api/paddle/incubate/nn/functional/fused_multi_transformer_cn.rst
+++ b/docs/api/paddle/incubate/nn/functional/fused_multi_transformer_cn.rst
@@ -89,7 +89,7 @@ Transformer 层的功能与以下伪代码一致：
 
 返回
 ::::::::::::
-    - Tensor|tuple：如果 ``cache_kvs`` 为 None，则返回与 ``x`` 形状和数据类型相同的张量，代表 Transformer 的输出。如果 ``cache_kvs`` 不为 None，则返回元组（output, cache_kvs），其中 output 是 Transformer 的输出，cache_kvs 与输入`cache_kvs`原地更新。
+    - Tensor|tuple：如果  ``cache_kvs``  为 None，则返回与  ``x``  形状和数据类型相同的张量，代表 Transformer 的输出。如果  ``cache_kvs``  不为 None，则返回元组（output, cache_kvs），其中 output 是 Transformer 的输出，cache_kvs 与输入`cache_kvs`原地更新。
 
 
 代码示例
diff --git a/docs/api/paddle/incubate/nn/functional/fused_rms_norm_cn.rst b/docs/api/paddle/incubate/nn/functional/fused_rms_norm_cn.rst
index 1cb6548d0fe..4c8f1bdb85f 100644
--- a/docs/api/paddle/incubate/nn/functional/fused_rms_norm_cn.rst
+++ b/docs/api/paddle/incubate/nn/functional/fused_rms_norm_cn.rst
@@ -13,7 +13,7 @@ fused_rms_norm 算子目前只支持在 GPU 下运行。
 
 参数
 ::::::::::::
-    - **x** (Tensor) - 输入 ``Tensor``。
+    - **x** (Tensor) - 输入  ``Tensor`` 。
     - **norm_weight** (Tensor) - 用于仿射输出的权重张量。
     - **norm_bias** (Tensor) - 用于仿射输出的偏置张量。
     - **epsilon** (float) - 一个小的浮点数，用于避免除以零。
@@ -28,11 +28,11 @@ fused_rms_norm 算子目前只支持在 GPU 下运行。
 
 返回
 ::::::::::::
-输出 ``Tensor``
+输出  ``Tensor`` 
 
 形状
 ::::::::::::
-``Tensor``，形状同 ``x`` 一致。
+ ``Tensor`` ，形状同  ``x``  一致。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/incubate/nn/functional/masked_multihead_attention_cn.rst b/docs/api/paddle/incubate/nn/functional/masked_multihead_attention_cn.rst
index 5cf2cbfecbd..fbc56dafe8b 100644
--- a/docs/api/paddle/incubate/nn/functional/masked_multihead_attention_cn.rst
+++ b/docs/api/paddle/incubate/nn/functional/masked_multihead_attention_cn.rst
@@ -36,7 +36,7 @@ masked_multihead_attention
 
 形状
 ::::::::::::
-``Tensor`` | ``tuple``
+ ``Tensor``  |  ``tuple`` 
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/incubate/optimizer/LBFGS_cn.rst b/docs/api/paddle/incubate/optimizer/LBFGS_cn.rst
index 0282ceeddf6..b438cedad48 100644
--- a/docs/api/paddle/incubate/optimizer/LBFGS_cn.rst
+++ b/docs/api/paddle/incubate/optimizer/LBFGS_cn.rst
@@ -5,7 +5,7 @@ LBFGS
 
 .. py:class:: paddle.incubate.optimizer.LBFGS(lr=1.0, max_iter=20, max_eval=None, tolerance_grad=1e-07, tolerance_change=1e-09, history_size=100, line_search_fn=None, parameters=None, weight_decay=None, grad_clip=None, name=None)
 
-``LBFGS`` 使用 L-BFGS 方法对参数进行优化更新，使得 loss 值最小。
+ ``LBFGS``  使用 L-BFGS 方法对参数进行优化更新，使得 loss 值最小。
 
 L-BFGS 是限制内存的 BFGS 方法，适用于海森矩阵为稠密矩阵、内存开销较大场景。BFGS 参考 :ref:`cn_api_paddle_incubate_optimizer_functional_minimize_bfgs` .
 
diff --git a/docs/api/paddle/incubate/optimizer/functional/minimize_bfgs_cn.rst b/docs/api/paddle/incubate/optimizer/functional/minimize_bfgs_cn.rst
index 84a63f03734..3830723ecfd 100644
--- a/docs/api/paddle/incubate/optimizer/functional/minimize_bfgs_cn.rst
+++ b/docs/api/paddle/incubate/optimizer/functional/minimize_bfgs_cn.rst
@@ -6,7 +6,7 @@ minimize_bfgs
 .. py:function:: paddle.incubate.optimizer.functional.minimize_bfgs(objective_func, initial_position, max_iters=50, tolerance_grad=1e-07, tolerance_change=1e-09, initial_inverse_hessian_estimate=None, line_search_fn='strong_wolfe', max_line_search_iters=50, initial_step_length=1.0, dtype='float32', name=None)
 
 
-``minimize_bfgs`` 使用 BFGS 方法求解可微函数 ``objective_func`` 的最小值。
+ ``minimize_bfgs``  使用 BFGS 方法求解可微函数  ``objective_func``  的最小值。
 
 BFGS 是一种拟牛顿方法，用于解决可微函数上的无约束优化问题，通过如下迭代公式更新参数：
 
@@ -40,11 +40,11 @@ BFGS 具体原理参考书籍 Jorge Nocedal, Stephen J. Wright, Numerical Optimi
 参数
 :::::::::
     - **objective_func** (callable) - 待优化的目标函数，接受 1 维 Tensor 并返回一个标量。
-    - **initial_position** (Tensor) - 迭代的初始位置，与 ``objective_func`` 的输入形状相同。
+    - **initial_position** (Tensor) - 迭代的初始位置，与  ``objective_func``  的输入形状相同。
     - **max_iters** (int，可选) - BFGS 迭代的最大次数。默认值：50。
     - **tolerance_grad** (float，可选) - 当梯度的范数小于该值时，终止迭代。当前使用正无穷范数。默认值：1e-7。
     - **tolerance_change** (float，可选) - 当函数值/x 值/其他参数 两次迭代的改变量小于该值时，终止迭代。默认值：1e-9。
-    - **initial_inverse_hessian_estimate** (Tensor，可选) - 函数在初始位置时的近似逆海森矩阵，必须满足对称性和正定性。当为 None 时，将使用 N 阶单位矩阵，其中 N 为 ``initial_position`` 的 size。默认值：None。
+    - **initial_inverse_hessian_estimate** (Tensor，可选) - 函数在初始位置时的近似逆海森矩阵，必须满足对称性和正定性。当为 None 时，将使用 N 阶单位矩阵，其中 N 为  ``initial_position``  的 size。默认值：None。
     - **line_search_fn** (str，可选) - 指定要使用的线搜索方法，目前只支持值为'strong wolfe'方法，未来将支持'Hager Zhang'方法。默认值：'strong wolfe'。
     - **max_line_search_iters** (int，可选) - 线搜索的最大迭代次数。默认值：50。
     - **initial_step_length** (float，可选) - 线搜索中第一次迭代时的步长，不同的初始步长可能会产生不同的优化结果。对于高斯牛顿类方法初始的试验步长应该总是 1。默认值：1.0。
diff --git a/docs/api/paddle/incubate/optimizer/functional/minimize_lbfgs_cn.rst b/docs/api/paddle/incubate/optimizer/functional/minimize_lbfgs_cn.rst
index a241a7a943b..76bcf9a1a00 100644
--- a/docs/api/paddle/incubate/optimizer/functional/minimize_lbfgs_cn.rst
+++ b/docs/api/paddle/incubate/optimizer/functional/minimize_lbfgs_cn.rst
@@ -5,7 +5,7 @@ minimize_lbfgs
 
 .. py:function:: paddle.incubate.optimizer.functional.minimize_lbfgs(objective_func, initial_position, history_size=100, max_iters=50, tolerance_grad=1e-08, tolerance_change=1e-08, initial_inverse_hessian_estimate=None, line_search_fn='strong_wolfe', max_line_search_iters=50, initial_step_length=1.0, dtype='float32', name=None)
 
-``minimize_lbfgs`` 使用 L-BFGS 方法求解可微函数 ``objective_func`` 的最小值。
+ ``minimize_lbfgs``  使用 L-BFGS 方法求解可微函数  ``objective_func``  的最小值。
 
 L-BFGS 是限制内存的 BFGS 方法，适用于海森矩阵为稠密矩阵、内存开销较大场景。BFGS 参考 :ref:`cn_api_paddle_incubate_optimizer_functional_minimize_bfgs` .
 
@@ -33,12 +33,12 @@ LBFGS 具体原理参考书籍 Jorge Nocedal, Stephen J. Wright, Numerical Optim
 参数
 :::::::::
     - **objective_func** (callable) - 待优化的目标函数，接受 1 维 Tensor 并返回一个标量。
-    - **initial_position** (Tensor) - 迭代的初始位置，与 ``objective_func`` 的输入形状相同。
+    - **initial_position** (Tensor) - 迭代的初始位置，与  ``objective_func``  的输入形状相同。
     - **history_size** (Scalar，可选) - 指定储存的向量对{si,yi}数量。默认值：100。
     - **max_iters** (int，可选) - BFGS 迭代的最大次数。默认值：50。
     - **tolerance_grad** (float，可选) - 当梯度的范数小于该值时，终止迭代。当前使用正无穷范数。默认值：1e-7。
     - **tolerance_change** (float，可选) - 当函数值/x 值/其他参数 两次迭代的改变量小于该值时，终止迭代。默认值：1e-9。
-    - **initial_inverse_hessian_estimate** (Tensor，可选) - 函数在初始位置时的近似逆海森矩阵，必须满足对称性和正定性。当为 None 时，将使用 N 阶单位矩阵，其中 N 为 ``initial_position`` 的 size。默认值：None。
+    - **initial_inverse_hessian_estimate** (Tensor，可选) - 函数在初始位置时的近似逆海森矩阵，必须满足对称性和正定性。当为 None 时，将使用 N 阶单位矩阵，其中 N 为  ``initial_position``  的 size。默认值：None。
     - **line_search_fn** (str，可选) - 指定要使用的线搜索方法，目前只支持值为'strong wolfe'方法，未来将支持'Hager Zhang'方法。默认值：'strong wolfe'。
     - **max_line_search_iters** (int，可选) - 线搜索的最大迭代次数。默认值：50。
     - **initial_step_length** (float，可选) - 线搜索中第一次迭代时的步长，不同的初始步长可能会产生不同的优化结果。对于高斯牛顿类方法初始的试验步长应该总是 1。默认值：1.0。
diff --git a/docs/api/paddle/incubate/segment_max_cn.rst b/docs/api/paddle/incubate/segment_max_cn.rst
index 67f37c5b3cc..a30386a725f 100644
--- a/docs/api/paddle/incubate/segment_max_cn.rst
+++ b/docs/api/paddle/incubate/segment_max_cn.rst
@@ -8,14 +8,14 @@ segment_max
 
 分段求最大值函数。
 
-此运算符，将 ``segment_ids`` 中相同索引对应的 ``data`` 的元素，进行求最大值操作。其中 ``segment_ids`` 是一个单调非减序列。
-具体而言，该算子计算一个 Tensor ``out``，使得
+此运算符，将  ``segment_ids``  中相同索引对应的  ``data``  的元素，进行求最大值操作。其中  ``segment_ids``  是一个单调非减序列。
+具体而言，该算子计算一个 Tensor  ``out`` ，使得
 
 .. math::
 
     out_i = \max_{j \in \{segment\_ids_j == i \} } data_{j}
 
-其中求最大值的索引 ``j``，是符合 ``segment_ids[j] == i`` 的所有 ``j`` 。
+其中求最大值的索引  ``j`` ，是符合  ``segment_ids[j] == i``  的所有  ``j``  。
 
 
 参数
diff --git a/docs/api/paddle/incubate/segment_mean_cn.rst b/docs/api/paddle/incubate/segment_mean_cn.rst
index f0f71bce3e0..d2680ecb07e 100644
--- a/docs/api/paddle/incubate/segment_mean_cn.rst
+++ b/docs/api/paddle/incubate/segment_mean_cn.rst
@@ -8,14 +8,14 @@ segment_mean
 
 分段求均值函数。
 
-此运算符，将 ``segment_ids`` 中相同索引对应的 ``data`` 的元素，进行求均值操作。其中 ``segment_ids`` 是一个单调非减序列。
-具体而言，该算子计算一个 Tensor ``out``，使得
+此运算符，将  ``segment_ids``  中相同索引对应的  ``data``  的元素，进行求均值操作。其中  ``segment_ids``  是一个单调非减序列。
+具体而言，该算子计算一个 Tensor  ``out`` ，使得
 
 .. math::
 
     out_i = \mathop{mean}_{j \in \{segment\_ids_j == i \} } data_{j}
 
-其中求均值的索引 ``j``，是符合 ``segment_ids[j] == i`` 的所有 ``j`` 。
+其中求均值的索引  ``j`` ，是符合  ``segment_ids[j] == i``  的所有  ``j``  。
 
 
 参数
diff --git a/docs/api/paddle/incubate/segment_min_cn.rst b/docs/api/paddle/incubate/segment_min_cn.rst
index e3ab77d6e15..744cf05c5a8 100644
--- a/docs/api/paddle/incubate/segment_min_cn.rst
+++ b/docs/api/paddle/incubate/segment_min_cn.rst
@@ -8,14 +8,14 @@ segment_min
 
 分段求最小值函数。
 
-此运算符，将 ``segment_ids`` 中相同索引对应的 ``data`` 的元素，进行求最小值操作。其中 ``segment_ids`` 是一个单调非减序列。
-具体而言，该算子计算一个 Tensor ``out``，使得
+此运算符，将  ``segment_ids``  中相同索引对应的  ``data``  的元素，进行求最小值操作。其中  ``segment_ids``  是一个单调非减序列。
+具体而言，该算子计算一个 Tensor  ``out`` ，使得
 
 .. math::
 
     out_i = \min_{j \in \{segment\_ids_j == i \} } data_{j}
 
-其中求最小值的索引 ``j``，是符合 ``segment_ids[j] == i`` 的所有 ``j`` 。
+其中求最小值的索引  ``j`` ，是符合  ``segment_ids[j] == i``  的所有  ``j``  。
 
 
 参数
diff --git a/docs/api/paddle/incubate/segment_sum_cn.rst b/docs/api/paddle/incubate/segment_sum_cn.rst
index 651d01be984..a372e6837b2 100644
--- a/docs/api/paddle/incubate/segment_sum_cn.rst
+++ b/docs/api/paddle/incubate/segment_sum_cn.rst
@@ -8,14 +8,14 @@ segment_sum
 
 分段求和函数。
 
-此运算符，将 ``segment_ids`` 中相同索引对应的 ``data`` 的元素，进行求和操作。其中 ``segment_ids`` 是一个单调非减序列。
-具体而言，该算子计算一个 Tensor ``out``，使得
+此运算符，将  ``segment_ids``  中相同索引对应的  ``data``  的元素，进行求和操作。其中  ``segment_ids``  是一个单调非减序列。
+具体而言，该算子计算一个 Tensor  ``out`` ，使得
 
 .. math::
 
     out_i = \sum_{j \in \{segment\_ids_j == i \} } data_{j}
 
-其中求和的索引 ``j``，是符合 ``segment_ids[j] == i`` 的所有 ``j`` 。
+其中求和的索引  ``j`` ，是符合  ``segment_ids[j] == i``  的所有  ``j``  。
 
 
 参数
diff --git a/docs/api/paddle/incubate/softmax_mask_fuse_cn.rst b/docs/api/paddle/incubate/softmax_mask_fuse_cn.rst
index edd2ab7dc72..4663a661674 100644
--- a/docs/api/paddle/incubate/softmax_mask_fuse_cn.rst
+++ b/docs/api/paddle/incubate/softmax_mask_fuse_cn.rst
@@ -5,8 +5,8 @@ softmax_mask_fuse
 
 .. py:function:: paddle.incubate.softmax_mask_fuse(x, mask, name=None)
 
-对输入 ``x`` 进行使用输入 ``mask`` mask 后的 softmax 操作。
-该 API 主要针对加速 Transformer 架构而设计。将 ``tmp = x + mask, rst = softmax(tmp)`` 两个操作合为一个操作。计算公式为：
+对输入  ``x``  进行使用输入  ``mask``  mask 后的 softmax 操作。
+该 API 主要针对加速 Transformer 架构而设计。将  ``tmp = x + mask, rst = softmax(tmp)``  两个操作合为一个操作。计算公式为：
 
 .. math::
     out = softmax(x + mask)
@@ -21,7 +21,7 @@ softmax_mask_fuse
 
 返回
 :::::::::
-``Tensor``，维度和数据类型都与 ``x`` 相同，存储运算后的结果
+ ``Tensor`` ，维度和数据类型都与  ``x``  相同，存储运算后的结果
 
 
 代码示例
diff --git a/docs/api/paddle/incubate/softmax_mask_fuse_upper_triangle_cn.rst b/docs/api/paddle/incubate/softmax_mask_fuse_upper_triangle_cn.rst
index 2041ac4ac46..945f6f35605 100644
--- a/docs/api/paddle/incubate/softmax_mask_fuse_upper_triangle_cn.rst
+++ b/docs/api/paddle/incubate/softmax_mask_fuse_upper_triangle_cn.rst
@@ -5,8 +5,8 @@ softmax_mask_fuse_upper_triangle
 
 .. py:function:: paddle.incubate.softmax_mask_fuse_upper_triangle(x)
 
-对输入 ``x`` 进行带 mask 的 softmax 操作，并且总是 mask 住 x 的上三角矩阵部分（不包含对角线部分）。
-该 API 主要针对加速 Transformer 架构而设计。将 ``tmp = x + mask, rst = softmax(tmp)`` 两个操作合为一个操作。计算公式为：
+对输入  ``x``  进行带 mask 的 softmax 操作，并且总是 mask 住 x 的上三角矩阵部分（不包含对角线部分）。
+该 API 主要针对加速 Transformer 架构而设计。将  ``tmp = x + mask, rst = softmax(tmp)``  两个操作合为一个操作。计算公式为：
 
 .. math::
     out = softmax(LowerTriangular(x))
@@ -19,7 +19,7 @@ softmax_mask_fuse_upper_triangle
 
 返回
 :::::::::
-``Tensor``，维度和数据类型都与 ``x`` 相同，存储运算后的结果
+ ``Tensor`` ，维度和数据类型都与  ``x``  相同，存储运算后的结果
 
 
 代码示例
diff --git a/docs/api/paddle/incubate/xpu/resnet_block/ResNetBasicBlock_cn.rst b/docs/api/paddle/incubate/xpu/resnet_block/ResNetBasicBlock_cn.rst
index a4cc5c78748..74269e83345 100644
--- a/docs/api/paddle/incubate/xpu/resnet_block/ResNetBasicBlock_cn.rst
+++ b/docs/api/paddle/incubate/xpu/resnet_block/ResNetBasicBlock_cn.rst
@@ -4,11 +4,11 @@ ResNetBasicBlock
 -------------------------------
 .. py:class:: paddle.incubate.xpu.resnet_block.ResNetBasicBlock(num_channels1, num_filter1, filter1_size, num_channels2, num_filter2, filter2_size, num_channels3, num_filter3, filter3_size, stride1=1, stride2=1, stride3=1, act='relu', momentum=0.9, eps=1e-5, data_format='NCHW', has_shortcut=False, use_global_stats=False, is_test=False, filter1_attr=None, scale1_attr=None, bias1_attr=None, moving_mean1_name=None, moving_var1_name=None, filter2_attr=None, scale2_attr=None, bias2_attr=None, moving_mean2_name=None, moving_var2_name=None, ilter3_attr=None, scale3_attr=None, bias3_attr=None, moving_mean3_name=None, moving_var3_name=None, padding1=0, padding2=0, padding3=0, dilation1=1, dilation2=1, dilation3=1, trainable_statistics=False, find_conv_max=True)
 
-该接口用于构建 ``ResNetBasicBlock`` 类的一个可调用对象，实现一次性计算多个 ``Conv2D``、 ``BatchNorm`` 和 ``ReLU`` 的功能，排列顺序参见源码链接。
+该接口用于构建  ``ResNetBasicBlock``  类的一个可调用对象，实现一次性计算多个  ``Conv2D`` 、  ``BatchNorm``  和  ``ReLU``  的功能，排列顺序参见源码链接。
 
-当 has_shortcut = False 时，实现计算两个 ``Conv2D``、两个 ``BatchNorm`` 和两个 ``ReLU`` 的功能，此时输入输出 ``Tensor`` 的 shape 需要保持一致。
+当 has_shortcut = False 时，实现计算两个  ``Conv2D`` 、两个  ``BatchNorm``  和两个  ``ReLU``  的功能，此时输入输出  ``Tensor``  的 shape 需要保持一致。
 
-当 has_shortcut = True 时，实现计算三个 ``Conv2D``、三个 ``BatchNorm`` 和两个 ``ReLU`` 的功能。
+当 has_shortcut = True 时，实现计算三个  ``Conv2D`` 、三个  ``BatchNorm``  和两个  ``ReLU``  的功能。
 
 
 
@@ -18,27 +18,27 @@ ResNetBasicBlock
     - **num_filter** (int) - 由卷积操作产生的输出的通道数。
     - **filter_size** (int|list|tuple) - 卷积核大小。可以为单个整数或包含两个整数的元组或列表，分别表示卷积核的高和宽。如果为单个整数，表示卷积核的高和宽都等于该整数。
     - **stride** (int，可选) - 步长大小。为单个整数，表示沿着高和宽的步长都等于该整数。默认值：1。
-    - **act** (str，可选) - 激活函数。默认值： ``relu``。
-    - **momentum** (float，可选) - 此值用于计算 ``moving_mean`` 和 ``moving_var``。默认值：0.9。
+    - **act** (str，可选) - 激活函数。默认值：  ``relu`` 。
+    - **momentum** (float，可选) - 此值用于计算  ``moving_mean``  和  ``moving_var`` 。默认值：0.9。
     - **eps** (float，可选) - 为了数值稳定加在分母上的值。默认值：1e-5。
     - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，目前只支持"NCHW"。N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度。默认值："NCHW"。
-    - **has_shortcut** (bool，可选) - 设置是否计算第三个 Conv2D 和 BatchNorm。为 True 时计算，否则不进行计算。默认值： ``False`` 。
-    - **use_global_stats** (bool，可选) – 指示是否使用全局均值和方差。在预测或测试模式下，将 ``use_global_stats`` 设置为 true 或将 ``is_test`` 设置为 true，这两种行为是等效的。在训练模式中，当设置 ``use_global_stats`` 为 True 时，在训练期间也将使用全局均值和方差。默认值：False。
+    - **has_shortcut** (bool，可选) - 设置是否计算第三个 Conv2D 和 BatchNorm。为 True 时计算，否则不进行计算。默认值：  ``False``  。
+    - **use_global_stats** (bool，可选) – 指示是否使用全局均值和方差。在预测或测试模式下，将  ``use_global_stats``  设置为 true 或将  ``is_test``  设置为 true，这两种行为是等效的。在训练模式中，当设置  ``use_global_stats``  为 True 时，在训练期间也将使用全局均值和方差。默认值：False。
     - **is_test** (bool，可选) - 指示是否在测试阶段，非训练阶段使用训练过程中统计到的全局均值和全局方差。默认值：False。
-    - **filter_attr** (ParamAttr，可选) - 指定对应 ``Conv2D`` 权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **scale_attr** (ParamAttr，可选) - 指定对应 ``BatchNorm`` 权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** (ParamAttr，可选) - 指定对应 ``BatchNorm`` 偏置参数属性的对象。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **moving_mean_name** (str，可选) - ``moving_mean`` 的名称，存储全局均值。默认值：None。
-    - **moving_var_name** (str，可选) - ``moving_var`` 的名称，存储全局方差。默认值：None。
+    - **filter_attr** (ParamAttr，可选) - 指定对应  ``Conv2D``  权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **scale_attr** (ParamAttr，可选) - 指定对应  ``BatchNorm``  权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** (ParamAttr，可选) - 指定对应  ``BatchNorm``  偏置参数属性的对象。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **moving_mean_name** (str，可选) -  ``moving_mean``  的名称，存储全局均值。默认值：None。
+    - **moving_var_name** (str，可选) -  ``moving_var``  的名称，存储全局方差。默认值：None。
     - **padding** (int，可选) - 填充大小。为一个整数，padding_height = padding_width = padding。默认值：0。
     - **dilation** (int，可选) - 空洞大小。为单个整数，表示高和宽的空洞都等于该整数。默认值：1。
     - **trainable_statistics** (bool，可选) - eval 模式下是否计算 mean 均值和 var 方差。eval 模式下，trainable_statistics 为 True 时，由该批数据计算均值和方差。默认值：False。
-    - **find_conv_max** (bool，可选) - 是否计算每个 Conv2D 输入 ``Tensor`` 的最大值，为 True 表示计算。默认值：True。
+    - **find_conv_max** (bool，可选) - 是否计算每个 Conv2D 输入  ``Tensor``  的最大值，为 True 表示计算。默认值：True。
 
 
 返回
 :::::::::
-    - Tensor，输出 Tensor，数据类型与 ``X`` 一样。
+    - Tensor，输出 Tensor，数据类型与  ``X``  一样。
 
 
 
diff --git a/docs/api/paddle/index_add_cn.rst b/docs/api/paddle/index_add_cn.rst
index 5f0d849345c..c0d9609bd54 100644
--- a/docs/api/paddle/index_add_cn.rst
+++ b/docs/api/paddle/index_add_cn.rst
@@ -7,7 +7,7 @@ index_add
 
 
 
-沿着指定轴 ``axis`` 将 ``index`` 中指定位置的 ``x`` 与 ``value`` 相加，并写入到结果 Tensor 中的对应位置。这里 ``index`` 是一个 ``1-D`` Tensor。除 ``axis`` 轴外，返回的 Tensor 其余维度大小和输入 ``x`` 相等， ``axis`` 维度的大小等于 ``index`` 的大小。
+沿着指定轴  ``axis``  将  ``index``  中指定位置的  ``x``  与  ``value``  相加，并写入到结果 Tensor 中的对应位置。这里  ``index``  是一个  ``1-D``  Tensor。除  ``axis``  轴外，返回的 Tensor 其余维度大小和输入  ``x``  相等，  ``axis``  维度的大小等于  ``index``  的大小。
 
 **示例**
 
@@ -60,7 +60,7 @@ index_add
 
 **示例 1 图解说明**
 
-    下图展示了示例 1 中的情形——一个形状为 [3,3] 的二维张量通过 index_add 操作在 axis=0 轴上对指定位置的元素进行相加，同时保持了除 ``axis`` 轴外，返回的 Tensor 其余维度大小和输入 ``x`` 相等。
+    下图展示了示例 1 中的情形——一个形状为 [3,3] 的二维张量通过 index_add 操作在 axis=0 轴上对指定位置的元素进行相加，同时保持了除  ``axis``  轴外，返回的 Tensor 其余维度大小和输入  ``x``  相等。
 
     .. figure:: ../../images/api_legend/index_add/index_add-1.png
         :width: 500
@@ -69,7 +69,7 @@ index_add
 
 **示例 2 图解说明**
 
-    下图展示了示例 2 中的情形——一个形状为 [3,3] 的二维张量通过 index_add 操作在 axis=1 轴上对指定位置的元素进行相加，同时保持了除 ``axis`` 轴外，返回的 Tensor 其余维度大小和输入 ``x`` 相等。
+    下图展示了示例 2 中的情形——一个形状为 [3,3] 的二维张量通过 index_add 操作在 axis=1 轴上对指定位置的元素进行相加，同时保持了除  ``axis``  轴外，返回的 Tensor 其余维度大小和输入  ``x``  相等。
 
     .. figure:: ../../images/api_legend/index_add/index_add-2.png
         :width: 500
@@ -79,10 +79,10 @@ index_add
 参数
 :::::::::
 
-    - **x** （Tensor）– 输入 Tensor。 ``x`` 的数据类型可以是 float16, float32，float64，int32，int64。
+    - **x** （Tensor）– 输入 Tensor。  ``x``  的数据类型可以是 float16, float32，float64，int32，int64。
     - **index** （Tensor）– 包含索引下标的 1-D Tensor。数据类型为 int32 或者 int64。
     - **axis**    (int) – 索引轴。数据类型为 int。
-    - **value** （Tensor）– 与 ``x`` 相加的 Tensor。 ``value`` 的数据类型同 ``x`` 。
+    - **value** （Tensor）– 与  ``x``  相加的 Tensor。  ``value``  的数据类型同  ``x``  。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/index_fill_cn.rst b/docs/api/paddle/index_fill_cn.rst
index c7af8c8e68f..3e5b50a0d4f 100644
--- a/docs/api/paddle/index_fill_cn.rst
+++ b/docs/api/paddle/index_fill_cn.rst
@@ -5,7 +5,7 @@ index_fill
 
 .. py:function:: paddle.index_fill(x, index, axis, value, name=None)
 
-依据指定的轴 ``axis`` 和索引 ``indices`` 将指定位置的 ``x`` 填充为 ``value`` 。
+依据指定的轴  ``axis``  和索引  ``indices``  将指定位置的  ``x``  填充为  ``value``  。
 
 **图解说明**：
 
@@ -18,7 +18,7 @@ index_fill
 参数
 :::::::::
 
-    - **x** （Tensor）– 输入 Tensor。 ``x`` 的数据类型可以是 float16, float32，float64，int32，int64。
+    - **x** （Tensor）– 输入 Tensor。  ``x``  的数据类型可以是 float16, float32，float64，int32，int64。
     - **index** （Tensor）– 包含索引下标的 1-D Tensor。数据类型可以是 int32，int64。
     - **axis**    (int) – 索引轴。数据类型为 int。
     - **value** （float）– 用于填充目标张量的值。
diff --git a/docs/api/paddle/index_put_cn.rst b/docs/api/paddle/index_put_cn.rst
index a47c686c592..497f900e28e 100644
--- a/docs/api/paddle/index_put_cn.rst
+++ b/docs/api/paddle/index_put_cn.rst
@@ -5,7 +5,7 @@ index_put
 
 .. py:function::  paddle.index_put(x, indices, value, accumulate=False, name=None)
 
-依据索引 ``indices`` ，将指定位置的 ``x`` 重新赋值为 ``value`` 。这里 ``indices`` 是一个 ``tuple of tensor`` 。
+依据索引  ``indices``  ，将指定位置的  ``x``  重新赋值为  ``value``  。这里  ``indices``  是一个  ``tuple of tensor``  。
 
 **示例图解说明**：
 
@@ -19,10 +19,10 @@ index_put
 参数
 :::::::::
 
-    - **x** （Tensor）– 输入 Tensor。 ``x`` 的数据类型可以是 float16, float32，float64，int32，int64，bool。
+    - **x** （Tensor）– 输入 Tensor。  ``x``  的数据类型可以是 float16, float32，float64，int32，int64，bool。
     - **indices** （Tuple of Tensor）– 包含用来索引的 tensors 的元组。数据类型为 int32，int64，bool。
-    - **value**    (Tensor) – 用来给 ``x`` 赋值的 Tensor。
-    - **accumulate** （Tensor，可选）– 指定是否将 ``value`` 加到 ``x`` 的参数。 默认值为 False。
+    - **value**    (Tensor) – 用来给  ``x``  赋值的 Tensor。
+    - **accumulate** （Tensor，可选）– 指定是否将  ``value``  加到  ``x``  的参数。 默认值为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/index_sample_cn.rst b/docs/api/paddle/index_sample_cn.rst
index 39a3f9d227f..8e181f2f802 100644
--- a/docs/api/paddle/index_sample_cn.rst
+++ b/docs/api/paddle/index_sample_cn.rst
@@ -8,9 +8,9 @@ index_sample
 
 
 
-对输入 ``x`` 中的元素进行批量抽样，取 ``index`` 指定的对应下标的元素，按 index 中出现的先后顺序组织，填充为一个新的 Tensor。
+对输入  ``x``  中的元素进行批量抽样，取  ``index``  指定的对应下标的元素，按 index 中出现的先后顺序组织，填充为一个新的 Tensor。
 
- ``x`` 与 ``index`` 都是 ``2-D`` Tensor。``index`` 的第一维度与输入 ``x`` 的第一维度必须相同，``index`` 的第二维度没有大小要求，可以重复索引相同下标元素。
+  ``x``  与  ``index``  都是  ``2-D``  Tensor。 ``index``  的第一维度与输入  ``x``  的第一维度必须相同， ``index``  的第二维度没有大小要求，可以重复索引相同下标元素。
 
 参数
 :::::::::
@@ -20,7 +20,7 @@ index_sample
 
 返回
 :::::::::
-Tensor，数据类型与输入 ``x`` 相同，维度与 ``index`` 相同。
+Tensor，数据类型与输入  ``x``  相同，维度与  ``index``  相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/index_select_cn.rst b/docs/api/paddle/index_select_cn.rst
index 3d1cf8c1430..0aca2a76d6f 100644
--- a/docs/api/paddle/index_select_cn.rst
+++ b/docs/api/paddle/index_select_cn.rst
@@ -7,21 +7,21 @@ index_select
 
 
 
-沿着指定轴 ``axis`` 对输入 ``x`` 进行索引，取 ``index`` 中指定的相应项，创建并返回到一个新的 Tensor。这里 ``index`` 是一个 ``1-D`` Tensor。除 ``axis`` 轴外，返回的 Tensor 其余维度大小和输入 ``x`` 相等， ``axis`` 维度的大小等于 ``index`` 的大小。
+沿着指定轴  ``axis``  对输入  ``x``  进行索引，取  ``index``  中指定的相应项，创建并返回到一个新的 Tensor。这里  ``index``  是一个  ``1-D``  Tensor。除  ``axis``  轴外，返回的 Tensor 其余维度大小和输入  ``x``  相等，  ``axis``  维度的大小等于  ``index``  的大小。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``， ``dim`` 可替代 ``axis``；
-    参数顺序支持: 支持 PyTorch 参数顺序 ``(input, dim, index)`` 作为位置参数传入，可转换为 Paddle 顺序 ``(x, index, axis)``；
-    如 ``(input=x, dim=1, index=idx)`` 等价于 ``(x=x, index=idx, axis=1)``， ``(x, 1, idx)`` 等价于 ``(x, idx, axis=1)``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，  ``dim``  可替代  ``axis`` ；
+    参数顺序支持: 支持 PyTorch 参数顺序  ``(input, dim, index)``  作为位置参数传入，可转换为 Paddle 顺序  ``(x, index, axis)`` ；
+    如  ``(input=x, dim=1, index=idx)``  等价于  ``(x=x, index=idx, axis=1)`` ，  ``(x, 1, idx)``  等价于  ``(x, idx, axis=1)`` 。
 
 参数
 :::::::::
 
-    - **x** （Tensor） - 输入 Tensor。 ``x`` 的数据类型可以是 float16，float32，float64，int32，int64，complex64，complex128。
-      别名： ``input``
+    - **x** （Tensor） - 输入 Tensor。  ``x``  的数据类型可以是 float16，float32，float64，int32，int64，complex64，complex128。
+      别名：  ``input`` 
     - **index** （Tensor） - 包含索引下标的 1-D Tensor。
     - **axis** （int，可选） - 索引轴，若未指定，则默认选取第 0 维。
-      别名： ``dim``
+      别名：  ``dim`` 
     - **name** （str，可选） - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
diff --git a/docs/api/paddle/io/BatchSampler_cn.rst b/docs/api/paddle/io/BatchSampler_cn.rst
index 3870e3be4d5..912cc39eeb3 100644
--- a/docs/api/paddle/io/BatchSampler_cn.rst
+++ b/docs/api/paddle/io/BatchSampler_cn.rst
@@ -5,19 +5,19 @@ BatchSampler
 
 .. py:class:: paddle.io.BatchSampler(dataset=None, sampler=None, shuffle=False, batch_size=1, drop_last=False)
 
-批采样器的基础实现，用于 ``paddle.io.DataLoader`` 中迭代式获取 mini-batch 的样本下标数组，数组长度与 ``batch_size`` 一致。
+批采样器的基础实现，用于  ``paddle.io.DataLoader``  中迭代式获取 mini-batch 的样本下标数组，数组长度与  ``batch_size``  一致。
 
-所有用于 ``paddle.io.DataLoader`` 中的批采样器都必须是 ``paddle.io.BatchSampler`` 的子类并实现以下方法：
+所有用于  ``paddle.io.DataLoader``  中的批采样器都必须是  ``paddle.io.BatchSampler``  的子类并实现以下方法：
 
-``__iter__`` ：迭代式返回批样本下标数组。
+ ``__iter__``  ：迭代式返回批样本下标数组。
 
-``__len__`` ：每 epoch 中 mini-batch 数。
+ ``__len__``  ：每 epoch 中 mini-batch 数。
 
 参数
 ::::::::::::
 
-    - **dataset** (Dataset，可选) - 此参数必须是 :ref:`cn_api_paddle_io_Dataset` 或 :ref:`cn_api_paddle_io_IterableDataset` 的一个子类实例或实现了 ``__len__`` 的 Python 对象，用于生成样本下标。默认值为 None, 表示不使用此参数。
-    - **sampler** (Sampler|Iterable，可选) - 此参数必须是 :ref:`cn_api_paddle_io_Sampler` 或 Iterable 的子类实例，用于迭代式获取样本下标。 ``dataset`` 和 ``sampler`` 参数只能设置一个。默认值为 None, 表示不使用此参数。
+    - **dataset** (Dataset，可选) - 此参数必须是 :ref:`cn_api_paddle_io_Dataset` 或 :ref:`cn_api_paddle_io_IterableDataset` 的一个子类实例或实现了  ``__len__``  的 Python 对象，用于生成样本下标。默认值为 None, 表示不使用此参数。
+    - **sampler** (Sampler|Iterable，可选) - 此参数必须是 :ref:`cn_api_paddle_io_Sampler` 或 Iterable 的子类实例，用于迭代式获取样本下标。  ``dataset``  和  ``sampler``  参数只能设置一个。默认值为 None, 表示不使用此参数。
     - **shuffle** (bool，可选) - 是否需要在生成样本下标时打乱顺序。默认值为 False ，表示不打乱顺序。
     - **batch_size** (int，可选) - 每 mini-batch 中包含的样本数。默认值为 1 ，表示每 mini-batch 中包含 1 个样本数。
     - **drop_last** (bool，可选) - 是否需要丢弃最后无法凑整一个 mini-batch 的样本。默认值为 False ，表示不丢弃最后无法凑整一个 mini-batch 的样本。
diff --git a/docs/api/paddle/io/ConcatDataset_cn.rst b/docs/api/paddle/io/ConcatDataset_cn.rst
index 63657faf005..36cd3043524 100644
--- a/docs/api/paddle/io/ConcatDataset_cn.rst
+++ b/docs/api/paddle/io/ConcatDataset_cn.rst
@@ -17,7 +17,7 @@ ConcatDataset
 返回
 :::::::::
 
-Dataset，由 ``datasets`` 拼接而成的数据集。
+Dataset，由  ``datasets``  拼接而成的数据集。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/io/DataLoader_cn.rst b/docs/api/paddle/io/DataLoader_cn.rst
index 52d26372f73..adc755aa191 100644
--- a/docs/api/paddle/io/DataLoader_cn.rst
+++ b/docs/api/paddle/io/DataLoader_cn.rst
@@ -5,48 +5,48 @@ DataLoader
 
 .. py:class:: paddle.io.DataLoader(dataset, feed_list=None, places=None, return_list=False, batch_sampler=None, batch_size=1, shuffle=False, drop_last=False, collate_fn=None, num_workers=0, use_buffer_reader=True, use_shared_memory=True, prefetch_factor=2, timeout=0, worker_init_fn=None)
 
-DataLoader 返回一个迭代器，该迭代器根据 ``batch_sampler`` 给定的顺序迭代一次给定的 ``dataset``
+DataLoader 返回一个迭代器，该迭代器根据  ``batch_sampler``  给定的顺序迭代一次给定的  ``dataset`` 
 
-DataLoader 支持单进程和多进程的数据加载方式，当 ``num_workers`` 大于 0 时，将使用多进程方式异步加载数据。
+DataLoader 支持单进程和多进程的数据加载方式，当  ``num_workers``  大于 0 时，将使用多进程方式异步加载数据。
 
-DataLoader 当前支持 ``map-style`` 和 ``iterable-style`` 的数据集，``map-style`` 的数据集可通过下标索引样本，请参考 ``paddle.io.Dataset`` ； ``iterable-style`` 数据集只能迭代式地获取样本，类似 Python 迭代器，请参考 ``paddle.io.IterableDataset`` 。
+DataLoader 当前支持  ``map-style``  和  ``iterable-style``  的数据集， ``map-style``  的数据集可通过下标索引样本，请参考  ``paddle.io.Dataset``  ；  ``iterable-style``  数据集只能迭代式地获取样本，类似 Python 迭代器，请参考  ``paddle.io.IterableDataset``  。
 
 .. note::
 
-    当前还不支持在子进程中进行 GPU Tensor 的操作，请不要在子进程流程中使用 GPU Tensor，例如 ``dataset`` 中的预处理，``collate_fn`` 等，``numpy array`` 和 CPU Tensor 操作已支持。
+    当前还不支持在子进程中进行 GPU Tensor 的操作，请不要在子进程流程中使用 GPU Tensor，例如  ``dataset``  中的预处理， ``collate_fn``  等， ``numpy array``  和 CPU Tensor 操作已支持。
 
-``batch_sampler`` 请参考 ``paddle.io.BatchSampler``
+ ``batch_sampler``  请参考  ``paddle.io.BatchSampler`` 
 
 **禁用自动组 batch**
 
-在如 NLP 等任务中，用户需求自定义组 batch 的方式，不希望 ``DataLoader`` 自动组 batch， ``DataLoader`` 支持在 ``batch_size`` 和 ``batch_sampler`` 均为 None 的时候禁用自动组 batch 功能，此时需求从 ``dataset`` 中获取的数据为已经组好 batch 的数据，该数据将不做任何处理直接传到 ``collate_fn`` 或 ``default_collate_fn`` 中。
+在如 NLP 等任务中，用户需求自定义组 batch 的方式，不希望  ``DataLoader``  自动组 batch，  ``DataLoader``  支持在  ``batch_size``  和  ``batch_sampler``  均为 None 的时候禁用自动组 batch 功能，此时需求从  ``dataset``  中获取的数据为已经组好 batch 的数据，该数据将不做任何处理直接传到  ``collate_fn``  或  ``default_collate_fn``  中。
 
 .. note::
 
-    当禁用自动组 batch 时，``default_collate_fn`` 将不对输入数据做任何处理。
+    当禁用自动组 batch 时， ``default_collate_fn``  将不对输入数据做任何处理。
 
 参数
 ::::::::::::
 
-    - **dataset** (Dataset) - DataLoader 从此参数给定数据集中加载数据，此参数必须是 ``paddle.io.Dataset`` 或 ``paddle.io.IterableDataset`` 的一个子类实例。
-    - **feed_list** (list(Tensor)|tuple(Tensor)，可选) - feed 变量列表，由 ``paddle.static.data()`` 创建。当 ``return_list`` 为 False 时，此参数必须设置。默认值为 None。
+    - **dataset** (Dataset) - DataLoader 从此参数给定数据集中加载数据，此参数必须是  ``paddle.io.Dataset``  或  ``paddle.io.IterableDataset``  的一个子类实例。
+    - **feed_list** (list(Tensor)|tuple(Tensor)，可选) - feed 变量列表，由  ``paddle.static.data()``  创建。当  ``return_list``  为 False 时，此参数必须设置。默认值为 None。
     - **places** (list(Place)|tuple(Place)，可选) - 数据需要放置到的 Place 列表。在静态图和动态图模式中，此参数均必须设置。在动态图模式中，此参数列表长度必须是 1。默认值为 None。
     - **return_list** (bool，可选) - 每个设备上的数据是否以 list 形式返回。若 return_list = False，每个设备上的返回数据均是 str -> Tensor 的映射表，其中映射表的 key 是每个输入变量的名称。若 return_list = True，则每个设备上的返回数据均是 list(Tensor)。在动态图模式下，此参数必须为 True。默认值为 True。
-    - **batch_sampler** (BatchSampler，可选) - ``paddle.io.BatchSampler`` 或其子类的实例，DataLoader 通过 ``batch_sampler`` 产生的 mini-batch 索引列表来 ``dataset`` 中索引样本并组成 mini-batch。默认值为 None。
-    - **batch_size** (int|None，可选) - 每 mini-batch 中样本个数，为 ``batch_sampler`` 的替代参数，若 ``batch_sampler`` 未设置，会根据 ``batch_size`` ``shuffle`` ``drop_last`` 创建一个 ``paddle.io.BatchSampler``。默认值为 1。
-    - **shuffle** (bool，可选) - 生成 mini-batch 索引列表时是否对索引打乱顺序，为 ``batch_sampler`` 的替代参数，若 ``batch_sampler`` 未设置，会根据 ``batch_size`` ``shuffle`` ``drop_last`` 创建一个 ``paddle.io.BatchSampler``。默认值为 False。
-    - **drop_last** (bool，可选) - 是否丢弃因数据集样本数不能被 ``batch_size`` 整除而产生的最后一个不完整的 mini-batch，为 ``batch_sampler`` 的替代参数，若 ``batch_sampler`` 未设置，会根据 ``batch_size`` ``shuffle`` ``drop_last`` 创建一个 ``paddle.io.BatchSampler``。默认值为 False。
-    - **collate_fn** (callable，可选) - 通过此参数指定如何将样本列表组合为 mini-batch 数据，当 ``collate_fn`` 为 None 时，默认为将样本个字段在第 0 维上堆叠(同 ``np.stack(..., axis=0)`` )为 mini-batch 的数据。默认值为 None。
+    - **batch_sampler** (BatchSampler，可选) -  ``paddle.io.BatchSampler``  或其子类的实例，DataLoader 通过  ``batch_sampler``  产生的 mini-batch 索引列表来  ``dataset``  中索引样本并组成 mini-batch。默认值为 None。
+    - **batch_size** (int|None，可选) - 每 mini-batch 中样本个数，为  ``batch_sampler``  的替代参数，若  ``batch_sampler``  未设置，会根据  ``batch_size``   ``shuffle``   ``drop_last``  创建一个  ``paddle.io.BatchSampler`` 。默认值为 1。
+    - **shuffle** (bool，可选) - 生成 mini-batch 索引列表时是否对索引打乱顺序，为  ``batch_sampler``  的替代参数，若  ``batch_sampler``  未设置，会根据  ``batch_size``   ``shuffle``   ``drop_last``  创建一个  ``paddle.io.BatchSampler`` 。默认值为 False。
+    - **drop_last** (bool，可选) - 是否丢弃因数据集样本数不能被  ``batch_size``  整除而产生的最后一个不完整的 mini-batch，为  ``batch_sampler``  的替代参数，若  ``batch_sampler``  未设置，会根据  ``batch_size``   ``shuffle``   ``drop_last``  创建一个  ``paddle.io.BatchSampler`` 。默认值为 False。
+    - **collate_fn** (callable，可选) - 通过此参数指定如何将样本列表组合为 mini-batch 数据，当  ``collate_fn``  为 None 时，默认为将样本个字段在第 0 维上堆叠(同  ``np.stack(..., axis=0)``  )为 mini-batch 的数据。默认值为 None。
     - **num_workers** (int，可选) - 用于加载数据的子进程个数，若为 0 即为不开启子进程，在主进程中进行数据加载。默认值为 0。
-    - **use_buffer_reader** (bool，可选) - 是否使用缓存读取器。若 ``use_buffer_reader`` 为 True，DataLoader 会异步地预读取一定数量（默认读取下一个）的 mini-batch 的数据，可加速数据读取过程，但同时会占用少量的 CPU/GPU 存储，即一个 batch 输入数据的存储空间。默认值为 True。
-    - **prefetch_factor** (int，可选) - 缓存的 mini-batch 的个数。若 ``use_buffer_reader`` 为 True，DataLoader 会异步地预读取 ``prefetch_factor`` 个 mini-batch。默认值为 2。
-    - **use_shared_memory** (bool，可选) - 是否使用共享内存来提升子进程将数据放入进程间队列的速度，该参数仅在多进程模式下有效(即 ``num_workers > 0`` )，请确认机器上有足够的共享内存空间(如 Linux 系统下 ``/dev/shm/`` 目录空间大小)再设置此参数。默认为 True。
+    - **use_buffer_reader** (bool，可选) - 是否使用缓存读取器。若  ``use_buffer_reader``  为 True，DataLoader 会异步地预读取一定数量（默认读取下一个）的 mini-batch 的数据，可加速数据读取过程，但同时会占用少量的 CPU/GPU 存储，即一个 batch 输入数据的存储空间。默认值为 True。
+    - **prefetch_factor** (int，可选) - 缓存的 mini-batch 的个数。若  ``use_buffer_reader``  为 True，DataLoader 会异步地预读取  ``prefetch_factor``  个 mini-batch。默认值为 2。
+    - **use_shared_memory** (bool，可选) - 是否使用共享内存来提升子进程将数据放入进程间队列的速度，该参数仅在多进程模式下有效(即  ``num_workers > 0``  )，请确认机器上有足够的共享内存空间(如 Linux 系统下  ``/dev/shm/``  目录空间大小)再设置此参数。默认为 True。
     - **timeout** (int，可选) - 从子进程输出队列获取 mini-batch 数据的超时时间。默认值为 0。
-    - **worker_init_fn** (callable，可选) - 子进程初始化函数，此函数会被子进程初始化时被调用，并传递 ``worker id`` 作为参数。默认值为 None。
+    - **worker_init_fn** (callable，可选) - 子进程初始化函数，此函数会被子进程初始化时被调用，并传递  ``worker id``  作为参数。默认值为 None。
 
 返回
 ::::::::::::
-DataLoader，迭代 ``dataset`` 数据的迭代器，迭代器返回的数据中的每个元素都是一个 Tensor。
+DataLoader，迭代  ``dataset``  数据的迭代器，迭代器返回的数据中的每个元素都是一个 Tensor。
 
 
 代码示例
diff --git a/docs/api/paddle/io/Dataset_cn.rst b/docs/api/paddle/io/Dataset_cn.rst
index 56c619b0065..79228f718bd 100644
--- a/docs/api/paddle/io/Dataset_cn.rst
+++ b/docs/api/paddle/io/Dataset_cn.rst
@@ -9,11 +9,11 @@ Dataset
 
 映射式（map-style）数据集需要继承这个基类，映射式数据集为可以通过一个键值索引并获取指定样本的数据集，所有映射式数据集须实现以下方法：
 
-``__getitem__``：根据给定索引获取数据集中指定样本，在 ``paddle.io.DataLoader`` 中需要使用此函数通过下标获取样本。
+ ``__getitem__`` ：根据给定索引获取数据集中指定样本，在  ``paddle.io.DataLoader``  中需要使用此函数通过下标获取样本。
 
-``__len__``：返回数据集样本个数，``paddle.io.BatchSampler`` 中需要样本个数生成下标序列。
+ ``__len__`` ：返回数据集样本个数， ``paddle.io.BatchSampler``  中需要样本个数生成下标序列。
 
-见 ``paddle.io.DataLoader`` 。
+见  ``paddle.io.DataLoader``  。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/io/DistributedBatchSampler_cn.rst b/docs/api/paddle/io/DistributedBatchSampler_cn.rst
index 23040c839ab..b5fbdb151fa 100644
--- a/docs/api/paddle/io/DistributedBatchSampler_cn.rst
+++ b/docs/api/paddle/io/DistributedBatchSampler_cn.rst
@@ -14,7 +14,7 @@ DistributedBatchSampler
 参数
 ::::::::::::
 
-    - **dataset** (Dataset) - 此参数必须是 :ref:`cn_api_paddle_io_Dataset` 的一个子类实例或实现了 ``__len__`` 的 Python 对象，用于生成样本下标。
+    - **dataset** (Dataset) - 此参数必须是 :ref:`cn_api_paddle_io_Dataset` 的一个子类实例或实现了  ``__len__``  的 Python 对象，用于生成样本下标。
     - **batch_size** (int) - 每 mini-batch 中包含的样本数。
     - **num_replicas** (int，可选) - 分布式训练时的进程个数。如果是 None，会依据 :ref:`cn_api_paddle_distributed_ParallelEnv` 获取值。默认是 None。
     - **rank** (int，可选) - num_replicas 个进程中的进程序号。如果是 None，会依据 :ref:`cn_api_paddle_distributed_ParallelEnv` 获取值。默认是 None。
@@ -37,7 +37,7 @@ COPY-FROM: paddle.io.DistributedBatchSampler
 set_epoch(epoch)
 '''''''''
 
-设置 epoch 数。当设置``shuffle=True``时，此 epoch 被用作随机种子。默认情况下，用户可以不用此接口设置，每个 epoch 时，所有的进程(workers)使用不同的顺序。如果每个 epoch 设置相同的数字，每个 epoch 数据的读取顺序将会相同。
+设置 epoch 数。当设置 ``shuffle=True`` 时，此 epoch 被用作随机种子。默认情况下，用户可以不用此接口设置，每个 epoch 时，所有的进程(workers)使用不同的顺序。如果每个 epoch 设置相同的数字，每个 epoch 数据的读取顺序将会相同。
 
 **参数**
 
diff --git a/docs/api/paddle/io/IterableDataset_cn.rst b/docs/api/paddle/io/IterableDataset_cn.rst
index 36799624911..ca59bb53eeb 100644
--- a/docs/api/paddle/io/IterableDataset_cn.rst
+++ b/docs/api/paddle/io/IterableDataset_cn.rst
@@ -9,10 +9,10 @@ IterableDataset
 
 迭代式(iterable style)数据集需要继承这个基类，迭代式数据集为只能依次迭代式获取样本的数据集，类似 Python 中的迭代器，所有迭代式数据集须实现以下方法：
 
-``__iter__``：依次返回数据样本。
+ ``__iter__`` ：依次返回数据样本。
 
 .. note::
-    迭代式数据集不需要实现 ``__getitem__`` 和 ``__len__``，也不可以调用迭代式数据集的这两个方法。
+    迭代式数据集不需要实现  ``__getitem__``  和  ``__len__`` ，也不可以调用迭代式数据集的这两个方法。
 
 见 :ref:`cn_api_paddle_io_DataLoader` 。
 
@@ -21,14 +21,14 @@ IterableDataset
 
 COPY-FROM: paddle.io.IterableDataset:code-example1
 
-当 ``paddle.io.DataLoader`` 中 ``num_workers > 0`` 时，每个子进程都会遍历全量的数据集返回全量样本，所以数据集会重复 ``num_workers``
-次，如果需要数据集样本不会重复返回，可通过如下两种方法避免样本重复，两种方法中都需要通过 ``paddle.io.get_worker_info`` 获取各子进程的信息。
+当  ``paddle.io.DataLoader``  中  ``num_workers > 0``  时，每个子进程都会遍历全量的数据集返回全量样本，所以数据集会重复  ``num_workers`` 
+次，如果需要数据集样本不会重复返回，可通过如下两种方法避免样本重复，两种方法中都需要通过  ``paddle.io.get_worker_info``  获取各子进程的信息。
 
 
 代码示例 2
 ::::::::::::
 
-通过 ``__iter__`` 函数划分各子进程的数据
+通过  ``__iter__``  函数划分各子进程的数据
 
 COPY-FROM: paddle.io.IterableDataset:code-example2
 
@@ -36,6 +36,6 @@ COPY-FROM: paddle.io.IterableDataset:code-example2
 代码示例 3
 ::::::::::::
 
-通过各子进程初始化函数 ``worker_inif_fn`` 划分子进程数据
+通过各子进程初始化函数  ``worker_inif_fn``  划分子进程数据
 
 COPY-FROM: paddle.io.IterableDataset:code-example3
diff --git a/docs/api/paddle/io/RandomSampler_cn.rst b/docs/api/paddle/io/RandomSampler_cn.rst
index da91031c18d..4a62203516f 100644
--- a/docs/api/paddle/io/RandomSampler_cn.rst
+++ b/docs/api/paddle/io/RandomSampler_cn.rst
@@ -5,14 +5,14 @@ RandomSampler
 
 .. py:class:: paddle.io.RandomSampler(data_source, replacement=False, num_samples=None, generator=None)
 
-随机迭代样本，产生重排下标，如果 ``replacement = False``，则会采样整个数据集；如果 ``replacement = True``，则会按照 ``num_samples`` 指定的样本数采集。
+随机迭代样本，产生重排下标，如果  ``replacement = False`` ，则会采样整个数据集；如果  ``replacement = True`` ，则会按照  ``num_samples``  指定的样本数采集。
 
 参数
 :::::::::
-    - **data_source** (Dataset) - 此参数必须是 :ref:`cn_api_paddle_io_Dataset` 或 :ref:`cn_api_paddle_io_IterableDataset` 的一个子类实例或实现了 ``__len__`` 的 Python 对象，用于生成样本下标。默认值为 None。
-    - **replacement** (bool，可选) - 如果为 ``False`` 则会采样整个数据集，如果为 ``True`` 则会按 ``num_samples`` 指定的样本数采集。默认值为 ``False`` 。
-    - **num_samples** (int，可选) - 按此参数采集对应的样本数。默认值为 None，此时设为 ``data_source`` 的长度。
-    - **generator** (Generator，可选) - 指定采样 ``data_source`` 的采样器。默认值为 None，不启用。
+    - **data_source** (Dataset) - 此参数必须是 :ref:`cn_api_paddle_io_Dataset` 或 :ref:`cn_api_paddle_io_IterableDataset` 的一个子类实例或实现了  ``__len__``  的 Python 对象，用于生成样本下标。默认值为 None。
+    - **replacement** (bool，可选) - 如果为  ``False``  则会采样整个数据集，如果为  ``True``  则会按  ``num_samples``  指定的样本数采集。默认值为  ``False``  。
+    - **num_samples** (int，可选) - 按此参数采集对应的样本数。默认值为 None，此时设为  ``data_source``  的长度。
+    - **generator** (Generator，可选) - 指定采样  ``data_source``  的采样器。默认值为 None，不启用。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/io/Sampler_cn.rst b/docs/api/paddle/io/Sampler_cn.rst
index 0a5e05d9837..307af28c237 100644
--- a/docs/api/paddle/io/Sampler_cn.rst
+++ b/docs/api/paddle/io/Sampler_cn.rst
@@ -9,16 +9,16 @@ Sampler
 
 所有数据集采样器必须继承这个基类，并实现以下方法：
 
-``__iter__``：迭代返回数据样本下标
+ ``__iter__`` ：迭代返回数据样本下标
 
-``__len__``: ``data_source`` 中的样本数
+ ``__len__`` :  ``data_source``  中的样本数
 
 参数
 ::::::::::::
 
-    - **data_source** (Dataset) - 此参数必须是 ``paddle.io.Dataset`` 或 ``paddle.io.IterableDataset`` 的一个子类实例或实现了 ``__len__`` 的 Python 对象，用于生成样本下标。默认值为 None。
+    - **data_source** (Dataset) - 此参数必须是  ``paddle.io.Dataset``  或  ``paddle.io.IterableDataset``  的一个子类实例或实现了  ``__len__``  的 Python 对象，用于生成样本下标。默认值为 None。
 
-可见 ``paddle.io.BatchSampler`` 和 ``paddle.io.DataLoader``
+可见  ``paddle.io.BatchSampler``  和  ``paddle.io.DataLoader`` 
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/io/SequenceSampler_cn.rst b/docs/api/paddle/io/SequenceSampler_cn.rst
index 6b7d131081d..5b0e7e1c471 100644
--- a/docs/api/paddle/io/SequenceSampler_cn.rst
+++ b/docs/api/paddle/io/SequenceSampler_cn.rst
@@ -5,12 +5,12 @@ SequenceSampler
 
 .. py:class:: paddle.io.SequenceSampler(data_source=None)
 
-顺序迭代 ``data_source`` 返回样本下标，即一次返回 ``0, 1, 2, ..., len(data_source) - 1``
+顺序迭代  ``data_source``  返回样本下标，即一次返回  ``0, 1, 2, ..., len(data_source) - 1`` 
 
 参数
 ::::::::::::
 
-    - **data_source** (Dataset) - 此参数必须是 ``paddle.io.Dataset`` 或 ``paddle.io.IterableDataset`` 的一个子类实例或实现了 ``__len__`` 的 Python 对象，用于生成样本下标。默认值为 None。
+    - **data_source** (Dataset) - 此参数必须是  ``paddle.io.Dataset``  或  ``paddle.io.IterableDataset``  的一个子类实例或实现了  ``__len__``  的 Python 对象，用于生成样本下标。默认值为 None。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/io/WeightedRandomSampler_cn.rst b/docs/api/paddle/io/WeightedRandomSampler_cn.rst
index 67ec3794c89..378598a0949 100644
--- a/docs/api/paddle/io/WeightedRandomSampler_cn.rst
+++ b/docs/api/paddle/io/WeightedRandomSampler_cn.rst
@@ -5,7 +5,7 @@ WeightedRandomSampler
 
 .. py:class:: paddle.io.WeightedRandomSampler(weights, num_samples, replacement=True)
 
-通过制定的权重随机采样，采样下标范围在 ``[0, len(weights) - 1]``，如果 ``replacement`` 为 ``True``，则下标可被采样多次
+通过制定的权重随机采样，采样下标范围在  ``[0, len(weights) - 1]`` ，如果  ``replacement``  为  ``True`` ，则下标可被采样多次
 
 参数
 :::::::::
diff --git a/docs/api/paddle/io/get_worker_info_cn.rst b/docs/api/paddle/io/get_worker_info_cn.rst
index 1ae66b4a611..4ea20cf3023 100644
--- a/docs/api/paddle/io/get_worker_info_cn.rst
+++ b/docs/api/paddle/io/get_worker_info_cn.rst
@@ -5,12 +5,12 @@ get_worker_info
 
 .. py:class:: paddle.io.get_worker_info
 
-获取 ``paddle.io.DataLoader`` 子进程信息的函数，用于 ``paddle.io.IterableDataset`` 中划分子进程数据。子进程信息包含以下字段：
+获取  ``paddle.io.DataLoader``  子进程信息的函数，用于  ``paddle.io.IterableDataset``  中划分子进程数据。子进程信息包含以下字段：
 
-``num_workers``：子进程数。
+ ``num_workers`` ：子进程数。
 
-``id``：子进程逻辑序号，从 0 到 ``num_workers - 1``
+ ``id`` ：子进程逻辑序号，从 0 到  ``num_workers - 1`` 
 
-``dataset``：各子进程中数据集实例。
+ ``dataset`` ：各子进程中数据集实例。
 
-示例代码见 ``paddle.io.IterableDataset``
+示例代码见  ``paddle.io.IterableDataset`` 
diff --git a/docs/api/paddle/io/random_split_cn.rst b/docs/api/paddle/io/random_split_cn.rst
index 853ca17fab4..5f9a6f299c0 100644
--- a/docs/api/paddle/io/random_split_cn.rst
+++ b/docs/api/paddle/io/random_split_cn.rst
@@ -10,9 +10,9 @@ random_split
 参数
 ::::::::::::
 
-    - **dataset** (Dataset) - 此参数必须是 ``paddle.io.Dataset`` 或 ``paddle.io.IterableDataset`` 的一个子类实例或实现了 ``__len__`` 的 Python 对象，用于生成样本下标。默认值为 None。
+    - **dataset** (Dataset) - 此参数必须是  ``paddle.io.Dataset``  或  ``paddle.io.IterableDataset``  的一个子类实例或实现了  ``__len__``  的 Python 对象，用于生成样本下标。默认值为 None。
     - **lengths** (list) - 总和为原数组长度，表示子集合长度数组；或总和为 1.0，表示子集合长度占比的数组。
-    - **generator** (Generator，可选) - 指定采样 ``data_source`` 的采样器。默认值为 None。
+    - **generator** (Generator，可选) - 指定采样  ``data_source``  的采样器。默认值为 None。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/is_autocast_enabled_cn.rst b/docs/api/paddle/is_autocast_enabled_cn.rst
index b0cb7f11fbc..7dfc4a89f18 100644
--- a/docs/api/paddle/is_autocast_enabled_cn.rst
+++ b/docs/api/paddle/is_autocast_enabled_cn.rst
@@ -18,7 +18,7 @@ is_autocast_enabled
 
 返回
 ::::::::::::
-布尔值，如果当前上下文中启用了自动混合精度，则返回 ``True``，否则返回 ``False``。
+布尔值，如果当前上下文中启用了自动混合精度，则返回  ``True`` ，否则返回  ``False`` 。
 
 
 代码示例
diff --git a/docs/api/paddle/is_complex_cn.rst b/docs/api/paddle/is_complex_cn.rst
index 41f9147286e..5cf41bd9fe2 100644
--- a/docs/api/paddle/is_complex_cn.rst
+++ b/docs/api/paddle/is_complex_cn.rst
@@ -8,11 +8,11 @@ is_complex
 判断输入 tensor 的数据类型是否为复数类型(complex64 或者 complex128)。
 
 .. note::
-   别名支持: 参数名 ``input`` 可替代 ``x``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``。
+   别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` 。
 
 参数
 :::::::::
-   - **x** (Tensor) - 输入 Tensor。别名： ``input``。
+   - **x** (Tensor) - 输入 Tensor。别名：  ``input`` 。
 
 
 返回
diff --git a/docs/api/paddle/is_floating_point_cn.rst b/docs/api/paddle/is_floating_point_cn.rst
index b4418a58844..a6a8494b103 100644
--- a/docs/api/paddle/is_floating_point_cn.rst
+++ b/docs/api/paddle/is_floating_point_cn.rst
@@ -7,12 +7,12 @@ is_floating_point
 判断输入 Tensor 的数据类型是否为浮点类型。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``is_floating_point(input=tensor_x)`` 等价于 ``is_floating_point(x=tensor_x)`` 。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``is_floating_point(input=tensor_x)``  等价于  ``is_floating_point(x=tensor_x)``  。
 
 参数
 :::::::::
 
-    - **x**  (Tensor) - 输入的 Tensor。别名： ``input``。
+    - **x**  (Tensor) - 输入的 Tensor。别名：  ``input`` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/is_tensor_cn.rst b/docs/api/paddle/is_tensor_cn.rst
index a4c9816d45a..75d5b21f622 100644
--- a/docs/api/paddle/is_tensor_cn.rst
+++ b/docs/api/paddle/is_tensor_cn.rst
@@ -8,12 +8,12 @@ is_tensor
 测试输入对象是否是 `paddle.Tensor`
 
 .. note::
-    别名支持: 参数名 ``obj`` 可替代 ``x``，如 ``is_tensor(obj=tensor_x)`` 等价于 ``is_tensor(x=tensor_x)`` 。
+    别名支持: 参数名  ``obj``  可替代  ``x`` ，如  ``is_tensor(obj=tensor_x)``  等价于  ``is_tensor(x=tensor_x)``  。
 
 参数
 ::::::::::::
 
-    - **x** (Object) - 测试的对象。别名： ``obj``。
+    - **x** (Object) - 测试的对象。别名：  ``obj`` 。
 
 
 返回
diff --git a/docs/api/paddle/isfinite_cn.rst b/docs/api/paddle/isfinite_cn.rst
index 9cd8d6fce78..6e653cc9080 100644
--- a/docs/api/paddle/isfinite_cn.rst
+++ b/docs/api/paddle/isfinite_cn.rst
@@ -8,17 +8,17 @@ isfinite
 返回输入 Tensor 的每一个值是否为有限值（既非 `+/-INF` 也非 `+/-NaN` ）。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` 。
 
 参数
 :::::::::
     - **x** (Tensor)：输入的 `Tensor`，数据类型为：float16、float32、float64、int32、int64、complex64、complex128。
-      别名： ``input``
+      别名：  ``input`` 
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-``Tensor``，每个元素是一个 bool 值，表示输入 `x` 的每个元素是否为有限值（既非 `+/-INF` 也非 `+/-NaN` ）。
+ ``Tensor`` ，每个元素是一个 bool 值，表示输入 `x` 的每个元素是否为有限值（既非 `+/-INF` 也非 `+/-NaN` ）。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/isin_cn.rst b/docs/api/paddle/isin_cn.rst
index c6a53479837..66e786f763f 100644
--- a/docs/api/paddle/isin_cn.rst
+++ b/docs/api/paddle/isin_cn.rst
@@ -5,22 +5,22 @@ isin
 
 .. py:function:: paddle.isin(x, test_x, assume_unique=False, invert=False, name=None)
 
-检验 ``x`` 中的每一个元素是否在 ``test_x`` 中。
+检验  ``x``  中的每一个元素是否在  ``test_x``  中。
 
 .. note::
-    别名支持: 参数名 ``elements`` 可替代 ``x``，参数名 ``test_elements`` 可替代 ``test_x``，如 ``isin(elements=tensor1, test_elements=tensor2)`` 等价于 ``isin(x=tensor1, test_x=tensor2)`` 。
+    别名支持: 参数名  ``elements``  可替代  ``x`` ，参数名  ``test_elements``  可替代  ``test_x`` ，如  ``isin(elements=tensor1, test_elements=tensor2)``  等价于  ``isin(x=tensor1, test_x=tensor2)``  。
 
 参数
 :::::::::
-    - **x** (Tensor) - 输入的 tensor，数据类型为：'bfloat16', 'float16', 'float32', 'float64', 'int32', 'int64'。别名： ``elements``。
-    - **test_x** (Tensor) - 用于检验的 tensor，数据类型为：'bfloat16', 'float16', 'float32', 'float64', 'int32', 'int64'。别名： ``test_elements``。
-    - **assume_unique** (bool，可选) - 如果设置为 True，表示 ``x`` 与 ``test_x`` 的元素均是唯一的，这种情况可以提升计算的速度。默认值为 False。
+    - **x** (Tensor) - 输入的 tensor，数据类型为：'bfloat16', 'float16', 'float32', 'float64', 'int32', 'int64'。别名：  ``elements`` 。
+    - **test_x** (Tensor) - 用于检验的 tensor，数据类型为：'bfloat16', 'float16', 'float32', 'float64', 'int32', 'int64'。别名：  ``test_elements`` 。
+    - **assume_unique** (bool，可选) - 如果设置为 True，表示  ``x``  与  ``test_x``  的元素均是唯一的，这种情况可以提升计算的速度。默认值为 False。
     - **invert** (bool，可选) - 是否输出反转的结果。如果为 True，表示将结果反转。默认值为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-``Tensor``，输出的 tensor 与输入 ``x`` 形状相同。
+ ``Tensor`` ，输出的 tensor 与输入  ``x``  形状相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/isinf_cn.rst b/docs/api/paddle/isinf_cn.rst
index bda9e1becbd..95b312840f9 100644
--- a/docs/api/paddle/isinf_cn.rst
+++ b/docs/api/paddle/isinf_cn.rst
@@ -8,17 +8,17 @@ isinf
 返回输入 tensor 的每一个值是否为 `+/-INF` 。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` 。
 
 参数
 :::::::::
     - **x** (Tensor)：输入的 `Tensor`，数据类型为：float16、float32、float64、uint8、int8、int16、int32、int64、complex64、complex128。
-      别名： ``input``
+      别名：  ``input`` 
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-``Tensor``，每个元素是一个 bool 值，表示输入 `x` 的每个元素是否为 `+/-INF` 。
+ ``Tensor`` ，每个元素是一个 bool 值，表示输入 `x` 的每个元素是否为 `+/-INF` 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/isnan_cn.rst b/docs/api/paddle/isnan_cn.rst
index 0344279bc65..3690c1b234d 100644
--- a/docs/api/paddle/isnan_cn.rst
+++ b/docs/api/paddle/isnan_cn.rst
@@ -8,17 +8,17 @@ isnan
 返回输入 tensor 的每一个值是否为 `+/-NaN` 。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` 。
 
 参数
 :::::::::
     - **x** (Tensor) - 输入的 `Tensor`，数据类型为：float16、float32、float64、int32、int64、complex64、complex128。
-      别名： ``input``
+      别名：  ``input`` 
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-``Tensor``，每个元素是一个 bool 值，表示输入 `x` 的每个元素是否为 `+/-NaN` 。
+ ``Tensor`` ，每个元素是一个 bool 值，表示输入 `x` 的每个元素是否为 `+/-NaN` 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/isneginf_cn.rst b/docs/api/paddle/isneginf_cn.rst
index 92cc528840d..0124ce98285 100644
--- a/docs/api/paddle/isneginf_cn.rst
+++ b/docs/api/paddle/isneginf_cn.rst
@@ -14,7 +14,7 @@ isneginf
 
 返回
 :::::::::
-``Tensor``，每个元素是一个 bool 值，表示输入 `x` 的每个元素是否为 `-INF` 。
+ ``Tensor`` ，每个元素是一个 bool 值，表示输入 `x` 的每个元素是否为 `-INF` 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/isposinf_cn.rst b/docs/api/paddle/isposinf_cn.rst
index b30cf9a8895..0404a8e8bae 100644
--- a/docs/api/paddle/isposinf_cn.rst
+++ b/docs/api/paddle/isposinf_cn.rst
@@ -14,7 +14,7 @@ isposinf
 
 返回
 :::::::::
-``Tensor``，每个元素是一个 bool 值，表示输入 `x` 的每个元素是否为 `+INF` 。
+ ``Tensor`` ，每个元素是一个 bool 值，表示输入 `x` 的每个元素是否为 `+INF` 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/isreal_cn.rst b/docs/api/paddle/isreal_cn.rst
index 77b0128c501..2b6ebb365c2 100644
--- a/docs/api/paddle/isreal_cn.rst
+++ b/docs/api/paddle/isreal_cn.rst
@@ -15,7 +15,7 @@ isreal
 
 返回
 :::::::::
-``Tensor``，每个元素是一个 bool 值，表示输入 `x` 的每个元素是否为实数类型。
+ ``Tensor`` ，每个元素是一个 bool 值，表示输入 `x` 的每个元素是否为实数类型。
 
 
 代码示例
diff --git a/docs/api/paddle/jit/TranslatedLayer_cn.rst b/docs/api/paddle/jit/TranslatedLayer_cn.rst
index 7a3ee0826eb..7b0fa367647 100644
--- a/docs/api/paddle/jit/TranslatedLayer_cn.rst
+++ b/docs/api/paddle/jit/TranslatedLayer_cn.rst
@@ -5,11 +5,11 @@ TranslatedLayer
 
 .. py:class:: paddle.jit.TranslatedLayer(programs, persistable_vars)
 
-``TranslatedLayer`` 是一个命令式编程模式 :ref:`cn_api_paddle_nn_Layer` 的继承类，
-通过 :ref:`cn_api_paddle_jit_load` 载入构建。能够像一般 ``Layer`` 一样在 train 或者 eval 模式下使用。
+ ``TranslatedLayer``  是一个命令式编程模式 :ref:`cn_api_paddle_nn_Layer` 的继承类，
+通过 :ref:`cn_api_paddle_jit_load` 载入构建。能够像一般  ``Layer``  一样在 train 或者 eval 模式下使用。
 
 .. note::
-  ``TranslatedLayer`` 对象不能够通过构造函数创建，仅能够通过 :ref:`cn_api_paddle_jit_load` 接口载入构建。
+   ``TranslatedLayer``  对象不能够通过构造函数创建，仅能够通过 :ref:`cn_api_paddle_jit_load` 接口载入构建。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/jit/enable_to_static_cn.rst b/docs/api/paddle/jit/enable_to_static_cn.rst
index 31fabd19e00..8de7feeff92 100644
--- a/docs/api/paddle/jit/enable_to_static_cn.rst
+++ b/docs/api/paddle/jit/enable_to_static_cn.rst
@@ -11,7 +11,7 @@ enable_to_static
 参数
 ::::::::::::
 
-    - **enable_to_static_bool** (bool) - 启用或禁用动转静。为 ``True`` 时启用动转静, 为 ``False`` 时关闭动转静。
+    - **enable_to_static_bool** (bool) - 启用或禁用动转静。为  ``True``  时启用动转静, 为  ``False``  时关闭动转静。
 
 
 代码示例
diff --git a/docs/api/paddle/jit/load_cn.rst b/docs/api/paddle/jit/load_cn.rst
index 088d161f647..6bffff4a6cb 100644
--- a/docs/api/paddle/jit/load_cn.rst
+++ b/docs/api/paddle/jit/load_cn.rst
@@ -6,25 +6,25 @@ load
 .. py:function:: paddle.jit.load(path, **configs)
 
 
-将接口 ``paddle.jit.save`` 或者 ``paddle.static.save_inference_model`` 存储的模型载入为 ``paddle.jit.TranslatedLayer``，用于预测推理或者 fine-tune 训练。
+将接口  ``paddle.jit.save``  或者  ``paddle.static.save_inference_model``  存储的模型载入为  ``paddle.jit.TranslatedLayer`` ，用于预测推理或者 fine-tune 训练。
 
 .. note::
-    如果载入的模型是通过 ``paddle.static.save_inference_model`` 存储的，在使用它进行 fine-tune 训练时会存在一些局限：
+    如果载入的模型是通过  ``paddle.static.save_inference_model``  存储的，在使用它进行 fine-tune 训练时会存在一些局限：
     1. 命令式编程模式所有原先输入变量或者参数依赖于 LoD 信息的模型暂时无法使用；
-    2. 所有存储模型的 feed 变量都需要被传入 ``Translatedlayer`` 的 forward 方法；
-    3. 原模型变量的 ``stop_gradient`` 信息已丢失且无法准确恢复；
-    4. 原模型参数的 ``trainable`` 信息已丢失且无法准确恢复。
+    2. 所有存储模型的 feed 变量都需要被传入  ``Translatedlayer``  的 forward 方法；
+    3. 原模型变量的  ``stop_gradient``  信息已丢失且无法准确恢复；
+    4. 原模型参数的  ``trainable``  信息已丢失且无法准确恢复。
 
 参数
 :::::::::
-    - **path** (str) - 载入模型的路径前缀。格式为 ``dirname/file_prefix`` 或者 ``file_prefix`` 。
-    - **config** (dict，可选) - 其他用于兼容的载入配置选项。这些选项将来可能被移除，如果不是必须使用，不推荐使用这些配置选项。默认为 ``None``。目前支持以下配置选项：
-        (1) model_filename (str) - paddle 1.x 版本 ``save_inference_model`` 接口存储格式的预测模型文件名，原默认文件名为 ``__model__`` ；
-        (2) params_filename (str) - paddle 1.x 版本 ``save_inference_model`` 接口存储格式的参数文件名，没有默认文件名，默认将各个参数分散存储为单独的文件。
+    - **path** (str) - 载入模型的路径前缀。格式为  ``dirname/file_prefix``  或者  ``file_prefix``  。
+    - **config** (dict，可选) - 其他用于兼容的载入配置选项。这些选项将来可能被移除，如果不是必须使用，不推荐使用这些配置选项。默认为  ``None`` 。目前支持以下配置选项：
+        (1) model_filename (str) - paddle 1.x 版本  ``save_inference_model``  接口存储格式的预测模型文件名，原默认文件名为  ``__model__``  ；
+        (2) params_filename (str) - paddle 1.x 版本  ``save_inference_model``  接口存储格式的参数文件名，没有默认文件名，默认将各个参数分散存储为单独的文件。
 
 返回
 :::::::::
-TranslatedLayer，一个能够执行存储模型的 ``Layer`` 对象。
+TranslatedLayer，一个能够执行存储模型的  ``Layer``  对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/jit/save_cn.rst b/docs/api/paddle/jit/save_cn.rst
index 03ddcfc0c22..02ba3bbb5ca 100644
--- a/docs/api/paddle/jit/save_cn.rst
+++ b/docs/api/paddle/jit/save_cn.rst
@@ -5,27 +5,27 @@ save
 
 .. py:function:: paddle.jit.save(layer, path, input_spec=None, **configs)
 
-将输入的 ``Layer`` 或 ``function`` 存储为 ``paddle.jit.TranslatedLayer`` 格式的模型，载入后可用于预测推理或者 fine-tune 训练。
+将输入的  ``Layer``  或  ``function``  存储为  ``paddle.jit.TranslatedLayer``  格式的模型，载入后可用于预测推理或者 fine-tune 训练。
 
-该接口会将输入 ``Layer`` 转写后的模型结构 ``Program`` 和所有必要的持久参数变量存储至输入路径 ``path`` 。
+该接口会将输入  ``Layer``  转写后的模型结构  ``Program``  和所有必要的持久参数变量存储至输入路径  ``path``  。
 
-``path`` 是存储目标的前缀，存储的模型结构 ``Program`` 文件的后缀为 ``.pdmodel`` ，存储的持久参数变量文件的后缀为 ``.pdiparams``，同时这里也会将一些变量描述信息存储至文件，文件后缀为 ``.pdiparams.info``，这些额外的信息将在 fine-tune 训练中使用。
+ ``path``  是存储目标的前缀，存储的模型结构  ``Program``  文件的后缀为  ``.pdmodel``  ，存储的持久参数变量文件的后缀为  ``.pdiparams`` ，同时这里也会将一些变量描述信息存储至文件，文件后缀为  ``.pdiparams.info`` ，这些额外的信息将在 fine-tune 训练中使用。
 
 存储的模型能够被以下 API 完整地载入使用：
 
-    - ``paddle.jit.load``
-    - ``paddle.static.load_inference_model``
+    -  ``paddle.jit.load`` 
+    -  ``paddle.static.load_inference_model`` 
     - 其他 C++ 预测库 API
 
 .. note::
-    当使用 ``paddle.jit.save`` 保存 ``function`` 时，``function`` 不能包含参数变量。如果必须保存参数变量，请用 Layer 封装 function，然后按照处理 Layer 的方式调用相应的 API。
+    当使用  ``paddle.jit.save``  保存  ``function``  时， ``function``  不能包含参数变量。如果必须保存参数变量，请用 Layer 封装 function，然后按照处理 Layer 的方式调用相应的 API。
 
 参数
 :::::::::
-    - **layer** (Layer|function) - 需要存储的 ``Layer`` 对象或者 ``function``。
-    - **path** (str) - 存储模型的路径前缀。格式为 ``dirname/file_prefix`` 或者 ``file_prefix`` 。
-    - **input_spec** (list or tuple[InputSpec|Tensor|Python built-in variable]，可选) - 描述存储模型 forward 方法的输入，可以通过 InputSpec 或者示例 Tensor 进行描述。此外，我们还支持指定非张量类型的参数，比如 int、float、string，或者这些类型的列表/字典。如果为 ``None``，所有原 ``Layer`` forward 方法的输入变量将都会被配置为存储模型的输入变量。默认为 ``None``。
-    - **configs** (dict，可选) - 其他用于兼容的存储配置选项。这些选项将来可能被移除，如果不是必须使用，不推荐使用这些配置选项。默认为 ``None``。目前支持以下配置选项：(1) output_spec (list[Tensor]) - 选择存储模型的输出目标。默认情况下，所有原 ``Layer`` forward 方法的返回值均会作为存储模型的输出。如果传入的 ``output_spec`` 列表不是所有的输出变量，存储的模型将会根据 ``output_spec`` 所包含的结果被裁剪。
+    - **layer** (Layer|function) - 需要存储的  ``Layer``  对象或者  ``function`` 。
+    - **path** (str) - 存储模型的路径前缀。格式为  ``dirname/file_prefix``  或者  ``file_prefix``  。
+    - **input_spec** (list or tuple[InputSpec|Tensor|Python built-in variable]，可选) - 描述存储模型 forward 方法的输入，可以通过 InputSpec 或者示例 Tensor 进行描述。此外，我们还支持指定非张量类型的参数，比如 int、float、string，或者这些类型的列表/字典。如果为  ``None`` ，所有原  ``Layer``  forward 方法的输入变量将都会被配置为存储模型的输入变量。默认为  ``None`` 。
+    - **configs** (dict，可选) - 其他用于兼容的存储配置选项。这些选项将来可能被移除，如果不是必须使用，不推荐使用这些配置选项。默认为  ``None`` 。目前支持以下配置选项：(1) output_spec (list[Tensor]) - 选择存储模型的输出目标。默认情况下，所有原  ``Layer``  forward 方法的返回值均会作为存储模型的输出。如果传入的  ``output_spec``  列表不是所有的输出变量，存储的模型将会根据  ``output_spec``  所包含的结果被裁剪。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/jit/set_code_level_cn.rst b/docs/api/paddle/jit/set_code_level_cn.rst
index 11b457d9b53..56fb8c0f5a8 100644
--- a/docs/api/paddle/jit/set_code_level_cn.rst
+++ b/docs/api/paddle/jit/set_code_level_cn.rst
@@ -8,18 +8,18 @@ set_code_level
 
 有两种方法设置代码级别：
 
-1. 调用函数 ``set_code_level``
-2. 设置环境变量 ``TRANSLATOR_CODE_LEVEL``
+1. 调用函数  ``set_code_level`` 
+2. 设置环境变量  ``TRANSLATOR_CODE_LEVEL`` 
 
 .. note::
-    函数 ``set_code_level`` 的优先级高于环境变量 ``TRANSLATOR_CODE_LEVEL``。
+    函数  ``set_code_level``  的优先级高于环境变量  ``TRANSLATOR_CODE_LEVEL`` 。
 
 
 参数
 ::::::::::::
 
   - **level** (int) - 打印的代码级别。默认值为 100，这意味着打印的是所有 AST Transformer 转化后的代码。
-  - **also_to_stdout** (bool) - 表示是否也将代码输出到 ``sys.stdout``。默认值 False，表示仅输出到 ``sys.stderr``。
+  - **also_to_stdout** (bool) - 表示是否也将代码输出到  ``sys.stdout`` 。默认值 False，表示仅输出到  ``sys.stderr`` 。
 
 
 代码示例
diff --git a/docs/api/paddle/jit/set_verbosity_cn.rst b/docs/api/paddle/jit/set_verbosity_cn.rst
index f81f4d61a7d..27622a8e136 100644
--- a/docs/api/paddle/jit/set_verbosity_cn.rst
+++ b/docs/api/paddle/jit/set_verbosity_cn.rst
@@ -8,18 +8,18 @@ set_verbosity
 
 有两种方法设置日志详细级别：
 
-1. 调用函数 ``set_verbosity``；
-2. 设置环境变量 ``TRANSLATOR_VERBOSITY``。
+1. 调用函数  ``set_verbosity`` ；
+2. 设置环境变量  ``TRANSLATOR_VERBOSITY`` 。
 
 .. note::
-    函数 ``set_verbosity`` 的优先级高于环境变量 ``TRANSLATOR_VERBOSITY``。
+    函数  ``set_verbosity``  的优先级高于环境变量  ``TRANSLATOR_VERBOSITY`` 。
 
 
 参数
 ::::::::::::
 
     - **level** (int) - 日志详细级别。值越大，表示越详细。默认值为 0，表示不显示日志。
-    - **also_to_stdout** (bool) - 表示是否也将日志信息输出到 ``sys.stdout``。默认值 False，表示仅输出到 ``sys.stderr``。
+    - **also_to_stdout** (bool) - 表示是否也将日志信息输出到  ``sys.stdout`` 。默认值 False，表示仅输出到  ``sys.stderr`` 。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/jit/to_static_cn.rst b/docs/api/paddle/jit/to_static_cn.rst
index 8d209f760de..3c78cf4e0dd 100644
--- a/docs/api/paddle/jit/to_static_cn.rst
+++ b/docs/api/paddle/jit/to_static_cn.rst
@@ -12,12 +12,12 @@ to_static
 
     - **function** (callable) - 待转换的动态图函数。若以装饰器形式使用，则被装饰函数默认会被解析为此参数值，无需显式指定。
     - **input_spec** (list[InputSpec]|tuple[InputSpec]) - 用于指定被装饰函数中输入 Tensor 的 shape、dtype 和 name 信息，为包含 InputSpec 的 list/tuple 类型。
-    - **build_strategy** (BuildStrategy|None)：通过配置 :attr:`build_strategy`，对转换后的计算图进行优化，例如：计算图中算子融合、计算图执行过程中开启内存/显存优化等。关于 :attr:`build_strategy` 更多信息，请参阅 :ref:`paddle.static.BuildStrategy <cn_api_paddle_static_BuildStrategy>`。默认为 ``None``。
-    - **backend** (str，可选): 指定后端编译器，可以指定为 ``"CINN"`` 或者 ``None``。当该参数指定为 ``"CINN"`` 时，将会使用 ``CINN`` 编译器来加速训练和推理。默认值为 ``"CINN"``。
+    - **build_strategy** (BuildStrategy|None)：通过配置 :attr:`build_strategy`，对转换后的计算图进行优化，例如：计算图中算子融合、计算图执行过程中开启内存/显存优化等。关于 :attr:`build_strategy` 更多信息，请参阅 :ref:`paddle.static.BuildStrategy <cn_api_paddle_static_BuildStrategy>`。默认为  ``None`` 。
+    - **backend** (str，可选): 指定后端编译器，可以指定为  ``"CINN"``  或者  ``None`` 。当该参数指定为  ``"CINN"``  时，将会使用  ``CINN``  编译器来加速训练和推理。默认值为  ``"CINN"`` 。
     - **kwargs**: 支持的 key 包括 :attr:`property` 和 :attr:`full_graph`。
 
-      - **property** (bool): 表示被装饰的函数是否以 class property 属性的方式进行导出，默认为 ``False``。
-      - **full_graph** (bool): 表示被装饰的函数是否以整图静态图的方式进行导出，默认为 ``False``。
+      - **property** (bool): 表示被装饰的函数是否以 class property 属性的方式进行导出，默认为  ``False`` 。
+      - **full_graph** (bool): 表示被装饰的函数是否以整图静态图的方式进行导出，默认为  ``False`` 。
 
 
 代码示例
diff --git a/docs/api/paddle/kthvalue_cn.rst b/docs/api/paddle/kthvalue_cn.rst
index 4bfaeea5d54..5a79bf765a2 100644
--- a/docs/api/paddle/kthvalue_cn.rst
+++ b/docs/api/paddle/kthvalue_cn.rst
@@ -9,15 +9,15 @@ kthvalue
 
 参数
 :::::::::
-    - **x** （Tensor） - 一个输入的 N-D ``Tensor``，支持的数据类型：float32、float64、int32、int64。
-    - **k** （int，Tensor） - 需要沿轴查找的第 ``k`` 小，所对应的 ``k`` 值。
-    - **axis** （int，可选） - 指定对输入 Tensor 进行运算的轴，``axis`` 的有效范围是[-R, R），R 是输入 ``x`` 的 Rank， ``axis`` 为负时与 ``axis`` + R 等价。默认值为-1。
+    - **x** （Tensor） - 一个输入的 N-D  ``Tensor`` ，支持的数据类型：float32、float64、int32、int64。
+    - **k** （int，Tensor） - 需要沿轴查找的第  ``k``  小，所对应的  ``k``  值。
+    - **axis** （int，可选） - 指定对输入 Tensor 进行运算的轴， ``axis``  的有效范围是[-R, R），R 是输入  ``x``  的 Rank，  ``axis``  为负时与  ``axis``  + R 等价。默认值为-1。
     - **keepdim** (bool，可选）- 是否保留指定的轴。如果是 True，维度会与输入 x 一致，对应所指定的轴的 size 为 1。否则，由于对应轴被展开，输出的维度会比输入小 1。默认值为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-tuple（Tensor），返回第 k 小的元素和对应的索引信息。结果的数据类型和输入 ``x`` 一致。索引的数据类型是 int64。
+tuple（Tensor），返回第 k 小的元素和对应的索引信息。结果的数据类型和输入  ``x``  一致。索引的数据类型是 int64。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/ldexp_cn.rst b/docs/api/paddle/ldexp_cn.rst
index c1c1e02f8d2..ff4e36dcae0 100644
--- a/docs/api/paddle/ldexp_cn.rst
+++ b/docs/api/paddle/ldexp_cn.rst
@@ -19,7 +19,7 @@ ldexp
 
 返回
 ::::::::::::
-输出为 Tensor，如果 ``x``， ``y`` 有不同的形状并且是可广播的，那么产生的张量形状是广播后 x 和 y 的形状。如果 ``x``， ``y`` 有相同的形状，其形状与 ``x``， ``y``  相同。数据类型是 float32 或 float64。
+输出为 Tensor，如果  ``x`` ，  ``y``  有不同的形状并且是可广播的，那么产生的张量形状是广播后 x 和 y 的形状。如果  ``x`` ，  ``y``  有相同的形状，其形状与  ``x`` ，  ``y``   相同。数据类型是 float32 或 float64。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/lerp_cn.rst b/docs/api/paddle/lerp_cn.rst
index e184d805b82..dbbd47d3216 100644
--- a/docs/api/paddle/lerp_cn.rst
+++ b/docs/api/paddle/lerp_cn.rst
@@ -19,7 +19,7 @@ lerp
 返回
 :::::::::
 
-输出 Tensor，与 ``x`` 数据类型相同。
+输出 Tensor，与  ``x``  数据类型相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/lgamma_cn.rst b/docs/api/paddle/lgamma_cn.rst
index 9e9876c0e2e..7d1b3006122 100644
--- a/docs/api/paddle/lgamma_cn.rst
+++ b/docs/api/paddle/lgamma_cn.rst
@@ -20,7 +20,7 @@ lgamma
 
 返回
 :::::::::
-输出 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出 Tensor，与  ``x``  维度相同、数据类型相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/linalg/cond_cn.rst b/docs/api/paddle/linalg/cond_cn.rst
index 8825e408d87..3bac9b5ab06 100644
--- a/docs/api/paddle/linalg/cond_cn.rst
+++ b/docs/api/paddle/linalg/cond_cn.rst
@@ -6,18 +6,18 @@ cond
 .. py:function:: paddle.linalg.cond(x, p=None, name=None)
 
 
-根据范数种类 ``p`` 计算一个或一批矩阵的条件数，也可以通过 paddle.cond 来调用。
+根据范数种类  ``p``  计算一个或一批矩阵的条件数，也可以通过 paddle.cond 来调用。
 
 参数
 ::::::::::::
 
-    - **x** (Tensor)：输入可以是形状为 ``(*, m, n)`` 的矩阵 Tensor， ``*`` 为零或更大的批次维度，此时 ``p`` 为 `2` 或 `-2`；也可以是形状为 ``(*, n, n)`` 的可逆（批）方阵 Tensor，此时 ``p`` 为任意已支持的值。数据类型为 float32 或 float64 。
+    - **x** (Tensor)：输入可以是形状为  ``(*, m, n)``  的矩阵 Tensor，  ``*``  为零或更大的批次维度，此时  ``p``  为 `2` 或 `-2`；也可以是形状为  ``(*, n, n)``  的可逆（批）方阵 Tensor，此时  ``p``  为任意已支持的值。数据类型为 float32 或 float64 。
     - **p** (float|string，可选)：范数种类。目前支持的值为 `fro` 、 `nuc` 、 `1` 、 `-1` 、 `2` 、 `-2` 、 `inf` 、 `-inf`。默认值为 `None`，即范数种类为 `2` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
-Tensor，条件数的计算结果，数据类型和输入 ``x`` 的一致。
+Tensor，条件数的计算结果，数据类型和输入  ``x``  的一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/linalg/det_cn.rst b/docs/api/paddle/linalg/det_cn.rst
index 1a7597e1c1a..c57cd9ab3a3 100644
--- a/docs/api/paddle/linalg/det_cn.rst
+++ b/docs/api/paddle/linalg/det_cn.rst
@@ -9,12 +9,12 @@ det
 参数
 ::::::::::::
 
-    - **x** (Tensor)：输入一个或批量矩阵。``x`` 的形状应为 ``[*, M, M]``，其中 ``*`` 为零或更大的批次维度，数据类型支持 float32、float64。
+    - **x** (Tensor)：输入一个或批量矩阵。 ``x``  的形状应为  ``[*, M, M]`` ，其中  ``*``  为零或更大的批次维度，数据类型支持 float32、float64。
 
 返回
 ::::::::::::
 
-Tensor，输出矩阵的行列式值 Shape 为 ``[*]`` 。
+Tensor，输出矩阵的行列式值 Shape 为  ``[*]``  。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/linalg/eig_cn.rst b/docs/api/paddle/linalg/eig_cn.rst
index a7693f0a5fa..0fc54c53afc 100644
--- a/docs/api/paddle/linalg/eig_cn.rst
+++ b/docs/api/paddle/linalg/eig_cn.rst
@@ -5,26 +5,26 @@ eig
 
 .. py:function:: paddle.linalg.eig(x, name=None)
 
-计算一般方阵 ``x`` 的的特征值和特征向量。
+计算一般方阵  ``x``  的的特征值和特征向量。
 
 .. note::
-    - 如果输入矩阵 ``x`` 为 Hermitian 矩阵或实对称阵，请使用更快的 API :ref:`cn_api_paddle_linalg_eigh` 。
+    - 如果输入矩阵  ``x``  为 Hermitian 矩阵或实对称阵，请使用更快的 API :ref:`cn_api_paddle_linalg_eigh` 。
     - 如果只计算特征值，请使用 :ref:`cn_api_paddle_linalg_eigvals` 。
-    - 如果矩阵 ``x`` 不是方阵，请使用 :ref:`cn_api_paddle_linalg_svd` 。
+    - 如果矩阵  ``x``  不是方阵，请使用 :ref:`cn_api_paddle_linalg_svd` 。
     - 该 API 当前只能在 CPU 上执行。
     - 对于输入是实数和复数类型，输出的数据类型均为复数。
 
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 输入一个或一批矩阵。``x`` 的形状应为 ``[*, M, M]``，数据类型支持 float32、float64、complex64 和 complex128。
+    - **x** (Tensor) - 输入一个或一批矩阵。 ``x``  的形状应为  ``[*, M, M]`` ，数据类型支持 float32、float64、complex64 和 complex128。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
 
-    - Tensor Eigenvalues，输出 Shape 为 ``[*, M]`` 的矩阵，表示特征值。
-    - Tensor Eigenvectors，输出 Shape 为 ``[*, M, M]`` 矩阵，表示特征向量。
+    - Tensor Eigenvalues，输出 Shape 为  ``[*, M]``  的矩阵，表示特征值。
+    - Tensor Eigenvectors，输出 Shape 为  ``[*, M, M]``  矩阵，表示特征向量。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/linalg/eigh_cn.rst b/docs/api/paddle/linalg/eigh_cn.rst
index 1b21026bc43..8c4ad024274 100644
--- a/docs/api/paddle/linalg/eigh_cn.rst
+++ b/docs/api/paddle/linalg/eigh_cn.rst
@@ -9,15 +9,15 @@ eigh
 参数
 ::::::::::::
 
-    - **x** (Tensor)：输入一个或一批厄米特矩阵或者实数对称矩阵。``x`` 的形状应为 ``[*, M, M]``，其中 ``*`` 为零或更大的批次维度，数据类型支持 float32、float64、complex64、complex128。
+    - **x** (Tensor)：输入一个或一批厄米特矩阵或者实数对称矩阵。 ``x``  的形状应为  ``[*, M, M]`` ，其中  ``*``  为零或更大的批次维度，数据类型支持 float32、float64、complex64、complex128。
     - **UPLO** (str，可选)：表示计算上三角或者下三角矩阵，默认值为 'L'，表示计算下三角矩阵的特征值和特征向量，'U'表示计算上三角矩阵的特征值和特征向量。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
 
-    - Tensor out_value，输出矩阵的特征值，输出顺序按照从小到大进行排序。Shape 为 ``[*, M]`` 。
-    - Tensor out_vector，输出矩阵的特征向量，与特征值一一对应，Shape 为 ``[*, M, M]`` 。
+    - Tensor out_value，输出矩阵的特征值，输出顺序按照从小到大进行排序。Shape 为  ``[*, M]``  。
+    - Tensor out_vector，输出矩阵的特征向量，与特征值一一对应，Shape 为  ``[*, M, M]``  。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/linalg/eigvals_cn.rst b/docs/api/paddle/linalg/eigvals_cn.rst
index 627db6093e8..35a9b160c53 100644
--- a/docs/api/paddle/linalg/eigvals_cn.rst
+++ b/docs/api/paddle/linalg/eigvals_cn.rst
@@ -14,13 +14,13 @@ eigvals
 参数
 :::::::::
 
-        - **x** （Tensor）- 需要计算特征值的方阵。输入的 Tensor 维度为 ``[*, M, M]``，其中 ``*`` 表示矩阵的批次维度。支持 ``float32`` 、 ``float64`` 、 ``complex64`` 和  ``complex128`` 四种数据类型。
+        - **x** （Tensor）- 需要计算特征值的方阵。输入的 Tensor 维度为  ``[*, M, M]`` ，其中  ``*``  表示矩阵的批次维度。支持  ``float32``  、  ``float64``  、  ``complex64``  和   ``complex128``  四种数据类型。
         - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 :::::::::
-``Tensor``，包含 x 的所有未排序特征值。返回的 Tensor 具有与 x 相同的批次维度。即使输入的 x 是实数 tensor，返回的也会是复数的结果。
+ ``Tensor`` ，包含 x 的所有未排序特征值。返回的 Tensor 具有与 x 相同的批次维度。即使输入的 x 是实数 tensor，返回的也会是复数的结果。
 
 
 代码示例
diff --git a/docs/api/paddle/linalg/eigvalsh_cn.rst b/docs/api/paddle/linalg/eigvalsh_cn.rst
index ecf89fe0d6f..43d0d19879a 100644
--- a/docs/api/paddle/linalg/eigvalsh_cn.rst
+++ b/docs/api/paddle/linalg/eigvalsh_cn.rst
@@ -9,14 +9,14 @@ eigvalsh
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 输入一个或一批厄米特矩阵或者实数对称矩阵。``x`` 的形状应为 ``[*, M, M]``，其中 ``*`` 为零或更大的批次维度，数据类型支持 float32， float64，complex64，complex128。
+    - **x** (Tensor) - 输入一个或一批厄米特矩阵或者实数对称矩阵。 ``x``  的形状应为  ``[*, M, M]`` ，其中  ``*``  为零或更大的批次维度，数据类型支持 float32， float64，complex64，complex128。
     - **UPLO** (str，可选) - 表示计算上三角或者下三角矩阵，默认值为 'L'，表示计算下三角矩阵的特征值，'U'表示计算上三角矩阵的特征值。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
 
-Tensor，输出矩阵的特征值，输出顺序按照从小到大进行排序。Shape 为 ``[*, M]`` 。
+Tensor，输出矩阵的特征值，输出顺序按照从小到大进行排序。Shape 为  ``[*, M]``  。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/linalg/lstsq_cn.rst b/docs/api/paddle/linalg/lstsq_cn.rst
index 5359b869ab2..24e862219e9 100644
--- a/docs/api/paddle/linalg/lstsq_cn.rst
+++ b/docs/api/paddle/linalg/lstsq_cn.rst
@@ -11,21 +11,21 @@ lstsq
 参数
 ::::::::::::
 
-    - **x** (Tensor)：形状为 ``(*, M, N)`` 的矩阵 Tensor， ``*`` 为零或更大的批次维度。数据类型为 float32 或 float64 。
-    - **y** (Tensor)：形状为 ``(*, M, K)`` 的矩阵 Tensor， ``*`` 为零或更大的批次维度。数据类型为 float32 或 float64 。
-    - **rcond** (float，可选)：默认值为 `None`，用来决定 ``x`` 有效秩的 float 型浮点数。当 ``rcond`` 为 `None` 时，该值会被设为 ``max(M, N)`` 乘 ``x`` 数据类型对应的机器精度。
+    - **x** (Tensor)：形状为  ``(*, M, N)``  的矩阵 Tensor，  ``*``  为零或更大的批次维度。数据类型为 float32 或 float64 。
+    - **y** (Tensor)：形状为  ``(*, M, K)``  的矩阵 Tensor，  ``*``  为零或更大的批次维度。数据类型为 float32 或 float64 。
+    - **rcond** (float，可选)：默认值为 `None`，用来决定  ``x``  有效秩的 float 型浮点数。当  ``rcond``  为 `None` 时，该值会被设为  ``max(M, N)``  乘  ``x``  数据类型对应的机器精度。
     - **driver** (str，可选)：默认值为 `None`，用来指定计算使用的 LAPACK 库方法。CPU 下该参数的合法值为 'gels'，'gelsy' (默认)，'gelsd'，'gelss'；CUDA 下该参数的合法值为 'gels' (默认) 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
 
-    Tuple，包含 ``solution``、``residuals``、``rank`` 和 ``singular_values``。
+    Tuple，包含  ``solution`` 、 ``residuals`` 、 ``rank``  和  ``singular_values`` 。
 
-    - ``solution`` 指最小二乘解，形状为 ``(*, N, K)`` 的 Tensor。
-    - ``residuals`` 指最小二乘解对应的残差，形状为 ``(*, K)`` 的 Tensor；当 ``M > N`` 且 ``x`` 中所有矩阵均为满秩矩阵时，该值会被计算，否则返回空 Tensor。
-    - ``rank`` 指 ``x`` 中矩阵的秩，形状为 ``(*)`` 的 Tensor；当 ``driver`` 为 'gelsy', 'gelsd', 'gelss' 时，该值会被计算，否则返回空 Tensor。
-    - ``singular_values`` 指 ``x`` 中矩阵的奇异值，形状为 ``(*, min(M, N))`` 的 Tensor；当 ``driver`` 为 'gelsd', 'gelss' 时，该值会被计算，否则返回空 Tensor。
+    -  ``solution``  指最小二乘解，形状为  ``(*, N, K)``  的 Tensor。
+    -  ``residuals``  指最小二乘解对应的残差，形状为  ``(*, K)``  的 Tensor；当  ``M > N``  且  ``x``  中所有矩阵均为满秩矩阵时，该值会被计算，否则返回空 Tensor。
+    -  ``rank``  指  ``x``  中矩阵的秩，形状为  ``(*)``  的 Tensor；当  ``driver``  为 'gelsy', 'gelsd', 'gelss' 时，该值会被计算，否则返回空 Tensor。
+    -  ``singular_values``  指  ``x``  中矩阵的奇异值，形状为  ``(*, min(M, N))``  的 Tensor；当  ``driver``  为 'gelsd', 'gelss' 时，该值会被计算，否则返回空 Tensor。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/linalg/lu_cn.rst b/docs/api/paddle/linalg/lu_cn.rst
index a268a096712..1cce7de8975 100644
--- a/docs/api/paddle/linalg/lu_cn.rst
+++ b/docs/api/paddle/linalg/lu_cn.rst
@@ -35,9 +35,9 @@ LU 和 pivot 可以通过调用 paddle.linalg.lu_unpack 展开获得 L、U、P 
 返回
 ::::::::::::
 
-    - Tensor ``LU``, LU 分解结果矩阵 LU，由 L、U 拼接组成。
-    - Tensor(dtype=int) ``Pivots``，旋转矩阵对应的旋转序列，详情见说明部分 pivot 部分，对于输入 ``[*, m, n]`` 的 ``x``，Pivots shape 为 ``[*, m]``。
-    - Tensor(dtype=int) ``Infos``，矩阵分解状态信息矩阵，对于输入 ``[*, m, n]``，Infos shape 为 ``[*]``。每个元素表示每组矩阵的 LU 分解是否成功，0 表示分解成功。
+    - Tensor  ``LU`` , LU 分解结果矩阵 LU，由 L、U 拼接组成。
+    - Tensor(dtype=int)  ``Pivots`` ，旋转矩阵对应的旋转序列，详情见说明部分 pivot 部分，对于输入  ``[*, m, n]``  的  ``x`` ，Pivots shape 为  ``[*, m]`` 。
+    - Tensor(dtype=int)  ``Infos`` ，矩阵分解状态信息矩阵，对于输入  ``[*, m, n]`` ，Infos shape 为  ``[*]`` 。每个元素表示每组矩阵的 LU 分解是否成功，0 表示分解成功。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/linalg/lu_solve_cn.rst b/docs/api/paddle/linalg/lu_solve_cn.rst
index 5419c168ecf..90af2488f7d 100644
--- a/docs/api/paddle/linalg/lu_solve_cn.rst
+++ b/docs/api/paddle/linalg/lu_solve_cn.rst
@@ -24,21 +24,21 @@ lu_solve
 
 .. note::
 
-    `lu` 和 `pivots` 由 ``paddle.linalg.lu`` 得到。
+    `lu` 和 `pivots` 由  ``paddle.linalg.lu``  得到。
 
 参数
 ::::::::::::
 
-    - **b** (Tensor) - 输入的欲进行线性方程组求解的右值，类型为 Tensor。 ``b`` 的形状应为 ``[*, M, K]``，其中 ``*`` 为零或更大的批次维度，数据类型为 float32， float64。
-    - **lu** (Tensor) - LU 分解结果矩阵，由 L、U 拼接组成，类型为 Tensor。 ``lu`` 的形状应为 ``[*, M, M]``，其中 ``*`` 为零或更大的批次维度。数据类型和 ``b`` 相同。
-    - **pivots** (Tensor) - LU 分解结果的主元信息，类型为 Tensor。 ``pivots`` 的形状应为 ``[*, M]``，其中 ``*`` 为零或更大的批次维度。数据类型为 int32。
+    - **b** (Tensor) - 输入的欲进行线性方程组求解的右值，类型为 Tensor。  ``b``  的形状应为  ``[*, M, K]`` ，其中  ``*``  为零或更大的批次维度，数据类型为 float32， float64。
+    - **lu** (Tensor) - LU 分解结果矩阵，由 L、U 拼接组成，类型为 Tensor。  ``lu``  的形状应为  ``[*, M, M]`` ，其中  ``*``  为零或更大的批次维度。数据类型和  ``b``  相同。
+    - **pivots** (Tensor) - LU 分解结果的主元信息，类型为 Tensor。  ``pivots``  的形状应为  ``[*, M]`` ，其中  ``*``  为零或更大的批次维度。数据类型为 int32。
     - **trans** (str，可选) - 是否对 A 进行转置，该参数的合法值为 'N'，'T'，'C'，默认值为 N。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
 
-    - Tensor，这个（或这批）矩阵 ``lu`` 、 ``pivots`` 和 ``b`` 经过运算后的结果，数据类型及维度和输入 ``b`` 的一致。
+    - Tensor，这个（或这批）矩阵  ``lu``  、  ``pivots``  和  ``b``  经过运算后的结果，数据类型及维度和输入  ``b``  的一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/linalg/matmul_cn.rst b/docs/api/paddle/linalg/matmul_cn.rst
index 6ecf4dded80..000321eec41 100644
--- a/docs/api/paddle/linalg/matmul_cn.rst
+++ b/docs/api/paddle/linalg/matmul_cn.rst
@@ -5,4 +5,4 @@ matmul
 
 .. py:function:: paddle.linalg.matmul(x, y, transpose_x=False, transpose_y=False, name=None, *, out=None)
 
-``matmul`` 的别名，请参考 :ref:`cn_api_paddle_matmul`。
+ ``matmul``  的别名，请参考 :ref:`cn_api_paddle_matmul`。
diff --git a/docs/api/paddle/linalg/matrix_exp_cn.rst b/docs/api/paddle/linalg/matrix_exp_cn.rst
index c70f3168342..424ac716be1 100644
--- a/docs/api/paddle/linalg/matrix_exp_cn.rst
+++ b/docs/api/paddle/linalg/matrix_exp_cn.rst
@@ -11,7 +11,7 @@ matrix_exp
 
     exp(A) = \sum_{n=0}^\infty A^n/n!
 
-输入的张量 ``x`` 应该是方阵，比如 ``(*, M, M)`` ，矩阵指数通过比例平方法的帕德近似计算而来。
+输入的张量  ``x``  应该是方阵，比如  ``(*, M, M)``  ，矩阵指数通过比例平方法的帕德近似计算而来。
 
 [1] Nicholas J. Higham, The scaling and squaring method for the matrix exponential revisited.
 
@@ -19,12 +19,12 @@ matrix_exp
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 输入张量，形状应该为 ``(*, M, M)`` ， ``*`` 表示 0 或多个维度。数据类型为： ``float32``, ``float64`` 。
+    - **x** (Tensor) - 输入张量，形状应该为  ``(*, M, M)``  ，  ``*``  表示 0 或多个维度。数据类型为：  ``float32`` ,  ``float64``  。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
-Tensor，与 ``x`` 的类型和形状相同。
+Tensor，与  ``x``  的类型和形状相同。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/linalg/matrix_norm_cn.rst b/docs/api/paddle/linalg/matrix_norm_cn.rst
index a5197bdae80..1f5ce813d06 100644
--- a/docs/api/paddle/linalg/matrix_norm_cn.rst
+++ b/docs/api/paddle/linalg/matrix_norm_cn.rst
@@ -16,7 +16,7 @@ matrix_norm
 
     - **x** (Tensor) - 输入 Tensor。维度为多维，数据类型为 float32 或 float64。
     - **p** (int|float|string，可选) - 范数(ord)的种类。目前支持的值为 `fro`、`nuc`、`inf`、`-inf`、`1`、`2`、`-1`、`-2`。默认值为 `fro` 。
-    - **axis** (list|tuple，可选) - 使用范数计算的轴。``axis`` 为 [-2,-1],否则 ``axis`` 必须为长度为 2 的 list|tuple。
+    - **axis** (list|tuple，可选) - 使用范数计算的轴。 ``axis``  为 [-2,-1],否则  ``axis``  必须为长度为 2 的 list|tuple。
     - **keepdim** (bool，可选) - 是否在输出的 Tensor 中保留和输入一样的维度，默认值为 False。当 :attr:`keepdim` 为 False 时，输出的 Tensor 会比输入 :attr:`input` 的维度少一些。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/linalg/matrix_power_cn.rst b/docs/api/paddle/linalg/matrix_power_cn.rst
index cd4c4ab9613..209b5489240 100644
--- a/docs/api/paddle/linalg/matrix_power_cn.rst
+++ b/docs/api/paddle/linalg/matrix_power_cn.rst
@@ -6,7 +6,7 @@ matrix_power
 .. py:function:: paddle.linalg.matrix_power(x, n, name=None)
 
 
-计算一个或一批方阵的 ``n`` 次幂。
+计算一个或一批方阵的  ``n``  次幂。
 
 记 :math:`X` 为一个或一批方阵，:math:`n` 为幂次，则公式为：
 
@@ -15,22 +15,22 @@ matrix_power
 
 特别地，
 
-- 如果 ``n > 0``，则返回计算 ``n`` 次幂后的一个或一批矩阵。
+- 如果  ``n > 0`` ，则返回计算  ``n``  次幂后的一个或一批矩阵。
 
-- 如果 ``n = 0``，则返回一个或一批单位矩阵。
+- 如果  ``n = 0`` ，则返回一个或一批单位矩阵。
 
-- 如果 ``n < 0``，则返回每个矩阵的逆（若矩阵可逆）的 ``abs(n)`` 次幂。
+- 如果  ``n < 0`` ，则返回每个矩阵的逆（若矩阵可逆）的  ``abs(n)``  次幂。
 
 参数
 :::::::::
-    - **x** (Tensor)：输入的欲进行 ``n`` 次幂运算的一个或一批方阵，类型为 Tensor。 ``x`` 的形状应为 ``[*, M, M]``，其中 ``*`` 为零或更大的批次维度，数据类型为 float32， float64。
+    - **x** (Tensor)：输入的欲进行  ``n``  次幂运算的一个或一批方阵，类型为 Tensor。  ``x``  的形状应为  ``[*, M, M]`` ，其中  ``*``  为零或更大的批次维度，数据类型为 float32， float64。
     - **n** (int)：输入的幂次，类型为 int。它可以是任意整数。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
 
-Tensor，这个（或这批）矩阵 ``x`` 经过 ``n`` 次幂运算后的结果，数据类型和输入 ``x`` 的一致。
+Tensor，这个（或这批）矩阵  ``x``  经过  ``n``  次幂运算后的结果，数据类型和输入  ``x``  的一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/linalg/matrix_rank_cn.rst b/docs/api/paddle/linalg/matrix_rank_cn.rst
index 16ac8b7a100..c80fc71b0c5 100644
--- a/docs/api/paddle/linalg/matrix_rank_cn.rst
+++ b/docs/api/paddle/linalg/matrix_rank_cn.rst
@@ -9,23 +9,23 @@ matrix_rank
 计算矩阵的秩。
 
 .. note::
-    1. 阈值参数支持单独使用 ``tol`` 或联合使用 ``atol`` 与 ``rtol``。
-    2. 当单独使用 ``tol`` 时：若 hermitian=False ，矩阵的秩是大于指定的 ``tol`` 阈值的奇异值的数量；若 hermitian=True ，矩阵的秩是大于指定 ``tol`` 阈值的特征值绝对值的数量。
-    3. 当联合使用 ``atol`` 与 ``rtol`` 时，阈值的计算方式是 ``max(atol, sigma_1 * rtol)`` ，其中 ``sigma_1`` 是奇异值中的最大值（或特征值绝对值的最大值）。
-    4. 当联合使用 ``atol`` 与 ``rtol`` 时：若 ``rtol`` 未被声明，同时 ``atol`` 未被声明或取值为 0 ， ``rtol`` 将被设为 ``max(m,n) * eps`` ，其中 ``m`` ， ``n`` 分别是 ``x`` 矩阵的行数和列数， ``eps`` 为 ``x`` 的类型的 epsilon 值；若 ``rtol`` 未被声明，同时 ``atol`` 取值大于 0 ， ``rtol`` 将被设为 0 。
+    1. 阈值参数支持单独使用  ``tol``  或联合使用  ``atol``  与  ``rtol`` 。
+    2. 当单独使用  ``tol``  时：若 hermitian=False ，矩阵的秩是大于指定的  ``tol``  阈值的奇异值的数量；若 hermitian=True ，矩阵的秩是大于指定  ``tol``  阈值的特征值绝对值的数量。
+    3. 当联合使用  ``atol``  与  ``rtol``  时，阈值的计算方式是  ``max(atol, sigma_1 * rtol)``  ，其中  ``sigma_1``  是奇异值中的最大值（或特征值绝对值的最大值）。
+    4. 当联合使用  ``atol``  与  ``rtol``  时：若  ``rtol``  未被声明，同时  ``atol``  未被声明或取值为 0 ，  ``rtol``  将被设为  ``max(m,n) * eps``  ，其中  ``m``  ，  ``n``  分别是  ``x``  矩阵的行数和列数，  ``eps``  为  ``x``  的类型的 epsilon 值；若  ``rtol``  未被声明，同时  ``atol``  取值大于 0 ，  ``rtol``  将被设为 0 。
 
 参数
 :::::::::
-    - **x** (Tensor) - 输入 tensor。它的形状应该是 ``[..., m, n]``，其中 ``...`` 是零或者更大的批次维度。如果 ``x`` 是一批矩阵，则输出具有相同的批次尺寸。``x`` 的数据类型应该为 float32，float64，complex64 或 complex128。
-    - **tol** (float|Tensor，可选) - 阈值。默认值：None。如果未指定 ``tol`` ， ``sigma`` 为所计算奇异值中的最大值（或特征值绝对值的最大值）， ``eps`` 为 ``x`` 的类型的 epsilon 值，使用公式 ``tol=sigma * max(m,n) * eps`` 来计算 ``tol``。请注意，如果 ``x`` 是一批矩阵，以这种方式为每批矩阵计算 ``tol`` 。
-    - **hermitian** (bool，可选) - 表示 ``x`` 是否是 Hermitian 矩阵。默认值：False。当 hermitian=True 时，``x`` 被假定为 Hermitian 矩阵，这时函数内会使用更高效的算法来求解特征值，但在函数内部不会对 ``x`` 进行检查。我们仅仅使用矩阵的下三角来进行计算。
+    - **x** (Tensor) - 输入 tensor。它的形状应该是  ``[..., m, n]`` ，其中  ``...``  是零或者更大的批次维度。如果  ``x``  是一批矩阵，则输出具有相同的批次尺寸。 ``x``  的数据类型应该为 float32，float64，complex64 或 complex128。
+    - **tol** (float|Tensor，可选) - 阈值。默认值：None。如果未指定  ``tol``  ，  ``sigma``  为所计算奇异值中的最大值（或特征值绝对值的最大值），  ``eps``  为  ``x``  的类型的 epsilon 值，使用公式  ``tol=sigma * max(m,n) * eps``  来计算  ``tol`` 。请注意，如果  ``x``  是一批矩阵，以这种方式为每批矩阵计算  ``tol``  。
+    - **hermitian** (bool，可选) - 表示  ``x``  是否是 Hermitian 矩阵。默认值：False。当 hermitian=True 时， ``x``  被假定为 Hermitian 矩阵，这时函数内会使用更高效的算法来求解特征值，但在函数内部不会对  ``x``  进行检查。我们仅仅使用矩阵的下三角来进行计算。
     - **atol** (float|Tensor，可选) - 绝对阈值。未被声明时当作 0 。默认值：None。
     - **rtol** (float|Tensor，可选) - 相对阈值。未被声明时取值参照上述 Note（注解） 。默认值：None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-Tensor， ``x`` 的秩，数据类型为 int64。
+Tensor，  ``x``  的秩，数据类型为 int64。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/linalg/norm_cn.rst b/docs/api/paddle/linalg/norm_cn.rst
index 21e92ca167f..aeb40d5c75f 100644
--- a/docs/api/paddle/linalg/norm_cn.rst
+++ b/docs/api/paddle/linalg/norm_cn.rst
@@ -50,13 +50,13 @@ norm
 :::::::::
 
     - **x** (Tensor) - 输入 Tensor。维度为多维，数据类型为 float32 或 float64。
-      别名： ``input``, ``A``
+      别名：  ``input`` ,  ``A`` 
     - **p** (int|float|string，可选) - 范数(ord)的种类。目前支持的值为 `fro`、`nuc`、`inf`、`-inf`、`0`、`1`、`2`，和任何实数 p 对应的 p 范数。默认值为 None。
-      别名： ``ord``
-    - **axis** (int|list|tuple，可选) - 使用范数计算的轴。如果 ``axis`` 为 None，若 ``p`` 同时为 ``str`` 类型，则会自动补全 ``axis``，否则忽略 input 的维度，将其当做向量来计算。如果 ``axis`` 为 int 或者只有一个元素的 list|tuple，``norm`` API 会计算输入 Tensor 的向量范数。如果 axis 为包含两个元素的 list，API 会计算输入 Tensor 的矩阵范数。当 ``axis < 0`` 时，实际的计算维度为 rank(input) + axis。默认值为 `None` 。
-      别名： ``dim``
+      别名：  ``ord`` 
+    - **axis** (int|list|tuple，可选) - 使用范数计算的轴。如果  ``axis``  为 None，若  ``p``  同时为  ``str``  类型，则会自动补全  ``axis`` ，否则忽略 input 的维度，将其当做向量来计算。如果  ``axis``  为 int 或者只有一个元素的 list|tuple， ``norm``  API 会计算输入 Tensor 的向量范数。如果 axis 为包含两个元素的 list，API 会计算输入 Tensor 的矩阵范数。当  ``axis < 0``  时，实际的计算维度为 rank(input) + axis。默认值为 `None` 。
+      别名：  ``dim`` 
     - **keepdim** (bool，可选) - 是否在输出的 Tensor 中保留和输入一样的维度，默认值为 False。当 :attr:`keepdim` 为 False 时，输出的 Tensor 会比输入 :attr:`input` 的维度少一些。
-    - **out** (Tensor，可选) - 存储输出的 Tensor，当 ``out = None`` 时，该参数无作用。
+    - **out** (Tensor，可选) - 存储输出的 Tensor，当  ``out = None``  时，该参数无作用。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出的数据类型，如果指定，则执行操作时输入张量将转换为 `dtype`。默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/linalg/ormqr_cn.rst b/docs/api/paddle/linalg/ormqr_cn.rst
index 81b2615b01d..77f6aa9a703 100644
--- a/docs/api/paddle/linalg/ormqr_cn.rst
+++ b/docs/api/paddle/linalg/ormqr_cn.rst
@@ -11,15 +11,15 @@ ormqr
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 输入一个或一批矩阵，类型为 Tensor。 ``x`` 的形状应为 ``[*, MN, K]``，其中 ``*`` 为零或更大的批次维度，数据类型支持 float32， float64。
-    - **tau** (Tensor) - 输入一个或一批 Householder 反射系数，类型为 Tensor。 ``tau`` 的形状应为 ``[*, min(MN, K)]``，其中 ``*`` 为零或更大的批次维度，数据类型支持 float32， float64。
-    - **other** (Tensor) - 输入一个或一批矩阵，类型为 Tensor。 ``other`` 的形状应为 ``[*, M, N]``，其中 ``*`` 为零或更大的批次维度，数据类型支持 float32， float64。
-    - **left** (bool， 可选) - 决定了矩阵乘积运算的顺序。如果 left 为 ``True`` ，计算顺序为 op(Q) * other ，否则，计算顺序为 other * op(Q)。默认值： ``True`` 。
-    - **transpose** (bool， 可选) - 如果为 ``True`` ，对矩阵 Q 进行共轭转置变换，否则，不对矩阵 Q 进行共轭转置变换。默认值： ``False`` 。
+    - **x** (Tensor) - 输入一个或一批矩阵，类型为 Tensor。  ``x``  的形状应为  ``[*, MN, K]`` ，其中  ``*``  为零或更大的批次维度，数据类型支持 float32， float64。
+    - **tau** (Tensor) - 输入一个或一批 Householder 反射系数，类型为 Tensor。  ``tau``  的形状应为  ``[*, min(MN, K)]`` ，其中  ``*``  为零或更大的批次维度，数据类型支持 float32， float64。
+    - **other** (Tensor) - 输入一个或一批矩阵，类型为 Tensor。  ``other``  的形状应为  ``[*, M, N]`` ，其中  ``*``  为零或更大的批次维度，数据类型支持 float32， float64。
+    - **left** (bool， 可选) - 决定了矩阵乘积运算的顺序。如果 left 为  ``True``  ，计算顺序为 op(Q) * other ，否则，计算顺序为 other * op(Q)。默认值：  ``True``  。
+    - **transpose** (bool， 可选) - 如果为  ``True``  ，对矩阵 Q 进行共轭转置变换，否则，不对矩阵 Q 进行共轭转置变换。默认值：  ``False``  。
 返回
 ::::::::::::
 
-    ``Tensor``，维度和数据类型都与 :attr:`other` 一致。
+     ``Tensor`` ，维度和数据类型都与 :attr:`other` 一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/linalg/pca_lowrank_cn.rst b/docs/api/paddle/linalg/pca_lowrank_cn.rst
index f045d479237..7f912b8b555 100644
--- a/docs/api/paddle/linalg/pca_lowrank_cn.rst
+++ b/docs/api/paddle/linalg/pca_lowrank_cn.rst
@@ -17,7 +17,7 @@ pca_lowrank
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 输入的需要进行线性主成分分析的一个或一批方阵，类型为 Tensor。 ``x`` 的形状应为 ``[*, M, N]``，其中 ``*`` 为零或更大的批次维度，数据类型支持 float32， float64。
+    - **x** (Tensor) - 输入的需要进行线性主成分分析的一个或一批方阵，类型为 Tensor。  ``x``  的形状应为  ``[*, M, N]`` ，其中  ``*``  为零或更大的批次维度，数据类型支持 float32， float64。
     - **q** (int，可选) - 对输入 :math:`X` 的秩稍微高估的预估值，默认值是 :math:`q=min(6,N,M)`。
     - **center** (bool，可选) - 是否对输入矩阵进行中心化操作，类型为 bool ，默认为 True。
     - **niter** (int) - 需要进行的子空间迭代次数。默认值为 2。
diff --git a/docs/api/paddle/linalg/pinv_cn.rst b/docs/api/paddle/linalg/pinv_cn.rst
index a4d3ea4eda9..714e5f56299 100644
--- a/docs/api/paddle/linalg/pinv_cn.rst
+++ b/docs/api/paddle/linalg/pinv_cn.rst
@@ -5,16 +5,16 @@ pinv
 
 .. py:function:: paddle.linalg.pinv(x, rcond=1e-15, hermitian=False, name=None)
 
-该 API 通过奇异值分解(``svd``)来计算伪逆矩阵，支持单个矩阵或批量矩阵。
+该 API 通过奇异值分解( ``svd`` )来计算伪逆矩阵，支持单个矩阵或批量矩阵。
 
-    - 如果 ``hermitian`` 为假，那么该 API 会利用奇异值分解(``svd``)进行伪逆矩阵的求解。
-    - 如果 ``hermitian`` 为真，那么该 API 会利用特征值分解(``eigh``)进行伪逆矩阵的求解。同时输入需要满足以下条件：如果数据类型为实数，那么输入需要为对称矩阵；如果数据类型为复数，那么输入需要为 ``hermitian`` 矩阵。
+    - 如果  ``hermitian``  为假，那么该 API 会利用奇异值分解( ``svd`` )进行伪逆矩阵的求解。
+    - 如果  ``hermitian``  为真，那么该 API 会利用特征值分解( ``eigh`` )进行伪逆矩阵的求解。同时输入需要满足以下条件：如果数据类型为实数，那么输入需要为对称矩阵；如果数据类型为复数，那么输入需要为  ``hermitian``  矩阵。
 
 参数
 :::::::::
     - **x** (Tensor)：输入变量，类型为 Tensor，数据类型为 float32、float64、complex64、complex12，形状为（M, N）或（B, M, N）。
     - **rcond** (float64，可选)：奇异值（特征值）被截断的阈值，奇异值（特征值）小于 rcond * 最大奇异值时会被置为 0，默认值为 1e-15。
-    - **hermitian** (bool，可选)：是否为 ``hermitian`` 矩阵或者实对称矩阵，默认值为 False。
+    - **hermitian** (bool，可选)：是否为  ``hermitian``  矩阵或者实对称矩阵，默认值为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/linalg/qr_cn.rst b/docs/api/paddle/linalg/qr_cn.rst
index 3aab06aad47..54a4bbc7181 100644
--- a/docs/api/paddle/linalg/qr_cn.rst
+++ b/docs/api/paddle/linalg/qr_cn.rst
@@ -19,14 +19,14 @@ qr
 参数
 ::::::::::::
 
-    - **x** (Tensor)：输入进行正交三角分解的一个或一批方阵，类型为 Tensor。 ``x`` 的形状应为 ``[*, M, N]``，其中 ``*`` 为零或更大的批次维度，数据类型支持 float32， float64。
-    - **mode** (str，可选)：控制正交三角分解的行为，默认是 ``reduced``，假设 ``x`` 形状应为 ``[*, M, N]`` 和 ``K = min(M, N)``：如果 ``mode = "reduced"``，则 :math:`Q` 形状为 ``[*, M, K]`` 和 :math:`R` 形状为 ``[*, K, N]``；如果 ``mode = "complete"``，则 :math:`Q` 形状为 ``[*, M, M]`` 和 :math:`R` 形状为 ``[*, M, N]``；如果 ``mode = "r"``，则不返回 :math:`Q`，只返回 :math:`R` 且形状为 ``[*, K, N]`` 。
+    - **x** (Tensor)：输入进行正交三角分解的一个或一批方阵，类型为 Tensor。  ``x``  的形状应为  ``[*, M, N]`` ，其中  ``*``  为零或更大的批次维度，数据类型支持 float32， float64。
+    - **mode** (str，可选)：控制正交三角分解的行为，默认是  ``reduced`` ，假设  ``x``  形状应为  ``[*, M, N]``  和  ``K = min(M, N)`` ：如果  ``mode = "reduced"`` ，则 :math:`Q` 形状为  ``[*, M, K]``  和 :math:`R` 形状为  ``[*, K, N]`` ；如果  ``mode = "complete"`` ，则 :math:`Q` 形状为  ``[*, M, M]``  和 :math:`R` 形状为  ``[*, M, N]`` ；如果  ``mode = "r"`` ，则不返回 :math:`Q`，只返回 :math:`R` 且形状为  ``[*, K, N]``  。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
 
-    - Tensor Q，正交三角分解的 Q 正交矩阵，需注意如果 ``mode = "reduced"``，则不返回 Q 矩阵，只返回 R 矩阵。
+    - Tensor Q，正交三角分解的 Q 正交矩阵，需注意如果  ``mode = "reduced"`` ，则不返回 Q 矩阵，只返回 R 矩阵。
     - Tensor R，正交三角分解的 R 上三角矩阵。
 
 代码示例
diff --git a/docs/api/paddle/linalg/slogdet_cn.rst b/docs/api/paddle/linalg/slogdet_cn.rst
index b6bb65344a2..44c62b59ef2 100644
--- a/docs/api/paddle/linalg/slogdet_cn.rst
+++ b/docs/api/paddle/linalg/slogdet_cn.rst
@@ -13,12 +13,12 @@ slogdet
 参数
 ::::::::::::
 
-    - **x** (Tensor)：输入一个或批量矩阵。``x`` 的形状应为 ``[*, M, M]``，其中 ``*`` 为零或更大的批次维度，数据类型支持 float32、float64、complex64、complex128。
+    - **x** (Tensor)：输入一个或批量矩阵。 ``x``  的形状应为  ``[*, M, M]`` ，其中  ``*``  为零或更大的批次维度，数据类型支持 float32、float64、complex64、complex128。
 
 返回
 ::::::::::::
 
-Tensor，输出矩阵的行列式值 Shape 为 ``[2, *]``。
+Tensor，输出矩阵的行列式值 Shape 为  ``[2, *]`` 。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/linalg/solve_cn.rst b/docs/api/paddle/linalg/solve_cn.rst
index aa43b44043f..316fe86eb31 100644
--- a/docs/api/paddle/linalg/solve_cn.rst
+++ b/docs/api/paddle/linalg/solve_cn.rst
@@ -20,20 +20,20 @@ solve
 
 特别地，
 
-- 如果 ``X`` 不可逆，则线性方程组不可解。
+- 如果  ``X``  不可逆，则线性方程组不可解。
 
 
 参数
 :::::::::
-    - **x** (Tensor) - 输入的欲进行线性方程组求解的一个或一批方阵（系数矩阵），类型为 Tensor。 ``x`` 的形状应为 ``[*, M, M]``，其中 ``*`` 为零或更大的批次维度，数据类型为 float32， float64。
-    - **y** (Tensor) - 输入的欲进行线性方程组求解的右值，类型为 Tensor。 ``y`` 的形状应为 ``[*, M, K]``，其中 ``*`` 为零或更大的批次维度，数据类型和 ``x`` 相同。
+    - **x** (Tensor) - 输入的欲进行线性方程组求解的一个或一批方阵（系数矩阵），类型为 Tensor。  ``x``  的形状应为  ``[*, M, M]`` ，其中  ``*``  为零或更大的批次维度，数据类型为 float32， float64。
+    - **y** (Tensor) - 输入的欲进行线性方程组求解的右值，类型为 Tensor。  ``y``  的形状应为  ``[*, M, K]`` ，其中  ``*``  为零或更大的批次维度，数据类型和  ``x``  相同。
     - **left** (bool，可选) - 设置所求解的线性方程组是 :math:`X * Out = Y` 或 :math:`Out * X = Y`。默认值为 True，表示所求解的线性方程组是 :math:`X * Out = Y`。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
 
-Tensor，这个（或这批）矩阵 ``x`` 与 ``y`` 经过运算后的结果，数据类型和输入 ``x`` 的一致。
+Tensor，这个（或这批）矩阵  ``x``  与  ``y``  经过运算后的结果，数据类型和输入  ``x``  的一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/linalg/svd_cn.rst b/docs/api/paddle/linalg/svd_cn.rst
index c4e790ecfff..31080b49729 100644
--- a/docs/api/paddle/linalg/svd_cn.rst
+++ b/docs/api/paddle/linalg/svd_cn.rst
@@ -19,16 +19,16 @@ svd
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 输入的欲进行奇异值分解的一个或一批方阵，类型为 Tensor。 ``x`` 的形状应为 ``[*, M, N]``，其中 ``*`` 为零或更大的批次维度，数据类型支持 float32， float64， complex64， complex128。
+    - **x** (Tensor) - 输入的欲进行奇异值分解的一个或一批方阵，类型为 Tensor。  ``x``  的形状应为  ``[*, M, N]`` ，其中  ``*``  为零或更大的批次维度，数据类型支持 float32， float64， complex64， complex128。
     - **full_matrices** (bool) - 是否计算完整的 U 和 V 矩阵，类型为 bool 默认为 False。这个参数会影响 U 和 V 生成的 Shape。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
 
-    - Tensor U，奇异值分解的 U 矩阵。如果 full_matrics 设置为 False，则 Shape 为 ``[*, M, K]``，如果 full_metrices 设置为 True，那么 Shape 为 ``[*, M, M]``。其中 K 为 M 和 N 的最小值。
-    - Tensor S，奇异值向量，Shape 为 ``[*, K]`` 。
-    - Tensor VH，奇异值分解的 VH 矩阵。如果 full_matrics 设置为 False，则 Shape 为 ``[*, K, N]``，如果 full_metrices 设置为 True，那么 Shape 为 ``[*, N, N]``。其中 K 为 M 和 N 的最小值。
+    - Tensor U，奇异值分解的 U 矩阵。如果 full_matrics 设置为 False，则 Shape 为  ``[*, M, K]`` ，如果 full_metrices 设置为 True，那么 Shape 为  ``[*, M, M]`` 。其中 K 为 M 和 N 的最小值。
+    - Tensor S，奇异值向量，Shape 为  ``[*, K]``  。
+    - Tensor VH，奇异值分解的 VH 矩阵。如果 full_matrics 设置为 False，则 Shape 为  ``[*, K, N]`` ，如果 full_metrices 设置为 True，那么 Shape 为  ``[*, N, N]`` 。其中 K 为 M 和 N 的最小值。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/linalg/svd_lowrank_cn.rst b/docs/api/paddle/linalg/svd_lowrank_cn.rst
index 8e7d65fd8a4..80d29598585 100644
--- a/docs/api/paddle/linalg/svd_lowrank_cn.rst
+++ b/docs/api/paddle/linalg/svd_lowrank_cn.rst
@@ -21,10 +21,10 @@ svd_lowrank
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 输入的需要进行奇异值分解的一个或一批方阵，类型为 Tensor。 ``x`` 的形状应为 ``[*, M, N]``，其中 ``*`` 为零或更大的批次维度，数据类型支持 float32， float64。
+    - **x** (Tensor) - 输入的需要进行奇异值分解的一个或一批方阵，类型为 Tensor。  ``x``  的形状应为  ``[*, M, N]`` ，其中  ``*``  为零或更大的批次维度，数据类型支持 float32， float64。
     - **q** (int，可选) - 对输入 :math:`X` 的秩稍微高估的预估值，默认值为 None，代表预估值取 6。
     - **niter** (int) - 需要进行的子空间迭代次数。默认值为 2。
-    - **M** (Tensor) - 输入矩阵在 `axis=-2` 维上的均值，形状应为 ``[*, 1, N]``，默认为 None。
+    - **M** (Tensor) - 输入矩阵在 `axis=-2` 维上的均值，形状应为  ``[*, 1, N]`` ，默认为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/linalg/svdvals_cn.rst b/docs/api/paddle/linalg/svdvals_cn.rst
index c5a96babe9f..74dde5530bb 100644
--- a/docs/api/paddle/linalg/svdvals_cn.rst
+++ b/docs/api/paddle/linalg/svdvals_cn.rst
@@ -18,13 +18,13 @@ svdvals
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 输入的欲进行奇异值分解的一个或一批矩阵，类型为 Tensor。 ``x`` 的形状应为 ``[*, M, N]``，其中 ``*`` 为零或更大的批次维度，数据类型支持 float32， float64。
+    - **x** (Tensor) - 输入的欲进行奇异值分解的一个或一批矩阵，类型为 Tensor。  ``x``  的形状应为  ``[*, M, N]`` ，其中  ``*``  为零或更大的批次维度，数据类型支持 float32， float64。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
 
-    - Tensor S，奇异值向量，Shape 为 ``[*, K]`` ，其中 K 为 M 和 N 的最小值。
+    - Tensor S，奇异值向量，Shape 为  ``[*, K]``  ，其中 K 为 M 和 N 的最小值。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/linalg/triangular_solve_cn.rst b/docs/api/paddle/linalg/triangular_solve_cn.rst
index 389cd4e6c94..879283d15aa 100644
--- a/docs/api/paddle/linalg/triangular_solve_cn.rst
+++ b/docs/api/paddle/linalg/triangular_solve_cn.rst
@@ -22,21 +22,21 @@ triangular_solve
 
 特别地，
 
-- 如果 ``x`` 不可逆，则线性方程组不可解。
+- 如果  ``x``  不可逆，则线性方程组不可解。
 
 参数
 :::::::::
-    - **x** (Tensor) - 线性方程组左边的系数方阵，其为一个或一批方阵。``x`` 的形状应为 ``[*, M, M]``，其中 ``*`` 为零或更大的批次维度，数据类型为 float32， float64，complex64，complex128。
-    - **y** (Tensor) - 线性方程组右边的矩阵，其为一个或一批矩阵。``y`` 的形状应为 ``[*, M, K]``，其中 ``*`` 为零或更大的批次维度，数据类型为 float32， float64，complex64，complex128。
-    - **upper** (bool，可选) - 对系数矩阵 ``x`` 取上三角还是下三角。默认为 True，表示取上三角。
-    - **transpose** (bool，可选) - 是否对系数矩阵 ``x`` 进行转置。默认为 False，不进行转置。
-    - **unitriangular** (bool，可选) - 如果为 True，则将系数矩阵 ``x`` 对角线元素假设为 1 来求解方程。默认为 False。
+    - **x** (Tensor) - 线性方程组左边的系数方阵，其为一个或一批方阵。 ``x``  的形状应为  ``[*, M, M]`` ，其中  ``*``  为零或更大的批次维度，数据类型为 float32， float64，complex64，complex128。
+    - **y** (Tensor) - 线性方程组右边的矩阵，其为一个或一批矩阵。 ``y``  的形状应为  ``[*, M, K]`` ，其中  ``*``  为零或更大的批次维度，数据类型为 float32， float64，complex64，complex128。
+    - **upper** (bool，可选) - 对系数矩阵  ``x``  取上三角还是下三角。默认为 True，表示取上三角。
+    - **transpose** (bool，可选) - 是否对系数矩阵  ``x``  进行转置。默认为 False，不进行转置。
+    - **unitriangular** (bool，可选) - 如果为 True，则将系数矩阵  ``x``  对角线元素假设为 1 来求解方程。默认为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
 
-Tensor，线程方程组的解，数据类型和 ``x`` 一致。
+Tensor，线程方程组的解，数据类型和  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/linalg/vecdot_cn.rst b/docs/api/paddle/linalg/vecdot_cn.rst
index 88d5c652e76..580dd97da4b 100644
--- a/docs/api/paddle/linalg/vecdot_cn.rst
+++ b/docs/api/paddle/linalg/vecdot_cn.rst
@@ -12,15 +12,15 @@ vecdot
 参数
 :::::::::
 
-        - **x** (Tensor) - 第一个输入张量。支持 ``float32`` 、 ``float64`` 、 ``int32`` 、 ``int64`` 、 ``complex64`` 和  ``complex128`` 六种数据类型。
-        - **y** (Tensor) - 第二个输入张量。其形状必须能沿指定 ``axis`` 与 ``x`` 进行广播运算，且必须与 ``x`` 具有相同的数据类型。
+        - **x** (Tensor) - 第一个输入张量。支持  ``float32``  、  ``float64``  、  ``int32``  、  ``int64``  、  ``complex64``  和   ``complex128``  六种数据类型。
+        - **y** (Tensor) - 第二个输入张量。其形状必须能沿指定  ``axis``  与  ``x``  进行广播运算，且必须与  ``x``  具有相同的数据类型。
         - **axis** (int，可选) - 计算点积所沿的轴。默认为-1，表示最后一个轴。
         - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 :::::::::
-``Tensor``， 包含沿指定轴计算的 ``x`` 和 ``y`` 点积结果的张量。
+ ``Tensor`` ， 包含沿指定轴计算的  ``x``  和  ``y``  点积结果的张量。
 
 
 代码示例
diff --git a/docs/api/paddle/linalg/vector_norm_cn.rst b/docs/api/paddle/linalg/vector_norm_cn.rst
index ca2308f693c..c0cf8d6e976 100644
--- a/docs/api/paddle/linalg/vector_norm_cn.rst
+++ b/docs/api/paddle/linalg/vector_norm_cn.rst
@@ -16,7 +16,7 @@ vector_norm
 
     - **x** (Tensor) - 输入 Tensor。维度为多维，数据类型为 float32 或 float64。
     - **p** (int|float，可选) - 范数(ord)的种类。目前支持的值为任何实数 p 对应的 p 范数。默认值为 2.0 。
-    - **axis** (int|list|tuple，可选) - 使用范数计算的轴。如果 ``axis`` 为 None，则忽略 input 的维度，将其当做向量来计算。如果 ``axis`` 为 int 或者 list|tuple，计算 Tensor 对应 axis 上的向量范数。默认值为 `None` 。
+    - **axis** (int|list|tuple，可选) - 使用范数计算的轴。如果  ``axis``  为 None，则忽略 input 的维度，将其当做向量来计算。如果  ``axis``  为 int 或者 list|tuple，计算 Tensor 对应 axis 上的向量范数。默认值为 `None` 。
     - **keepdim** (bool，可选) - 是否在输出的 Tensor 中保留和输入一样的维度，默认值为 False。当 :attr:`keepdim` 为 False 时，输出的 Tensor 会比输入 :attr:`input` 的维度少一些。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/linspace_cn.rst b/docs/api/paddle/linspace_cn.rst
index ee8febc1376..784fd82d32a 100644
--- a/docs/api/paddle/linspace_cn.rst
+++ b/docs/api/paddle/linspace_cn.rst
@@ -11,9 +11,9 @@ linspace
 参数
 ::::::::::::
 
-    - **start** (int|float|Tensor) – ``start`` 是区间开始的变量，可以是一个 int、float，或是一个 shape 为[0]的 Tensor，该 Tensor 的数据类型可以是 int32，int64，float32，float64。
-    - **stop** (int|float|Tensor) – ``stop`` 是区间结束的变量，可以是一个 int、float，或是一个 shape 为[0]的 Tensor，该 Tensor 的数据类型可以是 int32，int64，float32，float64。
-    - **num** (int|Tensor) – ``num`` 是给定区间内需要划分的区间数，可以是一个 int，或是一个 shape 为[0]的 Tensor，该 Tensor 的数据类型需为 int32。
+    - **start** (int|float|Tensor) –  ``start``  是区间开始的变量，可以是一个 int、float，或是一个 shape 为[0]的 Tensor，该 Tensor 的数据类型可以是 int32，int64，float32，float64。
+    - **stop** (int|float|Tensor) –  ``stop``  是区间结束的变量，可以是一个 int、float，或是一个 shape 为[0]的 Tensor，该 Tensor 的数据类型可以是 int32，int64，float32，float64。
+    - **num** (int|Tensor) –  ``num``  是给定区间内需要划分的区间数，可以是一个 int，或是一个 shape 为[0]的 Tensor，该 Tensor 的数据类型需为 int32。
     - **dtype** (str|paddle.dtype|np.dtype，可选) – 输出 Tensor 的数据类型，可以是 int32，int64，float32，float64。如果 dtype 的数据类型为 None，输出 Tensor 数据类型为 float32。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/load_cn.rst b/docs/api/paddle/load_cn.rst
index 688a4fde98a..3a867ba5098 100644
--- a/docs/api/paddle/load_cn.rst
+++ b/docs/api/paddle/load_cn.rst
@@ -8,7 +8,7 @@ load
 从指定路径载入可以在 paddle 中使用的对象实例。
 
 .. note::
-    目前支持载入：Layer 或者 Optimizer 的 ``state_dict``，Tensor 以及包含 Tensor 的嵌套 list、tuple、dict、Program。对于 Tensor 对象，只保存了它的名字和数值，没有保存 stop_gradient 等属性，如果您需要这些没有保存的属性，请调用 set_value 接口将数值设置到带有这些属性的 Tensor 中。
+    目前支持载入：Layer 或者 Optimizer 的  ``state_dict`` ，Tensor 以及包含 Tensor 的嵌套 list、tuple、dict、Program。对于 Tensor 对象，只保存了它的名字和数值，没有保存 stop_gradient 等属性，如果您需要这些没有保存的属性，请调用 set_value 接口将数值设置到带有这些属性的 Tensor 中。
 
 
 遇到使用问题，请参考：
@@ -21,11 +21,11 @@ load
 参数
 :::::::::
     - **path** (str|BytesIO) - 载入目标对象实例的路径/内存对象。通常该路径是目标文件的路径，当从用于存储预测模型 API 的存储结果中载入 state_dict 时，该路径可能是一个文件前缀或者目录。
-    - **\*\*configs** (dict，可选) - 其他用于兼容的载入配置选项。这些选项将来可能被移除，如果不是必须使用，不推荐使用这些配置选项。默认为 ``None``。目前支持以下配置选项：
+    - **\*\*configs** (dict，可选) - 其他用于兼容的载入配置选项。这些选项将来可能被移除，如果不是必须使用，不推荐使用这些配置选项。默认为  ``None`` 。目前支持以下配置选项：
 
-        - (1) model_filename (str) - paddle 1.x 版本 ``save_inference_model`` 接口存储格式的预测模型文件名，原默认文件名为 ``__model__`` ；
-        - (2) params_filename (str) - paddle 1.x 版本 ``save_inference_model`` 接口存储格式的参数文件名，没有默认文件名，默认将各个参数分散存储为单独的文件；
-        - (3) return_numpy(bool) - 如果被指定为 ``True`` ，``load`` 的结果中的 Tensor 会被转化为 ``numpy.ndarray``，默认为 ``False`` 。
+        - (1) model_filename (str) - paddle 1.x 版本  ``save_inference_model``  接口存储格式的预测模型文件名，原默认文件名为  ``__model__``  ；
+        - (2) params_filename (str) - paddle 1.x 版本  ``save_inference_model``  接口存储格式的参数文件名，没有默认文件名，默认将各个参数分散存储为单独的文件；
+        - (3) return_numpy(bool) - 如果被指定为  ``True``  ， ``load``  的结果中的 Tensor 会被转化为  ``numpy.ndarray`` ，默认为  ``False``  。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/log1p_cn.rst b/docs/api/paddle/log1p_cn.rst
index 0fe64ab7e92..b4e73b75910 100644
--- a/docs/api/paddle/log1p_cn.rst
+++ b/docs/api/paddle/log1p_cn.rst
@@ -20,7 +20,7 @@ log1p
 
 返回
 ::::::::::::
-计算 ``x`` 的自然对数 + 1 后的 Tensor，数据类型，形状与 ``x`` 一致。
+计算  ``x``  的自然对数 + 1 后的 Tensor，数据类型，形状与  ``x``  一致。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/log2_cn.rst b/docs/api/paddle/log2_cn.rst
index fd13a948956..33732747129 100755
--- a/docs/api/paddle/log2_cn.rst
+++ b/docs/api/paddle/log2_cn.rst
@@ -16,12 +16,12 @@ Log2 激活函数（计算底为 2 的对数）
 
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``;
+    别名支持: 参数名  ``input``  可替代  ``x`` ;
 
 参数
 :::::::::
   - **x** (Tensor) – 该 OP 的输入为 Tensor。数据类型为 int32，int64，float16，bfloat16，float32， float64， complex64 或 complex128。
-    ``别名：input``
+     ``别名：input`` 
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
   - **out** (Tensor，可选) - 输出的结果。该参数为仅关键字参数，默认值为 None。
 返回
diff --git a/docs/api/paddle/log_cn.rst b/docs/api/paddle/log_cn.rst
index 0264701261b..85173b33fb2 100644
--- a/docs/api/paddle/log_cn.rst
+++ b/docs/api/paddle/log_cn.rst
@@ -17,13 +17,13 @@ Log 激活函数（计算自然对数）
 参数
 ::::::::::::
 
-  - **x** (Tensor) – 输入为 Tensor。数据类型只能为 int32，int64，float16，bfloat16，float32， float64， complex64 或 complex128。别名 ``input``。
+  - **x** (Tensor) – 输入为 Tensor。数据类型只能为 int32，int64，float16，bfloat16，float32， float64， complex64 或 complex128。别名  ``input`` 。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/log_normal_cn.rst b/docs/api/paddle/log_normal_cn.rst
index 4bea2115753..1bbf9075140 100644
--- a/docs/api/paddle/log_normal_cn.rst
+++ b/docs/api/paddle/log_normal_cn.rst
@@ -6,7 +6,7 @@ log\_normal
 .. py:function:: paddle.log_normal(mean=1.0, std=2.0, shape=None, name=None)
 
 
-返回符合对数正态分布（对应正态分布的均值为 ``mean``，标准差为 ``std``）的随机 Tensor，对数正态分布的分布函数如下
+返回符合对数正态分布（对应正态分布的均值为  ``mean`` ，标准差为  ``std`` ）的随机 Tensor，对数正态分布的分布函数如下
 
 .. math::
 
@@ -17,22 +17,22 @@ log\_normal
 - :math:`mu` 表示对应正态分布的平均值。
 - :math:`sigma` 表示对应正态分布的标准差。
 
-如果 ``mean`` 是 Tensor，则输出 Tensor 和 ``mean`` 具有相同的形状和数据类型。
-如果 ``mean`` 不是 Tensor，且 ``std`` 是 Tensor，则输出 Tensor 和 ``std`` 具有相同的形状和数据类型。
-如果 ``mean`` 和 ``std`` 都不是 Tensor，则输出 Tensor 的形状为 ``shape``，数据类型为 float32。
-如果 ``mean`` 和 ``std`` 都是 Tensor，则 ``mean`` 和 ``std`` 的元素个数应该相同。
+如果  ``mean``  是 Tensor，则输出 Tensor 和  ``mean``  具有相同的形状和数据类型。
+如果  ``mean``  不是 Tensor，且  ``std``  是 Tensor，则输出 Tensor 和  ``std``  具有相同的形状和数据类型。
+如果  ``mean``  和  ``std``  都不是 Tensor，则输出 Tensor 的形状为  ``shape`` ，数据类型为 float32。
+如果  ``mean``  和  ``std``  都是 Tensor，则  ``mean``  和  ``std``  的元素个数应该相同。
 
 参数
 ::::::::::
 
-  - **mean** (float|Tensor，可选) - 输出 Tensor 对应正态分布的平均值。如果 ``mean`` 是 float，则表示输出 Tensor 中所有元素的正态分布的平均值。如果 ``mean`` 是 Tensor (支持的数据类型为 float32、float64)，则表示输出 Tensor 中每个元素对应正态分布的平均值。默认值为 1.0。
-  - **std** (float|Tensor，可选) - 输出 Tensor 对应正态分布的标准差。如果 ``std`` 是 float，则表示输出 Tensor 中所有元素的正态分布的标准差。如果 ``std`` 是 Tensor (支持的数据类型为 float32、float64)，则表示输出 Tensor 中每个元素对应正态分布的标准差。默认值为 2.0。
-  - **shape** (list|tuple|Tensor，可选) - 生成的随机 Tensor 的形状。如果 ``shape`` 是 list、tuple，则其中的元素可以是 int，或者是形状为[]且数据类型为 int32、int64 的 0-D Tensor。如果 ``shape`` 是 Tensor，则是数据类型为 int32、int64 的 1D Tensor。如果 ``mean`` 或者 ``std`` 是 Tensor，输出 Tensor 的形状和 ``mean`` 或者 ``std`` 相同(此时 ``shape`` 无效)。默认值为 None。
+  - **mean** (float|Tensor，可选) - 输出 Tensor 对应正态分布的平均值。如果  ``mean``  是 float，则表示输出 Tensor 中所有元素的正态分布的平均值。如果  ``mean``  是 Tensor (支持的数据类型为 float32、float64)，则表示输出 Tensor 中每个元素对应正态分布的平均值。默认值为 1.0。
+  - **std** (float|Tensor，可选) - 输出 Tensor 对应正态分布的标准差。如果  ``std``  是 float，则表示输出 Tensor 中所有元素的正态分布的标准差。如果  ``std``  是 Tensor (支持的数据类型为 float32、float64)，则表示输出 Tensor 中每个元素对应正态分布的标准差。默认值为 2.0。
+  - **shape** (list|tuple|Tensor，可选) - 生成的随机 Tensor 的形状。如果  ``shape``  是 list、tuple，则其中的元素可以是 int，或者是形状为[]且数据类型为 int32、int64 的 0-D Tensor。如果  ``shape``  是 Tensor，则是数据类型为 int32、int64 的 1D Tensor。如果  ``mean``  或者  ``std``  是 Tensor，输出 Tensor 的形状和  ``mean``  或者  ``std``  相同(此时  ``shape``  无效)。默认值为 None。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-  Tensor，符合对数正态分布（对应正态分布的均值为 ``mean``，标准差为 ``std``）的随机 Tensor。
+  Tensor，符合对数正态分布（对应正态分布的均值为  ``mean`` ，标准差为  ``std`` ）的随机 Tensor。
 
 示例代码
 ::::::::::
diff --git a/docs/api/paddle/logaddexp_cn.rst b/docs/api/paddle/logaddexp_cn.rst
index f40785948bc..aadec22bffd 100755
--- a/docs/api/paddle/logaddexp_cn.rst
+++ b/docs/api/paddle/logaddexp_cn.rst
@@ -5,7 +5,7 @@ logaddexp
 
 .. py:function:: paddle.logaddexp(x, y, name=None)
 
-计算 ``x`` 和 ``y`` 的以 e 为底的指数的和的自然对数。计算公式如下：
+计算  ``x``  和  ``y``  的以 e 为底的指数的和的自然对数。计算公式如下：
 
 .. math::
    logaddexp(x) = \log (exp(x)+exp(y))
@@ -18,7 +18,7 @@ logaddexp
 
 返回
 ::::::::::
-    ``Tensor``，根据上述公式计算的 logaddexp(x) 结果
+     ``Tensor`` ，根据上述公式计算的 logaddexp(x) 结果
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/logical_and_cn.rst b/docs/api/paddle/logical_and_cn.rst
index ef59be9ef7b..8f524a7312d 100644
--- a/docs/api/paddle/logical_and_cn.rst
+++ b/docs/api/paddle/logical_and_cn.rst
@@ -5,32 +5,32 @@ logical_and
 
 .. py:function:: paddle.logical_and(x, y, out=None, name=None)
 
-逐元素的对 ``x`` 和 ``y`` 进行逻辑与运算。
+逐元素的对  ``x``  和  ``y``  进行逻辑与运算。
 
 .. math::
        Out = X \&\& Y
 
 .. note::
-    ``paddle.logical_and`` 遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
+     ``paddle.logical_and``  遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
 
     .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``， ``other`` 可替代 ``y``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，  ``other``  可替代  ``y`` 。
 
 参数
 ::::::::::::
 
         - **x** （Tensor） - 输入的 `Tensor`，支持的数据类型为 bool, int8, int16, int32, int64, bfloat16, float16, float32, float64, complex64, complex128。
-          别名： ``input``
+          别名：  ``input`` 
         - **y** （Tensor） - 输入的 `Tensor`，支持的数据类型为 bool, int8, int16, int32, int64, bfloat16, float16, float32, float64, complex64, complex128。
-          别名： ``other``
+          别名：  ``other`` 
         - **out** （Tensor，可选） - 指定算子输出结果的 `Tensor`，可以是程序中已经创建的任何 Tensor。默认值为 None，此时将创建新的 Tensor 来保存输出结果。
         - **name** （str，可选） - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
- ``Tensor``，维度``x`` 维度相同，存储运算后的结果。
+  ``Tensor`` ，维度 ``x``  维度相同，存储运算后的结果。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/logical_not_cn.rst b/docs/api/paddle/logical_not_cn.rst
index 1e9341763b1..94639842cc9 100644
--- a/docs/api/paddle/logical_not_cn.rst
+++ b/docs/api/paddle/logical_not_cn.rst
@@ -8,25 +8,25 @@ logical_not
 
 
 
-逐元素的对 ``X``  Tensor 进行逻辑非运算
+逐元素的对  ``X``   Tensor 进行逻辑非运算
 
 .. math::
         Out = !X
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``。
+    别名支持: 参数名  ``input``  可替代  ``x`` 。
 
 参数
 ::::::::::::
 
         - **x** （Tensor） - 逻辑非运算的输入，是一个 Tensor，支持的数据类型为 bool, int8, int16, int32, int64, bfloat16, float16, float32, float64, complex64, complex128。
-          别名： ``input``
+          别名：  ``input`` 
         - **out** （Tensor，可选） - 指定算子输出结果的 Tensor，可以是程序中已经创建的任何 Tensor。默认值为 None，此时将创建新的 Tensor 来保存输出结果。
         - **name** （str，可选） - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
-Tensor，与 ``x`` 维度相同，数据类型相同。
+Tensor，与  ``x``  维度相同，数据类型相同。
 
 
 代码示例
diff --git a/docs/api/paddle/logical_or_cn.rst b/docs/api/paddle/logical_or_cn.rst
index fb3094479f5..90f5e279461 100644
--- a/docs/api/paddle/logical_or_cn.rst
+++ b/docs/api/paddle/logical_or_cn.rst
@@ -5,32 +5,32 @@ logical_or
 
 .. py:function:: paddle.logical_or(x, y, out=None, name=None)
 
-逐元素的对 ``X`` 和 ``Y`` 进行逻辑或运算。
+逐元素的对  ``X``  和  ``Y``  进行逻辑或运算。
 
 .. math::
         Out = X || Y
 
 .. note::
-    ``paddle.logical_or`` 遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
+     ``paddle.logical_or``  遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
 
     .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``， ``other`` 可替代 ``y``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，  ``other``  可替代  ``y`` 。
 
 参数
 ::::::::::::
 
         - **x** （Tensor） - 输入的 `Tensor`，支持的数据类型为 bool, int8, int16, int32, int64, bfloat16, float16, float32, float64, complex64, complex128。
-          别名： ``input``
+          别名：  ``input`` 
         - **y** （Tensor）- 输入的 `Tensor`，支持的数据类型为 bool, int8, int16, int32, int64, bfloat16, float16, float32, float64, complex64, complex128。
-          别名： ``other``
+          别名：  ``other`` 
         - **out** （Tensor，可选） - 指定算子输出结果的 `Tensor`，可以是程序中已经创建的任何 Tensor。默认值为 None，此时将创建新的 Tensor 来保存输出结果。
         - **name** （str，可选） - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
- ``Tensor``，维度``x`` 维度相同，存储运算后的结果。
+  ``Tensor`` ，维度 ``x``  维度相同，存储运算后的结果。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/logical_xor_cn.rst b/docs/api/paddle/logical_xor_cn.rst
index 4edadfd537d..58c9a75abbe 100644
--- a/docs/api/paddle/logical_xor_cn.rst
+++ b/docs/api/paddle/logical_xor_cn.rst
@@ -5,32 +5,32 @@ logical_xor
 
 .. py:function:: paddle.logical_xor(x, y, out=None, name=None)
 
-逐元素的对 ``X`` 和 ``Y`` 进行逻辑异或运算。
+逐元素的对  ``X``  和  ``Y``  进行逻辑异或运算。
 
 .. math::
         Out = (X || Y) \&\& !(X \&\& Y)
 
 .. note::
-    ``paddle.logical_xor`` 遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
+     ``paddle.logical_xor``  遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
 
     .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``， ``other`` 可替代 ``y``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，  ``other``  可替代  ``y`` 。
 
 参数
 ::::::::::::
 
         - **x** （Tensor） - 输入的 `Tensor`，支持的数据类型为 bool, int8, int16, int32, int64, bfloat16, float16, float32, float64, complex64, complex128。
-          别名： ``input``
+          别名：  ``input`` 
         - **y** （Tensor） - 输入的 `Tensor`，支持的数据类型为 bool, int8, int16, int32, int64, bfloat16, float16, float32, float64, complex64, complex128。
-          别名： ``other``
+          别名：  ``other`` 
         - **out** （Tensor，可选） - 指定算子输出结果的 `Tensor`，可以是程序中已经创建的任何 Tensor。默认值为 None，此时将创建新的 Tensor 来保存输出结果。
         - **name** （str，可选） - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
- ``Tensor``，维度``x`` 维度相同，存储运算后的结果。
+  ``Tensor`` ，维度 ``x``  维度相同，存储运算后的结果。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/logit_cn.rst b/docs/api/paddle/logit_cn.rst
index 49a9f23bc7a..40af74aad49 100644
--- a/docs/api/paddle/logit_cn.rst
+++ b/docs/api/paddle/logit_cn.rst
@@ -5,12 +5,12 @@ logit
 
 .. py:function:: paddle.logit(x, eps=None, name=None)
 
-实现了 logit 层。若 eps 为默认值 None，并且 ``x`` < 0 或者 ``x`` > 1，该函数将返回 NaN，计算公式如下：
+实现了 logit 层。若 eps 为默认值 None，并且  ``x``  < 0 或者  ``x``  > 1，该函数将返回 NaN，计算公式如下：
 
 .. math::
     logit(x) = ln(\frac{x}{1-x})
 
-其中， ``x`` 为输入的 Tensor，且和 eps 有着如下关系：
+其中，  ``x``  为输入的 Tensor，且和 eps 有着如下关系：
 
 .. math::
     x_i=\left\{
@@ -25,13 +25,13 @@ logit
 
 参数
 ::::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
-    - **eps** (float，可选) - 传入该参数后可将 ``x`` 的范围控制在 :math:`[eps, 1-eps]`，默认值为 None。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
+    - **eps** (float，可选) - 传入该参数后可将  ``x``  的范围控制在 :math:`[eps, 1-eps]`，默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/logspace_cn.rst b/docs/api/paddle/logspace_cn.rst
index 280007b0454..e741e84dea1 100644
--- a/docs/api/paddle/logspace_cn.rst
+++ b/docs/api/paddle/logspace_cn.rst
@@ -8,15 +8,15 @@ logspace
 返回一个 Tensor，Tensor 的值为在区间 :math:`[base^{start}, base^{stop}]` 上按对数均匀间隔的 :math:`num` 个值，输出 Tensor 的长度为 num。
 
 .. note::
-    ``paddle.logspace`` 不进行梯度计算。
+     ``paddle.logspace``  不进行梯度计算。
 
 参数
 ::::::::::::
 
-    - **start** (int|float|Tensor) – ``start`` 是区间开始值以 ``base`` 为底的指数，可以是一个标量，或是一个 shape 为 [] 的 0-D Tensor，该 Tensor 的数据类型可以是 float32、float64、int32 或者 int64。
-    - **stop** (int|float|Tensor) – ``stop`` 是区间结束值以 ``base`` 为底的指数，可以是一个标量，或是一个 shape 为 [] 的 0-D Tensor，该 Tensor 的数据类型可以是 float32、float64、int32 或者 int64。
-    - **num** (int|Tensor) – ``num`` 是给定区间内需要划分的区间数，可以是一个整型标量，或是一个 shape 为 [] 的 0-D Tensor，该 Tensor 的数据类型需为 int32。
-    - **base** (int|float|Tensor) – ``base`` 是对数函数的底数，可以是一个标量，或是一个 shape 为 [] 的 0-D Tensor，该 Tensor 的数据类型可以是 float32、float64、int32 或者 int64。
+    - **start** (int|float|Tensor) –  ``start``  是区间开始值以  ``base``  为底的指数，可以是一个标量，或是一个 shape 为 [] 的 0-D Tensor，该 Tensor 的数据类型可以是 float32、float64、int32 或者 int64。
+    - **stop** (int|float|Tensor) –  ``stop``  是区间结束值以  ``base``  为底的指数，可以是一个标量，或是一个 shape 为 [] 的 0-D Tensor，该 Tensor 的数据类型可以是 float32、float64、int32 或者 int64。
+    - **num** (int|Tensor) –  ``num``  是给定区间内需要划分的区间数，可以是一个整型标量，或是一个 shape 为 [] 的 0-D Tensor，该 Tensor 的数据类型需为 int32。
+    - **base** (int|float|Tensor) –  ``base``  是对数函数的底数，可以是一个标量，或是一个 shape 为 [] 的 0-D Tensor，该 Tensor 的数据类型可以是 float32、float64、int32 或者 int64。
     - **dtype** (str|paddle.dtype|np.dtype，可选) – 输出 Tensor 的数据类型，可以是 float32、float64、int32 或者 int64。如果 dtype 的数据类型为 None，输出 Tensor 数据类型为 float32。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/logsumexp_cn.rst b/docs/api/paddle/logsumexp_cn.rst
index 79ccf624e52..3a36310f31e 100644
--- a/docs/api/paddle/logsumexp_cn.rst
+++ b/docs/api/paddle/logsumexp_cn.rst
@@ -5,27 +5,27 @@ logsumexp
 
 .. py:function:: paddle.logsumexp(x, axis=None, keepdim=False, name=None, *, out=None)
 
-沿着参数 ``axis`` 计算 ``x`` 的以 e 为底的指数的和的自然对数。计算公式如下：
+沿着参数  ``axis``  计算  ``x``  的以 e 为底的指数的和的自然对数。计算公式如下：
 
 .. math::
    logsumexp(x) = \log\sum exp(x)
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``， ``dim`` 可替代 ``axis``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，  ``dim``  可替代  ``axis`` 。
 
 参数
 ::::::::::
     - **x** (Tensor) - 输入的 Tensor，数据类型为：float16，float32、float64，维度不超过 4 。
-      别名： ``input``
-    - **axis** (int|list|tuple，可选) - 指定对 ``x`` 进行计算的轴。``axis`` 可以是 int、list(int)、tuple(int)。如果 ``axis`` 包含多个维度，则沿着 ``axis`` 中的所有轴进行计算。``axis`` 或者其中的元素值应该在范围[-D, D)内，D 是 ``x`` 的维度。如果 ``axis`` 或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果 ``axis`` 是 None，则对 ``x`` 的全部元素计算 logsumexp。默认值为 None。
-      别名： ``dim``
-    - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如果 ``keepdim`` 为 True，则输出 Tensor 和 ``x`` 具有相同的维度(减少的维度除外，减少的维度的大小为 1)。否则，输出 Tensor 的形状会在 ``axis`` 上进行 squeeze 操作。默认值为 False。
+      别名：  ``input`` 
+    - **axis** (int|list|tuple，可选) - 指定对  ``x``  进行计算的轴。 ``axis``  可以是 int、list(int)、tuple(int)。如果  ``axis``  包含多个维度，则沿着  ``axis``  中的所有轴进行计算。 ``axis``  或者其中的元素值应该在范围[-D, D)内，D 是  ``x``  的维度。如果  ``axis``  或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果  ``axis``  是 None，则对  ``x``  的全部元素计算 logsumexp。默认值为 None。
+      别名：  ``dim`` 
+    - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如果  ``keepdim``  为 True，则输出 Tensor 和  ``x``  具有相同的维度(减少的维度除外，减少的维度的大小为 1)。否则，输出 Tensor 的形状会在  ``axis``  上进行 squeeze 操作。默认值为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
     - **out** （Tensor，可选） - 指定输出结果的 `Tensor`，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，沿着 ``axis`` 进行 logsumexp 计算的结果，数据类型和 ``x`` 相同。
+     ``Tensor`` ，沿着  ``axis``  进行 logsumexp 计算的结果，数据类型和  ``x``  相同。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/masked_fill_cn.rst b/docs/api/paddle/masked_fill_cn.rst
index 36c7675fa4c..05f19e10040 100644
--- a/docs/api/paddle/masked_fill_cn.rst
+++ b/docs/api/paddle/masked_fill_cn.rst
@@ -7,7 +7,7 @@ masked_fill
 
 
 
-返回一个 1-D 的 Tensor，Tensor 的值是根据 ``mask`` 信息，将 ``value`` 中的值填充到 ``x`` 中 ``mask`` 对应为 ``True`` 的位置，``mask`` 的数据类型是 bool。
+返回一个 1-D 的 Tensor，Tensor 的值是根据  ``mask``  信息，将  ``value``  中的值填充到  ``x``  中  ``mask``  对应为  ``True``  的位置， ``mask``  的数据类型是 bool。
 
 下图展示了一个例子：假设我们有一个所有元素值为 1 的 3x3 矩阵 `x` 和一个相同尺寸的掩码矩阵 `Mask`，`Value` 值为 3。
 
@@ -25,7 +25,7 @@ masked_fill
 
 返回
 ::::::::::::
-返回一个根据 ``mask`` 将对应位置填充为 ``value`` 的 Tensor，数据类型与 ``x`` 相同。
+返回一个根据  ``mask``  将对应位置填充为  ``value``  的 Tensor，数据类型与  ``x``  相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/masked_scatter_cn.rst b/docs/api/paddle/masked_scatter_cn.rst
index 8f75b328c9f..f88ce08c20c 100644
--- a/docs/api/paddle/masked_scatter_cn.rst
+++ b/docs/api/paddle/masked_scatter_cn.rst
@@ -5,7 +5,7 @@ masked_scatter
 
 .. py:function:: paddle.masked_scatter(x, mask, value, name=None)
 
-返回一个 N-D 的 Tensor，Tensor 的值是根据 ``mask`` 信息，将 ``value`` 中的值逐个填充到 ``x`` 中 ``mask`` 对应为 ``True`` 的位置，``mask`` 的数据类型是 bool。
+返回一个 N-D 的 Tensor，Tensor 的值是根据  ``mask``  信息，将  ``value``  中的值逐个填充到  ``x``  中  ``mask``  对应为  ``True``  的位置， ``mask``  的数据类型是 bool。
 
 
 **示例图解说明**：
@@ -30,7 +30,7 @@ masked_scatter
 
 返回
 ::::::::::::
-返回一个根据 ``mask`` 将对应位置逐个填充 ``value`` 中的 Tensor，数据类型与 ``x`` 相同。
+返回一个根据  ``mask``  将对应位置逐个填充  ``value``  中的 Tensor，数据类型与  ``x``  相同。
 
 
 代码示例
diff --git a/docs/api/paddle/masked_select_cn.rst b/docs/api/paddle/masked_select_cn.rst
index 97eaedbb404..62c58288526 100644
--- a/docs/api/paddle/masked_select_cn.rst
+++ b/docs/api/paddle/masked_select_cn.rst
@@ -7,23 +7,23 @@ masked_select
 
 
 
-返回一个 1-D 的 Tensor，Tensor 的值是根据 ``mask`` 对输入 ``x`` 进行选择的，``mask`` 的数据类型是 bool。
+返回一个 1-D 的 Tensor，Tensor 的值是根据  ``mask``  对输入  ``x``  进行选择的， ``mask``  的数据类型是 bool。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` 。
 
 参数
 ::::::::::::
 
     - **x** (Tensor) - 输入 Tensor，数据类型为 float32，float64，int32 或者 int64。
-      别名： ``input``
+      别名：  ``input`` 
     - **mask** (Tensor) - 用于索引的二进制掩码的 Tensor，数据类型为 bool。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
     - **out** （Tensor，可选） - 指定输出结果的 `Tensor`，默认值为 None。
 
 返回
 ::::::::::::
-返回一个根据 ``mask`` 选择的的 Tensor。
+返回一个根据  ``mask``  选择的的 Tensor。
 
 
 代码示例
diff --git a/docs/api/paddle/matmul_cn.rst b/docs/api/paddle/matmul_cn.rst
index 213be6bc1d3..5dd480dc6eb 100644
--- a/docs/api/paddle/matmul_cn.rst
+++ b/docs/api/paddle/matmul_cn.rst
@@ -11,32 +11,32 @@ matmul
     .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``， ``other`` 可替代 ``y``;
+    别名支持: 参数名  ``input``  可替代  ``x`` ，  ``other``  可替代  ``y`` ;
 
-并且其行为与 ``numpy.matmul`` 一致。目前，输入 Tensor 的维数可以是任意数量，``matmul``  可以用于
-实现 ``dot`` ， ``matmul`` 和 ``batchmatmul``。实际行为取决于输入 ``x`` 、输入 ``y`` 、 ``transpose_x`` ，
-``transpose_y``。具体如下：
+并且其行为与  ``numpy.matmul``  一致。目前，输入 Tensor 的维数可以是任意数量， ``matmul``   可以用于
+实现  ``dot``  ，  ``matmul``  和  ``batchmatmul`` 。实际行为取决于输入  ``x``  、输入  ``y``  、  ``transpose_x``  ，
+ ``transpose_y`` 。具体如下：
 
-- 如果 ``transpose`` 为真，则对应 Tensor 的后两维会转置。如果 Tensor 的一维，则转置无效。假定 ``x`` 是一个 shape=[D] 的一维 Tensor，则 ``x`` 视为 [1, D]。然而，``y`` 是一个 shape=[D]的一维 Tensor，则视为[D, 1]。
+- 如果  ``transpose``  为真，则对应 Tensor 的后两维会转置。如果 Tensor 的一维，则转置无效。假定  ``x``  是一个 shape=[D] 的一维 Tensor，则  ``x``  视为 [1, D]。然而， ``y``  是一个 shape=[D]的一维 Tensor，则视为[D, 1]。
 
-乘法行为取决于 ``x`` 和 ``y`` 的尺寸。具体如下：
+乘法行为取决于  ``x``  和  ``y``  的尺寸。具体如下：
 
 - 如果两个 Tensor 均为一维，则获得点积结果。
 
 - 如果两个 Tensor 都是二维的，则获得矩阵与矩阵的乘积。
 
-- 如果 ``x`` 是 1 维的，而 ``y`` 是 2 维的，则将 1 放在 ``x`` 维度之前，以进行矩阵乘法。矩阵相乘后，将删除前置尺寸。
+- 如果  ``x``  是 1 维的，而  ``y``  是 2 维的，则将 1 放在  ``x``  维度之前，以进行矩阵乘法。矩阵相乘后，将删除前置尺寸。
 
-- 如果 ``x`` 是 2 维的，而 ``y`` 是 1 维的，获得矩阵与向量的乘积。
+- 如果  ``x``  是 2 维的，而  ``y``  是 1 维的，获得矩阵与向量的乘积。
 
-- 如果两个输入至少为一维，且至少一个输入为 N 维（其中 N> 2），则将获得批矩阵乘法。如果第一个自变量是一维的，则将 1 放在其维度的前面，以便进行批量矩阵的乘法运算，然后将其删除。如果第二个参数为一维，则将 1 附加到其维度后面，以实现成批矩阵倍数的目的，然后将其删除。根据广播规则广播非矩阵维度（不包括最后两个维度）。例如，如果输入 ``x`` 是（j，1，n，m）Tensor，另一个 ``y`` 是（k，m，p）Tensor，则 out 将是（j，k，n，p）Tensor。
+- 如果两个输入至少为一维，且至少一个输入为 N 维（其中 N> 2），则将获得批矩阵乘法。如果第一个自变量是一维的，则将 1 放在其维度的前面，以便进行批量矩阵的乘法运算，然后将其删除。如果第二个参数为一维，则将 1 附加到其维度后面，以实现成批矩阵倍数的目的，然后将其删除。根据广播规则广播非矩阵维度（不包括最后两个维度）。例如，如果输入  ``x``  是（j，1，n，m）Tensor，另一个  ``y``  是（k，m，p）Tensor，则 out 将是（j，k，n，p）Tensor。
 
 参数
 :::::::::
     - **x** (Tensor) - 输入变量，类型为 Tensor，数据类型为 bfloat16， float16， float32， float64。
-      ``别名：input``
+       ``别名：input`` 
     - **y** (Tensor) - 输入变量，类型为 Tensor，数据类型为 bfloat16， float16， float32， float64。
-      ``别名：other``
+       ``别名：other`` 
     - **transpose_x** (bool，可选) - 相乘前是否转置 x，默认值为 False。
     - **transpose_y** (bool，可选) - 相乘前是否转置 y，默认值为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
diff --git a/docs/api/paddle/maximum_cn.rst b/docs/api/paddle/maximum_cn.rst
index bd977254b3e..07d0fa09c39 100644
--- a/docs/api/paddle/maximum_cn.rst
+++ b/docs/api/paddle/maximum_cn.rst
@@ -14,24 +14,24 @@ maximum
         out = max(x, y)
 
 .. note::
-   ``paddle.maximum`` 遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
+    ``paddle.maximum``  遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
 
    .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
 
 参数
 :::::::::
-   - **x** (Tensor)- 输入的 Tensor。数据类型为 ``bfloat16`` 、 ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 或  ``int64`` 。
-     ``别名: input``
-   - **y** (Tensor) - 输入的 Tensor。数据类型为 ``bfloat16`` 、 ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 或  ``int64`` 。
-     ``别名: other``
+   - **x** (Tensor)- 输入的 Tensor。数据类型为  ``bfloat16``  、  ``float16``  、  ``float32``  、  ``float64``  、  ``int32``  或   ``int64``  。
+      ``别名: input`` 
+   - **y** (Tensor) - 输入的 Tensor。数据类型为  ``bfloat16``  、  ``float16``  、  ``float32``  、  ``float64``  、  ``int32``  或   ``int64``  。
+      ``别名: other`` 
    - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
    - **out** (Tensor，可选) - 关键字参数。输出 Tensor，用于存储计算结果。如果指定，则结果将写入此 Tensor 中。
 
 
 返回
 :::::::::
-   ``Tensor``，存储运算后的结果。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
+    ``Tensor`` ，存储运算后的结果。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
 
 
 代码示例
diff --git a/docs/api/paddle/mean_cn.rst b/docs/api/paddle/mean_cn.rst
index 41a80485bcd..08b7224a67f 100644
--- a/docs/api/paddle/mean_cn.rst
+++ b/docs/api/paddle/mean_cn.rst
@@ -5,25 +5,25 @@ mean
 
 .. py:function:: paddle.mean(x, axis=None, keepdim=False, name=None, *, dtype=None, out=None)
 
-沿参数 ``axis`` 计算 ``x`` 的平均值。
+沿参数  ``axis``  计算  ``x``  的平均值。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x`` 和 ``dim`` 可替代 ``axis``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``， ``dim=0`` 等价于 ``axis=0``。
+    别名支持: 参数名  ``input``  可替代  ``x``  和  ``dim``  可替代  ``axis`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` ，  ``dim=0``  等价于  ``axis=0`` 。
 
 参数
 ::::::::::
     - **x** (Tensor) - 输入的 Tensor，数据类型为：bool、bfloat16、float16、float32、float64、int32、int64、complex64、complex128。
-      ``别名：input``
-    - **axis** (int|list|tuple，可选) - 指定对 ``x`` 进行计算的轴。``axis`` 可以是 int、list(int)、tuple(int)。如果 ``axis`` 包含多个维度，则沿着 ``axis`` 中的所有轴进行计算。``axis`` 或者其中的元素值应该在范围[-D, D)内，D 是 ``x`` 的维度。如果 ``axis`` 或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果 ``axis`` 是 None，则对 ``x`` 的全部元素计算平均值。默认值为 None。
-      ``别名：dim``
-    - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如果 ``keepdim`` 为 True，则输出 Tensor 和 ``x`` 具有相同的维度(减少的维度除外，减少的维度的大小为 1)。否则，输出 Tensor 的形状会在 ``axis`` 上进行 squeeze 操作。默认值为 False。
+       ``别名：input`` 
+    - **axis** (int|list|tuple，可选) - 指定对  ``x``  进行计算的轴。 ``axis``  可以是 int、list(int)、tuple(int)。如果  ``axis``  包含多个维度，则沿着  ``axis``  中的所有轴进行计算。 ``axis``  或者其中的元素值应该在范围[-D, D)内，D 是  ``x``  的维度。如果  ``axis``  或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果  ``axis``  是 None，则对  ``x``  的全部元素计算平均值。默认值为 None。
+       ``别名：dim`` 
+    - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如果  ``keepdim``  为 True，则输出 Tensor 和  ``x``  具有相同的维度(减少的维度除外，减少的维度的大小为 1)。否则，输出 Tensor 的形状会在  ``axis``  上进行 squeeze 操作。默认值为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
-    - **dtype** (str，可选) - 输出 Tensor 的数据类型。如果指定了 ``dtype``，在计算之前输入 Tensor 会被转换为指定的类型。该参数为仅关键字参数，默认值为 None，此时输出的数据类型与输入 ``x`` 的数据类型一致。
+    - **dtype** (str，可选) - 输出 Tensor 的数据类型。如果指定了  ``dtype`` ，在计算之前输入 Tensor 会被转换为指定的类型。该参数为仅关键字参数，默认值为 None，此时输出的数据类型与输入  ``x``  的数据类型一致。
     - **out** (Tensor，可选)- 输出的结果。该参数为仅关键字参数，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，沿着 ``axis`` 进行平均值计算的结果，数据类型由 ``dtype`` 参数决定，如果 ``dtype`` 为 None 则与 ``x`` 相同。
+     ``Tensor`` ，沿着  ``axis``  进行平均值计算的结果，数据类型由  ``dtype``  参数决定，如果  ``dtype``  为 None 则与  ``x``  相同。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/median_cn.rst b/docs/api/paddle/median_cn.rst
index b6cb238bc69..a848cd70904 100644
--- a/docs/api/paddle/median_cn.rst
+++ b/docs/api/paddle/median_cn.rst
@@ -5,31 +5,31 @@ median
 
 .. py:function:: paddle.median(x, axis=None, keepdim=False, mode='avg', name=None)
 
-沿给定的轴 ``axis`` 计算 ``x`` 中元素的中位数。
+沿给定的轴  ``axis``  计算  ``x``  中元素的中位数。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x`` 和 ``dim`` 可替代 ``axis``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``， ``dim=1`` 等价于 ``axis=1``。
-    当出现别名替换时， ``mode`` 设置默认参数为 ``min`` 而不是 ``avg``。
+    别名支持: 参数名  ``input``  可替代  ``x``  和  ``dim``  可替代  ``axis`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` ，  ``dim=1``  等价于  ``axis=1`` 。
+    当出现别名替换时，  ``mode``  设置默认参数为  ``min``  而不是  ``avg`` 。
 
 参数
 ::::::::::
    - **x** (Tensor) - 输入的 Tensor，数据类型为：bfloat16、float16、float32、float64、int32、int64。
-     别名： ``input``
-   - **axis** (int，可选) - 指定对 ``x`` 进行计算的轴。``axis`` 可以是 int。``axis`` 值应该在范围 [-D, D) 内，D 是 ``x`` 的维度。如果 ``axis`` 或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果 ``axis`` 是 None，则对 ``x`` 的全部元素计算中位数。默认值为 None。
-     别名： ``input``
+     别名：  ``input`` 
+   - **axis** (int，可选) - 指定对  ``x``  进行计算的轴。 ``axis``  可以是 int。 ``axis``  值应该在范围 [-D, D) 内，D 是  ``x``  的维度。如果  ``axis``  或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果  ``axis``  是 None，则对  ``x``  的全部元素计算中位数。默认值为 None。
+     别名：  ``input`` 
    - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留输入的维度。除非 keepdim 为 True，否则输出 Tensor 的维度将比输入 Tensor 小一维，默认值为 False。
-   - **mode** (str，可选) - 当输入 Tensor ``x`` 在 ``axis`` 轴上有偶数个元素时，可选择按照中间两个数的平均值或最小值确定中位数。可选的值是 'avg' 或 'min'。默认为 'avg'。当出现别名替换时， ``mode`` 设置默认参数为 ``min`` 而不是 ``avg``。
+   - **mode** (str，可选) - 当输入 Tensor  ``x``  在  ``axis``  轴上有偶数个元素时，可选择按照中间两个数的平均值或最小值确定中位数。可选的值是 'avg' 或 'min'。默认为 'avg'。当出现别名替换时，  ``mode``  设置默认参数为  ``min``  而不是  ``avg`` 。
    - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
     Tensor 或 (Tensor, Tensor)。
-    若 ``mode == 'avg'``，返回值是一个中位数 Tensor；
-    若 ``mode == 'min'`` 且 ``axis`` 是 None，返回值是一个中位数 Tensor；
-    若 ``mode == 'min'`` 且 ``axis`` 不是 None，返回值是两个 Tensor，第一个是中位数，第二个是中位数对应的下标；
+    若  ``mode == 'avg'`` ，返回值是一个中位数 Tensor；
+    若  ``mode == 'min'``  且  ``axis``  是 None，返回值是一个中位数 Tensor；
+    若  ``mode == 'min'``  且  ``axis``  不是 None，返回值是两个 Tensor，第一个是中位数，第二个是中位数对应的下标；
 
-    当 ``mode == 'avg'`` 时，若 ``x`` 的数据类型是 float64，返回值的数据类型则是 float64，其他输入数据类型情况下返回值的数据类型均是 float32；
-    当 ``mode == 'min'`` 时，返回值中，中位数的数据类型与 ``x`` 的数据类型一致，下标的数据类型均为 int64。
+    当  ``mode == 'avg'``  时，若  ``x``  的数据类型是 float64，返回值的数据类型则是 float64，其他输入数据类型情况下返回值的数据类型均是 float32；
+    当  ``mode == 'min'``  时，返回值中，中位数的数据类型与  ``x``  的数据类型一致，下标的数据类型均为 int64。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/meshgrid_cn.rst b/docs/api/paddle/meshgrid_cn.rst
index 46ada40c95a..d688769bd28 100644
--- a/docs/api/paddle/meshgrid_cn.rst
+++ b/docs/api/paddle/meshgrid_cn.rst
@@ -21,7 +21,7 @@ meshgrid
 返回
 ::::::::::::
 
-k 个 k 维 ``Tensor``，每个形状均为(N1, N2, ..., Nk)。
+k 个 k 维  ``Tensor`` ，每个形状均为(N1, N2, ..., Nk)。
 
 
 代码示例
diff --git a/docs/api/paddle/metric/accuracy_cn.rst b/docs/api/paddle/metric/accuracy_cn.rst
index 99eb10aa642..b7c3943768a 100644
--- a/docs/api/paddle/metric/accuracy_cn.rst
+++ b/docs/api/paddle/metric/accuracy_cn.rst
@@ -15,8 +15,8 @@ accuracy layer。参考 https://en.wikipedia.org/wiki/Precision_and_recall
 参数
 :::::::::
 
-    - **input** (Tensor) - accuracy layer 的输入，即网络的预测值，数据类型为 float32 或 float64 的 Tensor，shape 为 ``[sample_number, class_dim]`` 。
-    - **label** (Tensor) - 数据集的标签，数据类型为 int64 或 int32 的 Tensor，shape 为 ``[sample_number, 1]`` 。
+    - **input** (Tensor) - accuracy layer 的输入，即网络的预测值，数据类型为 float32 或 float64 的 Tensor，shape 为  ``[sample_number, class_dim]``  。
+    - **label** (Tensor) - 数据集的标签，数据类型为 int64 或 int32 的 Tensor，shape 为  ``[sample_number, 1]``  。
     - **k** (int，可选) - 取每个类别中 top k 个预测值用于计算，数据类型为 int64 或 int32，默认值为 1。
     - **correct** (Tensor，可选) - 正确预测值的个数，数据类型为 int64 或 int32 的 Tensor，默认值为 None。
     - **total** (Tensor，可选) - 总共的预测值，数据类型为 int64 或 int32 的 Tensor，默认值为 None。
@@ -25,7 +25,7 @@ accuracy layer。参考 https://en.wikipedia.org/wiki/Precision_and_recall
 返回
 :::::::::
 
-    ``Tensor``，计算出来的正确率，数据类型为 float32 的 Tensor。
+     ``Tensor`` ，计算出来的正确率，数据类型为 float32 的 Tensor。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/minimum_cn.rst b/docs/api/paddle/minimum_cn.rst
index f5e23f5b693..3cc42efb6fb 100644
--- a/docs/api/paddle/minimum_cn.rst
+++ b/docs/api/paddle/minimum_cn.rst
@@ -14,23 +14,23 @@ minimum
         out = min(x, y)
 
 .. note::
-   ``paddle.minimum`` 遵守 broadcasting，如你想了解更多，请参见 `Tensor 介绍`_ .
+    ``paddle.minimum``  遵守 broadcasting，如你想了解更多，请参见 `Tensor 介绍`_ .
 
    .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
 
 参数
 :::::::::
-   - **x** (Tensor) - 输入的 Tensor。数据类型为 ``bfloat16`` 、 ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 或  ``int64`` 。
-     ``别名: input``
-   - **y** (Tensor) - 输入的 Tensor。数据类型为 ``bfloat16`` 、 ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 或  ``int64`` 。
-     ``别名: other``
+   - **x** (Tensor) - 输入的 Tensor。数据类型为  ``bfloat16``  、  ``float16``  、  ``float32``  、  ``float64``  、  ``int32``  或   ``int64``  。
+      ``别名: input`` 
+   - **y** (Tensor) - 输入的 Tensor。数据类型为  ``bfloat16``  、  ``float16``  、  ``float32``  、  ``float64``  、  ``int32``  或   ``int64``  。
+      ``别名: other`` 
    - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
    - **out** (Tensor，可选) - 关键字参数。输出 Tensor，用于存储计算结果。如果指定，则结果将写入此 Tensor 中。
 
 返回
 :::::::::
-   ``Tensor``。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
+    ``Tensor`` 。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
 
 
 代码示例
diff --git a/docs/api/paddle/mod_cn.rst b/docs/api/paddle/mod_cn.rst
index f9049f3c6aa..a3723fe6c9d 100644
--- a/docs/api/paddle/mod_cn.rst
+++ b/docs/api/paddle/mod_cn.rst
@@ -11,7 +11,7 @@ mod
         out = x \% y
 
 .. note::
-    ``paddle.mod`` 支持广播。关于广播规则，请参见 `Tensor 介绍`_ .
+     ``paddle.mod``  支持广播。关于广播规则，请参见 `Tensor 介绍`_ .
 
     .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
@@ -23,7 +23,7 @@ mod
 
 返回
 :::::::::
-``Tensor``，存储运算后的结果。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
+ ``Tensor`` ，存储运算后的结果。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/mode_cn.rst b/docs/api/paddle/mode_cn.rst
index bd35208f4bf..eb0c75dbf63 100644
--- a/docs/api/paddle/mode_cn.rst
+++ b/docs/api/paddle/mode_cn.rst
@@ -5,18 +5,18 @@ mode
 
 .. py:function:: paddle.mode(x, axis=-1, keepdim=False,  name=None)
 
-沿着可选的 ``axis`` 查找对应轴上的众数和结果所在的索引信息。
+沿着可选的  ``axis``  查找对应轴上的众数和结果所在的索引信息。
 
 参数
 :::::::::
-    - **x** （Tensor） - 输入的多维 ``Tensor``，支持的数据类型：float32、float64、int32、int64。
-    - **axis** （int，可选） - 指定对输入 Tensor 进行运算的轴，``axis`` 的有效范围是[-R, R），R 是输入 ``x`` 的 Rank， ``axis`` 为负时与 ``axis`` + R 等价。默认值为-1。
+    - **x** （Tensor） - 输入的多维  ``Tensor`` ，支持的数据类型：float32、float64、int32、int64。
+    - **axis** （int，可选） - 指定对输入 Tensor 进行运算的轴， ``axis``  的有效范围是[-R, R），R 是输入  ``x``  的 Rank，  ``axis``  为负时与  ``axis``  + R 等价。默认值为-1。
     - **keepdim** （bool，可选）- 是否保留指定的轴。如果是 True，维度会与输入 x 一致，对应所指定的轴的 size 为 1。否则，由于对应轴被展开，输出的维度会比输入小 1。默认值为 1。
     - **name** （str，可选） - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-tuple（Tensor），返回检索到的众数结果和对应索引信息。结果的数据类型和输入 ``x`` 一致。索引的数据类型是 int64。
+tuple（Tensor），返回检索到的众数结果和对应索引信息。结果的数据类型和输入  ``x``  一致。索引的数据类型是 int64。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/moveaxis_cn.rst b/docs/api/paddle/moveaxis_cn.rst
index f8794e2af3d..e32d08b25aa 100644
--- a/docs/api/paddle/moveaxis_cn.rst
+++ b/docs/api/paddle/moveaxis_cn.rst
@@ -5,7 +5,7 @@ moveaxis
 
 .. py:function:: paddle.moveaxis(x, source, destination, name=None)
 
-将输入 Tensor ``x`` 的轴从 ``source`` 位置移动到 ``destination`` 位置，其他轴按原来顺序排布。同时根据新的 shape，重排 Tensor 中的数据。
+将输入 Tensor  ``x``  的轴从  ``source``  位置移动到  ``destination``  位置，其他轴按原来顺序排布。同时根据新的 shape，重排 Tensor 中的数据。
 
 下图展示了代码示例中的第一个操作
 
@@ -20,7 +20,7 @@ moveaxis
 
 返回
 :::::::::
-``Tensor``：将轴移动后的 Tensor
+ ``Tensor`` ：将轴移动后的 Tensor
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/msort_cn.rst b/docs/api/paddle/msort_cn.rst
index 6754cd731fe..670959b8ad3 100644
--- a/docs/api/paddle/msort_cn.rst
+++ b/docs/api/paddle/msort_cn.rst
@@ -12,17 +12,17 @@ msort
 参数
 ::::::::::::
 
-    - **input** (Tensor) - 输入的 N-D ``Tensor``，支持的数据类型为：float32、float64、int16、int32、int64、uint8。别名 ``input``。
+    - **input** (Tensor) - 输入的 N-D  ``Tensor`` ，支持的数据类型为：float32、float64、int16、int32、int64、uint8。别名  ``input`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 返回
 ::::::::::::
-Tensor，排序后的输出（与 ``input`` 维度相同、数据类型相同）。
+Tensor，排序后的输出（与  ``input``  维度相同、数据类型相同）。
 
 
 代码示例
diff --git a/docs/api/paddle/mul_cn.rst b/docs/api/paddle/mul_cn.rst
index 5432b895a67..82203126093 100644
--- a/docs/api/paddle/mul_cn.rst
+++ b/docs/api/paddle/mul_cn.rst
@@ -5,4 +5,4 @@ mul
 
 .. py:function:: paddle.mul(x, y, name=None, *, out=None)
 
-``multiply`` 的别名，请参考 :ref:`cn_api_paddle_multiply`。
+ ``multiply``  的别名，请参考 :ref:`cn_api_paddle_multiply`。
diff --git a/docs/api/paddle/multigammaln_cn.rst b/docs/api/paddle/multigammaln_cn.rst
index 1a99b2ee84b..5c6ed99e5c1 100644
--- a/docs/api/paddle/multigammaln_cn.rst
+++ b/docs/api/paddle/multigammaln_cn.rst
@@ -16,7 +16,7 @@ multigammaln
 
 返回
 ::::::::::::
-输出为 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出为 Tensor，与  ``x``  维度相同、数据类型相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/multinomial_cn.rst b/docs/api/paddle/multinomial_cn.rst
index 7ecf180ecaf..d4d8141b4c7 100644
--- a/docs/api/paddle/multinomial_cn.rst
+++ b/docs/api/paddle/multinomial_cn.rst
@@ -8,18 +8,18 @@ multinomial
 
 
 
-以输入 ``x`` 为概率，生成一个多项分布的 Tensor。
-输入 ``x`` 是用来随机采样的概率分布，``x`` 中每个元素都应该大于等于 0，且不能都为 0。
-参数 ``replacement`` 表示它是否是一个可放回的采样，如果 ``replacement`` 为 True，能重复对一种类别采样。
+以输入  ``x``  为概率，生成一个多项分布的 Tensor。
+输入  ``x``  是用来随机采样的概率分布， ``x``  中每个元素都应该大于等于 0，且不能都为 0。
+参数  ``replacement``  表示它是否是一个可放回的采样，如果  ``replacement``  为 True，能重复对一种类别采样。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` 。
 
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 输入的概率值。数据类型为 ``float32`` 、``float64`` 。
-      ``别名：input``
+    - **x** (Tensor) - 输入的概率值。数据类型为  ``float32``  、 ``float64``  。
+       ``别名：input`` 
     - **num_samples** (int，可选) - 采样的次数（可选，默认值为 1）。
     - **replacement** (bool，可选) - 是否是可放回的采样（可选，默认值为 False）。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
@@ -28,7 +28,7 @@ multinomial
 返回
 ::::::::::::
 
-    Tensor，多项分布采样得到的随机 Tensor，为 ``num_samples`` 次采样得到的类别下标。
+    Tensor，多项分布采样得到的随机 Tensor，为  ``num_samples``  次采样得到的类别下标。
 
 
 代码示例
diff --git a/docs/api/paddle/multiply_cn.rst b/docs/api/paddle/multiply_cn.rst
index 30dc0688d76..a4161a1229b 100755
--- a/docs/api/paddle/multiply_cn.rst
+++ b/docs/api/paddle/multiply_cn.rst
@@ -7,7 +7,7 @@ multiply
 
 
 
-逐元素相乘算子，输入 ``x`` 与输入 ``y`` 逐元素相乘，并将各个位置的输出元素保存到返回结果中。
+逐元素相乘算子，输入  ``x``  与输入  ``y``  逐元素相乘，并将各个位置的输出元素保存到返回结果中。
 
 等式是：
 
@@ -19,35 +19,35 @@ multiply
 
 对于这个运算算子有 2 种情况：
 
-        1. :math:`Y` 的 ``shape`` 与 :math:`X` 相同。
-        2. :math:`Y` 的 ``shape`` 是 :math:`X` 的连续子序列。
-        3. 输入 ``x`` 与输入 ``y`` 必须可以广播为相同形状，关于广播规则，请参见 `Tensor 介绍`_ .
+        1. :math:`Y` 的  ``shape``  与 :math:`X` 相同。
+        2. :math:`Y` 的  ``shape``  是 :math:`X` 的连续子序列。
+        3. 输入  ``x``  与输入  ``y``  必须可以广播为相同形状，关于广播规则，请参见 `Tensor 介绍`_ .
 
         .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``， ``other`` 可替代 ``y``;
+    别名支持: 参数名  ``input``  可替代  ``x`` ，  ``other``  可替代  ``y`` ;
 
 
 参数
 :::::::::
 
-        - **x** （Tensor）- 多维 ``Tensor``。数据类型为 ``bfloat16`` 、 ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 、 ``int64``、 ``bool``、 ``complex64`` 或  ``complex128``。
-          ``别名：input``
-        - **y** （Tensor）- 多维 ``Tensor``。数据类型为 ``bfloat16`` 、 ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 、 ``int64``、 ``bool``、 ``complex64`` 或  ``complex128``。
-          ``别名：other``
+        - **x** （Tensor）- 多维  ``Tensor`` 。数据类型为  ``bfloat16``  、  ``float16``  、  ``float32``  、  ``float64``  、  ``int32``  、  ``int64`` 、  ``bool`` 、  ``complex64``  或   ``complex128`` 。
+           ``别名：input`` 
+        - **y** （Tensor）- 多维  ``Tensor`` 。数据类型为  ``bfloat16``  、  ``float16``  、  ``float32``  、  ``float64``  、  ``int32``  、  ``int64`` 、  ``bool`` 、  ``complex64``  或   ``complex128`` 。
+           ``别名：other`` 
         - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
         - **out** (Tensor，可选)- 输出的结果。该参数为仅关键字参数，默认值为 None。
 
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 
 返回
 :::::::::
-   ``Tensor``，存储运算后的结果。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
+    ``Tensor`` ，存储运算后的结果。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
 
 
 代码示例
diff --git a/docs/api/paddle/mv_cn.rst b/docs/api/paddle/mv_cn.rst
index 2f219694a24..000b99b63da 100644
--- a/docs/api/paddle/mv_cn.rst
+++ b/docs/api/paddle/mv_cn.rst
@@ -5,7 +5,7 @@ mv
 
 .. py:function:: paddle.mv(x, vec, name=None)
 
-计算矩阵 ``x`` 和向量 ``vec`` 的乘积。
+计算矩阵  ``x``  和向量  ``vec``  的乘积。
 
 参数
 :::::::::
@@ -16,7 +16,7 @@ mv
 返回
 :::::::::
 
-    - Tensor，矩阵 ``x`` 和向量 ``vec`` 的乘积。
+    - Tensor，矩阵  ``x``  和向量  ``vec``  的乘积。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nanmean_cn.rst b/docs/api/paddle/nanmean_cn.rst
index 56a9d5d7755..a4d31d5b9cb 100644
--- a/docs/api/paddle/nanmean_cn.rst
+++ b/docs/api/paddle/nanmean_cn.rst
@@ -7,18 +7,18 @@ nanmean
 
 
 
-沿 ``axis`` 计算 ``x`` 的平均值，且忽略掉 ``NaNs`` 值。
+沿  ``axis``  计算  ``x``  的平均值，且忽略掉  ``NaNs``  值。
 
 参数
 ::::::::::
     - **x** (Tensor) - 输入的 Tensor，数据类型为：bfloat16、float16、float32、float64。
-    - **axis** (int|list|tuple，可选) - 指定对 ``x`` 进行计算的轴。``axis`` 可以是 int、list(int)、tuple(int)。如果 ``axis`` 包含多个维度，则沿着 ``axis`` 中的所有轴进行计算。``axis`` 或者其中的元素值应该在范围[-D, D)内，D 是 ``x`` 的维度。如果 ``axis`` 或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果 ``axis`` 是 None，则对 ``x`` 的全部元素计算平均值。默认值为 None。
-    - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如果 ``keepdim`` 为 True，则输出 Tensor 和 ``x`` 具有相同的维度(减少的维度除外，减少的维度的大小为 1)。否则，输出 Tensor 的形状会在 ``axis`` 上进行 squeeze 操作。默认值为 False。
+    - **axis** (int|list|tuple，可选) - 指定对  ``x``  进行计算的轴。 ``axis``  可以是 int、list(int)、tuple(int)。如果  ``axis``  包含多个维度，则沿着  ``axis``  中的所有轴进行计算。 ``axis``  或者其中的元素值应该在范围[-D, D)内，D 是  ``x``  的维度。如果  ``axis``  或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果  ``axis``  是 None，则对  ``x``  的全部元素计算平均值。默认值为 None。
+    - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如果  ``keepdim``  为 True，则输出 Tensor 和  ``x``  具有相同的维度(减少的维度除外，减少的维度的大小为 1)。否则，输出 Tensor 的形状会在  ``axis``  上进行 squeeze 操作。默认值为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，沿着 ``axis`` 进行平均值计算的结果且忽略掉 ``NaNs`` 值，数据类型和 ``x`` 相同。
+     ``Tensor`` ，沿着  ``axis``  进行平均值计算的结果且忽略掉  ``NaNs``  值，数据类型和  ``x``  相同。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nanmedian_cn.rst b/docs/api/paddle/nanmedian_cn.rst
index 7e6bbd02572..ccbbfce20a3 100644
--- a/docs/api/paddle/nanmedian_cn.rst
+++ b/docs/api/paddle/nanmedian_cn.rst
@@ -5,20 +5,20 @@ nanmedian
 
 .. py:function:: paddle.nanmedian(x, axis=None, keepdim=False, mode='avg', name=None)
 
-沿给定的轴 ``axis`` 计算中位数，同时忽略 NAN 元素。
+沿给定的轴  ``axis``  计算中位数，同时忽略 NAN 元素。
 如果元素的有效计数为偶数，则计算并返回中间两数的平均数。
 
 参数
 ::::::::::
    - **x** (Tensor) - 输入的 Tensor，数据类型为：float16、bfloat16、float32、float64、int32、int64。
-   - **axis** (None|int|list|tuple，可选) - 指定对 ``x`` 进行计算的轴。``axis`` 可以是 int 或者 int 元素的列表。``axis`` 值应该在范围[-D， D)内，D 是 ``x`` 的维度。如果 ``axis`` 或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果 ``axis`` 是 None，则对 ``x`` 的全部元素计算中位数。默认值为 None。
-   - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如果 ``keepdim`` 为 True，则输出 Tensor 和 ``x`` 具有相同的维度(减少的维度除外，减少的维度的大小为 1)。否则，输出 Tensor 的形状会在 ``axis`` 上进行 squeeze 操作。默认值为 False
-   - **mode** (str，可选) - 当输入 Tensor ``x`` 在 ``axis`` 轴上有偶数个非 NaN 元素时，可选择按照中间两个非 NaN 元素的平均值或最小值确定中位数。可选的值是 'avg' 或 'min'。默认为 'avg'。
+   - **axis** (None|int|list|tuple，可选) - 指定对  ``x``  进行计算的轴。 ``axis``  可以是 int 或者 int 元素的列表。 ``axis``  值应该在范围[-D， D)内，D 是  ``x``  的维度。如果  ``axis``  或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果  ``axis``  是 None，则对  ``x``  的全部元素计算中位数。默认值为 None。
+   - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如果  ``keepdim``  为 True，则输出 Tensor 和  ``x``  具有相同的维度(减少的维度除外，减少的维度的大小为 1)。否则，输出 Tensor 的形状会在  ``axis``  上进行 squeeze 操作。默认值为 False
+   - **mode** (str，可选) - 当输入 Tensor  ``x``  在  ``axis``  轴上有偶数个非 NaN 元素时，可选择按照中间两个非 NaN 元素的平均值或最小值确定中位数。可选的值是 'avg' 或 'min'。默认为 'avg'。
    - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    Tensor 或 (Tensor, Tensor)。 若 ``mode == 'min'`` 且 ``axis`` 是 int 类型，结果返回一个元组：(非 NaN 中位数，对应下标)；否则只返回一个 Tensor （非 NaN 中位数）。
+    Tensor 或 (Tensor, Tensor)。 若  ``mode == 'min'``  且  ``axis``  是 int 类型，结果返回一个元组：(非 NaN 中位数，对应下标)；否则只返回一个 Tensor （非 NaN 中位数）。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nanquantile_cn.rst b/docs/api/paddle/nanquantile_cn.rst
index 533628d8b07..264aad1453c 100644
--- a/docs/api/paddle/nanquantile_cn.rst
+++ b/docs/api/paddle/nanquantile_cn.rst
@@ -5,20 +5,20 @@ nanquantile
 
 .. py:function:: paddle.nanquantile(x, q, axis=None, keepdim=False, interpolation='linear', name=None)
 
-沿给定的轴 ``axis`` 计算 ``x`` 中元素的分位数, 忽略元素中的 ``NaN`` 。
+沿给定的轴  ``axis``  计算  ``x``  中元素的分位数, 忽略元素中的  ``NaN``  。
 
 参数
 ::::::::::
     - **x** (Tensor) - 输入的 Tensor，数据类型为：bfloat16、float16、float32、float64。
-    - **q** (int|float|list|Tensor) - 待计算的分位数，需要在符合取值范围[0, 1]。如果 ``q`` 是 List 或者 1-D Tensor，其中的每一个 q 分位数都会被计算，并且输出的首维大小与列表或 Tensor 中元素的数量相同。如果 ``q`` 是 0-D Tensor ，则会被当作 float 和 int 对待。
-    - **axis** (int|list，可选) - 指定对 ``x`` 进行计算的轴。``axis`` 可以是 int 或内部元素为 int 类型的 list。``axis`` 值应该在范围[-D, D)内，D 是 ``x`` 的维度。如果 ``axis`` 或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果 ``axis`` 是 list，对给定的轴上的所有元素计算分位数。如果 ``axis`` 是 None，则对 ``x`` 的全部元素计算分位数。默认值为 None。
-    - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如果 ``keepdim`` 为 True，则输出 Tensor 和 ``x`` 具有相同的维度(减少的维度除外，减少的维度的大小为 1)。否则，输出 Tensor 的形状会在 ``axis`` 上进行 squeeze 操作。默认值为 False。
-    - **interpolation** (str，可选) - 计算分位数的插值方法，可以是 ``linear`` , ``lower`` , ``higher`` , ``nearest`` 或者 ``midpoint`` 。 默认值为 ``linear`` 。
+    - **q** (int|float|list|Tensor) - 待计算的分位数，需要在符合取值范围[0, 1]。如果  ``q``  是 List 或者 1-D Tensor，其中的每一个 q 分位数都会被计算，并且输出的首维大小与列表或 Tensor 中元素的数量相同。如果  ``q``  是 0-D Tensor ，则会被当作 float 和 int 对待。
+    - **axis** (int|list，可选) - 指定对  ``x``  进行计算的轴。 ``axis``  可以是 int 或内部元素为 int 类型的 list。 ``axis``  值应该在范围[-D, D)内，D 是  ``x``  的维度。如果  ``axis``  或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果  ``axis``  是 list，对给定的轴上的所有元素计算分位数。如果  ``axis``  是 None，则对  ``x``  的全部元素计算分位数。默认值为 None。
+    - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如果  ``keepdim``  为 True，则输出 Tensor 和  ``x``  具有相同的维度(减少的维度除外，减少的维度的大小为 1)。否则，输出 Tensor 的形状会在  ``axis``  上进行 squeeze 操作。默认值为 False。
+    - **interpolation** (str，可选) - 计算分位数的插值方法，可以是  ``linear``  ,  ``lower``  ,  ``higher``  ,  ``nearest``  或者  ``midpoint``  。 默认值为  ``linear``  。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，沿着 ``axis`` 进行分位数计算的结果。与输入数据类型一致。
+     ``Tensor`` ，沿着  ``axis``  进行分位数计算的结果。与输入数据类型一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nansum_cn.rst b/docs/api/paddle/nansum_cn.rst
index cdd6cd7f632..901865a81b2 100644
--- a/docs/api/paddle/nansum_cn.rst
+++ b/docs/api/paddle/nansum_cn.rst
@@ -17,7 +17,7 @@ nansum
 
 返回
 :::::::::
-``Tensor``，在指定维度上进行求和运算的 Tensor，数据类型和输入数据类型一致。
+ ``Tensor`` ，在指定维度上进行求和运算的 Tensor，数据类型和输入数据类型一致。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/narrow_cn.rst b/docs/api/paddle/narrow_cn.rst
index 2ee8211416e..223bfda2d26 100644
--- a/docs/api/paddle/narrow_cn.rst
+++ b/docs/api/paddle/narrow_cn.rst
@@ -17,7 +17,7 @@ narrow
 
 返回
 :::::::::
-``Tensor``，与 input 数据类型相同，形状仅在 dim 维变为 length，其余维不变。
+ ``Tensor`` ，与 input 数据类型相同，形状仅在 dim 维变为 length，其余维不变。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/neg_cn.rst b/docs/api/paddle/neg_cn.rst
index 87ab8044935..38f1553a682 100644
--- a/docs/api/paddle/neg_cn.rst
+++ b/docs/api/paddle/neg_cn.rst
@@ -20,7 +20,7 @@ neg
 
 返回
 :::::::::
-输出 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出 Tensor，与  ``x``  维度相同、数据类型相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nextafter_cn.rst b/docs/api/paddle/nextafter_cn.rst
index b340befb9b5..679786df85b 100644
--- a/docs/api/paddle/nextafter_cn.rst
+++ b/docs/api/paddle/nextafter_cn.rst
@@ -20,7 +20,7 @@ nextafter
 
 返回
 :::::::::
-输出 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出 Tensor，与  ``x``  维度相同、数据类型相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/AdaptiveAvgPool1D_cn.rst b/docs/api/paddle/nn/AdaptiveAvgPool1D_cn.rst
index 1e53e39e6dd..79d2dc6eef2 100755
--- a/docs/api/paddle/nn/AdaptiveAvgPool1D_cn.rst
+++ b/docs/api/paddle/nn/AdaptiveAvgPool1D_cn.rst
@@ -5,7 +5,7 @@ AdaptiveAvgPool1D
 
 .. py:class:: paddle.nn.AdaptiveAvgPool1D(output_size, name=None)
 
-根据 ``output_size`` 对一个输入 Tensor 计算 1D 的自适应平均池化。输入和输出都是以 NCL 格式表示的 3-D Tensor，其中 N 是批大小，C 是通道数而 L 是特征的长度。输出的形状是 :math:`[N, C, output\_size]`。
+根据  ``output_size``  对一个输入 Tensor 计算 1D 的自适应平均池化。输入和输出都是以 NCL 格式表示的 3-D Tensor，其中 N 是批大小，C 是通道数而 L 是特征的长度。输出的形状是 :math:`[N, C, output\_size]`。
 
 计算公式为
 
diff --git a/docs/api/paddle/nn/AdaptiveLogSoftmaxWithLoss_cn.rst b/docs/api/paddle/nn/AdaptiveLogSoftmaxWithLoss_cn.rst
index f6f9bf8f5bd..2b97b34022b 100644
--- a/docs/api/paddle/nn/AdaptiveLogSoftmaxWithLoss_cn.rst
+++ b/docs/api/paddle/nn/AdaptiveLogSoftmaxWithLoss_cn.rst
@@ -10,11 +10,11 @@ AdaptiveLogSoftmaxWithLoss 将标签按照频率划分为多个组，每个组
 
 在每个训练的小批量中，只有当至少有一个目标标签出现时，相应的组才会被计算。这种方法的设计理念是，频繁访问的组（如包含最常见标签的初始组）应该具有较低的计算成本。
 
-对于参数 ``cutoffs``，按升序排序的整数序列。它控制组的数量和目标分配到组的方式。例如，设置 ``cutoffs = [10, 100, 1000]`` 意味着前 10 个目标将分配到 AdaptiveLogSoftmaxWithLoss 的 ``head``，目标 11, 12, ..., 100 将分配到第一个组，而目标 101, 102, ..., 1000 将分配到第二个组，而目标 1001, 1002, ..., n_classes - 1 将分配到第三个组。
+对于参数  ``cutoffs`` ，按升序排序的整数序列。它控制组的数量和目标分配到组的方式。例如，设置  ``cutoffs = [10, 100, 1000]``  意味着前 10 个目标将分配到 AdaptiveLogSoftmaxWithLoss 的  ``head`` ，目标 11, 12, ..., 100 将分配到第一个组，而目标 101, 102, ..., 1000 将分配到第二个组，而目标 1001, 1002, ..., n_classes - 1 将分配到第三个组。
 
-对于参数 ``div_value``，用于计算每个附加组的大小，其值为 :math:`\left\lfloor \frac{\text{in\_features}}{\text{div\_value}^{\text{idx}}} \right\rfloor`，其中 ``idx`` 是组索引（对于较不频繁的单词，组索引较大，索引从 :math:`1` 开始）。
+对于参数  ``div_value`` ，用于计算每个附加组的大小，其值为 :math:`\left\lfloor \frac{\text{in\_features}}{\text{div\_value}^{\text{idx}}} \right\rfloor`，其中  ``idx``  是组索引（对于较不频繁的单词，组索引较大，索引从 :math:`1` 开始）。
 
-对于参数 ``head_bias``，如果设置为 True，将在 AdaptiveLogSoftmaxWithLoss 的 ``head`` 上添加偏置项。详细信息请参阅论文：https://arxiv.org/abs/1609.04309 。
+对于参数  ``head_bias`` ，如果设置为 True，将在 AdaptiveLogSoftmaxWithLoss 的  ``head``  上添加偏置项。详细信息请参阅论文：https://arxiv.org/abs/1609.04309 。
 
 
 
@@ -24,14 +24,14 @@ AdaptiveLogSoftmaxWithLoss 将标签按照频率划分为多个组，每个组
     - **n_classes** (int): 数据集中类型的个数。
     - **cutoffs** (Sequence): 用于将 label 分配到不同存储组的截断值。
     - **div_value** (float, 可选): 用于计算组大小的指数值。默认值：4.0。
-    - **head_bias** (bool, 可选): 如果为 ``True``，AdaptiveLogSoftmaxWithLoss 的 ``head`` 添加偏置项。默认值： ``False``.
+    - **head_bias** (bool, 可选): 如果为  ``True`` ，AdaptiveLogSoftmaxWithLoss 的  ``head``  添加偏置项。默认值：  ``False`` .
     - **name** (str, 可选): 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
 :::::::::
-    - **input** (Tensor): - 输入 Tensor，形状为 ``[N, in_features]``， ``N`` 是批尺寸。
-    - **label** (Tensor): - 目标值，形状为 ``[N]``。
-    - **output1** (Tensor): - 形状为 ``[N]``。
+    - **input** (Tensor): - 输入 Tensor，形状为  ``[N, in_features]`` ，  ``N``  是批尺寸。
+    - **label** (Tensor): - 目标值，形状为  ``[N]`` 。
+    - **output1** (Tensor): - 形状为  ``[N]`` 。
     - **output2** (Scalar): - 标量，无形状
 
 返回
diff --git a/docs/api/paddle/nn/BCELoss_cn.rst b/docs/api/paddle/nn/BCELoss_cn.rst
index b8225560857..77852f5a70a 100644
--- a/docs/api/paddle/nn/BCELoss_cn.rst
+++ b/docs/api/paddle/nn/BCELoss_cn.rst
@@ -5,7 +5,7 @@ BCELoss
 
 .. py:class:: paddle.nn.BCELoss(weight=None, reduction='mean', name=None)
 
-创建一个 BCELoss 的可调用类，用于计算输入 ``input`` 和标签 ``label`` 之间的二值交叉熵损失值。二值交叉熵损失函数公式如下：
+创建一个 BCELoss 的可调用类，用于计算输入  ``input``  和标签  ``label``  之间的二值交叉熵损失值。二值交叉熵损失函数公式如下：
 
 当 `weight` 不为空时，公式为：
 
@@ -31,19 +31,19 @@ BCELoss
 
 
 .. note::
-    输入数据 ``input`` 一般是 ``sigmoid`` 的输出。因为是二分类，所以标签值 ``label`` 应该是 0 或者 1。
+    输入数据  ``input``  一般是  ``sigmoid``  的输出。因为是二分类，所以标签值  ``label``  应该是 0 或者 1。
 
 参数
 :::::::::
     - **weight** (Tensor，可选) - 手动指定每个 batch 二值交叉熵的权重，如果指定的话，维度必须是一个 batch 的数据的维度。数据类型是 float32, float64。默认值是：None。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：``'none'``, ``'mean'``, ``'sum'``。默认为 ``'mean'``，计算 `BCELoss` 的均值；设置为 ``'sum'`` 时，计算 `BCELoss` 的总和；设置为 ``'none'`` 时，则返回 bce_loss。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ,  ``'mean'`` ,  ``'sum'`` 。默认为  ``'mean'`` ，计算 `BCELoss` 的均值；设置为  ``'sum'``  时，计算 `BCELoss` 的总和；设置为  ``'none'``  时，则返回 bce_loss。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
 :::::::::
-    - **input** (Tensor) - :math:`(N, *)`，其中 N 是 batch_size， `*` 是任意其他维度。输入数据 ``input`` 一般是 ``sigmoid`` 的输出。数据类型是 float32、float64。
-    - **label** (Tensor) - :math:`(N, *)`，标签 ``label`` 的维度、数据类型与输入 ``input`` 相同。
-    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是 ``'none'``，则输出的维度为 :math:`(N, *)`，与输入 ``input`` 的形状相同。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出的维度为 :math:`[]` 。
+    - **input** (Tensor) - :math:`(N, *)`，其中 N 是 batch_size， `*` 是任意其他维度。输入数据  ``input``  一般是  ``sigmoid``  的输出。数据类型是 float32、float64。
+    - **label** (Tensor) - :math:`(N, *)`，标签  ``label``  的维度、数据类型与输入  ``input``  相同。
+    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是  ``'none'`` ，则输出的维度为 :math:`(N, *)`，与输入  ``input``  的形状相同。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出的维度为 :math:`[]` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/nn/BCEWithLogitsLoss_cn.rst b/docs/api/paddle/nn/BCEWithLogitsLoss_cn.rst
index c5bbe8995dd..7f97fbe89ee 100644
--- a/docs/api/paddle/nn/BCEWithLogitsLoss_cn.rst
+++ b/docs/api/paddle/nn/BCEWithLogitsLoss_cn.rst
@@ -7,7 +7,7 @@ BCEWithLogitsLoss
 
 可用于创建一个 BCEWithLogitsLoss 的可调用类，计算输入的预测值 `logit` 和标签 `label` 间的 `binary cross entropy with logits loss` 损失。
 
-计算方式结合了 `sigmoid` 操作和 :ref:`cn_api_paddle_nn_BCELoss` 操作。或者，我们也可以认为计算方式是 ``sigmoid_cross_entrop_with_logits`` 和一些 `reduce` 操作的组合。
+计算方式结合了 `sigmoid` 操作和 :ref:`cn_api_paddle_nn_BCELoss` 操作。或者，我们也可以认为计算方式是  ``sigmoid_cross_entrop_with_logits``  和一些 `reduce` 操作的组合。
 
 该损失函数衡量了在每个类别相互独立的分类任务中的逐元素概率误差。这可以被视为预测数据点的标签，其中标签不是相互排斥的。例如，一篇新闻文章可以同时关于政治，科技，体育或者同时不包含这些内容。
 
@@ -26,7 +26,7 @@ BCEWithLogitsLoss
 .. math::
     Out = \max(Logit, 0) - Logit * Labels + \log(1 + e^{-\|Logit\|})
 
-然后，当 ``weight`` 或 ``pos_weight`` 不为 None 的时候，将会在输出 Out 上乘以相应的权重。Tensor ``weight`` 给 Batch 中的每一条数据赋予不同权重，Tensor ``pos_weight`` 给每一类的正例添加相应的权重。
+然后，当  ``weight``  或  ``pos_weight``  不为 None 的时候，将会在输出 Out 上乘以相应的权重。Tensor  ``weight``  给 Batch 中的每一条数据赋予不同权重，Tensor  ``pos_weight``  给每一类的正例添加相应的权重。
 
 最后，将会添加 `reduce` 操作到前面的输出 Out 上。当 `reduction` 为 `none` 时，直接返回最原始的 `Out` 结果。当 `reduction` 为 `mean` 时，返回输出的均值 :math:`Out = MEAN(Out)`。当 `reduction` 为 `sum` 时，返回输出的求和 :math:`Out = SUM(Out)` 。
 
@@ -36,15 +36,15 @@ BCEWithLogitsLoss
 参数
 :::::::::
     - **weight** (Tensor，可选) - 手动指定每个 batch 二值交叉熵的权重。如果指定的话，维度必须是一个 batch 的数据的维度。数据类型是 float32, float64。默认值是：None。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：``'none'``, ``'mean'``, ``'sum'``。默认为 ``'mean'``，计算 `BCELoss` 的均值；设置为 ``'sum'`` 时，计算 `BCELoss` 的总和；设置为 ``'none'`` 时，则返回原始 loss。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ,  ``'mean'`` ,  ``'sum'`` 。默认为  ``'mean'`` ，计算 `BCELoss` 的均值；设置为  ``'sum'``  时，计算 `BCELoss` 的总和；设置为  ``'none'``  时，则返回原始 loss。
     - **pos_weight** (Tensor，可选) - 手动指定正类的权重，必须是与类别数相等长度的向量。数据类型是 float32, float64。默认值是：None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
 :::::::::
-    - **logit** (Tensor) - 输入的预测值。形状是 :math:`[N, *]`，其中 N 是 batch_size， `*` 是任意其他维度。输入的预测值 ``logit`` 一般是线性层的输出，不需要经过 ``sigmoid`` 层。数据类型是 float32、float64。
-    - **label** (Tensor) - 标签。 形状是 :math:`[N, *]`，标签 ``label`` 的维度、数据类型与输入的预测值 ``logit`` 相同。
-    - **output** (Tensor) - 输出的 Tensor。 如果 :attr:`reduction` 是 ``'none'``，则输出的维度为 :math:`[N, *]`，与输入 ``logit`` 的形状相同。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出的维度为 :math:`[]` 。
+    - **logit** (Tensor) - 输入的预测值。形状是 :math:`[N, *]`，其中 N 是 batch_size， `*` 是任意其他维度。输入的预测值  ``logit``  一般是线性层的输出，不需要经过  ``sigmoid``  层。数据类型是 float32、float64。
+    - **label** (Tensor) - 标签。 形状是 :math:`[N, *]`，标签  ``label``  的维度、数据类型与输入的预测值  ``logit``  相同。
+    - **output** (Tensor) - 输出的 Tensor。 如果 :attr:`reduction` 是  ``'none'`` ，则输出的维度为 :math:`[N, *]`，与输入  ``logit``  的形状相同。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出的维度为 :math:`[]` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/nn/BatchNorm1D_cn.rst b/docs/api/paddle/nn/BatchNorm1D_cn.rst
index 7fd2aeecac6..50994ab840c 100644
--- a/docs/api/paddle/nn/BatchNorm1D_cn.rst
+++ b/docs/api/paddle/nn/BatchNorm1D_cn.rst
@@ -6,7 +6,7 @@ BatchNorm1D
 .. py:class:: paddle.nn.BatchNorm1D(num_features, momentum=0.9, epsilon=1e-05, weight_attr=None, bias_attr=None, data_format='NCL', use_global_stats=None, name=None)
 
 
-构建 ``BatchNorm1D`` 类的一个可调用对象，具体用法参照 ``代码示例``。可以处理 2D 或者 3D 的 Tensor，实现了批归一化层（Batch Normalization Layer）的功能，可用作卷积和全连接操作的批归一化函数，根据当前批次数据按通道计算的均值和方差进行归一化。更多详情请参考：`Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/pdf/1502.03167.pdf>`_
+构建  ``BatchNorm1D``  类的一个可调用对象，具体用法参照  ``代码示例`` 。可以处理 2D 或者 3D 的 Tensor，实现了批归一化层（Batch Normalization Layer）的功能，可用作卷积和全连接操作的批归一化函数，根据当前批次数据按通道计算的均值和方差进行归一化。更多详情请参考：`Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/pdf/1502.03167.pdf>`_
 
 当训练时 :math:`\mu_{\beta}` 和 :math:`\sigma_{\beta}^{2}` 是 minibatch 的统计数据。计算公式如下：
 
@@ -38,12 +38,12 @@ BatchNorm1D
 参数
 ::::::::::::
 
-    - **num_features** (int) - 指明输入 ``Tensor`` 的通道数量。
+    - **num_features** (int) - 指明输入  ``Tensor``  的通道数量。
     - **epsilon** (float，可选) - 为了数值稳定加在分母上的值。默认值：1e-05。
-    - **momentum** (float，可选) - 此值用于计算 ``moving_mean`` 和 ``moving_var``。默认值：0.9。更新公式如上所示。
+    - **momentum** (float，可选) - 此值用于计算  ``moving_mean``  和  ``moving_var`` 。默认值：0.9。更新公式如上所示。
     - **weight_attr** (ParamAttr|bool，可选) - 指定权重参数属性的对象。如果为 False，则表示每个通道的伸缩固定为 1，不可改变。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **bias_attr** (ParamAttr|bool，可选) - 指定偏置参数属性的对象。如果为 False，则表示每一个通道的偏移固定为 0，不可改变。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **data_format** (str，可选) - 指定输入数据格式，数据格式可以为 ``"NC"``、``"NCL"`` 或者 ``"NLC"``，其中 N 是批大小，C 是通道数，L 是特征长度。默认值为 ``"NCL"``。
+    - **data_format** (str，可选) - 指定输入数据格式，数据格式可以为  ``"NC"`` 、 ``"NCL"``  或者  ``"NLC"`` ，其中 N 是批大小，C 是通道数，L 是特征长度。默认值为  ``"NCL"`` 。
     - **use_global_stats** (bool|None，可选) – 指示是否使用全局均值和方差。若设置为 False，则使用一个 mini-batch 的统计数据。若设置为 True 时，将使用全局统计数据。若设置为 None，则会在测试阶段使用全局统计数据，在训练阶段使用一个 mini-batch 的统计数据。默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
@@ -55,7 +55,7 @@ BatchNorm1D
 形状
 ::::::::::::
 
-    - input：当 data_format 为 ``"NC"`` 或 ``"NCL"`` 时，形状为（批大小，通道数）的 2-D Tensor 或形状为（批大小，通道数，特征长度）的 3-D Tensor。当 data_format 为 ``"NLC"`` 时，形状为（批大小，长度，通道数）的 3-D Tensor。
+    - input：当 data_format 为  ``"NC"``  或  ``"NCL"``  时，形状为（批大小，通道数）的 2-D Tensor 或形状为（批大小，通道数，特征长度）的 3-D Tensor。当 data_format 为  ``"NLC"``  时，形状为（批大小，长度，通道数）的 3-D Tensor。
     - output：和输入形状一样的 Tensor。
 
 .. note::
diff --git a/docs/api/paddle/nn/BatchNorm2D_cn.rst b/docs/api/paddle/nn/BatchNorm2D_cn.rst
index 7eaf7d414e7..ce412288e3e 100644
--- a/docs/api/paddle/nn/BatchNorm2D_cn.rst
+++ b/docs/api/paddle/nn/BatchNorm2D_cn.rst
@@ -6,7 +6,7 @@ BatchNorm2D
 .. py:class:: paddle.nn.BatchNorm2D(num_features, momentum=0.9, epsilon=1e-05, weight_attr=None, bias_attr=None, data_format='NCHW', use_global_stats=None, name=None)
 
 
-构建 ``BatchNorm2D`` 类的一个可调用对象，具体用法参照 ``代码示例``。可以处理 4D 的 Tensor，实现了批归一化层（Batch Normalization Layer）的功能，可用作卷积和全连接操作的批归一化函数，根据当前批次数据按通道计算的均值和方差进行归一化。更多详情请参考：`Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/pdf/1502.03167.pdf>`_
+构建  ``BatchNorm2D``  类的一个可调用对象，具体用法参照  ``代码示例`` 。可以处理 4D 的 Tensor，实现了批归一化层（Batch Normalization Layer）的功能，可用作卷积和全连接操作的批归一化函数，根据当前批次数据按通道计算的均值和方差进行归一化。更多详情请参考：`Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/pdf/1502.03167.pdf>`_
 
 当训练时 :math:`\mu_{\beta}` 和 :math:`\sigma_{\beta}^{2}` 是 minibatch 的统计数据。计算公式如下：
 
@@ -38,12 +38,12 @@ BatchNorm2D
 参数
 ::::::::::::
 
-    - **num_features** (int) - 指明输入 ``Tensor`` 的通道数量。
+    - **num_features** (int) - 指明输入  ``Tensor``  的通道数量。
     - **epsilon** (float，可选) - 为了数值稳定加在分母上的值。默认值：1e-05。
-    - **momentum** (float，可选) - 此值用于计算 ``moving_mean`` 和 ``moving_var``。默认值：0.9。更新公式如上所示。
+    - **momentum** (float，可选) - 此值用于计算  ``moving_mean``  和  ``moving_var`` 。默认值：0.9。更新公式如上所示。
     - **weight_attr** (ParamAttr|bool，可选) - 指定权重参数属性的对象。如果为 False，则表示每个通道的伸缩固定为 1，不可改变。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **bias_attr** (ParamAttr|bool，可选) - 指定偏置参数属性的对象。如果为 False，则表示每一个通道的偏移固定为 0，不可改变。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **data_format** (str，可选) - 指定输入数据格式，数据格式可以为 ``"NCHW"`` 或 ``"NHWC"``，其中 N 是批大小，C 是通道数，H 是特征高度，W 是特征宽度。默认值为 ``"NCHW"``。
+    - **data_format** (str，可选) - 指定输入数据格式，数据格式可以为  ``"NCHW"``  或  ``"NHWC"`` ，其中 N 是批大小，C 是通道数，H 是特征高度，W 是特征宽度。默认值为  ``"NCHW"`` 。
     - **use_global_stats** (bool|None，可选) – 指示是否使用全局均值和方差。若设置为 False，则使用一个 mini-batch 的统计数据。若设置为 True 时，将使用全局统计数据。若设置为 None，则会在测试阶段使用全局统计数据，在训练阶段使用一个 mini-batch 的统计数据。默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
@@ -55,7 +55,7 @@ BatchNorm2D
 形状
 ::::::::::::
 
-    - input：当 data_format 为 ``"NCHW"`` 时，形状为（批大小，通道数，高度，宽度）的 4-D Tensor。当 data_format 为 ``"NHWC"`` 时，形状为（批大小，高度，宽度，通道数）的 4-D Tensor。
+    - input：当 data_format 为  ``"NCHW"``  时，形状为（批大小，通道数，高度，宽度）的 4-D Tensor。当 data_format 为  ``"NHWC"``  时，形状为（批大小，高度，宽度，通道数）的 4-D Tensor。
     - output：和输入形状一样。
 
 .. note::
diff --git a/docs/api/paddle/nn/BatchNorm3D_cn.rst b/docs/api/paddle/nn/BatchNorm3D_cn.rst
index 44b1bbcdeea..1f7a674be5a 100644
--- a/docs/api/paddle/nn/BatchNorm3D_cn.rst
+++ b/docs/api/paddle/nn/BatchNorm3D_cn.rst
@@ -6,7 +6,7 @@ BatchNorm3D
 .. py:class:: paddle.nn.BatchNorm3D(num_features, momentum=0.9, epsilon=1e-05, weight_attr=None, bias_attr=None, data_format='NCDHW', use_global_stats=None, name=None)
 
 
-构建 ``BatchNorm3D`` 类的一个可调用对象，具体用法参照 ``代码示例``。可以处理 4D 的 Tensor，实现了批归一化层（Batch Normalization Layer）的功能，可用作卷积和全连接操作的批归一化函数，根据当前批次数据按通道计算的均值和方差进行归一化。更多详情请参考：`Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/pdf/1502.03167.pdf>`_
+构建  ``BatchNorm3D``  类的一个可调用对象，具体用法参照  ``代码示例`` 。可以处理 4D 的 Tensor，实现了批归一化层（Batch Normalization Layer）的功能，可用作卷积和全连接操作的批归一化函数，根据当前批次数据按通道计算的均值和方差进行归一化。更多详情请参考：`Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/pdf/1502.03167.pdf>`_
 
 当训练时 :math:`\mu_{\beta}` 和 :math:`\sigma_{\beta}^{2}` 是 minibatch 的统计数据。计算公式如下：
 
@@ -38,12 +38,12 @@ BatchNorm3D
 参数
 ::::::::::::
 
-    - **num_features** (int) - 指明输入 ``Tensor`` 的通道数量。
+    - **num_features** (int) - 指明输入  ``Tensor``  的通道数量。
     - **epsilon** (float，可选) - 为了数值稳定加在分母上的值。默认值：1e-05。
-    - **momentum** (float，可选) - 此值用于计算 ``moving_mean`` 和 ``moving_var``。默认值：0.9。更新公式如上所示。
+    - **momentum** (float，可选) - 此值用于计算  ``moving_mean``  和  ``moving_var`` 。默认值：0.9。更新公式如上所示。
     - **weight_attr** (ParamAttr|bool，可选) - 指定权重参数属性的对象。如果为 False，则表示每个通道的伸缩固定为 1，不可改变。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **bias_attr** (ParamAttr|bool，可选) - 指定偏置参数属性的对象。如果为 False，则表示每一个通道的偏移固定为 0，不可改变。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **data_format** (str，可选) - 指定输入数据格式，数据格式可以为 ``"NCDHW"`` 或 ``"NDHWC"``，其中 N 是批大小，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度。默认值为 ``"NCDHW"``。
+    - **data_format** (str，可选) - 指定输入数据格式，数据格式可以为  ``"NCDHW"``  或  ``"NDHWC"`` ，其中 N 是批大小，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度。默认值为  ``"NCDHW"`` 。
     - **use_global_stats** (bool|None，可选) – 指示是否使用全局均值和方差。若设置为 False，则使用一个 mini-batch 的统计数据。若设置为 True 时，将使用全局统计数据。若设置为 None，则会在测试阶段使用全局统计数据，在训练阶段使用一个 mini-batch 的统计数据。默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
@@ -55,7 +55,7 @@ BatchNorm3D
 形状
 ::::::::::::
 
-    - input：当 data_format 为 ``"NCDHW"`` 时，形状为（批大小，通道数，维度，高度，宽度）的 5-D Tensor。当 data_format 为 ``"NDHWC"`` 时，形状为（批大小，维度，高度，宽度，通道数）的 5-D Tensor。
+    - input：当 data_format 为  ``"NCDHW"``  时，形状为（批大小，通道数，维度，高度，宽度）的 5-D Tensor。当 data_format 为  ``"NDHWC"``  时，形状为（批大小，维度，高度，宽度，通道数）的 5-D Tensor。
     - output：和输入形状一样。
 
 .. note::
diff --git a/docs/api/paddle/nn/BatchNorm_cn.rst b/docs/api/paddle/nn/BatchNorm_cn.rst
index 0575779d4c5..b78da1d1d92 100644
--- a/docs/api/paddle/nn/BatchNorm_cn.rst
+++ b/docs/api/paddle/nn/BatchNorm_cn.rst
@@ -8,7 +8,7 @@ BatchNorm
 
 
 
-构建 ``BatchNorm`` 类的一个可调用对象，具体用法参照 ``代码示例``。其中实现了批归一化层（Batch Normalization Layer）的功能，可用作卷积和全连接操作的批归一化函数，根据当前批次数据按通道计算的均值和方差进行归一化。更多详情请参考：`Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/pdf/1502.03167.pdf>`_
+构建  ``BatchNorm``  类的一个可调用对象，具体用法参照  ``代码示例`` 。其中实现了批归一化层（Batch Normalization Layer）的功能，可用作卷积和全连接操作的批归一化函数，根据当前批次数据按通道计算的均值和方差进行归一化。更多详情请参考：`Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/pdf/1502.03167.pdf>`_
 
 当 use_global_stats = False 时，:math:`\mu_{\beta}` 和 :math:`\sigma_{\beta}^{2}` 是 minibatch 的统计数据。计算公式如下：
 
@@ -40,20 +40,20 @@ BatchNorm
 参数
 ::::::::::::
 
-    - **num_channels** (int) - 指明输入 ``Tensor`` 的通道数量。
+    - **num_channels** (int) - 指明输入  ``Tensor``  的通道数量。
     - **act** (str，可选) - 应用于输出上的激活函数，如 tanh、softmax、sigmoid，relu 等，支持列表请参考 :ref:`api_guide_activations`，默认值为 None。
     - **is_test** (bool，可选) - 指示是否在测试阶段，非训练阶段使用训练过程中统计到的全局均值和全局方差。默认值：False。
-    - **momentum** (float，可选) - 此值用于计算 ``moving_mean`` 和 ``moving_var``。默认值：0.9。更新公式如上所示。
+    - **momentum** (float，可选) - 此值用于计算  ``moving_mean``  和  ``moving_var`` 。默认值：0.9。更新公式如上所示。
     - **epsilon** (float，可选) - 为了数值稳定加在分母上的值。默认值：1e-05。
     - **param_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **bias_attr** (ParamAttr，可选) - 指定偏置参数属性的对象。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **dtype** (str|paddle.dtype|np.dtype，可选) - 指明输入 ``Tensor`` 的数据类型，可以为 float32 或 float64。默认值：float32。
-    - **data_layout** (str，可选) - 指定输入数据格式，数据格式可以为 ``"NCHW"`` 或 ``"NHWC"``，其中 N 是批大小，C 是通道数，H 是特征高度，W 是特征宽度。默认值为 ``"NCHW"``。
-    - **in_place** (bool，可选) - 指示 ``batch_norm`` 的输出是否可以复用输入内存。默认值：False。
-    - **moving_mean_name** (str，可选) - ``moving_mean`` 的名称，存储全局均值。如果将其设置为 None, ``batch_norm`` 将随机命名全局均值；否则，``batch_norm`` 将命名全局均值为 ``moving_mean_name``。默认值：None。
-    - **moving_variance_name** (string，可选) - ``moving_var`` 的名称，存储全局方差。如果将其设置为 None, ``batch_norm`` 将随机命名全局方差；否则，``batch_norm`` 将命名全局方差为 ``moving_variance_name``。默认值：None。
+    - **dtype** (str|paddle.dtype|np.dtype，可选) - 指明输入  ``Tensor``  的数据类型，可以为 float32 或 float64。默认值：float32。
+    - **data_layout** (str，可选) - 指定输入数据格式，数据格式可以为  ``"NCHW"``  或  ``"NHWC"`` ，其中 N 是批大小，C 是通道数，H 是特征高度，W 是特征宽度。默认值为  ``"NCHW"`` 。
+    - **in_place** (bool，可选) - 指示  ``batch_norm``  的输出是否可以复用输入内存。默认值：False。
+    - **moving_mean_name** (str，可选) -  ``moving_mean``  的名称，存储全局均值。如果将其设置为 None,  ``batch_norm``  将随机命名全局均值；否则， ``batch_norm``  将命名全局均值为  ``moving_mean_name`` 。默认值：None。
+    - **moving_variance_name** (string，可选) -  ``moving_var``  的名称，存储全局方差。如果将其设置为 None,  ``batch_norm``  将随机命名全局方差；否则， ``batch_norm``  将命名全局方差为  ``moving_variance_name`` 。默认值：None。
     - **do_model_average_for_mean_and_var** (bool，可选) - 指示是否为 mean 和 variance 做模型均值。默认值：False。
-    - **use_global_stats** (bool，可选) – 指示是否使用全局均值和方差。在预测或测试模式下，将 ``use_global_stats`` 设置为 true 或将 ``is_test`` 设置为 true，这两种行为是等效的。在训练模式中，当设置 ``use_global_stats`` 为 True 时，在训练期间也将使用全局均值和方差。默认值：False。
+    - **use_global_stats** (bool，可选) – 指示是否使用全局均值和方差。在预测或测试模式下，将  ``use_global_stats``  设置为 true 或将  ``is_test``  设置为 true，这两种行为是等效的。在训练模式中，当设置  ``use_global_stats``  为 True 时，在训练期间也将使用全局均值和方差。默认值：False。
     - **trainable_statistics** (bool，可选) - eval 模式下是否计算 mean 均值和 var 方差。eval 模式下，trainable_statistics 为 True 时，由该批数据计算均值和方差。默认值：False。
 
 返回
diff --git a/docs/api/paddle/nn/Bilinear_cn.rst b/docs/api/paddle/nn/Bilinear_cn.rst
index 92b84008f12..4684e49b05e 100644
--- a/docs/api/paddle/nn/Bilinear_cn.rst
+++ b/docs/api/paddle/nn/Bilinear_cn.rst
@@ -40,7 +40,7 @@ Bilinear
 
 返回
 :::::::::
-``Tensor``，一个形为 [batch_size, out_features] 的 2-D Tensor。
+ ``Tensor`` ，一个形为 [batch_size, out_features] 的 2-D Tensor。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/CTCLoss_cn.rst b/docs/api/paddle/nn/CTCLoss_cn.rst
index cfe38bb9d77..01ccf4abb83 100644
--- a/docs/api/paddle/nn/CTCLoss_cn.rst
+++ b/docs/api/paddle/nn/CTCLoss_cn.rst
@@ -11,19 +11,19 @@ CTCLoss
 参数
 :::::::::
     - **blank** (int，可选) - 空格标记的 ID 值，其取值范围为 [0, num_classes + 1)。数据类型支持 int32。默认值为 0。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：``'none'``, ``'mean'``, ``'sum'``。设置为 ``'mean'`` 时，对 loss 值除以 label_lengths，并返回所得商的均值；设置为 ``'sum'`` 时，返回 loss 值的总和；设置为 ``'none'`` 时，则直接返回输出的 loss 值。默认值为 ``'mean'``。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ,  ``'mean'`` ,  ``'sum'`` 。设置为  ``'mean'``  时，对 loss 值除以 label_lengths，并返回所得商的均值；设置为  ``'sum'``  时，返回 loss 值的总和；设置为  ``'none'``  时，则直接返回输出的 loss 值。默认值为  ``'mean'`` 。
 
 形状
 :::::::::
     - **log_probs** (Tensor) - 经过 padding 的概率序列，其 shape 必须是 [max_logit_length, batch_size, num_classes + 1]。其中 max_logit_length 是最长输入序列的长度。该输入不需要经过 softmax 操作，因为其内部对 input 做了 softmax 操作。数据类型仅支持 float32 或 float64。
     - **labels** (Tensor) - 经过 padding 的标签序列，其 shape 为 [batch_size, max_label_length]，其中 max_label_length 是最长的 label 序列的长度。数据类型支持 int32。
-    - **input_lengths** (Tensor) - 表示输入 ``log_probs`` 数据中每个序列的长度，shape 为 [batch_size]。数据类型支持 int64。
+    - **input_lengths** (Tensor) - 表示输入  ``log_probs``  数据中每个序列的长度，shape 为 [batch_size]。数据类型支持 int64。
     - **label_lengths** (Tensor) - 表示 label 中每个序列的长度，shape 为 [batch_size]。数据类型支持 int64。
     - **norm_by_times** (bool，可选) - 是否根据序列长度对梯度进行正则化。数据类型支持 bool。默认值为 False。
 
 返回
 :::::::::
-``Tensor``，输入 ``log_probs`` 和标签 ``labels`` 间的 `ctc loss`。如果 :attr:`reduction` 是 ``'none'``，则输出 loss 的维度为 [batch_size]。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出 Loss 的维度为 []。数据类型与输入的 ``log_probs`` 一致。
+ ``Tensor`` ，输入  ``log_probs``  和标签  ``labels``  间的 `ctc loss`。如果 :attr:`reduction` 是  ``'none'`` ，则输出 loss 的维度为 [batch_size]。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出 Loss 的维度为 []。数据类型与输入的  ``log_probs``  一致。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/ClipGradByGlobalNorm_cn.rst b/docs/api/paddle/nn/ClipGradByGlobalNorm_cn.rst
index 7c28434b5d7..ad22784a167 100644
--- a/docs/api/paddle/nn/ClipGradByGlobalNorm_cn.rst
+++ b/docs/api/paddle/nn/ClipGradByGlobalNorm_cn.rst
@@ -8,15 +8,15 @@ ClipGradByGlobalNorm
 
 
 
-将一个 Tensor 列表 :math:`t\_list` 中所有 Tensor 的 L2 范数之和，限定在 ``clip_norm`` 范围内。
+将一个 Tensor 列表 :math:`t\_list` 中所有 Tensor 的 L2 范数之和，限定在  ``clip_norm``  范围内。
 
-- 如果范数之和大于 ``clip_norm``，则所有 Tensor 会乘以一个系数进行压缩
+- 如果范数之和大于  ``clip_norm`` ，则所有 Tensor 会乘以一个系数进行压缩
 
-- 如果范数之和小于或等于 ``clip_norm``，则不会进行任何操作。
+- 如果范数之和小于或等于  ``clip_norm`` ，则不会进行任何操作。
 
-输入的 Tensor 不是从该类里传入，而是默认选择优化器中输入的所有参数的梯度。如果某个参数 ``ParamAttr`` 中的 ``need_clip`` 值被设置为 ``False``，则该参数的梯度不会被裁剪。
+输入的 Tensor 不是从该类里传入，而是默认选择优化器中输入的所有参数的梯度。如果某个参数  ``ParamAttr``  中的  ``need_clip``  值被设置为  ``False`` ，则该参数的梯度不会被裁剪。
 
-该类需要在初始化 ``optimizer`` 时进行设置后才能生效，可参看 ``optimizer`` 文档(例如：:ref:`cn_api_paddle_optimizer_SGD` )。
+该类需要在初始化  ``optimizer``  时进行设置后才能生效，可参看  ``optimizer``  文档(例如：:ref:`cn_api_paddle_optimizer_SGD` )。
 
 裁剪公式如下：
 
@@ -29,7 +29,7 @@ ClipGradByGlobalNorm
             \\global\_norm=\sqrt{\sum_{i=0}^{n-1}(l2norm(t\_list[i]))^2}\\
 
 .. note::
-   ``ClipGradByGlobalNorm`` 的 ``need_clip`` 方法从 2.0 开始废弃。请在 :ref:`paddle.ParamAttr <cn_api_paddle_ParamAttr>` 中使用 ``need_clip`` 来说明 ``clip`` 范围。
+    ``ClipGradByGlobalNorm``  的  ``need_clip``  方法从 2.0 开始废弃。请在 :ref:`paddle.ParamAttr <cn_api_paddle_ParamAttr>` 中使用  ``need_clip``  来说明  ``clip``  范围。
 
 参数
 ::::::::::::
diff --git a/docs/api/paddle/nn/ClipGradByNorm_cn.rst b/docs/api/paddle/nn/ClipGradByNorm_cn.rst
index f4f2dc132f8..7e59d99da22 100644
--- a/docs/api/paddle/nn/ClipGradByNorm_cn.rst
+++ b/docs/api/paddle/nn/ClipGradByNorm_cn.rst
@@ -8,15 +8,15 @@ ClipGradByNorm
 
 
 
-将输入的多维 Tensor :math:`X` 的 L2 范数限制在 ``clip_norm`` 范围之内。
+将输入的多维 Tensor :math:`X` 的 L2 范数限制在  ``clip_norm``  范围之内。
 
-- 如果 L2 范数大于 ``clip_norm``，则该 Tensor 会乘以一个系数进行压缩
+- 如果 L2 范数大于  ``clip_norm`` ，则该 Tensor 会乘以一个系数进行压缩
 
-- 如果 L2 范数小于或等于 ``clip_norm``，则不会进行任何操作。
+- 如果 L2 范数小于或等于  ``clip_norm`` ，则不会进行任何操作。
 
-输入的 Tensor 不是从该类里传入，而是默认选择优化器中输入的所有参数的梯度。如果某个参数 ``ParamAttr`` 中的 ``need_clip`` 值被设置为 ``False``，则该参数的梯度不会被裁剪。
+输入的 Tensor 不是从该类里传入，而是默认选择优化器中输入的所有参数的梯度。如果某个参数  ``ParamAttr``  中的  ``need_clip``  值被设置为  ``False`` ，则该参数的梯度不会被裁剪。
 
-该类需要在初始化 ``optimizer`` 时进行设置后才能生效，可参看 ``optimizer`` 文档(例如：:ref:`cn_api_paddle_optimizer_SGD` )。
+该类需要在初始化  ``optimizer``  时进行设置后才能生效，可参看  ``optimizer``  文档(例如：:ref:`cn_api_paddle_optimizer_SGD` )。
 
 裁剪公式如下：
 
@@ -37,7 +37,7 @@ ClipGradByNorm
   \\norm(X) = (\sum_{i=1}^{n}|x_i|^2)^{\frac{1}{2}}\\
 
 .. note::
-   ``ClipGradByNorm`` 的 ``need_clip`` 方法从 2.0 开始废弃。请在 :ref:`paddle.ParamAttr <cn_api_paddle_ParamAttr>` 中使用 ``need_clip`` 来说明 ``clip`` 范围。
+    ``ClipGradByNorm``  的  ``need_clip``  方法从 2.0 开始废弃。请在 :ref:`paddle.ParamAttr <cn_api_paddle_ParamAttr>` 中使用  ``need_clip``  来说明  ``clip``  范围。
 
 参数
 ::::::::::::
diff --git a/docs/api/paddle/nn/ClipGradByValue_cn.rst b/docs/api/paddle/nn/ClipGradByValue_cn.rst
index 9a194981c6e..b8e7936f98a 100644
--- a/docs/api/paddle/nn/ClipGradByValue_cn.rst
+++ b/docs/api/paddle/nn/ClipGradByValue_cn.rst
@@ -10,24 +10,24 @@ ClipGradByValue
 
 将输入的多维 Tensor :math:`X` 的值限制在 [min, max] 范围。
 
-输入的 Tensor 不是从该类里传入，而是默认选择优化器中输入的所有参数的梯度。如果某个参数 ``ParamAttr`` 中的 ``need_clip`` 值被设置为 ``False``，则该参数的梯度不会被裁剪。
+输入的 Tensor 不是从该类里传入，而是默认选择优化器中输入的所有参数的梯度。如果某个参数  ``ParamAttr``  中的  ``need_clip``  值被设置为  ``False`` ，则该参数的梯度不会被裁剪。
 
-该类需要在初始化 ``optimizer`` 时进行设置后才能生效，可参看 ``optimizer`` 文档(例如：:ref:`cn_api_paddle_optimizer_SGD` )。
+该类需要在初始化  ``optimizer``  时进行设置后才能生效，可参看  ``optimizer``  文档(例如：:ref:`cn_api_paddle_optimizer_SGD` )。
 
-给定一个 Tensor  ``t``，该操作将它的值压缩到 ``min`` 和 ``max`` 之间
+给定一个 Tensor   ``t`` ，该操作将它的值压缩到  ``min``  和  ``max``  之间
 
-- 任何小于 ``min`` 的值都被设置为 ``min``
+- 任何小于  ``min``  的值都被设置为  ``min`` 
 
-- 任何大于 ``max`` 的值都被设置为 ``max``
+- 任何大于  ``max``  的值都被设置为  ``max`` 
 
 .. note::
-   ``ClipGradByValue`` 的 ``need_clip`` 方法从 2.0 开始废弃。请在 :ref:`paddle.ParamAttr <cn_api_paddle_ParamAttr>` 中使用 ``need_clip`` 来说明 ``clip`` 范围。
+    ``ClipGradByValue``  的  ``need_clip``  方法从 2.0 开始废弃。请在 :ref:`paddle.ParamAttr <cn_api_paddle_ParamAttr>` 中使用  ``need_clip``  来说明  ``clip``  范围。
 
 参数
 ::::::::::::
 
  - **max** (float) - 要修剪的最大值。
- - **min** (float，可选) - 要修剪的最小值。如果用户没有设置，将被自动设置为 ``-max`` （此时 ``max`` 必须大于 :math:`0`）。
+ - **min** (float，可选) - 要修剪的最小值。如果用户没有设置，将被自动设置为  ``-max``  （此时  ``max``  必须大于 :math:`0`）。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/nn/Conv1DTranspose_cn.rst b/docs/api/paddle/nn/Conv1DTranspose_cn.rst
index 9cad9a7537b..5ae17027afd 100644
--- a/docs/api/paddle/nn/Conv1DTranspose_cn.rst
+++ b/docs/api/paddle/nn/Conv1DTranspose_cn.rst
@@ -21,9 +21,9 @@ Conv1DTranspose
     -  :math:`X`：输入，具有 NCL 或 NLC 格式的 3-D Tensor
     -  :math:`W`：卷积核，具有 NCL 格式的 3-D Tensor
     -  :math:`*`：卷积计算（注意：转置卷积本质上的计算还是卷积）
-    -  :math:`b`：偏置（bias），1-D Tensor，形状为 ``[M]``
+    -  :math:`b`：偏置（bias），1-D Tensor，形状为  ``[M]`` 
     -  :math:`σ`：激活函数
-    -  :math:`Out`：输出值，NCL 或 NLC 格式的 3-D Tensor，和 ``X`` 的形状可能不同
+    -  :math:`Out`：输出值，NCL 或 NLC 格式的 3-D Tensor，和  ``X``  的形状可能不同
 
 
 参数
@@ -32,8 +32,8 @@ Conv1DTranspose
   - **in_channels** (int) - 输入特征的通道数。
   - **out_channels** (int) - 卷积核的个数，和输出特征通道数相同。
   - **kernel_size** (int|list|tuple) - 卷积核大小。可以为单个整数或包含一个整数的元组或列表，表示卷积核的长度。
-  - **stride** (int|tuple，可选) - 步长大小。如果 ``stride`` 为元组或列表，则必须包含一个整型数，表示滑动步长。默认值：1。
-  - **padding** (int|list|tuple|str，可选) - 填充大小。可以是以下三种格式：（1）字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考下述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。（2）整数，表示在输入特征两侧各填充 ``padding`` 大小的 0。（3）包含一个整数的列表或元组，表示在输入特征两侧各填充 ``padding[0]`` 大小的 0。默认值：0。
+  - **stride** (int|tuple，可选) - 步长大小。如果  ``stride``  为元组或列表，则必须包含一个整型数，表示滑动步长。默认值：1。
+  - **padding** (int|list|tuple|str，可选) - 填充大小。可以是以下三种格式：（1）字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考下述  ``padding``  = "SAME"或   ``padding``  = "VALID" 时的计算公式。（2）整数，表示在输入特征两侧各填充  ``padding``  大小的 0。（3）包含一个整数的列表或元组，表示在输入特征两侧各填充  ``padding[0]``  大小的 0。默认值：0。
   - **output_padding** (int|list|tuple，可选) - 输出特征尾部一侧额外添加的大小。默认值：0。
   - **groups** (int，可选) - 一维卷积层的组数。根据 Alex Krizhevsky 的深度卷积神经网络（CNN）论文中的分组卷积：当 group=2，卷积核的前一半仅和输入特征图的前一半连接。卷积核的后一半仅和输入特征图的后一半连接。默认值：1。
   - **dilation** (int|tuple，可选) - 空洞大小。可以为单个整数或包含一个整数的元组或列表，表示卷积核中的空洞。默认值：1。
@@ -59,12 +59,12 @@ Conv1DTranspose
         L^\prime_{out} &= (L_{in} - 1) * stride - 2 * padding + dilation * (L_f - 1) + 1 \\
         L_{out} &\in [ L^\prime_{out}, L^\prime_{out} + stride ]
 
-    如果 ``padding`` = "SAME":
+    如果  ``padding``  = "SAME":
 
     .. math::
         L'_{out} = \frac{(L_{in} + stride - 1)}{stride}
 
-    如果 ``padding`` = "VALID":
+    如果  ``padding``  = "VALID":
 
     .. math::
         L'_{out} = (L_{in}-1)*stride + dilation*(L_f-1)+1
diff --git a/docs/api/paddle/nn/Conv1D_cn.rst b/docs/api/paddle/nn/Conv1D_cn.rst
index 25186313b9f..0daa035a119 100644
--- a/docs/api/paddle/nn/Conv1D_cn.rst
+++ b/docs/api/paddle/nn/Conv1D_cn.rst
@@ -22,9 +22,9 @@ Conv1D
     - :math:`X`：输入值，NCL 或 NLC 格式的 3-D Tensor
     - :math:`W`：卷积核值，MCL 格式的 3-D Tensor
     - :math:`*`：卷积操作
-    - :math:`b`：偏置值，1-D Tensor，形状为 ``[M]``
+    - :math:`b`：偏置值，1-D Tensor，形状为  ``[M]`` 
     - :math:`\sigma`：激活函数
-    - :math:`Out`：输出值，NCL 或 NLC 格式的 3-D Tensor，和 ``X`` 的形状可能不同
+    - :math:`Out`：输出值，NCL 或 NLC 格式的 3-D Tensor，和  ``X``  的形状可能不同
 
 
 参数
@@ -34,7 +34,7 @@ Conv1D
     - **out_channels** (int) - 由卷积操作产生的输出的通道数。
     - **kernel_size** (int|list|tuple) - 卷积核大小。可以为单个整数或包含一个整数的元组或列表，表示卷积核的长度。
     - **stride** (int|list|tuple，可选) - 步长大小。可以为单个整数或包含一个整数的元组或列表，表示卷积的步长。默认值：1。
-    - **padding** (int|list|tuple|str，可选) - 填充大小。可以是以下三种格式：（1）字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考下述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。（2）整数，表示在输入特征两侧各填充 ``padding`` 大小的 0。（3）包含一个整数的列表或元组，表示在输入特征两侧各填充 ``padding[0]`` 大小的 0。默认值：0。
+    - **padding** (int|list|tuple|str，可选) - 填充大小。可以是以下三种格式：（1）字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考下述  ``padding``  = "SAME"或   ``padding``  = "VALID" 时的计算公式。（2）整数，表示在输入特征两侧各填充  ``padding``  大小的 0。（3）包含一个整数的列表或元组，表示在输入特征两侧各填充  ``padding[0]``  大小的 0。默认值：0。
     - **dilation** (int|list|tuple，可选) - 空洞大小。可以为单个整数或包含一个整数的元组或列表，表示卷积核中的元素的空洞。默认值：1。
     - **groups** (int，可选) - 一维卷积层的组数。根据 Alex Krizhevsky 的深度卷积神经网络（CNN）论文中的成组卷积：当 group=n，输入和卷积核分别根据通道数量平均分为 n 组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第 n 组卷积核和第 n 组输入进行卷积计算。默认值：1。
 
@@ -42,18 +42,18 @@ Conv1D
 ::::::::::::
 
     - **bias** (bool，可选) - 是否要学习和添加这一层的偏置。如果设置为 False，则不会创建任何偏差，并且 :attr:'bias_attr' 将被忽略。默认值：True。
-    - **padding_mode** (str，可选) - 填充模式。包括 ``'zeros'``, ``'reflect'``, ``'replicate'`` 或者 ``'circular'``。默认值：``'zeros'`` 。
+    - **padding_mode** (str，可选) - 填充模式。包括  ``'zeros'`` ,  ``'reflect'`` ,  ``'replicate'``  或者  ``'circular'`` 。默认值： ``'zeros'``  。
     - **dtype** (str|Tensor.dtype，可选) - 指定权重、偏置的参数类型，默认值为 None。
     - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** (ParamAttr|bool，可选) - 指定偏置参数属性的对象。若 ``bias_attr`` 为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** (ParamAttr|bool，可选) - 指定偏置参数属性的对象。若  ``bias_attr``  为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCL"和"NLC"。N 是批尺寸，C 是通道数，L 是特征长度。默认值："NCL"。
 
 
 属性
 ::::::::::::
 
-    - **weight** - 本层的可学习参数，类型为 ``Parameter``
-    - **bias** - 本层的可学习偏置，类型为 ``Parameter``
+    - **weight** - 本层的可学习参数，类型为  ``Parameter`` 
+    - **bias** - 本层的可学习偏置，类型为  ``Parameter`` 
 
 形状
 ::::::::::::
@@ -67,12 +67,12 @@ Conv1D
     .. math::
         L_{out} = \frac{(L_{in} + 2 * padding - (dilation * (kernel\_size - 1) + 1))}{stride} + 1
 
-    如果 ``padding`` = "SAME":
+    如果  ``padding``  = "SAME":
 
     .. math::
         L_{out} = \frac{(L_{in} + stride - 1)}{stride}
 
-    如果 ``padding`` = "VALID":
+    如果  ``padding``  = "VALID":
 
     .. math::
         L_{out} = \frac{\left ( L_{in} -\left ( dilation*\left ( kernel\_size-1 \right )+1 \right ) \right )}{stride}+1
diff --git a/docs/api/paddle/nn/Conv2DTranspose_cn.rst b/docs/api/paddle/nn/Conv2DTranspose_cn.rst
index 47042f27a66..01b60bd7a05 100644
--- a/docs/api/paddle/nn/Conv2DTranspose_cn.rst
+++ b/docs/api/paddle/nn/Conv2DTranspose_cn.rst
@@ -20,9 +20,9 @@ Conv2DTranspose
     -  :math:`X`：输入，具有 NCHW 或 NHWC 格式的 4-D Tensor
     -  :math:`W`：卷积核，具有 NCHW 格式的 4-D Tensor
     -  :math:`*`：卷积计算（注意：转置卷积本质上的计算还是卷积）
-    -  :math:`b`：偏置（bias），1-D Tensor，形状为 ``[M]``
+    -  :math:`b`：偏置（bias），1-D Tensor，形状为  ``[M]`` 
     -  :math:`σ`：激活函数
-    -  :math:`Out`：输出值，NCHW 或 NHWC 格式的 4-D Tensor，和 ``X`` 的形状可能不同
+    -  :math:`Out`：输出值，NCHW 或 NHWC 格式的 4-D Tensor，和  ``X``  的形状可能不同
 
 
 注意：
@@ -31,7 +31,7 @@ Conv2DTranspose
 
 由于转置卷积可以当成是卷积的反向计算，而根据卷积的输入输出计算公式来说，不同大小的输入特征层可能对应着相同大小的输出特征层，所以对应到转置卷积来说，固定大小的输入特征层对应的输出特征层大小并不唯一。
 
-如果指定了 output_size， ``conv2d_transpose`` 可以自动计算卷积核的大小。
+如果指定了 output_size，  ``conv2d_transpose``  可以自动计算卷积核的大小。
 
 参数
 ::::::::::::
@@ -39,8 +39,8 @@ Conv2DTranspose
   - **in_channels** (int) - 输入图像的通道数。
   - **out_channels** (int) - 卷积核的个数，和输出特征图通道数相同。
   - **kernel_size** (int|list|tuple) - 卷积核大小。可以为单个整数或包含两个整数的元组或列表，分别表示卷积核的高和宽。如果为单个整数，表示卷积核的高和宽都等于该整数。
-  - **stride** (int|list|tuple，可选) - 步长大小。如果 ``stride`` 为元组或列表，则必须包含两个整型数，分别表示垂直和水平滑动步长。否则，表示垂直和水平滑动步长均为 ``stride``。默认值：1。
-  - **padding** (int|str|tuple|list，可选) - 填充大小。如果 ``padding`` 为元组或列表，则必须包含两个整型数，分别表示竖直和水平边界填充大小。否则，表示竖直和水平边界填充大小均为 ``padding``。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考下方形状 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。默认值：0。
+  - **stride** (int|list|tuple，可选) - 步长大小。如果  ``stride``  为元组或列表，则必须包含两个整型数，分别表示垂直和水平滑动步长。否则，表示垂直和水平滑动步长均为  ``stride`` 。默认值：1。
+  - **padding** (int|str|tuple|list，可选) - 填充大小。如果  ``padding``  为元组或列表，则必须包含两个整型数，分别表示竖直和水平边界填充大小。否则，表示竖直和水平边界填充大小均为  ``padding`` 。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考下方形状  ``padding``  = "SAME"或   ``padding``  = "VALID" 时的计算公式。默认值：0。
   - **output_padding** (int|list|tuple，可选) - 输出形状上一侧额外添加的大小。默认值：0。
   - **groups** (int，可选) - 二维卷积层的组数。根据 Alex Krizhevsky 的深度卷积神经网络（CNN）论文中的分组卷积：当 group=2，卷积核的前一半仅和输入特征图的前一半连接。卷积核的后一半仅和输入特征图的后一半连接。默认值：1。
   - **dilation** (int|list|tuple，可选) - 空洞大小。可以为单个整数或包含两个整数的元组或列表，分别表示卷积核中的元素沿着高和宽的空洞。如果为单个整数，表示高和宽的空洞都等于该整数。默认值：1。
@@ -69,13 +69,13 @@ Conv2DTranspose
         H_{out} &\in [ H^\prime_{out}, H^\prime_{out} + strides[0] ) \\
         W_{out} &\in [ W^\prime_{out}, W^\prime_{out} + strides[1] ) \\
 
-    如果 ``padding`` = "SAME":
+    如果  ``padding``  = "SAME":
 
     .. math::
         & H'_{out} = \frac{(H_{in} + stride[0] - 1)}{stride[0]}\\
         & W'_{out} = \frac{(W_{in} + stride[1] - 1)}{stride[1]}\\
 
-    如果 ``padding`` = "VALID":
+    如果  ``padding``  = "VALID":
 
     .. math::
         & H'_{out} = (H_{in}-1)*strides[0] + dilations[0]*(kernel\_size[0]-1)+1\\
diff --git a/docs/api/paddle/nn/Conv2D_cn.rst b/docs/api/paddle/nn/Conv2D_cn.rst
index 54177cce65d..5804b03c895 100644
--- a/docs/api/paddle/nn/Conv2D_cn.rst
+++ b/docs/api/paddle/nn/Conv2D_cn.rst
@@ -22,9 +22,9 @@ Conv2D
     - :math:`X`：输入值，NCHW 或 NHWC 格式的 4-D Tensor
     - :math:`W`：卷积核值，MCHW 格式的 4-D Tensor
     - :math:`*`：卷积操作
-    - :math:`b`：偏置值，1-D Tensor，形状为 ``[M]``
+    - :math:`b`：偏置值，1-D Tensor，形状为  ``[M]`` 
     - :math:`\sigma`：激活函数
-    - :math:`Out`：输出值，NCHW 或 NHWC 格式的 4-D Tensor，和 ``X`` 的形状可能不同
+    - :math:`Out`：输出值，NCHW 或 NHWC 格式的 4-D Tensor，和  ``X``  的形状可能不同
 
 
 参数
@@ -34,7 +34,7 @@ Conv2D
     - **out_channels** (int) - 由卷积操作产生的输出的通道数。
     - **kernel_size** (int|list|tuple) - 卷积核大小。可以为单个整数或包含两个整数的元组或列表，分别表示卷积核的高和宽。如果为单个整数，表示卷积核的高和宽都等于该整数。
     - **stride** (int|list|tuple，可选) - 步长大小。可以为单个整数或包含两个整数的元组或列表，分别表示卷积沿着高和宽的步长。如果为单个整数，表示沿着高和宽的步长都等于该整数。默认值：1。
-    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 4 个二元组：当 ``data_format`` 为"NCHW"时为 [[0,0], [0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为"NHWC"时为[[0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含 4 个整数值：[padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含 2 个整数值：[padding_height, padding_width]，此时 padding_height_top = padding_height_bottom = padding_height， padding_width_left = padding_width_right = padding_width。若为一个整数，padding_height = padding_width = padding。默认值：0。
+    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述  ``padding``  = "SAME"或   ``padding``  = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 4 个二元组：当  ``data_format``  为"NCHW"时为 [[0,0], [0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当  ``data_format``  为"NHWC"时为[[0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含 4 个整数值：[padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含 2 个整数值：[padding_height, padding_width]，此时 padding_height_top = padding_height_bottom = padding_height， padding_width_left = padding_width_right = padding_width。若为一个整数，padding_height = padding_width = padding。默认值：0。
     - **dilation** (int|list|tuple，可选) - 空洞大小。可以为单个整数或包含两个整数的元组或列表，分别表示卷积核中的元素沿着高和宽的空洞。如果为单个整数，表示高和宽的空洞都等于该整数。默认值：1。
     - **groups** (int，可选) - 二维卷积层的组数。根据 Alex Krizhevsky 的深度卷积神经网络（CNN）论文中的成组卷积：当 group=n，输入和卷积核分别根据通道数量平均分为 n 组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第 n 组卷积核和第 n 组输入进行卷积计算。默认值：1。
 
@@ -42,11 +42,11 @@ Conv2D
 ::::::::::::
 
     - **bias** (bool，可选) - 是否要学习和添加这一层的偏置。如果设置为 False，则不会创建任何偏差，并且 :attr:'bias_attr' 将被忽略。默认值：True。
-    - **padding_mode** (str，可选) - 填充模式。包括 ``'zeros'``, ``'reflect'``, ``'replicate'`` 或者 ``'circular'``。默认值：``'zeros'`` 。
+    - **padding_mode** (str，可选) - 填充模式。包括  ``'zeros'`` ,  ``'reflect'`` ,  ``'replicate'``  或者  ``'circular'`` 。默认值： ``'zeros'``  。
     - **device** (str|Place|None，可选) - 指定权重参数放置的设备。默认值为 None。
     - **dtype** (str|Tensor.dtype，可选) - 指定权重、偏置的参数类型，默认值为 None。
     - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** (ParamAttr|bool，可选) - 指定偏置参数属性的对象。若 ``bias_attr`` 为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** (ParamAttr|bool，可选) - 指定偏置参数属性的对象。若  ``bias_attr``  为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCHW"和"NHWC"。N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度。默认值："NCHW"。
 
 
@@ -55,11 +55,11 @@ Conv2D
 
 weight
 '''''''''
-本层的可学习参数，类型为 ``Parameter``
+本层的可学习参数，类型为  ``Parameter`` 
 
 bias
 '''''''''
-本层的可学习偏置，类型为 ``Parameter``
+本层的可学习偏置，类型为  ``Parameter`` 
 
 形状
 ::::::::::::
@@ -78,7 +78,7 @@ bias
 
         W_{out} = \frac{(W_{in} + 2 * paddings[1] - (dilations[1] * (kernel\_size[1] - 1) + 1))}{strides[1]} + 1
 
-    如果 ``padding`` = "SAME":
+    如果  ``padding``  = "SAME":
 
     .. math::
         H_{out} = \frac{(H_{in} + stride[0] - 1)}{stride[0]}
@@ -86,7 +86,7 @@ bias
     .. math::
         W_{out} = \frac{(W_{in} + stride[1] - 1)}{stride[1]}
 
-    如果 ``padding`` = "VALID":
+    如果  ``padding``  = "VALID":
 
     .. math::
         H_{out} = \frac{\left ( H_{in} -\left ( dilation[0]*\left ( kernel\_size[0]-1 \right )+1 \right ) \right )}{stride[0]}+1
diff --git a/docs/api/paddle/nn/Conv3DTranspose_cn.rst b/docs/api/paddle/nn/Conv3DTranspose_cn.rst
index 715afd8d38e..2a041fe8e62 100755
--- a/docs/api/paddle/nn/Conv3DTranspose_cn.rst
+++ b/docs/api/paddle/nn/Conv3DTranspose_cn.rst
@@ -22,9 +22,9 @@ Conv3DTranspose
     -  :math:`X`：输入，具有 NCDHW 或 NDHWC 格式的 5-D Tensor
     -  :math:`W`：卷积核，具有 NCDHW 格式的 5-D Tensor
     -  :math:`*`：卷积操作（**注意**：转置卷积本质上的计算还是卷积）
-    -  :math:`b`：偏置（bias），1-D Tensor，形状为 ``[M]``
+    -  :math:`b`：偏置（bias），1-D Tensor，形状为  ``[M]`` 
     -  :math:`σ`：激活函数
-    -  :math:`Out`：输出值，NCDHW 或 NDHWC 格式的 5-D Tensor，和 ``X`` 的形状可能不同
+    -  :math:`Out`：输出值，NCDHW 或 NDHWC 格式的 5-D Tensor，和  ``X``  的形状可能不同
 
 
 .. note::
@@ -40,8 +40,8 @@ Conv3DTranspose
   - **in_channels** (int) - 输入图像的通道数。
   - **out_channels** (int) - 卷积核的个数，和输出特征图个数相同。
   - **kernel_size** (int|list|tuple) - 卷积核大小。可以为单个整数或包含三个整数的元组或列表，分别表示卷积核的深度，高和宽。如果为单个整数，表示卷积核的深度，高和宽都等于该整数。output_size 和 kernel_size 不能同时为 None。
-  - **stride** (int|tuple，可选) - 步长大小。如果 ``stride`` 为元组或列表，则必须包含三个整型数，分别表示深度，垂直和水平滑动步长。否则，表示深度，垂直和水平滑动步长均为 ``stride``。默认值为 1。
-  - **padding** (int|tuple，可选) - 填充大小。如果 ``padding`` 为元组或列表，则必须包含三个整型数，分别表示深度，竖直和水平边界填充大小。否则，表示深度，竖直和水平边界填充大小均为 ``padding``。如果它是一个字符串，可以是 "VALID" 或者 "SAME" ，表示填充算法，计算细节可参考下方形状 ``padding`` = "SAME" 或  ``padding`` = "VALID" 时的计算公式。默认值为 0。
+  - **stride** (int|tuple，可选) - 步长大小。如果  ``stride``  为元组或列表，则必须包含三个整型数，分别表示深度，垂直和水平滑动步长。否则，表示深度，垂直和水平滑动步长均为  ``stride`` 。默认值为 1。
+  - **padding** (int|tuple，可选) - 填充大小。如果  ``padding``  为元组或列表，则必须包含三个整型数，分别表示深度，竖直和水平边界填充大小。否则，表示深度，竖直和水平边界填充大小均为  ``padding`` 。如果它是一个字符串，可以是 "VALID" 或者 "SAME" ，表示填充算法，计算细节可参考下方形状  ``padding``  = "SAME" 或   ``padding``  = "VALID" 时的计算公式。默认值为 0。
   - **output_padding** (int|list|tuple，可选) - 输出形状上一侧额外添加的大小。默认值为 0。
   - **groups** (int，可选) - 二维卷积层的组数。根据 `Alex Krizhevsky 的 Deep CNN 论文 <https://papers.nips.cc/paper/2012/file/c399862d3b9d6b76c8436e924a68c45b-Paper.pdf>`_ 中的分组卷积：当 groups = 2，卷积核的前一半仅和输入特征图的前一半连接。卷积核的后一半仅和输入特征图的后一半连接。默认值为 1。
   - **dilation** (int|tuple，可选) - 空洞大小。可以为单个整数或包含三个整数的元组或列表，分别表示卷积核中的元素沿着深度，高和宽的空洞。如果为单个整数，表示深度，高和宽的空洞都等于该整数。默认值为 1。
@@ -71,14 +71,14 @@ Conv3DTranspose
         H_{out} &\in [ H^\prime_{out}, H^\prime_{out} + strides[1] ] \\
         W_{out} &\in [ W^\prime_{out}, W^\prime_{out} + strides[2] ] \\
 
-    如果 ``padding`` = "SAME":
+    如果  ``padding``  = "SAME":
 
     .. math::
         & D'_{out} = \frac{(D_{in} + stride[0] - 1)}{stride[0]}\\
         & H'_{out} = \frac{(H_{in} + stride[1] - 1)}{stride[1]}\\
         & W'_{out} = \frac{(W_{in} + stride[2] - 1)}{stride[2]}\\
 
-    如果 ``padding`` = "VALID":
+    如果  ``padding``  = "VALID":
 
     .. math::
         & D'_{out} = (D_{in}-1)*strides[0] + dilations[0]*(kernel\_size[0]-1)+1\\
diff --git a/docs/api/paddle/nn/Conv3D_cn.rst b/docs/api/paddle/nn/Conv3D_cn.rst
index 3c7807efc5c..d4b3c075dbb 100644
--- a/docs/api/paddle/nn/Conv3D_cn.rst
+++ b/docs/api/paddle/nn/Conv3D_cn.rst
@@ -22,9 +22,9 @@ Conv3D
     - :math:`X`：输入值，NCDHW 或 NDHWC 格式的 5-D Tensor
     - :math:`W`：卷积核值，MCDHW 格式的 5-D Tensor
     - :math:`*`：卷积操作
-    - :math:`b`：偏置值，1-D Tensor，形为 ``[M]``
+    - :math:`b`：偏置值，1-D Tensor，形为  ``[M]`` 
     - :math:`\sigma`：激活函数
-    - :math:`Out`：输出值，NCDHW 或 NDHWC 格式的 5-D Tensor，和 ``X`` 的形状可能不同
+    - :math:`Out`：输出值，NCDHW 或 NDHWC 格式的 5-D Tensor，和  ``X``  的形状可能不同
 
 参数
 ::::::::::::
@@ -33,7 +33,7 @@ Conv3D
     - **out_channels** (int) - 由卷积操作产生的输出的通道数。
     - **kernel_size** (int|list|tuple) - 卷积核大小。可以为单个整数或包含三个整数的元组或列表，分别表示卷积核的深度，高和宽。如果为单个整数，表示卷积核的深度，高和宽都等于该整数。
     - **stride** (int|list|tuple，可选) - 步长大小。可以为单个整数或包含三个整数的元组或列表，分别表示卷积沿着深度，高和宽的步长。如果为单个整数，表示沿着高和宽的步长都等于该整数。默认值：1。
-    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 5 个二元组：当 ``data_format`` 为"NCDHW"时为 [[0,0], [0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为"NDHWC"时为[[0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含 6 个整数值：[padding_depth_front, padding_depth_back, padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含 3 个整数值：[padding_depth, padding_height, padding_width]，此时 padding_depth_front = padding_depth_back = padding_depth, padding_height_top = padding_height_bottom = padding_height, padding_width_left = padding_width_right = padding_width。若为一个整数，padding_depth = padding_height = padding_width = padding。默认值：0。
+    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述  ``padding``  = "SAME"或   ``padding``  = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 5 个二元组：当  ``data_format``  为"NCDHW"时为 [[0,0], [0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当  ``data_format``  为"NDHWC"时为[[0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含 6 个整数值：[padding_depth_front, padding_depth_back, padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含 3 个整数值：[padding_depth, padding_height, padding_width]，此时 padding_depth_front = padding_depth_back = padding_depth, padding_height_top = padding_height_bottom = padding_height, padding_width_left = padding_width_right = padding_width。若为一个整数，padding_depth = padding_height = padding_width = padding。默认值：0。
     - **dilation** (int|list|tuple，可选) - 空洞大小。可以为单个整数或包含三个整数的元组或列表，分别表示卷积核中的元素沿着深度，高和宽的空洞。如果为单个整数，表示深度，高和宽的空洞都等于该整数。默认值：1。
     - **groups** (int，可选) - 三维卷积层的组数。根据 Alex Krizhevsky 的深度卷积神经网络（CNN）论文中的成组卷积：当 group=n，输入和卷积核分别根据通道数量平均分为 n 组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第 n 组卷积核和第 n 组输入进行卷积计算。默认值：1。
 
@@ -41,11 +41,11 @@ Conv3D
 ::::::::::::
 
     - **bias** (bool，可选) - 是否要学习和添加这一层的偏置。如果设置为 False，则不会创建任何偏差，并且 :attr:'bias_attr' 将被忽略。默认值：True。
-    - **padding_mode** (str，可选)：填充模式。包括 ``'zeros'``, ``'reflect'``, ``'replicate'`` 或者 ``'circular'``。默认值：``'zeros'`` 。
+    - **padding_mode** (str，可选)：填充模式。包括  ``'zeros'`` ,  ``'reflect'`` ,  ``'replicate'``  或者  ``'circular'`` 。默认值： ``'zeros'``  。
     - **device** (str|Place|None，可选) - 指定权重参数放置的设备。默认值为 None。
     - **dtype** (str|Tensor.dtype，可选) - 指定权重、偏置的参数类型，默认值为 None。
     - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若 ``bias_attr`` 为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若  ``bias_attr``  为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度。默认值："NCDHW"。
 
 
@@ -54,11 +54,11 @@ Conv3D
 
 weight
 '''''''''
-本层的可学习参数，类型为 ``Parameter``
+本层的可学习参数，类型为  ``Parameter`` 
 
 bias
 '''''''''
-本层的可学习偏置，类型为 ``Parameter``
+本层的可学习偏置，类型为  ``Parameter`` 
 
 形状
 ::::::::::::
@@ -78,7 +78,7 @@ bias
 
         W_{out} &= \frac{\left ( W_{in} + padding\_width\_left + padding\_width\_right -\left ( dilation[2]*\left ( kernel\_size[2]-1 \right )+1 \right ) \right )}{stride[2]}+1
 
-    如果 ``padding`` = "SAME":
+    如果  ``padding``  = "SAME":
 
     .. math::
         D_{out} = \frac{(D_{in} + stride[0] - 1)}{stride[0]}
@@ -87,7 +87,7 @@ bias
 
         W_{out} = \frac{(W_{in} + stride[2] - 1)}{stride[2]}
 
-    如果 ``padding`` = "VALID":
+    如果  ``padding``  = "VALID":
 
     .. math::
         D_{out} = \frac{\left ( D_{in} -\left ( dilation[0]*\left ( kernel\_size[0]-1 \right )+1 \right ) \right )}{stride[0]}+1
diff --git a/docs/api/paddle/nn/CosineEmbeddingLoss_cn.rst b/docs/api/paddle/nn/CosineEmbeddingLoss_cn.rst
index e9d3eb4e063..37dd697cc6a 100644
--- a/docs/api/paddle/nn/CosineEmbeddingLoss_cn.rst
+++ b/docs/api/paddle/nn/CosineEmbeddingLoss_cn.rst
@@ -25,7 +25,7 @@ CosineEmbeddingLoss
 参数
 :::::::::
     - **margin** (float，可选): - 可以设置的范围为[-1, 1]，建议设置的范围为[0, 0.5]。其默认为 `0`。
-    - **reduction** (string，可选): - 指定应用于输出结果的计算方式，可选值有：``'none'``, ``'mean'``, ``'sum'``。默认为 ``'mean'``，计算 `CosineEmbeddingLoss` 的均值；设置为 ``'sum'`` 时，计算 `CosineEmbeddingLoss` 的总和；设置为 ``'none'`` 时，则返回 `CosineEmbeddingLoss`。数据类型为 string。
+    - **reduction** (string，可选): - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ,  ``'mean'`` ,  ``'sum'`` 。默认为  ``'mean'`` ，计算 `CosineEmbeddingLoss` 的均值；设置为  ``'sum'``  时，计算 `CosineEmbeddingLoss` 的总和；设置为  ``'none'``  时，则返回 `CosineEmbeddingLoss`。数据类型为 string。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
@@ -33,7 +33,7 @@ CosineEmbeddingLoss
     - **input1** (Tensor): - 输入的 Tensor，维度是[N, M]，其中 N 是 batch size，可为 0，M 是数组长度。数据类型为：float32、float64。
     - **input2** (Tensor): - 输入的 Tensor，维度是[N, M]，其中 N 是 batch size，可为 0，M 是数组长度。数据类型为：float32、float64。
     - **label** (Tensor): - 标签，维度是[N]，N 是数组长度，数据类型为：float32、float64、int32、int64。
-    - **output** (Tensor): - 输入 ``input1`` 、 ``input2`` 和标签 ``label`` 间的 `CosineEmbeddingLoss` 损失。如果 `reduction` 是 ``'none'``，则输出 Loss 的维度为 [N]，与输入 ``input1`` 和 ``input2`` 相同。如果 `reduction` 是 ``'mean'`` 或 ``'sum'``，则输出 Loss 的维度为 []。
+    - **output** (Tensor): - 输入  ``input1``  、  ``input2``  和标签  ``label``  间的 `CosineEmbeddingLoss` 损失。如果 `reduction` 是  ``'none'`` ，则输出 Loss 的维度为 [N]，与输入  ``input1``  和  ``input2``  相同。如果 `reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出 Loss 的维度为 []。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/CrossEntropyLoss_cn.rst b/docs/api/paddle/nn/CrossEntropyLoss_cn.rst
index 15696a50798..c30cfc0b9c9 100644
--- a/docs/api/paddle/nn/CrossEntropyLoss_cn.rst
+++ b/docs/api/paddle/nn/CrossEntropyLoss_cn.rst
@@ -56,9 +56,9 @@ CrossEntropyLoss
 
     1. Weight
 
-        如果 ``weight`` 参数为 ``None`` , 直接进行下一步.
+        如果  ``weight``  参数为  ``None``  , 直接进行下一步.
 
-        如果 ``weight`` 参数不为 ``None`` , 每个样本的交叉熵按权重加权
+        如果  ``weight``  参数不为  ``None``  , 每个样本的交叉熵按权重加权
         根据 soft_label = False 或 True 如下：
 
         1.1. Hard labels (soft_label = False)
@@ -74,20 +74,20 @@ CrossEntropyLoss
 
     2. reduction
 
-        2.1 如果 ``reduction`` 参数为 ``none``
+        2.1 如果  ``reduction``  参数为  ``none`` 
 
         直接返回之前的结果
 
-        2.2 如果 ``reduction`` 参数为 ``sum``
+        2.2 如果  ``reduction``  参数为  ``sum`` 
 
         返回之前结果的和
 
         .. math::
            \\loss=\sum_{j}loss_j
 
-        2.3 如果 ``reduction`` 参数为 ``mean`` , 则按照 ``weight`` 参数进行如下处理。
+        2.3 如果  ``reduction``  参数为  ``mean``  , 则按照  ``weight``  参数进行如下处理。
 
-        2.3.1. 如果  ``weight``  参数为 ``None``
+        2.3.1. 如果   ``weight``   参数为  ``None`` 
 
         返回之前结果的平均值
 
@@ -96,7 +96,7 @@ CrossEntropyLoss
 
         其中，N 是样本数，C 是类别数。
 
-        2.3.2. 如果 ``weight`` 参数不为 ``None``，则返回之前结果的加权平均值
+        2.3.2. 如果  ``weight``  参数不为  ``None`` ，则返回之前结果的加权平均值
 
         1. Hard labels (soft_label = False)
 
@@ -116,7 +116,7 @@ CrossEntropyLoss
     - **reduction** (str，可选) - 指定应用于输出结果的计算方式，数据类型为 string，可选值有：`none`, `mean`, `sum`。默认为 `mean`，计算 `mini-batch` loss 均值。设置为 `sum` 时，计算 `mini-batch` loss 的总和。设置为 `none` 时，则返回 loss Tensor。
     - **soft_label** (bool，可选) – 指明 label 是否为软标签。默认为 False，表示 label 为硬标签；若 soft_label=True 则表示软标签。
     - **label_smoothing** （float，可选）- 指定计算损失时的标签平滑度，它应该在 :math:`[0.0，1.0]` 范围内。其中 0.0 表示无平滑。使得平滑后的标签变成原始真实标签和均匀分布的混合，默认值： 0.0。
-    - **axis** (int，可选) - 进行 softmax 计算的维度索引。它应该在 :math:`[-1，dim-1]` 范围内，而 ``dim`` 是输入 logits 的维度。默认值：-1。
+    - **axis** (int，可选) - 进行 softmax 计算的维度索引。它应该在 :math:`[-1，dim-1]` 范围内，而  ``dim``  是输入 logits 的维度。默认值：-1。
     - **use_softmax** (bool，可选) - 指定是否对 input 进行 softmax 归一化。默认值：True。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 形状
diff --git a/docs/api/paddle/nn/Embedding_cn.rst b/docs/api/paddle/nn/Embedding_cn.rst
index 0d446f7dd5c..ae27ac0e7fa 100644
--- a/docs/api/paddle/nn/Embedding_cn.rst
+++ b/docs/api/paddle/nn/Embedding_cn.rst
@@ -5,12 +5,12 @@ Embedding
 
 .. py:class:: paddle.nn.Embedding(num_embeddings, embedding_dim, padding_idx=None, max_norm=None, norm_type=2.0, *, scale_grad_by_freq=False, sparse=False, _weight=None, _freeze=False, device=None, dtype=None, weight_attr=None, name=None)
 
-嵌入层(Embedding Layer)，用于构建 ``Embedding`` 的一个可调用对象，具体用法参照 ``代码示例``。其根据 ``x`` 中的 id 信息从 embedding 矩阵中查询对应 embedding 信息，并会根据输入的 size (num_embeddings, embedding_dim)和 weight_attr 自动构造一个二维 embedding 矩阵。
+嵌入层(Embedding Layer)，用于构建  ``Embedding``  的一个可调用对象，具体用法参照  ``代码示例`` 。其根据  ``x``  中的 id 信息从 embedding 矩阵中查询对应 embedding 信息，并会根据输入的 size (num_embeddings, embedding_dim)和 weight_attr 自动构造一个二维 embedding 矩阵。
 
 输出的 Tensor 的 shape 是在输入 Tensor shape 的最后一维后面添加了 embedding_dim 的维度。
 
 .. note::
-   input 中的 id 必须满足 ``0 <= id < size[0]``，否则程序会抛异常退出。
+   input 中的 id 必须满足  ``0 <= id < size[0]`` ，否则程序会抛异常退出。
 
 .. code-block:: text
 
@@ -35,11 +35,11 @@ Embedding
 参数
 ::::::::::::
 
-    - **num_embeddings** (int) - 嵌入字典的大小，input 中的 id 必须满足 ``0 <= id < num_embeddings`` 。
+    - **num_embeddings** (int) - 嵌入字典的大小，input 中的 id 必须满足  ``0 <= id < num_embeddings``  。
     - **embedding_dim** (int) - 每个嵌入向量的维度。
-    - **padding_idx** (int|long|None，可选) - padding_idx 的配置区间为 ``[-weight.shape[0], weight.shape[0])``，如果配置了 padding_idx，那么在训练过程中遇到此 id 时，其参数及对应的梯度将会以 0 进行填充。
-    - **max_norm** (float，可选) - 若声明，会将范数大于此值的词嵌入向量重新归一化，使其范数等于此值。在动态图模式下会对 ``weight`` 产生 inplace 修改。默认值为 None。
-    - **norm_type** (float) - 应用 ``max_norm`` 时所计算的 p 阶范数的 p 值。默认值 2.0。
+    - **padding_idx** (int|long|None，可选) - padding_idx 的配置区间为  ``[-weight.shape[0], weight.shape[0])`` ，如果配置了 padding_idx，那么在训练过程中遇到此 id 时，其参数及对应的梯度将会以 0 进行填充。
+    - **max_norm** (float，可选) - 若声明，会将范数大于此值的词嵌入向量重新归一化，使其范数等于此值。在动态图模式下会对  ``weight``  产生 inplace 修改。默认值为 None。
+    - **norm_type** (float) - 应用  ``max_norm``  时所计算的 p 阶范数的 p 值。默认值 2.0。
 
 关键字参数
 ::::::::::::
@@ -60,7 +60,7 @@ Embedding
 weight
 '''''''''
 
-本层的可学习参数，类型为 ``Parameter`` 。
+本层的可学习参数，类型为  ``Parameter``  。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/nn/Flatten_cn.rst b/docs/api/paddle/nn/Flatten_cn.rst
index af961c40c65..3761e44528f 100644
--- a/docs/api/paddle/nn/Flatten_cn.rst
+++ b/docs/api/paddle/nn/Flatten_cn.rst
@@ -7,7 +7,7 @@ Flatten
 
 
 
-构造一个 ``Flatten`` 类的可调用对象。更多信息请参见代码示例。它实现将一个连续维度的 Tensor 展平成一维 Tensor。
+构造一个  ``Flatten``  类的可调用对象。更多信息请参见代码示例。它实现将一个连续维度的 Tensor 展平成一维 Tensor。
 
 
 参数
diff --git a/docs/api/paddle/nn/Fold_cn.rst b/docs/api/paddle/nn/Fold_cn.rst
index b52ad8a09f8..771a9b58c7c 100644
--- a/docs/api/paddle/nn/Fold_cn.rst
+++ b/docs/api/paddle/nn/Fold_cn.rst
@@ -22,9 +22,9 @@ Fold
 
 参数
 :::::::::
-    - **output_sizes**  (int|list|tuple) – 输出尺寸，整数或者整型列表。如为列表类型应包含两个元素 ``[output_size_h, output_size_w]``。如果为整数 o，则输出形状会被认为 ``[o, o]``。
-    - **kernel_size** (int|list|tuple) - 卷积核大小，整数或者整型列表。如为列表类型应包含两个元素 ``[k_h, k_w]``。如果为整数 k，则输出形状会被认为 ``[k, k]``。
-    - **strides** (int|list|tuple，可选) - 步长大小，整数或者整型列表。如为列表类型应包含两个元素 ``[stride_h, stride_w]``。如果为整数 stride，则输出形状会被认为 ``[sride, stride]``。默认为[1,1]。
+    - **output_sizes**  (int|list|tuple) – 输出尺寸，整数或者整型列表。如为列表类型应包含两个元素  ``[output_size_h, output_size_w]`` 。如果为整数 o，则输出形状会被认为  ``[o, o]`` 。
+    - **kernel_size** (int|list|tuple) - 卷积核大小，整数或者整型列表。如为列表类型应包含两个元素  ``[k_h, k_w]`` 。如果为整数 k，则输出形状会被认为  ``[k, k]`` 。
+    - **strides** (int|list|tuple，可选) - 步长大小，整数或者整型列表。如为列表类型应包含两个元素  ``[stride_h, stride_w]`` 。如果为整数 stride，则输出形状会被认为  ``[sride, stride]`` 。默认为[1,1]。
     - **paddings** (int|list|tuple，可选) – 每个维度的扩展，整数或者整型列表。如果为整型列表，长度应该为 4 或者 2；长度为 4 对应的 padding 参数是：[padding_top, padding_left，padding_bottom, padding_right]，长度为 2 对应的 padding 参数是[padding_h, padding_w]，会被当作[padding_h, padding_w, padding_h, padding_w]处理。如果为整数 padding，则会被当作[padding, padding, padding, padding]处理。默认值为 0。
     - **dilations** (int|list|tuple，可选) – 卷积膨胀，整型列表或者整数。如果为整型列表，应该包含两个元素[dilation_h, dilation_w]。如果是整数 dilation，会被当作整型列表[dilation, dilation]处理。默认值为 1。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
@@ -33,7 +33,7 @@ Fold
 形状
 :::::::::
  - **输入** ：4-D Tensor，形状为[N, C_in, L]，数据类型为 float32 或者 float64
- - **输出** ：形状如上面所描述的[N, Cout, H, W]，数据类型与 ``x`` 相同
+ - **输出** ：形状如上面所描述的[N, Cout, H, W]，数据类型与  ``x``  相同
 
 
 代码示例
diff --git a/docs/api/paddle/nn/GaussianNLLLoss_cn.rst b/docs/api/paddle/nn/GaussianNLLLoss_cn.rst
index 595dad72487..c96ff7268fa 100644
--- a/docs/api/paddle/nn/GaussianNLLLoss_cn.rst
+++ b/docs/api/paddle/nn/GaussianNLLLoss_cn.rst
@@ -22,7 +22,7 @@ GaussianNLLLoss
 
     - **full** (bool，可选) - 是否在损失计算中包括常数项。默认情况下为 False，表示忽略最后的常数项。
     - **epsilon** (float，可选) - 一个很小的数字，用于限制 variance 的值，使其不会导致除 0 的出现。默认值为 1e-6。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有 ``none``、``mean`` 和 ``sum``。默认为 ``mean``，计算 ``mini-batch`` loss 均值。设置为 ``sum`` 时，计算 ``mini-batch`` loss 的总和。设置为 ``none`` 时，则返回 loss Tensor。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有  ``none`` 、 ``mean``  和  ``sum`` 。默认为  ``mean`` ，计算  ``mini-batch``  loss 均值。设置为  ``sum``  时，计算  ``mini-batch``  loss 的总和。设置为  ``none``  时，则返回 loss Tensor。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
diff --git a/docs/api/paddle/nn/GroupNorm_cn.rst b/docs/api/paddle/nn/GroupNorm_cn.rst
index f7ba9217427..087290d6075 100644
--- a/docs/api/paddle/nn/GroupNorm_cn.rst
+++ b/docs/api/paddle/nn/GroupNorm_cn.rst
@@ -7,12 +7,12 @@ GroupNorm
 
 **Group Normalization 层**
 
-构建 ``GroupNorm`` 类的一个可调用对象，具体用法参照 ``代码示例``。其中实现了组归一化层的功能。更多详情请参考：`Group Normalization <https://arxiv.org/abs/1803.08494>`_ 。
+构建  ``GroupNorm``  类的一个可调用对象，具体用法参照  ``代码示例`` 。其中实现了组归一化层的功能。更多详情请参考：`Group Normalization <https://arxiv.org/abs/1803.08494>`_ 。
 
 参数
 ::::::::::::
 
-    - **num_groups** (int) - 从通道中分离出来的 ``group`` 的数目。
+    - **num_groups** (int) - 从通道中分离出来的  ``group``  的数目。
     - **num_channels** (int) - 输入的通道数。
     - **epsilon** (float，可选) - 为防止方差除零，增加一个很小的值。默认值：1e-05。
     - **weight_attr** (ParamAttr|bool，可选) - 指定权重参数属性的对象。如果为 False，表示参数不学习。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
diff --git a/docs/api/paddle/nn/HSigmoidLoss_cn.rst b/docs/api/paddle/nn/HSigmoidLoss_cn.rst
index 8684d13f78f..745ff93fd11 100644
--- a/docs/api/paddle/nn/HSigmoidLoss_cn.rst
+++ b/docs/api/paddle/nn/HSigmoidLoss_cn.rst
@@ -13,23 +13,23 @@ HSigmoidLoss
 
 若使用默认树结构，请参考 `Hierarchical Probabilistic Neural Network Language Model <http://www.iro.umontreal.ca/~lisa/pointeurs/hierarchical-nnlm-aistats05.pdf>`_ 。
 
-若使用自定义树结构，请将参数 ``is_custom`` 设置为 True，并完成以下步骤（以语言模型为例）：
+若使用自定义树结构，请将参数  ``is_custom``  设置为 True，并完成以下步骤（以语言模型为例）：
 
 1. 使用自定义词典来建立二叉树，每个叶结点都应该是词典中的单词；
 
-2. 建立一个 dict 类型数据结构，用于存储 **单词 id -> 该单词叶结点至根节点路径** 的映射，即路径表 ``path_table`` 参数；
+2. 建立一个 dict 类型数据结构，用于存储 **单词 id -> 该单词叶结点至根节点路径** 的映射，即路径表  ``path_table``  参数；
 
-3. 建立一个 dict 类型数据结构，用于存储 **单词 id -> 该单词叶结点至根节点路径的编码** 的映射，即路径编码 ``path_code`` 参数。编码是指每次二分类的标签，1 为真，0 为假；
+3. 建立一个 dict 类型数据结构，用于存储 **单词 id -> 该单词叶结点至根节点路径的编码** 的映射，即路径编码  ``path_code``  参数。编码是指每次二分类的标签，1 为真，0 为假；
 
 4. 每个单词都已经有自己的路径和路径编码，当对于同一批输入进行操作时，可以同时传入一批路径和路径编码进行运算。
 
 参数
 ::::::::::
     - **feature_size** (int) - 输入 Tensor 的特征大尺寸。
-    - **num_classes** (int) - 类别总数(字典大小)必须大于等于 2。若使用默认树结构，即当 ``is_custom=False`` 时，必须设置该参数。若使用自定义树结构，即当 ``is_custom=True`` 时，它取值应为自定义树结构的非叶节点的个数，用于指定二分类的类别总数。
+    - **num_classes** (int) - 类别总数(字典大小)必须大于等于 2。若使用默认树结构，即当  ``is_custom=False``  时，必须设置该参数。若使用自定义树结构，即当  ``is_custom=True``  时，它取值应为自定义树结构的非叶节点的个数，用于指定二分类的类别总数。
     - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **bias_attr** (ParamAttr，可选) - 指定偏置参数属性的对象，若 `bias_attr` 为 bool 类型，如果设置为 False，表示不会为该层添加偏置；如果设置为 True，表示使用默认的偏置参数属性。默认值为 None，表示使用默认的偏置参数属性。默认的偏置参数属性将偏置参数的初始值设为 0。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **is_custom** (bool，可选) - 是否使用用户自定义二叉树取代默认二叉树结构。如果设置为 True，请务必设置 ``path_table`` ， ``path_code`` ， ``num_classes``，否则必须设置 num_classes。默认值为 False。
+    - **is_custom** (bool，可选) - 是否使用用户自定义二叉树取代默认二叉树结构。如果设置为 True，请务必设置  ``path_table``  ，  ``path_code``  ，  ``num_classes`` ，否则必须设置 num_classes。默认值为 False。
     - **is_sparse** (bool，可选) - 是否使用稀疏更新方式。如果设置为 True，W 的梯度和输入梯度将会变得稀疏。默认值为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
@@ -37,7 +37,7 @@ HSigmoidLoss
 :::::::::
     - **input** (Tensor): - 输入的 Tensor，维度是[N, D]，其中 N 是 batch size， D 是特征尺寸。
     - **label** (Tensor): - 标签，维度是[N, 1]。
-    - **output** (Tensor): - 输入 ``input`` 和标签 ``label`` 间的 `hsigmoid loss` 损失。输出 Loss 的维度为[N, 1]。
+    - **output** (Tensor): - 输入  ``input``  和标签  ``label``  间的 `hsigmoid loss` 损失。输出 Loss 的维度为[N, 1]。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/HingeEmbeddingLoss_cn.rst b/docs/api/paddle/nn/HingeEmbeddingLoss_cn.rst
index 0dd20405ca7..bc3e46eb00f 100644
--- a/docs/api/paddle/nn/HingeEmbeddingLoss_cn.rst
+++ b/docs/api/paddle/nn/HingeEmbeddingLoss_cn.rst
@@ -30,13 +30,13 @@ HingeEmbeddingLoss
 参数
 :::::::::
     - **margin** (float，可选): - 当 label 为 -1 时，该值决定了小于 `margin` 的 input 才需要纳入 `hinge embedding loss` 的计算。默认为 1.0 。
-    - **reduction** (str，可选): - 指定应用于输出结果的计算方式，可选值有：``'none'``, ``'mean'``, ``'sum'``。默认为 ``'mean'``，计算 `hinge embedding loss` 的均值；设置为 ``'sum'`` 时，计算 `hinge embedding loss` 的总和；设置为 ``'none'`` 时，则返回 `hinge embedding loss`。
+    - **reduction** (str，可选): - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ,  ``'mean'`` ,  ``'sum'`` 。默认为  ``'mean'`` ，计算 `hinge embedding loss` 的均值；设置为  ``'sum'``  时，计算 `hinge embedding loss` 的总和；设置为  ``'none'``  时，则返回 `hinge embedding loss`。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 输入
 :::::::::
     - **input** (Tensor): - 输入 Tensor，维度是 [N, *]，其中 N 是 batch size， `*` 是任意数量的额外维度。数据类型为：float32、float64。
-    - **label** (Tensor): - 标签，维度是 [N, *]，与 ``input`` 相同，Tensor 中的值应该只包含 1 和 -1。数据类型为：float32、float64。
+    - **label** (Tensor): - 标签，维度是 [N, *]，与  ``input``  相同，Tensor 中的值应该只包含 1 和 -1。数据类型为：float32、float64。
 
 返回
 :::::::::
@@ -45,8 +45,8 @@ HingeEmbeddingLoss
 形状
 :::::::::
     - **input** (Tensor): - 输入的 Tensor，维度是 [N, *]，其中 N 是 batch size， `*` 是任意数量的额外维度。数据类型为：float32、float64。
-    - **label** (Tensor): - 标签，维度是 [N, *]，与 ``input`` 相同，应该只包含 1 和 -1。数据类型为：float32、float64。
-    - **output** (Tensor): - 输入 ``input`` 和标签 ``label`` 间的 `hinge embedding loss` 损失。如果 `reduction` 是 ``'none'``，则输出 Loss 的维度为 [N, *]，与输入 ``input`` 相同。如果 `reduction` 是 ``'mean'`` 或 ``'sum'``，则输出 Loss 的维度为 []。
+    - **label** (Tensor): - 标签，维度是 [N, *]，与  ``input``  相同，应该只包含 1 和 -1。数据类型为：float32、float64。
+    - **output** (Tensor): - 输入  ``input``  和标签  ``label``  间的 `hinge embedding loss` 损失。如果 `reduction` 是  ``'none'`` ，则输出 Loss 的维度为 [N, *]，与输入  ``input``  相同。如果 `reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出 Loss 的维度为 []。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/InstanceNorm1D_cn.rst b/docs/api/paddle/nn/InstanceNorm1D_cn.rst
index 5b845aad3af..96d4b3f5357 100644
--- a/docs/api/paddle/nn/InstanceNorm1D_cn.rst
+++ b/docs/api/paddle/nn/InstanceNorm1D_cn.rst
@@ -6,11 +6,11 @@ InstanceNorm1D
 .. py:class:: paddle.nn.InstanceNorm1D(num_features, epsilon=1e-05, momentum=0.9, weight_attr=None, bias_attr=None, data_format="NCL", name=None)
 
 
-构建 ``InstanceNorm1D`` 类的一个可调用对象，具体用法参照 ``代码示例``。可以处理 2D 或者 3D 的 Tensor，实现了实例归一化层（Instance Normalization Layer）的功能。更多详情请参考：Instance Normalization: The Missing Ingredient for Fast Stylization 。
+构建  ``InstanceNorm1D``  类的一个可调用对象，具体用法参照  ``代码示例`` 。可以处理 2D 或者 3D 的 Tensor，实现了实例归一化层（Instance Normalization Layer）的功能。更多详情请参考：Instance Normalization: The Missing Ingredient for Fast Stylization 。
 
 数据布局：NCL [batch, in_channels, length]
 
-``input`` 是 mini-batch 的输入。
+ ``input``  是 mini-batch 的输入。
 
 .. math::
     \mu_{\beta}        &\gets \frac{1}{m} \sum_{i=1}^{m} x_i                                 \quad &// mean  \\
@@ -24,9 +24,9 @@ InstanceNorm1D
 参数
 ::::::::::::
 
-    - **num_features** (int) - 指明输入 ``Tensor`` 的通道数量。
+    - **num_features** (int) - 指明输入  ``Tensor``  的通道数量。
     - **epsilon** (float，可选) - 为了数值稳定加在分母上的值。默认值：1e-05。
-    - **momentum** (float，可选) - 此值用于计算 ``moving_mean`` 和 ``moving_var``。默认值：0.9。更新公式如上所示。
+    - **momentum** (float，可选) - 此值用于计算  ``moving_mean``  和  ``moving_var`` 。默认值：0.9。更新公式如上所示。
     - **weight_attr** (ParamAttr|bool，可选) - 指定权重参数属性的对象。如果为 False，则表示每个通道的伸缩固定为 1，不可改变。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **bias_attr** (ParamAttr，可选) - 指定偏置参数属性的对象。如果为 False，则表示每一个通道的偏移固定为 0，不可改变。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **data_format** (string，可选) - 指定输入数据格式，数据格式可以为“NC"或者"NCL"。默认值：“NCL”。
diff --git a/docs/api/paddle/nn/InstanceNorm2D_cn.rst b/docs/api/paddle/nn/InstanceNorm2D_cn.rst
index a4ed8a5c515..a15ae7e54ca 100644
--- a/docs/api/paddle/nn/InstanceNorm2D_cn.rst
+++ b/docs/api/paddle/nn/InstanceNorm2D_cn.rst
@@ -6,11 +6,11 @@ InstanceNorm2D
 .. py:class:: paddle.nn.InstanceNorm2D(num_features, epsilon=1e-05, momentum=0.9, weight_attr=None, bias_attr=None, data_format="NCHW", name=None)
 
 
-构建 ``InstanceNorm2D`` 类的一个可调用对象，具体用法参照 ``代码示例``。可以处理 2D 或者 3D 的 Tensor，实现了实例归一化层（Instance Normalization Layer）的功能。更多详情请参考：Instance Normalization: The Missing Ingredient for Fast Stylization 。
+构建  ``InstanceNorm2D``  类的一个可调用对象，具体用法参照  ``代码示例`` 。可以处理 2D 或者 3D 的 Tensor，实现了实例归一化层（Instance Normalization Layer）的功能。更多详情请参考：Instance Normalization: The Missing Ingredient for Fast Stylization 。
 
 数据布局：NCHW [batch, in_channels, in_height, in_width]
 
-``input`` 是 mini-batch 的输入。
+ ``input``  是 mini-batch 的输入。
 
 .. math::
     \mu_{\beta}        &\gets \frac{1}{m} \sum_{i=1}^{m} x_i                                 \quad &// mean  \\
@@ -24,9 +24,9 @@ InstanceNorm2D
 参数
 ::::::::::::
 
-    - **num_features** (int) - 指明输入 ``Tensor`` 的通道数量。
+    - **num_features** (int) - 指明输入  ``Tensor``  的通道数量。
     - **epsilon** (float，可选) - 为了数值稳定加在分母上的值。默认值：1e-05。
-    - **momentum** (float，可选) - 此值用于计算 ``moving_mean`` 和 ``moving_var``。默认值：0.9。更新公式如上所示。
+    - **momentum** (float，可选) - 此值用于计算  ``moving_mean``  和  ``moving_var`` 。默认值：0.9。更新公式如上所示。
     - **weight_attr** (ParamAttr|bool，可选) - 指定权重参数属性的对象。如果为 False，则表示每个通道的伸缩固定为 1，不可改变。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **bias_attr** (ParamAttr，可选) - 指定偏置参数属性的对象。如果为 False，则表示每一个通道的偏移固定为 0，不可改变。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **data_format** (string，可选) - 指定输入数据格式，数据格式可以为“NCHW"。默认值：“NCHW”。
diff --git a/docs/api/paddle/nn/InstanceNorm3D_cn.rst b/docs/api/paddle/nn/InstanceNorm3D_cn.rst
index 008dee47827..bc442c6d95e 100644
--- a/docs/api/paddle/nn/InstanceNorm3D_cn.rst
+++ b/docs/api/paddle/nn/InstanceNorm3D_cn.rst
@@ -5,11 +5,11 @@ InstanceNorm3D
 
 .. py:class:: paddle.nn.InstanceNorm3D(num_features, epsilon=1e-05, momentum=0.9, weight_attr=None, bias_attr=None, data_format="NCDHW", name=None)
 
-构建 ``InstanceNorm3D`` 类的一个可调用对象，具体用法参照 ``代码示例``。可以处理 5D 的 Tensor，实现了实例归一化层（Instance Normalization Layer）的功能。更多详情请参考：Instance Normalization: The Missing Ingredient for Fast Stylization 。
+构建  ``InstanceNorm3D``  类的一个可调用对象，具体用法参照  ``代码示例`` 。可以处理 5D 的 Tensor，实现了实例归一化层（Instance Normalization Layer）的功能。更多详情请参考：Instance Normalization: The Missing Ingredient for Fast Stylization 。
 
 数据布局：NCDHW [batch, in_channels, D, in_height, in_width]
 
-``input`` 是 mini-batch 的输入。
+ ``input``  是 mini-batch 的输入。
 
 .. math::
     \mu_{\beta}        &\gets \frac{1}{m} \sum_{i=1}^{m} x_i                                 \quad &// mean  \\
@@ -23,9 +23,9 @@ InstanceNorm3D
 参数
 ::::::::::::
 
-    - **num_features** (int) - 指明输入 ``Tensor`` 的通道数量。
+    - **num_features** (int) - 指明输入  ``Tensor``  的通道数量。
     - **epsilon** (float，可选) - 为了数值稳定加在分母上的值。默认值：1e-05。
-    - **momentum** (float，可选) - 此值用于计算 ``moving_mean`` 和 ``moving_var``。默认值：0.9。更新公式如上所示。
+    - **momentum** (float，可选) - 此值用于计算  ``moving_mean``  和  ``moving_var`` 。默认值：0.9。更新公式如上所示。
     - **weight_attr** (ParamAttr|bool，可选) - 指定权重参数属性的对象。如果为 False，则表示每个通道的伸缩固定为 1，不可改变。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **bias_attr** (ParamAttr，可选) - 指定偏置参数属性的对象。如果为 False，则表示每一个通道的偏移固定为 0，不可改变。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **data_format** (string，可选) - 指定输入数据格式，数据格式可以为"NCDHW"。默认值：“NCDHW”。
diff --git a/docs/api/paddle/nn/KLDivLoss_cn.rst b/docs/api/paddle/nn/KLDivLoss_cn.rst
index 388c5000a9b..d6d730bb67a 100644
--- a/docs/api/paddle/nn/KLDivLoss_cn.rst
+++ b/docs/api/paddle/nn/KLDivLoss_cn.rst
@@ -7,39 +7,39 @@ KLDivLoss
 
 创建一个 `KLDivLoss` 类的可调用对象，以计算输入(Input)和输入(Label)之间的 Kullback-Leibler 散度损失。注意其中输入(Input)应为对数概率值，输入(Label)应为概率值。
 
-若 ``log_target`` 为 ``False``:
+若  ``log_target``  为  ``False`` :
 
 ..  math::
 
     l(input, label) = label * (log(label) - input)
 
-若 ``log_target`` 为 ``True``:
+若  ``log_target``  为  ``True`` :
 
 ..  math::
 
     l(input, label) = exp(label) * (label - input)
 
 
-当 ``reduction``  为 ``none`` 时，输出损失与输入（input）形状相同，各点的损失单独计算，不会对结果做 reduction 。
+当  ``reduction``   为  ``none``  时，输出损失与输入（input）形状相同，各点的损失单独计算，不会对结果做 reduction 。
 
-当 ``reduction``  为 ``mean`` 时，输出损失的形状为[]，输出为所有损失的平均值。
+当  ``reduction``   为  ``mean``  时，输出损失的形状为[]，输出为所有损失的平均值。
 
-当 ``reduction``  为 ``sum`` 时，输出损失的形状为[]，输出为所有损失的总和。
+当  ``reduction``   为  ``sum``  时，输出损失的形状为[]，输出为所有损失的总和。
 
-当 ``reduction``  为 ``batchmean`` 时，输出损失为[N]的形状，N 为批大小，输出为所有损失的总和除以批量大小。
+当  ``reduction``   为  ``batchmean``  时，输出损失为[N]的形状，N 为批大小，输出为所有损失的总和除以批量大小。
 
 参数
 ::::::::::::
 
     - **reduction** (str，可选) - 要应用于输出的 reduction 类型，可用类型为‘none’ | ‘batchmean’ | ‘mean’ | ‘sum’，‘none’表示无 reduction，‘batchmean’ 表示输出的总和除以批大小，‘mean’ 表示所有输出的平均值，‘sum’表示输出的总和。
-    - **log_target** (bool，可选) - 表示输入的 ``label`` 变量是否属于 log 空间。默认值为 False，表示不属于。
+    - **log_target** (bool，可选) - 表示输入的  ``label``  变量是否属于 log 空间。默认值为 False，表示不属于。
 
 形状
 ::::::::::::
 
     - **input** (Tensor)：输入的 Tensor，维度是[N, *]，其中 N 是 batch size， `*` 是任意数量的额外维度。数据类型为：float32、float64。
-    - **label** (Tensor)：标签，维度是[N, *]，与 ``input`` 相同。数据类型为：float32、float64。
-    - **output** (Tensor)：输入 ``input`` 和标签 ``label`` 间的 kl 散度。如果 `reduction` 是 ``'none'``，则输出 Loss 的维度为 [N, *]，与输入 ``input`` 相同。如果 `reduction` 是 ``'batchmean'`` 、 ``'mean'`` 或 ``'sum'``，则输出 Loss 的维度为 []。
+    - **label** (Tensor)：标签，维度是[N, *]，与  ``input``  相同。数据类型为：float32、float64。
+    - **output** (Tensor)：输入  ``input``  和标签  ``label``  间的 kl 散度。如果 `reduction` 是  ``'none'`` ，则输出 Loss 的维度为 [N, *]，与输入  ``input``  相同。如果 `reduction` 是  ``'batchmean'``  、  ``'mean'``  或  ``'sum'`` ，则输出 Loss 的维度为 []。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/nn/L1Loss_cn.rst b/docs/api/paddle/nn/L1Loss_cn.rst
index aaff39c17bb..5653c37b640 100644
--- a/docs/api/paddle/nn/L1Loss_cn.rst
+++ b/docs/api/paddle/nn/L1Loss_cn.rst
@@ -9,17 +9,17 @@ L1Loss
 
 该损失函数的数学计算公式如下：
 
-当 `reduction` 设置为 ``'none'`` 时：
+当 `reduction` 设置为  ``'none'``  时：
 
 ..  math::
     Out = \lvert input - label\rvert
 
-当 `reduction` 设置为 ``'mean'`` 时：
+当 `reduction` 设置为  ``'mean'``  时：
 
 ..  math::
     Out = MEAN(\lvert input - label\rvert)
 
-当 `reduction` 设置为 ``'sum'`` 时：
+当 `reduction` 设置为  ``'sum'``  时：
 
 ..  math::
     Out = SUM(\lvert input - label\rvert)
@@ -27,14 +27,14 @@ L1Loss
 
 参数
 :::::::::
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：``'none'``, ``'mean'``, ``'sum'``。默认为 ``'mean'``，计算 `L1Loss` 的均值；设置为 ``'sum'`` 时，计算 `L1Loss` 的总和；设置为 ``'none'`` 时，则返回 `L1Loss`。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ,  ``'mean'`` ,  ``'sum'`` 。默认为  ``'mean'`` ，计算 `L1Loss` 的均值；设置为  ``'sum'``  时，计算 `L1Loss` 的总和；设置为  ``'none'``  时，则返回 `L1Loss`。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
 :::::::::
     - **input** (Tensor)：输入的 Tensor，维度是[N, *]，其中 N 是 batch size， `*` 是任意数量的额外维度。数据类型为：float32、float64、int32、int64。
-    - **label** (Tensor)：标签，维度是[N, *]，与 ``input`` 相同。数据类型为：float32、float64、int32、int64。
-    - **output** (Tensor)：输入 ``input`` 和标签 ``label`` 间的 `L1 loss` 损失。如果 `reduction` 是 ``'none'``，则输出 Loss 的维度为 [N, *]，与输入 ``input`` 相同。如果 `reduction` 是 ``'mean'`` 或 ``'sum'``，则输出 Loss 的维度为 []。
+    - **label** (Tensor)：标签，维度是[N, *]，与  ``input``  相同。数据类型为：float32、float64、int32、int64。
+    - **output** (Tensor)：输入  ``input``  和标签  ``label``  间的 `L1 loss` 损失。如果 `reduction` 是  ``'none'`` ，则输出 Loss 的维度为 [N, *]，与输入  ``input``  相同。如果 `reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出 Loss 的维度为 []。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/LayerNorm_cn.rst b/docs/api/paddle/nn/LayerNorm_cn.rst
index 31c1656d18b..6300bf4b567 100644
--- a/docs/api/paddle/nn/LayerNorm_cn.rst
+++ b/docs/api/paddle/nn/LayerNorm_cn.rst
@@ -5,7 +5,7 @@ LayerNorm
 
 .. py:class:: paddle.nn.LayerNorm(normalized_shape, epsilon=1e-05, weight_attr=None, bias_attr=None, name=None)
 
-构建 ``LayerNorm`` 类的一个可调用对象，具体用法参照 ``代码示例``。其中实现了层归一化层（Layer Normalization Layer）的功能，其可以应用于小批量输入数据。更多详情请参考：`Layer Normalization <https://arxiv.org/pdf/1607.06450v1.pdf>`_ 。
+构建  ``LayerNorm``  类的一个可调用对象，具体用法参照  ``代码示例`` 。其中实现了层归一化层（Layer Normalization Layer）的功能，其可以应用于小批量输入数据。更多详情请参考：`Layer Normalization <https://arxiv.org/pdf/1607.06450v1.pdf>`_ 。
 
 计算公式如下：
 
@@ -26,7 +26,7 @@ LayerNorm
 参数
 ::::::::::::
 
-    - **normalized_shape** (int|list|tuple) – 需规范化的 shape，期望的输入 shape 为 ``[*, normalized_shape[0], normalized_shape[1], ..., normalized_shape[-1]]`` 。如果是单个整数，则此模块将在最后一个维度上规范化（此时最后一维的维度需与该参数相同）。
+    - **normalized_shape** (int|list|tuple) – 需规范化的 shape，期望的输入 shape 为  ``[*, normalized_shape[0], normalized_shape[1], ..., normalized_shape[-1]]``  。如果是单个整数，则此模块将在最后一个维度上规范化（此时最后一维的维度需与该参数相同）。
     - **epsilon** (float，可选) - 指明在计算过程中是否添加较小的值到方差中以防止除零。默认值：1e-05。
 weight_attr (ParamAttr|bool|None, 可选) - 用于指定可训练的增益参数 :math:g 的属性。如果为 False，则不使用权重（即权重参数为 None）；如果为 None，则会使用一个默认的 ParamAttr 作为权重的属性设置，该属性将权重初始化为 1。默认值为 None，表示使用默认的权重属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr`。
 bias_attr (ParamAttr|bool|None, 可选) - 用于指定可训练的偏置参数 :math:b 的属性。如果为 False，则不使用偏置（即偏置参数为 None）；如果为 None，则会使用一个默认的 ParamAttr 作为偏置的属性设置，该属性将偏置初始化为 0。默认值为 None，表示使用默认的偏置属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr`。
@@ -40,7 +40,7 @@ bias_attr (ParamAttr|bool|None, 可选) - 用于指定可训练的偏置参数 :
 返回
 :::::::::
 
-    ``Tensor``，维度与 :attr:`x` 相同，但内部的数值已经被 ``LayerNorm`` 标准化处理过。
+     ``Tensor`` ，维度与 :attr:`x` 相同，但内部的数值已经被  ``LayerNorm``  标准化处理过。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/nn/Layer_cn.rst b/docs/api/paddle/nn/Layer_cn.rst
index d3f5f4a639f..37e17ca0fb9 100644
--- a/docs/api/paddle/nn/Layer_cn.rst
+++ b/docs/api/paddle/nn/Layer_cn.rst
@@ -54,7 +54,7 @@ COPY-FROM: paddle.nn.Layer.eval
 apply(fn)
 '''''''''
 
-将一个函数 fn 递归地应用到网络的每一个子层(即在函数的 ``.sublayers()`` 中返回的子层)以及模块自身。该方法通常用来初始化一个模型中的参数。
+将一个函数 fn 递归地应用到网络的每一个子层(即在函数的  ``.sublayers()``  中返回的子层)以及模块自身。该方法通常用来初始化一个模型中的参数。
 
 **参数**
 
@@ -70,7 +70,7 @@ COPY-FROM: paddle.nn.Layer.apply
 full_name()
 '''''''''
 
-Layer 的全名。组成方式为：``name_scope`` + “/” + MyLayer.__class__.__name__ 。
+Layer 的全名。组成方式为： ``name_scope``  + “/” + MyLayer.__class__.__name__ 。
 
 **返回**
 str， Layer 的全名
@@ -82,18 +82,18 @@ COPY-FROM: paddle.nn.Layer.full_name
 register_forward_pre_hook(hook)
 '''''''''
 
-为 Layer 注册一个 ``forward pre-hook`` 函数，该 ``hook`` 函数将会在 ``forward`` 函数调用之前被调用。
+为 Layer 注册一个  ``forward pre-hook``  函数，该  ``hook``  函数将会在  ``forward``  函数调用之前被调用。
 
-``hook`` 函数具有以下形式：它的 ``input`` 是 ``Layer`` 的 ``input``，并且可以返回一个元组或者单个修改值；如果返回单个修改值，则将值包装到一个元组中。用户可以使用该函数来查看或修改 ``Layer`` ``forward`` 函数的输入。
+ ``hook``  函数具有以下形式：它的  ``input``  是  ``Layer``  的  ``input`` ，并且可以返回一个元组或者单个修改值；如果返回单个修改值，则将值包装到一个元组中。用户可以使用该函数来查看或修改  ``Layer``   ``forward``  函数的输入。
 
 hook(Layer, input) -> None or modified input
 
 **参数**
 
-    - **hook** (function) - 被注册为 ``forward pre-hook`` 的函数
+    - **hook** (function) - 被注册为  ``forward pre-hook``  的函数
 
 **返回**
-HookRemoveHelper，可通过调用 ``hook_remove_helper.remove()`` 来删除注册的 hook 函数。
+HookRemoveHelper，可通过调用  ``hook_remove_helper.remove()``  来删除注册的 hook 函数。
 
 **代码示例**
 
@@ -102,18 +102,18 @@ COPY-FROM: paddle.nn.Layer.register_forward_pre_hook
 register_forward_post_hook(hook)
 '''''''''
 
-为 Layer 注册一个 ``forward post-hook`` 函数，该 ``hook`` 函数将会在 ``forward`` 函数调用之后被调用。
+为 Layer 注册一个  ``forward post-hook``  函数，该  ``hook``  函数将会在  ``forward``  函数调用之后被调用。
 
-``hook`` 函数具有以下形式，它的 ``input`` 和 ``output`` 是 ``Layer`` 的 ``input`` 和 ``output``。用户可以用该函数来查看和修改 ``Layer`` ``forward`` 函数的输出。
+ ``hook``  函数具有以下形式，它的  ``input``  和  ``output``  是  ``Layer``  的  ``input``  和  ``output`` 。用户可以用该函数来查看和修改  ``Layer``   ``forward``  函数的输出。
 
 hook(Layer, input, output) -> None or modified output
 
 **参数**
 
-    - **hook** (function) - 被注册为 ``forward post-hook`` 的函数
+    - **hook** (function) - 被注册为  ``forward post-hook``  的函数
 
 **返回**
-HookRemoveHelper，可通过调用 ``hook_remove_helper.remove()`` 来删除注册的 hook 函数。
+HookRemoveHelper，可通过调用  ``hook_remove_helper.remove()``  来删除注册的 hook 函数。
 
 **代码示例**
 
@@ -151,7 +151,7 @@ create_variable(name=None, persistable=None, dtype=None)
     - **dtype** (str|paddle.dtype|np.dtype，可选) - Layer 中参数数据类型。如果设置为 str，则可以是“bool”，“float16”，“float32”，“float64”，“int8”，“int16”，“int32”，“int64”，“uint8”或“uint16”。默认值为 "float32" 。
 
 **返回**
-Tensor，返回创建的 ``Tensor``
+Tensor，返回创建的  ``Tensor`` 
 
 **代码示例**
 
@@ -169,7 +169,7 @@ create_tensor(name=None, persistable=None, dtype=None)
     - **dtype** (str|paddle.dtype|np.dtype，可选) - Layer 中参数数据类型。如果设置为 str，则可以是“bool”，“float16”，“float32”，“float64”，“int8”，“int16”，“int32”，“int64”，“uint8”或“uint16”。默认值为 "float32" 。
 
 **返回**
-Tensor，返回创建的 ``Tensor``
+Tensor，返回创建的  ``Tensor`` 
 
 **代码示例**
 
@@ -289,15 +289,15 @@ register_buffer(name, tensor, persistable=True)
 
 将一个 Tensor 注册为 buffer。
 
-buffer 是一个不可训练的变量，不会被优化器更新，但在评估或预测阶段可能是必要的状态变量。比如 ``BatchNorm`` 中的均值和方差。
+buffer 是一个不可训练的变量，不会被优化器更新，但在评估或预测阶段可能是必要的状态变量。比如  ``BatchNorm``  中的均值和方差。
 
-注册的 buffer 默认是可持久性的，会被保存到 ``state_dict`` 中。如果指定 ``persistable`` 参数为 False，则会注册一个非持久性的 buffer，即不会同步和保存到 ``state_dict`` 中。
+注册的 buffer 默认是可持久性的，会被保存到  ``state_dict``  中。如果指定  ``persistable``  参数为 False，则会注册一个非持久性的 buffer，即不会同步和保存到  ``state_dict``  中。
 
 **参数**
 
     - **name** (str) - 注册 buffer 的名字。可以通过此名字来访问已注册的 buffer。
     - **tensor** (Tensor) - 将被注册为 buffer 的变量。
-    - **persistable** (bool，可选) - 注册的 buffer 是否需要可持久性地保存到 ``state_dict`` 中。
+    - **persistable** (bool，可选) - 注册的 buffer 是否需要可持久性地保存到  ``state_dict``  中。
 
 **返回**
 None
@@ -394,7 +394,7 @@ state_dict(destination=None, include_sublayers=True, structured_name_prefix='',
 
 **参数**
 
-    - **destination** (dict，可选) - 如果提供 ``destination``，则所有参数和可持久性 buffers 都将存放在 ``destination`` 中。默认值：None。
+    - **destination** (dict，可选) - 如果提供  ``destination`` ，则所有参数和可持久性 buffers 都将存放在  ``destination``  中。默认值：None。
     - **include_sublayers** (bool，可选) - 如果设置为 True，则包括子层的参数和 buffers。默认值：True。
     - **structured_name_prefix** (str，可选) - 添加到参数和缓冲区名称的前缀。默认值：''。
     - **use_hook** (bool，可选) - 如果设置为 True，将_state_dict_hooks 中注册的函数应用于 destination。默认值：True。
@@ -410,7 +410,7 @@ COPY-FROM: paddle.nn.Layer.state_dict
 set_state_dict(state_dict, use_structured_name=True)
 '''''''''
 
-根据传入的 ``state_dict`` 设置参数和可持久性 buffers。所有参数和 buffers 将由 ``state_dict`` 中的 ``Tensor`` 设置。
+根据传入的  ``state_dict``  设置参数和可持久性 buffers。所有参数和 buffers 将由  ``state_dict``  中的  ``Tensor``  设置。
 
 **参数**
 
@@ -433,7 +433,7 @@ to(device=None, dtype=None, blocking=None)
 
 **参数**
 
-    - **device** （str|paddle.CPUPlace()|paddle.CUDAPlace()|paddle.CUDAPinnedPlace()|paddle.XPUPlace()|None，可选) - 希望存储 Layer 的设备位置。如果为 None，设备位置和原始的 Tensor 的设备位置一致。如果设备位置是 string 类型，取值可为 ``cpu``, ``gpu:x`` and ``xpu:x``，这里的 ``x`` 是 GPUs 或者 XPUs 的编号。默认值：None。
+    - **device** （str|paddle.CPUPlace()|paddle.CUDAPlace()|paddle.CUDAPinnedPlace()|paddle.XPUPlace()|None，可选) - 希望存储 Layer 的设备位置。如果为 None，设备位置和原始的 Tensor 的设备位置一致。如果设备位置是 string 类型，取值可为  ``cpu`` ,  ``gpu:x``  and  ``xpu:x`` ，这里的  ``x``  是 GPUs 或者 XPUs 的编号。默认值：None。
     - **dtype** (str|paddle.dtype|np.dtype，可选)- 数据的类型。如果为 None，数据类型和原始的 Tensor 一致。默认值：None。
     - **blocking** （bool|None，可选）- 如果为 False 并且当前 Tensor 处于固定内存上，将会发生主机到设备端的异步拷贝。否则，会发生同步拷贝。如果为 None，blocking 会被设置为 True。默认为 False。
 
@@ -443,7 +443,7 @@ COPY-FROM: paddle.nn.Layer.to
 
 astype(dtype=None)
 '''''''''
-将 Layer 的所有 ``parameters`` 和 ``buffers`` 的数据类型转换为 ``dtype``，并返回这个 Layer。
+将 Layer 的所有  ``parameters``  和  ``buffers``  的数据类型转换为  ``dtype`` ，并返回这个 Layer。
 
 **参数**
 
@@ -460,11 +460,11 @@ COPY-FROM: paddle.nn.Layer.astype
 float(excluded_layers=None)
 '''''''''
 
-将所有浮点型的参数和通过 ``register_buffers()`` 注册的 Buffer 变量转换为 float 数据类型。
+将所有浮点型的参数和通过  ``register_buffers()``  注册的 Buffer 变量转换为 float 数据类型。
 
 **参数**
 
-    - **excluded_layers** （list|tuple|nn.Layer|None，可选） - 不需要转换数据类型的层。如果 ``excluded_layers`` 为 None，则转换所有浮点参数和缓冲区，默认值：None。
+    - **excluded_layers** （list|tuple|nn.Layer|None，可选） - 不需要转换数据类型的层。如果  ``excluded_layers``  为 None，则转换所有浮点参数和缓冲区，默认值：None。
 
 **代码示例**
 
@@ -473,14 +473,14 @@ COPY-FROM: paddle.nn.Layer.float
 float16(excluded_layers=None)
 '''''''''
 
-将所有浮点型的参数和通过 ``register_buffers()`` 注册的 Buffer 变量转换为 float16 数据类型。
+将所有浮点型的参数和通过  ``register_buffers()``  注册的 Buffer 变量转换为 float16 数据类型。
 
 .. note::
    nn.BatchNorm 不支持 float16 类型的权重，默认不对其权重进行类型转换。
 
 **参数**
 
-    - **excluded_layers** （list|tuple|nn.Layer|None，可选） - 不需要转换数据类型的层。如果 ``excluded_layers`` 为 None，则转换除 ``nn.BatchNorm`` 之外的所有浮点参数和缓冲区，默认值：None。
+    - **excluded_layers** （list|tuple|nn.Layer|None，可选） - 不需要转换数据类型的层。如果  ``excluded_layers``  为 None，则转换除  ``nn.BatchNorm``  之外的所有浮点参数和缓冲区，默认值：None。
 
 **代码示例**
 
@@ -489,14 +489,14 @@ COPY-FROM: paddle.nn.Layer.float16
 bfloat16(excluded_layers=None)
 '''''''''
 
-将所有浮点型的参数和通过 ``register_buffers()`` 注册的 Buffer 变量转换为 bfloat16 数据类型。
+将所有浮点型的参数和通过  ``register_buffers()``  注册的 Buffer 变量转换为 bfloat16 数据类型。
 
 .. note::
    nn.BatchNorm 不支持 bfloat16 类型的权重，默认不对其权重进行类型转换。
 
 **参数**
 
-    - **excluded_layers** （list|tuple|nn.Layer|None，可选） - 不需要转换数据类型的层。如果 ``excluded_layers`` 为 None，则转换除 ``nn.BatchNorm`` 之外的所有浮点参数和缓冲区，默认值：None。
+    - **excluded_layers** （list|tuple|nn.Layer|None，可选） - 不需要转换数据类型的层。如果  ``excluded_layers``  为 None，则转换除  ``nn.BatchNorm``  之外的所有浮点参数和缓冲区，默认值：None。
 
 **代码示例**
 
diff --git a/docs/api/paddle/nn/Linear_cn.rst b/docs/api/paddle/nn/Linear_cn.rst
index c1391e810eb..ba835383bb4 100644
--- a/docs/api/paddle/nn/Linear_cn.rst
+++ b/docs/api/paddle/nn/Linear_cn.rst
@@ -33,12 +33,12 @@ Linear 层只接受一个 Tensor 作为输入，形状为 :math:`[batch\_size, *
 weight
 '''''''''
 
-本层的可学习参数，类型为 ``Parameter`` 。
+本层的可学习参数，类型为  ``Parameter``  。
 
 bias
 '''''''''
 
-本层的可学习偏置，类型为 ``Parameter`` 。
+本层的可学习偏置，类型为  ``Parameter``  。
 
 形状
 :::::::::
diff --git a/docs/api/paddle/nn/LogSoftmax_cn.rst b/docs/api/paddle/nn/LogSoftmax_cn.rst
index d8780786f78..20428c222b4 100644
--- a/docs/api/paddle/nn/LogSoftmax_cn.rst
+++ b/docs/api/paddle/nn/LogSoftmax_cn.rst
@@ -15,7 +15,7 @@ LogSoftmax 激活层，计算公式如下：
 
 参数
 :::::::::
-    - **axis** (int，可选) - 指定对输入 Tensor 进行运算的轴。``axis`` 的有效范围是[-D, D)，D 是输入 Tensor 的维度，``axis`` 为负值时与 :math:`axis + D` 等价。默认值为-1。
+    - **axis** (int，可选) - 指定对输入 Tensor 进行运算的轴。 ``axis``  的有效范围是[-D, D)，D 是输入 Tensor 的维度， ``axis``  为负值时与 :math:`axis + D` 等价。默认值为-1。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
diff --git a/docs/api/paddle/nn/MarginRankingLoss_cn.rst b/docs/api/paddle/nn/MarginRankingLoss_cn.rst
index 8838b47be3d..87d5bde4020 100644
--- a/docs/api/paddle/nn/MarginRankingLoss_cn.rst
+++ b/docs/api/paddle/nn/MarginRankingLoss_cn.rst
@@ -5,29 +5,29 @@ MarginRankingLoss
 
 .. py:class:: paddle.nn.MarginRankingLoss(margin=0.0, reduction='mean', name=None)
 
-创建一个 ``MarginRankingLoss`` 的可调用类，计算输入 input，other 和 标签 label 间的 `margin rank loss` 损失。
+创建一个  ``MarginRankingLoss``  的可调用类，计算输入 input，other 和 标签 label 间的 `margin rank loss` 损失。
 
 该损失函数的数学计算公式如下：
 
  .. math::
      margin\_rank\_loss = max(0, -label * (input - other) + margin)
 
-当 `reduction` 设置为 ``'mean'`` 时，
+当 `reduction` 设置为  ``'mean'``  时，
 
     .. math::
        Out = MEAN(margin\_rank\_loss)
 
-当 `reduction` 设置为 ``'sum'`` 时，
+当 `reduction` 设置为  ``'sum'``  时，
 
     .. math::
        Out = SUM(margin\_rank\_loss)
 
-当 `reduction` 设置为 ``'none'`` 时，直接返回最原始的 `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`` 。
+    - **reduction** （string，可选） - 指定应用于输出结果的计算方式，可选值有： ``none``  、  ``mean``  、  ``sum`` 。如果设置为  ``none`` ，则直接返回 最原始的  ``margin_rank_loss`` 。如果设置为  ``sum`` ，则返回  ``margin_rank_loss``  的总和。如果设置为  ``mean`` ，则返回  ``margin_rank_loss``  的平均值。默认值为  ``none``  。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
@@ -35,7 +35,7 @@ MarginRankingLoss
     - **input** ：N-D Tensor，维度是[N，*] 其中 N 是 batch size，`*` 是任意数量的额外维度，数据类型为 float32 或 float64。
     - **other** ：与 input 的形状、数据类型相同。
     - **label** ：与 input 的形状、数据类型相同。
-    - **output** ：如果 :attr:`reduction` 为 ``'sum'`` 或者是 ``'mean'``，则形状为 :math:`[]`，否则 shape 和输入 `input` 保持一致。数据类型与 ``input``、 ``other`` 相同。
+    - **output** ：如果 :attr:`reduction` 为  ``'sum'``  或者是  ``'mean'`` ，则形状为 :math:`[]`，否则 shape 和输入 `input` 保持一致。数据类型与  ``input`` 、  ``other``  相同。
 
 返回
 ::::::::
diff --git a/docs/api/paddle/nn/MultiHeadAttention_cn.rst b/docs/api/paddle/nn/MultiHeadAttention_cn.rst
index 4684dbb6190..ef3136b1704 100644
--- a/docs/api/paddle/nn/MultiHeadAttention_cn.rst
+++ b/docs/api/paddle/nn/MultiHeadAttention_cn.rst
@@ -20,11 +20,11 @@ MultiHeadAttention
     - **embed_dim** (int) - 输入输出的维度。
     - **num_heads** (int) - 多头注意力机制的 Head 数量。
     - **dropout** (float，可选) - 注意力目标的随机失活率。0 表示不加 dropout。默认值：0。
-    - **kdim** (int，可选) - 键值对中 key 的维度。如果为 ``None`` 则 ``kdim = embed_dim``。默认值：``None``。
-    - **vdim** (int，可选) - 键值对中 value 的维度。如果为 ``None`` 则 ``vdim = embed_dim``。默认值：``None``。
-    - **need_weights** (bool，可选) - 表明是否返回注意力权重。默认值：``False``。
-    - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值：``None``，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** （ParamAttr，可选）- 指定偏置参数属性的对象。默认值：``None``，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **kdim** (int，可选) - 键值对中 key 的维度。如果为  ``None``  则  ``kdim = embed_dim`` 。默认值： ``None`` 。
+    - **vdim** (int，可选) - 键值对中 value 的维度。如果为  ``None``  则  ``vdim = embed_dim`` 。默认值： ``None`` 。
+    - **need_weights** (bool，可选) - 表明是否返回注意力权重。默认值： ``False`` 。
+    - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值： ``None`` ，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** （ParamAttr，可选）- 指定偏置参数属性的对象。默认值： ``None`` ，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/MultiLabelMarginLoss_cn.rst b/docs/api/paddle/nn/MultiLabelMarginLoss_cn.rst
index 88ff2039138..d3112f30818 100644
--- a/docs/api/paddle/nn/MultiLabelMarginLoss_cn.rst
+++ b/docs/api/paddle/nn/MultiLabelMarginLoss_cn.rst
@@ -18,7 +18,7 @@ MultiLabelMarginLoss
 
 参数
 :::::::::
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：``'none'``、``'mean'``、``'sum'``。默认为 ``'mean'``，计算 Loss 的均值；设置为 ``'sum'`` 时，计算 Loss 的总和；设置为 ``'none'`` 时，则返回原始 Loss。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'`` 、 ``'mean'`` 、 ``'sum'`` 。默认为  ``'mean'`` ，计算 Loss 的均值；设置为  ``'sum'``  时，计算 Loss 的总和；设置为  ``'none'``  时，则返回原始 Loss。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 调用参数
@@ -30,7 +30,7 @@ MultiLabelMarginLoss
 :::::::::
     - **input** (Tensor) - :math:`[N, C]`，其中 N 是 batch_size， C 是类别数量。
     - **label** (Tensor) - :math:`[N, C]`，与 input 形状相同。
-    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是 ``'none'``，则输出的维度为 :math:`[N]`。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出的维度为 :math:`[]` 。
+    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是  ``'none'`` ，则输出的维度为 :math:`[N]`。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出的维度为 :math:`[]` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/nn/MultiLabelSoftMarginLoss_cn.rst b/docs/api/paddle/nn/MultiLabelSoftMarginLoss_cn.rst
index ae8b2c5025d..ec1b1dae141 100644
--- a/docs/api/paddle/nn/MultiLabelSoftMarginLoss_cn.rst
+++ b/docs/api/paddle/nn/MultiLabelSoftMarginLoss_cn.rst
@@ -25,19 +25,19 @@ MultiLabelSoftMarginLoss
 参数
 :::::::::
     - **weight** (Tensor，可选) - 手动设定权重，默认为 None
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有: ``'none'``, ``'mean'``, ``'sum'`` 。默认为 ``'mean'``，计算 Loss 的均值；设置为 ``'sum'`` 时，计算 Loss 的总和；设置为 ``'none'`` 时，则返回原始 Loss。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有:  ``'none'`` ,  ``'mean'`` ,  ``'sum'``  。默认为  ``'mean'`` ，计算 Loss 的均值；设置为  ``'sum'``  时，计算 Loss 的总和；设置为  ``'none'``  时，则返回原始 Loss。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 输入
 :::::::::
     - **input** (Tensor)：输入 Tensor，维度是 [N, *], 其中 N 是 batch size， `*` 是任意数量的额外维度。数据类型为：float32、float64。
-    - **label** (Tensor)：标签，维度是 [N, *], 与 ``input`` 相同，Tensor 中的值应该只包含 1 和 -1。数据类型为：float32、float64。
+    - **label** (Tensor)：标签，维度是 [N, *], 与  ``input``  相同，Tensor 中的值应该只包含 1 和 -1。数据类型为：float32、float64。
 
 形状
 :::::::::
     - **input** (Tensor)： :math:`[N, *]` , 其中 N 是 batch_size， `*` 是任意其他维度。数据类型是 float32、float64。
-    - **label** (Tensor)： :math:`[N, *]` ，标签 ``label`` 的维度、数据类型与输入 ``input`` 相同。
-    - **output** (Tensor)： 输出的 Tensor。如果 :attr:`reduction` 是 ``'none'``, 则输出的维度为 :math:`[N, *]` , 与输入 ``input`` 的形状相同。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``, 则输出的维度为 :math:`[]` 。
+    - **label** (Tensor)： :math:`[N, *]` ，标签  ``label``  的维度、数据类型与输入  ``input``  相同。
+    - **output** (Tensor)： 输出的 Tensor。如果 :attr:`reduction` 是  ``'none'`` , 则输出的维度为 :math:`[N, *]` , 与输入  ``input``  的形状相同。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` , 则输出的维度为 :math:`[]` 。
 
 
 返回
diff --git a/docs/api/paddle/nn/MultiMarginLoss_cn.rst b/docs/api/paddle/nn/MultiMarginLoss_cn.rst
index 86f898ece31..58e6abe1922 100644
--- a/docs/api/paddle/nn/MultiMarginLoss_cn.rst
+++ b/docs/api/paddle/nn/MultiMarginLoss_cn.rst
@@ -26,7 +26,7 @@ MultiMarginLoss
     - **p** (int，可选) - 手动指定幂次方指数大小，默认为 1。
     - **margin** (float，可选) - 手动指定间距，默认为 1。
     - **weight** (Tensor，可选) - 权重值，默认为 None。 如果给定权重则形状为 :math:`[C, ]`
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：``'none'``、``'mean'``、``'sum'``。默认为 ``'mean'``，计算 Loss 的均值；设置为 ``'sum'`` 时，计算 Loss 的总和；设置为 ``'none'`` 时，则返回原始 Loss。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'`` 、 ``'mean'`` 、 ``'sum'`` 。默认为  ``'mean'`` ，计算 Loss 的均值；设置为  ``'sum'``  时，计算 Loss 的总和；设置为  ``'none'``  时，则返回原始 Loss。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 调用参数
@@ -38,7 +38,7 @@ MultiMarginLoss
 :::::::::
     - **input** (Tensor) - :math:`[N, C]`，其中 N 是 batch_size， C 是类别数量。
     - **label** (Tensor) - :math:`[N, ]`。
-    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是 ``'none'``，则输出的维度为 :math:`[N, ]`。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出的维度为 :math:`[]` 。
+    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是  ``'none'`` ，则输出的维度为 :math:`[N, ]`。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出的维度为 :math:`[]` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/nn/Overview_cn.rst b/docs/api/paddle/nn/Overview_cn.rst
index e1644dffc61..d477a098cfe 100644
--- a/docs/api/paddle/nn/Overview_cn.rst
+++ b/docs/api/paddle/nn/Overview_cn.rst
@@ -517,7 +517,7 @@ Embedding 相关函数
     " :ref:`paddle.nn.functional.sigmoid_focal_loss <cn_api_paddle_nn_functional_sigmoid_focal_loss>` ", "用于计算分类任务中前景类-背景类数量不均衡问题的损失"
     " :ref:`paddle.nn.functional.smooth_l1_loss <cn_api_paddle_nn_functional_smooth_l1_loss>` ", "用于计算平滑 L1 损失"
     " :ref:`paddle.nn.functional.softmax_with_cross_entropy <cn_api_paddle_nn_functional_softmax_with_cross_entropy>` ", "将 softmax 操作、交叉熵损失函数的计算过程进行合并"
-    " :ref:`paddle.nn.functional.margin_cross_entropy <cn_api_paddle_nn_functional_margin_cross_entropy>` ", "支持 ``Arcface``，``Cosface``，``Sphereface`` 的结合 Margin 损失函数"
+    " :ref:`paddle.nn.functional.margin_cross_entropy <cn_api_paddle_nn_functional_margin_cross_entropy>` ", "支持  ``Arcface`` ， ``Cosface`` ， ``Sphereface``  的结合 Margin 损失函数"
     " :ref:`paddle.nn.functional.soft_margin_loss <cn_api_paddle_nn_functional_soft_margin_loss>` ", "用于计算 soft margin loss 损失函数"
     " :ref:`paddle.nn.functional.triplet_margin_loss <cn_api_paddle_nn_functional_triplet_margin_loss>` ", "用于计算 TripletMarginLoss"
     " :ref:`paddle.nn.functional.triplet_margin_with_distance_loss <cn_api_paddle_nn_functional_triplet_margin_with_distance_loss>` ", "用户自定义距离函数用于计算 triplet margin loss 损失"
diff --git a/docs/api/paddle/nn/Pad1D_cn.rst b/docs/api/paddle/nn/Pad1D_cn.rst
index 0a37ec4ed84..1f9370f8852 100644
--- a/docs/api/paddle/nn/Pad1D_cn.rst
+++ b/docs/api/paddle/nn/Pad1D_cn.rst
@@ -10,15 +10,15 @@ Pad1D
 ::::::::::::
 
   - **padding** (Tensor|list[int]|int) - 填充大小。如果是 int，则在所有待填充边界使用相同的填充，否则填充的格式为[pad_left, pad_right]。
-  - **mode** (str，可选) - padding 的四种模式，分别为 ``'constant'``、``'reflect'``、``'replicate'`` 和 ``'circular'``，默认值为 ``'constant'``。
+  - **mode** (str，可选) - padding 的四种模式，分别为  ``'constant'`` 、 ``'reflect'`` 、 ``'replicate'``  和  ``'circular'`` ，默认值为  ``'constant'`` 。
 
-     - ``'constant'`` 表示填充常数 ``value``；
-     - ``'reflect'`` 表示填充以输入边界值为轴的映射；
-     - ``'replicate'`` 表示填充输入边界值；
-     - ``'circular'`` 为循环填充输入。
+     -  ``'constant'``  表示填充常数  ``value`` ；
+     -  ``'reflect'``  表示填充以输入边界值为轴的映射；
+     -  ``'replicate'``  表示填充输入边界值；
+     -  ``'circular'``  为循环填充输入。
 
-  - **value** (float，可选) - 以 ``'constant'`` 模式填充区域时填充的值。默认值为 :math:`0.0`。
-  - **data_format** (str，可选)  - 指定输入的数据格式，可为 ``'NCL'`` 或者 ``'NLC'`` ，默认值为 ``'NCL'``。
+  - **value** (float，可选) - 以  ``'constant'``  模式填充区域时填充的值。默认值为 :math:`0.0`。
+  - **data_format** (str，可选)  - 指定输入的数据格式，可为  ``'NCL'``  或者  ``'NLC'``  ，默认值为  ``'NCL'`` 。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/nn/Pad2D_cn.rst b/docs/api/paddle/nn/Pad2D_cn.rst
index 7b11f11aa5b..8b1b8a9af2b 100644
--- a/docs/api/paddle/nn/Pad2D_cn.rst
+++ b/docs/api/paddle/nn/Pad2D_cn.rst
@@ -10,15 +10,15 @@ Pad2D
 ::::::::::::
 
   - **padding** (Tensor|list[int]|int]) - 填充大小。如果是 int，则在所有待填充边界使用相同的填充，否则填充的格式为[pad_left, pad_right, pad_top, pad_bottom]。
-  - **mode** (str，可选) - padding 的四种模式，分别为 ``'constant'``、``'reflect'``、``'replicate'`` 和 ``'circular'``，默认值为 ``'constant'``。
+  - **mode** (str，可选) - padding 的四种模式，分别为  ``'constant'`` 、 ``'reflect'`` 、 ``'replicate'``  和  ``'circular'`` ，默认值为  ``'constant'`` 。
 
-     - ``'constant'`` 表示填充常数 ``value``；
-     - ``'reflect'`` 表示填充以输入边界值为轴的映射；
-     - ``'replicate'`` 表示填充输入边界值；
-     - ``'circular'`` 为循环填充输入。
+     -  ``'constant'``  表示填充常数  ``value`` ；
+     -  ``'reflect'``  表示填充以输入边界值为轴的映射；
+     -  ``'replicate'``  表示填充输入边界值；
+     -  ``'circular'``  为循环填充输入。
 
-  - **value** (float，可选) - 以 ``'constant'`` 模式填充区域时填充的值。默认值为 :math:`0.0`。
-  - **data_format** (str，可选)  - 指定输入的数据格式，可为 ``'NCHW'`` 或者 ``'NHWC'``，默认值为 ``'NCHW'``。
+  - **value** (float，可选) - 以  ``'constant'``  模式填充区域时填充的值。默认值为 :math:`0.0`。
+  - **data_format** (str，可选)  - 指定输入的数据格式，可为  ``'NCHW'``  或者  ``'NHWC'`` ，默认值为  ``'NCHW'`` 。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/nn/Pad3D_cn.rst b/docs/api/paddle/nn/Pad3D_cn.rst
index aa12d54bb44..90ae6658540 100644
--- a/docs/api/paddle/nn/Pad3D_cn.rst
+++ b/docs/api/paddle/nn/Pad3D_cn.rst
@@ -10,15 +10,15 @@ Pad3D
 ::::::::::::
 
   - **padding** (Tensor|list[int]|int) - 填充大小。如果是 int，则在所有待填充边界使用相同的填充，否则填充的格式为[pad_left, pad_right, pad_top, pad_bottom, pad_front, pad_back]。
-  - **mode** (str，可选) - padding 的四种模式，分别为 ``'constant'``、``'reflect'``、``'replicate'`` 和 ``'circular'``，默认值为 ``'constant'``。
+  - **mode** (str，可选) - padding 的四种模式，分别为  ``'constant'`` 、 ``'reflect'`` 、 ``'replicate'``  和  ``'circular'`` ，默认值为  ``'constant'`` 。
 
-     - ``'constant'`` 表示填充常数 ``value``；
-     - ``'reflect'`` 表示填充以输入边界值为轴的映射；
-     - ``'replicate'`` 表示填充输入边界值；
-     - ``'circular'`` 为循环填充输入。
+     -  ``'constant'``  表示填充常数  ``value`` ；
+     -  ``'reflect'``  表示填充以输入边界值为轴的映射；
+     -  ``'replicate'``  表示填充输入边界值；
+     -  ``'circular'``  为循环填充输入。
 
-  - **value** (float，可选) - 以 ``'constant'`` 模式填充区域时填充的值。默认值为 :math:`0.0`。
-  - **data_format** (str，可选)  - 指定输入的数据格式，可为 ``'NCDHW'`` 或者 ``'NDHWC'``，默认值为 ``'NCDHW'``。
+  - **value** (float，可选) - 以  ``'constant'``  模式填充区域时填充的值。默认值为 :math:`0.0`。
+  - **data_format** (str，可选)  - 指定输入的数据格式，可为  ``'NCDHW'``  或者  ``'NDHWC'`` ，默认值为  ``'NCDHW'`` 。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/nn/PairwiseDistance_cn.rst b/docs/api/paddle/nn/PairwiseDistance_cn.rst
index 99142122a97..42a1530d517 100644
--- a/docs/api/paddle/nn/PairwiseDistance_cn.rst
+++ b/docs/api/paddle/nn/PairwiseDistance_cn.rst
@@ -5,7 +5,7 @@ PairwiseDistance
 
 .. py:class:: paddle.nn.PairwiseDistance(p=2., epsilon=1e-6, keepdim=False, name=None)
 
-计算两组向量（输入 ``x``、``y``）两两之间的距离。该距离通过 p 范数计算：
+计算两组向量（输入  ``x`` 、 ``y`` ）两两之间的距离。该距离通过 p 范数计算：
 
 .. math::
 
diff --git a/docs/api/paddle/nn/PoissonNLLLoss_cn.rst b/docs/api/paddle/nn/PoissonNLLLoss_cn.rst
index 55785eb79bb..4ad061fc00e 100644
--- a/docs/api/paddle/nn/PoissonNLLLoss_cn.rst
+++ b/docs/api/paddle/nn/PoissonNLLLoss_cn.rst
@@ -16,7 +16,7 @@ PoissonNLLLoss
 .. math::
     \text{loss}(\text{input}, \text{label}) = \text{input} - \text{label} * \log(\text{input}+\text{epsilon}) + \log(\text{label!})
 
-其中 `epsilon` 是 ``True`` 时使用的常数小量，使得 loss 计算过程中不会导致对 0 求对数情况的出现。
+其中 `epsilon` 是  ``True``  时使用的常数小量，使得 loss 计算过程中不会导致对 0 求对数情况的出现。
 当 `log_input` 设置为 `False` 时，损失函数的数学计算公式为：
 
 .. math::
@@ -31,10 +31,10 @@ PoissonNLLLoss
 
 参数
 :::::::::
-    - **log_input** (bool，可选) - 输入是否为对数函数映射后结果，默认值为 ``True``。
-    - **full** (bool，可选) - 是否在损失计算中包括 Stirling 近似项。默认值为 ``False``。
-    - **epsilon** (float，可选) - 在 :attr:`log_input` 为 ``True`` 时使用的常数小量。默认值为 1e-8。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有 ``none``、``mean`` 和 ``sum``。默认为 ``mean``，计算 ``mini-batch`` loss 均值。设置为 ``sum`` 时，计算 ``mini-batch`` loss 的总和。设置为 ``none`` 时，则返回 loss Tensor。默认值下为 ``mean``。
+    - **log_input** (bool，可选) - 输入是否为对数函数映射后结果，默认值为  ``True`` 。
+    - **full** (bool，可选) - 是否在损失计算中包括 Stirling 近似项。默认值为  ``False`` 。
+    - **epsilon** (float，可选) - 在 :attr:`log_input` 为  ``True``  时使用的常数小量。默认值为 1e-8。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有  ``none`` 、 ``mean``  和  ``sum`` 。默认为  ``mean`` ，计算  ``mini-batch``  loss 均值。设置为  ``sum``  时，计算  ``mini-batch``  loss 的总和。设置为  ``none``  时，则返回 loss Tensor。默认值下为  ``mean`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为 None。
 
 形状
diff --git a/docs/api/paddle/nn/RNNTLoss_cn.rst b/docs/api/paddle/nn/RNNTLoss_cn.rst
index 88c30ed1e83..b3fc149a59b 100644
--- a/docs/api/paddle/nn/RNNTLoss_cn.rst
+++ b/docs/api/paddle/nn/RNNTLoss_cn.rst
@@ -12,7 +12,7 @@ RNNTLoss
 :::::::::
     - **blank** (int，可选) - 空格标记的 ID 值，其取值范围为 [0, num_classes + 1)。数据类型支持 int32。默认值为 0。
     - **fastemit_lambda** (float，默认 0.001) - FastEmit 的正则化参数(https://arxiv.org/pdf/2010.11148.pdf)。
-    - **reduction** (str，可选) - 表示如何平均损失，候选是 ``'none'``|``'mean'``|``'sum'`` 。如果是 ``'mean'`` ，输出将是损失的总和并除以 batch_size;如果是 ``'sum'``，返回损失的总和;如果为 ``'none'``，则不应用 reduction。默认是 ``'mean'``。
+    - **reduction** (str，可选) - 表示如何平均损失，候选是  ``'none'`` | ``'mean'`` | ``'sum'``  。如果是  ``'mean'``  ，输出将是损失的总和并除以 batch_size;如果是  ``'sum'`` ，返回损失的总和;如果为  ``'none'`` ，则不应用 reduction。默认是  ``'mean'`` 。
     - **name** (str，可选) - 操作名称，默认为 None。
 
 形状
@@ -24,7 +24,7 @@ RNNTLoss
 
 返回
 :::::::::
-``Tensor``，输入 ``input`` 和标签 ``labels`` 间的 `rnnt loss`。如果 :attr:`reduction` 是 ``'none'``，则输出 loss 的维度为 [batch_size]。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出 Loss 的维度为 []。数据类型与输入的 ``input`` 一致。
+ ``Tensor`` ，输入  ``input``  和标签  ``labels``  间的 `rnnt loss`。如果 :attr:`reduction` 是  ``'none'`` ，则输出 loss 的维度为 [batch_size]。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出 Loss 的维度为 []。数据类型与输入的  ``input``  一致。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/Sigmoid_cn.rst b/docs/api/paddle/nn/Sigmoid_cn.rst
index 4b841e7abde..f3442defd37 100644
--- a/docs/api/paddle/nn/Sigmoid_cn.rst
+++ b/docs/api/paddle/nn/Sigmoid_cn.rst
@@ -5,7 +5,7 @@ Sigmoid
 
 .. py:class:: paddle.nn.Sigmoid(name=None)
 
-用于创建一个 ``Sigmoid`` 的可调用类。这个类可以计算输入 :attr:`x` 经过激活函数 ``sigmoid`` 之后的值。
+用于创建一个  ``Sigmoid``  的可调用类。这个类可以计算输入 :attr:`x` 经过激活函数  ``sigmoid``  之后的值。
 
     .. math::
 
@@ -24,7 +24,7 @@ Sigmoid
 返回
 ::::::::
 
-返回计算 ``Sigmoid`` 的可调用对象。
+返回计算  ``Sigmoid``  的可调用对象。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/SmoothL1Loss_cn.rst b/docs/api/paddle/nn/SmoothL1Loss_cn.rst
index 36f978f9603..85e89dd3bb5 100644
--- a/docs/api/paddle/nn/SmoothL1Loss_cn.rst
+++ b/docs/api/paddle/nn/SmoothL1Loss_cn.rst
@@ -22,7 +22,7 @@ SmoothL1Loss
 参数
 ::::::::::
 
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有 ``none``、``mean`` 和 ``sum``。默认为 ``mean``，计算 ``mini-batch`` loss 均值。设置为 `sum` 时，计算 `mini-batch` loss 的总和。设置为 ``none`` 时，则返回 loss Tensor。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有  ``none`` 、 ``mean``  和  ``sum`` 。默认为  ``mean`` ，计算  ``mini-batch``  loss 均值。设置为 `sum` 时，计算 `mini-batch` loss 的总和。设置为  ``none``  时，则返回 loss Tensor。
     - **delta** (str，可选) - SmoothL1Loss 损失的阈值参数 :math:`\delta`，用于控制 Huber 损失对线性误差或平方误差的侧重。数据类型为 float32。默认值为 :math:`1.0`。
     - **is_huber** (bool，可选) - 如果为 True，则使用 Huber 损失。如果为 False, 则使用 Huber 损失除以 delta 值。默认为 True。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
diff --git a/docs/api/paddle/nn/SoftMarginLoss_cn.rst b/docs/api/paddle/nn/SoftMarginLoss_cn.rst
index ec7826ba66f..5a3a231ab54 100644
--- a/docs/api/paddle/nn/SoftMarginLoss_cn.rst
+++ b/docs/api/paddle/nn/SoftMarginLoss_cn.rst
@@ -19,14 +19,14 @@ SoftMarginLoss
 
 参数
 :::::::::
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有: ``'none'``, ``'mean'``, ``'sum'`` 。默认为 ``'mean'``，计算 Loss 的均值；设置为 ``'sum'`` 时，计算 Loss 的总和；设置为 ``'none'`` 时，则返回原始 Loss。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有:  ``'none'`` ,  ``'mean'`` ,  ``'sum'``  。默认为  ``'mean'`` ，计算 Loss 的均值；设置为  ``'sum'``  时，计算 Loss 的总和；设置为  ``'none'``  时，则返回原始 Loss。
     - **name** (str，可选) - 操作的名称（可选，默认值为 None）。更多信息请参见 :ref:`api_guide_Name` 。
 
 形状
 :::::::::
     - **input** (Tensor) - :math:`[N, *]` , 其中 N 是 batch_size， `*` 是任意其他维度。数据类型是 float32、float64。
-    - **label** (Tensor) - :math:`[N, *]` ，标签 ``label`` 的维度、数据类型与输入 ``input`` 相同。
-    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是 ``'none'``，则输出的维度为 :math:`[N, *]`，与输入 ``input`` 的形状相同。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出的维度为 :math:`[]` 。
+    - **label** (Tensor) - :math:`[N, *]` ，标签  ``label``  的维度、数据类型与输入  ``input``  相同。
+    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是  ``'none'`` ，则输出的维度为 :math:`[N, *]`，与输入  ``input``  的形状相同。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出的维度为 :math:`[]` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/nn/Softmax2D_cn.rst b/docs/api/paddle/nn/Softmax2D_cn.rst
index 788c785d214..091178f3a76 100644
--- a/docs/api/paddle/nn/Softmax2D_cn.rst
+++ b/docs/api/paddle/nn/Softmax2D_cn.rst
@@ -4,7 +4,7 @@ Softmax2D
 -------------------------------
 .. py:class:: paddle.nn.Softmax2D(name=None)
 
-Softmax2D 是 Softmax 的变体，其针对 3D 或者 4D 的 ``Tensor`` 在空间维度上计算 Softmax。具体来说，输出的 ``Tensor`` 的每个空间维度 :math:`(channls, h_i, w_j)` 求和为 1。
+Softmax2D 是 Softmax 的变体，其针对 3D 或者 4D 的  ``Tensor``  在空间维度上计算 Softmax。具体来说，输出的  ``Tensor``  的每个空间维度 :math:`(channls, h_i, w_j)` 求和为 1。
 
 Softmax 的详细介绍请参考 :ref:`cn_api_paddle_nn_Softmax`
 
diff --git a/docs/api/paddle/nn/Softmax_cn.rst b/docs/api/paddle/nn/Softmax_cn.rst
index 032f7e4036f..4881b78aff3 100644
--- a/docs/api/paddle/nn/Softmax_cn.rst
+++ b/docs/api/paddle/nn/Softmax_cn.rst
@@ -82,7 +82,7 @@ Softmax 激活层，计算过程如下：
 
 参数
 ::::::::::
-    - **axis** (int，可选) - 指定对输入 Tensor 进行运算的轴。:attr:`axis` 的有效范围是 :math:`[-D, D)`，:math:`D` 是输入 Tensor 的维度，``axis`` 为负值时与 :math:`axis + D` 等价。默认值为 -1。
+    - **axis** (int，可选) - 指定对输入 Tensor 进行运算的轴。:attr:`axis` 的有效范围是 :math:`[-D, D)`，:math:`D` 是输入 Tensor 的维度， ``axis``  为负值时与 :math:`axis + D` 等价。默认值为 -1。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
diff --git a/docs/api/paddle/nn/SpectralNorm_cn.rst b/docs/api/paddle/nn/SpectralNorm_cn.rst
index 0421a9c00b3..5e088120407 100644
--- a/docs/api/paddle/nn/SpectralNorm_cn.rst
+++ b/docs/api/paddle/nn/SpectralNorm_cn.rst
@@ -6,11 +6,11 @@ SpectralNorm
 .. py:class:: paddle.nn.SpectralNorm(weight_shape, dim=0, power_iters=1, eps=1e-12, name=None, dtype="float32")
 
 
-构建 ``SpectralNorm`` 类的一个可调用对象，具体用法参照 ``代码示例``。其中实现了谱归一化层的功能，用于计算 fc、conv1d、conv2d、conv3d 层的权重参数的谱正则值，输入权重参数应分别为 2-D, 3-D, 4-D, 5-D Tensor，输出 Tensor 与输入 Tensor 维度相同。谱特征值计算方式如下：
+构建  ``SpectralNorm``  类的一个可调用对象，具体用法参照  ``代码示例`` 。其中实现了谱归一化层的功能，用于计算 fc、conv1d、conv2d、conv3d 层的权重参数的谱正则值，输入权重参数应分别为 2-D, 3-D, 4-D, 5-D Tensor，输出 Tensor 与输入 Tensor 维度相同。谱特征值计算方式如下：
 
-步骤 1：生成形状为[H]的向量 U，以及形状为[W]的向量 V，其中 H 是输入权重 Tensor 的第 ``dim`` 个维度，W 是剩余维度的乘积。
+步骤 1：生成形状为[H]的向量 U，以及形状为[W]的向量 V，其中 H 是输入权重 Tensor 的第  ``dim``  个维度，W 是剩余维度的乘积。
 
-步骤 2： ``power_iters`` 应该是一个正整数，用 U 和 V 迭代计算 ``power_iters`` 轮，迭代步骤如下。
+步骤 2：  ``power_iters``  应该是一个正整数，用 U 和 V 迭代计算  ``power_iters``  轮，迭代步骤如下。
 
 .. math::
 
@@ -30,8 +30,8 @@ SpectralNorm
 
     - **weight_shape** (list 或 tuple) - 权重参数的 shape。
     - **dim** (int，可选) - 将输入（weight）重塑为矩阵之前应排列到第一个的维度索引，如果 input（weight）是 fc 层的权重，则应设置为 0；如果 input（weight）是 conv 层的权重，则应设置为 1。默认值：0。
-    - **power_iters** (int，可选) - 将用于计算的 ``SpectralNorm`` 功率迭代次数，默认值：1。
-    - **eps** (float，可选) -  ``eps`` 用于保证计算规范中的数值稳定性，分母会加上 ``eps`` 防止除零。默认值：1e-12。
+    - **power_iters** (int，可选) - 将用于计算的  ``SpectralNorm``  功率迭代次数，默认值：1。
+    - **eps** (float，可选) -   ``eps``  用于保证计算规范中的数值稳定性，分母会加上  ``eps``  防止除零。默认值：1e-12。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 数据类型，可以为"float32"或"float64"。默认值为"float32"。
 
diff --git a/docs/api/paddle/nn/SyncBatchNorm_cn.rst b/docs/api/paddle/nn/SyncBatchNorm_cn.rst
index 494cd1ddb63..28a964da67a 100644
--- a/docs/api/paddle/nn/SyncBatchNorm_cn.rst
+++ b/docs/api/paddle/nn/SyncBatchNorm_cn.rst
@@ -5,7 +5,7 @@ SyncBatchNorm
 
 .. py:class:: paddle.nn.SyncBatchNorm(num_features, epsilon=1e-5, momentum=0.9, weight_attr=None, bias_attr=None, data_format='NCHW', name=None)
 
-构建 ``SyncBatchNorm`` 类的一个可调用对象，具体用法参照 ``代码示例``。实现了跨卡 GPU 同步的批归一化(Cross-GPU Synchronized Batch Normalization Layer)的功能，可用在其他层（类似卷积层和全连接层）之后进行归一化操作。根据所有 GPU 同一批次的数据按照通道计算的均值和方差进行归一化。更多详情请参考：`Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/pdf/1502.03167.pdf>`_
+构建  ``SyncBatchNorm``  类的一个可调用对象，具体用法参照  ``代码示例`` 。实现了跨卡 GPU 同步的批归一化(Cross-GPU Synchronized Batch Normalization Layer)的功能，可用在其他层（类似卷积层和全连接层）之后进行归一化操作。根据所有 GPU 同一批次的数据按照通道计算的均值和方差进行归一化。更多详情请参考：`Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/pdf/1502.03167.pdf>`_
 
 当模型处于训练模式时，:math:`\mu_{\beta}` 和 :math:`\sigma_{\beta}^{2}` 是所有 GPU 上同一 minibatch 的统计数据。计算公式如下：
 
@@ -36,22 +36,22 @@ SyncBatchNorm
 
 .. note::
 
-    如果您想用容器封装您的模型，而且您的模型在预测阶段中包含 ``SyncBatchNorm`` 这个算子的话，请使用 ``nn.LayerList`` 或者 ``nn.Sequential`` 而不要直接使用 ``list`` 来封装模型。
+    如果您想用容器封装您的模型，而且您的模型在预测阶段中包含  ``SyncBatchNorm``  这个算子的话，请使用  ``nn.LayerList``  或者  ``nn.Sequential``  而不要直接使用  ``list``  来封装模型。
 
 参数
 ::::::::::::
 
-    - **num_features** (int) - 指明输入 ``Tensor`` 的通道数量。
+    - **num_features** (int) - 指明输入  ``Tensor``  的通道数量。
     - **epsilon** (float，可选) - 为了数值稳定加在分母上的值。默认值：1e-05。
-    - **momentum** (float，可选) - 此值用于计算 ``moving_mean`` 和 ``moving_var``。默认值：0.9。更新公式如上所示。
-    - **weight_attr** (ParamAttr|bool，可选) - 指定权重参数属性的对象。如果设置为 ``False``，则表示本层没有可训练的权重参数。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** (ParamAttr|bool，可选) - 指定偏置参数属性的对象。如果设置为 ``False``，则表示本层没有可训练的偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **momentum** (float，可选) - 此值用于计算  ``moving_mean``  和  ``moving_var`` 。默认值：0.9。更新公式如上所示。
+    - **weight_attr** (ParamAttr|bool，可选) - 指定权重参数属性的对象。如果设置为  ``False`` ，则表示本层没有可训练的权重参数。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** (ParamAttr|bool，可选) - 指定偏置参数属性的对象。如果设置为  ``False`` ，则表示本层没有可训练的偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
 
 形状
 ::::::::::::
 
-    - input：一个二维到五维的 ``Tensor`` 。
-    - output：和 input 相同形状的 ``Tensor`` 。
+    - input：一个二维到五维的  ``Tensor``  。
+    - output：和 input 相同形状的  ``Tensor``  。
 
 代码示例
 ::::::::::::
@@ -63,17 +63,17 @@ COPY-FROM: paddle.nn.SyncBatchNorm
 convert_sync_batchnorm(layer)
 '''''''''''''''''''''''''''''
 
-把 ``BatchNorm*d`` 层转换为 ``SyncBatchNorm`` 层。
+把  ``BatchNorm*d``  层转换为  ``SyncBatchNorm``  层。
 
 参数
 ::::::::::::
 
-    - **layer** (paddle.nn.Layer) - 包含一个或多个 ``BatchNorm*d`` 层的模型。
+    - **layer** (paddle.nn.Layer) - 包含一个或多个  ``BatchNorm*d``  层的模型。
 
 返回
 ::::::::::::
 
-    如果原始模型中有 ``BatchNorm*d`` 层，则把 ``BatchNorm*d`` 层转换为 ``SyncBatchNorm`` 层的原始模型。
+    如果原始模型中有  ``BatchNorm*d``  层，则把  ``BatchNorm*d``  层转换为  ``SyncBatchNorm``  层的原始模型。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/nn/ThresholdedReLU_cn.rst b/docs/api/paddle/nn/ThresholdedReLU_cn.rst
index df16432fdbf..9d7381fa68c 100644
--- a/docs/api/paddle/nn/ThresholdedReLU_cn.rst
+++ b/docs/api/paddle/nn/ThresholdedReLU_cn.rst
@@ -21,7 +21,7 @@ Thresholded ReLU 激活层
 参数
 ::::::::::
     - **threshold** (float，可选) - ThresholdedReLU 激活计算公式中的 threshold 值。默认值为 1.0。
-    - **value** (float，可选) - 当 ``x`` 小于 ``threshold`` 时的替换值。默认值为 0.0。
+    - **value** (float，可选) - 当  ``x``  小于  ``threshold``  时的替换值。默认值为 0.0。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
diff --git a/docs/api/paddle/nn/TransformerDecoderLayer_cn.rst b/docs/api/paddle/nn/TransformerDecoderLayer_cn.rst
index e5c9e07e510..9b86ac7b426 100644
--- a/docs/api/paddle/nn/TransformerDecoderLayer_cn.rst
+++ b/docs/api/paddle/nn/TransformerDecoderLayer_cn.rst
@@ -9,7 +9,7 @@ TransformerDecoderLayer
 
 **Transformer 解码器层**
 
-Transformer 解码器层由三个子层组成：多头自注意力机制、编码-解码交叉注意力机制（encoder-decoder cross attention）和前馈神经网络。如果 ``normalize_before`` 为 ``True``，则对每个子层的输入进行层标准化（Layer Normalization），对每个子层的输出进行 dropout 和残差连接（residual connection）。否则（即 ``normalize_before`` 为 ``False``），则对每个子层的输入不进行处理，只对每个子层的输出进行 dropout、残差连接（residual connection）和层标准化（Layer Normalization）。
+Transformer 解码器层由三个子层组成：多头自注意力机制、编码-解码交叉注意力机制（encoder-decoder cross attention）和前馈神经网络。如果  ``normalize_before``  为  ``True`` ，则对每个子层的输入进行层标准化（Layer Normalization），对每个子层的输出进行 dropout 和残差连接（residual connection）。否则（即  ``normalize_before``  为  ``False`` ），则对每个子层的输入不进行处理，只对每个子层的输出进行 dropout、残差连接（residual connection）和层标准化（Layer Normalization）。
 
 
 参数
@@ -19,13 +19,13 @@ Transformer 解码器层由三个子层组成：多头自注意力机制、编
     - **nhead** (int) - 多头注意力机制的 Head 数量。
     - **dim_feedforward** (int) - 前馈神经网络中隐藏层的大小。
     - **dropout** (float，可选) - 对三个子层的输出进行处理的 dropout 值。默认值：0.1。
-    - **activation** (str，可选) - 前馈神经网络的激活函数。默认值：``relu``。
-    - **attn_dropout** (float，可选) - 多头自注意力机制中对注意力目标的随机失活率。如果为 ``None`` 则 ``attn_dropout = dropout``。默认值：``None``。
-    - **act_dropout** (float，可选) - 前馈神经网络的激活函数后的 dropout。如果为 ``None`` 则 ``act_dropout = dropout``。默认值：``None``。
-    - **normalize_before** (bool，可选) - 设置对每个子层的输入输出的处理。如果为 ``True``，则对每个子层的输入进行层标准化（Layer Normalization），对每个子层的输出进行 dropout 和残差连接（residual connection）。否则（即为 ``False``），则对每个子层的输入不进行处理，只对每个子层的输出进行 dropout、残差连接（residual connection）和层标准化（Layer Normalization）。默认值：``False``。
-    - **weight_attr** (ParamAttr|tuple，可选) - 指定权重参数属性的对象。如果是 ``tuple``，多头自注意力机制的权重参数属性使用 ``weight_attr[0]``，编码-解码交叉注意力机制的权重参数属性使用 ``weight_attr[1]``，前馈神经网络的权重参数属性使用 ``weight_attr[2]``。如果该值是 ``ParamAttr``，则多头自注意力机制、编码-解码交叉注意力机制和前馈神经网络的权重参数属性都使用 ``ParamAttr``。默认值：``None``，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** （ParamAttr|tuple|bool，可选）- 指定偏置参数属性的对象。如果是 ``tuple``，多头自注意力机制的偏置参数属性使用 ``bias_attr[0]``，编码-解码交叉注意力机制的偏置参数属性使用 ``bias_attr[1]``，前馈神经网络的偏置参数属性使用 ``bias_attr[2]``。如果该值是 ``ParamAttr``，则多头自注意力机制、编码-解码交叉注意力机制和前馈神经网络的偏置参数属性都使用 ``ParamAttr``。如果该参数为 ``bool`` 类型，只支持为 ``False``，表示没有偏置参数。默认值：``None``，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **layer_norm_eps** （float，可选）- transformer decoder 中 layer normalization 层的 ``eps`` 参数值。默认是 1e-5。
+    - **activation** (str，可选) - 前馈神经网络的激活函数。默认值： ``relu`` 。
+    - **attn_dropout** (float，可选) - 多头自注意力机制中对注意力目标的随机失活率。如果为  ``None``  则  ``attn_dropout = dropout`` 。默认值： ``None`` 。
+    - **act_dropout** (float，可选) - 前馈神经网络的激活函数后的 dropout。如果为  ``None``  则  ``act_dropout = dropout`` 。默认值： ``None`` 。
+    - **normalize_before** (bool，可选) - 设置对每个子层的输入输出的处理。如果为  ``True`` ，则对每个子层的输入进行层标准化（Layer Normalization），对每个子层的输出进行 dropout 和残差连接（residual connection）。否则（即为  ``False`` ），则对每个子层的输入不进行处理，只对每个子层的输出进行 dropout、残差连接（residual connection）和层标准化（Layer Normalization）。默认值： ``False`` 。
+    - **weight_attr** (ParamAttr|tuple，可选) - 指定权重参数属性的对象。如果是  ``tuple`` ，多头自注意力机制的权重参数属性使用  ``weight_attr[0]`` ，编码-解码交叉注意力机制的权重参数属性使用  ``weight_attr[1]`` ，前馈神经网络的权重参数属性使用  ``weight_attr[2]`` 。如果该值是  ``ParamAttr`` ，则多头自注意力机制、编码-解码交叉注意力机制和前馈神经网络的权重参数属性都使用  ``ParamAttr`` 。默认值： ``None`` ，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** （ParamAttr|tuple|bool，可选）- 指定偏置参数属性的对象。如果是  ``tuple`` ，多头自注意力机制的偏置参数属性使用  ``bias_attr[0]`` ，编码-解码交叉注意力机制的偏置参数属性使用  ``bias_attr[1]`` ，前馈神经网络的偏置参数属性使用  ``bias_attr[2]`` 。如果该值是  ``ParamAttr`` ，则多头自注意力机制、编码-解码交叉注意力机制和前馈神经网络的偏置参数属性都使用  ``ParamAttr`` 。如果该参数为  ``bool``  类型，只支持为  ``False`` ，表示没有偏置参数。默认值： ``None`` ，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **layer_norm_eps** （float，可选）- transformer decoder 中 layer normalization 层的  ``eps``  参数值。默认是 1e-5。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/TransformerDecoder_cn.rst b/docs/api/paddle/nn/TransformerDecoder_cn.rst
index e4e71039914..b7f9f71b15c 100644
--- a/docs/api/paddle/nn/TransformerDecoder_cn.rst
+++ b/docs/api/paddle/nn/TransformerDecoder_cn.rst
@@ -9,14 +9,14 @@ TransformerDecoder
 
 **Transformer 解码器**
 
-Transformer 解码器由多个 Transformer 解码器层（``TransformerDecoderLayer``）叠加组成的。
+Transformer 解码器由多个 Transformer 解码器层（ ``TransformerDecoderLayer`` ）叠加组成的。
 
 
 参数
 ::::::::::::
 
-    - **decoder_layer** (Layer) - ``TransformerDecoderLayer`` 的一个实例，作为 Transformer 解码器的第一层，其他层将根据它的配置进行构建。
-    - **num_layers** (int) - ``TransformerDecoderLayer`` 层的叠加数量。
+    - **decoder_layer** (Layer) -  ``TransformerDecoderLayer``  的一个实例，作为 Transformer 解码器的第一层，其他层将根据它的配置进行构建。
+    - **num_layers** (int) -  ``TransformerDecoderLayer``  层的叠加数量。
     - **norm** (LayerNorm，可选) - 层标准化（Layer Normalization）。如果提供该参数，将对解码器的最后一层的输出进行层标准化。
 
 
diff --git a/docs/api/paddle/nn/TransformerEncoderLayer_cn.rst b/docs/api/paddle/nn/TransformerEncoderLayer_cn.rst
index 7e9cfbac9f5..ef55b4c6d82 100644
--- a/docs/api/paddle/nn/TransformerEncoderLayer_cn.rst
+++ b/docs/api/paddle/nn/TransformerEncoderLayer_cn.rst
@@ -9,7 +9,7 @@ TransformerEncoderLayer
 
 **Transformer 编码器层**
 
-Transformer 编码器层由两个子层组成：多头自注意力机制和前馈神经网络。如果 ``normalize_before`` 为 ``True``，则对每个子层的输入进行层标准化（Layer Normalization），对每个子层的输出进行 dropout 和残差连接（residual connection）。否则（即 ``normalize_before`` 为 ``False``），则对每个子层的输入不进行处理，只对每个子层的输出进行 dropout、残差连接（residual connection）和层标准化（Layer Normalization）。
+Transformer 编码器层由两个子层组成：多头自注意力机制和前馈神经网络。如果  ``normalize_before``  为  ``True`` ，则对每个子层的输入进行层标准化（Layer Normalization），对每个子层的输出进行 dropout 和残差连接（residual connection）。否则（即  ``normalize_before``  为  ``False`` ），则对每个子层的输入不进行处理，只对每个子层的输出进行 dropout、残差连接（residual connection）和层标准化（Layer Normalization）。
 
 
 参数
@@ -19,13 +19,13 @@ Transformer 编码器层由两个子层组成：多头自注意力机制和前
     - **nhead** (int) - 多头注意力机制的 Head 数量。
     - **dim_feedforward** (int) - 前馈神经网络中隐藏层的大小。
     - **dropout** (float，可选) - 对两个子层的输出进行处理的 dropout 值。默认值：0.1。
-    - **activation** (str，可选) - 前馈神经网络的激活函数。默认值：``relu``。
-    - **attn_dropout** (float，可选) - 多头自注意力机制中对注意力目标的随机失活率。如果为 ``None`` 则 ``attn_dropout = dropout``。默认值：``None``。
-    - **act_dropout** (float，可选) - 前馈神经网络的激活函数后的 dropout。如果为 ``None`` 则 ``act_dropout = dropout``。默认值：``None``。
-    - **normalize_before** (bool，可选) - 设置对每个子层的输入输出的处理。如果为 ``True``，则对每个子层的输入进行层标准化（Layer Normalization），对每个子层的输出进行 dropout 和残差连接（residual connection）。否则（即为 ``False``），则对每个子层的输入不进行处理，只对每个子层的输出进行 dropout、残差连接（residual connection）和层标准化（Layer Normalization）。默认值：``False``。
-    - **weight_attr** (ParamAttr|list|tuple，可选) - 指定权重参数属性的对象。如果是 ``list/tuple``，多头自注意力机制的权重参数属性使用 ``weight_attr[0]``，前馈神经网络的权重参数属性使用 ``weight_attr[1]``。如果参数值是 ``ParamAttr``，则多头自注意力机制和前馈神经网络的权重参数属性都使用 ``ParamAttr``。默认值：``None``，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** （ParamAttr|list|tuple|bool，可选）- 指定偏置参数属性的对象。如果是 ``list/tuple``，多头自注意力机制的偏置参数属性使用 ``bias_attr[0]``，前馈神经网络的偏置参数属性使用 ``bias_attr[1]``。如果该参数值是 ``ParamAttr``，则多头自注意力机制和前馈神经网络的偏置参数属性都使用 ``ParamAttr``。如果该参数为 ``bool`` 类型，只支持为 ``False``，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **layer_norm_eps** （float，可选）- transformer encoder 中 layer normalization 层的 ``eps`` 参数值。默认是 1e-5。
+    - **activation** (str，可选) - 前馈神经网络的激活函数。默认值： ``relu`` 。
+    - **attn_dropout** (float，可选) - 多头自注意力机制中对注意力目标的随机失活率。如果为  ``None``  则  ``attn_dropout = dropout`` 。默认值： ``None`` 。
+    - **act_dropout** (float，可选) - 前馈神经网络的激活函数后的 dropout。如果为  ``None``  则  ``act_dropout = dropout`` 。默认值： ``None`` 。
+    - **normalize_before** (bool，可选) - 设置对每个子层的输入输出的处理。如果为  ``True`` ，则对每个子层的输入进行层标准化（Layer Normalization），对每个子层的输出进行 dropout 和残差连接（residual connection）。否则（即为  ``False`` ），则对每个子层的输入不进行处理，只对每个子层的输出进行 dropout、残差连接（residual connection）和层标准化（Layer Normalization）。默认值： ``False`` 。
+    - **weight_attr** (ParamAttr|list|tuple，可选) - 指定权重参数属性的对象。如果是  ``list/tuple`` ，多头自注意力机制的权重参数属性使用  ``weight_attr[0]`` ，前馈神经网络的权重参数属性使用  ``weight_attr[1]`` 。如果参数值是  ``ParamAttr`` ，则多头自注意力机制和前馈神经网络的权重参数属性都使用  ``ParamAttr`` 。默认值： ``None`` ，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** （ParamAttr|list|tuple|bool，可选）- 指定偏置参数属性的对象。如果是  ``list/tuple`` ，多头自注意力机制的偏置参数属性使用  ``bias_attr[0]`` ，前馈神经网络的偏置参数属性使用  ``bias_attr[1]`` 。如果该参数值是  ``ParamAttr`` ，则多头自注意力机制和前馈神经网络的偏置参数属性都使用  ``ParamAttr`` 。如果该参数为  ``bool``  类型，只支持为  ``False`` ，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **layer_norm_eps** （float，可选）- transformer encoder 中 layer normalization 层的  ``eps``  参数值。默认是 1e-5。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/TransformerEncoder_cn.rst b/docs/api/paddle/nn/TransformerEncoder_cn.rst
index e18e6310828..4ad4c0a3005 100644
--- a/docs/api/paddle/nn/TransformerEncoder_cn.rst
+++ b/docs/api/paddle/nn/TransformerEncoder_cn.rst
@@ -9,14 +9,14 @@ TransformerEncoder
 
 **Transformer 编码器**
 
-Transformer 编码器由多个 Transformer 编码器层（``TransformerEncoderLayer``）叠加组成的。
+Transformer 编码器由多个 Transformer 编码器层（ ``TransformerEncoderLayer`` ）叠加组成的。
 
 
 参数
 ::::::::::::
 
-    - **encoder_layer** (Layer) - ``TransformerEncoderLayer`` 的一个实例，作为 Transformer 编码器的第一层，其他层将根据它的配置进行构建。
-    - **num_layers** (int) - ``TransformerEncoderLayer`` 层的叠加数量。
+    - **encoder_layer** (Layer) -  ``TransformerEncoderLayer``  的一个实例，作为 Transformer 编码器的第一层，其他层将根据它的配置进行构建。
+    - **num_layers** (int) -  ``TransformerEncoderLayer``  层的叠加数量。
     - **norm** (LayerNorm，可选) - 层标准化（Layer Normalization）。如果提供该参数，将对编码器的最后一层的输出进行层标准化。
 
 
diff --git a/docs/api/paddle/nn/Transformer_cn.rst b/docs/api/paddle/nn/Transformer_cn.rst
index 32259beb07d..c1b7199ef37 100644
--- a/docs/api/paddle/nn/Transformer_cn.rst
+++ b/docs/api/paddle/nn/Transformer_cn.rst
@@ -9,11 +9,11 @@ Transformer
 
 **Transformer 模型**
 
-Transformer 模型由一个 ``TransformerEncoder`` 实例和一个 ``TransformerDecoder`` 实例组成，不包含 embedding 层和输出层。
+Transformer 模型由一个  ``TransformerEncoder``  实例和一个  ``TransformerDecoder``  实例组成，不包含 embedding 层和输出层。
 
 细节可参考论文 `Attention is all you need <https://arxiv.org/pdf/1706.03762.pdf>`_ 。
 
-用户可以使用相应的参数配置模型结构。请注意 ``normalize_before`` 的用法与某些类似 Transformer 的模型例如 BERT 和 GPT2 的用法不同，它表示在哪里（多头注意力机制或前馈神经网络的输入还是输出）进行层标准化（Layer Normalization）。该模型默认的结构是对每个子层的 output 进行层归一化，并在最后一个编码器/解码器的输出上进行另一个层归一化操作。
+用户可以使用相应的参数配置模型结构。请注意  ``normalize_before``  的用法与某些类似 Transformer 的模型例如 BERT 和 GPT2 的用法不同，它表示在哪里（多头注意力机制或前馈神经网络的输入还是输出）进行层标准化（Layer Normalization）。该模型默认的结构是对每个子层的 output 进行层归一化，并在最后一个编码器/解码器的输出上进行另一个层归一化操作。
 
 
 参数
@@ -21,18 +21,18 @@ Transformer 模型由一个 ``TransformerEncoder`` 实例和一个 ``Transformer
 
     - **d_model** (int，可选) - 编码器和解码器的输入输出的维度。默认值：512。
     - **nhead** (int，可选) - 多头注意力机制的 Head 数量。默认值：8。
-    - **num_encoder_layers** (int，可选) - 编码器中 ``TransformerEncoderLayer`` 的层数。默认值：6。
-    - **num_decoder_layers** (int，可选) - 解码器中 ``TransformerDecoderLayer`` 的层数。默认值：6。
+    - **num_encoder_layers** (int，可选) - 编码器中  ``TransformerEncoderLayer``  的层数。默认值：6。
+    - **num_decoder_layers** (int，可选) - 解码器中  ``TransformerDecoderLayer``  的层数。默认值：6。
     - **dim_feedforward** (int，可选) - 前馈神经网络中隐藏层的大小。默认值：2048。
     - **dropout** (float，可选) - 对编码器和解码器中每个子层的输出进行处理的 dropout 值。默认值：0.1。
-    - **activation** (str，可选) - 前馈神经网络的激活函数。默认值：``relu``。
-    - **attn_dropout** (float，可选) - 多头自注意力机制中对注意力目标的随机失活率。如果为 ``None`` 则 ``attn_dropout = dropout``。默认值：``None``。
-    - **act_dropout** (float，可选) - 前馈神经网络的激活函数后的 dropout。如果为 ``None`` 则 ``act_dropout = dropout``。默认值：``None``。
-    - **normalize_before** (bool，可选) - 设置对编码器解码器的每个子层的输入输出的处理。如果为 ``True``，则对每个子层的输入进行层标准化（Layer Normalization），对每个子层的输出进行 dropout 和残差连接（residual connection）。否则（即为 ``False``），则对每个子层的输入不进行处理，只对每个子层的输出进行 dropout、残差连接（residual connection）和层标准化（Layer Normalization）。默认值：``False``。
-    - **weight_attr** (ParamAttr|tuple，可选) - 指定权重参数属性的对象。如果是 ``tuple``，则只支持 ``tuple`` 长度为 1、2 或 3 的情况。如果 ``tuple`` 长度为 3，多头自注意力机制的权重参数属性使用 ``weight_attr[0]``，解码器的编码-解码交叉注意力机制的权重参数属性使用 ``weight_attr[1]``，前馈神经网络的权重参数属性使用 ``weight_attr[2]``；如果 ``tuple`` 的长度是 2，多头自注意力机制和解码器的编码-解码交叉注意力机制的权重参数属性使用 ``weight_attr[0]``，前馈神经网络的权重参数属性使用 ``weight_attr[1]``；如果 ``tuple`` 的长度是 1，多头自注意力机制、解码器的编码-解码交叉注意力机制和前馈神经网络的权重参数属性都使用 ``weight_attr[0]``。如果该参数值是 ``ParamAttr``，则多头自注意力机制、解码器的编码-解码交叉注意力机制和前馈神经网络的权重参数属性都使用 ``ParamAttr``。默认值：``None``，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** （ParamAttr|tuple|bool，可选）- 指定偏置参数属性的对象。如果是 ``tuple``，则只支持 ``tuple`` 长度为 1、2 或 3 的情况。如果 ``tuple`` 长度为 3，多头自注意力机制的偏置参数属性使用 ``bias_attr[0]``，解码器的编码-解码交叉注意力机制的偏置参数属性使用 ``bias_attr[1]``，前馈神经网络的偏置参数属性使用 ``bias_attr[2]``；如果 ``tuple`` 的长度是 2，多头自注意力机制和解码器的编码-解码交叉注意力机制的偏置参数属性使用 ``bias_attr[0]``，前馈神经网络的偏置参数属性使用 ``bias_attr[1]``；如果 ``tuple`` 的长度是 1，多头自注意力机制、解码器的编码-解码交叉注意力机制和前馈神经网络的偏置参数属性都使用 ``bias_attr[0]``。如果该参数值是 ``ParamAttr``，则多头自注意力机制、解码器的编码-解码交叉注意力机制和前馈神经网络的偏置参数属性都使用 ``ParamAttr``。如果该参数为 ``bool`` 类型，只支持为 ``False``，表示没有偏置参数。默认值：``None``，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **custom_encoder** (Layer，可选) - 若提供该参数，则将 ``custom_encoder`` 作为编码器。默认值：``None``。
-    - **custom_decoder** (Layer，可选) - 若提供该参数，则将 ``custom_decoder`` 作为解码器。默认值：``None``。
+    - **activation** (str，可选) - 前馈神经网络的激活函数。默认值： ``relu`` 。
+    - **attn_dropout** (float，可选) - 多头自注意力机制中对注意力目标的随机失活率。如果为  ``None``  则  ``attn_dropout = dropout`` 。默认值： ``None`` 。
+    - **act_dropout** (float，可选) - 前馈神经网络的激活函数后的 dropout。如果为  ``None``  则  ``act_dropout = dropout`` 。默认值： ``None`` 。
+    - **normalize_before** (bool，可选) - 设置对编码器解码器的每个子层的输入输出的处理。如果为  ``True`` ，则对每个子层的输入进行层标准化（Layer Normalization），对每个子层的输出进行 dropout 和残差连接（residual connection）。否则（即为  ``False`` ），则对每个子层的输入不进行处理，只对每个子层的输出进行 dropout、残差连接（residual connection）和层标准化（Layer Normalization）。默认值： ``False`` 。
+    - **weight_attr** (ParamAttr|tuple，可选) - 指定权重参数属性的对象。如果是  ``tuple`` ，则只支持  ``tuple``  长度为 1、2 或 3 的情况。如果  ``tuple``  长度为 3，多头自注意力机制的权重参数属性使用  ``weight_attr[0]`` ，解码器的编码-解码交叉注意力机制的权重参数属性使用  ``weight_attr[1]`` ，前馈神经网络的权重参数属性使用  ``weight_attr[2]`` ；如果  ``tuple``  的长度是 2，多头自注意力机制和解码器的编码-解码交叉注意力机制的权重参数属性使用  ``weight_attr[0]`` ，前馈神经网络的权重参数属性使用  ``weight_attr[1]`` ；如果  ``tuple``  的长度是 1，多头自注意力机制、解码器的编码-解码交叉注意力机制和前馈神经网络的权重参数属性都使用  ``weight_attr[0]`` 。如果该参数值是  ``ParamAttr`` ，则多头自注意力机制、解码器的编码-解码交叉注意力机制和前馈神经网络的权重参数属性都使用  ``ParamAttr`` 。默认值： ``None`` ，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** （ParamAttr|tuple|bool，可选）- 指定偏置参数属性的对象。如果是  ``tuple`` ，则只支持  ``tuple``  长度为 1、2 或 3 的情况。如果  ``tuple``  长度为 3，多头自注意力机制的偏置参数属性使用  ``bias_attr[0]`` ，解码器的编码-解码交叉注意力机制的偏置参数属性使用  ``bias_attr[1]`` ，前馈神经网络的偏置参数属性使用  ``bias_attr[2]`` ；如果  ``tuple``  的长度是 2，多头自注意力机制和解码器的编码-解码交叉注意力机制的偏置参数属性使用  ``bias_attr[0]`` ，前馈神经网络的偏置参数属性使用  ``bias_attr[1]`` ；如果  ``tuple``  的长度是 1，多头自注意力机制、解码器的编码-解码交叉注意力机制和前馈神经网络的偏置参数属性都使用  ``bias_attr[0]`` 。如果该参数值是  ``ParamAttr`` ，则多头自注意力机制、解码器的编码-解码交叉注意力机制和前馈神经网络的偏置参数属性都使用  ``ParamAttr`` 。如果该参数为  ``bool``  类型，只支持为  ``False`` ，表示没有偏置参数。默认值： ``None`` ，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **custom_encoder** (Layer，可选) - 若提供该参数，则将  ``custom_encoder``  作为编码器。默认值： ``None`` 。
+    - **custom_decoder** (Layer，可选) - 若提供该参数，则将  ``custom_decoder``  作为解码器。默认值： ``None`` 。
 
 
 代码示例
@@ -50,16 +50,16 @@ forward(self, src, tgt, src_mask=None, tgt_mask=None, memory_mask=None)
 
 **参数**
 
-    - **src** (Tensor) - Transformer 编码器的输入。它的形状应该是 ``[batch_size, source_length, d_model]``。数据类型为 float32 或是 float64。
-    - **tgt** (Tensor) - Transformer 解码器的输入。它的形状应该是 ``[batch_size, target_length, d_model]]``。数据类型为 float32 或是 float64。
-    - **src_mask** (Tensor，可选) - 在编码器的多头注意力机制(Multi-head Attention)中，用于避免注意到序列中无关的位置的表示的 Tensor。它的形状应该是，或者能被广播到 ``[batch_size, nhead, source_length, source_length]``。当 ``src_mask`` 的数据类型是 ``bool`` 时，无关的位置所对应的值应该为 ``False`` 并且其余为 ``True``。当 ``src_mask`` 的数据类型为 ``int`` 时，无关的位置所对应的值应该为 0 并且其余为 1。当 ``src_mask`` 的数据类型为 ``float`` 时，无关的位置所对应的值应该为 ``-INF`` 并且其余为 0。当输入中不包含无关项的时候，当前值可以为 ``None``，表示不做 mask 操作。默认值为 ``None``。
-    - **tgt_mask** (Tensor，可选) - 在解码器的自注意力机制(Self Attention)中，用于避免注意到序列中无关的位置的表示的 Tensor。它的形状应该是，或者能被广播到 ``[batch_size, nhead, target_length, target_length]``。当 ``src_mask`` 的数据类型是 ``bool`` 时，无关的位置所对应的值应该为 ``False`` 并且其余为 ``True``。当 ``src_mask`` 的数据类型为 ``int`` 时，无关的位置所对应的值应该为 0 并且其余为 1。当 ``src_mask`` 的数据类型为 ``float`` 时，无关的位置所对应的值应该为 ``-INF`` 并且其余为 0。当输入中不包含无关项的时候，当前值可以为 ``None``，表示不做 mask 操作。默认值为 ``None``。
-    - **memory_mask** (Tensor，可选) - 在解码器的交叉注意力机制(Cross Attention)中，用于避免注意到序列中无关的位置的表示的 Tensor，通常情况下指的是 padding 的部分。它的形状应该是，或者能被广播到 ``[batch_size, nhead, target_length, source_length]``。当 ``src_mask`` 的数据类型是 ``bool`` 时，无关的位置所对应的值应该为 ``False`` 并且其余为 ``True``。当 ``src_mask`` 的数据类型为 ``int`` 时，无关的位置所对应的值应该为 0 并且其余为 1。当 ``src_mask`` 的数据类型为 ``float`` 时，无关的位置所对应的值应该为 ``-INF`` 并且其余为 0。当输入中不包含无关项的时候，当前值可以为 ``None``，表示不做 mask 操作。默认值为 ``None``。
+    - **src** (Tensor) - Transformer 编码器的输入。它的形状应该是  ``[batch_size, source_length, d_model]`` 。数据类型为 float32 或是 float64。
+    - **tgt** (Tensor) - Transformer 解码器的输入。它的形状应该是  ``[batch_size, target_length, d_model]]`` 。数据类型为 float32 或是 float64。
+    - **src_mask** (Tensor，可选) - 在编码器的多头注意力机制(Multi-head Attention)中，用于避免注意到序列中无关的位置的表示的 Tensor。它的形状应该是，或者能被广播到  ``[batch_size, nhead, source_length, source_length]`` 。当  ``src_mask``  的数据类型是  ``bool``  时，无关的位置所对应的值应该为  ``False``  并且其余为  ``True`` 。当  ``src_mask``  的数据类型为  ``int``  时，无关的位置所对应的值应该为 0 并且其余为 1。当  ``src_mask``  的数据类型为  ``float``  时，无关的位置所对应的值应该为  ``-INF``  并且其余为 0。当输入中不包含无关项的时候，当前值可以为  ``None`` ，表示不做 mask 操作。默认值为  ``None`` 。
+    - **tgt_mask** (Tensor，可选) - 在解码器的自注意力机制(Self Attention)中，用于避免注意到序列中无关的位置的表示的 Tensor。它的形状应该是，或者能被广播到  ``[batch_size, nhead, target_length, target_length]`` 。当  ``src_mask``  的数据类型是  ``bool``  时，无关的位置所对应的值应该为  ``False``  并且其余为  ``True`` 。当  ``src_mask``  的数据类型为  ``int``  时，无关的位置所对应的值应该为 0 并且其余为 1。当  ``src_mask``  的数据类型为  ``float``  时，无关的位置所对应的值应该为  ``-INF``  并且其余为 0。当输入中不包含无关项的时候，当前值可以为  ``None`` ，表示不做 mask 操作。默认值为  ``None`` 。
+    - **memory_mask** (Tensor，可选) - 在解码器的交叉注意力机制(Cross Attention)中，用于避免注意到序列中无关的位置的表示的 Tensor，通常情况下指的是 padding 的部分。它的形状应该是，或者能被广播到  ``[batch_size, nhead, target_length, source_length]`` 。当  ``src_mask``  的数据类型是  ``bool``  时，无关的位置所对应的值应该为  ``False``  并且其余为  ``True`` 。当  ``src_mask``  的数据类型为  ``int``  时，无关的位置所对应的值应该为 0 并且其余为 1。当  ``src_mask``  的数据类型为  ``float``  时，无关的位置所对应的值应该为  ``-INF``  并且其余为 0。当输入中不包含无关项的时候，当前值可以为  ``None`` ，表示不做 mask 操作。默认值为  ``None`` 。
 
 
 **返回**
 
-Tensor，Transformer 解码器的输出。其形状和数据类型与 ``tgt`` 相同。
+Tensor，Transformer 解码器的输出。其形状和数据类型与  ``tgt``  相同。
 
 
 
@@ -71,12 +71,12 @@ generate_square_subsequent_mask(self, length)
 
 **参数**
 
-    - **length** (int|Tensor) - 序列的长度，``length`` 的数据类型为 int32 或者 int64。若为 Tensor，则当前 Tensor 需仅包含一个数值。
+    - **length** (int|Tensor) - 序列的长度， ``length``  的数据类型为 int32 或者 int64。若为 Tensor，则当前 Tensor 需仅包含一个数值。
 
 
 **返回**
 
-Tensor，根据输入的 ``length`` 具体的大小生成的形状为 ``[length, length]`` 方形的掩码。
+Tensor，根据输入的  ``length``  具体的大小生成的形状为  ``[length, length]``  方形的掩码。
 
 
 **代码示例**
diff --git a/docs/api/paddle/nn/TripletMarginLoss_cn.rst b/docs/api/paddle/nn/TripletMarginLoss_cn.rst
index 9a3a5ac9c80..2157f561eb9 100644
--- a/docs/api/paddle/nn/TripletMarginLoss_cn.rst
+++ b/docs/api/paddle/nn/TripletMarginLoss_cn.rst
@@ -19,7 +19,7 @@ TripletMarginLoss
     d(x_i, y_i) = \left\lVert {\bf x}_i - {\bf y}_i \right\rVert_p
 
 
-``p`` 为距离函数的范数。``margin`` 为（input，positive）与（input，negative）的距离间隔，``swap`` 为 True 时，会比较（input，negative）和（positive，negative）的大小，并将（input，negative）换为其中较小的值，内容详见论文 `Learning shallow convolutional feature descriptors with triplet losses <http://www.bmva.org/bmvc/2016/papers/paper119/paper119.pdf>`_ 。
+ ``p``  为距离函数的范数。 ``margin``  为（input，positive）与（input，negative）的距离间隔， ``swap``  为 True 时，会比较（input，negative）和（positive，negative）的大小，并将（input，negative）换为其中较小的值，内容详见论文 `Learning shallow convolutional feature descriptors with triplet losses <http://www.bmva.org/bmvc/2016/papers/paper119/paper119.pdf>`_ 。
 
 参数
 :::::::::
@@ -27,15 +27,15 @@ TripletMarginLoss
     - **p** (float，可选) - 手动指定范数，默认为 2。
     - **epsilon** (float，可选) - 防止除数为 0，默认为 1e-6。
     - **swap** (bool，可选) - 默认为 False。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：``'none'``、``'mean'``、``'sum'``。默认为 ``'mean'``，计算 Loss 的均值；设置为 ``'sum'`` 时，计算 Loss 的总和；设置为 ``'none'`` 时，则返回原始 Loss。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'`` 、 ``'mean'`` 、 ``'sum'`` 。默认为  ``'mean'`` ，计算 Loss 的均值；设置为  ``'sum'``  时，计算 Loss 的总和；设置为  ``'none'``  时，则返回原始 Loss。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
 :::::::::
     - **input** (Tensor) - :math:`[N, *]`，其中 N 是 batch_size， `*` 是任意其他维度。数据类型是 float32、float64。
-    - **positive** (Tensor) - :math:`[N, *]`，标签 ``positive`` 的维度、数据类型与输入 ``input`` 相同。
-    - **negative** (Tensor) - :math:`[N, *]`，标签 ``negative`` 的维度、数据类型与输入 ``input`` 相同。
-    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是 ``'none'``，则输出的维度为 :math:`[N, *]`，与输入 ``input`` 的形状相同。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出的维度为 :math:`[]` 。
+    - **positive** (Tensor) - :math:`[N, *]`，标签  ``positive``  的维度、数据类型与输入  ``input``  相同。
+    - **negative** (Tensor) - :math:`[N, *]`，标签  ``negative``  的维度、数据类型与输入  ``input``  相同。
+    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是  ``'none'`` ，则输出的维度为 :math:`[N, *]`，与输入  ``input``  的形状相同。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出的维度为 :math:`[]` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/nn/TripletMarginWithDistanceLoss_cn.rst b/docs/api/paddle/nn/TripletMarginWithDistanceLoss_cn.rst
index e286e358a8f..422df6fe918 100644
--- a/docs/api/paddle/nn/TripletMarginWithDistanceLoss_cn.rst
+++ b/docs/api/paddle/nn/TripletMarginWithDistanceLoss_cn.rst
@@ -14,13 +14,13 @@ TripletMarginWithDistanceLoss
     L(input, pos, neg) = \max \{d(input_i, pos_i) - d(input_i, neg_i) + {\rm margin}, 0\}
 
 
-其中的距离函数 ``distance_function`` 可以由用户自定义，使用 lambda 或是 def 都可以。如果未定义则调用 2 范数计算距离
+其中的距离函数  ``distance_function``  可以由用户自定义，使用 lambda 或是 def 都可以。如果未定义则调用 2 范数计算距离
 
 .. math::
     d(x_i, y_i) = \left\lVert {\bf x}_i - {\bf y}_i \right\rVert_2
 
 
-``margin`` 为（input,positive）与（input,negative）的距离间隔，``swap`` 为 True 时，会比较（input，negative）和（positive，negative）的大小，并将（input，negative）的值换为其中较小的值，内容详见论文 `Learning shallow convolutional feature descriptors with triplet losses <http://www.bmva.org/bmvc/2016/papers/paper119/paper119.pdf>`_ 。
+ ``margin``  为（input,positive）与（input,negative）的距离间隔， ``swap``  为 True 时，会比较（input，negative）和（positive，negative）的大小，并将（input，negative）的值换为其中较小的值，内容详见论文 `Learning shallow convolutional feature descriptors with triplet losses <http://www.bmva.org/bmvc/2016/papers/paper119/paper119.pdf>`_ 。
 
 
 
@@ -29,15 +29,15 @@ TripletMarginWithDistanceLoss
     - **distance_function** (可选) - 手动指定范数，默认为 None，使用欧式距离。
     - **margin** (float，可选) - 手动指定间距，默认为 1。
     - **swap** (bool，可选) - 默认为 False。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：``'none'``， ``'mean'``， ``'sum'``。默认为 ``'mean'``，计算 Loss 的均值；设置为 ``'sum'`` 时，计算 Loss 的总和；设置为 ``'none'`` 时，则返回原始 Loss。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ，  ``'mean'`` ，  ``'sum'`` 。默认为  ``'mean'`` ，计算 Loss 的均值；设置为  ``'sum'``  时，计算 Loss 的总和；设置为  ``'none'``  时，则返回原始 Loss。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
 :::::::::
     - **input** (Tensor) - :math:`[N, *]`，其中 N 是 batch_size， `*` 是任意其他维度。数据类型是 float32、float64。
-    - **positive** (Tensor) - :math:`[N, *]`，标签 ``positive`` 的维度、数据类型与输入 ``input`` 相同。
-    - **negative** (Tensor) - :math:`[N, *]`，标签 ``negative`` 的维度、数据类型与输入 ``input`` 相同。
-    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是 ``'none'``，则输出的维度为 :math:`[N, *]`，与输入 ``input`` 的形状相同。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出的维度为 :math:`[]` 。
+    - **positive** (Tensor) - :math:`[N, *]`，标签  ``positive``  的维度、数据类型与输入  ``input``  相同。
+    - **negative** (Tensor) - :math:`[N, *]`，标签  ``negative``  的维度、数据类型与输入  ``input``  相同。
+    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是  ``'none'`` ，则输出的维度为 :math:`[N, *]`，与输入  ``input``  的形状相同。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出的维度为 :math:`[]` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/nn/Unflatten_cn.rst b/docs/api/paddle/nn/Unflatten_cn.rst
index eed84aee977..e93a0108876 100644
--- a/docs/api/paddle/nn/Unflatten_cn.rst
+++ b/docs/api/paddle/nn/Unflatten_cn.rst
@@ -7,14 +7,14 @@ Unflatten
 
 
 
-构造一个 ``Unflatten`` 类的可调用对象。更多信息请参见代码示例。将输入 Tensor 沿指定轴 axis 上的维度展成 shape 形状。
+构造一个  ``Unflatten``  类的可调用对象。更多信息请参见代码示例。将输入 Tensor 沿指定轴 axis 上的维度展成 shape 形状。
 
 
 参数
 ::::::::::::
 
-    - **axis** (int) - 要展开维度的轴，作为 ``x.shape`` 的索引。
-    - **shape** (list|tuple|Tensor) - 在指定轴上将该维度展成 ``shape``， 其中 ``shape`` 最多包含一个 -1，如果输入 ``shape`` 不包含 -1 ，则 ``shape`` 内元素累乘的结果应该等于 ``x.shape[axis]``。数据类型为 ``int``。如果 ``shape`` 的类型是 ``list`` 或 ``tuple``，它的元素可以是整数或者形状为[]的 ``Tensor`` （0-D ``Tensor``）。如果 ``shape`` 的类型是 ``Tensor``，则是 1-D 的 ``Tensor``。
+    - **axis** (int) - 要展开维度的轴，作为  ``x.shape``  的索引。
+    - **shape** (list|tuple|Tensor) - 在指定轴上将该维度展成  ``shape`` ， 其中  ``shape``  最多包含一个 -1，如果输入  ``shape``  不包含 -1 ，则  ``shape``  内元素累乘的结果应该等于  ``x.shape[axis]`` 。数据类型为  ``int`` 。如果  ``shape``  的类型是  ``list``  或  ``tuple`` ，它的元素可以是整数或者形状为[]的  ``Tensor``  （0-D  ``Tensor`` ）。如果  ``shape``  的类型是  ``Tensor`` ，则是 1-D 的  ``Tensor`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/nn/Unfold_cn.rst b/docs/api/paddle/nn/Unfold_cn.rst
index 7f1afed0957..e09c6ee520c 100644
--- a/docs/api/paddle/nn/Unfold_cn.rst
+++ b/docs/api/paddle/nn/Unfold_cn.rst
@@ -8,7 +8,7 @@ Unfold
 
 
 
-实现的功能与卷积中用到的 im2col 函数一样，通常也被称作为 im2col 过程。对于每一个卷积核覆盖下的区域，元素会被重新排成一列。当卷积核在整个图片上滑动时，将会形成一系列的列向量。对于每一个输入形状为[N, C, H, W]的 ``x``，都将会按照下面公式计算出一个形状为[N, Cout, Lout]的输出。
+实现的功能与卷积中用到的 im2col 函数一样，通常也被称作为 im2col 过程。对于每一个卷积核覆盖下的区域，元素会被重新排成一列。当卷积核在整个图片上滑动时，将会形成一系列的列向量。对于每一个输入形状为[N, C, H, W]的  ``x`` ，都将会按照下面公式计算出一个形状为[N, Cout, Lout]的输出。
 
 .. note::
    对应的 `functional 方法` 请参考：:ref:`cn_api_paddle_nn_functional_unfold`。
@@ -31,16 +31,16 @@ Unfold
 参数
 ::::::::::::
 
-    - **kernel_sizes**  (int|list(tuple) of int) – 卷积核的尺寸，整数或者整型列表。如果为整型列表，应包含两个元素 ``[k_h, k_w]``，卷积核大小为 ``k_h * k_w``；如果为整数 k，会被当作整型列表 ``[k, k]`` 处理
+    - **kernel_sizes**  (int|list(tuple) of int) – 卷积核的尺寸，整数或者整型列表。如果为整型列表，应包含两个元素  ``[k_h, k_w]`` ，卷积核大小为  ``k_h * k_w`` ；如果为整数 k，会被当作整型列表  ``[k, k]``  处理
     - **dilations** (int|list(tuple) of int，可选) – 卷积膨胀，整型列表或者整数。如果为整型列表，应该包含两个元素[dilation_h, dilation_w]。如果是整数 dilation，会被当作整型列表[dilation, dilation]处理。默认值为 1
     - **paddings** (int|list(tuple) of int，可选) – 每个维度的扩展，整数或者整型列表。如果为整型列表，长度应该为 4 或者 2；长度为 4 对应的 padding 参数是：[padding_top, padding_left，padding_bottom, padding_right]，长度为 2 对应的 padding 参数是[padding_h, padding_w]，会被当作[padding_h, padding_w, padding_h, padding_w]处理。如果为整数 padding，则会被当作[padding, padding, padding, padding]处理。默认值为 0
-    - **strides**  (int|list(tuple) of int，可选) – 卷积步长，整数或者整型列表。如果为整型列表，应该包含两个元素 ``[stride_h, stride_w]``。如果为整数，则 ``stride_h = stride_w = strides``。默认值为 1
+    - **strides**  (int|list(tuple) of int，可选) – 卷积步长，整数或者整型列表。如果为整型列表，应该包含两个元素  ``[stride_h, stride_w]`` 。如果为整数，则  ``stride_h = stride_w = strides`` 。默认值为 1
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
 :::::::::
  - **输入** : 4-D Tensor，形状为[N, C, H, W]，数据类型为 float32 或者 float64
- - **输出**：形状如上面所描述的[N, Cout, Lout]，Cout 每一个滑动 block 里面覆盖的元素个数，Lout 是滑动 block 的个数，数据类型与 ``x`` 相同
+ - **输出**：形状如上面所描述的[N, Cout, Lout]，Cout 每一个滑动 block 里面覆盖的元素个数，Lout 是滑动 block 的个数，数据类型与  ``x``  相同
 
 
 代码示例
diff --git a/docs/api/paddle/nn/Upsample_cn.rst b/docs/api/paddle/nn/Upsample_cn.rst
index ddf31a902e7..38e91a44626 100644
--- a/docs/api/paddle/nn/Upsample_cn.rst
+++ b/docs/api/paddle/nn/Upsample_cn.rst
@@ -155,7 +155,7 @@ https://en.wikipedia.org/wiki/Bicubic_interpolation
     - **mode** (str，可选) - 插值方法。支持"bilinear"或"trilinear"或"nearest"或"bicubic"或"linear"或"area"。默认值为"nearest"。
     - **align_corners** (bool，可选) - 一个可选的 bool 型参数，如果为 True，则将输入和输出 Tensor 的 4 个角落像素的中心对齐，并保留角点像素的值。默认值为 False。
     - **align_mode** (int，可选) - 双线性插值的可选项。可以是 '0' 代表 src_idx = scale *（dst_indx + 0.5）-0.5；如果为'1'，代表 src_idx = scale * dst_index。默认值为 0。
-    - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致。支持的值有："NCW"、"NWC"、"NCHW"、"NHWC"、"NCDHW"、"NDHWC"。默认值为 None，此时若输入是 3-D Tensor， ``data_format`` 将默认为"NCW"；若输入是 4—D Tensor, 将默认为"NCHW"；若输入是 5—D Tensor, 将默认为"NCDHW"。
+    - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致。支持的值有："NCW"、"NWC"、"NCHW"、"NHWC"、"NCDHW"、"NDHWC"。默认值为 None，此时若输入是 3-D Tensor，  ``data_format``  将默认为"NCW"；若输入是 4—D Tensor, 将默认为"NCHW"；若输入是 5—D Tensor, 将默认为"NCDHW"。
     - **recompute_scale_factor** (bool，可选) - 是否在插值计算中重新计算乘数因子。当设置为 True 时，必须提供 scale_factor 参数，函数会用 scale_factor 和输入张量的形状计算输出张量的形状，然后根据输出张量形状和输入张量形状重新计算乘数因子。该参数可用于 scale_factor 为浮点数的情况。当设置为 False 时，将直接使用 size 或 scale_factor 进行插值计算，不进行重新计算。默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/nn/UpsamplingBilinear2D_cn.rst b/docs/api/paddle/nn/UpsamplingBilinear2D_cn.rst
index 28f43f75a09..88b87e527f1 100644
--- a/docs/api/paddle/nn/UpsamplingBilinear2D_cn.rst
+++ b/docs/api/paddle/nn/UpsamplingBilinear2D_cn.rst
@@ -26,7 +26,7 @@ https://en.wikipedia.org/wiki/Bilinear_interpolation
 ::::::::::::
 
     - **size** (int|list|tuple|Tensor|None) - 输出 Tensor，输入为 4D Tensor，形状为为(out_h, out_w)的 2-D Tensor。如果 :code:`size` 是一个整形数，则 `out_h` 和 `out_w` 都为这个数。如果 :code:`size` 是列表，每一个元素可以是整数或者形状为[]的 0-D Tensor。如果 :code:`size` 是 Tensor，则其为 1D Tensor。默认值为 None。
-    - **scale_factor** (float|Tensor|list|tuple|None) - 输入的高度或宽度的乘数因子。``size`` 和 ``scale_factor`` 至少要设置一个。``size`` 的优先级高于 ``scale_factor``。默认值为 None。如果 ``scale_factor`` 是一个 list 或 tuple，它必须与输入的 shape 匹配。
+    - **scale_factor** (float|Tensor|list|tuple|None) - 输入的高度或宽度的乘数因子。 ``size``  和  ``scale_factor``  至少要设置一个。 ``size``  的优先级高于  ``scale_factor`` 。默认值为 None。如果  ``scale_factor``  是一个 list 或 tuple，它必须与输入的 shape 匹配。
     - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致。对于 4-D Tensor，支持 NCHW(num_batches, channels, height, width) 或者 NHWC(num_batches, height, width, channels)，默认值：'NCHW'。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/nn/UpsamplingNearest2D_cn.rst b/docs/api/paddle/nn/UpsamplingNearest2D_cn.rst
index db2b4f03511..97e765ffae3 100644
--- a/docs/api/paddle/nn/UpsamplingNearest2D_cn.rst
+++ b/docs/api/paddle/nn/UpsamplingNearest2D_cn.rst
@@ -53,8 +53,8 @@ https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation
 参数
 ::::::::::::
 
-    - **size** (int|list|tuple|Tensor|None) - 输出 Tensor，输入为 4D Tensor，形状为(out_h, out_w)的 2-D Tensor。如果 :code:`size` 是一个整形数，则 `out_h` 和 `out_w` 都为这个数。如果 :code:`size` 是列表，每一个元素可以是整数或者形状为[]的 0-D Tensor。如果 ``size`` 是 Tensor，则其为 1D Tensor。默认值为 None。
-    - **scale_factor** (float|Tensor|list|None) - 输入的高度或宽度的乘数因子。``size`` 和 ``scale_factor`` 至少要设置一个。``size`` 的优先级高于 ``scale_factor``。默认值为 None。如果 ``scale_factor`` 是一个 list 或 tuple，它必须与输入的 shape 匹配。
+    - **size** (int|list|tuple|Tensor|None) - 输出 Tensor，输入为 4D Tensor，形状为(out_h, out_w)的 2-D Tensor。如果 :code:`size` 是一个整形数，则 `out_h` 和 `out_w` 都为这个数。如果 :code:`size` 是列表，每一个元素可以是整数或者形状为[]的 0-D Tensor。如果  ``size``  是 Tensor，则其为 1D Tensor。默认值为 None。
+    - **scale_factor** (float|Tensor|list|None) - 输入的高度或宽度的乘数因子。 ``size``  和  ``scale_factor``  至少要设置一个。 ``size``  的优先级高于  ``scale_factor`` 。默认值为 None。如果  ``scale_factor``  是一个 list 或 tuple，它必须与输入的 shape 匹配。
     - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致。对于 4-D Tensor，支持 NCHW(num_batches, channels, height, width) 或者 NHWC(num_batches, height, width, channels)，默认值：'NCHW'。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/nn/ZeroPad1D_cn.rst b/docs/api/paddle/nn/ZeroPad1D_cn.rst
index 6773a902436..05b12d69e59 100644
--- a/docs/api/paddle/nn/ZeroPad1D_cn.rst
+++ b/docs/api/paddle/nn/ZeroPad1D_cn.rst
@@ -13,7 +13,7 @@ ZeroPad1D
 
   - **padding** (Tensor | List[int] | int) - 如果输入数据类型为 int，则在所有待填充边界使用相同的填充，
     否则填充的格式为[pad_left, pad_right]。
-  - **data_format** (str)  - 指定输入的 format，可为 ``'NCL'`` 或者 ``'NLC'``，默认值为 ``'NCL'``，其中 `N` 是 batch size， `C` 是通道数， `L` 输入特征的长度。
+  - **data_format** (str)  - 指定输入的 format，可为  ``'NCL'``  或者  ``'NLC'`` ，默认值为  ``'NCL'`` ，其中 `N` 是 batch size， `C` 是通道数， `L` 输入特征的长度。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
@@ -23,8 +23,8 @@ ZeroPad1D
 形状
 :::::::::
 
-  - x(Tensor): ZeroPadD 层的输入，要求形状为 3-D，dtype 为 ``'float32'`` 或 ``'float64'``
-  - output(Tensor)：输出，形状为 3-D，dtype 与 ``'input'`` 相同
+  - x(Tensor): ZeroPadD 层的输入，要求形状为 3-D，dtype 为  ``'float32'``  或  ``'float64'`` 
+  - output(Tensor)：输出，形状为 3-D，dtype 与  ``'input'``  相同
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/ZeroPad2D_cn.rst b/docs/api/paddle/nn/ZeroPad2D_cn.rst
index 0e5a99cac1e..79b93d4809b 100644
--- a/docs/api/paddle/nn/ZeroPad2D_cn.rst
+++ b/docs/api/paddle/nn/ZeroPad2D_cn.rst
@@ -13,7 +13,7 @@ ZeroPad2D
 
   - **padding** (Tensor | List[int] | int]) - 填充大小。如果是 int，则在所有待填充边界使用相同的填充，
     否则填充的格式为[pad_left, pad_right, pad_top, pad_bottom]。
-  - **data_format** (str)  - 指定输入的 format，可为 ``'NCHW'`` 或者 ``'NHWC'``，默认值为 ``'NCHW'``。
+  - **data_format** (str)  - 指定输入的 format，可为  ``'NCHW'``  或者  ``'NHWC'`` ，默认值为  ``'NCHW'`` 。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
@@ -23,8 +23,8 @@ ZeroPad2D
 形状
 :::::::::
 
-  - x(Tensor): ZeroPadD 层的输入，要求形状为 4-D，dtype 为 ``'float32'`` 或 ``'float64'``
-  - output(Tensor)：输出，形状为 4-D，dtype 与 ``'input'`` 相同
+  - x(Tensor): ZeroPadD 层的输入，要求形状为 4-D，dtype 为  ``'float32'``  或  ``'float64'`` 
+  - output(Tensor)：输出，形状为 4-D，dtype 与  ``'input'``  相同
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/ZeroPad3D_cn.rst b/docs/api/paddle/nn/ZeroPad3D_cn.rst
index 9e40c1de5dd..7a4426d81ee 100644
--- a/docs/api/paddle/nn/ZeroPad3D_cn.rst
+++ b/docs/api/paddle/nn/ZeroPad3D_cn.rst
@@ -13,7 +13,7 @@ ZeroPad3D
 
   - **padding** (Tensor | List[int] | int) - 如果输入数据类型为 int，则在所有待填充边界使用相同的填充，
     否则填充的格式为[pad_left, pad_right, pad_top, pad_bottom, pad_front, pad_back]。
-  - **data_format** (str，可选)  - 指定输入的 format，可为 ``'NCDHW'`` 或者 ``'NDHWC'``，默认值为 ``'NCDHW'``，其中 `N` 是批尺寸， `C` 是通道数， `D` 是特征层深度， `H` 是特征层高度， `W` 是特征层宽度。。
+  - **data_format** (str，可选)  - 指定输入的 format，可为  ``'NCDHW'``  或者  ``'NDHWC'`` ，默认值为  ``'NCDHW'`` ，其中 `N` 是批尺寸， `C` 是通道数， `D` 是特征层深度， `H` 是特征层高度， `W` 是特征层宽度。。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
@@ -23,8 +23,8 @@ ZeroPad3D
 形状
 :::::::::
 
-  - x(Tensor): ZeroPadD 层的输入，要求形状为 5-D，dtype 为 ``'float32'`` 或 ``'float64'``
-  - output(Tensor)：输出，形状为 5-D，dtype 与 ``'input'`` 相同
+  - x(Tensor): ZeroPadD 层的输入，要求形状为 5-D，dtype 为  ``'float32'``  或  ``'float64'`` 
+  - output(Tensor)：输出，形状为 5-D，dtype 与  ``'input'``  相同
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/adaptive_avg_pool1d_cn.rst b/docs/api/paddle/nn/functional/adaptive_avg_pool1d_cn.rst
index 7ba737d9e2c..0967439d3a0 100755
--- a/docs/api/paddle/nn/functional/adaptive_avg_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/adaptive_avg_pool1d_cn.rst
@@ -5,7 +5,7 @@ adaptive_avg_pool1d
 
 .. py:function:: paddle.nn.functional.adaptive_avg_pool1d(x, output_size, name=None)
 
-根据 ``output_size`` 对 Tensor ``x`` 计算 1D 自适应平均池化。
+根据  ``output_size``  对 Tensor  ``x``  计算 1D 自适应平均池化。
 
 .. note::
    详细请参考对应的 `Class` 请参考：:ref:`cn_api_paddle_nn_AdaptiveAvgPool1D`。
diff --git a/docs/api/paddle/nn/functional/adaptive_avg_pool2d_cn.rst b/docs/api/paddle/nn/functional/adaptive_avg_pool2d_cn.rst
index 1298c143ce3..85e0e1b35b1 100755
--- a/docs/api/paddle/nn/functional/adaptive_avg_pool2d_cn.rst
+++ b/docs/api/paddle/nn/functional/adaptive_avg_pool2d_cn.rst
@@ -32,7 +32,7 @@ adaptive_avg_pool2d
 
 返回
 :::::::::
-``Tensor``，默认形状为（批大小，通道数，输出特征高度，输出特征宽度），即 NCHW 格式的 4-D Tensor，其数据类型与输入相同。
+ ``Tensor`` ，默认形状为（批大小，通道数，输出特征高度，输出特征宽度），即 NCHW 格式的 4-D Tensor，其数据类型与输入相同。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/adaptive_avg_pool3d_cn.rst b/docs/api/paddle/nn/functional/adaptive_avg_pool3d_cn.rst
index 65e324be848..39e3007466b 100755
--- a/docs/api/paddle/nn/functional/adaptive_avg_pool3d_cn.rst
+++ b/docs/api/paddle/nn/functional/adaptive_avg_pool3d_cn.rst
@@ -37,7 +37,7 @@ adaptive_avg_pool3d
 
 返回
 :::::::::
-``Tensor``，默认形状为（批大小，通道数，输出特征长度，输出特征高度，输出特征宽度），即 NCDHW 格式的 5-D Tensor，其数据类型与输入相同。
+ ``Tensor`` ，默认形状为（批大小，通道数，输出特征长度，输出特征高度，输出特征宽度），即 NCDHW 格式的 5-D Tensor，其数据类型与输入相同。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/adaptive_max_pool1d_cn.rst b/docs/api/paddle/nn/functional/adaptive_max_pool1d_cn.rst
index c394f52bce9..3dd8ffd1051 100755
--- a/docs/api/paddle/nn/functional/adaptive_max_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/adaptive_max_pool1d_cn.rst
@@ -21,7 +21,7 @@ adaptive_max_pool1d
 
 返回
 :::::::::
-``Tensor``，输入 `x` 经过自适应池化计算得到的目标 3-D Tensor，其数据类型与输入相同。
+ ``Tensor`` ，输入 `x` 经过自适应池化计算得到的目标 3-D Tensor，其数据类型与输入相同。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/adaptive_max_pool2d_cn.rst b/docs/api/paddle/nn/functional/adaptive_max_pool2d_cn.rst
index 9580a0441fd..cd54ce08cdb 100644
--- a/docs/api/paddle/nn/functional/adaptive_max_pool2d_cn.rst
+++ b/docs/api/paddle/nn/functional/adaptive_max_pool2d_cn.rst
@@ -20,7 +20,7 @@ adaptive_max_pool2d
 
 返回
 :::::::::
-``Tensor``，输入 `x` 经过自适应池化计算得到的目标 4-D Tensor，其数据类型与输入相同。
+ ``Tensor`` ，输入 `x` 经过自适应池化计算得到的目标 4-D Tensor，其数据类型与输入相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/adaptive_max_pool3d_cn.rst b/docs/api/paddle/nn/functional/adaptive_max_pool3d_cn.rst
index 2f6e30cfd79..5b9e53eaec9 100644
--- a/docs/api/paddle/nn/functional/adaptive_max_pool3d_cn.rst
+++ b/docs/api/paddle/nn/functional/adaptive_max_pool3d_cn.rst
@@ -20,7 +20,7 @@ adaptive_max_pool3d
 
 返回
 :::::::::
-``Tensor``，输入 `x` 经过自适应池化计算得到的目标 5-D Tensor，其数据类型与输入相同。
+ ``Tensor`` ，输入 `x` 经过自适应池化计算得到的目标 5-D Tensor，其数据类型与输入相同。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/affine_grid_cn.rst b/docs/api/paddle/nn/functional/affine_grid_cn.rst
index 5e89e95460a..ca7b8a20a1e 100644
--- a/docs/api/paddle/nn/functional/affine_grid_cn.rst
+++ b/docs/api/paddle/nn/functional/affine_grid_cn.rst
@@ -11,14 +11,14 @@ affine_grid
 参数
 ::::::::::::
 
-  - **theta** (Tensor) - Shape 为 ``[batch_size, 2, 3]`` 或 ``[batch_size, 3, 4]`` 的 Tensor，表示 batch_size 个 ``2X3``  或 ``3X4`` 的变换矩阵。数据类型支持 float32，float64。
-  - **out_shape** (Tensor | list | tuple) - 类型可以是 1-D Tensor、list 或 tuple。用于表示在仿射变换中的输出的 shape，其格式为 ``[N, C, H, W]`` 或 ``[N, C, D, H, W]`` ，格式 ``[N, C, H, W]`` 分别表示输出 feature map 的 batch size、channel 数量、高和宽，格式 ``[N, C, D, H, W]`` 分别表示输出 feature map 的 batch size、channel 数量、深度、高和宽。数据类型支持 int32。
+  - **theta** (Tensor) - Shape 为  ``[batch_size, 2, 3]``  或  ``[batch_size, 3, 4]``  的 Tensor，表示 batch_size 个  ``2X3``   或  ``3X4``  的变换矩阵。数据类型支持 float32，float64。
+  - **out_shape** (Tensor | list | tuple) - 类型可以是 1-D Tensor、list 或 tuple。用于表示在仿射变换中的输出的 shape，其格式为  ``[N, C, H, W]``  或  ``[N, C, D, H, W]``  ，格式  ``[N, C, H, W]``  分别表示输出 feature map 的 batch size、channel 数量、高和宽，格式  ``[N, C, D, H, W]``  分别表示输出 feature map 的 batch size、channel 数量、深度、高和宽。数据类型支持 int32。
   - **align_corners** (bool，可选) - 一个可选的 bool 型参数，如果为 True，则将输入和输出 Tensor 的 4（4D） 或 8（5D） 个角落像素的中心对齐，并保留角点像素的值。默认值：True。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
- Tensor。Shape 为 ``[N, H, W, 2]`` 的 4-D Tensor 或``[N, D, H, W, 3]``的 5-D Tensor，表示仿射变换前后的坐标的映射关系。输出为 4-D Tensor 时，N、H、W 分别为仿射变换中输出 feature map 的 batch size、高和宽，输出为 5D Tensor 时，N、D、H、W 分别为仿射变换中输出 feature map 的 batch size、深度、高和宽。数据类型与 ``theta`` 一致。
+ Tensor。Shape 为  ``[N, H, W, 2]``  的 4-D Tensor 或 ``[N, D, H, W, 3]`` 的 5-D Tensor，表示仿射变换前后的坐标的映射关系。输出为 4-D Tensor 时，N、H、W 分别为仿射变换中输出 feature map 的 batch size、高和宽，输出为 5D Tensor 时，N、D、H、W 分别为仿射变换中输出 feature map 的 batch size、深度、高和宽。数据类型与  ``theta``  一致。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/avg_pool1d_cn.rst b/docs/api/paddle/nn/functional/avg_pool1d_cn.rst
index 804b49a6114..765cc16ac6c 100755
--- a/docs/api/paddle/nn/functional/avg_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/avg_pool1d_cn.rst
@@ -26,7 +26,7 @@ avg_pool1d
 
 返回
 :::::::::
-``Tensor``，输入 `x` 经过平均池化计算得到的目标 3-D Tensor，其数据类型与输入相同。
+ ``Tensor`` ，输入 `x` 经过平均池化计算得到的目标 3-D Tensor，其数据类型与输入相同。
 
 
 
diff --git a/docs/api/paddle/nn/functional/batch_norm_cn.rst b/docs/api/paddle/nn/functional/batch_norm_cn.rst
index 1b3f7bea238..b978b40bf5c 100644
--- a/docs/api/paddle/nn/functional/batch_norm_cn.rst
+++ b/docs/api/paddle/nn/functional/batch_norm_cn.rst
@@ -18,9 +18,9 @@ batch_norm
     - **weight** (Tensor，可选) - 权重的 Tensor，默认为 None。
     - **bias** (Tensor，可选) - 偏置的 Tensor，默认为 None。
     - **training** (bool，可选) – 当该值为 True 时，表示为训练模式（train mode），即使用批数据计算并在训练期间跟踪全局均值和方差。为 False 时，表示使用推理模式（inference mode），即使用训练期间计算出的全局均值及方差计算。默认值为 False。
-    - **momentum** (float，可选) - 此值用于计算 ``moving_mean`` 和 ``moving_var``。默认值：0.9。更新公式如上所示。
+    - **momentum** (float，可选) - 此值用于计算  ``moving_mean``  和  ``moving_var`` 。默认值：0.9。更新公式如上所示。
     - **epsilon** (float，可选) - 为了数值稳定加在分母上的值。默认值：1e-05。
-    - **data_format** (str，可选) - 指定输入数据格式。数据格式可以为 ``"NC"``、``"NCL"``、``"NCHW"`` 或者 ``"NCDHW"``，其中 N 是批大小，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度，L 是特征长度。默认值为 ``"NCHW"``。
+    - **data_format** (str，可选) - 指定输入数据格式。数据格式可以为  ``"NC"`` 、 ``"NCL"`` 、 ``"NCHW"``  或者  ``"NCDHW"`` ，其中 N 是批大小，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度，L 是特征长度。默认值为  ``"NCHW"`` 。
     - **use_global_stats** (bool|None，可选) - 指示是否使用全局均值和方差。若设置为 False，则使用一个 mini-batch 的统计数据。若设置为 True 时，将使用全局统计数据。若设置为 None，则会在测试阶段使用全局统计数据，在训练阶段使用一个 mini-batch 的统计数据。默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/nn/functional/bilinear_cn.rst b/docs/api/paddle/nn/functional/bilinear_cn.rst
index 44ba51739d0..18d67d4cf5c 100644
--- a/docs/api/paddle/nn/functional/bilinear_cn.rst
+++ b/docs/api/paddle/nn/functional/bilinear_cn.rst
@@ -19,7 +19,7 @@ bilinear
 
 返回
 :::::::::
-``Tensor``，一个形为 [batch_size, out_features] 的 2-D Tensor。
+ ``Tensor`` ，一个形为 [batch_size, out_features] 的 2-D Tensor。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/binary_cross_entropy_cn.rst b/docs/api/paddle/nn/functional/binary_cross_entropy_cn.rst
index 67a414d2da7..85bef531698 100644
--- a/docs/api/paddle/nn/functional/binary_cross_entropy_cn.rst
+++ b/docs/api/paddle/nn/functional/binary_cross_entropy_cn.rst
@@ -5,7 +5,7 @@ binary_cross_entropy
 
 .. py:function:: paddle.nn.functional.binary_cross_entropy(input, label, weight=None, reduction='mean', name=None)
 
-该函数用于计算输入 ``input`` 和标签 ``label`` 之间的二值交叉熵损失值。二值交叉熵损失函数公式如下：
+该函数用于计算输入  ``input``  和标签  ``label``  之间的二值交叉熵损失值。二值交叉熵损失函数公式如下：
 
 当 `weight` 不为空时，公式为：
 
@@ -31,19 +31,19 @@ binary_cross_entropy
 
 
 .. note::
-    输入数据 ``input`` 一般是 ``sigmoid`` 的输出。因为是二分类，所以标签值 ``label`` 应该是 0 或者 1。
+    输入数据  ``input``  一般是  ``sigmoid``  的输出。因为是二分类，所以标签值  ``label``  应该是 0 或者 1。
 
 参数
 :::::::::
-    - **input** (Tensor) - :math:`[N, *]`，其中 N 是 batch_size， `*` 是任意其他维度。输入数据 ``input`` 一般是 ``sigmoid`` 的输出。数据类型是 float16、float32、float64。
-    - **label** (Tensor) - :math:`[N, *]`，标签 ``label`` 的维度、数据类型与输入 ``input`` 相同。
+    - **input** (Tensor) - :math:`[N, *]`，其中 N 是 batch_size， `*` 是任意其他维度。输入数据  ``input``  一般是  ``sigmoid``  的输出。数据类型是 float16、float32、float64。
+    - **label** (Tensor) - :math:`[N, *]`，标签  ``label``  的维度、数据类型与输入  ``input``  相同。
     - **weight** (Tensor，可选) - 手动指定每个 batch 二值交叉熵的权重，如果指定的话，维度必须是一个 batch 的数据的维度。数据类型是 float16、float32, float64。默认值是：None。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：``'none'``, ``'mean'``, ``'sum'``。默认为 ``'mean'``，计算 `BCELoss` 的均值；设置为 ``'sum'`` 时，计算 `BCELoss` 的总和；设置为 ``'none'`` 时，则返回 bce_loss。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ,  ``'mean'`` ,  ``'sum'`` 。默认为  ``'mean'`` ，计算 `BCELoss` 的均值；设置为  ``'sum'``  时，计算 `BCELoss` 的总和；设置为  ``'none'``  时，则返回 bce_loss。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-    - 输出的结果 Tensor。如果 :attr:`reduction` 是 ``'none'``，则输出的维度为 :math:`[N, *]`，与输入 ``input`` 的形状相同。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出的维度为 :math:`[]` 。
+    - 输出的结果 Tensor。如果 :attr:`reduction` 是  ``'none'`` ，则输出的维度为 :math:`[N, *]`，与输入  ``input``  的形状相同。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出的维度为 :math:`[]` 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/binary_cross_entropy_with_logits_cn.rst b/docs/api/paddle/nn/functional/binary_cross_entropy_with_logits_cn.rst
index 72afe9e8945..10774f75439 100644
--- a/docs/api/paddle/nn/functional/binary_cross_entropy_with_logits_cn.rst
+++ b/docs/api/paddle/nn/functional/binary_cross_entropy_with_logits_cn.rst
@@ -7,7 +7,7 @@ binary_cross_entropy_with_logits
 
 计算输入 `logit` 和标签 `label` 间的 `binary cross entropy with logits loss` 损失。
 
-结合了 `sigmoid` 操作和 :ref:`api_nn_loss_BCELoss` 操作。同时，我们也可以认为这是 ``sigmoid_cross_entrop_with_logits`` 和一些 `reduce` 操作的组合。
+结合了 `sigmoid` 操作和 :ref:`api_nn_loss_BCELoss` 操作。同时，我们也可以认为这是  ``sigmoid_cross_entrop_with_logits``  和一些 `reduce` 操作的组合。
 
 在每个类别独立的分类任务中，可以用于计算按元素的概率误差。可以将其视为预测数据点的标签，其中标签不是互斥的。例如，一篇新闻文章可以同时关于政治，科技，体育或者同时不包含这些内容。
 
@@ -26,7 +26,7 @@ binary_cross_entropy_with_logits
 .. math::
     Out = \max(Logit, 0) - Logit * Labels + \log(1 + e^{-\|Logit\|})
 
-然后，当 ``weight`` 或 ``pos_weight`` 不为 None 的时候，将会在输出 Out 上乘以相应的权重。Tensor ``weight`` 给 Batch 中的每一条数据赋予不同权重，Tensor ``pos_weight`` 给每一类的正例添加相应的权重。
+然后，当  ``weight``  或  ``pos_weight``  不为 None 的时候，将会在输出 Out 上乘以相应的权重。Tensor  ``weight``  给 Batch 中的每一条数据赋予不同权重，Tensor  ``pos_weight``  给每一类的正例添加相应的权重。
 
 最后，将会添加 `reduce` 操作到前面的输出 Out 上。当 `reduction` 为 `none` 时，直接返回最原始的 `Out` 结果。当 `reduction` 为 `mean` 时，返回输出的均值 :math:`Out = MEAN(Out)`。当 `reduction` 为 `sum` 时，返回输出的求和 :math:`Out = SUM(Out)` 。
 
@@ -34,16 +34,16 @@ binary_cross_entropy_with_logits
 
 参数
 :::::::::
-    - **logit** (Tensor) - :math:`[N, *]`，其中 N 是 batch_size， `*` 是任意其他维度。输入数据 ``logit`` 一般是线性层的输出，不需要经过 ``sigmoid`` 层。数据类型是 float32、float64。
-    - **label** (Tensor) - :math:`[N, *]`，标签 ``label`` 的维度、数据类型与输入 ``logit`` 相同。
+    - **logit** (Tensor) - :math:`[N, *]`，其中 N 是 batch_size， `*` 是任意其他维度。输入数据  ``logit``  一般是线性层的输出，不需要经过  ``sigmoid``  层。数据类型是 float32、float64。
+    - **label** (Tensor) - :math:`[N, *]`，标签  ``label``  的维度、数据类型与输入  ``logit``  相同。
     - **weight** (Tensor，可选) - 手动指定每个 batch 二值交叉熵的权重，如果指定的话，维度必须是一个 batch 的数据的维度。数据类型是 float32, float64。默认值是：None。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：``'none'``, ``'mean'``, ``'sum'``。默认为 ``'mean'``，计算 `BCELoss` 的均值；设置为 ``'sum'`` 时，计算 `BCELoss` 的总和；设置为 ``'none'`` 时，则返回原始 loss。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ,  ``'mean'`` ,  ``'sum'`` 。默认为  ``'mean'`` ，计算 `BCELoss` 的均值；设置为  ``'sum'``  时，计算 `BCELoss` 的总和；设置为  ``'none'``  时，则返回原始 loss。
     - **pos_weight** (Tensor，可选) - 手动指定正类的权重，必须是与类别数相等长度的向量。数据类型是 float32, float64。默认值是：None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-    - Tensor，输出的 Tensor。如果 :attr:`reduction` 是 ``'none'``，则输出的维度为 :math:`[N, *]`，与输入 ``input`` 的形状相同。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出的维度为 :math:`[]` 。
+    - Tensor，输出的 Tensor。如果 :attr:`reduction` 是  ``'none'`` ，则输出的维度为 :math:`[N, *]`，与输入  ``input``  的形状相同。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出的维度为 :math:`[]` 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/celu_cn.rst b/docs/api/paddle/nn/functional/celu_cn.rst
index 75e477dfaa6..c6ab20315b2 100644
--- a/docs/api/paddle/nn/functional/celu_cn.rst
+++ b/docs/api/paddle/nn/functional/celu_cn.rst
@@ -17,13 +17,13 @@ celu 激活层（CELU Activation Operator）
 
 参数
 ::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float16、float32、float64。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float16、float32、float64。
     - **alpha** (float，可选) - celu 的 alpha 值，默认值为 1.0。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/channel_shuffle_cn.rst b/docs/api/paddle/nn/functional/channel_shuffle_cn.rst
index e7fce5bffc4..48627eb297d 100644
--- a/docs/api/paddle/nn/functional/channel_shuffle_cn.rst
+++ b/docs/api/paddle/nn/functional/channel_shuffle_cn.rst
@@ -18,7 +18,7 @@ channel_shuffle
 
 返回
 :::::::::
-``Tensor``，调整过通道顺序的 Tensor，其数据类型与输入相同。
+ ``Tensor`` ，调整过通道顺序的 Tensor，其数据类型与输入相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/class_center_sample_cn.rst b/docs/api/paddle/nn/functional/class_center_sample_cn.rst
index a3be6a465d2..8dbab8e1d3f 100644
--- a/docs/api/paddle/nn/functional/class_center_sample_cn.rst
+++ b/docs/api/paddle/nn/functional/class_center_sample_cn.rst
@@ -11,30 +11,30 @@ class_center_sample
 1. 首先把所有正类别中心采样；
 2. 然后随机采样负类别中心。
 
-具体的过程是，给定一个维度为 [``batch_size``] 的 ``label``，从 [0, num_classes) 中把所有正类别中心选择出来，然后随机采样负类别中心补够 ``num_samples``。接着用采样出来的类别中心重新映射 ``label``。
+具体的过程是，给定一个维度为 [ ``batch_size`` ] 的  ``label`` ，从 [0, num_classes) 中把所有正类别中心选择出来，然后随机采样负类别中心补够  ``num_samples`` 。接着用采样出来的类别中心重新映射  ``label`` 。
 
 更多的细节信息，请参考论文《Partial FC: Training 10 Million Identities on a Single Machine》，arxiv: https://arxiv.org/abs/2010.05222
 
 .. note::
-    如果正类别中心数量大于给定的 ``num_samples``，将保留所有的正类别中心，因此 ``sampled_class_center`` 的维度将是 [``num_positive_class_centers``]。
+    如果正类别中心数量大于给定的  ``num_samples`` ，将保留所有的正类别中心，因此  ``sampled_class_center``  的维度将是 [ ``num_positive_class_centers`` ]。
 
     该 API 支持 CPU ， 单 GPU 和多 GPU 。
 
-    数据并行模式，设置 ``group=False`` 。
-    模型并行模式，设置 ``group=None`` ，否则返回 ``paddle.distributed.new_group`` 的组实例。
+    数据并行模式，设置  ``group=False``  。
+    模型并行模式，设置  ``group=None``  ，否则返回  ``paddle.distributed.new_group``  的组实例。
 
 参数
 ::::::::::::
 
     - **label** (Tensor) - 1-D Tensor，数据类型为 int32 或者 int64，每个元素的取值范围在 [0, num_classes)。
-    - **num_classes** (int) - 一个正整数，表示当前卡的类别数，注意每张卡的 ``num_classes`` 可以是不同的值。
+    - **num_classes** (int) - 一个正整数，表示当前卡的类别数，注意每张卡的  ``num_classes``  可以是不同的值。
     - **num_samples** (int) - 一个正整数，表示当前卡采样的类别中心数量。
-    - **group** (Group，可选) - 通信组的抽象描述，具体可以参考 ``paddle.distributed.collective.Group``。默认值为 ``None``。
+    - **group** (Group，可选) - 通信组的抽象描述，具体可以参考  ``paddle.distributed.collective.Group`` 。默认值为  ``None`` 。
 
 返回
 ::::::::::::
 
-    ``Tensor`` 二元组 - (``remapped_label``, ``sampled_class_center``)，``remapped_label`` 是重新映射后的标签，``sampled_class_center`` 是所采样的类别中心。
+     ``Tensor``  二元组 - ( ``remapped_label`` ,  ``sampled_class_center`` )， ``remapped_label``  是重新映射后的标签， ``sampled_class_center``  是所采样的类别中心。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/conv1d_cn.rst b/docs/api/paddle/nn/functional/conv1d_cn.rst
index c60d274ddb1..5d0f100147f 100755
--- a/docs/api/paddle/nn/functional/conv1d_cn.rst
+++ b/docs/api/paddle/nn/functional/conv1d_cn.rst
@@ -18,9 +18,9 @@ conv1d
     - :math:`X`：输入值，NCL 或 NLC 格式的 3-D Tensor
     - :math:`W`：卷积核值，MCL 格式的 3-D Tensor
     - :math:`*`：卷积操作
-    - :math:`b`：偏置值，2-D Tensor，形状为 ``[M,1]``
+    - :math:`b`：偏置值，2-D Tensor，形状为  ``[M,1]`` 
     - :math:`\sigma`：激活函数
-    - :math:`Out`：输出值，NCL 或 NLC 格式的 3-D Tensor，和 ``X`` 的形状可能不同
+    - :math:`Out`：输出值，NCL 或 NLC 格式的 3-D Tensor，和  ``X``  的形状可能不同
 
 **示例**
 
@@ -40,28 +40,28 @@ conv1d
 
     L_{out} = \frac{\left ( L_{in} + padding * 2 - \left ( dilation*\left ( L_{f}-1 \right )+1 \right ) \right )}{stride}+1
 
-如果 ``padding`` = "SAME":
+如果  ``padding``  = "SAME":
 
 .. math::
     L_{out} = \frac{(L_{in} + stride - 1)}{stride}
 
-如果 ``padding`` = "VALID":
+如果  ``padding``  = "VALID":
 
 .. math::
     L_{out} = \frac{\left ( L_{in} -\left ( dilation*\left ( L_{f}-1 \right )+1 \right ) \right )}{stride}+1
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``。
+    别名支持: 参数名  ``input``  可替代  ``x`` 。
 
 参数
 ::::::::::::
 
     - **x** (Tensor) - 输入是形状为 :math:`[N, C, L]` 或 :math:`[N, L, C]` 的 4-D Tensor，N 是批尺寸，C 是通道数，L 是特征长度，数据类型为 float16, float32 或 float64。
-      别名： ``input``。
+      别名：  ``input`` 。
     - **weight** (Tensor) - 形状为 :math:`[M, C/g, kL]` 的卷积核。M 是输出通道数，g 是分组的个数，kL 是卷积核的长度度。
     - **bias** (int|list|tuple，可选) - 偏置项，形状为：:math:`[M,]` 。
     - **stride** (int|list|tuple，可选) - 步长大小。卷积核和输入进行卷积计算时滑动的步长。整数或包含一个整数的列表或元组。默认值：1。
-    - **padding** (int|list|tuple|str，可选) - 填充大小。可以是以下三种格式：（1）字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考下述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。（2）整数，表示在输入特征两侧各填充 ``padding`` 大小的 0。（3）包含一个整数的列表或元组，表示在输入特征两侧各填充 ``padding[0]`` 大小的 0。默认值：0。
+    - **padding** (int|list|tuple|str，可选) - 填充大小。可以是以下三种格式：（1）字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考下述  ``padding``  = "SAME"或   ``padding``  = "VALID" 时的计算公式。（2）整数，表示在输入特征两侧各填充  ``padding``  大小的 0。（3）包含一个整数的列表或元组，表示在输入特征两侧各填充  ``padding[0]``  大小的 0。默认值：0。
     - **dilation** (int|list|tuple，可选) - 空洞大小。空洞卷积时会使用该参数，卷积核对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息。整数或包含一个整型数的列表或元组。默认值：1。
     - **groups** (int，可选) - 一维卷积层的组数。根据 Alex Krizhevsky 的深度卷积神经网络（CNN）论文中的成组卷积：当 group=n，输入和卷积核分别根据通道数量平均分为 n 组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第 n 组卷积核和第 n 组输入进行卷积计算。默认值：1。
     - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCL"和"NLC"。N 是批尺寸，C 是通道数，L 是特征长度。默认值："NCL"。
@@ -69,7 +69,7 @@ conv1d
 
 返回
 ::::::::::::
-3-D Tensor，数据类型与 ``x`` 一致。返回卷积的结果。
+3-D Tensor，数据类型与  ``x``  一致。返回卷积的结果。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/conv1d_transpose_cn.rst b/docs/api/paddle/nn/functional/conv1d_transpose_cn.rst
index 7cb543fa271..b11ebbc35f9 100644
--- a/docs/api/paddle/nn/functional/conv1d_transpose_cn.rst
+++ b/docs/api/paddle/nn/functional/conv1d_transpose_cn.rst
@@ -25,9 +25,9 @@ conv1d_transpose
     -  :math:`X`：输入，具有 NCL 或 NLC 格式的 3-D Tensor
     -  :math:`W`：卷积核，具有 NCL 格式的 3-D Tensor
     -  :math:`*`：卷积计算（注意：转置卷积本质上的计算还是卷积）
-    -  :math:`b`：偏置（bias），2-D Tensor，形状为 ``[M,1]``
+    -  :math:`b`：偏置（bias），2-D Tensor，形状为  ``[M,1]`` 
     -  :math:`σ`：激活函数
-    -  :math:`Out`：输出值，NCL 或 NLC 格式的 3-D Tensor，和 ``X`` 的形状可能不同
+    -  :math:`Out`：输出值，NCL 或 NLC 格式的 3-D Tensor，和  ``X``  的形状可能不同
 
 **示例**
 
@@ -48,13 +48,13 @@ conv1d_transpose
         & L'_{out} = (L_{in}-1)*stride - padding * 2 + dilation*(L_f-1)+1\\
         & L_{out}\in[L'_{out},L'_{out} + stride)
 
-如果 ``padding`` = "SAME":
+如果  ``padding``  = "SAME":
 
 .. math::
 
    L'_{out} = \frac{(L_{in} + stride - 1)}{stride}
 
-如果 ``padding`` = "VALID":
+如果  ``padding``  = "VALID":
 
 .. math::
 
@@ -73,18 +73,18 @@ conv1d_transpose
   - **weight** (Tensor) - 形状为 :math:`[C, M/g, kL]` 的卷积核（卷积核）。 M 是输出通道数，g 是分组的个数，kL 是卷积核的长度。
   - **bias** (int|list|tuple，可选) - 偏置项，形状为：:math:`[M,]` 。
   - **stride** (int|list|tuple，可选) - 步长大小。整数或包含一个整数的列表或元组。默认值：1。
-  - **padding** (int|list|tuple|str，可选) - 填充大小。可以是以下三种格式：（1）字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考下述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。（2）整数，表示在输入特征两侧各填充 ``padding`` 大小的 0。（3）包含一个整数的列表或元组，表示在输入特征两侧各填充 ``padding[0]`` 大小的 0。默认值：0。
+  - **padding** (int|list|tuple|str，可选) - 填充大小。可以是以下三种格式：（1）字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考下述  ``padding``  = "SAME"或   ``padding``  = "VALID" 时的计算公式。（2）整数，表示在输入特征两侧各填充  ``padding``  大小的 0。（3）包含一个整数的列表或元组，表示在输入特征两侧各填充  ``padding[0]``  大小的 0。默认值：0。
   - **output_padding** (int|list|tuple，可选) - 输出形状上尾部一侧额外添加的大小。默认值：0。
   - **groups** (int，可选) - 一维卷积层的组数。根据 Alex Krizhevsky 的深度卷积神经网络（CNN）论文中的成组卷积：当 group=n，输入和卷积核分别根据通道数量平均分为 n 组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第 n 组卷积核和第 n 组输入进行卷积计算。默认值：1。
   - **dilation** (int|list|tuple，可选) - 空洞大小。空洞卷积时会使用该参数，卷积核对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息。整数或包含一个整数的列表或元组。默认值：1。
-  - **output_size** (int|list|tuple，可选) - 输出尺寸，整数或包含一个整数的列表或元组。如果为 ``None``，则会用 filter_size(``weight``的 shape), ``padding`` 和 ``stride`` 计算出输出特征图的尺寸。默认值：None。
+  - **output_size** (int|list|tuple，可选) - 输出尺寸，整数或包含一个整数的列表或元组。如果为  ``None`` ，则会用 filter_size( ``weight`` 的 shape),  ``padding``  和  ``stride``  计算出输出特征图的尺寸。默认值：None。
   - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCL"和"NLC"。N 是批尺寸，C 是通道数，L 是特征长度。默认值："NCL"。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 ::::::::::::
-3-D Tensor，数据类型与 ``input`` 一致。如果未指定激活层，则返回转置卷积计算的结果，如果指定激活层，则返回转置卷积和激活计算之后的最终结果。
+3-D Tensor，数据类型与  ``input``  一致。如果未指定激活层，则返回转置卷积计算的结果，如果指定激活层，则返回转置卷积和激活计算之后的最终结果。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/conv2d_cn.rst b/docs/api/paddle/nn/functional/conv2d_cn.rst
index e7035e9ac8a..211192cb517 100755
--- a/docs/api/paddle/nn/functional/conv2d_cn.rst
+++ b/docs/api/paddle/nn/functional/conv2d_cn.rst
@@ -18,9 +18,9 @@ conv2d
     - :math:`X`：输入值，NCHW 或 NHWC 格式的 4-D Tensor
     - :math:`W`：卷积核值，MCHW 格式的 4-D Tensor
     - :math:`*`：卷积操作
-    - :math:`b`：偏置值，2-D Tensor，形状为 ``[M,1]``
+    - :math:`b`：偏置值，2-D Tensor，形状为  ``[M,1]`` 
     - :math:`\sigma`：激活函数
-    - :math:`Out`：输出值，NCHW 或 NHWC 格式的 4-D Tensor，和 ``X`` 的形状可能不同
+    - :math:`Out`：输出值，NCHW 或 NHWC 格式的 4-D Tensor，和  ``X``  的形状可能不同
 
 **示例**
 
@@ -42,7 +42,7 @@ conv2d
 
     W_{out} &= \frac{\left ( W_{in} + padding\_width\_left + padding\_width\_right -\left ( dilation[1]*\left ( W_{f}-1 \right )+1 \right ) \right )}{stride[1]}+1
 
-如果 ``padding`` = "SAME":
+如果  ``padding``  = "SAME":
 
 .. math::
     H_{out} = \frac{(H_{in} + stride[0] - 1)}{stride[0]}
@@ -50,7 +50,7 @@ conv2d
 .. math::
     W_{out} = \frac{(W_{in} + stride[1] - 1)}{stride[1]}
 
-如果 ``padding`` = "VALID":
+如果  ``padding``  = "VALID":
 
 .. math::
     H_{out} = \frac{\left ( H_{in} -\left ( dilation[0]*\left ( H_{f}-1 \right )+1 \right ) \right )}{stride[0]}+1
@@ -58,17 +58,17 @@ conv2d
     W_{out} = \frac{\left ( W_{in} -\left ( dilation[1]*\left ( W_{f}-1 \right )+1 \right ) \right )}{stride[1]}+1
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``。
+    别名支持: 参数名  ``input``  可替代  ``x`` 。
 
 参数
 ::::::::::::
 
     - **x** (Tensor) - 输入是形状为 :math:`[N, C, H, W]` 或 :math:`[N, H, W, C]` 的 4-D Tensor，N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度，数据类型为 float16, float32 或 float64。
-      别名： ``input``。
+      别名：  ``input`` 。
     - **weight** (Tensor) - 形状为 :math:`[M, C/g, kH, kW]` 的卷积核。M 是输出通道数，g 是分组的个数，kH 是卷积核的高度，kW 是卷积核的宽度。
     - **bias** (int|list|tuple，可选) - 偏置项，形状为：:math:`[M,]` 。
     - **stride** (int|list|tuple，可选) - 步长大小。卷积核和输入进行卷积计算时滑动的步长。如果它是一个列表或元组，则必须包含两个整型数：（stride_height,stride_width）。若为一个整数，stride_height = stride_width = stride。默认值：1。
-    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 4 个二元组：当 ``data_format`` 为"NCHW"时为 [[0,0], [0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为"NHWC"时为[[0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含 4 个整数值：[padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含 2 个整数值：[padding_height, padding_width]，此时 padding_height_top = padding_height_bottom = padding_height， padding_width_left = padding_width_right = padding_width。若为一个整数，padding_height = padding_width = padding。默认值：0。
+    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述  ``padding``  = "SAME"或   ``padding``  = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 4 个二元组：当  ``data_format``  为"NCHW"时为 [[0,0], [0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当  ``data_format``  为"NHWC"时为[[0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含 4 个整数值：[padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含 2 个整数值：[padding_height, padding_width]，此时 padding_height_top = padding_height_bottom = padding_height， padding_width_left = padding_width_right = padding_width。若为一个整数，padding_height = padding_width = padding。默认值：0。
     - **dilation** (int|list|tuple，可选) - 空洞大小。空洞卷积时会使用该参数，卷积核对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息。如果空洞大小为列表或元组，则必须包含两个整型数：（dilation_height,dilation_width）。若为一个整数，dilation_height = dilation_width = dilation。默认值：1。
     - **groups** (int，可选) - 二维卷积层的组数。根据 Alex Krizhevsky 的深度卷积神经网络（CNN）论文中的成组卷积：当 group=n，输入和卷积核分别根据通道数量平均分为 n 组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第 n 组卷积核和第 n 组输入进行卷积计算。默认值：1。
     - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCHW"和"NHWC"。N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度。默认值："NCHW"。
@@ -76,7 +76,7 @@ conv2d
 
 返回
 ::::::::::::
-4-D Tensor，数据类型与 ``x`` 一致。返回卷积的结果。
+4-D Tensor，数据类型与  ``x``  一致。返回卷积的结果。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/conv2d_transpose_cn.rst b/docs/api/paddle/nn/functional/conv2d_transpose_cn.rst
index c3b60f6c5d5..b2687908986 100644
--- a/docs/api/paddle/nn/functional/conv2d_transpose_cn.rst
+++ b/docs/api/paddle/nn/functional/conv2d_transpose_cn.rst
@@ -25,9 +25,9 @@ conv2d_transpose
     -  :math:`X`：输入，具有 NCHW 或 NHWC 格式的 4-D Tensor
     -  :math:`W`：卷积核，具有 NCHW 格式的 4-D Tensor
     -  :math:`*`：卷积计算（注意：转置卷积本质上的计算还是卷积）
-    -  :math:`b`：偏置（bias），2-D Tensor，形状为 ``[M,1]``
+    -  :math:`b`：偏置（bias），2-D Tensor，形状为  ``[M,1]`` 
     -  :math:`σ`：激活函数
-    -  :math:`Out`：输出值，NCHW 或 NHWC 格式的 4-D Tensor，和 ``X`` 的形状可能不同
+    -  :math:`Out`：输出值，NCHW 或 NHWC 格式的 4-D Tensor，和  ``X``  的形状可能不同
 
 **示例**
 
@@ -50,13 +50,13 @@ conv2d_transpose
         H_{out} &\in [ H^\prime_{out}, H^\prime_{out} + strides[0] ) \\
         W_{out} &\in [ W^\prime_{out}, W^\prime_{out} + strides[1] ) \\
 
-如果 ``padding`` = "SAME":
+如果  ``padding``  = "SAME":
 
 .. math::
    & H'_{out} = \frac{(H_{in} + stride[0] - 1)}{stride[0]}\\
    & W'_{out} = \frac{(W_{in} + stride[1] - 1)}{stride[1]}\\
 
-如果 ``padding`` = "VALID":
+如果  ``padding``  = "VALID":
 
 .. math::
     & H'_{out} = (H_{in}-1)*strides[0] + dilations[0]*(H_f-1)+1\\
@@ -74,19 +74,19 @@ conv2d_transpose
   - **x** (Tensor) - 输入是形状为 :math:`[N, C, H, W]` 或 :math:`[N, H, W, C]` 的 4-D Tensor，N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度，数据类型为 float16, float32 或 float64。
   - **weight** (Tensor) - 形状为 :math:`[C, M/g, kH, kW]` 的卷积核（卷积核）。 M 是输出通道数，g 是分组的个数，kH 是卷积核的高度，kW 是卷积核的宽度。
   - **bias** (int|list|tuple，可选) - 偏置项，形状为：:math:`[M,]` 。
-  - **stride** (int|list|tuple，可选) - 步长大小。如果 ``stride`` 为元组，则必须包含两个整型数，分别表示垂直和水平滑动步长。否则，表示垂直和水平滑动步长均为 ``stride``。默认值：1。
-  - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 4 个二元组：当 ``data_format`` 为"NCHW"时为 [[0,0], [0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为"NHWC"时为[[0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含 4 个整数值：[padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含 2 个整数值：[padding_height, padding_width]，此时 padding_height_top = padding_height_bottom = padding_height， padding_width_left = padding_width_right = padding_width。若为一个整数，padding_height = padding_width = padding。默认值：0。
+  - **stride** (int|list|tuple，可选) - 步长大小。如果  ``stride``  为元组，则必须包含两个整型数，分别表示垂直和水平滑动步长。否则，表示垂直和水平滑动步长均为  ``stride`` 。默认值：1。
+  - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述  ``padding``  = "SAME"或   ``padding``  = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 4 个二元组：当  ``data_format``  为"NCHW"时为 [[0,0], [0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当  ``data_format``  为"NHWC"时为[[0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含 4 个整数值：[padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含 2 个整数值：[padding_height, padding_width]，此时 padding_height_top = padding_height_bottom = padding_height， padding_width_left = padding_width_right = padding_width。若为一个整数，padding_height = padding_width = padding。默认值：0。
   - **output_padding** (int|list|tuple，可选) - 输出形状上一侧额外添加的大小。默认值：0。
   - **dilation** (int|list|tuple，可选) - 空洞大小。空洞卷积时会使用该参数，卷积核对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息。如果空洞大小为列表或元组，则必须包含两个整型数：（dilation_height,dilation_width）。若为一个整数，dilation_height = dilation_width = dilation。默认值：1。
   - **groups** (int，可选) - 二维卷积层的组数。根据 Alex Krizhevsky 的深度卷积神经网络（CNN）论文中的成组卷积：当 group=n，输入和卷积核分别根据通道数量平均分为 n 组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第 n 组卷积核和第 n 组输入进行卷积计算。默认值：1。
   - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCHW"和"NHWC"。N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度。默认值："NCHW"。
-  - **output_size** (int|list|tuple，可选) - 输出尺寸，整数或包含一个整数的列表或元组。如果为 ``None``，则会用 filter_size(``weight``的 shape), ``padding`` 和 ``stride`` 计算出输出特征图的尺寸。默认值：None。
+  - **output_size** (int|list|tuple，可选) - 输出尺寸，整数或包含一个整数的列表或元组。如果为  ``None`` ，则会用 filter_size( ``weight`` 的 shape),  ``padding``  和  ``stride``  计算出输出特征图的尺寸。默认值：None。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 ::::::::::::
-4-D Tensor，数据类型与 ``input`` 一致。如果未指定激活层，则返回转置卷积计算的结果，如果指定激活层，则返回转置卷积和激活计算之后的最终结果。
+4-D Tensor，数据类型与  ``input``  一致。如果未指定激活层，则返回转置卷积计算的结果，如果指定激活层，则返回转置卷积和激活计算之后的最终结果。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/nn/functional/conv3d_cn.rst b/docs/api/paddle/nn/functional/conv3d_cn.rst
index 743d745b356..d57effd3046 100755
--- a/docs/api/paddle/nn/functional/conv3d_cn.rst
+++ b/docs/api/paddle/nn/functional/conv3d_cn.rst
@@ -18,9 +18,9 @@ conv3d
     - :math:`X`：输入值，NCDHW 或 NDHWC 格式的 5-D Tensor
     - :math:`W`：卷积核值，MCDHW 格式的 5-D Tensor
     - :math:`*`：卷积操作
-    - :math:`b`：偏置值，2-D Tensor，形为 ``[M,1]``
+    - :math:`b`：偏置值，2-D Tensor，形为  ``[M,1]`` 
     - :math:`\sigma`：激活函数
-    - :math:`Out`：输出值，NCDHW 或 NDHWC 格式的 5-D Tensor，和 ``X`` 的形状可能不同
+    - :math:`Out`：输出值，NCDHW 或 NDHWC 格式的 5-D Tensor，和  ``X``  的形状可能不同
 
 **示例**
 
@@ -35,27 +35,27 @@ conv3d
   输出形状：:math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``。
+    别名支持: 参数名  ``input``  可替代  ``x`` 。
 
 参数
 ::::::::::::
 
     - **x** (Tensor) - 输入是形状为 :math:`[N, C, D, H, W]` 或 :math:`[N, D, H, W, C]` 的 5-D Tensor，N 是批尺寸，C 是通道数，D 是特征层深度，H 是特征高度，W 是特征宽度，数据类型为 float16, float32 或 float64。
-      别名： ``input``。
+      别名：  ``input`` 。
     - **weight** (Tensor) - 形状为 :math:`[M, C/g, kH, kW]` 的卷积核（卷积核）。 M 是输出通道数，g 是分组的个数，kH 是卷积核的高度，kW 是卷积核的宽度。
     - **bias** (int|list|tuple，可选) - 偏置项，形状为：:math:`[M,]` 。
     - **stride** (int|list|tuple，可选) - 步长大小。卷积核和输入进行卷积计算时滑动的步长。如果它是一个列表或元组，则必须包含两个整型数：（stride_height,stride_width）。若为一个整数，stride_height = stride_width = stride。默认值：1。
-    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 5 个二元组：当 ``data_format`` 为"NCDHW"时为 [[0,0], [0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为"NDHWC"时为[[0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含 6 个整数值：[padding_depth_front, padding_depth_back, padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含 3 个整数值：[padding_depth, padding_height, padding_width]，此时 padding_depth_front = padding_depth_back = padding_depth, padding_height_top = padding_height_bottom = padding_height, padding_width_left = padding_width_right = padding_width。若为一个整数，padding_depth = padding_height = padding_width = padding。默认值：0。
+    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述  ``padding``  = "SAME"或   ``padding``  = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 5 个二元组：当  ``data_format``  为"NCDHW"时为 [[0,0], [0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当  ``data_format``  为"NDHWC"时为[[0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含 6 个整数值：[padding_depth_front, padding_depth_back, padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含 3 个整数值：[padding_depth, padding_height, padding_width]，此时 padding_depth_front = padding_depth_back = padding_depth, padding_height_top = padding_height_bottom = padding_height, padding_width_left = padding_width_right = padding_width。若为一个整数，padding_depth = padding_height = padding_width = padding。默认值：0。
     - **dilation** (int|list|tuple，可选) - 空洞大小。空洞卷积时会使用该参数，卷积核对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息。如果空洞大小为列表或元组，则必须包含两个整型数：（dilation_height,dilation_width）。若为一个整数，dilation_height = dilation_width = dilation。默认值：1。
     - **groups** (int，可选) - 二维卷积层的组数。根据 Alex Krizhevsky 的深度卷积神经网络（CNN）论文中的成组卷积：当 group=n，输入和卷积核分别根据通道数量平均分为 n 组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第 n 组卷积核和第 n 组输入进行卷积计算。默认值：1。
     - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若 ``bias_attr`` 为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若  ``bias_attr``  为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征层深度，H 是特征高度，W 是特征宽度。默认值："NCDHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
-5-D Tensor，数据类型与 ``input`` 一致。返回卷积计算的结果。
+5-D Tensor，数据类型与  ``input``  一致。返回卷积计算的结果。
 
 返回类型
 ::::::::::::
diff --git a/docs/api/paddle/nn/functional/conv3d_transpose_cn.rst b/docs/api/paddle/nn/functional/conv3d_transpose_cn.rst
index d2604f25ce7..a88099903ce 100755
--- a/docs/api/paddle/nn/functional/conv3d_transpose_cn.rst
+++ b/docs/api/paddle/nn/functional/conv3d_transpose_cn.rst
@@ -26,9 +26,9 @@ conv3d_transpose
     -  :math:`X`：输入，具有 NCDHW 或 NDHWC 格式的 5-D Tensor
     -  :math:`W`：卷积核，具有 NCDHW 格式的 5-D Tensor
     -  :math:`*`：卷积操作（**注意**：转置卷积本质上的计算还是卷积）
-    -  :math:`b`：偏置（bias），2-D Tensor，形状为 ``[M, 1]``
+    -  :math:`b`：偏置（bias），2-D Tensor，形状为  ``[M, 1]`` 
     -  :math:`σ`：激活函数
-    -  :math:`Out`：输出值，NCDHW 或 NDHWC 格式的 5-D Tensor，和 ``X`` 的形状可能不同
+    -  :math:`Out`：输出值，NCDHW 或 NDHWC 格式的 5-D Tensor，和  ``X``  的形状可能不同
 
 **示例**
 
@@ -54,14 +54,14 @@ conv3d_transpose
     H_{out} &\in [ H^\prime_{out}, H^\prime_{out} + strides[1] ] \\
     W_{out} &\in [ W^\prime_{out}, W^\prime_{out} + strides[2] ] \\
 
-如果 ``padding`` = "SAME":
+如果  ``padding``  = "SAME":
 
 .. math::
     D'_{out} = \frac{(D_{in} + stride[0] - 1)}{stride[0]}\\
     H'_{out} = \frac{(H_{in} + stride[1] - 1)}{stride[1]}\\
     W'_{out} = \frac{(W_{in} + stride[2] - 1)}{stride[2]}\\
 
-如果 ``padding`` = "VALID":
+如果  ``padding``  = "VALID":
 
 .. math::
     D'_{out}=(D_{in}-1)*strides[0] + dilations[0]*(D_f-1)+1\\
@@ -79,19 +79,19 @@ conv3d_transpose
   - **x** (Tensor) - 形状为 :math:`[N, C, D, H, W]` 或 :math:`[N, D, H, W, C]` 的 5-D Tensor，N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度，数据类型：float32 或 float64。
   - **weight** (Tensor) - 形状为 :math:`[C, M/g, kD, kH, kW]` 的卷积核。M 是输出通道数，g 是分组的个数，kD 是卷积核的深度，kH 是卷积核的高度，kW 是卷积核的宽度。
   - **bias** (int|list|tuple，可选) - 偏置项，形状为：:math:`[M, ]` 。默认值为 None。
-  - **stride** (int|list|tuple，可选) - 步长大小。如果 ``stride`` 为元组或列表，则必须包含三个整型数，分别表示深度，垂直和水平滑动步长。否则，表示深度，垂直和水平滑动步长均为 ``stride``。默认值为 1。
-  - **padding** (int|list|tuple|str，可选) - 填充 padding 大小。padding 参数在输入特征层每边添加 ``dilation * (kernel_size - 1) - padding`` 个 0。如果它是一个字符串，可以是 "VALID" 或者 "SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME" 或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：(1) 包含 5 个二元组：当 ``data_format`` 为 "NCDHW" 时为 [[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当 ``data_format`` 为 "NDHWC" 时，为 [[0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]；(2) 包含 6 个整数值：[pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]；(3) 包含 3 个整数值：[pad_depth, pad_height, pad_width]，此时 pad_depth_front = pad_depth_back = pad_depth, pad_height_top = pad_height_bottom = pad_height, pad_width_left = pad_width_right = pad_width。若为一个整数，pad_depth = pad_height = pad_width = padding。默认值为 0。
+  - **stride** (int|list|tuple，可选) - 步长大小。如果  ``stride``  为元组或列表，则必须包含三个整型数，分别表示深度，垂直和水平滑动步长。否则，表示深度，垂直和水平滑动步长均为  ``stride`` 。默认值为 1。
+  - **padding** (int|list|tuple|str，可选) - 填充 padding 大小。padding 参数在输入特征层每边添加  ``dilation * (kernel_size - 1) - padding``  个 0。如果它是一个字符串，可以是 "VALID" 或者 "SAME"，表示填充算法，计算细节可参考上述  ``padding``  = "SAME" 或   ``padding``  = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：(1) 包含 5 个二元组：当  ``data_format``  为 "NCDHW" 时为 [[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当  ``data_format``  为 "NDHWC" 时，为 [[0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]；(2) 包含 6 个整数值：[pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]；(3) 包含 3 个整数值：[pad_depth, pad_height, pad_width]，此时 pad_depth_front = pad_depth_back = pad_depth, pad_height_top = pad_height_bottom = pad_height, pad_width_left = pad_width_right = pad_width。若为一个整数，pad_depth = pad_height = pad_width = padding。默认值为 0。
   - **output_padding** (int|list|tuple，可选) - 输出形状上一侧额外添加的大小。默认值为 0。
   - **dilation** (int|list|tuple，可选) - 空洞大小。空洞卷积时会使用该参数，卷积核对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息。如果空洞大小为列表或元组，则必须包含两个整型数：(dilation_height, dilation_width)。若为一个整数，dilation_height = dilation_width = dilation。默认值为 1。
   - **groups** (int，可选) - 三维转置卷积层的组数。从 `Alex Krizhevsky 的 Deep CNN 论文 <https://papers.nips.cc/paper/2012/file/c399862d3b9d6b76c8436e924a68c45b-Paper.pdf>`_ 中的群卷积中受到启发，当 groups = 2 时，输入和卷积核分别根据通道数量平均分为两组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算。默认值为 1。
-  - **output_size** (int|list|tuple，可选) - 输出尺寸，整数或包含一个整数的列表或元组。如果为 ``None``，则会用 filter_size( ``weight`` 的 shape), ``padding`` 和 ``stride`` 计算出输出特征图的尺寸。默认值为 None。
+  - **output_size** (int|list|tuple，可选) - 输出尺寸，整数或包含一个整数的列表或元组。如果为  ``None`` ，则会用 filter_size(  ``weight``  的 shape),  ``padding``  和  ``stride``  计算出输出特征图的尺寸。默认值为 None。
   - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是 "NCHW" 和 "NHWC"。N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度。默认值为 "NCHW"。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 ::::::::::::
-5-D Tensor，数据类型与 ``input`` 一致。如果未指定激活层，则返回转置卷积计算的结果，如果指定激活层，则返回转置卷积和激活计算之后的最终结果。
+5-D Tensor，数据类型与  ``input``  一致。如果未指定激活层，则返回转置卷积计算的结果，如果指定激活层，则返回转置卷积和激活计算之后的最终结果。
 
 返回类型
 ::::::::::::
diff --git a/docs/api/paddle/nn/functional/cosine_embedding_loss_cn.rst b/docs/api/paddle/nn/functional/cosine_embedding_loss_cn.rst
index 57a9a96f790..2720f7b7df6 100644
--- a/docs/api/paddle/nn/functional/cosine_embedding_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/cosine_embedding_loss_cn.rst
@@ -28,12 +28,12 @@ cosine_embedding_loss
     - **input2** (Tensor): - 输入的 Tensor，维度是[N, M]，其中 N 是 batch size，可为 0，M 是数组长度。数据类型为：float32、float64。
     - **label** (Tensor): - 标签，维度是[N]，N 是数组长度，数据类型为：float32、float64、int32、int64。
     - **margin** (float，可选): - 可以设置的范围为[-1, 1]，建议设置的范围为[0, 0.5]。其默认为 `0`。数据类型为 float。
-    - **reduction** (string，可选): - 指定应用于输出结果的计算方式，可选值有：``'none'``, ``'mean'``, ``'sum'``。默认为 ``'mean'``，计算 `CosineEmbeddingLoss` 的均值；设置为 ``'sum'`` 时，计算 `CosineEmbeddingLoss` 的总和；设置为 ``'none'`` 时，则返回 `CosineEmbeddingLoss`。数据类型为 string。
+    - **reduction** (string，可选): - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ,  ``'mean'`` ,  ``'sum'`` 。默认为  ``'mean'`` ，计算 `CosineEmbeddingLoss` 的均值；设置为  ``'sum'``  时，计算 `CosineEmbeddingLoss` 的总和；设置为  ``'none'``  时，则返回 `CosineEmbeddingLoss`。数据类型为 string。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-``Tensor``，输入 ``input1`` 、 ``input2`` 和标签 ``label`` 间的 `CosineEmbeddingLoss` 损失。如果 `reduction` 是 ``'none'``，则输出 Loss 的维度为 [N]，与输入 ``input1`` 和 ``input2`` 相同。如果 `reduction` 是 ``'mean'`` 或 ``'sum'``，则输出 Loss 的维度为 []。
+ ``Tensor`` ，输入  ``input1``  、  ``input2``  和标签  ``label``  间的 `CosineEmbeddingLoss` 损失。如果 `reduction` 是  ``'none'`` ，则输出 Loss 的维度为 [N]，与输入  ``input1``  和  ``input2``  相同。如果 `reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出 Loss 的维度为 []。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/cross_entropy_cn.rst b/docs/api/paddle/nn/functional/cross_entropy_cn.rst
index c990e0b6d6c..abf89476faf 100644
--- a/docs/api/paddle/nn/functional/cross_entropy_cn.rst
+++ b/docs/api/paddle/nn/functional/cross_entropy_cn.rst
@@ -31,9 +31,9 @@ cross_entropy
 
 1. weight 情况
 
-如果 ``weight`` 参数为 ``None``，则直接进入下一步。
+如果  ``weight``  参数为  ``None`` ，则直接进入下一步。
 
-如果 ``weight`` 参数不为 ``None``，则对每个样本的交叉熵进行 weight 加权(区分 soft_label = False or True):
+如果  ``weight``  参数不为  ``None`` ，则对每个样本的交叉熵进行 weight 加权(区分 soft_label = False or True):
 
 1.1 硬标签情况(soft_label = False)
 
@@ -47,27 +47,27 @@ cross_entropy
 
 2. reduction 情况
 
-2.1 如果 ``reduction`` 参数为 ``none``
+2.1 如果  ``reduction``  参数为  ``none`` 
 
      则直接返回上一步结果
 
-2.2 如果 ``reduction`` 参数为 ``sum``
+2.2 如果  ``reduction``  参数为  ``sum`` 
 
      则返回上一步结果的和
 
      .. math::
         \\loss=\sum_{j}loss_j
 
-2.3 如果 ``reduction`` 参数为 ``mean``，则根据 ``weight``  参数情况进行处理：
+2.3 如果  ``reduction``  参数为  ``mean`` ，则根据  ``weight``   参数情况进行处理：
 
-2.3.1 如果 ``weight`` 参数为 ``None``
+2.3.1 如果  ``weight``  参数为  ``None`` 
 
      则返回上一步结果的平均值
 
      .. math::
         \\loss=\sum_{j}loss_j/N, N 为样本数
 
-2.3.2 如果 ``weight`` 参数不为 ``None``，则返回上一步结果的加权平均值
+2.3.2 如果  ``weight``  参数不为  ``None`` ，则返回上一步结果的加权平均值
 
     (1) 硬标签情况(soft_label = False)
 
@@ -81,14 +81,14 @@ cross_entropy
 
 参数
 :::::::::
-    - **input** (Tensor) - 维度为 :math:`[N_1, N_2, ..., N_k, C]` 的多维 Tensor，其中最后一维 C 是类别数目。数据类型为 float32 或 float64。它需要未缩放的 ``input``。该 OP 不应该对 softmax 运算的输出进行操作，否则会产生错误的结果。
-    - **label** (Tensor) - 输入 input 对应的标签值。若 soft_label=False，要求 label 维度为 :math:`[N_1, N_2, ..., N_k]` 或 :math:`[N_1, N_2, ..., N_k, 1]`，数据类型为'int32', 'int64', 'float32', 'float64'，且值必须大于等于 0 且小于 C；若 soft_label=True 且没有指定 label_smoothing ，要求 label 的维度、数据类型与 input 相同，且每个样本各软标签的总和为 1；若指定了 label_smoothing (label_smoothing > 0.0) 时，无论 soft_label 是什么值，label 的维度和数据类型可以是前面两种情况中的任意一种。换句话说，如果 label_smoothing > 0.0，label 可以是独热标签或整数标签。``target`` 为 ``label`` 的别名，行为完全一致。
+    - **input** (Tensor) - 维度为 :math:`[N_1, N_2, ..., N_k, C]` 的多维 Tensor，其中最后一维 C 是类别数目。数据类型为 float32 或 float64。它需要未缩放的  ``input`` 。该 OP 不应该对 softmax 运算的输出进行操作，否则会产生错误的结果。
+    - **label** (Tensor) - 输入 input 对应的标签值。若 soft_label=False，要求 label 维度为 :math:`[N_1, N_2, ..., N_k]` 或 :math:`[N_1, N_2, ..., N_k, 1]`，数据类型为'int32', 'int64', 'float32', 'float64'，且值必须大于等于 0 且小于 C；若 soft_label=True 且没有指定 label_smoothing ，要求 label 的维度、数据类型与 input 相同，且每个样本各软标签的总和为 1；若指定了 label_smoothing (label_smoothing > 0.0) 时，无论 soft_label 是什么值，label 的维度和数据类型可以是前面两种情况中的任意一种。换句话说，如果 label_smoothing > 0.0，label 可以是独热标签或整数标签。 ``target``  为  ``label``  的别名，行为完全一致。
     - **weight** (Tensor，可选) - 权重 Tensor，需要手动给每个类调整权重，形状是（C）。它的维度与类别相同，数据类型为 float32，float64。默认值为 None。
     - **ignore_index** (int) - 指定一个忽略的标签值，此标签值不参与计算，负值表示无需忽略任何标签值。仅在 soft_label=False 时有效。默认值为-100。
     - **reduction** (str，可选) - 指示如何按批次大小平均损失，可选值为"none","mean","sum"，如果选择是"mean"，则返回 reduce 后的平均损失；如果选择是"sum"，则返回 reduce 后的总损失。如果选择是"none"，则返回没有 reduce 的损失。默认值是“mean”。
     - **soft_label** (bool，可选) - 指明 label 是否为软标签。默认为 False，表示 label 为硬标签；若 soft_label=True 则表示软标签。
     - **label_smoothing** （float，可选）- 指定计算损失时的标签平滑度，它应该在 :math:`[0.0，1.0]` 范围内。其中 0.0 表示无平滑。使得平滑后的标签变成原始真实标签和均匀分布的混合，默认值： 0.0。
-    - **axis** (int，可选) - 进行 softmax 计算的维度索引。它应该在 :math:`[-1，dim-1]` 范围内，而 ``dim`` 是输入 logits 的维度。默认值：-1。
+    - **axis** (int，可选) - 进行 softmax 计算的维度索引。它应该在 :math:`[-1，dim-1]` 范围内，而  ``dim``  是输入 logits 的维度。默认值：-1。
     - **use_softmax** (bool，可选) - 指定是否对 input 进行 softmax 归一化。默认值：True。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/nn/functional/ctc_loss_cn.rst b/docs/api/paddle/nn/functional/ctc_loss_cn.rst
index 4fa60483883..f5f8e030cef 100644
--- a/docs/api/paddle/nn/functional/ctc_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/ctc_loss_cn.rst
@@ -12,15 +12,15 @@ ctc_loss
 :::::::::
     - **log_probs** (Tensor) - 经过 padding 的概率序列，其 shape 必须是 [max_logit_length, batch_size, num_classes + 1]。其中 max_logit_length 是最长输入序列的长度。该输入不需要经过 softmax 操作，因为其内部对 input 做了 softmax 操作。数据类型仅支持 float32。
     - **labels** (Tensor) - 经过 padding 的标签序列，其 shape 为 [batch_size, max_label_length]，其中 max_label_length 是最长的 label 序列的长度。数据类型支持 int32。
-    - **input_lengths** (Tensor) - 表示输入 ``log_probs`` 数据中每个序列的长度，shape 为 [batch_size]。数据类型支持 int64。
+    - **input_lengths** (Tensor) - 表示输入  ``log_probs``  数据中每个序列的长度，shape 为 [batch_size]。数据类型支持 int64。
     - **label_lengths** (Tensor) - 表示 label 中每个序列的长度，shape 为 [batch_size]。数据类型支持 int64。
     - **blank** (int，可选) - 空格标记的 ID 值，其取值范围为 [0, num_classes + 1)。数据类型支持 int32。默认值为 0。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：``'none'``, ``'mean'``, ``'sum'``。设置为 ``'mean'`` 时，对 loss 值除以 label_lengths，并返回所得商的均值；设置为 ``'sum'`` 时，返回 loss 值的总和；设置为 ``'none'`` 时，则直接返回输出的 loss 值。默认值为 ``'mean'``。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ,  ``'mean'`` ,  ``'sum'`` 。设置为  ``'mean'``  时，对 loss 值除以 label_lengths，并返回所得商的均值；设置为  ``'sum'``  时，返回 loss 值的总和；设置为  ``'none'``  时，则直接返回输出的 loss 值。默认值为  ``'mean'`` 。
     - **norm_by_times** (bool，可选) - 是否根据序列长度对梯度进行正则化。数据类型支持 bool。默认值为 False。
 
 返回
 :::::::::
-``Tensor``，输入 ``log_probs`` 和标签 ``labels`` 间的 `ctc loss`。如果 :attr:`reduction` 是 ``'none'``，则输出 loss 的维度为 [batch_size]。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出 Loss 的维度为 []。数据类型与输入的 ``log_probs`` 一致。
+ ``Tensor`` ，输入  ``log_probs``  和标签  ``labels``  间的 `ctc loss`。如果 :attr:`reduction` 是  ``'none'`` ，则输出 loss 的维度为 [batch_size]。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出 Loss 的维度为 []。数据类型与输入的  ``log_probs``  一致。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/dice_loss_cn.rst b/docs/api/paddle/nn/functional/dice_loss_cn.rst
index 5fef7972e7a..630a8e2996f 100644
--- a/docs/api/paddle/nn/functional/dice_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/dice_loss_cn.rst
@@ -18,13 +18,13 @@ dice_loss 定义为：
 ::::::::::::
 
     - **input** (Tensor) - 分类的预测概率，秩大于等于 2 的多维 Tensor，维度为 :math:`[N_1, N_2, ..., N_k, D]`。第一个维度的大小是 batch_size，最后一维的大小 D 是类别数目。数据类型是 float32 或者 float64。
-    - **label** (Tensor)- 正确的标注数据(groud truth)，与输入 ``input`` 的秩相同的 Tensor，维度为 :math:`[N_1, N_2, ..., N_k, 1]`。第一个维度的大小是 batch_size，最后一个维度的大小是 1。数据类型为 int32 或者 int64。
+    - **label** (Tensor)- 正确的标注数据(groud truth)，与输入  ``input``  的秩相同的 Tensor，维度为 :math:`[N_1, N_2, ..., N_k, 1]`。第一个维度的大小是 batch_size，最后一个维度的大小是 1。数据类型为 int32 或者 int64。
     - **epsilon** (float，可选) - 将会加到分子和分母上的数，浮点型的数值。如果输入和标签都为空，则确保 dice 为 1。默认值：0.00001。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
- Tensor，shape 为 [batch_size, 1]，数据类型与 ``input`` 相同
+ Tensor，shape 为 [batch_size, 1]，数据类型与  ``input``  相同
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/dropout1d_cn.rst b/docs/api/paddle/nn/functional/dropout1d_cn.rst
index 89a340fb9a1..077fcc17116 100644
--- a/docs/api/paddle/nn/functional/dropout1d_cn.rst
+++ b/docs/api/paddle/nn/functional/dropout1d_cn.rst
@@ -5,20 +5,20 @@ dropout1d
 
 .. py:function:: paddle.nn.functional.dropout1d(x, p=0.5, training=True, inplace=False)
 
-根据丢弃概率 ``p``，在训练过程中随机将某些 1D 通道置 0(对一个形状为 ``[N, C, L]`` 的 3D Tensor 或 ``[C, L]`` 的 2D Tensor，1D 通道指的是其中的形状为 ``L`` 的 1 维特征图)。
+根据丢弃概率  ``p`` ，在训练过程中随机将某些 1D 通道置 0(对一个形状为  ``[N, C, L]``  的 3D Tensor 或  ``[C, L]``  的 2D Tensor，1D 通道指的是其中的形状为  ``L``  的 1 维特征图)。
 
-基于 ``paddle.nn.functional.dropout`` 实现，如您想了解更多，请参见 :ref:`cn_api_paddle_nn_functional_dropout` 。
+基于  ``paddle.nn.functional.dropout``  实现，如您想了解更多，请参见 :ref:`cn_api_paddle_nn_functional_dropout` 。
 
 参数
 :::::::::
- - **x** (Tensor) - 形状为 ``[N, C, L]`` 的 3D Tensor 或 ``[C, L]`` 的 2D Tensor，数据类型为 float16、float32 或 float64。
+ - **x** (Tensor) - 形状为  ``[N, C, L]``  的 3D Tensor 或  ``[C, L]``  的 2D Tensor，数据类型为 float16、float32 或 float64。
  - **p** (float，可选) - 将输入通道置 0 的概率，即丢弃概率，默认值为 0.5。
  - **training** (bool，可选) - 标记是否为训练阶段，默认值为 True。
  - **inplace** (bool，可选) - 是否原地操作。当前版本暂未实现(行为等同于 False)，未来版本将支持，默认值为 False。
 
 返回
 :::::::::
-经过 dropout1d 之后的结果，与输入 ``x`` 形状相同的 ``Tensor``。
+经过 dropout1d 之后的结果，与输入  ``x``  形状相同的  ``Tensor`` 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/dropout2d_cn.rst b/docs/api/paddle/nn/functional/dropout2d_cn.rst
index 64d3277dd47..ef1482c8232 100644
--- a/docs/api/paddle/nn/functional/dropout2d_cn.rst
+++ b/docs/api/paddle/nn/functional/dropout2d_cn.rst
@@ -7,7 +7,7 @@ dropout2d
 
 根据丢弃概率 `p`，在训练过程中随机将某些通道特征图置 0 (对一个形状为 `NCHW` 的 4 维 Tensor，通道特征图指的是其中的形状为 `HW` 的 2 维特征图)。
 
-基于 ``paddle.nn.functional.dropout`` 实现，如您想了解更多，请参见 :ref:`cn_api_paddle_nn_functional_dropout` 。
+基于  ``paddle.nn.functional.dropout``  实现，如您想了解更多，请参见 :ref:`cn_api_paddle_nn_functional_dropout` 。
 
 参数
 :::::::::
diff --git a/docs/api/paddle/nn/functional/dropout3d_cn.rst b/docs/api/paddle/nn/functional/dropout3d_cn.rst
index c112ef7dcf6..50e79ccfcf6 100644
--- a/docs/api/paddle/nn/functional/dropout3d_cn.rst
+++ b/docs/api/paddle/nn/functional/dropout3d_cn.rst
@@ -8,7 +8,7 @@ dropout3d
 根据丢弃概率 `p`，在训练过程中随机将某些通道特征图置 0 (对一个形状为 `NCDHW` 的 5 维 Tensor，通道指的是其中的形状为 `DHW` 的 3 维特征图)。
 
 .. note::
-   基于 ``paddle.nn.functional.dropout`` 实现，如您想了解更多，请参见 :ref:`cn_api_paddle_nn_functional_dropout` 。
+   基于  ``paddle.nn.functional.dropout``  实现，如您想了解更多，请参见 :ref:`cn_api_paddle_nn_functional_dropout` 。
 
 参数
 :::::::::
diff --git a/docs/api/paddle/nn/functional/dropout_cn.rst b/docs/api/paddle/nn/functional/dropout_cn.rst
index a967ce02d78..ad636e340eb 100644
--- a/docs/api/paddle/nn/functional/dropout_cn.rst
+++ b/docs/api/paddle/nn/functional/dropout_cn.rst
@@ -33,7 +33,7 @@ Dropout 是一种正则化手段，可根据给定的丢弃概率 `p`，在训
 
 使用示例 1
 :::::::::
-axis 参数的默认值为 None。当 ``axis=None`` 时，dropout 的功能为：对输入 Tensor x 中的任意元素，以丢弃概率 p 随机将一些元素输出置 0。这是我们最常见的 dropout 用法。
+axis 参数的默认值为 None。当  ``axis=None``  时，dropout 的功能为：对输入 Tensor x 中的任意元素，以丢弃概率 p 随机将一些元素输出置 0。这是我们最常见的 dropout 用法。
 
  -  下面以一个示例来解释它的实现逻辑，同时展示其它参数的含义。
 
@@ -50,7 +50,7 @@ axis 参数的默认值为 None。当 ``axis=None`` 时，dropout 的功能为
    将输入 x 和生成的 mask 点积，就得到了随机丢弃部分元素之后的结果：
    [[0 2 0]
     [4 0 6]]
-   假定 dropout 的概率使用默认值，即 ``p=0.5``，若 mode 参数使用默认值，即 ``mode='upscale_in_train'`` ，
+   假定 dropout 的概率使用默认值，即  ``p=0.5`` ，若 mode 参数使用默认值，即  ``mode='upscale_in_train'``  ，
    则在训练阶段，最终增大后的结果为：
    [[0 4 0 ]
     [8 0 12]]
@@ -68,10 +68,10 @@ axis 参数的默认值为 None。当 ``axis=None`` 时，dropout 的功能为
 :::::::::
 若参数 axis 不为 None，dropout 的功能为：以一定的概率从图像特征或语音序列中丢弃掉整个通道。
 
- -  axis 应设置为：``[0, 1, ... , ndim(x)-1]`` 的子集（ndim(x) 为输入 x 的维度），例如：
+ -  axis 应设置为： ``[0, 1, ... , ndim(x)-1]``  的子集（ndim(x) 为输入 x 的维度），例如：
 
-   - 若 x 的维度为 2，参数 axis 可能的取值有 4 种：``None``, ``[0]``, ``[1]``, ``[0,1]``
-   - 若 x 的维度为 3，参数 axis 可能的取值有 8 种：``None``, ``[0]``, ``[1]``, ``[2]``, ``[0,1]``, ``[0,2]``, ``[1,2]``, ``[0,1,2]``
+   - 若 x 的维度为 2，参数 axis 可能的取值有 4 种： ``None`` ,  ``[0]`` ,  ``[1]`` ,  ``[0,1]`` 
+   - 若 x 的维度为 3，参数 axis 可能的取值有 8 种： ``None`` ,  ``[0]`` ,  ``[1]`` ,  ``[2]`` ,  ``[0,1]`` ,  ``[0,2]`` ,  ``[1,2]`` ,  ``[0,1,2]`` 
 
  -  下面以维度为 2 的输入 Tensor 展示 axis 参数的用法：
 
@@ -80,7 +80,7 @@ axis 参数的默认值为 None。当 ``axis=None`` 时，dropout 的功能为
    假定 x 是形状为 2*3 的 2 维 Tensor:
    [[1 2 3]
     [4 5 6]]
-   (1) 若 ``axis=[0]``，则表示只在第 0 个维度做 dropout。这时生成 mask 的形状为 2*1。
+   (1) 若  ``axis=[0]`` ，则表示只在第 0 个维度做 dropout。这时生成 mask 的形状为 2*1。
      例如，我们可能会得到这样的 mask:
      [[1]
       [0]]
@@ -92,7 +92,7 @@ axis 参数的默认值为 None。当 ``axis=None`` 时，dropout 的功能为
       [0 0 0]]
      之后依据其它参数的设置，得到最终的输出结果。
 
-   (2) 若 ``axis=[1]``，则表示只在第 1 个维度做 dropout。这时生成的 mask 形状为 1*3。
+   (2) 若  ``axis=[1]`` ，则表示只在第 1 个维度做 dropout。这时生成的 mask 形状为 1*3。
      例如，我们可能会得到这样的 mask:
      [[1 0 1]]
      这个 1*3 的 mask 在和 x 做点积的时候，会首先广播成一个 2*3 的矩阵：
@@ -101,11 +101,11 @@ axis 参数的默认值为 None。当 ``axis=None`` 时，dropout 的功能为
      点积所得结果为：
      [[1 0 3]
       [4 0 6]]
-   (3) 若 ``axis=[0, 1]``，则表示在第 0 维和第 1 维上做 dropout。此时与默认设置 ``axis=None`` 的作用一致。
+   (3) 若  ``axis=[0, 1]`` ，则表示在第 0 维和第 1 维上做 dropout。此时与默认设置  ``axis=None``  的作用一致。
 
-若输入 x 为 4 维 Tensor，形状为 `NCHW`，其中 N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度，当设置 ``axis=[0,1]`` 时，则只会在通道 `N` 和 `C` 上做 dropout，通道 `H` 和 `W` 的元素是绑定在一起的，即：``paddle.nn.functional.dropout(x, p, axis=[0,1])``，此时对 4 维 Tensor 中的某个 2 维特征图（形状为 `HW`），或者全部置 0，或者全部保留，这便是 dropout2d 的实现。详情参考 :ref:`cn_api_paddle_nn_functional_dropout2d` 。
+若输入 x 为 4 维 Tensor，形状为 `NCHW`，其中 N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度，当设置  ``axis=[0,1]``  时，则只会在通道 `N` 和 `C` 上做 dropout，通道 `H` 和 `W` 的元素是绑定在一起的，即： ``paddle.nn.functional.dropout(x, p, axis=[0,1])`` ，此时对 4 维 Tensor 中的某个 2 维特征图（形状为 `HW`），或者全部置 0，或者全部保留，这便是 dropout2d 的实现。详情参考 :ref:`cn_api_paddle_nn_functional_dropout2d` 。
 
-类似的，若输入 x 为 5 维 Tensor，形状为 `NCDHW`，其中 D 是特征深度，当设置 ``axis=[0,1]`` 时，便可实现 dropout3d。详情参考 :ref:`cn_api_paddle_nn_functional_dropout3d` 。
+类似的，若输入 x 为 5 维 Tensor，形状为 `NCDHW`，其中 D 是特征深度，当设置  ``axis=[0,1]``  时，便可实现 dropout3d。详情参考 :ref:`cn_api_paddle_nn_functional_dropout3d` 。
 
 .. note::
    关于广播 (broadcasting) 机制，如您想了解更多，请参见 `Tensor 介绍`_ .
diff --git a/docs/api/paddle/nn/functional/elu_cn.rst b/docs/api/paddle/nn/functional/elu_cn.rst
index 81118671f3f..2a200b2a6b1 100644
--- a/docs/api/paddle/nn/functional/elu_cn.rst
+++ b/docs/api/paddle/nn/functional/elu_cn.rst
@@ -23,13 +23,13 @@ elu 激活层（ELU Activation Operator）
 
 参数
 ::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
     - **alpha** (float，可选) - elu 的 alpha 值，默认值为 1.0。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/embedding_cn.rst b/docs/api/paddle/nn/functional/embedding_cn.rst
index 1ffbf56ae54..bd5c3044ece 100644
--- a/docs/api/paddle/nn/functional/embedding_cn.rst
+++ b/docs/api/paddle/nn/functional/embedding_cn.rst
@@ -13,10 +13,10 @@ embedding
 
 .. note::
 
-   x 中的 id 必须满足 ``0 =< id < size[0]``，否则程序会抛异常退出。
+   x 中的 id 必须满足  ``0 =< id < size[0]`` ，否则程序会抛异常退出。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` 。
 
 
 .. code-block:: text
@@ -42,12 +42,12 @@ embedding
 ::::::::::::
 
 
-    - **x** (Tensor) - 存储 id 信息的 Tensor，数据类型必须为：int32/int64。input 中的 id 必须满足 ``0 =< id < size[0]`` 。
-      别名： ``input``
+    - **x** (Tensor) - 存储 id 信息的 Tensor，数据类型必须为：int32/int64。input 中的 id 必须满足  ``0 =< id < size[0]``  。
+      别名：  ``input`` 
     - **weight** (Tensor) - 存储词嵌入权重参数的 Tensor，形状为(num_embeddings, embedding_dim)。
-    - **padding_idx** (int|long|None，可选) - padding_idx 的配置区间为 ``[-weight.shape[0], weight.shape[0]``，如果配置了 padding_idx，那么在训练过程中遇到此 id 时，其参数及对应的梯度将会以 0 进行填充。如果 padding_idx < 0 ，则 padding_idx 将自动转换到 ``weight.shape[0] + padding_idx`` 。如果设置为 "None"，则不会对输出产生影响。默认值：None。
-    - **max_norm** (float，可选) - 若声明，会将范数大于此值的词嵌入向量重新归一化，使其范数等于此值。在动态图模式下会对 ``weight`` 产生 inplace 修改。默认值为 None。
-    - **norm_type** (float) - 应用 ``max_norm`` 时所计算的 p 阶范数的 p 值。默认值 2.0。
+    - **padding_idx** (int|long|None，可选) - padding_idx 的配置区间为  ``[-weight.shape[0], weight.shape[0]`` ，如果配置了 padding_idx，那么在训练过程中遇到此 id 时，其参数及对应的梯度将会以 0 进行填充。如果 padding_idx < 0 ，则 padding_idx 将自动转换到  ``weight.shape[0] + padding_idx``  。如果设置为 "None"，则不会对输出产生影响。默认值：None。
+    - **max_norm** (float，可选) - 若声明，会将范数大于此值的词嵌入向量重新归一化，使其范数等于此值。在动态图模式下会对  ``weight``  产生 inplace 修改。默认值为 None。
+    - **norm_type** (float) - 应用  ``max_norm``  时所计算的 p 阶范数的 p 值。默认值 2.0。
     - **sparse** (bool，可选) - 是否使用稀疏更新，在词嵌入权重较大的情况下，使用稀疏更新（即设置为 True）能够获得更快的训练速度及更小的内存/显存占用。但是一些优化器不支持稀疏更新，例如 :ref:`cn_api_paddle_optimizer_Adadelta` ， :ref:`cn_api_paddle_optimizer_Adamax` ， :ref:`cn_api_paddle_optimizer_Lamb` 。在这些情况下，稀疏必须为 False。默认值：False。
     - **scale_grad_by_freq** (bool，可选) - 是否根据单词在 mini-batch 中出现频率的倒数缩放梯度。默认值 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
diff --git a/docs/api/paddle/nn/functional/fold_cn.rst b/docs/api/paddle/nn/functional/fold_cn.rst
index fe80191c0a4..2348ced9758 100644
--- a/docs/api/paddle/nn/functional/fold_cn.rst
+++ b/docs/api/paddle/nn/functional/fold_cn.rst
@@ -21,9 +21,9 @@ fold
 参数
 :::::::::
     - **x**  (Tensor) – 输入 3-D Tensor，形状为[N, C, L]，数据类型为 float32 、 float64 、 complex64 或 complex128
-    - **output_sizes**  (int|list|tuple) – 输出尺寸，整数或者整型列表。如为列表类型应包含两个元素 ``[output_size_h, output_size_w]``。如果为整数 o，则输出形状会被认为 ``[o, o]``。
-    - **kernel_size** (int|list|tuple) - 卷积核大小，整数或者整型列表。如为列表类型应包含两个元素 ``[k_h, k_w]``。如果为整数 k，则输出形状会被认为 ``[k, k]``。
-    - **strides** (int|list|tuple，可选) - 步长大小，整数或者整型列表。如为列表类型应包含两个元素 ``[stride_h, stride_w]``。如果为整数 stride，则输出形状会被认为 ``[sride, stride]``。默认为[1,1]。
+    - **output_sizes**  (int|list|tuple) – 输出尺寸，整数或者整型列表。如为列表类型应包含两个元素  ``[output_size_h, output_size_w]`` 。如果为整数 o，则输出形状会被认为  ``[o, o]`` 。
+    - **kernel_size** (int|list|tuple) - 卷积核大小，整数或者整型列表。如为列表类型应包含两个元素  ``[k_h, k_w]`` 。如果为整数 k，则输出形状会被认为  ``[k, k]`` 。
+    - **strides** (int|list|tuple，可选) - 步长大小，整数或者整型列表。如为列表类型应包含两个元素  ``[stride_h, stride_w]`` 。如果为整数 stride，则输出形状会被认为  ``[sride, stride]`` 。默认为[1,1]。
     - **paddings** (int|list|tuple，可选) – 每个维度的扩展，整数或者整型列表。如果为整型列表，长度应该为 4 或者 2；长度为 4 对应的 padding 参数是：[padding_top, padding_left，padding_bottom, padding_right]，长度为 2 对应的 padding 参数是[padding_h, padding_w]，会被当作[padding_h, padding_w, padding_h, padding_w]处理。如果为整数 padding，则会被当作[padding, padding, padding, padding]处理。默认值为 0。
     - **dilations** (int|list|tuple，可选) – 卷积膨胀，整型列表或者整数。如果为整型列表，应该包含两个元素[dilation_h, dilation_w]。如果是整数 dilation，会被当作整型列表[dilation, dilation]处理。默认值为 1。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
@@ -32,7 +32,7 @@ fold
 
 形状
 :::::::::
- - **输出** ：Tensor，fold 操作之后的结果，形状如上面所描述的[N, Cout, H_out, W_out]，数据类型与 ``x`` 相同
+ - **输出** ：Tensor，fold 操作之后的结果，形状如上面所描述的[N, Cout, H_out, W_out]，数据类型与  ``x``  相同
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/gather_tree_cn.rst b/docs/api/paddle/nn/functional/gather_tree_cn.rst
index 6a7995fdf7d..b0fddfb934a 100644
--- a/docs/api/paddle/nn/functional/gather_tree_cn.rst
+++ b/docs/api/paddle/nn/functional/gather_tree_cn.rst
@@ -8,7 +8,7 @@ gather_tree
 
 
 
-在整个束搜索 (Beam Search) 结束后使用。在搜索结束后，可以获得每个时间步选择的的候选词 id 及其对应的在搜索树中的 parent 节点，``ids`` 和 ``parents`` 的形状布局均为 :math:`[max\_time, batch\_size, beam\_size]`，从最后一个时间步回溯产生完整的 id 序列。
+在整个束搜索 (Beam Search) 结束后使用。在搜索结束后，可以获得每个时间步选择的的候选词 id 及其对应的在搜索树中的 parent 节点， ``ids``  和  ``parents``  的形状布局均为 :math:`[max\_time, batch\_size, beam\_size]`，从最后一个时间步回溯产生完整的 id 序列。
 
 
 示例：
@@ -44,11 +44,11 @@ gather_tree
 ::::::::::::
 
     - **ids** (Tensor) - 形状为 :math:`[length, batch\_size, beam\_size]` 的三维 Tensor，数据类型是 int32 或 int64。包含了所有时间步选择的 id。
-    - **parents** (Tensor) - 形状和数据类型均与 ``ids`` 相同的 Tensor。包含了束搜索中每一时间步所选 id 对应的 parent。
+    - **parents** (Tensor) - 形状和数据类型均与  ``ids``  相同的 Tensor。包含了束搜索中每一时间步所选 id 对应的 parent。
 
 返回
 ::::::::::::
-和 ``ids`` 具有相同形状和数据类型的 Tensor。包含了根据 parent 回溯而收集产生的完整 id 序列。
+和  ``ids``  具有相同形状和数据类型的 Tensor。包含了根据 parent 回溯而收集产生的完整 id 序列。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/nn/functional/gaussian_nll_loss_cn.rst b/docs/api/paddle/nn/functional/gaussian_nll_loss_cn.rst
index ade63c5bc8a..e99a58d36ac 100644
--- a/docs/api/paddle/nn/functional/gaussian_nll_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/gaussian_nll_loss_cn.rst
@@ -20,7 +20,7 @@ gaussian_nll_loss
 - **variance** (Tensor): 输入 :attr:`Tensor`，其形状为 :math:`(N, *)` 或者 :math:`(*)`，形状与 :attr:`input` 相同，或者维度与 input 相同但最后一维的大小为 1，或者维度与 input 相比缺少最后一维，如 :attr:`input` 的形状为： :math:`(N, 3)` 时， :attr:`input` 的形状可为 :math:`(N, 1)` 或 :math:`(N)`，这时会进行 broadcast 操作。正方差样本，可为不同标签对应不同的方差（异方差性），也可以为同一个方差（同方差性）。数据类型为 float32 或 float64。
 - **full** (bool，可选) - 是否在损失计算中包括常数项。默认情况下为 False，表示忽略最后的常数项。
 - **epsilon** (float，可选) - 用于限制 variance 的值，使其不会导致除 0 的出现。默认值为 1e-6。
-- **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有 ``none``、``mean`` 和 ``sum``。默认为 ``mean``，计算 ``mini-batch`` loss 均值。设置为 `sum` 时，计算 `mini-batch` loss 的总和。设置为 ``none`` 时，则返回 loss Tensor。
+- **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有  ``none`` 、 ``mean``  和  ``sum`` 。默认为  ``mean`` ，计算  ``mini-batch``  loss 均值。设置为 `sum` 时，计算 `mini-batch` loss 的总和。设置为  ``none``  时，则返回 loss Tensor。
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/nn/functional/gelu_cn.rst b/docs/api/paddle/nn/functional/gelu_cn.rst
index 99a8f967dc2..a3a6032d5f5 100644
--- a/docs/api/paddle/nn/functional/gelu_cn.rst
+++ b/docs/api/paddle/nn/functional/gelu_cn.rst
@@ -22,19 +22,19 @@ gelu 激活层（GELU Activation Operator）
 其中，:math:`x` 为输入的 Tensor。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``。
+    别名支持: 参数名  ``input``  可替代  ``x`` 。
 
 参数
 ::::::::::::
- - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
-   别名： ``input``。
+ - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
+   别名：  ``input`` 。
  - **approximate** (str | bool，可选) - 是否使用近似计算，默认值为 False，表示不使用近似计算。
-   当 ``approximate`` 为 ``none`` 时等价于 False；为 ``tanh`` 时等价于 True；为其他字符串时会报错。
+   当  ``approximate``  为  ``none``  时等价于 False；为  ``tanh``  时等价于 True；为其他字符串时会报错。
  - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/glu_cn.rst b/docs/api/paddle/nn/functional/glu_cn.rst
index 3136d42efd5..084f6c2f6b7 100644
--- a/docs/api/paddle/nn/functional/glu_cn.rst
+++ b/docs/api/paddle/nn/functional/glu_cn.rst
@@ -12,14 +12,14 @@ glu
 
 参数
 ::::::::::::
- - **x** (Tensor) - 输入的 ``Tensor``，数据类型为 float32 或 float64。
+ - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为 float32 或 float64。
  - **axis** (int，可选) - 沿着该轴将输入二等分。:math:`D` 为输入的维数，则 :attr:`axis` 应该在 :math:`[-D, D)` 的范围内。如 :attr:`axis` 为负数，则相当于 :math:`axis + D`，默认值为-1。
  - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
 
-``Tensor``，数据类型同 :attr:`x` 一致，在指定的轴上其尺寸减半。
+ ``Tensor`` ，数据类型同 :attr:`x` 一致，在指定的轴上其尺寸减半。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/group_norm_cn.rst b/docs/api/paddle/nn/functional/group_norm_cn.rst
index 021bdcb7075..a784d0cf3fe 100644
--- a/docs/api/paddle/nn/functional/group_norm_cn.rst
+++ b/docs/api/paddle/nn/functional/group_norm_cn.rst
@@ -5,13 +5,13 @@ group_norm
 
 .. py:function:: paddle.nn.functional.group_norm(x, num_groups, epsilon=1e-05, weight=None, bias=None, data_format='NCHW', name=None)
 
-对输入 ``x`` 进行组归一化， 计算公式如下：
+对输入  ``x``  进行组归一化， 计算公式如下：
 
 .. math::
     y = \frac{x - E(x)}{\sqrt(Var(x)+ epsilon )} \ast weight + bias
 
-- :math:`x`: 形状为 [批大小，通道数，\*] 或 [批大小，\*，通道数]，其中通道数必须是 ``num_groups`` 的整数倍
-- :math:`E(x)`, :math:`Var(x)`: 每一组中 ``x`` 的均值和方差
+- :math:`x`: 形状为 [批大小，通道数，\*] 或 [批大小，\*，通道数]，其中通道数必须是  ``num_groups``  的整数倍
+- :math:`E(x)`, :math:`Var(x)`: 每一组中  ``x``  的均值和方差
 
 更多详情请参考：`Group Normalization <https://arxiv.org/abs/1803.08494>`_ 。
 
@@ -19,7 +19,7 @@ group_norm
 ::::::::::::
 
     - **x** (Tensor) - 输入 Tensor，形状为 [批大小，通道数，\*]。
-    - **num_groups** (int) - 从通道中分离出来的 ``group`` 的数目。
+    - **num_groups** (int) - 从通道中分离出来的  ``group``  的数目。
     - **epsilon** (float，可选) - 为防止方差除零，增加一个很小的值。默认值：1e-05。
     - **weight** (Tensor，可选) - 权重的 Tensor，形状为 [通道数]，默认为 None。
     - **bias** (Tensor，可选) - 偏置的 Tensor，形状为 [通道数]，默认为 None。
@@ -29,7 +29,7 @@ group_norm
 
 返回
 ::::::::::::
-    ``Tensor``，输出形状与 ``x`` 一致。
+     ``Tensor`` ，输出形状与  ``x``  一致。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/nn/functional/gumbel_softmax_cn.rst b/docs/api/paddle/nn/functional/gumbel_softmax_cn.rst
index e62cb84c81e..ae665cb94d1 100644
--- a/docs/api/paddle/nn/functional/gumbel_softmax_cn.rst
+++ b/docs/api/paddle/nn/functional/gumbel_softmax_cn.rst
@@ -4,7 +4,7 @@ gumbel_softmax
 -------------------------------
 .. py:function:: paddle.nn.functional.gumbel_softmax(x, temperature = 1.0, hard = False, axis = -1, name = None)
 
-实现了按 Gumbel-Softmax 分布进行采样的功能，通过 hard 可选择是否离散化。记 temperature 为 ``t``，涉及到的等式如下：
+实现了按 Gumbel-Softmax 分布进行采样的功能，通过 hard 可选择是否离散化。记 temperature 为  ``t`` ，涉及到的等式如下：
 
 1. 产生 gumbel 噪声
 
@@ -12,7 +12,7 @@ gumbel_softmax
 
     G_i = -log(-log(U_i)),\ U_i \sim U(0,1)
 
-2. 对输入 ``x`` 添加噪声
+2. 对输入  ``x``  添加噪声
 
 .. math::
 
@@ -35,7 +35,7 @@ gumbel_softmax
 
 返回
 ::::::::::
-    与 ``x`` 形状相同的符合 gumbel-softmax 分布的 ``Tensor``。如果 ``hard=True``，则返回的样本将是 one-hot。如果 ``hard=False``，则返回的向量将是各维度加起来等于 1 的概率。
+    与  ``x``  形状相同的符合 gumbel-softmax 分布的  ``Tensor`` 。如果  ``hard=True`` ，则返回的样本将是 one-hot。如果  ``hard=False`` ，则返回的向量将是各维度加起来等于 1 的概率。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/hardshrink_cn.rst b/docs/api/paddle/nn/functional/hardshrink_cn.rst
index 4315633984b..7c734a58eda 100644
--- a/docs/api/paddle/nn/functional/hardshrink_cn.rst
+++ b/docs/api/paddle/nn/functional/hardshrink_cn.rst
@@ -21,13 +21,13 @@ hardshrink 激活层。计算公式如下：
 
 参数
 ::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
     - **threshold** (float，可选) - hard_shrink 激活计算公式中的 threshold 值。默认值为 0.5。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/hardsigmoid_cn.rst b/docs/api/paddle/nn/functional/hardsigmoid_cn.rst
index eeae34cef34..51db6e86879 100644
--- a/docs/api/paddle/nn/functional/hardsigmoid_cn.rst
+++ b/docs/api/paddle/nn/functional/hardsigmoid_cn.rst
@@ -22,14 +22,14 @@ hardsigmoid 激活层。sigmoid 的分段线性逼近激活函数，速度比 si
 
 参数
 ::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
     - **slope** (float，可选) - hardsigmoid 的斜率。默认值为 0.1666667。
     - **offset** (float，可选) - hardsigmoid 的截距。默认值为 0.5。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/hardswish_cn.rst b/docs/api/paddle/nn/functional/hardswish_cn.rst
index 6bb512cc091..7cef3ab4b62 100644
--- a/docs/api/paddle/nn/functional/hardswish_cn.rst
+++ b/docs/api/paddle/nn/functional/hardswish_cn.rst
@@ -22,12 +22,12 @@ hardswish 激活函数。在 MobileNetV3 架构中被提出，相较于 swish 
 
 参数
 ::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/hardtanh_cn.rst b/docs/api/paddle/nn/functional/hardtanh_cn.rst
index 8188ff34e4e..8904d025421 100644
--- a/docs/api/paddle/nn/functional/hardtanh_cn.rst
+++ b/docs/api/paddle/nn/functional/hardtanh_cn.rst
@@ -21,14 +21,14 @@ hardtanh 激活层（Hardtanh Activation Operator）。计算输入 `x` 的 `har
 
 参数
 ::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
     - **min** (float，可选) - hardtanh 激活计算公式中的 min 值。默认值为-1。
     - **max** (float，可选) - hardtanh 激活计算公式中的 max 值。默认值为 1。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/hinge_embedding_loss_cn.rst b/docs/api/paddle/nn/functional/hinge_embedding_loss_cn.rst
index e94aa4d4c94..1ade0b18299 100644
--- a/docs/api/paddle/nn/functional/hinge_embedding_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/hinge_embedding_loss_cn.rst
@@ -30,9 +30,9 @@ hinge_embedding_loss
 参数
 :::::::::
     - **input** (Tensor): - 输入的 Tensor，维度是 [N, *]，其中 N 是 batch size， `*` 是任意数量的额外维度。数据类型为：float32、float64。
-    - **label** (Tensor): - 标签，维度是 [N, *]，与 ``input`` 相同，Tensor 中的值应该只包含 1 和 -1。数据类型为：float32、float64。
+    - **label** (Tensor): - 标签，维度是 [N, *]，与  ``input``  相同，Tensor 中的值应该只包含 1 和 -1。数据类型为：float32、float64。
     - **margin** (float，可选): - 当 label 为 -1 时，该值决定了小于 `margin` 的 input 才需要纳入 `hinge embedding loss` 的计算。默认为 1.0 。
-    - **reduction** (str，可选): - 指定应用于输出结果的计算方式，可选值有：``'none'``, ``'mean'``, ``'sum'``。默认为 ``'mean'``，计算 `hinge embedding loss` 的均值；设置为 ``'sum'`` 时，计算 `hinge embedding loss` 的总和；设置为 ``'none'`` 时，则返回 `hinge embedding loss`。
+    - **reduction** (str，可选): - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ,  ``'mean'`` ,  ``'sum'`` 。默认为  ``'mean'`` ，计算 `hinge embedding loss` 的均值；设置为  ``'sum'``  时，计算 `hinge embedding loss` 的总和；设置为  ``'none'``  时，则返回 `hinge embedding loss`。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
@@ -42,8 +42,8 @@ hinge_embedding_loss
 形状
 :::::::::
     - **input** (Tensor): - 输入的 Tensor，维度是 [N, *]，其中 N 是 batch size， `*` 是任意数量的额外维度。数据类型为：float32、float64。
-    - **label** (Tensor): - 标签，维度是 [N, *]，与 ``input`` 相同，应该只包含 1 和 -1。数据类型为：float32、float64。
-    - **output** (Tensor): - 输入 ``input`` 和标签 ``label`` 间的 `hinge embedding loss` 损失。如果 `reduction` 是 ``'none'``，则输出 Loss 的维度为 [N, *]，与输入 ``input`` 相同。如果 `reduction` 是 ``'mean'`` 或 ``'sum'``，则输出 Loss 的维度为 []。
+    - **label** (Tensor): - 标签，维度是 [N, *]，与  ``input``  相同，应该只包含 1 和 -1。数据类型为：float32、float64。
+    - **output** (Tensor): - 输入  ``input``  和标签  ``label``  间的 `hinge embedding loss` 损失。如果 `reduction` 是  ``'none'`` ，则输出 Loss 的维度为 [N, *]，与输入  ``input``  相同。如果 `reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出 Loss 的维度为 []。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/hsigmoid_loss_cn.rst b/docs/api/paddle/nn/functional/hsigmoid_loss_cn.rst
index adb4e0aea74..260dfe5a4c1 100644
--- a/docs/api/paddle/nn/functional/hsigmoid_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/hsigmoid_loss_cn.rst
@@ -13,31 +13,31 @@ hsigmoid_loss
 
 若使用默认树结构，请参考 `Hierarchical Probabilistic Neural Network Language Model <http://www.iro.umontreal.ca/~lisa/pointeurs/hierarchical-nnlm-aistats05.pdf>`_ 。
 
-若使用自定义树结构，请将参数 ``is_custom`` 设置为 True，并完成以下步骤（以语言模型为例）：
+若使用自定义树结构，请将参数  ``is_custom``  设置为 True，并完成以下步骤（以语言模型为例）：
 
 1. 使用自定义词典来建立二叉树，每个叶结点都应该是词典中的单词；
 
-2. 建立一个 dict 类型数据结构，用于存储 **单词 id -> 该单词叶结点至根节点路径** 的映射，即路径表 ``path_table`` 参数；
+2. 建立一个 dict 类型数据结构，用于存储 **单词 id -> 该单词叶结点至根节点路径** 的映射，即路径表  ``path_table``  参数；
 
-3. 建立一个 dict 类型数据结构，用于存储 **单词 id -> 该单词叶结点至根节点路径的编码** 的映射，即路径编码 ``path_code`` 参数。编码是指每次二分类的标签，1 为真，0 为假；
+3. 建立一个 dict 类型数据结构，用于存储 **单词 id -> 该单词叶结点至根节点路径的编码** 的映射，即路径编码  ``path_code``  参数。编码是指每次二分类的标签，1 为真，0 为假；
 
 4. 每个单词都已经有自己的路径和路径编码，当对于同一批输入进行操作时，可以同时传入一批路径和路径编码进行运算。
 
 参数
 ::::::::::
-    - **input** (Tensor) - 输入 Tensor。数据类型为 float32 或 float64，形状为 ``[N, D]``，其中 ``N`` 为 minibatch 的大小，``D`` 为特征大小。
-    - **label** (Tensor) - 训练数据的标签。数据类型为 int64，形状为 ``[N, 1]`` 。
-    - **num_classes** (int) - 类别总数(字典大小)必须大于等于 2。若使用默认树结构，即当 ``path_table`` 和 ``path_code`` 都为 None 时，必须设置该参数。若使用自定义树结构，即当 ``path_table`` 和 ``path_code`` 都不为 None 时，它取值应为自定义树结构的非叶节点的个数，用于指定二分类的类别总数。
-    - **weight** (Tensor) - 权重参数。形状为 ``[numclasses-1, D]``，数据类型和 ``input`` 相同。
-    - **bias** (Tensor，可选) - 偏置参数。形状为 ``[numclasses-1, 1]``，数据类型和 ``input`` 相同。如果设置为 None，将没有偏置参数。默认值为 None。
-    - **path_table** (Tensor，可选) - 存储每一批样本从类别（单词）到根节点的路径，按照从叶至根方向存储。数据类型为 int64，形状为 ``[N, L]``，其中 L 为路径长度。``path_table`` 和 ``path_code`` 应具有相同的形状，对于每个样本 i，path_table[i]为一个类似 np.ndarray 的结构，该数组内的每个元素都是其双亲结点权重矩阵的索引。默认值为 None。
-    - **path_code** (Tensor，可选) - 存储每一批样本从类别（单词）到根节点的路径编码，按从叶至根方向存储。数据类型为 int64，形状为 ``[N, L]``。默认值为 None。
+    - **input** (Tensor) - 输入 Tensor。数据类型为 float32 或 float64，形状为  ``[N, D]`` ，其中  ``N``  为 minibatch 的大小， ``D``  为特征大小。
+    - **label** (Tensor) - 训练数据的标签。数据类型为 int64，形状为  ``[N, 1]``  。
+    - **num_classes** (int) - 类别总数(字典大小)必须大于等于 2。若使用默认树结构，即当  ``path_table``  和  ``path_code``  都为 None 时，必须设置该参数。若使用自定义树结构，即当  ``path_table``  和  ``path_code``  都不为 None 时，它取值应为自定义树结构的非叶节点的个数，用于指定二分类的类别总数。
+    - **weight** (Tensor) - 权重参数。形状为  ``[numclasses-1, D]`` ，数据类型和  ``input``  相同。
+    - **bias** (Tensor，可选) - 偏置参数。形状为  ``[numclasses-1, 1]`` ，数据类型和  ``input``  相同。如果设置为 None，将没有偏置参数。默认值为 None。
+    - **path_table** (Tensor，可选) - 存储每一批样本从类别（单词）到根节点的路径，按照从叶至根方向存储。数据类型为 int64，形状为  ``[N, L]`` ，其中 L 为路径长度。 ``path_table``  和  ``path_code``  应具有相同的形状，对于每个样本 i，path_table[i]为一个类似 np.ndarray 的结构，该数组内的每个元素都是其双亲结点权重矩阵的索引。默认值为 None。
+    - **path_code** (Tensor，可选) - 存储每一批样本从类别（单词）到根节点的路径编码，按从叶至根方向存储。数据类型为 int64，形状为  ``[N, L]`` 。默认值为 None。
     - **is_sparse** (bool，可选) - 是否使用稀疏更新方式。如果设置为 True，W 的梯度和输入梯度将会变得稀疏。默认值为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    - Tensor，层次 sigmoid 计算后的结果，形状为[N, 1]，数据类型和 ``input`` 一致。
+    - Tensor，层次 sigmoid 计算后的结果，形状为[N, 1]，数据类型和  ``input``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/instance_norm_cn.rst b/docs/api/paddle/nn/functional/instance_norm_cn.rst
index bf0c9570b2c..ee8263fc4c4 100644
--- a/docs/api/paddle/nn/functional/instance_norm_cn.rst
+++ b/docs/api/paddle/nn/functional/instance_norm_cn.rst
@@ -16,7 +16,7 @@ instance_norm
     - **weight** (Tensor，可选) - 权重的 Tensor。默认值：None. 如果 weight 为 None 则 weight 被初始化为全 1 的 Tensor.
     - **bias** (Tensor，可选) - 偏置的 Tensor。默认值：None. 如果 bias 为 None 则 bias 被初始化为值等于 0 的 Tensor.
     - **use_input_stats** (bool，可选) - 默认是 True。过时（已被删除，无法使用）
-    - **momentum** (float，可选) - 此值用于计算 ``moving_mean`` 和 ``moving_var``。默认值：0.9。更新公式如上所示。
+    - **momentum** (float，可选) - 此值用于计算  ``moving_mean``  和  ``moving_var`` 。默认值：0.9。更新公式如上所示。
     - **eps** (float，可选) - 为了数值稳定加在分母上的值。默认值：1e-05。
     - **data_format** (string，可选) - 指定输入数据格式，数据格式可以为“NC", "NCL", "NCHW" 或者"NCDHW"。默认值："NCHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
diff --git a/docs/api/paddle/nn/functional/interpolate_cn.rst b/docs/api/paddle/nn/functional/interpolate_cn.rst
index f6d2904d1e8..c8297bcc5c7 100644
--- a/docs/api/paddle/nn/functional/interpolate_cn.rst
+++ b/docs/api/paddle/nn/functional/interpolate_cn.rst
@@ -141,19 +141,19 @@ https://en.wikipedia.org/wiki/Bicubic_interpolation
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 3-D，4-D 或 5-D Tensor，数据类型为 float32、float64 或 uint8，其数据格式由参数 ``data_format`` 指定。如果没有指定 ``data_format`` 参数，其数据格式将由维度决定，具体请参照 ``data_format`` 参数。
+    - **x** (Tensor) - 3-D，4-D 或 5-D Tensor，数据类型为 float32、float64 或 uint8，其数据格式由参数  ``data_format``  指定。如果没有指定  ``data_format``  参数，其数据格式将由维度决定，具体请参照  ``data_format``  参数。
     - **size** (list|tuple|Tensor|None) - 输出 Tensor，输入为 4D Tensor 时，形状为为(out_h, out_w)的 2-D Tensor。输入为 5-D Tensor 时，形状为(out_d, out_h, out_w)的 3-D Tensor。如果 :code:`out_shape` 是列表，每一个元素可以是整数或者形状为[]的 Tensor。如果 :code:`out_shape` 是 Tensor，则其为 1D Tensor。默认值为 None。
     - **scale_factor** (float|Tensor|list|tuple|None)-输入的高度或宽度的乘数因子。out_shape 和 scale 至少要设置一个。out_shape 的优先级高于 scale。默认值为 None。如果 scale_factor 是一个 list 或 tuple，它必须与输入的 shape 匹配。
     - **mode** (str，可选) - 插值方法。支持"bilinear"或"trilinear"或"nearest"或"bicubic"或"linear"或"area"。默认值为"nearest"。
     - **align_corners** (bool，可选) - 一个可选的 bool 型参数，如果为 True，则将输入和输出 Tensor 的 4 个角落像素的中心对齐，并保留角点像素的值。默认值为 False。
     - **align_mode** (int，可选) - 双线性插值的可选项。可以是 '0' 代表 src_idx = scale *（dst_indx + 0.5）-0.5；如果为'1'，代表 src_idx = scale * dst_index。默认值：0。
-    - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致。支持的值有："NCW"、"NWC"、"NCHW"、"NHWC"、"NCDHW"、"NDHWC"。默认值为 None，此时若输入是 3-D Tensor， ``data_format`` 将默认为"NCW"；若输入是 4—D Tensor, 将默认为"NCHW"；若输入是 5—D Tensor, 将默认为"NCDHW"。
+    - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致。支持的值有："NCW"、"NWC"、"NCHW"、"NHWC"、"NCDHW"、"NDHWC"。默认值为 None，此时若输入是 3-D Tensor，  ``data_format``  将默认为"NCW"；若输入是 4—D Tensor, 将默认为"NCHW"；若输入是 5—D Tensor, 将默认为"NCDHW"。
     - **recompute_scale_factor** (bool，可选) - 是否在插值计算中重新计算乘数因子。当设置为 True 时，必须提供 scale_factor 参数，函数会用 scale_factor 和输入张量的形状计算输出张量的形状，然后根据输出张量形状和输入张量形状重新计算乘数因子。该参数可用于 scale_factor 为浮点数的情况。当设置为 False 时，将直接使用 size 或 scale_factor 进行插值计算，不进行重新计算。默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
-3-D，4-D，或 5-D Tensor，数据格式与输入 ``x`` 一致。
+3-D，4-D，或 5-D Tensor，数据格式与输入  ``x``  一致。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/kl_div_cn.rst b/docs/api/paddle/nn/functional/kl_div_cn.rst
index 5ac2bc19425..d4daa41dde7 100644
--- a/docs/api/paddle/nn/functional/kl_div_cn.rst
+++ b/docs/api/paddle/nn/functional/kl_div_cn.rst
@@ -9,33 +9,33 @@ kl_div
 
 kL 发散损失计算如下：
 
-若 ``log_target`` 为 ``False``:
+若  ``log_target``  为  ``False`` :
 
 ..  math::
 
     l(input, label) = label * (log(label) - input)
 
-若 ``log_target`` 为 ``True``:
+若  ``log_target``  为  ``True`` :
 
 ..  math::
 
     l(input, label) = exp(label) * (label - input)
 
 
-当 ``reduction``  为 ``none`` 时，输出损失与输入（x）形状相同，各点的损失单独计算，不会对结果做 reduction 。
+当  ``reduction``   为  ``none``  时，输出损失与输入（x）形状相同，各点的损失单独计算，不会对结果做 reduction 。
 
-当 ``reduction``  为 ``mean`` 时，输出损失的形状为[]，输出为所有损失的平均值。
+当  ``reduction``   为  ``mean``  时，输出损失的形状为[]，输出为所有损失的平均值。
 
-当 ``reduction``  为 ``sum`` 时，输出损失的形状为[]，输出为所有损失的总和。
+当  ``reduction``   为  ``sum``  时，输出损失的形状为[]，输出为所有损失的总和。
 
-当 ``reduction``  为 ``batchmean`` 时，输出损失为[N]的形状，N 为批大小，输出为所有损失的总和除以批量大小。
+当  ``reduction``   为  ``batchmean``  时，输出损失为[N]的形状，N 为批大小，输出为所有损失的总和除以批量大小。
 
 参数
 :::::::::
     - **input** (Tensor) - KL 散度损失算子的输入 Tensor。维度为[N, \*]的多维 Tensor，其中 N 是批大小，\*表示任何数量的附加维度，数据类型为 float32 或 float64。
-    - **label** (Tensor) - KL 散度损失算子的 Tensor。与输入 ``input`` 的维度和数据类型一致的多维 Tensor。
+    - **label** (Tensor) - KL 散度损失算子的 Tensor。与输入  ``input``  的维度和数据类型一致的多维 Tensor。
     - **reduction** (str，可选) - 要应用于输出的 reduction 类型，可用类型为‘none’ | ‘batchmean’ | ‘mean’ | ‘sum’，‘none’表示无 reduction，‘batchmean’ 表示输出的总和除以批大小，‘mean’ 表示所有输出的平均值，‘sum’表示输出的总和。
-    - **log_target** (bool，可选) - 表示输入的 ``label`` 变量是否属于 log 空间。默认值为 False，表示不属于。
+    - **log_target** (bool，可选) - 表示输入的  ``label``  变量是否属于 log 空间。默认值为 False，表示不属于。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/nn/functional/l1_loss_cn.rst b/docs/api/paddle/nn/functional/l1_loss_cn.rst
index 99a84d13e3c..98f52185834 100644
--- a/docs/api/paddle/nn/functional/l1_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/l1_loss_cn.rst
@@ -5,21 +5,21 @@ l1_loss
 
 .. py:function:: paddle.nn.functional.l1_loss(input, label, reduction='mean', name=None)
 
-计算输入 ``input`` 和标签 ``label`` 间的 `L1 loss` 损失。
+计算输入  ``input``  和标签  ``label``  间的 `L1 loss` 损失。
 
 该损失函数的数学计算公式如下：
 
-当 `reduction` 设置为 ``'none'`` 时：
+当 `reduction` 设置为  ``'none'``  时：
 
 ..  math::
     Out = \lvert input - label\rvert
 
-当 `reduction` 设置为 ``'mean'`` 时：
+当 `reduction` 设置为  ``'mean'``  时：
 
 ..  math::
     Out = MEAN(\lvert input - label\rvert)
 
-当 `reduction` 设置为 ``'sum'`` 时：
+当 `reduction` 设置为  ``'sum'``  时：
 
 ..  math::
     Out = SUM(\lvert input - label\rvert)
@@ -28,13 +28,13 @@ l1_loss
 参数
 :::::::::
     - **input** (Tensor) - 输入的 Tensor，维度是[N, *]，其中 N 是 batch size， `*` 是任意数量的额外维度。数据类型为：float32、float64、int32、int64。
-    - **label** (Tensor) - 标签，维度是[N, *]，与 ``input`` 相同。数据类型为：float32、float64、int32、int64。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：``'none'``, ``'mean'``, ``'sum'``。默认为 ``'mean'``，计算 `L1Loss` 的均值；设置为 ``'sum'`` 时，计算 `L1Loss` 的总和；设置为 ``'none'`` 时，则返回 `L1Loss`。
+    - **label** (Tensor) - 标签，维度是[N, *]，与  ``input``  相同。数据类型为：float32、float64、int32、int64。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ,  ``'mean'`` ,  ``'sum'`` 。默认为  ``'mean'`` ，计算 `L1Loss` 的均值；设置为  ``'sum'``  时，计算 `L1Loss` 的总和；设置为  ``'none'``  时，则返回 `L1Loss`。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-``Tensor``，输入 ``input`` 和标签 ``label`` 间的 `L1 loss` 损失。如果 `reduction` 是 ``'none'``，则输出 Loss 的形状为 [N, *]，与输入 ``input`` 相同。如果 `reduction` 是 ``'mean'`` 或 ``'sum'``，则输出 Loss 的形状为 []。
+ ``Tensor`` ，输入  ``input``  和标签  ``label``  间的 `L1 loss` 损失。如果 `reduction` 是  ``'none'`` ，则输出 Loss 的形状为 [N, *]，与输入  ``input``  相同。如果 `reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出 Loss 的形状为 []。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/label_smooth_cn.rst b/docs/api/paddle/nn/functional/label_smooth_cn.rst
index bb231d797f8..a2399793243 100644
--- a/docs/api/paddle/nn/functional/label_smooth_cn.rst
+++ b/docs/api/paddle/nn/functional/label_smooth_cn.rst
@@ -32,7 +32,7 @@ label_smooth
 
 返回
 ::::::::::::
-为平滑后标签的 ``Tensor`` 。
+为平滑后标签的  ``Tensor``  。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/nn/functional/layer_norm_cn.rst b/docs/api/paddle/nn/functional/layer_norm_cn.rst
index bfabf384820..9daa0c040d6 100644
--- a/docs/api/paddle/nn/functional/layer_norm_cn.rst
+++ b/docs/api/paddle/nn/functional/layer_norm_cn.rst
@@ -10,19 +10,19 @@ layer_norm
 详情见 :ref:`cn_api_paddle_nn_LayerNorm` 。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``， ``eps`` 可替代 ``epsilon``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，  ``eps``  可替代  ``epsilon`` 。
 
 
 参数
 ::::::::::::
 
     - **x** (int) - 输入，数据类型为 bfloat16 、 float16 、 float32 或 float64。
-      别名： ``input``
+      别名：  ``input`` 
     - **normalized_shape** (int|list|tuple) - 期望的输入是 :math:`[*, normalized_shape[0], normalized_shape[1], ..., normalized_shape[-1]]`，如果是一个整数，会作用在最后一个维度。
     - **weight** (Tensor，可选) - 权重的 Tensor，默认为 None。
     - **bias** (Tensor，可选) - 偏置的 Tensor，默认为 None。
     - **epsilon** (float，可选) - 为了数值稳定加在分母上的值。默认值：1e-05。
-      别名： ``eps``
+      别名：  ``eps`` 
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
diff --git a/docs/api/paddle/nn/functional/leaky_relu__cn.rst b/docs/api/paddle/nn/functional/leaky_relu__cn.rst
index df7ad859b65..5d9be5f912e 100644
--- a/docs/api/paddle/nn/functional/leaky_relu__cn.rst
+++ b/docs/api/paddle/nn/functional/leaky_relu__cn.rst
@@ -5,4 +5,4 @@ leaky_relu\_
 
 .. py:function:: paddle.nn.functional.leaky_relu_(x, negative_slope=0.01, name=None)
 
-进行原地更新的 ``Leaky_ReLU`` API，运算后的输出 ``Tensor`` 将替换原始输入 ``x`` 。详情请参考 `Leaky ReLU <https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/api/paddle/nn/functional/leaky_relu_cn.html#leaky-relu>`_ 。
+进行原地更新的  ``Leaky_ReLU``  API，运算后的输出  ``Tensor``  将替换原始输入  ``x``  。详情请参考 `Leaky ReLU <https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/api/paddle/nn/functional/leaky_relu_cn.html#leaky-relu>`_ 。
diff --git a/docs/api/paddle/nn/functional/leaky_relu_cn.rst b/docs/api/paddle/nn/functional/leaky_relu_cn.rst
index 4fdb3d3d142..8df14c9b6ee 100644
--- a/docs/api/paddle/nn/functional/leaky_relu_cn.rst
+++ b/docs/api/paddle/nn/functional/leaky_relu_cn.rst
@@ -26,7 +26,7 @@ leaky_relu 激活层。计算公式如下：
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/local_response_norm_cn.rst b/docs/api/paddle/nn/functional/local_response_norm_cn.rst
index c7a28a69155..0420568cf58 100644
--- a/docs/api/paddle/nn/functional/local_response_norm_cn.rst
+++ b/docs/api/paddle/nn/functional/local_response_norm_cn.rst
@@ -7,7 +7,7 @@ local_response_norm
 
 局部响应正则化（Local Response Normalization）用于对局部输入区域进行正则化，执行一种侧向抑制（lateral inhibition）。更多详情参考：`ImageNet Classification with Deep Convolutional Neural Networks <https://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf>`_
 
-其中 ``input`` 是 mini-batch 的输入特征。计算过程如下：
+其中  ``input``  是 mini-batch 的输入特征。计算过程如下：
 
 .. math::
 
diff --git a/docs/api/paddle/nn/functional/log_sigmoid_cn.rst b/docs/api/paddle/nn/functional/log_sigmoid_cn.rst
index ff94fdfc2cd..a62734e731e 100644
--- a/docs/api/paddle/nn/functional/log_sigmoid_cn.rst
+++ b/docs/api/paddle/nn/functional/log_sigmoid_cn.rst
@@ -15,12 +15,12 @@ log_sigmoid 激活层。计算公式如下：
 
 参数
 ::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64, complex64, complex128。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64, complex64, complex128。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/log_softmax_cn.rst b/docs/api/paddle/nn/functional/log_softmax_cn.rst
index f1f4c839829..d55852845b2 100644
--- a/docs/api/paddle/nn/functional/log_softmax_cn.rst
+++ b/docs/api/paddle/nn/functional/log_softmax_cn.rst
@@ -15,14 +15,14 @@ log_softmax
 
 参数
 ::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
-    - **axis** (int，可选) - 指定对输入 ``x`` 进行运算的轴。``axis`` 的有效范围是[-D, D)，D 是输入 ``x`` 的维度，``axis`` 为负值时与 :math:`axis + D` 等价。默认值为-1。
-    - **dtype** (str|np.dtype|core.VarDesc.VarType，可选) - 输入 Tensor 的数据类型。如果指定了 ``dtype``，则输入 Tensor 的数据类型会在计算前转换到 ``dtype`` 。 ``dtype``  可以用来避免数据溢出。如果 ``dtype`` 为 None，则输出 Tensor 的数据类型和 ``x`` 相同。默认值为 None。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
+    - **axis** (int，可选) - 指定对输入  ``x``  进行运算的轴。 ``axis``  的有效范围是[-D, D)，D 是输入  ``x``  的维度， ``axis``  为负值时与 :math:`axis + D` 等价。默认值为-1。
+    - **dtype** (str|np.dtype|core.VarDesc.VarType，可选) - 输入 Tensor 的数据类型。如果指定了  ``dtype`` ，则输入 Tensor 的数据类型会在计算前转换到  ``dtype``  。  ``dtype``   可以用来避免数据溢出。如果  ``dtype``  为 None，则输出 Tensor 的数据类型和  ``x``  相同。默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，形状和 ``x`` 相同，数据类型为 ``dtype`` 或者和 ``x`` 相同。
+     ``Tensor`` ，形状和  ``x``  相同，数据类型为  ``dtype``  或者和  ``x``  相同。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/lp_pool1d_cn.rst b/docs/api/paddle/nn/functional/lp_pool1d_cn.rst
index 0ef48a89fff..0fe7055f3ba 100644
--- a/docs/api/paddle/nn/functional/lp_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/lp_pool1d_cn.rst
@@ -27,7 +27,7 @@ lp_pool1d
 
 返回
 :::::::::
-``Tensor``，输入 `x` 经过幂平均池化计算得到的目标 3-D Tensor，其数据类型与输入相同。
+ ``Tensor`` ，输入 `x` 经过幂平均池化计算得到的目标 3-D Tensor，其数据类型与输入相同。
 
 
 
diff --git a/docs/api/paddle/nn/functional/margin_cross_entropy_cn.rst b/docs/api/paddle/nn/functional/margin_cross_entropy_cn.rst
index e8bc2ec984c..4a7dde344fa 100644
--- a/docs/api/paddle/nn/functional/margin_cross_entropy_cn.rst
+++ b/docs/api/paddle/nn/functional/margin_cross_entropy_cn.rst
@@ -8,29 +8,29 @@ margin_cross_entropy
 .. math::
     L=-\frac{1}{N}\sum^N_{i=1}\log\frac{e^{s(cos(m_{1}\theta_{y_i}+m_{2})-m_{3})}}{e^{s(cos(m_{1}\theta_{y_i}+m_{2})-m_{3})}+\sum^n_{j=1,j\neq y_i} e^{scos\theta_{y_i}}}
 
-其中，:math:`\theta_{y_i}` 是特征 :math:`x` 与类 :math:`w_{i}` 的角度。更详细的介绍请参考 ``Arcface loss``，https://arxiv.org/abs/1801.07698 。
+其中，:math:`\theta_{y_i}` 是特征 :math:`x` 与类 :math:`w_{i}` 的角度。更详细的介绍请参考  ``Arcface loss`` ，https://arxiv.org/abs/1801.07698 。
 
 提示：
 
-    这个 API 支持单卡，也支持多卡（模型并行），使用模型并行时，``logits.shape[-1]`` 在每张卡上可以不同。
+    这个 API 支持单卡，也支持多卡（模型并行），使用模型并行时， ``logits.shape[-1]``  在每张卡上可以不同。
 
 参数
 ::::::::::::
 
-    - **logits** (Tensor) - 2-D Tensor，维度为 ``[N, local_num_classes]``，``logits`` 为归一化后的 ``X`` 与归一化后的 ``W`` 矩阵乘得到，数据类型为 float16，float32 或者 float64。如果用了模型并行，则 ``logits == sahrd_logits``。
-    - **label** (Tensor) - 维度为 ``[N]`` 或者 ``[N, 1]`` 的标签。
-    - **margin1** (float，可选) - 公式中的 ``m1``。默认值为 ``1.0``。
-    - **margin2** (float，可选) - 公式中的 ``m2``。默认值为 ``0.5``。
-    - **margin3** (float，可选) - 公式中的 ``m3``。默认值为 ``0.0``。
-    - **scale** (float，可选) - 公式中的 ``s``。默认值为 ``64.0``。
-    - **group** (Group，可选) - 通信组的抽象描述，具体可以参考 ``paddle.distributed.collective.Group``。默认值为 ``None``。
-    - **return_softmax** (bool，可选) - 是否返回 ``softmax`` 概率值。默认值为 ``None``。
-    - **reduction** （str，可选）- 是否对 ``loss`` 进行归约。可选值为 ``'none'`` | ``'mean'`` | ``'sum'``。如果 ``reduction='mean'``，则对 ``loss`` 进行平均，如果 ``reduction='sum'``，则对 ``loss`` 进行求和，``reduction='None'``，则直接返回 ``loss``。默认值为 ``'mean'``。
+    - **logits** (Tensor) - 2-D Tensor，维度为  ``[N, local_num_classes]`` ， ``logits``  为归一化后的  ``X``  与归一化后的  ``W``  矩阵乘得到，数据类型为 float16，float32 或者 float64。如果用了模型并行，则  ``logits == sahrd_logits`` 。
+    - **label** (Tensor) - 维度为  ``[N]``  或者  ``[N, 1]``  的标签。
+    - **margin1** (float，可选) - 公式中的  ``m1`` 。默认值为  ``1.0`` 。
+    - **margin2** (float，可选) - 公式中的  ``m2`` 。默认值为  ``0.5`` 。
+    - **margin3** (float，可选) - 公式中的  ``m3`` 。默认值为  ``0.0`` 。
+    - **scale** (float，可选) - 公式中的  ``s`` 。默认值为  ``64.0`` 。
+    - **group** (Group，可选) - 通信组的抽象描述，具体可以参考  ``paddle.distributed.collective.Group`` 。默认值为  ``None`` 。
+    - **return_softmax** (bool，可选) - 是否返回  ``softmax``  概率值。默认值为  ``None`` 。
+    - **reduction** （str，可选）- 是否对  ``loss``  进行归约。可选值为  ``'none'``  |  ``'mean'``  |  ``'sum'`` 。如果  ``reduction='mean'`` ，则对  ``loss``  进行平均，如果  ``reduction='sum'`` ，则对  ``loss``  进行求和， ``reduction='None'`` ，则直接返回  ``loss`` 。默认值为  ``'mean'`` 。
 
 返回
 ::::::::::::
 
-    - ``Tensor`` (``loss``) 或者 ``Tensor`` 二元组 (``loss``, ``softmax``) - 如果 ``return_softmax=False`` 返回 ``loss``，否则返回 (``loss``, ``softmax``)。当使用模型并行时 ``softmax == shard_softmax``，否则 ``softmax`` 的维度与 ``logits`` 相同。如果 ``reduction == None``，``loss`` 的维度为 ``[N, 1]``，否则为 ``[]``。
+    -  ``Tensor``  ( ``loss`` ) 或者  ``Tensor``  二元组 ( ``loss`` ,  ``softmax`` ) - 如果  ``return_softmax=False``  返回  ``loss`` ，否则返回 ( ``loss`` ,  ``softmax`` )。当使用模型并行时  ``softmax == shard_softmax`` ，否则  ``softmax``  的维度与  ``logits``  相同。如果  ``reduction == None`` ， ``loss``  的维度为  ``[N, 1]`` ，否则为  ``[]`` 。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/nn/functional/margin_ranking_loss_cn.rst b/docs/api/paddle/nn/functional/margin_ranking_loss_cn.rst
index be646e965cd..c3ef483a80b 100644
--- a/docs/api/paddle/nn/functional/margin_ranking_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/margin_ranking_loss_cn.rst
@@ -10,17 +10,17 @@ margin_ranking_loss
  .. math::
      margin\_rank\_loss = max(0, -label * (input - other) + margin)
 
-当 `reduction` 设置为 ``'mean'`` 时，
+当 `reduction` 设置为  ``'mean'``  时，
 
     .. math::
        Out = MEAN(margin\_rank\_loss)
 
-当 `reduction` 设置为 ``'sum'`` 时，
+当 `reduction` 设置为  ``'sum'``  时，
 
     .. math::
        Out = SUM(margin\_rank\_loss)
 
-当 `reduction` 设置为 ``'none'`` 时，直接返回最原始的 `margin_rank_loss` 。
+当 `reduction` 设置为  ``'none'``  时，直接返回最原始的 `margin_rank_loss` 。
 
 参数
 ::::::::
@@ -28,12 +28,12 @@ margin_ranking_loss
     - **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'`` 。
+    - **reduction** (string，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'``  、  ``'mean'``  、  ``'sum'`` 。如果设置为  ``'none'`` ，则直接返回 最原始的  ``margin_rank_loss`` 。如果设置为  ``'sum'`` ，则返回  ``margin_rank_loss``  的总和。如果设置为  ``'mean'`` ，则返回  ``margin_rank_loss``  的平均值。默认值为  ``'none'``  。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::
-Tensor，如果 :attr:`reduction` 为 ``'sum'`` 或者是 ``'mean'``，则形状为 :math:`[]`，否则 shape 和输入 `input` 保持一致。数据类型与 ``input``、 ``other`` 相同。
+Tensor，如果 :attr:`reduction` 为  ``'sum'``  或者是  ``'mean'`` ，则形状为 :math:`[]`，否则 shape 和输入 `input` 保持一致。数据类型与  ``input`` 、  ``other``  相同。
 
 代码示例
 ::::::::
diff --git a/docs/api/paddle/nn/functional/max_pool1d_cn.rst b/docs/api/paddle/nn/functional/max_pool1d_cn.rst
index 24cee7e1e19..4ca657155de 100755
--- a/docs/api/paddle/nn/functional/max_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool1d_cn.rst
@@ -27,7 +27,7 @@ max_pool1d
 
 返回
 :::::::::
-``Tensor``，输入 `x` 经过最大值池化计算得到的目标 3-D Tensor，其数据类型与输入相同。
+ ``Tensor`` ，输入 `x` 经过最大值池化计算得到的目标 3-D Tensor，其数据类型与输入相同。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/maxout_cn.rst b/docs/api/paddle/nn/functional/maxout_cn.rst
index 4d01ff7062d..da237a317c6 100644
--- a/docs/api/paddle/nn/functional/maxout_cn.rst
+++ b/docs/api/paddle/nn/functional/maxout_cn.rst
@@ -27,7 +27,7 @@ maxout 激活层。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型同 ``x`` 一致。
+     ``Tensor`` ，数据类型同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/mish_cn.rst b/docs/api/paddle/nn/functional/mish_cn.rst
index ae59a5bd23f..b58923f9b4f 100644
--- a/docs/api/paddle/nn/functional/mish_cn.rst
+++ b/docs/api/paddle/nn/functional/mish_cn.rst
@@ -19,12 +19,12 @@ mish 激活层。计算公式如下：
 
 参数
 ::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/mse_loss_cn.rst b/docs/api/paddle/nn/functional/mse_loss_cn.rst
index 05fa2a1b44c..69a6c1366c5 100644
--- a/docs/api/paddle/nn/functional/mse_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/mse_loss_cn.rst
@@ -9,17 +9,17 @@ mse_loss
 
 对于预测值 input 和目标值 label，公式为：
 
-当 `reduction` 设置为 ``'none'`` 时，
+当 `reduction` 设置为  ``'none'``  时，
 
     .. math::
         Out = (input - label)^2
 
-当 `reduction` 设置为 ``'mean'`` 时，
+当 `reduction` 设置为  ``'mean'``  时，
 
     .. math::
        Out = \operatorname{mean}((input - label)^2)
 
-当 `reduction` 设置为 ``'sum'`` 时，
+当 `reduction` 设置为  ``'sum'``  时，
 
     .. math::
        Out = \operatorname{sum}((input - label)^2)
@@ -31,15 +31,15 @@ mse_loss
     - **label** (Tensor) - 目标值，维度为 :math:`[N_1, N_2, ..., N_k]` 的多维 Tensor。数据类型为 float32 或 float64。
     - **reduction** (str, 可选) - 输出的归约方法可以是'none'、'mean'或'sum'。
 
-        - 如果 :attr:`reduction` 是 ``'mean'``，则返回减少的平均损失。
-        - 如果 :attr:`reduction` 是 ``'sum'``，则返回减少的总损失。
-        - 如果 :attr:`reduction` 为 ``'none'``，返回未减少的损失。默认为 ``‘mean’``。
+        - 如果 :attr:`reduction` 是  ``'mean'`` ，则返回减少的平均损失。
+        - 如果 :attr:`reduction` 是  ``'sum'`` ，则返回减少的总损失。
+        - 如果 :attr:`reduction` 为  ``'none'`` ，返回未减少的损失。默认为  ``‘mean’`` 。
 
     - **name** (str, 可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-``Tensor``，输入 ``input`` 和标签 ``label`` 间的 `mse loss` 损失。
+ ``Tensor`` ，输入  ``input``  和标签  ``label``  间的 `mse loss` 损失。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/multi_label_margin_loss_cn.rst b/docs/api/paddle/nn/functional/multi_label_margin_loss_cn.rst
index 34218826abc..746660fa5bd 100644
--- a/docs/api/paddle/nn/functional/multi_label_margin_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/multi_label_margin_loss_cn.rst
@@ -19,15 +19,15 @@ multi_label_margin_loss
 参数
 :::::::::
     - **input** (Tensor) - :math:`[N, C]`，其中 N 是 batch_size， `C` 是类别数量。数据类型是 float32、float64。
-    - **label** (Tensor) - :math:`[N, C]`，与 input 形状相同。标签 ``label`` 的数据类型为 int32、int64。标签值应该是类别索引（非负值）和 -1 值。-1 值会被忽略并停止处理每个样本。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：``'none'``， ``'mean'``， ``'sum'``。默认为 ``'mean'``，计算 Loss 的均值；设置为 ``'sum'`` 时，计算 Loss 的总和；设置为 ``'none'`` 时，则返回原始 Loss。
+    - **label** (Tensor) - :math:`[N, C]`，与 input 形状相同。标签  ``label``  的数据类型为 int32、int64。标签值应该是类别索引（非负值）和 -1 值。-1 值会被忽略并停止处理每个样本。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ，  ``'mean'`` ，  ``'sum'`` 。默认为  ``'mean'`` ，计算 Loss 的均值；设置为  ``'sum'``  时，计算 Loss 的总和；设置为  ``'none'``  时，则返回原始 Loss。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
 :::::::::
     - **input** (Tensor) - :math:`[N, C]`，其中 N 是 batch_size，`C` 是类别数量。数据类型是 float32、float64。
-    - **label** (Tensor) - :math:`[N, C]`，与 input 形状相同，标签 ``label`` 的数据类型为 int32、int64。
-    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是 ``'none'``，则输出的维度为 :math:`[N]`，与 batch_size 相同。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出的维度为 :math:`[]` 。
+    - **label** (Tensor) - :math:`[N, C]`，与 input 形状相同，标签  ``label``  的数据类型为 int32、int64。
+    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是  ``'none'`` ，则输出的维度为 :math:`[N]`，与 batch_size 相同。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出的维度为 :math:`[]` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/nn/functional/multi_label_soft_margin_loss_cn.rst b/docs/api/paddle/nn/functional/multi_label_soft_margin_loss_cn.rst
index 50653d74fb3..b2c3cc7e708 100644
--- a/docs/api/paddle/nn/functional/multi_label_soft_margin_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/multi_label_soft_margin_loss_cn.rst
@@ -25,20 +25,20 @@ multi_label_soft_margin_loss
 参数
 :::::::::
     - **input** (Tensor) - :math:`[N, *]` , 其中 N 是 batch_size， `*` 是任意其他维度。数据类型是 float32、float64。
-    - **label** (Tensor) - :math:`[N, *]` , 标签 ``label`` 的维度、数据类型与输入 ``input`` 相同。
+    - **label** (Tensor) - :math:`[N, *]` , 标签  ``label``  的维度、数据类型与输入  ``input``  相同。
     - **weight** (Tensor，可选) - 手动设定权重，默认为 None
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有: ``'none'``， ``'mean'``， ``'sum'`` 。默认为 ``'mean'``，计算 Loss 的均值；设置为 ``'sum'`` 时，计算 Loss 的总和；设置为 ``'none'`` 时，则返回原始 Loss。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有:  ``'none'`` ，  ``'mean'`` ，  ``'sum'``  。默认为  ``'mean'`` ，计算 Loss 的均值；设置为  ``'sum'``  时，计算 Loss 的总和；设置为  ``'none'``  时，则返回原始 Loss。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
 :::::::::
     - **input** (Tensor) - :math:`[N, *]` , 其中 N 是 batch_size， `*` 是任意其他维度。数据类型是 float32、float64。
-    - **label** (Tensor) - :math:`[N, *]` ，标签 ``label`` 的维度、数据类型与输入 ``input`` 相同。
-    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是 ``'none'``, 则输出的维度为 :math:`[N, *]` , 与输入 ``input`` 的形状相同。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``， 则输出的维度为 :math:`[]` 。
+    - **label** (Tensor) - :math:`[N, *]` ，标签  ``label``  的维度、数据类型与输入  ``input``  相同。
+    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是  ``'none'`` , 则输出的维度为 :math:`[N, *]` , 与输入  ``input``  的形状相同。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ， 则输出的维度为 :math:`[]` 。
 
 返回
 :::::::::
-    输出的 Tensor。如果 :attr:`reduction` 是 ``'none'``, 则输出的维度为 :math:`[N, *]` ， 与输入 ``input`` 的形状相同。如果 :attr:`reduction` 是 ``'mean'`` 或 `'sum'``， 则输出的维度为 :math:`[]` 。
+    输出的 Tensor。如果 :attr:`reduction` 是  ``'none'`` , 则输出的维度为 :math:`[N, *]` ， 与输入  ``input``  的形状相同。如果 :attr:`reduction` 是  ``'mean'``  或 `'sum'``， 则输出的维度为 :math:`[]` 。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/multi_margin_loss_cn.rst b/docs/api/paddle/nn/functional/multi_margin_loss_cn.rst
index ce3a49a1319..ada2ed18ba4 100644
--- a/docs/api/paddle/nn/functional/multi_margin_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/multi_margin_loss_cn.rst
@@ -23,18 +23,18 @@ multi_margin_loss
 参数
 :::::::::
     - **input** (Tensor) - :math:`[N, C]`，其中 N 是 batch_size， `C` 是类别数量。数据类型是 float32、float64。
-    - **label** (Tensor) - :math:`[N, ]`。标签 ``label`` 的数据类型为 int32、int64。
+    - **label** (Tensor) - :math:`[N, ]`。标签  ``label``  的数据类型为 int32、int64。
     - **p** (int，可选) - 手动指定范数，默认为 1。
     - **margin** (float，可选) - 手动指定间距，默认为 1。
     - **weight** (Tensor，可选) - 权重值，默认为 None。如果给定则形状为 :math:`[C, ]`。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：``'none'``， ``'mean'``， ``'sum'``。默认为 ``'mean'``，计算 Loss 的均值；设置为 ``'sum'`` 时，计算 Loss 的总和；设置为 ``'none'`` 时，则返回原始 Loss。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ，  ``'mean'`` ，  ``'sum'`` 。默认为  ``'mean'`` ，计算 Loss 的均值；设置为  ``'sum'``  时，计算 Loss 的总和；设置为  ``'none'``  时，则返回原始 Loss。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
 :::::::::
     - **input** (Tensor) - :math:`[N, C ]`，其中 N 是 batch_size，`C` 是类别问题。数据类型是 float32、float64。
-    - **label** (Tensor) - :math:`[N, ]`，标签 ``label`` 的数据类型为 int32、int64。
-    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是 ``'none'``，则输出的维度为 :math:`[N, ]`，与输入 ``input`` 的形状相同。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出的维度为 :math:`[]` 。
+    - **label** (Tensor) - :math:`[N, ]`，标签  ``label``  的数据类型为 int32、int64。
+    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是  ``'none'`` ，则输出的维度为 :math:`[N, ]`，与输入  ``input``  的形状相同。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出的维度为 :math:`[]` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/nn/functional/normalize_cn.rst b/docs/api/paddle/nn/functional/normalize_cn.rst
index 7768b328779..14faca38bf9 100644
--- a/docs/api/paddle/nn/functional/normalize_cn.rst
+++ b/docs/api/paddle/nn/functional/normalize_cn.rst
@@ -5,7 +5,7 @@ normalize
 
 .. py:function:: paddle.nn.functional.normalize(x, p=2, axis=1, epsilon=1e-12, name=None)
 
-使用 :math:`L_p` 范数沿维度 ``axis`` 对 ``x`` 进行归一化。计算公式如下：
+使用 :math:`L_p` 范数沿维度  ``axis``  对  ``x``  进行归一化。计算公式如下：
 
 .. math::
 
@@ -14,20 +14,20 @@ normalize
 .. math::
     \lvert \lvert x \rvert \rvert_p = \left(\sum_i {\lvert x_i\rvert^p}  \right)^{1/p}
 
-其中 :math:`\sum_i{\lvert x_i\rvert^p}` 沿维度 ``axis`` 进行计算。
+其中 :math:`\sum_i{\lvert x_i\rvert^p}` 沿维度  ``axis``  进行计算。
 
 
 参数
 :::::::::
     - **x** (Tensor) - 输入可以是 N-D Tensor。数据类型为：float32、float64。
     - **p** (float|int，可选) - 范数公式中的指数值。默认值：2
-    - **axis** (int，可选）- 要进行归一化的轴。如果 ``x`` 是 1-D Tensor，轴固定为 0。如果 `axis < 0`，轴为 `x.ndim + axis`。-1 表示最后一维。
+    - **axis** (int，可选）- 要进行归一化的轴。如果  ``x``  是 1-D Tensor，轴固定为 0。如果 `axis < 0`，轴为 `x.ndim + axis`。-1 表示最后一维。
     - **epsilon** (float，可选) - 添加到分母上的值以防止分母为 0。默认值为 1e-12。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-``Tensor``，输出的形状和数据类型和 ``x`` 相同。
+ ``Tensor`` ，输出的形状和数据类型和  ``x``  相同。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/one_hot_cn.rst b/docs/api/paddle/nn/functional/one_hot_cn.rst
index a00b7dbf774..b77c774b2d0 100644
--- a/docs/api/paddle/nn/functional/one_hot_cn.rst
+++ b/docs/api/paddle/nn/functional/one_hot_cn.rst
@@ -4,7 +4,7 @@ one_hot
 -------------------------------
 
 .. py:function:: paddle.nn.functional.one_hot(x, num_classes, name=None)
-将输入'x'中的每个 id 转换为一个 one-hot 向量，其长度为 ``num_classes``，该 id 对应的向量维度上的值为 1，其余维度的值为 0。
+将输入'x'中的每个 id 转换为一个 one-hot 向量，其长度为  ``num_classes`` ，该 id 对应的向量维度上的值为 1，其余维度的值为 0。
 
 输出的 Tensor 的 shape 是在输入 shape 的最后一维后面添加了 num_classes 的维度。
 
@@ -37,14 +37,14 @@ one_hot
     X 中第 2 维的值是 5，超过了 num_classes，因此抛异常。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``one_hot(input=tensor_x, ...)`` 等价于 ``one_hot(x=tensor_x, ...)``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``one_hot(input=tensor_x, ...)``  等价于  ``one_hot(x=tensor_x, ...)`` 。
 
 参数
 ::::::::::::
 
     - **x** (Tensor) - 维度为 :math:`[N_1, ..., N_n]` 的多维 Tensor，维度至少 1 维。数据类型为 int32 或 int64。
-      ``别名: input``
-    - **num_classes** (int) - 用于定义一个 one-hot 向量的长度。若输入为词 id，则 ``num_classes`` 通常取值为词典大小，默认值为-1。
+       ``别名: input`` 
+    - **num_classes** (int) - 用于定义一个 one-hot 向量的长度。若输入为词 id，则  ``num_classes``  通常取值为词典大小，默认值为-1。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/nn/functional/pad_cn.rst b/docs/api/paddle/nn/functional/pad_cn.rst
index 4331cb00eda..1e363a1dcb6 100644
--- a/docs/api/paddle/nn/functional/pad_cn.rst
+++ b/docs/api/paddle/nn/functional/pad_cn.rst
@@ -5,44 +5,44 @@ pad
 
 .. py:function:: paddle.nn.functional.pad(x, pad, mode="constant", value=0.0, data_format=None, pad_from_left_axis=True, name=None)
 
-依照 ``pad`` 和 ``mode`` 属性对 ``x`` 进行 ``pad``。
+依照  ``pad``  和  ``mode``  属性对  ``x``  进行  ``pad`` 。
 
 .. note::
-    1. 记 ``x`` 的维数为 N (以下延用)。 ``pad`` 的长度：
+    1. 记  ``x``  的维数为 N (以下延用)。  ``pad``  的长度：
 
-        1.1. 当 ``mode`` 为 ``'constant'`` 时， ``pad`` 的长度可以是任意小于等于 2*N 的偶数。若输入奇数长度的 pad，会自动在末尾补零至偶数长度，再按偶数方式处理 。例如：
+        1.1. 当  ``mode``  为  ``'constant'``  时，  ``pad``  的长度可以是任意小于等于 2*N 的偶数。若输入奇数长度的 pad，会自动在末尾补零至偶数长度，再按偶数方式处理 。例如：
 
-            - 示例： ``pad=[1,2,3]`` → 补零为 ``[1,2,3,0]``，表示第一个维度前后分别填充 1 和 2，第二个维度前后分别填充 3 和 0。
+            - 示例：  ``pad=[1,2,3]``  → 补零为  ``[1,2,3,0]`` ，表示第一个维度前后分别填充 1 和 2，第二个维度前后分别填充 3 和 0。
 
-        1.2. 当 ``mode`` 为 ``'reflect'``、 ``'replicate'`` 或 ``'circular'`` 时， ``pad`` 的长度必须为 2*(N-2)。
+        1.2. 当  ``mode``  为  ``'reflect'`` 、  ``'replicate'``  或  ``'circular'``  时，  ``pad``  的长度必须为 2*(N-2)。
 
-    2. ``pad`` 的顺序：支持右对齐(从 ``x`` 的最后一维开始)。特别地，当 ``mode`` 为 ``'constant'`` ，且 ``pad`` 是长度为 2N 的列表时，pad 的顺序可以通过 ``pad_from_left_axis`` 参数来控制，如果 ``pad_from_left_axis`` 是 True，pad 的顺序则是左对齐；如果 ``pad_from_left_axis`` 是 False，pad 的顺序则是右对齐。
-    3. 当 ``mode`` 为 ``'reflect'``、 ``'replicate'``、 ``'circular'``，或 ``pad`` 是 Tensor，或 ``pad`` 的长度是 2*(N-2) 时，``x`` 的维数只支持 3-D、4—D、5-D。此时 pad 作用在相应 ``data_format`` 的 [D, H, W] 轴上，顺序是从 [D, H, W] 轴的最后一维到第一维。具体地，当 N=3 时，pad 的格式为[pad_left, pad_right]；当 N=4 时，pad 的格式为[pad_left, pad_right, pad_top, pad_bottom]；当 N=5 时，pad 的格式为[pad_left, pad_right, pad_top, pad_bottom, pad_front, pad_back]。
-    4. 如果 ``mode`` 为 ``reflect``，则 ``x`` 对应 [D, H, W] 维度上的长度必须大于对应的 ``pad`` 值。
+    2.  ``pad``  的顺序：支持右对齐(从  ``x``  的最后一维开始)。特别地，当  ``mode``  为  ``'constant'``  ，且  ``pad``  是长度为 2N 的列表时，pad 的顺序可以通过  ``pad_from_left_axis``  参数来控制，如果  ``pad_from_left_axis``  是 True，pad 的顺序则是左对齐；如果  ``pad_from_left_axis``  是 False，pad 的顺序则是右对齐。
+    3. 当  ``mode``  为  ``'reflect'`` 、  ``'replicate'`` 、  ``'circular'`` ，或  ``pad``  是 Tensor，或  ``pad``  的长度是 2*(N-2) 时， ``x``  的维数只支持 3-D、4—D、5-D。此时 pad 作用在相应  ``data_format``  的 [D, H, W] 轴上，顺序是从 [D, H, W] 轴的最后一维到第一维。具体地，当 N=3 时，pad 的格式为[pad_left, pad_right]；当 N=4 时，pad 的格式为[pad_left, pad_right, pad_top, pad_bottom]；当 N=5 时，pad 的格式为[pad_left, pad_right, pad_top, pad_bottom, pad_front, pad_back]。
+    4. 如果  ``mode``  为  ``reflect`` ，则  ``x``  对应 [D, H, W] 维度上的长度必须大于对应的  ``pad``  值。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` 。
 
 参数
 ::::::::::::
 
-  - **x** (Tensor) - Tensor，format 可以为 ``'NCL'``、``'NLC'``、``'NCHW'``、``'NHWC'``、``'NCDHW'`` 或 ``'NDHWC'``，默认值为 ``'NCHW'``，数据类型支持 float16、float32、float64、int32、int64、complex64、complex128。别名： ``input``。
+  - **x** (Tensor) - Tensor，format 可以为  ``'NCL'`` 、 ``'NLC'`` 、 ``'NCHW'`` 、 ``'NHWC'`` 、 ``'NCDHW'``  或  ``'NDHWC'`` ，默认值为  ``'NCHW'`` ，数据类型支持 float16、float32、float64、int32、int64、complex64、complex128。别名：  ``input`` 。
   - **pad** (Tensor|list[int]|tuple[int]) - 填充大小，基本数据类型是整数类型。具体设置请参照 Note（注解）。
 
-  - **mode** (str，可选) - padding 的四种模式，分别为 ``'constant'``、``'reflect'``、``'replicate'`` 和 ``'circular'``，
+  - **mode** (str，可选) - padding 的四种模式，分别为  ``'constant'`` 、 ``'reflect'`` 、 ``'replicate'``  和  ``'circular'`` ，
 
-     - ``'constant'`` 表示填充常数 ``value``；
-     - ``'reflect'`` 表示填充以 ``x`` 边界值为轴的映射；
-     - ``'replicate'`` 表示填充 ``x`` 边界值；
-     - ``'circular'`` 为循环填充 ``x``。具体结果可见以下示例。
+     -  ``'constant'``  表示填充常数  ``value`` ；
+     -  ``'reflect'``  表示填充以  ``x``  边界值为轴的映射；
+     -  ``'replicate'``  表示填充  ``x``  边界值；
+     -  ``'circular'``  为循环填充  ``x`` 。具体结果可见以下示例。
 
-  - **value** (float，可选) - 以 ``'constant'`` 模式填充区域时填充的值。默认值为 :math:`0.0`。
-  - **data_format** (str，可选) - 当 ``mode`` 为 ``'reflect'``、 ``'replicate'``、 ``'circular'``，或 ``pad`` 是 Tensor，或 ``pad`` 的长度是 2*(N-2) 时，指定 ``x`` 的数据格式，可为 ``'NCL'``、``'NLC'``、``'NCHW'``、``'NHWC'``、``'NCDHW'`` 或 ``'NDHWC'``，默认值为 None，此时取值将根据输入 ``x`` 的维度自动推断：若 ``x`` 维度是 3，取值为 ``'NCL'``；若 ``x`` 维度是 4，取值为 ``'NCHW'``；；若 ``x`` 维度是 5，取值为 ``'NCDHW'``。
-  - **pad_from_left_axis** (bool，可选) - 只有当 ``mode`` 为 ``'constant'`` ，且 ``pad`` 是长度为 2N 的列表时有效，设置 ``pad`` 与 ``x`` 的轴左对齐或右对齐。默认值为 True，表示左对齐填充。
+  - **value** (float，可选) - 以  ``'constant'``  模式填充区域时填充的值。默认值为 :math:`0.0`。
+  - **data_format** (str，可选) - 当  ``mode``  为  ``'reflect'`` 、  ``'replicate'`` 、  ``'circular'`` ，或  ``pad``  是 Tensor，或  ``pad``  的长度是 2*(N-2) 时，指定  ``x``  的数据格式，可为  ``'NCL'`` 、 ``'NLC'`` 、 ``'NCHW'`` 、 ``'NHWC'`` 、 ``'NCDHW'``  或  ``'NDHWC'`` ，默认值为 None，此时取值将根据输入  ``x``  的维度自动推断：若  ``x``  维度是 3，取值为  ``'NCL'`` ；若  ``x``  维度是 4，取值为  ``'NCHW'`` ；；若  ``x``  维度是 5，取值为  ``'NCDHW'`` 。
+  - **pad_from_left_axis** (bool，可选) - 只有当  ``mode``  为  ``'constant'``  ，且  ``pad``  是长度为 2N 的列表时有效，设置  ``pad``  与  ``x``  的轴左对齐或右对齐。默认值为 True，表示左对齐填充。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 返回
 ::::::::::::
-Tensor，对 ``x`` 进行 ``'pad'`` 的结果，数据类型和 ``x`` 相同。
+Tensor，对  ``x``  进行  ``'pad'``  的结果，数据类型和  ``x``  相同。
 
 
 **示例**：
diff --git a/docs/api/paddle/nn/functional/pairwise_distance_cn.rst b/docs/api/paddle/nn/functional/pairwise_distance_cn.rst
index 763d40eacde..23e26d4252a 100644
--- a/docs/api/paddle/nn/functional/pairwise_distance_cn.rst
+++ b/docs/api/paddle/nn/functional/pairwise_distance_cn.rst
@@ -5,7 +5,7 @@ pairwise_distance
 
 .. py:function:: paddle.nn.functional.pairwise_distance(x, y, p=2., epsilon=1e-6, keepdim=False, name=None)
 
-计算两组向量（输入 ``x``、``y``）两两之间的距离。该距离通过 p 范数计算：
+计算两组向量（输入  ``x`` 、 ``y`` ）两两之间的距离。该距离通过 p 范数计算：
 
 .. math::
 
diff --git a/docs/api/paddle/nn/functional/pixel_shuffle_cn.rst b/docs/api/paddle/nn/functional/pixel_shuffle_cn.rst
index 6ef5496498a..a6711aac44e 100644
--- a/docs/api/paddle/nn/functional/pixel_shuffle_cn.rst
+++ b/docs/api/paddle/nn/functional/pixel_shuffle_cn.rst
@@ -19,7 +19,7 @@ pixel_shuffle
 
 返回
 :::::::::
-``Tensor``，输出 Tensor，其数据类型与输入相同。
+ ``Tensor`` ，输出 Tensor，其数据类型与输入相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/pixel_unshuffle_cn.rst b/docs/api/paddle/nn/functional/pixel_unshuffle_cn.rst
index 68aa5751582..2b6b2252f3e 100644
--- a/docs/api/paddle/nn/functional/pixel_unshuffle_cn.rst
+++ b/docs/api/paddle/nn/functional/pixel_unshuffle_cn.rst
@@ -18,7 +18,7 @@ pixel_unshuffle
 
 返回
 :::::::::
-``Tensor``，重新排列过的 Tensor，其数据类型与输入相同。
+ ``Tensor`` ，重新排列过的 Tensor，其数据类型与输入相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/poisson_nll_loss_cn.rst b/docs/api/paddle/nn/functional/poisson_nll_loss_cn.rst
index 12acee5423a..43aba0ba191 100644
--- a/docs/api/paddle/nn/functional/poisson_nll_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/poisson_nll_loss_cn.rst
@@ -10,28 +10,28 @@ poisson_nll_loss
 :::::::::
     - **input** (Tensor) - 输入 :attr:`Tensor`，对应泊松分布的期望，其形状为 :math:`[N, *]`，其中 :math:`*` 表示任何数量的额外维度。数据类型为 float16，bfloat16，float32 或 float64。
     - **label** (Tensor) - 标签 :attr:`Tensor`， 形状、数据类型和 :attr:`input` 相同。
-    - **log_input** (bool，可选) - 输入是否为对数函数映射后结果，如果为 ``True``，则 loss 当中第一项的计算公式为
+    - **log_input** (bool，可选) - 输入是否为对数函数映射后结果，如果为  ``True`` ，则 loss 当中第一项的计算公式为
 
     .. math::
         \text{input} - \text{label} * \log(\text{input}+\text{eps})
 
     其中 :attr:`eps` 为数值稳定使用的常数小量。
-    如果为 ``False``，则 loss 的计算公式为
+    如果为  ``False`` ，则 loss 的计算公式为
 
     .. math::
         \exp(\text{input}) - \text{label} * \text{input}
 
-    默认值为 ``True``。
+    默认值为  ``True`` 。
 
     - **full** (bool，可选) - 是否在损失计算中包括 Stirling 近似项。该近似项的计算公式为
 
     .. math::
         \text{label} * \log(\text{label}) - \text{label} + 0.5 * \log(2 * \pi * \text{label})
 
-    默认值为 ``False``。
+    默认值为  ``False`` 。
 
-    - **eps** (float，可选) - 在 :attr:`log_input` 为 ``True`` 时使用的常数小量，使得 loss 计算过程中不会导致对 0 求对数情况的出现。默认值为 1e-8。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有 ``none``、``mean`` 和 ``sum``。默认为 ``mean``，计算 ``mini-batch`` loss 均值。设置为 ``sum`` 时，计算 ``mini-batch`` loss 的总和。设置为 ``none`` 时，则返回 loss Tensor。默认值下为 ``mean``。
+    - **eps** (float，可选) - 在 :attr:`log_input` 为  ``True``  时使用的常数小量，使得 loss 计算过程中不会导致对 0 求对数情况的出现。默认值为 1e-8。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有  ``none`` 、 ``mean``  和  ``sum`` 。默认为  ``mean`` ，计算  ``mini-batch``  loss 均值。设置为  ``sum``  时，计算  ``mini-batch``  loss 的总和。设置为  ``none``  时，则返回 loss Tensor。默认值下为  ``mean`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/nn/functional/prelu_cn.rst b/docs/api/paddle/nn/functional/prelu_cn.rst
index b29acc7b4d5..52377686d65 100644
--- a/docs/api/paddle/nn/functional/prelu_cn.rst
+++ b/docs/api/paddle/nn/functional/prelu_cn.rst
@@ -15,14 +15,14 @@ prelu 激活层（PRelu Activation Operator）。计算公式如下：
 
 参数
 ::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
-    - **weight** (Tensor) - 可训练参数，数据类型同``x`` 一致，形状支持：[]、[1] 或者 [in]，其中`in`为输入的通道数。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
+    - **weight** (Tensor) - 可训练参数，数据类型同 ``x``  一致，形状支持：[]、[1] 或者 [in]，其中`in`为输入的通道数。
     - **data_format** (str，可选) – 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是 "NC", "NCL", "NCHW", "NCDHW", "NLC", "NHWC" 或者 "NDHWC"。默认值："NCHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/relu6_cn.rst b/docs/api/paddle/nn/functional/relu6_cn.rst
index 95c702d6f07..a62db92ad55 100644
--- a/docs/api/paddle/nn/functional/relu6_cn.rst
+++ b/docs/api/paddle/nn/functional/relu6_cn.rst
@@ -15,12 +15,12 @@ relu6 激活层
 
 参数
 ::::::::::
- - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
+ - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
  - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/relu_cn.rst b/docs/api/paddle/nn/functional/relu_cn.rst
index 1d265f15c72..a3f1ab1a80b 100644
--- a/docs/api/paddle/nn/functional/relu_cn.rst
+++ b/docs/api/paddle/nn/functional/relu_cn.rst
@@ -16,12 +16,12 @@ relu 激活层（Rectified Linear Unit）。计算公式如下：
 
 参数
 ::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/rnnt_loss_cn.rst b/docs/api/paddle/nn/functional/rnnt_loss_cn.rst
index 465e7c76769..efd77300307 100644
--- a/docs/api/paddle/nn/functional/rnnt_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/rnnt_loss_cn.rst
@@ -16,12 +16,12 @@ rnnt_loss
     - **label_lengths** (Tensor) - 每个标签序列的长度，它应该有形状 [batch_size] 和 dtype int64。
     - **blank** (int，可选) - RNN-T loss 的空白标签索引，处于半开放区间 [0,B)。数据类型必须为 int32。默认值为 0。
     - **fastemit_lambda** (float，默认 0.001) - FastEmit 的正则化参数(https://arxiv.org/pdf/2010.11148.pdf)。
-    - **reduction** (str，可选) - 表示如何平均损失，候选是 ``'none'``|``'mean'``|``'sum'`` 。如果 ::attr:`reduction` 是 ``'mean'``，输出将是损失的总和并除以 batch_size;如果 :attr:`reduction` 是 ``'sum'``，返回损失的总和;如果 :attr:`reduction` 为 ``'none'``，则不应用 reduction。默认是 ``'mean'``。
+    - **reduction** (str，可选) - 表示如何平均损失，候选是  ``'none'`` | ``'mean'`` | ``'sum'``  。如果 ::attr:`reduction` 是  ``'mean'`` ，输出将是损失的总和并除以 batch_size;如果 :attr:`reduction` 是  ``'sum'`` ，返回损失的总和;如果 :attr:`reduction` 为  ``'none'`` ，则不应用 reduction。默认是  ``'mean'`` 。
     - **name** (str，可选) - 操作名称，默认为 None。
 
 返回
 :::::::::
-``Tensor``，输入 ``input`` 和标签 ``labels`` 间的 `rnnt loss`。如果 :attr:`reduction` 是 ``'none'``，则输出 loss 的维度为 [batch_size]。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出 Loss 的维度为 []。数据类型与输入的 ``input`` 一致。
+ ``Tensor`` ，输入  ``input``  和标签  ``labels``  间的 `rnnt loss`。如果 :attr:`reduction` 是  ``'none'`` ，则输出 loss 的维度为 [batch_size]。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出 Loss 的维度为 []。数据类型与输入的  ``input``  一致。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/rrelu_cn.rst b/docs/api/paddle/nn/functional/rrelu_cn.rst
index f1051073f90..1f0ca422757 100644
--- a/docs/api/paddle/nn/functional/rrelu_cn.rst
+++ b/docs/api/paddle/nn/functional/rrelu_cn.rst
@@ -46,7 +46,7 @@ rrelu 激活函数，应用随机纠正线性单元对神经元激活，参考
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/scaled_dot_product_attention_cn.rst b/docs/api/paddle/nn/functional/scaled_dot_product_attention_cn.rst
index a08d2009aa3..db92d3df0f6 100644
--- a/docs/api/paddle/nn/functional/scaled_dot_product_attention_cn.rst
+++ b/docs/api/paddle/nn/functional/scaled_dot_product_attention_cn.rst
@@ -8,7 +8,7 @@ scaled_dot_product_attention
 
 ..  math::
     result=softmax(\frac{ Q * K^T }{\sqrt{d}}) * V
-其中, ``Q``、``K`` 和 ``V`` 表示注意力模块的三个输入参数。这三个参数的尺寸相同。``d`` 表示三个参数中最后一个维度的大小。
+其中,  ``Q`` 、 ``K``  和  ``V``  表示注意力模块的三个输入参数。这三个参数的尺寸相同。 ``d``  表示三个参数中最后一个维度的大小。
 
 .. warning::
     此 API 仅支持数据类型为 float16 和 bfloat16 的输入。
@@ -20,8 +20,8 @@ scaled_dot_product_attention
     - **query** (Tensor) - 注意力模块中的查询张量。具有以下形状的四维张量：[batch_size, seq_len, num_heads, head_dim]，或者三维张量：[seq_len, num_heads, head_dim]。数据类型可以是 float61 或 bfloat16。
     - **key** (Tensor) - 注意力模块中的关键张量。具有以下形状的四维张量:[batch_size, seq_len, num_heads, head_dim]，或者三维张量：[seq_len, num_heads, head_dim]。数据类型可以是 float61 或 bfloat16。
     - **value** (Tensor) - 注意力模块中的值张量。具有以下形状的四维张量: [batch_size, seq_len, num_heads, head_dim]，或者三维张量：[seq_len, num_heads, head_dim]。数据类型可以是 float61 或 bfloat16。
-    - **attn_mask** (Tensor, 可选) - 与添加到注意力分数的 ``query``、 ``key``、 ``value`` 类型相同的浮点掩码, 默认值为空。
-    - **dropout_p** (float) - ``dropout`` 的比例, 默认值为 0.00 即不进行正则化。
+    - **attn_mask** (Tensor, 可选) - 与添加到注意力分数的  ``query`` 、  ``key`` 、  ``value``  类型相同的浮点掩码, 默认值为空。
+    - **dropout_p** (float) -  ``dropout``  的比例, 默认值为 0.00 即不进行正则化。
     - **is_causal** (bool) - 是否启用因果关系, 默认值为 False 即不启用。
     - **training** (bool): - 是否处于训练阶段, 默认值为 True 即处于训练阶段。
     - **name** (str, 可选) - 默认值为 None。通常不需要用户设置此属性。欲了解更多信息, 请参阅:ref:`api_guide_Name`。
@@ -30,7 +30,7 @@ scaled_dot_product_attention
 返回
 ::::::::::
 
-    - ``out`` (Tensor): 形状为 ``[batch_size, seq_len, num_heads, head_dim]`` 的 4 维张量或者形状为 ``[seq_len, num_heads, head_dim]`` 的 3 维张量。数据类型可以是 float16 或 bfloat16。
+    -  ``out``  (Tensor): 形状为  ``[batch_size, seq_len, num_heads, head_dim]``  的 4 维张量或者形状为  ``[seq_len, num_heads, head_dim]``  的 3 维张量。数据类型可以是 float16 或 bfloat16。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/selu_cn.rst b/docs/api/paddle/nn/functional/selu_cn.rst
index 1310fa0961a..b68a0c42d24 100644
--- a/docs/api/paddle/nn/functional/selu_cn.rst
+++ b/docs/api/paddle/nn/functional/selu_cn.rst
@@ -19,14 +19,14 @@ selu 激活层
 
 参数
 ::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
     - **scale** (float，可选) - selu 激活计算公式中的 scale 值，必须大于 1.0。默认值为 1.0507009873554804934193349852946。
     - **alpha** (float，可选) - selu 激活计算公式中的 alpha 值，必须大于等于零。默认值为 1.6732632423543772848170429916717。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/sequence_mask_cn.rst b/docs/api/paddle/nn/functional/sequence_mask_cn.rst
index ff8f0460477..870314a1839 100644
--- a/docs/api/paddle/nn/functional/sequence_mask_cn.rst
+++ b/docs/api/paddle/nn/functional/sequence_mask_cn.rst
@@ -8,9 +8,9 @@ sequence_mask
 
 
 
-该层根据输入 ``x`` 和 ``maxlen`` 输出一个掩码，数据类型为 ``dtype`` 。
+该层根据输入  ``x``  和  ``maxlen``  输出一个掩码，数据类型为  ``dtype``  。
 
-假设 x 是一个形状为 ``[d_1, d_2，…, d_n]`` 的 Tensor，则输出 y 是一个形状为 ``[d_1, d_2，… ，d_n, maxlen]`` 的掩码，其中：
+假设 x 是一个形状为  ``[d_1, d_2，…, d_n]``  的 Tensor，则输出 y 是一个形状为  ``[d_1, d_2，… ，d_n, maxlen]``  的掩码，其中：
 
 .. math::
 
@@ -35,14 +35,14 @@ sequence_mask
 
 参数
 :::::::::
-  - **x** (Tensor) - 输入 Tensor，其元素是小于等于 ``maxlen`` 的整数，形状为 ``[d_1, d_2，…, d_n]`` 的 Tensor。
-  - **maxlen** (int，可选) - 序列的最大长度。默认为空，此时 ``maxlen`` 取 ``x`` 中所有元素的最大值。
-  - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出的数据类型，默认为 ``int64`` 。
+  - **x** (Tensor) - 输入 Tensor，其元素是小于等于  ``maxlen``  的整数，形状为  ``[d_1, d_2，…, d_n]``  的 Tensor。
+  - **maxlen** (int，可选) - 序列的最大长度。默认为空，此时  ``maxlen``  取  ``x``  中所有元素的最大值。
+  - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出的数据类型，默认为  ``int64``  。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-mask Tensor，Tensor，形状为 ``[d_1, d_2，… ，d_n, maxlen]``，数据类型由 ``dtype`` 指定，支持 float32、float64、int32 和 int64，默认为 int64。
+mask Tensor，Tensor，形状为  ``[d_1, d_2，… ，d_n, maxlen]`` ，数据类型由  ``dtype``  指定，支持 float32、float64、int32 和 int64，默认为 int64。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/sigmoid_focal_loss_cn.rst b/docs/api/paddle/nn/functional/sigmoid_focal_loss_cn.rst
index 7b620259182..d250286a11a 100644
--- a/docs/api/paddle/nn/functional/sigmoid_focal_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/sigmoid_focal_loss_cn.rst
@@ -19,23 +19,23 @@ sigmoid_focal_loss
 .. math::
            Out = \frac{Out}{normalizer}
 
-最后，该算子会添加 `reduce` 操作到前面的输出 Out 上。当 `reduction` 为 ``'none'`` 时，直接返回最原始的 `Out` 结果。当 `reduction` 为 ``'mean'`` 时，返回输出的均值 :math:`Out = MEAN(Out)`。当 `reduction` 为 ``'sum'`` 时，返回输出的求和 :math:`Out = SUM(Out)` 。
+最后，该算子会添加 `reduce` 操作到前面的输出 Out 上。当 `reduction` 为  ``'none'``  时，直接返回最原始的 `Out` 结果。当 `reduction` 为  ``'mean'``  时，返回输出的均值 :math:`Out = MEAN(Out)`。当 `reduction` 为  ``'sum'``  时，返回输出的求和 :math:`Out = SUM(Out)` 。
 
 **注意**：标签值 0 表示背景类（即负样本），1 表示前景类（即正样本）。
 
 参数
 :::::::::
-    - **logit** (Tensor) - 维度为 :math:`[N, *]`，其中 N 是 batch_size， `*` 是任意其他维度。输入数据 ``logit`` 一般是卷积层的输出，不需要经过 ``sigmoid`` 层。数据类型是 float32、float64。
-    - **label** (Tensor) - 维度为 :math:`[N, *]`，标签 ``label`` 的维度、数据类型与输入 ``logit`` 相同，取值范围 :math:`[0，1]`。数据类型是 float32、float64。
-    - **normalizer** (Tensor，可选) - 维度为 :math:`[1]` ，focal loss 的归一化系数，数据类型与输入 ``logit`` 相同。若设置为 None，则不会将 focal loss 做归一化操作（即不会将 focal loss 除以 normalizer）。在目标检测任务中，设置为正样本的数量。默认值为 None。
+    - **logit** (Tensor) - 维度为 :math:`[N, *]`，其中 N 是 batch_size， `*` 是任意其他维度。输入数据  ``logit``  一般是卷积层的输出，不需要经过  ``sigmoid``  层。数据类型是 float32、float64。
+    - **label** (Tensor) - 维度为 :math:`[N, *]`，标签  ``label``  的维度、数据类型与输入  ``logit``  相同，取值范围 :math:`[0，1]`。数据类型是 float32、float64。
+    - **normalizer** (Tensor，可选) - 维度为 :math:`[1]` ，focal loss 的归一化系数，数据类型与输入  ``logit``  相同。若设置为 None，则不会将 focal loss 做归一化操作（即不会将 focal loss 除以 normalizer）。在目标检测任务中，设置为正样本的数量。默认值为 None。
     - **alpha** (int|float，可选) - 用于平衡正样本和负样本的超参数，取值范围 :math:`[0，1]`。默认值设置为 0.25。
     - **gamma** (int|float，可选) - 用于平衡易分样本和难分样本的超参数，默认值设置为 2.0。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：``'none'``, ``'mean'``, ``'sum'``。默认为 ``'mean'``，计算 `focal loss` 的均值；设置为 ``'sum'`` 时，计算 `focal loss` 的总和；设置为 ``'none'`` 时，则返回原始 loss。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ,  ``'mean'`` ,  ``'sum'`` 。默认为  ``'mean'`` ，计算 `focal loss` 的均值；设置为  ``'sum'``  时，计算 `focal loss` 的总和；设置为  ``'none'``  时，则返回原始 loss。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-    - Tensor，输出的 Tensor。如果 :attr:`reduction` 是 ``'none'``，则输出的维度为 :math:`[N, *]`，与输入 ``logit`` 的形状相同。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出的维度为 :math:`[]` 。
+    - Tensor，输出的 Tensor。如果 :attr:`reduction` 是  ``'none'`` ，则输出的维度为 :math:`[N, *]`，与输入  ``logit``  的形状相同。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出的维度为 :math:`[]` 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/silu_cn.rst b/docs/api/paddle/nn/functional/silu_cn.rst
index 041b58f7e71..3d3ae48cf97 100644
--- a/docs/api/paddle/nn/functional/silu_cn.rst
+++ b/docs/api/paddle/nn/functional/silu_cn.rst
@@ -14,19 +14,19 @@ silu 激活层。计算公式如下：
 其中，:math:`x` 为输入的 Tensor。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` 。
 
 参数
 ::::::::::
 
 
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为 bfloat16 、 float16 、 float32 、 float64 、 complex64 或 complex128 。别名 ``input``。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为 bfloat16 、 float16 、 float32 、 float64 、 complex64 或 complex128 。别名  ``input`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
 
-    ``Tensor``，数据类型和形状同 :attr:`x` 一致。
+     ``Tensor`` ，数据类型和形状同 :attr:`x` 一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/smooth_l1_loss_cn.rst b/docs/api/paddle/nn/functional/smooth_l1_loss_cn.rst
index 34ddf581a52..8a4f68b502b 100644
--- a/docs/api/paddle/nn/functional/smooth_l1_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/smooth_l1_loss_cn.rst
@@ -25,7 +25,7 @@ smooth_l1_loss
 
     - **input** (Tensor) - 输入 `Tensor`，数据类型为 float32。其形状为 :math:`[N, C]`，其中 :math:`C` 为类别数。对于多维度的情形下，它的形状为 :math:`[N, C, d_1, d_2, ..., d_k]`，:math:`k \geqslant 1`。
     - **label** (Tensor) - 输入 :attr:`input` 对应的标签值，数据类型和 :attr:`input` 相同。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，数据类型为 string，可选值有 ``none``、``mean``、``sum``。默认为 ``mean``，计算 ``mini-batch`` loss 均值。设置为 ``sum`` 时，计算 ``mini-batch`` loss 的总和。设置为 ``none`` 时，则返回 loss Tensor。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，数据类型为 string，可选值有  ``none`` 、 ``mean`` 、 ``sum`` 。默认为  ``mean`` ，计算  ``mini-batch``  loss 均值。设置为  ``sum``  时，计算  ``mini-batch``  loss 的总和。设置为  ``none``  时，则返回 loss Tensor。
     - **delta** (str，可选) - SmoothL1Loss 损失的阈值参数 :math:`\delta`，用于控制 Huber 损失对线性误差或平方误差的侧重。数据类型为 float32。默认值为 1.0。
     - **is_huber** (bool，可选) - 如果为 True，则使用 Huber 损失。如果为 False, 则使用 Huber 损失除以 delta 值。默认为 True。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
diff --git a/docs/api/paddle/nn/functional/soft_margin_loss_cn.rst b/docs/api/paddle/nn/functional/soft_margin_loss_cn.rst
index ccaabdc1253..39c1c248461 100644
--- a/docs/api/paddle/nn/functional/soft_margin_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/soft_margin_loss_cn.rst
@@ -20,14 +20,14 @@ soft_margin_loss
 参数
 :::::::::
     - **input** (Tensor) - :math:`[N, *]` ，其中 N 是 batch_size， `*` 是任意其他维度。数据类型是 float32、float64。
-    - **label** (Tensor) - :math:`[N, *]` ，标签 ``label`` 的维度、数据类型与输入 ``input`` 相同。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'``、 ``'mean'``、 ``'sum'`` 。默认为 ``'mean'``，计算 Loss 的均值；设置为 ``'sum'`` 时，计算 Loss 的总和；设置为 ``'none'`` 时，则返回原始 Loss。
+    - **label** (Tensor) - :math:`[N, *]` ，标签  ``label``  的维度、数据类型与输入  ``input``  相同。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：  ``'none'`` 、  ``'mean'`` 、  ``'sum'``  。默认为  ``'mean'`` ，计算 Loss 的均值；设置为  ``'sum'``  时，计算 Loss 的总和；设置为  ``'none'``  时，则返回原始 Loss。
     - **name** (str，可选) - 操作的名称（可选，默认值为 None）。更多信息请参见 :ref:`api_guide_Name` 。
 
 
 返回
 :::::::::
-    - 输出的结果 Tensor。如果 :attr:`reduction` 是 ``'none'``, 则输出的维度为 :math:`[N, *]` ，与输入 ``input`` 的形状相同。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出的维度为 :math:`[]` 。
+    - 输出的结果 Tensor。如果 :attr:`reduction` 是  ``'none'`` , 则输出的维度为 :math:`[N, *]` ，与输入  ``input``  的形状相同。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出的维度为 :math:`[]` 。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/softmax_cn.rst b/docs/api/paddle/nn/functional/softmax_cn.rst
index 07385cb4731..9cab17b5760 100644
--- a/docs/api/paddle/nn/functional/softmax_cn.rst
+++ b/docs/api/paddle/nn/functional/softmax_cn.rst
@@ -8,7 +8,7 @@ softmax
 
 步骤 1：输入 :attr:`x` 的 :attr:`axis` 维会被置换到最后一维；
 
-步骤 2：将输入 :attr:`x` 在逻辑上变换为二维矩阵。二维矩阵第一维（列长度）是输入除最后一维之外的其他维度值的乘积，第二维（行长度）和输入 ``axis`` 维的长度相同；对于矩阵的每一行，softmax 操作对其进行重新缩放，使得该行的每个元素在 :math:`[0, 1]` 范围内，并且总和为 :math:`1`；
+步骤 2：将输入 :attr:`x` 在逻辑上变换为二维矩阵。二维矩阵第一维（列长度）是输入除最后一维之外的其他维度值的乘积，第二维（行长度）和输入  ``axis``  维的长度相同；对于矩阵的每一行，softmax 操作对其进行重新缩放，使得该行的每个元素在 :math:`[0, 1]` 范围内，并且总和为 :math:`1`；
 
 步骤 3：softmax 操作执行完成后，执行步骤 1 和步骤 2 的逆运算，将二维矩阵恢复至和输入 :attr:`x` 相同的维度。
 
@@ -81,13 +81,13 @@ softmax
                  [0.72747516, 0.72747516, 0.72747516, 0.72747516]]]
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``dim`` 可替代 ``axis`` ，如 ``softmax(input=tensor_x, dim=1, ...)`` 等价于 ``softmax(x=tensor_x, axis=1, ...)`` 。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，参数名  ``dim``  可替代  ``axis``  ，如  ``softmax(input=tensor_x, dim=1, ...)``  等价于  ``softmax(x=tensor_x, axis=1, ...)``  。
 
 参数
 ::::::::::
 
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为 bfloat16 、 float16 、 float32 或 float64。别名： ``input``。
-    - **axis** (int，可选) - 指定对输入 :attr:`x` 进行运算的轴。:attr:`axis` 的有效范围是 :math:`[-D, D)`，:math:`D` 是输入 :attr:`x` 的维度，:attr:`axis` 为负值时与 :math:`axis + D` 等价。默认值为 -1。别名： ``dim``。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为 bfloat16 、 float16 、 float32 或 float64。别名：  ``input`` 。
+    - **axis** (int，可选) - 指定对输入 :attr:`x` 进行运算的轴。:attr:`axis` 的有效范围是 :math:`[-D, D)`，:math:`D` 是输入 :attr:`x` 的维度，:attr:`axis` 为负值时与 :math:`axis + D` 等价。默认值为 -1。别名：  ``dim`` 。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 `Tensor` 的数据类型，支持 bfloat16、 float16、 float32、float64。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
     - **out** (Tensor，可选) - 指定输出结果的 `Tensor`，默认值为 None。
@@ -95,7 +95,7 @@ softmax
 返回
 ::::::::::
 
-    ``Tensor``，形状和 :attr:`x` 相同，数据类型为 :attr:`dtype` 或者和 :attr:`x` 相同。
+     ``Tensor`` ，形状和 :attr:`x` 相同，数据类型为 :attr:`dtype` 或者和 :attr:`x` 相同。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/softmax_with_cross_entropy_cn.rst b/docs/api/paddle/nn/functional/softmax_with_cross_entropy_cn.rst
index 7c997fdf04b..3987aa12b42 100644
--- a/docs/api/paddle/nn/functional/softmax_with_cross_entropy_cn.rst
+++ b/docs/api/paddle/nn/functional/softmax_with_cross_entropy_cn.rst
@@ -8,9 +8,9 @@ softmax_with_cross_entropy
 
 实现了 softmax 交叉熵损失函数。该函数会将 softmax 操作、交叉熵损失函数的计算过程进行合并，从而提供了数值上更稳定的梯度值。
 
-因为该运算对 ``logits`` 的 ``axis`` 维执行 softmax 运算，所以它需要未缩放的 ``logits``。该运算不应该对 softmax 运算的输出进行操作，否则会产生错误的结果。
+因为该运算对  ``logits``  的  ``axis``  维执行 softmax 运算，所以它需要未缩放的  ``logits`` 。该运算不应该对 softmax 运算的输出进行操作，否则会产生错误的结果。
 
-当 ``soft_label`` 为 ``False`` 时，``label`` 除了 ``axis`` 维度上的形状为 1，其余维度和 ``logits`` 一致，表示一批数据中的每一个样本仅可分类到一个类别。
+当  ``soft_label``  为  ``False``  时， ``label``  除了  ``axis``  维度上的形状为 1，其余维度和  ``logits``  一致，表示一批数据中的每一个样本仅可分类到一个类别。
 
 涉及到的等式如下：
 
@@ -24,7 +24,7 @@ softmax_with_cross_entropy
 .. math::
    loss_j =  -\sum_{i=0}^{K}\text{label}_i\left(\text{logits}_i - \log\left(\sum_{i=0}^{K}\exp(\text{logits}_i)\right)\right), j = 1,...,K
 
-3. 如果 ``numeric_stable_mode`` 为 ``True`` ，softmax 结果首先经由下式计算得出，然后使用 softmax 结果和 ``label`` 计算交叉熵损失。
+3. 如果  ``numeric_stable_mode``  为  ``True``  ，softmax 结果首先经由下式计算得出，然后使用 softmax 结果和  ``label``  计算交叉熵损失。
 
 .. math::
     max_j           &= \max_{i=0}^{K}{\text{logits}_i} \\
@@ -34,19 +34,19 @@ softmax_with_cross_entropy
 参数
 ::::::::::::
 
-  - **logits** (Tensor) - 维度为任意维的多维 ``Tensor``，数据类型为 float32 或 float64。表示未缩放的输入。
-  - **label** (Tensor) - 如果 ``soft_label`` 为 True， ``label`` 是一个和 ``logits`` 维度相同的的 ``Tensor``。如果 ``soft_label`` 为 False， ``label`` 是一个在 axis 维度上大小为 1，其它维度上与 ``logits`` 维度相同的 ``Tensor`` 。
+  - **logits** (Tensor) - 维度为任意维的多维  ``Tensor`` ，数据类型为 float32 或 float64。表示未缩放的输入。
+  - **label** (Tensor) - 如果  ``soft_label``  为 True，  ``label``  是一个和  ``logits``  维度相同的的  ``Tensor`` 。如果  ``soft_label``  为 False，  ``label``  是一个在 axis 维度上大小为 1，其它维度上与  ``logits``  维度相同的  ``Tensor``  。
   - **soft_label** (bool，可选) - 指明是否将输入标签当作软标签。默认值：False。
-  - **ignore_index** (int，可选) - 指明要无视的目标值，使其不对输入梯度有贡献。仅在 ``soft_label`` 为 False 时有效，默认值：kIgnoreIndex（-100）。
-  - **numeric_stable_mode** (bool，可选) – 指明是否使用一个具有更佳数学稳定性的算法。仅在 ``soft_label`` 为 False 的 GPU 模式下生效。若 ``soft_label`` 为 True 或者执行设备为 CPU，算法一直具有数学稳定性。注意使用稳定算法时速度可能会变慢。默认值：True。
+  - **ignore_index** (int，可选) - 指明要无视的目标值，使其不对输入梯度有贡献。仅在  ``soft_label``  为 False 时有效，默认值：kIgnoreIndex（-100）。
+  - **numeric_stable_mode** (bool，可选) – 指明是否使用一个具有更佳数学稳定性的算法。仅在  ``soft_label``  为 False 的 GPU 模式下生效。若  ``soft_label``  为 True 或者执行设备为 CPU，算法一直具有数学稳定性。注意使用稳定算法时速度可能会变慢。默认值：True。
   - **return_softmax** (bool，可选) – 指明是否在返回交叉熵计算结果的同时返回 softmax 结果。默认值：False。
-  - **axis** (int，可选) – 执行 softmax 计算的维度索引。其范围为 :math:`[-1，rank-1]`，其中 ``rank`` 是输入 ``logits`` 的秩。默认值：-1。
+  - **axis** (int，可选) – 执行 softmax 计算的维度索引。其范围为 :math:`[-1，rank-1]`，其中  ``rank``  是输入  ``logits``  的秩。默认值：-1。
 
 返回
 ::::::::::::
 
-  - 如果 ``return_softmax`` 为 False，则返回交叉熵损失结果的 ``Tensor``，数据类型和 ``logits`` 一致，除了 ``axis`` 维度上的形状为 1，其余维度和 ``logits`` 一致。
-  - 如果 ``return_softmax`` 为 True，则返回交叉熵损失结果的 ``Tensor`` 和 softmax 结果的 ``Tensor`` 组成的元组。其中交叉熵损失结果的数据类型和 ``logits`` 一致，除了 ``axis`` 维度上的形状为 1，其余维度上交叉熵损失结果和 ``logits`` 一致；softmax 结果的数据类型和 ``logits`` 一致，维度和 ``logits`` 一致。
+  - 如果  ``return_softmax``  为 False，则返回交叉熵损失结果的  ``Tensor`` ，数据类型和  ``logits``  一致，除了  ``axis``  维度上的形状为 1，其余维度和  ``logits``  一致。
+  - 如果  ``return_softmax``  为 True，则返回交叉熵损失结果的  ``Tensor``  和 softmax 结果的  ``Tensor``  组成的元组。其中交叉熵损失结果的数据类型和  ``logits``  一致，除了  ``axis``  维度上的形状为 1，其余维度上交叉熵损失结果和  ``logits``  一致；softmax 结果的数据类型和  ``logits``  一致，维度和  ``logits``  一致。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/softplus_cn.rst b/docs/api/paddle/nn/functional/softplus_cn.rst
index 25fe7780850..f3e43e16906 100644
--- a/docs/api/paddle/nn/functional/softplus_cn.rst
+++ b/docs/api/paddle/nn/functional/softplus_cn.rst
@@ -18,7 +18,7 @@ softplus 激活层
 参数
 ::::::::::::
 
- - **x** (Tensor) - 输入的 ``Tensor``，数据类型为 float32 或 float64。
+ - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为 float32 或 float64。
  - **beta** (float，可选) - Softplus 激活计算公式中的 :math:`\beta` 值。默认值为 1。
  - **threshold** (float，可选) - Softplus 激活计算公式中的 :math:`\varepsilon` 值。默认值为 20。
  - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
@@ -26,7 +26,7 @@ softplus 激活层
 返回
 ::::::::::
 
-    ``Tensor``，数据类型和形状同 :attr:`x` 一致。
+     ``Tensor`` ，数据类型和形状同 :attr:`x` 一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/softshrink_cn.rst b/docs/api/paddle/nn/functional/softshrink_cn.rst
index 8b7dd249188..587c7172147 100644
--- a/docs/api/paddle/nn/functional/softshrink_cn.rst
+++ b/docs/api/paddle/nn/functional/softshrink_cn.rst
@@ -19,13 +19,13 @@ softshrink 激活层
 
 参数
 ::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
     - **threshold** (float，可选) - softshrink 激活计算公式中的 threshold 值，必须大于等于零。默认值为 0.5。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/softsign_cn.rst b/docs/api/paddle/nn/functional/softsign_cn.rst
index 73eef5e4c07..950d7a6eb56 100644
--- a/docs/api/paddle/nn/functional/softsign_cn.rst
+++ b/docs/api/paddle/nn/functional/softsign_cn.rst
@@ -15,12 +15,12 @@ softsign 激活层
 
 参数
 ::::::::::
- - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
+ - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
  - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/sparse_attention_cn.rst b/docs/api/paddle/nn/functional/sparse_attention_cn.rst
index fd4fa08f4f0..648f99ce2bc 100755
--- a/docs/api/paddle/nn/functional/sparse_attention_cn.rst
+++ b/docs/api/paddle/nn/functional/sparse_attention_cn.rst
@@ -8,27 +8,27 @@ sparse_attention
 
 对 Transformer 模块中的 Attention 矩阵进行了稀疏化，从而减少内存消耗和计算量。
 
-其稀疏数据排布通过 CSR 格式表示，CSR 格式包含两个参数，``offset`` 和 ``colunms``。计算公式为：
+其稀疏数据排布通过 CSR 格式表示，CSR 格式包含两个参数， ``offset``  和  ``colunms`` 。计算公式为：
 
 .. math::
    result=softmax(\frac{ Q * K^T }{\sqrt{d}}) * V
 
-其中，``Q``，``K``，``V`` 表示注意力模块的三个输入参数。这三个参数的维度是一样的。``d`` 代表这三个参数的最后一个维度的大小。
+其中， ``Q`` ， ``K`` ， ``V``  表示注意力模块的三个输入参数。这三个参数的维度是一样的。 ``d``  代表这三个参数的最后一个维度的大小。
 
 .. warning::
     目前该 API 只在 CUDA11.3 及以上版本中使用。
 
 参数
 :::::::::
-  - **query** (Tensor) - 输入的 Tensor，代表注意力模块中的 ``query``，这是一个 4 维 Tensor，形状为：[batch_size, num_heads, seq_len, head_dim]，数据类型为 float32 或 float64。
-  - **key** (Tensor) - 输入的 Tensor，代表注意力模块中的 ``key``，这是一个 4 维 Tensor，形状为：[batch_size, num_heads, seq_len, head_dim]，数据类型为 float32 或 float64。
-  - **value** (Tensor) - 输入的 Tensor，代表注意力模块中的 ``value``，这是一个 4 维 Tensor，形状为：[batch_size, num_heads, seq_len, head_dim]，数据类型为 float32 或 float64。
-  - **sparse_csr_offset** (Tensor) - 输入的 Tensor，注意力模块中的稀疏特性，稀疏特性使用 CSR 格式表示，``offset`` 代表矩阵中每一行非零元的数量。这是一个 3 维 Tensor，形状为：[batch_size, num_heads, seq_len + 1]，数据类型为 int32。
-  - **sparse_csr_columns** (Tensor) - 输入的 Tensor，注意力模块中的稀疏特性，稀疏特性使用 CSR 格式表示，``colunms`` 代表矩阵中每一行非零元的列索引值。这是一个 3 维 Tensor，形状为：[batch_size, num_heads, sparse_nnz]，数据类型为 int32。
+  - **query** (Tensor) - 输入的 Tensor，代表注意力模块中的  ``query`` ，这是一个 4 维 Tensor，形状为：[batch_size, num_heads, seq_len, head_dim]，数据类型为 float32 或 float64。
+  - **key** (Tensor) - 输入的 Tensor，代表注意力模块中的  ``key`` ，这是一个 4 维 Tensor，形状为：[batch_size, num_heads, seq_len, head_dim]，数据类型为 float32 或 float64。
+  - **value** (Tensor) - 输入的 Tensor，代表注意力模块中的  ``value`` ，这是一个 4 维 Tensor，形状为：[batch_size, num_heads, seq_len, head_dim]，数据类型为 float32 或 float64。
+  - **sparse_csr_offset** (Tensor) - 输入的 Tensor，注意力模块中的稀疏特性，稀疏特性使用 CSR 格式表示， ``offset``  代表矩阵中每一行非零元的数量。这是一个 3 维 Tensor，形状为：[batch_size, num_heads, seq_len + 1]，数据类型为 int32。
+  - **sparse_csr_columns** (Tensor) - 输入的 Tensor，注意力模块中的稀疏特性，稀疏特性使用 CSR 格式表示， ``colunms``  代表矩阵中每一行非零元的列索引值。这是一个 3 维 Tensor，形状为：[batch_size, num_heads, sparse_nnz]，数据类型为 int32。
 
 返回
 :::::::::
-  ``Tensor``，代表注意力模块的结果。这是一个 4 维 Tensor，形状为：[batch_size, num_heads, seq_len, head_dim]，数据类型为 float32 或 float64。
+   ``Tensor`` ，代表注意力模块的结果。这是一个 4 维 Tensor，形状为：[batch_size, num_heads, seq_len, head_dim]，数据类型为 float32 或 float64。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/swish_cn.rst b/docs/api/paddle/nn/functional/swish_cn.rst
index d7f0d4b2dc0..493e90cccfa 100644
--- a/docs/api/paddle/nn/functional/swish_cn.rst
+++ b/docs/api/paddle/nn/functional/swish_cn.rst
@@ -16,12 +16,12 @@ swish 激活层。计算公式如下：
 
 参数
 ::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/tanhshrink_cn.rst b/docs/api/paddle/nn/functional/tanhshrink_cn.rst
index 5acd011184f..d217a387ebf 100644
--- a/docs/api/paddle/nn/functional/tanhshrink_cn.rst
+++ b/docs/api/paddle/nn/functional/tanhshrink_cn.rst
@@ -15,12 +15,12 @@ tanhshrink 激活层
 
 参数
 ::::::::::
- - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
+ - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
  - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/temporal_shift_cn.rst b/docs/api/paddle/nn/functional/temporal_shift_cn.rst
index fcf15f6e3f3..6d35d6210a0 100644
--- a/docs/api/paddle/nn/functional/temporal_shift_cn.rst
+++ b/docs/api/paddle/nn/functional/temporal_shift_cn.rst
@@ -7,7 +7,7 @@ temporal_shift
 
 对输入 X 做时序通道 T 上的位移操作，为 TSM(Temporal Shift Module)中使用的操作。
 
-输入 (X) 的形状应为 [N*T, C, H, W] 或 [N*T, H, W, C]，N 是批大小，T 是 ``seg_num`` 指定的时间段号，C 是通道号，H 和 W 是特征的高度和宽度。
+输入 (X) 的形状应为 [N*T, C, H, W] 或 [N*T, H, W, C]，N 是批大小，T 是  ``seg_num``  指定的时间段号，C 是通道号，H 和 W 是特征的高度和宽度。
 
 以 data_format="NCHW" 为例，时间偏移计算如下：
 
@@ -15,7 +15,7 @@ temporal_shift
 
 步骤 2：填充 0 到第二个 (T) 尺寸的变形结果，填充宽度每边为 1，填充结果的形状为 [N，T+2，C，H，W]。
 
-步骤 3：假设 ``shift_ratio`` 为 1/4，切片填充结果如下：
+步骤 3：假设  ``shift_ratio``  为 1/4，切片填充结果如下：
 
 .. math::
 
@@ -33,13 +33,13 @@ temporal_shift
 :::::::::
   - **x**  (Tensor) – 时移算符的输入 Tensor。维度为 :math:`[N*T，C，H，W]` 的 4-D Tensor。N 为批量大小，T 为时间段数，C 为信道数，H 为特征高度，W 为特征宽度，数据类型为 float16、float32 或 float64。
   - **seg_num**  (int) – 时间段编号，这应该是一个正整数。
-  - **shift_ratio**  (float，可选) – 通道的移位比、通道的第一个 ``shift_ratio`` 部分沿时间维度移动-1，通道的第二个 ``shift_ratio`` 部分沿时间维度移动 1，范围须在 [0, 0.5] 内。默认值 0.25
+  - **shift_ratio**  (float，可选) – 通道的移位比、通道的第一个  ``shift_ratio``  部分沿时间维度移动-1，通道的第二个  ``shift_ratio``  部分沿时间维度移动 1，范围须在 [0, 0.5] 内。默认值 0.25
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
   - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是 "NCHW" 或 "NHWC"。N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度。默认值："NCHW"。
 
 返回
 :::::::::
-Tensor，时序位移后的输出 Tensor，维度和数据类型与输入 ``x`` 一致。
+Tensor，时序位移后的输出 Tensor，维度和数据类型与输入  ``x``  一致。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/thresholded_relu_cn.rst b/docs/api/paddle/nn/functional/thresholded_relu_cn.rst
index d00a2591184..e42a61f1e50 100644
--- a/docs/api/paddle/nn/functional/thresholded_relu_cn.rst
+++ b/docs/api/paddle/nn/functional/thresholded_relu_cn.rst
@@ -22,14 +22,14 @@ thresholded relu 激活层。计算公式如下：
 
 参数
 ::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
     - **threshold** (float，可选) - thresholded_relu 激活计算公式中的 threshold 值。默认值为 1.0。
-    - **value** (float，可选) - 当 ``x`` 小于 ``threshold`` 时的替换值。默认值为 0.0。
+    - **value** (float，可选) - 当  ``x``  小于  ``threshold``  时的替换值。默认值为 0.0。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/functional/triplet_margin_loss_cn.rst b/docs/api/paddle/nn/functional/triplet_margin_loss_cn.rst
index 51c96bfaea2..fff0cee3b08 100644
--- a/docs/api/paddle/nn/functional/triplet_margin_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/triplet_margin_loss_cn.rst
@@ -20,7 +20,7 @@ triplet_margin_loss
 
 
 
-``p`` 为距离函数的范数。``margin`` 为（input，positive）与（input，negative）的距离间隔，``swap`` 为 True 时，会比较（input，negative）和（positive，negative）的大小，并将（input，negative）换为其中较小的值，内容详见论文 `Learning shallow convolutional feature descriptors with triplet losses <http://www.bmva.org/bmvc/2016/papers/paper119/paper119.pdf>`_ 。
+ ``p``  为距离函数的范数。 ``margin``  为（input，positive）与（input，negative）的距离间隔， ``swap``  为 True 时，会比较（input，negative）和（positive，negative）的大小，并将（input，negative）换为其中较小的值，内容详见论文 `Learning shallow convolutional feature descriptors with triplet losses <http://www.bmva.org/bmvc/2016/papers/paper119/paper119.pdf>`_ 。
 
 参数
 :::::::::
@@ -31,15 +31,15 @@ triplet_margin_loss
     - **p** (float，可选) - 手动指定范数，默认为 2。
     - **epsilon** (float，可选) - 防止除数为零，默认为 1e-6。
     - **swap** (bool，可选) - 默认为 False。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：``'none'``， ``'mean'``， ``'sum'``。默认为 ``'mean'``，计算 Loss 的均值；设置为 ``'sum'`` 时，计算 Loss 的总和；设置为 ``'none'`` 时，则返回原始 Loss。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ，  ``'mean'`` ，  ``'sum'`` 。默认为  ``'mean'`` ，计算 Loss 的均值；设置为  ``'sum'``  时，计算 Loss 的总和；设置为  ``'none'``  时，则返回原始 Loss。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
 :::::::::
     - **input** (Tensor) - :math:`[N, * ]`，其中 N 是 batch_size， `*` 是任意其他维度。数据类型是 float32、float64。
-    - **positive** (Tensor) - :math:`[N, *]`，标签 ``positive`` 的维度、数据类型与输入 ``input`` 相同。
-    - **negative** (Tensor) - :math:`[N, *]`，标签 ``negative`` 的维度、数据类型与输入 ``input`` 相同。
-    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是 ``'none'``，则输出的维度为 :math:`[N, *]`，与输入 ``input`` 的形状相同。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出的维度为 :math:`[]` 。
+    - **positive** (Tensor) - :math:`[N, *]`，标签  ``positive``  的维度、数据类型与输入  ``input``  相同。
+    - **negative** (Tensor) - :math:`[N, *]`，标签  ``negative``  的维度、数据类型与输入  ``input``  相同。
+    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是  ``'none'`` ，则输出的维度为 :math:`[N, *]`，与输入  ``input``  的形状相同。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出的维度为 :math:`[]` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/nn/functional/triplet_margin_with_distance_loss_cn.rst b/docs/api/paddle/nn/functional/triplet_margin_with_distance_loss_cn.rst
index ea60a564458..0127ba643e2 100644
--- a/docs/api/paddle/nn/functional/triplet_margin_with_distance_loss_cn.rst
+++ b/docs/api/paddle/nn/functional/triplet_margin_with_distance_loss_cn.rst
@@ -14,36 +14,36 @@ triplet_margin_with_distance_loss
     L(input, pos, neg) = \max \{d(input_i, pos_i) - d(input_i, neg_i) + {\rm margin}, 0\}
 
 
-其中的距离函数 ``distance_function`` 可以由用户自定义，使用 lambda 或是 def 都可以。如果未定义则调用 2 范数计算距离
+其中的距离函数  ``distance_function``  可以由用户自定义，使用 lambda 或是 def 都可以。如果未定义则调用 2 范数计算距离
 
 .. math::
     d(x_i, y_i) = \left\lVert {\bf x}_i - {\bf y}_i \right\rVert_2
 
 
-``margin`` 为（input,positive）与（input,negative）的距离间隔，``swap`` 为 True 时，会比较（input，negative）和（positive，negative）的大小，并将（input，negative）的值换为其中较小的值，内容详见论文 `Learning shallow convolutional feature descriptors with triplet losses <http://www.bmva.org/bmvc/2016/papers/paper119/paper119.pdf>`_ 。
+ ``margin``  为（input,positive）与（input,negative）的距离间隔， ``swap``  为 True 时，会比较（input，negative）和（positive，negative）的大小，并将（input，negative）的值换为其中较小的值，内容详见论文 `Learning shallow convolutional feature descriptors with triplet losses <http://www.bmva.org/bmvc/2016/papers/paper119/paper119.pdf>`_ 。
 
 
 参数
 :::::::::
     - **input** (Tensor) - :math:`[N, * ]`，其中 N 是 batch_size， `*` 是任意其他维度。数据类型是 float32、float64。
-    - **positive** (Tensor) - :math:`[N, *]`，正样本，维度、数据类型与输入 ``input`` 相同。
-    - **negative** (Tensor) - :math:`[N, *]`，负样本，维度、数据类型与输入 ``input`` 相同。
+    - **positive** (Tensor) - :math:`[N, *]`，正样本，维度、数据类型与输入  ``input``  相同。
+    - **negative** (Tensor) - :math:`[N, *]`，负样本，维度、数据类型与输入  ``input``  相同。
     - **distance_function** (Callable，可选) - 手动指定范数，默认为 None，计算欧式距离。
     - **margin** (float，可选) - 手动指定间距，默认为 1。
     - **swap** (bool，可选) - 默认为 False。
-    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有：``'none'``， ``'mean'``， ``'sum'``。默认为 ``'mean'``，计算 Loss 的均值；设置为 ``'sum'`` 时，计算 Loss 的总和；设置为 ``'none'`` 时，则返回原始 Loss。
+    - **reduction** (str，可选) - 指定应用于输出结果的计算方式，可选值有： ``'none'`` ，  ``'mean'`` ，  ``'sum'`` 。默认为  ``'mean'`` ，计算 Loss 的均值；设置为  ``'sum'``  时，计算 Loss 的总和；设置为  ``'none'``  时，则返回原始 Loss。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 形状
 :::::::::
     - **input** (Tensor) - :math:`[N, *]`，其中 N 是 batch_size， `*` 是任意其他维度。数据类型是 float32、float64。
-    - **positive** (Tensor) - :math:`[N, *]`，标签 ``positive`` 的维度、数据类型与输入 ``input`` 相同。
-    - **negative** (Tensor) - :math:`[N, *]`，标签 ``negative`` 的维度、数据类型与输入 ``input`` 相同。
-    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是 ``'none'``，则输出的维度为 :math:`[N, *]`，与输入 ``input`` 的形状相同。如果 :attr:`reduction` 是 ``'mean'`` 或 ``'sum'``，则输出的维度为 :math:`[]` 。
+    - **positive** (Tensor) - :math:`[N, *]`，标签  ``positive``  的维度、数据类型与输入  ``input``  相同。
+    - **negative** (Tensor) - :math:`[N, *]`，标签  ``negative``  的维度、数据类型与输入  ``input``  相同。
+    - **output** (Tensor) - 输出的 Tensor。如果 :attr:`reduction` 是  ``'none'`` ，则输出的维度为 :math:`[N, *]`，与输入  ``input``  的形状相同。如果 :attr:`reduction` 是  ``'mean'``  或  ``'sum'`` ，则输出的维度为 :math:`[]` 。
 
 返回
 :::::::::
-    输出的 Tensor。如果 :attr:`reduction` 是 ``'none'``，则输出的维度为 :math:`[N, *]`，与输入 ``input`` 的形状相同。如果 :attr:`reduction` 是 ``'mean'`` 或           ``'sum'``，则输出的维度为 :math:`[]` 。
+    输出的 Tensor。如果 :attr:`reduction` 是  ``'none'`` ，则输出的维度为 :math:`[N, *]`，与输入  ``input``  的形状相同。如果 :attr:`reduction` 是  ``'mean'``  或            ``'sum'`` ，则输出的维度为 :math:`[]` 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/unfold_cn.rst b/docs/api/paddle/nn/functional/unfold_cn.rst
index 8dab4daec9f..0c487d9dfb9 100644
--- a/docs/api/paddle/nn/functional/unfold_cn.rst
+++ b/docs/api/paddle/nn/functional/unfold_cn.rst
@@ -8,7 +8,7 @@ unfold
 
 
 
-实现的功能与卷积中用到的 im2col 函数一样，通常也被称作为 im2col 过程。对于每一个卷积核覆盖下的区域，元素会被重新排成一列。当卷积核在整个图片上滑动时，将会形成一系列的列向量。对于每一个输入形状为[N, C, H, W]的 ``x``，都将会按照下面公式计算出一个形状为[N, Cout, Lout]的输出。
+实现的功能与卷积中用到的 im2col 函数一样，通常也被称作为 im2col 过程。对于每一个卷积核覆盖下的区域，元素会被重新排成一列。当卷积核在整个图片上滑动时，将会形成一系列的列向量。对于每一个输入形状为[N, C, H, W]的  ``x`` ，都将会按照下面公式计算出一个形状为[N, Cout, Lout]的输出。
 
 
 ..  math::
@@ -43,8 +43,8 @@ unfold
 ::::::::::::
 
     - **x**  (Tensor) – 输入 4-D Tensor，形状为[N, C, H, W]，数据类型为 float32 或者 float64
-    - **kernel_sizes**  (int|list(tuple) of int) – 卷积核的尺寸，整数或者整型列表。如果为整型列表，应包含两个元素 ``[k_h, k_w]``，卷积核大小为 ``k_h * k_w``；如果为整数 k，会被当作整型列表 ``[k, k]`` 处理
-    - **strides**  (int|list(tuple) of int，可选) – 卷积步长，整数或者整型列表。如果为整型列表，应该包含两个元素 ``[stride_h, stride_w]``。如果为整数，则 ``stride_h = stride_w = strides``。默认值为 1
+    - **kernel_sizes**  (int|list(tuple) of int) – 卷积核的尺寸，整数或者整型列表。如果为整型列表，应包含两个元素  ``[k_h, k_w]`` ，卷积核大小为  ``k_h * k_w`` ；如果为整数 k，会被当作整型列表  ``[k, k]``  处理
+    - **strides**  (int|list(tuple) of int，可选) – 卷积步长，整数或者整型列表。如果为整型列表，应该包含两个元素  ``[stride_h, stride_w]`` 。如果为整数，则  ``stride_h = stride_w = strides`` 。默认值为 1
     - **paddings** (int|list(tuple) of int，可选) – 每个维度的扩展，整数或者整型列表。如果为整型列表，长度应该为 4 或者 2；长度为 4 对应的 padding 参数是：[padding_top, padding_left，padding_bottom, padding_right]，长度为 2 对应的 padding 参数是[padding_h, padding_w]，会被当作[padding_h, padding_w, padding_h, padding_w]处理。如果为整数 padding，则会被当作[padding, padding, padding, padding]处理。默认值为 0
     - **dilations** (int|list(tuple) of int，可选) – 卷积膨胀，整型列表或者整数。如果为整型列表，应该包含两个元素[dilation_h, dilation_w]。如果是整数 dilation，会被当作整型列表[dilation, dilation]处理。默认值为 1
     - **name** (str，可选) – 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
@@ -52,7 +52,7 @@ unfold
 
 返回
 ::::::::::::
-Tensor,  unfold 操作之后的结果，形状如上面所描述的[N, Cout, Lout]，Cout 每一个滑动 block 里面覆盖的元素个数，Lout 是滑动 block 的个数，数据类型与 ``x`` 相同
+Tensor,  unfold 操作之后的结果，形状如上面所描述的[N, Cout, Lout]，Cout 每一个滑动 block 里面覆盖的元素个数，Lout 是滑动 block 的个数，数据类型与  ``x``  相同
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/upsample_cn.rst b/docs/api/paddle/nn/functional/upsample_cn.rst
index 9f9e38a376e..048fffacc1d 100644
--- a/docs/api/paddle/nn/functional/upsample_cn.rst
+++ b/docs/api/paddle/nn/functional/upsample_cn.rst
@@ -140,18 +140,18 @@ https://en.wikipedia.org/wiki/Bicubic_interpolation
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 3-D，4-D 或 5-D Tensor，数据类型为 float32、float64 或 uint8，其数据格式由参数 ``data_format`` 指定。如果没有指定 ``data_format`` 参数，其数据格式将由维度决定，具体请参照 ``data_format`` 参数。
+    - **x** (Tensor) - 3-D，4-D 或 5-D Tensor，数据类型为 float32、float64 或 uint8，其数据格式由参数  ``data_format``  指定。如果没有指定  ``data_format``  参数，其数据格式将由维度决定，具体请参照  ``data_format``  参数。
     - **size** (list|tuple|Tensor|None) - 输出 Tensor，输入为 4D Tensor 时，形状为为(out_h, out_w)的 2-D Tensor。输入为 5-D Tensor 时，形状为(out_d, out_h, out_w)的 3-D Tensor。如果 :code:`out_shape` 是列表，每一个元素可以是整数或者形状为[]的变量。如果 :code:`out_shape` 是变量，则其维度大小为 1。默认值为 None。
     - **scale_factor** (float|Tensor|list|tuple|None)-输入的高度或宽度的乘数因子。out_shape 和 scale 至少要设置一个。out_shape 的优先级高于 scale。默认值为 None。如果 scale_factor 是一个 list 或 tuple，它必须与输入的 shape 匹配。
     - **mode** (str，可选) - 插值方法。支持"bilinear"或"trilinear"或"nearest"或"bicubic"或"linear"或"area"。默认值为"nearest"。
     - **align_mode** (int，可选)- 双线性插值的可选项。可以是 '0' 代表 src_idx = scale *（dst_indx + 0.5）-0.5；如果为'1'，代表 src_idx = scale * dst_index。
     - **align_corners** (bool，可选) - 一个可选的 bool 型参数，如果为 True，则将输入和输出 Tensor 的 4 个角落像素的中心对齐，并保留角点像素的值。默认值为 True
-    - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致。支持的值有："NCW"、"NWC"、"NCHW"、"NHWC"、"NCDHW"、"NDHWC"。默认值为 None，此时若输入是 3-D Tensor， ``data_format`` 将默认为"NCW"；若输入是 4—D Tensor, 将默认为"NCHW"；若输入是 5—D Tensor, 将默认为"NCDHW"。
+    - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致。支持的值有："NCW"、"NWC"、"NCHW"、"NHWC"、"NCDHW"、"NDHWC"。默认值为 None，此时若输入是 3-D Tensor，  ``data_format``  将默认为"NCW"；若输入是 4—D Tensor, 将默认为"NCHW"；若输入是 5—D Tensor, 将默认为"NCDHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
-3-D，4-D，或 5-D Tensor，数据格式与输入 ``x`` 一致。
+3-D，4-D，或 5-D Tensor，数据格式与输入  ``x``  一致。
 
 
 代码示例
diff --git a/docs/api/paddle/nn/functional/zeropad2d_cn.rst b/docs/api/paddle/nn/functional/zeropad2d_cn.rst
index 533976abedd..001c053a43a 100644
--- a/docs/api/paddle/nn/functional/zeropad2d_cn.rst
+++ b/docs/api/paddle/nn/functional/zeropad2d_cn.rst
@@ -4,18 +4,18 @@ zeropad2d
 -------------------------------
 .. py:function:: paddle.nn.functional.zeropad2d(x, padding, data_format="NCHW", name=None)
 
-返回一个按照 ``padding`` 属性对 ``x`` 进行零填充的 Tensor，数据类型与 ``x`` 相同。
+返回一个按照  ``padding``  属性对  ``x``  进行零填充的 Tensor，数据类型与  ``x``  相同。
 
 参数
 ::::::::::
-    - **x** (Tensor) - Tensor，format 可以为 ``'NCHW'``, ``'NHWC'``，默认值为 ``'NCHW'``，数据类型支持 float16, float32, float64, int32, int64。
+    - **x** (Tensor) - Tensor，format 可以为  ``'NCHW'`` ,  ``'NHWC'`` ，默认值为  ``'NCHW'`` ，数据类型支持 float16, float32, float64, int32, int64。
     - **padding** (Tensor | List[int] | Tuple[int]) - 填充大小。pad 的格式为[pad_left, pad_right, pad_top, pad_bottom]；
-    - **data_format** (str，可选)  - 指定 ``x`` 的 format，可为 ``'NCHW'``, ``'NHWC'``，默认值为 ``'NCHW'``。
+    - **data_format** (str，可选)  - 指定  ``x``  的 format，可为  ``'NCHW'`` ,  ``'NHWC'`` ，默认值为  ``'NCHW'`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    Tensor：对 ``x`` 进行 ``'pad'`` 的结果，数据类型和 ``x`` 相同。
+    Tensor：对  ``x``  进行  ``'pad'``  的结果，数据类型和  ``x``  相同。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/nn/initializer/Dirac_cn.rst b/docs/api/paddle/nn/initializer/Dirac_cn.rst
index 5ef281db148..f178c2cf2ef 100644
--- a/docs/api/paddle/nn/initializer/Dirac_cn.rst
+++ b/docs/api/paddle/nn/initializer/Dirac_cn.rst
@@ -6,7 +6,7 @@ Dirac
 .. py:class:: paddle.nn.initializer.Dirac(groups=1, name=None)
 
 
-通过 ``狄拉克 delta 函数`` 来初始化 3D/4D/5D Tensor。
+通过  ``狄拉克 delta 函数``  来初始化 3D/4D/5D Tensor。
 
 该初始化方式一般用于 Conv1D/Conv2D/Conv3D 卷积层，能尽可能多的保留卷积层输入的特性。（如果 `out_channels` > `in_channels`，则可保留全部的输入 `channel` 特性）
 
diff --git a/docs/api/paddle/nn/initializer/calculate_gain_cn.rst b/docs/api/paddle/nn/initializer/calculate_gain_cn.rst
index ba65fbfc0db..524710da222 100644
--- a/docs/api/paddle/nn/initializer/calculate_gain_cn.rst
+++ b/docs/api/paddle/nn/initializer/calculate_gain_cn.rst
@@ -10,7 +10,7 @@ calculate_gain
 参数
 :::::::::
     - **nonlinearity** (str) - 非线性激活函数的名称。如果输入一个线性的函数，例如：`linear/conv1d/conv2d/conv3d/conv1d_transpose/conv2d_transpose/conv3d_transpose`，则返回 1.0。
-    - **param** (bool|int|float，可选) - 某些激活函数的参数，目前仅用于 ``leaky_relu`` 中的计算。默认为 ``None``，此时以 0.01 来参与 ``leaky_relu`` 的增益值计算。
+    - **param** (bool|int|float，可选) - 某些激活函数的参数，目前仅用于  ``leaky_relu``  中的计算。默认为  ``None`` ，此时以 0.01 来参与  ``leaky_relu``  的增益值计算。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/nn/initializer/set_global_initializer_cn.rst b/docs/api/paddle/nn/initializer/set_global_initializer_cn.rst
index 53565205dbe..a42199f1a24 100644
--- a/docs/api/paddle/nn/initializer/set_global_initializer_cn.rst
+++ b/docs/api/paddle/nn/initializer/set_global_initializer_cn.rst
@@ -10,7 +10,7 @@ set_global_initializer
 模型参数为模型中的 weight 和 bias 统称，在框架中对应 paddle.ParamAttr 类，继承自 paddle.Tensor，是一种可持久化的 variable。
 该 API 的设置仅对模型参数生效，对通过 :ref:`cn_api_paddle_static_create_global_var` 、 :ref:`cn_api_paddle_Tensor_create_tensor` 等 API 创建的变量不会生效。
 
-如果创建网络层时还通过 ``param_attr`` 、 ``bias_attr`` 设置了初始化方式，这里的全局设置将不会生效，因为其优先级更低。
+如果创建网络层时还通过  ``param_attr``  、  ``bias_attr``  设置了初始化方式，这里的全局设置将不会生效，因为其优先级更低。
 
 参数
 ::::::::::::
diff --git a/docs/api/paddle/nn/parameter/Parameter_cn.rst b/docs/api/paddle/nn/parameter/Parameter_cn.rst
index 2f6e0ea921c..782fbd471ca 100644
--- a/docs/api/paddle/nn/parameter/Parameter_cn.rst
+++ b/docs/api/paddle/nn/parameter/Parameter_cn.rst
@@ -7,12 +7,12 @@ Parameter
 
 一种被视为模型参数的 Tensor。
 
-Parameter 是 Tensor 的子类，当与 ``Layer`` 一起使用时具有特殊行为 - 当被赋值给 Layer 的属性时，会自动添加到该层的参数列表中。普通 Tensor 不会有此效果。
+Parameter 是 Tensor 的子类，当与  ``Layer``  一起使用时具有特殊行为 - 当被赋值给 Layer 的属性时，会自动添加到该层的参数列表中。普通 Tensor 不会有此效果。
 
 参数
 :::::::::
  - **data** (Tensor，可选) - 参数的 Tensor 数据。如果为 None，则创建一个未初始化的参数，默认值为 None。
- - **requires_grad** (bool，可选) - 是否需要计算梯度。注意 ``paddle.no_grad()`` 不会影响 Parameter 的默认创建行为(在 no_grad 模式下仍会保持 ``requires_grad=True``)，默认值为 True。
+ - **requires_grad** (bool，可选) - 是否需要计算梯度。注意  ``paddle.no_grad()``  不会影响 Parameter 的默认创建行为(在 no_grad 模式下仍会保持  ``requires_grad=True`` )，默认值为 True。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/quant/llm_int8_linear_cn.rst b/docs/api/paddle/nn/quant/llm_int8_linear_cn.rst
index 36299085863..34ef59028bb 100644
--- a/docs/api/paddle/nn/quant/llm_int8_linear_cn.rst
+++ b/docs/api/paddle/nn/quant/llm_int8_linear_cn.rst
@@ -21,7 +21,7 @@ llm_int8_linear
 
 返回
 ::::::::::::
-    - ``Tensor``：输出张量，其数据类型与 x 相同。
+    -  ``Tensor`` ：输出张量，其数据类型与 x 相同。
 
 代码示例：
 ::::::::::
diff --git a/docs/api/paddle/nn/quant/weight_only_linear_cn.rst b/docs/api/paddle/nn/quant/weight_only_linear_cn.rst
index 8a156888e38..f2e008d07c2 100644
--- a/docs/api/paddle/nn/quant/weight_only_linear_cn.rst
+++ b/docs/api/paddle/nn/quant/weight_only_linear_cn.rst
@@ -20,7 +20,7 @@ weight_only_linear
 
 返回
 ::::::::::::
-    - ``Tensor``：输出张量，其数据类型与 x 相同。
+    -  ``Tensor`` ：输出张量，其数据类型与 x 相同。
 
 代码示例：
 ::::::::::
diff --git a/docs/api/paddle/nn/utils/parameters_to_vector_cn.rst b/docs/api/paddle/nn/utils/parameters_to_vector_cn.rst
index d91a54024de..74c6211f641 100644
--- a/docs/api/paddle/nn/utils/parameters_to_vector_cn.rst
+++ b/docs/api/paddle/nn/utils/parameters_to_vector_cn.rst
@@ -14,7 +14,7 @@ parameters_to_vector
 
 返回
 :::::::::
-``Tensor``，多个 parameter 展平并连接的 1-D Tensor
+ ``Tensor`` ，多个 parameter 展平并连接的 1-D Tensor
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/utils/remove_weight_norm_cn.rst b/docs/api/paddle/nn/utils/remove_weight_norm_cn.rst
index de2c77c2493..301d1e59e50 100644
--- a/docs/api/paddle/nn/utils/remove_weight_norm_cn.rst
+++ b/docs/api/paddle/nn/utils/remove_weight_norm_cn.rst
@@ -5,18 +5,18 @@ remove_weight_norm
 
 .. py:function:: paddle.nn.utils.remove_weight_norm(layer, name='weight')
 
-移除传入 ``layer`` 中的权重归一化。
+移除传入  ``layer``  中的权重归一化。
 
 参数
 ::::::::::::
 
    - **layer** (Layer) - 要移除权重归一化的层。
-   - **name** (str，可选) - 权重参数的名字。默认值为 ``weight``。
+   - **name** (str，可选) - 权重参数的名字。默认值为  ``weight`` 。
 
 返回
 ::::::::::::
 
-   ``Layer``，移除权重归一化 hook 之后的层。
+    ``Layer`` ，移除权重归一化 hook 之后的层。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/nn/utils/spectral_norm_cn.rst b/docs/api/paddle/nn/utils/spectral_norm_cn.rst
index 04c8f1bd821..94500f34dc7 100644
--- a/docs/api/paddle/nn/utils/spectral_norm_cn.rst
+++ b/docs/api/paddle/nn/utils/spectral_norm_cn.rst
@@ -6,11 +6,11 @@ spectral_norm
 .. py:function:: paddle.nn.utils.spectral_norm(layer, name='weight', n_power_iterations=1, eps=1e-12, dim=None)
 
 
-根据以下步骤对传入的 ``layer`` 中的权重参数进行谱归一化：
+根据以下步骤对传入的  ``layer``  中的权重参数进行谱归一化：
 
-步骤 1：生成形状为[H]的向量 U，以及形状为[W]的向量 V，其中 H 是输入权重 Tensor 的第 ``dim`` 个维度，W 是剩余维度的乘积。
+步骤 1：生成形状为[H]的向量 U，以及形状为[W]的向量 V，其中 H 是输入权重 Tensor 的第  ``dim``  个维度，W 是剩余维度的乘积。
 
-步骤 2： ``n_power_iterations`` 是一个正整数，用 U 和 V 迭代计算 ``n_power_iterations`` 轮，迭代步骤如下。
+步骤 2：  ``n_power_iterations``  是一个正整数，用 U 和 V 迭代计算  ``n_power_iterations``  轮，迭代步骤如下。
 
 .. math::
 
@@ -29,15 +29,15 @@ spectral_norm
 ::::::::::::
 
     - **layer** (paddle.nn.Layer) - 要添加权重谱归一化的层。
-    - **name** (str，可选) - 权重参数的名字。默认值为 ``weight``。
-    - **n_power_iterations** (int，可选) - 将用于计算的 ``SpectralNorm`` 幂迭代次数，默认值：1。
-    - **eps** (float，可选) -  ``eps`` 用于保证计算中的数值稳定性，分母会加上 ``eps`` 防止除零。默认值：1e-12。
+    - **name** (str，可选) - 权重参数的名字。默认值为  ``weight`` 。
+    - **n_power_iterations** (int，可选) - 将用于计算的  ``SpectralNorm``  幂迭代次数，默认值：1。
+    - **eps** (float，可选) -   ``eps``  用于保证计算中的数值稳定性，分母会加上  ``eps``  防止除零。默认值：1e-12。
     - **dim** (int，可选) - 将输入（weight）重塑为矩阵之前应排列到第一个的维度索引，如果 input（weight）是 fc 层的权重，则应设置为 0；如果 input（weight）是 conv 层的权重，则应设置为 1。默认值：None。
 
 返回
 ::::::::::::
 
-   ``Layer``，添加了权重谱归一化的层
+    ``Layer`` ，添加了权重谱归一化的层
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/nn/utils/weight_norm_cn.rst b/docs/api/paddle/nn/utils/weight_norm_cn.rst
index fdd9856a16b..a9e528bde4c 100644
--- a/docs/api/paddle/nn/utils/weight_norm_cn.rst
+++ b/docs/api/paddle/nn/utils/weight_norm_cn.rst
@@ -5,7 +5,7 @@ weight_norm
 
 .. py:function:: paddle.nn.utils.weight_norm(layer, name='weight', dim=0)
 
-根据以下公式对传入的 ``layer`` 中的权重参数进行归一化：
+根据以下公式对传入的  ``layer``  中的权重参数进行归一化：
 
 .. math::
     \mathbf{w} = g \dfrac{v}{\|v\|}
@@ -16,13 +16,13 @@ weight_norm
 ::::::::::::
 
    - **layer** (paddle.nn.Layer) - 要添加权重归一化的层。
-   - **name** (str，可选) - 权重参数的名字。默认值为 ``weight``。
+   - **name** (str，可选) - 权重参数的名字。默认值为  ``weight`` 。
    - **dim** (int|None，可选) - 进行归一化操作的切片所在维度，是小于权重 Tensor rank 的非负数。比如卷积的权重 shape 是 [cout,cin,kh,kw] , rank 是 4，则 dim 可以选 0,1,2,3；fc 的权重 shape 是 [cout,cin] ，rank 是 2，dim 可以选 0，1。如果为 None 就对所有维度上的元素做归一化。默认：0。
 
 返回
 ::::::::::::
 
-   ``Layer``，添加了权重归一化 hook 的层。
+    ``Layer`` ，添加了权重归一化 hook 的层。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/no_grad_cn.rst b/docs/api/paddle/no_grad_cn.rst
index 842bd874b14..1e8d0fc0710 100644
--- a/docs/api/paddle/no_grad_cn.rst
+++ b/docs/api/paddle/no_grad_cn.rst
@@ -12,7 +12,7 @@ no_grad
 也可以用作一个装饰器（需要创建实例对象作为装饰器）。
 
 .. note::
-    别名支持: 参数名 ``orig_func`` 可替代 ``func``。
+    别名支持: 参数名  ``orig_func``  可替代  ``func`` 。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/nonzero_cn.rst b/docs/api/paddle/nonzero_cn.rst
index 74e58ae7421..41adf7c75b0 100644
--- a/docs/api/paddle/nonzero_cn.rst
+++ b/docs/api/paddle/nonzero_cn.rst
@@ -8,18 +8,18 @@ nonzero
 
 
 
-返回输入 ``x`` 中非零元素的坐标。如果输入 ``x`` 有 ``n`` 维，共包含 ``z`` 个非零元素，当 ``as_tuple = False`` 时，
-返回结果是一个 ``shape`` 等于 ``[z x n]`` 的 ``Tensor``，第 ``i`` 行代表输入中第 ``i`` 个非零元素的坐标；当 ``as_tuple = True`` 时，
-返回结果是由 ``n`` 个大小为 ``z`` 的 ``1-D Tensor`` 构成的元组，第 ``i`` 个 ``1-D Tensor`` 记录输入的非零元素在第 ``i`` 维的坐标。
+返回输入  ``x``  中非零元素的坐标。如果输入  ``x``  有  ``n``  维，共包含  ``z``  个非零元素，当  ``as_tuple = False``  时，
+返回结果是一个  ``shape``  等于  ``[z x n]``  的  ``Tensor`` ，第  ``i``  行代表输入中第  ``i``  个非零元素的坐标；当  ``as_tuple = True``  时，
+返回结果是由  ``n``  个大小为  ``z``  的  ``1-D Tensor``  构成的元组，第  ``i``  个  ``1-D Tensor``  记录输入的非零元素在第  ``i``  维的坐标。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x`` ，如 ``nonzero(input=tensor_x)`` 等价于 ``nonzero(x=tensor_x)`` 。
+    别名支持: 参数名  ``input``  可替代  ``x``  ，如  ``nonzero(input=tensor_x)``  等价于  ``nonzero(x=tensor_x)``  。
 
 参数
 :::::::::
 
-    - **x** （Tensor）– 输入的 Tensor。别名： ``input``。
-    - **as_tuple** (bool，可选) - 返回格式。是否以 ``1-D Tensor`` 构成的元组格式返回。
+    - **x** （Tensor）– 输入的 Tensor。别名：  ``input`` 。
+    - **as_tuple** (bool，可选) - 返回格式。是否以  ``1-D Tensor``  构成的元组格式返回。
 
 关键字参数
 :::::::::
diff --git a/docs/api/paddle/normal__cn.rst b/docs/api/paddle/normal__cn.rst
index 9d98fb92942..2a79ef0d8a2 100644
--- a/docs/api/paddle/normal__cn.rst
+++ b/docs/api/paddle/normal__cn.rst
@@ -22,7 +22,7 @@ Inplace 版本的 :ref:`cn_api_paddle_normal` API，对输入 x 采用 Inplace 
 
 返回
 ::::::::::
-   Tensor：符合正态分布（均值为 ``mean``，标准差为 ``std`` 的正态随机分布）的随机 Tensor。
+   Tensor：符合正态分布（均值为  ``mean`` ，标准差为  ``std``  的正态随机分布）的随机 Tensor。
 
 示例代码
 ::::::::::
diff --git a/docs/api/paddle/normal_cn.rst b/docs/api/paddle/normal_cn.rst
index 0a3b0420f43..775b497e66c 100644
--- a/docs/api/paddle/normal_cn.rst
+++ b/docs/api/paddle/normal_cn.rst
@@ -6,27 +6,27 @@ normal
 .. py:function:: paddle.normal(mean=0.0, std=1.0, shape=None, name=None)
 
 
-返回符合正态分布（均值为 ``mean``，标准差为 ``std`` 的正态随机分布）的随机 Tensor。
+返回符合正态分布（均值为  ``mean`` ，标准差为  ``std``  的正态随机分布）的随机 Tensor。
 
-如果 ``mean`` 是 Tensor，则输出 Tensor 和 ``mean`` 具有相同的形状和数据类型。
-如果 ``mean`` 不是 Tensor，且 ``std`` 是 Tensor，则输出 Tensor 和 ``std`` 具有相同的形状和数据类型。
-如果 ``mean`` 和 ``std`` 都不是 Tensor，则输出 Tensor 的形状为 ``shape``，数据类型为 float32。
+如果  ``mean``  是 Tensor，则输出 Tensor 和  ``mean``  具有相同的形状和数据类型。
+如果  ``mean``  不是 Tensor，且  ``std``  是 Tensor，则输出 Tensor 和  ``std``  具有相同的形状和数据类型。
+如果  ``mean``  和  ``std``  都不是 Tensor，则输出 Tensor 的形状为  ``shape`` ，数据类型为 float32。
 
-如果 ``mean`` 和 ``std`` 都是 Tensor，则 ``mean`` 和 ``std`` 的元素个数应该相同。
+如果  ``mean``  和  ``std``  都是 Tensor，则  ``mean``  和  ``std``  的元素个数应该相同。
 
-如果 ``mean`` 是一个复数，则输出 Tensor 服从复正态分布，其数据类型为 complex64。
-如果 ``mean`` 是复数类型的 Tensor，则输出 Tensor 的数据类型与 ``mean`` 相同。
+如果  ``mean``  是一个复数，则输出 Tensor 服从复正态分布，其数据类型为 complex64。
+如果  ``mean``  是复数类型的 Tensor，则输出 Tensor 的数据类型与  ``mean``  相同。
 
 参数
 ::::::::::
-    - **mean** (float|complex|Tensor，可选) - 输出 Tensor 的正态分布的平均值。如果 ``mean`` 是 float，则表示输出 Tensor 中所有元素的正态分布的平均值。如果 ``mean`` 是 Tensor (支持的数据类型为 float32、float64、complex64、complex128)，则表示输出 Tensor 中每个元素的正态分布的平均值。默认值为 0.0。
-    - **std** (float|Tensor，可选) - 输出 Tensor 的正态分布的标准差。如果 ``std`` 是 float，则表示输出 Tensor 中所有元素的正态分布的标准差。如果 ``std`` 是 Tensor (支持的数据类型为 float32、float64)，则表示输出 Tensor 中每个元素的正态分布的标准差。默认值为 0.0。
-    - **shape** (list|tuple|Tensor，可选) - 生成的随机 Tensor 的形状。如果 ``shape`` 是 list、tuple，则其中的元素可以是 int，或者是形状为[]且数据类型为 int32、int64 的 0-D Tensor。如果 ``shape`` 是 Tensor，则是数据类型为 int32、int64 的 1D Tensor。如果 ``mean`` 或者 ``std`` 是 Tensor，输出 Tensor 的形状和 ``mean`` 或者 ``std`` 相同(此时 ``shape`` 无效)。默认值为 None。
+    - **mean** (float|complex|Tensor，可选) - 输出 Tensor 的正态分布的平均值。如果  ``mean``  是 float，则表示输出 Tensor 中所有元素的正态分布的平均值。如果  ``mean``  是 Tensor (支持的数据类型为 float32、float64、complex64、complex128)，则表示输出 Tensor 中每个元素的正态分布的平均值。默认值为 0.0。
+    - **std** (float|Tensor，可选) - 输出 Tensor 的正态分布的标准差。如果  ``std``  是 float，则表示输出 Tensor 中所有元素的正态分布的标准差。如果  ``std``  是 Tensor (支持的数据类型为 float32、float64)，则表示输出 Tensor 中每个元素的正态分布的标准差。默认值为 0.0。
+    - **shape** (list|tuple|Tensor，可选) - 生成的随机 Tensor 的形状。如果  ``shape``  是 list、tuple，则其中的元素可以是 int，或者是形状为[]且数据类型为 int32、int64 的 0-D Tensor。如果  ``shape``  是 Tensor，则是数据类型为 int32、int64 的 1D Tensor。如果  ``mean``  或者  ``std``  是 Tensor，输出 Tensor 的形状和  ``mean``  或者  ``std``  相同(此时  ``shape``  无效)。默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-  Tensor：符合正态分布（均值为 ``mean``，标准差为 ``std`` 的正态随机分布）的随机 Tensor。
+  Tensor：符合正态分布（均值为  ``mean`` ，标准差为  ``std``  的正态随机分布）的随机 Tensor。
 
 示例代码
 ::::::::::
diff --git a/docs/api/paddle/numel_cn.rst b/docs/api/paddle/numel_cn.rst
index fda44244e48..57fd0a9c573 100644
--- a/docs/api/paddle/numel_cn.rst
+++ b/docs/api/paddle/numel_cn.rst
@@ -16,7 +16,7 @@ numel
 
 返回
 ::::::::::::
-返回值为 ``x`` 元素个数的 0-D Tensor。
+返回值为  ``x``  元素个数的 0-D Tensor。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/ones_cn.rst b/docs/api/paddle/ones_cn.rst
index c144630efe3..a6d93c730c6 100644
--- a/docs/api/paddle/ones_cn.rst
+++ b/docs/api/paddle/ones_cn.rst
@@ -7,38 +7,38 @@ ones
 
 
 
-创建一个形状为 ``shape``、数据类型为 ``dtype`` 且值全为 1 的 Tensor。
+创建一个形状为  ``shape`` 、数据类型为  ``dtype``  且值全为 1 的 Tensor。
 
 .. note::
-    别名支持: 参数名 ``size`` 可替代 ``shape``。
-    ``shape`` 支持可变参数类型。
+    别名支持: 参数名  ``size``  可替代  ``shape`` 。
+     ``shape``  支持可变参数类型。
     使用实例：
-        ``paddle.ones(1, 2, 3, dtype=paddle.float32)``
+         ``paddle.ones(1, 2, 3, dtype=paddle.float32)`` 
 
-        ``paddle.ones(size=[1, 2, 3], dtype=paddle.float32)``
+         ``paddle.ones(size=[1, 2, 3], dtype=paddle.float32)`` 
 
 
 参数
 :::::::::
 
     - **shape** (list|tuple|Tensor|*shape) - 生成的 Tensor 的形状。数据类型为 int32 或 int64。
-      如果 ``shape`` 是 list、tuple，则其中的元素可以是 int，或者是形状为 [] 且数据类型为 int32、int64 的 0-D Tensor。
-      如果 ``shape`` 是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor，表示一个列表。
-      如果 ``shape`` 是 \*shape，则可以直接以可变参数的形式传入多个整数（例如 ``randn(2, 3)``）。
-      该参数的别名为 ``size``。
-    - **dtype** (str|paddle.dtype|np.dtype，可选) - 要创建的 Tensor 的数据类型，可以为 bool、float16、float32、float64、int32 或 int64。如果 ``dtype`` 为 None，那么数据类型为 float32。
+      如果  ``shape``  是 list、tuple，则其中的元素可以是 int，或者是形状为 [] 且数据类型为 int32、int64 的 0-D Tensor。
+      如果  ``shape``  是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor，表示一个列表。
+      如果  ``shape``  是 \*shape，则可以直接以可变参数的形式传入多个整数（例如  ``randn(2, 3)`` ）。
+      该参数的别名为  ``size`` 。
+    - **dtype** (str|paddle.dtype|np.dtype，可选) - 要创建的 Tensor 的数据类型，可以为 bool、float16、float32、float64、int32 或 int64。如果  ``dtype``  为 None，那么数据类型为 float32。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 ::::::::::::
     - **out** (Tensor，可选) - 用于存储结果的 Tensor。若指定，将直接写入该 Tensor，默认值为 None。
-    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。默认值为 None，表示使用当前全局设备（可通过 ``paddle.device.set_device`` 设置）。
+    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。默认值为 None，表示使用当前全局设备（可通过  ``paddle.device.set_device``  设置）。
     - **requires_grad** (bool，可选) - 是否需要为返回的 Tensor 记录梯度信息。默认值为 False。
     - **pin_memory** (bool，可选) - 若为 True，返回的 CPU Tensor 将分配在锁页内存中。仅对 CPU Tensor 生效。默认值为 False。
 
 返回
 :::::::::
-Tensor，每个元素都是 1，形状为 ``shape``，数据类型为 ``dtype``。
+Tensor，每个元素都是 1，形状为  ``shape`` ，数据类型为  ``dtype`` 。
 
 
 代码示例
diff --git a/docs/api/paddle/ones_like_cn.rst b/docs/api/paddle/ones_like_cn.rst
index 28581e69e86..33371771881 100644
--- a/docs/api/paddle/ones_like_cn.rst
+++ b/docs/api/paddle/ones_like_cn.rst
@@ -6,29 +6,29 @@ ones_like
 .. py:function:: paddle.ones_like(x, dtype=None, name=None, *, device=None, requires_grad=False, pin_memory=False)
 
 
-返回一个和输入参数 ``x`` 具有相同形状的数值都为 1 的 Tensor，数据类型为 ``dtype`` 或者和 ``x`` 相同，如果 ``dtype`` 为 None，则输出 Tensor 的数据类型与 ``x`` 相同。
+返回一个和输入参数  ``x``  具有相同形状的数值都为 1 的 Tensor，数据类型为  ``dtype``  或者和  ``x``  相同，如果  ``dtype``  为 None，则输出 Tensor 的数据类型与  ``x``  相同。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` 。
 
 参数
 ::::::::::
     - **x** (Tensor) – 输入的 Tensor，数据类型可以是 bool，float16，float32，float64，int32，int64。
-    - **input** - ``x`` 的别名，行为完全一致。
-      别名： ``input``
-    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，支持 bool，float16, float32，float64，int32，int64。当该参数值为 None 时，输出 Tensor 的数据类型与 ``x`` 相同。默认值为 None。
+    - **input** -  ``x``  的别名，行为完全一致。
+      别名：  ``input`` 
+    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，支持 bool，float16, float32，float64，int32，int64。当该参数值为 None 时，输出 Tensor 的数据类型与  ``x``  相同。默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 ::::::::::::
-    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。若为 None，则与 ``x`` 保持一致。
+    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。若为 None，则与  ``x``  保持一致。
     - **requires_grad** (bool，可选) - 是否需要为返回的 Tensor 记录梯度信息。默认值为 False。
     - **pin_memory** (bool，可选) - 若为 True，返回的 CPU Tensor 将分配在锁页内存中。仅对 CPU Tensor 生效。默认值为 False。
 
 返回
 ::::::::::
 
-Tensor：和 ``x`` 具有相同形状的数值都为 1 的 Tensor，数据类型为 ``dtype`` 或者和 ``x`` 相同。
+Tensor：和  ``x``  具有相同形状的数值都为 1 的 Tensor，数据类型为  ``dtype``  或者和  ``x``  相同。
 
 
 代码示例
diff --git a/docs/api/paddle/onnx/export_cn.rst b/docs/api/paddle/onnx/export_cn.rst
index 8b1399ad2e3..3364eaa5a1c 100644
--- a/docs/api/paddle/onnx/export_cn.rst
+++ b/docs/api/paddle/onnx/export_cn.rst
@@ -5,7 +5,7 @@ export
 
 .. py:function:: paddle.onnx.export(layer, path, input_spec=None, opset_version=9, **configs)
 
-将输入的 ``Layer`` 存储为 ``ONNX`` 格式的模型，可使用 onnxruntime 或其他框架进行推理。
+将输入的  ``Layer``  存储为  ``ONNX``  格式的模型，可使用 onnxruntime 或其他框架进行推理。
 
 .. note::
 
@@ -13,11 +13,11 @@ export
 
 参数
 :::::::::
-    - **layer** (Layer) - 导出的 ``Layer`` 对象。
-    - **path** (str) - 存储模型的路径前缀。格式为 ``dirname/file_prefix`` 或者 ``file_prefix``，导出后``ONNX``模型自动添加后缀 ``.onnx`` 。
-    - **input_spec** (list[InputSpec|Tensor]，可选) - 描述存储模型 forward 方法的输入，可以通过 InputSpec 或者示例 Tensor 进行描述。如果为 ``None``，所有原 ``Layer`` forward 方法的输入变量将都会被配置为存储模型的输入变量。默认为 ``None``。
-    - **opset_version** (int，可选) - 导出 ``ONNX`` 模型的 Opset 版本，目前稳定支持导出的版本为 9、10 和 11。默认为 ``9``。
-    - **configs (dict，可选) - 其他用于兼容的存储配置选项。这些选项将来可能被移除，如果不是必须使用，不推荐使用这些配置选项。默认为 ``None``。目前支持以下配置选项：(1) output_spec (list[Tensor]) - 选择存储模型的输出目标。默认情况下，所有原 ``Layer`` forward 方法的返回值均会作为存储模型的输出。如果传入的 ``output_spec`` 列表不是所有的输出变量，存储的模型将会根据 ``output_spec`` 所包含的结果被裁剪。
+    - **layer** (Layer) - 导出的  ``Layer``  对象。
+    - **path** (str) - 存储模型的路径前缀。格式为  ``dirname/file_prefix``  或者  ``file_prefix`` ，导出后 ``ONNX`` 模型自动添加后缀  ``.onnx``  。
+    - **input_spec** (list[InputSpec|Tensor]，可选) - 描述存储模型 forward 方法的输入，可以通过 InputSpec 或者示例 Tensor 进行描述。如果为  ``None`` ，所有原  ``Layer``  forward 方法的输入变量将都会被配置为存储模型的输入变量。默认为  ``None`` 。
+    - **opset_version** (int，可选) - 导出  ``ONNX``  模型的 Opset 版本，目前稳定支持导出的版本为 9、10 和 11。默认为  ``9`` 。
+    - **configs (dict，可选) - 其他用于兼容的存储配置选项。这些选项将来可能被移除，如果不是必须使用，不推荐使用这些配置选项。默认为  ``None`` 。目前支持以下配置选项：(1) output_spec (list[Tensor]) - 选择存储模型的输出目标。默认情况下，所有原  ``Layer``  forward 方法的返回值均会作为存储模型的输出。如果传入的  ``output_spec``  列表不是所有的输出变量，存储的模型将会根据  ``output_spec``  所包含的结果被裁剪。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/optimizer/ASGD_cn.rst b/docs/api/paddle/optimizer/ASGD_cn.rst
index e5630a4d0e5..d7bfe62c011 100644
--- a/docs/api/paddle/optimizer/ASGD_cn.rst
+++ b/docs/api/paddle/optimizer/ASGD_cn.rst
@@ -75,7 +75,7 @@ minimize(loss, startup_program=None, parameters=None, no_grad_set=None)
 
 **返回**
 
- tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到 ``Executor.run()`` 接口的 ``fetch_list`` 参数中，若加入，则会重写 ``use_prune`` 参数为 True，并根据 ``feed`` 和 ``fetch_list`` 进行剪枝，详见 ``Executor`` 的文档。
+ tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到  ``Executor.run()``  接口的  ``fetch_list``  参数中，若加入，则会重写  ``use_prune``  参数为 True，并根据  ``feed``  和  ``fetch_list``  进行剪枝，详见  ``Executor``  的文档。
 
 
 **代码示例**
diff --git a/docs/api/paddle/optimizer/Adadelta_cn.rst b/docs/api/paddle/optimizer/Adadelta_cn.rst
index cfeb4644a66..333b6bec41f 100644
--- a/docs/api/paddle/optimizer/Adadelta_cn.rst
+++ b/docs/api/paddle/optimizer/Adadelta_cn.rst
@@ -76,7 +76,7 @@ minimize(loss, startup_program=None, parameters=None, no_grad_set=None)
 
 **返回**
 
- tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到 ``Executor.run()`` 接口的 ``fetch_list`` 参数中，若加入，则会重写 ``use_prune`` 参数为 True，并根据 ``feed`` 和 ``fetch_list`` 进行剪枝，详见 ``Executor`` 的文档。
+ tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到  ``Executor.run()``  接口的  ``fetch_list``  参数中，若加入，则会重写  ``use_prune``  参数为 True，并根据  ``feed``  和  ``fetch_list``  进行剪枝，详见  ``Executor``  的文档。
 
 
 **代码示例**
@@ -102,7 +102,7 @@ set_lr(value)
 .. note::
     该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-手动设置当前 ``optimizer`` 的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
+手动设置当前  ``optimizer``  的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
 
 **参数**
 
@@ -122,7 +122,7 @@ set_lr_scheduler(scheduler)
 .. note::
     该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-手动设置当前 ``optimizer`` 的学习率为 LRScheduler 类。
+手动设置当前  ``optimizer``  的学习率为 LRScheduler 类。
 
 **参数**
 
diff --git a/docs/api/paddle/optimizer/Adagrad_cn.rst b/docs/api/paddle/optimizer/Adagrad_cn.rst
index eeeca3350a6..29d35fb9917 100644
--- a/docs/api/paddle/optimizer/Adagrad_cn.rst
+++ b/docs/api/paddle/optimizer/Adagrad_cn.rst
@@ -18,7 +18,7 @@ Adaptive Gradient 优化器（自适应梯度优化器，简称 Adagrad）可以
 
 相关论文：`Adaptive Subgradient Methods for Online Learning and Stochastic Optimization <http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf>`_ 。
 
-原始论文的算法中没有引入上述公式中的 ``epsilon`` 属性，此处引入该属性用于维持数值稳定性，避免除 0 错误发生。
+原始论文的算法中没有引入上述公式中的  ``epsilon``  属性，此处引入该属性用于维持数值稳定性，避免除 0 错误发生。
 
 引入 epsilon 参数依据：`Per-parameter adaptive learning rate methods <http://cs231n.github.io/neural-networks-3/#ada>`_ 。
 
diff --git a/docs/api/paddle/optimizer/AdamW_cn.rst b/docs/api/paddle/optimizer/AdamW_cn.rst
index 29b8a7b993d..fd7f5477e72 100755
--- a/docs/api/paddle/optimizer/AdamW_cn.rst
+++ b/docs/api/paddle/optimizer/AdamW_cn.rst
@@ -87,7 +87,7 @@ minimize(loss, startup_program=None, parameters=None, no_grad_set=None)
 
 **返回**
 
-tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到 ``Executor.run()`` 接口的 ``fetch_list`` 参数中，若加入，则会重写 ``use_prune`` 参数为 True，并根据 ``feed`` 和 ``fetch_list`` 进行剪枝，详见 ``Executor`` 的文档。
+tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到  ``Executor.run()``  接口的  ``fetch_list``  参数中，若加入，则会重写  ``use_prune``  参数为 True，并根据  ``feed``  和  ``fetch_list``  进行剪枝，详见  ``Executor``  的文档。
 
 
 **代码示例**
@@ -113,7 +113,7 @@ set_lr(value)
 .. note::
   该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-手动设置当前 ``optimizer`` 的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
+手动设置当前  ``optimizer``  的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
 
 **参数**
 
@@ -133,7 +133,7 @@ set_lr_scheduler(scheduler)
 .. note::
   该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-手动设置当前 ``optimizer`` 的学习率为 LRScheduler 类。
+手动设置当前  ``optimizer``  的学习率为 LRScheduler 类。
 
 **参数**
 
diff --git a/docs/api/paddle/optimizer/Adam_cn.rst b/docs/api/paddle/optimizer/Adam_cn.rst
index 450995d2207..eec62871ee4 100755
--- a/docs/api/paddle/optimizer/Adam_cn.rst
+++ b/docs/api/paddle/optimizer/Adam_cn.rst
@@ -104,7 +104,7 @@ minimize(loss, startup_program=None, parameters=None, no_grad_set=None)
 
 **返回**
 
- tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到 ``Executor.run()`` 接口的 ``fetch_list`` 参数中，若加入，则会重写 ``use_prune`` 参数为 True，并根据 ``feed`` 和 ``fetch_list`` 进行剪枝，详见 ``Executor`` 的文档。
+ tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到  ``Executor.run()``  接口的  ``fetch_list``  参数中，若加入，则会重写  ``use_prune``  参数为 True，并根据  ``feed``  和  ``fetch_list``  进行剪枝，详见  ``Executor``  的文档。
 
 
 **代码示例**
@@ -131,7 +131,7 @@ set_lr(value)
 
     该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-手动设置当前 ``optimizer`` 的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
+手动设置当前  ``optimizer``  的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
 
 **参数**
 
@@ -152,7 +152,7 @@ set_lr_scheduler(scheduler)
 
     该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-手动设置当前 ``optimizer`` 的学习率为 LRScheduler 类。
+手动设置当前  ``optimizer``  的学习率为 LRScheduler 类。
 
 **参数**
 
diff --git a/docs/api/paddle/optimizer/Adamax_cn.rst b/docs/api/paddle/optimizer/Adamax_cn.rst
index 02df286826e..c8b7a7c0088 100755
--- a/docs/api/paddle/optimizer/Adamax_cn.rst
+++ b/docs/api/paddle/optimizer/Adamax_cn.rst
@@ -25,7 +25,7 @@ Adamax 优化器是参考 `Adam 论文 <https://arxiv.org/abs/1412.6980>`_ 第 7
 
 相关论文：`Adam: A Method for Stochastic Optimization <https://arxiv.org/abs/1412.6980>`_
 
-论文中没有 ``epsilon`` 参数。但是，为了保持数值稳定性，避免除 0 错误，此处增加了这个参数。
+论文中没有  ``epsilon``  参数。但是，为了保持数值稳定性，避免除 0 错误，此处增加了这个参数。
 
 参数
 ::::::::::::
@@ -43,7 +43,7 @@ Adamax 优化器是参考 `Adam 论文 <https://arxiv.org/abs/1412.6980>`_ 第 7
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 .. note::
-    目前 ``Adamax`` 不支持 Sparse Parameter Optimization（稀疏参数优化）。
+    目前  ``Adamax``  不支持 Sparse Parameter Optimization（稀疏参数优化）。
 
 代码示例
 ::::::::::::
@@ -84,7 +84,7 @@ minimize(loss, startup_program=None, parameters=None, no_grad_set=None)
 
 **返回**
 
- tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到 ``Executor.run()`` 接口的 ``fetch_list`` 参数中，若加入，则会重写 ``use_prune`` 参数为 True，并根据 ``feed`` 和 ``fetch_list`` 进行剪枝，详见 ``Executor`` 的文档。
+ tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到  ``Executor.run()``  接口的  ``fetch_list``  参数中，若加入，则会重写  ``use_prune``  参数为 True，并根据  ``feed``  和  ``fetch_list``  进行剪枝，详见  ``Executor``  的文档。
 
 **代码示例**
 
@@ -112,7 +112,7 @@ set_lr(value)
 
     该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-手动设置当前 ``optimizer`` 的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
+手动设置当前  ``optimizer``  的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
 
 **参数**
 
@@ -133,7 +133,7 @@ set_lr_scheduler(scheduler)
 
     该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-手动设置当前 ``optimizer`` 的学习率为 LRScheduler 类。
+手动设置当前  ``optimizer``  的学习率为 LRScheduler 类。
 
 **参数**
 
diff --git a/docs/api/paddle/optimizer/LBFGS_cn.rst b/docs/api/paddle/optimizer/LBFGS_cn.rst
index 6f1b0524fc1..91d35cba8f3 100644
--- a/docs/api/paddle/optimizer/LBFGS_cn.rst
+++ b/docs/api/paddle/optimizer/LBFGS_cn.rst
@@ -5,7 +5,7 @@ LBFGS
 
 .. py:class:: paddle.optimizer.LBFGS(learning_rate=1.0, max_iter=20, max_eval=None, tolerance_grad=1e-07, tolerance_change=1e-09, history_size=100, line_search_fn=None, parameters=None, weight_decay=None, grad_clip=None, name=None)
 
-``LBFGS`` 使用 L-BFGS 方法对参数进行优化更新，使得 loss 值最小。
+ ``LBFGS``  使用 L-BFGS 方法对参数进行优化更新，使得 loss 值最小。
 
 L-BFGS 是限制内存的 BFGS 方法，适用于海森矩阵为稠密矩阵、内存开销较大场景。BFGS 参考 :ref:`cn_api_paddle_incubate_optimizer_functional_minimize_bfgs` .
 
diff --git a/docs/api/paddle/optimizer/Lamb_cn.rst b/docs/api/paddle/optimizer/Lamb_cn.rst
index 36f9596f55b..62f4e82d1ed 100755
--- a/docs/api/paddle/optimizer/Lamb_cn.rst
+++ b/docs/api/paddle/optimizer/Lamb_cn.rst
@@ -40,7 +40,7 @@ LAMB（Layer-wise Adaptive Moments optimizer for Batching training）优化器
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 .. note::
-    目前 ``Lamb`` 不支持 Sparse Parameter Optimization（稀疏参数优化）。
+    目前  ``Lamb``  不支持 Sparse Parameter Optimization（稀疏参数优化）。
 
 代码示例
 ::::::::::::
@@ -79,7 +79,7 @@ minimize(loss, startup_program=None, parameters=None, no_grad_set=None)
 
 **返回**
 
- tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到 ``Executor.run()`` 接口的 ``fetch_list`` 参数中，若加入，则会重写 ``use_prune`` 参数为 True，并根据 ``feed`` 和 ``fetch_list`` 进行剪枝，详见 ``Executor`` 的文档。
+ tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到  ``Executor.run()``  接口的  ``fetch_list``  参数中，若加入，则会重写  ``use_prune``  参数为 True，并根据  ``feed``  和  ``fetch_list``  进行剪枝，详见  ``Executor``  的文档。
 
 **代码示例**
 
@@ -104,7 +104,7 @@ set_lr(value)
 .. note::
     该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-手动设置当前 ``optimizer`` 的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
+手动设置当前  ``optimizer``  的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
 
 **参数**
 
@@ -124,7 +124,7 @@ set_lr_scheduler(scheduler)
 .. note::
     该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-手动设置当前 ``optimizer`` 的学习率为 LRScheduler 类。
+手动设置当前  ``optimizer``  的学习率为 LRScheduler 类。
 
 **参数**
 
diff --git a/docs/api/paddle/optimizer/Momentum_cn.rst b/docs/api/paddle/optimizer/Momentum_cn.rst
index 85dc9598a85..408549fa1b4 100644
--- a/docs/api/paddle/optimizer/Momentum_cn.rst
+++ b/docs/api/paddle/optimizer/Momentum_cn.rst
@@ -73,7 +73,7 @@ minimize(loss, startup_program=None, parameters=None, no_grad_set=None)
 
 **返回**
 
- tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到 ``Executor.run()`` 接口的 ``fetch_list`` 参数中，若加入，则会重写 ``use_prune`` 参数为 True，并根据 ``feed`` 和 ``fetch_list`` 进行剪枝，详见 ``Executor`` 的文档。
+ tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到  ``Executor.run()``  接口的  ``fetch_list``  参数中，若加入，则会重写  ``use_prune``  参数为 True，并根据  ``feed``  和  ``fetch_list``  进行剪枝，详见  ``Executor``  的文档。
 
 
 **代码示例**
diff --git a/docs/api/paddle/optimizer/NAdam_cn.rst b/docs/api/paddle/optimizer/NAdam_cn.rst
index 12adfe0dfb3..76c800c7ce5 100644
--- a/docs/api/paddle/optimizer/NAdam_cn.rst
+++ b/docs/api/paddle/optimizer/NAdam_cn.rst
@@ -42,7 +42,7 @@ NAdam
 
 .. note::
 
-    目前 ``NAdam`` 不支持 Sparse Parameter Optimization（稀疏参数优化）。
+    目前  ``NAdam``  不支持 Sparse Parameter Optimization（稀疏参数优化）。
 
 代码示例
 ::::::::::::
@@ -84,7 +84,7 @@ minimize(loss, startup_program=None, parameters=None, no_grad_set=None)
 
 **返回**
 
- tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到 ``Executor.run()`` 接口的 ``fetch_list`` 参数中，若加入，则会重写 ``use_prune`` 参数为 True，并根据 ``feed`` 和 ``fetch_list`` 进行剪枝，详见 ``Executor`` 的文档。
+ tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到  ``Executor.run()``  接口的  ``fetch_list``  参数中，若加入，则会重写  ``use_prune``  参数为 True，并根据  ``feed``  和  ``fetch_list``  进行剪枝，详见  ``Executor``  的文档。
 
 **代码示例**
 
@@ -112,7 +112,7 @@ set_lr(value)
 
     该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-    手动设置当前 ``optimizer`` 的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
+    手动设置当前  ``optimizer``  的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
 
 **参数**
 
@@ -133,7 +133,7 @@ set_lr_scheduler(scheduler)
 
     该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-    手动设置当前 ``optimizer`` 的学习率为 LRScheduler 类。
+    手动设置当前  ``optimizer``  的学习率为 LRScheduler 类。
 
 **参数**
 
diff --git a/docs/api/paddle/optimizer/Optimizer_cn.rst b/docs/api/paddle/optimizer/Optimizer_cn.rst
index 9580ca0f8f3..90e6f5376e0 100755
--- a/docs/api/paddle/optimizer/Optimizer_cn.rst
+++ b/docs/api/paddle/optimizer/Optimizer_cn.rst
@@ -61,7 +61,7 @@ minimize(loss, startup_program=None, parameters=None, no_grad_set=None)
 
 **返回**
 
- tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到 ``Executor.run()`` 接口的 ``fetch_list`` 参数中，若加入，则会重写 ``use_prune`` 参数为 True，并根据 ``feed`` 和 ``fetch_list`` 进行剪枝，详见 ``Executor`` 的文档。
+ tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到  ``Executor.run()``  接口的  ``fetch_list``  参数中，若加入，则会重写  ``use_prune``  参数为 True，并根据  ``feed``  和  ``fetch_list``  进行剪枝，详见  ``Executor``  的文档。
 
 
 **代码示例**
@@ -89,7 +89,7 @@ set_lr(value)
 
     该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-    手动设置当前 ``optimizer`` 的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
+    手动设置当前  ``optimizer``  的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
 
 **参数**
 
@@ -110,7 +110,7 @@ set_lr_scheduler(scheduler)
 
     该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-    手动设置当前 ``optimizer`` 的学习率为 LRScheduler 类。
+    手动设置当前  ``optimizer``  的学习率为 LRScheduler 类。
 
 **参数**
 
diff --git a/docs/api/paddle/optimizer/RAdam_cn.rst b/docs/api/paddle/optimizer/RAdam_cn.rst
index 4868908f309..df7576ca3eb 100644
--- a/docs/api/paddle/optimizer/RAdam_cn.rst
+++ b/docs/api/paddle/optimizer/RAdam_cn.rst
@@ -45,7 +45,7 @@ RAdam
 
 .. note::
 
-    目前 ``RAdam`` 不支持 Sparse Parameter Optimization（稀疏参数优化）。
+    目前  ``RAdam``  不支持 Sparse Parameter Optimization（稀疏参数优化）。
 
 代码示例
 ::::::::::::
@@ -87,7 +87,7 @@ minimize(loss, startup_program=None, parameters=None, no_grad_set=None)
 
 **返回**
 
- tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到 ``Executor.run()`` 接口的 ``fetch_list`` 参数中，若加入，则会重写 ``use_prune`` 参数为 True，并根据 ``feed`` 和 ``fetch_list`` 进行剪枝，详见 ``Executor`` 的文档。
+ tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到  ``Executor.run()``  接口的  ``fetch_list``  参数中，若加入，则会重写  ``use_prune``  参数为 True，并根据  ``feed``  和  ``fetch_list``  进行剪枝，详见  ``Executor``  的文档。
 
 **代码示例**
 
@@ -115,7 +115,7 @@ set_lr(value)
 
     该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-    手动设置当前 ``optimizer`` 的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
+    手动设置当前  ``optimizer``  的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
 
 **参数**
 
@@ -136,7 +136,7 @@ set_lr_scheduler(scheduler)
 
     该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-    手动设置当前 ``optimizer`` 的学习率为 LRScheduler 类。
+    手动设置当前  ``optimizer``  的学习率为 LRScheduler 类。
 
 **参数**
 
diff --git a/docs/api/paddle/optimizer/RMSProp_cn.rst b/docs/api/paddle/optimizer/RMSProp_cn.rst
index 17f3e407c35..c1b59bcbcf5 100755
--- a/docs/api/paddle/optimizer/RMSProp_cn.rst
+++ b/docs/api/paddle/optimizer/RMSProp_cn.rst
@@ -84,7 +84,7 @@ minimize(loss, startup_program=None, parameters=None, no_grad_set=None)
 
 **返回**
 
- tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到 ``Executor.run()`` 接口的 ``fetch_list`` 参数中，若加入，则会重写 ``use_prune`` 参数为 True，并根据 ``feed`` 和 ``fetch_list`` 进行剪枝，详见 ``Executor`` 的文档。
+ tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到  ``Executor.run()``  接口的  ``fetch_list``  参数中，若加入，则会重写  ``use_prune``  参数为 True，并根据  ``feed``  和  ``fetch_list``  进行剪枝，详见  ``Executor``  的文档。
 
 
 **代码示例**
@@ -112,7 +112,7 @@ set_lr(value)
 
     该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-    手动设置当前 ``optimizer`` 的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
+    手动设置当前  ``optimizer``  的学习率。当使用_LRScheduler 时，无法使用该 API 手动设置学习率，因为这将导致冲突。
 
 **参数**
 
@@ -133,7 +133,7 @@ set_lr_scheduler(scheduler)
 
     该 API 只在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下生效。
 
-    手动设置当前 ``optimizer`` 的学习率为 LRScheduler 类。
+    手动设置当前  ``optimizer``  的学习率为 LRScheduler 类。
 
 **参数**
 
diff --git a/docs/api/paddle/optimizer/Rprop_cn.rst b/docs/api/paddle/optimizer/Rprop_cn.rst
index 75981acfbd4..95392779dd0 100644
--- a/docs/api/paddle/optimizer/Rprop_cn.rst
+++ b/docs/api/paddle/optimizer/Rprop_cn.rst
@@ -87,7 +87,7 @@ minimize(loss, startup_program=None, parameters=None, no_grad_set=None)
 
 **返回**
 
- tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到 ``Executor.run()`` 接口的 ``fetch_list`` 参数中，若加入，则会重写 ``use_prune`` 参数为 True，并根据 ``feed`` 和 ``fetch_list`` 进行剪枝，详见 ``Executor`` 的文档。
+ tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到  ``Executor.run()``  接口的  ``fetch_list``  参数中，若加入，则会重写  ``use_prune``  参数为 True，并根据  ``feed``  和  ``fetch_list``  进行剪枝，详见  ``Executor``  的文档。
 
 
 **代码示例**
diff --git a/docs/api/paddle/optimizer/SGD_cn.rst b/docs/api/paddle/optimizer/SGD_cn.rst
index 5a9ffa6565c..ff315461373 100644
--- a/docs/api/paddle/optimizer/SGD_cn.rst
+++ b/docs/api/paddle/optimizer/SGD_cn.rst
@@ -63,7 +63,7 @@ minimize(loss, startup_program=None, parameters=None, no_grad_set=None)
 
 **返回**
 
- tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到 ``Executor.run()`` 接口的 ``fetch_list`` 参数中，若加入，则会重写 ``use_prune`` 参数为 True，并根据 ``feed`` 和 ``fetch_list`` 进行剪枝，详见 ``Executor`` 的文档。
+ tuple(optimize_ops, params_grads)，其中 optimize_ops 为参数优化 OP 列表；param_grads 为由(param, param_grad)组成的列表，其中 param 和 param_grad 分别为参数和参数的梯度。在静态图模式下，该返回值可以加入到  ``Executor.run()``  接口的  ``fetch_list``  参数中，若加入，则会重写  ``use_prune``  参数为 True，并根据  ``feed``  和  ``fetch_list``  进行剪枝，详见  ``Executor``  的文档。
 
 
 **代码示例**
diff --git a/docs/api/paddle/optimizer/lr/CosineAnnealingDecay_cn.rst b/docs/api/paddle/optimizer/lr/CosineAnnealingDecay_cn.rst
index 6e13b8542c2..b1db74efa6f 100644
--- a/docs/api/paddle/optimizer/lr/CosineAnnealingDecay_cn.rst
+++ b/docs/api/paddle/optimizer/lr/CosineAnnealingDecay_cn.rst
@@ -5,7 +5,7 @@ CosineAnnealingDecay
 
 .. py:class:: paddle.optimizer.lr.CosineAnnealingDecay(learning_rate, T_max, eta_min=0, last_epoch=-1, verbose=False)
 
-该接口使用 ``cosine annealing`` 的策略来动态调整学习率。
+该接口使用  ``cosine annealing``  的策略来动态调整学习率。
 
 .. math::
         \begin{aligned}
@@ -18,8 +18,8 @@ CosineAnnealingDecay
         \end{aligned}
 
 
-:math:`\eta_{max}` 的初始值为 ``learning_rate``， :math:`T_{cur}` 是 SGDR（重启训练 SGD）训练过程中的当前训练轮数。SGDR 的训练方法可以参考论文，
-这里只是实现了 ``cosine annealing`` 动态学习率，热启训练部分没有实现。
+:math:`\eta_{max}` 的初始值为  ``learning_rate`` ， :math:`T_{cur}` 是 SGDR（重启训练 SGD）训练过程中的当前训练轮数。SGDR 的训练方法可以参考论文，
+这里只是实现了  ``cosine annealing``  动态学习率，热启训练部分没有实现。
 
 相关论文：`SGDR: Stochastic Gradient Descent with Warm Restarts <https://arxiv.org/abs/1608.03983>`_
 
@@ -30,11 +30,11 @@ CosineAnnealingDecay
     - **T_max** (float|int) - 训练的上限轮数，是余弦衰减周期的一半。必须是一个正整数。
     - **eta_min** (float|int，可选) - 学习率的最小值，即公式中的 :math:`\eta_{min}`。默认值为 0。
     - **last_epoch** (int，可选) - 上一轮的轮数，重启训练时设置为上一轮的 epoch 数。默认值为 -1，则为初始学习率。
-    - **verbose** (bool，可选) - 如果是 ``True``，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** (bool，可选) - 如果是  ``True`` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 返回
 ::::::::::::
-用于调整学习率的 ``CosineAnnealingDecay`` 实例对象。
+用于调整学习率的  ``CosineAnnealingDecay``  实例对象。
 
 代码示例
 ::::::::::::
@@ -50,7 +50,7 @@ step 函数需要在优化器的 `optimizer.step()` 函数之后调用，调用
 
 **参数**
 
-  - **epoch** （int，可选）- 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+  - **epoch** （int，可选）- 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
diff --git a/docs/api/paddle/optimizer/lr/CosineAnnealingWarmRestarts_cn.rst b/docs/api/paddle/optimizer/lr/CosineAnnealingWarmRestarts_cn.rst
index d75be03d7b8..b791f7eccc4 100644
--- a/docs/api/paddle/optimizer/lr/CosineAnnealingWarmRestarts_cn.rst
+++ b/docs/api/paddle/optimizer/lr/CosineAnnealingWarmRestarts_cn.rst
@@ -5,13 +5,13 @@ CosineAnnealingWarmRestarts
 
 .. py:class:: paddle.optimizer.lr.CosineAnnealingWarmRestarts(learning_rate, T_0, T_mult=1, eta_min=0, last_epoch=-1, verbose=False)
 
-该接口使用 ``cosine annealing`` 的策略来动态调整学习率。
+该接口使用  ``cosine annealing``  的策略来动态调整学习率。
 
 .. math::
         \eta_t = \eta_{min} + \frac{1}{2}(\eta_{max} - \eta_{min})\left(1 +
         \cos\left(\frac{T_{cur}}{T_{i}}\pi\right)\right)
 
-:math:`\eta_{max}` 的初始值为 ``learning_rate``， :math:`T_{cur}` 是 SGDR（重启训练 SGD）训练过程中的当前训练轮数。:math:`T_{i}` 是 SGDR 两次重启训练之间 epoch 的数量
+:math:`\eta_{max}` 的初始值为  ``learning_rate`` ， :math:`T_{cur}` 是 SGDR（重启训练 SGD）训练过程中的当前训练轮数。:math:`T_{i}` 是 SGDR 两次重启训练之间 epoch 的数量
 
 当 :math:`T_{cur}=T_{i}` ，设 :math:`\eta_t = \eta_{min}` 。当重启后 :math:`T_{cur}=0` ，设 :math:`\eta_t=\eta_{max}` 。
 
@@ -25,11 +25,11 @@ SGDR 的训练方法可以参考论文，相关论文：`SGDR: Stochastic Gradie
     - **T_mult** (int，可选) - 重启之后 :math:`T_{i}` 乘积增长因子。默认值 1。
     - **eta_min** (float，可选) - 最小学习率。默认值 0.
     - **last_epoch** (int，可选) - 上一轮的轮数，重启训练时设置为上一轮的 epoch 数。默认值为 -1，则为初始学习率。
-    - **verbose** (bool，可选) - 如果是 ``True``，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** (bool，可选) - 如果是  ``True`` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 返回
 ::::::::::::
-用于调整学习率的 ``CosineAnnealingWarmRestarts`` 实例对象。
+用于调整学习率的  ``CosineAnnealingWarmRestarts``  实例对象。
 
 代码示例
 ::::::::::::
@@ -46,7 +46,7 @@ step 函数需要在优化器的 `optimizer.step()` 函数之后调用，调用
 
 **参数**
 
-  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
diff --git a/docs/api/paddle/optimizer/lr/CyclicLR_cn.rst b/docs/api/paddle/optimizer/lr/CyclicLR_cn.rst
index ba3c1daa086..bebc4e9769a 100644
--- a/docs/api/paddle/optimizer/lr/CyclicLR_cn.rst
+++ b/docs/api/paddle/optimizer/lr/CyclicLR_cn.rst
@@ -13,25 +13,25 @@ CyclicLR
 
 内置了三种学习率缩放策略：**triangular**：没有任何缩放的三角循环。**triangular2**：每个三角循环里将初始幅度缩放一半。**exp_range**：每个循环中将初始幅度按照指数函数进行缩放，公式为 :math:`gamma^{iterations}`。
 
-初始幅度由 `max_learning_rate - base_learning_rate` 定义。同时需要注意 CyclicLR 应在每次迭代后调用 ``step`` 方法。
+初始幅度由 `max_learning_rate - base_learning_rate` 定义。同时需要注意 CyclicLR 应在每次迭代后调用  ``step``  方法。
 
 参数
 ::::::::::::
 
     - **base_learning_rate** (float) - 初始学习率，也是学习率变化的下边界。论文中建议将其设置为最大学习率的三分之一或四分之一。
-    - **max_learning_rate** (float) - 最大学习率，需要注意的是，实际的学习率由 ``base_learning_rate`` 与初始幅度的缩放求和而来，因此实际学习率可能达不到 ``max_learning_rate`` 。
-    - **step_size_up** (int) - 学习率从初始学习率增长到最大学习率所需步数。每个循环总的步长 ``step_size`` 由 ``step_size_up + step_size_down`` 定义，论文中建议将 ``step_size`` 设置为单个 epoch 中步长的 3 或 4 倍。
-    - **step_size_down** (int，可选) - 学习率从最大学习率下降到初始学习率所需步数。若未指定，则其值默认等于 ``step_size_up`` 。
+    - **max_learning_rate** (float) - 最大学习率，需要注意的是，实际的学习率由  ``base_learning_rate``  与初始幅度的缩放求和而来，因此实际学习率可能达不到  ``max_learning_rate``  。
+    - **step_size_up** (int) - 学习率从初始学习率增长到最大学习率所需步数。每个循环总的步长  ``step_size``  由  ``step_size_up + step_size_down``  定义，论文中建议将  ``step_size``  设置为单个 epoch 中步长的 3 或 4 倍。
+    - **step_size_down** (int，可选) - 学习率从最大学习率下降到初始学习率所需步数。若未指定，则其值默认等于  ``step_size_up``  。
     - **mode** (str，可选) - 可以是 triangular、triangular2 或者 exp_range，对应策略已在上文描述，当 scale_fn 被指定时时，该参数将被忽略。默认值为 triangular。
     - **exp_gamma** (float，可选) - exp_range 缩放函数中的常量。默认值为 1.0。
-    - **sacle_fn** (function，可选) - 一个有且仅有单个参数的函数，且对于任意的输入 x，都必须满足 0 ≤ scale_fn(x) ≤ 1；如果该参数被指定，则会忽略 mode 参数。默认值为 ``False`` 。
+    - **sacle_fn** (function，可选) - 一个有且仅有单个参数的函数，且对于任意的输入 x，都必须满足 0 ≤ scale_fn(x) ≤ 1；如果该参数被指定，则会忽略 mode 参数。默认值为  ``False``  。
     - **scale_mode** (str，可选) - cycle 或者 iterations，表示缩放函数使用 cycle 数或 iterations 数作为输入。默认值为 cycle。
     - **last_epoch** (int，可选) - 上一轮的轮数，重启训练时设置为上一轮的 epoch 数。默认值为 -1，则为初始学习率。
-    - **verbose** (bool，可选) - 如果是 ``True``，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** (bool，可选) - 如果是  ``True`` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 返回
 ::::::::::::
-用于调整学习率的 ``CyclicLR`` 实例对象。
+用于调整学习率的  ``CyclicLR``  实例对象。
 
 代码示例
 ::::::::::::
@@ -47,7 +47,7 @@ step 函数需要在优化器的 `optimizer.step()` 函数之后调用，调用
 
 **参数**
 
-  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
diff --git a/docs/api/paddle/optimizer/lr/ExponentialDecay_cn.rst b/docs/api/paddle/optimizer/lr/ExponentialDecay_cn.rst
index cc28203da7a..0ef7ca1d9d1 100644
--- a/docs/api/paddle/optimizer/lr/ExponentialDecay_cn.rst
+++ b/docs/api/paddle/optimizer/lr/ExponentialDecay_cn.rst
@@ -17,13 +17,13 @@ ExponentialDecay
 ::::::::::::
 
     - **learning_rate** (float) - 初始学习率，数据类型为 Python float。
-    - **gamma** (float) - 衰减率，``new_lr = origin_lr * gamma`` 。gamma 应该在区间 (0.0, 1.0) 内。
+    - **gamma** (float) - 衰减率， ``new_lr = origin_lr * gamma``  。gamma 应该在区间 (0.0, 1.0) 内。
     - **last_epoch** (int，可选) - 上一轮的轮数，重启训练时设置为上一轮的 epoch 数。默认值为 -1，则为初始学习率。
-    - **verbose** (bool，可选) - 如果是 ``True``，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** (bool，可选) - 如果是  ``True`` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 返回
 ::::::::::::
-用于调整学习率的 ``ExponentialDecay`` 实例对象。
+用于调整学习率的  ``ExponentialDecay``  实例对象。
 
 代码示例
 ::::::::::::
@@ -39,7 +39,7 @@ step 函数需要在优化器的 `optimizer.step()` 函数之后调用，调用
 
 **参数**
 
-  - **epoch** (int，可选）- 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+  - **epoch** (int，可选）- 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
diff --git a/docs/api/paddle/optimizer/lr/InverseTimeDecay_cn.rst b/docs/api/paddle/optimizer/lr/InverseTimeDecay_cn.rst
index ebe9f53a9df..182e7b9d941 100644
--- a/docs/api/paddle/optimizer/lr/InverseTimeDecay_cn.rst
+++ b/docs/api/paddle/optimizer/lr/InverseTimeDecay_cn.rst
@@ -19,13 +19,13 @@ InverseTimeDecay
 ::::::::::::
 
     - **learning_rate** (float) - 初始学习率，数据类型为 Python float。
-    - **gamma** (float) - 衰减率，``new_lr = origin_lr * gamma`` 。
+    - **gamma** (float) - 衰减率， ``new_lr = origin_lr * gamma``  。
     - **last_epoch** (int，可选) - 上一轮的轮数，重启训练时设置为上一轮的 epoch 数。默认值为 -1，则为初始学习率。
-    - **verbose** (bool，可选) - 如果是 ``True``，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** (bool，可选) - 如果是  ``True`` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 返回
 ::::::::::::
-用于调整学习率的 ``InverseTimeDecay`` 实例对象。
+用于调整学习率的  ``InverseTimeDecay``  实例对象。
 
 代码示例
 ::::::::::::
@@ -41,7 +41,7 @@ step 函数需要在优化器的 `optimizer.step()` 函数之后调用，调用
 
 **参数**
 
-  - **epoch** （int，可选）- 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+  - **epoch** （int，可选）- 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
diff --git a/docs/api/paddle/optimizer/lr/LRScheduler_cn.rst b/docs/api/paddle/optimizer/lr/LRScheduler_cn.rst
index 2325f74fa25..6e800182db7 100644
--- a/docs/api/paddle/optimizer/lr/LRScheduler_cn.rst
+++ b/docs/api/paddle/optimizer/lr/LRScheduler_cn.rst
@@ -43,15 +43,15 @@ LRScheduler
 
 * :code:`CosineAnnealingWarmRestarts`: 余弦退火学习率，即学习率随 step 数变化呈余弦函数周期变化。 请参考 :ref:`cn_api_paddle_optimizer_lr_CosineAnnealingWarmRestarts`。
 
-你可以继承该基类实现任意的学习率策略，导出基类的方法为 ``from paddle.optimizer.lr import LRScheduler`` ，
-必须要重写该基类的 ``get_lr()`` 函数，否则会抛出 ``NotImplementedError`` 异常。
+你可以继承该基类实现任意的学习率策略，导出基类的方法为  ``from paddle.optimizer.lr import LRScheduler``  ，
+必须要重写该基类的  ``get_lr()``  函数，否则会抛出  ``NotImplementedError``  异常。
 
 参数
 ::::::::::::
 
     - **learning_rate** (float，可选) - 初始学习率，数据类型为 Python float。
     - **last_epoch** (int，可选) - 上一轮的轮数，重启训练时设置为上一轮的 epoch 数。默认值为 -1，则为初始学习率。
-    - **verbose** (bool，可选) - 如果是 ``True``，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** (bool，可选) - 如果是  ``True`` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 返回
 ::::::::::::
@@ -71,7 +71,7 @@ step 函数需要在优化器的 `optimizer.step()` 函数之后调用，调用
 
 **参数**
 
-    - **epoch** （int，可选）- 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+    - **epoch** （int，可选）- 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
@@ -84,22 +84,22 @@ COPY-FROM: paddle.optimizer.lr.LRScheduler.step
 get_lr()
 '''''''''
 
-如果一个子类继承了 ``基类 LRScheduler``，则用户必须重写方法 ``get_lr()``，否则，将会抛出 ``NotImplementedError`` 异常，
+如果一个子类继承了  ``基类 LRScheduler`` ，则用户必须重写方法  ``get_lr()`` ，否则，将会抛出  ``NotImplementedError``  异常，
 
-上述给出了实现 ``StepLR`` 的一个简单示例。
+上述给出了实现  ``StepLR``  的一个简单示例。
 
 state_keys()
 '''''''''
 
-该函数通过定义字典 ``self.keys`` 来设置 ``optimizer.state_dict()`` 时的存储对象，默认情况下：``self.keys=['last_epoch', 'last_lr']``，其中 ``last_epoch``
-是当前的 epoch 数，``last_lr`` 是当前的学习率值。
+该函数通过定义字典  ``self.keys``  来设置  ``optimizer.state_dict()``  时的存储对象，默认情况下： ``self.keys=['last_epoch', 'last_lr']`` ，其中  ``last_epoch`` 
+是当前的 epoch 数， ``last_lr``  是当前的学习率值。
 
-如果需要改变默认的行为，用户需要重写该方法，来重新定义字典 ``self.keys``，一般无需重新设置。
+如果需要改变默认的行为，用户需要重写该方法，来重新定义字典  ``self.keys`` ，一般无需重新设置。
 
 state_dict()
 '''''''''
 
-以 ``dict`` 形式返回调度器的状态。
+以  ``dict``  形式返回调度器的状态。
 
 set_state_dict(state_dict)
 '''''''''
diff --git a/docs/api/paddle/optimizer/lr/LambdaDecay_cn.rst b/docs/api/paddle/optimizer/lr/LambdaDecay_cn.rst
index 722a7c28fc1..77c266475e5 100644
--- a/docs/api/paddle/optimizer/lr/LambdaDecay_cn.rst
+++ b/docs/api/paddle/optimizer/lr/LambdaDecay_cn.rst
@@ -5,7 +5,7 @@ LambdaDecay
 
 .. py:class:: paddle.optimizer.lr.LambdaDecay(learning_rate, lr_lambda, last_epoch=-1, verbose=False)
 
-该接口提供 ``lambda`` 函数设置学习率的策略。``lr_lambda`` 为一个 ``lambda`` 函数，其通过 ``epoch`` 计算出一个因子，该因子会乘以初始学习率。。
+该接口提供  ``lambda``  函数设置学习率的策略。 ``lr_lambda``  为一个  ``lambda``  函数，其通过  ``epoch``  计算出一个因子，该因子会乘以初始学习率。。
 
 衰减过程可以参考以下代码：
 
@@ -26,11 +26,11 @@ LambdaDecay
     - **learning_rate** （float） - 初始学习率，数据类型为 Python float。
     - **lr_lambda** （function）：lr_lambda 为一个 lambda 函数，其通过 epoch 计算出一个因子，该因子会乘以初始学习率。
     - **last_epoch** （int，可选）：上一轮的轮数，重启训练时设置为上一轮的 epoch 数。默认值为 -1，则为初始学习率。
-    - **verbose** （bool，可选）：如果是 ``True``，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** （bool，可选）：如果是  ``True`` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 返回
 ::::::::::::
-用于调整学习率的 ``LambdaDecay`` 实例对象。
+用于调整学习率的  ``LambdaDecay``  实例对象。
 
 代码示例
 ::::::::::::
@@ -46,7 +46,7 @@ step 函数需要在优化器的 `optimizer.step()` 函数之后调用，调用
 
 **参数**
 
-  - **epoch** （int，可选）- 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+  - **epoch** （int，可选）- 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
diff --git a/docs/api/paddle/optimizer/lr/LinearLR_cn.rst b/docs/api/paddle/optimizer/lr/LinearLR_cn.rst
index 7953d27d24d..3abeba7f666 100644
--- a/docs/api/paddle/optimizer/lr/LinearLR_cn.rst
+++ b/docs/api/paddle/optimizer/lr/LinearLR_cn.rst
@@ -17,11 +17,11 @@ LinearLR
     - **start_factor** (float) - 初始学习率因子，通过 `learning_rate * start_factor` 确定。
     - **end_factor** (float) - 最终学习率因子，通过 `learning_rate * end_factor` 确定。
     - **last_epoch** (int，可选) - 上一轮的轮数，重启训练时设置为上一轮的 epoch 数。默认值为 -1，则为初始学习率。
-    - **verbose** (bool，可选) - 如果是 ``True``，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** (bool，可选) - 如果是  ``True`` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 返回
 ::::::::::::
-用于调整学习率的 ``LinearLR`` 实例对象。
+用于调整学习率的  ``LinearLR``  实例对象。
 
 代码示例
 ::::::::::::
@@ -38,7 +38,7 @@ step 函数需要在优化器的 `optimizer.step()` 函数之后调用，调用
 
 **参数**
 
-  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
diff --git a/docs/api/paddle/optimizer/lr/LinearWarmup_cn.rst b/docs/api/paddle/optimizer/lr/LinearWarmup_cn.rst
index ecfd7f0d1b5..4b6a2f3280f 100644
--- a/docs/api/paddle/optimizer/lr/LinearWarmup_cn.rst
+++ b/docs/api/paddle/optimizer/lr/LinearWarmup_cn.rst
@@ -20,22 +20,22 @@ LinearWarmup
 
     lr = learning\_rate
 
-其中 learning_rate 为热身之后的学习率，可以是 python 的 float 类型或者 ``_LRScheduler`` 的任意子类。
+其中 learning_rate 为热身之后的学习率，可以是 python 的 float 类型或者  ``_LRScheduler``  的任意子类。
 
 参数
 ::::::::::::
 
-    - **learning rate** (float|_LRScheduler) - 热启训练之后的学习率，可以是 python 的 float 类型或者 ``_LRScheduler`` 的任意子类。
+    - **learning rate** (float|_LRScheduler) - 热启训练之后的学习率，可以是 python 的 float 类型或者  ``_LRScheduler``  的任意子类。
     - **warmup_steps** (int) - 进行 warm up 过程的步数。
     - **start_lr** (float) - warm up 的起始学习率。
     - **end_lr** (float) - warm up 的最终学习率。
     - **last_epoch** (int，可选) - 上一轮的轮数，重启训练时设置为上一轮的 epoch 数。默认值为 -1，则为初始学习率。
-    - **verbose** (bool，可选) - 如果是 ``True``，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** (bool，可选) - 如果是  ``True`` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 
 返回
 ::::::::::::
-用于调整学习率的 ``LinearWarmup`` 实例对象。
+用于调整学习率的  ``LinearWarmup``  实例对象。
 
 代码示例
 ::::::::::::
@@ -51,7 +51,7 @@ step 函数需要在优化器的 `optimizer.step()` 函数之后调用，调用
 
 **参数**
 
-  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
diff --git a/docs/api/paddle/optimizer/lr/MultiStepDecay_cn.rst b/docs/api/paddle/optimizer/lr/MultiStepDecay_cn.rst
index b5d40e896cb..d850b583a56 100644
--- a/docs/api/paddle/optimizer/lr/MultiStepDecay_cn.rst
+++ b/docs/api/paddle/optimizer/lr/MultiStepDecay_cn.rst
@@ -25,14 +25,14 @@ MultiStepDecay
 
     - **learning_rate** (float) - 初始学习率，数据类型为 Python float。
     - **milestones** (list) - 轮数下标列表。必须递增。
-    - **gamma** (float，可选) - 衰减率，``new_lr = origin_lr * gamma``，衰减率必须小于等于 1.0，默认值为 0.1。
+    - **gamma** (float，可选) - 衰减率， ``new_lr = origin_lr * gamma`` ，衰减率必须小于等于 1.0，默认值为 0.1。
     - **last_epoch** (int，可选) - 上一轮的轮数，重启训练时设置为上一轮的 epoch 数。默认值为 -1，则为初始学习率。
-    - **verbose** (bool，可选) - 如果是 ``True``，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** (bool，可选) - 如果是  ``True`` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 
 返回
 ::::::::::::
-用于调整学习率的 ``MultiStepDecay`` 实例对象。
+用于调整学习率的  ``MultiStepDecay``  实例对象。
 
 代码示例
 ::::::::::::
@@ -48,7 +48,7 @@ step 函数需要在优化器的 `optimizer.step()` 函数之后调用，调用
 
 **参数**
 
-  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
diff --git a/docs/api/paddle/optimizer/lr/MultiplicativeDecay_cn.rst b/docs/api/paddle/optimizer/lr/MultiplicativeDecay_cn.rst
index 4f11fe72d4b..cee62040314 100644
--- a/docs/api/paddle/optimizer/lr/MultiplicativeDecay_cn.rst
+++ b/docs/api/paddle/optimizer/lr/MultiplicativeDecay_cn.rst
@@ -5,7 +5,7 @@ MultiplicativeDecay
 
 .. py:class:: paddle.optimizer.lr.MultiplicativeDecay(learning_rate, lr_lambda, last_epoch=-1, verbose=False)
 
-该接口提供 ``lambda`` 函数设置学习率的策略。``lr_lambda`` 为一个 ``lambda`` 函数，其通过 ``epoch`` 计算出一个因子，该因子会乘以当前学习率。
+该接口提供  ``lambda``  函数设置学习率的策略。 ``lr_lambda``  为一个  ``lambda``  函数，其通过  ``epoch``  计算出一个因子，该因子会乘以当前学习率。
 
 衰减过程可以参考以下代码：
 
@@ -26,11 +26,11 @@ MultiplicativeDecay
     - **learning_rate** （float） - 初始学习率，数据类型为 Python float。
     - **lr_lambda** （function）- lr_lambda 为一个 lambda 函数，其通过 epoch 计算出一个因子，该因子会乘以当前学习率。
     - **last_epoch** （int，可选）- 上一轮的轮数，重启训练时设置为上一轮的 epoch 数。默认值为 -1，则为初始学习率。
-    - **verbose** （bool，可选）- 如果是 ``True``，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** （bool，可选）- 如果是  ``True`` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 返回
 ::::::::::::
-用于调整学习率的 ``MultiplicativeDecay`` 实例对象。
+用于调整学习率的  ``MultiplicativeDecay``  实例对象。
 
 代码示例
 ::::::::::::
@@ -46,7 +46,7 @@ step 函数需要在优化器的 `optimizer.step()` 函数之后调用，调用
 
 **参数**
 
-  - **epoch** （int，可选）- 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+  - **epoch** （int，可选）- 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
diff --git a/docs/api/paddle/optimizer/lr/NaturalExpDecay_cn.rst b/docs/api/paddle/optimizer/lr/NaturalExpDecay_cn.rst
index 5213933030d..7343dbb4a9e 100644
--- a/docs/api/paddle/optimizer/lr/NaturalExpDecay_cn.rst
+++ b/docs/api/paddle/optimizer/lr/NaturalExpDecay_cn.rst
@@ -19,11 +19,11 @@ NaturalExpDecay
     - **learning_rate** (float) - 初始学习率，数据类型为 Python float。
     - **gamma** (float) - 衰减率，gamma 应该大于 0.0，才能使学习率衰减。默认值为 0.1。
     - **last_epoch** (int，可选) - 上一轮的轮数，重启训练时设置为上一轮的 epoch 数。默认值为 -1，则为初始学习率。
-    - **verbose** (bool，可选) - 如果是 ``True``，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** (bool，可选) - 如果是  ``True`` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 返回
 ::::::::::::
-用于调整学习率的 ``NaturalExpDecay`` 实例对象。
+用于调整学习率的  ``NaturalExpDecay``  实例对象。
 
 代码示例
 ::::::::::::
@@ -39,7 +39,7 @@ step 函数需要在优化器的 `optimizer.step()` 函数之后调用，调用
 
 **参数**
 
-  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
diff --git a/docs/api/paddle/optimizer/lr/NoamDecay_cn.rst b/docs/api/paddle/optimizer/lr/NoamDecay_cn.rst
index d5889874af0..fc7f12d0e7a 100644
--- a/docs/api/paddle/optimizer/lr/NoamDecay_cn.rst
+++ b/docs/api/paddle/optimizer/lr/NoamDecay_cn.rst
@@ -23,11 +23,11 @@ Noam 衰减的计算方式如下：
     - **warmup_steps** (int) - 预热步数，为超参数。数据类型为 Python int。
     - **learning_rate** (float) - 初始学习率，数据类型为 Python float。默认值为 1.0。
     - **last_epoch** (int，可选) - 上一轮的轮数，重启训练时设置为上一轮的 epoch 数。默认值为 -1，则为初始学习率。
-    - **verbose** (bool，可选) - 如果是 `True`，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** (bool，可选) - 如果是 `True`，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 返回
 ::::::::::::
-用于调整学习率的 ``NoamDecay`` 实例对象。
+用于调整学习率的  ``NoamDecay``  实例对象。
 
 代码示例
 ::::::::::::
@@ -43,7 +43,7 @@ step 函数需要在优化器的 `optimizer.step()` 函数之后调用，调用
 
 **参数**
 
-  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
diff --git a/docs/api/paddle/optimizer/lr/OneCycleLR_cn.rst b/docs/api/paddle/optimizer/lr/OneCycleLR_cn.rst
index 0b1a2aad343..17dddad68bf 100644
--- a/docs/api/paddle/optimizer/lr/OneCycleLR_cn.rst
+++ b/docs/api/paddle/optimizer/lr/OneCycleLR_cn.rst
@@ -5,32 +5,32 @@ OneCycleLR
 
 .. py:class:: paddle.optimizer.lr.OneCycleLR(max_learning_rate, total_steps, divide_factor=25., end_learning_rate=0.0001, phase_pct=0.3, anneal_strategy='cos', three_phase=False, last_epoch=-1, verbose=False)
 
-使用 ``one cycle`` 策略来动态调整学习率。
+使用  ``one cycle``  策略来动态调整学习率。
 
 该策略将学习率从初始学习率调整到最大学习率，再从最大学习率调整到远小于初始学习率的最小学习率。
 
 相关论文：`Super-Convergence: Very Fast Training of Neural Networks Using Large Learning Rates <https://arxiv.org/abs/1708.07120>`_
 
-注意，本调度器默认行为参考 fastai 仓库，其声称二阶段拥有比三阶段更好的效果。设置 ``three_phase=True`` 可以与论文中所描述的行为保持一致。
+注意，本调度器默认行为参考 fastai 仓库，其声称二阶段拥有比三阶段更好的效果。设置  ``three_phase=True``  可以与论文中所描述的行为保持一致。
 
-同时也请注意本调度器需要在每次迭代后调用 ``step`` 方法。
+同时也请注意本调度器需要在每次迭代后调用  ``step``  方法。
 
 参数
 ::::::::::::
 
-    - **max_learning_rate** (float) - 最大学习率，学习率变化的上边界，数据类型为 Python float。功能上其通过 ``divide_factor`` 定义了初始学习率。
+    - **max_learning_rate** (float) - 最大学习率，学习率变化的上边界，数据类型为 Python float。功能上其通过  ``divide_factor``  定义了初始学习率。
     - **total_steps** (int，可选) - 训练过程中总的迭代数。
     - **divide_factor** (float，可选) - 该参数用于推断初始学习率，公式为 initial_learning_rate = max_learning_rate / divide_factor。默认值为 25。
     - **end_learning_rate** (float，可选) - 最小学习率，学习率变化的下边界。它应该是一个远小于初始学习率的数。
     - **phase_pct** (float) - 学习率从初始学习率增长到最大学习率所需迭代数占总迭代数的比例。默认值为 0.3。
-    - **anneal_strategy** (str，可选) - 调整学习率的策略。必须是 ( ``cos`` , ``linear`` )其中之一，``cos`` 表示使用余弦退火，``linear`` 表示线性退火。默认值为 ``cos`` 。
-    - **three_phase** (bool，可选) - 是否使用三阶段调度策略。如果是 ``True``，学习率将先从初始学习率上升到最大学习率，再从最大学习率下降到初始学习率（这两阶段所需要的迭代数是一致的），最后学习率会下降至最小学习率。如果是 ``False``，学习率在上升至最大学习率之后，直接下降至最小学习率。默认值为 ``False`` 。
+    - **anneal_strategy** (str，可选) - 调整学习率的策略。必须是 (  ``cos``  ,  ``linear``  )其中之一， ``cos``  表示使用余弦退火， ``linear``  表示线性退火。默认值为  ``cos``  。
+    - **three_phase** (bool，可选) - 是否使用三阶段调度策略。如果是  ``True`` ，学习率将先从初始学习率上升到最大学习率，再从最大学习率下降到初始学习率（这两阶段所需要的迭代数是一致的），最后学习率会下降至最小学习率。如果是  ``False`` ，学习率在上升至最大学习率之后，直接下降至最小学习率。默认值为  ``False``  。
     - **last_epoch** (int，可选) - 上一轮的轮数，重启训练时设置为上一轮的 epoch 数。默认值为 -1，则为初始学习率。
-    - **verbose** (bool，可选) - 如果是 ``True``，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** (bool，可选) - 如果是  ``True`` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 返回
 ::::::::::::
-用于调整学习率的 ``OneCycleLR`` 实例对象。
+用于调整学习率的  ``OneCycleLR``  实例对象。
 
 代码示例
 ::::::::::::
@@ -46,7 +46,7 @@ step 函数需要在优化器的 `optimizer.step()` 函数之后调用，调用
 
 **参数**
 
-  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
diff --git a/docs/api/paddle/optimizer/lr/PiecewiseDecay_cn.rst b/docs/api/paddle/optimizer/lr/PiecewiseDecay_cn.rst
index 08d8dc9465c..681be4b2f03 100644
--- a/docs/api/paddle/optimizer/lr/PiecewiseDecay_cn.rst
+++ b/docs/api/paddle/optimizer/lr/PiecewiseDecay_cn.rst
@@ -27,11 +27,11 @@ PiecewiseDecay
     - **boundaries** (list) - 指定学习率的边界值列表。列表的数据元素为 Python int 类型。
     - **values** (list) - 学习率列表。数据元素类型为 Python float 的列表。与边界值列表有对应的关系。
     - **last_epoch** (int，可选) - 上一轮的轮数，重启训练时设置为上一轮的 epoch 数。默认值为 -1，则为初始学习率。
-    - **verbose** (bool，可选) - 如果是 ``True``，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** (bool，可选) - 如果是  ``True`` ，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 返回
 ::::::::::::
-用于调整学习率的 ``PiecewiseDecay`` 实例对象。
+用于调整学习率的  ``PiecewiseDecay``  实例对象。
 
 代码示例
 ::::::::::::
@@ -47,7 +47,7 @@ step 函数需要在优化器的 `optimizer.step()` 函数之后调用，调用
 
 **参数**
 
-  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
diff --git a/docs/api/paddle/optimizer/lr/PolynomialDecay_cn.rst b/docs/api/paddle/optimizer/lr/PolynomialDecay_cn.rst
index a42fbde5b60..5866d10d8a5 100644
--- a/docs/api/paddle/optimizer/lr/PolynomialDecay_cn.rst
+++ b/docs/api/paddle/optimizer/lr/PolynomialDecay_cn.rst
@@ -6,7 +6,7 @@ PolynomialDecay
 .. py:class:: paddle.optimizer.lr.PolynomialDecay(learning_rate, decay_steps, end_lr=0.0001, power=1.0, cycle=False, last_epoch=-1, verbose=False)
 
 
-该接口提供学习率按多项式衰减的策略。通过多项式衰减函数，使得学习率值逐步从初始的 ``learning_rate``，衰减到 ``end_lr`` 。
+该接口提供学习率按多项式衰减的策略。通过多项式衰减函数，使得学习率值逐步从初始的  ``learning_rate`` ，衰减到  ``end_lr``  。
 
 若 cycle 为 True，则计算公式为：
 
@@ -34,11 +34,11 @@ PolynomialDecay
     - **power** (float，可选) - 多项式的幂，power 应该大于 0.0，才能使学习率衰减。默认值为 1.0。
     - **cycle** (bool，可选) - 学习率下降后是否重新上升。若为 True，则学习率衰减到最低学习率值时，会重新上升。若为 False，则学习率单调递减。默认值为 False。
     - **last_epoch** (int，可选) - 上一轮的轮数，重启训练时设置为上一轮的 epoch 数。默认值为 -1，则为初始学习率。
-    - **verbose** (bool，可选) - 如果是 `True`，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** (bool，可选) - 如果是 `True`，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 返回
 ::::::::::::
-用于调整学习率的 ``PolynomialDecay`` 实例对象。
+用于调整学习率的  ``PolynomialDecay``  实例对象。
 
 
 代码示例
@@ -55,7 +55,7 @@ step 函数需要在优化器的 `optimizer.step()` 函数之后调用，调用
 
 **参数**
 
-  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
diff --git a/docs/api/paddle/optimizer/lr/ReduceOnPlateau_cn.rst b/docs/api/paddle/optimizer/lr/ReduceOnPlateau_cn.rst
index 60c49057093..b3391923f6c 100644
--- a/docs/api/paddle/optimizer/lr/ReduceOnPlateau_cn.rst
+++ b/docs/api/paddle/optimizer/lr/ReduceOnPlateau_cn.rst
@@ -5,30 +5,30 @@ ReduceOnPlateau
 
 .. py:class:: paddle.optimizer.lr.ReduceOnPlateau(learning_rate, mode='min', factor=0.1, patience=10, threshold=1e-4, threshold_mode='rel', cooldown=0, min_lr=0, epsilon=1e-8, verbose=False)
 
-`loss` 自适应的学习率衰减策略。默认情况下，当 ``loss`` 停止下降时，降低学习率。其思想是：一旦模型表现不再提升，将学习率降低 2-10 倍对模型的训练往往有益。
+`loss` 自适应的学习率衰减策略。默认情况下，当  ``loss``  停止下降时，降低学习率。其思想是：一旦模型表现不再提升，将学习率降低 2-10 倍对模型的训练往往有益。
 
-`loss` 是传入到该类方法 ``step`` 中的 ``metrics`` 参数，其可以是 float 或者 shape 为[]的 0-D Tensor 或 numpy\.ndarray。如果 loss 停止下降超过 ``patience`` 个 epoch，学习率将会衰减为 ``learning_rate * factor`` （特殊地，``mode`` 也可以被设置为 ``'max'``，此时逻辑相反）。
+`loss` 是传入到该类方法  ``step``  中的  ``metrics``  参数，其可以是 float 或者 shape 为[]的 0-D Tensor 或 numpy\.ndarray。如果 loss 停止下降超过  ``patience``  个 epoch，学习率将会衰减为  ``learning_rate * factor``  （特殊地， ``mode``  也可以被设置为  ``'max'`` ，此时逻辑相反）。
 
-此外，每降低一次学习率后，将会进入一个时长为 ``cooldown`` 个 epoch 的冷静期，在冷静期内，将不会监控 ``loss`` 的变化情况，也不会衰减。在冷静期之后，会继续监控 ``loss`` 的上升或下降。
+此外，每降低一次学习率后，将会进入一个时长为  ``cooldown``  个 epoch 的冷静期，在冷静期内，将不会监控  ``loss``  的变化情况，也不会衰减。在冷静期之后，会继续监控  ``loss``  的上升或下降。
 
 
 参数
 ::::::::::::
 
     - **learning_rate** (float) - 初始学习率，数据类型为 Python float。
-    - **mode** (str，可选) - ``'min'`` 和 ``'max'`` 之一。通常情况下，为 ``'min'``，此时当 ``loss`` 停止下降时学习率将衰减。默认：``'min'`` 。 （注意：仅在特殊用法时，可以将其设置为 ``'max'``，此时判断逻辑相反，``loss`` 停止上升学习率才衰减）。
-    - **factor** (float，可选) - 学习率衰减的比例。``new_lr = origin_lr * factor``，它是值小于 1.0 的 float 型数字，默认：0.1。
-    - **patience** (int，可选) - 当 ``loss`` 连续 ``patience`` 个 epoch 没有下降(对应 mode: 'min')或上升(对应 mode: 'max')时，学习率才会衰减。默认：10。
-    - **threshold** (float，可选) - ``threshold`` 和 ``threshold_mode`` 两个参数将会决定 ``loss`` 最小变化的阈值。小于该阈值的变化将会被忽视。默认：1e-4。
-    - **threshold_mode** (str，可选) - ``'rel'`` 和 ``'abs'`` 之一。在 ``'rel'`` 模式下，``loss`` 最小变化的阈值是 ``last_loss * threshold``，其中 ``last_loss`` 是 ``loss`` 在上个 epoch 的值。在 ``'abs'`` 模式下，``loss`` 最小变化的阈值是 ``threshold``。默认：``'rel'`` 。
-    - **cooldown** (int，可选) - 在学习率每次衰减之后，会进入时长为 ``cooldown`` 个 step 的冷静期。默认：0。
+    - **mode** (str，可选) -  ``'min'``  和  ``'max'``  之一。通常情况下，为  ``'min'`` ，此时当  ``loss``  停止下降时学习率将衰减。默认： ``'min'``  。 （注意：仅在特殊用法时，可以将其设置为  ``'max'`` ，此时判断逻辑相反， ``loss``  停止上升学习率才衰减）。
+    - **factor** (float，可选) - 学习率衰减的比例。 ``new_lr = origin_lr * factor`` ，它是值小于 1.0 的 float 型数字，默认：0.1。
+    - **patience** (int，可选) - 当  ``loss``  连续  ``patience``  个 epoch 没有下降(对应 mode: 'min')或上升(对应 mode: 'max')时，学习率才会衰减。默认：10。
+    - **threshold** (float，可选) -  ``threshold``  和  ``threshold_mode``  两个参数将会决定  ``loss``  最小变化的阈值。小于该阈值的变化将会被忽视。默认：1e-4。
+    - **threshold_mode** (str，可选) -  ``'rel'``  和  ``'abs'``  之一。在  ``'rel'``  模式下， ``loss``  最小变化的阈值是  ``last_loss * threshold`` ，其中  ``last_loss``  是  ``loss``  在上个 epoch 的值。在  ``'abs'``  模式下， ``loss``  最小变化的阈值是  ``threshold`` 。默认： ``'rel'``  。
+    - **cooldown** (int，可选) - 在学习率每次衰减之后，会进入时长为  ``cooldown``  个 step 的冷静期。默认：0。
     - **min_lr** (float，可选) - 最小的学习率。衰减后的学习率最低下界限。默认：0。
     - **epsilon** (float，可选) - 如果新旧学习率间的差异小于 epsilon，则不会更新。默认值：1e-8。
-    - **verbose** (bool，可选) - 如果是 `True`，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** (bool，可选) - 如果是 `True`，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 返回
 ::::::::::::
-用于调整学习率的 ``ReduceOnPlateau`` 实例对象。
+用于调整学习率的  ``ReduceOnPlateau``  实例对象。
 
 代码示例
 ::::::::::::
@@ -40,12 +40,12 @@ COPY-FROM: paddle.optimizer.lr.ReduceOnPlateau
 step(metrics, epoch=None)
 '''''''''
 
-step 函数需要在优化器的 `optimizer.step()` 函数之后调用，其根据传入的 metrics 调整 optimizer 中的学习率，调整后的学习率将会在下一个 ``step`` 时生效。
+step 函数需要在优化器的 `optimizer.step()` 函数之后调用，其根据传入的 metrics 调整 optimizer 中的学习率，调整后的学习率将会在下一个  ``step``  时生效。
 
 **参数**
 
-  - **metrics** (Tensor|numpy.ndarray|float）- 用来判断是否需要降低学习率。如果 ``loss`` 连续 ``patience`` 个 ``step`` 没有下降，将会降低学习率。可以是 Tensor 或者 numpy.array，但是 shape 必须为[]，也可以是 Python 的 float 类型。
-  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+  - **metrics** (Tensor|numpy.ndarray|float）- 用来判断是否需要降低学习率。如果  ``loss``  连续  ``patience``  个  ``step``  没有下降，将会降低学习率。可以是 Tensor 或者 numpy.array，但是 shape 必须为[]，也可以是 Python 的 float 类型。
+  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
diff --git a/docs/api/paddle/optimizer/lr/StepDecay_cn.rst b/docs/api/paddle/optimizer/lr/StepDecay_cn.rst
index fa99559b03a..ebe66f4f852 100644
--- a/docs/api/paddle/optimizer/lr/StepDecay_cn.rst
+++ b/docs/api/paddle/optimizer/lr/StepDecay_cn.rst
@@ -25,14 +25,14 @@ StepDecay
 
     - **learning_rate** (float) - 初始学习率，数据类型为 Python float。
     - **step_size** (int) - 学习率衰减轮数间隔。
-    - **gamma** (float，可选) - 衰减率，``new_lr = origin_lr * gamma``，衰减率必须小于等于 1.0，默认值为 0.1。
+    - **gamma** (float，可选) - 衰减率， ``new_lr = origin_lr * gamma`` ，衰减率必须小于等于 1.0，默认值为 0.1。
     - **last_epoch** (int，可选) - 上一轮的轮数，重启训练时设置为上一轮的 epoch 数。默认值为 -1，则为初始学习率。
-    - **verbose** (bool，可选) - 如果是 `True`，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为 ``False`` 。
+    - **verbose** (bool，可选) - 如果是 `True`，则在每一轮更新时在标准输出 `stdout` 输出一条信息。默认值为  ``False``  。
 
 
 返回
 ::::::::::::
-用于调整学习率的 ``StepDecay`` 实例对象。
+用于调整学习率的  ``StepDecay``  实例对象。
 
 代码示例
 ::::::::::::
@@ -48,7 +48,7 @@ step 函数需要在优化器的 `optimizer.step()` 函数之后调用，调用
 
 **参数**
 
-  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加 ``epoch`` 数。
+  - **epoch** (int，可选) - 指定具体的 epoch 数。默认值 None，此时将会从-1 自动累加  ``epoch``  数。
 
 **返回**
 
diff --git a/docs/api/paddle/outer_cn.rst b/docs/api/paddle/outer_cn.rst
index f71af5b65a7..5b552eb05b0 100644
--- a/docs/api/paddle/outer_cn.rst
+++ b/docs/api/paddle/outer_cn.rst
@@ -11,13 +11,13 @@ outer
 对于 1 维 Tensor 正常计算外积，对于大于 1 维的 Tensor 先展平为 1 维再计算外积。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``vec2`` 可替代 ``y`` ，如 ``outer(input=tensor_x, vec2=tensor_y, ...)`` 等价于 ``outer(x=tensor_x, y=tensor_y, ...)`` 。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，参数名  ``vec2``  可替代  ``y``  ，如  ``outer(input=tensor_x, vec2=tensor_y, ...)``  等价于  ``outer(x=tensor_x, y=tensor_y, ...)``  。
 
 参数
 :::::::::
 
-    - **x** (Tensor) - 一个 N 维 Tensor 或者标量 Tensor。别名： ``input``。
-    - **y** (Tensor) - 一个 N 维 Tensor 或者标量 Tensor。别名： ``vec2``。
+    - **x** (Tensor) - 一个 N 维 Tensor 或者标量 Tensor。别名：  ``input`` 。
+    - **y** (Tensor) - 一个 N 维 Tensor 或者标量 Tensor。别名：  ``vec2`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/permute_cn.rst b/docs/api/paddle/permute_cn.rst
index 8556dd22de8..589cf74ff64 100644
--- a/docs/api/paddle/permute_cn.rst
+++ b/docs/api/paddle/permute_cn.rst
@@ -16,7 +16,7 @@ permute
 
 返回
 ::::::::::::
-    ``Tensor``，经过 dims 指定顺序重排后的多维 Tensor，数据类型与输入一致，shape 为根据 dims 重新排列后的 shape。
+     ``Tensor`` ，经过 dims 指定顺序重排后的多维 Tensor，数据类型与输入一致，shape 为根据 dims 重新排列后的 shape。
 
 
 代码示例
diff --git a/docs/api/paddle/poisson_cn.rst b/docs/api/paddle/poisson_cn.rst
index 4091c361f64..d96060cda87 100644
--- a/docs/api/paddle/poisson_cn.rst
+++ b/docs/api/paddle/poisson_cn.rst
@@ -5,19 +5,19 @@ poisson
 
 .. py:function:: paddle.poisson(x, name=None)
 
-以输入参数 ``x`` 为泊松分布的 `lambda` 参数，生成一个泊松分布的随机数 Tensor，输出 Tensor 的 shape 和 dtype 与输入 Tensor 相同。
+以输入参数  ``x``  为泊松分布的 `lambda` 参数，生成一个泊松分布的随机数 Tensor，输出 Tensor 的 shape 和 dtype 与输入 Tensor 相同。
 
 .. math::
    out_i \sim Poisson(lambda = x_i)
 
 参数
 :::::::::
-    - **x** (Tensor) - Tensor 的每个元素，对应泊松分布的 ``lambda`` 参数。数据类型为：bfloat16, float16, float32、float64。
+    - **x** (Tensor) - Tensor 的每个元素，对应泊松分布的  ``lambda``  参数。数据类型为：bfloat16, float16, float32、float64。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-`Tensor`：泊松分布的随机数 Tensor，shape 和 dtype 与输入 ``x`` 相同。
+`Tensor`：泊松分布的随机数 Tensor，shape 和 dtype 与输入  ``x``  相同。
 
 
 代码示例
diff --git a/docs/api/paddle/polar_cn.rst b/docs/api/paddle/polar_cn.rst
index afb10bfd0ae..5db512f3ef8 100644
--- a/docs/api/paddle/polar_cn.rst
+++ b/docs/api/paddle/polar_cn.rst
@@ -6,7 +6,7 @@ polar
 .. py:function:: paddle.polar(abs, angle, name=None, *, out=None)
 
 
-对于给定的模 ``abs`` 和相位角 ``angle``，返回一个对应复平面（笛卡尔坐标系）上的复数坐标 Tensor。
+对于给定的模  ``abs``  和相位角  ``angle`` ，返回一个对应复平面（笛卡尔坐标系）上的复数坐标 Tensor。
 
 .. math::
     \text{out} = \text{abs}\cdot\cos(\text{angle}) + \text{abs}\cdot\sin(\text{angle})\cdot j
@@ -20,10 +20,10 @@ polar
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 返回
 ::::::::::
-    - ``Tensor`` (Tensor)：对应模 ``abs`` 和相位角 ``angle`` 在复平面（笛卡尔坐标系）上的复数坐标 Tensor，形状和原输入的形状一致。
+    -  ``Tensor``  (Tensor)：对应模  ``abs``  和相位角  ``angle``  在复平面（笛卡尔坐标系）上的复数坐标 Tensor，形状和原输入的形状一致。
 
 
 代码示例
diff --git a/docs/api/paddle/polygamma_cn.rst b/docs/api/paddle/polygamma_cn.rst
index c54b4a8d033..9d8c78997bb 100644
--- a/docs/api/paddle/polygamma_cn.rst
+++ b/docs/api/paddle/polygamma_cn.rst
@@ -6,7 +6,7 @@ polygamma
 .. py:function:: paddle.polygamma(x, n, name=None)
 
 
-对于给定的 ``x`` 逐元素计算每个元素的多伽马函数值，其中 ``x`` 的大小无特殊限制。返回一个多伽马函数上的 Tensor。
+对于给定的  ``x``  逐元素计算每个元素的多伽马函数值，其中  ``x``  的大小无特殊限制。返回一个多伽马函数上的 Tensor。
 
 .. math::
     \Phi^n(x) = \frac{d^n}{dx^n} [\ln(\Gamma(x))]
@@ -14,11 +14,11 @@ polygamma
 参数
 ::::::::::
     - **x** (Tensor) – 输入是一个多维的 Tensor，它的数据类型可以是 float32，float64。
-    - **n** (int) - 指定需要求解 ``n`` 阶多伽马函数，它的数据类型是 int。
+    - **n** (int) - 指定需要求解  ``n``  阶多伽马函数，它的数据类型是 int。
     - **name** (str，可选) - 具体用法请参见  :ref:`api_guide_Name` ，一般无需设置，默认值为 None。
 返回
 ::::::::::
-    - ``Tensor`` (Tensor)：在 x 处的多伽马函数的值。
+    -  ``Tensor``  (Tensor)：在 x 处的多伽马函数的值。
 
 
 代码示例
diff --git a/docs/api/paddle/pow_cn.rst b/docs/api/paddle/pow_cn.rst
index 9330923d1a7..c19f67ebc95 100644
--- a/docs/api/paddle/pow_cn.rst
+++ b/docs/api/paddle/pow_cn.rst
@@ -7,29 +7,29 @@ pow
 
 
 
-指数算子，逐元素计算 ``x`` 的 ``y`` 次幂。
+指数算子，逐元素计算  ``x``  的  ``y``  次幂。
 
 .. math::
 
     out = x^{y}
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``exponent`` 可替代 ``y`` ，如 ``pow(input=2, exponent=1.1)`` 等价于 ``pow(x=2, y=1.1)`` 。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，参数名  ``exponent``  可替代  ``y``  ，如  ``pow(input=2, exponent=1.1)``  等价于  ``pow(x=2, y=1.1)``  。
 
 参数
 :::::::::
-    - **x** （Tensor）- 多维 ``Tensor``，数据类型为 ``bfloat16`` 、 ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 或  ``int64`` 。别名： ``input``。
-    - **y** （float|int|Tensor）- 如果类型是多维 ``Tensor``，其数据类型应该和 ``x`` 相同。别名： ``exponent``。
+    - **x** （Tensor）- 多维  ``Tensor`` ，数据类型为  ``bfloat16``  、  ``float16``  、  ``float32``  、  ``float64``  、  ``int32``  或   ``int64``  。别名：  ``input`` 。
+    - **y** （float|int|Tensor）- 如果类型是多维  ``Tensor`` ，其数据类型应该和  ``x``  相同。别名：  ``exponent`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 返回
 :::::::::
-Tensor，维度和数据类型都和 ``x`` 相同。
+Tensor，维度和数据类型都和  ``x``  相同。
 
 
 代码示例
diff --git a/docs/api/paddle/prod_cn.rst b/docs/api/paddle/prod_cn.rst
index 6ab87c2ef24..ba859dca799 100644
--- a/docs/api/paddle/prod_cn.rst
+++ b/docs/api/paddle/prod_cn.rst
@@ -10,15 +10,15 @@ prod
 对指定维度上的 Tensor 元素进行求乘积运算，并输出相应的计算结果。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x`` 和 ``dim`` 可替代 ``axis``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``， ``dim=1`` 等价于 ``axis=1``。
+    别名支持: 参数名  ``input``  可替代  ``x``  和  ``dim``  可替代  ``axis`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` ，  ``dim=1``  等价于  ``axis=1`` 。
 
 参数
 ::::::::::::
 
     - **x** (Tensor) - 输入的 Tensor，数据类型为：bfloat16、float16、float32、float64、int32、int64、complex64、complex128。
-      别名： ``input``
+      别名：  ``input`` 
     - **axis** (int|list|tuple，可选) - 求乘积运算的维度。如果是 None，则计算所有元素的乘积并返回包含单个元素的 Tensor，否则该参数必须在 :math:`[-x.ndim, x.ndim)` 范围内。如果 :math:`axis[i] < 0`，则维度将变为 :math:`x.ndim + axis[i]`，默认为 None。
-      别名： ``dim``
+      别名：  ``dim`` 
     - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留输入的维度。除非 keepdim 为 True，否则输出 Tensor 的维度将比输入 Tensor 小一维，默认值为 False。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，支持 int32、int64、float32、float64。如果指定了该参数，那么在执行操作之前，输入 Tensor 将被转换为 dtype 类型。这对于防止数据类型溢出非常有用。若参数为空，则输出变量的数据类型和输入变量相同，默认为：None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
diff --git a/docs/api/paddle/profiler/export_chrome_tracing_cn.rst b/docs/api/paddle/profiler/export_chrome_tracing_cn.rst
index ba547248fe6..b40c48715d6 100644
--- a/docs/api/paddle/profiler/export_chrome_tracing_cn.rst
+++ b/docs/api/paddle/profiler/export_chrome_tracing_cn.rst
@@ -6,8 +6,8 @@ export_chrome_tracing
 .. py:function:: paddle.profiler.export_chrome_tracing(dir_name: str, worker_name: Optional[str]=None)
 
 返回一个回调函数，用于将采集的性能数据保存到 google chrome tracing 格式的文件。
-输出的文件将会保存在目录 ``dir_name`` 中，文件名的前缀将会被设置成 ``worker_name`` 。
-如果 ``worker_name`` 没有被设置，默认名字为 [hostname]_[pid]。
+输出的文件将会保存在目录  ``dir_name``  中，文件名的前缀将会被设置成  ``worker_name``  。
+如果  ``worker_name``  没有被设置，默认名字为 [hostname]_[pid]。
 
 参数
 :::::::::
diff --git a/docs/api/paddle/profiler/export_protobuf_cn.rst b/docs/api/paddle/profiler/export_protobuf_cn.rst
index 676cb7ca1ed..1d0ab2bff99 100644
--- a/docs/api/paddle/profiler/export_protobuf_cn.rst
+++ b/docs/api/paddle/profiler/export_protobuf_cn.rst
@@ -6,8 +6,8 @@ export_protobuf
 .. py:function:: paddle.profiler.export_protobuf(dir_name: str, worker_name: Optional[str]=None)
 
 返回一个回调函数，用于将采集的性能数据保存到 protobuf 格式的文件。
-输出的文件将会保存在目录 ``dir_name`` 中，文件名的前缀将会被设置成 ``worker_name`` 。
-如果 ``worker_name`` 没有被设置，默认名字为 [hostname]_[pid]。
+输出的文件将会保存在目录  ``dir_name``  中，文件名的前缀将会被设置成  ``worker_name``  。
+如果  ``worker_name``  没有被设置，默认名字为 [hostname]_[pid]。
 
 参数
 :::::::::
diff --git a/docs/api/paddle/put_along_axis_cn.rst b/docs/api/paddle/put_along_axis_cn.rst
index 57a97c306ce..e8db71ab954 100644
--- a/docs/api/paddle/put_along_axis_cn.rst
+++ b/docs/api/paddle/put_along_axis_cn.rst
@@ -11,17 +11,17 @@ put_along_axis
 :::::::::
 
     - **arr**  (Tensor) - 输入的 Tensor 作为目标矩阵，数据类型为：bfloat16、float16、float32、float64、int32、int64、uint8、int16。
-    - **indices**  (Tensor) - 索引矩阵，包含沿轴提取 1d 切片的下标，必须和 arr 矩阵有相同的维度。当 ``broadcast`` 为 ``True`` 时，需要能够 broadcast 与 arr 矩阵对齐，否则除 ``axis`` 维度，其他维度都需要小于等于 ``arr`` 与 ``values`` 的对应维度。数据类型为：int32、int64。
-    - **values** (float) - 需要插入的值，当 ``broadcast`` 为 ``True`` 时，形状和维度需要能够被 broadcast 与 indices 矩阵匹配，否则各维度需大于等于 ``indices`` 的各维度。数据类型为：bfloat16、float16、float32、float64、int32、int64、uint8、int16。
+    - **indices**  (Tensor) - 索引矩阵，包含沿轴提取 1d 切片的下标，必须和 arr 矩阵有相同的维度。当  ``broadcast``  为  ``True``  时，需要能够 broadcast 与 arr 矩阵对齐，否则除  ``axis``  维度，其他维度都需要小于等于  ``arr``  与  ``values``  的对应维度。数据类型为：int32、int64。
+    - **values** (float) - 需要插入的值，当  ``broadcast``  为  ``True``  时，形状和维度需要能够被 broadcast 与 indices 矩阵匹配，否则各维度需大于等于  ``indices``  的各维度。数据类型为：bfloat16、float16、float32、float64、int32、int64、uint8、int16。
     - **axis**  (int) - 指定沿着哪个维度获取对应的值，数据类型为：int。
-    - **reduce** (str，可选) - 归约操作类型，默认为 ``assign``，可选为 ``add``、 ``multiple``、 ``mean``、 ``amin``、 ``amax``。不同的规约操作插入值 value 对于输入矩阵 arr 会有不同的行为，如为 ``assgin`` 则覆盖输入矩阵， ``add`` 则累加至输入矩阵， ``mean`` 则计算累计平均值至输入矩阵， ``multiple`` 则累乘至输入矩阵， ``amin`` 则计算累计最小值至输入矩阵， ``amax`` 则计算累计最大值至输入矩阵。
-    - **include_self** (bool，可选) - 规约时是否包含 arr 的元素，默认为 ``True``。
-    - **broadcast** (bool，可选) - 是否广播 ``index`` 矩阵，默认为 ``True``。
+    - **reduce** (str，可选) - 归约操作类型，默认为  ``assign`` ，可选为  ``add`` 、  ``multiple`` 、  ``mean`` 、  ``amin`` 、  ``amax`` 。不同的规约操作插入值 value 对于输入矩阵 arr 会有不同的行为，如为  ``assgin``  则覆盖输入矩阵，  ``add``  则累加至输入矩阵，  ``mean``  则计算累计平均值至输入矩阵，  ``multiple``  则累乘至输入矩阵，  ``amin``  则计算累计最小值至输入矩阵，  ``amax``  则计算累计最大值至输入矩阵。
+    - **include_self** (bool，可选) - 规约时是否包含 arr 的元素，默认为  ``True`` 。
+    - **broadcast** (bool，可选) - 是否广播  ``index``  矩阵，默认为  ``True`` 。
 
 返回
 :::::::::
 
-输出 Tensor，indeces 矩阵选定的下标会被插入 value，与 ``arr`` 数据类型相同。
+输出 Tensor，indeces 矩阵选定的下标会被插入 value，与  ``arr``  数据类型相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/quantile_cn.rst b/docs/api/paddle/quantile_cn.rst
index c3f1f328b2d..6fd6db8b51f 100644
--- a/docs/api/paddle/quantile_cn.rst
+++ b/docs/api/paddle/quantile_cn.rst
@@ -5,20 +5,20 @@ quantile
 
 .. py:function:: paddle.quantile(x, q, axis=None, keepdim=False, interpolation='linear', name=None)
 
-沿给定的轴 ``axis`` 计算 ``x`` 中元素的分位数。
+沿给定的轴  ``axis``  计算  ``x``  中元素的分位数。
 
 参数
 ::::::::::
     - **x** (Tensor) - 输入的 Tensor，数据类型为：float32、float64、int32、int64。
-    - **q** (int|float|list|Tensor) - 待计算的分位数，需要在符合取值范围[0, 1]。如果 ``q`` 是 List 或者 1-D Tensor，其中的每一个 q 分位数都会被计算，并且输出的首维大小与列表或 Tensor 中元素的数量相同。如果 ``q`` 是 0-D Tensor ，则会被当作 float 和 int 对待。
-    - **axis** (int|list，可选) - 指定对 ``x`` 进行计算的轴。``axis`` 可以是 int 或内部元素为 int 类型的 list。``axis`` 值应该在范围[-D, D)内，D 是 ``x`` 的维度。如果 ``axis`` 或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果 ``axis`` 是 list，对给定的轴上的所有元素计算分位数。如果 ``axis`` 是 None，则对 ``x`` 的全部元素计算分位数。默认值为 None。
-    - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如果 ``keepdim`` 为 True，则输出 Tensor 和 ``x`` 具有相同的维度(减少的维度除外，减少的维度的大小为 1)。否则，输出 Tensor 的形状会在 ``axis`` 上进行 squeeze 操作。默认值为 False。
-    - **interpolation** (str，可选) - 计算分位数的插值方法，可以是 ``linear`` , ``lower`` , ``higher`` , ``nearest`` 或者 ``midpoint`` 。 默认值为 ``linear`` 。
+    - **q** (int|float|list|Tensor) - 待计算的分位数，需要在符合取值范围[0, 1]。如果  ``q``  是 List 或者 1-D Tensor，其中的每一个 q 分位数都会被计算，并且输出的首维大小与列表或 Tensor 中元素的数量相同。如果  ``q``  是 0-D Tensor ，则会被当作 float 和 int 对待。
+    - **axis** (int|list，可选) - 指定对  ``x``  进行计算的轴。 ``axis``  可以是 int 或内部元素为 int 类型的 list。 ``axis``  值应该在范围[-D, D)内，D 是  ``x``  的维度。如果  ``axis``  或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果  ``axis``  是 list，对给定的轴上的所有元素计算分位数。如果  ``axis``  是 None，则对  ``x``  的全部元素计算分位数。默认值为 None。
+    - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如果  ``keepdim``  为 True，则输出 Tensor 和  ``x``  具有相同的维度(减少的维度除外，减少的维度的大小为 1)。否则，输出 Tensor 的形状会在  ``axis``  上进行 squeeze 操作。默认值为 False。
+    - **interpolation** (str，可选) - 计算分位数的插值方法，可以是  ``linear``  ,  ``lower``  ,  ``higher``  ,  ``nearest``  或者  ``midpoint``  。 默认值为  ``linear``  。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，沿着 ``axis`` 进行分位数计算的结果。与输入数据类型一致。
+     ``Tensor`` ，沿着  ``axis``  进行分位数计算的结果。与输入数据类型一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/rad2deg_cn.rst b/docs/api/paddle/rad2deg_cn.rst
index 4474fbcf874..605488a4fdf 100644
--- a/docs/api/paddle/rad2deg_cn.rst
+++ b/docs/api/paddle/rad2deg_cn.rst
@@ -20,7 +20,7 @@ rad2deg
 返回
 :::::::::
 
-输出 Tensor，与 ``x`` 维度相同、数据类型相同（输入为 int 时，输出数据类型为 float32）。
+输出 Tensor，与  ``x``  维度相同、数据类型相同（输入为 int 时，输出数据类型为 float32）。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/rand_cn.rst b/docs/api/paddle/rand_cn.rst
index 88ea6315ed3..2de263ef4da 100644
--- a/docs/api/paddle/rand_cn.rst
+++ b/docs/api/paddle/rand_cn.rst
@@ -5,17 +5,17 @@ rand
 
 .. py:function:: paddle.rand(shape, dtype=None, name=None)
 
-返回符合均匀分布的、范围在[0, 1)的 Tensor，形状为 ``shape``，数据类型为 ``dtype``。
+返回符合均匀分布的、范围在[0, 1)的 Tensor，形状为  ``shape`` ，数据类型为  ``dtype`` 。
 
 参数
 ::::::::::
-    - **shape** (list|tuple|Tensor) - 生成的随机 Tensor 的形状。如果 ``shape`` 是 list、tuple，则其中的元素可以是 int，或者是形状为[]且数据类型为 int32、int64 的 0-D Tensor。如果 ``shape`` 是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor。
+    - **shape** (list|tuple|Tensor) - 生成的随机 Tensor 的形状。如果  ``shape``  是 list、tuple，则其中的元素可以是 int，或者是形状为[]且数据类型为 int32、int64 的 0-D Tensor。如果  ``shape``  是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，支持 float32、float64。当该参数值为 None 时，输出 Tensor 的数据类型为 float32。使用全局默认 dtype（详细信息请见 :ref:`get_default_dtype` ）。默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    Tensor：符合均匀分布的范围为[0, 1)的随机 Tensor，形状为 ``shape``，数据类型为 ``dtype``。
+    Tensor：符合均匀分布的范围为[0, 1)的随机 Tensor，形状为  ``shape`` ，数据类型为  ``dtype`` 。
 
 示例代码
 ::::::::::
diff --git a/docs/api/paddle/rand_like_cn.rst b/docs/api/paddle/rand_like_cn.rst
index a0210946bb3..1f370a627cf 100644
--- a/docs/api/paddle/rand_like_cn.rst
+++ b/docs/api/paddle/rand_like_cn.rst
@@ -17,7 +17,7 @@ rand_like
 
 返回
 ::::::::::
-    Tensor：与输入张量 ``input`` 形状相同的 Tensor，其元素为从区间 [0, 1) 上均匀分布中采样的随机数，数据类型为 ``dtype``。
+    Tensor：与输入张量  ``input``  形状相同的 Tensor，其元素为从区间 [0, 1) 上均匀分布中采样的随机数，数据类型为  ``dtype`` 。
 
 代码示例
 :::::::::::
diff --git a/docs/api/paddle/randint_cn.rst b/docs/api/paddle/randint_cn.rst
index 823c4855a9b..a40dda633eb 100644
--- a/docs/api/paddle/randint_cn.rst
+++ b/docs/api/paddle/randint_cn.rst
@@ -5,19 +5,19 @@ randint
 
 .. py:function:: paddle.randint(low=0, high=None, shape=[1], dtype=None, name=None)
 
-返回服从均匀分布的、范围在[``low``, ``high``)的随机 Tensor，形状为 ``shape``，数据类型为 ``dtype``。当 ``high`` 为 None 时（默认），均匀采样的区间为[0, ``low``)。
+返回服从均匀分布的、范围在[ ``low`` ,  ``high`` )的随机 Tensor，形状为  ``shape`` ，数据类型为  ``dtype`` 。当  ``high``  为 None 时（默认），均匀采样的区间为[0,  ``low`` )。
 
 参数
 ::::::::::
-    - **low** (int，可选) - 要生成的随机值范围的下限，``low`` 包含在范围中。当 ``high`` 为 None 时，均匀采样的区间为[0, ``low``)。默认值为 0。
-    - **high** (int，可选) - 要生成的随机值范围的上限，``high`` 不包含在范围中。默认值为 None，此时范围是[0, ``low``)。
-    - **shape** (list|tuple|Tensor，可选) - 生成的随机 Tensor 的形状。如果 ``shape`` 是 list、tuple，则其中的元素可以是 int，或者是形状为[]且数据类型为 int32、int64 的 0-D Tensor。如果 ``shape`` 是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor。默认值为[1]。
+    - **low** (int，可选) - 要生成的随机值范围的下限， ``low``  包含在范围中。当  ``high``  为 None 时，均匀采样的区间为[0,  ``low`` )。默认值为 0。
+    - **high** (int，可选) - 要生成的随机值范围的上限， ``high``  不包含在范围中。默认值为 None，此时范围是[0,  ``low`` )。
+    - **shape** (list|tuple|Tensor，可选) - 生成的随机 Tensor 的形状。如果  ``shape``  是 list、tuple，则其中的元素可以是 int，或者是形状为[]且数据类型为 int32、int64 的 0-D Tensor。如果  ``shape``  是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor。默认值为[1]。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，支持 int32、int64。当该参数值为 None 时， 输出 Tensor 的数据类型为 int64。默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    服从均匀分布的、范围在[``low``, ``high``)的随机 Tensor，形状为 ``shape``，数据类型为 ``dtype``。
+    服从均匀分布的、范围在[ ``low`` ,  ``high`` )的随机 Tensor，形状为  ``shape`` ，数据类型为  ``dtype`` 。
 
 代码示例
 :::::::::::
diff --git a/docs/api/paddle/randint_like_cn.rst b/docs/api/paddle/randint_like_cn.rst
index d1068134fae..601fdf64faf 100644
--- a/docs/api/paddle/randint_like_cn.rst
+++ b/docs/api/paddle/randint_like_cn.rst
@@ -5,19 +5,19 @@ randint_like
 
 .. py:function:: paddle.randint_like(x, low=0, high=None, dtype=None, name=None)
 
-返回服从均匀分布的、范围在[``low``, ``high``)的随机 Tensor，输出的形状与 x 的形状一致，当数据类型 ``dtype`` 为 None 时（默认），输出的数据类型与 x 的数据类型一致，当数据类型 ``dtype`` 不为 None 时，将输出用户指定的数据类型。当 ``high`` 为 None 时（默认），均匀采样的区间为[0, ``low``)。
+返回服从均匀分布的、范围在[ ``low`` ,  ``high`` )的随机 Tensor，输出的形状与 x 的形状一致，当数据类型  ``dtype``  为 None 时（默认），输出的数据类型与 x 的数据类型一致，当数据类型  ``dtype``  不为 None 时，将输出用户指定的数据类型。当  ``high``  为 None 时（默认），均匀采样的区间为[0,  ``low`` )。
 
 参数
 ::::::::::
-    - **x** (Tensor) – 输入的多维 Tensor，数据类型可以是 bool，int32，int64，float16，float32，float64。输出 Tensor 的形状和 ``x`` 相同。如果 ``dtype`` 为 None，则输出 Tensor 的数据类型与 ``x`` 相同。
-    - **low** (int，可选) - 要生成的随机值范围的下限，``low`` 包含在范围中。当 ``high`` 为 None 时，均匀采样的区间为[0, ``low``)。默认值为 0。
-    - **high** (int，可选) - 要生成的随机值范围的上限，``high`` 不包含在范围中。默认值为 None，此时范围是[0, ``low``)。
+    - **x** (Tensor) – 输入的多维 Tensor，数据类型可以是 bool，int32，int64，float16，float32，float64。输出 Tensor 的形状和  ``x``  相同。如果  ``dtype``  为 None，则输出 Tensor 的数据类型与  ``x``  相同。
+    - **low** (int，可选) - 要生成的随机值范围的下限， ``low``  包含在范围中。当  ``high``  为 None 时，均匀采样的区间为[0,  ``low`` )。默认值为 0。
+    - **high** (int，可选) - 要生成的随机值范围的上限， ``high``  不包含在范围中。默认值为 None，此时范围是[0,  ``low`` )。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，支持 bool，int32，int64，float16，float32，float64。当该参数值为 None 时，输出 Tensor 的数据类型与输入 Tensor 的数据类型一致。默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    Tensor：从区间[``low``，``high``)内均匀分布采样的随机 Tensor，形状为 ``x.shape``，数据类型为 ``dtype``。
+    Tensor：从区间[ ``low`` ， ``high`` )内均匀分布采样的随机 Tensor，形状为  ``x.shape`` ，数据类型为  ``dtype`` 。
 
 代码示例
 :::::::::::
diff --git a/docs/api/paddle/randn_cn.rst b/docs/api/paddle/randn_cn.rst
index 326ea3492a9..063b73a634a 100644
--- a/docs/api/paddle/randn_cn.rst
+++ b/docs/api/paddle/randn_cn.rst
@@ -5,31 +5,31 @@ randn
 
 .. py:function:: paddle.randn(shape, dtype=None, name=None, *, out=None, device=None, requires_grad=False, pin_memory=False)
 
-返回符合标准正态分布（均值为 0，标准差为 1 的正态随机分布）的随机 Tensor，形状为 ``shape``，数据类型为 ``dtype``。
+返回符合标准正态分布（均值为 0，标准差为 1 的正态随机分布）的随机 Tensor，形状为  ``shape`` ，数据类型为  ``dtype`` 。
 
 参数
 ::::::::::
 
   - **shape** (list|tuple|Tensor|*shape) - 生成的 Tensor 的形状。数据类型为 int32 或 int64。
-    如果 ``shape`` 是 list、tuple，则其中的元素可以是 int，或者是形状为 [] 且数据类型为 int32、int64 的 0-D Tensor。
-    如果 ``shape`` 是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor，表示一个列表。
-    如果 ``shape`` 是 \*shape，则可以直接以可变参数的形式传入多个整数（例如 ``randn(2, 3)``）。
-    该参数的别名为 ``size``。
+    如果  ``shape``  是 list、tuple，则其中的元素可以是 int，或者是形状为 [] 且数据类型为 int32、int64 的 0-D Tensor。
+    如果  ``shape``  是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor，表示一个列表。
+    如果  ``shape``  是 \*shape，则可以直接以可变参数的形式传入多个整数（例如  ``randn(2, 3)`` ）。
+    该参数的别名为  ``size`` 。
   - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型。
     支持的数据类型包括：float16、bfloat16、float32、float64、complex64、complex128。
-    默认值为 None，此时使用全局默认数据类型（可参考 ``get_default_dtype`` 了解详情）。
+    默认值为 None，此时使用全局默认数据类型（可参考  ``get_default_dtype``  了解详情）。
   - **name** (str，可选) - 操作的名称，具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 ::::::::::::
   - **out** (Tensor，可选) - 用于保存输出结果的 Tensor。默认值为 None。
-  - **device** (PlaceLike|None，可选) - 指定返回 Tensor 所在的设备。默认值为 None，表示使用当前全局设备（可通过 ``paddle.device.set_device`` 设置）。
+  - **device** (PlaceLike|None，可选) - 指定返回 Tensor 所在的设备。默认值为 None，表示使用当前全局设备（可通过  ``paddle.device.set_device``  设置）。
   - **requires_grad** (bool，可选) - 是否在返回的 Tensor 上记录 autograd 的操作。默认值为 False。
   - **pin_memory** (bool，可选) - 如果设置为 True，返回的 Tensor 会分配在锁页内存中。仅对 CPU Tensor 生效。默认值为 False。
 
 返回
 ::::::::::
-  Tensor：符合标准正态分布的随机 Tensor，形状为 ``shape``，数据类型为 ``dtype``。
+  Tensor：符合标准正态分布的随机 Tensor，形状为  ``shape`` ，数据类型为  ``dtype`` 。
 
 示例代码
 ::::::::::
diff --git a/docs/api/paddle/randn_like_cn.rst b/docs/api/paddle/randn_like_cn.rst
index 584635d1acd..103c3c2a2d3 100644
--- a/docs/api/paddle/randn_like_cn.rst
+++ b/docs/api/paddle/randn_like_cn.rst
@@ -9,13 +9,13 @@ randn_like
 
 参数
 ::::::::::
-    - **x** (Tensor) – 输入的多维 Tensor，数据类型可以是 float16，bfloat16，float32，float64，complex64，complex128。输出 Tensor 的形状和 ``x`` 相同。如果 ``dtype`` 为 None，则输出 Tensor 的数据类型与 ``x`` 相同。
+    - **x** (Tensor) – 输入的多维 Tensor，数据类型可以是 float16，bfloat16，float32，float64，complex64，complex128。输出 Tensor 的形状和  ``x``  相同。如果  ``dtype``  为 None，则输出 Tensor 的数据类型与  ``x``  相同。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，支持 float16，bfloat16，float32，float64，complex64，complex128。当该参数值为 None 时，输出 Tensor 的数据类型与输入 Tensor 的数据类型一致。默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    Tensor：服从均值为 0、方差为 1 的标准正态分布 Tensor，形状为 ``x.shape``，数据类型为 ``dtype``。
+    Tensor：服从均值为 0、方差为 1 的标准正态分布 Tensor，形状为  ``x.shape`` ，数据类型为  ``dtype`` 。
 
 代码示例
 :::::::::::
diff --git a/docs/api/paddle/randperm_cn.rst b/docs/api/paddle/randperm_cn.rst
index f08e981532e..39579ee7af4 100644
--- a/docs/api/paddle/randperm_cn.rst
+++ b/docs/api/paddle/randperm_cn.rst
@@ -5,7 +5,7 @@ randperm
 
 .. py:function:: paddle.randperm(n, dtype="int64", name=None)
 
-返回一个数值在 0 到 n-1、随机排列的 1-D Tensor，数据类型为 ``dtype``。
+返回一个数值在 0 到 n-1、随机排列的 1-D Tensor，数据类型为  ``dtype`` 。
 
 参数
 ::::::::::::
@@ -15,7 +15,7 @@ randperm
 
 返回
 ::::::::::
-  Tensor：一个数值在 0 到 n-1、随机排列的 1-D Tensor，数据类型为 ``dtype`` 。
+  Tensor：一个数值在 0 到 n-1、随机排列的 1-D Tensor，数据类型为  ``dtype``  。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/range_cn.rst b/docs/api/paddle/range_cn.rst
index c44c9739fc3..f25c10abe66 100644
--- a/docs/api/paddle/range_cn.rst
+++ b/docs/api/paddle/range_cn.rst
@@ -5,26 +5,26 @@ range
 
 .. py:function:: paddle.range(start=0, end=None, step=1, dtype=None, *, out=None, device=None, requires_grad=False, name=None)
 
-返回一个形状为 [$\lfloor \dfrac{end-start}{step} \rfloor + 1$] 的 1-D Tensor(对应 **闭区间** [ ``start`` , ``end`` ])，数据类型为 ``dtype`` 。
+返回一个形状为 [$\lfloor \dfrac{end-start}{step} \rfloor + 1$] 的 1-D Tensor(对应 **闭区间** [  ``start``  ,  ``end``  ])，数据类型为  ``dtype``  。
 
 参数
 ::::::::::
 
-  - **start** (float|int|Tensor) - 区间起点（且区间包括此值）。当 ``start`` 类型是 Tensor 时，是形状为[]且数据类型为 int32、int64、float32、float64 的 0-D Tensor。如果仅指定 ``start``，而 ``end`` 为 None，则区间为[0, ``start``)。默认值为 0。
-  - **end** (float|int|Tensor，可选) - 区间终点（且通常区间不包括此值）。当 ``end`` 类型是 Tensor 时，是形状为[]且数据类型为 int32、int64、float32、float64 的 0-D Tensor。默认值为 None。
-  - **step** (float|int|Tensor，可选) - 均匀分割的步长。当 ``step`` 类型是 Tensor 时，是形状为[]且数据类型为 int32、int64、float32、float64 的 0-D Tensor。默认值为 1。
+  - **start** (float|int|Tensor) - 区间起点（且区间包括此值）。当  ``start``  类型是 Tensor 时，是形状为[]且数据类型为 int32、int64、float32、float64 的 0-D Tensor。如果仅指定  ``start`` ，而  ``end``  为 None，则区间为[0,  ``start`` )。默认值为 0。
+  - **end** (float|int|Tensor，可选) - 区间终点（且通常区间不包括此值）。当  ``end``  类型是 Tensor 时，是形状为[]且数据类型为 int32、int64、float32、float64 的 0-D Tensor。默认值为 None。
+  - **step** (float|int|Tensor，可选) - 均匀分割的步长。当  ``step``  类型是 Tensor 时，是形状为[]且数据类型为 int32、int64、float32、float64 的 0-D Tensor。默认值为 1。
   - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，支持 int32、int64、float32、float64。当该参数值为 None 时，输出 Tensor 的数据类型为 int64。默认值为 None。
 
 关键字参数
 ::::::::::::
   - **out** (Tensor，可选) - 用于存储结果的 Tensor。若指定，将直接写入该 Tensor，默认值为 None。
-  - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。默认值为 None，表示使用当前全局设备（可通过 ``paddle.device.set_device`` 设置）。
+  - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。默认值为 None，表示使用当前全局设备（可通过  ``paddle.device.set_device``  设置）。
   - **requires_grad** (bool，可选) - 是否需要为返回的 Tensor 记录梯度信息。默认值为 False。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-  返回一个形状为 [$\lfloor \dfrac{end-start}{step} \rfloor + 1$] 的 1-D Tensor(对应 **闭区间** [ ``start`` , ``end`` ])，数据类型为 ``dtype`` 。
+  返回一个形状为 [$\lfloor \dfrac{end-start}{step} \rfloor + 1$] 的 1-D Tensor(对应 **闭区间** [  ``start``  ,  ``end``  ])，数据类型为  ``dtype``  。
 
 
 代码示例
diff --git a/docs/api/paddle/regularizer/L1Decay_cn.rst b/docs/api/paddle/regularizer/L1Decay_cn.rst
index 0eb12e5fc76..c1ce7d2da2b 100644
--- a/docs/api/paddle/regularizer/L1Decay_cn.rst
+++ b/docs/api/paddle/regularizer/L1Decay_cn.rst
@@ -7,11 +7,11 @@ L1Decay
 
 L1Decay 实现 L1 权重衰减正则化，用于模型训练，使得权重矩阵稀疏。
 
-该类生成的实例对象，需要设置在 :ref:`cn_api_paddle_ParamAttr` 或者 ``optimizer``
-(例如 :ref:`cn_api_paddle_optimizer_Momentum` )中，在 ``ParamAttr`` 中设置时，只对该
-网络层中的可训练参数生效；在 ``optimizer`` 中设置时，会对所有的可训练参数生效；如果同时设置，在
-``ParamAttr`` 中设置的优先级会高于在 ``optimizer`` 中的设置，即，对于一个可训练的参数，如果在
-``ParamAttr`` 中定义了正则化，那么会忽略 ``optimizer`` 中的正则化；否则会使用 ``optimizer``中的
+该类生成的实例对象，需要设置在 :ref:`cn_api_paddle_ParamAttr` 或者  ``optimizer`` 
+(例如 :ref:`cn_api_paddle_optimizer_Momentum` )中，在  ``ParamAttr``  中设置时，只对该
+网络层中的可训练参数生效；在  ``optimizer``  中设置时，会对所有的可训练参数生效；如果同时设置，在
+ ``ParamAttr``  中设置的优先级会高于在  ``optimizer``  中的设置，即，对于一个可训练的参数，如果在
+ ``ParamAttr``  中定义了正则化，那么会忽略  ``optimizer``  中的正则化；否则会使用  ``optimizer`` 中的
 正则化。
 
 具体实现中，L1 权重衰减正则化的损失函数计算如下：
diff --git a/docs/api/paddle/regularizer/L2Decay_cn.rst b/docs/api/paddle/regularizer/L2Decay_cn.rst
index a65af545fae..197ca4026a3 100644
--- a/docs/api/paddle/regularizer/L2Decay_cn.rst
+++ b/docs/api/paddle/regularizer/L2Decay_cn.rst
@@ -8,11 +8,11 @@ L2Decay
 
 L2Decay 实现 L2 权重衰减正则化，用于模型训练，有助于防止模型对训练数据过拟合。
 
-该类生成的实例对象，需要设置在 :ref:`cn_api_paddle_ParamAttr` 或者 ``optimizer``
-(例如 :ref:`cn_api_paddle_optimizer_Momentum` )中，在 ``ParamAttr`` 中设置时，
-只对该网络层中的参数生效；在 ``optimizer`` 中设置时，会对所有的参数生效；如果同时设置，
-在 ``ParamAttr`` 中设置的优先级会高于在 ``optimizer`` 中设置，即，对于一个可训练的参数，如果在
-``ParamAttr`` 中定义了正则化，那么会忽略 ``optimizer`` 中的正则化；否则会使用 ``optimizer`` 中的
+该类生成的实例对象，需要设置在 :ref:`cn_api_paddle_ParamAttr` 或者  ``optimizer`` 
+(例如 :ref:`cn_api_paddle_optimizer_Momentum` )中，在  ``ParamAttr``  中设置时，
+只对该网络层中的参数生效；在  ``optimizer``  中设置时，会对所有的参数生效；如果同时设置，
+在  ``ParamAttr``  中设置的优先级会高于在  ``optimizer``  中设置，即，对于一个可训练的参数，如果在
+ ``ParamAttr``  中定义了正则化，那么会忽略  ``optimizer``  中的正则化；否则会使用  ``optimizer``  中的
 正则化。
 
 具体实现中，L2 权重衰减正则化的损失函数计算如下：
diff --git a/docs/api/paddle/remainder_cn.rst b/docs/api/paddle/remainder_cn.rst
index 35d0411a9e8..d70a49ebefa 100644
--- a/docs/api/paddle/remainder_cn.rst
+++ b/docs/api/paddle/remainder_cn.rst
@@ -12,26 +12,26 @@ remainder
         \\out = x \% y\\
 
 .. note::
-    ``paddle.remainder`` 支持广播，如您想了解更多，请参见 `Tensor 介绍`_ .
+     ``paddle.remainder``  支持广播，如您想了解更多，请参见 `Tensor 介绍`_ .
 
     .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``， ``other`` 可替代 ``y``;
+    别名支持: 参数名  ``input``  可替代  ``x`` ，  ``other``  可替代  ``y`` ;
 
 参数
 :::::::::
 
   - **x** (Tensor) - 多维 Tensor。数据类型为 bfloat16 、float16 、float32 、float64、int32 或 int64。
-    ``别名：input``
+     ``别名：input`` 
   - **y** (Tensor) - 多维 Tensor。数据类型为 bfloat16 、float16 、float32 、float64、int32 或 int64。
-    ``别名：other``
+     ``别名：other`` 
   - **name** (str，可选)  - 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为 None。
   - **out** (Tensor，可选) - 输出的结果。该参数为仅关键字参数，默认值为 None。
 
 返回
 :::::::::
-``Tensor``，存储运算后的结果。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
+ ``Tensor`` ，存储运算后的结果。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/renorm_cn.rst b/docs/api/paddle/renorm_cn.rst
index 6edceeabead..a07ec8070cc 100644
--- a/docs/api/paddle/renorm_cn.rst
+++ b/docs/api/paddle/renorm_cn.rst
@@ -17,7 +17,7 @@ renorm
 
 返回
 :::::::::
-``Tensor``，经过 renorm 处理的张量。
+ ``Tensor`` ，经过 renorm 处理的张量。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/repeat_interleave_cn.rst b/docs/api/paddle/repeat_interleave_cn.rst
index c294928a37a..ece170f5322 100644
--- a/docs/api/paddle/repeat_interleave_cn.rst
+++ b/docs/api/paddle/repeat_interleave_cn.rst
@@ -4,16 +4,16 @@ repeat_interleave
 -------------------------------
 
 .. py:function:: paddle.repeat_interleave(x, repeats, axis=None, name=None, *, output_size=None)
-沿着指定轴 ``axis`` 对输入 ``x`` 进行复制，创建并返回到一个新的 Tensor。当 ``repeats`` 为 ``1-D`` Tensor 时，``repeats``  长度必须和指定轴 ``axis`` 维度一致，``repeats`` 对应位置的值表示 ``x`` 对应位置元素需要复制的次数。当 ``repeats`` 为 int 时，``x`` 沿指定轴 ``axis`` 上所有元素复制 ``repeats`` 次。
+沿着指定轴  ``axis``  对输入  ``x``  进行复制，创建并返回到一个新的 Tensor。当  ``repeats``  为  ``1-D``  Tensor 时， ``repeats``   长度必须和指定轴  ``axis``  维度一致， ``repeats``  对应位置的值表示  ``x``  对应位置元素需要复制的次数。当  ``repeats``  为 int 时， ``x``  沿指定轴  ``axis``  上所有元素复制  ``repeats``  次。
 
 
 **示例一图解说明**：
-以下图为例，输入张量 ``[[1, 2, 3], [4, 5, 6]]``，重复次数 ``repeats`` 为 [3, 2, 1]，参数 ``axis =1``，表示第 1 列元素重复 3 次，第 2 列重复 2 次，第 3 列重复 1 次。
+以下图为例，输入张量  ``[[1, 2, 3], [4, 5, 6]]`` ，重复次数  ``repeats``  为 [3, 2, 1]，参数  ``axis =1`` ，表示第 1 列元素重复 3 次，第 2 列重复 2 次，第 3 列重复 1 次。
 
-最终输出为二维张量 ``[[1, 1, 1, 2, 2, 3], [4, 4, 4, 5, 5, 6]]``。
+最终输出为二维张量  ``[[1, 1, 1, 2, 2, 3], [4, 4, 4, 5, 5, 6]]`` 。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``， ``dim`` 可替代 ``axis``；
+    别名支持: 参数名  ``input``  可替代  ``x`` ，  ``dim``  可替代  ``axis`` ；
 
     .. figure:: ../../images/api_legend/repeat_interleave.png
        :width: 500
@@ -21,15 +21,15 @@ repeat_interleave
        :align: center
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x`` 和 ``dim`` 可替代 ``axis``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``， ``dim=1`` 等价于 ``axis=1``。
+    别名支持: 参数名  ``input``  可替代  ``x``  和  ``dim``  可替代  ``axis`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` ，  ``dim=1``  等价于  ``axis=1`` 。
 
 参数
 :::::::::
-    - **x** （Tensor）– 输入 Tensor。 ``x`` 的数据类型可以是 float32，float64，int32，int64。
-      别名： ``input``
+    - **x** （Tensor）– 输入 Tensor。  ``x``  的数据类型可以是 float32，float64，int32，int64。
+      别名：  ``input`` 
     - **repeats** （Tensor, int）– 包含复制次数的 1-D Tensor 或指定的复制次数。
-    - **axis**    (int，可选) – 指定对输入 ``x`` 进行运算的轴，若未指定，默认值为 None，使用输入 Tensor 的 flatten 形式。
-      别名： ``dim``
+    - **axis**    (int，可选) – 指定对输入  ``x``  进行运算的轴，若未指定，默认值为 None，使用输入 Tensor 的 flatten 形式。
+      别名：  ``dim`` 
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
     - **output_size** (int64，可选) – 关键字参数。输出 Tensor 的总大小，用于优化内存分配。若未指定，默认值为 None。
 
diff --git a/docs/api/paddle/reshape_cn.rst b/docs/api/paddle/reshape_cn.rst
index 39e121d9233..72518cb34ad 100644
--- a/docs/api/paddle/reshape_cn.rst
+++ b/docs/api/paddle/reshape_cn.rst
@@ -6,7 +6,7 @@ reshape
 .. py:function::  paddle.reshape(x, shape, name=None)
 
 
-在保持输入 ``x`` 数据不变的情况下，改变 ``x`` 的形状。
+在保持输入  ``x``  数据不变的情况下，改变  ``x``  的形状。
 
 请注意，在动态图模式下，输出 Tensor 将与输入 Tensor 共享数据，并且没有 Tensor 数据拷贝的过程。
 如果不希望输入与输出共享数据，请使用 `Tensor.clone`，例如 `reshape_clone_x = x.reshape([-1]).clone()` 。
@@ -29,19 +29,19 @@ reshape
    :alt: 图例
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``reshape(input=tensor_x, ...)`` 等价于 ``reshape(x=tensor_x, ...)``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``reshape(input=tensor_x, ...)``  等价于  ``reshape(x=tensor_x, ...)`` 。
 
 参数
 ::::::::::::
 
-  - **x** (Tensor) - N-D ``Tensor``，数据类型为 ``float16``, ``float32``, ``float64``, ``int16``, ``int32``, ``int64``, ``int8``, ``uint8``, ``complex64``, ``complex128``, ``bfloat16`` 或 ``bool``。别名： ``input``。
-  - **shape** (list|tuple|Tensor|*shape) - 数据类型是 ``int32``。定义目标形状。目标形状最多只能有一个维度为-1。如果 ``shape`` 的类型是 list 或 tuple，它的元素可以是整数或者形状为[]的 ``Tensor``。如果 ``shape`` 的类型是 ``Tensor``，则是 1-D 的 ``Tensor``。 如果是 ``shape`` 是 \*shape，则直接以可变长参数形式传入整数（例如 ``reshape(tensor_x, 2, 3)``）。
+  - **x** (Tensor) - N-D  ``Tensor`` ，数据类型为  ``float16`` ,  ``float32`` ,  ``float64`` ,  ``int16`` ,  ``int32`` ,  ``int64`` ,  ``int8`` ,  ``uint8`` ,  ``complex64`` ,  ``complex128`` ,  ``bfloat16``  或  ``bool`` 。别名：  ``input`` 。
+  - **shape** (list|tuple|Tensor|*shape) - 数据类型是  ``int32`` 。定义目标形状。目标形状最多只能有一个维度为-1。如果  ``shape``  的类型是 list 或 tuple，它的元素可以是整数或者形状为[]的  ``Tensor`` 。如果  ``shape``  的类型是  ``Tensor`` ，则是 1-D 的  ``Tensor`` 。 如果是  ``shape``  是 \*shape，则直接以可变长参数形式传入整数（例如  ``reshape(tensor_x, 2, 3)`` ）。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
 
-``Tensor``，改变形状后的 ``Tensor``，数据类型与 ``x`` 相同。
+ ``Tensor`` ，改变形状后的  ``Tensor`` ，数据类型与  ``x``  相同。
 
 
 代码示例
diff --git a/docs/api/paddle/roll_cn.rst b/docs/api/paddle/roll_cn.rst
index 79d97b7283b..880453ec6af 100644
--- a/docs/api/paddle/roll_cn.rst
+++ b/docs/api/paddle/roll_cn.rst
@@ -8,33 +8,33 @@ roll
 
 
 
-沿着指定维度 ``axis`` 对输入 ``x`` 进行循环滚动，当元素移动到最后位置时，会从第一个位置重新插入。如果 ``axis`` 为 ``None``，则输入在被循环滚动之前，会先展平成 ``1-D Tensor``，滚动操作完成后恢复成原来的形状。
+沿着指定维度  ``axis``  对输入  ``x``  进行循环滚动，当元素移动到最后位置时，会从第一个位置重新插入。如果  ``axis``  为  ``None`` ，则输入在被循环滚动之前，会先展平成  ``1-D Tensor`` ，滚动操作完成后恢复成原来的形状。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x`` 和 ``dim`` 可替代 ``axis``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``， ``dim=1`` 等价于 ``axis=1``。
+    别名支持: 参数名  ``input``  可替代  ``x``  和  ``dim``  可替代  ``axis`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` ，  ``dim=1``  等价于  ``axis=1`` 。
 
 参数
 :::::::::
 
     - **x** （Tensor）– 输入的 Tensor。
-      别名： ``input``
-    - **shifts** (int|list|tuple) - 滚动位移。如果 ``shifts`` 是一个元组或者列表，则 ``axis`` 必须是相同大小的元组或者列表，输入 Tensor 将依次沿着每个维度滚动相应的数值。
+      别名：  ``input`` 
+    - **shifts** (int|list|tuple) - 滚动位移。如果  ``shifts``  是一个元组或者列表，则  ``axis``  必须是相同大小的元组或者列表，输入 Tensor 将依次沿着每个维度滚动相应的数值。
     - **axis** (int|list|tuple，可选) – 滚动轴。默认值为 None。
-      别名： ``dim``
+      别名：  ``dim`` 
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
-下图展示了一个形状为 ``[[1,2,3],[4,5,6],[7,8,9]]`` 的二维张量通过 ``roll`` 操作转变为形状不同的张量。
+下图展示了一个形状为  ``[[1,2,3],[4,5,6],[7,8,9]]``  的二维张量通过  ``roll``  操作转变为形状不同的张量。
 
 .. image:: ../../images/api_legend/roll.png
     :width: 700
     :align: center
     :alt: 图例
 
-- 当 ``axis = None`` 时，张量会被展平成一维，然后进行循环滚动，再恢复原状
-- 当 ``axis=0`` 时，张量沿着 0 轴方向进行循环滚动
-- 当 ``axis=1`` 时，张量沿着 1 轴方向进行循环滚动
+- 当  ``axis = None``  时，张量会被展平成一维，然后进行循环滚动，再恢复原状
+- 当  ``axis=0``  时，张量沿着 0 轴方向进行循环滚动
+- 当  ``axis=1``  时，张量沿着 1 轴方向进行循环滚动
 
-由于 ``axis`` 参数的取值不同，对应的滚动操作也不同，由图可以看到每个元素在不同滚动操作下的位置变化。
+由于  ``axis``  参数的取值不同，对应的滚动操作也不同，由图可以看到每个元素在不同滚动操作下的位置变化。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/row_stack_cn.rst b/docs/api/paddle/row_stack_cn.rst
index 9ba489aa91b..62b26d2ebcc 100644
--- a/docs/api/paddle/row_stack_cn.rst
+++ b/docs/api/paddle/row_stack_cn.rst
@@ -5,7 +5,7 @@ row_stack
 
 .. py:function:: paddle.row_stack(x, name=None)
 
-:ref:`cn_api_paddle_vstack` 的别名。沿垂直轴堆叠输入 ``x`` 中的所有张量。所有张量必须具有相同的数据类型。
+:ref:`cn_api_paddle_vstack` 的别名。沿垂直轴堆叠输入  ``x``  中的所有张量。所有张量必须具有相同的数据类型。
 
 下图展示了一个 row_stack 的情形，将一个形状为（1，3）的二维张量与另一个同样形状为（1，3），但是数据内容不同的二维张量进行 row_stack 操作，二者沿垂直轴堆叠成一个新的二维向量。通过图例能很好看出张量的变化。
 
@@ -16,7 +16,7 @@ row_stack
 参数
 ::::::::::::
 
-    - **x** (list[Tensor]|tuple[Tensor]) - 输入 ``x`` 可以是张量的 list 或 tuple， ``x`` 中张量的数据类型必须相同。支持的数据类型： ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 、 ``int64`` 或 ``bfloat16`` 。
+    - **x** (list[Tensor]|tuple[Tensor]) - 输入  ``x``  可以是张量的 list 或 tuple，  ``x``  中张量的数据类型必须相同。支持的数据类型：  ``float16``  、  ``float32``  、  ``float64``  、  ``int32``  、  ``int64``  或  ``bfloat16``  。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/rsqrt_cn.rst b/docs/api/paddle/rsqrt_cn.rst
index d9c2989a4be..a6dc82c0e75 100644
--- a/docs/api/paddle/rsqrt_cn.rst
+++ b/docs/api/paddle/rsqrt_cn.rst
@@ -21,13 +21,13 @@ rsqrt 激活函数。
 参数
 ::::::::::::
 
-    - **x** (Tensor) – 输入是多维 Tensor，数据类型可以是 float32 和 float64。别名 ``input``。
+    - **x** (Tensor) – 输入是多维 Tensor，数据类型可以是 float32 和 float64。别名  ``input`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/save_cn.rst b/docs/api/paddle/save_cn.rst
index 78e91871254..ff20c9ba35a 100644
--- a/docs/api/paddle/save_cn.rst
+++ b/docs/api/paddle/save_cn.rst
@@ -8,12 +8,12 @@ save
 将对象实例 obj 保存到指定的路径中。
 
 .. note::
-    目前支持保存：Layer 或者 Optimizer 的 ``state_dict``，Tensor 以及包含 Tensor 的嵌套 list、tuple、dict，Program。对于 Tensor 对象，只保存了它的名字和数值，没有保存 stop_gradient 等属性，如果您需要这些没有保存的属性，请调用 set_value 接口将数值设置到带有这些属性的 Tensor 中。
+    目前支持保存：Layer 或者 Optimizer 的  ``state_dict`` ，Tensor 以及包含 Tensor 的嵌套 list、tuple、dict，Program。对于 Tensor 对象，只保存了它的名字和数值，没有保存 stop_gradient 等属性，如果您需要这些没有保存的属性，请调用 set_value 接口将数值设置到带有这些属性的 Tensor 中。
 
 .. note::
-    不同于 ``paddle.jit.save``，由于 ``paddle.save`` 的存储结果是单个文件，所以不需要通过添加后缀的方式区分多个存储文件，``paddle.save`` 的输入参数 ``path`` 将直接作为存储结果的文件名而非前缀。为了统一存储文件名的格式，我们推荐使用 paddle 标椎文件后缀：
-    1. 对于 ``Layer.state_dict``，推荐使用后缀 ``.pdparams`` ；
-    2. 对于 ``Optimizer.state_dict``，推荐使用后缀 ``.pdopt`` 。
+    不同于  ``paddle.jit.save`` ，由于  ``paddle.save``  的存储结果是单个文件，所以不需要通过添加后缀的方式区分多个存储文件， ``paddle.save``  的输入参数  ``path``  将直接作为存储结果的文件名而非前缀。为了统一存储文件名的格式，我们推荐使用 paddle 标椎文件后缀：
+    1. 对于  ``Layer.state_dict`` ，推荐使用后缀  ``.pdparams``  ；
+    2. 对于  ``Optimizer.state_dict`` ，推荐使用后缀  ``.pdopt``  。
     具体示例请参考 API 的代码示例。
 
 
@@ -29,7 +29,7 @@ save
     - **obj**  (Object) – 要保存的对象实例。
     - **path**  (str|BytesIO) – 保存对象实例的路径/内存对象。如果存储到当前路径，输入的 path 字符串将会作为保存的文件名。
     - **protocol**  (int，可选) – pickle 模块的协议版本，默认值为 4，取值范围是[2,4]。
-    - **configs**  (dict，可选) – 其他配置选项，目前支持以下选项：（1）use_binary_format（bool）- 如果被保存的对象是静态图的 Tensor，你可以指定这个参数。如果被指定为 ``True``，这个 Tensor 会被保存为由 paddle 定义的二进制格式的文件；否则这个 Tensor 被保存为 pickle 格式。默认为 ``False`` 。
+    - **configs**  (dict，可选) – 其他配置选项，目前支持以下选项：（1）use_binary_format（bool）- 如果被保存的对象是静态图的 Tensor，你可以指定这个参数。如果被指定为  ``True`` ，这个 Tensor 会被保存为由 paddle 定义的二进制格式的文件；否则这个 Tensor 被保存为 pickle 格式。默认为  ``False``  。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/scale_cn.rst b/docs/api/paddle/scale_cn.rst
index 0e54add08ea..364eaf0538d 100644
--- a/docs/api/paddle/scale_cn.rst
+++ b/docs/api/paddle/scale_cn.rst
@@ -7,12 +7,12 @@ scale
 
 对输入 Tensor 进行缩放和偏置，其公式如下：
 
-``bias_after_scale`` 为 True:
+ ``bias_after_scale``  为 True:
 
 .. math::
                         Out=scale*X+bias
 
-``bias_after_scale`` 为 False:
+ ``bias_after_scale``  为 False:
 
 .. math::
                         Out=scale*(X+bias)
diff --git a/docs/api/paddle/scatter_cn.rst b/docs/api/paddle/scatter_cn.rst
index 6ddecac3d2d..264a7f2e9f3 100644
--- a/docs/api/paddle/scatter_cn.rst
+++ b/docs/api/paddle/scatter_cn.rst
@@ -15,9 +15,9 @@ scatter
 .. py:function:: paddle.scatter(x, index, updates, overwrite=True, name=None)
 
 
-通过基于 ``updates`` 来更新选定索引 ``index`` 上的输入来获得输出。具体行为如下：
+通过基于  ``updates``  来更新选定索引  ``index``  上的输入来获得输出。具体行为如下：
 
-如下图，当 overwrite 为 True 的时候使用覆盖模式更新相同索引的输出，依次将 ``x[index[i]]`` 更新为 ``update[i]`` ；而当 overwrite 为 False 时使用累加模式更新相同索引的输出，先依次将 ``x[index[i]]`` 更新为与该行大小相同的元素值均为 0 的 Tensor ，再依次将 ``update[i]`` 加到 ``x[index[i]]`` 产生输出。
+如下图，当 overwrite 为 True 的时候使用覆盖模式更新相同索引的输出，依次将  ``x[index[i]]``  更新为  ``update[i]``  ；而当 overwrite 为 False 时使用累加模式更新相同索引的输出，先依次将  ``x[index[i]]``  更新为与该行大小相同的元素值均为 0 的 Tensor ，再依次将  ``update[i]``  加到  ``x[index[i]]``  产生输出。
 
 .. image:: ../../images/api_legend/scatter.png
    :alt: 图例- scatter 的行为展示
@@ -25,15 +25,15 @@ scatter
 COPY-FROM: paddle.scatter:scatter-example-1
 
 **Notice：**
-因为 ``updates`` 的应用顺序是不确定的，因此，如果索引 ``index`` 包含重复项，则输出将具有不确定性。
+因为  ``updates``  的应用顺序是不确定的，因此，如果索引  ``index``  包含重复项，则输出将具有不确定性。
 
 
 参数
 :::::::::
-    - **x** （Tensor） - ``ndim>= 1`` 的输入 N-D Tensor。数据类型可以是 float32，float64。
-    - **index** （Tensor）- 一维或者零维 Tensor。数据类型可以是 int32，int64。 ``index`` 的长度不能超过 ``updates`` 的长度，并且 ``index`` 中的值不能超过输入的长度。
-    - **updates** （Tensor）- 根据 ``index`` 使用 ``update`` 参数更新输入 ``x``。当 ``index`` 为一维 tensor 时，``updates`` 形状应与输入 ``x`` 相同，并且 ``dim>1`` 的 dim 值应与输入 ``x`` 相同。当 ``index`` 为零维 tensor 时，``updates`` 应该是一个 ``(N-1)-D`` 的 Tensor，并且 ``updates`` 的第 i 个维度应该与 ``x`` 的 ``i+1`` 个维度相同。
-    - **overwrite** （bool，可选）- 指定索引 ``index`` 相同时，更新输出的方式。如果为 True，则使用覆盖模式更新相同索引的输出，如果为 False，则使用累加模式更新相同索引的输出。默认值为 True。
+    - **x** （Tensor） -  ``ndim>= 1``  的输入 N-D Tensor。数据类型可以是 float32，float64。
+    - **index** （Tensor）- 一维或者零维 Tensor。数据类型可以是 int32，int64。  ``index``  的长度不能超过  ``updates``  的长度，并且  ``index``  中的值不能超过输入的长度。
+    - **updates** （Tensor）- 根据  ``index``  使用  ``update``  参数更新输入  ``x`` 。当  ``index``  为一维 tensor 时， ``updates``  形状应与输入  ``x``  相同，并且  ``dim>1``  的 dim 值应与输入  ``x``  相同。当  ``index``  为零维 tensor 时， ``updates``  应该是一个  ``(N-1)-D``  的 Tensor，并且  ``updates``  的第 i 个维度应该与  ``x``  的  ``i+1``  个维度相同。
+    - **overwrite** （bool，可选）- 指定索引  ``index``  相同时，更新输出的方式。如果为 True，则使用覆盖模式更新相同索引的输出，如果为 False，则使用累加模式更新相同索引的输出。默认值为 True。
     - **name** （str，可选） - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
@@ -51,15 +51,15 @@ COPY-FROM: paddle.scatter:scatter-example-2
 
 .. py:function:: paddle.scatter(input, dim, index, src, reduce=None, out=None)
 
-PyTorch 兼容的 scatter 函数。基于 :ref:`cn_api_paddle_put_along_axis` 实现，等效于 ``paddle.put_along_axis(..., broadcast=False)``。详细的用法见 :ref:`cn_api_paddle_put_along_axis`。
+PyTorch 兼容的 scatter 函数。基于 :ref:`cn_api_paddle_put_along_axis` 实现，等效于  ``paddle.put_along_axis(..., broadcast=False)`` 。详细的用法见 :ref:`cn_api_paddle_put_along_axis`。
 
 参数
 :::::::::
     - **input** （Tensor） - 输入 N-D Tensor。数据类型可以是 float32，float64，float16，bfloat16，int32，int64，int16，uint8。
-    - **dim** （int） - 进行 scatter 操作的维度，范围为 ``[-input.ndim, input.ndim)``。
-    - **index** （Tensor）- 索引矩阵，包含沿轴提取 1d 切片的下标，必须和 arr 矩阵有相同的维度。注意，除了 ``dim`` 维度外， ``index`` 张量的各维度大小应该小于等于 ``input`` 以及 ``src`` 张量。内部的值应该在 ``input.shape[dim]`` 范围内。数据类型可以是 int32，int64。
-    - **src** （Tensor）- 需要插入的值。``src`` 是张量时，各维度大小需要至少大于等于 ``index`` 各维度。不受到 ``input`` 的各维度约束。当为标量值时，会自动广播大小到 ``index``。数据类型为：bfloat16、float16、float32、float64、int32、int64、uint8、int16。本参数有一个互斥的别名 ``value``。
-    - **reduce** （str，可选）- 指定 scatter 的归约方式。默认值为 None，等效为 ``assign``。可选为 ``add``、 ``multiple``、 ``mean``、 ``amin``、 ``amax``。不同的规约操作插入值 src 对于输入矩阵 arr 会有不同的行为，如为 ``assgin`` 则覆盖输入矩阵， ``add`` 则累加至输入矩阵， ``mean`` 则计算累计平均值至输入矩阵， ``multiple`` 则累乘至输入矩阵， ``amin`` 则计算累计最小值至输入矩阵， ``amax`` 则计算累计最大值至输入矩阵。
+    - **dim** （int） - 进行 scatter 操作的维度，范围为  ``[-input.ndim, input.ndim)`` 。
+    - **index** （Tensor）- 索引矩阵，包含沿轴提取 1d 切片的下标，必须和 arr 矩阵有相同的维度。注意，除了  ``dim``  维度外，  ``index``  张量的各维度大小应该小于等于  ``input``  以及  ``src``  张量。内部的值应该在  ``input.shape[dim]``  范围内。数据类型可以是 int32，int64。
+    - **src** （Tensor）- 需要插入的值。 ``src``  是张量时，各维度大小需要至少大于等于  ``index``  各维度。不受到  ``input``  的各维度约束。当为标量值时，会自动广播大小到  ``index`` 。数据类型为：bfloat16、float16、float32、float64、int32、int64、uint8、int16。本参数有一个互斥的别名  ``value`` 。
+    - **reduce** （str，可选）- 指定 scatter 的归约方式。默认值为 None，等效为  ``assign`` 。可选为  ``add`` 、  ``multiple`` 、  ``mean`` 、  ``amin`` 、  ``amax`` 。不同的规约操作插入值 src 对于输入矩阵 arr 会有不同的行为，如为  ``assgin``  则覆盖输入矩阵，  ``add``  则累加至输入矩阵，  ``mean``  则计算累计平均值至输入矩阵，  ``multiple``  则累乘至输入矩阵，  ``amin``  则计算累计最小值至输入矩阵，  ``amax``  则计算累计最大值至输入矩阵。
     - **out** (Tensor，可选) - 用于引用式传入输出值，注意：动态图下 out 可以是任意 Tensor，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/searchsorted_cn.rst b/docs/api/paddle/searchsorted_cn.rst
index 318be10795b..c6c55306720 100644
--- a/docs/api/paddle/searchsorted_cn.rst
+++ b/docs/api/paddle/searchsorted_cn.rst
@@ -5,19 +5,19 @@ searchsorted
 
 .. py:function:: paddle.searchsorted(sorted_sequence, values, out_int32=False, right=False, name=None)
 
-根据给定的 ``values`` 在 ``sorted_sequence`` 的最后一个维度查找合适的索引。
+根据给定的  ``values``  在  ``sorted_sequence``  的最后一个维度查找合适的索引。
 
 参数
 ::::::::
     - **sorted_sequence** (Tensor) - 输入的 N 维或一维 Tensor，支持的数据类型：bfloat16、float16、float32、float64、int32、int64。该 Tensor 的数值在其最后一个维度递增。
     - **values** (Tensor) - 输入的 N 维 Tensor，支持的数据类型：bfloat16、float16、float32、float64、int32、int64。
     - **out_int32** (bool，可选) - 输出的数据类型支持 int32、int64。默认值为 False，表示默认的输出数据类型为 int64。
-    - **right** (bool，可选) - 根据给定 ``values`` 在 ``sorted_sequence`` 查找对应的上边界或下边界。如果 ``sorted_sequence``的值为 nan 或 inf，则返回最内层维度的大小。默认值为 False，表示在 ``sorted_sequence`` 的查找给定 ``values`` 的下边界。
+    - **right** (bool，可选) - 根据给定  ``values``  在  ``sorted_sequence``  查找对应的上边界或下边界。如果  ``sorted_sequence`` 的值为 nan 或 inf，则返回最内层维度的大小。默认值为 False，表示在  ``sorted_sequence``  的查找给定  ``values``  的下边界。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::
-Tensor(与 ``values`` 维度相同)，如果参数 ``out_int32`` 为 False，则返回数据类型为 int64 的 Tensor，否则将返回 int32 的 Tensor。
+Tensor(与  ``values``  维度相同)，如果参数  ``out_int32``  为 False，则返回数据类型为 int64 的 Tensor，否则将返回 int32 的 Tensor。
 
 
 
diff --git a/docs/api/paddle/select_scatter_cn.rst b/docs/api/paddle/select_scatter_cn.rst
index e7ebd798340..9a97ba5970c 100644
--- a/docs/api/paddle/select_scatter_cn.rst
+++ b/docs/api/paddle/select_scatter_cn.rst
@@ -4,20 +4,20 @@ select_scatter
 -------------------------------
 
 .. py:function:: paddle.select_scatter(x, values, axis, index, name=None)
-将 ``values`` 矩阵的值嵌入到 ``x`` 矩阵的第 ``axis`` 维的 ``index`` 列
+将  ``values``  矩阵的值嵌入到  ``x``  矩阵的第  ``axis``  维的  ``index``  列
 
 参数
 :::::::::
     - **x**  (Tensor) - 输入的 Tensor 作为目标矩阵，数据类型为： `bool`、 `float16`、 `float32`、 `float64`、 `uint8`、 `int8`、 `int16`、 `int32`、 `int64`、 `bfloat16`、 `complex64`、 `complex128`。
-    - **values**  (Tensor) - 需要插入的值，形状需要与 ``x`` 矩阵除去第 ``axis`` 维后的形状一致，数据类型为： `bool`、 `float16`、 `float32`、 `float64`、 `uint8`、 `int8`、 `int16`、 `int32`、 `int64`、 `bfloat16`、 `complex64`、 `complex128`。
+    - **values**  (Tensor) - 需要插入的值，形状需要与  ``x``  矩阵除去第  ``axis``  维后的形状一致，数据类型为： `bool`、 `float16`、 `float32`、 `float64`、 `uint8`、 `int8`、 `int16`、 `int32`、 `int64`、 `bfloat16`、 `complex64`、 `complex128`。
     - **axis**  (int) - 指定沿着哪个维度嵌入对应的值，数据类型为：int。
-    - **index**  (int) - 指定沿着 ``axis`` 维的哪一列嵌入对应的值，数据类型为：int。
+    - **index**  (int) - 指定沿着  ``axis``  维的哪一列嵌入对应的值，数据类型为：int。
     - **name**  (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
 
-输出 Tensor， ``x`` 矩阵的第 ``axis`` 维的第 ``index`` 列会被插入 ``value``，与 ``x`` 数据类型相同。
+输出 Tensor，  ``x``  矩阵的第  ``axis``  维的第  ``index``  列会被插入  ``value`` ，与  ``x``  数据类型相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/set_printoptions_cn.rst b/docs/api/paddle/set_printoptions_cn.rst
index 4eb3c94a77f..1823ec30fba 100644
--- a/docs/api/paddle/set_printoptions_cn.rst
+++ b/docs/api/paddle/set_printoptions_cn.rst
@@ -7,7 +7,7 @@ set_printoptions
 
 
 
-设置 paddle 中 ``Tensor`` 的打印配置选项。
+设置 paddle 中  ``Tensor``  的打印配置选项。
 
 参数
 :::::::::
diff --git a/docs/api/paddle/set_rng_state_cn.rst b/docs/api/paddle/set_rng_state_cn.rst
index 015e70b520e..58d20dd5ced 100644
--- a/docs/api/paddle/set_rng_state_cn.rst
+++ b/docs/api/paddle/set_rng_state_cn.rst
@@ -9,8 +9,8 @@ set_rng_state
 
 参数
 ::::::::::::
-    - **state_list** (list|tuple) - 要设置回设备生成器的设备状态。state_list 是从 ``get_rng_state()`` 获取的。
-    - **device** (str) - 此参数决定了具体的运行设备。可以是 ``cpu``、``gpu``、``xpu``。默认值为 None。如果为 None，则返回当前设备（由 ``set_device`` 指定）的生成器。
+    - **state_list** (list|tuple) - 要设置回设备生成器的设备状态。state_list 是从  ``get_rng_state()``  获取的。
+    - **device** (str) - 此参数决定了具体的运行设备。可以是  ``cpu`` 、 ``gpu`` 、 ``xpu`` 。默认值为 None。如果为 None，则返回当前设备（由  ``set_device``  指定）的生成器。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/sgn_cn.rst b/docs/api/paddle/sgn_cn.rst
index 528efe9369e..0a92b2524b1 100644
--- a/docs/api/paddle/sgn_cn.rst
+++ b/docs/api/paddle/sgn_cn.rst
@@ -7,7 +7,7 @@ sgn
 
 对于复数 Tensor，此函数返回一个新的 Tensor，其元素与 input 元素的角度相同且绝对值为 1。
 
-对于实数 Tensor，对输入参数 ``x`` 中每个元素进行正负判断，并且输出正负判断值：1 代表正，-1 代表负，0 代表零。
+对于实数 Tensor，对输入参数  ``x``  中每个元素进行正负判断，并且输出正负判断值：1 代表正，-1 代表负，0 代表零。
 
 参数
 ::::::::::::
@@ -16,7 +16,7 @@ sgn
 
 返回
 ::::::::::::
-Tensor，输出正负号或复数的单位向量，数据的 shape 大小及数据类型和输入 ``x`` 一致。
+Tensor，输出正负号或复数的单位向量，数据的 shape 大小及数据类型和输入  ``x``  一致。
 
 
 代码示例
diff --git a/docs/api/paddle/sign_cn.rst b/docs/api/paddle/sign_cn.rst
index 979c50616cd..54ed09cba69 100644
--- a/docs/api/paddle/sign_cn.rst
+++ b/docs/api/paddle/sign_cn.rst
@@ -5,21 +5,21 @@ sign
 
 .. py:function:: paddle.sign(x, name=None, *, out=None)
 
-对输入参数 ``x`` 中每个元素进行判断，并且输出判断值：对于实数， 1 表示正数，-1 表示负数，0 表示零。对于复数，返回值是一个单位大小的复数。如果复数元素为零，则返回 0+0j。
+对输入参数  ``x``  中每个元素进行判断，并且输出判断值：对于实数， 1 表示正数，-1 表示负数，0 表示零。对于复数，返回值是一个单位大小的复数。如果复数元素为零，则返回 0+0j。
 
 参数
 ::::::::::::
-    - **x** (Tensor) – 进行正负值判断的多维 Tensor，数据类型为 uint8, int8， int16， int32， int64， bfloat16， float16， float32， float64， complex64 或 complex128。别名 ``input``。
+    - **x** (Tensor) – 进行正负值判断的多维 Tensor，数据类型为 uint8, int8， int16， int32， int64， bfloat16， float16， float32， float64， complex64 或 complex128。别名  ``input`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 返回
 ::::::::::::
-Tensor，输出正负号，数据的 shape 大小及数据类型和输入 ``x`` 一致。
+Tensor，输出正负号，数据的 shape 大小及数据类型和输入  ``x``  一致。
 
 
 代码示例
diff --git a/docs/api/paddle/signal/istft_cn.rst b/docs/api/paddle/signal/istft_cn.rst
index 44b11c94471..a649ef8fa61 100644
--- a/docs/api/paddle/signal/istft_cn.rst
+++ b/docs/api/paddle/signal/istft_cn.rst
@@ -21,40 +21,40 @@ istft
 - :math:`H`: `hop_length` 参数的值。
 
 
-``paddle.signal.istft`` 的结果理论上是 ``paddle.signal.stft`` 的原始输入 ``x``，但
+ ``paddle.signal.istft``  的结果理论上是  ``paddle.signal.stft``  的原始输入  ``x`` ，但
 如果频域的结果是经过修改（如滤波），这种情况下恢复的时域信号是无法保证真实存在的。因此，
-``paddle.signal.istft`` 的结果是对于原始信号的最小二乘估计：
+ ``paddle.signal.istft``  的结果是对于原始信号的最小二乘估计：
 `Griffin-Lim optimal estimate <https://ieeexplore.ieee.org/document/1164317>`_ 。
 
 参数
 :::::::::
 
 - **x** (Tensor) - 输入数据，是维度为 2D 或者 3D 的 Tensor，数据类型必须为复数（复信号），其
-  形状为 ``[..., fft_size, num_frames]``；
+  形状为  ``[..., fft_size, num_frames]`` ；
 - **n_fft** (int) - 离散傅里叶变换的样本点个数；
-- **hop_length** (int，可选) - 对输入分帧时，相邻两帧偏移的样本点个数，默认为 ``None``
-  (为 ``n_fft//4``)；
-- **win_length** (int，可选) - 信号窗的长度，默认为 ``None`` (为 ``n_fft``)；
-- **window** (int，可选) - 维度为 1D 长度为 ``win_length`` 的 Tensor，数据类型可为复数。
-  如果 ``win_length < n_fft``，该 Tensor 将被补长至 ``n_fft``。默认为 ``None`` (长
-  度为 ``win_length`` 幅值为 1 的矩形窗)；
+- **hop_length** (int，可选) - 对输入分帧时，相邻两帧偏移的样本点个数，默认为  ``None`` 
+  (为  ``n_fft//4`` )；
+- **win_length** (int，可选) - 信号窗的长度，默认为  ``None``  (为  ``n_fft`` )；
+- **window** (int，可选) - 维度为 1D 长度为  ``win_length``  的 Tensor，数据类型可为复数。
+  如果  ``win_length < n_fft`` ，该 Tensor 将被补长至  ``n_fft`` 。默认为  ``None``  (长
+  度为  ``win_length``  幅值为 1 的矩形窗)；
 - **center** (bool，可选) - 选择是否将输入信号进行补长，使得第
-  :math:`t \times hop\_length` 个样本点在第 :math:`t` 帧的中心，默认为 ``True``；
+  :math:`t \times hop\_length` 个样本点在第 :math:`t` 帧的中心，默认为  ``True`` ；
 - **normalized** (bool，可选) - 是否将傅里叶变换的结果乘以值为 :math:`1/sqrt(n)` 的缩放
   系数；
-- **onesided** (bool，可选) - 该参数与 ``paddle.signal.stft`` 中的有区别，此处表示
-  告知接口输入的 ``x`` 是否为满足共轭对称性的短时傅里叶变换 Tensor 的一半。若满足上述条件，
-  且设为 ``True``，则 ``paddle.signal.istft`` 将返回一个实信号，默认为 ``True``；
+- **onesided** (bool，可选) - 该参数与  ``paddle.signal.stft``  中的有区别，此处表示
+  告知接口输入的  ``x``  是否为满足共轭对称性的短时傅里叶变换 Tensor 的一半。若满足上述条件，
+  且设为  ``True`` ，则  ``paddle.signal.istft``  将返回一个实信号，默认为  ``True`` ；
 - **length** (int，可选) - 指定输出信号的长度，该信号将从逆短时傅里叶变换的结果中截取。
-  默认为 ``None`` (返回不截取的信号)；
+  默认为  ``None``  (返回不截取的信号)；
 - **return_complex** (bool，可选) - 表示输出的重构信号是否为复信号。如果
-  ``return_complex`` 设为 ``True``， ``onesided`` 必须设为 ``False``，默认
-  为 ``False``；
+   ``return_complex``  设为  ``True`` ，  ``onesided``  必须设为  ``False`` ，默认
+  为  ``False`` ；
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-逆短时傅里叶变换的结果，是重构信号的最小二乘估计 Tensor，其形状为 ``[..., seq_length]``。
+逆短时傅里叶变换的结果，是重构信号的最小二乘估计 Tensor，其形状为  ``[..., seq_length]`` 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/signal/stft_cn.rst b/docs/api/paddle/signal/stft_cn.rst
index 4d09840094d..fd9a77bba98 100644
--- a/docs/api/paddle/signal/stft_cn.rst
+++ b/docs/api/paddle/signal/stft_cn.rst
@@ -19,41 +19,41 @@ stft
 上式中符号的意义：
 
 - :math:`t`：第 :math:`t` 帧输入信号；
-- :math:`f`：傅里叶变换频域的自变量，如果 ``onesided=False`` , :math:`f`
+- :math:`f`：傅里叶变换频域的自变量，如果  ``onesided=False``  , :math:`f`
   取值范围是 :math:`0 \leq f < n\_fft` ,
   如果 `onesided=True`，取值范围是
   :math:`0 \leq f < \lfloor n\_fft / 2 \rfloor + 1`；
-- :math:`N`: ``n_fft`` 参数的值；
-- :math:`H`: ``hop_length`` 参数的值。
+- :math:`N`:  ``n_fft``  参数的值；
+- :math:`H`:  ``hop_length``  参数的值。
 
 
 参数
 :::::::::
 
 - **x** (Tensor) - 输入数据，是维度为 1D 或者 2D 的 Tensor，数据类型可为复数（复信号），其形状
-  为 ``[..., seq_length]``；
+  为  ``[..., seq_length]`` ；
 - **n_fft** (int) - 离散傅里叶变换的样本点个数；
-- **hop_length** (int，可选) - 对输入分帧时，相邻两帧偏移的样本点个数，默认为 ``None``
-  (为 ``n_fft//4``)；
-- **win_length** (int，可选) - 信号窗的长度，默认为 ``None`` (为 ``n_fft``)；
-- **window** (int，可选) - 维度为 1D 长度为 ``win_length`` 的 Tensor，数据类型可为复数。
-  如果 ``win_length < n_fft``，该 Tensor 将被补长至 ``n_fft``。默认为 ``None`` (长度
-  为 ``win_length`` 幅值为 1 的矩形窗)；
+- **hop_length** (int，可选) - 对输入分帧时，相邻两帧偏移的样本点个数，默认为  ``None`` 
+  (为  ``n_fft//4`` )；
+- **win_length** (int，可选) - 信号窗的长度，默认为  ``None``  (为  ``n_fft`` )；
+- **window** (int，可选) - 维度为 1D 长度为  ``win_length``  的 Tensor，数据类型可为复数。
+  如果  ``win_length < n_fft`` ，该 Tensor 将被补长至  ``n_fft`` 。默认为  ``None``  (长度
+  为  ``win_length``  幅值为 1 的矩形窗)；
 - **center** (bool，可选) - 选择是否将输入信号进行补长，使得第
-  :math:`t \times hop\_length` 个样本点在第 ``t`` 帧的中心，默认为 ``True``；
-- **pad_mode** (str，可选) - 当 ``center`` 为 ``True`` 时，确定 padding 的模式，模式
-  的选项可以参考 ``paddle.nn.functional.pad``，默认为 "reflect"；
-- **normalized** (bool，可选) - 是否将傅里叶变换的结果乘以值为 ``1/sqrt(n)`` 的缩放系
+  :math:`t \times hop\_length` 个样本点在第  ``t``  帧的中心，默认为  ``True`` ；
+- **pad_mode** (str，可选) - 当  ``center``  为  ``True``  时，确定 padding 的模式，模式
+  的选项可以参考  ``paddle.nn.functional.pad`` ，默认为 "reflect"；
+- **normalized** (bool，可选) - 是否将傅里叶变换的结果乘以值为  ``1/sqrt(n)``  的缩放系
   数；
 - **onesided** (bool，可选) - 当输入为实信号时，选择是否只返回傅里叶变换结果的一半的频点
   值（输入信号和窗函数均为实数时，傅里叶变换结果具有共轭对称性）。如果输入的信号或者窗函数的
-  数据类型是复数，则此时不能设置为 ``True``。默认为 ``None``；
+  数据类型是复数，则此时不能设置为  ``True`` 。默认为  ``None`` ；
 - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-短时傅里叶变换的结果，复数 Tensor。当输入实信号和实窗函数，如果 ``onesided`` 为 ``True``，
-其形状为 ``[..., n_fft//2 + 1, num_frames]``；否则为 ``[..., n_fft, num_frames]``。
+短时傅里叶变换的结果，复数 Tensor。当输入实信号和实窗函数，如果  ``onesided``  为  ``True`` ，
+其形状为  ``[..., n_fft//2 + 1, num_frames]`` ；否则为  ``[..., n_fft, num_frames]`` 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/signbit_cn.rst b/docs/api/paddle/signbit_cn.rst
index 32d193663e7..2f116e88524 100644
--- a/docs/api/paddle/signbit_cn.rst
+++ b/docs/api/paddle/signbit_cn.rst
@@ -5,7 +5,7 @@ signbit
 
 .. py:function:: paddle.signbit(x, name=None)
 
-对输入参数 ``x`` 的每个元素判断是否设置了其符号位，并输出判断值。若存在符号位，则输出 True，否则输出 False。
+对输入参数  ``x``  的每个元素判断是否设置了其符号位，并输出判断值。若存在符号位，则输出 True，否则输出 False。
 
 参数
 ::::::::::::
@@ -14,7 +14,7 @@ signbit
 
 返回
 ::::::::::::
-Tensor，输出掩码，数据的 shape 大小及数据类型和输入 ``x`` 一致。
+Tensor，输出掩码，数据的 shape 大小及数据类型和输入  ``x``  一致。
 
 
 代码示例
diff --git a/docs/api/paddle/sin_cn.rst b/docs/api/paddle/sin_cn.rst
index 84ebb5f5ea0..c63460a80f1 100644
--- a/docs/api/paddle/sin_cn.rst
+++ b/docs/api/paddle/sin_cn.rst
@@ -15,13 +15,13 @@ sin
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 支持任意维度的 Tensor。数据类型为 float32，float64，float16，complex64，complex128。别名 ``input``。
+    - **x** (Tensor) - 支持任意维度的 Tensor。数据类型为 float32，float64，float16，complex64，complex128。别名  ``input`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/sinh_cn.rst b/docs/api/paddle/sinh_cn.rst
index ed42d2e52dd..16b8eef7dd3 100644
--- a/docs/api/paddle/sinh_cn.rst
+++ b/docs/api/paddle/sinh_cn.rst
@@ -24,7 +24,7 @@ sinh
 
 返回
 ::::::::::::
-输出 Tensor，与 ``x`` 维度相同、数据类型相同。
+输出 Tensor，与  ``x``  维度相同、数据类型相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/slice_cn.rst b/docs/api/paddle/slice_cn.rst
index a7f0c966819..10d660d2581 100755
--- a/docs/api/paddle/slice_cn.rst
+++ b/docs/api/paddle/slice_cn.rst
@@ -8,7 +8,7 @@ slice
 
 
 
-沿多个轴生成 ``input`` 的切片。与 numpy 类似：https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html 该 OP 使用 ``axes`` 、 ``starts`` 和 ``ends`` 属性来指定轴列表中每个轴的起点和终点位置，并使用此信息来对 ``input`` 切片。如果向 ``starts`` 或 ``ends`` 传递负值如 :math:`-i`，则表示该轴的反向第 :math:`i-1` 个位置（这里以 0 为初始位置）。如果传递给 ``starts`` 或 ``end`` 的值大于 n（维度中的元素数目），则表示 n。当切片一个未知数量的维度时，建议传入 ``INT_MAX``。 ``axes`` 、 ``starts`` 和 ``ends`` 三个参数的元素数目必须相等。以下示例将解释切片如何工作：
+沿多个轴生成  ``input``  的切片。与 numpy 类似：https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html 该 OP 使用  ``axes``  、  ``starts``  和  ``ends``  属性来指定轴列表中每个轴的起点和终点位置，并使用此信息来对  ``input``  切片。如果向  ``starts``  或  ``ends``  传递负值如 :math:`-i`，则表示该轴的反向第 :math:`i-1` 个位置（这里以 0 为初始位置）。如果传递给  ``starts``  或  ``end``  的值大于 n（维度中的元素数目），则表示 n。当切片一个未知数量的维度时，建议传入  ``INT_MAX`` 。  ``axes``  、  ``starts``  和  ``ends``  三个参数的元素数目必须相等。以下示例将解释切片如何工作：
 
 ::
 
@@ -39,14 +39,14 @@ slice
 参数
 ::::::::::::
 
-        - **input** （Tensor）- 多维 ``Tensor``，数据类型为 ``float16``， ``float32``，``float64``，``int32``，或 ``int64``。
-        - **axes** （list|tuple）- 数据类型是 ``int32``。表示进行切片的轴。
-        - **starts** （list|tuple|Tensor）- 数据类型是 ``int32``。如果 ``starts`` 的类型是 list 或 tuple，它的元素可以是整数或者形状为[]的 ``0-D Tensor``。如果 ``starts`` 的类型是 ``Tensor``，则是 1-D ``Tensor``。表示在各个轴上切片的起始索引值。
-        - **ends** （list|tuple|Tensor）- 数据类型是 ``int32``。如果 ``ends`` 的类型是 list 或 tuple，它的元素可以是整数或者形状为[]的 ``0-D Tensor``。如果 ``ends`` 的类型是 ``Tensor``，则是 1-D ``Tensor``。表示在各个轴上切片的结束索引值。
+        - **input** （Tensor）- 多维  ``Tensor`` ，数据类型为  ``float16`` ，  ``float32`` ， ``float64`` ， ``int32`` ，或  ``int64`` 。
+        - **axes** （list|tuple）- 数据类型是  ``int32`` 。表示进行切片的轴。
+        - **starts** （list|tuple|Tensor）- 数据类型是  ``int32`` 。如果  ``starts``  的类型是 list 或 tuple，它的元素可以是整数或者形状为[]的  ``0-D Tensor`` 。如果  ``starts``  的类型是  ``Tensor`` ，则是 1-D  ``Tensor`` 。表示在各个轴上切片的起始索引值。
+        - **ends** （list|tuple|Tensor）- 数据类型是  ``int32`` 。如果  ``ends``  的类型是 list 或 tuple，它的元素可以是整数或者形状为[]的  ``0-D Tensor`` 。如果  ``ends``  的类型是  ``Tensor`` ，则是 1-D  ``Tensor`` 。表示在各个轴上切片的结束索引值。
 
 返回
 ::::::::::::
-多维 ``Tensor``，数据类型与 ``input`` 相同。
+多维  ``Tensor`` ，数据类型与  ``input``  相同。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/slice_scatter_cn.rst b/docs/api/paddle/slice_scatter_cn.rst
index 9e3857b4c2b..60ae04a3fa8 100644
--- a/docs/api/paddle/slice_scatter_cn.rst
+++ b/docs/api/paddle/slice_scatter_cn.rst
@@ -27,7 +27,7 @@ slice_scatter
 返回
 :::::::::
 
-Tensor， 与 ``x`` 数据类型与形状相同。
+Tensor， 与  ``x``  数据类型与形状相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/softmax_cn.rst b/docs/api/paddle/softmax_cn.rst
index 364d5e565cf..6206a2a03b1 100644
--- a/docs/api/paddle/softmax_cn.rst
+++ b/docs/api/paddle/softmax_cn.rst
@@ -8,7 +8,7 @@ softmax
 
 步骤 1：输入 :attr:`input` 的 :attr:`dim` 维会被置换到最后一维；
 
-步骤 2：将输入 :attr:`input` 在逻辑上变换为二维矩阵。二维矩阵第一维（列长度）是输入除最后一维之外的其他维度值的乘积，第二维（行长度）和输入 ``dim`` 维的长度相同；对于矩阵的每一行，softmax 操作对其进行重新缩放，使得该行的每个元素在 :math:`[0, 1]` 范围内，并且总和为 :math:`1`；
+步骤 2：将输入 :attr:`input` 在逻辑上变换为二维矩阵。二维矩阵第一维（列长度）是输入除最后一维之外的其他维度值的乘积，第二维（行长度）和输入  ``dim``  维的长度相同；对于矩阵的每一行，softmax 操作对其进行重新缩放，使得该行的每个元素在 :math:`[0, 1]` 范围内，并且总和为 :math:`1`；
 
 步骤 3：softmax 操作执行完成后，执行步骤 1 和步骤 2 的逆运算，将二维矩阵恢复至和输入 :attr:`input` 相同的维度。
 
@@ -84,7 +84,7 @@ softmax
 参数
 ::::::::::
 
-    - **input** (Tensor) - 输入的 ``Tensor``，数据类型为 bfloat16 、 float16 、 float32 或 float64。
+    - **input** (Tensor) - 输入的  ``Tensor`` ，数据类型为 bfloat16 、 float16 、 float32 或 float64。
     - **dim** (int，可选) - 指定对输入 :attr:`input` 进行运算的轴。:attr:`dim` 的有效范围是 :math:`[-D, D)`，:math:`D` 是输入 :attr:`input` 的维度，:attr:`dim` 为负值时与 :math:`dim + D` 等价。默认值为 None。
     - **dtype** (str，可选) - 输出 `Tensor` 的数据类型，支持 bfloat16、 float16、 float32、float64。
     - **out** (Tensor，可选) - 指定输出结果的 `Tensor`，默认值为 None。
@@ -92,7 +92,7 @@ softmax
 返回
 ::::::::::
 
-    ``Tensor``，形状和 :attr:`input` 相同，数据类型为 :attr:`dtype` 或者和 :attr:`input` 相同。
+     ``Tensor`` ，形状和 :attr:`input` 相同，数据类型为 :attr:`dtype` 或者和 :attr:`input` 相同。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/sort_cn.rst b/docs/api/paddle/sort_cn.rst
index 5778ddc5f8b..2e5090cc1f8 100644
--- a/docs/api/paddle/sort_cn.rst
+++ b/docs/api/paddle/sort_cn.rst
@@ -7,21 +7,21 @@ sort
 
 
 
-对输入变量沿给定轴进行排序，输出排序好的数据，其维度和输入相同。默认升序排列，如果需要降序排列设置 ``descending=True`` 。
+对输入变量沿给定轴进行排序，输出排序好的数据，其维度和输入相同。默认升序排列，如果需要降序排列设置  ``descending=True``  。
 
 
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 输入的多维 ``Tensor``，支持的数据类型：float32、float64、int16、int32、int64、uint8。
-    - **axis** (int，可选) - 指定对输入 Tensor 进行运算的轴，``axis`` 的有效范围是[-R, R)，R 是输入 ``x`` 的 Rank， ``axis`` 为负时与 ``axis`` +R 等价。默认值为-1。
+    - **x** (Tensor) - 输入的多维  ``Tensor`` ，支持的数据类型：float32、float64、int16、int32、int64、uint8。
+    - **axis** (int，可选) - 指定对输入 Tensor 进行运算的轴， ``axis``  的有效范围是[-R, R)，R 是输入  ``x``  的 Rank，  ``axis``  为负时与  ``axis``  +R 等价。默认值为-1。
     - **descending** (bool，可选) - 指定算法排序的方向。如果设置为 True，算法按照降序排序。如果设置为 False 或者不设置，按照升序排序。默认值为 False。
     - **stable** (bool，可选) - 是否使用稳定排序算法。若设置为 True，则使用稳定排序算法，即相同元素的顺序在排序结果中将会被保留。默认值为 False，此时的算法不一定是稳定排序算法。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
-Tensor，排序后的输出（与 ``x`` 维度相同、数据类型相同）。
+Tensor，排序后的输出（与  ``x``  维度相同、数据类型相同）。
 
 
 代码示例
diff --git a/docs/api/paddle/sparse/Overview_cn.rst b/docs/api/paddle/sparse/Overview_cn.rst
index 3e0d89b6617..f0b1be2dee6 100644
--- a/docs/api/paddle/sparse/Overview_cn.rst
+++ b/docs/api/paddle/sparse/Overview_cn.rst
@@ -58,7 +58,7 @@ paddle.sparse 目录包含飞桨框架支持稀疏数据存储和计算相关的
     " :ref:`paddle.sparse.is_same_shape <cn_api_paddle_sparse_is_same_shape>` ", "判断两个稀疏 Tensor 或稠密 Tensor 的 shape 是否一致"
     " :ref:`paddle.sparse.reshape <cn_api_paddle_sparse_reshape>` ", "改变一个 SparseTensor 的形状"
     " :ref:`paddle.sparse.coalesce<cn_api_paddle_sparse_coalesce>` ", "对 SparseCooTensor 进行排序并合并"
-    " :ref:`paddle.sparse.transpose <cn_api_paddle_sparse_transpose>` ", "在不改变数据的情况下改变 ``x`` 的维度顺序, 支持 COO 格式的多维 SparseTensor 以及 COO 格式的 2 维和 3 维 SparseTensor"
+    " :ref:`paddle.sparse.transpose <cn_api_paddle_sparse_transpose>` ", "在不改变数据的情况下改变  ``x``  的维度顺序, 支持 COO 格式的多维 SparseTensor 以及 COO 格式的 2 维和 3 维 SparseTensor"
     " :ref:`paddle.sparse.mask_as<cn_api_paddle_sparse_mask_as>` ", "稀疏张量的掩码逻辑，使用稀疏张量 `mask` 的索引过滤输入的稠密张量 `x`"
 
 .. _about_sparse_nn:
diff --git a/docs/api/paddle/sparse/isnan_cn.rst b/docs/api/paddle/sparse/isnan_cn.rst
index 8d793c64c6f..d966aac7769 100644
--- a/docs/api/paddle/sparse/isnan_cn.rst
+++ b/docs/api/paddle/sparse/isnan_cn.rst
@@ -14,7 +14,7 @@ isnan
 
 返回
 :::::::::
-多维稀疏 ``Tensor``，每个元素是一个 bool 值，表示输入 :attr:`x` 的每个元素是否为 `+/-NaN`，稀疏格式与 :attr:`x` 相同 。
+多维稀疏  ``Tensor`` ，每个元素是一个 bool 值，表示输入 :attr:`x` 的每个元素是否为 `+/-NaN`，稀疏格式与 :attr:`x` 相同 。
 
 
 代码示例
diff --git a/docs/api/paddle/sparse/nn/BatchNorm_cn.rst b/docs/api/paddle/sparse/nn/BatchNorm_cn.rst
index 9372833d018..14714edeae9 100644
--- a/docs/api/paddle/sparse/nn/BatchNorm_cn.rst
+++ b/docs/api/paddle/sparse/nn/BatchNorm_cn.rst
@@ -6,7 +6,7 @@ BatchNorm
 .. py:class:: paddle.sparse.nn.BatchNorm(num_features, momentum=0.9, epsilon=1e-05, weight_attr=None, bias_attr=None, data_format="NDHWC", use_global_stats=None, name=None)
 
 
-构建稀疏 ``BatchNorm`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。可以处理 4D SparseCooTensor ，实现了批归一化层（Batch Normalization Layer）的功能，可用作卷积和全连接操作的批归一化函数，根据当前批次数据按通道计算的均值和方差进行归一化。更多详情请参考： `Batch Normalization : Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/pdf/1502.03167.pdf>`_ 。
+构建稀疏  ``BatchNorm``  类的一个可调用对象，具体用法参照  ``代码示例``  。可以处理 4D SparseCooTensor ，实现了批归一化层（Batch Normalization Layer）的功能，可用作卷积和全连接操作的批归一化函数，根据当前批次数据按通道计算的均值和方差进行归一化。更多详情请参考： `Batch Normalization : Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/pdf/1502.03167.pdf>`_ 。
 
 当 use_global_stats = False 时 :math: `\mu_{\beta}` 和 :math: `\sigma_{\beta}^{2}` 是 minibatch 的统计数据。计算公式如下：
 
@@ -39,13 +39,13 @@ BatchNorm
 参数
 ::::::::::::
 
-    - **num_features** (int) - 指明输入 ``Tensor`` 的通道数量。
-    - **momentum** (float，可选) - 此值用于计算 ``moving_mean`` 和 ``moving_var`` 。默认值：0.9。更新公式如上所示。
+    - **num_features** (int) - 指明输入  ``Tensor``  的通道数量。
+    - **momentum** (float，可选) - 此值用于计算  ``moving_mean``  和  ``moving_var``  。默认值：0.9。更新公式如上所示。
     - **epsilon** (float，可选) - 为了数值稳定加在分母上的值。默认值：1e-05。
     - **weight_attr** (ParamAttr|bool，可选) - 指定权重参数属性的对象。如果为 False，则表示每个通道的伸缩固定为 1，不可改变。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **bias_attr** (ParamAttr，可选) - 指定偏置参数属性的对象。如果为 False，则表示每一个通道的偏移固定为 0，不可改变。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **data_format** (string，可选) - 指定输入数据格式，数据格式可以为“NCDHW"。默认值：“NCDHW”。
-    - **use_global_stats** (bool，可选) – 指示是否使用全局均值和方差。在预测或测试模式下，将 ``use_global_stats`` 设置为 true 或将 ``is_test`` 设置为 true，这两种行为是等效的。在训练模式中，当设置 ``use_global_stats`` 为 True 时，在训练期间也将使用全局均值和方差。默认值：False。
+    - **use_global_stats** (bool，可选) – 指示是否使用全局均值和方差。在预测或测试模式下，将  ``use_global_stats``  设置为 true 或将  ``is_test``  设置为 true，这两种行为是等效的。在训练模式中，当设置  ``use_global_stats``  为 True 时，在训练期间也将使用全局均值和方差。默认值：False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为 None。
 
 
diff --git a/docs/api/paddle/sparse/nn/Conv2D_cn.rst b/docs/api/paddle/sparse/nn/Conv2D_cn.rst
index 4e7dfac3aff..d0f9a890385 100644
--- a/docs/api/paddle/sparse/nn/Conv2D_cn.rst
+++ b/docs/api/paddle/sparse/nn/Conv2D_cn.rst
@@ -24,8 +24,8 @@ Conv2D
     - :math:`X`：输入值，NHWC 格式的 Tensor
     - :math:`W`：卷积核值，HWCM 格式的 Tensor
     - :math:`*`：卷积操作
-    - :math:`b`：偏置值，1-D Tensor，形为 ``[M]``
-    - :math:`Out`：输出值，NHWC 格式的 Tensor，和 ``X`` 的形状可能不同
+    - :math:`b`：偏置值，1-D Tensor，形为  ``[M]`` 
+    - :math:`Out`：输出值，NHWC 格式的 Tensor，和  ``X``  的形状可能不同
 
 参数
 ::::::::::::
@@ -45,7 +45,7 @@ Conv2D
         注意，批量维度和通道维度也包括在内。每对整数对应输入的一个维度的填充量。批量维度和通道维度的填充应为 [0, 0] 或 (0, 0)。默认值为 0。
     - **dilation** (int|list|tuple，可选) - 空洞大小。可以为单个整数或包含三个整数的元组或列表，分别表示卷积核中的元素沿着深度，高和宽的空洞。如果为单个整数，表示深度，高和宽的空洞都等于该整数。默认值：1。
     - **groups** (int，可选) - 二维卷积层的组数。根据 Alex Krizhevsky 的深度卷积神经网络（CNN）论文中的成组卷积：当 group=n，输入和卷积核分别根据通道数量平均分为 n 组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第 n 组卷积核和第 n 组输入进行卷积计算。默认值：1。
-    - **padding_mode** (str，可选) - 填充模式。包括 ``'zeros'``, ``'reflect'``, ``'replicate'`` 或者 ``'circular'``。默认值：``'zeros'`` 。
+    - **padding_mode** (str，可选) - 填充模式。包括  ``'zeros'`` ,  ``'reflect'`` ,  ``'replicate'``  或者  ``'circular'`` 。默认值： ``'zeros'``  。
     - **weight_attr** (ParamAttr，可选) - conv2d 的可学习参数/权重的参数属性。如果设置为 None 或 ParamAttr 的一个属性，conv2d 将创建 ParamAttr 作为 param_attr。如果设置为 None，则参数初始化为 :math:`Normal(0.0, std)`，:math:`std` 为 :math:`(\frac{2.0 }{filter\_elem\_num})^{0.5}`。默认值为 None。
     - **bias_attr** (ParamAttr|bool，可选) - conv2d 的偏置参数属性。如果设置为 False，则不会在输出单元中添加偏置。如果设置为 None 或 ParamAttr 的一个属性，conv2d 将创建 ParamAttr 作为 bias_attr。如果 bias_attr 的初始化器未设置，则偏置初始化为零。默认值为 None。
     - **data_format** (str，可选) - 指定输入的数据格式。可以是 "NCHW" 或 "NHWC"。目前仅支持 "NHWC"。N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度。默认值："NDHWC"。 当前只支持"NDHWC"。
@@ -56,11 +56,11 @@ Conv2D
 
 weight
 '''''''''
-本层的可学习参数，类型为 ``Parameter``
+本层的可学习参数，类型为  ``Parameter`` 
 
 bias
 '''''''''
-本层的可学习偏置，类型为 ``Parameter``
+本层的可学习偏置，类型为  ``Parameter`` 
 
 形状
 ::::::::::::
diff --git a/docs/api/paddle/sparse/nn/Conv3D_cn.rst b/docs/api/paddle/sparse/nn/Conv3D_cn.rst
index 0789485baea..7308fc3fde9 100644
--- a/docs/api/paddle/sparse/nn/Conv3D_cn.rst
+++ b/docs/api/paddle/sparse/nn/Conv3D_cn.rst
@@ -21,8 +21,8 @@ NDHWC 格式，其中 N 是批尺寸，C 是通道数，D 是特征层深度，H
     - :math:`X`：输入值，NDHWC 格式的 5-D Tensor
     - :math:`W`：卷积核值，DHWCM 格式的 5-D Tensor
     - :math:`*`：卷积操作
-    - :math:`b`：偏置值，1-D Tensor，形为 ``[M]``
-    - :math:`Out`：输出值，NDHWC 格式的 5-D Tensor，和 ``X`` 的形状可能不同
+    - :math:`b`：偏置值，1-D Tensor，形为  ``[M]`` 
+    - :math:`Out`：输出值，NDHWC 格式的 5-D Tensor，和  ``X``  的形状可能不同
 
 参数
 ::::::::::::
@@ -31,17 +31,17 @@ NDHWC 格式，其中 N 是批尺寸，C 是通道数，D 是特征层深度，H
     - **out_channels** (int) - 由卷积操作产生的输出的通道数。
     - **kernel_size** (int|list|tuple) - 卷积核大小。可以为单个整数或包含三个整数的元组或列表，分别表示卷积核的深度，高和宽。如果为单个整数，表示卷积核的深度，高和宽都等于该整数。
     - **stride** (int|list|tuple，可选) - 步长大小。可以为单个整数或包含三个整数的元组或列表，分别表示卷积沿着深度，高和宽的步长。如果为单个整数，表示沿着高和宽的步长都等于该整数。默认值：1。
-    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：
+    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述  ``padding``  = "SAME"或   ``padding``  = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：
 
-        - (1)包含 5 个二元组：当 ``data_format`` 为"NCDHW"时为 [[0,0], [0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为"NDHWC"时为[[0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；
+        - (1)包含 5 个二元组：当  ``data_format``  为"NCDHW"时为 [[0,0], [0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当  ``data_format``  为"NDHWC"时为[[0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；
         - (2)包含 6 个整数值：[padding_depth_front, padding_depth_back, padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；
         - (3)包含 3 个整数值：[padding_depth, padding_height, padding_width]，此时 padding_depth_front = padding_depth_back = padding_depth, padding_height_top = padding_height_bottom = padding_height, padding_width_left = padding_width_right = padding_width。若为一个整数，padding_depth = padding_height = padding_width = padding。默认值：0。
 
     - **dilation** (int|list|tuple，可选) - 空洞大小。可以为单个整数或包含三个整数的元组或列表，分别表示卷积核中的元素沿着深度，高和宽的空洞。如果为单个整数，表示深度，高和宽的空洞都等于该整数。默认值：1。
     - **groups** (int，可选) - 三维卷积层的组数。根据 Alex Krizhevsky 的深度卷积神经网络（CNN）论文中的成组卷积：当 group=n，输入和卷积核分别根据通道数量平均分为 n 组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第 n 组卷积核和第 n 组输入进行卷积计算。默认值：1。
-    - **padding_mode** (str，可选) - 填充模式。包括 ``'zeros'``, ``'reflect'``, ``'replicate'`` 或者 ``'circular'``。默认值：``'zeros'`` 。
+    - **padding_mode** (str，可选) - 填充模式。包括  ``'zeros'`` ,  ``'reflect'`` ,  ``'replicate'``  或者  ``'circular'`` 。默认值： ``'zeros'``  。
     - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若 ``bias_attr`` 为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若  ``bias_attr``  为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度。默认值："NDHWC"。 当前只支持"NDHWC"。
 
 
@@ -50,11 +50,11 @@ NDHWC 格式，其中 N 是批尺寸，C 是通道数，D 是特征层深度，H
 
 weight
 '''''''''
-本层的可学习参数，类型为 ``Parameter``
+本层的可学习参数，类型为  ``Parameter`` 
 
 bias
 '''''''''
-本层的可学习偏置，类型为 ``Parameter``
+本层的可学习偏置，类型为  ``Parameter`` 
 
 形状
 ::::::::::::
@@ -74,7 +74,7 @@ bias
 
         W_{out} &= \frac{\left ( W_{in} + padding\_width\_left + padding\_width\_right -\left ( dilation[2]*\left ( kernel\_size[2]-1 \right )+1 \right ) \right )}{stride[2]}+1
 
-    如果 ``padding`` = "SAME":
+    如果  ``padding``  = "SAME":
 
     .. math::
         D_{out} = \frac{(D_{in} + stride[0] - 1)}{stride[0]}
@@ -83,7 +83,7 @@ bias
 
         W_{out} = \frac{(W_{in} + stride[2] - 1)}{stride[2]}
 
-    如果 ``padding`` = "VALID":
+    如果  ``padding``  = "VALID":
 
     .. math::
         D_{out} = \frac{\left ( D_{in} -\left ( dilation[0]*\left ( kernel\_size[0]-1 \right )+1 \right ) \right )}{stride[0]}+1
diff --git a/docs/api/paddle/sparse/nn/SubmConv2D_cn.rst b/docs/api/paddle/sparse/nn/SubmConv2D_cn.rst
index 596dd7fb4cd..e32a66c70fd 100644
--- a/docs/api/paddle/sparse/nn/SubmConv2D_cn.rst
+++ b/docs/api/paddle/sparse/nn/SubmConv2D_cn.rst
@@ -33,7 +33,7 @@ SubmConv2D
     - **stride** (int|list|tuple, 可选): - 步长大小。如果 stride 是一个列表/元组，它必须包含两个整数，(stride_H, stride_W)。否则, stride_H = stride_W = stride。默认值为 1。
     - **padding** (int|str|tuple|list, 可选): - 填充大小。应为以下几种格式之一；
 
-        - (1) 如果它是一个字符串，可以是 "VALID" 或者 "SAME"，计算细节可参考上述 ``padding`` = "SAME" 或  ``padding`` = "VALID" 时的计算公式。
+        - (1) 如果它是一个字符串，可以是 "VALID" 或者 "SAME"，计算细节可参考上述  ``padding``  = "SAME" 或   ``padding``  = "VALID" 时的计算公式。
         - (2) 如果它是一个整数, 则代表它每个 Spartial 维度(depth, height, width) 被 `padding` 的大小填充为零。
         - (3) 一个 list[int] 或 tuple[int]，其长度是 Spartial 维度的数目，它包含每个 Spartial 维度每侧的填充量。它的形式为 [pad_d1, pad_d2, ...]。
         - (4) 一个 list[int] 或 tuple[int]，其长度为 2 * 部分维数。对于所有局部维度，它的形式为 [pad_before, pad_after, pad_before, pad_after, ...]。
@@ -42,7 +42,7 @@ SubmConv2D
         请注意，批维度和通道维度也包括在内。每对整数对应于输入维度的填充量。批维度和通道维度中的填充应为[0, 0]或者是(0, 0)默认值为 0。
     - **dilation** (int|list|tuple, 可选): - 空洞大小。如果 dilation 是列表或元组, 则它必须包含两个整数 (dilation_H, dilation_W)。否则, dilation_H = dilation_W = dilation。默认值为 1。
     - **groups** (int, 可选): - 二维卷积层的组号。根据 Alex Krizhevsky 的 Deep CNN 论文中的分组卷积:当 group = 2 时, 卷积核的前半部分仅连接到输入通道的前半部分, 而卷积核的后半部分仅连接到输入通道的后半部分。默认值为 1。
-    - **padding_mode** (str, 可选): - ``'zeros'``, ``'reflect'``, ``'replicate'`` 或 ``'circular'``。 目前仅支持 ``'zeros'``。
+    - **padding_mode** (str, 可选): -  ``'zeros'`` ,  ``'reflect'`` ,  ``'replicate'``  或  ``'circular'`` 。 目前仅支持  ``'zeros'`` 。
     - **key** (str, 可选): - key 用于保存或使用相同的规则手册，规则手册的定义和作用是指 https://pdfs.semanticscholar.org/5125/a16039cabc6320c908a4764f32596e018ad3.pdf。默认值为 None。
     - **weight_attr** (ParamAttr, 可选): - conv2d 的可学习参数/权重的参数属性。如果设置为 None 或 ParamAttr 的一个属性，则 conv2d 将创建 ParamAttr 作为 param_attr。 如果设置为 None, 则参数初始化为:math:`Normal(0.0, std)`, 并且 :math:`std` 是:math:`(\frac{2.0 }{filter\_elem\_num})^{0.5}`,默认值为 None。
     - **bias_attr** (ParamAttr|bool, 可选): - conv2d 偏差的参数属性。如果设置为 False, 则不会向输出单位添加任何偏置。如果设置为 None 或 ParamAttr 的一个属性，则 conv2d 将创建 ParamAttr 作为 bias_attr。如果未设置 bias_attr 的初始值设定项,则偏置初始化为零。默认值为 None。
@@ -53,11 +53,11 @@ SubmConv2D
 
 weight
 '''''''''
-该层卷积核的可学习权重，类型为 ``Parameter``。
+该层卷积核的可学习权重，类型为  ``Parameter`` 。
 
 bias
 '''''''''
-该层的可学习偏置，类型为 ``Parameter``。
+该层的可学习偏置，类型为  ``Parameter`` 。
 
 形状
 ::::::::::::
diff --git a/docs/api/paddle/sparse/nn/SubmConv3D_cn.rst b/docs/api/paddle/sparse/nn/SubmConv3D_cn.rst
index 8e761b859ee..d72e28809ef 100644
--- a/docs/api/paddle/sparse/nn/SubmConv3D_cn.rst
+++ b/docs/api/paddle/sparse/nn/SubmConv3D_cn.rst
@@ -21,8 +21,8 @@ NDHWC 格式，其中 N 是批尺寸，C 是通道数，D 是特征层深度，H
     - :math:`X` ：输入值，NDHWC 格式的 5-D Tensor
     - :math:`W` ：卷积核值，DHWCM 格式的 5-D Tensor
     - :math:`*` ：子流形稀疏卷积操作的定义参考论文：https://arxiv.org/abs/1706.01307
-    - :math:`b` ：偏置值，1-D Tensor，形为 ``[M]``
-    - :math:`Out` ：输出值，NDHWC 格式的 5-D Tensor，和 ``X`` 的形状可能不同
+    - :math:`b` ：偏置值，1-D Tensor，形为  ``[M]`` 
+    - :math:`Out` ：输出值，NDHWC 格式的 5-D Tensor，和  ``X``  的形状可能不同
 
 参数
 ::::::::::::
@@ -31,18 +31,18 @@ NDHWC 格式，其中 N 是批尺寸，C 是通道数，D 是特征层深度，H
     - **out_channels** (int) - 由卷积操作产生的输出的通道数。
     - **kernel_size** (int|list|tuple) - 卷积核大小。可以为单个整数或包含三个整数的元组或列表，分别表示卷积核的深度，高和宽。如果为单个整数，表示卷积核的深度，高和宽都等于该整数。
     - **stride** (int|list|tuple，可选) - 步长大小。可以为单个整数或包含三个整数的元组或列表，分别表示卷积沿着深度，高和宽的步长。如果为单个整数，表示沿着高和宽的步长都等于该整数。默认值：1。
-    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是 "VALID" 或者 "SAME" ，表示填充算法，计算细节可参考上述 ``padding`` = "SAME" 或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：
+    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是 "VALID" 或者 "SAME" ，表示填充算法，计算细节可参考上述  ``padding``  = "SAME" 或   ``padding``  = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：
 
-        - (1)包含 5 个二元组：当 ``data_format`` 为 "NCDHW" 时为 [[0,0], [0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为 "NDHWC" 时为[[0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；
+        - (1)包含 5 个二元组：当  ``data_format``  为 "NCDHW" 时为 [[0,0], [0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当  ``data_format``  为 "NDHWC" 时为[[0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；
         - (2)包含 6 个整数值：[padding_depth_front, padding_depth_back, padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；
         - (3)包含 3 个整数值：[padding_depth, padding_height, padding_width]，此时 padding_depth_front = padding_depth_back = padding_depth, padding_height_top = padding_height_bottom = padding_height, padding_width_left = padding_width_right = padding_width。若为一个整数，padding_depth = padding_height = padding_width = padding。默认值：0。
 
     - **dilation** (int|list|tuple，可选) - 空洞大小。可以为单个整数或包含三个整数的元组或列表，分别表示卷积核中的元素沿着深度，高和宽的空洞。如果为单个整数，表示深度，高和宽的空洞都等于该整数。默认值：1。
     - **groups** (int，可选) - 三维卷积层的组数。根据 Alex Krizhevsky 的深度卷积神经网络（CNN）论文中的成组卷积：当 group = n ，输入和卷积核分别根据通道数量平均分为 n 组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第 n 组卷积核和第 n 组输入进行卷积计算。默认值：1。
-    - **padding_mode** (str，可选) - 填充模式。包括 ``'zeros'``, ``'reflect'``, ``'replicate'`` 或者 ``'circular'`` 。默认值：``'zeros'`` 。
+    - **padding_mode** (str，可选) - 填充模式。包括  ``'zeros'`` ,  ``'reflect'`` ,  ``'replicate'``  或者  ``'circular'``  。默认值： ``'zeros'``  。
     - **key** (str，可选) - 这个 key 是用来保存或者使用相同的 rulebook ，rulebook 的定义参考论文：https://pdfs.semanticscholar.org/5125/a16039cabc6320c908a4764f32596e018ad3.pdf。 默认是 None。
     - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若 ``bias_attr`` 为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若  ``bias_attr``  为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是 "NCDHW" 和 "NDHWC" 。N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度。默认值："NDHWC" 。 当前只支持 "NDHWC" 。
 
 
@@ -51,11 +51,11 @@ NDHWC 格式，其中 N 是批尺寸，C 是通道数，D 是特征层深度，H
 
 weight
 '''''''''
-本层的可学习参数，类型为 ``Parameter``
+本层的可学习参数，类型为  ``Parameter`` 
 
 bias
 '''''''''
-本层的可学习偏置，类型为 ``Parameter``
+本层的可学习偏置，类型为  ``Parameter`` 
 
 形状
 ::::::::::::
@@ -75,7 +75,7 @@ bias
 
         W_{out} &= \frac{\left ( W_{in} + padding\_width\_left + padding\_width\_right -\left ( dilation[2]*\left ( kernel\_size[2]-1 \right )+1 \right ) \right )}{stride[2]}+1
 
-    如果 ``padding`` = "SAME":
+    如果  ``padding``  = "SAME":
 
     .. math::
         D_{out} = \frac{(D_{in} + stride[0] - 1)}{stride[0]}
@@ -84,7 +84,7 @@ bias
 
         W_{out} = \frac{(W_{in} + stride[2] - 1)}{stride[2]}
 
-    如果 ``padding`` = "VALID":
+    如果  ``padding``  = "VALID":
 
     .. math::
         D_{out} = \frac{\left ( D_{in} -\left ( dilation[0]*\left ( kernel\_size[0]-1 \right )+1 \right ) \right )}{stride[0]}+1
diff --git a/docs/api/paddle/sparse/nn/SyncBatchNorm_cn.rst b/docs/api/paddle/sparse/nn/SyncBatchNorm_cn.rst
index 82b965b6a10..19220bc95e9 100644
--- a/docs/api/paddle/sparse/nn/SyncBatchNorm_cn.rst
+++ b/docs/api/paddle/sparse/nn/SyncBatchNorm_cn.rst
@@ -5,7 +5,7 @@ SyncBatchNorm
 
 .. py:class:: paddle.sparse.nn.SyncBatchNorm(num_features, epsilon=1e-5, momentum=0.9, weight_attr=None, bias_attr=None, data_format='NCHW', name=None)
 
-构建 ``SyncBatchNorm`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。实现了跨卡 GPU 同步的批归一化(Cross-GPU Synchronized Batch Normalization Layer)的功能，可用在其他层（类似卷积层和全连接层）之后进行归一化操作。根据所有 GPU 同一批次的数据按照通道计算的均值和方差进行归一化。更多详情请参考：`Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/pdf/1502.03167.pdf>`_ 。
+构建  ``SyncBatchNorm``  类的一个可调用对象，具体用法参照  ``代码示例``  。实现了跨卡 GPU 同步的批归一化(Cross-GPU Synchronized Batch Normalization Layer)的功能，可用在其他层（类似卷积层和全连接层）之后进行归一化操作。根据所有 GPU 同一批次的数据按照通道计算的均值和方差进行归一化。更多详情请参考：`Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/pdf/1502.03167.pdf>`_ 。
 
 当模型处于训练模式时，:math:`\mu_{\beta}` 和 :math:`\sigma_{\beta}^{2}` 是所有 GPU 上同一 minibatch 的统计数据。计算公式如下：
 
@@ -36,24 +36,24 @@ SyncBatchNorm
 
 .. note::
 
-    如果您想用容器封装您的模型，而且您的模型在预测阶段中包含 ``SyncBatchNorm`` 这个算子的话，请使用 ``nn.LayerList`` 或者 ``nn.Sequential`` 而不要直接使用 ``list`` 来封装模型。
+    如果您想用容器封装您的模型，而且您的模型在预测阶段中包含  ``SyncBatchNorm``  这个算子的话，请使用  ``nn.LayerList``  或者  ``nn.Sequential``  而不要直接使用  ``list``  来封装模型。
 
 参数
 ::::::::::::
 
-    - **num_features** (int) - 指明输入 ``Tensor`` 的通道数量。
+    - **num_features** (int) - 指明输入  ``Tensor``  的通道数量。
     - **epsilon** (float，可选) - 为了数值稳定加在分母上的值。默认值：1e-05。
-    - **momentum** (float，可选) - 此值用于计算 ``moving_mean`` 和 ``moving_var`` 。默认值：0.9。更新公式如上所示。
-    - **weight_attr** (ParamAttr|bool，可选) - 指定权重参数属性的对象。如果设置为 ``False`` ，则表示本层没有可训练的权重参数。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** (ParamAttr|bool，可选) - 指定偏置参数属性的对象。如果设置为 ``False`` ，则表示本层没有可训练的偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **momentum** (float，可选) - 此值用于计算  ``moving_mean``  和  ``moving_var``  。默认值：0.9。更新公式如上所示。
+    - **weight_attr** (ParamAttr|bool，可选) - 指定权重参数属性的对象。如果设置为  ``False``  ，则表示本层没有可训练的权重参数。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** (ParamAttr|bool，可选) - 指定偏置参数属性的对象。如果设置为  ``False``  ，则表示本层没有可训练的偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **data_format** (string，可选) - 指定输入数据格式，数据格式可以为“NCHW"。默认值：“NCHW”。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为 None。
 
 形状
 ::::::::::::
 
-    - input：一个二维到五维的 ``Tensor`` 。
-    - output：和 input 相同形状的 ``Tensor`` 。
+    - input：一个二维到五维的  ``Tensor``  。
+    - output：和 input 相同形状的  ``Tensor``  。
 
 代码示例
 ::::::::::::
@@ -65,17 +65,17 @@ COPY-FROM: paddle.sparse.nn.SyncBatchNorm
 convert_sync_batchnorm(layer)
 '''''''''''''''''''''''''''''
 
-把 ``BatchNorm`` 层转换为 ``SyncBatchNorm`` 层。
+把  ``BatchNorm``  层转换为  ``SyncBatchNorm``  层。
 
 参数
 ::::::::::::
 
-    - **layer** (paddle.nn.Layer) - 包含一个或多个 ``BatchNorm`` 层的模型。
+    - **layer** (paddle.nn.Layer) - 包含一个或多个  ``BatchNorm``  层的模型。
 
 返回
 ::::::::::::
 
-    如果原始模型中有 ``BatchNorm`` 层，则把 ``BatchNorm`` 层转换为 ``SyncBatchNorm`` 层的原始模型。
+    如果原始模型中有  ``BatchNorm``  层，则把  ``BatchNorm``  层转换为  ``SyncBatchNorm``  层的原始模型。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/sparse/nn/functional/conv2d_cn.rst b/docs/api/paddle/sparse/nn/functional/conv2d_cn.rst
index abb2d11596f..41461604a9c 100644
--- a/docs/api/paddle/sparse/nn/functional/conv2d_cn.rst
+++ b/docs/api/paddle/sparse/nn/functional/conv2d_cn.rst
@@ -18,8 +18,8 @@ conv2d
     - :math:`X` ：输入值，NHWC 格式的 Tensor
     - :math:`W` ：卷积核值，HWCM 格式的 Tensor
     - :math:`*` ：卷积操作
-    - :math:`b` ：偏置值，1-D Tensor，形为 ``[M]``
-    - :math:`Out` ：输出值， ``Out`` 和 ``X`` 的形状可能不同。
+    - :math:`b` ：偏置值，1-D Tensor，形为  ``[M]`` 
+    - :math:`Out` ：输出值，  ``Out``  和  ``X``  的形状可能不同。
 
 参数
 ::::::::::::
diff --git a/docs/api/paddle/sparse/nn/functional/conv3d_cn.rst b/docs/api/paddle/sparse/nn/functional/conv3d_cn.rst
index 6c8b789e604..4766e7235d2 100644
--- a/docs/api/paddle/sparse/nn/functional/conv3d_cn.rst
+++ b/docs/api/paddle/sparse/nn/functional/conv3d_cn.rst
@@ -18,8 +18,8 @@ conv3d
     - :math:`X` ：输入值，NCDHW 或 NDHWC 格式的 5-D Tensor
     - :math:`W` ：卷积核值，MCDHW 格式的 5-D Tensor
     - :math:`*` ：卷积操作
-    - :math:`b` ：偏置值，1-D Tensor，形为 ``[M]``
-    - :math:`Out` ：输出值，NCDHW 或 NDHWC 格式的 5-D Tensor，和 ``X`` 的形状可能不同
+    - :math:`b` ：偏置值，1-D Tensor，形为  ``[M]`` 
+    - :math:`Out` ：输出值，NCDHW 或 NDHWC 格式的 5-D Tensor，和  ``X``  的形状可能不同
 
 **示例**
 
@@ -43,21 +43,21 @@ conv3d
 
         - 如果它是一个列表或元组，则必须包含三个整型数：（stride_depth, stride_height,stride_width）。
         - 若为一个整数，stride_depth = stride_height = stride_width = stride。默认值：1。
-    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：
+    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述  ``padding``  = "SAME"或   ``padding``  = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：
 
-        - (1)包含 5 个二元组：当 ``data_format`` 为"NCDHW"时为 [[0,0], [0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为"NDHWC"时为[[0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；
+        - (1)包含 5 个二元组：当  ``data_format``  为"NCDHW"时为 [[0,0], [0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当  ``data_format``  为"NDHWC"时为[[0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；
         - (2)包含 6 个整数值：[padding_depth_front, padding_depth_back, padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；
         - (3)包含 3 个整数值：[padding_depth, padding_height, padding_width]，此时 padding_depth_front = padding_depth_back = padding_depth, padding_height_top = padding_height_bottom = padding_height, padding_width_left = padding_width_right = padding_width。若为一个整数，padding_depth = padding_height = padding_width = padding。默认值：0。
     - **dilation** (int|list|tuple，可选) - 空洞大小。空洞卷积时会使用该参数，卷积核对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息。如果空洞大小为列表或元组，则必须包含两个整型数：（dilation_height,dilation_width）。若为一个整数，dilation_height = dilation_width = dilation。默认值：1。
     - **groups** (int，可选) - 二维卷积层的组数。根据 Alex Krizhevsky 的深度卷积神经网络（CNN）论文中的成组卷积：当 group=n，输入和卷积核分别根据通道数量平均分为 n 组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第 n 组卷积核和第 n 组输入进行卷积计算。默认值：1。
     - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若 ``bias_attr`` 为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若  ``bias_attr``  为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征层深度，H 是特征高度，W 是特征宽度。默认值："NCDHW"。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
-5-D Tensor ，数据类型与 ``input`` 一致。返回卷积计算的结果。
+5-D Tensor ，数据类型与  ``input``  一致。返回卷积计算的结果。
 
 返回类型
 ::::::::::::
diff --git a/docs/api/paddle/sparse/nn/functional/subm_conv3d_cn.rst b/docs/api/paddle/sparse/nn/functional/subm_conv3d_cn.rst
index 37f2c547c35..f052e5b4ecb 100644
--- a/docs/api/paddle/sparse/nn/functional/subm_conv3d_cn.rst
+++ b/docs/api/paddle/sparse/nn/functional/subm_conv3d_cn.rst
@@ -18,8 +18,8 @@ subm_conv3d
     - :math:`X` ：输入值，NCDHW 或 NDHWC 格式的 5-D Tensor
     - :math:`W` ：卷积核值，MCDHW 格式的 5-D Tensor
     - :math:`*` ：卷积操作
-    - :math:`b` ：偏置值，1-D Tensor，形为 ``[M]``
-    - :math:`Out` ：输出值，NCDHW 或 NDHWC 格式的 5-D Tensor，和 ``X`` 的形状可能不同
+    - :math:`b` ：偏置值，1-D Tensor，形为  ``[M]`` 
+    - :math:`Out` ：输出值，NCDHW 或 NDHWC 格式的 5-D Tensor，和  ``X``  的形状可能不同
 
 **示例**
 
@@ -40,18 +40,18 @@ subm_conv3d
     - **weight** (Tensor) - 形状为 :math:`[kD, kH, kW, C/g, M]` 的卷积核（卷积核）。 M 是输出通道数，g 是分组的个数，kH 是卷积核的高度，kW 是卷积核的宽度。
     - **bias** (Tensor，可选) - 偏置项，形状为：:math:`[M]` 。
     - **stride** (int|list|tuple，可选) - 步长大小。卷积核和输入进行卷积计算时滑动的步长。如果它是一个列表或元组，则必须包含三个整型数：（stride_depth, stride_height,stride_width）。若为一个整数，stride_depth = stride_height = stride_width = stride。默认值：1。
-    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 5 个二元组：当 ``data_format`` 为"NCDHW"时为 [[0,0], [0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为"NDHWC"时为[[0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含 6 个整数值：[padding_depth_front, padding_depth_back, padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含 3 个整数值：[padding_depth, padding_height, padding_width]，此时 padding_depth_front = padding_depth_back = padding_depth, padding_height_top = padding_height_bottom = padding_height, padding_width_left = padding_width_right = padding_width。若为一个整数，padding_depth = padding_height = padding_width = padding。默认值：0。
+    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述  ``padding``  = "SAME"或   ``padding``  = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：(1)包含 5 个二元组：当  ``data_format``  为"NCDHW"时为 [[0,0], [0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当  ``data_format``  为"NDHWC"时为[[0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含 6 个整数值：[padding_depth_front, padding_depth_back, padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含 3 个整数值：[padding_depth, padding_height, padding_width]，此时 padding_depth_front = padding_depth_back = padding_depth, padding_height_top = padding_height_bottom = padding_height, padding_width_left = padding_width_right = padding_width。若为一个整数，padding_depth = padding_height = padding_width = padding。默认值：0。
     - **dilation** (int|list|tuple，可选) - 空洞大小。空洞卷积时会使用该参数，卷积核对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息。如果空洞大小为列表或元组，则必须包含两个整型数：（dilation_height,dilation_width）。若为一个整数，dilation_height = dilation_width = dilation。默认值：1。
     - **groups** (int，可选) - 二维卷积层的组数。根据 Alex Krizhevsky 的深度卷积神经网络（CNN）论文中的成组卷积：当 group=n，输入和卷积核分别根据通道数量平均分为 n 组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第 n 组卷积核和第 n 组输入进行卷积计算。默认值：1。
     - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr`。
-    - **bias_attr** (ParamAttr|bool，可选) - 指定偏置参数属性的对象。若 ``bias_attr`` 为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr`。
+    - **bias_attr** (ParamAttr|bool，可选) - 指定偏置参数属性的对象。若  ``bias_attr``  为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr`。
     - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCDHW"和"NDHWC"。N 是批尺寸，C 是通道数，D 是特征层深度，H 是特征高度，W 是特征宽度。默认值："NCDHW"。
     - **key** (str，可选) - 用来保存和使用相同 rulebook 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为 None 。
 
 返回
 ::::::::::::
-5-D Tensor，数据类型与 ``input`` 一致。返回卷积计算的结果。
+5-D Tensor，数据类型与  ``input``  一致。返回卷积计算的结果。
 
 返回类型
 ::::::::::::
diff --git a/docs/api/paddle/sparse/pca_lowrank_cn.rst b/docs/api/paddle/sparse/pca_lowrank_cn.rst
index b9588d8cd9c..21afa4b567f 100644
--- a/docs/api/paddle/sparse/pca_lowrank_cn.rst
+++ b/docs/api/paddle/sparse/pca_lowrank_cn.rst
@@ -17,7 +17,7 @@ pca_lowrank
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 输入的需要进行线性主成分分析的一个稀疏方阵，类型为 Tensor。 ``x`` 的形状应为 ``[M, N]``，数据类型支持 float32， float64。
+    - **x** (Tensor) - 输入的需要进行线性主成分分析的一个稀疏方阵，类型为 Tensor。  ``x``  的形状应为  ``[M, N]`` ，数据类型支持 float32， float64。
     - **q** (int，可选) - 对输入 :math:`X` 的秩稍微高估的预估值，默认值是 :math:`q=min(6,N,M)`。
     - **center** (bool，可选) - 是否对输入矩阵进行中心化操作，类型为 bool ，默认为 True。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
diff --git a/docs/api/paddle/sparse/reshape_cn.rst b/docs/api/paddle/sparse/reshape_cn.rst
index dbfcc58e77b..f5b881b8e71 100644
--- a/docs/api/paddle/sparse/reshape_cn.rst
+++ b/docs/api/paddle/sparse/reshape_cn.rst
@@ -6,16 +6,16 @@ reshape
 .. py:function:: paddle.sparse.reshape(x, shape, name=None)
 
 
-在保持输入 ``x`` 数据不变的情况下，改变 ``x`` 的形状。 ``x`` 必须是一个 ``SparseCooTensor`` 或者 ``SparseCsrTensor`` 。
+在保持输入  ``x``  数据不变的情况下，改变  ``x``  的形状。  ``x``  必须是一个  ``SparseCooTensor``  或者  ``SparseCsrTensor``  。
 
-目前只能针对输入 ``x`` 的 ``sparse dims`` 部分改变形状，但是 ``shape`` 仍必须指定为变形后的 ``Tensor`` 的完整的形状。
+目前只能针对输入  ``x``  的  ``sparse dims``  部分改变形状，但是  ``shape``  仍必须指定为变形后的  ``Tensor``  的完整的形状。
 
-注意如果 ``x`` 是一个 ``SparseCsrTensor`` ， 则 ``len(shape)`` 必须为 2 或者 3。
+注意如果  ``x``  是一个  ``SparseCsrTensor``  ， 则  ``len(shape)``  必须为 2 或者 3。
 
-在指定目标 ``shape`` 时存在一些技巧：
+在指定目标  ``shape``  时存在一些技巧：
 
-  - 1. -1 表示这个维度的值是从 ``x`` 的元素总数和剩余维度推断出来的。因此，有且只有一个维度可以被设置为-1。
-  - 2. 0 表示实际的维数是从 ``x`` 的对应维数中复制出来的，因此 ``shape`` 中 0 的索引值不能超过 ``x`` 的维度。
+  - 1. -1 表示这个维度的值是从  ``x``  的元素总数和剩余维度推断出来的。因此，有且只有一个维度可以被设置为-1。
+  - 2. 0 表示实际的维数是从  ``x``  的对应维数中复制出来的，因此  ``shape``  中 0 的索引值不能超过  ``x``  的维度。
 
 这里有一些例子来解释它们：
 
@@ -24,20 +24,20 @@ reshape
   - 3. 给定一个形状为[2,4,6]的三维 Tensor x ，目标形状为[-1,0,3,2]，则将 x 变换为形状为[2,4,3,2]的 4-D Tensor，且 x 的数据保持不变。在这种情况下， 0 对应位置的维度值将从 x 的对应维数中复制，-1 对应位置的维度值由 x 的元素总数和剩余维度推断出来。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` 。
 
 参数
 :::::::::
 
-  - **x** (Tensor) - ``sparse tensor``，数据类型为 ``float32``、 ``float64``、 ``int32``、 ``int64`` 或者 ``bool``。
-    别名： ``input``
-  - **shape** (list|tuple) - 数据类型是 ``int32``。定义目标形状。目标形状最多只能有一个维度为 -1 。
+  - **x** (Tensor) -  ``sparse tensor`` ，数据类型为  ``float32`` 、  ``float64`` 、  ``int32`` 、  ``int64``  或者  ``bool`` 。
+    别名：  ``input`` 
+  - **shape** (list|tuple) - 数据类型是  ``int32`` 。定义目标形状。目标形状最多只能有一个维度为 -1 。
   - **name** (str ，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None 。
 
 返回
 :::::::::
 
-``Tensor`` ： 改变形状后的 ``Tensor``，数据类型与 ``x`` 相同。
+ ``Tensor``  ： 改变形状后的  ``Tensor`` ，数据类型与  ``x``  相同。
 
 
 代码示例
diff --git a/docs/api/paddle/sparse/slice_cn.rst b/docs/api/paddle/sparse/slice_cn.rst
index d239131106d..287fcc8c077 100644
--- a/docs/api/paddle/sparse/slice_cn.rst
+++ b/docs/api/paddle/sparse/slice_cn.rst
@@ -5,11 +5,11 @@ slice
 
 .. py:function:: paddle.sparse.slice(x, axis, starts, ends, name=None)
 
-沿多个轴生成 ``x`` 的切片。使用 ``axes`` 、 ``starts`` 和 ``ends`` 属性来指定轴列表中每个轴的起点和终点位置，并使用此信息来对 ``x`` 切片。
-如果向 ``starts`` 或 ``ends`` 传递负值如 :math:`-i`，则表示该轴的反向第 :math:`i-1` 个位置（这里以 0 为初始位置）。
-如果传递给 ``starts`` 或 ``end`` 的值大于 n (维度中的元素数目)，则表示 n。
-当切片一个未知数量的维度时，建议传入 ``INT_MAX``。
-``axes`` 、 ``starts`` 和 ``ends`` 三个参数的元素数目必须相等。
+沿多个轴生成  ``x``  的切片。使用  ``axes``  、  ``starts``  和  ``ends``  属性来指定轴列表中每个轴的起点和终点位置，并使用此信息来对  ``x``  切片。
+如果向  ``starts``  或  ``ends``  传递负值如 :math:`-i`，则表示该轴的反向第 :math:`i-1` 个位置（这里以 0 为初始位置）。
+如果传递给  ``starts``  或  ``end``  的值大于 n (维度中的元素数目)，则表示 n。
+当切片一个未知数量的维度时，建议传入  ``INT_MAX`` 。
+ ``axes``  、  ``starts``  和  ``ends``  三个参数的元素数目必须相等。
 
 以下示例将解释切片如何工作 (此处只介绍 Slice 的概念, 故不区分稀疏和稠密 Tensor):
 
@@ -34,15 +34,15 @@ slice
 
 参数
 :::::::::
-    - **x** (Tensor) - 输入的多维 ``Tensor``，数据类型为 bool、float16、float32、float64、int32 或 int64。
-    - **axis** (list|tuple|Tensor) - 数据类型是 ``int32``。如果 ``axes`` 的类型是 list 或 tuple, 它的元素可以是整数或者形状为[1]的 ``Tensor``。如果 ``axes`` 的类型是 ``Tensor``，则是 1-D ``Tensor``。表示进行切片的轴。
-    - **starts** (list|tuple|Tensor) - 数据类型是 ``int32``。如果 ``starts`` 的类型是 list 或 tuple, 它的元素可以是整数或者形状为[1]的 ``Tensor``。如果 ``starts`` 的类型是 ``Tensor``，则是 1-D ``Tensor``。表示在各个轴上切片的起始索引值。
-    - **ends** (list|tuple|Tensor) - 数据类型是 ``int32``。如果 ``ends`` 的类型是 list 或 tuple, 它的元素可以是整数或者形状为[1]的 ``Tensor``。如果 ``ends`` 的类型是 ``Tensor``，则是 1-D ``Tensor``。表示在各个轴上切片的结束索引值。
+    - **x** (Tensor) - 输入的多维  ``Tensor`` ，数据类型为 bool、float16、float32、float64、int32 或 int64。
+    - **axis** (list|tuple|Tensor) - 数据类型是  ``int32`` 。如果  ``axes``  的类型是 list 或 tuple, 它的元素可以是整数或者形状为[1]的  ``Tensor`` 。如果  ``axes``  的类型是  ``Tensor`` ，则是 1-D  ``Tensor`` 。表示进行切片的轴。
+    - **starts** (list|tuple|Tensor) - 数据类型是  ``int32`` 。如果  ``starts``  的类型是 list 或 tuple, 它的元素可以是整数或者形状为[1]的  ``Tensor`` 。如果  ``starts``  的类型是  ``Tensor`` ，则是 1-D  ``Tensor`` 。表示在各个轴上切片的起始索引值。
+    - **ends** (list|tuple|Tensor) - 数据类型是  ``int32`` 。如果  ``ends``  的类型是 list 或 tuple, 它的元素可以是整数或者形状为[1]的  ``Tensor`` 。如果  ``ends``  的类型是  ``Tensor`` ，则是 1-D  ``Tensor`` 。表示在各个轴上切片的结束索引值。
 
 返回
 ::::::::::::
 
-多维 ``Tensor``，数据类型与 ``x`` 相同。
+多维  ``Tensor`` ，数据类型与  ``x``  相同。
 
 
 代码示例
diff --git a/docs/api/paddle/sparse/sparse_coo_tensor_cn.rst b/docs/api/paddle/sparse/sparse_coo_tensor_cn.rst
index b9d4a796757..35c190bfb73 100644
--- a/docs/api/paddle/sparse/sparse_coo_tensor_cn.rst
+++ b/docs/api/paddle/sparse/sparse_coo_tensor_cn.rst
@@ -5,14 +5,14 @@ sparse_coo_tensor
 
 .. py:function:: paddle.sparse.sparse_coo_tensor(indices, values, shape=None, dtype=None, place=None, stop_gradient=True)
 
-该 API 通过已知的非零元素的 ``indices`` 和 ``values`` 来创建一个 coordinate 格式的稀疏 tensor，tensor 类型为 ``paddle.Tensor`` 。
+该 API 通过已知的非零元素的  ``indices``  和  ``values``  来创建一个 coordinate 格式的稀疏 tensor，tensor 类型为  ``paddle.Tensor``  。
 
-其中 ``indices`` 是存放坐标信息，是一个二维数组，每一列是对应非零元素的坐标，shape 是 ``[sparse_dim, nnz]`` , ``sparse_dim`` 是坐标的维度，``nnz`` 是非零元素的个数。
+其中  ``indices``  是存放坐标信息，是一个二维数组，每一列是对应非零元素的坐标，shape 是  ``[sparse_dim, nnz]``  ,  ``sparse_dim``  是坐标的维度， ``nnz``  是非零元素的个数。
 
-其中 ``values`` 是存放非零元素，是一个多维数组，shape 是 ``[nnz, {dense_dim}]`` , nnz 是非零元素个数，``dense_dim`` 是非零元素的维度。
+其中  ``values``  是存放非零元素，是一个多维数组，shape 是  ``[nnz, {dense_dim}]``  , nnz 是非零元素个数， ``dense_dim``  是非零元素的维度。
 
 
-如果 ``values`` 已经是一个 tensor，且 ``dtype`` 、 ``place`` 没有发生变化，将不会发生 tensor 的拷贝并返回原来的 tensor。
+如果  ``values``  已经是一个 tensor，且  ``dtype``  、  ``place``  没有发生变化，将不会发生 tensor 的拷贝并返回原来的 tensor。
 否则会创建一个新的 tensor，且不保留原来计算图。
 
 参数
@@ -25,8 +25,8 @@ sparse_coo_tensor
     - **shape** (list|tuple，可选) - 稀疏 Tensor 的形状，也是 Tensor 的形状，如果没有提供，将自动推测出最小的形状。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 创建 tensor 的数据类型，可以是 'bool' ，'float16'，'float32'，
       'float64' ，'int8'，'int16'，'int32'，'int64'，'uint8'，'complex64'，'complex128'。
-      默认值为 None，如果 ``values`` 为 python 浮点类型，则从
-      :ref:`cn_api_paddle_get_default_dtype` 获取类型，如果 ``values`` 为其他类型，
+      默认值为 None，如果  ``values``  为 python 浮点类型，则从
+      :ref:`cn_api_paddle_get_default_dtype` 获取类型，如果  ``values``  为其他类型，
       则会自动推导类型。
     - **place** (CPUPlace|CUDAPinnedPlace|CUDAPlace|str，可选) - 创建 tensor 的设备位置，可以是
       CPUPlace, CUDAPinnedPlace, CUDAPlace。默认值为 None，使用全局的 place。
@@ -34,7 +34,7 @@ sparse_coo_tensor
 
 返回
 :::::::::
-通过 ``indices`` 和 ``values`` 创建的稀疏 Tensor。
+通过  ``indices``  和  ``values``  创建的稀疏 Tensor。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/sparse/sparse_csr_tensor_cn.rst b/docs/api/paddle/sparse/sparse_csr_tensor_cn.rst
index 3692122c9d4..0cf0f7ca090 100644
--- a/docs/api/paddle/sparse/sparse_csr_tensor_cn.rst
+++ b/docs/api/paddle/sparse/sparse_csr_tensor_cn.rst
@@ -5,22 +5,22 @@ sparse_csr_tensor
 
 .. py:function:: paddle.sparse.sparse_csr_tensor(crows, cols, values, shape=None, dtype=None, place=None, stop_gradient=True)
 
-该 API 通过已知的非零元素的 ``crows`` , ``cols`` 和 ``values`` 来创建一个 CSR(Compressed Sparse Row) 格式的稀疏 tensor，tensor 类型为 ``paddle.Tensor`` 。
+该 API 通过已知的非零元素的  ``crows``  ,  ``cols``  和  ``values``  来创建一个 CSR(Compressed Sparse Row) 格式的稀疏 tensor，tensor 类型为  ``paddle.Tensor``  。
 
-当前 ``sparse_csr_tensor`` 要求输入的 ``crows`` 中每个 batch 的数据是递增的，``cols`` 也是递增的。
+当前  ``sparse_csr_tensor``  要求输入的  ``crows``  中每个 batch 的数据是递增的， ``cols``  也是递增的。
 
-``crows`` 可以是 scalar，tuple，list，numpy\.ndarray，paddle\.Tensor。
-``cols`` 可以是 scalar，tuple，list，numpy\.ndarray，paddle\.Tensor。
-``values`` 可以是 scalar，tuple，list，numpy\.ndarray，paddle\.Tensor。
+ ``crows``  可以是 scalar，tuple，list，numpy\.ndarray，paddle\.Tensor。
+ ``cols``  可以是 scalar，tuple，list，numpy\.ndarray，paddle\.Tensor。
+ ``values``  可以是 scalar，tuple，list，numpy\.ndarray，paddle\.Tensor。
 
 
-如果 ``values`` 已经是一个 tensor，且 ``dtype`` 、 ``place`` 没有发生变化，将不会发生 tensor 的拷贝并返回原来的 tensor。
+如果  ``values``  已经是一个 tensor，且  ``dtype``  、  ``place``  没有发生变化，将不会发生 tensor 的拷贝并返回原来的 tensor。
 否则会创建一个新的 tensor，且不保留原来计算图。
 
 参数
 :::::::::
 
-    - **crows** (list|tuple|ndarray|Tensor) - 每行第一个非零元素在 ``values`` 的起始位置。可以是
+    - **crows** (list|tuple|ndarray|Tensor) - 每行第一个非零元素在  ``values``  的起始位置。可以是
       list，tuple，numpy\.ndarray，paddle\.Tensor 类型。
     - **cols** (list|tuple|ndarray|Tensor) - 一维数组，存储每个非零元素的列信息。可以是
       list，tuple，numpy\.ndarray，paddle\.Tensor 类型。
@@ -29,8 +29,8 @@ sparse_csr_tensor
     - **shape** (list|tuple，可选) - 稀疏 Tensor 的形状，也是 Tensor 的形状，如果没有提供，将自动推测出最小的形状。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 创建 tensor 的数据类型，可以是 'bool' ，'float16'，'float32'，
       'float64' ，'int8'，'int16'，'int32'，'int64'，'uint8'，'complex64'，'complex128'。
-      默认值为 None，如果 ``values`` 为 python 浮点类型，则从
-      :ref:`cn_api_paddle_get_default_dtype` 获取类型，如果 ``values`` 为其他类型，
+      默认值为 None，如果  ``values``  为 python 浮点类型，则从
+      :ref:`cn_api_paddle_get_default_dtype` 获取类型，如果  ``values``  为其他类型，
       则会自动推导类型。
     - **place** (CPUPlace|CUDAPinnedPlace|CUDAPlace|str，可选) - 创建 tensor 的设备位置，可以是
       CPUPlace, CUDAPinnedPlace, CUDAPlace。默认值为 None，使用全局的 place。
@@ -38,7 +38,7 @@ sparse_csr_tensor
 
 返回
 :::::::::
-通过 ``crows``, ``cols`` 和 ``values`` 创建的稀疏 Tensor。
+通过  ``crows`` ,  ``cols``  和  ``values``  创建的稀疏 Tensor。
 
 **代码示例**
 
diff --git a/docs/api/paddle/sparse/sum_cn.rst b/docs/api/paddle/sparse/sum_cn.rst
index 8d14edb308e..42301a7f788 100644
--- a/docs/api/paddle/sparse/sum_cn.rst
+++ b/docs/api/paddle/sparse/sum_cn.rst
@@ -24,7 +24,7 @@ sum
 返回
 ::::::::::::
 
-  ``Tensor``，在指定维度上进行求和运算的 Tensor。如果 `x.dtype='bool'` 或 `x.dtype='int32'`，则其数据类型为 `'int64'`，否则数据类型与 `x` 一致。
+   ``Tensor`` ，在指定维度上进行求和运算的 Tensor。如果 `x.dtype='bool'` 或 `x.dtype='int32'`，则其数据类型为 `'int64'`，否则数据类型与 `x` 一致。
 
 
 代码示例
diff --git a/docs/api/paddle/special/logsumexp_cn.rst b/docs/api/paddle/special/logsumexp_cn.rst
index 889884c6069..cdb85350a75 100644
--- a/docs/api/paddle/special/logsumexp_cn.rst
+++ b/docs/api/paddle/special/logsumexp_cn.rst
@@ -5,4 +5,4 @@ logsumexp
 
 .. py:function:: paddle.special.logsumexp(x, axis=None, keepdim=False, name=None, *, out=None)
 
-``logsumexp`` 的别名，请参考 :ref:`cn_api_paddle_logsumexp`。
+ ``logsumexp``  的别名，请参考 :ref:`cn_api_paddle_logsumexp`。
diff --git a/docs/api/paddle/special/softmax_cn.rst b/docs/api/paddle/special/softmax_cn.rst
index d631d5a3bf5..1bc2c0e51e2 100644
--- a/docs/api/paddle/special/softmax_cn.rst
+++ b/docs/api/paddle/special/softmax_cn.rst
@@ -8,7 +8,7 @@ softmax
 
 步骤 1：输入 :attr:`input` 的 :attr:`dim` 维会被置换到最后一维；
 
-步骤 2：将输入 :attr:`input` 在逻辑上变换为二维矩阵。二维矩阵第一维（列长度）是输入除最后一维之外的其他维度值的乘积，第二维（行长度）和输入 ``dim`` 维的长度相同；对于矩阵的每一行，softmax 操作对其进行重新缩放，使得该行的每个元素在 :math:`[0, 1]` 范围内，并且总和为 :math:`1`；
+步骤 2：将输入 :attr:`input` 在逻辑上变换为二维矩阵。二维矩阵第一维（列长度）是输入除最后一维之外的其他维度值的乘积，第二维（行长度）和输入  ``dim``  维的长度相同；对于矩阵的每一行，softmax 操作对其进行重新缩放，使得该行的每个元素在 :math:`[0, 1]` 范围内，并且总和为 :math:`1`；
 
 步骤 3：softmax 操作执行完成后，执行步骤 1 和步骤 2 的逆运算，将二维矩阵恢复至和输入 :attr:`input` 相同的维度。
 
@@ -84,7 +84,7 @@ softmax
 参数
 ::::::::::
 
-    - **input** (Tensor) - 输入的 ``Tensor``，数据类型为 bfloat16 、 float16 、 float32 或 float64。
+    - **input** (Tensor) - 输入的  ``Tensor`` ，数据类型为 bfloat16 、 float16 、 float32 或 float64。
     - **dim** (int，可选) - 指定对输入 :attr:`input` 进行运算的轴。:attr:`dim` 的有效范围是 :math:`[-D, D)`，:math:`D` 是输入 :attr:`input` 的维度，:attr:`dim` 为负值时与 :math:`dim + D` 等价。默认值为 None。
     - **dtype** (str，可选) - 输出 `Tensor` 的数据类型，支持 bfloat16、 float16、 float32、float64。
     - **out** (Tensor，可选) - 指定输出结果的 `Tensor`，默认值为 None。
@@ -92,7 +92,7 @@ softmax
 返回
 ::::::::::
 
-    ``Tensor``，形状和 :attr:`input` 相同，数据类型为 :attr:`dtype` 或者和 :attr:`input` 相同。
+     ``Tensor`` ，形状和 :attr:`input` 相同，数据类型为 :attr:`dtype` 或者和 :attr:`input` 相同。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/split_cn.rst b/docs/api/paddle/split_cn.rst
index d15115995cf..4e13a59ba61 100644
--- a/docs/api/paddle/split_cn.rst
+++ b/docs/api/paddle/split_cn.rst
@@ -9,7 +9,7 @@ split
 
 将输入 Tensor 分割成多个子 Tensor。
 
-下图展示了一个 split 的情形——一个形状为[4,4,4]的三维张量在进行 split 操作, 其中参数 ``num_or_sections`` 为 2， ``axis`` 为 2。通过比较，可以清晰地看到张量在切割前后的变化。
+下图展示了一个 split 的情形——一个形状为[4,4,4]的三维张量在进行 split 操作, 其中参数  ``num_or_sections``  为 2，  ``axis``  为 2。通过比较，可以清晰地看到张量在切割前后的变化。
 
 .. image:: ../../images/api_legend/split.png
     :width: 600
@@ -18,8 +18,8 @@ split
 参数
 :::::::::
        - **x** (Tensor) - 输入变量，数据类型为 bool、float16、float32、float64、uint8、int8、int32、int64 的多维 Tensor。
-       - **num_or_sections** (int|list|tuple) - 如果 ``num_or_sections`` 是一个整数，则表示 Tensor 平均划分为相同大小子 Tensor 的数量。如果 ``num_or_sections`` 是一个 list 或 tuple，那么它的长度代表子 Tensor 的数量，它的元素可以是整数或者形状为[]的 0-D Tensor，依次代表子 Tensor 需要分割成的维度的大小。list 或 tuple 的长度不能超过输入 Tensor 待分割的维度的大小。在 list 或 tuple 中，至多有一个元素值为-1，表示该值是由 ``x`` 的维度和其他 ``num_or_sections`` 中元素推断出来的。例如对一个维度为[4, 6, 6] Tensor 的第三维进行分割时，指定 ``num_or_sections=[2,-1,1]``，输出的三个 Tensor 维度分别为：[4, 6, 2]，[4, 6, 3]，[4, 6, 1]。
-       - **axis** (int|Tensor，可选) - 整数或者形状为[]的 0-D Tensor，数据类型为 int32 或 int64。表示需要分割的维度。如果 ``axis < 0``，则划分的维度为 ``rank(x) + axis``。默认值为 0。
+       - **num_or_sections** (int|list|tuple) - 如果  ``num_or_sections``  是一个整数，则表示 Tensor 平均划分为相同大小子 Tensor 的数量。如果  ``num_or_sections``  是一个 list 或 tuple，那么它的长度代表子 Tensor 的数量，它的元素可以是整数或者形状为[]的 0-D Tensor，依次代表子 Tensor 需要分割成的维度的大小。list 或 tuple 的长度不能超过输入 Tensor 待分割的维度的大小。在 list 或 tuple 中，至多有一个元素值为-1，表示该值是由  ``x``  的维度和其他  ``num_or_sections``  中元素推断出来的。例如对一个维度为[4, 6, 6] Tensor 的第三维进行分割时，指定  ``num_or_sections=[2,-1,1]`` ，输出的三个 Tensor 维度分别为：[4, 6, 2]，[4, 6, 3]，[4, 6, 1]。
+       - **axis** (int|Tensor，可选) - 整数或者形状为[]的 0-D Tensor，数据类型为 int32 或 int64。表示需要分割的维度。如果  ``axis < 0`` ，则划分的维度为  ``rank(x) + axis`` 。默认值为 0。
        - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/sqrt_cn.rst b/docs/api/paddle/sqrt_cn.rst
index 5edb401c36c..95b60c380fd 100644
--- a/docs/api/paddle/sqrt_cn.rst
+++ b/docs/api/paddle/sqrt_cn.rst
@@ -13,7 +13,7 @@ sqrt
 .. math:: out=\sqrt x=x^{1/2}
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``；
+    别名支持: 参数名  ``input``  可替代  ``x`` ；
 
 .. note::
     请确保输入中的数值是非负数。
@@ -23,7 +23,7 @@ sqrt
 
 
     - **x** (Tensor) - 支持任意维度的 Tensor。数据类型为 float16，float32，float64，complex64 或 complex128。
-      ``别名: input``
+       ``别名: input`` 
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
     - **out** (Tensor，可选) - 关键字参数。输出 Tensor，用于存储计算结果。如果指定，则结果将写入此 Tensor 中。
 
diff --git a/docs/api/paddle/squeeze_cn.rst b/docs/api/paddle/squeeze_cn.rst
index 65a1cb82da3..5d92b4114d1 100644
--- a/docs/api/paddle/squeeze_cn.rst
+++ b/docs/api/paddle/squeeze_cn.rst
@@ -51,17 +51,17 @@ squeeze
     :alt: 图例
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``dim`` 可替代 ``axis``，如 ``squeeze(input=tensor_x, dim=1)`` 等价于 ``squeeze(x=tensor_x, axis=1)``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，参数名  ``dim``  可替代  ``axis`` ，如  ``squeeze(input=tensor_x, dim=1)``  等价于  ``squeeze(x=tensor_x, axis=1)`` 。
 
 参数
 :::::::::
-        - **x** (Tensor) - 输入的 `Tensor` ，数据类型为：float32、float64、bool、int8、int32、int64。别名： ``input``。
-        - **axis** (int|list|tuple，可选) - 输入一个或一列整数，代表要压缩的轴。axis 的范围： [−ndim(x), ndim(x)) 。 如果 axis 为负数， 则 axis=axis+ndim(x) 。默认为 None，表示对所有尺寸为 1 的维度进行压缩。别名： ``dim``。
+        - **x** (Tensor) - 输入的 `Tensor` ，数据类型为：float32、float64、bool、int8、int32、int64。别名：  ``input`` 。
+        - **axis** (int|list|tuple，可选) - 输入一个或一列整数，代表要压缩的轴。axis 的范围： [−ndim(x), ndim(x)) 。 如果 axis 为负数， 则 axis=axis+ndim(x) 。默认为 None，表示对所有尺寸为 1 的维度进行压缩。别名：  ``dim`` 。
         - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-``Tensor``，对维度进行压缩后的 Tensor，数据类型与输入 Tensor 一致。
+ ``Tensor`` ，对维度进行压缩后的 Tensor，数据类型与输入 Tensor 一致。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/stack_cn.rst b/docs/api/paddle/stack_cn.rst
index c81a2ee3ea8..2f32ca327fe 100644
--- a/docs/api/paddle/stack_cn.rst
+++ b/docs/api/paddle/stack_cn.rst
@@ -8,7 +8,7 @@ stack
 
 
 沿 axis 轴对输入 x 进行堆叠操作。要求所有输入 Tensor 有相同的 Shape 和数据类型。
-例如，输入 x 为 N 个 Shape 为 [A, B]的 Tensor，如果 ``axis==0``，则输出 Tensor 的 Shape 为 [N, A, B]；如果 ``axis==1``，则输出 Tensor 的 Shape 为 [A, N, B]；以此类推。
+例如，输入 x 为 N 个 Shape 为 [A, B]的 Tensor，如果  ``axis==0`` ，则输出 Tensor 的 Shape 为 [N, A, B]；如果  ``axis==1`` ，则输出 Tensor 的 Shape 为 [A, N, B]；以此类推。
 
 .. code-block:: text
 
@@ -73,14 +73,14 @@ stack
 参数
 :::::::::
 
-    - **x** (list[Tensor]|tuple[Tensor]) – 输入 x 是多个 Tensor，且这些 Tensor 的维度和数据类型必须相同。支持的数据类型：float32、float64、int32、int64。别名 ``input``。
-    - **axis** (int，可选) – 指定对输入 Tensor 进行堆叠运算的轴，有效 axis 的范围是：[−(R+1),R+1)，R 是输入中第一个 Tensor 的维数。如果 axis < 0，则 axis=axis+R+1。默认值为 0。别名 ``dim``。
+    - **x** (list[Tensor]|tuple[Tensor]) – 输入 x 是多个 Tensor，且这些 Tensor 的维度和数据类型必须相同。支持的数据类型：float32、float64、int32、int64。别名  ``input`` 。
+    - **axis** (int，可选) – 指定对输入 Tensor 进行堆叠运算的轴，有效 axis 的范围是：[−(R+1),R+1)，R 是输入中第一个 Tensor 的维数。如果 axis < 0，则 axis=axis+R+1。默认值为 0。别名  ``dim`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/standard_normal_cn.rst b/docs/api/paddle/standard_normal_cn.rst
index 214886c337a..4c7b8a9e3e8 100644
--- a/docs/api/paddle/standard_normal_cn.rst
+++ b/docs/api/paddle/standard_normal_cn.rst
@@ -5,17 +5,17 @@ standard_normal
 
 .. py:function:: paddle.standard_normal(shape, dtype=None, name=None)
 
-返回符合标准正态分布（均值为 0，标准差为 1 的正态随机分布）的随机 Tensor，形状为 ``shape``，数据类型为 ``dtype``。
+返回符合标准正态分布（均值为 0，标准差为 1 的正态随机分布）的随机 Tensor，形状为  ``shape`` ，数据类型为  ``dtype`` 。
 
 参数
 ::::::::::
-  - **shape** (list|tuple|Tensor) - 生成的随机 Tensor 的形状。如果 ``shape`` 是 list、tuple，则其中的元素可以是 int，或者是形状为[]且数据类型为 int32、int64 的 0-D Tensor。如果 ``shape`` 是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor。
+  - **shape** (list|tuple|Tensor) - 生成的随机 Tensor 的形状。如果  ``shape``  是 list、tuple，则其中的元素可以是 int，或者是形状为[]且数据类型为 int32、int64 的 0-D Tensor。如果  ``shape``  是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor。
   - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，支持 float16、bfloat16、float32、float64、complex64、complex128。当该参数值为 None 时，输出 Tensor 的数据类型为 float32。默认值为 None。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-  Tensor：符合标准正态分布的随机 Tensor，形状为 ``shape``，数据类型为 ``dtype``。
+  Tensor：符合标准正态分布的随机 Tensor，形状为  ``shape`` ，数据类型为  ``dtype`` 。
 
 示例代码
 ::::::::::
diff --git a/docs/api/paddle/stanh_cn.rst b/docs/api/paddle/stanh_cn.rst
index 3442713b6ea..ef68628455e 100644
--- a/docs/api/paddle/stanh_cn.rst
+++ b/docs/api/paddle/stanh_cn.rst
@@ -13,14 +13,14 @@ stanh 激活函数
 
 参数
 ::::::::::::
-    - **x** (Tensor) - 输入的 ``Tensor``，数据类型为：float32、float64。
+    - **x** (Tensor) - 输入的  ``Tensor`` ，数据类型为：float32、float64。
     - **scale_a** (float，可选) - stanh 激活计算公式中的输入缩放参数 a。默认值为 0.67。
     - **scale_b** (float，可选) - stanh 激活计算公式中的输出缩放参数 b。默认值为 1.7159。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，数据类型和形状同 ``x`` 一致。
+     ``Tensor`` ，数据类型和形状同  ``x``  一致。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/static/BuildStrategy_cn.rst b/docs/api/paddle/static/BuildStrategy_cn.rst
index f519a0a494a..7690f27e89f 100644
--- a/docs/api/paddle/static/BuildStrategy_cn.rst
+++ b/docs/api/paddle/static/BuildStrategy_cn.rst
@@ -5,7 +5,7 @@ BuildStrategy
 
 .. py:class:: paddle.static.BuildStrategy
 
-``BuildStrategy`` 使用户更方便地控制 ``ParallelExecutor`` 中计算图的建造方法，可通过设置 ``ParallelExecutor`` 中的 ``BuildStrategy`` 成员来实现此功能。
+ ``BuildStrategy``  使用户更方便地控制  ``ParallelExecutor``  中计算图的建造方法，可通过设置  ``ParallelExecutor``  中的  ``BuildStrategy``  成员来实现此功能。
 
 返回
 :::::::::
@@ -72,8 +72,8 @@ bool 类型或 None。设为 True 时可用于减少总内存消耗，False 表
 reduce_strategy
 '''''''''
 
-``static.BuildStrategy.ReduceStrategy`` 类型。在 ``ParallelExecutor`` 中，存在两种参数梯度聚合策略，即 ``AllReduce`` 和 ``Reduce``。如果用户需要在所有执行设备上独立地进行参数更新，可以使用 ``AllReduce``。如果使用 ``Reduce`` 策略，所有参数的优化将均匀地分配给不同的执行设备，随之将优化后的参数广播给其他执行设备。
-默认值为 ``AllReduce`` 。
+ ``static.BuildStrategy.ReduceStrategy``  类型。在  ``ParallelExecutor``  中，存在两种参数梯度聚合策略，即  ``AllReduce``  和  ``Reduce`` 。如果用户需要在所有执行设备上独立地进行参数更新，可以使用  ``AllReduce`` 。如果使用  ``Reduce``  策略，所有参数的优化将均匀地分配给不同的执行设备，随之将优化后的参数广播给其他执行设备。
+默认值为  ``AllReduce``  。
 
 **代码示例**
 
diff --git a/docs/api/paddle/static/CompiledProgram_cn.rst b/docs/api/paddle/static/CompiledProgram_cn.rst
index 80f1b3bdcfc..e36d34e6041 100644
--- a/docs/api/paddle/static/CompiledProgram_cn.rst
+++ b/docs/api/paddle/static/CompiledProgram_cn.rst
@@ -16,7 +16,7 @@ CompiledProgram 根据 `build_strategy` 的配置将输入的 Program 或 Graph
 
 返回
 :::::::::
-CompiledProgram，初始化后的 ``CompiledProgram`` 对象。
+CompiledProgram，初始化后的  ``CompiledProgram``  对象。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/static/Executor_cn.rst b/docs/api/paddle/static/Executor_cn.rst
index b86ada1e857..fc507a46848 100644
--- a/docs/api/paddle/static/Executor_cn.rst
+++ b/docs/api/paddle/static/Executor_cn.rst
@@ -19,7 +19,7 @@ Executor 支持单 GPU、多 GPU 以及 CPU 运行。
 
 返回
 ::::::::::::
-初始化后的 ``Executor`` 对象。
+初始化后的  ``Executor``  对象。
 
 代码示例
 ::::::::::::
@@ -50,13 +50,13 @@ run(program=None, feed=None, fetch_list=None, feed_var_name='feed', fetch_var_na
 **参数**
 
   - **program** (Program|CompiledProgram，可选) – 该参数为被执行的 Program 或 CompiledProgram，如果未提供该参数，即该参数为 None，在该接口内，main_program 将被设置为 paddle.static.default_main_program()。默认为：None。
-  - **feed** (list|dict，可选) – 该参数表示模型的输入变量。如果是单卡训练，``feed`` 为 ``dict`` 类型，如果是多卡训练，参数 ``feed`` 可以是 ``dict`` 或者 ``list`` 类型变量，如果该参数类型为 ``dict`` ，feed 中的数据将会被分割(split)并分送给多个设备（CPU/GPU），即输入数据被均匀分配到不同设备上；如果该参数类型为 ``list``，则列表中的各个元素都会直接分别被拷贝到各设备中。默认为：None。
+  - **feed** (list|dict，可选) – 该参数表示模型的输入变量。如果是单卡训练， ``feed``  为  ``dict``  类型，如果是多卡训练，参数  ``feed``  可以是  ``dict``  或者  ``list``  类型变量，如果该参数类型为  ``dict``  ，feed 中的数据将会被分割(split)并分送给多个设备（CPU/GPU），即输入数据被均匀分配到不同设备上；如果该参数类型为  ``list`` ，则列表中的各个元素都会直接分别被拷贝到各设备中。默认为：None。
   - **fetch_list** (list，可选) – 该参数表示模型运行之后需要返回的变量。默认为：None。
   - **feed_var_name** (str，可选) – 该参数表示数据输入算子(feed operator)的输入变量名称。默认为："feed"。
   - **fetch_var_name** (str，可选) – 该参数表示结果获取算子(fetch operator)的输出变量名称。默认为："fetch"。
   - **scope** (Scope，可选) – 该参数表示执行当前 program 所使用的作用域，用户可以为不同的 program 指定不同的作用域。默认值：paddle.static.global_scope()。
   - **return_numpy** (bool，可选) – 该参数表示是否将返回的计算结果（fetch list 中指定的变量）转化为 numpy；如果为 False，则每个变量返回的类型为 Tensor，否则返回变量的类型为 numpy.ndarray。默认为：True。
-  - **use_program_cache** (bool，可选) – 该参数表示是否对输入的 Program 进行缓存。如果该参数为 True，在以下情况时，模型运行速度可能会更快：输入的 program 为 ``paddle.static.Program``，并且模型运行过程中，调用该接口的参数（program、 feed 变量名和 fetch_list 变量）名始终不变。默认为：False。
+  - **use_program_cache** (bool，可选) – 该参数表示是否对输入的 Program 进行缓存。如果该参数为 True，在以下情况时，模型运行速度可能会更快：输入的 program 为  ``paddle.static.Program`` ，并且模型运行过程中，调用该接口的参数（program、 feed 变量名和 fetch_list 变量）名始终不变。默认为：False。
   - **use_prune** (bool，可选) - 该参数表示输入 Program 是否会被裁剪。如果该参数为 True，会根据 feed 和 fetch_list 裁剪 Program，这意味着对生成 fetch_list 没有必要的算子和变量会被裁剪掉。默认为 False，即算子和变量在运行过程不会被裁剪。注意如果 Optimizer.minimize()返回的 tuple 被作为 fetch_list 参数，那么 use_prune 会被重载为 True 并且 Program 会被裁剪。
 
 **返回**
diff --git a/docs/api/paddle/static/ExponentialMovingAverage_cn.rst b/docs/api/paddle/static/ExponentialMovingAverage_cn.rst
index 1b4a6559774..540450acf04 100644
--- a/docs/api/paddle/static/ExponentialMovingAverage_cn.rst
+++ b/docs/api/paddle/static/ExponentialMovingAverage_cn.rst
@@ -10,23 +10,23 @@ ExponentialMovingAverage
 .. math::
     \begin{align}\begin{aligned}\text{EMA}_0 & = 0\\\text{EMA}_t & = \text{decay} * \text{EMA}_{t-1} + (1 - \text{decay}) * \theta_t\end{aligned}\end{align}
 
-用 ``update()`` 方法计算出的平均结果将保存在由实例化对象创建和维护的临时变量中，并且可以通过调用 ``apply()`` 方法把结果应用于当前模型的参数。同时，可用 ``restore()`` 方法恢复原始参数。
+用  ``update()``  方法计算出的平均结果将保存在由实例化对象创建和维护的临时变量中，并且可以通过调用  ``apply()``  方法把结果应用于当前模型的参数。同时，可用  ``restore()``  方法恢复原始参数。
 
 **偏置校正**
 
-所有的滑动平均均初始化为 :math:`0`，因此它们相对于零是有偏的，可以通过除以因子 :math:`(1 - \text{decay}^t)` 来校正，因此在调用 ``apply()`` 方法时，作用于参数的真实滑动平均值将为：
+所有的滑动平均均初始化为 :math:`0`，因此它们相对于零是有偏的，可以通过除以因子 :math:`(1 - \text{decay}^t)` 来校正，因此在调用  ``apply()``  方法时，作用于参数的真实滑动平均值将为：
 
 .. math::
     \widehat{\text{EMA}}_t = \frac{\text{EMA}_t}{1 - \text{decay}^t}
 
 **衰减率调节**
 
-一个非常接近于 1 的很大的衰减率将会导致平均值滑动得很慢。更优的策略是，开始时设置一个相对较小的衰减率。参数 ``thres_steps`` 允许用户传递一个变量以设置衰减率，在这种情况下，
+一个非常接近于 1 的很大的衰减率将会导致平均值滑动得很慢。更优的策略是，开始时设置一个相对较小的衰减率。参数  ``thres_steps``  允许用户传递一个变量以设置衰减率，在这种情况下，
 真实的衰减率变为：
 
 .. math::
     \min(\text{decay}, \frac{1 + \text{thres_steps}}{10 + \text{thres_steps}})
-通常 ``thres_steps`` 可以是全局的训练迭代步数。
+通常  ``thres_steps``  可以是全局的训练迭代步数。
 
 参数
 :::::::::
@@ -55,7 +55,7 @@ apply(executor, need_restore=True)
 **参数**
 
     - **executor** (Executor) – 将滑动平均值作用在参数上的执行器。
-    - **need_restore** (bool，可选) – 是否在结束后恢复原始参数，默认值为 ``True`` 。
+    - **need_restore** (bool，可选) – 是否在结束后恢复原始参数，默认值为  ``True``  。
 
 
 restore(executor)
diff --git a/docs/api/paddle/static/InputSpec_cn.rst b/docs/api/paddle/static/InputSpec_cn.rst
index 81a197d68c6..e537367b37a 100644
--- a/docs/api/paddle/static/InputSpec_cn.rst
+++ b/docs/api/paddle/static/InputSpec_cn.rst
@@ -7,19 +7,19 @@ InputSpec
 .. py:class:: paddle.static.InputSpec(shape, dtype='float32', name=None, stop_gradient=False)
 用于描述模型输入的签名信息，包括 shape、dtype 和 name。
 
-此接口常用于指定高层 API 中模型的输入 Tensor 信息，或动态图转静态图时，指定被 ``paddle.jit.to_static`` 装饰的 forward 函数每个输入参数的 Tensor 信息。
+此接口常用于指定高层 API 中模型的输入 Tensor 信息，或动态图转静态图时，指定被  ``paddle.jit.to_static``  装饰的 forward 函数每个输入参数的 Tensor 信息。
 
 参数
 ::::::::::::
 
-  - **shape** (tuple(integers)|list[integers])- 声明维度信息的 list 或 tuple，默认值为 None。设置为 ``None`` 或 ``-1`` 时表示维度可以是任意大小。例如，可以将可变的批尺寸（batch size）设置为 ``None`` 或 ``-1`` 。
+  - **shape** (tuple(integers)|list[integers])- 声明维度信息的 list 或 tuple，默认值为 None。设置为  ``None``  或  ``-1``  时表示维度可以是任意大小。例如，可以将可变的批尺寸（batch size）设置为  ``None``  或  ``-1``  。
   - **dtype** (str|paddle.dtype|np.dtype，可选)- 数据类型，支持 bool，float16，float32，float64，int8，int16，int32，int64，uint8。默认值为 float32。
   - **name** (str，可选) - 变量的名称，具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
   - **stop_gradient** (bool，可选) - 提示是否应该停止计算梯度，默认值为 False，表示不停止计算梯度。
 
 返回
 ::::::::::::
-初始化后的 ``InputSpec`` 对象。
+初始化后的  ``InputSpec``  对象。
 
 
 代码示例
@@ -41,7 +41,7 @@ from_tensor(tensor, name=None)
 
 **返回**
 
-根据 Tensor 信息构造的 ``InputSpec`` 对象。
+根据 Tensor 信息构造的  ``InputSpec``  对象。
 
 
 **代码示例**
@@ -61,7 +61,7 @@ from_numpy(ndarray, name=None)
 
 **返回**
 
-根据 ndarray 信息构造的 ``InputSpec`` 对象。
+根据 ndarray 信息构造的  ``InputSpec``  对象。
 
 
 **代码示例**
@@ -79,7 +79,7 @@ batch(batch_size)
 
 **返回**
 
- 更新 shape 信息后的 ``InputSpec`` 对象。
+ 更新 shape 信息后的  ``InputSpec``  对象。
 
 
 **代码示例**
@@ -94,7 +94,7 @@ unbatch()
 
 **返回**
 
- 更新 shape 信息后的 ``InputSpec`` 对象。
+ 更新 shape 信息后的  ``InputSpec``  对象。
 
 
 **代码示例**
diff --git a/docs/api/paddle/static/IpuCompiledProgram_cn.rst b/docs/api/paddle/static/IpuCompiledProgram_cn.rst
index fe006fcd27a..56bc2f44bfa 100644
--- a/docs/api/paddle/static/IpuCompiledProgram_cn.rst
+++ b/docs/api/paddle/static/IpuCompiledProgram_cn.rst
@@ -17,7 +17,7 @@ IpuCompiledProgram 将输入的 Program 转换和优化成 IPU 所需要的形
 
 返回
 :::::::::
-IpuCompiledProgram，初始化后的 ``IpuCompiledProgram`` 对象。
+IpuCompiledProgram，初始化后的  ``IpuCompiledProgram``  对象。
 
 代码示例
 ::::::::::
@@ -38,7 +38,7 @@ compile(self, feed_list, fetch_list)
 
 **返回**
 
-Program，编译之后的 ``Program`` 对象。
+Program，编译之后的  ``Program``  对象。
 
 
 **代码示例**
diff --git a/docs/api/paddle/static/IpuStrategy_cn.rst b/docs/api/paddle/static/IpuStrategy_cn.rst
index dd277ffe542..775299562ec 100644
--- a/docs/api/paddle/static/IpuStrategy_cn.rst
+++ b/docs/api/paddle/static/IpuStrategy_cn.rst
@@ -7,7 +7,7 @@ IpuStrategy
 .. py:class:: paddle.static.IpuStrategy()
 
 
-``IpuStrategy`` 使用户能更精准地控制 :ref:`cn_api_paddle_static_IpuCompiledProgram` 中计算图的建造方法。
+ ``IpuStrategy``  使用户能更精准地控制 :ref:`cn_api_paddle_static_IpuCompiledProgram` 中计算图的建造方法。
 
 
 返回
@@ -137,7 +137,7 @@ COPY-FROM: paddle.static.IpuStrategy.disable_pattern
 register_patch(self)
 '''''''''
 
-注册 patch function 以支持 IPU 上的动转静功能。该函数仅应在 IPU 动转静时使用，注册的函数会影响原动转静的逻辑，可通过``release_patch``释放注册的函数。
+注册 patch function 以支持 IPU 上的动转静功能。该函数仅应在 IPU 动转静时使用，注册的函数会影响原动转静的逻辑，可通过 ``release_patch`` 释放注册的函数。
 
 **代码示例**
 
@@ -183,19 +183,19 @@ COPY-FROM: paddle.static.IpuStrategy.parse_optimizer
 num_ipus
 '''''''''
 
-返回 IpuStrategy 实例中的 IPU 设备个数，类型为 ``Int``。
+返回 IpuStrategy 实例中的 IPU 设备个数，类型为  ``Int`` 。
 
 is_training
 '''''''''
 
-返回 IpuStrategy 实例中的计算模式是训练模式或推理模式，类型为 ``Bool``。
+返回 IpuStrategy 实例中的计算模式是训练模式或推理模式，类型为  ``Bool`` 。
 
 enable_pipelining
 '''''''''
 
-返回 IpuStrategy 实例中是否使能数据流水线功能，类型为 ``Bool``。
+返回 IpuStrategy 实例中是否使能数据流水线功能，类型为  ``Bool`` 。
 
 enable_fp16
 '''''''''
 
-返回 IpuStrategy 实例中是否使能 float16 计算图，类型为 ``Bool``。
+返回 IpuStrategy 实例中是否使能 float16 计算图，类型为  ``Bool`` 。
diff --git a/docs/api/paddle/static/Print_cn.rst b/docs/api/paddle/static/Print_cn.rst
index 6fb10f97274..4a0fa2d62db 100644
--- a/docs/api/paddle/static/Print_cn.rst
+++ b/docs/api/paddle/static/Print_cn.rst
@@ -24,7 +24,7 @@ Print
     - **print_tensor_shape** (bool，可选) - 指明是否打印 Tensor 维度信息，默认为 True。
     - **print_tensor_layout** (bool，可选) - 指明是否打印 Tensor 布局信息，默认为 True。
     - **print_tensor_lod** (bool，可选) - 指明是否打印 Tensor 的 LoD 信息，默认为 True。
-    - **print_phase** (str，可选) - 指明打印的阶段，包括 ``forward`` , ``backward`` 和 ``both``，默认为 ``both``。设置为 ``forward`` 时，只打印 Tensor 的前向信息；设置为 ``backward`` 时，只打印 Tensor 的梯度信息；设置为 ``both`` 时，则同时打印 Tensor 的前向信息以及梯度信息。
+    - **print_phase** (str，可选) - 指明打印的阶段，包括  ``forward``  ,  ``backward``  和  ``both`` ，默认为  ``both`` 。设置为  ``forward``  时，只打印 Tensor 的前向信息；设置为  ``backward``  时，只打印 Tensor 的梯度信息；设置为  ``both``  时，则同时打印 Tensor 的前向信息以及梯度信息。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/static/Program_cn.rst b/docs/api/paddle/static/Program_cn.rst
index c25118d112b..477bc2c3684 100644
--- a/docs/api/paddle/static/Program_cn.rst
+++ b/docs/api/paddle/static/Program_cn.rst
@@ -12,7 +12,7 @@ Program
 Program 是 Paddle 对于计算图的一种静态描述，使用 Program 的构造函数可以创建一个 Program。Program 中包括至少一个 :ref:`api_guide_Block`，当 :ref:`api_guide_Block` 中存在条件选择的控制流 OP（例如 :ref:`cn_api_paddle_static_nn_while_loop` 等）时，该 Program 将会含有嵌套着的 :ref:`api_guide_Block` 即控制流外部的 :ref:`api_guide_Block` 将包含着控制流内部的 :ref:`api_guide_Block`，而嵌套的 :ref:`api_guide_Block` 的元素访问控制将由具体的控制流 OP 来决定。关于 Program 具体的结构和包含的类型请参阅 `framework.proto <https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/framework/framework.proto>`_
 。
 
-一个 Program 的集合通常包含初始化程序（startup_program）与主程序（main_program），初始化程序是一个包含一些初始化工作的 Program，主程序将会包含用来训练的网络结构和变量，在使用同一个 :ref:`api_guide_executor` 执行时他们会共享初始化工作的结果，例如初始化的参数。一个 Program 的集合可以被用来测试或者训练，被用来训练时，``Paddle`` 将会利用所有用户使用的 OP 和变量来搭建一个训练网络，被用来测试时，可以通过调用 Program 相关的接口例如：``clone`` 剪去一些与测试无关的 OP 和变量，比如反向传播的 OP 和变量。
+一个 Program 的集合通常包含初始化程序（startup_program）与主程序（main_program），初始化程序是一个包含一些初始化工作的 Program，主程序将会包含用来训练的网络结构和变量，在使用同一个 :ref:`api_guide_executor` 执行时他们会共享初始化工作的结果，例如初始化的参数。一个 Program 的集合可以被用来测试或者训练，被用来训练时， ``Paddle``  将会利用所有用户使用的 OP 和变量来搭建一个训练网络，被用来测试时，可以通过调用 Program 相关的接口例如： ``clone``  剪去一些与测试无关的 OP 和变量，比如反向传播的 OP 和变量。
 
 
 返回
@@ -35,7 +35,7 @@ to_string(throw_on_error, with_details=False)
 **参数**
 
  - **throw_on_error** (bool) - 是否在没有设置必需字段时抛出异常。
- - **with_details** (bool) - 值为 true 时，打印更多关于变量和参数的信息，如 ``trainable``， ``optimize_attr`` 等。
+ - **with_details** (bool) - 值为 true 时，打印更多关于变量和参数的信息，如  ``trainable`` ，  ``optimize_attr``  等。
 
 
 **返回**
@@ -51,16 +51,16 @@ clone(for_test=False)
 '''''''''
 
 .. note::
-    1. ``Program.clone()`` 方法不会克隆例如 :ref:`cn_api_paddle_io_DataLoader` 这样的数据读取相关的部分，这可能会造成的数据读取部分在克隆后丢失；
-    2. 此 API 当 ``for_test=True`` 时将会裁剪部分 OP 和变量。为防止错误的裁剪，推荐在 :ref:`cn_api_paddle_static_append_backward` 和执行优化器之前使用；``clone(for_test=True)`` 。
+    1.  ``Program.clone()``  方法不会克隆例如 :ref:`cn_api_paddle_io_DataLoader` 这样的数据读取相关的部分，这可能会造成的数据读取部分在克隆后丢失；
+    2. 此 API 当  ``for_test=True``  时将会裁剪部分 OP 和变量。为防止错误的裁剪，推荐在 :ref:`cn_api_paddle_static_append_backward` 和执行优化器之前使用； ``clone(for_test=True)``  。
 
 
-当 ``for_test=True`` 时创建一个新的、仅包含当前 Program 前向内容的 Program。否则创建一个新的和当前 Program 完全相同的 Program。
+当  ``for_test=True``  时创建一个新的、仅包含当前 Program 前向内容的 Program。否则创建一个新的和当前 Program 完全相同的 Program。
 
-有些 OP，在训练和测试之间的行为是不同的，比如 :ref:`cn_api_paddle_static_nn_batch_norm`。它们有一个属性 ``is_test`` 来控制行为。当 ``for_test=True`` 时，此方法将把它们的 ``is_test`` 属性更改为 True。
+有些 OP，在训练和测试之间的行为是不同的，比如 :ref:`cn_api_paddle_static_nn_batch_norm`。它们有一个属性  ``is_test``  来控制行为。当  ``for_test=True``  时，此方法将把它们的  ``is_test``  属性更改为 True。
 
-- 克隆 Program 用于训练时，将 ``for_test`` 设置为 False。
-- 克隆 Program 用于测试时，将 ``for_test`` 设置为 True。虽然在这种情况下，如果在使用了优化器之后调用 ``clone`` 我们依旧会对 Program 当中反向执行以及优化器相关的内容进行自动裁剪，但是，我们强烈建议在使用优化器之前使用 ``clone`` 例如如果使用的是 :ref:`cn_api_paddle_optimizer_Momentum` 可以这样去使用：
+- 克隆 Program 用于训练时，将  ``for_test``  设置为 False。
+- 克隆 Program 用于测试时，将  ``for_test``  设置为 True。虽然在这种情况下，如果在使用了优化器之后调用  ``clone``  我们依旧会对 Program 当中反向执行以及优化器相关的内容进行自动裁剪，但是，我们强烈建议在使用优化器之前使用  ``clone``  例如如果使用的是 :ref:`cn_api_paddle_optimizer_Momentum` 可以这样去使用：
 
 **代码示例**
 
@@ -68,11 +68,11 @@ COPY-FROM: paddle.static.Program.clone:code-example-1
 
 **参数**
 
-    - **for_test** (bool，可选) – 取值为 True 时，clone 方法内部会把 operator 的属性 ``is_test`` 设置为 True，并裁剪反向 OP 和参数优化 OP，默认值为 False。
+    - **for_test** (bool，可选) – 取值为 True 时，clone 方法内部会把 operator 的属性  ``is_test``  设置为 True，并裁剪反向 OP 和参数优化 OP，默认值为 False。
 
 **返回**
 
-Program，当 ``for_test=True`` 时返回一个新的、仅包含当前 Program 前向内容的 Program。否则返回一个新的，和当前 Program 完全相同的 Program。
+Program，当  ``for_test=True``  时返回一个新的、仅包含当前 Program 前向内容的 Program。否则返回一个新的，和当前 Program 完全相同的 Program。
 
 
 **代码示例**
@@ -158,7 +158,7 @@ COPY-FROM: paddle.static.Program.global_block
 block(index)
 '''''''''
 
-返回该 Program 中，``index`` 指定的 :ref:`api_guide_Block` 。 ``index`` 类型为 ``int`` 。
+返回该 Program 中， ``index``  指定的 :ref:`api_guide_Block` 。  ``index``  类型为  ``int``  。
 
 **参数**
 
@@ -218,12 +218,12 @@ COPY-FROM: paddle.static.Program.all_parameters
 state_dict(mode='all', scope=None)
 '''''''''
 
-获取当前 ``Program`` 持久性变量。并将所有持久性变量存放在 dict 结构中。
+获取当前  ``Program``  持久性变量。并将所有持久性变量存放在 dict 结构中。
 
 **参数**
 
-    - **mode** (str，可选) - 获取何种持久性变量。目前支持以下选项：(1) ``opt``：获得优化器的持久性变量放在 ``dict`` 结构中；(2) ``param``：获得组网中的持久性变量放在 ``dict`` 结构中，不包含优化器中的持久性变量；(3) ``all``：获得组网和优化器中的持久性变量放在 dict 结构中；默认值为 ``all``。
-    - **scope** (Scope，可选) - 如果 scope 为 ``None``，通过 `paddle.static.global_scope()` 获取全局/默认作用域实例，并从中获取 ``state_dict``；否则从指定的 ``scope`` 获取 ``state_dict``。默认值为 ``None`` 。
+    - **mode** (str，可选) - 获取何种持久性变量。目前支持以下选项：(1)  ``opt`` ：获得优化器的持久性变量放在  ``dict``  结构中；(2)  ``param`` ：获得组网中的持久性变量放在  ``dict``  结构中，不包含优化器中的持久性变量；(3)  ``all`` ：获得组网和优化器中的持久性变量放在 dict 结构中；默认值为  ``all`` 。
+    - **scope** (Scope，可选) - 如果 scope 为  ``None`` ，通过 `paddle.static.global_scope()` 获取全局/默认作用域实例，并从中获取  ``state_dict`` ；否则从指定的  ``scope``  获取  ``state_dict`` 。默认值为  ``None``  。
 
 **返回**
 
@@ -237,12 +237,12 @@ COPY-FROM: paddle.static.Program.state_dict
 set_state_dict(state_dict, scope=None)
 '''''''''
 
-将 ``state_dict`` 中的持久性变量设置到 ``Program`` 中。
+将  ``state_dict``  中的持久性变量设置到  ``Program``  中。
 
 **参数**
 
     - **state_dict** (dict) - 包含持久性变量的字典。键值是持久性变量的名字，值为持久性变量。
-    - **scope** (Scope，可选) - 如果 scope 为 ``None``，通过 `paddle.static.global_scope()` 获取全局/默认作用域实例，并将 ``state_dict`` 中久性变量设置到这个作用域中；否则将 ``state_dict`` 设置到指定的 ``scope`` 中。默认值为 ``None`` 。
+    - **scope** (Scope，可选) - 如果 scope 为  ``None`` ，通过 `paddle.static.global_scope()` 获取全局/默认作用域实例，并将  ``state_dict``  中久性变量设置到这个作用域中；否则将  ``state_dict``  设置到指定的  ``scope``  中。默认值为  ``None``  。
 
 **返回**
 
diff --git a/docs/api/paddle/static/Variable_cn.rst b/docs/api/paddle/static/Variable_cn.rst
index 38fd37d09bb..e7a0f1c5e1a 100644
--- a/docs/api/paddle/static/Variable_cn.rst
+++ b/docs/api/paddle/static/Variable_cn.rst
@@ -13,9 +13,9 @@ Variable
 
 在 Paddle 静态图模式中，OP 的每个输入和输出都是 :ref:`api_guide_Variable`。多数情况下，:ref:`api_guide_Variable` 用于保存不同种类的数据或训练标签。
 
-:ref:`api_guide_Variable` 总是属于某一个 :ref:`api_guide_Block`。所有 :ref:`api_guide_Variable` 都有其自己的 ``name``，不同 :ref:`api_guide_Block` 中的两个 :ref:`api_guide_Variable` 可以具有相同的名称。如果使用的 **不是** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式，那么同一个 :ref:`api_guide_Block` 中的两个或更多 :ref:`api_guide_Variable` 拥有相同 ``name`` 将意味着他们会共享相同的内容。通常我们使用这种方式来实现 **参数共享**。
+:ref:`api_guide_Variable` 总是属于某一个 :ref:`api_guide_Block`。所有 :ref:`api_guide_Variable` 都有其自己的  ``name`` ，不同 :ref:`api_guide_Block` 中的两个 :ref:`api_guide_Variable` 可以具有相同的名称。如果使用的 **不是** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式，那么同一个 :ref:`api_guide_Block` 中的两个或更多 :ref:`api_guide_Variable` 拥有相同  ``name``  将意味着他们会共享相同的内容。通常我们使用这种方式来实现 **参数共享**。
 
-:ref:`api_guide_Variable` 有很多种。它们每种都有自己的属性和用法。请参考 `framework.proto <https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/framework/framework.proto>`_ 以获得详细信息。:ref:`api_guide_Variable` 的大多数成员变量可以设置为 ``None``。它的意思是它不可用或稍后指定。
+:ref:`api_guide_Variable` 有很多种。它们每种都有自己的属性和用法。请参考 `framework.proto <https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/framework/framework.proto>`_ 以获得详细信息。:ref:`api_guide_Variable` 的大多数成员变量可以设置为  ``None`` 。它的意思是它不可用或稍后指定。
 
 如果您希望创建一个 :ref:`api_guide_Variable` 那么可以参考如下示例：
 
@@ -41,7 +41,7 @@ to_string(throw_on_error, with_details=True)
 **参数：**
 
  - **throw_on_error** (bool) - 是否在没有设置必需字段时抛出异常。
- - **with_details** (bool) - 值为 true 时，打印更多关于 :ref:`api_guide_Variable` 的信息，如 ``error_clip`` , ``stop_gradient`` 等。
+ - **with_details** (bool) - 值为 true 时，打印更多关于 :ref:`api_guide_Variable` 的信息，如  ``error_clip``  ,  ``stop_gradient``  等。
 
 **返回**
 
@@ -55,11 +55,11 @@ COPY-FROM: paddle.static.Variable.to_string
 clone(self)
 '''''''''
 
-返回一个新的 ``Variable``，其复制原 ``Variable`` 并且新的 ``Variable`` 也被保留在计算图中，即复制的新 ``Variable`` 也参与反向计算。调用 ``out = variable.clone()`` 与 ``out = assign(variable)`` 效果一样。
+返回一个新的  ``Variable`` ，其复制原  ``Variable``  并且新的  ``Variable``  也被保留在计算图中，即复制的新  ``Variable``  也参与反向计算。调用  ``out = variable.clone()``  与  ``out = assign(variable)``  效果一样。
 
 **返回**
 
-复制的新 ``Variable``。
+复制的新  ``Variable`` 。
 
 **代码示例**
 COPY-FROM: paddle.static.Variable.clone
@@ -68,11 +68,11 @@ COPY-FROM: paddle.static.Variable.clone
 detach(self)
 '''''''''
 
-返回一个新的 ``Variable``，并从当前计算图分离。
+返回一个新的  ``Variable`` ，并从当前计算图分离。
 
 **返回**
 
-与当前计算图分离的 ``Variable``。
+与当前计算图分离的  ``Variable`` 。
 
 **代码示例**
 COPY-FROM: paddle.static.Variable.detach
@@ -81,16 +81,16 @@ COPY-FROM: paddle.static.Variable.detach
 astype(self, dtype)
 '''''''''
 
-将该 :ref:`api_guide_Variable` 中的数据转换成目标 ``Dtype``。
+将该 :ref:`api_guide_Variable` 中的数据转换成目标  ``Dtype`` 。
 
 **参数：**
 
  - **self** ( :ref:`api_guide_Variable` ) - 当前 :ref:`api_guide_Variable`，用户不需要传入。
- - **dtype** (int | float | float64) - 希望转换成的 ``Dtype``。
+ - **dtype** (int | float | float64) - 希望转换成的  ``Dtype`` 。
 
 
 **返回**
-一个全新的转换了 ``Dtype`` 的 :ref:`api_guide_Variable`。
+一个全新的转换了  ``Dtype``  的 :ref:`api_guide_Variable`。
 
 **代码示例**
 COPY-FROM: paddle.static.Variable.astype
@@ -103,7 +103,7 @@ get_value(scope=None)
 
 **参数**
 
-  - scope ( Scope，可选 ) - 从指定的 ``scope`` 中获取 :ref:`api_guide_Variable` 的值。如果 ``scope`` 为 ``None``，通过 `paddle.static.global_scope()` 获取全局/默认作用域实例，并从中获取 :ref:`api_guide_Variable` 的值；否则，从指定的 ``scope`` 中获取 :ref:`api_guide_Variable` 的值。
+  - scope ( Scope，可选 ) - 从指定的  ``scope``  中获取 :ref:`api_guide_Variable` 的值。如果  ``scope``  为  ``None`` ，通过 `paddle.static.global_scope()` 获取全局/默认作用域实例，并从中获取 :ref:`api_guide_Variable` 的值；否则，从指定的  ``scope``  中获取 :ref:`api_guide_Variable` 的值。
 
 **返回**
 
@@ -116,12 +116,12 @@ COPY-FROM: paddle.static.Variable.get_value
 set_value(value, scope=None)
 '''''''''
 
-将 ``value`` 设置为 :ref:`api_guide_Variable` 的值。
+将  ``value``  设置为 :ref:`api_guide_Variable` 的值。
 
 **参数**
 
   - value ( Tensor|ndarray ) - :ref:`api_guide_Variable` 的值。
-  - scope ( Scope，可选 ) - 将 :ref:`api_guide_Variable` 的值设置到指定的 ``scope`` 中。如果 ``scope`` 为 ``None``，通过 `paddle.static.global_scope()` 获取全局/默认作用域实例，并将 :ref:`api_guide_Variable` 的值设置到这个用域实例中；否则，将 :ref:`api_guide_Variable` 的值设置到指定的 ``scope`` 中。
+  - scope ( Scope，可选 ) - 将 :ref:`api_guide_Variable` 的值设置到指定的  ``scope``  中。如果  ``scope``  为  ``None`` ，通过 `paddle.static.global_scope()` 获取全局/默认作用域实例，并将 :ref:`api_guide_Variable` 的值设置到这个用域实例中；否则，将 :ref:`api_guide_Variable` 的值设置到指定的  ``scope``  中。
 
 **返回**
 
@@ -135,11 +135,11 @@ COPY-FROM: paddle.static.Variable.set_value
 size(self)
 '''''''''
 
-返回该 :ref:`api_guide_Variable` 中的数据元素数量，结果是一个 shape 为[1]的 int64 的 ``Variable`` 。
+返回该 :ref:`api_guide_Variable` 中的数据元素数量，结果是一个 shape 为[1]的 int64 的  ``Variable``  。
 
 **返回**
 
-``Variable``：单元元素数量。
+ ``Variable`` ：单元元素数量。
 
 **代码示例**
 COPY-FROM: paddle.static.Variable.size
@@ -152,7 +152,7 @@ ndimension(self)
 
 **返回**
 
-``Variable`` 的维度。
+ ``Variable``  的维度。
 
 **代码示例**
 COPY-FROM: paddle.static.Variable.ndimension
@@ -164,7 +164,7 @@ dim(self)
 返回该 :ref:`api_guide_Variable` 的维度，也称作 rank。
 
 **返回**
-``Variable`` 的维度。
+ ``Variable``  的维度。
 
 **代码示例**
 COPY-FROM: paddle.static.Variable.dim
@@ -177,7 +177,7 @@ persistable
 
 .. note::
   1. 该属性我们即将废弃，此介绍仅为了帮助用户理解概念，1.6 版本后用户可以不再关心该属性
-  2. 该属性除参数以外默认值为 ``False``，而参数的该属性默认值为 ``True`` 。
+  2. 该属性除参数以外默认值为  ``False`` ，而参数的该属性默认值为  ``True``  。
 
 此 :ref:`api_guide_Variable` 是否是长期存活的 :ref:`api_guide_Variable`。
 
@@ -185,7 +185,7 @@ name
 '''''''''
 
 .. note::
-  静态图模式下，同一个 :ref:`api_guide_Block` 中的两个或更多 :ref:`api_guide_Variable` 拥有相同 ``name`` 将意味着他们会共享相同的内容。通常我们使用这种方式来实现参数共享。
+  静态图模式下，同一个 :ref:`api_guide_Block` 中的两个或更多 :ref:`api_guide_Variable` 拥有相同  ``name``  将意味着他们会共享相同的内容。通常我们使用这种方式来实现参数共享。
 
 此 :ref:`api_guide_Variable` 的名字（str）。
 
@@ -212,7 +212,7 @@ lod_level
 .. note::
   该属性是只读属性。
 
-此 :ref:`api_guide_Variable` 的 ``LoD`` 信息。
+此 :ref:`api_guide_Variable` 的  ``LoD``  信息。
 
 type
 '''''''''
@@ -220,7 +220,7 @@ type
 .. note::
   该属性是只读属性。
 
-此 :ref:`api_guide_Variable` 的内存模型，例如是：``DenseTensor``，或者 ``SelectedRows``。
+此 :ref:`api_guide_Variable` 的内存模型，例如是： ``DenseTensor`` ，或者  ``SelectedRows`` 。
 
 ndim
 '''''''''
diff --git a/docs/api/paddle/static/WeightNormParamAttr_cn.rst b/docs/api/paddle/static/WeightNormParamAttr_cn.rst
index 3450ddf80b0..d6ca046f4cd 100644
--- a/docs/api/paddle/static/WeightNormParamAttr_cn.rst
+++ b/docs/api/paddle/static/WeightNormParamAttr_cn.rst
@@ -8,10 +8,10 @@ WeightNormParamAttr
 
 
 .. note::
-    动态图模式下请使用 ``paddle.nn.utils.weight_norm`` 。
+    动态图模式下请使用  ``paddle.nn.utils.weight_norm``  。
 
 .. note::
-    该类中的 ``gradient_clip`` 属性在 2.0 版本会废弃，推荐在初始化 ``optimizer`` 时设置梯度裁剪。共有三种裁剪策略：:ref:`cn_api_paddle_nn_ClipGradByGlobalNorm` 、
+    该类中的  ``gradient_clip``  属性在 2.0 版本会废弃，推荐在初始化  ``optimizer``  时设置梯度裁剪。共有三种裁剪策略：:ref:`cn_api_paddle_nn_ClipGradByGlobalNorm` 、
     :ref:`cn_api_paddle_nn_ClipGradByNorm` 、 :ref:`cn_api_paddle_nn_ClipGradByValue` 。
 
 该类定义了权重归一化(Weight Normalization)的参数。权重归一化可以将神经网络中权重向量的长度与其方向解耦，详细的定义与实现可以参考论文：`Weight Normalization: A Simple Reparameterization to Accelerate Training of Deep Neural Networks <https://arxiv.org/pdf/1602.07868.pdf>`_
@@ -21,11 +21,11 @@ WeightNormParamAttr
 
   - **dim** (int，可选) - 进行归一化操作(norm)的切片所在维度，是小于权重 Tensor rank 的非负数。比如卷积的权重 shape 是 :math:`[cout, cin, kh, kw]` , rank 是 4，则 dim 可以选 0,1,2,3；fc 的权重 shape 是 :math:`[cout, cin]` ，rank 是 2，dim 可以选 0，1。 dim 默认为 None，如果为 None 就对所有元素做归一化(norm)。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
-  - **initializer** (Initializer，可选) - 初始化参数方法，例如 ``initializer = fluid.nn.initializer.Constant(1.0)``。默认为 None，如果为 None 则使用默认初始化函数 `Xavier()` 。
+  - **initializer** (Initializer，可选) - 初始化参数方法，例如  ``initializer = fluid.nn.initializer.Constant(1.0)`` 。默认为 None，如果为 None 则使用默认初始化函数 `Xavier()` 。
   - **learning_rate** (float32，可选) - 学习率，优化过程 :math:`global\_lr∗parameter\_lr∗scheduler\_factor` 的学习速率，默认为 1.0。
   - **regularizer** (WeightDecayRegularizer，可选) - 正则化方法。支持两种正则化策略：:ref:`cn_api_paddle_regularizer_L1Decay` 、
-    :ref:`cn_api_paddle_regularizer_L2Decay`，如果在 ``optimizer`` (例如 :ref:`cn_api_paddle_optimizer_SGD` ) 中也
-    设置了正则化，``optimizer`` 中的正则化将被忽略。默认值为 None，表示没有正则化。
+    :ref:`cn_api_paddle_regularizer_L2Decay`，如果在  ``optimizer``  (例如 :ref:`cn_api_paddle_optimizer_SGD` ) 中也
+    设置了正则化， ``optimizer``  中的正则化将被忽略。默认值为 None，表示没有正则化。
   - **trainable** (bool，可选) - 指明参数是否可训练，默认为 True。
   - **do_model_average** (bool，可选) - 指明参数是否需要模型平均化操作(Model Average)，默认为 False。
   - **need_clip** (bool，可选) - 指明参数梯度是否需要在优化器中进行 clip，默认为 True。
diff --git a/docs/api/paddle/static/accuracy_cn.rst b/docs/api/paddle/static/accuracy_cn.rst
index 9d8ee6de0aa..4f7ed30a654 100755
--- a/docs/api/paddle/static/accuracy_cn.rst
+++ b/docs/api/paddle/static/accuracy_cn.rst
@@ -15,8 +15,8 @@ accuracy layer。参考 https://en.wikipedia.org/wiki/Precision_and_recall
 参数
 ::::::::::::
 
-    - **input** (Tensor)-数据类型为 float32,float64。输入为网络的预测值。shape 为 ``[sample_number, class_dim]`` 。
-    - **label** (Tensor)-数据类型为 int64，int32。输入为数据集的标签。shape 为 ``[sample_number, 1]`` 。
+    - **input** (Tensor)-数据类型为 float32,float64。输入为网络的预测值。shape 为  ``[sample_number, class_dim]``  。
+    - **label** (Tensor)-数据类型为 int64，int32。输入为数据集的标签。shape 为  ``[sample_number, 1]``  。
     - **k** (int64|int32) - 取每个类别中 k 个预测值用于计算。
     - **correct** (int64|int32)-正确预测值的个数。
     - **total** (int64|int32)-总共的预测值。
diff --git a/docs/api/paddle/static/append_backward_cn.rst b/docs/api/paddle/static/append_backward_cn.rst
index f974283ea82..9f52890ea98 100644
--- a/docs/api/paddle/static/append_backward_cn.rst
+++ b/docs/api/paddle/static/append_backward_cn.rst
@@ -9,20 +9,20 @@ append_backward
 
 
 
-将向主程序（``main_program``）添加反向部分。
+将向主程序（ ``main_program`` ）添加反向部分。
 
 完整的神经网络训练由前向和反向传播两部分组成。但是当我们配置网络时，我们只需要指定其前向部分。
 该接口使用链式法则，能够根据前向部分自动生成反向部分。
 
-在大多数情况下，用户无需手动调用此接口，它将由优化器（``Optimizer``）的 ``minimize`` 函数自动调用。
+在大多数情况下，用户无需手动调用此接口，它将由优化器（ ``Optimizer`` ）的  ``minimize``  函数自动调用。
 
 参数
 ::::::::::::
 
     - **loss** (Tensor) - 表示网络损失的 Tensor 。
-    - **parameter_list** （list [Tensor|str]，可选）- 指定优化器需要更新的参数或参数名称列表。如果为 ``None``，则将更新所有参数。默认值为 ``None``。
-    - **no_grad_set** （set [Tensor|str]，可选）-  在 `block0` ( :ref:`api_guide_Block` ) 中要忽略梯度的 Tensor 的名字的集合。所有的 :ref:`api_guide_Block` 中带有 ``stop_gradient = True`` 的所有 Tensor 的名字都会被自动添加到此集合中。如果该参数不为 ``None``，则会将该参数集合的内容添加到默认的集合中。默认值为 ``None``。
-    - **callbacks** （list [callable object]，可选）- 回调函数列表。用于在反向传播构建中执行一些自定义作业。每次将新的梯度 OP 添加到程序中时，将调用其中的所有可调用对象。可调用对象必须有两个输入参数：:ref:`api_guide_Block` 和 ``context`` 。 :ref:`api_guide_Block` 是将被添加到新梯度算子的块。``context`` 是一个映射，其键是梯度 Tensor 名，值是对应的原始 Tensor。除此之外，``context`` 还有另一个特殊的键值对：键是字符串 ``__ current_op_desc__``，值是刚刚触发可调用对象的梯度 OP 的 ``op_desc``。默认值为 ``None``。
+    - **parameter_list** （list [Tensor|str]，可选）- 指定优化器需要更新的参数或参数名称列表。如果为  ``None`` ，则将更新所有参数。默认值为  ``None`` 。
+    - **no_grad_set** （set [Tensor|str]，可选）-  在 `block0` ( :ref:`api_guide_Block` ) 中要忽略梯度的 Tensor 的名字的集合。所有的 :ref:`api_guide_Block` 中带有  ``stop_gradient = True``  的所有 Tensor 的名字都会被自动添加到此集合中。如果该参数不为  ``None`` ，则会将该参数集合的内容添加到默认的集合中。默认值为  ``None`` 。
+    - **callbacks** （list [callable object]，可选）- 回调函数列表。用于在反向传播构建中执行一些自定义作业。每次将新的梯度 OP 添加到程序中时，将调用其中的所有可调用对象。可调用对象必须有两个输入参数：:ref:`api_guide_Block` 和  ``context``  。 :ref:`api_guide_Block` 是将被添加到新梯度算子的块。 ``context``  是一个映射，其键是梯度 Tensor 名，值是对应的原始 Tensor。除此之外， ``context``  还有另一个特殊的键值对：键是字符串  ``__ current_op_desc__`` ，值是刚刚触发可调用对象的梯度 OP 的  ``op_desc`` 。默认值为  ``None`` 。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/static/auc_cn.rst b/docs/api/paddle/static/auc_cn.rst
index 4512d6bf111..0e967025a80 100755
--- a/docs/api/paddle/static/auc_cn.rst
+++ b/docs/api/paddle/static/auc_cn.rst
@@ -27,7 +27,7 @@ auc
 
     - **input** (Tensor) - 数据类型为 float32、float64。浮点二维变量，值的范围为[0,1]。每一行降序排列。该输入为网络预测值，通常代表每个标签的概率。
     - **label** (Tensor) - 数据类型为 int32、int64。二维整型变量，为训练数据的标签，第一维大小代表 batch size，第二维大小为 1。
-    - **curve** (str，可选) - 曲线类型，可以为 ``ROC`` 或 ``PR``，默认 ``ROC``。
+    - **curve** (str，可选) - 曲线类型，可以为  ``ROC``  或  ``PR`` ，默认  ``ROC`` 。
     - **num_thresholds** (int，可选) - 将 roc 曲线离散化时使用的临界值数。默认 4095。
     - **topk** (int，可选) -  取 topk 的输出值用于计算。
     - **slide_steps** (int，可选) - 当计算 batch auc 时，不仅用当前步也用于先前步。slide_steps=1，表示用当前步；slide_steps = 3 表示用当前步和前两步；slide_steps = 0，则用所有步。默认值为 1。
diff --git a/docs/api/paddle/static/cpu_places_cn.rst b/docs/api/paddle/static/cpu_places_cn.rst
index eb085454bda..85f28c06761 100644
--- a/docs/api/paddle/static/cpu_places_cn.rst
+++ b/docs/api/paddle/static/cpu_places_cn.rst
@@ -6,18 +6,18 @@ cpu_places
 .. py:function:: paddle.static.cpu_places(device_count=None)
 
 
-创建 ``device_count`` 个 ``paddle.CPUPlace`` 对象，并返回所创建的对象列表。
+创建  ``device_count``  个  ``paddle.CPUPlace``  对象，并返回所创建的对象列表。
 
-如果 ``device_count`` 为 ``None``，则设备数目将由环境变量 ``CPU_NUM`` 确定。如果未设置 ``CPU_NUM`` 环境变量，则设备数目会默认设为 1，也就是说，``CPU_NUM=1``。
-``CPU_NUM`` 表示在当前任务中使用的设备数目。如果 ``CPU_NUM`` 与物理核心数相同，可以加速程序的运行。
+如果  ``device_count``  为  ``None`` ，则设备数目将由环境变量  ``CPU_NUM``  确定。如果未设置  ``CPU_NUM``  环境变量，则设备数目会默认设为 1，也就是说， ``CPU_NUM=1`` 。
+ ``CPU_NUM``  表示在当前任务中使用的设备数目。如果  ``CPU_NUM``  与物理核心数相同，可以加速程序的运行。
 
 参数
 :::::::::
-  - **device_count** (int，可选) - 设备数目。默认值为 ``None``。
+  - **device_count** (int，可选) - 设备数目。默认值为  ``None`` 。
 
 返回
 :::::::::
-list[paddle.CPUPlace]， ``CPUPlace`` 的列表。
+list[paddle.CPUPlace]，  ``CPUPlace``  的列表。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/static/create_global_var_cn.rst b/docs/api/paddle/static/create_global_var_cn.rst
index 13d61a77815..36cd66c4647 100644
--- a/docs/api/paddle/static/create_global_var_cn.rst
+++ b/docs/api/paddle/static/create_global_var_cn.rst
@@ -8,7 +8,7 @@ create_global_var
 
 
 
-在全局块中创建一个新的 Tensor，Tensor 的值为 ``value`` 。
+在全局块中创建一个新的 Tensor，Tensor 的值为  ``value``  。
 
 参数
 ::::::::::::
diff --git a/docs/api/paddle/static/cuda_places_cn.rst b/docs/api/paddle/static/cuda_places_cn.rst
index 7485f27b5ff..b3216f04530 100644
--- a/docs/api/paddle/static/cuda_places_cn.rst
+++ b/docs/api/paddle/static/cuda_places_cn.rst
@@ -9,22 +9,22 @@ cuda_places
 .. note::
     多卡任务请先使用 FLAGS_selected_gpus 环境变量设置可见的 GPU 设备，下个版本将会修正 CUDA_VISIBLE_DEVICES 环境变量无效的问题。
 
-该接口根据 ``device_ids`` 创建一个或多个 ``paddle.CUDAPlace`` 对象，并返回所创建的对象列表。
+该接口根据  ``device_ids``  创建一个或多个  ``paddle.CUDAPlace``  对象，并返回所创建的对象列表。
 
-如果 ``device_ids`` 为 ``None``，则首先检查 ``FLAGS_selected_gpus`` 标志。
-例如：``FLAGS_selected_gpus=0,1,2``，则返回的列表将为 ``[paddle.CUDAPlace(0), paddle.CUDAPlace(1), paddle.CUDAPlace(2)]``。
-如果未设置标志 ``FLAGS_selected_gpus``，则根据 ``CUDA_VISIBLE_DEVICES`` 环境变量，返回所有可见的 GPU places。
+如果  ``device_ids``  为  ``None`` ，则首先检查  ``FLAGS_selected_gpus``  标志。
+例如： ``FLAGS_selected_gpus=0,1,2`` ，则返回的列表将为  ``[paddle.CUDAPlace(0), paddle.CUDAPlace(1), paddle.CUDAPlace(2)]`` 。
+如果未设置标志  ``FLAGS_selected_gpus`` ，则根据  ``CUDA_VISIBLE_DEVICES``  环境变量，返回所有可见的 GPU places。
 
-如果 ``device_ids`` 不是 ``None``，它应该是使用的 GPU 设备 ID 的列表或元组。
-例如：``device_id=[0,1,2]``，返回的列表将是 ``[paddle.CUDAPlace(0), paddle.CUDAPlace(1), paddle.CUDAPlace(2)]``。
+如果  ``device_ids``  不是  ``None`` ，它应该是使用的 GPU 设备 ID 的列表或元组。
+例如： ``device_id=[0,1,2]`` ，返回的列表将是  ``[paddle.CUDAPlace(0), paddle.CUDAPlace(1), paddle.CUDAPlace(2)]`` 。
 
 参数
 :::::::::
-  - **device_ids** (list(int)|tuple(int)，可选) - GPU 的设备 ID 列表或元组。默认值为 ``None``。
+  - **device_ids** (list(int)|tuple(int)，可选) - GPU 的设备 ID 列表或元组。默认值为  ``None`` 。
 
 返回
 :::::::::
-list[paddle.CUDAPlace]，创建的 ``paddle.CUDAPlace`` 列表。
+list[paddle.CUDAPlace]，创建的  ``paddle.CUDAPlace``  列表。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/static/data_cn.rst b/docs/api/paddle/static/data_cn.rst
index 5bf7e175c5f..c6b58d17937 100644
--- a/docs/api/paddle/static/data_cn.rst
+++ b/docs/api/paddle/static/data_cn.rst
@@ -9,7 +9,7 @@ data
 
 
 
-会在全局 block 中创建变量（Tensor），该全局变量可被计算图中的算子（operator）访问。该变量可作为占位符用于数据输入。例如用执行器（Executor）输入数据进该变量，当 ``dtype`` 为 None 时，``dtype`` 将通过 ``paddle.get_default_dtype()`` 获取全局类型。
+会在全局 block 中创建变量（Tensor），该全局变量可被计算图中的算子（operator）访问。该变量可作为占位符用于数据输入。例如用执行器（Executor）输入数据进该变量，当  ``dtype``  为 None 时， ``dtype``  将通过  ``paddle.get_default_dtype()``  获取全局类型。
 
 
 参数
@@ -17,7 +17,7 @@ data
 
     - **name** (str) - 变量名，具体用法请参见 :ref:`api_guide_Name`。
     - **shape** (list|tuple)- 声明维度信息的 list 或 tuple。可以在某个维度上设置 None 或-1，以指示该维度可以是任何大小。例如，将可变 batchsize 设置为 None 或-1。
-    - **dtype** (str|paddle.dtype|np.dtype，可选)- 数据类型，支持 bool，float16，float32，float64，int8，int16，int32，int64，uint8。默认值为 None。当 ``dtype`` 为 None 时，``dtype`` 将通过 ``padle.get_default_dtype()`` 获取全局类型。
+    - **dtype** (str|paddle.dtype|np.dtype，可选)- 数据类型，支持 bool，float16，float32，float64，int8，int16，int32，int64，uint8。默认值为 None。当  ``dtype``  为 None 时， ``dtype``  将通过  ``padle.get_default_dtype()``  获取全局类型。
     - **lod_level** (int，可选)- DenseTensor 变量的 LoD level 数，LoD level 是 PaddlePaddle 的高级特性，一般任务中不会需要更改此默认值。默认值为 0。
 
 返回
diff --git a/docs/api/paddle/static/default_main_program_cn.rst b/docs/api/paddle/static/default_main_program_cn.rst
index 4e4f5e6db6c..ae36697fb83 100644
--- a/docs/api/paddle/static/default_main_program_cn.rst
+++ b/docs/api/paddle/static/default_main_program_cn.rst
@@ -5,13 +5,13 @@ default_main_program
 
 .. py:function:: paddle.static.default_main_program()
 
-此接口可以获取当前用于存储 OP 和 Tensor 描述信息的 ``default main program``。
+此接口可以获取当前用于存储 OP 和 Tensor 描述信息的  ``default main program`` 。
 
-例如 ``z = paddle.add(x, y)`` 会创建新 ``Op`` 和 tensor ``z``，这些变量会被记录在 ``default main program`` 中。
+例如  ``z = paddle.add(x, y)``  会创建新  ``Op``  和 tensor  ``z`` ，这些变量会被记录在  ``default main program``  中。
 
-``default main program`` 是许多编程接口中 Program 参数的默认值。例如对于 ``Executor.run()`` 如果用户没有传入 Program 参数，会默认使用 ``default main program`` 。
+ ``default main program``  是许多编程接口中 Program 参数的默认值。例如对于  ``Executor.run()``  如果用户没有传入 Program 参数，会默认使用  ``default main program``  。
 
-可以使用 :ref:`cn_api_paddle_static_program_guard` 来切换 ``default main program``。
+可以使用 :ref:`cn_api_paddle_static_program_guard` 来切换  ``default main program`` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/static/default_startup_program_cn.rst b/docs/api/paddle/static/default_startup_program_cn.rst
index e64d6708a57..85556ccaf51 100644
--- a/docs/api/paddle/static/default_startup_program_cn.rst
+++ b/docs/api/paddle/static/default_startup_program_cn.rst
@@ -7,13 +7,13 @@ default_startup_program
 
 该函数可以获取默认/全局 startup :ref:`cn_api_paddle_static_Program` (初始化启动程序)。
 
-``paddle.nn`` 中的函数将参数初始化 OP 追加到 ``startup program`` 中，运行 ``startup program`` 会完成参数的初始化。
+ ``paddle.nn``  中的函数将参数初始化 OP 追加到  ``startup program``  中，运行  ``startup program``  会完成参数的初始化。
 
-该函数将返回默认的或当前的 ``startup program``。用户可以使用 :ref:`cn_api_paddle_static_program_guard` 来切换 :ref:`cn_api_paddle_static_Program` 。
+该函数将返回默认的或当前的  ``startup program`` 。用户可以使用 :ref:`cn_api_paddle_static_program_guard` 来切换 :ref:`cn_api_paddle_static_Program` 。
 
 返回
 :::::::::
- :ref:`cn_api_paddle_static_Program`，当前的默认/全局的 ``startup program`` 。
+ :ref:`cn_api_paddle_static_Program`，当前的默认/全局的  ``startup program``  。
 
 
 代码示例
diff --git a/docs/api/paddle/static/deserialize_persistables_cn.rst b/docs/api/paddle/static/deserialize_persistables_cn.rst
index 3bc790276be..d15669688b9 100644
--- a/docs/api/paddle/static/deserialize_persistables_cn.rst
+++ b/docs/api/paddle/static/deserialize_persistables_cn.rst
@@ -16,7 +16,7 @@ deserialize_persistables
 
   - **program** (Program) - 指定包含要反序列化的参数的名称的 program。
   - **data** (bytes) - 序列化之后的模型参数。
-  - **executor** (Executor) - 用来执行 load op 的 ``executor`` 。
+  - **executor** (Executor) - 用来执行 load op 的  ``executor``  。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/static/device_guard_cn.rst b/docs/api/paddle/static/device_guard_cn.rst
index bc73bc2c2b1..ad0fef3c857 100644
--- a/docs/api/paddle/static/device_guard_cn.rst
+++ b/docs/api/paddle/static/device_guard_cn.rst
@@ -13,7 +13,7 @@ device_guard
 参数
 ::::::::::::
 
-    - **device** (str|None) – 指定上下文中使用的设备。它可以是 ``cpu``、 ``gpu``、 ``gpu:x``，其中 ``x`` 是 GPU 的编号。当它被设置为 ``cpu`` 或者 ``gpu`` 时，创建在该上下文中的 OP 将被运行在 CPUPlace 或者 CUDAPlace 上。若设置为 ``gpu``，同时程序运行在单卡模式下，设备的索引将与执行器的设备索引保持一致，默认值：None，在该上下文中的 OP 将被自动地分配设备。
+    - **device** (str|None) – 指定上下文中使用的设备。它可以是  ``cpu`` 、  ``gpu`` 、  ``gpu:x`` ，其中  ``x``  是 GPU 的编号。当它被设置为  ``cpu``  或者  ``gpu``  时，创建在该上下文中的 OP 将被运行在 CPUPlace 或者 CUDAPlace 上。若设置为  ``gpu`` ，同时程序运行在单卡模式下，设备的索引将与执行器的设备索引保持一致，默认值：None，在该上下文中的 OP 将被自动地分配设备。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/static/global_scope_cn.rst b/docs/api/paddle/static/global_scope_cn.rst
index b45efca661d..de3cdd313e0 100644
--- a/docs/api/paddle/static/global_scope_cn.rst
+++ b/docs/api/paddle/static/global_scope_cn.rst
@@ -9,7 +9,7 @@ global_scope
 
 
 
-获取全局/默认作用域实例。很多 API 使用默认 ``global_scope``，例如 ``Executor.run`` 等。
+获取全局/默认作用域实例。很多 API 使用默认  ``global_scope`` ，例如  ``Executor.run``  等。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/static/gradients_cn.rst b/docs/api/paddle/static/gradients_cn.rst
index 9a1ad54e5a3..0a0c0d113d3 100644
--- a/docs/api/paddle/static/gradients_cn.rst
+++ b/docs/api/paddle/static/gradients_cn.rst
@@ -17,7 +17,7 @@ gradients
   - **targets** (Tensor|list[Tensor]) – 目标 Tensor 或包含 Tensor 的列表。
   - **inputs** (Tensor|list[Tensor]) – 输入 Tensor 或包含 Tensor 的列表。
   - **target_gradients** (Tensor|list[Tensor]，可选) – 目标的梯度 Tensor，应与目标 Tensor 的形状相同；如果设置为 None，则以 1 初始化所有梯度 Tensor。
-  - **no_grad_set** (set[Tensor|str]，可选) – 在 `block0` ( :ref:`api_guide_Block` ) 中要忽略梯度的 Tensor 的名字的集合。所有的 :ref:`api_guide_Block` 中带有 ``stop_gradient = True`` 的所有 Tensor 的名字都会被自动添加到此集合中。如果该参数不为 ``None``，则会将该参数集合的内容添加到默认的集合中。默认值为 ``None`` 。
+  - **no_grad_set** (set[Tensor|str]，可选) – 在 `block0` ( :ref:`api_guide_Block` ) 中要忽略梯度的 Tensor 的名字的集合。所有的 :ref:`api_guide_Block` 中带有  ``stop_gradient = True``  的所有 Tensor 的名字都会被自动添加到此集合中。如果该参数不为  ``None`` ，则会将该参数集合的内容添加到默认的集合中。默认值为  ``None``  。
 
 
 返回
diff --git a/docs/api/paddle/static/load_cn.rst b/docs/api/paddle/static/load_cn.rst
index 9ae2d5278d1..17ef5c6fbe5 100644
--- a/docs/api/paddle/static/load_cn.rst
+++ b/docs/api/paddle/static/load_cn.rst
@@ -17,7 +17,7 @@ load
 ::::::::::::
 
  - **program**  ( :ref:`cn_api_paddle_static_Program` ) – 要加载的 Program。
- - **model_path**  (str) – 保存 Program 的目录名称+文件前缀。格式为 ``目录名称/文件前缀`` 。
+ - **model_path**  (str) – 保存 Program 的目录名称+文件前缀。格式为  ``目录名称/文件前缀``  。
  - **executor** (Executor，可选) - 当 startup program 没有运行时，用于初始化参数的 Executor。默认值：None。
  - **var_list** (list，可选) - 指定加载的 Tensor 列表，该参数只在加载旧接口[save_params，save_persistables，save_vars]保存的模型文件时使用。当加载的是多个小文件时，Tensor 列表可以是所有加载文件中 Tensor 的子集；当加载的单个大文件时，Tensor 列表必须和加载文件中的 Tensor 保持一致。
 
diff --git a/docs/api/paddle/static/load_inference_model_cn.rst b/docs/api/paddle/static/load_inference_model_cn.rst
index 419dc7963a5..922179a37c9 100644
--- a/docs/api/paddle/static/load_inference_model_cn.rst
+++ b/docs/api/paddle/static/load_inference_model_cn.rst
@@ -15,7 +15,7 @@ load_inference_model
 ::::::::::::
 
   - **path_prefix** (str|None) – 模型的存储目录 + 模型名称（不包含后缀）。如果是 None，表示从内存加载模型。
-  - **executor** (Executor) – 运行模型的 ``executor``，详见 :ref:`api_guide_executor` 。
+  - **executor** (Executor) – 运行模型的  ``executor`` ，详见 :ref:`api_guide_executor` 。
   - **kwargs** - 支持的 key 包括 'model_filename', 'params_filename'。(注意：kwargs 主要是用来做反向兼容的)。
 
       - **model_filename** (str) - 自定义 model_filename。
@@ -26,9 +26,9 @@ load_inference_model
 ::::::::::::
 该接口返回一个包含三个元素的列表 [program，feed_target_names, fetch_targets]。它们的含义描述如下：
 
-  - **program** （Program）– ``Program`` （详见 :ref:`api_guide_Program` ）类的实例。此处它被用于预测，因此可被称为 Inference Program。
+  - **program** （Program）–  ``Program``  （详见 :ref:`api_guide_Program` ）类的实例。此处它被用于预测，因此可被称为 Inference Program。
   - **feed_target_names** （list）– 字符串列表，包含着 Inference Program 预测时所需提供数据的所有变量名称（即所有输入变量的名称）。
-  - **fetch_targets** （list）– ``Variable`` （详见 :ref:`api_guide_Program` ）类型列表，包含着模型的所有输出变量。通过这些输出变量即可得到模型的预测结果。
+  - **fetch_targets** （list）–  ``Variable``  （详见 :ref:`api_guide_Program` ）类型列表，包含着模型的所有输出变量。通过这些输出变量即可得到模型的预测结果。
 
 
 代码示例
diff --git a/docs/api/paddle/static/load_program_state_cn.rst b/docs/api/paddle/static/load_program_state_cn.rst
index eb50af49320..046eb469d65 100644
--- a/docs/api/paddle/static/load_program_state_cn.rst
+++ b/docs/api/paddle/static/load_program_state_cn.rst
@@ -5,12 +5,12 @@ load_program_state
 
 .. py:function:: paddle.static.load_program_state(model_path, var_list=None)
 
-从本地加载 ``Program`` 的参数和优化器的 Tensor 信息到内存中。
+从本地加载  ``Program``  的参数和优化器的 Tensor 信息到内存中。
 
 参数
 ::::::::::::
 
-    - **model_path** (str) - 存储 ``Program`` 的参数和优化器的 Tensor 信息的目录名称+文件前缀，格式为 ``目录名称/文件前缀`` 。
+    - **model_path** (str) - 存储  ``Program``  的参数和优化器的 Tensor 信息的目录名称+文件前缀，格式为  ``目录名称/文件前缀``  。
     - **var_list** (list，可选) - 指定加载的 Tensor 列表，该参数只在加载旧接口[save_params，save_persistables，save_vars]保存的模型文件时使用。当加载的是多个小文件时，Tensor 列表可以是所有加载文件中 Tensor 的子集；当加载的单个大文件时，Tensor 列表必须和加载文件中的 Tensor 保持一致。
 
 返回
diff --git a/docs/api/paddle/static/nn/batch_norm_cn.rst b/docs/api/paddle/static/nn/batch_norm_cn.rst
index b6a464ad3fe..efb70dec64a 100644
--- a/docs/api/paddle/static/nn/batch_norm_cn.rst
+++ b/docs/api/paddle/static/nn/batch_norm_cn.rst
@@ -19,7 +19,7 @@ batch_norm
 
 更多详情请参考：`Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/pdf/1502.03167.pdf>`_
 
-``input`` 是 mini-batch 的输入。
+ ``input``  是 mini-batch 的输入。
 
 .. math::
     \mu_{\beta} &\gets \frac{1}{m} \sum_{i=1}^{m} x_i  \qquad &//\
@@ -58,8 +58,8 @@ moving_mean 和 moving_var 是训练过程中统计得到的全局均值和方
     - **data_layout** （string) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCHW"和"NHWC"。N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度。默认值："NCHW"。
     - **in_place** （bool）- batch_norm 的输出复用输入的 tensor，可以节省显存。默认：False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
-    - **moving_mean_name** （string）- moving_mean 的名称，存储全局均值。如果将其设置为 None, ``batch_norm`` 将随机命名全局均值；否则，``batch_norm`` 将命名全局均值为 ``moving_mean_name``。默认：None。
-    - **moving_variance_name** （string）- moving_variance 的名称，存储全局变量。如果将其设置为 None, ``batch_norm`` 将随机命名全局方差；否则，``batch_norm`` 将命名全局方差为 ``moving_variance_name``。默认：None。
+    - **moving_mean_name** （string）- moving_mean 的名称，存储全局均值。如果将其设置为 None,  ``batch_norm``  将随机命名全局均值；否则， ``batch_norm``  将命名全局均值为  ``moving_mean_name`` 。默认：None。
+    - **moving_variance_name** （string）- moving_variance 的名称，存储全局变量。如果将其设置为 None,  ``batch_norm``  将随机命名全局方差；否则， ``batch_norm``  将命名全局方差为  ``moving_variance_name`` 。默认：None。
     - **do_model_average_for_mean_and_var** （bool，默认 False）- 是否为 mean 和 variance 做模型均值。
     - **use_global_stats** （bool） – 是否使用全局均值和方差。在预测或测试模式下，将 use_global_stats 设置为 true 或将 is_test 设置为 true，并且行为是等效的。在训练模式中，当设置 use_global_stats 为 True 时，在训练期间也使用全局均值和方差。默认：False。
 
diff --git a/docs/api/paddle/static/nn/case_cn.rst b/docs/api/paddle/static/nn/case_cn.rst
index 89c521d1f1b..10d924a3fea 100644
--- a/docs/api/paddle/static/nn/case_cn.rst
+++ b/docs/api/paddle/static/nn/case_cn.rst
@@ -12,7 +12,7 @@ case
 参数
 ::::::::::::
 
-    - **pred_fn_pairs** (list|tuple) - 一个 list 或者 tuple，元素是二元组(pred, fn)。其中 ``pred`` 是元素个数为 1 的布尔型 Tensor （ 0-D Tensor 或者形状为 [1] ），``fn`` 是一个可调用对象。所有的可调用对象都返回相同结构的 Tensor。
+    - **pred_fn_pairs** (list|tuple) - 一个 list 或者 tuple，元素是二元组(pred, fn)。其中  ``pred``  是元素个数为 1 的布尔型 Tensor （ 0-D Tensor 或者形状为 [1] ）， ``fn``  是一个可调用对象。所有的可调用对象都返回相同结构的 Tensor。
     - **default** (callable，可选) - 可调用对象，返回一个或多个 Tensor。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
@@ -20,8 +20,8 @@ case
 ::::::::::::
 Tensor|list(Tensor)
 
-- 如果 ``pred_fn_pairs`` 中存在 pred 是 True 的元组(pred, fn)，则返回第一个为 True 的 pred 的元组中 fn 的返回结果；如果 ``pred_fn_pairs`` 中不存在 pred 为 True 的元组(pred, fn) 且 ``default`` 不是 None，则返回调用 ``default`` 的返回结果；
-- 如果 ``pred_fn_pairs`` 中不存在 pred 为 True 的元组(pred, fn) 且 ``default`` 是 None，则返回 ``pred_fn_pairs`` 中最后一个 pred 的返回结果。
+- 如果  ``pred_fn_pairs``  中存在 pred 是 True 的元组(pred, fn)，则返回第一个为 True 的 pred 的元组中 fn 的返回结果；如果  ``pred_fn_pairs``  中不存在 pred 为 True 的元组(pred, fn) 且  ``default``  不是 None，则返回调用  ``default``  的返回结果；
+- 如果  ``pred_fn_pairs``  中不存在 pred 为 True 的元组(pred, fn) 且  ``default``  是 None，则返回  ``pred_fn_pairs``  中最后一个 pred 的返回结果。
 
 
 代码示例
diff --git a/docs/api/paddle/static/nn/cond_cn.rst b/docs/api/paddle/static/nn/cond_cn.rst
index c24433d27c9..243bdd35f4a 100644
--- a/docs/api/paddle/static/nn/cond_cn.rst
+++ b/docs/api/paddle/static/nn/cond_cn.rst
@@ -7,32 +7,32 @@ cond
 .. py:function:: paddle.static.nn.cond(pred, true_fn=None, false_fn=None, name=None, return_names=None)
 
 
-如果 ``pred`` 是 ``True``，该 API 返回 ``true_fn()``，否则返回 ``false_fn()``。
-用户如果不想在 ``callable`` 中做任何事，可以把 ``true_fn`` 或 ``false_fn`` 设为 ``None``，此时本 API 会把该 ``callable`` 视为简单返回 ``None``。
+如果  ``pred``  是  ``True`` ，该 API 返回  ``true_fn()`` ，否则返回  ``false_fn()`` 。
+用户如果不想在  ``callable``  中做任何事，可以把  ``true_fn``  或  ``false_fn``  设为  ``None`` ，此时本 API 会把该  ``callable``  视为简单返回  ``None`` 。
 
-``true_fn`` 和 ``false_fn`` 需要返回同样嵌套结构（nest structure）的 Tensor，如果不想返回任何值也可都返回 ``None``。
+ ``true_fn``  和  ``false_fn``  需要返回同样嵌套结构（nest structure）的 Tensor，如果不想返回任何值也可都返回  ``None`` 。
 PaddlePaddle 里 Tensor 的嵌套结构是指一个 Tensor，或者 Tensor 的元组（tuple），或者 Tensor 的列表（list）。
 
 .. note::
-    1. ``true_fn`` 和 ``false_fn`` 返回的元组必须形状相同，但是里面的 Tensor 形状可以不同。
-    2. 本接口在动态图和静态图模式下都可以运行，在动态图情况下就只会按 ``pred`` 条件运行其中一支分支。
-    3. 静态图模式下，因为各个分支都要参与组网，因此不论运行哪个分支，在 ``true_fn`` 和 ``false_fn`` 内外创建的 Tensor 和 Op 都会组网，即 PaddlePaddle 并不是惰性语法（lazy semantics）。例如
+    1.  ``true_fn``  和  ``false_fn``  返回的元组必须形状相同，但是里面的 Tensor 形状可以不同。
+    2. 本接口在动态图和静态图模式下都可以运行，在动态图情况下就只会按  ``pred``  条件运行其中一支分支。
+    3. 静态图模式下，因为各个分支都要参与组网，因此不论运行哪个分支，在  ``true_fn``  和  ``false_fn``  内外创建的 Tensor 和 Op 都会组网，即 PaddlePaddle 并不是惰性语法（lazy semantics）。例如
 
        COPY-FROM: paddle.static.nn.cond:code-example-1
 
-       不管 ``a < b`` 是否成立，``c = a * b`` 都会被组网且运行，``a + c`` 和 ``b * b`` 都会参与组网，只是组网后运行时只会运行条件对应的分支。
+       不管  ``a < b``  是否成立， ``c = a * b``  都会被组网且运行， ``a + c``  和  ``b * b``  都会参与组网，只是组网后运行时只会运行条件对应的分支。
 
 参数
 :::::::::
-    - **pred** (Tensor) - 一个元素个数为 1 的布尔型（boolean）的 Tensor （ 0-D Tensor 或者形状为 [1] ），该布尔值决定要返回 ``true_fn`` 还是 ``false_fn`` 的运行结果。
-    - **true_fn** (callable) - 一个当 ``pred`` 是 ``True`` 时被调用的 callable，默认值：``None``。
-    - **false_fn** (callable) - 一个当 ``pred`` 是 ``False`` 时被调用的 callable，默认值：``None``。
-    - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值：``None``。
-    - **return_names** (sequence of string，可选) - 通常情况下，用户不必设置此参数。字符串表示返回的变量的名称。序列的结构必须与 ``true_fn`` 和 ``false_fn`` 的返回值相同，默认值：``None``。
+    - **pred** (Tensor) - 一个元素个数为 1 的布尔型（boolean）的 Tensor （ 0-D Tensor 或者形状为 [1] ），该布尔值决定要返回  ``true_fn``  还是  ``false_fn``  的运行结果。
+    - **true_fn** (callable) - 一个当  ``pred``  是  ``True``  时被调用的 callable，默认值： ``None`` 。
+    - **false_fn** (callable) - 一个当  ``pred``  是  ``False``  时被调用的 callable，默认值： ``None`` 。
+    - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值： ``None`` 。
+    - **return_names** (sequence of string，可选) - 通常情况下，用户不必设置此参数。字符串表示返回的变量的名称。序列的结构必须与  ``true_fn``  和  ``false_fn``  的返回值相同，默认值： ``None`` 。
 
 返回
 :::::::::
-Tensor|list(Tensor)|tuple(Tensor)，如果 ``pred`` 是 ``True``，该 API 返回 ``true_fn()``，否则返回 ``false_fn()``。
+Tensor|list(Tensor)|tuple(Tensor)，如果  ``pred``  是  ``True`` ，该 API 返回  ``true_fn()`` ，否则返回  ``false_fn()`` 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/static/nn/conv2d_cn.rst b/docs/api/paddle/static/nn/conv2d_cn.rst
index b462ca7574b..e4abc7d5175 100644
--- a/docs/api/paddle/static/nn/conv2d_cn.rst
+++ b/docs/api/paddle/static/nn/conv2d_cn.rst
@@ -28,9 +28,9 @@ conv2d
     - :math:`X`：输入值，NCHW 或 NHWC 格式的 4-D Tensor；
     - :math:`W`：滤波器值，MCHW 格式的 4-D Tensor；
     - :math:`*`：卷积操作；
-    - :math:`b`：偏置值，2-D Tensor，形状为 ``[M,1]``；
+    - :math:`b`：偏置值，2-D Tensor，形状为  ``[M,1]`` ；
     - :math:`\sigma`：激活函数；
-    - :math:`Out`：输出值，NCHW 或 NHWC 格式的 4-D Tensor，和 ``X`` 的形状可能不同。
+    - :math:`Out`：输出值，NCHW 或 NHWC 格式的 4-D Tensor，和  ``X``  的形状可能不同。
 
 **示例**
 
@@ -52,7 +52,7 @@ conv2d
 
     W_{out} &= \frac{\left ( W_{in} + padding\_width\_left + padding\_width\_right -\left ( dilation[1]*\left ( W_{f}-1 \right )+1 \right ) \right )}{stride[1]}+1
 
-如果 ``padding`` = "SAME":
+如果  ``padding``  = "SAME":
 
 .. math::
     H_{out} = \frac{(H_{in} + stride[0] - 1)}{stride[0]}
@@ -60,7 +60,7 @@ conv2d
 .. math::
     W_{out} = \frac{(W_{in} + stride[1] - 1)}{stride[1]}
 
-如果 ``padding`` = "VALID":
+如果  ``padding``  = "VALID":
 
 .. math::
     H_{out} = \frac{\left ( H_{in} -\left ( dilation[0]*\left ( H_{f}-1 \right )+1 \right ) \right )}{stride[0]}+1
@@ -74,16 +74,16 @@ conv2d
     - **num_filters** (int) - 滤波器（卷积核）的个数。和输出图像通道相同。
     - **filter_size** (int|list|tuple) - 滤波器大小。如果它是一个列表或元组，则必须包含两个整数值：（filter_size_height，filter_size_width）。若为一个整数，filter_size_height = filter_size_width = filter_size。
     - **stride** (int|list|tuple，可选) - 步长大小。滤波器和输入进行卷积计算时滑动的步长。如果它是一个列表或元组，则必须包含两个整型数：（stride_height,stride_width）。若为一个整数，stride_height = stride_width = stride。默认值：1。
-    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：
+    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述  ``padding``  = "SAME"或   ``padding``  = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：
 
-        - (1)包含 4 个二元组：当 ``data_format`` 为"NCHW"时为 [[0,0], [0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为"NHWC"时为[[0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；
+        - (1)包含 4 个二元组：当  ``data_format``  为"NCHW"时为 [[0,0], [0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当  ``data_format``  为"NHWC"时为[[0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；
         - (2)包含 4 个整数值：[padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；
         - (3)包含 2 个整数值：[padding_height, padding_width]，此时 padding_height_top = padding_height_bottom = padding_height， padding_width_left = padding_width_right = padding_width。若为一个整数，padding_height = padding_width = padding。默认值：0。
 
     - **dilation** (int|list|tuple，可选) - 膨胀比例大小。空洞卷积时会使用该参数，滤波器对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息。如果膨胀比例为列表或元组，则必须包含两个整型数：（dilation_height,dilation_width）。若为一个整数，dilation_height = dilation_width = dilation。默认值：1。
     - **groups** (int，可选) - 二维卷积层的组数。根据 Alex Krizhevsky 的深度卷积神经网络（CNN）论文中的成组卷积：当 group=n，输入和滤波器分别根据通道数量平均分为 n 组，第一组滤波器和第一组输入进行卷积计算，第二组滤波器和第二组输入进行卷积计算，……，第 n 组滤波器和第 n 组输入进行卷积计算。默认值：1。
     - **param_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** (ParamAttr|bool，可选) - 指定偏置参数属性的对象。若 ``bias_attr`` 为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** (ParamAttr|bool，可选) - 指定偏置参数属性的对象。若  ``bias_attr``  为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **use_cudnn** (bool，可选) - 是否使用 cudnn 内核。只有已安装 cudnn 库时才有效。默认值：True。
     - **act** (str，可选) - 激活函数类型，如 tanh、softmax、sigmoid，relu 等，支持列表请参考 :ref:`api_guide_activations`。如果设为 None，则未添加激活函数。默认值：None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
@@ -91,7 +91,7 @@ conv2d
 
 返回
 ::::::::::::
-4-D Tensor，数据类型与 ``input`` 一致。如果未指定激活层，则返回卷积计算的结果，如果指定激活层，则返回卷积和激活计算之后的最终结果。
+4-D Tensor，数据类型与  ``input``  一致。如果未指定激活层，则返回卷积计算的结果，如果指定激活层，则返回卷积和激活计算之后的最终结果。
 
 
 
diff --git a/docs/api/paddle/static/nn/conv2d_transpose_cn.rst b/docs/api/paddle/static/nn/conv2d_transpose_cn.rst
index 3c100a5e08a..1d8580ad12f 100644
--- a/docs/api/paddle/static/nn/conv2d_transpose_cn.rst
+++ b/docs/api/paddle/static/nn/conv2d_transpose_cn.rst
@@ -32,9 +32,9 @@ conv2d_transpose
     -  :math:`X`：输入，具有 NCHW 或 NHWC 格式的 4-D Tensor；
     -  :math:`W`：滤波器，具有 NCHW 格式的 4-D Tensor；
     -  :math:`*`：卷积计算（注意：转置卷积本质上的计算还是卷积）；
-    -  :math:`b`：偏置（bias），2-D Tensor，形状为 ``[M,1]``；
+    -  :math:`b`：偏置（bias），2-D Tensor，形状为  ``[M,1]`` ；
     -  :math:`σ`：激活函数；
-    -  :math:`Out`：输出值，NCHW 或 NHWC 格式的 4-D Tensor，和 ``X`` 的形状可能不同。
+    -  :math:`Out`：输出值，NCHW 或 NHWC 格式的 4-D Tensor，和  ``X``  的形状可能不同。
 
 **示例**
 
@@ -57,13 +57,13 @@ conv2d_transpose
         & H_{out}\in[H'_{out},H'_{out} + strides[0])\\
         & W_{out}\in[W'_{out},W'_{out} + strides[1])\\
 
-如果 ``padding`` = "SAME":
+如果  ``padding``  = "SAME":
 
 .. math::
    & H'_{out} = \frac{(H_{in} + stride[0] - 1)}{stride[0]}\\
    & W'_{out} = \frac{(W_{in} + stride[1] - 1)}{stride[1]}\\
 
-如果 ``padding`` = "VALID":
+如果  ``padding``  = "VALID":
 
 .. math::
     & H'_{out} = (H_{in}-1)*strides[0] + dilations[0]*(H_f-1)+1\\
@@ -75,7 +75,7 @@ conv2d_transpose
 
     由于转置卷积可以当成是卷积的反向计算，而根据卷积的输入输出计算公式来说，不同大小的输入特征层可能对应着相同大小的输出特征层，所以对应到转置卷积来说，固定大小的输入特征层对应的输出特征层大小并不唯一。
 
-    如果指定了 output_size， ``conv2d_transpose`` 可以自动计算滤波器的大小。
+    如果指定了 output_size，  ``conv2d_transpose``  可以自动计算滤波器的大小。
 
 参数
 ::::::::::::
@@ -83,10 +83,10 @@ conv2d_transpose
   - **input** （Tensor）- 形状为 :math:`[N, C, H, W]` 或 :math:`[N, H, W, C]` 的 4-D Tensor，N 是批尺寸，C 是通道数，H 是特征高度，W 是特征宽度。数据类型：float32 或 float64。
   - **num_filters** (int) - 滤波器（卷积核）的个数，与输出图片的通道数相同。
   - **output_size** (int|tuple，可选) - 输出图片的大小。如果 output_size 是一个元组，则必须包含两个整型数，（output_size_height，output_size_width）。如果 output_size=None，则内部会使用 filter_size、padding 和 stride 来计算 output_size。如果 output_size 和 filter_size 是同时指定的，那么它们应满足上面的公式。默认：None。output_size 和 filter_size 不能同时为 None。
-  - **filter_size** (int|tuple，可选) - 滤波器大小。如果 filter_size 是一个元组，则必须包含两个整型数，（filter_size_height, filter_size_width）。否则，filter_size_height = filter_size_width = filter_size。如果 filter_size=None，则必须指定 output_size， ``conv2d_transpose`` 内部会根据 output_size、padding 和 stride 计算出滤波器大小。默认：None。output_size 和 filter_size 不能同时为 None。
-  - **padding** (int|list|tuple|str，可选) - 填充 padding 大小。padding 参数在输入特征层每边添加 ``dilation * (kernel_size - 1) - padding`` 个 0。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：
+  - **filter_size** (int|tuple，可选) - 滤波器大小。如果 filter_size 是一个元组，则必须包含两个整型数，（filter_size_height, filter_size_width）。否则，filter_size_height = filter_size_width = filter_size。如果 filter_size=None，则必须指定 output_size，  ``conv2d_transpose``  内部会根据 output_size、padding 和 stride 计算出滤波器大小。默认：None。output_size 和 filter_size 不能同时为 None。
+  - **padding** (int|list|tuple|str，可选) - 填充 padding 大小。padding 参数在输入特征层每边添加  ``dilation * (kernel_size - 1) - padding``  个 0。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述  ``padding``  = "SAME"或   ``padding``  = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：
 
-    - (1)包含 4 个二元组：当 ``data_format`` 为"NCHW"时为 [[0,0], [0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为"NHWC"时为[[0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；
+    - (1)包含 4 个二元组：当  ``data_format``  为"NCHW"时为 [[0,0], [0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当  ``data_format``  为"NHWC"时为[[0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；
     - (2)包含 4 个整数值：[padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；
     - (3)包含 2 个整数值：[padding_height, padding_width]，此时 padding_height_top = padding_height_bottom = padding_height， padding_width_left = padding_width_right = padding_width。若为一个整数，padding_height = padding_width = padding。默认值：0。
 
@@ -102,7 +102,7 @@ conv2d_transpose
 
 返回
 ::::::::::::
-4-D Tensor，数据类型与 ``input`` 一致。如果未指定激活层，则返回转置卷积计算的结果，如果指定激活层，则返回转置卷积和激活计算之后的最终结果。
+4-D Tensor，数据类型与  ``input``  一致。如果未指定激活层，则返回转置卷积计算的结果，如果指定激活层，则返回转置卷积和激活计算之后的最终结果。
 
 
 代码示例
diff --git a/docs/api/paddle/static/nn/conv3d_cn.rst b/docs/api/paddle/static/nn/conv3d_cn.rst
index 8a5b143bc95..68095f78e9d 100644
--- a/docs/api/paddle/static/nn/conv3d_cn.rst
+++ b/docs/api/paddle/static/nn/conv3d_cn.rst
@@ -28,9 +28,9 @@ conv3d
     - :math:`X`：输入值，NCDHW 或 NDHWC 格式的 5-D Tensor；
     - :math:`W`：滤波器值，MCDHW 格式的 5-D Tensor；
     - :math:`*`：卷积操作；
-    - :math:`b`：偏置值，2-D Tensor，形为 ``[M,1]``；
+    - :math:`b`：偏置值，2-D Tensor，形为  ``[M,1]`` ；
     - :math:`\sigma`：激活函数；
-    - :math:`Out`：输出值，NCDHW 或 NDHWC 格式的 5-D Tensor，和 ``X`` 的形状可能不同。
+    - :math:`Out`：输出值，NCDHW 或 NDHWC 格式的 5-D Tensor，和  ``X``  的形状可能不同。
 
 **示例**
 
@@ -54,7 +54,7 @@ conv3d
 
     W_{out} &= \frac{\left ( W_{in} + padding\_width\_left + padding\_width\_right -\left ( dilation[2]*\left ( W_{f}-1 \right )+1 \right ) \right )}{stride[2]}+1
 
-如果 ``padding`` = "SAME":
+如果  ``padding``  = "SAME":
 
 .. math::
     D_{out} = \frac{(D_{in} + stride[0] - 1)}{stride[0]}
@@ -63,7 +63,7 @@ conv3d
 
     W_{out} = \frac{(W_{in} + stride[2] - 1)}{stride[2]}
 
-如果 ``padding`` = "VALID":
+如果  ``padding``  = "VALID":
 
 .. math::
     D_{out} = \frac{\left ( D_{in} -\left ( dilation[0]*\left ( D_{f}-1 \right )+1 \right ) \right )}{stride[0]}+1
@@ -79,16 +79,16 @@ conv3d
     - **num_fliters** (int) - 滤波器（卷积核）的个数。和输出图像通道相同。
     - **filter_size** (int|list|tuple) - 滤波器大小。如果它是一个列表或元组，则必须包含三个整数值：（filter_size_depth, filter_size_height，filter_size_width）。若为一个整数，则 filter_size_depth = filter_size_height = filter_size_width = filter_size。
     - **stride** (int|list|tuple，可选) - 步长大小。滤波器和输入进行卷积计算时滑动的步长。如果它是一个列表或元组，则必须包含三个整型数：（stride_depth, stride_height, stride_width）。若为一个整数，stride_depth = stride_height = stride_width = stride。默认值：1。
-    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：
+    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述  ``padding``  = "SAME"或   ``padding``  = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：
 
-        - (1)包含 5 个二元组：当 ``data_format`` 为"NCDHW"时为 [[0,0], [0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为"NDHWC"时为[[0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；
+        - (1)包含 5 个二元组：当  ``data_format``  为"NCDHW"时为 [[0,0], [0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当  ``data_format``  为"NDHWC"时为[[0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；
         - (2)包含 6 个整数值：[padding_depth_front, padding_depth_back, padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；
         - (3)包含 3 个整数值：[padding_depth, padding_height, padding_width]，此时 padding_depth_front = padding_depth_back = padding_depth, padding_height_top = padding_height_bottom = padding_height, padding_width_left = padding_width_right = padding_width。若为一个整数，padding_depth = padding_height = padding_width = padding。默认值：0。
 
     - **dilation** (int|list|tuple，可选) - 膨胀比例大小。空洞卷积时会使用该参数，滤波器对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息。如果膨胀比例为列表或元组，则必须包含三个整型数：（dilation_depth, dilation_height,dilation_width）。若为一个整数，dilation_depth = dilation_height = dilation_width = dilation。默认值：1。
     - **groups** (int，可选) - 三维卷积层的组数。根据 Alex Krizhevsky 的深度卷积神经网络（CNN）论文中的成组卷积：当 group=n，输入和滤波器分别根据通道数量平均分为 n 组，第一组滤波器和第一组输入进行卷积计算，第二组滤波器和第二组输入进行卷积计算，……，第 n 组滤波器和第 n 组输入进行卷积计算。默认值：1。
     - **param_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-    - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若 ``bias_attr`` 为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+    - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若  ``bias_attr``  为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **use_cudnn** （bool，可选）- 是否使用 cudnn 内核。只有已安装 cudnn 库时才有效。默认值：True。
     - **act** (str，可选) - 激活函数类型，如 tanh、softmax、sigmoid，relu 等，支持列表请参考 :ref:`api_guide_activations`。如果设为 None，则未添加激活函数。默认值：None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
@@ -96,7 +96,7 @@ conv3d
 
 返回
 ::::::::::::
-5-D Tensor，数据类型与 ``input`` 一致。如果未指定激活层，则返回卷积计算的结果，如果指定激活层，则返回卷积和激活计算之后的最终结果。
+5-D Tensor，数据类型与  ``input``  一致。如果未指定激活层，则返回卷积计算的结果，如果指定激活层，则返回卷积和激活计算之后的最终结果。
 
 
 代码示例
diff --git a/docs/api/paddle/static/nn/conv3d_transpose_cn.rst b/docs/api/paddle/static/nn/conv3d_transpose_cn.rst
index 3320f9a74b2..b9cdba364c1 100755
--- a/docs/api/paddle/static/nn/conv3d_transpose_cn.rst
+++ b/docs/api/paddle/static/nn/conv3d_transpose_cn.rst
@@ -31,9 +31,9 @@ conv3d_transpose
     -  :math:`X`：输入，具有 NCDHW 或 NDHWC 格式的 5-D Tensor；
     -  :math:`W`：滤波器，具有 NCDHW 格式的 5-D Tensor；
     -  :math:`*`：卷积操作（注意：转置卷积本质上的计算还是卷积）；
-    -  :math:`b`：偏置（bias），2-D Tensor，形状为 ``[M,1]``；
+    -  :math:`b`：偏置（bias），2-D Tensor，形状为  ``[M,1]`` ；
     -  :math:`σ`：激活函数；
-    -  :math:`Out`：输出值，NCDHW 或 NDHWC 格式的 5-D Tensor，和 ``X`` 的形状可能不同。
+    -  :math:`Out`：输出值，NCDHW 或 NDHWC 格式的 5-D Tensor，和  ``X``  的形状可能不同。
 
 **示例**
 
@@ -61,14 +61,14 @@ conv3d_transpose
     & H_{out}\in[H'_{out},H'_{out} + strides[1])\\
     & W_{out}\in[W'_{out},W'_{out} + strides[2])\\
 
-如果 ``padding`` = "SAME":
+如果  ``padding``  = "SAME":
 
 .. math::
     D'_{out} = \frac{(D_{in} + stride[0] - 1)}{stride[0]}\\
     H'_{out} = \frac{(H_{in} + stride[1] - 1)}{stride[1]}\\
     W'_{out} = \frac{(W_{in} + stride[2] - 1)}{stride[2]}\\
 
-如果 ``padding`` = "VALID":
+如果  ``padding``  = "VALID":
 
 .. math::
     D'_{out}=(D_{in}-1)*strides[0] + dilations[0]*(D_f-1)+1\\
@@ -82,7 +82,7 @@ conv3d_transpose
 
     由于转置卷积可以当成是卷积的反向计算，而根据卷积的输入输出计算公式来说，不同大小的输入特征层可能对应着相同大小的输出特征层，所以对应到转置卷积来说，固定大小的输入特征层对应的输出特征层大小并不唯一。
 
-    如果指定了 output_size， ``conv3d_transpose`` 可以自动计算滤波器的大小。
+    如果指定了 output_size，  ``conv3d_transpose``  可以自动计算滤波器的大小。
 
 参数
 ::::::::::::
@@ -90,10 +90,10 @@ conv3d_transpose
   - **input** （Tensor）- 形状为 :math:`[N, C, D, H, W]` 或 :math:`[N, D, H, W, C]` 的 5-D Tensor，N 是批尺寸，C 是通道数，D 是特征深度，H 是特征高度，W 是特征宽度，数据类型：float32 或 float64。
   - **num_filters** (int) - 滤波器（卷积核）的个数，与输出的图片的通道数相同。
   - **output_size** (int|tuple，可选) - 输出图片的大小。如果 output_size 是一个元组，则必须包含三个整型数，（output_size_depth，output_size_height，output_size_width）。如果 output_size=None，则内部会使用 filter_size、padding 和 stride 来计算 output_size。如果 output_size 和 filter_size 是同时指定的，那么它们应满足上面的公式。默认：None。output_size 和 filter_size 不能同时为 None。
-  - **filter_size** (int|tuple，可选) - 滤波器大小。如果 filter_size 是一个元组，则必须包含三个整型数，（filter_size_depth，filter_size_height, filter_size_width）。否则，filter_size_depth = filter_size_height = filter_size_width = filter_size。如果 filter_size=None，则必须指定 output_size， ``conv2d_transpose`` 内部会根据 output_size、padding 和 stride 计算出滤波器大小。默认：None。output_size 和 filter_size 不能同时为 None。
-  - **padding** (int|list|tuple|str，可选) - 填充 padding 大小。padding 参数在输入特征层每边添加 ``dilation * (kernel_size - 1) - padding`` 个 0。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：
+  - **filter_size** (int|tuple，可选) - 滤波器大小。如果 filter_size 是一个元组，则必须包含三个整型数，（filter_size_depth，filter_size_height, filter_size_width）。否则，filter_size_depth = filter_size_height = filter_size_width = filter_size。如果 filter_size=None，则必须指定 output_size，  ``conv2d_transpose``  内部会根据 output_size、padding 和 stride 计算出滤波器大小。默认：None。output_size 和 filter_size 不能同时为 None。
+  - **padding** (int|list|tuple|str，可选) - 填充 padding 大小。padding 参数在输入特征层每边添加  ``dilation * (kernel_size - 1) - padding``  个 0。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述  ``padding``  = "SAME"或   ``padding``  = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有 3 种格式：
 
-    - (1)包含 5 个二元组：当 ``data_format`` 为"NCDHW"时为 [[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当 ``data_format`` 为"NDHWC"时为[[0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]；
+    - (1)包含 5 个二元组：当  ``data_format``  为"NCDHW"时为 [[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当  ``data_format``  为"NDHWC"时为[[0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]；
     - (2)包含 6 个整数值：[pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]；
     - (3)包含 3 个整数值：[pad_depth, pad_height, pad_width]，此时 pad_depth_front = pad_depth_back = pad_depth, pad_height_top = pad_height_bottom = pad_height, pad_width_left = pad_width_right = pad_width。若为一个整数，pad_depth = pad_height = pad_width = padding。默认值：0。
 
@@ -109,7 +109,7 @@ conv3d_transpose
 
 返回
 ::::::::::::
-5-D Tensor，数据类型与 ``input`` 一致。如果未指定激活层，则返回转置卷积计算的结果，如果指定激活层，则返回转置卷积和激活计算之后的最终结果。
+5-D Tensor，数据类型与  ``input``  一致。如果未指定激活层，则返回转置卷积计算的结果，如果指定激活层，则返回转置卷积和激活计算之后的最终结果。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/static/nn/embedding_cn.rst b/docs/api/paddle/static/nn/embedding_cn.rst
index 42f094c94fe..dddbd2ba70f 100644
--- a/docs/api/paddle/static/nn/embedding_cn.rst
+++ b/docs/api/paddle/static/nn/embedding_cn.rst
@@ -16,7 +16,7 @@ embedding
 输出的 Tensor 的 shape 是将输入 Tensor shape 的会在输出的 embedding 最后追加一维 emb_size。
 
 .. note::
-    input 中的 id 必须满足 ``0 =< id < size[0]``，否则程序会抛异常退出。
+    input 中的 id 必须满足  ``0 =< id < size[0]`` ，否则程序会抛异常退出。
 
 
 ::
@@ -62,12 +62,12 @@ embedding
 参数
 ::::::::::::
 
-    - **input** (Variable) - 存储 id 信息的 Tensor，数据类型必须为：int64，输入的 shape 最后一维须为 1。input 中的 id 必须满足 ``0 =< id < size[0]`` 。
+    - **input** (Variable) - 存储 id 信息的 Tensor，数据类型必须为：int64，输入的 shape 最后一维须为 1。input 中的 id 必须满足  ``0 =< id < size[0]``  。
     - **size** (tuple|list) - embedding 矩阵的维度。必须包含两个元素，第一个元素为 vocab_size(词表大小)，第二个为 emb_size（embedding 层维度）。
     - **is_sparse** (bool，可选) - 是否使用稀疏的更新方式，这个参数只会影响反向的梯度更新的性能，sparse 更新速度更快，推荐使用稀疏更新的方式。但某些 optimizer 不支持 sparse 更新，比如 :ref:`cn_api_paddle_optimizer_Adadelta` 、 :ref:`cn_api_paddle_optimizer_Adamax`，此时 is_sparse 必须为 False。默认为 False。
     - **is_distributed** (bool，可选) - 是否使用分布式的方式存储 embedding 矩阵，仅在多机分布式 cpu 训练中使用。默认为 False。
-    - **padding_idx** (int|long|None，可选) - padding_idx 需在区间 ``[-vocab_size, vocab_size)``，否则不生效，``padding_idx < 0`` 时，padding_idx 会被改成``vocab_size + padding_idx``，input 中等于 padding_index 的 id 对应的 embedding 信息会被设置为 0，且这部分填充数据在训练时将不会被更新。如果为 None，不作处理，默认为 None。
-    - **param_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr`。此外，可以通过 ``param_attr`` 参数加载用户自定义或预训练的词向量。只需将本地词向量转为 numpy 数据格式，且保证本地词向量的 shape 和 embedding 的 ``size`` 参数一致，然后使用 :ref:`cn_api_paddle_to_tensor` 进行初始化，即可实现加载自定义或预训练的词向量。
+    - **padding_idx** (int|long|None，可选) - padding_idx 需在区间  ``[-vocab_size, vocab_size)`` ，否则不生效， ``padding_idx < 0``  时，padding_idx 会被改成 ``vocab_size + padding_idx`` ，input 中等于 padding_index 的 id 对应的 embedding 信息会被设置为 0，且这部分填充数据在训练时将不会被更新。如果为 None，不作处理，默认为 None。
+    - **param_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr`。此外，可以通过  ``param_attr``  参数加载用户自定义或预训练的词向量。只需将本地词向量转为 numpy 数据格式，且保证本地词向量的 shape 和 embedding 的  ``size``  参数一致，然后使用 :ref:`cn_api_paddle_to_tensor` 进行初始化，即可实现加载自定义或预训练的词向量。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，数据类型必须为：float32 或 float64，默认为 float32。
 
 返回
diff --git a/docs/api/paddle/static/nn/group_norm_cn.rst b/docs/api/paddle/static/nn/group_norm_cn.rst
index 00852f17be5..e77e3662f6d 100755
--- a/docs/api/paddle/static/nn/group_norm_cn.rst
+++ b/docs/api/paddle/static/nn/group_norm_cn.rst
@@ -14,8 +14,8 @@ group_norm
   - **input** (Tensor)：维度大于 1 的 Tensor，数据类型为 float32 或 float64。
   - **groups** (int)：从 channel 中分离出来的 group 的数目，数据类型为 int32。
   - **epsilon** (float，可选)：为防止方差除以零，增加一个很小的值。数据类型为 float32。默认值：1e-05。
-  - **param_attr** (ParamAttr|bool，可选)：指定权重参数属性的对象。若 ``param_attr`` 为 bool 类型，只支持为 False，表示没有权重参数。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
-  - **bias_attr** (ParamAttr|bool，可选)：指定偏置参数属性的对象。若 ``bias_attr`` 为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+  - **param_attr** (ParamAttr|bool，可选)：指定权重参数属性的对象。若  ``param_attr``  为 bool 类型，只支持为 False，表示没有权重参数。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
+  - **bias_attr** (ParamAttr|bool，可选)：指定偏置参数属性的对象。若  ``bias_attr``  为 bool 类型，只支持为 False，表示没有偏置参数。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
   - **act** (str，可选)：将激活应用于输出的 group normalization。
   - **data_layout** (str，可选)：指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCHW"和"NHWC"，默认值："NCHW"。如果是"NCHW"，则数据按[批大小，输入通道数，* ]的顺序存储。
   - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
diff --git a/docs/api/paddle/static/nn/instance_norm_cn.rst b/docs/api/paddle/static/nn/instance_norm_cn.rst
index 87aa05163f3..13d82e202c4 100644
--- a/docs/api/paddle/static/nn/instance_norm_cn.rst
+++ b/docs/api/paddle/static/nn/instance_norm_cn.rst
@@ -16,7 +16,7 @@ NCHW[batch,in_channels,in_height,in_width]
 
 更多详情请参考：`Instance Normalization: The Missing Ingredient for Fast Stylization <https://arxiv.org/pdf/1607.08022.pdf>`_
 
-``input`` 是 mini-batch 的输入。
+ ``input``  是 mini-batch 的输入。
 
 .. math::
     \mu_{\beta}        &\gets \frac{1}{m} \sum_{i=1}^{m} x_i                                 \quad &// mean of each channel in each sample in a batch  \\
diff --git a/docs/api/paddle/static/nn/layer_norm_cn.rst b/docs/api/paddle/static/nn/layer_norm_cn.rst
index 0ca5b14fce3..9cee5f5609e 100644
--- a/docs/api/paddle/static/nn/layer_norm_cn.rst
+++ b/docs/api/paddle/static/nn/layer_norm_cn.rst
@@ -31,10 +31,10 @@ layer_norm
 参数
 ::::::::::::
 
-  - **input** (Tensor) - 维度为任意维度的多维 ``Tensor``，数据类型为 float32 或 float64。
-  - **scale** (bool，可选) - 指明是否在归一化后学习自适应增益 ``g``。默认值：True。
-  - **shift** (bool，可选) - 指明是否在归一化后学习自适应偏差 ``b``。默认值：True。
-  - **begin_norm_axis** (int，可选) - 指明归一化将沿着 ``begin_norm_axis`` 到 ``rank（input）`` 的维度执行。默认值：1。
+  - **input** (Tensor) - 维度为任意维度的多维  ``Tensor`` ，数据类型为 float32 或 float64。
+  - **scale** (bool，可选) - 指明是否在归一化后学习自适应增益  ``g`` 。默认值：True。
+  - **shift** (bool，可选) - 指明是否在归一化后学习自适应偏差  ``b`` 。默认值：True。
+  - **begin_norm_axis** (int，可选) - 指明归一化将沿着  ``begin_norm_axis``  到  ``rank（input）``  的维度执行。默认值：1。
   - **epsilon** (float，可选) - 指明在计算过程中是否添加较小的值到方差中以防止除零。默认值：1e-05。
   - **param_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
   - **bias_attr** (ParamAttr，可选) - 指定偏置参数属性的对象。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
@@ -43,7 +43,7 @@ layer_norm
 
 返回
 ::::::::::::
-表示归一化结果的 ``Tensor``，数据类型和 ``input`` 一致，返回维度和 ``input`` 一致。
+表示归一化结果的  ``Tensor`` ，数据类型和  ``input``  一致，返回维度和  ``input``  一致。
 
 
 代码示例
diff --git a/docs/api/paddle/static/nn/nce_cn.rst b/docs/api/paddle/static/nn/nce_cn.rst
index f66d1e07645..bcd18e64209 100644
--- a/docs/api/paddle/static/nn/nce_cn.rst
+++ b/docs/api/paddle/static/nn/nce_cn.rst
@@ -26,10 +26,10 @@ nce
     - **bias_attr** (ParamAttr，可选)：指定偏置参数属性的对象。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **num_neg_samples** (int) - 负样例的数量，默认值是 10。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
-    - **sampler** (str，可选) – 采样器，用于从负类别中进行取样。可以是 ``uniform``, ``log_uniform`` 或 ``custom_dist``，默认 ``uniform`` 。
-    - **custom_dist** (nd.array，可选) – 第 0 维的长度为 ``num_total_classes``。如果采样器类别为 ``custom_dist``，则使用此参数。custom_dist[i] 是第 i 个类别被取样的概率。默认为 None。
+    - **sampler** (str，可选) – 采样器，用于从负类别中进行取样。可以是  ``uniform`` ,  ``log_uniform``  或  ``custom_dist`` ，默认  ``uniform``  。
+    - **custom_dist** (nd.array，可选) – 第 0 维的长度为  ``num_total_classes`` 。如果采样器类别为  ``custom_dist`` ，则使用此参数。custom_dist[i] 是第 i 个类别被取样的概率。默认为 None。
     - **seed** (int，可选) – 采样器使用的 seed。默认为 0。
-    - **is_sparse** (bool，可选) – 标志位，指明是否使用稀疏更新，为 ``True`` 时 :math:`weight@GRAD` 和 :math:`bias@GRAD` 的类型会变为 SelectedRows。默认为 ``False`` 。
+    - **is_sparse** (bool，可选) – 标志位，指明是否使用稀疏更新，为  ``True``  时 :math:`weight@GRAD` 和 :math:`bias@GRAD` 的类型会变为 SelectedRows。默认为  ``False``  。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/static/nn/sequence_conv_cn.rst b/docs/api/paddle/static/nn/sequence_conv_cn.rst
index 766d9e3b0e1..89e1104677f 100644
--- a/docs/api/paddle/static/nn/sequence_conv_cn.rst
+++ b/docs/api/paddle/static/nn/sequence_conv_cn.rst
@@ -8,10 +8,10 @@ sequence_conv
 
 .. note::
     1. 该 API 的输入只能是带有 LoD 信息的 Tensor，如果您需要处理的输入是普通的 Tensor 类型，请使用 :ref:`paddle.nn.functional.conv2d <cn_api_paddle_nn_functional_conv2d>` 。
-    2. 参数 ``padding`` 为无用参数，将在未来的版本中被移除。
+    2. 参数  ``padding``  为无用参数，将在未来的版本中被移除。
 
 
-在给定的卷积参数下（如卷积核数目、卷积核大小等），对输入的变长序列（sequence）Tensor 进行卷积操作。默认情况下，该 OP 会自适应地在每个输入序列的两端等长地填充全 0 数据，以确保卷积后的序列输出长度和输入长度一致。支持通过配置 ``padding_start`` 参数来指定序列填充的行为。
+在给定的卷积参数下（如卷积核数目、卷积核大小等），对输入的变长序列（sequence）Tensor 进行卷积操作。默认情况下，该 OP 会自适应地在每个输入序列的两端等长地填充全 0 数据，以确保卷积后的序列输出长度和输入长度一致。支持通过配置  ``padding_start``  参数来指定序列填充的行为。
 
 ::
 
@@ -52,12 +52,12 @@ sequence_conv
 参数
 :::::::::
 
-    - **input** (Variable) - 维度为 :math:`（M, K)` 的二维 Tensor，仅支持 lod_level 为 1。其中 M 是 mini-batch 的总时间步数，K 是输入的 ``hidden_size`` 特征维度。数据类型为 float32 或 float64。
+    - **input** (Variable) - 维度为 :math:`（M, K)` 的二维 Tensor，仅支持 lod_level 为 1。其中 M 是 mini-batch 的总时间步数，K 是输入的  ``hidden_size``  特征维度。数据类型为 float32 或 float64。
     - **num_filters** (int) - 滤波器的数量。
-    - **filter_size** (int，可选) - 滤波器的高度（H）；不支持指定滤波器宽度（W），宽度固定取值为输入的 ``hidden_size``。默认值为 3。
+    - **filter_size** (int，可选) - 滤波器的高度（H）；不支持指定滤波器宽度（W），宽度固定取值为输入的  ``hidden_size`` 。默认值为 3。
     - **filter_stride** (int，可选) - 滤波器每次移动的步长。目前只支持取值为 1，默认为 1。
-    - **padding** (bool，可选) - **此参数不起任何作用，将在未来的版本中被移除。** 无论 ``padding`` 取值为 False 或者 True，默认地，该函数会自适应地在每个输入序列的两端等长地填充全 0 数据，以确保卷积后的输出序列长度和输入长度一致。默认填充是考虑到输入的序列长度可能会小于卷积核大小，这会导致无正确计算卷积输出。填充为 0 的数据在训练过程中不会被更新。默认为 True。
-    - **padding_start** (int，可选) - 表示对输入序列填充时的起始位置，可以为负值。负值表示在每个序列的首端填充 ``|padding_start|`` 个时间步（time_step）的全 0 数据；正值表示对每个序列跳过前 ``padding_start`` 个时间步的数据。同时在末端填充 :math:`filter\_size + padding\_start - 1` 个时间步的全 0 数据，以保证卷积输出序列长度和输入长度一致。如果 ``padding_start`` 为 None，则在每个序列的两端填充 :math:`\frac{filter\_size}{2}` 个时间步的全 0 数据；如果 ``padding_start`` 设置为 0，则只在序列的末端填充 :math:`filter\_size - 1` 个时间步的全 0 数据。默认为 None。
+    - **padding** (bool，可选) - **此参数不起任何作用，将在未来的版本中被移除。** 无论  ``padding``  取值为 False 或者 True，默认地，该函数会自适应地在每个输入序列的两端等长地填充全 0 数据，以确保卷积后的输出序列长度和输入长度一致。默认填充是考虑到输入的序列长度可能会小于卷积核大小，这会导致无正确计算卷积输出。填充为 0 的数据在训练过程中不会被更新。默认为 True。
+    - **padding_start** (int，可选) - 表示对输入序列填充时的起始位置，可以为负值。负值表示在每个序列的首端填充  ``|padding_start|``  个时间步（time_step）的全 0 数据；正值表示对每个序列跳过前  ``padding_start``  个时间步的数据。同时在末端填充 :math:`filter\_size + padding\_start - 1` 个时间步的全 0 数据，以保证卷积输出序列长度和输入长度一致。如果  ``padding_start``  为 None，则在每个序列的两端填充 :math:`\frac{filter\_size}{2}` 个时间步的全 0 数据；如果  ``padding_start``  设置为 0，则只在序列的末端填充 :math:`filter\_size - 1` 个时间步的全 0 数据。默认为 None。
     - **bias_attr** (ParamAttr，可选) - 指定偏置参数属性的对象。默认值为 None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **param_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr` 。
     - **act** (str，可选) – 应用于输出上的激活函数，如 tanh、softmax、sigmoid，relu 等，支持列表请参考 :ref:`api_guide_activations`，默认值为 None。
diff --git a/docs/api/paddle/static/nn/sequence_expand_cn.rst b/docs/api/paddle/static/nn/sequence_expand_cn.rst
index 6ac59f6421b..96a447bb8fe 100644
--- a/docs/api/paddle/static/nn/sequence_expand_cn.rst
+++ b/docs/api/paddle/static/nn/sequence_expand_cn.rst
@@ -8,10 +8,10 @@ sequence_expand
 
 
 
-序列扩张层（Sequence Expand Layer)，根据输入 ``y`` 的第 ``ref_level`` 层 lod 对输入 ``x`` 进行扩展。``x`` 的 lod level 最多为 1，若 ``x`` 的 lod level 为 1，则 ``x`` 的 lod 大小必须与 ``y`` 的第 ``ref_level`` 层 lod 大小相等；若 ``x`` 的 lod level 为 0，则 ``x`` 的第一维大小必须与 ``y`` 第 ``ref_level`` 层大小相等。``x`` 的秩最少为 2，当 ``x`` 的秩大于 2 时，将被当作是一个二维 Tensor 处理。
+序列扩张层（Sequence Expand Layer)，根据输入  ``y``  的第  ``ref_level``  层 lod 对输入  ``x``  进行扩展。 ``x``  的 lod level 最多为 1，若  ``x``  的 lod level 为 1，则  ``x``  的 lod 大小必须与  ``y``  的第  ``ref_level``  层 lod 大小相等；若  ``x``  的 lod level 为 0，则  ``x``  的第一维大小必须与  ``y``  第  ``ref_level``  层大小相等。 ``x``  的秩最少为 2，当  ``x``  的秩大于 2 时，将被当作是一个二维 Tensor 处理。
 
 .. note::
-    该 API 的输入 ``x`` 可以是 Tensor 或 DenseTensor， ``y`` 只能是 DenseTensor。
+    该 API 的输入  ``x``  可以是 Tensor 或 DenseTensor，  ``y``  只能是 DenseTensor。
 
 范例解释如下：
 
@@ -55,12 +55,12 @@ sequence_expand
 
     - **x** (Variable) - 输入变量，维度为 :math:`[M, K]` ，lod level 至多 1 的二维 Tensor。数据类型支持 int32，int64，float32 或 float64。
     - **y** (Variable) - 输入变量，lod level 至少为 1 的 Tensor。数据类型不限。
-    - **ref_level** (int，可选) - 扩展 ``x`` 所依据的 ``y`` 的 lod 层。默认值-1，表示 lod 的最后一层。
+    - **ref_level** (int，可选) - 扩展  ``x``  所依据的  ``y``  的 lod 层。默认值-1，表示 lod 的最后一层。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-扩展变量，维度为 :math:`[N, K]` 的 Tensor，N 由输入 ``x`` 和 ``y`` 的 lod 共同决定。数据类型与输入 ``x`` 一致。
+扩展变量，维度为 :math:`[N, K]` 的 Tensor，N 由输入  ``x``  和  ``y``  的 lod 共同决定。数据类型与输入  ``x``  一致。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/static/nn/sequence_pool_cn.rst b/docs/api/paddle/static/nn/sequence_pool_cn.rst
index 18982fb1e1b..c20854e783a 100644
--- a/docs/api/paddle/static/nn/sequence_pool_cn.rst
+++ b/docs/api/paddle/static/nn/sequence_pool_cn.rst
@@ -22,7 +22,7 @@ sequence_pool
 - **last**: :math:`Out[i] = X_{N\_i}`
 - **first**: :math:`Out[i] = X_{0}`
 
-其中 ``N_i`` 为待池化第 i 个输入序列的长度。
+其中  ``N_i``  为待池化第 i 个输入序列的长度。
 
 ::
 
diff --git a/docs/api/paddle/static/nn/sparse_embedding_cn.rst b/docs/api/paddle/static/nn/sparse_embedding_cn.rst
index 0b129dde64f..51d5b53d33a 100644
--- a/docs/api/paddle/static/nn/sparse_embedding_cn.rst
+++ b/docs/api/paddle/static/nn/sparse_embedding_cn.rst
@@ -14,7 +14,7 @@ sparse_embedding
 输出的 Tensor 的 shape 是将输入 Tensor shape 的会在输出的 embedding 最后追加一维 emb_size。
 
 .. note::
-    input 中的 id 必须满足 ``0 =< id < size[0]``，否则程序会抛异常退出。
+    input 中的 id 必须满足  ``0 =< id < size[0]`` ，否则程序会抛异常退出。
 
 
 ::
@@ -59,13 +59,13 @@ sparse_embedding
 
 参数
 ::::::::
-    - **input** (Variable) - 存储 id 信息的 Tensor，数据类型必须为：int64，输入的 shape 最后一维须为 1。input 中的 id 必须满足 ``0 =< id < size[0]`` 。
+    - **input** (Variable) - 存储 id 信息的 Tensor，数据类型必须为：int64，输入的 shape 最后一维须为 1。input 中的 id 必须满足  ``0 =< id < size[0]``  。
     - **size** (tuple|list) - embedding 矩阵的维度(vocab_size，emb_size)。必须包含两个元素，第一个元素为 vocab_size(词表大小)，第二个为 emb_size（embedding 层维度）。大规模稀疏场景下，参数规模初始为 0，会随着训练的进行逐步扩展，因此如果 vocab_size 暂时无用，其值可以为任意整数，emb_size 则为词嵌入权重参数的维度配置。
-    - **padding_idx** (int|long|None，可选) - padding_idx 需在区间 ``[-vocab_size, vocab_size)``，否则不生效，``padding_idx < 0`` 时，padding_idx 会被改成``vocab_size + padding_idx``，input 中等于 padding_index 的 id 对应的 embedding 信息会被设置为 0，且这部分填充数据在训练时将不会被更新。如果为 None，不作处理，默认为 None。
+    - **padding_idx** (int|long|None，可选) - padding_idx 需在区间  ``[-vocab_size, vocab_size)`` ，否则不生效， ``padding_idx < 0``  时，padding_idx 会被改成 ``vocab_size + padding_idx`` ，input 中等于 padding_index 的 id 对应的 embedding 信息会被设置为 0，且这部分填充数据在训练时将不会被更新。如果为 None，不作处理，默认为 None。
     - **is_test** (bool，可选) -  表示训练/预测模式。在预测模式(is_test=False)下，遇到不存在的特征，不会初始化及创建，直接以 0 填充后返回。默认值为 False。
     - **entry** (str，可选) - 准入策略配置，目前支持概率准入 ProbabilityEntry 和频次准入 CountFilterEntry。默认为 None。
     - **table_class** (str，可选) - 稀疏表的类型，其值可以为 CommonSparseTable 和 SSDSparseTable。默认为 CommonSparseTable。
-    - **param_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr`。此外，可以通过 ``param_attr`` 参数加载用户自定义或预训练的词向量。只需将本地词向量转为 numpy 数据格式，且保证本地词向量的 shape 和 embedding 的 ``size`` 参数一致，然后使用 :ref:`cn_api_paddle_to_tensor` 进行初始化，即可实现加载自定义或预训练的词向量。
+    - **param_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为 None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_paddle_ParamAttr`。此外，可以通过  ``param_attr``  参数加载用户自定义或预训练的词向量。只需将本地词向量转为 numpy 数据格式，且保证本地词向量的 shape 和 embedding 的  ``size``  参数一致，然后使用 :ref:`cn_api_paddle_to_tensor` 进行初始化，即可实现加载自定义或预训练的词向量。
     - **dtype** (str) - 输出 Tensor 的数据类型，数据类型必须为：float32 或 float64，默认为 float32。
 
 返回
diff --git a/docs/api/paddle/static/nn/spectral_norm_cn.rst b/docs/api/paddle/static/nn/spectral_norm_cn.rst
index ce69906e52d..dc43536e802 100644
--- a/docs/api/paddle/static/nn/spectral_norm_cn.rst
+++ b/docs/api/paddle/static/nn/spectral_norm_cn.rst
@@ -9,9 +9,9 @@ spectral_norm
 
 该 OP 用于计算了 fc、conv1d、conv2d、conv3d 层的权重参数的谱正则值，输入权重参数应分别为 2-D, 3-D, 4-D, 5-D Tensor，输出 Tensor 与输入 Tensor shape 相同。谱特征值计算方式如下。
 
-步骤 1：生成形状为[H]的向量 U，以及形状为[W]的向量 V，其中 H 是输入权重 Tensor 的第 ``dim`` 个维度，W 是剩余维度的乘积。
+步骤 1：生成形状为[H]的向量 U，以及形状为[W]的向量 V，其中 H 是输入权重 Tensor 的第  ``dim``  个维度，W 是剩余维度的乘积。
 
-步骤 2： ``power_iters`` 应该是一个正整数，用 U 和 V 迭代计算 ``power_iters`` 轮，迭代步骤如下。
+步骤 2：  ``power_iters``  应该是一个正整数，用 U 和 V 迭代计算  ``power_iters``  轮，迭代步骤如下。
 
 .. math::
 
@@ -32,13 +32,13 @@ spectral_norm
     - **weight** (Tensor) - spectral_norm 算子的输入权重 Tensor，可以是 2-D, 3-D, 4-D, 5-D Tensor，它是 fc、conv1d、conv2d、conv3d 层的权重，数据类型为 float32 或 float64。
     - **dim** (int，可选) - 将输入（weight）重塑为矩阵之前应排列到第一个的维度索引，如果 input（weight）是 fc 层的权重，则应设置为 0；如果 input（weight）是 conv 层的权重，则应设置为 1，默认为 0。
     - **power_iters** (int，可选) - 将用于计算 spectral norm 的功率迭代次数，默认值 1。
-    - **eps** (float，可选) - epsilon 用于保证计算规范中的数值稳定性，分母会加上 ``eps`` 防止除零，默认 1e-12。
+    - **eps** (float，可选) - epsilon 用于保证计算规范中的数值稳定性，分母会加上  ``eps``  防止除零，默认 1e-12。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
 
-    Tensor，谱正则化后权重 Tensor，维度和数据类型与输入 ``weight`` 一致。
+    Tensor，谱正则化后权重 Tensor，维度和数据类型与输入  ``weight``  一致。
 
 
 代码示例
diff --git a/docs/api/paddle/static/nn/static_pylayer_cn.rst b/docs/api/paddle/static/nn/static_pylayer_cn.rst
index 8854bcb143f..4f7b630633d 100644
--- a/docs/api/paddle/static/nn/static_pylayer_cn.rst
+++ b/docs/api/paddle/static/nn/static_pylayer_cn.rst
@@ -7,27 +7,27 @@ static_pylayer
 .. py:function:: paddle.static.nn.static_pylayer(forward_fn, inputs, backward_fn=None, name=None)
 
 
-该 API 返回 ``forward_fn(inputs)``，并且根据传入的 ``forward_fn`` 和 ``backward_fn`` 的执行逻辑创建两个 sub_block，
-同时创建 ``pylayer`` 算子，``pylayer`` 算子的属性储存创建的 sub_block ID。
+该 API 返回  ``forward_fn(inputs)`` ，并且根据传入的  ``forward_fn``  和  ``backward_fn``  的执行逻辑创建两个 sub_block，
+同时创建  ``pylayer``  算子， ``pylayer``  算子的属性储存创建的 sub_block ID。
 
-``forward_fn`` 和 ``backward_fn`` 需要返回同样嵌套结构（nest structure）的 Tensor。
+ ``forward_fn``  和  ``backward_fn``  需要返回同样嵌套结构（nest structure）的 Tensor。
 PaddlePaddle 里 Tensor 的嵌套结构是指一个 Tensor，或者 Tensor 的元组（tuple），或者 Tensor 的列表（list）。
 
 .. note::
-    1. 如果 ``backward_fn`` 不为 None，用户需要使 ``forward_fn`` 的输入 Tensor 的数量和 ``backward_fn`` 的输出 Tensor 的数量相同，``forward_fn`` 的输出 Tensor 的数量和 ``backward_fn`` 的输入 Tensor 的数量相同。
-    2. 在 ``backward_fn`` 被设置为 ``None`` 的情况下，``inputs`` 里所有 Variable 的 ``stop_gradient`` 属性应该被设为 ``True``，否则可能会在反向传播（backward propagation）中得到意想不到的结果。
+    1. 如果  ``backward_fn``  不为 None，用户需要使  ``forward_fn``  的输入 Tensor 的数量和  ``backward_fn``  的输出 Tensor 的数量相同， ``forward_fn``  的输出 Tensor 的数量和  ``backward_fn``  的输入 Tensor 的数量相同。
+    2. 在  ``backward_fn``  被设置为  ``None``  的情况下， ``inputs``  里所有 Variable 的  ``stop_gradient``  属性应该被设为  ``True`` ，否则可能会在反向传播（backward propagation）中得到意想不到的结果。
     3. 本 API 只能被运行在静态图模式下。
 
 参数
 :::::::::
     - **forward_fn** (callable) - 一个前向传播（forward propagation）时被调用的 callable。
-    - **inputs** (list[Variable]) - Variable 类型列表，其含义为 ``forward_fn`` 的输入 Variable。
-    - **backward_fn** (callable，可选) - 一个反向传播（backward propagation）时被调用的 callable。默认值：``None``，表示不需要进行反向传播（backward propagation）。
-    - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值：``None``。
+    - **inputs** (list[Variable]) - Variable 类型列表，其含义为  ``forward_fn``  的输入 Variable。
+    - **backward_fn** (callable，可选) - 一个反向传播（backward propagation）时被调用的 callable。默认值： ``None`` ，表示不需要进行反向传播（backward propagation）。
+    - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值： ``None`` 。
 
 返回
 :::::::::
-Variable|list(Variable)|tuple(Variable)，该 API 返回 ``forward_fn(inputs)``。
+Variable|list(Variable)|tuple(Variable)，该 API 返回  ``forward_fn(inputs)`` 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/static/nn/switch_case_cn.rst b/docs/api/paddle/static/nn/switch_case_cn.rst
index 14cd7bb1afe..660533a0c3f 100644
--- a/docs/api/paddle/static/nn/switch_case_cn.rst
+++ b/docs/api/paddle/static/nn/switch_case_cn.rst
@@ -12,8 +12,8 @@ switch_case
 参数
 ::::::::::::
 
-    - **branch_index** (Tensor) - 元素个数为 1 的 Tensor （ 0-D Tensor 或者形状为 [1] ），指定将要执行的分支。数据类型是 ``int32``, ``int64`` 或 ``uint8``。
-    - **branch_fns** (dict|list|tuple) - 如果 ``branch_fns`` 是一个 list 或 tuple，它的元素可以是 (int, callable) 二元组，即由整数和可调用对象构成的二元组，整数表示对应的可调用对象的键；也可以仅仅是可调用对象，它在 list 或者 tuple 中的实际索引值将作为该可调用对象的键。如果 ``branch_fns`` 是一个字典，那么它的键是整数，它的值是可调用对象。所有的可调用对象都返回相同结构的 Tensor。
+    - **branch_index** (Tensor) - 元素个数为 1 的 Tensor （ 0-D Tensor 或者形状为 [1] ），指定将要执行的分支。数据类型是  ``int32`` ,  ``int64``  或  ``uint8`` 。
+    - **branch_fns** (dict|list|tuple) - 如果  ``branch_fns``  是一个 list 或 tuple，它的元素可以是 (int, callable) 二元组，即由整数和可调用对象构成的二元组，整数表示对应的可调用对象的键；也可以仅仅是可调用对象，它在 list 或者 tuple 中的实际索引值将作为该可调用对象的键。如果  ``branch_fns``  是一个字典，那么它的键是整数，它的值是可调用对象。所有的可调用对象都返回相同结构的 Tensor。
     - **default** (callable，可选) - 可调用对象，返回一个或多个 Tensor。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
@@ -22,8 +22,8 @@ switch_case
 
 Tensor|list(Tensor)
 
-- 如果 ``branch_fns`` 中存在与 ``branch_index`` 匹配的可调用对象，则返回该可调用对象的返回结果；如果 ``branch_fns`` 中不存在与 ``branch_index`` 匹配的可调用对象且 ``default`` 不是 None，则返回调用 ``default`` 的返回结果；
-- 如果 ``branch_fns`` 中不存在与 ``branch_index`` 匹配的可调用对象且 ``default`` 是 None，则返回 ``branch_fns`` 中键值最大的可调用对象的返回结果。
+- 如果  ``branch_fns``  中存在与  ``branch_index``  匹配的可调用对象，则返回该可调用对象的返回结果；如果  ``branch_fns``  中不存在与  ``branch_index``  匹配的可调用对象且  ``default``  不是 None，则返回调用  ``default``  的返回结果；
+- 如果  ``branch_fns``  中不存在与  ``branch_index``  匹配的可调用对象且  ``default``  是 None，则返回  ``branch_fns``  中键值最大的可调用对象的返回结果。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/static/nn/while_loop_cn.rst b/docs/api/paddle/static/nn/while_loop_cn.rst
index 791f70976a2..24b0d781835 100644
--- a/docs/api/paddle/static/nn/while_loop_cn.rst
+++ b/docs/api/paddle/static/nn/while_loop_cn.rst
@@ -7,23 +7,23 @@ ____________________________________
 
 .. py:function:: paddle.static.nn.while_loop(cond, body, loop_vars, is_test=False, name=None)
 
-该 API 用于实现类似 while 的循环控制功能，只要循环条件 ``cond`` 的返回值为 True，``while_loop`` 则会循环执行循环体 ``body``，直到 ``cond`` 的返回值为 False。
+该 API 用于实现类似 while 的循环控制功能，只要循环条件  ``cond``  的返回值为 True， ``while_loop``  则会循环执行循环体  ``body`` ，直到  ``cond``  的返回值为 False。
 
 .. note::
-    ``body`` 中定义的局部变量无法使用 ``Executor`` 的 ``fetch_list`` 来获取的，变量需在 ``body`` 外定义并将其置于 ``loop_vars`` 中进行循环更新后才可通过 ``fetch_list`` 获取。
+     ``body``  中定义的局部变量无法使用  ``Executor``  的  ``fetch_list``  来获取的，变量需在  ``body``  外定义并将其置于  ``loop_vars``  中进行循环更新后才可通过  ``fetch_list``  获取。
 
 参数
 :::::::::
 
-    - **cond** (callable) - 返回 boolean 类型 Tensor 的可调用函数，用以判断循环是否继续执行。``cond`` 的参数和 ``loop_vars`` 相对应。
-    - **body** (callable) - 循环执行的结构体。其返回一个包含 tensor 或 DenseTensorArray 的列表或元组，且这些 tensor 或 DenseTensorArray 的长度，结构，类型和 ``loop_vars`` 中的相同。且``body`` 的参数与 ``loop_vars`` 相对应。
-    - **loop_vars** (list|tuple) - 包含 tensor 或 DenseTensorArray 的列表或是元组，将其传入至 ``cond`` 和 ``body`` 中，得到循环条件和输出值。
+    - **cond** (callable) - 返回 boolean 类型 Tensor 的可调用函数，用以判断循环是否继续执行。 ``cond``  的参数和  ``loop_vars``  相对应。
+    - **body** (callable) - 循环执行的结构体。其返回一个包含 tensor 或 DenseTensorArray 的列表或元组，且这些 tensor 或 DenseTensorArray 的长度，结构，类型和  ``loop_vars``  中的相同。且 ``body``  的参数与  ``loop_vars``  相对应。
+    - **loop_vars** (list|tuple) - 包含 tensor 或 DenseTensorArray 的列表或是元组，将其传入至  ``cond``  和  ``body``  中，得到循环条件和输出值。
     - **is_test** (bool，可选) - 用于表明是否在测试阶段执行，默认值为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-list|tuple，循环迭代之后 ``body`` 的返回值，和 ``loop_vars`` 具有相同的结构。
+list|tuple，循环迭代之后  ``body``  的返回值，和  ``loop_vars``  具有相同的结构。
 
 
 示例代码
diff --git a/docs/api/paddle/static/program_guard_cn.rst b/docs/api/paddle/static/program_guard_cn.rst
index 9ab667382c8..d4d99f4384b 100644
--- a/docs/api/paddle/static/program_guard_cn.rst
+++ b/docs/api/paddle/static/program_guard_cn.rst
@@ -9,15 +9,15 @@ program_guard
 
 
 
-配合使用 python 的 ``with`` 语句来将 ``with`` block 里的算子和变量添加进指定的全局主程序（main program）和启动程序（startup program）。
+配合使用 python 的  ``with``  语句来将  ``with``  block 里的算子和变量添加进指定的全局主程序（main program）和启动程序（startup program）。
 
-``with`` 语句块下的各接口将在新的 main program（主程序）中添加 operators（算子）和 Tensors。
+ ``with``  语句块下的各接口将在新的 main program（主程序）中添加 operators（算子）和 Tensors。
 
 参数
 ::::::::::::
 
-    - **main_program** (Program) – ``with`` 语句中将使用的新的 main program。
-    - **startup_program** (Program，可选) – ``with`` 语句中将使用的新的 startup program。若传入 ``None`` 则不改变当前的启动程序，即仍使用 default_startup_program。默认值为 None。
+    - **main_program** (Program) –  ``with``  语句中将使用的新的 main program。
+    - **startup_program** (Program，可选) –  ``with``  语句中将使用的新的 startup program。若传入  ``None``  则不改变当前的启动程序，即仍使用 default_startup_program。默认值为 None。
 
 代码示例 1
 ::::::::::::
diff --git a/docs/api/paddle/static/py_func_cn.rst b/docs/api/paddle/static/py_func_cn.rst
index 903ed39812a..2c58fcc4afa 100644
--- a/docs/api/paddle/static/py_func_cn.rst
+++ b/docs/api/paddle/static/py_func_cn.rst
@@ -11,27 +11,27 @@ py_func
 
 PaddlePaddle 通过 py_func 在 Python 端注册 OP。py_func 的设计原理在于 Paddle 中的 Tensor 与 numpy 数组可以方便的互相转换，从而可使用 Python 中的 numpy API 来自定义一个 Python OP。
 
-该自定义的 Python OP 的前向函数是 ``func``，反向函数是 ``backward_func`` 。 Paddle 将在前向部分调用 ``func``，并在反向部分调用 ``backward_func`` （如果 ``backward_func`` 不是 None)。 ``x`` 为 ``func`` 的输入，必须为 Tensor 类型；``out``  为 ``func`` 的输出，既可以是 Tensor 类型，也可以是 numpy 数组。
+该自定义的 Python OP 的前向函数是  ``func`` ，反向函数是  ``backward_func``  。 Paddle 将在前向部分调用  ``func`` ，并在反向部分调用  ``backward_func``  （如果  ``backward_func``  不是 None)。  ``x``  为  ``func``  的输入，必须为 Tensor 类型； ``out``   为  ``func``  的输出，既可以是 Tensor 类型，也可以是 numpy 数组。
 
-反向函数 ``backward_func`` 的输入依次为：前向输入 ``x`` 、前向输出 ``out`` 、 ``out`` 的梯度。如果 ``out`` 的某些输出没有梯度，则 ``backward_func`` 的相关输入为 None。如果 ``x`` 的某些变量没有梯度，则用户应在 ``backward_func`` 中主动返回 None。
+反向函数  ``backward_func``  的输入依次为：前向输入  ``x``  、前向输出  ``out``  、  ``out``  的梯度。如果  ``out``  的某些输出没有梯度，则  ``backward_func``  的相关输入为 None。如果  ``x``  的某些变量没有梯度，则用户应在  ``backward_func``  中主动返回 None。
 
-在调用该接口之前，还应正确设置 ``out`` 的数据类型和形状，而 ``out`` 和 ``x`` 对应梯度的数据类型和形状将自动推断而出。
+在调用该接口之前，还应正确设置  ``out``  的数据类型和形状，而  ``out``  和  ``x``  对应梯度的数据类型和形状将自动推断而出。
 
-此功能还可用于调试正在运行的网络，可以通过添加没有输出的 ``py_func`` 运算，并在 ``func`` 中打印输入 ``x`` 。
+此功能还可用于调试正在运行的网络，可以通过添加没有输出的  ``py_func``  运算，并在  ``func``  中打印输入  ``x``  。
 
 参数
 ::::::::::::
 
-    - **func** （callable） - 所注册的 Python OP 的前向函数，运行网络时，将根据该函数与前向输入 ``x``，计算前向输出 ``out``。在 ``func`` 建议先主动将 Tensor 转换为 numpy 数组，方便灵活的使用 numpy 相关的操作，如果未转换成 numpy，则可能某些操作无法兼容。
-    - **x** (Tensor|tuple(Tensor)|list[Tensor]) -  前向函数 ``func`` 的输入，多个 Tensor 以 tuple(Tensor)或 list[Tensor]的形式传入。
-    - **out** (T|tuple(T)|list[T]) -  前向函数 ``func`` 的输出，可以为 T|tuple(T)|list[T]，其中 T 既可以为 Tensor，也可以为 numpy 数组。由于 Paddle 无法自动推断 ``out`` 的形状和数据类型，必须应事先创建 ``out`` 。
-    - **backward_func** (callable，可选) - 所注册的 Python OP 的反向函数。默认值为 None，意味着没有反向计算。若不为 None，则会在运行网络反向时调用 ``backward_func`` 计算 ``x`` 的梯度。
-    - **skip_vars_in_backward_input** (Tensor，可选) -  ``backward_func`` 的输入中不需要的变量，可以是 Tensor|tuple(Tensor)|list[Tensor]。这些变量必须是 ``x`` 和 ``out`` 中的一个。默认值为 None，意味着没有变量需要从 ``x`` 和 ``out`` 中去除。若不为 None，则这些变量将不是 ``backward_func`` 的输入。该参数仅在 ``backward_func`` 不为 None 时有用。
+    - **func** （callable） - 所注册的 Python OP 的前向函数，运行网络时，将根据该函数与前向输入  ``x`` ，计算前向输出  ``out`` 。在  ``func``  建议先主动将 Tensor 转换为 numpy 数组，方便灵活的使用 numpy 相关的操作，如果未转换成 numpy，则可能某些操作无法兼容。
+    - **x** (Tensor|tuple(Tensor)|list[Tensor]) -  前向函数  ``func``  的输入，多个 Tensor 以 tuple(Tensor)或 list[Tensor]的形式传入。
+    - **out** (T|tuple(T)|list[T]) -  前向函数  ``func``  的输出，可以为 T|tuple(T)|list[T]，其中 T 既可以为 Tensor，也可以为 numpy 数组。由于 Paddle 无法自动推断  ``out``  的形状和数据类型，必须应事先创建  ``out``  。
+    - **backward_func** (callable，可选) - 所注册的 Python OP 的反向函数。默认值为 None，意味着没有反向计算。若不为 None，则会在运行网络反向时调用  ``backward_func``  计算  ``x``  的梯度。
+    - **skip_vars_in_backward_input** (Tensor，可选) -   ``backward_func``  的输入中不需要的变量，可以是 Tensor|tuple(Tensor)|list[Tensor]。这些变量必须是  ``x``  和  ``out``  中的一个。默认值为 None，意味着没有变量需要从  ``x``  和  ``out``  中去除。若不为 None，则这些变量将不是  ``backward_func``  的输入。该参数仅在  ``backward_func``  不为 None 时有用。
 
 返回
 ::::::::::::
 
-Tensor|tuple(Tensor)|list[Tensor]，前向函数的输出 ``out``
+Tensor|tuple(Tensor)|list[Tensor]，前向函数的输出  ``out`` 
 
 
 代码示例 1
diff --git a/docs/api/paddle/static/save_cn.rst b/docs/api/paddle/static/save_cn.rst
index 8a9479e090d..73fcfb84813 100644
--- a/docs/api/paddle/static/save_cn.rst
+++ b/docs/api/paddle/static/save_cn.rst
@@ -6,20 +6,20 @@ save
 .. py:function:: paddle.static.save(program, model_path, protocol=4, **configs)
 
 
-将传入的参数、优化器信息和网络描述保存到 ``model_path`` 。
+将传入的参数、优化器信息和网络描述保存到  ``model_path``  。
 
-参数包含所有的可训练 :ref:`cn_api_paddle_static_Variable`，将保存到后缀为 ``.pdparams`` 的文件中。
+参数包含所有的可训练 :ref:`cn_api_paddle_static_Variable`，将保存到后缀为  ``.pdparams``  的文件中。
 
 优化器信息包含优化器使用的所有 Tensor。对于 Adam 优化器，包含 beta1、beta2、momentum 等。
-所有信息将保存到后缀为 ``.pdopt`` 的文件中。（如果优化器没有需要保存的 Tensor（如 sgd），则不会生成）。
+所有信息将保存到后缀为  ``.pdopt``  的文件中。（如果优化器没有需要保存的 Tensor（如 sgd），则不会生成）。
 
-网络描述是程序的描述。它只用于部署。描述将保存到后缀为 ``.pdmodel`` 的文件中。
+网络描述是程序的描述。它只用于部署。描述将保存到后缀为  ``.pdmodel``  的文件中。
 
 参数
 ::::::::::::
 
  - **program**  ( :ref:`cn_api_paddle_static_Program` ) – 要保存的 Program。
- - **model_path**  (str) – 保存 program 的文件前缀。格式为 ``目录名称/文件前缀``。如果文件前缀为空字符串，会引发异常。
+ - **model_path**  (str) – 保存 program 的文件前缀。格式为  ``目录名称/文件前缀`` 。如果文件前缀为空字符串，会引发异常。
  - **protocol**  (int，可选) – pickle 模块的协议版本，默认值为 4，取值范围是[2,4]。
  - **\*\*configs**  (dict，可选) - 可选的关键字参数。
 
diff --git a/docs/api/paddle/static/save_inference_model_cn.rst b/docs/api/paddle/static/save_inference_model_cn.rst
index 5673eaf70fb..05e71a257df 100644
--- a/docs/api/paddle/static/save_inference_model_cn.rst
+++ b/docs/api/paddle/static/save_inference_model_cn.rst
@@ -9,7 +9,7 @@ save_inference_model
 
 
 
-将模型及其参数保存到指定的路径。例如，``path_prefix="PATH/modelname"``，在调用 ``save_inference_model(path_prefix, feed_vars, fetch_vars, executor)`` 之后，你可以在 ``PATH`` 目录下找到两个文件，分别是 ``modelname.pdmodel`` 和 ``modelname.pdiparams``，前者表示序列化之后的模型文件，后者表示序列化之后的参数文件。
+将模型及其参数保存到指定的路径。例如， ``path_prefix="PATH/modelname"`` ，在调用  ``save_inference_model(path_prefix, feed_vars, fetch_vars, executor)``  之后，你可以在  ``PATH``  目录下找到两个文件，分别是  ``modelname.pdmodel``  和  ``modelname.pdiparams`` ，前者表示序列化之后的模型文件，后者表示序列化之后的参数文件。
 
 
 参数
@@ -18,7 +18,7 @@ save_inference_model
   - **path_prefix** (str) – 要保存到的目录 + 模型名称（不包含后缀）。
   - **feed_vars** (Variable | list[Variable]) – 模型的所有输入变量。
   - **fetch_vars** (Variable | list[Variable]) – 模型的所有输出变量。
-  - **executor** (Executor) –  用于保存预测模型的 ``executor``，详见 :ref:`api_guide_executor` 。
+  - **executor** (Executor) –  用于保存预测模型的  ``executor`` ，详见 :ref:`api_guide_executor` 。
   - **kwargs** - 支持的 key 包括 'program'和 'clip_extra'。(注意：kwargs 主要是用来做反向兼容的)。
 
       - **program** - 指定想要序列化的 program，默认使用 default_main_program。
diff --git a/docs/api/paddle/static/scope_guard_cn.rst b/docs/api/paddle/static/scope_guard_cn.rst
index fb85952d2c2..5f0942efd06 100644
--- a/docs/api/paddle/static/scope_guard_cn.rst
+++ b/docs/api/paddle/static/scope_guard_cn.rst
@@ -10,11 +10,11 @@ scope_guard
 
 
 
-通过 python 的 ``with`` 语句切换作用域（scope）。
+通过 python 的  ``with``  语句切换作用域（scope）。
 作用域记录了变量名和变量 ( :ref:`api_guide_Variable` ) 之间的映射关系，类似于编程语言中的大括号。
 如果未调用此接口，所有的变量和变量名都会被记录在默认的全局作用域中。
 当用户需要创建同名的变量时，如果不希望同名的变量映射关系被覆盖，则需要通过该接口切换作用域。
-通过 ``with`` 语句切换后，``with`` 语句块中所有创建的变量都将分配给新的作用域。
+通过  ``with``  语句切换后， ``with``  语句块中所有创建的变量都将分配给新的作用域。
 
 参数
 ::::::::::::
diff --git a/docs/api/paddle/static/serialize_persistables_cn.rst b/docs/api/paddle/static/serialize_persistables_cn.rst
index 4b83344bfca..e46bb259993 100644
--- a/docs/api/paddle/static/serialize_persistables_cn.rst
+++ b/docs/api/paddle/static/serialize_persistables_cn.rst
@@ -16,7 +16,7 @@ serialize_persistables
 
   - **feed_vars** (Variable | list[Variable]) – 模型的输入变量。
   - **fetch_vars** (Variable | list[Variable]) – 模型的输出变量。
-  - **executor** (Executor) - 用于保存预测模型的 ``executor``，详见 :ref:`api_guide_executor` 。
+  - **executor** (Executor) - 用于保存预测模型的  ``executor`` ，详见 :ref:`api_guide_executor` 。
   - **kwargs** - 支持的 key 包括 program。(注意：kwargs 主要是用来做反向兼容的)。
 
       - **program** - 指定想要序列化的 program，默认使用 default_main_program。
diff --git a/docs/api/paddle/static/set_program_state_cn.rst b/docs/api/paddle/static/set_program_state_cn.rst
index 37aca5bb182..cff80f4d75a 100644
--- a/docs/api/paddle/static/set_program_state_cn.rst
+++ b/docs/api/paddle/static/set_program_state_cn.rst
@@ -6,7 +6,7 @@ set_program_state
 .. py:function:: paddle.static.set_program_state(program, state_dict)
 
 
-利用 ``state_dict`` 设置 ``Program`` 的参数和优化器信息。
+利用  ``state_dict``  设置  ``Program``  的参数和优化器信息。
 
 如果参数的 shape 或 dtype 不匹配，则会引发异常。
 
@@ -16,7 +16,7 @@ set_program_state
 参数
 ::::::::::::
 
-    - **program** (Program) - 需要被设置的 ``Program`` 。
+    - **program** (Program) - 需要被设置的  ``Program``  。
     - **state_dict** (dict) - 存储参数和优化器信息的 dict；dict 中 key 的类型为 Tensor 的名称，value 为 np.ndarray 类型的数据。
 
 返回
diff --git a/docs/api/paddle/static/xpu_places_cn.rst b/docs/api/paddle/static/xpu_places_cn.rst
index f913a47d0ed..baba183fbd6 100644
--- a/docs/api/paddle/static/xpu_places_cn.rst
+++ b/docs/api/paddle/static/xpu_places_cn.rst
@@ -9,22 +9,22 @@ xpu_places
 .. note::
     多卡任务请先使用 FLAGS_selected_xpus 环境变量设置可见的 XPU 设备，下个版本将会修正 XPU_VISIBLE_DEVICES 环境变量无效的问题。
 
-该接口根据 ``device_ids`` 创建一个或多个 ``paddle.XPUPlace`` 对象，并返回所创建的对象列表。
+该接口根据  ``device_ids``  创建一个或多个  ``paddle.XPUPlace``  对象，并返回所创建的对象列表。
 
-如果 ``device_ids`` 为 ``None``，则首先检查 ``FLAGS_selected_xpus`` 标志。
-例如：``FLAGS_selected_xpus=0,1,2``，则返回的列表将为 ``[paddle.XPUPlace(0), paddle.XPUPlace(1), paddle.XPUPlace(2)]``。
-如果未设置标志 ``FLAGS_selected_xpus``，则根据 ``XPU_VISIBLE_DEVICES`` 环境变量，返回所有可见的 XPU places。
+如果  ``device_ids``  为  ``None`` ，则首先检查  ``FLAGS_selected_xpus``  标志。
+例如： ``FLAGS_selected_xpus=0,1,2`` ，则返回的列表将为  ``[paddle.XPUPlace(0), paddle.XPUPlace(1), paddle.XPUPlace(2)]`` 。
+如果未设置标志  ``FLAGS_selected_xpus`` ，则根据  ``XPU_VISIBLE_DEVICES``  环境变量，返回所有可见的 XPU places。
 
-如果 ``device_ids`` 不是 ``None``，它应该是使用的 XPU 设备 ID 的列表或元组。
-例如：``device_id=[0,1,2]``，返回的列表将是 ``[paddle.XPUPlace(0), paddle.XPUPlace(1), paddle.XPUPlace(2)]``。
+如果  ``device_ids``  不是  ``None`` ，它应该是使用的 XPU 设备 ID 的列表或元组。
+例如： ``device_id=[0,1,2]`` ，返回的列表将是  ``[paddle.XPUPlace(0), paddle.XPUPlace(1), paddle.XPUPlace(2)]`` 。
 
 参数
 :::::::::
-  - **device_ids** (list(int)|tuple(int)，可选) - XPU 的设备 ID 列表或元组。默认值为 ``None``。
+  - **device_ids** (list(int)|tuple(int)，可选) - XPU 的设备 ID 列表或元组。默认值为  ``None`` 。
 
 返回
 :::::::::
-list[paddle.XPUPlace]，创建的 ``paddle.XPUPlace`` 列表。
+list[paddle.XPUPlace]，创建的  ``paddle.XPUPlace``  列表。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/std_cn.rst b/docs/api/paddle/std_cn.rst
index c0481cd8d64..23b1c50b114 100644
--- a/docs/api/paddle/std_cn.rst
+++ b/docs/api/paddle/std_cn.rst
@@ -5,19 +5,19 @@ std
 
 .. py:function:: paddle.std(x, axis=None, unbiased=True, keepdim=False, name=None)
 
-沿给定的轴 ``axis`` 计算 ``x`` 中元素的标准差。
+沿给定的轴  ``axis``  计算  ``x``  中元素的标准差。
 
 参数
 ::::::::::
     - **x** (Tensor) - 输入的 Tensor，数据类型为：float16、float32、float64。
-    - **axis** (int|list|tuple，可选) - 指定对 ``x`` 进行计算的轴。``axis`` 可以是 int、list(int)、tuple(int)。如果 ``axis`` 包含多个维度，则沿着 ``axis`` 中的所有轴进行计算。``axis`` 或者其中的元素值应该在范围[-D, D)内，D 是 ``x`` 的维度。如果 ``axis`` 或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果 ``axis`` 是 None，则对 ``x`` 的全部元素计算标准差。默认值为 None。
-    - **unbiased** (bool，可选) - 是否使用无偏估计来计算标准差。使用 :math:`N` 来代表在 axis 上的维度，如果 ``unbiased`` 为 True，则在计算中使用 :math:`N - 1` 作为除数。为 False 时将使用 :math:`N` 作为除数。默认值为 True。
-    - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如果 ``keepdim`` 为 True，则输出 Tensor 和 ``x`` 具有相同的维度(减少的维度除外，减少的维度的大小为 1)。否则，输出 Tensor 的形状会在 ``axis`` 上进行 squeeze 操作。默认值为 False。
+    - **axis** (int|list|tuple，可选) - 指定对  ``x``  进行计算的轴。 ``axis``  可以是 int、list(int)、tuple(int)。如果  ``axis``  包含多个维度，则沿着  ``axis``  中的所有轴进行计算。 ``axis``  或者其中的元素值应该在范围[-D, D)内，D 是  ``x``  的维度。如果  ``axis``  或者其中的元素值小于 0，则等价于 :math:`axis + D`。如果  ``axis``  是 None，则对  ``x``  的全部元素计算标准差。默认值为 None。
+    - **unbiased** (bool，可选) - 是否使用无偏估计来计算标准差。使用 :math:`N` 来代表在 axis 上的维度，如果  ``unbiased``  为 True，则在计算中使用 :math:`N - 1` 作为除数。为 False 时将使用 :math:`N` 作为除数。默认值为 True。
+    - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如果  ``keepdim``  为 True，则输出 Tensor 和  ``x``  具有相同的维度(减少的维度除外，减少的维度的大小为 1)。否则，输出 Tensor 的形状会在  ``axis``  上进行 squeeze 操作。默认值为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，沿着 ``axis`` 进行标准差计算的结果，数据类型和 ``x`` 相同。
+     ``Tensor`` ，沿着  ``axis``  进行标准差计算的结果，数据类型和  ``x``  相同。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/strided_slice_cn.rst b/docs/api/paddle/strided_slice_cn.rst
index 41a6676e702..5284532fe3f 100644
--- a/docs/api/paddle/strided_slice_cn.rst
+++ b/docs/api/paddle/strided_slice_cn.rst
@@ -8,7 +8,7 @@ strided_slice
 
 strided_slice 算子。
 
-沿多个轴生成 ``x`` 的切片，与 numpy 类似：https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html。该 OP 使用 ``axes`` 、 ``starts`` 和 ``ends`` 属性来指定轴列表中每个轴的起点和终点位置，并使用此信息来对 ``x`` 切片。如果向 ``starts`` 或 ``ends`` 传递负值如 :math:`-i`，则表示该轴的反向第 :math:`i-1` 个位置（这里以 0 为初始位置）， ``strides`` 表示切片的步长，``strides`` 如果为负数，则按照反方向进行切片。如果传递给 ``starts`` 或 ``ends`` 的值大于 n（维度中的元素数目），则表示 n。当切片一个未知数量的维度时，建议传入 ``INT_MAX``。 ``axes`` 、 ``starts`` 和 ``ends`` 以及 ``strides`` 四个参数的元素数目必须相等。以下示例将解释切片如何工作：
+沿多个轴生成  ``x``  的切片，与 numpy 类似：https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html。该 OP 使用  ``axes``  、  ``starts``  和  ``ends``  属性来指定轴列表中每个轴的起点和终点位置，并使用此信息来对  ``x``  切片。如果向  ``starts``  或  ``ends``  传递负值如 :math:`-i`，则表示该轴的反向第 :math:`i-1` 个位置（这里以 0 为初始位置），  ``strides``  表示切片的步长， ``strides``  如果为负数，则按照反方向进行切片。如果传递给  ``starts``  或  ``ends``  的值大于 n（维度中的元素数目），则表示 n。当切片一个未知数量的维度时，建议传入  ``INT_MAX`` 。  ``axes``  、  ``starts``  和  ``ends``  以及  ``strides``  四个参数的元素数目必须相等。以下示例将解释切片如何工作：
 
 ::
 
@@ -48,16 +48,16 @@ strided_slice 算子。
 ::::::::::::
 
 
-        - **x** （Tensor）- 多维 ``Tensor``，数据类型为 ``bool``, ``float32``，``float64``，``int32``，或 ``int64``。
-        - **axes** （list|tuple）- 数据类型是 ``int32``。表示进行切片的轴。
-        - **starts** （list|tuple|Tensor）- 数据类型是 ``int32``。如果 ``starts`` 的类型是 list 或 tuple，它的元素可以是整数或者形状为[]的 ``0-D Tensor``。如果 ``starts`` 的类型是 ``Tensor``，则是 1-D ``Tensor``。表示在各个轴上切片的起始索引值。
-        - **ends** （list|tuple|Tensor）- 数据类型是 ``int32``。如果 ``ends`` 的类型是 list 或 tuple，它的元素可以是整数或者形状为[]的 ``0-D Tensor``。如果 ``ends`` 的类型是 ``Tensor``，则是 1-D ``Tensor``。表示在各个轴上切片的结束索引值。
-        - **strides** （list|tuple|Tensor）- 数据类型是 ``int32``。如果 ``strides`` 的类型是 list 或 tuple，它的元素可以是整数或者形状为[]的 ``0-D Tensor``。如果 ``strides`` 的类型是 ``Tensor``，则是 1-D ``Tensor``。表示在各个轴上切片的步长。
+        - **x** （Tensor）- 多维  ``Tensor`` ，数据类型为  ``bool`` ,  ``float32`` ， ``float64`` ， ``int32`` ，或  ``int64`` 。
+        - **axes** （list|tuple）- 数据类型是  ``int32`` 。表示进行切片的轴。
+        - **starts** （list|tuple|Tensor）- 数据类型是  ``int32`` 。如果  ``starts``  的类型是 list 或 tuple，它的元素可以是整数或者形状为[]的  ``0-D Tensor`` 。如果  ``starts``  的类型是  ``Tensor`` ，则是 1-D  ``Tensor`` 。表示在各个轴上切片的起始索引值。
+        - **ends** （list|tuple|Tensor）- 数据类型是  ``int32`` 。如果  ``ends``  的类型是 list 或 tuple，它的元素可以是整数或者形状为[]的  ``0-D Tensor`` 。如果  ``ends``  的类型是  ``Tensor`` ，则是 1-D  ``Tensor`` 。表示在各个轴上切片的结束索引值。
+        - **strides** （list|tuple|Tensor）- 数据类型是  ``int32`` 。如果  ``strides``  的类型是 list 或 tuple，它的元素可以是整数或者形状为[]的  ``0-D Tensor`` 。如果  ``strides``  的类型是  ``Tensor`` ，则是 1-D  ``Tensor`` 。表示在各个轴上切片的步长。
         - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
-多维 ``Tensor``，数据类型与 ``x`` 相同。
+多维  ``Tensor`` ，数据类型与  ``x``  相同。
 
 
 代码示例
diff --git a/docs/api/paddle/subtract_cn.rst b/docs/api/paddle/subtract_cn.rst
index 774203fe0f1..eaeb3cee941 100644
--- a/docs/api/paddle/subtract_cn.rst
+++ b/docs/api/paddle/subtract_cn.rst
@@ -6,7 +6,7 @@ subtract
 .. py:function:: paddle.subtract(x, y, name=None)
 
 
-逐元素相减算子，输入 ``x`` 与输入 ``y`` 逐元素相减，并将各个位置的输出元素保存到返回结果中。
+逐元素相减算子，输入  ``x``  与输入  ``y``  逐元素相减，并将各个位置的输出元素保存到返回结果中。
 
 等式是：
 
@@ -14,19 +14,19 @@ subtract
         out = x - y
 
 .. note::
-   ``paddle.subtract`` 遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
+    ``paddle.subtract``  遵守 broadcasting，如您想了解更多，请参见 `Tensor 介绍`_ .
 
    .. _Tensor 介绍: ../../guides/beginner/tensor_cn.html#id7
 
 参数
 :::::::::
-   - **x** (Tensor) - 输入的 Tensor。数据类型为 ``bfloat16`` 、 ``float16`` 、 ``float32`` 、 ``float64``、 ``int16`` 、 ``int32`` 、 ``int64`` 、 ``complex64`` 或  ``complex128`` 。
-   - **y** (Tensor) - 输入的 Tensor。数据类型为 ``bfloat16`` 、 ``float16`` 、 ``float32`` 、 ``float64``、 ``int16`` 、 ``int32`` 、 ``int64`` 、 ``complex64`` 或  ``complex128`` 。
+   - **x** (Tensor) - 输入的 Tensor。数据类型为  ``bfloat16``  、  ``float16``  、  ``float32``  、  ``float64`` 、  ``int16``  、  ``int32``  、  ``int64``  、  ``complex64``  或   ``complex128``  。
+   - **y** (Tensor) - 输入的 Tensor。数据类型为  ``bfloat16``  、  ``float16``  、  ``float32``  、  ``float64`` 、  ``int16``  、  ``int32``  、  ``int64``  、  ``complex64``  或   ``complex128``  。
    - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-   ``Tensor``，存储运算后的结果。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
+    ``Tensor`` ，存储运算后的结果。如果 x 和 y 有不同的 shape 且是可以广播的，返回 Tensor 的 shape 是 x 和 y 经过广播后的 shape。如果 x 和 y 有相同的 shape，返回 Tensor 的 shape 与 x，y 相同。
 
 
 代码示例
diff --git a/docs/api/paddle/sum_cn.rst b/docs/api/paddle/sum_cn.rst
index a603e8dddd0..e3eb9b984cd 100644
--- a/docs/api/paddle/sum_cn.rst
+++ b/docs/api/paddle/sum_cn.rst
@@ -8,23 +8,23 @@ sum
 对指定维度上的 Tensor 元素进行求和运算，并输出相应的计算结果。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x`` 和 ``dim`` 可替代 ``axis``，如 ``input=tensor_x`` 等价于 ``x=tensor_x`` 和 ``dim=1`` 等价于 ``axis=1``。
-    参数顺序支持：传递位置参数时，可以支持交换 dtype 和轴的位置顺序。如 ``paddle.sum(x, axis, keepdim, dtype)`` 等价于 ``paddle.sum(x, axis, dtype, keepdim)``。
+    别名支持: 参数名  ``input``  可替代  ``x``  和  ``dim``  可替代  ``axis`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x``  和  ``dim=1``  等价于  ``axis=1`` 。
+    参数顺序支持：传递位置参数时，可以支持交换 dtype 和轴的位置顺序。如  ``paddle.sum(x, axis, keepdim, dtype)``  等价于  ``paddle.sum(x, axis, dtype, keepdim)`` 。
 
 参数
 ::::::::::::
 
     - **x** (Tensor) - 输入变量为多维 Tensor，支持数据类型为 bool、bfloat16、float16、float32、float64、uint8、int8、int16、int32、int64、complex64、complex128。
-      别名： ``input``
+      别名：  ``input`` 
     - **axis** (int|list|tuple，可选) - 求和运算的维度。如果为 None，则计算所有元素的和并返回包含单个元素的 Tensor 变量，否则必须在 :math:`[−rank(x),rank(x)]` 范围内。如果 :math:`axis [i] <0`，则维度将变为 :math:`rank+axis[i]`，默认值为 None。
-      别名： ``dim``
+      别名：  ``dim`` 
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出变量的数据类型。若参数为空，则输出变量的数据类型和输入变量相同，默认值为 None。
     - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减小的维度。如 keepdim 为 true，否则结果 Tensor 的维度将比输入 Tensor 小，默认值为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 返回
 ::::::::::::
 
-  ``Tensor``，在指定维度上进行求和运算的 Tensor。如果输入的数据类型为 `bool` 或 `int32`， 则返回的数据类型为 `int64` 。除此之外返回的数据类型和输入的数据类型一致。
+   ``Tensor`` ，在指定维度上进行求和运算的 Tensor。如果输入的数据类型为 `bool` 或 `int32`， 则返回的数据类型为 `int64` 。除此之外返回的数据类型和输入的数据类型一致。
 
 
 代码示例
diff --git a/docs/api/paddle/summary_cn.rst b/docs/api/paddle/summary_cn.rst
index c28d4987bc4..89b0d93f943 100644
--- a/docs/api/paddle/summary_cn.rst
+++ b/docs/api/paddle/summary_cn.rst
@@ -5,15 +5,15 @@ summary
 
 .. py:function:: paddle.summary(net, input_size=None, dtypes=None, input=None)
 
-通过 ``input_size`` 或 ``input`` 打印网络 ``net`` 的基础结构和参数信息。``input_size`` 指定网络 ``net`` 输入 Tensor 的大小，而 ``input`` 指定网络 ``net`` 的输入 Tensor；如果给出 ``input``，那么 ``input_size`` 和 ``dtypes`` 的输入将被忽略。
+通过  ``input_size``  或  ``input``  打印网络  ``net``  的基础结构和参数信息。 ``input_size``  指定网络  ``net``  输入 Tensor 的大小，而  ``input``  指定网络  ``net``  的输入 Tensor；如果给出  ``input`` ，那么  ``input_size``  和  ``dtypes``  的输入将被忽略。
 
 
 参数
 :::::::::
-  - **net** (Layer) - 网络实例，必须是 ``Layer`` 的子类。
+  - **net** (Layer) - 网络实例，必须是  ``Layer``  的子类。
   - **input_size** (tuple|InputSpec|list[tuple|InputSpec，可选) - 输入 Tensor 的大小。如果网络只有一个输入，那么该值需要设定为 tuple 或 InputSpec。如果模型有多个输入。那么该值需要设定为 list[tuple|InputSpec]，包含每个输入的 shape。默认值：None。
-  - **dtypes** (str，可选) - 输入 Tensor 的数据类型，如果没有给定，默认使用 ``float32`` 类型。默认值：None。
-  - **input** (tensor，可选) - 输入的 Tensor，如果给出 ``input``，那么 ``input_size`` 和 ``dtypes`` 的输入将被忽略。默认值：None。
+  - **dtypes** (str，可选) - 输入 Tensor 的数据类型，如果没有给定，默认使用  ``float32``  类型。默认值：None。
+  - **input** (tensor，可选) - 输入的 Tensor，如果给出  ``input`` ，那么  ``input_size``  和  ``dtypes``  的输入将被忽略。默认值：None。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/swapaxes_cn.rst b/docs/api/paddle/swapaxes_cn.rst
index c69ce8f6771..cb4237fbe26 100644
--- a/docs/api/paddle/swapaxes_cn.rst
+++ b/docs/api/paddle/swapaxes_cn.rst
@@ -5,4 +5,4 @@ swapaxes
 
 .. py:function:: paddle.swapaxes(x, perm, name=None)
 
-``transpose`` 的别名，请参考 :ref:`cn_api_paddle_transpose`。
+ ``transpose``  的别名，请参考 :ref:`cn_api_paddle_transpose`。
diff --git a/docs/api/paddle/swapdims_cn.rst b/docs/api/paddle/swapdims_cn.rst
index 2ab761693d1..97d7867727c 100644
--- a/docs/api/paddle/swapdims_cn.rst
+++ b/docs/api/paddle/swapdims_cn.rst
@@ -5,4 +5,4 @@ swapdims
 
 .. py:function:: paddle.swapdims(x, perm, name=None)
 
-``transpose`` 的别名，请参考 :ref:`cn_api_paddle_transpose`。
+ ``transpose``  的别名，请参考 :ref:`cn_api_paddle_transpose`。
diff --git a/docs/api/paddle/take_along_axis_cn.rst b/docs/api/paddle/take_along_axis_cn.rst
index 70dc8e9288a..c31553d1b25 100644
--- a/docs/api/paddle/take_along_axis_cn.rst
+++ b/docs/api/paddle/take_along_axis_cn.rst
@@ -8,22 +8,22 @@ take_along_axis
 基于输入索引矩阵，沿着指定 axis 从 arr 矩阵里选取 1d 切片。索引矩阵必须和 arr 矩阵有相同的维度，需要能够 broadcast 与 arr 矩阵对齐。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``arr`` 和 ``dim`` 可替代 ``axis``，如 ``input=tensor_arr`` 等价于 ``arr=tensor_arr``， ``dim=1`` 等价于 ``axis=1``。
+    别名支持: 参数名  ``input``  可替代  ``arr``  和  ``dim``  可替代  ``axis`` ，如  ``input=tensor_arr``  等价于  ``arr=tensor_arr`` ，  ``dim=1``  等价于  ``axis=1`` 。
 
 参数
 :::::::::
 
     - **arr**  (Tensor) - 输入的 Tensor 作为源矩阵，数据类型为：bfloat16、float16、float32、float64、int32、int64、uint8、int16。
-      别名： ``input``
-    - **indices**  (Tensor) - 索引矩阵，包含沿轴提取 1d 切片的下标，必须和 arr 矩阵有相同的维度，当 ``broadcast`` 为 ``True`` 时，需要能够 broadcast 与 arr 矩阵对齐，否则除 ``axis`` 维度，其他维度都需要小于等于 ``arr`` 的对应维度，数据类型为：int32、int64。
+      别名：  ``input`` 
+    - **indices**  (Tensor) - 索引矩阵，包含沿轴提取 1d 切片的下标，必须和 arr 矩阵有相同的维度，当  ``broadcast``  为  ``True``  时，需要能够 broadcast 与 arr 矩阵对齐，否则除  ``axis``  维度，其他维度都需要小于等于  ``arr``  的对应维度，数据类型为：int32、int64。
     - **axis**  (int) - 指定沿着哪个维度获取对应的值，数据类型为：int。
-      别名： ``dim``
-    - **broadcast** (bool，可选) - 是否广播 ``index`` 矩阵，默认为 ``True``。
+      别名：  ``dim`` 
+    - **broadcast** (bool，可选) - 是否广播  ``index``  矩阵，默认为  ``True`` 。
 
 返回
 :::::::::
 
-输出 Tensor，包含 indeces 矩阵选定的元素，与 ``arr`` 数据类型相同。
+输出 Tensor，包含 indeces 矩阵选定的元素，与  ``arr``  数据类型相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/take_along_dim_cn.rst b/docs/api/paddle/take_along_dim_cn.rst
index 4c10d41af2d..9eec4a5ec05 100644
--- a/docs/api/paddle/take_along_dim_cn.rst
+++ b/docs/api/paddle/take_along_dim_cn.rst
@@ -5,4 +5,4 @@ take_along_dim
 
 .. py:function:: paddle.take_along_dim(arr, indices, axis, broadcast=True, *, out=None)
 
-``take_along_axis`` 的别名，请参考 :ref:`cn_api_paddle_take_along_axis`。
+ ``take_along_axis``  的别名，请参考 :ref:`cn_api_paddle_take_along_axis`。
diff --git a/docs/api/paddle/take_cn.rst b/docs/api/paddle/take_cn.rst
index 02c3739960c..c73e687af6e 100644
--- a/docs/api/paddle/take_cn.rst
+++ b/docs/api/paddle/take_cn.rst
@@ -13,11 +13,11 @@ take
 
     - **x**  (Tensor) - 输入的 Tensor，支持 int32、int64、float32、float64 数据类型。
     - **index**  (Tensor) - 索引矩阵，支持 int32、int64 数据类型。
-    - **mode**  (str，可选) - 索引越界处理，可选 ``'raise'``，``'wrap'``，``'clip'``，默认为 ``'raise'``。
+    - **mode**  (str，可选) - 索引越界处理，可选  ``'raise'`` ， ``'wrap'`` ， ``'clip'`` ，默认为  ``'raise'`` 。
 
-        - ``raise``：直接抛出错误；
-        - ``wrap``：通过取余数来约束超出范围的索引；
-        - ``clip``：将超出范围的索引剪裁到允许的最小（大）范围。此模式意味着所有超出范围的索引都将被最后一个元素的索引替换，而且将禁用负值索引。
+        -  ``raise`` ：直接抛出错误；
+        -  ``wrap`` ：通过取余数来约束超出范围的索引；
+        -  ``clip`` ：将超出范围的索引剪裁到允许的最小（大）范围。此模式意味着所有超出范围的索引都将被最后一个元素的索引替换，而且将禁用负值索引。
 
     - **name**  (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/tensor_cn.rst b/docs/api/paddle/tensor_cn.rst
index 374842000ad..0e753d8597c 100644
--- a/docs/api/paddle/tensor_cn.rst
+++ b/docs/api/paddle/tensor_cn.rst
@@ -6,10 +6,10 @@ tensor
 
 .. py:function:: paddle.tensor(data, dtype=None, device=None, requires_grad=False, pin_memory=False)
 
-通过已知的 ``data`` 来创建一个 Tensor，Tensor 类型为 ``paddle.Tensor``。
-``data`` 可以是 scalar，tuple，list，numpy\.ndarray，paddle\.Tensor。
+通过已知的  ``data``  来创建一个 Tensor，Tensor 类型为  ``paddle.Tensor`` 。
+ ``data``  可以是 scalar，tuple，list，numpy\.ndarray，paddle\.Tensor。
 
-如果 ``data`` 已经是一个 Tensor，且 ``dtype`` 、 ``device`` 没有发生变化，将不会发生 Tensor 的拷贝并返回原来的 Tensor。
+如果  ``data``  已经是一个 Tensor，且  ``dtype``  、  ``device``  没有发生变化，将不会发生 Tensor 的拷贝并返回原来的 Tensor。
 否则会创建一个新的 Tensor，且不保留原来计算图。
 
 .. code-block:: text
@@ -27,22 +27,22 @@ tensor
 
 .. note::
 
-  ``paddle.tensor`` 在功能和参数上与 ``torch.tensor`` 对齐。
-  与 ``paddle.to_tensor`` 的区别在于两者的参数名称不同， ``paddle.tensor`` 还额外支持了 ``pin_memory`` 功能。
+   ``paddle.tensor``  在功能和参数上与  ``torch.tensor``  对齐。
+  与  ``paddle.to_tensor``  的区别在于两者的参数名称不同，  ``paddle.tensor``  还额外支持了  ``pin_memory``  功能。
 
 参数
 :::::::::
 
     - **data** (scalar|tuple|list|ndarray|Tensor) - 初始化 Tensor 的数据，可以是 scalar，list，tuple，numpy\.ndarray，paddle\.Tensor 类型。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 创建 Tensor 的数据类型，可以是 bool、float16、float32、float64、int8、int16、int32、int64、uint8、complex64、complex128。
-      默认值为 None，如果 ``data`` 为 python 浮点类型，则从 :ref:`cn_api_paddle_get_default_dtype` 获取类型，如果 ``data`` 为其他类型，则会自动推导类型。
+      默认值为 None，如果  ``data``  为 python 浮点类型，则从 :ref:`cn_api_paddle_get_default_dtype` 获取类型，如果  ``data``  为其他类型，则会自动推导类型。
     - **device** (CPUPlace|CUDAPinnedPlace|CUDAPlace，可选) - 创建 tensor 的设备位置，可以是 CPUPlace、CUDAPinnedPlace、CUDAPlace。默认值为 None，使用全局的 place。
     - **requires_grad** (bool，可选) - 是否阻断 Autograd 的梯度传导。默认值为 False，此时不进行梯度传传导。
     - **pin_memory** (bool，可选) - 是否将当前 Tensor 的拷贝到固定内存上， 如果当前 Tensor 已经在固定内存上，则不会发生任何拷贝。默认值为 False。
 
 返回
 :::::::::
-通过 ``data`` 创建的 Tensor。
+通过  ``data``  创建的 Tensor。
 
 
 代码示例
diff --git a/docs/api/paddle/tensor_split_cn.rst b/docs/api/paddle/tensor_split_cn.rst
index cb35471eaf8..4feb4f87221 100644
--- a/docs/api/paddle/tensor_split_cn.rst
+++ b/docs/api/paddle/tensor_split_cn.rst
@@ -7,9 +7,9 @@ tensor_split
 
 
 
-将输入 Tensor 沿着轴 ``axis`` 分割成多个子 Tensor，允许进行不等长地分割。
+将输入 Tensor 沿着轴  ``axis``  分割成多个子 Tensor，允许进行不等长地分割。
 
-如下图，Tenser ``x`` 的 shape 为[6]，经过 ``paddle.tensor_split(x, num_or_indices=4)`` 变换后，得到 ``out0``，``out1``，``out2``，``out3`` 四个子 Tensor :
+如下图，Tenser  ``x``  的 shape 为[6]，经过  ``paddle.tensor_split(x, num_or_indices=4)``  变换后，得到  ``out0`` ， ``out1`` ， ``out2`` ， ``out3``  四个子 Tensor :
 
 .. image:: ../../images/api_legend/tensor_split/tensor_split-1.png
    :alt: 图例-不能被整除的情况
@@ -19,11 +19,11 @@ tensor_split
 参数
 :::::::::
        - **x** (Tensor) - 输入变量，数据类型为 bool、bfloat16、float16、float32、float64、uint8、int8、int32、int64 的多维 Tensor，其维度必须大于 0。
-         别名： ``input``
-       - **num_or_indices** (int|list|tuple) - 如果 ``num_or_indices`` 是一个整数 ``n`` ，则 ``x`` 沿 ``axis`` 拆分为 ``n`` 部分。如果 ``x`` 可被 ``n`` 整除，则每个部分都是 ``x.shape[axis]/n`` 。如果 ``x`` 不能被 ``n`` 整除，则前 ``int(x.shape[axis]%n)`` 个部分的大小将是 ``int(x.shape[axis]/n)+1`` ，其余部分的大小将是 ``int(x.shape[axis]/n)`` 。如果 ``num_or_indices`` 是整数索引的列表或元组，则在每个索引处沿 ``axis`` 分割 ``x`` 。例如， ``num_or_indices=[2, 4]`` 在 ``axis=0`` 时将沿轴 0 将 ``x`` 拆分为 ``x[：2]`` 、 ``x[2:4]`` 和 ``x[4:]`` 。
-         别名： ``indices`` （类型为 list 或 tuple 时） 或 ``sections`` （类型为 int 时）
-       - **axis** (int|Tensor，可选) - 整数或者形状为[]的 0-D Tensor，数据类型为 int32 或 int64。表示需要分割的维度。如果 ``axis < 0``，则划分的维度为 ``rank(x) + axis`` 。默认值为 0。
-         别名： ``dim``
+         别名：  ``input`` 
+       - **num_or_indices** (int|list|tuple) - 如果  ``num_or_indices``  是一个整数  ``n``  ，则  ``x``  沿  ``axis``  拆分为  ``n``  部分。如果  ``x``  可被  ``n``  整除，则每个部分都是  ``x.shape[axis]/n``  。如果  ``x``  不能被  ``n``  整除，则前  ``int(x.shape[axis]%n)``  个部分的大小将是  ``int(x.shape[axis]/n)+1``  ，其余部分的大小将是  ``int(x.shape[axis]/n)``  。如果  ``num_or_indices``  是整数索引的列表或元组，则在每个索引处沿  ``axis``  分割  ``x``  。例如，  ``num_or_indices=[2, 4]``  在  ``axis=0``  时将沿轴 0 将  ``x``  拆分为  ``x[：2]``  、  ``x[2:4]``  和  ``x[4:]``  。
+         别名：  ``indices``  （类型为 list 或 tuple 时） 或  ``sections``  （类型为 int 时）
+       - **axis** (int|Tensor，可选) - 整数或者形状为[]的 0-D Tensor，数据类型为 int32 或 int64。表示需要分割的维度。如果  ``axis < 0`` ，则划分的维度为  ``rank(x) + axis``  。默认值为 0。
+         别名：  ``dim`` 
        - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/tensordot_cn.rst b/docs/api/paddle/tensordot_cn.rst
index da2ddb2dcb6..2cbde5f835c 100644
--- a/docs/api/paddle/tensordot_cn.rst
+++ b/docs/api/paddle/tensordot_cn.rst
@@ -10,8 +10,8 @@ Tensor 缩并运算（Tensor Contraction），即沿着 axes 给定的多个轴
 **图解说明**
 
 可以选择沿一个或多个轴进行点积操作，操作后返回的结果张量维度是 a 和 b 上未参与点积的维度的并集。
-图例中展示了一个 shape = [2,2,2]的 ``a`` 张量，和 shape = [2,3]的 ``b`` 张量。
-shape = [2,2,3]的 ``res`` 张量为 a,b 两个张量沿着 a 张量的最后一个轴和 b 张量的第一个轴进行缩并的结果（即参数 ``axes = 1`` 的情况）
+图例中展示了一个 shape = [2,2,2]的  ``a``  张量，和 shape = [2,3]的  ``b``  张量。
+shape = [2,2,3]的  ``res``  张量为 a,b 两个张量沿着 a 张量的最后一个轴和 b 张量的第一个轴进行缩并的结果（即参数  ``axes = 1``  的情况）
 
 .. image:: ../../images/api_legend/tensordot.png
    :width: 500
@@ -20,27 +20,27 @@ shape = [2,2,3]的 ``res`` 张量为 a,b 两个张量沿着 a 张量的最后一
 参数
 ::::::::::::
 
-    - **x** （Tensor）- 缩并运算操作的左 Tensor，数据类型为 ``float16`` 或 ``float32`` 或 ``float64``。
-    - **y** （Tensor）- 缩并运算操作的右 Tensor，与 ``x`` 具有相同的数据类型。
-    - **axes** （int|tuple|list|Tensor）- 指定对 ``x`` 和 ``y`` 做缩并运算的轴，默认值为整数 2。
+    - **x** （Tensor）- 缩并运算操作的左 Tensor，数据类型为  ``float16``  或  ``float32``  或  ``float64`` 。
+    - **y** （Tensor）- 缩并运算操作的右 Tensor，与  ``x``  具有相同的数据类型。
+    - **axes** （int|tuple|list|Tensor）- 指定对  ``x``  和  ``y``  做缩并运算的轴，默认值为整数 2。
 
-        1. ``axes`` 可以是一个非负整数。若输入的是一个整数 ``n``，则表示对 ``x`` 的后 ``n`` 个轴和对 ``y`` 的前 ``n`` 个轴进行缩并运算。
+        1.  ``axes``  可以是一个非负整数。若输入的是一个整数  ``n`` ，则表示对  ``x``  的后  ``n``  个轴和对  ``y``  的前  ``n``  个轴进行缩并运算。
 
-        2. ``axes`` 可以是一个一维的整数 tuple 或 list，表示 ``x`` 和 ``y`` 沿着相同的轴方向进行缩并运算。例如，``axes`` =[0, 1]表示 ``x`` 的前两个轴和 ``y`` 的前两个轴对应进行缩并运算。
+        2.  ``axes``  可以是一个一维的整数 tuple 或 list，表示  ``x``  和  ``y``  沿着相同的轴方向进行缩并运算。例如， ``axes``  =[0, 1]表示  ``x``  的前两个轴和  ``y``  的前两个轴对应进行缩并运算。
 
-        3. ``axes`` 可以是一个 tuple 或 list，其中包含一个或两个一维的整数 tuple|list|Tensor。如果 ``axes`` 包含一个 tuple|list|Tensor，则对 ``x`` 和 ``y`` 的相同轴做缩并运算，具体轴下标由该 tuple|list|Tensor 中的整数值指定。如果 ``axes`` 包含两个 tuple|list|Tensor，则第一个指定 ``x`` 做缩并运算的轴下标，第二个指定 ``y`` 的对应轴下标。如果 ``axes`` 包含两个以上的 tuple|list|Tensor，只有前两个会被作为轴下标序列使用，其它的将被忽略。
+        3.  ``axes``  可以是一个 tuple 或 list，其中包含一个或两个一维的整数 tuple|list|Tensor。如果  ``axes``  包含一个 tuple|list|Tensor，则对  ``x``  和  ``y``  的相同轴做缩并运算，具体轴下标由该 tuple|list|Tensor 中的整数值指定。如果  ``axes``  包含两个 tuple|list|Tensor，则第一个指定  ``x``  做缩并运算的轴下标，第二个指定  ``y``  的对应轴下标。如果  ``axes``  包含两个以上的 tuple|list|Tensor，只有前两个会被作为轴下标序列使用，其它的将被忽略。
 
-        4. ``axes`` 可以是一个 Tensor，这种情况下该 Tensor 会被转换成 list，然后应用前述规则确定做缩并运算的轴。请注意，输入 Tensor 类型的 ``axes`` 只在动态图模式下可用。
+        4.  ``axes``  可以是一个 Tensor，这种情况下该 Tensor 会被转换成 list，然后应用前述规则确定做缩并运算的轴。请注意，输入 Tensor 类型的  ``axes``  只在动态图模式下可用。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
-一个 ``Tensor``，表示 Tensor 缩并的结果，数据类型与 ``x`` 和 ``y`` 相同。一般情况下，有 :math:`output.ndim = x.ndim + y.ndim - 2 \times n_{axes}`，其中 :math:`n_{axes}` 表示做 Tensor 缩并的轴数量。
+一个  ``Tensor`` ，表示 Tensor 缩并的结果，数据类型与  ``x``  和  ``y``  相同。一般情况下，有 :math:`output.ndim = x.ndim + y.ndim - 2 \times n_{axes}`，其中 :math:`n_{axes}` 表示做 Tensor 缩并的轴数量。
 
 .. note::
 
-    1. 本 API 支持 Tensor 维度广播，``x`` 和 ``y`` 做缩并操作的对应维度 size 必须相等，或适用于广播规则。
-    2. 本 API 支持 axes 扩展，当指定的 ``x`` 和 ``y`` 两个轴序列长短不一时，短的序列会自动在末尾补充和长序列相同的轴下标。例如，如果输入 ``axes`` =[[0, 1, 2, 3], [1, 0]]，则指定 ``x`` 的轴序列是[0, 1, 2, 3]，对应 ``y`` 的轴序列会自动从[1,0]扩展成[1, 0, 2, 3]。
+    1. 本 API 支持 Tensor 维度广播， ``x``  和  ``y``  做缩并操作的对应维度 size 必须相等，或适用于广播规则。
+    2. 本 API 支持 axes 扩展，当指定的  ``x``  和  ``y``  两个轴序列长短不一时，短的序列会自动在末尾补充和长序列相同的轴下标。例如，如果输入  ``axes``  =[[0, 1, 2, 3], [1, 0]]，则指定  ``x``  的轴序列是[0, 1, 2, 3]，对应  ``y``  的轴序列会自动从[1,0]扩展成[1, 0, 2, 3]。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/text/Conll05st_cn.rst b/docs/api/paddle/text/Conll05st_cn.rst
index fb984d44827..7099152f892 100644
--- a/docs/api/paddle/text/Conll05st_cn.rst
+++ b/docs/api/paddle/text/Conll05st_cn.rst
@@ -23,7 +23,7 @@ Conll05st
 
 返回值
 :::::::::
-``Dataset``，conll05st 数据集实例。
+ ``Dataset`` ，conll05st 数据集实例。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/text/Imdb_cn.rst b/docs/api/paddle/text/Imdb_cn.rst
index 99d3093c0fb..8300a47e67e 100644
--- a/docs/api/paddle/text/Imdb_cn.rst
+++ b/docs/api/paddle/text/Imdb_cn.rst
@@ -17,7 +17,7 @@ Imdb
 
 返回
 :::::::::
-``Dataset``， IMDB 数据集实例。
+ ``Dataset`` ， IMDB 数据集实例。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/text/Imikolov_cn.rst b/docs/api/paddle/text/Imikolov_cn.rst
index bf411e98b67..6d8cafbc0e7 100644
--- a/docs/api/paddle/text/Imikolov_cn.rst
+++ b/docs/api/paddle/text/Imikolov_cn.rst
@@ -20,7 +20,7 @@ Imikolov
 
 返回
 :::::::::
-``Dataset``，imikolov 数据集实例。
+ ``Dataset`` ，imikolov 数据集实例。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/text/Movielens_cn.rst b/docs/api/paddle/text/Movielens_cn.rst
index 8a9bdb52819..a21be987ea9 100644
--- a/docs/api/paddle/text/Movielens_cn.rst
+++ b/docs/api/paddle/text/Movielens_cn.rst
@@ -20,7 +20,7 @@ Movielens
 
 返回值
 :::::::::
-    ``Dataset``，Movielens 1-M 数据集实例。
+     ``Dataset`` ，Movielens 1-M 数据集实例。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/text/Overview_cn.rst b/docs/api/paddle/text/Overview_cn.rst
index 8fae7c337fc..4f7072d3e3f 100644
--- a/docs/api/paddle/text/Overview_cn.rst
+++ b/docs/api/paddle/text/Overview_cn.rst
@@ -45,8 +45,8 @@ PaddleNLP 提供了在文本任务上简洁易用的全流程 API，旨在为飞
     :header: "API 模块", "功能简介", "API 用法简单示例"
     :widths: 10, 20, 20
 
-    " `paddlenlp.datasets <https://paddlenlp.readthedocs.io/zh/latest/data_prepare/dataset_list.html>`_ ", "数据集相关 API，包含自定义数据集，数据集贡献与数据集快速加载等功能", " ``train_ds = paddlenlp.datasets.load_dataset('ptb', splits='train')`` "
+    " `paddlenlp.datasets <https://paddlenlp.readthedocs.io/zh/latest/data_prepare/dataset_list.html>`_ ", "数据集相关 API，包含自定义数据集，数据集贡献与数据集快速加载等功能", "  ``train_ds = paddlenlp.datasets.load_dataset('ptb', splits='train')``  "
     " `paddlenlp.data <https://paddlenlp.readthedocs.io/zh/latest/data_prepare/data_preprocess.html>`_ ", "文本数据处理 Pipeline 的相关 API", "见链接文档"
-    " `paddlenlp.transformers <https://paddlenlp.readthedocs.io/zh/latest/source/paddlenlp.transformers.html>`_ ", "基于 Transformer 结构相关的预训练模型 API，包含 ERNIE, BERT, RoBERTa, Electra 等主流经典结构和下游任务", " ``model = paddlenlp.transformers.BertForSequenceClassification.from_pretrained('bert-wwm-chinese', num_classes=2)`` "
-    " `paddlenlp.metrics <https://paddlenlp.readthedocs.io/zh/latest/metrics/metrics.html>`_", "提供了文本任务上的一些模型评价指标，例如 Perplexity、GlLUE 中用到的评估器、BLEU、Rouge 等，与飞桨高层 API 兼容", " ``metric = paddlenlp.metrics.AccuracyAndF1()`` "
-    " `paddlenlp.embeddings <https://paddlenlp.readthedocs.io/zh/latest/model_zoo/embeddings.html>`_", "词向量相关 API，支持一键快速加载包预训练的中文词向量，VisualDL 高维可视化等功能", " ``token_embedding = paddlenlp.embeddings.TokenEmbedding(embedding_name='fasttext.wiki-news.target.word-word.dim300.en')`` "
+    " `paddlenlp.transformers <https://paddlenlp.readthedocs.io/zh/latest/source/paddlenlp.transformers.html>`_ ", "基于 Transformer 结构相关的预训练模型 API，包含 ERNIE, BERT, RoBERTa, Electra 等主流经典结构和下游任务", "  ``model = paddlenlp.transformers.BertForSequenceClassification.from_pretrained('bert-wwm-chinese', num_classes=2)``  "
+    " `paddlenlp.metrics <https://paddlenlp.readthedocs.io/zh/latest/metrics/metrics.html>`_", "提供了文本任务上的一些模型评价指标，例如 Perplexity、GlLUE 中用到的评估器、BLEU、Rouge 等，与飞桨高层 API 兼容", "  ``metric = paddlenlp.metrics.AccuracyAndF1()``  "
+    " `paddlenlp.embeddings <https://paddlenlp.readthedocs.io/zh/latest/model_zoo/embeddings.html>`_", "词向量相关 API，支持一键快速加载包预训练的中文词向量，VisualDL 高维可视化等功能", "  ``token_embedding = paddlenlp.embeddings.TokenEmbedding(embedding_name='fasttext.wiki-news.target.word-word.dim300.en')``  "
diff --git a/docs/api/paddle/text/UCIHousing_cn.rst b/docs/api/paddle/text/UCIHousing_cn.rst
index fa4baf9e50a..2f8c16e91ac 100644
--- a/docs/api/paddle/text/UCIHousing_cn.rst
+++ b/docs/api/paddle/text/UCIHousing_cn.rst
@@ -18,7 +18,7 @@ UCIHousing
 
 返回值
 :::::::::
-``Dataset``，UCI housing 数据集实例。
+ ``Dataset`` ，UCI housing 数据集实例。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/text/ViterbiDecoder_cn.rst b/docs/api/paddle/text/ViterbiDecoder_cn.rst
index a8a5fb2be5c..3a2069d3d08 100644
--- a/docs/api/paddle/text/ViterbiDecoder_cn.rst
+++ b/docs/api/paddle/text/ViterbiDecoder_cn.rst
@@ -4,7 +4,7 @@ ViterbiDecoder
 -------------------------------
 .. py:class:: paddle.text.ViterbiDecoder(transitions, include_bos_eos_tag=True, name=None)
 
-构建一个 ``ViterbiDecoder`` 类的可调用对象。请参见 :ref:`cn_api_paddle_text_viterbi_decode` API。
+构建一个  ``ViterbiDecoder``  类的可调用对象。请参见 :ref:`cn_api_paddle_text_viterbi_decode` API。
 
 参数
 :::::::::
diff --git a/docs/api/paddle/text/WMT14_cn.rst b/docs/api/paddle/text/WMT14_cn.rst
index c19c3911499..97000fc48b1 100644
--- a/docs/api/paddle/text/WMT14_cn.rst
+++ b/docs/api/paddle/text/WMT14_cn.rst
@@ -23,7 +23,7 @@ http://paddlemodels.bj.bcebos.com/wmt/wmt14.tgz
 
 返回值
 :::::::::
-``Dataset``，WMT14 数据集实例。
+ ``Dataset`` ，WMT14 数据集实例。
 
   - **src_ids** (np.array) - 源语言当前的 token id 序列。
   - **trg_ids** (np.array) - 目标语言当前的 token id 序列。
diff --git a/docs/api/paddle/text/WMT16_cn.rst b/docs/api/paddle/text/WMT16_cn.rst
index f678643051b..7e43d879e3b 100644
--- a/docs/api/paddle/text/WMT16_cn.rst
+++ b/docs/api/paddle/text/WMT16_cn.rst
@@ -23,7 +23,7 @@ http://www.statmt.org/wmt16/multimodal-task.html#task1
 
 返回值
 :::::::::
-``Dataset``，WMT16 数据集实例。实例一共有三个字段：
+ ``Dataset`` ，WMT16 数据集实例。实例一共有三个字段：
 
   - **src_ids** (np.array) - 源语言当前的 token id 序列。
   - **trg_ids** (np.array) - 目标语言当前的 token id 序列。
diff --git a/docs/api/paddle/tile_cn.rst b/docs/api/paddle/tile_cn.rst
index 860f51b0326..0768a99ceba 100644
--- a/docs/api/paddle/tile_cn.rst
+++ b/docs/api/paddle/tile_cn.rst
@@ -5,19 +5,19 @@ tile
 
 .. py:function:: paddle.tile(x, repeat_times, name=None)
 
-根据参数 ``repeat_times`` 对输入 ``x`` 的各维度进行复制。平铺后，输出的第 ``i``  个维度的值等于 ``x.shape[i]*repeat_times[i]`` 。
+根据参数  ``repeat_times``  对输入  ``x``  的各维度进行复制。平铺后，输出的第  ``i``   个维度的值等于  ``x.shape[i]*repeat_times[i]``  。
 
-``x`` 的维数和 ``repeat_times`` 中的元素数量应小于等于 6。
+ ``x``  的维数和  ``repeat_times``  中的元素数量应小于等于 6。
 
 参数
 :::::::::
     - **x** (Tensor) - 输入的 Tensor，数据类型为：bool、float16、float32、float64、int32 或 int64。
-    - **repeat_times** (list|tuple|Tensor) - 指定输入 ``x`` 每个维度的复制次数。如果 ``repeat_times`` 的类型是 list 或 tuple，它的元素可以是整数或者数据类型为 int32 的 1-D Tensor。如果 ``repeat_times`` 的类型是 Tensor，则是数据类型为 int32 的 1-D Tensor。
+    - **repeat_times** (list|tuple|Tensor) - 指定输入  ``x``  每个维度的复制次数。如果  ``repeat_times``  的类型是 list 或 tuple，它的元素可以是整数或者数据类型为 int32 的 1-D Tensor。如果  ``repeat_times``  的类型是 Tensor，则是数据类型为 int32 的 1-D Tensor。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-``Tensor``，数据类型与 ``x`` 相同。返回值的第 i 维的大小等于 ``x[i] * repeat_times[i]`` 。
+ ``Tensor`` ，数据类型与  ``x``  相同。返回值的第 i 维的大小等于  ``x[i] * repeat_times[i]``  。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/to_dlpack_cn.rst b/docs/api/paddle/to_dlpack_cn.rst
index 7fa105a4fee..12c21d4cf04 100644
--- a/docs/api/paddle/to_dlpack_cn.rst
+++ b/docs/api/paddle/to_dlpack_cn.rst
@@ -5,7 +5,7 @@ to_dlpack
 
 .. py:function:: paddle.to_dlpack(x)
 
-将 Tensor 对象转化为一个带有 dltensor 的 ``PyCapsule`` 对象，该对象是一种称为 DLPack 的通用稳定内存数据结构，可用于不同深度学习框架之间的 Tensor 共享。
+将 Tensor 对象转化为一个带有 dltensor 的  ``PyCapsule``  对象，该对象是一种称为 DLPack 的通用稳定内存数据结构，可用于不同深度学习框架之间的 Tensor 共享。
 
 参数
 :::::::::
@@ -13,7 +13,7 @@ to_dlpack
 
 返回
 :::::::::
-  - **dlpack** (PyCapsule) - 一个带有 dltensor 的 ``PyCapsule`` 对象。
+  - **dlpack** (PyCapsule) - 一个带有 dltensor 的  ``PyCapsule``  对象。
 
 代码示例 1
 :::::::::
diff --git a/docs/api/paddle/to_tensor_cn.rst b/docs/api/paddle/to_tensor_cn.rst
index 2aa868e7188..a9924718167 100644
--- a/docs/api/paddle/to_tensor_cn.rst
+++ b/docs/api/paddle/to_tensor_cn.rst
@@ -6,10 +6,10 @@ to_tensor
 
 .. py:function:: paddle.to_tensor(data, dtype=None, place=None, stop_gradient=True)
 
-通过已知的 ``data`` 来创建一个 Tensor，Tensor 类型为 ``paddle.Tensor``。
-``data`` 可以是 scalar，tuple，list，numpy\.ndarray，paddle\.Tensor。
+通过已知的  ``data``  来创建一个 Tensor，Tensor 类型为  ``paddle.Tensor`` 。
+ ``data``  可以是 scalar，tuple，list，numpy\.ndarray，paddle\.Tensor。
 
-如果 ``data`` 已经是一个 Tensor，且 ``dtype`` 、 ``place`` 没有发生变化，将不会发生 Tensor 的拷贝并返回原来的 Tensor。
+如果  ``data``  已经是一个 Tensor，且  ``dtype``  、  ``place``  没有发生变化，将不会发生 Tensor 的拷贝并返回原来的 Tensor。
 否则会创建一个新的 Tensor，且不保留原来计算图。
 
 .. code-block:: text
@@ -30,13 +30,13 @@ to_tensor
 
     - **data** (scalar|tuple|list|ndarray|Tensor) - 初始化 Tensor 的数据，可以是 scalar，list，tuple，numpy\.ndarray，paddle\.Tensor 类型。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 创建 Tensor 的数据类型，可以是 bool、float16、float32、float64、int8、int16、int32、int64、uint8、complex64、complex128。
-      默认值为 None，如果 ``data`` 为 python 浮点类型，则从 :ref:`cn_api_paddle_get_default_dtype` 获取类型，如果 ``data`` 为其他类型，则会自动推导类型。
-    - **place** (CPUPlace|CUDAPinnedPlace|CUDAPlace，可选) - 创建 tensor 的设备位置，可以是 CPUPlace、CUDAPinnedPlace、CUDAPlace。默认值为 None，使用全局的 place。别名： ``device``。
+      默认值为 None，如果  ``data``  为 python 浮点类型，则从 :ref:`cn_api_paddle_get_default_dtype` 获取类型，如果  ``data``  为其他类型，则会自动推导类型。
+    - **place** (CPUPlace|CUDAPinnedPlace|CUDAPlace，可选) - 创建 tensor 的设备位置，可以是 CPUPlace、CUDAPinnedPlace、CUDAPlace。默认值为 None，使用全局的 place。别名：  ``device`` 。
     - **stop_gradient** (bool，可选) - 是否阻断 Autograd 的梯度传导。默认值为 True，此时不进行梯度传传导。
 
 返回
 :::::::::
-通过 ``data`` 创建的 Tensor。
+通过  ``data``  创建的 Tensor。
 
 
 代码示例
diff --git a/docs/api/paddle/topk_cn.rst b/docs/api/paddle/topk_cn.rst
index feee3bdaa12..0abe85a1890 100644
--- a/docs/api/paddle/topk_cn.rst
+++ b/docs/api/paddle/topk_cn.rst
@@ -5,16 +5,16 @@ topk
 
 .. py:function:: paddle.topk(x, k, axis=None, largest=True, sorted=True, name=None, *, out=None)
 
-沿着可选的 ``axis`` 查找 topk 最大或者最小的结果和结果所在的索引信息。
+沿着可选的  ``axis``  查找 topk 最大或者最小的结果和结果所在的索引信息。
 如果是一维 Tensor，则直接返回 topk 查询的结果。如果是多维 Tensor，则在指定的轴上查询 topk 的结果。
 
 参数
 :::::::::
-    - **x** (Tensor) - 输入的多维 ``Tensor`` ，支持的数据类型：float32、float64、int32、int64。
-      ``别名: input``
+    - **x** (Tensor) - 输入的多维  ``Tensor``  ，支持的数据类型：float32、float64、int32、int64。
+       ``别名: input`` 
     - **k** (int，Tensor) - 在指定的轴上进行 top 寻找的数量。
-    - **axis** (int，可选) - 指定对输入 Tensor 进行运算的轴， ``axis`` 的有效范围是[-R, R），R 是输入 ``x`` 的 Rank， ``axis`` 为负时与 ``axis`` + R 等价。默认值为-1。
-      ``别名: dim``
+    - **axis** (int，可选) - 指定对输入 Tensor 进行运算的轴，  ``axis``  的有效范围是[-R, R），R 是输入  ``x``  的 Rank，  ``axis``  为负时与  ``axis``  + R 等价。默认值为-1。
+       ``别名: dim`` 
     - **largest** (bool，可选) - 指定算法排序的方向。如果设置为 True，排序算法按照降序的算法排序，否则按照升序排序。默认值为 True。
     - **sorted** (bool，可选) - 控制返回的结果是否按照有序返回，默认为 True。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
@@ -22,7 +22,7 @@ topk
 
 返回
 :::::::::
-tuple(Tensor)， 返回 topk 的结果和结果的索引信息。结果的数据类型和输入 ``x`` 一致。索引的数据类型是 int64。
+tuple(Tensor)， 返回 topk 的结果和结果的索引信息。结果的数据类型和输入  ``x``  一致。索引的数据类型是 int64。
 
 
 代码示例
diff --git a/docs/api/paddle/trace_cn.rst b/docs/api/paddle/trace_cn.rst
index d38fc24c53b..6d7ebfb1f35 100644
--- a/docs/api/paddle/trace_cn.rst
+++ b/docs/api/paddle/trace_cn.rst
@@ -12,7 +12,7 @@ trace
 
 如果输入的维度大于 2D，则返回一个由对角线元素之和组成的数组，其中对角线从由 axis1 和 axis2 指定的二维平面中获得。默认由输入的前两维组成获得对角线的 2D 平面。
 
-参数 ``offset`` 确定从指定的二维平面中获取对角线的位置：
+参数  ``offset``  确定从指定的二维平面中获取对角线的位置：
 
     - 如果 offset = 0，则取主对角线。
     - 如果 offset > 0，则取主对角线右上的对角线。
diff --git a/docs/api/paddle/transpose_cn.rst b/docs/api/paddle/transpose_cn.rst
index 6e74ee16ecb..c31845f3b3e 100644
--- a/docs/api/paddle/transpose_cn.rst
+++ b/docs/api/paddle/transpose_cn.rst
@@ -11,13 +11,13 @@ transpose
 根据 perm 对输入的多维 Tensor 进行数据重排。返回多维 Tensor 的第 i 维对应输入 Tensor 的 perm[i]维。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，参数 ``dim0`` 与 ``dim1`` 可替代 ``axis`` ，如 ``transpose(input=x, dim0=0, dim1=1)`` 等价于 ``transpose(x=x, perm=[1, 0, 2])`` 。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，参数  ``dim0``  与  ``dim1``  可替代  ``axis``  ，如  ``transpose(input=x, dim0=0, dim1=1)``  等价于  ``transpose(x=x, perm=[1, 0, 2])``  。
 
 
 参数
 ::::::::::::
 
-    - **x** (Tensor) - 输入：x:[N_1, N_2, ..., N_k, D]多维 Tensor，可选的数据类型为 bool, float16, bfloat16, float32, float64, int8, int16, int32, int64, uint8, uint16, complex64, complex128。别名： ``input``。
+    - **x** (Tensor) - 输入：x:[N_1, N_2, ..., N_k, D]多维 Tensor，可选的数据类型为 bool, float16, bfloat16, float32, float64, int8, int16, int32, int64, uint8, uint16, complex64, complex128。别名：  ``input`` 。
     - **perm** (list|tuple) - perm 长度必须和 X 的维度相同，并依照 perm 中数据进行重排。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/trapezoid_cn.rst b/docs/api/paddle/trapezoid_cn.rst
index 75890946015..1f16dd52a8e 100644
--- a/docs/api/paddle/trapezoid_cn.rst
+++ b/docs/api/paddle/trapezoid_cn.rst
@@ -12,13 +12,13 @@ trapezoid
 :::::::::
 
     - **y** (Tensor) - 输入多维 Tensor，可选的数据类型为 float16、float32、float64。
-    - **x** (Tensor，可选) - ``y`` 中数值对应的浮点数所组成的 Tensor，类型与 ``y`` 相同，形状与 ``y`` 的形状相匹配；若 ``x`` 有输入，已知 ``y`` 的尺寸为 `[d_1, d_2, ... , d_n]` 且 `axis=k`，则 ``x`` 的尺寸只能为 `[d_k]` 或 `[d_1, d_2, ... , d_n]`；如果 ``x`` 为 None，则假定采样点均匀分布 ``dx``。
-    - **dx** (float，可选) - 相邻采样点之间的常数间隔；当 ``x`` 和 ``dx`` 均未指定时，``dx`` 默认为 1.0。
-    - **axis** (int，可选) - 计算 trapezoid rule 时 ``y`` 的维度。默认值 -1。
+    - **x** (Tensor，可选) -  ``y``  中数值对应的浮点数所组成的 Tensor，类型与  ``y``  相同，形状与  ``y``  的形状相匹配；若  ``x``  有输入，已知  ``y``  的尺寸为 `[d_1, d_2, ... , d_n]` 且 `axis=k`，则  ``x``  的尺寸只能为 `[d_k]` 或 `[d_1, d_2, ... , d_n]`；如果  ``x``  为 None，则假定采样点均匀分布  ``dx`` 。
+    - **dx** (float，可选) - 相邻采样点之间的常数间隔；当  ``x``  和  ``dx``  均未指定时， ``dx``  默认为 1.0。
+    - **axis** (int，可选) - 计算 trapezoid rule 时  ``y``  的维度。默认值 -1。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 返回
 :::::::::
-Tensor，按 trapezoidal rule 计算出 ``y`` 等于 N 维张量时的定积分，如果 ``y`` 是一维张量，则结果是浮点数。如果 N 大于 1 维，则结果为 N-1 维张量。
+Tensor，按 trapezoidal rule 计算出  ``y``  等于 N 维张量时的定积分，如果  ``y``  是一维张量，则结果是浮点数。如果 N 大于 1 维，则结果为 N-1 维张量。
 
 
 代码示例
diff --git a/docs/api/paddle/tril_cn.rst b/docs/api/paddle/tril_cn.rst
index dd5371ccfaa..7bb100c5956 100644
--- a/docs/api/paddle/tril_cn.rst
+++ b/docs/api/paddle/tril_cn.rst
@@ -8,19 +8,19 @@ tril
 
 
 
-返回输入矩阵 ``input`` 的下三角部分，其余部分被设为 0。
+返回输入矩阵  ``input``  的下三角部分，其余部分被设为 0。
 矩形的下三角部分被定义为对角线上和下方的元素。
 
 参数
 :::::::::
-    - **x** (Tensor) - 输入 Tensor x，数据类型支持 bool、float32、float64、int32、int64、complex64、complex128。别名 ``input``。
+    - **x** (Tensor) - 输入 Tensor x，数据类型支持 bool、float32、float64、int32、int64、complex64、complex128。别名  ``input`` 。
     - **diagonal** (int，可选) - 指定的对角线，默认值为 0。如果 diagonal = 0，表示主对角线；如果 diagonal 是正数，表示主对角线之上的对角线；如果 diagonal 是负数，表示主对角线之下的对角线。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/triu_cn.rst b/docs/api/paddle/triu_cn.rst
index d9a7e089335..1a5de544a20 100644
--- a/docs/api/paddle/triu_cn.rst
+++ b/docs/api/paddle/triu_cn.rst
@@ -11,14 +11,14 @@ triu
 
 参数
 :::::::::
-    - **x** (Tensor)：输入 Tensor x，数据类型支持 `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`。别名 ``input``。
+    - **x** (Tensor)：输入 Tensor x，数据类型支持 `float32`, `float64`, `int32`, `int64`, `complex64`, `complex128`。别名  ``input`` 。
     - **diagonal** (int，可选)：指定的对角线，默认值为 0。如果 diagonal = 0，表示主对角线；如果 diagonal 是正数，表示主对角线之上的对角线；如果 diagonal 是负数，表示主对角线之下的对角线。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/unbind_cn.rst b/docs/api/paddle/unbind_cn.rst
index a18cbb3a61b..94c2b450302 100644
--- a/docs/api/paddle/unbind_cn.rst
+++ b/docs/api/paddle/unbind_cn.rst
@@ -7,7 +7,7 @@ unbind
 
 
 .. note::
-    别名支持: 参数名 ``dim`` 可替代 ``axis``，如 ``paddle.unbind(input=tensor_x, dim=0)`` 等价于 ``paddle.unbind(input=tensor_x, axis=0)`` 。
+    别名支持: 参数名  ``dim``  可替代  ``axis`` ，如  ``paddle.unbind(input=tensor_x, dim=0)``  等价于  ``paddle.unbind(input=tensor_x, axis=0)``  。
 
 
 将输入 Tensor 按照指定的维度分割成多个子 Tensor。
@@ -15,7 +15,7 @@ unbind
 参数
 :::::::::
        - **input** (Tensor) - 输入变量，数据类型为 float16、loat32、float64、int32、int64、complex64、complex128 的多维 Tensor。
-       - **axis** (int32|int64，可选) - 数据类型为 int32 或 int64，表示需要分割的维度。如果 axis < 0，则划分的维度为 rank(input) + axis。默认值为 0。别名： ``dim``。
+       - **axis** (int32|int64，可选) - 数据类型为 int32 或 int64，表示需要分割的维度。如果 axis < 0，则划分的维度为 rank(input) + axis。默认值为 0。别名：  ``dim`` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/unflatten_cn.rst b/docs/api/paddle/unflatten_cn.rst
index 5a24a0809a4..1e4d12036ae 100644
--- a/docs/api/paddle/unflatten_cn.rst
+++ b/docs/api/paddle/unflatten_cn.rst
@@ -7,7 +7,7 @@ unflatten
 
 将输入 Tensor 沿指定轴 axis 上的维度展成 shape 形状。与 :ref:`cn_api_paddle_flatten` 是反函数。
 
-下图展示了一个[2, 6]的 Tensor 在经过 ``unflatten(X, axis=1, shape=(2, 3))`` 后的形状，数据依次为 0 到 11。
+下图展示了一个[2, 6]的 Tensor 在经过  ``unflatten(X, axis=1, shape=(2, 3))``  后的形状，数据依次为 0 到 11。
 
 .. image:: ../../images/api_legend/unflatten.png
    :alt: 图例
@@ -18,13 +18,13 @@ unflatten
 :::::::::
 
     - **x** (Tensor) - 输入多维 Tensor，可选的数据类型为 'float16'、'float32'、'float64'、'int16'、'int32'、'int64'、'bool'、'uint16'。
-    - **axis** (int) - 要展开维度的轴，作为 ``x.shape`` 的索引。
-    - **shape** (list|tuple|Tensor) - 在指定轴上将该维度展成 ``shape``， 其中 ``shape`` 最多包含一个 -1，如果输入 ``shape`` 不包含 -1 ，则 ``shape`` 内元素累乘的结果应该等于 ``x.shape[axis]``。数据类型为 ``int``。如果 ``shape`` 的类型是 ``list`` 或 ``tuple``，它的元素可以是整数或者形状为[]的 ``Tensor`` （0-D ``Tensor``）。如果 ``shape`` 的类型是 ``Tensor``，则是 1-D 的 ``Tensor``。
+    - **axis** (int) - 要展开维度的轴，作为  ``x.shape``  的索引。
+    - **shape** (list|tuple|Tensor) - 在指定轴上将该维度展成  ``shape`` ， 其中  ``shape``  最多包含一个 -1，如果输入  ``shape``  不包含 -1 ，则  ``shape``  内元素累乘的结果应该等于  ``x.shape[axis]`` 。数据类型为  ``int`` 。如果  ``shape``  的类型是  ``list``  或  ``tuple`` ，它的元素可以是整数或者形状为[]的  ``Tensor``  （0-D  ``Tensor`` ）。如果  ``shape``  的类型是  ``Tensor`` ，则是 1-D 的  ``Tensor`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 :::::::::
-Tensor，沿指定轴将维度展开的后的 ``x``。
+Tensor，沿指定轴将维度展开的后的  ``x`` 。
 
 
 代码示例
diff --git a/docs/api/paddle/unfold_cn.rst b/docs/api/paddle/unfold_cn.rst
index 9f08d7072d8..3ea5c903f44 100644
--- a/docs/api/paddle/unfold_cn.rst
+++ b/docs/api/paddle/unfold_cn.rst
@@ -9,7 +9,7 @@ unfold
 
 仅在动态图下可用，返回的 Tensor 和 x 共享内存。
 
-下图展示了一个元素值为 0-8 且 Shape 为 [9] 的 Tensor 如何使用 ``unfold`` 方法在第一个维度（axis = 0），使用大小为 2 的窗口（size = 2）根据 4 的步长（step = 4）进行采样。
+下图展示了一个元素值为 0-8 且 Shape 为 [9] 的 Tensor 如何使用  ``unfold``  方法在第一个维度（axis = 0），使用大小为 2 的窗口（size = 2）根据 4 的步长（step = 4）进行采样。
 
 .. image:: ../../images/api_legend/unfold.png
     :width: 700
@@ -19,7 +19,7 @@ unfold
 :::::::::
 
     - **x** (Tensor) - 输入多维 Tensor，可选的数据类型为 'float16'、'float32'、'float64'、'int16'、'int32'、'int64'、'bool'、'uint16'。
-    - **axis** (int) - 表示需要提取的维度。如果 ``axis < 0``，则维度为 ``rank(x) + axis``。
+    - **axis** (int) - 表示需要提取的维度。如果  ``axis < 0`` ，则维度为  ``rank(x) + axis`` 。
     - **size** (int) - 表示需要提取的窗口长度。
     - **step** (int) - 表示每次提取跳跃的步长。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
diff --git a/docs/api/paddle/uniform_cn.rst b/docs/api/paddle/uniform_cn.rst
index 7cb7a45cf4d..6d675b43587 100644
--- a/docs/api/paddle/uniform_cn.rst
+++ b/docs/api/paddle/uniform_cn.rst
@@ -8,7 +8,7 @@ uniform
 
 
 
-返回数值服从范围[``min``, ``max``)内均匀分布的随机 Tensor，形状为 ``shape``，数据类型为 ``dtype``。
+返回数值服从范围[ ``min`` ,  ``max`` )内均匀分布的随机 Tensor，形状为  ``shape`` ，数据类型为  ``dtype`` 。
 
 .. code-block:: text
 
@@ -21,7 +21,7 @@ uniform
 参数
 ::::::::::::
 
-    - **shape** (list|tuple|Tensor) - 生成的随机 Tensor 的形状。如果 ``shape`` 是 list、tuple，则其中的元素可以是 int，或者是形状为[]且数据类型为 int32、int64 的 0-D Tensor。如果 ``shape`` 是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor。
+    - **shape** (list|tuple|Tensor) - 生成的随机 Tensor 的形状。如果  ``shape``  是 list、tuple，则其中的元素可以是 int，或者是形状为[]且数据类型为 int32、int64 的 0-D Tensor。如果  ``shape``  是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，支持 float32、float64。默认值为 None。
     - **min** (float|int，可选) - 要生成的随机值范围的下限，min 包含在范围中。支持的数据类型：float、int。默认值为-1.0。
     - **max** (float|int，可选) - 要生成的随机值范围的上限，max 不包含在范围中。支持的数据类型：float、int。默认值为 1.0。
@@ -31,7 +31,7 @@ uniform
 返回
 ::::::::::::
 
-Tensor：数值服从范围[``min``, ``max``)内均匀分布的随机 Tensor，形状为 ``shape``，数据类型为 ``dtype``。
+Tensor：数值服从范围[ ``min`` ,  ``max`` )内均匀分布的随机 Tensor，形状为  ``shape`` ，数据类型为  ``dtype`` 。
 
 
 代码示例
diff --git a/docs/api/paddle/unique_cn.rst b/docs/api/paddle/unique_cn.rst
index 2017d71f199..44e6901d069 100644
--- a/docs/api/paddle/unique_cn.rst
+++ b/docs/api/paddle/unique_cn.rst
@@ -38,7 +38,7 @@ unique
     - **return_inverse** (bool，可选) - 如果为 True，则还返回输入 Tensor 的元素对应在独有元素中的索引，该索引可用于重构输入 Tensor。
     - **return_counts** (bool，可选) - 如果为 True，则还返回每个独有元素在输入 Tensor 中的个数。
     - **axis** (int，可选) - 指定选取独有元素的轴。默认值为 None，将输入平铺为 1-D 的 Tensor 后再选取独有元素。
-    - **dtype** (str|paddle.dtype|np.dtype，可选) - 用于设置 ``index`` ， ``inverse`` 或者 ``counts`` 的类型，应该为 int32 或者 int64。默认：int64。
+    - **dtype** (str|paddle.dtype|np.dtype，可选) - 用于设置  ``index``  ，  ``inverse``  或者  ``counts``  的类型，应该为 int32 或者 int64。默认：int64。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
@@ -46,9 +46,9 @@ unique
 ::::::::::::
 
     - **out** (Tensor) - 独有元素构成的 Tensor，数据类型与输入一致。
-    - **index** (Tensor，可选) - 独有元素在输入 Tensor 中的索引，仅在 ``return_index`` 为 True 时返回。
-    - **inverse** (Tensor，可选) - 输入 Tensor 的元素对应在独有元素中的索引，仅在 ``return_inverse`` 为 True 时返回。
-    - **counts** (Tensor，可选) - 每个独有元素在输入 Tensor 中的个数，仅在 ``return_counts`` 为 True 时返回。
+    - **index** (Tensor，可选) - 独有元素在输入 Tensor 中的索引，仅在  ``return_index``  为 True 时返回。
+    - **inverse** (Tensor，可选) - 输入 Tensor 的元素对应在独有元素中的索引，仅在  ``return_inverse``  为 True 时返回。
+    - **counts** (Tensor，可选) - 每个独有元素在输入 Tensor 中的个数，仅在  ``return_counts``  为 True 时返回。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/unique_consecutive_cn.rst b/docs/api/paddle/unique_consecutive_cn.rst
index 6aba05fdb99..f89a4050c67 100644
--- a/docs/api/paddle/unique_consecutive_cn.rst
+++ b/docs/api/paddle/unique_consecutive_cn.rst
@@ -18,18 +18,18 @@ unique_consecutive
        :align: center
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x`` 和 ``dim`` 可替代 ``axis``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``， ``dim=1`` 等价于 ``axis=1``。
+    别名支持: 参数名  ``input``  可替代  ``x``  和  ``dim``  可替代  ``axis`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` ，  ``dim=1``  等价于  ``axis=1`` 。
 
 参数
 ::::::::::::
 
     - **x** (Tensor) - 输入的 `Tensor`，数据类型为：float32、float64、int32、int64。
-      别名： ``input``
+      别名：  ``input`` 
     - **return_inverse** (bool，可选) - 如果为 True，则还返回输入 Tensor 的元素对应在连续不重复元素中的索引，该索引可用于重构输入 Tensor。默认：False。
     - **return_counts** (bool，可选) - 如果为 True，则还返回每个连续不重复元素在输入 Tensor 中的个数。默认：False。
     - **axis** (int，可选) - 指定选取连续不重复元素的轴。默认值为 None，将输入平铺为 1-D 的 Tensor 后再选取连续不重复元素。默认：None。
-      别名： ``dim``
-    - **dim** - ``axis`` 的别名，行为完全一致。
+      别名：  ``dim`` 
+    - **dim** -  ``axis``  的别名，行为完全一致。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 用于设置 `inverse` 或者 `counts` 的类型，应该为 int32 或者 int64。默认：int64。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
@@ -37,8 +37,8 @@ unique_consecutive
 ::::::::::::
 
     - **out** ( Tensor )  - 连续不重复元素构成的 Tensor ，数据类型与输入一致。
-    - **inverse** ( Tensor ，可选 ) - 输入 Tensor 的元素对应在连续不重复元素中的索引，仅在 ``return_inverse`` 为 True 时返回。
-    - **counts** ( Tensor ，可选) - 每个连续不重复元素在输入 Tensor 中的个数，仅在 ``return_counts`` 为 True 时返回。
+    - **inverse** ( Tensor ，可选 ) - 输入 Tensor 的元素对应在连续不重复元素中的索引，仅在  ``return_inverse``  为 True 时返回。
+    - **counts** ( Tensor ，可选) - 每个连续不重复元素在输入 Tensor 中的个数，仅在  ``return_counts``  为 True 时返回。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/unsqueeze_cn.rst b/docs/api/paddle/unsqueeze_cn.rst
index de1b67338c3..a11de907282 100644
--- a/docs/api/paddle/unsqueeze_cn.rst
+++ b/docs/api/paddle/unsqueeze_cn.rst
@@ -10,21 +10,21 @@ unsqueeze
 请注意，在动态图模式下，输出 Tensor 将与输入 Tensor 共享数据，并且没有 Tensor 数据拷贝的过程。
 如果不希望输入与输出共享数据，请使用 `Tensor.clone`，例如 `unsqueeze_clone_x = x.unsqueeze(-1).clone()` 。
 
-下图展示了一个 Shape 为 [2, 3] 的 Tensor 如何使用 ``unsqueeze`` 方法在最后一个位置（axis = 2）增加一个维度，从二维变成三维。
+下图展示了一个 Shape 为 [2, 3] 的 Tensor 如何使用  ``unsqueeze``  方法在最后一个位置（axis = 2）增加一个维度，从二维变成三维。
 
 .. image:: ../../images/api_legend/unsqueeze.png
     :width: 700
     :alt: 图例
 
-额外的，当需要在多个位置增加维度时， ``unsqueeze`` 方法会按顺序依次增加维度。例如 Shape 为 [2, 3] 的 Tensor 在 axis = [0, 2] 处增加维度， ``unsqueeze`` 方法会先在 axis = 0 前插入一个维度， Shape 变为 [1, 2, 3]，接着在 axis = 2 前插入一个维度， Shape 最终变为 [1, 2, 1, 3]。
+额外的，当需要在多个位置增加维度时，  ``unsqueeze``  方法会按顺序依次增加维度。例如 Shape 为 [2, 3] 的 Tensor 在 axis = [0, 2] 处增加维度，  ``unsqueeze``  方法会先在 axis = 0 前插入一个维度， Shape 变为 [1, 2, 3]，接着在 axis = 2 前插入一个维度， Shape 最终变为 [1, 2, 1, 3]。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``dim`` 可替代 ``axis``，如 ``unsqueeze(input=tensor_x, dim=1)`` 等价于 ``unsqueeze(x=tensor_x, axis=1)``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，参数名  ``dim``  可替代  ``axis`` ，如  ``unsqueeze(input=tensor_x, dim=1)``  等价于  ``unsqueeze(x=tensor_x, axis=1)`` 。
 
 参数
 :::::::::
-        - **x** (Tensor) - 输入的 `Tensor`，数据类型为：bfloat16、float32、float64、bool、int8、int32、int64。别名： ``input``。
-        - **axis** (int|list|tuple|Tensor) - 表示要插入维度的位置。数据类型是 int32。如果 axis 的类型是 list 或 tuple，它的元素可以是整数或者形状为[]的 0-D Tensor。如果 axis 的类型是 Tensor，则是 1-D Tensor。如果 axis 是负数，则 axis=axis+ndim(x)+1 。别名： ``dim``。
+        - **x** (Tensor) - 输入的 `Tensor`，数据类型为：bfloat16、float32、float64、bool、int8、int32、int64。别名：  ``input`` 。
+        - **axis** (int|list|tuple|Tensor) - 表示要插入维度的位置。数据类型是 int32。如果 axis 的类型是 list 或 tuple，它的元素可以是整数或者形状为[]的 0-D Tensor。如果 axis 的类型是 Tensor，则是 1-D Tensor。如果 axis 是负数，则 axis=axis+ndim(x)+1 。别名：  ``dim`` 。
         - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/unstack_cn.rst b/docs/api/paddle/unstack_cn.rst
index b3ce6a2ddb1..9a41b891fc0 100644
--- a/docs/api/paddle/unstack_cn.rst
+++ b/docs/api/paddle/unstack_cn.rst
@@ -5,21 +5,21 @@ unstack
 
 .. py:function:: paddle.unstack(x, axis=0, num=None)
 
-将单个 dim 为 ``D`` 的 Tensor 沿 ``axis`` 轴 unpack 为 ``num`` 个 dim 为 ``(D-1)`` 的 Tensor。
+将单个 dim 为  ``D``  的 Tensor 沿  ``axis``  轴 unpack 为  ``num``  个 dim 为  ``(D-1)``  的 Tensor。
 
 参数
 ::::::::::::
 
-      - **x** (Tensor) – 输入 x 为 ``dim > 0`` 的 Tensor，支持的数据类型：float32，float64，int32，int64， complex64，complex128。
-      - **axis** (int | 可选) – 输入 Tensor 进行 unpack 运算所在的轴，axis 的范围为：``[-D, D)`` ，如果 ``axis < 0``，则 :math:`axis = axis + dim(x)`，axis 的默认值为 0。
-      - **num** (int | 可选) - axis 轴的长度，一般无需设置，默认值为 ``None`` 。
+      - **x** (Tensor) – 输入 x 为  ``dim > 0``  的 Tensor，支持的数据类型：float32，float64，int32，int64， complex64，complex128。
+      - **axis** (int | 可选) – 输入 Tensor 进行 unpack 运算所在的轴，axis 的范围为： ``[-D, D)``  ，如果  ``axis < 0`` ，则 :math:`axis = axis + dim(x)`，axis 的默认值为 0。
+      - **num** (int | 可选) - axis 轴的长度，一般无需设置，默认值为  ``None``  。
 
 返回
 ::::::::::::
 
- 长度为 num 的 Tensor 列表，数据类型与输入 Tensor 相同，dim 为 ``(D-1)``。
+ 长度为 num 的 Tensor 列表，数据类型与输入 Tensor 相同，dim 为  ``(D-1)`` 。
 
-也可以参考下方的图示来理解 ``unstack`` 是如何对张量进行变换的。图中分别展示了一个形状为 ``(3, 4)`` 的 Tensor 在 ``axis=1`` 和一个形状为 ``(2, 3, 3)`` 的 Tensor 在 ``axis=1`` 的 unstack 操作。
+也可以参考下方的图示来理解  ``unstack``  是如何对张量进行变换的。图中分别展示了一个形状为  ``(3, 4)``  的 Tensor 在  ``axis=1``  和一个形状为  ``(2, 3, 3)``  的 Tensor 在  ``axis=1``  的 unstack 操作。
 
 .. image:: ../../images/api_legend/unstack.png
    :width: 500
diff --git a/docs/api/paddle/utils/cpp_extension/CUDAExtension_cn.rst b/docs/api/paddle/utils/cpp_extension/CUDAExtension_cn.rst
index f21dcbc2a2f..3fb47814a0d 100644
--- a/docs/api/paddle/utils/cpp_extension/CUDAExtension_cn.rst
+++ b/docs/api/paddle/utils/cpp_extension/CUDAExtension_cn.rst
@@ -7,7 +7,7 @@ CUDAExtension
 
 此接口用于配置自定义 OP 的源文件信息，编译生成同时支持 CPU 和 GPU 设备上执行的算子。若要编译仅支持 CPU 设备的算子，请使用 :ref:`cn_api_paddle_utils_cpp_extension_CppExtension` 。
 
-此接口是对 Python 内建库 ``setuptools.Extension`` 的进一步封装。除了不需要显式地指定 ``name`` 参数，其他参数以及使用方式上，与原生内建库接口保持一致。
+此接口是对 Python 内建库  ``setuptools.Extension``  的进一步封装。除了不需要显式地指定  ``name``  参数，其他参数以及使用方式上，与原生内建库接口保持一致。
 
 **使用样例如下：**
 
@@ -29,7 +29,7 @@ CUDAExtension
 
 .. note::
 
-    搭配 ``setup`` 接口使用，编译生成的动态库名称与 :ref:`cn_api_paddle_utils_cpp_extension_setup` 接口中的 ``name`` 一致。
+    搭配  ``setup``  接口使用，编译生成的动态库名称与 :ref:`cn_api_paddle_utils_cpp_extension_setup` 接口中的  ``name``  一致。
 
 
 
@@ -37,8 +37,8 @@ CUDAExtension
 ::::::::::::
 
   - **sources** (list[str]) - 用于指定自定义 OP 对应的源码文件。cpp 源文件支持。cc、.cpp 等后缀；cuda 源文件以。cu 为后缀。
-  - **\*args, \*\*kwargs** (可选) - 用于指定 Extension 的其他参数，支持的参数与 ``setuptools.Extension`` 一致。
+  - **\*args, \*\*kwargs** (可选) - 用于指定 Extension 的其他参数，支持的参数与  ``setuptools.Extension``  一致。
 
 返回
 ::::::::::::
- ``setuptools.Extension`` 对象。
+  ``setuptools.Extension``  对象。
diff --git a/docs/api/paddle/utils/cpp_extension/CppExtension_cn.rst b/docs/api/paddle/utils/cpp_extension/CppExtension_cn.rst
index 1b02f9647c9..2fc52f78a55 100644
--- a/docs/api/paddle/utils/cpp_extension/CppExtension_cn.rst
+++ b/docs/api/paddle/utils/cpp_extension/CppExtension_cn.rst
@@ -7,7 +7,7 @@ CppExtension
 
 此接口用于配置自定义 OP 的源文件信息，编译生成仅支持 CPU 设备上执行的算子。若要编译同时支持 GPU 设备的算子，请使用 :ref:`cn_api_paddle_utils_cpp_extension_CUDAExtension` 。
 
-此接口是对 Python 内建库 ``setuptools.Extension`` 的进一步封装。除了不需要显式地指定 ``name`` 参数，其他参数以及使用方式上，与原生内建库接口保持一致。
+此接口是对 Python 内建库  ``setuptools.Extension``  的进一步封装。除了不需要显式地指定  ``name``  参数，其他参数以及使用方式上，与原生内建库接口保持一致。
 
 **使用样例如下：**
 
@@ -27,7 +27,7 @@ CppExtension
 
 .. note::
 
-    搭配 ``setup`` 接口使用，编译生成的动态库名称与 :ref:`cn_api_paddle_utils_cpp_extension_setup` 接口中的 ``name`` 一致。
+    搭配  ``setup``  接口使用，编译生成的动态库名称与 :ref:`cn_api_paddle_utils_cpp_extension_setup` 接口中的  ``name``  一致。
 
 
 
@@ -35,8 +35,8 @@ CppExtension
 ::::::::::::
 
   - **sources** (list[str]) - 用于指定自定义 OP 对应的源码文件。cpp 源文件支持。cc、.cpp 等后缀
-  - **\*args, \*\*kwargs** (可选) - 用于指定 Extension 的其他参数，支持的参数与 ``setuptools.Extension`` 一致。
+  - **\*args, \*\*kwargs** (可选) - 用于指定 Extension 的其他参数，支持的参数与  ``setuptools.Extension``  一致。
 
 返回
 ::::::::::::
- ``setuptools.Extension`` 对象。
+  ``setuptools.Extension``  对象。
diff --git a/docs/api/paddle/utils/cpp_extension/get_build_directory_cn.rst b/docs/api/paddle/utils/cpp_extension/get_build_directory_cn.rst
index 693ddb63354..686185d0cbe 100644
--- a/docs/api/paddle/utils/cpp_extension/get_build_directory_cn.rst
+++ b/docs/api/paddle/utils/cpp_extension/get_build_directory_cn.rst
@@ -5,7 +5,7 @@ get_build_directory
 
 .. py:function:: paddle.utils.cpp_extension.get_build_directory()
 
-此接口返回编译自定义 OP 时生成动态链接库所在的 build 目录路径。此目录可以通过 ``export PADDLE_EXTENSION_DIR=XXX`` 来设置。若未设定，则默认使用 ``~/.cache/paddle_extension`` 作为 build 目录。
+此接口返回编译自定义 OP 时生成动态链接库所在的 build 目录路径。此目录可以通过  ``export PADDLE_EXTENSION_DIR=XXX``  来设置。若未设定，则默认使用  ``~/.cache/paddle_extension``  作为 build 目录。
 
 
 返回
diff --git a/docs/api/paddle/utils/cpp_extension/load_cn.rst b/docs/api/paddle/utils/cpp_extension/load_cn.rst
index f822879e897..ec9cccbc750 100644
--- a/docs/api/paddle/utils/cpp_extension/load_cn.rst
+++ b/docs/api/paddle/utils/cpp_extension/load_cn.rst
@@ -5,19 +5,19 @@ load
 
 .. py:function:: paddle.utils.cpp_extension.load(name, sources, extra_cxx_cflags=None, extra_cuda_cflags=None, extra_ldflags=None, extra_include_paths=None, build_directory=None, verbose=False)
 
-此接口将即时编译（Just-In-Time）传入的自定义 OP 对应的 cpp 和 cuda 源码文件，返回一个包含自定义算子 API 的 ``Module`` 对象。
+此接口将即时编译（Just-In-Time）传入的自定义 OP 对应的 cpp 和 cuda 源码文件，返回一个包含自定义算子 API 的  ``Module``  对象。
 
 其通过子进程的方式，在后台隐式地执行源码文件编译、符号链接、动态库生成、组网 API 接口生成等一系列过程。不需要本地预装 CMake 或者 Ninja 等工具命令，仅需必要的编译器命令环境，Linux 下需安装版本不低于 5.4 的 GCC，并软链到 `/usr/bin/cc` ，Windows 下需安装版本不低于 2017 的 Visual Studio；若编译支持 GPU 设备的算子，则需要提前安装 CUDA，其中自带 `nvcc` 编译环境。
 
-在编译前会执行 `ABI 兼容性检查 <https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html>`_ ，即检查编译器版本是否与本地安装的 Paddle 一致。如在 Linux 下，对于 CUDA 10.1 以上的 Paddle 默认使用 GCC 8.2 编译，则本地 ``cc`` 对应的编译器版本也需为 8.2，在 Windows 下，Paddle 使用 Visualt Studio 2017 编译，则本地也需安装
+在编译前会执行 `ABI 兼容性检查 <https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html>`_ ，即检查编译器版本是否与本地安装的 Paddle 一致。如在 Linux 下，对于 CUDA 10.1 以上的 Paddle 默认使用 GCC 8.2 编译，则本地  ``cc``  对应的编译器版本也需为 8.2，在 Windows 下，Paddle 使用 Visualt Studio 2017 编译，则本地也需安装
 大于 2017 的 Visual Studio，如果不满足，则可能由于 ABI 兼容性原因引发自定义 OP 编译或执行报错。Mac 下默认使用 clang 进行编译，无 ABI 兼容性问题。
 
-相对于 :ref:`cn_api_paddle_utils_cpp_extension_setup` 的方式，此接口不需要额外的 ``setup.py`` 文件和  ``python setup.py install`` 命令，``load``  接口包含了一键执行自定义 OP 的编译和加载的全部流程。
+相对于 :ref:`cn_api_paddle_utils_cpp_extension_setup` 的方式，此接口不需要额外的  ``setup.py``  文件和   ``python setup.py install``  命令， ``load``   接口包含了一键执行自定义 OP 的编译和加载的全部流程。
 
 .. note::
 
     1. 目前已支持 Linux ，MacOS 和 Windows 平台。
-    2. 编译器的 ABI 兼容性是向前兼容的，Linux 下推荐使用 GCC 8.2 高版本作为 ``/usr/bin/cc`` 命令的软链对象，可通过 ``which cc`` 查看 ``cc`` 命令的位置，使用 ``cc --version`` 查看对应的 GCC 版本。
+    2. 编译器的 ABI 兼容性是向前兼容的，Linux 下推荐使用 GCC 8.2 高版本作为  ``/usr/bin/cc``  命令的软链对象，可通过  ``which cc``  查看  ``cc``  命令的位置，使用  ``cc --version``  查看对应的 GCC 版本。
     3. Windows 下需要安装 Visual Studio 2017 及以上版本。
 
 
@@ -46,10 +46,10 @@ load
   - **name** (str) - 用于指定编译自定义 OP 时，生成的动态链接库的名字，不包括后缀如。so 或者。dll。
   - **sources** (list[str]) - 用于指定自定义 OP 对应的源码文件。cpp 源文件支持。cc、.cpp 等后缀；cuda 源文件以。cu 为后缀。
   - **extra_cxx_cflags** (list[str]，可选) - 用于指定编译 cpp 源文件时额外的编译选项。默认情况下，Paddle 框架相关的必要选项均已被隐式地包含；默认值为 None 。
-  - **extra_cuda_cflags** (list[str]，可选) - 用于指定编译 cuda 源文件时额外的编译选项。默认情况下，Paddle 框架相关的必要选项均已被隐式地包含；``nvcc`` 相关的编译选项请参考：`CUDA Compiler Driver NVCC <https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html>`_ 。默认值为 None 。
+  - **extra_cuda_cflags** (list[str]，可选) - 用于指定编译 cuda 源文件时额外的编译选项。默认情况下，Paddle 框架相关的必要选项均已被隐式地包含； ``nvcc``  相关的编译选项请参考：`CUDA Compiler Driver NVCC <https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html>`_ 。默认值为 None 。
   - **extra_ldflags** (list[str]，可选) - 用于指定编译自定义 OP 时额外的链接选项。GCC 支持的链接选项请参考：`GCC Link Options <https://gcc.gnu.org/onlinedocs/gcc/Link-Options.html>`_ 。默认值为 None 。
-  - **extra_include_paths** (list[str]，可选) - 用于指定编译 cpp 或 cuda 源文件时，额外的头文件搜索目录。默认情况下，Paddle 框架相关头文件所在目录 ``site-packages/paddle/include`` 已被隐式地包含。默认值为 None 。
-  - **build_directory** (str，可选) - 用于指定存放生成动态链接库的目录。若为 None，则会使用环境变量 ``PADDLE_EXTENSION_DIR`` 的值作为默认的存放目录。可使用 :ref:`cn_api_paddle_utils_cpp_extension_get_build_directory` 接口查看当前的目录设置。默认值为 None 。
+  - **extra_include_paths** (list[str]，可选) - 用于指定编译 cpp 或 cuda 源文件时，额外的头文件搜索目录。默认情况下，Paddle 框架相关头文件所在目录  ``site-packages/paddle/include``  已被隐式地包含。默认值为 None 。
+  - **build_directory** (str，可选) - 用于指定存放生成动态链接库的目录。若为 None，则会使用环境变量  ``PADDLE_EXTENSION_DIR``  的值作为默认的存放目录。可使用 :ref:`cn_api_paddle_utils_cpp_extension_get_build_directory` 接口查看当前的目录设置。默认值为 None 。
   - **verbose** (str，可选) - 用于指定是否需要输出编译过程中的日志信息，默认为 False。
 
 返回
diff --git a/docs/api/paddle/utils/cpp_extension/setup_cn.rst b/docs/api/paddle/utils/cpp_extension/setup_cn.rst
index 26e3182ba25..dbb904c2649 100644
--- a/docs/api/paddle/utils/cpp_extension/setup_cn.rst
+++ b/docs/api/paddle/utils/cpp_extension/setup_cn.rst
@@ -5,20 +5,20 @@ setup
 
 .. py:function:: paddle.utils.cpp_extension.setup(**attr)
 
-此接口用于配置如何编译自定义 OP 源文件，包括编译动态库，自动地生成 Python API 并以 Module 的形式安装到 site-packages 目录等过程。编译完成后，支持通过 ``import`` 语句导入使用。
+此接口用于配置如何编译自定义 OP 源文件，包括编译动态库，自动地生成 Python API 并以 Module 的形式安装到 site-packages 目录等过程。编译完成后，支持通过  ``import``  语句导入使用。
 
-此接口是对 Python 内建库中的 ``setuptools.setup`` 接口的进一步封装，支持的参数类型，以及使用方式均与原生接口保持一致。接口隐藏了 Paddle 框架内部概念，如默认需要指定的编译选项，头文件搜索目录，链接选项等；此接口会自动搜索和检查本地的 ``cc`` 和 ``nvcc`` 编译命令和版本环境，根据用户指定的 ``Extension`` 类型，完成支持 CPU 或 GPU 设备的算子编译。
+此接口是对 Python 内建库中的  ``setuptools.setup``  接口的进一步封装，支持的参数类型，以及使用方式均与原生接口保持一致。接口隐藏了 Paddle 框架内部概念，如默认需要指定的编译选项，头文件搜索目录，链接选项等；此接口会自动搜索和检查本地的  ``cc``  和  ``nvcc``  编译命令和版本环境，根据用户指定的  ``Extension``  类型，完成支持 CPU 或 GPU 设备的算子编译。
 
-同时，编译前会执行 `ABI 兼容性检查 <https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html>`_ ，即检查编译器版本是否与本地安装的 Paddle 一致。如在 Linux 下，对于 CUDA 10.1 以上的 Paddle 默认使用 GCC 8.2 编译，则本地 ``cc`` 对应的编译器版本也需为 8.2，在 Windows 下，Paddle 使用 Visualt Studio 2017 编译，则本地也需安装
+同时，编译前会执行 `ABI 兼容性检查 <https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html>`_ ，即检查编译器版本是否与本地安装的 Paddle 一致。如在 Linux 下，对于 CUDA 10.1 以上的 Paddle 默认使用 GCC 8.2 编译，则本地  ``cc``  对应的编译器版本也需为 8.2，在 Windows 下，Paddle 使用 Visualt Studio 2017 编译，则本地也需安装
 大于 2017 的 Visual Studio，如果不满足，则可能由于 ABI 兼容性原因引发自定义 OP 编译或执行报错。Mac 下默认使用 clang 进行编译，无 ABI 兼容性问题。
 
-相对于即时编译的 :ref:`cn_api_paddle_utils_cpp_extension_load` 接口，此接口仅需执行一次 ``python setup.py install`` 命令，即可像其他 python 库一样 import 导入使用。如下是一个 ``setup.py`` 文件的简单样例：
+相对于即时编译的 :ref:`cn_api_paddle_utils_cpp_extension_load` 接口，此接口仅需执行一次  ``python setup.py install``  命令，即可像其他 python 库一样 import 导入使用。如下是一个  ``setup.py``  文件的简单样例：
 
 
 .. note::
 
     1. 目前已支持 Linux ，MacOS 和 Windows 平台。
-    2. 编译器的 ABI 兼容性是向前兼容的，Linux 下推荐使用 GCC 8.2 高版本作为 ``/usr/bin/cc`` 命令的软链对象，可通过 ``which cc`` 查看 ``cc`` 命令的位置，使用 ``cc --version`` 查看对应的 GCC 版本。
+    2. 编译器的 ABI 兼容性是向前兼容的，Linux 下推荐使用 GCC 8.2 高版本作为  ``/usr/bin/cc``  命令的软链对象，可通过  ``which cc``  查看  ``cc``  命令的位置，使用  ``cc --version``  查看对应的 GCC 版本。
     3. Windows 下需要安装 Visual Studio 2017 及以上版本。
 
 .. code-block:: text
@@ -47,7 +47,7 @@ setup
 
 
 
-在源文件所在目录下执行 ``python setup.py install`` 即可完成自定义 OP 编译和 ``custom_op`` 库的安装。在组网时，可以通过如下方式使用：
+在源文件所在目录下执行  ``python setup.py install``  即可完成自定义 OP 编译和  ``custom_op``  库的安装。在组网时，可以通过如下方式使用：
 
 .. code-block:: text
 
@@ -63,11 +63,11 @@ setup
 参数
 ::::::::::::
 
-  - **name** (string) - 用于指定生成的动态链接库的名称，以及安装到 site-packages 的 ``Module`` 名字
-  - **ext_modules** (Extension) - 用于指定包含自定义 OP 必要源文件、编译选项等信息的 ``Extension``。若只编译运行在 CPU 设备上的 OP，请使用 :ref:`cn_api_paddle_utils_cpp_extension_CppExtension`；若编译同时支持 GPU 设备上的 OP，请使用 :ref:`cn_api_paddle_utils_cpp_extension_CUDAExtension` 。
-  - **include_dirs** (list[str]，可选) - 用于指定编译自定义 OP 时额外的头文件搜索目录。此接口默认会自动添加 ``site-packages/paddle/include`` 目录。若自定义 OP 源码引用了其他三方库文件，可以通过此参数指定三方库的搜索目录。默认值为 None 。
-  - **extra_compile_args** (list[str] | dict，可选) - 用于指定编译自定义 OP 时额外的编译选项，如 ``-O3`` 等。若为 ``list[str]`` 类型，则表示这些编译选项会同时应用到 ``cc`` 和 ``nvcc`` 编译过程；可以通过 ``{'cxx': [...], 'nvcc': [...]}`` 字典的形式单独指定额外的 ``cc`` 或 ``nvcc`` 的编译选项。默认值为 None 。
-  - **\*\*attr** (dict，可选) - 其他参数与 ``setuptools.setup`` 一致。
+  - **name** (string) - 用于指定生成的动态链接库的名称，以及安装到 site-packages 的  ``Module``  名字
+  - **ext_modules** (Extension) - 用于指定包含自定义 OP 必要源文件、编译选项等信息的  ``Extension`` 。若只编译运行在 CPU 设备上的 OP，请使用 :ref:`cn_api_paddle_utils_cpp_extension_CppExtension`；若编译同时支持 GPU 设备上的 OP，请使用 :ref:`cn_api_paddle_utils_cpp_extension_CUDAExtension` 。
+  - **include_dirs** (list[str]，可选) - 用于指定编译自定义 OP 时额外的头文件搜索目录。此接口默认会自动添加  ``site-packages/paddle/include``  目录。若自定义 OP 源码引用了其他三方库文件，可以通过此参数指定三方库的搜索目录。默认值为 None 。
+  - **extra_compile_args** (list[str] | dict，可选) - 用于指定编译自定义 OP 时额外的编译选项，如  ``-O3``  等。若为  ``list[str]``  类型，则表示这些编译选项会同时应用到  ``cc``  和  ``nvcc``  编译过程；可以通过  ``{'cxx': [...], 'nvcc': [...]}``  字典的形式单独指定额外的  ``cc``  或  ``nvcc``  的编译选项。默认值为 None 。
+  - **\*\*attr** (dict，可选) - 其他参数与  ``setuptools.setup``  一致。
 
 返回
 ::::::::::::
diff --git a/docs/api/paddle/utils/download/get_weights_path_from_url_cn.rst b/docs/api/paddle/utils/download/get_weights_path_from_url_cn.rst
index fa807141c1c..b32e603070b 100644
--- a/docs/api/paddle/utils/download/get_weights_path_from_url_cn.rst
+++ b/docs/api/paddle/utils/download/get_weights_path_from_url_cn.rst
@@ -5,7 +5,7 @@ get_weights_path_from_url
 
 .. py:function:: paddle.utils.download.get_weights_path_from_url(url, md5sum=None)
 
- 从 ``WEIGHT_HOME`` 文件夹获取权重，如果不存在，就从 url 下载。
+ 从  ``WEIGHT_HOME``  文件夹获取权重，如果不存在，就从 url 下载。
 
 参数
 ::::::::::::
diff --git a/docs/api/paddle/utils/require_version_cn.rst b/docs/api/paddle/utils/require_version_cn.rst
index d21db8e0c27..ea0c9fdf101 100644
--- a/docs/api/paddle/utils/require_version_cn.rst
+++ b/docs/api/paddle/utils/require_version_cn.rst
@@ -5,7 +5,7 @@ require_version
 
 .. py:function:: paddle.utils.require_version(min_version, max_version=None)
 
-检查 PaddlePaddle 的安装版本是否在区间 ``[min_version, max_version]`` 内，如果安装版本低于 min_version 或高于 max_version ，将抛出异常，如果安装版本满足则没有返回值。
+检查 PaddlePaddle 的安装版本是否在区间  ``[min_version, max_version]``  内，如果安装版本低于 min_version 或高于 max_version ，将抛出异常，如果安装版本满足则没有返回值。
 
 参数
 ::::::::::::
diff --git a/docs/api/paddle/vander_cn.rst b/docs/api/paddle/vander_cn.rst
index 5844caebf45..572f470eb8c 100644
--- a/docs/api/paddle/vander_cn.rst
+++ b/docs/api/paddle/vander_cn.rst
@@ -6,7 +6,7 @@ vander
 .. py:function:: paddle.vander(x, n=None, increasing=False, name=None)
 生成范德蒙德矩阵。
 
-输出矩阵的每一列都是输入向量的幂。 幂的顺序由递增的布尔参数确定。 具体而言，当递增为 ``false`` 时，第 i 个输出列是输入向量元素顺序的升序，其幂为 N-i-1。 每行都有等比级数的这样一个矩阵称为 Alexandre-Theophile Vandermonde 矩阵。
+输出矩阵的每一列都是输入向量的幂。 幂的顺序由递增的布尔参数确定。 具体而言，当递增为  ``false``  时，第 i 个输出列是输入向量元素顺序的升序，其幂为 N-i-1。 每行都有等比级数的这样一个矩阵称为 Alexandre-Theophile Vandermonde 矩阵。
 
 参数
 ::::::::::
diff --git a/docs/api/paddle/var_cn.rst b/docs/api/paddle/var_cn.rst
index b63c7e5e301..9f9d8ac6017 100644
--- a/docs/api/paddle/var_cn.rst
+++ b/docs/api/paddle/var_cn.rst
@@ -5,32 +5,32 @@ var
 
 .. py:function:: paddle.var(x, axis=None, unbiased=True, keepdim=False, name=None, *, correction=1, out=None)
 
-沿给定的轴 ``axis`` 计算 ``x`` 中元素的方差。
+沿给定的轴  ``axis``  计算  ``x``  中元素的方差。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x`` 和 ``dim`` 可替代 ``axis``，如 ``input=tensor_x`` 等价于 ``x=tensor_x``， ``dim=1`` 等价于 ``axis=1``。
+    别名支持: 参数名  ``input``  可替代  ``x``  和  ``dim``  可替代  ``axis`` ，如  ``input=tensor_x``  等价于  ``x=tensor_x`` ，  ``dim=1``  等价于  ``axis=1`` 。
 
 参数
 ::::::::::
    - **x** (Tensor) - 输入的 Tensor，数据类型为：float16、float32、float64。
-     别名： ``input``
-   - **axis** (int|list|tuple，可选) - 指定对 ``x`` 进行计算的轴。``axis`` 可以是 int、list(int)、tuple(int)。
-     ``别名：dim``
+     别名：  ``input`` 
+   - **axis** (int|list|tuple，可选) - 指定对  ``x``  进行计算的轴。 ``axis``  可以是 int、list(int)、tuple(int)。
+      ``别名：dim`` 
 
-      - 如果 ``axis`` 包含多个维度，则沿着 ``axis`` 中的所有轴进行计算。``axis`` 或者其中的元素值应该在范围[-D, D)内，D 是 ``x`` 的维度。
-      - 如果 ``axis`` 或者其中的元素值小于 0，则等价于 :math:`axis + D` 。
-      - 如果 ``axis`` 是 None，则对 ``x`` 的全部元素计算方差。默认值为 None。
+      - 如果  ``axis``  包含多个维度，则沿着  ``axis``  中的所有轴进行计算。 ``axis``  或者其中的元素值应该在范围[-D, D)内，D 是  ``x``  的维度。
+      - 如果  ``axis``  或者其中的元素值小于 0，则等价于 :math:`axis + D` 。
+      - 如果  ``axis``  是 None，则对  ``x``  的全部元素计算方差。默认值为 None。
 
-   - **unbiased** (bool，可选) - 是否使用无偏估计来计算方差。使用 :math:`N` 来代表在 axis 上的维度，如果 ``unbiased`` 为 True，则在计算中使用 :math:`N - 1` 作为除数。为 False 时将使用 :math:`N` 作为除数。默认值为 True。
+   - **unbiased** (bool，可选) - 是否使用无偏估计来计算方差。使用 :math:`N` 来代表在 axis 上的维度，如果  ``unbiased``  为 True，则在计算中使用 :math:`N - 1` 作为除数。为 False 时将使用 :math:`N` 作为除数。默认值为 True。
    - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留输入的维度。除非 keepdim 为 True，否则输出 Tensor 的维度将比输入 Tensor 小一维，默认值为 False。
-     别名： ``dim``
+     别名：  ``dim`` 
    - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
    - **correction** (int|float，可选) - 样本数量与样本自由度之间的差异。该参数为仅关键字参数，默认值为 1（贝塞尔校正）。
    - **out** (Tensor，可选)- 输出的结果。该参数为仅关键字参数，默认值为 None。
 
 返回
 ::::::::::
-    ``Tensor``，沿着 ``axis`` 进行方差计算的结果，数据类型和 ``x`` 相同。
+     ``Tensor`` ，沿着  ``axis``  进行方差计算的结果，数据类型和  ``x``  相同。
 
 代码示例
 ::::::::::
diff --git a/docs/api/paddle/version/cuda_cn.rst b/docs/api/paddle/version/cuda_cn.rst
index 0d6acf76406..efce965959f 100644
--- a/docs/api/paddle/version/cuda_cn.rst
+++ b/docs/api/paddle/version/cuda_cn.rst
@@ -11,7 +11,7 @@ cuda
 返回
 ::::::::::
 
-若 paddle wheel 包为 GPU 版本，则返回 paddle wheel 包编译时使用的 CUDA 的版本信息；若 paddle wheel 包为 CPU 版本，则返回 ``False`` 。
+若 paddle wheel 包为 GPU 版本，则返回 paddle wheel 包编译时使用的 CUDA 的版本信息；若 paddle wheel 包为 CPU 版本，则返回  ``False``  。
 
 代码示例：
 ::::::::::
diff --git a/docs/api/paddle/version/cudnn_cn.rst b/docs/api/paddle/version/cudnn_cn.rst
index 0ca863a109b..77442b962a1 100644
--- a/docs/api/paddle/version/cudnn_cn.rst
+++ b/docs/api/paddle/version/cudnn_cn.rst
@@ -11,7 +11,7 @@ cudnn
 返回
 :::::::::
 
-若 paddle wheel 包为 GPU 版本，则返回 paddle wheel 包编译时使用的 cuDNN 的版本信息；若 paddle wheel 包为 CPU 版本，则返回 ``False`` 。
+若 paddle wheel 包为 GPU 版本，则返回 paddle wheel 包编译时使用的 cuDNN 的版本信息；若 paddle wheel 包为 CPU 版本，则返回  ``False``  。
 
 代码示例：
 ::::::::::
diff --git a/docs/api/paddle/version/nccl_cn.rst b/docs/api/paddle/version/nccl_cn.rst
index ea5c854e60f..06a9bb9ae91 100644
--- a/docs/api/paddle/version/nccl_cn.rst
+++ b/docs/api/paddle/version/nccl_cn.rst
@@ -11,7 +11,7 @@ nccl
 返回
 :::::::::
 
-若 paddle wheel 包为 GPU 版本，则返回 paddle wheel 包编译时使用的 nccl 的版本信息；若 paddle wheel 包为 CPU 版本，则返回 ``False`` 。
+若 paddle wheel 包为 GPU 版本，则返回 paddle wheel 包编译时使用的 nccl 的版本信息；若 paddle wheel 包为 CPU 版本，则返回  ``False``  。
 
 代码示例：
 ::::::::::
diff --git a/docs/api/paddle/version/show_cn.rst b/docs/api/paddle/version/show_cn.rst
index 3d3d152b5d5..a2d39840372 100644
--- a/docs/api/paddle/version/show_cn.rst
+++ b/docs/api/paddle/version/show_cn.rst
@@ -19,8 +19,8 @@ show
     - minor - paddle wheel 包版本号的 minor 信息。
     - patch - paddle wheel 包版本号的 patch 信息。
     - rc - 是否是 rc 版本。
-    - cuda - 若 paddle wheel 包为 GPU 版本，则返回 paddle wheel 包编译时使用的 CUDA 的版本信息；若 paddle wheel 包为 CPU 版本，则返回 ``False`` 。
-    - cudnn - 若 paddle wheel 包为 GPU 版本，则返回 paddle wheel 包编译时使用的 cuDNN 的版本信息；若 paddle wheel 包为 CPU 版本，则返回 ``False`` 。
+    - cuda - 若 paddle wheel 包为 GPU 版本，则返回 paddle wheel 包编译时使用的 CUDA 的版本信息；若 paddle wheel 包为 CPU 版本，则返回  ``False``  。
+    - cudnn - 若 paddle wheel 包为 GPU 版本，则返回 paddle wheel 包编译时使用的 cuDNN 的版本信息；若 paddle wheel 包为 CPU 版本，则返回  ``False``  。
     - tensorrt - 返回 paddle 安装包编译时使用的 TensorRT 版本号，若无安装 TensorRT, 则返回 None 。
     - cuda_archs - 返回 paddle 安装包编译时的 CUDA 架构列表。
 
diff --git a/docs/api/paddle/version/xpu_cn.rst b/docs/api/paddle/version/xpu_cn.rst
index 69d76e1e13b..f619b0c4dc5 100644
--- a/docs/api/paddle/version/xpu_cn.rst
+++ b/docs/api/paddle/version/xpu_cn.rst
@@ -11,7 +11,7 @@ xpu
 返回
 ::::::::::
 
-若 paddle wheel 包为 XPU 版本，则返回 paddle wheel 包编译时使用的 XPU 的版本信息；若 paddle wheel 包为 非 XPU 版本，则返回 ``False`` 。
+若 paddle wheel 包为 XPU 版本，则返回 paddle wheel 包编译时使用的 XPU 的版本信息；若 paddle wheel 包为 非 XPU 版本，则返回  ``False``  。
 
 代码示例：
 ::::::::::
diff --git a/docs/api/paddle/version/xpu_xccl_cn.rst b/docs/api/paddle/version/xpu_xccl_cn.rst
index 9a711ce23a5..1b7ba9879cf 100644
--- a/docs/api/paddle/version/xpu_xccl_cn.rst
+++ b/docs/api/paddle/version/xpu_xccl_cn.rst
@@ -10,7 +10,7 @@ xpu_xccl
 返回
 ::::::::::
 
-若 paddle wheel 包为 XPU 版本，则返回 paddle wheel 包编译时使用的 XPU xccl 版本信息；若 paddle wheel 包为 非 XPU 版本，则返回 ``False`` 。
+若 paddle wheel 包为 XPU 版本，则返回 paddle wheel 包编译时使用的 XPU xccl 版本信息；若 paddle wheel 包为 非 XPU 版本，则返回  ``False``  。
 
 代码示例：
 ::::::::::
diff --git a/docs/api/paddle/view_as_complex_cn.rst b/docs/api/paddle/view_as_complex_cn.rst
index 64ceec01ac6..7c53edcab1f 100644
--- a/docs/api/paddle/view_as_complex_cn.rst
+++ b/docs/api/paddle/view_as_complex_cn.rst
@@ -6,11 +6,11 @@ view_as_complex
 .. py:function:: paddle.view_as_complex(input)
 
 
-获取实数张量 ``input`` 的一个视图，将其视为一个复数张量。
+获取实数张量  ``input``  的一个视图，将其视为一个复数张量。
 
 输入 Tensor 的数据类型是 'float32' 或者 'float64'，输出 Tensor 的数据类型相应为 'complex64' 或者 'complex128'。
 
-输入 Tensor 的形状是 ``(*, 2)`` (其中 ``*`` 表示任意形状)，亦即，输入的最后一维的大小必须是 2，这对应着复数的实部和虚部。输出 Tensor 的形状是 ``(*,)``。
+输入 Tensor 的形状是  ``(*, 2)``  (其中  ``*``  表示任意形状)，亦即，输入的最后一维的大小必须是 2，这对应着复数的实部和虚部。输出 Tensor 的形状是  ``(*,)`` 。
 
 下图展示了一个 view_as_complex 简单的使用情形。一个形状为[2, 3, 2]的实数 Tensor 经过 view_as_complex 转换，最后一个长度为 2 的维度被合并为复数，形状变为[2, 3]。
 
@@ -26,7 +26,7 @@ view_as_complex
 
 返回
 :::::::::
-输出 Tensor，数据类型是 'complex64' 或 'complex128'，与 ``input`` 的数值精度一致。
+输出 Tensor，数据类型是 'complex64' 或 'complex128'，与  ``input``  的数值精度一致。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/view_as_real_cn.rst b/docs/api/paddle/view_as_real_cn.rst
index c3ccc05a1c6..b740993f01f 100644
--- a/docs/api/paddle/view_as_real_cn.rst
+++ b/docs/api/paddle/view_as_real_cn.rst
@@ -6,11 +6,11 @@ view_as_real
 .. py:function:: paddle.view_as_real(input)
 
 
-获取复数张量 ``input`` 的一个视图，将其视为一个实数张量。
+获取复数张量  ``input``  的一个视图，将其视为一个实数张量。
 
 输入 Tensor 的数据类型是 'complex64' 或者 'complex128'，输出 Tensor 的数据类型相应为 'float32' 或者 'float64'。
 
-输入 Tensor 的形状是 ``(*,)`` (其中 ``*`` 表示任意形状)，输出 Tensor 的形状是 ``(*, 2)``，亦即，输出的形状是在输入形状后附加一个 ``2``，因为一个复数的实部和虚部分别表示为一个实数。
+输入 Tensor 的形状是  ``(*,)``  (其中  ``*``  表示任意形状)，输出 Tensor 的形状是  ``(*, 2)`` ，亦即，输出的形状是在输入形状后附加一个  ``2`` ，因为一个复数的实部和虚部分别表示为一个实数。
 
 返回的实数张量是输入复数张量的一个视图，这意味着二者共享同一块内存区域。
 
@@ -27,7 +27,7 @@ view_as_real
 
 返回
 :::::::::
-输出 Tensor，数据类型是 'float32' 或 'float64'，与 ``input`` 共享同一块内存区域。
+输出 Tensor，数据类型是 'float32' 或 'float64'，与  ``input``  共享同一块内存区域。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/view_cn.rst b/docs/api/paddle/view_cn.rst
index 3cd12d9e24b..f292596c5b2 100644
--- a/docs/api/paddle/view_cn.rst
+++ b/docs/api/paddle/view_cn.rst
@@ -10,19 +10,19 @@ view
 仅在动态图下可用，返回的 Tensor 和 x 共享内存。
 
 .. note::
-    别名支持: 参数名 ``size`` 和 ``dtype`` 可替代 ``shape_or_dtype``。
-    ``shape_or_dtype`` 支持可变参数类型。
+    别名支持: 参数名  ``size``  和  ``dtype``  可替代  ``shape_or_dtype`` 。
+     ``shape_or_dtype``  支持可变参数类型。
     使用实例：
-        ``tensor_x.view(dtype=paddle.float32)``
-        ``tensor_x.view(size=[-1, 1, 3])``
-        ``tensor_x.view(-1, 1, 3)``
+         ``tensor_x.view(dtype=paddle.float32)`` 
+         ``tensor_x.view(size=[-1, 1, 3])`` 
+         ``tensor_x.view(-1, 1, 3)`` 
 
 参数
 :::::::::
 
     - **x** (Tensor) - 输入多维 Tensor，可选的数据类型为 'float16'、'float32'、'float64'、'int16'、'int32'、'int64'、'bool'、'uint16'。
     - **shape_or_dtype** (list|tuple|np.dtype|str|VarType) - 指定的新的 shape 或者 dtype。如果是 list 或者 tuple，则代表 shape，否则代表 dtype。
-      别名： ``size`` 和 ``dtype``
+      别名：  ``size``  和  ``dtype`` 
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/vision/datasets/Cifar100_cn.rst b/docs/api/paddle/vision/datasets/Cifar100_cn.rst
index f4d04e9b7b1..99382247b85 100644
--- a/docs/api/paddle/vision/datasets/Cifar100_cn.rst
+++ b/docs/api/paddle/vision/datasets/Cifar100_cn.rst
@@ -11,11 +11,11 @@ Cifar100
 参数
 :::::::::
 
-  - **data_file** (str，可选) - 数据集文件路径，如果 ``download`` 参数设置为 ``True``，``data_file`` 参数可以设置为 ``None``。默认值为 ``None``，默认存放在：``~/.cache/paddle/dataset/cifar``。
-  - **mode** (str，可选) - ``'train'`` 或 ``'test'`` 模式两者之一，默认值为 ``'train'``。
-  - **transform** (Callable，可选) - 图片数据的预处理，若为 ``None`` 即为不做预处理。默认值为 ``None``。
-  - **download** (bool，可选) - 当 ``data_file`` 是 ``None`` 时，该参数决定是否自动下载数据集文件。默认值为 ``True``。
-  - **backend** (str，可选) - 指定要返回的图像类型：PIL.Image 或 numpy.ndarray。必须是 {'pil'，'cv2'} 中的值。如果未设置此选项，将从 :ref:`paddle.vision.get_image_backend <cn_api_paddle_vision_get_image_backend>` 获得这个值。默认值为 ``None``。
+  - **data_file** (str，可选) - 数据集文件路径，如果  ``download``  参数设置为  ``True`` ， ``data_file``  参数可以设置为  ``None`` 。默认值为  ``None`` ，默认存放在： ``~/.cache/paddle/dataset/cifar`` 。
+  - **mode** (str，可选) -  ``'train'``  或  ``'test'``  模式两者之一，默认值为  ``'train'`` 。
+  - **transform** (Callable，可选) - 图片数据的预处理，若为  ``None``  即为不做预处理。默认值为  ``None`` 。
+  - **download** (bool，可选) - 当  ``data_file``  是  ``None``  时，该参数决定是否自动下载数据集文件。默认值为  ``True`` 。
+  - **backend** (str，可选) - 指定要返回的图像类型：PIL.Image 或 numpy.ndarray。必须是 {'pil'，'cv2'} 中的值。如果未设置此选项，将从 :ref:`paddle.vision.get_image_backend <cn_api_paddle_vision_get_image_backend>` 获得这个值。默认值为  ``None`` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/vision/datasets/Cifar10_cn.rst b/docs/api/paddle/vision/datasets/Cifar10_cn.rst
index 78451d15f33..ff7139d818e 100644
--- a/docs/api/paddle/vision/datasets/Cifar10_cn.rst
+++ b/docs/api/paddle/vision/datasets/Cifar10_cn.rst
@@ -11,11 +11,11 @@ Cifar10
 参数
 :::::::::
 
-  - **data_file** (str，可选) - 数据集文件路径，如果 ``download`` 参数设置为 ``True``，``data_file`` 参数可以设置为 ``None``。默认值为 ``None``，默认存放在：``~/.cache/paddle/dataset/cifar``。
-  - **mode** (str，可选) - ``'train'`` 或 ``'test'`` 模式两者之一，默认值为 ``'train'``。
-  - **transform** (Callable，可选) - 图片数据的预处理，若为 ``None`` 即为不做预处理。默认值为 ``None``。
-  - **download** (bool，可选) - 当 ``data_file`` 是 ``None`` 时，该参数决定是否自动下载数据集文件。默认值为 ``True``。
-  - **backend** (str，可选) - 指定要返回的图像类型：PIL.Image 或 numpy.ndarray。必须是 {'pil'，'cv2'} 中的值。如果未设置此选项，将从 :ref:`paddle.vision.get_image_backend <cn_api_paddle_vision_get_image_backend>` 获得这个值。默认值为 ``None``。
+  - **data_file** (str，可选) - 数据集文件路径，如果  ``download``  参数设置为  ``True`` ， ``data_file``  参数可以设置为  ``None`` 。默认值为  ``None`` ，默认存放在： ``~/.cache/paddle/dataset/cifar`` 。
+  - **mode** (str，可选) -  ``'train'``  或  ``'test'``  模式两者之一，默认值为  ``'train'`` 。
+  - **transform** (Callable，可选) - 图片数据的预处理，若为  ``None``  即为不做预处理。默认值为  ``None`` 。
+  - **download** (bool，可选) - 当  ``data_file``  是  ``None``  时，该参数决定是否自动下载数据集文件。默认值为  ``True`` 。
+  - **backend** (str，可选) - 指定要返回的图像类型：PIL.Image 或 numpy.ndarray。必须是 {'pil'，'cv2'} 中的值。如果未设置此选项，将从 :ref:`paddle.vision.get_image_backend <cn_api_paddle_vision_get_image_backend>` 获得这个值。默认值为  ``None`` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/vision/datasets/DatasetFolder_cn.rst b/docs/api/paddle/vision/datasets/DatasetFolder_cn.rst
index e704b7c3354..2fe5ce9f12c 100644
--- a/docs/api/paddle/vision/datasets/DatasetFolder_cn.rst
+++ b/docs/api/paddle/vision/datasets/DatasetFolder_cn.rst
@@ -23,10 +23,10 @@ DatasetFolder
 ::::::::::::
 
   - **root** (str) - 根目录路径。
-  - **loader** (Callable，可选) - 可以加载数据路径的一个函数，如果该值没有设定，默认使用 ``cv2.imread``。默认值为 None。
-  - **extensions** (list[str]|tuple[str]，可选) - 允许的数据后缀列表，``extensions`` 和 ``is_valid_file`` 不可以同时设置。如果该值没有设定，默认为 ``('.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif', '.tiff', '.webp')``。默认值为 None。
-  - **transform** (Callable，可选) - 图片数据的预处理，若为 ``None`` 即为不做预处理。默认值为 ``None``。
-  - **is_valid_file** (Callable，可选) - 根据每条数据的路径来判断是否合法的一个函数。``extensions`` 和 ``is_valid_file`` 不可以同时设置。默认值为 None。
+  - **loader** (Callable，可选) - 可以加载数据路径的一个函数，如果该值没有设定，默认使用  ``cv2.imread`` 。默认值为 None。
+  - **extensions** (list[str]|tuple[str]，可选) - 允许的数据后缀列表， ``extensions``  和  ``is_valid_file``  不可以同时设置。如果该值没有设定，默认为  ``('.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif', '.tiff', '.webp')`` 。默认值为 None。
+  - **transform** (Callable，可选) - 图片数据的预处理，若为  ``None``  即为不做预处理。默认值为  ``None`` 。
+  - **is_valid_file** (Callable，可选) - 根据每条数据的路径来判断是否合法的一个函数。 ``extensions``  和  ``is_valid_file``  不可以同时设置。默认值为 None。
 
 返回
 :::::::::
@@ -38,7 +38,7 @@ DatasetFolder
 
   - **classes** (list[str]) - 包含全部类名的列表。
   - **class_to_idx** (dict[str, int]) - 类名到类别索引号的映射字典。
-  - **samples** (list[tuple[str, int]]) - 一个列表，其中每项为 ``(样本路径, 类别索引号)`` 形式的元组。
+  - **samples** (list[tuple[str, int]]) - 一个列表，其中每项为  ``(样本路径, 类别索引号)``  形式的元组。
   - **targets** (list[int]) - 数据集中各个图片的类别索引号列表。
 
 代码示例
diff --git a/docs/api/paddle/vision/datasets/FashionMNIST_cn.rst b/docs/api/paddle/vision/datasets/FashionMNIST_cn.rst
index 023e7c22399..963d30ce669 100644
--- a/docs/api/paddle/vision/datasets/FashionMNIST_cn.rst
+++ b/docs/api/paddle/vision/datasets/FashionMNIST_cn.rst
@@ -11,12 +11,12 @@ FashionMNIST
 参数
 :::::::::
 
-  - **image_path** (str，可选) - 图像文件路径，如果 ``download`` 参数设置为 ``True``，``image_path`` 参数可以设置为 ``None``。默认值为 ``None``，默认存放在：``~/.cache/paddle/dataset/fashion-mnist``。
-  - **label_path** (str，可选) - 标签文件路径，如果 ``download`` 参数设置为 ``True``，``label_path`` 参数可以设置为 ``None``。默认值为 ``None``，默认存放在：``~/.cache/paddle/dataset/fashion-mnist``。
-  - **mode** (str，可选) - ``'train'`` 或 ``'test'`` 模式两者之一，默认值为 ``'train'``。
-  - **transform** (Callable，可选) - 图片数据的预处理，若为 ``None`` 即为不做预处理。默认值为 ``None``。
-  - **download** (bool，可选) - 当 ``data_file`` 是 ``None`` 时，该参数决定是否自动下载数据集文件。默认值为  ``True``。
-  - **backend** (str，可选) - 指定要返回的图像类型：PIL.Image 或 numpy.ndarray。必须是 {'pil'，'cv2'} 中的值。如果未设置此选项，将从 :ref:`paddle.vision.get_image_backend <cn_api_paddle_vision_get_image_backend>` 获得这个值。默认值为   ``None``。
+  - **image_path** (str，可选) - 图像文件路径，如果  ``download``  参数设置为  ``True`` ， ``image_path``  参数可以设置为  ``None`` 。默认值为  ``None`` ，默认存放在： ``~/.cache/paddle/dataset/fashion-mnist`` 。
+  - **label_path** (str，可选) - 标签文件路径，如果  ``download``  参数设置为  ``True`` ， ``label_path``  参数可以设置为  ``None`` 。默认值为  ``None`` ，默认存放在： ``~/.cache/paddle/dataset/fashion-mnist`` 。
+  - **mode** (str，可选) -  ``'train'``  或  ``'test'``  模式两者之一，默认值为  ``'train'`` 。
+  - **transform** (Callable，可选) - 图片数据的预处理，若为  ``None``  即为不做预处理。默认值为  ``None`` 。
+  - **download** (bool，可选) - 当  ``data_file``  是  ``None``  时，该参数决定是否自动下载数据集文件。默认值为   ``True`` 。
+  - **backend** (str，可选) - 指定要返回的图像类型：PIL.Image 或 numpy.ndarray。必须是 {'pil'，'cv2'} 中的值。如果未设置此选项，将从 :ref:`paddle.vision.get_image_backend <cn_api_paddle_vision_get_image_backend>` 获得这个值。默认值为    ``None`` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/vision/datasets/Flowers_cn.rst b/docs/api/paddle/vision/datasets/Flowers_cn.rst
index d2523d2b5bd..8ed1642bda5 100644
--- a/docs/api/paddle/vision/datasets/Flowers_cn.rst
+++ b/docs/api/paddle/vision/datasets/Flowers_cn.rst
@@ -11,13 +11,13 @@ Flowers
 参数
 :::::::::
 
-  - **data_file** (str，可选) - 数据文件路径，如果 ``download`` 参数设置为 ``True``， ``data_file`` 参数可以设置为 ``None``。默认值为 ``None``，默认存放在：``~/.cache/paddle/dataset/flowers``。
-  - **label_file** (str，可选) - 标签文件路径，如果 ``download`` 参数设置为 ``True``， ``label_file`` 参数可以设置为 ``None``。默认值为 ``None``，默认存放在：``~/.cache/paddle/dataset/flowers``。
-  - **setid_file** (str，可选) - 子数据集下标划分文件路径，如果 ``download`` 参数设置为 ``True`` ， ``setid_file`` 参数可以设置为 ``None``。默认值为 ``None``，默认存放在：``~/.cache/paddle/dataset/flowers``。
-  - **mode** (str，可选) - ``'train'`` 或 ``'test'`` 模式两者之一，默认值为 ``'train'``。
-  - **transform** (Callable，可选) - 图片数据的预处理，若为 ``None`` 即为不做预处理。默认值为 ``None``。
-  - **download** (bool，可选) - 当 ``data_file`` 是 ``None`` 时，该参数决定是否自动下载数据集文件。默认值为 ``True``。
-  - **backend** (str，可选) - 指定要返回的图像类型：PIL.Image 或 numpy.ndarray。必须是 {'pil'，'cv2'} 中的值。如果未设置此选项，将从 :ref:`paddle.vision.get_image_backend <cn_api_paddle_vision_get_image_backend>` 获得这个值。默认值为 ``None``。
+  - **data_file** (str，可选) - 数据文件路径，如果  ``download``  参数设置为  ``True`` ，  ``data_file``  参数可以设置为  ``None`` 。默认值为  ``None`` ，默认存放在： ``~/.cache/paddle/dataset/flowers`` 。
+  - **label_file** (str，可选) - 标签文件路径，如果  ``download``  参数设置为  ``True`` ，  ``label_file``  参数可以设置为  ``None`` 。默认值为  ``None`` ，默认存放在： ``~/.cache/paddle/dataset/flowers`` 。
+  - **setid_file** (str，可选) - 子数据集下标划分文件路径，如果  ``download``  参数设置为  ``True``  ，  ``setid_file``  参数可以设置为  ``None`` 。默认值为  ``None`` ，默认存放在： ``~/.cache/paddle/dataset/flowers`` 。
+  - **mode** (str，可选) -  ``'train'``  或  ``'test'``  模式两者之一，默认值为  ``'train'`` 。
+  - **transform** (Callable，可选) - 图片数据的预处理，若为  ``None``  即为不做预处理。默认值为  ``None`` 。
+  - **download** (bool，可选) - 当  ``data_file``  是  ``None``  时，该参数决定是否自动下载数据集文件。默认值为  ``True`` 。
+  - **backend** (str，可选) - 指定要返回的图像类型：PIL.Image 或 numpy.ndarray。必须是 {'pil'，'cv2'} 中的值。如果未设置此选项，将从 :ref:`paddle.vision.get_image_backend <cn_api_paddle_vision_get_image_backend>` 获得这个值。默认值为  ``None`` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/vision/datasets/ImageFolder_cn.rst b/docs/api/paddle/vision/datasets/ImageFolder_cn.rst
index 43a35912603..34bbbc5d179 100644
--- a/docs/api/paddle/vision/datasets/ImageFolder_cn.rst
+++ b/docs/api/paddle/vision/datasets/ImageFolder_cn.rst
@@ -19,10 +19,10 @@ ImageFolder
 ::::::::::::
 
   - **root** (str) - 根目录路径。
-  - **loader** (Callable，可选) - 可以加载数据路径的一个函数，如果该值没有设定，默认使用 ``cv2.imread``。默认值为 None。
-  - **extensions** (list[str]|tuple[str]，可选) - 允许的数据后缀列表，``extensions`` 和 ``is_valid_file`` 不可以同时设置。如果该值没有设定，默认为 ``('.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif', '.tiff', '.webp')``。默认值为 None。
-  - **transform** (Callable，可选) - 图片数据的预处理，若为 ``None`` 即为不做预处理。默认值为 ``None``。
-  - **is_valid_file** (Callable，可选) - 根据每条数据的路径来判断是否合法的一个函数。``extensions`` 和 ``is_valid_file`` 不可以同时设置。默认值为  None。
+  - **loader** (Callable，可选) - 可以加载数据路径的一个函数，如果该值没有设定，默认使用  ``cv2.imread`` 。默认值为 None。
+  - **extensions** (list[str]|tuple[str]，可选) - 允许的数据后缀列表， ``extensions``  和  ``is_valid_file``  不可以同时设置。如果该值没有设定，默认为  ``('.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif', '.tiff', '.webp')`` 。默认值为 None。
+  - **transform** (Callable，可选) - 图片数据的预处理，若为  ``None``  即为不做预处理。默认值为  ``None`` 。
+  - **is_valid_file** (Callable，可选) - 根据每条数据的路径来判断是否合法的一个函数。 ``extensions``  和  ``is_valid_file``  不可以同时设置。默认值为  None。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/vision/datasets/MNIST_cn.rst b/docs/api/paddle/vision/datasets/MNIST_cn.rst
index e73c466a3bf..fa872c5f178 100644
--- a/docs/api/paddle/vision/datasets/MNIST_cn.rst
+++ b/docs/api/paddle/vision/datasets/MNIST_cn.rst
@@ -11,12 +11,12 @@ MNIST
 参数
 :::::::::
 
-  - **image_path** (str，可选) - 图像文件路径，如果 ``download`` 参数设置为 ``True``，``image_path`` 参数可以设置为 ``None``。默认值为 ``None``，默认存放在：``~/.cache/paddle/dataset/mnist``。
-  - **label_path** (str，可选) - 标签文件路径，如果 ``download`` 参数设置为 ``True``，``label_path`` 参数可以设置为 ``None``。默认值为 ``None``，默认存放在：``~/.cache/paddle/dataset/mnist``。
-  - **mode** (str，可选) - ``'train'`` 或 ``'test'`` 模式两者之一，默认值为 ``'train'``。
-  - **transform** (Callable，可选) - 图片数据的预处理，若为 ``None`` 即为不做预处理。默认值为 ``None``。
-  - **download** (bool，可选) - 当 ``data_file`` 是 ``None`` 时，该参数决定是否自动下载数据集文件。默认值为 ``True``。
-  - **backend** (str，可选) - 指定要返回的图像类型：PIL.Image 或 numpy.ndarray。必须是 {'pil'，'cv2'} 中的值。如果未设置此选项，将从 :ref:`paddle.vision.get_image_backend <cn_api_paddle_vision_get_image_backend>` 获得这个值。默认值为 ``None``。
+  - **image_path** (str，可选) - 图像文件路径，如果  ``download``  参数设置为  ``True`` ， ``image_path``  参数可以设置为  ``None`` 。默认值为  ``None`` ，默认存放在： ``~/.cache/paddle/dataset/mnist`` 。
+  - **label_path** (str，可选) - 标签文件路径，如果  ``download``  参数设置为  ``True`` ， ``label_path``  参数可以设置为  ``None`` 。默认值为  ``None`` ，默认存放在： ``~/.cache/paddle/dataset/mnist`` 。
+  - **mode** (str，可选) -  ``'train'``  或  ``'test'``  模式两者之一，默认值为  ``'train'`` 。
+  - **transform** (Callable，可选) - 图片数据的预处理，若为  ``None``  即为不做预处理。默认值为  ``None`` 。
+  - **download** (bool，可选) - 当  ``data_file``  是  ``None``  时，该参数决定是否自动下载数据集文件。默认值为  ``True`` 。
+  - **backend** (str，可选) - 指定要返回的图像类型：PIL.Image 或 numpy.ndarray。必须是 {'pil'，'cv2'} 中的值。如果未设置此选项，将从 :ref:`paddle.vision.get_image_backend <cn_api_paddle_vision_get_image_backend>` 获得这个值。默认值为  ``None`` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/vision/datasets/VOC2012_cn.rst b/docs/api/paddle/vision/datasets/VOC2012_cn.rst
index ecf274fd9ad..58a8b66cade 100644
--- a/docs/api/paddle/vision/datasets/VOC2012_cn.rst
+++ b/docs/api/paddle/vision/datasets/VOC2012_cn.rst
@@ -11,11 +11,11 @@ VOC2012
 参数
 :::::::::
 
-  - **data_file** (str，可选) - 数据集文件路径，如果 ``download`` 参数设置为 ``True``， ``data_file`` 参数可以设置为 ``None``。默认值为 ``None``，默认存放在：``~/.cache/paddle/dataset/voc2012``。
-  - **mode** (str，可选) - ``'train'`` 或 ``'test'`` 模式两者之一，默认值为 ``'train'``。
-  - **transform** (Callable，可选) - 图片数据的预处理，若为 ``None`` 即为不做预处理。默认值为 ``None``。
-  - **download** (bool，可选) - 当 ``data_file`` 是 ``None`` 时，该参数决定是否自动下载数据集文件。默认值为 ``True``。
-  - **backend** (str，可选) - 指定要返回的图像类型：PIL.Image 或 numpy.ndarray。必须是 {'pil'，'cv2'} 中的值。如果未设置此选项，将从 :ref:`paddle.vision.get_image_backend <cn_api_paddle_vision_get_image_backend>` 获得这个值。默认值为 ``None``。
+  - **data_file** (str，可选) - 数据集文件路径，如果  ``download``  参数设置为  ``True`` ，  ``data_file``  参数可以设置为  ``None`` 。默认值为  ``None`` ，默认存放在： ``~/.cache/paddle/dataset/voc2012`` 。
+  - **mode** (str，可选) -  ``'train'``  或  ``'test'``  模式两者之一，默认值为  ``'train'`` 。
+  - **transform** (Callable，可选) - 图片数据的预处理，若为  ``None``  即为不做预处理。默认值为  ``None`` 。
+  - **download** (bool，可选) - 当  ``data_file``  是  ``None``  时，该参数决定是否自动下载数据集文件。默认值为  ``True`` 。
+  - **backend** (str，可选) - 指定要返回的图像类型：PIL.Image 或 numpy.ndarray。必须是 {'pil'，'cv2'} 中的值。如果未设置此选项，将从 :ref:`paddle.vision.get_image_backend <cn_api_paddle_vision_get_image_backend>` 获得这个值。默认值为  ``None`` 。
 
 返回
 :::::::::
diff --git a/docs/api/paddle/vision/get_image_backend_cn.rst b/docs/api/paddle/vision/get_image_backend_cn.rst
index 60cba4709cb..c1398dfd380 100644
--- a/docs/api/paddle/vision/get_image_backend_cn.rst
+++ b/docs/api/paddle/vision/get_image_backend_cn.rst
@@ -11,7 +11,7 @@ get_image_backend
 返回
 :::::::::
 
-    ``str``，加载图像的模块名称，``pil`` 或 ``cv2``。
+     ``str`` ，加载图像的模块名称， ``pil``  或  ``cv2`` 。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/image_load_cn.rst b/docs/api/paddle/vision/image_load_cn.rst
index d6c7f844321..abfab1cb370 100644
--- a/docs/api/paddle/vision/image_load_cn.rst
+++ b/docs/api/paddle/vision/image_load_cn.rst
@@ -11,12 +11,12 @@ image_load
 :::::::::
 
     - **path** (str) - 图像路径。
-    - **backend** (str，可选) - 加载图像的后端。参数必须是 ``cv2``， ``pil``， ``None`` 之一。如果后端为 ``None``，则使用全局的 ``_imread_backend`` 参数，默认值为 ``pil``。这个参数可以使用 :ref:`cn_api_paddle_vision_set_image_backend` 指定。默认值：None 。
+    - **backend** (str，可选) - 加载图像的后端。参数必须是  ``cv2`` ，  ``pil`` ，  ``None``  之一。如果后端为  ``None`` ，则使用全局的  ``_imread_backend``  参数，默认值为  ``pil`` 。这个参数可以使用 :ref:`cn_api_paddle_vision_set_image_backend` 指定。默认值：None 。
 
 返回
 :::::::::
 
-    ``PIL.Image 或 numpy.ndarray``，加载后的图像。
+     ``PIL.Image 或 numpy.ndarray`` ，加载后的图像。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/ops/PSRoIPool_cn.rst b/docs/api/paddle/vision/ops/PSRoIPool_cn.rst
index 212865cb244..a3eb0785374 100644
--- a/docs/api/paddle/vision/ops/PSRoIPool_cn.rst
+++ b/docs/api/paddle/vision/ops/PSRoIPool_cn.rst
@@ -5,7 +5,7 @@ PSRoIPool
 
 .. py:class:: paddle.vision.ops.PSRoIPool(output_size, spatial_scale=1.0)
 
-构建一个 ``PSRoIPool`` 类的可调用对象。请参见 :ref:`cn_api_paddle_vision_ops_psroi_pool` API。
+构建一个  ``PSRoIPool``  类的可调用对象。请参见 :ref:`cn_api_paddle_vision_ops_psroi_pool` API。
 
 参数
 :::::::::
diff --git a/docs/api/paddle/vision/ops/RoIAlign_cn.rst b/docs/api/paddle/vision/ops/RoIAlign_cn.rst
index 878eef41b77..7a4db9c84df 100644
--- a/docs/api/paddle/vision/ops/RoIAlign_cn.rst
+++ b/docs/api/paddle/vision/ops/RoIAlign_cn.rst
@@ -5,7 +5,7 @@ RoIAlign
 
 .. py:class:: paddle.vision.ops.RoIAlign(output_size, spatial_scale=1.0)
 
-构建一个 ``RoIAlign`` 类的可调用对象。请参见 :ref:`cn_api_paddle_vision_ops_roi_align` API。
+构建一个  ``RoIAlign``  类的可调用对象。请参见 :ref:`cn_api_paddle_vision_ops_roi_align` API。
 
 参数
 :::::::::
diff --git a/docs/api/paddle/vision/ops/RoIPool_cn.rst b/docs/api/paddle/vision/ops/RoIPool_cn.rst
index 19e611eff1d..94030c376c9 100644
--- a/docs/api/paddle/vision/ops/RoIPool_cn.rst
+++ b/docs/api/paddle/vision/ops/RoIPool_cn.rst
@@ -5,7 +5,7 @@ RoIPool
 
 .. py:class:: paddle.vision.ops.RoIPool(output_size, spatial_scale=1.0)
 
-构建一个 ``RoIPool`` 类的可调用对象。请参见 :ref:`cn_api_paddle_vision_ops_roi_pool` API。
+构建一个  ``RoIPool``  类的可调用对象。请参见 :ref:`cn_api_paddle_vision_ops_roi_pool` API。
 
 参数
 :::::::::
diff --git a/docs/api/paddle/vision/ops/distribute_fpn_proposals_cn.rst b/docs/api/paddle/vision/ops/distribute_fpn_proposals_cn.rst
index 7cfc77c6469..cdc530dbdad 100644
--- a/docs/api/paddle/vision/ops/distribute_fpn_proposals_cn.rst
+++ b/docs/api/paddle/vision/ops/distribute_fpn_proposals_cn.rst
@@ -25,7 +25,7 @@ distribute_fpn_proposals
     - **refer_level** （int） - 具有指定比例的 FPN 层的引用级别。
     - **refer_scale** （int） - 具有指定级别的 FPN 层的引用比例。
     - **pixel_offset** (bool, 可选）- 是否有像素偏移。如果是 True, 在计算形状大小时时会偏移 1。默认值为 False。
-    - **rois_num** (Tensor, 可选): 每张图所包含的 RoI 数量。是形状为[B]的 1-D Tensor, 数据类型为 int32。其中 B 是图像数量。如果``rois_num`` 不为 None， 将会返回一个形状为[B]的 1-D Tensor, 其中每个元素是每张图在对应层级上的 RoI 数量。默认值为 None。
+    - **rois_num** (Tensor, 可选): 每张图所包含的 RoI 数量。是形状为[B]的 1-D Tensor, 数据类型为 int32。其中 B 是图像数量。如果 ``rois_num``  不为 None， 将会返回一个形状为[B]的 1-D Tensor, 其中每个元素是每张图在对应层级上的 RoI 数量。默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/vision/ops/generate_proposals_cn.rst b/docs/api/paddle/vision/ops/generate_proposals_cn.rst
index e24cca4f2ca..7799e5b42b6 100644
--- a/docs/api/paddle/vision/ops/generate_proposals_cn.rst
+++ b/docs/api/paddle/vision/ops/generate_proposals_cn.rst
@@ -9,12 +9,12 @@ generate_proposals
 
 
 
-根据每个检测框为 foreground 对象的概率，根据 ``anchors`` 和 ``bbox_deltas`` 以及 ``scores``  计算生成 RPN 的输出 proposal。最后的推选的 proposal 被用于训练检测网络。
+根据每个检测框为 foreground 对象的概率，根据  ``anchors``  和  ``bbox_deltas``  以及  ``scores``   计算生成 RPN 的输出 proposal。最后的推选的 proposal 被用于训练检测网络。
 
 
 该操作通过以下步骤生成 proposals ：
 
-        1、通过转置操作将 ``scores`` 和 ``bbox_deltas`` 的大小分别调整为 ``（H * W * A，1）`` 和 ``（H * W * A，4）`` 。
+        1、通过转置操作将  ``scores``  和  ``bbox_deltas``  的大小分别调整为  ``（H * W * A，1）``  和  ``（H * W * A，4）``  。
 
         2. 计算出候选框的位置。
 
@@ -26,26 +26,26 @@ generate_proposals
 
 参数
 ::::::::::::
-        - **scores** (Tensor) - Shape 为 ``[N，A，H，W]`` 的 4-D Tensor，表示每个框包含 object 的概率。N 是批大小，A 是 anchor 数，H 和 W 是 feature map 的高度和宽度。数据类型支持 float32。
-        - **bbox_deltas** (Tensor)- Shape 为 ``[N，4 * A，H，W]`` 的 4-D Tensor，表示预测出的候选框的位置和 anchor 的位置之间的距离。数据类型支持 float32。
-        - **img_size** (Tensor) - Shape 为 ``[N，2]`` 的 2-D Tensor，表示原始图像的大小信息。信息包含原始图像宽、高和 feature map 相对于原始图像缩放的比例。数据类型可为 float32 或 float64。
-        - **anchors** (Tensor) - Shape 为 ``[H，W，A，4]`` 的 4-D Tensor。H 和 W 是 feature map 的高度和宽度。A 是每个位置的框的数量。每个 anchor 以 ``（xmin，ymin，xmax，ymax）`` 的格式表示，其中， ``xmin`` 和 ``ymin`` 为左上角的坐标， ``xmax`` 和 ``ymax`` 为右下角的坐标。数据类型支持 float32。
-        - **variances** (Tensor) - Shape 为 ``[H，W，A，4]`` 的 4-D Tensor，表示 ``anchors`` 的方差。每个 anchor 的方差都是 ``（xcenter，ycenter，w，h）`` 的格式表示。数据类型支持 float32。
+        - **scores** (Tensor) - Shape 为  ``[N，A，H，W]``  的 4-D Tensor，表示每个框包含 object 的概率。N 是批大小，A 是 anchor 数，H 和 W 是 feature map 的高度和宽度。数据类型支持 float32。
+        - **bbox_deltas** (Tensor)- Shape 为  ``[N，4 * A，H，W]``  的 4-D Tensor，表示预测出的候选框的位置和 anchor 的位置之间的距离。数据类型支持 float32。
+        - **img_size** (Tensor) - Shape 为  ``[N，2]``  的 2-D Tensor，表示原始图像的大小信息。信息包含原始图像宽、高和 feature map 相对于原始图像缩放的比例。数据类型可为 float32 或 float64。
+        - **anchors** (Tensor) - Shape 为  ``[H，W，A，4]``  的 4-D Tensor。H 和 W 是 feature map 的高度和宽度。A 是每个位置的框的数量。每个 anchor 以  ``（xmin，ymin，xmax，ymax）``  的格式表示，其中，  ``xmin``  和  ``ymin``  为左上角的坐标，  ``xmax``  和  ``ymax``  为右下角的坐标。数据类型支持 float32。
+        - **variances** (Tensor) - Shape 为  ``[H，W，A，4]``  的 4-D Tensor，表示  ``anchors``  的方差。每个 anchor 的方差都是  ``（xcenter，ycenter，w，h）``  的格式表示。数据类型支持 float32。
         - **pre_nms_top_n** (int，可选) - 每张图在 NMS 操作之前要保留的总框数。默认值为 6000。
         - **post_nms_top_n** (int，可选) - 每个图在 NMS 后要保留的总框数。默认值为 1000。
         - **nms_thresh** (float，可选) - NMS 中的阈值。默认值为 0.5。
         - **min_size** (float，可选) - 根据宽和高过滤候选框的阈值，宽或高小于该阈值的候选框将被过滤掉。默认值为 0.1。
-        - **eta** (float，可选) - 自适应阈值的衰减系数。仅在自适应 NMS 中且自适应阈值大于 0.5 时生效，在每次迭代中 ``adaptive_threshold = adaptive_treshold * eta`` 。默认值为 1.0。
-        - **pixel_offset** (bool, 可选）- 是否有像素偏移。如果是 True, ``img_size`` 在计算时会偏移 1。默认值为 False。
-        - **return_rois_num** (bool，可选) - 是否返回 ``rpn_rois_num`` 。当设定为 True 时会返回一个形状为[N,]的 1-D 的 Tensor，包含该 Batch 中每一张图片包含的 RoI 的数目。 N 是批大小和图片数量。默认值为 False。
+        - **eta** (float，可选) - 自适应阈值的衰减系数。仅在自适应 NMS 中且自适应阈值大于 0.5 时生效，在每次迭代中  ``adaptive_threshold = adaptive_treshold * eta``  。默认值为 1.0。
+        - **pixel_offset** (bool, 可选）- 是否有像素偏移。如果是 True,  ``img_size``  在计算时会偏移 1。默认值为 False。
+        - **return_rois_num** (bool，可选) - 是否返回  ``rpn_rois_num``  。当设定为 True 时会返回一个形状为[N,]的 1-D 的 Tensor，包含该 Batch 中每一张图片包含的 RoI 的数目。 N 是批大小和图片数量。默认值为 False。
         - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 
 返回
 ::::::::::::
-- **rpn_rois** (Tensor) - 生成的 RoIs。为形状是 ``[N, 4]`` 的 2-D Tensor， 其中 N 为 RoIs 的数量。数据类型与 ``scores`` 一致。
-- **rpn_roi_probs** (Tensor) - 生成的 RoIs 的得分。为形状是为 ``[N, 1]`` 的 2-D Tensor，其中 N 为 RoIs 的数量。数据类型与 ``scores`` 一致。
-- **rpn_rois_num** (Tensor) - 该 Batch 中每一张图片包含的 RoI 的数目。为形状是为 ``[B,]`` 的 1-D Tensor。其中 ``B`` 是批大小和图片数量。此外，其和与 RoIs 的数量 ``N`` 一致。
+- **rpn_rois** (Tensor) - 生成的 RoIs。为形状是  ``[N, 4]``  的 2-D Tensor， 其中 N 为 RoIs 的数量。数据类型与  ``scores``  一致。
+- **rpn_roi_probs** (Tensor) - 生成的 RoIs 的得分。为形状是为  ``[N, 1]``  的 2-D Tensor，其中 N 为 RoIs 的数量。数据类型与  ``scores``  一致。
+- **rpn_rois_num** (Tensor) - 该 Batch 中每一张图片包含的 RoI 的数目。为形状是为  ``[B,]``  的 1-D Tensor。其中  ``B``  是批大小和图片数量。此外，其和与 RoIs 的数量  ``N``  一致。
 
 
 代码示例
diff --git a/docs/api/paddle/vision/ops/nms_cn.rst b/docs/api/paddle/vision/ops/nms_cn.rst
index 9f9b1abfc38..2280ea85638 100644
--- a/docs/api/paddle/vision/ops/nms_cn.rst
+++ b/docs/api/paddle/vision/ops/nms_cn.rst
@@ -19,11 +19,11 @@ nms
 
 参数
 :::::::::
-    - **boxes** (Tensor) - 待进行计算的框坐标，它应当是一个形状为[num_boxes, 4]的 2-D Tensor，以[[x1, y1, x2, y2], ...]的形式给出，数据类型可以是 float32 或 float64，其中(x1, y1)是左上角的坐标值，(x2, y2)是右下角的坐标值，其关系应符合 ``0 <= x1 < x2 && 0 <= y1 < y2``。
+    - **boxes** (Tensor) - 待进行计算的框坐标，它应当是一个形状为[num_boxes, 4]的 2-D Tensor，以[[x1, y1, x2, y2], ...]的形式给出，数据类型可以是 float32 或 float64，其中(x1, y1)是左上角的坐标值，(x2, y2)是右下角的坐标值，其关系应符合  ``0 <= x1 < x2 && 0 <= y1 < y2`` 。
     - **iou_threshold** (float32，可选) - 用于判断两个框是否重叠的 IoU 门限值。如果 IoU(box1, box2) > threshold， box1 和 box2 将被认为是重叠框。默认为：0.3。
     - **scores** (Tensor，可选) - 与 boxes 参数对应的 score，它应当是一个形状为[num_boxes]的 1-D Tensor。数据类型可以是 float32 或 float64。默认为：None。
     - **category_idxs** (Tensor，可选) - 与 boxes 参数对应的类别编号，它应当是一个形状为[num_boxes]的 1-D Tensor。数据类型为 int64。默认为：None。
-    - **categories** (List，可选) - 类别列表，它的每个元素应该是唯一的，满足 ``categories == paddle.unique(class_idxs)``。默认为：None。
+    - **categories** (List，可选) - 类别列表，它的每个元素应该是唯一的，满足  ``categories == paddle.unique(class_idxs)`` 。默认为：None。
     - **top_k** (int64，可选) - 需要返回的分数最高的 boxes 索引数量。该值须小于等于 num_boxes。默认为：None。
 
 
diff --git a/docs/api/paddle/vision/ops/roi_align_cn.rst b/docs/api/paddle/vision/ops/roi_align_cn.rst
index 8f11f5a9d5c..822fc22f59b 100644
--- a/docs/api/paddle/vision/ops/roi_align_cn.rst
+++ b/docs/api/paddle/vision/ops/roi_align_cn.rst
@@ -15,7 +15,7 @@ roi_align
     - **boxes_num** (Tensor) - 该 batch 中每一张图所包含的框数量。数据类型为 int32。
     - **output_size** (int|Tuple(int, int)) - 池化后输出的尺寸(H, W)，数据类型为 int32。如果 output_size 是单个 int 类型整数，则 H 和 W 都与其相等。
     - **spatial_scale** (float32，可选) - 空间比例因子，用于将 boxes 中的坐标从其输入尺寸按比例映射到 input 特征图的尺寸。
-    - **sampling_ratio** (int32，可选) - 插值网格中用于计算每个池化输出条柱的输出值的采样点数。如果大于 0，则使用每个条柱的精确采样点。如果小于或等于 0，则使用自适应数量的网格点（计算为 ``ceil(roi_width / output_width)``，高度同理）。默认值：-1。
+    - **sampling_ratio** (int32，可选) - 插值网格中用于计算每个池化输出条柱的输出值的采样点数。如果大于 0，则使用每个条柱的精确采样点。如果小于或等于 0，则使用自适应数量的网格点（计算为  ``ceil(roi_width / output_width)`` ，高度同理）。默认值：-1。
     - **aligned** (bool，可选) - 默认值为 True，表示像素移动框将其坐标移动-0.5，以便与两个相邻像素索引更好地对齐。如果为 False，则是使用遗留版本的实现。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
diff --git a/docs/api/paddle/vision/ops/yolo_loss_cn.rst b/docs/api/paddle/vision/ops/yolo_loss_cn.rst
index 6d1c4d066a4..d28e220e215 100644
--- a/docs/api/paddle/vision/ops/yolo_loss_cn.rst
+++ b/docs/api/paddle/vision/ops/yolo_loss_cn.rst
@@ -7,7 +7,7 @@ yolo_loss
 
 该运算通过给定的预测结果和真实框计算 YOLOv3 损失。
 
-YOLOv3 loss 前的网络输出形状为[N，C，H，W]，H 和 W 应该相同，用来指定网格(grid)大小。每个网格点预测 S 个边界框(bounding boxes)，S 由每个尺度中 ``anchors`` 簇的个数指定。在第二维（表示通道的维度）中，C 的值应为 S *（class_num + 5），class_num 是源数据集的对象种类数（如 coco 中为 80），另外，除了存储 4 个边界框位置坐标 x，y，w，h，还包括边界框以及每个 anchor 框的 one-hot 关键字的置信度得分。
+YOLOv3 loss 前的网络输出形状为[N，C，H，W]，H 和 W 应该相同，用来指定网格(grid)大小。每个网格点预测 S 个边界框(bounding boxes)，S 由每个尺度中  ``anchors``  簇的个数指定。在第二维（表示通道的维度）中，C 的值应为 S *（class_num + 5），class_num 是源数据集的对象种类数（如 coco 中为 80），另外，除了存储 4 个边界框位置坐标 x，y，w，h，还包括边界框以及每个 anchor 框的 one-hot 关键字的置信度得分。
 假设有四个表征位置的坐标为 :math:`t_x, t_y, t_w, t_h`，那么边界框的预测将会如下定义：
 
          $$
@@ -45,9 +45,9 @@ YOLOv3 loss 前的网络输出形状为[N，C，H，W]，H 和 W 应该相同，
          $$
 
 
-当 ``use_label_smooth`` 为 ``True`` 时，在计算分类损失时将平滑分类目标，将正样本的目标平滑到 1.0-1.0 / class_num，并将负样本的目标平滑到 1.0 / class_num。
+当  ``use_label_smooth``  为  ``True``  时，在计算分类损失时将平滑分类目标，将正样本的目标平滑到 1.0-1.0 / class_num，并将负样本的目标平滑到 1.0 / class_num。
 
-``gt_score`` （如果存在）表示真实框的 mixup 得分，那么真实框所产生的所有损失需要乘上 ``gt_score`` 。
+ ``gt_score``  （如果存在）表示真实框的 mixup 得分，那么真实框所产生的所有损失需要乘上  ``gt_score``  。
 
 
 
diff --git a/docs/api/paddle/vision/set_image_backend_cn.rst b/docs/api/paddle/vision/set_image_backend_cn.rst
index f68ec618739..9b1ac3e5c1c 100644
--- a/docs/api/paddle/vision/set_image_backend_cn.rst
+++ b/docs/api/paddle/vision/set_image_backend_cn.rst
@@ -5,12 +5,12 @@ set_image_backend
 
 .. py:function:: paddle.vision.set_image_backend(backend)
 
-在 :ref:`cn_api_paddle_vision_datasets_ImageFolder` 和 :ref:`cn_api_paddle_vision_datasets_DatasetFolder` 类中指定用于加载图像的后端。现在支持后端是 ``pillow`` 和 ``opencv``。如果未设置后端，则默认使用 ``pil`` 。
+在 :ref:`cn_api_paddle_vision_datasets_ImageFolder` 和 :ref:`cn_api_paddle_vision_datasets_DatasetFolder` 类中指定用于加载图像的后端。现在支持后端是  ``pillow``  和  ``opencv`` 。如果未设置后端，则默认使用  ``pil``  。
 
 参数
 :::::::::
 
-    - **backend** (str) - 加载图像的后端，必须为 ``pil`` 或者 ``cv2`` 。
+    - **backend** (str) - 加载图像的后端，必须为  ``pil``  或者  ``cv2``  。
 
 
 代码示例
diff --git a/docs/api/paddle/vision/transforms/BaseTransform_cn.rst b/docs/api/paddle/vision/transforms/BaseTransform_cn.rst
index 4790d7f4aac..7714ecd6899 100644
--- a/docs/api/paddle/vision/transforms/BaseTransform_cn.rst
+++ b/docs/api/paddle/vision/transforms/BaseTransform_cn.rst
@@ -16,24 +16,24 @@ BaseTransform
     else:
         _get_params -> _apply_*() for * in keys
 
-如果你想要定义自己的图像变化方法，需要重写子类中的 ``_apply_*`` 方法，否则将引发 NotImplementedError 错误。
+如果你想要定义自己的图像变化方法，需要重写子类中的  ``_apply_*``  方法，否则将引发 NotImplementedError 错误。
 
 参数
 :::::::::
 
-    - **keys** (list[str]|tuple[str]，可选) - 输入的类型。你的输入可以是单一的图像，也可以是包含不同数据结构的元组，``keys`` 可以用来指定输入类型。举个例子，如果你的输入就是一个单一的图像，那么 ``keys`` 可以为 ``None`` 或者 ("image")。如果你的输入是两个图像：``(image, image)``，那么 `keys` 应该设置为 ``("image", "image")``。如果你的输入是 ``(image, boxes)``，那么 ``keys`` 应该为 ``("image", "boxes")``。目前支持的数据类型如下所示：
+    - **keys** (list[str]|tuple[str]，可选) - 输入的类型。你的输入可以是单一的图像，也可以是包含不同数据结构的元组， ``keys``  可以用来指定输入类型。举个例子，如果你的输入就是一个单一的图像，那么  ``keys``  可以为  ``None``  或者 ("image")。如果你的输入是两个图像： ``(image, image)`` ，那么 `keys` 应该设置为  ``("image", "image")`` 。如果你的输入是  ``(image, boxes)`` ，那么  ``keys``  应该为  ``("image", "boxes")`` 。目前支持的数据类型如下所示：
 
-            - "image"：输入的图像，它的维度为 ``(H, W, C)`` 。
-            - "coords"：输入的左边，它的维度为 ``(N, 2)`` 。
+            - "image"：输入的图像，它的维度为  ``(H, W, C)``  。
+            - "coords"：输入的左边，它的维度为  ``(N, 2)``  。
             - "boxes"：输入的矩形框，他的维度为 (N, 4)，形式为 "xyxy"，第一个 "xy" 表示矩形框左上方的坐标，第二个 "xy" 表示矩形框右下方的坐标。
-            - "mask"：分割的掩码，它的维度为 ``(H, W, 1)`` 。
+            - "mask"：分割的掩码，它的维度为  ``(H, W, 1)``  。
 
             你也可以通过自定义 _apply_ 的方法来处理特殊的数据结构。
 
 返回
 :::::::::
 
-    ``PIL.Image 或 numpy ndarray``，变换后的图像。
+     ``PIL.Image 或 numpy ndarray`` ，变换后的图像。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/BrightnessTransform_cn.rst b/docs/api/paddle/vision/transforms/BrightnessTransform_cn.rst
index 45aa6d9472c..c07bee4ca90 100644
--- a/docs/api/paddle/vision/transforms/BrightnessTransform_cn.rst
+++ b/docs/api/paddle/vision/transforms/BrightnessTransform_cn.rst
@@ -11,7 +11,7 @@ BrightnessTransform
 :::::::::
 
     - **value** (float) - 亮度调整范围大小，会从给定参数后的均匀分布[max(0，1 - brightness), 1 + brightness]中随机选择进行实际调整，可以是任何非负数。参数等于 0 时输出原始图像。
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值：None。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值：None。
 
 形状
 :::::::::
@@ -22,7 +22,7 @@ BrightnessTransform
 返回
 :::::::::
 
-    计算 ``BrightnessTransform`` 的可调用对象。
+    计算  ``BrightnessTransform``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/CenterCrop_cn.rst b/docs/api/paddle/vision/transforms/CenterCrop_cn.rst
index af152899c6a..daad3680482 100644
--- a/docs/api/paddle/vision/transforms/CenterCrop_cn.rst
+++ b/docs/api/paddle/vision/transforms/CenterCrop_cn.rst
@@ -11,7 +11,7 @@ CenterCrop
 :::::::::
 
     - **size** (int|list|tuple) - 输出图像的形状大小。
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值：None。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值：None。
 
 形状
 :::::::::
@@ -22,7 +22,7 @@ CenterCrop
 返回
 :::::::::
 
-    计算 ``CenterCrop`` 的可调用对象。
+    计算  ``CenterCrop``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/ColorJitter_cn.rst b/docs/api/paddle/vision/transforms/ColorJitter_cn.rst
index 1013f413bd1..7ba74d0c409 100644
--- a/docs/api/paddle/vision/transforms/ColorJitter_cn.rst
+++ b/docs/api/paddle/vision/transforms/ColorJitter_cn.rst
@@ -14,7 +14,7 @@ ColorJitter
     - **contrast** (float，可选) - 对比度调整范围大小，，会从给定参数后的均匀分布[max(0，1 - contrast), 1 + contrast]中随机选择进行实际调整，不能是负数。默认值：0。
     - **saturation** (float，可选) - 饱和度调整范围大小，，会从给定参数后的均匀分布[max(0，1 - saturation), 1 + saturation]中随机选择进行实际调整，不能是负数。默认值：0。
     - **hue** (float，可选) - 色调调整范围大小，会从给定参数后的均匀分布[-hue, hue]中随机选择进行实际调整，参数值需要在 0 到 0.5 之间。默认值：0。
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值：None。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值：None。
 
 形状
 :::::::::
@@ -25,7 +25,7 @@ ColorJitter
 返回
 :::::::::
 
-    计算 ``ColorJitter`` 的可调用对象。
+    计算  ``ColorJitter``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/ContrastTransform_cn.rst b/docs/api/paddle/vision/transforms/ContrastTransform_cn.rst
index ba7ea56c256..44b6700d013 100644
--- a/docs/api/paddle/vision/transforms/ContrastTransform_cn.rst
+++ b/docs/api/paddle/vision/transforms/ContrastTransform_cn.rst
@@ -11,7 +11,7 @@ ContrastTransform
 :::::::::
 
     - **value** (float) - 对比度调整范围大小，会从给定参数后的均匀分布[max(0，1 - contrast), 1 + contrast]中随机选择进行实际调整，不能是负数。参数值为 0 时返回原图像。
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值：None。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值：None。
 
 形状
 :::::::::
@@ -22,7 +22,7 @@ ContrastTransform
 返回
 :::::::::
 
-    计算 ``ContrastTransform`` 的可调用对象。
+    计算  ``ContrastTransform``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/Grayscale_cn.rst b/docs/api/paddle/vision/transforms/Grayscale_cn.rst
index 3545d3294fc..ee6f833ef59 100644
--- a/docs/api/paddle/vision/transforms/Grayscale_cn.rst
+++ b/docs/api/paddle/vision/transforms/Grayscale_cn.rst
@@ -11,7 +11,7 @@ Grayscale
 :::::::::
 
     - **num_output_channels** (int，可选) - 输出图像的通道数，参数值为 1 或 3。默认值：1。
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值：None。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值：None。
 
 形状
 :::::::::
@@ -22,7 +22,7 @@ Grayscale
 返回
 :::::::::
 
-    计算 ``Grayscale`` 的可调用对象。
+    计算  ``Grayscale``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/HueTransform_cn.rst b/docs/api/paddle/vision/transforms/HueTransform_cn.rst
index cd204eb6bfd..8cffc18527f 100644
--- a/docs/api/paddle/vision/transforms/HueTransform_cn.rst
+++ b/docs/api/paddle/vision/transforms/HueTransform_cn.rst
@@ -11,7 +11,7 @@ HueTransform
 :::::::::
 
     - **value** (float) - 色调调整范围大小，会从给定参数后的均匀分布[-hue, hue]中随机选择进行实际调整，参数值需要在 0 到 0.5 之间，参数值为 0 时返回原始图像。
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值：None。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值：None。
 
 形状
 :::::::::
@@ -22,7 +22,7 @@ HueTransform
 返回
 :::::::::
 
-    计算 ``HueTransform`` 的可调用对象。
+    计算  ``HueTransform``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/Normalize__upper_cn.rst b/docs/api/paddle/vision/transforms/Normalize__upper_cn.rst
index 927c45c778d..14aeefbf68b 100644
--- a/docs/api/paddle/vision/transforms/Normalize__upper_cn.rst
+++ b/docs/api/paddle/vision/transforms/Normalize__upper_cn.rst
@@ -13,8 +13,8 @@ Normalize
     - **mean** (int|float|list|tuple，可选) - 用于每个通道归一化的均值。
     - **std** (int|float|list|tuple，可选) - 用于每个通道归一化的标准差值。
     - **data_format** (str，可选) - 数据的格式，必须为 'HWC' 或 'CHW'。 默认值为 'CHW'。
-    - **to_rgb** (bool，可选) - 是否转换为 ``rgb`` 的格式。默认值为 False。
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值为 None。
+    - **to_rgb** (bool，可选) - 是否转换为  ``rgb``  的格式。默认值为 False。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值为 None。
 
 形状
 :::::::::
@@ -25,7 +25,7 @@ Normalize
 返回
 :::::::::
 
-计算 ``Normalize`` 的可调用对象。
+计算  ``Normalize``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/Pad__upper_cn.rst b/docs/api/paddle/vision/transforms/Pad__upper_cn.rst
index c48dd390ab9..35aebbd7336 100644
--- a/docs/api/paddle/vision/transforms/Pad__upper_cn.rst
+++ b/docs/api/paddle/vision/transforms/Pad__upper_cn.rst
@@ -14,12 +14,12 @@ Pad
     - **fill** (int|list|tuple，可选) - 用于填充的像素值。仅当 padding_mode 为 constant 时参数值有效。 默认值：0。 如果参数值是一个长度为 3 的元组，则会分别用于填充 R，G，B 通道。
     - **padding_mode** (string，可选) - 填充模式。支持: constant, edge, reflect 或 symmetric。 默认值：constant。
 
-        - ``constant`` 表示使用常量值进行填充，该值由 fill 参数指定；
-        - ``edge`` 表示使用图像边缘像素值进行填充；
-        - ``reflect`` 表示使用原图像的镜像值进行填充（不使用边缘上的值）；比如：使用该模式对 ``[1, 2, 3, 4]`` 的两端分别填充 2 个值，结果是 ``[3, 2, 1, 2, 3, 4, 3, 2]``。
-        - ``symmetric`` 表示使用原图像的镜像值进行填充（使用边缘上的值）；比如：使用该模式对 ``[1, 2, 3, 4]`` 的两端分别填充 2 个值，结果是 ``[2, 1, 1, 2, 3, 4, 4, 3]``。
+        -  ``constant``  表示使用常量值进行填充，该值由 fill 参数指定；
+        -  ``edge``  表示使用图像边缘像素值进行填充；
+        -  ``reflect``  表示使用原图像的镜像值进行填充（不使用边缘上的值）；比如：使用该模式对  ``[1, 2, 3, 4]``  的两端分别填充 2 个值，结果是  ``[3, 2, 1, 2, 3, 4, 3, 2]`` 。
+        -  ``symmetric``  表示使用原图像的镜像值进行填充（使用边缘上的值）；比如：使用该模式对  ``[1, 2, 3, 4]``  的两端分别填充 2 个值，结果是  ``[2, 1, 1, 2, 3, 4, 4, 3]`` 。
 
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值: None。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值: None。
 
 形状
 :::::::::
@@ -30,7 +30,7 @@ Pad
 返回
 :::::::::
 
-计算 ``Pad`` 的可调用对象。
+计算  ``Pad``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/RandomAffine_cn.rst b/docs/api/paddle/vision/transforms/RandomAffine_cn.rst
index 5ea3a90d0c0..7dd9bb9e627 100644
--- a/docs/api/paddle/vision/transforms/RandomAffine_cn.rst
+++ b/docs/api/paddle/vision/transforms/RandomAffine_cn.rst
@@ -23,18 +23,18 @@ RandomAffine
         如果 shear 为 4 个值的 sequence 类型，则与 x 轴平行方向范围 (shear[2], shear[1]) 内进行剪切，与 y 轴平行方向范围 (shear[2], shear[3]) 内进行剪切；
         默认值为 None ，表示不会进行剪切。
     - interpolation (str，可选) - 插值的方法。
-        如果这个参数没有设定或者输入图像为单通道，则该参数会根据使用的后端，被设置为 ``PIL.Image.NEAREST`` 或者 ``cv2.INTER_NEAREST`` 。
-        当使用 ``pil`` 作为后端时, 支持的插值方法如下:
+        如果这个参数没有设定或者输入图像为单通道，则该参数会根据使用的后端，被设置为  ``PIL.Image.NEAREST``  或者  ``cv2.INTER_NEAREST``  。
+        当使用  ``pil``  作为后端时, 支持的插值方法如下:
             - "nearest": Image.NEAREST
             - "bilinear": Image.BILINEAR
             - "bicubic": Image.BICUBIC
-        当使用 ``cv2`` 作为后端时, 支持的插值方法如下:
+        当使用  ``cv2``  作为后端时, 支持的插值方法如下:
             - "nearest": cv2.INTER_NEAREST
             - "bilinear": cv2.INTER_LINEAR
             - "bicubic": cv2.INTER_CUBIC
     - fill (int|list|tuple，可选) - 对图像扩展时填充的像素值，默认值： 0 ，如果只设定一个数字则所有通道上像素值均为该值。
     - center (2-tuple，可选) - 仿射变换的中心点坐标，原点是图片左上角，默认值是图像的中心点。
-    - keys (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值： None 。
+    - keys (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值： None 。
 
 形状
 :::::::::
@@ -45,7 +45,7 @@ RandomAffine
 返回
 :::::::::
 
-    计算 ``RandomAffine`` 的可调用对象。
+    计算  ``RandomAffine``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/RandomCrop_cn.rst b/docs/api/paddle/vision/transforms/RandomCrop_cn.rst
index cae49e2df80..2365115d755 100644
--- a/docs/api/paddle/vision/transforms/RandomCrop_cn.rst
+++ b/docs/api/paddle/vision/transforms/RandomCrop_cn.rst
@@ -14,19 +14,19 @@ RandomCrop
     - **padding** (int|sequence，可选) - 对图像四周外边进行填充，如果提供了长度为 4 的序列，则将其分别用于填充左边界，上边界，右边界和下边界。默认值：None，不填充。
     - **pad_if_needed** (boolean，可选) - 如果裁剪后的图像小于期望的大小时，是否对裁剪后的图像进行填充，以避免引发异常，默认值：False，保持初次裁剪后的大小，不填充。
     - **fill** (float|tuple，可选) - 用于填充的像素值。仅当 padding_mode 为 constant 时参数值有效。默认值：0。如果参数值是一个长度为 3 的元组，则会分别用于填充 R，G，B 通道。
-    - **padding_mode** (string，可选) - 填充模式。支持：constant, edge, reflect 或 symmetric。默认值：constant。 ``constant`` 表示使用常量值进行填充，该值由 fill 参数指定。 ``edge`` 表示使用图像边缘像素值进行填充。 ``reflect`` 表示使用原图像的镜像值进行填充（不使用边缘上的值）；比如：使用该模式对 [1, 2, 3, 4] 的两端分别填充 2 个值，结果是 [3, 2, 1, 2, 3, 4, 3, 2]。 ``symmetric`` 表示使用原图像的镜像值进行填充（使用边缘上的值）；比如：使用该模式对 [1, 2, 3, 4] 的两端分别填充 2 个值，结果是 [2, 1, 1, 2, 3, 4, 4, 3]。
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值：None。
+    - **padding_mode** (string，可选) - 填充模式。支持：constant, edge, reflect 或 symmetric。默认值：constant。  ``constant``  表示使用常量值进行填充，该值由 fill 参数指定。  ``edge``  表示使用图像边缘像素值进行填充。  ``reflect``  表示使用原图像的镜像值进行填充（不使用边缘上的值）；比如：使用该模式对 [1, 2, 3, 4] 的两端分别填充 2 个值，结果是 [3, 2, 1, 2, 3, 4, 3, 2]。  ``symmetric``  表示使用原图像的镜像值进行填充（使用边缘上的值）；比如：使用该模式对 [1, 2, 3, 4] 的两端分别填充 2 个值，结果是 [2, 1, 1, 2, 3, 4, 4, 3]。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值：None。
 
 形状
 :::::::::
 
-    - img (PIL.Image|np.ndarray|Paddle.Tensor) - 输入的图像数据，数据格式为 ``HWC`` 。
+    - img (PIL.Image|np.ndarray|Paddle.Tensor) - 输入的图像数据，数据格式为  ``HWC``  。
     - output (PIL.Image|np.ndarray|Paddle.Tensor) - 返回随机裁剪后的图像数据。
 
 返回
 :::::::::
 
-    计算 ``RandomCrop`` 的可调用对象。
+    计算  ``RandomCrop``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/RandomErasing_cn.rst b/docs/api/paddle/vision/transforms/RandomErasing_cn.rst
index fa9c1b230fd..0f8ebf0d1f6 100644
--- a/docs/api/paddle/vision/transforms/RandomErasing_cn.rst
+++ b/docs/api/paddle/vision/transforms/RandomErasing_cn.rst
@@ -15,7 +15,7 @@ RandomErasing
     - **ratio** (sequence，可选) - 擦除区域的纵横比范围。默认值：(0.3, 3.3)。
     - **value** (int|float|sequence|str，可选) - 擦除区域中像素将被替换为的值。如果 value 是一个数，所有的像素都将被替换为这个数。如果 value 是长为 3 的序列，R,G,B 通道将被对应地替换。如果 value 是"random"，每个像素会被替换为随机值。默认值：0。
     - **inplace** (bool，可选) - 该变换是否在原地操作。默认值：False。
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值：None。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值：None。
 
 形状
 :::::::::
@@ -26,7 +26,7 @@ RandomErasing
 返回
 :::::::::
 
-    计算 ``RandomErasing`` 的可调用对象。
+    计算  ``RandomErasing``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/RandomHorizontalFlip_cn.rst b/docs/api/paddle/vision/transforms/RandomHorizontalFlip_cn.rst
index 31ead816a32..509580a7273 100644
--- a/docs/api/paddle/vision/transforms/RandomHorizontalFlip_cn.rst
+++ b/docs/api/paddle/vision/transforms/RandomHorizontalFlip_cn.rst
@@ -11,7 +11,7 @@ RandomHorizontalFlip
 :::::::::
 
     - **prob** (float，可选) - 图片执行水平翻转的概率，取值范围为[0, 1]，默认值为 0.5。
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值：None。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值：None。
 
 形状
 :::::::::
@@ -22,7 +22,7 @@ RandomHorizontalFlip
 返回
 :::::::::
 
-    计算 ``RandomHorizontalFlip`` 的可调用对象。
+    计算  ``RandomHorizontalFlip``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/RandomPerspective_cn.rst b/docs/api/paddle/vision/transforms/RandomPerspective_cn.rst
index f8788ae785f..39dded6f723 100644
--- a/docs/api/paddle/vision/transforms/RandomPerspective_cn.rst
+++ b/docs/api/paddle/vision/transforms/RandomPerspective_cn.rst
@@ -12,17 +12,17 @@ RandomPerspective
     - **prob** (float，可选) - 进行透视变换的概率，范围为 [0, 1] 。默认值： 0.5 。
     - **distortion_scale** (float，可选) - 图片失真程度的大小，范围为 [0, 1] 。默认值： 0.5 。
     - **interpolation** (str，可选) - 插值的方法。
-        如果这个参数没有设定或者输入图像为单通道，则该参数会根据使用的后端，被设置为 ``PIL.Image.NEAREST`` 或者 ``cv2.INTER_NEAREST`` 。
-        当使用 ``pil`` 作为后端时, 支持的插值方法如下:
+        如果这个参数没有设定或者输入图像为单通道，则该参数会根据使用的后端，被设置为  ``PIL.Image.NEAREST``  或者  ``cv2.INTER_NEAREST``  。
+        当使用  ``pil``  作为后端时, 支持的插值方法如下:
             - "nearest": Image.NEAREST
             - "bilinear": Image.BILINEAR
             - "bicubic": Image.BICUBIC
-        当使用 ``cv2`` 作为后端时, 支持的插值方法如下:
+        当使用  ``cv2``  作为后端时, 支持的插值方法如下:
             - "nearest": cv2.INTER_NEAREST
             - "bilinear": cv2.INTER_LINEAR
             - "bicubic": cv2.INTER_CUBIC
     - **fill** (int|list|tuple，可选) - 对图像扩展时填充的值。默认值： 0 ，如果只设定一个数字则所有通道上像素值均为该值。
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值： None 。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值： None 。
 
 形状
 ::::::::::::
@@ -33,7 +33,7 @@ RandomPerspective
 返回
 ::::::::::::
 
-    计算 ``RandomPerspective`` 的可调用对象。
+    计算  ``RandomPerspective``  的可调用对象。
 
 
 代码示例
diff --git a/docs/api/paddle/vision/transforms/RandomResizedCrop_cn.rst b/docs/api/paddle/vision/transforms/RandomResizedCrop_cn.rst
index 7cd12fe182a..b0f7f22aa7e 100644
--- a/docs/api/paddle/vision/transforms/RandomResizedCrop_cn.rst
+++ b/docs/api/paddle/vision/transforms/RandomResizedCrop_cn.rst
@@ -15,8 +15,8 @@ RandomResizedCrop
     - **size** (int|list|tuple) - 输出图像大小，当为单个 int 值时，生成指定 size 大小的方形图片，为(height,width)格式的数组或元组时按照参数大小输出。
     - **scale** (list|tuple，可选) - 相对于原图的尺寸，随机裁剪后图像大小的范围。默认值：（0.08，1.0）。
     - **ratio** (list|tuple，可选) - 裁剪后的目标图像宽高比范围，默认值：(0.75, 1.33)。
-    - **interpolation** (int|str，可选) - 插值的方法。默认值：'bilinear'。当使用 ``pil`` 作为后端时，支持的插值方法如下：- "nearest": Image.NEAREST, - "bilinear": Image.BILINEAR, - "bicubic": Image.BICUBIC, - "box": Image.BOX, - "lanczos": Image.LANCZOS, - "hamming": Image.HAMMING。当使用 ``cv2`` 作为后端时，支持的插值方法如下：- "nearest": cv2.INTER_NEAREST, - "bilinear": cv2.INTER_LINEAR, - "area": cv2.INTER_AREA, - "bicubic": cv2.INTER_CUBIC, - "lanczos": cv2.INTER_LANCZOS4。
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值：None。
+    - **interpolation** (int|str，可选) - 插值的方法。默认值：'bilinear'。当使用  ``pil``  作为后端时，支持的插值方法如下：- "nearest": Image.NEAREST, - "bilinear": Image.BILINEAR, - "bicubic": Image.BICUBIC, - "box": Image.BOX, - "lanczos": Image.LANCZOS, - "hamming": Image.HAMMING。当使用  ``cv2``  作为后端时，支持的插值方法如下：- "nearest": cv2.INTER_NEAREST, - "bilinear": cv2.INTER_LINEAR, - "area": cv2.INTER_AREA, - "bicubic": cv2.INTER_CUBIC, - "lanczos": cv2.INTER_LANCZOS4。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值：None。
 
 形状
 :::::::::
@@ -27,7 +27,7 @@ RandomResizedCrop
 返回
 :::::::::
 
-    计算 ``RandomResizedCrop`` 的可调用对象。
+    计算  ``RandomResizedCrop``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/RandomRotation_cn.rst b/docs/api/paddle/vision/transforms/RandomRotation_cn.rst
index 333548e048a..2f37d024ae6 100644
--- a/docs/api/paddle/vision/transforms/RandomRotation_cn.rst
+++ b/docs/api/paddle/vision/transforms/RandomRotation_cn.rst
@@ -11,11 +11,11 @@ RandomRotation
 :::::::::
 
     - **degrees** (sequence|float|int) - 旋转的角度度数范围。如果度数是数字而不是像（min，max）这样的序列，则会根据 degrees 参数值生成度数范围（-degrees，+degrees）。
-    - **interpolation** (str，可选) - 插值的方法。如果这个参数没有设定或者输入图像为单通道，则该参数会根据使用的后端，被设置为 ``PIL.Image.NEAREST`` 或者 ``cv2.INTER_NEAREST``。当使用 ``pil`` 作为后端时，支持的插值方法如下：- "nearest": Image.NEAREST,- "bilinear": Image.BILINEAR,- "bicubic": Image.BICUBIC 当使用 ``cv2`` 作为后端时，支持的插值方法如下：- "nearest": cv2.INTER_NEAREST,- "bilinear": cv2.INTER_LINEAR,- "bicubic": cv2.INTER_CUBIC。
+    - **interpolation** (str，可选) - 插值的方法。如果这个参数没有设定或者输入图像为单通道，则该参数会根据使用的后端，被设置为  ``PIL.Image.NEAREST``  或者  ``cv2.INTER_NEAREST`` 。当使用  ``pil``  作为后端时，支持的插值方法如下：- "nearest": Image.NEAREST,- "bilinear": Image.BILINEAR,- "bicubic": Image.BICUBIC 当使用  ``cv2``  作为后端时，支持的插值方法如下：- "nearest": cv2.INTER_NEAREST,- "bilinear": cv2.INTER_LINEAR,- "bicubic": cv2.INTER_CUBIC。
     - **expand** (bool，可选) - 是否要对旋转后的图片进行大小扩展，默认值：False。当参数值为 True 时，会对图像大小进行扩展，让其能够足以容纳整个旋转后的图像。当参数值为 False 时，会按照原图像大小保留旋转后的图像。**这个扩展操作的前提是围绕中心旋转且没有平移**。
     - **center** (tuple[int, int]，可选) - 旋转的中心点坐标，原点是图片左上角，默认值是图像的中心点。
     - **fill** (int，可选) - 对图像扩展时填充的值。默认值：0。
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值：None。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值：None。
 
 形状
 :::::::::
@@ -26,7 +26,7 @@ RandomRotation
 返回
 :::::::::
 
-    计算 ``RandomRotation`` 的可调用对象。
+    计算  ``RandomRotation``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/RandomVerticalFlip_cn.rst b/docs/api/paddle/vision/transforms/RandomVerticalFlip_cn.rst
index f12062dd720..ccef52c766b 100644
--- a/docs/api/paddle/vision/transforms/RandomVerticalFlip_cn.rst
+++ b/docs/api/paddle/vision/transforms/RandomVerticalFlip_cn.rst
@@ -11,7 +11,7 @@ RandomVerticalFlip
 :::::::::
 
     - **prob** (float) - 执行图片垂直翻转的概率，默认值为 0.5。
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值：None。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值：None。
 
 形状
 :::::::::
@@ -22,7 +22,7 @@ RandomVerticalFlip
 返回
 :::::::::
 
-    计算 ``RandomVerticalFlip`` 的可调用对象。
+    计算  ``RandomVerticalFlip``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/Resize__upper_cn.rst b/docs/api/paddle/vision/transforms/Resize__upper_cn.rst
index f17b3bddb3b..277d8809749 100644
--- a/docs/api/paddle/vision/transforms/Resize__upper_cn.rst
+++ b/docs/api/paddle/vision/transforms/Resize__upper_cn.rst
@@ -13,7 +13,7 @@ Resize
     - **size** (int|list|tuple) - 输出图像大小。如果 size 是一个序列，例如（h，w），输出大小将与此匹配。如果 size 为 int，图像的较小边缘将与此数字匹配，即如果 height > width，则图像将重新缩放为(size * height / width, size)。
     - **interpolation** (int|str，可选) - 插值的方法，默认值: 'bilinear'。
 
-        - 当使用 ``pil`` 作为后端时，支持的插值方法如下
+        - 当使用  ``pil``  作为后端时，支持的插值方法如下
 
             + "nearest": Image.NEAREST,
             + "bilinear": Image.BILINEAR,
@@ -22,7 +22,7 @@ Resize
             + "lanczos": Image.LANCZOS,
             + "hamming": Image.HAMMING。
 
-        - 当使用 ``cv2`` 作为后端时，支持的插值方法如下
+        - 当使用  ``cv2``  作为后端时，支持的插值方法如下
 
             + "nearest": cv2.INTER_NEAREST,
             + "bilinear": cv2.INTER_LINEAR,
@@ -30,7 +30,7 @@ Resize
             + "bicubic": cv2.INTER_CUBIC,
             + "lanczos": cv2.INTER_LANCZOS4。
 
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值: None。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值: None。
 
 形状
 :::::::::
@@ -41,7 +41,7 @@ Resize
 返回
 :::::::::
 
-计算 ``Resize`` 的可调用对象。
+计算  ``Resize``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/SaturationTransform_cn.rst b/docs/api/paddle/vision/transforms/SaturationTransform_cn.rst
index b99ace9f89c..f9d079e0aec 100644
--- a/docs/api/paddle/vision/transforms/SaturationTransform_cn.rst
+++ b/docs/api/paddle/vision/transforms/SaturationTransform_cn.rst
@@ -11,7 +11,7 @@ SaturationTransform
 :::::::::
 
     - **value** (float) - 饱和度的调整数值，非负数，当参数值为 0 时返回原始图像。
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值：None。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值：None。
 
 形状
 :::::::::
@@ -22,7 +22,7 @@ SaturationTransform
 返回
 :::::::::
 
-    计算 ``SaturationTransform`` 的可调用对象。
+    计算  ``SaturationTransform``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/ToTensor_cn.rst b/docs/api/paddle/vision/transforms/ToTensor_cn.rst
index 036802e5d9f..5cfca68cc21 100644
--- a/docs/api/paddle/vision/transforms/ToTensor_cn.rst
+++ b/docs/api/paddle/vision/transforms/ToTensor_cn.rst
@@ -5,36 +5,36 @@ ToTensor
 
 .. py:class:: paddle.vision.transforms.ToTensor(data_format='CHW', keys=None)
 
-将 ``PIL.Image`` 或 ``numpy.ndarray`` 转换成 ``paddle.Tensor``。
+将  ``PIL.Image``  或  ``numpy.ndarray``  转换成  ``paddle.Tensor`` 。
 
-将形状为 （H x W x C）的输入数据 ``PIL.Image`` 或 ``numpy.ndarray`` 转换为 (C x H x W)。
+将形状为 （H x W x C）的输入数据  ``PIL.Image``  或  ``numpy.ndarray``  转换为 (C x H x W)。
 
-若输入数据形状为（H x W）， ``ToTensor`` 会将该数据的形状视为（H x W x 1）。并且输出 Tensor 的形状是（1 x H x W）。
+若输入数据形状为（H x W），  ``ToTensor``  会将该数据的形状视为（H x W x 1）。并且输出 Tensor 的形状是（1 x H x W）。
 
-如果想保持形状不变，可以将参数 ``data_format`` 设置为 ``'HWC'``。
+如果想保持形状不变，可以将参数  ``data_format``  设置为  ``'HWC'`` 。
 
-同时，如果输入的 ``PIL.Image`` 的 ``mode`` 是 ``(L, LA, P, I, F, RGB, YCbCr, RGBA, CMYK, 1)``
-其中一种，或者输入的 ``numpy.ndarray`` 数据类型是 'uint8'，那么会将输入数据从（0-255）的范围缩放到
+同时，如果输入的  ``PIL.Image``  的  ``mode``  是  ``(L, LA, P, I, F, RGB, YCbCr, RGBA, CMYK, 1)`` 
+其中一种，或者输入的  ``numpy.ndarray``  数据类型是 'uint8'，那么会将输入数据从（0-255）的范围缩放到
 （0-1）的范围。其他的情况，则保持输入不变。
 
-在其他情况下， ``Tensor`` 将不缩放直接返回。
+在其他情况下，  ``Tensor``  将不缩放直接返回。
 
 参数
 :::::::::
 
     - **data_format** (str，可选) - 返回 Tensor 的格式，必须为 'HWC' 或 'CHW'。默认值：'CHW'。
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 定义一致。默认值：None。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  定义一致。默认值：None。
 
 形状
 :::::::::
 
     - img (PIL.Image|numpy.ndarray) - 输入的图像数据，数据格式为'HWC'。
-    - output (np.ndarray) - 返回的 Tensor 数据，根据参数 ``data_format``，Tensor 的格式必须为 'HWC' 或 'CHW'。
+    - output (np.ndarray) - 返回的 Tensor 数据，根据参数  ``data_format`` ，Tensor 的格式必须为 'HWC' 或 'CHW'。
 
 返回
 :::::::::
 
-    计算 ``ToTensor`` 的可调用对象。
+    计算  ``ToTensor``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/Transpose_cn.rst b/docs/api/paddle/vision/transforms/Transpose_cn.rst
index 895ce182901..e7382a3e3a0 100644
--- a/docs/api/paddle/vision/transforms/Transpose_cn.rst
+++ b/docs/api/paddle/vision/transforms/Transpose_cn.rst
@@ -12,18 +12,18 @@ Transpose
 :::::::::
 
     - **order** (list|tuple，可选) - 目标的维度顺序。Default: (2, 0, 1)。
-    - **keys** (list[str]|tuple[str]，可选) - 与 ``BaseTransform`` 一致。默认值：None。
+    - **keys** (list[str]|tuple[str]，可选) - 与  ``BaseTransform``  一致。默认值：None。
 
 形状
 :::::::::
 
     - **img** (PIL.Image|np.ndarray|Paddle.Tensor) - 输入的图像数据，数据格式为'HWC'。
-    - **output** (np.ndarray|Paddle.Tensor) - 返回更改格式后的数组或 Tensor。如果输入是 ``PIL.Image`` ，输出将会自动转换为 ``np.ndarray`` 。
+    - **output** (np.ndarray|Paddle.Tensor) - 返回更改格式后的数组或 Tensor。如果输入是  ``PIL.Image``  ，输出将会自动转换为  ``np.ndarray``  。
 
 返回
 :::::::::
 
-    计算 ``Transpose`` 的可调用对象。
+    计算  ``Transpose``  的可调用对象。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/adjust_brightness_cn.rst b/docs/api/paddle/vision/transforms/adjust_brightness_cn.rst
index bd5e5f09faa..2b016dcc857 100644
--- a/docs/api/paddle/vision/transforms/adjust_brightness_cn.rst
+++ b/docs/api/paddle/vision/transforms/adjust_brightness_cn.rst
@@ -16,7 +16,7 @@ adjust_brightness
 返回
 :::::::::
 
-    ``PIL.Image 或 numpy.ndarray 或 paddle.Tensor``，调整后的图像。
+     ``PIL.Image 或 numpy.ndarray 或 paddle.Tensor`` ，调整后的图像。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/adjust_contrast_cn.rst b/docs/api/paddle/vision/transforms/adjust_contrast_cn.rst
index 053ee572272..35ba1019e18 100644
--- a/docs/api/paddle/vision/transforms/adjust_contrast_cn.rst
+++ b/docs/api/paddle/vision/transforms/adjust_contrast_cn.rst
@@ -16,7 +16,7 @@ adjust_contrast
 返回
 :::::::::
 
-    ``PIL.Image 或 numpy.ndarray 或 paddle.Tensor``，调整后的图像。
+     ``PIL.Image 或 numpy.ndarray 或 paddle.Tensor`` ，调整后的图像。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/adjust_hue_cn.rst b/docs/api/paddle/vision/transforms/adjust_hue_cn.rst
index d2ae662e426..9f43d7dc533 100644
--- a/docs/api/paddle/vision/transforms/adjust_hue_cn.rst
+++ b/docs/api/paddle/vision/transforms/adjust_hue_cn.rst
@@ -9,18 +9,18 @@ adjust_hue
 
 通过将图像转换为 HSV 和周期性调整色调通道（H）的强度。然后将图像转换为原始图像模式。
 
-``hue_factor`` 是 H 通道的位移量，必须在 ``[-0.5, 0.5]`` 之间。
+ ``hue_factor``  是 H 通道的位移量，必须在  ``[-0.5, 0.5]``  之间。
 
 参数
 :::::::::
 
     - **img** (PIL.Image|np.array|paddle.Tensor) - 输入的图像。
-    - **hue_factor** (float) - 图像的色调通道的偏移量。数值应在 ``[-0.5, 0.5]`` 。0.5 和-0.5 分别表示 HSV 空间中色相通道正向和负向完全反转，0 表示没有调整色调。因此，-0.5 和 0.5 都会给出一个带有互补色的图像，而 0 则会给出原始图像。
+    - **hue_factor** (float) - 图像的色调通道的偏移量。数值应在  ``[-0.5, 0.5]``  。0.5 和-0.5 分别表示 HSV 空间中色相通道正向和负向完全反转，0 表示没有调整色调。因此，-0.5 和 0.5 都会给出一个带有互补色的图像，而 0 则会给出原始图像。
 
 返回
 :::::::::
 
-    ``PIL.Image`` 或 ``numpy.ndarray`` 或 ``paddle.Tensor``，调整后的图像。
+     ``PIL.Image``  或  ``numpy.ndarray``  或  ``paddle.Tensor`` ，调整后的图像。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/affine_cn.rst b/docs/api/paddle/vision/transforms/affine_cn.rst
index 866f9aeafbc..b85760b3127 100644
--- a/docs/api/paddle/vision/transforms/affine_cn.rst
+++ b/docs/api/paddle/vision/transforms/affine_cn.rst
@@ -15,12 +15,12 @@ affine
     - scale (float) - 伸缩变换的比例大小，注意必须大于 0 。
     - shear (list|tuple) - 剪切角度值，顺时针方向，第一个值是平行于 x 轴的剪切量，而第二个值是于平行于 y 轴的剪切量。
     - interpolation (str，可选) - 插值的方法。
-        如果这个参数没有设定或者输入图像为单通道，则该参数会根据使用的后端，被设置为 ``PIL.Image.NEAREST`` 或者 ``cv2.INTER_NEAREST`` 。
-        当使用 ``pil`` 作为后端时, 支持的插值方法如下:
+        如果这个参数没有设定或者输入图像为单通道，则该参数会根据使用的后端，被设置为  ``PIL.Image.NEAREST``  或者  ``cv2.INTER_NEAREST``  。
+        当使用  ``pil``  作为后端时, 支持的插值方法如下:
             - "nearest": Image.NEAREST
             - "bilinear": Image.BILINEAR
             - "bicubic": Image.BICUBIC
-        当使用 ``cv2`` 作为后端时, 支持的插值方法如下:
+        当使用  ``cv2``  作为后端时, 支持的插值方法如下:
             - "nearest": cv2.INTER_NEAREST
             - "bilinear": cv2.INTER_LINEAR
             - "bicubic": cv2.INTER_CUBIC
@@ -30,7 +30,7 @@ affine
 返回
 ::::::::::::
 
-    ``PIL.Image / numpy ndarray / paddle.Tensor`` ，仿射变换后的图像。
+     ``PIL.Image / numpy ndarray / paddle.Tensor``  ，仿射变换后的图像。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/vision/transforms/center_crop_cn.rst b/docs/api/paddle/vision/transforms/center_crop_cn.rst
index ee1b9bd187a..0fb830491f2 100644
--- a/docs/api/paddle/vision/transforms/center_crop_cn.rst
+++ b/docs/api/paddle/vision/transforms/center_crop_cn.rst
@@ -11,12 +11,12 @@ center_crop
 :::::::::
 
     - **img** (PIL.Image|np.array) - 用于裁剪的图像，（0,0）表示图像的左上角。
-    - **output_size** (sequence|list) - 要裁剪的矩形框的大小：(height, width)。如果是 ``int`` 值，则所有方向按照这个值裁剪。
+    - **output_size** (sequence|list) - 要裁剪的矩形框的大小：(height, width)。如果是  ``int``  值，则所有方向按照这个值裁剪。
 
 返回
 :::::::::
 
-    ``PIL.Image 或 numpy.ndarray``，裁剪后的图像。
+     ``PIL.Image 或 numpy.ndarray`` ，裁剪后的图像。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/crop_cn.rst b/docs/api/paddle/vision/transforms/crop_cn.rst
index 2b1ea47abcc..a8c05c2f9f3 100644
--- a/docs/api/paddle/vision/transforms/crop_cn.rst
+++ b/docs/api/paddle/vision/transforms/crop_cn.rst
@@ -19,7 +19,7 @@ crop
 返回
 :::::::::
 
-    ``PIL.Image 或 numpy.ndarray``，裁剪后的图像。
+     ``PIL.Image 或 numpy.ndarray`` ，裁剪后的图像。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/erase_cn.rst b/docs/api/paddle/vision/transforms/erase_cn.rst
index 61807a581c4..3e3ebe3cb31 100644
--- a/docs/api/paddle/vision/transforms/erase_cn.rst
+++ b/docs/api/paddle/vision/transforms/erase_cn.rst
@@ -21,7 +21,7 @@ erase
 返回
 :::::::::
 
-    ``paddle.Tensor`` 或 ``numpy.array`` 或 ``PIL.Image``，擦除后的图像，类型与输入图像的类型一致。
+     ``paddle.Tensor``  或  ``numpy.array``  或  ``PIL.Image`` ，擦除后的图像，类型与输入图像的类型一致。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/hflip_cn.rst b/docs/api/paddle/vision/transforms/hflip_cn.rst
index 5925d07d31e..329f7954aea 100644
--- a/docs/api/paddle/vision/transforms/hflip_cn.rst
+++ b/docs/api/paddle/vision/transforms/hflip_cn.rst
@@ -15,7 +15,7 @@ hflip
 返回
 :::::::::
 
-    ``PIL.Image 或 numpy.ndarray``，翻转后的图像数据。
+     ``PIL.Image 或 numpy.ndarray`` ，翻转后的图像数据。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/normalize_cn.rst b/docs/api/paddle/vision/transforms/normalize_cn.rst
index 07e58ef3156..95ed6c29ab1 100644
--- a/docs/api/paddle/vision/transforms/normalize_cn.rst
+++ b/docs/api/paddle/vision/transforms/normalize_cn.rst
@@ -14,12 +14,12 @@ normalize
     - **mean** (list|tuple) - 用于每个通道归一化的均值。
     - **std** (list|tuple) - 用于每个通道归一化的标准差值。
     - **data_format** (str，可选) - 数据的格式，必须为 'HWC' 或 'CHW'。默认值：'CHW'。
-    - **to_rgb** (bool，可选) - 是否转换为 ``rgb`` 的格式。默认值：False。
+    - **to_rgb** (bool，可选) - 是否转换为  ``rgb``  的格式。默认值：False。
 
 返回
 :::::::::
 
-``numpy array`` 或 ``paddle.Tensor``，归一化后的图像。
+ ``numpy array``  或  ``paddle.Tensor`` ，归一化后的图像。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/pad_cn.rst b/docs/api/paddle/vision/transforms/pad_cn.rst
index 1f862762561..6f8b9cc0c6a 100644
--- a/docs/api/paddle/vision/transforms/pad_cn.rst
+++ b/docs/api/paddle/vision/transforms/pad_cn.rst
@@ -15,15 +15,15 @@ pad
     - **fill** (int|tuple，可选) - 用于填充的像素值。仅当 padding_mode 为 constant 时参数值有效。默认值：0。如果参数值是一个长度为 3 的元组，则会分别用于填充 R，G，B 通道。
     - **padding_mode** (string，可选) - 填充模式。支持：constant, edge, reflect 或 symmetric。默认值：constant。
 
-        - ``constant`` 表示使用常量值进行填充，该值由 fill 参数指定；
-        - ``edge`` 表示使用图像边缘像素值进行填充；
-        - ``reflect`` 表示使用原图像的镜像值进行填充（不使用边缘上的值）；比如：使用该模式对 ``[1, 2, 3, 4]`` 的两端分别填充 2 个值，结果是 ``[3, 2, 1, 2, 3, 4, 3, 2]``。
-        - ``symmetric`` 表示使用原图像的镜像值进行填充（使用边缘上的值）；比如：使用该模式对 ``[1, 2, 3, 4]`` 的两端分别填充 2 个值，结果是 ``[2, 1, 1, 2, 3, 4, 4, 3]``。
+        -  ``constant``  表示使用常量值进行填充，该值由 fill 参数指定；
+        -  ``edge``  表示使用图像边缘像素值进行填充；
+        -  ``reflect``  表示使用原图像的镜像值进行填充（不使用边缘上的值）；比如：使用该模式对  ``[1, 2, 3, 4]``  的两端分别填充 2 个值，结果是  ``[3, 2, 1, 2, 3, 4, 3, 2]`` 。
+        -  ``symmetric``  表示使用原图像的镜像值进行填充（使用边缘上的值）；比如：使用该模式对  ``[1, 2, 3, 4]``  的两端分别填充 2 个值，结果是  ``[2, 1, 1, 2, 3, 4, 4, 3]`` 。
 
 返回
 :::::::::
 
-``PIL.Image`` 或 ``numpy.ndarray``，填充后的图像。
+ ``PIL.Image``  或  ``numpy.ndarray`` ，填充后的图像。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/perspective_cn.rst b/docs/api/paddle/vision/transforms/perspective_cn.rst
index 57d5af28e5f..4e819e94e44 100644
--- a/docs/api/paddle/vision/transforms/perspective_cn.rst
+++ b/docs/api/paddle/vision/transforms/perspective_cn.rst
@@ -13,12 +13,12 @@ perspective
     - **startpoints** (list(list(float))) - 在原图上的四个角（左上、右上、右下、左下）的坐标。
     - **endpoints** (list(list(float))) - 在变换后的图上的四个角（左上、右上、右下、左下）的坐标。
     - **interpolation** (str，可选) - 插值的方法。
-        如果这个参数没有设定或者输入图像为单通道，则该参数会根据使用的后端，被设置为 ``PIL.Image.NEAREST`` 或者 ``cv2.INTER_NEAREST`` 。
-        当使用 ``pil`` 作为后端时, 支持的插值方法如下:
+        如果这个参数没有设定或者输入图像为单通道，则该参数会根据使用的后端，被设置为  ``PIL.Image.NEAREST``  或者  ``cv2.INTER_NEAREST``  。
+        当使用  ``pil``  作为后端时, 支持的插值方法如下:
             - "nearest": Image.NEAREST
             - "bilinear": Image.BILINEAR
             - "bicubic": Image.BICUBIC
-        当使用 ``cv2`` 作为后端时, 支持的插值方法如下:
+        当使用  ``cv2``  作为后端时, 支持的插值方法如下:
             - "nearest": cv2.INTER_NEAREST
             - "bilinear": cv2.INTER_LINEAR
             - "bicubic": cv2.INTER_CUBIC
@@ -27,7 +27,7 @@ perspective
 返回
 ::::::::::::
 
-    ``PIL.Image 或 numpy ndarray 或 paddle.Tensor`` ，透视变换后的图像。
+     ``PIL.Image 或 numpy ndarray 或 paddle.Tensor``  ，透视变换后的图像。
 
 代码示例
 ::::::::::::
diff --git a/docs/api/paddle/vision/transforms/resize_cn.rst b/docs/api/paddle/vision/transforms/resize_cn.rst
index 728b736524a..135394e3dae 100644
--- a/docs/api/paddle/vision/transforms/resize_cn.rst
+++ b/docs/api/paddle/vision/transforms/resize_cn.rst
@@ -14,7 +14,7 @@ resize
     - **size** (int|tuple) - 输出图像大小。如果 size 是一个序列，例如（h，w），输出大小将与此匹配。如果 size 为 int，图像的较小边缘将与此数字匹配，即如果 height > width，则图像将重新缩放为(size * height / width, size)。
     - **interpolation** (int|str，可选) - 插值的方法，默认值：'bilinear'。
 
-        - 当使用 ``pil`` 作为后端时，支持的插值方法如下
+        - 当使用  ``pil``  作为后端时，支持的插值方法如下
 
             + "nearest": Image.NEAREST,
             + "bilinear": Image.BILINEAR,
@@ -23,7 +23,7 @@ resize
             + "lanczos": Image.LANCZOS,
             + "hamming": Image.HAMMING。
 
-        - 当使用 ``cv2`` 作为后端时，支持的插值方法如下
+        - 当使用  ``cv2``  作为后端时，支持的插值方法如下
 
             + "nearest": cv2.INTER_NEAREST,
             + "bilinear": cv2.INTER_LINEAR,
@@ -34,7 +34,7 @@ resize
 返回
 :::::::::
 
-``PIL.Image`` 或 ``numpy.ndarray``，调整大小后的图像数据。
+ ``PIL.Image``  或  ``numpy.ndarray`` ，调整大小后的图像数据。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/rotate_cn.rst b/docs/api/paddle/vision/transforms/rotate_cn.rst
index 64e6e336703..869d079fe77 100644
--- a/docs/api/paddle/vision/transforms/rotate_cn.rst
+++ b/docs/api/paddle/vision/transforms/rotate_cn.rst
@@ -20,7 +20,7 @@ rotate
 返回
 :::::::::
 
-    ``PIL.Image 或 numpy ndarray``，旋转后的图像。
+     ``PIL.Image 或 numpy ndarray`` ，旋转后的图像。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/to_grayscale_cn.rst b/docs/api/paddle/vision/transforms/to_grayscale_cn.rst
index e46e5d02d6f..f183601f533 100644
--- a/docs/api/paddle/vision/transforms/to_grayscale_cn.rst
+++ b/docs/api/paddle/vision/transforms/to_grayscale_cn.rst
@@ -16,7 +16,7 @@ to_grayscale
 返回
 :::::::::
 
-    ``PIL.Image 或 numpy.ndarray``，输入图像的灰度版本。
+     ``PIL.Image 或 numpy.ndarray`` ，输入图像的灰度版本。
 
     - 如果 output_channels = 1：返回一个单通道图像。
     - 如果 output_channels = 3：返回一个 RBG 格式的 3 通道图像。
diff --git a/docs/api/paddle/vision/transforms/to_tensor_cn.rst b/docs/api/paddle/vision/transforms/to_tensor_cn.rst
index 45753178dc4..a627c35e517 100644
--- a/docs/api/paddle/vision/transforms/to_tensor_cn.rst
+++ b/docs/api/paddle/vision/transforms/to_tensor_cn.rst
@@ -5,13 +5,13 @@ to_tensor
 
 .. py:function:: paddle.vision.transforms.to_tensor(pic, data_format='CHW')
 
-将 ``PIL.Image`` 或 ``numpy.ndarray`` 转换成 ``paddle.Tensor``。
+将  ``PIL.Image``  或  ``numpy.ndarray``  转换成  ``paddle.Tensor`` 。
 
-将形状为 （H x W x C）的输入数据 ``PIL.Image`` 或 ``numpy.ndarray`` 转换为 (C x H x W)。
-如果想保持形状不变，可以将参数 ``data_format`` 设置为 ``'HWC'``。
+将形状为 （H x W x C）的输入数据  ``PIL.Image``  或  ``numpy.ndarray``  转换为 (C x H x W)。
+如果想保持形状不变，可以将参数  ``data_format``  设置为  ``'HWC'`` 。
 
-同时，如果输入的 ``PIL.Image`` 的 ``mode`` 是 ``(L, LA, P, I, F, RGB, YCbCr, RGBA, CMYK, 1)``
-其中一种，或者输入的 ``numpy.ndarray`` 数据类型是 'uint8'，那个会将输入数据从（0-255）的范围缩放到
+同时，如果输入的  ``PIL.Image``  的  ``mode``  是  ``(L, LA, P, I, F, RGB, YCbCr, RGBA, CMYK, 1)`` 
+其中一种，或者输入的  ``numpy.ndarray``  数据类型是 'uint8'，那个会将输入数据从（0-255）的范围缩放到
 （0-1）的范围。其他的情况，则保持输入不变。
 
 参数
@@ -23,7 +23,7 @@ to_tensor
 返回
 :::::::::
 
-    ``paddle.Tensor``，转换后的数据。
+     ``paddle.Tensor`` ，转换后的数据。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vision/transforms/vflip_cn.rst b/docs/api/paddle/vision/transforms/vflip_cn.rst
index 4589b529ab8..14fc04299cc 100644
--- a/docs/api/paddle/vision/transforms/vflip_cn.rst
+++ b/docs/api/paddle/vision/transforms/vflip_cn.rst
@@ -15,7 +15,7 @@ vflip
 返回
 :::::::::
 
-    ``PIL.Image 或 numpy.ndarray``，翻转后的图像数据。
+     ``PIL.Image 或 numpy.ndarray`` ，翻转后的图像数据。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/vsplit_cn.rst b/docs/api/paddle/vsplit_cn.rst
index 30e0cec64f5..c0e2e0ca50b 100644
--- a/docs/api/paddle/vsplit_cn.rst
+++ b/docs/api/paddle/vsplit_cn.rst
@@ -7,10 +7,10 @@ vsplit
 
 
 
-``vsplit`` 全称 Vertical Split 即垂直分割，将输入 Tensor 沿着垂直轴分割成多个子 Tensor ，等价于将 :ref:`cn_api_paddle_tensor_split` API 的参数 axis 固定为 0。
+ ``vsplit``  全称 Vertical Split 即垂直分割，将输入 Tensor 沿着垂直轴分割成多个子 Tensor ，等价于将 :ref:`cn_api_paddle_tensor_split` API 的参数 axis 固定为 0。
 
 .. note::
-   请确保使用 ``paddle.vsplit`` 进行变换的 Tensor 维度数量不少于 2。
+   请确保使用  ``paddle.vsplit``  进行变换的 Tensor 维度数量不少于 2。
 
 当 Tensor 维度数量等于 2 时：
 
@@ -25,7 +25,7 @@ vsplit
 参数
 :::::::::
        - **x** (Tensor) - 输入变量，数据类型为 bool、bfloat16、float16、float32、float64、uint8、int8、int32、int64 的多维 Tensor，其维度必须大于 1。
-       - **num_or_indices** (int|list|tuple) - 如果 ``num_or_indices`` 是一个整数 ``n`` ，则 ``x`` 拆分为 ``n`` 部分。如果 ``num_or_indices`` 是整数索引的列表或元组，则在每个索引处分割 ``x`` 。
+       - **num_or_indices** (int|list|tuple) - 如果  ``num_or_indices``  是一个整数  ``n``  ，则  ``x``  拆分为  ``n``  部分。如果  ``num_or_indices``  是整数索引的列表或元组，则在每个索引处分割  ``x``  。
        - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
diff --git a/docs/api/paddle/vstack_cn.rst b/docs/api/paddle/vstack_cn.rst
index d43b4e7f387..62c15534c52 100644
--- a/docs/api/paddle/vstack_cn.rst
+++ b/docs/api/paddle/vstack_cn.rst
@@ -5,19 +5,19 @@ vstack
 
 .. py:function:: paddle.vstack(x, name=None)
 
-沿垂直轴堆叠输入 ``x`` 中的所有张量。所有张量必须具有相同的数据类型。
+沿垂直轴堆叠输入  ``x``  中的所有张量。所有张量必须具有相同的数据类型。
 
 参数
 ::::::::::::
 
-    - **x** (list[Tensor]|tuple[Tensor]) - 输入 ``x`` 可以是张量的 list 或 tuple， ``x`` 中张量的数据类型必须相同。支持的数据类型： ``float16`` 、 ``float32`` 、 ``float64`` 、 ``int32`` 、 ``int64`` 或 ``bfloat16`` 。
+    - **x** (list[Tensor]|tuple[Tensor]) - 输入  ``x``  可以是张量的 list 或 tuple，  ``x``  中张量的数据类型必须相同。支持的数据类型：  ``float16``  、  ``float32``  、  ``float64``  、  ``int32``  、  ``int64``  或  ``bfloat16``  。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
 Tensor，与输入数据类型相同的堆叠张量。
 
-也可以参考下方的图示来理解 ``vstack`` 是如何对张量进行变换的。
+也可以参考下方的图示来理解  ``vstack``  是如何对张量进行变换的。
 
 .. image:: ../../images/api_legend/vstack.png
    :width: 500
diff --git a/docs/api/paddle/where_cn.rst b/docs/api/paddle/where_cn.rst
index 15c203463b0..1db94288ade 100644
--- a/docs/api/paddle/where_cn.rst
+++ b/docs/api/paddle/where_cn.rst
@@ -8,7 +8,7 @@ where
 
 
 
-根据 ``condition`` 来选择 ``x`` 或 ``y`` 中的对应元素来组成新的 Tensor。具体地，
+根据  ``condition``  来选择  ``x``  或  ``y``  中的对应元素来组成新的 Tensor。具体地，
 
 .. math::
     out_i =
@@ -18,27 +18,27 @@ where
     \end{cases}.
 
 .. note::
-    ``numpy.where(condition)`` 功能与 ``paddle.nonzero(condition, as_tuple=True)`` 相同，可以参考 :ref:`cn_api_paddle_nonzero`。
+     ``numpy.where(condition)``  功能与  ``paddle.nonzero(condition, as_tuple=True)``  相同，可以参考 :ref:`cn_api_paddle_nonzero`。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，参数名 ``other`` 可替代 ``y`` ，如 ``paddle.where(condition, input=x, other=y)`` 等价于 ``paddle.where(condition, x=x, y=y)`` 。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，参数名  ``other``  可替代  ``y``  ，如  ``paddle.where(condition, input=x, other=y)``  等价于  ``paddle.where(condition, x=x, y=y)``  。
 
 参数
 ::::::::::::
 
-    - **condition** (Tensor) - 选择 ``x`` 或 ``y`` 元素的条件。在为 True（非零值）时，选择 ``x``，否则选择 ``y``。
-    - **x** (Tensor|scalar，可选) - 条件为 True 时选择的 Tensor 或 scalar，数据类型为 bfloat16、 float16、float32、float64、int32 或 int64。``x`` 和 ``y`` 必须都给出或者都不给出。别名： ``input``。
-    - **y** (Tensor|scalar，可选) - 条件为 False 时选择的 Tensor 或 scalar，数据类型为 bfloat16、float16、float32、float64、int32 或 int64。``x`` 和 ``y`` 必须都给出或者都不给出。别名： ``other``。
+    - **condition** (Tensor) - 选择  ``x``  或  ``y``  元素的条件。在为 True（非零值）时，选择  ``x`` ，否则选择  ``y`` 。
+    - **x** (Tensor|scalar，可选) - 条件为 True 时选择的 Tensor 或 scalar，数据类型为 bfloat16、 float16、float32、float64、int32 或 int64。 ``x``  和  ``y``  必须都给出或者都不给出。别名：  ``input`` 。
+    - **y** (Tensor|scalar，可选) - 条件为 False 时选择的 Tensor 或 scalar，数据类型为 bfloat16、float16、float32、float64、int32 或 int64。 ``x``  和  ``y``  必须都给出或者都不给出。别名：  ``other`` 。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 :::::::::
 
-    - **out** (Tensor，可选) - 输出 Tensor，若不为 ``None``，计算结果将保存在该 Tensor 中，默认值为 ``None``。
+    - **out** (Tensor，可选) - 输出 Tensor，若不为  ``None`` ，计算结果将保存在该 Tensor 中，默认值为  ``None`` 。
 
 返回
 ::::::::::::
-Tensor，形状与 ``condition`` 相同，数据类型与 ``x`` 和 ``y`` 相同。
+Tensor，形状与  ``condition``  相同，数据类型与  ``x``  和  ``y``  相同。
 
 
 
diff --git a/docs/api/paddle/zeros_cn.rst b/docs/api/paddle/zeros_cn.rst
index e9bbfbbc8d1..48397150f2a 100644
--- a/docs/api/paddle/zeros_cn.rst
+++ b/docs/api/paddle/zeros_cn.rst
@@ -7,36 +7,36 @@ zeros
 
 
 
-创建形状为 ``shape`` 、数据类型为 ``dtype`` 且值全为 0 的 Tensor。
+创建形状为  ``shape``  、数据类型为  ``dtype``  且值全为 0 的 Tensor。
 
 .. note::
-    别名支持: 参数名 ``size`` 可替代 ``shape``。
-    ``shape`` 支持可变参数类型。
+    别名支持: 参数名  ``size``  可替代  ``shape`` 。
+     ``shape``  支持可变参数类型。
     使用实例：
-        ``paddle.zeros(1, 2, 3, dtype=paddle.float32)``
-        ``paddle.zeros(size=[1, 2, 3], dtype=paddle.float32)``
+         ``paddle.zeros(1, 2, 3, dtype=paddle.float32)`` 
+         ``paddle.zeros(size=[1, 2, 3], dtype=paddle.float32)`` 
 
 参数
 ::::::::::::
 
     - **shape** (list|tuple|Tensor|*shape) - 生成的 Tensor 的形状。数据类型为 int32 或 int64。
-      如果 ``shape`` 是 list、tuple，则其中的元素可以是 int，或者是形状为 [] 且数据类型为 int32、int64 的 0-D Tensor。
-      如果 ``shape`` 是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor，表示一个列表。
-      如果 ``shape`` 是 \*shape，则可以直接以可变参数的形式传入多个整数（例如 ``randn(2, 3)``）。
-      该参数的别名为 ``size``。
+      如果  ``shape``  是 list、tuple，则其中的元素可以是 int，或者是形状为 [] 且数据类型为 int32、int64 的 0-D Tensor。
+      如果  ``shape``  是 Tensor，则是数据类型为 int32、int64 的 1-D Tensor，表示一个列表。
+      如果  ``shape``  是 \*shape，则可以直接以可变参数的形式传入多个整数（例如  ``randn(2, 3)`` ）。
+      该参数的别名为  ``size`` 。
     - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，数据类型必须为 bool、float16、float32、float64、int32 或 int64。若为 None，数据类型为 float32，默认为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 ::::::::::::
     - **out** (Tensor，可选) - 用于存储结果的 Tensor。若指定，将直接写入该 Tensor，默认值为 None。
-    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。默认值为 None，表示使用当前全局设备（可通过 ``paddle.device.set_device`` 设置）。
+    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。默认值为 None，表示使用当前全局设备（可通过  ``paddle.device.set_device``  设置）。
     - **requires_grad** (bool，可选) - 是否需要为返回的 Tensor 记录梯度信息。默认值为 False。
     - **pin_memory** (bool，可选) - 若为 True，返回的 CPU Tensor 将分配在锁页内存中。仅对 CPU Tensor 生效。默认值为 False。
 
 返回
 ::::::::::::
-值全为 0 的 Tensor，数据类型和 ``dtype`` 定义的类型一致。
+值全为 0 的 Tensor，数据类型和  ``dtype``  定义的类型一致。
 
 
 代码示例
diff --git a/docs/api/paddle/zeros_like_cn.rst b/docs/api/paddle/zeros_like_cn.rst
index 628fed026c0..eef5d49a1c3 100644
--- a/docs/api/paddle/zeros_like_cn.rst
+++ b/docs/api/paddle/zeros_like_cn.rst
@@ -6,26 +6,26 @@ zeros_like
 .. py:function:: paddle.zeros_like(x, dtype=None, name=None, *, device=None, requires_grad=False, pin_memory=False)
 
 
-返回一个和 ``x`` 具有相同的形状的全零 Tensor，数据类型为 ``dtype`` 或者和 ``x`` 相同。
+返回一个和  ``x``  具有相同的形状的全零 Tensor，数据类型为  ``dtype``  或者和  ``x``  相同。
 
 .. note::
-    别名支持: 参数名 ``input`` 可替代 ``x``，如 ``zeros_like(input=x, ...)`` 等价于 ``zeros_like(x=x, ...)``。
+    别名支持: 参数名  ``input``  可替代  ``x`` ，如  ``zeros_like(input=x, ...)``  等价于  ``zeros_like(x=x, ...)`` 。
 
 参数
 ::::::::::
-    - **x** (Tensor) – 输入的多维 Tensor，数据类型可以是 bool，float16, float32，float64，int32，int64。输出 Tensor 的形状和 ``x`` 相同。如果 ``dtype`` 为 None，则输出 Tensor 的数据类型与 ``x`` 相同。别名： ``input``。
-    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，支持 bool，float16, float32，float64，int32，int64。当该参数值为 None 时，输出 Tensor 的数据类型与 ``x`` 相同。默认值为 None。
+    - **x** (Tensor) – 输入的多维 Tensor，数据类型可以是 bool，float16, float32，float64，int32，int64。输出 Tensor 的形状和  ``x``  相同。如果  ``dtype``  为 None，则输出 Tensor 的数据类型与  ``x``  相同。别名：  ``input`` 。
+    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型，支持 bool，float16, float32，float64，int32，int64。当该参数值为 None 时，输出 Tensor 的数据类型与  ``x``  相同。默认值为 None。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 关键字参数
 ::::::::::::
-    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。若为 None，则与 ``x`` 保持一致。
+    - **device** (PlaceLike|None，可选) - 期望创建 Tensor 所在的设备。若为 None，则与  ``x``  保持一致。
     - **requires_grad** (bool，可选) - 是否需要为返回的 Tensor 记录梯度信息。默认值为 False。
     - **pin_memory** (bool，可选) - 若为 True，返回的 CPU Tensor 将分配在锁页内存中。仅对 CPU Tensor 生效。默认值为 False。
 
 返回
 ::::::::::
-    Tensor：和 ``x`` 具有相同的形状全零 Tensor，数据类型为 ``dtype`` 或者和 ``x`` 相同。
+    Tensor：和  ``x``  具有相同的形状全零 Tensor，数据类型为  ``dtype``  或者和  ``x``  相同。
 
 
 代码示例