mindspore 2.4.10__cp310-cp310-manylinux1_x86_64.whl → 2.5.0__cp310-cp310-manylinux1_x86_64.whl

mindspore/ops/function/math_func.py

@@ -34,28 +34,31 @@ from mindspore.ops.primitive import constexpr, _primexpr
 from mindspore.ops.operations._inner_ops import TileSize
 from mindspore.ops.auto_generate import Cummin, BatchMatMul, BernoulliExt, lin_space_ext_op, BitwiseAndScalar,\
     BitwiseAndTensor, BitwiseOrScalar, BitwiseOrTensor, BitwiseXorScalar, BitwiseXorTensor, RemainderTensorTensor,\
-    RemainderTensorScalar, RemainderScalarTensor
+    RemainderTensorScalar, RemainderScalarTensor, std_mean_op, var_mean_op, InplaceErfinv
 from mindspore.ops import auto_generate
 from mindspore.ops.operations.math_ops import STFT
 from mindspore.ops.operations.math_ops import LuUnpack
 from mindspore.ops.auto_generate.pyboost_inner_prim import roll_impl, cross_impl
+from mindspore.ops.auto_generate.pyboost_inner_prim import reduce_max_impl, reduce_min_impl
 from mindspore.ops.operations.math_ops import Ormqr
 from mindspore.ops.operations.math_ops import DivMod
 from mindspore.ops.operations.array_ops import MatrixSetDiagV3, Transpose
-from mindspore.ops.auto_generate import (minimum, maximum, mul, sin, sinc, sinh, cummax, real, conj, add, sub, cos,
-                                         cosh, nan_to_num, norm_op, lp_norm_v2_op,
+from mindspore.ops.auto_generate import (minimum, maximum, mul, muls, sin, sinc, sinh, cummax, real, conj, add, sub, cos,
+                                         cosh, nan_to_num, norm_op, lp_norm_v2_op, linalg_vector_norm_op, std_op,
                                          matrix_exp, sqrt, rsqrt, square, trace, nextafter, abs, acos, acosh, angle,
                                          asin, asinh, atan, atan2, atanh, ceil, equal, erf, erfc, erfinv, exp, expm1,
                                          floor, floor_divide, floor_mod, gcd, greater, greater_equal, less, less_equal,
-                                         log, log1p, neg, not_equal, pow, round_op, isfinite, argmax_ext, mean_ext_op,
+                                         log, log1p, neg, not_equal, round_op, isfinite, argmax_ext, mean_ext_op,
                                          sum_ext_op, prod_ext_op, all, matrix_inverse_ext, atan2_ext, sign, acos_ext,
                                          acosh_ext, asin_ext, asinh_ext, atan_ext, tan, median_ext_op, median_dim_op,
-                                         xlogy_op, xlogy_scalar_other_op, xlogy_scalar_self_op, trunc, histc_ext)
-
+                                         xlogy_op, xlogy_scalar_other_op, xlogy_scalar_self_op, trunc, histc_ext,
+                                         bincount_ext, rotated_iou_op, cat, narrow, var_op, pow, pow_scalar_tensor_op,
+                                         frac_ext, pow_tensor_scalar_op, not_equal_op, isinf, addmv_op, cdist,
+                                         addbmm_op, addmm_op, grouped_matmul_v2, transpose_ext, grouped_matmul_v4)
 
 
 from mindspore.ops.auto_generate.gen_ops_def import add_ext, sub_ext, bmm_ext
-from mindspore.ops.auto_generate import tanh
+from mindspore.ops.auto_generate import tanh, tanh_
 from mindspore.nn import layer
 from mindspore._checkparam import check_is_number
 from mindspore import _checkparam as validator
@@ -143,7 +146,8 @@ transpose_ = P.Transpose()
 xdivy_ = P.Xdivy()
 tensor_div_ = P.Div()
 tensor_divmod_ = DivMod()
-generator_step_ = Tensor(10, mstype.int64)
+generator_step_ = Tensor(12, mstype.int64)
+tuple_to_tensor_ = TupleToTensor()
 
 #####################################
 # Private Operation Functions.
@@ -186,7 +190,8 @@ dtype_ = P.DType()
 eps_ = P.Eps()
 erf_ = P.Erf()
 erfc_ = P.Erfc()
-erfinv_ = P.Erfinv()
+erfinv_ext_ = P.Erfinv()
+inplace_erfinv_ = InplaceErfinv()
 exp2_ = P.Pow()
 expand_dims_ = P.ExpandDims()
 fill_v2_ = P.FillV2()
@@ -197,7 +202,6 @@ igammac_ = Igammac()
 imag_ = P.Imag()
 inv_ = P.math_ops.Inv()
 invert_ = P.Invert()
-isinf_ = P.IsInf()
 isnan_ = P.IsNan()
 lcm_ = Lcm()
 lerp_ = P.Lerp()
@@ -230,7 +234,6 @@ size_ = P.Size()
 scalar_to_tensor_ = P.ScalarToTensor()
 shape_ = P.Shape()
 sparse_segment_mean_ = SparseSegmentMean()
-tanh_ = P.Tanh()
 tensor_round_ = P.Round()
 tile_ = P.Tile()
 tile_size_ = TileSize()
@@ -446,10 +449,9 @@ def bincount(input, weights=None, minlength=0):
     if weights is not None:
         if input.shape != weights.shape:
             raise ValueError('for bincount `input` and `weights` must have the same length')
-        idx_mapping *= weights
+        idx_mapping = weights * idx_mapping
     return reduce_sum_(idx_mapping.astype(mstype.float32), 1).ravel()
 
-
 def bucketize(input, boundaries, *, right=False):
     r"""
     Bucketizes `input` based on `boundaries`. If `right` is ``False``, the left boundary is closed. For each element x
@@ -824,7 +826,8 @@ def float_power(input, exponent):
 
     Raises:
         TypeError: If neither `input` nor `exponent` is a Tensor.
-        TypeError: If the data type of `input` or `exponent` is not in Tensor and Number.
+        TypeError: If the data type of `input` is not Tensor or Number.
+        TypeError: If the data type of `exponent` is not Tensor or Number.
 
     Supported Platforms:
         ``GPU`` ``CPU``
@@ -857,6 +860,81 @@ def float_power(input, exponent):
     return pow(input, exponent)
 
 
+def float_power_ext(input, exponent):
+    """
+    Computes `input` to the power of `exponent` element-wise in double precision, and always
+    returns a mindspore.float64 tensor.
+
+    .. math::
+
+        out_{i} = input_{i} ^ {exponent_{i}}
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Note:
+        Unlike `ops.pow`, this function always uses double precision for calculations, while
+        the precision of `ops.pow` depends on type promotion.
+        Currently, this function does not support complex number calculations.
+        Since float64 calculations are significantly slower on ascend devices compared to other data
+        types, it is strongly recommended to use this function only in scenarios where double precision
+        is required and performance is not a priority. Otherwise, using `ops.pow` is a better choice.
+
+    Args:
+        input (Union[Tensor, Number]): The first input is a tensor or a number.
+        exponent (Union[Tensor, Number]): The second input, if the first input is Tensor,
+            the second input can be Number or Tensor. Otherwise, it must be a Tensor.
+
+    Returns:
+        Tensor, the shape is the same as the one after broadcasting, the return value type
+        is mindspore.float64.
+
+    Raises:
+        TypeError: If neither `input` nor `exponent` is a Tensor.
+        TypeError: If the data type of `input` or `exponent` is neither a tensor nor a number,
+            or it contains complex numbers.
+        ValueError: If `input` and `exponent` have different shapes and cannot be broadcasted
+            to each other.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor([1, 2, 3])
+        >>> ops.function.math_func.float_power_ext(input, 2)
+        Tensor(shape=[3], dtype=Float64, value= [ 1.00000000e+00,  4.00000000e+00,  9.00000000e+00])
+        >>>
+        >>> exp = Tensor([2, -3, -4])
+        >>> ops.function.math_func.float_power_ext(input, exp)
+        Tensor(shape=[3], dtype=Float64, value= [ 1.00000000e+00,  1.25000000e-01,  1.23456790e-02])
+    """
+    if not (isinstance(input, Tensor) or isinstance(exponent, Tensor)):
+        raise TypeError("At least one of the types of inputs must be tensor, " +
+                        f"but the type of 'input' got is {type(input)}, " +
+                        f"and the type of 'exponent' is {type(exponent)}.")
+    if (not isinstance(input, (Tensor, int, float, bool))) or \
+            (isinstance(input, Tensor) and is_complex(input)):
+        raise TypeError("The type of 'input' must be Tensor or Number (excluding complex), " +
+                        f"but got {type(input)}.")
+    if (not isinstance(exponent, (Tensor, int, float, bool))) or \
+            (isinstance(exponent, Tensor) and is_complex(exponent)):
+        raise TypeError("The type of 'exponent' must be Tensor or Number (excluding complex), " +
+                        f"but got {type(exponent)}.")
+
+    op = pow
+    if isinstance(input, Tensor) and isinstance(exponent, numbers.Number):
+        op = pow_tensor_scalar_op
+    if isinstance(input, numbers.Number) and isinstance(exponent, Tensor):
+        op = pow_scalar_tensor_op
+
+    if isinstance(input, Tensor) and input.dtype != mstype.float64:
+        input = cast_(input, mstype.float64)
+    if isinstance(exponent, Tensor) and exponent.dtype != mstype.float64:
+        exponent = cast_(exponent, mstype.float64)
+    return op(input, exponent)
+
+
 def floor_div(x, y):
     """
     Alias for :func:`mindspore.ops.floor_divide` .
@@ -913,7 +991,7 @@ def logdet(input):
     Calculates log determinant of one or a batch of square matrices.
 
     Args:
-        input (Tensor): Tensor of shape :math:`(*, n, n)` where :math:`*` means zero or more batch dimensions.
+        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
@@ -939,7 +1017,8 @@ def logdet(input):
 
 def i0(input):
     r"""
-    Alias for :func:`mindspore.ops.bessel_i0` .
+    For details, please refer to :func:`mindspore.ops.bessel_i0`.
+    The parameter `input` of the current interface is the same as the parameter `x` of the reference interface.
 
     Supported Platforms:
         ``GPU`` ``CPU``
@@ -1044,8 +1123,8 @@ def inplace_index_add(var, indices, updates, axis):  # pylint: disable=redefined
     Adds Tensor `updates` to specified axis and indices of Tensor `var` element-wise.
 
     Args:
-        var (Parameter): The input Parameter to add to, with data type uint8, int8, int16, int32,
-            float16, float32, float64.
+        var (Union[Parameter, Tensor]): The input Parameter or Tensor to add to, with data type uint8, int8, int16,
+            int32, float16, float32, float64.
         indices (Tensor): The indies along `axis` to perform the addition. A 1D Tensor
             of shape :math:`(updates.shape[axis],)`, every value of it
             should be in range :math:`[0, var.shape[axis])` with data type int32.
@@ -1057,7 +1136,6 @@ def inplace_index_add(var, indices, updates, axis):  # pylint: disable=redefined
         Tensor, updated result, has the same shape and dtype as `var`.
 
     Raises:
-        TypeError: If `var` is not a Parameter.
         TypeError: If neither `indices` nor `updates` is a Tensor.
         ValueError: If `axis` is out of valid range.
         ValueError: If `var` rank is not the same as `updates` rank.
@@ -1163,7 +1241,7 @@ def logical_not(input):
 
 
 def logical_or(input, other):
-    """
+    r"""
     Computes the "logical OR" of two tensors element-wise.
 
     Inputs of `input` and `other` comply with the implicit type conversion rules to make the data types consistent.
@@ -1175,7 +1253,7 @@ def logical_or(input, other):
 
     .. math::
 
-        out_{i} = input_{i} \\vee other_{i}
+        out_{i} = input_{i} \vee other_{i}
 
     Note:
         logical_or supports broadcasting.
@@ -1639,7 +1717,7 @@ def xlogy_ext(input, other):
 
     .. math::
 
-        out_i = input_{i}\log{other_{i}}
+        out_i = input_{i} * \log({other_{i}})
 
     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.
@@ -1813,40 +1891,92 @@ def polar(abs, angle):  # pylint: disable=redefined-outer-name
         y_{i} =  abs_{i} * \cos(angle_{i}) + abs_{i} * \sin(angle_{i}) * j
 
     Args:
-        abs (Tensor): Radial distance. The shape of tensor is
-          :math:`(N,*)` where :math:`N` means the batchsize of the input tensor,
-          :math:`*` means, any number of additional dimensions.
-          Must be one of the following types: float32, float64.
-        angle (Tensor):  Polar angle. It has the same shape and dtype as `abs`.
+        abs (Tensor, float): Radial distance. Tensor of any dimension,
+            with dtype required to be float32.
+
+        angle (Tensor, float): Polar angle. It has the same shape and dtype as `abs`.
 
     Returns:
-        Tensor, has the same shape as `abs`.
+        Tensor, with the same shape as `abs` and the dtype is complex64.
 
-        - If the inputs are float32, data type must be complex64.
-        - If the inputs are float64, data type must be complex128.
 
     Raises:
         TypeError: If neither `abs` nor `angle` is a Tensor.
-        TypeError: If the dtype of input is not one of: float32, float64.
+        TypeError: If the dtype of input is not one of: float32.
         TypeError: If the dtypes of `abs` and `angle` are not the same.
         ValueError: If `abs`'s shape is not the same as `angle`.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> abs = Tensor(np.array([1, 2]), mindspore.float64)
-        >>> angle = Tensor(np.array([np.pi / 2, 5 * np.pi / 4]), mindspore.float64)
+        >>> abs = Tensor(np.array([1, 2]), mindspore.float32)
+        >>> angle = Tensor(np.array([np.pi / 2, 5 * np.pi / 4]), mindspore.float32)
         >>> output = ops.polar(abs, angle)
         >>> print(output)
-        [ 6.12323400e-17+1.j         -1.41421356e+00-1.41421356j]
+        [ -4.3711388e-08+1.j         -1.4142137e+00-1.4142134j]
     """
     return polar_(abs, angle)
 
 
