mindspore 2.5.0__cp310-cp310-win_amd64.whl → 2.6.0__cp310-cp310-win_amd64.whl

mindspore/ops/_grad_experimental/grad_comm_ops.py

@@ -27,7 +27,7 @@ from mindspore.ops.operations._inner_ops import issubclass_
 from mindspore.common.sparse_tensor import RowTensorInner
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
 from mindspore.ops.operations.comm_ops import (AllGather, _MiniStepAllGather, _HostAllGather, AllReduce,
-                                               NeighborExchange, AlltoAll, NeighborExchangeV2, Broadcast,
+                                               NeighborExchange, AlltoAll, AlltoAllV, NeighborExchangeV2, Broadcast,
                                                _GetTensorSlice, _MirrorOperator, _MirrorMiniStepOperator, ReduceOp,
                                                ReduceScatter, _HostReduceScatter, _VirtualDiv, _VirtualAdd, _AllSwap,
                                                _VirtualAssignAdd, _VirtualAccuGrad, _MirrorMicroStepOperator,
@@ -192,7 +192,7 @@ def get_bprop_virtual_assign_add(self):
 
     def bprop(x, y, out, dout):
         if reduce_scatter:
-            dout = reduce_scatter(dout)
+            dout = reduce_scatter(cast(dout, dtype(y)))
         return F.depend((cast(out_tensor, dtype(x)), cast(out_tensor, dtype(y))), assign_add(y, dout))
 
     return bprop
@@ -451,7 +451,7 @@ def get_bprop_micro_step_all_gather(self):
         if with_mirror_operator:
             if not do_mirror:
                 return (dout, cast(out_tensor, dtype(z)))
-            real_grad = reduce_scatter(dout)
+            real_grad = reduce_scatter(cast(dout, dtype(z)))
             if mean_flag:
                 real_grad = F.tensor_mul(real_grad, scale)
             return (real_grad, cast(out_tensor, dtype(z)))
@@ -635,6 +635,21 @@ def get_bprop_all_to_all(self):
     return bprop
 
 
+@bprop_getters.register(AlltoAllV)
+def get_bprop_all_to_all_v(self):
+    """Generate bprop for AlltoAll."""
+    all_to_all_v_grad = AlltoAllV(self.group, self.block_size)
+    if hasattr(self, "instance_name") and self.instance_name:
+        instance_name = "grad" + self.instance_name
+        all_to_all_v_grad.set_prim_instance_name(instance_name)
+
+    def bprop(x, send_numel_list, recv_numel_list, out, dout):
+        dx = all_to_all_v_grad(dout, recv_numel_list, send_numel_list)
+        return (dx, zeros_like(send_numel_list), zeros_like(recv_numel_list))
+
+    return bprop
+
+
 @bprop_getters.register(NeighborExchangeV2)
 def get_bprop_neighborexchangev2(self):
     """Generate bprop for NeighborExchangeV2."""

mindspore/ops/_grad_experimental/grad_debug_ops.py

@@ -17,7 +17,8 @@
 
 import mindspore.ops.functional as F
 from mindspore.ops import operations as P
-from mindspore.ops._grad_experimental.grad_base import bprop_getters
+from mindspore.ops.composite import multitype_ops as C
+from mindspore.ops._grad_experimental.grad_base import bprop_getters, bprops
 
 # Unused parameters are placeholders.
 
@@ -34,3 +35,9 @@ def get_bprop_insert_gradient_of(self):
             return (dout,)
         return (fdout,)
     return bprop
+
+
+@bprops.register("TensorDump")
+def bprop_tensor_dump(file, input_x, out, dout):
+    """Generate bprop for TensorDump"""
+    return file, C.zeros_like(input_x)

mindspore/ops/_grad_experimental/taylor_rule.py

@@ -127,6 +127,35 @@ def taylor_realdiv(self):
     return taylor_fprop_realdiv
 
 
+def _taylor_fprop_div(input_x, input_y):
+    """The rule to generate `Div` taylor rule."""
+    if not input_y.shape:
+        return ops.div(input_x, input_y)
+    input_x, input_y = _trans_scalar_inputs(input_x, input_y)
+    primals = ops.div(input_x[0], input_y[0])
+    series_num = len(input_x) - 1
+    factorial = _factorial(series_num)
+    series = zeros_like(input_x)
+    series[0] = primals
+    for k in range(1, series_num + 1):
+        for i in range(0, k):
+            tmp = ops.div(series[i] * input_y[k - i], (factorial[k - i] * factorial[i]))
+            series[k] += tmp
+        series[k] = ops.div(input_x[k] - factorial[k] * series[k], input_y[0])
+    return series
+
+
+@taylor_fprop_getters.register(P.Div)
+def taylor_div(self):
+    """Higher order derivatives rule definition for `Div` operation."""
+
+    def taylor_fprop_div(input_x, input_y):
+        series = _taylor_fprop_div(input_x, input_y)
+        return series
+
+    return taylor_fprop_div
+
+
 @taylor_fprop_getters.register(P.Exp)
 def taylor_exp(self):
     """Higher order derivatives rule definition for `Exp` operation."""

mindspore/ops/_register_for_op.py

@@ -60,14 +60,3 @@ class PyFuncRegistry(UserDict):
         if key not in self:
             raise ValueError(f"Python function with key{key} not registered.")
         return self[key]
-
-
-class OpaquePredicateRegistry(PyFuncRegistry):
-    """Registry opaque predicate functions used for dynamic obfuscation"""
-    def __init__(self):
-        super(OpaquePredicateRegistry, self).__init__()
-        self.func_names = []
-
-    def register(self, key, value):
-        self[key] = value
-        self.func_names.append(key)

mindspore/{ops_generate → ops/_utils}/arg_dtype_cast.py

@@ -20,14 +20,133 @@ import mindspore as ms
 from mindspore import ops
 from mindspore.common.tensor import Tensor
 from mindspore.ops.operations._sequence_ops import TensorToScalar, TensorToTuple
-from mindspore.ops_generate.gen_ops_inner_prim import TupleToList, ListToTuple
 from mindspore._c_expression import OpDtype
+from mindspore._c_expression import typing
+from mindspore._c_expression import op_enum
+from mindspore.ops.primitive import Primitive, prim_attr_register, prim_arg_register
 
 tensor_to_tuple_ = TensorToTuple()
+tensor_to_scalar_ = TensorToScalar()
+
+
+class TupleToList(Primitive):
+    r"""
+    Convert tuple to list.
+
+    Inputs:
+        - **x** (tuple) - The input
+
+    Outputs:
+        List, has the same elements as the `input`.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> from mindspore.ops._utils.arg_dtype_cast import TupleToList
+        >>> x = (1, 2, 3)
+        >>> result = TupleToList()(x)
+        >>> print(result)
+        [1, 2, 3]
+    """
+    @prim_arg_register
+    def __init__(self):
+        """Initialize TupleToList"""
+
+    def __call__(self, input):
+        return list(input)
+
+
+class ListToTuple(Primitive):
+    r"""
+    Convert list to tuple.
+
+    Inputs:
+        - **x** (list) - The input
+
+    Outputs:
+        Tuple, has the same elements as the `input`.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> from mindspore.ops._utils.arg_dtype_cast import ListToTuple
+        >>> x = [1, 2, 3]
+        >>> result = ListToTuple()(x)
+        >>> print(result)
+        (1, 2, 3)
+    """
+    @prim_arg_register
+    def __init__(self):
+        """Initialize TupleToList"""
+
+    def __call__(self, input):
+        return tuple(input)
+
+
 tuple_to_list = TupleToList()
 list_to_tuple = ListToTuple()
 
 
+class DtypeToEnum(Primitive):
+    r"""
+    Convert mindspore dtype to enum.
+
+    Inputs:
+        - **op_name** (str) - The op name
+        - **arg_name** (str) - The arg name
+        - **dtype** (mindspore.dtype) - The data type.
+
+    Outputs:
+        An integer.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize"""
+
+    def __call__(self, op_name, arg_name, dtype):
+        """Run in PyNative mode"""
+        if not isinstance(dtype, typing.Type):
+            raise TypeError(
+                f"For '{op_name}', the input '{arg_name}' should be mindspore dtype, but got {dtype}.")
+        return typing.type_to_type_id(dtype)
+
+
+class StringToEnum(Primitive):
+    r"""
+    Convert string to enum.
+
+    Inputs:
+        - **op_name** (str) - The op name
+        - **arg_name** (str) - The arg name
+        - **enum_str** (str) - The str data.
+
+    Outputs:
+        An integer.
+
+    Supported Platforms:
+        ``CPU``
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize"""
+
+    def __call__(self, op_name, arg_name, enum_str):
+        """Run in PyNative mode"""
+        if enum_str is None:
+            return None
+        if not isinstance(enum_str, str):
+            raise TypeError(
+                f"For '{op_name}', the input '{arg_name}' should be a str, but got {type(enum_str)}.")
+        return op_enum.str_to_enum(op_name, arg_name, enum_str)
+
+
 def int_to_float(data):
     return float(data)
 
@@ -184,7 +303,7 @@ def get_support_dtype_list(src_type, dst_type):
     return support_list
 
 
-def to_py_number(data, dst_type):
+def tensor_to_number(data, dst_type):
     """Convert tensor to python number"""
     if dst_type == DT_INT_VAL:
         data = ops.cast(data, ms.int64)
@@ -197,7 +316,7 @@ def to_py_number(data, dst_type):
             data = ops.cast(data, ms.int64)
         elif src_type in (ms.bfloat16, ms.float16, ms.float32, ms.float64):
             data = ops.cast(data, ms.float32)
-    return TensorToScalar()(data)
+    return tensor_to_scalar_(data)
 
 
 def do_type_cast(data, dst_type):
@@ -230,7 +349,7 @@ def do_type_cast(data, dst_type):
             return list_to_tensor(data)
     elif is_number(dst_type):
         if isinstance(data, Tensor):
-            return to_py_number(data, dst_type)
+            return tensor_to_number(data, dst_type)
     raise TypeError("Type conversion failed.")
 
 

mindspore/{ops_generate → ops/_utils}/arg_handler.py

@@ -14,13 +14,11 @@
 # ============================================================================
 """Operator argument handle function."""
 
-from mindspore.ops_generate.gen_ops_inner_prim import DtypeToEnum, StringToEnum
-# Enum Class:
-from mindspore._c_expression import FormatEnum as Format
-from mindspore._c_expression import ReductionEnum as Reduction
 from mindspore.common import Tensor
 from mindspore.common import dtype as mstype
 
+from .arg_dtype_cast import DtypeToEnum, StringToEnum
+
 
 def arg_invalid_info(op_name, arg_name, arg_val):
     """
@@ -128,6 +126,7 @@ def generator_handler(op_name, arg_name, inputs):
             new_inputs.append(input_)
     return tuple(new_inputs)
 
+
 dtype_to_type_id = DtypeToEnum()
 
 # string to enum

mindspore/ops/_vmap/vmap_array_ops.py

@@ -21,7 +21,7 @@ import mindspore
 import mindspore.numpy as mnp
 from mindspore import ops
 from mindspore.common import Tensor
-from mindspore._c_expression import Tensor as Tensor_
+from mindspore._c_expression import TensorPy as Tensor_
 from mindspore.ops import operations as P
 from mindspore.ops import functional as F
 from mindspore.ops.primitive import constexpr, _primexpr
@@ -141,6 +141,8 @@ def _get_prefix(indices_shape, axis_size, indices_dtype):
     the generated prefix is a Tensor([[[0], [0]],
                                       [[1], [1]]])
     """
+    cast_op = P.Cast()
+
     def _check(indices_shape):
         if not indices_shape:
             raise ValueError("indices_shape is empty in _get_prefix.")
@@ -148,8 +150,8 @@ def _get_prefix(indices_shape, axis_size, indices_dtype):
     _check(indices_shape)
     indices_len = len(indices_shape)
     if indices_len == 1:
-        prefix = P.Range()(Tensor(0, indices_dtype), Tensor(axis_size, indices_dtype), Tensor(1, indices_dtype))
-        return prefix
+        prefix = P.Range()(0, axis_size, 1)
+        return cast_op(prefix, indices_dtype)
 
     indices_end = indices_len - 1
     prefix_shape = ()
@@ -164,9 +166,8 @@ def _get_prefix(indices_shape, axis_size, indices_dtype):
         else:
             expand_shape = expand_shape + (1,)
 
-    prefix = P.BroadcastTo(prefix_shape)(P.Reshape()(P.Range()(Tensor(
-        0, indices_dtype), Tensor(axis_size, indices_dtype), Tensor(1, indices_dtype)), expand_shape))
-    return prefix
+    prefix = P.BroadcastTo(prefix_shape)(P.Reshape()(P.Range()(0, axis_size, 1), expand_shape))
+    return cast_op(prefix, indices_dtype)
 
 
 @vmap_rules_getters.register(P.Transpose)
@@ -213,6 +214,31 @@ def get_transpose_vmap_rule(prim, axis_size):
     return vmap_rule
 
 
+@vmap_rules_getters.register("TransposeExtView")
+def get_transpose_ext_vmap_rule(prim, axis_size):
+    """VmapRule for `TransposeExtView` operation."""
+    if isinstance(prim, str):
+        prim = Primitive(prim)
+
+    def vmap_rule(x_bdim, dim1_bdim, dim2_bdim):
+        is_all_none, result = vmap_general_preprocess(prim, x_bdim, dim1_bdim, dim2_bdim)
+        if is_all_none:
+            return result
+
+        x, dim = x_bdim
+        dim1, dim1_dim = dim1_bdim
+        dim2, dim2_dim = dim2_bdim
+        if dim1_dim is not None or dim2_dim is not None:
+            _raise_value_error("The source axis of dim1_dim and dim2_dim in `TransposeExtView` must be None, "
+                               "but got {} and {}.".format(dim1_dim, dim2_dim))
+        batch_dim1 = dim1 if dim1 < dim else dim1 + 1
+        batch_dim2 = dim2 if dim2 < dim else dim2 + 1
+        out = prim(x, batch_dim1, batch_dim2)
+        return out, dim
+
+    return vmap_rule
+
+
 @vmap_rules_getters.register("Tile")
 def get_tile_vmap_rule(prim, axis_size):
     """VmapRule for `P.Tile` operation."""

mindspore/ops/_vmap/vmap_grad_nn_ops.py

@@ -25,8 +25,9 @@ from mindspore.ops.primitive import _primexpr
 from mindspore.ops.function import _VmapGeneralRule
 from mindspore.ops._vmap.vmap_base import vmap_rules_getters, vmap_general_preprocess, _raise_value_error, \
     _bdim_at_front, _vmap_clone_prim, _bdim_at_any, _handle_broadcasting
-from mindspore.ops.auto_generate.gen_arg_handler import Format, Reduction
 from mindspore.ops import auto_generate as gen
+from mindspore._c_expression import FormatEnum as Format
+from mindspore._c_expression import ReductionEnum as Reduction
 
 
 @vmap_rules_getters.register(G.NLLLossGrad)

mindspore/ops/_vmap/vmap_math_ops.py

@@ -561,20 +561,17 @@ def get_index_add_vmap_rule(prim, axis_size):
 @vmap_rules_getters.register(linalg_ops.Svd)
 def get_svd_vmap_rule(prim, axis_size):
     """VmapRule for 'Svd' operation."""
-    if isinstance(prim, str):
-        prim = Primitive(prim)
-        compute_uv = True
-    else:
-        compute_uv = prim.compute_uv
 
-    def vmap_rule(x_bdim):
+    def vmap_rule(x_bdim, full_matrices_bdim, compute_uv_bdim):
         is_all_none, result = vmap_general_preprocess(prim, x_bdim)
         if is_all_none:
             return result
 
         x, x_dim = x_bdim
+        full_matrices, _ = full_matrices_bdim
+        compute_uv, _ = compute_uv_bdim
         x = _bdim_at_front(x, x_dim, axis_size)
-        s, u, v = prim(x)
+        s, u, v = prim(x, full_matrices, compute_uv)
         if compute_uv:
             return (s, 0), (u, 0), (v, 0)
         return (s, 0), (u, None), (v, None)

mindspore/ops/_vmap/vmap_nn_ops.py

@@ -29,9 +29,9 @@ from mindspore.ops._vmap.vmap_base import vmap_rules_getters, vmap_general_prepr
     _bdim_at_any, _bdim_at_front, _bdim_at_back, _handle_broadcasting, get_unary_grad_vmap_rule, _raise_value_error, \
     _vmap_clone_prim, _get_reduce_batch_axis
 from mindspore.ops.primitive import Primitive
-from mindspore.ops.auto_generate.gen_arg_handler import Format
 from mindspore.ops.auto_generate import Embedding
-from mindspore.ops.auto_generate import gen_arg_handler as handler
+from mindspore.ops._utils import arg_handler as handler
+from mindspore._c_expression import FormatEnum as Format
 
 
 @vmap_rules_getters.register(P.ApplyAdaMax)
@@ -1632,13 +1632,12 @@ def get_apply_adagrad_da_vmap_rule(prim, axis_size):
     return vmap_rule
 
 
-@vmap_rules_getters.register(NN.AdaptiveMaxPool2D)
+@vmap_rules_getters.register(P.AdaptiveMaxPool2D)
 def get_adaptive_max_pool_2d_vmap_rule(prim, axis_size):
     """VmapRule for `AdaptiveMaxPool2D`."""
     nchw_index = 4
     chw_reverse_index = -3
     hw_size = 2
-    output_size = prim.output_size
 
     @_primexpr
     def get_output_shape(x_ori_shape, output_size):
@@ -1661,8 +1660,8 @@ def get_adaptive_max_pool_2d_vmap_rule(prim, axis_size):
             output_shape += (w_out,)
         return output_shape
 
-    def vmap_rule(input_x_bdim):
-        is_all_none, result = vmap_general_preprocess(prim, input_x_bdim)
+    def vmap_rule(input_x_bdim, output_size_bdim):
+        is_all_none, result = vmap_general_preprocess(prim, input_x_bdim, output_size_bdim)
         if is_all_none:
             return result
 
@@ -1670,18 +1669,20 @@ def get_adaptive_max_pool_2d_vmap_rule(prim, axis_size):
         x = _bdim_at_front(input_x, input_x_dim, axis_size)
         x_ndim = F.rank(x)
 
+        output_size, _ = output_size_bdim
+
         if x_ndim > nchw_index:
             # for the case of NCHW
             x_ori_shape = F.shape(x)
             x = F.reshape(x, (-1,) + x_ori_shape[chw_reverse_index:])
             output_shape = get_output_shape(x_ori_shape, output_size)
-            out, indices = prim(x)
+            out, indices = prim(x, output_size)
             out = F.reshape(out, output_shape)
             indices = F.reshape(indices, output_shape)
             return (out, 0), (indices, 0)
 
         # for the case of CHW
-        out, indices = prim(x)
+        out, indices = prim(x, output_size)
         return (out, 0), (indices, 0)
 
     return vmap_rule

mindspore/ops/auto_generate/__init__.py

@@ -19,13 +19,14 @@ Primitive operator classes and operator functional.
 A collection of operators to build neural networks or to compute functions.
 """
 
-from . import gen_ops_def, gen_arg_handler, gen_arg_dtype_cast
+from . import gen_ops_def
+from .._utils import arg_handler, arg_dtype_cast
 
 from .gen_ops_prim import *
 from .gen_ops_def import *
-from .gen_arg_handler import *
-from .gen_arg_dtype_cast import *
 from ..operations.manually_defined.ops_def import *
+from .._utils.arg_handler import *
+from .._utils.arg_dtype_cast import *
 
 
 __all__ = []