mindspore 2.4.10__cp39-cp39-win_amd64.whl → 2.6.0rc1__cp39-cp39-win_amd64.whl

mindspore/ops/operations/_custom_ops_utils.py

@@ -0,0 +1,247 @@
+# Copyright 2024 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""compile custom kernel with ninja"""
+
+import os
+import shlex
+import subprocess
+import sysconfig
+import time
+import stat
+from mindspore import log as logger
+
+
+class VersionManager:
+    """version manager"""
+
+    def __init__(self):
+        self.entries = {}  # module_name : (version, hash)
+
+    def _get_version(self, module_name):
+        """get version"""
+        return self.entries.get(module_name, (None, None))[0]
+
+    def _update_version_if_changed(self, module_name, sources, build_args, build_dir):
+        """update version if changed"""
+        hash_value = self._update_hash(0, build_dir)
+        hash_value = self._update_sources_hash(hash_value, sources)
+        hash_value = self._update_args_hash(hash_value, build_args)
+
+        entry = self.entries.get(module_name)
+        if entry is None:
+            self.entries[module_name] = entry = (0, hash_value)
+        elif hash_value != entry[1]:
+            self.entries[module_name] = entry = (entry[0] + 1, hash_value)
+
+        return entry[0]
+
+    def _update_hash(self, seed, value):
+        """update hash value"""
+        # Good old boost::hash_combine
+        return seed ^ (hash(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2))
+
+    def _update_sources_hash(self, hash_value, sources):
+        """hash source files"""
+        for filename in sources:
+            with open(filename) as file:
+                hash_value = self._update_hash(hash_value, file.read())
+        return hash_value
+
+    def _update_args_hash(self, hash_value, build_args):
+        """hash build arguments"""
+        for group in build_args:
+            if group:
+                for argument in group:
+                    hash_value = self._update_hash(hash_value, argument)
+        return hash_value
+
+    def check_version(self, name, sources, cflags, ldflags, include_paths, build_dir):
+        """check version"""
+        old_version = self._get_version(name)
+        version = self._update_version_if_changed(name, sources, [cflags, ldflags, include_paths], build_dir)
+        logger.info(f'Build module {name}, version={version}')
+        if version > 0:
+            if version != old_version:
+                logger.info(
+                    f'The conditions for extension module {name} have changed. '
+                    f'Updating to version {version} and re-building as {name}_v{version}.'
+                )
+            name = f'{name}_v{version}'
+
+        if version != old_version:
+            return True
+        logger.info(f'No modifications detected for extension module {name}')
+        return False
+
+
+version_manager = VersionManager()
+
+
+class FileLocker:
+    """FileLocker"""
+
+    def __init__(self, build_dir):
+        """FileLocker"""
+        self.lock_file_name = os.path.join(build_dir, 'build.lock')
+        self.lock_fd = None
+
+    def try_lock(self):
+        """Acquire a file-based lock."""
+        try:
+            mode = stat.S_IRUSR | stat.S_IWUSR
+            self.lock_fd = os.open(self.lock_file_name, os.O_CREAT | os.O_EXCL, mode)
+            return True
+        except FileExistsError:
+            return False
+
+    def release_lock(self):
+        """Release the file-based lock."""
+        if self.lock_fd is not None:
+            os.close(self.lock_fd)
+            self.lock_fd = None
+        os.remove(self.lock_file_name)
+
+    def wait(self):
+        """Wait until lock is released."""
+        while os.path.exists(self.lock_file_name):
+            time.sleep(0.5)
+
+
+class ExtensionBuilder:
+    """ExtensionBuilder"""
+
+    def __init__(self):
+        """ExtensionBuilder"""
+
+    def _get_build_directory(self, module_name):
+        """Get build directory."""
+        build_root = os.environ.get('MS_COMPILER_CACHE_PATH')
+        if build_root is None:
+            build_root = os.path.realpath("./kernel_meta")
+        logger.info(f'Using {build_root} as MindSpore extensions root...')
+
+        build_dir = os.path.join(build_root, module_name)
+        if not os.path.exists(build_dir):
+            os.makedirs(build_dir, exist_ok=True)
+        return build_dir
+
+    def _compile(self, name, sources, cflags, ldflags, include_paths, build_dir):
+        """Compile."""
+        if version_manager.check_version(name, sources, cflags, ldflags, include_paths, build_dir):
+            locker = FileLocker(build_dir)
+            if locker.try_lock():
+                try:
+                    self._write_ninja_file_and_build_library(name, sources, cflags, ldflags, include_paths, build_dir)
+                finally:
+                    locker.release_lock()
+            else:
+                locker.wait()
+        logger.info(f'Loading extension module {name}...')
+
+    def _verify_ninja_availability(self):
+        """Check ninja is available."""
+        try:
+            subprocess.check_output('ninja --version'.split())
+        except Exception:
+            raise RuntimeError("Ninja is required to load C++ extensions")
+
+    def _write_ninja_file_and_build_library(self, module_name, sources, cflags, ldflags, include_paths, build_dir):
+        """Write ninja file and build library."""
+        self._verify_ninja_availability()
+
+        ninja_build_file = os.path.join(build_dir, 'build.ninja')
+        logger.info(f'Save ninja build file {ninja_build_file}.')
+        self._write_ninja_file(ninja_build_file, module_name, sources, cflags, ldflags, include_paths)
+
+        logger.info(f'Building extension module {module_name}.')
+        self._run_ninja_build(build_dir, module_name)
+
+    def _write_ninja_file(self, fname, name, sources, extra_cflags, extra_ldflags, extra_include_paths):
+        """Write ninja file."""
+        python_include_path = sysconfig.get_path('include', scheme='posix_prefix')
+        python_includes = [python_include_path] if python_include_path is not None else []
+        cflags = [f'-DMS_EXTENSION_NAME={name}', "-D_GLIBCXX_USE_CXX11_ABI=0"]
+        cflags += [f'-I{shlex.quote(os.path.abspath(include.strip()))}' for include in extra_include_paths]
+        cflags += [f'-isystem {shlex.quote(include)}' for include in python_includes]
+        cflags += ['-fPIC', '-std=c++17']
+        cflags += extra_cflags
+        cflags = [flag.strip() for flag in cflags]
+
+        # '/path/to/file.cpp' -> 'file'
+        objs = [os.path.splitext(os.path.basename(src))[0] + ".o" for src in sources]
+        sources = [os.path.abspath(file) for file in sources]
+        ldflags = ['-shared'] + [flag.strip() for flag in extra_ldflags]
+        target = name + '.so'
+
+        config = ['ninja_required_version = 1.3']
+        config.append('cxx = ' + os.environ.get('CXX', 'g++'))
+
+        flags = [f'cflags = {" ".join(cflags)}']
+        flags.append(f'ldflags = {" ".join(ldflags)}')
+
+        compile_rule = ['rule compile']
+        compile_rule.append('  command = $cxx -MMD -MF $out.d $cflags -c $in -o $out')
+        compile_rule.append('  depfile = $out.d')
+        compile_rule.append('  deps = gcc')
+
+        build = [f'build {obj.replace(" ", "$ ")}: compile {src.replace(" ", "$ ")}' for src, obj in zip(sources, objs)]
+
+        link_rule = ['rule link', '  command = $cxx $in $ldflags -o $out']
+        link = [f'build {target}: link {" ".join(objs)}']
+        default = [f'default {target}']
+
+        blocks = [config, flags, compile_rule, link_rule, build, link, default]
+        content = "\n\n".join("\n".join(b) for b in blocks) + "\n"
+
+        if os.path.exists(fname):
+            with open(fname) as f:
+                old_content = f.read()
+            if old_content == content:
+                return
+
+        with open(fname, 'w') as source_file:
+            source_file.write(content)
+
+    def _run_ninja_build(self, build_dir, module_name):
+        """Run ninja build."""
+        cmd = ['ninja', '-v']
+        env = os.environ.copy()
+
+        try:
+            subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=build_dir, check=True, env=env)
+            # If the build succeeds, do nothing with the output (silent)
+        except subprocess.CalledProcessError as e:
+            # Capture the error details
+            stderr_output = e.stderr.decode() if e.stderr else ""
+            stdout_output = e.stdout.decode() if e.stdout else ""
+            full_output = stderr_output + stdout_output
+
+            # Format the error message
+            msg = f"Error building extension '{module_name}': {full_output}"
+
+            # In multi-card situation, only one process build the library.
+            # When building failed, the old extension library should be removed.
+            so_file = os.path.join(build_dir, f"{module_name}.so")
+            if os.path.exists(so_file):
+                os.remove(so_file)
+            raise RuntimeError(msg) from e
+
+    def build(self, module_name, sources, extra_cflags=None, extra_ldflags=None, extra_include_paths=None):
+        """Build module."""
+        src = [sources] if isinstance(sources, str) else sources
+        build_dir = self._get_build_directory(module_name)
+        self._compile(module_name, src, extra_cflags, extra_ldflags, extra_include_paths, build_dir)
+        return os.path.join(build_dir, f"{module_name}.so")

