mindspore 2.7.0__cp310-cp310-win_amd64.whl → 2.7.1__cp310-cp310-win_amd64.whl

mindspore/ops/auto_generate/gen_ops_def.py

@@ -1558,9 +1558,6 @@ def clone(input):
     r"""
     Returns a copy of the input tensor.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Note:
         This function is differentiable, and gradients will flow back directly from the calculation
         result of the function to the `input`.
@@ -1939,9 +1936,6 @@ def count_nonzero(input, dim=None):
     r"""
     Count the number of non-zero elements in the Tensor `input` on a given dimension `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.
@@ -2268,6 +2262,13 @@ def dense(input, weight, bias=None):
     return dense_op(input, weight, bias)
 
 
+def dequant_swiglu_quant(x, weight_scale, activation_scale, bias=None, quant_scale=None, quant_offset=None, group_index=None, activate_left=False, quant_mode='static'):
+    r"""
+    
+    """
+    return dequant_swiglu_quant_op(x, weight_scale, activation_scale, bias, quant_scale, quant_offset, group_index, activate_left, quant_mode)
+
+
 def diagonal(input, offset=0, dim1=0, dim2=1):
     r"""
     Returns diagonals of the input tensor along specified dimension.
@@ -2436,9 +2437,6 @@ def dot(input, other):
     r"""
     Computes the dot product of two 1D tensor.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         input (Tensor): The first input in the dot product, must be 1D.
         other (Tensor): The second input in the dot product, must be 1D.
@@ -2573,104 +2571,6 @@ def elu(input_x, alpha=1.0):
     return elu_op(input_x)
 
 
-def embedding_apply_adam_w(var_handle, beta1_power, beta2_power, lr, weight_decay, beta1, beta2, epsilon, grad, keys, max_grad_norm, global_step, embedding_dim, ams_grad=(0,), mask_zero=(0,), padding_key=(0,), padding_key_mask=(1,), completion_key=(0,), completion_key_mask=(1,), _embedding_dim=1, _max_key_num=1):
-    r"""
-    
-    """
-    return embedding_apply_adam_w_op(var_handle, beta1_power, beta2_power, lr, weight_decay, beta1, beta2, epsilon, grad, keys, max_grad_norm, global_step, embedding_dim, ams_grad, mask_zero, padding_key, padding_key_mask, completion_key, completion_key_mask, _embedding_dim, _max_key_num)
-
-
-def embedding_apply_adam(var_handle, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad, keys, global_step, embedding_dim, mask_zero=(0,), padding_key=(0,), padding_key_mask=(1,), completion_key=(0,), completion_key_mask=(1,), _embedding_dim=1, _max_key_num=1):
-    r"""
-    
-    """
-    return embedding_apply_adam_op(var_handle, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad, keys, global_step, embedding_dim, mask_zero, padding_key, padding_key_mask, completion_key, completion_key_mask, _embedding_dim, _max_key_num)
-
-
-def embedding_apply_ada_grad(var_handle, lr, grad, keys, global_step, embedding_dim, mask_zero=(0,), padding_key=(0,), padding_key_mask=(1,), completion_key=(0,), completion_key_mask=(1,), _embedding_dim=1, _max_key_num=1):
-    r"""
-    
-    """
-    return embedding_apply_ada_grad_op(var_handle, lr, grad, keys, global_step, embedding_dim, mask_zero, padding_key, padding_key_mask, completion_key, completion_key_mask, _embedding_dim, _max_key_num)
-
-
-def embedding_apply_ftrl(var_handle, lr, lr_power, lambda1, lambda2, grad, keys, global_step, embedding_dim, mask_zero=(0,), padding_key=(0,), padding_key_mask=(1,), completion_key=(0,), completion_key_mask=(1,), _embedding_dim=1, _max_key_num=1):
-    r"""
-    
-    """
-    return embedding_apply_ftrl_op(var_handle, lr, lr_power, lambda1, lambda2, grad, keys, global_step, embedding_dim, mask_zero, padding_key, padding_key_mask, completion_key, completion_key_mask, _embedding_dim, _max_key_num)
-
-
-def embedding_apply_rmsprop(var_handle, lr, rho, momentum, epsilon, grad, keys, global_step, embedding_dim, mask_zero=(0,), padding_key=(0,), padding_key_mask=(1,), completion_key=(0,), completion_key_mask=(1,), _embedding_dim=1, _max_key_num=1):
-    r"""
-    
-    """
-    return embedding_apply_rmsprop_op(var_handle, lr, rho, momentum, epsilon, grad, keys, global_step, embedding_dim, mask_zero, padding_key, padding_key_mask, completion_key, completion_key_mask, _embedding_dim, _max_key_num)
-
-
-def embedding_apply_sgd(var_handle, lr, grad, keys, global_step, embedding_dim, mask_zero=(0,), padding_key=(0,), padding_key_mask=(1,), completion_key=(0,), completion_key_mask=(1,), _embedding_dim=1, _max_key_num=1):
-    r"""
-    
-    """
-    return embedding_apply_sgd_op(var_handle, lr, grad, keys, global_step, embedding_dim, mask_zero, padding_key, padding_key_mask, completion_key, completion_key_mask, _embedding_dim, _max_key_num)
-
-
-def embedding_feature_mapping_export(file_path, table_name, global_step, values, embedding_dim, feature_id, offset_id):
-    r"""
-    
-    """
-    return embedding_feature_mapping_export_op(file_path, table_name, global_step, values, embedding_dim, feature_id, offset_id)
-
-
-def embedding_feature_mapping_file_size(file_path, table_name, global_step, embedding_dim, only_offset_flag=True):
-    r"""
-    
-    """
-    return embedding_feature_mapping_file_size_op(file_path, table_name, global_step, embedding_dim, only_offset_flag)
-
-
-def embedding_feature_mapping_find(table_name, feature_size, num=1):
-    r"""
-    
-    """
-    return embedding_feature_mapping_find_op(table_name, feature_size, num)
-
-
-def embedding_feature_mapping_import(file_path, teble_name, feature_size, global_step, embedding_dim, only_offset_flag=True, num=1):
-    r"""
-    
-    """
-    return embedding_feature_mapping_import_op(file_path, teble_name, feature_size, global_step, embedding_dim, only_offset_flag, num)
-
-
-def embedding_feature_mapping_insert(table_name, num, feature_id, offset_id):
-    r"""
-    
-    """
-    return embedding_feature_mapping_insert_op(table_name, num, feature_id, offset_id)
-
-
-def embedding_feature_mapping_table_size(table_name):
-    r"""
-    
-    """
-    return embedding_feature_mapping_table_size_op(table_name)
-
-
-def embedding_feature_mapping_v2(table_name, feature_id, table_total_size, table_actual_size):
-    r"""
-    
-    """
-    return embedding_feature_mapping_v2_op(table_name, feature_id, table_total_size, table_actual_size)
-
-
-def embedding_table_evict(var_handle, global_step, steps_to_live=0):
-    r"""
-    
-    """
-    return embedding_table_evict_op(var_handle, global_step, steps_to_live)
-
-
 def equal(input, other):
     r"""
     Compute the equivalence of the two inputs element-wise.
@@ -3521,6 +3421,43 @@ def floor(input):
     return floor_op(input)
 
 
+def format_cast(input, acl_format):
+    r"""
+    Change tensor format.
+
+    .. warning::
+        FormatCast will not work in the ge backend, origin input will be returned.
+
+    Args:
+        input (Tensor): The input tensor. 
+        acl_format (int): enum value of acl format, the valid values are below: 
+            - ``0`` NCHW
+            - ``1`` NHWC
+            - ``2`` ND
+            - ``3`` NC1HWC0
+            - ``4`` FRACTAL_Z
+            - ``27`` NDHWC
+            - ``29`` FRACTAL_NZ
+            - ``30`` NCDHW
+            - ``32`` NDC1HWC0
+            - ``33`` FRACTAL_Z_3D
+
+    Returns:
+        Tensor
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> input = mindspore.ops.randn((2, 3, 4, 5))
+        >>> output = mindspore.ops.format_cast(input, 2)
+        >>> print(output.shape)
+        (2, 3, 4, 5)
+    """
+    return format_cast_op(input, acl_format)
+
+
 def frac_ext(input):
     r"""
     Calculates the fractional part of each element in the input.
@@ -4016,7 +3953,6 @@ def histc_ext(input, bins=100, min=0, max=0):
     Elements lower than min or higher than max are ignored.
 
     .. warning::
-        This is an experimental API that is subject to change or deletion.
         If input is int64, valid values fit within int32; exceeding this may cause precision errors.
 
     Args:
@@ -5184,6 +5120,25 @@ def inplace_scatter_add(input, dim, index, src):
     return inplace_scatter_add_op(input, dim, index, src)
 
 
+def inplace_sigmoid(input):
+    r"""
+    sigmoid_() -> Tensor
+
+    In-place version of sigmoid().
+
+    .. warning::
+        Only supports Ascend.
+    """
+    return inplace_sigmoid_op(input)
+
+
+def inplace_sign(input):
+    r"""
+    
+    """
+    return inplace_sign_op(input)
+
+
 def inplace_silu(input):
     r"""
     Computes Sigmoid Linear Unit of input element-wise. The SiLU function is defined as:
@@ -5500,7 +5455,7 @@ def isinf(input):
     Return a boolean tensor indicating which elements are +/- inifnity.
 
     .. warning::
-        - This is an experimental API that is subject to change.
+        - This is an experimental API that is subject to change or deletion.
         - For Ascend, it is only supported on platforms above Atlas A2.
 
     Args:
@@ -7371,11 +7326,18 @@ def nextafter(input, other):
 
     Examples:
         >>> import mindspore
-        >>> input = mindspore.tensor([0.0], mindspore.float32)
-        >>> other = mindspore.tensor([0.1], mindspore.float32)
+        >>> import numpy as np
+        >>> eps = np.finfo(np.float32).eps
+        >>> input = mindspore.tensor([1.0], mindspore.float32)
+        >>> other = mindspore.tensor([2.0], mindspore.float32)
         >>> output = mindspore.ops.nextafter(input, other)
-        >>> print(output)
-        [1.e-45]
+        >>> print(output == eps + 1)
+        [ True]
+        >>> input = mindspore.tensor([1.0, 2.0], mindspore.float32)
+        >>> other = mindspore.tensor([2.0, 1.0], mindspore.float32)
+        >>> output = mindspore.ops.nextafter(input, other)
+        >>> print(output == mindspore.tensor([eps + 1, 2 - eps], mindspore.float32))
+        [ True True]
     """
     return next_after_op(input, other)
 
@@ -7429,9 +7391,6 @@ def outer_ext(input, vec2):
     Return outer product of `input` and `vec2`. If `input` is a vector of size :math:`n`
     and `vec2` is a vector of size :math:`m` , then output must be a matrix of shape :math:`(n, m)` .
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     .. note::
         This function does not broadcast.
 
@@ -7678,12 +7637,13 @@ def range(start, end, step, maxlen=1000000):
     Returns a tensor with a step length of `step` in the interval [ `start` , `end` ).
 
     .. note::
-        The types of all 3 inputs must be all integers or floating-point numbers.
+        - The types of all 3 inputs must be all integers or floating-point numbers.
+        - When the input is a tensor, the tensor must contain only one element, whose dtype is Number.
 
     Args:
-        start (number): The start value of the interval.
-        end (number): The end value of the interval.
-        step (number): The interval between each value.
+        start (Union[Number, Tensor]): The start value of the interval.
+        end (Union[Number, Tensor]): The end value of the interval.
+        step (Union[Number, Tensor]): The interval between each value.
         maxlen (int, optional): Memory that can fit `maxlen` many elements
             will be allocated for the output. Optional, must be positive. Default: 1000000.
             If the output has more than `maxlen` elements, a runtime error will occur.
@@ -8186,9 +8146,9 @@ def ring_attention_update(prev_attn_out, prev_softmax_max, prev_softmax_sum, cur
         - This is an experimental API that is subject to change or deletion.
         - When `layout` is ``"TND"``, the last dimension of `prev_attn_out` must be a multiple of 64.
         - When `layout` is ``"TND"``, `actual_seq_qlen` is mandatory.
-        - When `layout` is ``"TND"``, N x D must satisfy the constraint:
-          (AlignUp(NxD, 64)x(DataSizex6+8))+(AlignUp(Nx8, 64)x56) <= 192x1024.
-          DataSize is 4 bytes when `prev_attn_out` dtype is float32, 2 bytes when dtype is float16 / bfloat16.
+        - When `layout` is ``"TND"``, N * D must satisfy the constraint:
+          :math:`(\text{AlignUp}(N*D, 64)*(DataSize*6+8))+(\text{AlignUp}(N*8, 64)*56) <= 192*1024`.
+          :math:`DataSize` is 4 bytes when `prev_attn_out` dtype is float32, 2 bytes when dtype is float16 / bfloat16.
         - When `layout` is ``"TND"``, if `actual_seq_qlen` is not a non-decreasing sequence from 0 to T, the result is undefined.
 
     Args:
@@ -9303,14 +9263,13 @@ def stack_ext(tensors, dim=0):
     :math:`(x_1, x_2, ..., x_{dim}, N, x_{dim+1}, ..., x_R)`.
 
     Args:
-        tensors (Union[tuple, list]): A Tuple or list of Tensor objects with the same shape and type.
+        tensors (Union[tuple, list]): A Tuple or list of Tensor objects with the same shape.
         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`.
