[Eager]Add sort-simple-yaml for automatically sort api|backward.yaml (#41038)

* [Eager]Add sort-simple-yaml for automatically sort api|backward.yaml

* remove it test=document_fix

* refine

* add more yaml

* remove optional

* fix infRT CI

.pre-commit-config.yaml

@@ -10,7 +10,7 @@ repos:
     -   id: yapf
         files: (.*\.(py|bzl)|BUILD|.*\.BUILD|WORKSPACE)$
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    sha: 5bf6c09bfa1297d3692cadd621ef95f1284e33c0
+    rev: v4.1.0
     hooks:
     -   id: check-added-large-files
     -   id: check-merge-conflict
@@ -18,6 +18,8 @@ repos:
     -   id: detect-private-key
         files: (?!.*third_party)^.*$ | (?!.*book)^.*$
     -   id: end-of-file-fixer
+    -   id: sort-simple-yaml
+        files: (api|backward)\.yaml$
 -   repo: local
     hooks:
     -   id: clang-format-with-version-check

python/paddle/utils/code_gen/api.yaml

+# - api : norm
+#   args : (Tensor x, int axis, float epsilon, bool is_test)
+#   output : Tensor(out), Tensor(norm)
+#   infer_meta :
+#     func : NormInferMeta
+#   kernel :
+#     func : norm
+#   intermediate : norm
+#   backward : norm_grad
+
+# # maxout
+# - api : maxout
+#   args : (Tensor x, int groups, int axis)
+#   output : Tensor
+#   infer_meta :
+#     func : MaxoutInferMeta
+#   kernel :
+#     func : maxout
+#   backward : maxout_grad
+
+# # batch_norm
+# - api : batch_norm
+#   args : (Tensor x, Tensor scale, Tensor bias, Tensor mean, Tensor variance, float momentum, float epsilon, str 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
+
+# # 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
+#   optional : bias
+
+# broadcast_tensors
+# - api : broadcast_tensors
+#   args : (Tensor[] x)
+#   output : Tensor[]
+#   infer_meta :
+#     func : BroadcastTensorsInferMeta
+#   kernel :
+#     func : broadcast_tensors
+#   backward : broadcast_tensors_grad
+
+# # dropout
+# - api : dropout
+#   args : (Tensor x, Tensor seed_tensor, float p, bool is_test, str mode, int seed, bool fix_seed)
+#   output : Tensor(out), Tensor(mask)
+#   infer_meta :
+#     func : DropoutInferMeta
+#   kernel :
+#     func : dropout
+
+# # expand
+# - api : expand
+#   args : (Tensor x, ScalarArray shape)
+#   output : Tensor
+#   infer_meta :
+#     func : ExpandInferMeta
+#   kernel :
+#     func : expand
+#   backward : expand_grad
+
+# eye
+# - api : eye
+#   args : (int64_t num_rows, int64_t num_colums, DataType dtype = DataType::FLOAT32)
+#   output : Tensor
+#   infer_meta :
+#     func : EyeInferMeta
+#   kernel :
+#     func : eye
+
+# gaussian_random
+# - api : gaussian_random
+#   args : (ScalarArray shape, float mean, float std, int seed, DataType dtype=DataType::FLOAT32)
+#   output : Tensor
+#   infer_meta :
+#     func : CreateInferMeta
+#     param : [shape, dtype]
+#   kernel :
+#     func : gaussian_random
+#     data_type : dtype
+
+# # graph_send_recv
+# - api : graph_send_recv
+#   args : (Tensor x, Tensor src_index, Tensor dst_index, str pool_type)
+#   output : Tensor(out), Tensor(dst_count)
+#   infer_meta :
+#     func : GraphSendRecvInferMeta
+#   kernel :
+#     func : graph_send_recv
+#   backward : graph_send_recv_grad
+
+# # label_smooth
+# - api : label_smooth
+#   args : (Tensor label, Tensor prior_dist, float epsilon)
+#   output : Tensor
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [label]
+#   kernel :
+#     func : label_smooth
+#     data_type : label
+#   optional : prior_dist
+#   backward : label_smooth_grad
+
+# linspace start stop number
+# - api : linspace
+#   args : (Tensor start, Tensor stop, Tensor number, DataType dtype=DataType::FLOAT32)
+#   output : Tensor
+#   infer_meta :
+#     func : LinspaceInferMeta
+#   kernel :
+#     func : linspace
+
+# # multi_dot
+# - api : multi_dot
+#   args : (Tensor[] x)
+#   output : Tensor
+#   infer_meta :
+#     func : MultiDotInferMeta
+#   kernel :
+#     func : multi_dot
+#   backward : multi_dot_grad
+
+# # nll_loss
+# - api : nll_loss
+#   args : (Tensor x, Tensor label, Tensor weight, int64_t ignore_index, str reduction)
+#   output : Tensor(out), Tensor(total_weight)
+#   infer_meta :
+#     func : NllLossRawInferMeta
+#   kernel :
+#     func : nll_loss
+#     data_type : x
+#   optional : weight
+#   backward : nll_loss_grad
+
+# # psroi_pool
+# - 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
+#   optional : rois_num
+
+# # randint
+# - api : randint
+#   args : (int low, int high, ScalarArray shape, DataType dtype)
+#   output : Tensor
+#   infer_meta :
+#     func : RandintInferMeta
+#   kernel :
+#     func : randint
+
+# # randperm
+# - 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
+
+# # top_k
+# - api : top_k
+#   args : (Tensor x, Scalar k, int axis = -1, bool largest = true, bool sorted = true)
+#   output : Tensor(out), Tensor(indices)
+#   infer_meta :
+#     func : TopKInferMeta
+#   kernel :
+#     func : top_k
+#   backward : top_k_grad
+
+# # 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
+
+# # unbind
+# - api : unbind
+#   args : (Tensor x, int axis)
+#   output : Tensor[]
+#   infer_meta :
+#     func : UnbindInferMeta
+#   kernel :
+#     func : unbind
+
+# # uniform_random_raw selected rows ??
+
+# - api : pixel_shuffle
+#   args : (Tensor x, int upscale_factor, const std::string& data_format)
+#   output : Tensor
+#   infer_meta :
+#     func : PixelShuffleInferMeta
+#   kernel :
+#     func : pixel_shuffle
+
+# BilinearTensorProductInferMeta
+
+# BroadcastTensorsInferMeta
+
+# bincount
+# - api : bincount
+#   args : (Tensor x, Tensor weight, int minlength)
+#   output : Tensor
+#   infer_meta :
+#     func : BincountInferMeta
+#   kernel :
+#     func : bincount
+#   optional : weight
+
+# expand_as
+# - api : expand_as
+#   args : (Tensor x, Tensor y, int[] target_shape)
+#   output : Tensor
+#   infer_meta :
+#     func : ExpandAsInferMeta
+#   kernel :
+#     func : expand_as
+#   optional : y
+#   # backward : expand_as_grad
+#   # optional : y
+
+# - api : equal_all
+#   args : (Tensor x, Tensor y)
+#   output : Tensor
+#   infer_meta :
+#     func : CompareAllInferMeta
+#   kernel :
+#     func : equal_all
+
+# histogram
+# - api : histogram
+#   args : (Tensor x, int64_t bins, int min, int max)
+#   output : Tensor
+#   infer_meta :
+#     func : HistogramInferMeta
+#   kernel :
+#     func : histogram
+
+- api : abs
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : abs
+  backward : abs_grad
+
+# accuracy
+- api : accuracy
+  args : (Tensor x, Tensor indices, Tensor label)
+  output : Tensor(accuracy), Tensor(correct), Tensor(total)
+  infer_meta :
+    func : AccuracyInferMeta
+  kernel :
+    func : accuracy
+    dtype : x
+
+# acos
+- api : acos
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : acos
+  backward : acos_grad
+
+# acosh
+- api : acosh
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : acosh
+  backward : acosh_grad
+
+- api : adadelta
+  args : (Tensor param, Tensor grad, Tensor avg_squared_grad, Tensor avg_squared_update, float rho, float epsilon)
+  output : Tensor(param_out), Tensor(moment_out), Tensor(inf_norm_out)
+  infer_meta :
+    func : AdadeltaInferMeta
+  kernel :
+    func : adadelta
+
+- api : adamax
+  args : (Tensor param, Tensor grad, Tensor learning_rate, Tensor moment, Tensor inf_norm, Tensor beta1_pow, float beta1, float beta2, float epsilon)
+  output : Tensor(param_out), Tensor(avg_squared_grad_out), Tensor(avg_squared_update_out)
+  infer_meta :
+    func : AdamaxInferMeta
+  kernel :
+    func : adamax
+
 - api : add
   args : (Tensor x, Tensor y)
   output : Tensor
   infer_meta :
-    func : ElementwiseInferMeta
+    func : ElementwiseInferMeta
+  kernel :
+    func : add
+  backward : add_grad
+  # no_need_buffer : x, y
+
+- api : addmm
+  args : (Tensor input, Tensor x, Tensor y, float alpha, float beta)
+  output : Tensor
+  infer_meta :
+    func : AddmmInferMeta
+  kernel :
+    func : addmm
+  backward : addmm_grad
+
+# arg_max
+- api : argmax
+  args : (Tensor x, int64_t axis, bool keepdims, bool flatten, int dtype)
+  output : Tensor
+  infer_meta :
+    func : ArgMinMaxInferMeta
+  kernel :
+    func : arg_max
+
+# arg_min
+- api : argmin
+  args : (Tensor x, int64_t axis, bool keepdims, bool flatten, int dtype)
+  output : Tensor
+  infer_meta :
+    func : ArgMinMaxInferMeta
+  kernel :
+    func : arg_min
+
+# argsort
+- api : argsort
+  args : (Tensor x, int axis, bool descending)
+  output : Tensor(out), Tensor(indices)
+  infer_meta :
+    func : ArgsortInferMeta
+  kernel :
+    func : argsort
+  backward : argsort_grad
+  # no_need_buffer : x
+
+# asin
+- api : asin
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : asin
+  backward : asin_grad
+
+# asinh
+- api : asinh
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : asinh
+  backward : asinh_grad
+
+# atan
+- api : atan
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : atan
+  backward : atan_grad
+
+- api : atan2
+  args : (Tensor x, Tensor y)
+  output : Tensor
+  infer_meta :
+    func : Atan2InferMeta
+  kernel :
+    func : atan2
+  backward : atan2_grad
+
+# atanh
+- api : atanh
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : atanh
+  backward : atanh_grad
+
+# 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
+
+- api : bce_loss
+  args : (Tensor input, Tensor label)
+  output : Tensor
+  infer_meta :
+    func : BCELossInferMeta
+  kernel :
+    func : bce_loss
+  backward : bce_loss_grad
+
+# bernoulli
+- api : bernoulli
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : bernoulli
+
+# bitwise_and
+- api : bitwise_and
+  args : (Tensor x, Tensor y)
+  output : Tensor
+  infer_meta :
+    func : ElementwiseInferMeta
+  kernel :
+    func : bitwise_and
+
+# bitwise_not
+- api : bitwise_not
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : bitwise_not
+
+# bitwise_or
+- api : bitwise_or
+  args : (Tensor x, Tensor y)
+  output : Tensor
+  infer_meta :
+    func : ElementwiseInferMeta
+  kernel :
+    func : bitwise_or
+
+# bitwise_xor
+- api : bitwise_xor
+  args : (Tensor x, Tensor y)
+  output : Tensor
+  infer_meta :
+    func : ElementwiseInferMeta
+  kernel :
+    func : bitwise_xor
+
+# brelu
+- api : brelu
+  args : (Tensor x, float t_min, float t_max)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : brelu
+  backward : brelu_grad
+
+- api : cast
+  args : (Tensor x, DataType out_dtype)
+  output : Tensor
+  infer_meta :
+    func : CastInferMeta
+  kernel :
+    func : cast
+    param : [x, out_dtype]
+    data_type : x
+  backward : cast_grad
+
+# cholesky
+- api : cholesky
+  args : (Tensor x, bool upper)
+  output : Tensor
+  infer_meta :
+    func : CholeskyInferMeta
+  kernel :
+    func : cholesky
+  backward : cholesky_grad
+
+# cholesky_solve
+- api : cholesky_solve
+  args : (Tensor x, Tensor y, bool upper)
+  output : Tensor
+  infer_meta :
+    func : CholeskySolveInferMeta
+  kernel :
+    func : cholesky_solve
+  backward : cholesky_solve_grad
+
+- api : concat
+  args : (Tensor[] x, Scalar(int64_t) axis)
+  output : Tensor
+  infer_meta :
+    func : ConcatInferMeta
+    param : [x, axis]
+  kernel :
+    func : concat
+
+- api : conj
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : conj
+
+- api : copy_to
+  args : (Tensor x, Place place, bool blocking)
+  output : Tensor
+  invoke : copy_to_impl(x, place, blocking)
+
+# cos
+- api : cos
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : cos
+  backward : cos_grad
+
+# cosh
+- api : cosh
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : cosh
+  backward : cosh_grad
+
+- api : cross
+  args : (Tensor x, Tensor y, int axis = 9)
+  output : Tensor
+  infer_meta :
+    func : CrossInferMeta
+  kernel :
+    func : cross
+  backward : cross_grad
+
+# cumsum
+- api : cumsum
+  args : (Tensor x, int axis, bool flatten, bool exclusive, bool reverse)
+  output : Tensor
+  infer_meta :
+    func : CumsumInferMeta
+  kernel :
+    func : cumsum
+
+- api : diag
+  args : (Tensor x, int offset, float padding_value)
+  output : Tensor
+  infer_meta :
+    func : DiagInferMeta
+  kernel :
+    func : diag
+
+- api : diagonal
+  args : (Tensor x, int offset, int axis1, int axis2)
+  output : Tensor
+  infer_meta :
+    func : DiagonalInferMeta
+  kernel :
+    func : diagonal
+  backward : diagonal_grad
+  # no_need_buffer : x
+
+- api : digamma
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : digamma
+  backward : digamma_grad
+
+- api : dist
+  args : (Tensor x, Tensor y, float p)
+  output : Tensor
+  infer_meta :
+    func : DistInferMeta
+  kernel :
+    func : dist
+  backward : dist_grad
+
+- api : divide
+  args : (Tensor x, Tensor y)
+  output : Tensor
+  infer_meta :
+    func : ElementwiseInferMeta
+  kernel :
+    func : divide
+  backward : divide_grad
+
+- api : dot
+  args : (Tensor x, Tensor y)
+  output : Tensor
+  infer_meta :
+    func : DotInferMeta
+  kernel :
+    func : dot
+
+# eigh
+- api : eigh
+  args : (Tensor x, str uplo)
+  output : Tensor(out_w), Tensor(out_v)
+  infer_meta :
+    func : EighInferMeta
+  kernel :
+    func : eigh
+  backward : eigh_grad
+
+# elu
+- api : elu
+  args : (Tensor x, float alpha)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : elu
+  backward : elu_grad
+
+- api : empty
+  args : (ScalarArray shape, DataType dtype=DataType::FLOAT32, Place place=CPUPlace())
+  output: Tensor
+  infer_meta :
+    func : CreateInferMeta
+    param : [shape, dtype]
+  kernel :
+    func : empty
+    param : [shape, dtype]
+    data_type : dtype
+    backend : place
+
+- api : empty_like
+  args : (Tensor x, DataType dtype = DataType::UNDEFINED, Place place = {})
+  output: Tensor
+  infer_meta :
+    func : CreateLikeInferMeta
+    param : [x, dtype]
+  kernel :
+    func : empty_like
+    param : [x, dtype]
+    data_type : dtype > x
+    backend : place > x
+
+- api : equal
+  args : (Tensor x, Tensor y, int axis = -1)
+  output : Tensor
+  infer_meta :
+    func : CompareInferMeta
+  kernel :
+    func : equal
+
+# erf
+- api : erf
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : erf
+  backward : erf_grad
+
+# erfinv
+- api : erfinv
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : erfinv
+  backward : erfinv_grad
+
+- api : flatten
+  args : (Tensor x, int start_axis, int stop_axis)
+  output : Tensor
+  infer_meta :
+    func : FlattenInferMeta
+  kernel :
+    func : flatten
+
+# flip
+- api : flip
+  args : (Tensor x, int[] axis)
+  output : Tensor
+  infer_meta :
+    func : FlipInferMeta
+  kernel :
+    func : flip
+
+- api : full
+  args : (ScalarArray shape, Scalar value, DataType dtype=DataType::FLOAT32, Place place=CPUPlace())
+  output: Tensor
+  infer_meta :
+    func : CreateInferMeta
+    param : [shape, dtype]
+  kernel :
+    func : full
+    param : [shape, value, dtype]
+    data_type : dtype
+    backend : place
+
+- api : full_like
+  args : (Tensor x, Scalar value, DataType dtype = DataType::UNDEFINED, Place place = {})
+  output: Tensor
+  infer_meta :
+    func : CreateLikeInferMeta
+    param : [x, dtype]
+  kernel :
+    func : full_like
+    param : [x, value, dtype]
+    data_type : dtype > x
+    backend : place > x
+
+- api : gather_nd
+  args : (Tensor x, Tensor index)
+  output : Tensor
+  infer_meta :
+    func : GatherNdInferMeta
+  kernel :
+    func : gather_nd
+    data_type : x
+  backward : gather_nd_grad
+
+- api : gather_tree
+  args : (Tensor ids, Tensor parents)
+  output : Tensor
+  infer_meta :
+    func : GatherTreeMeta
+  kernel :
+    func : gather_tree
+
+- api : greater
+  args : (Tensor x, Tensor y, int axis = -1)
+  output : Tensor
+  infer_meta :
+    func : CompareInferMeta
+  kernel :
+    func : greater
+
+- api : greater_equal
+  args : (Tensor x, Tensor y, int axis = -1)
+  output : Tensor
+  infer_meta :
+    func : CompareInferMeta
+  kernel :
+    func : greater_equal
+
+- api : gumbel_softmax
+  args : (Tensor x, float temperature, bool hard, int axis)
+  output : Tensor
+  infer_meta :
+    func : GumbelSoftmaxInferMeta
+  kernel :
+    func : gumbel_softmax
+  # backward : gumbel_softmax_grad
+
+# hard_shrink
+- api : hard_shrink
+  args : (Tensor x, float threshold)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
   kernel :
-    func : add
-  backward : add_grad
+    func : hard_shrink
+  backward : hard_shrink_grad
 
-- api : cast
-  args : (Tensor x, DataType out_dtype)
+# hard_sigmoid
+- api : hard_sigmoid
+  args : (Tensor x, float slope, float offset)
   output : Tensor
   infer_meta :
-    func : CastInferMeta
+    func : UnchangedInferMeta
+    param : [x]
   kernel :
-    func : cast
-    param : [x, out_dtype]
-    data_type : x
-  backward : cast_grad
+    func : hard_sigmoid
+  backward : hard_sigmoid_grad
 
+- api : huber_loss
+  args : (Tensor input, Tensor label, float delta)
+  output : Tensor(out), Tensor(residual)
+  infer_meta :
+    func : HuberLossInferMeta
+  kernel :
+    func : huber_loss
+  # backward : huber_loss_grad
 
-- api : concat
-  args : (Tensor[] x, Scalar(int64_t) axis)
+# increment
+- api : increment
+  args : (Tensor x, float value)
   output : Tensor
   infer_meta :
-    func : ConcatInferMeta
-    param : [x, axis]
+    func : IncrementInferMeta
   kernel :
-    func : concat
+    func : increment
 
-- api : conj
+- api : index_sample
+  args : (Tensor x, Tensor index)
+  output : Tensor
+  infer_meta :
+    func : IndexSampleInferMeta
+  kernel :
+    func : index_sample
+    data_type : x
+  backward : index_sample_grad
+  # no_need_buffer : x
+
+# is_empty
+- api : is_empty
   args : (Tensor x)
   output : Tensor
   infer_meta :
-    func : UnchangedInferMeta
+    func : IsEmptyInferMeta
   kernel :
-    func : conj
+    func : is_empty
 
-- api : copy_to
-  args : (Tensor x, Place place, bool blocking)
+# isfinite
+- api : isfinite
+  args : (Tensor x)
   output : Tensor
-  invoke : copy_to_impl(x, place, blocking)
+  infer_meta :
+    func : IsfiniteInferMeta
+  kernel :
+    func : isfinite, infinite_sr
 
-- api : divide
-  args : (Tensor x, Tensor y)
+# isinf
+- api : isinf
+  args : (Tensor x)
   output : Tensor
   infer_meta :
-    func : ElementwiseInferMeta
+    func : IsfiniteInferMeta
   kernel :
-    func : divide
-  backward : divide_grad
+    func : isinf, isinf_sr
 
-- api : dot
-  args : (Tensor x, Tensor y)
+# isnan
+- api : isnan
+  args : (Tensor x)
   output : Tensor
   infer_meta :
-    func : DotInferMeta
+    func : IsfiniteInferMeta
   kernel :
-    func : dot
+    func : isnan, isnan_sr
 
-- api : empty
-  args : (ScalarArray shape, DataType dtype=DataType::FLOAT32, Place place=CPUPlace())
-  output: Tensor
+# leaky_relu
+- api : leaky_relu
+  args : (Tensor x, float alpha)
+  output : Tensor
   infer_meta :
-    func : CreateInferMeta
-    param : [shape, dtype]
+    func : UnchangedInferMeta
+    param : [x]
   kernel :
-    func : empty
-    param : [shape, dtype]
-    data_type : dtype
-    backend : place
+    func : leaky_relu
+  backward : leaky_relu_grad
 
-- api : empty_like
-  args : (Tensor x, DataType dtype = DataType::UNDEFINED, Place place = {})
-  output: Tensor
+- api : lerp
+  args : (Tensor x, Tensor y, Tensor weight)
+  output : Tensor
   infer_meta :
-    func : CreateLikeInferMeta
-    param : [x, dtype]
+    func : LerpInferMeta
   kernel :
-    func : empty_like
-    param : [x, dtype]
-    data_type : dtype > x
-    backend : place > x
+    func : lerp
+  backward : lerp_grad
 
-- api : flatten
-  args : (Tensor x, int start_axis, int stop_axis)
+- api : less_equal
+  args : (Tensor x, Tensor y, int axis = -1)
   output : Tensor
   infer_meta :
-    func : FlattenInferMeta
+    func : CompareInferMeta
   kernel :
-    func : flatten
+    func : less_equal
 
-- api : full
-  args : (ScalarArray shape, Scalar value, DataType dtype=DataType::FLOAT32, Place place=CPUPlace())
-  output: Tensor
+- api : less_than
+  args : (Tensor x, Tensor y, int axis = -1)
+  output : Tensor
   infer_meta :
-    func : CreateInferMeta
-    param : [shape, dtype]
+    func : CompareInferMeta
   kernel :
-    func : full
-    param : [shape, value, dtype]
-    data_type : dtype
-    backend : place
+    func : less_than
 
-- api : full_like
-  args : (Tensor x, Scalar value, DataType dtype = DataType::UNDEFINED, Place place = {})
-  output: Tensor
+# log_loss
+- api : log_loss
+  args : (Tensor input, Tensor label, float epsilon)
+  output : Tensor
   infer_meta :
-    func : CreateLikeInferMeta
-    param : [x, dtype]
+    func : LogLossInferMeta
   kernel :
-    func : full_like
-    param : [x, value, dtype]
-    data_type : dtype > x
-    backend : place > x
+    func : log_loss
+  backward : log_loss_grad
 
-- api : matmul
-  args : (Tensor x, Tensor y, bool transpose_x = false, bool transpose_y = false)
+# logical_and
+- api : logical_and
+  args : (Tensor x, Tensor y)
   output : Tensor
   infer_meta :
-    func : MatmulInferMeta
+    func : ElementwiseInferMeta
   kernel :
-    func : matmul
-  backward : matmul_grad
+    func : logical_and
 
-- api : mean
-  args : (Tensor x, int64_t[] axis={}, bool keep_dim=false)
+# logical_not
+- api : logical_not
+  args : (Tensor x)
   output : Tensor
   infer_meta :
-    func : ReduceInferMeta
+    func : UnchangedInferMeta
   kernel :
-    func : mean
+    func : logical_not
 
-- api : multiply
+# logical_or
+- api : logical_or
   args : (Tensor x, Tensor y)
   output : Tensor
   infer_meta :
     func : ElementwiseInferMeta
   kernel :
-    func : multiply
-  backward : multiply_grad
+    func : logical_or
 
-- api : ones_like
-  args : (Tensor x, DataType dtype=DataType::UNDEFINED, Place place={})
+# logical_xor
+- api : logical_xor
+  args : (Tensor x, Tensor y)
   output : Tensor
-  invoke : full_like(x, 1, dtype, place)
+  infer_meta :
+    func : ElementwiseInferMeta
+  kernel :
+    func : logical_xor
 
-- api : pool2d
-  args : (Tensor x, int[] kernel_size, int[] strides, int[] paddings, bool ceil_mode, bool exclusive, str data_format, str pooling_type, bool global_pooling, bool adaptive, str padding_algorithm)
-  output : Tensor(out)
+# logsigmoid
+- api : logsigmoid
+  args : (Tensor x)
+  output : Tensor
   infer_meta :
-    func : PoolInferMeta
-  kernel:
-    func : pool2d
+    func : UnchangedInferMeta
+  kernel :
+    func : logsigmoid
+  backward : logsigmoid_grad
 
-- api : reshape
-  args : (Tensor x, ScalarArray shape)
-  output : Tensor(out)
+# masked_select
+- api : masked_select
+  args : (Tensor x, Tensor mask)
+  output : Tensor
   infer_meta :
-    func : ReshapeInferMeta
+    func : MaskedSelectInferMeta
   kernel :
-    func : reshape
-  inplace : (x -> out)
+    func : masked_select
+    data_type : x
+  backward : masked_select_grad
 
-- api : relu
-  args : (Tensor x)
+- api : matmul
+  args : (Tensor x, Tensor y, bool transpose_x = false, bool transpose_y = false)
   output : Tensor
   infer_meta :
-    func : UnchangedInferMeta
+    func : MatmulInferMeta
   kernel :
-    func : relu
-  inplace : (x -> out)
-  backward: relu_grad
+    func : matmul
+  backward : matmul_grad
 
-- api : scale
-  args : (Tensor x, Scalar scale, float bias, bool bias_after_scale)
+# matrix_power
+- api : matrix_power
+  args : (Tensor x, int n)
   output : Tensor
   infer_meta :
     func : UnchangedInferMeta
     param : [x]
   kernel :
-    func : scale, scale_sr
-  inplace : (x -> out)
+    func : matrix_power
+  backward : matrix_power_grad
 
-- api : sign
-  args : (Tensor x)
+- api : mean
+  args : (Tensor x, int64_t[] axis={}, bool keep_dim=false)
   output : Tensor
   infer_meta :
-    func : UnchangedInferMeta
+    func : ReduceInferMeta
   kernel :
-    func : sign
+    func : mean
 
-- api : softmax
-  args : (Tensor x, int axis)
+# multinomial
+- api : multinomial
+  args : (Tensor x, int num_samples, bool replacement)
   output : Tensor
   infer_meta :
-    func : SoftmaxInferMeta
+    func : MultinomialInferMeta
   kernel :
-    func : sotfmax
+    func : multinomial
 
-- api : split
-  args : (Tensor x, ScalarArray num_or_sections, Scalar(int) axis)
-  output : Tensor[]
-  invoke : split_impl(x, num_or_sections, axis)
-
-- api : subtract
+- api : multiply
   args : (Tensor x, Tensor y)
   output : Tensor
   infer_meta :
     func : ElementwiseInferMeta
   kernel :
-    func : subtract
-  backward : subtract_grad
+    func : multiply
+  backward : multiply_grad
 
-- api : sum
-  args : (Tensor x, int64_t[] axis={}, DataType dtype=DataType::UNDEFINED, bool keep_dim=false)
+- api : mv
+  args : (Tensor x, Tensor vec)
   output : Tensor
   infer_meta :
-    func : SumInferMeta
+    func : MvInferMeta
   kernel :
-    func : sum
-    data_type : x
+    func : mv
+  backward : mv_grad
 
-- api : zeros_like
-  args : (Tensor x, DataType dtype=DataType::UNDEFINED, Place place = {})
+- api : not_equal
+  args : (Tensor x, Tensor y, int axis = -1)
   output : Tensor
-  invoke : full_like(x, 0, dtype, place)
-
+  infer_meta :
+    func : CompareInferMeta
+  kernel :
+    func : not_equal
 
 - api : one_hot
   args : (Tensor x, Scalar(int) num_classes)
@@ -235,94 +1051,97 @@
   kernel :
     func : one_hot
 
-- api : digamma
-  args : (Tensor x)
+- api : ones_like
+  args : (Tensor x, DataType dtype=DataType::UNDEFINED, Place place={})
+  output : Tensor
+  invoke : full_like(x, 1, dtype, place)
+
+# pad
+- api : pad
+  args : (Tensor x, int[] paddings, float pad_value)
   output : Tensor
   infer_meta :
-    func : UnchangedInferMeta
+    func : PadInferMeta
   kernel :
-    func : digamma
-  backward : digamma_grad
+    func : pad
+  # backward : pad_grad
 
-- api : abs
-  args : (Tensor x)
+# pixel_shuffle
+- api : pixel_shuffle
+  args : (Tensor x, int upscale_factor, str data_format)
   output : Tensor
   infer_meta :
-    func : UnchangedInferMeta
+    func : PixelShuffleInferMeta
   kernel :
-    func : abs
-  backward : abs_grad
+    func : pixel_shuffle
+  # backward : pixel_shuffle_grad
 
-- api : trunc
+# poisson  // no need grad
+- api : poisson
   args : (Tensor x)
   output : Tensor
   infer_meta :
     func : UnchangedInferMeta
   kernel :
-    func : trunc
-  backward : trunc_grad
+    func : poisson
 
-# - api : norm
-#   args : (Tensor x, int axis, float epsilon, bool is_test)
-#   output : Tensor(out), Tensor(norm)
-#   infer_meta :
-#     func : NormInferMeta
-#   kernel :
-#     func : norm
-#   intermediate : norm
-#   backward : norm_grad
+- api : pool2d
+  args : (Tensor x, int[] kernel_size, int[] strides, int[] paddings, bool ceil_mode, bool exclusive, str data_format, str pooling_type, bool global_pooling, bool adaptive, str padding_algorithm)
+  output : Tensor(out)
+  infer_meta :
+    func : PoolInferMeta
+  kernel:
+    func : pool2d
 
-- api : diagonal
-  args : (Tensor x, int offset, int axis1, int axis2)
+# put_along_axis
+- api : put_along_axis
+  args : (Tensor x, Tensor index, Tensor value, int axis, str reduce)
   output : Tensor
   infer_meta :
-    func : DiagonalInferMeta
+    func : UnchangedInferMeta
+    param : [index]
   kernel :
-    func : diagonal
-  backward : diagonal_grad
+    func : put_along_axis
+    data_type : x
+  backward : put_along_axis_grad
 
-- api : gumbel_softmax
-  args : (Tensor x, float temperature, bool hard, int axis)
+# reduce_prod
+- api : reduce_prod
+  args : (Tensor x, int64_t[] dims, bool keep_dim, bool reduce_all)
   output : Tensor
   infer_meta :
-    func : GumbelSoftmaxInferMeta
+    func : ReduceInferMetaBase
   kernel :
-    func : gumbel_softmax
-  # backward : gumbel_softmax_grad
+    func : reduce_prod
 
-- api : diag
-  args : (Tensor x, int offset, float padding_value)
+- api : relu
+  args : (Tensor x)
   output : Tensor
   infer_meta :
-    func : DiagInferMeta
+    func : UnchangedInferMeta
   kernel :
-    func : diag
-
-# - api : pixel_shuffle
-#   args : (Tensor x, int upscale_factor, const std::string& data_format)
-#   output : Tensor
-#   infer_meta :
-#     func : PixelShuffleInferMeta
-#   kernel :
-#     func : pixel_shuffle
+    func : relu
+  inplace : (x -> out)
+  backward : relu_grad
 
-- api : transpose
-  args : (Tensor x, int[] axis)
-  output : Tensor
+- api : reshape
+  args : (Tensor x, ScalarArray shape)
+  output : Tensor(out)
   infer_meta :
-    func : TransposeInferMeta
+    func : ReshapeInferMeta
   kernel :
-    func : transpose
-  backward : transpose_grad
+    func : reshape
+  inplace : (x -> out)
 
-- api : lerp
-  args : (Tensor x, Tensor y, Tensor weight)
+- api : scale
+  args : (Tensor x, Scalar scale, float bias, bool bias_after_scale)
   output : Tensor
   infer_meta :
-    func : LerpInferMeta
+    func : UnchangedInferMeta
+    param : [x]
   kernel :
-    func : lerp
-  # backward : lerp_grad
+    func : scale, scale_sr
+  inplace : (x -> out)
 
 - api : scatter
   args : (Tensor x, Tensor index, Tensor updates, bool overwrite)
@@ -333,7 +1152,7 @@
   kernel :
     func : scatter
   backward : scatter_grad
-
+  # no_need_buffer : updates
 
 - api : scatter_nd_add
   args : (Tensor x, Tensor index, Tensor updates)
@@ -344,214 +1163,302 @@
   kernel :
     func : scatter_nd_add
   backward : scatter_nd_add_grad
+  # no_need_buffer : updates
 
+# segment_pool
+- api : segment_pool
+  args : (Tensor x, Tensor segment_ids, str pooltype)
+  output : Tensor(out), Tensor(summed_ids)
+  infer_meta :
+    func : SegmentPoolInferMeta
+  kernel :
+    func : segment_pool
+  backward : segment_pool_grad
 
-- api : addmm
-  args : (Tensor input, Tensor x, Tensor y, float alpha, float beta)
+# selu
+- api : selu
+  args : (Tensor x, float scale, float alpha)
   output : Tensor
   infer_meta :
-    func : AddmmInferMeta
+    func : UnchangedInferMeta
+    param : [x]
   kernel :
-    func : addmm
-  backward : addmm_grad
+    func : selu
+  backward : selu_grad
 
-
-- api : adadelta
-  args : (Tensor param, Tensor grad, Tensor avg_squared_grad, Tensor avg_squared_update, float rho, float epsilon)
-  output : Tensor(param_out), Tensor(moment_out), Tensor(inf_norm_out)
+# shard_index
+- api : shard_index
+  args : (Tensor in, int index_num, int nshards, int shard_id, int ignore_value)
+  output : Tensor
   infer_meta :
-    func : AdadeltaInferMeta
+    func : ShardIndexInferMeta
   kernel :
-    func : adadelta
+    func : shard_index
 
-- api : adamax
-  args : (Tensor param, Tensor grad, Tensor learning_rate, Tensor moment, Tensor inf_norm, Tensor beta1_pow, float beta1, float beta2, float epsilon)
-  output : Tensor(param_out), Tensor(avg_squared_grad_out), Tensor(avg_squared_update_out)
+# sigmoid
+- api : sigmoid
+  args : (Tensor x)
+  output : Tensor
   infer_meta :
-    func : AdamaxInferMeta
+    func : UnchangedInferMeta
   kernel :
-    func : adamax
-
+    func : sigmoid
+  backward : sigmoid_grad
 
-
-- api : where
-  args : (Tensor condition, Tensor x, Tensor y)
+# 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 : WhereInferMeta
+    func : SigmoidCrossEntropyWithLogitsInferMeta
   kernel :
-    func : where
-  backward : where_grad
-
-
-# BilinearTensorProductInferMeta
-
-# BroadcastTensorsInferMeta
+    func : sigmoid_cross_entropy_with_logits
+  backward : sigmoid_cross_entropy_with_logits_grad
 
-- api : less_than
-  args : (Tensor x, Tensor y, int axis = -1)
+- api : sign
+  args : (Tensor x)
   output : Tensor
   infer_meta :
-    func : CompareInferMeta
+    func : UnchangedInferMeta
   kernel :
-    func : less_than  
+    func : sign
 
-- api : less_equal
-  args : (Tensor x, Tensor y, int axis = -1)
+# silu
+- api : silu
+  args : (Tensor x)
   output : Tensor
   infer_meta :
-    func : CompareInferMeta
+    func : UnchangedInferMeta
   kernel :
-    func : less_equal
+    func : silu
+  backward : silu_grad
 
-- api : greater
-  args : (Tensor x, Tensor y, int axis = -1)
+# sin
+- api : sin
+  args : (Tensor x)
   output : Tensor
   infer_meta :
-    func : CompareInferMeta
+    func : UnchangedInferMeta
   kernel :
-    func : greater
+    func : sin
+  backward : sin_grad
 
-- api : greater_equal
-  args : (Tensor x, Tensor y, int axis = -1)
+# sinh
+- api : sinh
+  args : (Tensor x)
   output : Tensor
   infer_meta :
-    func : CompareInferMeta
+    func : UnchangedInferMeta
   kernel :
-    func : greater_equal
+    func : sinh
+  backward : sinh_grad
 
-- api : equal
-  args : (Tensor x, Tensor y, int axis = -1)
+# size
+- api : size
+  args : (Tensor x)
   output : Tensor
   infer_meta :
-    func : CompareInferMeta
+    func : SizeInferMeta
   kernel :
-    func : equal
+    func : size
 
-- api : not_equal
-  args : (Tensor x, Tensor y, int axis = -1)
+# soft_shrink
+- api : soft_shrink
+  args : (Tensor x, float lambda)
   output : Tensor
   infer_meta :
-    func : CompareInferMeta
+    func : UnchangedInferMeta
+    param : [x]
   kernel :
-    func : not_equal
+    func : soft_shrink
+  backward : soft_shrink_grad
 
-# - api : equal_all
-#   args : (Tensor x, Tensor y)
-#   output : Tensor
-#   infer_meta :
-#     func : CompareAllInferMeta
-#   kernel :
-#     func : equal_all
+- api : softmax
+  args : (Tensor x, int axis)
+  output : Tensor
+  infer_meta :
+    func : SoftmaxInferMeta
+  kernel :
+    func : softmax
+  backward : softmax_grad
 
+- api : split
+  args : (Tensor x, ScalarArray num_or_sections, Scalar(int) axis)
+  output : Tensor[]
+  invoke : split_impl(x, num_or_sections, axis)
 
-- api : huber_loss
-  args : (Tensor input, Tensor label, float delta)
-  output : Tensor(out), Tensor(residual)
+- api : subtract
+  args : (Tensor x, Tensor y)
+  output : Tensor
   infer_meta :
-    func : HuberLossInferMeta
+    func : ElementwiseInferMeta
   kernel :
-    func : huber_loss
-  # backward : huber_loss_grad
+    func : subtract
+  backward : subtract_grad
+  # no_need_buffer : x, y
 
-- api : triangular_solve
-  args : (Tensor x, Tensor y, bool upper, bool tranpose, bool unitriangular)
+- api : sum
+  args : (Tensor x, int64_t[] axis={}, DataType dtype=DataType::UNDEFINED, bool keep_dim=false)
   output : Tensor
   infer_meta :
-    func : TriangularSolveInferMeta
+    func : SumInferMeta
   kernel :
-    func : triangular_solve
-  # backward : triangular_solve_grad
-
+    func : sum
+    data_type : x
 
-- api : index_sample
-  args : (Tensor x, Tensor index)
+# take_along_axis
+- api : take_along_axis
+  args : (Tensor x, Tensor index, int axis)
   output : Tensor
   infer_meta :
-    func : IndexSampleInferMeta
+    func : UnchangedInferMeta
+    param : [index]
   kernel :
-    func : index_sample
+    func : take_along_axis
     data_type : x
-  backward : index_sample_grad
+  backward : take_along_axis_grad
 
-
-- api : cross
-  args : (Tensor x, Tensor y, int axis = 9)
+# tan
+- api : tan
+  args : (Tensor x)
   output : Tensor
   infer_meta :
-    func : CrossInferMeta
+    func : UnchangedInferMeta
   kernel :
-    func : cross
-  backward : cross_grad
+    func : tan
+  backward : tan_grad
 
-
-- api : atan2
-  args : (Tensor x, Tensor y)
+# tanh
+- api : tanh
+  args : (Tensor x)
   output : Tensor
   infer_meta :
-    func : Atan2InferMeta
+    func : UnchangedInferMeta
   kernel :
-    func : atan2
-  backward : atan2_grad
+    func : tanh
+  backward : tanh_grad
 
-
-- api : bce_loss
-  args : (Tensor input, Tensor label)
+# tanh_shrink
+- api : tanh_shrink
+  args : (Tensor x)
   output : Tensor
   infer_meta :
-    func : BCELossInferMeta
+    func : UnchangedInferMeta
   kernel :
-    func : bce_loss
-  backward : bce_loss_grad
+    func : tanh_shrink
+  backward : tanh_shrink_grad
 
-
-- api : dist
-  args : (Tensor x, Tensor y, float p)
+# thresholded_relu
+- api : thresholded_relu
+  args : (Tensor x, float threshold)
   output : Tensor
   infer_meta :
-    func : DistInferMeta
+    func : UnchangedInferMeta
+    param : [x]
   kernel :
-    func : dist
-  # backward : dist_grad
-
+    func : thresholded_relu
+  backward : thresholded_relu_grad
 
-- api : gather_nd
-  args : (Tensor x, Tensor index)
+# tile
+- api : tile
+  args : (Tensor x, ScalarArray repeat_times)
   output : Tensor
   infer_meta :
-    func : GatherNdInferMeta
+    func : TileInferMeta
   kernel :
-    func : gather_nd
-    data_type : x
-  backward : gather_nd_grad
+    func : tile
+  backward : tile_grad
+  # no_need_buffer : x
 
-- api : gather_tree
-  args : (Tensor ids, Tensor parents)
+# trace
+- api : trace
+  args : (Tensor x, int offset, int axis1, int axis2)
   output : Tensor
   infer_meta :
-    func : GatherTreeMeta
+    func : TraceInferMeta
   kernel :
-    func : gather_tree
+    func : trace
+  backward : trace_grad
+  no_need_buffer : x
 
-- api : mv
-  args : (Tensor x, Tensor vec)
+- api : transpose
+  args : (Tensor x, int[] axis)
   output : Tensor
   infer_meta :
-    func : MvInferMeta
+    func : TransposeInferMeta
   kernel :
-    func : mv
-  backward : mv_grad
-
-
-
+    func : transpose
+  backward : transpose_grad
 
-#  =================================== sep0
+- api : triangular_solve
+  args : (Tensor x, Tensor y, bool upper, bool transpose, bool unitriangular)
+  output : Tensor
+  infer_meta :
+    func : TriangularSolveInferMeta
+  kernel :
+    func : triangular_solve
+  # backward : triangular_solve_grad
 
+- api : trunc
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : trunc
+  backward : trunc_grad
 
-#  =================================== sep1
+# 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
+  # no_need_buffer : x
+
+# 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
+    data_type : input
 
+- api : where
+  args : (Tensor condition, Tensor x, Tensor y)
+  output : Tensor
+  infer_meta :
+    func : WhereInferMeta
+  kernel :
+    func : where
+  backward : where_grad
 
-#  =================================== sep2
+# where_index
+- api : where_index
+  args : (Tensor condition)
+  output : Tensor
+  infer_meta :
+    func : WhereIndexInferMeta
+  kernel :
+    func : where_index
+  # no_need_buffer : x, y
 
+# 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=1.0, bool iou_aware=false, float iou_aware_factor=0.5)
+  output : Tensor(boxes), Tensor(scores)
+  infer_meta :
+    func : YoloBoxInferMeta
+  kernel :
+    func : yolo_box
+    data_type : x
 
-#  =================================== sep3
+- api : zeros_like
+  args : (Tensor x, DataType dtype=DataType::UNDEFINED, Place place = {})
+  output : Tensor
+  invoke : full_like(x, 0, dtype, place)

python/paddle/utils/code_gen/backward.yaml

-- backward_api : matmul_grad
-  forward : matmul (Tensor x, Tensor y, bool transpose_x=false, bool transpose_y=false) -> Tensor(out)
-  args : (Tensor x, Tensor y, Tensor out_grad, bool transpose_x=false, bool transpose_y=false)
-  output : Tensor(x_grad), Tensor(y_grad)
+# - backward_api : norm_grad
+#   forward : norm (Tensor x, int axis, float epsilon, bool is_test) -> Tensor(out), Tensor(norm)
+#   args : (Tensor x, Tensor norm, Tensor out_grad, int axis, float epsilon, bool is_test)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : norm_grad
+
+# - backward_api : matmul_triple_grad
+#   forward : matmul_double_grad (Tensor x, Tensor y, Tensor out_grad, Tensor dx_grad, Tensor dy_grad, bool transpose_x, bool transpose_y) -> Tensor(d2x), Tensor(d2y), Tensor(dout_grad)
+#   args : (Tensor x, Tensor y, Tensor out_grad, Tensor dx_grad, Tensor dy_grad, Tensor d2x_grad, Tensor d2y_grad, Tensor dout_grad_grad, bool transpose_x, bool transpose_y)
+#   output : Tensor(d3x), Tensor(d3y), Tensor(d2out_grad), Tensor(ddx_grad), Tensor(ddy_grad)
+#   infer_meta :
+#     func : MatmulTripleGradInferMeta
+#   kernel :
+#     func : matmul_triple_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 : batch_norm_grad
+#   forward : batch_norm (Tensor x, Tensor scale, Tensor bias, Tensor mean, Tensor variance, float momentum, float epsilon, str 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
+#   optional : bias
+
+# - 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 : gumbel_softmax_grad
+#   forward : gumbel_softmax (Tensor x, float temperature, bool hard, int axis) -> Tensor(out)
+#   args : (Tensor out, Tensor out_grad, int axis)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : GumbelSoftmaxGradInferMeta
+#     param : [out, out_grad, axis]
+#   kernel :
+#     func : gumbel_softmax_grad
+
+# - backward_api : huber_loss_grad
+#   forward : huber_loss (Tensor input, Tensor label, float delta) -> Tensor(out), Tensor(residual)
+#   args : (Tensor residual, Tensor out_grad, float delta)
+#   output : Tensor(input_grad), Tensor(label_grad)
+#   infer_meta :
+#     func : GeneralBinaryGradInferMeta
+#     param : [x, y]
+#   kernel :
+#     func : where_grad
+
+# - backward_api : triangular_solve_grad
+#   forward : triangular_solve (Tensor x, Tensor y, bool upper, bool tranpose, bool unitriangular) -> Tensor(out)
+#   args : (Tensor x, Tensor y, Tensor out, Tensor out_grad, bool upper, bool tranpose, bool unitriangular)
+#   output : Tensor(x_grad), Tensor(y_grad)
+#   infer_meta :
+#     func : GeneralBinaryGradInferMeta
+#     param : [x, y]
+#   kernel :
+#     func : triangular_solve_grad
+
+# - backward_api : dropout_grad
+#   forward : dropout (Tensor x, Tensor seed_tensor, float p, bool is_test, str mode, int seed, bool fix_seed) -> Tensor(out), Tensor(mask)
+#   args : (Tensor mask, Tensor out_grad, float p, bool is_test, str mode)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [out_grad]
+#   kernel :
+#     func : dropout_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 : UnchangedInferMeta
+#     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 : graph_send_recv_grad
+#   forward : graph_send_recv (Tensor x, Tensor src_index, Tensor dst_index, str pool_type) -> Tensor(out), Tensor(dst_count)
+#   args : (Tensor out_grad, Tensor x, Tensor out, Tensor src_index, Tensor dst_index, Tensor dst_count, str pool_type)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : graph_send_recv_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 : 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, str data_format) -> Tensor(out)
+#   args : (Tensor out_grad, int upscale_factor, str 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 : 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 : where_index_grad
+
+- backward_api : abs_grad
+  forward : abs (Tensor x) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad)
+  output : Tensor(x_grad)
   infer_meta :
-    func : GeneralBinaryGradInferMeta
-    param : [x, y]
+    func : UnchangedInferMeta
+    param : [out_grad]
   kernel :
-    func : matmul_grad
+    func : abs_grad
 
-- backward_api : matmul_double_grad
-  forward : matmul_grad (Tensor x, Tensor y, Tensor out_grad, bool transpose_x, bool transpose_y) -> Tensor(dx), Tensor(dy)
-  args : (Tensor x, Tensor y, Tensor out_grad, Tensor dx_grad, Tensor dy_grad, bool transpose_x, bool transpose_y)
-  output : Tensor(d2x), Tensor(d2y), Tensor(dout_grad)
+- backward_api : acos_grad
+  forward : acos (Tensor x) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad)
+  output : Tensor(x_grad)
   infer_meta :
-    func : GeneralTernaryGradInferMeta
-    param : [x, y, out_grad]
+    func : UnchangedInferMeta
+    param : [x]
   kernel :
-    func : matmul_double_grad
-  optional : dx_grad, dy_grad
+    func : acos_grad
 
-- backward_api : scale_grad
-  forward : scale (Tensor x, Scalar scale, float bias, bool bias_after_scale) -> Tensor(out)
-  args : (Tensor out_grad, Scalar scale, float bias=0.0, bool bias_after_scale=true)
+- backward_api : acosh_grad
+  forward : acosh (Tensor x) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad)
   output : Tensor(x_grad)
