mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/ops/operations/math_ops.py

@@ -25,11 +25,9 @@ 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_
-from mindspore.common._utils import is_shape_unknown
 
 
 def _infer_shape_reduce(x, axis, keep_dims, prim_name):
@@ -91,15 +89,18 @@ class _MathBinaryOp(_BinaryOp):
     def do_infer_dtype(x_dtype, y_dtype, valid_dtype=mstype.number_type, prim_name=None):
         """Staticmethod of infer dtype for _MathBinaryOp."""
         args_type = {"x": x_dtype, "y": y_dtype}
-        complex_types = [mstype.tensor_type(mstype.complex64), mstype.tensor_type(mstype.complex128)]
+        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.tensor_type(mstype.complex64),
-                (mstype.complex64, mstype.float32): mstype.tensor_type(mstype.complex64),
-                (mstype.float32, mstype.complex64): mstype.tensor_type(mstype.complex64),
-                (mstype.complex128, mstype.complex128): mstype.tensor_type(mstype.complex128),
-                (mstype.complex128, mstype.float64): mstype.tensor_type(mstype.complex128),
-                (mstype.float64, mstype.complex128): mstype.tensor_type(mstype.complex128),
+                (mstype.complex64, mstype.complex64): mstype.TensorType(mstype.complex64),
+                (mstype.complex64, mstype.float32): mstype.TensorType(mstype.complex64),
+                (mstype.float32, mstype.complex64): mstype.TensorType(mstype.complex64),
+                (mstype.complex128, mstype.complex128): mstype.TensorType(mstype.complex128),
+                (mstype.complex128, mstype.float64): mstype.TensorType(mstype.complex128),
+                (mstype.float64, mstype.complex128): mstype.TensorType(mstype.complex128),
             }
             if (x_dtype.element_type(), y_dtype.element_type()) not in type_infer_dict.keys():
                 raise TypeError('Complex math binary op expecting Tensor [Complex64, Complex64],'
@@ -152,10 +153,20 @@ class Ger(Primitive):
 
     Refer to :func:`mindspore.ops.ger` for more details.
 
+    Inputs:
+        - **x1** - (Tensor) - 1-D input Tensor.
+        - **x2** - (Tensor) - 1-D input Tensor, has the same dtype as `x1`.
+
+    Outputs:
+        Tensor, output matrix with the same dtype as inputs.With `x1` shape :math:`(m,)` and
+        `x2` shape of :math:`(n,)`,the `output` has shape :math:`(m, n)`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> x1 = Tensor([1., 2., 3., 4.], mindspore.float32)
         >>> x2 = Tensor([1., 2., 3.], mindspore.float32)
         >>> ger = ops.Ger()
@@ -179,10 +190,35 @@ class Add(_MathBinaryOp):
 
     Refer to :func:`mindspore.ops.add` for more details.
 
+    Note:
+        - One of the two inputs must be a Tensor, when the two inputs have different shapes,
+          they must be able to broadcast to a common shape.
+        - The two inputs can not be bool type at the same time,
+          [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.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.
+
+    Outputs:
+        Tensor, the shape is the same as the one of the input `x` , `y` after broadcasting,
+        and the data type is the one with higher precision or higher digits among the two inputs.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> # case 1: x and y are both Tensor.
         >>> add = ops.Add()
         >>> x = Tensor(np.array([1, 2, 3]).astype(np.float32))
@@ -201,6 +237,20 @@ class Add(_MathBinaryOp):
         >>> # and the output is the data format of higher precision float32.
         >>> print(output.dtype)
         Float32
+        >>> # case 3: one of x and y is a bool scalar
+        >>> add = ops.Add()
+        >>> x = True
+        >>> y = Tensor(np.array([4, 5, 6]).astype(np.float32))
+        >>> output = add(x, y)
+        >>> print(output)
+        [5. 6. 7.]
+        >>> # case 4: one of x and y is a bool Tensor
+        >>> add = ops.Add()
+        >>> x = Tensor(np.array([True, False, True]), mindspore.bool_)
+        >>> y = Tensor(np.array([4, 5, 6]).astype(np.float32))
+        >>> output = add(x, y)
+        >>> print(output)
+        [5. 5. 7.]
     """
 
     @staticmethod
@@ -243,8 +293,8 @@ class Add(_MathBinaryOp):
 
 class Addcdiv(Primitive):
     r"""
-    Performs the element-wise division of tensor `x1` by tensor `x2`,
-    multiply the result by the scalar `value` and add it to `input_data`.
+    Adds the element-wise division of `x1` by `x2`, multiplied by `value` to `input_data`.
+    It computes the following operation:
 
     .. math::
         y[i] = input\_data[i] + value[i] * (x1[i] / x2[i])
@@ -269,6 +319,9 @@ class Addcdiv(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_data = Tensor(np.array([1, 1, 1, 1]), mindspore.float32)
         >>> x1 = Tensor(np.array([1, 2, 3, 4]), mindspore.float32)
         >>> x2 = Tensor(np.array([4, 3, 2, 1]), mindspore.float32)
@@ -287,8 +340,8 @@ class Addcdiv(Primitive):
 
 class Addcmul(Primitive):
     r"""
-    Performs the element-wise product of tensor `x1` and tensor `x2`,
-    multiply the result by the scalar `value` and add it to `input_data`.
+    Adds the element-wise product of `x1` by `x2`, multiplied by `value` to `input_data`.
+    It computes the following operation:
 
     .. math::
         output[i] = input\_data[i] + value[i] * (x1[i] * x2[i])
@@ -313,6 +366,9 @@ class Addcmul(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_data = Tensor(np.array([1, 1, 1]), mindspore.float32)
         >>> x1 = Tensor(np.array([[1], [2], [3]]), mindspore.float32)
         >>> x2 = Tensor(np.array([[1, 2, 3]]), mindspore.float32)
@@ -384,38 +440,28 @@ 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.
 
     Refer to :func:`mindspore.ops.assign_add` for more details.
 
+    Inputs:
+        - **variable** (Parameter) - The `Parameter`.
+          :math:`(N,*)` where :math:`*` means, any number of additional dimensions, its rank should be less than 8.
+        - **value** (Union[numbers.Number, Tensor]) - The value to be added to the `variable`.
+          It must have the same shape as `variable` if it is a Tensor.
+
+    Outputs:
+        Tensor, has the same data type and shape as original `variable`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, nn
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
@@ -450,10 +496,22 @@ class AssignSub(Primitive):
 
     Refer to :func:`mindspore.ops.assign_sub` for more details.
 
+    Inputs:
+        - **variable** (Parameter) - The `Parameter`.
+          :math:`(N,*)` where :math:`*` means, any number of additional dimensions, its rank be should be less than 8.
+        - **value** (Union[numbers.Number, Tensor]) - The value to be subtracted from the `variable`.
+          It must have the same shape as `variable` if it is a Tensor.
+
+    Outputs:
+        Tensor, has the same data type and shape as original `variable`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, nn
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
@@ -488,8 +546,8 @@ class _Reduce(PrimitiveWithCheck):
     Definition of base class of reduction class operators.
 
     Args:
-         keep_dims (bool): If true, keep these reduced dimensions and the length is 1.
-                           If false, don't keep these dimensions. Default: False.
+         keep_dims (bool): If ``True`` , keep these reduced dimensions and the length is 1.
+                           If ``False`` , don't keep these dimensions. Default: ``False`` .
     """
 
     __mindspore_signature__ = (
@@ -542,8 +600,8 @@ class EuclideanNorm(Primitive):
     The specified `axes` are removed by default.
 
     Args:
-        keep_dims (bool, optional): whether to retain the reduced dimensions. If true, retains them with length 1.
-            If false, these dimensions are removed. Default: False.
+        keep_dims (bool, optional): whether to retain the reduced dimensions. If ``True`` , retains them with length 1.
+            If ``False`` , these dimensions are removed. Default: ``False`` .
 
     Inputs:
         - **x** (Tensor) - The input Tensor to reduce.
@@ -584,23 +642,22 @@ class ReduceMean(_Reduce):
     controlling `keep_dims`.
 
     Args:
-        keep_dims (bool): If true, keep these reduced dimensions and the length is 1.
-                          If false, don't keep these dimensions. Default: False.
+        keep_dims (bool): If ``True`` , keep these reduced dimensions and the length is 1.
+                          If ``False`` , don't keep these dimensions. Default: ``False`` .
 
     Inputs:
-        - **x** (Tensor[Number]) - The input tensor. The dtype of the tensor to be reduced is number.
-          :math:`(N, *)` where :math:`*` means, any number of additional dimensions, its rank should be less than 8.
-        - **axis** (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: (), reduce all dimensions.
-          Only constant value is allowed. Must be in the range [-r, r).
+        - **x** (Tensor[Number]) - The input tensor.
+        - **axis** (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: ``()`` , reduce all
+          dimensions. Only constant value is allowed. Must be in the range [-r, r).
 
     Outputs:
         Tensor, has the same dtype as the `x`.
 
-        - If `axis` is (), and `keep_dims` is False,
+        - If `axis` is (), and `keep_dims` is ``False`` ,
           the output is a 0-D tensor representing the mean of all elements in the input tensor.
-        - If `axis` is int, set as 1, and `keep_dims` is False,
+        - If `axis` is int, set as 1, and `keep_dims` is ``False`` ,
           the shape of output is :math:`(x_0, x_2, ..., x_R)`.
-        - If `axis` is tuple(int) or list(int), set as (1, 2), and `keep_dims` is False,
+        - If `axis` is tuple(int) or list(int), set as (1, 2), and `keep_dims` is ``False`` ,
           the shape of output is :math:`(x_0, x_3, ..., x_R)`.
 
     Raises:
@@ -613,6 +670,9 @@ class ReduceMean(_Reduce):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
         >>> op = ops.ReduceMean(keep_dims=True)
         >>> output = op(x, 1)
@@ -668,21 +728,21 @@ class CumulativeLogsumexp(Primitive):
     log(exp(a) + exp(b) + exp(c))].
 
     Args:
-        exclusive (bool, optional): If true, the last element will be skipped during the calculation and thus an
+        exclusive (bool, optional): If ``True`` , the last element will be skipped during the calculation and thus an
                                     exclusive cumulative log-sum-exp will be performed. For example, this operation
                                     will output [-inf, a, log(exp(a) * exp(b))] with tensor [a, b, c] as the input.
                                     Note that the minimal value -inf, for performance reasons, is representable by the
-                                    floating point type. Default: False.
-        reverse (bool, optional): If true, the function accumulation values will be calculated after the elements of
-                                  `x` on `axis` are flipped, and the calculation result will be flipped afterwards. For
-                                  example, this operation will output [log(exp(c) + exp(b) + exp(a)), log(exp(c) +
-                                  exp(b)), c] with tensor [a, b, c] as the input. Default: False.
+                                    floating point type. Default: ``False`` .
+        reverse (bool, optional): If ``True`` , the function accumulation values will be calculated after the elements
+                                  of `x` on `axis` are flipped, and the calculation result will be flipped afterwards.
+                                  For example, this operation will output [log(exp(c) + exp(b) + exp(a)), log(exp(c) +
+                                  exp(b)), c] with tensor [a, b, c] as the input. Default: ``False`` .
 
     Inputs:
         - **x** (Tensor) - The input tensor. Must be one of the following types: float16, float32, float64. The
           dimension of `x` must greater than 0.
         - **axis** (Tensor) - A 0-D tensor describing the dimension to compute the cumulative product. Must be one of
-          the following types: int64, int32, int16. Must be in the range [-rank(x), rank(x)). Default: 0.
+          the following types: int64, int32, int16. Must be in the range [-rank(x), rank(x)). Default: ``0`` .
 
     Outputs:
         Tensor, has the same dtype and shape as the `x`.
@@ -736,29 +796,29 @@ class ReduceSum(PrimitiveWithCheck):
     controlling `keep_dims`.
 
     Args:
-        keep_dims (bool): If true, keep these reduced dimensions and the length is 1.
-                          If false, don't keep these dimensions. Default: False.
-        skip_mode (bool): If true and axis is empty tuple or empty list, the ReduceSum operation isn't performed,
+        keep_dims (bool): If ``True`` , keep these reduced dimensions and the length is 1.
+                          If ``False`` , don't keep these dimensions. Default: ``False`` .
+        skip_mode (bool): If ``True`` and axis is empty tuple or empty list, the ReduceSum operation isn't performed,
                           skip it.
-                          If true and axis is other values, the ReduceSum calculation is performed normally.
-                          If false, do reduce. Default: False.
+                          If ``True`` and axis is other values, the ReduceSum calculation is performed normally.
+                          If ``False`` , do reduce. Default: ``False`` .
 
     Inputs:
-         - **x** (Tensor[Number]) - The input tensor. The dtype of the tensor to be reduced is number.
-           :math:`(N, *)` where :math:`*` means, any number of additional dimensions, its rank should be less than 8.
-         - **axis** (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: (), reduce all dimensions
-           when skip_mode is false. Only constant value is allowed. Must be in the range [-rank(`x`), rank(`x`)).
+         - **x** (Tensor[Number]) - The input tensor.
+         - **axis** (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: ``()`` , reduce all
+           dimensions when skip_mode is ``False`` . Only constant value is allowed. Must be in the range [-rank(`x`),
+           rank(`x`)).
 
     Outputs:
         Tensor, has the same dtype as the `x`.
 
-        - If axis is (), keep_dims is False, and skip_mode is False,
+        - If axis is (), keep_dims is ``False`` , and skip_mode is ``False`` ,
           the output is a 0-D tensor representing the sum of all elements in the input tensor.
-        - If axis is (), and skip_mode is True,
+        - If axis is (), and skip_mode is ``True`` ,
           the ReduceSum operation is not performed, output tensor is equal to the input tensor.
-        - If axis is int, set as 2, and keep_dims is False,
+        - If axis is int, set as 2, and keep_dims is ``False`` ,
           the shape of output is :math:`(x_1, x_3, ..., x_R)`.
-        - If axis is tuple(int) or list(int), set as (2, 3), and keep_dims is False,
+        - If axis is tuple(int) or list(int), set as (2, 3), and keep_dims is ``False`` ,
           the shape of output is :math:`(x_1, x_4, ..., x_R)`.
 
     Raises:
@@ -771,6 +831,9 @@ class ReduceSum(PrimitiveWithCheck):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
         >>> op = ops.ReduceSum(keep_dims=True)
         >>> output = op(x, 1)
@@ -857,23 +920,22 @@ class ReduceAll(_Reduce):
     controlling `keep_dims`.
 
     Args:
-       keep_dims (bool): If true, keep these reduced dimensions and the length is 1.
-                         If false, don't keep these dimensions. Default : False.
+       keep_dims (bool): If ``True`` , keep these reduced dimensions and the length is 1.
+                         If ``False`` , don't keep these dimensions. Default: ``False`` .
 
     Inputs:
         - **x** (Tensor[bool]) - The input tensor. The dtype of the tensor to be reduced is bool.
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions, its rank should be less than 8.
-        - **axis** (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: (), reduce all dimensions.
-          Only constant value is allowed. Must be in the range [-rank(x), rank(x)).
+        - **axis** (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: ``()`` , reduce all
+          dimensions. Only constant value is allowed. Must be in the range [-rank(x), rank(x)).
 
     Outputs:
         Tensor, the dtype is bool.
 
-        - If axis is (), and keep_dims is False,
+        - If axis is (), and keep_dims is ``False`` ,
           the output is a 0-D tensor representing the "logical and" of all elements in the input tensor.
-        - If axis is int, set as 2, and keep_dims is False,
+        - If axis is int, set as 2, and keep_dims is ``False`` ,
           the shape of output is :math:`(x_1, x_3, ..., x_R)`.
-        - If axis is tuple(int), set as (2, 3), and keep_dims is False,
+        - If axis is tuple(int), set as (2, 3), and keep_dims is ``False`` ,
           the shape of output is :math:`(x_1, x_4, ..., x_R)`.
 
     Raises:
@@ -885,6 +947,8 @@ class ReduceAll(_Reduce):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[True, False], [True, True]]))
         >>> op = ops.ReduceAll(keep_dims=True)
         >>> # case 1: Reduces a dimension by the "logicalAND" of all elements in the dimension.
@@ -902,6 +966,12 @@ class ReduceAll(_Reduce):
         >>> print(output)
         [[False]
         [ True]]
+        >>> # case 4: input is a scalar.
+        >>> x = Tensor(True)
+        >>> op = ops.ReduceAll()
+        >>> output = op(x)
+        >>> print(output)
+        True
     """
 
 
@@ -912,14 +982,13 @@ class ReduceAny(_Reduce):
     controlling `keep_dims`.
 
     Args:
-       keep_dims (bool): If true, keep these reduced dimensions and the length is 1.
-                         If false, don't keep these dimensions. Default : False.
+       keep_dims (bool): If ``True`` , keep these reduced dimensions and the length is 1.
+                         If ``False`` , don't keep these dimensions. Default: ``False`` .
 
     Inputs:
         - **x** (Tensor[bool]) - The input tensor. The dtype of the tensor to be reduced is bool.
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions, its rank should be less than 8.
-        - **axis** (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: (), reduce all dimensions.
-          Only constant value is allowed. Must be in the range [-rank(x), rank(x)).
+        - **axis** (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: ``()`` , reduce all
+          dimensions. Only constant value is allowed. Must be in the range [-rank(x), rank(x)).
 
     Outputs:
         Tensor, the dtype is bool.
@@ -940,6 +1009,8 @@ class ReduceAny(_Reduce):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[True, False], [True, True]]))
         >>> op = ops.ReduceAny(keep_dims=True)
         >>> # case 1: Reduces a dimension by the "logical OR" of all elements in the dimension.
@@ -957,6 +1028,12 @@ class ReduceAny(_Reduce):
         >>> print(output)
         [[True]
         [ True]]
+        >>> # case 4: input is a scalar.
+        >>> x = Tensor(True)
+        >>> op = ops.ReduceAny()
+        >>> output = op(x)
+        >>> print(output)
+        True
     """
 
 
@@ -967,14 +1044,13 @@ class ReduceMax(_Reduce):
     controlling `keep_dims`.
 
     Args:
-        keep_dims (bool): If true, keep these reduced dimensions and the length is 1.
-                          If false, don't keep these dimensions. Default : False.
+        keep_dims (bool): If ``True`` , keep these reduced dimensions and the length is 1.
+                          If ``False`` , don't keep these dimensions. Default: ``False`` .
 
     Inputs:
-         - **x** (Tensor[Number]) - The input tensor. The dtype of the tensor to be reduced is number.
-           :math:`(N, *)` where :math:`*` means, any number of additional dimensions, its rank should be less than 8.
-         - **axis** (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: (), reduce all dimensions.
-           Only constant value is allowed. Must be in the range [-r, r).
+         - **x** (Tensor[Number]) - The input tensor.
+         - **axis** (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: ``()`` , reduce all
+           dimensions. Only constant value is allowed. Must be in the range [-r, r).
 
     Outputs:
         Tensor, has the same dtype as the `x`.
@@ -996,6 +1072,9 @@ class ReduceMax(_Reduce):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
         >>> op = ops.ReduceMax(keep_dims=True)
         >>> output = op(x, 1)
@@ -1051,23 +1130,22 @@ class ReduceMin(_Reduce):
     controlling `keep_dims`.
 
     Args:
-        keep_dims (bool): If true, keep these reduced dimensions and the length is 1.
-                          If false, don't keep these dimensions. Default : False.
+        keep_dims (bool): If ``True`` , keep these reduced dimensions and the length is 1.
+                          If ``False`` , don't keep these dimensions. Default: ``False`` .
 
     Inputs:
-        - **x** (Tensor[Number]) - The input tensor. The dtype of the tensor to be reduced is number.
-          :math:`(N, *)` where :math:`*` means, any number of additional dimensions, its rank should be less than 8.
-        - **axis** (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: (), reduce all dimensions.
-          Only constant value is allowed. Must be in the range [-r, r).
+        - **x** (Tensor[Number]) - The input tensor.
+        - **axis** (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: ``()`` , reduce all
+          dimensions. Only constant value is allowed. Must be in the range [-r, r).
 
     Outputs:
         Tensor, has the same dtype as the `x`.
 
-        - If `axis` is (), and `keep_dims` is False,
+        - If `axis` is (), and `keep_dims` is ``False`` ,
           the output is a 0-D tensor representing the minimum of all elements in the input tensor.
-        - If `axis` is int, set as 1, and `keep_dims` is False,
+        - If `axis` is int, set as 1, and `keep_dims` is ``False`` ,
           the shape of output is :math:`(x_0, x_2, ..., x_R)`.
-        - If `axis` is tuple(int), set as (1, 2), and `keep_dims` is False,
+        - If `axis` is tuple(int), set as (1, 2), and `keep_dims` is ``False`` ,
           the shape of output is :math:`(x_0, x_3, ..., x_R)`.
 
     Raises:
@@ -1080,6 +1158,9 @@ class ReduceMin(_Reduce):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
         >>> op = ops.ReduceMin(keep_dims=True)
         >>> output = op(x, 1)
@@ -1174,23 +1255,22 @@ class ReduceProd(_Reduce):
     controlling `keep_dims`.
 
     Args:
-        keep_dims (bool): If true, keep these reduced dimensions and the length is 1.
-                          If false, don't keep these dimensions. Default: False.
+        keep_dims (bool): If ``True`` , keep these reduced dimensions and the length is 1.
+                          If ``False`` , don't keep these dimensions. Default: ``False`` .
 
     Inputs:
-        - **x** (Tensor[Number]) - The input tensor. The dtype of the tensor to be reduced is number.
-          :math:`(N, *)` where :math:`*` means, any number of additional dimensions, its rank should be less than 8.
-        - **axis** (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: (), reduce all dimensions.
-          Only constant value is allowed. Must be in the range [-r, r).
+        - **x** (Tensor[Number]) - The input tensor.
+        - **axis** (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: ``()`` , reduce all
+          dimensions. Only constant value is allowed. Must be in the range [-r, r).
 
     Outputs:
         Tensor, has the same dtype as the `x`.
 
-        - If `axis` is (), and `keep_dims` is False,
+        - If `axis` is (), and `keep_dims` is ``False`` ,
           the output is a 0-D tensor representing the product of all elements in the input tensor.
-        - If `axis` is int, set as 1, and `keep_dims` is False,
+        - If `axis` is int, set as 1, and `keep_dims` is ``False`` ,
           the shape of output is :math:`(x_0, x_2, ..., x_R)`.
-        - If `axis` is tuple(int), set as (1, 2), and `keep_dims` is False,
+        - If `axis` is tuple(int), set as (1, 2), and `keep_dims` is ``False`` ,
           the shape of output is :math:`(x_0, x_3, ..., x_R)`.
 
     Raises:
@@ -1203,6 +1283,9 @@ class ReduceProd(_Reduce):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
         >>> op = ops.ReduceProd(keep_dims=True)
         >>> output = op(x, 1)
@@ -1259,12 +1342,12 @@ class CumProd(Primitive):
         y_i = x_1 * x_2 * x_3 * ... * x_i
 
     Args:
-        exclusive (bool): If true, perform exclusive cumulative product. Default: False.
-        reverse (bool): If true, reverse the result along axis. Default: False
+        exclusive (bool): If ``True`` , perform exclusive cumulative product. Default: ``False`` .
+        reverse (bool): If ``True`` , reverse the result along axis. Default: ``False`` .
 
     Inputs:
-        - **x** (Tensor[Number]) - The input tensor.
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions, its rank should be less than 8.
+        - **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.
 
@@ -1280,6 +1363,8 @@ class CumProd(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> a, b, c, = 1, 2, 3
         >>> x = Tensor(np.array([a, b, c]).astype(np.float32))
         >>> op0 = ops.CumProd()
@@ -1345,6 +1430,8 @@ class Lcm(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x1 = Tensor(np.array([7, 8, 9]))
         >>> x2 = Tensor(np.array([14, 6, 12]))
         >>> lcm_ = ops.Lcm()
@@ -1366,6 +1453,19 @@ class Cdist(Primitive):
 
     Refer to :func:`mindspore.ops.cdist` for more details.
 
+    Args:
+        p (float, optional): P value for the p-norm distance to calculate between each vector pair, P ∈ [0,∞].
+            Default: ``2.0`` .
+
+    Inputs:
+        - **input_x** (Tensor) - Input tensor of shape :math:`(B, P, M)`.
+          When :math:`B` is equal to 0, it means this dimension can be ignored,
+          i.e. shape of the tensor is :math:`(P, M)`.
+        - **input_y** (Tensor) - Input tensor of shape :math:`(B, R, M)` with the same dtype as `input_x`.
+
+    Outputs:
+        Tensor, has the same dtype as `input_x`, which shape is :math:`(B, P, R)`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -1392,20 +1492,20 @@ class Cdist(Primitive):
 
 
 class LpNorm(Primitive):
-    """
+    r"""
     Returns the matrix norm or vector norm of a given tensor.
 
     .. math::
-        output = sum(abs(input)**p)**(1/p)
+        output = \sum(abs(input)**p)**(1/p)
 
     Args:
         axis(int,list,tuple): Specifies which dimension or dimensions of input to calculate the norm across.
-        p(int, optional): The order of norm. Default: 2.
-        keep_dims(bool, optional): Whether the output tensors have dim retained or not. Default: False.
-        epsilon(float, optional): A value added to the denominator for numerical stability. Default: 1e-12.
+        p(int, optional): The order of norm. Default: ``2`` .
+        keep_dims(bool, optional): Whether the output tensors have dim retained or not. Default: ``False`` .
+        epsilon(float, optional): A value added to the denominator for numerical stability. Default: ``1e-12`` .
 
     Inputs:
-        - **input** (Tensor) - Input tensor.
+        - **input** (Tensor) - Input tensor of type float16, float32.
 
     Outputs:
         Tensor, has the same dtype as `input`, its shape depends on `axis`. For example, if the shape of input
@@ -1426,6 +1526,8 @@ class LpNorm(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[[1.0, 2.0], [3.0, 4.0]], [[5.0, 6.0], [7.0, 8.0]]]).astype(np.float32))
         >>> op = ops.LpNorm(axis=[0, 1], p=2, keep_dims=False)
         >>> output = op(input_x)
@@ -1451,7 +1553,7 @@ class LpNorm(Primitive):
         self.init_prim_io_names(inputs=['input'], outputs=['output'])
 
 
-class MatMul(PrimitiveWithCheck):
+class MatMul(Primitive):
     r"""
     Multiplies matrix `a` and matrix `b`.
 
@@ -1463,22 +1565,24 @@ class MatMul(PrimitiveWithCheck):
 
     Note:
         If :math:`N * M` cannot be divided by 16, the performance will be poor in ascend environment.
+        The dtype of inputs must be same.
 
     Args:
-        transpose_a (bool): If true, `a` is transposed before multiplication. Default: False.
-        transpose_b (bool): If true, `b` is transposed before multiplication. Default: False.
+        transpose_a (bool): If ``True`` , `a` is transposed before multiplication. Default: ``False`` .
+        transpose_b (bool): If ``True`` , `b` is transposed before multiplication. Default: ``False`` .
 
     Inputs:
         - **a** (Tensor) - The first tensor to be multiplied. The shape of the tensor is :math:`(N, C)`. If
-          `transpose_a` is True, its shape must be :math:`(C, N)` after transpose.
+          `transpose_a` is ``True`` , its shape must be :math:`(C, N)` after transpose.
         - **b** (Tensor) - The second tensor to be multiplied. The shape of the tensor is :math:`(C, M)`. If
-          `transpose_b` is True, its shape must be :math:`(M, C)` after transpose.
+          `transpose_b` is ``True`` , its shape must be :math:`(M, C)` after transpose.
 
     Outputs:
         Tensor, the shape of the output tensor is :math:`(N, M)`.
 
     Raises:
         TypeError: If `transpose_a` or `transpose_b` is not a bool.
+        TypeError: If the dtype of `a` and the dtype of `b` are not the same.
         ValueError: If the column of matrix dimensions of `a` is not equal to
                     the row of matrix dimensions of `b`.
         ValueError: If length of shape of `a` or `b` is not equal to 2.
@@ -1487,6 +1591,9 @@ class MatMul(PrimitiveWithCheck):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> a = Tensor(np.ones(shape=[1, 3]), mindspore.float32)
         >>> b = Tensor(np.ones(shape=[3, 4]), mindspore.float32)
         >>> matmul = ops.MatMul()
@@ -1505,40 +1612,6 @@ class MatMul(PrimitiveWithCheck):
         self.add_prim_attr('transpose_x1', self.transpose_a)
         self.add_prim_attr('transpose_x2', self.transpose_b)
 
-    def check_shape_size(self, x1, x2):
-        if len(x1) != 2 or len(x2) != 2:
-            raise ValueError(f"For '{self.name}', inputs 'x', 'y' should have the same dimension size and "
-                             f"be equal to 2, but got the size of 'x': ({len(x1)}) and the size of 'y': ({len(x2)}).")
-
-    def check_shape(self, x1, x2):
-        is_dyn_shape = is_shape_unknown(x1) or is_shape_unknown(x2)
-        if not is_dyn_shape:
-            self.check_shape_size(x1, x2)
-        cls_name = self.name
-
-        # set attribute
-        self.add_prim_attr('transpose_x1', self.transpose_a)
-        self.add_prim_attr('transpose_x2', self.transpose_b)
-
-        if is_dyn_shape:
-            return
-
-        # validate whether last two dims satisfying matrix multiply
-        x1_last = x1[-2:]
-        x2_last = x2[-2:]
-        x1_col = x1_last[not self.transpose_a]
-        x2_row = x2_last[self.transpose_b]
-        if np.all(np.array(x1) != -1) and np.all(np.array(x2) != -1):
-            if x1_col != x2_row:
-                raise ValueError(f"For '{cls_name}', the input dimensions must be equal, but got 'x1_col': {x1_col} "
-                                 f"and 'x2_row': {x2_row}. And 'x' shape {x1}(transpose_a={self.transpose_a}), "
-                                 f"'y' shape {x2}(transpose_b={self.transpose_b}).")
-
-    def check_dtype(self, x1, x2):
-        args = {"x1": x1, "x2": x2}
-        validator.check_tensors_dtypes_same_and_valid(args, mstype.float_type + mstype.int_type
-                                                      + (mstype.complex64, mstype.complex128), self.name)
-
 
 class BatchMatMul(Primitive):
     r"""
@@ -1548,20 +1621,20 @@ class BatchMatMul(Primitive):
 
         \text{output}[..., :, :] = \text{matrix}(x[..., :, :]) * \text{matrix}(y[..., :, :])
 
-    The first input tensor must be not less than `3` and the second input must be not less than `2`.
+    The rank of both two input tensors must be same and not less than `2`.
 
     Args:
-        transpose_a (bool): If true, the last two dimensions of `x` is transposed before multiplication.
-            Default: False.
-        transpose_b (bool): If true, the last two dimensions of `y` is transposed before multiplication.
-            Default: False.
+        transpose_a (bool): If ``True`` , the last two dimensions of `x` is transposed before multiplication.
+            Default: ``False`` .
+        transpose_b (bool): If ``True`` , the last two dimensions of `y` is transposed before multiplication.
+            Default: ``False`` .
 
     Inputs:
         - **x** (Tensor) - The first tensor to be multiplied. The shape of the tensor is :math:`(*B, N, C)`,
           where :math:`*B` represents the batch size which can be multidimensional, :math:`N` and :math:`C` are the
-          size of the last two dimensions. If `transpose_a` is True, its shape must be :math:`(*B, C, N)`.
+          size of the last two dimensions. If `transpose_a` is ``True`` , its shape must be :math:`(*B, C, N)`.
         - **y** (Tensor) - The second tensor to be multiplied. The shape of the tensor is :math:`(*B, C, M)`. If
-          `transpose_b` is True, its shape must be :math:`(*B, M, C)`.
+          `transpose_b` is ``True`` , its shape must be :math:`(*B, M, C)`.
 
     Outputs:
         Tensor, the shape of the output tensor is :math:`(*B, N, M)`.
@@ -1569,12 +1642,15 @@ class BatchMatMul(Primitive):
     Raises:
         TypeError: If `transpose_a` or `transpose_b` is not a bool.
         ValueError: If length of shape of `x` is not equal to length of shape of `y` or
-                    length of shape of `x` is less than 3.
+                    length of shape of inputs is less than 2.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.ones(shape=[2, 4, 1, 3]), mindspore.float32)
         >>> y = Tensor(np.ones(shape=[2, 4, 3, 4]), mindspore.float32)
         >>> batmatmul = ops.BatchMatMul()
@@ -1669,11 +1745,12 @@ class CumSum(Primitive):
 
     Args:
         exclusive (bool): By default, this op performs an inclusive cumsum, which means that the first
-            element of the input is identical to the first element of the output. Default: False.
-        reverse (bool): If true, perform inverse cumulative sum. Default: False.
+            element of the input is identical to the first element of the output. Default: ``False`` .
+        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)).
 
@@ -1688,6 +1765,8 @@ class CumSum(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[3, 4, 6, 10], [1, 6, 7, 9], [4, 3, 8, 7], [1, 3, 7, 9]]).astype(np.float32))
         >>> cumsum = ops.CumSum()
         >>> # case 1: along the axis 0
@@ -1738,10 +1817,20 @@ class AddN(Primitive):
 
     Refer to :func:`mindspore.ops.addn` for more details.
 
+    Inputs:
+        - **x** (Union(tuple[Tensor], list[Tensor])) - A tuple or list composed of Tensor, the data type is
+          boolean or numeric.
+
+    Outputs:
+        Tensor, has the same shape and dtype as each Tensor of `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, nn, ops
         >>> class NetAddN(nn.Cell):
         ...     def __init__(self):
         ...         super(NetAddN, self).__init__()
@@ -1779,10 +1868,21 @@ class AccumulateNV2(Primitive):
 
     Refer to :func:`mindspore.ops.accumulate_n` for more details.
 
+    Inputs:
+        - **x** (Union(tuple[Tensor], list[Tensor])) - The input tuple or list
+          is made up of multiple tensors whose dtype is number to be added together.
+          Each element of tuple or list should have the same shape.
+
+    Outputs:
+        Tensor, has the same shape and dtype as each entry of the `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, nn
         >>> class NetAccumulateNV2(nn.Cell):
         ...     def __init__(self):
         ...         super(NetAccumulateNV2, self).__init__()
@@ -1821,10 +1921,19 @@ class Neg(Primitive):
 
     Refer to :func:`mindspore.ops.neg` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input tensor whose dtype is Number.
+
+    Outputs:
+        Tensor, has the same shape and dtype as input.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> neg = ops.Neg()
         >>> x = Tensor(np.array([1, 2, -1, 2, 0, -3.5]), mindspore.float32)
         >>> output = neg(x)
@@ -1847,6 +1956,17 @@ class InplaceUpdateV2(Primitive):
 
     Refer to :func:`mindspore.ops.inplace_update` for more details.
 
+    Inputs:
+        - **x** (Tensor) - A tensor which to be inplace updated. It can be one of the following data types:
+          float32, float16 and int32.
+        - **indices** (Union[int, tuple]): Indices into the left-most dimension of `x`, and determines which rows of x
+          to update with v. It is an int or tuple, whose value is in [0, the first dimension size of x).
+        - **v** (Tensor) - A tensor with the same type as `x` and the same dimension size as `x` except
+          the first dimension, which must be the same as the size of `indices`.
+
+    Outputs:
+        Tensor, with the same type and shape as the input `x`.
+
     Supported Platforms:
         ``GPU`` ``CPU``
 
@@ -1876,33 +1996,25 @@ 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`.
 
     Refer to :func:`mindspore.ops.inplace_add` for more details.
 
+    Args:
+        indices (Union[int, tuple]): Indices into the left-most dimension of `x`, and determines which rows of `x`
+            to add with `v`. It is an integer or a tuple, whose value is in [0, the first dimension size of `x`).
+
+    Inputs:
+        - **x** (Tensor) - The tensor to be added. It has shape :math:`(N,*)` where :math:`*` means
+          any number of additional dimensions.
+        - **input_v** (Tensor) - The value tensor add to `x`. It has the same dimension sizes as `x` except
+          the first dimension, whose size must be the same as `indices`. It has the same data type with `x`.
+
+    Outputs:
+        Tensor, has the same shape and dtype as `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -1942,10 +2054,28 @@ class InplaceIndexAdd(Primitive):
 
     Refer to :func:`mindspore.ops.inplace_index_add` for more details.
 
+    Args:
+        axis (int): The dimension along which to index. It should be in range :math:`[0, len(var.dim))`.
+
+    Inputs:
+        - **var** (Parameter) - The input Parameter to add to, with data type uint8, int8, int16, int32,
+          float16, float32, float64.
+        - **indices** (Tensor) - The indies along `axis` to perform the addition. A 1D Tensor
+          of shape :math:`(updates.shape[axis],)`, every value of it
+          should be in range :math:`[0, var.shape[axis])` with data type int32.
+        - **updates** (Tensor) - The input Tensor with the value to add. Must have same data type as `var`.
+          The shape must be the same as `var` except the `axis` th dimension.
+
+    Outputs:
+        Tensor, updated result, has the same shape and dtype as `var`.
+
     Supported Platforms:
         ``Ascend`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops, Parameter
         >>> var = Parameter(Tensor(np.array([[1, 2], [3, 4], [5, 6]]), mindspore.float32))
         >>> indices = Tensor(np.array([0, 1]), mindspore.int32)
         >>> updates = Tensor(np.array([[0.5, 1.0], [1.0, 1.5]]), mindspore.float32)
@@ -1977,6 +2107,19 @@ class InplaceSub(Primitive):
 
     Refer to :func:`mindspore.ops.inplace_sub` for more details.
 
+    Args:
+        indices (Union[int, tuple]): Indices into the left-most dimension of `x`, and determines which rows of `x`
+            to subtract by `v`. It is an integer or a tuple, whose value is in [0, the first dimension size of `x`).
+
+    Inputs:
+        - **x** (Tensor) - The tensor to be subtracted. It has shape :math:`(N,*)` where :math:`*` means
+          any number of additional dimensions.
+        - **input_v** (Tensor) - The value tensor subtract from `x`. It has the same dimension sizes as `x` except
+          the first dimension, whose size must be the same as `indices`. It has the same data type with `x`.
+
+    Outputs:
+        Tensor, has the same shape and dtype as `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -2014,10 +2157,34 @@ class Sub(_MathBinaryOp):
 
     Refer to :func:`mindspore.ops.sub` for more details.
 
+    Note:
+        - One of the two inputs must be a Tensor, when the two inputs have different shapes,
+          they must be able to broadcast to a common shape.
+        - The two inputs can not be bool type at the same time,
+          [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.
+
+    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.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.
+
+    Outputs:
+        Tensor, the shape is the same as the two inputs after broadcasting,
+        and the data type is the one with higher precision or higher digits among the two inputs.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1, 2, 3]), mindspore.int32)
         >>> y = Tensor(np.array([4, 5, 6]), mindspore.int32)
         >>> sub = ops.Sub()
@@ -2042,10 +2209,34 @@ class Mul(_MathBinaryOp):
 
     Refer to :func:`mindspore.ops.mul` for more details.
 
+    Note:
+        - One of the two inputs must be a Tensor, when the two inputs have different shapes,
+          they must be able to broadcast to a common shape.
+        - The two inputs can not be bool type at the same time,
+          [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.
+
+    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.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.
+
+    Outputs:
+        Tensor, the shape is the same as the one after broadcasting,
+        and the data type is the one with higher precision or higher digits among the two inputs.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
         >>> y = Tensor(np.array([4.0, 5.0, 6.0]), mindspore.float32)
         >>> mul = ops.Mul()
@@ -2134,6 +2325,9 @@ class SquaredDifference(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
         >>> y = Tensor(np.array([2.0, 4.0, 6.0]), mindspore.float32)
         >>> squared_difference = ops.SquaredDifference()
@@ -2158,10 +2352,10 @@ class Square(Primitive):
         out_{i} = (x_{i})^2
 
     Inputs:
-        - **x** (Tensor) - The input tensor with a dtype of Number, its rank must be in [0, 7] inclusive.
+        - **x** (Tensor) - The input tensor.
 
     Outputs:
-        Tensor, has the same shape and dtype as the `x`.
+        Tensor, has the same shape and dtype as `x`.
 
     Raises:
         TypeError: If `x` is not a Tensor.
@@ -2170,6 +2364,9 @@ class Square(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
         >>> square = ops.Square()
         >>> output = square(x)
@@ -2187,24 +2384,21 @@ class Rsqrt(Primitive):
     r"""
     Computes reciprocal of square root of input tensor element-wise.
 
-    .. math::
-
-        out_{i} =  \frac{1}{\sqrt{x_{i}}}
+    Refer to :func:`mindspore.ops.rsqrt` for more details.
 
     Inputs:
-        - **x** (Tensor) - The input of Rsqrt. Its rank must be in [0, 7] inclusive and
-          each element must be a non-negative number.
+        - **x** (Tensor) - The input Tensor, each element must be a non-negative,
+          if an element is negative, the calculation result is nan.
 
     Outputs:
         Tensor, has the same type and shape as `x`.
 
-    Raises:
-        TypeError: If `x` is not a Tensor.
-
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> input_tensor = Tensor([[4, 4], [9, 9]], mindspore.float32)
         >>> rsqrt = ops.Rsqrt()
         >>> output = rsqrt(input_tensor)
@@ -2231,8 +2425,7 @@ class Sqrt(Primitive):
         out_{i} =  \sqrt{x_{i}}
 
     Inputs:
-        - **x** (Tensor) - The input tensor with a dtype of Number, the shape is :math:`(N, *)`
-          where :math:`*` means, any number of additional dimensions.
+        - **x** (Tensor) - The input tensor.
 
     Outputs:
         Tensor, has the same shape and data type as the `x`.
@@ -2244,6 +2437,9 @@ class Sqrt(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1.0, 4.0, 9.0]), mindspore.float32)
         >>> sqrt = ops.Sqrt()
         >>> output = sqrt(x)
@@ -2267,7 +2463,6 @@ class Reciprocal(PrimitiveWithCheck):
 
     Inputs:
         - **x** (Tensor) - The input tensor.
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
 
     Outputs:
         Tensor, has the same shape as the `x`.
@@ -2279,6 +2474,9 @@ class Reciprocal(PrimitiveWithCheck):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
         >>> reciprocal = ops.Reciprocal()
         >>> output = reciprocal(x)
@@ -2310,10 +2508,26 @@ class Pow(Primitive):
 
     Refer to :func:`mindspore.ops.pow` for more details.
 
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
+    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.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\_.
+
+    Outputs:
+        Tensor, the shape is the same as the one after broadcasting,
+        and the data type is the one with higher precision or higher digits among the two inputs.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
         >>> y = 3.0
         >>> pow = ops.Pow()
@@ -2352,10 +2566,19 @@ class Exp(Primitive):
 
     Refer to :func:`mindspore.ops.exp` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input tensor.
+
+    Outputs:
+        Tensor, has the same shape and dtype as the `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([0.0, 1.0, 3.0]), mindspore.float32)
         >>> exp = ops.Exp()
         >>> output = exp(x)
@@ -2382,10 +2605,10 @@ class Logit(Primitive):
     Refer to :func:`mindspore.ops.logit` for more details.
 
     Args:
-        eps (float, optional): The epsilon. The input clamp bound is defined as [eps, 1-eps]. Default: -1.0.
+        eps (float, optional): The epsilon. The input clamp bound is defined as [eps, 1-eps]. Default: ``-1.0`` .
 
     Inputs:
-        - **x** (Tensor) - The input tensor.
+        - **x** (Tensor) - The input tensor of type float16, float32 or float64.
 
     Outputs:
         Tensor, with the same shape and dtype as the `x`.
@@ -2394,6 +2617,8 @@ class Logit(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([0.1, 0.2, 0.3]).astype(np.float32))
         >>> op = ops.Logit(eps=1e-5)
         >>> output = op(x)
@@ -2416,20 +2641,21 @@ class ReduceStd(Primitive):
 
     Args:
         axis (Union[int, tuple(int), list(int)], optional): The dimensions to reduce.
-            Default: (), reduce all dimensions. Only constant value is allowed.
+            Default: ``()`` , reduce all dimensions. Only constant value is allowed.
             Let `r` be rank of `input_x`, it should be in the range :math:`[-r,r)`.
-        unbiased (bool, optional):  Whether to use Bessel’s correction.
-            If True, will use the Bessel correction unbiased estimation.
-            If False, will through the biased estimation to calculate the standard deviation.
-            Default: True.
+        unbiased (bool, optional):  Whether to use Bessel's correction.
+            If ``True`` , will use the Bessel correction unbiased estimation.
+            If ``False`` , will through the biased estimation to calculate the standard deviation.
+            Default: ``True`` .
         keep_dims (bool, optional): Whether the output Tensor has dim retained or not.
-            If True, keep these reduced dimensions specified by `axis` and the length is 1.
-            If False, don't keep these dimensions.
-            Default: Fasle.
+            If ``True`` , keep these reduced dimensions specified by `axis` and the length is 1.
+            If ``False`` , don't keep these dimensions.
+            Default: ``Fasle`` .
 
     Inputs:
-        - **input_x** (Tensor[Number]) - The input Tensor, it has dtype Number with shape
+        - **input_x** (Tensor[Number]) - The input Tensor with shape
           :math:`(N, *)` where :math:`*` means any number of additional dimensions.
+          Supported dtypes: float16, float32.
 
     Outputs:
         Tuple(output_std, output_mean) containing the standard deviation and mean.
@@ -2473,10 +2699,6 @@ class Einsum(Primitive):
     dimensions specified notation based on the Einstein summation convention(Einsum).
     You can use this operator to perform diagonal/reducesum/transpose/matmul/mul/inner product operations, etc.
 
-    The inputs must be a tuple of tensors.
-    When the inputs are only one tensor, you can input (tensor, )
-    dtypes of them should be float16/float32/float64.
-
     Args:
         equation (str): An attribute, represent the operation you want to do.
             the value can contain only letters([a-z][A-Z]), commas(,), ellipsis(...),
@@ -2487,7 +2709,10 @@ class Einsum(Primitive):
             and the right of it indicates the desired output dimension.
 
     Inputs:
-        - **x** (Tuple) - input tensor used for calculation. the data type of the tensor must be the same.
+        - **x** () - Input tensor used for calculation.
+          The inputs must be a tuple/list of Tensors.
+          When the inputs are only one tensor, you can input (tensor, ).
+          Dtypes of them should be float16/float32/float64 and dtype of the tensor(s) must be the same.
 
     Outputs:
         Tensor, the shape of it can be obtained from the equation,
@@ -2495,11 +2720,15 @@ class Einsum(Primitive):
 
     Raises:
         TypeError: If equation itself is invalid, or the equation does not match the input tensor.
+        TypeError: If dtype of the input Tensors are not the same or dtype is not float16, float32 or float64.
 
     Supported Platforms:
         ``GPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
         >>> equation = "i->"
         >>> einsum = ops.Einsum(equation)
@@ -2565,7 +2794,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'])
 
 
@@ -2580,9 +2808,9 @@ class Diagonal(Primitive):
         offset (int): The offset of main diagonal, which controls which diagonal to consider. If :math:`offset=0`,
             return the main diagonal elements with respect to dim1 and dim2. If :math:`offset>0`, return the
             diagonal elements that are `offset` units upward from the main diagonal. If :math:`offset<0`, return the
-            diagonal elements that are `offset` units downward from the main diagonal. Default: 0.
-        dim1 (int): The first dimension with respect to which to take diagonal. Default: 0.
-        dim2 (int): The second dimension with respect to which to take diagonal. Default: 1.
+            diagonal elements that are `offset` units downward from the main diagonal. Default: ``0`` .
+        dim1 (int): The first dimension with respect to which to take diagonal. Default: ``0`` .
+        dim2 (int): The second dimension with respect to which to take diagonal. Default: ``1`` .
 
     Inputs:
         - **x** (Tensor) - The input to take diagonal, with float32 or double data type.
@@ -2637,10 +2865,19 @@ class Expm1(Primitive):
 
     Refer to :func:`mindspore.ops.expm1` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input tensor.
+
+    Outputs:
+        Tensor, has the same shape and dtype as `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([0.0, 2.0, 3.0, 5.0]), mindspore.float32)
         >>> expm1 = ops.Expm1()
         >>> output = expm1(x)
@@ -2664,9 +2901,9 @@ class Histogram(Primitive):
     Elements lower than min and higher than max are ignored.
 
     Args:
-        bins (int, optional): Number of histogram bins, optional. Default 100. If specified, must be positive.
-        min (float, optional): An optional float of the lower end of the range (inclusive). Default value is 0.0.
-        max (float, optional): An optional float of the upper end of the range (inclusive). Default value is 0.0.
+        bins (int, optional): Number of histogram bins, optional. Default: ``100`` . If specified, must be positive.
+        min (float, optional): An optional float of the lower end of the range (inclusive). Default value is ``0.0`` .
+        max (float, optional): An optional float of the upper end of the range (inclusive). Default value is ``0.0`` .
 
     Inputs:
         - **x** (Tensor) - the input tensor, type support list: [float16, float32, int32].
@@ -2711,7 +2948,7 @@ class HistogramFixedWidth(PrimitiveWithInfer):
 
     Args:
         nbins (int): The number of histogram bins, the type is a positive integer.
-        dtype (str, optional): An optional attribute. The dtype must be str. Default: "int32".
+        dtype (str, optional): An optional attribute. The dtype must be str. Default: ``'int32'`` .
 
     Inputs:
         - **x** (Tensor) - Numeric Tensor. Must be one of the following types: int32, float32, float16.
@@ -2730,6 +2967,8 @@ class HistogramFixedWidth(PrimitiveWithInfer):
         ``Ascend`` ``GPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor([-1.0, 0.0, 1.5, 2.0, 5.0, 15], mindspore.float16)
         >>> range_op = Tensor([0.0, 5.0], mindspore.float16)
         >>> hist = ops.HistogramFixedWidth(5)
@@ -2755,10 +2994,19 @@ class Log(Primitive):
 
     Refer to :func:`mindspore.ops.log` for more details.
 
+    Inputs:
+        - **x** (Tensor) - Input Tensor of any dimension. The value must be greater than 0.
+
+    Outputs:
+        Tensor, has the same shape and dtype as the `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
         >>> log = ops.Log()
         >>> output = log(x)
@@ -2782,10 +3030,19 @@ class Log1p(Primitive):
 
     Refer to :func:`mindspore.ops.log1p` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input tensor. The value must be greater than -1.
+
+    Outputs:
+        Tensor, has the same shape as the `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
         >>> log1p = ops.Log1p()
         >>> output = log1p(x)
@@ -2824,12 +3081,21 @@ class Hypot(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x1 = Tensor(np.array([3., 5., 7.]))
         >>> x2 = Tensor(np.array([4., 12., 24.]))
         >>> hypot_ = ops.Hypot()
         >>> y = hypot_(x1, x2)
         >>> print(y)
         [ 5. 13. 25.]
+        >>> x1 = Tensor(2.1, mindspore.float32)
+        >>> x2 = Tensor(2.1, mindspore.float32)
+        >>> hypot_ = ops.Hypot()
+        >>> y = hypot_(x1, x2)
+        >>> print(y)
+        2.9698484
     """
 
     __mindspore_signature__ = (sig.sig_dtype.T, sig.sig_dtype.T)
@@ -2870,6 +3136,8 @@ class Heaviside(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([-1.5, 0., 2.]))
         >>> values = Tensor(np.array([0.5]))
         >>> heaviside = ops.Heaviside()
@@ -2889,10 +3157,22 @@ class Erf(Primitive):
 
     Refer to :func:`mindspore.ops.erf` for more details.
 
+    Inputs:
+        - **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`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([-1, 0, 1, 2, 3]), mindspore.float32)
         >>> erf = ops.Erf()
         >>> output = erf(x)
@@ -2912,10 +3192,22 @@ class Erfc(Primitive):
 
     Refer to :func:`mindspore.ops.erfc` for more details.
 
+    Inputs:
+        - **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`.
+
     Supported Platforms:
         ``Ascend`` ``GPU``  ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([-1, 0, 1, 2, 3]), mindspore.float32)
         >>> erfc = ops.Erfc()
         >>> output = erfc(x)
@@ -2935,10 +3227,23 @@ class Minimum(_MathBinaryOp):
 
     Refer to :func:`mindspore.ops.minimum` for more details.
 
+    Inputs:
+        - **x** (Union[Tensor, Number, bool]) - The first input is a number or
+          a bool or a tensor whose data type is number or bool.
+        - **y** (Union[Tensor, Number, bool]) - The second input is a number or
+          a bool when the first input is a tensor or a tensor whose data type is number or bool.
+
+    Outputs:
+        Tensor, the shape is the same as the one after broadcasting,
+        and the data type is the one with higher precision or higher digits among the two inputs.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> # case 1 : same data type
         >>> x = Tensor(np.array([1.0, 5.0, 3.0]), mindspore.float32)
         >>> y = Tensor(np.array([4.0, 2.0, 6.0]), mindspore.float32)
@@ -2970,10 +3275,23 @@ class Maximum(_MathBinaryOp):
 
     Refer to :func:`mindspore.ops.maximum` for more details.
 
+    Inputs:
+        - **x** (Union[Tensor, Number, bool]) - The first input is a number or
+          a bool or a tensor whose data type is number or bool.
+        - **y** (Union[Tensor, Number, bool]) - The second input is a number or
+          a bool when the first input is a tensor or a tensor whose data type is number or bool.
+
+    Outputs:
+        Tensor, the shape is the same as the one after broadcasting,
+        and the data type is the one with higher precision or higher digits among the two inputs.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> # case 1 : same data type
         >>> x = Tensor(np.array([1.0, 5.0, 3.0]), mindspore.float32)
         >>> y = Tensor(np.array([4.0, 2.0, 6.0]), mindspore.float32)
@@ -3010,6 +3328,9 @@ class RealDiv(_MathBinaryOp):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
         >>> y = Tensor(np.array([4.0, 5.0, 6.0]), mindspore.float32)
         >>> realdiv = ops.RealDiv()
@@ -3032,38 +3353,36 @@ class Div(_MathBinaryOp):
     r"""
     Computes the quotient of dividing the first input tensor by the second input tensor element-wise.
 
-    .. math::
-
-        out_{i} = \frac{x_i}{y_i}
+    Refer to :func:`mindspore.ops.div` for more details.
 
     Note:
-        - Inputs of `x` and `y` comply with the implicit type conversion rules to make the data types consistent.
-        - The inputs must be two tensors or one tensor and one scalar.
-        - When the inputs are two tensors,
-          dtypes of them cannot be bool at the same time, and the shapes of them can be broadcast.
-        - When the inputs are one tensor and one scalar, the scalar could only be a constant.
+        - One of the two inputs must be a Tensor, when the two inputs have different shapes,
+          they must be able to broadcast to a common shape.
+        - The two inputs can not be bool type at the same time,
+          [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.
 
     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.0/api_python/mindspore.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/r2.0/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\_.
+          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.
 
     Outputs:
         Tensor, the shape is the same as the one of the input `x` , `y` after broadcasting,
         and the data type is the one with higher precision or higher digits among the two inputs.
 
-    Raises:
-        TypeError: If neither `x` nor `y` is a Tensor.
-        TypeError: If data types of `x` and `y` are both Tensor with bool\_.
-
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> # case 1 :has same data type and shape of the two inputs
         >>> x = Tensor(np.array([-4.0, 5.0, 6.0]), mindspore.float32)
         >>> y = Tensor(np.array([3.0, 2.0, 3.0]), mindspore.float32)
@@ -3138,14 +3457,12 @@ 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.0/api_python/mindspore.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/r2.0/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\_.
 
-
     Outputs:
         Tensor, the shape is the same as the one after broadcasting,
         and the data type is the one with higher precision or higher digits among the two inputs.
@@ -3157,6 +3474,9 @@ class DivNoNan(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x1 = Tensor(np.array([-1.0, 0., 1.0, 5.0, 6.0]), mindspore.float32)
         >>> x2 = Tensor(np.array([0., 0., 0., 2.0, 3.0]), mindspore.float32)
         >>> div_no_nan = ops.DivNoNan()
@@ -3209,6 +3529,9 @@ class MulNoNan(_MathBinaryOp):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> # case 1 : same data type and shape of two inputs, there are some 0 in y.
         >>> x = Tensor(np.array([[-1.0, 6.0, np.inf], [np.nan, -7.0, 4.0]]), mindspore.float32)
         >>> y = Tensor(np.array([[-1.0, 4.0, 0], [0, -3.0, 1.0]]), mindspore.float32)
@@ -3247,16 +3570,35 @@ class FloorDiv(Primitive):
 
     Refer to :func:`mindspore.ops.floor_div` for more details.
 
+    Inputs:
+        - **x** (Union[Tensor, Number, bool]) - The first input is a Number or
+          a bool or a tensor whose data type is Number or bool.
+        - **y** (Union[Tensor, Number, bool]) - The second input is a Number or
+          a bool when the first input is a tensor or a tensor whose data type is Number or bool.
+
+    Outputs:
+        Tensor, the shape is the same as the one after broadcasting,
+        and the data type is the one with higher precision or higher digits among the two inputs.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([2, 4, -1]), mindspore.int32)
         >>> y = Tensor(np.array([3, 3, 3]), mindspore.int32)
         >>> floor_div = ops.FloorDiv()
         >>> output = floor_div(x, y)
         >>> print(output)
         [ 0  1 -1]
+        >>> x = Tensor(2.0, mindspore.float32)
+        >>> y = Tensor(2.0, mindspore.float32)
+        >>> floor_div = ops.FloorDiv()
+        >>> output = floor_div(x, y)
+        >>> print(output)
+        1.0
     """
     __mindspore_signature__ = (sig.sig_dtype.T, sig.sig_dtype.T)
 
@@ -3298,6 +3640,9 @@ class TruncateDiv(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([2, 4, -1]), mindspore.int32)
         >>> y = Tensor(np.array([3, 3, 3]), mindspore.int32)
         >>> truncate_div = ops.TruncateDiv()
@@ -3330,7 +3675,7 @@ class TruncateMod(Primitive):
         - When the elements of input exceed 2048, the accuracy of operator cannot guarantee the requirement of
           double thousandths in the mini form.
         - Due to different architectures, the calculation results of this operator on NPU and CPU may be inconsistent.
-        - If shape is expressed as :math:`(D1, D2, ..., Dn)`, then :math:`D1*D2... *DN<=1000000,n<=8`.
+        - If shape is expressed as (D1,D2... ,Dn), then D1\*D2... \*DN<=1000000,n<=8.
 
     Inputs:
         - **x** (Union[Tensor, numbers.Number, bool]) - The first input is a number, or a bool,
@@ -3351,6 +3696,9 @@ class TruncateMod(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([2, 4, -1]), mindspore.int32)
         >>> y = Tensor(np.array([3, 3, 3]), mindspore.int32)
         >>> truncate_mod = ops.TruncateMod()
@@ -3384,7 +3732,7 @@ class Mod(_MathBinaryOp):
         - When the elements of input exceed 2048, the accuracy of operator cannot guarantee the requirement of
           double thousandths in the mini form.
         - Due to different architectures, the calculation results of this operator on NPU and CPU may be inconsistent.
-        - If shape is expressed as :math:`(D1,D2... ,Dn)`, then :math:`D1*D2... *DN<=1000000,n<=8`.
+        - If shape is expressed as :math:`(D1, D2, ..., Dn)`, then :math:`D1*D2... *DN<=1000000,n<=8`.
 
     Inputs:
         - **x** (Union[Tensor, numbers.Number, bool]) - The first input is a number, a bool
@@ -3407,6 +3755,9 @@ class Mod(_MathBinaryOp):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([-4.0, 5.0, 6.0]), mindspore.float32)
         >>> y = Tensor(np.array([3.0, 2.0, 3.0]), mindspore.float32)
         >>> mod = ops.Mod()
@@ -3429,10 +3780,22 @@ class Floor(Primitive):
 
     Refer to :func:`mindspore.ops.floor` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input tensor. Supported dtypes:
+
+          - Ascend: float16, float32.
+          - GPU/CPU: float16, float32, float64.
+
+    Outputs:
+        Tensor, has the same shape as `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1.1, 2.5, -1.5]), mindspore.float32)
         >>> floor = ops.Floor()
         >>> output = floor(x)
@@ -3452,10 +3815,23 @@ class FloorMod(Primitive):
 
     Refer to :func:`mindspore.ops.floor_mod` for more details.
 
+    Inputs:
+        - **x** (Union[Tensor, Number, bool]) - The first input is a number or
+          a bool or a tensor whose data type is number or bool.
+        - **y** (Union[Tensor, Number, bool]) -  The second input is a number or
+          a bool when the first input is a tensor, or it can be a tensor whose data type is number or bool.
+
+    Outputs:
+        Tensor, the shape is the same as the one after broadcasting,
+        and the data type is the one with higher precision of the two inputs.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([2, 4, -1]), mindspore.int32)
         >>> y = Tensor(np.array([3, 3, 3]), mindspore.int32)
         >>> floor_mod = ops.FloorMod()
@@ -3478,15 +3854,28 @@ class Ceil(PrimitiveWithInfer):
 
     Refer to :func:`mindspore.ops.ceil` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input tensor with a dtype of float16 or float32.
+
+    Outputs:
+        Tensor, has the same shape as `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1.1, 2.5, -1.5]), mindspore.float32)
         >>> ceil_op = ops.Ceil()
         >>> output = ceil_op(x)
         >>> print(output)
         [ 2.  3. -1.]
+        >>> x = Tensor(2.1, mindspore.float32)
+        >>> output = ceil_op(x)
+        >>> print(output)
+        3.0
     """
 
     @prim_attr_register
@@ -3528,6 +3917,9 @@ class Xdivy(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([2, 4, -1]), mindspore.float32)
         >>> y = Tensor(np.array([2, 2, 2]), mindspore.float32)
         >>> xdivy = ops.Xdivy()
@@ -3593,10 +3985,26 @@ class Xlogy(Primitive):
 
     Refer to :func:`mindspore.ops.xlogy` for more details.
 
+    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.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\_.
+
+    Outputs:
+        Tensor, the shape is the same as the one after broadcasting,
+        and the data type is the one with higher precision or higher digits among the two inputs.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([-5, 0, 4]), mindspore.float32)
         >>> y = Tensor(np.array([2, 2, 2]), mindspore.float32)
         >>> xlogy = ops.Xlogy()
@@ -3618,6 +4026,12 @@ class Acosh(Primitive):
 
     Refer to :func:`mindspore.ops.acosh` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input Tensor. Input value must be in range [1, inf].
+
+    Outputs:
+        Tensor, has the same shape and type as `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -3630,6 +4044,10 @@ class Acosh(Primitive):
         >>> output = acosh(x)
         >>> print(output)
         [0.        0.9624237 1.7627472 5.298292 ]
+        >>> x = Tensor(2.6)
+        >>> output = acosh(x)
+        >>> print(output)
+        1.609438
     """
 
     @prim_attr_register
@@ -3644,15 +4062,28 @@ class Cosh(Primitive):
 
     Refer to :func:`mindspore.ops.cosh` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input Tensor.
+
+    Outputs:
+        Tensor, has the same shape and dtype as `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> cosh = ops.Cosh()
         >>> x = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
         >>> output = cosh(x)
         >>> print(output)
         [1.0289385 1.364684 1.048436 1.0040528]
+        >>> x = Tensor(2.1, mindspore.float32)
+        >>> output = cosh(x)
+        >>> print(output)
+        4.144313
     """
 
     @prim_attr_register
@@ -3666,10 +4097,19 @@ class Asinh(Primitive):
 
     Refer to :func:`mindspore.ops.asinh` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input Tensor, its rank should be less than 8.
+
+    Outputs:
+        Tensor, has the same shape and type as `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> asinh = ops.Asinh()
         >>> x = Tensor(np.array([-5.0, 1.5, 3.0, 100.0]), mindspore.float32)
         >>> output = asinh(x)
@@ -3722,6 +4162,9 @@ class Sinh(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> sinh = ops.Sinh()
         >>> x = Tensor(np.array([0.62, 0.28, 0.43, 0.62]), mindspore.float32)
         >>> output = sinh(x)
@@ -3744,7 +4187,7 @@ class _LogicBinaryOp(_BinaryOp):
         """Staticmethod of infer dtype for _LogicBinaryOp."""
         args_dtype = {"x": x_dtype, "y": y_dtype}
         validator.check_tensors_dtypes_same_and_valid(args_dtype, valid_type, prim_name)
-        return mstype.tensor_type(mstype.bool_)
+        return mstype.TensorType(mstype.bool_)
 
     def infer_dtype(self, x_dtype, y_dtype):
         return _LogicBinaryOp.do_infer_dtype(x_dtype, y_dtype, prim_name=self.name)
@@ -3757,6 +4200,21 @@ class Quantile(Primitive):
 
     Refer to :func:`mindspore.ops.quantile` and :func:`mindspore.ops.nanquantile` for more details.
 
+    Args:
+        dim (int, optional): The dimension to reduce. By default, `axis` is ``None`` resulting in the
+            input tensor being flattened before computation. Default: ``None`` .
+        keep_dims (bool, optional): Whether the output tensor has dim retained or not. Default: ``False`` .
+        ignore_nan (bool, optional): Whether to ignore NaN values in the input. Default: ``False`` .
+
+    Inputs:
+        - **input** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+          Supported dtypes: float32, float64.
+        - **q** (Union[float, Tensor]) - A scalar or 1D tensor of quantile values in the range [0, 1].
+          Supported dtypes: float32, float64.
+
+    Outputs:
+        Tensor, has the same dtype as the `input`.
+
     Supported Platforms:
 
 
@@ -3792,10 +4250,23 @@ class Equal(Primitive):
 
     Refer to :func:`mindspore.ops.equal` for more details.
 
+    Inputs:
+        - **x** (Union[Tensor, Number]) - The first input is a Number or
+          a tensor whose data type is Number.
+        - **y** (Union[Tensor, Number]) - The second input is a Number
+          when the first input is a tensor or a tensor whose data type is Number.
+          The data type is the same as the first input.
+
+    Outputs:
+        Tensor, it has the same shape as the `x` and `y` after broadcasting, and the data type is bool.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> # case 1: The shape of two inputs are different
         >>> x = Tensor(np.array([1, 2, 3]), mindspore.float32)
         >>> equal = ops.Equal()
@@ -3821,7 +4292,7 @@ class Equal(Primitive):
 
 class ApproximateEqual(_LogicBinaryOp):
     r"""
-    Returns True if abs(x-y) is smaller than tolerance element-wise, otherwise False.
+    Returns ``True`` if abs(x-y) is smaller than tolerance element-wise, otherwise False.
 
     .. math::
 
@@ -3837,7 +4308,7 @@ class ApproximateEqual(_LogicBinaryOp):
     the relatively highest precision data type.
 
     Args:
-        tolerance (float): The maximum deviation that two elements can be considered equal. Default: 1e-05.
+        tolerance (float): The maximum deviation that two elements can be considered equal. Default: ``1e-05`` .
 
     Inputs:
         - **x** (Tensor) - A tensor. Must be one of the following types: float32, float16.
@@ -3849,13 +4320,16 @@ class ApproximateEqual(_LogicBinaryOp):
 
     Raises:
         TypeError: If `tolerance` is not a float.
-        RuntimeError: If the data type of `x`, `y` conversion of Parameter is given
+        TypeError: If the data type of `x`, `y` conversion of Parameter is given
                       but data type conversion of Parameter is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1, 2, 3]), mindspore.float32)
         >>> y = Tensor(np.array([2, 3, 6]), mindspore.float32)
         >>> approximate_equal = ops.ApproximateEqual(2.)
@@ -3894,6 +4368,9 @@ class EqualCount(PrimitiveWithInfer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1, 2, 3]), mindspore.int32)
         >>> y = Tensor(np.array([1, 2, 4]), mindspore.int32)
         >>> equal_count = ops.EqualCount()
@@ -3914,12 +4391,24 @@ class NotEqual(Primitive):
 
     Refer to :func:`mindspore.ops.ne` for more details.
 
+    Inputs:
+        - **x** (Union[Tensor, Number, bool]) - The first input is a number or
+          a bool or a tensor whose data type is number or bool.
+        - **y** (Union[Tensor, Number, bool]) - The second input is a number or
+          a bool when the first input is a tensor or a tensor whose data type is number or bool.
+
+    Outputs:
+        Tensor, it has the same shape as the `x` and `y` after broadcasting, and the data type is bool.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> x = Tensor(np.array([1, 2, 3]), mindspore.float32)
-        >>> not_equal = ops.NotEqual()
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.array([1, 2, 3]), mindspore.float32)
+        >>> not_equal = ops.NotEqual()
         >>> output = not_equal(x, 2.0)
         >>> print(output)
         [ True False  True]
@@ -3945,10 +4434,25 @@ class Greater(PrimitiveWithCheck):
 
     Refer to :func:`mindspore.ops.gt` for more details.
 
+    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.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\_.
+
+    Outputs:
+        Tensor, the shape is the same as the one after broadcasting, and the data type is bool.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1, 2, 3]), mindspore.int32)
         >>> y = Tensor(np.array([1, 1, 4]), mindspore.int32)
         >>> greater = ops.Greater()
@@ -3976,14 +4480,27 @@ class Greater(PrimitiveWithCheck):
 
 class GreaterEqual(PrimitiveWithCheck):
     r"""
-    Computes the boolean value of :math:`x >= y` element-wise.
+    Given two Tensors, compares them element-wise to check if each element in the first
+    Tensor is greater than or equal to the corresponding element in the second Tensor.
 
     Refer to :func:`mindspore.ops.ge` for more details.
 
+    Inputs:
+        - **x** (Union[Tensor, Number, bool]) - The first input is a number or
+          a bool or a tensor whose data type is number or bool.
+        - **y** (Union[Tensor, Number, bool]) - The second input is a number or
+          a bool when the first input is a tensor or a tensor whose data type is number or bool.
+
+    Outputs:
+        Tensor, the shape is the same as the one after broadcasting, and the data type is bool.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1, 2, 3]), mindspore.int32)
         >>> y = Tensor(np.array([1, 1, 4]), mindspore.int32)
         >>> greater_equal = ops.GreaterEqual()
@@ -4013,7 +4530,7 @@ class Lerp(Primitive):
     Refer to :func:`mindspore.ops.lerp` for more details.
 
     Inputs:
-        - **start** (Tensor) - The tensor with the starting points. Data type must be float16 or float32.
+        - **start** (Tensor) - The tensor with the starting points. Data type must be float16, float32 or float64.
         - **end** (Tensor) - The tensor with the ending points. Data type must be the same as `start`.
         - **weight** (Union[float, Tensor]) - The weight for the interpolation formula. Must be a float
           or a scalar tensor with float16 or float32 data type.
@@ -4025,6 +4542,9 @@ class Lerp(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> start = Tensor(np.array([1., 2., 3., 4.]), mindspore.float32)
         >>> end = Tensor(np.array([10., 10., 10., 10.]), mindspore.float32)
         >>> lerp = ops.Lerp()
@@ -4063,6 +4583,8 @@ class Gcd(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x1 = Tensor(np.array([7, 8, 9]))
         >>> x2 = Tensor(np.array([14, 6, 12]))
         >>> gcd_ = ops.Gcd()
@@ -4084,10 +4606,22 @@ class Less(PrimitiveWithCheck):
 
     Refer to :func:`mindspore.ops.less` for more details.
 
+    Inputs:
+        - **x** (Union[Tensor, Number, bool]) -  The first input is a number or
+          a bool or a tensor whose data type is number or bool.
+        - **y** (Union[Tensor, Number, bool]) - The second input is a number or
+          a bool when the first input is a tensor, or it can be a tensor whose data type is number or bool.
+
+    Outputs:
+        Tensor, the shape is the same as the one after broadcasting,and the data type is bool.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1, 2, 3]), mindspore.int32)
         >>> y = Tensor(np.array([1, 1, 4]), mindspore.int32)
         >>> less = ops.Less()
