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

mindspore/ops/composite/__init__.py

@@ -25,7 +25,7 @@ from mindspore.ops.composite.base import GradOperation, _Grad, HyperMap, Map, Mu
 from mindspore.ops.composite.env_ops import env_get
 from mindspore.ops.function.clip_func import clip_by_global_norm
 from mindspore.ops.composite.multitype_ops.add_impl import hyper_add
-from mindspore.ops.composite.multitype_ops.ones_like_impl import ones_like
+from mindspore.ops.composite.multitype_ops.ones_like_impl import ones_like, _ones_like_for_grad
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
 from mindspore.ops.function.random_func import normal, laplace, uniform, gamma, poisson, multinomial
 from mindspore.ops.composite.math_ops import matmul, cummin, mm
@@ -46,6 +46,7 @@ __all__ = [
     'hyper_add',
     'zeros_like',
     'ones_like',
+    '_ones_like_for_grad',
     'zip_operation',
     'normal',
     'laplace',

mindspore/ops/composite/base.py

@@ -24,6 +24,7 @@ import numpy as np
 import mindspore as ms
 from mindspore import context
 from mindspore.common.parameter import Parameter, ParameterTuple
+from mindspore.common.tensor import Tensor
 from mindspore.parallel._utils import _grads_divided_by_device_num_if_recomputation
 from mindspore._c_expression import GradOperation_, HyperMap_, Map_, MultitypeFuncGraph_, Tail_, \
     TupleAdd_, UnpackCall_, ZipOperation_, ListAppend_, TupleGetItemTensor_, ListInsert_, \
@@ -35,7 +36,6 @@ from mindspore._c_expression import GradOperation_, HyperMap_, Map_, MultitypeFu
 from mindspore.common import dtype as mstype
 from mindspore.common.api import jit, _pynative_executor, _wrap_func
 from mindspore.common.api import _add_flags, _core
-from mindspore.ops.primitive import Primitive
 from mindspore.ops import signature as sig
 
 __all__ = [TupleAdd_, ListAdd_, UnpackCall_, TupleGetItemTensor_, SequenceSliceGetItem_,
@@ -358,16 +358,14 @@ class GradOperation(GradOperation_):
         #   In PYNATIVE_MODE calling Grad from functions decorated with 'jit', use the out layer after_grad do
         #   grad in GRAPH_MODE.
         if context.get_context("mode") == context.GRAPH_MODE:
-            dynamic_shape_inputs = None
             if isinstance(fn, ms.nn.Cell):
-                dynamic_shape_inputs = fn.get_inputs()
                 fn.grad_ops_label = True
             if self.get_by_list:
-                @jit(input_signature=dynamic_shape_inputs)
+                @jit
                 def after_grad(*args, **kwargs):
                     return grad_(fn, weights)(*args, **kwargs)
             else:
-                @jit(input_signature=dynamic_shape_inputs)
+                @jit
                 def after_grad(*args, **kwargs):
                     return grad_(fn)(*args, **kwargs)
         elif self.pynative_:
@@ -578,11 +576,7 @@ class _Grad(GradOperation_):
             outputs = fn(*args, **kwargs)
             if not isinstance(outputs, tuple) or len(outputs) < 2:
                 raise ValueError("When has_aux is True, origin fn requires more than one outputs.")
-            res = (outputs[0],)
-            stop_gradient = Primitive("StopGradient")
-            for item in outputs[1:]:
-                res += (stop_gradient(item),)
-            return res
+            return outputs
 
         grad_ = _Grad(self.get_all, self.get_by_list, self.sens_param, self.get_by_position, self.has_aux,
                       self.get_value, self.return_ids, self.merge_forward)
@@ -592,20 +586,17 @@ class _Grad(GradOperation_):
         #   In PYNATIVE_MODE calling Grad from functions decorated with 'jit', use the out layer after_grad do
         #   grad in GRAPH_MODE.
         if context.get_context("mode") == context.GRAPH_MODE:
-            dynamic_shape_inputs = None
-            if isinstance(fn, ms.nn.Cell):
-                dynamic_shape_inputs = fn.get_inputs()
             if self.get_by_position:
-                @jit(input_signature=dynamic_shape_inputs)
+                @jit
                 def after_grad(*args):
                     return grad_(fn, weights, grad_position)(*args)
             else:
                 if self.get_by_list:
-                    @jit(input_signature=dynamic_shape_inputs)
+                    @jit
                     def after_grad(*args):
                         return grad_(fn, weights)(*args)
                 else:
-                    @jit(input_signature=dynamic_shape_inputs)
+                    @jit
                     def after_grad(*args):
                         return grad_(fn)(*args)
         elif self.pynative_:
@@ -615,9 +606,12 @@ class _Grad(GradOperation_):
             @_wrap_func
             def after_grad(*args, **kwargs):
                 run_args, res = self._pynative_forward_run(fn, grad_, weights, *args, **kwargs)
-                out = _pynative_executor.grad(fn, grad_, weights, grad_position, *run_args)
+                if self.has_aux:
+                    out = _pynative_executor.grad_aux(fn, grad_, weights, grad_position, *run_args)
+                else:
+                    out = _pynative_executor.grad(fn, grad_, weights, grad_position, *run_args)
                 out = _grads_divided_by_device_num_if_recomputation(out)
-                if self.return_ids and out:
+                if self.return_ids and (isinstance(out, Tensor) or out) and out is not None:
                     out = _combine_with_ids(grad_position, weights, out)
                 if self.get_value:
                     return res, out
@@ -820,14 +814,15 @@ class MultitypeFuncGraph(MultitypeFuncGraph_):
             self.register_fn(type_names, fn)
             self.entries.append((types, fn))
             return fn
-
         return deco
 
-    def register_default(self):
+    def _register_default(self, convert_to_interpret=True):
         def deco(fn):
-            self.default_func = fn
+            if not convert_to_interpret:
+                self.register_default_fn(fn)
+            else:
+                self.default_func = fn
             return fn
-
         return deco
 
     # pylint: disable=missing-docstring
@@ -843,7 +838,7 @@ class HyperMap(HyperMap_):
     HyperMap will apply the set operation to input sequences.
 
     Apply the operations to every element of the sequence or nested sequence. Different
-    from `mindspore.ops.Map`, the `HyperMap` supports to apply on nested structure. The
+    from :class:`mindspore.ops.Map`, the `HyperMap` supports to apply on nested structure. The
     `HyperMap` also supports dynamic sequences as input, but it does not extend this
     support to nested dynamic sequences.
 
@@ -928,9 +923,9 @@ class Map(Map_):
     Apply the operations to every element of the sequence.
 
     Args:
-        ops (Union[MultitypeFuncGraph, None]): `ops` is the operation to apply. If `ops` is `None`,
+        ops (Union[MultitypeFuncGraph, None], optional): `ops` is the operation to apply. If `ops` is `None`,
             the operations should be put in the first input of the instance. Default: ``None`` .
-        reverse (bool): The optimizer needs to be inverted in some scenarios to improve parallel performance,
+        reverse (bool, optional): The optimizer needs to be inverted in some scenarios to improve parallel performance,
             general users please ignore. `Reverse` is the flag to decide if apply the operation reversely.
             Only supported in graph mode. Default is ``False`` .
 

mindspore/ops/composite/math_ops.py

@@ -85,8 +85,9 @@ def matmul(x1, x2, dtype=None):
 def mm(input, mat2):
     r"""
     Returns the matrix product of two arrays.
-    If `input` is a :math:`(n \times m)` Tensor, `mat2` is a
-    :math:`(m \times p)` Tensor, `out` will be a :math:`(n \times p)` Tensor.
+
+    If `input` is a :math:`(n \times m)` tensor, `mat2` is a
+    :math:`(m \times p)` tensor, `out` will be a :math:`(n \times p)` tensor.
 
     Note:
         - This function cannot support broadcasting.
@@ -95,28 +96,17 @@ def mm(input, mat2):
 
     Args:
         input (Tensor): The first matrix of matrix multiplication.
-            The last dimension of `input` must be the same size as the first dimension of `mat2`.
         mat2 (Tensor): The second matrix of matrix multiplication.
-            The last dimension of `input` must be the same size as the first dimension of `mat2`.
 
     Returns:
-        Tensor or scalar, the matrix product of the inputs.
-
-    Raises:
-        ValueError: If the last dimension of `input` is not the same size as the
-            second-to-last dimension of `mat2`.
-        ValueError: If `input` or `mat2` is not a Tensor.
+        Tensor or scalar
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore as ms
-        >>> from mindspore import ops
-        >>> import numpy as np
-        >>> x1 = ms.Tensor(np.random.rand(2, 3), ms.float32)
-        >>> x2 = ms.Tensor(np.random.rand(3, 4), ms.float32)
-        >>> out = ops.mm(x1, x2)
+        >>> import mindspore
+        >>> out = mindspore.ops.mm(mindspore.ops.ones((2, 3)), mindspore.ops.ones((3, 4)))
         >>> print(out.shape)
         (2, 4)
     """

mindspore/ops/composite/multitype_ops/__init__.py

@@ -25,7 +25,7 @@ from mindspore.ops.composite.multitype_ops.mod_impl import mod
 from mindspore.ops.composite.multitype_ops.getitem_impl import getitem
 from mindspore.ops.composite.multitype_ops.setitem_impl import setitem
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
-from mindspore.ops.composite.multitype_ops.ones_like_impl import ones_like
+from mindspore.ops.composite.multitype_ops.ones_like_impl import ones_like, _ones_like_for_grad
 from mindspore.ops.composite.multitype_ops.equal_impl import equal
 from mindspore.ops.composite.multitype_ops.not_equal_impl import not_equal
 from mindspore.ops.composite.multitype_ops.less_impl import less
@@ -44,6 +44,7 @@ from mindspore.ops.composite.multitype_ops.right_shift_impl import right_shift
 from mindspore.ops.composite.multitype_ops.uadd_impl import uadd
 from mindspore.ops.composite.multitype_ops.in_impl import in_
 from mindspore.ops.composite.multitype_ops.not_in_impl import not_in_
+from mindspore.ops.composite.multitype_ops.invert_impl import invert
 __all__ = [
     'add',
     'sub',
@@ -73,5 +74,7 @@ __all__ = [
     'left_shift',
     'right_shift',
     'in_',
-    'not_in_'
+    'not_in_',
+    'invert',
+    '_ones_like_for_grad'
 ]

mindspore/ops/composite/multitype_ops/_compile_utils.py

@@ -16,7 +16,7 @@
 """constexpr util"""
 from __future__ import absolute_import
 from enum import IntEnum
-
+import numpy as np
 
 from mindspore.ops.composite.multitype_ops import _constexpr_utils as const_utils
 from mindspore.ops import functional as F
@@ -35,6 +35,8 @@ from mindspore import ops
 from mindspore.ops.primitive import _primexpr
 from mindspore import _checkparam as validator
 from mindspore.common._stub_tensor import _convert_stub
+from mindspore.ops.auto_generate.gen_ops_prim import select_ext_view_op, slice_ext_op, inplace_copy_op, \
+    index_op, inplace_index_put_op
 
 slice_get_item = SliceGetItem()
 hyper_map = base.HyperMap()
@@ -45,9 +47,15 @@ is_parameter = IsParameter()
 getitem_tensor_index_info = GetitemTensorIndexInfo(const_utils.is_ascend())
 setitem_tensor_index_info = SetitemTensorIndexInfo(const_utils.is_ascend())
 
-selevt_view = SelectView()
+select_view = SelectView()
 copy_with_slice = CopyWithSlice()
 
+tensor_1d = Tensor([0], dtype=mstype.int64)
+empty_tensor_1d = Tensor(shape=(0,), dtype=mstype.int64)
+empty_tensor_9d = Tensor(shape=(0,)*9, dtype=mstype.int64)
+
+
+
 def strided_slice(data, begin_strides, end_strides, step_strides, begin_mask=0, end_mask=0, ellipsis_mask=0,
                   new_axis_mask=0, shrink_axis_mask=0):
     """strided_slice primitive cache"""
@@ -148,7 +156,7 @@ def data_update_by_ops(transfer_type, arg, data, new_index, origin_data, value=N
     elif transfer_type == ValueTransferType.kSelect:
         data = F.select(Tensor(new_index), value, data)
     elif transfer_type == ValueTransferType.kSelectView:
-        data = selevt_view(data, arg[0], arg[1])
+        data = select_view(data, arg[0], arg[1])
     elif transfer_type == ValueTransferType.kCopyView:
         value = _broadcast(F.shape(data), F.cast(value, F.dtype(data)))
         data = copy_with_slice(data, value)
@@ -196,14 +204,14 @@ def value_update(transfer_types, args, data, value):
     return value
 
 
-def _tensor_getitem(self, index):
+def _tensor_getitem_origin(self, index):
     """Handle tensor getitem"""
     new_index, tensor_update_types, tensor_update_args = getitem_tensor_index_info(
         self, index)
     return data_update(tensor_update_types, tensor_update_args, self, new_index)
 
 
-def _tensor_setitem(self, index, value):
+def _tensor_setitem_origin(self, index, value):
     """Handle tensor setitem"""
     setitem_info = setitem_tensor_index_info(self, index, value)
     new_index = setitem_info[0]
@@ -218,8 +226,213 @@ def _tensor_setitem(self, index, value):
     return output
 
 
-setattr(tensor_operator_registry, "__getitem__", _tensor_getitem)
-setattr(tensor_operator_registry, "__setitem__", _tensor_setitem)
+setattr(tensor_operator_registry, "_tensor_getitem_origin", _tensor_getitem_origin)
+setattr(tensor_operator_registry, "_tensor_setitem_origin", _tensor_setitem_origin)
+
+
+def _record_tensor_index(index, remain_indexes, dim):
+    """Record indexes remained to be used by aclnnIndex/aclnnIndexPut"""
+    if len(remain_indexes) > dim:
+        remain_indexes[dim] = index
+        return remain_indexes
+
+    while dim > len(remain_indexes):
+        # use empty_tensor with dim_num 9 to indicate unused dim
+        remain_indexes.append(empty_tensor_9d)
+
+    remain_indexes.append(index)
+    return remain_indexes
+
+
+def _count_indexed_dims(indexes):
+    """Count indexed dims"""
+    count = 0
+    for index in indexes:
+        if isinstance(index, Tensor):
+            if index.dtype == mstype.bool_:
+                count += index.ndim
+            else:
+                count += 1
+        elif not isinstance(index, (type(None), type(...), bool)):
+            count += 1
+    return count
+
+
+def _do_select(self: Tensor, dim: int, index: int, dim_index: int, self_shape: list):
+    """call select view operator"""
+    if not self_shape:
+        raise TypeError("Invalid index of a 0-dim tensor.")
+    dim_size = self_shape[dim]
+    if index >= dim_size or index < -dim_size:
+        raise IndexError(f"Index {index} is out of bounds for dimension {dim_index} with size {dim_size}")
+    index = index + dim_size if index < 0 else index
+    return select_ext_view_op(self, dim, index)
+
+
+def _do_slice(self: Tensor, dim: int, index: slice, self_shape: list):
+    """call slice view operator"""
+    def _get_index(index, default):
+        if index is None:
+            return default
+        if isinstance(index, Tensor):
+            return index.__index__()
+        return index
+
+    if not self_shape:
+        raise TypeError("Invalid index of a 0-dim tensor.")
+    step = _get_index(index.step, 1)
+    if step <= 0:
+        raise ValueError("slice step must be positive")
+    start = _get_index(index.start, 0)
+    end = _get_index(index.stop, self_shape[dim])
+    if start == 0 and end == self_shape[dim] and step == 1:
+        return self
+    return slice_ext_op(self, dim, start, end, step)
+
+
+def _process_dim_in_multi_dim_index(prev_result, orig_tensor, index, dim, indexed_dims, dim_index, remain_indexes,
+                                    prev_shape):
+    """Process dim in multi dim index"""
+    if isinstance(index, bool):
+        result = F.expand_dims(prev_result, dim)
+        index_for_bool = tensor_1d if index else empty_tensor_1d
+        _record_tensor_index(index_for_bool, remain_indexes, dim)
+        prev_shape.insert(dim, 1)
+        dim += 1
+        return result, dim, remain_indexes, prev_shape
+    if isinstance(index, int):
+        result = _do_select(prev_result, dim, index, dim_index, prev_shape)
+        del prev_shape[dim]
+        return result, dim, remain_indexes, prev_shape
+    if isinstance(index, slice):
+        result = _do_slice(prev_result, dim, index, prev_shape)
+        # current dim in prev_shape will not be used later, ignore it
+        dim += 1
+        return result, dim, remain_indexes, prev_shape
+    if isinstance(index, type(...)):
+        dim += (orig_tensor.ndim - indexed_dims)
+        return prev_result, dim, remain_indexes, prev_shape
+    if index is None:
+        result = F.expand_dims(prev_result, dim)
+        prev_shape.insert(dim, 1)
+        dim += 1
+        return result, dim, remain_indexes, prev_shape
+    if isinstance(index, Tensor):
+        result = prev_result
+        if index.ndim == 0 and index.dtype in mstype.int_type + mstype.uint_type + (mstype.bool_,):
+            if index.dtype in mstype.int_type + mstype.uint_type:
+                result = _do_select(prev_result, dim, index.item(), dim_index, prev_shape)
+                del prev_shape[dim]
+                return result, dim, remain_indexes, prev_shape
+            # process index with Tensor bool type
+            result = F.expand_dims(prev_result, dim)
+            index_for_bool = tensor_1d if index else empty_tensor_1d
+            _record_tensor_index(index_for_bool, remain_indexes, dim)
+            prev_shape.insert(dim, 1)
+            dim += 1
+            return result, dim, remain_indexes, prev_shape
+        _record_tensor_index(index, remain_indexes, dim)
+        dim += 1
+        return result, dim, remain_indexes, prev_shape
+    raise IndexError(f"Invalid tensor index type {index}")
+
+
+def _process_multi_dim_index(self, indexes, remain_indexes, indexed_dims):
+    """Process indexes in tuple"""
+    self_viewed = self
+    self_viewed_shape = list(self.shape)
+    dim = 0
+    for i, index in enumerate(indexes):
+        if isinstance(index, (list, tuple, np.ndarray)):
+            index_np = np.array(index) if isinstance(index, (list, tuple)) else index
+            if index_np.dtype in (np.int8, np.int16, np.int32, np.int64, np.uint8, np.uint16, np.uint32, np.uint64,
+                                  np.float16, np.float32, np.float64):
+                index = Tensor(index_np, mstype.int64)
+            elif index_np.dtype == np.bool_:
+                index = Tensor(index_np, mstype.bool_)
+            else:
+                raise TypeError(f"Index {index} contain unsupported elements")
+        self_viewed, dim, remain_indexes, self_viewed_shape = _process_dim_in_multi_dim_index(
+            self_viewed, self, index, dim, indexed_dims, i, remain_indexes, self_viewed_shape)
+    return self_viewed, remain_indexes
+
+
+def _wrap_index_to_tuple(index):
+    """Wrap index to tuple"""
+    if isinstance(index, tuple):
+        return index
+    if isinstance(index, list):
+        if len(index) < 32 and any(isinstance(i, (Tensor, list, tuple, slice, type(None), type(...))) for i in index):
+            return tuple(index)
+    return (index,)
+
+
+def _tensor_getitem(self, index):
+    """Handle tensor getitem"""
+    if isinstance(index, bool):
+        self_viewed = F.expand_dims(self, 0)
+        index_for_bool = tensor_1d if index else empty_tensor_1d
+        return index_op(self_viewed, [index_for_bool])
+    if isinstance(index, int):
+        return _do_select(self, 0, index, 0, list(self.shape))
+    if isinstance(index, slice):
+        result = _do_slice(self, 0, index, list(self.shape))
+        return result
+    if index is None:
+        return F.expand_dims(self, 0)
+    if isinstance(index, type(...)):
+        return self
+    indexes = _wrap_index_to_tuple(index)
+    indexed_dims = _count_indexed_dims(indexes)
+    if self.ndim < indexed_dims:
+        raise IndexError(f"too many indices for tensor with dimension size {self.ndim}")
+    remain_indexes = []
+    self_viewed, remain_indexes = _process_multi_dim_index(self, indexes, remain_indexes, indexed_dims)
+    if not remain_indexes:
+        return self_viewed
+    return index_op(self_viewed, remain_indexes)
+
+
+def _tensor_setitem(self, index, value):
+    """Handle tensor setitem"""
+    if not isinstance(value, Tensor):
+        if isinstance(value, (bool, int, float)):
+            value = Tensor(value, dtype=self.dtype)
+        else:
+            raise TypeError(f"Can't assign a {type(value)} to a {self.dtype}.")
+
+    if isinstance(index, bool) and index is False:
+        return self
+    if isinstance(index, type(...)):
+        inplace_copy_op(self, value)
+        return self
+    if index is None or (isinstance(index, bool) and index is True):
+        self_viewed = F.expand_dims(self, 0)
+        inplace_copy_op(self_viewed, value)
+        return self
+    if isinstance(index, int):
+        self_viewed = _do_select(self, 0, index, 0, list(self.shape))
+        inplace_copy_op(self_viewed, value)
+        return self
+    if isinstance(index, slice):
+        self_viewed = _do_slice(self, 0, index, list(self.shape))
+        inplace_copy_op(self_viewed, value)
+        return self
+    indexes = _wrap_index_to_tuple(index)
+    indexed_dims = _count_indexed_dims(indexes)
+    if self.ndim < indexed_dims:
+        raise IndexError(f"too many indices for tensor with dimension size {self.ndim}")
+    remain_indexes = []
+    self_viewed, remain_indexes = _process_multi_dim_index(self, indexes, remain_indexes, indexed_dims)
+    if not remain_indexes:
+        inplace_copy_op(self_viewed, value)
+        return self
+    inplace_index_put_op(self_viewed, remain_indexes, value)
+    return self
+
+
+setattr(tensor_operator_registry, "_tensor_getitem", _tensor_getitem)
+setattr(tensor_operator_registry, "_tensor_setitem", _tensor_setitem)
 
 
 def _tensor_add(self, other):
@@ -313,31 +526,16 @@ def _check_scalar_tensor_args(args):
         const_utils.raise_value_error("For item, the index of scalar Tensor should not be set.")
 
 
-def tensor_item(data, *args):
-    """Tensor getitem by index whose dtype is int or tuple with int."""
-    # transform a.item(tuple(int)) -> a.item(int1,int2...intN)
+def tensor_item(data):
+    """Tensor getitem which has only one element."""
     if data.ndim == 0:
-        _check_scalar_tensor_args(args)
         return TensorToScalar()(data)
-    if len(args) == 1 and isinstance(args[0], tuple):
-        args = args[0]
-
-    args_types = hyper_map(F.typeof, args)
-    if not args or const_utils.judge_index_type(args_types[0], mstype.type_none):
-        if data.shape == (1,):
-            return TensorToScalar()(data[0])
-        const_utils.raise_value_error("Can only convert an array of size 1 to a Python scalar")
-
-    if not const_utils.judge_indexes_types(args_types, mstype.int64):
-        const_utils.raise_type_error("The index object cannot be interpreted as an integer")
-
-    if len(args) == data.ndim:
-        return tensor_index_by_tuple(data, args)
-    if len(args) > 1:
-        const_utils.raise_value_error("Incorrect number of indices for array")
-    output = _tensor_index_by_integer(F.reshape(data, (-1,)), args[0])
-    return TensorToScalar()(output)
-
+    if data.shape == (1,):
+        return TensorToScalar()(data[0])
+    exp_msg = const_utils.gen_exception_msg("The tensor should have only one element. "
+                                            "But the shape of input tensor is {}.", data.shape)
+    const_utils.raise_value_error(exp_msg)
+    return None
 
 def tensor_itemset(data, *args):
     """Tensor setitem by index and value."""

mindspore/ops/composite/multitype_ops/_constexpr_utils.py

@@ -27,7 +27,6 @@ from mindspore.ops.operations import _inner_ops
 from mindspore.ops.primitive import constexpr, _primexpr
 from mindspore import log as logger
 from mindspore import context
-from mindspore._c_expression import Tensor as Tensor_
 
 ALL_TENSOR = 0
 NO_TENSOR = 1
@@ -201,7 +200,7 @@ def make_tensor(a, dtype=mstype.int64, data_shape=None, dim_size=None):
 
     if isinstance(a, (list, tuple)):
         if not a:
-            return Tensor_(a, dtype)
+            return Tensor(a, dtype)
         # Convert all tuple/nested tuples to lists
         a = _deep_list(a, dim_size)
         # Convert all tensor sub-elements to numpy arrays

mindspore/ops/composite/multitype_ops/add_impl.py

@@ -600,7 +600,8 @@ def _dict_add_dict(x, y):
 hyper_add = base.HyperMap(_add_backward)
 
 
-@add.register_default()
+# pylint: disable=protected-access
+@add._register_default()
 def default_add(x, y):
     """Default function for add."""
     return x + y

mindspore/ops/composite/multitype_ops/bitwise_and_impl.py

@@ -50,7 +50,8 @@ def _scalar_bitwise_and_tensor(x, y):
     return F.bitwise_and(x, y)
 
 
-@bitwise_and.register_default()
+# pylint: disable=protected-access
+@bitwise_and._register_default()
 def default_bitwsie_add(x, y):
     """Default function for bitwise_and."""
     return x & y

mindspore/ops/composite/multitype_ops/bitwise_or_impl.py

@@ -50,7 +50,8 @@ def _scalar_bitwise_or_tensor(x, y):
     return F.bitwise_or(x, y)
 
 
-@bitwise_or.register_default()
+# pylint: disable=protected-access
+@bitwise_or._register_default()
 def default_bitwsie_or(x, y):
     """Default function for bitwise_or."""
     return x | y

mindspore/ops/composite/multitype_ops/bitwise_xor_impl.py

@@ -50,7 +50,8 @@ def _scalar_bitwise_xor_tensor(x, y):
     return F.bitwise_xor(x, y)
 
 
-@bitwise_xor.register_default()
+# pylint: disable=protected-access
+@bitwise_xor._register_default()
 def default_bitwsie_xor(x, y):
     """Default function for bitwise_xor."""
     return x ^ y

mindspore/ops/composite/multitype_ops/div_impl.py

@@ -21,6 +21,7 @@ from mindspore.ops.composite.multitype_ops._constexpr_utils import log_warning,
 from mindspore.ops.composite import base
 from mindspore.ops import functional as F
 from mindspore.common import COOTensor
+from mindspore.ops.auto_generate import div_op
 
 
 div = base.MultitypeFuncGraph("div", True)
@@ -84,7 +85,7 @@ def _div_tensor(x, y):
     Returns:
         Tensor, has the same dtype as x.
     """
-    return F.tensor_div(x, y)
+    return div_op(x, y)
 
 
 @div.register("Number", "Tensor")
@@ -99,7 +100,7 @@ def _scalar_div_tensor(x, y):
     Returns:
         Tensor, has the same dtype as x.
     """
-    return F.tensor_div(x, y)
+    return div_op(x, y)
 
 
 @div.register("Tensor", "Number")
@@ -114,7 +115,7 @@ def _tensor_div_scalar(x, y):
     Returns:
         Tensor, has the same dtype as x.
     """
-    return F.tensor_div(x, y)
+    return div_op(x, y)
 
 
 @div.register("Tuple", "Tensor")
@@ -181,7 +182,8 @@ def _tensor_div_list(x, y):
     return F.tensor_div(x, y)
 
 
-@div.register_default()
+# pylint: disable=protected-access
+@div._register_default()
 def default_div(x, y):
     """Default function for div."""
     if y != 0:

mindspore/ops/composite/multitype_ops/equal_impl.py

@@ -306,7 +306,7 @@ def _number_equal_string(x, y):
 
     Args:
        x (Number): The first input which is a number.
-       y (String): The second input which is a string.
+       y (str): The second input which is a string.
 
     Returns:
        bool, return false.
@@ -320,7 +320,7 @@ def _string_equal_number(x, y):
     Determine if number equal string.
 
     Args:
-       x (String): The first input which is a string.
+       x (str): The first input which is a string.
        y (Number): The second input which is a number.
 
     Returns:
@@ -329,7 +329,8 @@ def _string_equal_number(x, y):
     return False
 
 
-@equal.register_default()
+# pylint: disable=protected-access
+@equal._register_default()
 def default_equal(x, y):
     """Default function for equal."""
     return x == y

mindspore/ops/composite/multitype_ops/floordiv_impl.py

@@ -80,7 +80,8 @@ def _tensor_floordiv_list(x, y):
     return F.tensor_floordiv(x, y)
 
 
-@floordiv.register_default()
+# pylint: disable=protected-access
+@floordiv._register_default()
 def default_floordiv(x, y):
     """Default function for floordiv."""
     if y == 0: