mindspore 2.7.0__cp310-cp310-win_amd64.whl → 2.7.1__cp310-cp310-win_amd64.whl

mindspore/ops_generate/op_def_py/op_prim_py_generator.py

@@ -20,14 +20,14 @@ 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
+import common.template_utils as template
 from common.op_proto import OpProto
-from common.template import Template
+from common.template_utils import Template
 from pyboost import pyboost_utils
+from op_def_py.base_op_prim_py_generator import BaseOpPrimPyGenerator, _generate_arg_handler, generate_py_op_deprecated
 
 
-class OpPrimPyGenerator(BaseGenerator):
+class OpPrimPyGenerator(BaseOpPrimPyGenerator):
     """
     Generates Python code for primitive operators based on provided specifications.
     """
@@ -87,7 +87,7 @@ class OpPrimPyGenerator(BaseGenerator):
 
         pyboost_import_header = self.generate_pyboost_import_header(op_protos)
         res_str = template.PY_LICENSE_STR + \
-            template.OPS_PY_PRIM_HEADER + pyboost_import_header + gen_py
+                  template.OPS_PY_PRIM_HEADER + pyboost_import_header + gen_py
 
         save_path = os.path.join(work_path, K.PY_AUTO_GEN_PATH)
         file_name = f"{file_pre}_ops_prim.py"
@@ -111,113 +111,6 @@ class OpPrimPyGenerator(BaseGenerator):
                 pyboost_import_header += header
         return pyboost_import_header
 
