mindspore 2.0.0rc1__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
@@ -32,6 +33,8 @@ from mindspore.common import Tensor, CSRTensor, COOTensor
 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()
@@ -42,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):
@@ -65,16 +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
-    kRaiseIndexError = 21
+    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):
@@ -82,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:
@@ -98,13 +113,19 @@ def data_update(transfer_types, args, data, new_index, value=None):
             return data
         if transfer_type == ValueTransferType.kEmptyTensor:
             return handle_empty_tensor(arg, data)
+        if transfer_type == ValueTransferType.kFormatIndexTensor:
+            new_index = format_index_tensor(new_index, arg)
+        if transfer_type == ValueTransferType.kGetitemByBoolTensor:
+            return F.gather_nd(data, new_index.nonzero())
+        if transfer_type == ValueTransferType.kSetitemByBoolTensor:
+            return handle_setitem_by_bool_tensor(data, new_index, value)
         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):
+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.
@@ -125,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
@@ -144,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:
@@ -182,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)
@@ -273,17 +305,27 @@ def _scalar_to_tensor(input_x):
     return ops.add(input_x, mutable(Tensor(0)))
 
 
+@_primexpr
+def _check_scalar_tensor_args(args):
+    """For the item, check that the index of the scalar tensor is set."""
+    if args not in ((None,), ()):
+        const_utils.raise_value_error("For item, the index of scalar Tensor should not be set.")
+
+
 def tensor_item(data, *args):
     """Tensor getitem by index whose dtype is int or tuple with int."""
     # transform a.item(tuple(int)) -> a.item(int1,int2...intN)
+    if data.ndim == 0:
+        _check_scalar_tensor_args(args)
+        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")
@@ -342,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):
@@ -429,12 +472,39 @@ def handle_multi_dim_index_tensor(new_index, arg):
     return new_index
 
 
+def format_index_tensor(index, arg):
+    """Format index tensor when tensor less than 0"""
+    format_indices, format_dims = arg
+    if isinstance(index, list):
+        for format_idx, format_dim in zip(format_indices, format_dims):
+            index_tensor = index[format_idx]
+            index[format_idx] = F.select(index_tensor < 0, index_tensor + format_dim, index_tensor)
+        return index
+    index = Tensor(index)
+    return F.select(index < 0, index + format_dims, index)
+
+
+def handle_setitem_by_bool_tensor(data, index, value):
+    """Set a tensor item by a bool tensor with a tensor."""
+    value = F.cast(value, F.dtype(data))
+    indices = index.nonzero()
+    if indices.shape[0] == 0:
+        return data
+    value_shape = (indices.shape[0],) + data.shape[index.ndim:]
+    value = _broadcast(value_shape, value)
+    value = F.scatter_nd(indices, value, data.shape)
+    index = index.reshape(const_utils.generate_padding_shape(index.shape, len(data.shape)))
+    index = _broadcast(data.shape, index)
+    result = F.select(index, value, data)
+    return result
+
+
 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)
     expand_positions, tuple_index_new = (), ()
     for i, (index, index_type) in enumerate(zip(tuple_index, indexes_types)):
-        if isinstance(index_type, mstype.none_type):
+        if isinstance(index_type, mstype.NoneType):
             tuple_index_new += (const_utils.make_empty_slice(),)
             expand_positions += (i,)
         elif isinstance(index_type, mstype.Bool):
@@ -471,29 +541,27 @@ def convert_variable_to_tensor_slice(slice_index):
     return slice_index
 
 
+class _TensorIndexGetitem(base.TensorIndexGetitem_):
+    """
+    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 __call__(self, *args):
+        pass
+
+_tensor_index_getitem = _TensorIndexGetitem('tensor_index_getitem')
+
+
 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)
-    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))
-    if is_dynamic:
-        begin_strides, end_strides, step_strides = get_stride_info_from_slice(data, slice_index)
-    else:
-        begin_strides, end_strides, step_strides = const_utils.get_stride_info_from_slice(data_shape, slice_index)
-    begin_mask = 1 if slice_get_item(slice_index, "start") is None else 0
-    end_mask = 1 if slice_get_item(slice_index, "stop") is None else 0
-    for i in range(1, len(data_shape)):
-        begin_mask += 2 ** i
-        end_mask += 2 ** i
-    if begin_mask or end_mask:
-        return strided_slice(data, begin_strides, end_strides, step_strides, begin_mask, end_mask, 0, 0, 0)
-    return F.strided_slice(data, begin_strides, end_strides, step_strides)
+    return _tensor_index_getitem(data, slice_index)
 
 
 def get_stride_info_from_slice(data, slice_index):
@@ -531,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):
@@ -550,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)
@@ -570,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:
@@ -583,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)
 
@@ -591,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):
@@ -609,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 = ()
@@ -637,23 +714,92 @@ def convert_tupleslice_to_tensor(tuple_index):
     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
+def judge_tuple_index_dim_check_error(index_dim, data_dim):
+    """raise IndexError when tuple_index's dim is invalid"""
+    if index_dim > data_dim:
+        raise IndexError(f"The dim of index cannot be greater than indexed data, but got "
+                         f"dim of index:{index_dim}, dim of data:{data_dim}")
 
-    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)
+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
+    index_dim = 0
+    for index in tuple_index:
+        if isinstance(toptypeof(index), mstype.TensorType) and index.dtype == mstype.bool_:
+            index_dim += index.ndim
+        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)
-    if contain_type == const_utils.ALL_BASIC:
+    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
+    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):
@@ -895,6 +1041,15 @@ def _generate_indices_from_tuple_of_tensor(tuple_index, op_name):
     return indices
 
 
