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

mindspore/ops_generate/gen_ops.py

@@ -47,6 +47,6 @@ def main():
 if __name__ == "__main__":
     try:
         main()
-    except Exception as e: # pylint: disable=broad-except
+    except Exception as e:
         logging.critical("Auto generate failed, err info: %s", e)
         raise e

mindspore/ops_generate/op_def/lite_ops_cpp_generator.py

@@ -24,7 +24,6 @@ import common.template as template
 from common.base_generator import BaseGenerator
 from pyboost import pyboost_utils
 
-
 LITE_OPS_H = """
 #ifndef MINDSPORE_CORE_OPS_GEN_LITE_OPS_H_
 #define MINDSPORE_CORE_OPS_GEN_LITE_OPS_H_
@@ -122,9 +121,10 @@ class LiteOpsCcGenerator(BaseGenerator):
         self.inc_ops_head_templat = template.Template(INC_OPS_HEAD)
         self.lite_ops_cc_template = template.Template(LITE_OPS_CC)
         self.op_template = template.op_template
-        self.register_primitive_c_template = template.Template("${op_name}::${op_name}():BaseOperator(kName${op_name}) {}\n"
-                                                               "REGISTER_PRIMITIVE_C(kName${op_name}, ${op_name});\n"
-                                                               "MIND_API_OPERATOR_IMPL(${op_name}, BaseOperator);\n\n")
+        self.register_primitive_c_template = template.Template(
+            "${op_name}::${op_name}():BaseOperator(kName${op_name}) {}\n"
+            "REGISTER_PRIMITIVE_C(kName${op_name}, ${op_name});\n"
+            "MIND_API_OPERATOR_IMPL(${op_name}, BaseOperator);\n\n")
 
     def generate(self, work_path, op_protos):
         """

mindspore/ops_generate/op_def/ops_def_cc_generator.py

@@ -101,9 +101,6 @@ class OpsDefCcGenerator(BaseGenerator):
                                                        is_graph_view=is_graph_view,
                                                        func_impl_declaration=func_impl_declaration_str,
                                                        func_impl_define=func_impl_define)
-            if op_proto.op_view:
-                view_op_def = op_def_cc.replace(class_name, class_name + "View")
-                op_def_cc += view_op_def
 
             if "deprecated" not in operator_name:
                 gen_cc_list.append(op_def_cc)

mindspore/ops_generate/op_def/ops_name_h_generator.py

@@ -19,15 +19,12 @@ This module defines the `OpsNameHGenerator` class, which produces C++ code to de
 constants for operator names based on given prototypes.
 """
 
-import os
-
 import common.gen_constants as K
 import common.gen_utils as gen_utils
 import common.template as template
 from common.base_generator import BaseGenerator
 from pyboost import pyboost_utils
 
-
 OP_NAME_OP_DEF = """
 #ifndef MINDSPORE_CORE_OP_NAME_${suffix}_H_
 #define MINDSPORE_CORE_OP_NAME_${suffix}_H_

mindspore/ops_generate/op_def/ops_primitive_h_generator.py

@@ -19,15 +19,12 @@ This module defines the `OpsPrimitiveHGenerator` class, which creates C++ header
 containing definitions for operator primitives based on provided operator prototypes.
 """
 
-import os
-
 import common.gen_constants as K
 import common.gen_utils as gen_utils
 import common.template as template
 from common.base_generator import BaseGenerator
 from pyboost import pyboost_utils
 
-
 OP_PRIM_OP_DEF_H = """
 #ifndef MINDSPORE_CORE_OPS_GEN_OPS_PRIMITIVE_${suffix}_H_
 #define MINDSPORE_CORE_OPS_GEN_OPS_PRIMITIVE_${suffix}_H_
@@ -42,7 +39,6 @@ $ops_prim_gen
 #endif  // MINDSPORE_CORE_OPS_GEN_OPS_PRIMITIVE_${suffix}_H_
 """
 
-
 OP_PRIM_OP_DEF_CC = """
 
 #include "$auto_gen_path/gen_ops_primitive_${suffix}.h"