-  invoke : scale(out_grad, scale, bias, bias_after_scale)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : acosh_grad
 
 - backward_api : add_grad
   forward : add (Tensor x, Tensor y) -> Tensor(out)
@@ -34,26 +217,188 @@
     param : [x, y]
   kernel :
     func : add_grad
+  no_need_buffer : x, y
 
-- backward_api : subtract_grad
-  forward : subtract (Tensor x, Tensor y) -> Tensor(out)
-  args : (Tensor x, Tensor y, Tensor out_grad, int axis = -1)
+- backward_api : addmm_grad
+  forward : scatter (Tensor input, Tensor x, Tensor y, float alpha, float beta) -> Tensor(out)
+  args : (Tensor input, Tensor x, Tensor y, Tensor out_grad, float alpha, float beta)
+  output : Tensor(input_grad), Tensor(x_grad), Tensor(y_grad)
+  infer_meta :
+    func : GeneralTernaryGradInferMeta
+    param : [input, x, y]
+  kernel :
+    func : addmm_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 : asin_grad
+  forward : asin (Tensor x) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : asin_grad
+
+- backward_api : asinh_grad
+  forward : asinh (Tensor x) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : asinh_grad
+
+- backward_api : atan2_grad
+  forward : cross (Tensor x, Tensor y) -> Tensor(out)
+  args : (Tensor x, Tensor y, Tensor out_grad)
   output : Tensor(x_grad), Tensor(y_grad)
   infer_meta :
     func : GeneralBinaryGradInferMeta
     param : [x, y]
   kernel :
