# The operators included in this file are:
# 1) Operators defined only in PIR, dynamic graphs do not exist;
# 2) The definitions of static graphs and dynamic graphs are inconsistent, but the final definition plan has not yet been clarified.
# After the definition is clearly defined, migrate to paddle/phi/ops/yaml/inconsistent/update_ops.yaml or paddle/phi/ops/yaml/ops.yaml

- op : add
  args : (Tensor x, Tensor y)
  output : Tensor(out)
  infer_meta :
    func : ElementwiseInferMeta
    spmd_rule : ElementwiseBinaryInferSpmd
  kernel :
    func : add
    data_type: x
  inplace : (x -> out)
  backward : add_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
  traits : pir::BinaryElementWiseTrait

# this add_n is only for ops_api_gen.py and onednn
- op : add_n
  args : (Tensor[] inputs)
  output : Tensor(out)
  infer_meta:
    func: AddNInferMeta
    spmd_rule : AddNInferSpmd
    param: [inputs]
  kernel:
    func: add_n
    param: [inputs]
  backward : add_n_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : anchor_generator
  args: (Tensor input, float[] anchor_sizes, float[] aspect_ratios, float[] variances, float[] stride={16.0, 16.0}, float offset=0.5)
  output: Tensor (anchors), Tensor (variances_out)
  infer_meta:
    func: AnchorGeneratorInferMeta
  kernel:
    func: anchor_generator
    data_type: input

- op : assign
  args : (Tensor x)
  output : Tensor
  infer_meta :
    func : UnchangedInferMeta
    spmd_rule : AssignInferSpmd
  kernel :
    func : assign_raw
  backward : assign_grad
  inplace : (x -> out)
  interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface

- op : assign_value
  args : (int[] shape, DataType dtype, Scalar[] values, Place place = {})
  output : Tensor(out)
  infer_meta :
    func : AssignValueInferMeta
    param: [shape, dtype]
  kernel :
    func : assign_value
    param : [shape, dtype, values]
    backend: place>
    data_type : dtype
  interfaces : paddle::dialect::InferSymbolicShapeInterface
  traits : paddle::dialect::ForwardOnlyTrait

- op : batch_norm
  args : (Tensor x, Tensor mean, Tensor variance, Tensor scale, Tensor bias, bool is_test, float momentum, float epsilon, str data_format, bool use_global_stats, bool trainable_statistics)
  output : Tensor(out), Tensor(mean_out), Tensor(variance_out), Tensor(saved_mean), Tensor(saved_variance), Tensor(reserve_space)
  infer_meta:
    func : BatchNormInferMeta
    spmd_rule : BatchNormInferSpmd
  kernel :
    func : batch_norm
    data_type : x
  view : (mean -> mean_out), (variance -> variance_out)
  backward : batch_norm_grad
  optional : scale, bias, reserve_space
  interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface

- op : beam_search_decode
  args: (Tensor ids, Tensor scores, int beam_size, int end_id)
  output: Tensor (sentence_ids), Tensor (sentence_scores)
  infer_meta:
    func: BeamSearchDecodeInferMeta
  kernel:
    func: beam_search_decode

- op : c_embedding
  args : (Tensor weight, Tensor x, int64_t start_index=0, int64_t vocab_size=-1)
  output : Tensor(out)
  infer_meta :
    func : CEmbeddingInferMeta
    param : [weight, x, start_index]
    spmd_rule: CEmbeddingInferSpmd
  kernel :
    func : c_embedding
    param : [weight, x, start_index, vocab_size]
    data_type : weight
  backward : c_embedding_grad

- op : coalesce_tensor_
  args : (Tensor[] input, DataType dtype, bool copy_data = false, bool set_constant = false, bool persist_output = false, float constant = 0.0, bool use_align = true, int align_size = -1, int size_of_dtype = -1, int64_t[] concated_shapes = {}, int64_t[] concated_ranks = {})
  output : Tensor[](output){input.size()}, Tensor(fused_output)
  infer_meta :
    func : CoalesceTensorInferMeta
    spmd_rule : CoalesceTensorInferSpmd
  kernel :
    func : coalesce_tensor
    data_type : dtype
  inplace: (input -> output)
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : comm_init_all
  args : (int[] devices={}, int ring_id=0)
  output :
  infer_meta :
    func : CommInitAllInferMeta
    param : [devices, ring_id]
  kernel :
    func : comm_init_all
    data_type : DataType::FLOAT32

