paddlepaddle--paddle/paddle/phi/ops/yaml/op_compat.yaml

# All the configuration in this file are only for existing operators,
# which cannot be modified in principle. There's no need to configure
# this file for new operator.
#
# This file is used for two purposes:
# 1. Configure the mapping relationship of parameter names of operator
#    between the operators in ops.yaml and the old operators defined
#    in fluid.
# 2. Save the extra parameters in the OpMaker of operators temporarily,
#    which will be removed in the future.

# - op : rnn
#   backward : rnn_grad
#   extra :
#     attrs : [bool is_test = false]

- op : abs
  backward : abs_grad, abs_double_grad, abs_triple_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : accuracy
  inputs :
    {x : Out , indices : Indices, label: Label}
  outputs :
    {accuracy : Accuracy, correct : Correct, total : Total}

- op : acos
  inputs :
    x : X
  outputs :
    out : Out

- op : acosh
  inputs :
    x : X
  outputs :
    out : Out
  backward : acosh_grad
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : adadelta_ (adadelta)
  inputs :
    {param : Param, grad: Grad, avg_squared_grad : AvgSquaredGrad, avg_squared_update : AvgSquaredUpdate, learning_rate : LearningRate, master_param : MasterParam }
  outputs :
    {param_out : ParamOut, moment_out : AvgSquaredGradOut, inf_norm_out : AvgSquaredUpdateOut, master_param_out : MasterParamOut}

- op : adagrad_ (adagrad)
  inputs :
    { param : Param, grad : Grad, moment : Moment, learning_rate : LearningRate, master_param : MasterParam }
  outputs :
    { param_out : ParamOut, moment_out : MomentOut, master_param_out : MasterParamOut }

- op : adam_ (adam)
  inputs :
    {param: Param, grad: Grad, learning_rate: LearningRate, moment1: Moment1, moment2: Moment2, moment2_max: Moment2Max, beta1_pow: Beta1Pow, beta2_pow: Beta2Pow, master_param: MasterParam, skip_update: SkipUpdate}
  outputs :
    {param_out: ParamOut, moment1_out: Moment1Out, moment2_out: Moment2Out, moment2_max_out: Moment2MaxOut, beta1_pow_out: Beta1PowOut, beta2_pow_out: Beta2PowOut, master_param_out: MasterParamOut}
  scalar :
    beta1 :
      data_type : float
      tensor_name : Beta1Tensor
    beta2 :
      data_type : float
      tensor_name : Beta2Tensor
    epsilon :
      data_type : float
      tensor_name : EpsilonTensor
  manual_signature : [adam_]

- op : adamax_ (adamax)
  inputs :
    {param : Param, grad: Grad, learning_rate : LearningRate, moment : Moment, inf_norm : InfNorm, beta1_pow : Beta1Pow, master_param : MasterParam}
  outputs :
    {param_out : ParamOut, moment_out : MomentOut, inf_norm_out : InfNormOut, master_param_out : MasterParamOut}

- op : adamw_ (adamw)
  inputs :
    {param: Param, grad: Grad, learning_rate: LearningRate, moment1: Moment1, moment2: Moment2, moment2_max: Moment2Max, beta1_pow: Beta1Pow, beta2_pow: Beta2Pow, master_param: MasterParam, skip_update: SkipUpdate}
  outputs :
    {param_out: ParamOut, moment1_out: Moment1Out, moment2_out: Moment2Out, moment2_max_out: Moment2MaxOut, beta1_pow_out: Beta1PowOut, beta2_pow_out: Beta2PowOut, master_param_out: MasterParamOut}
  scalar :
    beta1 :
      data_type : float
      tensor_name : Beta1Tensor
    beta2 :
      data_type : float
      tensor_name : Beta2Tensor
    epsilon :
      data_type : float
      tensor_name : EpsilonTensor

- op : add (elementwise_add)
  backward : add_grad (elementwise_add_grad), add_double_grad (elementwise_add_grad_grad), add_triple_grad (elementwise_add_triple_grad)
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}
  attrs :
    {scale_x : Scale_x, scale_y : Scale_y, scale_out : Scale_out}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]
  complex_promote : [X, Y]

- op : add_n (sum)
  inputs:
    {inputs : X}
  outputs:
    {out : Out}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]

- op : add_position_encoding
  backward: add_position_encoding_grad
  inputs:
    x : X
  outputs:
    out : Out

- op : addmm
  backward : addmm_grad
  inputs :
    {input : Input, x : X, y : Y}
  outputs :
    out : Out
  attrs :
    {alpha : Alpha, beta : Beta}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : affine_channel
  backward: affine_channel_grad
  inputs:
    {x : X, scale : Scale, bias : Bias}
  outputs:
    out : Out

- op : affine_grid
  backward : affine_grid_grad
  inputs :
    input : Theta
  outputs :
    output : Output
  int_array:
    output_shape :
      data_type : int
      tensor_name : OutputShape
  extra :
    attrs : [bool use_cudnn = true]

- op : all (reduce_all)
  inputs:
    x : X
  attrs:
    { axis : dim,  keepdim : keep_dim}
  outputs:
    out : Out
  manual_signature : [all]
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : allclose
  inputs :
    {x : Input, y : Other}
  outputs :
    out : Out
  scalar :
    rtol :
      data_type : std::string
      tensor_name : Rtol
    atol :
      data_type : std::string
      tensor_name : Atol

- op : amax (reduce_amax)
  backward : amax_grad (reduce_amax_grad)
  inputs :
    x : X
  outputs :
    out : Out
  attrs:
    { axis : dim,  keepdim : keep_dim }
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]
  get_expected_kernel_type :
    amax_grad : GetReduceGradExpectedKernelType
  manual_signature : [amax]

- op : amin (reduce_amin)
  backward : amin_grad (reduce_amin_grad)
  inputs :
    x : X
  outputs :
    out : Out
  attrs:
    { axis : dim,  keepdim : keep_dim }
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]
  get_expected_kernel_type :
    amin_grad : GetReduceGradExpectedKernelType
  manual_signature : [amin]

- op : anchor_generator
  inputs:
    input : Input
  outputs:
    {anchors : Anchors, variances_out : Variances}

- op : angle
  backward : angle_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : any (reduce_any)
  inputs :
    x : X
  outputs :
    out : Out
  attrs:
    { axis : dim,  keepdim : keep_dim }
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]
  get_expected_kernel_type :
    any : GetReduceOpUseInputPlaceExpectedKernelType
  manual_signature : [any]

- op : arange(range)
  inputs :
    {start : Start, end : End, step : Step}
  outputs :
    out : Out
  scalar:
    start:
      data_type : double
      support_tensor : true
    end:
      data_type : double
      support_tensor : true
    step:
      data_type : double
      support_tensor : true

- op : argmax(arg_max)
  inputs :
    x : X
  outputs :
    out : Out
  scalar:
    axis:
      data_type : int64_t
      support_tensor : true

- op : argmin(arg_min)
  inputs :
    x : X
  outputs :
    out : Out
  scalar:
    axis:
      data_type : int64_t
      support_tensor : true

- op : argsort
  inputs :
    x : X
  outputs :
    out : Out
    indices : Indices

- op : array_to_tensor(tensor_array_to_tensor)
  backward : tanh_shrink_grad
  inputs :
    x : X
  outputs :
    out : Out
    out_index : OutIndex

- op : as_complex
  inputs :
    x : X
  outputs :
    out : Out

- op : as_real
  inputs :
    x : X
  outputs :
    out : Out

- op : asin
  inputs :
    x : X
  outputs :
    out : Out

- op : asinh
  backward : asinh_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : assert
  inputs :
    {cond : Cond, data : Data}

- op : assign
  backward : assign_grad
  inputs :
    x : X
  outputs :
    out : Out
  manual_signature : [assign, assign_grad]
  get_expected_kernel_type :
    assign : GetAssignExpectedKernelType

- op : assign_pos
  inputs :
    {x : X}
  outputs :
    out : Out

- op : assign_value
  outputs :
    out : Out
  manual_signature : [assign_value]

- op : atan
  inputs :
    x : X
  outputs :
    out : Out

- op : atan2
  backward : atan2_grad
  inputs :
    {x : X1, y : X2}
  outputs :
    out : Out

- op : atanh
  backward : atanh_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : attention_lstm
  backward: attention_lstm_grad
  inputs:
    {x : X, c0 : C0, h0 : H0, attention_weight : AttentionWeight, attention_bias : AttentionBias, attention_scalar : AttentionScalar, attention_scalar_bias : AttentionScalarBias, lstm_weight : LSTMWeight, lstm_bias : LSTMBias}
  outputs:
    {hidden : Hidden, cell : Cell, attentioned_x : AttentionedX, attention_fc_out : AttentionFCOut, lstm_x : LSTMX, lstm_out : LSTMOUT}

- op : auc
  inputs :
    {x : Predict, label : Label, stat_pos : StatPos, stat_neg : StatNeg, ins_tag_weight : InsTagWeight}
  outputs :
    {auc : AUC, stat_pos_out : StatPosOut, stat_neg_out : StatNegOut}

- op : baddbmm
  backward : baddbmm_grad
  inputs :
    {input : Input, x : X, y : Y}
  outputs :
    out : Out
  attrs :
    {alpha : Alpha, beta : Beta}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : barrier
  inputs :
    {x : X}
  outputs :
    out : Out

- op : batch_fc
  backward : batch_fc_grad
  inputs :
    {input : Input, w : W, bias : Bias}
  outputs :
    out : Out

- op : batch_norm
  backward : batch_norm_grad, batch_norm_double_grad(batch_norm_grad_grad)
  inputs:
    x : X
    mean : Mean
    variance : Variance
    scale : Scale
    bias : Bias
  outputs :
    out : Y
    mean_out: MeanOut
    variance_out: VarianceOut
    saved_mean: SavedMean
    saved_variance: SavedVariance
    reserve_space: ReserveSpace
  attrs:
    data_format: data_layout
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool fuse_with_relu = false]

- op : bce_loss
  backward : bce_loss_grad
  inputs :
    {input : X, label : Label}
  outputs :
    out : Out

- op : beam_search_decode
  inputs:
    {ids : Ids, scores : Scores}
  outputs:
    {sentence_ids : SentenceIds, sentence_scores : SentenceScores}

- op : bernoulli
  inputs :
    x : X
  outputs :
    out : Out

- op : bicubic_interp (bicubic_interp_v2)
  backward : bicubic_interp_grad (bicubic_interp_v2_grad)
  inputs :
    {x : X, out_size : OutSize, size_tensor : SizeTensor, scale_tensor : Scale}
  outputs :
    output : Out
  attrs:
    data_format: data_layout
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : bilinear (bilinear_tensor_product)
  backward: bilinear_grad (bilinear_tensor_product_grad)
  inputs :
    {x : X, y : Y,weight: Weight, bias: Bias}
  outputs :
    {out : Out}

- op : bilinear_interp (bilinear_interp_v2)
  backward : bilinear_interp_grad (bilinear_interp_v2_grad)
  inputs :
    {x : X, out_size : OutSize, size_tensor : SizeTensor, scale_tensor : Scale}
  outputs :
    output : Out
  attrs:
    data_format: data_layout
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]

- op : bincount
  inputs :
    {x : X, weights : Weights}
  outputs :
    out : Out
  scalar:
    minlength:
      data_type : int
      support_tensor : true
  get_expected_kernel_type :
    bincount : GetBincountExpectedKernelType

- op : bipartite_match
  inputs:
    dist_mat : DistMat
  outputs:
    {col_to_row_match_indices : ColToRowMatchIndices, col_to_row_match_dist : ColToRowMatchDist}

- op : bitwise_and
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}

- op : bitwise_not
  inputs :
    {x : X}
  outputs :
    {out : Out}

- op : bitwise_or
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}

- op : bitwise_xor
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}

- op : bmm
  backward : bmm_grad, bmm_double_grad
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : bn_act_xpu
  attrs:
    data_format: data_layout

- op : box_coder
  inputs :
    {prior_box : PriorBox , prior_box_var : PriorBoxVar, target_box: TargetBox}
  outputs :
    output_box : OutputBox

- op : broadcast_tensors
  backward : broadcast_tensors_grad
  inputs :
    input : X
  outputs :
    out : Out
  drop_empty_grad : [input_grad]

- op : c_concat
  backward: c_concat_grad
  inputs :
    x : X
  outputs :
    out : Out

- op : c_embedding
  backward : c_embedding_grad
  inputs :
    {weight : W, x : Ids}
  outputs :
    out : Out

- op : c_softmax_with_cross_entropy
  backward : c_softmax_with_cross_entropy_grad
  inputs :
    {logits : Logits, label : Label}
  outputs :
    {softmax : Softmax, loss : Loss}

- op : c_split
  inputs :
    x : X
  outputs :
    out : Out

- op : cast
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]

- op : ceil
  backward : ceil_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : celu
  backward : celu_grad, celu_double_grad(celu_grad_grad)
  inputs :
    x : X
  outputs :
    out : Out

- op : check_finite_and_unscale_(check_finite_and_unscale)
  inputs :
    {x : X, scale: Scale}
  outputs :
    {out : Out, found_infinite: FoundInfinite}
  get_expected_kernel_type :
    check_finite_and_unscale_ : GetCheckFiniteAndUnscaleExpectedKernelType

- op : cholesky
  inputs :
    x : X
  outputs :
    out : Out

- op : cholesky_solve
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : class_center_sample
  inputs :
    label : Label
  outputs :
    {remapped_label : RemappedLabel, sampled_local_class_center : SampledLocalClassCenter}

