op_compat.yaml 27.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
# 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.

12 13 14 15 16
# - op : rnn
#   backward : rnn_grad
#   extra :
#     attrs : [bool is_test = false]

17
- op : abs
18
  backward : abs_grad
19 20 21 22
  inputs :
    x : X
  outputs :
    out : Out
23
  extra :
H
HongyuJia 已提交
24
    attrs : [bool use_mkldnn = false]
25

26 27 28 29 30 31
- op : acos
  inputs :
    x : X
  outputs :
    out : Out

32
- op : acosh
33 34 35 36
  inputs :
    x : X
  outputs :
    out : Out
37 38 39 40
  backward : acosh_grad
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

41 42 43 44 45 46
- op : add (elementwise_add)
  backward : add_grad (elementwise_add_grad)
  extra :
    attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]

47
- op : addmm
48 49 50 51
  backward : addmm_grad
  extra :
    attrs : [bool use_mkldnn = false]

52
- op : affine_grid
53 54 55 56
  backward : affine_grid_grad
  extra :
    attrs : [bool use_cudnn = true]

57
- op : angle
58
  backward : angle_grad
59 60 61 62
  inputs :
    x : X
  outputs :
    out : Out
63
  extra :
H
HongyuJia 已提交
64
    attrs : [bool use_mkldnn = false]
65

66 67 68 69 70 71 72
- op : argsort
  inputs :
    x : X
  outputs :
    out : Out
    indices : Indices

73 74 75 76 77 78 79 80 81 82 83 84
- op : as_complex
  inputs :
    x : X
  outputs :
    out : Out

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

85 86 87 88 89 90
- op : asin
  inputs :
    x : X
  outputs :
    out : Out

91
- op : asinh
92
  backward : asinh_grad
93 94 95 96
  inputs :
    x : X
  outputs :
    out : Out
97 98 99
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

100 101 102 103 104 105
- op : atan
  inputs :
    x : X
  outputs :
    out : Out

106
- op : atan2
107
  inputs :
108
    {x : X1, y : X2}
109 110 111
  outputs :
    out : Out

112
- op : atanh
113
  backward : atanh_grad
114 115 116 117
  inputs :
    x : X
  outputs :
    out : Out
118 119 120
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

121
- op : batch_norm
122 123 124 125
  backward : batch_norm_grad
  extra :
    attrs : [bool use_mkldnn = false, bool fuse_with_relu = false]

126
- op : bernoulli
127 128 129 130 131
  inputs :
    x : X
  outputs :
    out : Out

132
- op : bicubic_interp (bicubic_interp_v2)
133 134 135 136
  backward : bicubic_interp_grad (bicubic_interp_v2_grad)
  extra :
    attrs : [bool use_mkldnn = false]

137
- op : bilinear_interp (bilinear_interp_v2)
138 139 140 141
  backward : bilinear_interp_grad (bilinear_interp_v2_grad)
  extra :
    attrs : [bool use_mkldnn = false]

142 143 144 145 146 147
- op : bmm
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

148
- op : ceil
149
  backward : ceil_grad
150 151 152 153
  inputs :
    x : X
  outputs :
    out : Out
154 155 156
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

157 158 159 160 161 162 163
- op : celu
  backward : celu_grad, celu_double_grad(celu_grad_grad)
  inputs :
    x : X
  outputs :
    out : Out

164
- op : cholesky
165 166 167 168 169
  inputs :
    x : X
  outputs :
    out : Out

170
- op : cholesky_solve
171 172 173 174 175
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

176
- op : clip
177 178 179 180
  backward : clip_grad
  extra :
    attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32"]

181
- op : concat
182 183 184 185
  backward : concat_grad
  extra :
    attrs : [bool use_mkldnn = false, bool use_quantizer = false, str mkldnn_data_type = "float32"]

186 187 188 189 190
- op : conditional_block
  backward : conditional_block_grad
  extra :
    attrs : ['str[] skip_eager_deletion_vars = {}']

191 192 193 194 195 196
- op : conj
  inputs :
    x : X
  outputs :
    out : Out

197
- op : conv2d
198
  backward : conv2d_grad
199
  extra :
200
    attrs : [bool is_test = false, bool use_cudnn = true, bool fuse_relu_before_depthwise_conv = false, bool use_mkldnn = false,
201
             bool use_quantizer = false, str mkldnn_data_type = "float32", bool fuse_relu = false,
202
             str fuse_activation = "", float fuse_alpha = 0.0f, float fuse_beta = 0.0f, bool use_addto = false,
203 204
             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,
205
             int workspace_size_MB = phi::backends::gpu::GetDefaultConvWorkspaceSizeLimitMB(), bool exhaustive_search = false]
206

207
- op : conv2d_fusion
F
Feiyu Chan 已提交
208
  extra :
209
    attrs : [bool is_test = false, bool use_cudnn = false, bool fuse_relu_before_depthwise_conv = false, bool use_mkldnn = false,
F
Feiyu Chan 已提交
210
             bool use_quantizer = false, str mkldnn_data_type = "float32", bool fuse_relu = false,
211
             str fuse_activation = "", float fuse_alpha = 0.0f, float fuse_beta = 0.0f, bool use_addto = false,
F
Feiyu Chan 已提交
212 213
             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,
214
             int workspace_size_MB = phi::backends::gpu::GetDefaultConvWorkspaceSizeLimitMB(), bool exhaustive_search = false]
215

216
- op : conv2d_transpose
217 218 219 220 221
  backward : conv2d_transpose_grad
  extra :
    attrs : [bool is_test = false, bool use_cudnn = true, bool use_mkldnn = false, bool force_fp32_output = false,
             str mkldnn_data_type = "float32", bool fuse_relu = false,
             str fuse_activation = "", float fuse_alpha = 0.0f, float fuse_beta = 0.0f,
222
             int workspace_size_MB = phi::backends::gpu::GetDefaultConvWorkspaceSizeLimitMB()]
223

224
- op : conv3d
225 226 227 228 229
  backward : conv3d_grad
  extra :
    attrs : [bool is_test = false, bool use_cudnn = true, bool use_mkldnn = false, str mkldnn_data_type = "float32", 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,
230
             int workspace_size_MB = phi::backends::gpu::GetDefaultConvWorkspaceSizeLimitMB(), bool exhaustive_search = false]
231

232
- op : conv3d_transpose
233 234
  backward : conv3d_transpose_grad
  extra :
235
    attrs : [bool use_cudnn = true, bool use_mkldnn = false, int workspace_size_MB = phi::backends::gpu::GetDefaultConvWorkspaceSizeLimitMB()]
F
Feiyu Chan 已提交
236

237
- op : cos
238
  backward : cos_grad, cos_double_grad, cos_triple_grad
239 240 241 242
  inputs :
    x : X
  outputs :
    out : Out
243 244 245
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

246
- op : cosh
247
  backward : cosh_grad
248 249 250 251
  inputs :
    x : X
  outputs :
    out : Out
252 253 254
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

255
- op : cross
256 257
  inputs :
    {x : X, y : Y}
258 259 260 261 262
  attrs :
    axis : dim
  outputs :
    out : Out

263
- op : data_norm
264 265 266 267
  backward : data_norm_grad
  extra :
    attrs : [bool use_mkldnn = false]

268
- op : depthwise_conv2d
269 270
  backward : depthwise_conv2d_grad
  extra :
271
    attrs : [bool is_test = false, bool fuse_relu_before_depthwise_conv = false, bool use_mkldnn = false,
272 273 274 275
             bool use_quantizer = false, str mkldnn_data_type = "float32", 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,
276
             int workspace_size_MB = phi::backends::gpu::GetDefaultConvWorkspaceSizeLimitMB(), bool exhaustive_search = false]
277

278
- op : depthwise_conv2d_transpose
279 280 281 282 283
  backward : depthwise_conv2d_transpose_grad
  extra :
    attrs : [bool is_test = false, bool use_cudnn = false, bool use_mkldnn = false, bool force_fp32_output = false,
             str mkldnn_data_type = "float32", bool fuse_relu = false,
             str fuse_activation = "", float fuse_alpha = 0.0f, float fuse_beta = 0.0f,
284
             int workspace_size_MB = phi::backends::gpu::GetDefaultConvWorkspaceSizeLimitMB()]
285

286 287 288 289
- op : dequantize_linear
  extra :
    attrs : [float moving_rate = 0.9]

290 291 292 293 294 295 296
- op : det (determinant)
  backward : det_grad (determinant_grad)
  inputs :
    x : Input
  outputs :
    out : Out

