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

mindspore/ops/auto_generate/gen_extend_func.py

@@ -1,4 +1,4 @@
-# Copyright 2024 Huawei Technologies Co., Ltd
+# Copyright 2023 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.
@@ -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):
@@ -237,16 +237,16 @@ 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 argsort(input, dim=-1, descending=False):
+def argsort(input, dim=-1, descending=False, stable=False):
     r"""
     Sorts the input tensor along the given dimension in specified order and return the sorted indices.
     
@@ -259,39 +259,44 @@ def argsort(input, dim=-1, descending=False):
             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, the indices of sorted input tensor. Data type is int64.
     
+    Raises:
+        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``
     
     Examples:
         >>> import mindspore
         >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> import mindspore.mint as mint
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[8, 2, 1], [5, 9, 3], [4, 6, 7]]), mindspore.float16)
-        >>> sort = mint.argsort(x)
+        >>> sort = ops.auto_generate.argsort_ext(x)
         >>> print(sort)
         [[2 1 0]
-        [2 0 1]
-        [0 1 2]]
+         [2 0 1]
+         [0 1 2]]
     """
-    return argsort_impl(input, dim, descending)
+    return argsort_impl(input, dim, descending, stable)
 
 
-def asin(input):
+def asinh(input):
     r"""
-    Computes arcsine of input tensors element-wise.
+    Computes inverse hyperbolic sine of the input element-wise.
     
     .. math::
     
-        out_i = \sin^{-1}(input_i)
+        out_i = \sinh^{-1}(input_i)
     
     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 sine 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`.
@@ -306,24 +311,25 @@ def asin(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.asin_ext(input)
+        >>> input = Tensor(np.array([-5.0, 1.5, 3.0, 100.0]), mindspore.float32)
+        >>> output = ops.asinh_ext(input)
         >>> print(output)
-        [0.8330927  0.04001068  0.30469266  0.59438497 ]
+        [-2.3124385  1.1947632  1.8184465  5.298342 ]
     """
-    return asin_impl(input)
+    return asinh_impl(input)
 
 
-def asinh(input):
+def asin(input):
     r"""
-    Computes inverse hyperbolic sine of the input element-wise.
+    Computes arcsine of input tensors element-wise.
     
     .. math::
     
-        out_i = \sinh^{-1}(input_i)
+        out_i = \sin^{-1}(input_i)
     
     Args:
-        input (Tensor): The input tensor of inverse hyperbolic sine 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`.
@@ -338,12 +344,12 @@ def asinh(input):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([-5.0, 1.5, 3.0, 100.0]), mindspore.float32)
-        >>> output = ops.asinh_ext(input)
+        >>> input = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), mindspore.float32)
+        >>> output = ops.asin_ext(input)
         >>> print(output)
-        [-2.3124385  1.1947632  1.8184465  5.298342 ]
+        [0.8330927  0.04001068  0.30469266  0.59438497 ]
     """
-    return asinh_impl(input)
+    return asin_impl(input)
 
 
 def atan2(input, other):
@@ -382,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]
     """
@@ -463,9 +469,9 @@ def avg_pool1d(input, kernel_size, stride=None, padding=0, ceil_mode=False, coun
     Examples:
         >>> import mindspore
         >>> import numpy as np
-        >>> from mindspore import Tensor, mint
+        >>> from mindspore import Tensor, ops
         >>> 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)
+        >>> output = ops.auto_generate.avg_pool1d_ext(input_x, kernel_size=6, stride=1)
         >>> print(output.shape)
         (1, 3, 1)
     """
@@ -505,15 +511,15 @@ def bincount(input, weights=None, minlength=0):
         ``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]
+        >>> 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)
 
@@ -716,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.
@@ -956,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
@@ -1002,18 +1106,18 @@ def index_select(input, dim, index):
     return index_select_impl(input, dim, index)
 
 
-def inplace_add(input, other, alpha=1):
+def inplace_adds(input, other, alpha=1):
     r"""
     None
     """
-    return inplace_add_impl(input, other, alpha)
+    return inplace_adds_impl(input, other, alpha)
 
 
-def inplace_adds(input, other, alpha=1):
+def inplace_add(input, other, alpha=1):
     r"""
     None
     """
-    return inplace_adds_impl(input, other, alpha)
+    return inplace_add_impl(input, other, alpha)
 
 
 def sub_tensor_(input, other, alpha=1):
@@ -1028,7 +1132,6 @@ def isneginf(input):
     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:
@@ -1190,9 +1293,9 @@ def log10(input):
     Examples:
         >>> import mindspore
         >>> import numpy as np
-        >>> from mindspore import Tensor, mint
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([3.0, 5.0, 7.0]), mindspore.float32)
-        >>> output = mint.log10(x)
+        >>> output = ops.auto_generate.log10_ext(x)
         >>> print(output)
         [0.47712136 0.69897    0.845098  ]
     """
@@ -1207,7 +1310,6 @@ def log2(input):
         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.
     
@@ -1215,10 +1317,8 @@ def log2(input):
         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.
+        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 `input` is not a Tensor.
@@ -1229,57 +1329,15 @@ def log2(input):
     Examples:
         >>> import mindspore
         >>> import numpy as np
-        >>> from mindspore import Tensor, mint
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([3.0, 5.0, 7.0]), mindspore.float32)
-        >>> output = mint.log2(x)
+        >>> output = ops.auto_generate.log2_ext(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.
-    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 logaddexp(input, other):
     r"""
     Computes the logarithm of the sum of exponentiations of the inputs.
@@ -1297,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`.
@@ -1368,6 +1426,48 @@ def logsumexp(input, dim, keepdim=False):
     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
@@ -1797,38 +1897,6 @@ def prod(input, dim=None, keepdim=False, dtype=None):
     return prod_impl(input, dim, keepdim, 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)
-        >>> print(y)
-        [2 3 4 5]
-    """
-    return select_impl(input, dim, index)
-
-
 def selu(input):
     r"""
     Activation function SELU (Scaled exponential Linear Unit).
@@ -1868,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)
 
@@ -2025,50 +2093,63 @@ def sub(input, other, alpha=1):
 
 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.
+    Calculate sum of Tensor elements over a given dim.
     
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
+    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:
-        Tensor, transpose 2D tensor, return 1D tensor as it is.
+        A Tensor, sum of elements over a given `dim` in `input`.
     
     Raises:
-        ValueError: If the dimension of `input` is greater than 2.
-        ValueError: If `input` is empty.
-        TypeError: If `input` is not a tensor.
+        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``
+        ``Ascend`` ``GPU`` ``CPU``
     
     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.]]
+        >>> 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 t_impl(input)
+    return sum_impl(input, dim, keepdim, dtype)
 
 
 def topk(input, k, dim=-1, largest=True, sorted=True):
@@ -2127,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]]))
@@ -2136,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]]))
@@ -2148,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.
     
@@ -2185,44 +2263,44 @@ def trace(input):
     return trace_impl(input)
 
 
-def transpose(input, dim0, dim1):
+def tril(input, diagonal=0):
     r"""
-    Interchange two axes of a tensor.
+    None
+    """
+    return tril_impl(input, diagonal)
+
+
+def t(input):
+    r"""
+    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)