+def parse_check_slice_index(index_out, dim_size):
+    """ Parse and check slice index """
+    has_false = False
+    start, stop, step = const_utils.normalize_slice(index_out, dim_size)
+    if F.isconstant(start) and F.isconstant(stop) and F.isconstant(step):
+        has_false = const_utils.check_slice_empty(start, stop, step)
+    return has_false
+
+
 def _generate_indices_from_tuple(data, tuple_index, op_name, fancy_position):
     """Generate an indices tensor from a tuple that contains slice, int, ellipsis, tensor."""
     data_shape = F.shape(data)
@@ -925,8 +1080,7 @@ def _generate_indices_from_tuple(data, tuple_index, op_name, fancy_position):
             tuple_index_new += (tensor_index,)
             tensor_indexes.append(tensor_index)
         elif i in slice_positions:
-            start, stop, step = const_utils.normalize_slice(index, dim_size)
-            if const_utils.check_slice_empty(start, stop, step):
+            if parse_check_slice_index(index, dim_size):
                 return False
             slice_ele_list_index = const_utils.transform_slice_to_ele_list(index, dim_size)
             slice_shapes += (len(slice_ele_list_index),)
@@ -962,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 = ()
@@ -984,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)
@@ -1025,13 +1179,49 @@ 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.
+
+    Args:
+        data (Tensor): A tuple to be sliced.
+        index: Index of tensor.
+
+    Returns:
+        Type is the same as the element type of data.
+    """
+
+    def __call__(self, *args):
+        pass
+
+
+_tensor_index_setitem = _TensorIndexSetitem('tensor_index_setitem')
+
+
 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):
-        return tensor_setitem_by_slice_with_tensor(self, index, value)
-    return tensor_setitem_by_slice_with_sequence(self, index, value)
+    """Set a tensor item by slice."""
+    indices, value_shape, start, stop, step, value = _tensor_index_setitem(
+        self, index, value)
+    if start == stop:
+        return self
+    value = F.broadcast_to(value, value_shape)
+    if not const_utils.is_ascend() and step == 1:
+        if isinstance(step, Tensor):
+            return copy_slice(self, value, start, stop, step)
+        return copy_slice(self, value, (start,), (stop,), (step,))
+    return F.tensor_scatter_update(self, indices, value)
 
 
 def tensor_setitem_by_ellipsis(self, index, value):
@@ -1049,8 +1239,6 @@ def _tensor_setitem_by_int_tensor_with_tensor(data, index, value):
     updates = _generate_updates_from_tensor(data, index, value, const_utils.SET_ITEM_BY_ONE_TENSOR)
     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:
@@ -1081,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)
 
 
@@ -1118,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)
 
 
@@ -1202,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)
@@ -1220,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:
@@ -1248,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)
 
 
@@ -1283,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)
 
@@ -1315,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)):
@@ -1326,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)
@@ -1333,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
 
 
@@ -1417,8 +1721,8 @@ def remove_expanded_dims(tuple_index, data_shape, value):
         elif const_utils.is_slice(index_out):
             indices_out += (index_out,)
             not_expanded_dim += (True,)
-            start, stop, step = const_utils.normalize_slice(index_out, data_shape[cur_dim])
-            has_false = has_false or const_utils.check_slice_empty(start, stop, step)
+            has_false = has_false or parse_check_slice_index(
+                index_out, data_shape[cur_dim])
             cur_dim += 1
         elif isinstance(index_out, (Tensor, bool)):  # advanced index
             if idx_advanced == -1:
@@ -1490,7 +1794,7 @@ def reduce_(a, reduce_fn, cmp_fn=None, axis=None, keepdims=False, initial=None,
     ndim = F.rank(a)
     if dtype is None:
         dtype = F.dtype(a)
-    axes = const_utils.check_axis_valid_const(axis, ndim)
+    axes = validator.check_axis_valid(axis, ndim)
     if initial is not None:
         if ((isinstance(initial, Tensor) and F.rank(initial) > 0) or
                 not isinstance(initial, (int, float, bool, Tensor))):
@@ -1505,18 +1809,20 @@ def reduce_(a, reduce_fn, cmp_fn=None, axis=None, keepdims=False, initial=None,
             initial = F.fill(dtype, shape, initial)
         a = cmp_fn(a, initial)
 
-    if isinstance(where, Tensor):
+    if where is not None and not isinstance(where, Tensor):
+        where = Tensor(where, dtype=mstype.bool_)
+
+    if where is not None and (where.shape or not where):
         if initial is None:
             const_utils.raise_value_error('initial value must be provided for where masks')
         ndim_orig = F.rank(a)
         # broadcasts input tensors
         shape_out = const_utils.infer_out_shape(F.shape(where), F.shape(a), F.shape(initial))
-        broadcast_to = P.BroadcastTo(shape_out)
         where = where.astype(mstype.float32)
-        where = broadcast_to(where)
+        where = F.broadcast_to(where, shape_out)
         where = where.astype(mstype.bool_)
-        a = broadcast_to(a)
-        initial = broadcast_to(initial)
+        a = F.broadcast_to(a, shape_out)
+        initial = F.broadcast_to(initial, shape_out)
         a = F.select(where, a, initial)
         axes = const_utils.real_axes(ndim_orig, F.rank(a), axes)