mindspore 2.2.14__cp38-cp38-manylinux1_x86_64.whl → 2.3.0rc2__cp38-cp38-manylinux1_x86_64.whl

mindspore/ops/composite/multitype_ops/_constexpr_utils.py

@@ -23,9 +23,11 @@ from mindspore.common import dtype as mstype
 from mindspore.common._register_for_tensor import tensor_operator_registry
 from mindspore.common.tensor import Tensor
 from mindspore.ops import operations as P
+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
@@ -198,6 +200,8 @@ def make_tensor(a, dtype=mstype.int64, data_shape=None, dim_size=None):
         return P.ScalarToTensor()(a, dtype)
 
     if isinstance(a, (list, tuple)):
+        if not a:
+            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
@@ -455,10 +459,22 @@ def tuple_index_type_cnt(types, op_name):
 def check_value_elements(types):
     """Judges the type of all elements of the tuple."""
     tensor_number = 0
+    last_type = None
+    mix_but_no_tensor = False
     for ele in types:
         if isinstance(ele, mstype.TensorType):
             tensor_number += 1
+        elif isinstance(ele, (list, tuple)):
+            return MIXED
+
+        if last_type is None:
+            last_type = type(ele)
+        elif not isinstance(ele, last_type):
+            mix_but_no_tensor = True
+
     if tensor_number == 0:
+        if mix_but_no_tensor:
+            return MIXED
         return NO_TENSOR
     if tensor_number == len(types):
         return ALL_TENSOR
@@ -529,12 +545,6 @@ def generate_broadcast_shape(shapes, op_name):
     return tuple(broadcast_shape)
 
 
-@_primexpr
-def check_two_shapes_need_broadcast(shape_x, shape_y):
-    """Check shape_y needs to be broadcast to shape_x."""
-    return shape_y != shape_x
-
-
 @_primexpr
 def compute_multiples(origin_shape, broadcast_shape):
     """Compute multiples between origin shape with broadcast shape."""
@@ -552,18 +562,12 @@ def convert_scalar_to_tensor(data_shape, data_dtype, indices_shape, value, op_ty
     return P.FillV2()(updates_shape, P.Cast()(value, data_dtype))
 
 
-def generate_updates_shape(data_shape, index_shape, op_type, is_dynamic):
+def generate_updates_shape(data_shape, index_shape, op_type):
     """Generate updates shape for 'tensor setitem'."""
     if op_type == SET_ITEM_BY_ONE_TENSOR:
-        if is_dynamic:
-            updates_shape = P.Concat(-1)((index_shape, data_shape[1:]))
-        else:
-            updates_shape = index_shape + data_shape[1:]
+        updates_shape = index_shape + data_shape[1:]
     else:
-        if is_dynamic:
-            updates_shape = P.Concat(-1)((index_shape[:-1], data_shape[index_shape[-1]:]))
-        else:
-            updates_shape = index_shape[:-1] + data_shape[index_shape[-1]:]
+        updates_shape = index_shape[:-1] + data_shape[index_shape[-1]:]
     return updates_shape
 
 
@@ -632,94 +636,6 @@ def check_number_index_type(number):
                      .format(number, type(number)))
 
 