@@ -4116,10 +4650,25 @@ class LessEqual(PrimitiveWithCheck):
 
     Refer to :func:`mindspore.ops.le` for more details.
 
+    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.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\_.
+
+    Outputs:
+        Tensor, the shape is the same as the one after broadcasting, and the data type is bool.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1, 2, 3]), mindspore.int32)
         >>> y = Tensor(np.array([1, 1, 4]), mindspore.int32)
         >>> less_equal = ops.LessEqual()
@@ -4148,10 +4697,19 @@ class LogicalNot(Primitive):
 
     Refer to :func:`mindspore.ops.logical_not` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input tensor, the dtype must be bool.
+
+    Outputs:
+        Tensor, the shape is the same as the `x`, and the dtype is bool.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([True, False, True]), mindspore.bool_)
         >>> logical_not = ops.LogicalNot()
         >>> output = logical_not(x)
@@ -4171,16 +4729,43 @@ class LogicalAnd(_LogicBinaryOp):
 
     Refer to :func:`mindspore.ops.logical_and` for more details.
 
+    Inputs:
+        - **x** (Union[Tensor, bool]) - The first input is a bool or a tensor whose data type can be implicitly
+          converted to bool.
+        - **y** (Union[Tensor, bool]) - The second input is a bool when the first input is a tensor or
+          a tensor whose data type can be implicitly converted to bool.
+
+    Outputs:
+        Tensor, the shape is the same as the `x` and `y` after broadcasting, and the data type is bool.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([True, False, True]), mindspore.bool_)
         >>> y = Tensor(np.array([True, True, False]), mindspore.bool_)
         >>> logical_and = ops.LogicalAnd()
         >>> output = logical_and(x, y)
         >>> print(output)
         [ True False False]