297
- op : diag (diag_v2)
298
  backward : diag_grad (diag_v2_grad)
299 300 301 302 303
  inputs :
    x : X
  outputs :
    out : Out

304 305 306 307 308 309
- op : diag_embed
  inputs :
    input : Input
  outputs :
    out : Out

310
- op : diagonal
311 312 313 314 315
  inputs :
    x : Input
  outputs :
    out : Out

316
- op : digamma
317 318 319 320 321
  inputs :
    x : X
  outputs :
    out : Out

322
- op : dist
323 324 325 326 327
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

328 329 330 331
- op : distributed_push_sparse
  extra :
    attrs : ['int[] slots = {}']

332 333 334 335 336 337
- op : divide (elementwise_div)
  backward : divide_grad (elementwise_div)
  extra :
    attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]

338
- op : dot
339 340 341 342 343
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

344
- op : dropout
345 346 347 348
  backward : dropout_grad
  extra :
    attrs : [bool fix_seed = false, int seed = 0]

349
- op : dropout_nd
350 351 352 353
  backward : dropout_nd_grad
  extra :
    attrs : [bool fix_seed = false, int seed = 0]

354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373
- 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

374 375 376 377 378 379
- op : elementwise_pow
  backward : elementwise_pow_grad
  extra :
    attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]

380
- op : elu
381 382 383 384 385
  backward : elu_grad, elu_double_grad (elu_grad_grad)
  inputs :
    x : X
  outputs :
    out : Out
386 387 388
  extra :
    attrs : [bool use_mkldnn = false]

389 390 391 392 393 394 395
- op : embedding (lookup_table_v2)
  backward : embedding_grad (lookup_table_v2_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 = {}']

396 397 398 399 400 401
- op : equal_all
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

402
- op : erf
403 404 405 406 407
  inputs :
    x : X
  outputs :
    out : Out

408
- op : erfinv
409 410 411 412 413
  inputs :
    x : X
  outputs :
    out : Out

414
- op : exp
415
  backward : exp_grad
416 417 418 419
  inputs :
    x : X
  outputs :
    out : Out
420 421
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]
422

423 424 425 426 427
- op : expand (expand_v2)
  backward : expand_grad (expand_v2_grad)
  extra :
    attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32"]

428
- op : expm1
429
  backward : expm1_grad
430 431 432 433
  inputs :
    x : X
  outputs :
    out : Out
434 435 436
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
- op : fake_channel_wise_quantize_abs_max
  extra :
    attrs : [int round_type = 1]

- op : fake_channel_wise_quantize_dequantize_abs_max
  extra :
    attrs : [int round_type = 1]

- op : fake_quantize_abs_max
  extra :
    attrs : [int round_type = 1]

- op : fake_quantize_dequantize_abs_max
  extra :
    attrs : [int round_type = 1]

- op : fake_quantize_dequantize_moving_average_abs_max
  extra :
    attrs : [int round_type = 1]

- op : fake_quantize_moving_average_abs_max
  extra :
    attrs : [int round_type = 1]

- op : fake_quantize_range_abs_max
  extra :
    attrs : [int round_type = 1]

465
- op : fft_c2c
466 467 468
  inputs: {x: X}
  outputs: {out: Out}

469
- op : fft_c2r
470 471 472
  inputs: {x: X}
  outputs: {out: Out}

473
- op : fft_r2c
474 475 476
  inputs: {x: X}
  outputs: {out: Out}

477 478 479 480 481 482
- op : fill_diagonal_tensor
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

483 484 485 486 487 488
- op : flip
  inputs :
    x : X
  outputs :
    out : Out

489 490
- op : floor
  backward : floor_grad
491 492 493 494
  inputs :
    x : X
  outputs :
    out : Out
495 496 497
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514
- op : floor_divide (elementwise_floordiv)
  extra :
    attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]

- op : fmax (elementwise_fmax)
  backward : fmax_grad (elementwise_fmax_grad)
  extra :
    attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]

- op : fmin (elementwise_fmin)
  backward : fmin_grad (elementwise_fmin_grad)
  extra :
    attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]

515 516 517 518 519 520
- op : fold
  inputs :
    x : X
  outputs :
    out : Y

521
- op : frobenius_norm
522 523 524 525
  backward : frobenius_norm_grad
  extra :
    attrs : [bool use_mkldnn = false]

