mindspore 1.10.0__cp39-cp39-win_amd64.whl → 2.0.0rc1__cp39-cp39-win_amd64.whl

mindspore/ops/composite/multitype_ops/_compile_utils.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2021 Huawei Technologies Co., Ltd
+# Copyright 2020-2023 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,24 +15,32 @@
 
 """constexpr util"""
 from __future__ import absolute_import
+from enum import IntEnum
+
 
 from mindspore.ops.composite.multitype_ops import _constexpr_utils as const_utils
 from mindspore.ops import functional as F
-from mindspore.ops  import operations as P
+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, DynamicBroadcastTo, TopTypeof
+from mindspore.ops.operations._inner_ops import TensorCopySlices, SliceGetItem, \
+    TopTypeof, issubclass_, IsParameter, GetitemTensorIndexInfo, SetitemTensorIndexInfo
 from mindspore.common import dtype as mstype
 from mindspore.common._register_for_tensor import tensor_operator_registry
-from mindspore.common.tensor import Tensor, CSRTensor, COOTensor
-from mindspore.common._utils import is_shape_unknown
+from mindspore.common.initializer import Zero
+from mindspore.common import Tensor, CSRTensor, COOTensor
+from mindspore.common import mutable
+from mindspore import ops
+from mindspore.ops.primitive import _primexpr
 
 slice_get_item = SliceGetItem()
 hyper_map = base.HyperMap()
 stack = P.Stack(axis=-1)
 copy_slice = TensorCopySlices()
-dynamic_broadcast_to = DynamicBroadcastTo()
 toptypeof = TopTypeof()
