mindspore 2.3.0__cp310-cp310-win_amd64.whl → 2.4.0__cp310-cp310-win_amd64.whl

mindspore/common/recompute.py

@@ -23,8 +23,10 @@ from mindspore.common.tensor import Tensor
 from mindspore import ops
 from mindspore.ops.composite import GradOperation
 from mindspore.common._register_for_recompute import recompute_registry
-from mindspore.common.api import _pynative_executor
+from mindspore.common.api import _pynative_executor, _no_grad
 from mindspore.common.generator import get_rng_state, set_rng_state
+from mindspore.train.amp import amp_decorator
+from mindspore._c_expression.amp import get_curr_amp_strategy
 
 
 class _WrapCell(Cell):
@@ -34,7 +36,7 @@ class _WrapCell(Cell):
     """
 
     def __init__(self, function):
-        super(_WrapCell, self).__init__()
+        super(_WrapCell, self).__init__(auto_prefix=False)
         self.function = function
 
     def construct(self, *args, **kwargs):
@@ -56,6 +58,7 @@ class _RecomputeCell(Cell):
         self.args = []
         self.kwargs = []
         self.wrap_cell = _WrapCell(block)
+        self.wrap_cell.set_inputs()
 
         self.net = block
         self.internal_params = []
@@ -64,15 +67,18 @@ class _RecomputeCell(Cell):
         self._add_attr("is_cell_recompute", "True")
         self.grad = GradOperation(get_all=True, get_by_list=True, sens_param=True)
         self.init_mixed_precision_type(block)
+        self.amp_strategy = None
 
     def construct(self, *args, **kwargs):
-        _check_input_args_validate(self.net, args)
+        _check_input_args_validate(self.net, args, kwargs)
         self.args.append(args)
         self.kwargs.append(kwargs)
         self.save_rng_state = kwargs.pop("save_rng_state", True)
         if self.save_rng_state:
             self.cpu_rng_state = get_rng_state()
-        return self.net(*args, **kwargs)
+        self.amp_strategy = get_curr_amp_strategy()
+        with _no_grad():
+            return self.net(*args, **kwargs)
 
     def bprop(self, *args):
         """
@@ -86,14 +92,23 @@ class _RecomputeCell(Cell):
         self.args.pop()
         self.kwargs.pop()
         if kwargs:
-            input_args = list(input_args) + list(kwargs.values())
+            input_args_for_check = list(input_args) + list(kwargs.values())
+        else:
+            input_args_for_check = list(input_args)
         # To detach inputs to avoid erasing auto grad meta info of origin inputs.
         input_args = _detach_input(input_args)
+        kwargs = _detach_input(kwargs)
+        kwargs['sens'] = grad_input
         try:
             pre_rng_state = get_rng_state()
             set_rng_state(self.cpu_rng_state)
             _pynative_executor.set_is_run_recompute(True)
-            grads = self.grad(self.net, self.internal_params)(*input_args, grad_input)
+            if self.amp_strategy:
+                with amp_decorator(self.amp_strategy.get_amp_level(), self.amp_strategy.get_amp_dtype(),
+                                   self.amp_strategy.get_white_list(), self.amp_strategy.get_black_list()):
+                    grads = self.grad(self.net, self.internal_params)(*input_args, **kwargs)
+            else:
+                grads = self.grad(self.net, self.internal_params)(*input_args, **kwargs)
             _pynative_executor.set_is_run_recompute(False)
             set_rng_state(pre_rng_state)
         except Exception as err:
@@ -101,7 +116,7 @@ class _RecomputeCell(Cell):
             raise err
         weights = OrderedDict()
         input_grads = list(grads[0])
-        _padding_input_grads(input_args, input_grads)
+        _padding_input_grads(input_args_for_check, input_grads)
         for i, param in enumerate(self.internal_params):
             weights[param] = grads[1][i]
         return tuple(input_grads), weights
@@ -121,6 +136,7 @@ class _RecomputeCell(Cell):
             # To avoid sub cell same name
             block.__self__.check_names_and_refresh_name()
             self.internal_params = block.__self__.trainable_params()
+            self.wrap_cell.mixed_precision_type = block.__self__.get_mixed_precision_type()
             self.wrap_cell.set_mixed_precision_type(block.__self__.get_mixed_precision_type())
             self.net = self.wrap_cell
         else:
@@ -128,13 +144,14 @@ class _RecomputeCell(Cell):
                             "only support Cell object or MethodType function!")
 
 
