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

mindspore/ops/operations/_inner_ops.py

@@ -25,10 +25,10 @@ from mindspore.ops.operations._scalar_ops import bit_or, bit_and
 from mindspore.ops import signature as sig
 from mindspore.ops.operations.math_ops import _infer_shape_reduce
 from mindspore.ops.primitive import PrimitiveWithCheck, PrimitiveWithInfer, prim_attr_register, Primitive, \
-    _check_contains_variable
+    _run_op, _check_contains_variable
 from mindspore._c_expression import TensorPy as Tensor_
 from mindspore._c_expression import typing, HookType
-from mindspore._c_expression import pyboost_generator, pyboost_cell_backward_hook
+from mindspore._c_expression import pyboost_generator
 from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
 from mindspore.common.parameter import Parameter
@@ -1565,11 +1565,10 @@ class CellBackwardHook(PrimitiveWithInfer):
         self.add_prim_attr("cell_id", cell_id)
         self.grad_output = None
 
-    def __call__(self, args):
-        is_tuple = True
-        if not isinstance(args, tuple):
-            args = (args,)
-            is_tuple = False
+    def __call__(self, *args):
+        # If args is empty, just return.
+        if not args:
+            return args
 
         # Collect the indices and values of arguments that are instances of Tensor
         tensors_idx = []
@@ -1579,18 +1578,20 @@ class CellBackwardHook(PrimitiveWithInfer):
                 tensors_idx.append(i)
                 tensors.append(arg)
 
-        # If there are no Tensor arguments, return original args
+        # If there are no Tensor arguments, return the single argument or the original tuple
         if not tensors:
-            return args if is_tuple else args[0]
+            return args[0] if len(args) == 1 else args
 
-        new_tensors = pyboost_cell_backward_hook(self, (tensors,))
+        new_tensors = _run_op(self, self.name, tensors)
+        if not isinstance(new_tensors, tuple):
+            new_tensors = (new_tensors,)
 
         # Replace the original Tensor arguments with the processed ones
         arg_list = list(args)
         for idx, val in zip(tensors_idx, new_tensors):
             arg_list[idx] = val
 
-        return tuple(arg_list) if is_tuple else arg_list[0]
+        return arg_list[0] if len(arg_list) == 1 else tuple(arg_list)
 
     def infer_shape(self, *inputs_shape):
         if len(inputs_shape) == 1:

mindspore/ops/operations/array_ops.py

@@ -42,7 +42,7 @@ from ..auto_generate import (
     NonZero, ResizeNearestNeighbor, Identity, Split, CumSum, CumProd,
     MaskedSelect, Cummax, Cummin, Argmin, Concat, UnsortedSegmentSum, UniqueConsecutive,
     ScalarToTensor, Triu, BroadcastTo, StridedSlice, Select, TopkExt,
-    SearchSorted, Meshgrid, Squeeze, Slice, TransposeExtView, MaskedScatter)
+    SearchSorted, Meshgrid, Squeeze, Slice, TransposeExtView)
 from .manually_defined import Rank, Shape, Tile, Cast, Ones, Zeros, TypeAs
 from ..auto_generate import ArgMaxWithValue, ArgMinWithValue
 from ..auto_generate import TensorScatterElements as TensorScatterElementsExt
@@ -1048,11 +1048,11 @@ class Fill(PrimitiveWithCheck):
         self.init_prim_io_names(inputs=['type', 'shape', 'value'], outputs=['y'])
 
     def __call__(self, dtype, dims, x):
-        if dtype not in mstype.all_types:
+        if dtype not in mstype.all_types and dtype not in [mstype.uint16, mstype.uint32, mstype.uint64]:
             raise TypeError(
                 f"For \'{self.name}\', the supported data type is ['bool', 'int8', 'int16', 'int32', 'int64', 'uint8', "
                 "'uint16', 'uint32', 'uint64','float16', 'float32', 'float64'], but got an invalid dtype!.")
