mindspore 2.4.10__cp311-cp311-win_amd64.whl → 2.6.0__cp311-cp311-win_amd64.whl

mindspore/ops/auto_generate/gen_extend_func.py

@@ -17,17 +17,20 @@ from mindspore.common import dtype as mstype
 from mindspore.ops.auto_generate.pyboost_inner_prim import *
 
 
-def acos(input):
+def acosh(input):
     r"""
-    Computes arccosine of input tensors element-wise.
+    Computes inverse hyperbolic cosine of the inputs element-wise.
     
     .. math::
     
-        out_i = \cos^{-1}(input_i)
+        out_i = \cosh^{-1}(input_i)
+    
+    .. note::
+        Given an input tensor input, the function computes inverse hyperbolic cosine of every element.
+        Input range is [1, inf].
     
     Args:
-        input (Tensor): The shape of tensor is
-            :math:`(N,*)`, where :math:`*` means any number of additional dimensions.
+        input (Tensor): The input tensor of inverse hyperbolic cosine function.
     
     Returns:
         Tensor, has the same shape as `input`. The dtype of output is float32 when dtype of `input` is in [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
@@ -42,28 +45,25 @@ def acos(input):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), mindspore.float32)
-        >>> output = ops.acos_ext(input)
+        >>> input = Tensor(np.array([1.0, 1.5, 3.0, 100.0]), mindspore.float32)
+        >>> output = ops.acosh_ext(input)
         >>> print(output)
-        [0.7377037  1.5307857 1.2661037 0.9764114]
+        [0.        0.9624236 1.7627472 5.298292 ]
     """
-    return acos_impl(input)
+    return acosh_impl(input)
 
 
-def acosh(input):
+def acos(input):
     r"""
-    Computes inverse hyperbolic cosine of the inputs element-wise.
+    Computes arccosine of input tensors element-wise.
     
     .. math::
     
-        out_i = \cosh^{-1}(input_i)
-    
-    .. note::
-        Given an input tensor input, the function computes inverse hyperbolic cosine of every element.
-        Input range is [1, inf].
+        out_i = \cos^{-1}(input_i)
     
     Args:
-        input (Tensor): The input tensor of inverse hyperbolic cosine function.
+        input (Tensor): The shape of tensor is
+            :math:`(N,*)`, where :math:`*` means any number of additional dimensions.
     
     Returns:
         Tensor, has the same shape as `input`. The dtype of output is float32 when dtype of `input` is in [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
@@ -78,12 +78,12 @@ def acosh(input):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([1.0, 1.5, 3.0, 100.0]), mindspore.float32)
-        >>> output = ops.acosh_ext(input)
+        >>> input = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), mindspore.float32)
+        >>> output = ops.acos_ext(input)
         >>> print(output)
-        [0.        0.9624236 1.7627472 5.298292 ]
+        [0.7377037  1.5307857 1.2661037 0.9764114]
     """
-    return acosh_impl(input)
+    return acos_impl(input)
 
 
 def adaptive_avg_pool2d_grad(grad_output, x):
@@ -93,6 +93,13 @@ def adaptive_avg_pool2d_grad(grad_output, x):
     return adaptive_avg_pool2d_grad_impl(grad_output, x)
 
 
+def adaptive_avg_pool3d(input, output_size):
+    r"""
+    None
+    """
+    return adaptive_avg_pool3d_impl(input, output_size)
+
+
 def add(input, other, alpha=1):
     r"""
     Adds scaled other value to input Tensor.
@@ -151,14 +158,38 @@ def add(input, other, alpha=1):
 
 def argmax(input, dim=None, keepdim=False):
     r"""
+    argmax(input) -> Tensor
+    
+    Return the indices of the maximum values of a tensor.
+    
+    Args:
+        input (Tensor): Input tensor.
+    
+    Returns:
+        Tensor.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore import ops
+        >>> x = Tensor(np.array([[1, 20, 5], [67, 8, 9], [130, 24, 15]]).astype(np.float32))
+        >>> output = ops.auto_generate.argmax_ext(x)
+        >>> print(output)
+        6
+    
+    .. function:: argmax(input, dim, keepdim=False) -> Tensor
+        :noindex:
+    
     Return the indices of the maximum values of a tensor across a dimension.
     
     Args:
         input (Tensor): Input tensor.
-        dim (Union[int, None], optional): The dimension to reduce. If `dim` is ``None`` , the indices of the maximum
-            value within the flattened input will be returned. Default: ``None`` .
+        dim (int): The dimension to reduce. 
         keepdim (bool, optional): Whether the output tensor retains the specified
-            dimension. Ignored if `dim` is None. Default: ``False`` .
+            dimension. Default: ``False`` .
     
     Returns:
         Tensor, indices of the maximum values across a dimension.
@@ -206,46 +237,54 @@ def argmin(input, dim=None, keepdim=False):
     Examples:
         >>> import numpy as np
         >>> from mindspore import Tensor
-        >>> from mindspore import mint
+        >>> from mindspore import ops
         >>> x = Tensor(np.array([[1, 20, 5], [67, 8, 9], [130, 24, 15]]).astype(np.float32))
-        >>> output = mint.argmin(x, dim=-1)
+        >>> output = ops.auto_generate.argmin_ext(x, dim=-1)
         >>> print(output)
         [0 1 2]
     """
     return argmin_impl(input, dim, keepdim)
 
 
-def asin(input):
+def argsort(input, dim=-1, descending=False, stable=False):
     r"""
-    Computes arcsine of input tensors element-wise.
+    Sorts the input tensor along the given dimension in specified order and return the sorted indices.
     
-    .. math::
-    
-        out_i = \sin^{-1}(input_i)
+    .. warning::
+            This is an experimental optimizer API that is subject to change.
     
     Args:
-        input (Tensor): The shape of tensor is
-            :math:`(N,*)`, where :math:`*` means any number of additional dimensions.
+        input(Tensor): The input tensor to sort.
+        dim (int, optional): The dim to sort along. Default: ``-1`` , means the last dimension.
+            The Ascend backend only supports sorting the last dimension.
+        descending (bool, optional): The sort order. If `descending` is ``True`` then the elements
+            are sorted in descending order by value. Otherwise sort in ascending order. Default: ``False`` .
+        stable (bool, optional): Whether to use stable sorting algorithm. Default: ``False``.
     
     Returns:
