Update API documents based on review comments.

2022-07-05 11:30:17 +08:00 · 2022-07-05 11:30:17 +08:00 · 1f9a61f51a
parent 2779bd4956
commit 1f9a61f51a
40 changed files with 114 additions and 97 deletions
--- a/docs/api/api_python/nn/mindspore.nn.MSSSIM.rst
+++ b/docs/api/api_python/nn/mindspore.nn.MSSSIM.rst
@ -5,7 +5,7 @@

    多尺度计算两个图像之间的结构相似性（SSIM）。

-    基于Zhou Wang、Eero P.Simoncelli和Alan C.Bovik在2004年于Signals, Systems 和 Computers上发表的 `Multiscale structural similarity for image quality assessment <https://ieeexplore.ieee.org/document/1292216>`_ 。
+    基于Zhou Wang、Eero P.Simoncelli和Alan C.Bovik在2004年于Signals, Systems and Computers上发表的 `Multiscale structural similarity for image quality assessment <https://ieeexplore.ieee.org/document/1292216>`_ 。

    .. math::
        l(x,y)&=\frac{2\mu_x\mu_y+C_1}{\mu_x^2+\mu_y^2+C_1}, C_1=(K_1L)^2.\\
@ -16,9 +16,9 @@
    **参数：**

    - **max_val** (Union[int, float]) - 像素值的动态范围，即最大值和最小值之间的差值。（8bit灰度图像素为255）。默认值：1.0。
-    - **power_factors** (Union[tuple, list]) - 权重列表，可循环获取权重值。默认值：(0.0448、0.2856、0.3001、0.2363、0.1333)。此处使用的默认值是由Wang等人在论文中提出。
-    - **filter_size** (int) - 高斯过滤器的大小。默认值：11。
-    - **filter_sigma** (float) - 高斯核的标准差。默认值：1.5。
+    - **power_factors** (Union[tuple, list]) - 权重列表。默认值：(0.0448、0.2856、0.3001、0.2363、0.1333)。此处使用的默认值是由Wang等人在论文中提出。
+    - **filter_size** (int) - 高斯滤波器的尺寸大小。默认值：11。
+    - **filter_sigma** (float) - 高斯滤波器的标准差。默认值：1.5。
    - **k1** (float) - 在亮度比较函数中，此常量用于生成 :math:`C_1` 。默认值：0.01。
    - **k2** (float) - 在对比度比较函数中，此常量用于生成 :math:`C_2` 。默认值：0.03。

@ -29,7 +29,7 @@

    **输出：**

-    Tensor，值在[0, 1]范围内。它是一个shape为N的一维Tensor，其中N是 `img1` 的批次号。
+    Tensor，输入的结构相似性。取值在[0, 1]范围内。它是一个shape为N的一维Tensor，其中N是 `img1` 的batch size。

    **异常：**

--- a/docs/api/api_python/nn/mindspore.nn.MatrixSetDiag.rst
+++ b/docs/api/api_python/nn/mindspore.nn.MatrixSetDiag.rst
@ -5,7 +5,7 @@ mindspore.nn.MatrixSetDiag

    将输入的对角矩阵的对角线值置换为输入的对角线值。