+is_parameter = IsParameter()
+getitem_tensor_index_info = GetitemTensorIndexInfo(const_utils.is_ascend())
+setitem_tensor_index_info = SetitemTensorIndexInfo(const_utils.is_ascend())
 
 
 def strided_slice(data, begin_strides, end_strides, step_strides, begin_mask=0, end_mask=0, ellipsis_mask=0,
@@ -43,50 +51,138 @@ def strided_slice(data, begin_strides, end_strides, step_strides, begin_mask=0,
     return strided_slice_(data, begin_strides, end_strides, step_strides)
 
 
+class ValueTransferType(IntEnum):
+    """Transfer op types of handling tensor getitem/setitem"""
+    kUnknown = 0
+    kTensorScatterUpdate = 1
+    kExpandDims = 2
+    kBroadCast = 3
+    kCast = 4
+    kSelect = 5
+    kGather = 6
+    kStrideSlice = 7
+    kStrideSliceWithMask = 8
+    kGatherND = 9
+    kScatterNdUpdate = 10
+    kReshape = 11
+    kScatterND = 12
+    kNumberToTensor = 13
+    kHandleSequenceValue = 14
+    kByPass = 15
+    kReSetItemByIndex = 16
+    kCopySlice = 17
+    kSetItemByBool = 18
+    kEmptyTensor = 19
+    kSetItemByEllipsis = 20
+    kRaiseIndexError = 21
+
+
+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.
+    """
+    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)
+        if transfer_type == ValueTransferType.kSetItemByBool:
+            return tensor_setitem_by_bool(data, new_index, value)
+        if transfer_type == ValueTransferType.kCopySlice:
+            return copy_slice(data, value.astype(data.dtype), arg[0], arg[1], arg[2])
+        if transfer_type == ValueTransferType.kSetItemByEllipsis:
+            return tensor_setitem_by_ellipsis(data, new_index, value)
+        if transfer_type == ValueTransferType.kReSetItemByIndex:
+            data[new_index] = value
+            return data
+        if transfer_type == ValueTransferType.kEmptyTensor:
+            return handle_empty_tensor(arg, data)
+        if transfer_type == ValueTransferType.kRaiseIndexError:
+            raise IndexError(
+                f'index {arg[0]} is out of bounds for dimension with size {arg[1]}')
+    return data
+
+
+def data_update_by_ops(transfer_type, arg, data, new_index, value=None):
+    """
+    Generate a new tensor when handling tensor getitem/setitem
+    by ops.
+    """
+    if transfer_type == ValueTransferType.kStrideSliceWithMask:
+        stride_info, mask_index = arg[0], arg[1]
+        data = strided_slice(data, stride_info[0], stride_info[1], stride_info[2],
+                             mask_index[0], mask_index[1], 0, 0, mask_index[2])
+    elif transfer_type == ValueTransferType.kGatherND:
+        if isinstance(new_index, list):
+            new_index = handle_multi_dim_index_tensor(new_index, arg)
+        data = F.gather_nd(data, Tensor(new_index))
+    elif transfer_type == ValueTransferType.kTensorScatterUpdate:
+        if isinstance(new_index, list):
+            new_index = handle_multi_dim_index_tensor(new_index, arg)
+        data = F.tensor_scatter_update(data, new_index, value)
+    elif transfer_type == ValueTransferType.kScatterNdUpdate:
+        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.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.kStrideSlice:
+        data = F.strided_slice(data, arg[0], arg[1], arg[2])
+    else:
+        raise IndexError(f"Inlvaid transfer type {transfer_type}.")
+    return data
+
+
+def value_update(transfer_types, args, data, value):
+    """Transfer value before set value to tensor when handling tensor setitem"""
+    for transfer_type, arg in zip(transfer_types, args):
+        if transfer_type == ValueTransferType.kByPass:
+            continue
+        if transfer_type == ValueTransferType.kNumberToTensor:
+            value = F.fill(F.dtype(data), (), value)
+        elif transfer_type == ValueTransferType.kHandleSequenceValue:
+            op_type, index = arg
+            if op_type == const_utils.SET_ITEM_BY_ONE_TENSOR:
+                index = Tensor(index)
+            value = _generate_updates_from_sequence(
+                data, index, value, op_type)
+        elif transfer_type == ValueTransferType.kExpandDims:
+            value = F.expand_dims(value, arg)
+        elif transfer_type == ValueTransferType.kBroadCast:
+            value = _broadcast(arg, value.astype(F.dtype(data)))
+        elif transfer_type == ValueTransferType.kCast:
+            value = F.cast(value, F.dtype(data))
+        elif transfer_type == ValueTransferType.kReshape:
+            value = F.reshape(value, arg)
+        elif transfer_type == ValueTransferType.kScatterND:
+            value = F.scatter_nd(arg[0], value, arg[1])
+        else:
+            raise IndexError(f"Inlvaid transfer type {transfer_type}.")
+    return value
+
+
 def _tensor_getitem(self, index):
     """Handle tensor getitem"""
-    if isinstance(index, Tensor):
-        return tensor_index_by_tensor(self, index)
-    if isinstance(index, list):
-        return tensor_index_by_list(self, index)
-    if isinstance(index, tuple):
-        return tensor_index_by_tuple(self, index)
-    if isinstance(index, bool):
-        return _tensor_index_by_bool(self, index)
-    if isinstance(index, int):
-        return _tensor_index_by_integer(self, index)
-    if isinstance(index, slice):
-        return tensor_index_by_slice(self, index)
-    if index is None:
-        return F.expand_dims(self, 0)
-    if index is ...:
-        return self
-    raise IndexError(f"Only support integers, slices(`:`), ellipsis(`...`), None, bool, tensor with int, "
-                     f"list and tuple ,but got {index} with type {type(index)}.")
+    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):
     """Handle tensor setitem"""
-    if not isinstance(value, (int, float, bool, list, tuple, Tensor)):
-        raise ValueError(f"only support numbers, Tensor, tuple, list as value,"
-                         f"but got {value} with type {type(value)}.")
-    if isinstance(index, list):
-        index = format_list_indices(index, F.shape(self)[0])
-    if isinstance(index, Tensor):
-        return tensor_setitem_by_tensor(self, index, value)
-    if isinstance(index, tuple):
-        return tensor_setitem_by_tuple(self, index, value)
-    if isinstance(index, bool):
-        return tensor_setitem_by_bool(self, index, value)
-    if isinstance(index, int):
-        return tensor_setitem_by_number(self, index, value)
-    if isinstance(index, slice):
-        return tensor_setitem_by_slice(self, index, value)
-    if index in (None, ...):
-        return tensor_setitem_by_ellipsis(self, index, value)
-
-    raise IndexError("Tensor setitem index only support integers, slices(`:`), ellipsis(`...`), bool, tensor, \
-        list and tuple, but got {index} with type{type(index)}")
+    setitem_info = setitem_tensor_index_info(self, index, value)
+    new_index = setitem_info[0]
+    v_transfer_types = setitem_info[1]
+    v_transfer_args = setitem_info[2]
+    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)
 
 
 tensor_operator_registry.register("__getitem__", _tensor_getitem)
@@ -119,6 +215,10 @@ def _tensor_mul(self, other):
     return F.mul(self, other)
 
 
+def _tensor_matmul(self, other):
+    return F.matmul(self, other)
+
+
 def _tensor_div(self, other):
     if isinstance(self, (tuple, list)):
         self = sequence_to_tensor(self, F.dtype(other))
@@ -158,6 +258,7 @@ def _tensor_floordiv(self, other):
 tensor_operator_registry.register('__add__', _tensor_add)
 tensor_operator_registry.register('__sub__', _tensor_sub)
 tensor_operator_registry.register('__mul__', _tensor_mul)
+tensor_operator_registry.register('__matmul__', _tensor_matmul)
 tensor_operator_registry.register('__truediv__', _tensor_div)
 tensor_operator_registry.register('__mod__', _tensor_mod)
 tensor_operator_registry.register('__pow__', _tensor_pow)
@@ -165,6 +266,13 @@ tensor_operator_registry.register('__rpow__', _tensor_rpow)
 tensor_operator_registry.register('__floordiv__', _tensor_floordiv)
 
 
+def _scalar_to_tensor(input_x):
+    if ops.isconstant(input_x):
+        return P.ScalarToTensor()(input_x, ops.dtype(input_x))
+    # use add Tensor([0]) cast scalar to tensor.
+    return ops.add(input_x, mutable(Tensor(0)))
+
+
 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)
@@ -239,13 +347,9 @@ def tensor_itemset_by_tuple_with_number(data, tuple_index, nubmer_value):
 
 def _broadcast(broadcast_shape, x):
     """Broadcast tensor to the required shape."""
-    if not const_utils.check_two_shapes_need_broadcast(broadcast_shape, F.shape(x)):
+    if F.shape(x) == broadcast_shape:
         return x
-    multiples = const_utils.compute_multiples(F.shape(x), broadcast_shape)
-    if multiples:
-        x = F.reshape(x, const_utils.expanded_shape(F.shape(x), len(multiples) - F.rank(x)))
-        return F.tile(x, multiples)
-    return x
+    return F.broadcast_to(x, broadcast_shape)
 
 
 def _transform_indexing_tensor(broadcast_shape, final_shape, new_shape, item):
@@ -285,6 +389,46 @@ def _transform_ellipsis_to_slice(data, tuple_index, op_name):
     return tuple_index_new
 
 
+def handle_empty_tensor(arg, data):
+    """handle data update with empty tensor"""
+    if 0 in arg:
+        init_func = Zero()
+        init_func.__enable_zero_dim__ = True
+        return Tensor(shape=arg, dtype=data.dtype, init=init_func)
+    return const_utils.make_tensor([], data.dtype, arg)
+
+
+def handle_multi_dim_index_tensor(new_index, arg):
+    """handle data update with multi dim index tensor"""
+    slice_cnt = 0
+    new_indies_tensor = []
+    if len(arg) == 1:
+        broadcast_shape = arg[0]
+        new_index = hyper_map(F.partial(Tensor), new_index)
+        broadcast_tensors = hyper_map(
+            F.partial(_broadcast, broadcast_shape), new_index)
+        new_broadcast_tensors = ()
+        for tensor in broadcast_tensors:
+            new_broadcast_tensors += (F.cast(tensor, mstype.int64),)
+        new_index = stack(new_broadcast_tensors)
+        return new_index
+    broadcast_shape, final_shape, index_tensor_new_shape, slice_shapes, tensor_positions, fancy_position = arg
+    for i, index in enumerate(new_index):
+        if i in tensor_positions:
+            transform_tensor = _transform_indexing_tensor(broadcast_shape, final_shape, index_tensor_new_shape,
+                                                          Tensor(index))
+            new_indies_tensor.append(F.cast(transform_tensor, mstype.int64))
+        else:
+            shape = const_utils.compute_slice_shape(
+                slice_shapes, len(broadcast_shape), slice_cnt, fancy_position)
+            array = Tensor(index).reshape(shape)
+            slice_index_tensor = _broadcast(final_shape, array)
+            new_indies_tensor.append(F.cast(slice_index_tensor, mstype.int64))
+            slice_cnt += 1
+    new_index = stack(new_indies_tensor)
+    return new_index
+
+
 def _expand_data_dims(data, tuple_index):
     """expand the data's dim with 'None' and 'Boolean' in tuple_index"""
     indexes_types = hyper_map(toptypeof, tuple_index)
@@ -307,12 +451,34 @@ def _expand_data_dims(data, tuple_index):
     return data, tuple_index_new
 
 
+def convert_variable_to_tensor_slice(slice_index):
+    """convert mutable scalar to tensor"""
+    start = slice_get_item(slice_index, "start")
+    stop = slice_get_item(slice_index, "stop")
+    step = slice_get_item(slice_index, "step")
+    find_mutable_scalar = False
+    if isinstance(start, int) and not F.isconstant(start):
+        start = ops.Cast()(start, mstype.int64)
+        find_mutable_scalar = True
+    if isinstance(stop, int) and not F.isconstant(stop):
+        stop = ops.Cast()(stop, mstype.int64)
+        find_mutable_scalar = True
+    if isinstance(step, int) and not F.isconstant(step):
+        step = ops.Cast()(step, mstype.int64)
+        find_mutable_scalar = True
+    if find_mutable_scalar:
+        return F.make_slice(start, stop, step)
+    return slice_index
+
+
 def tensor_index_by_slice(data, slice_index):
     """Tensor getitem by a slice."""
     min_data_dim, max_data_dim = 1, 8
     const_utils.judge_data_dim(data.ndim, min_data_dim, max_data_dim)
     data_shape = F.shape(data)
-    is_dynamic = (is_shape_unknown(data_shape)
+    slice_index = convert_variable_to_tensor_slice(slice_index)
+
+    is_dynamic = (F.is_sequence_value_unknown(data_shape)
                   or isinstance(slice_get_item(slice_index, "start"), Tensor)
                   or isinstance(slice_get_item(slice_index, "stop"), Tensor)
                   or isinstance(slice_get_item(slice_index, "step"), Tensor))
@@ -335,6 +501,12 @@ def get_stride_info_from_slice(data, slice_index):
     data_shape = F.dyn_shape(data)
     begin_strides, end_strides, step_strides = [], [], []
     start, stop, step = get_slice_stride(slice_index, data_shape[0])
+    if start.ndim > 0:
+        start = start.item()
+    if stop.ndim > 0:
+        stop = stop.item()
+    if step.ndim > 0:
+        step = step.item()
     begin_strides.append(start)
     end_strides.append(stop)
     step_strides.append(step)
@@ -364,19 +536,10 @@ def _tensor_index_by_bool(data, bool_value):
     return const_utils.raise_index_error("When tensor is indexed by a bool object, the value only support 'True'.")
 
 
-def check_range(x, dim_size):
-    """Check whether x is within the range of dim_size"""
-    tensor_x = const_utils.make_tensor(x)
-    if tensor_x >= dim_size or tensor_x < -dim_size:
-        return tensor_x
-    tensor_x = tensor_x % dim_size
-    return tensor_x
-
-
 def get_stride_info_from_integer(tensor_int):
     """Convert integer to slice"""
     begin_strides = [tensor_int]
-    end_strides = [tensor_int + const_utils.make_tensor(1)]
+    end_strides = [tensor_int + 1]
     step_strides = [const_utils.make_tensor(1)]
     begin_tensor = stack(begin_strides)
     end_tensor = stack(end_strides)
@@ -386,14 +549,15 @@ 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.")
 
-    data_shape = F.shape(data)
-    if is_shape_unknown(data_shape):
-        data_shape = F.dyn_shape(data)
-        transformed_tensor = check_range(int_index, data_shape[0])
-        begin_strides, end_strides, step_strides = get_stride_info_from_integer(transformed_tensor)
+    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:
         transformed_number = const_utils.check_range(int_index, data_shape[0])
         begin_strides, end_strides, step_strides = \
@@ -401,22 +565,41 @@ def _tensor_index_by_integer(data, int_index):
     shrink_axis_mask = 1
     begin_mask = 0
     end_mask = 0
-    for i in range(1, len(data_shape)):
+    for i in range(2, 8):
         begin_mask += 2 ** i
         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:
+        raise IndexError(f"The dim of index cannot be greater than indexed data, but got "
+                         f"dim of index:{tensor_index.ndim}, dim of data:{data.ndim}")
+    if data.shape[:tensor_index.ndim] != tensor_index.shape[:]:
+        raise IndexError(f"The shape of index {tensor_index.shape} does not match the shape "
+                         f"of the indexed data {data.shape}")
+
+
+def tensor_index_by_bool_tensor(data, tensor_index):
+    """Tensor getitem by a bool tensor"""
+    _check_dim_shape_valid(data, tensor_index)
+    tensor_index = tensor_index.nonzero()
+    return F.gather_nd(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)
-    valid = const_utils.check_type_isinstance(F.dtype(tensor_index), mstype.Int)
-    if valid is False:
-        exp_msg = const_utils.gen_exception_msg(
-            "The tensor index must be int type, but got {}.", F.dtype(tensor_index))
-        const_utils.raise_index_error(exp_msg)
-    return F.gather(data, tensor_index, 0)
+    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):
+        return tensor_index_by_bool_tensor(data, tensor_index)
+    exp_msg = const_utils.gen_exception_msg(
+        "The tensor index must be int or bool type, but got {}.", F.dtype(tensor_index))
+    const_utils.raise_index_error(exp_msg)
+    return data
 
 
 def tensor_index_by_list(data, list_index):
@@ -427,10 +610,13 @@ 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 data_shape[0] == -1 and 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")
-        tensor_index = const_utils.sequence_to_index(list_index, data_shape[0])
+        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")
+            tensor_index = const_utils.sequence_to_index(list_index, None)
+        else:
+            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.")
         return F.gather(data, tensor_index, 0)
@@ -441,18 +627,28 @@ def tensor_index_by_list(data, list_index):
     return tensor_index_by_tuple(data, tuple_index_new)
 
 
+def convert_tupleslice_to_tensor(tuple_index):
+    """convert mutable scalar in slice to tensor"""
+    new_tuple_index = []
+    for item in tuple_index:
+        if isinstance(item, slice):
+            item = convert_variable_to_tensor_slice(item)
+        new_tuple_index.append(item)
+    return tuple(new_tuple_index)
+
+
 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)
-
     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:
@@ -460,31 +656,6 @@ def tensor_index_by_tuple(data, tuple_index):
     return _tensor_getitem_by_tuple(data, tuple_index, op_name)
 
 
-def _tensor_getitem_by_tuple_of_tensor(data, tuple_index, op_name):
-    """Tensor getitem by a tuple of tensor."""
-    data_shape = F.shape(data)
-    tuple_index_len = len(tuple_index)
-
-    indexes_types = hyper_map(F.dtype, tuple_index)
-    const_utils.check_indexes_types_valid(indexes_types, mstype.int_type, op_name)
-    tensor_index_shape = hyper_map(F.shape, tuple_index)
-    broadcast_shape = const_utils.generate_broadcast_shape(tensor_index_shape, op_name)
-    if 0 in broadcast_shape:
-        res_shape = broadcast_shape
-        if tuple_index_len < len(data_shape):
-            res_shape += data_shape[tuple_index_len:]
-        res = const_utils.make_tensor([], data.dtype, res_shape)
-        return res
-
-    broadcast_tensors = hyper_map(F.partial(_broadcast, broadcast_shape), tuple_index)
-    new_broadcast_tensors = ()
-    for tensor in broadcast_tensors:
-        new_broadcast_tensors += (F.cast(tensor, mstype.int64),)
-    indices = stack(new_broadcast_tensors)
-    result = F.gather_nd(data, indices)
-    return result
-
-
 def get_slice_stride(slice_index, dim_size):
     """Get slice stride info"""
     start = slice_get_item(slice_index, "start")
@@ -498,13 +669,13 @@ def get_slice_stride(slice_index, dim_size):
     if step is None:
         step = const_utils.make_tensor(1)
 
-    if F.issubclass_(F.typeof(start), mstype.number):
+    if issubclass_(F.typeof(start), mstype.number):
         start = const_utils.make_tensor(start)
 
-    if F.issubclass_(F.typeof(stop), mstype.number):
+    if issubclass_(F.typeof(stop), mstype.number):
         stop = const_utils.make_tensor(stop)
 
-    if F.issubclass_(F.typeof(step), mstype.number):
+    if issubclass_(F.typeof(step), mstype.number):
         step = const_utils.make_tensor(step)
 
     return start, stop, step
@@ -543,7 +714,7 @@ def _get_stride_info_from_tuple(data, tuple_index):
             step_strides.append(step)
             index_count = index_count + 1
         elif isinstance(index, int):
-            int_tensor = check_range(index, dim_size)
+            int_tensor = _scalar_to_tensor(index)
             begin_strides.append(int_tensor)
             end_strides.append(int_tensor + const_utils.make_tensor(1))
             step_strides.append(const_utils.make_tensor(1))
@@ -577,7 +748,7 @@ def _get_stride_info_from_tuple(data, tuple_index):
 def _tensor_getitem_by_tuple_slice(data, tuple_index):
     """Tensor getitem by a tuple of slice"""
     data_shape = F.shape(data)
-    is_dynamic = is_shape_unknown(data_shape)
+    is_dynamic = F.is_sequence_value_unknown(data_shape)
     for item in tuple_index:
         if isinstance(item, slice):
             is_dynamic = is_dynamic or isinstance(slice_get_item(item, "start"), Tensor) \
@@ -599,6 +770,39 @@ def _tensor_getitem_by_tuple_slice(data, tuple_index):
     return strided_slice(data, begin_v, end_v, step_v, begin_mask, end_mask, 0, 0, shrink_axis_mask)
 
 
+@_primexpr
+def _tensor_getitem_by_tuple_parse_bool_tensor_index(index, tuple_index_new, tensor_indexes,
+                                                     tensor_positions_new):
+    """ parse index of bool tensor type """
+    indices = index.nonzero()
+    if indices.shape[0] == 0:
+        return None, tensor_indexes, tensor_positions_new
+    indices = F.cast(indices, mstype.int64)
+    indices = indices.T
+    for sub_index in indices:
+        tensor_positions_new.append(len(tuple_index_new))
+        tuple_index_new += (sub_index,)
+        tensor_indexes.append(sub_index)
+    return tuple_index_new, tensor_indexes, tensor_positions_new
+
+
+def _tensor_getitem_by_tuple_parse_tensor_index(index, tuple_index_new, tensor_indexes, tensor_positions_new):
+    """ parse index of tensor type """
+    if F.dtype(index) in mstype.int_type:
+        tensor_index = F.cast(index, mstype.int64)
+        tensor_positions_new.append(len(tuple_index_new))
+        tuple_index_new += (tensor_index,)
+        tensor_indexes.append(tensor_index)
+    elif F.dtype(index) == mstype.bool_:
+        return _tensor_getitem_by_tuple_parse_bool_tensor_index(index, tuple_index_new, tensor_indexes,
+                                                                tensor_positions_new)
+    else:
+        exp_msg = const_utils.gen_exception_msg(
+            "The tensor element in tuple index must be int or bool type, but got {}.", F.dtype(index))
+        const_utils.raise_index_error(exp_msg)
+    return tuple_index_new, tensor_indexes, tensor_positions_new
+
+
 def _tensor_getitem_by_tuple(data, tuple_index, op_name):
     """Tensor getitem by a tuple of mixed tensor."""
     slice_is_tensor = False
@@ -609,51 +813,49 @@ def _tensor_getitem_by_tuple(data, tuple_index, op_name):
                               or isinstance(slice_get_item(item, "step"), Tensor)
     if slice_is_tensor:
         const_utils.raise_index_error("Not supported when slice has tensor")
-    tuple_index_len = len(tuple_index)
-    tensor_indexes, slice_indexes = [], []
+
     indexes_types = hyper_map(toptypeof, tuple_index)
     slice_positions, _, _, int_positions, _, tensor_positions, sequence_positions = \
         const_utils.get_pos_of_indexes_types(indexes_types, op_name)
-    tuple_index_new, slice_shapes = (), ()
     data_shape = F.shape(data)
+    tensor_indexes, slice_indexes = [], []
+    tuple_index_new, slice_shapes = (), ()
+    slice_positions_new, tensor_positions_new = [], []
     for i, (index, dim_size) in enumerate(zip(tuple_index, data_shape)):
         if i in int_positions:
             int_index = const_utils.check_range(index, dim_size)
             tensor_index = F.scalar_to_tensor(int_index, mstype.int64)
-            if is_shape_unknown(data_shape):
-                dyn_shape = F.dyn_shape(data)
-                tensor_index = check_range(index, dyn_shape[i])
+            if F.is_sequence_value_unknown(data_shape):
+                tensor_index = _scalar_to_tensor(int_index)
                 tensor_index = F.cast(tensor_index, mstype.int64)
+            tensor_positions_new.append(len(tuple_index_new))
             tuple_index_new += (tensor_index,)
             tensor_indexes.append(tensor_index)
-            tensor_positions += (i,)
         elif i in sequence_positions:
             tensor_index = const_utils.sequence_to_index(index, dim_size)
             if tensor_index is False:
                 const_utils.raise_index_error("The sequence element(tuple/list) in tuple index can't be empty.")
+            tensor_positions_new.append(len(tuple_index_new))
             tuple_index_new += (tensor_index,)
             tensor_indexes.append(tensor_index)
-            tensor_positions += (i,)
         elif i in tensor_positions:
-            invalid = const_utils.check_type_invalid(F.dtype(index), mstype.int_type)
-            if invalid:
-                exp_msg = const_utils.gen_exception_msg(
-                    "The tensor element in tuple index must be int type, but got {}.", F.dtype(index))
-                const_utils.raise_index_error(exp_msg)
-            tensor_index = F.cast(index, mstype.int64)
-            tuple_index_new += (tensor_index,)
-            tensor_indexes.append(tensor_index)
+            tuple_index_new, tensor_indexes, tensor_positions_new = \
+                _tensor_getitem_by_tuple_parse_tensor_index(index, tuple_index_new,
+                                                            tensor_indexes, tensor_positions_new)
+            if tuple_index_new is None:
+                return Tensor([])
         elif i in slice_positions:
             slice_ele_list_index = const_utils.transform_slice_to_ele_list(index, dim_size)
             slice_shapes += (len(slice_ele_list_index),)
+            slice_positions_new.append(len(tuple_index_new))
             tuple_index_new += (slice_ele_list_index,)
             slice_indexes.append(slice_ele_list_index)
-
     tensor_indexes_shapes = hyper_map(F.shape, tensor_indexes)
     broadcast_shape, index_tensor_new_shape, final_shape, fancy_position = \
-        const_utils.generate_index_info_from_tuple_of_mixed_tensors(tensor_positions, tensor_indexes_shapes,
+        const_utils.generate_index_info_from_tuple_of_mixed_tensors(tensor_positions_new, tensor_indexes_shapes,
                                                                     slice_shapes, op_name)
 
+    tuple_index_len = len(tuple_index)
     if 0 in final_shape + data_shape:
         if tuple_index_len < len(data_shape):
             final_shape = final_shape + data_shape[tuple_index_len:]
@@ -662,11 +864,11 @@ def _tensor_getitem_by_tuple(data, tuple_index, op_name):
     final_index_tensors = []
     slice_cnt = 0
     for i, index in enumerate(tuple_index_new):
-        if i in tensor_positions:
+        if i in tensor_positions_new:
             transform_tensor = _transform_indexing_tensor(broadcast_shape, final_shape, index_tensor_new_shape,
                                                           index)
             final_index_tensors.append(transform_tensor)
-        elif i in slice_positions:
+        elif i in slice_positions_new:
             slice_index_tensor = convert_slice_to_tensor(index, final_shape, slice_cnt, broadcast_shape,
                                                          slice_shapes, fancy_position)
             final_index_tensors.append(slice_index_tensor)
@@ -701,7 +903,6 @@ def _generate_indices_from_tuple(data, tuple_index, op_name, fancy_position):
     slice_positions, _, _, int_positions, _, tensor_positions, sequence_positions = \
         const_utils.get_pos_of_indexes_types(indexes_types, op_name)
     tuple_index_new, slice_shapes = (), ()
-
     for i, (index, dim_size) in enumerate(zip(tuple_index, data_shape)):
         if i in int_positions:
             int_index = const_utils.check_range(index, dim_size)
@@ -718,7 +919,7 @@ def _generate_indices_from_tuple(data, tuple_index, op_name, fancy_position):
             invalid = const_utils.check_type_invalid(F.dtype(index), mstype.int_type)
             if invalid:
                 exp_msg = const_utils.gen_exception_msg(
-                    "The tensor element in tuple index must be int type, but got {}.", F.dtype(index))
+                    "The tensor element in tuple index must be int or bool type, but got {}.", F.dtype(index))
                 const_utils.raise_index_error(exp_msg)
             tensor_index = F.cast(index, mstype.int64)
             tuple_index_new += (tensor_index,)
@@ -783,11 +984,11 @@ 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 is_shape_unknown(F.shape(data)):
+    if F.is_sequence_value_unknown(F.shape(data)):
         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)
