diff --git a/docs/api/paddle/metric/Metric_cn.rst b/docs/api/paddle/metric/Metric_cn.rst
index 2c1e1ee34a5..363107d5925 100644
--- a/docs/api/paddle/metric/Metric_cn.rst
+++ b/docs/api/paddle/metric/Metric_cn.rst
@@ -17,13 +17,13 @@ Metric
             m.update(prediction, label)
         m.accumulate()
 
-`compute` 接口的进阶用法：
+``compute`` 接口的进阶用法：
 
-在 `compute` 中可以使用 PaddlePaddle 内置的算子进行评估器的状态，而不是通过
-Python/NumPy，这样可以加速计算。`update` 接口将 `compute` 的输出作为
+在 ``compute`` 中可以使用 PaddlePaddle 内置的算子进行评估器的状态，而不是通过
+Python/NumPy，这样可以加速计算。``update`` 接口将 ``compute`` 的输出作为
 输入，内部采用 Python/NumPy 计算。
 
-`Metric` 计算流程如下 （在{}中的表示模型和评估器的计算）:
+``Metric`` 计算流程如下 （在{}中的表示模型和评估器的计算）:
 
     .. code-block:: text
 
@@ -46,9 +46,9 @@ Python/NumPy，这样可以加速计算。`update` 接口将 `compute` 的输出
 代码示例 1
 ::::::::::::
 
-以 计算正确率的 `Accuracy` 为例，该评估器的输入为 `pred` 和 `label`，可以在 `compute` 中通过 `pred` 和 `label`先计算正确预测的矩阵。
-例如，预测结果包含 10 类，`pred` 的 shape 是[N, 10]，`label` 的 shape 是[N, 1]，N 是 batch size，我们需要计算 top-1 和 top-5 的准确率，
-可以在 `compute` 中计算每个样本的 top-5 得分，正确预测的矩阵的 shape 是[N, 5]。
+以 计算正确率的 ``Accuracy`` 为例，该评估器的输入为 ``pred`` 和 ``label``，可以在 ``compute`` 中通过 ``pred`` 和 ``label`` 先计算正确预测的矩阵。
+例如，预测结果包含 10 类，``pred`` 的 shape 是[N, 10]，``label`` 的 shape 是[N, 1]，N 是 batch size，我们需要计算 top-1 和 top-5 的准确率，
+可以在 ``compute`` 中计算每个样本的 top-5 得分，正确预测的矩阵的 shape 是[N, 5]。
 
 
 COPY-FROM: paddle.metric.Metric:code-compute-example
@@ -56,7 +56,7 @@ COPY-FROM: paddle.metric.Metric:code-compute-example
 代码示例 2
 ::::::::::::
 
-在 `compute` 中的计算，使用内置的算子(可以跑在 GPU 上，使得速度更快)。作为 `update` 的输入，该接口计算如下：
+在 ``compute`` 中的计算，使用内置的算子(可以跑在 GPU 上，使得速度更快)。作为 ``update`` 的输入，该接口计算如下：
 
 COPY-FROM: paddle.metric.Metric:code-update-example
 
