mindspore 2.1.0__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/ops/composite/multitype_ops/_compile_utils.py

@@ -24,7 +24,8 @@ from mindspore.ops import operations as P
 from mindspore.ops.composite import base
 from mindspore.ops._primitive_cache import _get_cache_prim
 from mindspore.ops.operations._inner_ops import TensorCopySlices, SliceGetItem, \
-    TopTypeof, issubclass_, IsParameter, GetitemTensorIndexInfo, SetitemTensorIndexInfo
+    TopTypeof, issubclass_, IsParameter, GetitemTensorIndexInfo, SetitemTensorIndexInfo, \
+    SelectView, CopyWithSlice
 from mindspore.common import dtype as mstype
 from mindspore.common._register_for_tensor import tensor_operator_registry
 from mindspore.common.initializer import Zero
@@ -33,6 +34,7 @@ from mindspore.common import mutable
 from mindspore import ops
 from mindspore.ops.primitive import _primexpr
 from mindspore import _checkparam as validator
+from mindspore.common._stub_tensor import _convert_stub
 
 slice_get_item = SliceGetItem()
 hyper_map = base.HyperMap()
@@ -43,6 +45,8 @@ is_parameter = IsParameter()
 getitem_tensor_index_info = GetitemTensorIndexInfo(const_utils.is_ascend())
 setitem_tensor_index_info = SetitemTensorIndexInfo(const_utils.is_ascend())
 
+selevt_view = SelectView()
+copy_with_slice = CopyWithSlice()
 
 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):
@@ -66,19 +70,23 @@ class ValueTransferType(IntEnum):
     kGatherND = 9
     kScatterNdUpdate = 10
     kReshape = 11
-    kScatterND = 12
-    kNumberToTensor = 13
-    kHandleSequenceValue = 14
-    kByPass = 15
-    kReSetItemByIndex = 16
-    kCopySlice = 17
-    kSetItemByBool = 18
-    kEmptyTensor = 19
-    kSetItemByEllipsis = 20
-    kFormatIndexTensor = 21
-    kGetitemByBoolTensor = 22
-    kSetitemByBoolTensor = 23
-    kRaiseIndexError = 24
+    kSelectView = 12
+    kUnsqueeze = 13
+    kCopyView = 14
+    kScatterND = 15
+    kNumberToTensor = 16
+    kHandleSequenceValue = 17
+    kByPass = 18
+    kReSetItemByIndex = 19
+    kCopySlice = 20
+    kSetItemByBool = 21
+    kEmptyTensor = 22
+    kSetItemByEllipsis = 23
+    kFormatIndexTensor = 24
+    kGetitemByBoolTensor = 25
+    kSetitemByBoolTensor = 26
+    kJustReturn = 27
+    kRaiseIndexError = 28
 
 
 def data_update(transfer_types, args, data, new_index, value=None):
@@ -86,11 +94,14 @@ def data_update(transfer_types, args, data, new_index, value=None):
     We finally generate a new tensor when handling tensor getitem/setitem
     by transfer data and value with index.
     """
+    origin_data = data
     for transfer_type, arg in zip(transfer_types, args):
         if transfer_type == ValueTransferType.kUnknown:
             raise IndexError(f"Inlvaid transfer type {transfer_type}.")
         if transfer_type <= ValueTransferType.kScatterND:
-            data = data_update_by_ops(transfer_type, arg, data, new_index, value)
+            data = data_update_by_ops(transfer_type, arg, data, new_index, origin_data, value)
+        if transfer_type == ValueTransferType.kJustReturn:
+            return _convert_stub(arg)
         if transfer_type == ValueTransferType.kSetItemByBool:
             return tensor_setitem_by_bool(data, new_index, value)
         if transfer_type == ValueTransferType.kCopySlice:
@@ -114,7 +125,7 @@ def data_update(transfer_types, args, data, new_index, value=None):
     return data
 
 
-def data_update_by_ops(transfer_type, arg, data, new_index, value=None):
+def data_update_by_ops(transfer_type, arg, data, new_index, origin_data, value=None):
     """
     Generate a new tensor when handling tensor getitem/setitem
     by ops.