+        >>> x = Tensor(1, mindspore.bool_)
+        >>> y = Tensor(0, mindspore.bool_)
+        >>> output = ops.LogicalAnd()(x, y)
+        >>> print(output)
+        False
+        >>> x = True
+        >>> y = Tensor(0, mindspore.bool_)
+        >>> output = ops.LogicalAnd()(x, y)
+        >>> print(output)
+        False
+        >>> x = True
+        >>> y = Tensor(np.array([True, False]), mindspore.bool_)
+        >>> output = ops.LogicalAnd()(x, y)
+        >>> print(output)
+        [True False]
     """
 
 
@@ -4190,16 +4775,43 @@ class LogicalOr(_LogicBinaryOp):
 
     Refer to :func:`mindspore.ops.logical_or` for more details.
 
+    Inputs:
+        - **x** (Union[Tensor, bool]) - The first input is a bool or a tensor whose data type can be implicitly
+          converted to bool.
+        - **y** (Union[Tensor, bool]) - The second input is a bool when the first input is a tensor or
+          a tensor whose data type can be implicitly converted to bool.
+
+    Outputs:
+        Tensor, the shape is the same as the `x` and `y` after broadcasting, and the data type is bool.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([True, False, True]), mindspore.bool_)
         >>> y = Tensor(np.array([True, True, False]), mindspore.bool_)
         >>> logical_or = ops.LogicalOr()
         >>> output = logical_or(x, y)
         >>> print(output)
         [ True  True  True]
+        >>> x = Tensor(1, mindspore.bool_)
+        >>> y = Tensor(0, mindspore.bool_)
+        >>> output = ops.LogicalOr()(x, y)
+        >>> print(output)
+        True
+        >>> x = True
+        >>> y = Tensor(0, mindspore.bool_)
+        >>> output = ops.LogicalOr()(x, y)
+        >>> print(output)
+        True
+        >>> x = True
+        >>> y = Tensor(np.array([True, False]), mindspore.bool_)
+        >>> output = ops.LogicalOr()(x, y)
+        >>> print(output)
+        [True True]
     """
 
 