- op : clip
  backward : clip_grad, clip_double_grad
  inputs :
    x : X
  outputs :
    out : Out
  scalar :
    min :
      data_type : float
      tensor_name : Min
    max :
      data_type :  float
      tensor_name : Max
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]

- op : clip_by_norm
  inputs :
    x : X
  outputs :
    out : Out

- op : coalesce_tensor
  inputs :
    {input : Input}
  outputs :
    {output : Output, fused_output : FusedOutput}
  attrs :
    {size_of_dtype : user_defined_size_of_dtype}

- op : collect_fpn_proposals
  inputs:
    {multi_level_rois : MultiLevelRois, multi_level_scores : MultiLevelScores, multi_level_rois_num : MultiLevelRoIsNum}
  attrs:
    post_nms_topn : post_nms_topN
  outputs:
    {fpn_rois : FpnRois, rois_num : RoisNum}

- op : complex
  backward : complex_grad
  inputs :
    {real : X, imag : Y}
  outputs :
    out : Out

- op : concat
  backward : concat_grad, concat_double_grad
  inputs:
    x: X
  outputs:
    out: Out
  attrs:
    axis: axis
  scalar :
    axis :
      data_type : int
      tensor_name : AxisTensor
  drop_empty_grad : [x_grad]
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_quantizer = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]
  get_expected_kernel_type :
    concat : GetConcatExpectedKernelType

- op : conditional_block
  backward : conditional_block_grad
  extra :
    attrs : ['str[] skip_eager_deletion_vars = {}']

- op : conj
  inputs :
    x : X
  outputs :
    out : Out

- op : conv2d
  backward : conv2d_grad, conv2d_grad_grad
  inputs :
    {input : Input, filter : Filter}
  outputs :
    out : Output
  extra :
    attrs : [bool is_test = false, bool use_cudnn = true, bool use_mkldnn = false, bool use_onednn = false, bool use_addto = false,
             bool force_fp32_output = false,
             int workspace_size_MB = phi::backends::gpu::GetDefaultConvWorkspaceSizeLimitMB(), bool exhaustive_search = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]
  get_expected_kernel_type :
    conv2d : GetConvExpectedKernelType

- op : conv2d_transpose
  backward : conv2d_transpose_grad, conv2d_transpose_double_grad (conv2d_transpose_grad_grad)
  inputs :
    {x : Input, filter : Filter, bias : Bias}
  outputs :
    out : Output
  int_array :
    output_size :
      data_type : int
      support_tensor : true
  extra :
    inputs : [bias]
    attrs : [bool is_test = false, bool use_cudnn = true, bool use_mkldnn = false, bool use_onednn = false, bool force_fp32_output = false,
             str mkldnn_data_type = "float32", str onednn_data_type = "", bool fuse_relu = false,
             str fuse_activation = "", float fuse_alpha = 0.0f, float fuse_beta = 0.0f,
             int workspace_size_MB = phi::backends::gpu::GetDefaultConvWorkspaceSizeLimitMB()]

- op : conv2d_transpose_bias
  inputs :
    {x : Input, filter : Filter, bias : Bias}
  outputs :
    out : Output
  int_array :
    output_size :
      data_type : int
      support_tensor : true
  extra :
    attrs : [bool is_test = false, bool use_cudnn = false, bool use_mkldnn = true, bool use_onednn = false, bool force_fp32_output = false,
             str mkldnn_data_type = "float32", str onednn_data_type = "", bool fuse_relu = false,
             str fuse_activation = "", float fuse_alpha = 0.0f, float fuse_beta = 0.0f]

- op : conv3d
  backward : conv3d_grad, conv3d_double_grad (conv3d_grad_grad)
  inputs :
    {input : Input, filter : Filter}
  outputs :
    out : Output
  extra :
    attrs : [bool is_test = false, bool use_cudnn = true, bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "", bool fuse_relu = false,
             str fuse_activation = "", float fuse_alpha = 0.0f, float fuse_beta = 0.0f,
             bool use_addto = false, bool fuse_residual_connection = false, bool force_fp32_output = false,
             int workspace_size_MB = phi::backends::gpu::GetDefaultConvWorkspaceSizeLimitMB(), bool exhaustive_search = false]
  get_expected_kernel_type :
    conv3d : GetConvExpectedKernelType

- op : conv3d_transpose
  backward : conv3d_transpose_grad
  inputs :
    {x : Input, filter : Filter}
  outputs :
    out : Output
  extra :
    attrs : [bool use_cudnn = true, bool use_mkldnn = false, bool use_onednn = false, int workspace_size_MB = phi::backends::gpu::GetDefaultConvWorkspaceSizeLimitMB()]

- op : correlation
  backward : correlation_grad
  inputs :
    {input1 : Input1, input2 : Input2}
  outputs :
    out : Output
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : cos
  backward : cos_grad, cos_double_grad, cos_triple_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : cosh
  backward : cosh_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : crop (crop_tensor)
  backward : crop_grad (crop_tensor_grad)
  inputs :
    x : X
  outputs :
    out : Out
  int_array:
    shape :
      data_type : int
      tensor_name : Shape
      tensors_name : ShapeTensor
    offsets :
      data_type : int
      tensor_name : Offsets
      tensors_name : OffsetsTensor

- op : cross
  inputs :
    {x : X, y : Y}
  attrs :
    axis : dim
  outputs :
    out : Out

- op : cross_entropy_with_softmax (softmax_with_cross_entropy)
  backward : cross_entropy_with_softmax_grad (softmax_with_cross_entropy_grad)
  inputs :
    {input : Logits, label : Label}
  outputs :
    {softmax : Softmax, loss : Loss}

- op : cumprod
  backward : cumprod_grad
  inputs :
    x : X
  attrs :
    dim : dim
  outputs :
    out : Out

- op : cumsum
  backward: cumsum_grad
  inputs :
    x : X
  outputs :
    out : Out
  scalar:
    axis:
      data_type : int
      support_tensor : true

- op : cvm
  backward: cvm_grad
  inputs:
    {x : X, cvm : CVM}
  outputs:
    out : Y

- op : data_norm
  backward : data_norm_grad
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : decode_jpeg
  inputs :
    x : X
  outputs :
    out : Out

- op : deformable_conv
  backward : deformable_conv_grad
  inputs :
    {x : Input, offset : Offset, filter : Filter, mask : Mask}
  outputs :
    out : Output

- op : depthwise_conv2d
  backward : depthwise_conv2d_grad, depthwise_conv2d_double_grad (depthwise_conv2d_grad_grad)
  inputs :
    {input : Input, filter : Filter}
  outputs :
    out : Output
  attrs :
    {scale_in : Scale_in, scale_out : Scale_out, scale_in_eltwise : Scale_in_eltwise, scale_weights : Scale_weights}
  extra :
    attrs : [bool is_test = false, bool use_cudnn = false, bool fuse_relu_before_depthwise_conv = false, bool use_mkldnn = false, bool use_onednn = false,
             bool use_quantizer = false, str mkldnn_data_type = "float32", str onednn_data_type = "", bool fuse_relu = false,
             str fuse_activation = "", float fuse_alpha = 0.0f, float fuse_beta = 0.0f, bool use_addto = false,
             bool fuse_residual_connection = false, float Scale_in = 1.0f, float Scale_out = 1.0f,
             float Scale_in_eltwise = 1.0f, 'float[] Scale_weights = {1.0f}', bool force_fp32_output = false,
             int workspace_size_MB = phi::backends::gpu::GetDefaultConvWorkspaceSizeLimitMB(), bool exhaustive_search = false]
  get_expected_kernel_type :
    depthwise_conv2d : GetConvExpectedKernelType

- op : depthwise_conv2d_transpose
  backward : depthwise_conv2d_transpose_grad
  inputs :
    {x : Input, filter : Filter, bias: Bias}
  outputs :
    out : Output
  int_array :
    output_size :
      data_type : int
      support_tensor : true
  extra :
    inputs : [bias]
    attrs : [bool is_test = false, bool use_cudnn = false, bool use_mkldnn = false, bool use_onednn = false, bool force_fp32_output = false,
             str mkldnn_data_type = "float32", str onednn_data_type = "", bool fuse_relu = false,
             str fuse_activation = "", float fuse_alpha = 0.0f, float fuse_beta = 0.0f,
             int workspace_size_MB = phi::backends::gpu::GetDefaultConvWorkspaceSizeLimitMB()]

- op : dequantize
  inputs :
    input : Input
  outputs :
    output : Output
  attrs :
    {scale : Scale, shift : Shift}

- op : dequantize_abs_max
  inputs :
    {x : X, scale : Scale}
  outputs :
    out : Out

- op : dequantize_linear
  inputs :
    {x : X, scale : Scale, zero_point : ZeroPoint, in_accum : InAccum, in_state : InState}
  outputs :
    {y : Y, out_scale : OutScale, out_accum : OutAccum, out_state : OutState}
  extra :
    attrs : [float moving_rate = 0.9]

- op : dequantize_log
  inputs :
    x : X
    dict : Dict
  outputs :
    out : Out

- op : det (determinant)
  backward : det_grad (determinant_grad)
  inputs :
    x : Input
  outputs :
    out : Out

- op : dgc_clip_by_norm
  inputs:
    x : X
  outputs:
    out : Out

- op : dgc_momentum
  inputs :
    {param : Param, grad : Grad, velocity : Velocity, learning_rate : LearningRate, master_param : MasterParam, current_step_tensor : current_step, nranks_tensor : nranks}
  outputs :
    {param_out : ParamOut, velocity_out : VelocityOut, master_param_out : MasterParamOut, grad_out : Grad_out}

- op : diag (diag_v2)
  backward : diag_grad (diag_v2_grad)
  inputs :
    x : X
  outputs :
    out : Out

- op : diag_embed
  inputs :
    input : Input
  outputs :
    out : Out

- op : diagonal
  inputs :
    x : Input
  outputs :
    out : Out

- op : digamma
  inputs :
    x : X
  outputs :
    out : Out

- op : dirichlet
  inputs :
    alpha : Alpha
  outputs :
    out : Out

- op : dist
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : div_scale
  backward : div_scale_grad
  inputs :
    x : X
  outputs :
    out : Out
  scalar :
    scale :
      data_type : float
      tensor_name : ScaleTensor
    bias :
      data_type : float
      support_tensor : false
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]

- op : divide (elementwise_div)
  backward : divide_grad (elementwise_div_grad)
  inputs :
    {x: X, y : Y}
  outputs :
    out: Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]

- op : dot
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : dropout
  backward : dropout_grad
  inputs :
    x : X
    seed_tensor : Seed
  outputs :
    out : Out
    mask : Mask
  attrs :
    p : dropout_prob
    is_test : is_test
    mode : dropout_implementation
    seed : seed
    fix_seed : fix_seed
  extra :
    attrs : [bool fix_seed = false, int seed = 0]
  scalar :
    p :
      support_tensor : true

- op : dropout_nd
  backward : dropout_nd_grad
  extra :
    attrs : [bool fix_seed = false, int seed = 0]

- op : edit_distance
  inputs :
    hyps : Hyps
    refs : Refs
    hypslength : HypsLength
    refslength : RefsLength
  outputs :
    sequencenum : SequenceNum
    out : Out

- op : eig
  inputs :
    x : X
  outputs :
    out_w : Eigenvalues
    out_v : Eigenvectors

- op : eigh
  inputs :
    x : X
  outputs :
    out_w : Eigenvalues
    out_v : Eigenvectors

- op : eigvals
  inputs :
    x : X
  outputs :
    out : Out

- op : eigvalsh
  backward : eigvalsh_grad
  inputs :
    {x : X}
  outputs :
    {eigenvalues : Eigenvalues, eigenvectors : Eigenvectors}
  attrs :
    uplo : UPLO

- op : einsum
  backward : einsum_grad
  inputs :
    x : Operands
  outputs:
    {out : Out, inner_cache: InnerCache, xshape : XShape}
  drop_empty_grad: [x_grad]
  extra:
    outputs: [inner_cache, xshape]

- op : elementwise_pow
  backward : elementwise_pow_grad
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]
  complex_promote : [X, Y]
  manual_signature : [elementwise_pow]

- op : elu
  backward : elu_grad, elu_double_grad (elu_grad_grad)
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : embedding (lookup_table_v2)
  backward : embedding_grad (lookup_table_v2_grad)
  inputs :
    {x : Ids, weight : W}
  outputs :
    out : Out
  attrs :
   sparse : is_sparse
  manual_signature : [embedding_grad]
  extra :
    attrs : [bool is_sparse = false, bool is_distributed = false, bool remote_prefetch = false,
             int trainer_id = 0, int slot = 0, 'int64_t[] height_sections = {}', 'str[] epmap = {}',
             'str[] table_names = {}']

- op : empty
  outputs :
    out : Out
  int_array:
    shape :
      data_type : int64_t
      tensor_name : ShapeTensor
      tensors_name : ShapeTensorList

- op : equal
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : equal_all
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : erf
  inputs :
    x : X
  outputs :
    out : Out

- op : erfinv
  inputs :
    x : X
  outputs :
    out : Out

- op : exp
  backward : exp_grad, exp_double_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : expand (expand_v2)
  backward : expand_grad (expand_v2_grad), expand_double_grad(expand_v2_double_grad)
  inputs :
    x : X
  attrs :
   shape : shape
  outputs :
    out : Out
  int_array:
    shape :
      data_type : int
      tensor_name : Shape
      tensors_name : expand_shapes_tensor
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]
  manual_signature : [expand, expand_grad]