-        Tensor, has the same shape as `input`. The dtype of output is float32 when dtype of `input` is in [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
+        Tensor, the indices of sorted input tensor. Data type is int64.
     
     Raises:
-        TypeError: If `input` is not a Tensor.
+        ValueError: If `dim` is out of range.
+        TypeError: If dtype of `dim` is not int32.
+        TypeError: If dtype of `descending` is not bool.
+        TypeError: If dtype of `stable` is not bool.
     
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend``
     
     Examples:
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), mindspore.float32)
-        >>> output = ops.asin_ext(input)
-        >>> print(output)
-        [0.8330927  0.04001068  0.30469266  0.59438497 ]
+        >>> x = Tensor(np.array([[8, 2, 1], [5, 9, 3], [4, 6, 7]]), mindspore.float16)
+        >>> sort = ops.auto_generate.argsort_ext(x)
+        >>> print(sort)
+        [[2 1 0]
+         [2 0 1]
+         [0 1 2]]
     """
-    return asin_impl(input)
+    return argsort_impl(input, dim, descending, stable)
 
 
 def asinh(input):
@@ -280,6 +319,39 @@ def asinh(input):
     return asinh_impl(input)
 
 
+def asin(input):
+    r"""
+    Computes arcsine of input tensors element-wise.
+    
+    .. math::
+    
+        out_i = \sin^{-1}(input_i)
+    
+    Args:
+        input (Tensor): The shape of tensor is
+            :math:`(N,*)`, where :math:`*` means any number of additional dimensions.
+    
+    Returns:
+        Tensor, has the same shape as `input`. The dtype of output is float32 when dtype of `input` is in [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
+    
+    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
+        >>> input = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), mindspore.float32)
+        >>> output = ops.asin_ext(input)
+        >>> print(output)
+        [0.8330927  0.04001068  0.30469266  0.59438497 ]
+    """
+    return asin_impl(input)
+
+
 def atan2(input, other):
     r"""
     Returns arctangent of input/other element-wise.
@@ -316,7 +388,7 @@ def atan2(input, other):
         >>> from mindspore import Tensor, ops
         >>> input = Tensor(np.array([0, 1]), mindspore.float32)
         >>> other = Tensor(np.array([1, 1]), mindspore.float32)
-        >>> output = mint.atan2(input, other)
+        >>> output = ops.auto_generate.atan2_ext(input, other)
         >>> print(output)
         [0.        0.7853982]
     """
@@ -356,6 +428,102 @@ def atan(input):
     return atan_impl(input)
 
 
+def avg_pool1d(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True):
+    r"""
+    Applies a 1D average pooling over an input Tensor which can be regarded as a composition of 1D input planes.
+    
+    Typically the input is of shape :math:`(N_{in}, C_{in}, L_{in})`, avg_pool1d outputs regional average in the
+    :math:`(L_{in})`-dimension. Given kernel size as :math:`ks = l_{ker}` and `stride` as :math:`s = s_0`, the
+    operation is as follows.
+    
+    .. math::
+        \text{output}(N_i, C_j, l) = \frac{1}{l_{ker}} \sum_{n=0}^{l_{ker}-1}
+        \text{input}(N_i, C_j, s_0 \times l + n)
+    
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+    
+    Args:
+        input (Tensor): Tensor of shape :math:`(N, C_{in}, L_{in})`.
+        kernel_size (Union(int, tuple[int])): The size of kernel window used to take the average value.
+        stride (Union(int, tuple[int]), optional): The distance of kernel moving. `stride` can either be an int
+            number or a tuple of one int number. Default: ``None``, the same value as `kernel_size`.
+        padding (Union(int, tuple[int]), optional): The pad length to be filled. `padding` can either be an integer
+            or a tuple of one integer. Default: ``0`` .
+        ceil_mode (bool, optional): If True, apply ceil instead of floor to compute the output shape. Default: ``False``.
+        count_include_pad (bool, optional): If True, include the zero-padding in the averaging calculation. Default: ``True`` .
+    
+    Returns:
+        Tensor of shape :math:`(N, C_{in}, L_{out})`.
+    
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `kernel_size` or `stride` is not an int.
+        TypeError: If `ceil_mode` or `count_include_pad` is not a bool.
+        ValueError: If `kernel_size` or `stride` is less than `1`.
+        ValueError: If `kernel_size` or `stride` or `padding` is not int nor a tuple whose length is greater than `1`.
+    
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input_x = Tensor(np.random.randint(0, 10, [1, 3, 6]), mindspore.float32)
+        >>> output = ops.auto_generate.avg_pool1d_ext(input_x, kernel_size=6, stride=1)
+        >>> print(output.shape)
+        (1, 3, 1)
+    """
+    return avg_pool1d_impl(input, kernel_size, stride, padding, ceil_mode, count_include_pad)
+
+
+def bincount(input, weights=None, minlength=0):
+    r"""
+    Count the occurrences of each value in the input.
+    
+    If `minlength` is not specified, the length of the output Tensor is the maximum value in the input plus one.
+    If `minlength` is specified, the length of the output Tensor is the maximum value between `minlength` or
+    the maximum value in the input plus one.
+    
+    Each value in the output Tensor represents the number of occurrences of that index value in the input.
+    If `weights` is specified, the output results are weighted, 
+    i.e., :math:`out[n] += weight[i]` instead of :math:`out[n] += 1`.
+    
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+    
+    Args:
+        input (Tensor): A one-dimensional Tensor.
+        weights (Tensor, optional): Weights with the same shape as the input. Default: ``None``.
+        minlength (int, optional): The minimum length of output Tensor. Should be non-negative. Default: ``0``.
+    
+    Returns:
+        Tensor, If input is non-empty, the output shape is :math:`(max(max(input)+1, minlength), )`,
+        otherwise the shape is :math:`(0, )`.
+    
+    Raises:
+        TypeError: If `input` or `weights` is not a Tensor.
+        ValueError: If `input` contains negative values.
+        ValueError: If `input` is not one-dimensional or `input` and `weights` do not have the same shape.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> from mindspore import ops, Tensor
+        >>> print(ops.auto_generate.bincount_ext(Tensor(np.arange(5))))
+        [1 1 1 1 1]
+        >>> print(ops.auto_generate.bincount_ext(Tensor(np.array([0, 1, 1, 3, 2, 1, 7]))))
+        [1 3 1 1 0 0 0 1]
+        >>> w = Tensor(np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6])) # weights
+        >>> x = Tensor(np.array([0, 1, 1, 2, 2, 2]))
+        >>> print(ops.auto_generate.bincount_ext(x,  weights=w, minlength=5))
+        [0.3 0.7 1.1 0.  0. ]
+    """
+    return bincount_impl(input, weights, minlength)
+
+
 def bmm(input, mat2):
     r"""
     Performs batch matrix-matrix multiplication of two three-dimensional tensors.