@@ -135,14 +146,22 @@ def data_update_by_ops(transfer_type, arg, data, new_index, value=None):
         F.scatter_nd_update(data, new_index, value)
     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])
+    elif transfer_type == ValueTransferType.kCopyView:
+        value = _broadcast(F.shape(data), F.cast(value, F.dtype(data)))
+        data = copy_with_slice(data, value)
+        return origin_data
     elif transfer_type == ValueTransferType.kReshape:
         data = F.reshape(data, arg)
     elif transfer_type == ValueTransferType.kGather:
         data = F.gather(data, new_index, 0)
     elif transfer_type == ValueTransferType.kExpandDims:
         data = F.expand_dims(data, 0)
+    elif transfer_type == ValueTransferType.kUnsqueeze:
+        data = F.unsqueeze(data, arg)
     elif transfer_type == ValueTransferType.kStrideSlice:
-        data = F.strided_slice(data, arg[0], arg[1], arg[2])
+        data = strided_slice(data, arg[0], arg[1], arg[2])
     else:
         raise IndexError(f"Inlvaid transfer type {transfer_type}.")
     return data
@@ -154,7 +173,7 @@ def value_update(transfer_types, args, data, value):
         if transfer_type == ValueTransferType.kByPass:
             continue
         if transfer_type == ValueTransferType.kNumberToTensor:
-            value = F.fill(F.dtype(data), (), value)
+            value = F.cast(value, F.dtype(data))
         elif transfer_type == ValueTransferType.kHandleSequenceValue:
             op_type, index = arg
             if op_type == const_utils.SET_ITEM_BY_ONE_TENSOR:
@@ -192,7 +211,10 @@ def _tensor_setitem(self, index, value):
     data_update_types = setitem_info[3]
     data_update_args = setitem_info[4]
     value = value_update(v_transfer_types, v_transfer_args, self, value)
-    return data_update(data_update_types, data_update_args, self, new_index, value)
+    output = data_update(data_update_types, data_update_args, self, new_index, value)
+    if new_index == "view":
+        return (self,)
+    return output
 
 
 tensor_operator_registry.register("__getitem__", _tensor_getitem)
@@ -286,7 +308,7 @@ def _scalar_to_tensor(input_x):
 @_primexpr
 def _check_scalar_tensor_args(args):
     """For the item, check that the index of the scalar tensor is set."""
-    if args != (None,) and args != ():
+    if args not in ((None,), ()):
         const_utils.raise_value_error("For item, the index of scalar Tensor should not be set.")
 
 
@@ -295,15 +317,15 @@ def tensor_item(data, *args):
     # transform a.item(tuple(int)) -> a.item(int1,int2...intN)
     if data.ndim == 0:
         _check_scalar_tensor_args(args)
-        return data
+        return data.asnumpy().item()
     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 data[0]
-        const_utils.raise_value_error("Can only convert an array of size 1 to a Tensor scalar")
+            return data.asnumpy().item()
+        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")
@@ -362,7 +384,8 @@ def tensor_itemset_by_tuple_with_number(data, tuple_index, nubmer_value):
         exp_msg = const_utils.gen_exception_msg(
             "Tuple index len({}) is not same to tensor dimension({})", len(tuple_index), data.ndim)
         const_utils.raise_index_error(exp_msg)
-    return tensor_setitem_by_tuple_with_number(data, tuple_index, nubmer_value)
+    nubmer_value = F.cast(nubmer_value, F.dtype(data))
+    return tensor_itemset_by_tuple_with_tensor(data, tuple_index, nubmer_value)
 
 
 def _broadcast(broadcast_shape, x):
