!47396 fix docs first line issues

Merge pull request !47396 from luojianing/code_docs_r2.0.0-alpha
2023-01-03 01:57:03 +00:00 · 2023-01-03 01:57:03 +00:00 · 350a4b5a68
parent 80622935f7 07810d27e0
commit 350a4b5a68
111 changed files with 97 additions and 364 deletions
--- a/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.any.rst
+++ b/docs/api/api_python/mindspore/Tensor/mindspore.Tensor.any.rst
@ -10,4 +10,4 @@ mindspore.Tensor.any
        - **keep_dims** (bool) - 计算结果是否保留维度。默认值：False。

    返回：
-        Tensor。如果在指定轴方向上所有Tensor元素都为True，则其值为True，否则其值为False。如果轴为None或空元组，则默认降维。
+        Tensor。如果在指定轴方向上存在任意Tensor元素为True，则其值为True，否则其值为False。如果轴为None或空元组，则默认降维。
--- a/docs/api/api_python/nn/mindspore.nn.AdaptiveAvgPool1d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.AdaptiveAvgPool1d.rst
@ -3,9 +3,7 @@ mindspore.nn.AdaptiveAvgPool1d

 .. py:class:: mindspore.nn.AdaptiveAvgPool1d(output_size)

-    对输入的多维数据进行一维平面上的自适应平均池化运算。
-
-    在一个输入Tensor上应用1D adaptive average pooling，可视为组成一个1D输入平面。
+    在一个输入Tensor上应用1D自适应平均池化运算，可视为组成一个1D输入平面。

    通常，输入的shape为 :math:`(N_{in}, C_{in}, L_{in})` ，AdaptiveAvgPool1d在 :math:`L_{in}` 维度上计算区域平均值。
    输出的shape为 :math:`(N_{in}, C_{in}, L_{out})` ，其中， :math:`L_{out}` 为 `output_size`。
--- a/docs/api/api_python/nn/mindspore.nn.AdaptiveAvgPool2d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.AdaptiveAvgPool2d.rst
@ -3,8 +3,6 @@ mindspore.nn.AdaptiveAvgPool2d

 .. py:class:: mindspore.nn.AdaptiveAvgPool2d(output_size)

-    二维自适应平均池化。
-
    对输入Tensor，提供二维的自适应平均池化操作。也就是说，对于输入任何尺寸，指定输出的尺寸都为H * W。但是输入和输出特征的数目不会变化。

    输入和输出数据格式可以是"NCHW"和"CHW"。N是批处理大小，C是通道数，H是特征高度，W是特征宽度。运算如下：
--- a/docs/api/api_python/nn/mindspore.nn.AdaptiveAvgPool3d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.AdaptiveAvgPool3d.rst
@ -3,8 +3,6 @@ mindspore.nn.AdaptiveAvgPool3d

 .. py:class:: mindspore.nn.AdaptiveAvgPool3d(output_size)

-    三维自适应平均池化。
-
    对输入Tensor，提供三维的自适应平均池化操作。也就是说对于输入任何尺寸，指定输出的尺寸都为 :math:`(D, H, W)`。但是输入和输出特征的数目不会变化。

    假设输入 `x` 最后三维大小分别为 :math:`(inD, inH, inW)`，则输出的最后三维大小分别为 :math:`(outD, outH, outW)`。运算如下：
--- a/docs/api/api_python/nn/mindspore.nn.AdaptiveMaxPool1d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.AdaptiveMaxPool1d.rst
@ -3,9 +3,7 @@ mindspore.nn.AdaptiveMaxPool1d

 .. py:class:: mindspore.nn.AdaptiveMaxPool1d(output_size)

-    对输入的多维数据进行一维平面上的自适应最大池化运算。
-
-    在一个输入Tensor上应用1D adaptive maximum pooling，可被视为组成一个1D输入平面。
+    在一个输入Tensor上应用1D自适应最大池化运算，可被视为组成一个1D输入平面。

    通常，输入的shape为 :math:`(N_{in}, C_{in}, L_{in})` ，AdaptiveMaxPool1d在 :math:`L_{in}` 维度上计算区域最大值。
    输出的shape为 :math:`(N_{in}, C_{in}, L_{out})` ，其中， :math:`L_{out}` 为 `output_size`。
--- a/docs/api/api_python/nn/mindspore.nn.AdaptiveMaxPool2d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.AdaptiveMaxPool2d.rst
@ -3,8 +3,6 @@ mindspore.nn.AdaptiveMaxPool2d

 .. py:class:: mindspore.nn.AdaptiveMaxPool2d(output_size, return_indices=False)

-    二维自适应最大池化运算。
-
    对输入Tensor，提供二维自适应最大池化操作。对于输入任何格式，指定输出的格式都为H * W。但是输入和输出特征的数目不会变化。

    输入和输出数据格式可以是"NCHW"和"CHW"。N是批处理大小，C是通道数，H是特征高度，W是特征宽度。运算如下：
--- a/docs/api/api_python/nn/mindspore.nn.AdaptiveMaxPool3d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.AdaptiveMaxPool3d.rst
@ -3,9 +3,7 @@ mindspore.nn.AdaptiveMaxPool3d

 .. py:class:: mindspore.nn.AdaptiveMaxPool3d(output_size, return_indices=False)

-    三维自适应最大值池化。
-
-    对于任何输入尺寸，输出的大小为 :math:`(D, H, W)` 。输出特征的数量与输入特征的数量相同。
+    对输入Tensor，提供三维自适应最大池化操作。对于任何输入尺寸，输出的大小为 :math:`(D, H, W)` 。输出特征的数量与输入特征的数量相同。

    参数：
        - **output_size** (Union[int, tuple]) - 表示输出特征图的尺寸，输入可以是tuple :math:`(D, H, W)`，也可以是一个int值D来表示输出尺寸为 :math:`(D, D, D)` 。:math:`D` ， :math:`H` 和 :math:`W` 可以是int型整数或者None，其中None表示输出大小与对应的输入的大小相同。
--- a/docs/api/api_python/nn/mindspore.nn.AvgPool1d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.AvgPool1d.rst
@ -3,9 +3,7 @@ mindspore.nn.AvgPool1d

 .. py:class:: mindspore.nn.AvgPool1d(kernel_size=1, stride=1, pad_mode='valid')

-    对输入的多维数据进行一维平面上的平均池化运算。
-
-    在一个输入Tensor上应用1D average pooling，可被视为组成一个1D输入平面。
+    在一个输入Tensor上应用1D平均池化运算，可被视为组成一个1D输入平面。

    通常，输入的shape为 :math:`(N_{in}, C_{in}, L_{in})` ，AvgPool1d在 :math:`(L_{in})` 维度上输出区域平均值。
    给定 `kernel_size` 为 :math:`k` 和 `stride` ，公式定义如下：
--- a/docs/api/api_python/nn/mindspore.nn.AvgPool2d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.AvgPool2d.rst
@ -3,9 +3,7 @@ mindspore.nn.AvgPool2d

 .. py:class:: mindspore.nn.AvgPool2d(kernel_size=1, stride=1, pad_mode='valid', data_format='NCHW')

-    对输入的多维数据进行二维的平均池化运算。
-
-    在输入张量上应用2D average pooling，可视为二维输入平面的组合。
+    在输入Tensor上应用2D平均池化运算，可视为二维输入平面的组合。

    通常，输入的shape为 :math:`(N_{in},C_{in},H_{in},W_{in})` ，AvgPool2d的输出为 :math:`(H_{in},W_{in})` 维度的区域平均值。给定 `kernel_size` 为 :math:`(kH,kW)` 和 `stride` ，公式定义如下：

--- a/docs/api/api_python/nn/mindspore.nn.AvgPool3d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.AvgPool3d.rst
@ -3,9 +3,7 @@ mindspore.nn.AvgPool3d

 .. py:class:: mindspore.nn.AvgPool3d(kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=None)

-    对输入的多维数据进行三维的平均池化运算。
-
-    在一个输入Tensor上应用3D max pooling，输入Tensor可看成是由一系列3D平面组成的。
+    在一个输入Tensor上应用3D平均池化运算，输入Tensor可看成是由一系列3D平面组成的。

    通常，输入的shape为 :math:`(N_{in}, C_{in}, D_{in}, H_{in}, W_{in})` ，AvgPool3D输出 :math:`(D_{in}, H_{in}, W_{in})` 维度的区域平均值。给定 `kernel_size` 为 :math:`ks = (d_{ker}, h_{ker}, w_{ker})` 和 `stride` 为 :math:`s = (s_0, s_1, s_2)`，公式如下。

--- a/docs/api/api_python/nn/mindspore.nn.BatchNorm1d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.BatchNorm1d.rst
@ -3,9 +3,7 @@ mindspore.nn.BatchNorm1d

 .. py:class:: mindspore.nn.BatchNorm1d(num_features, eps=1e-5, momentum=0.9, affine=True, gamma_init='ones', beta_init='zeros', moving_mean_init='zeros', moving_var_init='ones', use_batch_statistics=None, data_format='NCHW')

