mindspore 2.6.0__cp311-cp311-manylinux1_x86_64.whl → 2.7.0__cp311-cp311-manylinux1_x86_64.whl

mindspore/common/np_dtype.py

@@ -16,10 +16,10 @@
 # ============================================================================
 """Numpy data type for MindSpore."""
 
-from mindspore._c_expression.np_dtypes import np_version_valid
-if np_version_valid(True):
+from mindspore._c_expression.np_dtypes import np_dtype_valid
+if np_dtype_valid(True):
     from mindspore._c_expression.np_dtypes import bfloat16 # pylint: disable=unused-import
 
 __all__ = []
-if np_version_valid(False):
+if np_dtype_valid(False):
     __all__.extend(["bfloat16"])

mindspore/common/parameter.py

@@ -33,6 +33,7 @@ from mindspore import context
 from mindspore.common._utils import get_slice_num, get_slice_shape
 from mindspore.common.initializer import initializer
 from mindspore.common.tensor import Tensor, _TensorMeta
+from mindspore.common.hook_handle import _update_hook_version
 from mindspore import _checkparam as Validator
 from mindspore._check_jit_forbidden_api import jit_forbidden_register
 from mindspore._c_expression import TensorPy as Tensor_
@@ -49,20 +50,27 @@ import mindspore.common._monad as monad
 __all__ = ['Parameter', 'ParameterTuple']
 
 PARAMETER_NAME_DEFAULT = "Parameter"
+_GENERATED_PARAMETER_NAME_PREFIX = PARAMETER_NAME_DEFAULT + '#'
 PARAMETER_NAME_PREFIX_MAX_LEN = 1024
 
-# Global variable for parameter unique key.
-_GLOBAL_PARAMETER_KEY = -1
+_PARAMETER_NAME_ID = 0
+
+
+def _generate_parameter_name():
+    global _PARAMETER_NAME_ID
+    name = _GENERATED_PARAMETER_NAME_PREFIX + str(_PARAMETER_NAME_ID)
+    _PARAMETER_NAME_ID += 1
+    return name
+
+
+def _is_parameter_generated(param_name):
+    if not param_name or not isinstance(param_name, str):
+        return False
+    return param_name.startswith(_GENERATED_PARAMETER_NAME_PREFIX)
 
-# Global variable to mark the hook of parameter is updated
-_parameter_hook_updated = True
-def set_parameter_hook_updated(value):
-    global _parameter_hook_updated
-    _parameter_hook_updated = value
 
-def parameter_hook_updated():
-    global _parameter_hook_updated
-    return _parameter_hook_updated
+# Global variable for parameter unique key.
+_GLOBAL_PARAMETER_KEY = -1
 
 
 def _is_in_auto_parallel_mode():
@@ -72,7 +80,7 @@ def _is_in_auto_parallel_mode():
 
 def _is_parallel_mode():
     """ Whether is parallel mode """
-    if not _is_initialized() or context.get_context('mode') == context.PYNATIVE_MODE:
+    if not _is_initialized():
         return False
     if os.getenv("RUN_MODE") != "predict":
         return False
@@ -410,10 +418,6 @@ class Parameter(Tensor_):
                                "1. context.set_ps_context(enable_ps=True) \n"
                                "2. export MS_ROLE environment variable \n"
                                "Please refer to the official website for detailed usage.")
-
-        if context.get_context("mode") == context.PYNATIVE_MODE:
-            raise RuntimeError("Parameter server training is not supported in pynative mode currently."
-                               "Please switch to graph mode and retry.")
         self.is_param_ps = True
         self.init_in_server = init_in_server
         self.param_info.init_in_server = init_in_server
