amend ops

2021-12-22 11:46:09 +08:00 · 2021-12-22 11:46:09 +08:00 · 3c9aa15c15
parent 35ffa628eb
commit 3c9aa15c15
24 changed files with 157 additions and 138 deletions
--- a/docs/api/api_python/ops/mindspore.ops.Add.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Add.rst
@ -1,31 +1,32 @@
 mindspore.ops.Add
 =================

-.. py:class:: mindspore.ops.Add(*args, **kwargs)
+.. py:class:: mindspore.ops.Add()

-    两个输入Tensor按元素相加。
-
-    输入 `x` 和 `y` 遵循隐式类型转换规则，使数据类型保持一致。
-    输入必须是两个Tensor，或一个Tensor和一个Scalar。
-    当输入是两个Tensor时，它们的数据类型不能同时是bool，它们的shape可以广播。
-    当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
+    两个输入Tensor逐元素相加。

    .. math::

        out_{i} = x_{i} + y_{i}

+    .. note::
+        - 输入 `x` 和 `y` 遵循 `隐式类型转换规则 <https://www.mindspore.cn/docs/note/zh-CN/master/operator_list_implicit.html>`_ ，使数据类型保持一致。
+        - 输入必须是两个Tensor，或一个Tensor和一个Scalar。
+        - 当输入是两个Tensor时，它们的数据类型不能同时是bool，并保证其shape可以广播。
+        - 当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
+
    **输入：**