mindspore/ops_generate/op_def_py/op_prim_py_generator.py

@@ -142,7 +142,10 @@ class OpPrimPyGenerator(BaseGenerator):
                 # step1.3: get args set prim arg expression:
                 assign_str = self._get_assign_str_by_type_it(op_proto.op_class.name, arg)
                 if arg.arg_handler:
-                    assign_str = f"""        self._set_prim_arg_with_handler("{arg.arg_name}", {assign_str}, {arg.arg_handler})"""
+                    assign_str = (
+                        f'        self._set_prim_arg_with_handler('
+                        f'"{arg.arg_name}", {assign_str}, {arg.arg_handler})'
+                    )
                 else:
                     assign_str = f"""        self._set_prim_arg("{arg.arg_name}", {assign_str})"""
                 args_assign.append(assign_str)
@@ -318,7 +321,7 @@ class OpPrimPyGenerator(BaseGenerator):
             call_method_body_str += f"""
         # Add for jit context.
         if jit_context() and jit_context().compiled:
-            return None"""
+            return jit_context().default_output()"""
             pyboost_func_name = pyboost_utils.get_pyboost_name(op_proto.op_name)
             call_method_body_str += f"""
         res = {pyboost_func_name}(self, [{call_args_list_str}])"""

mindspore/ops_generate/pyboost/auto_grad_impl_cc_generator.py

@@ -58,7 +58,7 @@ class AutoGradImplGenerator(BaseGenerator):
         do_grad_op_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
             auto_grad_reg_list.append(self.auto_grad_reg_template.replace(class_name=op_proto.op_class.name))
             do_grad_op_list.append(self._get_single_do_grad_op(op_proto))
@@ -80,24 +80,38 @@ class AutoGradImplGenerator(BaseGenerator):
         Returns:
             str: The generated DoGrad function string.
         """
-        input_args_str = self._get_input_args(op_proto, False, False)
-        input_args_with_optional_str = self._get_input_args(op_proto, False, True)
-        input_args_with_type_str = self._get_input_args(op_proto, True, False)
+        input_args_str = self._get_input_args(op_proto, False, False, op_proto.op_view)
+        input_args_with_optional_str = self._get_input_args(op_proto, False, True, op_proto.op_view)
+        input_args_with_type_str = self._get_input_args(op_proto, True, False, op_proto.op_view)
+        inner_grad_args_with_type = self._get_input_args(op_proto, True, False, False)
         multi_output_str = 'Multi' if is_op_multi_output(op_proto.op_returns) else ''
         view_arg_str = self._get_view_str(op_proto.op_view, input_args_str)
         grad_args_with_type_str = self.do_grad_op_args_with_type.replace(input_args_with_type=input_args_with_type_str)
+        inner_grad_args_with_type =\
+            self.do_grad_op_args_with_type.replace(input_args_with_type=inner_grad_args_with_type)
         op_def_name_str = "g" + op_proto.op_class.name
-        bprop_expander = "true" if op_proto.bprop_expander else "false"
+        TRUE = "true"
+        FALSE = "false"
+        bprop_expander = TRUE if op_proto.bprop_expander else FALSE
+        non_differentiable = TRUE if op_proto.non_differentiable else FALSE
+        if not op_proto.op_view:
+            convert_basic_to_value = ''
+        else:
+            input_args_with_optional_str, convert_basic_to_value = self._get_convert_str(op_proto,
+                                                                                         input_args_with_optional_str)
         return self.DO_GRAD_FUNCTION_BODY_TEMPLATE.replace(class_name=op_proto.op_class.name,
+                                                           inner_grad_args_with_type=inner_grad_args_with_type,
                                                            grad_args_with_type=grad_args_with_type_str,
                                                            grad_input_args=input_args_str,
                                                            grad_input_args_with_optional=input_args_with_optional_str,
                                                            is_multi=multi_output_str,
                                                            view_arg=view_arg_str,
                                                            op_def_name=op_def_name_str,
-                                                           bprop_expander=bprop_expander)
+                                                           bprop_expander=bprop_expander,
+                                                           non_differentiable=non_differentiable,
+                                                           convert_basic_to_value=convert_basic_to_value)
 