@@ -530,10 +553,6 @@ class _TensorIndexGetitem(base.TensorIndexGetitem_):
         Type is the same as the element type of data.
     """
 
-    def __init__(self, name):
-        """Initialize _TensorIndexGetitem."""
-        base.TensorIndexGetitem_.__init__(self, name)
-
     def __call__(self, *args):
         pass
 
@@ -580,9 +599,12 @@ def _tensor_index_by_bool(data, bool_value):
     """Tensor getitem by a single bool value"""
     min_data_dim, max_data_dim = 0, 7
     const_utils.judge_data_dim(data.ndim, min_data_dim, max_data_dim)
+    output = data
     if bool_value:
-        return F.expand_dims(data, 0)
-    return const_utils.raise_index_error("When tensor is indexed by a bool object, the value only support 'True'.")
+        output = F.expand_dims(data, 0)
+    elif not F.is_sequence_value_unknown(F.shape(data)):
+        return const_utils.raise_index_error("When tensor is indexed by a bool object, the value only support 'True'.")
+    return output
 
 
 def get_stride_info_from_integer(tensor_int):
@@ -599,15 +621,14 @@ def get_stride_info_from_integer(tensor_int):
 def _tensor_index_by_integer(data, int_index):
     """Tensor getitem by a single integer number"""
     data_shape = F.shape(data)
-    if not data_shape:
-        const_utils.raise_type_error("Cannot iterate over a scalar tensor.")
-    if data.ndim < 1 or data.ndim > 8:
-        const_utils.raise_value_error("Expect Tensor to have dimension between 1 and 8.")
-
     if F.is_sequence_value_unknown(data_shape) or not F.isconstant(int_index):
         tensor_index = _scalar_to_tensor(int_index)
         begin_strides, end_strides, step_strides = get_stride_info_from_integer(tensor_index)
     else:
+        if not data_shape:
+            const_utils.raise_type_error("Cannot iterate over a scalar tensor.")
+        if data.ndim < 1 or data.ndim > 8:
+            const_utils.raise_value_error("Expect Tensor to have dimension between 1 and 8.")
         transformed_number = const_utils.check_range(int_index, data_shape[0])
         begin_strides, end_strides, step_strides = \
             const_utils.get_stride_info_from_integer(data_shape, transformed_number)
@@ -619,7 +640,6 @@ def _tensor_index_by_integer(data, int_index):
         end_mask += 2 ** i
     return strided_slice(data, begin_strides, end_strides, step_strides, begin_mask, end_mask, 0, 0, shrink_axis_mask)
 
-
 def _check_dim_shape_valid(data, tensor_index):
     """check dim and shape of tensor_index for tensor(bool) indexing"""
     if data.ndim < tensor_index.ndim:
@@ -632,7 +652,8 @@ def _check_dim_shape_valid(data, tensor_index):
 
 def tensor_index_by_bool_tensor(data, tensor_index):
     """Tensor getitem by a bool tensor"""
-    _check_dim_shape_valid(data, tensor_index)
+    if not F.is_sequence_value_unknown(F.shape(data)):
+        _check_dim_shape_valid(data, tensor_index)
     tensor_index = tensor_index.nonzero()
     return F.gather_nd(data, tensor_index)
 
@@ -640,7 +661,8 @@ def tensor_index_by_bool_tensor(data, tensor_index):
 def tensor_index_by_tensor(data, tensor_index):
     """Tensor getitem by a single tensor"""
     min_data_dim, max_data_dim = 0, 7
-    const_utils.judge_data_dim(data.ndim, min_data_dim, max_data_dim)
+    if not F.is_sequence_value_unknown(F.shape(data)):
+        const_utils.judge_data_dim(data.ndim, min_data_dim, max_data_dim)
     if const_utils.check_type_isinstance(F.dtype(tensor_index), mstype.Int):
         return F.gather(data, tensor_index, 0)
     if const_utils.check_type_isinstance(F.dtype(tensor_index), mstype.Bool):
@@ -658,16 +680,22 @@ def tensor_index_by_list(data, list_index):
 
     data_shape = F.shape(data)
     indexes_types = hyper_map(toptypeof, list_index)
-    if const_utils.check_type_isinstance(indexes_types, (mstype.Bool, mstype.Int)):
+    if const_utils.check_type_isinstance(indexes_types, (mstype.Bool, mstype.Int)) \
+            and not F.is_sequence_value_unknown(list_index):
         if not F.isconstant(data_shape[0]):
             if all(isinstance(i, bool) for i in list_index):
-                const_utils.raise_unimplemented_error(
-                    "Not supported to the dynamic shape tensor slice by using list of Boolean type")
+                if F.dyn_shape(data)[0] != len(list_index):
+                    raise IndexError(
+                        f'dimension is {F.dyn_shape(data)[0]} but corresponding boolean dimension is {len(list_index)}')
+                tensor_index = Tensor(list_index).nonzero()
+                return F.gather_nd(data, tensor_index)
             tensor_index = const_utils.sequence_to_index(list_index, None)
         else:
-            tensor_index = const_utils.sequence_to_index(list_index, data_shape[0])
+            tensor_index = const_utils.sequence_to_index(
+                list_index, data_shape[0])
         if tensor_index is False:
-            const_utils.raise_index_error("When tensor is indexed by list, the list can't be empty.")
+            const_utils.raise_index_error(
+                "When tensor is indexed by list, the list can't be empty.")
         return F.gather(data, tensor_index, 0)
 
     tuple_index_new = ()
@@ -693,6 +721,29 @@ def judge_tuple_index_dim_check_error(index_dim, data_dim):
                          f"dim of index:{index_dim}, dim of data:{data_dim}")
 
 
+class _HandleEmptySlice(base.HandleEmptySlice_):
+    """
+    Getting item of Tensor.
+
+    Args:
+        data (Tensor): A tuple to be sliced.
+        index: Index of tensor.
+
+    Returns:
+        Type is the same as the element type of data.
+    """
+
+    def __init__(self, name):
+        """Initialize _HandleEmptySlice."""
+        base.HandleEmptySlice_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+_handle_empty_slice = _HandleEmptySlice('handle_zero_tuple_index')
+
+
 def judge_tuple_index_dim(data, tuple_index):
     """Judge whether tuple_index's dim is valid"""
     data_dim = data.ndim