-        x_nptype = mstype._dtype_to_nptype(dtype)  # pylint:disable=protected-access
+        x_nptype = mstype.dtype_to_nptype(dtype)
         if not isinstance(dims, Tensor) and not isinstance(dims, tuple):
             raise TypeError(f"For \'{self.name}\', input[1] must be tensor.")
         if not isinstance(x, Tensor) and not isinstance(x, float) and not isinstance(x, int):
@@ -1065,7 +1065,7 @@ class Fill(PrimitiveWithCheck):
         return Tensor(ret, dtype=dtype)
 
     def infer_value(self, dtype, dims, x):
-        x_nptype = mstype._dtype_to_nptype(dtype)  # pylint:disable=protected-access
+        x_nptype = mstype.dtype_to_nptype(dtype)
         if dims is not None and None not in dims and x is not None:
             if isinstance(dims, Tensor):
                 dims = dims.asnumpy()
@@ -3974,6 +3974,52 @@ class RangeV2(Primitive):
         validator.check_positive_int(maxlen, "maxlen", self.name)
 
 
+class MaskedScatter(Primitive):
+    """
+    Updates the value in the input with value in `updates` according to the `mask`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Inputs:
+        - **x** (Tensor): The input Tensor to be updated.
+        - **mask** (Tensor[bool]): The mask Tensor indicating which elements should be modified or replaced.
+          The shapes of `mask` and `x` must be the same or broadcastable.
+        - **updates** (Tensor): The values to scatter into the target tensor `x`. It has the same data type as `x`. The
+          number of elements must be greater than or equal to the number of True's in `mask`.
+
+    Outputs:
+        Tensor, with the same type and shape as `x`.
+
+    Raises:
+        TypeError: If `x`, `mask` or `updates` is not a Tensor.
+        TypeError: If data type of `x` is not be supported.
+        TypeError: If dtype of `mask` is not bool.
+        TypeError: If the dim of `x` less than the dim of `mask`.
+        ValueError: If `mask` can not be broadcastable to `x`.
+        ValueError: If the number of elements in `updates` is less than number of True's in `mask`.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input_x = Tensor(np.array([1., 2., 3., 4.]), mindspore.float32)
+        >>> mask = Tensor(np.array([True, True, False, True]), mindspore.bool_)
+        >>> updates = Tensor(np.array([5., 6., 7.]), mindspore.float32)
+        >>> output = ops.MaskedScatter()(input_x, mask, updates)
+        >>> print(output)
+        [5. 6. 3. 7.]
+    """
+
+    @prim_attr_register
+    def __init__(self):
+        """Initialize MaskedScatter"""
+        self.init_prim_io_names(inputs=['x', 'mask', 'updates'], outputs=['y'])
+
+
 class _TensorScatterOp(PrimitiveWithInfer):
     """
     Defines TensorScatter Base Operators

mindspore/ops/operations/comm_ops.py

@@ -18,9 +18,10 @@
 from __future__ import absolute_import
 from __future__ import division
 
+import os
 from mindspore.common import Tensor
 from mindspore import _checkparam as validator
-from mindspore.communication.management import get_rank, get_group_size, GlobalComm, _get_group
+from mindspore.communication.management import get_rank, get_group_size, GlobalComm, _get_group, _host_distribute
 from mindspore.common import dtype as mstype
 from mindspore.ops.primitive import PrimitiveWithInfer, PrimitiveWithCheck, Primitive, prim_attr_register
 from mindspore.common.api import context
@@ -97,6 +98,17 @@ def check_collective_target_dtype(data_name, data_dtype, prim_name):
     validator.check_tensor_dtype_valid(data_name, data_dtype, valid_dtype, prim_name)
 
 
+def check_hcom_group_valid(group, prim_name=None):
+    """Check if hcom group is valid."""
+    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
+    sim_level = os.getenv("MS_SIMULATION_LEVEL")
+    no_sim = (sim_level is None or sim_level.strip() == '')
+    if no_sim and (not _host_distribute()) and context.get_context("mode") == context.PYNATIVE_MODE and \
+            group != GlobalComm.WORLD_COMM_GROUP:
+        raise RuntimeError(f"{msg_prefix} 'group' only support 'hccl_world_group' in pynative mode, but got "
+                           f"'group': {group}. Please start by using mpi-run.")
+
+
 class AllReduce(Primitive):
     """
     Reduces tensors across all devices in such a way that all devices will get the same final result,