@@ -463,13 +631,6 @@ def fold(input, output_size, kernel_size, dilation=1, padding=0, stride=1):
     return fold_impl(input, converted_output_size, converted_kernel_size, converted_dilation, converted_padding, converted_stride)
 
 
-def copy(variable, value):
-    r"""
-    None
-    """
-    return copy_impl(variable, value)
-
-
 def cummin(input, dim):
     r"""
     Returns a tuple (values, indices) where `values` is the cumulative minimum value of input Tensor `input`
@@ -480,6 +641,9 @@ def cummin(input, dim):
             y_{i} = \min(x_{1}, x_{2}, ... , x_{i})
         \end{array}
     
+    .. note::
+        O2 mode is not supported in Ascend.
+    
     Args:
         input (Tensor): The input Tensor, The dimension must be greater than 0.
         dim (int): Operation dimension. The value of `dim` must be in the range `[-input.ndim, input.ndim - 1]`.
@@ -494,9 +658,6 @@ def cummin(input, dim):
         TypeError: If `dim` is not an int.
         ValueError: If `dim` is out the range of `[-input.ndim, input.ndim - 1]`.
     
-    .. note::
-        O2 mode is not supported in Ascend.
-    
     Supported Platforms:
         ``Ascend``
     
@@ -561,6 +722,54 @@ def cumsum(input, dim, dtype=None):
     return cumsum_impl(input, dim, dtype)
 
 
+def diag(input, diagonal=0):
+    r"""
+    If input is a vector (1-D tensor), then returns a 2-D square tensor with the elements of input as the diagonal.
+    
+    If input is a matrix (2-D tensor), then returns a 1-D tensor with the diagonal elements of input.
+    
+    The argument diagonal controls which diagonal to consider:
+    
+    - If `diagonal` = 0, it is the main diagonal.
+    
+    - If `diagonal` > 0, it is above the main diagonal.
+    
+    - If `diagonal` < 0, it is below the main diagonal.
+    
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+    
+    Args:
+        input (Tensor): The input tensor.
+        diagonal (int, optional): the diagonal to consider. Defaults: ``0``.
+    
+    Returns:
+        Tensor, has the same dtype as the `input`, its shape is up to `diagonal`.
+    
+        - If `input` shape is :math:`(x_0)` : then output shape is :math:`(x_0 + \left | diagonal \right | , x_0 + \left | diagonal \right | )` 2-D Tensor.
+    
+        - If `input` shape is :math:`(x_0, x_1)` : then output shape is main diagonal to move :math:`(\left | diagonal \right |)` elements remains elements' length 1-D Tensor.
+    
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        ValueError: If shape of `input` is not 1-D and 2-D.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor([1, 2, 3, 4]).astype('int32')
+        >>> output = ops.auto_generate.diag_ext(input)
+        >>> print(output)
+        [[1 0 0 0]
+         [0 2 0 0]
+         [0 0 3 0]
+         [0 0 0 4]]
+    """
+    return diag_impl(input, diagonal)
+
+
 def elu(input, alpha=1.0):
     r"""
     Exponential Linear Unit activation function.
@@ -652,6 +861,40 @@ def flatten(input, start_dim=0, end_dim=-1):
     return flatten_impl(input, start_dim, end_dim)
 
 
+def frac(input):
+    r"""
+    Calculates the fractional part of each element in the input.
+    
+    .. math::
+        out_i = input_i - \lfloor |input_i| \rfloor * sgn(input_i)
+    
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+    
+    Args:
+        input (Tensor): The input Tensor.
+    
+    Returns:
+        Tensor, has the same shape and type as input.
+    
+    Raises:
+        TypeError: If `input` is not a Tensor.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor([2, 4.2, -2.5], mindspore.float16)
+        >>> output = ops.frac_ext(x)
+        >>> print(output)
+          [ 0.      0.1992 -0.5   ]
+    """
+    return frac_impl(input)
+
+
 def histc(input, bins=100, min=0, max=0):
     r"""
     Computes the histogram of a tensor.
@@ -767,6 +1010,56 @@ def unfold(input, kernel_size, dilation=1, padding=0, stride=1):
     return unfold_impl(input, converted_kernel_size, converted_dilation, converted_padding, converted_stride)
 
 
+def index_add(input, dim, index, source, alpha=1):
+    r"""
+    Accumulate the elements of `alpha` times `source` into the `input` by adding to the index in the order given in `index`. For example, if ``dim == 0`` , ``index[i] == j`` , and ``alpha = -1`` , then the `i` th row of `source` is subtracted from the `j` th row of `input` . The `dim` th dimension of `source` must have the same size as the length of `index` , and all other dimensions must match `input`, or an error will be raised. For a 3-D tensor, the output is defined as follows:
+    
+    .. math::
+        \begin{array}{ll}
+        input[index[i],\ :,\ :]\ +=\ alpha * source[i,\ :,\ :]  \qquad \#if\ dim == 0 \\
+        input[:,\ \ index[i],\ :]\ +=\ alpha * source[:,\ \ i,\ :]  \qquad \#if\ dim == 1 \\
+        input[:,\ :,\ \ index[i]]\ +=\ alpha * source[:,\ :,\ \ i]  \qquad\#if\ dim == 2 \\
+        \end{array}
+        
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+        
+    Args:
+        input (Tensor): The input Tensor.
+        dim (int): The dimension along which to index.
+        index (Tensor): Add the value of "input Tensor" and `source` along the dimension of the `dim` according to the specified index value, with data type int32. The `index` must be 1D with the same size as the size of `source` in the `dim` dimension. The values of `index` should be in [0, b), where the b is the size of "input Tensor" in the `dim` dimension.
+        source (Tensor): The input tensor with the value to add. Must have same data type as "input Tensor". The shape must be the same as "input Tensor" except the `dim` th dimension.
+        alpha (number, optional): The scalar multiplier for source. Default: ``1``.
+        
+    Returns:
+        Tensor, has the same shape and dtype as `input`.
+    
+    Raises:
+        TypeError: If neither `index` nor `source` is a Tensor.
+        ValueError: If the value of `dim` is out of the dimension range of `source` shape.
+        ValueError: If `index` rank is not the same as `source` rank.
+        ValueError: If shape of `index` is not 1D or size of `index` is not equal to dimension of source[dim].
+        ValueError: If the shape of `source` is not the same as that of `input` except the `dim` axis.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), mindspore.float32)
+        >>> index = Tensor(np.array([0, 2]), mindspore.int32)
+        >>> y = Tensor(np.array([[0.5, 1.0], [1.0, 1.5], [2.0, 2.5]]), mindspore.float32)
+        >>> output = ops.auto_generate.index_add_ext(x, 1, index, y, alpha=1)
+        >>> print(output)
+        [[ 1.5  2.   4. ]
+         [ 5.   5.   7.5]
+         [ 9.   8.  11.5]]
+    """
+    return index_add_impl(input, dim, index, source, alpha)
+
+
 def index_select(input, dim, index):
     r"""
     Generates a new Tensor that accesses the values of `input` along the specified `dim` dimension