-    def _process_args(self, op_proto: OpProto):
-        """
-        Processes operator arguments to categorize them for code generation.
-
-        Args:
-            op_proto (OpProto): The operator prototype.
-
-        Returns:
-            tuple: A tuple containing processed arguments.
-        """
-        inputs_name = []
-        args_name = []
-        args_assign = []
-        inputs_default = {}
-        init_args_with_default = []
-        args_handlers = {}
-
-        for arg in op_proto.op_args:
-            # step1: get args infos:
-            if arg.is_prim_init:
-                # step1.1: get args name:
-                args_name.append(arg.arg_name)
-                # step1.2: get args assign with default value:
-                if arg.default is not None:
-                    init_args_with_default.append(f"""{arg.arg_name}={arg.default}""")
-                else:
-                    init_args_with_default.append(f"""{arg.arg_name}""")
-
-                # 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('
-                        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)
-            # step2: get inputs infos:
-            else:
-                # step2.1: get inputs name:
-                inputs_name.append(arg.arg_name)
-
-                # step2.2: get default value of inputs:
-                if arg.default is not None:
-                    inputs_default[arg.arg_name] = arg.default
-
-                # step2.3: get args_handler functions for inputs
-                if arg.arg_handler:
-                    args_handlers[arg.arg_name] = arg.arg_handler
-
-        return inputs_name, inputs_default, args_name, args_assign, init_args_with_default, args_handlers
-
-    def _get_assign_str_by_type_it(self, class_name, arg):
-        """
-        Generates assignment string with type casting.
-
-        Args:
-            class_name (str): The name of the class.
-            arg (OpArg): The operator argument.
-
-        Returns:
-            str: A string representing the assignment.
-        """
-        assign_str = ""
-        type_cast = arg.type_cast
-        if type_cast:
-            assign_str += f"type_it('{class_name}', '{arg.arg_name}', {arg.arg_name}, "
-            if len(type_cast) == 1:
-                assign_str += gen_utils.get_type_str(type_cast[0]) + ', '
-            else:
-                assign_str += '(' + ', '.join(gen_utils.get_type_str(ct) for ct in type_cast) + '), '
-            assign_str += gen_utils.get_type_str(arg.arg_dtype) + ')'
-        else:
-            assign_str = arg.arg_name
-        return assign_str
-
-    def _generate_class_desc(self, op_proto: OpProto, input_args, init_args, doc_dic):
-        """
-        Generates a class description based on the operator prototype.
-
-        Args:
-            op_proto (OpProto): The operator prototype.
-            input_args (list): List of input argument names.
-            init_args (list): List of initialization argument names.
-            doc_dic (dict): Documentation dictionary.
-
-        Returns:
-            str: A string containing the class description.
-        """
-        if op_proto.op_function and op_proto.op_function.disable:
-            # if function disabled, function name is equal to operator_name
-            return gen_utils.get_op_description(op_proto.op_name, doc_dic)
-
-        # If function is a released API, refer to the function doc.
-        init_args_str = ", ".join(init_args)
-        input_args_str = ", ".join(input_args)
-        args_str = ", ".join(input_args + init_args)
-
-        description_template = Template(template.PRIMITIVE_CLASS_DESC)
-        description_str = description_template.replace(class_name=op_proto.op_class.name,
-                                                       init_args_str=init_args_str,
-                                                       input_args_str=input_args_str,
-                                                       func_name=op_proto.op_function.name,
-                                                       args_str=args_str)
-        return description_str
-
     def _generate_init_code(self, args_assign, init_args_with_default, op_proto: OpProto):
         """
         Generates the __init__ method code for the operator primitive class.
@@ -242,50 +135,6 @@ class OpPrimPyGenerator(BaseGenerator):
         init_code_str += f"\n"
         return init_code_str
 
-    def _get_init_code(self, init_code, op_proto: OpProto):
-        """
-        Generates additional initialization code for the operator primitive class.
-
-        Args:
-            init_code (str): Existing initialization code.
-            op_proto (OpProto): The operator prototype.
-
-        Returns:
-            str: A string containing additional initialization code.
-        """
-        labels_dic = op_proto.op_labels
-        if labels_dic:
-            if init_code:
-                init_code += "\n"
-            init_code += "\n".join([f"""        self.add_prim_attr("{k}", {v})""" for k, v in labels_dic.items()])
-
-        return init_code if init_code else f"""        pass"""
-
-    def _generate_call_code(self, args_handlers, init_args, inputs_args, inputs_default, op_proto: OpProto):
-        """
-        Generates the __call__ method code for the operator primitive class.
-
-        Args:
-            args_handlers (dict): Dictionary of argument handlers.
-            init_args (list): List of initialization argument names.
-            inputs_args (list): List of input argument names.
-            inputs_default (dict): Dictionary of default input values.
-            op_proto (OpProto): The operator prototype.
-
-        Returns:
-            str: A string containing the __call__ method code.
-        """
-        call_code_str = ""
-        call_args = []
-        for name in inputs_args:
-            call_args.append(f"{name}={inputs_default[name]}" if name in inputs_default else name)
-        call_method_args_str = ", ".join(call_args)
-        call_method_body_str = self._get_call_method_body_str(args_handlers, init_args, inputs_args, inputs_default,
-                                                              op_proto)
-        call_code_str += f"""    def __call__(self, {call_method_args_str}):"""
-        call_code_str += f"""{call_method_body_str}"""
-        return call_code_str
-
     def _get_call_method_body_str(self, args_handlers, init_args, inputs_args, inputs_default, op_proto: OpProto):
         """
         Generates the body of the __call__ method.
@@ -334,159 +183,3 @@ class OpPrimPyGenerator(BaseGenerator):
             call_method_body_str += f"""
         return super().__call__({call_args_list_str})\n"""
         return call_method_body_str