- op : expand_as (expand_as_v2)
  backward : expand_as_grad (expand_as_v2_grad)
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : expm1
  backward : expm1_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : exponential_ (exponential)
  backward : exponential__grad (exponential_grad)
  inputs :
    x : X
  outputs :
    out : Out
  attrs :
    lam : lambda

- op : eye
  outputs :
    out : Out
  scalar :
    num_rows :
      support_tensor : true
    num_columns :
      support_tensor : true

- op : fake_channel_wise_dequantize_max_abs
  inputs :
    {x : X, scales : Scales}
  outputs :
    out : Out

- op : fake_channel_wise_quantize_abs_max
  inputs :
    x : X
  outputs :
    out : Out
    out_scale : OutScale

- op : fake_channel_wise_quantize_dequantize_abs_max
  inputs :
    x : X
  outputs :
    out : Out
    out_scale : OutScale

- op : fake_dequantize_max_abs
  inputs :
    {x : X, scale : Scale}
  outputs :
    out : Out

- op : fake_quantize_abs_max
  inputs :
    x : X
  outputs :
    out : Out
    out_scale : OutScale

- op : fake_quantize_dequantize_abs_max
  inputs :
    x : X
  outputs :
    out : Out
    out_scale : OutScale

- op : fake_quantize_dequantize_moving_average_abs_max
  inputs :
    x : X
    in_scale : InScale
    in_accum : InAccum
    in_state : InState
  outputs :
    out : Out
    out_scale : OutScale
    out_state : OutState
    out_accum : OutAccum

- op : fake_quantize_moving_average_abs_max
  inputs :
    x : X
    in_scale : InScale
    in_accum : InAccum
    in_state : InState
  outputs :
    out : Out
    out_scale : OutScale
    out_state : OutState
    out_accum : OutAccum

- op : fake_quantize_range_abs_max
  inputs :
    x : X
    in_scale : InScale
    iter : Iter
  outputs :
    out : Out
    out_scale : OutScale
    out_scales : OutScales

- op : faster_tokenizer
  inputs:
    {vocab : Vocab, text : Text, text_pair : TextPair}
  outputs:
    {input_ids : InputIds, segment_ids : SegmentIds}

- op : fc
  inputs :
    input : Input
    w : W
    bias : Bias
  outputs :
    out : Out
  attrs :
    {scale_in : Scale_in, scale_out : Scale_out, scale_weights : Scale_weights}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_quantizer = false, str mkldnn_data_type = "float32", str onednn_data_type = "", float Scale_in = 1.0f, "float[] Scale_weights = {1.0f}", float Scale_out = 1.0f, bool force_fp32_output = false, str fuse_activation = "" , float fuse_alpha = 0.0f, float fuse_beta = 0.0f, float fused_output_scale = 1.0f, 'int[] fused_reshape2_shape = {}']

- op : feed
  outputs: {out: Out}

- op : fetch_barrier
  inputs:
    x : X
  outputs:
    out : Out

- op : fft_c2c
  inputs: {x: X}
  outputs: {out: Out}

- op : fft_c2r
  inputs: {x: X}
  outputs: {out: Out}

- op : fft_r2c
  inputs: {x: X}
  outputs: {out: Out}

- op : fill (fill_any)
  backward : fill_grad (fill_any_grad)
  inputs :
    x : X
  outputs :
    out : Out
  scalar :
    value :
      data_type : float
      support_tensor : true

- op : fill_diagonal
  backward : fill_diagonal_grad
  inputs :
    x : X
  outputs :
    out : Out

- op : fill_diagonal_tensor
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : flash_attn_unpadded
  backward : flash_attn_unpadded_grad
  scalar :
    max_seqlen_q :
      data_type : int64_t
      support_tensor : true
    max_seqlen_k :
      data_type : int64_t
      support_tensor : true

- op : flash_attn_v3_varlen
  backward : flash_attn_v3_varlen_grad
  scalar :
    max_seqlen_q :
      data_type : int64_t
      support_tensor : true
    max_seqlen_k :
      data_type : int64_t
      support_tensor : true

- op : flash_attn_varlen_qkvpacked
  backward : flash_attn_varlen_qkvpacked_grad
  scalar :
    max_seqlen_q :
      data_type : int64_t
      support_tensor : true
    max_seqlen_k :
      data_type : int64_t
      support_tensor : true

- op : flatten (flatten_contiguous_range)
  backward : flatten_grad (flatten_contiguous_range_grad)
  inputs :
    x : X
  outputs :
    {out : Out, xshape : XShape}
  attrs :
    {start_axis : start_axis, stop_axis : stop_axis}
  extra :
    outputs : [xshape]
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]
  manual_signature : [flatten, flatten_grad]

- op : flip
  inputs :
    x : X
  outputs :
    out : Out

- op : floor
  backward : floor_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : floor_divide (elementwise_floordiv)
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]
  complex_promote : [X, Y]
  manual_signature : [floor_divide]

- op : fmax (elementwise_fmax)
  backward : fmax_grad (elementwise_fmax_grad)
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]
  complex_promote : [X, Y]
  manual_signature : [fmax]

- op : fmin (elementwise_fmin)
  backward : fmin_grad (elementwise_fmin_grad)
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]
  complex_promote : [X, Y]
  manual_signature : [fmin]

- op : fold
  inputs :
    x : X
  outputs :
    out : Y

- op : frame
  backward : frame_grad
  inputs :
    x : X
  outputs :
    out : Out

- op : frobenius_norm
  backward : frobenius_norm_grad
  inputs:
    x : X
  attrs:
    { axis : dim,  keepdim : keep_dim}
  outputs:
    out : Out
  int_array:
    axis :
      data_type : int
      support_tensor : true
  get_expected_kernel_type :
    frobenius_norm : GetReduceExpectedKernelType
    frobenius_norm_grad : GetReduceGradExpectedKernelType
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : full (fill_constant)
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : full_like (fill_any_like)
  inputs :
    x : X
  outputs :
    out : Out
  scalar :
    value :
      data_type : float
      support_tensor : true

- op : full_with_tensor
  int_array:
    shape :
      data_type : int64_t
      support_tensor : true

- op : fused_adam_(fused_adam)
  inputs :
    {params : Params, grads : Grads, learning_rate : LearningRate, moments1 : Moments1,
     moments2 : Moments2, moments2_max : Moments2Max, beta1_pows : Beta1Pows, beta2_pows : Beta2Pows, master_params : MasterParams,
     skip_update : SkipUpdate}
  outputs :
    {params_out : ParamsOut, moments1_out : Moments1Out, moments2_out : Moments2Out, moments2_max_out : Moments2MaxOut,
     beta1_pows_out : Beta1PowsOut, beta2_pows_out : Beta2PowsOut, master_params_out : MasterParamsOut}

- op : fused_attention
  backward: fused_attention_grad
  inputs:
    x: X
    ln_scale: LnScale
    ln_bias: LnBias
    qkv_weight: QKVW
    qkv_bias: QKVBias
    cache_kv: CacheKV
    src_mask: SrcMask
    out_linear_weight: OutLinearW
    out_linear_bias: OutLinearBias
    ln_scale_2: Ln2Scale
    ln_bias_2: Ln2Bias
  outputs:
    ln_mean: LnMean
    ln_var: LnVariance
    ln_out: LnOut
    qkv_out: QKVOut
    qkv_bias_out: QKVBiasOut
    transpose_out_2: TransposeOut2
    qk_out: QKOut
    qktv_out: QKTVOut
    softmax_out: SoftmaxOut
    attn_dropout_mask_out: AttnDropoutMaskOut
    attn_dropout_out: AttnDropoutOut
    src_mask_out: SrcMaskOut
    fmha_out: FMHAOut
    out_linear_out: OutLinearOut
    dropout_mask_out: DropoutMaskOut
    ln_mean_2: Ln2Mean
    ln_var_2: Ln2Variance
    bias_dropout_residual_out: BiasDropoutResidualOut
    cache_kv_out: CacheKVOut
    out: Y

- op : fused_batch_norm_act
  backward : fused_batch_norm_act_grad
  inputs:
    x : X
    mean : Mean
    variance : Variance
    scale : Scale
    bias : Bias
  outputs :
    out : Y
    mean_out: MeanOut
    variance_out: VarianceOut
    saved_mean: SavedMean
    saved_variance: SavedVariance
    reserve_space: ReserveSpace

- op : fused_bias_dropout_residual_layer_norm
  backward : fused_bias_dropout_residual_layer_norm_grad
  inputs :
    x : X
    residual : Residual
    bias : Bias
    ln_scale : LnScale
    ln_bias : LnBias
  outputs :
    bias_dropout_residual_out : BiasDropoutResidualOut
    dropout_mask_out : DropoutMaskOut
    ln_mean : LnMean
    ln_variance : LnVariance
    y : Y

- op : fused_bn_add_activation_ (fused_bn_add_activation)
  backward : fused_bn_add_activation_grad
  inputs:
    x : X
    z : Z
    mean : Mean
    variance : Variance
    scale : Scale
    bias : Bias
  outputs :
    out : Y
    mean_out: MeanOut
    variance_out: VarianceOut
    saved_mean: SavedMean
    saved_variance: SavedVariance
    reserve_space: ReserveSpace

- op : fused_conv2d
  inputs :
    {input : Input, filter : Filter, bias : Bias, residual_param : ResidualData}
  outputs :
    {output : Output}
  attrs :
    {scale_in : Scale_in, scale_out : Scale_out, scale_in_eltwise : Scale_in_eltwise, scale_weights : Scale_weights}
  extra :
    attrs : [bool use_cudnn = false, float fuse_alpha = 0.0f, float fuse_beta = 0.0f, float Scale_in = 1.0f,
             float Scale_out = 1.0f, float Scale_in_eltwise = 1.0f, 'float[] Scale_weights = {1.0f}', bool use_mkldnn = true, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]

- op : fused_conv2d_add_act
  inputs :
    input : Input
    filter : Filter
    bias : Bias
    residual_data : ResidualData
  outputs :
    output : Output
    outputs : Outputs
  extra :
    attrs : [bool is_test = false, bool use_cudnn = true, bool fuse_relu_before_depthwise_conv = false, bool use_mkldnn = false, bool use_onednn = false,
             bool use_quantizer = false, str mkldnn_data_type = "float32", str onednn_data_type = "", bool fuse_relu = false,
             str fuse_activation = "", float fuse_beta = 0.0f, bool use_addto = false,
             bool fuse_residual_connection = false, float Scale_in = 1.0f, float Scale_out = 1.0f,
             float Scale_in_eltwise = 1.0f, 'float[] Scale_weights = {1.0f}', bool force_fp32_output = false]
  get_expected_kernel_type :
    fused_conv2d_add_act : GetConvExpectedKernelType

- op : fused_conv3d
  inputs :
    {input : Input, filter : Filter, bias : Bias, residual_param : ResidualData}
  outputs :
    {output : Output}
  attrs :
    {scale_in : Scale_in, scale_out : Scale_out, scale_in_eltwise : Scale_in_eltwise, scale_weights : Scale_weights}
  extra :
    attrs : [bool use_cudnn = false, float fuse_alpha = 0.0f, float fuse_beta = 0.0f, float Scale_in = 1.0f,
             float Scale_out = 1.0f, float Scale_in_eltwise = 1.0f, 'float[] Scale_weights = {1.0f}', bool use_mkldnn = true, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]

- op : fused_elementwise_add
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}

- op : fused_elementwise_div
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}

- op : fused_elementwise_mul
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}

- op : fused_elementwise_sub
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}

- op : fused_embedding_eltwise_layernorm
  inputs :
    ids : Ids
    embs : Embs
    bias : Bias
    scale : Scale
  outputs :
    out : Out

- op : fused_embedding_fc_lstm
  inputs:
    {ids : Ids, embeddings : Embeddings, weight_h : WeightH, bias : Bias, h0 : H0, c0 : C0}
  outputs:
    {hidden : Hidden, cell : Cell, xx : XX, batched_input : BatchedInput, batched_hidden : BatchedHidden, batched_cell : BatchedCell, reordered_h0 : ReorderedH0, reordered_c0 : ReorderedC0}

- op : fused_fc_elementwise_layernorm
  inputs :
    x : X
    w : W
    y : Y
    bias0 : Bias0
    scale : Scale
    bias1 : Bias1
  outputs :
    out : Out
    mean : Mean
    variance : Variance

- op : fused_feedforward
  backward: fused_feedforward_grad
  inputs:
    x: X
    dropout1_seed: Dropout1Seed
    dropout2_seed: Dropout2Seed
    linear1_weight: Linear1Weight
    linear1_bias: Linear1Bias
    linear2_weight: Linear2Weight
    linear2_bias: Linear2Bias
    ln1_scale: Ln1Scale
    ln1_bias: Ln1Bias
    ln2_scale: Ln2Scale
    ln2_bias: Ln2Bias
  attrs:
    dropout1_seed_val: dropout1_seed
    dropout2_seed_val: dropout2_seed
    dropout1_prob: dropout1_rate
    dropout2_prob: dropout2_rate
  outputs:
    out: Out
    dropout1_mask: Dropout1Mask
    dropout2_mask: Dropout2Mask
    ln1_mean: Ln1Mean
    ln1_variance: Ln1Variance
    ln2_mean: Ln2Mean
    ln2_variance: Ln2Variance
    linear1_out: Linear1Out
    ln1_out: Ln1Out
    dropout1_out: Dropout1Out
    dropout2_out: Dropout2Out