+def pow_ext(input, exponent):
+    """
+    Calculates the `exponent` power of each element in `input`.
+
+    When `exponent` is a Tensor, the shapes of `input` and `exponent` must be broadcastable.
+
+    .. math::
+
+        out_{i} = input_{i} ^{ exponent_{i}}
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Union[Tensor, Number]): The first input is a Number or a tensor whose data type is
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+        exponent (Union[Tensor, Number]): The second input is a Number or a tensor whose data type is
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+
+    Returns:
+        Tensor, the shape is the same as the one after broadcasting,
+        and the data type is the one with higher precision or higher digits among the two inputs.
+
+    Raises:
+        TypeError: If types of `input` and `exponent` are bool.
+        TypeError: The `input` is tensor and of type int or bool, while the `exponent` is negative int.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
+        >>> exponent = 3.0
+        >>> output = ops.pow(input, exponent)
+        >>> print(output)
+        [ 1.  8. 64.]
+        >>>
+        >>> input = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
+        >>> exponent = Tensor(np.array([2.0, 4.0, 3.0]), mindspore.float32)
+        >>> output = ops.pow(input, exponent)
+        >>> print(output)
+        [ 1. 16. 64.]
+    """
+    if isinstance(input, Tensor) and isinstance(exponent, numbers.Number):
+        return pow_tensor_scalar_op(input, exponent)
+    if isinstance(input, numbers.Number) and isinstance(exponent, Tensor):
+        return pow_scalar_tensor_op(input, exponent)
+    return pow(input, exponent)
+
+
 def arccos(input):
     """
     Alias for :func:`mindspore.ops.acos` .
@@ -2070,6 +2200,9 @@ def bitwise_xor(input, other):
     If they have different data types, the lower priority data type will be converted to
     the relatively highest priority data type.
 
+    .. warning::
+        This API has poor performance on CPU and it is recommended to run it on the Ascend/GPU.
+
     Args:
         input (Tensor): The first input tensor with shape :math:`(N, *)` where :math:`*` means
             any number of additional dimensions.
@@ -2278,6 +2411,9 @@ def inverse(input):
     """
     Compute the inverse of the input matrix.
 
+    Note:
+        The `input` dtype of complex numbers is not supported.
+
     Args:
         input (Tensor): A matrix to be calculated. Input `input` must be at least two dimensions, and the size of
             the last two dimensions must be the same size. And the matrix must be invertible.
@@ -2701,6 +2837,45 @@ def eps(x):
     return eps_(x)
 
 
+def erfinv_(input):
+    r"""
+    Update the `input` tensor in-place by computing the inverse error function with `input`, which is defined in the
+    range `(-1, 1)` as:
+
+    .. math::
+
+
+        erfinv(erf(input)) = input
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input tensor to compute with.
+
+    Returns:
+
+        Tensor.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `input.dtype` is not one of: bool, int8, int16, int32, int64, uint8, float16, float32, bfloat16.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([0, 0.5, -0.9]), mindspore.float32)
+        >>> output = ops.erfinv_(input)
+        >>> print(output)
+        [ 0.          0.47693613 -1.1630869 ]
+    """
+    return inplace_erfinv_(input)
+
+
 def linspace(start, end, steps):
     r"""
     Returns a Tensor whose value is `steps` evenly spaced in the interval `start` and `end` (including `start` and
@@ -2721,7 +2896,7 @@ def linspace(start, end, steps):
             Must be positive int number or 0D int32/int64 Tensor.
 
     Returns:
-        Tensor, has the same dtype as `start`, and the shape of :math:`(steps)`.
+        Tensor, has the same dtype as `start`, and the shape of :math:`(steps,)`.
 
     Raises:
         TypeError: If `start` or `end` is not a Tensor.
@@ -2780,7 +2955,7 @@ def linspace_ext(start, end, steps, *, dtype=None):
         Tensor, has the shape of :math:`(steps,)`, with dtype specified by `dtype`.
 
     Raises:
-        TypeError: If type of `start` or dtype of `end` is not supported.
+        TypeError: If dtype of `start` or dtype of `end` is not supported.
         ValueError: If `steps` is not positive integer.
 
     Supported Platforms:
@@ -3398,13 +3573,6 @@ def ne(input, other):
     r"""
     Computes the non-equivalence of two tensors element-wise.
 
-    Note:
-        - Inputs of `input` and `other` comply with the implicit type conversion rules to make the data types
-          consistent.
-        - 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.
-        - Broadcasting is supported.
-
     .. math::
 
         out_{i} =\begin{cases}
@@ -3412,6 +3580,13 @@ def ne(input, other):
         & \text{False,   if } input_{i} = other_{i}
         \end{cases}
 
+    Note:
+        - Inputs of `input` and `other` comply with the implicit type conversion rules to make the data types
+          consistent.
+        - 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.
+        - Broadcasting is supported.
+
     Args:
         input (Union[Tensor, Number, bool]): The first input is a number or
             a bool or a tensor whose data type is number or bool.
@@ -3753,7 +3928,7 @@ def median_ext(input, dim=None, keepdim=False):
     Raises:
         TypeError: If dtype of ``input`` is not one of the following: uint8, int16, int32, int64, float16 or float32.
         TypeError: If input ``input`` is not a Tensor.
-        TypeError: If ``dim`` is not a int.
+        TypeError: If ``dim`` is not an int.
         TypeError: If ``keepdim`` is not a bool.
         ValueError: If ``dim`` is not in range of [-x.dim, x.dim-1].
 
@@ -3799,7 +3974,7 @@ def median(input, axis=-1, keepdims=False):
     Raises:
         TypeError: If dtype of `input` is not one of the following: int16, int32, int64, float32, float64.
         TypeError: If input `input` is not a Tensor.
-        TypeError: If `axis` is not a int.
+        TypeError: If `axis` is not an int.
         TypeError: If `keepdims` is not a bool.
         ValueError: If `axis` is not in range of [-x.dim, x.dim-1].
 
@@ -3924,7 +4099,7 @@ def orgqr(input, input2):
     computes the first :math:`N` columns of a product of
     `Householder <https://en.wikipedia.org/wiki/Householder_transformation#Householder_matrix>`_
     matrices. Suppose input `input` is a matrix of size :math:`(M, N)` after householder transformation.
-    When the diagonal of `input` is set to 1, every colunm of lower triangular in `input` is
+    When the diagonal of `input` is set to 1, every column of lower triangular in `input` is
     denoted as :math:`w_j` for :math:`j` for
     :math:`j=1, \ldots, M`, this function returns the first :math:`N` columns of the matrix
 
@@ -4172,6 +4347,8 @@ def logspace(start, end, steps, base=10, *, dtype=mstype.float32):
         end (Union[float, Tensor]): End value of interval.
         steps (int): The steps must be a non-negative integer.
         base (int, optional): The base must be a non-negative integer. Default: ``10`` .
+
+    Keyword Args:
         dtype (mindspore.dtype, optional): The dtype of output. Default: ``mstype.float32`` .
 
     Returns:
@@ -4375,6 +4552,126 @@ def vander(x, N=None):
     return F.tensor_pow(x, exponent)
 
 
+def var_ext(input, dim=None, *, correction=1, keepdim=False):
+    r"""
+    Calculates the variance over the dimensions specified by `dim`. `dim` can be a single dimension, list of
+    dimensions, or None to reduce over all dimensions.
+
+    The variance (:math:`\delta ^2`) is calculated as:
+
+    .. math::
+        \delta ^2 = \frac{1}{\max(0, N - \delta N)}\sum^{N - 1}_{i = 0}(x_i - \bar{x})^2
+
+    where :math:`x` is the sample set of elements, :math:`\bar{x}` is the sample mean, :math:`N` is the number
+    of samples and :math:`\delta N` is the `correction`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The tensor used to calculate the variance.
+        dim (None, int, tuple(int), optional): The dimension or dimensions to reduce. Defaults to ``None``.
+            If ``None``, all dimensions are reduced.
+
+    Keyword Args:
+        correction (int, optional): The difference between the sample size and sample degrees of freedom. Defaults
+            to Bessel’s correction. Defaults to ``1``.
+        keepdim (bool, optional): Whether the output tensor has dim retained or not. If ``True`` , keep these
+            reduced dimensions and the length is 1. If ``False``, don't keep these dimensions. Defaults to ``False``.
+
+    Returns:
+        Tensor, the variance.
+        Suppose the shape of `input` is :math:`(x_0, x_1, ..., x_R)`:
+
+        - If `dim` is () and `keepdim` is set to ``False`` , returns a 0-D Tensor, indicating the variance of all
+          elements in `input`.
+        - If `dim` is int, e.g. ``1`` and `keepdim` is set to ``False`` , then the returned Tensor has shape
+          :math:`(x_0, x_2, ..., x_R)`.
+        - If `dim` is tuple(int) or list(int), e.g. ``(1, 2)`` and `keepdim` is set to ``False`` , then the returned
+          Tensor has shape :math:`(x_0, x_3, ..., x_R)`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `input` is not in bfloat16, float16, flaot32.
+        TypeError: If `dim` is not one of the followings: None, int, list, tuple.
+        TypeError: If `correction` is not an int.
+        TypeError: If `keepdim` is not a bool.
+        ValueError: If `dim` is out of range :math:`[-input.ndim, input.ndim)`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor([[8, 2, 1], [5, 9, 3], [4, 6, 7]], mindspore.float32)
+        >>> output = ops.var_ext(input, dim=0, correction=1, keepdim=True)
+        >>> print(output)
+        [[ 4.333333, 12.333333, 9.333333]]
+    """
+    return var_op(input, dim, correction, keepdim)
+
+
+def std_ext(input, dim=None, *, correction=1, keepdim=False):
+    r"""
+    Calculates the standard deviation over the dimensions specified by `dim`. `dim` can be a single dimension, list of
+    dimensions, or None to reduce over all dimensions.
+
+    The standard deviation (:math:`\sigma`) is calculated as:
+
+    .. math::
+        \sigma =\sqrt{\frac{1}{N-\delta N}\sum_{j-1}^{N-1}\left(s e l f_{i j}-\overline{x_{i}}\right)^{2}}
+
+    where :math:`x` is the sample set of elements, :math:`\bar{x}` is the sample mean, :math:`N` is the number
+    of samples and :math:`\delta N` is the `correction`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The tensor used to calculate the standard deviation.
+        dim (None, int, tuple(int), optional): The dimension or dimensions to reduce. Defaults to ``None``.
+            If ``None``, all dimensions are reduced.
+
+    Keyword Args:
+        correction (int, optional): The difference between the sample size and sample degrees of freedom. Defaults
+            to Bessel’s correction. Defaults to ``1``.
+        keepdim (bool, optional): Whether the output tensor has dim retained or not. If ``True`` , keep these
+            reduced dimensions and the length is 1. If ``False``, don't keep these dimensions. Defaults to ``False``.
+
+    Returns:
+        Tensor, the standard deviation.
+        Suppose the shape of `input` is :math:`(x_0, x_1, ..., x_R)`:
+
+        - If `dim` is () and `keepdim` is set to ``False`` , returns a 0-D Tensor, indicating the standard deviation of
+          all elements in `input`.
+        - If `dim` is int, e.g. ``1`` and `keepdim` is set to ``False`` , then the returned Tensor has shape
+          :math:`(x_0, x_2, ..., x_R)`.
+        - If `dim` is tuple(int) or list(int), e.g. ``(1, 2)`` and `keepdim` is set to ``False`` , then the returned
+          Tensor has shape :math:`(x_0, x_3, ..., x_R)`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `input` is not in bfloat16, float16, float32.
+        TypeError: If `dim` is not one of the followings: None, int, tuple.
+        TypeError: If `correction` is not an int.
+        TypeError: If `keepdim` is not a bool.
+        ValueError: If `dim` is out of range :math:`[-input.ndim, input.ndim)`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import mint, Tensor
+        >>> input = Tensor(np.array([[1, 2, 3], [-1, 1, 4]]).astype(np.float32))
+        >>> output = ops.std_ext(input, dim=1, correction=1, keepdim=False)
+        >>> print(output)
+        [1.      2.5166113]
+    """
+    return std_op(input, dim, correction, keepdim)
+
+
 def var(input, axis=None, ddof=0, keepdims=False):
     r"""
     Returns the variance of each row of the input Tensor by default, or it can calculate them
@@ -4627,73 +4924,183 @@ def std_mean(input, axis=None, ddof=0, keepdims=False):
     return tensor_pow(output[0], 0.5), output[1]
 
 
-def reciprocal(input):
+def std_mean_ext(input, dim=None, *, correction=1, keepdim=False):
     r"""