@@ -700,29 +751,55 @@ def judge_tuple_index_dim(data, tuple_index):
     for index in tuple_index:
         if isinstance(toptypeof(index), mstype.TensorType) and index.dtype == mstype.bool_:
             index_dim += index.ndim
-        else:
+        elif not isinstance(toptypeof(index), (mstype.NoneType, mstype.Ellipsis_, mstype.Bool)):
             index_dim += 1
     judge_tuple_index_dim_check_error(index_dim, data_dim)
 
 
+def judge_simple_tuple_index(data, tuple_index):
+    """Judge whether tuple_index is simple index, which not rollback to cpu ops."""
+    op_name = const_utils.TENSOR_GETITEM
+    indexes_types = hyper_map(toptypeof, tuple_index)
+    contain_type = const_utils.tuple_index_type_cnt(indexes_types, op_name)
+    return F.isconstant(tuple_index) and contain_type == const_utils.ALL_BASIC \
+        and F.is_sequence_value_unknown(F.shape(data)) and F.isconstant(F.rank(data))
+
+
 def tensor_index_by_tuple(data, tuple_index):
     """Tensor getitem by tuple of various types with None"""
     if not tuple_index:
         return data
-
-    tuple_index = convert_tupleslice_to_tensor(tuple_index)
-    op_name = const_utils.TENSOR_GETITEM
-    tuple_index = _transform_ellipsis_to_slice(data, tuple_index, op_name)
-    data, tuple_index = _expand_data_dims(data, tuple_index)
-
-    min_data_dim, max_data_dim = 1, 8
-    const_utils.judge_data_dim(data.ndim, min_data_dim, max_data_dim)
-    judge_tuple_index_dim(data, tuple_index)
-    indexes_types = hyper_map(toptypeof, tuple_index)
-    contain_type = const_utils.tuple_index_type_cnt(indexes_types, op_name)
-    if contain_type == const_utils.ALL_BASIC:
+    if judge_simple_tuple_index(data, tuple_index):
+        tuple_index = convert_tupleslice_to_tensor(tuple_index)
+        op_name = const_utils.TENSOR_GETITEM
+        tuple_index = _transform_ellipsis_to_slice(data, tuple_index, op_name)
+        min_data_dim, max_data_dim = 1, 8
+        const_utils.judge_data_dim(data.ndim, min_data_dim, max_data_dim)
         return _tensor_getitem_by_tuple_slice(data, tuple_index)