-    假设 `x` 有 :math:`k+1` 个维度 :math:`[I,J,K,...,M,N]' ， `diagonal` 有 :math:`k` 个维度 :math:`[I, J, K, ..., min(M, N)]` ，则输出秩为 :math:`k+1` ，维度为 :math:`[I, J, K, ..., M, N]` 的Tensor，其中：
+    假设 `x` 有 :math:`k+1` 个维度 :math:`[I,J,K,...,M,N]` ， `diagonal` 有 :math:`k` 个维度 :math:`[I, J, K, ..., min(M, N)]` ，则输出秩为 :math:`k+1` ，维度为 :math:`[I, J, K, ..., M, N]` 的Tensor，其中：

    .. math::
        output[i, j, k, ..., m, n] = diagnoal[i, j, k, ..., n]\ for\ m == n
@ -26,6 +26,6 @@ mindspore.nn.MatrixSetDiag

    - **TypeError** - `x` 或 `diagonal` 的数据类型不是float32、float16、int32、int8或uint8。
    - **ValueError** - `x` 的shape长度小于2。
-    - **ValueError** - :math:`x_shape[-2] < x_shape[-1]` 且 :math:`x_shape[:-1] != diagonal_shape` 。
-    - **ValueError** - :math:`x_shape[-2] >= x_shape[-1]` 且 :math:`x_shape[:-2] + x_shape[-1:] != diagonal_shape` 。 
+    - **ValueError** - :math:`x\_shape[-2] < x\_shape[-1]` 且 :math:`x\_shape[:-1] != diagonal\_shape` 。
+    - **ValueError** - :math:`x\_shape[-2] >= x\_shape[-1]` 且 :math:`x\_shape[:-2] + x\_shape[-1:] != diagonal\_shape` 。 
    
--- a/docs/api/api_python/nn/mindspore.nn.MultiClassDiceLoss.rst
+++ b/docs/api/api_python/nn/mindspore.nn.MultiClassDiceLoss.rst
@ -3,7 +3,7 @@ mindspore.nn.MultiClassDiceLoss

 .. py:class:: mindspore.nn.MultiClassDiceLoss(weights=None, ignore_indiex=None, activation='softmax')

-    当有多个分类时，标签通过one-hot编码转换为多个二分类。每个通道切面，可以看做是一个二分类问题，所以多分类DiceLoss损失函数，可以通过计算每个类别的二分类的 :class:`mindspore.nn.DiceLoss` 损失，最后再求平均值得到。
+    对于多标签问题，可以将标签通过one-hot编码转换为多个二分类标签。每个通道可以看做是一个二分类问题，所以损失可以通过先计算每个类别的二分类的 :class:`mindspore.nn.DiceLoss` 损失，再计算各二分类损失的平均值得到。

    **参数：**

--- a/docs/api/api_python/nn/mindspore.nn.Norm.rst
+++ b/docs/api/api_python/nn/mindspore.nn.Norm.rst
@ -19,7 +19,7 @@ mindspore.nn.Norm

    **输出：**

-    Tensor，输出为Tensor，如果'keep_dims'为True，则将保留'axis'指定的维度且为1；否则，将移除'axis'中指定的维度。数据类型与 `x` 相同。
+    Tensor，如果'keep_dims'为True，则将保留'axis'指定的维度且为1；否则，将移除'axis'中指定的维度。数据类型与 `x` 相同。

    **异常：**

--- a/docs/api/api_python/nn/mindspore.nn.PSNR.rst
+++ b/docs/api/api_python/nn/mindspore.nn.PSNR.rst
@ -17,12 +17,12 @@ mindspore.nn.PSNR

    **输入：**

-    - **img1** (Tensor) - 格式为'NCHW'的第一批图像。shape和数据类型必须与 `img2` 相同。
-    - **img2** (Tensor) - 格式为'NCHW'的第二批图像。shape和数据类型必须与 `img1` 相同。
+    - **img1** (Tensor) - 格式为'NCHW'的输入图像。shape和数据类型必须与 `img2` 相同。
+    - **img2** (Tensor) - 格式为'NCHW'的输入图像。shape和数据类型必须与 `img1` 相同。

    **输出：**

-    Tensor，使用数据类型mindspore.float32。shape为N的一维Tensor，其中N是 `img1` 的批次大小。
+    Tensor，使用数据类型mindspore.float32。shape为N的一维Tensor，其中N是 `img1` 的batch size。

    **异常：**

--- a/docs/api/api_python/nn/mindspore.nn.SSIM.rst
+++ b/docs/api/api_python/nn/mindspore.nn.SSIM.rst
@ -23,8 +23,8 @@ mindspore.nn.SSIM

    **输入：**

-    - **img1** (Tensor)：格式为'NCHW'的第一批图像。shape和数据类型必须与img2相同。
-    - **img2** (Tensor)：格式为'NCHW'的第二批图像。shape和数据类型必须与img1相同。
+    - **img1** (Tensor)：格式为'NCHW'的输入图像。shape和数据类型必须与img2相同。
+    - **img2** (Tensor)：格式为'NCHW'的输入图像。shape和数据类型必须与img1相同。

    **输出：**

--- a/docs/api/api_python/nn/mindspore.nn.SparseTensorDenseMatmul.rst
+++ b/docs/api/api_python/nn/mindspore.nn.SparseTensorDenseMatmul.rst
@ -3,12 +3,12 @@ mindspore.nn.SparseTensorDenseMatmul

 .. py:class:: mindspore.nn.SparseTensorDenseMatmul(adjoint_st=False, adjoint_dt=False)

-    稀疏矩阵 `a` 乘以密集矩阵 `b` 。稀疏矩阵和密集矩阵的秩必须等于2。
+    稀疏矩阵 `a` 乘以稠密矩阵 `b` 。稀疏矩阵和稠密矩阵的秩必须等于2。

    **参数：**

    - **adjoint_st** (bool) - 如果为True，则在乘法之前转置稀疏Tensor。默认值：False。
-    - **adjoint_dt** (bool) - 如果为True，则在乘法之前转置密集Tensor。默认值：False。
+    - **adjoint_dt** (bool) - 如果为True，则在乘法之前转置稠密Tensor。默认值：False。

    **输入：**

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

 .. py:class:: mindspore.nn.SparseToDense

-    将稀疏Tensor转换为稠密Tensor。
+    将稀疏Tensor(COO Tensor)转换为稠密Tensor。

    在Python中，为了方便使用，三个Tensor被收集到一个SparseTensor类中。MindSpore使用三个独立的稠密Tensor： `indices` 、 `values` 和 `dense_shape` 来表示稀疏Tensor。在调用 :class:`mindspore.ops.SparseToDense` 之前，可以单独的将 `indices` 、 `values` 和 `dense_shape` 传递给稀疏Tensor对象。

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

 .. py:class:: mindspore.nn.SyncBatchNorm(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, process_groups=None)

-    在N维输入上进行跨卡同步批归一化（Batch Normalization，BN）。
+    在N维输入上进行跨设备同步批归一化（Batch Normalization，BN）。

    同步BN是跨设备的。BN的实现仅对每个设备中的数据进行归一化。同步BN将归一化组内的输入。描述见论文 `Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift <https://arxiv.org/abs/1502.03167>`_ 。使用mini-batch数据和和学习参数进行训练，参数见如下公式。

@ -18,7 +18,7 @@ mindspore.nn.SyncBatchNorm
    - **num_features** (int) - 指定输入Tensor的通道数量，输入Tensor的size为 :math:`(N, C, H, W)` 。
    - **eps** (float) - :math:`\epsilon` 添加到分母中的值，以确保数值稳定。默认值：1e-5。
    - **momentum** (float) - 动态均值和动态方差所使用的动量。默认值：0.9。
-    - **affine** (bool) - bool类型。设置为True时，可学习 :math:`\gamma` 和 :math:`\beta` 值。默认值：True。
+    - **affine** (bool) - bool类型。设置为True时， :math:`\gamma` 和 :math:`\beta` 为可学习参数。默认值：True。
    - **gamma_init** (Union[Tensor, str, Initializer, numbers.Number]) - :math:`\gamma` 参数的初始化方法。str的值引用自函数 `mindspore.common.initializer` ，包括'zeros'、'ones'、'xavier_uniform'、'he_uniform'等。默认值：'ones'。
    - **beta_init** (Union[Tensor, str, Initializer, numbers.Number]) - :math:`\beta` 参数的初始化方法。str的值引用自函数 `mindspore.common.initializer` ，包括'zeros'、'ones'、'xavier_uniform'、'he_uniform'等。默认值：'zeros'。
    - **moving_mean_init** (Union[Tensor, str, Initializer, numbers.Number]) - 动态平均值的初始化方法。str的值引用自函数 `mindspore.common.initializer` ，包括'zeros'、'ones'、'xavier_uniform'、'he_uniform'等。默认值：'zeros'。