-    func : subtract_grad
+    func : atan2_grad
 
-- backward_api : multiply_grad
-  forward : multiply (Tensor x, Tensor y) -> Tensor(out)
-  args : (Tensor x, Tensor y, Tensor out_grad, int axis = -1)
+- backward_api : atan_grad
+  forward : atan (Tensor x) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : atan_grad
+
+- backward_api : atanh_grad
+  forward : atanh (Tensor x) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : atanh_grad
+
+- backward_api : bce_loss_grad
+  forward : bce_loss (Tensor input, Tensor label) -> Tensor(out)
+  args : (Tensor input, Tensor label, Tensor out_grad)
+  output : Tensor(input_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [input]
+  kernel :
+    func : bce_loss_grad
+
+- backward_api : brelu_grad
+  forward : brelu (Tensor x, float t_min, float t_max) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad, float t_min, float t_max)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : brelu_grad
+
+- backward_api : cast_grad
+  forward : cast (Tensor x, DataType out_dtype) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : cast_grad
+    data_type : out_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 : UnchangedInferMeta
+    param : [out]
+  kernel :
+    func : cholesky_grad
+
+- backward_api : cholesky_solve_grad
+  forward : cholesky (Tensor x, Tensor y, bool upper) -> Tensor(out)
+  args : (Tensor x, Tensor y, Tensor out, Tensor out_grad, bool upper)
   output : Tensor(x_grad), Tensor(y_grad)
   infer_meta :
     func : GeneralBinaryGradInferMeta
     param : [x, y]
   kernel :