+        A stacked Tensor.
 
     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.
 
@@ -9946,9 +9905,6 @@ def transpose_ext_view(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.
@@ -9976,17 +9932,17 @@ def transpose_ext_view(input, dim0, dim1):
     return transpose_ext_view_op(input, dim0, dim1)
 
 
-def transpose(input, input_perm):
+def transpose(input, dims):
     r"""
     Transpose dimensions of the input tensor according to input permutation.
 
     Note:
-        On GPU and CPU, if the value of `input_perm` is negative, its actual value is `input_perm[i] + rank(input)`.
-        Negative value of `input_perm` is not supported on Ascend.
+        On GPU and CPU, if the value of `dims` is negative, its actual value is `dims[i] + rank(input)`.
+        Negative value of `dims` is not supported on Ascend.
 
     Args:
         input (Tensor): The input tensor.
-        input_perm (tuple[int]): Specify the new axis ordering.
+        dims (Union[tuple[int], list[int]]): Specify the new axis ordering.
 
     Returns:
         Tensor
@@ -10006,7 +9962,7 @@ def transpose(input, input_perm):
           [ 8. 11.]
           [ 9. 12.]]]
     """
-    return transpose_op(input, input_perm)
+    return transpose_op(input, dims)
 
 
 def transpose_view(input, input_perm):
@@ -10120,9 +10076,6 @@ def triu(input, diagonal=0):
     r"""
     Zero the input tensor below the diagonal specified.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         input (Tensor): The input tensor.
         diagonal (int, optional): The diagonal specified of 2-D tensor. Default ``0`` represents the main diagonal.
@@ -10557,7 +10510,7 @@ def grouped_matmul_v2(x, weight, bias=None, scale=None, offset=None, antiquant_s
     return grouped_matmul_v2_op(x, weight, bias, scale, offset, antiquant_scale, antiquant_offset, group_list, split_item, group_type)
 
 
-def grouped_matmul_v4(x, weight, bias=None, scale=None, offset=None, antiquant_scale=None, antiquant_offset=None, pre_token_scale=None, group_list=None, activation_input=None, activation_quant_scale=None, activation_quant_offset=None, split_item=0, group_type=-1, group_list_type=0, act_type=0):
+def grouped_matmul_v4(x, weight, bias=None, scale=None, offset=None, antiquant_scale=None, antiquant_offset=None, pre_token_scale=None, group_list=None, activation_input=None, activation_quant_scale=None, activation_quant_offset=None, split_item=0, group_type=-1, group_list_type=0, act_type=0, output_dtype=None):
     r"""
     Group calculation matmul.
 
@@ -10572,8 +10525,10 @@ def grouped_matmul_v4(x, weight, bias=None, scale=None, offset=None, antiquant_s
             y_i = x_i\times (weight_i + antiquant\_offset_i) * antiquant\_scale_i + bias_i
 
     .. note::
-        Only when `bias` , `scale` , `offset` , `antiquant_scale` and `antiquant_offset` are all None, `group_type` is 0,
-        and `split_item` is 3, the reverse derivative is supported.
+        - Only when `bias` , `scale` , `offset` , `antiquant_scale` and `antiquant_offset` are all None, `group_type` is 0,
+          and `split_item` is 3, the reverse derivative is supported.
+        - When `x` type is int8 and `weight` type is int4, the `scale` should be of the uint64 data type,
+          but its memory needs to be arranged in float32 format.
         
     ** Per-Token-Quant **
 
@@ -10613,6 +10568,8 @@ def grouped_matmul_v4(x, weight, bias=None, scale=None, offset=None, antiquant_s
                                as the cumsum of grouping size in each group, and 1 represents the positions as the grouping size in
                                each group. Default: ``0``.
         act_type (int): Activation function type. Currently not supported. Default: ``0``.
+        output_dtype (mindspore.dtype): Specifies the output data type, currently taking effect only when input x is int8 and weight is int4.
+                                        If None is passed in, bfloat16 will be used by default. Default: ``None``.
 
 
         Parameter limitations 1
@@ -10703,7 +10660,7 @@ def grouped_matmul_v4(x, weight, bias=None, scale=None, offset=None, antiquant_s
          [108 112]
          [108 112]]
     """
-    return grouped_matmul_v4_op(x, weight, bias, scale, offset, antiquant_scale, antiquant_offset, pre_token_scale, group_list, activation_input, activation_quant_scale, activation_quant_offset, split_item, group_type, group_list_type, act_type)
+    return grouped_matmul_v4_op(x, weight, bias, scale, offset, antiquant_scale, antiquant_offset, pre_token_scale, group_list, activation_input, activation_quant_scale, activation_quant_offset, split_item, group_type, group_list_type, act_type, output_dtype)
 
 
 def kv_cache_scatter_update(var, indices, updates, axis, reduce='none'):