mindspore 1.10.0__cp37-cp37m-win_amd64.whl → 2.0.0rc1__cp37-cp37m-win_amd64.whl

mindspore/ops/operations/math_ops.py

@@ -14,29 +14,29 @@
 # ============================================================================
 
 """Operators for math."""
-
 from __future__ import absolute_import
 from __future__ import division
 
 import numpy as np
+
 from mindspore import context
+from mindspore import log as logger
 from mindspore.ops import signature as sig
-from mindspore._checkparam import Validator as validator
-from mindspore._checkparam import Rel
+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.ops._utils import is_shape_unknown
+from mindspore.common._utils import is_shape_unknown
 
 
 def _infer_shape_reduce(x, axis, keep_dims, prim_name):
     """Common infer for reduce operator"""
 
     def reduce_one_axis(one_axis):
-        validator.check_int_range(one_axis, -dim, dim, Rel.INC_LEFT, 'axis', prim_name)
+        validator.check_int_range(one_axis, -dim, dim, validator.INC_LEFT, 'axis', prim_name)
         if one_axis < 0:
             one_axis += dim
         axis_reduce.add(one_axis)
@@ -102,9 +102,9 @@ class _MathBinaryOp(_BinaryOp):
                 (mstype.float64, mstype.complex128): mstype.tensor_type(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],'
-                                + '[complex64, float32], [float32, complex64], [complex128, complex128],'
-                                + '[complex128, float64], [float64, complex128],'
+                raise TypeError('Complex math binary op expecting Tensor [Complex64, Complex64],'
+                                + '[Complex64, Float32], [Float32, Complex64], [Complex128, Complex128],'
+                                + '[Complex128, Float64], [Float64, Complex128],'
                                 + f'but got : [{format(x_dtype)},{format(y_dtype)}].')
             return type_infer_dict.get((x_dtype.element_type(), y_dtype.element_type()))
 
@@ -150,7 +150,7 @@ class Ger(Primitive):
     shape :math:`(m,)` and `x2` is a 1D Tensor of shape :math:`(n,)`, then `output` must be a 2D Tensor of shape
     :math:`(m, n)`.
 
-    Refer to :func:`mindspore.ops.ger` for more detail.
+    Refer to :func:`mindspore.ops.ger` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -177,7 +177,7 @@ class Add(_MathBinaryOp):
     r"""
     Adds two input tensors element-wise.
 
-    Refer to :func:`mindspore.ops.add` for more detail.
+    Refer to :func:`mindspore.ops.add` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -218,14 +218,6 @@ class Add(_MathBinaryOp):
             return out
         return None
 
-    def _infer_min_value(self, x, y):
-        """Calculate min value for output for Add op"""
-        return self._infer_specified_add_value(x, y)
-
-    def _infer_max_value(self, x, y):
-        """Calculate max value for output for Add op"""
-        return self._infer_specified_add_value(x, y)
-
     def infer_value(self, x, y):
         if x is not None and y is not None:
             x = x.asnumpy()
@@ -235,6 +227,14 @@ class Add(_MathBinaryOp):
             return Tensor(out)
         return None
 
+    def _infer_min_value(self, x, y):
+        """Calculate min value for output for Add op"""
+        return self._infer_specified_add_value(x, y)
+
+    def _infer_max_value(self, x, y):
+        """Calculate max value for output for Add op"""
+        return self._infer_specified_add_value(x, y)
+
     def _infer_shape_value(self, x, y):
         shape_value = self._infer_specified_add_value(x, y)
         shape_value = self._convert_back_shape(shape_value, x)
@@ -243,8 +243,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.
+    Performs the element-wise division of tensor `x1` by tensor `x2`,
+    multiply the result by the scalar `value` and add it to `input_data`.
 
     .. math::
         y[i] = input\_data[i] + value[i] * (x1[i] / x2[i])
@@ -260,9 +260,10 @@ class Addcdiv(Primitive):
 
     Raises:
         TypeError: If dtype of `x1`, `x2`, `value`, `input_data` is not tensor.
-        ValueError: If `x1` could not be broadcast to a tensor with shape of `x2`.
-        ValueError: If `value` could not be broadcast to tensors with shapes of `x1/x2`.
-        ValueError: If `input_data` could not be broadcast to tensors with shapes of `value*(x1/x2)`.
+        TypeError: If dtype of `x1`, `x2`, `value`, `input_data` are not the same.
+        ValueError: If `x1` could not be broadcast to `x2`.
+        ValueError: If `value` could not be broadcast to `x1/x2`.
+        ValueError: If `input_data` could not be broadcast to `value*(x1/x2)`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -286,8 +287,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.
+    Performs the element-wise product of tensor `x1` and tensor `x2`,
+    multiply the result by the scalar `value` and add it to `input_data`.
 
     .. math::
         output[i] = input\_data[i] + value[i] * (x1[i] * x2[i])
@@ -303,15 +304,13 @@ class Addcmul(Primitive):
 
     Raises:
         TypeError: If dtype of `x1`, `x2`, `value`, `input_data` is not tensor.
-        TypeError: If dtype of `input_data` is not one of: float32, float16, int32.
-        TypeError: If dtype of `x1` or `x2` is not one of: float32, float16, int32.
-        TypeError: If dtype of `value` is not one of: float32, float16, int32.
-        ValueError: If `x1` could not be broadcast to a tensor with shape of `x2`.
-        ValueError: If `value` could not be broadcast to tensors with shapes of `x1` * `x2`.
-        ValueError: If `input_data` could not be broadcast to tensors with shapes of `value*(x1*x2)`.
+        TypeError: If dtype of `x1`, `x2`, `value`, `input_data` are not the same.
+        ValueError: If `x1` could not be broadcast to `x2`.
+        ValueError: If `value` could not be broadcast to `x1` * `x2`.
+        ValueError: If `input_data` could not be broadcast to `value*(x1*x2)`.
 
     Supported Platforms:
-        ``Ascend`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> input_data = Tensor(np.array([1, 1, 1]), mindspore.float32)
@@ -338,8 +337,9 @@ class AddV2(Primitive):
 
     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, the shapes of them should be the same.
+    When the inputs are two tensors, and the shapes of them can be broadcast.
     When the inputs are one tensor and one scalar, the scalar could only be a constant.
+    CPU/Ascend does not support broadcast for now.
 
     .. math::
 
@@ -358,14 +358,14 @@ class AddV2(Primitive):
         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 neither `x` nor `y` is a Tensor.
         TypeError: If dtype of `x` or `y` is not in [float16, float32, float64,
         uint8, int8, int16, int32, int64, complex64, complex128].
-        ValueError: If the shape of 'x' and 'y' is not the same.
+        ValueError: If the shape of 'x' and 'y' is not the same for CPU and Ascend.
 
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> from mindspore.ops.operations.math_ops import AddV2
@@ -410,7 +410,7 @@ class AssignAdd(Primitive):
     """
     Updates a `Parameter` by adding a value to it.
 
-    Refer to :func:`mindspore.ops.assign_add` for more detail.
+    Refer to :func:`mindspore.ops.assign_add` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -448,7 +448,7 @@ class AssignSub(Primitive):
     """
     Updates a `Parameter` by subtracting a value from it.
 
-    Refer to :func:`mindspore.ops.assign_sub` for more detail.
+    Refer to :func:`mindspore.ops.assign_sub` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -513,11 +513,12 @@ class _Reduce(PrimitiveWithCheck):
         value = None
         if input_x is not None and axis is not None:
             prim_map = {
-                'ReduceSum': np.sum,
                 'ReduceMax': np.max,
                 'ReduceMin': np.min,
                 'ReduceProd': np.prod,
                 'ReduceMean': np.mean,
+                'ReduceAll': np.all,
+                'ReduceAny': np.any,
             }
             np_reduce_func = prim_map.get(self.name, None)
 
@@ -535,6 +536,47 @@ class _Reduce(PrimitiveWithCheck):
         return value
 
 
+class EuclideanNorm(Primitive):
+    """
+    Calculates the Euclidean norm(aka L2 norm) of a Tensor along the specified axes.
+    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.
+
+    Inputs:
+        - **x** (Tensor) - The input Tensor to reduce.
+        - **axes** (Tensor) - The axes to perform reduction on. Must be one of the following types: int32, int64.
+          It must be in range :math:`[-rank(x), rank(x))`.
+
+    Outputs:
+        Tensor, has the same type as the 'x'.
+
+    Raises:
+        TypeError: If `keep_dims` is not a bool.
+        TypeError: If `x` is not a Tensor.
+        ValueError: If `axes` is out of range.
+
+    Supported Platforms:
+        ``GPU``
+
+    Examples:
+        >>> x = Tensor(np.array([[3, 5], [4, 12]])).astype(np.int32)
+        >>> axes = Tensor([0])
+        >>> op = ops.EuclideanNorm(keep_dims=True)
+        >>> output = op(x, axes)
+        >>> print(output)
+        [[5 13]]
+    """
+
+    @prim_attr_register
+    def __init__(self, keep_dims=False):
+        """Initialize"""
+        self.init_prim_io_names(inputs=['x', 'axes'], outputs=['y'])
+        validator.check_value_type("keep_dims", keep_dims, [bool], self.name)
+
+
 class ReduceMean(_Reduce):
     """
     Reduces a dimension of a tensor by averaging all elements in the dimension, by default. And also can reduce
@@ -547,7 +589,7 @@ class ReduceMean(_Reduce):
 
     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.
+          :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).
 
@@ -619,7 +661,75 @@ class ReduceMean(_Reduce):
         super(ReduceMean, self).__init__(keep_dims)
 
 
-class ReduceSum(_Reduce):
+class CumulativeLogsumexp(Primitive):
+    """
+    Compute the cumulative log-sum-exp of the input tensor `x` along `axis` . For example, with all parameters at
+    default values, if the input `x` is a tensor [a, b, c], the output will be [a, log(exp(a) + exp(b)),
+    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 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.
+
+    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.
+
+    Outputs:
+        Tensor, has the same dtype and shape as the `x`.
+
+    Raises:
+        TypeError: If `x` or `axis` not a Tensor.
+        TypeError: If dtype of `x` is not in [float16, float32, float64].
+        TypeError: If dtype of `axis` is not in [int16, int32, int64].
+        TypeError: If `exclusive` or `reverse` is not a bool.
+        ValueError: If the dimension of `x` is not greater than 0.
+        RuntimeError: If `axis` is out of range [-rank(x), rank(x)).
+
+    Supported Platforms:
+        ``Ascend`` ``CPU`` ``GPU``
+
+    Examples:
+        >>> x = Tensor(np.array([1.0, 2.0, 3.0]).astype(np.float32))
+        >>> op = ops.CumulativeLogsumexp(exclusive=False, reverse=False)
+        >>> output = op(x, Tensor(0))
+        >>> print(output)
+        [1.        2.3132617 3.407606 ]
+        >>> x = Tensor(np.array([1.0, 2.0, 3.0]).astype(np.float32))
+        >>> op = ops.CumulativeLogsumexp(exclusive=True, reverse=False)
+        >>> output = op(x, Tensor(0))
+        >>> print(output)
+        [-3.4028235e+38  1.0000000e+00  2.3132617e+00]
+        >>> x = Tensor(np.array([1.0, 2.0, 3.0]).astype(np.float32))
+        >>> op = ops.CumulativeLogsumexp(exclusive=False, reverse=True)
+        >>> output = op(x, Tensor(0))
+        >>> print(output)
+        [3.407606  3.3132617 3.       ]
+        >>> x = Tensor(np.array([1.0, 2.0, 3.0]).astype(np.float32))
+        >>> op = ops.CumulativeLogsumexp(exclusive=True, reverse=True)
+        >>> output = op(x, Tensor(0))
+        >>> print(output)
+        [ 3.3132617e+00  3.0000000e+00 -3.4028235e+38]
+    """
+
+    @prim_attr_register
+    def __init__(self, exclusive=False, reverse=False):
+        """Initialize  CumulativeLogsumexp"""
+        self.init_prim_io_names(inputs=['x', 'axis'], outputs=['y'])
+        validator.check_bool(exclusive, "exclusive", self.name)
+        validator.check_bool(reverse, "reverse", self.name)
+
+
+class ReduceSum(PrimitiveWithCheck):
     """
     Reduces a dimension of a tensor by summing all elements in the dimension, by default. And also can reduce a
     dimension of `x` along the axis. Determine whether the dimensions of the output and input are the same by
@@ -628,18 +738,24 @@ class ReduceSum(_Reduce):
     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,
+                          skip it.
+                          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.
-           Only constant value is allowed. Must be in the range [-rank(`x`), rank(`x`)).
+           :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`)).
 
     Outputs:
         Tensor, has the same dtype as the `x`.
 
-        - If axis is (), and keep_dims 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,
+          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,
           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,
@@ -647,6 +763,7 @@ class ReduceSum(_Reduce):
 
     Raises:
         TypeError: If `keep_dims` is not a bool.
+        TypeError: If `skip_mode` is not a bool.
         TypeError: If `x` is not a Tensor.
         ValueError: If `axis` is None.
 
@@ -694,12 +811,44 @@ class ReduceSum(_Reduce):
           [54.]]]
     """
 
+    __mindspore_signature__ = (
+        sig.make_sig('input_x'),
+        sig.make_sig('axis', default=())
+    )
+
     @prim_attr_register
-    def __init__(self, keep_dims=False):
-        """Initialize ReduceSum"""
-        super(ReduceSum, self).__init__(keep_dims)
+    def __init__(self, keep_dims=False, skip_mode=False):
+        """Initialize Reduce"""
+        validator.check_value_type('keep_dims', keep_dims, [bool], self.name)
+        validator.check_value_type('skip_mode', skip_mode, [bool], self.name)
+        self.init_prim_io_names(inputs=['input_x', 'axis'], outputs=['y'])
+        self.keep_dims = keep_dims
+        self.skip_mode = skip_mode
         self.__setattr_flag__ = True
 
+    def __call__(self, x, axis=()):
+        args = [x, axis]
+        output = _run_op(self, self.name, args)
+        return output
+
+    def infer_value(self, input_x, axis):
+        """ return reduce op value"""
+        value = None
+        if input_x is not None and axis is not None:
+            value = input_x.asnumpy()
+            if isinstance(axis, int):
+                pass
+            elif axis:
+                axis = tuple(set(axis))
+            elif axis in ((), []) and self.skip_mode:
+                return input_x
+            else:
+                axis = tuple(range(len(value.shape)))
+            value = np.sum(value, axis, keepdims=self.keep_dims)
+            value = np.array(value)
+            value = Tensor(value)
+        return value
+
 
 class ReduceAll(_Reduce):
     """
@@ -823,7 +972,7 @@ class ReduceMax(_Reduce):
 
     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.
+           :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).
 
@@ -907,7 +1056,7 @@ class ReduceMin(_Reduce):
 
     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.
+          :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).
 
@@ -975,10 +1124,10 @@ class ReduceMin(_Reduce):
 
 class Bucketize(Primitive):
     """
-    Bucketizes 'input' based on 'boundaries'.
+    Bucketizes `input` based on `boundaries`.
 
     Args:
-        boundaries (list_float): A sorted list of floats gives the boundary of the buckets, and no default value.
+        boundaries (list[float]): A sorted list of floats gives the boundary of the buckets, and no default value.
 
     Inputs:
         - **input** (Tensor) - A tensor containing the search value(s).
@@ -991,13 +1140,13 @@ class Bucketize(Primitive):
         TypeError: If `input` is not a Tensor.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> class Bucketize(nn.Cell):
         ...     def __init__(self, boundaries):
         ...         super().__init__()
-        ...         self.bucketize = op.Bucketize(boundaries=boundaries)
+        ...         self.bucketize = ops.Bucketize(boundaries=boundaries)
         ...     def construct(self, input):
         ...         return self.bucketize(input)
         >>> input = Tensor(np.array([[3, 6, 9], [3, 6, 9]]).astype(np.int32))
@@ -1026,11 +1175,11 @@ class ReduceProd(_Reduce):
 
     Args:
         keep_dims (bool): If true, keep these reduced dimensions and the length is 1.
-                          If false, don't keep these dimensions. Default : False.
+                          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.
+          :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).
 
@@ -1175,7 +1324,10 @@ class Lcm(Primitive):
     """
     Computes least common multiplier of input tensors element-wise.
     The shape of two inputs should be broadcastable, and data type of them should be
-    one of: int32, int64
+    one of: int32, int64.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Inputs:
         - **x1** (Tensor) - The first input tensor.
@@ -1190,7 +1342,7 @@ class Lcm(Primitive):
         ValueError: If shape of two inputs are not broadcastable.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x1 = Tensor(np.array([7, 8, 9]))
@@ -1212,12 +1364,15 @@ class Cdist(Primitive):
     """
     Computes batched the p-norm distance between each pair of the two collections of row vectors.
 
-    Refer to :func:`mindspore.ops.cdist` for more detail.
+    Refer to :func:`mindspore.ops.cdist` for more details.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[[1.0, 1.0], [2.0, 2.0]]]).astype(np.float32))
         >>> input_y = Tensor(np.array([[[3.0, 3.0], [3.0, 3.0]]]).astype(np.float32))
         >>> op = ops.Cdist(p=2.0)
@@ -1243,7 +1398,29 @@ class LpNorm(Primitive):
     .. math::
         output = sum(abs(input)**p)**(1/p)
 