-    对输入的二维数据进行批归一化(Batch Normalization Layer)。
-
-    在二维输入（mini-batch 一维输入）上应用批归一化，避免内部协变量偏移。归一化在卷积网络中被广泛的应用。请见论文 `Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/abs/1502.03167>`_ 。
+    在二维输入（mini-batch 一维输入）上应用批归一化（Batch Normalization Layer），避免内部协变量偏移。归一化在卷积网络中被广泛的应用。请见论文 `Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/abs/1502.03167>`_ 。

    使用mini-batch数据和学习参数进行训练，计算公式如下。

--- a/docs/api/api_python/nn/mindspore.nn.BatchNorm2d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.BatchNorm2d.rst
@ -3,9 +3,7 @@ mindspore.nn.BatchNorm2d

 .. py:class:: mindspore.nn.BatchNorm2d(num_features, eps=1e-5, momentum=0.9, affine=True, gamma_init='ones', beta_init='zeros', moving_mean_init='zeros', moving_var_init='ones', use_batch_statistics=None, data_format='NCHW')

-    对输入的四维数据进行批归一化(Batch Normalization Layer)。
-
-    在四维输入（具有额外通道维度的小批量二维输入）上应用批归一化处理，以避免内部协变量偏移。批归一化广泛应用于卷积网络中。请见论文 `Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/abs/1502.03167>`_ 。使用mini-batch数据和学习参数进行训练，这些参数见以下公式：
+    在四维输入（具有额外通道维度的小批量二维输入）上应用批归一化处理（Batch Normalization Layer），以避免内部协变量偏移。批归一化广泛应用于卷积网络中。请见论文 `Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/abs/1502.03167>`_ 。使用mini-batch数据和学习参数进行训练，这些参数见以下公式：

    .. math::
        y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta
--- a/docs/api/api_python/nn/mindspore.nn.BatchNorm3d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.BatchNorm3d.rst
@ -5,7 +5,7 @@ mindspore.nn.BatchNorm3d

    对输入的五维数据进行批归一化(Batch Normalization Layer)。

-    在五维输入（带有附加通道维度的mini-batch 三维输入）上应用批归一化，避免内部协变量偏移。归一化在卷积网络中得到了广泛的应用。
+    在五维输入（带有附加通道维度的mini-batch 三维输入）上应用批归一化（Batch Normalization Layer），避免内部协变量偏移。归一化在卷积网络中得到了广泛的应用。

    .. math::
        y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta
--- a/docs/api/api_python/nn/mindspore.nn.Conv1d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.Conv1d.rst
@ -3,9 +3,7 @@ mindspore.nn.Conv1d

 .. py:class:: mindspore.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, pad_mode='same', padding=0, dilation=1, group=1, has_bias=False, weight_init='normal', bias_init='zeros')

-    一维卷积层。
-
-    对输入Tensor计算一维卷积，该Tensor的shape通常为 :math:`(N, C_{in}, L_{in})` ，其中 :math:`N` 是batch size， :math:`C_{in}` 是空间维度，:math:`L_{in}` 是序列的长度。
+    对输入Tensor计算一维卷积。该Tensor的shape通常为 :math:`(N, C_{in}, L_{in})` ，其中 :math:`N` 是batch size， :math:`C_{in}` 是空间维度，:math:`L_{in}` 是序列的长度。
    对于每个batch中的Tensor，其shape为 :math:`(C_{in}, L_{in})` ，公式定义如下：

    .. math::
--- a/docs/api/api_python/nn/mindspore.nn.Conv1dTranspose.rst
+++ b/docs/api/api_python/nn/mindspore.nn.Conv1dTranspose.rst
@ -3,8 +3,6 @@ mindspore.nn.Conv1dTranspose

 .. py:class:: mindspore.nn.Conv1dTranspose(in_channels, out_channels, kernel_size, stride=1, pad_mode='same', padding=0, dilation=1, group=1, has_bias=False, weight_init='normal', bias_init='zeros')

-    一维转置卷积层。
-
    计算一维转置卷积，可以视为Conv1d对输入求梯度，也称为反卷积（实际不是真正的反卷积）。

    输入的shape通常是 :math:`(N, C_{in}, L_{in})` ，其中 :math:`N` 是batch size， :math:`C_{in}` 是空间维度， :math:`L_{in}` 是序列的长度。
--- a/docs/api/api_python/nn/mindspore.nn.Conv2d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.Conv2d.rst
@ -3,9 +3,7 @@ mindspore.nn.Conv2d

 .. py:class:: mindspore.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, pad_mode="same", padding=0, dilation=1, group=1, has_bias=False, weight_init="normal", bias_init="zeros", data_format="NCHW")

-    二维卷积层。
-
-    对输入Tensor计算二维卷积，该Tensor的常见shape为 :math:`(N, C_{in}, H_{in}, W_{in})`，其中 :math:`N` 为batch size，:math:`C_{in}` 为空间维度，:math:`H_{in}, W_{in}` 分别为特征层的高度和宽度。对于每个batch中的Tensor，其shape为 :math:`(C_{in}, H_{in}, W_{in})` ，公式定义如下：
+    对输入Tensor计算二维卷积。该Tensor的常见shape为 :math:`(N, C_{in}, H_{in}, W_{in})`，其中 :math:`N` 为batch size，:math:`C_{in}` 为空间维度，:math:`H_{in}, W_{in}` 分别为特征层的高度和宽度。对于每个batch中的Tensor，其shape为 :math:`(C_{in}, H_{in}, W_{in})` ，公式定义如下：

    .. math::
        \text{out}(N_i, C_{\text{out}_j}) = \text{bias}(C_{\text{out}_j}) +
--- a/docs/api/api_python/nn/mindspore.nn.Conv2dTranspose.rst
+++ b/docs/api/api_python/nn/mindspore.nn.Conv2dTranspose.rst
@ -3,8 +3,6 @@ mindspore.nn.Conv2dTranspose

 .. py:class:: mindspore.nn.Conv2dTranspose(in_channels, out_channels, kernel_size, stride=1, pad_mode="same", padding=0, dilation=1, group=1, has_bias=False, weight_init="normal", bias_init="zeros")

-    二维转置卷积层。
-
    计算二维转置卷积，可以视为Conv2d对输入求梯度，也称为反卷积（实际不是真正的反卷积）。

    输入的shape通常为 :math:`(N, C_{in}, H_{in}, W_{in})` ，其中 :math:`N` 是batch size，:math:`C_{in}` 是空间维度， :math:`H_{in}, W_{in}` 分别为特征层的高度和宽度。
--- a/docs/api/api_python/nn/mindspore.nn.Conv3d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.Conv3d.rst
@ -3,9 +3,7 @@ mindspore.nn.Conv3d

 .. py:class:: mindspore.nn.Conv3d(in_channels, out_channels, kernel_size, stride=1, pad_mode='same', padding=0, dilation=1, group=1, has_bias=False, weight_init='normal', bias_init='zeros', data_format='NCDHW')

-    三维卷积层。
-
-    对输入Tensor计算三维卷积，该Tensor的shape通常为 :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})` ，其中 :math:`N` 为batch size， :math:`C_{in}` 是空间维度。:math:`D_{in}, H_{in}, W_{in}` 分别为特征层的深度、高度和宽度。对于每个batch中的Tensor，其shape为 :math:`(C_{in}, D_{in}, H_{in}, W_{in})` ，公式定义如下：
+    对输入Tensor计算三维卷积。该Tensor的shape通常为 :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})` ，其中 :math:`N` 为batch size， :math:`C_{in}` 是空间维度。:math:`D_{in}, H_{in}, W_{in}` 分别为特征层的深度、高度和宽度。对于每个batch中的Tensor，其shape为 :math:`(C_{in}, D_{in}, H_{in}, W_{in})` ，公式定义如下：

    .. math::
        \text{out}(N_i, C_{\text{out}_j}) = \text{bias}(C_{\text{out}_j}) +
--- a/docs/api/api_python/nn/mindspore.nn.Conv3dTranspose.rst
+++ b/docs/api/api_python/nn/mindspore.nn.Conv3dTranspose.rst
@ -3,8 +3,6 @@ mindspore.nn.Conv3dTranspose

 .. py:class:: mindspore.nn.Conv3dTranspose(in_channels, out_channels, kernel_size, stride=1, pad_mode='same', padding=0, dilation=1, group=1, output_padding=0, has_bias=False, weight_init='normal', bias_init='zeros', data_format='NCDHW')

