mindspore 2.1.0__cp38-cp38-manylinux1_x86_64.whl → 2.2.10__cp38-cp38-manylinux1_x86_64.whl

mindspore/ops/function/math_func.py

@@ -127,6 +127,8 @@ cast_ = P.Cast()
 #####################################
 # Private Operation Functions.
 #####################################
+addcdiv_ = P.Addcdiv()
+addcuml_ = P.Addcmul()
 addn_ = P.AddN()
 angle_ = Angle()
 log_ = P.Log()
@@ -142,6 +144,7 @@ asin_ = P.Asin()
 polar_ = Polar()
 acos_ = P.ACos()
 atan_ = P.Atan()
+atan2_ = P.Atan2()
 sinh_ = P.Sinh()
 cosh_ = P.Cosh()
 tanh_ = P.Tanh()
@@ -177,6 +180,7 @@ tensor_round_ = P.Round()
 linspace_ = P.LinSpace()
 matrix_exp_ = MatrixExp()
 exp2_ = P.Pow()
+trunc_ = P.Trunc()
 truncate_div_ = P.TruncateDiv()
 truncate_mod_ = P.TruncateMod()
 sparse_segment_mean_ = SparseSegmentMean()
@@ -188,6 +192,38 @@ cumsum_ = P.CumSum()
 shape_ = P.Shape()
 reshape_ = P.Reshape()
 dtype_ = P.DType()
+eps_ = P.Eps()
+rank_ = P.Rank()
+expand_dims_ = P.ExpandDims()
+sign_ = P.Sign()
+nextafter_ = P.NextAfter()
+matrix_inverse_ = P.MatrixInverse()
+matrix_determinant_ = P.MatrixDeterminant()
+log_matrix_determinant_ = P.LogMatrixDeterminant()
+trace_ = P.Trace()
+real_ = P.Real()
+rsqrt_ = P.Rsqrt()
+reciprocal_ = P.Reciprocal()
+tile_ = P.Tile()
+batch_matmul_ = P.BatchMatMul()
+fill_v2_ = P.FillV2()
+imag_ = P.Imag()
+log1p_ = P.Log1p()
+accumulate_ = P.AccumulateNV2()
+conj_ = P.Conj()
+erfinv_ = P.Erfinv()
+cumprod_ = P.CumProd()
+lgamma_ = P.Lgamma()
+digamma_ = P.Digamma()
+poly_gamma_ = P.Polygamma()
+isinf_ = P.IsInf()
+zeros_ = P.Zeros()
+ones_ = P.Ones()
+logical_xor_ = P.LogicalXor()
+zeta_ = P.Zeta()
+div_ = P.Div()
+matmul_ = P.MatMul()
+
 
 #####################################
 # Element-wise Operation Functions.
@@ -284,12 +320,13 @@ def add(input, other):
           [True, Tensor(True, bool\_), Tensor(np.array([True]), bool\_)] are all considered bool type.
         - The two inputs comply with the implicit type conversion rules to make the data types
           consistent.
+        - When input is Tensor, it's dimension should be greater than or equal to 1.
 
     Args:
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
         other (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.
@@ -324,7 +361,7 @@ def add(input, other):
         >>> print(output.dtype)
         Float32
     """
-    return _get_cache_prim(P.Add)()(input, other)
+    return tensor_add(input, other)
 
 
 def addcdiv(input, tensor1, tensor2, value=1):
@@ -365,7 +402,7 @@ def addcdiv(input, tensor1, tensor2, value=1):
         >>> print(y)
         [1.25      1.6666667 2.5       5.       ]
     """
-    return _get_cache_prim(P.Addcdiv)()(input, tensor1, tensor2, Tensor(value))
+    return addcdiv_(input, tensor1, tensor2, Tensor(value))
 
 
 def addcmul(input, tensor1, tensor2, value=1):
@@ -411,7 +448,7 @@ def addcmul(input, tensor1, tensor2, value=1):
          [ 3.  5.  7.]
          [ 4.  7. 10.]]
     """
-    return _get_cache_prim(P.Addcmul)()(input, tensor1, tensor2, Tensor(value))
+    return addcuml_(input, tensor1, tensor2, Tensor(value))
 
 
 def angle(input):
@@ -489,8 +526,7 @@ def bincount(input, weights=None, minlength=0):
         raise TypeError(f"For math function 'bincount', 'weights' must be Tensor, but got {type(weights)}.")
     if not isinstance(minlength, int) or isinstance(minlength, bool):
         raise TypeError(f"For math function 'bincount', 'minlength' must be int but got {type(minlength)}.")
-    rank_op = _get_cache_prim(P.Rank)()
-    if rank_op(input) != 1:
+    if rank_(input) != 1:
         raise ValueError(f"For math function 'bincount', 'input' should be one-dimensional tensor.")
     if not (input >= 0).all():
         raise ValueError(f"For 'bincount', elements of 'input' should be non-negative.")
@@ -554,7 +590,7 @@ def bucketize(input, boundaries, *, right=False):
 
     bucketize_op = _get_cache_prim(P.Bucketize)
     epsilon_ = 0. if right else 1.e-6
-    boundaries = [boundary+epsilon_ for boundary in boundaries]
+    boundaries = [boundary + epsilon_ for boundary in boundaries]
     return bucketize_op(boundaries)(input)
 
 
@@ -628,18 +664,15 @@ def argmin(input, axis=None, keepdims=False):
         return Tensor(0)
     is_axis_none = False
     if axis is None:
-        input = P.Reshape()(input, (-1,))
+        input = reshape_(input, (-1,))
         axis = 0
         is_axis_none = True
     out = _get_cache_prim(P.Argmin)(axis)(input)
     if keepdims and not is_axis_none:
-        out = P.ExpandDims()(out, axis)
+        out = expand_dims_(out, axis)
     return out
 
 
-neg_tensor = P.Neg()
-
-
 def neg(input):
     """
     Returns a tensor with negative values of the input tensor element-wise.
