mindspore 2.6.0rc1__cp310-cp310-win_amd64.whl → 2.7.0rc1__cp310-cp310-win_amd64.whl

mindspore/ops/composite/multitype_ops/setitem_impl.py

@@ -16,6 +16,7 @@
 """Implementation for internal polymorphism `setitem` operations."""
 
 from __future__ import absolute_import
+import os
 from mindspore.ops.composite.multitype_ops import _compile_utils as compile_utils
 from mindspore.ops import functional as F
 from mindspore.ops.operations._inner_ops import SliceGetItem
@@ -293,6 +294,8 @@ def _tensor_setitem_by_tensor_with_tensor(data, index, value_tensor):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value_tensor)
     return compile_utils.tensor_setitem_by_tensor_with_tensor(data, index, value_tensor)
 
 
@@ -316,6 +319,8 @@ def _tensor_setitem_by_tensor_with_number(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     return compile_utils.tensor_setitem_by_tensor_with_number(data, index, value)
 
 
@@ -337,6 +342,8 @@ def _tensor_setitem_by_tuple_with_number(data, tuple_index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, tuple_index, value)
     return compile_utils.tensor_setitem_by_tuple_with_number(data, tuple_index, value)
 
 
@@ -358,6 +365,8 @@ def _tensor_setitem_by_tuple_with_tensor(data, tuple_index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, tuple_index, value)
     return compile_utils.tensor_setitem_by_tuple_with_tensor(data, tuple_index, value)
 
 
@@ -380,6 +389,8 @@ def _tensor_setitem_by_tuple_with_tuple(data, tuple_index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, tuple_index, value)
     return compile_utils.tensor_setitem_by_tuple_with_sequence(data, tuple_index, value)
 
 
@@ -402,6 +413,8 @@ def _tensor_setitem_by_tuple_with_list(data, tuple_index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, tuple_index, value)
     return compile_utils.tensor_setitem_by_tuple_with_sequence(data, tuple_index, value)
 
 
@@ -418,6 +431,8 @@ def _tensor_setitem_by_tensor_with_tuple(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     return compile_utils.tensor_setitem_by_tensor_with_sequence(data, index, value)
 
 
@@ -434,6 +449,8 @@ def _tensor_setitem_by_tensor_with_list(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     return compile_utils.tensor_setitem_by_tensor_with_sequence(data, index, value)
 
 
@@ -456,6 +473,8 @@ def _tensor_setitem_by_slice_with_tensor(data, input_slice, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, input_slice, value)
     return compile_utils.tensor_setitem_by_slice(data, input_slice, value)
 
 
@@ -478,6 +497,8 @@ def _tensor_setitem_by_slice_with_number(data, input_slice, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, input_slice, value)
     return compile_utils.tensor_setitem_by_slice(data, input_slice, value)
 
 
@@ -500,6 +521,8 @@ def _tensor_setitem_by_slice_with_list(data, input_slice, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, input_slice, value)
     return compile_utils.tensor_setitem_by_slice(data, input_slice, value)
 
 
@@ -522,6 +545,8 @@ def _tensor_setitem_by_slice_with_tuple(data, input_slice, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, input_slice, value)
     return compile_utils.tensor_setitem_by_slice(data, input_slice, value)
 
 
@@ -543,6 +568,8 @@ def _tensor_setitem_by_number_with_number(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     if isinstance(index, bool):
         return compile_utils.tensor_setitem_by_bool(data, index, value)
     return compile_utils.tensor_setitem_by_number_with_number(data, index, value)
@@ -566,6 +593,8 @@ def _tensor_setitem_by_number_with_tensor(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     if isinstance(index, bool):
         return compile_utils.tensor_setitem_by_bool(data, index, value)
     return compile_utils.tensor_setitem_by_number_with_tensor(data, index, value)
@@ -589,6 +618,8 @@ def _tensor_setitem_by_number_with_tuple(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     if isinstance(index, bool):
         return compile_utils.tensor_setitem_by_bool(data, index, value)
     return compile_utils.tensor_setitem_by_number_with_sequence(data, index, value)
@@ -612,6 +643,8 @@ def _tensor_setitem_by_number_with_list(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     if isinstance(index, bool):
         return compile_utils.tensor_setitem_by_bool(data, index, value)
     return compile_utils.tensor_setitem_by_number_with_sequence(data, index, value)
@@ -634,6 +667,8 @@ def _tensor_setitem_by_ellipsis_with_number(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     return compile_utils.tensor_setitem_by_ellipsis_with_number(data, value)
 
 
@@ -654,6 +689,8 @@ def _tensor_setitem_by_ellipsis_with_tensor(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     return compile_utils.tensor_setitem_by_ellipsis_with_tensor(data, value)
 
 
@@ -674,6 +711,8 @@ def _tensor_setitem_by_ellipsis_with_list(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     return compile_utils.tensor_setitem_by_ellipsis_with_sequence(data, value)
 
 
@@ -694,6 +733,8 @@ def _tensor_setitem_by_ellipsis_with_tuple(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     return compile_utils.tensor_setitem_by_ellipsis_with_sequence(data, value)
 
 
@@ -714,6 +755,8 @@ def _tensor_setitem_by_none_with_number(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     return compile_utils.tensor_setitem_by_ellipsis_with_number(data, value)
 
 
@@ -734,6 +777,8 @@ def _tensor_setitem_by_none_with_tensor(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     return compile_utils.tensor_setitem_by_ellipsis_with_tensor(data, value)
 
 
@@ -754,6 +799,8 @@ def _tensor_setitem_by_none_with_list(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     return compile_utils.tensor_setitem_by_ellipsis_with_sequence(data, value)
 
 
@@ -774,6 +821,8 @@ def _tensor_setitem_by_none_with_tuple(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     return compile_utils.tensor_setitem_by_ellipsis_with_sequence(data, value)
 
 
@@ -794,6 +843,8 @@ def _tensor_setitem_by_list_with_number(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     value = F.cast(value, F.dtype(data))
     return compile_utils.tensor_setitem_by_list(data, index, value)
 
@@ -815,6 +866,8 @@ def _tensor_setitem_by_list_with_tensor(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     return compile_utils.tensor_setitem_by_list(data, index, value)
 
 
@@ -835,6 +888,8 @@ def _tensor_setitem_by_list_with_tuple(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     value = compile_utils.sequence_to_tensor(value, F.dtype(data))
     return compile_utils.tensor_setitem_by_list(data, index, value)
 
@@ -856,6 +911,8 @@ def _tensor_setitem_by_list_with_list(data, index, value):
     Outputs:
         Tensor, element type and shape is same as data.
     """
+    if os.environ.get("MS_DEV_TENSOR_INDEX_BOOST") == "1":
+        return compile_utils._tensor_setitem(data, index, value)
     value = compile_utils.sequence_to_tensor(value, F.dtype(data))
     return compile_utils.tensor_setitem_by_list(data, index, value)
 

mindspore/ops/composite/multitype_ops/sub_impl.py

@@ -16,12 +16,23 @@
 """Implementation for internal polymorphism `sub` operations."""
 
 from __future__ import absolute_import
+from mindspore.ops.auto_generate.gen_ops_prim import InplaceSubExt, InplaceSubScalar
 from mindspore.ops.composite.multitype_ops import _compile_utils as utils
 from mindspore.ops.composite.multitype_ops._constexpr_utils import check_equal, make_tensor
 from mindspore.ops.composite import base
 from mindspore.ops import functional as F
 
 
+# x -= y
+augassign_sub = base.MultitypeFuncGraph('augassign_sub', True)
+"""
+`augassign_sub` is a metafuncgraph object which will compute the subtraction of two objects
+using ".register" decorator.
+"""
+
+augassign_sub.set_need_raise()
+
+
 sub = base.MultitypeFuncGraph("sub", True)
 """
 `sub` is a metafuncgraph object which will compute the subtraction of two objects
@@ -30,30 +41,45 @@ using ".register" decorator.
 sub.set_need_raise()
 
 
+@augassign_sub.register("Number", "Number")
 @sub.register("Number", "Number")
 def _sub_scalar(x, y):
     """Returns x - y where x and y are all scalars."""
     return F.scalar_sub(x, y)
 
 
+@augassign_sub.register("Tensor", "Tensor")
+def _sub_tensor_augassign(x, y):
+    """Returns x - y where x and y are all tensors."""
+    return InplaceSubExt()(x, y)
+
+
 @sub.register("Tensor", "Tensor")
 def _sub_tensor(x, y):
     """Returns x - y where x and y are all tensors."""
     return F.tensor_sub(x, y)
 
 
+@augassign_sub.register("Number", "Tensor")
 @sub.register("Number", "Tensor")
 def _scalar_sub_tensor(x, y):
     """Returns x - y where x is a scalar and y is a tensor. x and y should have same dtype."""
     return F.tensor_sub(x, y)
 
 
+@augassign_sub.register("Tensor", "Number")
+def _tensor_sub_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 InplaceSubScalar()(x, y)
+
+
 @sub.register("Tensor", "Number")
 def _tensor_sub_scalar(x, y):
     """Returns x - y where x is a tensor and y is a scalar. x and y should have same dtype."""
     return F.tensor_sub(x, y)
 
 
+@augassign_sub.register("Tuple", "Tensor")
 @sub.register("Tuple", "Tensor")
 def _tuple_sub_tensor(x, y):
     """Returns x - y where x is a tuple and y is a tensor. """
@@ -61,6 +87,7 @@ def _tuple_sub_tensor(x, y):
     return F.tensor_sub(x, y)
 
 
+@augassign_sub.register("Tensor", "Tuple")
 @sub.register("Tensor", "Tuple")
 def _tensor_sub_tuple(x, y):
     """Returns x - y where x is a tensor and y is a tuple. """
@@ -68,6 +95,7 @@ def _tensor_sub_tuple(x, y):
     return F.tensor_sub(x, y)
 
 
+@augassign_sub.register("List", "Tensor")
 @sub.register("List", "Tensor")
 def _list_sub_tensor(x, y):
     """Returns x - y where x is a list and y is a tensor. """
@@ -75,6 +103,7 @@ def _list_sub_tensor(x, y):
     return F.tensor_sub(x, y)
 
 
+@augassign_sub.register("Tensor", "List")
 @sub.register("Tensor", "List")
 def _tensor_sub_list(x, y):
     """Returns x - y where x is a tensor and y is a list. """
@@ -82,6 +111,7 @@ def _tensor_sub_list(x, y):
     return F.tensor_sub(x, y)
 
 
+@augassign_sub.register("CSRTensor", "CSRTensor")
 @sub.register("CSRTensor", "CSRTensor")
 def _sub_csrtensor(x, y):
     """Returns x - y where x and y are all CSR tensors."""
@@ -89,6 +119,7 @@ def _sub_csrtensor(x, y):
     return F.csr_add(x, y, make_tensor(1, x.values.dtype), make_tensor(-1, x.values.dtype))
 
 
+@augassign_sub.register("COOTensor", "COOTensor")
 @sub.register("COOTensor", "COOTensor")
 def _sub_cootensor(x, y):
     """Returns x - y where x and y are all COO tensors."""
@@ -96,6 +127,7 @@ def _sub_cootensor(x, y):
     return F.coo_add(x, -y, make_tensor(0, x.values.dtype))
 
 
+@augassign_sub.register("Tensor", "COOTensor")
 @sub.register("Tensor", "COOTensor")
 def _tensor_sub_cootensor(x, y):
     """Returns x - y where x is a tensor and y is a COO tensor."""
@@ -103,6 +135,7 @@ def _tensor_sub_cootensor(x, y):
     return F.tensor_scatter_sub(x, y.indices, y.values)
 
 
+@augassign_sub.register("COOTensor", "Tensor")
 @sub.register("COOTensor", "Tensor")
 def _cootensor_sub_tensor(x, y):
     """Returns x - y where x is a COO tensor and y is a tensor."""
@@ -111,6 +144,7 @@ def _cootensor_sub_tensor(x, y):
 
 
 # pylint: disable=protected-access
+@augassign_sub._register_default()
 @sub._register_default()
 def default_sub(x, y):
     """Default function for sub."""

mindspore/ops/composite/multitype_ops/zeros_like_impl.py

@@ -213,6 +213,20 @@ def _zeros_like_env_type(x):
     return F.environ_create()
 
 
+@zeros_like_leaf.register("Slice")
+def _zeros_like_slice(x):
+    """
+    Slice.
+
+    Args:
+        x (Slice): the input
+
+    Returns:
+        x.
+    """
+    return x
+
+
 class _ZerosLike(base.ZerosLike_):
     def __init__(self, name, fn_leaf):
         """Initialize _ZerosLike."""

mindspore/ops/function/__init__.py

@@ -785,7 +785,9 @@ from .other_func import (
     partial,
     rotary_position_embedding,
     move_to,
-    moe_init_routing_v2
+    moe_init_routing_v2,
+    moe_distribute_dispatch,
+    moe_distribute_combine
 )
 
 from ._add_attr_func import (

mindspore/ops/function/_add_attr_func.py

@@ -14,6 +14,8 @@
 # ============================================================================
 """_add_attr"""
 
+__all__ = ["_add_attr"]
+
 from typing import Callable
 import mindspore as ms
 from mindspore._c_expression import AddAttr_
@@ -36,13 +38,12 @@ class AddAttr(AddAttr_):
         if (not isinstance(fn, Callable)) or isinstance(fn, Primitive):
             raise TypeError(f"the parameter 'fn' must be callable type except Primitive, but got:{type(fn)}")
 
-        if self.addattr_fn is not None and self.addattr_fn == fn and \
-           self.fn is not None and self.fn == fn and \
-           self.attrs_dict is not None and self.attrs_dict == kwargs:
+        if self._is_attr_set(fn, kwargs):
             return self.addattr_fn
 
         add_attr_ = AddAttr()
         attr_kv_pair = tuple(kwargs.items())
+
         @ms.common.jit
         def add_attr_fn(*args):
             return add_attr_(fn, attr_kv_pair)(*args)
@@ -52,7 +53,11 @@ class AddAttr(AddAttr_):
         self.attrs_dict = kwargs
         return self.addattr_fn
 
-def _add_attr(fn, **kwargs):
-    return  AddAttr()(fn, **kwargs)
+    def _is_attr_set(self, fn, kwargs):
+        return self.addattr_fn is not None and self.addattr_fn == fn and \
+               self.fn is not None and self.fn == fn and \
+               self.attrs_dict is not None and self.attrs_dict == kwargs
 
-__all__ = ["_add_attr"]
+
+def _add_attr(fn, **kwargs):
+    return AddAttr()(fn, **kwargs)

mindspore/ops/function/array_func.py

@@ -104,15 +104,13 @@ from mindspore.ops._utils.utils import ms_arrange
 from mindspore.ops.auto_generate import cat, range, scatter_nd, deepcopy, masked_fill, diagonal, expand_dims, \
     flip, transpose, triu, unsorted_segment_sum, diag, gather, gather_d, gather_nd, reshape, masked_select, \
     broadcast_to, strided_slice, ones, zeros, max_, min_, select, zero_, view_as, \
-    expand_as, unstack_ext_op, full_like_op, \
+    expand_as, unstack_ext_view_op, full_like_op, \
     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
+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
 from mindspore.ops.operations.manually_defined import tile, rank, scalar_cast
 from mindspore.ops.auto_generate.pyboost_inner_prim import _PyboostOneHotExtPrim
-from mindspore._c_expression import pyboost_empty
-from mindspore._c_expression import pyboost_empty_like
-from mindspore._c_expression import pyboost_new_empty
 
 arg_max_with_value_ = ArgMaxWithValue()
 arg_min_with_value_ = ArgMinWithValue()
@@ -517,92 +515,6 @@ def reverse(x, axis):
     return flip(x, axis)
 
 
-def empty(*size, dtype=None, device=None):
-    r"""
-    Creates a tensor with uninitialized data, whose shape, dtype and device are described by the argument `size`,
-    `dtype` and `device` respectively.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Args:
-        size (Union[tuple[int], list[int], int]): The specified shape of output tensor. Only positive integer or
-            tuple or list containing positive integers are allowed.
-
-    Keyword Args:
-        dtype (:class:`mindspore.dtype`, optional): The specified type of output tensor. If `dtype` is ``None`` ,
-            `mindspore.float32` will be used. Default: ``None`` .
-        device (string, optional): The specified device of the output tensor. Support ``CPU`` and ``Ascend``. If
-            `device = None`, the value set by :func:`mindspore.set_device` will be used. Default ``None``.
-
-    Returns:
-        Tensor, whose dtype and size are defined by input.
-
-    Raises:
-        TypeError: If `size` is neither an int nor a tuple or list of int.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import ops
-        >>> output = ops.empty((2, 3), dtype=mindspore.float32)
-        >>> print(output)
-        [[0. 0. 0.]
-         [0. 0. 0.]]
-    """
-
-    return pyboost_empty([size, dtype, device])
-
-def empty_like(input, *, dtype=None, device=None):
-    r"""
-    Returns an uninitialized Tensor with the same shape as the `input`. Its dtype is specified by `dtype` and its
-    device is specified by `device`.
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
-    Args:
-        input (Tensor): Tensor of any dimension.
-
-    Keyword Args:
-        dtype (:class:`mindspore.dtype`, optional): The specified dtype of the output tensor. If `dtype = None`, the
-            tensor will have the same dtype as input `input`. Default ``None``.
-        device (string, optional): The specified device of the output tensor. Support ``CPU`` and ``Ascend``. If
-            `device = None`, the tensor will have the same device as input `input` and if the device of the input
-            tensor is not defined, the value set by :func:`mindspore.set_device` will be used. Default ``None``.
-
-    Returns:
-        Tensor, has the same shape, type and device as `input` but with uninitialized data (May be a random value).
-
-    Raises:
-        TypeError: If `input` is not a Tensor.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import ops, Tensor
-        >>> x = Tensor([[1, 2, 3], [4, 5, 6]])
-        >>> output1 = ops.empty_like(x)
-        >>> print(output1)
-        [[0 0 0]
-         [0 0 0]]
-        >>> output2 = ops.empty_like(x, dtype=mindspore.float64)
-        >>> print(output2)
-        [[0. 0. 0.]
-         [0. 0. 0.]]
-    """
-
-    return pyboost_empty_like([input, dtype, device])
-
-
-def new_empty(input, size, dtype, device):
-    return pyboost_new_empty([input, size, dtype, device])
-
-
 def ravel(input):
     """
     Expand the multidimensional Tensor into 1D along the 0 axis direction.
@@ -1981,7 +1893,7 @@ def unbind_ext(input, dim=0):
         (Tensor(shape=[3], dtype=Int64, value=[1, 2, 3]), Tensor(shape=[3], dtype=Int64, value=[4, 5, 6]),
         Tensor(shape=[3], dtype=Int64, value=[7, 8, 9]))
     """
-    return unstack_ext_op(input, dim)
+    return unstack_ext_view_op(input, dim)
 
 
 def unsqueeze(input, dim):
@@ -3267,7 +3179,7 @@ def _get_slice_scatter_const(x_shape, axis, start, end, step):
     x_rank = len(x_shape)
     axis = axis if axis >= 0 else axis + x_rank
     start = start if start is not None else 0
-    start = start if start >= 0 else start + x_rank
+    start = start if start >= 0 else start + x_shape[axis]
     end = end if end is not None else x_shape[axis]
     end = end if end >= 0 else end + x_shape[axis]
     end = end if end < x_shape[axis] else x_shape[axis]
@@ -4607,9 +4519,9 @@ def split_ext(tensor, split_size, dim=0):
          Tensor(shape=[3], dtype=Float32, value= [ 6.00000000e+00,  7.00000000e+00,  8.00000000e+00]))
     """
     if isinstance(split_size, int):
-        res = split_tensor(tensor, split_size, dim)
+        res = split_tensor_op(tensor, split_size, dim)
     elif isinstance(split_size, (list, tuple)):
-        res = split_with_size(tensor, split_size, dim)
+        res = split_with_size_op(tensor, split_size, dim)
     else:
         raise TypeError(f"Type of Argument `split_size` should be integer, tuple(int) or list(int), "
                         f"but got {type(split_size)}")
@@ -5430,6 +5342,7 @@ def narrow(input, axis, start, length):
     sizes[axis] = length
     return tensor_slice(input, begins, sizes)
 
+
 def topk(input, k, dim=None, largest=True, sorted=True):
     r"""
     Return the top `k` largest or smallest elements of the input tensor along a specified dimension.
@@ -5897,7 +5810,7 @@ def nonzero(input, *, as_tuple=False):
         input (Tensor): The input tensor.
 
     .. note::
-        - Ascend: Rank of Input tensor can be equal to 0 except jit level O2 mode.
+        - 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.
 
     Keyword Args:

mindspore/ops/function/debug_func.py

@@ -15,6 +15,8 @@
 
 """Operators for debug function."""
 
+__all__ = ['print_', 'tensordump']
+
 from mindspore.ops.operations.debug_ops import Print
 from mindspore.common.tensor import Tensor
 from mindspore.ops import operations as P
@@ -22,7 +24,7 @@ from .._primitive_cache import _get_cache_prim
 
 
 def print_(*input_x):
-    """
+    r"""
     Outputs the inputs to stdout.
     The outputs are printed to screen by default.
     It can also be saved in a file by setting the parameter  `print_file_path` in `context`.
@@ -38,7 +40,7 @@ def print_(*input_x):
         This function is used for debugging.
 
     Args:
-        input_x (Union[Tensor, bool, int, float, str, tuple, list]): The inputs of print_.
+        input_x (Union[Tensor, bool, int, float, str, tuple, list]): The inputs of print\_.
             Supports multiple inputs which are separated by ','.
 
     Returns:
@@ -176,6 +178,5 @@ def tensordump(file_name, tensor, mode='out'):
     _tensordump = _get_cache_prim(P.TensorDump)(input_output=mode)
     return _tensordump(file_name, tensor)
 
-__all__ = ['print_', 'tensordump']
 
 __all__.sort()

mindspore/ops/function/grad/grad_func.py

@@ -1395,7 +1395,7 @@ def stop_gradient(value):
         >>> mindspore.ops.grad(f1)(mindspore.tensor(x))
         Tensor(shape=[], dtype=Float32, value= 6)
         >>>
-        >>> # The same function with stop_gradient, return a zero gradient because x is effectively treated as a constant.
+        >>> # With stop_gradient, return a zero gradient because x is effectively treated as a constant.
         >>> def f2(x):
         ...     return mindspore.ops.stop_gradient(x) ** 2
         >>> f2(x)