@@ -75,10 +75,10 @@ reset()
 update(*args)
 '''''''''
 
-更新状态。如果定义了 `compute` ， `update` 的输入是 `compute` 的输出。如果没有定义，则输入是网络的输出**output**和标签**label**，
-如：`update(output1, output2, ..., label1, label2,...)` 。
+更新状态。如果定义了 ``compute``， ``update`` 的输入是 ``compute`` 的输出。如果没有定义，则输入是网络的输出**output**和标签**label**，
+如：``update(output1, output2, ..., label1, label2,...)`` 。
 
-也可以参考 `update` 。
+也可以参考 ``update`` 。
 
 
 accumulate()
@@ -106,7 +106,7 @@ compute()
 
 此接口可以通过 PaddlePaddle 内置的算子计算 metric 的状态，可以加速 metric 的计算，为可选的高阶接口。
 
-- 如果这个接口定义了，输入是网络的输出 **outputs** 和 标签 **labels**，定义如：`compute(output1, output2, ..., label1, label2,...)` 。
-- 如果这个接口没有定义，默认的行为是直接将输入参数返回给 `update`，则其定义如：`update(output1, output2, ..., label1, label2,...)` 。
+- 如果这个接口定义了，输入是网络的输出 **outputs** 和 标签 **labels**，定义如：``compute(output1, output2, ..., label1, label2,...)`` 。
+- 如果这个接口没有定义，默认的行为是直接将输入参数返回给 ``update``，则其定义如：``update(output1, output2, ..., label1, label2,...)`` 。
 
-也可以参考 `compute` 。
+也可以参考 ``compute`` 。
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..4c0b41a71b9 100755
--- a/docs/api/paddle/nn/functional/adaptive_avg_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/adaptive_avg_pool1d_cn.rst
@@ -8,7 +8,7 @@ adaptive_avg_pool1d
 根据 ``output_size`` 对 Tensor ``x`` 计算 1D 自适应平均池化。
 
 .. note::
-   详细请参考对应的 `Class` 请参考：:ref:`cn_api_paddle_nn_AdaptiveAvgPool1D`。
+   详细请参考对应的 ``Class`` 请参考：:ref:`cn_api_paddle_nn_AdaptiveAvgPool1D`。
 
 
 参数
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 26a38bed7bf..98b99a6d350 100755
--- a/docs/api/paddle/nn/functional/adaptive_max_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/adaptive_max_pool1d_cn.rst
@@ -10,7 +10,7 @@ adaptive_max_pool1d
 
 
 ..  note::
-    详细请参考对应的 `Class` 请参考：:ref:`cn_api_paddle_nn_AdaptiveMaxPool1D` 。
+    详细请参考对应的 ``Class`` 请参考：:ref:`cn_api_paddle_nn_AdaptiveMaxPool1D` 。
 
 
 参数
diff --git a/docs/api/paddle/nn/functional/avg_pool1d_cn.rst b/docs/api/paddle/nn/functional/avg_pool1d_cn.rst
index ab61f7351ca..a2934233b7b 100755
--- a/docs/api/paddle/nn/functional/avg_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/avg_pool1d_cn.rst
@@ -9,7 +9,7 @@ avg_pool1d
 默认是以 ``NCL`` 格式表示的，其中 ``N`` 是 batch size, ``C`` 是通道数，``L`` 是输入特征的长度。
 
 .. note::
-   详细请参考对应的 `Class` 请参考：:ref:`cn_api_paddle_nn_AvgPool1D` 。
+   详细请参考对应的 ``Class`` 请参考：:ref:`cn_api_paddle_nn_AvgPool1D` 。
 
 
 参数
diff --git a/docs/api/paddle/nn/functional/avg_pool2d_cn.rst b/docs/api/paddle/nn/functional/avg_pool2d_cn.rst
index 8c565b2d5f2..4dd9cf21237 100644
--- a/docs/api/paddle/nn/functional/avg_pool2d_cn.rst
+++ b/docs/api/paddle/nn/functional/avg_pool2d_cn.rst
@@ -4,8 +4,8 @@ avg_pool2d
 -------------------------------
 
 .. py:function:: paddle.nn.functional.avg_pool2d(x, kernel_size, stride=None, padding=0, ceil_mode=False, exclusive=True, divisor_override=None, data_format="NCHW", name=None)
-该函数是一个二维平均池化函数，其将构建一个二维平均池化层，根据输入参数 `kernel_size`, `stride`,
-`padding` 等参数对输入做平均池化操作。
+该函数是一个二维平均池化函数，其将构建一个二维平均池化层，根据输入参数 ``kernel_size``, ``stride``,
+``padding`` 等参数对输入做平均池化操作。
 
 例如：
 
diff --git a/docs/api/paddle/nn/functional/avg_pool3d_cn.rst b/docs/api/paddle/nn/functional/avg_pool3d_cn.rst
index 80df259eb76..1e8d3d6f35f 100644
--- a/docs/api/paddle/nn/functional/avg_pool3d_cn.rst
+++ b/docs/api/paddle/nn/functional/avg_pool3d_cn.rst
@@ -4,8 +4,8 @@ avg_pool3d
 -------------------------------
 
 .. py:function:: paddle.nn.functional.avg_pool3d(x, kernel_size, stride=None, padding=0, ceil_mode=False, exclusive=True, divisor_override=None, data_format="NCDHW", name=None)
-该函数是一个三维平均池化函数，根据输入参数 `kernel_size`, `stride`,
-`padding` 等参数对输入做平均池化操作。
+该函数是一个三维平均池化函数，根据输入参数 ``kernel_size``, ``stride``,
+``padding`` 等参数对输入做平均池化操作。
 
 
 例如：
diff --git a/docs/api/paddle/nn/functional/fractional_max_pool2d_cn.rst b/docs/api/paddle/nn/functional/fractional_max_pool2d_cn.rst
index 8bcd333ddab..7a1b95c09a9 100644
--- a/docs/api/paddle/nn/functional/fractional_max_pool2d_cn.rst
+++ b/docs/api/paddle/nn/functional/fractional_max_pool2d_cn.rst
@@ -5,11 +5,11 @@ fractional_max_pool2d
 
 .. py:function:: paddle.nn.functional.fractional_max_pool2d(x, output_size, kernel_size=None, random_u=None, return_mask=False, name=None)
 
-对输入的 Tensor `x` 采取 `2` 维分数阶最大值池化操作，具体可以参考论文：
+对输入的 Tensor ``x`` 采取 ``2`` 维分数阶最大值池化操作，具体可以参考论文：
 
 [1] Ben Graham, Fractional Max-Pooling. 2015. http://arxiv.org/abs/1412.6071
 
-其中输出的 `H` 和 `W` 由参数 `output_size` 决定。
+其中输出的 ``H`` 和 ``W`` 由参数 ``output_size`` 决定。
 
 对于各个输出维度，分数阶最大值池化的计算公式为：
 
@@ -25,12 +25,12 @@ fractional_max_pool2d
 
     where, u \in (0, 1), i = 0,1,2...size_{output}
 
-公式中的 `u` 即为函数中的参数 `random_u`。另外，由于 `ceil` 对于正小数的操作最小值为 `1` ，因此这里需要再减去 `1` 使索引可以从 `0` 开始计数。
+公式中的 ``u`` 即为函数中的参数 ``random_u``。另外，由于 ``ceil`` 对于正小数的操作最小值为 ``1`` ，因此这里需要再减去 ``1`` 使索引可以从 ``0`` 开始计数。
 
-例如，有一个长度为 `7` 的序列 `[2, 4, 3, 1, 5, 2, 3]` ， `output_size` 为 `5` ， `random_u` 为 `0.3`。
-则由上述公式可得 `alpha = 7/5 = 1.4` ， 索引的起始序列为 `[0, 1, 3, 4, 6]` ，索引的截止序列为 `[1, 3, 4, 6, 7]` 。
-进而得到论文中的随机序列为 `index_end - index_start = [1, 2, 1, 2, 1]` 。
-由于池化操作的步长与核尺寸相同，同为此随机序列，最终得到池化输出为 `[2, 4, 1, 5, 3]` 。
+例如，有一个长度为 ``7`` 的序列 ``[2, 4, 3, 1, 5, 2, 3]`` ， ``output_size`` 为 ``5`` ， ``random_u`` 为 ``0.3``。
+则由上述公式可得 ``alpha = 7/5 = 1.4`` ， 索引的起始序列为 ``[0, 1, 3, 4, 6]`` ，索引的截止序列为 ``[1, 3, 4, 6, 7]`` 。
+进而得到论文中的随机序列为 ``index_end - index_start = [1, 2, 1, 2, 1]`` 。
+由于池化操作的步长与核尺寸相同，同为此随机序列，最终得到池化输出为 ``[2, 4, 1, 5, 3]`` 。
 
 参数
 :::::::::
@@ -43,7 +43,7 @@ fractional_max_pool2d
 
 返回
 :::::::::
-`Tensor`，输入 `x` 经过分数阶最大值池化计算得到的目标 4-D Tensor，其数据类型与输入相同。
+``Tensor``，输入 ``x`` 经过分数阶最大值池化计算得到的目标 4-D Tensor，其数据类型与输入相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/fractional_max_pool3d_cn.rst b/docs/api/paddle/nn/functional/fractional_max_pool3d_cn.rst
index 828762b4db0..31aaf6d0e98 100644
--- a/docs/api/paddle/nn/functional/fractional_max_pool3d_cn.rst
+++ b/docs/api/paddle/nn/functional/fractional_max_pool3d_cn.rst
@@ -5,11 +5,11 @@ fractional_max_pool3d
 
 .. py:function:: paddle.nn.functional.fractional_max_pool3d(x, output_size, kernel_size=None, random_u=None, return_mask=False, name=None)
 
-对输入的 Tensor `x` 采取 `3` 维分数阶最大值池化操作，具体可以参考论文：
+对输入的 Tensor ``x`` 采取 ``3`` 维分数阶最大值池化操作，具体可以参考论文：
 
 [1] Ben Graham, Fractional Max-Pooling. 2015. http://arxiv.org/abs/1412.6071
 
-其中输出的 `D`, `H` 和 `W` 由参数 `output_size` 决定。
+其中输出的 ``D``, ``H`` 和 ``W`` 由参数 ``output_size`` 决定。
 
 对于各个输出维度，分数阶最大值池化的计算公式为：
 
@@ -25,12 +25,12 @@ fractional_max_pool3d
 
     where, u \in (0, 1), i = 0,1,2...size_{output}
 
-公式中的 `u` 即为函数中的参数 `random_u`。另外，由于 `ceil` 对于正小数的操作最小值为 `1` ，因此这里需要再减去 `1` 使索引可以从 `0` 开始计数。
+公式中的 ``u`` 即为函数中的参数 ``random_u``。另外，由于 ``ceil`` 对于正小数的操作最小值为 ``1`` ，因此这里需要再减去 ``1`` 使索引可以从 ``0`` 开始计数。
 
-例如，有一个长度为 `7` 的序列 `[2, 4, 3, 1, 5, 2, 3]` ， `output_size` 为 `5` ， `random_u` 为 `0.3`。
-则由上述公式可得 `alpha = 7/5 = 1.4` ， 索引的起始序列为 `[0, 1, 3, 4, 6]` ，索引的截止序列为 `[1, 3, 4, 6, 7]` 。
-进而得到论文中的随机序列为 `index_end - index_start = [1, 2, 1, 2, 1]` 。
-由于池化操作的步长与核尺寸相同，同为此随机序列，最终得到池化输出为 `[2, 4, 1, 5, 3]` 。
+例如，有一个长度为 ``7`` 的序列 ``[2, 4, 3, 1, 5, 2, 3]`` ， ``output_size`` 为 ``5`` ， ``random_u`` 为 ``0.3``。
+则由上述公式可得 ``alpha = 7/5 = 1.4`` ， 索引的起始序列为 ``[0, 1, 3, 4, 6]`` ，索引的截止序列为 ``[1, 3, 4, 6, 7]`` 。
+进而得到论文中的随机序列为 ``index_end - index_start = [1, 2, 1, 2, 1]`` 。
+由于池化操作的步长与核尺寸相同，同为此随机序列，最终得到池化输出为 ``[2, 4, 1, 5, 3]`` 。
 
 参数
 :::::::::
@@ -43,7 +43,7 @@ fractional_max_pool3d
 
 返回
 :::::::::
-`Tensor`，输入 `x` 经过分数阶最大值池化计算得到的目标 5-D Tensor，其数据类型与输入相同。
+``Tensor``，输入 ``x`` 经过分数阶最大值池化计算得到的目标 5-D Tensor，其数据类型与输入相同。
 
 代码示例
 :::::::::
diff --git a/docs/api/paddle/nn/functional/lp_pool1d_cn.rst b/docs/api/paddle/nn/functional/lp_pool1d_cn.rst
index ea83afec2be..d70ab576a07 100644
--- a/docs/api/paddle/nn/functional/lp_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/lp_pool1d_cn.rst
@@ -9,7 +9,7 @@ lp_pool1d
 默认是以 ``NCL`` 格式表示的，其中 ``N`` 是 batch size, ``C`` 是通道数，``L`` 是输入特征的长度。
 
 .. note::
-   详细请参考对应的 `Class` 请参考：:ref:`cn_api_paddle_nn_LPPool1D` 。
+   详细请参考对应的 ``Class`` 请参考：:ref:`cn_api_paddle_nn_LPPool1D` 。
 
 
 参数
diff --git a/docs/api/paddle/nn/functional/lp_pool2d_cn.rst b/docs/api/paddle/nn/functional/lp_pool2d_cn.rst
index 97a53cad8d6..fc17ebfd98b 100644
--- a/docs/api/paddle/nn/functional/lp_pool2d_cn.rst
+++ b/docs/api/paddle/nn/functional/lp_pool2d_cn.rst
@@ -4,8 +4,8 @@ lp_pool2d
 -------------------------------
 
 .. py:function:: paddle.nn.functional.lp_pool2d(x, norm_type, kernel_size, stride=None, padding=0, ceil_mode=False, data_format="NCHW", name=None)
-该函数是一个二维幂平均池化函数，其将构建一个二维幂平均池化层，根据输入参数 `kernel_size`, `stride`,
-`padding` 等参数对输入做平均池化操作。
+该函数是一个二维幂平均池化函数，其将构建一个二维幂平均池化层，根据输入参数 ``kernel_size``, ``stride``,
+``padding`` 等参数对输入做平均池化操作。
 
 例如：
 
diff --git a/docs/api/paddle/nn/functional/max_pool1d_cn.rst b/docs/api/paddle/nn/functional/max_pool1d_cn.rst
index 1320ebffc59..dc1a409b652 100755
--- a/docs/api/paddle/nn/functional/max_pool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool1d_cn.rst
@@ -9,7 +9,7 @@ max_pool1d
 默认是以 ``NCL`` 格式表示的，其中 ``N`` 是 batch size, ``C`` 是通道数，``L`` 是输入特征的长度。
 
 .. note::
-   详细请参考对应的 `Class` 请参考：:ref:`cn_api_paddle_nn_MaxPool1D` 。
+   详细请参考对应的 ``Class`` 请参考：:ref:`cn_api_paddle_nn_MaxPool1D` 。
 
 参数
 :::::::::
diff --git a/docs/api/paddle/nn/functional/max_pool2d_cn.rst b/docs/api/paddle/nn/functional/max_pool2d_cn.rst
index fd9af4721f6..253d4dce40b 100644
--- a/docs/api/paddle/nn/functional/max_pool2d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool2d_cn.rst
@@ -4,8 +4,8 @@ max_pool2d
 -------------------------------
 
 .. py:function:: paddle.nn.functional.max_pool2d(x, kernel_size, stride=None, padding=0, return_mask=False, ceil_mode=False, dilation=1, data_format="NCHW", name=None)
-构建 `max_pool2d` 类的一个可调用对象，其将构建一个二维最大池化层，根据输入参数 `kernel_size`, `stride`,
-`padding` 等参数对输入做最大池化操作。
+构建 ``max_pool2d`` 类的一个可调用对象，其将构建一个二维最大池化层，根据输入参数 ``kernel_size``, ``stride``,
+``padding`` 等参数对输入做最大池化操作。
 
 例如：
 
diff --git a/docs/api/paddle/nn/functional/max_pool3d_cn.rst b/docs/api/paddle/nn/functional/max_pool3d_cn.rst
index 1e82d14d3c8..a3d57d9c580 100644
--- a/docs/api/paddle/nn/functional/max_pool3d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_pool3d_cn.rst
@@ -4,8 +4,8 @@ max_pool3d
 -------------------------------
 
 .. py:function:: paddle.nn.functional.max_pool3d(x, kernel_size, stride=None, padding=0, return_mask=False, ceil_mode=False, dilation=1, data_format="NCDHW", name=None)
-该函数是一个三维最大池化函数，根据输入参数 `kernel_size`, `stride`,
-`padding` 等参数对输入 `x` 做最大池化操作。
+该函数是一个三维最大池化函数，根据输入参数 ``kernel_size``, ``stride``,
+``padding`` 等参数对输入 ``x`` 做最大池化操作。
 
 例如：
 
diff --git a/docs/api/paddle/nn/functional/max_unpool1d_cn.rst b/docs/api/paddle/nn/functional/max_unpool1d_cn.rst
index b74e8b8b597..d2e4f8aa2f1 100644
--- a/docs/api/paddle/nn/functional/max_unpool1d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_unpool1d_cn.rst
@@ -5,10 +5,10 @@ max_unpool1d
 
 .. py:function:: paddle.nn.functional.max_unpool1d(x, indices, kernel_size, stride=None, padding=0, data_format="NCL", output_size=None, name=None)
 
-这个 API 实现了 `1D 最大反池化` 操作
+这个 API 实现了 ``1D 最大反池化`` 操作
 
 .. note::
-   更多细节请参考对应的 `Class` 请参考 :ref:`cn_api_paddle_nn_MaxUnPool1D` 。
+   更多细节请参考对应的 ``Class`` 请参考 :ref:`cn_api_paddle_nn_MaxUnPool1D` 。
 
 
 输入：
@@ -19,7 +19,7 @@ max_unpool1d
 .. math::
   L_{out} = (L_{in} - 1) \times \text{stride} - 2 \times \text{padding} + \text{kernel_size}
 
-或由参数 `output_size` 直接指定
+或由参数 ``output_size`` 直接指定
 
 
 参数
diff --git a/docs/api/paddle/nn/functional/max_unpool2d_cn.rst b/docs/api/paddle/nn/functional/max_unpool2d_cn.rst
index 3ea2f558e32..9ac94cac724 100644
--- a/docs/api/paddle/nn/functional/max_unpool2d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_unpool2d_cn.rst
@@ -5,10 +5,10 @@ max_unpool2d
 
 .. py:function:: paddle.nn.functional.max_unpool2d(x, indices, kernel_size, stride=None,padding=0,data_format="NCHW",output_size=None,name=None)
 
-这个 API 实现了 `2D 最大反池化` 操作
+这个 API 实现了 ``2D 最大反池化`` 操作
 
 .. note::
-   更多细节请参考对应的 `Class` 请参考 :ref:`cn_api_paddle_nn_MaxUnPool2D` 。
+   更多细节请参考对应的 ``Class`` 请参考 :ref:`cn_api_paddle_nn_MaxUnPool2D` 。
 
 
 输入：
@@ -22,7 +22,7 @@ max_unpool2d
 .. math::
   W_{out} = (W_{in} - 1) \times \text{stride[1]} - 2 \times \text{padding[1]} + \text{kernel_size[1]}
 
-或由参数 `output_size` 直接指定
+或由参数 ``output_size`` 直接指定
 
 
 参数
diff --git a/docs/api/paddle/nn/functional/max_unpool3d_cn.rst b/docs/api/paddle/nn/functional/max_unpool3d_cn.rst
index 41e44338aff..e9f7effbd55 100644
--- a/docs/api/paddle/nn/functional/max_unpool3d_cn.rst
+++ b/docs/api/paddle/nn/functional/max_unpool3d_cn.rst
@@ -5,10 +5,10 @@ max_unpool3d
 
 .. py:function:: paddle.nn.functional.max_unpool3d(x, indices, kernel_size, stride=None, padding=0, data_format="NCDHW", output_size=None, name=None)
 
-这个 API 实现了 `3D 最大反池化` 操作
+这个 API 实现了 ``3D 最大反池化`` 操作
 
 .. note::
-   更多细节请参考对应的 `Class` 请参考 :ref:`cn_api_paddle_nn_MaxUnPool3D` 。
+   更多细节请参考对应的 ``Class`` 请参考 :ref:`cn_api_paddle_nn_MaxUnPool3D` 。
 
 
 输入：
@@ -25,7 +25,7 @@ max_unpool3d
 .. math::
   W_{out} = (W_{in} - 1) \times \text{stride[2]} - 2 \times \text{padding[2]} + \text{kernel_size[2]}
 
-或由参数 `output_size` 直接指定
+或由参数 ``output_size`` 直接指定
 
 
 参数
diff --git a/docs/api/paddle/optimizer/Adadelta_cn.rst b/docs/api/paddle/optimizer/Adadelta_cn.rst
index cfeb4644a66..eac1566700e 100644
--- a/docs/api/paddle/optimizer/Adadelta_cn.rst
+++ b/docs/api/paddle/optimizer/Adadelta_cn.rst
@@ -34,7 +34,7 @@ Adadelta 优化器，是对 :ref:`Adagrad <cn_api_paddle_optimizer_Adagrad>` 的
       默认值为 None，此时将不进行梯度裁剪。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
-Adadelta 优化器出自 `DECOUPLED WEIGHT DECAY REGULARIZATION 论文 <https://arxiv.org/pdf/1711.05101.pdf>`，用来解决 Adam 优化器中 L2 正则化失效的问题。
+Adadelta 优化器出自 `DECOUPLED WEIGHT DECAY REGULARIZATION 论文 <https://arxiv.org/pdf/1711.05101.pdf>`_，用来解决 Adam 优化器中 L2 正则化失效的问题。
 
 
 
diff --git a/docs/api/paddle/sparse/masked_matmul_cn.rst b/docs/api/paddle/sparse/masked_matmul_cn.rst
index 4d60b41c7ab..14db5ecf64b 100644
--- a/docs/api/paddle/sparse/masked_matmul_cn.rst
+++ b/docs/api/paddle/sparse/masked_matmul_cn.rst
@@ -6,10 +6,10 @@ masked_matmul
 .. py:function:: paddle.sparse.masked_matmul(x, y, mask, name=None)
 
 .. note::
-    该 API 从 `CUDA 11.3` 开始支持。
+    该 API 从 ``CUDA 11.3`` 开始支持。
 
-对输入 :attr:`x` 与输入 :attr:`y` 两个 DenseTensor 求矩阵乘法，同时根据稀疏 Tensor `mask` 进行压缩存储，
-返回一个与 `mask` 布局一致的稀疏 Tensor。
+对输入 :attr:`x` 与输入 :attr:`y` 两个 DenseTensor 求矩阵乘法，同时根据稀疏 Tensor ``mask`` 进行压缩存储，
+返回一个与 ``mask`` 布局一致的稀疏 Tensor。
 
 输入、输出的格式对应关系如下：
 
@@ -19,8 +19,8 @@ masked_matmul
 
      x[DenseTensor] @ y[DenseTensor] * mask[SparseCsrTensor] -> out[SparseCsrTensor]
 
-该 API 支持反向传播，`x` 和 `y` 必须 >= 2D，不支持自动广播。 `x` 的 shape 应该为 `[*, M, K]` ， `y` 的 shape 应该为
-`[*, K, N]` ， `mask` 的 shape 应该为 `[*, M, N]` 。其中 `*` 为 0 或者批维度。
+该 API 支持反向传播，``x`` 和 ``y`` 必须 >= 2D，不支持自动广播。 ``x`` 的 shape 应该为 ``[*, M, K]``， ``y`` 的 shape 应该为
+``[*, K, N]``， ``mask`` 的 shape 应该为 ``[*, M, N]``。其中 ``*`` 为 0 或者批维度。
 
 参数
 :::::::::
@@ -31,7 +31,7 @@ masked_matmul
 
 返回
 :::::::::
-SparseTensor: 其 Tensor 类型、dtype、shape 均与 `mask` 相同。
+SparseTensor: 其 Tensor 类型、dtype、shape 均与 ``mask`` 相同。
 
 
 代码示例
diff --git a/docs/api/paddle/sparse/matmul_cn.rst b/docs/api/paddle/sparse/matmul_cn.rst
index 929ba721b62..b1c4d4f85cb 100644
--- a/docs/api/paddle/sparse/matmul_cn.rst
+++ b/docs/api/paddle/sparse/matmul_cn.rst
@@ -6,9 +6,9 @@ matmul
 .. py:function:: paddle.sparse.matmul(x, y, name=None)
 
 .. note::
-    该 API 从 `CUDA 11.0` 开始支持。
+    该 API 从 ``CUDA 11.0`` 开始支持。
 
-对输入 :attr:`x` 与输入 :attr:`y` 求稀疏矩阵乘法，`x` 为稀疏 Tensor， `y` 可为稀疏 Tensor 或稠密 Tensor。
+对输入 :attr:`x` 与输入 :attr:`y` 求稀疏矩阵乘法，``x`` 为稀疏 Tensor， ``y`` 可为稀疏 Tensor 或稠密 Tensor。
 
 输入、输出的格式对应关系如下：
 
@@ -22,8 +22,8 @@ matmul
 
      x[SparseCooTensor] @ y[DenseTensor] -> out[DenseTensor]
 
-该 API 支持反向传播，`x` 和 `y` 必须 >= 2D，不支持自动广播。 `x` 的 shape 应该为 `[*, M, K]` ， `y` 的 shape 应该为
-`[*, K, N]` ，其中 `*` 为 0 或者批维度。
+该 API 支持反向传播，``x`` 和 ``y`` 必须 >= 2D，不支持自动广播。 ``x`` 的 shape 应该为 ``[*, M, K]``， ``y`` 的 shape 应该为
+``[*, K, N]``，其中 ``*`` 为 0 或者批维度。
 
 参数
 :::::::::
@@ -33,7 +33,7 @@ matmul
 
 返回
 :::::::::
-SparseTensor|DenseTensor: 其 Tensor 类型由 `x` 和 `y` 共同决定，数据类型与输入相同。
+SparseTensor|DenseTensor: 其 Tensor 类型由 ``x`` 和 ``y`` 共同决定，数据类型与输入相同。
 
 
 代码示例
diff --git a/docs/api/paddle/sparse/mv_cn.rst b/docs/api/paddle/sparse/mv_cn.rst
index 869f79cd940..2429d971ba1 100644
--- a/docs/api/paddle/sparse/mv_cn.rst
+++ b/docs/api/paddle/sparse/mv_cn.rst
@@ -6,9 +6,9 @@ mv
 .. py:function:: paddle.sparse.mv(x, vec, name=None)
 
 .. note::
-    该 API 从 `CUDA 11.0` 开始支持。
+    该 API 从 ``CUDA 11.0`` 开始支持。
 
-输入 :attr:`x` 为稀疏矩阵，输入 :attr:`vec` 为稠密向量，对 `x` 与 `vec` 计算矩阵与向量相乘。
+输入 :attr:`x` 为稀疏矩阵，输入 :attr:`vec` 为稠密向量，对 ``x`` 与 ``vec`` 计算矩阵与向量相乘。
 
 输入、输出的格式对应关系如下：
 
@@ -18,8 +18,8 @@ mv
 
      x[SparseCooTensor] @ vec[DenseTensor] -> out[DenseTensor]
 
-该 API 支持反向传播。输入 `x` 的 shape 应该为 `[M, N]` ，输入 `vec` 的 shape 应该为 `[N]` ，输出 `out`
-的 shape 为 `[M]` 。
+该 API 支持反向传播。输入 ``x`` 的 shape 应该为 ``[M, N]``，输入 ``vec`` 的 shape 应该为 ``[N]``，输出 ``out``
+的 shape 为 ``[M]``。
 
 参数
 :::::::::
diff --git a/docs/api/paddle/sparse/nn/functional/attention_cn.rst b/docs/api/paddle/sparse/nn/functional/attention_cn.rst
index 5f36ad1c5cc..3da0815643e 100644
--- a/docs/api/paddle/sparse/nn/functional/attention_cn.rst
+++ b/docs/api/paddle/sparse/nn/functional/attention_cn.rst
@@ -5,24 +5,24 @@ attention
 .. py:function:: paddle.sparse.nn.functional.attention(query, key, value, sparse_mask, key_padding_mask=None, attn_mask=None, name=None)
 
 .. note::
-    该 API 从 `CUDA 11.7` 开始支持。
+  该 API 从 ``CUDA 11.7`` 开始支持。
 
 稀疏 Attention，该 API 内部使用 SparseCsrTensor 来存储 Transformer 模块中的 attention 矩阵，从而达到减少显存占用、提高性能的目的。
-参数 `sparse_mask` 描述了稀疏矩阵的非 0 元素索引布局。
+参数 ``sparse_mask`` 描述了稀疏矩阵的非 0 元素索引布局。
 
 .. math::
     result = softmax(\frac{ Q * K^T }{\sqrt{d}}) * V
 
-其中：矩阵 `Q` `K` `V` 表示 attention 模块的三个输入 Tensor，其 shape 均为 `[batch_size, num_heads, seq_len, head_dim]` ，
-公式中的 `d` 代表 `head_dim` 。
+其中：矩阵 ``Q`` ``K`` ``V`` 表示 attention 模块的三个输入 Tensor，其 shape 均为 ``[batch_size, num_heads, seq_len, head_dim]``，
+公式中的 ``d`` 代表 ``head_dim``。
 
 参数
 ::::::::::
-    - **query** (DenseTensor) - Attention 模块的 `query` 输入，4D Tensor，数据类型为 float32、float64。
-    - **key** (DenseTensor) - Attention 模块的 `key` 输入，4D Tensor，数据类型为 float32、float64。
-    - **value** (DenseTensor) - Attention 模块的 `value` 输入，4D Tensor，数据类型为 float32、float64。
+    - **query** (DenseTensor) - Attention 模块的 ``query`` 输入，4D Tensor，数据类型为 float32、float64。
+    - **key** (DenseTensor) - Attention 模块的 ``key`` 输入，4D Tensor，数据类型为 float32、float64。
+    - **value** (DenseTensor) - Attention 模块的 ``value`` 输入，4D Tensor，数据类型为 float32、float64。
     - **sparse_mask** (SparseCsrTensor) - Attention 模块的非 0 元素布局，是一个 3D 的 SparseCsrTensor，shape 为 `[batch_size*num_heads, seq_len, seq_len]` 。
-      同时每个批次的非 0 元素个数均相等。`crows` 和 `cols` 的数据类型为 int64，`value` 的数据类型为 float32、float64。
+      同时每个批次的非 0 元素个数均相等。``crows`` 和 ``cols`` 的数据类型为 int64，``value`` 的数据类型为 float32、float64。
     - **key_padding_mask** (DenseTensor, 可选) - Attention 模块中的 key padding mask，是一个 2D 的 DenseTensor，shape 为 `[batch_size, seq_len]` 。
       数据类型为 float32、float64。默认：None，表示无此掩码运算。
     - **attn_mask** (DenseTensor, 可选) - Attention 模块中的 attention mask，是一个 2D 的 DenseTensor，shape 为 `[seq_len, seq_len]` 。
diff --git a/docs/api/paddle/sparse/sum_cn.rst b/docs/api/paddle/sparse/sum_cn.rst
index 8d14edb308e..14a35e3571f 100644
--- a/docs/api/paddle/sparse/sum_cn.rst
+++ b/docs/api/paddle/sparse/sum_cn.rst
@@ -6,7 +6,7 @@ sum
 .. py:function:: paddle.sparse.sum(x, axis=None, dtype=None, keepdim=False, name=None)
 
 计算给定维度 :attr:`axis` 上稀疏张量 :attr:`x` 元素的和。
-输入 :attr:`x` 必须为稀疏压缩格式（ `SparseCooTensor` 或 `SparseCsrTensor`）。
+输入 :attr:`x` 必须为稀疏压缩格式（ ``SparseCooTensor`` 或 ``SparseCsrTensor``）。
 
 等式为：
 
@@ -17,14 +17,14 @@ sum
 :::::::::
     - **x** (Tensor) - 输入的 Tensor，数据类型为 bool、float16、float32、float64、int32 或 int64。
     - **axis** (int|list|tuple，可选) - 沿着哪些维度进行求和操作。如果为 :attr:`None`，则对 :attr:`x` 的所有元素进行求和并返回一个只有一个元素的 Tensor；否则必须在 :math:`[-rank(x), rank(x))` 范围内。如果 :math:`axis[i] < 0`，则要减少的维度是 :math:`rank + axis[i]`。
-    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型。默认值为 None，表示与输入 Tensor `x` 数据类型一致。
+    - **dtype** (str|paddle.dtype|np.dtype，可选) - 输出 Tensor 的数据类型。默认值为 None，表示与输入 Tensor ``x`` 数据类型一致。
     - **keepdim** (bool，可选) - 是否在输出 Tensor 中保留减少的维度。如果为 True，则结果 Tensor 的维数比 :attr:`x` 少一维，否则与 :attr:`x` 维数一致。默认值为 False。
     - **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为 None。
 
 返回
 ::::::::::::
 
-  ``Tensor``，在指定维度上进行求和运算的 Tensor。如果 `x.dtype='bool'` 或 `x.dtype='int32'`，则其数据类型为 `'int64'`，否则数据类型与 `x` 一致。
+  ``Tensor``，在指定维度上进行求和运算的 Tensor。如果 ``x.dtype='bool'`` 或 ``x.dtype='int32'``，则其数据类型为 ``'int64'``，否则数据类型与 ``x`` 一致。
 
 
 代码示例