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

mindspore/ops/auto_generate/gen_ops_def.py

@@ -1655,6 +1655,54 @@ def cosh(input):
     return cosh_op(input)
 
 
+def count_nonzero(input, dim=None):
+    r"""
+    Counts the number of non-zero values in the tensor input along the given dim. If no dim is specified then all non-zeros in the tensor are counted.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): Input data is used to count non-zero numbers. With shape
+            :math:`(*)` where :math:`*` means, any number of additional dimensions.
+        dim (Union[int, tuple(int), list(int)], optional): The dimension to reduce. Default value: ``None``, which indicates that the number of non-zero elements is calculated. If `dim` is ``None``, all elements in the tensor are summed up.
+            
+    Returns:
+        Tensor, number of nonzero element across dim specified by `dim`.
+
+    Raises:
+        TypeError: If `input` is not tensor.
+        TypeError: If `dim` is not int, tuple(int), list(int) or None.
+        ValueError: If any value in `dim` is not in range [-x.ndim, x.ndim).
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> import numpy as np
+        >>> import mindspore
+        >>> # case 1: each value specified.
+        >>> x = Tensor(np.array([[0, 1, 0], [1, 1, 0]]).astype(np.float32))
+        >>> nonzero_num = ops.count_nonzero(input=x, dim=[0, 1])
+        >>> print(nonzero_num)
+        [[3]]
+        >>> # case 2: all value is default.
+        >>> nonzero_num = ops.count_nonzero(input=x)
+        >>> print(nonzero_num)
+        3
+        >>> # case 3: dim value was specified 0.
+        >>> nonzero_num = ops.count_nonzero(input=x, dim=[0,])
+        >>> print(nonzero_num)
+        [1 2 0]
+        >>> # case 4: dim value was specified 1.
+        >>> nonzero_num = ops.count_nonzero(input=x, dim=[1,])
+        >>> print(nonzero_num)
+        [1 2]
+    """
+    return count_nonzero_op(input, dim)
+
+
 def cummax(input, axis):
     r"""
     Returns a tuple (values,indices) where 'values' is the cumulative maximum value of input Tensor `input`
@@ -1860,7 +1908,8 @@ def dense(input, weight, bias=None):
         output = input * weight^{T} + bias
 
     .. warning::
-        This is an experimental API that is subject to change or deletion.
+        - This is an experimental API that is subject to change or deletion.
+        - In PYNATIVE mode, if `bias` is not 1D, the `input` cannot be greater than 6D.
 
     Args:
         input (Tensor): Input Tensor of shape :math:`(*, in\_channels)`,
@@ -1877,6 +1926,7 @@ def dense(input, weight, bias=None):
         TypeError: If `input` is not Tensor.
         TypeError: If `weight` is not Tensor.
         TypeError: If `bias` is not Tensor.
+        RuntimeError: If `bias` is not 1D and `input` is greater than 6D in PYNATIVE mode.
 
     Supported Platforms:
         ``Ascend`` ``GPU``  ``CPU``
@@ -6404,7 +6454,7 @@ def rotary_position_embedding(x, cos, sin, mode=0):
 
     Args:
         x (Tensor): 4D tensor, with float16, bfloat16 or float32 data type.
-        cos (Tensor): 4D tensor, has the same type as `x` , in range of [-1, 1].
+        cos (Tensor): 4D constant, has the same type as `x` , in range of [-1, 1].
         sin (Tensor): Same with `cos` .
         mode (int): An optional attribute. Used to select a calculation mode. 0: rotate_half(GPT-NeoX style); 1: rotate_interleaved(GPT-J style). Defaults to ``0`` .
 
@@ -6420,7 +6470,6 @@ def rotary_position_embedding(x, cos, sin, mode=0):
 
             11SD, B1SD, BNSD; D < 896 and D is an Even. B, N < 1000;
 
-            B * N <= 1024 if gradient calculation of cos/sin is used.
           - Supported layout: 11SD, B1SD, BNSD;
 
             D < 896 and D is an Even.

mindspore/ops/auto_generate/gen_ops_prim.py

@@ -81,6 +81,7 @@ from mindspore._c_expression import pyboost_copy_ext
 from mindspore._c_expression import pyboost_copy
 from mindspore._c_expression import pyboost_cos
 from mindspore._c_expression import pyboost_cosh
+from mindspore._c_expression import pyboost_count_nonzero
 from mindspore._c_expression import pyboost_cross
 from mindspore._c_expression import pyboost_cummax
 from mindspore._c_expression import pyboost_cummin_ext
@@ -116,7 +117,6 @@ from mindspore._c_expression import pyboost_gather_d_grad_v2
 from mindspore._c_expression import pyboost_gather_d
 from mindspore._c_expression import pyboost_gelu_grad
 from mindspore._c_expression import pyboost_gelu
-from mindspore._c_expression import pyboost_generator
 from mindspore._c_expression import pyboost_greater_equal
 from mindspore._c_expression import pyboost_greater
 from mindspore._c_expression import pyboost_grid_sampler_2d_grad
@@ -195,6 +195,7 @@ from mindspore._c_expression import pyboost_muls
 from mindspore._c_expression import pyboost_multinomial_ext
 from mindspore._c_expression import pyboost_mv
 from mindspore._c_expression import pyboost_nan_to_num
+from mindspore._c_expression import pyboost_ne_scalar
 from mindspore._c_expression import pyboost_neg
 from mindspore._c_expression import pyboost_non_zero_ext
 from mindspore._c_expression import pyboost_non_zero
@@ -214,6 +215,11 @@ from mindspore._c_expression import pyboost_prelu
 from mindspore._c_expression import pyboost_prod_ext
 from mindspore._c_expression import pyboost_rand_ext
 from mindspore._c_expression import pyboost_rand_like_ext
+from mindspore._c_expression import pyboost_randint_like
+from mindspore._c_expression import pyboost_randint
+from mindspore._c_expression import pyboost_randn_like
+from mindspore._c_expression import pyboost_randn
+from mindspore._c_expression import pyboost_randperm_ext
 from mindspore._c_expression import pyboost_reciprocal
 from mindspore._c_expression import pyboost_reduce_all
 from mindspore._c_expression import pyboost_reduce_any
@@ -250,6 +256,7 @@ from mindspore._c_expression import pyboost_scatter_add_ext
 from mindspore._c_expression import pyboost_scatter
 from mindspore._c_expression import pyboost_scatter_value
 from mindspore._c_expression import pyboost_searchsorted
+from mindspore._c_expression import pyboost_select_ext
 from mindspore._c_expression import pyboost_select
 from mindspore._c_expression import pyboost_select_v2
 from mindspore._c_expression import pyboost_selu_ext
@@ -317,6 +324,7 @@ from mindspore._c_expression import pyboost_zeros
 from mindspore._c_expression import pyboost_add_rmsnorm_quant_v2
 from mindspore._c_expression import pyboost_dynamic_quant_ext
 from mindspore._c_expression import pyboost_grouped_matmul
+from mindspore._c_expression import pyboost_kv_cache_scatter_update
 from mindspore._c_expression import pyboost_moe_finalize_routing
 from mindspore._c_expression import pyboost_quant_batch_matmul
 from mindspore._c_expression import pyboost_quant_v2
@@ -2379,7 +2387,8 @@ class BatchMatMul(Primitive):
 
     \text{output}[..., :, :] = \text{matrix}(x[..., :, :]) * \text{matrix}(y[..., :, :])
 
-    The rank of both two input tensors must be same and not less than `2`.
+    The rank of the two input tensors must be at least `2`, and the two input tensors must have the same rank
+    if the environment is GPU or CPU.
 
     Args:
         transpose_a (bool): If ``True`` , the last two dimensions of `x` is transposed before multiplication.
@@ -3770,6 +3779,36 @@ class Cosh(Primitive):
 cosh_op=Cosh()
 
 
+class CountNonZero(Primitive):
+    r"""
+    .. code-block::
+        
+        prim = ops.CountNonZero()
+        out = prim(input, dim)
+        
+    is equivalent to
+    
+    .. code-block::
+    
+        ops.count_nonzero(input, dim)
+        
+    Refer to :func:`mindspore.ops.count_nonzero` for more details.
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('dim', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, dim=None):
+          return _convert_stub(pyboost_count_nonzero(self, [input, dim]))
+
+count_nonzero_op=CountNonZero()
+
+
 class Cross(Primitive):
     r"""
     Returns the cross product of vectors in dimension `dim` of input and other.
@@ -6490,7 +6529,8 @@ class Generator(Primitive):
         self.add_prim_attr("side_effect_mem", True)
 
     def __call__(self, cmd, inputs):
-          return _convert_stub(pyboost_generator(self, [cmd, inputs]))
+          return super().__call__(cmd, inputs)
+
 
 generator_op=Generator()
 
@@ -8678,6 +8718,9 @@ class LinSpaceExt(Primitive):
         &output = [start, start+step, start+2*step, ... , end]
         \end{aligned}
 
+    .. warning::
+        Atlas training series does not support int16 dtype currently.
+
     Inputs:
         - **start** (Union[float, int]) - Start value of interval.
           It can be a float or integer.
@@ -9446,7 +9489,7 @@ class MatMul(Primitive):
 
     .. math::
 
-    Output_{i j}=\sum_{k=1}^{p} a_{i k} b_{k j}=a_{i 1} b_{1 j}+a_{i 2} b_{2 j}+\cdots+a_{i p} b_{p j}, p\in N
+        (Output)_{i j}=\sum_{k=1}^{p} a_{i k} b_{k j}=a_{i 1} b_{1 j}+a_{i 2} b_{2 j}+\cdots+a_{i p} b_{p j}, p\in N
 
     where the :math:`i,j` indicates the output of the i-th row and j-th column element.
 
@@ -11245,6 +11288,115 @@ class RandLikeExt(Primitive):
 rand_like_ext_op=RandLikeExt()
 
 
+class RandIntLike(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('low'),
+        sig.make_sig('high'),
+        sig.make_sig('seed'),
+        sig.make_sig('offset'),
+        sig.make_sig('dtype', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, low, high, seed, offset, dtype=None):
+          return _convert_stub(pyboost_randint_like(self, [input, low, high, seed, offset, dtype if dtype is None else dtype_to_type_id('RandIntLike', 'dtype', dtype)]))
+
+randint_like_op=RandIntLike()
+
+
+class RandInt(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('low'),
+        sig.make_sig('high'),
+        sig.make_sig('shape'),
+        sig.make_sig('seed'),
+        sig.make_sig('offset'),
+        sig.make_sig('dtype', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, low, high, shape, seed, offset, dtype=None):
+          return _convert_stub(pyboost_randint(self, [low, high, shape, seed, offset, dtype if dtype is None else dtype_to_type_id('RandInt', 'dtype', dtype)]))
+
+randint_op=RandInt()
+
+
+class RandnLike(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('input'),
+        sig.make_sig('seed'),
+        sig.make_sig('offset'),
+        sig.make_sig('dtype', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, input, seed, offset, dtype=None):
+          return _convert_stub(pyboost_randn_like(self, [input, seed, offset, dtype if dtype is None else dtype_to_type_id('RandnLike', 'dtype', dtype)]))
+
+randn_like_op=RandnLike()
+
+
+class Randn(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('shape'),
+        sig.make_sig('seed'),
+        sig.make_sig('offset'),
+        sig.make_sig('dtype', default=None),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, shape, seed, offset, dtype=None):
+          return _convert_stub(pyboost_randn(self, [shape, seed, offset, dtype if dtype is None else dtype_to_type_id('Randn', 'dtype', dtype)]))
+
+randn_op=Randn()
+
+
+class RandpermExt(Primitive):
+    r"""
+    
+    """
+    __mindspore_signature__ =  (
+        sig.make_sig('n'),
+        sig.make_sig('seed'),
+        sig.make_sig('offset'),
+        sig.make_sig('dtype', default=mstype.int64),
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+    def __call__(self, n, seed, offset, dtype=mstype.int64):
+          return _convert_stub(pyboost_randperm_ext(self, [n, seed, offset, dtype_to_type_id('RandpermExt', 'dtype', dtype)]))
+
+randperm_ext_op=RandpermExt()
+
+
 class RandpermV2(Primitive):
     r"""
     .. code-block::