-    def _get_input_args(self, op_proto, has_type, with_optional):
+    def _get_input_args(self, op_proto, has_type, with_optional, use_basic_type=False):
         """
         Get the input arguments for the DoGrad function.
 
@@ -110,7 +124,7 @@ class AutoGradImplGenerator(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), use_basic_type)
             if has_type:
                 args_list.append(f"const {input_dtype} &{op_arg.arg_name}_tensor")
             else:
@@ -120,6 +134,33 @@ class AutoGradImplGenerator(BaseGenerator):
                     args_list.append(f"{op_arg.arg_name}_tensor")
         return args_list
 
+    def _get_convert_str(self, op_proto, args_name):
+        """
+        Get the input convert func for the DoGrad function.
+
+        Args:
+            op_proto: The operator prototype.
+            has_type (bool): Whether to include type information for the arguments.
+
+        Returns:
+            list: A list of input arguments for the DoGrad function.
+            list: A list of convert functions.
+        """
+        args_name_list = []
+        convert_funcs = []
+        convert_types = ["tuple[int]", "list[int]", "int"]
+        convert_func_template = Template("const auto &${arg_name} = PackToValue(${input_name});")
+        for op_arg, arg_name in zip(op_proto.op_args, args_name):
+            if op_arg.arg_dtype not in convert_types:
+                args_name_list.append(arg_name)
+                continue
+            out_arg_name = arg_name + "_value"
+            input_name = arg_name
+            convert_funcs.append(convert_func_template.replace(arg_name=out_arg_name,
+                                                               input_name=input_name))
+            args_name_list.append(out_arg_name)
+        return args_name_list, convert_funcs
+
     def _get_view_str(self, is_view_op: bool, grad_args: list):
         """
         Get the view argument string for a DoGrad function.

mindspore/ops_generate/pyboost/auto_grad_reg_cc_generator.py

@@ -56,7 +56,7 @@ class AutoGradRegHeaderGenerator(BaseGenerator):
         op_grad_func_obj_list = []
         index = 0
         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
             op_type_enum_list.append(self.op_type_enum_template.replace(class_name=op_proto.op_class.name,
                                                                         enum_val=index))
@@ -87,7 +87,7 @@ class AutoGradRegHeaderGenerator(BaseGenerator):
         input_tensor_prt_args_str = ""
         for op_arg in op_proto.op_args:
             is_optional = is_optional_param(op_arg)
-            input_dtype = get_input_dtype(op_arg.arg_dtype, is_optional)
+            input_dtype = get_input_dtype(op_arg.arg_dtype, is_optional, op_proto.op_view)
             input_tensor_prt_args_str += f"const {input_dtype} &, "
 
         return self.op_grad_func_args_template.replace(input_tensor_prt_args=input_tensor_prt_args_str.rstrip(', '))

mindspore/ops_generate/pyboost/gen_pyboost_func.py