@@ -175,6 +187,7 @@ class AllReduce(Primitive):
         if not isinstance(self.group, str):
             raise TypeError(f"For '{self.name}', the 'group' must be str, "
                             f"but got {type(self.group).__name__}.")
+        check_hcom_group_valid(self.group, prim_name=self.name)
         self.op = op
         self.add_prim_attr('group', self.group)
         self.add_prim_attr('fusion', 0)
@@ -707,6 +720,7 @@ class Broadcast(PrimitiveWithInfer):
         """Initialize Broadcast."""
         validator.check_value_type('root_rank', root_rank, (int,), self.name)
         validator.check_value_type('group', _get_group(group), (str,), self.name)
+        check_hcom_group_valid(group, prim_name=self.name)
         self.add_prim_attr('group', _get_group(group))
         self.add_prim_attr('no_eliminate', True)
 

mindspore/ops/operations/custom_ops.py

@@ -1075,18 +1075,17 @@ class Custom(ops.PrimitiveWithInfer):
                 if isinstance(arg_dtype, mstype.TensorType):
                     arg_dtype = arg_dtype.element_type()
                 fake_arg = np.zeros(arg["shape"]).astype(
-                    mstype._dtype_to_nptype(arg_dtype))  # pylint:disable=protected-access
+                    mstype.dtype_to_nptype(arg_dtype))
                 fake_input.append(fake_arg)
 
         fake_output = self.func(*fake_input)
 
         if hasattr(fake_output, 'shape'):
             infer_shape = fake_output.shape
-            # pylint:disable=protected-access
-            infer_dtype = mstype.TensorType(mstype._pytype_to_dtype(fake_output.dtype))
+            infer_dtype = mstype.TensorType(mstype.pytype_to_dtype(fake_output.dtype))
         else:
             infer_shape = (1,)
-            infer_dtype = mstype._pytype_to_dtype(fake_output.dtype)  # pylint:disable=protected-access
+            infer_dtype = mstype.pytype_to_dtype(fake_output.dtype)
 
         infer_value = Tensor(fake_output) if enable_infer_value else None
 
@@ -1247,7 +1246,6 @@ class CustomOpBuilder:
         self.ldflags = ldflags
         self.build_dir = kwargs.get("build_dir")
         self.enable_atb = kwargs.get("enable_atb", False)
-        self.debug_mode = kwargs.get("debug_mode", False)
         self._ms_path = os.path.dirname(os.path.abspath(ms.__file__))
         if self.enable_atb:
             if backend is not None and backend != "Ascend":
@@ -1318,8 +1316,6 @@ class CustomOpBuilder:
         """
         flags = [f'-DMS_EXTENSION_NAME={self.name}', '-D_GLIBCXX_USE_CXX11_ABI=0', '-DENABLE_FAST_HASH_TABLE=1']
         flags += ['-std=c++17', '-fstack-protector-all', '-fPIC', '-pie']
-        if self.debug_mode:
-            flags.append('-g')
         if self.backend == "Ascend":
             flags.append('-DCUSTOM_ASCEND_OP')
             if self.enable_atb:
@@ -1336,9 +1332,7 @@ class CustomOpBuilder:
             list[str], A list of linker flags.
         """
         flags = ['-shared']