@@ -813,18 +1106,55 @@ def index_select(input, dim, index):
     return index_select_impl(input, dim, index)
 
 
+def inplace_adds(input, other, alpha=1):
+    r"""
+    None
+    """
+    return inplace_adds_impl(input, other, alpha)
+
+
 def inplace_add(input, other, alpha=1):
     r"""
     None
     """
-    return inplace_add_impl(input, other, alpha)
+    return inplace_add_impl(input, other, alpha)
+
+
+def sub_tensor_(input, other, alpha=1):
+    r"""
+    None
+    """
+    return sub_tensor_impl(input, other, alpha)
 
 
-def inplace_adds(input, other, alpha=1):
+def isneginf(input):
     r"""
-    None
+    Determines which elements are -inf for each position.
+    
+    .. warning::
+        - This API can be used only on the Atlas A2 training series.
+    
+    Args:
+        input (Tensor): Input Tensor.
+    
+    Returns:
+        Tensor with the same shape as the input, where elements are `True` if the corresponding element in the `input` is negative infinity, and `False` otherwise.
+    
+    Raises:
+        TypeError: If the input is not a tensor.
+    
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    
+    Examples:
+        >>> from mindspore import ops, Tensor
+        >>> from mindspore import dtype as mstype
+        >>> output = ops.isneginf(Tensor([[-float("inf"), float("inf")], [1, -float("inf")]], mstype.float32))
+        >>> print(output)
+        [[ True False]
+         [False  True]]
     """
-    return inplace_adds_impl(input, other, alpha)
+    return isneginf_impl(input)
 
 
 def l1_loss(input, target, reduction='mean'):
@@ -908,7 +1238,7 @@ def leaky_relu(input, negative_slope=0.01):
     
     Args:
         input (Tensor): The input of leaky_relu is a Tensor of any dimension.
-        negative_slope (Union[int, float]): Slope of the activation function when the element of `input` is less than 0.
+        negative_slope (Union[int, float], optional): Slope of the activation function when the element of `input` is less than 0.
           Default: ``0.01`` .
     
     Returns:
@@ -933,32 +1263,65 @@ def leaky_relu(input, negative_slope=0.01):
     return leaky_relu_impl(input, negative_slope)
 
 
-def log_softmax(input, dim=None, dtype=None):
+def log10(input):
     r"""
-    Applies the Log Softmax function to the input tensor on the specified axis.
-    Supposes a slice in the given axis, :math:`x` for each element :math:`x_i`,
-    the Log Softmax function is shown as follows:
+    Returns the logarithm to the base 10 of a tensor element-wise.
     
     .. math::
-        \text{output}(x_i) = \log \left(\frac{\exp(x_i)} {\sum_{j = 0}^{N-1}\exp(x_j)}\right),
+        y_i = \log_{10}(x_i)
     
-    where :math:`N` is the length of the Tensor.
+    .. warning::
+        - This is an experimental API that is subject to change or deletion.
+        - If the input value of operator Log10 is within the range (0, 0.01] or [0.95, 1.05], the output accuracy
+          may be affacted.
     
     Args:
-        input (Tensor): The input Tensor.
-        dim (int, optional): The axis to perform the Log softmax operation. Default: ``None`` .
+        input (Tensor): Input Tensor of any dimension. The value must be greater than 0.
     
-    Keyword Args:
-        dtype (:class:`mindspore.dtype`, optional): The desired dtype of returned Tensor. If not set to None, the input
-            Tensor will be cast to `dtype` before the operation is performed. This is useful for preventing overflows.
-            If set to None, stay the same as original Tensor. Default: ``None`` . Supported data type is {float16, float32, double, bfloat16}.
+    Returns:
+        Tensor, has the same shape as the `input`, and the dtype changes according to the `input.dtype`.
+        
+        - if `input.dtype` is in [float16, float32, float64, bfloat16], the output dtype is the same as the `input.dtype`.
+        - if `input.dtype` is integer or boolean type, the output dtype is float32.
+    
+    Raises:
+        TypeError: If `input` is not a Tensor.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.array([3.0, 5.0, 7.0]), mindspore.float32)
+        >>> output = ops.auto_generate.log10_ext(x)
+        >>> print(output)
+        [0.47712136 0.69897    0.845098  ]
+    """
+    return log10_impl(input)
+
+
+def log2(input):
+    r"""
+    Returns the logarithm to the base 2 of a tensor element-wise.
+    
+    .. math::
+        y_i = \log_2(x_i)
+    
+    .. warning::
+        - If the input value of operator Log2 is within the range (0, 0.01] or [0.95, 1.05], the output accuracy
+          may be affacted.
+    
+    Args:
+        input (Tensor): Input Tensor of any dimension. The value must be greater than 0.
     
     Returns:
-        Tensor, with the same shape as the input.
+        Tensor, has the same shape as the `input`. If `input.dtype` is of integer or boolean type, the output dtype
+        will be float32. Otherwise, the output dtype will be the same as `input.dtype`.
     
     Raises:
-        TypeError: If `dim` is not an int.
-        ValueError: If `dim` is not in range [-len(input.shape), len(input.shape)).
+        TypeError: If `input` is not a Tensor.
     
     Supported Platforms:
         ``Ascend``
@@ -967,12 +1330,12 @@ def log_softmax(input, dim=None, dtype=None):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> logits = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
-        >>> output = ops.auto_generate.log_softmax(logits, dim=-1)
+        >>> x = Tensor(np.array([3.0, 5.0, 7.0]), mindspore.float32)
+        >>> output = ops.auto_generate.log2_ext(x)
         >>> print(output)
-        [-4.4519143 -3.4519143 -2.4519143 -1.4519144 -0.4519144]
+        [1.5849625 2.321928  2.807355 ]
     """
-    return log_softmax_impl(input, dim, dtype)
+    return log2_impl(input)
 
 
 def logaddexp(input, other):
@@ -992,7 +1355,7 @@ def logaddexp(input, other):
         input (Tensor): Input Tensor. The dtype of `input` must be float.
         other (Tensor): Input Tensor. The dtype of `other` must be float.
             If the shape of `input` is not equal to the shape of `other`,