-        updates = dynamic_broadcast_to(value, updates_shape)
+        updates = ops.broadcast_to(value, updates_shape)
         return updates
     updates_shape = const_utils.generate_updates_shape(data.shape, index.shape, op_type, False)
     need_broadcast = const_utils.check_two_shapes_need_broadcast(updates_shape, value.shape)
@@ -807,6 +1008,7 @@ def tensor_setitem_by_tensor(self, index, value):
 
 
 def tensor_setitem_by_tuple(self, index, value):
+    index = convert_tupleslice_to_tensor(index)
     if isinstance(value, (int, float, bool)):
         index = format_tuple_indices(index)
         return tensor_setitem_by_tuple_with_number(self, index, value)
@@ -824,6 +1026,7 @@ def tensor_setitem_by_number(self, index, value):
 
 
 def tensor_setitem_by_slice(self, index, value):
+    index = convert_variable_to_tensor_slice(index)
     if isinstance(value, (int, float, bool)):
         return tensor_setitem_by_slice_with_number(self, index, value)
     if isinstance(value, Tensor):
@@ -844,28 +1047,29 @@ def _tensor_setitem_by_int_tensor_with_tensor(data, index, value):
     if F.rank(index) == 0:
         index = F.expand_dims(index, -1)
     updates = _generate_updates_from_tensor(data, index, value, const_utils.SET_ITEM_BY_ONE_TENSOR)