-        flags += ['-Wl,-z,relro,-z,now,-z,noexecstack', '-Wl,--disable-new-dtags,--rpath']
-        if not self.debug_mode:
-            flags.append('-s')  # strip
+        flags += ['-Wl,-z,relro,-z,now,-z,noexecstack', '-Wl,--disable-new-dtags,--rpath', '-s']
         flags += [
             f"-L{os.path.abspath(os.path.join(self._ms_path, 'lib'))}",
             '-lmindspore_core',

mindspore/ops/operations/debug_ops.py

@@ -309,8 +309,6 @@ class TensorDump(Primitive):
         """Initialize TensorDump."""
         if security.enable_security():
             raise ValueError('The TensorDump is not supported, please without `-s on` and recompile source.')
-        if input_output not in ['in', 'out']:
-            raise ValueError(f"The 'input_output' argument should be one of ['in', 'out'], but got: {input_output}")
         self.add_prim_attr("side_effect_io", True)
         self.add_prim_attr("channel_name", "ms_tensor_dump")
 
@@ -503,11 +501,13 @@ class DumpGradient(Primitive):
     def __init__(self):
         pass
 
+    def _dump_hook(self, dout):
+        P.TensorDump()(self.bwd_dump_path, dout)
+        return dout
+
     def __call__(self, path, x, input_output):
-        def _dump_hook(dout):
-            P.TensorDump()(path, dout)
-            return dout
-        x = P.InsertGradientOf(_dump_hook)(x)
+        self.bwd_dump_path = path
+        x = P.InsertGradientOf(self._dump_hook)(x)
         return x
 
 

mindspore/ops/operations/manually_defined/ops_def.py

@@ -977,7 +977,7 @@ class ScalarToTensor(PrimitiveWithInfer):
     def __call__(self, x, dtype=mstype.float32):
         validator.check_value_type("x", x, [bool, int, float], self.name)
         validator.check_subclass("dtype", dtype, mstype.number, self.name)
-        data_type = mstype._dtype_to_nptype(dtype)  # pylint:disable=protected-access
+        data_type = mstype.dtype_to_nptype(dtype)
         return Tensor(np.array(x, data_type), dtype=dtype)
 
 
@@ -1149,7 +1149,7 @@ def scalar_cast(input_x, input_y):
     Args:
         input_x (scalar): The input scalar.
         input_y (mindspore.dtype): The type to be cast. Only constant value is allowed.
-            The value should only be mindspore.int64, mindspore.float64, or mindspore.bool.
+            The value should only be mindspore.int64, mindspore.float64, or mindspore.bool\_.
 
     Returns:
         Scalar, the type is the same as the python type corresponding to `input_y`.
@@ -1714,7 +1714,7 @@ def infer_value_for_Arange(start, end, step, dtype=None):
         if has_float:
             np_dtype = np.float32
     else:
-        np_dtype = mstype._dtype_to_nptype(typing.type_id_to_type(dtype))  # pylint:disable=protected-access
+        np_dtype = mstype.dtype_to_nptype(typing.type_id_to_type(dtype))
     return Tensor(np.arange(start, end, step, dtype=np_dtype))
 
 
@@ -1738,7 +1738,7 @@ def _infer_value_for_ReduceExtand(input_x, axis, keep_dims, dtype, prim_name):
             else:
                 axis = tuple(range(len(value.shape)))
             if dtype is not None:
-                np_dtype = mstype._dtype_to_nptype(typing.type_id_to_type(dtype))  # pylint:disable=protected-access
+                np_dtype = mstype.dtype_to_nptype(typing.type_id_to_type(dtype))
                 value = np_reduce_extand_func(value, axis, dtype=np_dtype, keepdims=keep_dims)
             else:
                 value = np_reduce_extand_func(value, axis, keepdims=keep_dims)
@@ -1771,7 +1771,7 @@ def infer_value_for_Cast(x, dst_type_enum=None):
     if x is None or dst_type_enum is None:
         return None
     dst_type = typing.type_id_to_type(dst_type_enum)
-    src_type = mstype._get_py_obj_dtype(x)  # pylint:disable=protected-access
+    src_type = mstype.get_py_obj_dtype(x)
     validator.check_subclass("input_x", src_type, [mstype.tensor_type, mstype.number], "Cast")
     validator.check_subclass("type", dst_type, mstype.number, "Cast")
 
@@ -1781,7 +1781,7 @@ def infer_value_for_Cast(x, dst_type_enum=None):
         dst_type = dst_type.element_type()
 
     value = None
-    np_dst_type = mstype._dtype_to_nptype(dst_type)  # pylint:disable=protected-access
+    np_dst_type = mstype.dtype_to_nptype(dst_type)
     if isinstance(x, (int, float)):
         value = Tensor(np.array(x).astype(np_dst_type), dtype=dst_type)
     else:
@@ -2839,8 +2839,8 @@ class WhileLoop(Primitive):
             while cond_func(val):
                 val = loop_func(val)
         except Exception as e:
-            raise ValueError(f"Invalid loop_func, please check input arguments and "
-                             f"return value, error info: {e}")
+            raise ValueError("Invalid loop_func, please check input arguments and \
+                             return value, error info: {}".format(e))
         return val
 
 
@@ -2935,8 +2935,8 @@ class Scan(Primitive):
                 ys.append(y)
                 i = i + 1
         except Exception as e:
-            raise ValueError(f"Invalid loop_func, please check input arguments and "
-                             f"return value, error info: {e}")
+            raise ValueError("Invalid loop_func, please check input arguments and \
+                             return value, error info: {}".format(e))
         return carry, ys
 
 
@@ -3011,6 +3011,6 @@ class ForiLoop(Primitive):
             for i in range(lower, upper):
                 val = loop_func(i, val)
         except Exception as e:
-            raise ValueError(f"Invalid loop_func, please check input arguments and "
-                             f"return value, error info: {e}")
+            raise ValueError("Invalid loop_func, please check input arguments and \
+                             return value, error info: {}".format(e))
         return val

mindspore/ops/operations/math_ops.py

@@ -882,7 +882,7 @@ class Sub(_MathBinaryOp):
     Note:
         - When the two inputs have different shapes, they must be able to broadcast to a common shape.
         - The two inputs can not be bool type at the same time,
-          [True, Tensor(True), Tensor(np.array([True]))] are all considered bool type.
+          [True, Tensor(True, bool\_), Tensor(np.array([True]), bool\_)] are all considered bool type.
         - The two inputs comply with the implicit type conversion rules to make the data types
           consistent.
 
@@ -890,7 +890,7 @@ class Sub(_MathBinaryOp):
         - **x** (Union[Tensor, number.Number, bool]) - The first input is a number.Number or
           a bool or a tensor whose data type is
           `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-          `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+          `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         - **y** (Union[Tensor, number.Number, bool]) - The second input, when the first input is a Tensor,
           the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool.
 
@@ -1289,10 +1289,10 @@ class DivNoNan(Primitive):
         - **x1** (Union[Tensor, number.Number, bool]) - The first input is a number.Number or
           a bool or a tensor whose data type is
           `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-          `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+          `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         - **x2** (Union[Tensor, number.Number, bool]) - The second input is a number.Number or
-          a bool when the first input is a bool or a tensor whose data type is number or bool.
-          When the first input is Scalar, the second input must be a Tensor whose data type is number or bool.
+          a bool when the first input is a bool or a tensor whose data type is number or bool\_.
+          When the first input is Scalar, the second input must be a Tensor whose data type is number or bool\_.
 
     Outputs:
         Tensor, the shape is the same as the one after broadcasting,

mindspore/ops/operations/nn_ops.py

@@ -41,7 +41,7 @@ from ..auto_generate import (CeLU, Flatten, LogSoftmax, LogSoftmaxExt, GLU, ReLU
                              UpsampleNearest3D, UpsampleTrilinear3D,
                              SoftMarginLoss, UpsampleBilinear2D, UpsampleLinear1D,
                              BinaryCrossEntropy, BCEWithLogitsLoss, SoftShrink, AdaptiveMaxPool2D,
-                             SmoothL1Loss, KvScaleCache)
+                             SmoothL1Loss)
 from .manually_defined import BatchNorm
 
 

