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

mindspore/numpy/utils.py

@@ -18,9 +18,8 @@ from __future__ import absolute_import
 import types
 
 from mindspore.common import Tensor
-from mindspore._c_expression import Tensor as Tensor_
-from mindspore.ops import functional as F
 from mindspore.common import dtype as mstype
+from mindspore import ops
 
 from mindspore.numpy.utils_const import _tile_size, _add_unit_axes, _raise_type_error, _type_convert, \
     _tuple_setitem, _callable_const, _check_is_float, _get_device
@@ -65,7 +64,7 @@ def _check_input_for_asarray(array_like):
 
 def _is_scalar(shape):
     """check whether input shape is a scalar"""
-    return F.shape_mul(shape) == 1
+    return ops.shape_mul(shape) == 1
 
 
 def _convert_list_tensor_to_tuple_tensor(list_of_tensor):
@@ -80,27 +79,27 @@ def _convert_list_tensor_to_tuple_tensor(list_of_tensor):
 
 def _expand(x, ndim, axis=0):
     """Expand x to ndim from axis, which can be 0 or -1."""
-    shape = _add_unit_axes(F.shape(x), ndim, axis == -1)
-    return F.reshape(x, shape)
+    shape = _add_unit_axes(ops.shape(x), ndim, axis == -1)
+    return ops.reshape(x, shape)
 
 
 def _broadcast_to(x, shape_cur, shape_to, ndim_to):
     """Broadcasts x from shape_cur to shape_to."""
     size = _tile_size(shape_cur, shape_to, ndim_to)
-    return F.tile(x, size)
+    return ops.tile(x, size)
 
 
 def _broadcast_to_shape(x, shape):
     """Broadcasts x from current shape to shape"""
     ndim_to = len(shape)
     x = _expand(x, ndim_to)
-    return _broadcast_to(x, F.shape(x), shape, ndim_to)
+    return _broadcast_to(x, ops.shape(x), shape, ndim_to)
 
 
 def _get_size(x, axis=None):
     """Get the number of elements along the given axis of tensor x."""
-    if axis is None or F.tuple_len(axis) == 0:
-        axis = F.make_range(x.ndim)
+    if axis is None or ops.tuple_len(axis) == 0:
+        axis = ops.make_range(x.ndim)
     nums = 1
     for ax in axis:
         nums *= x.shape[ax]
@@ -110,7 +109,7 @@ def _get_size(x, axis=None):
 def _check_input_tensor(*tensors):
     for tensor in tensors:
         if not isinstance(tensor, Tensor):
-            _raise_type_error('expect Tensor, but got ', F.typeof(tensor))
+            _raise_type_error('expect Tensor, but got ', ops.typeof(tensor))
     return True
 
 
@@ -129,7 +128,7 @@ def _to_tensor(*args):
     for arg in args:
         if isinstance(arg, (int, float, bool, list, tuple)):
             if isinstance(arg, (list, tuple)) and not arg:
-                arg = Tensor_(arg)
+                arg = Tensor(arg)
             arg = _convert_64_to_32(_type_convert(Tensor, arg))
         elif not isinstance(arg, Tensor):
             _raise_type_error("Expect input to be array like.")
@@ -141,7 +140,7 @@ def _to_tensor(*args):
 
 def _get_dtype_from_scalar(*input_numbers):
     """
-    Get the final dtype from series of input numbers, compared with F.typeof, we
+    Get the final dtype from series of input numbers, compared with ops.typeof, we
     return int32/float32 for python int/float instead.
     """
     bool_flag = True
@@ -184,7 +183,7 @@ def _slice_along_axis(f, axis, slice_start, slice_end):
     slice_size = slice_end - slice_start
     index_start = _tuple_setitem(index_start, axis, slice_start)
     index_end = _tuple_setitem(index_end, axis, slice_size)
-    return F.tensor_slice(f, index_start, index_end)
+    return ops.tensor_slice(f, index_start, index_end)
 
 
 def _to_tensor_origin_dtype(*args):
@@ -203,12 +202,12 @@ def _to_tensor_origin_dtype(*args):
 
 def _callable(tensor, obj):
     """Returns True if `obj` is a function."""
-    if F.isconstant(tensor):
+    if ops.isconstant(tensor):
         return isinstance(obj, types.FunctionType)
-    return _callable_const(F.typeof(obj))
+    return _callable_const(ops.typeof(obj))
 
 
 def _isnan(x):