-    index = F.select(index < 0, index + F.shape(data)[0], index)
+    data_shape = F.shape(data)
+    first_val = data_shape[0]
+    if not F.isconstant(first_val):
+        first_val = -1
+    index = F.select(index < 0, index + first_val, index)
     index = F.expand_dims(index, -1)
     if F.rank(index) < 2:
         index = F.expand_dims(index, 0)
         updates = F.expand_dims(updates, 0)
+    if is_parameter(data):
+        F.scatter_nd_update(data, index, updates)
+        return data
     return F.tensor_scatter_update(data, index, updates)
 
 
 def _tensor_setitem_by_bool_tensor_with_tensor(data, index, value):
     """Set a tensor item by a bool tensor with a tensor."""
-    index_shape = F.shape(index)
-    data_shape = F.shape(data)
-    const_utils.check_equal(data_shape, index_shape,
-                            "The tensor(shape={}) and tensor index(shape={}) should be the same shape.")
-    size = F.shape_mul(F.shape(value))
-    const_utils.check_equal(1, size,
-                            "When assign value is a tensor, its size should be {}, but current size is {}.")
-    dtype = F.dtype(data)
-    u_cast = F.cast(value, dtype)
-    one_data = F.ones_like(data)
-    u = F.tensor_mul(one_data, u_cast)
-    result = F.select(index, u, data)
+    index = index.reshape(const_utils.generate_padding_shape(index.shape, len(data.shape)))
+    index = F.broadcast_to(index, data.shape)
+    value = F.cast(value, F.dtype(data))
+    value = value.reshape(const_utils.generate_padding_shape(value.shape, len(data.shape)))
+    value = F.broadcast_to(value, data.shape)
+    result = F.select(index, value, data)
     return result
 
 
