mindspore 2.5.0__cp310-cp310-win_amd64.whl → 2.6.0rc1__cp310-cp310-win_amd64.whl

mindspore/ops/operations/custom_ops.py

@@ -29,7 +29,6 @@ import numpy as np
 import mindspore as ms
 from mindspore._c_expression import Oplib, typing
 from mindspore._c_expression import pyboost_custom_ext
-from mindspore.common._stub_tensor import _convert_stub
 from mindspore import context
 from mindspore.common import Tensor
 from mindspore.common import dtype as mstype
@@ -40,6 +39,7 @@ from mindspore.communication.management import get_rank, GlobalComm
 from ._ms_kernel import determine_variable_usage
 from ._custom_grad import autodiff_bprop
 from ._pyfunc_registry import add_pyfunc
+from ._custom_ops_utils import ExtensionBuilder
 
 if platform.system() != "Windows":
     import fcntl
@@ -183,10 +183,16 @@ class _CustomExt(ops.PrimitiveWithInfer):
 
         infer_value = None
         if infer_shape is None:
-            logger.warning("'out_shape' is None. Add a placeholder instead. "
-                           "A CPP version of infer shape function is required "
-                           "in this case.")
+            logger.debug("'out_shape' is None. Add a placeholder instead. "
+                         "A CPP version of infer shape function is required "
+                         "in this case.")
             infer_shape = (1,)
+        if infer_dtype is None:
+            logger.debug("'out_dtype' is None. Add a placeholder instead. "
+                         "A CPP version of infer type function is required "
+                         "in this case.")
+            infer_dtype = ms.float16
+
         # after all automatic infer information fulfillment, throw error if infer_shape/infer_dtype is still None
         if not isinstance(infer_shape, (tuple, list)):
             raise TypeError("'out_shape' must be one of [tuple, list, function], but got {}".format(type(infer_shape)))
@@ -215,7 +221,7 @@ class Custom(ops.PrimitiveWithInfer):
     function if needed. Then these `Custom` objects can be directly used in neural networks.
     Detailed description and introduction of user-defined operators, including correct writing of parameters,
     please refer to `Custom Operators Tutorial
-    <https://www.mindspore.cn/docs/en/master/model_train/custom_program/op_custom.html>`_ .
+    <https://www.mindspore.cn/tutorials/en/master/custom_program/op_custom.html>`_ .
 
     .. warning::
         - This is an experimental API that is subject to change.
@@ -297,14 +303,17 @@ class Custom(ops.PrimitiveWithInfer):
                  b) Ascend platform.
                  Before using Custom operators on the Ascend platform, users must first develop custom operators
                  based on Ascend C and compile them. The complete development and usage process can refer to the
-                 tutorial `AOT-Type Custom Operators(Ascend) <https://www.mindspore.cn/docs/en/master/model_train/custom_program/operation/op_custom_ascendc.html>`_.
+                 tutorial `AOT-Type Custom Operators(Ascend)
+                 <https://www.mindspore.cn/tutorials/en/master/custom_program/operation/op_custom_ascendc.html>`_.
                  By passing the name of the operator through the input parameter `func`, there are two usage methods
-                 based on the implementation of the infer shape function:
-
-                 - Python infer: If the operator's infer shape is implemented in Python, that is, the infer shape
-                   function is passed through the `out_shape` parameter, specify `func="CustomName"` .
-                 - C++ infer: If the operator's infer shape is implemented through C++, then pass the path of the
-                   infer shape implementation file in `func` and separate the operator name with `:`,
+                 based on the implementation of the infer function:
+
+                 - Python infer: If the operator's infer function is implemented in Python, that is, the infer shape
+                   function is passed through the `out_shape` parameter, and the infer type is passed throuht the
+                   `out_dtype`, then the `func` should be specified as the operator name, for example,
+                   `func="CustomName"`.
+                 - C++ infer: If the operator's infer function is implemented through C++, then pass the path of the
+                   infer function implementation file in `func` and separate the operator name with `:`,
                    for example: `func="add_custom_infer.cc:AddCustom"` .
 
               2. for "julia":
@@ -425,6 +434,7 @@ class Custom(ops.PrimitiveWithInfer):
         self._func_compile_attrs = {}
         self._is_ms_kernel = False
         self.out_shape = out_shape
+        self.out_dtype = out_dtype
 
         self._check_platform()
         self._check_func()
@@ -442,13 +452,17 @@ class Custom(ops.PrimitiveWithInfer):
 
         if self.out_shape is None and self.func_type == "aot":
             self.add_prim_attr("cpp_infer_shape", True)
-        self.out_dtype = out_dtype
+        if self.out_dtype is None and self.func_type == "aot":
+            self.add_prim_attr("cpp_infer_type", True)
+        self.multi_output = (reg_info is not None and (len(reg_info.get("outputs", [])) > 1))
+        self.add_prim_attr("multi_output", self.multi_output)
+
         self.bprop = bprop
         self.fake_output = False
         self.single_scalar_output = False
-        if not self.out_dtype:
+        if not self.out_dtype and not self.func_type == "pyfunc":
             self.fake_output = True
-        elif not self.out_shape:
+        elif not self.out_shape and self.func_type == "pyfunc":
             self.single_scalar_output = True
         self.add_prim_attr("fake_output", self.fake_output)
         self.add_prim_attr("single_scalar_output", self.single_scalar_output)
@@ -464,10 +478,10 @@ class Custom(ops.PrimitiveWithInfer):
 
         self.add_prim_attr("func_type", self.func_type)
         self._update_attr()
-        self.enable_pyboost = False
-        self.custom_pyboost = _CustomExt(self.func, self.out_shape, self.out_dtype, self.bprop)
-        if context.get_context("device_target") == "Ascend" and self.func_type == "aot":
-            self.enable_pyboost = True
+
+        self.enable_pyboost = (context.get_context("device_target") == "Ascend" and self.func_type == "aot")
+        if self.enable_pyboost:
+            self.custom_pyboost = _CustomExt(self.func, self.out_shape, self.out_dtype, self.bprop)
             for key, value in super().get_attr_dict().items():
                 self.custom_pyboost.add_prim_attr(key, value)
 
@@ -510,10 +524,15 @@ class Custom(ops.PrimitiveWithInfer):
                 infer_dtype = mstype.int32
         if self.func_type == "aot":
             if infer_shape is None:
-                logger.warning("{}, 'out_shape' is None. Add a placeholder instead. "
-                               "A CPP version of infer shape function is required "
-                               "in this case.".format(self.log_prefix))
+                logger.debug("{}, 'out_shape' is None. Add a placeholder instead. "
+                             "A CPP version of infer shape function is required "
+                             "in this case.".format(self.log_prefix))
                 infer_shape = (1,)