-    func : multiply_grad
+    func : cholesky_solve_grad
+
+- backward_api : cos_grad
+  forward : cos (Tensor x) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : cos_grad
+
+- backward_api : cosh_grad
+  forward : cosh (Tensor x) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : cosh_grad
+
+- backward_api : cross_grad
+  forward : cross (Tensor x, Tensor y, int axis = 9) -> Tensor(out)
+  args : (Tensor x, Tensor y, Tensor out_grad, int axis)
+  output : Tensor(x_grad), Tensor(y_grad)
+  infer_meta :
+    func : GeneralBinaryGradInferMeta
+    param : [x, y]
+  kernel :
+    func : cross_grad
+
+- backward_api : diagonal_grad
+  forward : diagonal (Tensor x, int offset, int axis1, int axis2) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad, int offset = 0, int axis1 = 0, int axis2 = 1)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : diagonal_grad
+
+- backward_api : digamma_grad
+  forward : digamma (Tensor x) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : digamma_grad
+
+- backward_api : dist_grad
+  forward : dist (Tensor x, Tensor y, float p) -> Tensor(out)
+  args : (Tensor x, Tensor y, Tensor out, Tensor out_grad, float p)
+  output : Tensor(x_grad), Tensor(y_grad)
+  infer_meta :
+    func : GeneralBinaryGradInferMeta
+    param : [x, y]
+  kernel :
+    func : dist_grad
 
 - backward_api : divide_grad
   forward : divide (Tensor x, Tensor y) -> Tensor(out)