@@ -4212,16 +4824,43 @@ class LogicalXor(Primitive):
 
     Refer to :func:`mindspore.ops.logical_xor` for more details.
 
+    Inputs:
+        - **x** (Union[Tensor, bool]) - The first input is a bool or a tensor whose data type can be implicitly
+          converted to bool.
+        - **y** (Union[Tensor, bool]) - The second input is a bool when the first input is a tensor or
+          a tensor whose data type can be implicitly converted to bool.
+
+    Outputs:
+        Tensor, the shape is the same as the `x` and `y` after broadcasting, and the data type is bool.
+
     Supported Platforms:
         ``Ascend`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([True, False, True]), mindspore.bool_)
         >>> y = Tensor(np.array([True, True, False]), mindspore.bool_)
         >>> logical_xor = ops.LogicalXor()
         >>> output = logical_xor(x, y)
         >>> print(output)
         [ False True True]
+        >>> x = Tensor(1, mindspore.bool_)
+        >>> y = Tensor(0, mindspore.bool_)
+        >>> output = ops.LogicalXor()(x, y)
+        >>> print(output)
+        True
+        >>> x = True
+        >>> y = Tensor(0, mindspore.bool_)
+        >>> output = ops.LogicalXor()(x, y)
+        >>> print(output)
+        True
+        >>> x = True
+        >>> y = Tensor(np.array([True, False]), mindspore.bool_)
+        >>> output = ops.LogicalXor()(x, y)
+        >>> print(output)
+        [False True]
     """
 
     @prim_attr_register
@@ -4236,15 +4875,28 @@ class IsNan(Primitive):
 
     Refer to :func:`mindspore.ops.isnan` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input tensor.
+
+    Outputs:
+        Tensor, has the same shape of input, and the dtype is bool.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> is_nan = ops.IsNan()
         >>> x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32)
         >>> output = is_nan(x)
         >>> print(output)
         [ True False False]
+        >>> x = Tensor(2.1, mindspore.float64)
+        >>> output = is_nan(x)
+        >>> print(output)
+        False
     """
 
     @prim_attr_register
@@ -4259,15 +4911,28 @@ class IsInf(Primitive):
 
     Refer to :func:`mindspore.ops.isinf` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input tensor.
+
+    Outputs:
+        Tensor, has the same shape of input, and the dtype is bool.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> is_inf = ops.IsInf()
         >>> x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32)
         >>> output = is_inf(x)
         >>> print(output)
         [False False True]
+        >>> x = Tensor(2.1, mindspore.float64)
+        >>> output = is_inf(x)
+        >>> print(output)
+        False
     """
 
     @prim_attr_register
@@ -4286,6 +4951,9 @@ class IsFinite(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> is_finite = ops.IsFinite()
         >>> x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32)
         >>> output = is_finite(x)
@@ -4305,7 +4973,7 @@ class FloatStatus(Primitive):
 
     Inputs:
         - **x** (Tensor) - The input tensor. The data type must be float16, float32 or float64.
-          :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
+          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
 
     Outputs:
         Tensor, has the shape of :math:`(1,)`, and the dtype is `mindspore.dtype.float32`.
@@ -4317,6 +4985,9 @@ class FloatStatus(Primitive):
         ``GPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> float_status = ops.FloatStatus()
         >>> x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32)
         >>> result = float_status(x)
@@ -4346,6 +5017,7 @@ class NPUAllocFloatStatus(Primitive):
         ``Ascend``
 
     Examples:
+        >>> from mindspore import ops
         >>> alloc_status = ops.NPUAllocFloatStatus()
         >>> output = alloc_status()
         >>> print(output)
@@ -4355,7 +5027,8 @@ class NPUAllocFloatStatus(Primitive):
     @prim_attr_register
     def __init__(self):
         """Initialize NPUAllocFloatStatus"""
-        logger.warning("The 'NPUAllocFloatStatus' operator will be deprecated in the future. Please don't use it.")
+        logger.warning("The 'NPUAllocFloatStatus' operator will be deprecated in the future, "
+                       "please use 'nn.TrainOneStepWithLossScaleCell' or 'amp.all_finite'.")
 
 
 class NPUGetFloatStatus(Primitive):
@@ -4391,7 +5064,7 @@ class NPUGetFloatStatus(Primitive):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import ops
-        >>> from mindspore.common import dtype as mstype
+        >>> from mindspore import dtype as mstype
         >>> from mindspore.common.tensor import Tensor
         >>> class Net(nn.Cell):
         ...     def __init__(self):
@@ -4425,7 +5098,8 @@ class NPUGetFloatStatus(Primitive):
     @prim_attr_register
     def __init__(self):
         """Initialize NPUGetFloatStatus"""
-        logger.warning("The 'NPUGetFloatStatus' operator will be deprecated in the future. Please don't use it.")
+        logger.warning("The 'NPUGetFloatStatus' operator will be deprecated in the future, "
+                       "please use 'nn.TrainOneStepWithLossScaleCell' or 'amp.all_finite'.")
 
 
 class NPUClearFloatStatus(Primitive):
@@ -4455,7 +5129,7 @@ class NPUClearFloatStatus(Primitive):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> from mindspore import ops
-        >>> from mindspore.common import dtype as mstype
+        >>> from mindspore import dtype as mstype
         >>> from mindspore.common.tensor import Tensor
         >>> class Net(nn.Cell):
         ...     def __init__(self):
@@ -4489,7 +5163,8 @@ class NPUClearFloatStatus(Primitive):
     @prim_attr_register
     def __init__(self):
         """Initialize NPUClearFloatStatus"""
-        logger.warning("The 'NPUClearFloatStatus' operator will be deprecated in the future. Please don't use it.")
+        logger.warning("The 'NPUClearFloatStatus' operator will be deprecated in the future,"
+                       "please use 'nn.TrainOneStepWithLossScaleCell' or 'amp.all_finite'.")
 
 
 class NPUGetFloatStatusV2(Primitive):
@@ -4538,9 +5213,10 @@ class NPUGetFloatStatusV2(Primitive):
         ...         self.get_status = NPUGetFloatStatusV2()
         ...         self.sub = ops.Sub()
         ...         self.neg = ops.Neg()
-        ...         self.not_equal = ops.NotEqual()
-        ...         self.reduce_any = ops.ReduceAny(keep_dims=False)
+        ...         self.equal = ops.Equal()
+        ...         self.reduce_all = ops.ReduceAll(keep_dims=False)
         ...         self.base = Tensor([0], dtype=ms.int32)
+        ...         self.logic_not = ops.LogicalNot()
         ...
         ...     def construct(self, x):
         ...         init = Tensor([0]*8, dtype=ms.int32)
@@ -4549,8 +5225,9 @@ class NPUGetFloatStatusV2(Primitive):
         ...         res = self.sub(x, self.neg(x))
         ...         init = ops.depend(init, res)
         ...         get_status = self.get_status(init)
-        ...         flag = self.not_equal(self.base, get_status)
-        ...         overflow = self.reduce_any(flag)
+        ...         flag = self.equal(self.base, get_status)
+        ...         overall_finite = self.reduce_all(flag)
+        ...         overflow = self.logic_not(overall_finite)
         ...         return overflow
         ...
         >>> value = 65504
@@ -4620,9 +5297,10 @@ class NPUClearFloatStatusV2(Primitive):
         ...         self.get_status = NPUGetFloatStatusV2()
         ...         self.sub = ops.Sub()
         ...         self.neg = ops.Neg()
-        ...         self.not_equal = ops.NotEqual()
-        ...         self.reduce_any = ops.ReduceAny(keep_dims=False)
+        ...         self.equal = ops.Equal()
+        ...         self.reduce_all = ops.ReduceAll(keep_dims=False)
         ...         self.base = Tensor([0], dtype=ms.int32)
+        ...         self.logic_not = ops.LogicalNot()
         ...
         ...     def construct(self, x):
         ...         init = Tensor([0]*8, dtype=ms.int32)
@@ -4631,8 +5309,9 @@ class NPUClearFloatStatusV2(Primitive):
         ...         res = self.sub(x, self.neg(x))
         ...         init = ops.depend(init, res)
         ...         get_status = self.get_status(init)
-        ...         flag = self.not_equal(self.base, get_status)
-        ...         overflow = self.reduce_any(flag)
+        ...         flag = self.equal(self.base, get_status)
+        ...         overall_finite = self.reduce_all(flag)
+        ...         overflow = self.logic_not(overall_finite)
         ...         return overflow
         ...
         >>> value = 65504
@@ -4662,10 +5341,19 @@ class Cos(Primitive):
 
     Refer to :func:`mindspore.ops.cos` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input Tensor.
+
+    Outputs:
+        Tensor, has the same shape as `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> cos = ops.Cos()
         >>> x = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
         >>> output = cos(x)
