mindspore 2.7.0rc1__cp310-cp310-win_amd64.whl → 2.7.1__cp310-cp310-win_amd64.whl

mindspore/ops/communication.py

@@ -0,0 +1,97 @@
+# Copyright 2025 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""comm_func"""
+from ..ops.function.comm_func import (
+    TCPStore,
+    init_process_group,
+    destroy_process_group,
+    get_rank,
+    get_world_size,
+    new_group,
+    get_backend,
+    get_global_rank,
+    get_process_group_ranks,
+    get_group_rank,
+    all_reduce,
+    all_gather_into_tensor,
+    all_gather_into_tensor_uneven,
+    all_to_all,
+    all_to_all_single,
+    reduce_scatter_tensor,
+    reduce_scatter_tensor_uneven,
+    isend,
+    irecv,
+    send,
+    recv,
+    barrier,
+    broadcast,
+    reduce,
+    P2POp,
+    batch_isend_irecv,
+    gather,
+    scatter,
+    all_gather,
+    reduce_scatter,
+    all_gather_object,
+    broadcast_object_list,
+    gather_object,
+    scatter_object_list,
+    is_available,
+    is_initialized,
+    set_comm_ops_inplace,
+    all_to_all_v_c,
+)
+
+__all__ = [
+    "TCPStore",
+    "init_process_group",
+    "destroy_process_group",
+    "get_rank",
+    "get_world_size",
+    "new_group",
+    "get_backend",
+    "get_global_rank",
+    "get_process_group_ranks",
+    "get_group_rank",
+    "all_reduce",
+    "all_gather_into_tensor",
+    "all_gather_into_tensor_uneven",
+    "all_to_all",
+    "all_to_all_single",
+    "reduce_scatter_tensor",
+    "reduce_scatter_tensor_uneven",
+    "isend",
+    "irecv",
+    "send",
+    "recv",
+    "gather",
+    "scatter",
+    "all_gather",
+    "reduce_scatter",
+    "barrier",
+    "broadcast",
+    "reduce",
+    "P2POp",
+    "batch_isend_irecv",
+    "all_gather_object",
+    "broadcast_object_list",
+    "gather_object",
+    "scatter_object_list",
+    "is_available",
+    "is_initialized",
+    "set_comm_ops_inplace",
+    'all_to_all_v_c',
+]

mindspore/ops/composite/__init__.py

@@ -21,7 +21,7 @@ Pre-defined combination of operators.
 
 from __future__ import absolute_import
 from mindspore.ops.composite.base import GradOperation, _Grad, HyperMap, Map, MultitypeFuncGraph, add_flags, \
-    tail, zip_operation, _Vmap, _TaylorOperation, iter_converter, ms_hasnext, ms_next
+    tail, zip_operation, _Vmap, _TaylorOperation, iter_converter, ms_hasnext, ms_next, recompute_block
 from mindspore.ops.composite.env_ops import env_get
 from mindspore.ops.function.clip_func import clip_by_global_norm
 from mindspore.ops.composite.multitype_ops.add_impl import hyper_add
@@ -30,6 +30,7 @@ from mindspore.ops.composite.multitype_ops.sub_impl import augassign_sub
 from mindspore.ops.composite.multitype_ops.mul_impl import augassign_mul
 from mindspore.ops.composite.multitype_ops.div_impl import augassign_div
 from mindspore.ops.composite.multitype_ops.floordiv_impl import augassign_floordiv
+from mindspore.ops.composite.multitype_ops.mod_impl import augassign_mod
 from mindspore.ops.composite.multitype_ops.ones_like_impl import ones_like, _ones_like_for_grad
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
 from mindspore.ops.function.random_func import normal, laplace, uniform, gamma, poisson, multinomial
@@ -54,6 +55,7 @@ __all__ = [
     'augassign_mul',
     'augassign_div',
     'augassign_floordiv',
+    'augassign_mod',
     'zeros_like',
     'ones_like',
     '_ones_like_for_grad',
@@ -79,4 +81,5 @@ __all__ = [
     '_Vmap',
     'iter_converter',
     'ms_hasnext',
-    'ms_next']
+    'ms_next',
+    'recompute_block']

mindspore/ops/composite/base.py