- op : fused_gate_attention
  backward: fused_gate_attention_grad
  inputs:
    {query : Query, key : Key, query_weight : QueryWeight, key_weight : KeyWeight, value_weight : ValueWeight, qkv_weight : QKVWeight, nonbatched_bias : NonbatchedBias, src_mask : SrcMask, gate_weight : GateWeight, gate_bias : GateBias, out_linear_weight : OutLinearWeight, out_linear_bias : OutLinearBias}
  outputs:
    {query_transpose_out : QueryTransposeOut, key_transpose_out : KeyTransposeOut, value_transpose_out : ValueTransposeOut, qkv_transpose_out : QKVTransposeOut, softmax_out : SoftmaxOut, softmax_lse : SoftmaxLse, fmha_out : FMHAOut, gate_out : GateOut, out : Out}

- op : fused_gemm_epilogue
  inputs:
    {x : X, y : Y, bias : Bias}
  outputs :
    {out : Out, reserve_space: ReserveSpace}

- op : fused_gemm_epilogue_grad
  inputs:
    {x : X, y : Y, reserve_space: ReserveSpace, out_grad : DOut}
  outputs :
    {x_grad : DX, y_grad : DY, bias_grad : DBias}

- op : fused_multi_transformer_int8
  inputs:
    {x : X, ln_scale : LnScale, ln_bias : LnBias, qkv_w : QKVW, qkv_bias : QKVBias, cache_kv : CacheKV,
    time_step : TimeStep, src_mask : SrcMask, out_linear_w : OutLinearW, out_linear_bias : OutLinearBias,
    ffn_ln_scale : FFNLnScale, ffn_ln_bias : FFNLnBias, ffn1_weight : FFN1Weight, ffn1_bias : FFN1Bias,
    ffn2_weight : FFN2Weight, ffn2_bias : FFN2Bias, qkv_out_scale : QKVOutScale, out_linear_out_scale : OutLinearOutScale,
    ffn1_out_scale : FFN1OutScale, ffn2_out_scale : FFN2OutScale}
  outputs:
    {cache_kv_out : CacheKVOut, out : Out}

- op : fused_seqpool_cvm
  backward: fused_seqpool_cvm_grad
  inputs:
    {x : X, cvm : CVM}
  outputs:
    out : Out
  drop_empty_grad : [x_grad]

- op : fused_transpose
  inputs:
    {x : X}
  outputs :
    {out : Out}
  extra :
    attrs : [str data_format = "AnyLayout"]

- op : fusion_gru
  inputs :
    x : X
    h0 : H0
    weight_x : WeightX
    weight_h : WeightH
    bias : Bias
  outputs :
    reordered_h0 : ReorderedH0
    xx : XX
    batched_input : BatchedInput
    batched_out : BatchedOut
    hidden : Hidden
  attrs :
    {scale_data : Scale_data, shift_data : Shift_data, scale_weights : Scale_weights}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "", float Scale_data = 1.0f, float Shift_data = 0.0f, 'float[] Scale_weights = {1.0f}']

- op : fusion_lstm
  inputs :
    x : X
    h0 : H0
    weight_x : WeightX
    weight_h : WeightH
    bias : Bias
    c0 : C0
  outputs :
    out : Out
    hidden : Hidden
    cell : Cell
    xx : XX
    batched_input : BatchedInput
    batched_hidden : BatchedHidden
    batched_cell : BatchedCell
    reordered_h0 : ReorderedH0
    reordered_c0 : ReorderedC0
    checked_cell : CheckedCell
  attrs :
    {scale_data : Scale_data, shift_data : Shift_data, scale_weights : Scale_weights}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]

- op : fusion_repeated_fc_relu
  inputs :
    x : X
    w : W
    bias : Bias
  outputs :
    relu_out : ReluOut
    out : Out

- op : fusion_seqconv_eltadd_relu
  inputs :
    x : X
    filter : Filter
    bias : Bias
  outputs :
    out : Out
    col_mat : ColMat
  attrs :
    context_length : contextLength
    context_start : contextStart
    context_stride : contextStride

- op : fusion_seqpool_concat
  inputs:
    x : X
  outputs:
    out : Out

- op : fusion_transpose_flatten_concat
  inputs :
    x : X
  outputs :
    out : Out

- op : gather
  backward : gather_grad, gather_double_grad
  inputs :
    {x : X, index : Index}
  outputs :
    out : Out
  scalar :
    axis :
      data_type : int
      tensor_name : Axis

- op : gather_nd
  backward : gather_nd_grad
  inputs :
    {x : X, index : Index}
  outputs :
    out : Out

- op : gather_tree
  inputs :
    {ids : Ids, parents : Parents}
  outputs :
    out : Out

- op : gaussian (gaussian_random)
  outputs :
    out : Out
  int_array:
    shape :
      data_type : int64_t
      tensor_name : ShapeTensor
      tensors_name : ShapeTensorList
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]
  manual_signature : [gaussian]

- op : gelu
  backward : gelu_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]

- op : generate_proposals(generate_proposals_v2)
  inputs :
    {scores : Scores, bbox_deltas : BboxDeltas, im_shape : ImShape, anchors : Anchors, variances : Variances}
  outputs :
    {rpn_rois : RpnRois, rpn_roi_probs : RpnRoiProbs, rpn_rois_num : RpnRoisNum}
  attrs :
    {pre_nms_top_n : pre_nms_topN, post_nms_top_n : post_nms_topN}

- op : global_gather
  backward : global_gather_grad
  inputs :
    x : X
  outputs:
    out : Out

- op : global_scatter
  inputs :
    {x : X}
  outputs :
    out : Out

- op : grad_add
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]

- op : graph_khop_sampler
  inputs :
    {row : Row, colptr : Col_Ptr, x : X, eids : Eids}
  outputs :
    {out_src : Out_Src, out_dst : Out_Dst, sample_index : Sample_Index, reindex_x : Reindex_X, out_eids : Out_Eids}

- op : graph_sample_neighbors
  inputs :
    {row : Row, colptr : Col_Ptr, x : X, eids : Eids, perm_buffer : Perm_Buffer}
  outputs :
    {out : Out, out_count : Out_Count, out_eids : Out_Eids}

- op : greater_equal
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : greater_than
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : grid_sample(grid_sampler)
  backward : grid_sample_grad (grid_sampler_grad)
  inputs :
    {x : X, grid : Grid}
  outputs :
    out : Output
  extra :
    attrs : [bool use_cudnn = true]

- op : group_norm
  inputs :
    x : X
    scale : Scale
    bias : Bias
  outputs :
    y : Y
    mean : Mean
    variance : Variance
  attrs:
    data_format: data_layout

- op : gumbel_softmax
  inputs :
    x : X
  outputs :
    out : Out

- op : hardshrink (hard_shrink)
  backward : hardshrink_grad (hard_shrink_grad)
  inputs :
    x : X
  outputs :
    out : Out

- op : hardsigmoid (hard_sigmoid)
  backward : hardsigmoid_grad (hard_sigmoid_grad)
  inputs :
    x : X
  outputs :
    out : Out

- op : hardswish (hard_swish)
  inputs :
    x : X
  outputs :
    out : Out
  backward : hardswish_grad (hard_swish_grad)
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]
  manual_signature : [hardswish]

- op : hardtanh (brelu)
  backward : hardtanh_grad (brelu_grad)
  inputs :
    x : X
  outputs :
    out : Out

- op : hash
  inputs:
    x : X
  attrs :
    runtime_shape : ALL_KERNELS_MUST_COMPUTE_RUNTIME_SHAPE
  outputs:
    out : Out

- op : heaviside (elementwise_heaviside)
  backward : heaviside_grad (elementwise_heaviside_grad)
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]
  complex_promote : [X, Y]

- op : hinge_loss
  backward: hinge_loss_grad
  inputs:
    {logits : Logits, labels : Labels}
  outputs:
    loss : Loss

- op : histogram
  inputs :
    {input: X, weight : Weight}
  outputs :
    out : Out

- op : hsigmoid_loss(hierarchical_sigmoid)
  backward: hsigmoid_loss_grad(hierarchical_sigmoid_grad)
  inputs:
   {x: X, w: W, label: Label, bias: Bias, path: PathTable, code: PathCode}
  outputs:
   {out: Out, pre_out: PreOut, w_out: W_Out}

- op : huber_loss
  backward : huber_loss_grad
  inputs :
    {input : X, label : Y}
  outputs :
    {out : Out, residual : Residual}

- op : im2sequence
  inputs:
    {x : X, y : Y}
  outputs:
    out : Out

- op : imag
  backward : imag_grad
  inputs :
    x : X
  outputs :
    out : Out

- op : increment
  inputs :
    x : X
  outputs :
    out : Out

- op : index_add
  inputs :
    {x : X, index : Index, add_value : AddValue}
  outputs :
    out : Out

- op : index_elementwise_get
  backward : index_elementwise_get_grad, index_elementwise_get_double_grad
  inputs :
     {x : x, index : index, input_dims : input_dims, input_strides : input_strides, index_dims : index_dims, index_stride : index_stride}
  outputs :
     out : Out
  attrs : {slice_offset : slice_offset, accumulate : accumulate, is_combined : is_combined}

- op : index_elementwise_put
  backward : index_elementwise_put_grad, index_elementwise_put_double_grad

- op : index_elementwise_put_with_tensor
  backward : index_elementwise_put_with_tensor_grad, index_elementwise_put_with_tensor_double_grad
  outputs :
     out : Out

- op : index_sample
  inputs :
    {x : X, index : Index}
  outputs :
    out : Out

- op : index_select
  backward : index_select_grad, index_select_double_grad
  inputs :
    {x : X, index : Index}
  outputs :
    out : Out
  attrs :
    axis : dim

- op : instance_norm
  inputs :
    x : X
    scale : Scale
    bias : Bias
  outputs :
    y : Y
    saved_mean : SavedMean
    saved_variance : SavedVariance
  extra:
    outputs: [ saved_mean, saved_variance ]
  get_expected_kernel_type:
    instance_norm: GetInstanceNormExpectedKernelType

- op : inverse
  inputs :
    x : Input
  outputs :
    out : Output

- op : is_empty
  inputs :
    x : X
  outputs :
    out : Out

- op : isclose
  inputs :
    {x : Input, y : Other}
  outputs :
    out : Out
  scalar :
    rtol :
      data_type : std::string
      tensor_name : Rtol
    atol :
      data_type : std::string
      tensor_name : Atol

- op : isfinite (isfinite_v2)
  inputs :
    x : X
  outputs :
    out : Out

- op : isinf (isinf_v2)
  inputs :
    x : X
  outputs :
    out : Out

- op : isnan (isnan_v2)
  inputs :
    x : X
  outputs :
    out : Out

- op : kldiv_loss
  backward : kldiv_loss_grad
  inputs :
    {x : X, label : Target}
  outputs :
    out : Loss

- op : kron
  backward : kron_grad
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}
  complex_promote : [X, Y]

- op : kthvalue
  inputs :
    x : X
  outputs :
    {out : Out, indices : Indices}

- op : l1_norm
  inputs :
    x : X
  outputs :
    out : Out
  backward : l1_norm_grad
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : label_smooth
  inputs :
    {label : X, prior_dist : PriorDist}
  outputs :
    out : Out

- op : lamb_ (lamb)
  inputs :
    {param : Param, grad : Grad, learning_rate : LearningRate, moment1 : Moment1, moment2 : Moment2, beta1_pow : Beta1Pow, beta2_pow : Beta2Pow, master_param : MasterParam, skip_update : SkipUpdate}
  outputs :
    {param_out : ParamOut, moment1_out : Moment1Out, moment2_out : Moment2Out, beta1_pow_out : Beta1PowOut, beta2_pow_out : Beta2PowOut, master_param_outs : MasterParamOut}

- op : layer_norm
  backward : layer_norm_grad
  inputs :
    x : X
    scale : Scale
    bias : Bias
  outputs :
    out : Y
    mean : Mean
    variance : Variance
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "", bool is_test = false]
  get_expected_kernel_type :
    layer_norm : GetLayerNormExpectedKernelType

- op : leaky_relu
  backward : leaky_relu_grad, leaky_relu_double_grad (leaky_relu_grad_grad)
  inputs :
    x : X
  outputs :
    out : Out
  attrs:
    negative_slope : alpha
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : legacy_bilinear_interp (bilinear_interp)
  backward : legacy_bilinear_interp_grad (bilinear_interp_grad)
  inputs :
    {x : X, out_size : OutSize, size_tensor : SizeTensor, scale_tensor : Scale}
  outputs :
    output : Out
  attrs:
    data_format: data_layout
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : legacy_expand (expand)
  backward : legacy_expand_grad (expand_grad)
  inputs :
    x : X
  attrs :
   shape : expand_times
  outputs :
    out : Out
  int_array:
    shape :
      data_type : int
      tensor_name : ExpandTimes
      tensors_name : expand_times_tensor
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]
  manual_signature : [legacy_expand, legacy_expand_grad]

- op : legacy_generate_proposals(generate_proposals)
  inputs:
    {scores : Scores, bbox_deltas : BboxDeltas, im_info : ImInfo, anchors : Anchors, variances : Variances}
  attrs:
    {pre_nms_top_n : pre_nms_topN, post_nms_top_n : post_nms_topN}
  outputs:
    {rpn_rois : RpnRois, rpn_roi_probs : RpnRoiProbs, rpn_rois_num : RpnRoisNum}

- op : legacy_matmul (matmul)
  backward : legacy_matmul_grad (matmul_grad), legacy_matmul_double_grad (matmul_grad_grad)
  inputs :
    {x : X, y : Y, out_grad : DOut, x_grad_grad : DDX, y_grad_grad : DDY}
  attrs :
    {transpose_x : transpose_X, transpose_y : transpose_Y}
  outputs :
    {out : Out, x_grad : DX, y_grad : DY}
  extra :
    attrs : [bool use_quantizer = false, str mkldnn_data_type = "float32", str onednn_data_type = "",
             float Scale_x = 1.0f, float Scale_y = 1.0f,
             float Scale_out = 1.0f, bool force_fp32_output = false]
  complex_promote : [X, Y]

- op : legacy_nearest_interp (nearest_interp)
  backward : legacy_nearest_interp_grad (nearest_interp_grad)
  inputs :
    {x : X, out_size : OutSize, size_tensor : SizeTensor, scale_tensor : Scale}
  outputs :
    output : Out
  attrs:
    data_format: data_layout
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : legacy_reshape (reshape)
  backward : legacy_reshape_grad (reshape_grad)
  inputs:
    x : X
  outputs:
    out : Out
    xshape: XShape
  int_array:
    shape :
      data_type : int
      tensor_name : Shape
      tensors_name : ShapeTensor
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "", bool use_quantizer = false]

- op : lerp
  backward : lerp_grad
  inputs :
    {x : X, y : Y, weight : Weight}
  outputs :
    out : Out

- op : less_equal
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : less_than
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : lgamma
  inputs :
    x : X
  outputs :
    out : Out

- op : linear_interp (linear_interp_v2)
  backward : linear_interp_grad (linear_interp_v2_grad)
  inputs :
    {x : X, out_size : OutSize, size_tensor : SizeTensor, scale_tensor : Scale}
  outputs :
    output : Out
  attrs:
    data_format: data_layout
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : linear_v2
  backward : linear_v2_grad, linear_v2_double_grad

- op : linspace
  inputs :
    {start : Start, stop : Stop, number : Num}
  outputs :
    out : Out

- op : lod_reset
  backward : lod_reset_grad
  inputs:
    {x : X, y : Y}
  outputs:
    out : Out

- op : log
  backward : log_grad, log_double_grad (log_grad_grad)
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : log10
  backward : log10_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : log1p
  backward : log1p_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : log2
  backward : log2_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : log_loss
  backward : log_loss_grad
  inputs :
    {input : Predicted, label : Labels}
  outputs :
    out : Loss

- op : log_softmax
  backward : log_softmax_grad
  inputs :
    x : X
  outputs :
    out: Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : logcumsumexp
  backward : logcumsumexp_grad
  inputs :
    x : X
  outputs :
    out : Out

- op : logical_and
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : logical_not
  inputs :
    x : X
  outputs :
    out : Out

- op : logical_or
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : logical_xor
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : logit
  inputs :
    x : X
  outputs :
    out : Out

- op : logsigmoid
  backward : logsigmoid_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : logsumexp
  backward : logsumexp_grad
  inputs :
    x : X
  outputs :
    out : Out

- op : lookup_table
  backward: lookup_table_grad
  inputs:
    {w : W, ids : Ids}
  outputs:
    out : Out
  extra:
    attrs: [int slot = 0]
  manual_signature : [lookup_table, lookup_table_grad]

- op : lrn
  backward : lrn_grad
  inputs :
    x : X
  outputs :
    {out : Out, mid_out : MidOut}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool is_test = false]

- op : lstsq
  inputs :
    {x : X, y : Y}
  outputs :
    {solution : Solution, residuals : Residuals, rank : Rank, singular_values : SingularValues}
  scalar :
    rcond :
      data_type : float
      support_tensor : true

- op : lu_unpack
  backward : lu_unpack_grad
  inputs :
    {x : X, y : Pivots}
  outputs :
    {pmat : Pmat, l : L, u : U}

- op : margin_cross_entropy
  backward : margin_cross_entropy_grad
  inputs:
    {logits : Logits, label : Label}
  outputs:
    {softmax : Softmax, loss : Loss}

- op : masked_select
  backward : masked_select_grad, masked_select_double_grad
  inputs :
    {x : X, mask : Mask}
  outputs :
    out : Y

- op : match_matrix_tensor
  backward: match_matrix_tensor_grad
  inputs:
    {x : X, y : Y, w : W}
  outputs:
    {out : Out, tmp : Tmp}

- op : matmul (matmul_v2)
  backward : matmul_grad (matmul_v2_grad), matmul_double_grad (matmul_v2_grad_grad), matmul_triple_grad (matmul_v2_triple_grad)
  inputs :
    {x : X, y : Y}
  attrs :
    {transpose_x : trans_x, transpose_y : trans_y}
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "", bool force_fp32_output = false]
  complex_promote : [X, Y]

- op : matmul_with_flatten (mul)
  backward : matmul_with_flatten_grad (mul_grad)
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, float scale_x = 1.0f, 'float[] scale_y = {1.0f}',
             float scale_out = 1.0f, bool force_fp32_output = false]

- op : matrix_nms
  inputs :
    {bboxes : BBoxes, scores : Scores}
  outputs :
    {out : Out, index : Index, roisnum : RoisNum}
  get_expected_kernel_type :
    matrix_nms : GetMatrixNmsExpectedKernelType

- op : matrix_power
  inputs :
    x : X
  outputs :
    out : Out

- op : matrix_rank
  inputs :
    {x : X, tol_tensor : TolTensor}
  outputs :
    out : Out
  manual_signature : [matrix_rank]

- op : max (reduce_max)
  backward : max_grad (reduce_max_grad)
  inputs:
    x : X
  attrs:
    { axis : dim,  keepdim : keep_dim}
  outputs:
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]
  int_array:
    axis :
      data_type : int
      support_tensor : true
  get_expected_kernel_type :
    max : GetReduceExpectedKernelType
    max_grad : GetReduceGradExpectedKernelType
  manual_signature : [max]

- op : max_pool2d_with_index
  inputs :
    {x : X}
  outputs :
    {out : Out, mask : Mask}
  attrs :
    kernel_size : ksize

- op : max_pool3d_with_index
  inputs :
    {x : X}
  outputs :
    {out : Out, mask : Mask}
  attrs :
    kernel_size : ksize

- op : maximum (elementwise_max)
  backward : maximum_grad (elementwise_max_grad)
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]
  complex_promote : [X, Y]
  manual_signature : [maximum]

- op : maxout
  inputs :
    x : X
  outputs :
    out : Out

- op : mean (reduce_mean)
  backward : mean_grad (reduce_mean_grad)
  inputs :
    x : X
  outputs :
    out : Out
  attrs :
    {axis : dim, keepdim : keep_dim}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]
  int_array:
      axis :
        data_type : int
        support_tensor : true

- op : mean_all (mean)
  backward : mean_all_grad (mean_grad)
  inputs :
    x : X
  outputs :
    out : Out

- op : memory_efficient_attention
  backward : memory_efficient_attention_grad
  scalar :
    max_seqlen_q :
      data_type : int64_t
      support_tensor : true
    max_seqlen_k :
      data_type : int64_t
      support_tensor : true

- op : merge_selected_rows
  inputs :
    x : X
  outputs :
    out : Out

- op : merged_adam_
  inputs :
    {param: Param, grad: Grad, learning_rate: LearningRate, moment1: Moment1, moment2: Moment2, moment2_max: Moment2Max, beta1_pow: Beta1Pow, beta2_pow: Beta2Pow, master_param: MasterParam}
  outputs :
    {param_out: ParamOut, moment1_out: Moment1Out, moment2_out: Moment2Out, moment2_max_out: Moment2MaxOut, beta1_pow_out: Beta1PowOut, beta2_pow_out: Beta2PowOut, master_param_out: MasterParamOut}
  scalar :
    beta1 :
      data_type : float
      support_tensor : true
    beta2 :
      data_type : float
      support_tensor : true
    epsilon :
      data_type : float
      support_tensor : true

- op : merged_momentum_ (merged_momentum)
  inputs :
    {param : Param, grad : Grad, velocity : Velocity, learning_rate : LearningRate, master_param : MasterParam}
  outputs :
    {param_out : ParamOut, velocity_out : VelocityOut, master_param_out : MasterParamOut}

- op : meshgrid
  backward : meshgrid_grad
  inputs :
    inputs : X
  outputs :
    out : Out
  drop_empty_grad : [inputs_grad]

- op : min (reduce_min)
  backward : min_grad (reduce_min_grad)
  inputs:
    x : X
  outputs:
    out : Out
  attrs:
    { axis : dim,  keepdim : keep_dim}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]
  int_array:
    axis :
      data_type : int
      support_tensor : true
  get_expected_kernel_type :
    min : GetReduceExpectedKernelType
    min_grad : GetReduceGradExpectedKernelType
  manual_signature : [min]

- op : minimum (elementwise_min)
  backward : minimum_grad (elementwise_min_grad)
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32", str onednn_data_type = "",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]
  complex_promote : [X, Y]
  manual_signature : [minimum]

- op : mish
  backward : mish_grad
  inputs:
    {x : X, lambda : threshold}
  outputs:
    out: Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : mode
  backward : mode_grad
  inputs :
    x : X
  outputs :
    {out : Out, indices : Indices}

- op : momentum_ (momentum)
  inputs :
    {param : Param, grad : Grad, velocity : Velocity, learning_rate : LearningRate, master_param : MasterParam}
  outputs :
    {param_out : ParamOut, velocity_out : VelocityOut, master_param_out : MasterParamOut}

- op : moving_average_abs_max_scale
  inputs :
    {x : X, in_accum : InAccum, in_state : InState}
  outputs :
    {out : Out, out_scale : OutScale, out_state : OutState, out_accum : OutAccum}

- op : multi_dot
  backward : multi_dot_grad
  inputs :
    x : X
  outputs :
    out : Out
  drop_empty_grad : [x_grad]

- op : multi_gru
  inputs :
    {x : X, weight_x : WeightX, weight_h : WeightH, bias : Bias, scale_weights : Scale_weights}
  outputs :
    hidden : Hidden
  attrs :
    {scale_data : Scale_data,  shift_data : Shift_data}
  manual_signature : [multi_gru]

- op : multiclass_nms
  inputs:
    {bboxes : BBoxes, scores : Scores}
  outputs:
    out : Out
  get_expected_kernel_type :
    multiclass_nms : GetMulticlassNmsExpectedKernelType

- op : multiclass_nms3
  inputs :
    {bboxes : BBoxes, scores : Scores, rois_num : RoisNum}
  outputs :
    {out : Out, index : Index, nms_rois_num : NmsRoisNum}

- op : multihead_matmul
  inputs :
    {input : Input, w : W, bias : Bias, bias_qk : BiasQK}
  outputs :
    out : Out
  attrs :
    {transpose_q : transpose_Q,  transpose_k : transpose_K, transpose_v : transpose_V}

- op : multinomial
  inputs :
    {x : X}
  outputs :
    out : Out
  scalar :
    num_samples :
      data_type : int
      support_tensor : true

- op : multiplex
  backward : multiplex_grad
  inputs :
    {inputs : X, index : Ids}
  outputs :
    out : Out
  drop_empty_grad : [inputs_grad]

- op : multiply (elementwise_mul)
  backward : multiply_grad (elementwise_mul_grad)
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]

- op : mv
  inputs :
    {x : X, vec : Vec}
  outputs :
    out : Out

- op : nanmedian
  backward : nanmedian_grad
  inputs :
    {x : X}
  outputs :
    {out : Out, medians : MedianIndex}
  int_array:
    axis:
      data_type : int
  extra:
    outputs : [medians]

- op : nearest_interp (nearest_interp_v2)
  backward : nearest_interp_grad (nearest_interp_v2_grad)
  inputs :
    {x : X, out_size : OutSize, size_tensor : SizeTensor, scale_tensor : Scale}
  outputs :
    output : Out
  attrs:
    data_format: data_layout
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : nll_loss
  backward : nll_loss_grad
  inputs :
    {input : X, label : Label, weight : Weight}
  outputs :
    {out : Out, total_weight : Total_weight}

- op : nms
  inputs :
    x : Boxes
  outputs :
    out : KeepBoxesIdxs
  attrs :
    threshold : iou_threshold

- op : nonzero (where_index)
  inputs :
    condition : Condition
  outputs :
    out : Out

- op : norm
  backward : norm_grad
  inputs :
    x : X
  outputs :
    {out : Out, norm : Norm}
  extra :
    outputs : [norm]

- op : not_equal
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : numel(size)
  inputs :
    x : Input
  outputs :
    size : Out

- op : one_hot (one_hot_v2)
  inputs :
    x : X
  outputs :
    out : Out
  scalar :
    depth :
      data_type : int
      tensor_name : depth_tensor

- op : overlap_add
  backward : overlap_add_grad
  inputs :
    x : X
  outputs :
    out : Out

- op : p_norm
  backward: p_norm_grad
  inputs :
    x : X
  outputs :
    out : Out

- op : pad
  backward : pad_grad, pad_double_grad
  inputs :
    x : X
  outputs :
    out : Out
  scalar:
    pad_value:
      data_type : float
      support_tensor : true

- op : pad2d
  backward : pad2d_grad
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : pad3d
  backward : pad3d_grad, pad3d_double_grad
  inputs :
    x : X
  outputs :
    out : Out
  int_array:
    paddings :
      data_type : int
      tensor_name : Paddings
  attrs :
    pad_value : value
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : partial_allgather
  inputs :
    x : X
  outputs :
    out : Out

- op : partial_concat
  backward : partial_concat_grad
  inputs :
    x : X
  outputs :
    out : Out
  drop_empty_grad : [x_grad]
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : partial_recv
  outputs :
    out : Out

- op : partial_sum
  backward : partial_sum_grad
  inputs :
    x : X
  outputs :
    out : Out
  drop_empty_grad : [x_grad]
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : pixel_shuffle
  backward : pixel_shuffle_grad
  inputs :
    x : X
  outputs :
    out : Out

- op : pixel_unshuffle
  backward : pixel_unshuffle_grad
  inputs :
    x : X
  outputs :
    out : Out

- op : poisson
  inputs :
    x : X
  outputs :
    out : Out

- op : pool2d
  backward : pool2d_grad, pool2d_double_grad
  inputs :
    {x : X}
  outputs :
    {out : Out}
  attrs :
    {kernel_size : ksize}
  int_array:
    kernel_size :
      data_type : int
      support_tensor : true
  get_expected_kernel_type :
    pool2d : GetPoolExpectedKernelType
    pool2d_grad : GetPoolExpectedKernelType
    pool2d_double_grad : GetPoolDoubleGradExpectedKernelType
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_quantizer = false,
              str mkldnn_data_type = "float32", str onednn_data_type = "", bool is_test = false]

- op : pool3d
  backward : pool3d_grad
  inputs :
    {x : X}
  outputs :
    {out : Out}
  attrs :
    {kernel_size : ksize}
  get_expected_kernel_type :
    pool3d : GetPoolExpectedKernelType
    pool3d_grad : GetPoolExpectedKernelType
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : pow
  backward : pow_grad, pow_double_grad, pow_triple_grad
  inputs :
    x : X
  outputs :
    out : Out
  attrs :
    y : factor
  scalar :
    y :
      data_type : float
      tensor_name : FactorTensor

- op : prelu
  backward : prelu_grad
  inputs :
    { x : X, alpha : Alpha}
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "", bool is_test = false]

- op : print
  inputs :
    in : In
  outputs :
    out : Out

- op : prior_box
  inputs :
    {input: Input, image: Image}
  outputs :
    {out: Boxes, var: Variances}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_quantizer = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]

- op : prod (reduce_prod)
  backward : prod_grad (reduce_prod_grad)
  inputs:
    x : X
  outputs:
    out : Out
  attrs:
    { axis : dim,  keepdim : keep_dim}
  int_array:
    axis :
      data_type : int
      support_tensor : true
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]
  get_expected_kernel_type :
    prod : GetReduceExpectedKernelType
    prod_grad : GetReduceGradExpectedKernelType
  manual_signature : [prod]

- op : psroi_pool
  backward : psroi_pool_grad
  inputs :
    {x : X, boxes : ROIs, boxes_num : RoisNum}
  outputs :
    out : Out

- op : put_along_axis
  backward : put_along_axis_grad, put_along_axis_double_grad
  inputs :
    {arr : Input, indices : Index, values : Value}
  outputs :
    out : Result
  attrs :
    {axis : Axis, reduce : Reduce, include_self: Include_self}

- op : pylayer
  backward : pylayer_grad
  extra :
    attrs : ['str[] skip_eager_deletion_vars = {}']

- op : qr
  backward : qr_grad
  inputs :
    x : X
  outputs :
    {q : Q, r : R}

- op : quantize
  inputs :
    input : Input
  outputs :
    output : Output
  attrs :
    {scale : Scale, shift : Shift, include_self: Include_self}

- op : quantize_linear
  inputs :
    {x : X, scale : Scale, zero_point : ZeroPoint, in_accum : InAccum, in_state : InState}
  outputs :
    {y : Y, out_scale : OutScale, out_accum : OutAccum, out_state : OutState}
  extra :
    attrs : [float moving_rate = 0.9]

- op : randint
  outputs :
    out : Out
  int_array:
    shape :
      data_type : int64_t
      tensor_name : ShapeTensor
      tensors_name : ShapeTensorList
  manual_signature : [randint]

- op : randperm
  outputs :
    out : Out
  extra :
    attrs : [int seed = 0]

- op : range_v2
  inputs :
    {start : Start, end : End, step : Step}
  outputs :
    out : Out
  scalar:
    start:
      data_type : double
      support_tensor : true
    end:
      data_type : double
      support_tensor : true
    step:
      data_type : double
      support_tensor : true

- op : real
  backward : real_grad
  inputs :
    x : X
  outputs :
    out : Out

- op : reciprocal
  backward : reciprocal_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : relu
  backward : relu_grad, relu_double_grad (relu_grad_grad)
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]

- op : relu6
  backward : relu6_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, float threshold = 6.0]

- op : remainder (elementwise_mod)
  inputs :
    {x : X, y : Y}
  outputs :
    {out : Out}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]
  complex_promote : [X, Y]
  manual_signature : [remainder]

- op : renorm
  backward : renorm_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : repeat_interleave
  inputs :
    x : X
  outputs :
    out : Out
  attrs :
    repeats : Repeats

- op : repeat_interleave
  backward : repeat_interleave_grad, repeat_interleave_double_grad
  inputs :
    x : X
  outputs :
    out : Out
  attrs :
    {repeats : Repeats, axis : dim}

- op : repeat_interleave_with_tensor_index
  backward : repeat_interleave_with_tensor_index_grad, repeat_interleave_with_tensor_index_double_grad
  inputs :
    {x : X, repeats: RepeatTensor}
  outputs:
    out : Out
  attrs:
    axis : dim

- op : requantize
  inputs :
    input : Input
  outputs :
    output : Output
  attrs :
    {scale_in : Scale_in, scale_out : Scale_out, shift_in : Shift_in, shift_out : Shift_out}

- op : reshape (reshape2)
  backward : reshape_grad (reshape2_grad)
  inputs:
    x : X
  outputs:
    out : Out
    xshape: XShape
  int_array:
    shape :
      data_type : int
      tensor_name : Shape
      tensors_name : ShapeTensor
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "", bool use_quantizer = false]

- op : resnet_basic_block
  backward: resnet_basic_block_grad
  inputs:
    {x : X, filter1 : Filter1, scale1 : Scale1, bias1 : Bias1, mean1 : Mean1, var1 : Var1, filter2 : Filter2, scale2 : Scale2, bias2 : Bias2, mean2 : Mean2, var2 : Var2, filter3 : Filter3, scale3 : Scale3, bias3 : Bias3, mean3 : Mean3, var3 : Var3}
  outputs:
    {out : Y, conv1 : Conv1, saved_mean1 : SavedMean1, saved_invstd1 : SavedInvstd1, mean1_out : Mean1Out, var1_out : Var1Out, conv2 : Conv2, conv2_input : Conv2Input, saved_mean2 : SavedMean2, saved_invstd2 : SavedInvstd2, mean2_out : Mean2Out, var2_out : Var2Out, conv3 : Conv3, saved_mean3 : SavedMean3, saved_invstd3 : SavedInvstd3, mean3_out : Mean3Out, var3_out : Var3Out, max_input1 : MaxInput1, max_filter1 : MaxFilter1, max_input2 : MaxInput2, max_filter2 : MaxFilter2, max_input3 : MaxInput3, max_filter3 : MaxFilter3}

- op : resnet_unit
  backward: resnet_unit_grad
  inputs:
    {x : X, filter_x : FilterX, scale_x : ScaleX, bias_x : BiasX, mean_x : MeanX, var_x : VarX, z : Z, filter_z : FilterZ, scale_z : ScaleZ, bias_z : BiasZ, mean_z : MeanZ, var_z : VarZ}
  outputs:
    {out : Y, bit_mask : BitMask, conv_x : ConvX, saved_mean_x : SavedMeanX, saved_invstd_x : SavedInvstdX, running_mean_x : RunningMeanX, running_var_x : RunningVarX, conv_z : ConvZ, saved_mean_z : SavedMeanZ, saved_invstd_z : SavedInvstdZ, running_mean_z : RunningMeanZ, running_var_z : RunningVarZ}

- op : reverse
  inputs:
    x : X
  outputs:
    out : Out
  int_array:
    axis :
      data_type : int
      support_tensor : true
  manual_signature : [reverse]

- op : rmsprop_ (rmsprop)
  inputs :
    {param: Param, mean_square: MeanSquare, mean_grad: MeanGrad, learning_rate: LearningRate, grad: Grad, moment: Moment, master_param: MasterParam}
  outputs :
    {param_out: ParamOut, moment_out: MomentOut, mean_square_out: MeanSquareOut, mean_grad_out: MeanGradOut, master_param_outs: MasterParamOut}

- op : rnn
  backward : rnn_grad
  inputs:
    { x : Input, pre_state : PreState, weight_list : WeightList, sequence_length : SequenceLength}
  outputs:
    { out : Out, dropout_state_out : DropoutState, state : State, reserve : Reserve}
  drop_empty_grad : [pre_state_grad, weight_list_grad]

- op : roi_align
  backward : roi_align_grad
  inputs :
    {x : X, boxes : ROIs, boxes_num : RoisNum}
  outputs :
    out : Out

- op : roi_pool
  backward : roi_pool_grad
  inputs :
    {x : X, boxes : ROIs, boxes_num : RoisNum}
  outputs :
    {out : Out, arg_max : Argmax}

- op : roll
  backward : roll_grad
  inputs :
    x : X
  outputs :
    out : Out
  int_array :
    shifts :
      data_type : int64_t
      tensor_name : ShiftsTensor

- op : round
  backward : round_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : row_conv
  backward : row_conv_grad
  inputs :
    {x : X, filter : Filter}
  outputs :
    {out : Out}

- op : rsqrt
  backward : rsqrt_grad, rsqrt_double_grad (rsqrt_grad_grad)
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : save_combine
  inputs :
    {x : X}

- op : scale
  backward : scale_grad
  inputs :
    x : X
  outputs :
    out : Out
  scalar :
    scale :
      data_type : float
      tensor_name : ScaleTensor
    bias :
      data_type : float
      support_tensor : false
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]

- op : scatter
  backward : scatter_grad
  inputs :
    {x : X, index : Ids, updates : Updates}
  outputs :
    out : Out

- op : scatter_nd_add
  backward : scatter_nd_add_grad
  inputs :
    {x : X, index : Index, updates : Updates}
  outputs :
    out : Out

- op : searchsorted
  inputs :
    {sorted_sequence : SortedSequence, values : Values}
  outputs :
    out : Out

- op : seed
  outputs :
    out : Out
  extra :
    attrs : [bool deterministic = false, str rng_name = "", bool force_cpu = false]

- op : segment_pool
  backward : segment_pool_grad
  inputs :
    {x : X, segment_ids : SegmentIds}
  outputs :
    {out : Out, summed_ids : SummedIds}

- op : self_dp_attention
  inputs :
    x : X
  outputs :
    out : Out

- op : selu
  backward : selu_grad
  inputs :
    x : X
  outputs :
    out : Out

- op : send_u_recv(graph_send_recv)
  backward : send_u_recv_grad(graph_send_recv_grad)
  inputs :
    {x : X, src_index : Src_index, dst_index : Dst_index}
  outputs :
    {out : Out, dst_count : Dst_count}
  int_array :
    out_size:
      data_type : int64_t
      tensor_name : Out_size

- op : send_ue_recv(graph_send_ue_recv)
  backward : send_ue_recv_grad(graph_send_ue_recv_grad)
  inputs :
    {x : X, y : Y, src_index : Src_index, dst_index : Dst_index}
  outputs :
    {out : Out, dst_count : Dst_count}
  int_array :
    out_size:
      data_type : int64_t
      tensor_name : Out_size

- op : send_uv (graph_send_uv)
  backward : send_uv_grad (graph_send_uv_grad)

- op : sequence_expand
  backward: sequence_expand_grad
  inputs:
    {x : X, y : Y}
  outputs:
    out : Out

- op : sequence_mask
  inputs:
    x : X
  attrs:
    max_len: maxlen
  outputs:
    y : Y
  scalar :
    max_len :
      data_type : int
      tensor_name : MaxLenTensor

- op : sequence_softmax
  backward : sequence_softmax_grad
  inputs:
    x : X
  outputs:
    out : Out
  extra :
    attrs : [str data_format = "AnyLayout", bool use_cudnn = false]

- op : sgd_ (sgd)
  inputs :
    {param : Param, learning_rate : LearningRate, grad : Grad, master_param : MasterParam}
  outputs :
    {param_out : ParamOut, master_param_out : MasterParamOut}
  get_expected_kernel_type :
    sgd_ : GetSgdExpectedKernelType
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : shape
  inputs :
    input : Input
  outputs :
    out : Out

- op : shape
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]

- op : shard_index
  inputs :
    input : X
  outputs :
    out : Out

- op : share_buffer
  inputs :
    x : X
  outputs :
    out : Out
    xout : XOut

- op : share_data
  inputs:
    x : X
  outputs:
    out : Out

- op : shuffle_batch
  backward: shuffle_batch_grad
  inputs:
    {x : X, seed : Seed}
  outputs:
    {out : Out, shuffle_idx : ShuffleIdx, seed_out : SeedOut}

- op : shuffle_channel
  backward : shuffle_channel_grad
  inputs:
    {x : X, group : group}
  outputs:
    {out : Out}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : sigmoid
  backward : sigmoid_grad, sigmoid_double_grad (sigmoid_grad_grad), sigmoid_triple_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]

- op : sign
  backward : sign_grad
  inputs :
    x : X
  outputs :
    out : Out

- op : silu
  backward : silu_grad, silu_double_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : sin
  backward : sin_grad, sin_double_grad, sin_triple_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : sinh
  backward : sinh_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : slice
  backward : slice_grad
  inputs :
    input : Input
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]
  int_array :
    starts :
      data_type : int
      tensor_name : StartsTensor
      tensors_name : StartsTensorList
    ends :
      data_type : int
      tensor_name : EndsTensor
      tensors_name : EndsTensorList