@@ -496,11 +500,11 @@ class Parameter(Tensor_):
                 the default value `PARAMETER_NAME_DEFAULT` is used.
         """
         if name_ is None:
-            name_ = PARAMETER_NAME_DEFAULT
+            name_ = _generate_parameter_name()
         elif isinstance(name_, str):
             name_ = name_.strip()
             if name_ == '':
-                name_ = PARAMETER_NAME_DEFAULT
+                name_ = _generate_parameter_name()
             if len(name_) > PARAMETER_NAME_PREFIX_MAX_LEN:
                 raise ValueError("The length of the '{}' name should be less than {}.".
                                  format(name_, PARAMETER_NAME_PREFIX_MAX_LEN))
@@ -904,13 +908,10 @@ class Parameter(Tensor_):
         incoming_tensor_is_init = isinstance(data, Tensor) and not data.has_init
         current_tensor_is_init = isinstance(self, Tensor) and not self.has_init
         if self.dtype != data.dtype:
-            if mstype.implicit_conversion_seq.get(self.dtype) < mstype.implicit_conversion_seq.get(data.dtype):
-                self._raise_type_error(data.dtype)
-            else:
-                from mindspore.ops import functional as F
-                if isinstance(data, Tensor) and data.init is not None:
-                    data.init_data()
-                data = F.cast(data, self.dtype)
+            from mindspore.ops import functional as F
+            if isinstance(data, Tensor) and data.init is not None:
+                data.init_data()
+            data = F.cast(data, self.dtype)
         if isinstance(data, Tensor) and data.has_init:
             # The parameter has been initialized, directly update by the data
             if current_tensor_is_init:
@@ -938,7 +939,6 @@ class Parameter(Tensor_):
             init_data_args += (slice_index, layout[2], layout[5])
         return init_data_args
 
-
     def init_data(self, layout=None, set_sliced=False):
         """
         Initialize the parameter's data.
@@ -1007,11 +1007,11 @@ class Parameter(Tensor_):
         For details, please refer to :func:`mindspore.Tensor.register_hook`.
         """
         handle = Tensor.register_hook(self, hook_fn)
-        set_parameter_hook_updated(True)
+        _update_hook_version()
         return handle
 
     def _remove_hook(self):
-        set_parameter_hook_updated(True)
+        _update_hook_version()
 
     def _offload(self):
         r"""
@@ -1030,7 +1030,6 @@ class Parameter(Tensor_):
         """
         return Tensor_._offload(self, True)
 
-
     def _load(self):
         r"""
         Load parameter to device.
@@ -1160,6 +1159,5 @@ class ParameterTuple(tuple):
                 _insert_accumu_init_info(x1.name, init_to_value(init))
         return ParameterTuple(new)
 
-
     def __parameter_tuple__(self):
         """For parse check."""

mindspore/common/recompute.py

@@ -18,15 +18,15 @@ from collections import OrderedDict
 from types import MethodType
 from mindspore import log as logger
 from mindspore.nn.cell import Cell
-from mindspore import context
 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, _no_grad
 from mindspore.common.generator import get_rng_state, set_rng_state
-from mindspore.train.amp import amp_decorator
+from mindspore.train.amp import AmpDecorator
 from mindspore._c_expression.amp import get_curr_amp_strategy
+from mindspore._check_jit_forbidden_api import jit_forbidden_register
 
 
 class _WrapCell(Cell):
@@ -104,8 +104,8 @@ class _RecomputeCell(Cell):
             set_rng_state(self.cpu_rng_state)
             _pynative_executor.set_is_run_recompute(True)
             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()):
+                with AmpDecorator(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)
@@ -211,14 +211,12 @@ def _detach_input(input_arg):
 def _check_validation(block):
     if not isinstance(block, Cell):
         raise TypeError("Recompute function now only support block which inherited from Cell!")
-    if context.get_context("mode") != context.PYNATIVE_MODE:
-        raise AssertionError("Recompute function now only support pynative mode, you can use "
-                             "Cell.recompute() in graph mode.")
     if block.construct.__code__.co_name == "staging_specialize":
         logger.warning('Block\'s construct method decorated by @jit that recompute '
                        'function will not come into effect.')
 
 