-@_primexpr
-def get_stride_info_from_slice(data_shape, slice_index):
-    """Get stride info from a python slice"""
-    begin, end, step = get_slice_stride(slice_index, data_shape[0])
-    begin_strides = [begin]
-    end_strides = [end]
-    step_strides = [step]
-    for end in data_shape[1:]:
-        begin_strides.append(0)
-        end_strides.append(end)
-        step_strides.append(1)
-    return tuple(begin_strides), tuple(end_strides), tuple(step_strides)
-
-
-@constexpr
-def get_stride_info_from_integer(data_shape, number):
-    """Get stride info from an integer"""
-    begin_strides = [number]
-    end_strides = [number + 1]
-    step_strides = [1]
-    for end in data_shape[1:]:
-        begin_strides.append(0)
-        end_strides.append(end)
-        step_strides.append(1)
-    return tuple(begin_strides), tuple(end_strides), tuple(step_strides)
-
-
-@constexpr
-def get_slice_stride(index_slice, dim_size):
-    """Get slice stride info"""
-    step = 1 if index_slice.step is None else index_slice.step
-    if step < 0:
-        start_default = -1
-        stop_default = -(dim_size + 1)
-        stop = stop_default if index_slice.stop is None else max(stop_default, index_slice.stop)
-    else:
-        start_default = 0
-        stop_default = dim_size
-        stop = stop_default if index_slice.stop is None else min(stop_default, index_slice.stop)
-    start = start_default if index_slice.start is None else index_slice.start
-    return start, stop, step
-
-
-@constexpr
-def get_stride_info_from_tuple(data_shape, tuple_index):
-    """Get stride info from a tuple"""
-    begin_strides, end_strides, step_strides = [], [], []
-    tuple_index_len = len(tuple_index)
-    data_dim = len(data_shape)
-    shrink_axis, index_count, ellipsis_count = 0, 0, 0
-    for index, dim_size in zip(tuple_index, data_shape):
-        if isinstance(index, slice):
-            start, stop, step = get_slice_stride(index, dim_size)
-            begin_strides.append(start)
-            end_strides.append(stop)
-            step_strides.append(step)
-            index_count = index_count + 1
-        elif isinstance(index, int):
-            begin_strides.append(index)
-            end_strides.append(index + 1)
-            step_strides.append(1)
-            shrink_axis = shrink_axis + (1 << index_count)
-            index_count = index_count + 1
-        elif index is ...:
-            ellipsis_count = ellipsis_count + 1
-            if ellipsis_count > 1:
-                raise IndexError("An index can have only one ellipsis (...)")
-            ellipsis_range_size = data_dim - tuple_index_len + 1
-            begin_strides.extend([0] * ellipsis_range_size)
-            end_strides.extend(
-                [shape for shape in data_shape[index_count: index_count + ellipsis_range_size]])
-            step_strides.extend([1] * ellipsis_range_size)
-            index_count = index_count + ellipsis_range_size
-        else:
-            raise IndexError("Not supported index data type, got ",
-                             index, " type is ", type(index))
-    for index in range(index_count, data_dim):
-        begin_strides.append(0)
-        end_strides.append(data_shape[index])
-        step_strides.append(1)
-    strides_v = {
-        'begin': tuple(begin_strides),
-        'end': tuple(end_strides),
-        'step': tuple(step_strides)
-    }
-    return strides_v, shrink_axis
-
-
 @constexpr
 def scalar_to_tensor(x):
     """Convert a scalar to a tensor"""
@@ -860,33 +776,6 @@ def sequence_to_index(sequence, dim_size):
     return make_tensor(sequence, mstype.int64, None, dim_size)
 
 
-@_primexpr
-def int_to_index(i, shape):
-    """Converts integer to tensor indices."""
-    def _check(i, dim_size):
-        if i < -dim_size or i >= dim_size:
-            raise IndexError(f'index {i} is out of bounds for axis 0 with size {dim_size}')
-
-    dim_size = shape[0]
-    _check(i, dim_size)
-    i = (i + dim_size) % dim_size
-    if len(shape) == 1:
-        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.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)
-    mesh_arrays = list()
-    for arr in mesh:
-        mesh_arrays.append(P.BroadcastTo(out_shape)(arr))
-    index = P.Stack(-1)(mesh_arrays)
-    return P.Concat(-1)((P.FillV2()(P.Shape()(index)[:-1] + (1,),
-                                    P.Cast()(i, mstype.int64)), index))
-
-
 @constexpr
 def rem_not_expanded_dims(idx_advanced, expand_true, tensor_index_ndim, rem_ndim, not_expanded_dim):
     """Adds remaining dimensions not indexed to not_expanded_dim"""
@@ -945,7 +834,7 @@ def infer_out_shape(*shapes):
     return tuple(shape_out)
 
 
