mindspore 2.6.0rc1__cp311-cp311-win_amd64.whl → 2.7.0__cp311-cp311-win_amd64.whl

mindspore/ops/auto_generate/gen_extend_func.py

@@ -118,11 +118,11 @@ def add(input, other, alpha=1):
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         alpha (number.Number): A scaling factor applied to `other`, default 1.
     
     Returns:
@@ -237,9 +237,9 @@ 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]
     """
@@ -276,14 +276,13 @@ def argsort(input, dim=-1, descending=False, stable=False):
     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, stable)
 
@@ -389,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]
     """
@@ -470,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)
     """
@@ -512,14 +511,14 @@ def bincount(input, weights=None, minlength=0):
         ``Ascend``
     
     Examples:
-        >>> from mindspore import mint, Tensor
-        >>> print(mint.bincount(Tensor(np.arange(5))))
+        >>> from mindspore import ops, Tensor
+        >>> print(ops.auto_generate.bincount_ext(Tensor(np.arange(5))))
         [1 1 1 1 1]
-        >>> print(mint.bincount(Tensor(np.array([0, 1, 1, 3, 2, 1, 7]))))
+        >>> 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(mint.bincount(x,  weights=w, minlength=5))
+        >>> 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)
@@ -643,7 +642,7 @@ def cummin(input, dim):
         \end{array}
     
     .. note::
-        O2 mode is not supported in Ascend.
+        GE backend is not supported in Ascend.
     
     Args:
         input (Tensor): The input Tensor, The dimension must be greater than 0.
@@ -759,9 +758,9 @@ def diag(input, diagonal=0):
         ``Ascend``
     
     Examples:
-        >>> from mindspore import Tensor, mint
+        >>> from mindspore import Tensor, ops
         >>> input = Tensor([1, 2, 3, 4]).astype('int32')
-        >>> output = mint.diag(input)
+        >>> output = ops.auto_generate.diag_ext(input)
         >>> print(output)
         [[1 0 0 0]
          [0 2 0 0]
@@ -1011,56 +1010,6 @@ 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
@@ -1294,9 +1243,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  ]
     """
@@ -1330,9 +1279,9 @@ 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 ]
     """
@@ -1898,38 +1847,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).
@@ -1969,13 +1886,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)
 
@@ -2086,11 +2003,11 @@ def sub(input, other, alpha=1):
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
             a bool or a tensor whose data type is
             `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+            `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         alpha (number.Number): A scaling factor applied to `other`, default 1.
     
     Returns:
@@ -2296,41 +2213,6 @@ def trace(input):
     return trace_impl(input)
 
 
-def transpose(input, dim0, dim1):
-    r"""
-    Interchange two axes of a 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.
-    
-    Returns:
-        Transposed tensor, has the same data type as `input`.
-    
-    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]`.
-    
-    Supported Platforms:
-        ``Ascend``
-    
-    Examples:
-        >>> 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