diff --git a/paddle/fluid/framework/details/op_registry.h b/paddle/fluid/framework/details/op_registry.h index 4b109ba0dcff22ee55722a026305a671c0783557..1edc84aba07d9753eb543db4e038b842706de811 100644 --- a/paddle/fluid/framework/details/op_registry.h +++ b/paddle/fluid/framework/details/op_registry.h @@ -63,7 +63,7 @@ using OpRegistryClasses = std::tuple< // NOLINT TypePair, // NOLINT TypePair, // NOLINT TypePair, // NOLINT - TypePair, // NOLINT + TypePair, // NOLINT TypePair, // NOLINT TypePair, // NOLINT TypePair, // NOLINT @@ -262,7 +262,7 @@ struct OpInfoFiller { info->grad_comp_op_maker_, nullptr, platform::errors::AlreadyExists( - "CompositeGradOpMakerBase of %s has been registered", op_type)); + "GradCompositeOpMakerBase of %s has been registered", op_type)); info->grad_comp_op_maker_ = [](const OpDesc& fwd_op, diff --git a/paddle/fluid/operators/elementwise/elementwise_add_op.cc b/paddle/fluid/operators/elementwise/elementwise_add_op.cc index f1261bdfa443a8ef928c356d0552f1c411833631..11e0fa7dd1f9705e259d30d76aba852c6a526011 100644 --- a/paddle/fluid/operators/elementwise/elementwise_add_op.cc +++ b/paddle/fluid/operators/elementwise/elementwise_add_op.cc @@ -52,8 +52,8 @@ class ElementwiseAddOpMaker : public ElementwiseOpMaker { }; class ElementwiseAddGradCompositeOpMaker - : public prim::CompositeGradOpMakerBase { - using prim::CompositeGradOpMakerBase::CompositeGradOpMakerBase; + : public prim::GradCompositeOpMakerBase { + using prim::GradCompositeOpMakerBase::GradCompositeOpMakerBase; public: void Apply() override { diff --git a/paddle/fluid/operators/elementwise/elementwise_div_op.cc b/paddle/fluid/operators/elementwise/elementwise_div_op.cc index e202cd8cb4b5241ef87e4b0f84d7ca4ad790f223..3d62792d8513eabd228694b5ff6268cded58ca09 100644 --- a/paddle/fluid/operators/elementwise/elementwise_div_op.cc +++ b/paddle/fluid/operators/elementwise/elementwise_div_op.cc @@ -68,8 +68,8 @@ class ElementwiseDivGradOpMaker : public framework::SingleGradOpMaker { }; class ElementwiseDivGradCompositeOpMaker - : public prim::CompositeGradOpMakerBase { - using prim::CompositeGradOpMakerBase::CompositeGradOpMakerBase; + : public prim::GradCompositeOpMakerBase { + using prim::GradCompositeOpMakerBase::GradCompositeOpMakerBase; public: void Apply() override { diff --git a/paddle/fluid/operators/elementwise/elementwise_sub_op.cc b/paddle/fluid/operators/elementwise/elementwise_sub_op.cc index 43437c5322996c93cb20818d752351c3470c0588..be839f123a1e9fb2a015bae592763eab34443b7f 100644 --- a/paddle/fluid/operators/elementwise/elementwise_sub_op.cc +++ b/paddle/fluid/operators/elementwise/elementwise_sub_op.cc @@ -55,8 +55,8 @@ class ElementwiseSubOpMaker : public ElementwiseOpMaker { }; class ElementwiseSubGradCompositeOpMaker - : public prim::CompositeGradOpMakerBase { - using prim::CompositeGradOpMakerBase::CompositeGradOpMakerBase; + : public prim::GradCompositeOpMakerBase { + using prim::GradCompositeOpMakerBase::GradCompositeOpMakerBase; public: void Apply() override { diff --git a/paddle/fluid/operators/generator/filters.py b/paddle/fluid/operators/generator/filters.py index 0cfd4b950137b13c8fa5c8b7d0b88fe3cc5cec3b..8efbac1f7e92c4591c58df9d036a43e6eb0366ab 100644 --- a/paddle/fluid/operators/generator/filters.py +++ b/paddle/fluid/operators/generator/filters.py @@ -14,7 +14,6 @@ import itertools import re -from typing import Dict, List from type_mapping import ( attr_types_map, @@ -138,23 +137,17 @@ def to_composite_grad_opmaker_name(backward_op_name): for i in range(len(words)): words[i] = words[i].strip() words[i] = words[i].capitalize() - composite_grad_opmaker_name = "".join(word for word in words) - composite_grad_opmaker_name += "CompositeGradOpMaker" + composite_grad_opmaker_name = words[0] + "Composite" + composite_grad_opmaker_name += "".join(word for word in words[1:]) + composite_grad_opmaker_name += "OpMaker" return composite_grad_opmaker_name -def to_variable_names(dict_list: List[Dict], key: str) -> List[str]: - names = [] - for var in dict_list: - names.append(var[key]) - return names - - def cartesian_prod_attrs(attrs): items = [] for attr in attrs: type_name = attr["typename"] - name = attr["fluid_name"] + name = attr["name"] if type_name == "Scalar": items.append((name, to_scalar_tensor_name(attr))) elif type_name == "IntArray": @@ -183,15 +176,11 @@ def cartesian_prod_attrs(attrs): def cartesian_prod_mapping(op): kernels = op["kernel"]["func"] inputs = [ - x["fluid_name"] - for x in op["inputs"] - if x["fluid_name"] in op["kernel"]["param"] + x["name"] for x in op["inputs"] if x["name"] in op["kernel"]["param"] ] inputs = [to_opmaker_name_cstr(input) for input in inputs] attrs = cartesian_prod_attrs(op["attrs"]) - outputs = [ - to_opmaker_name_cstr(output["fluid_name"]) for output in op["outputs"] - ] + outputs = [to_opmaker_name_cstr(output["name"]) for output in op["outputs"]] def vec(items): return "{" + ', '.join(items) + "}" diff --git a/paddle/fluid/operators/generator/generate_op.py b/paddle/fluid/operators/generator/generate_op.py index ff3a12367ad30777e2b683afa2c225cf38fcf251..c16be45f8f1ecda325d962f511c9750d62e61f27 100644 --- a/paddle/fluid/operators/generator/generate_op.py +++ b/paddle/fluid/operators/generator/generate_op.py @@ -28,7 +28,6 @@ from filters import ( to_opmaker_name_cstr, to_pascal_case, to_scalar_tensor_name, - to_variable_names, ) from jinja2 import Environment, FileSystemLoader, StrictUndefined from parse_utils import to_named_dict @@ -61,7 +60,6 @@ env.filters["to_input_name"] = to_input_name env.filters["to_opmaker_name_cstr"] = to_opmaker_name_cstr env.filters["cartesian_prod_mapping"] = cartesian_prod_mapping env.filters["to_composite_grad_opmaker_name"] = to_composite_grad_opmaker_name -env.filters["to_variable_names"] = to_variable_names env.tests["base_op"] = is_base_op env.tests["composite_op"] = is_composite_op env.tests["vec"] = is_vec @@ -159,26 +157,29 @@ def process_int_array(op_item, int_array_configs): ] -def add_composite_info(ops, backward_ops, backward_op_dict): - # add backward composite name in forward - for op in ops + backward_ops: - if ( - op["backward"] in backward_op_dict - and "composite" in backward_op_dict[op["backward"]] - ): - op["backward_composite"] = op["backward"] - else: - op["backward_composite"] = None - - -# add fluid name in ops and backward ops info -def add_fluid_name(dict_list): - for item in dict_list: - item["fluid_name"] = item["name"] - - -# add fluid name of op and params for OpMaker -def add_compat_name(op_fluid_map_list, forward_op_dict, backward_op_dict): +def parse_composite_info(ops, backward_ops, backward_op_dict): + for op in ops: + if "backward" in op: + op["phi_backward"] = op["backward"] + for backward_op in backward_ops: + if "backward" in backward_op: + backward_op["phi_backward"] = backward_op["backward"] + for backward_op_name, op_dict in backward_op_dict.items(): + if "composite" not in op_dict: + continue + op_dict["composite"]["phi_inputs"] = [] + op_dict["composite"]["phi_attrs"] = [] + op_dict["composite"]["phi_outputs"] = [] + for input in op_dict["inputs"]: + op_dict["composite"]["phi_inputs"].append(input['name']) + for attr in op_dict["attrs"]: + op_dict["composite"]["phi_attrs"].append(attr['name']) + for output in op_dict["outputs"]: + op_dict["composite"]["phi_outputs"].append(output['name']) + + +# replace name of op and params for OpMaker +def replace_compat_name(op_fluid_map_list, forward_op_dict, backward_op_dict): def get_phi_and_fluid_op_name(op_item): names = op_item.split('(') if len(names) == 1: @@ -186,14 +187,12 @@ def add_compat_name(op_fluid_map_list, forward_op_dict, backward_op_dict): else: return names[0].strip(), names[1].split(')')[0].strip() - def add_op_param_name(op_args, args_alias_map): + def update_op_param_name(op_args, args_alias_map): for item in op_args: if item['name'] in args_alias_map: - item['fluid_name'] = args_alias_map[item['name']] - else: - item['fluid_name'] = item['name'] + item['name'] = args_alias_map[item['name']] - def add_grad_args_name(op_args, args_alias_map): + def update_grad_args_name(op_args, args_alias_map): for item in op_args: if ( item['name'].endswith('_grad') @@ -202,12 +201,38 @@ def add_compat_name(op_fluid_map_list, forward_op_dict, backward_op_dict): args_alias_map[item['name']] = ( args_alias_map[item['name'][:-5]] + '_grad' ) - item['fluid_name'] = args_alias_map[item['name'][:-5]] + '_grad' - elif ( - item['name'].endswith('_grad') - and item['name'][:-5] not in args_alias_map - ): - item['fluid_name'] = item['name'] + item['name'] = args_alias_map[item['name'][:-5]] + '_grad' + + def add_fluid_info_in_composite(composite_map, args_alias_map): + fluid_input_list = [] + fluid_attr_list = [] + fluid_output_list = [] + # add fluid op inputs + for input in composite_map["phi_inputs"]: + if input in args_alias_map: + fluid_input_list.append(args_alias_map[input]) + else: + fluid_input_list.append(input) + # add fluid op attrs + for attr in composite_map["phi_attrs"]: + if attr in args_alias_map: + fluid_attr_list.append(args_alias_map[attr]) + else: + fluid_attr_list.append(attr) + # add fluid op outputs + for output in composite_map["phi_outputs"]: + if output in args_alias_map: + fluid_output_list.append(args_alias_map[output]) + else: + fluid_output_list.append(output) + + composite_map.update( + { + "fluid_inputs": fluid_input_list, + "fluid_attrs": fluid_attr_list, + "fluid_outputs": fluid_output_list, + } + ) def get_param_list_alias(param_list, args_map): return [ @@ -262,15 +287,15 @@ def add_compat_name(op_fluid_map_list, forward_op_dict, backward_op_dict): op_item['kernel']['layout']['candidates'], args_name_map ) - def add_grad_op_compat_name(grad_op_item, args_name_map): - add_op_param_name(grad_op_item['inputs'], args_name_map) - add_op_param_name(grad_op_item['outputs'], args_name_map) - add_op_param_name(grad_op_item['attrs'], args_name_map) - add_op_param_name(grad_op_item['forward']['inputs'], args_name_map) - add_op_param_name(grad_op_item['forward']['outputs'], args_name_map) - add_op_param_name(grad_op_item['forward']['attrs'], args_name_map) - add_grad_args_name(grad_op_item['inputs'], args_map) - add_grad_args_name(grad_op_item['outputs'], args_map) + def update_grad_op_compat_name(grad_op_item, args_name_map): + update_op_param_name(grad_op_item['inputs'], args_name_map) + update_op_param_name(grad_op_item['outputs'], args_name_map) + update_op_param_name(grad_op_item['attrs'], args_name_map) + update_op_param_name(grad_op_item['forward']['inputs'], args_name_map) + update_op_param_name(grad_op_item['forward']['outputs'], args_name_map) + update_op_param_name(grad_op_item['forward']['attrs'], args_name_map) + update_grad_args_name(grad_op_item['inputs'], args_map) + update_grad_args_name(grad_op_item['outputs'], args_map) for op_args in op_fluid_map_list: new_op_name, op_name = get_phi_and_fluid_op_name(op_args['op']) @@ -315,32 +340,39 @@ def add_compat_name(op_fluid_map_list, forward_op_dict, backward_op_dict): int_array_configs[ op_args[key][args_item['name']] ] = int_array_configs[args_item['name']] - args_item['fluid_name'] = op_args[key][ - args_item['name'] - ] + args_item['name'] = op_args[key][args_item['name']] + if has_backward: + for args_item in backward_op_item['forward'][key]: + if args_item['name'] in op_args[key]: + args_item['name'] = op_args[key][args_item['name']] + forward_op_item["attr_dict"] = to_named_dict(forward_op_item["attrs"]) update_common_params_name( forward_op_item, args_map, scalar_configs, int_array_configs ) if has_backward: - # update fluid info in backward - add_grad_op_compat_name(backward_op_item, args_map) + update_grad_op_compat_name(backward_op_item, args_map) update_common_params_name( backward_op_item, args_map, scalar_configs, int_array_configs ) + backward_op_item["attr_dict"] = to_named_dict( + backward_op_item["attrs"] + ) if 'backward' not in op_args: continue backward_op_list = op_args['backward'].split(',') - phi_bw_op_name, bw_op_name = get_phi_and_fluid_op_name( - backward_op_list[0] - ) - if ( - forward_op_item["backward_composite"] is not None - and phi_bw_op_name != bw_op_name - ): - forward_op_item["backward_composite"] = bw_op_name + # add fluid args name in composite map + for backward_op in backward_op_list: + if ( + "composite" + in backward_op_dict[backward_op.split('(')[0].strip()] + ): + add_fluid_info_in_composite( + backward_op_dict[backward_op]["composite"], args_map + ) + _, bw_op_name = get_phi_and_fluid_op_name(backward_op_list[0]) forward_op_item['backward'] = bw_op_name backward_op_item['op_name'] = bw_op_name @@ -351,20 +383,18 @@ def add_compat_name(op_fluid_map_list, forward_op_dict, backward_op_dict): double_grad_op_name, ) = get_phi_and_fluid_op_name(backward_op_list[1]) double_grad_item = backward_op_dict[phi_double_grad_op_name] - if ( - backward_op_item["backward_composite"] is not None - and phi_double_grad_op_name != double_grad_op_name - ): - backward_op_item["backward_composite"] = double_grad_op_name backward_op_item['backward'] = double_grad_op_name double_grad_item['op_name'] = double_grad_op_name - add_grad_op_compat_name(double_grad_item, args_map) + update_grad_op_compat_name(double_grad_item, args_map) update_common_params_name( double_grad_item, args_map, scalar_configs, int_array_configs, ) + double_grad_item["attr_dict"] = to_named_dict( + double_grad_item["attrs"] + ) # for triple grad if len(backward_op_list) > 2: @@ -373,22 +403,18 @@ def add_compat_name(op_fluid_map_list, forward_op_dict, backward_op_dict): triple_grad_op_name, ) = get_phi_and_fluid_op_name(backward_op_list[2]) triple_grad_item = backward_op_dict[phi_triple_grad_op_name] - if ( - double_grad_item["backward_composite"] is not None - and phi_triple_grad_op_name != triple_grad_op_name - ): - double_grad_item[ - "backward_composite" - ] = triple_grad_op_name double_grad_item['backward'] = triple_grad_op_name triple_grad_item['op_name'] = triple_grad_op_name - add_grad_op_compat_name(triple_grad_item, args_map) + update_grad_op_compat_name(triple_grad_item, args_map) update_common_params_name( triple_grad_item, args_map, scalar_configs, int_array_configs, ) + triple_grad_item["attr_dict"] = to_named_dict( + triple_grad_item["attrs"] + ) def process_invoke_op(forward_op_dict, backward_op_dict): @@ -406,28 +432,20 @@ def process_invoke_op(forward_op_dict, backward_op_dict): for input_item in reuse_op['inputs']: bw_op['invoke']['inputs'].append( { - 'fluid_name': input_item['fluid_name'], 'name': input_item['name'], 'value': args_list[args_index], } ) args_index = args_index + 1 - bw_fluid_attrs_set = [ - item['fluid_name'] for item in bw_op['attrs'] - ] for attr in reuse_op['attrs']: if args_index < len(args_list): attr_value = ( f"this->GetAttr(\"{args_list[args_index]}\")" - if args_list[args_index] in bw_fluid_attrs_set + if args_list[args_index] in bw_op['attr_dict'] else args_list[args_index] ) bw_op['invoke']['attrs'].append( - { - 'name': attr['name'], - 'fluid_name': attr['fluid_name'], - 'value': attr_value, - } + {'name': attr['name'], 'value': attr_value} ) args_index = args_index + 1 else: @@ -436,8 +454,7 @@ def process_invoke_op(forward_op_dict, backward_op_dict): bw_op['invoke']['outputs'].append( { 'name': output_item['name'], - 'fluid_name': output_item['fluid_name'], - 'value': bw_op['outputs'][idx]['fluid_name'], + 'value': bw_op['outputs'][idx]['name'], } ) @@ -490,26 +507,17 @@ def main( for op in ops: op['op_name'] = op['name'] - add_fluid_name(op['inputs']) - add_fluid_name(op['attrs']) - add_fluid_name(op['outputs']) for bw_op in backward_ops: bw_op['op_name'] = bw_op['name'] - add_fluid_name(bw_op['inputs']) - add_fluid_name(bw_op['attrs']) - add_fluid_name(bw_op['outputs']) - add_fluid_name(bw_op['forward']['inputs']) - add_fluid_name(bw_op['forward']['attrs']) - add_fluid_name(bw_op['forward']['outputs']) for bw_output in bw_op['outputs']: bw_output['drop_empty_grad'] = True # deal the drop_empty_grad of bw_op by op_compat.yaml parse_drop_empty_grad(op_fluid_map_list, backward_op_dict) - add_composite_info(ops, backward_ops, backward_op_dict) + parse_composite_info(ops, backward_ops, backward_op_dict) - add_compat_name(op_fluid_map_list, forward_op_dict, backward_op_dict) + replace_compat_name(op_fluid_map_list, forward_op_dict, backward_op_dict) # prepare for invoke case process_invoke_op(forward_op_dict, backward_op_dict) @@ -537,6 +545,7 @@ def main( ops=ops, backward_ops=backward_ops, op_dict=op_dict, + composite_gen_flag=True, ) f.write(msg) ks_template = env.get_template('ks.c.j2') diff --git a/paddle/fluid/operators/generator/generate_sparse_op.py b/paddle/fluid/operators/generator/generate_sparse_op.py index 3eea32091dc8067c3572a9621cccd9d714d50b9e..1da91e3f60005f731a78c08fcfcbde53778e2c43 100644 --- a/paddle/fluid/operators/generator/generate_sparse_op.py +++ b/paddle/fluid/operators/generator/generate_sparse_op.py @@ -28,14 +28,12 @@ from filters import ( to_opmaker_name_cstr, to_pascal_case, to_scalar_tensor_name, - to_variable_names, ) -from generate_op import add_fluid_name, process_invoke_op +from generate_op import process_invoke_op from jinja2 import Environment, FileSystemLoader, StrictUndefined from parse_utils import to_named_dict from tests import ( is_base_op, - is_composite_op, is_initializer_list, is_scalar, is_vec, @@ -62,9 +60,7 @@ env.filters["to_input_name"] = to_input_name env.filters["to_opmaker_name_cstr"] = to_opmaker_name_cstr env.filters["cartesian_prod_mapping"] = cartesian_prod_mapping env.filters["to_composite_grad_opmaker_name"] = to_composite_grad_opmaker_name -env.filters["to_variable_names"] = to_variable_names env.tests["base_op"] = is_base_op -env.tests["composite_op"] = is_composite_op env.tests["vec"] = is_vec env.tests["scalar"] = is_scalar env.tests["initializer_list"] = is_initializer_list @@ -100,18 +96,9 @@ def main(op_yaml_path, backward_yaml_path, output_op_path, output_arg_map_path): op['name'] = op['op_name'] if op["backward"] is not None: op["backward"] = SPARSE_OP_PREFIX + op["backward"] - add_fluid_name(op["inputs"]) - add_fluid_name(op["attrs"]) - add_fluid_name(op["outputs"]) for bw_op in backward_ops: bw_op['op_name'] = SPARSE_OP_PREFIX + bw_op['name'] bw_op['name'] = bw_op['op_name'] - add_fluid_name(bw_op["inputs"]) - add_fluid_name(bw_op["attrs"]) - add_fluid_name(bw_op["outputs"]) - add_fluid_name(bw_op["forward"]["inputs"]) - add_fluid_name(bw_op["forward"]["attrs"]) - add_fluid_name(bw_op["forward"]["outputs"]) if 'invoke' in bw_op: bw_op['invoke']['args'] = [ param.strip() for param in bw_op['invoke']['args'].split(',') @@ -152,6 +139,7 @@ def main(op_yaml_path, backward_yaml_path, output_op_path, output_arg_map_path): ops=ops, backward_ops=backward_ops, op_dict=op_dict, + composite_gen_flag=False, ) f.write(msg) diff --git a/paddle/fluid/operators/generator/generate_static_op.py b/paddle/fluid/operators/generator/generate_static_op.py index 3a825bafb127c254c50f8b49b1b063335862d0df..7701f76734a0c0073a59dd0ec5fa441ce1830385 100644 --- a/paddle/fluid/operators/generator/generate_static_op.py +++ b/paddle/fluid/operators/generator/generate_static_op.py @@ -28,14 +28,12 @@ from filters import ( to_opmaker_name_cstr, to_pascal_case, to_scalar_tensor_name, - to_variable_names, ) -from generate_op import add_compat_name, add_fluid_name +from generate_op import replace_compat_name from jinja2 import Environment, FileSystemLoader, StrictUndefined from parse_utils import to_named_dict from tests import ( is_base_op, - is_composite_op, is_initializer_list, is_scalar, is_vec, @@ -62,9 +60,7 @@ env.filters["to_input_name"] = to_input_name env.filters["to_opmaker_name_cstr"] = to_opmaker_name_cstr env.filters["cartesian_prod_mapping"] = cartesian_prod_mapping env.filters["to_composite_grad_opmaker_name"] = to_composite_grad_opmaker_name -env.filters["to_variable_names"] = to_variable_names env.tests["base_op"] = is_base_op -env.tests["composite_op"] = is_composite_op env.tests["vec"] = is_vec env.tests["scalar"] = is_scalar env.tests["initializer_list"] = is_initializer_list @@ -104,11 +100,8 @@ def main( for op in ops: op['op_name'] = op['name'] - add_fluid_name(op["inputs"]) - add_fluid_name(op["attrs"]) - add_fluid_name(op["outputs"]) - add_compat_name(op_op_map, forward_op_dict, {}) + replace_compat_name(op_op_map, forward_op_dict, {}) if len(ops) == 0: if os.path.isfile(output_op_path): @@ -123,6 +116,7 @@ def main( ops=ops, backward_ops=[], op_dict=forward_op_dict, + composite_gen_flag=False, ) f.write(msg) diff --git a/paddle/fluid/operators/generator/parse_utils.py b/paddle/fluid/operators/generator/parse_utils.py index bd3971f35a1fa8d226133d7236396eea46d96cf0..7d153ff868eeb8285df9c2ea5b35930d7d8f3859 100644 --- a/paddle/fluid/operators/generator/parse_utils.py +++ b/paddle/fluid/operators/generator/parse_utils.py @@ -294,13 +294,14 @@ def parse_composite( composite_config: str, ) -> Dict[str, Any]: # composite_config: func(args1, args2,.....) - result = re.search( - r"(?P[a-z][a-z0-9_]+)\s*\((?P[^\)]+)\)", - composite_config, - ) - - func_name = result.group("func_name") - func_args = result.group("func_args") + fname = r'(.*?)' + wspace = r'\s*' + fargs = r'(.*?)' + pattern = fr'{fname}{wspace}\({wspace}{fargs}{wspace}\)' + + m = re.search(pattern, composite_config) + func_name = m.group(1) + func_args = m.group(2) composite_dict = {} composite_dict["func_name"] = func_name diff --git a/paddle/fluid/operators/generator/templates/op.c.j2 b/paddle/fluid/operators/generator/templates/op.c.j2 index 2339822af280fb2050d3e84dea3daa22395913e3..23641dad90f1bebc38e7cb76a18248c0f4a9d142 100644 --- a/paddle/fluid/operators/generator/templates/op.c.j2 +++ b/paddle/fluid/operators/generator/templates/op.c.j2 @@ -39,9 +39,11 @@ using paddle::framework::GradVarName; {% else %} {{backward_op_reused_maker(op, op_dict[op["forward"]["name"]], op["invoke"])}} {% endif %} - {% if op is composite_op %} + {% if composite_gen_flag == True %} + {% if op is composite_op %} {{composite_grad_op_maker(op_dict[op["name"]])}} - {% endif %} + {% endif %} + {% endif %} {% endfor %} } // namespace operators } // namespace paddle @@ -49,7 +51,7 @@ using paddle::framework::GradVarName; namespace ops = paddle::operators; {% for op in ops + backward_ops %} {% if op is base_op %} -{{register_op_with_components(op)}} +{{register_op_with_components(op, op_dict)}} {{register_op_version(op)}} {% endif %} {% endfor %} diff --git a/paddle/fluid/operators/generator/templates/operator_utils.c.j2 b/paddle/fluid/operators/generator/templates/operator_utils.c.j2 index a2190b6976f9edcce04bed1932d57b2fd9523cfa..37b5075235a83d7ce09f0c6fa0ebcf0463fc3cfb 100644 --- a/paddle/fluid/operators/generator/templates/operator_utils.c.j2 +++ b/paddle/fluid/operators/generator/templates/operator_utils.c.j2 @@ -12,7 +12,7 @@ class {{op_name | to_pascal_case}}OpMaker : public framework::OpProtoAndCheckerM {{add_output(loop.index0, output, op_name)}}; {% endfor %} {% for attr in op["attrs"] %} - {% if attr["fluid_name"] in op["kernel"]["param"] %} + {% if attr["name"] in op["kernel"]["param"] %} {{add_attr(loop.index0, attr, op_name)}}; {% endif %} {% endfor %} @@ -27,7 +27,7 @@ TODO: Documentation of {{op_name}} op. {# add input, it could be duplicable or dispensable #} {% macro add_input(i, input, op_name) %}{# inline #} - {% set name = input["fluid_name"] %} + {% set name = input["name"] %} {% set typename = input["typename"] %} AddInput({{name| to_opmaker_name}}, "({{typename}}), input {{i}} of {{op_name}} op.") {%- if typename is vec %} @@ -42,7 +42,7 @@ AddInput({{name| to_opmaker_name}}, "({{typename}}), input {{i}} of {{op_name}} {# add output, it could be duplicable or intermediate, however, optional output is not supported #} {% macro add_output(i, output, op_name) %}{# inline #} - {% set name = output["fluid_name"] %} + {% set name = output["name"] %} {% set typename = output["typename"] %} {% set is_intermediate = output["intermediate"] %} AddOutput({{name | to_opmaker_name}}, "({{typename}}), output {{i}} of {{op_name}} op.") @@ -66,7 +66,7 @@ AddOutput({{name | to_opmaker_name}}, "({{typename}}), output {{i}} of {{op_name {# add attribute, and process default value if needed #} {% macro add_attr(i, attr, op_name) %}{# inline #} - {% set name = attr["fluid_name"] %} + {% set name = attr["name"] %} {% set typename = attr["typename"] %} {% if typename is scalar %} AddInput("{{attr | to_scalar_tensor_name}}", "attribute {{i}} for {{op_name}} op from 0D Tensor.") @@ -153,15 +153,15 @@ All possible KernelSignatures returned by {{op["name"] | to_pascal_case }}OpArgu {% set kernel_in_type_list = kernel_config["dispatch"][kernel_func][0] %} if ( {%- for input in inputs %} - {%- if input["fluid_name"] in kernel_config["param"] %} + {%- if input["name"] in kernel_config["param"] %} {%- if kernel_in_type_list[input_idx.idx] == "dense" %} -ctx.IsDenseTensorInput("{{input["fluid_name"]}}"){{" && " if not loop.last}} +ctx.IsDenseTensorInput("{{input["name"]}}"){{" && " if not loop.last}} {%- elif kernel_in_type_list[input_idx.idx] == "selected_rows" %} -ctx.IsSelectedRowsInput("{{input["fluid_name"]}}"){{" && " if not loop.last}} +ctx.IsSelectedRowsInput("{{input["name"]}}"){{" && " if not loop.last}} {%- elif kernel_in_type_list[input_idx.idx] == "sparse_coo" %} -ctx.IsSparseCooTensorInput("{{input["fluid_name"]}}"){{" && " if not loop.last}} +ctx.IsSparseCooTensorInput("{{input["name"]}}"){{" && " if not loop.last}} {%- elif kernel_in_type_list[input_idx.idx] == "sparse_csr" %} -ctx.IsSparseCsrTensorInput("{{input["fluid_name"]}}"){{" && " if not loop.last}} +ctx.IsSparseCsrTensorInput("{{input["name"]}}"){{" && " if not loop.last}} {%- endif %} {% set input_idx.idx = input_idx.idx + 1 %} {%- endif %} @@ -210,8 +210,8 @@ PD_REGISTER_ARG_MAPPING_FN({{op["op_name"]}}, phi::{{op["op_name"] | to_pascal_c {% macro get_input_list(inputs, kernel_args) %}{# inline #} paddle::small_vector inputs { {%- for input in inputs %} -{%- if input["fluid_name"] in kernel_args %} -{{input["fluid_name"] | to_opmaker_name_cstr}}{{", " if not loop.last}} +{%- if input["name"] in kernel_args %} +{{input["name"] | to_opmaker_name_cstr}}{{", " if not loop.last}} {%- endif %} {%- endfor %} } @@ -219,8 +219,8 @@ paddle::small_vector inputs { {% macro get_an_attr(attr, kernel_args) %}{# inline #} {% set typename = attr["typename"] %} -{%- if attr["fluid_name"] in kernel_args %} -{% set name = attr["fluid_name"] %} +{%- if attr["name"] in kernel_args %} +{% set name = attr["name"] %} {% if typename is scalar %}{# scalar correspond to a dispensable input and an attr in opmaker #} attrs.emplace_back(ctx.HasInput("{{attr | to_scalar_tensor_name}}") ? "{{attr | to_scalar_tensor_name}}" : "{{name}}"); {%- elif typename == "IntArray" %} @@ -251,7 +251,7 @@ attrs.emplace_back("{{name}}"); {% macro get_output_list(outputs, kernel_args) %}{# inline #} paddle::small_vector outputs { {%- for output in outputs %} -{{output["fluid_name"] | to_opmaker_name_cstr}}{{", " if not loop.last}} +{{output["name"] | to_opmaker_name_cstr}}{{", " if not loop.last}} {%- endfor %} } {%- endmacro %} @@ -263,7 +263,7 @@ phi::KernelKey GetExpectedKernelType( {%if kernel["data_type"] is not none %}{# data type ---------------------------------#} {% if kernel["data_type"]["candidates"] | length == 1 %} {% set data_type_arg = kernel["data_type"]["candidates"][0] %} - {% set inputs = op["inputs"] | map(attribute="fluid_name") | list %} + {% set inputs = op["inputs"] | map(attribute="name") | list %} {% if data_type_arg in inputs %} auto data_type = framework::OperatorWithKernel::IndicateVarDataType(ctx, {{data_type_arg | to_opmaker_name}}); {% if kernel["data_type"]["to_complex_flag"][0] %} @@ -319,8 +319,9 @@ DECLARE_NO_NEED_BUFFER_VARS_INFERER({{op["op_name"] | to_pascal_case}}NoNeedBuff {% endif %} {% endmacro%} -{% macro register_op_with_components(op) %} +{% macro register_op_with_components(op, op_dict) %} {% set name = op["op_name"] %} +{% set phi_name = op["name"] %} REGISTER_OPERATOR({{name}}, ops::{{name | to_pascal_case}}Op, {% if not "forward" in op %}{# it is a forward op #} ops::{{name | to_pascal_case}}OpMaker, @@ -336,8 +337,8 @@ REGISTER_OPERATOR({{name}}, ops::{{name | to_pascal_case}}Op, {% if op is supports_inplace %}{# inplace#} ops::{{name | to_pascal_case}}InplaceInferer, {% endif %} -{% if "backward_composite" in op and op["backward_composite"] is not none %} - ops::{{op["backward_composite"] | to_composite_grad_opmaker_name}}, +{% if "phi_backward" in op and op["phi_backward"] is not none and "composite" in op_dict[op["phi_backward"]] %} + ops::{{op["phi_backward"] | to_composite_grad_opmaker_name}}, {% endif %} {% if op is supports_no_need_buffer %}{# no_need_buffer #} ops::{{name | to_pascal_case}}NoNeedBufferVarInferer, @@ -390,12 +391,12 @@ REGISTER_OP_VERSION({{name}}) {# --------------------------------------- backward op maker ---------------------------------------------- #} {% macro backward_op_maker(op, forward_op ) %} {% set name = op["op_name"] %} - {% set forward_input_names = op["forward"]["inputs"] | map(attribute="fluid_name") | list %} - {% set forward_output_names = op["forward"]["outputs"] | map(attribute="fluid_name") | list %} - {% set forward_attr_names = op["forward"]["attrs"] | map(attribute="fluid_name") | list %} - {% set forward_input_orig_names = forward_op["inputs"] | map(attribute="fluid_name") | list %} - {% set forward_output_orig_names = forward_op["outputs"] | map(attribute="fluid_name") | list %} - {% set forward_attr_orig_names = forward_op["attrs"] | map(attribute="fluid_name") | list %} + {% set forward_input_names = op["forward"]["inputs"] | map(attribute="name") | list %} + {% set forward_output_names = op["forward"]["outputs"] | map(attribute="name") | list %} + {% set forward_attr_names = op["forward"]["attrs"] | map(attribute="name") | list %} + {% set forward_input_orig_names = forward_op["inputs"] | map(attribute="name") | list %} + {% set forward_output_orig_names = forward_op["outputs"] | map(attribute="name") | list %} + {% set forward_attr_orig_names = forward_op["attrs"] | map(attribute="name") | list %} template class {{name | to_pascal_case}}OpMaker : public framework::SingleGradOpMaker { public: @@ -406,8 +407,8 @@ class {{name | to_pascal_case}}OpMaker : public framework::SingleGradOpMaker grad_op->SetType("{{name}}"); {% for input in op["inputs"] %} - grad_op->SetInput({{input["fluid_name"] | to_opmaker_name}}, this->{{extract_input_from_forward( - input["fluid_name"], + grad_op->SetInput({{input["name"] | to_opmaker_name}}, this->{{extract_input_from_forward( + input["name"], forward_input_names, forward_output_names, forward_input_orig_names, @@ -415,8 +416,8 @@ class {{name | to_pascal_case}}OpMaker : public framework::SingleGradOpMaker {% endfor %} {% for output in op["outputs"] %} - grad_op->SetOutput({{output["fluid_name"] | to_opmaker_name}}, this->{{extract_output_from_forward( - output["fluid_name"], + grad_op->SetOutput({{output["name"] | to_opmaker_name}}, this->{{extract_output_from_forward( + output["name"], forward_input_names, forward_output_names, forward_input_orig_names, @@ -426,7 +427,7 @@ class {{name | to_pascal_case}}OpMaker : public framework::SingleGradOpMaker grad_op->SetAttrMap(this->Attrs()); {% for attr in op["attrs"] %} - {% set attr_name = attr["fluid_name"] %} + {% set attr_name = attr["name"] %} {% if attr_name in forward_attr_names %} {% if attr["typename"] == "IntArray" %} {% if 'tensor_name' in attr or 'manual_flag' not in attr %} @@ -454,12 +455,12 @@ class {{name | to_pascal_case}}OpMaker : public framework::SingleGradOpMaker {% macro backward_op_reused_maker(bw_op, forward_op, invoke_op) %} {% set name = bw_op["op_name"] %} - {% set forward_input_names = bw_op["forward"]["inputs"] | map(attribute="fluid_name") | list %} - {% set forward_output_names = bw_op["forward"]["outputs"] | map(attribute="fluid_name") | list %} - {% set forward_attr_names = bw_op["forward"]["attrs"] | map(attribute="fluid_name") | list %} - {% set forward_input_orig_names = forward_op["inputs"] | map(attribute="fluid_name") | list %} - {% set forward_output_orig_names = forward_op["outputs"] | map(attribute="fluid_name") | list %} - {% set forward_attr_orig_names = forward_op["attrs"] | map(attribute="fluid_name") | list %} + {% set forward_input_names = bw_op["forward"]["inputs"] | map(attribute="name") | list %} + {% set forward_output_names = bw_op["forward"]["outputs"] | map(attribute="name") | list %} + {% set forward_attr_names = bw_op["forward"]["attrs"] | map(attribute="name") | list %} + {% set forward_input_orig_names = forward_op["inputs"] | map(attribute="name") | list %} + {% set forward_output_orig_names = forward_op["outputs"] | map(attribute="name") | list %} + {% set forward_attr_orig_names = forward_op["attrs"] | map(attribute="name") | list %} template class {{name | to_pascal_case}}OpMaker : public framework::SingleGradOpMaker { public: @@ -470,7 +471,7 @@ class {{name | to_pascal_case}}OpMaker : public framework::SingleGradOpMaker grad_op->SetType("{{invoke_op["func"]}}"); {% for input in invoke_op["inputs"] %} - grad_op->SetInput({{input["fluid_name"] | to_opmaker_name}}, this->{{extract_input_from_forward( + grad_op->SetInput({{input["name"] | to_opmaker_name}}, this->{{extract_input_from_forward( input["value"], forward_input_names, forward_output_names, @@ -479,7 +480,7 @@ class {{name | to_pascal_case}}OpMaker : public framework::SingleGradOpMaker {% endfor %} {% for output in invoke_op["outputs"] %} - grad_op->SetOutput({{output["fluid_name"] | to_opmaker_name}}, this->{{extract_output_from_forward( + grad_op->SetOutput({{output["name"] | to_opmaker_name}}, this->{{extract_output_from_forward( output["value"], forward_input_names, forward_output_names, @@ -489,49 +490,42 @@ class {{name | to_pascal_case}}OpMaker : public framework::SingleGradOpMaker {% endfor %} {% for attr in invoke_op["attrs"] %} - grad_op->SetAttr("{{attr["fluid_name"]}}", {{attr["value"]}}); + grad_op->SetAttr("{{attr["name"]}}", {{attr["value"]}}); {% endfor %} } }; {% endmacro %} -{% macro composite_grad_op_maker(backward_op) %} - {% set op_name = backward_op["op_name"] %} - {% set inputs = backward_op["inputs"] | to_variable_names("name")%} - {% set input_dict = backward_op["input_dict"] %} - {% set fluid_inputs = backward_op["inputs"] | to_variable_names("fluid_name")%} - {% set forward_fluid_inputs = backward_op["forward"]["inputs"] | to_variable_names("fluid_name")%} - {% set forward_fluid_outputs = backward_op["forward"]["outputs"] | to_variable_names("fluid_name")%} - {% set attrs = backward_op["attrs"] | to_variable_names("name") %} - {% set fluid_attrs = backward_op["attrs"] | to_variable_names("fluid_name") %} - {% set attr_dict = backward_op["attr_dict"] %} - {% set outputs = backward_op["outputs"] | to_variable_names("name")%} - {% set output_dict = backward_op["output_dict"] %} - {% set fluid_outputs = backward_op["outputs"] | to_variable_names("fluid_name")%} - {% set composite_func_info = backward_op["composite"] %} -class {{op_name | to_composite_grad_opmaker_name}} : public prim::CompositeGradOpMakerBase { +{% macro composite_grad_op_maker(composite_op_dict) %} + {% set op_name = composite_op_dict["name"] %} +class {{op_name | to_composite_grad_opmaker_name}} : public prim::GradCompositeOpMakerBase { public: - using prim::CompositeGradOpMakerBase::CompositeGradOpMakerBase; + using prim::GradCompositeOpMakerBase::GradCompositeOpMakerBase; void Apply() override { //get inputs -{{construct_composite_input(inputs, fluid_inputs, forward_fluid_inputs, forward_fluid_outputs, input_dict)}} +{{construct_composite_input(composite_op_dict)}} //get attr -{{construct_composite_attr(attrs, fluid_attrs, attr_dict)}} +{{construct_composite_attr(composite_op_dict)}} //get output -{{construct_composite_output(outputs, fluid_outputs, output_dict)}} +{{construct_composite_output(composite_op_dict)}} //get output ptr -{{construct_composite_output_ptr(outputs, output_dict)}} +{{construct_composite_output_ptr(composite_op_dict)}} //get output orginal name -{{get_composite_output_orginal_name(outputs, output_dict)}} +{{get_composite_output_orginal_name(composite_op_dict)}} //call composite backward func -{{call_composite_backward_api(composite_func_info)}} +{{call_composite_backward_api(composite_op_dict)}} //recover output name -{{recover_composite_output_name(outputs)}} +{{recover_composite_output_name(composite_op_dict)}} } }; {%- endmacro %} -{% macro construct_composite_input(inputs, fluid_inputs, forward_fluid_inputs, forward_fluid_outputs, input_dict) %} +{% macro construct_composite_input(composite_op_dict) %} + {% set inputs = composite_op_dict["composite"]["phi_inputs"] %} + {% set input_dict = composite_op_dict["input_dict"] %} + {% set fluid_inputs = composite_op_dict["composite"]["fluid_inputs"] %} + {% set forward_fluid_inputs = composite_op_dict["forward"]["inputs"] | map(attribute="name") | list %} + {% set forward_fluid_outputs = composite_op_dict["forward"]["outputs"] | map(attribute="name") | list %} {% set inputs_length = inputs | length %} {% for i in range(inputs_length) %} {% set input_typename = input_dict[inputs[i]]["typename"] %} @@ -540,13 +534,13 @@ class {{op_name | to_composite_grad_opmaker_name}} : public prim::CompositeGradO {% if input_typename == "Tensor" %} {% if input_optional_flag == True %} paddle::optional {{inputs[i]}} = this->GetOptionalSingleForwardInput("{{fluid_inputs[i]}}"); - {% else %} + {% elif input_optional_flag == False %} paddle::experimental::Tensor {{inputs[i]}} = this->GetSingleForwardInput("{{fluid_inputs[i]}}"); {% endif %} {% elif input_typename == "Tensor[]" %} {% if input_optional_flag == True %} std::vector> {{inputs[i]}} = this->GetOptionalMultiForwardInput("{{fluid_inputs[i]}}"); - {% else %} + {% elif input_optional_flag == False %} std::vector {{inputs[i]}} = this->GetMultiForwardInput("{{fluid_inputs[i]}}"); {% endif %} {% endif %} @@ -554,13 +548,13 @@ class {{op_name | to_composite_grad_opmaker_name}} : public prim::CompositeGradO {% if input_typename == "Tensor" %} {% if input_optional_flag == True %} paddle::optional {{inputs[i]}} = this->GetOptionalSingleForwardOutput("{{fluid_inputs[i]}}"); - {% else %} + {% elif input_optional_flag == False %} paddle::experimental::Tensor {{inputs[i]}} = this->GetSingleForwardOutput("{{fluid_inputs[i]}}"); {% endif %} {% elif input_typename == "Tensor[]" %} {% if input_optional_flag == True %} std::vector> {{inputs[i]}} = this->GetOptionalMultiForwardOutput("{{fluid_inputs[i]}}"); - {% else %} + {% elif input_optional_flag == False %} std::vector {{inputs[i]}} = this->GetMultiForwardOutput("{{fluid_inputs[i]}}"); {% endif %} {% endif %} @@ -568,13 +562,13 @@ class {{op_name | to_composite_grad_opmaker_name}} : public prim::CompositeGradO {% if input_typename == "Tensor" %} {% if input_optional_flag == True %} paddle::optional {{inputs[i]}} = this->GetOptionalSingleOutputGrad("{{fluid_inputs[i][:-5]}}"); - {% else %} + {% elif input_optional_flag == False %} paddle::experimental::Tensor {{inputs[i]}} = this->GetSingleOutputGrad("{{fluid_inputs[i][:-5]}}"); {% endif %} {% elif input_typename == "Tensor[]" %} {% if input_optional_flag == True %} std::vector> {{inputs[i]}} = this->GetOptionalMultiOutputGrad("{{fluid_inputs[i][:-5]}}"); - {% else %} + {% elif input_optional_flag == False %} std::vector {{inputs[i]}} = this->GetMultiOutputGrad("{{fluid_inputs[i][:-5]}}"); {%- endif %} {%- endif %} @@ -582,18 +576,24 @@ class {{op_name | to_composite_grad_opmaker_name}} : public prim::CompositeGradO {%- endfor %} {%- endmacro %} -{% macro construct_composite_attr(attrs, fluid_attrs, attr_dict) %} +{% macro construct_composite_attr(composite_op_dict) %} + {% set attrs = composite_op_dict["composite"]["phi_attrs"] %} + {% set fluid_attrs = composite_op_dict["composite"]["fluid_attrs"] %} + {% set fluid_attrs_dict = composite_op_dict["attr_dict"] %} {% set attrs_length = attrs | length %} {% for i in range(attrs_length) %} - {% set attrs_data_type = attr_dict[attrs[i]]["typename"] | to_op_attr_type %} - const {{attrs_data_type}} {{attrs[i]}} = this->Attr<{{attrs_data_type}}>("{{fluid_attrs[i]}}"); + {% set attrs_data_type = fluid_attrs_dict[fluid_attrs[i]]["typename"] | to_op_attr_type %} + {{attrs_data_type}} {{attrs[i]}} = this->Attr<{{attrs_data_type}}>("{{fluid_attrs[i]}}"); {% endfor %} {%- endmacro %} -{% macro construct_composite_output(outputs, fluid_outputs, output_dict) %} +{% macro construct_composite_output(composite_op_dict) %} + {% set outputs = composite_op_dict["composite"]["phi_outputs"] %} + {% set fluid_outputs = composite_op_dict["composite"]["fluid_outputs"] %} + {% set outputs_dict = composite_op_dict["output_dict"] %} {% set outputs_length = outputs | length %} {% for i in range(outputs_length) %} - {% set output_typename = output_dict[outputs[i]]["typename"] %} + {% set output_typename = outputs_dict[outputs[i]]["typename"] %} {% if output_typename == "Tensor" %} paddle::experimental::Tensor {{outputs[i] + "_t"}} = this->GetSingleInputGrad("{{fluid_outputs[i][:-5]}}"); {% elif output_typename == "Tensor[]" %} @@ -602,10 +602,12 @@ class {{op_name | to_composite_grad_opmaker_name}} : public prim::CompositeGradO {%- endfor %} {%- endmacro %} -{% macro construct_composite_output_ptr(outputs, output_dict) %} +{% macro construct_composite_output_ptr(composite_op_dict) %} + {% set outputs = composite_op_dict["composite"]["phi_outputs"] %} + {% set outputs_dict = composite_op_dict["output_dict"] %} {% set outputs_length = outputs | length %} {% for i in range(outputs_length) %} - {% set output_typename = output_dict[outputs[i]]["typename"] %} + {% set output_typename = outputs_dict[outputs[i]]["typename"] %} {% if output_typename == "Tensor" %} paddle::experimental::Tensor* {{outputs[i]}} = this->GetOutputPtr(&{{outputs[i]+ "_t"}}); {% elif output_typename == "Tensor[]" %} @@ -618,10 +620,12 @@ class {{op_name | to_composite_grad_opmaker_name}} : public prim::CompositeGradO {%- endfor %} {%- endmacro %} -{% macro get_composite_output_orginal_name(outputs, output_dict) %} +{% macro get_composite_output_orginal_name(composite_op_dict) %} + {% set outputs = composite_op_dict["composite"]["phi_outputs"] %} + {% set outputs_dict = composite_op_dict["output_dict"] %} {% set outputs_length = outputs | length %} {% for i in range(outputs_length) %} - {% set output_typename = output_dict[outputs[i]]["typename"] %} + {% set output_typename = outputs_dict[outputs[i]]["typename"] %} {% if output_typename == "Tensor" %} std::string {{outputs[i] + "_name"}} = this->GetOutputName({{outputs[i] + "_t"}}); {% elif output_typename == "Tensor[]" %} @@ -630,12 +634,13 @@ class {{op_name | to_composite_grad_opmaker_name}} : public prim::CompositeGradO {%- endfor %} {%- endmacro %} -{% macro call_composite_backward_api(composite_func_info) %} - VLOG(3) << "Runing {{composite_func_info["func_name"]}} composite func"; - prim::{{composite_func_info["func_name"]}}({{composite_func_info["func_args"]}}); +{% macro call_composite_backward_api(composite_op_dict) %} + VLOG(3) << "Runing {{composite_op_dict["composite"]["func_name"]}} composite func"; + prim::{{composite_op_dict["composite"]["func_name"]}}({{composite_op_dict["composite"]["func_args"]}}); {%- endmacro %} -{% macro recover_composite_output_name(outputs) %} +{% macro recover_composite_output_name(composite_op_dict) %} + {% set outputs = composite_op_dict["composite"]["phi_outputs"] %} {% set outputs_length = outputs | length %} {% for i in range(outputs_length) %} this->RecoverOutputName({{outputs[i] + "_t"}}, {{outputs[i] + "_name"}}); diff --git a/paddle/fluid/prim/tests/test_static_prim.cc b/paddle/fluid/prim/tests/test_static_prim.cc index 009f8675bcf1d3170ed42006a5d91f10310713e6..87475559617fb6b70c89417769c62695891ea443 100644 --- a/paddle/fluid/prim/tests/test_static_prim.cc +++ b/paddle/fluid/prim/tests/test_static_prim.cc @@ -135,9 +135,9 @@ struct TestBaseProgram { int idx_{0}; }; -class TestGradCompositeGradMaker : public CompositeGradOpMakerBase { +class TestGradCompositeGradMaker : public GradCompositeOpMakerBase { public: - using prim::CompositeGradOpMakerBase::CompositeGradOpMakerBase; + using prim::GradCompositeOpMakerBase::GradCompositeOpMakerBase; void Apply() override {} }; diff --git a/paddle/fluid/prim/utils/static/composite_grad_desc_maker.h b/paddle/fluid/prim/utils/static/composite_grad_desc_maker.h index adfc2b759dd1e2da18da19e201ffb2f12e194972..e053d1465e70d53a40920b73b9e7a959eef1b8dc 100644 --- a/paddle/fluid/prim/utils/static/composite_grad_desc_maker.h +++ b/paddle/fluid/prim/utils/static/composite_grad_desc_maker.h @@ -41,9 +41,9 @@ namespace prim { argument DropEmptyIG in the derived classes. */ -class CompositeGradOpMakerBase { +class GradCompositeOpMakerBase { public: - explicit CompositeGradOpMakerBase( + explicit GradCompositeOpMakerBase( const framework::OpDesc& fwd_op, const std::unordered_set& no_grad_set, std::unordered_map* grad_to_var, @@ -61,7 +61,7 @@ class CompositeGradOpMakerBase { acting_program_.MutableBlock(0)); } - virtual ~CompositeGradOpMakerBase() = default; + virtual ~GradCompositeOpMakerBase() = default; virtual std::vector> operator()() { this->Apply();