@@ -65,114 +410,260 @@
   kernel :
     func : divide_grad
 
+- backward_api : eigh_grad
+  forward : eigh (Tensor x, str 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 : digamma_grad
-  forward : digamma (Tensor x) -> Tensor(out)
+- backward_api : elu_grad
+  forward : elu (Tensor x, float alpha) -> Tensor(out)
+  args : (Tensor x, Tensor out, Tensor out_grad, float alpha)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : elu_grad
+
+- backward_api : erf_grad
+  forward : erf (Tensor x) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : erf_grad
+    data_type : out_grad
+
+- backward_api : erfinv_grad
+  forward : erf (Tensor x) -> Tensor(out)
+  args : (Tensor out, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out]
+  kernel :
+    func : erfinv_grad
+
+- backward_api : gather_nd_grad
+  forward : gather_nd (Tensor x, Tensor index) -> Tensor(out)
+  args : (Tensor x, Tensor index, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : gather_nd_grad
+# # forward backward type not match
+# - backward_api : top_k_grad
+#   forward : top_k (Tensor x, Scalar k, int axis = -1, bool largest = true, bool sorted = true) -> Tensor(out), Tensor(indices)
+#   args : (Tensor x, Tensor indices, Tensor out_grad, Scalar k = -1, int axis = -1, bool largest = true, bool sorted = true)
+#   output : Tensor(x_grad)
+#   infer_meta :
+#     func : UnchangedInferMeta
+#     param : [x]
+#   kernel :
+#     func : top_k_grad
+
+- backward_api : hard_shrink_grad
+  forward : hard_shrink (Tensor x, float threshold) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad, float threshold)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : hard_shrink_grad
+
+- backward_api : hard_sigmoid_grad
+  forward : hard_sigmoid (Tensor x, float slope, float offset) -> Tensor(out)
+  args : (Tensor out, Tensor out_grad, float slope, float offset)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out]
+  kernel :
+    func : hard_sigmoid_grad
+
+- backward_api : index_sample_grad
+  forward : index_sample (Tensor x, Tensor index) -> Tensor(out)
+  args : (Tensor x, Tensor index, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : index_sample_grad
+    data_type : out_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(label_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out_grad]
+  kernel :
+    func : label_smooth_grad
+  optional : prior_dist
+
+- backward_api : leaky_relu_grad
+  forward : leaky_relu (Tensor x, float alpha) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad, float alpha)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : leaky_relu_grad
+
+- backward_api : lerp_grad
+  forward : transpose (Tensor x, Tensor y, Tensor weight) -> Tensor(out)
+  args : (Tensor x, Tensor y, Tensor weight, Tensor out, Tensor out_grad)
+  output : Tensor(x_grad), Tensor(y_grad)
+  infer_meta :
+    func : GeneralBinaryGradInferMeta
+    param : [x, y]
+  kernel :
+    func : lerp_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 : [input]
+  kernel :
+    func : log_loss_grad
+
+- backward_api : logsigmoid_grad
+  forward : logsigmoid (Tensor x) -> Tensor(out)
   args : (Tensor x, Tensor out_grad)
   output : Tensor(x_grad)
   infer_meta :
-    func : UnchangedInferMeta
-    param : [x]
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : logsigmoid_grad
+
+- backward_api : masked_select_grad
+  forward : masked_select (Tensor x, Tensor mask) -> Tensor(out)
+  args : (Tensor x, Tensor mask, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : masked_select_grad
+    data_type : x
+
+- backward_api : matmul_double_grad
+  forward : matmul_grad (Tensor x, Tensor y, Tensor out_grad, bool transpose_x, bool transpose_y) -> Tensor(dx), Tensor(dy)
+  args : (Tensor x, Tensor y, Tensor out_grad, Tensor dx_grad, Tensor dy_grad, bool transpose_x, bool transpose_y)
+  output : Tensor(d2x), Tensor(d2y), Tensor(dout_grad)
+  infer_meta :
+    func : GeneralTernaryGradInferMeta
+    param : [x, y, out_grad]
+  kernel :
+    func : matmul_double_grad
+  optional : dx_grad, dy_grad
+
+- backward_api : matmul_grad
+  forward : matmul (Tensor x, Tensor y, bool transpose_x=false, bool transpose_y=false) -> Tensor(out)
+  args : (Tensor x, Tensor y, Tensor out_grad, bool transpose_x=false, bool transpose_y=false)
+  output : Tensor(x_grad), Tensor(y_grad)
+  infer_meta :
+    func : GeneralBinaryGradInferMeta
+    param : [x, y]
+  kernel :
+    func : matmul_grad
+
+- backward_api : matrix_power_grad
+  forward : matrix_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 : matrix_power_grad
+
+- backward_api : multiply_grad
+  forward : multiply (Tensor x, Tensor y) -> Tensor(out)
+  args : (Tensor x, Tensor y, Tensor out_grad, int axis = -1)
+  output : Tensor(x_grad), Tensor(y_grad)
+  infer_meta :
+    func : GeneralBinaryGradInferMeta
+    param : [x, y]
+  kernel :
+    func : multiply_grad
+
+- backward_api : mv_grad
+  forward : mv (Tensor x, Tensor vec) -> Tensor(out)
+  args : (Tensor x, Tensor vec, Tensor out_grad)
+  output : Tensor(x_grad), Tensor(vec_grad)
+  infer_meta :
+    func : GeneralBinaryGradInferMeta
+    param : [x, vec]
   kernel :
-    func : digamma_grad
+    func : mv_grad
 
-- backward_api : abs_grad
-  forward : abs (Tensor x) -> Tensor(out)
-  args : (Tensor x, Tensor out_grad)
-  output : Tensor(x_grad)
+- backward_api : nll_loss_grad
+  forward : nll_loss (Tensor x, Tensor label, Tensor weight, int64_t ignore_index, str reduction) -> Tensor(out), Tensor(total_weight)
+  args : (Tensor x, Tensor label,  Tensor weight, Tensor total_weight, Tensor out_grad, int64_t ignore_index, str reduction)
+  output : Tensor (x_grad)
   infer_meta :
     func : UnchangedInferMeta
     param : [x]
   kernel :
-    func : abs_grad
+    func : nll_loss_grad
+    data_type : out_grad
+  optional : weight
 
-- backward_api : relu_grad
-  forward : relu (Tensor x) -> Tensor(out)
-  args : (Tensor x, Tensor out_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 : relu_grad
-
-- backward_api : trunc_grad
-  forward : trunc (Tensor x) -> Tensor(out)
-  args : (Tensor out_grad)
-  output : Tensor(x_grad)
+    func : psroi_pool_grad
+  optional : rois_num
+
+# output is optional
+- backward_api : put_along_axis_grad
+  forward : put_along_axis (Tensor x, Tensor index, Tensor value, int axis, str reduce) -> Tensor(out)
+  args : (Tensor x, Tensor index, Tensor out_grad, int axis, str reduce)
+  output : Tensor(x_grad), Tensor(value_grad)
   infer_meta :
-    func : UnchangedInferMeta
-    param : [out_grad]
+    func : GeneralBinaryGradInferMeta
+    param : [x, index]
   kernel :
-    func : trunc_grad
-
-# - backward_api : norm_grad
-#   forward : norm (Tensor x, int axis, float epsilon, bool is_test) -> Tensor(out), Tensor(norm)
-#   args : (Tensor x, Tensor norm, Tensor out_grad, int axis, float epsilon, bool is_test)
-#   output : Tensor(x_grad)
-#   infer_meta :
-#     func : UnchangedInferMeta
-#     param : [x]
-#   kernel :
-#     func : norm_grad
+    func : put_along_axis_grad
 
-- backward_api : diagonal_grad
-  forward : diagonal (Tensor x, int offset, int axis1, int axis2) -> Tensor(out)
-  args : (Tensor x, Tensor out_grad, int offset = 0, int axis1 = 0, int axis2 = 1)
+- backward_api : relu_grad
+  forward : relu (Tensor x) -> Tensor(out)
+  args : (Tensor out, Tensor out_grad)
   output : Tensor(x_grad)
   infer_meta :
     func : UnchangedInferMeta
-    param : [x]
+    param : [out]
   kernel :
-    func : diagonal_grad
-
-# - backward_api : split_grad
-#   forward : split (Tensor x, ScalarArray num_or_sections, Scalar axis) -> Tensor[](out)
-#   args : (Tensor[] out_grad, Scalar axis)
-#   output : Tensor(x_grad)    
-#   invoke : concat( out_grad, axis)
-# TODO(zhangyunfei) The config of double grad and triple grad will be supported in the future.
-
-# - backward_api : matmul_triple_grad
-#   forward : matmul_double_grad (Tensor x, Tensor y, Tensor out_grad, Tensor dx_grad, Tensor dy_grad, bool transpose_x, bool transpose_y) -> Tensor(d2x), Tensor(d2y), Tensor(dout_grad)
-#   args : (Tensor x, Tensor y, Tensor out_grad, Tensor dx_grad, Tensor dy_grad, Tensor d2x_grad, Tensor d2y_grad, Tensor dout_grad_grad, bool transpose_x, bool transpose_y)
-#   output : Tensor(d3x), Tensor(d3y), Tensor(d2out_grad), Tensor(ddx_grad), Tensor(ddy_grad)
-#   infer_meta :
-#     func : MatmulTripleGradInferMeta
-#   kernel :
-#     func : matmul_triple_grad
-
-# - backward_api : gumbel_softmax_grad
-#   forward : gumbel_softmax (Tensor x, float temperature, bool hard, int axis) -> Tensor(out)
-#   args : (Tensor out, Tensor out_grad, int axis)
-#   output : Tensor(x_grad)
-#   infer_meta :
-#     func : GumbelSoftmaxGradInferMeta
-#     param : [out, out_grad, axis]
-#   kernel :
-#     func : gumbel_softmax_grad
-
+    func : relu_grad
 
-- backward_api : transpose_grad
-  forward : transpose (Tensor x, int[] axis) -> Tensor(out)
-  args : (Tensor out_grad, int[] axis)
+- backward_api : scale_grad
+  forward : scale (Tensor x, Scalar scale, float bias, bool bias_after_scale) -> Tensor(out)
+  args : (Tensor out_grad, Scalar scale, float bias=0.0, bool bias_after_scale=true)
   output : Tensor(x_grad)
-  infer_meta :
-    func : TransposeGradInferMeta
-    param : [out_grad, axis]
-  kernel :
-    func : transpose_grad
-
-# - backward_api : lerp_grad
-#   forward : transpose (Tensor x, Tensor y, Tensor weight) -> Tensor(out)
-#   args : (Tensor x, Tensor y, Tensor weight, Tensor out, Tensor out_grad)
-#   output : Tensor(x_grad), Tensor(y_grad)
-#   infer_meta :
-#     func : GeneralBinaryGradInferMeta
-#     param : [x, y]
-#   kernel :
-#     func : lerp_grad
-
+  invoke : scale(out_grad, scale, bias, bias_after_scale)
 
 - backward_api : scatter_grad
   forward : scatter (Tensor x, Tensor index, Tensor updates, bool overwrite) -> Tensor(out)
@@ -194,139 +685,219 @@
   kernel :
     func : scatter_nd_grad
 
-- backward_api : addmm_grad
-  forward : scatter (Tensor input, Tensor x, Tensor y, float alpha, float beta) -> Tensor(out)
-  args : (Tensor input, Tensor x, Tensor y, Tensor out_grad, float alpha, float beta)
-  output : Tensor(input_grad), Tensor(x_grad), Tensor(y_grad)
+- backward_api : segment_pool_grad
+  forward : segment_pool (Tensor x, Tensor segment_ids, str pooltype) -> Tensor(out), Tensor(summed_ids)
+  args : (Tensor x, Tensor segment_ids, Tensor out, Tensor summed_ids, Tensor out_grad, str pooltype)
+  output : Tensor(x_grad)
   infer_meta :
-    func : GeneralTernaryGradInferMeta
-    param : [input, x, y]
+    func : UnchangedInferMeta
+    param : [x]
   kernel :
-    func : addmm_grad
+    func : segment_pool_grad
 
-- backward_api : where_grad
-  forward : where (Tensor condition, Tensor x, Tensor y) -> Tensor(out)
-  args : (Tensor condition, Tensor x, Tensor y, Tensor out_grad)
-  output : Tensor(x_grad), Tensor(y_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 : GeneralBinaryGradInferMeta
-    param : [x, y]
+    func : UnchangedInferMeta
+    param : [out]
   kernel :
-    func : where_grad
+    func : selu_grad
 
-# - backward_api : huber_loss_grad
-#   forward : huber_loss (Tensor input, Tensor label, float delta) -> Tensor(out), Tensor(residual)
-#   args : (Tensor residual, Tensor out_grad, float delta)
-#   output : Tensor(input_grad), Tensor(label_grad)
-#   infer_meta :
-#     func : GeneralBinaryGradInferMeta
-#     param : [x, y]
-#   kernel :
-#     func : where_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 ignore_index)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : sigmoid_cross_entropy_with_logits_grad
 
-# - backward_api : triangular_solve_grad
-#   forward : triangular_solve (Tensor x, Tensor y, bool upper, bool tranpose, bool unitriangular) -> Tensor(out)
-#   args : (Tensor x, Tensor y, Tensor out, Tensor out_grad, bool upper, bool tranpose, bool unitriangular)
-#   output : Tensor(x_grad), Tensor(y_grad)
-#   infer_meta :
-#     func : GeneralBinaryGradInferMeta
-#     param : [x, y]
-#   kernel :
-#     func : triangular_solve_grad
+- backward_api : sigmoid_grad
+  forward : sigmoid (Tensor x) -> Tensor(out)
+  args : (Tensor out, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out]
+  kernel :
+    func : sigmoid_grad
 
-- backward_api : index_sample_grad
-  forward : index_sample (Tensor x, Tensor index) -> Tensor(out)
-  args : (Tensor x, Tensor index, Tensor out_grad)
+- backward_api : silu_grad
+  forward : silu (Tensor x) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad)
   output : Tensor(x_grad)
   infer_meta :
     func : UnchangedInferMeta
     param : [x]
   kernel :
-    func : index_sample_grad
+    func : silu_grad
 
-- backward_api : cross_grad
-  forward : cross (Tensor x, Tensor y, int axis = 9) -> Tensor(out)
-  args : (Tensor x, Tensor y, Tensor out_grad, int axis)
-  output : Tensor(x_grad), Tensor(y_grad)
+- backward_api : sin_grad
+  forward : sin (Tensor x) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad)
+  output : Tensor(x_grad)
   infer_meta :
-    func : GeneralBinaryGradInferMeta
-    param : [x, y]
+    func : UnchangedInferMeta
+    param : [x]
   kernel :
-    func : cross_grad
+    func : sin_grad
 
-- backward_api : atan2_grad
-  forward : cross (Tensor x, Tensor y) -> Tensor(out)
-  args : (Tensor x, Tensor y, Tensor out_grad)
-  output : Tensor(x_grad), Tensor(y_grad)
+- backward_api : sinh_grad
+  forward : sinh (Tensor x) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad)
+  output : Tensor(x_grad)
   infer_meta :