-    Returns reciprocal of a tensor element-wise.
+    By default, return the standard deviation and mean of each dimension in Tensor.
+    If dim is a dimension list, calculate the standard deviation and mean of the corresponding dimension.
+
+    The standard deviation (:math:`\sigma`) is calculated as:
 
     .. math::
 
-        out_{i} =  \frac{1}{x_{i}}
+        \sigma = \sqrt{\frac{1}{N - \delta N} \sum_{j=0}^{N-1} \left(self_{ij} - \overline{x_{i}}\right)^{2}}
+
+    where is :math:`x` the sample set of elements, :math:`\bar{x}` is the sample mean,
+    :math:`N` is the number of samples and :math:`\delta N` is the `correction` .
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Args:
-        input (Tensor): The input tensor.
+        input (Tensor): The input tensor. Supported dtypes: float16, float32.
+        dim (Union[int, tuple(int), list(int)], optional):
+            Specify the dimensions for calculating standard deviation and mean. Default value: ``None``.
+
+    Keyword Args:
+        correction (int, optional): Difference between the sample size and sample degrees of freedom.
+            Defaults to Bessel's correction. Default: ``1``.
+        keepdim (bool, optional): Whether to preserve the dimensions of the output Tensor.
+            If True, retain the reduced dimension with a size of 1. Otherwise, remove the dimensions.
+            Default value: ``False``.
 
     Returns:
-        Tensor, has the same shape as the `input`.
+        A tuple of standard deviation and mean.
 
     Raises:
         TypeError: If `input` is not a Tensor.