@@ -4684,10 +5372,20 @@ class ACos(Primitive):
 
     Refer to :func:`mindspore.ops.acos` for more details.
 
+    Inputs:
+        - **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`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> acos = ops.ACos()
         >>> x = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), mindspore.float32)
         >>> output = acos(x)
@@ -4711,6 +5409,9 @@ class Sin(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> sin = ops.Sin()
         >>> x = Tensor(np.array([0.62, 0.28, 0.43, 0.62]), mindspore.float32)
         >>> output = sin(x)
@@ -4725,14 +5426,27 @@ class Sin(Primitive):
 
 class Asin(Primitive):
     r"""
-    Computes arcsine of input tensors element-wise.
+    Computes arcsine of input tensor element-wise.
 
     Refer to :func:`mindspore.ops.asin` for more details.
 
+    Note:
+        Complex64 and complex128 are not supported on Ascend currently.
+
+    Inputs:
+        - **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`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> asin = ops.Asin()
         >>> x = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), mindspore.float32)
         >>> output = asin(x)
@@ -4763,7 +5477,7 @@ class NMSWithMask(PrimitiveWithInfer):
 
     Args:
         iou_threshold (float): Specifies the threshold of overlap boxes with respect to
-            IOU. Default: 0.5.
+            IOU. Default: ``0.5`` .
 
     Inputs:
         - **bboxes** (Tensor) - The shape of tensor is :math:`(N, 5)`. Input bounding boxes.
@@ -4793,6 +5507,9 @@ class NMSWithMask(PrimitiveWithInfer):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> bbox = np.array([[100.0, 100.0, 50.0, 68.0, 0.63], [150.0, 75.0, 165.0, 115.0, 0.55],
         ...                  [12.0, 190.0, 288.0, 200.0, 0.9], [28.0, 130.0, 106.0, 172.0, 0.3]])
         >>> bbox[:, 2] += bbox[:, 0]
@@ -4810,7 +5527,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
@@ -4832,15 +5548,28 @@ class Abs(Primitive):
 
     Refer to :func:`mindspore.ops.abs` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input tensor.
+
+    Outputs:
+        Tensor, has the same shape as the `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([-1.0, 1.0, 0.0]), mindspore.float32)
         >>> abs = ops.Abs()
         >>> output = abs(x)
         >>> print(output)
         [1. 1. 0.]
+        >>> x = Tensor(3.6)
+        >>> output = abs(x)
+        >>> print(output)
+        3.6
     """
 
     @prim_attr_register
@@ -4859,8 +5588,7 @@ class Sign(Primitive):
         1, &if\ x > 0\end{cases}
 
     Inputs:
-        - **x** (Tensor) - The input tensor.
-          :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
+        - **x** (Tensor) - The input tensor of any dimension.
 
     Outputs:
         Tensor, has the same shape and dtype as the `x`.
@@ -4872,6 +5600,9 @@ class Sign(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+         >>> import mindspore
+         >>> import numpy as np
+         >>> from mindspore import Tensor, ops
          >>> x = Tensor(np.array([[2.0, 0.0, -1.0]]), mindspore.float32)
          >>> sign = ops.Sign()
          >>> output = sign(x)
@@ -4888,12 +5619,21 @@ class Round(Primitive):
     r"""
     Returns half to even of a tensor element-wise.
 
-    Refer to :func:`mindspore.ops.round` for more detailsed.
+    Refer to :func:`mindspore.ops.round` for more details.
+
+    Inputs:
+        - **x** (Tensor) - The input tensor.
+
+    Outputs:
+        Tensor, has the same shape and type as the `x`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([0.8, 1.5, 2.3, 2.5, -4.5]), mindspore.float32)
         >>> round = ops.Round()
         >>> output = round(x)
@@ -4913,10 +5653,19 @@ class Tan(Primitive):
 
     Refer to :func:`mindspore.ops.tan` for more details.
 
+    Inputs:
+        - **x** (Tensor) - Input tensor of any dimension.
+
+    Outputs:
+        Tensor, has the same shape as `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> tan = ops.Tan()
         >>> x = Tensor(np.array([-1.0, 0.0, 1.0]), mindspore.float32)
         >>> output = tan(x)
@@ -4936,10 +5685,22 @@ class Atan(Primitive):
 
     Refer to :func:`mindspore.ops.atan` for more details.
 
+    Inputs:
+        - **x** (Tensor): The input Tensor. Supported dtypes:
+
+          - Ascend: float16, float32.
+          - GPU/CPU: float16, float32, float64.
+
+    Outputs:
+        A Tensor, has the same type as the input.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1.0, 0.0]), mindspore.float32)
         >>> atan = ops.Atan()
         >>> output = atan(x)