-            they must be broadcastable to a common shape (which becomes the shape of the output).
+            they must be broadcastable to a common shape.
     
     Returns:
         Tensor, with the same dtype as `input` and `other`.
@@ -1016,11 +1379,100 @@ def logaddexp(input, other):
     return logaddexp_impl(input, other)
 
 
-def matmul(input, mat2):
+def logsumexp(input, dim, keepdim=False):
+    r"""
+    Computes the logarithm of the sum of exponentiations of all elements along the specified `dim` dimension of the `input` (with numerical stabilization), and retains the dimension based on the `keepdim` parameter.
+    
+    .. math::
+    
+        logsumexp(input) = \log(\sum(e^{input-input_{max}})) + input_{max}
+    
+    .. 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 `[0, len(input.shape) - 1]`), when the `dim` is `()`, all dimensions are reduced.
+        keepdim (bool, optional): Whether the output tensor retains the dimension `dim`, default: `False`.
+    
+    Returns:
+        Tensor, the dtype changes according to the `input.dtype`, and the shape changes according to the values of `dim` and `keepdim`.
+    
+        - If `input.dtype` is in [float16, float32, bfloat16], the output dtype is the same as the `input.dtype`.
+        - If `input.dtype` is an integer or boolean type, the output dtype is float32.
+        - If `dim` is (), and `keepdim` is False, the output is a 0-D tensor representing the logarithm of the sum of exponentiations 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 dtype of `input` is not one of: bool, int8, int16, int32, int64, uint8, float16, float32, bfloat16.
+        TypeError: If `dim` is not an int or tuple(int) or list(list).
+        TypeError: If `keepdim` is not a bool.
+        ValueError: If the value of any elements of `dim` is not in the range `[0, len(input.shape) - 1]`.
+        RuntimeError: If any element of `dim` is repeated.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
+        >>> output = ops.auto_generate.logsumexp_ext(x, 1, keepdim=True)
+        >>> print(output.shape)
+        (3, 1, 5, 6)
+    """
+    return logsumexp_impl(input, dim, keepdim)
+
+
+def log_softmax(input, dim=None, dtype=None):
+    r"""
+    Applies the Log Softmax function to the input tensor on the specified axis.
+    Supposes a slice in the given axis, :math:`x` for each element :math:`x_i`,
+    the Log Softmax function is shown as follows:
+    
+    .. math::
+        \text{output}(x_i) = \log \left(\frac{\exp(x_i)} {\sum_{j = 0}^{N-1}\exp(x_j)}\right),
+    
+    where :math:`N` is the length of the Tensor.
+    
+    Args:
+        input (Tensor): The input Tensor.
+        dim (int, optional): The axis to perform the Log softmax operation. Default: ``None`` .
+    
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): The desired dtype of returned Tensor. If not set to None, the input
+            Tensor will be cast to `dtype` before the operation is performed. This is useful for preventing overflows.
+            If set to None, stay the same as original Tensor. Default: ``None`` . Supported data type is {float16, float32, double, bfloat16}.
+    
+    Returns:
+        Tensor, with the same shape as the input.
+    
+    Raises:
+        TypeError: If `dim` is not an int.
+        ValueError: If `dim` is not in range [-len(input.shape), len(input.shape)).
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> logits = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
+        >>> output = ops.auto_generate.log_softmax(logits, dim=-1)
+        >>> print(output)
+        [-4.4519143 -3.4519143 -2.4519143 -1.4519144 -0.4519144]
+    """
+    return log_softmax_impl(input, dim, dtype)
+
+
+def matmul(input, other):
     r"""
     None
     """
-    return matmul_impl(input, mat2)
+    return matmul_impl(input, other)
 
 
 def matrix_inverse(input):
@@ -1053,42 +1505,93 @@ def matrix_inverse(input):
     return matrix_inverse_impl(input)
 
 