+            if infer_dtype is None:
+                logger.debug("{}, 'out_dtype' is None. Add a placeholder instead. "
+                             "A CPP version of infer type function is required "
+                             "in this case.".format(self.log_prefix))
+                infer_dtype = ms.float16
         # after all automatic infer information fulfillment, throw error if infer_shape/infer_dtype is still None
         if not isinstance(infer_shape, (tuple, list)):
             raise TypeError("{}, 'out_shape' must be one of [tuple, list, function], but got {}"
@@ -1079,9 +1098,188 @@ class Custom(ops.PrimitiveWithInfer):
 
     def __call__(self, *args):
         if self.enable_pyboost:
-            return _convert_stub(pyboost_custom_ext(self.custom_pyboost, [args]))
+            res = pyboost_custom_ext(self.custom_pyboost, [args])
+            return res if self.multi_output else res[0]
         should_elim, output = self.check_elim(*args)
         if should_elim:
             return output
         # pylint: disable=protected-access
         return ops.primitive._run_op(self, self.name, args)
+
+
+class CustomOpBuilder:
+    r"""
+    CustomOpBuilder is used to initialize and configure custom operators for MindSpore.
+    Users can define and load custom operator modules through this class and apply them to the network.
+
+    In most cases, users only need to provide the source files and additional compilation options in the constructor
+    and call the `load` method to complete the compilation and loading of the operator.
+    If users have specific customization requirements, they can inherit this class and override certain methods.
+    It is important to note that if methods are overridden, some parameters passed to the constructor may be ignored.
+
+    .. warning::
+        This is an experimental API that is subject to change.
+
+    Args:
+        name (str): The unique name of the custom operator module, used to identify the operator.
+        sources (Union[str, list[str]]): The source file(s) of the custom operator. It can be a single file path or
+                                    a list of file paths.
+        backend (str, optional): The target backend for the operator, such as "CPU" or "Ascend". Default: ``None``.
+        include_paths (list[str], optional): Additionally included paths needed during compilation. Default: ``None``.
+        cflags (str, optional): Extra C++ compiler flags to be used during compilation. Default: ``None``.
+        ldflags (str, optional): Extra linker flags to be used during linking. Default: ``None``.
+        kwargs (dict, optional): Additional keyword arguments for future extensions or specific custom requirements.
+
+    .. note::
+        - If the `backend` argument is provided, additional default flags will be automatically added to
+          the compilation and linking steps to support the operator's target backend. The default options
+          can be referenced in the implementation of the `get_cflags` and `get_ldflags` methods in the `CustomOpBuilder
+          <https://gitee.com/mindspore/mindspore/blob/master/mindspore/python/mindspore/ops/operations/custom_ops.py>`_.
+        - The `sources` argument must point to valid source files for the custom operator.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> from mindspore import ops
+        >>> builder = ops.CustomOpBuilder(
+        ...     name="custom_op_cpu",
+        ...     sources="custom_ops_impl/pybind_op_cpu.cpp",
+        ...     backend="CPU"
+        ... )
+        >>> my_ops = builder.load()
+    """
+    _mindspore_path = None
+    _loaded_ops = {}
+    _ms_code_base = None
+
+    def __init__(self, name, sources, backend=None, include_paths=None, cflags=None, ldflags=None, **kwargs):
+        self.name = name
+        self.source = sources
+        self.backend = backend
+        self.include_paths = include_paths
+        self.cflags = cflags
+        self.ldflags = ldflags
+        if CustomOpBuilder._mindspore_path is None:
+            CustomOpBuilder._mindspore_path = os.path.dirname(os.path.abspath(ms.__file__))
+            CustomOpBuilder._ms_code_base = os.path.join(CustomOpBuilder._mindspore_path, "include")
+        if self.backend == "Ascend":
+            self.ascend_cann_path = os.getenv("ASCEND_OPP_PATH").split('opp')[0]
+
+    def get_sources(self):
+        """
+        Get the source files for the custom operator.
+
+        Returns:
+            str or list[str], The source file(s) for the operator.
+        """
+        return self.source
+
+    def get_include_paths(self):
+        """
+        Get the include paths required for compiling the custom operator.
+
+        Returns:
+            list[str], A list of include paths.
+        """
+        include_list = self.include_paths if self.include_paths is not None else []
+        include_list.append(CustomOpBuilder._mindspore_path)
+        include_list.append(os.path.join(CustomOpBuilder._mindspore_path, "include"))
+        include_list.append(os.path.join(CustomOpBuilder._mindspore_path, "include/third_party"))
+        include_list.append(os.path.join(CustomOpBuilder._mindspore_path, "include/third_party/robin_hood_hashing"))
+        include_list.append(os.path.join(CustomOpBuilder._mindspore_path, "include/third_party/securec/include"))
+
+        if self.backend == "Ascend":
+            include_list.append(os.path.join(self.ascend_cann_path, "include"))
+        include_list += self._get_ms_inner_includes()
+        return include_list
+
+    def _get_ms_inner_includes(self):
+        """include paths for inner module interface."""
+        ms_inner_code_base = os.path.join(CustomOpBuilder._mindspore_path, "include", "mindspore")
+        include_list = []
+        include_list.append(ms_inner_code_base + "/core/include")
+        include_list.append(ms_inner_code_base + "/core/mindrt/include")
+        include_list.append(ms_inner_code_base + "/core/mindrt")
+        include_list.append(ms_inner_code_base + "/ops")
+        include_list.append(ms_inner_code_base + "/ops/kernel/include")
+        include_list.append(ms_inner_code_base + "/ccsrc")
+        include_list.append(ms_inner_code_base + "/ccsrc/include")
+        include_list.append(ms_inner_code_base + "/ccsrc/minddata/mindrecord/include")
+        return include_list
+
+    def get_cflags(self):
+        """
+        Get the C++ compiler flags for building the custom operator.
+
+        Returns:
+            list[str], A list of C++ compiler flags.
+        """
+        flags = ['-fstack-protector-all', '-fPIC', '-pie']
+        flags += ['-DENABLE_FAST_HASH_TABLE=1']
+        if self.backend == "Ascend":
+            flags.append('-DCUSTOM_ASCEND_OP')
+        if self.cflags is not None:
+            flags.append(self.cflags)
+        return flags
+
+    def get_ldflags(self):
+        """
+        Get the linker flags for building the custom operator.
+
+        Returns:
+            list[str], A list of linker flags.
+        """
+        flags = ['-Wl,-z,relro,-z,now,-z,noexecstack', '-Wl,--disable-new-dtags,--rpath', '-s']
+        flags += [
+            '-L' + os.path.abspath(os.path.join(CustomOpBuilder._mindspore_path, 'lib')),
+            '-lmindspore_core',
+            '-lmindspore_ms_backend',
+            '-lmindspore_pynative'
+        ]
+        if self.backend == "Ascend":
+            flags.append('-L' + os.path.abspath(os.path.join(CustomOpBuilder._mindspore_path, 'lib/plugin')))
+            flags.append('-L' + os.path.abspath(os.path.join(self.ascend_cann_path, "lib64")))
+            flags.append('-lascendcl')
+            flags.append('-l:libmindspore_ascend.so.2')
+        if self.ldflags is not None:
+            flags.append(self.ldflags)
+        return flags
+
+    def build(self):
+        """
+        Build the custom operator module.
+
+        This method generates a dynamic library file for the custom operator based on the provided source files,
+        include paths, compilation flags, and link flags.
+
+        Returns:
+            str, The path to the compiled module.
+        """
+        return ExtensionBuilder().build(
+            module_name=self.name,
+            sources=self.get_sources(),
+            extra_include_paths=self.get_include_paths(),
+            extra_cflags=self.get_cflags(),
+            extra_ldflags=self.get_ldflags())
+
+    def load(self):
+        """
+        Build and load the custom operator module.
+
+        Returns:
+            Module, The loaded custom operator module.
+        """
+        if self.name in CustomOpBuilder._loaded_ops:
+            return CustomOpBuilder._loaded_ops[self.name]
+        module_path = self.build()
+        mod = self._import_module(module_path)
+        CustomOpBuilder._loaded_ops[self.name] = mod
+        return mod
+
+    def _import_module(self, module_path):
+        """Import module from library."""
+        spec = importlib.util.spec_from_file_location(self.name, module_path)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        return module

mindspore/ops/operations/debug_ops.py

@@ -19,12 +19,13 @@ from pathlib import Path
 import numpy as np
 from mindspore import log as logger
 from mindspore._c_expression import security, HookType
-from mindspore._c_expression import Tensor as Tensor_
+from mindspore._c_expression import TensorPy as Tensor_
 from mindspore._c_expression import _tensordump_process_file
 from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
 from mindspore.common.parameter import Parameter
 from mindspore.common.tensor import Tensor
+from mindspore.common.jit_context import jit_context
 from mindspore.ops.primitive import prim_attr_register, Primitive, PrimitiveWithInfer
 from mindspore._checkparam import check_hook_fn
 from mindspore.ops import operations as P
@@ -62,9 +63,7 @@ class ScalarSummary(Primitive):
     """
     This operator will put a scalar to a summary file with protocol buffer format.
     It must be used with :class:`mindspore.SummaryRecord` or :class:`mindspore.SummaryCollector`,
-    which specify the directory of the summary file. The summary file can
-    be loaded and shown by MindInsight, see `MindInsight documents <https://www.mindspore.cn/
-    mindinsight/docs/en/master/index.html>`_ for details.
+    which specify the directory of the summary file.
     In Ascend platform with graph mode, the environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
     can be set to solve operator execution failure when calling this operator intensively.
 
@@ -122,11 +121,9 @@ class ScalarSummary(Primitive):
 class ImageSummary(Primitive):
     """
     This operator will put an image tensor to a summary file with protocol buffer format. It must be used with
-    SummaryRecord or SummaryCollector, which specify the directory of the summary file. The summary file can
-    be loaded and shown by MindInsight, see `MindInsight documents <https://www.mindspore.cn/
-    mindinsight/docs/en/master/index.html>`_ for details.
+    SummaryRecord or SummaryCollector, which specify the directory of the summary file.
     In Ascend platform with graph mode, the environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
-    can be set to solve operator execution failure when calling this operator intensively.
+    can be set to solve execution failure when calling this operator intensively.
 
     Inputs:
         - **name** (str) - The name of the input variable, it must not be an empty string.
@@ -175,9 +172,7 @@ class ImageSummary(Primitive):
 class TensorSummary(Primitive):
     """
     This operator will put a tensor to a summary file with protocol buffer format. It must be used with SummaryRecord
-    or SummaryCollector, which specify the directory of the summary file. The summary file can
-    be loaded and shown by MindInsight, see `MindInsight documents <https://www.mindspore.cn/
-    mindinsight/docs/en/master/index.html>`_ for details.
+    or SummaryCollector, which specify the directory of the summary file.
     In Ascend platform with graph mode, the environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
     can be set to solve operator execution failure when calling this operator intensively.
 
@@ -236,7 +231,7 @@ class TensorDump(Primitive):
     Save the Tensor as an npy file in numpy format.
 
     .. warning::
-        - The parameter input_output will no longer support the value 'all'.
+        The parameter input_output will no longer support the value 'all'.
 
     .. note::
         In Ascend platform with graph mode, the environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
@@ -344,8 +339,6 @@ class HistogramSummary(Primitive):
     """
     This operator will calculate the histogram of a tensor and put it to a summary file with protocol buffer format.
     It must be used with SummaryRecord or SummaryCollector, which specify the directory of the summary file.
-    The summary file can be loaded and shown by MindInsight, see `MindInsight documents <https://www.mindspore.cn/
-    mindinsight/docs/en/master/index.html>`_ for details.
     In Ascend platform with graph mode, the environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
     can be set to solve operator execution failure when calling this operator intensively.
 
@@ -466,6 +459,107 @@ class InsertGradientOf(Primitive):
         self.f = f
 
 
+class Morph(PrimitiveWithInfer):
+    """
+    The `Morph` Primitive is used to encapsulate a user-defined function `fn`, allowing it to be used as a custom
+    Primitive.
+    The primary application scenario of the `Morph` Primitive is in the auto-parallel case after `GRAPH_MODE` mode,
+    where collective communication operators are used within the user-defined `fn` to implement custom parallel
+    computation logic, especially in scenarios where `fn` involves dynamic shapes.
+    When the `Morph` Primitive is applied to inputs, it is actually the encapsulated user-defined function `fn` that is
+    applied to the inputs.
+    The main difference between the `Morph` Primitive and :func:`mindspore.ops.Custom` is that the former is expanded
+    and replaced by the user-defined `fn` before automatic differentiation, so there is no need to implement a backward
+    function.
+
+    .. note::
+        - This primitive is only supported in GRAPH_MODE.
+        - `fn` must satisfy the syntax constraints of the graph mode.
+        - Users do not need to implement a custom backward function.
+        - `vararg`, `kwarg`, `kwonlyargs` and free variables are not supported in user-defined function.
+
+    Args:
+        fn (Function): Mindspore's function, user-defined function.
+        infer_shape (Function): Mindspore's function, user-defined infer_shape function.
+        infer_dtype (Function): Mindspore's function, user-defined infer_dtype function.
+
+    Inputs:
+        The inputs of user-defined `fn`.
+
+    Outputs:
+        The outputs of user-defined `fn`.
+
+    Raises:
+        RuntimeError: if not used in GRAPH_MODE.
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>> from mindspore import context, nn, ops, Tensor, Parameter
+        >>>
+        >>> np_weight0 = np.array([1.0, 2.0, 3.0])
+        >>> np_weight1 = np.array([4.0, 5.0, 6.0])
+        >>> np_input_x = np.array([7.0, 8.0, 9.0])
+        >>>
+        >>> def infer_dtype(args):
+        ...     return args
+        >>>
+        >>> def infer_shape(args):
+        ...     return args
+        >>>
+        >>> def mul_by(*args):
+        ...     def inner(x):
+        ...         return args[0] * x
+        ...     return inner
+        >>>
+        >>> NUMBER_100 = 100
+        >>> class MorphNet(nn.Cell):
+        ...     def __init__(self):
+        ...         super(MorphNet, self).__init__()
+        ...         self.weight0 = Parameter(Tensor(np_weight0, ms.float32), name="weight0")
+        ...         self.weight1 = Parameter(Tensor(np_weight1, ms.float32), name="weight1")
+        ...         self.mul_by_100 = ops.Morph(mul_by(NUMBER_100), infer_shape, infer_dtype)
+        ...     def construct(self, x):
+        ...         a = x * self.weight0
+        ...         b = self.mul_by_100(a)
+        ...         out = b * self.weight1
+        ...         return out
+        >>>
+        >>> context.set_context(mode=context.GRAPH_MODE)
+        >>> input_x = Tensor(np_input_x, ms.float32)
+        >>> net = MorphNet()
+        >>> grad_op = ops.GradOperation(get_all=True, get_by_list=True)
+        >>> grad_net = grad_op(net, net.trainable_params())
+        >>> bwd_out = grad_net(input_x)
+        >>> x_grad = bwd_out[0][0].asnumpy()
+        >>> weight0_grad = bwd_out[1][0].asnumpy()
+        >>> weight1_grad = bwd_out[1][1].asnumpy()
+        >>> print("x_grad", x_grad)
+        >>> print("weight0_grad", weight0_grad)
+        >>> print("weight1_grad", weight1_grad)
+        x_grad [ 400. 1000. 1800.]
+        weight0_grad [2800. 4000. 5400.]
+        weight1_grad [ 700. 1600. 2700.]
+    """
+    @prim_attr_register
+    def __init__(self, fn, infer_shape, infer_dtype):
+        self.add_prim_attr('side_effect_backprop', True)
+        self.add_prim_attr('side_effect_mem', True)
+        self.add_prim_attr('side_effect_io', True)
+        self.add_prim_attr('__metamorphosis__', fn)
+        self._infer_shape = infer_shape
+        self._infer_dtype = infer_dtype
+
+    def infer_shape(self, *args):
+        return self._infer_shape(*args)
+
+    def infer_dtype(self, *args):
+        return self._infer_dtype(*args)
+
+    def __call__(self, *args):
+        raise RuntimeError("Morph is only supported in GRAPH_MODE.")
+
+
 class HookBackward(PrimitiveWithInfer):
     """
     This operation is used as a tag to hook gradient in intermediate variables. Note that this function
@@ -527,8 +621,7 @@ class HookBackward(PrimitiveWithInfer):
     def __init__(self, hook_fn, cell_id=""):
         """Initialize HookBackward."""
         super(HookBackward, self).__init__(self.__class__.__name__)
-        if not check_hook_fn("HookBackward", hook_fn):
-            return
+        check_hook_fn(hook_fn)
         if cell_id != "":
             logger.warning(f"The args 'cell_id' of HookBackward will be removed in a future version. If the value of "
                            f"'cell_id' is set, the hook function will not work.")
@@ -600,6 +693,9 @@ class Print(Primitive):
         self.add_prim_attr("side_effect_io", True)
 
     def __call__(self, *args):
+        # Add for jit context.
+        if jit_context() and jit_context().compiled:
+            return
         for arg in args:
             if isinstance(arg, Parameter):
                 print(Tensor_.__repr__(arg))
@@ -607,6 +703,9 @@ class Print(Primitive):
                 print(arg.__repr__())
             else:
                 print(arg)
+        # Add for jit context.
+        if jit_context():
+            jit_context().run_op(self, None, *args)
 
 
 class Assert(PrimitiveWithInfer):

mindspore/ops/operations/inner_ops.py

@@ -87,7 +87,7 @@ class NoRepeatNGram(Primitive):
     Because 3 consecutive words [2, 3, 2] do not appear twice in the word sequence.
 
     Args:
-        ngram_size (int): Size of n-grams, must be greater than 0. Default: ``1`` .
+        ngram_size (int, optional): Size of n-grams, must be greater than 0. Default: ``1`` .
 
     Inputs:
         - **state_seq** (Tensor) - n-gram word series, a 3-D tensor with shape: :math:`(batch\_size, beam\_width, m)`.

mindspore/ops/operations/linalg_ops.py

@@ -19,64 +19,7 @@ from __future__ import absolute_import
 from mindspore import _checkparam as Validator
 from mindspore.ops.primitive import Primitive
 from mindspore.ops.primitive import prim_attr_register
-from ..auto_generate import Geqrf
-
-
-class Svd(Primitive):
-    """
-    Computes the singular value decompositions of one or more matrices.
-
-    Refer to :func:`mindspore.ops.svd` for more details.
-
-    Args:
-        full_matrices (bool, optional): If ``True`` , compute full-sized :math:`U` and :math:`V`. If ``False``,
-                                        compute only the leading P singular vectors, with P is the minimum of M and N.
-                                        Default: ``False`` .
-        compute_uv (bool, optional): If ``True`` , compute the left and right singular vectors.
-                                     If ``False`` , compute only the singular values. Default: ``True`` .
-
-    Inputs:
-        - **input** (Tensor) - Tensor of the matrices to be decomposed. The shape should be :math:`(*, M, N)`,
-          the supported dtype are float32 and float64.
-
-    Outputs:
-        - **s**  (Tensor) - Singular values. The shape is :math:`(*, P)`.
-        - **u**  (Tensor) - Left singular vectors. If `compute_uv` is ``False`` , u will be zero value.
-          The shape is :math:`(*, M, P)`. If `full_matrices` is ``True`` , the shape will be :math:`(*, M, M)`.
-        - **v**  (Tensor) - Right singular vectors. If `compute_uv` is ``False`` , v will be zero value.
-          The shape is :math:`(*, N, P)`. If `full_matrices` is ``True`` , the shape will be :math:`(*, N, N)`.
-
-    Supported Platforms:
-        ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> import mindspore as ms
-        >>> from mindspore import Tensor
-        >>> from mindspore import ops
-        >>> ms.set_device(device_target="CPU")
-        >>> svd = ops.Svd(full_matrices=True, compute_uv=True)
-        >>> a = Tensor(np.array([[1, 2], [-4, -5], [2, 1]]).astype(np.float32))
-        >>> s, u, v = svd(a)
-        >>> print(s)
-        [7.0652843 1.040081 ]
-        >>> print(u)
-        [[ 0.30821905 -0.48819482 0.81649697]
-         [-0.90613353  0.11070572 0.40824813]
-         [ 0.2896955   0.8656849  0.4082479 ]]
-        >>> print(v)
-        [[ 0.63863593 0.769509  ]
-         [ 0.769509  -0.63863593]]
-    """
-
-    @prim_attr_register
-    def __init__(self, full_matrices=False, compute_uv=True):
-        super().__init__(name="Svd")
-        self.init_prim_io_names(inputs=['a'], outputs=['s', 'u', 'v'])
-        self.full_matrices = Validator.check_value_type("full_matrices", full_matrices, [bool], self.name)
-        self.compute_uv = Validator.check_value_type("compute_uv", compute_uv, [bool], self.name)
-        self.add_prim_attr('full_matrices', self.full_matrices)
-        self.add_prim_attr('compute_uv', self.compute_uv)
+from ..auto_generate import Geqrf, Svd
 
 
 class Eigh(Primitive):

mindspore/ops/operations/manually_defined/_inner.py

@@ -66,7 +66,7 @@ class TensorReport(Primitive):
     @prim_attr_register
     def __init__(self):
         """Initialize TensorReport"""
-        self.add_prim_attr("side_effect_io", True)
+        self.add_prim_attr("side_effect_mem", True)
         self.add_prim_attr("channel_name", "ms_tensor_report")
 
     def __call__(self, file, input_x):