@@ -4957,15 +5718,21 @@ class Atanh(Primitive):
     r"""
     Computes inverse hyperbolic tangent of the input element-wise.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Refer to :func:`mindspore.ops.atanh` for more details.
 
+    Inputs:
+        - **x** (Tensor): The input Tensor.
+
+    Outputs:
+        A Tensor, has the same type as the input.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([0, -0.5]), mindspore.float32)
         >>> atanh = ops.Atanh()
         >>> output = atanh(x)
@@ -4985,10 +5752,22 @@ class Atan2(_MathBinaryOp):
 
     Refer to :func:`mindspore.ops.atan2` for more details.
 
+    Inputs:
+        - **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:
+        Tensor, the shape is the same as the one after broadcasting, and the data type is same as `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([0, 1]), mindspore.float32)
         >>> y = Tensor(np.array([1, 1]), mindspore.float32)
         >>> atan2 = ops.Atan2()
@@ -5008,7 +5787,6 @@ class SquareSumAll(Primitive):
     Returns the square sum of a tensor element-wise.
 
     .. math::
-
         \left\{\begin{matrix}out_{x} = {\textstyle \sum_{0}^{N}} (x_{i})^2
         \\out_{y} = {\textstyle \sum_{0}^{N}} (y_{i})^2
         \end{matrix}\right.
@@ -5058,10 +5836,21 @@ class BitwiseAnd(_BitwiseBinaryOp):
 
     Refer to :func:`mindspore.ops.bitwise_and` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The first input tensor with shape
+          :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
+        - **y** (Tensor) - The second input tensor with same type as the `x`.
+
+    Outputs:
+        Tensor, has the same type as the `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([0, 0, 1, -1, 1, 1, 1]), mindspore.int16)
         >>> y = Tensor(np.array([0, 1, 1, -1, -1, 2, 3]), mindspore.int16)
         >>> bitwise_and = ops.BitwiseAnd()
@@ -5077,10 +5866,21 @@ class BitwiseOr(_BitwiseBinaryOp):
 
     Refer to :func:`mindspore.ops.bitwise_or` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The first input tensor with shape
+          :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
+        - **y** (Tensor) - The second input tensor with same type as the `x`.
+
+    Outputs:
+        Tensor, has the same type as the `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([0, 0, 1, -1, 1, 1, 1]), mindspore.int16)
         >>> y = Tensor(np.array([0, 1, 1, -1, -1, 2, 3]), mindspore.int16)
         >>> bitwise_or = ops.BitwiseOr()
@@ -5096,10 +5896,21 @@ class BitwiseXor(_BitwiseBinaryOp):
 
     Refer to :func:`mindspore.ops.bitwise_xor` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The first input tensor with shape
+          :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
+        - **y** (Tensor) - The second input tensor with same type as the `x`.
+
+    Outputs:
+        Tensor, has the same type as the `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([0, 0, 1, -1, 1, 1, 1]), mindspore.int16)
         >>> y = Tensor(np.array([0, 1, 1, -1, -1, 2, 3]), mindspore.int16)
         >>> bitwise_xor = ops.BitwiseXor()
@@ -5110,18 +5921,38 @@ 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.
 
     Refer to :func:`mindspore.ops.bessel_i0` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input tensor.
+          Data type must be float16, float32 or float64.
+
+    Outputs:
+        Tensor, has the same shape as `x`.
+
     Supported Platforms:
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> bessel_i0 = ops.BesselI0()
         >>> x = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
         >>> output = bessel_i0(x)
@@ -5135,18 +5966,38 @@ 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.
 
     Refer to :func:`mindspore.ops.bessel_i1` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input tensor.
+          Data type must be float16, float32 or float64.
+
+    Outputs:
+        Tensor, has the same shape as `x`.
+
     Supported Platforms:
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> bessel_i1 = ops.BesselI1()
         >>> x = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
         >>> output = bessel_i1(x)
@@ -5161,14 +6012,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.
@@ -5185,6 +6039,9 @@ class BesselI0e(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> bessel_i0e = ops.BesselI0e()
         >>> x = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
         >>> output = bessel_i0e(x)
@@ -5200,14 +6057,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.
@@ -5224,6 +6084,9 @@ class BesselI1e(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> bessel_i1e = ops.BesselI1e()
         >>> x = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
         >>> output = bessel_i1e(x)
@@ -5239,7 +6102,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.
@@ -5258,6 +6131,9 @@ class BesselK0(Primitive):
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> bessel_k0 = ops.BesselK0()
         >>> x = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
         >>> output = bessel_k0(x)
@@ -5272,7 +6148,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.
@@ -5291,6 +6177,9 @@ class BesselK1(Primitive):
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> bessel_k1 = ops.BesselK1()
         >>> x = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
         >>> output = bessel_k1(x)
@@ -5304,8 +6193,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.
@@ -5324,6 +6223,9 @@ class BesselK0e(Primitive):
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> bessel_k0e = ops.BesselK0e()
         >>> x = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
         >>> output = bessel_k0e(x)
@@ -5337,8 +6239,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.
@@ -5357,6 +6269,9 @@ class BesselK1e(Primitive):
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> bessel_k1e = ops.BesselK1e()
         >>> x = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
         >>> output = bessel_k1e(x)
@@ -5370,8 +6285,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.
@@ -5390,6 +6313,9 @@ class BesselJ0(Primitive):
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> bessel_j0 = ops.BesselJ0()
         >>> x = Tensor(np.array([0.5, 1., 2., 4.]), mindspore.float32)
         >>> output = bessel_j0(x)
@@ -5404,8 +6330,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.
@@ -5424,11 +6358,14 @@ class BesselJ1(Primitive):
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> bessel_j1 = ops.BesselJ1()
         >>> x = Tensor(np.array([0.5, 1., 2., 4.]), mindspore.float32)
         >>> output = bessel_j1(x)
         >>> print(output)
-        [0.24226846,  0.44005059,  0.57672481, -0.06604333]
+        [0.24226846  0.44005059  0.57672481  -0.06604333]
     """
 
     @prim_attr_register
@@ -5438,8 +6375,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.
@@ -5458,6 +6404,9 @@ class BesselY0(Primitive):
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> bessel_y0 = ops.BesselY0()
         >>> x = Tensor(np.array([0.5, 1., 2., 4.]), mindspore.float32)
         >>> output = bessel_y0(x)
@@ -5472,8 +6421,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.
@@ -5492,6 +6450,9 @@ class BesselY1(Primitive):
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> bessel_y1 = ops.BesselY1()
         >>> x = Tensor(np.array([0.5, 1., 2., 4.]), mindspore.float32)
         >>> output = bessel_y1(x)
@@ -5509,12 +6470,21 @@ class Inv(Primitive):
     r"""
     Computes Reciprocal of input tensor element-wise.
 
-    Refer to :func:`mindspore.ops.inv` for more details.
+    Refer to :func:`mindspore.ops.inv` for more details.
+
+    Inputs:
+        - **x** (Tensor) - Input tensor, it must be one of the following types: float16, float32 or int32.
+
+    Outputs:
+        Tensor, has the same shape and data type as `x`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> inv = ops.Inv()
         >>> x = Tensor(np.array([0.25, 0.4, 0.31, 0.52]), mindspore.float32)
         >>> output = inv(x)
@@ -5537,6 +6507,9 @@ class Invert(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> invert = ops.Invert()
         >>> x = Tensor(np.array([25, 4, 13, 9]), mindspore.int16)
         >>> output = invert(x)
@@ -5550,13 +6523,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:
@@ -5564,42 +6539,24 @@ 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``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> 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):
@@ -5609,10 +6566,21 @@ class LinSpace(Primitive):
 
     Refer to :func:`mindspore.ops.linspace` for more details.
 
+    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.
+
+    Outputs:
+        Tensor, has the same shape and dtype as `start`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> linspace = ops.LinSpace()
         >>> start = Tensor(1, mindspore.float32)
         >>> stop = Tensor(10, mindspore.float32)
@@ -5634,10 +6602,14 @@ class MatrixInverse(Primitive):
     result may be returned.
 
     Note:
-        The parameter 'adjoint' is only supporting False right now, because complex number is not supported at present.
+        The parameter 'adjoint' is only supporting ``False``  right now, because complex number is not supported at
+        present.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Args:
-        adjoint (bool) : An optional bool. Default: False.
+        adjoint (bool) : An optional bool. Default: ``False`` .
 
     Inputs:
         - **x** (Tensor) - A matrix to be calculated. The matrix must be at least two dimensions, and the last two
@@ -5656,6 +6628,9 @@ class MatrixInverse(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[[-0.710504  , -1.1207525],
         ...                       [-1.7651395 , -1.7576632]],
         ...                      [[ 0.52412605,  1.9070215],
@@ -5682,28 +6657,32 @@ class MatrixPower(Primitive):
     When n equals 0, it returns a group of identity matrices. If n is negative,
     it computes the inverse of each matrix (if possible) raised to the power of abs(n).
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Args:
         n (int) : The exponent, a required int.
 
     Inputs:
-        - **x** (Tensor) - A 3-D Tensor. Supported data types are float16 and float32.
-          The shape is :math:`(b, m, m)`, represents b m-D square matrices.
+        - **x** (Tensor) - A 3-D Tensor. The shape is :math:`(b, m, m)`, represents b m-D square matrices.
 
     Outputs:
         - **y** (Tensor) - A 3-D Tensor. Data type and shape are the same as `x`'s.
 
     Raises:
         TypeError: If the data type of `n` is not int.
-        TypeError: If the data type of `x` is neither float32 nor float16.
         TypeError: If x is not a Tensor.
         ValueError: If `x` is not a 3-D tensor.
         ValueError: If shape[1] and shape[2] of `x` are not the same.
         ValueError: If n is negative but got input x has singular matrices.
+        ValueError: If `n` < 0 and input is int type.
 
     Supported Platforms:
-
+        ``Ascend`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor([[[0, 1], [-1, 0]], [[1, 0], [0, -1]]], dtype=ms.float32)
         >>> matrix_power = ops.MatrixPower(n=2)
         >>> y = matrix_power(x)
@@ -5726,8 +6705,15 @@ class MatrixDeterminant(Primitive):
 
     Refer to :func:`mindspore.ops.det` for more details.
 
-    Supported Platforms:
+    Inputs:
+        - **x** (Tensor) - A matrix to be calculated. The matrix must be at least two dimensions, and the last two
+          dimensions must be the same size.
 
+    Outputs:
+        Tensor, the shape is `x_shape[:-2]`, the dtype is same as `x`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> input_x = Tensor(np.array([[[-4.5, -1.5], [7.0, 6.0]], [[2.5, 0.5], [3.0, 9.0]]]), mindspore.float32)
@@ -5750,6 +6736,15 @@ class LogMatrixDeterminant(Primitive):
 
     Refer to :func:`mindspore.ops.slogdet` for more details.
 
+    Inputs:
+        - **x** (Tensor) - A matrix to be calculated. The matrix must be at least two dimensions, and the last two
+          dimensions must be the same size. Supported dtypes: float32, float64, complex64 and complex128.
+
+    Outputs:
+        - **sign** (Tensor) - The signs of the log determinants. The shape is `x_shape[:-2]`, the dtype is same as `x`.
+        - **y** (Tensor) - The absolute values of the log determinants. The shape is `x_shape[:-2]`, the dtype is same
+          as `x`.
+
     Supported Platforms:
 
 
@@ -5813,9 +6808,11 @@ class IndexAdd(Primitive):
     Args:
         axis (int): The dimension along which to index.
         use_lock (bool): Whether to enable a lock to protect the updating process of variable tensors.
-            If true, when updating the value of `x`, this process will be protected by a lock by using atomic operation.
-            If false, the result may be unpredictable. Default: True.
-        check_index_bound (bool): If true, check index boundary. If false, don't check index boundary. Default: True.
+            If ``True`` , when updating the value of `x`, this process will be protected by a lock by using atomic
+            operation.
+            If ``False`` , the result may be unpredictable. Default: ``True`` .
+        check_index_bound (bool): If ``True`` , check index boundary. If ``False`` , don't check index boundary.
+            Default: ``True`` .
 
     Inputs:
         - **x** (Parameter) - The input Parameter to add to.
@@ -5841,6 +6838,9 @@ class IndexAdd(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, nn, ops, Parameter
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
@@ -5879,24 +6879,24 @@ class Erfinv(Primitive):
     r"""
     Computes the inverse error function of input. The inverse error function is defined in the range (-1, 1).
 
-    The formula is defined as:
-
-    .. math::
-                                erfinv(erf(x)) = x
+    Refer to :func:`mindspore.ops.erfinv` for more details.
 
     Inputs:
-        - **input_x** (Tensor) - The input tensor to compute to, with data type float32, float16 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`.
 
-    Raises:
-        TypeError: If dtype of `input_x` is not float16, float32 or float64.
-
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([0, 0.5, -0.9]), mindspore.float32)
         >>> erfinv = ops.Erfinv()
         >>> output = erfinv(x)
@@ -5933,6 +6933,9 @@ class Conj(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.asarray(np.complex(1.3+0.4j)), mindspore.complex64)
         >>> conj = ops.Conj()
         >>> output = conj(x)
@@ -5975,6 +6978,9 @@ class ComplexAbs(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.asarray(np.complex(3+4j)), mindspore.complex64)
         >>> complex_abs = ops.ComplexAbs()
         >>> output = complex_abs(x)
@@ -5994,7 +7000,7 @@ class Real(Primitive):
     If input is real, it is returned unchanged.
 
     Inputs:
-        - **input** (Tensor) - The input tensor to compute to.
+        - **input** (Tensor) - The input tensor to compute with.
 
     Outputs:
         Tensor, the shape is the same as the input.
@@ -6006,6 +7012,9 @@ class Real(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.asarray(np.complex(1.3+0.4j)), mindspore.complex64)
         >>> real = ops.Real()
         >>> output = real(x)
@@ -6041,6 +7050,9 @@ class Complex(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> real = Tensor(np.array([1]), mindspore.float32)
         >>> imag = Tensor(np.array([2]), mindspore.float32)
         >>> complex = ops.Complex()
@@ -6061,7 +7073,7 @@ class Imag(Primitive):
     If input is real, it is returned zeros.
 
     Inputs:
-        - **input** (Tensor) - The input tensor to compute to.
+        - **input** (Tensor) - The input tensor.
 
     Outputs:
         Tensor, the shape is the same as the input.
@@ -6073,6 +7085,9 @@ class Imag(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.asarray(np.complex(1.3+0.4j)), mindspore.complex64)
         >>> imag = ops.Imag()
         >>> output = imag(x)
@@ -6095,10 +7110,18 @@ class Angle(Primitive):
 
     Refer to :func:`mindspore.ops.angle` for more details.
 
+    Inputs:
+        - **input** (Tensor) - The input tensor. Supported types: complex64, complex128.
+
+    Outputs:
+        Tensor, has the float32 or float64 type and the same shape as input.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> input = Tensor([-1.5 + 7.8j, 3 + 5.75j], mindspore.complex64)
         >>> angle = ops.Angle()
         >>> output = angle(input)
@@ -6118,10 +7141,19 @@ class Trunc(Primitive):
 
     Refer to :func:`mindspore.ops.trunc` for more details.
 
+    Inputs:
+        - **input_x** (Tensor) - Input tensor of any dimension.
+
+    Outputs:
+        Tensor, the same shape and data type as `input_x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([3.4742, 0.5466, -0.8008, -3.9079]), mindspore.float32)
         >>> output = ops.Trunc()(x)
         >>> print(output)
@@ -6208,16 +7240,31 @@ class Igamma(Primitive):
 
     Refer to :func:`mindspore.ops.igamma` for more details.
 
+    Inputs:
+        - **a** (Tensor) - The input tensor.
+        - **x** (Tensor) - The input tensor. It should have the same dtype with `a`.
+
+    Outputs:
+        Tensor, has the same dtype as `a` and `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> a = Tensor(np.array([2.0, 4.0, 6.0, 8.0]).astype(np.float32))
         >>> x = Tensor(np.array([2.0, 3.0, 4.0, 5.0]).astype(np.float32))
         >>> igamma = ops.Igamma()
         >>> output = igamma(a, x)
         >>> print (output)
         [0.593994  0.35276785  0.21486944  0.13337152]
+        >>> a = Tensor(2.1, mindspore.float32)
+        >>> x = Tensor(2.1, mindspore.float32)
+        >>> igamma = ops.Igamma()
+        >>> output = igamma(a, x)
+        >>> print (output)
+        0.5917439
     """
 
     @prim_attr_register
@@ -6232,16 +7279,31 @@ class Igammac(Primitive):
 
     Refer to :func:`mindspore.ops.igammac` for more details.
 
+    Inputs:
+        - **a** (Tensor) - The input tensor.
+        - **x** (Tensor) - The input tensor. It should have the same dtype with `a`.
+
+    Outputs:
+        Tensor, has the same dtype as `a` and `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> a = Tensor(np.array([2.0, 4.0, 6.0, 8.0]).astype(np.float32))
         >>> x = Tensor(np.array([2.0, 3.0, 4.0, 5.0]).astype(np.float32))
         >>> igammac = ops.Igammac()
         >>> output = igammac(a, x)
         >>> print (output)
         [0.40600586 0.6472318  0.7851304  0.8666283 ]