-    Refer to :func:`mindspore.ops.norm` for more detail.
+    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.
+
+    Inputs:
+        - **input** (Tensor) - Input tensor.
+
+    Outputs:
+        Tensor, has the same dtype as `input`, its shape depends on `axis`. For example, if the shape of input
+        is :math:`(2, 3, 4)`, `axis` is :math:`[0, 1]`, output shape will be :math:`(4,)`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If dtype of `input` is not one of: float16, float32.
+        TypeError: If `p` is not an int.
+        TypeError: If `axis` is not an int, a tuple or a list.
+        TypeError: If `axis` is a tuple or a list, but the element of `axis` is not an int.
+        TypeError: If `keep_dims` is not a bool.
+        ValueError: If the element of `axis` is out of the range :math:`[-r, r)`,
+            where :math:`r` is the rank of `input`.
+        ValueError: If the length of shape of `axis` is bigger than the length of shape of `input`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1293,9 +1470,9 @@ class MatMul(PrimitiveWithCheck):
 
     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:`(N, C)` 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:`(C, M)` 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)`.
@@ -1359,9 +1536,8 @@ class MatMul(PrimitiveWithCheck):
 
     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,),
-                                                      self.name)
+        validator.check_tensors_dtypes_same_and_valid(args, mstype.float_type + mstype.int_type
+                                                      + (mstype.complex64, mstype.complex128), self.name)
 
 
 class BatchMatMul(Primitive):
@@ -1403,28 +1579,14 @@ class BatchMatMul(Primitive):
         >>> y = Tensor(np.ones(shape=[2, 4, 3, 4]), mindspore.float32)
         >>> batmatmul = ops.BatchMatMul()
         >>> output = batmatmul(x, y)
-        >>> print(output)
-        [[[[3. 3. 3. 3.]]
-          [[3. 3. 3. 3.]]
-          [[3. 3. 3. 3.]]
-          [[3. 3. 3. 3.]]]
-         [[[3. 3. 3. 3.]]
-          [[3. 3. 3. 3.]]
-          [[3. 3. 3. 3.]]
-          [[3. 3. 3. 3.]]]]
+        >>> print(output.shape)
+        (2, 4, 1, 4)
         >>> x = Tensor(np.ones(shape=[2, 4, 3, 1]), mindspore.float32)
         >>> y = Tensor(np.ones(shape=[2, 4, 3, 4]), mindspore.float32)
         >>> batmatmul = ops.BatchMatMul(transpose_a=True)
         >>> output = batmatmul(x, y)
-        >>> print(output)
-        [[[[3. 3. 3. 3.]]
-          [[3. 3. 3. 3.]]
-          [[3. 3. 3. 3.]]
-          [[3. 3. 3. 3.]]]
-         [[[3. 3. 3. 3.]]
-          [[3. 3. 3. 3.]]
-          [[3. 3. 3. 3.]]
-          [[3. 3. 3. 3.]]]]
+        >>> print(output.shape)
+        (2, 4, 1, 4)
     """
 
     @prim_attr_register
@@ -1434,14 +1596,15 @@ class BatchMatMul(Primitive):
         cls_name = self.name
         validator.check_value_type("transpose_a", transpose_a, [bool], cls_name)
         validator.check_value_type("transpose_b", transpose_b, [bool], cls_name)
+        self.add_prim_attr('adj_x1', self.transpose_a)
+        self.add_prim_attr('adj_x2', self.transpose_b)
 
 
 class Betainc(Primitive):
     r"""
-    Computes the regularized incomplete beta integral
-    :math:`I_{x}(a, b)`.
-
-    The regularized incomplete beta integral is defined as:
+    Calculates the regularized incomplete beta function
+    :math:`I_{x}(a, b)`. It is defined as the ratio of the incomplete beta function
+    to the complete beta function:
 
     .. math::
 
@@ -1451,17 +1614,26 @@ class Betainc(Primitive):
 
     .. math::
 
-        B(x ; a, b)=\int_{0}^{x} t^{a-1}(1-t)^{b-1} d t
+        B(x ; a, b)=\int_{0}^{x} t^{a-1}(1-t)^{b-1} dt
+
+    is the incomplete beta function and
+
+    .. math::
+
+        B(a, b) = \int_0^1 t^{a-1} (1-t)^{b-1} dt
 
-    is the incomplete beta function and B(a, b) is the complete beta function
+    is the complete beta function.
 
     Inputs:
-        - **a** (Tensor) - A Tensor of types: float32, float64.
-        - **b** (Tensor) - A Tensor, must have the same dtype and shape as a.
-        - **x** (Tensor) - A Tensor, must have the same dtype and shape as a.
+        - **a** (Tensor) - Peak location of beta distribution.
+          A Tensor of types: float32, float64.
+        - **b** (Tensor) - Spread of the beta distribution.
+          A Tensor, must have the same dtype and shape as `a` .
+        - **x** (Tensor) - Upper limit of integration of the incomplete beta function.
+          A Tensor, must have the same dtype and shape as `a` .
 
     Outputs:
-        A Tensor, has the same dtype and shape as a.
+        A Tensor, has the same dtype and shape as `a` .
 
     Raises:
         TypeError: If dtype of `a` is not float32 nor float64.
@@ -1470,20 +1642,21 @@ class Betainc(Primitive):
 
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
-    Example:
-        >>> a = Tensor(np.array([1, 1, 1]), mindspore.float32)
-        >>> b = Tensor(np.array([1, 1, 1]), mindspore.float32)
-        >>> x = Tensor(np.array([1, 1,1 ]), mindspore.float32)
+    Examples:
+        >>> a = Tensor(np.array([0.3, 0.1, 0.4]), mindspore.float32)
+        >>> b = Tensor(np.array([0.4, 0.5, 0.9]), mindspore.float32)
+        >>> x = Tensor(np.array([0.2, 0.6, 0.5]), mindspore.float32)
         >>> betainc = ops.Betainc()
         >>> print(betainc(a, b, x))
-        [1. 1. 1.]
+        [0.41462693 0.8706035  0.7298298 ]
     """
 
     @prim_attr_register
     def __init__(self):
         """Initialize Betainc"""
+        self.init_prim_io_names(inputs=['a', 'b', 'x'], outputs=['output'])
 
 
 class CumSum(Primitive):
@@ -1563,7 +1736,7 @@ class AddN(Primitive):
     """
     Computes addition of all input tensors element-wise.
 
-    Refer to :func:`mindspore.ops.addn` for more detail.
+    Refer to :func:`mindspore.ops.addn` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1604,26 +1777,10 @@ class AccumulateNV2(Primitive):
     """
     Computes accumulation of all input tensors element-wise.
 
-    AccumulateNV2 is similar to AddN, but there is a significant difference
-    among them: AccumulateNV2 will not wait for all of its inputs to be ready
-    before summing. That is to say, AccumulateNV2 is able to save
-    memory when inputs are ready at different time since the minimum temporary
-    storage is proportional to the output size rather than the input size.
-
-    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`.
-
-    Raises:
-        TypeError: If `x` is neither tuple nor list.
-        ValueError: If there is an input element with a different shape.
+    Refer to :func:`mindspore.ops.accumulate_n` for more details.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``GPU``
 
     Examples:
         >>> class NetAccumulateNV2(nn.Cell):
@@ -1662,7 +1819,7 @@ class Neg(Primitive):
     """
     Returns a tensor with negative values of the input tensor element-wise.
 
-    Refer to :func:`mindspore.ops.neg` for more detail.
+    Refer to :func:`mindspore.ops.neg` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1683,37 +1840,25 @@ class Neg(Primitive):
 
 class InplaceUpdateV2(Primitive):
     r"""
-    Updates specified rows with values in `v`.
-
-    Note:
-        This operator only supports dynamic shape. As for static shape, please use operator 'InplaceUpdate' instead.
+    Updates specified values in `x` to `v` according to `indices`.
 
-    Args:
-
-    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`.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
-    Raises:
-        TypeError: If `indices` is neither int nor tuple.
-        TypeError: If `indices` is a tuple and its element is not an int.
+    Refer to :func:`mindspore.ops.inplace_update` for more details.
 
     Supported Platforms:
-        ``Ascend``
+        ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> indices = (0, 1)
         >>> x = Tensor(np.array([[1, 2], [3, 4], [5, 6]]), mindspore.float32)
         >>> v = Tensor(np.array([[0.5, 1.0], [1.0, 1.5]]), mindspore.float32)
-        >>> inplace_update = ops.InplaceUpdate(indices)
-        >>> output = inplace_update(x, v)
+        >>> inplace_update_v2 = ops.InplaceUpdateV2()
+        >>> output = inplace_update_v2(x, indices, v)
         >>> print(output)
         [[0.5 1. ]
          [1.  1.5]
@@ -1731,42 +1876,15 @@ class InplaceUpdateV2(Primitive):
         return output
 
 
-class InplaceUpdate(PrimitiveWithInfer):
+class InplaceUpdate(Primitive):
     r"""
-    Updates specified rows with values in `v`.
-
-    Args:
-        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).
-
-    Inputs:
-        - **x** (Tensor) - A tensor which to be inplace updated. It can be one of the following data types:
-          float32, float16 and int32.
-        - **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`.
-
-    Raises:
-        TypeError: If `indices` is neither int nor tuple.
-        TypeError: If `indices` is a tuple and its element is not an int.
+    The InplaceUpdate interface is deprecated. Please use the :class:`mindspore.ops.InplaceUpdateV2` instead.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> indices = (0, 1)
-        >>> x = Tensor(np.array([[1, 2], [3, 4], [5, 6]]), mindspore.float32)
-        >>> v = Tensor(np.array([[0.5, 1.0], [1.0, 1.5]]), mindspore.float32)
-        >>> inplace_update = ops.InplaceUpdate(indices)
-        >>> output = inplace_update(x, v)
-        >>> print(output)
-        [[0.5 1. ]
-         [1.  1.5]
-         [5.  6. ]]
+        Deprecated
     """
 
+    @deprecated("2.0", "ops.InplaceUpdateV2", False)
     @prim_attr_register
     def __init__(self, indices):
         """Initialize InplaceUpdate"""
@@ -1779,14 +1897,14 @@ class InplaceUpdate(PrimitiveWithInfer):
             validator.check_value_type("item of indices", item, [int], self.name)
 
 
-class InplaceAdd(PrimitiveWithInfer):
+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 detail.
+    Refer to :func:`mindspore.ops.inplace_add` for more details.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -1814,35 +1932,53 @@ class InplaceAdd(PrimitiveWithInfer):
         for item in self.indices:
             validator.check_value_type("item of indices", item, [int], self.name)
 
-    def infer_dtype(self, x_dtype, v_dtype):
-        args = {'x': x_dtype, 'v': v_dtype}
-        valid_type = [mstype.int32, mstype.float16, mstype.float32]
-        validator.check_tensors_dtypes_same_and_valid(args, valid_type, self.name)
-        return x_dtype
 
-    def infer_shape(self, x_shape, v_shape):
-        validator.check("x", len(x_shape), "v", len(v_shape), Rel.EQ, self.name)
-        validator.check("size of indices", len(self.indices), "v's first dimension", v_shape[0],
-                        Rel.EQ, self.name)
-        for i in self.indices:
-            if i < 0 or i >= x_shape[0]:
-                raise ValueError(f"For '{self.name}', the value of 'indices' must be "
-                                 f"in [0, {x_shape[0]}), but got {i}.")
-        x_rank = len(x_shape)
-        for idx in range(x_rank)[1:]:
-            validator.check('v dim %d' % idx, v_shape[idx], "x dim %d" % idx, x_shape[idx], Rel.EQ, self.name)
+class InplaceIndexAdd(Primitive):
+    """
+    Adds Tensor `updates` to specified axis and indices of Tensor `var` element-wise.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Refer to :func:`mindspore.ops.inplace_index_add` for more details.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> 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)
+        >>> inplaceIndexAdd = ops.InplaceIndexAdd(axis=0)
+        >>> var = inplaceIndexAdd(var, indices, updates)
+        >>> print(var)
+        [[1.5 3. ]
+         [4.  5.5]
+         [5.  6. ]]
+    """
+
+    __mindspore_signature__ = (
+        sig.make_sig('var', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
+        sig.make_sig('indices', dtype=sig.sig_dtype.T1),
+        sig.make_sig('updates', dtype=sig.sig_dtype.T)
+    )
 
-        return x_shape
+    @prim_attr_register
+    def __init__(self, axis):
+        """Initialize InplaceIndexAdd"""
+        self.init_prim_io_names(inputs=['var', 'indices', 'updates'], outputs=['var'])
+        self.axis = axis
+        validator.check_value_type('axis', axis, [int], self.name)
 
 
-class InplaceSub(PrimitiveWithInfer):
+class InplaceSub(Primitive):
     r"""
     Subtracts `v` into specified rows of `x`. Computes :math:`y = x`; :math:`y[i,] -= input\_v`.
 
-    Refer to :func:`mindspore.ops.inplace_sub` for more detail.
+    Refer to :func:`mindspore.ops.inplace_sub` for more details.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -1869,33 +2005,14 @@ class InplaceSub(PrimitiveWithInfer):
             self.indices = (indices,)
         for item in self.indices:
             validator.check_value_type("item of indices", item, [int], self.name)
-
-    def infer_dtype(self, x_dtype, v_dtype):
-        args = {'x': x_dtype, 'v': v_dtype}
-        valid_type = [mstype.int32, mstype.float16, mstype.float32]
-        validator.check_tensors_dtypes_same_and_valid(args, valid_type, self.name)
-        return x_dtype
-
-    def infer_shape(self, x_shape, v_shape):
-        validator.check("x", len(x_shape), "v", len(v_shape), Rel.EQ, self.name)
-        validator.check("size of indices", len(self.indices), "v's first dimension", v_shape[0],
-                        Rel.EQ, self.name)
-        for i in self.indices:
-            if i < 0 or i >= x_shape[0]:
-                raise ValueError(f"For '{self.name}', the value of 'indices' must be "
-                                 f"in [0, {x_shape[0]}), but got {i}.")
-        x_rank = len(x_shape)
-        for idx in range(x_rank)[1:]:
-            validator.check('v dim %d' % idx, v_shape[idx], "x dim %d" % idx, x_shape[idx], Rel.EQ, self.name)
-
-        return x_shape
+        self.add_prim_attr("indices", self.indices)
 
 
 class Sub(_MathBinaryOp):
     r"""
     Subtracts the second input tensor from the first input tensor element-wise.
 
-    Refer to :func:`mindspore.ops.sub` for more detail.
+    Refer to :func:`mindspore.ops.sub` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1923,7 +2040,7 @@ class Mul(_MathBinaryOp):
     r"""
     Multiplies two tensors element-wise.
 
-    Refer to :func:`mindspore.ops.mul` for more detail.
+    Refer to :func:`mindspore.ops.mul` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1937,6 +2054,17 @@ class Mul(_MathBinaryOp):
         [ 4. 10. 18.]
     """
 
+    # Let x/y using same sig_dtype to enable implicit conversion for compatibility
+    __mindspore_signature__ = (
+        sig.make_sig('x', rw=sig.sig_rw.RW_READ, dtype=sig.sig_dtype.T),
+        sig.make_sig('y', rw=sig.sig_rw.RW_READ, dtype=sig.sig_dtype.T)
+    )
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize Xdivy."""
+        self.init_prim_io_names(inputs=['x', 'y'], outputs=['output'])
+
     @staticmethod
     def _infer_specified_mul_value(x, y):
         """Calculate min/max value for output of Mul op"""
@@ -1991,10 +2119,9 @@ class SquaredDifference(Primitive):
         out_{i} = (x_{i} - y_{i}) * (x_{i} - y_{i}) = (x_{i} - y_{i})^2
 
     Inputs:
-        - **x** (Union[Tensor, Number, bool]) - The first input is a number, or a bool,
-          or a tensor whose data type is float16, float32, int32 or bool.
+        - **x** (Union[Tensor, Number, bool]) - The first input is a number, or a bool, or a tensor.
         - **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 float16, float32, int32 or bool.
+          is a tensor, or a tensor.
 
     Outputs:
         Tensor, the shape is the same as the one after broadcasting,
@@ -2104,7 +2231,8 @@ class Sqrt(Primitive):
         out_{i} =  \sqrt{x_{i}}
 
     Inputs:
-        - **x** (Tensor) - The input tensor with a dtype of Number, its rank must be in [0, 7] inclusive.
+        - **x** (Tensor) - The input tensor with a dtype of Number, the shape is :math:`(N, *)`
+          where :math:`*` means, any number of additional dimensions.
 
     Outputs:
         Tensor, has the same shape and data type as the `x`.
@@ -2129,7 +2257,7 @@ class Sqrt(Primitive):
         self.init_prim_io_names(inputs=['x'], outputs=['output'])
 
 
-class Reciprocal(PrimitiveWithInfer):
+class Reciprocal(PrimitiveWithCheck):
     r"""
     Returns reciprocal of a tensor element-wise.
 
@@ -2167,13 +2295,6 @@ class Reciprocal(PrimitiveWithInfer):
             self.target = "OTHER"
         self.init_prim_io_names(inputs=['x'], outputs=['y'])
 
-    def infer_shape(self, x):
-        return x
-
-    def infer_dtype(self, x):
-        validator.check_subclass("x", x, mstype.tensor, self.name)
-        return x
-
     def infer_value(self, x):
         if x is not None:
             x = x.asnumpy()
@@ -2187,7 +2308,7 @@ class Pow(Primitive):
     r"""
     Calculates the `y` power of each element in `x`.
 
-    Refer to :func:`mindspore.ops.pow` for more detail.
+    Refer to :func:`mindspore.ops.pow` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2229,7 +2350,7 @@ class Exp(Primitive):
     r"""
     Returns exponential of a tensor element-wise.
 
-    Refer to :func:`mindspore.ops.exp` for more detail.
+    Refer to :func:`mindspore.ops.exp` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2255,21 +2376,22 @@ class Logit(Primitive):
     r"""
     Calculate the logit of a tensor element-wise. Element in `x` is clamped to [eps, 1-eps].
 
-    .. math::
-        \begin{align}
-        y_{i} & = \ln(\frac{z_{i}}{1 - z_{i}}) \\
-        z_{i} & = \begin{cases}
-        x_{i} & \text{if eps is None} \\
-        \text{eps} & \text{if } x_{i} \lt \text{eps} \\
-        x_{i} & \text{if } \text{eps} \leq x_{i} \leq 1 - \text{eps} \\
-        1 - \text{eps} & \text{if } x_{i} \gt 1 - \text{eps}
-        \end{cases}
-        \end{align}
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    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.
 
-    Refer to :func:`mindspore.ops.logit` for more detail.
+    Inputs:
+        - **x** (Tensor) - The input tensor.
+
+    Outputs:
+        Tensor, with the same shape and dtype as the `x`.
 
     Supported Platforms:
-        ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([0.1, 0.2, 0.3]).astype(np.float32))
@@ -2289,10 +2411,33 @@ class Logit(Primitive):
 
 class ReduceStd(Primitive):
     """
-    Returns the standard-deviation and mean of each row of the input tensor in the dimension `axis`.
-    If `axis` is a list of dimensions, reduce over all of them.
+    Returns the standard-deviation and mean of the input Tensor along
+    dimension(s) specified by `axis`.
+
+    Args:
+        axis (Union[int, tuple(int), list(int)], optional): The dimensions to reduce.
+            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.
+        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.
 
-    Refer to :func:`mindspore.ops.std` for more detail.
+    Inputs:
+        - **input_x** (Tensor[Number]) - The input Tensor, it has dtype Number with shape
+          :math:`(N, *)` where :math:`*` means any number of additional dimensions.
+
+    Outputs:
+        Tuple(output_std, output_mean) containing the standard deviation and mean.
+
+    Raises:
+        TypeError: If `keep_dims` is not a bool.
+        TypeError: If `input_x` is not a Tensor.
+        ValueError: If `axis` is not one of the following: int, tuple or list.
 
     Supported Platforms:
         ``Ascend`` ``CPU``
@@ -2324,12 +2469,13 @@ class ReduceStd(Primitive):
 
 class Einsum(Primitive):
     """
-    This operator uses equation to represent a tuple of tensors operations,
-    you can use this operator to perform diagonal/reducesum/transpose/matmul/mul/inner product operations, etc.
+    Sums the product of the elements of the input Tensor along
+    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
+    dtypes of them should be float16/float32/float64.
 
     Args:
         equation (str): An attribute, represent the operation you want to do.
@@ -2423,21 +2569,83 @@ class Einsum(Primitive):
         self.init_prim_io_names(inputs=['inputs'], outputs=['output'])
 
 
-class Expm1(Primitive):
-    r"""
-    Returns exponential then minus 1 of a tensor element-wise.
+class Diagonal(Primitive):
+    """
+    Create a tensor with specific diagonal elements of input. This operator extracts the diagonal elements with
+    offset from the 2-D sub-tensors which specified by dim1 and dim2.
+    The shape of output tensor can be dertermined by removing dim1 and dim2 form the shape of input and appending
+    a dimension at the end. The size of the last dimension is the length of diagonal.
+
+    Args:
+        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.
+
+    Inputs:
+        - **x** (Tensor) - The input to take diagonal, with float32 or double data type.
+          The input must be at least 2-dimensional.
+          The shape is :math:`(N_{0}, N_{1}, *)` where :math:`*` means, any number of additional dimensions.
+
+    Outputs:
+        - **y** (Tensor) - A tensor whose values are diagonal of input, with the same data type as input.
+          The shape of the output is one dimension lower than the input.
+          If the shape of `x` is :math:`(d_{0}, d_{1}, ..., d_{n-1})`, the size of the `dim1` dimension
+          is :math:`d_{i}` and the size of the `dim2` dimension is :math:`d_{j}`, the shape of `y` is the same
+          as the input shape with `dim1` and `dim2` dimension removed and the diagonal dimension appended.
+          If the `offset` is nonnegative, the size of output's last dimension is
+          :math:`max(min(d_{i}, d_{j}-offset), 0)`. But if the `offset` is negative, the size of output's
+          last dimension is :math:`max(min(d_{i} + offset, d_{j}), 0)`.
 
-    Refer to :func:`mindspore.ops.expm1` for more detail.
+    Raises:
+        TypeError: If dtype of `x` is neither float32 nor double.
+        TypeError: If `offset` is not an int.
+        TypeError: If `dim1` is not an int.
+        TypeError: If `dim2` is not an int.
+        ValueError: If the dimension of input is less than 2 dimensions.
+        ValueError: If `dim1` is not in range of [-len(x.shape), len(x.shape)).
+        ValueError: If `dim2` is not in range of [-len(x.shape), len(x.shape)).
+        ValueError: If `dim1` and `dim2` are identical.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend``  ``CPU``
 
     Examples:
-        >>> x = Tensor(np.array([0.0, 2.0, 3.0, 5.0]), mindspore.float32)
-        >>> expm1 = ops.Expm1()
-        >>> output = expm1(x)
-        >>> print(output)
-        [  0.         6.389056  19.085537 147.41316 ]
+        >>> x = Tensor(np.array([[[ 0.,  1.,  2.,  3.], [ 4.,  5.,  6.,  7.], [ 8.,  9., 10., 11.]],
+        ... [[12., 13., 14., 15.], [16., 17., 18., 19.], [20., 21., 22., 23.]]]), mindspore.float32)
+        >>> diagonal_ops = ops.Diagonal(offset=1, dim1=-1, dim2=1)
+        >>> y = diagonal_ops(x)
+        >>> print(y)
+        [[ 4.  9.]
+         [16. 21.]]
+    """
+
+    @prim_attr_register
+    def __init__(self, offset=0, dim1=0, dim2=1):
+        """Initialize Diagonal"""
+        self.init_prim_io_names(inputs=['x'], outputs=['y'])
+        validator.check_is_int(offset, "offset", self.name)
+        validator.check_is_int(dim1, "dim1", self.name)
+        validator.check_is_int(dim2, "dim2", self.name)
+
+
+class Expm1(Primitive):
+    r"""
+    Returns exponential then minus 1 of a tensor element-wise.
+
+    Refer to :func:`mindspore.ops.expm1` for more details.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> x = Tensor(np.array([0.0, 2.0, 3.0, 5.0]), mindspore.float32)
+        >>> expm1 = ops.Expm1()
+        >>> output = expm1(x)
+        >>> print(output)
+        [  0.         6.389056  19.085537 147.41316 ]
     """
 
     @prim_attr_register
@@ -2448,7 +2656,7 @@ class Expm1(Primitive):
 
 class Histogram(Primitive):
     """
-    Computes the histogram of a tensor.
+    Computes the histogram of Tensor element distribution.
 
     The elements are sorted into equal width bins between `min` and `max`.
     If `min` and `max` are both zero, the minimum and maximum values of the data are used.
@@ -2456,12 +2664,12 @@ class Histogram(Primitive):
     Elements lower than min and higher than max are ignored.
 
     Args:
-        bins (int) : Number of histogram bins, optional. Default 100. If specified, must be positive.
-        min (float): An optional float of the lower end of the range (inclusive). Default value is 0.0.
-        max (float): 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]
+        - **x** (Tensor) - the input tensor, type support list: [float16, float32, int32].
 
     Outputs:
         Tensor, 1-D Tensor with type int32.
@@ -2493,7 +2701,7 @@ class Histogram(Primitive):
         validator.check_value_type("min", min, [float], self.name)
         validator.check_value_type("max", max, [float], self.name)
         validator.check_positive_int(bins, 'bins', self.name)
-        validator.check('min', min, 'max', max, Rel.LE, self.name)
+        validator.check('min', min, 'max', max, validator.LE, self.name)
 
 
 class HistogramFixedWidth(PrimitiveWithInfer):
@@ -2502,21 +2710,21 @@ class HistogramFixedWidth(PrimitiveWithInfer):
     width and determined by the inputs `range` and the arguments `nbins`.
 
     Args:
-        dtype (str): An optional attribute. The dtype must be "int32". Default: "int32".
         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".
 
     Inputs:
         - **x** (Tensor) - Numeric Tensor. Must be one of the following types: int32, float32, float16.
-        - **range** (Tensor) - Must have the same data type as `x`, and the shape is (2,).
+        - **range** (Tensor) - Must have the same data type as `x`, and the shape is :math:`(2,)`.
           x <= range[0] will be mapped to histogram[0], x >= range[1] will be mapped to histogram[-1].
 
     Outputs:
-        Tensor, the type is int32.
+        1-D Tensor, whose length is the type is `nbins` with dtype of int32.
 
     Raises:
         TypeError: If `dtype` is not a str or `nbins` is not an int.
         ValueError: If `nbins` is less than 1.
-        ValueError: If `dtype` is neither 'int32' nor 'int64'.
+        ValueError: If `dtype` is not 'int32'.
 
     Supported Platforms:
         ``Ascend`` ``GPU``
@@ -2534,7 +2742,7 @@ class HistogramFixedWidth(PrimitiveWithInfer):
     def __init__(self, nbins, dtype='int32'):
         """Initialize HistogramFixedWidth."""
         self.nbins = validator.check_value_type("nbins", nbins, [int], self.name)
-        validator.check_int(nbins, 1, Rel.GE, "nbins", self.name)
+        validator.check_int(nbins, 1, validator.GE, "nbins", self.name)
         valid_values = ['int32']
         self.dtype = validator.check_string(dtype, valid_values, "dtype", self.name)
         self.init_prim_io_names(inputs=['x', 'range'], outputs=['y'])
@@ -2545,7 +2753,7 @@ class Log(Primitive):
     """
     Returns the natural logarithm of a tensor element-wise.
 
-    Refer to :func:`mindspore.ops.log` for more detail.
+    Refer to :func:`mindspore.ops.log` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2572,7 +2780,7 @@ class Log1p(Primitive):
     r"""
     Returns the natural logarithm of one plus the input tensor element-wise.
 
-    Refer to :func:`mindspore.ops.log1p` for more detail.
+    Refer to :func:`mindspore.ops.log1p` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2595,7 +2803,10 @@ class Hypot(Primitive):
     """
     Computes hypotenuse of input tensors element-wise as legs of a right triangle.
     The shape of two inputs should be broadcastable, and data type of them should be
-    one of: float32, float64
+    one of: float32, float64.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Inputs:
         - **x1** (Tensor) - The first input tensor.
@@ -2610,7 +2821,7 @@ class Hypot(Primitive):
         ValueError: If shape of two inputs are not broadcastable.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x1 = Tensor(np.array([3., 5., 7.]))
@@ -2630,7 +2841,7 @@ class Hypot(Primitive):
 
 class Heaviside(Primitive):
     r"""
-    Computes the Heaviside step function for each element in input.
+    Applies the Heaviside step function for input `x` element-wise.
 
     .. math::
             \text { heaviside }(\text { x, values })=\left\{\begin{array}{ll}
@@ -2639,13 +2850,16 @@ class Heaviside(Primitive):
             1, & \text { if x }>0
             \end{array}\right.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Inputs:
         - **x** (Tensor) - The input tensor. With real number data type.
-        - **values** (Tensor) - The values to use where x is zero. Values can be broadcast with x.
-          'x' should have the same dtype with 'values'.
+        - **values** (Tensor) - The values to use where `x` is zero.
+          It should be able to broadcast with `x` have the same dtype as `x`.
 
     Outputs:
-        Tensor, has the same type as 'x' and 'values'.
+        Tensor, has the same type as `x` and `values`.
 
     Raises:
         TypeError: If `x` or `values` is not Tensor.
@@ -2673,7 +2887,7 @@ class Erf(Primitive):
     r"""
     Computes the Gauss error function of `x` element-wise.
 
-    Refer to :func:`mindspore.ops.erf` for more detail.
+    Refer to :func:`mindspore.ops.erf` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2696,7 +2910,7 @@ class Erfc(Primitive):
     r"""
     Computes the complementary error function of `x` element-wise.
 
-    Refer to :func:`mindspore.ops.erfc` for more detail.
+    Refer to :func:`mindspore.ops.erfc` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU``  ``CPU``
@@ -2719,7 +2933,7 @@ class Minimum(_MathBinaryOp):
     r"""
     Computes the minimum of input tensors element-wise.
 
-    Refer to :func:`mindspore.ops.minimum` for more detail.
+    Refer to :func:`mindspore.ops.minimum` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2754,7 +2968,7 @@ class Maximum(_MathBinaryOp):
     """
     Computes the maximum of input tensors element-wise.
 
-    Refer to :func:`mindspore.ops.maximum` for more detail.
+    Refer to :func:`mindspore.ops.maximum` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2780,7 +2994,17 @@ class RealDiv(_MathBinaryOp):
     """
     Divides the first input tensor by the second input tensor in floating-point type element-wise.
 
-    Refer to :func:`mindspore.ops.div` for more detail.
+    Refer to :func:`mindspore.ops.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``
@@ -2812,7 +3036,7 @@ class Div(_MathBinaryOp):
 
         out_{i} = \frac{x_i}{y_i}
 
-    .. note::
+    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,
@@ -2822,8 +3046,8 @@ class Div(_MathBinaryOp):
     Inputs:
         - **x** (Union[Tensor, number.Number, bool]) - The first input is a number.Number or
           a bool or a tensor whose data type is
-          `number <https://www.mindspore.cn/docs/en/r1.10/api_python/mindspore.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/r1.10/api_python/mindspore.html#mindspore.dtype>`_.
+          `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>`_.
         - **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\_.
@@ -2896,7 +3120,7 @@ class Div(_MathBinaryOp):
 
 class DivNoNan(Primitive):
     r"""
-    Computes a safe divide and returns 0 if the x2 is zero.
+    Operates a safe division between `x1` and `x2` element-wise. Returns 0 if element of `x2` is zero.
 
     Inputs of `x1` and `x2` 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.
@@ -2914,10 +3138,11 @@ 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/r1.10/api_python/mindspore.html#mindspore.dtype>`_ or
-          `bool_ <https://www.mindspore.cn/docs/en/r1.10/api_python/mindspore.html#mindspore.dtype>`_.
+          `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>`
+          _.
         - **x2** (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\_.
+          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\_.
 
 
@@ -3020,7 +3245,7 @@ class FloorDiv(Primitive):
     """
     Divides the first input tensor by the second input tensor element-wise and round down to the closest integer.
 
-    Refer to :func:`mindspore.ops.floor_div` for more detail.
+    Refer to :func:`mindspore.ops.floor_div` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3043,8 +3268,8 @@ class FloorDiv(Primitive):
 
 class TruncateDiv(Primitive):
     """
-    Divides the first input tensor by the second input tensor element-wise for integer types, negative numbers will
-    round fractional quantities towards zero.
+    Divides the first input tensor by the second input tensor element-wise and rounds the results
+    of division towards zero. Equivalent to C-style integer division.
 
     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.
@@ -3070,7 +3295,7 @@ class TruncateDiv(Primitive):
         TypeError: If `x` and `y` is not one of the following: Tensor, Number, bool.
 
     Supported Platforms:
-        ``Ascend``  ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([2, 4, -1]), mindspore.int32)
@@ -3102,10 +3327,10 @@ class TruncateMod(Primitive):
 
     .. warning::
         - The input data does not support 0.
-        - When the elements of input exceed 2048 , the accuracy of operator cannot guarantee the requirement of
+        - 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 (D1,D2... ,Dn), then 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, or a bool,
@@ -3123,7 +3348,7 @@ class TruncateMod(Primitive):
         ValueError: If the shape `x` and `y` cannot be broadcasted to each other.
 
     Supported Platforms:
-        ``Ascend``  ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([2, 4, -1]), mindspore.int32)
@@ -3202,7 +3427,7 @@ class Floor(Primitive):
     r"""
     Rounds a tensor down to the closest integer element-wise.
 
-    Refer to :func:`mindspore.ops.floor` for more detail.
+    Refer to :func:`mindspore.ops.floor` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3223,9 +3448,9 @@ class Floor(Primitive):
 
 class FloorMod(Primitive):
     r"""
-    Computes the remainder of division element-wise. It's a flooring divide.
+    Computes the remainder of division element-wise, and it's a flooring divide.
 
-    Refer to :func:`mindspore.ops.floor_mod` for more detail.
+    Refer to :func:`mindspore.ops.floor_mod` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3251,7 +3476,7 @@ class Ceil(PrimitiveWithInfer):
     r"""
     Rounds a tensor up to the closest integer element-wise.
 
-    Refer to :func:`mindspore.ops.ceil` for more detail.
+    Refer to :func:`mindspore.ops.ceil` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3366,7 +3591,7 @@ class Xlogy(Primitive):
     Computes the first input tensor multiplied by the logarithm of second input tensor element-wise.
     Returns zero when `x` is zero.
 
-    Refer to :func:`mindspore.ops.xlogy` for more detail.
+    Refer to :func:`mindspore.ops.xlogy` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3391,7 +3616,7 @@ class Acosh(Primitive):
     r"""
     Computes inverse hyperbolic cosine of the inputs element-wise.
 
-    Refer to :func:`mindspore.ops.acosh` for more detail.
+    Refer to :func:`mindspore.ops.acosh` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3417,7 +3642,7 @@ class Cosh(Primitive):
     r"""
     Computes hyperbolic cosine of input element-wise.
 
-    Refer to :func:`mindspore.ops.cosh` for more detail.
+    Refer to :func:`mindspore.ops.cosh` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3439,7 +3664,7 @@ class Asinh(Primitive):
     r"""
     Computes inverse hyperbolic sine of the input element-wise.
 
-    Refer to :func:`mindspore.ops.asinh` for more detail.
+    Refer to :func:`mindspore.ops.asinh` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3462,28 +3687,19 @@ class Sinc(Primitive):
     r"""
     Computes the normalized sinc of input.
 
-    Refer to :func:`mindspore.ops.sinc` for more detail.
-
-    .. math::
-
-        y_i = \begin{cases}1 & \text{ if } x_i= 0\\ \frac{sin(\pi x_i)}{x_i} &
-        \text{ otherwise } \end{cases}
-
-    Inputs:
-        - **x** (Tensor) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
-
-    Outputs:
-        Tensor, has the same shape as the `x`. The dtype of output is float32 when dtype of `x` is in
-        [uint8, uint8, uint16, int16, uint32, int32, uint64, int64, bool]. Otherwise output has the
-        same dtype as the `x`.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
-    Raises:
-        TypeError: If `x` is not a Tensor.
+    Refer to :func:`mindspore.ops.sinc` for more details.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> import mindspore.ops.operations.math_ops as ops
+        >>> from mindspore import Tensor, dtype
         >>> sinc = ops.Sinc()
         >>> x = Tensor(np.array([0.62, 0.28, 0.43, 0.62]), mindspore.float32)
         >>> output = sinc(x)
@@ -3500,7 +3716,7 @@ class Sinh(Primitive):
     r"""
     Computes hyperbolic sine of the input element-wise.
 
-    Refer to :func:`mindspore.ops.sinh` for more detail.
+    Refer to :func:`mindspore.ops.sinh` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3534,11 +3750,47 @@ class _LogicBinaryOp(_BinaryOp):
         return _LogicBinaryOp.do_infer_dtype(x_dtype, y_dtype, prim_name=self.name)
 
 
+class Quantile(Primitive):
+    r"""
+    Computes the q-th quantiles of all elements in the input tensor, doing a linear interpolation when the
+    q-th quantile lies between two data points.
+
+    Refer to :func:`mindspore.ops.quantile` and :func:`mindspore.ops.nanquantile` for more details.
+
+    Supported Platforms:
+
+
+    Examples:
+        >>> quantile = ops.Quantile()
+        >>> input = Tensor(np.array([0.0700, -0.5446,  0.9214]), mindspore.float32)
+        >>> q = Tensor(np.array([0, 0.5, 1]), mindspore.float32)
+        >>> output = quantile(input, q)
+        >>> print(output)
+        [-0.5446  0.07  0.9214]
+    """
+
+    @prim_attr_register
+    def __init__(self, dim=None, keep_dims=False, ignore_nan=False):
+        """Initialize Quantile"""
+        if dim is not None:
+            validator.check_value_type("dim", dim, [int], self.name)
+        else:
+            self.add_prim_attr("dim", 10000)
+        if keep_dims is not None:
+            validator.check_value_type("keep_dims", keep_dims, [bool], self.name)
+        else:
+            self.add_prim_attr("keep_dims", False)
+        if ignore_nan is not None:
+            validator.check_value_type("ignore_nan", ignore_nan, [bool], self.name)
+        else:
+            self.add_prim_attr("ignore_nan", False)
+
+
 class Equal(Primitive):
     r"""
     Computes the equivalence between two tensors element-wise.
 
-    Refer to :func:`mindspore.ops.equal` for more detail.
+    Refer to :func:`mindspore.ops.equal` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3627,12 +3879,12 @@ class EqualCount(PrimitiveWithInfer):
     Inputs:
         - **x** (Tensor) - The first input tensor. If the data type and shape of `y` are determined, then `x`
           must be the same as `y`, and vice versa.
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+          :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
         - **y** (Tensor) - The second input tensor. If the data type and shape of `x` are determined, then `y`
           must be the same as `x`, and vice versa.
 
     Outputs:
-        Tensor, with the type same as input tensor and shape as (1,).
+        Tensor, with the type same as input tensor and shape as :math:`(1,)`.
 
     Raises:
         TypeError: If `x` or `y` is not a Tensor.
@@ -3655,22 +3907,12 @@ class EqualCount(PrimitiveWithInfer):
         """Initialize EqualCount"""
         self.init_prim_io_names(inputs=['x', 'y'], outputs=['output'])
 
-    def infer_shape(self, x_shape, y_shape):
-        validator.check("x_shape", x_shape, "y_shape", y_shape, Rel.EQ, self.name)
-        output_shape = (1,)
-        return output_shape
-
-    def infer_dtype(self, x_dtype, y_dtype):
-        args = {'x': x_dtype, 'y': y_dtype}
-        validator.check_tensors_dtypes_same_and_valid(args, mstype.number_type + (mstype.bool_,), self.name)
-        return x_dtype
-
 
 class NotEqual(Primitive):
     """
     Computes the non-equivalence of two tensors element-wise.
 
-    Refer to :func:`mindspore.ops.ne` for more detail.
+    Refer to :func:`mindspore.ops.ne` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3701,7 +3943,7 @@ class Greater(PrimitiveWithCheck):
     r"""
     Compare the value of the input parameters :math:`x,y` element-wise, and the output result is a bool value.
 
-    Refer to :func:`mindspore.ops.gt` for more detail.
+    Refer to :func:`mindspore.ops.gt` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3712,7 +3954,7 @@ class Greater(PrimitiveWithCheck):
         >>> greater = ops.Greater()
         >>> output = greater(x, y)
         >>> print(output)
-        [False  True False]
+        [False True False]
     """
     __mindspore_signature__ = (sig.sig_dtype.T, sig.sig_dtype.T)
 
@@ -3736,7 +3978,7 @@ class GreaterEqual(PrimitiveWithCheck):
     r"""
     Computes the boolean value of :math:`x >= y` element-wise.
 
-    Refer to :func:`mindspore.ops.ge` for more detail.
+    Refer to :func:`mindspore.ops.ge` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3766,9 +4008,18 @@ class GreaterEqual(PrimitiveWithCheck):
 
 class Lerp(Primitive):
     """
-    Computes the minimum of input tensors element-wise.
+    Does a linear interpolation of two tensors start and end based on a float or tensor weight.
 
-    Refer to :func:`mindspore.ops.lerp` for more detail.
+    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.
+        - **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.
+
+    Outputs:
+        Tensor, has the same type and shape as input `start`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3784,7 +4035,6 @@ class Lerp(Primitive):
 
     @prim_attr_register
     def __init__(self):
-        super().__init__("Lerp")
         self.init_prim_io_names(inputs=['start', 'end', 'weight'], outputs=['output'])
 
 
@@ -3792,7 +4042,10 @@ class Gcd(Primitive):
     """
     Computes greatest common divisor of input tensors element-wise.
     The shape of two inputs should be broadcastable, and data type of them should be
-    one of: int32, int64
+    one of: int32, int64.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Inputs:
         - **x1** (Tensor) - The first input tensor.
@@ -3800,14 +4053,14 @@ class Gcd(Primitive):
 
     Outputs:
         Tensor, the shape is the same as the one after broadcasting, and the data type is one
-        with higher digits in the two inputs.
+        with higher precision in the two inputs.
 
     Raises:
         TypeError: If data type `x1` or `x2` is not int32 or int64.
         ValueError: If shape of two inputs are not broadcastable.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x1 = Tensor(np.array([7, 8, 9]))
@@ -3829,7 +4082,7 @@ class Less(PrimitiveWithCheck):
     r"""
     Computes the boolean value of :math:`x < y` element-wise.
 
-    Refer to :func:`mindspore.ops.less` for more detail.
+    Refer to :func:`mindspore.ops.less` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3861,7 +4114,7 @@ class LessEqual(PrimitiveWithCheck):
     r"""
     Computes the boolean value of :math:`x <= y` element-wise.
 
-    Refer to :func:`mindspore.ops.le` for more detail.
+    Refer to :func:`mindspore.ops.le` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3893,7 +4146,7 @@ class LogicalNot(Primitive):
     """
     Computes the "logical NOT" of a tensor element-wise.
 
-    Refer to :func:`mindspore.ops.logical_not` for more detail.
+    Refer to :func:`mindspore.ops.logical_not` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3916,7 +4169,7 @@ class LogicalAnd(_LogicBinaryOp):
     r"""
     Computes the "logical AND" of two tensors element-wise.
 
-    Refer to :func:`mindspore.ops.logical_and` for more detail.
+    Refer to :func:`mindspore.ops.logical_and` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3935,7 +4188,7 @@ class LogicalOr(_LogicBinaryOp):
     """
     Computes the "logical OR" of two tensors element-wise.
 