--- a/docs/api/api_python/nn/mindspore.nn.TimeDistributed.rst
+++ b/docs/api/api_python/nn/mindspore.nn.TimeDistributed.rst
@ -3,13 +3,13 @@ mindspore.nn.TimeDistributed

 .. py:class:: mindspore.nn.TimeDistributed(layer, time_axis, reshape_with_axis=None)

-    时间分布层。
+    时间序列封装层。

-    TimeDistributed是一个封装层，它允许将一个层应用到输入的每个时间切片。 `x` 至少是三维。执行中有两种情况。当提供 `reshape_with_axis` 时，选择reshape方法会更高效；否则，将使用沿 `time_axis` 划分输入的方法，这种方法更通用。比如，在处理BN时无法提供 `reshape_with_axis` 。
+    TimeDistributed是一个封装层，它允许将一个网络层应用到输入的每个时间切片。 `x` 至少是三维。执行中有两种情况。当提供 `reshape_with_axis` 时，选择reshape方法会更高效；否则，将使用沿 `time_axis` 划分输入的方法，这种方法更通用。比如，在处理BN时无法提供 `reshape_with_axis` 。

    **参数：**

-    - **layer** (Union[Cell, Primitive]) - 被封装的Cell或Primitive。
+    - **layer** (Union[Cell, Primitive]) - 需被封装的Cell或Primitive。
    - **time_axis** (int) - 指定各个时间切片上的轴。
    - **reshape_with_axis** (int) - 将使用 `time_axis` 调整该轴。默认值：None。

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

    通过Adam算法更新梯度。

-    Adam算法首次提出，参见 `Adam: A Method for Stochastic Optimization <https://arxiv.org/abs/1412.6980>`_ 。
+    Adam算法详情请参考 `Adam: A Method for Stochastic Optimization <https://arxiv.org/abs/1412.6980>`_ 。

    有关更多详细信息，参见 :class:`mindspore.nn.Adam` 。

--- a/docs/api/api_python/ops/mindspore.ops.ApplyAdaMax.rst
+++ b/docs/api/api_python/ops/mindspore.ops.ApplyAdaMax.rst
@ -16,7 +16,7 @@
            var = var - \frac{l}{1 - \beta_1^{t+1}} * \frac{m_{t+1}}{v_{t+1} + \epsilon}
        \end{array}

-    :math:`t` 表示更新步长， :math:`m` 为一阶矩， :math:`m_{t}` 是上一步的 :math:`m_{t+1}` ， :math:`v` 为二阶矩， :math:`v_{t}` 是上一步的 :math:`v_{t+1}` ， :math:`l` 代表学习率 `lr` ， :math:`g` 代表 `grad` ， :math:`\beta_1, \beta_2` 代表 `beta1` 和 `beta2` ， :math:`\beta_1^{t+1}` 代表 `beta1_power` ， :math:`var` 代表要更新的网络参数， :math:`\epsilon` 代表 `epsilon` 。
+    :math:`t` 表示更新步数， :math:`m` 为一阶矩， :math:`m_{t}` 是上一步的 :math:`m_{t+1}` ， :math:`v` 为二阶矩， :math:`v_{t}` 是上一步的 :math:`v_{t+1}` ， :math:`l` 代表学习率 `lr` ， :math:`g` 代表 `grad` ， :math:`\beta_1, \beta_2` 代表 `beta1` 和 `beta2` ， :math:`\beta_1^{t+1}` 代表 `beta1_power` ， :math:`var` 代表要更新的网络参数， :math:`\epsilon` 代表 `epsilon` 。

    `var` 、 `m` 、 `v` 和 `grad` 的输入符合隐式类型转换规则，使数据类型一致。如果它们具有不同的数据类型，则低精度数据类型将转换为相对最高精度的数据类型。

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

    使用动量算法的优化器。

-    更多详细信息，请参阅论文 `关于深度学习中初始化和动量的重要性 <https://dl.acm.org/doi/10.5555/3042817.3043064>`_ 。
+    更多详细信息，请参阅论文 `On the importance of initialization and momentum in deep learning <https://dl.acm.org/doi/10.5555/3042817.3043064>`_ 。

    输入的 `variable` 、 `accumulation` 和 `gradient` 的输入遵循隐式类型转换规则，使数据类型一致。如果它们具有不同的数据类型，则低精度数据类型将转换为相对最高精度的数据类型。

@ -13,8 +13,8 @@

    **参数：**
    
-    - **use_locking** (bool) - 是否启用锁，以保护 `variable` 和 `accumulation` 不被更新。默认值：False。
-    - **use_nesterov** (bool) - 是否启用涅斯捷罗夫动量。默认值：False。
+    - **use_locking** (bool) - 是否对参数更新加锁保护。默认值：False。
+    - **use_nesterov** (bool) - 是否使用nesterov动量。默认值：False。
    - **gradient_scale** (float) - 梯度的缩放比例。默认值：1.0。

    **输入：**
--- a/docs/api/api_python/ops/mindspore.ops.ApplyPowerSign.rst
+++ b/docs/api/api_python/ops/mindspore.ops.ApplyPowerSign.rst
@ -14,7 +14,7 @@
            var = var - lr_{t+1} * \text{update}
        \end{array}