mindspore/ops/operations/_embedding_cache_ops.py

@@ -27,7 +27,7 @@ class UpdateCache(PrimitiveWithCheck):
     The difference is that UpdateCache will not update when indices < 0 or indices >= max_num.
 
     Inputs:
-        - **input_x** (Parameter) - Parameter which is going to be updated.
+        - **input_x** (Union[Parameter, Tensor]) - Parameter or Tensor which is going to be updated.
         - **indices** (Tensor) - Update indices of input_x.
         - **updates** (Tensor) - The update values.
 
@@ -148,7 +148,7 @@ class CacheSwapTable(PrimitiveWithCheck):
     Delete a hashmap entry,and insert a new key to hashmap, return the key and value of delete entry.
 
     Inputs:
-        - **cache_table** (Parameter) - The cache table which is on device.
+        - **cache_table** (Union[Parameter, Tensor]) - The cache table which is on device.
         - **swap_cache_idx** (Tensor) - The index of table which need to swap. -1 is skipped.
         - **miss_value** (int) - The values which arg going to swap into cache table.
 
@@ -227,10 +227,10 @@ class MapCacheIdx(PrimitiveWithCheck):
 
 class DynamicAssign(PrimitiveWithCheck):
     """
-    Assigns `Parameter` with a value, the `value` can have a dynamic shape.
+    Assigns `Parameter` or `Tensor` with a value, the `value` can have a dynamic shape.
 
     Inputs:
-        - **variable** (Parameter) - The `Parameter`.
+        - **variable** (Union[Parameter, Tensor]) - The `Parameter` or `Tensor`.
         - **value** (Tensor) - The value to be assigned.
 
     Outputs:

mindspore/ops/operations/_grad_ops.py

@@ -30,13 +30,13 @@ from mindspore.communication.management import GlobalComm
 from mindspore.common._utils import is_shape_unknown, is_dim_unknown
 from ..auto_generate import (AbsGrad, ACosGrad, LogitGrad, AcoshGrad, AsinGrad, AsinhGrad, ReciprocalGrad, RsqrtGrad,
                              SqrtGrad, BatchNormGrad, BatchNormGradGrad, BiasAddGrad, GeLUGrad, FastGeLUGrad,
-                             AvgPoolGrad, MinimumGrad, LogSoftmaxGrad, PReLUGrad, ReluGrad, ReLU6Grad, EluGrad,
+                             AvgPoolGrad, MinimumGrad, LogSoftmaxGrad, GluGrad, PReLUGrad, ReluGrad, ReLU6Grad, EluGrad,
                              GatherDGradV2, ResizeBilinearGrad, ResizeLinear1DGrad, ResizeNearestNeighborV2Grad,
                              SigmoidGrad, HSwishGrad, NLLLossGrad, AtanGrad, GridSampler3DGrad, GridSampler2DGrad,
                              ResizeBicubicGrad, HSigmoidGrad, CholeskyGrad, ResizeNearestNeighborGrad, LayerNormGrad,
                              HShrinkGrad, LayerNormGradGrad, SiLUGrad, MaximumGrad, MaximumGradGrad, RmsNormGrad,
                              FlashAttentionScoreGrad, UpsampleTrilinear3DGrad, UpsampleNearest3DGrad, MaskedSelectGrad,
-                             BinaryCrossEntropyGrad, SoftShrinkGrad, SeluGrad)
+                             BinaryCrossEntropyGrad, SoftShrinkGrad, SoftMarginLossGrad, SeluGrad, SmoothL1LossGrad)
 
 
 class SparseFillEmptyRowsGrad(Primitive):
@@ -1639,25 +1639,6 @@ class SliceGrad(PrimitiveWithInfer):
                 'value': None}
 
 
-class SmoothL1LossGrad(Primitive):
-    """Computes gradient for prediction on SmoothL1Loss."""
-
-    @prim_attr_register
-    def __init__(self, beta=1.0, reduction='none'):
-        self.add_prim_attr('sigma', self.beta)
-        self.reduction = validator.check_string(
-            reduction, ['none', 'sum', 'mean'], 'reduction', self.name)
-
-
-class SoftMarginLossGrad(Primitive):
-    """Computes gradient for prediction on SoftMarginLoss."""
-
-    @prim_attr_register
-    def __init__(self, reduction="mean"):
-        self.init_prim_io_names(inputs=['predict', 'label', "dout"], outputs=['gradient'])
-        self.reduction = validator.check_string(reduction, ['none', 'sum', 'mean'], 'reduction', self.name)
-
-
 class StridedSliceGrad(Primitive):
     """
     Performs grad of StridedSlice operation.