+        >>> a = Tensor(2.1, mindspore.float32)
+        >>> x = Tensor(2.1, mindspore.float32)
+        >>> igammac = ops.Igammac()
+        >>> output = igammac(a, x)
+        >>> print (output)
+        0.40825662
     """
 
     @prim_attr_register
@@ -6257,6 +7319,18 @@ class IsClose(Primitive):
 
     Refer to :func:`mindspore.ops.isclose` for more details.
 
+    Args:
+        rtol(float, optional): Relative tolerance. Default: ``1e-05`` .
+        atol(float, optional): Absolute tolerance. Default: ``1e-08`` .
+        equal_nan(bool, optional): If ``True`` , then two NaNs will be considered equal. Default: ``True`` .
+
+    Inputs:
+        - **input** (Tensor) - First tensor to compare, with data type belongs to float32, float16, int32.
+        - **other** (Tensor) - Second tensor to compare, with data type belongs to float32, float16, int32.
+
+    Outputs:
+        Tensor, with the same shape as `input` and `other` after broadcasting, its dtype is bool.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
@@ -6291,6 +7365,13 @@ class MatrixExp(Primitive):
 
     Refer to :func:`mindspore.ops.matrix_exp` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The shape of tensor is :math:`(*, n, n)` where * is zero or more batch dimensions.
+          Supported dtypes: float64, float32, float16, complex64, complex128.
+
+    Outputs:
+        Tensor, has the same shape and dtype as the `x`.
+
     Supported Platforms:
 
 
@@ -6314,7 +7395,7 @@ class MatrixSolve(Primitive):
 
     Args:
         adjoint (bool, optional): Indicates whether the adjoint of the
-            matrix is used during the computation. Default: False,  use its transpose instead.
+            matrix is used during the computation. Default: ``False`` ,  use its transpose instead.
 
     Inputs:
         - **matrix** (Tensor) - A tensor of shape :math:`(..., M, M)`,
@@ -6342,13 +7423,17 @@ class MatrixSolve(Primitive):
         ``Ascend`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> matrix = Tensor(np.array([[1.0  , 4.0],
         ...                       [2.0 , 7.0]]), mindspore.float32)
         >>> rhs = Tensor(np.array([[1.0]  , [3.0]]), mindspore.float32)
         >>> matrix_solve = ops.MatrixSolve(adjoint = False)
         >>> output = matrix_solve(matrix, rhs)
         >>> print(output)
-        [[5.0], [-1.0]]
+        [[5.0]
+         [-1.0]]
     """
 
     @prim_attr_register
@@ -6366,7 +7451,7 @@ class MatrixSolveLs(Primitive):
     path is typically 6-7 times slower than the fast path. If `fast` is `False` then `l2_regularizer` is ignored.
 
     Args:
-        fast (bool): An optional bool. Defaults to True.
+        fast (bool): An optional bool. Default: ``True`` .
 
     Inputs:
         - **matrix** (Tensor) -  A Tensor. Must be one of the following data types: float64, float32, complex64,
@@ -6414,7 +7499,7 @@ class Lu(Primitive):
 
     Args:
         output_idx_type (:class:`mindspore.dtype`): An optional data type of `mindspore.dtype.int32`.
-            Default: `mindspore.dtype.int32`.
+            Default: ``mindspore.dtype.int32`` .
 
     Inputs:
         - **input** (Tensor) - A tensor of shape `[..., M, M]` whose inner-most 2 dimensions form
@@ -6525,10 +7610,32 @@ class LuUnpack(Primitive):
 
     Refer to :func:`mindspore.ops.lu_unpack` for more details.
 
+    Args:
+        unpack_data (bool, optional): A flag indicating if the LU_data should be unpacked.
+            If ``False`` , then the returned L and U are None. Default: ``True`` .
+        unpack_pivots (bool, optional): A flag indicating if the LU_pivots should be unpacked
+            into a permutation matrix P. If ``False`` , then the returned P is None. Default: ``True`` .
+
+    Inputs:
+        - **LU_data** (Tensor) - The packed LU factorization data. The shape of a tensor is :math:`(*, M, N)`,
+          where :math:`*` is batch dimensions, with data type int8, uint8, int16, int32, int64, float16,
+          float32, float64. The dims of LU_data must be equal to or greater than 2.
+        - **LU_pivots** (Tensor) - The packed LU factorization pivots. The shape of a tensor is :math:`(*, min(M, N))`,
+          where :math:`*` is batch dimensions, with data type int8, uint8, int16, int32, int64.
+
+    Outputs:
+        - **pivots** (Tensor) - The permutation matrix of LU factorization. The shape is :math:`(*, M, M)`,
+          the dtype is same as `LU_data`.
+        - **L** (Tensor) - The L matrix of LU factorization. The dtype is the same as `LU_data`.
+        - **U** (Tensor) - The U matrix of LU factorization. The dtype is the same as `LU_data`.
+
     Supported Platforms:
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> LU_data = Tensor(np.array([[[-0.3806, -0.4872,  0.5536],
         ...                             [-0.1287,  0.6508, -0.2396],
         ...                             [ 0.2583,  0.5239,  0.6902]],
@@ -6578,6 +7685,12 @@ class Lgamma(Primitive):
 
     Refer to :func:`mindspore.ops.lgamma` for more details.
 
+    Inputs:
+        - **x** (Tensor) - The input tensor. The dtype can be float16, float32 or float64.
+
+    Outputs:
+        Tensor, has the same dtype as `x`.
+
     Supported Platforms:
         ``GPU`` ``CPU``
 
@@ -6587,6 +7700,10 @@ class Lgamma(Primitive):
         >>> output = lgamma(x)
         >>> print(output)
         [0.5723649 0.8854049 9.549267 ]
+        >>> x = Tensor(2.1, mindspore.float32)
+        >>> output = lgamma(x)
+        >>> print(output)
+        0.045437694
     """
 
     @prim_attr_register
@@ -6619,6 +7736,8 @@ class Digamma(Primitive):
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1.5, 0.5, 9]).astype(np.float16))
         >>> digamma = ops.Digamma()
         >>> output = digamma(x)
@@ -6641,10 +7760,22 @@ class Polygamma(Primitive):
 
     Refer to :func:`mindspore.ops.polygamma` for more details.
 
+    Inputs:
+        - **a** (Tensor) - The order of the polygamma function, it has shape :math:`()`,
+          supported types: int32, int64.
+        - **x** (Tensor) - The tensor to compute the :math:`a`-th derivative of the polygamma function with,
+          supported types: float16, float32, float64.
+
+    Outputs:
+        Tensor, has the same dtype as `x`.
+
     Supported Platforms:
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([1.0, -0.5]), mindspore.float32)
         >>> a = Tensor(np.array(1), mindspore.int64)
         >>> polygamma = ops.Polygamma()
@@ -6677,6 +7808,15 @@ class CholeskyInverse(Primitive):
 
     Refer to :func:`mindspore.ops.cholesky_inverse` for more details.
 
+    Args:
+        upper(bool, optional): Whether to return a lower or upper triangular matrix. Default: ``False`` .
+
+    Inputs:
+        - **x** (Tensor) - The input tensor whose rank is 2. Supported dtypes: float32, float64.
+
+    Outputs:
+        Tensor, has the same shape and dtype as `x`.
+
     Supported Platforms:
         ``Ascend`` ``CPU``
 
@@ -6707,7 +7847,7 @@ class Cross(Primitive):
     Refer to :func:`mindspore.ops.cross` for more details.
 
     Args:
-        dim (int): Spefcified dim along which to cumpute cross product with. Default: -65530.
+        dim (int): Spefcified dim along which to cumpute cross product with. Default: ``-65530`` .
 
     Inputs:
         - **x1** (Tensor) - Input Tensor.
@@ -6724,7 +7864,7 @@ class Cross(Primitive):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor
-        >>> from mindspore.common import dtype as mstype
+        >>> from mindspore import dtype as mstype
         >>> import mindspore.ops as ops
         >>> cross = ops.Cross(dim = 0)
         >>> x1 = Tensor([1, 2, 3], mstype.int8)
@@ -6805,7 +7945,7 @@ class RaggedRange(Primitive):
 
 class Trace(Primitive):
     """
-    Returns a new tensor that is the sum of the input trace.
+    Computes the sum of the diagonal elements in a 2-D matrix.
 
     Note:
         Input must be matrix, and complex number is not supported at present.
@@ -6827,6 +7967,9 @@ class Trace(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), mindspore.float32)
         >>> trace = ops.Trace()
         >>> output = trace(x)
@@ -6855,31 +7998,35 @@ class Median(Primitive):
     If `global_median` is True, computes the  median of all elements of tensor.
 
     .. warning::
-        When attr `global_median` is True, the value of the second output tensor `indices` is meaningless.
+        - `indices` does not necessarily contain the first occurrence of each median value found in the `input`,
+          unless it is unique. The specific implementation of this API is device-specific.
+          The results may be different on CPU and GPU.
+        - When attr `global_median` is ``True`` , the value of the second output tensor `indices` is meaningless.
 
     Args:
         global_median (bool, optional): Whether the output tensor is the median of all
-            input tensor elements or not. Default: Fasle.
-        axis (int, optional): The specified dimension to compute median. Default: 0.
-        keep_dims (bool, optional): Whether the output tensor need to retain `axis` dimension or not. Default: False.
+            input tensor elements or not. Default: ``False`` .
+        axis (int, optional): The specified dimension to compute median. Default: ``0`` .
+        keep_dims (bool, optional): Whether the output tensor need to retain `axis` dimension or not.
+            Default: ``False`` .
+        ignore_nan (bool, optional): Whether to ignore the NaN values in input Tensor. Default: ``False`` .
 
     Inputs:
-        - **x** (Tensor) - A Tensor to calculate median with. Supported dtype:int16, int32, int64, float32 or float64.
+        - **x** (Tensor) - A Tensor to calculate median with.
 
     Outputs:
         - **y** (Tensor) - Median, has the same dtype as the `x`.
 
-          - If `global_median` is True, the `y` has only one element.
-          - If `keep_dims` is True, the `y` has the same shape as the `x` except the size
+          - If `global_median` is ``True`` , the `y` has only one element.
+          - If `keep_dims` is ``True`` , the `y` has the same shape as the `x` except the size
             of `y` in dimension `axis` is 1.
           - Otherwise, the `y` lacks `axis` dimension than input.
 
         - **indices** (Tensor) - Indices, Has the same shape as the `y`, with dtype int64.
 
     Raises:
-        TypeError: If dtype of `x` is not one of the following: int16, int32, int64, float32, float64.
         TypeError: If input `x` is not a Tensor.
-        TypeError: If `global_median` or `keep_dims` is assigned a nonboolean value.
+        TypeError: If `global_median` , `keep_dims` or `ignore_nan` is assigned a nonboolean value.
         TypeError: If `axis` is not int.
         ValueError: If `axis` is not in range of [-x.dim, x.dim-1].
 
@@ -6906,13 +8053,15 @@ class Median(Primitive):
     """
 
     @prim_attr_register
-    def __init__(self, global_median=False, axis=0, keep_dims=False):
+    def __init__(self, global_median=False, axis=0, keep_dims=False, ignore_nan=False):
+        self.add_prim_attr("cust_aicpu", self.name)
         validator.check_value_type("global_median", global_median, [bool], self.name)
         self.global_median = global_median
         if global_median is False:
             validator.check_value_type("axis", axis, [int], self.name)
             validator.check_value_type("keep_dims", keep_dims, [bool], self.name)
         self.init_prim_io_names(inputs=['x'], outputs=['y', 'indices'])
+        validator.check_value_type("ignore_nan", ignore_nan, [bool], self.name)
 
 
 class SparseSegmentMean(Primitive):
@@ -6948,12 +8097,12 @@ class Zeta(Primitive):
     r"""
     Compute the Hurwitz zeta function ζ(x,q) of input Tensor.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     .. math::
         \zeta \left ( x,q \right )=  \textstyle \sum_{n=0} ^ {\infty} \left ( q+n\right )^{-x}
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Inputs:
         - **x** (Tensor) - A Tensor, types: float32, float64.
         - **q** (Tensor) - A Tensor, must have the same shape and type as `x`.
@@ -6971,6 +8120,9 @@ class Zeta(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([10.]), mindspore.float32)
         >>> q = Tensor(np.array([1.]), mindspore.float32)
         >>> zeta = ops.Zeta()
@@ -6993,10 +8145,27 @@ class Bernoulli(Primitive):
 
     Refer to :func:`mindspore.ops.bernoulli` for more details.
 
+    Args:
+        seed (int, optional): The seed value for random generating. The value of `seed` must be -1 or a
+            positive integer, and -1 means using the current timestamp. Default: ``-1`` .
+        offset (int, optional): Used to change the starting position during the generation of
+            random number sequence. Default: ``0`` .
+
+    Inputs:
+        - **x** (Tensor) - Input Tensor.
+        - **p** (Union[Tensor, float], optional) - Success probability, representing the probability of
+          setting 1 for the corresponding position of the current Tensor. It has the same shape as `x`,
+          the value of `p` must be in the range `[0, 1]`. Default: ``0.5`` .
+
+    Outputs:
+        - **y** (Tensor) - with the same shape and type as `x` .
+
     Supported Platforms:
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor([0.1, 0.2, 0.3], mindspore.float32)
         >>> bernoulli = ops.Bernoulli()
         >>> output = bernoulli(input_x, Tensor([1.0]))
@@ -7027,7 +8196,7 @@ class TridiagonalSolve(Primitive):
     The penultimate dimension of diagonals must be 3.
 
     Args:
-        partial_pivoting (bool): decide if use the method of partial_pivoting. Default: True.
+        partial_pivoting (bool): decide if use the method of partial_pivoting. Default: ``True`` .
 
     Inputs:
         - **diagonals** [Tensor] - The input tensor A of the equation AX = B, with data type of float32,
@@ -7077,10 +8246,24 @@ class Renorm(Primitive):
 
     Refer to :func:`mindspore.ops.renorm` for more details.
 
+    Args:
+        p (int): Power of norm calculation.
+        dim (int): The dimension that expected to get the slice-tensor.
+        maxnorm (float32): Max norm.
+
+    Inputs:
+        - **x** (Tensor) - A Tensor, types: float32 or float16.
+
+    Outputs:
+        Tensor, has the same dtype and shape as input.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]), mindspore.float32)
         >>> y = ops.Renorm(p=1, dim=0, maxnorm=5.)(x)
         >>> print(y)
@@ -7111,10 +8294,24 @@ class Cholesky(Primitive):
 
     Refer to :func:`mindspore.ops.cholesky` for more details.
 
+    Args:
+        upper (bool, optional): Flag that indicates whether to return a upper or lower triangular matrix.
+            Default: ``False`` .
+
+    Inputs:
+        - **input_x** (Tensor) - Tensor of shape :math:`(*, N, N)`, where :math:`*` is zero or more batch dimensions
+          consisting of symmetric positive-definite matrices, with float32 or float64 data type.
+
+    Outputs:
+        Tensor, has the same shape and data type as `input_x`.
+
     Supported Platforms:
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[1.0, 1.0], [1.0, 2.0]]), mindspore.float32)
         >>> cholesky = ops.Cholesky(upper=False)
         >>> output = cholesky(input_x)
@@ -7140,6 +8337,23 @@ class STFT(Primitive):
 
     Refer to :func:`mindspore.ops.stft` for more details.
 
+    Args:
+        n_fft (int): The size of Fourier transform.
+        hop_length (int): The distance between neighboring sliding window frames.
+        win_length (int): the size of window frame and STFT filter.
+        normalized (bool): controls whether to return the normalized STFT results.
+        onesided (bool): controls whether to return half of results to
+            avoid redundancy for real inputs.
+        return_complex (bool): If ``True`` , return a complex tensor. If False, return
+            a real tensor with an extra last dimension for the real and imaginary components.
+
+    Inputs:
+        - **x** (Tensor) - Time sequence of stft, must be either a 1-D time tensor or a 2-D tensor.
+        - **window** (Tensor) - the optional window function.
+
+    Outputs:
+        Tensor, containing the result after STFT.
+
     Supported Platforms:
         ``Ascend`` ``CPU``
 
@@ -7172,7 +8386,7 @@ class CholeskySolve(Primitive):
     Computes the solution of a set of linear equations with a positive definite matrix,
     according to its Cholesky decomposition factor `u` , and outputs the result as `c`.
 
-    If `upper` is set to `True`, `u` is upper triangular and `c` is returned such that:
+    If `upper` is set to ``True`` , `u` is upper triangular and `c` is returned such that:
 
     .. math::
         c = (u^{T}u)^{{-1}}b
@@ -7184,7 +8398,7 @@ class CholeskySolve(Primitive):
 
     Args:
         upper (bool, optional): A flag indicates whether to treat the Cholesky factor
-            as an upper or a lower triangular matrix. Default: False.
+            as an upper or a lower triangular matrix. Default: ``False`` .
 
     Inputs:
         - **x1** (Tensor) - Tensor of shape :math:`(*, N, M)`, indicating 2D or 3D matrices,
@@ -7253,39 +8467,48 @@ class FFTWithSize(Primitive):
 
     Note:
         - FFT/IFFT requires complex64 or complex128 inputs, return complex64 or complex128 outputs.
-        - RFFT requires float32 or float64 inputs, return complex64 or complex128 outputs.
+        - RFFT requires bool, uint8, int8, int16, int32, int64, float32 and float64 inputs,
+          return complex64 or complex128 outputs.
         - IRFFT requires complex64 or complex128 inputs, return float32 or float64 outputs.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Args:
         signal_ndim (int): The number of dimensions in each signal, this controls how many dimensions
             of the fourier transform are realized, can only be 1, 2 or 3.
-        inverse (bool): Whether it is the inverse transformation.
-        real (bool): Whether it is the real transformation.
+        inverse (bool): Whether it is the inverse transformation, used to select from FFT and RFFT or IFFT and IRFFT.
 
-            - "inverse:False real:False" corresponds to FFT.
-            - "inverse:True real:False" corresponds to IFFT.
-            - "inverse:False real:True" corresponds to RFFT.
-            - "inverse:True real:True" corresponds to IRFFT.
+            - when set to ``True``: IFFT and IRFFT.
+            - when set to ``False``: FFT and RFFT.
 
-        norm (str, optional): The normalization, optional values: ["backward", "forward", "ortho"].
-            Default value: "backward".
+        real (bool): Whether it is the real transformation, combines with `inverse` to select a specific
+            transformation mode:
 
