[Docs] Fix inline backticks in sparse and metric CN docs

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,17 +46,17 @@ 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
 
 代码示例 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`` 。

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`。
 
 
 参数

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` 。
 
 
 参数

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` 。
 
 
 参数

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`` 等参数对输入做平均池化操作。
 
 例如：
 

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`` 等参数对输入做平均池化操作。
 
 
 例如：

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，其数据类型与输入相同。
 
 代码示例
 :::::::::

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，其数据类型与输入相同。
 
 代码示例
 :::::::::

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` 。
 
 
 参数

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`` 等参数对输入做平均池化操作。
 
 例如：
 

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` 。
 
 参数
 :::::::::

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`` 等参数对输入做最大池化操作。
 
 例如：
 

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`` 做最大池化操作。
 
 例如：
 

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`` 直接指定
 
 
 参数

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`` 直接指定
 
 
 参数

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`` 直接指定
 
 
 参数

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 正则化失效的问题。
 
 
 

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`` 相同。
 
 
 代码示例

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`` 共同决定，数据类型与输入相同。
 
 
 代码示例