wehub-resource-sync
947 lines
40 KiB
YAML
947 lines
40 KiB
YAML
# This file is designed for fusion C++ forward operators, which manages the
|
|
# generated code for static mode and dynamic mode (when `support_dygraph_mode` is true).
|
|
# "support_dygraph_mode" is an extra configuration item in this file,
|
|
# if one operator have "support_dygraph_mode : true", it supports dygraph mode,
|
|
# otherwise the operator only could be used in static mode.
|
|
|
|
- op : add_act_xpu
|
|
args : (Tensor x, Tensor x_max, Tensor y, Tensor y_max, int act_type)
|
|
output : Tensor(out), Tensor(out_max)
|
|
infer_meta :
|
|
func : AddActXPUInferMeta
|
|
kernel :
|
|
func : add_act_xpu
|
|
data_type : x
|
|
optional : x_max, y_max
|
|
|
|
- op : add_layernorm_xpu
|
|
args : (Tensor x, Tensor y, Tensor scale, Tensor bias, int begin_norm_axis, float epsilon)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : AddLayernormXPUInferMeta
|
|
kernel :
|
|
func : add_layernorm_xpu
|
|
data_type : x
|
|
|
|
- op : addcmul_xpu
|
|
args : (Tensor x, Tensor y, Tensor w)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : AddCMulXPUInferMeta
|
|
kernel :
|
|
func : addcmul_xpu
|
|
data_type : x
|
|
|
|
- op : blha_get_max_len
|
|
args : (Tensor seq_lens_encoder, Tensor seq_lens_decoder, Tensor batch_size)
|
|
output : Tensor(max_enc_len_this_time), Tensor(max_dec_len_this_time)
|
|
infer_meta :
|
|
func : BlhaGetMaxLenInferMeta
|
|
kernel :
|
|
func : blha_get_max_len
|
|
data_type : seq_lens_encoder
|
|
support_dygraph_mode : true
|
|
|
|
- op : block_multihead_attention_
|
|
args : (Tensor qkv, Tensor key_cache, Tensor value_cache, Tensor seq_lens_encoder, Tensor seq_lens_decoder, Tensor seq_lens_this_time, Tensor padding_offsets, Tensor cum_offsets, Tensor cu_seqlens_q, Tensor cu_seqlens_k, Tensor block_tables, Tensor pre_key_cache, Tensor pre_value_cache, Tensor rope_emb, Tensor mask, Tensor tgt_mask, Tensor cache_k_quant_scales, Tensor cache_v_quant_scales, Tensor cache_k_dequant_scales, Tensor cache_v_dequant_scales, Tensor qkv_out_scale, Tensor qkv_bias, Tensor out_shift, Tensor out_smooth, Tensor max_enc_len_this_time, Tensor max_dec_len_this_time, int max_seq_len, int block_size, bool use_neox_style, bool dynamic_cachekv_quant=false, int quant_round_type=1, float quant_max_bound=127.0, float quant_min_bound=-127.0, float out_scale=-1, str compute_dtype="default", float rope_theta=10000.0)
|
|
output : Tensor(fmha_out), Tensor(qkv_out), Tensor(key_cache_out), Tensor(value_cache_out)
|
|
infer_meta :
|
|
func : BlockMultiheadAttentionInferMeta
|
|
kernel :
|
|
func : block_multihead_attention
|
|
data_type : qkv
|
|
optional : pre_key_cache, pre_value_cache, rope_emb, mask, tgt_mask, cache_k_quant_scales, cache_v_quant_scales, cache_k_dequant_scales, cache_v_dequant_scales, qkv_out_scale, qkv_bias, out_shift, out_smooth, max_enc_len_this_time, max_dec_len_this_time
|
|
inplace : (qkv -> qkv_out), (key_cache -> key_cache_out), (value_cache -> value_cache_out)
|
|
support_dygraph_mode : true
|
|
data_transform :
|
|
skip_transform : max_enc_len_this_time, max_dec_len_this_time
|
|
|
|
- op : block_multihead_attention_xpu
|
|
args : (Tensor qkv, Tensor key_cache, Tensor value_cache, Tensor seq_lens_encoder, Tensor seq_lens_decoder, Tensor seq_lens_this_time, Tensor padding_offsets, Tensor cum_offsets, Tensor cu_seqlens_q, Tensor cu_seqlens_k, Tensor block_tables, Tensor cache_k_per_batch_maxs, Tensor cache_v_per_batch_maxs, Tensor pre_key_cache, Tensor pre_value_cache, Tensor rope_emb, Tensor mask, Tensor tgt_mask, Tensor cache_k_quant_scales, Tensor cache_v_quant_scales, Tensor cache_k_dequant_scales, Tensor cache_v_dequant_scales, Tensor qkv_out_scale, Tensor qkv_bias, Tensor out_shift, Tensor out_smooth, Tensor max_enc_len_this_time, Tensor max_dec_len_this_time, int max_seq_len, int block_size, bool use_neox_style, bool dynamic_cachekv_quant=false, int quant_round_type=1, float quant_max_bound=127.0, float quant_min_bound=-127.0, float out_scale=-1, str compute_dtype="default", float rope_theta=10000.0)
|
|
output : Tensor(fmha_out), Tensor(qkv_out), Tensor(key_cache_out), Tensor(value_cache_out)
|
|
infer_meta :
|
|
func : BlockMultiheadAttentionInferXPUMeta
|
|
kernel :
|
|
func : block_multihead_attention_xpu
|
|
data_type : qkv
|
|
optional : pre_key_cache, pre_value_cache, rope_emb, mask, tgt_mask, cache_k_quant_scales, cache_v_quant_scales, cache_k_dequant_scales, cache_v_dequant_scales, qkv_out_scale, qkv_bias, out_shift, out_smooth, max_enc_len_this_time, max_dec_len_this_time
|
|
inplace : (qkv -> qkv_out), (key_cache -> key_cache_out), (value_cache -> value_cache_out)
|
|
support_dygraph_mode : true
|
|
data_transform :
|
|
skip_transform : max_enc_len_this_time, max_dec_len_this_time
|
|
|
|
- op : bn_act_xpu
|
|
args : (Tensor x, Tensor mean, Tensor variance, Tensor scale, Tensor bias, float momentum, float epsilon, str data_format, int act_type)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : BNActXPUInferMeta
|
|
kernel :
|
|
func : bn_act_xpu
|
|
data_type : x
|
|
|
|
- op : conv1d_xpu
|
|
args : (Tensor x, Tensor x_max, Tensor filter, Tensor filter_max, Tensor bias, Tensor branch, Tensor branch_max, int[] paddings, str padding_algorithm, int dilations, int strides, int groups, int act_type, float act_param)
|
|
output : Tensor(out), Tensor(out_max)
|
|
infer_meta :
|
|
func : Conv1dXPUInferMeta
|
|
kernel :
|
|
func : conv1d_xpu
|
|
data_type : x
|
|
optional : bias, branch, branch_max, x_max
|
|
|
|
- op : conv2d_transpose_xpu
|
|
args : (Tensor x, Tensor x_max, Tensor filter, Tensor filter_max, Tensor bias, int[] strides, int[] paddings, int[] output_padding, IntArray output_size, str padding_algorithm, int groups, int[] dilations, str data_format, bool has_bias, bool with_act, str act_type)
|
|
output : Tensor(out), Tensor(out_max)
|
|
infer_meta :
|
|
func : Conv2dTransposeXPUInferMeta
|
|
kernel :
|
|
func : conv2d_transpose_xpu
|
|
data_type : x
|
|
optional : bias, x_max
|
|
|
|
- op : conv2d_xpu
|
|
args : (Tensor x, Tensor x_max, Tensor filter, Tensor filter_max, Tensor bias, Tensor branch, Tensor branch_max, Tensor scale_max, Tensor out_max_in, int[] paddings, int[] dilations, int[] strides, str padding_algorithm, int groups, int act_type, float act_param, DataType out_dtype)
|
|
output : Tensor(out), Tensor(out_max)
|
|
infer_meta :
|
|
func : Conv2dXPUInferMeta
|
|
kernel :
|
|
func : conv2d_xpu
|
|
data_type : x
|
|
optional : bias, branch, branch_max ,x_max, scale_max, out_max_in
|
|
|
|
- op : cross_attention_xpu
|
|
args : (Tensor input_q, Tensor input_kv, Tensor[] fc_weight, Tensor[] fc_weight_max, Tensor[] fc_bias, Tensor mask, int head_num, int head_dim, float alpha, DataType out_dtype)
|
|
output : Tensor(qkv), Tensor(qkv_max)
|
|
infer_meta :
|
|
func : CrossAttentionXPUInferMeta
|
|
kernel :
|
|
func : cross_attention_xpu
|
|
data_type : input_q
|
|
|
|
- op : dequantize_xpu
|
|
args : (Tensor x, DataType out_dtype, float scale = 1.0f)
|
|
output : Tensor(y)
|
|
infer_meta :
|
|
func : DeQuantizeXPUInferMeta
|
|
kernel :
|
|
func : dequantize_xpu
|
|
data_type: x
|
|
|
|
- op : distributed_fused_lamb_init
|
|
args : (Tensor[] param, Tensor[] grad, float beta1, float beta2, int[] apply_weight_decay, int alignment, int rank, int nranks)
|
|
output : Tensor(fp32_fused_param), Tensor(fp32_fused_grad), Tensor(fp16_fused_param), Tensor(fp16_fused_grad), Tensor(moment1), Tensor(moment2), Tensor(beta1_pow), Tensor(beta2_pow), Tensor(fused_param_offsets), Tensor(fp32_shard_fused_param_offsets), Tensor(fp16_shard_fused_param_offsets), Tensor(param_info), Tensor(param_order), Tensor[](param_out){param.size()}, Tensor[](master_param_out){param.size()}, Tensor[](grad_out){grad.size()}, Tensor(global_scale), Tensor(step)
|
|
infer_meta :
|
|
func : DistributedFusedLambInitInferMeta
|
|
kernel :
|
|
func : distributed_fused_lamb_init
|
|
data_type: DataType::FLOAT32
|
|
optional : fp32_fused_param, fp32_fused_grad, fp16_fused_param, fp16_fused_grad
|
|
inplace: (param -> param_out), (grad -> grad_out)
|
|
|
|
- op : embedding_with_eltwise_add_xpu
|
|
args : (Tensor[] ids, Tensor[] tables, Tensor mask, int64_t padding_idx)
|
|
output: Tensor(out), Tensor(seq_lod), Tensor(max_seq_len)
|
|
infer_meta :
|
|
func: EmbeddingWithEltwiseAddXPUInferMeta
|
|
param : [ids, tables, mask]
|
|
kernel:
|
|
func: embedding_with_eltwise_add_xpu
|
|
data_type: tables
|
|
optional : mask, seq_lod, max_seq_len
|
|
|
|
- op : fast_layernorm_xpu
|
|
args : (Tensor x, Tensor scale, Tensor bias, int begin_norm_axis, float epsilon)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : FastLayernormXPUInferMeta
|
|
kernel :
|
|
func : fast_layernorm_xpu
|
|
data_type : x
|
|
|
|
- op : fast_where_xpu
|
|
args : (Tensor condition, Tensor x, Tensor y)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : FastWhereXPUInferMeta
|
|
kernel :
|
|
func : fast_where_xpu
|
|
data_type : x
|
|
|
|
- op : fc
|
|
args : (Tensor input, Tensor w, Tensor bias, int in_num_col_dims = 1, str activation_type = "", bool padding_weights = false)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : FCInferMeta
|
|
kernel :
|
|
func : fc
|
|
data_type : input
|
|
optional : bias
|
|
|
|
- op : fc_xpu
|
|
args : (Tensor x, Tensor x_max, Tensor w, Tensor w_max, Tensor bias, Tensor scale_max, Tensor out_max_in, int in_num_col_dims, bool transpose_x, float alpha, float beta, int act_type, float act_alpha, DataType out_dtype)
|
|
output : Tensor(out), Tensor(out_max)
|
|
infer_meta :
|
|
func : FcXPUInferMeta
|
|
kernel :
|
|
func : fc_xpu
|
|
data_type : x
|
|
optional : bias, x_max, w_max, scale_max, out_max_in
|
|
|
|
- op : fp8_fp8_half_gemm_fused
|
|
args : (Tensor x, Tensor y, Tensor bias, bool transpose_x = false, bool transpose_y = false, float scale = 1.0f, str output_dtype = "float16", str activation_type = "identity")
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : FP8OutHalfGemmFusedInferMeta
|
|
kernel :
|
|
func : fp8_fp8_half_gemm_fused
|
|
data_type : x
|
|
optional : bias
|
|
support_dygraph_mode : true
|
|
|
|
- op : fused_bias_act
|
|
args : (Tensor x, Tensor bias, Tensor dequant_scales, Tensor shift, Tensor smooth, str act_method = "gelu", str compute_dtype = "default", float quant_scale = -1, int quant_round_type = 1, float quant_max_bound = 127.0, float quant_min_bound = -127.0)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func: FusedBiasActInferMeta
|
|
kernel :
|
|
func : fused_bias_act
|
|
data_type : x
|
|
optional : bias, dequant_scales, shift, smooth
|
|
support_dygraph_mode : true
|
|
|
|
- op : fused_bias_dropout_residual_layer_norm
|
|
args : (Tensor x, Tensor residual, Tensor bias, Tensor ln_scale, Tensor ln_bias, float dropout_rate = 0.5f, bool is_test = false, bool dropout_fix_seed = true, int dropout_seed = true, str dropout_implementation = "downgrade_in_infer", float ln_epsilon = 1e-5)
|
|
optional : bias, ln_scale, ln_bias
|
|
output : Tensor(y), Tensor(bias_dropout_residual_out), Tensor(dropout_mask_out), Tensor(ln_mean), Tensor(ln_variance)
|
|
infer_meta :
|
|
func : FusedBiasDropoutResidualLnInferMeta
|
|
kernel :
|
|
func : fused_bias_dropout_residual_layer_norm
|
|
data_type : x
|
|
backward : fused_bias_dropout_residual_layer_norm_grad
|
|
intermediate : bias_dropout_residual_out, dropout_mask_out, ln_mean, ln_variance
|
|
support_dygraph_mode : true
|
|
|
|
- op : fused_bias_residual_layernorm
|
|
args : (Tensor x, Tensor bias, Tensor residual, Tensor norm_weight, Tensor norm_bias, float epsilon, float residual_alpha, int begin_norm_axis, float quant_scale, int quant_round_type, float quant_max_bound, float quant_min_bound)
|
|
output : Tensor(out), Tensor(residual_out), Tensor(mean), Tensor(variance)
|
|
infer_meta :
|
|
func : FusedLayerNormInferMeta
|
|
kernel :
|
|
func : fused_bias_residual_layernorm
|
|
data_type : x
|
|
optional : bias, residual, norm_weight, norm_bias, residual_out
|
|
support_dygraph_mode : true
|
|
|
|
- op : fused_conv2d_add_act
|
|
args : (Tensor input, Tensor filter, Tensor bias, Tensor residual_data, int[] strides={1, 1}, int[] paddings={0, 0}, str padding_algorithm="EXPLICIT", int[] dilations={1, 1} , int groups=1, str data_format="NCHW", str activation="relu", int[] split_channels={}, bool exhaustive_search=false, int workspace_size_MB=32, float fuse_alpha=0.0f)
|
|
output : Tensor(output), Tensor[](outputs){split_channels.size()}
|
|
infer_meta :
|
|
func : FusedConv2dAddActInferMeta
|
|
param : [input, filter, bias, residual_data, strides, paddings, padding_algorithm, dilations, groups, data_format, activation, split_channels]
|
|
kernel :
|
|
func : fused_conv2d_add_act
|
|
data_type : input
|
|
optional : bias, residual_data, outputs
|
|
interfaces : paddle::dialect::LayoutTransformationInterface
|
|
|
|
- op : fused_dconv_drelu_dbn
|
|
args : (Tensor grad_output, Tensor weight, Tensor grad_output_add, Tensor residual_input, Tensor bn1_eqscale, Tensor bn1_eqbias, Tensor conv_input, Tensor bn1_mean, Tensor bn1_inv_std, Tensor bn1_gamma, Tensor bn1_beta, Tensor bn1_input, Tensor bn2_mean, Tensor bn2_inv_std, Tensor bn2_gamma, Tensor bn2_beta, Tensor bn2_input, int[] paddings, int[] dilations, int[] strides, str padding_algorithm, int groups, str data_format, bool fuse_shortcut, bool fuse_dual, bool fuse_add, bool exhaustive_search)
|
|
output : Tensor(grad_weight), Tensor(grad_bn1_input), Tensor(grad_bn1_gamma), Tensor(grad_bn1_beta), Tensor(grad_bn2_input), Tensor(grad_bn2_gamma), Tensor(grad_bn2_beta)
|
|
optional : grad_output_add, residual_input, bn1_eqscale, bn1_eqbias, conv_input, bn2_mean, bn2_inv_std, bn2_gamma, bn2_beta, bn2_input, grad_bn2_input, grad_bn2_gamma, grad_bn2_beta
|
|
infer_meta :
|
|
func : FusedDconvDreluDbnInferMeta
|
|
kernel :
|
|
func : fused_dconv_drelu_dbn
|
|
data_type : grad_output
|
|
|
|
- op : fused_dot_product_attention
|
|
args : (Tensor q, Tensor k, Tensor v, Tensor bias, Tensor cu_seqlen_q, Tensor cu_seqlen_kv, float scaling_factor, float dropout_probability, bool is_training = false, str mask_type_str = "none", str bias_type_str = "none")
|
|
output : Tensor(out), Tensor(softmax_out), Tensor(rng_state)
|
|
infer_meta :
|
|
func : FusedDotProductAttentionInferMeta
|
|
param : [q, k, v, bias]
|
|
kernel :
|
|
func : fused_dot_product_attention
|
|
data_type : q
|
|
backward : fused_dot_product_attention_grad
|
|
optional : bias, cu_seqlen_q, cu_seqlen_kv
|
|
support_dygraph_mode : true
|
|
|
|
- op : fused_dropout_add
|
|
args : (Tensor x, Tensor y, Tensor seed_tensor, Scalar p, bool is_test, str mode, int seed = 0, bool fix_seed = false)
|
|
optional : seed_tensor
|
|
output : Tensor(out), Tensor(seed_offset)
|
|
infer_meta :
|
|
func : FusedDropoutAddInferMeta
|
|
spmd_rule : FusedDropoutAddSpmd
|
|
param : [x, y]
|
|
kernel :
|
|
func : fused_dropout_add
|
|
data_type : x
|
|
backward : fused_dropout_add_grad
|
|
support_dygraph_mode : true
|
|
|
|
- op : fused_elementwise_add
|
|
args: (Tensor x, Tensor y, int axis = -1, str fuse_activation = "", float fuse_alpha
|
|
= 0.0f, float fuse_beta = 0.0f, float fused_output_scale = 1.0f, int[] fused_unsqueeze2_axes
|
|
= {}, float scale_x = 1.0f, float scale_y = 1.0f, float scale_out = 1.0f)
|
|
output: Tensor (out)
|
|
infer_meta:
|
|
func: ElementwiseInferMeta
|
|
param : [x, y]
|
|
kernel :
|
|
func : fused_elementwise_add
|
|
data_type : x
|
|
support_dygraph_mode : true
|
|
traits : pir::BinaryElementWiseTrait
|
|
interfaces: paddle::dialect::LayoutTransformationInterface
|
|
|
|
- op : fused_elementwise_div
|
|
args: (Tensor x, Tensor y, int axis = -1, str fuse_activation = "", float fuse_alpha
|
|
= 0.0f, float fuse_beta = 0.0f, float fused_output_scale = 1.0f, int[] fused_unsqueeze2_axes
|
|
= {}, float scale_x = 1.0f, float scale_y = 1.0f, float scale_out = 1.0f)
|
|
output: Tensor (out)
|
|
infer_meta:
|
|
func: ElementwiseInferMeta
|
|
param : [x, y]
|
|
kernel :
|
|
func : fused_elementwise_div
|
|
data_type : x
|
|
support_dygraph_mode : true
|
|
traits : pir::BinaryElementWiseTrait
|
|
interfaces: paddle::dialect::LayoutTransformationInterface
|
|
|
|
- op : fused_elementwise_mul
|
|
args: (Tensor x, Tensor y, int axis = -1, str fuse_activation = "", float fuse_alpha
|
|
= 0.0f, float fuse_beta = 0.0f, float fused_output_scale = 1.0f, int[] fused_unsqueeze2_axes
|
|
= {}, float scale_x = 1.0f, float scale_y = 1.0f, float scale_out = 1.0f)
|
|
output: Tensor (out)
|
|
infer_meta:
|
|
func: ElementwiseInferMeta
|
|
param : [x, y]
|
|
kernel :
|
|
func : fused_elementwise_mul
|
|
data_type : x
|
|
support_dygraph_mode : true
|
|
traits : pir::BinaryElementWiseTrait
|
|
interfaces: paddle::dialect::LayoutTransformationInterface
|
|
|
|
- op : fused_elementwise_sub
|
|
args: (Tensor x, Tensor y, int axis = -1, str fuse_activation = "", float fuse_alpha
|
|
= 0.0f, float fuse_beta = 0.0f, float fused_output_scale = 1.0f, int[] fused_unsqueeze2_axes
|
|
= {}, float scale_x = 1.0f, float scale_y = 1.0f, float scale_out = 1.0f)
|
|
output: Tensor (out)
|
|
infer_meta:
|
|
func: ElementwiseInferMeta
|
|
param : [x, y]
|
|
kernel :
|
|
func : fused_elementwise_sub
|
|
data_type : x
|
|
support_dygraph_mode : true
|
|
traits : pir::BinaryElementWiseTrait
|
|
interfaces: paddle::dialect::LayoutTransformationInterface
|
|
|
|
- op : fused_elemwise_activation
|
|
args: (Tensor x, Tensor y, str[] functor_list, int axis = -1, float scale = 0.0, bool save_intermediate_out
|
|
= false)
|
|
output: Tensor (out), Tensor (intermediate_out)
|
|
infer_meta:
|
|
func: FusedElemwiseActivationInferMeta
|
|
kernel:
|
|
func: fused_elemwise_activation
|
|
data_type: x
|
|
intermediate: intermediate_out
|
|
backward: fused_elemwise_activation_grad
|
|
|
|
- op : fused_elemwise_add_activation
|
|
args: (Tensor x, Tensor y, str[] functor_list, int axis = -1, float scale = 0.0, bool save_intermediate_out = false)
|
|
output: Tensor(out), Tensor(intermediate_out)
|
|
kernel:
|
|
func: fused_elemwise_add_activation
|
|
infer_meta:
|
|
func : FusedElemwiseActivationInferMeta
|
|
backward: fused_elemwise_add_activation_grad
|
|
intermediate: intermediate_out
|
|
|
|
- op : fused_embedding_eltwise_layernorm
|
|
args : (Tensor[] ids, Tensor[] embs, Tensor bias, Tensor scale, float epsilon = 0.00001f)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : FusedEmbeddingEltWiseLayerNormInferMeta
|
|
kernel :
|
|
func : fused_embedding_eltwise_layernorm
|
|
data_type : embs
|
|
|
|
- op : fused_fc_elementwise_layernorm
|
|
args : (Tensor x, Tensor w, Tensor y, Tensor bias0, Tensor scale, Tensor bias1, int x_num_col_dims = 1, str activation_type = "", float epsilon = 0.00001f, int begin_norm_axis = 1)
|
|
output : Tensor(out), Tensor(mean), Tensor(variance)
|
|
infer_meta :
|
|
func : FusedFCElementwiseLayerNormInferMeta
|
|
kernel :
|
|
func : fused_fc_elementwise_layernorm
|
|
data_type : x
|
|
optional : bias0, scale, bias1, mean, variance
|
|
|
|
- op : fused_linear_param_grad_add
|
|
args : (Tensor x, Tensor dout, Tensor dweight, Tensor dbias, bool multi_precision = true, bool has_bias = true)
|
|
output : Tensor(dweight_out), Tensor(dbias_out)
|
|
infer_meta:
|
|
func : FusedLinearParamGradAddInferMeta
|
|
spmd_rule : FusedLinearParamGradAddInferSpmd
|
|
optional : dweight, dbias
|
|
kernel:
|
|
func : fused_linear_param_grad_add
|
|
data_type : dout
|
|
support_dygraph_mode : true
|
|
traits : pir::SideEffectTrait
|
|
|
|
- op : fused_multi_transformer_
|
|
args : (Tensor x, Tensor[] ln_scales, Tensor[] ln_biases, Tensor[] qkv_weights, Tensor[] qkv_biases, Tensor[] cache_kvs, Tensor[] pre_caches, Tensor rotary_tensor, Tensor beam_offset, Tensor time_step, Tensor seq_lengths, Tensor src_mask, Tensor[] out_linear_weights, Tensor[] out_linear_biases, Tensor[] ffn_ln_scales, Tensor[] ffn_ln_biases, Tensor[] ffn1_weights, Tensor[] ffn1_biases, Tensor[] ffn2_weights, Tensor[] ffn2_biases, bool pre_layer_norm = true, float epsilon = 1e-5, float residual_alpha = 1.0f, float dropout_rate = .5f, int rotary_emb_dims = 0, bool is_test = false, str dropout_implementation = "downgrade_in_infer", str act_method = "gelu", bool trans_qkvw = true, int ring_id = -1, str norm_type = "layernorm", bool use_neox_rotary_style=true, int gqa_group_size=-1)
|
|
output : Tensor[](cache_kv_outs){out_linear_weights.size()}, Tensor(out)
|
|
infer_meta :
|
|
func : FusedMultiTransformerInferMeta
|
|
kernel :
|
|
func : fused_multi_transformer
|
|
data_type : x
|
|
optional : ln_biases, qkv_biases, cache_kvs, pre_caches, rotary_tensor, beam_offset, time_step, seq_lengths, src_mask, out_linear_biases, ffn_ln_biases, ffn1_biases, ffn2_biases, cache_kv_outs
|
|
inplace : (cache_kvs -> cache_kv_outs)
|
|
support_dygraph_mode : true
|
|
data_transform :
|
|
skip_transform : time_step
|
|
|
|
- op : fused_multi_transformer_int8_xpu
|
|
args : (Tensor x, Tensor[] ln_scale, Tensor[] ln_bias, Tensor[] qkv_in_max, Tensor[] qkvw, Tensor[] qkv_bias, Tensor[] qkv_scales, Tensor[] out_linear_in_max, Tensor[] out_linear_w, Tensor[] out_linear_bias, Tensor[] out_linear_scales, Tensor[] ffn_ln_scale, Tensor[] ffn_ln_bias, Tensor[] ffn1_in_max, Tensor[] ffn1_weight, Tensor[] ffn1_bias, Tensor[] ffn1_scales, Tensor[] ffn2_in_max, Tensor[] ffn2_weight, Tensor[] ffn2_bias, Tensor[] ffn2_scales, Tensor[] cache_kv, Tensor[] pre_caches, Tensor rotary_pos_emb, Tensor time_step, Tensor seq_lengths, Tensor src_mask, Tensor gather_index, Tensor max_buffer, bool pre_layer_norm, int rotary_emb_dims, float epsilon, float dropout_rate, bool is_test, str dropout_implementation, str act_method, bool trans_qkvw, int ring_id, int gather_axis)
|
|
output : Tensor(out), Tensor[](cache_kv_out){out_linear_w.size()}
|
|
infer_meta :
|
|
func : FusedMultiTransformerInt8XpuInferMeta
|
|
kernel :
|
|
func : fused_multi_transformer_int8_xpu
|
|
data_type : x
|
|
optional : cache_kv, pre_caches, rotary_pos_emb, time_step, seq_lengths, src_mask, gather_index
|
|
|
|
- op : fused_multi_transformer_xpu
|
|
args : (Tensor x, Tensor[] ln_scale, Tensor[] ln_bias, Tensor[] qkvw, Tensor[] qkvw_max, Tensor[] qkv_bias, Tensor[] out_linear_w, Tensor[] out_linear_wmax, Tensor[] out_linear_bias, Tensor[] ffn_ln_scale, Tensor[] ffn_ln_bias, Tensor[] ffn1_weight, Tensor[] ffn1_weight_max, Tensor[] ffn1_bias, Tensor[] ffn2_weight, Tensor[] ffn2_weight_max, Tensor[] ffn2_bias, Tensor[] cache_kv, Tensor[] pre_caches, Tensor rotary_pos_emb, Tensor time_step, Tensor seq_lengths, Tensor src_mask, Tensor gather_index, Tensor max_buffer, bool pre_layer_norm, int rotary_emb_dims, float epsilon, float dropout_rate, bool is_test, str dropout_implementation, str act_method, bool trans_qkvw, int ring_id, int gather_axis)
|
|
output : Tensor(out), Tensor[](cache_kv_out){out_linear_w.size()}
|
|
infer_meta :
|
|
func : FusedMultiTransformerXpuInferMeta
|
|
kernel :
|
|
func : fused_multi_transformer_xpu
|
|
data_type : x
|
|
optional : cache_kv, pre_caches, rotary_pos_emb, time_step, seq_lengths, src_mask, gather_index
|
|
|
|
- op : fused_partial_rope
|
|
args: (Tensor x, Tensor cos, Tensor sin)
|
|
output: Tensor(out)
|
|
infer_meta:
|
|
func: FusedPartialRopeInferMeta
|
|
kernel:
|
|
func: fused_partial_rope
|
|
backward: fused_partial_rope_grad
|
|
support_dygraph_mode : true
|
|
|
|
- op : fused_rotary_position_embedding
|
|
args : (Tensor q, Tensor k, Tensor v, Tensor sin, Tensor cos, Tensor position_ids, bool use_neox_rotary_style = true, bool time_major = false, float rotary_emb_base = 10000.0)
|
|
output : Tensor(out_q), Tensor(out_k), Tensor(out_v)
|
|
infer_meta :
|
|
func : FusedRopeInferMeta
|
|
spmd_rule : FusedRopeInferSpmd
|
|
optional : k, v, sin, cos, position_ids, out_k, out_v
|
|
kernel :
|
|
func : fused_rotary_position_embedding
|
|
data_type : q
|
|
backward: fused_rotary_position_embedding_grad
|
|
support_dygraph_mode : true
|
|
|
|
- op : fused_scale_bias_add_relu
|
|
args : (Tensor x1, Tensor scale1, Tensor bias1, Tensor x2, Tensor scale2, Tensor bias2, bool fuse_dual, bool exhaustive_search)
|
|
optional : scale2, bias2
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : FusedScaleBiasAddReluInferMeta
|
|
kernel :
|
|
func : fused_scale_bias_add_relu
|
|
data_type : x1
|
|
|
|
- op : fused_scale_bias_relu_conv_bn
|
|
args : (Tensor x, Tensor w, Tensor scale, Tensor bias, Tensor bn_scale, Tensor bn_bias, Tensor input_running_mean, Tensor input_running_var, int[] paddings, int[] dilations, int[] strides, str padding_algorithm, int groups, str data_format, float momentum, float epsilon, bool fuse_prologue, bool exhaustive_search, int64_t accumulation_count = 0)
|
|
optional : scale, bias
|
|
output : Tensor(out), Tensor(out_running_mean), Tensor(out_running_var), Tensor(saved_mean), Tensor(saved_var), Tensor(eq_scale), Tensor(eq_bias)
|
|
infer_meta :
|
|
func : FusedScaleBiasReluConvBnInferMeta
|
|
kernel :
|
|
func : fused_scale_bias_relu_conv_bn
|
|
data_type : x
|
|
|
|
- op : fused_seqpool_cvm
|
|
args: (Tensor[] x, Tensor cvm, str pooltype = "SUM", float pad_value = 0.0, bool
|
|
use_cvm = true, int cvm_offset = 2)
|
|
output: Tensor[] (out){x.size()}
|
|
infer_meta:
|
|
func: FusedSeqpoolCvmInferMeta
|
|
kernel:
|
|
func: fused_seqpool_cvm
|
|
data_type: x
|
|
backward: fused_seqpool_cvm_grad
|
|
|
|
- op : fused_stack_quant
|
|
args : (Tensor[] x)
|
|
output : Tensor(out), Tensor(scale)
|
|
infer_meta :
|
|
func : FusedStackQuantInferMeta
|
|
kernel :
|
|
func : fused_stack_quant
|
|
data_type : x
|
|
support_dygraph_mode : true
|
|
|
|
- op : fused_stack_transpose_quant
|
|
args : (Tensor[] x)
|
|
output : Tensor(out), Tensor(scale)
|
|
infer_meta :
|
|
func : FusedStackTransposeQuantInferMeta
|
|
kernel :
|
|
func : fused_stack_transpose_quant
|
|
data_type : x
|
|
support_dygraph_mode : true
|
|
|
|
- op : fused_token_prune
|
|
args: (Tensor attn, Tensor x, Tensor mask, Tensor new_mask, bool keep_first_token
|
|
= true, bool keep_order = false)
|
|
output: Tensor (slimmed_x), Tensor (cls_inds)
|
|
infer_meta:
|
|
func: FusedTokenPruneInferMeta
|
|
kernel:
|
|
func: fused_token_prune
|
|
support_dygraph_mode : true
|
|
|
|
- op : fused_transpose_wlch_split_quant
|
|
args: (Tensor x, IntArray tokens_per_expert, bool pow_2_scales=false)
|
|
output: Tensor[](out){tokens_per_expert.size()}, Tensor[](scales){tokens_per_expert.size()}
|
|
infer_meta:
|
|
func: FusedTransposeWLCHSplitQuantInferMeta
|
|
kernel:
|
|
func: fused_transpose_wlch_split_quant
|
|
support_dygraph_mode : true
|
|
|
|
- op : fusion_group
|
|
args: (Tensor[] inputs, int[] outs_dtype = {}, int[] inputs_dtype = {}, str func_name = "", int type
|
|
= 0)
|
|
output: Tensor[] (outs){inputs.size()}
|
|
infer_meta:
|
|
func: FusionGroupInferMeta
|
|
kernel:
|
|
func: fusion_group
|
|
data_type : DataType::FLOAT32
|
|
|
|
- op : fusion_gru
|
|
args : (Tensor x, Tensor h0, Tensor weight_x, Tensor weight_h, Tensor bias, str activation = "tanh", str gate_activation = "sigmoid", bool is_reverse = false, bool use_seq = true, bool origin_mode = false, bool force_fp32_output = false)
|
|
output : Tensor(reordered_h0), Tensor(xx), Tensor(batched_input), Tensor(batched_out), Tensor(hidden)
|
|
infer_meta :
|
|
func : FusionGRUInferMeta
|
|
kernel :
|
|
func : fusion_gru
|
|
data_type : x
|
|
optional : h0, bias
|
|
intermediate : reordered_h0, xx, batched_input, batched_out
|
|
|
|
- op : fusion_lstm
|
|
args : (Tensor x, Tensor weight_x, Tensor weight_h, Tensor bias, Tensor h0, Tensor c0, bool use_peepholes=true, bool is_reverse=false, bool use_seq=true, str gate_activation="sigmoid", str cell_activation="tanh", str candidate_activation="tanh", float scale_data=1.0, float shift_data=0.0, float[] scale_weights={1.0}, bool force_fp32_output=false)
|
|
output : Tensor(hidden), Tensor(cell), Tensor(xx), Tensor(batched_input), Tensor(batched_hidden), Tensor(batched_cell), Tensor(reordered_h0), Tensor(reordered_c0), Tensor(checked_cell)
|
|
infer_meta :
|
|
func : FusionLstmInferMeta
|
|
kernel :
|
|
func : fusion_lstm
|
|
data_type : x
|
|
optional : h0, c0
|
|
intermediate : xx, batched_input, batched_hidden, batched_cell, reordered_h0, reordered_c0, checked_cell
|
|
|
|
- op : fusion_repeated_fc_relu
|
|
args : (Tensor x, Tensor[] w, Tensor[] bias)
|
|
output : Tensor[](relu_out){w.size()-1}, Tensor(out)
|
|
infer_meta :
|
|
func : FusionRepeatedFCReluInferMeta
|
|
kernel :
|
|
func : fusion_repeated_fc_relu
|
|
data_type: x
|
|
intermediate : relu_out
|
|
|
|
- op : fusion_seqconv_eltadd_relu
|
|
args : (Tensor x, Tensor filter, Tensor bias, int context_length, int context_start = 0, int context_stride = 1)
|
|
output : Tensor(out), Tensor(col_mat)
|
|
infer_meta :
|
|
func : FusionSeqConvEltAddReluInferMeta
|
|
kernel :
|
|
func : fusion_seqconv_eltadd_relu
|
|
data_type : x
|
|
intermediate : col_mat
|
|
|
|
- op : fusion_seqpool_concat
|
|
args: (Tensor[] x, str pooltype = "SUM", int axis = 1)
|
|
output: Tensor (out)
|
|
infer_meta:
|
|
func: FusionSeqpoolConcatInferMeta
|
|
kernel:
|
|
func: fusion_seqpool_concat
|
|
data_type: x
|
|
support_dygraph_mode : true
|
|
|
|
- op : fusion_seqpool_cvm_concat
|
|
args: (Tensor[] x, Tensor cvm, str pooltype = "SUM", bool use_cvm = true, int axis = 1)
|
|
output: Tensor (out)
|
|
infer_meta:
|
|
func: FusionSeqpoolCvmConcatInferMeta
|
|
kernel:
|
|
func: fusion_seqpool_cvm_concat
|
|
data_type: x
|
|
support_dygraph_mode : true
|
|
|
|
- op : fusion_squared_mat_sub
|
|
args : (Tensor x, Tensor y, float scalar = 1.0f)
|
|
output : Tensor(squared_x), Tensor(squared_y), Tensor(squared_xy), Tensor(out)
|
|
infer_meta :
|
|
func : FusionSquaredMatSubInferMeta
|
|
kernel :
|
|
func : fusion_squared_mat_sub
|
|
data_type : x
|
|
intermediate : squared_x, squared_y, squared_xy
|
|
|
|
- op : fusion_transpose_flatten_concat
|
|
args : (Tensor[] x, int[] trans_axis, int flatten_axis, int concat_axis)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : FusionTransposeFlattenConcatInferMeta
|
|
kernel :
|
|
func : fusion_transpose_flatten_concat
|
|
data_type : x
|
|
|
|
- op : gemm_epilogue
|
|
args : (Tensor input, Tensor w, Tensor bias, int in_num_col_dims = 1, str activation_type = "", bool padding_weights = false)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : FCInferMeta
|
|
kernel :
|
|
func : gemm_epilogue
|
|
data_type : input
|
|
optional : bias
|
|
support_dygraph_mode : true
|
|
|
|
- op : generate_sequence_xpu
|
|
args : (Tensor x, DataType dtype)
|
|
output : Tensor
|
|
infer_meta :
|
|
func : GenerateSequenceXPUInferMeta
|
|
kernel :
|
|
func : generate_sequence_xpu
|
|
data_type : dtype
|
|
|
|
- op : group_norm_silu_xpu
|
|
args : (Tensor x, Tensor scale, Tensor bias, int groups = -1, double epsilon = 1e-5)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : GroupNormalizeSiluXPUInferMeta
|
|
kernel :
|
|
func : group_norm_silu_xpu
|
|
data_type : x
|
|
|
|
- op : layer_norm_act_xpu
|
|
args : (Tensor x, Tensor scale, Tensor bias, int begin_norm_axis, float epsilon, int act_type, float act_param)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : LayerNormActXPUInferMeta
|
|
kernel :
|
|
func : layer_norm_act_xpu
|
|
data_type : x
|
|
|
|
- op : layer_norm_relu_xpu
|
|
args : (Tensor x, Tensor scale, Tensor bias, int begin_norm_axis, float epsilon = 1e-5)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : LayerNormalizeReluXPUInferMeta
|
|
kernel :
|
|
func : layer_norm_relu_xpu
|
|
data_type : x
|
|
optional : scale, bias
|
|
|
|
- op : mask_adaptive_xpu
|
|
args : (Tensor mask)
|
|
output : Tensor (length), Tensor (seq_lod), Tensor (pad_seq_len)
|
|
infer_meta :
|
|
func : MaskAdaptiveXPUInferMeta
|
|
kernel :
|
|
func : mask_adaptive_xpu
|
|
data_type : mask
|
|
|
|
# This op is implemented using CUDNN Frontend API, which serves as a supplement to
|
|
# legacy max pooling implementation. It shows better performance with NHWC layout and
|
|
# half precision.
|
|
- op : max_pool2d_v2
|
|
args : (Tensor x, int[] kernel_size, int[] strides= {1, 1}, int[] paddings = {0, 0}, str data_format = "NCHW", bool global_pooling = false, bool adaptive = false)
|
|
output : Tensor(out), Tensor(saved_idx)
|
|
infer_meta :
|
|
func : MaxPoolV2InferMeta
|
|
param : [x, kernel_size, strides, paddings, data_format, global_pooling, adaptive]
|
|
kernel :
|
|
func : max_pool2d_v2
|
|
param : [x, kernel_size, strides, paddings, data_format, global_pooling, adaptive]
|
|
intermediate: saved_idx
|
|
backward : max_pool2d_v2_grad
|
|
|
|
- op : multi_encoder_xpu
|
|
args : (Tensor x, Tensor[] fc_input_max, Tensor[] fc_weight, Tensor[] fc_weight_max, Tensor[] fc_bias, Tensor[] ln_scale, Tensor[] ln_bias, Tensor[] smooth_scale_weight, Tensor[] roformer_embedding, Tensor mask, Tensor seq_lod, Tensor max_seq_len, int layer_num, bool norm_before, int hidden_dim, int head_num, int size_per_head, int ffn_hidden_dim_scale, int act_type, int relative_type, int slice_idx, bool is_per_channel, int max_pos_len, float[] softmax_max_value, str[] quant_types)
|
|
output : Tensor(out), Tensor(x_fp16), Tensor(out_fp16)
|
|
infer_meta :
|
|
func : MultiEncoderXPUInferMeta
|
|
kernel :
|
|
func : multi_encoder_xpu
|
|
data_type : x
|
|
optional : mask, seq_lod, max_seq_len, x_fp16, out_fp16
|
|
|
|
- op : multihead_matmul
|
|
args : (Tensor input, Tensor w, Tensor bias, Tensor bias_qk, bool transpose_q = false, bool transpose_k = true, bool transpose_v = false, float alpha = 1.0f, int head_number = 1)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : MultiheadMatmulInferMeta
|
|
kernel :
|
|
func : multihead_matmul
|
|
data_type : input
|
|
optional : bias_qk
|
|
|
|
- op : pad2d_xpu
|
|
args : (Tensor x, int[] paddings, str mode = "constant", float pad_value = 0.0, str data_format = "NCHW")
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : Pad2dXPUInferMeta
|
|
kernel :
|
|
func : pad2d_xpu
|
|
data_type : x
|
|
|
|
- op : qkv_attention_xpu
|
|
args : (Tensor q, Tensor k, Tensor v, Tensor q_max, Tensor k_max, Tensor v_max, Tensor qk_max, Tensor qkv_max, float alpha, int head_num, int head_dim, bool qkv_fc_fusion, DataType out_dtype)
|
|
output : Tensor(qkv)
|
|
infer_meta :
|
|
func : QKVAttentionXPUInferMeta
|
|
kernel :
|
|
func : qkv_attention_xpu
|
|
data_type : q
|
|
optional : q_max, k_max, v_max, qk_max, qkv_max
|
|
|
|
- op : qkv_unpack_mha
|
|
args : (Tensor q, Tensor k, Tensor v, Tensor src_mask)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : UnchangedInferMeta
|
|
param : [q]
|
|
kernel :
|
|
func : qkv_unpack_mha
|
|
data_type : q
|
|
optional : src_mask
|
|
|
|
- op : quantize_xpu
|
|
args : (Tensor x, DataType out_dtype, float scale = 1.0f)
|
|
output : Tensor(y)
|
|
infer_meta :
|
|
func : QuantizeXPUInferMeta
|
|
kernel :
|
|
func : quantize_xpu
|
|
data_type : x
|
|
|
|
- op : resnet_basic_block
|
|
args: (Tensor x, Tensor filter1, Tensor scale1, Tensor bias1, Tensor mean1, Tensor
|
|
var1, Tensor filter2, Tensor scale2, Tensor bias2, Tensor mean2, Tensor var2,
|
|
Tensor filter3, Tensor scale3, Tensor bias3, Tensor mean3, Tensor var3, int stride1
|
|
= 1, int stride2 = 1, int stride3 = 1, int padding1 = 0, int padding2 = 0, int
|
|
padding3 = 0, int dilation1 = 1, int dilation2 = 1, int dilation3 = 1, int group
|
|
= 1, float momentum = 0.9, float epsilon = 1e-5, str data_format = "NCHW", bool
|
|
has_shortcut = false, bool use_global_stats = false, bool is_test = false, bool
|
|
trainable_statistics = false, str act_type = "relu", bool find_conv_input_max
|
|
= true)
|
|
output: Tensor (out), Tensor (conv1), Tensor (saved_mean1), Tensor (saved_invstd1),
|
|
Tensor (mean1_out), Tensor (var1_out), Tensor (conv2), Tensor (conv2_input), Tensor
|
|
(saved_mean2), Tensor (saved_invstd2), Tensor (mean2_out), Tensor (var2_out),
|
|
Tensor (conv3), Tensor (saved_mean3), Tensor (saved_invstd3), Tensor (mean3_out),
|
|
Tensor (var3_out), Tensor (max_input1), Tensor (max_filter1), Tensor (max_input2),
|
|
Tensor (max_filter2), Tensor (max_input3), Tensor (max_filter3)
|
|
infer_meta:
|
|
func: ResnetBasicBlockInferMeta
|
|
kernel:
|
|
func: resnet_basic_block
|
|
data_type: x
|
|
optional: filter3, scale3, bias3, mean3, var3, conv3, saved_mean3, saved_invstd3,
|
|
mean3_out, var3_out, max_input1, max_filter1, max_input2, max_filter2, max_input3,
|
|
max_filter3
|
|
backward: resnet_basic_block_grad
|
|
support_dygraph_mode: true
|
|
|
|
- op : resnet_unit
|
|
args: (Tensor x, Tensor filter_x, Tensor scale_x, Tensor bias_x, Tensor mean_x,
|
|
Tensor var_x, Tensor z, Tensor filter_z, Tensor scale_z, Tensor bias_z, Tensor
|
|
mean_z, Tensor var_z, int stride = 1, int stride_z = 1, int padding = 0, int dilation
|
|
= 1, int group = 1, float momentum = 0.9, float epsilon = 1e-5, str data_format
|
|
= "NHWC", bool fuse_add = false, bool has_shortcut = false, bool use_global_stats
|
|
= false, bool is_test = false, bool use_addto = false, str act_type = "relu")
|
|
output: Tensor (out), Tensor (bit_mask), Tensor (conv_x), Tensor (saved_mean_x),
|
|
Tensor (saved_invstd_x), Tensor (running_mean_x), Tensor (running_var_x), Tensor
|
|
(conv_z), Tensor (saved_mean_z), Tensor (saved_invstd_z), Tensor (running_mean_z),
|
|
Tensor (running_var_z)
|
|
infer_meta:
|
|
func: ResnetUnitInferMeta
|
|
kernel:
|
|
func: resnet_unit
|
|
data_type: x
|
|
optional: z, filter_z, scale_z, bias_z, mean_z, var_z, conv_z, saved_mean_z, saved_invstd_z,
|
|
running_mean_z, running_var_z
|
|
backward: resnet_unit_grad
|
|
support_dygraph_mode : true
|
|
|
|
- op : roformer_relative_embedding_xpu
|
|
args : (Tensor x, Tensor sin_emb, Tensor cos_emb, int max_pos_len)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : RoformerRelativePosXPUInferMeta
|
|
kernel :
|
|
func : roformer_relative_embedding_xpu
|
|
data_type : x
|
|
|
|
- op : self_dp_attention
|
|
args : (Tensor x, float alpha = 1.0f, int head_number = 1)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : SelfDPAttenInferMeta
|
|
kernel :
|
|
func : self_dp_attention
|
|
data_type : x
|
|
|
|
- op : sequence_unpad_xpu
|
|
args : (Tensor x, Tensor length)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : SequenceUnpadXPUInferMeta
|
|
kernel :
|
|
func : sequence_unpad_xpu
|
|
data_type : x
|
|
|
|
- op : sine_pos_xpu
|
|
args : (Tensor x, Tensor y)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : SinePosXPUInferMeta
|
|
kernel :
|
|
func : sine_pos_xpu
|
|
data_type : x
|
|
|
|
- op : skip_layernorm
|
|
args : (Tensor x, Tensor y, Tensor scale, Tensor bias, float epsilon, int begin_norm_axis)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : SkipLayerNormInferMeta
|
|
kernel :
|
|
func : skip_layernorm
|
|
data_type : x
|
|
|
|
- op : spatial_transformer_resblock_xpu
|
|
args : (Tensor x, Tensor[] x_max, Tensor[] conv_bias, Tensor[] conv_filter, Tensor[] conv_filter_max, Tensor[] gn_bias, Tensor[] gn_scale, int[] dilations, int[] paddings, int[] strides, float[] gn_eps, int[] gn_groups, int[] groups, bool conv_fix, bool has_silu_fc_input, bool include_silu)
|
|
output : Tensor(out), Tensor(out_max)
|
|
infer_meta :
|
|
func : SpatialTransformerResblockXPUInferMeta
|
|
kernel :
|
|
func : spatial_transformer_resblock_xpu
|
|
data_type : x
|
|
|
|
- op : squeeze_excitation_block
|
|
args : (Tensor x, Tensor filter, Tensor filter_max, Tensor bias, Tensor branch, int[] act_type, float[] act_param, int[] filter_dims)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : SqueezeExcitationInferMeta
|
|
kernel :
|
|
func : squeeze_excitation_block
|
|
data_type : x
|
|
optional : bias, branch
|
|
|
|
- op : variable_length_memory_efficient_attention
|
|
args : (Tensor query, Tensor key, Tensor value, Tensor seq_lens, Tensor kv_seq_lens, Tensor mask, float scale, bool causal, int pre_cache_length)
|
|
output : Tensor
|
|
infer_meta :
|
|
func : VariableLengthMemoryEfficientAttentionInferMeta
|
|
kernel :
|
|
func : variable_length_memory_efficient_attention
|
|
data_type : query
|
|
optional : mask
|
|
support_dygraph_mode : true
|
|
|
|
- op : yolo_box_xpu
|
|
args : (Tensor x, Tensor x_max, Tensor grid, Tensor stride, Tensor anchor_grid, float offset)
|
|
output : Tensor(out), Tensor(out_max)
|
|
infer_meta :
|
|
func : YoloBoxXPUInferMeta
|
|
kernel :
|
|
func : yolo_box_xpu
|
|
data_type : x
|
|
optional : x_max
|
|
|
|
- op: add_group_norm_silu
|
|
args : (Tensor x,Tensor residual, Tensor scale, Tensor bias, double epsilon = 1e-5, int groups = -1, str data_format = "NCHW", str activation = "")
|
|
output : Tensor(y), Tensor(residual_out), Tensor(mean), Tensor(variance)
|
|
infer_meta :
|
|
func : AddGroupNormSiluInferMeta
|
|
kernel :
|
|
func : add_group_norm_silu
|
|
data_type : x
|
|
optional : scale, bias, residual, residual_out
|
|
support_dygraph_mode : true
|
|
interfaces : paddle::dialect::LayoutTransformationInterface
|
|
|
|
- op: fused_act_dequant
|
|
args: (Tensor x, Tensor x_scale)
|
|
output: Tensor(out)
|
|
infer_meta:
|
|
func: FusedActDequantInferMeta
|
|
kernel:
|
|
func: fused_act_dequant
|
|
data_type: x
|
|
support_dygraph_mode: true
|
|
|
|
- op: fused_embedding_fc_lstm
|
|
args: (Tensor ids, Tensor embeddings, Tensor weight_h, Tensor bias, Tensor h0, Tensor
|
|
c0, bool use_peepholes = true, bool is_reverse = false, bool use_seq = true, str
|
|
gate_activation = "sigmoid", str cell_activation = "tanh", str candidate_activation
|
|
= "tanh")
|
|
output: Tensor (hidden), Tensor (cell), Tensor (xx), Tensor (batched_input), Tensor
|
|
(batched_hidden), Tensor (batched_cell), Tensor (reordered_h0), Tensor (reordered_c0)
|
|
infer_meta:
|
|
func: FusedEmbeddingFcLstmInferMeta
|
|
kernel:
|
|
func: fused_embedding_fc_lstm
|
|
data_type: embeddings
|
|
optional: h0, c0
|
|
intermediate: xx, batched_input, batched_hidden, batched_cell, reordered_h0, reordered_c0
|
|
|
|
- op: fused_swiglu_weighted_bwd
|
|
args: (Tensor o1, Tensor do2_s, Tensor unzipped_probs)
|
|
output: Tensor(do1), Tensor(probs_grad), Tensor(o2_s)
|
|
infer_meta:
|
|
func: FusedSwigluWeightedBwdInferMeta
|
|
kernel:
|
|
func: fused_swiglu_weighted_bwd
|
|
data_type: o1
|
|
support_dygraph_mode : true
|
|
|
|
- op: fused_transpose_split_quant
|
|
args: (Tensor x, Tensor input_scales, IntArray tokens_per_expert, bool pow_2_scales=false)
|
|
output: Tensor[](out){tokens_per_expert.size()}, Tensor[](scales){tokens_per_expert.size()}
|
|
infer_meta:
|
|
func: FusedTransposeSplitQuantInferMeta
|
|
kernel:
|
|
func: fused_transpose_split_quant
|
|
optional: input_scales
|
|
support_dygraph_mode : true
|
|
|
|
- op: fused_weighted_swiglu_act_quant
|
|
args: (Tensor x, Tensor prob, bool using_pow2_scaling)
|
|
output: Tensor(out), Tensor(scale)
|
|
infer_meta:
|
|
func: FusedWeightedSwigluActQuantInferMeta
|
|
kernel:
|
|
func: fused_weighted_swiglu_act_quant
|
|
optional: prob
|
|
support_dygraph_mode : true
|