mindspore/ops/primitive.py

@@ -458,7 +458,7 @@ class Primitive(Primitive_):
 
             - If the computation involves something like randomization or global variable, the equivalence
               is not guaranteed currently.
-            - Should only be used in Graph mode or in gradient functions that are decorated by @jit.
+            - Not supported in pynative mode
 
         Args:
             mode (bool): Specifies whether the primitive is recomputed. Default: ``True`` .
@@ -466,7 +466,7 @@ class Primitive(Primitive_):
         Examples:
             >>> import numpy as np
             >>> import mindspore as ms
-            >>> from mindspore import Tensor, ops, nn, jit
+            >>> from mindspore import Tensor, ops, nn
             >>> class NetRecompute(nn.Cell):
             ...     def __init__(self):
             ...         super(NetRecompute,self).__init__()
@@ -481,7 +481,6 @@ class Primitive(Primitive_):
             ...         super(GradNet,self).__init__()
             ...         self.network = network
             ...         self.grad = ops.GradOperation()
-            ...     @jit
             ...     def construct(self, x):
             ...         g_out = self.grad(self.network)(x)
             ...         return g_out
@@ -493,6 +492,8 @@ class Primitive(Primitive_):
             >>> print(a)
             [0. 0.5]
         """
+        if context.get_context("mode") == context.PYNATIVE_MODE:
+            raise TypeError("Recompute is not supported in pynative mode currently.")
         Validator.check_bool(mode)
         self.add_prim_attr("recompute", mode)
         return self
@@ -509,6 +510,8 @@ class Primitive(Primitive_):
         Args:
             backward_prefetch(Union[str, int]): Specifies whether the activation is prefetched in backward pass.
         """