@@ -876,7 +1080,7 @@ def tensor_setitem_by_tensor_with_tensor(data, index, value_tensor):
     if tensor_dtype == const_utils.INT_:
         return _tensor_setitem_by_int_tensor_with_tensor(data, index, value_tensor)
 
-    if is_shape_unknown(F.shape(data)):
+    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_bool_tensor_with_tensor(data, index, value_tensor)
@@ -890,11 +1094,13 @@ def tensor_setitem_by_tensor_with_number(data, index, value):
 def tensor_setitem_by_tensor_with_sequence(data, index, value):
     """Assigns the tensor by tensor with tuple value."""
     index_dtype = F.dtype(index)
-    invalid = const_utils.check_type_invalid(index_dtype, (mstype.int32, mstype.int64))
-    if invalid:
-        exp_msg = const_utils.gen_exception_msg("The tensor index must be int type, but got {}.", index_dtype)
-        const_utils.raise_index_error(exp_msg)
-    return _tensor_setitem_by_tensor_with_sequence(data, index, value)
+    if index_dtype in (mstype.int32, mstype.int64):
+        return _tensor_setitem_by_tensor_with_sequence(data, index, value)
+    if index_dtype == mstype.bool_:
+        return _tensor_setitem_by_bool_tensor_with_sequence(data, index, value)
+    exp_msg = const_utils.gen_exception_msg("The tensor index must be int or bool type, but got {}.", index_dtype)
+    const_utils.raise_index_error(exp_msg)
+    return None
 
 
 def _tensor_setitem_by_tensor_with_sequence(data, index, value):