-    :math:`t` 表示更新步长，而 :math:`m` 表示第一个时刻向量， :math:`m_{t}` 是 :math:`m_{t+1}` 的最后时刻， :math:`lr` 表示 `lr` ， :math:`g` 表示 `grad` ， :math:`\beta` 表示 `beta` 。
+    :math:`t` 表示更新步数，而 :math:`m` 为一阶矩， :math:`m_{t}` 是上一步的 :math:`m_{t+1}` ， :math:`lr` 表示 `lr` ， :math:`g` 表示 `grad` ， :math:`\beta` 表示 `beta` 。

    所有输入都遵循隐式类型转换规则，以使数据类型一致。如果 `lr` 、 `logbase` 、 `sign_decay` 或 `beta` 是数值型，则会自动转换为Tensor，数据类型与操作中涉及的Tensor的数据类型一致。如果输入是Tensor，并且具有不同的数据类型，则低精度数据类型将转换为最高精度的数据类型。

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

 .. py:class:: mindspore.ops.ApplyProximalAdagrad(use_locking=False)

-    更新Proximal Adagrad算法的参数。
+    根据Proximal Adagrad算法更新网络参数。
    请参阅论文 `Efficient Learning using Forward-Backward Splitting <http://papers.nips.cc//paper/3793-efficient-learning-using-forward-backward-splitting.pdf>`_ 。

    .. math::
@ -22,7 +22,7 @@ mindspore.ops.ApplyProximalAdagrad
    **输入：**

    - **var** (Parameter) - 公式中的"var"。数据类型需为float16或float32。shape为 :math:`(N,*)` ，其中 :math:`*` 表示任何数量的附加维度。
-    - **accum** (Parameter) - 公式中的"accum"。与 `var` 的shape与数据类型相同。
+    - **accum** (Parameter) - 公式中的"accum"。与 `var` 的shape和数据类型相同。
    - **lr** (Union[Number, Tensor]) - 学习率，必须为标量，数据类型为float16或float32。
    - **l1** (Union[Number, Tensor]) - l1正则化强度，必须为标量，数据类型为float16或float32。
    - **l2** (Union[Number, Tensor]) - l2正则化强度，必须为标量，数据类型为float16或float32。
--- a/docs/api/api_python/ops/mindspore.ops.ApplyProximalGradientDescent.rst
+++ b/docs/api/api_python/ops/mindspore.ops.ApplyProximalGradientDescent.rst
@ -3,7 +3,7 @@ mindspore.ops.ApplyProximalGradientDescent

 .. py:class:: mindspore.ops.ApplyProximalGradientDescent

-    更新FOBOS(Forward Backward Splitting)算法的参数。
+    根据FOBOS(Forward Backward Splitting)算法更新网络参数。
    请参阅论文 `Efficient Learning using Forward-Backward Splitting
    <http://papers.nips.cc//paper/3793-efficient-learning-using-forward-backward-splitting.pdf>`_。

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

    **输入：**

-    - **x** (Tensor) - 输入Tensor，需为以下数据类型：float16，float32。shape: :math:`(N,*)` ，其中 :math:`*` 表示任何数量的附加维度。其轶应小于8。
+    - **x** (Tensor) - 输入Tensor，需为以下数据类型：float16，float32。shape: :math:`(N,*)` ，其中 :math:`*` 表示任何数量的附加维度。其秩应小于8。
    - **y** (Tensor) - 输入Tensor，shape与数据类型与 `x` 相同。

    **输出：**
--- a/docs/api/api_python/ops/mindspore.ops.ArgMaxWithValue.rst
+++ b/docs/api/api_python/ops/mindspore.ops.ArgMaxWithValue.rst
@ -32,5 +32,6 @@

    **异常：**

+    - **TYpeError** - `input_x` 的数据类型非float16、float32或float64。
    - **TypeError** - `keep_dims` 不是bool。
    - **TypeError** - `axis` 不是int。
--- a/docs/api/api_python/ops/mindspore.ops.BinaryCrossEntropy.rst
+++ b/docs/api/api_python/ops/mindspore.ops.BinaryCrossEntropy.rst
@ -36,7 +36,7 @@ mindspore.ops.BinaryCrossEntropy

    **输出：**

-    Tensor或Scalar，如果 `reduction` 为'none'，则输出为Tensor，其shape与 `logits` 相同。否则，输出为Scalar。
+    Tensor，与 `logits` 有相同的数据类型。如果 `reduction` 为'none'，则shape与 `logits` 相同。否则，输出为Scalar Tensor。

    **异常：**

--- a/docs/api/api_python/ops/mindspore.ops.CTCLoss.rst
+++ b/docs/api/api_python/ops/mindspore.ops.CTCLoss.rst
@ -35,4 +35,3 @@ mindspore.ops.CTCLoss
    - **TypeError** - `x` 的数据类型不是float16、float32或float64。
    - **TypeError** - `labels_indices` 的数据类型不是int64。
    - **TypeError** - `labels_values` 或 `sequence_length` 的数据类型不是int32。
-    
--- a/docs/api/api_python/ops/mindspore.ops.Conv2D.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Conv2D.rst
@ -51,4 +51,4 @@ mindspore.ops.Conv2D
    - **ValueError** - `pad_mode` 不是"same"、"valid"或"pad"。
    - **ValueError** - `pad` 是一个长度不等于4的tuple。
    - **ValueError** - `pad_mode` 不等于"pad"，`pad` 不等于(0, 0, 0, 0)。
-    - **ValueError** - `data_format` 既不是"NCW"，也不是"NHWC"。
+    - **ValueError** - `data_format` 既不是"NCHW"，也不是"NHWC"。
--- a/docs/api/api_python/ops/mindspore.ops.Conv3D.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Conv3D.rst
@ -5,7 +5,7 @@ mindspore.ops.Conv3D

    3维卷积操作。

-    对输入Tensor进行3维卷积操作。输入Tensor的shape通常为 :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})` ，输出的shape为 :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})` ，其中 :math:`N` 为batch size，:math:`C` 是空间维度， :math:`D` 、 :math:`H` 、 :math:`W` 分别为特征层的深度、高度和宽度。公式定义如下：
+    对输入Tensor进行3维卷积操作。输入Tensor的shape通常为 :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})` ，输出的shape为 :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})` ，其中 :math:`N` 为batch size，:math:`C` 是通道数， :math:`D` 、 :math:`H` 、 :math:`W` 分别为特征层的深度、高度和宽度。公式定义如下：

    .. math::
        \operatorname{out}\left(N_{i}, C_{\text {out}_j}\right)=\operatorname{bias}\left(C_{\text {out}_j}\right)+