-    三维转置卷积层。
-
    计算三维转置卷积，可以视为Conv3d对输入求梯度，也称为反卷积（实际不是真正的反卷积）。

    输入的shape通常为 :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})` ，其中 :math:`N` 为batch size， :math:`C_{in}` 是空间维度。:math:`D_{in}, H_{in}, W_{in}` 分别为特征层的深度、高度和宽度。
--- a/docs/api/api_python/nn/mindspore.nn.FractionalMaxPool2d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.FractionalMaxPool2d.rst
@ -3,9 +3,7 @@ mindspore.nn.FractionalMaxPool2d

 .. py:class:: mindspore.nn.FractionalMaxPool2d(kernel_size, output_size=None, output_ratio=None, return_indices=False, _random_samples=None)

-    对输入的多维数据进行二维的分数最大池化运算。
-
-    对多个输入平面组成的输入上应用2D分数最大池化。在  :math:`(kH_{in}, kW_{in})` 区域上应用最大池化操作，由输出shape决定随机步长。对于任何输入shape，指定输出shape为 :math:`(H, W)` 。输出特征的数量等于输入平面的数量。
+    对多个输入平面组成的输入上应用2D分数最大池化。在 :math:`(kH_{in}, kW_{in})` 区域上应用最大池化操作，由输出shape决定随机步长。对于任何输入shape，指定输出shape为 :math:`(H, W)` 。输出特征的数量等于输入平面的数量。
    在一个输入Tensor上应用2D fractional max pooling，可被视为组成一个2D平面。

    分数最大池化的详细描述在 `Fractional Max-Pooling <https://arxiv.org/pdf/1412.6071>`_ 。
--- a/docs/api/api_python/nn/mindspore.nn.FractionalMaxPool3d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.FractionalMaxPool3d.rst
@ -3,9 +3,7 @@ mindspore.nn.FractionalMaxPool3d

 .. py:class:: mindspore.nn.FractionalMaxPool3d(kernel_size, output_size=None, output_ratio=None, return_indices=False, _random_samples=None)

-    对输入的多维数据进行三维的分数最大池化运算。
-
-    对多个输入平面组成的输入上应用3D分数最大池化。在  :math:`(kD_{in}, kH_{in}, kW_{in})` 区域上应用最大池化操作，由输出shape决定随机步长。输出特征的数量等于输入平面的数量。
+    对多个输入平面组成的输入上应用3D分数最大池化。在 :math:`(kD_{in}, kH_{in}, kW_{in})` 区域上应用最大池化操作，由输出shape决定随机步长。输出特征的数量等于输入平面的数量。

    分数最大池化的详细描述在 `Fractional MaxPooling by Ben Graham <https://arxiv.org/abs/1412.6071>`_ 。

--- a/docs/api/api_python/nn/mindspore.nn.HSwish.rst
+++ b/docs/api/api_python/nn/mindspore.nn.HSwish.rst
@ -3,8 +3,6 @@ mindspore.nn.HSwish

 .. py:class:: mindspore.nn.HSwish

-    Hard Swish激活函数。
-
    对输入的每个元素计算Hard Swish。input是具有任何有效形状的张量。

    Hard Swish定义如下：
--- a/docs/api/api_python/nn/mindspore.nn.Hardtanh.rst
+++ b/docs/api/api_python/nn/mindspore.nn.Hardtanh.rst
@ -3,8 +3,6 @@ mindspore.nn.Hardtanh

 .. py:class:: mindspore.nn.Hardtanh(min_val=-1.0, max_val=1.0)

-    Hardtanh激活函数。
-
    按元素计算Hardtanh函数。Hardtanh函数定义为：

    .. math::
--- a/docs/api/api_python/nn/mindspore.nn.InstanceNorm1d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.InstanceNorm1d.rst
@ -3,9 +3,7 @@ mindspore.nn.InstanceNorm1d

 .. py:class:: mindspore.nn.InstanceNorm1d(num_features, eps=1e-5, momentum=0.1, affine=True, gamma_init='ones', beta_init='zeros')

-    对三维输入实现实例归一化（Instance Normalization Layer）。
-
-    该层在三维输入（带有额外通道维度的mini-batch一维输入）上应用实例归一化，详见论文 `Instance Normalization:
+    该层在三维输入（带有额外通道维度的mini-batch一维输入）上应用实例归一化。详见论文 `Instance Normalization:
    The Missing Ingredient for Fast Stylization <https://arxiv.org/abs/1607.08022>`_ 。
    使用mini-batch数据和学习参数进行训练，参数见如下公式。

--- a/docs/api/api_python/nn/mindspore.nn.InstanceNorm2d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.InstanceNorm2d.rst
@ -3,9 +3,7 @@ mindspore.nn.InstanceNorm2d

 .. py:class:: mindspore.nn.InstanceNorm2d(num_features, eps=1e-5, momentum=0.1, affine=True, gamma_init='ones', beta_init='zeros')

-    对四维输入实现实例归一化（Instance Normalization Layer）。
-
-    该层在四维输入（带有额外通道维度的mini-batch二维输入）上应用实例归一化，详见论文 `Instance Normalization:
+    该层在四维输入（带有额外通道维度的mini-batch二维输入）上应用实例归一化。详见论文 `Instance Normalization:
    The Missing Ingredient for Fast Stylization <https://arxiv.org/abs/1607.08022>`_ 。
    使用mini-batch数据和学习参数进行训练，参数见如下公式。

--- a/docs/api/api_python/nn/mindspore.nn.InstanceNorm3d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.InstanceNorm3d.rst
@ -3,9 +3,7 @@ mindspore.nn.InstanceNorm3d

 .. py:class:: mindspore.nn.InstanceNorm3d(num_features, eps=1e-5, momentum=0.1, affine=True, gamma_init='ones', beta_init='zeros')

-    对五维输入实现实例归一化（Instance Normalization Layer）。
-
-    该层在五维输入（带有额外通道维度的mini-batch三维输入）上应用实例归一化，详见论文 `Instance Normalization:
+    该层在五维输入（带有额外通道维度的mini-batch三维输入）上应用实例归一化。详见论文 `Instance Normalization:
    The Missing Ingredient for Fast Stylization <https://arxiv.org/abs/1607.08022>`_ 。
    使用mini-batch数据和学习参数进行训练，参数见如下公式。

--- a/docs/api/api_python/nn/mindspore.nn.LPPool1d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.LPPool1d.rst
@ -3,9 +3,7 @@ mindspore.nn.LPPool1d

 .. py:class:: mindspore.nn.LPPool1d(norm_type, kernel_size, stride=None, ceil_mode=False)

-    对输入的多维数据进行一维平面上的LP池化运算。
-
-    在一个输入Tensor上应用1D LP pooling，可被视为组成一个1D输入平面。
+    在一个输入Tensor上应用1D LP池化运算，可被视为组成一个1D输入平面。

    通常，输入的shape为 :math:`(N_{in}, C_{in}, L_{in})` 或 :math:`(C, L_{in})`，输出的shape为 :math:`(N_{in}, C_{in}, L_{in})` 或 :math:`(C, L_{in})`，输出与输入的shape一致，公式如下：

--- a/docs/api/api_python/nn/mindspore.nn.LPPool2d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.LPPool2d.rst
@ -3,9 +3,7 @@ mindspore.nn.LPPool2d

 .. py:class:: mindspore.nn.LPPool2d(norm_type, kernel_size, stride=None, ceil_mode=False)

-    对输入的多维数据进行二维平面上的LP池化运算。
-
-    在一个输入Tensor上应用2D LP pooling，可被视为组成一个2D输入平面。
+    在一个输入Tensor上应用2D LP池化运算，可被视为组成一个2D输入平面。

    通常，输入的shape为 :math:`(N, C, H_{in}, W_{in})`，输出的shape为 :math:`(N, C, H_{in}, W_{in})`，输出与输入的shape一致，公式如下：

--- a/docs/api/api_python/nn/mindspore.nn.LogSigmoid.rst
+++ b/docs/api/api_python/nn/mindspore.nn.LogSigmoid.rst
@ -3,8 +3,6 @@ mindspore.nn.LogSigmoid

 .. py:class:: mindspore.nn.LogSigmoid

-    Log Sigmoid激活函数。
-
    按元素计算Log Sigmoid激活函数。输入是任意格式的Tensor。

    Log Sigmoid定义为：
--- a/docs/api/api_python/nn/mindspore.nn.LogSoftmax.rst
+++ b/docs/api/api_python/nn/mindspore.nn.LogSoftmax.rst
@ -3,8 +3,6 @@ mindspore.nn.LogSoftmax

 .. py:class:: mindspore.nn.LogSoftmax(axis=-1)

-    Log Softmax激活函数。
-
    按元素计算Log Softmax激活函数。

    输入经Softmax函数、Log函数转换后，值的范围在[-inf,0)。
--- a/docs/api/api_python/nn/mindspore.nn.MaxPool1d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.MaxPool1d.rst
@ -3,9 +3,7 @@ mindspore.nn.MaxPool1d

 .. py:class:: mindspore.nn.MaxPool1d(kernel_size=1, stride=1, pad_mode='valid')

-    对时间数据进行最大池化运算。
-
-    在一个输入张量上应用1D max pooling，该张量可被视为一维平面的组合。
+    在一个输入Tensor上应用1D最大池化运算，该Tensor可被视为一维平面的组合。

    通常，输入的shape为 :math:`(N_{in}, C_{in}, L_{in})` ，MaxPool1d输出 :math:`(L_{in})` 维度区域最大值。
    给定 `kernel_size` 和 `stride` ，公式如下：
--- a/docs/api/api_python/nn/mindspore.nn.MaxPool2d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.MaxPool2d.rst
@ -3,9 +3,7 @@ mindspore.nn.MaxPool2d

 .. py:class:: mindspore.nn.MaxPool2d(kernel_size=1, stride=1, pad_mode='valid', data_format='NCHW')

