mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/ops/composite/multitype_ops/_constexpr_utils.py

@@ -19,7 +19,6 @@ from functools import partial
 from itertools import compress
 
 import numpy as np
-from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
 from mindspore.common._register_for_tensor import tensor_operator_registry
 from mindspore.common.tensor import Tensor
@@ -114,7 +113,7 @@ def make_empty_slice():
     return slice(None, None, None)
 
 
-@constexpr
+@_primexpr
 def _deep_list(array_like, dim_size=None):
     """convert nested tuple/list mixtures to pure nested list"""
     if dim_size is not None:
@@ -156,7 +155,7 @@ def _deep_tensor_to_nparray(array_like):
     return array_like
 
 
-@constexpr
+@_primexpr
 def check_range(x, dim_size):
     if dim_size is None:
         return x
@@ -167,7 +166,7 @@ def check_range(x, dim_size):
     return x
 
 
-@constexpr
+@_primexpr
 def make_tensor(a, dtype=mstype.int64, data_shape=None, dim_size=None):
     """
     Converts the input to tensor.
@@ -195,6 +194,9 @@ def make_tensor(a, dtype=mstype.int64, data_shape=None, dim_size=None):
     if dim_size is not None:
         a = check_range(a, dim_size)
 
+    if isinstance(a, int):
+        return P.ScalarToTensor()(a, dtype)
+
     if isinstance(a, (list, tuple)):
         # Convert all tuple/nested tuples to lists
         a = _deep_list(a, dim_size)
@@ -242,7 +244,7 @@ def check_tensor_setitem_index(index, element_type=None):
                 raise IndexError(
                     "Index of type '{}' is not supported yet.".format(type(item)))
         return True
-    if isinstance(index, mstype.tensor_type):
+    if isinstance(index, mstype.TensorType):
         if element_type is None or element_type != mstype.bool_:
             raise TypeError(
                 "The index of tensor should be a bool type tensor. "
@@ -338,13 +340,13 @@ def get_pos_of_indexes_types(indexes_types, op_name):
             slice_positions += (i,)
         elif isinstance(index_type, mstype.Ellipsis_):
             ellipsis_positions += (i,)
-        elif isinstance(index_type, mstype.none_type):
+        elif isinstance(index_type, mstype.NoneType):
             none_positions += (i,)
         elif isinstance(index_type, mstype.Int):
             int_positions += (i,)
         elif isinstance(index_type, mstype.Bool):
             bool_positions += (i,)
-        elif isinstance(index_type, mstype.tensor_type):
+        elif isinstance(index_type, mstype.TensorType):
             tensor_positions += (i,)
         elif isinstance(index_type, (list, tuple)):
             sequence_positions += (i,)
@@ -396,10 +398,16 @@ def slice2indices(input_slice, shape):
         return False
     ndim = len(shape)
     mesh = list()
-    grids = [P.Range()(P.Fill()(mstype.int64, (), start), P.Fill()(
-        mstype.int64, (), stop), P.Fill()(mstype.int64, (), step))]
-    grids += [P.Range()(Tensor(0, mstype.int64), P.Fill()(mstype.int64, (), dim_size),
-                        Tensor(1, mstype.int64)) for dim_size in shape[1:]]
+    range_op = P.Range()
+    cast_op = P.Cast()
+    grids = [
+        range_op(cast_op(start, mstype.int64), cast_op(stop, mstype.int64),
+                 cast_op(step, mstype.int64))
+    ]
+    grids += [
+        range_op(Tensor(0, mstype.int64), cast_op(dim_size, mstype.int64),
+                 Tensor(1, mstype.int64)) for dim_size in shape[1:]
+    ]
     for j, grid in enumerate(grids):
         mesh.append(P.Reshape()(grid, tuple(
             [grid.size if j == t else 1 for t in range(ndim)])))
@@ -436,7 +444,7 @@ def check_indices_value_size(indices_size, value_size):
 @constexpr
 def tuple_index_type_cnt(types, op_name):
     """count the tensor type of types which contains the tuple elements' type."""
-    if all(isinstance(ele, mstype.tensor_type) for ele in types):
+    if all(isinstance(ele, mstype.TensorType) for ele in types):
         return ALL_TENSOR
     if all(isinstance(ele, (mstype.Int, mstype.Ellipsis_, mstype.Slice)) for ele in types):
         return ALL_BASIC
@@ -448,7 +456,7 @@ def check_value_elements(types):
     """Judges the type of all elements of the tuple."""
     tensor_number = 0
     for ele in types:
-        if isinstance(ele, mstype.tensor_type):
+        if isinstance(ele, mstype.TensorType):
             tensor_number += 1
     if tensor_number == 0:
         return NO_TENSOR
@@ -541,7 +549,7 @@ def convert_scalar_to_tensor(data_shape, data_dtype, indices_shape, value, op_ty
         updates_shape = indices_shape + data_shape[1:]
     else:
         updates_shape = indices_shape[:-1] + data_shape[indices_shape[-1]:]
-    return P.Fill()(data_dtype, updates_shape, value)
+    return P.FillV2()(updates_shape, P.Cast()(value, data_dtype))
 
 
 def generate_updates_shape(data_shape, index_shape, op_type, is_dynamic):
@@ -842,7 +850,7 @@ def sequence_to_index(sequence, dim_size):
         return False
     if all(isinstance(i, bool) for i in sequence):
         if dim_size is None:
-            raise IndexError("Not supported to take the subscript of dynamic shape tensor using Boolean type")
+            return Tensor(sequence)
         seq_size = len(sequence)
         if seq_size != dim_size:
             raise IndexError(f'dimension is {dim_size} but corresponding boolean dimension is {seq_size}')
@@ -863,11 +871,11 @@ def int_to_index(i, shape):
     _check(i, dim_size)
     i = (i + dim_size) % dim_size
     if len(shape) == 1:
-        return P.Fill()(mstype.int64, (1, 1), i)
+        return P.FillV2()((1, 1), P.Cast()(i, mstype.int64))
     mesh = list()
     ndim = len(shape) - 1
     for j, size in enumerate(shape[1:]):
-        grid = P.Range()(Tensor(0, mstype.int64), P.Fill()(mstype.int64, (), size), Tensor(1, mstype.int64))
+        grid = P.Range()(Tensor(0, mstype.int64), P.Cast()(size, mstype.int64), Tensor(1, mstype.int64))
         mesh.append(P.Reshape()(grid, tuple([size if j == t else 1 for t in range(ndim)])))
     shapes = map(P.Shape(), mesh)
     out_shape = infer_out_shape(*shapes)
@@ -875,7 +883,8 @@ def int_to_index(i, shape):
     for arr in mesh:
         mesh_arrays.append(P.BroadcastTo(out_shape)(arr))
     index = P.Stack(-1)(mesh_arrays)
-    return P.Concat(-1)((P.Fill()(mstype.int64, P.Shape()(index)[:-1] + (1,), i), index))
+    return P.Concat(-1)((P.FillV2()(P.Shape()(index)[:-1] + (1,),
+                                    P.Cast()(i, mstype.int64)), index))
 
 
 @constexpr
@@ -899,7 +908,7 @@ def rem_not_expanded_dims(idx_advanced, expand_true, tensor_index_ndim, rem_ndim
 
 @_primexpr
 def check_slice_empty(start, stop, step):
-    return (start - stop)*step >= 0
+    return (start - stop) * step >= 0
 
 
 @_primexpr
@@ -911,9 +920,6 @@ def real_axes(ndim_orig, ndim_out, axes_orig):
     return axes + tuple(axes_orig)
 
 
-check_axis_valid_const = constexpr(validator.check_axis_valid)
-
-
 @_primexpr
 def compute_slice_shape(slice_shape, broadcast_shape_len, slice_cnt, fancy_position):
     """Computes slice tensor shapes"""

mindspore/ops/composite/multitype_ops/add_impl.py

@@ -33,6 +33,7 @@ _add_backward = base.MultitypeFuncGraph('add_backward')
 `_add_backward` is an metafuncgraph object which will add_backward two objects according to input type
 using ".register" decorator.
 """
+add.set_need_raise()
 
 
 class _TupleAdd(base.TupleAdd_):
@@ -59,6 +60,50 @@ _tuple_add = _TupleAdd('tuple_add')
 """`_tuple_add` is an metafuncgraph object which will concatenate two tuples to form a tuple."""
 
 
+class _DictUpdate(base.DictUpdate_):
+    """
+    A metafuncgraph class that append another dict to the end of the dict.
+
+    Args:
+        name (str): The name of the metafuncgraph object.
+    """
+
+    def __init__(self, name):
+        """Initialize _DictUpdate."""
+        base.DictUpdate_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+_dict_update = _DictUpdate('dict_update')
+"""`_dict_update` is an metafuncgraph object which will concatenate two dict to form a dict."""
+
+
+class _ListAdd(base.ListAdd_):
+    """
+    Adding two lists.
+
+    Args:
+        x (list): x
+        y (list): y
+
+    Returns:
+        List, consists of elements of x and elements of y.
+    """
+
+    def __init__(self, name):
+        """Initialize _TupleAdd."""
+        base.ListAdd_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+_list_add = _ListAdd('list_add')
+"""`_list_add` is an metafuncgraph object which will concatenate two lists to form a list."""
+
+
 @add.register("Number", "Number")
 @_add_backward.register("Number", "Number")
 def _scalar_add_scalar(x, y):
@@ -198,9 +243,7 @@ def _list_add_list(x, y):
     """
     if F.is_sequence_shape_unknown(x) or F.is_sequence_shape_unknown(y):
         return SequenceAdd()(x, y)
-    for i in y:
-        x.append(i)
-    return x
+    return _list_add(x, y)
 
 
 @add.register("Tensor", "Tensor")
@@ -292,7 +335,8 @@ def _add_csrtensor(x, y):
     Returns:
         CSRTensor, consists of elements of x and elements of y.
     """
-    check_equal(x.shape, y.shape, "input1 (shape={}) and input2(shape={}) should be the same shape.")
+    check_equal(x.shape, y.shape,
+                "input1 (shape={}) and input2(shape={}) should be the same shape.")
     return F.csr_add(x, y, make_tensor(1, x.values.dtype), make_tensor(1, x.values.dtype))
 
 
@@ -308,7 +352,8 @@ def _add_cootensor(x, y):
     Returns:
         COOTensor, consists of elements of x and elements of y.
     """
-    check_equal(x.shape, y.shape, "input1 (shape={}) and input2(shape={}) should be the same shape.")
+    check_equal(x.shape, y.shape,
+                "input1 (shape={}) and input2(shape={}) should be the same shape.")
     return F.coo_add(x, y, make_tensor(0, x.values.dtype))
 
 
@@ -324,7 +369,8 @@ def _add_cootensor_tensor(x, y):
     Returns:
         Tensor, consists of elements of x and elements of y.
     """
-    check_equal(x.shape, y.shape, "input1 (shape={}) and input2(shape={}) should be the same shape.")
+    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)
 
 
@@ -340,7 +386,8 @@ def _add_tensor_cootensor(x, y):
     Returns:
         Tensor, consists of elements of x and elements of y.
     """
-    check_equal(x.shape, y.shape, "input1 (shape={}) and input2(shape={}) should be the same shape.")
+    check_equal(x.shape, y.shape,
+                "input1 (shape={}) and input2(shape={}) should be the same shape.")
     return F.tensor_scatter_add(x, y.indices, y.values)
 
 
@@ -535,4 +582,19 @@ def _map_tensor_add_backward(x, y):
     return x
 
 
+@add.register("Dictionary", "Dictionary")
+def _dict_add_dict(x, y):
+    """
+        dictionary is added to dictionary.
+
+        Args:
+            x (dictionary): x
+            y (dictionary): y.
+
+        Returns:
+            dictionary, has the same dtype as x.
+    """
+    return _dict_update(x, y)
+
+
 hyper_add = base.HyperMap(_add_backward)

mindspore/ops/composite/multitype_ops/bitwise_and_impl.py

@@ -23,6 +23,8 @@ from mindspore.ops.operations import _inner_ops as inner
 # using ".register" decorator
 bitwise_and = base.MultitypeFuncGraph("bitwise_and", True)
 
+bitwise_and.set_need_raise()
+
 
 @bitwise_and.register("Number", "Number")
 def _bitwise_and_scalar(x, y):
@@ -46,4 +48,3 @@ def _tensor_bitwise_and_scalar(x, y):
 def _scalar_bitwise_and_tensor(x, y):
     """Returns x & y where x and y are all tensors."""
     return F.bitwise_and(x, y)
-    

mindspore/ops/composite/multitype_ops/bitwise_or_impl.py

@@ -23,6 +23,8 @@ from mindspore.ops.operations import _inner_ops as inner
 # using ".register" decorator
 bitwise_or = base.MultitypeFuncGraph("bitwise_or", True)
 
+bitwise_or.set_need_raise()
+
 
 @bitwise_or.register("Number", "Number")
 def _bitwise_or_scalar(x, y):
@@ -46,4 +48,3 @@ def _tensor_bitwise_or_scalar(x, y):
 def _scalar_bitwise_or_tensor(x, y):
     """Returns x | y where x and y are all tensors."""
     return F.bitwise_or(x, y)
-    

mindspore/ops/composite/multitype_ops/bitwise_xor_impl.py

@@ -23,6 +23,8 @@ from mindspore.ops.operations import _inner_ops as inner
 # using ".register" decorator
 bitwise_xor = base.MultitypeFuncGraph("bitwise_xor", True)
 
+bitwise_xor.set_need_raise()
+
 
 @bitwise_xor.register("Number", "Number")
 def _bitwise_xor_scalar(x, y):

mindspore/ops/composite/multitype_ops/div_impl.py

@@ -28,6 +28,7 @@ div = base.MultitypeFuncGraph("div", True)
 div is a metafuncgraph object which will div two objects according to input type
 using ".register" decorator
 """
+div.set_need_raise()
 
 
 @div.register("CSRTensor", "Tensor")

mindspore/ops/composite/multitype_ops/floordiv_impl.py

@@ -25,6 +25,7 @@ floordiv = base.MultitypeFuncGraph("floordiv", True)
 `floordiv` is a metafuncgraph object which will compute the floordiv of two objects
 using ".register" decorator.
 """
+floordiv.set_need_raise()
 
 
 @floordiv.register("Number", "Number")

mindspore/ops/composite/multitype_ops/getitem_impl.py

@@ -23,14 +23,14 @@ from mindspore.ops import functional as F
 from mindspore.ops.operations._inner_ops import SliceGetItem
 from ...operations._sequence_ops import SequenceSlice
 
-DOC_URL = "https://mindspore.cn/docs/zh-CN/master/note/index_support.html"
+DOC_URL = "https://mindspore.cn/search/en?inputValue=Index%20values"
 
-getitem = base.MultitypeFuncGraph('getitem', doc_url=DOC_URL)
+getitem = base.MultitypeFuncGraph('getitem', False)
 """
 getitem is a metafuncgraph object which will get item from an object according to input type
 using ".register" decorator.
 """
-
+getitem.set_doc_url(DOC_URL)
 slice_getitem = SliceGetItem()
 sequence_slice = SequenceSlice()
 
@@ -49,7 +49,7 @@ class _TupleSlice(base.SequenceSliceGetItem_):
 
     def __init__(self, name):
         """Initialize _TupleSlice."""
-        base.SequenceSliceGetItem_.__init__(self, name, "MakeTuple", "TupleGetItem")
+        super(_TupleSlice, self).__init__(name, "MakeTuple", "TupleGetItem")
 
     def __call__(self, *args):
         pass
@@ -106,7 +106,26 @@ _tuple_get_item_tensor = _TupleGetItemTensor('tuple_get_item_tensor')
 """_tuple_get_item_tensor is an metafuncgraph object which will select indexed item."""
 
 
-@getitem.register("Tuple", "Number")
+@getitem.register("Tuple", "Bool")
+def _tuple_getitem_by_bool(data, number_index):
+    """
+    Getting item of tuple by bool index.
+
+    Inputs:
+        data (tuple): A tuple to be sliced.
+        number_index (Number): Index in scalar.
+
+    Outputs:
+        Type, is the same as the element type of data.
+    """
+    if number_index:
+        return F.tuple_getitem(data, 1)
+    return F.tuple_getitem(data, 0)
+
+
+@getitem.register("Tuple", "Int")
+@getitem.register("Tuple", "UInt")
+@getitem.register("Tuple", "Float")
 def _tuple_getitem_by_number(data, number_index):
     """
     Getting item of tuple by number index.
@@ -137,10 +156,10 @@ def _tuple_getitem_by_slice(data, slice_index):
         start = slice_getitem(slice_index, "start")
         stop = slice_getitem(slice_index, "stop")
         step = slice_getitem(slice_index, "step")
-        if start is None:
-            start = 0
         if step is None:
             step = 1
+        if start is None:
+            start = 0 if step >= 1 else -1
         if stop is None:
             stop = (2**31-1) if step >= 1 else -(2**31-1)
         return sequence_slice(data, start, stop, step)
@@ -162,7 +181,26 @@ def _tuple_getitem_by_tensor(data, tensor_index):
     return _tuple_get_item_tensor(data, tensor_index)
 
 
-@getitem.register("List", "Number")
+@getitem.register("List", "Bool")
+def _list_getitem_by_bool(data, number_index):
+    """
+    Getting item of list by bool index.
+
+    Inputs:
+        data (tuple): A list to be sliced.
+        number_index (Bool): Index in scalar.
+
+    Outputs:
+        Type, is the same as the element type of data.
+    """
+    if number_index:
+        return F.list_getitem(data, 1)
+    return F.list_getitem(data, 0)
+
+
+@getitem.register("List", "Int")
+@getitem.register("List", "UInt")
+@getitem.register("List", "Float")
 def _list_getitem_by_number(data, number_index):
     """
     Getting item of list by number index.
@@ -193,10 +231,10 @@ def _list_getitem_by_slice(data, slice_index):
         start = slice_getitem(slice_index, "start")
         stop = slice_getitem(slice_index, "stop")
         step = slice_getitem(slice_index, "step")
-        if start is None:
-            start = 0
         if step is None:
             step = 1
+        if start is None:
+            start = 0 if step >= 1 else -1
         if stop is None:
             stop = (2**31-1) if step >= 1 else -(2**31-1)
         return sequence_slice(data, start, stop, step)

mindspore/ops/composite/multitype_ops/greater_equal_impl.py

@@ -23,6 +23,8 @@ from ...operations._sequence_ops import tuple_greater_equal, list_greater_equal
 # using ".register" decorator
 greater_equal = base.MultitypeFuncGraph("greater_equal", True)
 
+greater_equal.set_need_raise()
+
 
 @greater_equal.register("Number", "Number")
 def _greater_equal_scala(x, y):

mindspore/ops/composite/multitype_ops/greater_impl.py

@@ -24,6 +24,8 @@ from ...operations._sequence_ops import tuple_greater_than, list_greater_than
 # using ".register" decorator
 greater = base.MultitypeFuncGraph("greater", True)
 
+greater.set_need_raise()
+
 
 @greater.register("Number", "Number")
 def _greater_scalar(x, y):

mindspore/ops/composite/multitype_ops/left_shift_impl.py

@@ -22,6 +22,8 @@ from mindspore.ops.operations import _inner_ops as inner
 # using ".register" decorator
 left_shift = base.MultitypeFuncGraph("left_shift", True)
 
+left_shift.set_need_raise()
+
 
 @left_shift.register("Number", "Number")
 def _left_shift_scalar(x, y):

mindspore/ops/composite/multitype_ops/less_equal_impl.py

@@ -25,6 +25,8 @@ from mindspore.ops.operations import _sequence_ops as _seq
 # using ".register" decorator
 less_equal = base.MultitypeFuncGraph("less_equal", True)
 
+less_equal.set_need_raise()
+
 
 @less_equal.register("Number", "Number")
 def _less_equal_scala(x, y):

mindspore/ops/composite/multitype_ops/less_impl.py

@@ -26,6 +26,8 @@ from mindspore.ops.operations import _sequence_ops as _seq
 # using ".register" decorator
 less = base.MultitypeFuncGraph("less", True)
 
+less.set_need_raise()
+
 
 @less.register("Number", "Number")
 def _less_scala(x, y):

mindspore/ops/composite/multitype_ops/logic_not_impl.py

@@ -90,7 +90,7 @@ def _logical_not_tuple(x):
     Returns:
        bool, Return logical not operation result of x.
    """
-    return F.bool_not(x.__bool__())
+    return x.__len__() == 0
 
 
 @logical_not.register("List")
@@ -104,4 +104,4 @@ def _logical_not_list(x):
     Returns:
        bool, Return logical not operation result of x.
    """
-    return F.bool_not(x.__bool__())
+    return x.__len__() == 0

mindspore/ops/composite/multitype_ops/mod_impl.py

@@ -25,6 +25,7 @@ mod = base.MultitypeFuncGraph("mod", True)
 `mod` is a metafuncgraph object which will compute the mod of two objects
 using ".register" decorator.
 """
+mod.set_need_raise()
 
 
 @mod.register("Number", "Number")

mindspore/ops/composite/multitype_ops/mul_impl.py

@@ -27,6 +27,7 @@ mul = base.MultitypeFuncGraph("mul", True)
 `mul` is a metafuncgraph object which will multiply two objects according to input type
 using ".register" decorator.
 """
+mul.set_need_raise()
 
 
 @mul.register("Number", "Number")

mindspore/ops/composite/multitype_ops/negative_impl.py

@@ -26,6 +26,7 @@ negative = base.MultitypeFuncGraph("negative", True)
 `negative` is a metafuncgraph object which will give the negative of an object according to its input type
 using ".register" decorator.
 """
+negative.set_need_raise()
 
 
 @negative.register("Number")

mindspore/ops/composite/multitype_ops/not_in_impl.py

@@ -27,6 +27,7 @@ not_in_ = base.MultitypeFuncGraph("not_in", True)
 "not_in_" is a multi type func graph object which will determine if a not in b.
 using ".register" decorator
 """
+not_in_.set_need_raise()
 
 
 @not_in_.register("Number", "Tuple")

mindspore/ops/composite/multitype_ops/ones_like_impl.py

@@ -78,6 +78,12 @@ def _ones_like_func(x):
     return F.environ_create()
 
 
+@ones_like_leaf.register("None")
+def _ones_like_none(x):
+    """Returns none"""
+    return None
+
+
 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.

mindspore/ops/composite/multitype_ops/pow_impl.py

@@ -26,6 +26,7 @@ pow_ = base.MultitypeFuncGraph("pow", True)
 `pow` is a metafuncgraph object which will compute the pow of two objects
 using ".register" decorator.
 """
+pow_.set_need_raise()
 
 
 @pow_.register("Number", "Number")

mindspore/ops/composite/multitype_ops/right_shift_impl.py

@@ -22,6 +22,8 @@ from mindspore.ops.operations import _inner_ops as inner
 # using ".register" decorator
 right_shift = base.MultitypeFuncGraph("right_shift", True)
 
+right_shift.set_need_raise()
+
 
 @right_shift.register("Number", "Number")
 def _right_shift_scalar(x, y):

mindspore/ops/composite/multitype_ops/setitem_impl.py

@@ -22,10 +22,13 @@ 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 ...operations._sequence_ops import SequenceSliceSetItem
 
-DOC_URL = "https://mindspore.cn/docs/zh-CN/r2.0/note/index_support.html"
-setitem = base.MultitypeFuncGraph('setitem', doc_url=DOC_URL)
+DOC_URL = "https://mindspore.cn/search/en?inputValue=Index%20value%20assignment"
+
+setitem = base.MultitypeFuncGraph('setitem')
+setitem.set_doc_url(DOC_URL)
 slice_get_item = SliceGetItem()
 sequence_slice_setitem = SequenceSliceSetItem()
 
@@ -250,7 +253,7 @@ def _dict_setitem_with_tensor(data, key, value):
     Outputs:
         dict, type is as same as the element type of data.
     """
-    return F.dict_setitem(data, key, value)
+    return _dict_setitem(data, key, value)
 
 
 @setitem.register("Tensor", "Tensor", "Tensor")
@@ -436,7 +439,7 @@ def _tensor_setitem_by_slice_with_tensor(data, input_slice, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
-    return compile_utils.tensor_setitem_by_slice_with_tensor(data, input_slice, value)
+    return compile_utils.tensor_setitem_by_slice(data, input_slice, value)
 
 
 @setitem.register("Tensor", "Slice", "Number")
@@ -458,7 +461,7 @@ def _tensor_setitem_by_slice_with_number(data, input_slice, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
-    return compile_utils.tensor_setitem_by_slice_with_number(data, input_slice, value)
+    return compile_utils.tensor_setitem_by_slice(data, input_slice, value)
 
 
 @setitem.register("Tensor", "Slice", "List")
@@ -480,7 +483,7 @@ def _tensor_setitem_by_slice_with_list(data, input_slice, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
-    return compile_utils.tensor_setitem_by_slice_with_sequence(data, input_slice, value)
+    return compile_utils.tensor_setitem_by_slice(data, input_slice, value)
 
 
 @setitem.register("Tensor", "Slice", "Tuple")
@@ -502,7 +505,7 @@ def _tensor_setitem_by_slice_with_tuple(data, input_slice, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
-    return compile_utils.tensor_setitem_by_slice_with_sequence(data, input_slice, value)
+    return compile_utils.tensor_setitem_by_slice(data, input_slice, value)
 
 
 @setitem.register("Tensor", "Number", "Number")

mindspore/ops/composite/multitype_ops/sub_impl.py

@@ -27,6 +27,7 @@ sub = base.MultitypeFuncGraph("sub", True)
 `sub` is a metafuncgraph object which will compute the subtraction of two objects
 using ".register" decorator.
 """
+sub.set_need_raise()
 
 
 @sub.register("Number", "Number")

mindspore/ops/composite/multitype_ops/uadd_impl.py

@@ -20,6 +20,8 @@ from mindspore.ops.composite import base
 # using ".register" decorator
 uadd = base.MultitypeFuncGraph("uadd", True)
 
+uadd.set_need_raise()
+
 
 @uadd.register("Tensor")
 @uadd.register("Number")