+        TypeError: If `dim` is not one of the following data types: int, tuple, list, or Tensor.
+        TypeError: If `keepdim` is not a bool.
+        ValueError: If `dim` is out of range.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend``
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
-        >>> import numpy as np
-        >>> input = ms.Tensor(np.array([1.0, 2.0, 4.0]), ms.float32)
-        >>> output = ops.reciprocal(input)
-        >>> print(output)
-        [1.   0.5  0.25]
+        >>> input = ms.Tensor([[1, 2, 3, 4], [-1, 1, 4, -10]], ms.float32)
+        >>> output_std, output_mean = ms.mint.std_mean(input, 1, correction=2, keepdim=True)
+        >>> print(output_std)
+        [[1.5811388]
+         [7.3824115]]
+        >>> print(output_mean)
+        [[ 2.5]
+         [-1.5]]
     """
-    return reciprocal_(input)
+    return std_mean_op(input, dim, correction, keepdim)
 
 
-def outer(input, vec2):
-    """
-    Return outer product of `input` and `vec2`. If `input` is a vector of size :math:`n`
-    and `vec2` is a vector of size :math:`m` , then output must be a matrix of shape :math:`(n, m)` .
+def var_mean_ext(input, dim=None, *, correction=1, keepdim=False):
+    r"""
+    By default, return the variance and mean of each dimension in Tensor.
+    If dim is a dimension list, calculate the variance and mean of the corresponding dimension.
 
-    Note:
-        This function does not broadcast.
+    The variance (:math:`\sigma ^2`) is calculated as:
+
+    .. math::
+
+        \sigma ^2 = \frac{1}{N - \delta N} \sum_{j=0}^{N-1} \left(self_{ij} - \overline{x_{i}}\right)^{2}
+
+    where is :math:`x` the sample set of elements, :math:`\bar{x}` is the sample mean,
+    :math:`N` is the number of samples and :math:`\delta N` is the `correction` .
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Args:
-        input (Tensor): 1-D input vector.
-        vec2 (Tensor): 1-D input vector.
+        input (Tensor): The input tensor. Supported dtypes: float16, float32.
+        dim (Union[int, tuple(int), list(int)], optional):
+            Specify the dimensions for calculating variance and mean. Default value: ``None``.
+
+    Keyword Args:
+        correction (int, optional): Difference between the sample size and sample degrees of freedom.
+            Defaults to Bessel's correction. Default: ``1``.
+        keepdim (bool, optional): Whether to preserve the dimensions of the output Tensor.
+            If True, retain the reduced dimension with a size of 1. Otherwise, remove the dimensions.
+            Default value: ``False``.
 
     Returns:
-        out (Tensor, optional), 2-D matrix, the outer product of two vectors.
+        A tuple of variance and mean.
 
     Raises:
-        TypeError: If `input` or `vec2` is not a Tensor.
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `dim` is not one of the following data types: int, tuple, list, or Tensor.
+        TypeError: If `keepdim` is not a bool.
+        ValueError: If `dim` is out of range.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend``
 
     Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> from mindspore import ops
-        >>> input = Tensor(np.array([7, 8, 9]), mindspore.int32)
-        >>> vec2 = Tensor(np.array([7, 10, 11]), mindspore.int32)
-        >>> out = ops.outer(input, vec2)
-        >>> print(out)
-        [[49 70 77]
-         [56 80 88]
-         [63 90 99]]
-    """
-
+        >>> import mindspore as ms
+        >>> input = ms.Tensor([[1, 2, 3, 4], [-1, 1, 4, -10]], ms.float32)
+        >>> output_var, output_mean = ms.mint.var_mean(input, 1, correction=2, keepdim=True)
+        >>> print(output_var)
+        [[ 2.5]
+         [54.5]]
+        >>> print(output_mean)
+        [[ 2.5]
+         [-1.5]]
+    """
+    return var_mean_op(input, dim, correction, keepdim)
+
+
+def reciprocal(input):
+    r"""
+    Returns reciprocal of a tensor element-wise.
+
+    .. math::
+
+        out_{i} =  \frac{1}{x_{i}}
+
+    Args:
+        input (Tensor): The input tensor.
+
+    Returns:
+        Tensor, has the same shape as the `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore import ops
+        >>> import numpy as np
+        >>> input = ms.Tensor(np.array([1.0, 2.0, 4.0]), ms.float32)
+        >>> output = ops.reciprocal(input)
+        >>> print(output)
+        [1.   0.5  0.25]
+    """
+    return reciprocal_(input)
+
+
+def outer(input, vec2):
+    """
+    Return outer product of `input` and `vec2`. If `input` is a vector of size :math:`n`
+    and `vec2` is a vector of size :math:`m` , then output must be a matrix of shape :math:`(n, m)` .
+
+    Note:
+        This function does not broadcast.
+
+    Args:
+        input (Tensor): 1-D input vector.
+        vec2 (Tensor): 1-D input vector.
+
+    Returns:
+        out (Tensor, optional), 2-D matrix, the outer product of two vectors.
+
+    Raises:
+        TypeError: If `input` or `vec2` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore import ops
+        >>> input = Tensor(np.array([7, 8, 9]), mindspore.int32)
+        >>> vec2 = Tensor(np.array([7, 10, 11]), mindspore.int32)
+        >>> out = ops.outer(input, vec2)
+        >>> print(out)
+        [[49 70 77]
+         [56 80 88]
+         [63 90 99]]
+    """
+
     if not isinstance(input, (Tensor, Tensor_)):
         raise TypeError("the input input must be Tensor!")
     if not isinstance(vec2, (Tensor, Tensor_)):
@@ -4799,6 +5206,103 @@ def addbmm(input, batch1, batch2, *, beta=1, alpha=1):
     return beta * input + alpha * (bmm_res.sum(axis=0))
 
 
+def addbmm_ext(input, batch1, batch2, *, beta=1, alpha=1):
+    r"""
+    Applies batch matrix multiplication to `batch1` and `batch2`, with a reduced add step and add `input` to the result.
+
+    The optional values `alpha` and `beta` are the matrix-matrix product between `batch1` and `batch2` and the scale
+    factor for the added tensor `input` respectively. If `beta` is 0, then `input` will be ignored.
+
+    .. math::
+        output = \beta input + \alpha (\sum_{i=0}^{b-1} {batch1_i @ batch2_i})
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): Tensor to be added.
+        batch1 (Tensor): The first batch of tensor to be multiplied.
+        batch2 (Tensor): The second batch of tensor to be multiplied.
+
+    Keyword Args:
+        beta (Union[int, float], optional): Multiplier for `input`. Default: ``1`` .
+        alpha (Union[int, float], optional): Multiplier for `batch1` @ `batch2`. Default: ``1`` .
+
+    Returns:
+        Tensor, has the same dtype as `input`.
+
+    Raises:
+        TypeError: If `alpha` or `beta` is not an int or float.
+        ValueError: If `batch1`, `batch2` cannot apply batch matrix multiplication.
+        ValueError: If `batch1` and `batch2` are not 3-D tensors.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> m = np.ones((3, 3)).astype(np.float32)
+        >>> arr1 = np.arange(24).astype(np.float32).reshape((2, 3, 4))
+        >>> arr2 = np.arange(24).astype(np.float32).reshape((2, 4, 3))
+        >>> a = Tensor(arr1)
+        >>> b = Tensor(arr2)
+        >>> c = Tensor(m)
+        >>> output = ops.addbmm_ext(c, a, b)
+        >>> print(output)
+        [[ 949. 1009. 1069.]
+         [1285. 1377. 1469.]
+         [1621. 1745. 1869.]]
+    """
+    return addbmm_op(input, batch1, batch2, beta, alpha)
+
+
+def addmm_ext(input, mat1, mat2, *, beta=1, alpha=1):
+    r"""
+    Performs a matrix multiplication of the 2-D matrices mat1 and mat2. The matrix input is added to the final result.
+    The formula is defined as follows:
+
+    .. math::
+        output = \beta input + \alpha (mat1 @ mat2)
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): matrix to be added, the shape must be broadcastable with mat1 @ mat2.
+        mat1 (Tensor): the first matrix to be matrix multiplied, must be 2-D Tensor, with the same shape of the input.
+        mat2 (Tensor): the second matrix to be matrix multiplied, must be 2-D Tensor, with the same shape of the input.
+
+    Keyword Args:
+        beta (Union[float, int], optional): multiplier for input. Default: ``1`` .
+        alpha (Union[float, int], optional): multiplier for :math:`mat1 @ mat2`. Default: ``1`` .
+
+    Returns:
+        Tensor, with the same dtype as `input` and the same shape as mat1 @ mat2.
+
+    Raises:
+        TypeError: If the type of `input`, `mat1` or `mat2` is not Tensor.
+        TypeError: If the types of `input`, `mat1`, `mat2` are different.
+        ValueError: If `mat1` and `mat2` are not 2-D tensors.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> input = Tensor(np.ones([3, 3]).astype(np.float32))
+        >>> mat1 = Tensor(np.ones([3, 4]).astype(np.float32))
+        >>> mat2 = Tensor(np.ones([4, 3]).astype(np.float32))
+        >>> output =  ops.function.math_func.addmm_ext(input, mat1, mat2)
+        >>> print(output)
+        [[5. 5. 5.]
+         [5. 5. 5.]
+         [5. 5. 5.]]
+    """
+    return addmm_op(input, mat1, mat2, beta, alpha)
+
+
 def addmm(input, mat1, mat2, *, beta=1, alpha=1):
     r"""
     Multiplies matrix `mat1` and matrix `mat2`. The matrix `input` is added to the final result.
@@ -4910,6 +5414,53 @@ def addmv(input, mat, vec, *, beta=1, alpha=1):
     return out
 
 
+def addmv_ext(input, mat, vec, *, beta=1, alpha=1):
+    """
+    Performs a matrix-vector product of `mat` and `vec`, and add the input vector `input` to the final result.
+
+    If `mat` is a tensor of size :math:`(N, M)` , `vec` is a 1-D tensor of size :math:`M` , then `input` must be
+    broadcastable with a 1-D tensor of size :math:`N` . In this case, `output` is a 1-D Tensor of size :math:`N` .
+
+    .. math::
+        output = \beta input + \alpha (mat @ vec)
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): Vector to be added.
+        mat (Tensor): The first tensor needs to be multiplied.
+        vec (Tensor): The second tensor needs to be multiplied.
+
+    Keyword Args:
+        beta (Union[float, int], optional): Coefficient of `input`. Default: ``1``.
+        alpha (Union[float, int], optional): Coefficient of :math:`mat @ vec` . Default: ``1``.
+
+    Returns:
+        Tensor, with a shape of :math:`(N,)` , and its dtype is the same as `input`.
+
+    Raises:
+        TypeError: If dtype of `input`, `mat` or `vec` is not tensor.
+        TypeError: If dtypes of `mat` and `vec` are not the same.
+        ValueError: If `mat` is not a 2-D tensor.
+        ValueError: If `vec` is not a 1-D tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> input = Tensor(np.array([2., 3.]).astype(np.float32))
+        >>> mat = Tensor(np.array([[2., 5., 3.], [4., 2., 2.]]).astype(np.float32))
+        >>> vec = Tensor(np.array([3., 2., 4.]).astype(np.float32))
+        >>> output = mint.addmv(input, mat, vec)
+        >>> print(output)
+        [30. 27.]
+    """
+    return addmv_op(input, mat, vec, beta, alpha)
+
+
 def adjoint(x):
     r"""
     Calculates the conjugation of Tensor element by element, and transposes the last two dimensions.
@@ -5047,60 +5598,13 @@ def lcm(input, other):
     return lcm_(input, other)
 
 
-def cdist(x1, x2, p=2.0):
-    """
-    Computes p-norm distance between each pair of row vectors of two input Tensors.
-
-    Note:
-        On Ascend, the supported dtypes are float16 and float32.
-        On CPU, the supported dtypes are float16 and float32.
-        On GPU, the supported dtypes are float32 and float64.
-
-    Args:
-        x1 (Tensor): Input tensor of shape :math:`(B, P, M)`.
-          Letter :math:`B` represents 0 or positive int number.
-          When :math:`B` is equal to 0, it means this dimension can be ignored,
-          i.e. shape of the tensor is :math:`(P, M)`.
-        x2 (Tensor): Input tensor of shape :math:`(B, R, M)`, has the same dtype as `x1`.
-        p (float, optional): P value for the p-norm distance to calculate between each
-          vector pair, P ∈ [0,∞]. Default: ``2.0`` .
-
-    Returns:
-        Tensor, p-norm distance, has the same dtype as `x1`, its shape is :math:`(B, P, R)`.
-
-    Raises:
-        TypeError: If `x1` or `x2` is not Tensor.
-        TypeError: If dtype of `x1` or `x2` is not listed in the "Note" above.
-        TypeError: If `p` is not float32.
-        ValueError: If `p` is negative.
-        ValueError: If dimension of `x1` is not the same as `x2`.
-        ValueError: If dimension of `x1` or `x2` is neither 2 nor 3.
-        ValueError: If the batch shape of `x1` is not the same as the shape of `x2`.
-        ValueError: If the number of columns of `x1` is not the same as that of `x2`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([[[1.0, 1.0], [2.0, 2.0]]]).astype(np.float32))
-        >>> y = Tensor(np.array([[[3.0, 3.0], [3.0, 3.0]]]).astype(np.float32))
-        >>> output = ops.cdist(x, y, 2.0)
-        >>> print(output)
-        [[[2.8284273 2.8284273]
-          [1.4142137 1.4142137]]]
-    """
-    cdist_ = _get_cache_prim(P.Cdist)(p)
-    return cdist_(x1, x2)
-
-
 def lerp(input, end, weight):
     """
     Does a linear interpolation of two tensors input and end based on a float or tensor weight.
 
     If `weight` is a tensor, the shapes of three inputs need to be broadcast;
     If `weight` is a float, the shapes of `input` and `end` need to be broadcast.
+    If `weight` is a float and platform is Ascend, the types of `input` and `end` need to be float32.
 
     .. math::
 
@@ -5217,7 +5721,7 @@ def bernoulli_ext(input, *, generator=None):
             Default: ``None``, uses the default pseudorandom number generator.
 
     Returns:
-        output (Tensor): The output tensor, with the same shape and dtype as `input`.
+        output (Tensor), The output tensor, with the same shape and dtype as `input`.
 
     Raises:
         TypeError: If dtype of `input` is not one of: float16, float32, float64, bfloat16.
@@ -5810,7 +6314,7 @@ def atleast_1d(inputs):
     return tuple([_expand(arr, 1) for arr in inputs])
 
 
-def dstack(inputs):
+def dstack(tensors):
     r"""
     Stacks tensors along the third axis.
 
@@ -5818,7 +6322,7 @@ def dstack(inputs):
     2-D tensors :math:`(M,N)` should be reshaped to :math:`(M,N,1)` before concatenation.
 
     Args:
-        inputs (Union(List[Tensor], Tuple[Tensor])): A sequence of tensors.
+        tensors (Union(List[Tensor], Tuple[Tensor])): A sequence of tensors.
             The tensors must have the same shape along all but the third axis.
             1-D or 2-D tensors must have the same shape.
 
@@ -5827,8 +6331,8 @@ def dstack(inputs):
         The output shape is similar to the output of `numpy.dstack()` function.
 
     Raises:
-        TypeError: If `inputs` is not tuple or list.
-        ValueError: If `inputs` is empty.
+        TypeError: If `tensors` is not tuple or list.
+        ValueError: If `tensors` is empty.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -5847,24 +6351,24 @@ def dstack(inputs):
           [ 5. 11.]
           [ 6. 12.]]]
     """
-    if not isinstance(inputs, (tuple, list)):
-        raise TypeError(f"For 'dstack', 'inputs' must be list or tuple of tensors, but got {type(inputs)}")
-    if not inputs:
-        raise TypeError(f"For 'dstack', 'inputs' can not be empty.")
-    trans_inputs = ()
-    for tensor in inputs:
+    if not isinstance(tensors, (tuple, list)):
+        raise TypeError(f"For 'dstack', 'tensors' must be list or tuple of tensors, but got {type(tensors)}")
+    if not tensors:
+        raise TypeError(f"For 'dstack', 'tensors' can not be empty.")
+    trans_tensors = ()
+    for tensor in tensors:
         if not isinstance(tensor, Tensor):
-            raise TypeError(f"For 'dstack', each elements of 'inputs' must be Tensor, but got {type(tensor)}")
-        if tensor.size == 0:
-            raise TypeError(f"For 'dstack', each elements of 'inputs' can not be empty.")
-        if tensor.ndim <= 1:
-            tensor = _expand(tensor, 2)
-        if tensor.ndim == 2:
+            raise TypeError(f"For 'dstack', each elements of 'tensors' must be Tensor, but got {type(tensor)}")
+        if tensor.ndim == 0:
+            tensor = reshape_(tensor, (1, 1, 1))
+        elif tensor.ndim == 1:
+            tensor = expand_dims_(expand_dims_(tensor, 0), 2)
+        elif tensor.ndim == 2:
             tensor = expand_dims_(tensor, 2)
-        trans_inputs += (tensor,)
-    if not trans_inputs:
+        trans_tensors += (tensor,)
+    if not trans_tensors:
         raise ValueError("For 'dstack', at least one tensor is needed to concatenate.")
-    return _get_cache_prim(P.Concat)(2)(trans_inputs)
+    return _get_cache_prim(P.Concat)(2)(trans_tensors)
 
 
 @_primexpr
@@ -5950,6 +6454,113 @@ def diff(x, n=1, axis=-1, prepend=None, append=None):
     return a2 - a1
 
 
+def _diff_is_scalar_or_scalar_tensor(value):
+    """judge the value"""
+    if isinstance(value, int):
+        return True
+
+    if isinstance(value, ms.Tensor) and value.shape == ():
+        return True
+
+    return False
+
+
+def _diff_check(input, n, dim):
+    """judge the input n and dim"""
+    if not isinstance(input, Tensor):
+        raise TypeError("For 'diff', 'input' must be a tensor")
+
+    if not _diff_is_scalar_or_scalar_tensor(n):
+        raise TypeError("For 'diff', 'n' must be a int scalar or int scalar tensor")
+
+    if not _diff_is_scalar_or_scalar_tensor(dim):
+        raise TypeError("For 'diff', 'dim' must be a scalar or scalar tensor")
+
+    if input.dtype in (mstype.complex64, mstype.complex128, mstype.float64, mstype.int16):
+        raise TypeError("For 'diff', 'input' do not support complex64/complex128/float64/int16")
+
+
+def _diff_helper(input, n, dim):
+    """calculate the forward difference"""
+    out_len = input.shape[dim] - 1
+    is_bool = (input.dtype == mstype.bool_)
+    result = input
+
+    for i in range(n):  # pylint: disable=unused-variable
+        if is_bool:
+            result = logical_xor(narrow(result, dim, 1, out_len), narrow(result, dim, 0, out_len))
+        else:
+            result = sub_ext(narrow(result, dim, 1, out_len), narrow(result, dim, 0, out_len))
+
+        if out_len == 0:
+            break
+        out_len -= 1
+
+    return result
+
+
+def _diff_prepend_append_on_dim(input, prepend, append, dim):
+    """append tensor on dim"""
+    if prepend is not None and append is None:
+        return cat((prepend, input), dim)
+
+    if prepend is None and append is not None:
+        return cat((input, append), dim)
+
+    return cat((prepend, input, append), dim)
+
+
+def diff_ext(input, n=1, dim=-1, prepend=None, append=None):
+    r"""
+    Computes the n-th forward difference along the given dimension.
+
+    The first-order differences are given by :math:`out[i] = input[i+1] - input[i]`. Higher-order differences are
+    calculated by using `torch.diff()` recursively.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): the tensor to compute the differences on.
+        n (int, optional): the number of times to recursively compute the difference.
+            Default: ``1`` .
+        dim (int, optional): the dimension to compute the difference along.
+            Default is the last dimension. Default: ``0`` .
+        prepend (Tensor, optional): values to prepend or append to `input` along `dim`
+            before computing the difference. Their dimensions must be equivalent to that of input,
+            and their shapes must match input's shape except on `dim`. Default: ``None`` .
+        append (Tensor, optional): values to prepend or append to `input` along `dim`
+            before computing the difference. Their dimensions must be equivalent to that of input,
+            and their shapes must match input's shape except on `dim`. Default: ``None`` .
+
+    Returns:
+        Tensor, the result of n-th forward difference computation.
+
+    Raises:
+        TypeError: If `input` is not a tensor.
+        TypeError: If `n` is not a scalar or scalar tensor.
+        TypeError: If `dim` is not a scalar or scalar tensor.
+        TypeError: If `input` type is complex64, complex128, float64, int16.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor([1, 3, -1, 0, 4])
+        >>> out = ops.diff_ext(x)
+        >>> print(out.asnumpy())
+        [ 2 -4  1  4]
+    """
+    _diff_check(input, n, dim)
+
+    if (prepend is None and append is None) or n == 0:
+        return _diff_helper(input, n, dim)
+
+    input = _diff_prepend_append_on_dim(input, prepend, append, dim)
+    return _diff_helper(input, n, dim)
+
+
 def tril_indices(row, col, offset=0, *, dtype=mstype.int64):
     r"""
     Calculates the indices of the lower triangular elements in a `row` * `col` matrix
@@ -6638,7 +7249,7 @@ def logsumexp(input, axis, keep_dims=False):
     Args:
         input (Tensor): The input tensor. With float16 or float32 data type.
         axis (Union[int, tuple(int), list(int)]): The dimensions to reduce. Only constant value is allowed.
-        keep_dims (bool): If True, keep these reduced dimensions and the length is 1.
+        keep_dims (bool, optional): If True, keep these reduced dimensions and the length is 1.
             If ``False`` , don't keep these dimensions.
             Default : ``False`` .
 
@@ -6686,10 +7297,11 @@ def amin(input, axis=None, keepdims=False, *, initial=None, where=None):
     Args:
         input (Tensor[Number]): The input tensor. The dtype of the tensor to be reduced is number.
             :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        axis (Union[int, tuple(int), list(int), Tensor]): The dimensions to reduce. Default: ``None`` , reduce all
-            dimensions. Only constant value is allowed. Assume the rank of `x` is r, and the value range is [-r,r).
-        keepdims (bool): If ``True`` , keep these reduced dimensions and the length is 1. If ``False`` , don't keep
-            these dimensions. Default: ``False`` .
+        axis (Union[int, tuple(int), list(int), Tensor], optional): The dimensions to reduce. Default: ``None`` ,
+            reduce all dimensions. Only constant value is allowed. Assume the rank of `x` is r, and the value range is
+            [-r,r).
+        keepdims (bool, optional): If ``True`` , keep these reduced dimensions and the length is 1. If ``False`` ,
+            don't keep these dimensions. Default: ``False`` .
 
     Keyword Args:
         initial (scalar, optional): The minimum value of an output element. Must be present to allow computation
@@ -6796,10 +7408,11 @@ def amax(input, axis=None, keepdims=False, *, initial=None, where=None):
     Args:
         input (Tensor[Number]): The input tensor. The dtype of the tensor to be reduced is number.
             :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        axis (Union[int, tuple(int), list(int), Tensor]): The dimensions to reduce. Default: ``None`` , reduce all
-            dimensions. Only constant value is allowed. Assume the rank of `x` is r, and the value range is [-r,r).
-        keepdims (bool): If ``True`` , keep these reduced dimensions and the length is 1. If ``False`` , don't keep
-            these dimensions. Default: ``False`` .
+        axis (Union[int, tuple(int), list(int), Tensor], optional): The dimensions to reduce. Default: ``None`` ,
+            reduce all dimensions. Only constant value is allowed. Assume the rank of `x` is r, and the value range is
+            [-r,r).
+        keepdims (bool, optional): If ``True`` , keep these reduced dimensions and the length is 1. If ``False`` ,
+            don't keep these dimensions. Default: ``False`` .
 
     Keyword Args:
         initial (scalar, optional): The minimum value of an output element. Must be present to allow computation
@@ -6878,6 +7491,174 @@ def amax(input, axis=None, keepdims=False, *, initial=None, where=None):
     return _get_cache_prim(P.ReduceMax)(keepdims)(input, axis)
 
 
+def amax_ext(input, dim=(), keepdim=False):
+    r"""
+    Computes the maximum value of of all elements along the specified `dim` dimension of the `input`,
+    and retains the dimension based on the `keepdim` parameter.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): Input tensor.
+        dim (Union[int, tuple(int), list(int)], optional): The dimension to be reduced,
+            the value should be within `[-len(input.shape), len(input.shape) - 1]`,
+            when the `dim` is `()`, all dimensions are reduced, default: ``()``.
+        keepdim (bool, optional): Whether the output tensor retains the dimension `dim`, default: ``False``.
+
+    Returns:
+        Tensor, has same type as `input`, and the shape changes according to the values of `dim` and `keepdim`.
+
+        - If `dim` is `()`, and `keepdim` is False, the output is a 0-D tensor representing the maximum value of
+          all elements in the `input` tensor.
+        - If `dim` is `1`, and `keepdim` is False, the shape of output is
+          :math:`(input.shape[0], input.shape[2], ..., input.shape[n])`.
+        - If `dim` is `(1, 2)`, and `keepdim` is False, the shape of output is
+          :math:`(input.shape[0], input.shape[3], ..., input.shape[n])`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `dim` is not an int or tuple(int) or list(int).
+        TypeError: If `keepdim` is not a bool.
+        ValueError: If the value of any elements of `dim` is not in the range
+            `[-len(input.shape), len(input.shape) - 1]`.
+        RuntimeError: If any element of `dim` is repeated.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore import ops
+        >>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
+        >>> output = ops.function.math_func.amax_ext(x, 1, keepdim=True)
+        >>> result = output.shape
+        >>> print(result)
+        (3, 1, 5, 6)
+        >>> # case 1: Reduces a dimension by the maximum value of all elements in the dimension.
+        >>> x = Tensor(np.array([[[1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 3, 3]],
+        ... [[4, 4, 4, 4, 4, 4], [5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6]],
+        ... [[7, 7, 7, 7, 7, 7], [8, 8, 8, 8, 8, 8], [9, 9, 9, 9, 9, 9]]]),
+        ... mindspore.float32)
+        >>> output = ops.function.math_func.amax_ext(x)
+        >>> print(output)
+        9.0
+        >>> print(output.shape)
+        ()
+        >>> # case 2: Reduces a dimension along axis 0.
+        >>> output = ops.function.math_func.amax_ext(x, 0, True)
+        >>> print(output)
+        [[[7. 7. 7. 7. 7. 7.]
+          [8. 8. 8. 8. 8. 8.]
+          [9. 9. 9. 9. 9. 9.]]]
+        >>> # case 3: Reduces a dimension along axis 1.
+        >>> output = ops.function.math_func.amax_ext(x, 1, True)
+        >>> print(output)
+        [[[3. 3. 3. 3. 3. 3.]]
+         [[6. 6. 6. 6. 6. 6.]]
+         [[9. 9. 9. 9. 9. 9.]]]
+        >>> # case 4: Reduces a dimension along axis 2.
+        >>> output = ops.function.math_func.amax_ext(x, 2, True)
+        >>> print(output)
+        [[[1.]
+          [2.]
+          [3.]]
+         [[4.]
+          [5.]
+          [6.]]
+         [[7.]
+          [8.]
+          [9.]]]
+    """
+    return reduce_max_impl(input, dim, keepdim)
+
+
+def amin_ext(input, dim=(), keepdim=False):
+    r"""
+    Computes the minimum value of of all elements along the specified `dim` dimension of the `input`,
+    and retains the dimension based on the `keepdim` parameter.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): Input tensor.
+        dim (Union[int, tuple(int), list(int)], optional): The dimension to be reduced,
+            the value should be within `[-len(input.shape), len(input.shape) - 1]`,
+            when the `dim` is `()`, all dimensions are reduced, default: ``()``.
+        keepdim (bool, optional): Whether the output tensor retains the dimension `dim`, default: ``False``.
+
+    Returns:
+        Tensor, has same type as `input`, and the shape changes according to the values of `dim` and `keepdim`.
+
+        - If `dim` is `()`, and `keepdim` is False, the output is a 0-D tensor representing the minimum value of
+          all elements in the `input` tensor.
+        - If `dim` is `1`, and `keepdim` is False, the shape of output is
+          :math:`(input.shape[0], input.shape[2], ..., input.shape[n])`.
+        - If `dim` is `(1, 2)`, and `keepdim` is False, the shape of output is
+          :math:`(input.shape[0], input.shape[3], ..., input.shape[n])`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `dim` is not an int or tuple(int) or list(int).
+        TypeError: If `keepdim` is not a bool.
+        ValueError: If the value of any elements of `dim` is not in the range
+            `[-len(input.shape), len(input.shape) - 1]`.
+        RuntimeError: If any element of `dim` is repeated.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore import ops
+        >>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
+        >>> output = ops.function.math_func.amin_ext(x, 1, keepdim=True)
+        >>> result = output.shape
+        >>> print(result)
+        (3, 1, 5, 6)
+        >>> # case 1: Reduces a dimension by the minimum value of all elements in the dimension.
+        >>> x = Tensor(np.array([[[1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 3, 3]],
+        ... [[4, 4, 4, 4, 4, 4], [5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6]],
+        ... [[7, 7, 7, 7, 7, 7], [8, 8, 8, 8, 8, 8], [9, 9, 9, 9, 9, 9]]]),
+        ... mindspore.float32)
+        >>> output = ops.function.math_func.amin_ext(x)
+        >>> print(output)
+        1.0
+        >>> print(output.shape)
+        ()
+        >>> # case 2: Reduces a dimension along axis 0.
+        >>> output = ops.function.math_func.amin_ext(x, 0, True)
+        >>> print(output)
+        [[[1. 1. 1. 1. 1. 1.]
+          [2. 2. 2. 2. 2. 2.]
+          [3. 3. 3. 3. 3. 3.]]]
+        >>> # case 3: Reduces a dimension along axis 1.
+        >>> output = ops.function.math_func.amin_ext(x, 1, True)
+        >>> print(output)
+        [[[1. 1. 1. 1. 1. 1.]]
+         [[4. 4. 4. 4. 4. 4.]]
+         [[7. 7. 7. 7. 7. 7.]]]
+        >>> # case 4: Reduces a dimension along axis 2.
+        >>> output = ops.function.math_func.amin_ext(x, 2, True)
+        >>> print(output)
+        [[[1.]
+          [2.]
+          [3.]]
+         [[4.]
+          [5.]
+          [6.]]
+         [[7.]
+          [8.]
+          [9.]]]
+    """
+    return reduce_min_impl(input, dim, keepdim)
+
+
 def mean(x, axis=None, keep_dims=False):
     r"""
     Reduces all dimension of a tensor by averaging all elements in the dimension, by default.
@@ -7153,6 +7934,16 @@ def _multi_svd_norm(x, row_axis, col_axis, op):
     raise ValueError(f"For svd_norm, the op input must be one of ['amax', 'amin', 'sum'], but got f{op}")
 
 
+def _reshape_matrix_norm(input, res, dim, keepdims):
+    """reshape res of matrix_norm if keepdims is True."""
+    if keepdims:
+        res_shape = list(input.shape)
+        res_shape[dim[0]] = 1
+        res_shape[dim[1]] = 1
+        res = res.reshape(res_shape)
+    return res
+
+
 def _normalize_axis_index(axis, ndim):
     """normalize_axis_index for norm."""
     # pylint: disable=chained-comparison
@@ -7482,21 +8273,311 @@ def _check_vector_norm_ord(ord):
                          f"or must be int or float, but got {ord}.")
 
 
-def _compute_vector_norm_inf(x, dim, keepdims, norm_func):
-    """compute vector norm of `x` when ord is ``inf`` or ``-inf`` """
-    if len(dim) == 1:
-        ret_norm = norm_func(ops.abs(x), axis=dim[0], keepdims=keepdims)[0]
-    else:
-        start_dim = min(dim)
-        end_dim = max(dim)
-        flatten_x = ops.flatten(x, start_dim=start_dim, end_dim=end_dim)
-        ret_norm = norm_func(ops.abs(flatten_x), axis=start_dim, keepdims=False)[0]
-        if keepdims is True:
-            ret_shape = list(x.shape)
-            for i in dim:
-                ret_shape[i] = 1
-            ret_norm = ret_norm.reshape(ret_shape)
-    return ret_norm
+def _compute_vector_norm_inf(x, dim, keepdims, norm_func):
+    """compute vector norm of `x` when ord is ``inf`` or ``-inf`` """
+    if len(dim) == 1:
+        ret_norm = norm_func(ops.abs(x), axis=dim[0], keepdims=keepdims)[0]
+    else:
+        start_dim = min(dim)
+        end_dim = max(dim)
+        flatten_x = ops.flatten(x, start_dim=start_dim, end_dim=end_dim)
+        ret_norm = norm_func(ops.abs(flatten_x), axis=start_dim, keepdims=False)[0]
+        if keepdims is True:
+            ret_shape = list(x.shape)
+            for i in dim:
+                ret_shape[i] = 1
+            ret_norm = ret_norm.reshape(ret_shape)
+    return ret_norm
+
+
+@_primexpr
+def _check_vector_norm_inputs(x, ord):
+    """vector_norm inputs check"""
+    if not isinstance(x, (Tensor, Tensor_)):
+        raise TypeError(f"For `vector_norm`, the `x` must be Tensor!, but get {type(x)}.")
+
+    if not isinstance(ord, (bool, int, float)):
+        raise ValueError(f"For `vector_norm`, the ord mode must be one of [bool, int, float, inf, -inf], "
+                         f"but got {ord}.")
+
+
+def vector_norm_ext(x, ord=2, dim=None, keepdim=False, *, dtype=None):
+    r"""
+    Returns the vector norm of the given tensor on the specified dimensions.
+
+    `ord` is the calculation mode of norm. The following norm modes are supported.
+
+    ==========================      ==========================================
+    `ord`                           norm for vectors
+    ==========================      ==========================================
+    ``2`` (Default)                 ``2``-norm (see below)
+    ``inf``                         :math:`max(abs(x))`
+    ``-inf``                        :math:`min(abs(x))`
+    ``0``                           :math:`sum(x!=0)`
+    other ``int`` or ``float``      :math:`sum(abs(x)^{ord})^{(1 / ord)}`
+    ==========================      ==========================================
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        x (Tensor): Tensor of shape :math:`(*)` where * is zero s more batch dimensions.
+        ord (Union[bool, int, float, inf, -inf], optional): norm's mode. refer to the table above for
+            behavior. Default: ``2`` .
+        dim (Union[int, List(int), Tuple(int)], optional): The dimensions along which to perform the vector norm
+            calculation. Default: ``None`` .
+
+            - When `dim` is an integer, a list or a tuple, the norm calculation will be performed across these specified
+              dimensions, while the remaining dimensions will be considered as batch dimensions.
+
+            - When `dim` is None, the norm will be calculated after flattening the Tensor `x` .
+
+        keepdim (bool): whether the output Tensor retains the original dimension. Default: ``False`` .
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): When set, `x` will be converted to the specified type,
+            `dtype` before execution, and dtype of returned Tensor will also be `dtype`.
+            When `dtype` is ``None`` , the dtype of `x` is preserved. Default: ``None`` .
+
+    Returns:
+        Tensor, the result of norm calculation on the specified dimension, `dim`.
+
+    Raises:
+        TypeError: If `x` is not a Tensor.
+        TypeError: If `dim` is neither an int nor a list or tuple.
+        ValueError: If `ord` is not in [bool, int, float, inf, -inf].
+        ValueError: The elements of `dim` are duplicate.
+        ValueError: If any elements of `dim` is out of range.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> x = ms.ops.arange(0, 12, dtype=ms.float32) - 6
+        >>> print(ms.ops.vector_norm_ext(x, ord=2))
+        12.083046
+        >>> print(ms.ops.vector_norm_ext(x, ord=float('inf')))
+        6.0
+        >>> print(ms.ops.vector_norm_ext(x, ord=float('-inf')))
+        0.0
+        >>> print(ms.ops.vector_norm_ext(x, ord=0))
+        11.0
+        >>> print(ms.ops.vector_norm_ext(x, ord=4.5))
+        7.2243643
+    """
+    _check_vector_norm_inputs(x, ord)
+    if float(ord) in [0.0, 1.0, 2.0, 3.0]:
+        return linalg_vector_norm_op(x, float(ord), dim, keepdim, dtype)
+
+    if x.dtype in [mstype.bfloat16, mstype.float16, mstype.float32]:
+        if dtype is None:
+            return lp_norm_v2_op(x, ord, dim, keepdim, 0.0)
+        return ops.cast(lp_norm_v2_op(x, ord, dim, keepdim, 0.0), dtype)
+
+    cast_dtype = x.dtype if dtype is None else dtype
+    x = ops.cast(x, mstype.float32)
+    return ops.cast(lp_norm_v2_op(x, ord, dim, keepdim, 0.0), cast_dtype)
+
+
+def matrix_norm_ext(A, ord='fro', dim=(-2, -1), keepdim=False, *, dtype=None):
+    r"""
+    Returns the matrix norm of a given tensor on the specified dimensions.
+
+    `ord` is the calculation mode of norm. The following norm modes are supported.
+
+    ====================== ================================
+    `ord`                  norm for matrix
+    ====================== ================================
+    ``'fro'`` (Default)    Frobenius norm
+    ``'nuc'``              nuclear norm
+    ``inf``                :math:`max(sum(abs(x), dim=1))`
+    ``-inf``               :math:`min(sum(abs(x), dim=1))`
+    ``1``                  :math:`max(sum(abs(x), dim=0))`
+    ``-1``                 :math:`min(sum(abs(x), dim=0))`
+    ``2``                  largest singular value
+    ``-2``                 smallest singular value
+    ====================== ================================
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        A (Tensor): Tensor of shape :math:`(*, m, n)` where * is zero or more batch dimensions.
+        ord (Union[int, inf, -inf, 'fro', 'nuc'], optional): norm's mode. refer to the table above for
+            behavior. Default: ``'fro'`` .
+        dim (Tuple(int, int), optional): calculate the dimension of the matrix norm.
+            Default: ``(-2, -1)`` .
+        keepdim (bool): whether the output Tensor retains the original dimension. Default: ``False`` .
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): When set, `A` will be converted to the specified type,
+            `dtype`, before execution, and dtype of returned Tensor will also be `dtype`.
+            When `dtype` is ``None`` , the dtype of `A` is preserved. Default: ``None`` .
+
+    Returns:
+        Tensor, the result of norm calculation on the specified dimension, `dim`.
+
+    Raises:
+        TypeError: If `dim` is not a tuple of int.
+        ValueError: If the length of `dim` is not equal to 2.
+        ValueError: If `ord` is not in [2, -2, 1, -1, float('inf'), float('-inf'), 'fro', 'nuc'].
+        ValueError: If two elements of `dim` is same after normalize.
+        ValueError: If any elements of `dim` is out of range.
+
+    Note:
+        Dynamic shape, Dynamic rank and mutable input is not supported in `graph mode (mode=mindspore.GRAPH_MODE)
+        <https://www.mindspore.cn/docs/en/master/model_train/program_form/static_graph.html>`_.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> A = ms.ops.arange(0, 12, dtype=ms.float32).reshape(3, 4)
+        >>> print(ms.ops.matrix_norm_ext(A, ord='fro'))
+        22.494444
+        >>> print(ms.ops.matrix_norm_ext(A, ord='nuc'))
+        24.364643
+        >>> print(ms.ops.matrix_norm_ext(A, ord=float('inf')))
+        38.0
+        >>> print(ms.ops.matrix_norm_ext(A, ord=float('-inf')))
+        6.0
+    """
+    ndim = A.ndim
+    row_axis, col_axis = _check_matrix_norm_axis(dim, ndim)
+    _check_matrix_norm_ord(ord)
+    if ord == 'fro':
+        return vector_norm_ext(A, 2, dim, keepdim, dtype=dtype)
+    if ord == 'nuc':
+        res = _multi_svd_norm(A, row_axis, col_axis, 'sum')
+        return _reshape_matrix_norm(A, res, dim, keepdim)
+    if ord == 2:
+        res = _multi_svd_norm(A, row_axis, col_axis, 'amax')
+        return _reshape_matrix_norm(A, res, dim, keepdim)
+    if ord == -2:
+        res = _multi_svd_norm(A, row_axis, col_axis, 'amin')
+        return _reshape_matrix_norm(A, res, dim, keepdim)
+    if ord in [float('inf'), -float('inf')]:
+        row_axis, col_axis = col_axis, row_axis
+    if not keepdim and col_axis > row_axis:
+        col_axis -= 1
+    if ord < 0:
+        return ops.amin(vector_norm_ext(A, 1, row_axis, keepdim, dtype=dtype), col_axis, keepdim)
+    return ops.amax(vector_norm_ext(A, 1, row_axis, keepdim, dtype=dtype), col_axis, keepdim)
+
+
+@_primexpr
+def _check_linalg_norm_input(dim, ord, ndim):
+    """dim check"""
+    if dim is None:
+        if ord is not None and ndim > 2:
+            raise ValueError("For `linalg.norm`, the input must be 1D or 2D when `ord` is specified but `dim` is None.")
+        dim = tuple(range(ndim))
+        if (ord is None) or (ord == 'fro' and ndim == 2) or (ord == 2 and ndim == 1):
+            return dim, True
+        return dim, False
+    if isinstance(dim, int):
+        dim = (dim,)
+    elif isinstance(dim, (list, tuple)):
+        if len(dim) > 2:
+            raise ValueError(f"For `linalg.norm`, the length of `dim` must be 1 or 2 when dim is not None",
+                             f"but got {len(dim)}.")
+    else:
+        raise TypeError(f'For `linalg.norm`, the dim should be int, list of int or tuple of int, but got {type(dim)}')
+    return dim, False
+
+
+def linalg_norm(A, ord=None, dim=None, keepdim=False, *, dtype=None):
+    r"""
+    Returns the matrix norm or vector norm of a given tensor.
+
+    `ord` is the calculation mode of norm. The following norm modes are supported.
+
+    ====================== ================================ ==========================================
+    `ord`                   norm for matrices               norm for vectors
+    ====================== ================================ ==========================================
+    `None` (default)        Frobenius norm                   `2`-norm (see below)
+    `'fro'`                 Frobenius norm                   -- not supported --
+    `'nuc'`                 nuclear norm                     -- not supported --
+    `inf`                   :math:`max(sum(abs(x), dim=1))`  :math:`max(abs(x))`
+    `-inf`                  :math:`min(sum(abs(x), dim=1))`  :math:`min(abs(x))`
+    `0`                     -- not supported --              :math:`sum(x != 0)`
+    `1`                     :math:`max(sum(abs(x), dim=0))`  as below
+    `-1`                    :math:`min(sum(abs(x), dim=0))`  as below
+    `2`                     largest singular value           as below
+    `-2`                    smallest singular value          as below
+    other `int` or `float`  -- not supported --              :math:`sum(abs(x)^{ord})^{(1 / ord)}`
+    ====================== ================================ ==========================================
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        A (Tensor): Tensor of shape :math:`(*, n)` or :math:`(*, m, n)` where * is zero or more batch dimensions.
+        ord (Union[int, float, inf, -inf, 'fro', 'nuc'], optional): norm's mode. refer to the table above for
+            behavior. Default: ``None`` .
+        dim (Union[int, Tuple(int)], optional): calculate the dimension of vector norm or matrix norm.
+            Default: ``None`` .
+
+            - When `dim` is int, it will be calculated by vector norm.
+
+            - When `dim` is a 2-tuple, it will be calculated by matrix norm.
+
+            - If `dim` is None and `ord` is None, `A` will be flattened to 1D and the 2-norm
+              of the vector will be calculated.
+
+            - If `dim` is None and `ord` is not None, `A` must be 1D or 2D.
+
+        keepdim (bool): whether the output Tensor retains the original dimension. Default: ``False`` .
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): When set, `A` will be converted to the specified type,
+            `dtype`, before execution, and dtype of returned Tensor will also be `dtype`. Default: ``None`` .
+
+    Returns:
+        Tensor, the result of norm calculation on the specified dimension, `dim`, has the same dtype as `A`.
+
+    Raises:
+        ValueError: If `dim` is out of range.
+        TypeError: If `dim` is neither an int nor a tuple of int.
+        TypeError: If `A` is a vector and `ord` is a str.
+        ValueError: If `A` is a matrices and `ord` is not in valid mode.
+        ValueError: If two elements of `dim` is same after normalize.
+        ValueError: If any elements of `dim` is out of range.
+
+    Note:
+        Dynamic shape, Dynamic rank and mutable input is not supported in `graph mode (mode=mindspore.GRAPH_MODE)
+        <https://www.mindspore.cn/docs/en/master/model_train/program_form/static_graph.html>`_.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore import ops
+        >>> data_range = ops.arange(-13, 13, dtype=ms.float32)
+        >>> x = data_range[data_range != 0]
+        >>> print(ops.function.math_func.linalg_norm(x))
+        38.327538
+        >>> print(ops.function.math_func.linalg_norm(x, 1))
+        169.0
+        >>> n = ops.arange(27, dtype=ms.float32).reshape(3, 3, 3)
+        >>> print(ops.function.math_func.linalg_norm(n, dim=(1, 2)))
+        [14.282857 39.76179  66.45299 ]
+        >>> print(ops.function.math_func.linalg_norm(n[0, :, :]))
+        14.282857
+        >>> print(ops.function.math_func.linalg_norm(n[1, :, :]))
+        39.76179
+    """
+    dim, immediate = _check_linalg_norm_input(dim, ord, A.ndim)
+    if immediate:
+        return vector_norm_ext(A, 2, dim, keepdim, dtype=dtype)
+    if ord is not None:
+        if ord in ['fro', 'nuc'] or (dim is not None and len(dim) == 2) or (dim is None and A.ndim == 2):
+            return matrix_norm_ext(A, ord, dim, keepdim, dtype=dtype)
+        return vector_norm_ext(A, ord, dim, keepdim, dtype=dtype)
+    return vector_norm_ext(A, 2, dim, keepdim, dtype=dtype)
 
 
 def norm_ext(input, p='fro', dim=None, keepdim=False, *, dtype=None):
@@ -7508,46 +8589,44 @@ def norm_ext(input, p='fro', dim=None, keepdim=False, *, dtype=None):
     ====================== ================================ ==========================================
     `p`                     norm for matrices               norm for vectors
     ====================== ================================ ==========================================
-    `None` (default)        Frobenius norm                   `2`-norm (see below)
     `'fro'`                 Frobenius norm                   -- not supported --
     `'nuc'`                 nuclear norm                     -- not supported --
-    `inf`                   :math:`max(sum(abs(x), dim=1))`  :math:`max(abs(x))`
-    `-inf`                  :math:`min(sum(abs(x), dim=1))`  :math:`min(abs(x))`
-    `0`                     -- not supported --              :math:`sum(x != 0)`
-    other `int` or `float`  -- not supported --              :math:`sum(abs(x)^{ord})^{(1 / ord)}`
+    other `int` or `float`  -- not supported --              :math:`sum(abs(x)^{p})^{(1 / p)}`
     ====================== ================================ ==========================================
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
 
     Args:
-        input (Tensor): The input of norm with data type of bfloat16, float16 or float32.
-            The shape is :math:`(*)` where :math:`*` means, any number of additional dimensions.
-        p (Union[int, float, inf, -inf, 'fro', 'nuc'], optional): norm's mode. refer to the table above for
+        input (Tensor): The shape is :math:`(*)` or :math:`(*, m, n)`
+            where :math:`*` means, any number of additional dimensions.
+        p (Union[bool, int, float, inf, -inf, 'fro', 'nuc'], optional): norm's mode. refer to the table above for
             behavior. Default: ``fro`` .
-        dim (Union[int, Tuple(int)], optional): calculate the dimension of vector norm or matrix norm.
+        dim (Union[int, List(int), Tuple(int)], optional): calculate the dimension of vector norm or matrix norm.
             Default: ``None`` .
-        keepdim (bool): whether the output Tensor retains the original dimension. Default: ``False`` .
+        keepdim (bool, optional): whether the output Tensor retains the original dimension. Default: ``False`` .
 
     Keyword Args:
         dtype (:class:`mindspore.dtype`, optional): When set, `input` will be converted to the specified type,
             `dtype`, before execution, and dtype of returned Tensor will also be `dtype`. Default: ``None`` .
 
     Returns:
-        Tensor, the result of norm calculation on the specified dimension, `dim`, has the same dtype as `input`.
+        Tensor, the result of norm calculation on the specified dimension, `dim`.
 
     Raises:
+        TypeError: If `input` is not a Tensor.
         ValueError: If `dim` is out of range.
         TypeError: If `dim` is neither an int nor a tuple of int.
-        ValueError: If two elements of `dim` is same after normalize.
+        ValueError: If two elements of `dim` is same after normalized.
         ValueError: If any elements of `dim` is out of range.
 
+    Note:
+        Dynamic shape, Dynamic rank and mutable input is not supported in `graph mode (mode=mindspore.GRAPH_MODE)
+        <https://www.mindspore.cn/docs/en/master/model_train/program_form/static_graph.html>`_.
+
     Supported Platforms:
         ``Ascend``
 
-    Note:
-        Currently, it only support `ops.function.math_func.norm_ext(input, p=number)`.
-
     Examples:
         >>> import mindspore as ms
         >>> from mindspore import ops
@@ -7559,25 +8638,19 @@ def norm_ext(input, p='fro', dim=None, keepdim=False, *, dtype=None):
     """
     if not isinstance(input, (Tensor, Tensor_)):
         raise TypeError(f"For `norm_ext`, the `input` must be Tensor!, but get {type(input)}.")
-
-    if (dim is not None) or keepdim or (dtype is not None):
-        raise ValueError(f"For `norm_ext`, the value of `dim`, `keepdim` and `dtype` must be default value currently.")
-
-    if isinstance(p, (int, float)):
-        if float(p) in [0.0, 1.0, 2.0, 3.0]:
-            return norm_op(input, p, dim, keepdim, dtype)
-        if input.dtype in [mstype.bfloat16, mstype.float16, mstype.float32]:
-            return lp_norm_v2_op(input, p, dim, keepdim, 0.0)
-        dtype = input.dtype
-        input = ops.cast(input, mstype.float32)
-        return ops.cast(lp_norm_v2_op(input, p, dim, keepdim, 0.0), dtype)
-
+    if isinstance(p, (bool, int, float)):
+        return vector_norm_ext(input, p, dim, keepdim, dtype=dtype)
     if p == 'fro':
         if isinstance(dim, (list, tuple)) and len(dim) > 2:
             raise ValueError(f"For `norm_ext`, the size of `dim` cannot be greater than 2 "
-                             f"when the mode of norm is `fro`.")
-        return norm_op(input, 2.0, dim, keepdim, dtype)
-    raise ValueError(f"For `norm_ext`, the value of `p` cannot be `{p}` currently.")
+                             f"when the norm mode is `fro`.")
+        return linalg_vector_norm_op(input, 2.0, dim, keepdim, dtype)
+    if p == 'nuc':
+        dim = tuple(range(input.ndim)) if dim is None else dim
+        return matrix_norm_ext(input, p, dim, keepdim, dtype=dtype)
+    raise ValueError(f"For `norm_ext`, the value of `p` must be one of [int, float, inf, -inf, 'fro', 'nuc',] "
+                     f"but got `{p}`.")
+
 
 def vector_norm(x, ord=2, axis=None, keepdims=False, *, dtype=None):
     r"""
@@ -7671,7 +8744,7 @@ def vector_norm(x, ord=2, axis=None, keepdims=False, *, dtype=None):
 @_primexpr
 def _check_matrix_norm_axis(axis, ndim):
     """matrix_norm axis check"""
-    if not isinstance(axis, tuple):
+    if not isinstance(axis, (list, tuple)):
         raise TypeError(f'For matrix_norm , the axis should be tuple of int, but got {type(axis)}')
     if len(axis) != 2:
         raise ValueError(f'For matrix_norm, the length of axis should be 2, but got {len(axis)}.')
@@ -7741,21 +8814,21 @@ def matrix_norm(A, ord='fro', axis=(-2, -1), keepdims=False, *, dtype=None):
     Examples:
         >>> import mindspore as ms
         >>> A = ms.ops.arange(0, 12, dtype=ms.float32).reshape(3, 4)
-        >>> print(ms.ops.matrix_norm(x, ord='fro'))
+        >>> print(ms.ops.matrix_norm(A, ord='fro'))
         22.494444
-        >>> print(ms.ops.matrix_norm(x, ord='nuc'))
+        >>> print(ms.ops.matrix_norm(A, ord='nuc'))
         24.364643
-        >>> print(ms.ops.matrix_norm(x, ord=float('inf')))
+        >>> print(ms.ops.matrix_norm(A, ord=float('inf')))
         38.0
-        >>> print(ms.ops.matrix_norm(x, ord=float('-inf')))
+        >>> print(ms.ops.matrix_norm(A, ord=float('-inf')))
         6.0
-        >>> print(ms.ops.vector_norm(x, ord=1))
+        >>> print(ms.ops.vector_norm(A, ord=1))
         21.0
-        >>> print(ms.ops.vector_norm(x, ord=-1))
+        >>> print(ms.ops.vector_norm(A, ord=-1))
         12.0
-        >>> print(ms.ops.vector_norm(x, ord=2))
+        >>> print(ms.ops.vector_norm(A, ord=2))
         22.409302
-        >>> print(ms.ops.vector_norm(x, ord=-2))
+        >>> print(ms.ops.vector_norm(A, ord=-2))
         1.672928e-07
     """
     ndim = A.ndim