526 527 528 529 530 531 532 533 534
- op : full (fill_constant)
  extra :
    attrs : [bool use_mkldnn = false]

- op : gather
  backward : gather_grad
  extra :
    attrs : [bool overwrite = true]

535 536 537 538 539 540
- op : gather_tree
  inputs :
    {ids : Ids, parents : Parents}
  outputs :
    out : Out

541
- op : gelu
542
  backward : gelu_grad
543 544 545 546
  inputs :
    x : X
  outputs :
    out : Out
547
  extra :
H
HongyuJia 已提交
548
    attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32"]
549

550 551 552 553 554
- op : grad_add
  extra :
    attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]

555 556 557 558 559 560
- op : grid_sample(grid_sampler)
  backward : grid_sample_grad (grid_sampler_grad)
  inputs :
    {x : X, grid : Grid}
  outputs :
    out : Output
561 562 563
  extra :
    attrs : [bool use_cudnn = true]

564
- op : gru
565 566 567 568
  backward : gru_grad
  extra :
    attrs : [bool is_test = false]

569 570 571 572 573 574
- op : gumbel_softmax
  inputs :
    x : X
  outputs :
    out : Out

575 576 577 578 579
- op : hard_swish
  backward : hard_swish_grad
  extra :
    attrs : [bool use_mkldnn = false]

580 581 582 583 584 585 586 587 588 589 590 591 592 593
- 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

594 595 596 597 598 599
- op : heaviside (elementwise_heaviside)
  backward : heaviside_grad (elementwise_heaviside_grad)
  extra :
    attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]

600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619
- op : histogram
  inputs :
    input : X
  outputs :
    out : Out

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

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

620
- op : inplace_abn
621 622 623 624
  backward : inplace_abn_grad
  extra :
    attrs : [bool use_mkldnn = false, bool fuse_with_relu = false]

625 626 627 628 629 630
- op : inverse
  inputs :
    x : Input
  outputs :
    out : Output

631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666
- op : is_empty
  inputs :
    x : X
  outputs :
    out : Out

- 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 : kthvalue
  inputs :
    x : X
  outputs :
    {out : Out, indices : Indices}

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

667
- op : layer_norm
668 669 670 671
  backward : layer_norm_grad
  extra :
    attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32", bool is_test = false]

672
- op : leaky_relu
673 674 675 676 677 678 679
  backward : leaky_relu_grad, leaky_relu_double_grad (leaky_relu_grad_grad)
  inputs :
    x : X
  outputs :
    out : Out
  attrs:
    negative_slope : alpha
680 681 682
  extra :
    attrs : [bool use_mkldnn = false]

683 684 685 686 687 688 689
- op : lerp
  backward : lerp_grad
  inputs :
    {x : X, y : Y, weight : Weight}
  outputs :
    out : Out

690
- op : lgamma
691 692 693 694 695
  inputs :
    x : X
  outputs :
    out : Out

696
- op : linear_interp (linear_interp_v2)
697 698 699 700
  backward : linear_interp_grad (linear_interp_v2_grad)
  extra :
    attrs : [bool use_mkldnn = false]

701
- op : log
702 703 704 705 706
  backward : log_grad, log_double_grad (log_grad_grad)
  inputs :
    x : X
  outputs :
    out : Out
707 708 709
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

710
- op : log10
711
  backward : log10_grad
712 713 714 715
  inputs :
    x : X
  outputs :
    out : Out
716 717 718
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

719
- op : log1p
720
  backward : log1p_grad
721 722 723 724
  inputs :
    x : X
  outputs :
    out : Out
725 726 727
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

728
- op : log2
729
  backward : log2_grad
730 731 732 733
  inputs :
    x : X
  outputs :
    out : Out
734 735 736
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

737
- op : log_softmax
738 739 740 741
  backward : log_softmax_grad
  extra :
    attrs : [bool use_mkldnn = false]

742 743 744 745 746 747 748 749 750 751 752 753
- op : logit
  inputs :
    x : X
  outputs :
    out : Out

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

754
- op : logsigmoid
755 756 757 758
  backward : logsigmoid_grad
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

759
- op : lrn
760 761 762 763
  backward : lrn_grad
  extra :
    attrs : [bool use_mkldnn = false, bool is_test = false]

