mindspore 2.6.0rc1__cp311-cp311-win_amd64.whl → 2.7.0__cp311-cp311-win_amd64.whl

mindspore/ops/tensor_method.py

@@ -21,11 +21,10 @@ from mindspore.ops import operations as P
 from mindspore.ops import functional as F
 from mindspore.ops.composite.multitype_ops import _compile_utils as utils
 from mindspore.ops.composite.multitype_ops._compile_utils import (
-    sequence_to_tensor, _tensor_sub, _tensor_pow, _tensor_div, _tensor_floordiv
+    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_copy_op
+    inplace_scatter_src_op, inplace_scatter_src_reduce_op, inplace_scatter_value_op, inplace_scatter_value_reduce_op
 )
 from mindspore.ops.auto_generate.gen_ops_prim import (
     floor_div_op, floor_div_scalar_op
@@ -237,7 +236,7 @@ from mindspore.ops.function.array_func import scatter
 # 92 scatter_add
 from mindspore.ops.function.array_func import tensor_scatter_add
 # 93 select
-from mindspore.ops.auto_generate import select, select_ext
+from mindspore.ops.auto_generate import select, select_ext_view
 # 94 sigmoid
 from mindspore.ops.auto_generate import sigmoid
 # 95 sin
@@ -273,7 +272,7 @@ from mindspore.ops.operations.manually_defined import tile
 # 110 topk
 from mindspore.ops.function.array_func import topk
 # 111 transpose
-from mindspore.ops.auto_generate import transpose, transpose_ext
+from mindspore.ops.auto_generate import transpose, transpose_ext_view
 # 112 tril
 from mindspore.ops.function.array_func import tril
 # 113 trunc
@@ -442,6 +441,9 @@ 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
 
@@ -503,16 +505,16 @@ def tensor_allclose(input, other, rtol=1e-05, atol=1e-08, equal_nan=False):
 
 
 # 8 any
-def tensor_any(x, axis=None, keep_dims=False):
+def reduce_tensor_any(x, axis=None, keep_dims=False):
     if axis is None:
         axis = ()
     return any(x, axis, keep_dims)
 
 
-def deprecated_tensor_any(x, dim=None, keepdim=False):
+def tensor_any(input, dim=None, keepdim=False):
     if dim is None:
         dim = ()
-    return any(x, dim, keepdim)
+    return any(input, dim, keepdim)
 
 
 # 9 arctan2
@@ -948,6 +950,10 @@ def deprecated_tensor_remainder(input, divisor):
     return remainder(input, divisor)
 
 
+def deprecated_tensor_mod(input, other):
+    return _tensor_mod(input, other)
+
+
 # 86 repeat
 def tensor_repeat(input, *repeats):
     raise RuntimeError("'repeat' is not supported on this device.")
@@ -998,7 +1004,7 @@ def deprecated_tensor_scatter_add(input, indices, updates):
 
 # 93 select
 def tensor_select_ext(input, dim, index):
-    return select_ext(input, dim, index)
+    return select_ext_view(input, dim, index)
 
 
 def deprecated_tensor_select(input, condition, y):
@@ -1170,7 +1176,7 @@ def deprecated_tensor_topk(input, k, dim=None, largest=True, sorted=True):
 
 # 111 transpose
 def tensor_transpose_ext(input, dim0, dim1):
-    return transpose_ext(input, dim0, dim1)
+    return transpose_ext_view(input, dim0, dim1)
 
 
 def deprecated_tensor_transpose(input, *axes):
@@ -1449,14 +1455,10 @@ def tensor_atanh(input):
     return F.atanh(input)
 
 
-def tensor_copy_(input, src):
+def tensor_copy_(input, src, non_blocking=False):
     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)
 
@@ -1514,6 +1516,16 @@ def tensor_empty(*size, dtype=None, device=None):
         "This is a function for empty not should be called. Please check the implementation.")
 
 
+def tensor_empty_like(input, *, dtype=None, device=None):
+    raise NotImplementedError(
+        "This is a function for empty_like should not be called. Please check the implementation.")
+
+
+def tensor_new_empty(input, size, *, dtype=None, device=None):
+    raise NotImplementedError(
+        "This is a function for new_empty should not be called. Please check the implementation.")
+
+
 def deprecated_tensor_logaddexp(input, other):
     return F.logaddexp(input, other)
 
@@ -1744,6 +1756,10 @@ def deprecated_tensor_diag(input):
     return F.diag(input)
 
 
+def deprecated_einsum(equation, operands):
+    raise NotImplementedError('einsum only supports Ascend.')
+
+
 # 916 index_add
 @constexpr
 def _check_index_add_alpha(alpha):
@@ -1808,6 +1824,8 @@ def tensor_inplace_sub(input, other, *, alpha=1):
         return sub(input, other)
     return sub_ext(input, other, alpha=alpha)
 
+def tensor_new_full(input, size, fill_value, *, dtype=None):
+    raise NotImplementedError("new_full method support Ascend only")
 
 def tensor_div_empty_(input, other, rounding_mode=None):
     raise ValueError("should not come here for div_ method.")
@@ -1840,6 +1858,14 @@ def all_gather_matmul(
     raise NotImplementedError('all_gather_matmul only supports Ascend.')
 
 
+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)
 
@@ -1884,5 +1910,27 @@ 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)
+
+
+def tensor_quant_matmul(x1, x2, scale, *, offset=None, pertoken_scale=None, bias=None, output_dtype=None,
+                        x1_dtype=None, x2_dtype=None, pertoken_scale_dtype=None, scale_dtype=None, group_sizes=None):
+    r"""
+    For details, please refer to :func:`mindspore.ops.auto_generate.quant_matmul`.
+    """
+    raise NotImplementedError('quant_matmul only supports Ascend.')
+
+
+def tensor_gmm(x, weight, *, bias=None, group_list=None, group_type=0, group_list_type=0):
+    raise NotImplementedError("gmm has not been implemented by python.")
+
+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/api/cpp_create_prim_instance_helper_generator.py

@@ -53,7 +53,7 @@ class CppCreatePrimInstanceHelperGenerator(BaseGenerator):
         """
         py_arg_default = self.generate_op_arg_default_value(op_protos)
         py_labels = self.generate_op_labels(op_protos)
-        res_str = (template.PY_LICENSE_STR + py_arg_default + py_labels)
+        res_str = template.PY_LICENSE_STR + py_arg_default + py_labels
 
         save_path = os.path.join(work_path, K.PY_AUTO_GEN_PATH)
         file_name = "cpp_create_prim_instance_helper.py"

mindspore/ops_generate/api/functional_map_cpp_generator.py

@@ -159,14 +159,6 @@ class FunctionalMapCppGenerator(BaseGenerator):
         sig_str += '}\n},'
         return sig_str
 
-    def _is_input_arg(self, arg_name, op_name):
-        res = False
-        if op_name in K.INPUT_NAME_MAP and arg_name == K.INPUT_NAME_MAP[op_name]:
-            res = True
-        elif op_name not in K.INPUT_NAME_MAP and arg_name in K.INPUT_ARGS_NAME:
-            res = True
-        return res
-
     def _generate_single_signature_str(self, func_api_name, tensor_proto, is_tensor_method) -> str:
         """
         Generates a single function signature string for the given operation prototype.
@@ -186,7 +178,7 @@ class FunctionalMapCppGenerator(BaseGenerator):
         arg_valid_types = []
         for _, arg in enumerate(op_proto.op_args):
             arg_name = arg.arg_name
-            if is_tensor_method and self._is_input_arg(arg_name, op_name):
+            if is_tensor_method and _is_input_arg(arg_name, op_name):
                 continue
 
             arg_valid_types = self._handle_arg_valid_types(arg, arg_name, arg_valid_types, func_api_name)
@@ -502,3 +494,12 @@ class FunctionalMapCppGenerator(BaseGenerator):
                 self._get_and_append_single_op_varargs_list(func_protos,
                                                             mint_varargs_list)
         return mint_varargs_list
+
+
+def _is_input_arg(arg_name, op_name):
+    res = False
+    if op_name in K.INPUT_NAME_MAP and arg_name == K.INPUT_NAME_MAP[op_name]:
+        res = True
+    elif op_name not in K.INPUT_NAME_MAP and arg_name in K.INPUT_ARGS_NAME:
+        res = True
+    return res

mindspore/ops_generate/api/functions_cc_generator.py

@@ -37,6 +37,13 @@ class FunctionsHeaderGenerator(BaseGenerator):
         """
         self.FUNCTIONS_H_TEMPLATE = template.FUNCTIONS_H_TEMPLATE
         self.function_interface_template = Template("${return_type} BACKEND_EXPORT ${op_name}(${input_args});")
+        self.function_interface_template_comm = Template(
+            "${return_type} BACKEND_EXPORT ${op_name}_inner(${input_args}," \
+            "CommHandlePtr comm_handle, const std::string& target);"
+        )
+        self.function_interface_template_comm_return_handle = Template(
+            "${return_type_with_handle} BACKEND_EXPORT ${op_name}(${input_args});"
+        )
 
     def generate(self, work_path, op_protos):
         """
@@ -48,14 +55,30 @@ class FunctionsHeaderGenerator(BaseGenerator):
         """
         functions_list = []
         for op_proto in op_protos:
-            if op_proto.op_dispatch is None or op_proto.op_dispatch.is_comm_op:
+            if op_proto.op_dispatch is None:
                 continue
             input_args_with_type_str = self._get_input_args(op_proto)
             return_type_str = _get_return_type_str(op_proto)
-            functions = self.function_interface_template.replace(op_name=op_proto.op_name,
-                                                                 input_args=input_args_with_type_str,
-                                                                 return_type=return_type_str)
+            function_template = (
+                self.function_interface_template
+                if not op_proto.op_dispatch.is_comm_op
+                else self.function_interface_template_comm
+            )
+            functions = function_template.replace(op_name=op_proto.op_name,
+                                                  input_args=input_args_with_type_str,
+                                                  return_type=return_type_str)
             functions_list.append(functions)
+            if op_proto.op_dispatch.is_comm_op:
+                return_type_with_handle = _get_return_type_with_handle_str(return_type_str)
+                functions_with_handle = (
+                    self.function_interface_template_comm_return_handle.replace(
+                        op_name=op_proto.op_name,
+                        input_args=input_args_with_type_str,
+                        return_type=return_type_str,
+                        return_type_with_handle=return_type_with_handle,
+                    )
+                )
+                functions_list.append(functions_with_handle)
         pyboost_func_h_str = self.FUNCTIONS_H_TEMPLATE.replace(op_call_with_grad=functions_list)
         save_path = os.path.join(work_path, K.MS_PYBOOST_FUNCTIONS_AUTO_GEN_PATH)
         file_name = "functions.h"
@@ -73,7 +96,7 @@ class FunctionsHeaderGenerator(BaseGenerator):
         """
         args_list = []
         for op_arg in op_proto.op_args:
-            input_dtype = get_input_dtype(op_arg.arg_dtype, is_optional_param(op_arg))
+            input_dtype = get_input_dtype(op_arg.arg_dtype, is_optional_param(op_arg), op_proto.op_view)
             args_list.append("const " + input_dtype + " &" + op_arg.arg_name)
         return args_list
 
@@ -89,12 +112,19 @@ class FunctionsGenerator(BaseGenerator):
         """
         self.FUNCTIONS_CC_TEMPLATE = template.FUNCTIONS_CC_TEMPLATE
         self.FUNCTION_BODY_TEMPLATE = template.FUNCTION_BODY_TEMPLATE
+        self.FUNCTION_COMM_BODY_TEMPLATE = template.FUNCTION_COMM_BODY_TEMPLATE
         self.pyboost_func_include_header_template = Template(
             f'#include "{K.MS_PYBOOST_BASE_PATH}/auto_generate/${{operator_name}}.h"\n'
         )
         self.clone_inplace_input_template = Template(
             'GetCloneFunc()(op, prim::kPrim${class_name}, device_target, {${grad_args}});'
         )
+        self.create_aclnn_op_template = Template(
+            'auto op = CREATE_PYBOOST_OP(${class_name}, device_target);'
+        )
+        self.create_internal_op_template = Template(
+            'auto op = CREATE_PYBOOST_SELECTED_OP(${class_name}, device_target);'
+        )
 
     def generate(self, work_path, op_protos):
         """
@@ -108,7 +138,7 @@ class FunctionsGenerator(BaseGenerator):
         op_call_with_grad_list = []
         ops_inc_head_set = set()
         for op_proto in op_protos:
-            if op_proto.op_dispatch is None or op_proto.op_dispatch.is_comm_op:
+            if op_proto.op_dispatch is None:
                 continue
             func_include_headers_list.append(
                 self.pyboost_func_include_header_template.replace(operator_name=op_proto.op_name))
@@ -137,8 +167,22 @@ class FunctionsGenerator(BaseGenerator):
         inplace_clone_args = self._get_clone_input_args(op_proto, False, False)
         clone_func_str = self._get_clone_inplace_str(op_proto.op_inplace, op_proto.op_class.name, inplace_clone_args)
         return_type_str = _get_return_type_str(op_proto)
+        if op_proto.op_dispatch.is_comm_op:
+            return_type_with_handle = _get_return_type_with_handle_str(return_type_str)
+            comm_body = self.FUNCTION_COMM_BODY_TEMPLATE.replace(op_name=op_proto.op_name,
+                                                                 class_name=op_proto.op_class.name,
+                                                                 input_args=input_args,
+                                                                 clone_func=clone_func_str,
+                                                                 input_args_with_type=input_args_with_type,
+                                                                 return_type=return_type_str,
+                                                                 return_type_with_handle=return_type_with_handle)
+            return comm_body
+        create_op_str = self.create_aclnn_op_template.replace(class_name=op_proto.op_class.name)
+        if getattr(op_proto.op_dispatch, 'internal_op_ascend') != 'None':
+            create_op_str = self.create_internal_op_template.replace(class_name=op_proto.op_class.name)
         return self.FUNCTION_BODY_TEMPLATE.replace(op_name=op_proto.op_name,
                                                    class_name=op_proto.op_class.name,
+                                                   create_op=create_op_str,
                                                    input_args=input_args,
                                                    clone_func=clone_func_str,
                                                    input_args_with_type=input_args_with_type,
@@ -157,7 +201,7 @@ class FunctionsGenerator(BaseGenerator):
         """
         args_list = []
         for op_arg in op_proto.op_args:
-            input_dtype = get_input_dtype(op_arg.arg_dtype, is_optional_param(op_arg))
+            input_dtype = get_input_dtype(op_arg.arg_dtype, is_optional_param(op_arg), op_proto.op_view)
             if has_type:
                 args_list.append("const " + input_dtype + " &" + op_arg.arg_name)
             else:
@@ -194,7 +238,7 @@ class FunctionsGenerator(BaseGenerator):
         """
         args_list = []
         for op_arg in op_proto.op_args:
-            input_dtype = get_input_dtype(op_arg.arg_dtype, is_optional_param(op_arg))
+            input_dtype = get_input_dtype(op_arg.arg_dtype, is_optional_param(op_arg), op_proto.op_view)
             if has_type:
                 args_list.append(f"const {input_dtype} &{op_arg.arg_name}")
             else:
@@ -205,6 +249,10 @@ class FunctionsGenerator(BaseGenerator):
         return args_list
 
 
+def _get_return_type_with_handle_str(return_type_str):
+    return f"std::tuple<{return_type_str}, CommHandlePtr>"
+
+
 def _get_return_type_str(op_proto):
     """
     Get the return type string for the function.
@@ -217,8 +265,8 @@ def _get_return_type_str(op_proto):
     """
     returns_type = []
     type_convert_to_base = {
-        'std::vector<mindspore::tensor::TensorPtr>': 'std::vector<mindspore::tensor::BaseTensorPtr>',
-        'mindspore::tensor::TensorPtr': 'mindspore::tensor::BaseTensorPtr'
+        'std::vector<mindspore::tensor::TensorPtr>': 'std::vector<mindspore::tensor::TensorPtr>',
+        'mindspore::tensor::TensorPtr': 'mindspore::tensor::TensorPtr'
     }
     for return_obj in op_proto.op_returns:
         temp_return = get_return_type(return_obj.arg_dtype)

mindspore/ops_generate/api/tensor_func_reg_cpp_generator.py

@@ -81,7 +81,7 @@ class TensorFuncRegCppGenerator(BaseGenerator):
             'MS_LOG(INFO) << "Call Tensor${class_name}";\n'
             'auto res = mindspore::pynative::'
             '${pyboost_function}(mindspore::prim::kPrim${class_name}, parse_args.src_types_, ${convert_args});\n'
-            'trace::Capture(parse_args.arg_list_, "${class_name}", &res);\n'
+            'trace::Capture(parse_args.arg_list_, mindspore::prim::kPrim${class_name}, &res);\n'
             'return res;\n'
         )
         self.callback_python_template = Template(

mindspore/ops_generate/common/base_generator.py

@@ -1,3 +1,17 @@
+# Copyright 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.
+# 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.
+# ============================================================================
 """
 Base generator interface for other pyboost file generator classes
 """

mindspore/ops_generate/common/gen_constants.py

@@ -54,14 +54,14 @@ ADD_MINT_DOCS_PY_PATH = "mindspore/python/mindspore/mint"
 TENSOR_PY_CC_PATH = "mindspore/ccsrc/pybind_api/ir/tensor_register/auto_generate"
 
 # yaml keys def
-OP_KEYS = {'args', 'args_signature', 'returns', 'function',
-           'class', 'view', 'dispatch', 'labels', 'bprop_expander'}
+OP_KEYS = {'args', 'args_signature', 'returns', 'function', 'class', 'view', 'graph_view', 'dispatch', 'labels',
+           'bprop_expander', 'non-differentiable'}
 ARG_KEYS = {'dtype', 'default', 'prim_init', 'type_cast', 'arg_handler'}
 RETURN_KEYS = {'dtype', 'inplace', 'type_cast'}
 ARG_SIGNATURE_KEYS = {'rw_write', 'rw_read', 'rw_ref', 'dtype_group'}
 CLASS_KEYS = {'name', 'disable'}
 FUNCTION_KEYS = {'name', 'disable'}
-DISPATCH_KEYS = {'enable', 'is_comm_op', 'Ascend', 'GPU', 'CPU'}
+DISPATCH_KEYS = {'enable', 'is_comm_op', 'Ascend', 'InternalOpAscend', 'GPU', 'CPU'}
 TENSOR_FUNC_KEYS = {'op_yaml', 'py_method', 'kwonlyargs',
                     'varargs', 'alias', 'Ascend', 'GPU', 'CPU', 'interface'}
 
@@ -89,3 +89,8 @@ MS_OPS_KERNEL_PATH = "mindspore/ops/kernel"
 MS_PYBOOST_FUNCTIONS_AUTO_GEN_PATH = "mindspore/ccsrc/pyboost/functions/auto_generate"
 MS_COMMON_PYBOOST_KERNEL_PATH = os.path.join(MS_OPS_KERNEL_PATH, "common/pyboost")
 MS_PYBOOST_BASE_PATH = "mindspore/ccsrc/pyboost"
+MS_PYBOOST_INTERNAL_FUNCTIONS_AUTO_GEN_PATH = os.path.join(MS_OPS_KERNEL_PATH,
+                                                           "ascend/pyboost/internal/functions")
+MS_INTERNAL_PYBOOST_GEN_PATH = "mindspore/ccsrc/plugin/device/ascend/kernel/internal/pyboost/auto_gen"
+MS_PLUGIN_INTERNAL_PATH = "mindspore/ccsrc/plugin/device/ascend/kernel/internal"
+MS_OPS_PYBOOST_INTERNAL = "mindspore/ops/kernel/ascend/pyboost/internal"

mindspore/ops_generate/common/gen_utils.py

@@ -121,25 +121,6 @@ def merge_files(origin_dir, merged_file_path, file_format):
     merge_files_to_one_file(op_yaml_file_names, merged_file_path)
 
 
-def merge_files_append(origin_dir, merged_file_path, file_format):
-    """
-    Merge multiple files into one file.
-    origin_dir: indicates the origin file directory.
-    merged_file_path: indicates the merged file path.
-    file_format: indicates the format of regular matching.
-    Files whose names meet the regular matching in 'origin_dir' directory will be merged into one file.
-    """
-    file_paths = glob.glob(os.path.join(origin_dir, file_format))
-    merged_content = ''
-    file_paths.sort()
-    for file_path in file_paths:
-        with open(file_path, 'r') as file:
-            merged_content += file.read()
-            merged_content += '\n'
-    with open(merged_file_path, 'a') as file:
-        file.write(merged_content)
-
-
 def safe_load_yaml(yaml_file_path):
     """
     Load yaml dictionary from file.

mindspore/ops_generate/common/op_proto.py

@@ -112,10 +112,12 @@ class OpDispatch:
         gpu (str): The dispatch type for the GPU.
     """
 
-    def __init__(self, enable=False, is_comm_op=False, ascend='default', cpu='default', gpu='default'):
+    def __init__(self, enable=False, is_comm_op=False, ascend='default',
+                 internal_op_ascend='None', cpu='default', gpu='default'):
         self.enable = enable
         self.is_comm_op = is_comm_op
         self.ascend = ascend
+        self.internal_op_ascend = internal_op_ascend
         self.cpu = cpu
         self.gpu = gpu
 
@@ -151,7 +153,8 @@ class OpProto:
                  op_inplace=False,
                  op_labels=None,
                  op_deprecated=None,
-                 bprop_expander=True):
+                 bprop_expander=True,
+                 non_differentiable=False):
         self.op_name = op_name
         self.op_args = op_args
         self.op_function = op_function
@@ -165,6 +168,7 @@ class OpProto:
         self.op_labels = op_labels
         self.op_deprecated = op_deprecated
         self.bprop_expander = bprop_expander
+        self.non_differentiable = non_differentiable
 
     @staticmethod
     def load_from_yaml(op_name, op_data):
@@ -208,10 +212,12 @@ class OpProto:
         # get op deprecated
         op_deprecated = op_data.get('deprecated', None)
         bprop_expander = op_data.get('bprop_expander', True)
+        non_differentiable = op_data.get('non-differentiable', False)
         op_proto = OpProto(op_name=op_name, op_args=op_args, op_returns=op_returns, op_function=op_function,
                            op_class=op_class, op_dispatch=op_dispatch, op_args_signature=op_args_signature,
                            op_view=op_view, op_graph_view=op_graph_view, op_inplace=op_inplace, op_labels=op_labels,
-                           op_deprecated=op_deprecated, bprop_expander=bprop_expander)
+                           op_deprecated=op_deprecated, bprop_expander=bprop_expander,
+                           non_differentiable=non_differentiable)
         return op_proto
 
 
@@ -401,9 +407,10 @@ def get_op_dispatch(op_name, op_data):
             f'The dispatch enable value should be bool, but get {type(enable)}, op name is {op_name}.')
     is_comm_op = op_dispatch.get('is_comm_op', False)
     ascend = op_dispatch.get('Ascend', 'default')