-    func : GeneralBinaryGradInferMeta
-    param : [x, y]
+    func : UnchangedInferMeta
+    param : [x]
   kernel :
-    func : atan2_grad
+    func : sinh_grad
 
-- backward_api : bce_loss_grad
-  forward : bce_loss (Tensor input, Tensor label) -> Tensor(out)
-  args : (Tensor input, Tensor label, Tensor out_grad)
-  output : Tensor(input_grad)
+- backward_api : soft_shrink_grad
+  forward : soft_shrink (Tensor x, float lambda) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad, float lambda)
+  output : Tensor(x_grad)
   infer_meta :
     func : UnchangedInferMeta
-    param : [input]
+    param : [x]
   kernel :
-    func : bce_loss_grad
+    func : soft_shrink_grad
 
+- backward_api : softmax_grad
+  forward : softmax (Tensor x, int axis) -> Tensor(out)
+  args : (Tensor out, Tensor out_grad, int axis)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out]
+  kernel :
+    func : softmax_grad
 
-# - backward_api : dist_grad
-#   forward : dist (Tensor x, Tensor y, float p) -> Tensor(out)
-#   args : (Tensor x, Tensor y, Tensor out, Tensor out_grad, float p)
-#   output : Tensor(x_grad), Tensor(y_grad)
-#   infer_meta :
-#     func : GeneralBinaryGradInferMeta
-#     param : [x, y]
-#   kernel :
-#     func : dist_grad
+- backward_api : split_grad
+  forward : split (Tensor x, ScalarArray num_or_sections, Scalar axis) -> Tensor[](out)
+  args : (Tensor[] out_grad, Scalar axis)
+  output : Tensor(x_grad)
+  invoke : concat( out_grad, axis)
+# TODO(zhangyunfei) The config of double grad and triple grad will be supported in the future.
 
+- backward_api : subtract_grad
+  forward : subtract (Tensor x, Tensor y) -> Tensor(out)
+  args : (Tensor x, Tensor y, Tensor out_grad, int axis = -1)
+  output : Tensor(x_grad), Tensor(y_grad)
+  infer_meta :
+    func : GeneralBinaryGradInferMeta
+    param : [x, y]
+  kernel :
+    func : subtract_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 : gather_nd_grad
-  forward : gather_nd (Tensor x, Tensor index) -> Tensor(out)
-  args : (Tensor x, Tensor index, Tensor out_grad)
+- backward_api : tan_grad
+  forward : tan (Tensor x) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad)
   output : Tensor(x_grad)
   infer_meta :
     func : UnchangedInferMeta
     param : [x]
   kernel :
-    func : gather_nd_grad
+    func : tan_grad
 
-- backward_api : mv_grad
-  forward : mv (Tensor x, Tensor vec) -> Tensor(out)
-  args : (Tensor x, Tensor vec, Tensor out_grad)
-  output : Tensor(x_grad), Tensor(vec_grad)
+- backward_api : tanh_grad
+  forward : tanh (Tensor x) -> Tensor(out)
+  args : (Tensor out, Tensor out_grad)
+  output : Tensor(x_grad)
   infer_meta :
-    func : GeneralBinaryGradInferMeta
-    param : [x, vec]
+    func : UnchangedInferMeta
+    param : [out]
   kernel :
-    func : mv_grad
+    func : tanh_grad
 
-    
-- backward_api : cast_grad
-  forward : cast (Tensor x, DataType out_dtype) -> Tensor(out)
+- backward_api : tanh_shrink_grad
+  forward : tanh_shrink (Tensor x) -> Tensor(out)
   args : (Tensor x, Tensor out_grad)
   output : Tensor(x_grad)
   infer_meta :
     func : UnchangedInferMeta
     param : [x]
   kernel :
-    func : cast_grad
-    data_type : out_grad
+    func : tanh_shrink_grad
 
+- backward_api : thresholded_relu_grad
+  forward : thresholded_relu (Tensor x, float threshold) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad, float threshold)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : thresholded_relu_grad
 
-#  =================================== sep0
-
+- 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
 
-#  =================================== sep1
+- backward_api : trace_grad
+  forward : trace (Tensor x, int offset, int axis1, int axis2) -> Tensor(out)
+  args : (Tensor x, Tensor out_grad, int offset, int axis1, int axis2)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [x]
+  kernel :
+    func : trace_grad
 
+- backward_api : transpose_grad
+  forward : transpose (Tensor x, int[] axis) -> Tensor(out)
+  args : (Tensor out_grad, int[] axis)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : TransposeGradInferMeta
+    param : [out_grad, axis]
+  kernel :
+    func : transpose_grad
 
-#  =================================== sep2
+- backward_api : trunc_grad
+  forward : trunc (Tensor x) -> Tensor(out)
+  args : (Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out_grad]
+  kernel :
+    func : trunc_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
 
-#  =================================== sep3
+- backward_api : where_grad
+  forward : where (Tensor condition, Tensor x, Tensor y) -> Tensor(out)
+  args : (Tensor condition, Tensor x, Tensor y, Tensor out_grad)
+  output : Tensor(x_grad), Tensor(y_grad)
+  infer_meta :
+    func : GeneralBinaryGradInferMeta
+    param : [x, y]
+  kernel :
+    func : where_grad