764 765 766 767 768 769 770
- op : lu_unpack
  backward : lu_unpack_grad
  inputs :
    {x : X, y : Pivots}
  outputs :
    {pmat : Pmat, l : L, u : U}

771 772 773 774 775 776
- op : masked_select
  inputs :
    {x : X, mask : Mask}
  outputs :
    out : Y

777
- op : matmul (matmul_v2)
778 779 780 781
  backward : matmul_grad (matmul_v2_grad)
  extra :
    attrs : [bool use_mkldnn = false, 'int[] fused_reshape_Out = {}', 'int[] fused_transpose_Out = {}',
             str mkldnn_data_type = "float32", 'int[] fused_reshape_X = {}', 'int[] fused_reshape_Y = {}',
782
             'int[] fused_transpose_X = {}', 'int[] fused_transpose_Y = {}']
783

784 785 786 787 788 789
- op : matmul_with_flatten (mul)
  backward : matmul_with_flatten_grad (mul_grad)
  extra :
    attrs : [bool use_mkldnn = false, float scale_x = 1.0f, 'float[] scale_y = {1.0f}',
             float scale_out = 1.0f, bool force_fp32_output = false]

790 791 792 793 794 795
- op : matrix_power
  inputs :
    x : X
  outputs :
    out : Out

796 797 798 799 800 801 802 803 804 805 806 807
- op : maximum (elementwise_max)
  backward : maximum_grad (elementwise_max_grad)
  extra :
    attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]

- op : maximum (elementwise_min)
  backward : maximum_grad (elementwise_min_grad)
  extra :
    attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]

808 809 810 811 812 813
- op : maxout
  inputs :
    x : X
  outputs :
    out : Out

814 815 816 817 818
- op : mish
  backward : mish_grad
  extra :
    attrs : [bool use_mkldnn = false]

819 820 821 822 823 824 825
- op : mode
  backward : mode_grad
  inputs :
    x : X
  outputs :
    {out : Out, indices : Indices}

826 827 828 829 830 831
- op : multiply (elementwise_mul)
  backward : multiply_grad (elementwise_mul_grad)
  extra :
    attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]

832
- op : mv
833 834 835 836 837
  inputs :
    {x : X, vec : Vec}
  outputs :
    out : Out

838 839 840 841 842 843
- op : nce
  backward : nce_grad
  extra :
    attrs : [int trainer_id = 0, 'int64_t[] height_sections = {}', 'str[] epmap = {}',
             'str[] table_names = {}', 'int[] custom_neg_classes = {}']

844
- op : nearest_interp (nearest_interp_v2)
845 846 847 848
  backward : nearest_interp_grad (nearest_interp_v2_grad)
  extra :
    attrs : [bool use_mkldnn = false]

849 850 851 852 853 854 855
- op : nll_loss
  backward : nll_loss_grad
  inputs :
    {input : X, label : Label, weight : Weight}
  outputs :
    {out : Out, total_weight : Total_weight}

856
- op : pad2d
857 858 859 860
  backward : pad2d_grad
  extra :
    attrs : [bool use_mkldnn = false]

861
- op : pad3d
862 863 864 865
  backward : pad3d_grad
  extra :
    attrs : [bool use_mkldnn = false]

866
- op : partial_sum
867 868 869 870
  backward : partial_sum_grad
  extra :
    attrs : [bool use_mkldnn = false]

871
- op : poisson
872 873 874 875 876
  inputs :
    x : X
  outputs :
    out : Out

877 878 879 880 881 882 883 884 885 886 887
- op : pool2d
  backward : pool2d_grad
  extra :
    attrs : [bool use_mkldnn = false, bool use_quantizer = false,
              str mkldnn_data_type = "float32", bool is_test = false]

- op : pool3d
  backward : pool3d_grad
  extra :
    attrs : [bool use_mkldnn = false]

888
- op : prelu
889 890 891 892
  backward : prelu_grad
  extra :
    attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32", bool is_test = false]

893 894 895 896 897 898 899
- op : qr
  backward : qr_grad
  inputs :
    x : X
  outputs :
    {q : Q, r : R}

900 901 902 903
- op : quantize_linear
  extra :
    attrs : [float moving_rate = 0.9]

904
- op : reciprocal
905
  backward : reciprocal_grad
906 907 908 909
  inputs :
    x : X
  outputs :
    out : Out
