mindspore 2.4.10__cp39-cp39-win_amd64.whl → 2.6.0__cp39-cp39-win_amd64.whl

mindspore/ops/composite/multitype_ops/getitem_impl.py

@@ -265,7 +265,7 @@ def _string_getitem_by_number(data, number_index):
     Getting item of string by number index.
 
     Inputs:
-        data (String): A string.
+        data (str): A string.
         number_index (Number): Index in scalar.
 
     Outputs:
@@ -394,7 +394,8 @@ def _map_tensor_getitem(map_tensor, key_tensor):
     return _map_tensor_ops.MapTensorGet(True)(map_tensor, key_tensor)
 
 
-@getitem.register_default()
+# pylint: disable=protected-access
+@getitem._register_default()
 def default_getitem(x, y):
     """Default function for getitem."""
     return x[y]

mindspore/ops/composite/multitype_ops/greater_equal_impl.py

@@ -47,8 +47,8 @@ def _greater_equal_string(x, y):
     Determine whether x is greater than or equal to y.
 
     Args:
-       x(String): String.
-       y(String): String.
+       x(str): String.
+       y(str): String.
 
     Returns:
        bool, if x >= y return true, x < y return false.
@@ -103,7 +103,8 @@ def _greater_equal_list(x, y):
     return list_greater_equal()(x, y)
 
 
-@greater_equal.register_default()
+# pylint: disable=protected-access
+@greater_equal._register_default()
 def default_greater_equal(x, y):
     """Default function for greater equal."""
     return x >= y

mindspore/ops/composite/multitype_ops/greater_impl.py

@@ -48,8 +48,8 @@ def _greater_string(x, y):
     Determine whether x is greater than y.
 
     Args:
-       x(String): String.
-       y(String): String.
+       x(str): String.
+       y(str): String.
 
     Returns:
        bool, if x > y return true, x <= y return false.
@@ -104,7 +104,8 @@ def _greater_than_list(x, y):
     return list_greater_than()(x, y)
 
 
-@greater.register_default()
+# pylint: disable=protected-access
+@greater._register_default()
 def default_greater(x, y):
     """Default function for greater."""
     return x > y

mindspore/ops/composite/multitype_ops/in_impl.py

@@ -190,7 +190,8 @@ def _mstype_in_tuple(x, y):
     return const_utils.check_in_sequence(x, y)
 
 
-@in_.register_default()
+# pylint: disable=protected-access
+@in_._register_default()
 def default_in(x, y):
     """Default function for in."""
     return x in y

mindspore/ops/composite/multitype_ops/invert_impl.py

@@ -0,0 +1,50 @@
+# Copyright 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""Implementation for internal polymorphism `invert` operations."""
+from mindspore.ops.composite import base
+from mindspore.ops import functional as F
+
+
+invert = base.MultitypeFuncGraph('invert', True)
+
+@invert.register("Number")
+def _invert_scalar(x):
+    """
+    return the inverted value of x.
+
+    Args:
+        x (Number): x
+    Returns:
+        Number. Equal to -x-1, has the same type of x.
+    """
+    if isinstance(x, bool):
+        if x:
+            return -2
+        return -1
+    if not isinstance(x, int):
+        raise TypeError(f"bad operand type for unary ~: '{type(x)}")
+    return -x-1
+
+@invert.register("Tensor")
+def _invert_tensor(x):
+    """
+    return the inverted tensor of x.
+    Arg:
+        x (Tensor): x
+    Returns:
+        Tensor.
+    """
+    return F.logical_not(x)

mindspore/ops/composite/multitype_ops/left_shift_impl.py

@@ -31,7 +31,8 @@ def _left_shift_scalar(x, y):
     return inner.bit_left_shift(x, y)
 
 
-@left_shift.register_default()
+# pylint: disable=protected-access
+@left_shift._register_default()
 def default_left_shift(x, y):
     """Default function for left shift."""
     return x << y

mindspore/ops/composite/multitype_ops/less_equal_impl.py

@@ -49,8 +49,8 @@ def _less_equal_string(x, y):
     Determine whether x is less than or equal to y.
 
     Args:
-       x(String): String.
-       y(String): String.
+       x(str): String.
+       y(str): String.
 
     Returns:
        bool, if x <= y return true, x > y return false.
@@ -105,7 +105,8 @@ def _less_equal_list(x, y):
     return _seq.list_le()(x, y)
 
 
-@less_equal.register_default()
+# pylint: disable=protected-access
+@less_equal._register_default()
 def default_less_equal(x, y):
     """Default function for less equal."""
     return x <= y

mindspore/ops/composite/multitype_ops/less_impl.py

@@ -50,8 +50,8 @@ def _less_string(x, y):
     Determine whether x is less than y.
 
     Args:
-       x(String): String.
-       y(String): String.
+       x(str): String.
+       y(str): String.
 
     Returns:
        bool, if x < y return true, x >= y return false.
@@ -106,7 +106,8 @@ def _less_list(x, y):
     return _seq.list_lt()(x, y)
 
 
-@less.register_default()
+# pylint: disable=protected-access
+@less._register_default()
 def default_less(x, y):
     """Default function for less."""
     return x < y

mindspore/ops/composite/multitype_ops/logic_not_impl.py

@@ -43,7 +43,7 @@ def _logical_not_string(x):
     Return logical not operation result of x.
 
     Args:
-       x(String): String.
+       x(str): String.
 
     Returns:
        bool, Return logical not operation result of x.
@@ -107,7 +107,8 @@ def _logical_not_list(x):
     return x.__len__() == 0
 
 
-@logical_not.register_default()
+# pylint: disable=protected-access
+@logical_not._register_default()
 def default_logical_not(x):
     """Default function for logical not."""
     return not x

mindspore/ops/composite/multitype_ops/logical_and_impl.py

@@ -54,7 +54,8 @@ def _logical_and_tensor(x, y):
     return F.logical_and(x, y)
 
 
-@logical_and.register_default()
+# pylint: disable=protected-access
+@logical_and._register_default()
 def default_logical_and(x, y):
     """Default function for logical and."""
     return x and y

mindspore/ops/composite/multitype_ops/logical_or_impl.py

@@ -55,7 +55,8 @@ def _logical_or_tensor(x, y):
     return F.logical_or(x, y)
 
 
-@logical_or.register_default()
+# pylint: disable=protected-access
+@logical_or._register_default()
 def default_logical_or(x, y):
     """Default function for logical or."""
     return x or y

mindspore/ops/composite/multitype_ops/mod_impl.py

@@ -80,7 +80,8 @@ def _tensor_mod_list(x, y):
     return F.tensor_mod(x, y)
 
 
-@mod.register_default()
+# pylint: disable=protected-access
+@mod._register_default()
 def default_mod(x, y):
     """Default function for mod."""
     return x % y

mindspore/ops/composite/multitype_ops/mul_impl.py

@@ -71,7 +71,7 @@ def _tensor_mul_scalar(x, y):
     Outputs:
         Tensor, has the same dtype as x.
     """
-    return F.tensor_mul(x, y)
+    return F.tensor_muls(x, y)
 
 
 @mul.register("Number", "String")
@@ -288,7 +288,8 @@ def _tensor_mul_cootensor(x, y):
     return COOTensor(y.indices, y.values * other_values, y.shape)
 
 
-@mul.register_default()
+# pylint: disable=protected-access
+@mul._register_default()
 def default_mul(x, y):
     """Default function for mul."""
     return x * y

mindspore/ops/composite/multitype_ops/negative_impl.py

@@ -73,7 +73,8 @@ def _negative_cootensor(x):
     return COOTensor(x.indices, F.neg(x.values), x.shape)
 
 
-@negative.register_default()
+# pylint: disable=protected-access
+@negative._register_default()
 def default_negative(x):
     """Default function for negative."""
     return -x

mindspore/ops/composite/multitype_ops/not_equal_impl.py

@@ -284,7 +284,8 @@ def _none_not_equal_list(x, y):
     return True
 
 
-@not_equal.register_default()
+# pylint: disable=protected-access
+@not_equal._register_default()
 def default_not_equal(x, y):
     """Default function for not equal."""
     return x != y

mindspore/ops/composite/multitype_ops/not_in_impl.py

@@ -190,7 +190,8 @@ def _mstype_not_in_tuple(x, y):
     return not const_utils.check_in_sequence(x, y)
 
 
-@not_in_.register_default()
+# pylint: disable=protected-access
+@not_in_._register_default()
 def default_not_in(x, y):
     """Default function for not in."""
     return x not in y

mindspore/ops/composite/multitype_ops/ones_like_impl.py

@@ -29,13 +29,17 @@ ones_like_leaf = base.MultitypeFuncGraph('ones_like', True)
 using ".register" decorator.
 """
 