-    if _get_device() == 'Ascend' and not _check_is_float(F.dtype(x)):
-        return F.fill(mstype.bool_, F.shape(x), False)
-    return F.isnan(x)
+    if _get_device() == 'Ascend' and not _check_is_float(ops.dtype(x)):
+        return ops.fill(mstype.bool_, ops.shape(x), False)
+    return ops.isnan(x)

mindspore/numpy/utils_const.py

@@ -20,14 +20,13 @@ from itertools import accumulate
 import operator
 
 import mindspore.context as context
-from mindspore.ops import functional as F
 from mindspore.ops.primitive import constexpr
 from mindspore.ops.primitive import _primexpr
 from mindspore.common import dtype as mstype
 from mindspore.common import Tensor
-from mindspore._c_expression import Tensor as Tensor_
 from mindspore._c_expression import typing
 from mindspore import _checkparam as validator
+from mindspore import ops
 
 from mindspore.numpy.dtypes import promotion_rule, dtype_tuple, all_types, dtype_map, rule_for_trigonometric
 
@@ -80,13 +79,13 @@ def _check_dtype(dtype):
 @_primexpr
 def _is_shape_empty(shp):
     """Check whether shape contains zero"""
-    if F.is_sequence_shape_unknown(shp):
+    if ops.is_sequence_shape_unknown(shp):
         return False
     if isinstance(shp, int):
         return shp == 0
     if isinstance(shp, (tuple, list)):
         return 0 in shp
-    return F.shape_mul(shp) == 0
+    return ops.shape_mul(shp) == 0
 
 
 @_primexpr
@@ -189,7 +188,7 @@ def _check_axis_valid(axes, ndim):
             raise ValueError('duplicate value in "axis"')
 
     if axes is None:
-        axes = F.make_range(ndim)
+        axes = ops.make_range(ndim)
         return axes
     if isinstance(axes, (tuple, list)):
         axes = tuple(map(lambda x: _check_axis_in_range(x, ndim), axes))
@@ -282,7 +281,7 @@ def _raise_unimplemented_error(info, param=None):
 @_primexpr
 def _empty(dtype, shape):
     """Returns an uninitialized array with dtype and shape."""
-    return Tensor_(dtype, shape)
+    return Tensor(dtype=dtype, shape=shape)
 
 
 @constexpr

mindspore/ops/__init__.py

@@ -31,12 +31,14 @@ from mindspore.ops.op_info_register import op_info_register, custom_info_registe
 from mindspore.ops.primitive import constexpr
 from mindspore.ops import composite, operations, functional, function
 from mindspore.ops import signature
-from mindspore.ops.auto_generate import cpp_create_prim_instance_helper, gen_arg_dtype_cast, gen_arg_handler, \
+from mindspore.ops.auto_generate import cpp_create_prim_instance_helper, \
     gen_extend_func, gen_ops_def, gen_ops_prim, pyboost_inner_prim
+from mindspore.ops.functional_overload import all_gather_matmul, matmul_reduce_scatter
 from mindspore.ops.composite import *
 from mindspore.ops.operations import *
 from mindspore.ops.function import *
 from mindspore.ops.functional import *
+from mindspore.ops._utils import arg_dtype_cast, arg_handler
 
 __primitive__ = [
     "prim_attr_register", "prim_arg_register", "Primitive", "PrimitiveWithInfer", "PrimitiveWithCheck", "signature"
@@ -46,8 +48,8 @@ __all__ = ["get_vm_impl_fn", "vm_impl_registry",
            "op_info_register", "custom_info_register", "AkgGpuRegOp", "AkgAscendRegOp", "AiCPURegOp", "TBERegOp",
            "CpuRegOp", "CustomRegOp", "DataType",
            "constexpr", "reshard",
-           "cpp_create_prim_instance_helper", "gen_arg_dtype_cast", "gen_arg_handler", "gen_extend_func", "gen_ops_def",
-           "gen_ops_prim", "pyboost_inner_prim"]
+           "cpp_create_prim_instance_helper", "arg_dtype_cast", "arg_handler", "gen_extend_func", "gen_ops_def",
+           "gen_ops_prim", "pyboost_inner_prim", "all_gather_matmul", "matmul_reduce_scatter"]
 __all__.extend(__primitive__)
 __all__.extend(composite.__all__)
 __all__.extend(operations.__all__)

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,
@@ -37,9 +37,24 @@ from mindspore.ops._grad_experimental.grad_base import bprop_getters
 from mindspore.ops.operations import _grad_ops as G
 import mindspore as ms
 
