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

mindspore/ops/function/nn_func.py

@@ -41,7 +41,7 @@ from mindspore.ops.operations.nn_ops import TripletMarginLoss
 from mindspore.ops.operations._sequence_ops import TupleToTensor, TensorToTuple, ListToTensor
 from mindspore.common.api import _function_forbid_reuse
 from mindspore.ops.auto_generate import log_softmax, dense, prelu, celu, fast_gelu, silu, elu, sigmoid, relu6, \
-    softmax_impl, swiglu, logsigmoid_op, kl_div_op, divs_op
+    softmax_impl, swiglu, logsigmoid_op, kl_div_op, divs_op, l1_loss_ext
 from mindspore.ops.auto_generate import relu_op, inplace_relu_op
 from mindspore.ops.auto_generate import group_norm_op, rms_norm, add_rms_norm, layer_norm_ext_op, batch_norm_ext_op,\
     mse_loss_ext
@@ -49,13 +49,14 @@ from mindspore.ops.auto_generate import group_norm_op, rms_norm, add_rms_norm, l
 from mindspore.ops.auto_generate import (reflection_pad_1d_op, reflection_pad_2d_op, add_layernorm_v2_op,
                                          reflection_pad_3d_op,  # pylint: disable=W0611
                                          replication_pad_1d_op, replication_pad_2d_op, replication_pad_3d_op,
-                                         constant_pad_nd_op, dropout_ext_op, reverse_v2_impl, avg_pool2d_op,
+                                         constant_pad_nd_op, func_dropout_ext_op, reverse_v2_impl, avg_pool2d_op,
                                          upsample_nearest1d_op, upsample_nearest2d_op, upsample_nearest3d_op,
                                          upsample_linear1d_op, upsample_bilinear2d_op, upsample_bicubic2d_op,
                                          upsample_trilinear3d_impl, fill_scalar_op, floor_op, nllloss_2d_op,
-                                         masked_fill_op, masked_select, ones, flatten_ext, conv_transpose2d)
+                                         masked_fill_op, masked_select, ones, flatten_ext, conv_transpose2d,
+                                         func_max_pool2d_op)
 # 2
-
+from mindspore.ops.auto_generate.pyboost_inner_prim import grid_sampler_2d_impl, grid_sampler_3d_impl
 # 3
 
 # 4
@@ -91,16 +92,16 @@ from mindspore.ops.auto_generate import avg_pool3d_ext_op
 # 19
 
 # 20
-
+from mindspore.ops.functional_overload import conv3d as conv3d_op
 from mindspore.ops.auto_generate.gen_ops_prim import embedding_op, MaxPoolWithIndices, \
     PromptFlashAttention, MaxPoolWithMask
-from mindspore.ops.auto_generate.gen_ops_prim import conv3d_ext_op, conv3d_padding_op, conv2d_ext_op, \
+from mindspore.ops.auto_generate.gen_ops_prim import conv2d_ext_op, \
     conv2d_padding_op, conv1d_ext_op, conv1d_padding_op, speed_fusion_attention_op
 from mindspore.common.generator import default_generator
 from mindspore.ops.auto_generate import hardshrink, hardsigmoid, hardswish
 from mindspore.ops.auto_generate import softshrink
 from mindspore.ops.auto_generate import soft_margin_loss
-from mindspore.ops.auto_generate import moe_token_permute, moe_token_unpermute
+from mindspore.ops.auto_generate import moe_token_permute, moe_token_unpermute, ring_attention_update
 from mindspore.ops.auto_generate import adaptive_avg_pool2d_ext_op
 from mindspore.ops.auto_generate.pyboost_inner_prim import nllloss_impl
 from mindspore.ops.auto_generate.pyboost_inner_prim import adaptive_max_pool2d_impl
@@ -1622,7 +1623,6 @@ def dropout_ext(input, p=0.5, training=True, inplace=False):
         - **output** (Tensor) - Zeroed tensor, with the same shape and data type as `input`.
 
     Raises:
-        TypeError: If `p` is not a float.
         TypeError: If `input` is not a Tensor.
 
     Supported Platforms:
@@ -1636,16 +1636,8 @@ def dropout_ext(input, p=0.5, training=True, inplace=False):
         >>> print(output.shape)
         (2, 2)
     """
-    check_bool_const(training, "training", "dropout_ext")
-    check_bool_const(inplace, "inplace", "dropout_ext")
-    if not training:
-        return input
     seed, offset = default_generator._step(generator_step_)  # pylint: disable=protected-access
-    out, _ = dropout_ext_op(input, p, seed, offset)
-    if inplace:
-        input.copy_(out)
-        return input
-    return out
+    return func_dropout_ext_op(input, p, training, inplace, seed, offset)
 
 
 def dropout1d(input, p=0.5, training=True):
@@ -2394,7 +2386,7 @@ def is_floating_point(input):
         >>> mindspore.ops.is_floating_point(input)
         False
     """
-    return input.dtype in [mstype.float32, mstype.bfloat16, mstype.float16, mstype.float64]
+    return input.dtype in mstype.float_type
 
 
 def _is_dim_unknown(shape):
@@ -4302,6 +4294,15 @@ def nll_loss(inputs, target, weight=None, ignore_index=-100, reduction='mean', l
         \sum_{n=1}^{N} l_{n}, & \text { if reduction }=\text { 'sum' }
         \end{array}\right.
 
+    .. warning::
+        - In GE mode, the rank of `inputs` should be 1D or 2D, the rank of `target` and `weight` should be 1D,
+          and the following restraints should be met:
+
+          - when `inputs` is 1D: target_shape[0] == 1 and weight_shape[0] == inputs_shape[0].
+          - when `inputs` is 2D: target_shape[0] == inputs_shape[0] and weight_shape[0] == inputs_shape[1].
+
+        - On GPU or CPU, `inputs` should be 2D.
+
     Args:
         inputs (Tensor): :math:`(N, C)` where `C = number of classes` or :math:`(N, C, H, W)`
             in case of 2D Loss, or :math:`(N, C, d_1, d_2, ..., d_K)`.
@@ -4420,7 +4421,7 @@ def nll_loss_ext(input, target, weight=None, ignore_index=-100, reduction='mean'
     :math:`N` is the batch size, :math:`c` belonging to :math:`[0, C-1]` is class index,
     where :math:`C` is the number of classes.
 
-    If `reduction` is not ``'None'`` (default ``'mean'``), then
+    If `reduction` is not ``'none'`` (default ``'mean'``), then
 
     .. math::
 
@@ -4444,7 +4445,7 @@ def nll_loss_ext(input, target, weight=None, ignore_index=-100, reduction='mean'
         weight (Tensor, optional): A rescaling weight applied to the loss of each batch element.
             If not None, the shape is :math:`(C,)`.
             The data type must be float16 or float32 or bfloat16(only supported by Atlas A2 training series products).
-            It should have the same data type as `input` . Default: ``'None'`` .
+            It should have the same data type as `input` . Default: ``None`` .
         ignore_index (int, optional): Specifies a target value that is ignored
             and does not contribute to the input gradient. Default: ``-100`` .
         reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
@@ -4481,10 +4482,10 @@ def _nllloss_nd(input, target, weight=None, ignore_index=-100, reduction='mean')
         weight = ones(n_classes, input.dtype)
     if input_dim < 1:
         raise ValueError(f"input dim should be less than 1, but got {input_dim}")
-    if input_dim != 1 and input.shape[0] != target.shape[0]:
+    if F.isconstant(input_dim) and F.isconstant(target.ndim) and input_dim != 1 and input.shape[0] != target.shape[0]:
         raise ValueError(f"input bacth_size should be equal to target batch_size, but got {input.shape[0]} and "
                          f"{target.shape[0]}")
-    if input_dim == 1 or input_dim == 2:
+    if input_dim in [1, 2]:
         return nllloss_impl(input, target, weight, reduction, ignore_index)[0]
     if input_dim == 4:
         return nllloss_2d_op(input, target, weight, reduction, ignore_index)[0]
@@ -4845,8 +4846,9 @@ def smooth_l1_loss(input, target, beta=1.0, reduction='none'):
         >>> print(output)
         [0.  0.  0.5]
     """
-    _smooth_l1_loss = _get_cache_prim(P.SmoothL1Loss)(beta, reduction)
-    return _smooth_l1_loss(input, target)
+    if beta == 0.0:
+        return l1_loss_ext(input, target, reduction)
+    return ops.auto_generate.smooth_l1_loss(input, target, beta=beta, reduction=reduction)
 
 
 def threshold(input, thr, value):
@@ -5365,7 +5367,7 @@ def max_pool3d(x, kernel_size, stride=None, padding=0, dilation=1, ceil_mode=Fal
     return out
 
 
-def grid_sample(input, grid, mode='bilinear', padding_mode='zeros', align_corners=False):
+def grid_sample(input, grid, mode='bilinear', padding_mode='zeros', align_corners=None):
     """
     Given an `input` and a flow-field `grid`, computes the `output` using `input` values and pixel locations from
     `grid`. Only spatial (4-D) and volumetric (5-D) `input` is supported.
@@ -5411,10 +5413,10 @@ def grid_sample(input, grid, mode='bilinear', padding_mode='zeros', align_corner
         padding_mode (str, optional): An optional string specifying the pad method.
             The optional values are "zeros", "border" or
             "reflection". Default: ``'zeros'`` .
-        align_corners (bool, optional): If set to `True`, the extrema (-1 and 1) are considered as referring to
+        align_corners (bool, optional): If set to ``True``, the extrema (-1 and 1) are considered as referring to
             the center points of the input's corner pixels. If set to `False`, they are instead considered as referring
             to the corner points of the input's corner pixels, making the sampling more resolution agnostic. Default:
-            ``False`` .
+            ``None``, which is the same as ``False`` .
 
     Returns:
         Tensor, dtype is the same as `input` and whose shape is :math:`(N, C, H_{out}, W_{out})` (4-D) and
@@ -5451,11 +5453,10 @@ def grid_sample(input, grid, mode='bilinear', padding_mode='zeros', align_corner
           [[14.5      ]
            [14.8      ]]]]
     """
+    align_corners = False if align_corners is None else align_corners
     if input.ndim == 4:
-        _grid_sampler_2d = _get_cache_prim(NN_OPS.GridSampler2D)(mode, padding_mode, align_corners)
-        return _grid_sampler_2d(input, grid)
-    _grid_sampler_3d = _get_cache_prim(NN_OPS.GridSampler3D)(mode, padding_mode, align_corners)
-    return _grid_sampler_3d(input, grid)
+        return grid_sampler_2d_impl(input, grid, mode, padding_mode, align_corners)
+    return grid_sampler_3d_impl(input, grid, mode, padding_mode, align_corners)
 
 
 @constexpr
@@ -6307,7 +6308,7 @@ def conv1d_ext(input, weight, bias=None, stride=1, padding=0, dilation=1, groups
             this 1D convolution layer also can be called 1D depthwise convolution layer. Default: ``1`` .
 
             - :math:`(C_{in} \text{ % } \text{groups} == 0)` , :math:`(C_{out} \text{ % } \text{groups} == 0)` ,
-              :math:`(C_{out} >= \text{groups})` , :math:`(\text{kernel_size[1]} = C_{in} / \text{groups})`。
+              :math:`(C_{out} >= \text{groups})` , :math:`(\text{weight[1]} = C_{in} / \text{groups})`。
 
     Returns:
         Tensor, the value that applied 1D convolution. The shape is :math:`(N, C_{out}, L_{out})`.
@@ -6372,9 +6373,9 @@ def _get_pad_info(dilation, weight):
     for i in range(2):
         d = dilation[i]
         weight_size = weight.shape[i + 2]
-        pad = d * (weight_size - 1)
-        pad_l += (int(pad / 2),)
-        pad_r += (int(pad - pad_l[i]),)
+        pad_item = d * (weight_size - 1)
+        pad_l += (int(pad_item / 2),)
+        pad_r += (int(pad_item - pad_l[i]),)
         if pad_l[i] != pad_r[i]:
             need_pad_nd = True
     return need_pad_nd, pad_l, pad_r
@@ -6438,9 +6439,6 @@ def conv2d_ext(input, weight, bias=None, stride=1, padding=0, dilation=1, groups
     <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_ and
     `ConvNets <http://cs231n.github.io/convolutional-networks/>`_.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         input (Tensor): Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})` or :math:`(C_{in}, H_{in}, W_{in})`.
         weight (Tensor): Tensor of shape
@@ -6477,7 +6475,7 @@ def conv2d_ext(input, weight, bias=None, stride=1, padding=0, dilation=1, groups
         groups (int, optional): Splits `input` into groups. Default: ``1`` .
 
             - :math:`(C_{in} \text{ % } \text{groups} == 0)` , :math:`(C_{out} \text{ % } \text{groups} == 0)` ,
-              :math:`(C_{out} >= \text{groups})` , :math:`(\text{kernel_size[1]} = C_{in} / \text{groups})`
+              :math:`(C_{out} >= \text{groups})` , :math:`(\text{weight[1]} = C_{in} / \text{groups})`
 
     Returns:
         Tensor, the value that applied 2D convolution. The shape is :math:`(N, C_{out}, H_{out}, W_{out})`.
@@ -6981,10 +6979,6 @@ def batch_norm_ext(input, running_mean, running_var, weight=None, bias=None, tra
         [[ 2.1621194  1.2360122]
          [14.810596  10.180061 ]]
     """
-    if weight is None:
-        weight = ops.ones([input.shape[1]], dtype=input.dtype)
-    if bias is None:
-        bias = ops.zeros([input.shape[1]], dtype=input.dtype)
     output = batch_norm_ext_op(input, weight, bias, running_mean, running_var, training, momentum, eps)
     return output[0]
 
@@ -7382,8 +7376,8 @@ def conv3d_ext(input, weight, bias=None, stride=1, padding=0, dilation=1, groups
     - :math:`H_{out} = (H_{in} + PadUp + PadDown - ((kh - 1) * DilationH + 1)) / StrideH + 1` .
     - :math:`W_{out} = (W_{in} + PadLeft + PadRight - ((kw - 1) * DilationW + 1)) / StrideW + 1` .
     - :math:`D_{out} = (D_{in} + PadFront + PadBack - ((kd - 1) * DilationD + 1)) / StrideD + 1` .
-    - :math:`(D_{in}+PadFront+PadBack - ((kd-1)*DilationD+1)) /% StrideD <= PadBack` .
-    - :math:`(H_{in}+PadUp+PadDown - ((kh-1)*Dilationh+1)) /% StrideH <= PadDown` .
+    - :math:`(D_{in}+PadFront+PadBack - ((kd-1)*DilationD+1)) \% StrideD <= PadBack` .
+    - :math:`(H_{in}+PadUp+PadDown - ((kh-1)*Dilationh+1)) \% StrideH <= PadDown` .
     - :math:`stride_d <= kernel_d` .
     - :math:`PadUp < kh` and :math:`PadDown < kh` . When `padding` = ``'valid'``, both PadUp and PadDown are zeros.
       When `padding` = ``'same'``, pad can be calculated by
@@ -7396,7 +7390,6 @@ def conv3d_ext(input, weight, bias=None, stride=1, padding=0, dilation=1, groups
 
     .. warning::
         This API does not support Atlas series products.
-        This is an experimental API that is subject to change or deletion.
 
     Args:
         input (Tensor): Tensor of shape :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`.
@@ -7450,12 +7443,7 @@ def conv3d_ext(input, weight, bias=None, stride=1, padding=0, dilation=1, groups
         (12, 26, 59, 47, 5)
     """
 
-    if isinstance(padding, (tuple, list, int)):
-        return conv3d_ext_op(input, weight, bias, stride, padding, dilation, groups)
-    if isinstance(padding, str):
-        return conv3d_padding_op(input, weight, bias, stride, padding, dilation, groups)
-    raise TypeError(f"For conv3d, the parameter 'padding' must be a tuple/list " \
-                    f"or a string, but got {type(padding)}")
+    return conv3d_op(input, weight, bias, stride, padding, dilation, groups)
 
 
 @_primexpr
@@ -7523,7 +7511,7 @@ def pixel_shuffle(input, upscale_factor):
     c, h, w = idx[-3:]
     _check_pxiel_shuffle_valid(c, upscale_factor)
     c = c // upscale_factor ** 2
-    input_perm = (pre + (c, upscale_factor, upscale_factor, h, w))
+    input_perm = pre + (c, upscale_factor, upscale_factor, h, w)
     input = reshape_(input, input_perm)
     input_perm = [i for i in range(length - 2)]
     input_perm = input_perm + [length, length - 2, length + 1, length - 1]
@@ -7587,7 +7575,7 @@ def pixel_unshuffle(input, downscale_factor):
     _check_pxiel_unshuffle_valid(h, w, downscale_factor)
     h = h // downscale_factor
     w = w // downscale_factor
-    input_perm = (pre + (c, h, downscale_factor, w, downscale_factor))
+    input_perm = pre + (c, h, downscale_factor, w, downscale_factor)
     input = reshape_(input, input_perm)
     input_perm = [i for i in range(length - 2)]
     input_perm = input_perm + [length - 1, length + 1, length - 2, length]
@@ -8912,13 +8900,7 @@ def max_pool2d_ext(input, kernel_size, stride=None, padding=0, dilation=1, ceil_
         >>> print(argmax.shape)
         (20, 16, 24, 31)
     """
-    strides = stride if (stride is not None) else kernel_size
-    if return_indices:
-        max_pool_func_ = _get_cache_prim(MaxPoolWithIndices)(kernel_size, strides, padding, dilation, ceil_mode)
-        out, indices = max_pool_func_(input)
-    else:
-        max_pool_func_ = _get_cache_prim(MaxPoolWithMask)(kernel_size, strides, padding, dilation, ceil_mode)
-        out, indices = max_pool_func_(input)
+    out, indices = func_max_pool2d_op(input, kernel_size, stride, padding, dilation, ceil_mode, return_indices)
     if return_indices:
         return out, indices
     return out
@@ -9668,6 +9650,7 @@ __all__ = [
     'lp_pool2d',
     'moe_token_permute',
     'moe_token_unpermute',
+    'ring_attention_update',
     'max_unpool1d',
     'max_unpool2d',
     'max_unpool3d',

mindspore/ops/function/other_func.py

@@ -15,6 +15,7 @@
 """Defines other operators with functional form."""
 from mindspore.ops import operations as P
 from mindspore.ops.auto_generate import rotary_position_embedding
+from mindspore.ops.auto_generate import moe_distribute_dispatch, moe_distribute_combine
 from mindspore.ops.auto_generate.gen_ops_prim import moe_init_routing_v2_op
 
 partial_ = P.Partial()
@@ -268,6 +269,8 @@ __all__ = [
     'partial',
     'rotary_position_embedding',
     'move_to',
-    'moe_init_routing_v2'
+    'moe_init_routing_v2',
+    'moe_distribute_dispatch',
+    'moe_distribute_combine'
 ]
 __all__.sort()

mindspore/ops/function/random_func.py

@@ -296,7 +296,7 @@ def uniform_(input, from_=0, to=1, *, generator=None):
     Returns:
         Tensor, with the same shape and dtype as `input` tensor.
 
-   Raises:
+    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, float64,
             bfloat16.
@@ -765,9 +765,9 @@ def normal_ext(mean=0.0, std=1.0, size=None, generator=None):
     Generates random numbers according to the standard Normal (or Gaussian) random number distribution.
 
     Args:
-        mean (Union[float, Tensor]): Mean value of each element, the shape of the `mean` tensor
+        mean (Union[Tensor]): Mean value of each element, the shape of the `mean` tensor
             should be the same as that of the `std` tensor.
-        std (Union[float, Tensor]): Standard deviation for each element, the shape of the `std` tensor
+        std (Union[Tensor]): Standard deviation for each element, the shape of the `std` tensor
             should be the same as that of the `mean` tensor. The value of `std` should be greater than or equal to 0.
 
     Keyword Args:
@@ -793,6 +793,33 @@ def normal_ext(mean=0.0, std=1.0, size=None, generator=None):
         >>> print(output.shape)
         (3,)
 
+    .. function:: normal(mean, std) -> Tensor
+        :noindex:
+
+    Similar to the function above, but the means are shared among all drawn elements.
+
+    Args:
+        mean (float): Mean value of each element.
+        std (Tensor): Standard deviation for each element. The value of `std` should be greater
+            than or equal to 0.
+
+    Returns:
+        Outputs a tensor with the same shape as `std`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import ops
+        >>> from mindspore import Tensor
+        >>> mean = 1.
+        >>> std = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
+        >>> output = ops.function.random_func.normal_ext(mean, std)
+        >>> print(output.shape)
+        (3,)
+
     .. function:: normal(mean, std=1.0) -> Tensor
         :noindex:
 
@@ -1007,7 +1034,7 @@ def gamma(shape, alpha, beta, seed=None):
         (3, 2, 2)
         >>> # case 2: alpha_shape is (2, 3), so shape is (3, 1, 3)
         >>> shape = (3, 1, 3)
-        >>> alpha = mindspore.tensor([[1, 3, 4], [2, 5, 6]]), mindspore.float32)
+        >>> alpha = mindspore.tensor([[1, 3, 4], [2, 5, 6]], mindspore.float32)
         >>> beta = mindspore.tensor([1.0], mindspore.float32)
         >>> output = mindspore.ops.gamma(shape, alpha, beta, seed=5)
         >>> result = output.shape

mindspore/ops/functional.py

@@ -20,7 +20,7 @@ from mindspore.common._register_for_tensor import tensor_operator_registry
 from mindspore.ops import _constants
 from mindspore.ops.function import *
 from mindspore.ops.function.array_func import chunk_ext, zero_
-from mindspore.ops.function.math_func import all, argmax_ext, float_power_ext, erfinv_, tanh_, bernoulli_ext
+from mindspore.ops.function.math_func import all, argmax_ext, float_power_ext, erfinv_, tanh_, bernoulli_ext, bernoulli_
 from mindspore.ops.function.random_func import random_, uniform_ext, uniform_, normal_, exponential_
 from mindspore.ops import operations as P
 from mindspore.ops.operations import array_ops
@@ -33,7 +33,6 @@ from mindspore.ops.operations.nn_ops import AdaptiveMaxPool2D
 from mindspore.ops.operations.math_ops import Roll
 from mindspore.ops.composite.math_ops import mm
 from mindspore.ops.function.math_func import dot
-from mindspore.ops.function.array_func import new_empty
 from mindspore.ops import auto_generate
 from mindspore.ops.auto_generate import cast
 from mindspore.ops._utils.arg_dtype_cast import DtypeToEnum
@@ -383,7 +382,6 @@ setattr(tensor_operator_registry, 'nanmedian', nanmedian)
 setattr(tensor_operator_registry, 'csr_to_coo', csr_to_coo)
 setattr(tensor_operator_registry, 'zeros', zeros)
 setattr(tensor_operator_registry, 'ones', ones)
-setattr(tensor_operator_registry, 'new_empty', new_empty)
 setattr(tensor_operator_registry, 'unsorted_segment_min', unsorted_segment_min)
 setattr(tensor_operator_registry, 'unsorted_segment_max', unsorted_segment_max)
 setattr(tensor_operator_registry, 'unsorted_segment_prod', unsorted_segment_prod)
@@ -399,6 +397,7 @@ setattr(tensor_operator_registry, 'inplace_scatter_add', auto_generate.inplace_s
 setattr(tensor_operator_registry, 'slice_scatter', slice_scatter)
 setattr(tensor_operator_registry, 'select_scatter', select_scatter)
 setattr(tensor_operator_registry, 'bernoulli', bernoulli_ext)
+setattr(tensor_operator_registry, 'bernoulli_', bernoulli_)
 setattr(tensor_operator_registry, 'poisson', P.Poisson)
 setattr(tensor_operator_registry, 'randperm', P.Randperm)
 setattr(tensor_operator_registry, 'multinomial', multinomial)