@@ -13631,8 +13783,7 @@ class SelectExt(Primitive):
         pass
 
     def __call__(self, input, dim, index):
-          return super().__call__(input, dim, index)
-
+          return _convert_stub(pyboost_select_ext(self, [input, dim, index]))
 
 select_ext_op=SelectExt()
 
@@ -16494,8 +16645,7 @@ class KVCacheScatterUpdate(Primitive):
         self.add_prim_attr("side_effect_mem", True)
 
     def __call__(self, var, indices, updates, axis, reduce='none'):
-          return super().__call__(var, indices, updates, axis, str_to_enum('KVCacheScatterUpdate', 'reduce', reduce))
-
+          return _convert_stub(pyboost_kv_cache_scatter_update(self, [var, indices, updates, axis, str_to_enum('KVCacheScatterUpdate', 'reduce', reduce)]))
 
 kv_cache_scatter_update_op=KVCacheScatterUpdate()
 

mindspore/ops/function/array_func.py

@@ -1312,6 +1312,8 @@ def unique_with_pad(x, pad_num):
 
     .. warning::
         :func:`mindspore.ops.unique_with_pad` is deprecated from version 2.4 and will be removed in a future version.
+        Please use the :func:`mindspore.ops.unique` combined with :func:`mindspore.ops.pad` to realize
+        the same function.
 
     Args:
         x (Tensor): The tensor need to be unique. Must be 1-D vector with types: int32, int64.

