mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/ops/composite/multitype_ops/setitem_impl.py

@@ -21,8 +21,8 @@ from mindspore.ops import functional as F
 from mindspore.ops.operations._inner_ops import SliceGetItem
 from mindspore.ops.operations import _map_tensor_ops
 from mindspore.ops.composite import base
-from mindspore.common import Tensor
 from mindspore.ops.composite.base import _dict_setitem
+from mindspore.ops.operations._sequence_ops import TensorToScalar
 from ...operations._sequence_ops import SequenceSliceSetItem
 
 DOC_URL = "https://mindspore.cn/search/en?inputValue=Index%20value%20assignment"
@@ -105,6 +105,23 @@ def _list_setitem_with_tensor(data, number_index, value):
     return F.list_setitem(data, number_index, value)
 
 
+@setitem.register("List", "Tensor", "Tensor")
+def _list_setitem_with_tensor_index(data, tensor_index, value):
+    """
+    Assigns value to list.
+
+    Inputs:
+        data (list): Data of type list.
+        tensor_index (Tensor): Index of data.
+        value (Tensor): Value given.
+
+    Outputs:
+        list, type is the same as the element type of data.
+    """
+    number_index = TensorToScalar()(tensor_index)
+    return F.list_setitem(data, number_index, value)
+
+
 @setitem.register("List", "Number", "List")
 def _list_setitem_with_list(data, number_index, value):
     """
@@ -777,11 +794,8 @@ def _tensor_setitem_by_list_with_number(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
-    # list indices will be converted to tuple or tensor based on its contents.
-    index = compile_utils.format_list_indices(index, data.shape[0])
-    if isinstance(index, Tensor):
-        return compile_utils.tensor_setitem_by_tensor_with_number(data, index, value)
-    return compile_utils.tensor_setitem_by_tuple_with_number(data, index, value)
+    value = F.cast(value, F.dtype(data))
+    return compile_utils.tensor_setitem_by_list(data, index, value)
 
 
 @setitem.register("Tensor", "List", "Tensor")
@@ -801,11 +815,7 @@ def _tensor_setitem_by_list_with_tensor(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
-    # list indices will be converted to tuple or tensor based on its contents.
-    index = compile_utils.format_list_indices(index, data.shape[0])
-    if isinstance(index, Tensor):
-        return compile_utils.tensor_setitem_by_tensor_with_tensor(data, index, value)
-    return compile_utils.tensor_setitem_by_tuple_with_tensor(data, index, value)
+    return compile_utils.tensor_setitem_by_list(data, index, value)
 
 
 @setitem.register("Tensor", "List", "Tuple")
@@ -825,11 +835,8 @@ def _tensor_setitem_by_list_with_tuple(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
-    # list indices will be converted to tuple or tensor based on its contents.
-    index = compile_utils.format_list_indices(index, data.shape[0])
-    if isinstance(index, Tensor):
-        return compile_utils.tensor_setitem_by_tensor_with_sequence(data, index, value)
-    return compile_utils.tensor_setitem_by_tuple_with_sequence(data, index, value)
+    value = compile_utils.sequence_to_tensor(value, F.dtype(data))
+    return compile_utils.tensor_setitem_by_list(data, index, value)
 
 
 @setitem.register("Tensor", "List", "List")
@@ -849,11 +856,8 @@ def _tensor_setitem_by_list_with_list(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
-    # list indices will be converted to tuple or tensor based on its contents.
-    index = compile_utils.format_list_indices(index, data.shape[0])
-    if isinstance(index, Tensor):
-        return compile_utils.tensor_setitem_by_tensor_with_sequence(data, index, value)
-    return compile_utils.tensor_setitem_by_tuple_with_sequence(data, index, value)
+    value = compile_utils.sequence_to_tensor(value, F.dtype(data))
+    return compile_utils.tensor_setitem_by_list(data, index, value)
 
 
 @setitem.register("MapTensor", "Tensor", "Tensor")
@@ -871,3 +875,10 @@ def _map_tensor_setitem(map_tensor, key_tensor, value_tensor):
     """
     _map_tensor_ops.put(map_tensor, key_tensor, value_tensor)
     return map_tensor
+
+
+@setitem.register_default()
+def default_getitem(x, y, z):
+    """Default function for setitem."""
+    x[y] = z
+    return x

mindspore/ops/composite/multitype_ops/sub_impl.py

@@ -108,3 +108,9 @@ def _cootensor_sub_tensor(x, y):
     """Returns x - y where x is a COO tensor and y is a tensor."""
     check_equal(x.shape, y.shape, "input1 (shape={}) and input2(shape={}) should be the same shape.")
     return F.tensor_scatter_add(-y, x.indices, x.values)