@@ -1962,15 +1943,6 @@ class MvlgammaGrad(Primitive):
         self.p = validator.check_value_type('p', p, [int], self.name)
 
 
-class CdistGrad(Primitive):
-    """Computes gradient for Cdist."""
-
-    @prim_attr_register
-    def __init__(self, p=2.0):
-        validator.check_value_type("p", p, [float], self.name)
-        self.init_prim_io_names(inputs=['grad', 'input_x', 'input_y', 'cdist'], outputs=['output'])
-
-
 class PdistGrad(Primitive):
     """Computes gradient for Pdist operation.
 
@@ -2908,19 +2880,6 @@ class AffineGridGrad(Primitive):
         self.init_prim_io_names(inputs=['y_grad', 'x_size'], outputs=['x_grad'])
 
 
-
-class GluGrad(Primitive):
-    """
-    Computes grad for Glu operation.
-    """
-
-    @prim_attr_register
-    def __init__(self, axis):
-        self.add_prim_attr("cust_aicpu", self.name)
-        self.init_prim_io_names(inputs=["grads", "x"], outputs=["y"])
-        validator.check_value_type("axis", axis, [int], self.name)
-
-
 class MapTensorGetGrad(Primitive):
     """
     Computes gradients for MapTensorGet operation.

mindspore/ops/operations/_infer_ops.py