@@ -8707,6 +9780,8 @@ def log2(input):
         >>> print(output)
         [1. 2. 3.]
     """
+    if input.dtype == mstype.bool_:
+        input = input.astype(mstype.int64)
     x_dtype = dtype_(input)
     denominator = log_(_make_tensor(2, x_dtype))
     frac_log = log_(input)
@@ -9424,7 +10499,7 @@ def trapz(y, x=None, *, dx=1.0, dim=-1):
         TypeError: If `y` is not a Tensor.
         TypeError: If `x` is not None and is not a Tensor.
         TypeError: If `dx` is not a float number.
-        TypeError: If `dim` is not a Integer.
+        TypeError: If `dim` is not an integer.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -9477,7 +10552,7 @@ def cholesky(input_x, upper=False):
     Args:
         input_x (Tensor): Tensor of shape :math:`(*, N, N)`, where :math:`*` is zero or more batch dimensions
             consisting of symmetric positive-definite matrices, with float32 or float64 data type.
-        upper (bool): If `upper` is `True`, returns an upper-triangular matrix. If `upper` is `False`, returns
+        upper (bool, optional): If `upper` is `True`, returns an upper-triangular matrix. If `upper` is `False`, returns
             a lower-triangular matrix. Default: ``False`` .
 
     Returns:
@@ -9630,7 +10705,7 @@ def cross(input, other, dim=None):
             found with the size `3`. Default: ``None``.
 
     Returns:
-        Tensor, has the same shape and type as input `input`.
+        Tensor, has the same shape and type as `input`.
 
     Raises:
         TypeError: If `input` is not a Tensor.
@@ -9794,7 +10869,7 @@ def cumprod(input, dim, dtype=None):
         y_i = x_1 * x_2 * x_3 * ... * x_i
 
     Args:
-        input (Tensor[Number]): The input tensor.
+        input (Tensor): The input tensor.
             :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
         dim (int): The dimensions to compute the cumulative product. Only constant value is allowed.
         dtype (:class:`mindspore.dtype`, optional): The desired data type of output.
@@ -10034,53 +11109,12 @@ def polygamma(n, input):
     return poly_gamma_(n, input)
 
 
-def isinf(input):
-    r"""
-    Determines which elements are inf or -inf for each position.
-
-    .. math::
-
-        out_i = \begin{cases}
-          & \ True,\ \text{ if } x_{i} = \text{Inf} \\
-          & \ False,\ \text{ if } x_{i} \ne  \text{Inf}
-        \end{cases}
-
-    where :math:`Inf` means not a number.
-
-    Args:
-        input (Tensor): The input tensor.
-
-    Returns:
-        Tensor, has the same shape of input, and the dtype is bool.
-
-    Raises:
-        TypeError: If `input` is not a Tensor.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32)
-        >>> output = ops.isinf(x)
-        >>> print(output)
-        [False False True]
-        >>> x = Tensor(2.1, mindspore.float64)
-        >>> output = ops.isinf(x)
-        >>> print(output)
-        False
-    """
-    return isinf_(input)
-
-
 def _is_sign_inf(x, fn):
     """Tests element-wise for infinity with sign."""
     shape = x.shape
     zeros_tensor = zeros_(shape, mstype.float32)
     ones_tensor = ones_(shape, mstype.float32)
-    is_inf = isinf_(x)
+    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)
@@ -10091,6 +11125,9 @@ def isposinf(input):
     """
     Tests element-wise for positive infinity.
 