-    Refer to :func:`mindspore.ops.logical_or` for more detail.
+    Refer to :func:`mindspore.ops.logical_or` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3954,24 +4207,13 @@ class LogicalXor(Primitive):
     r"""
     Computes the "logical XOR" of two tensors element-wise.
 
-    .. math::
-
-        out_{i} = x_{i} \oplus y_{i}
-
-    Inputs:
-        - **x** (Tensor) - The first input is a tensor whose data type is bool.
-        - **y** (Tensor) - The second input is a the tensor to compute XOR with the first input.
-          Datatype must be bool.
-
-    Outputs:
-        Tensor, the shape is the same as the one after broadcasting, and the data type is bool.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
-    Raises:
-        TypeError: If neither `x` nor `y` is a Tensor whose data type is bool.
-        ValueError: If the shape of two inputs cannot be broadcast.
+    Refer to :func:`mindspore.ops.logical_xor` for more details.
 
     Supported Platforms:
-        ``CPU``
+        ``Ascend`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([True, False, True]), mindspore.bool_)
@@ -3992,7 +4234,7 @@ class IsNan(Primitive):
     r"""
     Determines which elements are NaN for each position.
 
-    Refer to :func:`mindspore.ops.isnan` for more detail.
+    Refer to :func:`mindspore.ops.isnan` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4013,26 +4255,9 @@ class IsNan(Primitive):
 
 class IsInf(Primitive):
     r"""
-    Determines which elements are inf or -inf for each position
-
-    .. math::
-
-        out_i = \begin{cases}
-        & \text{ if } x_{i} = \text{Inf},\ \ True \\
-        & \text{ if } x_{i} \ne \text{Inf},\ \ False
-        \end{cases}
-
-    where :math:`Inf` means not a number.
-
-    Inputs:
-        - **x** (Tensor) - The input tensor.
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
-
-    Outputs:
-        Tensor, has the same shape of input, and the dtype is bool.
+    Determines which elements are inf or -inf for each position.
 
-    Raises:
-        TypeError: If `x` is not a Tensor.
+    Refer to :func:`mindspore.ops.isinf` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4055,7 +4280,7 @@ class IsFinite(Primitive):
     r"""
     Determines which elements are finite for each position.
 
-    Refer to :func:`mindspore.ops.isfinite` for more detail.
+    Refer to :func:`mindspore.ops.isfinite` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4079,11 +4304,11 @@ class FloatStatus(Primitive):
     Determines if the elements contain Not a Number(NaN), infinite or negative infinite. 0 for normal, 1 for overflow.
 
     Inputs:
-        - **x** (Tensor) - The input tensor. The data type must be float16 or float32.
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+        - **x** (Tensor) - The input tensor. The data type must be float16, float32 or float64.
+          :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
 
     Outputs:
-        Tensor, has the shape of `(1,)`, and the dtype is `mindspore.dtype.float32`.
+        Tensor, has the shape of :math:`(1,)`, and the dtype is `mindspore.dtype.float32`.
 
     Raises:
         TypeError: If dtype of `x` is not in [float16, float32, float64].
@@ -4105,17 +4330,17 @@ class FloatStatus(Primitive):
         self.init_prim_io_names(inputs=['x'], outputs=['output'])
 
 
-class NPUAllocFloatStatus(PrimitiveWithInfer):
+class NPUAllocFloatStatus(Primitive):
     """
     Allocates a flag to store the overflow status.
 
-    The flag is a tensor whose shape is `(8,)` and data type is `mindspore.dtype.float32`.
+    The flag is a tensor whose shape is :math:`(8,)` and data type is `mindspore.dtype.float32`.
 
     Note:
         Please refer to the Examples of :class:`mindspore.ops.NPUGetFloatStatus`.
 
     Outputs:
-        Tensor, has the shape of `(8,)`.
+        Tensor, has the shape of :math:`(8,)`.
 
     Supported Platforms:
         ``Ascend``
@@ -4130,24 +4355,22 @@ class NPUAllocFloatStatus(PrimitiveWithInfer):
     @prim_attr_register
     def __init__(self):
         """Initialize NPUAllocFloatStatus"""
+        logger.warning("The 'NPUAllocFloatStatus' operator will be deprecated in the future. Please don't use it.")
 
-    def infer_shape(self):
-        return [8]
 
-    def infer_dtype(self):
-        return mstype.float32
-
-
-class NPUGetFloatStatus(PrimitiveWithInfer):
+class NPUGetFloatStatus(Primitive):
     """
-    Updates the flag which is the output tensor of `NPUAllocFloatStatus` with the latest overflow status.
+    `mindspore.ops.NPUGetFloatStatus` updates the flag which is
+    the output tensor of :class:`mindspore.ops.NPUAllocFloatStatus` with the latest overflow status.
 
-    The flag is a tensor whose shape is `(8,)` and data type is `mindspore.dtype.float32`.
-    If the sum of the flag equals to 0, there is no overflow happened. If the sum of the flag is bigger than 0, there
-    is overflow happened.
-    In addition, there are strict sequencing requirements for use, i.e., before using the NPUGetFloatStatus operator,
-    need to ensure that the NPUClearFlotStatus and your compute has been executed.
-    We use Depend on ensure the execution order.
+
+    Note:
+        The flag is a tensor whose shape is :math:`(8,)` and data type is `mindspore.dtype.float32`.
+        If the sum of the flag equals to 0, there is no overflow happened. If the sum of the
+        flag is bigger than 0, there is overflow happened.
+        In addition, there are strict sequencing requirements for use, i.e., before
+        using the NPUGetFloatStatus operator, need to ensure that the NPUClearFlotStatus
+        and your compute has been executed. We use :class:`mindspore.ops.Depend` to ensure the execution order.
 
     Inputs:
         - **x** (Tensor) - The output tensor of `NPUAllocFloatStatus`.
@@ -4202,19 +4425,10 @@ class NPUGetFloatStatus(PrimitiveWithInfer):
     @prim_attr_register
     def __init__(self):
         """Initialize NPUGetFloatStatus"""
+        logger.warning("The 'NPUGetFloatStatus' operator will be deprecated in the future. Please don't use it.")
 
-    def infer_shape(self, x_shape):
-        cls_name = self.name
-        validator.check_equal_int(len(x_shape), 1, "len(x_shape)", cls_name)
-        validator.check_equal_int(x_shape[0], 8, "x_shape[0]", cls_name)
-        return [8]
-
-    def infer_dtype(self, x_dtype):
-        validator.check_tensor_dtype_valid('x', x_dtype, [mstype.float16, mstype.float32], self.name)
-        return mstype.float32
 
-
-class NPUClearFloatStatus(PrimitiveWithInfer):
+class NPUClearFloatStatus(Primitive):
     """
     Clears the flag which stores the overflow status.
 
@@ -4275,23 +4489,178 @@ class NPUClearFloatStatus(PrimitiveWithInfer):
     @prim_attr_register
     def __init__(self):
         """Initialize NPUClearFloatStatus"""
+        logger.warning("The 'NPUClearFloatStatus' operator will be deprecated in the future. Please don't use it.")
 
-    def infer_shape(self, x_shape):
-        cls_name = self.name
-        validator.check_equal_int(len(x_shape), 1, "len(x_shape)", cls_name)
-        validator.check_equal_int(x_shape[0], 8, "x_shape[0]", cls_name)
-        return [8]
 
-    def infer_dtype(self, x_dtype):
-        validator.check_tensor_dtype_valid('x', x_dtype, [mstype.float16, mstype.float32], self.name)
-        return mstype.float32
+class NPUGetFloatStatusV2(Primitive):
+    """
+    Get the flag for storage overflow status. This flag is located in a register at a
+    fixed address on the `Ascend` device, and overflow information is automatically
+    written to this register.
+    The flag is a one-dimensional Tensor with shape :math:`(8,)` and data type `mindspore.dtype.int32`.
+    If the value of flag is zero, no overflow has occurred, otherwise, overflow.
+    When performing overflow detection on the network, you should first call `NPUClearFloatStatusV2` to
+    reset the register before the detection, and then call `NPUGetFloatStatusV2` to get the register
+    status after the network execution is completed.
+
+    Note:
+        - In order to avoid mis-optimization by the compiler, additional input is added to
+          this operator. The input is defined as a shape of: math:`(8,)` and data type of
+          `mindspore.dtype.int32` Tensor, meaningless.
+        - Since this op lacks contextual dependencies with parameters in the network,
+          :class:`mindspore.ops.Depend` needs to be used to ensure order of execution.
+
+    Inputs:
+        Tensor, an additional input created to avoid compiler optimization, is specified as shape :math:`(8,)`,
+        data type is `mindspore.dtype.int32`, and has no actual meaning.
+        Usually use the output of `NPUClearFloatStatusV2`.
+
+    Outputs:
+        Tensor, shape and data type are the same as input. If all are zero, it means no overflow, otherwise, overflow.
+
+    Raises:
+        TypeError: If `x` is not a Tensor.
+        TypeError: If dtype of `x` is not int32.
+        ValueError: If shape of `x` is not equal to :math:`(8,)`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> from mindspore import ops, nn, Tensor
+        >>> from mindspore.ops.operations.math_ops import NPUGetFloatStatusV2, NPUClearFloatStatusV2
+        >>> class Net(nn.Cell):
+        ...     def __init__(self):
+        ...         super().__init__()
+        ...         self.clear_status = NPUClearFloatStatusV2()
+        ...         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.base = Tensor([0], dtype=ms.int32)
+        ...
+        ...     def construct(self, x):
+        ...         init = Tensor([0]*8, dtype=ms.int32)
+        ...         clear_status = self.clear_status(init)
+        ...         x = ops.depend(x, clear_status)
+        ...         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)
+        ...         return overflow
+        ...
+        >>> value = 65504
+        >>> data = np.full((2, 3), value, dtype=np.float16)
+        >>> x = Tensor(data, dtype=ms.float16)
+        >>> net = Net()
+        >>> res = net(x)
+        >>> print(res)
+        True
+        >>> value = 10
+        >>> data = np.full((2, 3), value, dtype=np.float16)
+        >>> x = Tensor(data, dtype=ms.float16)
+        >>> net = Net()
+        >>> res = net(x)
+        >>> print(res)
+        False
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize NPUGetFloatStatusV2"""
+
+
+
+class NPUClearFloatStatusV2(Primitive):
+    """
+    Clear the flag for storage overflow status. This flag is located in a register at a
+    fixed address on the `Ascend` device, and overflow information is automatically
+    written to this register.
+    The flag is a one-dimensional Tensor with shape :math:`(8,)` and data type `mindspore.dtype.int32`.
+    If the value of flag is zero, no overflow has occurred, otherwise, overflow.
+    When performing overflow detection on the network, you should first call `NPUClearFloatStatusV2` to
+    reset the register before the detection, and then call `NPUGetFloatStatusV2` to get the register
+    status after the network execution is completed.
+
+    Note:
+        - In order to avoid mis-optimization by the compiler, additional input and output are added to
+          this operator. The input and output are defined as a shape of: math:`(8,)` and data type of
+          `mindspore.dtype.int32` Tensor, meaningless.
+        - Since this op lacks contextual dependencies with parameters in the network,
+          :class:`mindspore.ops.Depend` needs to be used to ensure order of execution.
+
+    Inputs:
+        Tensor, an additional input created to avoid compiler optimization, is specified as shape :math:`(8,)`,
+        data type is `mindspore.dtype.int32`, and has no actual meaning.
+
+    Outputs:
+        Tensor, shape and data type are the same as input, meaningless.
+
+    Raises:
+        TypeError: If `x` is not a Tensor.
+        TypeError: If dtype of `x` is not int32.
+        ValueError: If shape of `x` is not equal to :math:`(8,)`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> from mindspore import ops, nn, Tensor
+        >>> from mindspore.ops.operations.math_ops import NPUGetFloatStatusV2, NPUClearFloatStatusV2
+        >>> class Net(nn.Cell):
+        ...     def __init__(self):
+        ...         super().__init__()
+        ...         self.clear_status = NPUClearFloatStatusV2()
+        ...         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.base = Tensor([0], dtype=ms.int32)
+        ...
+        ...     def construct(self, x):
+        ...         init = Tensor([0]*8, dtype=ms.int32)
+        ...         clear_status = self.clear_status(init)
+        ...         x = ops.depend(x, clear_status)
+        ...         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)
+        ...         return overflow
+        ...
+        >>> value = 65504
+        >>> data = np.full((2, 3), value, dtype=np.float16)
+        >>> x = Tensor(data, dtype=ms.float16)
+        >>> net = Net()
+        >>> res = net(x)
+        >>> print(res)
+        True
+        >>> value = 10
+        >>> data = np.full((2, 3), value, dtype=np.float16)
+        >>> x = Tensor(data, dtype=ms.float16)
+        >>> net = Net()
+        >>> res = net(x)
+        >>> print(res)
+        False
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize NPUClearFloatStatusV2"""
 
 
 class Cos(Primitive):
     r"""
     Computes cosine of input element-wise.
 
-    Refer to :func:`mindspore.ops.cos` for more detail.
+    Refer to :func:`mindspore.ops.cos` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4313,7 +4682,7 @@ class ACos(Primitive):
     r"""
     Computes arccosine of input tensors element-wise.
 
-    Refer to :func:`mindspore.ops.acos` for more detail.
+    Refer to :func:`mindspore.ops.acos` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4336,7 +4705,7 @@ class Sin(Primitive):
     r"""
     Computes sine of the input element-wise.
 
-    Refer to :func:`mindspore.ops.sin` for more detail.
+    Refer to :func:`mindspore.ops.sin` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4358,7 +4727,7 @@ class Asin(Primitive):
     r"""
     Computes arcsine of input tensors element-wise.
 
-    Refer to :func:`mindspore.ops.asin` for more detail.
+    Refer to :func:`mindspore.ops.asin` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4379,11 +4748,12 @@ class Asin(Primitive):
 
 class NMSWithMask(PrimitiveWithInfer):
     r"""
-    When object detection problem is performed in the computer vision field, object detection algorithm generates
+    Non-maximum Suppression. When object detection problem is performed in the computer vision field,
+    object detection algorithm generates
     a plurality of bounding boxes. Use the box with the highest score, calculate the overlap between other boxes and
     the current box, and delete the box based on a certain threshold(IOU). On Ascend platform, the input box score is
     ignored, which only selects boexs based on the IOU between boxes, which means if you want to remove boxes that has
-    lower scores, you need to sort the input boxes by score in descending order in advance. The IOU is as follows,
+    lower scores, you need to sort the input boxes by score in descending order in advance. The IOU is as follows:
 
     .. math::
         \text{IOU} = \frac{\text{Area of Overlap}}{\text{Area of Union}}
@@ -4460,7 +4830,7 @@ class Abs(Primitive):
     r"""
     Returns absolute value of a tensor element-wise.
 
-    Refer to :func:`mindspore.ops.abs` for more detail.
+    Refer to :func:`mindspore.ops.abs` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4490,7 +4860,7 @@ class Sign(Primitive):
 
     Inputs:
         - **x** (Tensor) - The input tensor.
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+          :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
 
     Outputs:
         Tensor, has the same shape and dtype as the `x`.
@@ -4499,7 +4869,7 @@ class Sign(Primitive):
         TypeError: If `x` is not a Tensor.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
          >>> x = Tensor(np.array([[2.0, 0.0, -1.0]]), mindspore.float32)
@@ -4518,17 +4888,17 @@ class Round(Primitive):
     r"""
     Returns half to even of a tensor element-wise.
 
-    Refer to :func:`mindspore.ops.round` for more detailed.
+    Refer to :func:`mindspore.ops.round` for more detailsed.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-         >>> x = Tensor(np.array([0.8, 1.5, 2.3, 2.5, -4.5]), mindspore.float32)
-         >>> round = ops.Round()
-         >>> output = round(x)
-         >>> print(output)
-         [ 1.  2.  2.  2. -4.]
+        >>> x = Tensor(np.array([0.8, 1.5, 2.3, 2.5, -4.5]), mindspore.float32)
+        >>> round = ops.Round()
+        >>> output = round(x)
+        >>> print(output)
+        [ 1.  2.  2.  2. -4.]
     """
 
     @prim_attr_register
@@ -4541,10 +4911,10 @@ class Tan(Primitive):
     r"""
     Computes tangent of `x` element-wise.
 
-    Refer to :func:`mindspore.ops.tan` for more detail.
+    Refer to :func:`mindspore.ops.tan` for more details.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> tan = ops.Tan()
@@ -4564,7 +4934,7 @@ class Atan(Primitive):
     r"""
     Computes the trigonometric inverse tangent of the input element-wise.
 
-    Refer to :func:`mindspore.ops.atan` for more detail.
+    Refer to :func:`mindspore.ops.atan` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4588,9 +4958,9 @@ class Atanh(Primitive):
     Computes inverse hyperbolic tangent of the input element-wise.
 
     .. warning::
-        This is an experimental prototype that is subject to change and/or deletion.
+        This is an experimental API that is subject to change or deletion.
 
-    Refer to :func:`mindspore.ops.atanh` for more detail.
+    Refer to :func:`mindspore.ops.atanh` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4613,10 +4983,10 @@ class Atan2(_MathBinaryOp):
     r"""
     Returns arctangent of x/y element-wise.
 
-    Refer to :func:`mindspore.ops.atan2` for more detail.
+    Refer to :func:`mindspore.ops.atan2` for more details.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([0, 1]), mindspore.float32)
@@ -4626,6 +4996,7 @@ class Atan2(_MathBinaryOp):
         >>> print(output)
         [0.        0.7853982]
     """
+
     @prim_attr_register
     def __init__(self):
         """Initialize Atan2"""
@@ -4634,7 +5005,7 @@ class Atan2(_MathBinaryOp):
 
 class SquareSumAll(Primitive):
     r"""
-    Returns the square sum of a tensor element-wise
+    Returns the square sum of a tensor element-wise.
 
     .. math::
 
@@ -4642,14 +5013,14 @@ class SquareSumAll(Primitive):
         \\out_{y} = {\textstyle \sum_{0}^{N}} (y_{i})^2
         \end{matrix}\right.
 
+    Note:
+        SquareSumAll only supports float16 and float32 data type.
+
     Inputs:
         - **x** (Tensor) - The input tensor. The data type must be float16 or float32.
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+          :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
         - **y** (Tensor) - The input tensor has the same type and shape as the `x`.
 
-    Note:
-        SquareSumAll only supports float16 and float32 data type.
-
     Outputs:
         - **output_x** (Tensor) - The same type as the `x`.
         - **output_y** (Tensor) - The same type as the `x`.
@@ -4685,7 +5056,7 @@ class BitwiseAnd(_BitwiseBinaryOp):
     r"""
     Returns bitwise `and` of two tensors element-wise.
 
-    Refer to :func:`mindspore.ops.bitwise_and` for more detail.
+    Refer to :func:`mindspore.ops.bitwise_and` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4704,7 +5075,7 @@ class BitwiseOr(_BitwiseBinaryOp):
     r"""
     Returns bitwise `or` of two tensors element-wise.
 
-    Refer to :func:`mindspore.ops.bitwise_or` for more detail.
+    Refer to :func:`mindspore.ops.bitwise_or` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4723,7 +5094,7 @@ class BitwiseXor(_BitwiseBinaryOp):
     r"""
     Returns bitwise `xor` of two tensors element-wise.
 
-    Refer to :func:`mindspore.ops.bitwise_xor` for more detail.
+    Refer to :func:`mindspore.ops.bitwise_xor` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4742,16 +5113,10 @@ class BesselI0(Primitive):
     """
     Computes BesselI0 of input element-wise.
 
-    Inputs:
-        - **x** (Tensor) - The shape of tensor is
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
-          Data type must be float16, float32 or float64.
-
-    Outputs:
-        Tensor, has the same shape as `x`.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
-    Raises:
-        TypeError: If `x` is not a Tensor of float16, float32 or float64.
+    Refer to :func:`mindspore.ops.bessel_i0` for more details.
 
     Supported Platforms:
         ``GPU`` ``CPU``
@@ -4761,28 +5126,22 @@ class BesselI0(Primitive):
         >>> x = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
         >>> output = bessel_i0(x)
         >>> print(output)
-        [1.014452  1.179784  1.0241697 1.0020261]
+        [1.0144521 1.1797839 1.0241698 1.0020262]
     """
 
     @prim_attr_register
     def __init__(self):
-        """Initialize BesselI0"""
+        self.init_prim_io_names(inputs=['x'], outputs='y')
 
 
 class BesselI1(Primitive):
     """
     Computes BesselI1 of input element-wise.
 
