mindspore 2.1.0__cp37-cp37m-manylinux1_x86_64.whl → 2.2.11__cp37-cp37m-manylinux1_x86_64.whl

mindspore/ops/operations/math_ops.py

@@ -25,7 +25,6 @@ from mindspore.ops import signature as sig
 from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
 from mindspore.common.tensor import Tensor
-from mindspore.common._decorator import deprecated
 from mindspore.ops._utils import get_broadcast_shape
 from mindspore.ops.primitive import Primitive, PrimitiveWithInfer, PrimitiveWithCheck, prim_attr_register, _run_op
 from mindspore._c_expression import Tensor as Tensor_
@@ -92,6 +91,9 @@ class _MathBinaryOp(_BinaryOp):
         args_type = {"x": x_dtype, "y": y_dtype}
         complex_types = [mstype.TensorType(mstype.complex64), mstype.TensorType(mstype.complex128)]
         if x_dtype in complex_types or y_dtype in complex_types:
+            if (not isinstance(x_dtype, type(mstype.tensor_type))) or \
+               (not isinstance(y_dtype, type(mstype.tensor_type))):
+                raise TypeError('Only Tensor type support Complex')
             type_infer_dict = {
                 (mstype.complex64, mstype.complex64): mstype.TensorType(mstype.complex64),
                 (mstype.complex64, mstype.float32): mstype.TensorType(mstype.complex64),
@@ -195,12 +197,13 @@ class Add(_MathBinaryOp):
           [True, Tensor(True, bool\_), Tensor(np.array([True]), bool\_)] are all considered bool type.
         - The two inputs comply with the implicit type conversion rules to make the data types
           consistent.
+        - When input is Tensor, it's dimension should be greater than or equal to 1.
 
     Inputs:
         - **x** (Union[Tensor, number.Number, bool]) - The first input is a number.Number or
           a bool or a tensor whose data type is
-          `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_.
+          `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+          `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
         - **y** (Union[Tensor, number.Number, bool]) - The second input, when the first input is a Tensor,
           the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool.
           When the first input is Scalar, the second input must be a Tensor whose data type is number or bool.
@@ -437,28 +440,6 @@ class AddV2(Primitive):
         self.init_prim_io_names(inputs=['x', 'y'], outputs=['output'])
 
 
-class TensorAdd(_MathBinaryOp):
-    """
-    Same as operator Add. TensorAdd will be deprecated in the future.
-    Please use Add instead.
-    """
-
-    @deprecated("1.1", "Add", True)
-    @prim_attr_register
-    def __init__(self):
-        """Initialize TensorAdd."""
-        _MathBinaryOp.__init__(self)
-
-    def infer_value(self, x, y):
-        if x is not None and y is not None:
-            x = x.asnumpy()
-            y = y.asnumpy()
-            out = x + y
-            out = np.array(out, x.dtype)
-            return Tensor(out)
-        return None
-
-
 class AssignAdd(Primitive):
     """
     Updates a `Parameter` by adding a value to it.
@@ -1365,7 +1346,8 @@ class CumProd(Primitive):
         reverse (bool): If ``True`` , reverse the result along axis. Default: ``False`` .
 
     Inputs:
-        - **x** (Tensor[Number]) - The input tensor.
+        - **x** (Tensor[Number]) - The input Tensor with shape
+          :math:`(N, *)` where :math:`*` means any number of additional dimensions.
         - **axis** (int) - The dimensions to compute the cumulative product.
           Only constant value is allowed.
 
@@ -1554,9 +1536,8 @@ class LpNorm(Primitive):
     """
 
     @prim_attr_register
-    def __init__(self, axis, p=2, keep_dims=False, epsilon=1e-12):
+    def __init__(self, axis=(), p=2, keep_dims=False, epsilon=1e-12):
         """Initialize LpNorm"""
-        super().__init__("LpNorm")
         validator.check_value_type("p", p, [int], self.name)
         validator.check_value_type("axis", axis, [int, tuple, list], self.name)
         validator.check_value_type("keep_dims", keep_dims, [bool], self.name)
@@ -1767,7 +1748,8 @@ class CumSum(Primitive):
         reverse (bool): If ``True`` , perform inverse cumulative sum. Default: ``False`` .
 
     Inputs:
-        - **input** (Tensor) - The input tensor to accumulate.
+        - **input** (Tensor) - The input Tensor with shape
+          :math:`(N, *)` where :math:`*` means any number of additional dimensions.
         - **axis**  (int) - The axis to accumulate the tensor's value. Only constant value is allowed.
           Must be in the range [-rank(input), rank(input)).
 
@@ -2013,27 +1995,6 @@ class InplaceUpdateV2(Primitive):
         return output
 
 
-class InplaceUpdate(Primitive):
-    r"""
-    The InplaceUpdate interface is deprecated. Please use the :class:`mindspore.ops.InplaceUpdateV2` instead.
-
-    Supported Platforms:
-        Deprecated
-    """
-
-    @deprecated("2.0", "ops.InplaceUpdateV2", False)
-    @prim_attr_register
-    def __init__(self, indices):
-        """Initialize InplaceUpdate"""
-        self.init_prim_io_names(inputs=['x', 'v'], outputs=['y'])
-        self.indices = indices
-        validator.check_value_type("indices", indices, [int, tuple], self.name)
-        if isinstance(indices, int):
-            self.indices = (indices,)
-        for item in self.indices:
-            validator.check_value_type("item of indices", item, [int], self.name)
-
-
 class InplaceAdd(Primitive):
     """
     Adds `v` into specified rows of `x`. Computes `y` = `x`; y[i,] += `v`.
@@ -2206,8 +2167,8 @@ class Sub(_MathBinaryOp):
     Inputs:
         - **x** (Union[Tensor, number.Number, bool]) - The first input is a number.Number or
           a bool or a tensor whose data type is
-          `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_.
+          `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+          `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
         - **y** (Union[Tensor, number.Number, bool]) - The second input, when the first input is a Tensor,
           the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool.
           When the first input is Scalar, the second input must be a Tensor whose data type is number or bool.
@@ -2258,8 +2219,8 @@ class Mul(_MathBinaryOp):
     Inputs:
         - **x** (Union[Tensor, number.Number, bool]) - The first input is a number.Number or
           a bool or a tensor whose data type is
-          `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_.
+          `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+          `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
         - **y** (Union[Tensor, number.Number, bool]) - The second input, when the first input is a Tensor,
           the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool.
           When the first input is Scalar, the second input must be a Tensor whose data type is number or bool.
@@ -2532,6 +2493,7 @@ class Reciprocal(PrimitiveWithCheck):
         self.init_prim_io_names(inputs=['x'], outputs=['y'])
 
     def infer_value(self, x):
+        """Infer value for Reciprocal"""
         if x is not None:
             x = x.asnumpy()
             out = 1.0 / x
@@ -2549,8 +2511,8 @@ class Pow(Primitive):
     Inputs:
         - **x** (Union[Tensor, number.Number, bool]) - The first input is a number.Number or
           a bool or a tensor whose data type is
-          `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_.
+          `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+          `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
         - **y** (Union[Tensor, number.Number, bool]) - The second input, when the first input is a Tensor,
           the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool\_.
           When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.
@@ -2589,6 +2551,7 @@ class Pow(Primitive):
         self.init_prim_io_names(inputs=['x1', 'x2'], outputs=['y'])
 
     def infer_value(self, x, power):
+        """infer value for _BinaryOp"""
         if x is not None and power is not None:
             x = x.asnumpy()
             power = power.asnumpy()
@@ -2832,7 +2795,6 @@ class Einsum(Primitive):
         seg_equation = equation.split("->")
         if len(seg_equation) > 2:
             raise TypeError("the equation can contain only one arrow !")
-        self.add_prim_attr('equation', equation)
         self.init_prim_io_names(inputs=['inputs'], outputs=['output'])
 
 
@@ -2970,7 +2932,7 @@ class Histogram(Primitive):
     """
 
     @prim_attr_register
-    def __init__(self, bins=100, min=0.0, max=0.0):  # pylint: disable=W0622
+    def __init__(self, bins=100, min=0.0, max=0.0):
         """Initialize Histogram."""
         self.init_prim_io_names(inputs=['x'], outputs=['y'])
         validator.check_value_type("bins", bins, [int], self.name)
@@ -3197,8 +3159,10 @@ class Erf(Primitive):
     Refer to :func:`mindspore.ops.erf` for more details.
 
     Inputs:
-        - **x** (Tensor) - Input Tensor of Gaussian error function. Its data type
-          must be float16 float32 or float64.
+        - **x** (Tensor) - Input Tensor of Gaussian error function. Supported dtypes:
+
+          - Ascend: float16, float32.
+          - GPU/CPU: float16, float32, float64.
 
     Outputs:
         Tensor, has the same shape and dtype as the `x`.
@@ -3230,7 +3194,10 @@ class Erfc(Primitive):
     Refer to :func:`mindspore.ops.erfc` for more details.
 
     Inputs:
-        - **x** (Tensor) - The input tensor with a dtype of float16, float32 or float64.
+        - **x** (Tensor) - The input tensor. Supported dtypes:
+
+          - Ascend: float16, float32.
+          - GPU/CPU: float16, float32, float64.
 
     Outputs:
         Tensor, has the same shape and dtype as `x`.
@@ -3400,8 +3367,8 @@ class Div(_MathBinaryOp):
     Inputs:
         - **x** (Union[Tensor, number.Number, bool]) - The first input is a number.Number or
           a bool or a tensor whose data type is
-          `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_.
+          `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+          `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
         - **y** (Union[Tensor, number.Number, bool]) - The second input, when the first input is a Tensor,
           the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool.
           When the first input is Scalar, the second input must be a Tensor whose data type is number or bool.
@@ -3491,8 +3458,8 @@ class DivNoNan(Primitive):
     Inputs:
         - **x1** (Union[Tensor, number.Number, bool]) - The first input is a number.Number or
           a bool or a tensor whose data type is
-          `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_.
+          `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+          `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
         - **x2** (Union[Tensor, number.Number, bool]) - The second input is a number.Number or
           a bool when the first input is a bool or a tensor whose data type is number or bool\_.
           When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.
@@ -3815,8 +3782,10 @@ class Floor(Primitive):
     Refer to :func:`mindspore.ops.floor` for more details.
 
     Inputs:
-        - **x** (Tensor) - The input tensor, its data type must be float16,
-          float32 or float64.
+        - **x** (Tensor) - The input tensor. Supported dtypes:
+
+          - Ascend: float16, float32.
+          - GPU/CPU: float16, float32, float64.
 
     Outputs:
         Tensor, has the same shape as `x`.
@@ -4020,8 +3989,8 @@ class Xlogy(Primitive):
     Inputs:
         - **x** (Union[Tensor, number.Number, bool]) - The first input is a number.Number or
           a bool or a tensor whose data type is
-          `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_.
+          `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+          `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
         - **y** (Union[Tensor, number.Number, bool]) - The second input is a number.Number or
           a bool when the first input is a tensor or a tensor whose data type is number or bool\_.
           When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.
@@ -4469,8 +4438,8 @@ class Greater(PrimitiveWithCheck):
     Inputs:
         - **x** (Union[Tensor, number.Number, bool]) - The first input is a number.Number or
           a bool or a tensor whose data type is
-          `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ .
+          `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+          `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ .
         - **y** (Union[Tensor, number.Number, bool]) - The second input, when the first input is a Tensor,
           the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool\_.
           When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.
@@ -4685,8 +4654,8 @@ class LessEqual(PrimitiveWithCheck):
     Inputs:
         - **x** (Union[Tensor, number.Number, bool]) - The first input is a number.Number or
           a bool or a tensor whose data type is
-          `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_.
+          `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+          `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
         - **y** (Union[Tensor, number.Number, bool]) - The second input, when the first input is a Tensor,
           the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool\_.
           When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.
@@ -5405,7 +5374,8 @@ class ACos(Primitive):
     Refer to :func:`mindspore.ops.acos` for more details.
 
     Inputs:
-        - **x** (Tensor) - The input Tensor.
+        - **x** (Tensor) - The shape of tensor is
+          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
 
     Outputs:
         Tensor, has the same shape and dtype as `x`.
@@ -5422,10 +5392,6 @@ class ACos(Primitive):
         >>> output = acos(x)
         >>> print(output)
         [0.737726  1.5307857 1.2661036 0.9764105]
-        >>> x = Tensor(0.5)
-        >>> output = acos(x)
-        >>> print(output)
-        1.0471978
     """
 
     @prim_attr_register
@@ -5469,7 +5435,8 @@ class Asin(Primitive):
         Complex64 and complex128 are not supported on Ascend currently.
 
     Inputs:
-        - **x** (Tensor) - The input Tensor.
+        - **x** (Tensor) - The shape of tensor is
+          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
 
     Outputs:
         Tensor, has the same shape and dtype as `x`.
@@ -5486,10 +5453,6 @@ class Asin(Primitive):
         >>> output = asin(x)
         >>> print(output)
         [0.8330704  0.04001067 0.30469266 0.5943858 ]
-        >>> x = Tensor(0.12)
-        >>> output = asin(x)
-        >>> print(output)
-        0.12028988
     """
 
     @prim_attr_register
@@ -5565,7 +5528,6 @@ class NMSWithMask(PrimitiveWithInfer):
         """Initialize NMSWithMask"""
         validator.check_value_type("iou_threshold", iou_threshold, [float], self.name)
         self.init_prim_io_names(inputs=['bboxes'], outputs=['selected_boxes', 'selected_idx', 'selected_mask'])
-        self.is_ge = context.get_context("enable_ge")
 
     def infer_shape(self, bboxes_shape):
         cls_name = self.name
@@ -5728,7 +5690,7 @@ class Atan(Primitive):
         - **x** (Tensor): The input Tensor. Supported dtypes:
 
           - Ascend: float16, float32.
-          - GPU/CPU: float16, float32, float64, complex64, complex128.
+          - GPU/CPU: float16, float32, float64.
 
     Outputs:
         A Tensor, has the same type as the input.
@@ -5792,8 +5754,9 @@ class Atan2(_MathBinaryOp):
     Refer to :func:`mindspore.ops.atan2` for more details.
 
     Inputs:
-        - **x** (Tensor, Number.number) - The input tensor or scalar.
-        - **y** (Tensor, Number.number) - The input tensor or scalar. It has the same shape with `x` or
+        - **x** (Tensor) - The input tensor with shape
+          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+        - **y** (Tensor) - The input tensor. It has the same shape with `x` or
           its shape is able to broadcast with `x`.
 
     Outputs:
@@ -5959,8 +5922,18 @@ class BitwiseXor(_BitwiseBinaryOp):
 
 
 class BesselI0(Primitive):
-    """
-    Computes BesselI0 of input element-wise.
+    r"""
+    Computes modified Bessel function of the first kind, order 0 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            I_{0}(x)=J_{0}(\mathrm{i} x)=\sum_{m=0}^{\infty}
+            \frac{x^{2 m}}{2^{2 m} (m !)^{2}}
+        \end{array}
+
+    where :math:`J_{0}` is Bessel function of the first kind, order 0.
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
@@ -5994,8 +5967,18 @@ class BesselI0(Primitive):
 
 
 class BesselI1(Primitive):
-    """
-    Computes BesselI1 of input element-wise.
+    r"""
+    Computes modified Bessel function of the first kind, order 1 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            I_{1}(x)=\mathrm{i}^{-1} J_{1}(\mathrm{i} x)=\sum_{m=0}^
+            {\infty} \frac{x^{2m+1}}{2^{2m+1} m ! (m+1) !}
+        \end{array}
+
+    where :math:`J_{1}` is Bessel function of the first kind, order 1.
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
@@ -6030,14 +6013,17 @@ class BesselI1(Primitive):
 
 class BesselI0e(Primitive):
     r"""
-    Computes BesselI0e of input element-wise.
+    Computes exponential scaled modified Bessel function of the first kind, order 0 element-wise.
 
     The formula is defined as:
 
     .. math::
-        BesselI0e(x) = \exp(|x|) * bessel\_i0(x)
+        \begin{array}{ll} \\
+            \text I_{0}e(x)=e^{(-|x|)} * I_{0}(x)=e^{(-|x|)} * \sum_{m=0}^
+            {\infty} \frac{x^{2 m}}{2^{2 m} (m !)^{2}}
+        \end{array}
 
-    where bessel_i0 is Bessel function of the first kind with 0 order.
+    where :math:`I_{0}` is modified Bessel function of the first kind, order 0.
 
     Inputs:
         - **x** (Tensor) - The input tensor.
@@ -6072,14 +6058,17 @@ class BesselI0e(Primitive):
 
 class BesselI1e(Primitive):
     r"""
-    Computes BesselI1e of input element-wise.
+    Computes exponential scaled modified Bessel function of the first kind, order 1 element-wise.
 
     The formula is defined as:
 
     .. math::
-        BesselI1e(x) = \exp(|x|) * bessel\_i1(x)
+        \begin{array}{ll} \\
+            \text I_{1}e(x)=e^{(-|x|)} * I_{1}(x)=e^{(-|x|)} * \sum_{m=0}^
+            {\infty} \frac{x^{2m+1}}{2^{2m+1} m ! (m+1) !}
+        \end{array}
 
-    where bessel_i1 is Bessel function of the first kind with 1 order.
+    where :math:`I_{1}` is  modified Bessel function of the first kind, order 1.
 
     Inputs:
         - **x** (Tensor) - The input tensor.
@@ -6114,7 +6103,17 @@ class BesselI1e(Primitive):
 
 class BesselK0(Primitive):
     r"""
-    Computes BesselK0 of input element-wise.
+    Computes modified Bessel function of the second kind, order 0 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            K_{0}(x)= \lim_{\nu \to 0} \left(\frac{\pi}{2}\right) \frac
+            {I_{-\nu}(x)-I_{\nu}(x)}{\sin (\nu \pi)} = \int_{0}^{\infty} e^{-x \cosh t} d t
+        \end{array}
+
+    where :math:`I_{0}` is modified Bessel function of the first kind, order 0.
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
@@ -6150,7 +6149,17 @@ class BesselK0(Primitive):
 
 class BesselK1(Primitive):
     r"""
-    Computes BesselK1 of input element-wise.
+    Computes modified Bessel function of the second kind, order 1 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            K_{1}(x)=\lim_{\nu \to 1} \left(\frac{\pi}{2}\right) \frac{I_{-\nu}(x)-
+            I_{\nu}(x)}{\sin (\nu \pi)} = \int_{0}^{\infty} e^{-x \cosh t} \cosh (t) d t
+        \end{array}
+
+    where :math:`I_{1}` is modified Bessel function of the first kind, order 1.
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
@@ -6185,8 +6194,18 @@ class BesselK1(Primitive):
 
 
 class BesselK0e(Primitive):
-    """
-    Computes BesselK0e of input element-wise.
+    r"""
+    Computes exponential scaled modified Bessel function of the second kind, order 0 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            K_{0}e(x)= e^{(-|x|)} * K_{0}(x) = e^{(-|x|)} * \int_{0}^
+            {\infty} e^{-x \cosh t} d t
+        \end{array}
+
+    where :math:`K_{0}` is modified Bessel function of the second kind, order 0.
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
@@ -6221,8 +6240,18 @@ class BesselK0e(Primitive):
 
 
 class BesselK1e(Primitive):
-    """
-    Computes BesselK1e of input element-wise.
+    r"""
+    Computes exponential scaled modified Bessel function of the second kind, order 1 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            K_{1}e(x)= e^{(-|x|)} * K_{1}(x) = e^{(-|x|)} * \int_{0}
+            ^{\infty} e^{-x \cosh t} \cosh (t) d t
+        \end{array}
+
+    where :math:`K_{1}` is modified Bessel function of the second kind, order 1.
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
@@ -6257,8 +6286,16 @@ class BesselK1e(Primitive):
 
 
 class BesselJ0(Primitive):
-    """
-    Computes BesselJ0 of input element-wise.
+    r"""
+    Computes Bessel function of the first kind, order 0 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            J_{0}(x) = \frac{1}{\pi} \int_{0}^{\pi} \cos (x \sin \theta) d \theta
+            =\sum_{m=0}^{\infty} \frac{(-1)^{m} x^{2 m}}{2^{2 m} (m !)^2}
+        \end{array}
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
@@ -6294,8 +6331,16 @@ class BesselJ0(Primitive):
 
 
 class BesselJ1(Primitive):
-    """
-    Computes BesselJ1 of input element-wise.
+    r"""
+    Computes Bessel function of the first kind, order 1 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            J_{1}(x) = \frac{1}{\pi} \int_{0}^{\pi} \cos (x \sin \theta- \theta) d \theta
+            =\sum_{m=0}^{\infty} \frac{(-1)^{m} x^{2 m+1}}{2^{2 m+1} m !(m+1) !}
+        \end{array}
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
@@ -6331,8 +6376,17 @@ class BesselJ1(Primitive):
 
 
 class BesselY0(Primitive):
-    """
-    Computes BesselY0 of input element-wise.
+    r"""
+    Computes Bessel function of the second kind, order 0 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            Y_{0}(x)=\lim_{n \to 0} \frac{J_{n}(x) \cos n \pi-J_{-n}(x)}{\sin n \pi}
+        \end{array}
+
+    where :math:`J_{0}` is Bessel function of the first kind, order 0.
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
@@ -6368,8 +6422,17 @@ class BesselY0(Primitive):
 
 
 class BesselY1(Primitive):
-    """
-    Computes BesselY1 of input element-wise.
+    r"""
+    Computes Bessel function of the second kind, order 1 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            Y_{1}(x)=\lim_{n \to 1} \frac{J_{n}(x) \cos n \pi-J_{-n}(x)}{\sin n \pi}
+        \end{array}
+
+    where :math:`J_{1}` is Bessel function of the first kind, order 1.
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
@@ -6461,13 +6524,15 @@ class Invert(Primitive):
         self.init_prim_io_names(inputs=['x'], outputs=['y'])
 
 
-class Eps(PrimitiveWithInfer):
+class Eps(Primitive):
     """
     Create a Tensor with the same data type and shape as input, and the element value is the minimum value that the
-    corresponding data type can be expressed.
+    corresponding data type can express.
+
+    Refer to :func:`mindspore.ops.eps` for more detail.
 
     Inputs:
-        - **x** (Tensor) - Tensor of any dimension used to obtain the minimum value that its data type can be expressed.
+        - **x** (Tensor) - Tensor of any dimension used to obtain the minimum value that its data type can express.
           The data type must be float16, float32 or float64.
 
     Outputs:
@@ -6475,7 +6540,7 @@ class Eps(PrimitiveWithInfer):
 
     Raises:
         TypeError: If `x` is not a Tensor.
-        TypeError: If data type of `x` is neither float16 nor float32.
+        TypeError: If data type of `x` is neither float16, float32, nor float64.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -6486,33 +6551,13 @@ class Eps(PrimitiveWithInfer):
         >>> x = Tensor([4, 1, 2, 3], mindspore.float32)
         >>> output = ops.Eps()(x)
         >>> print(output)
-        [1.5258789e-05 1.5258789e-05 1.5258789e-05 1.5258789e-05]
+        [1.1920929e-07 1.1920929e-07 1.1920929e-07 1.1920929e-07]
     """
 
     @prim_attr_register
     def __init__(self):
         """Initialize Eps"""
-        self.init_prim_io_names(inputs=['input_x'], outputs=['y'])
-
-    def __infer__(self, input_x):
-        valid_dtypes = [mstype.float16, mstype.float32, mstype.float64]
-        validator.check_tensor_dtype_valid('input_x', input_x['dtype'], valid_dtypes, self.name)
-
-        x_nptype = mstype.dtype_to_nptype(input_x['dtype'].element_type())
-        if x_nptype == np.float16:
-            min_val = 2 ** (-14)
-        elif x_nptype == np.float32:
-            min_val = 2 ** (-16)
-        else:
-            min_val = 2 ** (-52)
-
-        res = np.full(input_x['shape'], min_val, x_nptype)
-        out = {
-            'value': Tensor(res),
-            'shape': input_x['shape'],
-            'dtype': input_x['dtype'],
-        }
-        return out
+        self.init_prim_io_names(inputs=['x'], outputs=['y'])
 
 
 class LinSpace(Primitive):
@@ -6524,9 +6569,9 @@ class LinSpace(Primitive):
 
     Inputs:
         - **start** (Tensor) -  Start value of interval, 0-D Tensor with dtype float32 or float64.
-        - **stop** (Tensor) - Last value of interval, 0-D Tensor with dtype  float32 or float64.
-        - **num** (int) - Number of ticks in the interval, inclusive of `start` and `stop`.
-          Supported dtypes: int32, int64.
+        - **stop** (Tensor) - Last value of interval, 0-D Tensor with dtype float32 or float64.
+        - **num** (Union[int, Tensor]) - Number of ticks in the interval, inclusive of `start` and `stop`.
+          Must be a positive integer. When the input is Tensor, it must be a 0-D Tensor with dtype int32 or int64.
 
     Outputs:
         Tensor, has the same shape and dtype as `start`.
@@ -6838,7 +6883,10 @@ class Erfinv(Primitive):
     Refer to :func:`mindspore.ops.erfinv` for more details.
 
     Inputs:
-        - **input_x** (Tensor) - The input tensor to compute with, with data type float16, float32 or float64.
+        - **input_x** (Tensor) - The input tensor.  Supported dtypes:
+
+          - Ascend: float16, float32.
+          - GPU/CPU: float16, float32, float64.
 
     Outputs:
         Tensor, has the same shape and dtype as `input_x`.
@@ -8457,11 +8505,11 @@ class FFTWithSize(Primitive):
             satisfied. Default: ``()`` .
 
             - The length of `signal_sizes` is equal to the signal_ndim of the IRFFT:
-              :math:`len(signal_sizes)=signal_ndim`.
+              :math:`len(signal\_sizes)=signal\_ndim`.
             - The last dimension of `signal_sizes` divided by 2 is equal to
-              the last dimension of the IRFFT input: :math:`signal_size[-1]/2+1=x.shape[-1]`.
+              the last dimension of the IRFFT input: :math:`signal\_size[-1]/2+1=x.shape[-1]`.
             - `signal_sizes` has exactly the same dimensions as the input shape
-              except for the last dimension: :math:`signal_sizes[:-1]=x.shape[:-1]`.
+              except for the last dimension: :math:`signal\_sizes[:-1]=x.shape[:-1]`.
 
     Inputs:
         - **x** (Tensor) - The dimension of the input tensor must be greater than or equal to signal_ndim.