-def mean(input, axis=None, keep_dims=False, dtype=None):
+def max_unpool2d(input, indices, kernel_size, stride=None, padding=0, output_size=None):
+    r"""
+    Computes the inverse of `max_pool2d`.
+    
+    `max_unpool2d` keeps the maximal value and set all position of non-maximal values to zero. Typically the input is of shape :math:`(N, C, H_{in}, W_{in})` or :math:`(C, H_{in}, W_{in})`, and the output is of shape :math:`(N, C, H_{out}, W_{out})` or :math:`(C, H_{out}, W_{out})`. The operation is as follows.
+    
+    .. math::
+        \begin{array}{ll} \\
+        H_{out} = (H_{in} - 1) \times stride[0] - 2 \times padding[0] + kernel\_size[0] \\
+        W_{out} = (W_{in} - 1) \times stride[1] - 2 \times padding[1] + kernel\_size[1] \\
+        \end{array}
+    
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+    
+    Args:
+        input (Tensor): The input Tensor to invert. Tensor of shape :math:`(N, C, H_{in}, W_{in})` or :math:`(C, H_{in}, W_{in})`.
+        indices (Tensor): Max values' index represented by the indices. Tensor of shape must be same with input 'input'. Values of indices must belong to :math:`[0, H_{in} \times W_{in} - 1]`. Data type must be in int32 or int64.
+        kernel_size (Union[int, tuple[int]]): The size of kernel used to take the maximum value, an int number that represents height and width of the kernel, or a tuple of two int numbers that represent height and width respectively.
+        stride (Union[int, tuple[int]], optional): The distance of kernel moving, an int number that represents the height and width of movement are both stride, or a tuple of two int numbers that represent height and width of movement respectively. Default: ``None`` , which indicates the moving step is `kernel_size` .
+        padding (Union[int, tuple[int]], optional): The pad value to be filled. Default: ``0`` . If `padding` is an integer, the paddings of height and width are the same, equal to padding. If `padding` is a tuple of two integers, the padding of height and width equal to padding[0] and padding[1] correspondingly.
+        output_size (tuple[int], optional): The target output size. Default: ``None`` . If output_size == (), then the shape of output computed by `kernel_size`, `stride` and `padding`. If output_size != (), then output_size must be :math:`(N, C, H, W)` , :math:`(C, H, W)` or :math:`(H, W)` and output_size must belong to :math:`[(N, C, H_{out} - stride[0], W_{out} - stride[1]), (N, C, H_{out} + stride[0], W_{out} + stride[1])]`.
+    
+    Returns:
+        Tensor, with shape :math:`(N, C, H_{out}, W_{out})` or :math:`(C, H_{out}, W_{out})`, with the same data type with `input`.
+    
+    Raises:
+        TypeError: If data type of `input` or `indices` is not supported.
+        TypeError: If `kernel_size`, `stride` or `padding` is neither an int nor a tuple.
+        ValueError: If numbers in `stride`, `padding` or `kernel_size` are not positive.
+        ValueError: If the shapes of `input` and `indices` are different.
+        ValueError: If the length of `input` is not 3 or 4.
+        ValueError: If the type of `output_size` is not tuple.
+        ValueError: If `output_size` is not close to output size computed by attr `kernel_size`, `stride`, `padding`.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([[[[0, 1], [8, 9]]]]).astype(np.float32))
+        >>> indices = Tensor(np.array([[[[0, 1], [2, 3]]]]).astype(np.int64))
+        >>> output = ops.max_unpool2d_ext(input, indices, 1, stride=1, padding=0)
+        >>> print(output.asnumpy())
+        [[[[0. 1.]
+           [8. 9.]]]]
+    """
+    return max_unpool2d_impl(input, indices, kernel_size, stride, padding, output_size)
+
+
+def mean(input, dim=None, keepdim=False, dtype=None):
     r"""
     Reduces all dimension of a tensor by averaging all elements in the dimension, by default.
-    And reduce a dimension of `input` along the specified `axis`. `keep_dims`
+    And reduce a dimension of `input` along the specified `dim`. `keepdim`
     determines whether the dimensions of the output and input are the same.
     
     Note:
-        The `axis` with tensor type is only used for compatibility with older versions and is not recommended.
+        The `dim` with tensor type is only used for compatibility with older versions and is not recommended.
     
     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`` ,
+        dim (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 `input` is r,
             and the value range is [-r,r).
-        keep_dims (bool): If ``True`` , keep these reduced dimensions and the length is 1.
+        keepdim (bool): If ``True`` , keep these reduced dimensions and the length is 1.
             If ``False`` , don't keep these dimensions. Default: ``False`` .
         dtype (:class:`mindspore.dtype`): The desired data type of returned Tensor. Default: ``None`` .
     
     Returns:
         Tensor, has the same data type as input tensor.
     
-        - If `axis` is ``None`` , and `keep_dims` is ``False`` ,
+        - If `dim` is ``None`` , and `keepdim` is ``False`` ,
           the output is a 0-D tensor representing the product of all elements in the input tensor.
-        - If `axis` is int, set as 1, and `keep_dims` is ``False`` ,
+        - If `dim` is int, set as 1, and `keepdim` is ``False`` ,
           the shape of output is :math:`(x_0, x_2, ..., x_R)`.
-        - If `axis` is tuple(int), set as (1, 2), and `keep_dims` is ``False`` ,
+        - If `dim` is tuple(int), set as (1, 2), and `keepdim` is ``False`` ,
           the shape of output is :math:`(x_0, x_3, ..., x_R)`.
-        - If `axis` is 1-D Tensor, set as [1, 2], and `keep_dims` is ``False`` ,
+        - If `dim` is 1-D Tensor, set as [1, 2], and `keepdim` is ``False`` ,
           the shape of output is :math:`(x_0, x_3, ..., x_R)`.
     
     Raises:
         TypeError: If `x` is not a Tensor.
-        TypeError: If `axis` is not one of the following: int, tuple, list or Tensor.
-        TypeError: If `keep_dims` is not a bool.
-        ValueError: If `axis` is out of range.
+        TypeError: If `dim` is not one of the following: int, tuple, list or Tensor.
+        TypeError: If `keepdim` is not a bool.
+        ValueError: If `dim` is out of range.
     
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1098,7 +1601,7 @@ def mean(input, axis=None, keep_dims=False, dtype=None):
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
-        >>> output = ops.mean(x, 1, keep_dims=True)
+        >>> output = ops.mean_ext(x, 1, keepdim=True)
         >>> result = output.shape
         >>> print(result)
         (3, 1, 5, 6)
@@ -1107,25 +1610,25 @@ def mean(input, axis=None, keep_dims=False, dtype=None):
         ... [[4, 4, 4, 4, 4, 4], [5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6]],
         ... [[6, 6, 6, 6, 6, 6], [8, 8, 8, 8, 8, 8], [10, 10, 10, 10, 10, 10]]]),
         ... mindspore.float32)
-        >>> output = ops.mean(x)
+        >>> output = ops.mean_ext(x)
         >>> print(output)
         5.0
         >>> print(output.shape)
         ()
-        >>> # case 2: Reduces a dimension along the axis 0
-        >>> output = ops.mean(x, 0, True)
+        >>> # case 2: Reduces a dimension along the dim 0
+        >>> output = ops.mean_ext(x, 0, True)
         >>> print(output)
         [[[4. 4. 4. 4. 4. 4.]
         [5. 5. 5. 5. 5. 5.]
         [6. 6. 6. 6. 6. 6.]]]
-        >>> # case 3: Reduces a dimension along the axis 1
-        >>> output = ops.mean(x, 1, True)
+        >>> # case 3: Reduces a dimension along the dim 1
+        >>> output = ops.mean_ext(x, 1, True)
         >>> print(output)
         [[[2. 2. 2. 2. 2. 2.]]
         [[5. 5. 5. 5. 5. 5.]]
         [[8. 8. 8. 8. 8. 8.]]]
-        >>> # case 4: Reduces a dimension along the axis 2
-        >>> output = ops.mean(x, 2, True)
+        >>> # case 4: Reduces a dimension along the dim 2
+        >>> output = ops.mean_ext(x, 2, True)
         >>> print(output)
         [[[ 2.]
         [ 2.]
@@ -1137,7 +1640,7 @@ def mean(input, axis=None, keep_dims=False, dtype=None):
         [ 8.]
         [10.]]]
     """
-    return mean_impl(input, axis, keep_dims, dtype)
+    return mean_impl(input, dim, keepdim, dtype)
 
 
 def mish(input):
@@ -1186,6 +1689,50 @@ def mish(input):
     return mish_impl(input)
 
 