-    return _tensor_getitem_by_tuple(data, tuple_index, op_name)
+
+    if not F.is_sequence_value_unknown(F.shape(data)):
+        judge_tuple_index_dim(data, tuple_index)
+    tuple_index, zero_index, non_zero_shapes = _handle_bool_tensor(tuple_index)
+    for non_zero_shape in non_zero_shapes:
+        if F.reduce_min(non_zero_shape) == 0:
+            tuple_index = zero_index
+            break
+    if not F.is_sequence_value_unknown(F.shape(data)) and F.isconstant(tuple_index):
+        _, stub_zero_dim_tensor = _handle_empty_slice(data, tuple_index)
+        if 0 in stub_zero_dim_tensor.shape:
+            return F.fill(data.dtype, stub_zero_dim_tensor.shape, 0)
+    has_tensor_index = False
+    for i in tuple_index:
+        if isinstance(i, Tensor):
+            has_tensor_index = True
+            break
+    empty_broadcast_data_shape = False
+    _broadcast_data_shape = _handle_scalar_tensor_index(data, tuple_index)
+    if has_tensor_index and isinstance(_broadcast_data_shape, Tensor) and _broadcast_data_shape == Tensor([0]):
+        empty_broadcast_data_shape = True
+    if has_tensor_index and isinstance(_broadcast_data_shape, tuple) and not _broadcast_data_shape:
+        empty_broadcast_data_shape = True
+    return _tensor_index_getitem(data, tuple_index, empty_broadcast_data_shape)
 
 
 def get_slice_stride(slice_index, dim_size):
@@ -1039,7 +1116,7 @@ def sequence_to_tensor(value, dtype):
 
     if value_elements_type == const_utils.ALL_TENSOR:
         value = F.stack(value).astype(dtype)
-    elif value_elements_type == const_utils.NO_TENSOR:
+    elif value_elements_type == const_utils.NO_TENSOR and not F.is_sequence_value_unknown(value):
         value = const_utils.make_tensor(value, dtype)
     else:
         new_value = ()
@@ -1061,7 +1138,7 @@ def _generate_updates_from_sequence(data, index, value, op_type):
 def _generate_updates_from_tensor(data, index, value, op_type):
     """Generate an updates tensor from a tensor."""
     value = value.astype(data.dtype)
-    if F.is_sequence_value_unknown(F.shape(data)):
+    if F.is_sequence_value_unknown(F.shape(data)) or F.is_sequence_value_unknown(F.shape(index)):
         data_shape = F.dyn_shape(data)
         index_shape = F.dyn_shape(index)
         updates_shape = const_utils.generate_updates_shape(data_shape, index_shape, op_type, True)
@@ -1102,6 +1179,18 @@ def tensor_setitem_by_number(self, index, value):
     return tensor_setitem_by_number_with_sequence(self, index, value)
 
 
+def _tuple_index_transfer(broadcast_shape, final_shape, new_shape, x, all_empty_tensor):
+    """Transform tuple index tensor to the required."""
+    if isinstance(broadcast_shape, Tensor):
+        if not all_empty_tensor:
+            x = F.broadcast_to(x, broadcast_shape)
+        x = F.reshape(x, new_shape)
+        x = F.broadcast_to(x, final_shape)
+        return x
+    item = _broadcast(broadcast_shape, x)
+    return _broadcast(final_shape, F.reshape(item, new_shape))
+
+
 class _TensorIndexSetitem(base.TensorIndexSetitem_):
     """
     Getting item of Tensor.
@@ -1114,10 +1203,6 @@ class _TensorIndexSetitem(base.TensorIndexSetitem_):
         Type is the same as the element type of data.
     """
 
-    def __init__(self, name):
-        """Initialize _TensorIndexGetitem."""
-        base.TensorIndexSetitem_.__init__(self, name)
-
     def __call__(self, *args):
         pass
 
@@ -1184,13 +1269,12 @@ def tensor_setitem_by_tensor_with_tensor(data, index, value_tensor):
         return _tensor_setitem_by_int_tensor_with_tensor(data, index, value_tensor)
 
     if F.is_sequence_value_unknown(F.shape(data)):