-_device_local_norm = None
-if ms.get_auto_parallel_context("dump_device_local_norm"):
-    _device_local_norm = Parameter(Tensor(0.0, mstype.float32), name="_device_local_norm", requires_grad=False)
+_squared_device_local_norm = None
+
+
+def get_squared_device_local_norm_param():
+    """
+    Get Parameter `_squared_device_local_norm`.
+    `_squared_device_local_norm` will accumulate squared local norm of each grad in bprop under GRAPH_MODE.
+    User need to reset it to zero after network propagation each step.
+    """
+    global _squared_device_local_norm
+    if _squared_device_local_norm is None:
+        if ms.get_auto_parallel_context("dump_device_local_norm"):
+            _squared_device_local_norm = Parameter(Tensor(0.0, mstype.float32), name="_squared_device_local_norm",
+                                                   requires_grad=False)
+        else:
+            raise ValueError("The parallel config 'dump_device_local_norm' is False.")
+    return _squared_device_local_norm
+
 
 @bprop_getters.register(AllReduce)
 def get_bprop_all_reduce(self):
@@ -177,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
@@ -195,7 +210,7 @@ def get_bprop_virtual_assign_kv_cache(self):
         dout_update = dout + y
         kv_equal = F.equal(seq_chunk, 0)
         update_kv = F.select(kv_equal, F.broadcast_to(cast(out_tensor, dtype(y)), F.shape(y)), dout_update)