@@ -16,4 +16,5 @@
 """Operator of infer net"""
 # pylint: disable=unused-import
 from ..auto_generate import (QuantV2, DynamicQuantExt, QuantBatchMatmul, WeightQuantBatchMatmul, KVCacheScatterUpdate,
-                             FusedInferAttentionScore, GroupedMatmul, MoeFinalizeRouting, QuantLinearSparse)
+                             FusedInferAttentionScore, GroupedMatmul, MoeFinalizeRouting, QuantLinearSparse,
+                             MatmulAllReduceAddRmsNorm, MoeGatingTopKSoftmax)

mindspore/ops/operations/_inner_ops.py

@@ -21,7 +21,6 @@ import weakref
 import numpy as np
 
 from mindspore.common import Tensor
-from mindspore.common._stub_tensor import StubTensor
 from mindspore.ops import composite as C
 from mindspore.ops.operations.array_ops import Cast
 from mindspore.ops.operations._scalar_ops import bit_or, bit_and
@@ -29,15 +28,15 @@ 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, \
     _run_op, _check_contains_variable
-from mindspore._c_expression import Tensor as Tensor_
+from mindspore._c_expression import TensorPy as Tensor_
 from mindspore._c_expression import typing, HookType
+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
+from mindspore.common._stub_tensor import _convert_stub
 from mindspore.communication.management import GlobalComm, get_rank, _get_group, get_group_size
 from mindspore.common.api import _pynative_executor