@@ -904,6 +1110,12 @@ def _tensor_setitem_by_tensor_with_sequence(data, index, value):
     return F.tensor_scatter_update(data, index, updates)
 
 
+def _tensor_setitem_by_bool_tensor_with_sequence(data, index, value):
+    """Set a tensor item by a bool tensor with a tuple."""
+    value = sequence_to_tensor(value, F.dtype(data))
+    return _tensor_setitem_by_bool_tensor_with_tensor(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)
@@ -929,7 +1141,7 @@ def tensor_copy_slice_from_slice(data, input_slice, value):
     if dim0_size >= data_shape[0]:
         dim0_size = data_shape[0:1]
     value_shape = P.Concat(-1)((dim0_size, data_shape[1:]))
-    value = dynamic_broadcast_to(value, value_shape)
+    value = ops.broadcast_to(value, value_shape)
     return copy_slice(data, value.astype(data.dtype), start_tensor, stop_tensor, step_tensor)
 
 
@@ -941,7 +1153,7 @@ def tensor_setitem_by_slice_with_tensor(data, input_slice, value):
         data_shape = F.shape(data)
         step = const_utils.get_step_from_slice(input_slice)
         if step == 1 and not const_utils.is_ascend():
-            if is_shape_unknown(data_shape):
+            if F.is_sequence_value_unknown(data_shape):
                 return tensor_copy_slice_from_slice(data, input_slice, value)
             start, stop, step = const_utils.normalize_slice(input_slice, data.shape[0])
             dim0_size = stop - start
@@ -950,7 +1162,7 @@ def tensor_setitem_by_slice_with_tensor(data, input_slice, value):
             value_shape = (dim0_size,) + const_utils.tuple_slice(data.shape, 1, None)
             value = _broadcast(value_shape, value)
             return copy_slice(data, value.astype(data.dtype), (start,), (stop,), (step,))
-        if is_shape_unknown(data_shape):
+        if F.is_sequence_value_unknown(data_shape):
             const_utils.raise_unimplemented_error(
                 "Not supported to take the subscript of dynamic shape tensor slice setitem")
         indices = const_utils.slice2indices(input_slice, data_shape)
@@ -974,7 +1186,7 @@ def tensor_copy_slice_from_tuple(data, tuple_index, value):
     dim1_start, dim1_stop, _ = get_slice_stride(tuple_index[1], data_shape[1])
     if dim1_stop - dim1_start <= 0:
         return data
-    dim0_start = check_range(tuple_index[0], data_shape[0])
+    dim0_start = _scalar_to_tensor(tuple_index[0])
     dim0_stop = dim0_start + const_utils.make_tensor(1)
     start = (dim0_start, dim1_start)
     stop = (dim0_stop, dim1_stop)
@@ -986,7 +1198,7 @@ def tensor_copy_slice_from_tuple(data, tuple_index, value):
     if dim1_size > data_shape[1]:
         dim1_size = data_shape[1:2]
     value_shape = P.Concat(-1)((dim1_size, data_shape[2:]))
-    value = dynamic_broadcast_to(value, value_shape)
+    value = ops.broadcast_to(value, value_shape)
     return copy_slice(data, value.astype(data.dtype), start_tensor, stop_tensor, step_tensor)
 
 
@@ -996,7 +1208,7 @@ def tensor_setitem_by_tuple_with_tensor(data, tuple_index, value):
     tuple_index = _transform_ellipsis_to_slice(data, tuple_index, op_name)
 
     if const_utils.use_copy_slice(tuple_index) and not const_utils.is_ascend():
-        if is_shape_unknown(F.shape(data)):
+        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:
@@ -1016,7 +1228,6 @@ def tensor_setitem_by_tuple_with_tensor(data, tuple_index, value):
     if len(tuple_index) == 1:
         data[tuple_index[0]] = value
         return data
-
     indexes_types = hyper_map(toptypeof, tuple_index)
     contain_type = const_utils.tuple_index_type_cnt(indexes_types, op_name)
 
@@ -1050,14 +1261,20 @@ def tensor_setitem_by_number_with_sequence(data, index, value):
 def tensor_setitem_by_number_with_tensor(data, index, value):
     """Assigns the tensor by number with tensor value."""
     data_shape = F.shape(data)
-    if is_shape_unknown(data_shape):
-        index = check_range(index, F.dyn_shape(data)[0])
+    if F.is_sequence_value_unknown(data_shape):
+        index = _scalar_to_tensor(index)
         index = F.expand_dims(index, -1)
         return _tensor_setitem_by_int_tensor_with_tensor(data, index, value)
 
+    dim_size = data_shape[0]
+    if index < -dim_size or index >= dim_size:
+        raise IndexError(f'index {index} is out of bounds for axis 0 with size {dim_size}')
     index = const_utils.int_to_index(index, data_shape)
     value_shape = const_utils.tuple_slice(F.shape(index), None, -1)
     value = _broadcast(value_shape, value.astype(F.dtype(data)))
+    if is_parameter(data):
+        F.scatter_nd_update(data, index, value)
+        return data
     return F.tensor_scatter_update(data, index, value)
 
 
@@ -1065,7 +1282,7 @@ def tensor_setitem_by_ellipsis_with_number(data, value):
     """Assigns the tensor by ellipsis with number value."""
     data_shape = F.shape(data)
     data_dtype = F.dtype(data)
-    if is_shape_unknown(data_shape):
+    if F.is_sequence_value_unknown(data_shape):
         value = F.fill(F.dtype(data), (), value)
         return tensor_setitem_by_ellipsis_with_tensor(data, value)
     return F.fill(data_dtype, data_shape, value)
@@ -1077,9 +1294,9 @@ def tensor_setitem_by_ellipsis_with_tensor(data, value):
     data_dtype = F.dtype(data)
     value = value.astype(data_dtype)
 