-@constexpr
+@constexpr(check=False)
 def use_copy_slice(tuple_index):
     if tuple_index is not None and len(tuple_index) >= 2:
         return (isinstance(tuple_index[0], int) and
@@ -1000,7 +889,9 @@ def generate_padding_shape(shape, length):
     """
     pad the `shape` to `length` with 1.
     """
-    if len(shape) > length:
-        raise ValueError(f"Can not pad {shape} to length {length}.")
+
+    if _inner_ops.IsConstant()(length) and _inner_ops.IsConstant()(len(shape)):
+        if len(shape) > length:
+            raise ValueError(f"Can not pad {shape} to length {length}.")
 
     return shape + (1,) * (length - len(shape))

mindspore/ops/composite/multitype_ops/add_impl.py

@@ -598,3 +598,9 @@ def _dict_add_dict(x, y):
 
 
 hyper_add = base.HyperMap(_add_backward)
+
+
+@add.register_default()
+def default_add(x, y):
+    """Default function for add."""
+    return x + y

mindspore/ops/composite/multitype_ops/bitwise_and_impl.py

@@ -48,3 +48,9 @@ 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)
+
+
+@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

@@ -48,3 +48,9 @@ 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)
+
+
+@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

@@ -48,3 +48,9 @@ def _tensor_bitwise_xor_scalar(x, y):
 def _scalar_bitwise_xor_tensor(x, y):
     """Returns x ^ y where x and y are all tensors."""
     return F.bitwise_xor(x, y)
+
+
+@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

@@ -179,3 +179,11 @@ def _tensor_div_list(x, y):
     """
     y = utils.sequence_to_tensor(y, x.dtype)
     return F.tensor_div(x, y)
+
+
+@div.register_default()
+def default_div(x, y):
+    """Default function for div."""
+    if y != 0:
+        return x / y
+    raise ValueError("division by zero")

mindspore/ops/composite/multitype_ops/equal_impl.py

@@ -327,3 +327,9 @@ def _string_equal_number(x, y):
        bool, return false.
    """
     return False
+
+
+@equal.register_default()
+def default_equal(x, y):
+    """Default function for equal."""
+    return x == y

mindspore/ops/composite/multitype_ops/floordiv_impl.py

@@ -78,3 +78,11 @@ def _tensor_floordiv_list(x, y):
     """Returns x // y where x is a tensor and y is a list. """
     y = utils.sequence_to_tensor(y, x.dtype)
     return F.tensor_floordiv(x, y)
+
+
+@floordiv.register_default()
+def default_floordiv(x, y):
+    """Default function for floordiv."""
+    if y == 0:
+        raise ValueError("division by zero")
+    return x // y

mindspore/ops/composite/multitype_ops/getitem_impl.py

@@ -392,3 +392,9 @@ def _map_tensor_getitem(map_tensor, key_tensor):
         Tensor, value tensor according the key tensor.
     """
     return _map_tensor_ops.MapTensorGet(True)(map_tensor, key_tensor)
+
+
+@getitem.register_default()
+def default_getitem(x, y):
+    """Default function for getitem."""
+    return x[y]

mindspore/ops/composite/multitype_ops/greater_equal_impl.py

@@ -101,3 +101,9 @@ def _greater_equal_list(x, y):
        bool, if x >= y return true in python logic, x < y return false.
    """
     return list_greater_equal()(x, y)
+
+
+@greater_equal.register_default()
+def default_greater_equal(x, y):
+    """Default function for greater equal."""
+    return x >= y

mindspore/ops/composite/multitype_ops/greater_impl.py

@@ -102,3 +102,9 @@ def _greater_than_list(x, y):
        bool, if x > y return true in python logic, x <= y return false.
    """
     return list_greater_than()(x, y)
+
+
+@greater.register_default()
+def default_greater(x, y):
+    """Default function for greater."""
+    return x > y

mindspore/ops/composite/multitype_ops/in_impl.py

@@ -41,7 +41,7 @@ def _number_in_tuple(x, y):
     Returns:
        bool, if x in y return true, x not in y return false.
    """