+def mm(input, mat2):
+    r"""
+    Returns the matrix product of two arrays.
+    If `input` is a :math:`(n \times m)` Tensor, `mat2` is a
+    :math:`(m \times p)` Tensor, `out` will be a :math:`(n \times p)` Tensor.
+    
+    Note:
+        This function cannot support broadcasting.
+        Refer to :func:`mindspore.ops.matmul` instead if you need a broadcastable function.
+    
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+    
+    Args:
+        input (Tensor): The first matrix of matrix multiplication.
+            The last dimension of `input` must be the same size as the first dimension of `mat2`.
+        mat2 (Tensor): The second matrix of matrix multiplication.
+            The last dimension of `input` must be the same size as the first dimension of `mat2`.
+    
+    Returns:
+        Tensor, the matrix product of the inputs.
+    
+    Raises:
+        ValueError: If the last dimension of `input` is not the same size as the
+            second-to-last dimension of `mat2`.
+        TypeError: If `input` or `mat2` is not a Tensor.
+        TypeError: If dtype of `input` or `mat2` is not float16, float32 or bfloat16.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore import ops
+        >>> import numpy as np
+        >>> x1 = ms.Tensor(np.random.rand(2, 3), ms.float32)
+        >>> x2 = ms.Tensor(np.random.rand(3, 4), ms.float32)
+        >>> out = ops.mm_ext(x1, x2)
+        >>> print(out.shape)
+        (2, 4)
+    """
+    return mm_impl(input, mat2)
+
+
 def mse_loss(input, target, reduction='mean'):
     r"""
     Calculates the mean squared error between the predicted value and the label value.
@@ -1272,34 +1819,34 @@ def outer(input, vec2):
     return outer_impl(input, vec2)
 
 
-def prod(input, axis=None, keep_dims=False, dtype=None):
+def prod(input, dim=None, keepdim=False, dtype=None):
     r"""
     Reduces a dimension of a tensor by multiplying all elements in the dimension, by default. And also can
-    reduce a dimension of `input` along the `axis`. Determine whether the dimensions of the output and input are the
-    same by controlling `keep_dims`.
+    reduce a dimension of `input` along the `dim`. Determine whether the dimensions of the output and input are the
+    same by controlling `keepdim`.
     
     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 (int): The dimensions to reduce. Default: ``None`` , reduce all dimensions.
+        dim (int): The dimensions to reduce. Default: ``None`` , reduce all dimensions.
             Only constant value is allowed. Assume the rank of `input` is r, and the value range is [-r,r).
-        keep_dims (bool): If ``True`` , keep these reduced dimensions and the length is 1.
+        keepdim (bool): If ``True`` , keep these reduced dimensions and the length is 1.
             If ``False`` , don't keep these dimensions. Default: ``False`` .
         dtype (:class:`mindspore.dtype`): The desired data type of returned Tensor. Default: ``None`` .
     
     Returns:
         Tensor, has the same data type as input tensor.
     
-        - If `axis` is ``None`` , and `keep_dims` is  ``False`` ,
+        - If `dim` is ``None`` , and `keepdim` is  ``False`` ,
           the output is a 0-D tensor representing the product of all elements in the input tensor.
-        - If `axis` is int, set as 1, and `keep_dims` is  ``False`` ,
+        - If `dim` is int, set as 1, and `keepdim` is  ``False`` ,
           the shape of output is :math:`(input_0, input_2, ..., input_R)`.
     
     Raises:
         TypeError: If `input` is not a Tensor.
-        TypeError: If `axis` is not one of the following: int or None.
-        TypeError: If `keep_dims` is not a bool.
-        ValueError: If `axis` is out of range.
+        TypeError: If `dim` is not one of the following: int or None.
+        TypeError: If `keepdim` is not a bool.
+        ValueError: If `dim` is out of range.
     
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1309,7 +1856,7 @@ def prod(input, axis=None, keep_dims=False, dtype=None):
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
-        >>> output = ops.ProdExt()(x, 1, keep_dims=True)
+        >>> output = ops.prod_ext(x, 1, keepdim=True)
         >>> result = output.shape
         >>> print(result)
         (3, 1, 5, 6)
@@ -1317,25 +1864,25 @@ def prod(input, axis=None, keep_dims=False, dtype=None):
         >>> 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.ProdExt()(x)
+        >>> output = ops.prod_ext(x)
         >>> print(output)
         2.2833798e+33
         >>> print(output.shape)
         ()
-        >>> # case 2: Reduces a dimension along axis 0.
-        >>> output = ops.ProdExt()(x, 0, True)
+        >>> # case 2: Reduces a dimension along dim 0.
+        >>> output = ops.prod_ext(x, 0, True)
         >>> print(output)
         [[[ 28.  28.  28.  28.  28.  28.]
         [ 80.  80.  80.  80.  80.  80.]
         [162. 162. 162. 162. 162. 162.]]]
-        >>> # case 3: Reduces a dimension along axis 1.
-        >>> output = ops.ProdExt()(x, 1, True)
+        >>> # case 3: Reduces a dimension along dim 1.
+        >>> output = ops.prod_ext(x, 1, True)
         >>> print(output)
         [[[  6.   6.   6.   6.   6.   6.]]
         [[120. 120. 120. 120. 120. 120.]]
         [[504. 504. 504. 504. 504. 504.]]]
-        >>> # case 4: Reduces a dimension along axis 2.
-        >>> output = ops.ProdExt()(x, 2, True)
+        >>> # case 4: Reduces a dimension along dim 2.
+        >>> output = ops.prod_ext(x, 2, True)
         >>> print(output)
         [[[1.00000e+00]
         [6.40000e+01]
@@ -1347,40 +1894,7 @@ def prod(input, axis=None, keep_dims=False, dtype=None):
         [2.62144e+05]
         [5.31441e+05]]]
     """
-    return prod_impl(input, axis, keep_dims, dtype)
-
-
-def select(input, dim, index):
-    r"""
-    Slices the input tensor along the selected dimension at the given index.
-    
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-    
-    Args:
-        input (Tensor): the input tensor.
-        dim (int): the dimension to slice.
-        index (int): the index to select with.
-    
-    Returns:
-        Tensor.
-    
-    Raises:
-        TypeError: If input is not a Tensor.
-    
-    Supported Platforms:
-        ``Ascend``
-    
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import Tensor, mint
-        >>> input = Tensor([[2, 3, 4, 5],[3, 2, 4, 5]])
-        >>> y = mint.select(input, 0, 0)
-        >>> y = Tensor([1,2], mindspore.float32)
-        >>> print(y)
-        [2 3 4 5]
-    """
-    return select_impl(input, dim, index)
+    return prod_impl(input, dim, keepdim, dtype)
 
 
 def selu(input):
@@ -1422,13 +1936,13 @@ def selu(input):
     
     Examples:
         >>> import mindspore
-        >>> from mindspore import Tensor, mint
+        >>> from mindspore import Tensor, ops
         >>> import numpy as np
         >>> input = Tensor(np.array([[-1.0, 4.0, -8.0], [2.0, -5.0, 9.0]]), mindspore.float32)
-        >>> output = mint.nn.functional.selu(input)
+        >>> output = ops.auto_generate.selu_ext(input)
         >>> print(output)
         [[-1.1113307 4.202804 -1.7575096]
-        [ 2.101402 -1.7462534 9.456309 ]]
+         [ 2.101402 -1.7462534 9.456309 ]]
     """
     return selu_impl(input)
 
@@ -1494,7 +2008,7 @@ def stack(tensors, dim=0):
     
     Args:
         tensors (Union[tuple, list]): A Tuple or list of Tensor objects with the same shape and type.
-        dim (int): Dimension to stack. The range is [-(R+1), R+1). Default: ``0`` .
+        dim (int, optional): Dimension to stack. The range is [-(R+1), R+1). Default: ``0`` .
     
     Returns:
         Tensor. A stacked Tensor with the same type as `tensors`.
@@ -1502,7 +2016,7 @@ def stack(tensors, dim=0):
     Raises:
         TypeError: If the data types of elements in `tensors` are not the same.
         ValueError: If `dim` is out of the range [-(R+1), R+1);
-                    or if the shapes of elements in tensors are not the same.
+                    or if the shapes of elements in `tensors` are not the same.
     
     Supported Platforms:
         ``Ascend``
@@ -1577,6 +2091,67 @@ def sub(input, other, alpha=1):
     return sub_impl(input, other, alpha)
 
 
+def sum(input, dim=None, keepdim=False, dtype=None):
+    r"""
+    Calculate sum of Tensor elements over a given dim.
+    
+    Note:
+        The `dim` with tensor type is only used for compatibility with older versions and is not recommended.
+    
+    Args:
+        input (Tensor): The input tensor.
+        dim (Union[None, int, tuple(int), list(int), Tensor]): Dimensions along which a sum is performed.
+            If ``None`` , sum all the elements of the input tensor.
+            If the `dim` is a tuple or list of ints, a sum is performed on all the dimensions specified in the tuple.
+            Must be in the range :math:`[-input.ndim, input.ndim)` . Default: ``None`` .
+        keepdim (bool): 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. Default: ``False`` .
+        dtype (:class:`mindspore.dtype`): The desired data type of returned Tensor. Default: ``None`` .
+    
+    Returns:
+        A Tensor, sum of elements over a given `dim` in `input`.
+    
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `dim` is not an int, tulpe(int), list(int), Tensor or None.
+        ValueError: If `dim` is not in the range :math:`[-input.ndim, input.ndim)` .
+        TypeError: If `keepdim` is not a bool.
+    
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
+        >>> 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]]]), mstype.float32)
+        >>> out = ops.sum_ext(x)
+        >>> print(out)
+        270.0
+        >>> out = ops.sum_ext(x, dim=2)
+        >>> print(out)
+        [[ 6. 12. 18.]
+        [24. 30. 36.]
+        [42. 48. 54.]]
+        >>> out = ops.sum_ext(x, dim=2, keepdim=True)
+        >>> print(out)
+        [[[ 6.]
+        [12.]
+        [18.]]
+        [[24.]
+        [30.]
+        [36.]]
+        [[42.]
+        [48.]
+        [54.]]]
+    """
+    return sum_impl(input, dim, keepdim, dtype)
+
+
 def topk(input, k, dim=-1, largest=True, sorted=True):
     r"""
     Finds values and indices of the `k` largest or smallest entries along a given dimension.
@@ -1633,7 +2208,7 @@ def topk(input, k, dim=-1, largest=True, sorted=True):
         (Tensor(shape=[3, 2], dtype=Float32, value=
         [[ 9.67299998e-01,  5.36800027e-01],
          [ 6.52499974e-01,  4.68499988e-01],
-         [ 9.67499971e-01,  8.23000014e-01]]), Tensor(shape=[3, 2], dtype=Int32, value=
+         [ 9.67499971e-01,  8.23000014e-01]]), Tensor(shape=[3, 2], dtype=Int64, value=
         [[3, 0],
          [1, 2],
          [2, 3]]))
@@ -1642,7 +2217,7 @@ def topk(input, k, dim=-1, largest=True, sorted=True):
         (Tensor(shape=[3, 2], dtype=Float32, value=
         [[ 2.44700000e-01,  4.30200011e-01],
          [ 1.86800003e-01,  4.38800007e-01],
-         [ 3.56299996e-01,  5.15200019e-01]]), Tensor(shape=[3, 2], dtype=Int32, value=
+         [ 3.56299996e-01,  5.15200019e-01]]), Tensor(shape=[3, 2], dtype=Int64, value=
         [[1, 2],
          [3, 0],
          [0, 1]]))
@@ -1654,9 +2229,6 @@ def trace(input):
     r"""
     Returns a new tensor that is the sum of the `input` main trace.
     
-    Note:
-        Input must be tensor.
-    
     Args:
         input (Tensor): 2-D Tensor.
     
@@ -1691,44 +2263,44 @@ def trace(input):
     return trace_impl(input)
 
 
-def transpose(input, dim0, dim1):
+def tril(input, diagonal=0):
+    r"""
+    None
+    """
+    return tril_impl(input, diagonal)
+
+
+def t(input):
     r"""
-    Interchange two axes of a tensor.
+    Transpose the input tensor.
     
     .. warning::
         This is an experimental API that is subject to change or deletion.
     
     Args:
-        input(Tensor): Input tensor.
-        dim0 (int): First axis.
-        dim1 (int): Second axis.
+        input (Tensor): The input tensor.
     
     Returns:
-        Transposed tensor, has the same data type as `input`.
+        Tensor, transpose 2D tensor, return 1D tensor as it is.
     
     Raises:
-        TypeError: If argument `input` is not Tensor.
-        TypeError: If `dim0` or `dim1` is not integer.
-        ValueError: If `dim0` or `dim1` is not in the range of :math:`[-ndim, ndim-1]`.
+        ValueError: If the dimension of `input` is greater than 2.
+        ValueError: If `input` is empty.
+        TypeError: If `input` is not a tensor.
     
     Supported Platforms:
         ``Ascend``
     
     Examples:
+        >>> import mindspore
         >>> import numpy as np
-        >>> from mindspore import mint
-        >>> from mindspore import Tensor
-        >>> input = Tensor(np.ones((2,3,4), dtype=np.float32))
-        >>> output = mint.transpose(input, 0, 2)
-        >>> print(output.shape)
-        (4, 3, 2)
-    """
-    return transpose_impl(input, dim0, dim1)
-
-
-def tril(input, diagonal=0):
-    r"""
-    None
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([[1, 2, 3], [4, 5, 6]]), mindspore.float32)
+        >>> output = ops.t_ext(input)
+        >>> print(output)
+        [[ 1. 4.]
+         [ 2. 5.]
+         [ 3. 6.]]
     """
-    return tril_impl(input, diagonal)
+    return t_impl(input)