-    Inputs:
-        - **x** (Tensor) - The shape of tensor is
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
-          Data type must be float16 or float32.
-
-    Outputs:
-        Tensor, has the same shape as `x`.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
-    Raises:
-        TypeError: If `x` is not a Tensor of float16, float32 or float64.
+    Refer to :func:`mindspore.ops.bessel_i1` for more details.
 
     Supported Platforms:
         ``GPU`` ``CPU``
@@ -4812,8 +5171,7 @@ class BesselI0e(Primitive):
     where bessel_i0 is Bessel function of the first kind with 0 order.
 
     Inputs:
-        - **x** (Tensor) - The shape of tensor is
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+        - **x** (Tensor) - The input tensor.
           Data type must be float16, float32 or float64.
 
     Outputs:
@@ -4852,8 +5210,7 @@ class BesselI1e(Primitive):
     where bessel_i1 is Bessel function of the first kind with 1 order.
 
     Inputs:
-        - **x** (Tensor) - The shape of tensor is
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+        - **x** (Tensor) - The input tensor.
           Data type must be float16 or float32, float64.
 
     Outputs:
@@ -4884,9 +5241,11 @@ class BesselK0(Primitive):
     r"""
     Computes BesselK0 of input element-wise.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Inputs:
-        - **x** (Tensor) - The shape of tensor is
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+        - **x** (Tensor) - The input tensor.
           Data type must be float16, float32, float64.
 
     Outputs:
@@ -4915,9 +5274,11 @@ class BesselK1(Primitive):
     r"""
     Computes BesselK1 of input element-wise.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Inputs:
-        - **x** (Tensor) - The shape of tensor is
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+        - **x** (Tensor) - The input tensor.
           Data type must be float16, float32, float64.
 
     Outputs:
@@ -4946,9 +5307,11 @@ class BesselK0e(Primitive):
     """
     Computes BesselK0e of input element-wise.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Inputs:
-        - **x** (Tensor) - The shape of tensor is
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+        - **x** (Tensor) - The input tensor.
           Data type must be float16, float32, float64.
 
     Outputs:
@@ -4977,9 +5340,11 @@ class BesselK1e(Primitive):
     """
     Computes BesselK1e of input element-wise.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Inputs:
-        - **x** (Tensor) - The shape of tensor is
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+        - **x** (Tensor) - The input tensor.
           Data type must be float16, float32, float64.
 
     Outputs:
@@ -5008,9 +5373,11 @@ class BesselJ0(Primitive):
     """
     Computes BesselJ0 of input element-wise.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Inputs:
-        - **x** (Tensor) - The shape of tensor is
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+        - **x** (Tensor) - The input tensor.
           Data type must be float16, float32 or float64.
 
     Outputs:
@@ -5040,9 +5407,11 @@ class BesselJ1(Primitive):
     """
     Computes BesselJ1 of input element-wise.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Inputs:
-        - **x** (Tensor) - The shape of tensor is
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+        - **x** (Tensor) - The input tensor.
           Data type must be float16, float32 or float64.
 
     Outputs:
@@ -5072,9 +5441,11 @@ class BesselY0(Primitive):
     """
     Computes BesselY0 of input element-wise.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Inputs:
-        - **x** (Tensor) - The shape of tensor is
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+        - **x** (Tensor) - The input tensor.
           Data type must be float16, float32 or float64.
 
     Outputs:
@@ -5104,9 +5475,11 @@ class BesselY1(Primitive):
     """
     Computes BesselY1 of input element-wise.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Inputs:
-        - **x** (Tensor) - The shape of tensor is
-          :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+        - **x** (Tensor) - The input tensor.
           Data type must be float16, float32 or float64.
 
     Outputs:
@@ -5234,7 +5607,7 @@ class LinSpace(Primitive):
     Returns a Tensor whose value is `num` evenly spaced in the interval `start` and `stop` (including `start` and
     `stop`), and the length of the output Tensor is `num`.
 