-from mindspore.common._register_for_adapter import ms_adapter_registry
-from mindspore import ops
 from ..auto_generate import TensorCopySlices, SiLU, Cummin, TopKRouter, ExtractImagePatches, DecoderKVCache, \
     PromptKVCache, ApplyCamePart1, ApplyCamePart2, ApplyCamePart3, ApplyCamePart4
 
@@ -79,7 +78,7 @@ class Generator(Primitive):
     def __call__(self, cmd, inputs):
         if cmd == 0:  # step cmd
             return inputs[0], inputs[1]
-        return super().__call__(cmd, inputs)
+        return _convert_stub(pyboost_generator(self, [cmd, inputs]))
 
 
 class Quant(PrimitiveWithInfer):
@@ -534,7 +533,8 @@ class ConvertToDynamic(PrimitiveWithCheck):
           >>>         dynamic_input = self.convert_to_dynamic(input)
           >>>         reshaped_input = self.reshape(dynamic_input, new_shape)
           >>>
-          >>> ms.set_context(mode=ms.GRAPH_MODE, device_target="CPU")
+          >>> ms.set_context(mode=ms.GRAPH_MODE)
+          >>> ms.set_device(device_target="CPU")
           >>> input = Tensor(np.array([0, 1, 2, 3])
           >>> new_shape = (2, 2)
           >>> net = TestDynamicNet()
@@ -585,7 +585,8 @@ class GpuConvertToDynamicShape(PrimitiveWithCheck):
           >>>         dynamic_shape_input = self.convert_to_dynamic_shape(input)
           >>>         reshaped_input = self.reshape(input, new_shape)
           >>>
-          >>> ms.set_context(mode=ms.GRAPH_MODE, device_target="GPU")
+          >>> ms.set_context(mode=ms.GRAPH_MODE)
+          >>> ms.set_device(device_target="GPU")
           >>> input = Tensor(np.array([0, 1, 2, 3])
           >>> new_shape = (2, 2)
           >>> net = TestDynamicShapeReshapeNet()
@@ -632,7 +633,8 @@ class ErrorOnDynamicShapeInput(PrimitiveWithInfer):
           >>>         dynamic_shape_input = self.convert_to_dynamic_shape(input)
           >>>         self.error_on_dynamic_shape_input(dynamic_shape_input)
           >>>
-          >>> ms.set_context(mode=ms.GRAPH_MODE, device_target="GPU")
+          >>> ms.set_context(mode=ms.GRAPH_MODE)
+          >>> ms.set_device(device_target="GPU")
           >>> input = Tensor(np.array([0])
           >>> net = TestDynamicShapeReshapeNet()
           >>> output = net(input, new_shape)
@@ -663,17 +665,17 @@ class ErrorOnDynamicShapeInput(PrimitiveWithInfer):
 
 class SequenceMask(PrimitiveWithCheck):
     """
-    Returns a mask tensor representing the first N positions of each cell.
+    Returns a mask tensor representing the first N positions of each cell. The internal element data type is bool.
 
     If lengths has shape [d_1, d_2, ..., d_n], then the resulting tensor mask has type and shape
     [d_1, d_2, ..., d_n, maxlen], with mask[i_1, i_2, ..., i_n, j] = (j < lengths[i_1, i_2, ..., i_n])
 
     Inputs:
-        - **lengths** (Tensor) - Tensor to calculate the mask for. All values in this tensor should be
+        - **lengths** (Tensor) - The input tensor. All values in this tensor should be
           less than or equal to `maxlen`. Values greater than `maxlen` will be treated as `maxlen`.
           Must be type int32 or int64.
 
-        - **maxlen** (int) - size of the last dimension of returned tensor. Must be positive and same
+        - **maxlen** (int) - Specify the length of the returned tensor. Must be positive and same
           type as elements in `lengths`.
 
     Outputs:
@@ -1407,9 +1409,9 @@ class PsROIPooling(PrimitiveWithInfer):
         >>>                                  group_size=7)
         >>> out, channel_map = psRoIPooling(features, rois)
         >>> print(out.shape)
-            [4, 21, 7, 7]
+        [4, 21, 7, 7]
         >>> print(channel_map.shape)
-            [4, 21, 7, 7]
+        [4, 21, 7, 7]
     """
 
     @prim_attr_register
@@ -1570,7 +1572,29 @@ class CellBackwardHook(PrimitiveWithInfer):
         # If args is empty, just return.
         if not args:
             return args
-        return _run_op(self, self.name, args)
+
+        # Collect the indices and values of arguments that are instances of Tensor
+        tensors_idx = []
+        tensors = []
+        for i, arg in enumerate(args):
+            if isinstance(arg, Tensor):
+                tensors_idx.append(i)
+                tensors.append(arg)
+
+        # If there are no Tensor arguments, return the single argument or the original tuple
+        if not tensors:
+            return args[0] if len(args) == 1 else args
+
+        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 arg_list[0] if len(arg_list) == 1 else tuple(arg_list)
 
     def infer_shape(self, *inputs_shape):
         if len(inputs_shape) == 1:
@@ -1772,7 +1796,8 @@ class KMeansCentroids(PrimitiveWithInfer):
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor
         >>> from mindspore.ops import operations as P
-        >>> ms.set_context(mode=ms.GRAPH_MODE, device_target="Ascend")
+        >>> ms.set_context(mode=ms.GRAPH_MODE)
+        >>> ms.set_device(device_target="Ascend")
 
         >>> class Net(nn.Cell):
         >>>    def __init__(self):
@@ -2039,6 +2064,8 @@ class CheckBprop(PrimitiveWithInfer):
                              f"which is:{len(yshapes)} but got {len(xshapes)}.")
 
         def shape_equal(shape1, shape2):
+            if -2 in shape1 or -2 in shape2:
+                return True
             if len(shape1) != len(shape2):
                 return False
             for shape_axis1, shape_axis2 in zip(shape1, shape2):
@@ -2226,74 +2253,6 @@ class IsInstance(PrimitiveWithInfer):
         return out
 
 
-class ConvertToAdapterTensor(Primitive):
-    """
-    Convert a tensor from MindSpore's Tensor type to MSAdapter's Tensor type,
-    where MSAdapter's Tensor is a subclass of MindSpore's Tensor.
-
-    Inputs:
-        - **x** (Tensor) - The input tensor.
-
-    Outputs:
-        A tensor, whose type is MSAdapter's Tensor.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> x = Tensor([1, 2 ,3])
-        >>> x = ops.ConvertToAdapterTensor()(x)
-        >>> print(x)
-        [1 2 3]
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize"""
-
-    def __call__(self, x):
-        """Run in PyNative mode"""
-        return ms_adapter_registry.tensor(x, cast_tensor=True)
-
-
-convert_to_adapter_tensor = ConvertToAdapterTensor()
-
-
-class ConvertToMsTensor(Primitive):
-    """
-    Convert a tensor from MSAdapter's Tensor type to MindSpore's Tensor type,
-    where MSAdapter's Tensor is a subclass of MindSpore's Tensor.
-
-    Inputs:
-        - **x** (Tensor) - The input tensor.
-
-    Outputs:
-        A tensor, whose type is MindSpore's Tensor.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> x = Tensor([1, 2 ,3])
-        >>> x = ops.ConvertToMsTensor()(x)
-        >>> print(x)
-        [1 2 3]
-    """
-
-    @prim_attr_register
-    def __init__(self):
-        """Initialize"""
-
-    def __call__(self, x):
-        """Run in PyNative mode"""
-        if isinstance(x, StubTensor):
-            return StubTensor(stub=x.stub, tensor=x.tensor)
-        return ops.auto_generate.deepcopy(x)
-
-
-convert_to_ms_tensor = ConvertToMsTensor()
-
-
 class GetGrad(Primitive):
     """
         Use the position id or Parameter object to get the gradient from the output
@@ -2445,7 +2404,7 @@ class FFN(Primitive):
     The FFN computation is similar to Feed-Forward Network, it contains matmul + gelu + matmul.
 
     Args:
-        activation (string): The activation type, set to 'fastgelu' or 'gelu'.
+        activation (str): The activation type, set to 'fastgelu' or 'gelu'.
             Only support 'fastgelu' for now. Default: "fastgelu".
         inner_precise (int): The precise mode, set to 0 for high precision or 1 for high performance.
             Only support 1 for now. Default: 0.

mindspore/ops/operations/_ms_kernel.py

@@ -496,7 +496,7 @@ def kernel(fn=None, reg_info=None, compile_attrs=None):
         callable function is equal to the case when `fn` is not None.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -510,12 +510,12 @@ def kernel(fn=None, reg_info=None, compile_attrs=None):
         ...     "test3": 12,
         ... }
         >>> # Create the reg info json string.
-        >>> op_gpu_info = CustomRegOp() \\
+        >>> op_cpu_info = CustomRegOp() \\
         ...     .input(0, "a") \\
         ...     .input(0, "b") \\
         ...     .output(0, "y") \\
         ...     .dtype_format(DataType.F32_None, DataType.F32_None, DataType.F32_None) \\
-        ...     .target("GPU") \\
+        ...     .target("CPU") \\
         ...     .get_op_info()
         >>>
         >>> # Create inputs for the custom op.
@@ -524,7 +524,7 @@ def kernel(fn=None, reg_info=None, compile_attrs=None):
         ...
         >>> # Write a Hybrid DSL function through the decorator @kernel.
         >>> # We can also pass the compile attrs and the reg info through the decorator.
-        >>> @kernel(reg_info=op_gpu_info, compile_attrs=attrs)
+        >>> @kernel(reg_info=op_cpu_info, compile_attrs=attrs)
         ... def outer_product(a, b):
         ...     c = output_tensor(a.shape, a.dtype)
         ...
@@ -539,12 +539,6 @@ def kernel(fn=None, reg_info=None, compile_attrs=None):
         >>> # We can use the function directly as a python function.
         >>> # In this case, the inputs should be numpy arrays.
         >>> result = outer_product(input_x, input_y)
-        ...
-        >>> # Create a custom op with mode "hybrid" (default value) by the Hybrid DSL function.
-        >>> # In this case, we will enjoy the automatic dtype/shape infer for free.
-        >>> # The inputs should be mindspore tensors.
-        >>> test_op_hybrid = ops.Custom(outer_product)
-        >>> output = test_op_hybrid(Tensor(input_x), Tensor(input_y))
     """
     if compile_attrs is None:
         compile_attrs = {}

mindspore/ops/operations/_rl_inner_ops.py

@@ -859,7 +859,7 @@ class TensorsQueueCreate(PrimitiveWithInfer):
         dtype (mindspore.dtype): the data type in the TensorsQueue.
         shapes (tuple(tuple(int))): the shape of each tensor in element.
         size (int): The size of the TensorsQueue.
-        name (string): the name of this TensorsQueue. Default: "Q".
+        name (str): the name of this TensorsQueue. Default: "Q".
 
     Inputs:
         None.

mindspore/ops/operations/_scalar_ops.py

@@ -1,4 +1,4 @@
-# Copyright 2023 Huawei Technologies Co., Ltd
+# Copyright 2023-2025 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,7 +16,8 @@
 
 from mindspore.ops.primitive import Primitive, prim_attr_register
 from .manually_defined import ScalarAdd, ScalarBool, ScalarDiv, ScalarMul, ScalarEq, ScalarFloorDiv, ScalarGe, \
-    ScalarGt, ScalarLe, ScalarLog, ScalarLt, ScalarMod, ScalarPow, ScalarSub, ScalarUadd, ScalarUsub
+    ScalarGt, ScalarLe, ScalarLog, ScalarLt, ScalarMod, ScalarPow, ScalarSub, ScalarUadd, ScalarUsub, ScalarMax, \
+    ScalarMin
 
 
 class bool_not(Primitive):

mindspore/ops/operations/_sequence_ops.py

@@ -16,7 +16,7 @@
 from mindspore.ops.primitive import Primitive, PrimitiveWithCheck, prim_attr_register
 import mindspore._checkparam as validator
 from mindspore.common import Tensor
-from mindspore._c_expression import Tensor as Tensor_
+from mindspore._c_expression import TensorPy as Tensor_
 
 
 class ListAppend(Primitive):