@@ -16,9 +16,6 @@
 Generate pyboost function from pyboost_op.yaml
 """
 
-import os
-import shutil
-import logging
 from resources.resource_list import ResourceType
 from common import gen_constants as K
 from api.functions_cc_generator import FunctionsGenerator, FunctionsHeaderGenerator
@@ -26,7 +23,11 @@ from .pyboost_inner_prim_generator import PyboostInnerPrimGenerator
 from .pyboost_functions_py_generator import PyboostFunctionsPyGenerator
 from .pyboost_functions_h_generator import PyboostFunctionsHeaderGenerator
 from .pyboost_functions_cpp_generator import PyboostFunctionsGenerator
+from .pyboost_functions_impl_cpp_generator import PyboostFunctionsImplGenerator
 from .pyboost_grad_function_cpp_generator import PyboostGradFunctionsGenerator
+from .pyboost_internal_functions_h_generator import PyboostInternalFunctionsHeaderGenerator
+from .pyboost_internal_functions_cpp_generator import PyboostInternalFunctionsCppGenerator
+from .pyboost_internal_kernel_info_adapter_generator import PyboostKernelInfoAdapterGenerator
 from .pyboost_native_grad_functions_generator import (
     PyboostGradFunctionsHeaderGenerator,
     PyboostGradFunctionsCppGenerator,
@@ -35,6 +36,7 @@ from .pyboost_op_cpp_code_generator import (
     PyboostCommonOpHeaderGenerator,
     PyboostOpFunctionGenerator,
     PyboostOpHeaderGenerator,
+    PyboostInternalOpHeaderGenerator,
     delete_residual_files,
     PyboostOpRegisterCppCodeGenerator,
 )
@@ -43,18 +45,6 @@ from .auto_grad_impl_cc_generator import AutoGradImplGenerator
 from .auto_grad_reg_cc_generator import AutoGradRegHeaderGenerator
 
 
-def clear_old_generated_code(work_path):
-    """ delete old generated files to prevent compilation failure """
-    files_to_clear = ['mindspore/ops/kernel/common/pyboost',
-                      'mindspore/ops/kernel/functions/auto_generate',
-                      'mindspore/ccsrc/runtime/pynative/op_function']
-    for f in files_to_clear:
-        real_path = os.path.join(work_path, f)
-        if os.path.exists(real_path):
-            shutil.rmtree(real_path)
-            logging.warning("rm file %s", real_path)
-
-
 def gen_pyboost_code(resource_mgr):
     """ gen_pyboost_code """
     work_path = K.WORK_DIR
@@ -62,12 +52,14 @@ def gen_pyboost_code(resource_mgr):
     doc_yaml_data = resource_mgr.get_resource(ResourceType.OP_DOC_YAML)
     mint_func_protos = resource_mgr.get_resource(ResourceType.MINT_FUNC_PROTOS)
     alias_func_mapping = resource_mgr.get_resource(ResourceType.ALIAS_API_MAPPING)
-    clear_old_generated_code(work_path)
     call_pyboost_inner_prim_generator(work_path, op_protos)
     call_pyboost_functions_py_generator(work_path, op_protos, doc_yaml_data)
     call_pyboost_functions_h_generator(work_path, op_protos)
     call_pyboost_functions_cpp_generator(work_path, op_protos)
     call_pyboost_overload_functions_cpp_generator(work_path, op_protos, mint_func_protos, alias_func_mapping)
+    call_pyboost_internal_functions_h_generator(work_path, op_protos)
+    call_pyboost_internal_functions_cpp_generator(work_path, op_protos)
+    call_pyboost_internal_kernel_info_adapter_generator(work_path, op_protos)
     call_pyboost_grad_functions_cpp_generator(work_path, op_protos)
     call_pyboost_native_grad_functions_generator(work_path, op_protos)
     call_pyboost_op_cpp_code_generator(work_path, op_protos)
@@ -117,7 +109,27 @@ def call_pyboost_functions_h_generator(work_path, op_protos):
     generator.generate(work_path, op_protos)
 
 
+def call_pyboost_internal_functions_h_generator(work_path, op_protos):
+    "gen internal op functions headers"
+    generator = PyboostInternalFunctionsHeaderGenerator()
+    generator.generate(work_path, op_protos)
+
+
+def call_pyboost_internal_functions_cpp_generator(work_path, op_protos):
+    "gen internal op functions sources"
+    generator = PyboostInternalFunctionsCppGenerator()
+    generator.generate(work_path, op_protos)
+
+
+def call_pyboost_internal_kernel_info_adapter_generator(work_path, op_protos):
+    "gen kernel info adapter for internal op"
+    generator = PyboostKernelInfoAdapterGenerator()
+    generator.generate(work_path, op_protos)
+
+
 def call_pyboost_functions_cpp_generator(work_path, op_protos):
+    impl_generator = PyboostFunctionsImplGenerator()
+    impl_generator.generate(work_path, op_protos)
     generator = PyboostFunctionsGenerator()
     generator.generate(work_path, op_protos)
 
@@ -160,8 +172,11 @@ def call_PyboostCommonOpCppCodeGenerator(work_path, op_protos):
 
 
 def call_PyboostOpHeaderGenerator(work_path, op_protos):
+    """ generate pyboost op headers """
     generator = PyboostOpHeaderGenerator('ascend')
     generator.generate(work_path, op_protos)
+    generator = PyboostInternalOpHeaderGenerator('ascend')
+    generator.generate(work_path, op_protos)
 
     generator = PyboostOpHeaderGenerator('gpu')
     generator.generate(work_path, op_protos)

mindspore/ops_generate/pyboost/op_template_parser.py

@@ -29,7 +29,7 @@ from common.op_proto import OpProto
 from . import pyboost_utils
 from .pyboost_utils import get_input_dtype, tuple_input_to_cpp_type, get_return_type, \
     number_input_to_cpp_type, get_const_number_convert, get_tuple_input_convert, is_optional_param, \
-    get_input_args_type_str
+    get_input_args_type_str, basic_type_convert_str, input_dtype_to_cpp_type
 
 
 class OpTemplateParser:
@@ -45,8 +45,42 @@ class OpTemplateParser:
 
     def __init__(self, op_proto: OpProto):
         self.op_proto = op_proto
-
-    def _parse_call_args_types(self, op_args):
+        self.tensor_arg_handler_prt_template = Template(
+            "parse_args.arg_list_[${idx}] = "
+            "py::cast((*pynative::${func_str}(\"${func_name}\", \"${op_arg_name}\", "
+            "parse_args.arg_list_[${idx}]))->value());\n"
+            "parse_args.src_types_[${idx}] = ops::OP_DTYPE::DT_BEGIN;\n"
+            "parse_args.dst_types_[${idx}] = ${new_type};\n"
+        )
+        self.function_arg_handler_prt_template = Template(
+            "parse_args.arg_list_[${idx}] = "
+            "py::cast((*${func_str}(\"${func_name}\", \"${op_arg_name}\", parse_args.arg_list_[${idx}]))->value());\n"
+            "parse_args.src_types_[${idx}] = ops::OP_DTYPE::DT_BEGIN;\n"
+            "parse_args.dst_types_[${idx}] = ${new_type};\n"
+        )
+        self.arg_handler_template = Template(
+            "parse_args.arg_list_[${idx}] = "
+            "py::cast(pynative::${func_str}(\"${func_name}\", \"${op_arg_name}\", parse_args.arg_list_[${idx}]));\n"
+            "parse_args.src_types_[${idx}] = ops::OP_DTYPE::DT_BEGIN;\n"
+            "parse_args.dst_types_[${idx}] = ${new_type};\n"
+        )
+        self.arg_handler_optional_template = Template(
+            'if (!py::isinstance<py::none>(parse_args.arg_list_[${idx}])) {\n'
+            '  ${arg_handler_str}\n'
+            '}\n'
+        )
+        self.arg_handler_type_map = {"to_2d_paddings": "ops::OP_DTYPE::DT_TUPLE_INT",
+                                     "dtype_to_type_id": "ops::OP_DTYPE::DT_INT",
+                                     "to_kernel_size": "ops::OP_DTYPE::DT_TUPLE_INT",
+                                     "to_strides": "ops::OP_DTYPE::DT_TUPLE_INT",
+                                     "str_to_enum": "ops::OP_DTYPE::DT_INT",
+                                     "to_pair": "ops::OP_DTYPE::DT_TUPLE_INT",
+                                     "to_dilations": "ops::OP_DTYPE::DT_TUPLE_INT",
+                                     "to_output_padding": "ops::OP_DTYPE::DT_TUPLE_INT",
+                                     "to_rates": "ops::OP_DTYPE::DT_TUPLE_INT"}
+
+    @staticmethod
+    def _parse_call_args_types(op_proto, basic_type=False, is_convert=False):
         """
         Parses the data types of the call arguments for the operator.
 