@@ -31,7 +31,7 @@ from mindspore._c_expression import GradOperation_, HyperMap_, Map_, MultitypeFu
     SequenceSliceGetItem_, ListSliceSetItem_, VmapOperation_, TaylorOperation_, ListPop_, \
     ListClear_, ListReverse_, ListExtend_, DictClear_, DictHasKey_, DictUpdate_, DictFromKeys_, \
     ZerosLike_, TensorIndexGetitem_, TensorIndexSetitem_, ListAdd_, DictSetItem_, \
-    HandleBoolTensor_, PreSetitemByTuple_, StarredGetItem_, \
+    HandleBoolTensor_, PreSetitemByTuple_, StarredGetItem_, RecomputeBlock_, \
     StarredUnpack_, StarredUnpackMerge_, IterConverter_, HasNext_, Next_, MSContext
 from mindspore.common import dtype as mstype
 from mindspore.common.api import jit, _pynative_executor, _wrap_func
@@ -782,7 +782,7 @@ class MultitypeFuncGraph(MultitypeFuncGraph_):
         if len(self.entries) == 1:
             output = self.entries[0][1](*args)
             return output
-        types = tuple(map(mstype.get_py_obj_dtype, args))
+        types = tuple(map(mstype._get_py_obj_dtype, args))  # pylint:disable=protected-access
         for sigs, fn in self.entries:
             if len(sigs) != len(types):
                 continue
@@ -1315,3 +1315,17 @@ class _Next(Next_):
 
 ms_next = _Next('next')
 """`ms_next` will get next element and res elements for input"""
+
+
+class _RecomputeBlock(RecomputeBlock_):
+    """Set the block to be recomputed"""
+
+    def __init__(self, name):
+        """Initialize RecomputeBlock_."""
+        RecomputeBlock_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+recompute_block = _RecomputeBlock("recompute_block")

mindspore/ops/composite/multitype_ops/__init__.py

@@ -50,6 +50,7 @@ from mindspore.ops.composite.multitype_ops.sub_impl import augassign_sub
 from mindspore.ops.composite.multitype_ops.mul_impl import augassign_mul
 from mindspore.ops.composite.multitype_ops.div_impl import augassign_div
 from mindspore.ops.composite.multitype_ops.floordiv_impl import augassign_floordiv