+        if context.get_context("mode") == context.PYNATIVE_MODE:
+            raise ValueError("Offload is not supported in pynative mode currently.")
         self.add_prim_attr("offload", True)
         if isinstance(backward_prefetch, str):
             Validator.check_string(backward_prefetch, ['Auto'], 'backward_prefetch', 'Primitive._offload')
@@ -548,6 +551,10 @@ class Primitive(Primitive_):
         Validator.check_non_negative_int(rank_id, "rank_id", "Primitive.place")
         Validator.check_string(role, "MS_WORKER", "role", "Primitive.place")
 
+        if context.get_context("mode") == context.PYNATIVE_MODE:
+            raise RuntimeError("You are calling Primitive.place in pynative mode."
+                               "It's only supported in graph mode. Please switch to graph mode.")
+
         # Get the execution context and check whether calling of this 'place' method is valid.
         # This is because placing operators to arbitrary processes while other distributed training mode
         # is enabled is very unpredictable and may cause fatal error.

mindspore/ops/tensor_method.py

@@ -24,7 +24,8 @@ from mindspore.ops.composite.multitype_ops._compile_utils import (
     sequence_to_tensor, _tensor_sub, _tensor_pow, _tensor_div, _tensor_floordiv, _tensor_mod
 )
 from mindspore.ops.auto_generate.gen_ops_prim import (
-    inplace_scatter_src_op, inplace_scatter_src_reduce_op, inplace_scatter_value_op, inplace_scatter_value_reduce_op
+    inplace_scatter_src_op, inplace_scatter_src_reduce_op, inplace_scatter_value_op, inplace_scatter_value_reduce_op,
+    inplace_copy_op
 )
 from mindspore.ops.auto_generate.gen_ops_prim import (
     floor_div_op, floor_div_scalar_op
@@ -441,9 +442,6 @@ from mindspore.ops.auto_generate.gen_ops_prim import inplace_exp_op
 # 1030 log_
 from mindspore.ops.auto_generate.gen_ops_prim import inplace_log_op
 
-# 1031 masked_scatter
-from mindspore.ops.auto_generate import masked_scatter
-
 from .._checkparam import check_axis_in_range
 from ..ops.composite.multitype_ops import _compile_utils as compile_utils
 
@@ -1455,10 +1453,14 @@ def tensor_atanh(input):
     return F.atanh(input)
 
 
-def tensor_copy_(input, src, non_blocking=False):
+def tensor_copy_(input, src):
     raise ValueError("should not come here for copy_ method")
 
 
+def deprecated_tensor_copy_(input, src, non_blocking=False):
+    return inplace_copy_op(input, src)
+
+
 def tensor_tan(input):
     return F.tan(input)
 
@@ -1862,10 +1864,6 @@ def conv3d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1):
     raise NotImplementedError('conv3d only supports Ascend.')
 
 
-def tensor_remainder_(input, other):
-    return _tensor_mod(input, other)
-
-
 def tensor_floor_divide_(input, other):
     return _tensor_floordiv(input, other)
 
@@ -1910,10 +1908,6 @@ def tensor_gelu(input, *, approximate):
     return gelu(input, approximate)
 
 