-    对输入的多维数据进行二维的最大池化运算。
-
-    在一个输入Tensor上应用2D max pooling，可被视为组成一个2D平面。
+    在一个输入Tensor上应用2D最大池化运算，可被视为组成一个2D平面。

    通常，输入的形状为 :math:`(N_{in}, C_{in}, H_{in}, W_{in})` ，MaxPool2d输出 :math:`(H_{in}, W_{in})` 维度区域最大值。给定 `kernel_size` 为 :math:`(kH,kW)` 和 `stride` ，公式如下。

--- a/docs/api/api_python/nn/mindspore.nn.MaxPool3d.rst
+++ b/docs/api/api_python/nn/mindspore.nn.MaxPool3d.rst
@ -3,9 +3,7 @@ mindspore.nn.MaxPool3d

 .. py:class:: mindspore.nn.MaxPool3d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

-    对输入的多维数据进行三维的最大池化运算。
-
-    在一个输入Tensor上应用3D max pooling，输入Tensor可看成是由一系列3D平面组成的。
+    在一个输入Tensor上应用3D最大池化运算，输入Tensor可看成是由一系列3D平面组成的。

    通常，输入的shape为 :math:`(N_{in}, C_{in}, D_{in}, H_{in}, W_{in})` ，MaxPool3d输出 :math:`(D_{in}, H_{in}, W_{in})` 维度区域最大值。给定 `kernel_size` 为 :math:`ks = (d_{ker}, h_{ker}, w_{ker})` 和 `stride` 为 :math:`s = (s_0, s_1, s_2)`，公式如下。

--- a/docs/api/api_python/nn/mindspore.nn.PixelShuffle.rst
+++ b/docs/api/api_python/nn/mindspore.nn.PixelShuffle.rst
@ -3,8 +3,6 @@ mindspore.nn.PixelShuffle

 .. py:class:: mindspore.nn.PixelShuffle(upscale_factor)

-    PixelShuffle函数。
-
    在多个输入平面组成的输入上面应用PixelShuffle算法。在平面上应用高效亚像素卷积，步长为 :math:`1/r` 。关于PixelShuffle算法详细介绍，请参考 `Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional Neural Network <https://arxiv.org/abs/1609.05158>`_ 。

    通常情况下，输入shape :math:`(*, C \times r^2, H, W)` ，输出shape :math:`(*, C, H \times r, W \times r)` 。`r` 是缩小因子。 `*` 是大于等于0的维度。
--- a/docs/api/api_python/nn/mindspore.nn.PixelUnshuffle.rst
+++ b/docs/api/api_python/nn/mindspore.nn.PixelUnshuffle.rst
@ -3,8 +3,6 @@ mindspore.nn.PixelUnshuffle

 .. py:class:: mindspore.nn.PixelUnshuffle(downscale_factor)

-    PixelUnshuffle函数。
-
    在多个输入平面组成的输入上面应用PixelUnshuffle算法。关于PixelUnshuffle算法详细介绍，请参考 `Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional Neural Network <https://arxiv.org/abs/1609.05158>`_ 。

    通常情况下，输入shape :math:`(*, C, H \times r, W \times r)` ，输出shape :math:`(*, C \times r^2, H, W)` 。`r` 是缩小因子。 `*` 是大于等于0的维度。
--- a/docs/api/api_python/nn/mindspore.nn.Softmax.rst
+++ b/docs/api/api_python/nn/mindspore.nn.Softmax.rst
@ -3,7 +3,7 @@ mindspore.nn.Softmax

 .. py:class:: mindspore.nn.Softmax(axis=-1)

-    Softmax函数，它是二分类函数 :class:`mindspore.nn.Sigmoid` 在多分类上的推广，目的是将多分类的结果以概率的形式展现出来。
+    Softmax激活函数，它是二分类函数 :class:`mindspore.nn.Sigmoid` 在多分类上的推广，目的是将多分类的结果以概率的形式展现出来。

    对输入Tensor在轴 `axis` 上的元素计算其指数函数值，然后归一化到[0, 1]范围，总和为1。

--- a/docs/api/api_python/nn/mindspore.nn.Tanh.rst
+++ b/docs/api/api_python/nn/mindspore.nn.Tanh.rst
@ -3,9 +3,7 @@ mindspore.nn.Tanh

 .. py:class:: mindspore.nn.Tanh

-    Tanh激活函数。
-
-    按元素计算Tanh函数，返回一个新的Tensor，该Tensor是输入元素的双曲正切值。
+    逐元素计算Tanh函数，返回一个新的Tensor，该Tensor是输入元素的双曲正切值。

    Tanh函数定义为：

--- a/docs/api/api_python/ops/mindspore.ops.ArgMaxWithValue.rst
+++ b/docs/api/api_python/ops/mindspore.ops.ArgMaxWithValue.rst
@ -3,9 +3,7 @@

 .. py:class:: mindspore.ops.ArgMaxWithValue(axis=0, keep_dims=False)

-    根据指定的索引计算最大值，并返回索引和值。
-
-    在给定轴上计算输入Tensor的最大值。并且返回最大值和索引。
+    在给定轴上计算输入Tensor的最大值，并且返回最大值和索引。

    .. note::
        在auto_parallel和semi_auto_parallel模式下，不能使用第一个输出索引。
--- a/docs/api/api_python/ops/mindspore.ops.ArgMinWithValue.rst
+++ b/docs/api/api_python/ops/mindspore.ops.ArgMinWithValue.rst
@ -3,8 +3,6 @@

 .. py:class:: mindspore.ops.ArgMinWithValue(axis=0, keep_dims=False)

-    根据指定的索引计算最小值，并返回索引和值。
-
    在给定轴上计算输入Tensor的最小值，并且返回最小值和索引。

    .. note::
--- a/docs/api/api_python/ops/mindspore.ops.AvgPool3D.rst
+++ b/docs/api/api_python/ops/mindspore.ops.AvgPool3D.rst
@ -5,8 +5,6 @@

    对输入的多维数据进行三维的平均池化运算。

-    在输入Tensor上应用3D average pooling，可被视为3D输入平面。
-
    一般，输入shape为 :math:`(N, C, D_{in}, H_{in}, W_{in})` ，AvgPool3D在 :math:`(D_{in}, H_{in}, W_{in})` 维度上输出区域平均值。给定 `kernel_size` 为 :math:`(kD,kH,kW)` 和 `stride` ，运算如下：

    .. warning::
--- a/docs/api/api_python/ops/mindspore.ops.Cdist.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Cdist.rst
@ -3,6 +3,6 @@ mindspore.ops.Cdist

 .. py:class:: mindspore.ops.Cdist

-    计算两个tensor的p-范数距离。
+    计算两个Tensor的p-范数距离。

    更多参考详见 :func:`mindspore.ops.cdist`。
--- a/docs/api/api_python/ops/mindspore.ops.CumulativeLogsumexp.rst
+++ b/docs/api/api_python/ops/mindspore.ops.CumulativeLogsumexp.rst
@ -3,7 +3,7 @@

 .. py:class:: mindspore.ops.CumulativeLogsumexp(exclusive=False, reverse=False)

-    计算输入 `x` 沿轴 `axis` 的累积LogSumExp函数值，即：若输入 `x` 为[a, b, c]，则输出为[a, log(exp(a) + exp(b)), log(exp(a) + exp(b) + exp(c))]。
+    计算输入 `x` 沿轴 `axis` 的累积LogSumExp函数值。即：若输入 `x` 为[a, b, c]，则输出为[a, log(exp(a) + exp(b)), log(exp(a) + exp(b) + exp(c))]。

    参数：
        - **exclusive** (bool, 可选) - 如果为True，将在计算时跳过最后一个元素，此时输出为：[-inf, a, log(exp(a) * exp(b))]，其中-inf在输出时出于性能原因将以一个极小负数的形式呈现。默认值：False。
--- a/docs/api/api_python/ops/mindspore.ops.FractionalMaxPool3DWithFixedKsize.rst
+++ b/docs/api/api_python/ops/mindspore.ops.FractionalMaxPool3DWithFixedKsize.rst
@ -3,8 +3,6 @@ mindspore.ops.FractionalMaxPool3DWithFixedKsize

 .. py:class:: mindspore.ops.FractionalMaxPool3DWithFixedKsize(ksize, output_shape, data_format="NCDHW")

-    3D分数最大池化操作。
-
    此运算对由多个输入平面组成的输入信号进行3D分数最大池化。最大池化操作通过由目标输出大小确定的随机步长在 kD x kH x kW 区域中进行。

    输出特征的数量等于输入平面的数量。
--- a/docs/api/api_python/ops/mindspore.ops.FractionalMaxPoolWithFixedKsize.rst
+++ b/docs/api/api_python/ops/mindspore.ops.FractionalMaxPoolWithFixedKsize.rst
@ -3,8 +3,6 @@ mindspore.ops.FractionalMaxPoolWithFixedKsize

 .. py:class:: mindspore.ops.FractionalMaxPoolWithFixedKsize(ksize, output_shape, data_format="NCHW")