-        return F.depend((dout_update, cast(out_tensor, dtype(y)),
+        return F.depend((cast(dout_update, dtype(dout)), cast(out_tensor, dtype(y)),
                          cast(out_tensor, dtype(seq_chunk))), assign(y, update_kv))
 
     return bprop
@@ -221,6 +236,7 @@ def get_bprop_mirror_micro_step_operator(self):
     allgather for sparse feature.
     """
     group = self.group
+    global_rank = get_rank()
     dev_num = self.dev_num
     mean_flag = self.mean_flag
     param_name = " "
@@ -247,18 +263,29 @@ def get_bprop_mirror_micro_step_operator(self):
     out_tensor = Tensor(1.0, mstype.float16)
     opt_shard = _get_enable_parallel_optimizer()
     ln_print = P.Print()
+    tensor_dump = P.TensorDump()
     reduce_sum = P.ReduceSum(keep_dims=False)
     square = P.Square()
+    sqrt = P.Sqrt()
     dump_local_norm = ms.get_auto_parallel_context("dump_local_norm")
+    dump_local_norm_path = ms.get_auto_parallel_context("dump_local_norm_path")
     dump_device_local_norm = ms.get_auto_parallel_context("dump_device_local_norm")
+    if dump_device_local_norm:
+        # init _squared _squared_device_local_norm
+        squared_device_local_norm = get_squared_device_local_norm_param()
 
     def bprop(x, z, out, dout):
         if dump_local_norm or dump_device_local_norm:
-            _norm = reduce_sum(square((z)))
+            squared_norm = reduce_sum(square((z)))
             if dump_local_norm:
-                z = F.depend(z, ln_print("dump local norm: ", param_name, _norm))
+                if dump_local_norm_path:
+                    z = F.depend(z, tensor_dump(dump_local_norm_path + "/rank_" + str(global_rank) +
+                                                "/local_norm__" + param_name, sqrt(squared_norm)))
+                else:
+                    z = F.depend(z, ln_print("dump local norm: ", param_name, sqrt(squared_norm)))
             if dump_device_local_norm:
-                z = F.depend(z, F.assign_add(_device_local_norm, cast(_norm, _device_local_norm.dtype)))
+                z = F.depend(z, F.assign_add(squared_device_local_norm,
+                                             cast(squared_norm, squared_device_local_norm.dtype)))
         real_grad = z
         assign_out = dout
         if issubclass_(F.typeof(dout), mstype.tensor_type):
@@ -301,8 +328,38 @@ def get_bprop_all_gather(self):
     if self.rank_size == 0:
         raise ValueError(f"The 'rank_size' can not be zero, but got {self.rank_size}.")
     scale = 1.0 / self.rank_size
+    param_name = ""
+    if 'mirror_user_id' in self.get_attr_dict():
+        param_name = self.get_attr_dict()['mirror_user_id']
+    # monitor local norm
+    dump_local_norm = ms.get_auto_parallel_context("dump_local_norm")
+    dump_local_norm_path = ms.get_auto_parallel_context("dump_local_norm_path")
+    dump_device_local_norm = ms.get_auto_parallel_context("dump_device_local_norm")
+    if param_name and (dump_local_norm or dump_device_local_norm):
+        global_rank = get_rank()
+        cast = P.Cast()
+        ln_print = P.Print()
+        tensor_dump = P.TensorDump()
+        reduce_sum = P.ReduceSum(keep_dims=False)
+        square = P.Square()
+        sqrt = P.Sqrt()
+    if dump_device_local_norm:
+        # init _squared _squared_device_local_norm
+        squared_device_local_norm = get_squared_device_local_norm_param()
 
     def bprop(x, out, dout):
+        if param_name and (dump_local_norm or dump_device_local_norm):
+            squared_norm = reduce_sum(square((dout)))
+            if dump_local_norm:
+                if dump_local_norm_path:
+                    dout = F.depend(dout, tensor_dump(dump_local_norm_path + "/rank_" + str(global_rank) +
+                                                      "/local_norm__" + param_name, sqrt(squared_norm)))
+                else:
+                    dout = F.depend(dout, ln_print("dump local norm: ", param_name, sqrt(squared_norm)))
+            if dump_device_local_norm:
+                dout = F.depend(dout, F.assign_add(squared_device_local_norm,
+                                                   cast(squared_norm, squared_device_local_norm.dtype)))
+
         dx = reduce_scatter(dout)
         if mean_flag:
             dx = F.tensor_mul(dx, scale)
@@ -373,31 +430,43 @@ def get_bprop_micro_step_all_gather(self):
         if self.instance_name:
             instance_name = "grad_" + self.instance_name
             reduce_scatter.set_prim_instance_name(instance_name)
+    global_rank = get_rank()
     cast = P.Cast()
     dtype = P.DType()
     out_tensor = Tensor(1.0, mstype.float16)
     with_mirror_operator = self.get_attr_dict()["with_mirror_operator"]
     ln_print = P.Print()
+    tensor_dump = P.TensorDump()
     reduce_sum = P.ReduceSum(keep_dims=False)
     square = P.Square()
+    sqrt = P.Sqrt()
     dump_local_norm = ms.get_auto_parallel_context("dump_local_norm")
+    dump_local_norm_path = ms.get_auto_parallel_context("dump_local_norm_path")
     dump_device_local_norm = ms.get_auto_parallel_context("dump_device_local_norm")
+    if dump_device_local_norm:
+        # init _squared _squared_device_local_norm
+        squared_device_local_norm = get_squared_device_local_norm_param()
 
     def bprop(x, z, out, dout):
         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)))
         z = F.depend(z, dout)
         if dump_local_norm or dump_device_local_norm:
-            _norm = reduce_sum(square((z)))
+            squared_norm = reduce_sum(square((z)))
             if dump_local_norm:
-                z = F.depend(z, ln_print("dump local norm: ", param_name, _norm))
+                if dump_local_norm_path:
+                    z = F.depend(z, tensor_dump(dump_local_norm_path + "/rank_" + str(global_rank) +
+                                                "/local_norm__" + param_name, sqrt(squared_norm)))
+                else:
+                    z = F.depend(z, ln_print("dump local norm: ", param_name, sqrt(squared_norm)))
             if dump_device_local_norm:
-                z = F.depend(z, F.assign_add(_device_local_norm, cast(_norm, _device_local_norm.dtype)))
+                z = F.depend(z, F.assign_add(squared_device_local_norm,
+                                             cast(squared_norm, squared_device_local_norm.dtype)))
         if not do_mirror:
             return (z, cast(out_tensor, dtype(z)))
         real_grad = reduce_scatter(z)
@@ -566,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."""
@@ -599,16 +683,23 @@ def get_bprop_mirror_operator(self):
 
     dev_num_r = 1.0
     dump_local_norm = ms.get_auto_parallel_context("dump_local_norm")
+    dump_local_norm_path = ms.get_auto_parallel_context("dump_local_norm_path")
     dump_device_local_norm = ms.get_auto_parallel_context("dump_device_local_norm")
+    if dump_device_local_norm:
+        # init _squared _squared_device_local_norm
+        squared_device_local_norm = get_squared_device_local_norm_param()
     if dev_num > 1:
+        global_rank = get_rank()
         dev_num_r = 1.0 / dev_num
         all_reduce = AllReduce(group=group)
         all_gather = AllGather(group=group)
         mul = P.Mul()
         cast = P.Cast()
         ln_print = P.Print()
+        tensor_dump = P.TensorDump()
         reduce_sum = P.ReduceSum(keep_dims=False)
         square = P.Square()
+        sqrt = P.Sqrt()
 
         fusion = self.get_attr_dict()["fusion"]
         all_reduce.add_prim_attr("fusion", fusion)
@@ -623,11 +714,16 @@ def get_bprop_mirror_operator(self):
 
     def bprop(x, out, dout):
         if dump_local_norm or dump_device_local_norm:
-            _norm = reduce_sum(square((dout)))
+            squared_norm = reduce_sum(square((dout)))
             if dump_local_norm:
-                dout = F.depend(dout, ln_print("dump local norm: ", param_name, _norm))
+                if dump_local_norm_path:
+                    dout = F.depend(dout, tensor_dump(dump_local_norm_path + "/rank_" + str(global_rank) +
+                                                      "/local_norm__" + param_name, sqrt(squared_norm)))
+                else:
+                    dout = F.depend(dout, ln_print("dump local norm: ", param_name, sqrt(squared_norm)))
             if dump_device_local_norm:
-                dout = F.depend(dout, F.assign_add(_device_local_norm, cast(_norm, _device_local_norm.dtype)))
+                dout = F.depend(dout, F.assign_add(squared_device_local_norm,
+                                                   cast(squared_norm, squared_device_local_norm.dtype)))
 
         if dev_num == 1:
             return (dout,)

mindspore/ops/_grad_experimental/grad_debug_ops.py

@@ -15,8 +15,10 @@
 
 """Generate bprop for debug ops"""
 
+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.
 
@@ -27,5 +29,15 @@ def get_bprop_insert_gradient_of(self):
     f = self.f
 
     def bprop(x, out, dout):
-        return (f(dout),)
+        fdout = f(dout)
+        if fdout is None:
+            dout = F.depend(dout, fdout)
+            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/grad_inner_ops.py

@@ -23,6 +23,15 @@ from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
 from mindspore.ops._grad_experimental.grad_base import bprop_getters
 
 
+@bprop_getters.register("raise")
+def get_bprop_raise(self):
+    """Grad definition for `raise` operation."""
+    def bprop(x, y, z, out, dout):
+        return x, y, z
+
+    return bprop
+
+
 @bprop_getters.register(inner.ParallelResizeBilinear)
 def get_bprop_parallel_resize_bilinear(self):
     """Grad definition for `ParallelResizeBilinear` operation."""

mindspore/ops/_grad_experimental/grad_math_ops.py

@@ -657,7 +657,8 @@ def get_bprop_fft_with_size(self):
                 dx = rfft_fn(dout)
                 dx = reverse_branch(dx, onesided, dout_shape, offset_shape,
                                     output_type, dout, norm, inverse, signal_ndim, offset_size)
-        return (dx,)
+        return dx, zeros_like(signal_ndim), zeros_like(inverse), zeros_like(real), zeros_like(norm_enum), \
+               zeros_like(onesided), zeros_like(signal_sizes)
 
     return bprop
 

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/_op_impl/cpu/__init__.py

@@ -71,6 +71,7 @@ from .pyexecute import _pyexecute_cpu
 from .pyfunc import _pyfunc_cpu
 from .buffer_append import _buffer_append_cpu
 from .buffer_get import _buffer_get_cpu
+from .raise_op import _raise_cpu
 from .buffer_sample import _buffer_sample_cpu
 from .priority_replay_buffer import _prb_push_op_cpu
 from .priority_replay_buffer import _prb_sample_op_cpu

mindspore/ops/_op_impl/cpu/raise_op.py

@@ -0,0 +1,28 @@
+# 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.
+# ============================================================================
+"""storeattrgrad op"""
+from mindspore.ops.op_info_register import op_info_register, CpuRegOp, DataType
+
+raise_op_info = CpuRegOp("raise") \
+    .input(0, "x", "dynamic") \
+    .output(0, "y", "dynamic") \
+    .dtype_format(DataType.I32_Default, DataType.I32_Default) \
+    .get_op_info()
+
+
+@op_info_register(raise_op_info)
+def _raise_cpu():
+    """_getattrgrad_cpu cpu register"""
+    return

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)