-def _check_input_args_validate(block, args):
+def _check_input_args_validate(block, args, kwargs):
     """
     Check recompute input args validate
     :param args:
     :return:
     """
-    if not any([isinstance(arg, Tensor) for arg in args]):
+    if not (any([isinstance(arg, Tensor) for arg in args]) or \
+        any([isinstance(arg, Tensor) for arg in kwargs.values()])):
         logger.warning("None of the inputs of function are tensors, which not need use recompute!")
     for arg in args:
         if isinstance(arg, (tuple, list)):
@@ -168,6 +185,11 @@ def _padding_input_grads(args, input_grads):
 
 
 def _detach_input(input_arg):
+    """
+    Detach input
+    :param input_arg:
+    :return: detach output
+    """
     if isinstance(input_arg, Tensor):
         return ops.stop_gradient(input_arg)
     if isinstance(input_arg, (list, tuple)):
@@ -175,6 +197,14 @@ def _detach_input(input_arg):
         for arg in input_arg:
             detach_inputs.append(_detach_input(arg))
         return detach_inputs if isinstance(input_arg, list) else tuple(detach_inputs)
+    if isinstance(input_arg, dict):
+        detach_inputs = {}
+        for key, val in input_arg.items():
+            if isinstance(val, Tensor):
+                detach_inputs[key] = ops.stop_gradient(val)
+            else:
+                detach_inputs[key] = val
+        return detach_inputs
     return input_arg
 
 

mindspore/common/sparse_tensor.py

@@ -97,7 +97,8 @@ class RowTensor(RowTensorInner):
          [0, 0]]
 
     .. warning::
-        This is an experimental API that is subjected to change or deletion.
+        - This is an experimental API that is subjected to change or deletion.
+        - If use PyNative mode, set "export MS_PYNATIVE_CONFIG_STATIC_SHAPE=1".
 
     Args:
         indices (Tensor): A 1-D integer Tensor of shape :math:`(d_0)` . Default: ``None``.
@@ -226,10 +227,11 @@ class COOTensor(COOTensor_):
 
     Common arithmetic operations include: addition (+), subtraction (-), multiplication (*),
     and division (/). For details about operations supported by `COOTensor`, see
-    `operators <https://www.mindspore.cn/docs/en/master/note/static_graph_syntax_support.html#operators>`_.
+    `operators <https://www.mindspore.cn/docs/en/master/model_train/program_form/static_graph.html#operators>`_.
 
     .. warning::
         - This is an experimental API that is subject to change or deletion.
+        - If use PyNative mode, set "export MS_PYNATIVE_CONFIG_STATIC_SHAPE=1".
         - Currently, duplicate coordinates in the indices will not be coalesced.
           If the indices contain out-of-bound values, the result will be undefined.
 
@@ -646,6 +648,7 @@ class CSRTensor(CSRTensor_):
     [1., 2., 3., 4., 5., 6.], shape is (3, 5), then the dense representation of the sparse tensor will be:
 
     .. code-block::
+
         [[1., 0., 0., 2., 0.],
          [0., 3., 4., 0., 5.],
          [0., 0., 6., 0., 0.]]
@@ -668,10 +671,11 @@ class CSRTensor(CSRTensor_):
 
     Common arithmetic operations include: addition (+), subtraction (-), multiplication (*),
     and division (/). For details about operations supported by `CSRTensor`, see
-    `operators <https://www.mindspore.cn/docs/en/master/note/static_graph_syntax_support.html#operators>`_.
+    `operators <https://www.mindspore.cn/docs/en/master/model_train/program_form/static_graph.html#operators>`_.
 
     .. warning::
         - This is an experimental API that is subjected to change.
+        - If use PyNative mode, set "export MS_PYNATIVE_CONFIG_STATIC_SHAPE=1".
         - If the values given by `indptr` or `indices` are invalid, the results may be undefined. Invalid values include
           when the length of `values` or `indices` exceeds the range indicated by `indptr`, and when the columns
           indicated by `indices` are repeated on the same row.

mindspore/common/tensor.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Huawei Technologies Co., Ltd
+# Copyright 2020-2024 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.
@@ -31,6 +31,8 @@ from mindspore.common.hook_handle import _TensorHookHandle
 
 from mindspore.common._utils import get_slice_num
 from mindspore.common._register_for_tensor import tensor_operator_registry