+    .. warning::
+        For Ascend, it is only supported on platforms above Atlas A2.
+
     Args:
         input (Tensor): Input values.
 
@@ -10119,6 +11156,9 @@ def isneginf(input):
     """
     Tests element-wise for negative infinity.
 
+    .. warning::
+        For Ascend, it is only supported on platforms above Atlas A2.
+
     Args:
         input (Tensor): Input Tensor.
 
@@ -10161,7 +11201,7 @@ def logical_xor(input, other):
 
     Raises:
         TypeError: If the dtype of `input` or `other` is not bool or can not be implicitly converted to bool.
-        ValueError: If the shape of two inputs cannot be broadcast.
+        ValueError: If the shapes of two inputs cannot be broadcast.
 
     Supported Platforms:
         ``Ascend`` ``CPU``
@@ -10482,7 +11522,7 @@ def tanhshrink(input):
 
     if input.dtype in mstype.int_type + mstype.uint_type:
         input = input.astype(mstype.float32)
-    return input - tanh_(input)
+    return input - tanh(input)
 
 
 def zeta(input, other):
@@ -11412,34 +12452,18 @@ def _calc_new_shape(shape, axes, position=0):
 
 def tensor_dot(x1, x2, axes):
     """
-    Computation of Tensor contraction on arbitrary axes between tensors `a` and `b`.
-
-    Contraction allows for the summation of products of elements of `a` and `b` on specified axes.
-    The same number of axes must be specified for both x1 and x2, and values must be within range
-    of number of dims of both `a` and `b`.
-
-    Selected dims in both inputs must also match.
-
-    axes = 0 leads to outer product.
-    axes = 1 leads to normal matrix multiplication when inputs both 2D.
-    axes = 1 is the same as axes = ((1,),(0,)) where both `a` and `b` are 2D.
-    axes = 2 is the same as axes = ((1,2),(0,1)) where both `a` and `b` are 3D.
+    Compute the tensor dot product along the specified axes.
 
     Args:
-        x1 (Tensor): First tensor in tensor_dot with datatype float16 or float32
-        x2 (Tensor): Second tensor in tensor_dot with datatype float16 or float32
-        axes (Union[int, tuple(int), tuple(tuple(int)), list(list(int))]): Single value or
-            tuple/list of length 2 with dimensions specified for `a` and `b` each. If single value `N` passed,
-            automatically picks up last N dims from `a` input shape and first N dims from `b` input shape in order
-            as axes for each respectively.
+        x1 (Tensor): Input tensor.
+        x2 (Tensor): Input tensor.
+        axes (Union[int, tuple(int), tuple(tuple(int)), list(list(int))]): The number of dimensions to sum over. If an
+            integer `k` is provided, then sum over the last `k` axes of `x1` and the first `k` axes of `x2`, in order.
+            If a tuple or list is provided, then `axes[0]` specifies the axes of `x1` and `axes[1]` specifies the axes
+            of `x2`.
 
     Returns:
-        Tensor, the shape of the output tensor is :math:`(N + M)`, where :math:`N` and :math:`M` are the free axes not
-        contracted in both inputs.
-
-    Raises:
-        TypeError: If `x1` or `x2` is not a Tensor.
-        TypeError: If `axes` is not one of the following: int, tuple, list.
+        Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -11499,6 +12523,8 @@ def vecdot(x, y, *, axis=-1):
         y (Tensor): Second batch of vectors. The shape of Tensor is :math:`(*,N)`
             where :math:`*` means, any number of additional dimensions. Supporting broadcasting.
             The dtype of Tensor should be one of the following types: float, double, int, complex64 and complex128.
+
+    Keyword Args:
         axis (int): Dimension across which to calculate the dot product. Default: ``-1`` .
 
     Returns:
@@ -11926,15 +12952,16 @@ def round(input, *, decimals=0):
         input (Tensor): The input tensor.
 
     Keyword Args:
-        decimals (int, optional): Number of decimal places to round to (default: 0). If decimals is negative,
+        decimals (int, optional): Number of decimal places to round to (default: ``0``). If decimals is negative,
             it specifies the number of positions to the left of the decimal point. It supports converting the
-            single-element tensor to an int.
+            single-element tensor to an int. When `input` type is int32 or int64, the `decimals` should be 0.
 
     Returns:
         Tensor, has the same shape and type as the `input`.
 
     Raises:
         TypeError: If `input` is not a Tensor.
+        RuntimeError: If `input` type is int32 or int64, the `decimals` is not 0.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -11955,6 +12982,344 @@ def round(input, *, decimals=0):
     return round_op(input, decimals)
 
 