- op : dequantize_linear
  args : (Tensor x, Tensor scale, Tensor zero_point, Tensor in_accum, Tensor in_state, int quant_axis = 0, int bit_length = 8, int qmin = -128, int qmax = 127, int round_type = 0, bool is_test = true, bool only_observer = false)
  output : Tensor(y), Tensor(out_state), Tensor(out_accum), Tensor(out_scale)
  infer_meta :
    func : QuantizeLinearInferMeta
    param : [x, scale, zero_point, in_accum, in_state, quant_axis, bit_length, round_type, is_test, only_observer]
  kernel :
    func : quantize_linear
    param : [x, scale, zero_point, in_accum, in_state, quant_axis, bit_length, qmin, qmax, round_type, is_test, only_observer]
    data_type : x
  optional : scale, in_accum, in_state, out_state, out_accum, out_scale
  inplace : (scale -> out_scale, in_accum -> out_accum, in_state -> out_state)
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : distribute_fpn_proposals
  args : (Tensor fpn_rois, Tensor rois_num, int min_level, int max_level, int refer_level, int refer_scale, bool pixel_offset)
  output : Tensor[](multi_fpn_rois){max_level - min_level + 1}, Tensor[](multi_level_rois_num){max_level - min_level + 1}, Tensor(restore_index)
  infer_meta :
    func : DistributeFpnProposalsInferMeta
  kernel :
    func : distribute_fpn_proposals
    data_type : fpn_rois
  optional : rois_num, multi_level_rois_num
  interfaces : paddle::dialect::InferSymbolicShapeInterface
  traits : paddle::dialect::ForwardOnlyTrait

- op : divide
  args : (Tensor x, Tensor y)
  output : Tensor(out)
  infer_meta :
    func : ElementwiseInferMeta
    spmd_rule : ElementwiseBinaryInferSpmd
  kernel :
    func : divide
  inplace: (x -> out)
  data_transform :
    support_trans_dtype : x, y
  backward : divide_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
  traits : pir::BinaryElementWiseTrait

- op : einsum
  args : (Tensor[] x, str equation)
  output : Tensor(out), Tensor[](inner_cache){x.size()}, Tensor[](xshape){x.size()}
  infer_meta :
    func : EinsumRawInferMeta
    param : [x, equation]
  kernel :
    func : einsum
  optional : inner_cache, xshape
  backward : einsum_grad

- op : elementwise_pow
  args : (Tensor x, Tensor y)
  output : Tensor(out)
  infer_meta :
    func : ElementwiseInferMeta
    spmd_rule: ElementwiseBinaryInferSpmd
  kernel :
    func : elementwise_pow
  data_transform :
    support_trans_dtype : x, y
  backward : elementwise_pow_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
  traits : pir::BinaryElementWiseTrait

- op : embedding
  args : (Tensor x, Tensor weight, int64_t padding_idx=-1, bool sparse=false)
  output : Tensor
  infer_meta :
    func : EmbeddingInferMeta
    param : [x, weight, padding_idx]
    spmd_rule: EmbeddingInferSpmdUnsupportedVocabParallel
  kernel :
    func : embedding {dense, dense -> dense}
           sparse_weight_embedding {dense, selected_rows -> dense}
    param : [x, weight, padding_idx]
    data_type : weight
  backward : embedding_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : equal
  args : (Tensor x, Tensor y)
  output : Tensor(out)
  infer_meta :
    func : CompareInferMeta
    spmd_rule: ElementwiseBinaryInferSpmd
  kernel :
    func : equal
  data_transform :
    support_trans_dtype : x, y
  inplace: (x -> out)
  interfaces : paddle::dialect::InferSymbolicShapeInterface
  traits : paddle::dialect::ForwardOnlyTrait

- op : feed
  args : (str name, int col)
  output : Tensor(out)
  interfaces : paddle::dialect::InferSymbolicShapeInterface
  traits: pir::ImmutableLayoutTrait

- op : floor_divide
  args : (Tensor x, Tensor y)
  output : Tensor(out)
  infer_meta :
    func : ElementwiseInferMeta
  kernel :
    func : floor_divide
  data_transform :
    support_trans_dtype : x, y
  inplace: (x -> out)
  traits : paddle::dialect::ForwardOnlyTrait, pir::BinaryElementWiseTrait
  interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface

- op : fused_adam_
  args : (Tensor[] params, Tensor[] grads, Tensor learning_rate, Tensor[] moments1, Tensor[] moments2, Tensor[] moments2_max, Tensor[] beta1_pows, Tensor[] beta2_pows, Tensor[] master_params, Tensor skip_update, Scalar beta1, Scalar beta2, Scalar epsilon, int chunk_size, float weight_decay, bool use_adamw, bool multi_precision, bool use_global_beta_pow, bool amsgrad = false)
  output : Tensor[](params_out){params.size()}, Tensor[](moments1_out){params.size()}, Tensor[](moments2_out){params.size()}, Tensor[](moments2_max_out){params.size()}, Tensor[](beta1_pows_out){params.size()}, Tensor[](beta2_pows_out){params.size()}, Tensor[](master_params_out){params.size()}
  infer_meta :
    func : FusedAdamInferMeta
  kernel :
    func : fused_adam
    data_type : params
  optional : moments2_max, skip_update, master_params, moments2_max_out, master_params_out
  inplace : (params -> params_out), (moments1 -> moments1_out), (moments2 -> moments2_out), (moments2_max -> moments2_max_out), (beta1_pows -> beta1_pows_out), (beta2_pows -> beta2_pows_out), (master_params -> master_params_out)

- op : fused_gate_attention
  args: (Tensor query, Tensor key, Tensor query_weight, Tensor key_weight, Tensor
    value_weight, Tensor qkv_weight, Tensor nonbatched_bias, Tensor src_mask, Tensor
    gate_weight, Tensor gate_bias, Tensor out_linear_weight, Tensor out_linear_bias,
    bool has_gating = true, bool merge_qkv = true, bool use_flash_attn = false)
  output: Tensor (query_transpose_out), Tensor (key_transpose_out), Tensor (value_transpose_out),
    Tensor (qkv_transpose_out), Tensor (softmax_out), Tensor (softmax_lse), Tensor
    (fmha_out), Tensor (gate_out), Tensor (out)
  infer_meta:
    func: FusedGateAttentionInferMeta
  kernel:
    func: fused_gate_attention
  optional: key, query_weight, key_weight, value_weight, qkv_weight, nonbatched_bias,
    gate_weight, gate_bias, query_transpose_out, key_transpose_out, value_transpose_out,
    qkv_transpose_out, softmax_lse, gate_out
  intermediate: query_transpose_out, key_transpose_out, value_transpose_out, qkv_transpose_out,
    softmax_out, softmax_lse, fmha_out, gate_out
  backward: fused_gate_attention_grad

- op : fused_multi_transformer_int8
  args: (Tensor x, Tensor[] ln_scale, Tensor[] ln_bias, Tensor[] qkv_w, Tensor[]
    qkv_bias, Tensor[] cache_kv, Tensor time_step, Tensor src_mask, Tensor[] out_linear_w,
    Tensor[] out_linear_bias, Tensor[] ffn_ln_scale, Tensor[] ffn_ln_bias, Tensor[]
    ffn1_weight, Tensor[] ffn1_bias, Tensor[] ffn2_weight, Tensor[] ffn2_bias,
    Tensor[] qkv_out_scale, Tensor[] out_linear_out_scale, Tensor[] ffn1_out_scale,
    Tensor[] ffn2_out_scale, bool pre_layer_norm = true, float epsilon = 1e-5, float
    dropout_rate = .5f, bool is_test = false, str dropout_implementation = "downgrade_in_infer",
    str act_method = "gelu", bool trans_qkvw = true, int ring_id = -1, int num_head
    = 0, int dim_head = 0, int dim_ffn = 0, float[] qkv_in_scale = {}, float[] out_linear_in_scale
    = {}, float[] ffn1_in_scale = {}, float[] ffn2_in_scale = {}, int quant_round_type
    = 1, float quant_max_bound = 127.0, float quant_min_bound = -127.0)
  output: Tensor[](cache_kv_out){cache_kv.size()}, Tensor(out)
  infer_meta:
    func: FusedMultiTransformerInt8InferMeta
  kernel:
    func: fused_multi_transformer_int8
  optional: qkv_bias, cache_kv, time_step, src_mask, out_linear_bias, ffn1_bias,
    ffn2_bias, qkv_out_scale, out_linear_out_scale, ffn1_out_scale, ffn2_out_scale,
    cache_kv_out
  data_transform :
    skip_transform : time_step

- op : get_tensor_from_selected_rows
  args : (Tensor x)
  output : Tensor(out)
  infer_meta :
    func : UnchangedInferMeta
  kernel:
    func: get_tensor_from_selected_rows {selected_rows -> dense}
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : greater_equal
  args : (Tensor x, Tensor y)
  output : Tensor(out)
  infer_meta :
    func : CompareInferMeta
    spmd_rule : ElementwiseBinaryInferSpmd
  kernel :
    func : greater_equal
  data_transform :
    support_trans_dtype : x, y
  inplace: (x -> out)
  interfaces : paddle::dialect::InferSymbolicShapeInterface
  traits : paddle::dialect::ForwardOnlyTrait

- op : greater_than
  args : (Tensor x, Tensor y)
  output : Tensor(out)
  infer_meta :
    func : CompareInferMeta
    spmd_rule : ElementwiseBinaryInferSpmd
  kernel :
    func : greater_than
  data_transform :
    support_trans_dtype : x, y
  inplace: (x -> out)
  interfaces : paddle::dialect::InferSymbolicShapeInterface
  traits : paddle::dialect::ForwardOnlyTrait

- op : hardswish
  args : (Tensor x)
  output : Tensor(out)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : hardswish
  inplace : (x -> out)
  backward : hardswish_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface

- op : hash
  args: (Tensor x, int num_hash = 1, int64_t mod_by = 100000, bool runtime_shape = true)
  output: Tensor (out)
  infer_meta:
    func: HashInferMeta
    param: [x, num_hash, mod_by]
  kernel:
    func: hash
    param: [x, num_hash, mod_by]
    data_type: x

- op : lars_momentum_
  args: (Tensor[] param, Tensor[] grad, Tensor[] velocity, Tensor[] learning_rate, Tensor[] master_param, float mu, float lars_coeff=0.001f, float[] lars_weight_decay={0.0005f}, float epsilon=0.0f, bool multi_precision=false, float rescale_grad=1.0f)
  output: Tensor[](param_out){param.size()}, Tensor[](velocity_out){param.size()}, Tensor[](master_param_out){param.size()}
  infer_meta:
    func: LarsMomentumInferMeta
    param: [param, velocity, learning_rate, grad, master_param, lars_weight_decay, mu, lars_coeff, epsilon, multi_precision, rescale_grad]
  kernel:
    func: lars_momentum
    param: [param, velocity, learning_rate, grad, master_param, lars_weight_decay, mu, lars_coeff, epsilon, multi_precision, rescale_grad]
    data_type: param
  optional: master_param, master_param_out
  inplace : (param -> param_out), (velocity -> velocity_out), (master_param -> master_param_out)
  traits : pir::SideEffectTrait

- op : legacy_matmul
  args : (Tensor x, Tensor y, bool transpose_x = false, bool transpose_y = false, float alpha=1.0f)
  output : Tensor(out)
  infer_meta :
    func : MatmulInferMeta
    param: [x, y, transpose_x, transpose_y]
  kernel :
    func : legacy_matmul
    param: [x, y, transpose_x, transpose_y, alpha]
  backward : legacy_matmul_grad

- op : legacy_reshape
  args : (Tensor x, IntArray shape)
  output : Tensor(out)
  infer_meta :
    func : ReshapeInferMeta
    spmd_rule : ReshapeInferSpmd
    local_shape: out
    global_shape: out
  kernel :
    func : reshape
  inplace : (x -> out)
  view: (x -> out)
  backward: legacy_reshape_grad

- op : less_equal
  args : (Tensor x, Tensor y)
  output : Tensor(out)
  infer_meta :
    func : CompareInferMeta
    spmd_rule : ElementwiseBinaryInferSpmd
  kernel :
    func : less_equal
  data_transform :
    support_trans_dtype : x, y
  inplace: (x -> out)
  interfaces : paddle::dialect::InferSymbolicShapeInterface
  traits : paddle::dialect::ForwardOnlyTrait

- op : less_than
  args : (Tensor x, Tensor y)
  output : Tensor(out)
  infer_meta :
    func : CompareInferMeta
    spmd_rule : ElementwiseBinaryInferSpmd
  kernel :
    func : less_than
  data_transform :
    support_trans_dtype : x, y
  inplace: (x -> out)
  interfaces : paddle::dialect::InferSymbolicShapeInterface
  traits : paddle::dialect::ForwardOnlyTrait

- op : load_combine
  args : (str file_path, bool load_as_fp16, bool model_from_memory)
  output : Tensor[](Out)
  kernel:
    func: load_combine
    param: [file_path, load_as_fp16, model_from_memory]
  optional : Out

- op : lod_array_length
  args : (Tensor[] x)
  output : Tensor(out)

- op : lod_reset
  args: (Tensor x, Tensor y, int[] target_lod={}, bool append=false)
  output: Tensor(out)
  infer_meta:
    func: LodResetInferMeta
  kernel:
    func: lod_reset
  optional: y
  inplace: (x -> out)

- op : lookup_table
  args : (Tensor w, Tensor ids, bool is_sparse = false, bool is_distributed = false,
    int64_t padding_idx = -1, bool remote_prefetch = false, str entry_config
    = "", bool is_test = false, str entry = "none", str table_class = "none", str[]
    table_names = {}, int trainer_id = 0, int slot = 0, bool grad_inplace = false, str[]
    epmap = {}, int64_t[] height_sections = {})
  output : Tensor (out)
  infer_meta:
    func: LookupTableInferMeta
    param: [w, ids]
  kernel:
    func : lookup_table {dense, dense -> dense}
           lookup_table_sr {selected_rows, dense -> selected_rows}
    param: [w, ids, is_sparse, is_distributed, padding_idx, remote_prefetch, entry_config, is_test, entry, table_class, table_names, trainer_id, grad_inplace, epmap, height_sections]
    data_type: w
  backward: lookup_table_grad

- op : lrn
  args: (Tensor x, int n = 5, float k = 2.0, float alpha = 0.0001, float beta = 0.75, str data_format = "AnyLayout")
  output: Tensor (out), Tensor (mid_out)
  infer_meta:
    func: LrnInferMeta
    param : [x, n]
  kernel:
    func: lrn
    data_type: x
  backward: lrn_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : matmul
  args : (Tensor x, Tensor y, bool transpose_x = false, bool transpose_y = false)
  output : Tensor
  infer_meta :
    func : MatmulInferMeta
    spmd_rule : MatmulInferSpmd
  kernel :
    func : matmul
  data_transform :
    support_trans_dtype : x, y
  backward : matmul_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : matmul_with_flatten
  args : (Tensor x, Tensor y, int x_num_col_dims = 1, int y_num_col_dims = 1)
  output : Tensor
  infer_meta :
    func : MatmulWithFlattenInferMeta
  kernel :
    func : matmul_with_flatten
    data_type : x
  backward : matmul_with_flatten_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : maximum
  args : (Tensor x, Tensor y)
  output : Tensor(out)
  infer_meta :
    func : ElementwiseInferMeta
    spmd_rule : ElementwiseBinaryInferSpmd
  kernel :
    func : maximum
  data_transform :
    support_trans_dtype : x, y
  backward : maximum_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
  traits : pir::BinaryElementWiseTrait

- op : memcpy
  args : (Tensor x, int dst_place_type)
  output : Tensor(out)
  infer_meta:
    func: UnchangedInferMeta
    param: [x]
  kernel:
    func : memcpy
    param: [x, dst_place_type]
  interfaces : paddle::dialect::InferSymbolicShapeInterface
  traits : paddle::dialect::ForwardOnlyTrait

- op : min
  args : (Tensor x, IntArray axis={}, bool keepdim=false)
  output : Tensor(out)
  infer_meta :
    func : StrictReduceIntArrayAxisInferMeta
    spmd_rule : ReductionMinInferSpmdDynamic
  kernel :
    func : min
  backward : min_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : minimum
  args : (Tensor x, Tensor y)
  output : Tensor(out)
  infer_meta :
    func : ElementwiseInferMeta
  kernel :
    func : minimum
  data_transform :
    support_trans_dtype : x, y
  backward : minimum_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : multiply
  args : (Tensor x, Tensor y)
  output : Tensor
  infer_meta :
    func : ElementwiseInferMeta
    spmd_rule : ElementwiseBinaryInferSpmd
  kernel :
    func : multiply {dense, dense -> dense},
           multiply_sr {selected_rows, dense -> selected_rows}
  inplace : (x -> out)
  data_transform :
    support_trans_dtype : x, y
  backward : multiply_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
  traits : pir::BinaryElementWiseTrait

- op : nop
  args : (Tensor x)
  output : Tensor(out)
  infer_meta :
    func : UnchangedInferMeta
  kernel :
    func : nop
  inplace: (x -> out)
  interfaces : paddle::dialect::ParseKernelKeyInterface, paddle::dialect::LayoutTransformationInterface
  traits : pir::SideEffectTrait, paddle::dialect::ForwardOnlyTrait, pir::BinaryElementWiseTrait

- op : not_equal
  args : (Tensor x, Tensor y)
  output : Tensor(out)
  infer_meta :
    func : CompareInferMeta
    spmd_rule : ElementwiseBinaryInferSpmd
  kernel :
    func : not_equal
  data_transform :
    support_trans_dtype : x, y
  inplace: (x -> out)
  interfaces : paddle::dialect::InferSymbolicShapeInterface
  traits : paddle::dialect::ForwardOnlyTrait

- op : partial_recv
  args : (int ring_id = 0, int peer = 0, DataType dtype=DataType::FLOAT32, int[] out_shape= {}, int num = 1, int id = 0)
  output : Tensor(out)
  infer_meta :
    func: PartialRecvInferMeta
    param: [peer, dtype, out_shape, num, id]
  kernel :
    func : partial_recv
    data_type : dtype
    param: [peer, dtype, out_shape, num, id]

- op : partial_send
  args: (Tensor x, int ring_id = 0, int peer = 0, int num = 1, int id = 0)
  output :
  infer_meta:
    func: PartialSendInferMeta
    param: [x, peer, num, id]
  kernel:
    func: partial_send
    param: [x, peer, num, id]

- op : print
  args : (Tensor in, int first_n, str message, int summarize, bool print_tensor_name = true, bool print_tensor_type = true, bool print_tensor_shape = true, bool print_tensor_layout = true, bool print_tensor_lod = true, str print_phase = "BOTH", bool is_forward = true)
  output : Tensor(out)
  infer_meta:
    func: UnchangedInferMeta
    param: [in]
  kernel :
    func : print_kernel
    param: [in, first_n, message, summarize, print_tensor_name, print_tensor_type, print_tensor_shape, print_tensor_layout, print_tensor_lod, print_phase, is_forward]
  interfaces : paddle::dialect::InferSymbolicShapeInterface
  traits : pir::SideEffectTrait
  backward: print_grad

# Note: dequantize_linear and quantize_linear are supported using one op maker in fluid, the out_scale can't be used in dequantize_linear
# so ,the out_scale is optional. Currently, we can't modify the op definition of dequantize_linear/quantize_linear and it can cause incompatibility problem
# We need modify dequantize_linear/quantize_linear yaml and make it more reasonable when we abandon Fluid op.
- op : quantize_linear
  args : (Tensor x, Tensor scale, Tensor zero_point, Tensor in_accum, Tensor in_state, int quant_axis = 0, int bit_length = 8, int qmin = -128, int qmax = 127, int round_type = 0, bool is_test = true, bool only_observer = false)
  output : Tensor(y), Tensor(out_state), Tensor(out_accum), Tensor(out_scale)
  infer_meta :
    func : QuantizeLinearInferMeta
    param : [x, scale, zero_point, in_accum, in_state, quant_axis, bit_length, round_type, is_test, only_observer]
  kernel :
    func : quantize_linear
    param : [x, scale, zero_point, in_accum, in_state, quant_axis, bit_length, qmin, qmax, round_type, is_test, only_observer]
    data_type : x
  optional : scale, in_accum, in_state, out_state, out_accum, out_scale
  inplace : (scale -> out_scale, in_accum -> out_accum, in_state -> out_state)
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : recv_v2
  args : (int[] out_shape = {}, DataType dtype = DataType::FLOAT32, int peer = 0, int ring_id = 0, bool use_calc_stream = false, bool dynamic_shape = false)
  output : Tensor(out)
  infer_meta:
    func: RecvV2InferMeta
    param: [ring_id, dynamic_shape, peer, out_shape, dtype]
  kernel :
    func : recv_v2
    param : [ring_id, dynamic_shape, peer, out_shape, dtype, use_calc_stream]
    data_type : dtype
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : remainder
  args : (Tensor x, Tensor y)
  output : Tensor (out)
  infer_meta :
    func : ElementwiseInferMeta
    param: [x, y]
  kernel :
    func : remainder
  data_transform :
    support_trans_dtype : x, y
  inplace : (x -> out)
  interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
  backward: remainder_grad
  traits : pir::BinaryElementWiseTrait

- op : row_conv
  args : (Tensor x, Tensor filter)
  output : Tensor(out)
  infer_meta :
     func: RowConvInferMeta
  kernel :
     func : row_conv

- op : save_combine
  args : (Tensor[] x, str file_path, bool overwrite, bool save_as_fp16, bool save_to_memory)
  output : Tensor(out)
  kernel:
    func: save_combine_tensor
    param: [x, file_path, overwrite, save_as_fp16, save_to_memory]
  optional : out
  interfaces : paddle::dialect::ParseKernelKeyInterface

- op : seed
  args : (int seed, bool deterministic, str rng_name, bool force_cpu)
  output : Tensor(out)
  infer_meta:
    func: SeedInferMeta
    param: [seed]
  kernel:
    func: seed
  traits : pir::SideEffectTrait
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : send_v2
  args : (Tensor x, int ring_id = 0, int peer = 0, bool use_calc_stream = false, bool dynamic_shape = false)
  output :
  infer_meta:
    func: SendV2InferMeta
    param: [peer, ring_id]
  kernel :
    func : send_v2
    param : [x, ring_id, dynamic_shape, peer, use_calc_stream]
  traits : pir::SideEffectTrait

- op : sequence_expand
  args: (Tensor x, Tensor y, int ref_level = -1)
  output: Tensor (out)
  infer_meta:
    func: SequenceExpandInferMeta
  kernel:
    func: sequence_expand
    data_type: x
  backward: sequence_expand_grad
  no_need_buffer: y

- op : sequence_softmax
  args: (Tensor x)
  output: Tensor (out)
  infer_meta:
    func: SequenceSoftmaxInferMeta
  kernel:
    func: sequence_softmax
    param: [x]
  backward: sequence_softmax_grad

- op : set_value
  args : (Tensor x, IntArray starts, IntArray ends, IntArray steps, int64_t[] axes, int64_t[] decrease_axes, int64_t[] none_axes, int64_t[] shape, Scalar[] values)
  output : Tensor(out)
  inplace: (x -> out)
  infer_meta :
    func : SetValueInferMeta
    param : [x]
  kernel :
    func : set_value
  backward: set_value_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : shadow_feed
  args : (Tensor x,  int dst_place_type)
  output : Tensor(out)
  infer_meta:
    func: UnchangedInferMeta
    param: [x]
  kernel:
    func: shadow_feed
    param: [x, dst_place_type]
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : shadow_feed_tensors
  args : (Tensor[] x, int dst_place_type)
  output : Tensor[](out){x.size()}
  infer_meta:
    func: UnchangedVectorInferMeta
    param: [x]
  kernel:
    func: shadow_feed_tensors
    param: [x, dst_place_type]

- op : share_data_
  args : (Tensor x)
  output : Tensor(out)
  infer_meta:
    func: UnchangedInferMeta
    spmd_rule : ElementwiseUnaryInferSpmd
    param: [x]
  kernel:
    func: share_data
    param: [x]
  inplace : (x -> out)
  traits : paddle::dialect::ForwardOnlyTrait
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : soft_relu
  args : (Tensor x, float threshold = 40.0f)
  output : Tensor(out)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : soft_relu
  backward : soft_relu_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : softmax
  args : (Tensor x, int axis)
  output : Tensor(out)
  infer_meta :
    func : SoftmaxInferMeta
    spmd_rule : SoftmaxInferSpmd
  kernel :
    func : softmax
  inplace : (x -> out)
  backward : softmax_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : sparse_momentum
  args: (Tensor param, Tensor grad, Tensor velocity, Tensor index, Tensor learning_rate, Tensor master_param,float mu, Scalar axis=0, bool use_nesterov=false,str regularization_method="", float regularization_coeff=0.0f, bool multi_precision=false, float rescale_grad=1.0f)
  output: Tensor(param_out), Tensor(velocity_out), Tensor(master_param_out)
  infer_meta:
    func: SparseMomentumInferMeta
    param: [param, grad, velocity, index, learning_rate]
  kernel:
    func: sparse_momentum
    data_type: param
  optional: master_param, master_param_out

- op : straight_through_estimator_grad
  args: (Tensor out_grad)
  output: Tensor(x_grad)
  infer_meta:
    func: StraightThroughEstimatorInferMeta
  kernel:
    func: straight_through_estimator_grad

- op : subtract
  args : (Tensor x, Tensor y)
  output : Tensor(out)
  infer_meta :
    func : ElementwiseInferMeta
    spmd_rule : ElementwiseBinaryInferSpmd
  kernel :
    func : subtract
  inplace : (x -> out)
  data_transform :
    support_trans_dtype : x, y
  backward : subtract_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface
  traits : pir::BinaryElementWiseTrait

- op : sync_comm_stream
  args : (Tensor[] x, int ring_id = 0)
  output : Tensor[](out){x.size()}
  infer_meta :
    func : UnchangedVectorInferMeta
    param : [x]
  kernel :
    func : sync_comm_stream
    data_type : DataType::FLOAT32
  inplace: (x -> out)

- op : tile
  args : (Tensor x, IntArray repeat_times = {})
  output : Tensor(out)
  infer_meta :
    func : TileInferMeta
    spmd_rule : TileInferSpmdDynamic
  kernel :
    func : tile
  backward : tile_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op : unique
  args : (Tensor x, bool return_index=false, bool return_inverse=false, bool return_counts=false, int[] axis={}, DataType dtype=DataType::INT64, bool is_sorted=false)
  output : Tensor(out), Tensor(indices), Tensor(inverse), Tensor(counts)
  optional : indices, counts
  infer_meta :
    func : UniqueRawInferMeta
    spmd_rule : UniqueInferSpmdStatic
  kernel :
    func : unique
    data_type : x
  interfaces : paddle::dialect::ParseKernelKeyInterface
  interfaces : paddle::dialect::InferSymbolicShapeInterface
  traits : paddle::dialect::ForwardOnlyTrait

- op : write_to_array
  args : (Tensor i, Tensor x)
  output : Tensor[](out)

- op: c_softmax_with_multi_label_cross_entropy
  args: (Tensor logits, Tensor label, Tensor smooth_weight, int64_t ignore_index=-100, bool sum_multi_label_loss=true, int ring_id=0, int rank=0, int nranks=0)
  output: Tensor(softmax), Tensor(loss)
  infer_meta:
    func : CSoftmaxWithMultiLabelCrossEntropyInferMeta
    spmd_rule : CSoftmaxWithMultiLabelCrossEntropyInferSpmd
    param: [logits, label, smooth_weight, ignore_index, sum_multi_label_loss, rank, nranks]
  kernel:
    func: c_softmax_with_multi_label_cross_entropy
    data_type : logits
    param: [logits, label, smooth_weight, ignore_index, sum_multi_label_loss, rank, nranks]
  backward: c_softmax_with_multi_label_cross_entropy_grad

- op: faster_tokenizer
  args: (Tensor vocab, Tensor text, Tensor text_pair, bool do_lower_case = false,
    bool is_split_into_words = false, int max_seq_len = 0, bool pad_to_max_seq_len
    = false)
  output: Tensor (input_ids), Tensor (segment_ids)
  infer_meta:
    func: FasterTokenizerInferMeta
  kernel:
    func: faster_tokenizer
  optional: text_pair

- op: fused_attention
  args: (Tensor x, Tensor ln_scale, Tensor ln_bias, Tensor qkv_weight, Tensor qkv_bias, Tensor cache_kv, Tensor src_mask, Tensor out_linear_weight, Tensor out_linear_bias, Tensor ln_scale_2, Tensor ln_bias_2, int num_heads, bool transpose_qkv_wb, bool pre_layer_norm, float epsilon, float attn_dropout_rate, bool is_test, bool attn_dropout_fix_seed, int attn_dropout_seed, str attn_dropout_implementation, float dropout_rate, bool dropout_fix_seed, int dropout_seed, str dropout_implementation, float ln_epsilon, bool add_residual, int ring_id)
  output: Tensor(ln_mean), Tensor(ln_var), Tensor(ln_out), Tensor(qkv_out), Tensor(qkv_bias_out), Tensor(transpose_out_2), Tensor(qk_out), Tensor(qktv_out), Tensor(softmax_out), Tensor(attn_dropout_mask_out), Tensor(attn_dropout_out), Tensor(src_mask_out), Tensor(fmha_out), Tensor(out_linear_out), Tensor(dropout_mask_out), Tensor(ln_mean_2), Tensor(ln_var_2), Tensor(bias_dropout_residual_out), Tensor(cache_kv_out), Tensor(out)
  kernel:
    func: fused_attention
    data_type : x
  infer_meta:
    func: FusedAttentionInferMeta
  optional: cache_kv, ln_scale, ln_bias, qkv_bias, src_mask, out_linear_bias, ln_scale_2, ln_bias_2, ln_mean_2, ln_var_2, bias_dropout_residual_out, cache_kv_out
  backward: fused_attention_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op: fused_feedforward
  args: (Tensor x, Tensor dropout1_seed, Tensor dropout2_seed, Tensor linear1_weight, Tensor linear1_bias, Tensor linear2_weight, Tensor linear2_bias, Tensor ln1_scale, Tensor ln1_bias, Tensor ln2_scale, Tensor ln2_bias, bool pre_layer_norm, float ln1_epsilon, float ln2_epsilon, str act_method, float dropout1_prob, float dropout2_prob, str dropout1_implementation, str dropout2_implementation, bool is_test, bool dropout1_fix_seed, bool dropout2_fix_seed, int dropout1_seed_val, int dropout2_seed_val, bool add_residual, int ring_id)
  output: Tensor(out), Tensor(dropout1_mask), Tensor(dropout2_mask), Tensor(ln1_mean), Tensor(ln1_variance), Tensor(ln2_mean), Tensor(ln2_variance), Tensor(linear1_out), Tensor(ln1_out), Tensor(dropout1_out), Tensor(dropout2_out)
  kernel:
    func: fused_feedforward
    data_type : x
  infer_meta:
    func: FusedFeedForwardInferMeta
  optional: dropout1_seed, dropout2_seed, linear1_bias, linear2_bias, ln1_scale, ln1_bias, ln2_scale, ln2_bias, ln2_mean, ln2_variance, ln1_mean, ln1_variance, ln1_out
  backward: fused_feedforward_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op: moving_average_abs_max_scale
  args: (Tensor x, Tensor in_accum, Tensor in_state, float moving_rate=0.9f, bool is_test=false)
  output: Tensor(out), Tensor(out_scale), Tensor(out_state), Tensor(out_accum)
  infer_meta:
    func: MovingAverageAbsMaxScaleInferMeta
    param: [x, in_accum, in_state]
  kernel:
    func: moving_average_abs_max_scale
    param: [x, in_accum, in_state, moving_rate, is_test]
  optional : in_accum, in_state, out, out_state, out_accum
  inplace : (in_accum -> out_accum), (in_state -> out_state)
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op: nce
  args: (Tensor input, Tensor label, Tensor weight, Tensor bias, Tensor sample_weight, Tensor custom_dist_probs, Tensor custom_dist_alias, Tensor custom_dist_alias_probs, int num_total_classes, int[] custom_neg_classes={}, int num_neg_samples=10, int sampler=0, int seed=0, bool is_sparse=false, bool remote_prefetch=false, bool is_test=false)
  output: Tensor(cost), Tensor(sample_logits), Tensor(sample_labels)
  infer_meta:
    func: NceInferMeta
  kernel:
    func: nce
    data_type: input
  optional: bias, sample_weight, custom_dist_probs, custom_dist_alias, custom_dist_alias_probs
  intermediate: sample_logits, sample_labels
  backward: nce_grad
  interfaces : paddle::dialect::InferSymbolicShapeInterface

- op: onednn_to_paddle_layout
  args: (Tensor x, int dst_layout)
  output: Tensor(out)
  infer_meta:
    func : UnchangedInferMeta
    param : [x]
  kernel:
    func: onednn_to_paddle_layout