-
-    def _generate_py_op_signature(self, op_proto: OpProto, args_name, args_default):
-        """
-        Generates the __mindspore_signature__ for the operator.
-
-        Args:
-            op_proto (OpProto): The operator prototype.
-            args_name (list): List of argument names.
-            args_default (dict): Dictionary of default argument values.
-
-        Returns:
-            str: A string containing the __mindspore_signature__ code.
-        """
-        op_name = op_proto.op_name
-        args_signature = op_proto.op_args_signature
-
-        if args_signature is None and not args_default:
-            return ''
-
-        signature_code = f"""\n    __mindspore_signature__ = """
-
-        # Init rw.
-        read_list, ref_list, write_list = gen_utils.init_args_signature_rw(args_signature)
-        _check_signature_arg_valid(op_name, write_list, args_name)
-        _check_signature_arg_valid(op_name, read_list, args_name)
-        _check_signature_arg_valid(op_name, ref_list, args_name)
-
-        # Init dtype group.
-        same_dtype_groups, dtype_count = gen_utils.get_same_dtype_groups(args_signature, args_name)
-        _check_signature_arg_valid(op_name, list(same_dtype_groups.keys()), args_name)
-
-        # Only one dtype_group is set.
-        if dtype_count == 1 and not any([write_list, read_list, ref_list, args_default]):
-            signature_code += '('
-            for _ in range(len(args_name) - 1):
-                signature_code += 'sig.sig_dtype.T, '
-            signature_code += 'sig.sig_dtype.T)\n'
-            return signature_code
-
-        # Set sig.make_sig.
-        signature_code += f""" (\n"""
-        for arg_name in args_name:
-            signature_code += f"""        sig.make_sig('{arg_name}'"""
-            signature_code += signature_get_rw_label(arg_name, write_list, read_list, ref_list)
-            if arg_name in same_dtype_groups:
-                signature_code += f""", """ + signature_get_dtype_label(same_dtype_groups[arg_name])
-            if arg_name in args_default:
-                signature_code += f""", default=""" + str(args_default[arg_name])
-            signature_code += f"""),\n"""
-        signature_code += f"""    )\n"""
-        return signature_code
-
-
-def _check_signature_arg_valid(op_name, sig_arg_names, args_names):
-    """
-    Validates that all signature arguments are present in the list of argument names.
-
-    Args:
-        op_name (str): The name of the operator.
-        sig_arg_names (list): List of signature argument names.
-        args_names (list): List of actual argument names.
-
-    Raises:
-        ValueError: If a signature argument is not found in the list of argument names.
-    """
-    for sig_arg_name in sig_arg_names:
-        if sig_arg_name not in args_names:
-            raise ValueError(f"Op {op_name} has no input arg named '{sig_arg_name}'!")
-
-
-def signature_get_dtype_label(index):
-    """
-    Generates the label for the data type in the signature.
-
-    Args:
-        index (int): The index of the data type.
-
-    Returns:
-        str: The label string for the data type.
-    """
-    dtype_index = ''
-    if index > 0:
-        dtype_index = f"""{index}"""
-    return f"""dtype=sig.sig_dtype.T{dtype_index}"""
-
-
-def signature_get_rw_label(arg_name, write_list, read_list, ref_list):
-    """
-    Determines the read-write label for an argument in the signature.
-
-    Args:
-        arg_name (str): The name of the argument.
-        write_list (list): List of arguments that are writable.
-        read_list (list): List of arguments that are readable.
-        ref_list (list): List of arguments that are references.
-
-    Returns:
-        str: The read-write label for the argument.
-    """
-    for rw_arg_name in write_list:
-        if rw_arg_name == arg_name:
-            return ', sig.sig_rw.RW_WRITE'
-    for read_arg_name in read_list:
-        if read_arg_name == arg_name:
-            return ', sig.sig_rw.RW_READ'
-    for ref_arg_name in ref_list:
-        if ref_arg_name == arg_name:
-            return ', sig.sig_rw.RW_REF'
-    return ''
-
-
-def generate_py_op_deprecated(deprecated):
-    """
-    Generates the deprecated decorator for an operator.
-
-    Args:
-        deprecated (dict): The deprecation information.
-
-    Returns:
-        str: A string containing the deprecated decorator.
-    """
-    if deprecated is None:
-        return ''
-    version = deprecated.get("version")
-    if version is None:
-        raise ValueError("The version of deprecated can't be None.")
-    substitute = deprecated.get("substitute")
-    if substitute is None:
-        raise ValueError("The substitute of deprecated can't be None.")
-    use_substitute = deprecated.get("use_substitute")
-    if use_substitute is None:
-        raise ValueError("The use_substitute of deprecated can't be None.")
-    if use_substitute is not True and use_substitute is not False:
-        raise ValueError(f"The use_substitute must be True or False, but got {use_substitute}")
-
-    deprecated = f"""    @deprecated("{version}", "{substitute}", {use_substitute})\n"""
-    return deprecated
-
-
-def _generate_arg_handler(class_name, arg, arg_handler, is_optional):
-    """
-    Generates the argument handler call for an argument.
-
-    Args:
-        class_name (str): The name of the class.
-        arg (str): The name of the argument.
-        arg_handler (str): The handler function for the argument.
-        is_optional (bool): Indicates whether the argument is optional.
-
-    Returns:
-        str: The argument handler call string.
-    """
-    arg_handler_call = f"""{arg_handler}('{class_name}', '{arg}', {arg})"""
-    if is_optional:
-        arg_handler_call = f"""{arg} if {arg} is None else {arg_handler_call}"""
-    return arg_handler_call