- op : slogdet(slogdeterminant)
  backward : slogdet_grad(slogdeterminant_grad)
  inputs :
    x : Input
  outputs :
    out : Out

- op : soft_relu
  backward : soft_relu_grad
  inputs :
    x : X
  outputs :
    out : Out

- op : softmax
  backward : softmax_grad
  inputs :
    x : X
  outputs :
    out : Out
  get_expected_kernel_type :
    softmax : GetSoftmaxExpectedKernelType
    softmax_grad : GetSoftmaxGradExpectedKernelType
  extra :
    attrs : [str data_format = "AnyLayout", bool use_cudnn = true, bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "", bool is_test = false]

- op : softplus
  backward : softplus_grad, softplus_double_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : softshrink
  backward : softshrink_grad
  inputs :
    x : X
  outputs :
    out : Out
  attrs :
    threshold : lambda

- op : softsign
  backward : softsign_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : solve
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : sparse_batch_norm
  attrs:
    data_format: data_layout

- op : sparse_reshape
  int_array :
    shape :
      data_type : int64_t
      tensor_name : ShapeTensor
      tensors_name : ShapeTensorList

- op : sparse_slice
  int_array :
    starts :
      data_type : int
      tensor_name : StartsTensor
      tensors_name : StartsTensorList
    ends :
      data_type : int
      tensor_name : EndsTensor
      tensors_name : EndsTensorList

- op : sparse_sum
  scalar :
    axis :
      data_type : int
      tensor_name : AxisTensor

- op : sparse_sync_batch_norm
  attrs:
    data_format: data_layout

- op : spectral_norm
  backward : spectral_norm_grad
  inputs :
    {weight : Weight, u : U, v : V}
  outputs :
    out : Out

- op : split
  backward : split_grad
  inputs:
    x : X
  outputs:
    out : Out
  int_array:
    sections :
      data_type : int
      support_tensor : true
  scalar :
    axis :
      data_type : int
      support_tensor : true
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]

- op : split_with_num
  scalar :
    axis :
      data_type : int
      support_tensor : true
      tensor_name : AxisTensor

- op : sqrt
  backward : sqrt_grad, sqrt_double_grad (sqrt_grad_grad)
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : square
  backward : square_grad, square_double_grad (square_grad_grad)
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : squeeze (squeeze2)
  backward : squeeze_grad (squeeze2_grad), squeeze_double_grad(squeeze2_double_grad)
  inputs :
    x : X
  attrs :
   axis : axes
  outputs :
    {out : Out, xshape : XShape}
  int_array:
    axis :
      data_type : int
      support_tensor : true
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]
    outputs : [xshape]

- op : stack
  backward : stack_grad, stack_double_grad
  inputs :
    x : X
  outputs :
    out : Y
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]
  drop_empty_grad : [x_grad]

- op : stanh
  backward : stanh_grad
  inputs :
    x : X
  outputs :
    out : Out

- op : straight_through_estimator_grad
  inputs :
    x : X
  outputs :
    out : Out

- op : strided_slice
  backward : strided_slice_grad
  inputs :
    x : Input
  outputs :
    out : Out
  int_array :
    starts :
      data_type : int
      tensor_name : StartsTensor
      tensors_name : StartsTensorList
    ends :
      data_type : int
      tensor_name : EndsTensor
      tensors_name : EndsTensorList
    strides :
      data_type : int
      tensor_name : StridesTensor
      tensors_name : StridesTensorList
  manual_signature : [strided_slice, strided_slice_grad]
  get_expected_kernel_type :
    strided_slice : GetStridedSliceExpectedKernelType
    strided_slice_grad : GetStridedSliceGradExpectedKernelType

- op : subtract (elementwise_sub)
  backward : subtract_grad (elementwise_sub_grad)
  inputs :
    {x : X, y: Y}
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = "",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]
  complex_promote : [X, Y]

- op : sum (reduce_sum)
  backward : sum_grad (reduce_sum_grad), sum_double_grad
  inputs:
    {x : X}
  outputs:
    out : Out
  attrs:
    { axis : dim,  keepdim : keep_dim, dtype : out_dtype}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str mkldnn_data_type = "float32", str onednn_data_type = ""]
  int_array:
      axis :
        data_type : int
        support_tensor : true
  get_expected_kernel_type :
    sum : GetReduceExpectedKernelType
    sum_grad : GetReduceGradExpectedKernelType
  manual_signature : [sum]

- op : svd
  backward : svd_grad
  inputs :
    x : X
  outputs :
    {u : U, s : S, vh : VH}

- op : swish
  backward : swish_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, float beta = 1.0]

- op : sync_batch_norm
  inputs :
    {x : X, scale : Scale, bias : Bias, mean : Mean, variance : Variance}
  outputs :
    {out : Y, mean_out : MeanOut, variance_out : VarianceOut, saved_mean : SavedMean, saved_variance : SavedVariance, reserve_space : ReserveSpace}
  backward : sync_batch_norm_grad
  attrs:
    data_format: data_layout
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool fuse_with_relu = false]

- op : take_along_axis
  backward : take_along_axis_grad
  inputs :
    {arr : Input, indices : Index}
  outputs :
    out : Result
  attrs :
    axis : Axis

- op : tan
  backward : tan_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : tanh
  backward : tanh_grad, tanh_double_grad (tanh_grad_grad), tanh_triple_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : tanh_shrink
  backward : tanh_shrink_grad
  inputs :
    x : X
  outputs :
    out : Out
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false, bool use_cudnn = false]

- op : tdm_child
  inputs :
    {x : X , tree_info : TreeInfo, child_nums: child_nums, dtype: dtype}
  outputs :
    {child : Child, leaf_mask : LeafMask}
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : tdm_sampler
  inputs:
    {x : X, travel : Travel, layer : Layer}
  outputs:
    {out : Out, labels : Labels, mask : Mask}

- op : thresholded_relu
  inputs :
    x : X
  outputs :
    out : Out

- op : tile
  backward : tile_grad, tile_double_grad
  inputs :
    x : X
  outputs :
    out : Out
  int_array:
    repeat_times :
      data_type : int
      tensor_name : RepeatTimes
      tensors_name : repeat_times_tensor

- op : topk (top_k_v2)
  backward : topk_grad (top_k_v2_grad)
  inputs :
    x : X
  outputs :
    {out : Out, indices : Indices}
  scalar :
    k :
      data_type : int
      tensor_name : K

- op : topk_v1 (top_k)
  backward : topk_v1_grad (top_k_grad)
  inputs :
    x : X
  outputs :
    {out : Out, indices : Indices}
  scalar :
    k :
      data_type : int
      tensor_name : K

- op : trace
  inputs :
    x : Input
  outputs :
    out : Out

- op : transpose (transpose2)
  backward : transpose_grad (transpose2_grad)
  inputs :
    x : X
  outputs :
    out : Out
  attrs:
    perm : axis
  extra :
    outputs : [XShape]
    attrs : [bool use_mkldnn = false, bool use_onednn = false, str data_format = "AnyLayout", str mkldnn_data_type = "float32", str onednn_data_type = ""]

- op : triangular_solve
  backward : triangular_solve_grad
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

- op : tril_triu
  backward : tril_triu_grad
  inputs :
    {x: X}
  outputs :
    {out : Out}

- op : trilinear_interp (trilinear_interp_v2)
  backward : trilinear_interp_grad (trilinear_interp_v2_grad)
  inputs :
    {x : X, out_size : OutSize, size_tensor : SizeTensor, scale_tensor : Scale}
  outputs :
    output : Out
  attrs:
    data_format: data_layout
  extra :
    attrs : [bool use_mkldnn = false, bool use_onednn = false]

- op : trunc
  inputs :
    input : X
  outputs :
    out : Out

- op : truncated_gaussian_random
  outputs :
    out : Out

- op : unbind
  inputs :
    input : X
  outputs :
    out : Out

- op : unfold
  inputs :
    x : X
  outputs :
    out : Y

- op : uniform (uniform_random)
  outputs :
    out : Out
  int_array :
    shape :
      data_type : int64_t
      tensor_name : ShapeTensor
      tensors_name : ShapeTensorList
  scalar :
      min :
        data_type : float
        support_tensor : true
      max :
        data_type : float
        support_tensor : true
  manual_signature : [uniform]

- op : uniform_inplace (uniform_random_inplace)
  backward : uniform_inplace_grad(uniform_random_inplace_grad)
  inputs :
    x : X
  outputs :
    out : Out

- op : unique
  inputs :
    {x : X}
  outputs :
    {out : Out, indices : Indices, inverse : Index, counts : Counts}
  get_expected_kernel_type :
    unique : GetUniqueExpectedKernelType
  manual_signature : [unique]

- op : unique_consecutive
  inputs :
    x : X
  outputs :
    {out : Out, index : Index, counts : Counts}

- op : unpool
  inputs :
    {x : X, indices: Indices}
  outputs :
    out : Out
  attrs :
   padding : paddings
  int_array :
    output_size:
      data_type : int
      support_tensor : true

- op : unpool3d
  inputs :
    {x : X, indices: Indices}
  outputs :
    out : Out

- op : unsqueeze (unsqueeze2)
  backward : unsqueeze_grad (unsqueeze2_grad), unsqueeze_double_grad(unsqueeze2_double_grad)
  inputs :
    x : X
  attrs :
   axis : axes
  outputs :
    {out : Out, xshape : XShape}
  int_array:
    axis :
      data_type : int
      tensor_name : AxesTensor
      tensors_name : AxesTensorList
  extra :
    outputs : [xshape]

- op : unstack
  backward : unstack_grad
  inputs :
    x : X
  outputs :
    out : Y

- op : update_loss_scaling_(update_loss_scaling)
  inputs :
    {x : X, found_infinite : FoundInfinite, prev_loss_scaling : PrevLossScaling, in_good_steps : InGoodSteps, in_bad_steps : InBadSteps}
  outputs :
    {out : Out, loss_scaling : LossScaling, out_good_steps : OutGoodSteps, out_bad_steps : OutBadSteps}
  scalar :
    stop_update :
      data_type : bool
      tensor_name : StopUpdate
  get_expected_kernel_type :
    update_loss_scaling_ : GetUpdateLossScalingExpectedKernelType

- op : view_shape
  backward : view_shape_grad, view_shape_double_grad

- op : viterbi_decode
  inputs :
    {potentials : Input, transition_params : Transition, lengths : Length}
  outputs :
    {scores : Scores, path : Path}

- op : warpctc
  backward : warpctc_grad
  inputs :
    {logits : Logits, label : Label, logits_length : LogitsLength, labels_length : LabelLength}
  outputs :
    {warpctcgrad : WarpCTCGrad, loss : Loss}

- op : where
  backward : where_grad, where_double_grad
  inputs :
    {condition : Condition, x : X, y : Y}
  outputs :
    out : Out

- op : while
  backward : while_grad
  extra :
    attrs : ['str[] skip_eager_deletion_vars = {}']

- op : yolo_box
  inputs :
    {x : X, img_size : ImgSize}
  outputs :
    {boxes : Boxes, scores : Scores}

- op : yolo_box_head
  inputs :
    {x : X}
  outputs :
    {out : Out}

- op : yolo_box_post
  inputs :
    {boxes0 : Boxes0, boxes1 : Boxes1, boxes2 : Boxes2, image_shape : ImageShape, image_scale : ImageScale}
  outputs :
    {out : Out, nms_rois_num : NmsRoisNum}

- op : yolo_loss (yolov3_loss)
  backward: yolo_loss_grad (yolov3_loss_grad)
  inputs :
    {x : X,  gt_box : GTBox, gt_label : GTLabel ,gt_score : GTScore}
  outputs :
    {loss : Loss , objectness_mask : ObjectnessMask, gt_match_mask : GTMatchMask}
  get_expected_kernel_type :
    yolo_loss : GetYoloLossExpectedKernelType
    yolo_loss_grad : GetYoloLossExpectedKernelType

- op: box_clip
  inputs:
    {input : Input, im_info : ImInfo}
  outputs:
    output : Output

- op: c_allreduce_sum
  inputs :
    x : X
  outputs :
    out: Out

- op: c_identity
  inputs :
    x : X
  outputs :
    out: Out

- op: c_scatter
  inputs :
    x : X
  outputs :
    out: Out

- op: channel_shuffle
  inputs:
    {x: X}
  outputs:
    {out: Out}

- op: chunk_eval
  inputs:
    {inference : Inference, label : Label, seq_length : SeqLength}
  outputs:
    {precision : Precision, recall : Recall, f1_score : F1-Score, num_infer_chunks : NumInferChunks, num_label_chunks : NumLabelChunks, num_correct_chunks : NumCorrectChunks}

- op: comm_init_all

- op: crf_decoding
  inputs:
    emission: Emission
    transition: Transition
    label: Label
    length: Length
  outputs:
    viterbi_path: ViterbiPath

- op: cross_entropy
  backward: cross_entropy_grad
  inputs:
    {x : X, label : Label}
  outputs:
    out : Y

- op: cross_entropy2
  backward: cross_entropy_grad2
  inputs:
    {x : X, label : Label}
  outputs:
    {out : Y, x_shape : XShape, match_x : MatchX}

- op: ctc_align
  inputs:
    {input : Input, input_length : InputLength}
  outputs:
    {output : Output, output_length : OutputLength}

- op: cudnn_lstm
  backward: cudnn_lstm_grad
  inputs:
    {x: Input, init_h: InitH, init_c: InitC, w: W, weight_list: WeightList, sequence_length: SequenceLength}
  outputs:
    {reserve: Reserve, state_out: StateOut, out: Out, last_h: LastH, last_c: LastC}
  drop_empty_grad : [weight_list_grad]

- op: decayed_adagrad
  inputs:
    {param : Param, grad : Grad, moment : Moment, learning_rate : LearningRate}
  outputs:
    {param_out : ParamOut, moment_out : MomentOut}

- op: depend
  inputs:
    {x : X, dep : Dep}
  outputs:
    out : Out

- op: dgc
  inputs:
    {u: U, v: V, grad: Grad}
  outputs:
    {u_out: U_out, v_out: V_out, encode_grad: EncodeGrad, grad_out: Grad_out, gather_buff: GatherBuff}

- op: dgc
  inputs:
    {u : U, v : V, grad : Grad, param : Param}
  outputs:
    {u_out : U_out, v_out : V_out, encode_grad : EncodeGrad, grad_out : Grad_out, gather_buff : GatherBuff}

- op: distribute_fpn_proposals
  inputs :
    {fpn_rois: FpnRois, rois_num: RoisNum}
  outputs :
    multi_fpn_rois : MultiFpnRois
    multi_level_rois_num: MultiLevelRoIsNum
    restore_index: RestoreIndex

- op: distributed_fused_lamb_init
  inputs:
    {param: Param, grad: Grad}
  outputs:
    {fp32_fused_param: FP32FusedParam, fp32_fused_grad: FP32FusedGrad, fp16_fused_param: FP16FusedParam, fp16_fused_grad: FP16FusedGrad, moment1: Moment1, moment2: Moment2, beta1_pow: Beta1Pow, beta2_pow: Beta2Pow, fused_param_offsets: FusedParamOffsets, fp32_shard_fused_param_offsets: FP32ShardFusedParamOffsets, fp16_shard_fused_param_offsets: FP16ShardFusedParamOffsets, param_info: ParamInfo, param_order: ParamOrder, param_out: ParamOut, master_param_out: MasterParamOut, grad_out: GradOut, global_scale: GlobalScale, step: Step}

- op: dpsgd
  inputs:
    {param: Param,grad: Grad,learning_rate: LearningRate}
  outputs:
    param_out : ParamOut

- op: fetch (fetch_v2)
  inputs: {x: X}
  outputs: {out: Out}

- op: flatten2
  backward: flatten2_grad
  inputs:
    x : X
  outputs:
    {out : Out, x_shape : XShape}

- op: ftrl
  inputs:
    {param: Param, squared_accumulator: SquaredAccumulator, linear_accumulator: LinearAccumulator, grad: Grad, learning_rate: LearningRate}
  outputs:
    {param_out: ParamOut, squared_accum_out: SquaredAccumOut, linear_accum_out: LinearAccumOut}

- op: full_batch_size_like (fill_constant_batch_size_like)
  inputs:
    {input: Input}
  outputs:
    {out: Out}

- op: fused_elemwise_activation
  backward: fused_elemwise_activation_grad
  inputs:
    {x : X, y : Y}
  outputs:
    {out : Out, intermediate_out : IntermediateOut}

- op: fused_elemwise_add_activation
  backward: fused_elemwise_add_activation_grad
  inputs :
    {x: X, y: Y}
  outputs :
    {out : Out, intermediate_out : IntermediateOut}

- op: fused_elemwise_add_activation
  backward: fused_elemwise_add_activation_grad
  inputs:
    {x : X, y : Y}
  outputs:
    {out : Out, intermediate_out : IntermediateOut}

- op: fused_matmul
  inputs :
    {x: X, y: Y, residual_data: ResidualData}
  outputs :
    {out : Out}
  attrs :
    {scale_x : Scale_x, scale_y : Scale_y, scale_out : Scale_out, scale_in_eltwise : Scale_in_eltwise, fused_reshape_x : fused_reshape_X, fused_transpose_x : fused_transpose_X, fused_reshape_y : fused_reshape_Y, fused_transpose_y : fused_transpose_Y, fused_reshape_out : fused_reshape_Out, fused_transpose_out : fused_transpose_Out}

- op: fused_softmax_mask
  backward : fused_softmax_mask_grad
  inputs :
    {x: X, mask: Mask}
  outputs :
    {out : Out}

- op: fused_softplus
  inputs :
    {x: X}
  outputs :
    {out : Out}

- op: fused_token_prune
  inputs :
    {attn: Attn, x: X, mask: Mask, new_mask: NewMask}
  outputs :
    {slimmed_x : SlimmedX, cls_inds : CLSInds}

- op: fusion_group
  inputs:
    inputs : Inputs
  outputs:
    outs : Outs

- op: fusion_seqpool_cvm_concat
  inputs:
    {x : X, cvm : CVM}
  outputs:
    out : Out

- op: fusion_squared_mat_sub
  inputs :
    x : X
    y : Y
  outputs :
    squared_x : SquaredX
    squared_y : SquaredY
    squared_xy : SquaredXY
    out : Out

- op: get_tensor_from_selected_rows
  inputs :
    x : X
  outputs :
    out : Out

- op: gru
  backward: gru_grad
  inputs:
    {input : Input, h0 : H0, weight : Weight, bias : Bias}
  outputs:
    {batch_gate : BatchGate, batch_reset_hidden_prev : BatchResetHiddenPrev, batch_hidden : BatchHidden, hidden : Hidden}
  extra :
    attrs : [bool is_test = false]
    outputs : [batch_gate, batch_reset_hidden_prev, batch_hidden]

- op: gru_unit
  backward: gru_unit_grad
  inputs:
    {input : Input, hidden_prev : HiddenPrev, weight : Weight, bias : Bias}
  outputs:
    {gate : Gate, reset_hidden_prev : ResetHiddenPrev, hidden : Hidden}

- op: identity_loss
  inputs :
    x: X
  outputs :
    out : Out

- op: lars_momentum_ (lars_momentum)
  inputs:
    {param : Param, grad : Grad, velocity : Velocity, learning_rate : LearningRate, master_param : MasterParam}
  outputs :
    {param_out: ParamOut, velocity_out: VelocityOut, master_param_out: MasterParamOut}

- op: legacy_crop (crop)
  backward: legacy_crop_grad (crop_grad)
  inputs:
    {x : X, y : Y}
  outputs:
    out : Out
  int_array:
    offsets :
      data_type : int
      tensor_name : Offsets

- op: limit_by_capacity
  outputs :
    out : Out

- op: lod_array_length
  inputs :
    {x: X}
  outputs :
    out : Out

- op: logspace
  inputs:
    {start: Start, stop: Stop, num: Num, base: Base}
  outputs:
    {out: Out}

- op: lookup_table_dequant
  inputs:
    {w : W, ids : Ids}
  outputs:
    out : Out

- op: lstm
  backward: lstm_grad
  inputs:
    {input : Input, h0 : H0, c0 : C0, weight : Weight, bias : Bias}
  outputs:
    {hidden : Hidden, cell : Cell, batch_gate : BatchGate, batch_cell_pre_act : BatchCellPreAct}
  extra:
    outputs: [batch_gate, batch_cell_pre_act]

- op: lu
  backward: lu_grad
  inputs:
    x: X
  outputs:
    {out: Out, pivots : Pivots, infos : Infos}
  attrs:
    pivot : pivots

- op: match_matrix_tensor
  backward: match_matrix_tensor_grad
  inputs:
    {x : X, y : Y, w : W}
  outputs:
    {out : Out, tmp : Tmp}

- op: memcpy
  inputs:
    x: X
  outputs:
    out: Out

- op: memcpy_d2h
  inputs :
    x : X
  outputs :
    out : Out

- op: mp_allreduce_sum
  inputs :
    x : X
  outputs :
    out: Out

- op: nce
  backward: nce_grad
  inputs:
    {input : Input, label : Label, weight : Weight, bias : Bias, sample_weight : SampleWeight, custom_dist_probs : CustomDistProbs, custom_dist_alias : CustomDistAlias, custom_dist_alias_probs : CustomDistAliasProbs}
  outputs:
    {cost : Cost, sample_logits : SampleLogits, sample_labels : SampleLabels}
  extra :
    attrs : [int trainer_id = 0, 'int64_t[] height_sections = {}', 'str[] epmap = {}',
             'str[] table_names = {}', 'int[] custom_neg_classes = {}']

- op: nop
  inputs :
    x : X
  outputs :
    out : Out

- op: number_count
  inputs :
    {numbers: numbers}
  outputs :
    out : Out

- op: partial_send
  inputs :
    x : X

- op: prune_gate_by_capacity
  inputs:
    {gate_idx: GateIdx, expert_count: ExpertCount}
  outputs:
    out_gate_idx: NewGateIdx

- op: pyramid_hash
  backward: pyramid_hash_grad
  inputs:
    {x : X, w : W, white_list : WhiteList, black_list : BlackList}
  outputs:
    {out : Out, drop_pos : DropPos, x_temp_out : X_Temp_Out}

- op: random_routing
  inputs:
    {prob : Prob, topk_value : TopK_Value, topk_idx : TopK_Idx}
  outputs:
    out : Out

- op: rank_attention
  backward: rank_attention_grad
  inputs:
    {x : X, rank_offset : RankOffset, rank_param : RankParam}
  outputs:
    {input_help : InputHelp, out : Out, ins_rank: InsRank}
  attrs:
    {max_rank : MaxRank, max_size : MaxSize}

- op: rank_attention
  backward: rank_attention_grad
  inputs:
    {x : X, rank_offset : RankOffset, rank_param : RankParam}
  attrs:
    {max_rank : MaxRank, max_size : MaxSize}
  outputs:
    {input_help : InputHelp, out : Out, ins_rank : InsRank}

- op: read_from_array
  inputs:
    array : X
    i : I
  outputs :
    out : Out

- op: recv_v2
  outputs :
    out : Out

- op: reindex_graph (graph_reindex)
  inputs :
    {x : X, neighbors : Neighbors, count : Count, hashtable_value : HashTable_Value, hashtable_index : HashTable_Index}
  outputs :
    {reindex_src : Reindex_Src, reindex_dst : Reindex_Dst, out_nodes : Out_Nodes}

- op: rrelu
  inputs:
    {x: X}
  outputs:
    {out: Out, noise: Noise}
  extra:
    outputs: [noise]

- op: send_v2
  inputs :
    x : X

- op: sequence_conv
  backward: sequence_conv_grad
  inputs:
    {x : X, padding_data : PaddingData, filter : Filter}
  attrs:
    {padding_trainable : paddingTrainable, context_length : contextLength, context_start : contextStart, context_stride : contextStride}
  outputs:
    out : Out

- op: sequence_pool
  backward: sequence_pool_grad
  inputs:
    x : X
  outputs:
    {out : Out, max_index : MaxIndex}
  extra:
    attrs: [bool is_test = false]

- op: set_value
  backward: set_value_grad
  inputs:
    x : Input
  outputs:
    out: Out
  int_array:
    starts:
      data_type : int64_t
      tensors_name : StartsTensorList
    ends:
      data_type : int64_t
      tensors_name : EndsTensorList
    steps:
      data_type : int64_t
      tensors_name : StepsTensorList

- op: set_value_with_tensor
  backward: set_value_grad
  inputs:
    x : Input
  outputs:
    out: Out
  int_array:
    starts:
      data_type : int64_t
      tensors_name : StartsTensorList
    ends:
      data_type : int64_t
      tensors_name : EndsTensorList
    steps:
      data_type : int64_t
      tensors_name : StepsTensorList

- op: share_data_ (share_data)
  inputs :
    x : X
  outputs :
    out : Out

- op: sigmoid_cross_entropy_with_logits
  backward: sigmoid_cross_entropy_with_logits_grad
  inputs :
    {x: X, label: Label}
  outputs :
    out : Out

- op: skip_layernorm
  inputs :
    {x: X, y: Y, scale: Scale, bias : Bias}
  outputs :
    out : Out

- op: sparse_attention
  backward: sparse_attention_grad
  inputs:
    {q : Q, k : K, v : V, offset : Offset, columns : Columns, key_padding_mask : KeyPaddingMask, attn_mask : AttnMask}
  outputs:
    {out : Out, sparse_dot_sdd : SparseDotSdd, softmax : Softmax}

- op: sparse_momentum
  inputs :
    {param: Param, grad: Grad, velocity: Velocity, index: Index, axis: Axis, learning_rate: LearningRate,master_param: MasterParam}
  outputs :
    {param_out: ParamOut, velocity_out: VelocityOut, master_param_out: MasterParamOut}
  attrs:
    axis: axis
  scalar:
    axis:
      data_type : int
      tensor_name : Axis

- op: squared_l2_norm
  backward: squared_l2_norm_grad
  inputs :
    x : X
  outputs :
    out : Out

- op: stft
  backward: stft_grad
  inputs:
    {x : X, window : Window}
  outputs:
    out : Out

- op: sync_calc_stream(c_sync_calc_stream)
  inputs :
    x : X
  outputs :
    out : Out

- op: sync_comm_stream(c_sync_comm_stream)
  inputs :
    x : X
  outputs :
    out : Out

- op: temporal_shift
  backward: temporal_shift_grad
  inputs :
    x : X
  outputs :
    out : Out

- op: transfer_layout
  inputs:
    x : X
  outputs:
    out : Out

- op: uniform_random_batch_size_like
  inputs:
     input : Input
  outputs:
     out: Out

- op: write_to_array
  inputs :
    {x: X, i: I}
  outputs :
    out : Out