+def isnan_ext(tensor):
+    r"""
+    Returns a new tensor with boolean elements representing if each element of input is :math:`Nan` or not.
+    Complex values are considered NaN when either their real and/or imaginary part is :math:`Nan`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input tensor.
+
+    Returns:
+        Tensor, return a Boolean Tensor. If the input is :math:`Nan`, the value is ``True``.
+        Otherwise, the value is ``False``.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> input1 = Tensor([np.nan, 2, 3, 4])
+        >>> output = ms.mint.isnan(input1)
+        >>> print(output)
+        [ True  False  False  False]
+    """
+    return not_equal_op(tensor, tensor)
+
+
+def rotated_iou(boxes, query_boxes, trans=False, mode=0, is_cross=True, v_threshold=0.0, e_threshold=0.0):
+    r"""
+    Calculate the overlap area between rotated rectangles.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    .. note::
+        The input data types supported by the Ascend platform include
+        bfloat16, float16, float32.
+
+    Args:
+        boxes (Tensor): The first set of rectangles which has a
+            shape of :math:`(B, N, 5)`.
+        query_boxes (Tensor): The second set of rectangles which
+            has a shape of :math:`(B, K, 5)`.
+        trans (bool): Distinguish the rectangles representations
+            of boxes and query_boxes. If ``True``, the format of boxes
+            and query_boxes is ``'xyxyt'``, else the format is ``'xywht'``.
+            The default value is ``False``.
+        mode (int): Distinguish the calculation mode. If the value
+            is ``1``, the calculation mode is ``'iof'``, else the
+            calculation mode is ``'iou'``. The default value is ``0``.
+        is_cross (bool): If ``True``, use cross-calculation, else use
+            one-to-one calculation. The default value is ``True``.
+        v_threshold (float): Provide condition relaxation for
+            intersection calculation. The default value is ``0.0``.
+        e_threshold (float): Provide condition relaxation for
+            intersection calculation. The default value is ``0.0``.
+
+    Returns:
+        Tensor, the shape is :math:`(B, N, K)`.
+
+    Raises:
+        TypeError: If `boxes` is not a Tensor.
+        TypeError: If `query_boxes` is not a Tensor.
+        ValueError: If `boxes` and `query_boxes` do not has same first dim.
+        ValueError: If the third dimension of `boxes` or `query_boxes` is not ``5``.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> a = np.random.uniform(0,1,(2,2,5)).astype(np.float16)
+        >>> b = np.random.uniform(0,1,(2,3,5)).astype(np.float16)
+        >>> box1 = Tensor(a)
+        >>> box2 = Tensor(b)
+        >>> output = ops.rotated_iou(box1, box2, trans=False, mode=0, is_cross=True)
+    """
+    origin_dtype = boxes.dtype
+    if (origin_dtype != mstype.float16 and origin_dtype != mstype.float32
+            and origin_dtype != mstype.bfloat16):
+        raise ValueError(f"input boxes type is illegal.")
+
+    if (query_boxes.dtype != mstype.float16 and query_boxes.dtype != mstype.float32
+            and query_boxes.dtype != mstype.bfloat16):
+        raise ValueError(f"input query_boxes type is illegal.")
+
+    boxes_perm = (0, 2, 1)
+    boxes_cp = permute(boxes, boxes_perm)
+    if boxes_cp.dtype == mstype.float16 or boxes_cp.dtype == mstype.bfloat16:
+        boxes_cp = cast_(boxes_cp, mstype.float32)
+
+    query_boxes_perm = (0, 2, 1)
+    query_boxes_cp = permute(query_boxes, query_boxes_perm)
+    if query_boxes_cp.dtype == mstype.float16 or query_boxes_cp.dtype == mstype.bfloat16:
+        query_boxes_cp = cast_(query_boxes_cp, mstype.float32)
+
+    iou = rotated_iou_op(boxes_cp, query_boxes_cp, trans, mode, is_cross, v_threshold, e_threshold)
+    return cast_(iou, origin_dtype)
+
+
+def mul_ext(input, other):
+    r"""
+    Multiply other value by input Tensor.
+
+    .. math::
+
+        out_{i} = input_{i} \times other_{i}
+
+    Note:
+        - When the two inputs have different shapes, they must be able to broadcast to a common shape.
+        - The two inputs comply with the implicit type conversion rules to make the data types
+          consistent.
+
+    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/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+        other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
+            a bool or a tensor whose data type is
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+
+    Returns:
+        Tensor with a shape that is the same as the broadcasted shape of the input `input` and `other`,
+        and the data type is the one with higher precision or higher digits among the two inputs.
+
+    Raises:
+        TypeError: If the type of `input`, `other` is not one of the following: Tensor, number.Number, bool.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore import ops
+        >>> x = Tensor(np.array([2, 6, 9]).astype(np.int32))
+        >>> y = Tensor(np.array([4, 5, 6]).astype(np.float32))
+        >>> output = ops.mul_ext(x, y)
+        >>> print(output)
+        [8. 30. 54.]
+        >>> # the data type of x is int32, the data type of y is float32,
+        >>> # and the output is the data format of higher precision float32.
+        >>> print(output.dtype)
+        Float32
+    """
+    if isinstance(other, (float, int, bool)) and isinstance(input, Tensor):
+        return muls(input, other)
+    return mul(input, other)
+
+
+def _for_each_transpose(inputs):
+    inputs_t = []
+    for input_i in inputs:
+        input_i_t = transpose_ext(input_i, -1, -2)
+        inputs_t.append(input_i_t)
+    return inputs_t
+
+
+def _is_transposed(input_tensor):
+    dim = input_tensor.dim()
+    if dim < 2 or dim > 3:
+        raise ValueError("input tensor of _is_transposed should be either 2- or 3-dimensional.")
+    input_shape = input_tensor.shape
+    input_strides = input_tensor.stride()
+    if input_strides[-2] == 1 and input_strides[-1] == input_shape[-2]:
+        return True
+    return False
+
+
+def gmm(x, weight, *, bias=None, group_list=None, group_type=0):
+    r"""
+    Grouping matrix multiplication.
+
+    .. warning::
+        - This is an experimental API that is subject to change or deletion.
+        - `group_type` must be constant.
+
+    .. note::
+        - When `group_type` is 2, `weight` must be a non-continuous tensor after transpose.
+        - Only when `group_type` is 0 and `bias` is None, the reverse derivative is supported，
+          which is implemented by the function gmm_backward.
+
+    Args:
+        x (tuple[Tensor]): The first tensors to be multiplied.
+        weight (tuple[Tensor]): The second tensors to be multiplied.
+
+    Keyword Args:
+        bias (tuple[Tensor], optional): Biases added to outputs. In the training scenario,
+            the bias only supoorts None. Default: ``None`` .
+
+        group_list (Union[list[int], tuple(int)], optional): Represents the index of
+            the different groups on the grouping axis.  It must be a non-negative ascending
+            sequence . Default: ``None`` .
+
+            If `group_type` is 0, the last element in `group_list` should be equal to the
+            first dimension of the tensor in `x` .
+
+            If `group_type` is 2, the last element in `group_list` should be equal to the
+            second dimension of the tensor in `x` .
+
+        group_type (int, optional): Represents the dim that need to be grouped. Default: ``0`` .
+            For example, :math: `C[m,n] = A[m,k] \times B[k,n]`.
+
+            If `group_type` is 0, it means that the m-axis is grouped, where tensors in `x`
+            should be 2-D, tensors in `weight` should be 3-D, and the tensors of result would
+            be 2-D.
+
+            If `group_type` is 2, it means that the k-axis is grouped, where each tensor in `x`
+            and `weight` should be 2-D, and the tensors of result would be 3-D.
+
+    Returns:
+        tuple[Tensor], the results of grouping matrix multiplication.
+
+    Raises:
+        TypeError: If `group_type` is not a int.
+        ValueError: If `group_type` is invalid.
+        ValueError: If the length of `x` or `weight` is not 1.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.random.uniform(0,1, (10, 20)).astype(np.float32))
+        >>> weight = Tensor(np.random.uniform(0,1, (4, 20, 8)).astype(np.float32))
+        >>> group_list = [2, 6, 8, 10]
+        >>> y = ops.function.math_func.gmm([x,], [weight,], group_list=group_list)
+        >>> print(y[0].shape)
+        >>> [10, 8]
+    """
+    return grouped_matmul_v2(x, weight, bias=bias, group_list=group_list,
+                             split_item=3, group_type=group_type)
+
+
+def gmm_backward(grad, x, weight, *, group_list=None):
+    r"""
+    the grad of gmm
+    """
+    gradients = ops.auto_generate.gmm_backward(grad, x, weight, group_list)
+    dx = gradients[:len(x)]
+    dw = gradients[-len(weight):]
+    db = []
+    return dx, dw, db
+
+
+def gmm_v2(x, weight, *, bias=None, group_list=None, group_type=0, group_list_type=0):
+    r"""
+    Grouping matrix multiplication.
+
+    .. warning::
+        - This is an experimental API that is subject to change or deletion.
+        - `group_type` must be constant.
+
+    .. note::
+        - When `group_type` is 2, the tensors in `weight` must be non-continuous tensors after
+          transpose.
+        - Only when `group_type` is 0 and `bias` is None, the reverse derivative is supported,
+          which is implemented by the function gmm_v2_backward.
+
+    Args:
+        x (tuple[Tensor]): The first tensors to be multiplied.
+        weight (tuple[Tensor]): The second tensors to be multiplied.
+
+    Keyword Args:
+        bias (tuple[Tensor], optional): Biases added to outputs. In the training scenario,
+            the bias only supoorts None. Default: ``None`` .
+
+        group_list (Tensor, optional): Represents the index of the different groups on
+            the grouping axis. Supported dtypes: int64. Default: ``None`` .
+
+            If `group_list_type` is 0, it must be a non-negative ascending sequence.
+            And when `group_type` is 0, the last element in `group_list` should be equal to
+            the first dimension of the tensor in `x` . When `group_type` is 2, the last element
+            in `group_list` should be equal to the second dimension of the tensor in `x` .
+
+            If `group_list_type` is 1, the value in `group_list` are the size of each group.
+
+        group_type (int, optional): Represents the axes that need to be grouped. For example,
+            :math: `C[m,n] = A[m,k] \times B[k,n]`. Default: ``0`` .
+
+            If `group_type` is 0, it means that the m-axis is grouped, where tensors in `x`
+            should be 2-D, tensors in `weight` should be 3-D, and the tensors of result would be
+            2-D.
+
+            If `group_type` is 2, it means that the k-axis is grouped, where each tensor in `x`
+            and `weight` should be 2-D, and the tensors of result would be 3-D.
+
+        group_list_type (int, optional): If it's 0, the value in `group_list` are the cumsum
+            result of the size of each group. If it's 1, the value in `group_list` are the size
+            of each group.
+
+    Returns:
+        tuple[Tensor], the results of grouping matrix multiplication.
+
+    Raises:
+        TypeError: If `group_type` is not a int.
+        ValueError: If `group_type` is invalid.
+        ValueError: If the length of `x` or `weight` is not 1.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.random.uniform(0,1, (10, 20)).astype(np.float32))
+        >>> weight = Tensor(np.random.uniform(0,1, (4, 20, 8)).astype(np.float32))
+        >>> group_list = Tensor([2, 4, 2, 2])
+        >>> y = ops.function.math_func.gmm_v2([x,], [weight,], group_list=group_list, group_list_type=1)
+        >>> print(y[0].shape)
+        >>> [10, 8]
+    """
+    return grouped_matmul_v4(x, weight, bias=bias, group_list=group_list, split_item=3,
+                              group_type=group_type, group_list_type=group_list_type, act_type=0)
+
+
+def gmm_v2_backward(grad, x, weight, *, group_list=None, group_list_type=0):
+    r"""
+    the grad of gmm_v2
+    """
+    gradients = ops.auto_generate.gmm_v2_backward(grad, x, weight, group_list, group_list_type)
+    dx = gradients[:len(x)]
+    dw = gradients[-len(weight):]
+    db = []
+
+    return dx, dw, db
+
+
 __all__ = [
     'addn',
     'absolute',
@@ -12041,6 +13406,7 @@ __all__ = [
     'inplace_sub',
     'isfinite',
     'isnan',
+    'isnan_ext',
     'isclose',
     'isreal',
     'isneginf',
@@ -12086,6 +13452,7 @@ __all__ = [
     'sinh',
     'cosh',
     'tanh',
+    'tanh_',
     'tanhshrink',
     'asinh',
     'arcsinh',
@@ -12147,6 +13514,7 @@ __all__ = [
     'atleast_1d',
     'dstack',
     'diff',
+    'diff_ext',
     'atleast_2d',
     'cartesian_prod',
     'atleast_3d',
@@ -12177,6 +13545,7 @@ __all__ = [
     'signbit',
     'accumulate_n',
     'iou',
+    'rotated_iou',
     'baddbmm',
     'baddbmm_ext',
     'bmm',