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

mindspore/ops/operations/nn_ops.py

@@ -30,15 +30,16 @@ from mindspore.ops.primitive import Primitive
 from mindspore.ops.primitive import PrimitiveWithInfer
 from mindspore.ops.primitive import PrimitiveWithCheck
 from mindspore.ops.primitive import prim_attr_register
-from ..auto_generate import (CeLU, Flatten, LogSoftmax, ReLU, ReLU6, Dense, Tanh,
+from mindspore.run_check._check_version import AscendEnvChecker
+from ..auto_generate import (CeLU, Flatten, LogSoftmax, LogSoftmaxExt, ReLU, ReLU6, Dense, Tanh,
                              Elu, Sigmoid, Softmax, SoftplusExt, HSwish, HSigmoid, AvgPool, BiasAdd,
-                             NLLLoss, OneHot, GeLU, FastGeLU, PReLU, RmsNorm,
+                             NLLLoss, OneHot, GeLU, FastGeLU, PReLU, RmsNorm, IncreFlashAttention, MSELossExt,
                              GridSampler3D, GridSampler2D, LayerNorm, LayerNormExt, HShrink, AdamWeightDecay, Dropout,
                              ApplyRotaryPosEmb, PagedAttention, PagedAttentionMask, ReshapeAndCache,
                              FlashAttentionScore, Embedding, UpsampleNearest1D, UpsampleNearest2D,
                              UpsampleNearest3D, UpsampleTrilinear3D,
                              UpsampleBilinear2D, UpsampleLinear1D,
-                             BinaryCrossEntropy, BCEWithLogitsLoss)
+                             BinaryCrossEntropy, BCEWithLogitsLoss, SoftShrink)
 from .manually_defined import BatchNorm
 
 
@@ -453,7 +454,7 @@ class ReLUV3(Primitive):
     Inputs:
         - **input_x** (Tensor) - Tensor of shape :math:`(N, *)`, where :math:`*` means, any number of
           additional dimensions, data type is
-          `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+          `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Outputs:
         Tensor of shape :math:`(N, *)`, with the same type and shape as the `input_x`.
@@ -569,8 +570,6 @@ class SeLU(Primitive):
         self.init_prim_io_names(inputs=['input_x'], outputs=['output'])
 
 
-
-
 class FusedBatchNorm(Primitive):
     r"""
     The FusedBatchNorm interface is deprecated, please use the BatchNorm interface.
@@ -3075,9 +3074,9 @@ class LSTM(Primitive):
     Args:
         input_size (int): Number of features of input.
         hidden_size (int):  Number of features of hidden layer.
-        num_layers (int): Number of layers of stacked LSTM.
-        has_bias (bool): Whether the cell has bias `b_ih` and `b_hh`.
-        bidirectional (bool): Specifies whether it is a bidirectional LSTM.
+        num_layers (int): Number of layers of stacked LSTM, , which is only support `1` on CPU.
+        has_bias (bool): Whether the cell has bias `b_ih` and `b_hh` , which is only support `False` on CPU.
+        bidirectional (bool): Specifies whether it is a bidirectional LSTM, , which is only support `False` on CPU.
         dropout (float): If not 0, append `Dropout` layer on the outputs of each
             LSTM layer except the last layer. The range of dropout is [0.0, 1.0].
         proj_size (int): If `proj_size` > 0, a projection of the corresponding size will be used,
@@ -3776,6 +3775,7 @@ class AdamNoUpdateParam(Primitive):
     @prim_attr_register
     def __init__(self, use_locking=False, use_nesterov=False):
         """Initialize AdamNoUpdateParam."""
+        self.add_prim_attr('side_effect_mem', True)
         validator.check_value_type("use_locking", use_locking, [bool], self.name)
         validator.check_value_type("use_nesterov", use_nesterov, [bool], self.name)
 
@@ -6376,6 +6376,9 @@ class AvgPool3D(Primitive):
         \frac{1}{d_{ker} * h_{ker} * w_{ker}} \sum_{l=0}^{d_{ker}-1} \sum_{m=0}^{h_{ker}-1} \sum_{n=0}^{w_{ker}-1}
         \text{input}(N_i, C_j, s_0 \times d + l, s_1 \times h + m, s_2 \times w + n)
 
+    Note:
+        This interface currently does not support Atlas A2 training series products.
+
     Args:
         kernel_size (Union[int, tuple[int]]): The size of kernel used to take the average value,
             is an int number that represents depth, height and width are both kernel_size, or a tuple
@@ -7091,7 +7094,7 @@ class CTCLossV2Grad(Primitive):
         zero_infinity (bool): Whether to set infinite loss and correlation gradient to zero. Default: ``False`` .
 
     Inputs:
-        - **grad_out** (Tenosr) - Gradient renewal codfficient, A tensor for shape (N), where N is batch size.
+        - **grad_out** (Tensor) - Gradient renewal codfficient, A tensor for shape (N), where N is batch size.
         - **log_probs** (Tensor) - A tensor of shape (T, N, C), where T is input length, N is batch size and C is number
           of classes (including blank).
         - **targets** (Tensor) - A tensor of shape (N, S), where S is max target length, means the target sequences.
@@ -7461,43 +7464,6 @@ class Dilation2D(Primitive):
         self.add_prim_attr('dilation', self.dilation)
 
 
-class SoftShrink(Primitive):
-    r"""
-    Applies the SoftShrink function element-wise.
-
-    Refer to :func:`mindspore.ops.softshrink` for more details.
-
-    Args:
-        lambd(float, optional): The :math:`\lambda` must be no less than zero. Default: ``0.5`` .
-
-    Inputs:
-        - **input_x** (Tensor) - The input of soft shrink with data type of float16 or float32.
-
-    Outputs:
-        Tensor, has the same shape and data type as `input_x`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input_x = Tensor(np.array([[ 0.5297,  0.7871,  1.1754], [ 0.7836,  0.6218, -1.1542]]), mindspore.float16)
-        >>> softshrink = ops.SoftShrink()
-        >>> output = softshrink(input_x)
-        >>> print(output)
-        [[ 0.02979  0.287    0.676  ]
-         [ 0.2837   0.1216  -0.6543 ]]
-    """
-
-    @prim_attr_register
-    def __init__(self, lambd=0.5):
-        """Initialize SoftShrink"""
-        validator.check_value_type("lambd", lambd, [float], self.name)
-        validator.check_number("lambd", lambd, 0, validator.GE, self.name)
-
-
 class ApplyAdagradDA(Primitive):
     r"""
     Update `var` according to the proximal adagrad scheme.
@@ -9591,79 +9557,19 @@ class PromptFlashAttention(Primitive):
                                 outputs=["attention_out"])
 
 
-class IncreFlashAttention(Primitive):
-    r"""
-    The interface for fully inference.
-
-    B -- Batch size
-
-    S -- Sequence length
-
-    H -- Hidden size
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-        If there is no input parameter and no default value, None needs to be passed.
-
-    Args:
-    - **num_heads**  (int) - The number of heads.
-    - **input_layout** (str) - the data layout of the input qkv, support `(BSH)` and `(BNSD)`. Default `BSH`.
-    - **scale_value** (double) - The scale value indicating the scale coefficient, which is used as the scalar of
-        Muls in the calculation. Default: 1.0.
-    - **num_key_value_heads** (int) - head numbers of key/value which are used in GQA algorithm.
-        The value o indicates if the key and value have the same head nums, use numHeads.  Default: 0.
-    - **block_size** (int) - Default: 0.
-    - **inner_precise** (int) - Default: 1.
-
-    Inputs:
-        - **query** (Tensor) - The query tensor with data type of float16 or bfloat16.
-          Input tensor of shape :math:`(B, 1, H)` / :math:`(B, N, 1, D)`.
-        - **key** (TensorList) - The key tensor with data type of float16 or bfloat16.
-          Input tensor of shape :math:`(B, S, H)` / :math:`(B, N, S, D)`.
-        - **value** (TensorList) - The value tensor with data type of float16 or bfloat16.
-          Input tensor of shape :math:`(B, S, H)` / :math:`(B, N, S, D)`.
-        - **attn_mask** (Tensor) - The attention mask tensor with data type of float16 or bool.
-          Input tensor of shape :math:`(B, S)` / :math:`(B, 1, S)` / :math:`(B, 1, 1, S)`.
-        - **actual_seq_lengths** (Tensor) - Describe actual sequence length of each input with data type of int.
-        - **pse_shift** (Tensor) - The position encoding tensor with data type of float16 or float32.
-        - **dequant_scale1** (Tensor) - Quantitative parametor, the tensor with data type of uint64.
-        - **quant_scale1** (Tensor) - Quantitative parametor, the tensor with data type of float.
-        - **dequant_scale2** (Tensor) - Quantitative parametor, the tensor with data type of uint64.
-        - **quant_scale2** (Tensor) - Quantitative parametor, the tensor with data type of float.
-        - **quant_offset2** (Tensor) - Quantitative parametor, the tensor with data type of float.
-        - **antiquant_scale** (Tensor) - Quantitative parametor, the tensor with data type of float.
-        - **antiquant_offset** (Tensor) - Quantitative parametor, the tensor with data type of float.
-        - **block_table** (Tensor) - The tensor with data type of float.
-
-    Outputs:
-        - **attention_out** (Tensor) - Input tensor of shape :math:`(B, 1, H)` / :math:`(B, N, 1, D)`.
-
-    Supported Platforms:
-        ``Ascend``
-    """
-
-    @prim_attr_register
-    def __init__(self, num_heads, input_layout="BSH", scale_value=1.0, num_key_value_heads=0, block_size=0,
-                 inner_precise=1):
-        """Initialize IncreFlashAttention."""
-        validator.check_value_type('num_heads', num_heads, [int], self.name)
-        validator.check_value_type('input_layout', input_layout, [str], self.name)
-        validator.check_value_type('scale_value', scale_value, [float], self.name)
-        validator.check_value_type('num_key_value_heads', num_key_value_heads, [int], self.name)
-        validator.check_value_type('block_size', block_size, [int], self.name)
-        validator.check_value_type('inner_precise', inner_precise, [int], self.name)
-        self.init_prim_io_names(inputs=["query", "key", "value", "attn_mask", "actual_seq_lengths", "pse_shift",
-                                        "dequant_scale1", "quant_scale1", "dequant_scale2", "quant_scale2",
-                                        "quant_offset2", "antiquant_scale", "antiquant_offset", "block_table"],
-                                outputs=["attention_out"])
-
-
 class AllFinite(Primitive):
     r"""
     Check all gradients is finite.
     """
+
     @prim_attr_register
     def __init__(self):
         """Initialize"""
         self.init_prim_io_names(inputs=['gradients'],
                                 outputs=["is_finite"])
+        if context.get_context("device_target") == "Ascend":
+            checker = AscendEnvChecker(None)
+            if not checker.check_custom_version():
+                raise RuntimeError(
+                    "The version of Ascend AI software package installed "
+                    "in the current environment does not support AllFinite.")

mindspore/ops/operations/other_ops.py

@@ -300,10 +300,10 @@ class SampleDistortedBoundingBoxV2(Primitive):
 
     @prim_attr_register
     def __init__(self, seed=0, seed2=0, \
-                  aspect_ratio_range=(0.75, 1.33), \
-                  area_range=(0.05, 1.0), \
-                  max_attempts=100, \
-                  use_image_if_no_bounding_boxes=False):
+                 aspect_ratio_range=(0.75, 1.33), \
+                 area_range=(0.05, 1.0), \
+                 max_attempts=100, \
+                 use_image_if_no_bounding_boxes=False):
         validator.check_is_int(seed, "seed", self.name)
         validator.check_is_int(seed2, "seed2", self.name)
         validator.check_value_type("aspect_ratio_range", aspect_ratio_range, [list, tuple], self.name)
@@ -584,6 +584,9 @@ class StopGradient(Primitive):
         pass
 
 
+stop_gradient_ = StopGradient()
+
+
 class ConfusionMatrix(PrimitiveWithInfer):
     r"""
     Calculates the confusion matrix from labels and predictions.

mindspore/ops/operations/random_ops.py

@@ -89,6 +89,10 @@ class TruncatedNormal(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -153,6 +157,10 @@ class StandardNormal(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -204,6 +212,10 @@ class StandardLaplace(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -367,6 +379,10 @@ class Gamma(PrimitiveWithInfer):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -450,6 +466,10 @@ class ParameterizedTruncatedNormal(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -672,6 +692,10 @@ class UniformInt(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -737,6 +761,10 @@ class UniformReal(Primitive):
           - GPU: int32, int64.
           - CPU: int16, int32, int64.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -837,6 +865,10 @@ class RandomCategorical(PrimitiveWithInfer):
     r"""
     Generates random samples from a given categorical distribution tensor.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         dtype (mindspore.dtype): The type of output. Its value must be one of mstype.int16,
             mstype.int32 and mstype.int64. Default: ``mstype.int64`` .
@@ -903,6 +935,10 @@ class Multinomial(Primitive):
         - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
           to worry about which seed is more important.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` and `seed2` parameter have no effect.
+
     Args:
         seed (int, optional): The operator-level random seed, used to generate random numbers,
             must be non-negative. Default: ``0`` .
@@ -1012,6 +1048,11 @@ class UniformCandidateSampler(Primitive):
 
     Refer to :func:`mindspore.ops.uniform_candidate_sampler` for more details.
 
+    .. warning::
+        - The Ascend backend does not support the reproducibility of random numbers, so
+          the `seed` parameter has no effect.
+        - The Ascend backend does not support dynamic shape scenarios currently.
+
     Args:
         num_true (int): The number of target classes in each training example.
         num_sampled (int): The number of classes to randomly sample. The sampled_candidates will have a shape
@@ -1026,7 +1067,7 @@ class UniformCandidateSampler(Primitive):
 
     Inputs:
         - **true_classes** (Tensor) - A Tensor. The target classes with a Tensor shape of
-          :math:`(batch\_size, num\_true)`.
+          :math:`(batch\_size, num\_true)`. The value range of the elements must be :math:`[0, range\_max)`.
 
     Outputs:
         - **sampled_candidates** (Tensor) - The sampled_candidates is independent of the true classes.
@@ -1086,6 +1127,10 @@ class LogUniformCandidateSampler(Primitive):
 
     Refer to :func:`mindspore.ops.log_uniform_candidate_sampler` for more details.
 
+    .. warning::
+        The Ascend backend does not support the reproducibility of random numbers, so
+        the `seed` parameter has no effect.
+
     Args:
         num_true (int, optional): The number of target classes per training example. Default: ``1`` .
         num_sampled (int, optional): The number of classes to randomly sample. Default: ``5`` .

mindspore/ops/primitive.py

@@ -171,6 +171,9 @@ class Primitive(Primitive_):
                     if not isinstance(in_value, int) and self.name not in SUPPORTED_TUPLE_IN_TUPLE_STRATEGY:
                         raise TypeError(f'The {log_info}: {strategy} of {self.name} is not valid,'
                                         f' the value of strategy must be int type, but got:{type(in_value)}')
+                    if isinstance(in_value, Layout) and (self.name in SUPPORTED_TUPLE_IN_TUPLE_STRATEGY):
+                        is_layout.append(True)
+                        continue
                 is_layout.append(False)
                 continue
             is_layout.append(True)
@@ -188,9 +191,17 @@ class Primitive(Primitive_):
                 raise TypeError(f'{log_info} must be tuple type, but got:{type(layout)}')
             layout_value = ()
             for in_ele in layout:
-                if not isinstance(in_ele, Layout):
-                    raise TypeError(f"The {log_info} item should be a object of class Layout.")
-                layout_value += (in_ele.to_dict(),)
+                if isinstance(in_ele, Layout):
+                    layout_value += (in_ele.to_dict(),)
+                elif isinstance(in_ele, tuple):
+                    new_layout_list = ()
+                    for ele in in_ele:
+                        if not isinstance(ele, Layout):
+                            raise TypeError(f"The {log_info} item should be a object of class Layout.")
+                        new_layout_list += (ele.to_dict(),)
+                    layout_value += (new_layout_list,)
+                else:
+                    raise TypeError(f"The {log_info} item should be a object of class Layout or a tuple.")
         return layout_value
 
     def _check_shard_strategy_in_out_match(self, in_strategy, out_strategy):
@@ -299,7 +310,8 @@ class Primitive(Primitive_):
         if out_strategy is not None:
             out_is_layout = self._check_shard_strategy(out_strategy, "out_strategy")
         self._check_shard_strategy_in_out_match(in_strategy, out_strategy)
-        if in_is_layout is not None and out_is_layout is not None and in_is_layout[0] != out_is_layout[0]:
+        if in_is_layout is not None and out_is_layout is not None and (
+                (in_is_layout[0] != out_is_layout[0]) and (self.name not in SUPPORTED_TUPLE_IN_TUPLE_STRATEGY)):
             raise ValueError(f'The in_strategy type must equal to the out_strategy type, '
                              f'one using tuple(tuple) and the other using tuple(Layout) is not allowed.')
         in_layout_value = None
@@ -549,7 +561,7 @@ class PrimitiveWithCheck(Primitive):
     the shape and type. Method infer_value() can also be defined (such as PrimitiveWithInfer) for constant propagation.
 
     More on how to customize a Op, please refer to `Custom Operators
-    <https://www.mindspore.cn/tutorials/experts/en/master/operation/op_custom.html>`_.
+    <https://www.mindspore.cn/docs/en/master/model_train/custom_program/op_custom.html>`_.
 
     Args:
         name (str): Name of the current Primitive.
@@ -643,7 +655,7 @@ class PrimitiveWithInfer(Primitive):
     logic of the shape and type. The infer_value() is used for constant propagation.
 
     More on how to customize a Op, please refer to `Custom Operators
-    <https://www.mindspore.cn/tutorials/experts/en/master/operation/op_custom.html>`_.
+    <https://www.mindspore.cn/docs/en/master/model_train/custom_program/op_custom.html>`_.
 
     Args:
         name (str): Name of the current Primitive.

mindspore/ops_generate/arg_dtype_cast.py

@@ -238,6 +238,8 @@ def type_it(op_name, arg_name, data, src_type, dst_type):
     """
     cast operator argument data type.
     """
+    if isinstance(data, type(None)):
+        return data
     if not isinstance(src_type, tuple):
         src_type = int(src_type)
     else:

mindspore/ops_generate/gen_aclnn_implement.py

@@ -23,6 +23,7 @@ import pathlib
 import logging
 import gen_utils
 from pyboost_utils import AclnnUtils, get_dtypes
+from gen_constants import MS_OPS_KERNEL_PATH
 
 auto_gen = ''
 
@@ -35,7 +36,7 @@ def gen_h(op_name, aclnn_name, op_yaml, kernelmod_h_path, need_update_shape):
 #define MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_{op_name.upper()}_ACLNN{auto_gen.upper()}_KERNEL_MOD_H_
 #include <vector>
 #include "ops/base_operator.h"
-#include "plugin/device/ascend/kernel/opapi/aclnn_kernel_mod.h"
+#include "{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_kernel_mod.h"
 #include "transform/acl_ir/acl_convert.h"
 """
     update_shape = f"""
@@ -78,7 +79,7 @@ def gen_cc(op_name, class_name, op_yaml, kernelmod_cc_path, need_update_shape):
     """generate cc files"""
     kernelmod_name = op_yaml.get('dispatch').get("Ascend")
     cc_head = f"""
-#include "plugin/device/ascend/kernel/opapi/aclnn{auto_gen}/{op_name}_aclnn_kernel.h"
+#include "{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn{auto_gen}/{op_name}_aclnn_kernel.h"
 #include <algorithm>
 #include <vector>
 #include <memory>
@@ -135,8 +136,7 @@ bool {kernelmod_name}::Launch(const std::vector<KernelTensor *> &inputs, const s
                               const std::vector<KernelTensor *> &outputs, void *stream_ptr) {{
   MS_EXCEPTION_IF_NULL(stream_ptr);
   {input_templete}
-  ParseGenExecutor(GEN_EXECUTOR_BOOST(op_type_, hash_id_, {inputs}));
-  RunOp(stream_ptr, workspace);
+  RunOp(stream_ptr, workspace, {inputs});
   return true;
 }}
 """
