!44247 add docs of operators 2

Merge pull request !44247 from panfengfeng/code_docs_add_ops_doc_2

docs/api/api_python/mindspore/Tensor/mindspore.Tensor.conj.rst

@@ -0,0 +1,16 @@
+mindspore.Tensor.conj
+=====================
+
+.. py:method:: mindspore.Tensor.conj()
+
+    计算输入Tensor的逐元素共轭。复数的形式必须是 `a + bj` ，其中a是实部，b是虚部。
+
+    返回的共轭形式为 `a + bj` 。
+
+    如果 `input` 是实数，则直接返回 `input` 。
+
+    返回：
+        Tensor，数据类型与 `input` 相同。
+
+    异常：
+        - **TypeError** - 如果当前Tensor的数据类型不是数字类型。

docs/api/api_python/mindspore/Tensor/mindspore.Tensor.cross.rst

@@ -0,0 +1,21 @@
+mindspore.Tensor.cross
+======================
+
+.. py:method:: mindspore.Tensor.cross(other, dim=None)
+
+    返回沿着维度 `dim` 上，当前Tensor和 `other` 的向量积（叉积）。当前Tensor和 `other` 必须有相同的形状，且指定的 `dim` 维上size必须为3。
+    如果不指定 `dim`，则默认为第一维为3。
+
+    参数：
+        - **other** (Tensor) - 输入Tensor。
+        - **dim** (int) - 沿着此维进行叉积操作。默认值：None。
+
+    返回：
+        Tensor，数据类型与当前Tensor相同。
+
+    异常：
+        - **TypeError** - 如果 `other` 不是Tensor。
+        - **TypeError** - 如果当前Tensor的数据类型与 `other` 不同。
+        - **ValueError** - 如果当前Tensor和 `other` 的size不同，维度不为3。
+        - **ValueError** - 如果当前Tensor和 `other` 的shape不相同。
+        - **ValueError** - 如果 `dim` 不在[-len(input.shape), len(input.shape)-1]范围内。

docs/api/api_python/mindspore/Tensor/mindspore.Tensor.cumprod.rst

@@ -0,0 +1,22 @@
+mindspore.Tensor.cumprod
+========================
+
+.. py:method:: mindspore.Tensor.cumprod(dim, dtype=None)
+
+    返回输入的元素在 `dim` 维度上的累积乘积。
+    例如，如果当前输入是大小为N的向量，则结果也将是大小为N的向量（带有元素）。
+
+   .. math::
+        y_i = x_1 * x_2 * x_3 * ... * x_i
+
+    参数：
+        - **dim** (int) - 计算累积乘积的尺寸。只允许常量值。
+        - **dtype** - 输出的数据类型。默认值：None。
+
+    返回：
+        Tensor，数据类型和shape与当前Tensor相同，除非指定了 `dtype`。
+
+    异常：
+        - **TypeError** -  如果 `dim` 不是int。
+        - **TypeError** -  如果 `dtype` 无法进行转换。
+        - **ValueError** - 如果 `dim` 是None。

docs/api/api_python/mindspore/Tensor/mindspore.Tensor.div.rst