-def tensor_bernoulli_(input, p, seed, offset):
-    raise RuntimeError("'bernoulli_' is not supported on this device.")
-
-
 def deprecated_pixel_shuffle(input, upscale_factor):
     return F.pixel_shuffle(input, upscale_factor)
 
@@ -1931,6 +1925,3 @@ def tensor_gmm(x, weight, *, bias=None, group_list=None, group_type=0, group_lis
 
 def raise_func(*args, **kwargs):
     raise NotImplementedError("this func has not been implemented.")
-
-def tensor_masked_scatter(input, mask, source):
-    return masked_scatter(input, mask, source)

mindspore/ops_generate/pyboost/gen_pyboost_func.py

@@ -16,6 +16,9 @@
 Generate pyboost function from pyboost_op.yaml
 """
 
+import os
+import shutil
+import logging
 from resources.resource_list import ResourceType
 from common import gen_constants as K
 from api.functions_cc_generator import FunctionsGenerator, FunctionsHeaderGenerator
@@ -45,6 +48,18 @@ from .auto_grad_impl_cc_generator import AutoGradImplGenerator
 from .auto_grad_reg_cc_generator import AutoGradRegHeaderGenerator
 
 
+def clear_old_generated_code(work_path):
+    """ delete old generated files to prevent compilation failure """
+    files_to_clear = ['mindspore/ops/kernel/common/pyboost',
+                      'mindspore/ops/kernel/functions/auto_generate',
+                      'mindspore/ccsrc/runtime/pynative/op_function']
+    for f in files_to_clear:
+        real_path = os.path.join(work_path, f)
+        if os.path.exists(real_path):
+            shutil.rmtree(real_path)
+            logging.warning("rm file %s", real_path)
+
+
 def gen_pyboost_code(resource_mgr):
     """ gen_pyboost_code """
     work_path = K.WORK_DIR
@@ -52,6 +67,7 @@ def gen_pyboost_code(resource_mgr):
     doc_yaml_data = resource_mgr.get_resource(ResourceType.OP_DOC_YAML)
     mint_func_protos = resource_mgr.get_resource(ResourceType.MINT_FUNC_PROTOS)
     alias_func_mapping = resource_mgr.get_resource(ResourceType.ALIAS_API_MAPPING)
+    clear_old_generated_code(work_path)
     call_pyboost_inner_prim_generator(work_path, op_protos)
     call_pyboost_functions_py_generator(work_path, op_protos, doc_yaml_data)
     call_pyboost_functions_h_generator(work_path, op_protos)

mindspore/parallel/_auto_parallel_context.py

@@ -81,7 +81,6 @@ class _PipelineScheduler:
     PIPELINE_SEQPIPE = "seqpipe"
     PIPELINE_SEQVPP = "seqvpp"
     PIPELINE_SEQSMARTVPP = "seqsmartvpp"
-    PIPELINE_ZBV = "zero_bubble_v"
 
 
 class _AutoParallelContext:
@@ -435,6 +434,13 @@ class _AutoParallelContext:
         """
         self.check_context_handle()
         run_mode = context.get_context("mode")
+        if run_mode == context.PYNATIVE_MODE and parallel_mode not in (
+                context.ParallelMode.DATA_PARALLEL, context.ParallelMode.STAND_ALONE,
+                context.ParallelMode.AUTO_PARALLEL):
+            raise ValueError(f"Pynative only supports STAND_ALONE, DATA_PARALLEL and AUTO_PARALLEL using"
+                             f" sharding_propagation under shard function"
+                             f" for ParallelMode, "
+                             f"but got {parallel_mode.upper()}.")
         ret = self._context_handle.set_parallel_mode(parallel_mode)
         if ret is False:
             raise ValueError("The context configuration parameter 'parallel_mode' only support 'stand_alone', "
@@ -598,6 +604,9 @@ class _AutoParallelContext:
                 if not isinstance(dim, int):
                     raise TypeError("For 'set_auto_parallel_context', the element of argument "
                                     "'dataset_strategy' must be int type, but got the type : {} .".format(type(dim)))
+        if context.get_context('mode') == context.PYNATIVE_MODE:
+            raise ValueError("In PyNative mode, the setting value of 'dataset_strategy' must be either 'full_batch' "
+                             f"or 'data_parallel', but got {dataset_strategy}.")
         self._dataset_strategy_using_str = False
         self._context_handle.set_dataset_strategy(dataset_strategy)
 
@@ -637,6 +646,9 @@ class _AutoParallelContext:
                 return "full_batch"
             return "data_parallel"
         dataset_strategy = self._context_handle.get_dataset_strategy()
+        if context.get_context('mode') == context.PYNATIVE_MODE:
+            raise ValueError("In PyNative mode, the value of 'dataset_strategy' must be either 'full_batch' "
+                             f"or 'data_parallel', but got the setting value is {dataset_strategy}.")
         return dataset_strategy
 
     def set_grad_accumulation_step(self, grad_accumulation_step):
@@ -650,7 +662,7 @@ class _AutoParallelContext:
             raise ValueError("The interface is deprecated. To use gradient accumulation, "
                              "please use GradAccumulationCell in mindspore.nn.wrap.cell_wrapper.")
         self.check_context_handle()
-        Validator.check_positive_int(grad_accumulation_step, prim_name='grad_accumulation_step')
+        Validator.check_positive_int(grad_accumulation_step)
         self._context_handle.set_grad_accumulation_step(grad_accumulation_step)
 
     def get_grad_accumulation_step(self):
@@ -986,8 +998,6 @@ class _AutoParallelContext:
                                                                _PipelineScheduler.PIPELINE_GPIPE,
                                                                _PipelineScheduler.PIPELINE_SEQPIPE,
                                                                _PipelineScheduler.PIPELINE_SEQVPP,
-                                                               _PipelineScheduler.PIPELINE_SEQSMARTVPP,
-                                                               _PipelineScheduler.PIPELINE_ZBV,
                                                                _PipelineScheduler.PIPELINE_SEQSMARTVPP])
         scheduler_val = pipeline_config[pp_scheduler]
         if not pipeline_config[pp_interleave] and scheduler_val != _PipelineScheduler.PIPELINE_1F1B:
@@ -1062,7 +1072,7 @@ class _AutoParallelContext:
 
         if threshold_name in parallel_optimizer_config:
             Validator.check_non_negative_int(
-                parallel_optimizer_config[threshold_name], prim_name=threshold_name)
+                parallel_optimizer_config[threshold_name])
             self._context_handle.set_parallel_optimizer_threshold(
                 parallel_optimizer_config[threshold_name])
 

mindspore/parallel/_parallel_serialization.py

@@ -144,7 +144,8 @@ def _build_protobuf_strategy(strategy_filename):
     parallel_strategy_map = _load_protobuf_strategy(strategy_filename)
     layout_items = parallel_strategy_map.parallel_layout_item
     if not layout_items:
-        return {}
+        raise ValueError(f"For 'build_searched_strategy', the strategy file {strategy_filename} has no sliced "
+                         f"parameter, please check whether the 'strategy_filename' is correct.")
 
     strategy = {}
     for layout_item in layout_items:
@@ -158,8 +159,6 @@ def _build_json_strategy(strategy_filename):
     """build strategy from json file"""
     with open(strategy_filename, 'r') as f:
         json_content = json.load(f)
-    if "parallel_layout_item" not in json_content:
-        return {}
     layout_items = json_content.get("parallel_layout_item")
     strategy = {}
     for parameter_name, layout_item in layout_items.items():

mindspore/parallel/_ps_context.py

@@ -114,8 +114,8 @@ def _set_ps_context(**kwargs):
                           Default: ``False``.
         config_file_path (str): Configuration file path used by recovery. Default: ''.
         enable_ssl (bool): Set PS SSL mode enabled or disabled. Default: ``False``.
-                           When set to False, users need to review and confirm the security of network environment
-                           where the distributed job is located.
+                           There might be risk when this is set to False.
+                           It is user's responsibility to ensure the network environment is safe.
         client_password (str): Password to decrypt the secret key stored in the client certificate. Default: ''.
         server_password (str): Password to decrypt the secret key stored in the server certificate. Default: ''.