910 911 912
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

913
- op : reduce_all
914 915 916
  extra :
    attrs : [bool use_mkldnn = false]

917
- op : reduce_amax
918 919 920 921
  backward : reduce_amax_grad
  extra :
    attrs : [bool use_mkldnn = false]

922
- op : reduce_amin
923 924 925 926
  backward : reduce_amin_grad
  extra :
    attrs : [bool use_mkldnn = false]

927
- op : reduce_any
928 929 930
  extra :
    attrs : [bool use_mkldnn = false]

931
- op : reduce_max
932 933 934 935
  backward : reduce_max_grad
  extra :
    attrs : [bool use_mkldnn = false]

936
- op : reduce_mean
937 938 939 940
  backward : reduce_mean_grad
  extra :
    attrs : [bool use_mkldnn = false]

941
- op : reduce_min
942 943 944 945
  backward : reduce_min_grad
  extra :
    attrs : [bool use_mkldnn = false]

946
- op : reduce_prod
947 948 949 950
  backward : reduce_prod_grad
  extra :
    attrs : [bool use_mkldnn = false]

951
- op : reduce_sum
952 953 954 955
  backward : reduce_sum_grad
  extra :
    attrs : [bool use_mkldnn = false]

956
- op : relu
957 958 959 960 961
  backward : relu_grad, relu_double_grad (relu_grad_grad)
  inputs :
    x : X
  outputs :
    out : Out
962 963 964
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

965
- op : relu6
966 967 968 969
  backward : relu6_grad
  extra :
    attrs : [bool use_mkldnn = false]

970 971 972 973 974
- op : remainder (elementwise_mod)
  extra :
    attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]

975
- op : renorm
976
  backward : renorm_grad
977 978 979 980
  inputs :
    x : X
  outputs :
    out : Out
981 982 983
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

984
- op : round
985
  backward : round_grad
986 987 988 989
  inputs :
    x : X
  outputs :
    out : Out
990
  extra :
991 992
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

993
- op : rsqrt
994 995 996 997 998
  backward : rsqrt_grad, rsqrt_double_grad (rsqrt_grad_grad)
  inputs :
    x : X
  outputs :
    out : Out
999 1000
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]
1001

1002 1003 1004 1005
- op : scale
  extra :
    attrs : [bool use_mkldnn = false]

1006
- op : seed
1007 1008 1009
  extra :
    attrs : [bool deterministic = false, str rng_name = "", bool force_cpu = false]

1010 1011 1012
- op : send_uv (graph_send_uv)
  backward : send_uv_grad (graph_send_uv_grad)

1013 1014 1015 1016 1017
- op : sequence_softmax
  backward : sequence_softmax_grad
  extra :
    attrs : [str data_format = "AnyLayout"]

1018
- op : shape
1019 1020 1021
  extra :
    attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32"]

1022 1023 1024 1025 1026 1027 1028
- op : share_buffer
  inputs :
    x : X
  outputs :
    out : Out
    xout : XOut

1029
- op : shuffle_channel
1030 1031 1032 1033
  backward : shuffle_channel_grad
  extra :
    attrs : [bool use_mkldnn = false]

1034
- op : sigmoid
1035 1036 1037 1038 1039
  backward : sigmoid_grad, sigmoid_double_grad (sigmoid_grad_grad), sigmoid_triple_grad
  inputs :
    x : X
  outputs :
    out : Out
1040 1041 1042
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

1043
- op : silu
1044
  backward : silu_grad
1045 1046 1047 1048
  inputs :
    x : X
  outputs :
    out : Out
1049 1050 1051
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

1052
- op : sin
1053
  backward : sin_grad, sin_double_grad, sin_triple_grad
1054 1055 1056 1057
  inputs :
    x : X
  outputs :
    out : Out
1058 1059 1060
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

1061
- op : sinh
1062
  backward : sinh_grad
1063 1064 1065 1066
  inputs :
    x : X
  outputs :
    out : Out
1067 1068 1069
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

1070
- op : slice
1071 1072 1073 1074
  backward : slice_grad
  extra :
    attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32"]

1075
- op : softmax
1076 1077
  backward : softmax_grad
  extra :
1078
    attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32", bool is_test = false]
1079

1080
- op : softplus
1081
  backward : softplus_grad