@@ -57,22 +91,37 @@ class OpTemplateParser:
             list: A list of data types for the call arguments.
         """
         call_args_types = []
-        for op_arg in op_args:
+        if basic_type and not op_proto.op_view:
+            basic_type = False
+            raise Exception("Only view op support basic type now, please check.")
+        for op_arg in op_proto.op_args:
             is_optional = is_optional_param(op_arg)
-            call_args_types.append(get_input_dtype(
-                op_arg.arg_dtype, is_optional))
+            if is_convert:
+                if op_arg.is_type_id:
+                    call_args_types.append('TypeId')
+                    continue
+                call_args_types.append(input_dtype_to_cpp_type(
+                    op_arg.arg_dtype, is_optional))
+            else:
+                call_args_types.append(get_input_dtype(
+                    op_arg.arg_dtype, is_optional, basic_type))
         return call_args_types
 
-    def parse_call_args_with_types(self):
+    def parse_call_args_with_types(self, basic_type=False, is_convert=False):
         """
         Parses the original call arguments and their types for the operator.
 
         Returns:
             list: A list of formatted strings representing the call arguments with their types.
         """
-        call_args = self.parse_original_call_args(self.op_proto.op_args)
-        call_args_types = self._parse_call_args_types(self.op_proto.op_args)
+        call_args = OpTemplateParser.parse_original_call_args(self.op_proto.op_args)
+        call_args_after_convert, _, _ = self.op_args_converter()
+        call_args_types = self._parse_call_args_types(self.op_proto, basic_type, is_convert)
         call_args_with_types = []
+        if is_convert:
+            for type_name, arg_name in zip(call_args_types, call_args_after_convert):
+                call_args_with_types.append("const " + type_name + " &" + arg_name)
+            return call_args_with_types
         for type_name, arg_name in zip(call_args_types, call_args):
             call_args_with_types.append("const " + type_name + " &" + arg_name)
         return call_args_with_types
@@ -90,7 +139,7 @@ class OpTemplateParser:
         need_malloc_tensors = []
         tensor_list_convert = []
         call_args_with_tensor = []
-        call_args = self.parse_original_call_args(self.op_proto.op_args)
+        call_args = OpTemplateParser.parse_original_call_args(self.op_proto.op_args)
         for op_arg, call_arg in zip(self.op_proto.op_args, call_args):
             if pyboost_utils.is_tensor(op_arg):
                 call_arg = op_arg.arg_name + "_tensor"
@@ -105,7 +154,8 @@ class OpTemplateParser:
                 call_args_with_tensor.append(call_arg)
         return need_malloc_tensors, tensor_list_convert, call_args_with_tensor
 
-    def parse_original_call_args(self, op_args):
+    @staticmethod
+    def parse_original_call_args(op_args):
         """
         Parses the original call arguments from the operator prototype.
 