@ -26,10 +26,10 @@ mindspore.ops.Conv3D

    **参数：**

-    - **out_channel** (int) - 输出的空间维度数量 :math:`C_{out}` 。
+    - **out_channel** (int) - 输出的通道数 :math:`C_{out}` 。
    - **kernel_size** (Union[int, tuple[int]]) - 指定三维卷积核的深度、高度和宽度。数据类型为int或包含三个整数的Tuple。一个整数表示卷积核的深度、高度和宽度均为该值。包含三个整数的Tuple分别表示卷积核的深度、高度和宽度。
    - **mode** (int) - 指定不同的卷积模式。此值目前未被使用。默认值: 1。
-    - **stride** (Union[int, tuple[int]]) - 数据类型为int或由三个int值所组成的Tuple。当 `stride` 为int时表示在深度、高度和宽度方向的移动步长均为该值。当 `stride` 为三个int值所组成的Tuple时，三个int值分别表示在深度、高度和宽度方向的移动步长。默认值：1。
+    - **stride** (Union[int, tuple[int]]) - 当 `stride` 为int时表示在深度、高度和宽度方向的移动步长均为该值。当 `stride` 为三个int值所组成的Tuple时，三个int值分别表示在深度、高度和宽度方向的移动步长。默认值：1。
    - **pad_mode** (str) - 指定填充模式。可选值为"same"、"valid"、"pad"。默认值："valid"。

      - same: 输出的深度、高度和宽度分别与对应输入整除 `stride` 后的值相同。
@ -38,7 +38,7 @@ mindspore.ops.Conv3D

      - valid: 在不填充的前提下返回有效计算所得的输出。不满足计算的多余像素会被丢弃。如果设置此模式，则 `pad` 的值必须为0。

-      - pad: 在输入深度、高度和宽度各维度两侧进行自动填充。如果设置此模式， `pad` 的值必须大于或等于0。
+      - pad: 在输入深度、高度和宽度各维度两侧添加 `pad` 数量的填充。如果设置此模式， `pad` 的值必须大于或等于0。

    - **pad** (Union(int, tuple[int])) - 在输入各维度两侧的填充长度。如果 `pad` 是一个整数，则前部、后部、顶部，底部，左边和右边的填充都等于 `pad` 。如果 `pad` 是6个整数的Tuple，则前部、后部、顶部、底部、左边和右边的填充分别等于填充 `pad[0]` 、 `pad[1]` 、 `pad[2]` 、 `pad[3]` 、 `pad[4]` 和 `pad[5]` 。默认值：0。
    - **dilation** (Union[int, tuple[int]]) - 三维卷积核膨胀尺寸。数据类型为int或三个整数的Tuple :math:`(dilation_d, dilation_h, dilation_w)` 。目前在深度维度仅支持取值为1。若 :math:`k > 1` ，则kernel间隔 `k` 个元素取样。取值大于等于1且小于对应的高度或宽度大小。默认值: 1。
--- a/docs/api/api_python/ops/mindspore.ops.Conv3DTranspose.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Conv3DTranspose.rst
@ -21,19 +21,19 @@ mindspore.ops.Conv3DTranspose

    **参数：**

-    - **in_channel** (int) - 输入 `dout` 的空间维度。
-    - **out_channel** (int) - 输入 `weight` 的空间维度。
+    - **in_channel** (int) - 输入 `dout` 的通道数。
+    - **out_channel** (int) - 输入 `weight` 的通道数。
    - **kernel_size** (Union[int, tuple[int]]) - 指定三维卷积核的深度、高度和宽度。数据类型为int或包含三个int值的Tuple。为int时表示卷积核的深度、高度和宽度均为该值。包含三个int值的Tuple分别表示卷积核的深度、高度和宽度。
    - **mode** (int) - 指定不同的卷积模式。此值目前未被使用。默认值： 1。
    - **pad_mode** (str) - 指定填充模式。可选值为"same"、"valid"、"pad"。默认值: "valid"。

      - same: 填充输入。输出的深度、高度和宽度分别与对应输入整除 `stride` 后的值相同。
-        同一维度的padding将被尽可能均匀填充在两侧，额外的padding将被填充在尾侧。
+        同一维度的padding将被尽可能均匀填充在两侧，额外的padding将被填充在维度末端。
        若设置该模式，`pad` 的值必须为0。

      - valid: 在不填充的前提下返回有效计算所得的输出。不满足计算的多余像素会被丢弃。如果设置此模式，则 `pad` 的值必须为0。

-      - pad: 在输入深度、高度和宽度各维度两侧进行自动填充。如果设置此模式， `pad` 的值必须大于或等于0。
+      - pad: 在输入深度、高度和宽度各维度两侧添加 `pad` 数量的填充。如果设置此模式， `pad` 的值必须大于或等于0。
      
    - **pad** (Union(int, tuple[int])) - 在输入各维度两侧填充的数量。如果 `pad` 是一个整数，则前部、后部、顶部，底部，左边和右边的填充都等于 `pad` 。如果 `pad` 是6个整数的Tuple，则前部、后部、顶部、底部、左边和右边的填充分别等于填充 `pad[0]` 、 `pad[1]` 、 `pad[2]` 、 `pad[3]` 、 `pad[4]` 和 `pad[5]` 。默认值：0。
    - **stride** (Union(int, tuple[int])) - 三维卷积核的移动步长。数据类型为整型或三个整型的Tuple。一个整数表示在深度、高度和宽度方向的移动步长均为该值。三个整数的Tuple分别表示在深度、高度和宽度方向的移动步长。默认值：1。
