mindspore 2.4.10__cp310-none-any.whl → 2.5.0__cp310-none-any.whl

mindspore/ops/auto_generate/gen_extend_func.py

@@ -1,4 +1,4 @@
-# Copyright 2023 Huawei Technologies Co., Ltd
+# Copyright 2024 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -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.
@@ -215,6 +246,41 @@ def argmin(input, dim=None, keepdim=False):
     return argmin_impl(input, dim, keepdim)
 
 
+def argsort(input, dim=-1, descending=False):
+    r"""
+    Sorts the input tensor along the given dimension in specified order and return the sorted indices.
+    
+    .. warning::
+            This is an experimental optimizer API that is subject to change.
+    
+    Args:
+        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`` .
+    
+    Returns:
+        Tensor, the indices of sorted input tensor. Data type is int64.
+    
+    Supported Platforms:
+        ``Ascend``
+    
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> import mindspore.mint as mint
+        >>> x = Tensor(np.array([[8, 2, 1], [5, 9, 3], [4, 6, 7]]), mindspore.float16)
+        >>> sort = mint.argsort(x)
+        >>> print(sort)
+        [[2 1 0]
+        [2 0 1]
+        [0 1 2]]
+    """
+    return argsort_impl(input, dim, descending)
+
+
 def asin(input):
     r"""
     Computes arcsine of input tensors element-wise.
@@ -356,6 +422,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, mint
+        >>> input_x = Tensor(np.random.randint(0, 10, [1, 3, 6]), mindspore.float32)
+        >>> output = mint.nn.functional.avg_pool1d(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 mint
+        >>> print(mint.bincount(np.arange(5)))
+        [1. 1. 1. 1. 1.]
+        >>> print(mint.bincount(np.array([0, 1, 1, 3, 2, 1, 7])))
+        [1. 3. 1. 1. 0. 0. 0. 1.]
+        >>> w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights
+        >>> x = np.array([0, 1, 1, 2, 2, 2])
+        >>> print(mint.bincount(x,  weights=w, minlength=5))
+        [0.3 0.7 1.1 0.0 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 +625,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 +635,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 +652,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``
     
@@ -652,6 +807,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.
@@ -827,6 +1016,44 @@ def inplace_adds(input, other, alpha=1):
     return inplace_adds_impl(input, other, alpha)
 
 
+def sub_tensor_(input, other, alpha=1):
+    r"""
+    None
+    """
+    return sub_tensor_impl(input, other, alpha)
+
+
+def isneginf(input):
+    r"""
+    Determines which elements are -inf for each position.
+    
+    .. warning::
+        - This is an experimental API that is subject to change.
+        - 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 isneginf_impl(input)
+
+
 def l1_loss(input, target, reduction='mean'):
     r"""
     Calculate the mean absolute error between the `input` value and the `target` value.
@@ -908,7 +1135,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,6 +1160,84 @@ def leaky_relu(input, negative_slope=0.01):
     return leaky_relu_impl(input, negative_slope)
 
 
+def log10(input):
+    r"""
+    Returns the logarithm to the base 10 of a tensor element-wise.
+    
+    .. math::
+        y_i = \log_{10}(x_i)
+    
+    .. 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): Input Tensor of any dimension. The value must be greater than 0.
+    
+    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, mint
+        >>> x = Tensor(np.array([3.0, 5.0, 7.0]), mindspore.float32)
+        >>> output = mint.log10(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::
+        - This is an experimental API that is subject to change or deletion.
+        - 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, 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, mint
+        >>> x = Tensor(np.array([3.0, 5.0, 7.0]), mindspore.float32)
+        >>> output = mint.log2(x)
+        >>> print(output)
+        [1.5849625 2.321928  2.807355 ]
+    """
+    return log2_impl(input)
+
+
 def log_softmax(input, dim=None, dtype=None):
     r"""
     Applies the Log Softmax function to the input tensor on the specified axis.
@@ -1016,11 +1321,58 @@ 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 matmul(input, other):
     r"""
     None
     """
-    return matmul_impl(input, mat2)
+    return matmul_impl(input, other)
 
 
 def matrix_inverse(input):
@@ -1053,42 +1405,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 +1501,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 +1510,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 +1540,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 +1589,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 +1719,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 +1756,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 +1764,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,7 +1794,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)
+    return prod_impl(input, dim, keepdim, dtype)
 
 
 def select(input, dim, index):
@@ -1376,7 +1823,6 @@ def select(input, dim, index):
         >>> 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]
     """
@@ -1494,7 +1940,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 +1948,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 +2023,54 @@ def sub(input, other, alpha=1):
     return sub_impl(input, other, alpha)
 
 
+def sum(input, dim=None, keepdim=False, dtype=None):
+    r"""
+    Alias for :func:`mindspore.mint.transpose` . The `input` corresponds to the `input` in the reference interface,
+    and the parameters `axis0` and `axis1` correspond to `dim0` and `dim1` in the reference interface respectively.
+    
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+    
+    Refer to :func:`mindspore.mint.transpose` for more details.
+    """
+    return sum_impl(input, dim, keepdim, dtype)
+
+
+def t(input):
+    r"""
+    Transpose the input tensor.
+    
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+    
+    Args:
+        input (Tensor): The input tensor.
+    
+    Returns:
+        Tensor, transpose 2D tensor, return 1D tensor as it is.
+    
+    Raises:
+        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 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 t_impl(input)
+
+
 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.