+    internal_op_ascend = op_dispatch.get('InternalOpAscend', 'None')
     cpu = op_dispatch.get('CPU', 'default')
     gpu = op_dispatch.get('GPU', 'default')
-    return OpDispatch(enable, is_comm_op, ascend, cpu, gpu)
+    return OpDispatch(enable, is_comm_op, ascend, internal_op_ascend, cpu, gpu)
 
 
 def get_op_class(op_name, op_data) -> OpClass:

mindspore/ops_generate/common/template.py

@@ -93,7 +93,6 @@ ${func_impl_name}_impl = _Pyboost${class_name}Prim()
 """)
 
 IMPORT_PYBOOST_PRIM_HEADER = f"""
-from mindspore.common._stub_tensor import _convert_stub
 from mindspore.ops._utils.arg_handler import *
 """
 
@@ -118,19 +117,89 @@ REGISTER_PYBOOST_GRAD_DEFINE_TEMPLATE = Template(
 REGISTER_PYBOOST_GRAD_TEMPLATE = Template("${register_func}")
 
 PYBOOST_FUNCTION_HEADER_TEMPLATE = Template.load_from_file(
-    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_functions_h.tpl'))
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_api_h.tpl'))
 
-PYBOOST_FUNCTION_TEMPLATE = Template.load_from_file(
-    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_function.tpl'))
+PYBOOST_CORE_HEADER_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_core_header.tpl'))
+PYBOOST_INTERNAL_OP_HEADER_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/internal/template/pyboost_internal_header_template.tpl'))
+
+PYBOOST_INTERNAL_SINGLE_OP_HEADER_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'./{K.MS_OPS_PYBOOST_INTERNAL}/template/pyboost_internal_single_op_header_template.tpl'))
+
+PYBOOST_INTERNAL_SINGLE_OP_SOURCE_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'./{K.MS_OPS_PYBOOST_INTERNAL}/template/pyboost_internal_single_op_source_template.tpl'))
+
+PYBOOST_INTERNAL_SINGLE_OP_CUSTOMIZE_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'./{K.MS_OPS_PYBOOST_INTERNAL}/template/pyboost_internal_single_op_customize_source_template.tpl'))
+
+PYBOOST_INTERNAL_OP_SOURCE_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'./{K.MS_OPS_PYBOOST_INTERNAL}/template/pyboost_internal_source_template.tpl'))
+
+PYBOOST_INTERNAL_FUNCTION_HEADER_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_OPS_PYBOOST_INTERNAL}/template/pyboost_internal_functions_header_template.tpl'))
+
+PYBOOST_INTERNAL_FUNCTION_SOURCE_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_OPS_PYBOOST_INTERNAL}/template/pyboost_internal_functions_source_template.tpl'))
+
+PYBOOST_INTERNAL_FUNCTION_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_OPS_PYBOOST_INTERNAL}/template/pyboost_internal_function_template.tpl'))
+
+PYBOOST_KERNEL_INFO_ADAPTER_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_PLUGIN_INTERNAL_PATH}/pyboost/template/kernel_info_adapter.tpl'))
+
+PYBOOST_KERNEL_INFO_ADAPTER_H_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_PLUGIN_INTERNAL_PATH}/pyboost/template/kernel_info_adapter_h.tpl'))
+
+PYBOOST_INTERNAL_KERNEL_INFO_ADAPTER_H_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_PLUGIN_INTERNAL_PATH}/pyboost/template/internal_kernel_info_adapter_h.tpl'))
+
+PYBOOST_INTERNAL_KERNEL_INFO_ADAPTER_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_PLUGIN_INTERNAL_PATH}/pyboost/template/internal_kernel_info_adapter.tpl'))
+
+PYBOOST_INTERNAL_KERNEL_INFO_ADAPTER_CPP_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_PLUGIN_INTERNAL_PATH}/pyboost/template/internal_kernel_info_adapter_cpp.tpl'))
+
+PYBOOST_INTERNAL_KERNEL_INFO_ADAPTER_SINGLE_CPP_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'{K.MS_PLUGIN_INTERNAL_PATH}/pyboost/template/internal_kernel_info_adapter_single_cpp.tpl'))
 
-PYBOOST_COMM_FUNCTION_TEMPLATE = Template.load_from_file(
-    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_comm_function.tpl'))
+PYBOOST_REGISTRY_BODY_CC_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_registry_body_cc.tpl'))
 
-PYBOOST_FUNCTION_DYNAMIC_OUTPUT_TEMPLATE = Template.load_from_file(
-    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_function_dynamic_output.tpl'))
+PYBOOST_CORE_BODY_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_core_body.tpl'))
 
-PYBOOST_FUNCTIONS_CC_TEMPLATE = Template.load_from_file(
-    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_functions_cc.tpl'))
+PYBOOST_CORE_BODY_COMM_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_core_body_comm.tpl'))
+
+PYBOOST_CORE_BODY_SYNC_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_core_body_sync.tpl'))
+
+PYBOOST_REGISTRY_CC_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_registry_cc.tpl'))
+
+PYBOOST_API_CC_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_api_cc.tpl'))
+
+PYBOOST_API_BODY_CC_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_api_body_cc.tpl'))
+
+PYBOOST_CORE_CC_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/pyboost_core_cc.tpl'))
 
 PYBOOST_OVERLOAD_FUNCTIONS_CC_TEMPLATE = Template.load_from_file(
     os.path.join(
@@ -213,6 +282,10 @@ PYBOOST_OP_REGISTER_TEMPLATE = Template.load_from_file(
 PYBOOST_ASCEND_OP_HEADER_TEMPLATE = Template.load_from_file(
     os.path.join(K.WORK_DIR,
                  f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/template/pyboost_aclnn_header_template.tpl'))
+PYBOOST_ASCEND_INTERNAL_OP_HEADER_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR,
+                 f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/internal/template/pyboost_internal_header_template.tpl')
+)
 
 PYBOOST_ASCEND_OP_SOURCE_TEMPLATE = Template.load_from_file(
     os.path.join(K.WORK_DIR,
@@ -226,6 +299,8 @@ PYBOOST_ASCEND_SINGLE_HCLL_OP_HEADER_TEMPLATE = Template.load_from_file(
     os.path.join(K.WORK_DIR,
                  f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/template/pyboost_aclnn_single_hccl_op_header_template.tpl'))
 
+PYBOOST_CALL_FUNC_TEMPLATE = Template('${return_type} Call(${call_args_with_type}) override;')
+
 PYBOOST_ASCEND_SINGLE_OP_SOURCE_TEMPLATE = Template.load_from_file(
     os.path.join(K.WORK_DIR,
                  f'./{K.MS_OPS_KERNEL_PATH}/ascend/pyboost/template/pyboost_aclnn_single_op_source_template.tpl'))
@@ -373,7 +448,6 @@ from mindspore.ops._primitive_cache import _get_cache_prim
 from mindspore.ops._utils.arg_dtype_cast import type_it
 from mindspore.ops._utils.arg_handler import *
 from mindspore._c_expression import OpDtype
-from mindspore.common._stub_tensor import _convert_stub
 from mindspore.common.jit_context import jit_context
 from mindspore._checkparam import is_stub_tensor
 """
@@ -509,6 +583,9 @@ FUNCTIONS_CC_TEMPLATE = Template.load_from_file(
 FUNCTION_BODY_TEMPLATE = Template.load_from_file(
     os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/function_body.tpl'))
 
+FUNCTION_COMM_BODY_TEMPLATE = Template.load_from_file(
+    os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/comm_function_body.tpl'))
+
 FUNCTIONS_H_TEMPLATE = Template.load_from_file(
     os.path.join(K.WORK_DIR, './mindspore/ccsrc/pynative/op_function/template/functions_h.tpl'))