+@jit_forbidden_register
 def recompute(block, *args, **kwargs):
     r"""
     This function is used to reduce memory, when run block, rather than

mindspore/common/sparse_tensor.py

@@ -98,7 +98,6 @@ class RowTensor(RowTensorInner):
 
     .. warning::
         - 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``.
@@ -232,7 +231,6 @@ class COOTensor(COOTensor_):
 
     .. 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.
 
@@ -681,7 +679,6 @@ class CSRTensor(CSRTensor_):
 
     .. 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/symbol.py

@@ -104,7 +104,6 @@ class Symbol:
         if not isinstance(unique, bool):
             raise TypeError(f"For 'Symbol', the argument 'unique' must be bool, but got {type(unique)}")
 
-    # pylint: disable=missing-docstring
     def to_dict(self):
         # Convert the symbolic info to dictionary.
         # This method is not necessary to show in public api document, use comment instead of docstring.

mindspore/common/tensor.py

@@ -32,11 +32,12 @@ 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._c_expression import TensorPy as TensorPy_
+from mindspore._c_expression import _rmod_instance
 from mindspore import _checkparam as validator
 from mindspore._checkparam import is_stub_tensor, check_hook_fn
 from mindspore._check_jit_forbidden_api import jit_forbidden_register
 from mindspore.common.symbol import Symbol
-
+from mindspore._c_expression import is_reboot_node
 
 np_types = (np.int8, np.int16, np.int32, np.int64,
             np.uint8, np.uint16, np.uint32, np.uint64, np.float16,
@@ -93,13 +94,6 @@ def _set_symbolic_shape(shape):
     return shape, symbolic_shape
 
 
-def _convert_stub_tensor(input_data):
-    """Convert input to stub tensor"""
-    if not is_stub_tensor(input_data):
-        return input_data
-    return input_data.stub_sync()
-
-
 def _convert_numpy_array(input_data):
     """Convert inpyt to numpy array"""
     if not isinstance(input_data, np_types):
@@ -144,8 +138,6 @@ def _init(input_data=None, dtype=None, shape=None, init=None, const_arg=False, d
         _cast = tensor_operator_registry.get("cast")
         input_data = _cast(input_data, dtype)
 
-    input_data = _convert_stub_tensor(input_data)
-
     if input_data is None and shape is None and init is None and dtype is not None:
         validator.check_type_name('dtype', dtype, mstype.number_type + (mstype.bool_, mstype.string), "Tensor")
         logger.warning(f"For 'Tensor', if 'dtype' is not None, 'input_data', 'shape' or 'init' must not be None.")
@@ -325,7 +317,6 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
                 return True
         return NotImplemented
 
-
     def __deepcopy__(self, memodict):
         new_obj = Tensor(self)
         new_obj.init = self.init
@@ -379,9 +370,8 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         try:
             data = self._item()
             return int(data)
-        except ValueError:
-            raise ValueError("Only one element tensors can be converted to Python scalars")
-
+        except ValueError as e:
+            raise ValueError("Only one element tensors can be converted to Python scalars") from e
 
     def __float__(self):
         try:
@@ -396,8 +386,8 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
             if not isinstance(data, (int, bool)):
                 raise ValueError
             return int(data)
-        except ValueError:
-            raise ValueError("Only integer tensors of a single element can be converted to an index.")
+        except ValueError as e:
+            raise ValueError("Only integer tensors of a single element can be converted to an index.") from e
 
     def __pos__(self):
         return self
@@ -426,14 +416,8 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
     def __rtruediv__(self, other):
         return tensor_operator_registry.get('__truediv__')(other, self)
 
-    def __mod__(self, other):
-        return tensor_operator_registry.get('__mod__')(self, other)
-
     def __rmod__(self, other):
-        return tensor_operator_registry.get('__mod__')(other, self)
-
-    def __imod__(self, other):
-        return self.__mod__(other)
+        return _rmod_instance(other, self)
 
     def __rpow__(self, other):
         return tensor_operator_registry.get('__rpow__')(self, other)
@@ -1163,7 +1147,6 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
               which may be modified by returning a new output gradient.
             - The `hook` should have the following signature:
               hook(grad) -> New output gradient, but can not return None or not set return value.
-            - Higher-order differentiation does not support tensor `register_hook`.
             - The following constraints must be met under graph mode:
 
               - The `hook` must satisfy the syntax constraints of the graph mode.
@@ -1868,6 +1851,10 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
 
             self[i][j][index[i][j][k]] += src[i][j][k]  # if dim == 2
 
+        .. warning::
+            When deterministic computation is enabled, `index` can not be a non-contiguous Tensor; otherwise,
+            deterministic results can not be guaranteed.
+
         Args:
             dim (int): Which dim to scatter. Accepted range is [-r, r) where r = rank(`self`).
             index (Tensor): The index of `self` to do scatter operation whose data type must
@@ -2110,11 +2097,13 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
 
         from mindspore.common.initializer import Zero as ZeroInitializer
 
+        is_qint4x2 = self.dtype == mstype.qint4x2
         try:
+            dtype_ = mstype.int8 if is_qint4x2 else self.dtype
             if isinstance(self.init, ZeroInitializer):
-                data = np.zeros(data_shape, dtype=mstype.dtype_to_nptype(self.dtype))
+                data = np.zeros(data_shape, dtype=mstype._dtype_to_nptype(dtype_))  # pylint:disable=protected-access
             else:
-                data = np.ndarray(data_shape, dtype=mstype.dtype_to_nptype(self.dtype))
+                data = np.ndarray(data_shape, dtype=mstype._dtype_to_nptype(dtype_))  # pylint:disable=protected-access
         except ValueError as e:
             msg = "Error shape={}".format(shape)
             logger.critical(msg)
@@ -2127,7 +2116,7 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
                 self.init = init
                 global_seed = get_seed()
                 self._np_seed = np.random.get_state()[1][0]
-                self.need_set_seed = (slice_index is not None)
+                self.need_set_seed = slice_index is not None
                 self._global_seed = global_seed
                 self._seed_offset = 1
                 if self.need_set_seed:
@@ -2150,7 +2139,8 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
                     self.init.seed, _ = self.seed
 
         with seed_context(self.init):
-            if not isinstance(self.init, ZeroInitializer) and slice_num_of_persistent_data == 1:
+            if (not isinstance(self.init, ZeroInitializer) and slice_num_of_persistent_data == 1) \
+                    and not is_reboot_node():
                 self.init(data)
         self.init = None
 
@@ -2159,6 +2149,10 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
             self.assign_value(TensorPy_.persistent_data_from_numpy(data, slice_num_of_persistent_data))
         else:
             self.assign_value(TensorPy_.from_numpy(data))
+
+        if is_qint4x2:
+            self.set_dtype(mstype.qint4x2)
+
         return self
 
     def resize(self, *new_shape):
@@ -2495,7 +2489,6 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('uniform_')(self, from_=from_, to=to, generator=generator)
 
-
     def exponential_(self, lambd=1, *, generator=None):
         r"""
         Fills `self` tensor with elements drawn from the exponential distribution:
@@ -2529,7 +2522,6 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('exponential_')(self, lambd=lambd, generator=generator)
 
-
     def sum_to_size(self, *size):
         r"""
         Sum self Tensor to the `size`. `size` must be expandable to the Tensor size.
@@ -2561,17 +2553,19 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         shape_x = x.shape
         if len(size) > x.ndim:
             raise ValueError(f"For sum_to_size, size {size} is not expandable to the tensor size {shape_x}.")
+        pre_len = 0
+        pre_axis = []
         if len(size) < x.ndim:
-            pre_axis = tuple([axis for axis in range(x.ndim - len(size))])
-            x = x.sum(pre_axis)
-        axes = []
+            pre_len = x.ndim - len(size)
+            pre_axis = [axis for axis in range(pre_len)]
+        axes = pre_axis
         for i, element in enumerate(size):
-            if element != x.shape[i] and element == 1:
-                axes.append(i)
-            elif element != x.shape[i]:
+            if element != x.shape[i + pre_len] and element == 1:
+                axes.append(i + pre_len)
+            elif element != x.shape[i + pre_len]:
                 raise ValueError(f"For sum_to_size, size {size} is not expandable to the tensor size {shape_x}.")
         if axes:
-            return x.sum(tuple(axes), keepdims=True)
+            return x.sum(tuple(axes), keepdims=True).reshape(size)
         return x
 
     def nanmean(self, axis=None, keepdims=False, *, dtype=None):
@@ -2592,6 +2586,34 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('bernoulli')(self, generator=generator)
 
+    def bernoulli_(self, p=0.5, *, generator=None):
+        r"""
+        Fills each location of self with an independent sample from Bernoulli(p).
+
+        Args:
+            p (Union[number.Number, Tensor], optional): `p` should either be a scalar or tensor containing
+                probabilities to be used for drawing the binary random number, between ``0`` and ``1`` .
+                If it is a tensor, `p` must be floating point. Default: ``0.5`` .
+
+        Keyword Args:
+            generator (:class:`mindspore.Generator`, optional): a pseudorandom number generator.
+                Default: ``None`` , uses the default pseudorandom number generator.
+
+        Returns:
+            The input tensor.
+
+        Supported Platforms:
+            ``Ascend``
+
+        Examples:
+            >>> from mindspore import Tensor
+            >>> x = Tensor([[2, 3, 4], [1, 2, 3]])
+            >>> p = 0.1
+            >>> print(x.bernoulli_(p).shape)
+            (2, 3)
+        """
+        return tensor_operator_registry.get('bernoulli_')(self, p, generator=generator)
+
     def random_(self, from_=0, to=None, *, generator=None):
         r"""
         Fill the tensor with numbers sampled from a discrete uniform distribution over an