@@ -0,0 +1,29 @@
+mindspore.Tensor.div
+====================
+
+.. py:method:: mindspore.Tensor.div(other, rounding_mode=None)
+
+    逐元素计算第一个输入Tensor除以第二输入Tensor的商。
+
+    `input` 和 `other` 的输入遵循隐式类型转换规则，使数据类型一致。
+    输入必须是两个Tensor，或一个Tensor和一个Scalar。
+    当输入是两个Tensor时，它们的数据类型不能同时为bool，它们的shape可以广播。
+    当输入是一个Tensor和一个Scalar时，Scalar只能是一个常量。
+
+    .. math:
+        out_{i} = input_{i} / other_{i}:
+
+    参数：
+        - **other** (Union[Tensor, Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入必须是一个数值型或bool，或是数据类型为数值型或bool的Tensor。
+        - **rounding_mode** (str, 可选) - 应用于结果的舍入类型。三种类型被定义为None、"floor" 和 "trunc" 。默认值：None。
+
+          - **None**: 默认行为。相当于Python中的 `true division` 或NumPy中的 `true_divide` 。
+          - **floor**: 将除法的结果向下舍入。相当于Python中的 `floor division` 或NumPy中的 `floor_divide` 。
+          - **trunc**: 将除法的结果舍入到零。相当于C型整数除法。
+
+    返回：
+        Tensor，输出的shape与广播后的shape相同，数据类型取两个输入中精度较高或数字较高的。
+
+    异常：
+        - **TypeError** - 如果 `other` 不是以下之一：Tensor、Number、bool。
+        - **ValueError** - 如果 `rounding_mode` 不是以下之一：None、floor、trunc。

docs/api/api_python/mindspore/Tensor/mindspore.Tensor.equal.rst

@@ -0,0 +1,28 @@
+mindspore.Tensor.equal
+======================
+
+.. py:method:: mindspore.Tensor.equal(other)
+
+    逐元素比较两个输入Tensor是否相等。
+
+    .. math::
+        out_{i} =\begin{cases}
+            & \text{True,    if } input_{i} = other_{i} \\
+            & \text{False,   if } input_{i} \ne other_{i}
+            \end{cases}
+
+    .. note::
+        - 输入 `input` 和 `other` 遵循隐式类型转换规则，使数据类型保持一致。
+        - 输入必须是两个Tensor，或一个Tensor和一个Scalar。
+        - 当输入是两个Tensor时，它们的shape可以广播。
+        - 当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
+        - 支持广播。
+
+    参数：
+        - **other** (Union[Tensor, Number]) - 当第一个输入是Tensor时，第二个输入是数值型或数据类型为数值型的Tensor。数据类型与第一个输入相同。
+
+    返回：
+        Tensor，输出的shape与输入广播后的shape相同，数据类型为bool。
+
+    异常：
+        - **TypeError** - 如果 `other` 不是Tensor。

docs/api/api_python/mindspore/Tensor/mindspore.Tensor.erfinv.rst

@@ -0,0 +1,15 @@
+mindspore.Tensor.erfinv
+=======================
+
+.. py:method:: mindspore.Tensor.erfinv()
+
+    计算输入的逆误差函数。逆误差函数在 `(-1, 1)` 范围内定义为：
+
+    .. math::
+        erfinv(erf(x)) = x
+
+    返回：
+        Tensor，具有与当前Tensor相同的数据类型和shape。
+
+    异常：
+        - **TypeError** - 当前Tensor的数据类型不是float16、float32、float64。

docs/api/api_python/mindspore/Tensor/mindspore.Tensor.expm1.rst

@@ -0,0 +1,15 @@
+mindspore.Tensor.expm1
+======================
+
+.. py:method:: mindspore.Tensor.expm1()
+
+    逐元素计算输入Tensor的指数，然后减去1。
+
+    .. math::
+        out_i = e^{x_i} - 1
+
+    返回：
+        Tensor，shape与当前Tensor相同。
+
+    异常：
+        - **TypeError** - 如果当前Tensor的数据类型既不是float16也不是float32。

docs/api/api_python/mindspore/Tensor/mindspore.Tensor.less_equal.rst

@@ -0,0 +1,21 @@
+mindspore.Tensor.less_equal
+===========================
+
+.. py:method:: mindspore.Tensor.less_equal(other)
+
+    逐元素计算 :math:`input <= other` 的bool值。
+
+    .. math::
+        out_{i} =\begin{cases}
+            & \text{True,    if } input_{i}<=other_{i} \\
+            & \text{False,   if } input_{i}>other_{i}
+            \end{cases}
+
+    参数：
+        - **other** (Union[Tensor, number.Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个number.Number或bool值，或数据类型为number或bool_的Tensor。当第一个输入是Scalar时，第二>个输>入必须是数据类型为number或bool_的Tensor。
+
+    返回：
+        Tensor，shape与广播后的shape相同，数据类型为bool。
+
+    异常：
+        - **TypeError** - `other` 都不是Tensor。

docs/api/api_python/ops/mindspore.ops.func_conj.rst

@@ -0,0 +1,20 @@
+mindspore.ops.conj
+===================
+
+.. py:function:: mindspore.ops.conj(input)
+
+    计算输入Tensor的逐元素共轭。复数的形式必须是 `a + bj` ，其中a是实部，b是虚部。
+
+    返回的共轭形式为 `a + bj` 。
+
+    如果 `input` 是实数，则直接返回 `input` 。
+
+    参数：
+        - **input** (Tensor) - 输入Tensor，必须是数字类型。
+
+    返回：
+        Tensor，数据类型与 `input` 相同。
+
+    异常：
+        - **TypeError** -  如果 `input` 的数据类型不是数字类型。
+        - **ValueError** - 如果 `input` 不是Tensor。

docs/api/api_python/ops/mindspore.ops.func_cross.rst

@@ -0,0 +1,23 @@
+mindspore.ops.cross
+====================
+
+.. py:function:: mindspore.ops.cross(input, other, dim=None)
+
+    返回沿着维度 `dim` 上，`input` 和 `other` 的向量积（叉积）。 `input` 和 `other` 必须有相同的形状，且指定的 `dim` 维上size必须为3。
+    如果不指定 `dim`，则默认为第一维为3。
+    
+    参数：
+        - **input** (Tensor) - 输入Tensor。
+        - **other** (Tensor) - 输入Tensor。
+        - **dim** (int) - 沿着此维进行叉积操作。默认值：None。
+
+    返回：
+        Tensor，数据类型与 `input` 相同。
+
+    异常：
+        - **TypeError** - 如果 `input` 不是Tensor。
+        - **TypeError** - 如果 `other` 不是Tensor。
+        - **TypeError** - 如果 `input` 数据类型与 `other` 不同。
+        - **ValueError** - 如果 `input` 和 `other` 的size不同，维度不为3。
+        - **ValueError** - 如果 `input` 和 `other` 的shape不相同。
+        - **ValueError** - 如果 `dim` 不在[-len(input.shape), len(input.shape)-1]范围内。

docs/api/api_python/ops/mindspore.ops.func_cumprod.rst

@@ -0,0 +1,23 @@
+mindspore.ops.cumprod
+======================
+
+.. py:function:: mindspore.ops.cumprod(input, dim, dtype=None)
+
+    返回输入的元素在 `dim` 维度上的累积乘积。
+    例如，如果 `input` 是大小为N的向量，则结果也将是大小为N的向量（带有元素）。
+
+   .. math::
+        y_i = x_1 * x_2 * x_3 * ... * x_i
+
+    参数：
+        - **input** (Tensor[Number]) - 输入Tensor，必须是数字类型。:math:`(N,*)` ，其中 :math:`*` 表示任何额外的维度，其秩都应该小于8。
+        - **dim** (int) - 计算累积乘积的尺寸。只允许常量值。
+        - **dtype** - 输出的数据类型。默认值：None。
+
+    返回：
+        Tensor，数据类型和shape与 `input` 相同，除非指定了 `dtype`。
+
+    异常：
+        - **TypeError** -  如果 `dim` 不是int。
+        - **TypeError** -  如果 `dtype` 无法进行转换。
+        - **ValueError** - 如果 `dim` 是None。

docs/api/api_python/ops/mindspore.ops.func_diagonal.rst

@@ -0,0 +1,18 @@
+mindspore.ops.diagonal
+=======================
+
+.. py:function:: mindspore.ops.diagonal(input, offset=0, dim1=0, dim2=1)
+
+    返回 `input` 的部分视图，其相对于 `dim1` 和 `dim2` 的对角线元素作为维度附加在形状的末尾。
+
+    参数：
+        - **input** (Tensor) - 输入Tensor，其维度至少为2。
+        - **offset** (int, 可选) - 对角线与主对角线的偏移。可以是正值或负值。默认值：0。
+        - **dim1** (int, 可选) - 二维子数组的第一轴，对角线应该从这里开始。默认值：0。
+        - **dim2** (int, 可选) - 二维子数组的第二轴，对角线应该从这里开始。默认值：1。
+
+    返回：
+        Tensor，如果Tensor是二维，则返回值是一维数组。
+
+    异常：
+        - **ValueError** - 输入Tensor的维度少于2。

docs/api/api_python/ops/mindspore.ops.func_div.rst

@@ -1,24 +1,30 @@
 mindspore.ops.div
-==================
+=================
 
-.. py:function:: mindspore.ops.div(x, y)
+.. py:function:: mindspore.ops.div(input, other, rounding_mode=None)
 
     逐元素计算第一个输入Tensor除以第二输入Tensor的商。
 
-    `x` 和 `y` 的输入遵循隐式类型转换规则，使数据类型一致。
+    `input` 和 `other` 的输入遵循隐式类型转换规则，使数据类型一致。
     输入必须是两个Tensor，或一个Tensor和一个Scalar。
     当输入是两个Tensor时，它们的数据类型不能同时为bool，它们的shape可以广播。
     当输入是一个Tensor和一个Scalar时，Scalar只能是一个常量。
 
-    .. math::
-        out_{i} = x_{i} / y_{i}
+    .. math:
+        out_{i} = input_{i} / other_{i}
 
     参数：
-        - **x** (Union[Tensor, Number, bool]) - 第一个输入，为数值型，或bool，或数据类型为数值型或bool的Tensor。
-        - **y** (Union[Tensor, Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入必须是一个数值型或bool，或是数据类型为数值型或bool的Tensor。
+        - **input** (Union[Tensor, Number, bool]) - 第一个输入，为数值型，或bool，或数据类型为数值型或bool的Tensor。
+        - **other** (Union[Tensor, Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入必须是一个数值型或bool，或是数据类型为数值型或bool的Tensor。
+        - **rounding_mode** (str, 可选) - 应用于结果的舍入类型。三种类型被定义为None、"floor" 和 "trunc" 。默认值：None。
+
+          - **None**: 默认行为。相当于Python中的 `true division` 或NumPy中的 `true_divide` 。
+          - **floor**: 将除法的结果向下舍入。相当于Python中的 `floor division` 或NumPy中的 `floor_divide` 。
+          - **trunc**: 将除法的结果舍入到零。相当于C型整数除法。
 
     返回：
         Tensor，输出的shape与广播后的shape相同，数据类型取两个输入中精度较高或数字较高的。
 
     异常：
-        - **TypeError** - 如果 `x` 和 `y` 不是以下之一：Tensor、Number、bool。
+        - **TypeError** - 如果 `input` 和 `other` 不是以下之一：Tensor、Number、bool。
+        - **ValueError** - 如果 `rounding_mode` 不是以下之一：None、floor、trunc。

docs/api/api_python/ops/mindspore.ops.func_elu.rst

@@ -0,0 +1,38 @@
+mindspore.ops.elu
+=================
+
+.. py:function:: mindspore.ops.elu(input_x, alpha=1.0)
+
+    指数线性单元激活函数。
+
+    对输入的每个元素计算ELU。该激活函数定义如下：
+
+    .. math::
+            E_{i} =
+            \begin{cases}
+            x_i, &\text{if } x_i \geq 0; \cr
+            \alpha * (\exp(x_i) - 1), &\text{otherwise.}
+            \end{cases}
+
+    其中，:math:`x_i` 表示输入的元素，:math:`\alpha` 表示 `alpha` 参数。
+
+    ELU相关图参见 `ELU <https://en.wikipedia.org/wiki/Activation_function#/media/File:Activation_elu.svg>`_  。
+
+    .. math::
+        \text{ELU}(x)= \left\{
+        \begin{array}{align}
+            \alpha(e^{x}  - 1) & \text{if } x \le 0\\
+            x & \text{if } x \gt 0\\
+        \end{array}\right.
+
+    参数：
+        - **input_x** (Tensor) - 用于计算ELU的任意维度的Tensor，数据类型为float16或float32。
+        - **alpha** (float) - ELU的alpha值，数据类型为浮点数。默认值：1.0。。
+
+    返回：
+        Tensor，输出的shape、数据类型与 `input_x` 相同。
+
+    异常：
+        - **TypeError** - 如果 `alpha` 不是float。
+        - **TypeError** - 如果 `input_x` 的数据类型既不是float16，也不是float32。
+        - **ValueError** - 如果 `alpha` 不等于1.0。

docs/api/api_python/ops/mindspore.ops.func_erfinv.rst

@@ -0,0 +1,18 @@
+mindspore.ops.erfinv
+====================
+
+.. py:function:: mindspore.ops.erfinv(input)
+
+    计算输入的逆误差函数。逆误差函数在 `(-1, 1)` 范围内定义为：
+
+    .. math::
+        erfinv(erf(x)) = x
+
+    参数：
+        - **input** (Tensor) - 输入Tensor，数据类型必须为float16、float32、float64。
+
+    返回：
+        Tensor，具有与 `input` 相同的数据类型和shape。
+
+    异常：
+        - **TypeError** - `input` 的数据类型不是float16、float32、float64。

docs/api/api_python/ops/mindspore.ops.func_expm1.rst

@@ -8,7 +8,6 @@ mindspore.ops.expm1
     .. math::
         out_i = e^{x_i} - 1
 
-
     参数：
         - **x** (Tensor) - 数据类型为float16或float32的Tensor，其秩必须在[0, 7]中。
 

docs/api/api_python/ops/mindspore.ops.func_gelu.rst

@@ -0,0 +1,33 @@
+mindspore.ops.gelu
+==================
+
+.. py:function:: mindspore.ops.gelu(input_x, approximate='none')
+
+    高斯误差线性单元激活函数。
+
+    GeLU的描述可以在 `Gaussian Error Linear Units (GELUs) <https://arxiv.org/abs/1606.08415>`_ 这篇文章中找到。
+    也可以去查询 `BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding <https://arxiv.org/abs/1810.04805>`_ 。
+
+    当 `approximate` 为 `none` ，GELU的定义如下：
+
+    .. math::
+        GELU(x_i) = x_i*P(X < x_i),
+
+    其中 :math:`P` 是标准高斯分布的累积分布函数， :math:`x_i` 是输入的元素。
+
+    当 `approximate` 为 `tanh` ，GELU的定义如下：
+
+    .. math::
+        GELU(x_i) = 0.5 * x_i * (1 + tanh[\sqrt{\\frac{2}{pi}}(x + 0.044715 * x_{i}^{3})] )
+
+    GELU相关图参见 `GELU <https://en.wikipedia.org/wiki/Activation_function#/media/File:Activation_gelu.png>`_ 。
+
+    参数：
+        - **input_x** (Tensor) - 用于计算GELU的Tensor。数据类型为float16、float32、float64。
+        - **approximate** (str) - gelu近似算法。有两种：'none' 和 'tanh'。默认值：none。
+
+    输出：
+        Tensor，具有与 `input_x` 相同的数据类型和shape。
+
+    异常：
+        - **TypeError** - `input_x` 的数据类型既不是float16也不是float32。

docs/api/api_python/ops/mindspore.ops.func_less_equal.rst

@@ -0,0 +1,28 @@
+mindspore.ops.less_equal
+========================
+
+.. py:function:: mindspore.ops.less_equal(input, other)
+
+    逐元素计算 :math:`input <= other` 的bool值。
+
+    .. math::
+        out_{i} =\begin{cases}
+            & \text{True,    if } input_{i}<=other_{i} \\
+            & \text{False,   if } input_{i}>other_{i}
+            \end{cases}
+
+    .. note::
+        - 输入 `input` 和 `other` 遵循 `隐式类型转换规则 <https://www.mindspore.cn/docs/zh-CN/master/note/operator_list_implicit.html>`_ ，使数据类型保持一致。
+        - 输入必须是两个Tensor，或一个Tensor和一个Scalar。
+        - 当输入是两个Tensor时，它们的数据类型不能同时是bool，并保证其shape可以广播。
+        - 当输入是一个Tensor和一个Scalar时，Scalar只能是一个常数。
+
+    参数：
+        - **input** (Union[Tensor, number.Number, bool]) - 第一个输入，是一个number.Number、bool值或数据类型为 `number <https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore/mindspore.dtype.html#mindspore.dtype>`_ 或 `bool_ <https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore/mindspore.dtype.html#mindspore.dtype>`_ 的Tensor。
+        - **other** (Union[Tensor, number.Number, bool]) - 第二个输入，当第一个输入是Tensor时，第二个输入应该是一个number.Number或bool值，或数据类型为number或bool_的Tensor。当第一个输入是Scalar时，第二个输>入必须是数据类型为number或bool_的Tensor。
+
+    返回：
+        Tensor，shape与广播后的shape相同，数据类型为bool。
+
+    异常：
+        - **TypeError** - `input` 和 `other` 都不是Tensor。

mindspore/python/mindspore/common/tensor.py

@@ -6254,8 +6254,8 @@ class Tensor(Tensor_):
         .. math::
 
             out_{i} =\begin{cases}
-                & \text{True,    if } input\_x_{i}<=other_{i} \\
-                & \text{False,   if } input\_x_{i}>other_{i}
+                & \text{True,    if } input_{i}<=other_{i} \\
+                & \text{False,   if } input_{i}>other_{i}
                 \end{cases}
 
         Args:

mindspore/python/mindspore/ops/function/math_func.py

@@ -6399,17 +6399,17 @@ def conj(input):
 
     The complex conjugate returned by this operation is of the form a - bj.
 
-    If input is real, it is returned unchanged.
+    If `input` is real, it is returned unchanged.
 
     Args:
         input (Tensor): The input tensor to compute to. Must have numeric type.
 
     Returns:
-        Tensor, has the same dtype as the input.
+        Tensor, has the same dtype as the `input`.
 
     Raises:
-        TypeError: If the dtype of input is not a numeric type.
-        TypeError: If the input is not a Tensor.
+        TypeError: If the dtype of `input` is not a numeric type.
+        TypeError: If the `input` is not a Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``