@ -63,4 +63,4 @@ mindspore.ops.Conv3DTranspose
    - **ValueError** - `pad_mode` 未设定为"pad"且 `pad` 不等于(0, 0, 0, 0, 0, 0)。
    - **ValueError** - `data_format` 取值非"NCDHW"。
    - **TypeError** - `dout` 或 `weight` 的数据类型不是float16。
-    - **ValueError** - `bias` 不为None。 `dout` 或 `weight` 的轶不为5。
+    - **ValueError** - `bias` 不为None。 `dout` 或 `weight` 的秩不为5。
--- a/docs/api/api_python/ops/mindspore.ops.CumProd.rst
+++ b/docs/api/api_python/ops/mindspore.ops.CumProd.rst
@ -17,7 +17,7 @@ mindspore.ops.CumProd

    **输入：**

-    - **x** (Tensor[Number]) - 输入Tensor，shape: :math:`(N,*)` ，其中 :math:`*` 表示任何数量的附加维度。其轶应小于8。
+    - **x** (Tensor[Number]) - 输入Tensor，shape: :math:`(N,*)` ，其中 :math:`*` 表示任何数量的附加维度。其秩应小于8。
    - **axis** (int) - 沿此方向计算累计积。仅支持常量值。

    **输出：**
--- a/docs/api/api_python/ops/mindspore.ops.DynamicGRUV2.rst
+++ b/docs/api/api_python/ops/mindspore.ops.DynamicGRUV2.rst
@ -22,12 +22,12 @@ mindspore.ops.DynamicGRUV2
    
    - **direction** (str) - 指定GRU方向，str类型。默认值："UNIDIRECTIONAL"。目前仅支持"UNIDIRECTIONAL"。
    - **cell_depth** (int) - GRU单元深度。默认值：1。
-    - **keep_prob** (float) - keep rate。默认值：1.0。
+    - **keep_prob** (float) - Dropout保留概率。默认值：1.0。
    - **cell_clip** (float) - 输出裁剪率。默认值：-1.0。
    - **num_proj** (int) - 投影维度。默认值：0。
    - **time_major** (bool) - 如为True，则指定输入的第一维度为序列长度 `num_step` ，如为False则第一维度为 `batch_size` 。默认值：True。
    - **activation** (str) - 字符串，指定activation类型。默认值："tanh"。目前仅支持取值"tanh"。
-    - **gate_order** (str) - 字符串，指定weight和bias中门的排列顺序，可选则为"rzh"或"zrh"。默认值："rzh"。"rzh"代表顺序为：重置门、更新门、隐藏门。"zrh"代表顺序为：更新门，重置门，隐藏门。
+    - **gate_order** (str) - 字符串，指定weight和bias中门的排列顺序，可选值为"rzh"或"zrh"。默认值："rzh"。"rzh"代表顺序为：重置门、更新门、隐藏门。"zrh"代表顺序为：更新门，重置门，隐藏门。
    - **reset_after** (bool) - 是否在矩阵乘法后使用重置门。默认值：True。
    - **is_training** (bool) - 是否为训练模式。默认值：True。

@ -41,7 +41,7 @@ mindspore.ops.DynamicGRUV2
      shape： :math:`(\text{hidden_size}, 3 \times \text{hidden_size})` 。
      数据类型支持float16。
    - **bias_input** (Tensor) - 偏差 :math:`b_{\{ir,iz,in\}}` 。shape： :math:`(3 \times \text{hidden_size})` ，或 `None` 。与输入 `init_h` 的数据类型相同。
-    - **bias_hidden** (Tensor) - 偏差 :math:`b_{\{hr,hz,hn\}}` 。Tensor of shape :math:`(3 \times \text{hidden_size})` ，或 `None` 。与输入 `init_h` 的数据类型相同。
+    - **bias_hidden** (Tensor) - 偏差 :math:`b_{\{hr,hz,hn\}}` 。shape： :math:`(3 \times \text{hidden_size})` ，或 `None` 。与输入 `init_h` 的数据类型相同。
    - **seq_length** (Tensor) - 每个batch中序列的长度。shape： :math:`(\text{batch_size})` 。
      目前仅支持 `None` 。
    - **init_h** (Tensor) - 初始隐藏状态。shape： :math:`(\text{batch_size}, \text{hidden_size})` 。
@ -54,24 +54,25 @@ mindspore.ops.DynamicGRUV2
      - :math:`(num\_step, batch\_size, min(hidden\_size, num\_proj))` ，如果 `num_proj` 大于0,
      - :math:`(num\_step, batch\_size, hidden\_size)` ，如果 `num_proj` 等于0。
          
-      数据类型为 `bias_type` 。
-    - **output_h** (Tensor) - Tensor，shape： :math:`(\text{num_step}, \text{batch_size}, \text{hidden_size})` 。数据类型为 `bias_type` 。
-    - **update** (Tensor) - Tensor，shape： :math:`(\text{num_step}, \text{batch_size}, \text{hidden_size})` 。数据类型为 `bias_type` 。
-    - **reset** (Tensor) - Tensor，shape： :math:`(\text{num_step}, \text{batch_size}, \text{hidden_size})` 。数据类型为 `bias_type` 。
-    - **new** (Tensor) - Tensor，shape： :math:`(\text{num_step}, \text{batch_size}, \text{hidden_size})` 。数据类型为 `bias_type` 。
-    - **hidden_new** (Tensor) - Tensor，shape： :math:`(\text{num_step}, \text{batch_size}, \text{hidden_size})` 。数据类型为 `bias_type` 。
+      与 `bias_type` 数据类型相同。
+
+    - **output_h** (Tensor) - Tensor，shape： :math:`(\text{num_step}, \text{batch_size}, \text{hidden_size})` 。与 `bias_type` 数据类型相同。
+    - **update** (Tensor) - Tensor，shape： :math:`(\text{num_step}, \text{batch_size}, \text{hidden_size})` 。与 `bias_type` 数据类型相同。
+    - **reset** (Tensor) - Tensor，shape： :math:`(\text{num_step}, \text{batch_size}, \text{hidden_size})` 。与 `bias_type` 数据类型相同。
+    - **new** (Tensor) - Tensor，shape： :math:`(\text{num_step}, \text{batch_size}, \text{hidden_size})` 。与 `bias_type` 数据类型相同。
+    - **hidden_new** (Tensor) - Tensor，shape： :math:`(\text{num_step}, \text{batch_size}, \text{hidden_size})` 。与 `bias_type` 数据类型相同。

      关于 `bias_type` :

      - 如果 `bias_input` 和 `bias_hidden` 均为 `None` ，则 `bias_type` 为 `init_h` 的数据类型。