-    进行分数最大池化操作。
-
    此运算对由多个输入平面组成的输入信号进行2D分数最大池化。最大池化操作通过由目标输出大小确定的随机步长在 `kH x kW` 区域中进行。

    对于任何输入大小，指定输出的大小为 `H x W` 。输出特征的数量等于输入平面的数量。
--- a/docs/api/api_python/ops/mindspore.ops.Tanh.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Tanh.rst
@ -3,8 +3,6 @@

 .. py:class:: mindspore.ops.Tanh

-    Tanh激活函数。
-
-    按元素计算输入元素的双曲正切。
+    逐元素计算输入元素的双曲正切。

    更多参考详见 :func:`mindspore.ops.tanh`。
--- a/docs/api/api_python/ops/mindspore.ops.func_absolute.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_absolute.rst
@ -3,6 +3,4 @@ mindspore.ops.absolute

 .. py:function:: mindspore.ops.absolute(x)

-    ops.abs()的别名。
-
-    详情请查看 :func:`mindspore.ops.abs`。
+    :func:`mindspore.ops.abs` 的别名。
--- a/docs/api/api_python/ops/mindspore.ops.func_adaptive_avg_pool1d.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_adaptive_avg_pool1d.rst
@ -3,8 +3,6 @@ mindspore.ops.adaptive_avg_pool1d

 .. py:function:: mindspore.ops.adaptive_avg_pool1d(input_x, output_size)

-    一维自适应平均池化。
-
    对可以看作是由一系列1D平面组成的输入Tensor，应用一维自适应平均池化操作。

    通常，输入的shape为 :math:`(N_{in}, C_{in}, L_{in})`，adaptive_avg_pool1d输出区域平均值在 :math:`L_{in}` 区间。
--- a/docs/api/api_python/ops/mindspore.ops.func_adaptive_avg_pool2d.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_adaptive_avg_pool2d.rst
@ -3,8 +3,6 @@ mindspore.ops.adaptive_avg_pool2d

 .. py:function:: mindspore.ops.adaptive_avg_pool2d(input_x, output_size)

-    二维自适应平均池化。
-
    对输入Tensor，提供二维的自适应平均池化操作。也就是说，对于输入任何尺寸，指定输出的尺寸都为H * W。但是输入和输出特征的数目不会变化。

    输入和输出数据格式可以是"NCHW"和"CHW"。N是批处理大小，C是通道数，H是特征高度，W是特征宽度。
--- a/docs/api/api_python/ops/mindspore.ops.func_adaptive_avg_pool3d.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_adaptive_avg_pool3d.rst
@ -3,8 +3,6 @@ mindspore.ops.adaptive_avg_pool3d

 .. py:function:: mindspore.ops.adaptive_avg_pool3d(input_x, output_size)

-    三维自适应平均池化。
-
    对由多个平面组成的的输入Tensor，进行三维的自适应平均池化操作。对于任何输入尺寸，指定输出的尺寸都为 :math:`(D, H, W)`，但是输入和输出特征的数目不会变化。

    假设输入 `input_x` 最后三维大小分别为 :math:`(inD, inH, inW)`，则输出的最后三维大小分别为 :math:`(outD, outH, outW)`，运算如下：
--- a/docs/api/api_python/ops/mindspore.ops.func_adaptive_max_pool1d.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_adaptive_max_pool1d.rst
@ -3,8 +3,6 @@ mindspore.ops.adaptive_max_pool1d

 .. py:function:: mindspore.ops.adaptive_max_pool1d(input_x, output_size)

-    一维自适应最大池化。
-
    对可以看作是由一系列1D平面组成的输入Tensor，应用一维自适应最大池化操作。

    通常，输入的shape为 :math:`(N_{in}, C_{in}, L_{in})`，adaptive_max_pool1d输出区域最大值在 :math:`L_{in}` 区间。
--- a/docs/api/api_python/ops/mindspore.ops.func_adaptive_max_pool2d.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_adaptive_max_pool2d.rst
@ -3,8 +3,6 @@ mindspore.ops.adaptive_max_pool2d

 .. py:function:: mindspore.ops.adaptive_max_pool2d(input_x, output_size, return_indices=False)

-    二维自适应最大池化运算。
-
    对输入Tensor，提供二维自适应最大池化操作。即对于输入任何尺寸，指定输出的尺寸都为H * W。但是输入和输出特征的数目不会变化。

    输入和输出数据格式可以是"NCHW"和"CHW"。N是批处理大小，C是通道数，H是特征高度，W是特征宽度。运算如下：
--- a/docs/api/api_python/ops/mindspore.ops.func_adjoint.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_adjoint.rst
@ -3,13 +3,13 @@

 .. py:function:: mindspore.ops.adjoint(x)

-    计算张量的共轭，并转置最后两个维度。
+    计算Tensor的共轭，并转置最后两个维度。

    参数：
-        - **x** (Tensor) - 参与计算的tensor。
+        - **x** (Tensor) - 参与计算的Tensor。

    返回：
        Tensor，和 `x` 具有相同的dtype和shape。

    异常：
-        - **TypeError**：`x` 不是tensor。
+        - **TypeError**：`x` 不是Tensor。
--- a/docs/api/api_python/ops/mindspore.ops.func_amin.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_amin.rst
@ -3,7 +3,7 @@ mindspore.ops.amin

 .. py:function:: mindspore.ops.amin(x, axis=(), keep_dims=False)

-    默认情况下，移除输入所有维度，返回 `x` 中的最大值。也可仅缩小指定维度 `axis` 大小至1。 `keep_dims` 控制输出和输入的维度是否相同。
+    默认情况下，移除输入所有维度，返回 `x` 中的最小值。也可仅缩小指定维度 `axis` 大小至1。 `keep_dims` 控制输出和输入的维度是否相同。

    参数：
        - **x** (Tensor[Number]) - 输入Tensor，其数据类型为数值型。shape： :math:`(N, *)` ，其中 :math:`*` 表示任意数量的附加维度。秩应小于8。
--- a/docs/api/api_python/ops/mindspore.ops.func_arccos.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_arccos.rst
@ -3,6 +3,4 @@ mindspore.ops.arccos

 .. py:function:: mindspore.ops.arccos(x)

-    ops.acos()的别名。
-
-    详情请查看 :func:`mindspore.ops.acos`。
+    :func:`mindspore.ops.acos` 的别名。
--- a/docs/api/api_python/ops/mindspore.ops.func_col2im.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_col2im.rst
@ -3,7 +3,7 @@ mindspore.ops.col2im

 .. py:function:: mindspore.ops.col2im(input_x, output_size, kernel_size, dilation, padding_value, stride)

-    将一组滑动局部块组合成一个大的张量。
+    将一组滑动局部块组合成一个大的Tensor。

    参数：
        - **input_x** (Tensor) - 四维Tensor，输入的批量的滑动局部块，数据类型支持float16和float32。
--- a/docs/api/api_python/ops/mindspore.ops.func_conv2d.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_conv2d.rst
@ -3,9 +3,7 @@ mindspore.ops.conv2d

 .. py:function:: mindspore.ops.conv2d(inputs, weight, pad_mode="valid", padding=0, stride=1, dilation=1, group=1)

-    二维卷积层。
-
-    对输入Tensor计算二维卷积，该Tensor的常见shape为 :math:`(N, C_{in}, H_{in}, W_{in})` ，其中 :math:`N` 为batch size，:math:`C_{in}` 为通道数， :math:`H_{in}, W_{in}` 分别为特征层的高度和宽度， :math:`X_i` 为 :math:`i^{th}` 输入值， :math:`b_i` 为 :math:`i^{th}` 输入值的偏置项。对于每个batch中的Tensor，其shape为 :math:`(C_{in}, H_{in}, W_{in})` ，公式定义如下：
+    对输入Tensor计算二维卷积。该Tensor的常见shape为 :math:`(N, C_{in}, H_{in}, W_{in})` ，其中 :math:`N` 为batch size，:math:`C_{in}` 为通道数， :math:`H_{in}, W_{in}` 分别为特征层的高度和宽度， :math:`X_i` 为 :math:`i^{th}` 输入值， :math:`b_i` 为 :math:`i^{th}` 输入值的偏置项。对于每个batch中的Tensor，其shape为 :math:`(C_{in}, H_{in}, W_{in})` ，公式定义如下：

    .. math::
        out_j = \sum_{i=0}^{C_{in} - 1} ccor(W_{ij}, X_i) + b_j,
--- a/docs/api/api_python/ops/mindspore.ops.func_conv3d.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_conv3d.rst
@ -3,9 +3,7 @@ mindspore.ops.conv3d

 .. py:function:: mindspore.ops.conv3d(inputs, weight, pad_mode="valid", padding=0, stride=1, dilation=1, group=1)