mindspore/ops_generate/pyboost/auto_grad_impl_cc_generator.py

@@ -23,7 +23,7 @@ from common.template import Template
 import common.gen_constants as K
 from common.gen_utils import save_file
 from common.base_generator import BaseGenerator
-from pyboost.pyboost_utils import is_optional_param, get_input_dtype, is_op_multi_output
+from pyboost.pyboost_utils import is_optional_param, get_input_dtype, is_op_multi_output, get_output_dtype
 
 
 class AutoGradImplGenerator(BaseGenerator):
@@ -38,6 +38,8 @@ class AutoGradImplGenerator(BaseGenerator):
         self.OP_DEF_INC_HEAD_TEMPLATE = template.OP_DEF_INC_HEAD_TEMPLATE
         self.AUTO_GRAD_IMPL_CC_TEMPLATE = template.AUTO_GRAD_IMPL_CC_TEMPLATE
         self.DO_GRAD_FUNCTION_BODY_TEMPLATE = template.DO_GRAD_FUNCTION_BODY_TEMPLATE
+        self.DO_VIEW_GRAD_FUNCTION_BODY_TEMPLATE = template.DO_VIEW_GRAD_FUNCTION_BODY_TEMPLATE
+        self.DO_VIEW_CUSTOMIZE_GRAD_FUNCTION_BODY_TEMPLATE = template.DO_VIEW_CUSTOMIZE_GRAD_FUNCTION_BODY_TEMPLATE
         self.auto_grad_reg_template = Template("const_cast<kernel::pyboost::${class_name}GradFunc&>(" + \
                                                "kernel::pyboost::AutoGradFactory::Get()." + \
                                                "ops_auto_grad_registers().${class_name}GradFuncObj) = " + \
@@ -45,6 +47,9 @@ class AutoGradImplGenerator(BaseGenerator):
         self.do_grad_op_args_with_type = Template(
             "const kernel::pyboost::OpPtr &op, ${input_args_with_type}"
         )
+        self.do_grad_view_op_args_with_type = Template(
+            "${output_args_with_type}, ${input_args_with_type}"
+        )
 
     def generate(self, work_path, op_protos):
         """
@@ -60,8 +65,13 @@ class AutoGradImplGenerator(BaseGenerator):
         for op_proto in op_protos:
             if op_proto.op_dispatch is None:
                 continue
+            # the backward func of flatten_ext and t_ext are implemented by other view ops, just continue
+            if op_proto.op_view and not op_proto.bprop_expander:
+                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))
+            do_single_grad_op_str = self._get_single_do_grad_view_op(op_proto)\
+                  if op_proto.op_view else self._get_single_do_grad_op(op_proto)
+            do_grad_op_list.append(do_single_grad_op_str)
             ops_inc_head_set.add(self.OP_DEF_INC_HEAD_TEMPLATE.replace(prefix_char=op_proto.op_class.name[0].lower()))
         pyboost_func_h_str = self.AUTO_GRAD_IMPL_CC_TEMPLATE.replace(do_grad_op=do_grad_op_list,
                                                                      auto_grad_reg=auto_grad_reg_list,
@@ -80,12 +90,11 @@ class AutoGradImplGenerator(BaseGenerator):
         Returns:
             str: The generated DoGrad function string.
         """
-        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)
+        input_args_str = self._get_input_args(op_proto, False, False, False)
+        input_args_with_optional_str = self._get_input_args(op_proto, False, True, False)
+        input_args_with_type_str = self._get_input_args(op_proto, True, False, False)
         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)