@@ -177,10 +177,10 @@ def gen_aclnn_kernel(op_name, yaml_str, need_update_shape=False, auto=False):
     if check_op_registed(op_name) and not auto:
         logging.warning("Kernel {%s} is already registered.", op_name)
         return
-    current_path = os.path.dirname(os.path.abspath(__file__))
+    current_path = os.path.dirname(os.path.realpath(__file__))
     work_path = os.path.join(current_path, '../../../../')
 
-    aclnn_path = 'mindspore/ccsrc/plugin/device/ascend/kernel/opapi/aclnn/'
+    aclnn_path = '{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/'
     # merge inner ops
     op_yaml = yaml_str.get(op_name)
     class_name = ''.join(word.capitalize() for word in op_name.split('_'))
@@ -196,7 +196,7 @@ def gen_aclnn_kernel(op_name, yaml_str, need_update_shape=False, auto=False):
             return
         auto_gen = "_auto_gen"
         dispatch['Ascend'] = class_name + "Ascend"
-        aclnn_path = 'mindspore/ccsrc/plugin/device/ascend/kernel/opapi/aclnn_auto_gen/'
+        aclnn_path = f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_auto_gen/'
         pathlib.Path(os.path.join(work_path, aclnn_path)).mkdir(parents=True, exist_ok=True)
     if dispatch.get("Ascend") is None:
         raise ValueError("KernelMod {} is auto generated. If need achieve it, "
@@ -208,10 +208,10 @@ def gen_aclnn_kernel(op_name, yaml_str, need_update_shape=False, auto=False):
     generate(op_name, class_name, op_yaml, kernelmod_h_and_cc_path, need_update_shape)
 
 
-def get_registed_ops(file_path='mindspore/ccsrc/plugin/device/ascend/kernel/opapi/'):
+def get_registed_ops(file_path=f'{MS_OPS_KERNEL_PATH}/ascend/opapi/'):
     '''get registered ops by search files'''
-    # default search in 'mindspore/ccsrc/plugin/device/ascend/kernel/opapi/'
-    current_path = os.path.dirname(os.path.abspath(__file__))
+    # default search in 'ops/kernel/ascend/opapi/'
+    current_path = os.path.dirname(os.path.realpath(__file__))
     work_path = os.path.join(current_path, '../../../../')
     search_path = os.path.join(work_path, file_path)
     ret = []
@@ -230,7 +230,7 @@ def get_registed_ops(file_path='mindspore/ccsrc/plugin/device/ascend/kernel/opap
 
 
 registed_ops = get_registed_ops()
-manual_registed_ops = get_registed_ops('mindspore/ccsrc/plugin/device/ascend/kernel/opapi/aclnn/')
+manual_registed_ops = get_registed_ops(f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/')
 
 
 def check_op_registed(op_name, manual=False):

mindspore/ops_generate/gen_constants.py

@@ -0,0 +1,36 @@
+# 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.
+# ============================================================================
+"""
+Generate constants
+"""
+import os
+
+# op_def
+OP_DEF_AUTO_GENERATE_PATH = "op_def/auto_generate"
+MS_OP_DEF_AUTO_GENERATE_PATH = "mindspore/ops/op_def/auto_generate"
+YAML_PATH = "op_def/yaml"
+MS_YAML_PATH = "mindspore/ops/" + YAML_PATH
+PY_AUTO_GEN_PATH = "mindspore/python/mindspore/ops/auto_generate"
+PY_OPS_GEN_PATH = "mindspore/python/mindspore/ops_generate"
+
+# infer
+MS_OPS_FUNC_IMPL_PATH = "mindspore/ops/infer/ops_func_impl"
+
+# view
+MS_OPS_VIEW_PATH = "mindspore/ops/view"
+
+# kernel
+MS_OPS_KERNEL_PATH = "mindspore/ops/kernel"
+MS_COMMON_PYBOOST_KERNEL_PATH = os.path.join(MS_OPS_KERNEL_PATH, "common/pyboost")