-    三维卷积层。
-
-    对输入Tensor计算三维卷积，该Tensor的常见shape为 :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})` ，其中 :math:`N` 为batch size，:math:`C_{in}` 为通道数，:math:`D` 为深度， :math:`H_{in}, W_{in}` 分别为特征层的高度和宽度。 :math:`X_i` 为 :math:`i^{th}` 输入值， :math:`b_i` 为 :math:`i^{th}` 输入值的偏置项。对于每个batch中的Tensor，其shape为 :math:`(C_{in}, D_{in}, H_{in}, W_{in})` ，公式定义如下：
+    对输入Tensor计算三维卷积。该Tensor的常见shape为 :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})` ，其中 :math:`N` 为batch size，:math:`C_{in}` 为通道数，:math:`D` 为深度， :math:`H_{in}, W_{in}` 分别为特征层的高度和宽度。 :math:`X_i` 为 :math:`i^{th}` 输入值， :math:`b_i` 为 :math:`i^{th}` 输入值的偏置项。对于每个batch中的Tensor，其shape为 :math:`(C_{in}, D_{in}, H_{in}, W_{in})` ，公式定义如下：

    .. math::
        \operatorname{out}\left(N_{i}, C_{\text {out}_j}\right)=\operatorname{bias}\left(C_{\text {out}_j}\right)+
--- a/docs/api/api_python/ops/mindspore.ops.func_coo_tanh.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_coo_tanh.rst
@ -3,8 +3,6 @@

 .. py:function:: mindspore.ops.coo_tanh(x: COOTensor)

-    Tanh激活函数。
-
    按元素计算COOTensor输入元素的双曲正切。Tanh函数定义为：

    .. math::
--- a/docs/api/api_python/ops/mindspore.ops.func_csr_tanh.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_csr_tanh.rst
@ -3,9 +3,7 @@

 .. py:function:: mindspore.ops.csr_tanh(x: CSRTensor)

-    Tanh激活函数。
-
-    按元素计算CSRTensor输入元素的双曲正切。Tanh函数定义为：
+    逐元素计算CSRTensor输入元素的双曲正切。Tanh函数定义为：

    .. math::
        tanh(x_i) = \frac{\exp(x_i) - \exp(-x_i)}{\exp(x_i) + \exp(-x_i)} = \frac{\exp(2x_i) - 1}{\exp(2x_i) + 1},
--- a/docs/api/api_python/ops/mindspore.ops.func_cummax.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_cummax.rst
@ -3,7 +3,7 @@ mindspore.ops.cummax

 .. py:function:: mindspore.ops.cummax(x, axis)

-    返回一个元组（最值、索引），其中最值是输入张量 `x` 沿维度 `axis` 的累积最大值，索引是每个最大值的索引位置。
+    返回一个元组（最值、索引），其中最值是输入Tensor `x` 沿维度 `axis` 的累积最大值，索引是每个最大值的索引位置。

    .. math::
        \begin{array}{ll} \\
--- a/docs/api/api_python/ops/mindspore.ops.func_cummin.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_cummin.rst
@ -3,7 +3,7 @@ mindspore.ops.cummin

 .. py:function:: mindspore.ops.cummin(x, axis)

-    返回一个元组（最值、索引），其中最值是输入张量 `x` 沿维度 `axis` 的累积最小值，索引是每个最小值的索引位置。
+    返回一个元组（最值、索引），其中最值是输入Tensor `x` 沿维度 `axis` 的累积最小值，索引是每个最小值的索引位置。

    .. math::
        \begin{array}{ll} \\
--- a/docs/api/api_python/ops/mindspore.ops.func_diag.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_diag.rst
@ -3,7 +3,7 @@ mindspore.ops.diag

 .. py:function:: mindspore.ops.diag(input_x)

-    用给定的对角线值构造对角线张量。
+    用给定的对角线值构造对角线Tensor。

    假设输入Tensor维度为 :math:`[D_1,... D_k]` ，则输出是一个rank为2k的tensor，其维度为 :math:`[D_1,..., D_k, D_1,..., D_k]` ，其中 :math:`output[i_1,..., i_k, i_1,..., i_k] = input_x[i_1,..., i_k]` 并且其他位置的值为0。

--- a/docs/api/api_python/ops/mindspore.ops.func_divide.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_divide.rst
@ -3,5 +3,4 @@ mindspore.ops.divide

 .. py:function:: mindspore.ops.divide(x, other, *, rounding_mode=None)

-    ops.div()的别名。
-    详情请参考 :func:`mindspore.ops.div`。
+    :func:`mindspore.ops.div` 的别名。
--- a/docs/api/api_python/ops/mindspore.ops.func_expand.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_expand.rst
@ -3,7 +3,7 @@ mindspore.ops.expand

 .. py:function:: mindspore.ops.expand(input_x, size)

-    返回一个当前张量的新视图，其中单维度扩展到更大的尺寸。
+    返回一个当前Tensor的新视图，其中单维度扩展到更大的尺寸。

    .. note::
        将 `-1` 作为维度的 `size` 意味着不更改该维度的大小。张量也可以扩展到更大的维度，新的维度会附加在前面。对于新的维度，`size` 不能设置为-1。
--- a/docs/api/api_python/ops/mindspore.ops.func_fractional_max_pool2d.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_fractional_max_pool2d.rst
@ -3,8 +3,6 @@ mindspore.ops.fractional_max_pool2d

 .. py:function:: mindspore.ops.fractional_max_pool2d(input_x, kernel_size, output_size=None, output_ratio=None, return_indices=False, _random_samples=None)

-    对输入的多维数据进行二维的分数最大池化运算。
-
    对多个输入平面组成的输入上应用2D分数最大池化。在 :math:`(kH_{in}, kW_{in})` 区域上应用最大池化操作，由输出shape决定随机步长。对于任何输入shape，指定输出shape为 :math:`(H, W)` 。输出特征的数量等于输入平面的数量。
    在一个输入Tensor上应用2D fractional max pooling，可被视为组成一个2D平面。

--- a/docs/api/api_python/ops/mindspore.ops.func_fractional_max_pool3d.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_fractional_max_pool3d.rst
@ -3,8 +3,6 @@ mindspore.ops.fractional_max_pool3d

 .. py:function:: mindspore.ops.fractional_max_pool3d(input_x, kernel_size, output_size=None, output_ratio=None, return_indices=False, _random_samples=None)

-    对输入的多维数据进行三维的分数最大池化运算。
-
    对多个输入平面组成的输入上应用3D分数最大池化。在 :math:`(kD_{in}, kH_{in}, kW_{in})` 区域上应用最大池化操作，由输出shape决定随机步长。输出特征的数量等于输入平面的数量。

    分数最大池化的详细描述在 `Fractional MaxPooling by Ben Graham <https://arxiv.org/abs/1412.6071>`_ 。
--- a/docs/api/api_python/ops/mindspore.ops.func_hardswish.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_hardswish.rst
@ -3,9 +3,7 @@ mindspore.ops.hardswish

 .. py:function:: mindspore.ops.hardswish(x)

-    Hard Swish激活函数。
-
-    对输入的每个元素计算Hard Swish。输入是一个张量，具有任何有效的shape。
+    对输入的每个元素计算Hard Swish。输入是一个Tensor，具有任何有效的shape。

    Hard Swish定义如下：

--- a/docs/api/api_python/ops/mindspore.ops.func_hinge_embedding_loss.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_hinge_embedding_loss.rst
@ -3,7 +3,7 @@ mindspore.ops.hinge_embedding_loss

 .. py:function:: mindspore.ops.hinge_embedding_loss(inputs, targets, margin=1.0, reduction="mean")

-    Hinge Embedding 损失函数。按输入元素计算输出。衡量输入张量x和标签y（包含1或-1）之间的损失值。通常被用来衡量两个输入之间的相似度。
+    Hinge Embedding 损失函数。按输入元素计算输出。衡量输入x和标签y（包含1或-1）之间的损失值。通常被用来衡量两个输入之间的相似度。

    mini-batch中的第n个样例的损失函数为：

--- a/docs/api/api_python/ops/mindspore.ops.func_i0.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_i0.rst
@ -3,6 +3,4 @@ mindspore.ops.i0

 .. py:function:: mindspore.ops.i0(x)

-    ops.bessel_i0()的别名。
-
-    详情请查看 :func:`mindspore.ops.bessel_i0`。
+    :func:`mindspore.ops.bessel_i0` 的别名。
--- a/docs/api/api_python/ops/mindspore.ops.func_kl_div.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_kl_div.rst
@ -5,7 +5,7 @@ mindspore.ops.kl_div

    计算输入 `logits` 和 `labels` 的KL散度。

-    对于相同形状的张量 :math:`x` 和 :math:`target` ，kl_div的计算公式如下：
+    对于相同shape的Tensor :math:`x` 和 :math:`target` ，kl_div的计算公式如下：

    .. math::
        L(x, target) = target \cdot (\log target - x)
--- a/docs/api/api_python/ops/mindspore.ops.func_log_softmax.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_log_softmax.rst
@ -3,8 +3,6 @@ mindspore.ops.log_softmax

 .. py:function:: mindspore.ops.log_softmax(logits, axis=-1)

-    LogSoftmax激活函数。
-
    在指定轴上对输入Tensor应用LogSoftmax函数。假设在指定轴上， :math:`x` 对应每个元素 :math:`x_i` ，则LogSoftmax函数如下所示：

    .. math::