@@ -94,22 +103,62 @@ class AutoGradImplGenerator(BaseGenerator):
         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,
-                                                           non_differentiable=non_differentiable,
-                                                           convert_basic_to_value=convert_basic_to_value)
+                                                           non_differentiable=non_differentiable)
+
+    def _get_single_do_grad_view_op(self, op_proto):
+        """
+        Generate the DoGrad function for a single view operator prototype.
+
+        Args:
+            op_proto: The operator prototype for which the DoGrad function is generated.
+
+        Returns:
+            str: The generated DoGrad function string.
+        """
+        input_args_str = self._get_input_args(op_proto, False, False, True)
+        input_args_with_optional_str = self._get_input_args(op_proto, False, True, True)
+        input_args_with_type_str = self._get_input_args(op_proto, True, False, True)
+        inner_grad_args_with_type = self._get_input_args(op_proto, True, False, False)
+        view_arg_str = self._get_view_str(input_args_str)
+        grad_args_with_type_str = self.do_grad_view_op_args_with_type\
+            .replace(input_args_with_type=input_args_with_type_str,
+                     output_args_with_type=self._get_output_arg(op_proto))
+        inner_grad_args_with_type =\
+            self.do_grad_view_op_args_with_type.replace(output_args_with_type="const ValuePtr &output_value",
+                                                        input_args_with_type=inner_grad_args_with_type)
+        op_def_name_str = "g" + op_proto.op_class.name
+        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 op_proto.op_name in ["reshape", "expand_dims", "transpose", "slice_ext_view",\
+                                 "select_ext_view", "transpose_ext_view"]:
+            do_view_grad_function_body_tpl = self.DO_VIEW_CUSTOMIZE_GRAD_FUNCTION_BODY_TEMPLATE
+            convert_basic_to_value = ""
+        else:
+            do_view_grad_function_body_tpl = self.DO_VIEW_GRAD_FUNCTION_BODY_TEMPLATE
+            input_args_with_optional_str, convert_basic_to_value = self._get_convert_str(op_proto,
+                                                                                         input_args_with_optional_str)
+        return do_view_grad_function_body_tpl.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,
+                                                      view_arg=view_arg_str,
+                                                      op_def_name=op_def_name_str,
+                                                      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, use_basic_type=False):
         """
@@ -134,6 +183,15 @@ class AutoGradImplGenerator(BaseGenerator):
                     args_list.append(f"{op_arg.arg_name}_tensor")
         return args_list
 
+    def _get_output_arg(self, op_proto):
+        # for view operators, the output is tensor or vector<tensor>
+        if len(op_proto.op_returns) != 1:
+            raise ValueError(f"the output of {op_proto.op_name} is not tensor, ",
+                             "tuple[tensor] or list[tensor], which is not not as expected")
+        output_dtype = get_output_dtype(op_proto.op_returns[0].arg_dtype)
+        output_arg = f"const {output_dtype} &output"
+        return output_arg
+
     def _get_convert_str(self, op_proto, args_name):
         """
         Get the input convert func for the DoGrad function.
@@ -161,12 +219,11 @@ class AutoGradImplGenerator(BaseGenerator):
             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):
+    def _get_view_str(self, grad_args: list):
         """
         Get the view argument string for a DoGrad function.
 
         Args:
-            is_view_op (bool): Whether the operator is a view operator.
             grad_args (list): A list of gradient arguments.
 
         Returns:
@@ -174,7 +231,7 @@ class AutoGradImplGenerator(BaseGenerator):
         """
         view_arg_str = ''
         for i, grad_arg in enumerate(grad_args):
-            if is_view_op and i == 0:
+            if i == 0:
                 view_arg_str = ", " + grad_arg
                 break
         return view_arg_str

mindspore/ops_generate/pyboost/auto_grad_reg_cc_generator.py

@@ -23,7 +23,7 @@ from common.template import Template
 import common.gen_constants as K
 from common.gen_utils import save_file
 from common.base_generator import BaseGenerator
-from pyboost.pyboost_utils import is_optional_param, get_input_dtype
+from pyboost.pyboost_utils import is_optional_param, get_input_dtype, get_output_dtype
 
 
 class AutoGradRegHeaderGenerator(BaseGenerator):