+_ones_like_leaf_for_grad = base.MultitypeFuncGraph('_ones_like_for_grad', True)
 
+
+@_ones_like_leaf_for_grad.register("TypeType")
 @ones_like_leaf.register("TypeType")
 def _ones_like_type_type(x):
     """Returns x because x is a type. This is usually used in backprop progress."""
     return x
 
 
+@_ones_like_leaf_for_grad.register("Number")
 @ones_like_leaf.register("Number")
 def _ones_like_scalar(x):
     """Returns 1 which has the same dtype as x where x is a scalar."""
@@ -43,12 +47,14 @@ def _ones_like_scalar(x):
     return F.scalar_cast(1.0, t)
 
 
+@_ones_like_leaf_for_grad.register("Tensor")
 @ones_like_leaf.register("Tensor")
 def _ones_like_tensor(x):
     """Returns a tensor with the same shape and dtype as x and all elements are 1."""
     return P.OnesLike()(x)
 
 
+@_ones_like_leaf_for_grad.register("COOTensor")
 @ones_like_leaf.register("COOTensor")
 def _ones_like_coo_tensor(x):
     """Returns a tensor with the same shape and dtype as x and all elements are 1."""
@@ -57,12 +63,14 @@ def _ones_like_coo_tensor(x):
     return F.make_coo_tensor(F.coo_tensor_get_indices(x), values, F.coo_tensor_get_dense_shape(x))
 
 
+@_ones_like_leaf_for_grad.register("CSRTensor")
 @ones_like_leaf.register("CSRTensor")
 def _ones_like_csr_tensor(x):
     """Returns a tensor with the same shape and dtype as x and all elements are 1."""
     return F.make_csr_tensor(x.indptr, x.indices, ones_like(x.values), x.shape)
 
 
+@_ones_like_leaf_for_grad.register("Function")
 @ones_like_leaf.register("Function")
 def _ones_like_func(x):
     """
@@ -78,12 +86,20 @@ def _ones_like_func(x):
     return F.environ_create()
 
 
+@_ones_like_leaf_for_grad.register("None")
 @ones_like_leaf.register("None")
 def _ones_like_none(x):
     """Returns none"""
     return None
 
 
+# pylint: disable=protected-access
+@_ones_like_leaf_for_grad._register_default(False)
+def default_ones_like_leaf_for_grad(x):
+    """Default function for _ones_like_leaf_for_grad."""
+    return x
+
+
 ones_like = base.HyperMap(ones_like_leaf)
 """
 `ones_like` is a function which can generate a graph of `ones_like` operation according to input tensor dtype.
