add yaml; test=develop

python/paddle/utils/code_gen/api.yaml

@@ -239,3 +239,308 @@
   kernel :
     func : diagonal
   backward : diagonal_grad
+
+
+
+# softmax
+- api : softmax
+  args : (Tensor x, int axis)
+  output : Tensor
+  infer_meta :
+    func : SoftmaxInferMeta
+  kernel :
+    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
+
+# 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
+
+# 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
+
+# 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
+  args : (Tensor x, Tensor indices, Tensor label)
+  output : Tensor(accuracy), Tensor(correct), Tensor(total)
+  infer_meta :
+    func : AccuracyInferMeta
+  kernel :
+    func : accuracy
+
+# sin
+- api : sin
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : sin
+  backward : sin_grad
+
+# cos
+- api : cos
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : cos
+  backward : cos_grad
+
+
+# tanh
+- api : tanh
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : tanh
+  backward : tanh_grad
+
+# acos
+- api : acos
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : acos
+  backward : acos_grad
+
+
+# asin
+- api : asin
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : asin
+  backward : asin_grad
+
+
+# atan
+- api : atan
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : atan
+  backward : atan_grad
+
+# sinh
+- api : sinh
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : sinh
+  backward : sinh_grad
+
+# cosh
+- api : cosh
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : cosh
+  backward : cosh_grad
+
+# asinh
+- api : asinh
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : asinh
+  backward : asinh_grad
+
+# acosh
+- api : acosh
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : acosh
+  backward : acosh_grad
+
+# atanh
+- api : atanh
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : atanh
+  backward : atanh_grad
+
+# relu
+- api : relu
+  args : (Tensor x)
+  output : Tensor
+  infer_meta :
+    func : UnchangedInferMeta
+  kernel :
+    func : relu
+  backward : relu_grad
+
+
+# arg_min  # int64 ???? dtype
+- api : agrmin
+  args : (Tensor x, int axis, bool keepdims, bool flatten, int dtype)
+  output : Tensor
+  infer_meta :
+    func : XXXXInferMeta
+  kernel :
+    func : argmin
+
+# arg_max  # int64 ???? dtype
+- api : agrmax
+  args : (Tensor x, int axis, bool keepdims, bool flatten, int dtype)
+  output : Tensor
+  infer_meta :
+    func : XXXXInferMeta
+  kernel :
+    func : argmax
+
+# argsort; kernel why input?
+- api : argsort
+  args : (Tensor x, int axis, bool descending)
+  output : Tensor(out), tensor(indices)
+  infer_meta :
+    func : XXXXInferMeta
+  kernel :
+    func : argsort
+
+# auc
+
+
+# batch_norm
+# bernoulli
+# bilinear_tensor_product
+# bincount
+# bitwise_and
+# broadcast_tensors
+# cholesky
+# cholesky_solve
+# conv2d
+# copy
+# cumsum
+# depthwise_conv2d
+# dropout
+# embedding
+# erf
+# erfinv
+# expand_as
+# expand
+# eye
+# flip
+# gaussian_random
+# graph_send_recv
+# histogram
+# increment
+# is_empty
+# isinf
+# isinf_sr
+# label_smooth
+# linspace
+# log_loss
+# logical_and
+# masked_select
+# multi_dot
+# multinomial
+# nll_loss
+# pad
+# pixel_shuffle
+# poisson
+# psroi_pool
+# randint_raw
+# randperm_raw
+# max
+# max_raw
+# reduce_prod
+# scale_sr
+# selu
+# set_value
+# sgd
+# shape
+# shape_sr
+# shard_index
+# sigmoid_cross_entropy_with_logits
+# size
+# sparse_weight_embedding
+# tile
+# top_k
+# trace
+# phi_transfer_layout
+# truncated_gaussian_random
+# unbind
+# unfold
+# uniform_random_raw
+# uniform_random_raw_sr
+# viterbi_decode
+# where_index
+# yolo_box
+# sparse_conv3d
+# dense_to_sparse_coo

python/paddle/utils/code_gen/backward.yaml

@@ -90,3 +90,204 @@
 #     func : MatmulTripleGradInferMeta
 #   kernel :
 #     func : matmul_triple_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 : 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 : 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 : 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 : 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)
+  args : (Tensor out, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out]
+  kernel :
+    func : cos_grad
+
+- backward_api : tan_grad
+  forward : tan (Tensor x) -> Tensor(out)
+  args : (Tensor out, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out]
+  kernel :
+    func : tam_grad
+
+- backward_api : acos_grad
+  forward : acos (Tensor x) -> Tensor(out)
+  args : (Tensor out, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out]
+  kernel :
+    func : acos_grad
+
+- backward_api : sin_grad
+  forward : sin (Tensor x) -> Tensor(out)
+  args : (Tensor out, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out]
+  kernel :
+    func : sin_grad
+
+- backward_api : asin_grad
+  forward : asin (Tensor x) -> Tensor(out)
+  args : (Tensor out, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out]
+  kernel :
+    func : asin_grad
+
+- backward_api : atan_grad
+  forward : atan (Tensor x) -> Tensor(out)
+  args : (Tensor out, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out]
+  kernel :
+    func : atan_grad
+  
+- backward_api : sinh_grad
+  forward : sinh (Tensor x) -> Tensor(out)
+  args : (Tensor out, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out]
+  kernel :
+    func : sinh_grad
+
+- backward_api : cosh_grad
+  forward : cosh (Tensor x) -> Tensor(out)
+  args : (Tensor out, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out]
+  kernel :
+    func : cosh_grad
+
+- backward_api : asinh_grad
+  forward : asinh (Tensor x) -> Tensor(out)
+  args : (Tensor out, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out]
+  kernel :
+    func : asinh_grad
+
+- backward_api : acosh_grad
+  forward : acosh (Tensor x) -> Tensor(out)
+  args : (Tensor out, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out]
+  kernel :
+    func : acosh_grad
+  
+- backward_api : atanh_grad
+  forward : atanh (Tensor x) -> Tensor(out)
+  args : (Tensor out, Tensor out_grad)
+  output : Tensor(x_grad)
+  infer_meta :
+    func : UnchangedInferMeta
+    param : [out]
+  kernel :
+    func : atanh_grad
+
+- 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 : [out]
+  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