@@ -2654,7 +2676,7 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         Note:
            The rank of `self`.
 
-           - Ascend: its rank can be equal to 0 except O2 mode.
+           - Ascend: its rank can be equal to 0 except GE backend.
            - CPU/GPU: its rank should be greater than or eaqual to 1.
 
         Keyword Args:
@@ -2673,7 +2695,7 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         Raises:
             TypeError: If `self` is not Tensor.
             TypeError: If `as_tuple` is not bool.
-            RuntimeError: On GPU or CPU or Ascend O2 mode, if dim of `input` equals to 0.
+            RuntimeError: On GPU or CPU or Ascend GE backend, if dim of `input` equals to 0.
 
         Supported Platforms:
             ``Ascend`` ``GPU`` ``CPU``
@@ -2836,7 +2858,6 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
             return []
         return self._tolist()
 
-
     def unsorted_segment_min(self, segment_ids, num_segments):
         r"""
         For details, please refer to :func:`mindspore.ops.unsorted_segment_min`.
@@ -2859,7 +2880,7 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.unique_consecutive`.
         """
-        output, idx, counts =\
+        output, idx, counts = \
             tensor_operator_registry.get("unique_consecutive")(return_inverse, return_counts, dim)(self)
         if return_inverse and return_counts:
             return output, idx, counts
@@ -2946,7 +2967,8 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
               taken into account. As long as the real part is non-zero, it returns True; otherwise, it returns False.
 
         Args:
-            dtype (dtype.Number): The valid data type of the output tensor. Only constant value is allowed.
+            dtype (dtype.Number, bool): The valid data type of the output tensor. Only constant value is allowed.
+                Only Support type bool in PyNative mode.
 
         Returns:
             Tensor, converted to the specified `dtype`.
@@ -2998,7 +3020,6 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
             return str(self.dtype)
         return self.astype(dtype)
 
-
     def type_as(self, other):
         r"""
         Returns self tensor cast to the type of the with the input other tensor.
@@ -3041,7 +3062,6 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
             return self
         return TensorPy_.type_as(self, other)
 
-
     def bool(self):
         r"""
         Converts input tensor dtype to `bool`.
@@ -3537,49 +3557,6 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('zero_')(self)
 