-    if F.is_sequence_shape_unknown(y) or not F.isconstant(x):
+    if F.is_sequence_value_unknown(y) or not F.isconstant(x):
         return InSequence()(x, y)
     return const_utils.scalar_in_sequence(x, y)
 
@@ -58,7 +58,7 @@ def _number_in_list(x, y):
     Returns:
        bool, if x in y return true, x not in y return false.
    """
-    if F.is_sequence_shape_unknown(y) or not F.isconstant(x):
+    if F.is_sequence_value_unknown(y) or not F.isconstant(x):
         return InSequence()(x, y)
     return const_utils.scalar_in_sequence(x, y)
 
@@ -188,3 +188,9 @@ def _mstype_in_tuple(x, y):
        bool, if x in y return true, x not in y return false.
    """
     return const_utils.check_in_sequence(x, y)
+
+
+@in_.register_default()
+def default_in(x, y):
+    """Default function for in."""
+    return x in y

mindspore/ops/composite/multitype_ops/left_shift_impl.py

@@ -29,3 +29,9 @@ left_shift.set_need_raise()
 def _left_shift_scalar(x, y):
     """Returns x << y where x and y are all scalars."""
     return inner.bit_left_shift(x, y)
+
+
+@left_shift.register_default()
+def default_left_shift(x, y):
+    """Default function for left shift."""
+    return x << y

mindspore/ops/composite/multitype_ops/less_equal_impl.py

@@ -103,3 +103,9 @@ def _less_equal_list(x, y):
        bool, if x <= y return true in python logic, x > y return false.
    """
     return _seq.list_le()(x, y)
+
+
+@less_equal.register_default()
+def default_less_equal(x, y):
+    """Default function for less equal."""
+    return x <= y

mindspore/ops/composite/multitype_ops/less_impl.py

@@ -104,3 +104,9 @@ def _less_list(x, y):
        bool, if x < y return true in python logic, x >= y return false.
    """
     return _seq.list_lt()(x, y)
+
+
+@less.register_default()
+def default_less(x, y):
+    """Default function for less."""
+    return x < y

mindspore/ops/composite/multitype_ops/logic_not_impl.py

@@ -105,3 +105,9 @@ def _logical_not_list(x):
        bool, Return logical not operation result of x.
    """
     return x.__len__() == 0
+
+
+@logical_not.register_default()
+def default_logical_not(x):
+    """Default function for logical not."""
+    return not x

mindspore/ops/composite/multitype_ops/logical_and_impl.py

@@ -52,3 +52,9 @@ def _logical_and_tensor(x, y):
        Tensor, Return logical and operation result of x and y.
    """
     return F.logical_and(x, y)
+
+
+@logical_and.register_default()
+def default_logical_and(x, y):
+    """Default function for logical and."""
+    return x and y

mindspore/ops/composite/multitype_ops/logical_or_impl.py

@@ -53,3 +53,9 @@ def _logical_or_tensor(x, y):
        Tensor, Return logical operation or result of x and y.
    """
     return F.logical_or(x, y)
+
+
+@logical_or.register_default()
+def default_logical_or(x, y):
+    """Default function for logical or."""
+    return x or y

mindspore/ops/composite/multitype_ops/mod_impl.py

@@ -78,3 +78,9 @@ def _tensor_mod_list(x, y):
     """Returns x % y where x is a tensor and y is a list. """
     y = utils.sequence_to_tensor(y, x.dtype)
     return F.tensor_mod(x, y)
+
+
+@mod.register_default()
+def default_mod(x, y):
+    """Default function for mod."""
+    return x % y

mindspore/ops/composite/multitype_ops/mul_impl.py

@@ -286,3 +286,9 @@ def _tensor_mul_cootensor(x, y):
     check_equal(x.shape, y.shape, "input1 (shape={}) and input2(shape={}) should be the same shape.")
     other_values = F.gather_nd(x, y.indices)
     return COOTensor(y.indices, y.values * other_values, y.shape)
+
+
+@mul.register_default()
+def default_mul(x, y):
+    """Default function for mul."""
+    return x * y

mindspore/ops/composite/multitype_ops/negative_impl.py

@@ -48,7 +48,7 @@ def _negative_tensor(x):
     Returns:
        Tensor, negative value of x by element-wise.
    """