-      - 如果 `bias_input` 不为 `None` ，则 `bias_input` 为 `bias_type` 的数据类型。
+      - 如果 `bias_input` 不为 `None` ，则 `bias_type` 为 `bias_input` 的数据类型。
      - 如果 `bias_input` 为 `None` 而 `bias_hidden` 不为 `None` ，则 `bias_type` 为 `bias_hidden` 的数据类型。

    **异常：**

    - **TypeError** - `direction` 、 `activation` 或 `gate_order` 不是str。
    - **TypeError** - `cell_depth` 或 `num_proj` 不是int类型。
-    - **TypeError** - `keep_prob` 或 `cell_clip` float类型。
+    - **TypeError** - `keep_prob` 或 `cell_clip` 不是float类型。
    - **TypeError** - `time_major` 、 `reset_after` 或 `is_training` 不是bool类型。
    - **TypeError** - `x` 、 `weight_input` 、 `weight_hidden` 、 `bias_input` 、 `bias_hidden` 、 `seq_length` 或 `ini_h` 不是Tensor。
    - **TypeError** - `x` 、 `weight_input` 或 `weight_hidden` 的数据类型非float16。
--- a/docs/api/api_python/ops/mindspore.ops.DynamicRNN.rst
+++ b/docs/api/api_python/ops/mindspore.ops.DynamicRNN.rst
@ -3,7 +3,7 @@ mindspore.ops.DynamicRNN

 .. py:class:: mindspore.ops.DynamicRNN(cell_type='LSTM', direction='UNIDIRECTIONAL', cell_depth=1, use_peephole=False, keep_prob=1.0, cell_clip=-1.0, num_proj=0, time_major=True, activation='tanh', forget_bias=0.0, is_training=True)

-    将循环神经网络应用到输入上。当前仅支持长短期记忆。
+    将循环神经网络应用到输入上。当前仅支持LSTM。

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

    - **x** (Parameter) - 要添加到的输入参数。
    - **indices** (Tensor) - 沿 `axis` 在指定 `indices` 位置进行加法运算。数据类型支持int32。`indices` 必须为一维且与 `y` 在 `axis` 维度的尺寸相同。 `indices` 取值范围应为[0, b)， 其中b为 `x` 在 `axis` 维度的尺寸。
-    - **y** (Tensor) - 被添加的 `x` 的输入Tensor。必须与 `x` 的数据类型相同。除 `axis` 之外的维度shape必须与 `x` 的shape相同。
+    - **y** (Tensor) - 被添加到 `x` 的输入Tensor。必须与 `x` 的数据类型相同。除 `axis` 之外的维度shape必须与 `x` 的shape相同。

    **输出：**

@ -25,7 +25,7 @@ mindspore.ops.IndexAdd

    - **TypeError** - `x` 不是Parameter。
    - **TypeError** - `indices` 或 `y` 不是Tensor。
-    - **ValueError** - axis 超过了 `x` 的轶。
-    - **ValueError** - `x` 与 `y` 的轶不相同。
+    - **ValueError** - axis 超过了 `x` 的秩。
+    - **ValueError** - `x` 与 `y` 的秩不相同。
    - **ValueError** - `indices` 不是一维或与 `y[axis]` 的尺寸不同。
    - **ValueError** - `y` 的shape与除 `axis` 之外的维度的 `x` 的shape不同。
--- a/docs/api/api_python/ops/mindspore.ops.InplaceUpdate.rst
+++ b/docs/api/api_python/ops/mindspore.ops.InplaceUpdate.rst
@ -7,7 +7,7 @@ mindspore.ops.InplaceUpdate

    **参数：**

-    - **indices** (Union[int, tuple]) - 指定将 `x` 的哪些行更新为  `v` 。可以为int或Tuple，取值范围[0, len(`x`)]。
+    - **indices** (Union[int, tuple]) - 指定将 `x` 的哪些行更新为  `v` 。可以为int或Tuple，取值范围[0, len(`x`))。

    **输入：**

--- a/docs/api/api_python/ops/mindspore.ops.KLDivLoss.rst
+++ b/docs/api/api_python/ops/mindspore.ops.KLDivLoss.rst
@ -10,7 +10,7 @@ mindspore.ops.KLDivLoss
    .. math::
        L(x, target) = target \cdot (\log target - x)

-    可得
+    输出

    .. math::
        \ell(x, target) = \begin{cases}
--- a/docs/api/api_python/ops/mindspore.ops.Less.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Less.rst
@ -3,6 +3,6 @@

 .. py:class:: mindspore.ops.Less

-    计算 :math:`x < y` ，返回为bool。
+    逐元素计算 :math:`x < y` ，返回为bool。

    详情请查看 :func:`mindspore.ops.less` 。
--- a/docs/api/api_python/ops/mindspore.ops.Log1p.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Log1p.rst
@ -12,7 +12,7 @@ mindspore.ops.Log1p

    - **x** (Tensor) - 输入Tensor。数据类型为float16或float32。
      该值必须大于-1。
-      shape： :math:`(N,*)` 其中 :math:`*` 表示任何数量的附加维度，其轶应小于8。
+      shape： :math:`(N,*)` 其中 :math:`*` 表示任何数量的附加维度，其秩应小于8。

    **输出：**