-    Refer to :func:`mindspore.ops.linspace` for more detail.
+    Refer to :func:`mindspore.ops.linspace` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -5280,7 +5653,7 @@ class MatrixInverse(Primitive):
         ValueError: If the dimension of `x` is less than 2.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([[[-0.710504  , -1.1207525],
@@ -5303,14 +5676,58 @@ class MatrixInverse(Primitive):
         validator.check_value_type('adjoint', adjoint, [bool], self.name)
 
 
+class MatrixPower(Primitive):
+    """
+    Calculates the n-th power of a batch of square matrices.
+    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).
+
+    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.
+
+    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.
+
+    Supported Platforms:
+
+
+    Examples:
+        >>> x = Tensor([[[0, 1], [-1, 0]], [[1, 0], [0, -1]]], dtype=ms.float32)
+        >>> matrix_power = ops.MatrixPower(n=2)
+        >>> y = matrix_power(x)
+        >>> print(y)
+        [[[-1.  0.]
+          [-0. -1.]]
+         [[ 1.  0.]
+          [ 0.  1.]]]
+    """
+
+    @prim_attr_register
+    def __init__(self, n):
+        super().__init__(name="MatrixPower")
+        self.n = validator.check_value_type("n", n, [int], self.name)
+
+
 class MatrixDeterminant(Primitive):
     """
-    Computes the determinant of one or more square matrices.
+    Calculates the value of the determinant for one or more square matrices.
 
-    Refer to :func:`mindspore.ops.matrix_determinant` for more detail.
+    Refer to :func:`mindspore.ops.det` for more details.
 
     Supported Platforms:
-        ``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)
@@ -5329,12 +5746,12 @@ class MatrixDeterminant(Primitive):
 
 class LogMatrixDeterminant(Primitive):
     """
-    Computes the sign and the log of the absolute value of the determinant of one or more square matrices.
+    Calculates the sign and logarithm of the determinant of one or more square matrices.
 
-    Refer to :func:`mindspore.ops.log_matrix_determinant` for more detail.
+    Refer to :func:`mindspore.ops.slogdet` for more details.
 
     Supported Platforms:
-        ``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)
@@ -5353,9 +5770,44 @@ class LogMatrixDeterminant(Primitive):
         self.init_prim_io_names(inputs=['x'], outputs=['sign', 'y'])
 
 
+class MatrixLogarithm(Primitive):
+    """
+    Return the matrix logarithm of one or more square matrices.
+
+    Inputs:
+        - **x** (Tensor) - x is a tensor. The shape of tensor is :math:`[..., M, M]`.
+          Must be one of the following types:complex64, complex128. And shape must be 2D-7D.
+
+    Outputs:
+        - **y** (Tensor) - has the same shape and type as input.
+
+    Raises:
+        TypeError: If `x` is not a Tensor.
+        TypeError: If dtype of `x` is not one of: complex64, complex128.
+        ValueError: If the dimension of `x` is less to 2.
+        ValueError: If the size of last two dimensions are not equal.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> x = Tensor([[1 + 2j, 2 + 1j], [4 + 1j, 5 + 2j]])
+        >>> matrix_logarithm = ops.MatrixLogarithm()
+        >>> y = matrix_logarithm(x)
+        >>> print(y)
+        [[0.69155775+1.71618359j 0.64665196-0.34928196j]
+         [1.02426074-0.88736831j 1.44677531+0.6400109j ]]
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize MatrixLogarithm"""
+        self.init_prim_io_names(inputs=['x'], outputs=['y'])
+
+
 class IndexAdd(Primitive):
     """
-    Adds tensor `y` to specified axis and indices of tensor `x`. The axis should be in [0,  len(x.dim) - 1],
+    Adds tensor `y` to specified axis and indices of tensor `x`. The axis should be in [-len(x.dim),  len(x.dim) - 1],
     and indices should be in [0, the size of `x` - 1] at the axis dimension.
 
     Args:
@@ -5425,7 +5877,9 @@ class IndexAdd(Primitive):
 
 class Erfinv(Primitive):
     r"""
-    Computes the inverse error function of input. The inverse error function is defined in the range (-1, 1) as:
+    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
@@ -5440,7 +5894,7 @@ class Erfinv(Primitive):
         TypeError: If dtype of `input_x` is not float16, float32 or float64.
 
     Supported Platforms:
-        ``Ascend`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([0, 0.5, -0.9]), mindspore.float32)
@@ -5494,27 +5948,31 @@ class Conj(Primitive):
 
 class ComplexAbs(Primitive):
     r"""
-    Returns a Tensor that is the absolute value part of the input.
+    Returns a Tensor that contains the magnitudes of the input.
 
-    The complex numbers in input must be of the form a + bj, where a is the real part and b is the imaginary part.
+    The complex numbers in input must be of the form :math:`a + bj`,
+    where :math:`a` is the real part and :math:`b` is the imaginary part.
 
     .. math::
 
-        y = \sqrt{a^2+b^2}.
+        y = \sqrt{a^2+b^2}
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Inputs:
-        -**x** (Tensor) - A Tensor, types: complex64, complex128.
+        - **x** (Tensor) - A Tensor, types: complex64, complex128.
 
     Outputs:
-        -**y** (Tensor) - Tensor, has the same shape as x. If the type of x is complex64, the type of y is float32.
-        If the type of x is complex128, the type of y is float64.
+        Tensor, has the same shape as x. If the type of x is complex64, the type of output is float32.
+        If the type of x is complex128, the type of output is float64.
 
     Raises:
        TypeError: If the input is not a Tensor.
        TypeError: If the input type is not complex64 or complex128.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.asarray(np.complex(3+4j)), mindspore.complex64)
@@ -5545,7 +6003,7 @@ class Real(Primitive):
        TypeError: If the input is not a Tensor.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.asarray(np.complex(1.3+0.4j)), mindspore.complex64)
@@ -5565,6 +6023,9 @@ class Complex(Primitive):
     """
     Returns a complex Tensor from the real part and the imag part.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Inputs:
         - **real** (Tensor) - The real input tensor. types: float32, float64.
         - **imag** (Tensor) - The imag input tensor. types: float32, float64.
@@ -5577,7 +6038,7 @@ class Complex(Primitive):
        TypeError: If the dtypes of two inputs are not same.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> real = Tensor(np.array([1]), mindspore.float32)
@@ -5609,7 +6070,7 @@ class Imag(Primitive):
        TypeError: If the input is not a Tensor.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.asarray(np.complex(1.3+0.4j)), mindspore.complex64)
@@ -5628,21 +6089,14 @@ class Imag(Primitive):
 class Angle(Primitive):
     """
     Returns the element-wise argument of a complex tensor.
-    The elements in input are considered to be complex numbers of the form a+bj, where a is the real part and b
-    is the imaginary part. The argument returned by this function is of the form atan2(b,a).
-
-    Inputs:
-        - **input** (Tensor) - The input tensor. types: complex64, complex128.
 
-    Outputs:
-        Tensor, has the float32 or float64 type and the same shape as input.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
-    Raises:
-        TypeError: If `input` is not a Tensor.
-        TypeError: If the dtype of input is not one of: complex64, complex128.
+    Refer to :func:`mindspore.ops.angle` for more details.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> input = Tensor([-1.5 + 7.8j, 3 + 5.75j], mindspore.complex64)
@@ -5662,10 +6116,16 @@ class Trunc(Primitive):
     """
     Returns a new tensor with the truncated integer values of the elements of input.
 
-    Refer to :func:`mindspore.ops.trunc` for more detail.
+    Refer to :func:`mindspore.ops.trunc` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> x = Tensor(np.array([3.4742, 0.5466, -0.8008, -3.9079]), mindspore.float32)
+        >>> output = ops.Trunc()(x)
+        >>> print(output)
+        [ 3.  0. -0. -3.]
     """
 
     @prim_attr_register
@@ -5679,24 +6139,20 @@ class TridiagonalMatMul(Primitive):
     Return the result of a multiplication of two matrices, where the left one is a Tridiagonal Matrix.
 
     Inputs:
-        - **superdiag** (Tensor) - The input tensor.
+        - **superdiag** (Tensor) - Superdiagonals of Tridiagonal Matrices to the left of multiplication.
           Data types must be: float16, float32, double, complex64, complex128.
-          The shape is [..., 1, M].
-          Representing superdiagonals of Tridiagonal Matrices to the left of multiplication.
+          The shape is :math:`(..., 1, M)`.
           Last element is ignored.
-        - **maindiag** (Tensor) - The input tensor.
+        - **maindiag** (Tensor) - Maindiagonals of Tridiagonal Matrices to the left of multiplication.
           Data types must be: float16, float32, double, complex64, complex128.
-          The shape is [..., 1, M].
-          Representing maindiagonals of Tridiagonal Matrices to the left of multiplication.
-        - **subdiag** (Tensor) - The input tensor.
+          The shape is :math:`(..., 1, M)`.
+        - **subdiag** (Tensor) - Subdiagonals of Tridiagonal Matrices to the left of multiplication.
           Data types must be: float16, float32, double, complex64, complex128.
-          The shape is [..., 1, M].
-          Representing subdiagonals of Tridiagonal Matrices to the left of multiplication.
+          The shape is :math:`(..., 1, M)`.
           First element is ignored.
-        - **rhs** (Tensor) - The input tensor.
+        - **rhs** (Tensor) - MxN Matrices to the right of multiplication.
           Data types must be: float16, float32, double, complex64, complex128.
-          The shape is [..., M, N].
-          Representing MxN Matrices to the right of multiplication.
+          The shape is :math:`(..., 1, M)`.
 
     Outputs:
         Tensor, with the same shape and data type as the `rhs`.
@@ -5720,7 +6176,7 @@ class TridiagonalMatMul(Primitive):
                     are not same.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``CPU``
 
     Examples:
         >>> tridiagonalmatmul = ops.TridiagonalMatMul()
@@ -5746,36 +6202,11 @@ class TridiagonalMatMul(Primitive):
 class Igamma(Primitive):
     r"""
     Calculates lower regularized incomplete Gamma function.
-    The lower regularized incomplete Gamma function is defined as:
-
-    .. math::
-        P(a, x) = gamma(a, x) / Gamma(a) = 1 - Q(a, x)
-
-    where
-
-    .. math::
-        gamma(a, x) = \int_0^x t^{a-1} \exp^{-t} dt
-
-    is the lower incomplete Gamma function.
-
-    Above :math:`Q(a, x)` is the upper regularized complete Gamma function.
 
     .. warning::
-        This is an experimental prototype that is subject to change and/or deletion.
-
-    Inputs:
-        - **a** (Tensor) - The input tensor. With type of float32 or float64.
-        - **x** (Tensor) - The input tensor. With float32 or float64 type. `x` should have
-          the same dtype with `a`.
+        This is an experimental API that is subject to change or deletion.
 
-    Outputs:
-        Tensor, has the same dtype as `a` and `x`.
-
-    Raises:
-        TypeError: If a or x is not a Tensor.
-        TypeError: If dtype of input x and a is not float32 nor float64.
-        TypeError: If x has different dtype with a.
-        ValueError: If `a` could not be broadcast to a tensor with shape of `x`.
+    Refer to :func:`mindspore.ops.igamma` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -5783,7 +6214,7 @@ class Igamma(Primitive):
     Examples:
         >>> 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 = P.Igamma()
+        >>> igamma = ops.Igamma()
         >>> output = igamma(a, x)
         >>> print (output)
         [0.593994  0.35276785  0.21486944  0.13337152]
@@ -5799,31 +6230,7 @@ class Igammac(Primitive):
     r"""
     Compute the upper regularized incomplete Gamma function Q(a, x).
 
-    The upper regularized incomplete Gamma function is defined as:
-    \(Q(a, x) = Gamma(a, x) / Gamma(a) = 1 - P(a, x)\)
-    where
-    \(Gamma(a, x) = int_{x}^{\infty} t^{a-1} exp(-t) dt\)
-
-    is the upper incomplete Gama function.
-
-    Note, above P(a, x) (Igamma) is the lower regularized complete Gamma function.
-
-    .. warning::
-        This is an experimental prototype that is subject to change and/or deletion.
-
-    Inputs:
-        - **a** (Tensor) - The input tensor of igammac. With float32 or float64 data type.
-        - **x** (Tensor) - The input tensor of igammac. With float32 or float64 type. `x` should have
-          the same type with `a`.
-
-    Outputs:
-        A Tensor, has the same dtype as `a` and `x`.
-
-    Raises:
-        TypeError: If dtype of input x and a is not float32 nor float64.
-        TypeError: If a or x is not a Tensor.
-        TypeError: If x has different dtype with a.
-        ValueError: If `a` could not be broadcast to a tensor with shape of `x`.
+    Refer to :func:`mindspore.ops.igammac` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -5831,7 +6238,7 @@ class Igammac(Primitive):
     Examples:
         >>> 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 = P.Igammac()
+        >>> igammac = ops.Igammac()
         >>> output = igammac(a, x)
         >>> print (output)
         [0.40600586 0.6472318  0.7851304  0.8666283 ]
@@ -5845,9 +6252,10 @@ class Igammac(Primitive):
 
 class IsClose(Primitive):
     r"""
-    Returns a boolean Tensor where two tensors are element-wise equal within a tolerance.
+    Returns a tensor of Boolean values indicating whether two input tensors
+    are element-wise equal within a given tolerance.
 
-    Refer to :func:`mindspore.ops.isclose` for more detail.
+    Refer to :func:`mindspore.ops.isclose` for more details.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -5881,28 +6289,10 @@ class MatrixExp(Primitive):
     r"""
     Computes the matrix exponential of a square matrix. Supports batched inputs.
 
-    Refer to :func:`mindspore.ops.matrix_exp` for more detail.
-
-    .. math::
-
-        matrix\_exp(x) = \sum_{k=0}^{\infty} \frac{1}{k !} x^{k} \in \mathbb{K}^{n \times n}
-
-    Inputs:
-        - **x** (Tensor) - The shape of tensor is :math:`(*, n, n)` where * is zero or more batch dimensions.
-          Must be one of the following types: float64, float32, float16, complex64, complex128.
-
-    Outputs:
-        Tensor, has the same shape and dtype as the `x`.
-
-    Raises:
-        TypeError: If `x` is not a Tensor.
-        TypeError: If the dtype of `x` is not one of the following dtype:
-                   float16, float32, float64, complex64, complex128.
-        ValueError: If the rank of `x` is less than 2.
-        ValueError: If the last two dimensions of `x` are not equal.
+    Refer to :func:`mindspore.ops.matrix_exp` for more details.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+
 
     Examples:
         >>> matrix_exp = ops.MatrixExp()
@@ -5923,24 +6313,30 @@ class MatrixSolve(Primitive):
     Solves systems of linear equations.
 
     Args:
-        adjoint(bool): Indicating whether to solve with matrix or its (block-wise) adjoint. Default: False.
+        adjoint (bool, optional): Indicates whether the adjoint of the
+            matrix is used during the computation. Default: False,  use its transpose instead.
 
     Inputs:
-        - **matrix** (Tensor) - The shape of tensor is :math:`[..., M, M]`.
-        - **rhs** (Tensor) - The shape of tensor is :math:`[..., M, K]`. 'rhs' must have the same type as `matrix`.
+        - **matrix** (Tensor) - A tensor of shape :math:`(..., M, M)`,
+          is a matrix of coefficients for a system of linear equations.
+        - **rhs** (Tensor) - A tensor of shape :math:`(..., M, K)`,
+          is a matrix of the resulting values of a system of linear equations.
+          `rhs` must have the same type as `matrix`.
 
     Outputs:
-        A Tensor. Has the same type and shape as 'rhs'.
+        Tensor, a matrix composed of solutions to a system of linear equations,
+        which has the same type and shape as `rhs`.
 
     Raises:
-        TypeError: If adjoint is not the type of bool.
-        TypeError: If the type of matrix is not one of the following dtype:
-                   mstype.float16, mstype.float32, mstype.float64, mstype.complex64, mstype.complex128.
+        TypeError: If `adjoint` is not the type of bool.
+        TypeError: If the type of `matrix` is not one of the following dtype:
+                   mstype.float16, mstype.float32, mstype.float64, mstype.complex64,
+                   mstype.complex128.
         TypeError: If the type of `matrix` is not the same as that of `rhs`.
         ValueError: If the rank of `matrix` less than 2.
-        ValueError: If the dimension of `matrix` is not the same as `rhs`.
+        ValueError: If the dimension of `matrix` is not the same as `rhs` .
         ValueError: If the inner-most 2 dimension of `matrix` is not the same.
-        ValueError: If the inner-most 2 dimension of `rhs` does not match `matrix`.
+        ValueError: If the inner-most 2 dimension of `rhs` does not match `matrix` .
 
     Supported Platforms:
         ``Ascend`` ``CPU``
@@ -5961,27 +6357,130 @@ class MatrixSolve(Primitive):
         self.adjoint = validator.check_value_type("adjoint", adjoint, [bool], self.name)
 
 
-class LuSolve(Primitive):
+class MatrixSolveLs(Primitive):
+    r"""
+    Solves one or more linear least-squares problems.
+
+    If `fast` is `True`,then the solution is computed by solving the normal equations using Cholesky decomposition.
+    If `fast` is `False` an algorithm based on the numerically robust complete orthogonal decomposition is used. This
+    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.
+
+    Inputs:
+        - **matrix** (Tensor) -  A Tensor. Must be one of the following data types: float64, float32, complex64,
+          complex128. Shape is :math:`(*, M, N)`.
+        - **rhs** (Tensor) -  A Tensor. Must have the same data type as matrix. Shape is :math:`(*, M, K)`.
+          `matrix` and `rhs` should have the same dimensions except the last one.
+        - **l2_regularizer** (Tensor) - A Tensor of type float64. Scalar tensor.
+
+    Outputs:
+        Tensor of shape :math:`(*, N, K)` with the same data type as `matrix`.
+
+    Raises:
+        TypeError: If `matrix`, `rhs` or `l2_regularizer` is not tensor.
+        TypeError: If either of `matrix` and `rhs` is not float32, float64, complex64 or complex128.
+        TypeError: If `l2_regularizer` is not float64.
+        TypeError: If `fast` is not bool.
+        ValueError: If dimensions of `matrix` or `rhs` is less than 2.
+        ValueError: If shape of `matrix` dose not match the shape of `rhs`.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> matrix_solve_ls = ops.MatrixSolveLs(fast=True)
+        >>> matrix = Tensor([[3, 0, 0, 0], [2, 1, 0, 0], [1, 0, 1, 0], [1, 1, 1, 1]], mstype.float32)
+        >>> rhs = Tensor(np.array([[4], [2], [4], [2]]), mstype.float32)
+        >>> l2 = Tensor(0.0, mstype.float64)
+        >>> output = matrix_solve_ls(matrix, rhs, l2)
+        >>> print(output)
+        [[ 1.3333334]
+        [-0.6666667]
+        [ 2.6666665]
+        [-1.3333333]]
+    """
+
+    @prim_attr_register
+    def __init__(self, fast=True):
+        """Initialize MatrixSolveLs"""
+        validator.check_value_type('fast', fast, [bool], self.name)
+
+
+class Lu(Primitive):
+    """
+    Computes the LU decomposition of one or more square matrices.
+
+    Args:
+        output_idx_type (:class:`mindspore.dtype`): An optional data type of `mindspore.dtype.int32`.
+            Default: `mindspore.dtype.int32`.
+
+    Inputs:
+        - **input** (Tensor) - A tensor of shape `[..., M, M]` whose inner-most 2 dimensions form
+          matrices of size `[M, M]`, with data type float32, float64, complex64, complex128.
+
+    Outputs:
+        - **lu** (Tensor) - A tensor of shape `[..., M, M]` whose strictly lower triangular part denotes the lower
+          triangular factor `L` with unit diagonal. Upper triangular part denotes the upper triangular factor `U`.
+        - **p** (Tensor) - Permutation of the rows encoded as a list of indices in `0..M-1`, shape is `[..., M]`.
+
+    Raises:
+        TypeError: If the dtype of `input` is not one of the following dtype:
+            float32, float64, complex64, complex128.
+        TypeError: If `output_idx_type` is neither int32 nor int64.
+        ValueError: If `input` rank is less than 2.
+        ValueError: If input[-1] is not equal to input[-2].
+
+    Supported Platforms:
+        ``GPU``
+
+    Examples:
+        >>> input = Tensor(np.array([[2.5,3.1,3.5], [4.7,1.9,0.2], [1.1,3.6,2.0]]), mindspore.float32)
+        >>> lu, p = ops.Lu(output_idx_type=mindspore.int32)(input)
+        >>> print(lu)
+        [[4.7        1.9        0.2       ]
+         [0.23404257 3.155319   1.9531915 ]
+         [0.5319149  0.6621713  2.1002696 ]]
+        >>> print(p)
+        [1 2 0]
     """
-    Return the solution of the linear equation Ax = b.
+
+    @prim_attr_register
+    def __init__(self, output_idx_type):
+        super().__init__(name="Lu")
+        self.init_prim_io_names(inputs=['input'], outputs=['lu', 'p'])
+        validator.check_type_name("output_idx_type", output_idx_type, [mstype.int32, mstype.int64], self.name)
+        self.add_prim_attr('output_idx_type', output_idx_type)
+
+
+class LuSolve(Primitive):
+    r"""
+    Computes the solution y to the system of linear equations :math:`Ay = b` ,
+    given LU decomposition A and column vector b.
+
+    LU decomposition of a matrix can be generated from :func:`mindspore.scipy.linalg.lu` .
 
     Note:
         The batch dimensions of lu_pivots must match the batch dimensions of lu_data, the size of the dimension and the
-        number of each dimension must be the same. For example, lu_data is (3, 3, 2, 2) lu_pivots is (3, 3, 2),
-        lu_data's batch dimensions is (3, 3), lu_pivots's batch dimensions is (3, 3).
+        number of each dimension must be the same. For example, lu_data is :math:`(3, 3, 2, 2)` lu_pivots is
+        :math:`(3, 3, 2)`,
+        lu_data's batch dimensions is :math:`(3, 3)`, lu_pivots's batch dimensions is :math:`(3, 3)`.
 
         The batch dimensions of lu_data must match the batch dimensions of x, the batch dimensions may have
         different sizes, from right to left, the corresponding dimensions must be equal. For example, lu_data
-        is (3, 3, 2, 2) x is (2, 3, 3, 2, 1), lu_data's batch dimensions is (3, 3), x's batch dimensions is (2, 3, 3).
+        is :math:`(3, 3, 2, 2)` x is :math:`(2, 3, 3, 2, 1)`, lu_data's batch dimensions is
+        :math:`(3, 3)`, x's batch dimensions is :math:`(2, 3, 3)`.
 
     Inputs:
-        - **x** (Tensor) - The input is a tensor of size (*, m, k), where * is batch dimensions, with data type
-          float32, float16.
-        - **lu_data** (Tensor) - The input is a tensor of size (*, m, m), where * is batch dimensions, that can
-          be decomposed into an upper
-          triangular matrix U and a lower triangular matrix L, with data type float32, float16.
-        - **lu_pivots** (Tensor) - The input is a tensor of size (*, m), where * is batch dimensions, that can
-          be converted to a permutation matrix P, with data type int32.
+        - **x** (Tensor) - Column vector `b` in the above equation. It has shape :math:`(*, m, k)`,
+          where :math:`*` is batch dimensions, with data type float32, float16.
+        - **lu_data** (Tensor) - LU decomposition. It has shape :math:`(*, m, m)`, where * is batch
+          dimensions, that can be decomposed into an upper triangular matrix U and a lower triangular
+          matrix L, with data type float32, float16.
+        - **lu_pivots** (Tensor) - Permutation matrix P of LU decomposition. It has
+          shape :math:`(*, m)`, where :math:`*` is batch dimensions, that can be converted
+          to a permutation matrix P, with data type int32.
 
     Outputs:
         Tensor, the same data type as the x and lu_data.
@@ -5995,7 +6494,7 @@ class LuSolve(Primitive):
         ValueError: If `x` dimension less than 2, `lu_data` dimension less than 2 or `lu_pivots` dimension less than 1.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([[1], [3], [3]]), mindspore.float32)
@@ -6016,41 +6515,18 @@ class LuSolve(Primitive):
 
 class LuUnpack(Primitive):
     """
-    Unpack the LU_data and LU_pivots from a LU factorization of a tensor.
+    Converts `LU_data` and `LU_pivots` back into P, L and U matrices, where
+    P is a permutation matrix, L is a lower triangular matrix, and U is an
+    upper triangular matrix. Typically, `LU_data` and `LU_pivots` are generated
+    from the LU decomposition of a matrix.
 
-    Args:
-        unpack_data (bool): 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): 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. A tensor of size [*, M, N], where * 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. A tensor of size [*, min(M, N)], where * is
-          batch dimensions, with data type int8, uint8, int16, int32, int64.
-
-    Outputs:
-        - **pivots** (Tensor) - The permutation matrix of LU factorization. The shape is `[*, 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`.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
-    Raises:
-        TypeError: If the dtype of `LU_data` is not one of the following: int8, uint8, int16, int32,
-                   int64, float16, float32, float64.
-        TypeError: If the dtype of `LU_pivots` is not one of the following: int8, uint8, int16, int32, int64.
-        ValueError: If the dimension of `LU_data` is less than 2.
-        ValueError: If the dimension of `LU_pivots` is less than 1.
-        ValueError: If the size of the last dimension of LU_pivots is not equal to the minimum of the sizes of the last
-                    two dimensions of LU_data.
-        ValueError: If the batch dimensions of LU_data's does not match LU_pivots's batch dimensions.
-        ValueError: On the CPU platform, if the value of `LU_pivots` are out of range[1, LU_data.shape[-2]).
-        RuntimeError: On the Ascend platform, if the value of `LU_pivots` are out of range[1, LU_data.shape[-2]).
+    Refer to :func:`mindspore.ops.lu_unpack` for more details.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> LU_data = Tensor(np.array([[[-0.3806, -0.4872,  0.5536],
@@ -6062,10 +6538,31 @@ class LuUnpack(Primitive):
         >>> LU_pivots = Tensor(np.array([[1, 3, 3],
         ...                              [2, 3, 3]]), mstype.int32)
         >>> lu_unpack = ops.LuUnpack()
-        >>> pivots, L, U = lu_unpack(LU_data, LU_pivots, unpack_data, unpack_pivots)
+        >>> pivots, L, U = lu_unpack(LU_data, LU_pivots)
         >>> print(pivots)
+        [[[1. 0. 0.]
+          [0. 0. 1.]
+          [0. 1. 0.]]
+        <BLANKLINE>
+         [[0. 0. 1.]
+          [1. 0. 0.]
+          [0. 1. 0.]]]
         >>> print(L)
+        [[[ 1.      0.      0.    ]
+          [-0.1287  1.      0.    ]
+          [ 0.2583  0.5239  1.    ]]
+        <BLANKLINE>
+         [[ 1.      0.      0.    ]
+          [-0.6401  1.      0.    ]
+          [ 0.1015 -0.5363  1.    ]]]
         >>> print(U)
+        [[[-0.3806 -0.4872  0.5536]
+          [ 0.      0.6508 -0.2396]
+          [ 0.      0.      0.6902]]
+        <BLANKLINE>
+         [[ 0.6706 -1.1782  0.4574]
+          [ 0.     -0.4779  0.6701]
+          [ 0.      0.      0.6165]]]
     """
 
     @prim_attr_register
@@ -6075,39 +6572,113 @@ class LuUnpack(Primitive):
         validator.check_value_type("unpack_pivots", unpack_pivots, [bool], self.name)
 
 
-class CholeskyInverse(Primitive):
+class Lgamma(Primitive):
+    r"""
+    Computes the natural logarithm of the absolute value of the gamma function on input.
+
+    Refer to :func:`mindspore.ops.lgamma` for more details.
+
+    Supported Platforms:
+        ``GPU`` ``CPU``
+
+    Examples:
+        >>> x = Tensor(np.array([0.5, 3.2, 8.5]), mindspore.float32)
+        >>> lgamma = ops.Lgamma()
+        >>> output = lgamma(x)
+        >>> print(output)
+        [0.5723649 0.8854049 9.549267 ]
     """
-    Returns the inverse of the positive definite matrix using cholesky matrix factorization.
 
-    If upper is False, u is a lower triangular such that the output tensor is
+    @prim_attr_register
+    def __init__(self):
+        """Initialize Lgamma"""
+        self.init_prim_io_names(inputs=['x'], outputs=['y'])
 
-    .. math::
-                        inv = (uu^{T})^{{-1}}
 
-    If upper is True, u is an upper triangular such that the output tensor is
+class Digamma(Primitive):
+    r"""
+    Computes the grad of the lgamma function on input.
 
     .. math::
-                        inv = (u^{T}u)^{{-1}}
-
-    Note:
-        The input must be either an upper triangular matrix or a lower triangular matrix.
+        P(x) = grad(ln(gamma(x)))
 
-    Args:
-        upper(bool): Whether to return a lower or upper triangular matrix. Default: False.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Inputs:
-        - **x** (Tensor) - The input tensor. types: float32, float64.
+        - **x** (Tensor) - The input tensor. With type of float16 or float32 or float64.
 
     Outputs:
-        Tensor, has the same shape and dtype as x.
+        Tensor, has the same dtype as `x`.
 
     Raises:
-        TypeError: If `x` is not a Tensor.
-        TypeError: If dtype of `x` is not one of: float32, float64.
-        ValueError: If the dimension of `x` is not equal to 2.
+        TypeError: If x is not a Tensor.
+        TypeError: If dtype of input x is not float16 or float32 or float64.
 
     Supported Platforms:
-        ``CPU``
+        ``GPU`` ``CPU``
+
+    Examples:
+        >>> x = Tensor(np.array([1.5, 0.5, 9]).astype(np.float16))
+        >>> digamma = ops.Digamma()
+        >>> output = digamma(x)
+        >>> print(output)
+        [ 0.0365 -1.964   2.14  ]
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize Digamma"""
+        self.init_prim_io_names(inputs=['input'], outputs=['output'])
+
+
+class Polygamma(Primitive):
+    r"""
+    Computes the :math:`a`th derivative of the polygamma function on `x`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Refer to :func:`mindspore.ops.polygamma` for more details.
+
+    Supported Platforms:
+        ``GPU`` ``CPU``
+
+    Examples:
+        >>> x = Tensor(np.array([1.0, -0.5]), mindspore.float32)
+        >>> a = Tensor(np.array(1), mindspore.int64)
+        >>> polygamma = ops.Polygamma()
+        >>> output = polygamma(a, x)
+        >>> print(output)
+        [1.644934 8.934802]
+        >>> a = Tensor(np.array(2), mindspore.int64)
+        >>> output = polygamma(a, x)
+        >>> print(output)
+        [-2.404114  -0.8287967]
+        >>> a = Tensor(np.array(3), mindspore.int64)
+        >>> output = polygamma(a, x)
+        >>> print(output)
+        [  6.4939404 193.40909  ]
+        >>> a = Tensor(np.array(4), mindspore.int64)
+        >>> output = polygamma(a, x)
+        >>> print(output)
+        [-24.886265   -3.4742498]
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize Polygamma"""
+        self.init_prim_io_names(inputs=['a', 'x'], outputs=['y'])
+
+
+class CholeskyInverse(Primitive):
+    """
+    Returns the inverse of the positive definite matrix using cholesky matrix factorization given its Cholesky factor.
+
+    Refer to :func:`mindspore.ops.cholesky_inverse` for more details.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([[2,0,0], [4,1,0], [-1,1,2]]), mindspore.float32)
@@ -6129,30 +6700,25 @@ class CholeskyInverse(Primitive):
 class Cross(Primitive):
     """
     Returns the cross product of vectors in dimension `dim` of x1 and x2.
-    x1 and x2 must have the same shape and the same type, and the size of their `dim` dimension should be 3.
-    If `dim` is not given, it defaults to the first dimension found with the size 3.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Refer to :func:`mindspore.ops.cross` for more details.
 
     Args:
-        dim (int): The default value is -65530.
+        dim (int): Spefcified dim along which to cumpute cross product with. Default: -65530.
 
     Inputs:
-        - **x1** (Tensor) - x1 is a tensor.
-          x1 and x2 must have the same shape and the same type, and the size of their `dim` dimension should be 3.
-        - **x2** (Tensor) - x2 is a tensor.
+        - **x1** (Tensor) - Input Tensor.
+        - **x2** (Tensor) - Another input Tensor, must have the same shape and
+          the same type as `x1`, and the size of their `dim` dimension should be 3.
 
     Outputs:
-        Tensor, has the same shape and type as input.
-
-    Raises:
-        TypeError: If `x1` is not a Tensor.
-        TypeError: If `x2` is not a Tensor.
-        TypeError: If the type of `x1` is not the same as that of `x2`.
-        ValueError: If `x1` and `x2` not have the same size, and the size of their `dim` dimension not be 3.
-        ValueError: If `x1` and `x2` not have the same shape.
-        ValueError: If `dim` is out of range, `dim` should be [-len(x1.shape), len(x1.shape)-1].
+        Tensor, has the same shape and type as inputs.
 
     Supported Platforms:
-        ``CPU``
+        ``Ascend`` ``CPU``
 
     Examples:
         >>> import mindspore
@@ -6178,28 +6744,31 @@ class RaggedRange(Primitive):
     """
     Returns a `RaggedTensor` containing the specified sequences of numbers.
 
-      Args:
+    Args:
         Tsplits (mindspore.dtype): An mindspore.dtype from: mindspore.int32, mindspore.int64.
 
-      Inputs:
+    Inputs:
         - **starts** (Tensor) - The starts of each range, whose type is int32, int64, float32 or float64,
           and shape is 0D or 1D.
         - **limits** (Tensor) - The limits of each range, whose type and shape should be same as input `starts`.
         - **deltas** (Tensor) - The deltas of each range, whose type and shape should be same as input `starts`,
           and each element in the tensor should not be equal to 0.
-      Outputs:
+
+    Outputs:
         - **rt_nested_splits** (Tensor) - The nested splits of the return `RaggedTensor`,
           and type of the tensor is `Tsplits`,
           shape of the tensor is equal to shape of input `starts` plus 1.
         - **rt_dense_values**  (Tensor) - The dense values of the return `RaggedTensor`,
           and type of the tensor should be same as input `starts`.
           Let size of input `starts`, input `limits` and input `deltas` are i,
-          if type of the input `starts`, input `limits` and input `deltas`
-          are int32 or int64, shape of the output `rt_dense_values` is equal to
-          sum(abs(limits[i] - starts[i]) + abs(deltas[i]) - 1) / abs(deltas[i])),
-          if type of the input `starts`, input `limits` and input `deltas`
-          are float32 or float64, shape of the output `rt_dense_values` is equal to
-          sum(ceil(abs((limits[i] - starts[i]) / deltas[i]))).
+
+          - if type of the input `starts`, input `limits` and input `deltas`
+            are int32 or int64, shape of the output `rt_dense_values` is equal to
+            :math:`sum(abs(limits[i] - starts[i]) + abs(deltas[i] - 1) / abs(deltas[i]))`.
+          - if type of the input `starts`, input `limits` and input `deltas`
+            are float32 or float64, shape of the output `rt_dense_values` is equal to
+            :math:`sum(ceil(abs((limits[i] - starts[i]) / deltas[i])))`.
+
     Raises:
         TypeError: If any input is not Tensor.
         TypeError: If the type of `starts` is not one of the following dtype: int32, int64, float32, float64.
@@ -6210,7 +6779,7 @@ class RaggedRange(Primitive):
         ValueError: If the shape of `starts`, `limits` and `deltas` are not same.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> raggedrange = ops.RaggedRange(Tsplits=mstype.int64)
@@ -6239,27 +6808,40 @@ class Trace(Primitive):
     Returns a new tensor that is the sum of the input trace.
 
     Note:
-        Input must be matrix, and complex number is nor supported at present.
+        Input must be matrix, and complex number is not supported at present.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Inputs:
-        - **x**(Tensor) - A matrix to be calculated. The matrix must be two dimensional.
+        - **x** (Tensor) - A matrix to be calculated. The matrix must be two dimensional.
 
-    Output:
-        Tensor, with the same data type as input 'x', and size equals to 1.
+    Outputs:
+        Tensor, 0D Tensor with 1 element, it has the same data type as input `x`.
 
     Raises:
         TypeError: If `x` is not a Tensor.
         ValueError: If the dimension of `x` is not equal to 2.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), mindspore.float32)
         >>> trace = ops.Trace()
         >>> output = trace(x)
         >>> print(output)
-        15.
+        15.0
+        >>> x = Tensor(np.arange(1, 13).reshape(3, 4), mindspore.float32)
+        >>> trace = ops.Trace()
+        >>> output = trace(x)
+        >>> print(output)
+        18.0
+        >>> x = Tensor(np.arange(12, 0, -1).reshape(4, 3), mindspore.float32)
+        >>> trace = ops.Trace()
+        >>> output = trace(x)
+        >>> print(output)
+        24.0
     """
 
     @prim_attr_register
@@ -6269,32 +6851,36 @@ class Trace(Primitive):
 
 class Median(Primitive):
     """
-    Computes the median of elements of input tensor in the `axis` dimension. If `global_median` is True, computes the
-    median of all elements of tensor.
+    Computes the median and its corresponding indices of input tensor in the `axis` dimension.
+    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.
 
     Args:
-        global_median (bool): Whether the output tensor is the median of all input tensor elements or not.
-        axis (int): The dimension need to reduce. Default: 0.
-        keep_dims (bool): Whether the output tensor need to retain `axis` dimension or not. Default: False.
+        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.
 
     Inputs:
-        - **x** (Tensor) - A Tensor, whose dtype is int16, int32, int64, float32 or float64.
+        - **x** (Tensor) - A Tensor to calculate median with. Supported dtype:int16, int32, int64, float32 or float64.
 
     Outputs:
-        - **y** (Tensor) - A Tensor, 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 shape of `y` in dimension
-          `axis` is size 1. Otherwise, the `y` lacks `axis` dimension than input.
-        - **indices** (Tensor) - A Tensor, Has the same shape as the `y`, but dtype is int64.
+        - **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
+            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, double.
+        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` is not a bool.
-        TypeError: If `axis` is not a int.
-        TypeError: If `keep_dims` is not a bool.
+        TypeError: If `global_median` or `keep_dims` is assigned a nonboolean value.
+        TypeError: If `axis` is not int.
         ValueError: If `axis` is not in range of [-x.dim, x.dim-1].
 
     Supported Platforms:
@@ -6302,20 +6888,18 @@ class Median(Primitive):
 
     Examples:
         >>> # case 1 : common median compute
-        >>> from mindspore import Tensor
-        >>> from mindspore.ops.operations.math_ops import Median
+        >>> from mindspore import Tensor, ops
         >>> import numpy as np
         >>> x = Tensor(np.array([[5, 1, 2],[3, 5, 7], [1, 6, 4]]).astype(np.int64))
-        >>> median = Median(global_median=False, axis=0, keep_dims=False)
+        >>> median = ops.Median(global_median=False, axis=0, keep_dims=False)
         >>> y = median(x)
         >>> print(y)
         (Tensor(shape=[3], dtype=Int64, value= [3, 5, 4]), Tensor(shape=[3], dtype=Int64, value= [1, 1, 2]))
         >>> # case 2 : global median compute
-        >>> from mindspore import Tensor
-        >>> from mindspore.ops.operations.math_ops import Median
+        >>> from mindspore import Tensor, ops
         >>> import numpy as np
         >>> x = Tensor(np.array([[1, 7, 6],[5, 1, 3],[9, 17, 1]]).astype(np.int32))
-        >>> median = Median(global_median=True)
+        >>> median = ops.Median(global_median=True)
         >>> y = median(x)
         >>> print(y)
         (Tensor(shape=[], dtype=Int32, value= 5), Tensor(shape=[], dtype=Int64, value= 0))
@@ -6335,7 +6919,7 @@ class SparseSegmentMean(Primitive):
     """
     Computes the mean along sparse segments of a Tensor.
 
-    Refer to :func:`mindspore.ops.sparse_segment_mean` for more detail.
+    Refer to :func:`mindspore.ops.sparse_segment_mean` for more details.
 
     Supported Platforms:
         ``GPU`` ``CPU``
@@ -6361,19 +6945,18 @@ class SparseSegmentMean(Primitive):
 
 
 class Zeta(Primitive):
-    """
-    Compute the Hurwitz zeta function ζ(x,q).
+    r"""
+    Compute the Hurwitz zeta function ζ(x,q) of input Tensor.
 
     .. warning::
-        This is an experimental prototype that is subject to change and/or deletion.
+        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}
+        \zeta \left ( x,q \right )=  \textstyle \sum_{n=0} ^ {\infty} \left ( q+n\right )^{-x}
 
     Inputs:
         - **x** (Tensor) - A Tensor, types: float32, float64.
-        - **q** (Tensor) - A Tensor, must have the same shape and type as x.
+        - **q** (Tensor) - A Tensor, must have the same shape and type as `x`.
 
     Outputs:
         Tensor, has the same dtype and shape as the x.
@@ -6385,9 +6968,9 @@ class Zeta(Primitive):
         ValueError: If shape of `x` is not same as the `q`.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
-    Example:
+    Examples:
         >>> x = Tensor(np.array([10.]), mindspore.float32)
         >>> q = Tensor(np.array([1.]), mindspore.float32)
         >>> zeta = ops.Zeta()
@@ -6405,25 +6988,28 @@ class Bernoulli(Primitive):
     """
     Randomly set the elements of output to 0 or 1 with the probability of P which follows the Bernoulli distribution.
 
-    Refer to :func:`mindspore.ops.bernoulli` for more detail.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Refer to :func:`mindspore.ops.bernoulli` for more details.
 
     Supported Platforms:
-        ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
-        >>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int8)
-        >>> bernoulli = Bernoulli()
-        >>> output = bernoulli(input_x, 1.0)
+        >>> input_x = Tensor([0.1, 0.2, 0.3], mindspore.float32)
+        >>> bernoulli = ops.Bernoulli()
+        >>> output = bernoulli(input_x, Tensor([1.0]))
         >>> print(output)
-        [1 1 1]
-        >>> input_p = Tensor(np.array([0.0, 1.0, 1.0]), mindspore.float32)
+        [1. 1. 1.]
+        >>> input_p = Tensor([0.0, 1.0, 1.0], mindspore.float32)
         >>> output = bernoulli(input_x, input_p)
         >>> print(output)
-        [0 1 1]
+        [0. 1. 1.]
     """
 
     @prim_attr_register
-    def __init__(self, seed=-1):
+    def __init__(self, seed=-1, offset=0):
         """Initialize Bernoulli"""
         self.init_prim_io_names(inputs=['x', 'p'], outputs=['y'])
         validator.check_value_type("seed", seed, [int], self.name)
@@ -6431,6 +7017,57 @@ class Bernoulli(Primitive):
             raise ValueError(f"Seed must be -1 or a non-negative integer, but got {seed}.")
 
 
+class TridiagonalSolve(Primitive):
+    """
+    Return the results of tridiagonal systems of equations.
+
+    Solve the tridiagonal systems of equations like:AX = B.
+    and only the main diagonal, superdiagonal and subdiagonal has values.
+    The type of diagonals and rhs should be the same.
+    The penultimate dimension of diagonals must be 3.
+
+    Args:
+        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,
+          float64, complex64, complex128.
+          The penultimate dimension of diagonals must be 3.
+          Diagonals and rhs must have the same rank and the same type.
+        - **rhs** [Tensor] - The input tensor B of the equation AX = B, with data type of float32,
+          float64, complex64, complex128.
+          The penultimate dimension of rhs should be the same to the last dimension of diagonals.
+          Diagonals and rhs must have the same rank and the same type.
+
+    Outputs:
+        Tensor, has the same type and shape as the input "rhs".
+
+    Raises:
+        TypeError: If `diagonals` and "rhs" are not a float32, float64, complex64 or complex128.
+        TypeError: If the args `partial_pivoting` is not bool.
+        ValueError: If the last second value of the "diagonals" is not "3".
+        ValueError: If the last value of the "diagonals" is not equal to the last second value of the "rhs".
+        ValueError: If diagonals and rhs have different rank of shape.
+
+    Supported Platforms:
+        ``CPU``
+    Examples:
+        >>> diagonals = Tensor(np.array([[1.0,2.0,3.0],[2.0,3.0,4.0],[3.0,4.0,5.0]]).astype(np.float32))
+        >>> rhs = Tensor(np.array([[1.0],[2.0],[3.0]]).astype(np.float32))
+        >>> y = P.TridiagonalSolve()(diagonals,rhs)
+        >>> print(output)
+        [[ 0. ]
+         [ 1. ]
+         [-0.5]]
+    """
+
+    @prim_attr_register
+    def __init__(self, partial_pivoting=True):
+        self.init_prim_io_names(inputs=['diagonals', 'rhs'], outputs=['y'])
+        self.partial_pivoting = validator.check_value_type(
+            "partial_pivoting", partial_pivoting, [bool], self.name)
+
+
 class Renorm(Primitive):
     """
     Renormalizes the sub-tensors along dimension `dim`, and each sub-tensor's p-norm should not exceed the
@@ -6438,10 +7075,10 @@ class Renorm(Primitive):
     `maxnorm`. Otherwise the sub-tensor needs to be modified to the original value of the corresponding position
     divided by the p-norm of the substensor and then multiplied by `maxnorm`.
 
-    Refer to :func::`mindspore.ops.renorm` for more detail.
+    Refer to :func:`mindspore.ops.renorm` for more details.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([[1, 1, 1], [2, 2, 2], [3, 3, 3]]), mindspore.float32)
@@ -6466,39 +7103,16 @@ class Renorm(Primitive):
 
 class Cholesky(Primitive):
     """
-    Computes the Cholesky decomposition of a symmetric positive-definite matrix `A`
-    or for batches of symmetric positive-definite matrices.
-
-    If `upper` is `True`, the returned matrix `U` is upper-triangular, and the decomposition has the form:
-
-    .. math::
-        A = U^TU
-
-    If `upper` is `False`, the returned matrix `L` is lower-triangular, and the decomposition has the form:
-
-    .. math::
-        A = LL^T
-
-    Args:
-        upper (bool): 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.
+    Performs the Cholesky decomposition on a single or a batch of
+    symmetric positive-definite matrices.
 
-    Outputs:
-        Tensor, has the same shape and data type as `input_x`.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
-    Raises:
-        TypeError: If `upper` is not a bool.
-        TypeError: If dtype of `input_x` is not one of: float64, float32.
-        TypeError: If `input_x` is not a Tensor.
-        ValueError: If `input_x` is not batch square.
-        ValueError: If `input_x` is not symmetric positive definite.
+    Refer to :func:`mindspore.ops.cholesky` for more details.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> input_x = Tensor(np.array([[1.0, 1.0], [1.0, 2.0]]), mindspore.float32)
@@ -6518,28 +7132,16 @@ class Cholesky(Primitive):
 
 class STFT(Primitive):
     """
-    STFTs can be used as a way of quantifying the change of a nonstationary signal’s
-    frequency and phase content over time.
+    Applies Short-time Fourier transform (STFT) on input signal.
 
-    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, optional): whether to return a complex tensor, or
-            a real tensor with an extra last dimension for the real and
-            imaginary components.
+    STFT segments the signal into narrow time intervals and takes the Fourier transform
+    of each segment to quantify the change of a nonstationary signal’s frequency
+    and phase content over time.
 