@@ -139,7 +189,7 @@ class OpTemplateParser:
         call_args_after_convert = []
         value_tuple_convert = []
         const_number_convert = []
-        call_args = self.parse_original_call_args(self.op_proto.op_args)
+        call_args = OpTemplateParser.parse_original_call_args(self.op_proto.op_args)
         for op_arg, call_arg in zip(self.op_proto.op_args, call_args):
             if number_input_to_cpp_type(op_arg.arg_dtype):
                 call_args_after_convert.append(call_arg + "_imm")
@@ -199,8 +249,7 @@ class OpTemplateParser:
         args_signature = self.op_proto.op_args_signature
         if args_signature is not None:
             dtype_group = args_signature.dtype_group
-            indexes = {arg.arg_name: index for index,
-                       arg in enumerate(self.op_proto.op_args)}
+            indexes = {arg.arg_name: index for index, arg in enumerate(self.op_proto.op_args)}
             if dtype_group is not None:
                 match = re.findall(r'\((.*?)\)', dtype_group)
                 for item in match:
@@ -223,10 +272,10 @@ class OpTemplateParser:
             list: A list of call arguments that are tensors.
         """
         call_args_tensor = []
-        call_args_types = self._parse_call_args_types(self.op_proto.op_args)
-        call_args = self.parse_original_call_args(self.op_proto.op_args)
+        call_args_types = self._parse_call_args_types(self.op_proto)
+        call_args = OpTemplateParser.parse_original_call_args(self.op_proto.op_args)
         for _type, arg_name in zip(call_args_types, call_args):
-            if _type in ("mindspore::tensor::BaseTensorPtr", "std::optional<mindspore::tensor::BaseTensorPtr>"):
+            if _type in ("mindspore::tensor::TensorPtr", "std::optional<mindspore::tensor::TensorPtr>"):
                 call_args_tensor.append(arg_name)
         return call_args_tensor
 
@@ -258,8 +307,8 @@ class OpTemplateParser:
         """
         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 self.op_proto.op_returns:
             temp_return = get_return_type(return_obj.arg_dtype)