+from mindspore.common._tensor_overload import (repeat_interleave_mint, add_mint, item_mint, isnan_mint, flatten_mint,
+                                               max_mint, mean_mint, min_mint, split_mint, sub_mint)
 from mindspore._c_expression import Tensor as Tensor_
 from mindspore import _checkparam as validator
 from mindspore._checkparam import check_is_number, is_stub_tensor, check_hook_fn
@@ -51,7 +53,7 @@ def _check_input_data_type(input_data):
                     np.float16, np.float32, np.float64, np.bool_, np.str_, np.complex64, np.complex128)
     if isinstance(input_data, np.ndarray) and input_data.dtype not in valid_dtypes and \
             input_data.dtype.kind != 'U' and input_data.dtype.kind != 'S' and \
-            input_data.dtype.kind != 'T':  # Support dtype np.str_ and npy_bfloat16
+            not (input_data.dtype.kind == 'V' and input_data.dtype.char == 'E'):  # Support np.str_ and np.bfloat16
         new_line = '\n'
         for index, x in np.ndenumerate(input_data):
             if np.array(x).dtype not in valid_dtypes:
@@ -85,11 +87,11 @@ def tensor(input_data=None, dtype=None, shape=None, init=None, internal=False, c
     based on the `dtype` argument.
 
     Please refer to `Creating and Using Tensor
-    <https://www.mindspore.cn/docs/en/master/note/static_graph_syntax_support.html#mindspore-user-defined-data-types>`_ .
+    <https://www.mindspore.cn/docs/en/master/model_train/program_form/static_graph.html#mindspore-user-defined-data-types>`_ .
 
     The difference between it and the Tensor class is that it adds
     `Annotation
-    <https://www.mindspore.cn/docs/en/master/design/dynamic_graph_and_static_graph.html?#annotation-type>`_
+    <https://www.mindspore.cn/docs/en/master/model_train/program_form/static_graph.html#annotation-type>`_
     which can prevent the generation of AnyType compared to the Tensor class.
 
     The arguments and return values are the same as the Tensor class. Also see: :class:`mindspore.Tensor`.
@@ -143,6 +145,8 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             Default: ``False`` .
         const_arg (bool): Whether the tensor is a constant when it is used for the argument of a network.
             Default: ``False`` .
+        device(str): This parameter is reserved and does not need to be configured.
+            Default: ``None`` .
 
     Outputs:
         Tensor.
@@ -205,7 +209,8 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     """
     delta_seed = 0
 
-    def __init__(self, input_data=None, dtype=None, shape=None, init=None, internal=False, const_arg=False):
+    def __init__(self, input_data=None, dtype=None, shape=None, init=None, internal=False, const_arg=False,
+                 device=None):
         self.init_finished = False
         if isinstance(input_data, (Tensor, Tensor_)) and dtype is not None:
             logger.info("It is suggested to use 'Tensor.astype()' to convert the dtype of a Tensor.")
@@ -264,6 +269,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
                         Tensor_.__init__(self, input_data)
                     validator.check_value_type('const_arg', const_arg, bool, 'Tensor')
 
+        if device is not None and device != "CPU":
+            raise ValueError(f"Only 'CPU' is supported for device, but got {device}.")
+
         self.const_arg = const_arg
         self.virtual_flag = False
         self.init = init
@@ -380,6 +388,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def __abs__(self):
         return tensor_operator_registry.get('abs')(self)
 
+    @add_mint
     def __add__(self, other):
         return tensor_operator_registry.get('__add__')(self, other)
 
@@ -404,6 +413,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def __iadd__(self, other):
         return self.__add__(other)
 
+    @sub_mint
     def __sub__(self, other):
         return tensor_operator_registry.get('__sub__')(self, other)
 
@@ -513,9 +523,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         return state
 
     def __setstate__(self, state):
-        value = state.pop("value")
+        if isinstance(state, tuple):
+            value = state
+        else:
+            value = state.pop("value")
+            self.__dict__.update(state)
         Tensor_.__setstate__(self, value)
-        self.__dict__.update(state)
 
     @property
     def shape(self):
@@ -706,8 +719,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
         Examples:
             >>> from mindspore import Tensor
+            >>> from mindspore import dtype as mstype
             >>> import numpy as np
-            >>> x = Tensor(np.array([[1, 2], [3, 4]]))
+            >>> x = Tensor(np.array([[1, 2], [3, 4]]), dtype=mstype.int64)
             >>> output = x.strides
             >>> print(output)
             (16, 8)
@@ -940,6 +954,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('chunk')(self, chunks, axis)
 
+    @item_mint
     def item(self, index=None):
         """
         Get the item at the specified index of the tensor.
@@ -1054,7 +1069,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             self.init_data()
         return Tensor_.asnumpy(self)
 
-    def numpy(self):
+    def numpy(self, *, force=False):
         """
         Alias for :func:`mindspore.Tensor.asnumpy`.
         """
@@ -1295,12 +1310,48 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('addcmul')(self, tensor1, tensor2, value)
 
+    @add_mint
     def add(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.add`.
         """
         return tensor_operator_registry.get('add')(self, other)
 
+    def add_(self, other, *, alpha=1):
+        """
+        inplace update self by following compute:
+            self = self + other * alpha.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+            The `other` tensor must be broadcastable with the `self` tensor. It may be of a different data type.
+
+        Args:
+            other (Tensor): the source tensor Add to self Tensor.
+            alpha (Number): no effect currently.
+
+        Returns:
+            Return self Tensor.
+
+        Supported Platforms:
+            ``Ascend``
+
+        Examples:
+            >>> import numpy as np
+            >>> from mindspore import Tensor
+            >>> a = Tensor(np.ones((2,3)).astype("float32"))
+            >>> b = Tensor(np.ones((2,3)).astype("float32"))
+            >>> a.add_(b)
+            >>> print(a)
+            [[2. 2. 2.]
+            [2. 2. 2.]]
+        """
+        if isinstance(other, (int, float)):
+            ret = tensor_operator_registry.get("adds_")(self, other, alpha)
+        else:
+            ret = tensor_operator_registry.get("add_")(self, other, alpha)
+        return ret
+
     def subtract(self, other, *, alpha=1):
         r"""
         For details, please refer to :func:`mindspore.ops.subtract`.
@@ -1337,6 +1388,19 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('addmm')(self, mat1, mat2, beta=beta, alpha=alpha)
 
+    def addmm_(self, mat1, mat2, *, beta=1, alpha=1):
+        r"""
+        For details, please refer to :func:`mindspore.ops.addmm`.
+
+        .. note::
+            The output results are directly updated in the Tensor.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+
+        """
+        return tensor_operator_registry.get('addmm_')(self, mat1, mat2, beta=beta, alpha=alpha)
+
     def addr(self, vec1, vec2, beta=1, alpha=1):
         r"""
         For details, please refer to :func:`mindspore.ops.addr`.
@@ -1579,6 +1643,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('square')(self)
 
+    @sub_mint
     def sub(self, y):
         r"""
         For details, please refer to :func:`mindspore.ops.sub`.
@@ -1842,6 +1907,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('log2')(self)
 
+    @mean_mint
     def mean(self, axis=None, keep_dims=False):
         """
         For details, please refer to :func:`mindspore.ops.mean`.
@@ -2012,11 +2078,11 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         reshape_op = tensor_operator_registry.get('reshape')
         return reshape_op(self, (-1,))
 
-    def round(self):
+    def round(self, decimals=0):
         """
         For details, please refer to :func:`mindspore.ops.round`.
         """
-        return tensor_operator_registry.get('round')(self)
+        return tensor_operator_registry.get('round')(self, decimals=decimals)
 
     def roll(self, shifts, dims):
         """
@@ -2091,6 +2157,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('remainder')(self, divisor)
 
+    @flatten_mint
     def flatten(self, order='C', *, start_dim=0, end_dim=-1):
         r"""
         For details, please refer to :func:`mindspore.ops.flatten`.
@@ -2399,6 +2466,38 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         x = x.astype(origin_dtype)
         return x
 
+    def copy_(self, src, non_blocking=False):
+        """
+        Copies the elements from src into self tensor and returns self.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+            The `src` tensor must be broadcastable with the `self` tensor. It may be of a different data type.
+
+        Args:
+            src (Tensor): the source tensor to copy from.
+            non_blocking (bool): no effect currently.
+
+        Returns:
+            Return self Tensor.
+
+        Supported Platforms:
+            ``Ascend``
+
+        Examples:
+            >>> import numpy as np
+            >>> from mindspore import Tensor
+            >>> a = Tensor(np.ones((3,3)).astype("float32"))
+            >>> b = Tensor(np.zeros((3,3)).astype("float32"))
+            >>> a.copy_(b)
+            >>> print(a)
+            [[0. 0. 0.]
+            [0. 0. 0.]
+            [0. 0. 0.]]
+        """
+        return tensor_operator_registry.get("copy_")(self, src)
+
+    @max_mint
     def max(self, axis=None, keepdims=False, *, initial=None, where=True, return_indices=False):
         """
         Return the maximum of a tensor or maximum along an axis.
@@ -2467,6 +2566,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             return values
         return values, indices
 
+    @min_mint
     def min(self, axis=None, keepdims=False, *, initial=None, where=True, return_indices=False):
         """
         Return the minimum of a tensor or minimum along an axis.
@@ -2763,7 +2863,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             opt_shard_group(str): Optimizer shard group which is used in auto or semi auto parallel mode
                 to get one shard of a parameter's slice. For more information about optimizer parallel, please refer to:
                 `Optimizer Parallel
-                <https://www.mindspore.cn/tutorials/experts/en/master/parallel/optimizer_parallel.html>`_.
+                <https://www.mindspore.cn/docs/en/master/model_train/parallel/optimizer_parallel.html>`_.
                 Default: ``None``.
 
         Returns:
@@ -2995,16 +3095,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(x.trace())
             3.0
         """
-        if offset == 0 and axis1 == 0 and axis2 == 1 and dtype is None:
-            return tensor_operator_registry.get('trace')(self)
-        d = self.diagonal(offset, axis1=axis1, axis2=axis2)
-        shape = d.shape
-        if dtype is None:
-            dtype = d.dtype
-        if shape[-1] == 0:
-            return tensor_operator_registry.get('fill')(dtype, shape[:-1], 0)
-        res = tensor_operator_registry.get('reduce_sum')(d.astype(mstype.float32), -1)
-        return res.astype(dtype)
+        return tensor_operator_registry.get('tracev2')(self, offset, axis1, axis2, dtype)
 
     def take(self, indices, axis=None, mode='clip'):
         """
@@ -3164,6 +3255,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             sorter (Union[int, list, tuple, Tensor]): optional tensor of
                 integer indices that sort the tensor into ascending order on the innermost dimension
                 and the type must be int64. They are typically the result of argsort. Default: ``None`` .
+                CPU and GPU can only use default values
 
         Returns:
             Tensor, array of insertion points with the same shape as `v`.
@@ -3217,10 +3309,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def uniform(self, from_=0., to=1., generator=None):
         r"""
-        Generates random numbers in the half-open interval [from_, to).
+        Generates random numbers in the half-open interval [from\_, to).
 
         Args:
-            from_ (number): The lower bound of the interval.
+            from\_ (number): The lower bound of the interval.
             to (number): The upper bound of the interval.
             generator (Generator, optional): The random seed. Default: None.
 
@@ -3506,6 +3598,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
                 repeated_subs.append(tensor_operator_registry.get('repeat_elements')(sub, rep, axis))
         return tensor_operator_registry.get('concatenate')(repeated_subs, axis)
 
+    @repeat_interleave_mint
     def repeat_interleave(self, repeats, dim=None):
         """
         For details, please refer to :func:`mindspore.ops.repeat_interleave`.
@@ -3740,6 +3833,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get("xdivy")(self, y)
 
+    @split_mint
     def split(self, split_size_or_sections, axis=0):
         """
         For details, please refer to :func:`mindspore.ops.split`.
@@ -4039,6 +4133,27 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('int')(self, mstype.int32)
 
+    def byte(self):
+        r"""
+        Converts input tensor dtype to `uint8`.
+
+        Returns:
+            Tensor, converted to the `uint8` dtype.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import Tensor
+            >>> input_x = Tensor(np.ones([2,2]), mindspore.float32)
+            >>> output = input_x.byte()
+            >>> print(output.dtype)
+            uint8
+        """
+        return tensor_operator_registry.get('byte')(self, mstype.uint8)
+
     def long(self):
         r"""
         Converts input tensor dtype to `int64`. If the value in tensor is float or half, the decimal will be discarded.
@@ -4249,6 +4364,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('isinf')(self)
 
+    @isnan_mint
     def isnan(self):
         r"""
         For details, please refer to :func:`mindspore.ops.isnan`.
@@ -4425,7 +4541,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('mul')(self, value)
 
-    def nan_to_num(self, nan=0.0, posinf=None, neginf=None):
+    def nan_to_num(self, nan=None, posinf=None, neginf=None):
         """
         For details, please refer to :func:`mindspore.ops.nan_to_num`.
         """
@@ -4482,6 +4598,31 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('zeros')(size, dtype)
 
+    def zero_(self):
+        r"""
+        Return a tensor filled with zeros.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+
+        Returns:
+            Return a tensor. Fill self tensor with zeros.
+
+        Supported Platforms:
+            ``Ascend``
+
+        Examples:
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import Tensor
+            >>> x = Tensor(np.array([2, 2]))
+            >>> output = x.zero_()
+            >>> print(output)
+            [[0. 0.]
+             [0. 0.]]
+        """
+        return tensor_operator_registry.get('zero_')(self)
+
     def new_ones(self, size, dtype=None):
         r"""
         Return a tensor of `size` filled with ones.
@@ -4758,7 +4899,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         mode = context.get_context("mode")
         if mode != context.PYNATIVE_MODE:
             raise ValueError(f"The method of 'move_to' only supported in pynative mode, but got: {mode}.")
-        return Tensor(Tensor_.move_to(self, to, blocking))
+        return Tensor(Tensor_.move_to(self, to, blocking), device="CPU" if to == "CPU" else None)
 
 
     def _offload(self):
@@ -4805,6 +4946,44 @@ def _vm_compare(*args):
     return Tensor(np.array(fn(y)))
 
 
+def _check_sequence_shape(input_data):
+    """Check the shape of tensor input with type of sequence."""
+    max_dims_reached = False
+    max_ndim = 64 # corresponding to NPY_MAXDIMS
+    out_shape = [0]*max_ndim
+
+    def check_shape_recursive(input_data, curr_ndim):
+        nonlocal max_dims_reached, max_ndim, out_shape
+        if curr_ndim > max_ndim:
+            return False
+        if not isinstance(input_data, (tuple, list)):
+            if max_dims_reached and curr_ndim != max_ndim:
+                max_ndim = curr_ndim
+                return False
+            max_dims_reached = True
+            max_ndim = curr_ndim
+            return True
+        if not max_dims_reached:
+            out_shape[curr_ndim] = len(input_data)
+        else:
+            if out_shape[curr_ndim] != len(input_data):
+                max_ndim = curr_ndim
+                return False
+        if not input_data:
+            # process empty list
+            if not check_shape_recursive(None, curr_ndim + 1):
+                return False
+        for data in input_data:
+            if not check_shape_recursive(data, curr_ndim + 1):
+                return False
+        return True
+
+    if not check_shape_recursive(input_data, 0):
+        raise ValueError(f"When initializing a tensor with a sequence, the sequence has an inhomogeneous shape "
+                         f"after {max_ndim} dimensions. The detected shape was {tuple(out_shape[:max_ndim])} "
+                         f"+ inhomogeneous part.")
+
+
 def _check_tensor_input(input_data=None, dtype=None, shape=None, init=None):
     """Check the tensor input."""
     if input_data is not None and shape is not None:
@@ -4817,9 +4996,10 @@ def _check_tensor_input(input_data=None, dtype=None, shape=None, init=None):
     if input_data is not None:
         if isinstance(input_data, np.ndarray) and input_data.ndim >= 1 and input_data.size == 0:
             raise ValueError("input_data can not contain zero dimension.")
-        if isinstance(input_data, (tuple, list)) and np.array(input_data).ndim >= 1 \
-                and np.array(input_data).size == 0:
-            raise ValueError("input_data can not contain zero dimension.")
+        if isinstance(input_data, (tuple, list)):
+            _check_sequence_shape(input_data)
+            if np.array(input_data).ndim >= 1 and np.array(input_data).size == 0:
+                raise ValueError("input_data can not contain zero dimension.")
 
     if shape is not None and not (hasattr(init, "__enable_zero_dim__") and init.__enable_zero_dim__) and 0 in shape:
         raise ValueError("Shape can not contain zero value.")

mindspore/communication/__init__.py

@@ -20,7 +20,7 @@ Note that the APIs in the following list need to preset communication environmen
 For Ascend/GPU/CPU devices, it is recommended to use the msrun startup method
 without any third-party or configuration file dependencies.
 Please see the `msrun start up
-<https://www.mindspore.cn/tutorials/experts/zh-CN/master/parallel/msrun_launcher.html>`_
+<https://www.mindspore.cn/docs/zh-CN/master/model_train/parallel/msrun_launcher.html>`_
 for more details.
 """