1082 1083 1084 1085
  inputs :
    x : X
  outputs :
    out : Out
1086
  extra :
1087 1088 1089
    attrs : [bool use_mkldnn = false, bool use_cudnn = false, str fuse_activation_type = "", float fuse_activation_alpha = 0.0f,
             float fuse_activation_beta = 0.0f, float fuse_activation_scale = 1.0f]

1090 1091 1092 1093 1094 1095 1096 1097 1098
- op : softshrink
  backward : softshrink_grad
  inputs :
    x : X
  outputs :
    out : Out
  attrs :
    threshold : lambda

1099
- op : softsign
1100
  backward : softsign_grad
1101 1102 1103 1104
  inputs :
    x : X
  outputs :
    out : Out
1105 1106
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]
1107

1108
- op : solve
1109 1110 1111 1112 1113
  inputs :
    {x : X, y : Y}
  outputs :
    out : Out

1114
- op : sqrt
1115 1116 1117 1118 1119
  backward : sqrt_grad, sqrt_double_grad (sqrt_grad_grad)
  inputs :
    x : X
  outputs :
    out : Out
1120 1121 1122
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

1123
- op : square
1124 1125 1126 1127 1128
  backward : square_grad, square_double_grad (square_grad_grad)
  inputs :
    x : X
  outputs :
    out : Out
1129 1130 1131
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

1132
- op : squeeze (squeeze2)
1133 1134 1135 1136
  backward : squeeze_grad (squeeze2_grad)
  extra :
    attrs : [bool use_mkldnn = false, str mkldnn_data_type = "float32"]

1137
- op : stack
1138 1139 1140 1141
  backward : stack_grad
  extra :
    attrs : [bool use_mkldnn = false]

1142 1143 1144 1145 1146
- op : stack
  backward : stack_grad
  extra :
    attrs : [bool use_mkldnn = false]

1147 1148 1149 1150 1151 1152
- op : subtract (elementwise_sub)
  backward : subtract_grad (elementwise_sub_grad)
  extra :
    attrs : [bool use_mkldnn = false, str x_data_format = "", str y_data_format = "", str mkldnn_data_type = "float32",
             bool use_quantizer = false, float Scale_x = 1.0f, float Scale_y = 1.0f, float Scale_out = 1.0f]

1153
- op : swish
1154 1155 1156 1157
  backward : swish_grad
  extra :
    attrs : [bool use_mkldnn = false]

1158
- op : sync_batch_norm
1159 1160 1161 1162
  backward : sync_batch_norm_grad
  extra :
    attrs : [bool use_mkldnn = false, bool fuse_with_relu = false]

1163
- op : tan
1164
  backward : tan_grad
1165 1166 1167 1168
  inputs :
    x : X
  outputs :
    out : Out
1169 1170 1171
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

1172
- op : tanh
1173 1174 1175 1176 1177
  backward : tanh_grad, tanh_double_grad (tanh_grad_grad), tanh_triple_grad
  inputs :
    x : X
  outputs :
    out : Out
1178 1179 1180
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

1181
- op : tanh_shrink
1182
  backward : tanh_shrink_grad
1183 1184 1185 1186
  inputs :
    x : X
  outputs :
    out : Out
1187 1188 1189
  extra :
    attrs : [bool use_mkldnn = false, bool use_cudnn = false]

1190 1191 1192 1193 1194 1195
- op : thresholded_relu
  inputs :
    x : X
  outputs :
    out : Out

1196
- op : trace
1197 1198 1199 1200
  inputs :
    x : Input
  outputs :
    out : Out
1201

1202 1203 1204 1205 1206 1207
- op : transpose (transpose2)
  backward : transpose_grad (transpose2_grad)
  extra :
    attrs : [bool use_mkldnn = false, str data_format = "AnyLayout", bool use_quantizer = false,
              str mkldnn_data_type = "float32"]

1208
- op : trilinear_interp (trilinear_interp_v2)
1209 1210 1211 1212
  backward : trilinear_interp_grad (trilinear_interp_v2_grad)
  extra :
    attrs : [bool use_mkldnn = false]

1213
- op : trunc
1214
  inputs :
1215
    input : X
1216 1217
  outputs :
    out : Out
1218

1219 1220 1221 1222 1223 1224
- op : unfold
  inputs :
    x : X
  outputs :
    out : Y

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