-        const_utils.raise_unimplemented_error(
-            "Not supported to the dynamic shape tensor slice by using tensor of Boolean type")
+        return tensor_setitem_by_tuple_with_tensor(data, (index,), value_tensor.astype(data.dtype))
     return _tensor_setitem_by_bool_tensor_with_tensor(data, index, value_tensor)
 
 
 def tensor_setitem_by_tensor_with_number(data, index, value):
-    value = F.fill(F.dtype(data), (), value)
+    value = F.cast(value, F.dtype(data))
     return tensor_setitem_by_tensor_with_tensor(data, index, value)
 
 
@@ -1221,13 +1305,13 @@ def _tensor_setitem_by_bool_tensor_with_sequence(data, index, value):
 
 def tensor_setitem_by_slice_with_number(data, input_slice, value):
     """Givens a scalar assign to tensor by slice"""
-    value = F.fill(F.dtype(data), (), value)
+    value = F.cast(value, F.dtype(data))
     return tensor_setitem_by_slice_with_tensor(data, input_slice, value)
 
 
 def tensor_setitem_by_tuple_with_number(data, tuple_index, value):
     """Assigns the tensor by tuple with number value."""
-    value = F.fill(F.dtype(data), (), value)
+    value = F.cast(value, F.dtype(data))
     return tensor_setitem_by_tuple_with_tensor(data, tuple_index, value)
 
 
@@ -1305,7 +1389,123 @@ def tensor_copy_slice_from_tuple(data, tuple_index, value):
     return copy_slice(data, value.astype(data.dtype), start_tensor, stop_tensor, step_tensor)
 
 
+class _PreSetitemByTuple(base.PreSetitemByTuple_):
+    """
+    Getting item of Tensor.
+
+    Args:
+        data (Tensor): A tuple to be sliced.
+        index: Index of tensor.
+
+    Returns:
+        Type is the same as the element type of data.
+    """
+
+    def __init__(self, name):
+        """Initialize _PreSetitemByTuple."""
+        base.PreSetitemByTuple_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+_pre_setitem_by_tuple = _PreSetitemByTuple('pre_setitem_by_tuple')
+
+
+class _HandleBoolTensor(base.HandleBoolTensor_):
+    """
+    Getting item of Tensor.
+
+    Args:
+        data (Tensor): A tuple to be sliced.
+        index: Index of tensor.
+
+    Returns:
+        Type is the same as the element type of data.
+    """
+
+    def __init__(self, name):
+        """Initialize _HandleBoolTensor."""
+        base.HandleBoolTensor_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+_handle_bool_tensor = _HandleBoolTensor('handle_bool_tensor')
+
+
+class _HandleScalarTensorIndex(base.HandleScalarTensorIndex_):
+    """
+    Getting item of Tensor.
+
+    Args:
+        data (Tensor): A tuple to be sliced.
+        index: Index of tensor.
+
+    Returns:
+        Type is the same as the element type of data.
+    """
+
+    def __init__(self, name):
+        """Initialize _HandleBoolTensor."""
+        base.HandleScalarTensorIndex_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+_handle_scalar_tensor_index = _HandleScalarTensorIndex('handle_scalar_tensor_index')
+
+
 def tensor_setitem_by_tuple_with_tensor(data, tuple_index, value):