-    - **x** (Union[Tensor, Number, bool]) - 第一个输入，是一个Number、bool值或数据类型为Number或bool的Tensor。
-    - **y** (Union[Tensor, Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个Number或bool值，或数据类型为Number或bool的Tensor。
+    - **x** (Union[Tensor, number.Number, bool]) - 第一个输入，是一个number.Number、bool值或数据类型为 `number <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 或 `bool_ <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 的Tensor。
+    - **y** (Union[Tensor, number.Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个number.Number或bool值，或数据类型为number或bool_的Tensor。当第一个输入是Scalar时，第二个输入必须是数据类型为number或bool_的Tensor。

    **输出：**

-    Tensor，shape与广播后的shape相同，数据类型为两个输入中精度较高的类型。
+    Tensor，shape与输入 `x`，`y` 广播后的shape相同，数据类型为两个输入中精度较高的类型。

    **异常：**

-    - **TypeError** - `x` 和 `y` 不是Tensor、Number或bool。
+    - **TypeError** - `x` 和 `y` 不是Tensor、number.Number或bool。

    **支持平台：**

--- a/docs/api/api_python/ops/mindspore.ops.AddN.rst
+++ b/docs/api/api_python/ops/mindspore.ops.AddN.rst
@ -1,15 +1,15 @@
 mindspore.ops.AddN
 ===================

-.. py:class:: mindspore.ops.AddN(*args, **kwargs)
+.. py:class:: mindspore.ops.AddN()

-    按元素将所有输入的Tensor相加。
+    逐元素将所有输入的Tensor相加。

    所有输入Tensor必须具有相同的shape。

    **输入：**

-    - **x** (Union(tuple[Tensor], list[Tensor])) - 输入tuple或list由多个Tensor组成，其数据类型为Number或bool，用于相加。
+    - **x** (Union(tuple[Tensor], list[Tensor])) - Tensor组成的tuble或list，类型为 `bool_ <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 或 `number <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 。

    **输出：**

@ -18,6 +18,7 @@ mindspore.ops.AddN
    **异常：**

    - **TypeError** - `x` 既不是tuple，也不是list。
+    - **ValueError** - `x` 中存在shape不同的Tensor。

    **支持平台：**

--- a/docs/api/api_python/ops/mindspore.ops.Div.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Div.rst
@ -1,28 +1,33 @@
 mindspore.ops.Div
 =================

-.. py:class:: mindspore.ops.Div(*args, **kwargs)
+.. py:class:: mindspore.ops.Div()

-    按元素计算第一输入Tensor除以第二输入Tensor的商。
-
-    输入 `x` 和 `y` 遵循隐式类型转换规则，使数据类型保持一致。输入必须是两个Tensor，或一个Tensor和一个Scalar。当输入是两个Tensor时，它们的数据类型不能同时是bool，它们的shape可以广播。当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
+    逐元素计算第一输入Tensor除以第二输入Tensor的商。

    .. math::

        out_{i} = \frac{x_i}{y_i}

+    .. note::
+        - 输入 `x` 和 `y` 遵循 `隐式类型转换规则 <https://www.mindspore.cn/docs/note/zh-CN/master/operator_list_implicit.html>`_ ，使数据类型保持一致。
+        - 输入必须是两个Tensor，或一个Tensor和一个Scalar。
+        - 当输入是两个Tensor时，它们的数据类型不能同时是bool，并保证其shape可以广播。
+        - 当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
+
    **输入：**

-    - **x** (Union[Tensor, Number, bool]) - 第一个输入，是一个Number、bool值或数据类型为Number或bool的Tensor。
-    - **y** (Union[Tensor, Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个Number或bool值，或数据类型为Number或bool的Tensor。
+    - **x** (Union[Tensor, number.Number, bool]) - 第一个输入，是一个number.Number、bool值或数据类型为 `number <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 或 `bool_ <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 的Tensor。
+    - **y** (Union[Tensor, number.Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个number.Number或bool值，或数据类型为number或bool_的Tensor。当第一个输入是Scalar时，第二个输入必须是数据类型为number或bool_的Tensor。

    **输出：**

-    Tensor，shape与广播后的shape相同，数据类型为两个输入中精度较高的类型。
+    Tensor，shape与输入 `x`，`y` 广播后的shape相同，数据类型为两个输入中精度较高的类型。

    **异常：**

    - **TypeError** - `x` 和 `y` 都不是Tensor。
+    - **TypeError** - `x` 和 `y` 数据类型都是bool_的Tensor。

    **支持平台：**

@ -38,8 +43,8 @@ mindspore.ops.Div
    >>> print(output)
    [-1.3333334  2.5        2.        ]
    >>> # 用例2：两个输入的数据类型和shape不同
-    >>> x = Tensor(np.array([-4.0, 5.0, 6.0]), mindspore.int32)
-    >>> y = Tensor(2, mindspore.float32)
+    >>> x = Tensor(np.array([-4.0, 5.0, 6.0]), mindspore.float32)
+    >>> y = Tensor(2, mindspore.int32)
    >>> output = div(x, y)
    >>> print(output)
    [-2.  2.5  3.]
--- a/docs/api/api_python/ops/mindspore.ops.Eps.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Eps.rst
@ -1,18 +1,23 @@
 mindspore.ops.Eps
 =================

-.. py:class:: mindspore.ops.Eps(*args, **kwargs)
+.. py:class:: mindspore.ops.Eps()

-    创建一个填充 `x` 数据类型最小值的Tensor。
+    创建一个与输入数据类型和shape都相同的Tensor，元素值为对应数据类型能表达的最小值。

    **输入：**

-    - **x** (Tensor) - 用于获取其数据类型最小值的Tensor。数据类型必须为float16或float32。shape为 :math:`(N,*)` ，其中 :math:`*` 表示任意的附加维度数。
+    - **x** (Tensor) - 用于获取其数据类型能表达的最小值的任意维度的Tensor。数据类型必须为float16或float32。

    **输出：**

    Tensor，具有与 `x` 相同的数据类型和shape，填充了 `x` 数据类型的最小值。

+    **异常：**
+
+    - **TypeError** - `x` 不是Tensor。
+    - **TypeError** - `x` 的数据类型不是float16或者float32。
+
    **支持平台：**

    ``Ascend`` ``GPU`` ``CPU``
--- a/docs/api/api_python/ops/mindspore.ops.Erf.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Erf.rst
@ -1,9 +1,9 @@
 mindspore.ops.Erf
 =================

-.. py:class:: mindspore.ops.Erf(*args, **kwargs)
+.. py:class:: mindspore.ops.Erf()

-    按元素计算 `x` 的高斯误差函数。
+    逐元素计算 `x` 的高斯误差函数。

    .. math::

@ -11,7 +11,7 @@ mindspore.ops.Erf

    **输入：**

-    - **x** (Tensor) - 用于计算高斯误差函数的Tensor。数据类型必须为float16或float32。shape为 :math:`(N,*)` ，其中 :math:`*` 表示任意的附加维度数，其秩应小于8。
+    - **x** (Tensor) - 高斯误差函数的输入Tensor。数据类型必须为float16或float32。任意维度小于8的Tensor。

    **输出：**

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

 .. py:class:: mindspore.ops.Gamma(seed=0, seed2=0)

-    根据概率密度函数分布生成随机正浮点数x。
+    根据概率密度函数分布生成随机正值浮点数x。

    .. math::

@ -14,6 +14,13 @@ mindspore.ops.Gamma
    - **seed** (int) - 算子层的随机种子，用于生成随机数。必须是非负的。默认值：0。
    - **seed2** (int)：全局的随机种子，和算子层的随机种子共同决定最终生成的随机数。必须是非负的。默认值：0。

+    .. note::
+        - 随机种子：通过一些复杂的数学算法，可以得到一组有规律的随机数，而随机种子就是这个随机数的初始值。随机种子相同，得到的随机数就不会改变。
+        - 全局的随机种子和算子层的随机种子都没设置：使用默认值当做随机种子。
+        - 全局的随机种子设置了，算子层的随机种子未设置：随机生成一个种子和全局的随机种子拼接。
+        - 全局的随机种子未设置，算子层的随机种子设置了：使用默认的全局的随机种子，和算子层的随机种子拼接。
+        - 全局的随机种子和算子层的随机种子都设置了：全局的随机种子和算子层的随机种子拼接。
+
    **输入：**

    - **shape** (tuple) - 待生成的随机Tensor的shape。只支持常量值。
@ -22,12 +29,13 @@ mindspore.ops.Gamma

    **输出：**

-    Tensor。shape是输入 `shape` 以及alpha、beta广播后的shape。数据类型为float32。
+    Tensor。shape是输入 `shape`， `alpha`， `beta` 广播后的shape。数据类型为float32。

    **异常：**

-    - **TypeError** - `seed` 和 `seed2` 都不是int。
-    - **TypeError** - `alpha` 和 `beta` 都不是Tensor。
+    - **TypeError** - `seed` 或 `seed2` 的数据类型不是int。
+    - **TypeError** - `alpha` 或 `beta` 不是Tensor。
+    - **TypeError** - `alpha` 或 `beta` 的数据类型不是float32。
    - **ValueError** - `shape` 不是常量值。

    **支持平台：**
--- a/docs/api/api_python/ops/mindspore.ops.GeLU.rst
+++ b/docs/api/api_python/ops/mindspore.ops.GeLU.rst
@ -1,7 +1,7 @@
 mindspore.ops.GeLU
 ==================

-.. py:class:: mindspore.ops.GeLU(*args, **kwargs)
+.. py:class:: mindspore.ops.GeLU()

    高斯误差线性单元激活函数（Gaussian Error Linear Units activation function）。

@ -11,13 +11,13 @@ mindspore.ops.GeLU
    GeLU函数定义如下：

    .. math::
-        \text{output} = 0.5 * x * (1 + tanh(x / \sqrt{2})),
+        GELU(x_i) = x_i*P(X < x_i)

-    其中 :math:`tanh` 是双曲正切函数。
+    其中  :math:`P` 是标准高斯分布的累积分布函数， :math:`x_i` 是输入的元素。

    **输入：**

-    - **x** (Tensor) - 用于计算GeLU函数的Tensor，数据类型为float16或float32。
+    - **x** (Tensor) - 激活函数GeLU的输入，数据类型为float16或float32。

    **输出：**

--- a/docs/api/api_python/ops/mindspore.ops.L2Loss.rst
+++ b/docs/api/api_python/ops/mindspore.ops.L2Loss.rst
@ -1,14 +1,14 @@
 mindspore.ops.L2Loss
 ====================

-.. py:class:: mindspore.ops.L2Loss(*args, **kwargs)
+.. py:class:: mindspore.ops.L2Loss()

-    计算Tensor的L2范数的一半，不对结果进行开方。
+    用于计算L2范数，但不对结果进行开方操作。

-    把 `input_x` 设为x，输出设为loss。
+    把输入设为x，输出设为loss。

    .. math::
-        loss = sum(x ** 2) / 2
+        loss = \frac{\sum x ^ 2}{2}

    **输入：**

@ -16,7 +16,7 @@ mindspore.ops.L2Loss

    **输出：**

-    Tensor，具有与 `input_x` 相同的数据类型。输出Tensor是loss的值，是一个scalar Tensor。
+    Tensor，具有与 `input_x` 相同的数据类型的Scalar Tensor。

    **异常：**

--- a/docs/api/api_python/ops/mindspore.ops.LessEqual.rst
+++ b/docs/api/api_python/ops/mindspore.ops.LessEqual.rst
@ -1,14 +1,9 @@
 mindspore.ops.LessEqual
 ========================

-.. py:class:: mindspore.ops.LessEqual(*args, **kwargs)
+.. py:class:: mindspore.ops.LessEqual()

-    按元素计算 :math:`x <= y` 的bool值。
-
-    输入 `x` 和 `y` 遵循隐式类型转换规则，使数据类型保持一致。
-    输入必须是两个Tensor，或一个Tensor和一个Scalar。
-    当输入是两个Tensor时，它们的数据类型不能同时是bool，它们的shape可以广播。
-    当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
+    逐元素计算 :math:`x <= y` 的bool值。

    .. math::

@ -17,10 +12,16 @@ mindspore.ops.LessEqual
            & \text{False,   if } x_{i}>y_{i}
            \end{cases}

+    .. note::
+        - 输入 `x` 和 `y` 遵循 `隐式类型转换规则 <https://www.mindspore.cn/docs/note/zh-CN/master/operator_list_implicit.html>`_ ，使数据类型保持一致。
+        - 输入必须是两个Tensor，或一个Tensor和一个Scalar。
+        - 当输入是两个Tensor时，它们的数据类型不能同时是bool，并保证其shape可以广播。
+        - 当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
+
    **输入：**

-    - **x** (Union[Tensor, Number, bool]) - 第一个输入，是一个Number、bool值或数据类型为Number或bool的Tensor。
-    - **y** (Union[Tensor, Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个Number或bool值，或数据类型为Number或bool的Tensor。
+    - **x** (Union[Tensor, number.Number, bool]) - 第一个输入，是一个number.Number、bool值或数据类型为 `number <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 或 `bool_ <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 的Tensor。
+    - **y** (Union[Tensor, number.Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个number.Number或bool值，或数据类型为number或bool_的Tensor。当第一个输入是Scalar时，第二个输入必须是数据类型为number或bool_的Tensor。

    **输出：**

--- a/docs/api/api_python/ops/mindspore.ops.Log.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Log.rst
@ -1,20 +1,23 @@
 mindspore.ops.Log
 =================

-.. py:class:: mindspore.ops.Log(*args, **kwargs)
+.. py:class:: mindspore.ops.Log()

-    按元素返回Tensor的自然对数。
+    逐元素返回Tensor的自然对数。

    .. math::
        y_i = log_e(x_i)

    .. warning::

-        如果算子Log的输入值在(0，0.01]或[0.95，1.05]范围内，则输出精度可能会发生变化。
+        如果算子Log的输入值在(0，0.01]或[0.95，1.05]范围内，则输出精度可能会存在误差。
+
+    .. note::
+        Ascend上输入Tensor的维度要小于等于8，CPU上输入Tensor的维度要小于8。

    **输入：**

-    - **x** (Tensor) - 输入Tensor。该值必须大于0。shape为 :math:`(N,*)`，其中 :math:`*` 表示任意的附加维度数，它的秩应小于8。
+    - **x** (Tensor) - 任意维度的输入Tensor。该值必须大于0。

    **输出：**

--- a/docs/api/api_python/ops/mindspore.ops.MatMul.rst
+++ b/docs/api/api_python/ops/mindspore.ops.MatMul.rst
@ -28,7 +28,7 @@ mindspore.ops.matmul
    **异常：**

    - **TypeError** - `transpose_a` 或 `transpose_b` 不是bool。
-    - **ValueError** - 矩阵 `a` 的维度的列不等于矩阵 `b` 的维度的行。
+    - **ValueError** - 矩阵 `a` 的列不等于矩阵 `b` 的行。
    - **ValueError** - `a` 或 `b` 的维度不等于2。

    **支持平台：**
--- a/docs/api/api_python/ops/mindspore.ops.Mul.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Mul.rst
@ -1,23 +1,24 @@
 mindspore.ops.Mul
 =================

-.. py:class:: mindspore.ops.Mul(*args, **kwargs)
+.. py:class:: mindspore.ops.Mul()

-    两个Tensor按元素相乘。
-
-    输入 `x` 和 `y` 遵循隐式类型转换规则，使数据类型保持一致。
-    输入必须是两个Tensor，或一个Tensor和一个Scalar。
-    当输入是两个Tensor时，它们的数据类型不能同时是bool，它们的shape可以广播。
-    当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
+    两个Tensor逐元素相乘。

    .. math::

        out_{i} = x_{i} * y_{i}

+    .. note::
+        - 输入 `x` 和 `y` 遵循 `隐式类型转换规则 <https://www.mindspore.cn/docs/note/zh-CN/master/operator_list_implicit.html>`_ ，使数据类型保持一致。
+        - 输入必须是两个Tensor，或一个Tensor和一个Scalar。
+        - 当输入是两个Tensor时，它们的数据类型不能同时是bool，并保证其shape可以广播。
+        - 当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
+
    **输入：**

-    - **x** (Union[Tensor, Number, bool]) - 第一个输入，是一个Number、bool值或数据类型为Number或bool的Tensor。
-    - **y** (Union[Tensor, Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个Number或bool值，或数据类型为Number或bool的Tensor。
+    - **x** (Union[Tensor, number.Number, bool]) - 第一个输入，是一个number.Number、bool值或数据类型为 `number <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 或 `bool_ <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 的Tensor。
+    - **y** (Union[Tensor, number.Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个number.Number或bool值，或数据类型为number或bool_的Tensor。当第一个输入是Scalar时，第二个输入必须是数据类型为number或bool_的Tensor。

    **输出：**

@ -25,7 +26,7 @@ mindspore.ops.Mul

    **异常：**

-    - **TypeError** - `x` 和 `y` 不是Tensor、Number或bool。
+    - **TypeError** - `x` 和 `y` 不是Tensor、number.Number或bool。
    - **ValueError** - `x` 和 `y` 的shape不相同。

    **支持平台：**
--- a/docs/api/api_python/ops/mindspore.ops.OnesLike.rst
+++ b/docs/api/api_python/ops/mindspore.ops.OnesLike.rst
@ -1,15 +1,13 @@
 mindspore.ops.OnesLike
 ======================

-.. py:class:: mindspore.ops.OnesLike(*args, **kwargs)
+.. py:class:: mindspore.ops.OnesLike()

-    创建新Tensor。所有元素的值都为1。
-
-    返回填充了Scalar值为1的具有与输入相同shape和数据类型的Tensor。
+    返回值为1的Tensor，shape和数据类型与输入相同。

    **输入：**

-    - **input_x** (Tensor) - 输入Tensor。shape为 :math:`(N,*)` ，其中 :math:`*` 表示任意的附加维度数。
+    - **input_x** (Tensor) - 任意维度的Tensor。

    **输出：**

--- a/docs/api/api_python/ops/mindspore.ops.PReLU.rst
+++ b/docs/api/api_python/ops/mindspore.ops.PReLU.rst
@ -1,7 +1,7 @@
 mindspore.ops.PReLU
 ===================

-.. py:class:: mindspore.ops.PReLU(*args, **kwargs)
+.. py:class:: mindspore.ops.PReLU()

    带参数的线性修正单元激活函数（Parametric Rectified Linear Unit activation function）。

@ -14,18 +14,18 @@ mindspore.ops.PReLU

    .. note::

-        Ascend不支持0-D或1-D的x。
+        Ascend不支持标量和1维向量的输入x。

    **输入：**

-    - **x** (Tensor) - 用于计算激活函数的Tensor。数据类型为float16或float32。shape为 :math:`(N, C, *)` ，其中 :math:`*` 表示任意的附加维度数。
-    - **weight** (Tensor) - 权重Tensor。数据类型为float16或float32。只有两种shape是合法的，1或 `input_x` 的通道数。通道维度是输入的第二维。当输入为0-D或1-D Tensor时，通道数为1。
+    - **x** (Tensor) - 激活函数的输入Tensor。数据类型为float16或float32。shape为 :math:`(N, C, *)` ，其中 :math:`*` 表示任意的附加维度。
+    - **weight** (Tensor) - 权重Tensor。数据类型为float16或float32。weight只可以是向量，长度与输入x的通道数C相同。在GPU设备上，当输入为标量时，shape为1。

    **输出：**

    Tensor，数据类型与 `x` 的相同。

-    有关详细信息，请参考:class:`nn.PReLU`。
+    有关详细信息，请参考 :class:`mindspore.nn.PReLU` 。

    **异常：**

--- a/docs/api/api_python/ops/mindspore.ops.Pow.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Pow.rst
@ -1,23 +1,24 @@
 mindspore.ops.Pow
 ==================

-.. py:class:: mindspore.ops.Pow(*args, **kwargs)
+.. py:class:: mindspore.ops.Pow()

-    计算 `x` 中每个元素的 `y` 的幂次。
-
-    输入 `x` 和 `y` 遵循隐式类型转换规则，使数据类型保持一致。
-    输入必须是两个Tensor，或一个Tensor和一个Scalar。
-    当输入是两个Tensor时，它们的数据类型不能同时是bool，它们的shape可以广播。
-    当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
+    计算 `x` 中每个元素的 `y` 次幂。

    .. math::

        out_{i} = x_{i} ^{ y_{i}}

+    .. note::
+        - 输入 `x` 和 `y` 遵循 `隐式类型转换规则 <https://www.mindspore.cn/docs/note/zh-CN/master/operator_list_implicit.html>`_ ，使数据类型保持一致。
+        - 输入必须是两个Tensor，或一个Tensor和一个Scalar。
+        - 当输入是两个Tensor时，它们的数据类型不能同时是bool，并保证其shape可以广播。
+        - 当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
+
    **输入：**

-    - **x** (Union[Tensor, Number, bool]) - 第一个输入，是一个Number、bool值或数据类型为Number或bool的Tensor。
-    - **y** (Union[Tensor, Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个Number或bool值，或数据类型为Number或bool的Tensor。
+    - **x** (Union[Tensor, number.Number, bool]) - 第一个输入，是一个number.Number、bool值或数据类型为 `number <https://www.mindspore.cn/docs/api/en/master/api_python/mindspore.html#mindspore.dtype>`_ 或 `bool_ <https://www.mindspore.cn/docs/api/en/master/api_python/mindspore.html#mindspore.dtype>`_ 的Tensor。
+    - **y** (Union[Tensor, number.Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个number.Number或bool值，或数据类型为number或bool_的Tensor。当第一个输入是Scalar时，第二个输入必须是数据类型为number或bool_的Tensor。

    **输出：**
    
@ -25,8 +26,8 @@ mindspore.ops.Pow

    **异常：**

-    - **TypeError** - `x` 和 `y` 不是Tensor、Number或bool。
-    - **ValueError** - `x` 和 `y` 的shape不相同。
+    - **TypeError** - `x` 和 `y` 不是Tensor、number.Number或bool。
+    - **ValueError** - 当`x` 和 `y` 都为Tensor时，它们的shape不相同。

    **支持平台：**

--- a/docs/api/api_python/ops/mindspore.ops.ReLUV2.rst
+++ b/docs/api/api_python/ops/mindspore.ops.ReLUV2.rst
@ -1,7 +1,7 @@
 mindspore.ops.ReLUV2
 ====================

-.. py:class:: mindspore.ops.ReLUV2(*args, **kwargs)
+.. py:class:: mindspore.ops.ReLUV2()

    线性修正单元激活函数（Rectified Linear Unit activation function）。

@ -11,10 +11,6 @@ mindspore.ops.ReLUV2

        \text{ReLU}(x) = (x)^+ = \max(0, x)，

-    .. note::
-
-        与 `ReLu` 的区别在于该算子多输出一个mask，且算子的kernel与 `ReLu` 的不同。
-
    **输入：**

    - **input_x** (Tensor) - 输入Tensor必须是4-D Tensor。
@ -22,7 +18,7 @@ mindspore.ops.ReLUV2
    **输出：**

    - **output** (Tensor) - 数据类型和shape与 `input_x` 的相同。
-    - **mask** (Tensor) - 数据类型必须为uint8的Tensor。
+    - **mask** (Tensor) - 保留输出，无实际意义。

    **异常：**

@ -37,14 +33,9 @@ mindspore.ops.ReLUV2

    >>> input_x = Tensor(np.array([[[[1, -2], [-3, 4]], [[-5, 6], [7, -8]]]]), mindspore.float32)
    >>> relu_v2 = ops.ReLUV2()
-    >>> output, mask= relu_v2(input_x)
+    >>> output, _= relu_v2(input_x)
    >>> print(output)
    [[[[1. 0.]
       [0. 4.]]
       [[0. 6.]
       [7. 0.]]]]
-    >>> print(mask)
-    [[[[[1 0]
-        [2 0]]
-        [[2 0]
-        [1 0]]]]]
--- a/docs/api/api_python/ops/mindspore.ops.Reshape.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Reshape.rst
@ -1,9 +1,9 @@
 mindspore.ops.Reshape
 ======================

-.. py:class:: mindspore.ops.Reshape(*args, **kwargs)
+.. py:class:: mindspore.ops.Reshape()

-    基于给定的shape，使用相同的值对输入Tensor进行reshape操作。
+    基于给定的shape，对输入Tensor进行重新排列。

    `input_shape` 最多只能有一个-1，在这种情况下，它可以从剩余的维度和输入的元素个数中推断出来。

@ -18,7 +18,7 @@ mindspore.ops.Reshape

    **异常：**

-    - **ValueError** - 给定的 `input_shape`，如果它有几个-1，或者除-1（若存在）之外的元素的乘积小于或等于0，或者无法被输入Tensor的shape的乘积相除，或者与输入的数组大小不匹配。
+    - **ValueError** - 给定的 `input_shape`，如果它有多个-1，或者除-1（若存在）之外的元素的乘积小于或等于0，或者无法被输入Tensor的shape的乘积整除，或者与输入的数组大小不匹配。

    **支持平台：**

--- a/docs/api/api_python/ops/mindspore.ops.SeLU.rst
+++ b/docs/api/api_python/ops/mindspore.ops.SeLU.rst
@ -1,9 +1,9 @@
 mindspore.ops.SeLU
 ==================

-.. py:class:: mindspore.ops.SeLU(*args, **kwargs)
+.. py:class:: mindspore.ops.SeLU()

-    按元素计算输入Tensor的SeLU（scaled exponential Linear Unit）函数。
+    激活函数SeLU（Scaled exponential Linear Unit）。

    该激活函数定义为：

@ -21,7 +21,7 @@ mindspore.ops.SeLU

    **输入：**

-    - **input_x** (Tensor) - shape为 :math:`(N, *)` 的Tensor，其中， :math:`*` 表示任意的附加维度数，数据类型为float16或float32。
+    - **input_x** (Tensor) - 任意维度的Tensor，数据类型为float16或float32。

    **输出：**

--- a/docs/api/api_python/ops/mindspore.ops.Sigmoid.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Sigmoid.rst
@ -1,11 +1,11 @@
 mindspore.ops.Sigmoid
 =====================

-.. py:class:: mindspore.ops.Sigmoid(*args, **kwargs)
+.. py:class:: mindspore.ops.Sigmoid()

    Sigmoid激活函数。

-    按元素计算输入的Sigmoid函数。Sigmoid函数定义为：
+    逐元素计算Sgmoid激活函数。Sigmoid函数定义为：

    .. math::

@ -15,7 +15,7 @@ mindspore.ops.Sigmoid

    **输入：**

-    - **input_x** (Tensor) - shape为 :math:`(N, *)` 的tensor，其中， :math:`*` 表示任意的附加维度数，数据类型为float16或float32。
+    - **input_x** (Tensor) - 任意维度的Tensor，数据类型为float16或float32。

    **输出：**

--- a/docs/api/api_python/ops/mindspore.ops.Size.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Size.rst
@ -1,15 +1,13 @@
 mindspore.ops.Size
 ==================

-.. py:class:: mindspore.ops.Size(*args, **kwargs)
+.. py:class:: mindspore.ops.Size()

-    返回Tensor的大小。
-
-    返回一个整数Scalar，表示输入的元素大小，即Tensor中元素的总数。
+    返回一个Scalar，类型为整数，表示输入Tensor的大小，即Tensor中元素的总数。

    **输入：**

-    - **input_x** (Tensor) - Tensor的shape为 :math:`(x_1, x_2, ..., x_R)` 。数据类型为Number。
+    - **input_x** (Tensor) - 输入参数，shape为 :math:`(x_1, x_2, ..., x_R)` 。数据类型为 `number <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 。

    **输出：**

--- a/docs/api/api_python/ops/mindspore.ops.Sub.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Sub.rst
@ -1,23 +1,24 @@
 mindspore.ops.Sub
 =================

-.. py:class:: mindspore.ops.Sub(*args, **kwargs)
+.. py:class:: mindspore.ops.Sub()

-    按元素用第一个输入Tensor减去第二个输入Tensor。
-
-    输入 `x` 和 `y` 遵循隐式类型转换规则，使数据类型保持一致。
-    输入必须是两个Tensor，或一个Tensor和一个Scalar。
-    当输入是两个Tensor时，它们的数据类型不能同时是bool，它们的shape可以广播。
-    当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
+    逐元素用第一个输入Tensor减去第二个输入Tensor。

    .. math::

        out_{i} = x_{i} - y_{i}

+     .. note::
+        - 输入 `x` 和 `y` 遵循 `隐式类型转换规则 <https://www.mindspore.cn/docs/note/zh-CN/master/operator_list_implicit.html>`_ ，使数据类型保持一致。
+        - 输入必须是两个Tensor，或一个Tensor和一个Scalar。
+        - 当输入是两个Tensor时，它们的数据类型不能同时是bool，它们的shape可以广播。
+        - 当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
+
    **输入：**

-    - **x** (Union[Tensor, Number, bool]) - 第一个输入，是一个Number、bool值或数据类型为Number或bool的Tensor。
-    - **y** (Union[Tensor, Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个Number或bool值，或数据类型为Number或bool的Tensor。
+    - **x** (Union[Tensor, number.Number, bool]) - 第一个输入，是一个number.Number、bool值或数据类型为 `number <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 或 `bool_ <https://www.mindspore.cn/docs/api/zh-CN/master/api_python/mindspore.html#mindspore.dtype>`_ 的Tensor。
+    - **y** (Union[Tensor, number.Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个number.Number或bool值，或数据类型为number或bool_的Tensor。当第一个输入是Scalar时，第二个输入必须是数据类型为number或bool_的Tensor。

    **输出：**

@ -25,7 +26,7 @@ mindspore.ops.Sub

    **异常：**

-    - **TypeError** - `x` 和 `y` 不是Tensor、Number或bool。
+    - **TypeError** - `x` 和 `y` 不是Tensor、number.Number或bool。

    **支持平台：**

--- a/docs/api/api_python/ops/mindspore.ops.Tile.rst
+++ b/docs/api/api_python/ops/mindspore.ops.Tile.rst
@ -1,9 +1,9 @@
 mindspore.ops.Tile
 ===================

-.. py:class:: mindspore.ops.Tile(*args, **kwargs)
+.. py:class:: mindspore.ops.Tile()

-    按照给定的次数复制Tensor。
+    按照给定的次数复制输入Tensor。

    通过复制 `multiples` 次 `input_x` 来创建新的Tensor。输出Tensor的第i维度有 `input_x.shape[i] * multiples[i]` 个元素，并且 `input_x` 的值沿第i维度被复制 `multiples[i]` 次。

@ -13,12 +13,12 @@ mindspore.ops.Tile

    **输入：**

-    - **input_x** (Tensor) - 1-D或更高的Tensor。将输入Tensor的shape设置为 :math:`(x_1, x_2, ..., x_S)` 。
-    - **multiples** (tuple[int]) - 输入tuple由多个整数构成，如 :math:`(y_1, y_2, ..., y_S)` 。`multiples` 的长度不能小于 `input_x` 的维度。只支持常量值。
+    - **input_x** (Tensor) - 1-D或更高维的Tensor。
+    - **multiples** (tuple[int]) - 指定复制次数的参数，参数类型为tuple，数据类型为整数。如 :math:`(y_1, y_2, ..., y_S)` 。`multiples` 的长度不能小于 `input_x` 的维度。只支持常量值。

    **输出：**

-    Tensor，具有与 `input_x` 相同的数据类型。假设 `multiples` 的长度为 `d` ，`input_x` 的维度为 `input_x.dim`。
+    Tensor，具有与 `input_x` 相同的数据类型。假设 `multiples` 的长度为 `d` ，`input_x` 的维度为 `input_x.dim`，`input_x`的shape为 :math:`(x_1, x_2, ..., x_S)` 。

    - 如果 `input_x.dim = d`， 将其相应位置的shape相乘，输出的shape为 :math:`(x_1*y_1, x_2*y_2, ..., x_S*y_S)` 。
    - 如果 `input_x.dim < d`， 在 `input_x` 的shape的前面填充1，直到它们的长度一致。例如将 `input_x` 的shape设置为 :math:`(1, ..., x_1, ..., x_R, x_S)` ，然后可以将其相应位置的shape相乘，输出的shape为 :math:`(1*y_1, ..., x_R*y_R, x_S*y_S)` 。
--- a/docs/api/api_python/ops/mindspore.ops.UniformReal.rst
+++ b/docs/api/api_python/ops/mindspore.ops.UniformReal.rst
@ -3,24 +3,31 @@ mindspore.ops.UniformReal

 .. py:class:: mindspore.ops.UniformReal(seed=0, seed2=0)

-    产生随机的浮点数i，均匀分布在[0，1)范围内。
+    产生随机的浮点数，均匀分布在[0，1)范围内。

    **参数：**

    - **seed** (int) - 算子层的随机种子，用于生成随机数。必须是非负的。默认值：0。
    - **seed2** (int)：全局的随机种子，和算子层的随机种子共同决定最终生成的随机数。必须是非负的。默认值：0。

+    .. note::
+        - 随机种子：通过一些复杂的数学算法，可以得到一组有规律的随机数，而随机种子就是这个随机数的初始值。随机种子相同，得到的随机数就不会改变。
+        - 全局的随机种子和算子层的随机种子都没设置：使用默认值当做随机种子。
+        - 全局的随机种子设置了，算子层的随机种子未设置：随机生成一个种子和全局的随机种子拼接。
+        - 全局的随机种子未设置，算子层的随机种子设置了：使用默认的全局的随机种子，和算子层的随机种子拼接。
+        - 全局的随机种子和算子层的随机种子都设置了：全局的随机种子和算子层的随机种子拼接。
+
    **输入：**

-    - **shape** (tuple) - 待生成的随机Tensor的shape。只支持常量值。
+    - **shape** (tuple) - 待生成的Tensor的shape。只支持常量值。

    **输出：**

-    Tensor。它的shape为输入 `shape` 表示的值。数据类型为float32。
+    Tensor。它的shape为输入 `shape`。数据类型为float32。

    **异常：**

-    - **TypeError** - `seed` 和 `seed2` 都不是int。
+    - **TypeError** - `seed` 或 `seed2` 不是int。
    - **TypeError** - `shape` 不是tuple。
    - **ValueError** - `shape` 不是常量值。

--- a/docs/api/api_python/ops/mindspore.ops.ZerosLike.rst
+++ b/docs/api/api_python/ops/mindspore.ops.ZerosLike.rst
@ -1,15 +1,13 @@
 mindspore.ops.ZerosLike
 =======================

-.. py:class:: mindspore.ops.ZerosLike(*args, **kwargs)
+.. py:class:: mindspore.ops.ZerosLike()

-    创建新的Tensor。它的所有元素的值都为0。
-
-    返回具有与输入Tensor相同shape和数据类型的值为0的Tensor。
+    返回值为0的Tensor，其shape和数据类型与输入Tensor相同。

    **输入：**

-    - **input_x** (Tensor) - 输入Tensor。数据类型为int32、int64、float16或float32。shape为 :math:`(N,*)` ，其中 :math:`*` 表示任意的附加维度数。
+    - **input_x** (Tensor) - 任意维度的输入Tensor。数据类型为int32、int64、float16或float32。

    **输出：**