--- a/docs/api/api_python/ops/mindspore.ops.func_lp_pool1d.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_lp_pool1d.rst
@ -3,9 +3,7 @@ mindspore.ops.lp_pool1d

 .. py:function:: mindspore.ops.lp_pool1d(x, norm_type, kernel_size, stride=None, ceil_mode=False)

-    对输入的多维数据进行一维平面上的LP池化运算。
-
-    在一个输入Tensor上应用1D LP pooling，可被视为组成一个1D输入平面。
+    在输入Tensor上应用1D LP池化运算，可被视为组成一个1D输入平面。

    通常，输入的shape为 :math:`(N_{in}, C_{in}, L_{in})` 或 :math:`(C, L_{in})`，输出的shape为 :math:`(N_{in}, C_{in}, L_{in})` 或 :math:`(C, L_{in})`，输出与输入的shape一致，公式如下：

--- a/docs/api/api_python/ops/mindspore.ops.func_lp_pool2d.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_lp_pool2d.rst
@ -3,9 +3,7 @@ mindspore.ops.lp_pool2d

 .. py:function:: mindspore.ops.lp_pool2d(x, norm_type, kernel_size, stride=None, ceil_mode=False)

-    对输入的多维数据进行二维平面上的LP池化运算。
-
-    在一个输入Tensor上应用2D LP pooling，可被视为组成一个2D输入平面。
+    在输入Tensor上应用2D LP池化运算，可被视为组成一个2D输入平面。

    通常，输入的shape为 :math:`(N, C, H_{in}, W_{in})`，输出的shape为 :math:`(N, C, H_{in}, W_{in})`，输出与输入的shape一致，公式如下：

--- a/docs/api/api_python/ops/mindspore.ops.func_masked_select.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_masked_select.rst
@ -3,7 +3,7 @@ mindspore.ops.masked_select

 .. py:function:: mindspore.ops.masked_select(x, mask)

-    返回一个一维张量，其中的内容是 `x` 张量中对应于 `mask` 张量中True位置的值。`mask` 的shape与 `x` 的shape不需要一样，但必须符合广播规则。
+    返回一个一维Tensor，其中的内容是 `x` 中对应于 `mask` 中True位置的值。`mask` 的shape与 `x` 的shape不需要一样，但必须符合广播规则。

    参数：
        - **x** (Tensor) - 它的shape是 :math:`(x_1, x_2, ..., x_R)`。
--- a/docs/api/api_python/ops/mindspore.ops.func_matrix_set_diag.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_matrix_set_diag.rst
@ -3,7 +3,7 @@ mindspore.ops.matrix_set_diag

 .. py:function:: mindspore.ops.matrix_set_diag(x, diagonal, k=0, align="RIGHT_LEFT")

-    返回具有新的对角线值的批处理矩阵张量。
+    返回具有新的对角线值的批处理矩阵Tensor。
    给定输入 `x` 和对角线 `diagonal` ，此操作返回与 `x` 具有相同形状和值的张量，但返回的张量除开最内层矩阵的对角线。这些值将被对角线中的值覆盖。如果某些对角线比 `max_diag_len` 短，则需要被填充。
    其中 `max_diag_len` 指的是对角线的最长长度。
    `diagonal` 的维度 :math:`shape[-2]` 必须等于对角线个数 `num_diags` :math:`k[1] - k[0] + 1`， `diagonal` 的维度 :math:`shape[-1]` 必须
--- a/docs/api/api_python/ops/mindspore.ops.func_max.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_max.rst
@ -3,8 +3,6 @@ mindspore.ops.max

 .. py:function:: mindspore.ops.max(x, axis=0, keep_dims=False)

-    根据指定的索引计算最大值，并返回索引和值。
-
    在给定轴上计算输入Tensor的最大值。并且返回最大值和索引。

    .. note::
--- a/docs/api/api_python/ops/mindspore.ops.func_min.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_min.rst
@ -3,8 +3,6 @@ mindspore.ops.min

 .. py:function:: mindspore.ops.min(x, axis=0, keep_dims=False)

-    根据指定的索引计算最小值，并返回索引和值。
-
    在给定轴上计算输入Tensor的最小值。并且返回最小值和索引。

    .. note::
--- a/docs/api/api_python/ops/mindspore.ops.func_negative.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_negative.rst
@ -3,6 +3,4 @@ mindspore.ops.negative

 .. py:function:: mindspore.ops.negative(x)

-    ops.neg()的别名。
-
-    详情请参考 :func:`mindspore.ops.neg`。
+    :func:`mindspore.ops.neg` 的别名。
--- a/docs/api/api_python/ops/mindspore.ops.func_padding.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_padding.rst
@ -3,8 +3,7 @@ mindspore.ops.padding

 .. py:function:: mindspore.ops.padding(x, pad_dim_size=8)

-    通过填充0，将输入张量的最后一个维度从1扩展到指定大小。
-
+    通过填充0，将输入Tensor的最后一个维度从1扩展到指定大小。

    参数：
        - **x** (Tensor) - `x` 的shape为 :math:`(x_1, x_2, ..., x_R)`，秩至少为2，它的最后一个维度必须为1。其数据类型为数值型。
--- a/docs/api/api_python/ops/mindspore.ops.func_pixel_shuffle.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_pixel_shuffle.rst
@ -3,8 +3,6 @@ mindspore.ops.pixel_shuffle

 .. py:function:: mindspore.ops.pixel_shuffle(x, upscale_factor)

-    pixel_shuffle函数。
-
    在多个输入平面组成的输入上面应用pixel_shuffle算法。在平面上应用高效亚像素卷积，步长为 :math:`1/r` 。关于pixel_shuffle算法详细介绍，请参考 `Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional Neural Network <https://arxiv.org/abs/1609.05158>`_ 。

    通常情况下，`x` shape :math:`(*, C \times r^2, H, W)` ，输出shape :math:`(*, C, H \times r, W \times r)` 。`r` 是缩小因子。 `*` 是大于等于0的维度。
--- a/docs/api/api_python/ops/mindspore.ops.func_pixel_unshuffle.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_pixel_unshuffle.rst
@ -3,8 +3,6 @@ mindspore.ops.pixel_unshuffle

 .. py:function:: mindspore.ops.pixel_unshuffle(x, downscale_factor)

-    pixel_unshuffle函数。
-
    在多个输入平面组成的输入上面应用pixel_unshuffle算法。关于pixel_unshuffle算法详细介绍，请参考 `Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional Neural Network <https://arxiv.org/abs/1609.05158>`_ 。

    通常情况下，`x` shape :math:`(*, C, H \times r, W \times r)` ，输出shape :math:`(*, C \times r^2, H, W)` 。`r` 是缩小因子。 `*` 是大于等于0的维度。
--- a/docs/api/api_python/ops/mindspore.ops.func_scalar_to_tensor.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_scalar_to_tensor.rst
@ -3,7 +3,7 @@ mindspore.ops.scalar_to_tensor

 .. py:function:: mindspore.ops.scalar_to_tensor(input_x, dtype=mstype.float32)

-    将Scalar转换为指定数据类型的 `Tensor` 。
+    将Scalar转换为指定数据类型的Tensor。

    参数：
        - **input_x** (Union[int, float]) - 输入是Scalar。只能是常量值。
--- a/docs/api/api_python/ops/mindspore.ops.func_scatter_div.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_scatter_div.rst
@ -3,8 +3,6 @@ mindspore.ops.scatter_div

 .. py:function:: mindspore.ops.scatter_div(input_x, indices, updates)

-    通过除法操作更新输入张量的值。
-
    根据指定更新值和输入索引通过除法操作更新输入数据的值。
    该操作在更新完成后输出 `input_x` ，这样方便使用更新后的值。

--- a/docs/api/api_python/ops/mindspore.ops.func_scatter_min.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_scatter_min.rst
@ -3,8 +3,6 @@ mindspore.ops.scatter_min

 .. py:function:: mindspore.ops.scatter_min(input_x, indices, updates)

-    通过最小操作更新输入张量的值。
-
    根据指定更新值和输入索引通过最小值操作更新输入数据的值。
    该操作在更新完成后输出 `input_x` ，这样方便使用更新后的值。

--- a/docs/api/api_python/ops/mindspore.ops.func_scatter_nd_add.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_scatter_nd_add.rst
@ -3,7 +3,7 @@ mindspore.ops.scatter_nd_add

 .. py:function:: mindspore.ops.scatter_nd_add(input_x, indices, updates, use_locking=False)

-    将sparse addition应用于张量中的单个值或切片。
+    将sparse addition应用于Tensor中的单个值或切片。

    使用给定值通过加法运算和输入索引更新Tensor值。在更新完成后输出 `input_x` ，这有利于更加方便地使用更新后的值。

--- a/docs/api/api_python/ops/mindspore.ops.func_scatter_nd_div.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_scatter_nd_div.rst
@ -3,7 +3,7 @@ mindspore.ops.scatter_nd_div

 .. py:function:: mindspore.ops.scatter_nd_div(input_x, indices, updates, use_locking=False)