+
+
+@sub.register_default()
+def default_sub(x, y):
+    """Default function for sub."""
+    return x - y

mindspore/ops/composite/multitype_ops/zeros_like_impl.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ============================================================================
 
-"""Implementation for internal polymorphism `zeros_like_leaf` operations."""
+"""Implementation for internal polymorphism `zeros_like` operations."""
 
 from __future__ import absolute_import
 from mindspore.ops.composite import base
@@ -21,9 +21,9 @@ from mindspore.ops import functional as F
 from mindspore.ops.operations import _sequence_ops as seq
 from mindspore.ops.primitive import Primitive
 
-zeros_like_leaf = base.MultitypeFuncGraph('zeros_like_leaf', True)
+zeros_like_leaf = base.MultitypeFuncGraph('zeros_like', True)
 """
-`zeros_like_leaf` is a metafuncgraph object which will generate a tensor filled with one according to its input type
+`zeros_like` is a metafuncgraph object which will generate a tensor filled with one according to its input type
 using ".register" decorator.
 """
 
@@ -41,16 +41,19 @@ def _zeros_like_bool(x):
     """Returns False if x is a bool."""
     return False
 
+
 @zeros_like_leaf.register("String")
 def _zeros_like_string(x):
     """Returns False if x is a string."""
     return 0
 
+
 @zeros_like_leaf.register("Tuple")
 def _zeros_like_tuple(x):
     """Returns False if x is a tuple."""
     return 0
 
+
 @zeros_like_leaf.register("Function")
 def _zeros_like_func(x):
     """

mindspore/ops/deprecated.py

@@ -69,7 +69,10 @@ class BNTrainingUpdate(Primitive):
 
 class MaxPoolWithArgmax(Primitive):
     """
-    Please use MaxPoolWithArgmaxV2 instead.
+    Please use :class:`mindspore.ops.MaxPoolWithArgmaxV2` instead.
+
+    Supported Platforms:
+        Deprecated
     """
     @deprecated("2.0", "ops.MaxPoolWithArgmaxV2", False)
     @prim_attr_register
@@ -105,7 +108,6 @@ class DropoutGenMask(Primitive):
     @prim_attr_register
     def __init__(self, Seed0=0, Seed1=0):
         """Initialize DropoutGenMask."""
-        super().__init__(name="DropoutGenMask")
         self.init_prim_io_names(inputs=['shape', 'keep_prob'], outputs=['output'])
         validator.check_value_type("Seed0", Seed0, [int], self.name)
         validator.check_value_type("Seed1", Seed1, [int], self.name)
@@ -159,7 +161,10 @@ class TensorAdd(_MathBinaryOp):
 
 class InplaceUpdate(Primitive):
     """
-    Please use InplaceUpdateV2 instead.
+    Please use :class:`mindspore.ops.InplaceUpdateV2` instead.
+
+    Supported Platforms:
+        Deprecated
     """
     @deprecated("2.0", "ops.InplaceUpdateV2", False)
     @prim_attr_register
@@ -239,6 +244,9 @@ class Unpack(Primitive):
 class ScatterNonAliasingAdd(Primitive):
     """
     Please use TensorScatterAdd instead.
+
+    Supported Platforms:
+        Deprecated
     """
     __mindspore_signature__ = (
         sig.make_sig('input_x', sig.sig_rw.RW_WRITE, dtype=sig.sig_dtype.T),
@@ -257,6 +265,9 @@ class ScatterNonAliasingAdd(Primitive):
 class BatchToSpaceND(Primitive):
     """
     Please use batch_to_space_nd instead.