-    return F.neg_tensor(x)
+    return F.neg(x)
 
 
 @negative.register("CSRTensor")
@@ -59,7 +59,7 @@ def _negative_csrtensor(x):
     Returns:
        CSRTensor, negative value of x by element-wise.
    """
-    return CSRTensor(x.indptr, x.indices, F.neg_tensor(x.values), x.shape)
+    return CSRTensor(x.indptr, x.indices, F.neg(x.values), x.shape)
 
 
 @negative.register("COOTensor")
@@ -70,4 +70,10 @@ def _negative_cootensor(x):
     Returns:
        COOTensor, negative value of x by element-wise.
    """
-    return COOTensor(x.indices, F.neg_tensor(x.values), x.shape)
+    return COOTensor(x.indices, F.neg(x.values), x.shape)
+
+
+@negative.register_default()
+def default_negative(x):
+    """Default function for negative."""
+    return -x

mindspore/ops/composite/multitype_ops/not_equal_impl.py

@@ -282,3 +282,9 @@ def _none_not_equal_list(x, y):
        bool, return true.
    """
     return True
+
+
+@not_equal.register_default()
+def default_not_equal(x, y):
+    """Default function for not equal."""
+    return x != y

mindspore/ops/composite/multitype_ops/not_in_impl.py

@@ -27,7 +27,6 @@ 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")
@@ -189,3 +188,9 @@ def _mstype_not_in_tuple(x, y):
        bool, if x not in y return true, x in y return false.
    """
     return not const_utils.check_in_sequence(x, y)
+
+
+@not_in_.register_default()
+def default_not_in(x, y):
+    """Default function for not in."""
+    return x not in y

mindspore/ops/composite/multitype_ops/ones_like_impl.py

@@ -15,7 +15,7 @@
 # limitations under the License.
 # ============================================================================
 
-"""Implementation for internal polymorphism `ones_like_leaf` operations."""
+"""Implementation for internal polymorphism `ones_like` operations."""
 
 from __future__ import absolute_import
 from mindspore.ops.composite import base
@@ -23,7 +23,7 @@ from mindspore.ops import functional as F
 from mindspore.ops import operations as P
 
 
-ones_like_leaf = base.MultitypeFuncGraph('ones_like_leaf', True)
+ones_like_leaf = base.MultitypeFuncGraph('ones_like', True)
 """
 `ones_like_leaf` is a metafuncgraph object which will generate a tensor filled with one according to its input type
 using ".register" decorator.

mindspore/ops/composite/multitype_ops/pow_impl.py

@@ -79,3 +79,9 @@ def _tensor_pow_list(x, y):
     """Returns x ** y where x is a tensor and y is a list. """
     y = utils.sequence_to_tensor(y, x.dtype)
     return F.tensor_pow(x, y)
+
+
+@pow_.register_default()
+def default_pow(x, y):
+    """Default function for pow."""
+    return x ** y

mindspore/ops/composite/multitype_ops/right_shift_impl.py

@@ -29,3 +29,9 @@ right_shift.set_need_raise()
 def _right_shift_scalar(x, y):
     """Returns x >> y where x and y are all scalars."""
     return inner.bit_right_shift(x, y)
+
+
+@right_shift.register_default()
+def default_right_shift(x, y):
+    """Default function for right shift."""
+    return x >> y

mindspore/ops/composite/multitype_ops/setitem_impl.py

@@ -21,8 +21,8 @@ from mindspore.ops import functional as F
 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 mindspore.ops.operations._sequence_ops import TensorToScalar
 from ...operations._sequence_ops import SequenceSliceSetItem
 
 DOC_URL = "https://mindspore.cn/search/en?inputValue=Index%20value%20assignment"
@@ -105,6 +105,23 @@ def _list_setitem_with_tensor(data, number_index, value):
     return F.list_setitem(data, number_index, value)
 
 
+@setitem.register("List", "Tensor", "Tensor")
+def _list_setitem_with_tensor_index(data, tensor_index, value):
+    """
+    Assigns value to list.
+
+    Inputs:
+        data (list): Data of type list.
+        tensor_index (Tensor): Index of data.
+        value (Tensor): Value given.
+
+    Outputs:
+        list, type is the same as the element type of data.
+    """
+    number_index = TensorToScalar()(tensor_index)
+    return F.list_setitem(data, number_index, value)
+
+
 @setitem.register("List", "Number", "List")
 def _list_setitem_with_list(data, number_index, value):
     """
