add yaml config; test=develop

paddle/fluid/eager/auto_code_generator/final_state_generator/eager_gen.py

@@ -202,7 +202,7 @@ def ParseYamlArgs(string):
         default_value = m.group(3).split("=")[1].strip() if len(
             m.group(3).split("=")) > 1 else None
 
-        assert arg_type in yaml_types_mapping.keys()
+        assert arg_type in yaml_types_mapping.keys(), arg_type
         arg_type = yaml_types_mapping[arg_type]
         if "Tensor" in arg_type:
             assert default_value is None
@@ -1126,7 +1126,7 @@ if __name__ == "__main__":
             fwd_returns_str = fwd_api['output']
 
             bwd_api_name = fwd_api['backward']
-            assert bwd_api_name in grad_api_dict.keys()
+            assert bwd_api_name in grad_api_dict.keys(), bwd_api_name
             bwd_api = grad_api_dict[bwd_api_name]
 
             assert 'args' in bwd_api.keys()

paddle/phi/infermeta/backward.h

@@ -17,6 +17,9 @@ limitations under the License. */
 #include <tuple>
 
 #include "paddle/phi/core/meta_tensor.h"
+#include "paddle/phi/infermeta/binary.h"
+#include "paddle/phi/infermeta/multiary.h"
+#include "paddle/phi/infermeta/ternary.h"
 #include "paddle/phi/infermeta/unary.h"
 
 namespace phi {

python/paddle/utils/code_gen/api.yaml

@@ -252,66 +252,66 @@
     func : softmax
   backward : softmax_grad
 
-# maxout
-- api : maxout
-  args : (Tensor x, int groups, int axis)
-  output : Tensor
-  infer_meta :
-    func : MaxoutInferMeta
-  kernel :
-    func : maxout
-  backward : maxout_grad
+# # maxout
+# - api : maxout
+#   args : (Tensor x, int groups, int axis)
+#   output : Tensor
+#   infer_meta :
+#     func : MaxoutInferMeta
+#   kernel :
+#     func : maxout
+#   backward : maxout_grad
 
-# put_along_axis
-- api : put_along_axis
-  args : (Tensor x, Tensor index, Tensor value, int axis, string reduce)
-  output : Tensor
-  infer_meta :
-    func : PutAlongAxisInferMeta
-  kernel :
-    func : put_along_axis
-  backward : put_along_axis_grad
+# # put_along_axis
+# - api : put_along_axis
+#   args : (Tensor x, Tensor index, Tensor value, int axis, string reduce)
+#   output : Tensor
+#   infer_meta :
+#     func : PutAlongAxisInferMeta
+#   kernel :
+#     func : put_along_axis
+#   backward : put_along_axis_grad
 
 
-# take_along_axis
-- api : take_along_axis
-  args : (Tensor x, Tensor index, int axis)
-  output : Tensor
-  infer_meta :
-    func : TakeAlongAxisInferMeta
-  kernel :
-    func : take_along_axis
-  backward : take_along_axis_grad
+# # take_along_axis
+# - api : take_along_axis
+#   args : (Tensor x, Tensor index, int axis)
+#   output : Tensor
+#   infer_meta :
+#     func : TakeAlongAxisInferMeta
+#   kernel :
+#     func : take_along_axis
+#   backward : take_along_axis_grad
 
-# matrix_power
-- api : maxtrix_power
-  args : (Tensor x, int n)
-  output : Tensor
-  infer_meta :
-    func : MaxtrixPowerInferMeta
-  kernel :
-    func : maxtrix_power
-  backward : maxtrix_power_grad
+# # matrix_power
+# - api : maxtrix_power
+#   args : (Tensor x, int n)
+#   output : Tensor
+#   infer_meta :
+#     func : MaxtrixPowerInferMeta
+#   kernel :
+#     func : maxtrix_power
+#   backward : maxtrix_power_grad
 
-# eigh
-- api : eigh
-  args : (Tensor x, string uplo)
-  output : Tensor(out_w), Tensor(out_v)
-  infer_meta :
-    func : EighInferMeta
-  kernel :
-    func : eigh
-  backward : eigh_grad
+# # eigh
+# - api : eigh
+#   args : (Tensor x, string uplo)
+#   output : Tensor(out_w), Tensor(out_v)
+#   infer_meta :
+#     func : EighInferMeta
+#   kernel :
+#     func : eigh
+#   backward : eigh_grad
 
-# segment_pool
-- api : segment_pool
-  args : (Tensor x, Tensor segment_ids, string pooltype)
-  output : Tensor(out), Tensor(summed_ids)
-  infer_meta :
-    func : SegmentPoolInferMeta
-  kernel :
-    func : segment_pool
-  backward : segment_pool_grad
+# # segment_pool
+# - api : segment_pool
+#   args : (Tensor x, Tensor segment_ids, string pooltype)
+#   output : Tensor(out), Tensor(summed_ids)
+#   infer_meta :
+#     func : SegmentPoolInferMeta
+#   kernel :
+#     func : segment_pool
+#   backward : segment_pool_grad
 
 # accuracy
 - api : accuracy
@@ -451,7 +451,7 @@
   args : (Tensor x, int axis, bool keepdims, bool flatten, int dtype)
   output : Tensor
   infer_meta :
-    func : XXXXInferMeta
+    func : ArgMinMaxInferMeta
   kernel :
     func : argmin
 
@@ -460,7 +460,7 @@
   args : (Tensor x, int axis, bool keepdims, bool flatten, int dtype)
   output : Tensor
   infer_meta :
-    func : XXXXInferMeta
+    func : ArgMinMaxInferMeta
   kernel :
     func : argmax
 
@@ -469,85 +469,85 @@
   args : (Tensor x, int axis, bool descending)
   output : Tensor(out), Tensor(indices)
   infer_meta :
-    func : XXXXInferMeta
+    func : ArgsortInferMeta
   kernel :
     func : argsort
 
 # auc; kernel why input?
-- api : auc
-  args : (Tensor x, Tensor label, Tensor stat_pos, Tenosr stat_neg, string curve, int num_thresholds, int slide_steps)
-  output : Tensor(auc), Tensor(stat_pos_out), Tensor(stat_neg_out)
-  infer_meta :
-    func : AucInferMeta
-  kernel :
-    func : auc
+# - api : auc
+#   args : (Tensor x, Tensor label, Tensor stat_pos, Tensor stat_neg, str curve, int num_thresholds, int slide_steps)
+#   output : Tensor(auc), Tensor(stat_pos_out), Tensor(stat_neg_out)
+#   infer_meta :
+#     func : AucInferMeta
+#   kernel :
+#     func : auc
 
-# batch_norm
-- api : batch_norm
-  args : (Tensor x, Tensor scale, Tensor bias, Tensor mean, Tensor variance, float momentum, float epsilon, string data_layout, bool is_test, bool use_global_stats, bool trainable_statistics, bool fuse_with_relu)
-  output : Tensor(out), Tensor(mean_out), Tensor(variance_out), Tensor(saved_mean), Tensor(saved_variance), Tensor(reserve_space)
-  infer_meta :
-    func : XXXXInferMeta
-  kernel :
-    func : batch_norm
-  backward: batch_norm_grad
+# # batch_norm
+# - api : batch_norm
+#   args : (Tensor x, Tensor scale, Tensor bias, Tensor mean, Tensor variance, float momentum, float epsilon, string data_layout, bool is_test, bool use_global_stats, bool trainable_statistics, bool fuse_with_relu)
+#   output : Tensor(out), Tensor(mean_out), Tensor(variance_out), Tensor(saved_mean), Tensor(saved_variance), Tensor(reserve_space)
+#   infer_meta :
+#     func : XXXXInferMeta
+#   kernel :
+#     func : batch_norm
+#   backward: batch_norm_grad
 
-# bernoulli
-- api : bernoulli
-  args : (Tensor x)
-  output : Tensor
-  infer_meta :
-    func : BernoulliInferMeta
-  kernel :
-    func : bernoulli
+# # bernoulli
+# - api : bernoulli
+#   args : (Tensor x)
+#   output : Tensor
+#   infer_meta :
+#     func : BernoulliInferMeta
+#   kernel :
+#     func : bernoulli
 
-# bilinear_tensor_product ?? optional
-- api : bilinear_tensor_product
-  args : (Tensor x, Tensor y, Tensor weight, Tensor bias)
-  output : Tensor
-  infer_meta :
-    func : BilinearTensorProductInferMeta
-  kernel :
-    func : bilinear_tensor_product
-  backward : bilinear_tensor_product_grad
+# # bilinear_tensor_product ?? optional
+# - api : bilinear_tensor_product
+#   args : (Tensor x, Tensor y, Tensor weight, Tensor bias)
+#   output : Tensor
+#   infer_meta :
+#     func : BilinearTensorProductInferMeta
+#   kernel :
+#     func : bilinear_tensor_product
+#   backward : bilinear_tensor_product_grad
 
 # bincount ?? optional
-- api : bincount
-  args : (Tensor x, Tensor weight, int minlength)
-  output : Tensor
-  infer_meta :
-    func : BincountInferMeta
-  kernel :
-    func : bincount
+# - api : bincount
+#   args : (Tensor x, Tensor weight, int minlength)
+#   output : Tensor
+#   infer_meta :
+#     func : BincountInferMeta
+#   kernel :
+#     func : bincount
 
 
 # bitwise_and
-- api : bitwise_and
-  args : (Tensor x, Tensor y)
-  output : Tensor
-  infer_meta :
-    func : BitwiseInferMeta
-  kernel :
-    func : bitwise_and
+# - api : bitwise_and
+#   args : (Tensor x, Tensor y)
+#   output : Tensor
+#   infer_meta :
+#     func : BitwiseInferMeta
+#   kernel :
+#     func : bitwise_and
 
-# bitwise_or
-- api : bitwise_or
-  args : (Tensor x, Tensor y)
-  output : Tensor
-  infer_meta :
-    func : BitwiseInferMeta
-  kernel :
-    func : bitwise_or
+# # bitwise_or
+# - api : bitwise_or
+#   args : (Tensor x, Tensor y)
+#   output : Tensor
+#   infer_meta :
+#     func : BitwiseInferMeta
+#   kernel :
+#     func : bitwise_or
 
 
-# bitwise_xor
-- api : bitwise_xor
-  args : (Tensor x, Tensor y)
-  output : Tensor
-  infer_meta :
-    func : BitwiseInferMeta
-  kernel :
-    func : bitwise_xor
+# # bitwise_xor
+# - api : bitwise_xor
+#   args : (Tensor x, Tensor y)
+#   output : Tensor
+#   infer_meta :
+#     func : BitwiseInferMeta
+#   kernel :
+#     func : bitwise_xor
 
 # bitwise_not
 - api : bitwise_not
@@ -559,14 +559,14 @@
     func : bitwise_not
 
 # broadcast_tensors
-- api : broadcast_tensors
-  args : (Tensor[] x)
-  output : Tensor[]
-  infer_meta :
-    func : BroadcastTensorsInferMeta
-  kernel :
-    func : broadcast_tensors
-  backward : broadcast_tensors_grad
+# - api : broadcast_tensors
+#   args : (Tensor[] x)
+#   output : Tensor[]
+#   infer_meta :
+#     func : BroadcastTensorsInferMeta
+#   kernel :
+#     func : broadcast_tensors
+#   backward : broadcast_tensors_grad
 
 # cholesky
 - api : cholesky
@@ -588,8 +588,8 @@
     func : cholesky_solve
   backward : cholesky_solve_grad
 
-# conv2d
-# copy
+# # conv2d
+# # copy
 
 
 # cumsum
@@ -601,458 +601,458 @@
   kernel :
     func : cumsum
 
-# depthwise_conv2d
-# dropout ?? optional, intermediate
-- api : dropout
-  args : (Tensor x, Tensor seed_tensor, float p, bool is_test, string mode, int seed, bool fix_seed)
-  output : Tensor(out), Tensor(mask)
-  infer_meta :
-    func : DropoutInferMeta
-  kernel :
-    func : dropout
+# # depthwise_conv2d
+# # dropout ?? optional, intermediate
+# - api : dropout
+#   args : (Tensor x, Tensor seed_tensor, float p, bool is_test, string mode, int seed, bool fix_seed)
+#   output : Tensor(out), Tensor(mask)
+#   infer_meta :
+#     func : DropoutInferMeta
+#   kernel :
+#     func : dropout
 
-# embedding
+# # embedding
 
-# erf
-- api : erf
-  args : (Tensor x)
-  output : Tensor
-  infer_meta :
-    func : ErfInferMeta
-  kernel :
-    func : erf
-  backward : erf_grad
+# # erf
+# - api : erf
+#   args : (Tensor x)
+#   output : Tensor
+#   infer_meta :
+#     func : ErfInferMeta
+#   kernel :
+#     func : erf
+#   backward : erf_grad
 
-# erfinv
-- api : erfinv
-  args : (Tensor x)
-  output : Tensor
-  infer_meta :
-    func : ErfinvInferMeta
-  kernel :
-    func : erfinv
-  backward : erfinv_grad
+# # erfinv
+# - api : erfinv
+#   args : (Tensor x)
+#   output : Tensor
+#   infer_meta :
+#     func : ErfinvInferMeta
+#   kernel :
+#     func : erfinv
+#   backward : erfinv_grad
 
-# expand_as ?? optional 
-- api : expand_as
-  args : (Tensor x, Tensor y, int[] shape)
-  output : Tensor
-  infer_meta :
-    func : ExpandAsInferMeta
-  kernel :
-    func : expand_as
-  backward : expand_as_grad
+# # expand_as ?? optional 
+# - api : expand_as
+#   args : (Tensor x, Tensor y, int[] shape)
+#   output : Tensor
+#   infer_meta :
+#     func : ExpandAsInferMeta
+#   kernel :
+#     func : expand_as
+#   backward : expand_as_grad
 
 
-# expand
-- api : expand
-  args : (Tensor x, ScalarArray shape)
-  output : Tensor
-  infer_meta :
-    func : ExpandInferMeta
-  kernel :
-    func : expand
-  backward : expand_grad
+# # expand
+# - api : expand
+#   args : (Tensor x, ScalarArray shape)
+#   output : Tensor
+#   infer_meta :
+#     func : ExpandInferMeta
+#   kernel :
+#     func : expand
+#   backward : expand_grad
 
-# eye ? int64
+# eye
 - api : eye
-  args : (int num_rows, int num_colums, DataType dtype)
+  args : (int64 num_rows, int64 num_colums, DataType dtype)
   output : Tensor
   infer_meta :
     func : EyeInferMeta
   kernel :
     func : eye
 
-# flip
-- api : flip
-  args : (Tensor x, int[] axis)
-  output : Tensor
-  infer_meta :
-    func : FlipInferMeta
-  kernel :
-    func : flip
+# # flip
+# - api : flip
+#   args : (Tensor x, int[] axis)
+#   output : Tensor
+#   infer_meta :
+#     func : FlipInferMeta
+#   kernel :
+#     func : flip
 
 # gaussian_random
-- api : gaussian_random
-  args : (ScalayArray shape, float mean, float std, int seed, DataType dtype)
-  output : Tensor
-  infer_meta :
-    func : GaussianRandomInferMeta
-  kernel :
-    func : gaussian_random
+# - api : gaussian_random
+#   args : (ScalayArray shape, float mean, float std, int seed, DataType dtype)
+#   output : Tensor
+#   infer_meta :
+#     func : GaussianRandomInferMeta
+#   kernel :
+#     func : gaussian_random
 
-# graph_send_recv
-- api : graph_send_recv
-  args : (Tensor x, Tensor src_index, Tensor dst_index, string pool_type)
-  output : Tensor(out), Tensor(dst_count)
-  infer_meta :
-    func : GraphSendRecvInferMeta
-  kernel :
-    func : graph_send_recv
-  backward : graph_send_recv_grad
+# # graph_send_recv
+# - api : graph_send_recv
+#   args : (Tensor x, Tensor src_index, Tensor dst_index, string pool_type)
+#   output : Tensor(out), Tensor(dst_count)
+#   infer_meta :
+#     func : GraphSendRecvInferMeta
+#   kernel :
+#     func : graph_send_recv
+#   backward : graph_send_recv_grad
 
-# histogram int64 ???
-- api : histogram
-  args : (Tensor x, int64_t bins, int min, int max)
-  output : Tensor
-  infer_meta :
-    func : HistogramInferMeta
-  kernel :
-    func : histogram
+# # histogram int64 ???
+# - api : histogram
+#   args : (Tensor x, int64_t bins, int min, int max)
+#   output : Tensor
+#   infer_meta :
+#     func : HistogramInferMeta
+#   kernel :
+#     func : histogram
 
-# increment
-- api : increment
-  args : (Tensor x, float value)
-  output : Tensor
-  infer_meta :
-    func : IncrementInferMeta
-  kernel :
-    func : increment
+# # increment
+# - api : increment
+#   args : (Tensor x, float value)
+#   output : Tensor
+#   infer_meta :
+#     func : IncrementInferMeta
+#   kernel :
+#     func : increment
 
-# is_empty
-- api : is_empty
-  args : (Tensor x)
-  output : Tensor
-  infer_meta :
-    func : IsEmptyInferMeta
-  kernel :
-    func : is_empty
+# # is_empty
+# - api : is_empty
+#   args : (Tensor x)
+#   output : Tensor
+#   infer_meta :
+#     func : IsEmptyInferMeta
+#   kernel :
+#     func : is_empty
 
-# isinf selected rows??? involk
-- api : isinf
-  args : (Tensor x)
-  output : Tensor
-  infer_meta :
-    func : IsfiniteInferMeta
-  kernel :
-    func : isinf
+# # isinf selected rows??? involk
+# - api : isinf
+#   args : (Tensor x)
+#   output : Tensor
+#   infer_meta :
+#     func : IsfiniteInferMeta
+#   kernel :
+#     func : isinf
 
-# isnan
-- api : isnan
-  args : (Tensor x)
-  output : Tensor
-  infer_meta :
-    func : IsfiniteInferMeta
-  kernel :
-    func : isnan
+# # isnan
+# - api : isnan
+#   args : (Tensor x)
+#   output : Tensor
+#   infer_meta :
+#     func : IsfiniteInferMeta
+#   kernel :
+#     func : isnan
 
-# isfinite
-- api : isfinite
-  args : (Tensor x)
-  output : Tensor
-  infer_meta :
-    func : IsfiniteInferMeta
-  kernel :
-    func : isfinite
+# # isfinite
+# - api : isfinite
+#   args : (Tensor x)
+#   output : Tensor
+#   infer_meta :
+#     func : IsfiniteInferMeta
+#   kernel :
+#     func : isfinite
 
-# label_smooth  ?? optional
-- api : label_smooth
-  args : (Tensor label, Tensor prior_dist, float epsilon)
-  output : Tensor
-  infer_meta :
-    func : LabelSmoothInferMeta
-  kernel :
-    func : label_smooth
-  backward : label_smooth_grad
+# # label_smooth  ?? optional
+# - api : label_smooth
+#   args : (Tensor label, Tensor prior_dist, float epsilon)
+#   output : Tensor
+#   infer_meta :
+#     func : LabelSmoothInferMeta
+#   kernel :
+#     func : label_smooth
+#   backward : label_smooth_grad
 
-# linspace
-- api : linspace
-  args : (Tensor start, Tensor stop, Tensor number, DataType dtype)
-  output : Tensor
-  infer_meta :
-    func : LinspaceInferMeta
-  kernel :
-    func : linspace
+# # linspace
+# - api : linspace
+#   args : (Tensor start, Tensor stop, Tensor number, DataType dtype)
+#   output : Tensor
+#   infer_meta :
+#     func : LinspaceInferMeta
+#   kernel :
+#     func : linspace
 
-# log_loss
-- api : log_loss
-  args : (Tensor input, Tensor label, float epsilon)
-  output : Tensor
-  infer_meta :
-    func : LogLossInferMeta
-  kernel :
-    func : log_loss
-  backward : log_loss
+# # log_loss
+# - api : log_loss
+#   args : (Tensor input, Tensor label, float epsilon)
+#   output : Tensor
+#   infer_meta :
+#     func : LogLossInferMeta
+#   kernel :
+#     func : log_loss
+#   backward : log_loss
 
-# logical_and
-- api : logical_and
-  args : (Tensor x, Tensor y)
-  output : Tensor
-  infer_meta :
-    func : LogicalInferMeta
-  kernel :
-    func : logical_and
+# # logical_and
+# - api : logical_and
+#   args : (Tensor x, Tensor y)
+#   output : Tensor
+#   infer_meta :
+#     func : LogicalInferMeta
+#   kernel :
+#     func : logical_and
 
-# logical_or
-- api : logical_or
-  args : (Tensor x, Tensor y)
-  output : Tensor
-  infer_meta :
-    func : LogicalInferMeta
-  kernel :
-    func : logical_or
+# # logical_or
+# - api : logical_or
+#   args : (Tensor x, Tensor y)
+#   output : Tensor
+#   infer_meta :
+#     func : LogicalInferMeta
+#   kernel :
+#     func : logical_or
 
 
-# logical_xor
-- api : logical_xor
-  args : (Tensor x, Tensor y)
-  output : Tensor
-  infer_meta :
-    func : LogicalInferMeta
-  kernel :
-    func : logical_xor
+# # logical_xor
+# - api : logical_xor
+#   args : (Tensor x, Tensor y)
+#   output : Tensor
+#   infer_meta :
+#     func : LogicalInferMeta
+#   kernel :
+#     func : logical_xor
 
-# logical_not
-- api : logical_not
-  args : (Tensor x)
-  output : Tensor
-  infer_meta :
-    func : UnchangedInferMeta
-  kernel :
-    func : logical_not
+# # logical_not
+# - api : logical_not
+#   args : (Tensor x)
+#   output : Tensor
+#   infer_meta :
+#     func : UnchangedInferMeta
+#   kernel :
+#     func : logical_not
 
-# masked_select
-- api : masked_select
-  args : (Tensor x, Tensor mask)
-  output : Tensor
-  infer_meta :
-    func : MaksedSelectInferMeta
-  kernel :
-    func : masked_select
-  backward : masked_select_grad
+# # masked_select
+# - api : masked_select
+#   args : (Tensor x, Tensor mask)
+#   output : Tensor
+#   infer_meta :
+#     func : MaksedSelectInferMeta
+#   kernel :
+#     func : masked_select
+#   backward : masked_select_grad
 
-# multi_dot
-- api : multi_dot
-  args : (Tensor[] x)
-  output : Tensor
-  infer_meta :
-    func : MultiDotInferMeta
-  kernel :
-    func : multi_dot
-  backward : multi_dot_grad
+# # multi_dot
+# - api : multi_dot
+#   args : (Tensor[] x)
+#   output : Tensor
+#   infer_meta :
+#     func : MultiDotInferMeta
+#   kernel :
+#     func : multi_dot
+#   backward : multi_dot_grad
 
-# multinomial
-- api : multinomial
-  args : (Tensor x, int num_samples, bool replacement)
-  output : Tensor
-  infer_meta :
-    func : MultinomialInferMeta
-  kernel :
-    func : multinomial
+# # multinomial
+# - api : multinomial
+#   args : (Tensor x, int num_samples, bool replacement)
+#   output : Tensor
+#   infer_meta :
+#     func : MultinomialInferMeta
+#   kernel :
+#     func : multinomial
 
-# nll_loss  ?? optional
-- api : nll_loss
-  args : (Tensor input, Tensor label, Tensor weight, int64_t ignore_index, string reduction)
-  output : Tensor(out), Tensor(total_weight)
-  infer_meta :
-    func : NllLossInferMeta
-  kernel :
-    func : nll_loss
-  backward : nll_loss_grad
+# # nll_loss  ?? optional
+# - api : nll_loss
+#   args : (Tensor input, Tensor label, Tensor weight, int64_t ignore_index, string reduction)
+#   output : Tensor(out), Tensor(total_weight)
+#   infer_meta :
+#     func : NllLossInferMeta
+#   kernel :
+#     func : nll_loss
+#   backward : nll_loss_grad
 
-# pad
-- api : pad
-  args : (Tensor x, int[] paddings, float pad_value)
-  output : Tensor
-  infer_meta :
-    func : PadInferMeta
-  kernel :
-    func : pad
-  backward : pad_grad
+# # pad
+# - api : pad
+#   args : (Tensor x, int[] paddings, float pad_value)
+#   output : Tensor
+#   infer_meta :
+#     func : PadInferMeta
+#   kernel :
+#     func : pad
+#   backward : pad_grad
 
-# pixel_shuffle
-- api : pixel_shuffle
-  args : (Tensor x, int upscale_factor, string data_format)
-  output : Tensor
-  infer_meta :
-    func : PixelShuffleInferMeta
-  kernel :
-    func : pixel_shuffle
-  backward : pixel_shuffle_grad
+# # pixel_shuffle
+# - api : pixel_shuffle
+#   args : (Tensor x, int upscale_factor, string data_format)
+#   output : Tensor
+#   infer_meta :
+#     func : PixelShuffleInferMeta
+#   kernel :
+#     func : pixel_shuffle
+#   backward : pixel_shuffle_grad
 
-# poisson
-- api : poisson
-  args : (Tensor x)
-  output : Tensor
-  infer_meta :
-    func : PoissonInferMeta
-  kernel :
-    func : poisson
-  backward : poisson_grad
+# # poisson
+# - api : poisson
+#   args : (Tensor x)
+#   output : Tensor
+#   infer_meta :
+#     func : PoissonInferMeta
+#   kernel :
+#     func : poisson
+#   backward : poisson_grad
 
-# psroi_pool  ?? optional
-- api : psroi_pool
-  args : (Tensor x, Tensor rois, Tensor rois_num, int pooled_weight, int pooled_width, int output_channels, float spatial_scale )
-  output : Tensor
-  infer_meta :
-    func : PsroiPoolInferMeta
-  kernel :
-    func : psroi_pool
-  backward : psroi_pool_grad
+# # psroi_pool  ?? optional
+# - api : psroi_pool
+#   args : (Tensor x, Tensor rois, Tensor rois_num, int pooled_weight, int pooled_width, int output_channels, float spatial_scale )
+#   output : Tensor
+#   infer_meta :
+#     func : PsroiPoolInferMeta
+#   kernel :
+#     func : psroi_pool
+#   backward : psroi_pool_grad
 
-# randint_raw
-- api : randint
-  args : (int low, int high, ScalarArray shape, DataType dtype)
-  output : Tensor
-  infer_meta :
-    func : RandintInferMeta
-  kernel :
-    func : randint
+# # randint_raw
+# - api : randint
+#   args : (int low, int high, ScalarArray shape, DataType dtype)
+#   output : Tensor
+#   infer_meta :
+#     func : RandintInferMeta
+#   kernel :
+#     func : randint
 
-# randperm_raw
-- api : randperm
-  args : (int n, DataType dtype)
-  output : Tensor
-  infer_meta :
-    func : RandpermInferMeta
-  kernel :
-    func : randperm
+# # randperm_raw
+# - api : randperm
+#   args : (int n, DataType dtype)
+#   output : Tensor
+#   infer_meta :
+#     func : RandpermInferMeta
+#   kernel :
+#     func : randperm
 
-# max
-- api : max
-  args : (Tensor x, int64_t[] dims, bool keep_dim)
-  output : Tensor
-  infer_meta :
-    func : MaxInferMeta
-  kernel :
-    func : max
+# # max
+# - api : max
+#   args : (Tensor x, int64_t[] dims, bool keep_dim)
+#   output : Tensor
+#   infer_meta :
+#     func : MaxInferMeta
+#   kernel :
+#     func : max
 
-# reduce_prod
-- api : reduce_prod
-  args : (Tensor x, int64_t[] dims, bool keep_dim, bool reduce_all)
-  output : Tensor
-  infer_meta :
-    func : ReduceProdInferMeta
-  kernel :
-    func : reduce_prod
+# # reduce_prod
+# - api : reduce_prod
+#   args : (Tensor x, int64_t[] dims, bool keep_dim, bool reduce_all)
+#   output : Tensor
+#   infer_meta :
+#     func : ReduceProdInferMeta
+#   kernel :
+#     func : reduce_prod
 
-# selu
-- api : selu
-  args : (Tensor x, float scale, float alpha)
-  output : Tensor
-  infer_meta :
-    func : SeluInferMeta
-  kernel :
-    func : selu
-  backward : selu_grad
+# # selu
+# - api : selu
+#   args : (Tensor x, float scale, float alpha)
+#   output : Tensor
+#   infer_meta :
+#     func : SeluInferMeta
+#   kernel :
+#     func : selu
+#   backward : selu_grad
 
-# set_value None api
+# # set_value None api
 
-# sgd # need invoke
-# shape ??? selcted rows
+# # sgd # need invoke
+# # shape ??? selcted rows
 
-# shard_index
-- api : shard_index
-  args : (Tensor in, int index_num, int nshards, int shard_id, int ignore_value)
-  output : Tensor
-  infer_meta :
-    func : ShardIndexInferMeta
-  kernel :
-    func : shard_index
+# # shard_index
+# - api : shard_index
+#   args : (Tensor in, int index_num, int nshards, int shard_id, int ignore_value)
+#   output : Tensor
+#   infer_meta :
+#     func : ShardIndexInferMeta
+#   kernel :
+#     func : shard_index
 
-# sigmoid_cross_entropy_with_logits
-- api : sigmoid_cross_entropy_with_logits
-  args : (Tensor x, Tensor label, bool normalize, int ignore_index)
-  output : Tensor
-  infer_meta :
-    func : SigmoidCrossEntropyWithoLgitsInferMeta
-  kernel :
-    func : sigmoid_cross_entropy_with_logits
+# # sigmoid_cross_entropy_with_logits
+# - api : sigmoid_cross_entropy_with_logits
+#   args : (Tensor x, Tensor label, bool normalize, int ignore_index)
+#   output : Tensor
+#   infer_meta :
+#     func : SigmoidCrossEntropyWithoLgitsInferMeta
+#   kernel :
+#     func : sigmoid_cross_entropy_with_logits
 
-# size
-- api : size
-  args : (Tensor x)
-  output : Tensor
-  infer_meta :
-    func : SizeInferMeta
-  kernel :
-    func : size
+# # size
+# - api : size
+#   args : (Tensor x)
+#   output : Tensor
+#   infer_meta :
+#     func : SizeInferMeta
+#   kernel :
+#     func : size
 
-# tile
-- api : tile
-  args : (Tensor x, ScalarArray repeat_times)
-  output : Tensor
-  infer_meta :
-    func : TileInferMeta
-  kernel :
-    func : tile
-  backward : tile_grad
+# # tile
+# - api : tile
+#   args : (Tensor x, ScalarArray repeat_times)
+#   output : Tensor
+#   infer_meta :
+#     func : TileInferMeta
+#   kernel :
+#     func : tile
+#   backward : tile_grad
 
-# top_k
-- api : top_k
-  args : (Tensor x, Scalar k, int axis, bool largest, bool sorted)
-  output : Tensor(out), Tensor(indices)
-  infer_meta :
-    func : TopkInferMeta
-  kernel :
-    func : top_k
-  backward : top_k_grad
+# # top_k
+# - api : top_k
+#   args : (Tensor x, Scalar k, int axis, bool largest, bool sorted)
+#   output : Tensor(out), Tensor(indices)
+#   infer_meta :
+#     func : TopkInferMeta
+#   kernel :
+#     func : top_k
+#   backward : top_k_grad
 
-# trace
-- api : trace
-  args : (Tensor x, int offset, int axis1, int axis2)
-  output : Tensor
-  infer_meta :
-    func : TraceInferMeta
-  kernel :
-    func : trace
-  backward : trace_grad
+# # trace
+# - api : trace
+#   args : (Tensor x, int offset, int axis1, int axis2)
+#   output : Tensor
+#   infer_meta :
+#     func : TraceInferMeta
+#   kernel :
+#     func : trace
+#   backward : trace_grad
 
-# phi_transfer_layout | not have python api
+# # phi_transfer_layout | not have python api
 
-# truncated_gaussian_random
-- api : truncated_gaussian_random
-  args : (int[] shape, float mean, float std, int seed, DataType dtype)
-  output : Tensor
-  infer_meta :
-    func : TruncatedGaussianRandomInferMeta
-  kernel :
-    func : truncated_gaussian_random
+# # truncated_gaussian_random
+# - api : truncated_gaussian_random
+#   args : (int[] shape, float mean, float std, int seed, DataType dtype)
+#   output : Tensor
+#   infer_meta :
+#     func : TruncatedGaussianRandomInferMeta
+#   kernel :
+#     func : truncated_gaussian_random
 
-# unbind
-- api : unbind
-  args : (Tensor x, int axis)
-  output : Tensor[]
-  infer_meta :
-    func : UnbindInferMeta
-  kernel :
-    func : unbind
+# # unbind
+# - api : unbind
+#   args : (Tensor x, int axis)
+#   output : Tensor[]
+#   infer_meta :
+#     func : UnbindInferMeta
+#   kernel :
+#     func : unbind
 
-# unfold
-- api : unfold
-  args : (Tensor x, int[] kernel_sizes, int[] strides, int[] paddings, int[] dilations)
-  output : Tensor
-  infer_meta :
-    func : UnfoldInferMeta
-  kernel :
-    func : unfold
-  backward : unfold_grad
-
-# uniform_random_raw selected rows ??
-# viterbi_decode
-- api : viterbi_decode
-  args : (Tensor input, Tensor transition, Tensor length, bool include_bos_eos_tag)
-  output : Tensor(scores), Tensor(path)
-  infer_meta :
-    func : ViterbiDecodeInferMeta
-  kernel :
-    func : viterbi_decode
+# # unfold
+# - api : unfold
+#   args : (Tensor x, int[] kernel_sizes, int[] strides, int[] paddings, int[] dilations)
+#   output : Tensor
+#   infer_meta :
+#     func : UnfoldInferMeta
+#   kernel :
+#     func : unfold
+#   backward : unfold_grad
+
+# # uniform_random_raw selected rows ??
+# # viterbi_decode
+# - api : viterbi_decode
+#   args : (Tensor input, Tensor transition, Tensor length, bool include_bos_eos_tag)
+#   output : Tensor(scores), Tensor(path)
+#   infer_meta :
+#     func : ViterbiDecodeInferMeta
+#   kernel :
+#     func : viterbi_decode
 
-# where_index
-- api : where_index
-  args : (Tensor condition)
-  output : Tensor
-  infer_meta :
-    func : WhereIndexInferMeta
-  kernel :
-    func : where_index
+# # where_index
+# - api : where_index
+#   args : (Tensor condition)
+#   output : Tensor
+#   infer_meta :
+#     func : WhereIndexInferMeta
+#   kernel :
+#     func : where_index
 
 
-# yolo_box
-- api : yolo_box
-  args : (Tensor x, Tensor img_size, int[] anchors, int class_num, float conf_thresh, int downsample_ratio, bool clip_bbox, float scale_x_y, bool iou_aware, float iou_aware_factor)
-  output : Tensor(boxes), Tensor(scores)
-  infer_meta :
-    func : YoloBoxInferMeta
-  kernel :
-    func : yolo_box
+# # yolo_box
+# - api : yolo_box
+#   args : (Tensor x, Tensor img_size, int[] anchors, int class_num, float conf_thresh, int downsample_ratio, bool clip_bbox, float scale_x_y, bool iou_aware, float iou_aware_factor)
+#   output : Tensor(boxes), Tensor(scores)
+#   infer_meta :
+#     func : YoloBoxInferMeta
+#   kernel :
+#     func : yolo_box

python/paddle/utils/code_gen/api_gen.py

@@ -147,6 +147,7 @@ def source_include(header_file_path):
 #include "paddle/phi/infermeta/multiary.h"
 #include "paddle/phi/infermeta/nullary.h"
 #include "paddle/phi/infermeta/unary.h"
+#include "paddle/phi/infermeta/ternary.h"
 """
 
 

python/paddle/utils/code_gen/backward.yaml

@@ -101,66 +101,66 @@
   kernel :
     func : softmax_grad
 
-- backward_api : maxout_grad
-  forward : maxout (Tensor x, int groups, int axis) -> Tensor(out)
-  args : (Tensor x, Tensor out, Tensor out_grad, int groups, int axis)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [x]
-  kernel :
-    func : maxout_grad
+# - backward_api : maxout_grad
+#   forward : maxout (Tensor x, int groups, int axis) -> Tensor(out)
+#   args : (Tensor x, Tensor out, Tensor out_grad, int groups, int axis)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : maxout_grad
 
 
-- backward_api : put_along_axis_grad
-  forward : put_along_axis (Tensor x, Tensor index, Tensor value, int axis, string reduce) -> Tensor(out)
-  args : (Tensor x, Tensor index, Tensor out_grad, int axis, string reduce)
-  output : Tensor(x_grad), Tensor(value_grad)
-  infer_meta :
-    func : GeneralBinaryGradInferMeta
-    param : [x, valule]
-  kernel :
-    func : put_along_axis_grad
+# - backward_api : put_along_axis_grad
+#   forward : put_along_axis (Tensor x, Tensor index, Tensor value, int axis, string reduce) -> Tensor(out)
+#   args : (Tensor x, Tensor index, Tensor out_grad, int axis, string reduce)
+#   output : Tensor(x_grad), Tensor(value_grad)
+#   infer_meta :
+#     func : GeneralBinaryGradInferMeta
+#     param : [x, valule]
+#   kernel :
+#     func : put_along_axis_grad
 
-- backward_api : take_along_axis_grad
-  forward : take_along_axis (Tensor x, Tensor index, int axis) -> Tensor(out)
-  args : (Tensor x, Tensor index, Tensor out_grad, int axis)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [x]
-  kernel :
-    func : take_along_axis_grad
+# - backward_api : take_along_axis_grad
+#   forward : take_along_axis (Tensor x, Tensor index, int axis) -> Tensor(out)
+#   args : (Tensor x, Tensor index, Tensor out_grad, int axis)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : take_along_axis_grad
 
-- backward_api : maxtrix_power_grad
-  forward : maxtrix_power (Tensor x, int n) -> Tensor(out)
-  args : (Tensor x, Tensor out, Tensor out_grad, int n)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [x]
-  kernel :
-    func : maxtrix_power_grad
+# - backward_api : maxtrix_power_grad
+#   forward : maxtrix_power (Tensor x, int n) -> Tensor(out)
+#   args : (Tensor x, Tensor out, Tensor out_grad, int n)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : maxtrix_power_grad
   
-- backward_api : eigh_grad
-  forward : eigh (Tensor x, string uplo) -> Tensor(out_w), Tensor(out_v)
-  args : (Tensor out_w, Tensor out_v, Tensor outw_grad, Tensor outv_grad)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : XXXXXXXInferMeta
-    param : [x]
-  kernel :
-    func : eigh_grad
+# - backward_api : eigh_grad
+#   forward : eigh (Tensor x, string uplo) -> Tensor(out_w), Tensor(out_v)
+#   args : (Tensor out_w, Tensor out_v, Tensor out_w_grad, Tensor out_v_grad)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [out_v]
+#   kernel :
+#     func : eigh_grad
 
-- backward_api : segment_pool_grad
-  forward : segment_pool (Tensor x, Tensor segment_ids, string pooltype) -> Tensor(out), Tensor(summed_ids)
-  args : (Tensor x, Tensor segment_ids, Tensor out, Tensor summed_ids, Tenosr out_grad, string pooltype)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [x]
-  kernel :
-    func : segment_pool_grad
+# - backward_api : segment_pool_grad
+#   forward : segment_pool (Tensor x, Tensor segment_ids, string pooltype) -> Tensor(out), Tensor(summed_ids)
+#   args : (Tensor x, Tensor segment_ids, Tensor out, Tensor summed_ids, Tenosr out_grad, string pooltype)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : segment_pool_grad
 
 - backward_api : cos_grad
   forward : cos (Tensor x) -> Tensor(out)
@@ -172,15 +172,15 @@
   kernel :
     func : cos_grad
 
-- backward_api : tan_grad
-  forward : tan (Tensor x) -> Tensor(out)
+- backward_api : tanh_grad
+  forward : tanh (Tensor x) -> Tensor(out)
   args : (Tensor out, Tensor out_grad)
   output : Tensor(x_grad)
   infer_meta :
     func : UnchangedInferMeta
     param : [out]
   kernel :
-    func : tam_grad
+    func : tanh_grad
 
 - backward_api : acos_grad
   forward : acos (Tensor x) -> Tensor(out)
@@ -282,53 +282,53 @@
   kernel :
     func : relu_grad
 
-- backward_api : argsort_grad
-  forward : argsort (Tensor x, int axis, bool descending) -> Tensor(out), tensor(indices)
-  args : (Tensor indices, Tensor x, Tensor out_grad, int axis, bool descending)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [x]
-  kernel :
-    func : argsort_grad
+# - backward_api : argsort_grad
+#   forward : argsort (Tensor x, int axis, bool descending) -> Tensor(out), tensor(indices)
+#   args : (Tensor indices, Tensor x, Tensor out_grad, int axis, bool descending)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : argsort_grad
 
 
-- backward_api : batch_norm_grad
-  forward : batch_norm (Tensor x, Tensor scale, Tensor bias, Tensor mean, Tensor variance, float momentum, float epsilon, string data_layout, bool is_test, bool use_global_stats, bool trainable_statistics, bool fuse_with_relu) -> Tensor(out), Tensor(mean_out), Tensor(variance_out), Tensor(saved_mean), Tensor(saved_variance), Tensor(reserve_space)
-  args : (Tensor indices, Tensor x, Tensor out_grad, int axis, bool descending)
-  output : Tensor(x_grad), Tensor(scale_grad), Tensor(bias_grad)
-  infer_meta :
-    func : GeneralTernaryGradInferMeta
-    param : [x, scale, bias]
-  kernel :
-    func : batch_norm_grad
+# - backward_api : batch_norm_grad
+#   forward : batch_norm (Tensor x, Tensor scale, Tensor bias, Tensor mean, Tensor variance, float momentum, float epsilon, string data_layout, bool is_test, bool use_global_stats, bool trainable_statistics, bool fuse_with_relu) -> Tensor(out), Tensor(mean_out), Tensor(variance_out), Tensor(saved_mean), Tensor(saved_variance), Tensor(reserve_space)
+#   args : (Tensor indices, Tensor x, Tensor out_grad, int axis, bool descending)
+#   output : Tensor(x_grad), Tensor(scale_grad), Tensor(bias_grad)
+#   infer_meta :
+#     func : GeneralTernaryGradInferMeta
+#     param : [x, scale, bias]
+#   kernel :
+#     func : batch_norm_grad
 
-- backward_api : bilinear_tensor_product_grad
-  forward : bilinear_tensor_product (Tensor x, Tensor y, Tensor weight, Tensor bias) -> Tensor(out)
-  args : (Tensor x, Tensor y, Tensor weight, Tensor out_grad)
-  output : Tensor(x_grad), Tensor(y_grad), Tensor(weight_grad), Tensor(bias_grad)
-  infer_meta :
-    func : FourXXXXInferMeta
-    param : [x, y, weight, bias]
-  kernel :
-    func : bilinear_tensor_product_grad
+# - backward_api : bilinear_tensor_product_grad
+#   forward : bilinear_tensor_product (Tensor x, Tensor y, Tensor weight, Tensor bias) -> Tensor(out)
+#   args : (Tensor x, Tensor y, Tensor weight, Tensor out_grad)
+#   output : Tensor(x_grad), Tensor(y_grad), Tensor(weight_grad), Tensor(bias_grad)
+#   infer_meta :
+#     func : FourXXXXInferMeta
+#     param : [x, y, weight, bias]
+#   kernel :
+#     func : bilinear_tensor_product_grad
 
-- backward_api : broadcast_tensor_grad
-  forward : broadcast_tensors (Tensor[] x) -> Tensor [] (out)
-  args : (Tensor [] out_grad)
-  output : Tensor [] (x_grad)
-  infer_meta :
-    func : XXXXInferMeta
-    param : [out_grad]
-  kernel :
-    func : broadcast_tensor_grad
+# - backward_api : broadcast_tensor_grad
+#   forward : broadcast_tensors (Tensor[] x) -> Tensor [] (out)
+#   args : (Tensor [] out_grad)
+#   output : Tensor [] (x_grad)
+#   infer_meta :
+#     func : XXXXInferMeta
+#     param : [out_grad]
+#   kernel :
+#     func : broadcast_tensor_grad
 
 - backward_api : cholesky_grad
   forward : cholesky (Tensor x, bool upper) -> Tensor(out)
   args : (Tensor out, Tensor out_grad, bool upper)
   output : Tensor(x_grad)
   infer_meta :
-    func : XXXXGradInferMeta
+    func : UnchangedInferMeta
     param : [out]
   kernel :
     func : cholesky_grad
@@ -338,230 +338,230 @@
   args : (Tensor x, Tensor y, Tensor out, Tensor out_grad, bool upper)
   output : Tensor(x_grad), Tensor(y_grad)
   infer_meta :
-    func : GenerateBinnaryGradInferMeta
+    func : GeneralBinaryGradInferMeta
     param : [x, y]
   kernel :
     func : cholesky_solve_grad
 
-- backward_api : dropout_grad
-  forward : dropout (Tensor x, Tensor seed_tensor, float p, bool is_test, string mode, int seed, bool fix_seed) -> Tensor(out), Tensor(mask)
-  args : (Tensor mask, Tensor out_grad, float p, bool is_test, string mode)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [out_grad]
-  kernel :
-    func : dropout_grad
+# - backward_api : dropout_grad
+#   forward : dropout (Tensor x, Tensor seed_tensor, float p, bool is_test, string mode, int seed, bool fix_seed) -> Tensor(out), Tensor(mask)
+#   args : (Tensor mask, Tensor out_grad, float p, bool is_test, string mode)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [out_grad]
+#   kernel :
+#     func : dropout_grad
 
 
-- backward_api : erf_grad
-  forward : erf (Tensor x) -> Tensor(out)
-  args : (Tensor x, Tensor out, Tensor out_grad)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [x]
-  kernel :
-    func : erf_grad
+# - backward_api : erf_grad
+#   forward : erf (Tensor x) -> Tensor(out)
+#   args : (Tensor x, Tensor out, Tensor out_grad)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : erf_grad
   
-- backward_api : erfinv_grad
-  forward : erf (Tensor x) -> Tensor(out)
-  args : (Tensor out, Tensor out_grad)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : ErfinvGradInferMeta
-    param : [out]
-  kernel :
-    func : erfinv_grad
+# - backward_api : erfinv_grad
+#   forward : erf (Tensor x) -> Tensor(out)
+#   args : (Tensor out, Tensor out_grad)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : ErfinvGradInferMeta
+#     param : [out]
+#   kernel :
+#     func : erfinv_grad
 
-- backward_api : expand_as_grad
-  forward : expand_as (Tensor x, Tensor y, int[] target_shape) -> Tensor(out)
-  args : (Tensor x, Tensor out_grad, int[] target_shape)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedGradInferMeta
-    param : [x]
-  kernel :
-    func : expand_as_grad
+# - backward_api : expand_as_grad
+#   forward : expand_as (Tensor x, Tensor y, int[] target_shape) -> Tensor(out)
+#   args : (Tensor x, Tensor out_grad, int[] target_shape)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedGradInferMeta
+#     param : [x]
+#   kernel :
+#     func : expand_as_grad
 
-- backward_api : expand_grad
-  forward : expand (Tensor x, ScalarArray shape) -> Tensor(out)
-  args : (Tensor x, Tensor out_grad, ScalarArray shape)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedGradInferMeta
-    param : [x]
-  kernel :
-    func : expand_grad
+# - backward_api : expand_grad
+#   forward : expand (Tensor x, ScalarArray shape) -> Tensor(out)
+#   args : (Tensor x, Tensor out_grad, ScalarArray shape)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedGradInferMeta
+#     param : [x]
+#   kernel :
+#     func : expand_grad
 
-- backward_api : graph_send_recv_grad
-  forward : graph_send_recv (Tensor x, Tensor src_index, Tensor dst_index, string pool_type) -> Tensor(out), Tensor(dst_count)
-  args : (Tensor out_grad, Tensor x, Tensor out, Tensor src_index, Tensor dst_index, Tensor dst_count, string pool_type)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedGradInferMeta
-    param : [x]
-  kernel :
-    func : graph_send_recv_grad
+# - backward_api : graph_send_recv_grad
+#   forward : graph_send_recv (Tensor x, Tensor src_index, Tensor dst_index, string pool_type) -> Tensor(out), Tensor(dst_count)
+#   args : (Tensor out_grad, Tensor x, Tensor out, Tensor src_index, Tensor dst_index, Tensor dst_count, string pool_type)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedGradInferMeta
+#     param : [x]
+#   kernel :
+#     func : graph_send_recv_grad
 
-- backward_api : label_smooth_grad
-  forward : label_smooth (Tensor label, Tensor prior_dist, float epsilon) -> Tensor(out)
-  args : (Tensor out_grad, float epsilon)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : XXXXInferMeta
-    param : [x]
-  kernel :
-    func : label_smooth_grad
+# - backward_api : label_smooth_grad
+#   forward : label_smooth (Tensor label, Tensor prior_dist, float epsilon) -> Tensor(out)
+#   args : (Tensor out_grad, float epsilon)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : XXXXInferMeta
+#     param : [x]
+#   kernel :
+#     func : label_smooth_grad
   
-- backward_api : log_loss_grad
-  forward : log_loss (Tensor input, Tensor label, float epsilon) -> Tensor(out)
-  args : (Tensor input, Tensor label, Tensor out_grad, float epsilon)
-  output : Tensor(input_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [x]
-  kernel :
-    func : log_loss_grad
+# - backward_api : log_loss_grad
+#   forward : log_loss (Tensor input, Tensor label, float epsilon) -> Tensor(out)
+#   args : (Tensor input, Tensor label, Tensor out_grad, float epsilon)
+#   output : Tensor(input_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : log_loss_grad
 
-- backward_api : masked_selecte_grad
-  forward : masked_select (Tensor x, Tensor mask) -> Tensor(out)
-  args : (Tensor out_grad, Tensor x, Tensor mask)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [x]
-  kernel :
-    func : masked_selecte_grad
+# - backward_api : masked_selecte_grad
+#   forward : masked_select (Tensor x, Tensor mask) -> Tensor(out)
+#   args : (Tensor out_grad, Tensor x, Tensor mask)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : masked_selecte_grad
 
-- backward_api : multi_dot_grad
-  forward : multi_dot (Tensor[] x) -> Tensor(out)
-  args : (Tensor out_grad, Tensor[] x)
-  output : Tensor[] (x_grad)
-  infer_meta :
-    func : XXXXInferMeta
-    param : [x]
-  kernel :
-    func : multi_dot_grad
+# - backward_api : multi_dot_grad
+#   forward : multi_dot (Tensor[] x) -> Tensor(out)
+#   args : (Tensor out_grad, Tensor[] x)
+#   output : Tensor[] (x_grad)
+#   infer_meta :
+#     func : XXXXInferMeta
+#     param : [x]
+#   kernel :
+#     func : multi_dot_grad
 
-- backward_api : nll_loss_grad
-  forward : nll_loss (Tensor input, Tensor label, Tensor weight, int64_t ignore_index, string reduction) -> Tensor(out), Tensor(total_weight)
-  args : (Tensor x, Tensor label, Tensor total_weight, Tensor weight, Tensor out_grad, int64_t ignore_index, string reduction)
-  output : Tensor[] (x_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [x]
-  kernel :
-    func : nll_loss_grad
+# - backward_api : nll_loss_grad
+#   forward : nll_loss (Tensor input, Tensor label, Tensor weight, int64_t ignore_index, string reduction) -> Tensor(out), Tensor(total_weight)
+#   args : (Tensor x, Tensor label, Tensor total_weight, Tensor weight, Tensor out_grad, int64_t ignore_index, string reduction)
+#   output : Tensor[] (x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : nll_loss_grad
   
-- backward_api : pad_grad
-  forward : pad (Tensor x, int[] paddings, float pad_value) -> Tensor(out)
-  args : (Tensor out_grad, int[] paddings, float pad_value)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : XXXXXInferMeta
-    param : [x]
-  kernel :
-    func : pad_grad
+# - backward_api : pad_grad
+#   forward : pad (Tensor x, int[] paddings, float pad_value) -> Tensor(out)
+#   args : (Tensor out_grad, int[] paddings, float pad_value)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : XXXXXInferMeta
+#     param : [x]
+#   kernel :
+#     func : pad_grad
 
-- backward_api : pixel_shuffle_grad
-  forward : pixel_shuffle (Tensor x, int upscale_factor, string data_format) -> Tensor(out)
-  args : (Tensor out_grad, int upscale_factor, string data_format)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : XXXXXInferMeta
-    param : [x]
-  kernel :
-    func : pixel_shuffle_grad
+# - backward_api : pixel_shuffle_grad
+#   forward : pixel_shuffle (Tensor x, int upscale_factor, string data_format) -> Tensor(out)
+#   args : (Tensor out_grad, int upscale_factor, string data_format)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : XXXXXInferMeta
+#     param : [x]
+#   kernel :
+#     func : pixel_shuffle_grad
 
-- backward_api : poisson_grad
-  forward : poisson (Tensor x) -> Tensor(out)
-  args : ()
-  output : Tensor(x_grad)
-  infer_meta :
-    func : XXXXXInferMeta
-    param : [x]
-  kernel :
-    func : poisson_grad
+# - backward_api : poisson_grad
+#   forward : poisson (Tensor x) -> Tensor(out)
+#   args : ()
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : XXXXXInferMeta
+#     param : [x]
+#   kernel :
+#     func : poisson_grad
 
-- backward_api : psroi_pool_grad
-  forward : psroi_pool (Tensor x, Tensor rois, Tensor rois_num, int pooled_weight, int pooled_width, int output_channels, float spatial_scale ) -> Tensor(out)
-  args : (Tensor x, Tensor rois, Tensor rois_num, Tensor out_grad, int pooled_weight, int pooled_width, int output_channels, float spatial_scale)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [x]
-  kernel :
-    func : psroi_pool_grad
+# - backward_api : psroi_pool_grad
+#   forward : psroi_pool (Tensor x, Tensor rois, Tensor rois_num, int pooled_weight, int pooled_width, int output_channels, float spatial_scale ) -> Tensor(out)
+#   args : (Tensor x, Tensor rois, Tensor rois_num, Tensor out_grad, int pooled_weight, int pooled_width, int output_channels, float spatial_scale)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : psroi_pool_grad
 
-- backward_api : selu_grad
-  forward : selu (Tensor x, float scale, float alpha) -> Tensor(out)
-  args : (Tensor out, Tensor out_grad, float scale, float alpha)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : XXXXXInferMeta
-    param : [x]
-  kernel :
-    func : selu_grad
+# - backward_api : selu_grad
+#   forward : selu (Tensor x, float scale, float alpha) -> Tensor(out)
+#   args : (Tensor out, Tensor out_grad, float scale, float alpha)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : XXXXXInferMeta
+#     param : [x]
+#   kernel :
+#     func : selu_grad
 
-- backward_api : sigmoid_cross_entropy_with_logits_grad
-  forward : sigmoid_cross_entropy_with_logits (Tensor x, Tensor label, bool normalize, int ignore_index) -> Tensor(out)
-  args : (Tensor x, Tensor label, Tensor out_grad, bool normalize, int ingore_index)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [x]
-  kernel :
-    func : sigmoid_cross_entropy_with_logits_grad
+# - backward_api : sigmoid_cross_entropy_with_logits_grad
+#   forward : sigmoid_cross_entropy_with_logits (Tensor x, Tensor label, bool normalize, int ignore_index) -> Tensor(out)
+#   args : (Tensor x, Tensor label, Tensor out_grad, bool normalize, int ingore_index)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : sigmoid_cross_entropy_with_logits_grad
 
-- backward_api : tile_grad
-  forward : tile (Tensor x, ScalarArray repeat_times) -> Tensor(out)
-  args : (Tensor x, Tensor out_grad, ScalarArray repeat_times)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [x]
-  kernel :
-    func : tile_grad
+# - backward_api : tile_grad
+#   forward : tile (Tensor x, ScalarArray repeat_times) -> Tensor(out)
+#   args : (Tensor x, Tensor out_grad, ScalarArray repeat_times)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : tile_grad
 
-# forward backward type not match
-- backward_api : top_k_grad 
-  forward : top_k (Tensor x, Scalar k, int axis, bool largest, bool sorted) -> Tensor(out), Tensor(indices)
-  args : (Tensor out_grad, Tensor x, Tensor indices, int k, index axis, bool largest, bool sorted)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [x]
-  kernel :
-    func : top_k_grad
+# # forward backward type not match
+# - backward_api : top_k_grad 
+#   forward : top_k (Tensor x, Scalar k, int axis, bool largest, bool sorted) -> Tensor(out), Tensor(indices)
+#   args : (Tensor out_grad, Tensor x, Tensor indices, int k, index axis, bool largest, bool sorted)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : top_k_grad
 
 
-- backward_api : trace_grad 
-  forward : trace (Tensor x, int offset, int axis1, int axis2) -> Tensor(out)
-  args : (Tensor out_grad, Tensor x, int offset, int axis1, int axis2)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [x]
-  kernel :
-    func : trace_grad
+# - backward_api : trace_grad 
+#   forward : trace (Tensor x, int offset, int axis1, int axis2) -> Tensor(out)
+#   args : (Tensor out_grad, Tensor x, int offset, int axis1, int axis2)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : trace_grad
 
-- backward_api : unfold_grad 
-  forward : unfold (Tensor x, int[] kernel_sizes, int[] strides, int[] paddings, int[] dilations) -> Tensor(out)
-  args : (Tensor x, Tensor out_grad, int[] kernel_sizes, int[] strides, int[] paddings, int[] dilations)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [x]
-  kernel :
-    func : unfold_grad
+# - backward_api : unfold_grad 
+#   forward : unfold (Tensor x, int[] kernel_sizes, int[] strides, int[] paddings, int[] dilations) -> Tensor(out)
+#   args : (Tensor x, Tensor out_grad, int[] kernel_sizes, int[] strides, int[] paddings, int[] dilations)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : unfold_grad
 
-- backward_api : where_index_grad 
-  forward : where_index (Tensor condition) -> Tensor(out)
-  args : (Tensor out_grad, Tensor x, int offset, int axis1, int axis2)
-  output : Tensor(x_grad)
-  infer_meta :
-    func : UnchangedInferMeta
-    param : [x]
-  kernel :
-    func : trace_grad
+# - backward_api : where_index_grad 
+#   forward : where_index (Tensor condition) -> Tensor(out)
+#   args : (Tensor out_grad, Tensor x, int offset, int axis1, int axis2)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : trace_grad

python/paddle/utils/code_gen/wrapped_infermeta_gen.py

@@ -98,6 +98,7 @@ def source_include(header_file_path):
 #include "paddle/phi/infermeta/multiary.h"
 #include "paddle/phi/infermeta/nullary.h"
 #include "paddle/phi/infermeta/unary.h"
+#include "paddle/phi/infermeta/ternary.h"
 """