-    input:
-        - **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.
+    Refer to :func:`mindspore.ops.stft` for more details.
 
-
-    output:
-        - **y** (Tensor) - A tensor containing the STFT result with shape described above.
+    Supported Platforms:
+        ``Ascend`` ``CPU``
 
     Examples:
         >>> import mindspore as ms
@@ -6567,27 +7169,29 @@ class STFT(Primitive):
 
 class CholeskySolve(Primitive):
     """
-    Given its Cholesky factor `u`, solves a linear system of equations with a positive definite matrix.
+    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 `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
 
-    If `upper` is `False`, `u` is lower triangular and `c` is returned such that:
+    If `upper` is set to `False`, `u` is lower triangular and `c` is returned such that:
 
     .. math::
         c = (uu^{T})^{{-1}}b
 
     Args:
-        upper (bool): Flag which indicates whether to consider the Cholesky factor
-            as a lower or upper triangular matrix. Default: False.
+        upper (bool, optional): A flag indicates whether to treat the Cholesky factor
+            as an upper or a lower triangular matrix. Default: False.
 
     Inputs:
         - **x1** (Tensor) - Tensor of shape :math:`(*, N, M)`, indicating 2D or 3D matrices,
           with float32 or float64 data type.
         - **x2** (Tensor) - Tensor of shape :math:`(*, N, N)`, indicating 2D or 3D square matrices composed of
           upper or lower triangular Cholesky factor, with float32 or float64 data type.
+          x1 and x2 must have the same type.
 
     Outputs:
         Tensor, has the same shape and data type as `x1`.
@@ -6603,7 +7207,7 @@ class CholeskySolve(Primitive):
         ValueError: If `x2` is not 2D or 3D square matrices.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x1 = Tensor(np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]]), mindspore.float32)
@@ -6634,7 +7238,7 @@ class FFTWithSize(Primitive):
             \sum_{n_1=0}^{N_1-1} \dots \sum_{n_d=0}^{N_d-1} x[n_1, \dots, n_d]
              e^{-j\ 2 \pi \sum_{i=0}^d \frac{\omega_i n_i}{N_i}},
 
-    where :math:`d` = :attr:`signal_ndim` is number of dimensions for the
+    where :math:`d` = `signal_ndim` is number of dimensions for the
     signal, and :math:`N_i` is the size of signal dimension :math:`i`.
 
     For ifft, it computes the following expression:
@@ -6644,29 +7248,44 @@ class FFTWithSize(Primitive):
             \frac{1}{\prod_{i=1}^d N_i} \sum_{n_1=0}^{N_1-1} \dots \sum_{n_d=0}^{N_d-1} x[n_1, \dots, n_d]
              e^{\ j\ 2 \pi \sum_{i=0}^d \frac{\omega_i n_i}{N_i}},
 
-    where :math:`d` = :attr:`signal_ndim` is number of dimensions for the
+    where :math:`d` = `signal_ndim` is number of dimensions for the
     signal, and :math:`N_i` is the size of signal dimension :math:`i`.
 
     Note:
-        FFT/IFFT requires complex64 or complex128 inputs, return complex64 or complex128 outputs.
-        RFFT requires float32 or float64 inputs, return complex64 or complex128 outputs.
-        IRFFT requires complex64 or complex128 inputs, return float32 or float64 outputs.
+        - FFT/IFFT requires complex64 or complex128 inputs, return complex64 or complex128 outputs.
+        - RFFT requires float32 or float64 inputs, return complex64 or complex128 outputs.
+        - IRFFT requires complex64 or complex128 inputs, return float32 or float64 outputs.
 
     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, used to select FFT or IFFT and RFFT or IRFFT.
-            inverse=False means FFT or RFFT, inverse=True means IFFT or IRFFT.
-        real (bool): Whether it is the real transformation, used to select FFT/IFFT or RFFT/IRFFT.
-            real=False means FFT or IFFT, real=True means RFFT or IRFFT.
-        norm (str): The default normalization ("backward") has the direct (forward) transforms unscaled
-            and the inverse (backward) transforms scaled by 1/n.
-            "ortho" has both direct and inverse transforms are scaled by 1/sqrt(n).
-            "forward" has the direct transforms scaled by 1/n and the inverse transforms unscaled.
-            n is the input x's element numbers.
-        onesided (bool): Controls whether the input is halved to avoid redundancy. Default: True.
-        signal_sizes (list): Size of the original signal (the signal before rfft, no batch dimension),
-            only in irfft mode and set onesided=true requires the parameter. Default: [].
+        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: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.
+
+        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.
+
+        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: ().
+
+            - The length of `signal_sizes` is equal to the signal_ndim of the IRFFT:
+              :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]`.
+            - `signal_sizes` has exactly the same dimensions as the input shape
+              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.
@@ -6683,36 +7302,36 @@ class FFTWithSize(Primitive):
         ValueError: If norm is none of "backward", "forward" or "ortho".
 
     Supported Platforms:
-        ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
-          >>> # case FFT: signal_ndim: 1, inverse: False, real: False.
-          >>> fft_in = Tensor(np.array([2, 1, 2]), mindspore.complex64)
-          >>> fft_net = math_ops.FFTWithSize(signal_ndim=1, inverse=False, real=False)
-          >>> fft_output = fft_net(fft_in)
-          >>> print(fft_output)
-          [5.0000005 +2.9802322e-08j 0.50000036+8.6602569e-01j
-           0.49999955-8.6602527e-01j]
-          >>> # case IFFT: signal_ndim: 1, inverse: True, real: False.
-          >>> ifft_in = fft_output
-          >>> ifft_net = math_ops.FFTWithSize(signal_ndim=1, inverse=True, real=False)
-          >>> ifft_output = ifft_net(ifft_in)
-          >>> print(ifft_output)
-          [2.       +1.291434e-07j 1.0000004+7.947286e-08j 2.0000005-7.947286e-08j]
-          >>> # case RFFT2D: signal_ndim: 2, inverse: False, real: True.
-          >>> rfft_in = Tensor(np.array([[2, 1, 2], [3, 1, 6]]), mindspore.float32)
-          >>> rfft_net = math_ops.FFTWithSize(signal_ndim=2, inverse=False, real=True)
-          >>> rfft_output = rfft_net(rfft_in)
-          >>> print(rfft_output)
-          [[ 1.5000001e+01+2.0954278e-07j  1.1920929e-06+5.1961541e+00j]
-           [-5.0000005e+00-5.9604645e-08j  9.9999934e-01-3.4641027e+00j]]
-          >>> # case IRFFT2D: signal_ndim: 2, inverse: True, real: True.
-          >>> irfft_in = rfft_output
-          >>> irfft_net = math_ops.FFTWithSize(signal_ndim=2, inverse=True, real=True, signal_sizes=rfft_in.shape)
-          >>> irfft_output = irfft_net(irfft_in)
-          >>> print(irfft_output)
-          [[2.0000002  0.99999976 2.0000005 ]
-          [3.0000007  0.999999   6.000002  ]]
+        >>> # 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)
+        >>> fft_output = fft_net(fft_in)
+        >>> print(fft_output)
+        [5.        +0.j         0.5       +0.86602545j 0.50000006-0.8660255j ]
+        >>> # case IFFT: signal_ndim: 1, inverse: True, real: False.
+        >>> ifft_in = fft_output
+        >>> ifft_net = ops.FFTWithSize(signal_ndim=1, inverse=True, real=False)
+        >>> ifft_output = ifft_net(ifft_in)
+        >>> print(ifft_output)
+        [2.        -1.9868216e-08j 0.99999994+0.0000000e+00j
+         1.9999999 +7.9472862e-08j]
+        >>> # case RFFT2D: signal_ndim: 2, inverse: False, real: True.
+        >>> rfft_in = Tensor(np.array([[2, 1, 2], [3, 1, 6]]), mindspore.float32)
+        >>> rfft_net = ops.FFTWithSize(signal_ndim=2, inverse=False, real=True)
+        >>> rfft_output = rfft_net(rfft_in)
+        >>> print(rfft_output)
+        [[ 1.5000000e+01+1.1920929e-07j -2.3841858e-07+5.1961522e+00j]
+         [-5.0000000e+00-2.9802322e-08j  9.9999988e-01-3.4641016e+00j]]
+        >>> # case IRFFT2D: signal_ndim: 2, inverse: True, real: True.
+        >>> irfft_in = rfft_output
+        >>> irfft_net = ops.FFTWithSize(signal_ndim=2, inverse=True, real=True, signal_sizes=rfft_in.shape)
+        >>> irfft_output = irfft_net(irfft_in)
+        >>> print(irfft_output)
+        [[2.         1.         2.        ]
+         [3.         0.99999994 5.9999995 ]]
     """
 
     @prim_attr_register
@@ -6726,14 +7345,47 @@ class FFTWithSize(Primitive):
         validator.check_value_type('signal_sizes', signal_sizes, [tuple, list], self.name)
 
 