+
+    Supported Platforms:
+        Deprecated
     """
     @deprecated("2.0", "ops.batch_to_space_nd", False)
     @prim_attr_register

mindspore/ops/function/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2022 Huawei Technologies Co., Ltd
+# Copyright 2022-2024 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.
@@ -26,6 +26,8 @@ from . import (
     nn_func,
     linalg_func,
     clip_func,
+    fft_func,
+    reshard_func
 )
 from .array_func import (
     unique,
@@ -41,6 +43,7 @@ from .array_func import (
     size,
     ones,
     ones_like,
+    zero_,
     zeros,
     zeros_like,
     shape,
@@ -86,7 +89,6 @@ from .array_func import (
     gather_elements,
     gather_nd,
     is_tensor,
-    scalar_cast,
     masked_fill,
     narrow,
     tensor_scatter_add,
@@ -111,8 +113,8 @@ from .array_func import (
     is_nonzero,
     space_to_batch_nd,
     batch_to_space_nd,
-    range,
     arange,
+    range,
     select,
     one_hot,
     matrix_diag,
@@ -129,6 +131,7 @@ from .array_func import (
     unsorted_segment_sum,
     col2im,
     split,
+    split_ext,
     tensor_split,
     vsplit,
     hsplit,
@@ -162,7 +165,8 @@ from .array_func import (
     aminmax,
     sort,
     top_k,
-    deepcopy
+    deepcopy,
+    arange_ext,
 )
 from .parameter_func import (
     assign,
@@ -185,7 +189,6 @@ from .math_func import (
     add,
     addcdiv,
     addcmul,
-    neg_tensor,
     neg,
     negative,
     tensor_lt,
@@ -361,6 +364,7 @@ from .math_func import (
     matmul,
     inner,
     baddbmm,
+    baddbmm_ext,
     cummin,
     cummax,
     cumsum,
@@ -394,6 +398,7 @@ from .math_func import (
     kron,
     rot90,
     remainder,
+    remainder_ext,
     iou,
     bmm,
     trapz,
@@ -434,12 +439,6 @@ from .math_func import (
     trace,
     zeta,
     histc,
-    fft,
-    fft2,
-    fftn,
-    ifft,
-    ifft2,
-    ifftn,
     count_nonzero,
     tensor_dot,
     vecdot,
@@ -450,6 +449,7 @@ from .math_func import (
 from .nn_func import (
     adaptive_avg_pool1d,
     adaptive_avg_pool2d,
+    adaptive_avg_pool2d_ext,
     adaptive_avg_pool3d,
     adaptive_max_pool1d,
     adaptive_max_pool2d,
@@ -460,6 +460,7 @@ from .nn_func import (
     max_pool2d,
     max_pool3d,
     batch_norm,
+    rms_norm,
     bidense,
     celu,
     bias_add,
@@ -471,6 +472,7 @@ from .nn_func import (
     dropout3d,
     dense,
     deformable_conv2d,
+    embedding,
     fast_gelu,
     flip,
     fliplr,
@@ -482,10 +484,13 @@ from .nn_func import (
     hardshrink,
     soft_shrink,
     is_floating_point,
+    incre_flash_attention,
     intopk,
     interpolate,
     upsample,
     kl_div,
+    layer_norm,
+    add_layer_norm,
     log_softmax,
     lrn,
     mish,
@@ -509,6 +514,7 @@ from .nn_func import (
     prelu,
     mirror_pad,
     nll_loss,
+    mse_loss_ext,
     smooth_l1_loss,
     l1_loss,
     threshold,
@@ -521,6 +527,7 @@ from .nn_func import (
     conv3d_transpose,
     conv1d,
     conv2d,
+    conv_transpose2d,
     sigmoid,
     logsigmoid,
     relu,
@@ -528,6 +535,7 @@ from .nn_func import (
     rrelu,
     conv3d,
     glu,
+    swiglu,
     multi_margin_loss,
     multilabel_margin_loss,
     multilabel_soft_margin_loss,
@@ -542,6 +550,7 @@ from .nn_func import (
     msort,
     channel_shuffle,
     hardsigmoid,
+    group_norm,
 )
 from .linalg_func import (
     cond,
@@ -629,6 +638,7 @@ from .grad import (
 )
 from .debug_func import (
     print_,
+    tensordump
 )
 from .image_func import (
     bounding_box_decode,
@@ -716,10 +726,40 @@ from .clip_func import (
     clip,
     clip_by_global_norm,
 )
+from .fft_func import (
+    fft,
+    fft2,
+    fftn,
+    fftshift,
+    ifft,
+    ifft2,
+    ifftn,
+    ifftshift,
+    rfft,
+    irfft,
+    rfft2,
+    irfft2,
+    rfftn,
+    irfftn,
+    hfft,
+    ihfft,
+    hfft2,
+    ihfft2,
+    hfftn,
+    ihfftn,
+    fftfreq,
+    rfftfreq
+)
 from .other_func import (
     depend,
     partial,
+    rotary_position_embedding,
 )
+from .reshard_func import (
+    reshard,
+)
+
+from ..operations.manually_defined import (rank, scalar_cast)
 
 __all__ = []
 __all__.extend(array_func.__all__)
@@ -736,5 +776,7 @@ __all__.extend(spectral_func.__all__)
 __all__.extend(vmap_func.__all__)
 __all__.extend(sparse_unary_func.__all__)
 __all__.extend(clip_func.__all__)
+__all__.extend(fft_func.__all__)
 __all__.extend(other_func.__all__)
+__all__.extend(reshard_func.__all__)
 __all__.sort()