@@ -316,14 +365,6 @@ class OpTemplateParser:
 
         return op_outputs, call_outputs
 
-    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_signature_str(self, kw_only_args=None, varargs=None, *, is_tensor_api: bool) -> str:
         """
         Generates a single function signature string for the given operation prototype.
@@ -348,7 +389,7 @@ class OpTemplateParser:
         for arg in self.op_proto.op_args:
             arg_name = arg.arg_name
 
-            if is_tensor_api and self._is_input_arg(arg_name, op_name):
+            if is_tensor_api and _is_input_arg(arg_name, op_name):
                 continue
 
             single_arg = ''
@@ -398,42 +439,9 @@ class OpTemplateParser:
         Returns:
             str: Generated argument handler processing code.
         """
-        tensor_arg_handler_prt_template = Template(
-            "parse_args.arg_list_[${idx}] = "
-            "py::cast((*pynative::${func_str}(\"${func_name}\", \"${op_arg_name}\", \
-parse_args.arg_list_[${idx}]))->value());\n"
-            "parse_args.src_types_[${idx}] = ops::OP_DTYPE::DT_BEGIN;\n"
-            "parse_args.dst_types_[${idx}] = ${new_type};\n"
-        )
-        function_arg_handler_prt_template = Template(
-            "parse_args.arg_list_[${idx}] = "
-            "py::cast((*${func_str}(\"${func_name}\", \"${op_arg_name}\", parse_args.arg_list_[${idx}]))->value());\n"
-            "parse_args.src_types_[${idx}] = ops::OP_DTYPE::DT_BEGIN;\n"
-            "parse_args.dst_types_[${idx}] = ${new_type};\n"
-        )
         arg_handler_prt_template = (
-            tensor_arg_handler_prt_template) if is_tensor_api else function_arg_handler_prt_template
+            self.tensor_arg_handler_prt_template) if is_tensor_api else self.function_arg_handler_prt_template
 
-        arg_handler_template = Template(
-            "parse_args.arg_list_[${idx}] = "
-            "py::cast(pynative::${func_str}(\"${func_name}\", \"${op_arg_name}\", parse_args.arg_list_[${idx}]));\n"
-            "parse_args.src_types_[${idx}] = ops::OP_DTYPE::DT_BEGIN;\n"
-            "parse_args.dst_types_[${idx}] = ${new_type};\n"
-        )
-        arg_handler_optional_template = Template(
-            'if (!py::isinstance<py::none>(parse_args.arg_list_[${idx}])) {\n'
-            '  ${arg_handler_str}\n'
-            '}\n'
-        )
-        arg_handler_type_map = {"to_2d_paddings": "ops::OP_DTYPE::DT_TUPLE_INT",
-                                "dtype_to_type_id": "ops::OP_DTYPE::DT_INT",
-                                "to_kernel_size": "ops::OP_DTYPE::DT_TUPLE_INT",
-                                "to_strides": "ops::OP_DTYPE::DT_TUPLE_INT",
-                                "str_to_enum": "ops::OP_DTYPE::DT_INT",
-                                "to_pair": "ops::OP_DTYPE::DT_TUPLE_INT",
-                                "to_dilations": "ops::OP_DTYPE::DT_TUPLE_INT",
-                                "to_output_padding": "ops::OP_DTYPE::DT_TUPLE_INT",
-                                "to_rates": "ops::OP_DTYPE::DT_TUPLE_INT"}
         arg_handler_processor = []
         op_args = op_proto.op_args
         for idx, op_arg in enumerate(op_args):