-            - "backward" has the direct transforms unscaled and the inverse transforms scaled by :math:`1/n`,
+            - `inverse` is ``False`` ,  `real` is ``False`` : corresponds to FFT.
+            - `inverse` is ``True`` , `real` is ``False`` : corresponds to IFFT.
+            - `inverse` is ``False`` , `real` is ``True`` : corresponds to RFFT.
+            - `inverse` is ``True`` , `real` is ``True``  : corresponds to IRFFT.
+
+        norm (str, optional): The normalization, optional values: [ ``"backward"`` , ``"forward"`` , ``"ortho"`` ].
+            Default value: ``"backward"`` .
+
+            - ``"backward"`` has the direct transforms unscaled and the inverse transforms scaled by :math:`1/n`,
               where n is the input x's element numbers.
-            - "ortho" has both direct and inverse transforms are scaled by :math:`1/\sqrt n`.
-            - "forward" has the direct transforms scaled by :math:`1/n` and the inverse transforms unscaled.
+            - ``"ortho"`` has both direct and inverse transforms are scaled by :math:`1/\sqrt n`.
+            - ``"forward"`` has the direct transforms scaled by :math:`1/n` and the inverse transforms unscaled.
 
-        onesided (bool, optional): Controls whether the input is halved to avoid redundancy. Default: True.
+        onesided (bool, optional): Controls whether the input is halved to avoid redundancy. Default: ``True`` .
         signal_sizes (tuple, optional): Size of the original signal (the signal before rfft, no batch dimension),
-            only in IRFFT mode and set `onesided` to True requires the parameter, the following conditions must be
-            satisfied. Default: ().
+            only in IRFFT mode and set `onesided` to ``True`` requires the parameter, the following conditions must be
+            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.
@@ -7294,17 +8517,19 @@ class FFTWithSize(Primitive):
         A tensor containing the complex-to-complex, real-to-complex or complex-to-real Fourier transform result.
 
     Raises:
-        TypeError: If the input type of FFT/IFFT/IRFF is not one of: complex64, complex128.
-        TypeError: If the input type of RFFT is not one of: float32, float64.
+        TypeError: If the input type of FFT/IFFT/IRFFT is not one of: complex64, complex128.
         TypeError: If the input type is not Tensor.
         ValueError: If `x` dimension is less than signal_ndim.
         ValueError: If signal_ndim is greater than 3 or less than 1.
         ValueError: If norm is none of "backward", "forward" or "ortho".
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> # case FFT: signal_ndim: 1, inverse: False, real: False.
         >>> fft_in = Tensor(np.array([2, 1, 2]), mindspore.complex64)
         >>> fft_net = ops.FFTWithSize(signal_ndim=1, inverse=False, real=False)
@@ -7351,16 +8576,33 @@ class Polar(Primitive):
 
     Refer to :func:`mindspore.ops.polar` for more details.
 
+    Inputs:
+        - **abs** (Tensor) - Radial distance. Tensor of any dimension,
+          must be one of the following types: float32, float64.
+
+        - **angle** (Tensor) - Polar angle. It has the same shape and dtype as `abs`.
+
+    Outputs:
+        Tensor, has the same shape and data type as `abs`.
+
     Supported Platforms:
         ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> polar = ops.Polar()
         >>> x1 = Tensor(np.array([1, 2]), mindspore.float64)
         >>> x2 = Tensor(np.array([3, 4]), mindspore.float64)
         >>> output = polar(x1, x2)
         >>> print(output)
         [-0.9899925 +0.14112001j -1.30728724-1.51360499j]
+        >>> x1 = Tensor(2.1, mindspore.float32)
+        >>> x2 = Tensor(2.1, mindspore.float32)
+        >>> output = polar(x1, x2)
+        >>> print(output)
+        (-1.0601766+1.8127397j)
     """
 
     @prim_attr_register
@@ -7374,10 +8616,11 @@ class NextAfter(Primitive):
     Returns the next representable floating-point value after `x1` towards `x2` element-wise.
 
     Say there are two float32 numbers :math:`a, b`, and let the
-    representable delta of float32 datatype is :math:`eps`. If :math:`a < b`,
+    representable delta of float32 data type is :math:`eps`.
+    If :math:`a < b`,
     then the next representable of :math:`a` towards :math:`b` is :math:`a+eps`,
     If :math:`a > b`,
-    the next representable of :math:`b` towards :math:`a` is :math:`b-eps`.
+    the next representable of :math:`a` towards :math:`b` is :math:`a-eps`.
 
     .. math::
 
@@ -7387,12 +8630,10 @@ class NextAfter(Primitive):
         This is an experimental API that is subject to change or deletion.
 
     Inputs:
-        - **x1** (Tensor) - The shape of tensor is
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+        - **x1** (Tensor) - The input Tensor of any dimension.
           Must be one of the following types: float32, float64.
 
-        - **x2** (Tensor) - The shape of tensor is
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+        - **x2** (Tensor) - The input Tensor of any dimension.
           Must be one of the following types: float32, float64.
 
     Outputs:
@@ -7408,6 +8649,9 @@ class NextAfter(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> nextafter = ops.NextAfter()
         >>> x1 = Tensor(np.asarray([0.0]), mindspore.float32)
         >>> x2 = Tensor(np.asarray([0.1]), mindspore.float32)
@@ -7435,9 +8679,9 @@ class TrilIndices(Primitive):
     Args:
         row (int): number of rows in the 2-D matrix.
         col (int): number of columns in the 2-D matrix.
-        offset (int, optional): diagonal offset from the main diagonal. Default: 0.
+        offset (int, optional): diagonal offset from the main diagonal. Default: ``0`` .
         dtype (:class:`mindspore.dtype`, optional): The specified type of output tensor.
-            An optional data type of `mstype.int32` and `mstype.int64`. Default: `mstype.int32`.
+            An optional data type of ``mstype.int32`` and ``mstype.int64`` . Default: ``mstype.int32`` .
 
     Outputs:
         - **y** (Tensor) - indices of the elements in lower triangular part of matrix. The type specified by `dtype`.
@@ -7448,6 +8692,8 @@ class TrilIndices(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import ops
+        >>> from mindspore import dtype as mstype
         >>> net = ops.TrilIndices(4, 3, -1, mstype.int64)
         >>> output = net()
         >>> print(output)
@@ -7477,10 +8723,10 @@ class MatrixTriangularSolve(Primitive):
         Only GPU platforms now support the broadcast mechanism.
 
     Args:
-        lower (bool, optional): If True, the innermost matrices in `matrix` is
-            are lower triangular. Default: True.
+        lower (bool, optional): If ``True`` , the innermost matrices in `matrix` is
+            are lower triangular. Default: ``True`` .
         adjoint (bool, optional): Indicates whether the adjoint of the
-            matrix is used during the computation. Default: False,  use its transpose instead.
+            matrix is used during the computation. Default: ``False`` ,  use its transpose instead.
 
     Inputs:
         - **matrix** (Tensor) - Tensor of shape :math:`(*, M, M)`,
@@ -7525,7 +8771,7 @@ class CompareAndBitpack(Primitive):
     """
     Compare values of `x` to `threshold` and pack resulting bits into a `uint8`.
 
-    Each comparison returns a boolean true (if x_value > threshold) or and false otherwise.
+    Each comparison returns a boolean ``True`` (if x_value > threshold) or and ``False`` otherwise.
 
     Given an `x` shaped :math:`(s_0, s_1, ..., s_n)`, the output is a `uint8`
     Tensor shaped :math:`(s_0, s_1, ..., s_n / 8)`.
@@ -7574,10 +8820,28 @@ class NanToNum(Primitive):
 
     Refer to :func:`mindspore.ops.nan_to_num` for more details.
 
+    Args:
+        nan (float, optional): The value to replace `NaN`. Default value is ``0.0`` .
+        posinf (float, optional): If a Number, the value to replace positive infinity values with. If None, positive
+          infinity values are replaced with the greatest finite value representable by `x`'s dtype.
+          Default value is ``None`` .
+        neginf (float, optional): if a Number, the value to replace negative infinity values with. If None, negative
+          infinity values are replaced with the lowest finite value representable by `x`'s dtype.
+          Default value is ``None`` .
+
+    Inputs:
+        - **x** (Tensor) - Input Tensor of any dimensions. Supported data types: float32 or float16.
+
+    Outputs:
+        Tensor, has the same shape and dtype as the `x`.
+
     Supported Platforms:
         ``Ascend`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> nan_to_num = ops.NanToNum()
         >>> x = Tensor(np.array([float('nan'), float('inf'), -float('inf'), 3.14]), mindspore.float32)
         >>> output = nan_to_num(x)
@@ -7612,10 +8876,22 @@ class Orgqr(Primitive):
 
     Refer to :func:`mindspore.ops.orgqr` for more details.
 
+    Inputs:
+        - **x** (Tensor) - Tensor of shape :math:`(*, M, N)`, indicating 2D or 3D matrices,
+          with float32, float64, complex64 and complex128 data type.
+        - **tau** (Tensor) - Indicates the reflecting coefficient in Householder transformation, it has
+          shape :math:`(*, K)`, where `K` is less than or equal to `N`, and it has the same type as `x`.
+
+    Outputs:
+        Tensor, has the same shape and data type as `x`.
+
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[-114.6, 10.9, 1.1], [-0.304, 38.07, 69.38], [-0.45, -0.17, 62.]]), mindspore.float32)
         >>> tau = Tensor(np.array([1.55, 1.94, 0.0]), mindspore.float32)
         >>> net = ops.Orgqr()
@@ -7645,9 +8921,9 @@ class TriuIndices(Primitive):
     Args:
         row (int): number of rows in the 2-D matrix.
         col (int): number of columns in the 2-D matrix.
-        offset (int, optional): diagonal offset from the main diagonal. Default: 0.
+        offset (int, optional): diagonal offset from the main diagonal. Default: ``0`` .
         dtype (:class:`mindspore.dtype`, optional): The specified type of output tensor.
-            An optional data type of `mstype.int32` and `mstype.int64`. Default: `mstype.int32`.
+            An optional data type of ``mstype.int32`` and ``mstype.int64`` . Default: ``mstype.int32`` .
 
     Outputs:
         - **y** (Tensor) - indices of the elements in lower triangular part of matrix. The type specified by `dtype`.
@@ -7658,6 +8934,8 @@ class TriuIndices(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import ops
+        >>> from mindspore import dtype as mstype
         >>> net = ops.TriuIndices(5, 4, 2, mstype.int64)
         >>> output = net()
         >>> print(output)
@@ -7718,6 +8996,9 @@ class Fmax(Primitive):
         ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x1 = Tensor(np.array([1.0, 5.0, 3.0]), mindspore.float32)
         >>> x2 = Tensor(np.array([4.0, 2.0, 6.0]), mindspore.float32)
         >>> fmax = ops.Fmax()
@@ -7743,8 +9024,8 @@ class Eig(Primitive):
         This is an experimental API that is subject to change or deletion.
 
     Args:
-        compute_v (bool, optional): If `True`, compute both eigenvalues and eigenvectors;
-            If `False`, just eigenvalues will be computed. Default: False.
+        compute_v (bool, optional): If ``True`` , compute both eigenvalues and eigenvectors;
+            If `False`, just eigenvalues will be computed. Default: ``False`` .
     Inputs:
         - **x** (Tensor) - Square matrices of shape :math:`(*, N, N)`,
           with float32, float64, complex64 or complex128 data type.
@@ -7766,6 +9047,9 @@ class Eig(Primitive):
         ``Ascend`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[1.0, 0.0], [0.0, 2.0]]), mindspore.float32)
         >>> eig = ops.Eig(compute_v=True)
         >>> u, v = eig(input_x)
@@ -7790,8 +9074,8 @@ class SelfAdjointEig(Primitive):
     The eigenvalues are sorted in non-decreasing order.
 
     Args:
-         compute_v(bool): If `True` then eigenvectors will be computed and returned in v;
-              If `False`, only the eigenvalues will be computed. Default: True.
+         compute_v(bool): If ``True``  then eigenvectors will be computed and returned in v;
+              If ``False`` , only the eigenvalues will be computed. Default: ``True`` .
 
     Inputs:
          - **x** (Tensor) - Must be one of the following types:
@@ -7832,14 +9116,14 @@ class SelfAdjointEig(Primitive):
 
 class Qr(Primitive):
     """
-    Returns the QR decomposition of one or more matrices. If `full_matrices` is true, compute full-sized q and r,
-    If False (the default), compute the P columns of q where P is minimum of the 2 innermost dimensions of x.
+    Returns the QR decomposition of one or more matrices. If `full_matrices` is ``True`` , compute full-sized q and r,
+    If ``False`` (the default), compute the P columns of q where P is minimum of the 2 innermost dimensions of x.
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
 
     Args:
-        full_matrices (bool, optional): Whether compute full-sized QR decomposition. Default: False.
+        full_matrices (bool, optional): Whether compute full-sized QR decomposition. Default: ``False`` .
 
     Inputs:
         - **x** (Tensor) - A matrix to be calculated. The matrix must be at least two dimensions.
@@ -7848,10 +9132,10 @@ class Qr(Primitive):
 
     Outputs:
         - **q** (Tensor) - The orthonormal matrices of x.
-          If `full_matrices` is true, the shape is :math:`(m, m)`, else the shape is :math:`(m, p)`.
+          If `full_matrices` is ``True`` , the shape is :math:`(m, m)`, else the shape is :math:`(m, p)`.
           The dtype of `q` is same as `x`.
         - **r** (Tensor) - The upper triangular matrices of x.
-          If `full_matrices` is true, the shape is :math:`(m, n)`, else the shape is :math:`(p, n)`.
+          If `full_matrices` is ``True`` , the shape is :math:`(m, n)`, else the shape is :math:`(p, n)`.
           The dtype of `r` is same as `x`.
 
     Raises:
@@ -7863,6 +9147,8 @@ class Qr(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
         >>> qr_op = ops.Qr(full_matrices=False)
         >>> x = Tensor([[20., -31, 7], [4, 270, -90], [-8, 17, -32]], mstype.float32)
         >>> q, r = qr_op(x)
@@ -7892,10 +9178,10 @@ class Cauchy(Primitive):
 
     Args:
         size (list[int]): The size of tensor.
-        sigma (float, optional): the location parameter, specifying the location
-            of the peak of the distribution. Default: 1.0.
-        median (float, optional): the scale parameter which specifies the half-width
-            at half-maximum. Default: 0.0.
+        median (float, optional): the location parameter, specifying the location
+            of the peak of the distribution. Default: 0.0.
+        sigma (float, optional): the scale parameter which specifies the half-width
+            at half-maximum. Default: 1.0.
 
     Outputs:
         Tensor with cauchy distribution data. Tensor shape is size, and data type is float32.
@@ -7933,17 +9219,23 @@ class Ormqr(Primitive):
     Multiplies a(m, n) matrix C (given by other) with a matrix Q, where Q is represented using Householder
     reflectors (x, tau), which is the output of geqrf().
 
+    Refer to :func:`mindspore.ops.ormqr` for more details.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Args:
-        left (bool, optional): controls the order of multiplication. If true, compute op(Q)*C.
-            If false, compute C*op(Q). Default: True.
-        transpose(bool, optional): controls whether the matrix Q is conjugate transposed or not.Default: False.
+        left (bool, optional): controls the order of multiplication. If ``True`` , compute op(Q)*C.
+            If ``False`` , compute C*op(Q). Default: ``True`` .
+        transpose(bool, optional): controls whether the matrix Q is conjugate transposed or not.Default: ``False`` .
 
     Inputs:
-        - **x** (Tensor) - Tensor of shape: (*, mn, k) where mn equals to m or n depending on the the args of `left`,
+        - **x** (Tensor) - Tensor of shape :math:`(*, mn, k)` where the value of mn depending on `left`,
+          When `left` is ``True``, the value of mn is equal to m; otherwise, the value of mn is equal to n.
           and `*` is zero or more batch dimensions.
-        - **tau** (Tensor) - Tensor of shape (*, min(mn, k)) where `*` is zero or more batch dimensions,
+        - **tau** (Tensor) - Tensor of shape :math:`(*, min(mn, k))` where `*` is zero or more batch dimensions,
           and its type is the same as `x`.
-        - **other** (Tensor) - Tensor of shape (*, m, n) where `*` is zero or more batch dimensions,
+        - **other** (Tensor) - Tensor of shape :math:`(*, m, n)` where `*` is zero or more batch dimensions,
           and its type is the same as `x`.
 
     Outputs:
@@ -7956,20 +9248,23 @@ class Ormqr(Primitive):
         ValueError: If rank(x) - rank(tau) != 1.
         ValueError: If tau.shape[:-2] != x.shape[:-2]
         ValueError: If other.shape[:-2] != x.shape[:-2]
-        ValueError: If left == true, other.shape[-2] < tau.shape[-1].
-        ValueError: If left == true, other.shape[-2] != x.shape[-2].
-        ValueError: If left == false, other.shape[-1] < tau.shape[-1].
-        ValueError: If left == false, other.shape[-1] != x.shape[-2].
+        ValueError: If left == True, other.shape[-2] < tau.shape[-1].
+        ValueError: If left == True, other.shape[-2] != x.shape[-2].
+        ValueError: If left == False, other.shape[-1] < tau.shape[-1].
+        ValueError: If left == False, other.shape[-1] != x.shape[-2].
 
     Supported Platforms:
         ``GPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[-114.6, 10.9, 1.1], [-0.304, 38.07, 69.38], [-0.45, -0.17, 62]]), mindspore.float32)
         >>> tau = Tensor(np.array([1.55, 1.94, 3.0]), mindspore.float32)
         >>> other = Tensor(np.array([[-114.6, 10.9, 1.1],
-                                     [-0.304, 38.07, 69.38],
-                                     [-0.45, -0.17, 62]]), mindspore.float32)
+        ...                          [-0.304, 38.07, 69.38],
+        ...                          [-0.45, -0.17, 62]]), mindspore.float32)
         >>> net = ops.Ormqr()
         >>> y = net(x, tau, other)
         >>> print(y)