-    def new_empty(self, size, *, dtype=None, device=None):
-        r"""
-        Returns an uninitialized Tensor of `size`. 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:
-            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 dtype of the output tensor. If `dtype = None`,
-                the tensor will have the same dtype as `self`. 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 `self` and if the device of `self` is not
-                defined, the value set by :func:`mindspore.set_device` will be used. Default ``None``.
-
-        Returns:
-            Tensor, the shape, dtype and device is defined above but with uninitialized data (May be a random value).
-
-        Raises:
-            TypeError: If `size` is neither an int nor a tuple or list of int.
-
-        Supported Platforms:
-            ``Ascend``
-
-        Examples:
-            >>> import mindspore
-            >>> from mindspore import Tensor
-            >>> x = Tensor([[1, 2, 3], [4, 5, 6]])
-            >>> output1 = x.new_empty((2, 3))
-            >>> print(output1)
-            [[0 0 0]
-             [0 0 0]]
-            >>> output2 = x.new_empty((2, 3), dtype=mindspore.float64)
-            >>> print(output2)
-            [[0. 0. 0.]
-             [0. 0. 0.]]
-        """
-        return tensor_operator_registry.get('new_empty')(self, size, dtype, device)
-
     def sign(self):
         r"""
         For details, please refer to :func:`mindspore.ops.sign`.
@@ -3651,46 +3628,6 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('ormqr')(self, input2, input3, left, transpose)
 
-    def masked_scatter(self, mask, x):
-        r"""
-        Updates the value in the "self Tensor" with the `tensor` value according to the mask, and returns a Tensor.
-        The shape of `mask` and the "self Tensor" must be the same or `mask` is broadcastable.
-
-        .. warning::
-            This is an experimental API that is subject to change or deletion.
-
-        Args:
-            mask (Tensor[bool]): A bool tensor with a shape broadcastable to the "self Tensor".
-            x (Tensor): A tensor with the same data type as the "self Tensor". The number
-                of elements must be greater than or equal to the number of True's in `mask`.
-
-        Returns:
-            Tensor, with the same type and shape as the "self Tensor".
-
-        Raises:
-            TypeError: If `mask` or `x` is not a Tensor.
-            TypeError: If data type of the "self Tensor" is not be supported.
-            TypeError: If dtype of `mask` is not bool.
-            TypeError: If the dim of the "self Tensor" less than the dim of `mask`.
-            ValueError: If `mask` can not be broadcastable to the "self Tensor".
-            ValueError: If the number of elements in `x` is less than the number required for the updates.
-
-        Supported Platforms:
-            ``Ascend`` ``CPU``
-
-        Examples:
-            >>> import numpy as np
-            >>> import mindspore
-            >>> from mindspore import Tensor
-            >>> x = Tensor(np.array([1., 2., 3., 4.]), mindspore.float32)
-            >>> mask = Tensor(np.array([True, True, False, True]), mindspore.bool_)
-            >>> tensor = Tensor(np.array([5., 6., 7.]), mindspore.float32)
-            >>> output = x.masked_scatter(mask, tensor)
-            >>> print(output)
-            [5. 6. 3. 7.]
-        """
-        return tensor_operator_registry.get('masked_scatter')()(self, mask, x)
-
     def index_put(self, indices, values, accumulate=False):
         r"""
         Based on the indices in `indices`, replace the corresponding elements in Tensor `self`
@@ -3831,9 +3768,6 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
             raise ValueError(f"The type of 'blocking' must be bool, but got {blocking}")
         if to not in ("Ascend", "GPU", "CPU"):
             raise ValueError(f"The value of 'to' must be one of ['Ascend', 'GPU', 'CPU'], but got {to}")
-        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 TensorPy_.move_to(self, to, blocking)
 
     def _offload(self):
@@ -3868,6 +3802,23 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         """
         return TensorPy_._data_ptr(self)
 
+    def data_ptr(self):
+        r"""
+        Get the data ptr address of tensor, for CPU is host address, GPU/NPU is device address.
+        User should know how to use the data ptr address.
+        Note: this api is an experimental api, users need understatnd it before use.
+
+        Supported Platforms:
+            ``CPU/GPU/Ascend``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor
+            >>> x = ms.Tensor([1, 2, 3], ms.int64)
+            >>> data_ptr = x.data_ptr()
+        """
+        return TensorPy_._data_ptr(self)
+
     def normal_(self, mean=0, std=1, *, generator=None):
         r"""
         Update the `self` tensor in place by generating random numbers sampled from the normal
@@ -3907,13 +3858,13 @@ class Tensor(TensorPy_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('normal_')(self, mean=mean, std=std, generator=generator)
 
-
     def triangular_solve(self, A, upper=True, transpose=False, unitriangular=False):
         r"""
         For details, please refer to :func:`mindspore.mint.triangular_solve`.
         """
         return tensor_operator_registry.get('triangular_solve')(self, A, upper, transpose, unitriangular)
 
+
 def _vm_compare(*args):
     """Implement `vm_compare` for tensor."""
     if args:
@@ -3986,9 +3937,9 @@ def _check_astype_and_convert(dtype):
         if dtype.lower() not in all_types:
             raise TypeError(f"For Tensor.astype, the string input type must be one of {all_types}, "
                             f"but got '{dtype}'.")
-        dtype = mstype.pytype_to_dtype(np.dtype(dtype.lower()))
+        dtype = mstype._pytype_to_dtype(np.dtype(dtype.lower()))  # pylint:disable=protected-access
     elif isinstance(dtype, type):
-        dtype = mstype.pytype_to_dtype(dtype)
+        dtype = mstype._pytype_to_dtype(dtype)  # pylint:disable=protected-access
     elif dtype not in mstype.number_type + (mstype.bool_,):
         raise TypeError(
             f"For Tensor.astype, the input type must be one of {list(mstype.number_type + (mstype.bool_,) + np_types)},"