mindspore/ops/function/math_func.py

@@ -2761,6 +2761,9 @@ def linspace_ext(start, end, steps, *, dtype=None):
         &output = [start, start+step, start+2*step, ... , end]
         \end{aligned}
 
+    .. warning::
+        Atlas training series does not support int16 dtype currently.
+
     Args:
         start (Union[float, int]): Start value of interval.
             It can be a float or integer.
@@ -7518,7 +7521,7 @@ def norm_ext(input, p='fro', dim=None, keepdim=False, *, dtype=None):
         This is an experimental API that is subject to change or deletion.
 
     Args:
-        input (Tensor): The input of LogSigmoid with data type of bfloat16, float16 or float32.
+        input (Tensor): The input of norm with data type of bfloat16, float16 or float32.
             The shape is :math:`(*)` where :math:`*` means, any number of additional dimensions.
         p (Union[int, float, inf, -inf, 'fro', 'nuc'], optional): norm's mode. refer to the table above for
             behavior. Default: ``fro`` .
@@ -7554,6 +7557,9 @@ def norm_ext(input, p='fro', dim=None, keepdim=False, *, dtype=None):
         >>> print(ops.function.math_func.norm_ext(x, 2.0))
         38.327538
     """
+    if not isinstance(input, (Tensor, Tensor_)):
+        raise TypeError(f"For `norm_ext`, the `input` must be Tensor!, but get {type(input)}.")
+
     if (dim is not None) or keepdim or (dtype is not None):
         raise ValueError(f"For `norm_ext`, the value of `dim`, `keepdim` and `dtype` must be default value currently.")
 
@@ -9082,9 +9088,9 @@ def remainder(input, other):
     both dtypes cannot be bool, and the shapes of them could be broadcast. When the inputs are one tensor
     and one scalar, the scalar could only be a constant.
 
-    .. math::
+    .. code:: python
 
-        remainder(input, other) = input - input.div(other, rounding\_mode="floor") * other
+        remainder(input, other) == input - input.div(other, rounding_mode="floor") * other
 
     .. warning::
         - When the elements of input exceed 2048, there might be accuracy problems.
@@ -9129,9 +9135,10 @@ def remainder_ext(input, other):
 
     Supports broadcasting to a common shape and implicit type promotion.
 
-    .. math::
+    .. code:: python
+
+        remainder(input, other) == input - input.div(other, rounding_mode="floor") * other
 
-        remainder(input, other) = input - input.div(other, rounding\_mode="floor") * other
 
     Note:
         Complex inputs are not supported. At least one input need to be tensor, but not both are bool tensors.