@@ -442,7 +450,7 @@ parse_args.arg_list_[${idx}]))->value());\n"
                                for word in arg_handler.split('_'))
             if arg_handler:
                 op_arg_name = op_arg.arg_name
-                new_type = arg_handler_type_map[arg_handler]
+                new_type = self.arg_handler_type_map.get(arg_handler, "Not exist")
                 if func_str in ("StrToEnum", "DtypeToTypeId"):
                     arg_handler_str = arg_handler_prt_template.replace(func_str=func_str,
                                                                        func_name=func_name,
@@ -450,20 +458,21 @@ parse_args.arg_list_[${idx}]))->value());\n"
                                                                        idx=idx,
                                                                        new_type=new_type)
                 else:
-                    arg_handler_str = arg_handler_template.replace(func_str=func_str,
-                                                                   func_name=func_name,
-                                                                   op_arg_name=op_arg_name,
-                                                                   idx=idx,
-                                                                   new_type=new_type)
+                    arg_handler_str = self.arg_handler_template.replace(func_str=func_str,
+                                                                        func_name=func_name,
+                                                                        op_arg_name=op_arg_name,
+                                                                        idx=idx,
+                                                                        new_type=new_type)
 
                 if op_arg.default == "None":
-                    arg_handler_str = arg_handler_optional_template.replace(idx=idx,
-                                                                            arg_handler_str=arg_handler_str)
+                    arg_handler_str = self.arg_handler_optional_template.replace(idx=idx,
+                                                                                 arg_handler_str=arg_handler_str)
                 arg_handler_processor.append(arg_handler_str)
 
         return arg_handler_processor
 
-    def get_input_tensor_index(self, op_proto):
+    @staticmethod
+    def get_input_tensor_index(op_proto):
         """
         Get index of input.
 
@@ -500,14 +509,22 @@ parse_args.arg_list_[${idx}]))->value());\n"
         if is_tensor_api:
             self_index = self.get_input_tensor_index(op_proto)
         convert_args_str = ""
+        arg_basic_convert_template = Template("parse_args.${convert_func}(${index}), ")
         for idx, op_arg in enumerate(op_proto.op_args):
             if is_tensor_api:
                 if self_index == idx:
                     convert_args_str += "input_tensor, "
                     continue
             is_optional = is_optional_param(op_arg)
+            if op_proto.op_view:
+                convert_func = basic_type_convert_str(op_arg.arg_dtype, False)
+                if convert_func != "":
+                    arg_convert_str = arg_basic_convert_template.replace(convert_func=convert_func,
+                                                                         index=idx)
+                    convert_args_str += arg_convert_str
+                    continue
             arg_convert_template = Template("parse_args.ConvertOptional<${des_type}>(${index}), ") if is_optional \
-                                   else Template("parse_args.Convert<${des_type}>(${index}), ")
+                else Template("parse_args.Convert<${des_type}>(${index}), ")
             if op_arg.is_type_id:
                 arg_type_str = get_input_args_type_str('type', False)
             else:
@@ -515,3 +532,12 @@ parse_args.arg_list_[${idx}]))->value());\n"
             convert_args_str += arg_convert_template.replace(index=idx,
                                                              des_type=arg_type_str[:-3])
         return convert_args_str[:-2]
+
+
+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