-    if is_shape_unknown(data_shape):
+    if F.is_sequence_value_unknown(data_shape):
         data_shape = F.dyn_shape(data)
-        data = dynamic_broadcast_to(value, data_shape)
+        data = ops.broadcast_to(value, data_shape)
         return data
     value_shape = F.shape(value)
     source_shape = const_utils.get_source_shape(data_shape, value_shape)
@@ -1107,9 +1324,9 @@ def tensor_setitem_by_bool(data, index, value):
     elif isinstance(value, float):
         value = const_utils.make_tensor(value, mstype.float32)
 
-    if is_shape_unknown(data_shape) and index:
+    if F.is_sequence_value_unknown(data_shape) and index:
         data_shape = F.dyn_shape(data)
-        data = dynamic_broadcast_to(value, data_shape)
+        data = ops.broadcast_to(value, data_shape)
         return data
     value_shape = F.shape(value)
     source_shape = const_utils.get_source_shape(data_shape, value_shape)
@@ -1135,6 +1352,8 @@ def format_list_indices(list_indices, length):
     # If eyery element in list is bool, it's treated as 1-D bool tensor.
     # If every element in list is int(not all bool), it's treated as int tensor.
     if const_utils.judge_indexes_types(indices_types, mstype.int_type + (mstype.bool_,)):
+        if not F.isconstant(length):
+            return const_utils.sequence_to_index(list_indices, None)
         return const_utils.sequence_to_index(list_indices, length)
     # If list contains other types(.../list/tuple/None), it's treated as a tuple
     return const_utils.deep_tuple(list_indices)
@@ -1154,11 +1373,34 @@ def format_tuple_indices(tuple_indices):
     return res
 
 
+@_primexpr
+def remove_expanded_dims_parse_bool_tensor_index(index_out, indices_out, shapes, cur_dim):
+    """ Parse bool tensor index """
+    index_out = index_out.nonzero()
+    if index_out.shape[0] == 0:
+        return None, shapes, cur_dim
+    for i in range(index_out.shape[1]):
+        out = index_out[:, i]
+        indices_out += (out,)
+        shapes.append(F.shape(out))
+        cur_dim += 1
+    return indices_out, shapes, cur_dim
+
+
+def remove_expanded_dims_parse_tensor_index(index_out, indices_out, shapes, cur_dim):
+    """ Parse tensor index """
+    if index_out.dtype == mstype.bool_:
+        return remove_expanded_dims_parse_bool_tensor_index(index_out, indices_out, shapes, cur_dim)
+    indices_out += (index_out,)
+    shapes.append(F.shape(index_out))
+    cur_dim += 1
+    return indices_out, shapes, cur_dim
+
+
 def remove_expanded_dims(tuple_index, data_shape, value):
     """Removes expanded dimensions in tuple_index and value."""
-    op_name = const_utils.TENSOR_SETITEM
     not_expanded_dim = ()
-    shapes = ()
+    shapes = []
     has_true = False
     has_false = False
     has_sequence = False
@@ -1185,17 +1427,18 @@ def remove_expanded_dims(tuple_index, data_shape, value):
                 idx_advanced = 0
             idx_tensor = i
             if isinstance(index_out, Tensor):
-                if F.rank(index_out) > 0:
+                indices_out, shapes, cur_dim = \
+                    remove_expanded_dims_parse_tensor_index(index_out, indices_out, shapes, cur_dim)
+                if indices_out is None:
+                    return False, value, 0
+                if index_out.dtype != mstype.bool_ and F.rank(index_out) > 0:
                     has_sequence = True
-                indices_out += (index_out,)
-                shapes += (F.shape(index_out),)
-                cur_dim += 1
             has_true = has_true or index_out is True
             has_false = has_false or index_out is False
         else:
             const_utils.raise_index_error('invalid index type')
 
-    broadcast_shape = const_utils.generate_broadcast_shape(shapes, op_name)
+    broadcast_shape = const_utils.generate_broadcast_shape(shapes, const_utils.TENSOR_SETITEM)
     if has_false:
         if F.shape_mul(broadcast_shape) != 1:
             const_utils.raise_index_error('unable to broadcast indices')
@@ -1222,11 +1465,21 @@ def format_index(idx, data_shape, cur_dim):
     elif isinstance(idx, int) and not isinstance(idx, bool):
         idx = const_utils.make_tensor(idx, mstype.int64, None, data_shape[cur_dim])
     elif isinstance(idx, Tensor):
-        # does not take bool tensor into account since it's currently not supported
-        idx = F.select(idx < 0, idx + data_shape[cur_dim], idx)
+        tensor_dtype = const_utils.get_index_tensor_dtype(idx.dtype)
+        if tensor_dtype == const_utils.INT_:
+            idx = F.select(idx < 0, idx + data_shape[cur_dim], idx)
+        elif tensor_dtype == const_utils.BOOL_:
+            # index with tensor(bool) type is processed in remove_expanded_dims()
+            pass
     return idx
 
 
+@_primexpr
+def _check_shape_mul(shape):
+    if F.shape_mul(shape) == 0:
+        raise ValueError('zero-size tensors are not supported.')
+
+
 def reduce_(a, reduce_fn, cmp_fn=None, axis=None, keepdims=False, initial=None, where=True, dtype=None):
     """
     Applies comparison based on cmp_fn and reduction based on reduce_fn.
@@ -1243,8 +1496,7 @@ def reduce_(a, reduce_fn, cmp_fn=None, axis=None, keepdims=False, initial=None,
                 not isinstance(initial, (int, float, bool, Tensor))):
             const_utils.raise_type_error('initial must be scalar')
 
-    if F.shape_mul(shape) == 0:
-        const_utils.raise_value_error('zero-size tensors are not supported.')
+    _check_shape_mul(shape)
 
     if initial is not None:
         if isinstance(initial, Tensor):