@@ -777,11 +794,8 @@ def _tensor_setitem_by_list_with_number(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
-    # list indices will be converted to tuple or tensor based on its contents.
-    index = compile_utils.format_list_indices(index, data.shape[0])
-    if isinstance(index, Tensor):
-        return compile_utils.tensor_setitem_by_tensor_with_number(data, index, value)
-    return compile_utils.tensor_setitem_by_tuple_with_number(data, index, value)
+    value = F.cast(value, F.dtype(data))
+    return compile_utils.tensor_setitem_by_list(data, index, value)
 
 
 @setitem.register("Tensor", "List", "Tensor")
@@ -801,11 +815,7 @@ def _tensor_setitem_by_list_with_tensor(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
-    # list indices will be converted to tuple or tensor based on its contents.
-    index = compile_utils.format_list_indices(index, data.shape[0])
-    if isinstance(index, Tensor):
-        return compile_utils.tensor_setitem_by_tensor_with_tensor(data, index, value)
-    return compile_utils.tensor_setitem_by_tuple_with_tensor(data, index, value)
+    return compile_utils.tensor_setitem_by_list(data, index, value)
 
 
 @setitem.register("Tensor", "List", "Tuple")
@@ -825,11 +835,8 @@ def _tensor_setitem_by_list_with_tuple(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
-    # list indices will be converted to tuple or tensor based on its contents.
-    index = compile_utils.format_list_indices(index, data.shape[0])
-    if isinstance(index, Tensor):
-        return compile_utils.tensor_setitem_by_tensor_with_sequence(data, index, value)
-    return compile_utils.tensor_setitem_by_tuple_with_sequence(data, index, value)
+    value = compile_utils.sequence_to_tensor(value, F.dtype(data))
+    return compile_utils.tensor_setitem_by_list(data, index, value)
 
 
 @setitem.register("Tensor", "List", "List")
@@ -849,11 +856,8 @@ def _tensor_setitem_by_list_with_list(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
-    # list indices will be converted to tuple or tensor based on its contents.
-    index = compile_utils.format_list_indices(index, data.shape[0])
-    if isinstance(index, Tensor):
-        return compile_utils.tensor_setitem_by_tensor_with_sequence(data, index, value)
-    return compile_utils.tensor_setitem_by_tuple_with_sequence(data, index, value)
+    value = compile_utils.sequence_to_tensor(value, F.dtype(data))
+    return compile_utils.tensor_setitem_by_list(data, index, value)
 
 
 @setitem.register("MapTensor", "Tensor", "Tensor")
@@ -871,3 +875,10 @@ def _map_tensor_setitem(map_tensor, key_tensor, value_tensor):
     """
     _map_tensor_ops.put(map_tensor, key_tensor, value_tensor)
     return map_tensor
+
+
+@setitem.register_default()
+def default_getitem(x, y, z):
+    """Default function for setitem."""
+    x[y] = z
+    return x

mindspore/ops/composite/multitype_ops/sub_impl.py

@@ -108,3 +108,9 @@ def _cootensor_sub_tensor(x, y):
     """Returns x - y where x is a COO tensor and y is a tensor."""
     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)
+
+
+@sub.register_default()
+def default_sub(x, y):
+    """Default function for sub."""
+    return x - y