+class Polar(Primitive):
+    r"""
+    Converts polar coordinates to Cartesian coordinates.
+
+    Refer to :func:`mindspore.ops.polar` for more details.
+
+    Supported Platforms:
+        ``GPU`` ``CPU``
+
+    Examples:
+        >>> 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]
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize Polar"""
+        self.init_prim_io_names(inputs=['abs', 'angle'], outputs=['y'])
+
+
 class NextAfter(Primitive):
     """
-    Returns the next representable value after the given first number in the direction of given second number.
+    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`,
+    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`.
 
     .. math::
 
         out_{i} =  nextafter({x1_{i}, x2_{i}})
 
+    .. warning::
+        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.
@@ -6744,16 +7396,16 @@ class NextAfter(Primitive):
           Must be one of the following types: float32, float64.
 
     Outputs:
-        Tensor, has the same shape and data type as `x`.
+        Tensor, has the same shape and data type as `x1`.
 
     Raises:
         TypeError: If neither `x1` nor `x2` is a Tensor.
-        TypeError: If the dtype of input is not one of: float32, float64.
-        TypeError: If the dtypes of two inputs are not same.
+        TypeError: If the dtype of `x1` and `x2` is not one of: float32, float64.
+        TypeError: If the dtypes of `x1` and `x2` are not same.
         ValueError: If `x1`'s shape is not the same as `x2`.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> nextafter = ops.NextAfter()
@@ -6770,13 +7422,113 @@ class NextAfter(Primitive):
         self.init_prim_io_names(inputs=['x1', 'x2'], outputs=['output'])
 
 
+class TrilIndices(Primitive):
+    r"""
+    Calculates the indices of the lower triangular elements in a `row` * `col` matrix
+    and returns them as a 2-by-N Tensor.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Refer to :func:`mindspore.ops.tril_indices` for more details.
+
+    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.
+        dtype (:class:`mindspore.dtype`, optional): The specified type of output tensor.
+            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`.
+          The shape of output is :math:`(2, tril\_size)`, where :math:`tril\_size` is the number of elements in the
+          lower triangular matrix.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> net = ops.TrilIndices(4, 3, -1, mstype.int64)
+        >>> output = net()
+        >>> print(output)
+        [[1 2 2 3 3 3]
+         [0 0 1 0 1 2]]
+        >>> print(output.dtype)
+        Int64
+    """
+
+    @prim_attr_register
+    def __init__(self, row, col, offset=0, dtype=mstype.int32):
+        """Initialize TrilIndices"""
+        self.init_prim_io_names(inputs=[], outputs=['y'])
+        validator.check_int(row, 0, validator.GE, "row", self.name)
+        validator.check_int(col, 0, validator.GE, "col", self.name)
+        validator.check_value_type("offset", offset, [int], self.name)
+        valid_values = (mstype.int32, mstype.int64)
+        validator.check_type_name("dtype", dtype, valid_values, self.name)
+
+
+class MatrixTriangularSolve(Primitive):
+    r"""
+    Returns a new tensor with the solution of a linear equation system with an
+    upper or lower triangular matrix.
+
+    Note:
+        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.
+        adjoint (bool, optional): Indicates whether the adjoint of the
+            matrix is used during the computation. Default: False,  use its transpose instead.
+
+    Inputs:
+        - **matrix** (Tensor) - Tensor of shape :math:`(*, M, M)`,
+          with float32, float64, complex64 and complex128 data type.
+        - **rhs** (Tensor) - Tensor of shape :math:`(*, M, N)`,
+          with float32, float64, complex64 and complex128 data type.
+
+    Outputs:
+        Tensor, has the shape of :math:`(*, M, N)` and the same data type as `matrix`.
+
+    Raises:
+        TypeError: If `matrix` or `rhs` is not a Tensor.
+        TypeError: If `lower` or `adjoint` is not bool.
+        ValueError: For GPU platform, if the batch sizes of `matrix` and `rhs` do not satisfy broadcasting rules.
+            For other platforms, if the batch sizes of `matrix` and `rhs` are not equal.
+        ValueError: If the inner-most 2 dimensions of `matrix` are not equal.
+        ValueError: If the second-last dimensions of `matrix` and `rhs` are not equal.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> matrix_triangular_solve = ops.MatrixTriangularSolve(lower=True, adjoint=False)
+        >>> matrix = np.array([[3, 0, 0, 0], [2, 1, 0, 0], [1, 0, 1, 0], [1, 1, 1, 1]])
+        >>> rhs = np.array([[1, 0],[2, 2],[1, 5],[0, 3]])
+        >>> output = matrix_triangular_solve(Tensor(matrix, mindspore.float32), Tensor(rhs, mindspore.float32))
+        >>> print(output)
+        [[ 0.33333334  0.        ]
+         [ 1.3333333   2.        ]
+         [ 0.6666666   5.        ]
+         [-2.3333333  -4.        ]]
+    """
+
+    @prim_attr_register
+    def __init__(self, lower=True, adjoint=False):
+        """Initialize MatrixTriangularSolve"""
+        validator.check_value_type('adjoint', adjoint, [bool], self.name)
+        validator.check_value_type('lower', lower, [bool], self.name)
+
+
 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.
 
-    Given an `x` shaped `[s0, s1, ..., s_n]`, the output is a `uint8` tensor shaped `[s0, s1, ..., s_n / 8]`.
+    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)`.
 
     Inputs:
         - **x** (Tensor) - Input tensor. Values to compare against `threshold` and bitpack. The data type must be
@@ -6812,40 +7564,56 @@ class CompareAndBitpack(Primitive):
         """Initialize CompareAndBitPack"""
 
 
-class Orgqr(Primitive):
-    r"""
-    Computes the first :math:`N` columns of a product of Householder matrices. Take the case of input without batch
-    as an example. The input x is a matrix of size :math:`(M, N)` after householder transformation. When the diagonal
-    of x is set to 1, every colunm of lower triangular in x is denoted as :math:`w_j` for :math:`j` for
-    :math:`j=1, \ldots, M`, this function returns the first :math:`N` columns of the matrix
+class NanToNum(Primitive):
+    """
+    Replaces `NaN`, positive infinity and negative infinity values in the input Tensor with the values
+    specified by `nan`, `posinf` and `neginf` respectively.
 
-    .. math::
-        H_{1} H_{2} \ldots H_{k} \quad \text { with } \quad H_{j}=\mathrm{I}_{M}-\tau_{j} w_{j} w_{j}^{\mathrm{H}}
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
-    where :math:`\mathrm{I}_{M}` is the :math:`M`-dimensional identity matrix. And when :math:`w` is complex,
-    :math:`w^{\mathrm{H}}` is the conjugate transpose, otherwise the transpose.
-    The output matrix is the same size as the input matrix :math:`x`.
+    Refer to :func:`mindspore.ops.nan_to_num` 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) - Tensor of shape :math:`(*, K)`, where `K` is less than or equal to `N`, indicating the
-          reflecting coefficient in Householder transformation, which have the same type as x.
+    Supported Platforms:
+        ``Ascend`` ``CPU``
 
-    Outputs:
-        Tensor, has the same shape and data type as `x`.
+    Examples:
+        >>> nan_to_num = ops.NanToNum()
+        >>> x = Tensor(np.array([float('nan'), float('inf'), -float('inf'), 3.14]), mindspore.float32)
+        >>> output = nan_to_num(x)
+        >>> print(output)
+        [ 0.0000000e+00  3.4028235e+38 -3.4028235e+38  3.1400001e+00]
+    """
+
+    @prim_attr_register
+    def __init__(self, nan=0.0, posinf=None, neginf=None):
+        """Initialize NanToNum"""
+        if nan is not None:
+            validator.check_value_type("nan", nan, [float], self.name)
+        else:
+            self.add_prim_attr("nan_none", True)
+        if posinf is not None:
+            validator.check_value_type("posinf", posinf, [float], self.name)
+        else:
+            self.add_prim_attr("posinf_none", True)
+        if neginf is not None:
+            validator.check_value_type("neginf", neginf, [float], self.name)
+        else:
+            self.add_prim_attr("neginf_none", True)
 
-    Raises:
-        TypeError: If `x` or `tau` are not Tensors.
-        TypeError: If dtype of `x` and `tau` is not one of: float64, float32, complex64, complex128.
-        ValueError: If `x` and `tau` have different batch size.
-        ValueError: If x.shape[-2] < x.shape[-1].
-        ValueError: If x.shape[-1] < tau.shape[-1].
-        ValueError: If rank(x) - rank(tau) != 1.
-        ValueError: If rank(x) != 2 or 3.
+
+class Orgqr(Primitive):
+    r"""
+    Calculates the explicit representation of the orthogonal matrix :math:`Q`
+    returned by :class:`mindspore.ops.Geqrf`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Refer to :func:`mindspore.ops.orgqr` for more details.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor(np.array([[-114.6, 10.9, 1.1], [-0.304, 38.07, 69.38], [-0.45, -0.17, 62.]]), mindspore.float32)
@@ -6862,3 +7630,414 @@ class Orgqr(Primitive):
     def __init__(self):
         """Initialize Orgqr"""
         self.init_prim_io_names(inputs=['x', 'tau'], outputs=['y'])
+
+
+class TriuIndices(Primitive):
+    r"""
+    Calculates the indices of the upper triangular elements in a `row` * `col` matrix
+    and returns them as a 2-by-N Tensor.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Refer to :func:`mindspore.ops.triu_indices` for more details.
+
+    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.
+        dtype (:class:`mindspore.dtype`, optional): The specified type of output tensor.
+            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`.
+          The shape of output is :math:`(2, tril\_size)`, where :math:`tril\_size` is the number of elements in the
+          lower triangular matrix.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> net = ops.TriuIndices(5, 4, 2, mstype.int64)
+        >>> output = net()
+        >>> print(output)
+        [[0 0 1]
+         [2 3 3]]
+        >>> print(output.dtype)
+        Int64
+    """
+
+    @prim_attr_register
+    def __init__(self, row, col, offset=0, dtype=mstype.int32):
+        """Initialize TriuIndices"""
+        self.init_prim_io_names(inputs=[], outputs=['y'])
+        validator.check_int(row, 0, validator.GE, "row", self.name)
+        validator.check_int(col, 0, validator.GE, "col", self.name)
+        validator.check_value_type("offset", offset, [int], self.name)
+        valid_values = (mstype.int32, mstype.int64)
+        validator.check_type_name("dtype", dtype, valid_values, self.name)
+
+
+class Fmin(Primitive):
+    """
+    Computes the minimum of input tensors element-wise.
+
+    Refer to :func:`mindspore.ops.fmin` for more detail.
+
+    Supported Platforms:
+
+
+    Examples:
+        >>> x1 = Tensor(np.array([1.0, 5.0, 3.0]), mstype.float32)
+        >>> x2 = Tensor(np.array([4.0, 2.0, 6.0]), mstype.float32)
+        >>> fmin = ops.Fmin()
+        >>> output = fmin(x1, x2)
+        >>> print(output)
+        [1. 2. 3.]
+    """
+
+    __mindspore_signature__ = (sig.sig_dtype.T, sig.sig_dtype.T)
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize Fmin"""
+        self.add_prim_attr('ignore_nan', True)
+        self.init_prim_io_names(inputs=['x1, x2'], outputs=['y'])
+
+
+class Fmax(Primitive):
+    """
+    Computes the maximum of input tensors element-wise.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Refer to :func:`mindspore.ops.fmax` for more detail.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> 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()
+        >>> output = fmax(x1, x2)
+        >>> print(output)
+        [4. 5. 6.]
+    """
+
+    __mindspore_signature__ = (sig.sig_dtype.T, sig.sig_dtype.T)
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize Fmax"""
+        self.add_prim_attr('ignore_nan', True)
+        self.init_prim_io_names(inputs=['x1, x2'], outputs=['y'])
+
+
+class Eig(Primitive):
+    """
+    Computes the eigenvalues and eigenvectors of a square matrix(batch square matrices).
+
+    .. warning::
+        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.
+    Inputs:
+        - **x** (Tensor) - Square matrices of shape :math:`(*, N, N)`,
+          with float32, float64, complex64 or complex128 data type.
+
+    Outputs:
+        - **eigen_values** (Tensor) - Shape :math:`(*, N)`. Each inner most vector represents eigenvalues of
+          the corresponding matrix. The eigenvalues may not have an order.
+        - **eigen_vectors** (Tensor) - If `compute_v` is `False`, it’s an empty tensor. Otherwise, this tensor
+          has shape :math:`(*, N, N)`, whose columns represent normalized (unit length) eigenvectors of corresponding
+          eigenvalues.
+
+    Raises:
+        TypeError: If `compute_v` is not a bool.
+        TypeError: If dtype of `x` is not one of: float64, float32, complex64 or complex128.
+        TypeError: If `x` is not a Tensor.
+        ValueError: If `x` is not a square(batch squares).
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> 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)
+        >>> print(u)
+        [1.+0.j 2.+0.j]
+        >>> print(v)
+        [[1.+0.j 0.+0.j]
+         [0.+0.j 1.+0.j]]
+    """
+
+    @prim_attr_register
+    def __init__(self, compute_v=False):
+        """Initialize Eig"""
+        self.init_prim_io_names(inputs=['x'], outputs=['eigen_values', 'eigen_vectors'])
+        validator.check_value_type('compute_v', compute_v, [bool], self.name)
+
+
+class SelfAdjointEig(Primitive):
+    r"""
+    Computes the eigenvalues and (optionally) eigenvectors of each inner matrix in input
+    such that input[..., :, :] = v[..., :, :] * diag(e[..., :]).
+    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.
+
+    Inputs:
+         - **x** (Tensor) - Must be one of the following types:
+           float64, float32, complex64, complex128. Tensor input of shape :math:`[...,N, N]`.
+
+    Outputs:
+         - **eigen_value** (Tensor) - Has the same type as input, the shape is :math:`[...,N]`.
+         - **eigen_vector** (Tensor) - If `compute_v` is `False`, it’s an empty tensor.
+           Otherwise, it has the same type and shape as input, the shape is the same as the input.
+
+    Raises:
+         TypeError: If `compute_v` is not a bool.
+         TypeError: If dtype of `x` is not one of: float64, float32, complex64 or complex128.
+         TypeError: If `x` is not a Tensor.
+         ValueError: If `x` is not a square(batch squares).
+
+    Supported Platforms:
+         ``CPU``
+
+    Examples:
+           >>> from mindspore.ops.operations.math_ops import SelfAdjointEig
+           >>> input_x = Tensor(np.array([[1.0, 0.0], [0.0, 2.0]]).astype(np.float32))
+           >>> SelfAdjointEig = SelfAdjointEig()
+           >>> eigen_value, eigen_vector = SelfAdjointEig(input_x)
+           >>> print(eigen_value)
+           [1.  2.]
+           >>> print(eigen_vector)
+           [[1.  0.]
+            [0.  1.]]
+    """
+
+    @prim_attr_register
+    def __init__(self, compute_v=True):
+        """Initialize SelfAdjointEig."""
+        self.init_prim_io_names(inputs=['x'], outputs=['eigen_value', 'eigen_vector'])
+        validator.check_value_type("compute_v", compute_v, [bool], self.name)
+
+
+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.
+
+    .. 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.
+
+    Inputs:
+        - **x** (Tensor) - A matrix to be calculated. The matrix must be at least two dimensions.
+          types: float16, float32, float64, complex64, complex128.
+          Define the shape of x as :math:`(..., m, n)` p as the minimum values of m and n.
+
+    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)`.
+          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)`.
+          The dtype of `r` is same as `x`.
+
+    Raises:
+        TypeError: If `x` is not a Tensor.
+        TypeError: If `full_matrices` is not a bool.
+        ValueError: If the dimension of `x` is less than 2.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> 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)
+        >>> print(q)
+        [[-0.912871    0.16366126  0.37400758]
+         [-0.18257418 -0.9830709  -0.01544376]
+         [ 0.36514837 -0.08238228  0.92729706]]
+        >>> print(r)
+        [[ -21.908903  -14.788506  -1.6431675]
+        [    0.       -271.9031    92.25824  ]
+        [    0.          0.       -25.665514 ]]
+    """
+
+    @prim_attr_register
+    def __init__(self, full_matrices=False):
+        """Initialize Qr"""
+        validator.check_value_type('full_matrices', full_matrices, [bool], self.name)
+
+
+class Cauchy(Primitive):
+    r"""
+    Create a tensor of shape `size` with random numbers drawn from Cauchy distribution.
+    It is defined as follows:
+
+    .. math::
+        f(x)= \frac{1}{\pi} \frac{\sigma}{(x-median)^2 +\sigma^2}
+
+    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.
+
+    Outputs:
+        Tensor with cauchy distribution data. Tensor shape is size, and data type is float32.
+
+    Raises:
+        TypeError: If `sigma` is not a float.
+        TypeError: If `median` is not a float.
+        TypeError: If `size` is not a list.
+        ValueError: If `size` list is empty.
+        ValueError: If data of `size` is not a positive integer.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> size = [1]
+        >>> net = ops.Cauchy(size)
+        >>> y = net()
+        >>> print(y)
+        [0.03128606]
+    """
+
+    @prim_attr_register
+    def __init__(self, size, median=0.0, sigma=1.0):
+        validator.check_value_type('median', median, [float], self.name)
+        validator.check_value_type('sigma', sigma, [float], self.name)
+        validator.check_value_type('size', size, (list), self.name)
+        for index, size_ in enumerate(size):
+            validator.check_positive_int(size_, 'size[%d]' % index, self.name)
+
+
+class Ormqr(Primitive):
+    r"""
+    Computes the matrix-matrix multiplication of a product of Householder matrices with a general matrix.
+    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().
+
+    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.
+
+    Inputs:
+        - **x** (Tensor) - Tensor of shape: (*, mn, k) where mn equals to m or n depending on the the args of `left`,
+          and `*` is zero or more batch dimensions.
+        - **tau** (Tensor) - Tensor of shape (*, 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,
+          and its type is the same as `x`.
+
+    Outputs:
+        - **y** (Tensor) - the output Tensor, has the same shape and data type as `other`.
+
+    Raises:
+        TypeError: If `x` or `tau` or `other` is not Tensor.
+        TypeError: If dtype of `x` or `tau` or `other` is not one of: float64, float32, complex64, complex128.
+        ValueError: If `x` or `other` is less than 2D.
+        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].
+
+    Supported Platforms:
+        ``GPU``
+
+    Examples:
+        >>> 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)
+        >>> net = ops.Ormqr()
+        >>> y = net(x, tau, other)
+        >>> print(y)
+        [[  63.82713   -13.823125 -116.28614 ]
+         [ -53.659264  -28.157839  -70.42702 ]
+         [ -79.54292    24.00183   -41.34253 ]]
+    """
+
+    @prim_attr_register
+    def __init__(self, left=True, transpose=False):
+        """Initialize Ormqr"""
+        self.init_prim_io_names(inputs=['x', 'tau', 'other'], outputs=['y'])
+        self.left = validator.check_value_type('left', left, [bool], self.name)
+        self.transpose = validator.check_value_type('transpose', transpose, [bool], self.name)
+        self.add_prim_attr('left', self.left)
+        self.add_prim_attr('transpose', self.transpose)
+
+
+class Roll(Primitive):
+    """
+    Rolls the elements of a tensor along an axis.
+
+    Refer to :func:`mindspore.ops.roll` for more details.
+
+    Args:
+        shift (Union[list(int), tuple(int), int]): Specifies the number of places by which elements are shifted
+            positively (towards larger indices) along the specified dimension. Negative shifts will roll the elements
+            in the opposite direction.
+        axis (Union[list(int), tuple(int), int]): Specifies the dimension indexes of shape to be rolled.
+
+    Inputs:
+        - **input_x** (Tensor) - Input tensor.
+
+    Outputs:
+        Tensor, has the same shape and type as `input_x`.
+
+    Supported Platforms:
+        ``GPU``
+
+    Examples:
+        >>> input_x = Tensor(np.array([0, 1, 2, 3, 4]).astype(np.float32))
+        >>> op = ops.Roll(shift=2, axis=0)
+        >>> output = op(input_x)
+        >>> print(output)
+        [3. 4. 0. 1. 2.]
+        >>> input_x = Tensor(np.array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]).astype(np.float32))
+        >>> op = ops.Roll(shift=-1, axis=0)
+        >>> output = op(input_x)
+        >>> print(output)
+        [[5. 6. 7. 8. 9.]
+         [0. 1. 2. 3. 4.]]
+    """
+
+    @prim_attr_register
+    def __init__(self, shift, axis):
+        """Initialize Roll"""
+        if context.get_context("device_target") == "GPU":
+            validator.check_value_type("shift", shift, [int, tuple, list], self.name)
+            if not isinstance(shift, (list, tuple)):
+                self.add_prim_attr('shift', [shift])
+            validator.check_value_type("axis", axis, [int, tuple, list], self.name)
+            if not isinstance(axis, (list, tuple)):
+                self.add_prim_attr('axis', [axis])
+        else:
+            if isinstance(shift, (tuple, list)) and isinstance(axis, (tuple, list)):
+                validator.check_equal_int(len(shift), 1, "shift size", self.name)
+                validator.check_equal_int(len(axis), 1, "shift size", self.name)
+                validator.check_equal_int(axis[0], 0, "axis", self.name)
+            elif isinstance(shift, int) and isinstance(axis, int):
+                validator.check_is_int(axis, "axis", self.name)
+        self.init_prim_io_names(inputs=['input_x'], outputs=['output'])