+    """Assigns the tensor by tuple with tensor value."""
+    if const_utils.use_copy_slice(tuple_index) and not const_utils.is_ascend():
+        if F.is_sequence_value_unknown(F.shape(data)):
+            return tensor_copy_slice_from_tuple(data, tuple_index, value)
+        dim1_start, dim1_stop, _ = const_utils.normalize_slice(
+            tuple_index[1], data.shape[1])
+        if dim1_stop - dim1_start <= 0:
+            return data
+        dim0_start = tuple_index[0] if tuple_index[0] >= 0 else tuple_index[0] + data.shape[0]
+        start = (dim0_start, dim1_start)
+        stop = (dim0_start + 1, dim1_stop)
+        step = (1, 1)
+        value_shape = (dim1_stop - dim1_start,) + \
+            const_utils.tuple_slice(data.shape, 2, None)
+        value = _broadcast(value_shape, value)
+        return copy_slice(data, value.astype(data.dtype), start, stop, step)
+    tuple_index, _, non_zero_shapes = _handle_bool_tensor(tuple_index)
+
+    for non_zero_shape in non_zero_shapes:
+        if F.reduce_min(non_zero_shape) == 0:
+            return data
+    value = value.astype(data.dtype)
+    special_index, tuple_index, new_value_shape, idx_advanced, _broadcast_data_shape \
+        = _pre_setitem_by_tuple(data, tuple_index, value)
+    if special_index == 0:
+        return data
+    value = F.reshape(value, new_value_shape)
+    if not tuple_index or special_index == 1:
+        data[True] = value
+        return data
+
+    empty_broadcast_data_shape = False
+    if isinstance(_broadcast_data_shape, Tensor) and _broadcast_data_shape == Tensor([0]):
+        empty_broadcast_data_shape = True
+    if isinstance(_broadcast_data_shape, tuple) and not _broadcast_data_shape:
+        empty_broadcast_data_shape = True
+    indices = _tensor_index_setitem(
+        data, tuple_index, value, idx_advanced, empty_broadcast_data_shape)
+
+    updates = _generate_updates_from_tensor(
+        data, indices, value, const_utils.SET_ITEM_BY_TUPLE_OF_TENSOR)
+    if is_parameter(data):
+        F.scatter_nd_update(data, indices, updates)
+        return data
+    return F.tensor_scatter_update(data, indices, updates)
+
+def tensor_itemset_by_tuple_with_tensor(data, tuple_index, value):
     """Assigns the tensor by tuple with tensor value."""
     op_name = const_utils.TENSOR_SETITEM
     tuple_index = _transform_ellipsis_to_slice(data, tuple_index, op_name)
@@ -1323,7 +1523,6 @@ def tensor_setitem_by_tuple_with_tensor(data, tuple_index, value):
         value_shape = (dim1_stop - dim1_start,) + const_utils.tuple_slice(data.shape, 2, None)
         value = _broadcast(value_shape, value)
         return copy_slice(data, value.astype(data.dtype), start, stop, step)
-
     tuple_index, value, idx_advanced = remove_expanded_dims(tuple_index, F.shape(data), value)
 
     if tuple_index is False:
@@ -1351,7 +1550,7 @@ def tensor_setitem_by_tuple_with_sequence(data, tuple_index, value):
 
 def tensor_setitem_by_number_with_number(data, index, value):
     """Assigns the tensor by number with number value."""
-    value = F.fill(F.dtype(data), (), value)
+    value = F.cast(value, F.dtype(data))
     return tensor_setitem_by_number_with_tensor(data, index, value)
 
 
@@ -1386,7 +1585,7 @@ def tensor_setitem_by_ellipsis_with_number(data, value):
     data_shape = F.shape(data)
     data_dtype = F.dtype(data)
     if F.is_sequence_value_unknown(data_shape):
-        value = F.fill(F.dtype(data), (), value)
+        value = F.cast(value, F.dtype(data))
         return tensor_setitem_by_ellipsis_with_tensor(data, value)
     return F.fill(data_dtype, data_shape, value)
 
@@ -1418,6 +1617,7 @@ def tensor_setitem_by_ellipsis_with_sequence(data, value):
 def tensor_setitem_by_bool(data, index, value):
     """Assigns a value to the tensor by boolean."""
     data_shape = F.shape(data)
+    data_dtype = F.dtype(data)
     if not index:
         data_shape = (0,) + data_shape
     if isinstance(value, (list, tuple)):
@@ -1429,6 +1629,7 @@ def tensor_setitem_by_bool(data, index, value):
 
     if F.is_sequence_value_unknown(data_shape) and index:
         data_shape = F.dyn_shape(data)
+        value = value.astype(data_dtype)
         data = ops.broadcast_to(value, data_shape)
         return data
     value_shape = F.shape(value)
@@ -1436,7 +1637,7 @@ def tensor_setitem_by_bool(data, index, value):
     if index:
         value = F.reshape(value, source_shape)
         value = _broadcast(data_shape, value)
-        data = value
+        data = F.cast(value, data_dtype)
     return data
 
 

mindspore/ops/composite/multitype_ops/_constexpr_utils.py

@@ -398,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)])))
@@ -543,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):
@@ -844,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}')
@@ -865,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)
@@ -877,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