-    将sparse division应用于张量中的单个值或切片。
+    将sparse division应用于Tensor中的单个值或切片。

    使用给定值通过除法运算和输入索引更新 `input_x` 的值。为便于使用，函数返回 `input_x` 的复制。

--- a/docs/api/api_python/ops/mindspore.ops.func_scatter_nd_max.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_scatter_nd_max.rst
@ -3,7 +3,7 @@ mindspore.ops.scatter_nd_max

 .. py:function:: mindspore.ops.scatter_nd_max(input_x, indices, updates, use_locking=False)

-    对张量中的单个值或切片应用sparse maximum。
+    对Tensor中的单个值或切片应用sparse maximum。

    使用给定值通过最大值运算和输入索引更新Parameter值。在更新完成后输出 `input_x` ，这有利于更加方便地使用更新后的值。

--- a/docs/api/api_python/ops/mindspore.ops.func_scatter_nd_min.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_scatter_nd_min.rst
@ -3,7 +3,7 @@ mindspore.ops.scatter_nd_min

 .. py:function:: mindspore.ops.scatter_nd_min(input_x, indices, updates, use_locking=False)

-    对张量中的单个值或切片应用sparse minimum。
+    对Tensor中的单个值或切片应用sparse minimum。

    使用给定值通过最小值运算和输入索引更新 `input_x` 的值。为便于使用，函数返回 `input_x` 的复制。

--- a/docs/api/api_python/ops/mindspore.ops.func_select.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_select.rst
@ -3,7 +3,7 @@ mindspore.ops.select

 .. py:function:: mindspore.ops.select(cond, x, y)

-    根据条件判断Tensor中的元素的值来，决定输出中的相应元素是从 `x` （如果元素值为True）还是从 `y` （如果元素值为False）中选择。
+    根据条件判断Tensor中的元素的值，来决定输出中的相应元素是从 `x` （如果元素值为True）还是从 `y` （如果元素值为False）中选择。

    该算法可以被定义为：

--- a/docs/api/api_python/ops/mindspore.ops.func_sigmoid.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_sigmoid.rst
@ -3,7 +3,7 @@ mindspore.ops.sigmoid

 .. py:function:: mindspore.ops.sigmoid(input_x)

-    Sigmoid激活函数，逐元素计算Sigmoid激活函数。Sigmoid函数定义为：
+    逐元素计算Sigmoid激活函数。Sigmoid函数定义为：

    .. math::

--- a/docs/api/api_python/ops/mindspore.ops.func_softmax.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_softmax.rst
@ -3,9 +3,7 @@ mindspore.ops.softmax

 .. py:function:: mindspore.ops.softmax(x, axis=-1)

-    Softmax函数。
-
-    在指定轴上对输入Tensor执行Softmax函数做归一化操作。假设指定轴 :math:`x` 上有切片，那么每个元素 :math:`x_i` 所对应的Softmax函数如下所示：
+    在指定轴上对输入Tensor执行Softmax激活函数做归一化操作。假设指定轴 :math:`x` 上有切片，那么每个元素 :math:`x_i` 所对应的Softmax函数如下所示：

    .. math::
        \text{output}(x_i) = \frac{exp(x_i)}{\sum_{j = 0}^{N-1}\exp(x_j)},
--- a/docs/api/api_python/ops/mindspore.ops.func_space_to_batch_nd.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_space_to_batch_nd.rst
@ -3,7 +3,7 @@ mindspore.ops.space_to_batch_nd

 .. py:function:: mindspore.ops.space_to_batch_nd(input_x, block_size, paddings)

-    将空间维度划分为对应大小的块，然后在批次维度重排张量。
+    将空间维度划分为对应大小的块，然后在批次维度重排Tensor。

    此函数将输入的空间维度 [1, ..., M] 划分为形状为 `block_size` 的块网格，并将这些块在批次维度上（默认是第零维）中交错排列。
    输出的张量在空间维度上的截面是输入在对应空间维度上截面的一个网格，而输出的批次维度的大小为空间维度分解成块网格的数量乘以输入的批次维度的大小。
--- a/docs/api/api_python/ops/mindspore.ops.func_tanh.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_tanh.rst
@ -3,9 +3,7 @@

 .. py:function:: mindspore.ops.tanh(input_x)

-    Tanh激活函数。
-
-    按元素计算输入元素的双曲正切。Tanh函数定义为：
+    逐元素计算输入元素的双曲正切。Tanh函数定义为：

    .. math::
        tanh(x_i) = \frac{\exp(x_i) - \exp(-x_i)}{\exp(x_i) + \exp(-x_i)} = \frac{\exp(2x_i) - 1}{\exp(2x_i) + 1},
--- a/docs/api/api_python/ops/mindspore.ops.func_true_divide.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_true_divide.rst
@ -3,6 +3,4 @@

 .. py:function:: mindspore.ops.true_divide(dividend, divisor)

-    ops.div()在 :math:`rounding\_mode=None` 时的别名。
-
-    获取更多详情请查看： :func:`mindspore.ops.div` 。
+    :func:`mindspore.ops.div` 在 :math:`rounding\_mode=None` 时的别名。
--- a/docs/api/api_python/ops/mindspore.ops.func_trunc.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_trunc.rst
@ -3,7 +3,7 @@ mindspore.ops.trunc

 .. py:function:: mindspore.ops.trunc(input)

-    返回一个新的张量，该张量具有输入元素的截断整数值。
+    返回一个新的Tensor，该Tensor具有输入元素的截断整数值。

    参数：
        - **input** (Tensor) - 任意维度的Tensor。
--- a/docs/api/api_python/ops/mindspore.ops.func_unique_consecutive.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_unique_consecutive.rst
@ -3,7 +3,7 @@ mindspore.ops.unique_consecutive

 .. py:function:: mindspore.ops.unique_consecutive(x, return_idx=False, return_counts=False, axis=None)

-    对输入张量中连续且重复的元素去重。
+    对输入Tensor中连续且重复的元素去重。

    参数：
        - **x** (Tensor) - 输入Tensor。
--- a/docs/api/api_python/ops/mindspore.ops.func_unique_with_pad.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_unique_with_pad.rst
@ -3,11 +3,11 @@ mindspore.ops.unique_with_pad

 .. py:function:: mindspore.ops.unique_with_pad(x, pad_num)

-    对输入一维张量中元素去重，返回一维张量中的唯一元素（使用pad_num填充）和相对索引。
+    对输入一维Tensor中元素去重，返回一维Tensor中的唯一元素（使用pad_num填充）和相对索引。

    基本操作与unique相同，但unique_with_pad多了pad操作。
-    unique运算符对张量处理后所返回的元组（ `y` ， `idx` ）， `y` 与 `idx` 的shape通常会有差别。因此，为了解决上述情况，
-    unique_with_pad操作符将用用户指定的 `pad_num` 填充 `y` 张量，使其具有与张量 `idx` 相同的形状。
+    unique运算符对Tensor处理后所返回的元组（ `y` ， `idx` ）， `y` 与 `idx` 的shape通常会有差别。因此，为了解决上述情况，
+    unique_with_pad操作符将用用户指定的 `pad_num` 填充 `y` ，使其具有与 `idx` 相同的形状。

    参数：
        - **x** (Tensor) - 需要被去重的Tensor。必须是类型为int32或int64的一维向量。
@ -18,4 +18,4 @@ mindspore.ops.unique_with_pad

    异常：
        - **TypeError** - `x` 的数据类型既不是int32也不是int64。
-        - **ValueError** - `x` 不是一维张量。
+        - **ValueError** - `x` 不是一维Tensor。
--- a/docs/api/api_python/ops/mindspore.ops.func_unsorted_segment_min.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_unsorted_segment_min.rst
@ -5,7 +5,7 @@ mindspore.ops.unsorted_segment_min

    沿分段计算输入Tensor的最小值。

-    UnsortedSegmentMin的计算过程如下图所示：
+    unsorted_segment_min的计算过程如下图所示：

    .. image:: UnsortedSegmentMin.png

--- a/docs/api/api_python/ops/mindspore.ops.func_unsorted_segment_prod.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_unsorted_segment_prod.rst
@ -5,7 +5,7 @@ mindspore.ops.unsorted_segment_prod

    沿分段计算输入Tensor元素的乘积。

-    UnsortedSegmentProd的计算过程如下图所示：
+    unsorted_segment_prod的计算过程如下图所示：

    .. image:: UnsortedSegmentProd.png

--- a/docs/api/api_python/ops/mindspore.ops.func_unsorted_segment_sum.rst
+++ b/docs/api/api_python/ops/mindspore.ops.func_unsorted_segment_sum.rst
@ -7,7 +7,7 @@

    计算输出Tensor :math:`\text{output}[i] = \sum_{segment\_ids[j] == i} \text{data}[j, \ldots]` ，其中 :math:`j,...` 是代表元素索引的Tuple。 `segment_ids` 确定输入Tensor元素的分段。 `segment_ids` 不需要排序，也不需要覆盖 `num_segments` 范围内的所有值。

-    UnsortedSegmentSum的计算过程如下图所示：
+    unsorted_segment_sum的计算过程如下图所示：

    .. image:: UnsortedSegmentSum.png

--- a/Show More
+++ b/Show More