@@ -42,6 +42,9 @@ class AutoGradRegHeaderGenerator(BaseGenerator):
         self.op_grad_func_args_template = Template(
             "const kernel::pyboost::OpPtr &, ${input_tensor_prt_args}"
         )
+        self.op_view_grad_func_args_template = Template(
+            "${output_tensor_prt_args}, ${input_tensor_prt_args}"
+        )
 
     def generate(self, work_path, op_protos):
         """
@@ -60,9 +63,13 @@ class AutoGradRegHeaderGenerator(BaseGenerator):
                 continue
             op_type_enum_list.append(self.op_type_enum_template.replace(class_name=op_proto.op_class.name,
                                                                         enum_val=index))
+            # the backward func of flatten_ext and t_ext are implemented by other view ops, just continue
+            if op_proto.op_view and not op_proto.bprop_expander:
+                continue
             grad_func_args_with_type_str = self._get_grad_func_args_with_type_str(op_proto)
-            op_grad_func_list.append(self.op_grad_func_template.replace(class_name=op_proto.op_class.name,
-                                                                        grad_func_args=grad_func_args_with_type_str))
+            op_grad_func_list.append(
+                self.op_grad_func_template.replace(class_name=op_proto.op_class.name,
+                                                   grad_func_args=grad_func_args_with_type_str))
             op_grad_func_obj_list.append(self.op_grad_func_obj_template.replace(class_name=op_proto.op_class.name))
             index += 1
 
@@ -89,5 +96,15 @@ class AutoGradRegHeaderGenerator(BaseGenerator):
             is_optional = is_optional_param(op_arg)
             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(', '))
+        input_tensor_prt_args_str = input_tensor_prt_args_str.rstrip(', ')
+        if not op_proto.op_view:
+            return self.op_grad_func_args_template.replace(input_tensor_prt_args=\
+                                                           input_tensor_prt_args_str)
+        # for view operators, the output is tensor or vector<tensor>
+        if len(op_proto.op_returns) != 1:
+            raise ValueError(f"the output of {op_proto.op_name} is not tensor,",
+                             "tuple[tensor] or list[tensor], which is not not as expected")
+        output_dtype = get_output_dtype(op_proto.op_returns[0].arg_dtype)
+        output_tensor_prt_args_str = f"const {output_dtype} &"
+        return self.op_view_grad_func_args_template.replace(input_tensor_prt_args=input_tensor_prt_args_str,
+                                                            output_tensor_prt_args=output_tensor_prt_args_str)

mindspore/ops_generate/pyboost/op_template_parser.py

@@ -47,14 +47,15 @@ class OpTemplateParser:
         self.op_proto = op_proto
         self.tensor_arg_handler_prt_template = Template(
             "parse_args.arg_list_[${idx}] = "
-            "py::cast((*pynative::${func_str}(\"${func_name}\", \"${op_arg_name}\", "
+            "PyLong_FromLong((*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"
+            "PyLong_FromLong((*${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"
         )

mindspore/ops_generate/pyboost/pyboost_functions_cpp_generator.py

@@ -55,7 +55,7 @@ class PyboostFunctionsGenerator(BaseGenerator):
         self.PYBOOST_REGISTRY_CC_TEMPLATE = template.PYBOOST_REGISTRY_CC_TEMPLATE
         self.TENSOR_FUNC_CLASS_REG = template.TENSOR_FUNC_CLASS_REG
         self.OP_DEF_INC_HEAD_TEMPLATE = template.OP_DEF_INC_HEAD_TEMPLATE
-
+        self.MARK_SIDE_EFFECT_STR = "PyNativeAlgo::PyBoost::MarkSideEffect(PyList_GetItem(args, 0));"
         self.pyboost_api_body_template = template.PYBOOST_API_BODY_CC_TEMPLATE
 
     def generate(self, work_path, op_protos):
@@ -91,8 +91,8 @@ class PyboostFunctionsGenerator(BaseGenerator):
                 pyboost_op_name=pyboost_op_name,
                 pyboost_cfunc_name=pyboost_func_name,
                 class_name=op_proto.op_class.name)
-            pyboost_func_include_headers_str += self.pyboost_func_include_header_template.replace(
-                operator_name=op_proto.op_name)
+            pyboost_func_include_headers_str +=\
+                self.pyboost_func_include_header_template.replace(operator_name=op_proto.op_name)
             ops_inc_head_set.add(self.OP_DEF_INC_HEAD_TEMPLATE.replace(prefix_char=op_proto.op_class.name[0].lower()))
         register_func_str = self.REGISTER_TEMPLATE.replace(register_func=pyboost_func_pybind_def)
         function_class_register = self._get_function_class_register(op_protos)
@@ -132,11 +132,13 @@ class PyboostFunctionsGenerator(BaseGenerator):
             op_def_name_str = op_parser.get_op_def_name_str()
             parser_body_str = self._generate_parser_func(op_proto)
             op_args_str = [op_arg.arg_name for op_arg in op_proto.op_args]
+            side_effect_str = self._generate_mark_side_effect_str(op_proto)
             pyboost_api_body_str += self.pyboost_api_body_template.replace(func_name=op_pyboost_func_name,
                                                                            op_def_name=op_def_name_str,
                                                                            parser_body=parser_body_str,
                                                                            class_name=op_proto.op_class.name,
-                                                                           op_args=op_args_str)
+                                                                           op_args=op_args_str,
+                                                                           mark_side_effect=side_effect_str)
 
             ops_inc_head_set.add(self.OP_DEF_INC_HEAD_TEMPLATE.replace(prefix_char=op_proto.op_class.name[0].lower()))
 
@@ -148,7 +150,7 @@ class PyboostFunctionsGenerator(BaseGenerator):
         op_def_name_str = op_parser.get_op_def_name_str()
         parser_body_str = self._generate_parser_func(op_proto)
         op_args_str = [op_arg.arg_name for op_arg in op_proto.op_args]
-        registry_body_tpl = self.get_pyboost_registry_body_cc_tpl(op_proto)
+        registry_body_tpl = self.PYBOOST_REGISTRY_BODY_CC_TEMPLATE
         return registry_body_tpl.replace(func_name=op_pyboost_func_name,
                                          op_def_name=op_def_name_str,
                                          parser_body=parser_body_str,
@@ -200,5 +202,19 @@ class PyboostFunctionsGenerator(BaseGenerator):
                                                              arg_index=pyboost_utils.get_index(index))
         return parser_func_str
 
+    def _generate_mark_side_effect_str(self, op_proto: OpProto) -> str:
+        """
+        Generates the mark side effect str for the inplace operator.
+
+        Args:
+            op_proto (OpProto): The operator prototype containing the argument information.
+
+        Returns:
+            str: The generated mark side effect flag as a string.
+        """
+        if op_proto.op_inplace or op_proto.op_view:
+            return self.MARK_SIDE_EFFECT_STR
+        return ""
+
     def get_pyboost_registry_body_cc_tpl(self, op_proto: OpProto):
         return self.PYBOOST_REGISTRY_BODY_CC_TEMPLATE

mindspore/ops_generate/pyboost/pyboost_functions_h_generator.py

@@ -45,10 +45,10 @@ class PyboostFunctionsHeaderGenerator(BaseGenerator):
         self.PYBOOST_CORE_HEADER_TEMPLATE = template.PYBOOST_CORE_HEADER_TEMPLATE
 
         self.pyboost_func_template = Template(
-            'py::object PYNATIVE_EXPORT ${func_name}_Base(const PrimitivePtr &prim, const py::list &args);'
+            'PYNATIVE_EXPORT PyObject* ${func_name}_Base(const PrimitivePtr &prim, PyObject* args);'
         )
         self.pyboost_op_func_template = Template(
-            'py::object PYNATIVE_EXPORT ${func_name}_OP(const PrimitivePtr &prim, '
+            'PYNATIVE_EXPORT PyObject* ${func_name}_OP(const PrimitivePtr &prim, '
             'const std::vector<ops::OP_DTYPE>& source_type, ${input_args});'
         )
         self.input_args_template = Template(" const ${arg_type}& ${arg_name},")