+from mindspore.ops.composite.multitype_ops.mod_impl import augassign_mod
 
 __all__ = [
     'add',
@@ -87,5 +88,6 @@ __all__ = [
     'augassign_sub',
     'augassign_mul',
     'augassign_div',
-    'augassign_floordiv'
+    'augassign_floordiv',
+    'augassign_mod'
 ]

mindspore/ops/composite/multitype_ops/_compile_utils.py

@@ -344,6 +344,152 @@ def _process_multi_dim_index(self, indexes, remain_indexes, indexed_dims):
     return self_viewed, remain_indexes, need_index_prim
 
 
+def _get_need_index_prim(index, need_index_prim):
+    if isinstance(index, bool):
+        need_index_prim = True
+    elif isinstance(index, Tensor):
+        if F.rank(index) == 0 and index.dtype in mstype.int_type + mstype.uint_type + (mstype.bool_,):
+            if index.dtype not in mstype.int_type + mstype.uint_type:
+                need_index_prim = True
+        else:
+            need_index_prim = True
+    return need_index_prim
+
+
+def _process_with_inplace_index_input(prev_result, orig_tensor, index, dim, dim_index, remain_indexes, orig_dim, value):
+    """Process dim in multi dim index"""
+    result = prev_result
+    if isinstance(index, bool):
+        result = expand_dims_view_op(prev_result, dim)
+        index_for_bool = tensor_1d if index else empty_tensor_1d
+        remain_indexes = remain_indexes[0:dim] + (empty_tensor_9d,) * (dim - len(remain_indexes)) + (index_for_bool,)
+        inplace_index_put_op(result, remain_indexes, value, False)
+    elif isinstance(index, int):
+        result = _do_select(prev_result, dim, index, dim_index, F.shape(orig_tensor)[orig_dim])
+        inplace_index_put_op(result, remain_indexes, value, False)
+    elif isinstance(index, slice):
+        result = _do_slice(prev_result, dim, index, F.shape(orig_tensor)[orig_dim])
+        inplace_index_put_op(result, remain_indexes, value, False)
+    elif isinstance(index, EllipsisType):
+        inplace_index_put_op(result, remain_indexes, value, False)
+    elif index is None:
+        result = expand_dims_view_op(prev_result, dim)
+        inplace_index_put_op(result, remain_indexes, value, False)
+    elif isinstance(index, Tensor):
+        result = prev_result
+        if F.rank(index) == 0 and index.dtype in mstype.int_type + mstype.uint_type + (mstype.bool_,):
+            if index.dtype in mstype.int_type + mstype.uint_type:
+                index_py = TensorToScalar()(index)
+                dim_size = F.shape(orig_tensor)[orig_dim]
+                if index_py >= dim_size or index_py < -dim_size:
+                    raise IndexError("Index is out of bounds.")
+                new_index = (index_py + dim_size) % dim_size
+                result = select_ext_view_op(prev_result, dim, new_index)
+                # in graph mode, remain_indexes in different branch requires same size, so we fill empty tensor to it
+                remain_indexes = remain_indexes[0:dim] + (empty_tensor_9d,) * (dim - len(remain_indexes) + 1)
+                inplace_index_put_op(result, remain_indexes, value, False)
+            else:
+                # process index with Tensor bool type
+                result = expand_dims_view_op(prev_result, dim)
+                index_for_bool = tensor_1d if index else empty_tensor_1d
+                remain_indexes = remain_indexes[0:dim] + (empty_tensor_9d,) * (dim - len(remain_indexes)) + \
+                                 (index_for_bool,)
+                inplace_index_put_op(result, remain_indexes, value, False)
+        else:
+            remain_indexes = remain_indexes[0:dim] + (empty_tensor_9d,) * (dim - len(remain_indexes)) + (index,)
+            inplace_index_put_op(result, remain_indexes, value, False)
+    else:
+        raise IndexError("Invalid tensor index type")
+    return orig_tensor
+
+
+def _process_with_do_copy(prev_result, orig_tensor, index, dim, dim_index, remain_indexes, orig_dim, value):
+    """Process dim in multi dim index"""
+    result = prev_result
+    if isinstance(index, bool):
+        result = expand_dims_view_op(prev_result, dim)
+        index_for_bool = tensor_1d if index else empty_tensor_1d
+        remain_indexes = remain_indexes[0:dim] + (empty_tensor_9d,) * (dim - len(remain_indexes)) + (index_for_bool,)
+        do_copy(result, value)
+    elif isinstance(index, int):
+        result = _do_select(prev_result, dim, index, dim_index, F.shape(orig_tensor)[orig_dim])
+        do_copy(result, value)
+    elif isinstance(index, slice):
+        result = _do_slice(prev_result, dim, index, F.shape(orig_tensor)[orig_dim])
+        do_copy(result, value)
+    elif isinstance(index, EllipsisType):
+        do_copy(result, value)
+    elif index is None:
+        result = expand_dims_view_op(prev_result, dim)
+        do_copy(result, value)
+    elif isinstance(index, Tensor):
+        result = prev_result
+        if F.rank(index) == 0 and index.dtype in mstype.int_type + mstype.uint_type + (mstype.bool_,):
+            if index.dtype in mstype.int_type + mstype.uint_type:
+                index_py = TensorToScalar()(index)
+                dim_size = F.shape(orig_tensor)[orig_dim]
+                if index_py >= dim_size or index_py < -dim_size:
+                    raise IndexError("Index is out of bounds.")
+                new_index = (index_py + dim_size) % dim_size
+                result = select_ext_view_op(prev_result, dim, new_index)
+                # in graph mode, remain_indexes in different branch requires same size, so we fill empty tensor to it
+                remain_indexes = remain_indexes[0:dim] + (empty_tensor_9d,) * (dim - len(remain_indexes) + 1)
+                do_copy(result, value)
+            else:
+                # process index with Tensor bool type
+                result = expand_dims_view_op(prev_result, dim)
+                index_for_bool = tensor_1d if index else empty_tensor_1d
+                remain_indexes = remain_indexes[0:dim] + (empty_tensor_9d,) * (dim - len(remain_indexes)) + \
+                                 (index_for_bool,)
+                do_copy(result, value)
+        else:
+            remain_indexes = remain_indexes[0:dim] + (empty_tensor_9d,) * (dim - len(remain_indexes)) + (index,)
+            do_copy(result, value)
+    else:
+        raise IndexError("Invalid tensor index type")
+    return orig_tensor
+
+
+def _process_multi_dim_index_for_setitem(self, indexes, remain_indexes, indexed_dims, value):
+    """Process indexes in tuple"""
+    self_viewed = self
+    dim = 0
+    orig_dim = 0
+    need_index_prim = False
+    preprocessed_index = []
+    for index in indexes:
+        if isinstance(index, (list, tuple, np.ndarray)):
+            if not F.isconstant(index):
+                raise IndexError(
+                    "Current Tensor indexing does not support mutable list/tuple or list containing tensors. "
+                    "Please use an immutable expression instead.")
+            index = Tensor(index)
+            if isinstance(index, Tensor) and \
+                F.dtype(index) in (mstype.int8, mstype.int16, mstype.uint16, mstype.uint32,
+                                   mstype.uint64, mstype.float16, mstype.float32, mstype.float64):
+                # only uint8, int32 and int64 are supported by IndexOp
+                index = F.cast(index, mstype.int64)
+        preprocessed_index.append(index)
+        need_index_prim = _get_need_index_prim(index, need_index_prim)
+
+    if not preprocessed_index:
+        return do_copy(self_viewed, value)
+
+    result = self
+
+    for i, index in enumerate(preprocessed_index):
+        if i == len(preprocessed_index) - 1:
+            if need_index_prim:
+                result = _process_with_inplace_index_input(self_viewed,
+                                                           self, index, dim, i, remain_indexes, orig_dim, value)
+            else:
+                result = _process_with_do_copy(self_viewed, self, index, dim, i, remain_indexes, orig_dim, value)
+        else:
+            self_viewed, dim, remain_indexes, orig_dim, _ = _process_dim_in_multi_dim_index(
+                self_viewed, self, index, dim, indexed_dims, i, remain_indexes, orig_dim, True)
+    return result
+
+
 def _check_type_of_list_index(index_list):
     """Check type of element in list index"""
     for index in index_list:
@@ -446,13 +592,7 @@ def _tensor_setitem(self, index, value):
     if F.rank(self) < indexed_dims:
         raise IndexError("For setitem, there are too many indices")
     remain_indexes = ()
-    self_viewed, remain_indexes, need_index_prim = _process_multi_dim_index(self, indexes, remain_indexes, indexed_dims)
-    if not need_index_prim:
-        do_copy(self_viewed, value)
-        return self
-    inplace_index_put_op(self_viewed, remain_indexes, value, False)
-    return self
-
+    return _process_multi_dim_index_for_setitem(self, indexes, remain_indexes, indexed_dims, value)
 
 setattr(tensor_operator_registry, "_tensor_getitem", _tensor_getitem)
 setattr(tensor_operator_registry, "_tensor_setitem", _tensor_setitem)
@@ -660,7 +800,9 @@ def handle_empty_tensor(arg, data):
     if 0 in arg:
         init_func = Zero()
         init_func.__enable_zero_dim__ = True
-        return Tensor(shape=arg, dtype=data.dtype, init=init_func)
+        zero_tensor = Tensor(shape=arg, dtype=data.dtype, init=init_func)
+        zero_tensor.init_data()
+        return zero_tensor
     return const_utils.make_tensor([], data.dtype, arg)
 
 

mindspore/ops/composite/multitype_ops/_constexpr_utils.py

@@ -619,7 +619,7 @@ def scalar_in_sequence(x, y):
 @constexpr
 def get_np_eps(input_dtype):
     """Get numpy eps."""
-    nptype = mstype.dtype_to_nptype(input_dtype)
+    nptype = mstype._dtype_to_nptype(input_dtype)  # pylint:disable=protected-access
     eps = np.finfo(nptype).eps
     return float(eps)
 

mindspore/ops/composite/multitype_ops/add_impl.py

@@ -70,6 +70,13 @@ _tuple_add = _TupleAdd('tuple_add')
 """`_tuple_add` is an metafuncgraph object which will concatenate two tuples to form a tuple."""
 
 
+def _create_tuple_add(name):
+    """
+    Create and return a new `_TupleAdd` instance.
+    """
+    return _TupleAdd(name)
+
+
 class _DictUpdate(base.DictUpdate_):
     """
     A metafuncgraph class that append another dict to the end of the dict.

mindspore/ops/composite/multitype_ops/mod_impl.py

@@ -20,7 +20,15 @@ from mindspore.ops.composite import base
 from mindspore.ops import functional as F
 from mindspore.ops.auto_generate import (remainder_tensor_tensor_op, remainder_tensor_scalar_op,
                                          remainder_scalar_tensor_op)
+from mindspore.ops.auto_generate.gen_ops_prim import InplaceRemainderTensorTensor, InplaceRemainderTensorScalar
 
+# x %= y
+augassign_mod = base.MultitypeFuncGraph("augassign_mod", True)
+"""
+`augassign_mod` is a metafuncgraph object which will compute the mod of two objects
+using ".register" decorator.
+"""
+augassign_mod.set_need_raise()
 
 mod = base.MultitypeFuncGraph("mod", True)
 """
@@ -30,6 +38,7 @@ using ".register" decorator.
 mod.set_need_raise()
 
 
+@augassign_mod.register("Number", "Number")
 @mod.register("Number", "Number")
 def _mod_scalar(x, y):
     """Returns x % y where x and y are all scalars."""
@@ -42,18 +51,32 @@ def _mod_tensor(x, y):
     return remainder_tensor_tensor_op(x, y)
 
 
+@augassign_mod.register("Tensor", "Tensor")
+def _mul_tensor_augassign(x, y):
+    """Returns x % y where x and y are all tensors."""
+    return InplaceRemainderTensorTensor()(x, y)
+
+
 @mod.register("Tensor", "Number")
 def _tensor_mod_scalar(x, y):
     """Returns x % y where x is a tensor and y is a scalar. x and y should have same dtype."""
     return remainder_tensor_scalar_op(x, y)
 
 
+@augassign_mod.register("Tensor", "Number")
+def _tensor_mod_scalar_augassign(x, y):
+    """Returns x % y where x is a tensor and y is a scalar. x and y should have same dtype."""
+    return InplaceRemainderTensorScalar()(x, y)
+
+
+@augassign_mod.register("Number", "Tensor")
 @mod.register("Number", "Tensor")
 def _scalar_mod_tensor(x, y):
     """Returns x % y where x is a scalar and y is a tensor. x and y should have same dtype."""
     return remainder_scalar_tensor_op(x, y)
 
 
+@augassign_mod.register("Tuple", "Tensor")
 @mod.register("Tuple", "Tensor")
 def _tuple_mod_tensor(x, y):
     """Returns x % y where x is a tuple and y is a tensor. """
@@ -61,6 +84,7 @@ def _tuple_mod_tensor(x, y):
     return F.tensor_mod(x, y)
 
 
+@augassign_mod.register("Tensor", "Tuple")
 @mod.register("Tensor", "Tuple")
 def _tensor_mod_tuple(x, y):
     """Returns x % y where x is a tensor and y is a tuple. """
@@ -68,6 +92,7 @@ def _tensor_mod_tuple(x, y):
     return F.tensor_mod(x, y)
 
 
+@augassign_mod.register("List", "Tensor")
 @mod.register("List", "Tensor")
 def _list_mod_tensor(x, y):
     """Returns x % y where x is a list and y is a tensor. """
@@ -75,6 +100,7 @@ def _list_mod_tensor(x, y):
     return F.tensor_mod(x, y)
 
 
+@augassign_mod.register("Tensor", "List")
 @mod.register("Tensor", "List")
 def _tensor_mod_list(x, y):
     """Returns x % y where x is a tensor and y is a list. """
@@ -83,6 +109,7 @@ def _tensor_mod_list(x, y):
 
 
 # pylint: disable=protected-access
+@augassign_mod._register_default()
 @mod._register_default()
 def default_mod(x, y):
     """Default function for mod."""

mindspore/ops/function/__init__.py

@@ -481,6 +481,7 @@ from .nn_func import (
     max_pool3d,
     moe_token_permute,
     moe_token_unpermute,
+    ring_attention_update,
     batch_norm,
     add_rms_norm,
     rms_norm,
@@ -555,6 +556,7 @@ from .nn_func import (
     conv2d,
     conv_transpose2d,
     sigmoid,
+    inplace_sigmoid,
     soft_margin_loss,
     logsigmoid,
     relu,

mindspore/ops/function/array_func.py

@@ -33,10 +33,10 @@ from mindspore.ops.operations._sequence_ops import TupleToTensor
 from mindspore.ops.composite.multitype_ops import _constexpr_utils as const_utils
 from mindspore.ops.operations._sequence_ops import TensorToList
 # 1
-from mindspore.ops.auto_generate import OnesLikeExt, ZerosLikeExt, FillScalar, FillTensor, Arange, Chunk, UniqueDim, \
+from mindspore.ops.auto_generate import OnesLikeExt, ZerosLikeExt, FillScalar, FillTensor, Arange, UniqueDim, \
     Unique2, SortExt, NonZero, NonZeroExt, Scatter, ScatterValue, NewOnes, NewZeros
 # 2
-
+from mindspore.ops.auto_generate.pyboost_inner_prim import squeeze_impl
 # 3
 
 # 4
@@ -108,7 +108,7 @@ from mindspore.ops.auto_generate import cat, range, scatter_nd, deepcopy, masked
     index_fill_scalar, index_fill_tensor
 from mindspore.ops.auto_generate import take, tensor_scatter_elements as tensor_scatter_elements_ext
 from mindspore.ops.auto_generate.gen_ops_prim import scatter_add_ext_op, gather_d_op, slice_op, tril_ext_op, \
-    split_tensor_op, split_with_size_op
+    split_tensor_op, split_with_size_op, chunk_op
 from mindspore.ops.operations.manually_defined import tile, rank, scalar_cast
 from mindspore.ops.auto_generate.pyboost_inner_prim import _PyboostOneHotExtPrim
 
@@ -181,7 +181,6 @@ sort_ext_ = SortExt()
 scatter_prim = Scatter()
 scatter_value_ = ScatterValue()
 arange_ = Arange()
-chunk_ = Chunk()
 repeat_interleave_int_ = RepeatInterleaveInt()
 repeat_interleave_tensor_ = RepeatInterleaveTensor()
 unique_dim_ = UniqueDim()
@@ -784,7 +783,7 @@ def full_ext(size, fill_value, *, dtype=None):  # pylint: disable=redefined-oute
 
     Keyword Args:
         dtype (mindspore.dtype, optional): The specified type of output tensor.
-            `bool_` and `number` are supported, for details,
+            `bool` and `number` are supported, for details,
             please refer to :class:`mindspore.dtype` . Default: ``None`` .
 
     Returns:
@@ -857,7 +856,7 @@ def full_like_ext(input, fill_value, *, dtype=None):
         fill_value (Number): Value to fill the returned tensor. Complex numbers are not supported for now.
 
     Keyword Args:
-        dtype (mindspore.dtype, optional): The specified type of output tensor. `bool_` and `number` are supported,
+        dtype (mindspore.dtype, optional): The specified type of output tensor. `bool` and `number` are supported,
             for details, please refer to :class:`mindspore.dtype` . Default: ``None`` .
 
     Returns:
@@ -994,7 +993,7 @@ def chunk_ext(input, chunks, dim=0):
          Tensor(shape=[3], dtype=Float32, value= [ 3.00000000e+00,  4.00000000e+00,  5.00000000e+00]),
          Tensor(shape=[3], dtype=Float32, value= [ 6.00000000e+00,  7.00000000e+00,  8.00000000e+00]))
     """
-    return chunk_(input, chunks, dim)
+    return chunk_op(input, chunks, dim)
 
 
 def fills(x, value):
@@ -1960,10 +1959,7 @@ def squeeze(input, axis=None):
     """
     if axis is None:
         axis = ()
-    if isinstance(axis, list):
-        axis = tuple(axis)
-    squeeze_ = _get_cache_prim(P.Squeeze)(axis)
-    return squeeze_(input)
+    return squeeze_impl(input, axis)
 
 
 def scatter_mul(input_x, indices, updates):
@@ -2835,6 +2831,11 @@ def tensor_scatter_add(input_x, indices, updates):
     .. math::
         output\left [indices  \right ] = input\_x + update
 
+    The figure below shows an example of the computational process of tensor_scatter_add:
+
+    .. image:: ../images/TensorScatterAdd.png
+        :align: center
+
     Note:
         - On GPU, if some values of the `indices` are out of bound, instead of raising an index error,
           the corresponding `updates` will not be updated to self tensor.
@@ -3555,7 +3556,7 @@ def matrix_set_diag(x, diagonal, k=0, align="RIGHT_LEFT"):  # pylint: disable=re
     return matrix_set_diag_v3_op(x, diagonal, k)
 
 
-def meshgrid_ext(*tensors, indexing='ij'):
+def meshgrid_ext(*tensors, indexing=None):
     """
     Generates coordinate matrices from given coordinate tensors.
 
@@ -3577,7 +3578,7 @@ def meshgrid_ext(*tensors, indexing='ij'):
             for ``'ij'`` indexing, the shape of outputs is :math:`(M, N)`. In the 3-D
             case with inputs of length `M`, `N` and `P`, for ``'xy'`` indexing, the shape of outputs is
             :math:`(N, M, P)` and for ``'ij'`` indexing, the shape of outputs is :math:`(M, N, P)`.
-            Default: ``'ij'`` .
+            Default: ``None`` , which is equivalent to the value ``'ij'`` .
 
     Returns:
         Tensors, a Tuple of N N-D Tensor objects. The data type is the same with the Inputs.
@@ -4728,7 +4729,11 @@ def _tensor_split_sub_tensors(x, indices_or_sections, axis):
         idx = indices_or_sections[i]
         begin[axis] = 0 if i == 0 else indices_or_sections[i - 1]
         end[axis] = idx
-        sliced_tensor = strided_slice(x, tuple(begin), tuple(end), strides)
+        if begin[axis] == end[axis]:
+            empty_shape = x.shape[0:axis] + (0,) + x.shape[axis + 1:]
+            sliced_tensor = ms.Tensor(shape=empty_shape, dtype=x.dtype)
+        else:
+            sliced_tensor = strided_slice(x, tuple(begin), tuple(end), strides)
         sub_tensors.append(sliced_tensor)
     return tuple(sub_tensors)
 
@@ -4744,7 +4749,7 @@ def _tensor_split_sub_int(x, indices_or_sections, axis):
         res = _get_cache_prim(P.Split)(axis)(x)
     elif indices_or_sections > length_along_dim:
         res = _get_cache_prim(P.Split)(axis, length_along_dim)(x)
-        indices_or_sections_n = [length_along_dim, length_along_dim + 1]
+        indices_or_sections_n = [length_along_dim]
         res2 = _tensor_split_sub_tensors(x, indices_or_sections_n, axis)
         for _ in np.arange(length_along_dim, indices_or_sections):
             res += tuple(res2)[1:]
@@ -5067,7 +5072,7 @@ def max(input, axis=None, keepdims=False, *, initial=None, where=None):  # pylin
         >>> # case 4: Use "where" to include only specific elements in computing the maximum.
         >>> where = mindspore.tensor([[0, 0, 1, 0],
         ...                           [0, 0, 1, 1],
-        ...                           [1, 1, 1, 0]], dtype=mindspore.bool_)
+        ...                           [1, 1, 1, 0]], dtype=mindspore.bool)
         >>> mindspore.ops.max(input, axis=1, keepdims=True, initial=0, where=where)
         (Tensor(shape=[3, 1], dtype=Int64, value=
          [[4],
@@ -5207,7 +5212,7 @@ def min(input, axis=None, keepdims=False, *, initial=None, where=None):  # pylin
         >>> # case 4: Use "where" to include only specific elements in computing the minimum.
         >>> where = mindspore.tensor([[1, 0, 1, 0],
         ...                           [0, 0, 1, 1],
-        ...                           [1, 1, 1, 0]], dtype=mindspore.bool_)
+        ...                           [1, 1, 1, 0]], dtype=mindspore.bool)
         >>> mindspore.ops.min(input, axis=1, keepdims=True, initial=0, where=where)
         (Tensor(shape=[3, 1], dtype=Int64, value=
          [[ 0],
@@ -5812,6 +5817,7 @@ def nonzero(input, *, as_tuple=False):
     .. note::
         - Ascend: Rank of Input tensor can be equal to 0 except GE backend.
         - CPU/GPU: Rank of Input tensor should be greater than or eaqual to 1.
+        - Currently, only the Ascend backend is supported when `as_tuple` is ``True``.
 
     Keyword Args:
         as_tuple (bool, optional): Whether the output is tuple. Default ``False`` .
@@ -6301,7 +6307,7 @@ def repeat_elements(x, rep, axis=0):
     Repeat elements of a tensor along an axis, like :func:`mindspore.numpy.repeat` .
 
     Note:
-        It is recommended to use :func:'mindspore.mint.repeat_interleave', the dimension of input 'x' can support
+        It is recommended to use :func:`mindspore.mint.repeat_interleave`, the dimension of input 'x' can support
         a maximum of 8, and get better performance.
 
     Args: