wehub-resource-sync
1220 lines
38 KiB
YAML
Executable File
1220 lines
38 KiB
YAML
Executable File
- op : all
|
|
args : (Tensor x, IntArray axis={0}, bool keepdim=false, bool reduce_all=false, int in_dtype=-1, int out_dtype=-1)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : ReduceInferMetaBase
|
|
kernel :
|
|
func : all
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : amax
|
|
args : (Tensor x, IntArray axis={0}, bool keepdim=false, bool reduce_all=false, int in_dtype=-1, int out_dtype=-1)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : ReduceInferMeta
|
|
param : [x, axis, keepdim]
|
|
kernel :
|
|
func : amax_raw
|
|
param : [x, axis, keepdim, reduce_all]
|
|
backward : amax_grad
|
|
|
|
- op : amin
|
|
args : (Tensor x, IntArray axis={0}, bool keepdim=false, bool reduce_all=false, int in_dtype=-1, int out_dtype=-1)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : ReduceInferMeta
|
|
param : [x, axis, keepdim]
|
|
kernel :
|
|
func : amin_raw
|
|
param : [x, axis, keepdim, reduce_all]
|
|
backward : amin_grad
|
|
|
|
- op : any
|
|
args : (Tensor x, IntArray axis={0}, bool keepdim=false, bool reduce_all=false, int in_dtype=-1, int out_dtype=-1)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : ReduceInferMetaBase
|
|
param : [x, axis, keepdim, reduce_all]
|
|
kernel :
|
|
func : any_raw
|
|
param : [x, axis, keepdim, reduce_all]
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : arange
|
|
args : (Tensor start, Tensor end, Tensor step)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : ArangeTensorInferMetaLegacy
|
|
kernel :
|
|
func : arange_tensor
|
|
data_transform :
|
|
skip_transform : start, end, step
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : assign
|
|
args : (Tensor x)
|
|
output : Tensor
|
|
infer_meta :
|
|
func : UnchangedInferMeta
|
|
kernel :
|
|
func : assign
|
|
optional : x
|
|
inplace : (x -> out)
|
|
backward : assign_grad
|
|
|
|
- op : assign_value
|
|
args : (int[] shape, DataType dtype, Scalar[] values = {})
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : AssignValueInferMeta
|
|
param : [shape, dtype]
|
|
kernel :
|
|
func : assign_value
|
|
param : [shape, dtype, values]
|
|
data_type : dtype
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- 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
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : bicubic_interp
|
|
args : (Tensor x, Tensor out_size, Tensor[] size_tensor, Tensor scale_tensor, str data_format="NCHW", int out_d=0, int out_h=0, int out_w=0, float[] scale={}, str interp_method="bilinear", bool align_corners=true, int align_mode=1)
|
|
output : Tensor(output)
|
|
infer_meta :
|
|
func : InterpolateInferMeta
|
|
optional: out_size, size_tensor, scale_tensor
|
|
kernel :
|
|
func : bicubic_interp
|
|
data_type : x
|
|
backward : bicubic_interp_grad
|
|
data_transform :
|
|
skip_transform : out_size, size_tensor, scale_tensor
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface
|
|
|
|
- op : bilinear_interp
|
|
args : (Tensor x, Tensor out_size, Tensor[] size_tensor, Tensor scale_tensor, str data_format="NCHW", int out_d=0, int out_h=0, int out_w=0, float[] scale={}, str interp_method="bilinear", bool align_corners=true, int align_mode=1)
|
|
output : Tensor(output)
|
|
infer_meta :
|
|
func : InterpolateInferMeta
|
|
optional: out_size, size_tensor, scale_tensor
|
|
kernel :
|
|
func : bilinear_interp
|
|
data_type : x
|
|
backward : bilinear_interp_grad
|
|
data_transform :
|
|
skip_transform : out_size, size_tensor, scale_tensor
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
|
|
|
|
- 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
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : conv2d_transpose
|
|
args : (Tensor x, Tensor filter, Tensor bias, int[] strides={1, 1}, int[] paddings={0, 0}, int[] output_padding={}, IntArray output_size={}, str padding_algorithm="EXPLICIT", int groups=1, int[] dilations={1, 1}, str data_format="NCHW")
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : Conv2dTransposeInferMeta
|
|
param : [x, filter, strides, paddings, output_padding, output_size, padding_algorithm, groups, dilations, data_format]
|
|
kernel :
|
|
func : conv2d_transpose
|
|
param : [x, filter, strides, paddings, output_padding, output_size, padding_algorithm, groups, dilations, data_format]
|
|
data_type : x
|
|
optional : bias
|
|
backward : conv2d_transpose_grad
|
|
|
|
- op : conv2d_transpose_bias
|
|
args : (Tensor x, Tensor filter, Tensor bias, int[] strides={1, 1}, int[] paddings={0, 0}, int[] output_padding={}, IntArray output_size={}, str padding_algorithm="EXPLICIT", int groups=1, int[] dilations={1, 1}, str data_format="NCHW")
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : Conv2dTransposeInferMeta
|
|
param : [x, filter, strides, paddings, output_padding, output_size, padding_algorithm, groups, dilations, data_format]
|
|
kernel :
|
|
func : conv2d_transpose_bias
|
|
param : [x, filter, bias, strides, paddings, output_padding, output_size, padding_algorithm, groups, dilations, data_format]
|
|
data_type : x
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : cross_entropy
|
|
args: (Tensor x, Tensor label, bool soft_label = false, int ignore_index = -100)
|
|
output: Tensor (out)
|
|
infer_meta:
|
|
func: CrossEntropyInferMeta
|
|
kernel:
|
|
func: cross_entropy
|
|
data_type: x
|
|
backward: cross_entropy_grad
|
|
|
|
- op : cross_entropy2
|
|
args: (Tensor x, Tensor label, int ignore_index = -100)
|
|
output: Tensor (out), Tensor (x_shape), Tensor (match_x)
|
|
infer_meta:
|
|
func: CrossEntropy2InferMeta
|
|
kernel:
|
|
func: cross_entropy2
|
|
data_type: x
|
|
backward: cross_entropy_grad2
|
|
|
|
- op : decode_jpeg
|
|
args : (Tensor x, str mode = "unchanged")
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : DecodeJpegInferMeta
|
|
param : [x, mode]
|
|
kernel :
|
|
func : decode_jpeg
|
|
param : [x, mode]
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : deformable_conv
|
|
args : (Tensor x, Tensor offset, Tensor filter, Tensor mask, int[] strides={1, 1}, int[] paddings={0, 0}, int[] dilations={1, 1}, int deformable_groups=1, int groups=1, int im2col_step=64)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : DeformableConvInferMeta
|
|
kernel :
|
|
func : deformable_conv
|
|
data_type : x
|
|
backward : deformable_conv_grad
|
|
|
|
- op : depthwise_conv2d_transpose
|
|
args : (Tensor x, Tensor filter, Tensor bias, int[] strides={1, 1}, int[] paddings={0, 0}, int[] output_padding={}, IntArray output_size={}, str padding_algorithm="EXPLICIT", int groups=1, int[] dilations={1, 1}, str data_format="NCHW")
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : Conv2dTransposeInferMeta
|
|
param : [x, filter, strides, paddings, output_padding, output_size, padding_algorithm, groups, dilations, data_format]
|
|
kernel :
|
|
func : depthwise_conv2d_transpose
|
|
param : [x, filter, strides, paddings, output_padding, output_size, padding_algorithm, groups, dilations, data_format]
|
|
data_type : x
|
|
optional : bias
|
|
backward : depthwise_conv2d_transpose_grad
|
|
|
|
- op : dist_concat
|
|
args : (Tensor x, int ring_id = 0, int nranks = 1)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : DistConcatInferMeta
|
|
param: [x, nranks]
|
|
kernel :
|
|
func : dist_concat
|
|
param: [x, nranks]
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- 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
|
|
backward : einsum_grad
|
|
intermediate : inner_cache, xshape
|
|
|
|
- op : elementwise_pow
|
|
args : (Tensor x, Tensor y, int axis = -1)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : ElementwiseRawInferMeta
|
|
kernel :
|
|
func : elementwise_pow
|
|
backward : elementwise_pow_grad
|
|
|
|
- op : embedding
|
|
args : (Tensor x, Tensor weight, int64_t padding_idx=-1)
|
|
output : Tensor
|
|
infer_meta :
|
|
func : EmbeddingInferMeta
|
|
param : [x, weight, padding_idx]
|
|
kernel :
|
|
func : embedding {dense, dense -> dense}
|
|
sparse_weight_embedding {dense, selected_rows -> dense}
|
|
param : [x, weight, padding_idx]
|
|
data_type : weight
|
|
backward : embedding_grad
|
|
|
|
- op : empty
|
|
args : (IntArray shape = {}, DataType dtype = DataType::FLOAT32)
|
|
output: Tensor(out)
|
|
infer_meta :
|
|
func : CreateInferMeta
|
|
param : [shape, dtype]
|
|
kernel :
|
|
func : empty
|
|
param : [shape, dtype]
|
|
data_type : dtype
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : equal
|
|
args : (Tensor x, Tensor y, int axis = -1, bool force_cpu=false)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : CompareRawInferMeta
|
|
param : [x, y, axis]
|
|
kernel :
|
|
func : equal_raw
|
|
param : [x, y, axis]
|
|
backend : x
|
|
force_backend : force_cpu
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : expand_as
|
|
args : (Tensor x, Tensor y, int[] target_shape = {})
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : ExpandAsInferMeta
|
|
local_shape: out
|
|
kernel :
|
|
func : expand_as
|
|
data_type : x
|
|
optional : y
|
|
backward : expand_as_grad
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface
|
|
|
|
- op : exponential_
|
|
args : (Tensor x, float lam = 1.0f)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : UnchangedInferMeta
|
|
param : [x]
|
|
kernel :
|
|
func : exponential
|
|
inplace : (x -> out)
|
|
backward : exponential__grad
|
|
|
|
- op : eye
|
|
args : (Scalar(int64_t) num_rows, Scalar(int64_t) num_columns = -1, DataType dtype = DataType::FLOAT32)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : EyeInferMeta
|
|
param : [num_rows, num_columns, dtype]
|
|
kernel :
|
|
func : eye
|
|
param : [num_rows, num_columns, dtype]
|
|
data_type : dtype
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : fetch_barrier
|
|
args: (Tensor[] x, int trainer_id = 0, str[] endpoints = {"127.0.0.1:6164"})
|
|
output: Tensor[] (out){x.size()}
|
|
infer_meta:
|
|
func: FetchBarrierInferMeta
|
|
kernel:
|
|
func: fetch_barrier
|
|
optional: x
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : flatten
|
|
args : (Tensor x, int start_axis, int stop_axis)
|
|
output : Tensor(out), Tensor(xshape)
|
|
infer_meta :
|
|
func : FlattenWithXShapeInferMeta
|
|
kernel :
|
|
func : flatten_with_xshape
|
|
backend : x
|
|
inplace : (x -> out)
|
|
view : (x -> out)
|
|
backward : flatten_grad
|
|
|
|
- op : flatten2
|
|
args: (Tensor x, int axis = 1)
|
|
output: Tensor (out), Tensor (x_shape)
|
|
infer_meta:
|
|
func: Flatten2InferMeta
|
|
kernel:
|
|
func: flatten2
|
|
data_type: x
|
|
intermediate: x_shape
|
|
backward: flatten2_grad
|
|
inplace: (x -> out)
|
|
|
|
- op : floor_divide
|
|
args : (Tensor x, Tensor y, int axis = -1)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : ElementwiseRawInferMeta
|
|
kernel :
|
|
func : floor_divide
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : frobenius_norm
|
|
args : (Tensor x, IntArray axis={0}, bool keepdim=false, bool reduce_all=false, int in_dtype=-1, int out_dtype=-1)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : ReduceIntArrayAxisInferMetaBase
|
|
kernel :
|
|
func : frobenius_norm
|
|
param : [x, axis, keepdim, reduce_all]
|
|
backward : frobenius_norm_grad
|
|
|
|
- op : full_like
|
|
args : (Tensor x, Scalar value = 0.0, DataType dtype = DataType::UNDEFINED)
|
|
output: Tensor(out)
|
|
infer_meta :
|
|
func : FillAnyLikeInferMeta
|
|
kernel :
|
|
func : full_like
|
|
param : [x, value, dtype]
|
|
data_type : dtype > x
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : fused_softplus
|
|
args : (Tensor x, float beta=1.0, float threshold=20.0, str fuse_activation="", float fuse_alpha=0.0, float fuse_beta=0.0)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : UnchangedExceptDtypeInferMeta
|
|
param : [x]
|
|
kernel :
|
|
func : fused_softplus
|
|
|
|
- op : gaussian
|
|
args : (IntArray shape = {}, float mean = .0f, float std = 1.0f, int seed = 0, DataType dtype = DataType::FLOAT32)
|
|
output: Tensor(out)
|
|
infer_meta :
|
|
func : GaussianInferMeta
|
|
param : [shape, mean, std, seed, dtype]
|
|
kernel :
|
|
func : gaussian
|
|
param : [shape, mean, std, seed, dtype]
|
|
data_type : dtype
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : greater_equal
|
|
args : (Tensor x, Tensor y, int axis = -1, bool force_cpu=false)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : CompareRawInferMeta
|
|
param : [x, y, axis]
|
|
kernel :
|
|
func : greater_equal_raw
|
|
param : [x, y, axis]
|
|
backend : x
|
|
force_backend : force_cpu
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : greater_than
|
|
args : (Tensor x, Tensor y, int axis = -1, bool force_cpu=false)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : CompareRawInferMeta
|
|
param : [x, y, axis]
|
|
kernel :
|
|
func : greater_than_raw
|
|
param : [x, y, axis]
|
|
backend : x
|
|
force_backend : force_cpu
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : group_norm
|
|
args : (Tensor x, Tensor scale, Tensor bias, float epsilon = 1e-5, int groups = -1, str data_format = "NCHW")
|
|
output : Tensor(y), Tensor(mean), Tensor(variance)
|
|
infer_meta :
|
|
func : GroupNormInferMeta
|
|
spmd_rule : GroupNormInferSpmd
|
|
kernel :
|
|
func : group_norm
|
|
optional : scale, bias
|
|
intermediate : mean, variance
|
|
backward : group_norm_grad
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
|
|
|
|
- op : hardswish
|
|
args : (Tensor x, float threshold = 6.0f, float scale = 6.0f, float offset = 3.0f)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : UnchangedInferMeta
|
|
param : [x]
|
|
kernel :
|
|
func : hardswish
|
|
param : [x]
|
|
inplace : (x -> out)
|
|
backward : hardswish_grad
|
|
|
|
- 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
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : kthvalue
|
|
args : (Tensor x, int k = 1, int axis = -1, bool keepdim = false)
|
|
output : Tensor(out), Tensor(indices)
|
|
infer_meta :
|
|
func : KthvalueInferMeta
|
|
kernel :
|
|
func : kthvalue
|
|
backward : kthvalue_grad
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
|
|
|
|
- op : layer_norm
|
|
args : (Tensor x, Tensor scale, Tensor bias, float epsilon = 1e-5, int begin_norm_axis = 1)
|
|
output : Tensor(out), Tensor(mean), Tensor(variance)
|
|
infer_meta :
|
|
func : LayerNormInferMeta
|
|
spmd_rule : LayerNormInferSpmd
|
|
kernel :
|
|
func : layer_norm
|
|
data_type : x
|
|
backward : layer_norm_grad
|
|
intermediate : mean, variance
|
|
optional : scale, bias
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
|
|
|
|
- op : leaky_relu
|
|
args : (Tensor x, float negative_slope = 0.02)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : UnchangedInferMeta
|
|
param : [x]
|
|
kernel :
|
|
func : leaky_relu
|
|
inplace: (x -> out)
|
|
backward : leaky_relu_grad
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
|
|
traits: pir::UnaryElementWiseTrait
|
|
|
|
- op : legacy_bilinear_interp
|
|
args : (Tensor x, Tensor out_size, Tensor[] size_tensor, Tensor scale_tensor, str data_format="NCHW", int out_d=0, int out_h=0, int out_w=0, float scale=0.0, str interp_method="bilinear", bool align_corners=true, int align_mode=1)
|
|
output : Tensor(output)
|
|
infer_meta :
|
|
func : LegacyInterpolateInferMeta
|
|
optional: out_size, size_tensor, scale_tensor
|
|
kernel :
|
|
func : legacy_bilinear_interp
|
|
data_type : x
|
|
backward : legacy_bilinear_interp_grad
|
|
data_transform :
|
|
skip_transform : out_size, size_tensor, scale_tensor
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface
|
|
|
|
- op : legacy_crop
|
|
args: (Tensor x, Tensor y, IntArray offsets = {}, int[] shape = {})
|
|
output: Tensor (out)
|
|
infer_meta:
|
|
func: LegacyCropInferMeta
|
|
kernel:
|
|
func: legacy_crop
|
|
data_type: x
|
|
optional: y
|
|
backward: legacy_crop_grad
|
|
|
|
- op : legacy_expand
|
|
args : (Tensor x, IntArray shape = {})
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : ExpandInferMeta
|
|
kernel :
|
|
func : legacy_expand
|
|
data_type : x
|
|
backward : legacy_expand_grad
|
|
|
|
- op : legacy_generate_proposals
|
|
args: (Tensor scores, Tensor bbox_deltas, Tensor im_info, Tensor anchors, Tensor
|
|
variances, int pre_nms_top_n, int post_nms_top_n, float nms_thresh, float min_size,
|
|
float eta)
|
|
output: Tensor (rpn_rois), Tensor (rpn_roi_probs), Tensor (rpn_rois_num)
|
|
infer_meta:
|
|
func: LegacyGenerateProposalsInferMeta
|
|
kernel:
|
|
func: legacy_generate_proposals
|
|
data_type: anchors
|
|
optional: rpn_rois_num
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : legacy_nearest_interp
|
|
args : (Tensor x, Tensor out_size, Tensor[] size_tensor, Tensor scale_tensor, str data_format="NCHW", int out_d=0, int out_h=0, int out_w=0, float scale=0.0, str interp_method="bilinear", bool align_corners=true, int align_mode=1)
|
|
output : Tensor(output)
|
|
infer_meta :
|
|
func : LegacyInterpolateInferMeta
|
|
optional: out_size, size_tensor, scale_tensor
|
|
kernel :
|
|
func : legacy_nearest_interp
|
|
data_type : x
|
|
backward : legacy_nearest_interp_grad
|
|
data_transform :
|
|
skip_transform : out_size, size_tensor, scale_tensor
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface
|
|
|
|
- op : less_equal
|
|
args : (Tensor x, Tensor y, int axis = -1, bool force_cpu=false)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : CompareRawInferMeta
|
|
param : [x, y, axis]
|
|
kernel :
|
|
func : less_equal_raw
|
|
param : [x, y, axis]
|
|
backend : x
|
|
force_backend : force_cpu
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : less_than
|
|
args : (Tensor x, Tensor y, int axis = -1, bool force_cpu=false)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : CompareRawInferMeta
|
|
param : [x, y, axis]
|
|
kernel :
|
|
func : less_than_raw
|
|
param : [x, y, axis]
|
|
backend : x
|
|
force_backend : force_cpu
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : linear_interp
|
|
args : (Tensor x, Tensor out_size, Tensor[] size_tensor, Tensor scale_tensor, str data_format="NCHW", int out_d=0, int out_h=0, int out_w=0, float[] scale={}, str interp_method="bilinear", bool align_corners=true, int align_mode=1)
|
|
output : Tensor(output)
|
|
infer_meta :
|
|
func : InterpolateInferMeta
|
|
optional: out_size, size_tensor, scale_tensor
|
|
kernel :
|
|
func : linear_interp
|
|
data_type : x
|
|
backward : linear_interp_grad
|
|
data_transform :
|
|
skip_transform : out_size, size_tensor, scale_tensor
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface
|
|
|
|
- op : linspace
|
|
args : (Tensor start, Tensor stop, Tensor number, DataType dtype)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : LinspaceInferMeta
|
|
param: [start, stop, number, dtype]
|
|
kernel :
|
|
func : linspace
|
|
param: [start, stop, number, dtype]
|
|
data_type : dtype
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : logit
|
|
args : (Tensor x, float eps = 1e-6f)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : UnchangedInferMeta
|
|
param : [x]
|
|
spmd_rule : LogitInfoSpmd
|
|
kernel :
|
|
func : logit
|
|
inplace: (x -> out)
|
|
backward : logit_grad
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
|
|
traits: pir::UnaryElementWiseTrait
|
|
|
|
- op : lp_pool2d
|
|
args : (Tensor x, IntArray kernel_size, int[] strides = {1,1}, int[] paddings = {0,0}, bool ceil_mode = false, bool exclusive = true, str data_format = "NCHW", str pooling_type = "", bool global_pooling = false, bool adaptive = false, str padding_algorithm = "EXPLICIT", float norm_type = 0.0f)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : Pool2DInferMeta
|
|
param : [x, kernel_size, strides, paddings, ceil_mode, exclusive, data_format, pooling_type, global_pooling, adaptive, padding_algorithm]
|
|
kernel :
|
|
func : lp_pool2d
|
|
param : [x, kernel_size, strides, paddings, ceil_mode, exclusive, data_format, pooling_type, global_pooling, adaptive, padding_algorithm, norm_type]
|
|
backward : lp_pool2d_grad
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface
|
|
|
|
- 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
|
|
|
|
- op : matmul
|
|
args : (Tensor x, Tensor y, bool transpose_x = false, bool transpose_y = false)
|
|
output : Tensor
|
|
infer_meta :
|
|
func : MatmulInferMeta
|
|
kernel :
|
|
func : matmul
|
|
backward : matmul_grad
|
|
|
|
- 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
|
|
|
|
- op : matrix_rank
|
|
args : (Tensor x, Tensor tol_tensor, float tol=0.0f, bool hermitian=false, bool use_default_tol=true)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : MatrixRankStaticInferMeta
|
|
param : [x, tol_tensor, use_default_tol, hermitian]
|
|
optional : tol_tensor
|
|
kernel :
|
|
func : matrix_rank {dense -> dense},
|
|
matrix_rank_tol {dense, dense -> dense}
|
|
data_type : x
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : max
|
|
args : (Tensor x, IntArray axis={0}, bool keepdim=false, bool reduce_all=false, int in_dtype=-1, int out_dtype=-1)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : StrictReduceIntArrayAxisInferMetaBase
|
|
param : [x, axis, keepdim, reduce_all]
|
|
kernel :
|
|
func : max_raw
|
|
param : [x, axis, keepdim, reduce_all]
|
|
backward : max_grad
|
|
|
|
- op : maximum
|
|
args : (Tensor x, Tensor y, int axis = -1)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : ElementwiseRawInferMeta
|
|
kernel :
|
|
func : maximum
|
|
backward : maximum_grad
|
|
|
|
- op : min
|
|
args : (Tensor x, IntArray axis={0}, bool keepdim=false, bool reduce_all=false, int in_dtype=-1, int out_dtype=-1)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : StrictReduceIntArrayAxisInferMetaBase
|
|
param : [x, axis, keepdim, reduce_all]
|
|
kernel :
|
|
func : min_raw
|
|
param : [x, axis, keepdim, reduce_all]
|
|
backward : min_grad
|
|
|
|
- op : minimum
|
|
args : (Tensor x, Tensor y, int axis = -1)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : ElementwiseRawInferMeta
|
|
kernel :
|
|
func : minimum
|
|
backward : minimum_grad
|
|
|
|
- op : nearest_interp
|
|
args : (Tensor x, Tensor out_size, Tensor[] size_tensor, Tensor scale_tensor, str data_format="NCHW", int out_d=0, int out_h=0, int out_w=0, float[] scale={}, str interp_method="bilinear", bool align_corners=true, int align_mode=1)
|
|
output : Tensor(output)
|
|
infer_meta :
|
|
func : InterpolateInferMeta
|
|
optional: out_size, size_tensor, scale_tensor
|
|
kernel :
|
|
func : nearest_interp
|
|
data_type : x
|
|
backward : nearest_interp_grad
|
|
data_transform :
|
|
skip_transform : out_size, size_tensor, scale_tensor
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
|
|
|
|
- op : norm
|
|
args : (Tensor x, int axis, float epsilon=1.0e-10f, bool is_test=false)
|
|
output : Tensor(out), Tensor(norm)
|
|
infer_meta :
|
|
func : NormInferMeta
|
|
kernel :
|
|
func : norm
|
|
backward : norm_grad
|
|
intermediate : norm
|
|
|
|
- op : not_equal
|
|
args : (Tensor x, Tensor y, int axis = -1, bool force_cpu=false)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : CompareRawInferMeta
|
|
param : [x, y, axis]
|
|
kernel :
|
|
func : not_equal_raw
|
|
param : [x, y, axis]
|
|
backend : x
|
|
force_backend : force_cpu
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : one_hot
|
|
args : (Tensor x, Scalar(int) depth = -1, DataType dtype = DataType::FLOAT32, bool allow_out_of_range = false)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : OneHotRawInferMeta
|
|
kernel :
|
|
func : one_hot_raw
|
|
data_type : x
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : p_norm
|
|
args : (Tensor x, double porder=2, int axis=-1, float epsilon=1.0e-12f, bool keepdim=false, bool asvector=false)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : PNormInferMeta
|
|
spmd_rule: PNormInferSpmd
|
|
kernel :
|
|
func : p_norm
|
|
backward : p_norm_grad
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
|
|
|
|
- op : p_recv
|
|
args : (int ring_id = 0, int peer = 0, DataType dtype = DataType::FLOAT32, int[] out_shape = {}, bool dynamic_shape = false)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : PRecvInferMeta
|
|
param : [peer, dtype, out_shape, dynamic_shape]
|
|
kernel :
|
|
func : p_recv
|
|
param : [peer, dtype, out_shape, dynamic_shape]
|
|
data_type : dtype
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : p_recv_array
|
|
args : (int ring_id = 0, int peer = 0, DataType dtype = DataType::FLOAT32, int[] out_shape = {})
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : PRecvArrayInferMeta
|
|
param : [peer, dtype, out_shape]
|
|
kernel :
|
|
func : p_recv_array
|
|
param : [peer, dtype, out_shape]
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : p_send
|
|
args : (Tensor x, int ring_id = 0, int peer = 0, bool dynamic_shape = false)
|
|
output :
|
|
infer_meta :
|
|
func : PSendInferMeta
|
|
param : [x, peer]
|
|
kernel :
|
|
func : p_send
|
|
param : [x, peer, dynamic_shape]
|
|
data_type : x
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : p_send_array
|
|
args : (Tensor x, int ring_id = 0, int peer = 0, bool dynamic_shape = false)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : PSendArrayInferMeta
|
|
param : [x, peer]
|
|
kernel :
|
|
func : p_send_array
|
|
param : [x, peer, dynamic_shape]
|
|
data_type : x
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : pad3d
|
|
args : (Tensor x, IntArray paddings, str mode = "constant", float pad_value = 0.0, str data_format = "NCDHW")
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : Pad3dInferMeta
|
|
kernel :
|
|
func : pad3d
|
|
backward : pad3d_grad
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface
|
|
|
|
- op : pool2d
|
|
args : (Tensor x, IntArray kernel_size, int[] strides = {1,1}, int[] paddings = {0,0}, bool ceil_mode = false, bool exclusive = true, str data_format = "NCHW", str pooling_type = "", bool global_pooling = false, bool adaptive = false, str padding_algorithm = "EXPLICIT", bool use_cudnn = false)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : Pool2DInferMeta
|
|
param : [x, kernel_size, strides, paddings, ceil_mode, exclusive, data_format, pooling_type, global_pooling, adaptive, padding_algorithm]
|
|
kernel :
|
|
func : pool2d
|
|
param : [x, kernel_size, strides, paddings, ceil_mode, exclusive, data_format, pooling_type, global_pooling, adaptive, padding_algorithm]
|
|
backward : pool2d_grad
|
|
|
|
- op : pool3d
|
|
args : (Tensor x, int[] kernel_size, int[] strides = {1,1,1}, int[] paddings = {0,0,0}, bool ceil_mode = false, bool exclusive = true, str data_format = "NCDHW", str pooling_type = "", bool global_pooling = false, bool adaptive = false, str padding_algorithm = "EXPLICIT", bool use_cudnn = false)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : PoolInferMeta
|
|
param : [x, kernel_size, strides, paddings, ceil_mode, exclusive, data_format, pooling_type, global_pooling, adaptive, padding_algorithm]
|
|
kernel :
|
|
func : pool3d
|
|
param : [x, kernel_size, strides, paddings, ceil_mode, exclusive, data_format, pooling_type, global_pooling, adaptive, padding_algorithm]
|
|
backward : pool3d_grad
|
|
|
|
- op : prod
|
|
args : (Tensor x, IntArray axis={0}, bool keepdim=false, bool reduce_all=false, int in_dtype=-1, DataType out_dtype=DataType::UNDEFINED)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : ReduceIntArrayAxisInferMetaBase
|
|
param : [x, axis, keepdim, reduce_all, out_dtype]
|
|
kernel :
|
|
func : prod
|
|
param : [x, axis, keepdim, reduce_all, out_dtype]
|
|
data_type : x
|
|
backward : prod_grad
|
|
|
|
- op : quant_linear
|
|
args: (Tensor x, Tensor w, Tensor bias, int in_num_col_dims = 1, str activation_type = "", bool padding_weights = false, float scale_in = 1.0f, float[] scale_weights = {1.0f}, int quant_round_type = 1, float quant_max_bound = 127.0f, float quant_min_bound = -127.0f)
|
|
output: Tensor(out)
|
|
optional: bias
|
|
infer_meta:
|
|
func: QuantLinearInferMeta
|
|
kernel:
|
|
func: quant_linear
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : randint
|
|
args : (int low, int high, IntArray shape = {}, DataType dtype = DataType::INT64, int seed = 0)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : RandintInferMeta
|
|
param : [low, high, shape, dtype]
|
|
kernel :
|
|
func : randint
|
|
param : [low, high, shape, dtype]
|
|
data_type : dtype
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : randperm
|
|
args : (int n, DataType dtype = DataType::INT64)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : RandpermInferMeta
|
|
param : [n, dtype]
|
|
kernel :
|
|
func : randperm
|
|
param : [n, dtype]
|
|
data_type : dtype
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : range_v2
|
|
args : (Tensor start, Tensor end, Tensor step)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : RangeTensorInferMetaLegacy
|
|
kernel :
|
|
func : range_tensor
|
|
data_transform :
|
|
skip_transform : start, end, step
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : remainder
|
|
args : (Tensor x, Tensor y, int axis = -1)
|
|
output : Tensor (out)
|
|
infer_meta :
|
|
func : ElementwiseRawInferMeta
|
|
param: [x, y]
|
|
kernel :
|
|
func : remainder
|
|
inplace : (x -> out)
|
|
backward: remainder_grad
|
|
|
|
- op : rnn
|
|
args: (Tensor x, Tensor[] pre_state, Tensor[] weight_list, Tensor sequence_length, float dropout_prob=0.0, bool is_bidirec=false, int input_size=10, int hidden_size=100, int num_layers=1, str mode="RNN_TANH", int seed=0, bool is_test=false)
|
|
output: Tensor(out), Tensor(dropout_state_out), Tensor[](state){pre_state.size()}, Tensor(reserve)
|
|
infer_meta:
|
|
func: RnnInferMeta
|
|
param : [x, pre_state, weight_list, sequence_length, dropout_prob, is_bidirec, input_size, hidden_size, num_layers, mode, seed, is_test]
|
|
kernel:
|
|
func: rnn
|
|
param : [x, pre_state, weight_list, sequence_length, dropout_prob, is_bidirec, input_size, hidden_size, num_layers, mode, seed, is_test]
|
|
data_type: x
|
|
backward: rnn_grad
|
|
optional : sequence_length, dropout_state_out
|
|
intermediate : reserve
|
|
|
|
- op : row_conv
|
|
args: (Tensor x, Tensor filter)
|
|
output: Tensor (out)
|
|
infer_meta:
|
|
func: RowConvInferMeta
|
|
kernel:
|
|
func: row_conv
|
|
backward: row_conv_grad
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface
|
|
|
|
- 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 : shadow_output
|
|
args : (Tensor x, str name)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : UnchangedInferMeta
|
|
param : [x]
|
|
kernel:
|
|
func : shadow_output
|
|
param : [x]
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : share_buffer
|
|
args : (Tensor[] x, bool[] share_dims_and_dtype={})
|
|
output : Tensor[](out){x.size()}, Tensor[](xout){x.size()}
|
|
infer_meta :
|
|
func : ShareBufferInferMeta
|
|
kernel :
|
|
func : share_buffer
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : softmax
|
|
args : (Tensor x, int axis = -1)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : SoftmaxInferMeta
|
|
kernel :
|
|
func : softmax
|
|
inplace : (x -> out)
|
|
backward : softmax_grad
|
|
|
|
- op : softplus
|
|
args : (Tensor x, float beta = 1.0, float threshold = 20.0f)
|
|
output : Tensor
|
|
infer_meta :
|
|
func : UnchangedInferMeta
|
|
param : [x]
|
|
spmd_rule : SoftplusInfoSpmd
|
|
kernel :
|
|
func : softplus
|
|
backward : softplus_grad
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
|
|
traits: pir::UnaryElementWiseTrait
|
|
|
|
- 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
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : squeeze
|
|
args : (Tensor x, IntArray axis={})
|
|
output : Tensor(out), Tensor(xshape)
|
|
infer_meta :
|
|
func : SqueezeWithXShapeInferMeta
|
|
spmd_rule : SqueezeInferSpmd
|
|
kernel :
|
|
func : squeeze_with_xshape
|
|
data_type : x
|
|
inplace : (x -> out)
|
|
view: (x -> out)
|
|
intermediate : xshape
|
|
backward : squeeze_grad
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface, paddle::dialect::LayoutTransformationInterface
|
|
|
|
- op : strided_slice
|
|
args : (Tensor x, int[] axes, IntArray starts={}, IntArray ends={}, IntArray strides={}, int[] infer_flags={}, int[] decrease_axis={})
|
|
output : Tensor
|
|
infer_meta :
|
|
func : StridedSliceRawInferMeta
|
|
kernel :
|
|
func : strided_slice
|
|
param : [x, axes, starts, ends, strides]
|
|
backward : strided_slice_grad
|
|
|
|
- op : sum
|
|
args : (Tensor x, IntArray axis={0}, bool keepdim=false, bool reduce_all=false, int in_dtype=-1, DataType out_dtype=DataType::UNDEFINED)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : SumRawInferMeta
|
|
param : [x, axis, keepdim, reduce_all, out_dtype]
|
|
kernel :
|
|
func : sum_raw
|
|
param : [x, axis, keepdim, reduce_all, out_dtype]
|
|
data_type : x
|
|
backward : sum_grad
|
|
|
|
- op : swish
|
|
args : (Tensor x)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : UnchangedInferMeta
|
|
param : [x]
|
|
kernel :
|
|
func : swish
|
|
backward : swish_grad
|
|
|
|
- op : top_p_sampling
|
|
args : (Tensor x, Tensor ps, Tensor threshold, Tensor topp_seed, int seed=-1, int k=0, str mode="truncate")
|
|
output : Tensor (out), Tensor(ids), Tensor(topk_scores), Tensor(topk_ids)
|
|
infer_meta :
|
|
func : TopPSamplingInferMeta
|
|
kernel :
|
|
func : top_p_sampling
|
|
data_type : x
|
|
optional : threshold, topp_seed, topk_scores, topk_ids
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : topk_v1
|
|
args : (Tensor x, Scalar(int) k = 1)
|
|
output : Tensor(out), Tensor(indices)
|
|
infer_meta :
|
|
func : TopkV1InferMeta
|
|
kernel :
|
|
func : topk_v1
|
|
data_type : x
|
|
backward : topk_v1_grad
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface
|
|
|
|
- op : transfer_layout
|
|
args: (Tensor x, int src_layout = -1, int dst_layout=-1)
|
|
output: Tensor (out)
|
|
infer_meta:
|
|
func: TransferLayoutInferMeta
|
|
kernel:
|
|
func: transfer_layout
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : tril_indices
|
|
args : (int rows = 0, int cols = 0, int offset = 0, DataType dtype = DataType::INT64)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : TrilIndicesInferMeta
|
|
param : [rows, cols, offset, dtype]
|
|
kernel :
|
|
func : tril_indices
|
|
param : [rows, cols, offset, dtype]
|
|
data_type : dtype
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : tril_triu
|
|
args : (Tensor x, int diagonal = 0, bool lower = false)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : TrilTriuInferMeta
|
|
kernel :
|
|
func : tril_triu
|
|
backward : tril_triu_grad
|
|
|
|
- op : trilinear_interp
|
|
args : (Tensor x, Tensor out_size, Tensor[] size_tensor, Tensor scale_tensor, str data_format="NCHW", int out_d=0, int out_h=0, int out_w=0, float[] scale={}, str interp_method="bilinear", bool align_corners=true, int align_mode=1)
|
|
output : Tensor(output)
|
|
infer_meta :
|
|
func : InterpolateInferMeta
|
|
optional: out_size, size_tensor, scale_tensor
|
|
kernel :
|
|
func : trilinear_interp
|
|
data_type : x
|
|
backward : trilinear_interp_grad
|
|
data_transform :
|
|
skip_transform : out_size, size_tensor, scale_tensor
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface
|
|
|
|
- op : triu_indices
|
|
args : (int row = 0, int col = 0, int offset = 0, DataType dtype = DataType::INT64)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : TriuIndicesInferMeta
|
|
param : [row, col, offset, dtype]
|
|
kernel :
|
|
func : triu_indices
|
|
param : [row, col, offset, dtype]
|
|
data_type : dtype
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : truncated_gaussian_random
|
|
args : (int[] shape, float mean = .0f, float std = 1.0f, int seed = 0, float a = -2.0f, float b = 2.0f, DataType dtype=DataType::FLOAT32)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : TruncatedGaussianRandomInferMeta
|
|
param : [shape, mean, std, seed, a, b, dtype]
|
|
kernel :
|
|
func : truncated_gaussian_random
|
|
param : [shape, mean, std, seed, a, b, dtype]
|
|
data_type : dtype
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : uniform
|
|
args : (IntArray shape = {}, DataType dtype = DataType::FLOAT32, Scalar min = -1.0f, Scalar max = 1.0f, int seed = 0, int diag_num = 0, int diag_step = 0, float diag_val = 1.0f)
|
|
output : Tensor(out)
|
|
infer_meta :
|
|
func : UniformRandomInferMeta
|
|
param: [shape, dtype]
|
|
kernel :
|
|
func : uniform
|
|
param: [shape, dtype, min, max, seed]
|
|
data_type : dtype
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- 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
|
|
kernel :
|
|
func : unique
|
|
data_type : x
|
|
traits : paddle::dialect::ForwardOnlyTrait
|
|
|
|
- op : unpool
|
|
args: (Tensor x, Tensor indices, int[] ksize, str unpooling_type, int[] strides = {1,1}, int[] paddings ={0,0} ,IntArray output_size = {0,0}, str data_format="NCHW")
|
|
output: Tensor(out)
|
|
infer_meta:
|
|
func: UnpoolInferMeta
|
|
param : [x, indices, ksize, strides, paddings,output_size, data_format]
|
|
kernel:
|
|
func: unpool
|
|
data_type: x
|
|
param : [x, indices, ksize, strides, paddings,output_size, data_format]
|
|
backward: unpool_grad
|
|
|
|
- op : unsqueeze
|
|
args : (Tensor x, IntArray axis = {})
|
|
output : Tensor(out), Tensor(xshape)
|
|
infer_meta :
|
|
func : UnsqueezeWithXShapeInferMeta
|
|
spmd_rule : UnsqueezeWithXShapeInferSpmd
|
|
kernel :
|
|
func : unsqueeze_with_xshape
|
|
data_type : x
|
|
inplace : (x -> out)
|
|
view: (x -> out)
|
|
intermediate : xshape
|
|
backward : unsqueeze_grad
|
|
interfaces : paddle::dialect::InferSymbolicShapeInterface
|
|
|
|
- op: multiclass_nms
|
|
args: (Tensor bboxes, Tensor scores, float score_threshold,
|
|
int nms_top_k, int keep_top_k, float nms_threshold = 0.3, float nms_eta = 1.0,
|
|
bool normalized = true, int background_label = 0)
|
|
output: Tensor (out)
|
|
infer_meta:
|
|
func: MulticlassNmsv1InferMeta
|
|
kernel:
|
|
func: multiclass_nms
|
|
data_type: scores
|
|
traits : paddle::dialect::ForwardOnlyTrait
|