@@ -94,3 +110,5 @@ Example:
     >>> input = Tensor([2, 3], mindspore.float16)
     >>> ones = ones_like(input) # The dtype of ones is mindspore.float16
 """
+
+_ones_like_for_grad = base.HyperMap(_ones_like_leaf_for_grad)

mindspore/ops/composite/multitype_ops/pow_impl.py

@@ -16,7 +16,6 @@
 """Implementation for internal polymorphism `pow` operations."""
 
 from __future__ import absolute_import
-from mindspore.ops.composite.multitype_ops import _compile_utils as utils
 from mindspore.ops.composite import base
 from mindspore.ops import functional as F
 
@@ -53,35 +52,8 @@ def _scalar_pow_tensor(x, y):
     return F.tensor_pow(x, y)
 
 
-@pow_.register("Tuple", "Tensor")
-def _tuple_pow_tensor(x, y):
-    """Returns x ** y where x is a tuple and y is a tensor. """
-    x = utils.sequence_to_tensor(x, y.dtype)
-    return F.tensor_pow(x, y)
-
-
-@pow_.register("Tensor", "Tuple")
-def _tensor_pow_tuple(x, y):
-    """Returns x ** y where x is a tensor and y is a tuple. """
-    y = utils.sequence_to_tensor(y, x.dtype)
-    return F.tensor_pow(x, y)
-
-
-@pow_.register("List", "Tensor")
-def _list_pow_tensor(x, y):
-    """Returns x ** y where x is a list and y is a tensor. """
-    x = utils.sequence_to_tensor(x, y.dtype)
-    return F.tensor_pow(x, y)
-
-
-@pow_.register("Tensor", "List")
-def _tensor_pow_list(x, y):
-    """Returns x ** y where x is a tensor and y is a list. """
-    y = utils.sequence_to_tensor(y, x.dtype)
-    return F.tensor_pow(x, y)
-
-
-@pow_.register_default()
+# pylint: disable=protected-access
+@pow_._register_default()
 def default_pow(x, y):
     """Default function for pow."""
     return x ** y

mindspore/ops/composite/multitype_ops/right_shift_impl.py

@@ -31,7 +31,8 @@ def _right_shift_scalar(x, y):
     return inner.bit_right_shift(x, y)
 
 
-@right_shift.register_default()
+# pylint: disable=protected-access
+@right_shift._register_default()
 def default_right_shift(x, y):
     """Default function for right shift."""
     return x >> y

mindspore/ops/composite/multitype_ops/setitem_impl.py

@@ -877,7 +877,8 @@ def _map_tensor_setitem(map_tensor, key_tensor, value_tensor):
     return map_tensor
 
 
-@setitem.register_default()
+# pylint: disable=protected-access
+@setitem._register_default()
 def default_getitem(x, y, z):
     """Default function for setitem."""
     x[y] = z

mindspore/ops/composite/multitype_ops/sub_impl.py

@@ -110,7 +110,8 @@ def _cootensor_sub_tensor(x, y):
     return F.tensor_scatter_add(-y, x.indices, x.values)
 
 
-@sub.register_default()
+# pylint: disable=protected-access
+@sub._register_default()
 def default_sub(x, y):
     """Default function for sub."""
     return x - y

mindspore/ops/function/__init__.py

@@ -27,7 +27,16 @@ from . import (
     linalg_func,
     clip_func,
     fft_func,
-    reshard_func
+    reshard_func,
+    sparse_func,
+    random_func,
+    debug_func,
+    image_func,
+    spectral_func,
+    vmap_func,
+    sparse_unary_func,
+    other_func,
+    _add_attr_func
 )
 from .array_func import (
     unique,
@@ -70,6 +79,7 @@ from .array_func import (
     select_scatter,
     scalar_to_array,
     scalar_to_tensor,
+    take,
     tuple_to_array,
     expand_dims,
     squeeze,
@@ -167,6 +177,9 @@ from .array_func import (
     top_k,
     deepcopy,
     arange_ext,
+    view_as,
+    type_as,
+    expand_as,
 )
 from .parameter_func import (
     assign,
@@ -214,6 +227,7 @@ from .math_func import (
     sqrt,
     square,
     tensor_mul,
+    tensor_muls,
     mul,
     multiply,
     digamma,
@@ -238,6 +252,7 @@ from .math_func import (
     lcm,
     tensor_exp,
     einsum,
+    einsum_ext,
     view_as_real,
     var,
     var_mean,
@@ -317,6 +332,7 @@ from .math_func import (
     sinh,
     cosh,
     tanh,
+    tanh_,
     tanhshrink,
     asinh,
     arcsinh,
@@ -379,6 +395,7 @@ from .math_func import (
     atleast_1d,
     dstack,
     diff,
+    diff_ext,
     atleast_2d,
     cartesian_prod,
     atleast_3d,
@@ -400,6 +417,7 @@ from .math_func import (
     remainder,
     remainder_ext,
     iou,
+    rotated_iou,
     bmm,
     trapz,
     cholesky,
@@ -442,7 +460,9 @@ from .math_func import (
     count_nonzero,
     tensor_dot,
     vecdot,
+    multi_scale_deformable_attn_function,
     dot,
+    isnan_ext,
     batch_dot,
     eps,
 )
@@ -459,7 +479,10 @@ from .nn_func import (
     avg_pool3d,
     max_pool2d,
     max_pool3d,
+    moe_token_permute,
+    moe_token_unpermute,
     batch_norm,
+    add_rms_norm,
     rms_norm,
     bidense,
     celu,
@@ -479,12 +502,16 @@ from .nn_func import (
     flipud,
     fractional_max_pool2d,
     fractional_max_pool3d,
+    speed_fusion_attention,
     pixel_shuffle,
     pixel_unshuffle,
     hardshrink,
     soft_shrink,
     is_floating_point,
     incre_flash_attention,
+    prompt_flash_attention,
+    flash_attention_score,
+    fused_infer_attention_score,
     intopk,
     interpolate,
     upsample,
@@ -504,7 +531,6 @@ from .nn_func import (
     softsign,
     silu,
     selu,
-    soft_margin_loss,
     softmax,
     softmin,
     softshrink,
@@ -529,8 +555,10 @@ from .nn_func import (
     conv2d,
     conv_transpose2d,
     sigmoid,
+    soft_margin_loss,
     logsigmoid,
     relu,
+    relu_,
     relu6,
     rrelu,
     conv3d,
@@ -634,6 +662,7 @@ from .grad import (
     vjp,
     linearize,
     stop_gradient,
+    stop_gradient_,
     get_grad
 )
 from .debug_func import (
@@ -723,6 +752,7 @@ from .clip_func import (
     clip_by_value,
     clip_by_norm,
     clamp,
+    clamp_,
     clip,
     clip_by_global_norm,
 )
@@ -754,7 +784,14 @@ from .other_func import (
     depend,
     partial,
     rotary_position_embedding,
+    move_to,
+    moe_init_routing_v2
 )
+
+from ._add_attr_func import (
+    _add_attr,
+)
+
 from .reshard_func import (
     reshard,
 )
@@ -778,5 +815,6 @@ __all__.extend(sparse_unary_func.__all__)
 __all__.extend(clip_func.__all__)
 __all__.extend(fft_func.__all__)
 __all__.extend(other_func.__all__)
+__all__.extend(_add_attr_func.__all__)
 __all__.extend(reshard_func.__all__)
 __all__.sort()

mindspore/ops/function/_add_attr_func.py

@@ -0,0 +1,58 @@
+# Copyright 2025 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""_add_attr"""
+
+from typing import Callable
+import mindspore as ms
+from mindspore._c_expression import AddAttr_
+from mindspore.ops.primitive import Primitive
+
+
+class AddAttr(AddAttr_):
+    """
+    Config primitive attributes for operators in function.
+    """
+    def __init__(self):
+        super().__init__("AddAttr")
+        self.addattr_fn = None
+        self.fn = None
+        self.attrs_dict = None
+
+    def __call__(self, fn, **kwargs):
+        if not isinstance(kwargs, dict):
+            raise TypeError(f"the parameter 'kwargs' must be dict type, but got:{type(kwargs)}")
+        if (not isinstance(fn, Callable)) or isinstance(fn, Primitive):
+            raise TypeError(f"the parameter 'fn' must be callable type except Primitive, but got:{type(fn)}")
+
+        if self.addattr_fn is not None and self.addattr_fn == fn and \
+           self.fn is not None and self.fn == fn and \
+           self.attrs_dict is not None and self.attrs_dict == kwargs:
+            return self.addattr_fn
+
+        add_attr_ = AddAttr()
+        attr_kv_pair = tuple(kwargs.items())
+        @ms.common.jit
+        def add_attr_fn(*args):
+            return add_attr_(fn, attr_kv_pair)(*args)
+
+        self.addattr_fn = add_attr_fn
+        self.fn = fn
+        self.attrs_dict = kwargs
+        return self.addattr_fn
+
+def _add_attr(fn, **kwargs):
+    return  AddAttr()(fn, **kwargs)
+
+__all__ = ["_add_attr"]