@@ -857,8 +890,8 @@ def sub(input, other):
     Args:
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
         other (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.
@@ -952,8 +985,8 @@ def mul(input, other):
     Args:
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
         other (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.
@@ -1050,10 +1083,10 @@ def div(input, other, *, rounding_mode=None):
         raise ValueError("For ops.div, rounding_mode value should be None, 'floor' or 'trunc'.")
 
     if rounding_mode == 'floor':
-        return _get_cache_prim(P.FloorDiv)()(input, other)
-    output = _get_cache_prim(P.Div)()(input, other)
+        return tensor_floordiv(input, other)
+    output = div_(input, other)
     if rounding_mode == 'trunc':
-        output = _get_cache_prim(P.Trunc)()(output)
+        output = trunc_(output)
     return output
 
 
@@ -1241,8 +1274,8 @@ def pow(input, exponent):
     Args:
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
         exponent (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\_.
@@ -1436,7 +1469,7 @@ def logdet(input):
     Calculates log determinant of one or a batch of square matrices.
 
     Args:
-        input (Tensor): Input Tensor of any dimension.
+        input (Tensor): Tensor of shape :math:`(*, n, n)` where :math:`*` means zero or more batch dimensions.
 
     Returns:
         Tensor, the log determinant of `input`. If the matrix determinant is smaller than 0, nan will be returned. If
@@ -1491,8 +1524,7 @@ def floor(input):
         >>> print(output)
         [ 1.  2. -2.]
     """
-    _floor = _get_cache_prim(P.Floor)()
-    return _floor(input)
+    return floor_(input)
 
 
 def i0(input):
@@ -1560,9 +1592,10 @@ def inplace_add(x, v, indices):
             `indices` refers to the left-most dimension.
 
     Args:
-        x (Tensor): The first input is a tensor whose data type is float16, float32, float64 or int32.
-        v (Tensor): The second input is a tensor that has the same dimension sizes as `x` except
-            the first dimension, which must be the same as indices' size. It has the same data type with `x`.
+        x (Tensor): The tensor to be added. It has shape :math:`(N,*)` where :math:`*` means
+            any number of additional dimensions.
+        v (Tensor):  The value tensor add to `x`. It has the same dimension sizes as `x` except
+          the first dimension, whose size must be the same as `indices`. It has the same data type with `x`.
         indices (Union[int, tuple]): Indices into the left-most dimension of `x`, and determines which rows of `x`
             to add with `v`. It is an integer or a tuple, whose value is in [0, the first dimension size of `x`).
 
@@ -1650,10 +1683,10 @@ def inplace_sub(x, v, indices):
         `indices` refers to the left-most dimension.
 
     Args:
-        x (Tensor): The first input is a tensor whose data type is float16, float32, float64 or int32.
-            Tensors of arbitrary dimensions are supported.
-        v (Tensor): The second input is a tensor who has the same dimension sizes as `x` except
-            the first dimension, which must be the same as indices' size. It has the same data type with `x`.
+        x (Tensor): TThe tensor to be subtracted. It has shape :math:`(N,*)` where :math:`*` means
+            any number of additional dimensions.
+        v (Tensor): The value tensor subtract from `x`. It has the same dimension sizes as `x` except
+            the first dimension, whose size must be the same as `indices`. It has the same data type with `x`.
         indices (Union[int, tuple]): Indices into the left-most dimension of `x`, and determines which rows of `x`
             to subtract with `v`. It is an int or tuple, whose value is in [0, the first dimension size of `x`).
 
@@ -1891,7 +1924,7 @@ def sign(input):
     """
     if not isinstance(input, Tensor):
         raise TypeError(f"For sign, the input must be a Tensor, but got {type(input)}")
-    return _get_cache_prim(ops.Sign)()(input)
+    return sign_(input)
 
 
 def signbit(input):
@@ -2295,7 +2328,7 @@ def t(input):
     if input.ndim > 2:
         raise ValueError(f"For t(), the dimension of tensor should be less than 3, but got {input.ndim}.")
     if input.ndim == 2:
-        return _get_cache_prim(P.Transpose)()(input, (1, 0))
+        return transpose_(input, (1, 0))
     return input
 
 
@@ -2352,8 +2385,8 @@ def xlogy(input, other):
     Args:
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
         other (Union[Tensor, number.Number, bool]): The second input is a number.Number or
             a bool when the first input is a tensor or a tensor whose data type is number or bool\_.
             When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.
@@ -2452,8 +2485,7 @@ def arctan2(input, other):
         >>> print(output)
         [0.        0.7853982]
     """
-    _atan2 = _get_cache_prim(P.Atan2)()
-    return _atan2(input, other)
+    return atan2_(input, other)
 
 
 def polar(abs, angle):  # pylint: disable=redefined-outer-name
@@ -2857,16 +2889,17 @@ def atan2(input, other):
         - At least one of the `input` and `other` args is Tensor.
 
     Args:
-        input (Tensor, Number.number): The input tensor or scalar.
+        input (Tensor): The input tensor with shape
+            :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
             The data type should be one of the following types: float16, float32, float64
-        other (Tensor, Number.number): The input tensor or scalar. It has the same shape with `input` or
+        other (Tensor): The input tensor. It has the same shape with `input` or
             its shape is able to broadcast with `input`.
 
     Returns:
-        Tensor or scalar, the shape is the same as the one after broadcasting, and the data type is same as `input`.
+        Tensor, the shape is the same as the one after broadcasting, and the data type is same as `input`.
 
     Raises:
-        TypeError: If `input` or `other` is not a Tensor or scalar.
+        TypeError: If `input` or `other` is not a Tensor.
         RuntimeError: If the data type of `input` and `other` conversion of Parameter is required
                       when data type conversion of Parameter is not supported.
 
@@ -2883,8 +2916,7 @@ def atan2(input, other):
         >>> print(output)
         [0.        0.7853982]
     """
-    _atan2 = _get_cache_prim(P.Atan2)()
-    return _atan2(input, other)
+    return atan2_(input, other)
 
 
 def bitwise_and(input, other):
@@ -3154,7 +3186,6 @@ def nextafter(input, other):
         >>> print(output_)
         [1.e-45]
     """
-    nextafter_ = _get_cache_prim(P.NextAfter)()
     return nextafter_(input, other)
 
 
@@ -3218,7 +3249,7 @@ def inverse(input):
          [ 1.5 -0.5]]
     """
     _check_is_tensor("input", input, "inverse")
-    return _get_cache_prim(P.MatrixInverse)()(input)
+    return matrix_inverse_(input)
 
 
 def invert(x):
@@ -3229,13 +3260,14 @@ def invert(x):
         out_i = \sim x_{i}
 
     Args:
-        x (Tensor): The input Tensor.
+        x (Tensor): The input Tensor of shape :math:`(x_1, x_2, ..., x_R)`.
+            The data type should be one of the following types: int16, uint16.
 
     Returns:
         Tensor, has the same shape as `x`.
 
     Raises:
-        TypeError: If dtype of `x` is neither int nor uint.
+        TypeError: If dtype of `x` is neither int16 nor uint16.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3261,8 +3293,10 @@ def erf(input):
         erf(x)=\frac{2} {\sqrt{\pi}} \int\limits_0^{x} e^{-t^{2}} dt
 
     Args:
-        input (Tensor): The input tensor of Gaussian error function. Its data type
-            must be float16 float32 or float64.
+        input (Tensor): The input tensor of Gaussian error function. Supported dtypes:
+
+            - Ascend: float16, float32.
+            - GPU/CPU: float16, float32, float64.
 
     Returns:
         Tensor, has the same shape and dtype as the `input`.
@@ -3295,7 +3329,10 @@ def erfc(input):
         erfc(x) = 1 - \frac{2} {\sqrt{\pi}} \int\limits_0^{x} e^{-t^{2}} dt
 
     Args:
-        input (Tensor): The input tensor with a dtype of float16, float32 or float64.
+        input (Tensor): The input tensor. Supported dtypes:
+
+            - Ascend: float16, float32.
+            - GPU/CPU: float16, float32, float64.
 
     Returns:
         Tensor, has the same shape and dtype as `input`.
@@ -3321,7 +3358,15 @@ def erfc(input):
 
 def bessel_j0(x):
     r"""
-    Computes the Bessel j0 function of x element-wise.
+    Computes Bessel function of the first kind, order 0 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            J_{0}(x) = \frac{1}{\pi} \int_{0}^{\pi} \cos (x \sin \theta) d \theta
+            =\sum_{m=0}^{\infty} \frac{(-1)^{m} x^{2 m}}{2^{2 m} (m !)^2}
+        \end{array}
 
     Args:
         x (Tensor): The input tensor. The data type must be float16, float32 or float64.
@@ -3350,7 +3395,15 @@ def bessel_j0(x):
 
 def bessel_j1(x):
     r"""
-    Computes the Bessel j1 function of x element-wise.
+    Computes Bessel function of the first kind, order 1 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            J_{1}(x) = \frac{1}{\pi} \int_{0}^{\pi} \cos (x \sin \theta- \theta) d \theta
+            =\sum_{m=0}^{\infty} \frac{(-1)^{m} x^{2 m+1}}{2^{2 m+1} m !(m+1) !}
+        \end{array}
 
     Args:
         x (Tensor): The input tensor. The data type must be float16, float32 or float64.
@@ -3379,7 +3432,15 @@ def bessel_j1(x):
 
 def bessel_i0(x):
     r"""
-    Computes the Bessel i0 function of x element-wise.
+    Computes modified Bessel function of the first kind, order 0 element-wise.
+
+    .. math::
+        \begin{array}{ll} \\
+            I_{0}(x)=J_{0}(\mathrm{i} x)=\sum_{m=0}^{\infty}
+            \frac{x^{2 m}}{2^{2 m} (m !)^{2}}
+        \end{array}
+
+    where :math:`J_{0}` is Bessel function of the first kind, order 0.
 
     Args:
         x (Tensor): The input tensor. The data type must be float16, float32 or float64.
@@ -3408,7 +3469,17 @@ def bessel_i0(x):
 
 def bessel_i0e(x):
     r"""
-    Computes the Bessel i0e function of x element-wise.
+    Computes exponential scaled modified Bessel function of the first kind, order 0 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            \text I_{0}e(x)=e^{(-|x|)} * I_{0}(x)=e^{(-|x|)} * \sum_{m=0}^
+            {\infty} \frac{x^{2 m}}{2^{2 m} (m !)^{2}}
+        \end{array}
+
+    where :math:`I_{0}` is modified Bessel function of the first kind, order 0.
 
     Args:
         x (Tensor): The input tensor. The data type must be float16, float32 or float64.
@@ -3437,7 +3508,17 @@ def bessel_i0e(x):
 
 def bessel_k0(x):
     r"""
-    Computes the Bessel k0 function of x element-wise.
+    Computes modified Bessel function of the second kind, order 0 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            K_{0}(x)= \lim_{\nu \to 0} \left(\frac{\pi}{2}\right) \frac
+            {I_{-\nu}(x)-I_{\nu}(x)}{\sin (\nu \pi)} = \int_{0}^{\infty} e^{-x \cosh t} d t
+        \end{array}
+
+    where :math:`I_{0}` is modified Bessel function of the first kind, order 0.
 
     Args:
         x (Tensor): The input tensor. The data type must be float16, float32 or float64.
@@ -3466,7 +3547,17 @@ def bessel_k0(x):
 
 def bessel_k0e(x):
     r"""
-    Computes the Bessel k0e function of x element-wise.
+    Computes exponential scaled modified Bessel function of the second kind, order 0 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            K_{0}e(x)= e^{(-|x|)} * K_{0}(x) = e^{(-|x|)} * \int_{0}^
+            {\infty} e^{-x \cosh t} d t
+        \end{array}
+
+    where :math:`K_{0}` is modified Bessel function of the second kind, order 0.
 
     Args:
         x (Tensor): The input tensor. The data type must be float16, float32 or float64.
@@ -3495,7 +3586,16 @@ def bessel_k0e(x):
 
 def bessel_y0(x):
     r"""
-    Computes the Bessel y0 function of x element-wise.
+    Computes Bessel function of the second kind, order 0 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            Y_{0}(x)=\lim_{n \to 0} \frac{J_{n}(x) \cos n \pi-J_{-n}(x)}{\sin n \pi}
+        \end{array}
+
+    where :math:`J_{0}` is Bessel function of the first kind, order 0.
 
     Args:
         x (Tensor): The input tensor. The data type must be float16, float32 or float64.
@@ -3524,7 +3624,16 @@ def bessel_y0(x):
 
 def bessel_y1(x):
     r"""
-    Computes the Bessel y1 function of x element-wise.
+    Computes Bessel function of the second kind, order 1 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            Y_{1}(x)=\lim_{n \to 1} \frac{J_{n}(x) \cos n \pi-J_{-n}(x)}{\sin n \pi}
+        \end{array}
+
+    where :math:`J_{1}` is Bessel function of the first kind, order 1.
 
     Args:
         x (Tensor): The input tensor. The data type must be float16, float32 or float64.
@@ -3551,6 +3660,36 @@ def bessel_y1(x):
     return bessel_y1_(x)
 
 
+def eps(x):
+    r"""
+    Create a Tensor with the same data type and shape as input, and the element value is the minimum value that the
+    corresponding data type can express.
+
+    Args:
+        x (Tensor): Tensor of any dimension used to obtain the minimum value that its data type can express.
+            The data type must be float16, float32 or float64.
+
+    Returns:
+        Tensor, has the same type and shape as `x`, but filled with `x` dtype minimum val.
+
+    Raises:
+        TypeError: If `x` is not a Tensor.
+        TypeError: If data type of `x` is neither float16, float32, nor float64.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor([4, 1, 2, 3], mindspore.float32)
+        >>> output = ops.eps(x)
+        >>> print(output)
+        [1.1920929e-07 1.1920929e-07 1.1920929e-07 1.1920929e-07]
+    """
+    return eps_(x)
+
+
 def linspace(start, end, steps):
     r"""
     Returns a Tensor whose value is `steps` evenly spaced in the interval `start` and `end` (including `start` and
@@ -3633,7 +3772,7 @@ def det(input):
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
     """
-    return _get_cache_prim(P.MatrixDeterminant)()(input)
+    return matrix_determinant_(input)
 
 
 def matrix_determinant(input):
@@ -3641,7 +3780,7 @@ def matrix_determinant(input):
     `matrix_determinant` is deprecated, please use `det` instead.
     """
     logger.warning("matrix_determinant is deprecated, please use `det` instead.")
-    return _get_cache_prim(P.MatrixDeterminant)()(input)
+    return matrix_determinant_(input)
 
 
 def log_matrix_determinant(input):
@@ -3649,7 +3788,7 @@ def log_matrix_determinant(input):
     `log_matrix_determinant` is deprecated, please use `matrix_solve` instead.
     """
     logger.warning("`log_matrix_determinant` is deprecated, please use `matrix_solve` instead.")
-    return _get_cache_prim(P.LogMatrixDeterminant)()(input)
+    return log_matrix_determinant_(input)
 
 
 def matrix_exp(input):
@@ -3830,7 +3969,7 @@ def slogdet(input):
         >>> print(output)
         [2.80336046e+00    3.04452229e+00]
     """
-    return _get_cache_prim(P.LogMatrixDeterminant)()(input)
+    return log_matrix_determinant_(input)
 
 
 def trace(input):
@@ -3870,7 +4009,6 @@ def trace(input):
         >>> print(output)
         24.0
     """
-    trace_ = _get_cache_prim(P.Trace)()
     return trace_(input)
 
 
@@ -3992,7 +4130,7 @@ def trunc(input):
         >>> print(output)
         [3. 0. 0. -3.]
     """
-    return _get_cache_prim(P.Trunc)()(input)
+    return trunc_(input)
 
 
 def ldexp(x, other):
@@ -4043,11 +4181,7 @@ def ldexp(x, other):
         [[2.]
          [8.]]
     """
-
-    pow_ops = _get_cache_prim(P.Pow)()
-    mul_ops = _get_cache_prim(P.Mul)()
-
-    out = mul_ops(x, pow_ops(2.0, other))
+    out = tensor_mul(x, tensor_pow(2.0, other))
     return out
 
 
@@ -4102,11 +4236,11 @@ def logit(input, eps=None):
 #####################################
 
 
-def less(x, y):
+def less(input, other):
     r"""
-    Computes the boolean value of :math:`x < y` element-wise.
+    Computes the boolean value of :math:`input < other` element-wise.
 
-    Inputs of `x` and `y` comply with the implicit type conversion rules to make the data types consistent.
+    Inputs of `input` and `other` 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 one tensor and one scalar,
     the scalar could only be a constant.
@@ -4114,21 +4248,21 @@ def less(x, y):
     .. math::
 
         out_{i} =\begin{cases}
-            & \text{True,    if } x_{i}<y_{i} \\
-            & \text{False,   if } x_{i}>=y_{i}
+            & \text{True,    if } input_{i}<other_{i} \\
+            & \text{False,   if } input_{i}>=other_{i}
             \end{cases}
 
     Args:
-        x (Union[Tensor, Number, bool]): The first input is a number or
+        input (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
+        other (Union[Tensor, Number, bool]): The second input is a number or
             a bool when the first input is a tensor, or it can be a tensor whose data type is number or bool.
 
     Returns:
         Tensor, the shape is the same as the one after broadcasting,and the data type is bool.
 
     Raises:
-        TypeError: If `x` and `y` is not one of the following: Tensor, Number, bool.
+        TypeError: If `input` and `other` is not one of the following: Tensor, Number, bool.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4143,7 +4277,7 @@ def less(x, y):
         >>> print(output)
         [False False True]
     """
-    return tensor_lt(x, y)
+    return tensor_lt(input, other)
 
 
 def lt(input, other):
@@ -4156,28 +4290,29 @@ def lt(input, other):
     return less(input, other)
 
 
-def le(x, y):
+def le(input, other):
     r"""
-    Computes the boolean value of :math:`x <= y` element-wise.
+    Computes the boolean value of :math:`input <= other` element-wise.
 
     .. math::
 
         out_{i} =\begin{cases}
-            & \text{True,    if } x_{i}<=y_{i} \\
-            & \text{False,   if } x_{i}>y_{i}
+            & \text{True,    if } input_{i}<=other_{i} \\
+            & \text{False,   if } input_{i}>other_{i}
             \end{cases}
 
     .. note::
-        - Inputs of `x` and `y` comply with the implicit type conversion rules to make the data types consistent.
+        - Inputs of `input` and `other` 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 one tensor and one scalar, the scalar could only be a constant.
 
     Args:
-        x (Union[Tensor, number.Number, bool]): The first input is a number.Number or
+        input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_.
-        y (Union[Tensor, number.Number, bool]): The second input, when the first input is a Tensor,
+            `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
+        other (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\_.
 
@@ -4185,7 +4320,7 @@ def le(x, y):
         Tensor, the shape is the same as the one after broadcasting, and the data type is bool.
 
     Raises:
-        TypeError: If neither `x` nor `y` is a Tensor.
+        TypeError: If neither `input` nor `other` is a Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4200,22 +4335,23 @@ def le(x, y):
         >>> print(output)
         [ True False  True]
     """
-    return tensor_le(x, y)
+    return tensor_le(input, other)
 
 
-def gt(x, y):
+def gt(input, other):
     r"""
-    Compare the value of the input parameters :math:`x,y` element-wise, and the output result is a bool value.
+    Compare the value of the input parameters :math:`input,other` element-wise, and the output result is a bool value.
 
     .. math::
 
         out_{i} =\begin{cases}
-            & \text{True,    if } x_{i}>y_{i} \\
-            & \text{False,   if } x_{i}<=y_{i}
+            & \text{True,    if } input_{i}>other_{i} \\
+            & \text{False,   if } input_{i}<=other_{i}
             \end{cases}
 
     Note:
-        - Inputs of `x` and `y` comply with the implicit type conversion rules to make the data types consistent.
+        - Inputs of `input` and `other` comply with the implicit type conversion rules to make the data types
+          consistent.
         - The inputs must be two tensors or one tensor and one scalar.
         - When the inputs are two tensors, dtypes of them cannot be bool at the same time,
           and the shapes of them can be broadcast.
@@ -4225,11 +4361,11 @@ def gt(x, y):
           in another input by copying the value of the dimension.
 
     Args:
-        x (Union[Tensor, number.Number, bool]): The first input is a number.Number or
+        input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ .
-        y (Union[Tensor, number.Number, bool]): The second input, when the first input is a Tensor,
+            `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ .
+        other (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\_.
 
@@ -4237,7 +4373,7 @@ def gt(x, y):
         Tensor, the shape is the same as the one after broadcasting, and the data type is bool.
 
     Raises:
-        TypeError: If neither `x` nor `y` is a Tensor.
+        TypeError: If neither `input` nor `other` is a Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4252,16 +4388,16 @@ def gt(x, y):
         >>> print(output)
         [False True False]
     """
-    _greater = _get_cache_prim(P.Greater)()
-    return _greater(x, y)
+    return tensor_gt(input, other)
 
 
-def ge(x, y):
+def ge(input, other):
     r"""
-    Computes the boolean value of :math:`x >= y` element-wise.
+    Computes the boolean value of :math:`input >= other` element-wise.
 
     Note:
-        - Inputs of `x` and `y` comply with the implicit type conversion rules to make the data types consistent.
+        - Inputs of `input` and `other` comply with the implicit type conversion rules to make the data types
+          consistent.
         - The inputs must be two tensors or one tensor and one scalar.
         - When the inputs are two tensors, dtypes of them cannot be bool at the same time,
           and the shapes of them can be broadcast.
@@ -4273,21 +4409,21 @@ def ge(x, y):
     .. math::
 
         out_{i} =\begin{cases}
-            & \text{True,    if } x_{i}>=y_{i} \\
-            & \text{False,   if } x_{i}<y_{i}
+            & \text{True,    if } input_{i}>=other_{i} \\
+            & \text{False,   if } input_{i}<other_{i}
             \end{cases}
 
     Args:
-        x (Union[Tensor, Number, bool]): The first input is a number or
+        input (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
+        other (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.
 
     Returns:
         Tensor, the shape is the same as the one after broadcasting, and the data type is bool.
 
     Raises:
-        TypeError: If neither `x` nor `y` is a Tensor.
+        TypeError: If neither `input` nor `other` is a Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4302,14 +4438,15 @@ def ge(x, y):
         >>> print(output)
         [True True False]
     """
-    _greater_equal = _get_cache_prim(P.GreaterEqual)()
-    return _greater_equal(x, y)
+    return tensor_ge(input, other)
 
 
-def equal(input, other):
+def eq(input, other):
     r"""
     Computes the equivalence between two tensors element-wise.
 
+    The second argument can be a number or a tensor whose shape is broadcastable with the first argument and vise versa.
+
     .. math::
 
         out_{i} =\begin{cases}
@@ -4319,16 +4456,14 @@ def equal(input, other):
 
     Note:
         - `input` and `other` 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 could be broadcast.
-        - When the inputs are one tensor and one scalar, the scalar could only be a constant.
+        - The shapes of the inputs can be broadcasted to each other.
 
     Args:
         input (Union[Tensor, Number]): The first input is a number or
             a tensor whose data type is number.
-        other (Union[Tensor, Number]): The second input is a number
-            when the first input is a tensor or a tensor whose data type is number.
-            The data type is the same as the first input.
+        other (Union[Tensor, Number]): The second input is a number when the first input is a tensor.
+            The data type is the same as the first input. If the first input is a number,
+            the second input should be a tensor.
 
     Returns:
         Tensor, the shape is the same as the one after broadcasting, and the data type is bool.
@@ -4341,16 +4476,66 @@ def equal(input, other):
 
     Examples:
         >>> import mindspore
-        >>> import numpy as np
         >>> from mindspore import Tensor, ops
         >>> # case 1: The shape of two inputs are different
-        >>> x = Tensor(np.array([1, 2, 3]), mindspore.float32)
+        >>> x = Tensor([1, 2, 3], mindspore.float32)
+        >>> output = ops.eq(x, 2.0)
+        >>> print(output)
+        [False True False]
+        >>> # case 2: The shape of two inputs are the same
+        >>> x = Tensor([1, 2, 3], mindspore.int32)
+        >>> y = Tensor([1, 2, 4], mindspore.int32)
+        >>> output = ops.eq(x, y)
+        >>> print(output)
+        [ True  True False]
+    """
+    return equal_(input, other)
+
+
+def equal(input, other):
+    r"""
+    Computes the equivalence between two tensors element-wise.
+
+    The second argument can be a number or a tensor whose shape is broadcastable with the first argument and vise versa.
+
+    .. math::
+
+        out_{i} =\begin{cases}
+            & \text{True,    if } input_{i} = other_{i} \\
+            & \text{False,   if } input_{i} \ne other_{i}
+            \end{cases}
+
+    Note:
+        - `input` and `other` comply with the implicit type conversion rules to make the data types consistent.
+        - The shapes of the inputs can be broadcasted to each other.
+
+    Args:
+        input (Union[Tensor, Number]): The first input is a number or
+            a tensor whose data type is number.query.dtye
+        other (Union[Tensor, Number]): The second input is a number when the first input is a tensor.
+            The data type is the same as the first input. If the first input is a number,
+            the second input should be a tensor.
+
+    Returns:
+        Tensor, the shape is the same as the one after broadcasting, and the data type is bool.
+
+    Raises:
+        TypeError: If neither `input` nor `other` is a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> # case 1: The shape of two inputs are different
+        >>> x = Tensor([1, 2, 3], mindspore.float32)
         >>> output = ops.equal(x, 2.0)
         >>> print(output)
         [False True False]
         >>> # case 2: The shape of two inputs are the same
-        >>> x = Tensor(np.array([1, 2, 3]), mindspore.int32)
-        >>> y = Tensor(np.array([1, 2, 4]), mindspore.int32)
+        >>> x = Tensor([1, 2, 3], mindspore.int32)
+        >>> y = Tensor([1, 2, 4], mindspore.int32)
         >>> output = ops.equal(x, y)
         >>> print(output)
         [ True  True False]
@@ -4358,12 +4543,13 @@ def equal(input, other):
     return equal_(input, other)
 
 
-def ne(x, y):
+def ne(input, other):
     r"""
     Computes the non-equivalence of two tensors element-wise.
 
     Note:
-        - Inputs of `x` and `y` comply with the implicit type conversion rules to make the data types consistent.
+        - Inputs of `input` and `other` 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 could be broadcast.
         - When the inputs are one tensor and one scalar, the scalar could only be a constant.
@@ -4372,42 +4558,41 @@ def ne(x, y):
     .. math::
 
         out_{i} =\begin{cases}
-        & \text{True,    if } x_{i} \ne y_{i} \\
-        & \text{False,   if } x_{i} = y_{i}
+        & \text{True,    if } input_{i} \ne other_{i} \\
+        & \text{False,   if } input_{i} = other_{i}
         \end{cases}
 
     Args:
-        x (Union[Tensor, Number, bool]): The first input is a number or
+        input (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
+        other (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.
 
     Returns:
         Tensor, the shape is the same as the one after broadcasting,and the data type is bool.
 
     Raises:
-        TypeError: If `x` and `y` is not one of the following: Tensor, Number, bool.
-        TypeError: If neither `x` nor `y` is a Tensor.
+        TypeError: If `input` and `other` is not one of the following: Tensor, Number, bool.
+        TypeError: If neither `input` nor `other` is a Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore
-        >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([1, 2, 3]), mindspore.float32)
+        >>> x = Tensor([1, 2, 3], mindspore.float32)
         >>> output = ops.ne(x, 2.0)
         >>> print(output)
         [ True False  True]
         >>>
-        >>> x = Tensor(np.array([1, 2, 3]), mindspore.int32)
-        >>> y = Tensor(np.array([1, 2, 4]), mindspore.int32)
+        >>> x = Tensor([1, 2, 3], mindspore.int32)
+        >>> y = Tensor([1, 2, 4], mindspore.int32)
         >>> output = ops.ne(x, y)
         >>> print(output)
         [False False  True]
     """
-    return not_equal_(x, y)
+    return not_equal_(input, other)
 
 
 def not_equal(input, other):
@@ -4508,27 +4693,27 @@ def isfinite(x):
     return isfinite_(x)
 
 
-def isnan(x):
+def isnan(input):
     r"""
     Determines which elements are NaN for each position.
 
     .. math::
 
         out_i = \begin{cases}
-          & \ True,\ \text{ if } x_{i} = \text{Nan} \\
-          & \ False,\ \text{ if } x_{i} \ne  \text{Nan}
+          & \ True,\ \text{ if } input_{i} = \text{Nan} \\
+          & \ False,\ \text{ if } input_{i} \ne  \text{Nan}
         \end{cases}
 
     where :math:`Nan` means not a number.
 
     Args:
-        x (Tensor): The input tensor.
+        input (Tensor): The input tensor.
 
     Returns:
-        Tensor, has the same shape of input, and the dtype is bool.
+        Tensor, has the same shape of `input`, and the dtype is bool.
 
     Raises:
-        TypeError: If `x` is not a Tensor.
+        TypeError: If `input` is not a Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4546,34 +4731,34 @@ def isnan(x):
         >>> print(output)
         False
     """
-    return isnan_(x)
+    return isnan_(input)
 
 
-def isclose(x1, x2, rtol=1e-05, atol=1e-08, equal_nan=False):
+def isclose(input, other, rtol=1e-05, atol=1e-08, equal_nan=False):
     """
-    Returns a new Tensor with boolean elements representing if each element of `x1`
-    is “close” to the corresponding element of `x2`. Closeness is defined as:
+    Returns a new Tensor with boolean elements representing if each element of `input`
+    is “close” to the corresponding element of `other`. Closeness is defined as:
 
     .. math::
-        ∣x1−x2∣  ≤  atol + rtol × ∣x2∣
+        ∣input−other∣  ≤  atol + rtol × ∣other∣
 
     Args:
-        x1 (Tensor): First Tensor to compare, with data type belongs to float32, float16, int32.
-        x2 (Tensor): Second Tensor to compare, with data type belongs to float32, float16, int32.
+        input (Tensor): First Tensor to compare, with data type belongs to float32, float16, int32.
+        other (Tensor): Second Tensor to compare, with data type belongs to float32, float16, int32.
         rtol (float, optional): Relative tolerance. Default: ``1e-05`` .
         atol (float, optional): Absolute tolerance. Default: ``1e-08`` .
         equal_nan (bool, optional): If True, then two NaNs will be considered equal. Default: ``False`` .
 
     Returns:
-        A bool Tensor, with the shape as broadcasted result of the input `x1` and `x2`.
+        A bool Tensor, with the shape as broadcasted result of the input `input` and `other`.
 
     Raises:
-        TypeError: If either of `x1` and `x2` is not Tensor.
-        TypeError: If either of `x1` and `x2` is not float16, float32 or int32.
+        TypeError: If either of `input` and `other` is not Tensor.
+        TypeError: If either of `input` and `other` is not float16, float32 or int32.
         TypeError: If either of `atol` and `rtol` is not float.
         TypeError: If `equal_nan` is not bool.
-        TypeError: If the dtype of `x1` is not same as the `x2`.
-        ValueError: If `x1` and `x2` can not be broadcast.
+        TypeError: If the dtype of `input` is not same as the `other`.
+        ValueError: If `input` and `other` can not be broadcast.
         ValueError: If either of `atol` and `rtol` is less than zero.
 
     Supported Platforms:
@@ -4590,7 +4775,7 @@ def isclose(x1, x2, rtol=1e-05, atol=1e-08, equal_nan=False):
         [ True False False False  True]
     """
     is_close = _get_cache_prim(P.IsClose)(rtol=rtol, atol=atol, equal_nan=equal_nan)
-    return is_close(x1, x2)
+    return is_close(input, other)
 
 
 def isreal(input):
@@ -4622,14 +4807,11 @@ def isreal(input):
     _check_is_tensor("input", input, "isreal")
 
     # Note: Integral and Floating tensor values are always real
-    fillv2_op = _get_cache_prim(P.FillV2)()
     value = Tensor(1, mstype.bool_)
     real_dtype = mstype.int_type + mstype.uint_type + mstype.float_type + (mstype.bool_,)
     if input.dtype in real_dtype:
-        return fillv2_op(input.shape, value)
-
-    imag_op = _get_cache_prim(P.Imag)()
-    return imag_op(input) == 0
+        return fill_v2_(input.shape, value)
+    return imag_(input) == 0
 
 
 def is_complex(input):
@@ -4764,12 +4946,13 @@ def fmax(input, other):
     return fmax_(input, other)
 
 
-def maximum(x, y):
+def maximum(input, other):
     r"""
     Computes the maximum of input tensors element-wise.
 
     Note:
-        - Inputs of `x` and `y` comply with the implicit type conversion rules to make the data types consistent.
+        - Inputs of `input` and `other` comply with the implicit type conversion rules to make the data types
+          consistent.
         - The inputs must be two tensors or one tensor and one scalar.
         - When the inputs are two tensors,
           dtypes of them cannot be bool at the same time, and the shapes of them could be broadcast.
@@ -4779,12 +4962,12 @@ def maximum(x, y):
         - If one of the elements being compared is a NaN, then that element is returned.
 
     .. math::
-        output_i = \max(x_i, y_i)
+        output_i = \max(input_i, other_i)
 
     Args:
-        x (Union[Tensor, Number, bool]): The first input is a number or
+        input (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
+        other (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.
 
     Returns:
@@ -4792,8 +4975,8 @@ def maximum(x, y):
         and the data type is the one with higher precision or higher digits among the two inputs.
 
     Raises:
-        TypeError: If `x` and `y` is not one of the following: Tensor, Number, bool.
-        ValueError: If `x` and `y` are not the same shape.
+        TypeError: If `input` and `other` is not one of the following: Tensor, Number, bool.
+        ValueError: If `input` and `other` are not the same shape.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4815,7 +4998,7 @@ def maximum(x, y):
         >>> print(output.dtype)
         Float32
     """
-    return maximum_(x, y)
+    return maximum_(input, other)
 
 
 def fmin(input, other):
@@ -4861,12 +5044,13 @@ def fmin(input, other):
     return fmin_(input, other)
 
 
-def minimum(x, y):
+def minimum(input, other):
     r"""
     Computes the minimum of input tensors element-wise.
 
     Note:
-        - Inputs of `x` and `y` comply with the implicit type conversion rules to make the data types consistent.
+        - Inputs of `input` and `other` comply with the implicit type conversion rules to make the data types
+          consistent.
         - The inputs must be two tensors or one tensor and one scalar.
         - When the inputs are two tensors, dtypes of them cannot be bool at the same time.
         - When the inputs are one tensor and one scalar, the scalar could only be a constant.
@@ -4874,12 +5058,12 @@ def minimum(x, y):
         - If one of the elements being compared is a NaN, then that element is returned.
 
     .. math::
-        output_i = \min(x_i, y_i)
+        output_i = \min(input_i, other_i)
 
     Args:
-        x (Union[Tensor, Number, bool]): The first input is a number or
+        input (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
+        other (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.
 
     Returns:
@@ -4887,8 +5071,8 @@ def minimum(x, y):
         and the data type is the one with higher precision or higher digits among the two inputs.
 
     Raises:
-        TypeError: If `x` and `y` is not one of the following: Tensor, Number, bool.
-        ValueError: If `x` and `y` are not the same shape after broadcast.
+        TypeError: If `input` and `other` is not one of the following: Tensor, Number, bool.
+        ValueError: If `input` and `other` are not the same shape after broadcast.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4910,7 +5094,7 @@ def minimum(x, y):
         >>> print(output.dtype)
         Float32
     """
-    return minimum_(x, y)
+    return minimum_(input, other)
 
 
 def median(input, axis=-1, keepdims=False):
@@ -4993,8 +5177,8 @@ def nanmedian(input, axis=-1, keepdims=False):
         >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> x = Tensor([[0.57, 0.11, float("nan")],
-        >>>             [0.38, float("nan"), float("nan")],
-        >>>             [0.36, 0.16, float("nan")]], mindspore.float32)
+        ...             [0.38, float("nan"), float("nan")],
+        ...             [0.36, 0.16, float("nan")]], mindspore.float32)
         >>> y, idx = ops.nanmedian(x, axis=0, keepdims=False)
         >>> print(y)
         [0.38 0.11  nan]
@@ -5153,7 +5337,7 @@ def ormqr(input, tau, other, left=True, transpose=False):
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
         >>> input = Tensor(np.array([[-114.6, 10.9, 1.1], [-0.304, 38.07, 69.38], [-0.45, -0.17, 62]]),
-        >>>                mindspore.float32)
+        ...                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],
@@ -5507,7 +5691,7 @@ def vander(x, N=None):
     if N <= 0:
         raise ValueError(
             f"For vander, N must be greater than 0, but got {N}.")
-    exponent = ops.range(Tensor(N-1), Tensor(-1), Tensor(-1))
+    exponent = ops.range(Tensor(N - 1), Tensor(-1), Tensor(-1))
     x = F.expand_dims(x, 1)
     exponent = F.expand_dims(exponent, 0)
     return F.tensor_pow(x, exponent)
@@ -5629,10 +5813,10 @@ def var_mean(input, axis=None, ddof=0, keepdims=False):
     axis = _check_var_std_input(input, ddof, keepdims, axis, "var_mean")
     if ddof in (0, 1):
         output = _get_cache_prim(P.ReduceStd)(axis=axis, unbiased=bool(ddof), keep_dims=keepdims)(input)
-        return _get_cache_prim(P.Pow)()(output[0], 2), output[1]
+        return tensor_pow(output[0], 2), output[1]
     x_mean = mean(input, axis, True)
-    x_sub = _get_cache_prim(P.Sub)()(input, x_mean)
-    x_pow = _get_cache_prim(P.Pow)()(x_sub, 2)
+    x_sub = tensor_sub(input, x_mean)
+    x_pow = tensor_pow(x_sub, 2)
     x_sum = sum(x_pow, axis, keepdims)
     res_mean = mean(input, axis, keepdims)
     nums = 1
@@ -5762,7 +5946,7 @@ def std_mean(input, axis=None, ddof=0, keepdims=False):
     if ddof in (0, 1):
         return _get_cache_prim(P.ReduceStd)(axis=axis, unbiased=bool(ddof), keep_dims=keepdims)(input)
     output = var_mean(input, axis, ddof, keepdims)
-    return _get_cache_prim(P.Pow)()(output[0], 0.5), output[1]
+    return tensor_pow(output[0], 0.5), output[1]
 
 
 def real(input):
@@ -5791,7 +5975,7 @@ def real(input):
         >>> print(output)
         1.3
     """
-    return _get_cache_prim(ops.Real)()(input)
+    return real_(input)
 
 
 def reciprocal(input):
@@ -5828,7 +6012,7 @@ def reciprocal(input):
         raise TypeError(f"For reciprocal, the input must be a Tensor, but got {type(input)}.")
     if not is_complex(input) and not ops.is_floating_point(input):
         input = ops.cast(input, mstype.float32)
-    return _get_cache_prim(ops.Reciprocal)()(input)
+    return reciprocal_(input)
 
 
 def rsqrt(input):
@@ -5860,7 +6044,7 @@ def rsqrt(input):
         >>> print(output)
         [       nan 1.8349396  0.80530024        nan]
     """
-    return _get_cache_prim(ops.Rsqrt)()(input)
+    return rsqrt_(input)
 
 
 def sqrt(x):
@@ -5971,8 +6155,7 @@ def outer(input, vec2):
     if len(vec2.shape) != 1:
         raise ValueError("the input vec2 must be a 1-D vector!")
     input = input.reshape(-1, 1)
-    mul_ops = _get_cache_prim(P.Mul)()
-    y = mul_ops(input, vec2)
+    y = tensor_mul(input, vec2)
     return y
 
 
@@ -6006,10 +6189,6 @@ def mv(mat, vec):
         >>> print(output)
         [11. 13. 7.]
     """
-
-    matmul_op = _get_cache_prim(P.MatMul)()
-    reshape_op = _get_cache_prim(P.Reshape)()
-
     if not isinstance(mat, (Tensor, Tensor_)):
         raise TypeError("The input mat must be Tensor.")
     if not isinstance(vec, (Tensor, Tensor_)):
@@ -6020,9 +6199,9 @@ def mv(mat, vec):
         raise ValueError("The input vec must be 1-D Tensor.")
 
     length_vec = get_x_shape(vec.shape)
-    vec = reshape_op(vec, (length_vec[0], 1))
+    vec = reshape_(vec, (length_vec[0], 1))
 
-    out = matmul_op(mat, vec)
+    out = matmul_(mat, vec)
     out = out.T
     out = out[0]
     return out
@@ -6080,8 +6259,7 @@ def addbmm(input, batch1, batch2, *, beta=1, alpha=1):
         raise TypeError(f"For 'addbmm', parameter 'alpha' must be an int or float, but got {type(alpha)}.")
     if not isinstance(beta, (int, float)):
         raise TypeError(f"For 'addbmm', parameter 'beta' must be an int or float, but got {type(beta)}.")
-    bmm_op = _get_cache_prim(P.BatchMatMul)()
-    bmm_res = bmm_op(batch1, batch2)
+    bmm_res = batch_matmul_(batch1, batch2)
     return beta * input + alpha * (bmm_res.sum(axis=0))
 
 
@@ -6129,8 +6307,7 @@ def addmm(input, mat1, mat2, *, beta=1, alpha=1):
         raise TypeError(f"For 'addmm', parameter 'alpha' must be an int or float, but got {type(alpha)}.")
     if not isinstance(beta, (int, float)):
         raise TypeError(f"For 'addmm', parameter 'beta' must be an int or float, but got {type(beta)}.")
-    matmul_op = _get_cache_prim(P.MatMul)()
-    return beta * input + alpha * (matmul_op(mat1, mat2))
+    return beta * input + alpha * (matmul_(mat1, mat2))
 
 
 def addmv(input, mat, vec, *, beta=1, alpha=1):
@@ -6180,11 +6357,10 @@ def addmv(input, mat, vec, *, beta=1, alpha=1):
         [30. 27.]
     """
 
-    dtypeop = P.DType()
-    input_dtype = dtypeop(input)
+    input_dtype = dtype_(input)
     if not (isinstance(input, Tensor) and isinstance(mat, Tensor) and isinstance(vec, Tensor)):
         raise TypeError("For Addmv, inputs must be all tensors.")
-    if dtypeop(mat) != dtypeop(vec):
+    if dtype_(mat) != dtype_(vec):
         raise TypeError("For Addmv, the mat and vec should be the same dtype.")
     _check_input_1d(vec.shape, "vec", "Addmv")
     _check_input_2d(mat.shape, "mat", "Addmv")
@@ -6278,11 +6454,10 @@ def addr(x, vec1, vec2, *, beta=1, alpha=1):
          [ 9. 12.]]
     """
 
-    dtypeop = P.DType()
-    input_dtype = dtypeop(x)
+    input_dtype = dtype_(x)
     if not (isinstance(x, Tensor) and isinstance(vec1, Tensor) and isinstance(vec2, Tensor)):
         raise TypeError("For Addr, inputs must be all tensors.")
-    if dtypeop(vec1) != dtypeop(vec2):
+    if dtype_(vec1) != dtype_(vec2):
         raise TypeError("For Addr, the vec1 and vec2 should be the same dtype.")
     _check_input_1d(vec1.shape, "vec1", "Addr")
     _check_input_1d(vec2.shape, "vec2", "Addr")
@@ -6296,12 +6471,11 @@ def addr(x, vec1, vec2, *, beta=1, alpha=1):
         alpha = scalar_cast(alpha, mstype.int32)
         beta = scalar_cast(beta, mstype.int32)
     matmul_op = P.MatMul()
-    reshape_op = P.Reshape()
 
     length_vec1 = get_x_shape(vec1.shape)
-    vec1 = reshape_op(vec1, (length_vec1[0], 1))
+    vec1 = reshape_(vec1, (length_vec1[0], 1))
     length_vec2 = get_x_shape(vec2.shape)
-    vec2 = reshape_op(vec2, (1, length_vec2[0]))
+    vec2 = reshape_(vec2, (1, length_vec2[0]))
 
     out = beta * x + alpha * matmul_op(vec1, vec2)
     return out
@@ -6527,7 +6701,15 @@ def bernoulli(input, p=0.5, seed=None):
 
 def bessel_i1(x):
     r"""
-    Computes the Bessel i1 function of x element-wise.
+    Computes modified Bessel function of the first kind, order 1 element-wise.
+
+    .. math::
+        \begin{array}{ll} \\
+            I_{1}(x)=\mathrm{i}^{-1} J_{1}(\mathrm{i} x)=\sum_{m=0}^
+            {\infty} \frac{x^{2m+1}}{2^{2m+1} m ! (m+1) !}
+        \end{array}
+
+    where :math:`J_{1}` is Bessel function of the first kind, order 1.
 
     Args:
         x (Tensor): The input tensor. The data type must be float16, float32 or float64.
@@ -6556,7 +6738,17 @@ def bessel_i1(x):
 
 def bessel_i1e(x):
     r"""
-    Computes the Bessel i1e function of x element-wise.
+    Computes exponential scaled modified Bessel function of the first kind, order 1 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            \text I_{1}e(x)=e^{(-|x|)} * I_{1}(x)=e^{(-|x|)} * \sum_{m=0}^
+            {\infty} \frac{x^{2m+1}}{2^{2m+1} m ! (m+1) !}
+        \end{array}
+
+    where :math:`I_{1}` is  modified Bessel function of the first kind, order 1.
 
     Args:
         x (Tensor): The input tensor. The data type must be float16, float32 or float64.
@@ -6585,7 +6777,17 @@ def bessel_i1e(x):
 
 def bessel_k1(x):
     r"""
-    Computes the Bessel k1 function of x element-wise.
+    Computes modified Bessel function of the second kind, order 1 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            K_{1}(x)=\lim_{\nu \to 1} \left(\frac{\pi}{2}\right) \frac{I_{-\nu}(x)-
+            I_{\nu}(x)}{\sin (\nu \pi)} = \int_{0}^{\infty} e^{-x \cosh t} \cosh (t) d t
+        \end{array}
+
+    where :math:`I_{1}` is modified Bessel function of the first kind, order 1.
 
     Args:
         x (Tensor): The input tensor. The data type must be float16, float32 or float64.
@@ -6614,7 +6816,17 @@ def bessel_k1(x):
 
 def bessel_k1e(x):
     r"""
-    Computes the Bessel k1e function of x element-wise.
+    Computes exponential scaled modified Bessel function of the second kind, order 1 element-wise.
+
+    The formula is defined as:
+
+    .. math::
+        \begin{array}{ll} \\
+            K_{1}e(x)= e^{(-|x|)} * K_{1}(x) = e^{(-|x|)} * \int_{0}
+            ^{\infty} e^{-x \cosh t} \cosh (t) d t
+        \end{array}
+
+    where :math:`K_{1}` is modified Bessel function of the second kind, order 1.
 
     Args:
         x (Tensor): The input tensor. The data type must be float16, float32 or float64.
@@ -6676,8 +6888,7 @@ def deg2rad(x):
     """
     if not isinstance(x, (Tensor, Tensor_)):
         raise TypeError("The input x must be tensor")
-    dtype_op = _get_cache_prim(P.DType)()
-    x_dtype = dtype_op(x)
+    x_dtype = dtype_(x)
     _check_input_dtype("x", x_dtype, [mstype.float16, mstype.float32, mstype.float64], "")
     if x_dtype == mstype.float16:
         out = x * (Tensor(math.pi / 180.0).astype(mstype.float16))
@@ -6717,8 +6928,7 @@ def rad2deg(x):
     """
     if not isinstance(x, (Tensor, Tensor_)):
         raise TypeError("The input x must be tensor")
-    dtype_op = _get_cache_prim(P.DType)()
-    x_dtype = dtype_op(x)
+    x_dtype = dtype_(x)
     _check_input_dtype("x", x_dtype, [mstype.float16, mstype.float32, mstype.float64], "")
     if x_dtype == mstype.float16:
         out = x * (Tensor(180.0 / math.pi).astype(mstype.float16))
@@ -6823,14 +7033,12 @@ def cummin(input, axis):
     if axis == 0:
         out1, out2 = cummin_op(input)
     else:
-        transpose = _get_cache_prim(P.Transpose)()
-        _shape_op = _get_cache_prim(P.Shape)()
-        x_shape = _shape_op(input)
+        x_shape = shape_(input)
         prem = _create_cummin_perm(axis, x_shape)
-        input = transpose(input, prem)
+        input = transpose_(input, prem)
         out1, out2 = cummin_op(input)
-        out1 = transpose(out1, prem)
-        out2 = transpose(out2, prem)
+        out1 = transpose_(out1, prem)
+        out2 = transpose_(out2, prem)
     return [out1, out2]
 
 
@@ -6896,7 +7104,8 @@ def cumsum(x, axis, dtype=None):
         For the case of dynamic shape, the dtype of `x` only support int32, float16 or float32.
 
     Args:
-        x (Tensor): The input Tensor to accumulate.
+        x (Tensor): The input Tensor of shape :math:`(N,*)` where :math:`*` means, any number
+            of additional dimensions.
         axis (int): Axis along which the cumulative sum is computed.
         dtype (:class:`mindspore.dtype`, optional): The desired dtype of returned Tensor. If specified,
             the input Tensor will be cast to `dtype` before the computation. This is useful for preventing overflows.
@@ -7145,7 +7354,7 @@ def dstack(inputs):
         if tensor.ndim <= 1:
             tensor = _expand(tensor, 2)
         if tensor.ndim == 2:
-            tensor = P.ExpandDims()(tensor, 2)
+            tensor = expand_dims_(tensor, 2)
         trans_inputs += (tensor,)
     if not trans_inputs:
         raise ValueError("For 'dstack', at least one tensor is needed to concatenate.")
@@ -7410,8 +7619,7 @@ def cartesian_prod(*inputs):
     meshgrid_output = meshgrid(inputs)
     stack = P.Stack(axis=-1)
     stack_output = stack(meshgrid_output)
-    reshape = P.Reshape()
-    return reshape(stack_output, (-1, len(inputs)))
+    return reshape_(stack_output, (-1, len(inputs)))
 
 
 def atleast_3d(inputs):
@@ -7461,13 +7669,13 @@ def atleast_3d(inputs):
     """
 
     def _expand3(arr):
-        ndim = P.Rank()(arr)
+        ndim = rank_(arr)
         if ndim == 0:
-            return P.Reshape()(arr, (1, 1, 1))
+            return reshape_(arr, (1, 1, 1))
         if ndim == 1:
-            return P.Reshape()(arr, (1, P.Size()(arr), 1))
+            return reshape_(arr, (1, P.Size()(arr), 1))
         if ndim == 2:
-            return P.Reshape()(arr, P.Shape()(arr) + (1,))
+            return reshape_(arr, P.Shape()(arr) + (1,))
         return arr
 
     if isinstance(inputs, Tensor):
@@ -7565,7 +7773,7 @@ def vstack(inputs):
             ndim_diff = 2 - len(shape)
             if ndim_diff > 0:
                 shape = [1] * ndim_diff + [i for i in shape]
-            tensor = P.Reshape()(tensor, tuple(shape))
+            tensor = reshape_(tensor, tuple(shape))
         trans_tup += (tensor,)
     if not trans_tup:
         raise ValueError("For 'vstack', need at least one tensor to concatenate.")
@@ -7677,6 +7885,8 @@ def combinations(input, r=2, with_replacement=False):
         raise TypeError(f"For 'combinations', 'x' must be a tensor, but got {type(input)}")
     if input.ndim != 1:
         raise ValueError(f"For 'combinations', the dimension 'x' must be 1, but got {input.ndim}")
+    if not isinstance(r, int):
+        raise TypeError(f"For 'combinations', 'r' must be an integer, but got {type(r)}")
     comb_func = _combinations_with_replacement if with_replacement else _combinations
     ret = comb_func(input, r)
     if ret.size == 0:
@@ -7776,17 +7986,17 @@ def copysign(x, other):
         other = _type_convert(Tensor, other)
     other = _broadcast_to_shape(other, P.Shape()(x))
 
-    if _check_same_type(P.DType()(x), mstype.bool_):
+    if _check_same_type(dtype_(x), mstype.bool_):
         raise TypeError("copysign does not accept dtype bool.")
 
-    if _check_same_type(P.DType()(x), mstype.complex64):
+    if _check_same_type(dtype_(x), mstype.complex64):
         raise TypeError("copysign does not accept dtype complex64.")
-    if _check_same_type(P.DType()(other), mstype.complex64):
+    if _check_same_type(dtype_(other), mstype.complex64):
         raise TypeError("copysign does not accept dtype complex64.")
 
-    if _check_same_type(P.DType()(x), mstype.complex128):
+    if _check_same_type(dtype_(x), mstype.complex128):
         raise TypeError("copysign does not accept dtype complex128.")
-    if _check_same_type(P.DType()(other), mstype.complex128):
+    if _check_same_type(dtype_(other), mstype.complex128):
         raise TypeError("copysign does not accept dtype complex128.")
 
     x_float = (
@@ -7796,7 +8006,7 @@ def copysign(x, other):
     )
     pos_tensor = P.Abs()(x_float)
     less_zero = P.Less()(other, 0)
-    return P.Select()(less_zero, P.Neg()(pos_tensor), pos_tensor)
+    return P.Select()(less_zero, neg_tensor(pos_tensor), pos_tensor)
 
 
 def hann_window(window_length, periodic=True, *, dtype=None):
@@ -7948,14 +8158,12 @@ def logsumexp(input, axis, keep_dims=False):
         >>> print(output.shape)
         (3, 1, 5, 6)
     """
-    _exp = _get_cache_prim(P.Exp)()
     _reduce_sum = _get_cache_prim(P.ReduceSum)(keep_dims)
-    _log = _get_cache_prim(P.Log)()
 
     input_max = ops.ReduceMax(keep_dims=True)(input, axis)
-    input_exp = _exp(input - input_max)
+    input_exp = tensor_exp(input - input_max)
     input_sumexp = _reduce_sum(input_exp, axis)
-    input_logsumexp = _log(input_sumexp)
+    input_logsumexp = log_(input_sumexp)
     if not keep_dims:
         input_max = input_max.squeeze(axis=axis)
     return input_logsumexp + input_max
@@ -8467,50 +8675,53 @@ def norm(A, ord=None, dim=None, keepdim=False, *, dtype=None):
         ``Ascend`` ``GPU`` ``CPU``
 
     Note:
-        - Currently, complex numbers are not supported.
-        - Running on ``Ascend`` platform is not supported when ord is `2` , `-2` or `nuc` .
+        Currently, complex numbers are not supported.
 
     Examples:
         >>> import mindspore as ms
         >>> import mindspore.ops as ops
-        >>> x = ops.arange(-12, 13, dtype=ms.float32)
+        >>> data_range = ops.arange(-13, 13, dtype=ms.float32)
+        >>> # Exclude 0 from original data for 0 is invalid input when `ord` is negative.
+        >>> x = data_range[data_range != 0]
         >>> y = x.reshape(5, 5)
         >>> print(ops.norm(x))
-        36.05551
+        38.327538
         >>> print(ops.norm(x, float('inf')))
-        12.0
+        13.0
         >>> print(ops.norm(x, float('-inf')))
-        0.0
+        1.0
         >>> print(ops.norm(x, 0))
-        24.0
+        25.0
         >>> print(ops.norm(x, 1))
-        156.0
+        169.0
         >>> print(ops.norm(x, -1))
-        0.0
+        0.15915091
         >>> print(ops.norm(x, 2))
-        36.05551
+        38.327538
         >>> print(ops.norm(x, -2))
-        0.0
+        0.5647041
         >>> print(ops.norm(x, 3))
-        23.000631
+        24.309084
         >>> print(ops.norm(x, -3))
-        0.0
+        0.74708974
         >>> print(ops.norm(y))
-        36.05551
+        38.327538
         >>> print(ops.norm(y, 'fro'))
-        36.05551
+        38.327538
         >>> print(ops.norm(y, 'nuc'))
-        42.42641
+        45.56681
         >>> print(ops.norm(y, float('inf')))
-        50.0
+        55.0
         >>> print(ops.norm(y, float('-inf')))
-        6.0
+        9.0
         >>> print(ops.norm(y, 1))
-        32.0
+        35.0
         >>> print(ops.norm(y, -1))
-        30.0
+        33.0
         >>> print(ops.norm(y, 2))
-        35.355343
+        37.57774
+        >>> print(ops.norm(y, -2))
+        1.590545e-07
         >>> m = ms.Tensor([[1., -1., 2.], [-2., 3., -4.]])
         >>> print(ops.norm(m, dim=0))
         [2.236068  3.1622777 4.472136 ]
@@ -8518,6 +8729,10 @@ def norm(A, ord=None, dim=None, keepdim=False, *, dtype=None):
         [2.4494898 5.3851647]
         >>> print(ops.norm(m, ord=1, dim=1))
         [4. 9.]
+        >>> print(ops.norm(m, ord=-2, dim=0))
+        [0.8944272  0.94868326 1.7888544 ]
+        >>> print(ops.norm(m, ord=2, dim=1))
+        [2.4494898 5.3851647]
         >>> n = ops.arange(27, dtype=ms.float32).reshape(3, 3, 3)
         >>> print(ops.norm(n, dim=(1, 2)))
         [14.282857 39.76179  66.45299 ]
@@ -9073,7 +9288,7 @@ def gumbel_softmax(logits, tau=1, hard=False, dim=-1):
     """
     _check_logits_tensor(logits)
     _check_logits_shape(logits)
-    logits_dtype = _get_cache_prim(P.DType)()(logits)
+    logits_dtype = dtype_(logits)
     _check_input_dtype("logits", logits_dtype, [mstype.float16, mstype.float32], "gumbel_softmax")
     _check_attr_dtype("tau", tau, [float], "gumbel_softmax")
     _check_attr_dtype("hard", hard, [bool], "gumbel_softmax")
@@ -9085,14 +9300,13 @@ def gumbel_softmax(logits, tau=1, hard=False, dim=-1):
         _check_int_range(dim, -len(logits.shape),
                          len(logits.shape), 'dim', "gumbel_softmax")
 
-    log_op = _get_cache_prim(P.Log)()
     const_op = _get_cache_prim(P.ScalarToTensor)()
 
-    sample_shape = _get_cache_prim(P.Shape)()(logits)
+    sample_shape = shape_(logits)
     uniform = C.uniform(sample_shape, const_op(
         0.0, mstype.float32), const_op(1.0, mstype.float32))
-    uniform = _get_cache_prim(P.Cast)()(uniform, logits_dtype)
-    gumbel = neg_tensor(log_op(neg_tensor(log_op(uniform))))
+    uniform = cast_(uniform, logits_dtype)
+    gumbel = neg_tensor(log_(neg_tensor(log_(uniform))))
     gumbel = (logits + gumbel) / tau
     y_soft = _get_cache_prim(P.Softmax)(dim)(gumbel)
     if hard:
@@ -9194,13 +9408,13 @@ def stft(x, n_fft, hop_length=None, win_length=None, window=None, center=True,
         k] \exp \left(-j \frac{2 \pi \cdot \omega k}{\text { win_length }}\right)
 
     where :math:`m` is the index of the sliding window, and
-    :math:`ω` is the frequency in range :math:`0 \leq \omega < \text{n\_fft}0≤ω<n_fft`.
+    :math:`ω` is the frequency in range :math:`0 \leq \omega < \text{n\_fft}0≤ω<n\_fft`.
 
     Args:
         x (Tensor): Time sequences of stft, must be either a 1-D time tensor or a 2-D tensor.
         n_fft (int): The size of Fourier transform.
         hop_length (int, optional): The distance between neighboring sliding window
-            frames. Default: ``None``(treated as equal to :math:`floor(n_fft / 4)`).
+            frames. Default: ``None``(treated as equal to :math:`floor(n\_fft / 4)`).
         win_length (int, optional): the size of window frame and STFT filter.
             Default: ``None``(treated as equal to `n_fft`).
         window (Tensor, optional): the optional window function, 1-D tensor of size `win_length`.
@@ -9225,14 +9439,14 @@ def stft(x, n_fft, hop_length=None, win_length=None, window=None, center=True,
             If `return_complex` is False, it returns a real Tensor with shape :math:`(*, N, T, 2)`.
 
             `N` is size of Fourier transform, it depends on parameter `onesided`:
-            - If `onesided` is False, :math:`N = n_fft`.
-            - If `onesided` is True, :math:`N = n_fft // 2 + 1`.
+            - If `onesided` is False, :math:`N = n\_fft`.
+            - If `onesided` is True, :math:`N = n\_fft // 2 + 1`.
 
             `T` is the total number of frames used, calculated by this formula:
-            :math:`T = 1 + (len - n_fft) / hop_length`, where `len` depends on parameter `center`:
-            - If `center` is False, :math:`len = signal_length`.
-            - If `center` is True, :math:`len = signal_length + (n_fft // 2) * 2`.
-            where :math:`signal_length` is the signal length, it equals to :math:`x.shape[-1]`.
+            :math:`T = 1 + (len - n\_fft) / hop\_length`, where `len` depends on parameter `center`:
+            - If `center` is False, :math:`len = signal\_length`.
+            - If `center` is True, :math:`len = signal\_length + (n\_fft // 2) * 2`.
+            where :math:`signal\_length` is the signal length, it equals to :math:`x.shape[-1]`.
 
     Raises:
         TypeError: If `x` is not a 1-D or 2-D tensor.
@@ -9262,8 +9476,7 @@ def stft(x, n_fft, hop_length=None, win_length=None, window=None, center=True,
         window = ops.ones(win_length, mstype.float32)
 
     def _is_complex(x):
-        dtype = P.DType()
-        return dtype(x) in [mstype.complex64, mstype.complex128]
+        return dtype_(x) in [mstype.complex64, mstype.complex128]
 
     if onesided is None:
         onesided = (not _is_complex(x)) and (not _is_complex(window))
@@ -9372,20 +9585,17 @@ def _check_input_2d(input_shape, param_name, func_name):
 @_primexpr
 def _expand(x, ndim):
     """Expand x to ndim from axis, which can be 0 or -1."""
-    rank_op = _get_cache_prim(P.Rank)()
-    expand_dims_op = _get_cache_prim(P.ExpandDims)()
-    while rank_op(x) < ndim:
-        x = expand_dims_op(x, 0)
+    while rank_(x) < ndim:
+        x = expand_dims_(x, 0)
     return x
 
 
 def _broadcast_to(x, shape_cur, shape_to, ndim_to):
     """Broadcasts x from shape_cur to shape_to."""
-    tile_op = _get_cache_prim(P.Tile)()
     tile_size_op = _get_cache_prim(TileSize)()
     size = tile_size_op(shape_cur, shape_to, ndim_to)
     F.stop_gradient(size)
-    return tile_op(x, size)
+    return tile_(x, size)
 
 
 def matmul(input, other):
@@ -9449,17 +9659,13 @@ def matmul(input, other):
     if not (isinstance(input, Tensor) and isinstance(other, Tensor)):
         raise TypeError("For matmul op, inputs must be all tensors.")
 
-    rank_op = _get_cache_prim(P.Rank)()
-    input_rank, other_rank = rank_op(input), rank_op(other)
+    input_rank, other_rank = rank_(input), rank_(other)
     if input_rank == 2 and other_rank == 2:
         _matmul = _get_cache_prim(P.MatMul)(False, False)
         return _matmul(input, other)
 
-    shape_op = _get_cache_prim(P.Shape)()
-    reshape_op = _get_cache_prim(P.Reshape)()
-
-    ndim1_orig, ndim2_orig = rank_op(input), rank_op(other)
-    shape1_orig, shape2_orig = shape_op(input), shape_op(other)
+    ndim1_orig, ndim2_orig = rank_(input), rank_(other)
+    shape1_orig, shape2_orig = shape_(input), shape_(other)
     transpose_b = ndim2_orig == 1
     shape_backbone = _check_matmul_shapes(shape1_orig, shape2_orig, 'matmul')
     # infers the shape of the output
@@ -9471,21 +9677,21 @@ def matmul(input, other):
 
     input = _expand(input, 2)
     other = _expand(other, 2)
-    if rank_op(other) == 2:
-        if rank_op(input) > 2:
-            input = reshape_op(input, (-1, shape1_orig[-1]))
+    if rank_(other) == 2:
+        if rank_(input) > 2:
+            input = reshape_(input, (-1, shape1_orig[-1]))
         res = _matmul(input, other)
     else:
         # broadcasts input.shape[:-2] with other.shape[:-2]
         ndim_aligned = _max(ndim1_orig, ndim2_orig)
         input = _expand(input, ndim_aligned)
         other = _expand(other, ndim_aligned)
-        shape1_aligned, shape2_aligned = shape_op(input), shape_op(other)
+        shape1_aligned, shape2_aligned = shape_(input), shape_(other)
         input = _broadcast_to(input, shape1_aligned[:-2], shape_backbone, ndim_aligned)
         other = _broadcast_to(other, shape2_aligned[:-2], shape_backbone, ndim_aligned)
         res = _batch_matmul(input, other)
 
-    return reshape_op(res, shape_out)
+    return reshape_(res, shape_out)
 
 
 def inner(input, other):
@@ -9605,8 +9811,7 @@ def bmm(input_x, mat2):
     if not (isinstance(input_x, Tensor) and isinstance(mat2, Tensor)):
         raise TypeError("For bmm op, inputs input_x and mat2 must be all tensors.")
 
-    bmm_op = _get_cache_prim(P.BatchMatMul)()
-    return bmm_op(input_x, mat2)
+    return batch_matmul_(input_x, mat2)
 
 
 def quantile(input, q, axis=None, keepdims=False):
@@ -9770,15 +9975,14 @@ def baddbmm(input, batch1, batch2, beta=1, alpha=1):
           [5. 5. 5.]
           [5. 5. 5.]]]
     """
-    dtypeop = _get_cache_prim(P.DType)()
     bmmop = _get_cache_prim(P.BatchMatMul)(False, False)
     if not (isinstance(input, Tensor) and isinstance(batch1, Tensor) and isinstance(batch2, Tensor)):
         raise TypeError("For Baddbmm, inputs must be all tensors.")
     if len(batch1.shape) != 3 or len(batch2.shape) != 3:
         raise ValueError("For batch1 and batch2 must be 3-D tensors each containing the same number of matrices, "
                          f"but got length of batch1:'{len(batch1.shape)}', length of batch2:'{len(batch2.shape)}'.")
-    input_dtype = dtypeop(input)
-    if not (input_dtype == dtypeop(batch1) and input_dtype == dtypeop(batch2)):
+    input_dtype = dtype_(input)
+    if not (input_dtype == dtype_(batch1) and input_dtype == dtype_(batch2)):
         raise TypeError("For Baddbmm, the inputs should be the same dtype.")
     if input_dtype in (mstype.float16, mstype.float32, mstype.float64):
         if not (isinstance(alpha, (int, float)) and isinstance(beta, (int, float))):
@@ -9826,10 +10030,7 @@ def log2(input):
         >>> print(output)
         [1. 2. 3.]
     """
-
-    dtype_op = _get_cache_prim(P.DType)()
-
-    x_dtype = dtype_op(input)
+    x_dtype = dtype_(input)
     denominator = log_(_make_tensor(2, x_dtype))
     frac_log = log_(input)
     output = frac_log / denominator
@@ -10045,10 +10246,7 @@ def log10(input):
         >>> print(output)
         [0.301 0.602 1.   ]
     """
-
-    dtype_op = P.DType()
-
-    x_dtype = dtype_op(input)
+    x_dtype = dtype_(input)
     denominator = log_(_make_tensor(10, x_dtype))
     frac_log = log_(input)
     output = frac_log / denominator
@@ -10083,8 +10281,7 @@ def log1p(input):
         >>> print(output)
         [0.6931472 1.0986123 1.609438 ]
     """
-    _log1p = _get_cache_prim(P.Log1p)()
-    return _log1p(input)
+    return log1p_(input)
 
 
 def kron(input, other):
@@ -10235,7 +10432,7 @@ def all(input, axis=None, keep_dims=False):
     if axis is None:
         axis = ()
     if input.dtype != mstype.bool_:
-        input = _get_cache_prim(P.Cast)()(input, mstype.bool_)
+        input = cast_(input, mstype.bool_)
     return _get_cache_prim(P.ReduceAll)(keep_dims)(input, axis)
 
 
@@ -10294,7 +10491,7 @@ def any(input, axis=None, keep_dims=False):
     if axis is None:
         axis = ()
     if input.dtype != mstype.bool_:
-        input = _get_cache_prim(P.Cast)()(input, mstype.bool_)
+        input = cast_(input, mstype.bool_)
     return _get_cache_prim(P.ReduceAny)(keep_dims)(input, axis)
 
 
@@ -10369,7 +10566,7 @@ def accumulate_n(x):
         ValueError: If there is an input element with a different shape.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``GPU``
 
     Examples:
         >>> import mindspore
@@ -10381,8 +10578,6 @@ def accumulate_n(x):
         >>> print(output)
         [10. 14. 18.]
     """
-
-    accumulate_ = _get_cache_prim(P.AccumulateNV2)()
     return accumulate_(x)
 
 
@@ -10405,7 +10600,7 @@ def iou(anchor_boxes, gt_boxes, mode='iou'):
     Args:
         anchor_boxes (Tensor): Anchor boxes, tensor of shape :math:`(N, 4)` . "N" indicates the number of anchor boxes,
             and the value "4" refers to "x0", "y0", "x1", and "y1".
-            Data type must be either float16， float32 or float64.
+            Data type must be either float16,  float32 or float64.
         gt_boxes (Tensor): Ground truth boxes, tensor of shape :math:`(M, 4)` . "M" indicates the number of ground
             truth boxes, and the value "4" refers to "x0", "y0", "x1", and "y1".
             Data type must be either float16, float32 or float64.
@@ -10816,7 +11011,7 @@ def conj(input):
     """
     if not isinstance(input, (Tensor, Tensor_)):
         raise TypeError("For conj op, input must be Tensor.")
-    return _get_cache_prim(P.Conj)()(input)
+    return conj_(input)
 
 
 def cross(input, other, dim=None):
@@ -10879,7 +11074,7 @@ def _einsum_convert_num_to_char(num):
     # pylint: disable=chained-comparison
     if num >= 26 and num < 52:
         return chr(num - 26 + ord('a'))
-    raise ValueError(f"For Einsum, the number in sublist should be in range [0， 52), but got {num}")
+    raise ValueError(f"For Einsum, the number in sublist should be in range [0, 52), but got {num}")
 
 
 def einsum(equation, *operands):
@@ -11000,7 +11195,10 @@ def erfinv(input):
     where :math:`x` is the `input`.
 
     Args:
-        input (Tensor): The input tensor to compute with, with data type float16, float32 or float64.
+        input (Tensor): The input tensor. Supported dtypes:
+
+            - Ascend: float16, float32.
+            - GPU/CPU: float16, float32, float64.
 
     Returns:
         Tensor, has the same shape and dtype as `input`.
@@ -11020,7 +11218,7 @@ def erfinv(input):
         >>> print(output)
         [ 0.          0.47695306 -1.1630805 ]
     """
-    return _get_cache_prim(P.Erfinv)()(input)
+    return erfinv_(input)
 
 
 def less_equal(input, other):
@@ -11042,8 +11240,8 @@ def less_equal(input, other):
     Args:
         input (Union[Tensor, Number, bool]): The first input is a Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_.
         other (Union[Tensor, Number, bool]): The second input, when the first input is a Tensor,
             the second input should be a 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\_.
@@ -11067,7 +11265,7 @@ def less_equal(input, other):
         >>> print(output)
         [ True False  True]
     """
-    return _get_cache_prim(P.LessEqual)()(input, other)
+    return tensor_le(input, other)
 
 
 def cumprod(input, dim, dtype=None):
@@ -11105,10 +11303,9 @@ def cumprod(input, dim, dtype=None):
         >>> print(output)
         [1. 2. 6.]
     """
-    cumprod_op = _get_cache_prim(P.CumProd)()
-    output = cumprod_op(input, dim)
+    output = cumprod_(input, dim)
     if dtype:
-        output = _get_cache_prim(P.Cast)()(output, dtype)
+        output = cast_(output, dtype)
     return output
 
 
@@ -11119,8 +11316,8 @@ def greater(input, other):
     Args:
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ .
+            `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ .
         other (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\_.
@@ -11141,8 +11338,7 @@ def greater(input, other):
         >>> print(output)
         [False True False]
     """
-    greater_op = _get_cache_prim(P.Greater)()
-    return greater_op(input, other)
+    return tensor_gt(input, other)
 
 
 def greater_equal(input, other):
@@ -11152,8 +11348,8 @@ def greater_equal(input, other):
     Args:
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.html#mindspore.dtype>`_ .
+            `number <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.html#mindspore.dtype>`_ .
         other (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\_.
@@ -11174,8 +11370,7 @@ def greater_equal(input, other):
         >>> print(output)
         [True True False]
     """
-    greater_equal_op = _get_cache_prim(P.GreaterEqual)()
-    return greater_equal_op(input, other)
+    return tensor_ge(input, other)
 
 
 def igamma(input, other):
@@ -11313,8 +11508,7 @@ def lgamma(input):
         >>> print(output)
         0.045437694
     """
-    lgamma_op = _get_cache_prim(P.Lgamma)()
-    return lgamma_op(input)
+    return lgamma_(input)
 
 
 def digamma(input):
@@ -11348,8 +11542,7 @@ def digamma(input):
         >>> print(output)
         [ 0.0365 -1.964   2.14  ]
     """
-    digamma_op = _get_cache_prim(P.Digamma)()
-    return digamma_op(input)
+    return digamma_(input)
 
 
 def polygamma(n, input):
@@ -11388,8 +11581,7 @@ def polygamma(n, input):
         >>> print(output)
         [ 0.37446456 15.49884838]
     """
-    polygamma_op = _get_cache_prim(P.Polygamma)()
-    return polygamma_op(n, input)
+    return poly_gamma_(n, input)
 
 
 def isinf(input):
@@ -11430,20 +11622,19 @@ def isinf(input):
         >>> print(output)
         False
     """
-    isinf_op = _get_cache_prim(P.IsInf)()
-    return isinf_op(input)
+    return isinf_(input)
 
 
 def _is_sign_inf(x, fn):
     """Tests element-wise for infinity with sign."""
     shape = x.shape
-    zeros_tensor = _get_cache_prim(P.Zeros)()(shape, mstype.float32)
-    ones_tensor = _get_cache_prim(P.Ones)()(shape, mstype.float32)
-    is_inf = _get_cache_prim(P.IsInf)()(x)
+    zeros_tensor = zeros_(shape, mstype.float32)
+    ones_tensor = ones_(shape, mstype.float32)
+    is_inf = isinf_(x)
     is_sign = fn(x, zeros_tensor)
     res = ops.select(is_inf, ones_tensor, zeros_tensor)
     res = ops.select(is_sign, res, zeros_tensor)
-    return _get_cache_prim(P.Cast)()(res, mstype.bool_)
+    return cast_(res, mstype.bool_)
 
 
 def isposinf(input):
@@ -11554,8 +11745,7 @@ def logical_xor(input, other):
         input = input.astype(mstype.bool_)
     if isinstance(other, Tensor) and other.dtype != mstype.bool_:
         other = other.astype(mstype.bool_)
-    logical_xor_op = _get_cache_prim(P.LogicalXor)()
-    return logical_xor_op(input, other)
+    return logical_xor_(input, other)
 
 
 def imag(input):
@@ -11584,7 +11774,7 @@ def imag(input):
         >>> print(output)
         0.4
     """
-    return _get_cache_prim(P.Imag)()(input)
+    return imag_(input)
 
 
 @_primexpr
@@ -11651,7 +11841,7 @@ def nansum(input, axis=None, keepdims=False, *, dtype=None):
         axis = ()
     if input.dtype == mstype.bool_:
         input = input.astype(mstype.int64)
-    is_nan = _get_cache_prim(P.IsNan)()(input)
+    is_nan = isnan_(input)
     input = ops.masked_fill(input, is_nan, 0)
     input = _get_cache_prim(P.ReduceSum)(keepdims)(input, axis)
     if dtype is not None and input.dtype != dtype:
@@ -11709,8 +11899,8 @@ def diag_embed(input, offset=0, dim1=-2, dim2=-1):
     zeros = ops.Zeros()
     if not isinstance(input, (Tensor, Tensor_)):
         raise TypeError("For 'diag_embed', 'input' must be Tensor.")
-    dtypeop = P.DType()
-    input_dtype = dtypeop(input)
+
+    input_dtype = dtype_(input)
     if not (input_dtype in (mstype.int8, mstype.int16, mstype.int32, mstype.int64, mstype.uint8, mstype.uint16,
                             mstype.uint32, mstype.uint64, mstype.float16, mstype.float32, mstype.float64)):
         raise TypeError("For 'diag_embed', the dtype of 'input' must be int8, int16, int32, int64, "
@@ -11818,16 +12008,17 @@ def sum(input, dim=None, keepdim=False, *, dtype=None):
          [54.]]]
     """
     if not isinstance(input, Tensor):
-        raise TypeError("For 'sum', 'input' must be Tensor.")
-    if dim is not None:
-        if not isinstance(dim, (int, tuple, list)):
-            raise TypeError("For 'sum', 'dim' must be int, tuple(int), list(int) or None.")
+        raise TypeError(f"For 'sum', 'input' must be Tensor, but got{type(input)}")
+    if dim is not None and not isinstance(dim, (int, tuple, list)):
+        raise TypeError(f"For 'sum', 'dim' must be int, tuple(int), list(int) or None, but got {type(dim)}")
     if not isinstance(keepdim, bool):
-        raise TypeError("For 'sum', 'keepdim' must be bool.")
+        raise TypeError(f"For 'sum', 'keepdim' must be bool, but got {type(keepdim)}")
 
+    if input.dtype == mstype.bool_:
+        input = input.astype(mstype.int64)
     if dtype is not None:
         input = input.astype(dtype)
-    reduce_sum = P.ReduceSum(keep_dims=keepdim)
+    reduce_sum = _get_cache_prim(P.ReduceSum)(keep_dims=keepdim)
     if dim is not None:
         out = reduce_sum(input, dim)
     else:
@@ -11858,9 +12049,7 @@ def tanhshrink(input):
 
     if input.dtype in mstype.int_type + mstype.uint_type:
         input = input.astype(mstype.float64)
-
-    tanh_op = _get_cache_prim(P.Tanh)()
-    return input - tanh_op(input)
+    return input - tanh_(input)
 
 
 def zeta(input, other):
@@ -11905,17 +12094,17 @@ def zeta(input, other):
         if not isinstance(other, Tensor):
             raise TypeError(f"For 'zeta', at least one of the inputs should be Tensor.")
         _dtype = other.dtype
-        input = _get_cache_prim(P.Cast)()(input, _dtype)
+        input = cast_(input, _dtype)
     if isinstance(other, (int, float)):
         if not isinstance(input, Tensor):
             raise TypeError(f"For 'zeta', at least one of the inputs should be Tensor.")
         _dtype = input.dtype
-        other = _get_cache_prim(P.Cast)()(other, _dtype)
+        other = cast_(other, _dtype)
     if input.size < other.size:
         input = _get_cache_prim(P.BroadcastTo)(other.shape)(input)
     elif input.size > other.size:
         other = _get_cache_prim(P.BroadcastTo)(input.shape)(other)
-    output = _get_cache_prim(P.Zeta)()(input, other)
+    output = zeta_(input, other)
     return output
 
 
@@ -12079,7 +12268,7 @@ def _permute_input(input, input_dim, ret_dim):
     for value in ret_dim:
         is_transformed_dim[value] = True
 
-   # partition dim_permute
+    # partition dim_permute
     dim_permute_a, dim_permute_b = [], []
     for i in range(len(dim_permute)):
         value = dim_permute[i]
@@ -12111,7 +12300,7 @@ def _permute_input(input, input_dim, ret_dim):
     dim_permute = dim_permute_a + dim_permute_b
 
     # permute
-    input = P.Transpose()(input, tuple(dim_permute))
+    input = transpose_(input, tuple(dim_permute))
 
     return input, dim_permute
 
@@ -12129,7 +12318,7 @@ def _reshape_input(input, signal_ndim, batch_dims):
         i += 1
         if j >= len(batched_sizes):
             break
-    input = P.Reshape()(input, tuple(batched_sizes))
+    input = reshape_(input, tuple(batched_sizes))
     return input
 
 
@@ -12137,8 +12326,8 @@ def _check_fftwithsize_input(input, s, dim, norm, fft_func_name):  # pylint: dis
     """Check the input of fftwithsize"""
     if not isinstance(input, (Tensor, Tensor_)):
         raise TypeError("For '{fft_func_name}', 'input' must be Tensor.")
-    dtypeop = P.DType()
-    input_dtype = dtypeop(input)
+
+    input_dtype = dtype_(input)
     if fft_func_name in ('FFTN', 'IFFTN'):
         if not input_dtype in (mstype.complex64, mstype.complex128):
             raise TypeError("For '{fft_func_name}', the dtype of 'input' must be complex64, complex128, "
@@ -12201,7 +12390,7 @@ def _handle_fftwithsize_output(out, input_dim, batch_dims, dim_permute, out_size
 
     type_size = np.dtype(mstype.dtype_to_nptype(out.dtype)).itemsize
     if out.shape != out_sizes or out.strides != out_strides:
-        out = as_strided(out, out_sizes, [int(i/type_size) for i in out_strides])
+        out = as_strided(out, out_sizes, [int(i / type_size) for i in out_strides])
     return out
 
 
@@ -12246,8 +12435,8 @@ def fft(input, n=None, dim=-1, norm=None):  # pylint: disable=redefined-outer-na
     """
     if not isinstance(input, (Tensor, Tensor_)):
         raise TypeError("For 'FFT', 'input' must be Tensor.")
-    dtypeop = P.DType()
-    input_dtype = dtypeop(input)
+
+    input_dtype = dtype_(input)
     if not input_dtype in (mstype.complex64, mstype.complex128):
         raise TypeError("For 'FFT', the dtype of 'input' must be complex64, complex128, "
                         f"but got '{input_dtype}'.")
@@ -12417,8 +12606,8 @@ def ifft(input, n=None, dim=-1, norm=None):  # pylint: disable=redefined-outer-n
     """
     if not isinstance(input, (Tensor, Tensor_)):
         raise TypeError("For 'IFFT', 'input' must be Tensor.")
-    dtypeop = P.DType()
-    input_dtype = dtypeop(input)
+
+    input_dtype = dtype_(input)
     if not input_dtype in (mstype.complex64, mstype.complex128):
         raise TypeError("For 'IFFT', the dtype of 'input' must be complex64, complex128, "
                         f"but got '{input_dtype}'.")
@@ -12554,6 +12743,7 @@ def _check_validate_axis(axis, name):
         if isinstance(axis, (tuple, list)):
             for idx, item in enumerate(axis):
                 validator.check_value_type("axis[%d]" % idx, item, [int], name)
+
     _check(axis)
     axis = validator.check_value_type('axis', axis, [int, tuple, list], name)
     return axis
@@ -12697,7 +12887,6 @@ def _axes_int_check(x1_shape, x2_shape, axes, prim_name=None):
             raise ValueError(f"{msg_prefix} 'axes' cannot be greater than the length of 'x1_shape' and 'x2_shape', "
                              f"but got 'axes': {axes}, 'x1_shape': {x1_shape}, 'x2_shape': {x2_shape}.")
 
-
     if isinstance(axes, int):
         _check_lt_zero(axes)
         if axes == 0:
@@ -12831,7 +13020,6 @@ def tensor_dot(x1, x2, axes):
          [2. 2. 2]
          [2. 2. 2]]
     """
-    transpose_op = _get_cache_prim(P.Transpose)()
     matmul_op = _get_cache_prim(P.MatMul)(False, False)
     # input validity checks
     x1_shape = shape_(x1)
@@ -12844,8 +13032,8 @@ def tensor_dot(x1, x2, axes):
     x2_reshape_fwd, x2_transpose_fwd, x2_ret = _calc_new_shape(x2_shape, axes, 1)
     output_shape = x1_ret + x2_ret  # combine free axes from both inputs
     # run tensor_dot op
-    x1_transposed = transpose_op(x1, x1_transpose_fwd)
-    x2_transposed = transpose_op(x2, x2_transpose_fwd)
+    x1_transposed = transpose_(x1, x1_transpose_fwd)
+    x2_transposed = transpose_(x2, x2_transpose_fwd)
     x1_reshaped = reshape_(x1_transposed, x1_reshape_fwd)
     x2_reshaped = reshape_(x2_transposed, x2_reshape_fwd)
     mul_result = matmul_op(x1_reshaped, x2_reshaped)
@@ -12907,7 +13095,7 @@ def vecdot(x, y, *, axis=-1):
     ndim = x.ndim if x.ndim > y.ndim else y.ndim
     if (axis < -ndim) or (axis >= ndim):
         raise ValueError(f"For vecdot, the dim is out of range.")
-    if (x.dtype == mstype.complex64) or (x.dtype == mstype.complex128):
+    if x.dtype in mstype.complex_type:
         x = x.conj()
     result = x * y
     result = result.sum(axis=axis)
@@ -13013,7 +13201,6 @@ def dot(input, other):
         >>> print(output.shape)
         (3, 2, 2, 1, 2)
     """
-    transpose_op = _get_cache_prim(P.Transpose)()
     matmul_op = _get_cache_prim(P.MatMul)(False, False)
     input_shape = shape_(input)
     other_shape = shape_(other)
@@ -13024,7 +13211,7 @@ def dot(input, other):
 
     if len(input_shape) > 2 or len(other_shape) > 2:
         other_shape_transpose = _get_transpose_shape(other_shape)
-        other_transpose = transpose_op(other, other_shape_transpose)
+        other_transpose = transpose_(other, other_shape_transpose)
         input_reshape = reshape_(input, (-1, input_shape[-1]))
         other_reshape = reshape_(other_transpose, (other_shape[-2], -1))
         mul_result = matmul_op(input_reshape, other_reshape)
@@ -13039,11 +13226,13 @@ def _get_batch_size(x1_shape, x2_shape, prim_name=None):
     """
     Get batch sizes from two inputs
     """
+
     def _check():
         msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
         if len(x1_shape) < 2 or len(x2_shape) < 2:
             raise ValueError(f"{msg_prefix} inputs x1, x2 should have 'dimension >= 2', "
                              f"but got 'len(x1_shape)': ({len(x1_shape)}) and 'len(x2_shape)': ({len(x2_shape)}).")
+
     _check()
     return x1_shape[0], x2_shape[0]
 
@@ -13235,8 +13424,6 @@ def batch_dot(x1, x2, axes=None):
         (2, 2, 5, 5)
 
     """
-    transpose_op = _get_cache_prim(P.Transpose)()
-    batch_matmul_op = _get_cache_prim(P.BatchMatMul)()
     squeeze_one_op = _get_cache_prim(P.Squeeze)(1)
     squeeze_minus_one_op = _get_cache_prim(P.Squeeze)(-1)
     # input validity checks
@@ -13266,13 +13453,13 @@ def batch_dot(x1, x2, axes=None):
     x2_reshape_fwd, x2_transpose_fwd, x2_ret = _calc_new_shape_batchdot(x2_shape, axes, 1)
     output_shape = _get_output_shape(x1_batch_size, x1_ret, x2_ret)
 
-    x1_transposed = transpose_op(x1, x1_transpose_fwd)
-    x2_transposed = transpose_op(x2, x2_transpose_fwd)
+    x1_transposed = transpose_(x1, x1_transpose_fwd)
+    x2_transposed = transpose_(x2, x2_transpose_fwd)
     x1_reshaped = reshape_(x1_transposed, x1_reshape_fwd)
     x2_reshaped = reshape_(x2_transposed, x2_reshape_fwd)
 
     # Batch matmal op part
-    mul_result = batch_matmul_op(x1_reshaped, x2_reshaped)
+    mul_result = batch_matmul_(x1_reshaped, x2_reshaped)
 
     final_result = reshape_(mul_result, output_shape)
 
@@ -13361,6 +13548,7 @@ __all__ = [
     'exp',
     'tensor_expm1',
     'expm1',
+    'eq',
     'equal',
     'not_equal',
     'ne',
@@ -13559,5 +13747,6 @@ __all__ = [
     'vecdot',
     'dot',
     'batch_dot',
+    'eps'
 ]
 __all__.sort()