--- a/docs/api/api_python/ops/mindspore.ops.Mish.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Mish.rst
@ -10,7 +10,7 @@
    .. math::
        \text{output} = x * \tan(\log(1 + \exp(\text{x})))

-    更多详细信息请参见 `自正则化非单调神经激活函数 <https://arxiv.org/abs/1908.08681>`_ 。
+    更多详细信息请参见 `A Self Regularized Non-Monotonic Neural Activation Function <https://arxiv.org/abs/1908.08681>`_ 。

    **输入：**

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

 .. py:class:: mindspore.ops.Mod

-    将第一个输入Tensor除以第二个输入Tensor，并取余。
+    将第一个输入Tensor逐元素除以第二个输入Tensor，并取余。

    `x` 和 `y` 的输入遵循隐式类型转换规则，使数据类型一致。输入必须是两个Tensor或一个Tensor和一个Scalar。当输入是两个Tensor时，两个数据类型都不能是bool，它们的shape可以广播。当输入是一个Tensor和一个Scalar时，Scalar只能是一个常量。

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

 .. py:class:: mindspore.ops.MulNoNan

-    根据矩阵乘法计算输入 `x` 和 `y` 。如果 `y` 为零，无论 `x` 取何值，它都将返回0。
+    逐元素计算输入乘积。如果 `y` 为零，无论 `x` 取何值，它都将返回0。

    `x` 和 `y` 的输入遵循隐式类型转换规则，使数据类型一致。输入必须是两个Tensor或一个Tensor和一个Scalar。当输入是两个Tensor时，它们的shape可以被广播。当输入是一个Tensor和一个Scalar时，Scalar只能是一个常量。

--- a/docs/api/api_python/ops/mindspore.ops.ReduceAll.rst
+++ b/docs/api/api_python/ops/mindspore.ops.ReduceAll.rst
@ -12,7 +12,7 @@
    **输入：**

    - **x** (Tensor[bool]) - bool类型的输入Tensor。
-      shape: :math:`(N,*)` ，其中 :math:`*` 表示任意数量的附加维度，其轶应小于8。
+      shape: :math:`(N,*)` ，其中 :math:`*` 表示任意数量的附加维度，其秩应小于8。
    - **axis** (Union[int, tuple(int), list(int)]) - 要减少的维度。默认值: ()，缩小所有维度。只允许常量值。取值必须在[-rank(`x`), rank(`x`))范围内。

    **输出：**
--- a/docs/api/api_python/ops/mindspore.ops.ReduceMin.rst
+++ b/docs/api/api_python/ops/mindspore.ops.ReduceMin.rst
@ -11,13 +11,13 @@

    **输入：**

-    - **x** (Tensor[Number]) - bool类型的输入Tensor。
-      shape: :math:`(N,*)` ，其中 :math:`*` 表示任意数量的附加维度，其轶应小于8。
+    - **x** (Tensor[Number]) - 输入Tensor。
+      shape: :math:`(N,*)` ，其中 :math:`*` 表示任意数量的附加维度，其秩应小于8。
    - **axis** (Union[int, tuple(int), list(int)]) - 要减少的维度。默认值: ()，缩小所有维度。只允许常量值。取值必须在[-rank( `x` ), rank( `x` ))范围内。

    **输出：**

-    bool类型的Tensor。
+    Tensor。

    - 如果 `axis` 为()，且 `keep_dims` 为False，
      则输出一个0维Tensor，表示输入Tensor中所有元素的最小值。
--- a/docs/api/api_python/ops/mindspore.ops.ReduceProd.rst
+++ b/docs/api/api_python/ops/mindspore.ops.ReduceProd.rst
@ -12,7 +12,7 @@
    **输入：**

    - **x** (Tensor[number]) - bool类型的输入Tensor。
-      shape: :math:`(N,*)` ，其中 :math:`*` 表示任意数量的附加维度，其轶应小于8。
+      shape: :math:`(N,*)` ，其中 :math:`*` 表示任意数量的附加维度，其秩应小于8。
    - **axis** (Union[int, tuple(int), list(int)]) - 要减少的维度。默认值: ()，缩小所有维度。只允许常量值。取值必须在[-rank( `x` ), rank( `x` ))范围内。

    **输出：**
--- a/docs/api/api_python/ops/mindspore.ops.SpaceToDepth.rst
+++ b/docs/api/api_python/ops/mindspore.ops.SpaceToDepth.rst
@ -23,7 +23,7 @@ mindspore.ops.SpaceToDepth

    **输出：**

-    4维Tensor，数据类型与 `x` 相同。
+    4维Tensor，数据类型与 `x` 相同，shape： :math:`(N,(C_{in} * \text{block_size} * 2), H_{in} / \text{block_size}, W_{in} / \text{block_size}` 。

    **异常：**

--- a/docs/api/api_python/ops/mindspore.ops.TBERegOp.rst
+++ b/docs/api/api_python/ops/mindspore.ops.TBERegOp.rst
@ -76,6 +76,14 @@
        - **value_depend** (str) - 表示输入是否为常量值。默认值：None。
        - **kwargs** (dict) - 表示输入的其他信息。

+    .. py:method:: input_to_attr_index(input_to_attr_index)
+
+        需要转换为属性的输入的索引。
+
+        **参数：**
+
+        - **input_to_attr_index** (int) - 索引。默认值：()。
+
    .. py:method:: is_dynamic_format(is_dynamic_format=False)

        表示算子是否需要op_select_format函数来动态选择合适的数据格式和数据类型。
@ -129,6 +137,14 @@

        - **partial_flag** (bool) - 表示是否支持部分计算。默认值：True。

+    .. py:method:: real_input_index(real_input_index)
+
+        算子前端输入到后端TBE算子输入的映射。
+
+        **参数：**
+
+        - **real_input_index** (list) - 真实输入的索引。默认值：()。
+
    .. py:method:: reshape_type(reshape_type)

        指定算子的补维方式。