backward.yaml 77.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12
- backward_api : abs_double_grad
  forward : abs_grad (Tensor x, Tensor grad_out) -> Tensor(grad_x)
  args : (Tensor x, Tensor grad_x_grad)
  output : Tensor(grad_out_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : abs_double_grad
  data_transform:
    skip_transform : grad_x_grad

13 14 15 16
- backward_api : abs_grad
  forward : abs (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
17
  infer_meta :
18
    func : UnchangedInferMeta
19
    param : [x]
20
  kernel :
21
    func : abs_grad
22 23
  data_transform:
    skip_transform : out_grad
24
  backward : abs_double_grad
25

26 27 28 29
- backward_api : acos_grad
  forward : acos (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
30
  infer_meta :
31 32
    func : UnchangedInferMeta
    param : [x]
33
  kernel :
34
    func : acos_grad
P
pangyoki 已提交
35
  inplace : (out_grad -> x_grad)
36

37 38 39
- backward_api : acosh_grad
  forward : acosh (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
40
  output : Tensor(x_grad)
41 42 43 44 45
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : acosh_grad
P
pangyoki 已提交
46
  inplace : (out_grad -> x_grad)
47

48 49 50 51 52 53 54 55 56 57 58
- backward_api : add_double_grad
  forward : add_grad (Tensor x, Tensor y, Tensor grad_out, int axis = -1) -> Tensor(grad_x), Tensor(grad_y)
  args : (Tensor y, Tensor grad_out, Tensor grad_x_grad, Tensor grad_y_grad, int axis = -1)
  output : Tensor(grad_out_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [grad_out]
  kernel :
    func : add_double_grad
  optional : grad_x_grad, grad_y_grad
  backward : add_triple_grad
59
  inplace : (grad_x_grad -> grad_out_grad)
60

H
hong 已提交
61 62
- backward_api : add_grad
  forward : add (Tensor x, Tensor y) -> Tensor(out)
H
hong 已提交
63
  args : (Tensor x, Tensor y, Tensor out_grad, int axis = -1)
H
hong 已提交
64 65 66 67 68 69
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, y]
  kernel :
    func : add_grad
70
  no_need_buffer : x, y
71
  backward : add_double_grad
72
  inplace : (out_grad -> x_grad)
H
hong 已提交
73

74 75 76
- backward_api : add_n_grad
  forward : add_n (Tensor[] x) -> Tensor(out)
  args : (Tensor[] x, Tensor out_grad)
77
  output : Tensor[](x_grad){x.size()}
78
  invoke : add_n_grad_impl(x, out_grad, x_grad)
79 80
  no_need_buffer : x

81 82 83 84 85 86 87 88 89
- backward_api : add_triple_grad
  forward : add_double_grad (Tensor y, Tensor grad_out, Tensor grad_grad_x, Tensor grad_grad_y, int axis = -1) -> Tensor(grad_grad_out)
  args : (Tensor grad_grad_x, Tensor grad_grad_y, Tensor grad_grad_out_grad, int axis = -1)
  output : Tensor(grad_grad_x_grad), Tensor(grad_grad_y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [grad_grad_x, grad_grad_y]
  kernel :
    func : add_triple_grad
90
  inplace : (grad_grad_out_grad -> grad_grad_x_grad)
91

92
- backward_api : addmm_grad
H
hong 已提交
93
  forward : addmm (Tensor input, Tensor x, Tensor y, float alpha, float beta) -> Tensor(out)
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
  args : (Tensor input, Tensor x, Tensor y, Tensor out_grad, float alpha, float beta)
  output : Tensor(input_grad), Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralTernaryGradInferMeta
    param : [input, x, y]
  kernel :
    func : addmm_grad

- backward_api : argsort_grad
  forward : argsort (Tensor x, int axis, bool descending) -> Tensor(out), Tensor(indices)
  args : (Tensor indices, Tensor x, Tensor out_grad, int axis, bool descending)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : argsort_grad
H
hong 已提交
111
  no_need_buffer : x
112 113 114 115 116 117 118 119 120 121

- backward_api : asin_grad
  forward : asin (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : asin_grad
P
pangyoki 已提交
122
  inplace : (out_grad -> x_grad)
123 124 125 126 127 128 129 130 131 132

- backward_api : asinh_grad
  forward : asinh (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : asinh_grad
P
pangyoki 已提交
133
  inplace : (out_grad -> x_grad)
134

C
chentianyu03 已提交
135 136 137 138 139 140
- backward_api : assign_grad
  forward : assign (Tensor x) -> Tensor(out)
  args : (Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
Z
zyfncg 已提交
141 142
  kernel :
    func : assign
P
pangyoki 已提交
143
  inplace : (out_grad -> x_grad)
Z
zyfncg 已提交
144 145 146 147 148 149 150

- backward_api : assign_out__grad
  forward : assign_out_ (Tensor x, Tensor output) -> Tensor(out)
  args : (Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
C
chentianyu03 已提交
151
  kernel :
152
    func : assign
P
pangyoki 已提交
153
  inplace : (out_grad -> x_grad)
C
chentianyu03 已提交
154

155
- backward_api : atan2_grad
156
  forward : atan2 (Tensor x, Tensor y) -> Tensor(out)
157
  args : (Tensor x, Tensor y, Tensor out_grad)
H
hong 已提交
158 159 160 161 162
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, y]
  kernel :
163
    func : atan2_grad
H
hong 已提交
164

165 166 167 168 169 170 171 172 173
- backward_api : atan_grad
  forward : atan (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : atan_grad
P
pangyoki 已提交
174
  inplace : (out_grad -> x_grad)
175 176 177 178 179 180 181 182 183 184

- backward_api : atanh_grad
  forward : atanh (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : atanh_grad
P
pangyoki 已提交
185
  inplace : (out_grad -> x_grad)
186

187 188 189 190 191 192 193 194 195 196 197
- backward_api : batch_norm_double_grad
  forward : batch_norm_grad (Tensor x, Tensor scale, Tensor bias, Tensor out_mean, Tensor out_variance, Tensor saved_mean, Tensor saved_variance, Tensor reserve_space, Tensor grad_out, float momentum, float epsilon, str data_layout, bool is_test, bool use_global_stats, bool trainable_statistics, bool fuse_with_relu) -> Tensor(grad_x), Tensor(grad_scale), Tensor(grad_bias)
  args : (Tensor x, Tensor scale, Tensor out_mean, Tensor out_variance, Tensor saved_mean, Tensor saved_variance, Tensor grad_out,  Tensor grad_x_grad, Tensor grad_scale_grad, Tensor grad_bias_grad, float momentum, float epsilon, str data_layout, bool is_test, bool use_global_stats, bool trainable_statistics, bool fuse_with_relu)
  output : Tensor(x_grad), Tensor(scale_grad), Tensor(grad_out_grad)
  infer_meta :
    func : GeneralTernaryGradInferMeta
    param : [x, scale, x]
  kernel :
    func : batch_norm_grad_grad
    data_type : x
  optional : out_mean, out_variance
198
  inplace : (grad_out -> grad_out_grad)
199

H
hong 已提交
200 201 202 203 204 205 206 207 208 209 210
- backward_api : batch_norm_grad
  forward : batch_norm (Tensor x, Tensor scale, Tensor bias, Tensor mean, Tensor variance, float momentum, float epsilon, str data_layout, bool is_test, bool use_global_stats, bool trainable_statistics, bool fuse_with_relu) -> Tensor(out), Tensor(mean_out), Tensor(variance_out), Tensor(saved_mean), Tensor(saved_variance), Tensor(reserve_space)
  args : (Tensor x, Tensor scale, Tensor bias, Tensor mean_out, Tensor variance_out, Tensor saved_mean, Tensor saved_variance, Tensor reserve_space, Tensor out_grad, float momentum, float epsilon, str data_layout, bool is_test, bool use_global_stats, bool trainable_statistics, bool fuse_with_relu)
  output : Tensor(x_grad), Tensor(scale_grad), Tensor(bias_grad)
  infer_meta :
    func : GeneralTernaryGradInferMeta
    param : [x, scale, bias]
  kernel :
    func : batch_norm_grad
    data_type : out_grad
  optional : mean_out, variance_out, reserve_space
211
  backward : batch_norm_double_grad
H
hong 已提交
212

213 214 215 216 217 218 219 220 221
- backward_api : bce_loss_grad
  forward : bce_loss (Tensor input, Tensor label) -> Tensor(out)
  args : (Tensor input, Tensor label, Tensor out_grad)
  output : Tensor(input_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [input]
  kernel :
    func : bce_loss_grad
P
pangyoki 已提交
222
  inplace : (out_grad -> input_grad)
223 224 225 226 227 228 229 230 231 232

- backward_api : brelu_grad
  forward : brelu (Tensor x, float t_min, float t_max) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, float t_min, float t_max)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : brelu_grad
P
pangyoki 已提交
233
  inplace : (out_grad -> x_grad)
234 235 236 237 238 239 240 241 242 243 244

- backward_api : cast_grad
  forward : cast (Tensor x, DataType out_dtype) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : cast_grad
    data_type : out_grad
W
wanghuancoder 已提交
245
  no_need_buffer : x
246

247 248 249 250 251 252 253 254 255
- backward_api : ceil_grad
  forward : ceil(Tensor x) -> Tensor(out)
  args : (Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [out_grad]
  kernel :
    func : ceil_grad
P
pangyoki 已提交
256
  inplace : (out_grad -> x_grad)
257

258 259 260 261 262 263 264 265 266
- backward_api : celu_double_grad
  forward : celu_grad(Tensor x, Tensor grad_out, float alpha) -> Tensor(grad_x)
  args : (Tensor x, Tensor grad_out, Tensor grad_x_grad, float alpha)
  output : Tensor(x_grad), Tensor(grad_out_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, x]
  kernel :
    func : celu_double_grad
267
  inplace : (grad_x_grad -> grad_out_grad)
268 269 270 271 272 273 274 275 276 277 278

- backward_api : celu_grad
  forward : celu(Tensor x, float alpha) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, float alpha)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [x]
  kernel :
    func : celu_grad
  backward : celu_double_grad
P
pangyoki 已提交
279
  inplace : (out_grad -> x_grad)
280

281 282 283 284 285 286 287 288 289 290 291
- backward_api : cholesky_grad
  forward : cholesky (Tensor x, bool upper) -> Tensor(out)
  args : (Tensor out, Tensor out_grad, bool upper)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [out]
  kernel :
    func : cholesky_grad

- backward_api : cholesky_solve_grad
292
  forward : cholesky_solve (Tensor x, Tensor y, bool upper) -> Tensor(out)
293
  args : (Tensor x, Tensor y, Tensor out, Tensor out_grad, bool upper)
H
hong 已提交
294 295 296 297 298
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, y]
  kernel :
299 300
    func : cholesky_solve_grad

301 302 303 304 305 306 307 308 309 310
- backward_api : clip_double_grad
  forward : clip_grad (Tensor x, Tensor grad_out, Scalar min = 0., Scalar max = 0.) -> Tensor(grad_x)
  args : (Tensor x, Tensor grad_x_grad, Scalar min = 0., Scalar max = 0.)
  output : Tensor(grad_out_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : clip_grad

C
chentianyu03 已提交
311 312 313 314 315 316 317 318 319
- backward_api : clip_grad
  forward : clip (Tensor x, Scalar min, Scalar max) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, Scalar min = 0., Scalar max = 0.)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : clip_grad
320
  backward : clip_double_grad
P
pangyoki 已提交
321
  inplace : (out_grad -> x_grad)
322 323 324 325 326 327 328 329 330 331

- backward_api : concat_double_grad
  forward : concat_grad (Tensor[] x, Tensor grad_out, Scalar axis) -> Tensor[](grad_x)
  args : (Tensor[] grad_x_grad, Scalar axis = 0)
  output : Tensor(grad_out_grad)
  infer_meta :
    func : ConcatInferMeta
    param : [grad_x_grad, axis]
  kernel :
    func : concat
C
chentianyu03 已提交
332

333 334 335
- backward_api : concat_grad
  forward : concat (Tensor[] x, Scalar axis) -> Tensor(out)
  args : (Tensor[] x, Tensor out_grad, Scalar axis = 0)
336 337 338 339 340 341
  output : Tensor[](x_grad){x.size()}
  infer_meta :
    func : UnchangedMultiInferMeta
    param : [x]
  kernel :
    func : concat_grad
H
hong 已提交
342
  no_need_buffer : x
343
  backward : concat_double_grad
344

H
hong 已提交
345 346 347 348 349 350 351 352 353 354
- backward_api : conj_grad
  forward : conj (Tensor x) -> Tensor(out)
  args : (Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [out_grad]
  kernel :
    func : conj

H
hong 已提交
355 356 357 358
- backward_api : conv2d_grad
  forward : conv2d (Tensor input, Tensor filter, int[] strides, int[] paddings, str paddding_algorithm, int groups, int[] dilations, str data_format, bool use_addto, int workspace_size_MB, bool exhaustive_search) -> Tensor(out)
  args : (Tensor input, Tensor filter, Tensor out_grad,  int[] strides, int[] paddings, str paddding_algorithm, int groups, int[] dilations, str data_format, bool use_addto, int workspace_size_MB, bool exhaustive_search)
  output : Tensor(input_grad), Tensor(filter_grad)
359
  invoke : conv2d_grad_impl(input, filter, out_grad,  strides, paddings, paddding_algorithm, groups, dilations, data_format, use_addto, workspace_size_MB, exhaustive_search, input_grad, filter_grad)
360 361 362 363 364 365 366 367 368 369 370
  backward : conv2d_grad_grad

- backward_api : conv2d_grad_grad
  forward : conv2d_grad (Tensor input, Tensor filter, Tensor grad_out,  int[] strides, int[] paddings, str paddding_algorithm, int groups, int[] dilations, str data_format, bool use_addto, int workspace_size_MB, bool exhaustive_search) -> Tensor(grad_input), Tensor(grad_filter)
  args : (Tensor input, Tensor filter, Tensor grad_out, Tensor grad_input_grad, Tensor grad_filter_grad, int[] strides, int[] paddings, str paddding_algorithm, int groups, int[] dilations, str data_format, bool use_addto, int workspace_size_MB, bool exhaustive_search)
  output : Tensor(input_grad), Tensor(filter_grad), Tensor(grad_out_grad)
  infer_meta :
    func : GeneralTernaryGradInferMeta
    param: [input, filter, grad_out]
  kernel :
    func : conv2d_grad_grad
371
    use_gpudnn : true
372
  optional : grad_input_grad, grad_filter_grad
H
hong 已提交
373

C
chentianyu03 已提交
374 375 376 377 378 379 380 381 382 383
- backward_api : conv2d_transpose_double_grad
  forward : conv2d_transpose_grad(Tensor x, Tensor filter, Tensor grad_out, int[] strides, int[] paddings, int[] output_padding, int[] output_size, str padding_algorithm, int groups, int[] dilations, str data_format) -> Tensor(grad_x), Tensor(grad_filter)
  args : (Tensor x, Tensor filter, Tensor grad_out, Tensor grad_x_grad, Tensor grad_filter_grad, int[] strides, int[] paddings, int[] output_padding, int[] output_size, str padding_algorithm, int groups, int[] dilations, str data_format)
  output : Tensor(x_grad), Tensor(filter_grad), Tensor(grad_out_grad)
  infer_meta :
    func : Conv2dTransposeDoubleGradInferMeta
  kernel :
    func : conv2d_transpose_grad_grad
    use_gpudnn : true

F
From00 已提交
384 385 386 387 388 389
- backward_api : conv2d_transpose_grad
  forward : conv2d_transpose(Tensor x, Tensor filter, int[] strides, int[] paddings, int[] output_padding, int[] output_size, str padding_algorithm, int groups, int[] dilations, str data_format) -> Tensor(out)
  args : (Tensor x, Tensor filter, Tensor out_grad, int[] strides, int[] paddings, int[] output_padding, int[] output_size, str padding_algorithm, int groups, int[] dilations, str data_format)
  output : Tensor(x_grad), Tensor(filter_grad)
  infer_meta :
    func : ConvTransposeGradInferMeta
390
  kernel :
F
From00 已提交
391
    func : conv2d_transpose_grad
392
    use_gpudnn : true
C
chentianyu03 已提交
393
  backward : conv2d_transpose_double_grad
F
From00 已提交
394

395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
- backward_api : conv3d_grad
  forward : conv3d (Tensor input, Tensor filter, int[] strides, int[] paddings, str paddding_algorithm, int groups, int[] dilations, str data_format, bool use_addto, int workspace_size_MB, bool exhaustive_search) -> Tensor(out)
  args : (Tensor input, Tensor filter, Tensor out_grad,  int[] strides, int[] paddings, str paddding_algorithm, int groups, int[] dilations, str data_format, bool use_addto, int workspace_size_MB, bool exhaustive_search)
  output : Tensor(input_grad), Tensor(filter_grad)
  invoke : conv3d_grad_impl(input, filter, out_grad,  strides, paddings, paddding_algorithm, groups, dilations, data_format, use_addto, workspace_size_MB, exhaustive_search, input_grad, filter_grad)
  backward : conv3d_grad_grad

- backward_api : conv3d_grad_grad
  forward : conv3d_grad (Tensor input, Tensor filter, Tensor grad_out,  int[] strides, int[] paddings, str paddding_algorithm, int groups, int[] dilations, str data_format, bool use_addto, int workspace_size_MB, bool exhaustive_search) -> Tensor(grad_input), Tensor(grad_filter)
  args : (Tensor input, Tensor filter, Tensor grad_out, Tensor grad_input_grad, Tensor grad_filter_grad, int[] strides, int[] paddings, str paddding_algorithm, int groups, int[] dilations, str data_format, bool use_addto, int workspace_size_MB, bool exhaustive_search)
  output : Tensor(input_grad), Tensor(filter_grad), Tensor(grad_out_grad)
  infer_meta :
    func : GeneralTernaryGradInferMeta
    param: [input, filter, grad_out]
  kernel :
    func : conv3d_grad_grad
    use_gpudnn : true
  optional : grad_input_grad, grad_filter_grad

F
From00 已提交
414 415 416 417 418 419 420 421
- backward_api : conv3d_transpose_grad
  forward : conv3d_transpose(Tensor x, Tensor filter, int[] strides, int[] paddings, int[] output_padding, int[] output_size, str padding_algorithm, int groups, int[] dilations, str data_format) -> Tensor(out)
  args : (Tensor x, Tensor filter, Tensor out_grad, int[] strides, int[] paddings, int[] output_padding, int[] output_size, str padding_algorithm, int groups, int[] dilations, str data_format)
  output : Tensor(x_grad), Tensor(filter_grad)
  infer_meta :
    func : ConvTransposeGradInferMeta
  kernel :
    func : conv3d_transpose_grad
422
    use_gpudnn : true
F
From00 已提交
423

424 425 426 427 428 429 430 431 432
- backward_api : cos_grad
  forward : cos (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : cos_grad
P
pangyoki 已提交
433
  inplace : (out_grad -> x_grad)
434 435 436 437 438 439 440 441 442 443

- backward_api : cosh_grad
  forward : cosh (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : cosh_grad
P
pangyoki 已提交
444
  inplace : (out_grad -> x_grad)
445

446 447 448 449 450 451 452 453 454
- backward_api : cross_entropy_with_softmax_grad
  forward : cross_entropy_with_softmax (Tensor input, Tensor label, bool soft_label, bool use_softmax, bool numeric_stable_mode, int ignore_index, int axis) -> Tensor(softmax), Tensor(loss)
  args : (Tensor label, Tensor softmax, Tensor loss_grad, bool soft_label, bool use_softmax, bool numeric_stable_mode, int ignore_index, int axis)
  output : Tensor(input_grad)
  infer_meta :
    func : CrossEntropyWithSoftmaxGradInferMeta
  kernel :
    func : cross_entropy_with_softmax_grad
    data_type : softmax
455
  inplace : (softmax -> input_grad)
456

457 458 459 460 461 462 463 464 465 466
- backward_api : cross_grad
  forward : cross (Tensor x, Tensor y, int axis = 9) -> Tensor(out)
  args : (Tensor x, Tensor y, Tensor out_grad, int axis)
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, y]
  kernel :
    func : cross_grad

467 468 469 470 471 472 473 474 475 476
- backward_api : cumprod_grad
  forward : cumprod (Tensor x, int dim) -> Tensor(out)
  args : (Tensor x, Tensor out, Tensor out_grad, int dim)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [x]
  kernel :
    func : cumprod_grad

477 478 479 480 481 482 483 484 485
- backward_api : cumsum_grad
  forward : cumsum(Tensor x, int axis, bool flatten, bool exclusive, bool reverse) -> Tensor(out)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  args : (Tensor out_grad, int axis, bool flatten, bool exclusive, bool reverse)
  output : Tensor(x_grad)
  invoke : cumsum(out_grad, axis, flatten, exclusive, !reverse)

486 487 488 489 490 491 492 493
- backward_api : deformable_conv_grad
  forward : deformable_conv(Tensor x, Tensor offset, Tensor filter, Tensor mask, int[] strides, int[] paddings, int[] dilations, int deformable_groups, int groups, int im2col_step) -> Tensor(out)
  args : (Tensor x, Tensor offset, Tensor filter, Tensor mask, Tensor out_grad, int[] strides, int[] paddings, int[] dilations, int deformable_groups, int groups, int im2col_step)
  output : Tensor(x_grad), Tensor(offset_grad), Tensor(filter_grad), Tensor(mask_grad)
  infer_meta :
    func : DeformableConvGradInferMeta
  kernel :
    func : deformable_conv_grad
494
    data_type : x
495 496
  optional : mask

497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
- backward_api : depthwise_conv2d_grad
  forward : depthwise_conv2d (Tensor input, Tensor filter, int[] strides, int[] paddings, str paddding_algorithm, int groups, int[] dilations, str data_format, bool use_addto, int workspace_size_MB, bool exhaustive_search, bool fuse_relu) -> Tensor(out)
  args : (Tensor input, Tensor filter, Tensor out_grad,  int[] strides, int[] paddings, str paddding_algorithm, int groups, int[] dilations, str data_format, bool use_addto, int workspace_size_MB, bool exhaustive_search, bool fuse_relu)
  output : Tensor(input_grad), Tensor(filter_grad)
  invoke : conv2d_grad_impl(input, filter, out_grad,  strides, paddings, paddding_algorithm, groups, dilations, data_format, use_addto, workspace_size_MB, exhaustive_search, input_grad, filter_grad)
  backward : depthwise_conv2d_grad_grad

- backward_api : depthwise_conv2d_grad_grad
  forward : depthwise_conv2d_grad (Tensor input, Tensor filter, Tensor grad_out,  int[] strides, int[] paddings, str paddding_algorithm, int groups, int[] dilations, str data_format, bool use_addto, int workspace_size_MB, bool exhaustive_search, bool fuse_relu) -> Tensor(grad_input), Tensor(grad_filter)
  args : (Tensor input, Tensor filter, Tensor grad_out, Tensor grad_input_grad, Tensor grad_filter_grad, int[] strides, int[] paddings, str paddding_algorithm, int groups, int[] dilations, str data_format, bool use_addto, int workspace_size_MB, bool exhaustive_search)
  output : Tensor(input_grad), Tensor(filter_grad), Tensor(grad_out_grad)
  infer_meta :
    func : GeneralTernaryGradInferMeta
    param: [input, filter, grad_out]
  kernel :
    func : conv2d_grad_grad
    use_gpudnn : true
  optional : grad_input_grad, grad_filter_grad

F
From00 已提交
516 517 518 519 520 521 522 523 524
- backward_api : depthwise_conv2d_transpose_grad
  forward : depthwise_conv2d_transpose(Tensor x, Tensor filter, int[] strides, int[] paddings, int[] output_padding, int[] output_size, str padding_algorithm, int groups, int[] dilations, str data_format) -> Tensor(out)
  args : (Tensor x, Tensor filter, Tensor out_grad, int[] strides, int[] paddings, int[] output_padding, int[] output_size, str padding_algorithm, int groups, int[] dilations, str data_format)
  output : Tensor(x_grad), Tensor(filter_grad)
  infer_meta :
    func : ConvTransposeGradInferMeta
  kernel :
    func : depthwise_conv2d_transpose_grad

C
chentianyu03 已提交
525 526 527 528 529 530 531 532
- backward_api : det_grad
  forward : det (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
533
    func : determinant_grad
C
chentianyu03 已提交
534

535 536 537 538 539 540 541 542 543
- backward_api : diagonal_grad
  forward : diagonal (Tensor x, int offset, int axis1, int axis2) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, int offset = 0, int axis1 = 0, int axis2 = 1)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : diagonal_grad
H
hong 已提交
544
  no_need_buffer : x
545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564

- backward_api : digamma_grad
  forward : digamma (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : digamma_grad

- backward_api : dist_grad
  forward : dist (Tensor x, Tensor y, float p) -> Tensor(out)
  args : (Tensor x, Tensor y, Tensor out, Tensor out_grad, float p)
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, y]
  kernel :
    func : dist_grad
H
hong 已提交
565

566 567 568 569 570 571 572 573 574 575 576
- backward_api : divide_double_grad
  forward : divide_grad (Tensor x, Tensor y, Tensor out, Tensor grad_out, int axis = -1) -> Tensor(grad_x), Tensor(grad_y)
  args : (Tensor y, Tensor out, Tensor grad_x, Tensor grad_x_grad, Tensor grad_y_grad, int axis = -1)
  output : Tensor(y_grad), Tensor(out_grad), Tensor(grad_out_grad)
  infer_meta :
    func : GeneralTernaryGradInferMeta
    param : [y, grad_x, grad_x]
  kernel :
    func : divide_double_grad
    data_type : out
  optional : grad_x_grad, grad_y_grad
577
  inplace : (grad_x_grad -> grad_out_grad)
578

H
hong 已提交
579 580
- backward_api : divide_grad
  forward : divide (Tensor x, Tensor y) -> Tensor(out)
0
0x45f 已提交
581
  args : (Tensor x, Tensor y, Tensor out, Tensor out_grad, int axis = -1)
H
hong 已提交
582 583 584 585 586 587
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, y]
  kernel :
    func : divide_grad
588
  backward : divide_double_grad
H
hong 已提交
589

H
hong 已提交
590 591 592 593 594 595 596 597 598 599
- backward_api : dropout_grad
  forward : dropout (Tensor x, Tensor seed_tensor, float p, bool is_test, str mode, int seed, bool fix_seed) -> Tensor(out), Tensor(mask)
  args : (Tensor mask, Tensor out_grad, float p, bool is_test, str mode)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [out_grad]
  kernel :
    func : dropout_grad

600 601 602 603 604 605 606 607 608
- backward_api : eigh_grad
  forward : eigh (Tensor x, str uplo) -> Tensor(out_w), Tensor(out_v)
  args : (Tensor out_w, Tensor out_v, Tensor out_w_grad, Tensor out_v_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [out_v]
  kernel :
    func : eigh_grad
609 610 611
    data_type : out_v
  data_transform:
    skip_transform : out_w, out_w_grad
H
hong 已提交
612

613
- backward_api : einsum_grad
614 615
  forward : einsum (Tensor[] x, str equation) -> Tensor(out), Tensor[](inner_cache)
  args : (Tensor[] x, Tensor[] inner_cache, Tensor out_grad, str equation)
616 617 618 619 620 621 622
  output : Tensor[](x_grad){x.size()}
  infer_meta :
    func : UnchangedMultiInferMeta
    param : [x]
  kernel :
    func : einsum_grad

623 624 625 626 627 628 629 630 631 632
- backward_api : elementwise_pow_grad
  forward : elementwise_pow(Tensor x, Tensor y) -> Tensor(out)
  args : (Tensor x, Tensor y, Tensor out_grad, int axis=-1)
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param: [x, y]
  kernel :
    func : elementwise_pow_grad

633 634 635 636 637 638 639 640 641
- backward_api : elu_double_grad
  forward : elu_grad (Tensor x, Tensor out, Tensor grad_out, float alpha)-> Tensor(grad_x)
  args : (Tensor x, Tensor grad_out, Tensor grad_x_grad, float alpha)
  output : Tensor(x_grad), Tensor(grad_out_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, x]
  kernel :
    func : elu_double_grad
642
  inplace : (grad_x_grad -> grad_out_grad)
643

644 645 646 647 648 649 650 651 652
- backward_api : elu_grad
  forward : elu (Tensor x, float alpha) -> Tensor(out)
  args : (Tensor x, Tensor out, Tensor out_grad, float alpha)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : elu_grad
653
  backward : elu_double_grad
P
pangyoki 已提交
654
  inplace : (out_grad -> x_grad)
655

Z
zyfncg 已提交
656 657 658 659 660 661
- backward_api : embedding_grad
  forward : embedding (Tensor x, Tensor weight, int64_t padding_idx=-1, bool sparse=false) -> Tensor(out)
  args : (Tensor x, Tensor weight, Tensor out_grad, int64_t padding_idx=-1, bool sparse=false)
  output : Tensor(weight_grad)
  invoke : embedding_grad_impl(x, weight, out_grad, padding_idx, sparse, weight_grad)

662 663 664 665 666 667 668 669 670 671 672 673
- backward_api : erf_grad
  forward : erf (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : erf_grad
    data_type : out_grad

- backward_api : erfinv_grad
674
  forward : erfinv (Tensor x) -> Tensor(out)
675 676 677 678 679 680 681 682
  args : (Tensor out, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [out]
  kernel :
    func : erfinv_grad

C
chentianyu03 已提交
683 684 685 686 687 688 689 690 691
- backward_api : exp_grad
  forward : exp (Tensor x) -> Tensor(out)
  args : (Tensor out, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [out]
  kernel :
    func : exp_grad
P
pangyoki 已提交
692
  inplace : (out_grad -> x_grad)
C
chentianyu03 已提交
693

H
hong 已提交
694 695 696 697 698 699 700 701 702
- backward_api : expand_as_grad
  forward : expand_as (Tensor x, Tensor y, int[] target_shape) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, int[] target_shape)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : expand_as_grad
H
hong 已提交
703
  no_need_buffer : x
704

705 706 707 708 709 710 711 712 713
- backward_api : expand_double_grad
  forward : expand_grad (Tensor x, Tensor grad_out, IntArray shape) -> Tensor(grad_x)
  args : (Tensor grad_x_grad, IntArray shape)
  output : Tensor(grad_out_grad)
  infer_meta :
    func : ExpandInferMeta
  kernel :
    func : expand

H
hong 已提交
714 715 716 717 718 719 720 721 722
- backward_api : expand_grad
  forward : expand (Tensor x, IntArray shape) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, IntArray shape)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : expand_grad
W
wanghuancoder 已提交
723
  no_need_buffer : x
724
  backward : expand_double_grad
H
hong 已提交
725

726 727 728 729 730 731 732 733 734
- backward_api : expm1_grad
  forward : expm1 (Tensor x) -> Tensor(out)
  args : (Tensor out, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [out]
  kernel :
    func : expm1_grad
P
pangyoki 已提交
735
  inplace : (out_grad -> x_grad)
736

737 738 739 740 741 742 743 744 745 746 747 748
- backward_api : flatten_grad
  forward : flatten(Tensor x, int start_axis, int stop_axis) -> Tensor(out), Tensor(xshape)
  args : (Tensor xshape, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func :  KernelWithXShapeInferMeta
    param : [xshape]
  kernel :
    func : flatten_grad
    data_type: out_grad
    backend: out_grad
    layout: out_grad
749
  inplace : (out_grad -> x_grad)
750

H
hong 已提交
751 752 753 754 755 756 757 758 759 760
- backward_api : flip_grad
  forward : flip (Tensor x, int[] axis) -> Tensor(out)
  args : (Tensor out_grad, int[] axis)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [out_grad]
  kernel :
    func : flip

761 762 763 764 765 766 767 768 769
- backward_api : floor_grad
  forward : floor(Tensor x) -> Tensor(out)
  args : (Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [out_grad]
  kernel :
    func : floor_grad
P
pangyoki 已提交
770
  inplace : (out_grad -> x_grad)
771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791

- backward_api : fmax_grad
  forward : fmax(Tensor x, Tensor y, int axis) -> Tensor(out)
  args : (Tensor x, Tensor y, Tensor out_grad, int axis)
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param: [x, y]
  kernel :
    func : fmax_grad

- backward_api : fmin_grad
  forward : fmin(Tensor x, Tensor y, int axis) -> Tensor(out)
  args : (Tensor x, Tensor y, Tensor out_grad, int axis)
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param: [x, y]
  kernel :
    func : fmin_grad

F
From00 已提交
792 793 794 795 796 797 798 799 800 801
- backward_api : frobenius_norm_grad
  forward : frobenius_norm(Tensor x, int64_t[] axis,  bool keep_dim,  bool reduce_all) -> Tensor(out)
  args : (Tensor x, Tensor out, Tensor out_grad, int64_t[] axis,  bool keep_dim,  bool reduce_all)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : frobenius_norm_grad

802 803 804 805 806 807 808 809 810 811
- backward_api : gather_grad
  forward : gather(Tensor x, Tensor index, Scalar axis=0) -> Tensor(out)
  args : (Tensor x, Tensor index, Tensor out_grad, Scalar axis=0, bool overwrite=false)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [x]
  kernel :
    data_type: x
    func : gather_grad
H
hong 已提交
812
  no_need_buffer : x
813

814 815 816 817 818 819 820 821 822
- backward_api : gather_nd_grad
  forward : gather_nd (Tensor x, Tensor index) -> Tensor(out)
  args : (Tensor x, Tensor index, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : gather_nd_grad
H
hong 已提交
823
  no_need_buffer : x
824

825 826 827 828 829 830 831 832 833 834
- backward_api : gelu_grad
  forward : gelu(Tensor x,  bool approximate) -> Tensor(out)
  args : (Tensor x, Tensor out_grad,  bool approximate)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [x]
  kernel :
    func : gelu_grad

835 836 837 838 839 840 841 842 843
- backward_api : graph_send_recv_grad
  forward : graph_send_recv (Tensor x, Tensor src_index, Tensor dst_index, str pool_type = "SUM", int64_t out_size = 0) -> Tensor(out), Tensor(dst_count)
  args : (Tensor x, Tensor src_index, Tensor dst_index, Tensor out, Tensor dst_count, Tensor out_grad, str pool_type = "SUM")
  output : Tensor(x_grad)
  infer_meta :
    func : GeneralUnaryGradInferMeta
    param : [x]
  kernel :
    func : graph_send_recv_grad
844
    data_type : out_grad
845 846
  optional: out, dst_count

H
hong 已提交
847 848 849 850 851 852 853 854 855 856
- backward_api : gumbel_softmax_grad
  forward : gumbel_softmax (Tensor x, float temperature, bool hard, int axis) -> Tensor(out)
  args : (Tensor out, Tensor out_grad, int axis)
  output : Tensor(x_grad)
  infer_meta :
    func : GumbelSoftmaxGradInferMeta
    param : [out, out_grad, axis]
  kernel :
    func : gumbel_softmax_grad

857 858 859 860 861 862 863 864 865
- backward_api : hard_shrink_grad
  forward : hard_shrink (Tensor x, float threshold) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, float threshold)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : hard_shrink_grad
P
pangyoki 已提交
866
  inplace : (out_grad -> x_grad)
867 868 869 870 871 872 873 874 875 876

- backward_api : hard_sigmoid_grad
  forward : hard_sigmoid (Tensor x, float slope, float offset) -> Tensor(out)
  args : (Tensor out, Tensor out_grad, float slope, float offset)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [out]
  kernel :
    func : hard_sigmoid_grad
P
pangyoki 已提交
877
  inplace : (out_grad -> x_grad)
878

879 880 881 882 883 884 885 886 887
- backward_api : hard_swish_grad
  forward : hard_swish (Tensor x, float threshold = 6.0, float scale = 6.0, float offset = 3.0) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, float threshold, float scale, float offset)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : hard_swish_grad
P
pangyoki 已提交
888
  inplace : (out_grad -> x_grad)
889

890 891 892 893 894 895 896 897 898 899
- backward_api : huber_loss_grad
  forward : huber_loss (Tensor input, Tensor label, float delta) -> Tensor(out), Tensor(residual)
  args : (Tensor residual, Tensor out_grad, float delta)
  output : Tensor(input_grad), Tensor(label_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [residual, residual]
  kernel :
    func : huber_loss_grad

Z
zyfncg 已提交
900 901 902 903
- backward_api : imag_grad
  forward : imag (Tensor x) -> Tensor(out)
  args : (Tensor out_grad)
  output : Tensor(x_grad)
904
  invoke : imag_grad_impl(out_grad, x_grad)
Z
zyfncg 已提交
905

906 907 908 909 910 911 912 913 914 915
- backward_api : index_sample_grad
  forward : index_sample (Tensor x, Tensor index) -> Tensor(out)
  args : (Tensor x, Tensor index, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : index_sample_grad
    data_type : out_grad
H
hong 已提交
916
  no_need_buffer : x
917

F
From00 已提交
918 919 920 921 922 923 924 925 926 927
- backward_api : index_select_grad
  forward : index_select(Tensor x, Tensor index,  int dim) -> Tensor(out)
  args : (Tensor x, Tensor index, Tensor out_grad,  int dim)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : index_select_grad
    data_type : x
H
hong 已提交
928
  no_need_buffer : x
F
From00 已提交
929

930 931 932 933 934 935 936 937 938
- backward_api : kldiv_loss_grad
  forward : kldiv_loss(Tensor x, Tensor label, str reduction) -> Tensor(out)
  args : (Tensor x, Tensor label, Tensor out_grad, str reduction)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [x]
  kernel :
    func : kldiv_loss_grad
H
hong 已提交
939
  no_need_buffer : x
940

941 942 943 944 945 946 947 948 949 950 951
- backward_api : kron_grad
  forward : kron (Tensor x, Tensor y) -> Tensor(out)
  args : (Tensor x, Tensor y, Tensor out_grad)
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, y]
  kernel :
    func : kron_grad
    data_type : out_grad

952 953 954 955 956 957 958 959 960 961
- backward_api : kthvalue_grad
  forward : kthvalue(Tensor x, int k, int axis, bool keepdim) -> Tensor(out), Tensor(indices)
  args : (Tensor x, Tensor indices, Tensor out_grad, int k, int axis, bool keepdim)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [x]
  kernel :
    func : kthvalue_grad

962 963 964 965 966 967 968 969 970 971
- backward_api : label_smooth_grad
  forward : label_smooth (Tensor label, Tensor prior_dist, float epsilon) -> Tensor(out)
  args : (Tensor out_grad, float epsilon)
  output : Tensor(label_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [out_grad]
  kernel :
    func : label_smooth_grad

H
hong 已提交
972 973 974 975 976 977 978 979 980 981
- backward_api : layer_norm_grad
  forward : layer_norm (Tensor x, Tensor scale, Tensor bias, float epsilon, int begin_norm_axis, bool is_test) -> Tensor(out), Tensor(mean), Tensor(variance)
  args : (Tensor x,  Tensor scale, Tensor bias, Tensor mean, Tensor variance, Tensor out_grad, float epsilon, int begin_norm_axis, bool is_test)
  output : Tensor(x_grad), Tensor(scale_grad), Tensor(bias_grad)
  infer_meta :
    func : LayerNormGradInferMeta
    param : [x, scale, bias]
  kernel :
    func : layer_norm_grad
    data_type : out_grad
W
wanghuancoder 已提交
982
  no_need_buffer : bias
H
hong 已提交
983 984
  optional : scale, bias

985 986 987 988 989 990 991 992 993
- backward_api : leaky_relu_double_grad
  forward : leaky_relu_grad (Tensor x, Tensor grad_out, float alpha) -> Tensor(grad_x)
  args : (Tensor x, Tensor grad_x_grad, float alpha)
  output : Tensor(grad_out_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [grad_x_grad]
  kernel :
    func : leaky_relu_double_grad
994
  inplace : (grad_x_grad -> grad_out_grad)
995

996 997 998 999 1000 1001 1002 1003 1004
- backward_api : leaky_relu_grad
  forward : leaky_relu (Tensor x, float alpha) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, float alpha)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : leaky_relu_grad
1005
  backward : leaky_relu_double_grad
P
pangyoki 已提交
1006
  inplace : (out_grad -> x_grad)
1007 1008

- backward_api : lerp_grad
1009
  forward : lerp (Tensor x, Tensor y, Tensor weight) -> Tensor(out)
1010 1011 1012 1013 1014 1015 1016 1017
  args : (Tensor x, Tensor y, Tensor weight, Tensor out, Tensor out_grad)
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, y]
  kernel :
    func : lerp_grad

1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
- backward_api : lgamma_grad
  forward : lgamma(Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [x]
  kernel :
    func : lgamma_grad

- backward_api : log10_grad
  forward : log10 (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : log10_grad
P
pangyoki 已提交
1037
  inplace : (out_grad -> x_grad)
1038 1039 1040 1041 1042 1043 1044 1045 1046 1047

- backward_api : log1p_grad
  forward : log1p (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : log1p_grad
P
pangyoki 已提交
1048
  inplace : (out_grad -> x_grad)
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058

- backward_api : log2_grad
  forward : log2 (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : log2_grad
P
pangyoki 已提交
1059
  inplace : (out_grad -> x_grad)
1060

1061 1062 1063 1064 1065 1066 1067 1068 1069
- backward_api : log_double_grad
  forward : log_grad (Tensor x, Tensor grad_out) -> Tensor(grad_x)
  args : (Tensor x, Tensor grad_out, Tensor grad_x_grad)
  output : Tensor(x_grad), Tensor(grad_out_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, x]
  kernel :
    func : log_double_grad
1070
  inplace : (grad_x_grad -> grad_out_grad)
1071

1072 1073 1074 1075 1076 1077 1078 1079 1080
- backward_api : log_grad
  forward : log (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : log_grad
1081
  backward : log_double_grad
P
pangyoki 已提交
1082
  inplace : (out_grad -> x_grad)
1083

1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
- backward_api : log_loss_grad
  forward : log_loss (Tensor input, Tensor label, float epsilon) -> Tensor(out)
  args : (Tensor input, Tensor label, Tensor out_grad, float epsilon)
  output : Tensor(input_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [input]
  kernel :
    func : log_loss_grad

1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
- backward_api : log_softmax_grad
  forward : log_softmax(Tensor x,  int axis) -> Tensor(out)
  args : (Tensor out, Tensor out_grad,  int axis)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [out]
  kernel :
    func : log_softmax_grad

1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
- backward_api : logit_grad
  forward : logit (Tensor x, float eps = 1e-6f) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, float eps)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : logit_grad

1114 1115
- backward_api : logsigmoid_grad
  forward : logsigmoid (Tensor x) -> Tensor(out)
H
hong 已提交
1116 1117 1118
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
1119 1120 1121 1122
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : logsigmoid_grad
P
pangyoki 已提交
1123
  inplace : (out_grad -> x_grad)
1124

1125 1126 1127 1128 1129 1130 1131 1132 1133 1134
- backward_api : logsumexp_grad
  forward : logsumexp(Tensor x, int64_t[] axis,  bool keepdim,  bool reduce_all) -> Tensor(out)
  args : (Tensor x, Tensor out, Tensor out_grad, int64_t[] axis,  bool keepdim,  bool reduce_all)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [x]
  kernel :
    func : logsumexp_grad

1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
- backward_api : masked_select_grad
  forward : masked_select (Tensor x, Tensor mask) -> Tensor(out)
  args : (Tensor x, Tensor mask, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : masked_select_grad
    data_type : x
H
hong 已提交
1145
  no_need_buffer : x
1146 1147

- backward_api : matmul_double_grad
1148 1149 1150
  forward : matmul_grad (Tensor x, Tensor y, Tensor grad_out, bool transpose_x=false, bool transpose_y=false) -> Tensor(grad_x), Tensor(grad_y)
  args : (Tensor x, Tensor y, Tensor grad_out, Tensor grad_x_grad, Tensor grad_y_grad, bool transpose_x=false, bool transpose_y=false)
  output : Tensor(x_grad), Tensor(y_grad), Tensor(grad_out_grad)
1151 1152
  infer_meta :
    func : GeneralTernaryGradInferMeta
1153
    param : [x, y, grad_out]
1154 1155
  kernel :
    func : matmul_double_grad
1156
  backward : matmul_triple_grad
1157
  optional : grad_x_grad, grad_y_grad
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167

- backward_api : matmul_grad
  forward : matmul (Tensor x, Tensor y, bool transpose_x=false, bool transpose_y=false) -> Tensor(out)
  args : (Tensor x, Tensor y, Tensor out_grad, bool transpose_x=false, bool transpose_y=false)
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, y]
  kernel :
    func : matmul_grad
1168
  backward : matmul_double_grad
1169

1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
- backward_api : matmul_triple_grad
  forward : matmul_double_grad (Tensor x, Tensor y, Tensor fwd_grad_out, Tensor fwd_grad_grad_x, Tensor fwd_grad_grad_y, bool transpose_x=false, bool transpose_y=false) -> Tensor(grad_x), Tensor(grad_y), Tensor(grad_grad_out)
  args : (Tensor x, Tensor y, Tensor fwd_grad_out, Tensor fwd_grad_grad_x, Tensor fwd_grad_grad_y, Tensor grad_x_grad, Tensor grad_y_grad, Tensor grad_grad_out_grad, bool transpose_x=false, bool transpose_y=false)
  output : Tensor(x_grad), Tensor(y_grad), Tensor(fwd_grad_out_grad), Tensor(fwd_grad_grad_x_grad), Tensor(fwd_grad_grad_y_grad)
  infer_meta :
    func : GeneralQuinaryGradInferMeta
    param : [x, y, fwd_grad_out, fwd_grad_grad_x, fwd_grad_grad_y]
  kernel :
    func : matmul_triple_grad
  optional : grad_x_grad, grad_y_grad, grad_grad_out_grad

1181 1182 1183 1184 1185 1186 1187 1188 1189 1190
- backward_api : matrix_power_grad
  forward : matrix_power (Tensor x, int n) -> Tensor(out)
  args : (Tensor x, Tensor out, Tensor out_grad, int n)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : matrix_power_grad

1191 1192 1193 1194 1195 1196 1197 1198 1199 1200
- backward_api : max_grad
  forward: max (Tensor x,  int64_t[] dims={},  bool keep_dim=false) -> Tensor(out)
  args : (Tensor x, Tensor out, Tensor out_grad, int64_t[] dims={},  bool keep_dim=false, bool reduce_all=false)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [x]
  kernel :
    func : max_grad

F
From00 已提交
1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
- backward_api : max_pool2d_with_index_grad
  forward : max_pool2d_with_index(Tensor x, int[] kernel_size, int[] strides, int[] paddings, bool global_pooling, bool adaptive) -> Tensor(out), Tensor(mask)
  args : (Tensor x, Tensor mask, Tensor out_grad, int[] kernel_size, int[] strides, int[] paddings, bool global_pooling, bool adaptive)
  output : Tensor(x_grad)
  infer_meta :
    func : MaxPoolWithIndexGradInferMeta
  kernel :
    func : max_pool2d_with_index_grad

- backward_api : max_pool3d_with_index_grad
  forward : max_pool3d_with_index(Tensor x, int[] kernel_size, int[] strides, int[] paddings, bool global_pooling, bool adaptive) -> Tensor(out), Tensor(mask)
  args : (Tensor x, Tensor mask, Tensor out_grad, int[] kernel_size, int[] strides, int[] paddings, bool global_pooling, bool adaptive)
  output : Tensor(x_grad)
  infer_meta :
    func : MaxPoolWithIndexGradInferMeta
  kernel :
    func : max_pool3d_with_index_grad

1219 1220 1221 1222 1223 1224 1225 1226 1227 1228
- backward_api : maximum_grad
  forward : maximum(Tensor x, Tensor y) -> Tensor(out)
  args : (Tensor x, Tensor y, Tensor out_grad, int axis=-1)
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param: [x, y]
  kernel :
    func : maximum_grad

1229 1230 1231 1232 1233 1234 1235 1236 1237 1238
- backward_api : maxout_grad
  forward : maxout(Tensor x, int groups, int axis) -> Tensor(out)
  args : (Tensor x, Tensor out, Tensor out_grad, int groups, int axis)
  output : Tensor(x_grad)
  infer_meta :
    func : GeneralUnaryGradInferMeta
    param: [x]
  kernel :
    func : maxout_grad

1239 1240 1241 1242 1243 1244 1245 1246 1247 1248
- backward_api : mean_all_grad
  forward : mean_all(Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [x]
  kernel :
    func : mean_all_grad

1249 1250 1251 1252 1253 1254
- backward_api : mean_double_grad
  forward: mean_grad (Tensor x, Tensor grad_out, int64_t[] dims={},  bool keep_dim=false, bool reduce_all = false) -> Tensor(grad_x)
  args : (Tensor grad_x_grad, int64_t[] dims={},  bool keep_dim=false, bool reduce_all=false)
  output : Tensor(grad_out_grad)
  invoke : mean(grad_x_grad, dims, keep_dim)

1255 1256 1257 1258 1259 1260 1261 1262 1263
- backward_api : mean_grad
  forward: mean (Tensor x,  int64_t[] dims={},  bool keep_dim=false) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, int64_t[] dims={},  bool keep_dim=false, bool reduce_all=false)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [x]
  kernel :
    func : mean_grad
1264
  backward : mean_double_grad
H
hong 已提交
1265
  no_need_buffer : x
1266

Y
YuanRisheng 已提交
1267 1268 1269
- backward_api : meshgrid_grad
  forward : meshgrid (Tensor[] inputs) -> Tensor[](outputs)
  args : (Tensor[] inputs, Tensor[] outputs_grad)
1270 1271 1272 1273 1274
  output : Tensor[](inputs_grad){inputs.size()}
  infer_meta :
    func : MeshgridGradInferMeta
  kernel :
    func : meshgrid_grad
Y
YuanRisheng 已提交
1275

1276 1277 1278 1279 1280 1281 1282 1283 1284 1285
- backward_api : min_grad
  forward: min (Tensor x,  int64_t[] dims={},  bool keep_dim=false) -> Tensor(out)
  args : (Tensor x, Tensor out, Tensor out_grad, int64_t[] dims={},  bool keep_dim=false, bool reduce_all=false)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [x]
  kernel :
    func : min_grad

1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
- backward_api : minimum_grad
  forward : minimum(Tensor x, Tensor y) -> Tensor(out)
  args : (Tensor x, Tensor y, Tensor out_grad, int axis=-1)
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param: [x, y]
  kernel :
    func : minimum_grad

1296 1297 1298 1299 1300 1301 1302 1303 1304
- backward_api : mish_grad
  forward : mish (Tensor x, float threshold) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, float threshold)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : mish_grad
P
pangyoki 已提交
1305
  inplace : (out_grad -> x_grad)
1306

1307 1308 1309 1310 1311 1312 1313 1314 1315 1316
- backward_api : mode_grad
  forward : mode(Tensor x,  int axis,  bool keepdim) -> Tensor(out), Tensor(indices)
  args : (Tensor x, Tensor indices, Tensor out_grad,  int axis,  bool keepdim)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [x]
  kernel :
    func : mode_grad

1317
- backward_api : modulo_grad
1318
  forward : modulo (Tensor x, Tensor y) -> Tensor(out)
1319 1320 1321 1322 1323 1324 1325 1326 1327
  args : (Tensor x, Tensor y, Tensor out_grad, int axis = -1)
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, y]
  kernel :
    func : modulo_grad
  no_need_buffer : x, y

1328 1329 1330
- backward_api : multi_dot_grad
  forward : multi_dot (Tensor[] x) -> Tensor(out)
  args : (Tensor[] x, Tensor out_grad)
1331 1332 1333 1334 1335
  output : Tensor[](x_grad) {x.size()}
  infer_meta :
    func : MultiDotGradInferMeta
  kernel :
    func : multi_dot_grad
1336 1337 1338 1339

- backward_api : multiplex_grad
  forward : multiplex (Tensor[] ins, Tensor ids) -> Tensor(out)
  args : (Tensor[] ins, Tensor ids, Tensor out_grad)
1340 1341 1342 1343 1344 1345 1346
  output : Tensor[](ins_grad){ins.size()}
  infer_meta :
    func : MultiplexGradInferMeta
    param : [ids, out_grad]
  kernel :
    func : multiplex_grad
    param : [ids, out_grad]
1347

1348 1349 1350 1351 1352 1353 1354 1355 1356 1357
- backward_api : multiply_double_grad
  forward : multiply_grad (Tensor x, Tensor y, Tensor grad_out, int axis = -1) -> Tensor(grad_x), Tensor(grad_y)
  args : (Tensor x, Tensor y, Tensor grad_out, Tensor grad_x_grad, Tensor grad_y_grad, int axis = -1)
  output : Tensor(x_grad), Tensor(y_grad), Tensor(grad_out_grad)
  infer_meta :
    func : GeneralTernaryGradInferMeta
    param : [x, y, grad_out]
  kernel :
    func : multiply_double_grad
  optional : grad_x_grad, grad_y_grad
1358
  backward : multiply_triple_grad
1359
  inplace : (grad_x_grad -> grad_out_grad)
1360

1361 1362 1363 1364 1365 1366 1367 1368 1369
- backward_api : multiply_grad
  forward : multiply (Tensor x, Tensor y) -> Tensor(out)
  args : (Tensor x, Tensor y, Tensor out_grad, int axis = -1)
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, y]
  kernel :
    func : multiply_grad
1370
  backward : multiply_double_grad
1371

1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
- backward_api : multiply_triple_grad
  forward : multiply_double_grad (Tensor x, Tensor y, Tensor fwd_grad_out, Tensor fwd_grad_grad_x, Tensor fwd_grad_grad_y, int aixs = -1) -> Tensor(grad_x), Tensor(grad_y), Tensor(grad_grad_out)
  args : (Tensor x, Tensor y, Tensor fwd_grad_out, Tensor fwd_grad_grad_x, Tensor fwd_grad_grad_y, Tensor grad_x_grad, Tensor grad_y_grad, Tensor grad_grad_out_grad, int axis = -1)
  output : Tensor(x_grad), Tensor(y_grad), Tensor(fwd_grad_out_grad), Tensor(fwd_grad_grad_x_grad), Tensor(fwd_grad_grad_y_grad)
  infer_meta :
    func : GeneralQuinaryGradInferMeta
    param : [x, y, fwd_grad_out, x, y]
  kernel :
    func : multiply_triple_grad
  optional : fwd_grad_grad_x, fwd_grad_grad_y, grad_grad_out_grad

1383 1384 1385 1386 1387 1388 1389
- backward_api : mv_grad
  forward : mv (Tensor x, Tensor vec) -> Tensor(out)
  args : (Tensor x, Tensor vec, Tensor out_grad)
  output : Tensor(x_grad), Tensor(vec_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, vec]
H
hong 已提交
1390
  kernel :
1391
    func : mv_grad
H
hong 已提交
1392

1393
- backward_api : nll_loss_grad
Z
zyfncg 已提交
1394 1395 1396
  forward : nll_loss (Tensor input, Tensor label, Tensor weight, int64_t ignore_index, str reduction) -> Tensor(out), Tensor(total_weight)
  args : (Tensor input, Tensor label, Tensor weight, Tensor total_weight, Tensor out_grad, int64_t ignore_index, str reduction)
  output : Tensor(input_grad)
H
hong 已提交
1397
  infer_meta :
Z
zyfncg 已提交
1398
    func : NllLossGradInferMeta
H
hong 已提交
1399
  kernel :
1400
    func : nll_loss_grad
Z
zyfncg 已提交
1401
    data_type : input
1402
  optional : weight
H
hong 已提交
1403

H
hong 已提交
1404 1405 1406 1407 1408 1409 1410 1411 1412 1413
- backward_api : norm_grad
  forward : norm (Tensor x, int axis, float epsilon, bool is_test) -> Tensor(out), Tensor(norm)
  args : (Tensor x, Tensor norm, Tensor out_grad, int axis, float epsilon, bool is_test)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : norm_grad

1414 1415 1416 1417 1418 1419 1420 1421 1422 1423
- backward_api : p_norm_grad
  forward : p_norm(Tensor x,  float porder,  int axis,  float epsilon,  bool keepdim,  bool asvector=false) -> Tensor(out)
  args : (Tensor x, Tensor out, Tensor out_grad,  float porder,  int axis,  float epsilon,  bool keepdim,  bool asvector)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [x]
  kernel :
    func : p_norm_grad

1424 1425 1426 1427 1428 1429 1430 1431 1432
- backward_api : pad3d_double_grad
  forward : pad3d_grad(Tensor x, Tensor grad_out, IntArray paddings, str mode, float pad_value, str data_format) -> Tensor(grad_x)
  args : (Tensor grad_x_grad, IntArray paddings, str mode, float pad_value, str data_format)
  output : Tensor(grad_out_grad)
  infer_meta :
    func : Pad3dInferMeta
  kernel :
    func : pad3d

1433 1434 1435 1436 1437 1438 1439 1440 1441
- backward_api : pad3d_grad
  forward : pad3d(Tensor x, IntArray paddings, str mode,  float pad_value, str data_format) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, IntArray paddings, str mode,  float pad_value, str data_format)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [x]
  kernel :
    func : pad3d_grad
W
wanghuancoder 已提交
1442
  no_need_buffer : x
1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465
  backward : pad3d_double_grad

- backward_api : pad_double_grad
  forward : pad_grad(Tensor x, Tensor grad_out, int[] paddings, float pad_value) -> Tensor(grad_x)
  args : (Tensor grad_x_grad, int[] paddings, float pad_value)
  output : Tensor(grad_out_grad)
  infer_meta :
    func : PadInferMeta
  kernel :
    func : pad

- backward_api : pad_grad
  forward : pad(Tensor x, int[] paddings, float pad_value) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, int[] paddings, float pad_value)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [x]
  kernel :
    func : pad_grad
    param: [out_grad, paddings, pad_value]
  no_need_buffer : x
  backward : pad_double_grad
1466

H
hong 已提交
1467 1468 1469 1470 1471 1472 1473 1474 1475
- backward_api : pixel_shuffle_grad
  forward : pixel_shuffle (Tensor x, int upscale_factor, str data_format) -> Tensor(out)
  args : (Tensor out_grad, int upscale_factor, str data_format)
  output : Tensor(x_grad)
  infer_meta :
    func : PixelShuffleGradInferMeta
  kernel :
    func : pixel_shuffle_grad

H
hong 已提交
1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
- backward_api : poisson_grad
  forward : poisson (Tensor x) -> Tensor(out)
  args : (Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [out_grad]
  kernel :
    func : poisson_grad

1486 1487 1488 1489 1490 1491 1492 1493 1494 1495
- backward_api : pool2d_double_grad
  forward : pool2d_grad(Tensor x, Tensor out, Tensor grad_out, int[] kernel_size, int[] strides, int[] paddings, bool ceil_mode, bool exclusive, str data_format, str pooling_type, bool global_pooling, bool adaptive, str padding_algorithm) -> Tensor(grad_x)
  args : (Tensor grad_x_grad, int[] kernel_size, int[] strides, int[] paddings, bool ceil_mode, bool exclusive, str data_format, str pooling_type, bool global_pooling, bool adaptive, str padding_algorithm)
  output : Tensor(grad_out_grad)
  infer_meta :
    func : PoolInferMeta
  kernel :
    func : pool2d_double_grad
    use_gpudnn : true

F
From00 已提交
1496 1497 1498 1499 1500 1501 1502 1503
- backward_api : pool2d_grad
  forward : pool2d(Tensor x, int[] kernel_size, int[] strides, int[] paddings, bool ceil_mode, bool exclusive, str data_format, str pooling_type, bool global_pooling, bool adaptive, str padding_algorithm) -> Tensor(out)
  args : (Tensor x, Tensor out, Tensor out_grad, int[] kernel_size, int[] strides, int[] paddings, bool ceil_mode, bool exclusive, str data_format, str pooling_type, bool global_pooling, bool adaptive, str padding_algorithm)
  output : Tensor(x_grad)
  infer_meta :
    func : PoolGradInferMeta
  kernel :
    func : pool2d_grad
1504
    use_gpudnn : true
1505
  backward : pool2d_double_grad
1506 1507 1508 1509 1510 1511 1512 1513 1514 1515

- backward_api : pool2d_grad_gpudnn_unused
  forward : pool2d_gpudnn_unused(Tensor x, int[] kernel_size, int[] strides, int[] paddings, bool ceil_mode, bool exclusive, str data_format, str pooling_type, bool global_pooling, bool adaptive, str padding_algorithm) -> Tensor(out)
  args : (Tensor x, Tensor out, Tensor out_grad, int[] kernel_size, int[] strides, int[] paddings, bool ceil_mode, bool exclusive, str data_format, str pooling_type, bool global_pooling, bool adaptive, str padding_algorithm)
  output : Tensor(x_grad)
  infer_meta :
    func : PoolGradInferMeta
  kernel :
    func : pool2d_grad
    use_gpudnn : false
F
From00 已提交
1516 1517 1518 1519 1520 1521 1522 1523 1524

- backward_api : pool3d_grad
  forward : pool3d(Tensor x, int[] kernel_size, int[] strides, int[] paddings, bool ceil_mode, bool exclusive, str data_format, str pooling_type, bool global_pooling, bool adaptive, str padding_algorithm) -> Tensor(out)
  args : (Tensor x, Tensor out, Tensor out_grad, int[] kernel_size, int[] strides, int[] paddings, bool ceil_mode, bool exclusive, str data_format, str pooling_type, bool global_pooling, bool adaptive, str padding_algorithm)
  output : Tensor(x_grad)
  infer_meta :
    func : PoolGradInferMeta
  kernel :
    func : pool3d_grad
1525
    use_gpudnn : true
F
From00 已提交
1526

1527 1528 1529 1530 1531 1532 1533 1534 1535
- backward_api : pow_grad
  forward : pow(Tensor x, Scalar s) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, Scalar s=-1)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [x]
  kernel :
    func : pow_grad
P
pangyoki 已提交
1536
  inplace : (out_grad -> x_grad)
1537

1538 1539 1540 1541 1542 1543 1544 1545 1546 1547
- backward_api : prelu_grad
  forward : prelu(Tensor x, Tensor alpha, str data_format, str mode) -> Tensor(out)
  args : (Tensor x, Tensor alpha, Tensor out_grad, str data_format, str mode)
  output : Tensor(x_grad), Tensor(alpha_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param: [x, alpha]
  kernel :
    func : prelu_grad

1548
- backward_api : psroi_pool_grad
Z
zyfncg 已提交
1549 1550
  forward : psroi_pool (Tensor x, Tensor boxes, Tensor boxes_num, int pooled_height, int pooled_width, int output_channels, float spatial_scale) -> Tensor(out)
  args : (Tensor x, Tensor boxes, Tensor boxes_num, Tensor out_grad, int pooled_height, int pooled_width, int output_channels, float spatial_scale)
1551 1552
  output : Tensor(x_grad)
  infer_meta :
Z
zyfncg 已提交
1553
    func : GeneralUnaryGradInferMeta
1554 1555
    param : [x]
  kernel :
1556
    func : psroi_pool_grad
1557
    data_type : x
Z
zyfncg 已提交
1558
  optional : boxes_num
1559 1560 1561 1562 1563 1564

# output is optional
- backward_api : put_along_axis_grad
  forward : put_along_axis (Tensor x, Tensor index, Tensor value, int axis, str reduce) -> Tensor(out)
  args : (Tensor x, Tensor index, Tensor out_grad, int axis, str reduce)
  output : Tensor(x_grad), Tensor(value_grad)
H
hong 已提交
1565
  infer_meta :
1566 1567
    func : GeneralBinaryGradInferMeta
    param : [x, index]
H
hong 已提交
1568
  kernel :
1569
    func : put_along_axis_grad
H
hong 已提交
1570

Z
zyfncg 已提交
1571 1572 1573 1574
- backward_api : real_grad
  forward : real (Tensor x) -> Tensor(out)
  args : (Tensor out_grad)
  output : Tensor(x_grad)
1575
  invoke : real_grad_impl(out_grad, x_grad)
Z
zyfncg 已提交
1576

1577 1578 1579 1580 1581 1582 1583 1584 1585
- backward_api : reciprocal_grad
  forward : reciprocal (Tensor x) -> Tensor(out)
  args : (Tensor out, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [out]
  kernel :
    func : reciprocal_grad
P
pangyoki 已提交
1586
  inplace : (out_grad -> x_grad)
1587

H
hong 已提交
1588 1589 1590 1591 1592 1593 1594 1595
- backward_api : reduce_prod_grad
  forward : reduce_prod (Tensor x, int64_t[] dims, bool keep_dim, bool reduce_all) -> Tensor(out)
  args : (Tensor x, Tensor out, Tensor out_grad, int64_t[] dims,  bool keep_dim, bool reduce_all)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
H
hong 已提交
1596
    func : prod_grad
H
hong 已提交
1597

1598 1599 1600
- backward_api : relu_double_grad
  forward : relu_grad (Tensor out, Tensor grad_out) -> Tensor(grad_x)
  args : (Tensor out, Tensor grad_x_grad)
1601
  output : Tensor(grad_out_grad)
1602
  infer_meta :
1603 1604
    func : UnchangedInferMeta
    param : [out]
1605 1606
  kernel :
    func : relu_double_grad
1607
  inplace : (grad_x_grad -> grad_out_grad)
1608

1609 1610 1611
- backward_api : relu_grad
  forward : relu (Tensor x) -> Tensor(out)
  args : (Tensor out, Tensor out_grad)
H
hong 已提交
1612 1613 1614
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
1615
    param : [out]
H
hong 已提交
1616
  kernel :
1617
    func : relu_grad
1618
  backward: relu_double_grad
P
pangyoki 已提交
1619
  inplace : (out_grad -> x_grad)
H
hong 已提交
1620

1621 1622 1623 1624 1625 1626 1627 1628 1629
- backward_api : reshape_double_grad
  forward : reshape_grad (Tensor xshape, Tensor grad_out) -> Tensor(grad_x)
  args : (Tensor grad_out, Tensor grad_x_grad)
  output : Tensor(grad_out_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [grad_out]
  kernel :
    func : reshape_double_grad
W
wanghuancoder 已提交
1630
  no_need_buffer : grad_out
1631
  inplace : (grad_x_grad -> grad_out_grad)
1632

1633
- backward_api : reshape_grad
1634
  forward : reshape (Tensor x, IntArray shape) -> Tensor(out), Tensor(xshape)
1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645
  args : (Tensor xshape, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : KernelWithXShapeInferMeta
    param : [xshape]
  kernel :
    func : reshape_grad
    param : [out_grad]
    data_type: out_grad
    backend: out_grad
    layout: out_grad
1646
  backward : reshape_double_grad
1647
  inplace : (out_grad -> x_grad)
1648

1649 1650 1651 1652 1653 1654 1655 1656 1657
- backward_api : roi_align_grad
  forward : roi_align (Tensor x, Tensor boxes, Tensor boxes_num, int pooled_height, int pooled_width, float spatial_scale, int sampling_ratio, bool aligned) -> Tensor(out)
  args : (Tensor x, Tensor boxes, Tensor boxes_num, Tensor out_grad, int pooled_height, int pooled_width, float spatial_scale, int sampling_ratio, bool aligned)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : roi_align_grad
1658
    data_type : boxes
W
wanghuancoder 已提交
1659
  no_need_buffer : x
1660 1661
  optional : boxes_num

Z
zyfncg 已提交
1662 1663 1664 1665 1666 1667 1668 1669 1670
- backward_api : roi_pool_grad
  forward : roi_pool (Tensor x, Tensor boxes, Tensor boxes_num, int pooled_height, int pooled_width, float spatial_scale) -> Tensor(out), Tensor(arg_max)
  args : (Tensor x, Tensor boxes, Tensor boxes_num, Tensor arg_max, Tensor out_grad, int pooled_height, int pooled_width, float spatial_scale)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : roi_pool_grad
1671
    data_type : x
Z
zyfncg 已提交
1672 1673
  optional : boxes_num

F
From00 已提交
1674 1675 1676 1677 1678 1679 1680 1681 1682 1683
- backward_api : roll_grad
  forward : roll(Tensor x, IntArray shifts, int64_t[] axis) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, IntArray shifts, int64_t[] axis)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : roll_grad
    data_type : x
H
hong 已提交
1684
  no_need_buffer : x
F
From00 已提交
1685

1686 1687 1688 1689 1690 1691 1692 1693 1694
- backward_api : round_grad
  forward : round(Tensor x) -> Tensor(out)
  args : (Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param: [out_grad]
  kernel :
    func : round_grad
P
pangyoki 已提交
1695
  inplace : (out_grad -> x_grad)
1696

1697 1698 1699 1700 1701 1702 1703 1704 1705
- backward_api : rsqrt_double_grad
  forward : rsqrt_grad (Tensor out, Tensor grad_out) -> Tensor(grad_x)
  args : (Tensor out, Tensor grad_x, Tensor grad_x_grad)
  output : Tensor(out_grad), Tensor(grad_out_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [out, out]
  kernel :
    func : rsqrt_double_grad
1706
  inplace : (grad_x_grad -> grad_out_grad)
1707

Z
zyfncg 已提交
1708 1709 1710 1711 1712 1713 1714 1715 1716
- backward_api : rsqrt_grad
  forward : rsqrt (Tensor x) -> Tensor(out)
  args : (Tensor out, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [out]
  kernel :
    func : rsqrt_grad
1717
  backward : rsqrt_double_grad
P
pangyoki 已提交
1718
  inplace : (out_grad -> x_grad)
Z
zyfncg 已提交
1719

1720 1721 1722 1723 1724 1725 1726
- backward_api : scale_double_grad
  forward : scale_grad (Tensor grad_out, Scalar scale, float bias, bool bias_after_scale) -> Tensor(grad_x)
  args : (Tensor grad_x_grad, Scalar scale=1.0, float bias=0.0, bool bias_after_scale=true)
  output : Tensor(grad_out_grad)
  invoke : scale(grad_x_grad, scale, 0.0, bias_after_scale)
  backward : scale_triple_grad

1727 1728
- backward_api : scale_grad
  forward : scale (Tensor x, Scalar scale, float bias, bool bias_after_scale) -> Tensor(out)
1729
  args : (Tensor out_grad, Scalar scale=1.0, float bias=0.0, bool bias_after_scale=true)
H
hong 已提交
1730
  output : Tensor(x_grad)
1731
  invoke : scale(out_grad, scale, 0.0, bias_after_scale)
1732
  backward : scale_double_grad
1733
  inplace : (out_grad -> x_grad)
1734 1735 1736 1737 1738 1739

- backward_api : scale_triple_grad
  forward : scale_double_grad (Tensor grad_grad_x, Scalar scale, float bias, bool bias_after_scale) -> Tensor(grad_grad_out)
  args : (Tensor grad_grad_out_grad, Scalar scale=1.0, float bias=0.0, bool bias_after_scale=true)
  output : Tensor(grad_grad_x_grad)
  invoke : scale(grad_grad_out_grad, scale, 0.0, bias_after_scale)
H
hong 已提交
1740 1741 1742 1743 1744 1745 1746 1747 1748 1749

- backward_api : scatter_grad
  forward : scatter (Tensor x, Tensor index, Tensor updates, bool overwrite) -> Tensor(out)
  args : (Tensor index, Tensor updates, Tensor out_grad, bool overwrite)
  output : Tensor(x_grad), Tensor(updates_grad)
  infer_meta :
    func : ScatterGradInferMeta
    param : [index, updates, out_grad, overwrite]
  kernel :
    func : scatter_grad
H
hong 已提交
1750
  no_need_buffer : updates
H
hong 已提交
1751 1752

- backward_api : scatter_nd_add_grad
1753
  forward : scatter_nd_add (Tensor x, Tensor index, Tensor updates) -> Tensor(out)
H
hong 已提交
1754 1755 1756 1757 1758 1759
  args : (Tensor index, Tensor updates, Tensor out_grad)
  output : Tensor(x_grad), Tensor(updates_grad)
  infer_meta :
    func : ScatterNdAddGradInferMeta
    param : [index, updates, out_grad]
  kernel :
1760
    func : scatter_nd_add_grad
H
hong 已提交
1761
  no_need_buffer : updates
H
hong 已提交
1762

1763 1764 1765 1766
- backward_api : segment_pool_grad
  forward : segment_pool (Tensor x, Tensor segment_ids, str pooltype) -> Tensor(out), Tensor(summed_ids)
  args : (Tensor x, Tensor segment_ids, Tensor out, Tensor summed_ids, Tensor out_grad, str pooltype)
  output : Tensor(x_grad)
H
hong 已提交
1767
  infer_meta :
1768 1769
    func : UnchangedInferMeta
    param : [x]
H
hong 已提交
1770
  kernel :
1771
    func : segment_pool_grad
1772
    data_type : x
H
hong 已提交
1773
  optional : summed_ids
H
hong 已提交
1774

1775 1776 1777 1778
- backward_api : selu_grad
  forward : selu (Tensor x, float scale, float alpha) -> Tensor(out)
  args : (Tensor out, Tensor out_grad, float scale, float alpha)
  output : Tensor(x_grad)
H
hong 已提交
1779
  infer_meta :
1780 1781
    func : UnchangedInferMeta
    param : [out]
H
hong 已提交
1782
  kernel :
1783
    func : selu_grad
H
hong 已提交
1784

1785 1786 1787 1788 1789 1790 1791 1792
- backward_api : sigmoid_cross_entropy_with_logits_grad
  forward : sigmoid_cross_entropy_with_logits (Tensor x, Tensor label, bool normalize, int ignore_index) -> Tensor(out)
  args : (Tensor x, Tensor label, Tensor out_grad, bool normalize, int ignore_index)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
1793
    func : sigmoid_cross_entropy_with_logits_grad
P
pangyoki 已提交
1794
  inplace : (out_grad -> x_grad)
H
hong 已提交
1795

1796 1797 1798 1799 1800 1801 1802 1803 1804 1805
- backward_api : sigmoid_double_grad
  forward : sigmoid_grad (Tensor out, Tensor fwd_grad_out) -> Tensor(grad_x)
  args : (Tensor out, Tensor fwd_grad_out, Tensor grad_x_grad)
  output : Tensor(out_grad), Tensor(fwd_grad_out_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [out, fwd_grad_out]
  kernel :
    func : sigmoid_double_grad
  backward : sigmoid_triple_grad
1806
  inplace : (grad_x_grad -> fwd_grad_out_grad)
1807

1808 1809 1810 1811 1812 1813 1814 1815 1816
- backward_api : sigmoid_grad
  forward : sigmoid (Tensor x) -> Tensor(out)
  args : (Tensor out, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [out]
  kernel :
    func : sigmoid_grad
1817
  backward : sigmoid_double_grad
P
pangyoki 已提交
1818
  inplace : (out_grad -> x_grad)
1819 1820 1821 1822 1823 1824 1825 1826 1827

- backward_api : sigmoid_triple_grad
  forward : sigmoid_double_grad (Tensor out, Tensor fwd_grad_out, Tensor grad_grad_x) -> Tensor(grad_out), Tensor(grad_grad_out)
  args : (Tensor out, Tensor fwd_grad_out, Tensor grad_grad_x, Tensor grad_out_grad, Tensor grad_grad_out_grad)
  output : Tensor(out_grad), Tensor(fwd_grad_out_grad), Tensor(grad_grad_x_grad)
  infer_meta :
    func : GeneralTernaryGradInferMeta
    param : [out, fwd_grad_out, grad_grad_x]
  kernel :
1828
    func : sigmoid_triple_grad
1829
  optional : grad_grad_out_grad
1830
  inplace : (grad_grad_x -> fwd_grad_out_grad)
H
hong 已提交
1831

1832 1833 1834
- backward_api : silu_grad
  forward : silu (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
H
hong 已提交
1835 1836 1837 1838 1839
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
1840
    func : silu_grad
P
pangyoki 已提交
1841
  inplace : (out_grad -> x_grad)
H
hong 已提交
1842

1843 1844 1845 1846
- backward_api : sin_grad
  forward : sin (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
H
hong 已提交
1847
  infer_meta :
1848 1849
    func : UnchangedInferMeta
    param : [x]
H
hong 已提交
1850
  kernel :
1851
    func : sin_grad
P
pangyoki 已提交
1852
  inplace : (out_grad -> x_grad)
H
hong 已提交
1853

1854 1855 1856 1857
- backward_api : sinh_grad
  forward : sinh (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
H
hong 已提交
1858
  infer_meta :
1859 1860
    func : UnchangedInferMeta
    param : [x]
H
hong 已提交
1861
  kernel :
1862
    func : sinh_grad
P
pangyoki 已提交
1863
  inplace : (out_grad -> x_grad)
H
hong 已提交
1864

H
hong 已提交
1865 1866 1867 1868 1869 1870 1871 1872 1873
- backward_api : slice_grad
  forward : slice (Tensor input, int64_t[] axes, IntArray starts, IntArray ends, int64_t[] infer_flags, int64_t[] decrease_axis) -> Tensor(out)
  args : (Tensor input, Tensor out_grad, int64_t[] axes, IntArray starts, IntArray ends, int64_t[] infer_flags, int64_t[] decrease_axis)
  output : Tensor(input_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [input]
  kernel :
    func : slice_grad
H
hong 已提交
1874
  no_need_buffer : input
H
hong 已提交
1875

1876 1877 1878 1879
- backward_api : soft_shrink_grad
  forward : soft_shrink (Tensor x, float lambda) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, float lambda)
  output : Tensor(x_grad)
H
hong 已提交
1880 1881
  infer_meta :
    func : UnchangedInferMeta
1882
    param : [x]
H
hong 已提交
1883
  kernel :
1884
    func : soft_shrink_grad
P
pangyoki 已提交
1885
  inplace : (out_grad -> x_grad)
H
hong 已提交
1886

1887 1888 1889 1890 1891 1892 1893 1894 1895
- backward_api : softmax_grad
  forward : softmax (Tensor x, int axis) -> Tensor(out)
  args : (Tensor out, Tensor out_grad, int axis)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [out]
  kernel :
    func : softmax_grad
1896
    use_gpudnn : true
H
hong 已提交
1897

1898
- backward_api : split_grad
1899
  forward : split (Tensor x, IntArray num_or_sections, Scalar axis) -> Tensor[](out)
H
hong 已提交
1900
  args : (Tensor[] out_grad, Scalar axis = -1)
1901 1902 1903
  output : Tensor(x_grad)
  invoke : concat( out_grad, axis)
# TODO(zhangyunfei) The config of double grad and triple grad will be supported in the future.
H
hong 已提交
1904

1905 1906 1907 1908 1909 1910 1911 1912 1913
- backward_api : sqrt_double_grad
  forward : sqrt_grad (Tensor out, Tensor grad_out) -> Tensor(grad_x)
  args : (Tensor out, Tensor grad_x, Tensor grad_x_grad)
  output : Tensor(out_grad), Tensor(grad_out_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [out, out]
  kernel :
    func : sqrt_double_grad
1914
  inplace : (grad_x_grad -> grad_out_grad)
1915

1916 1917 1918 1919 1920 1921 1922 1923 1924
- backward_api : sqrt_grad
  forward : sqrt (Tensor x) -> Tensor(out)
  args : (Tensor out, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [out]
  kernel :
    func : sqrt_grad
1925
  backward : sqrt_double_grad
P
pangyoki 已提交
1926
  inplace : (out_grad -> x_grad)
1927 1928 1929 1930 1931 1932 1933 1934 1935 1936

- backward_api : square_double_grad
  forward : square_grad (Tensor x, Tensor grad_out) -> Tensor(grad_x)
  args : (Tensor x, Tensor grad_out, Tensor grad_x_grad)
  output : Tensor(x_grad), Tensor(grad_out_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, x]
  kernel :
    func : square_double_grad
1937
  inplace : (grad_x_grad -> grad_out_grad)
1938 1939 1940 1941 1942 1943 1944 1945 1946 1947

- backward_api : square_grad
  forward : square (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : square_grad
1948
  backward : square_double_grad
P
pangyoki 已提交
1949
  inplace : (out_grad -> x_grad)
1950

1951 1952 1953 1954 1955 1956
- backward_api : squeeze_double_grad
  forward : squeeze_grad(Tensor xshape, Tensor grad_out, int[] axes) -> Tensor(grad_x)
  args : (Tensor grad_x_grad, int[] axes)
  output : Tensor(grad_out_grad)
  invoke: squeeze(grad_x_grad, axes)

1957
- backward_api : squeeze_grad
1958
  forward : squeeze(Tensor x, int[] axes) -> Tensor(out), Tensor(xshape)
1959 1960 1961 1962 1963 1964 1965
  args : (Tensor xshape, Tensor out_grad, int[] axes)
  output : Tensor(x_grad)
  infer_meta :
    func : KernelWithXShapeInferMeta
    param: [xshape]
  kernel :
    func : squeeze_grad
1966
  inplace : (out_grad -> x_grad)
1967
  backward: squeeze_double_grad
1968

1969 1970 1971
- backward_api : stack_grad
  forward : stack (Tensor[] x, int axis) -> Tensor(out)
  args : (Tensor[] x, Tensor out_grad, int axis)
1972 1973 1974 1975 1976 1977 1978
  output : Tensor[](x_grad){x.size()}
  infer_meta :
    func : StackGradInferMeta
    param: [out_grad, axis]
  kernel :
    func : stack_grad
    param : [out_grad, axis]
1979 1980
  no_need_buffer : x

1981 1982 1983 1984 1985 1986 1987 1988 1989
- backward_api : strided_slice_grad
  forward : strided_slice (Tensor x, int[] axes, IntArray starts, IntArray ends, IntArray strides) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, int[] axes, IntArray starts, IntArray ends, IntArray strides)
  output : Tensor(x_grad)
  infer_meta :
    func : GeneralUnaryGradInferMeta
    param : [x]
  kernel :
    func : strided_slice_grad
H
hong 已提交
1990
  no_need_buffer : x
1991

1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002
- backward_api : subtract_double_grad
  forward : subtract_grad (Tensor x, Tensor y, Tensor grad_out, int axis = -1) -> Tensor(grad_x), Tensor(grad_y)
  args : (Tensor y, Tensor grad_out, Tensor grad_x_grad, Tensor grad_y_grad, int axis = -1)
  output : Tensor(grad_out_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [grad_out]
  kernel :
    func : subtract_double_grad
  optional : grad_x_grad, grad_y_grad
  no_need_buffer : y, grad_out
2003
  inplace : (grad_x_grad -> grad_out_grad)
2004

2005 2006 2007 2008 2009 2010 2011 2012 2013
- backward_api : subtract_grad
  forward : subtract (Tensor x, Tensor y) -> Tensor(out)
  args : (Tensor x, Tensor y, Tensor out_grad, int axis = -1)
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, y]
  kernel :
    func : subtract_grad
H
hong 已提交
2014
  no_need_buffer : x, y
2015
  backward : subtract_double_grad
2016
  inplace : (out_grad -> x_grad)
H
hong 已提交
2017

2018 2019 2020 2021 2022 2023 2024
- backward_api : sum_double_grad
  forward : sum_grad (Tensor x, Tensor grad_out, int64_t[] dims, bool keep_dim, bool reduce_all=false) -> Tensor(grad_x)
  args : (Tensor grad_x_grad, int64_t[] dims={}, bool keep_dim=false)
  output : Tensor(grad_out_grad)
  invoke : sum(grad_x_grad, dims, grad_x_grad.dtype(), keep_dim)
  backward : sum_triple_grad

F
From00 已提交
2025
- backward_api : sum_grad
2026
  forward : sum (Tensor x, int64_t[] dims={}, DataType out_dtype=DataType::UNDEFINED, bool keep_dim=false) -> Tensor(out)
F
From00 已提交
2027 2028 2029 2030 2031 2032 2033
  args : (Tensor x, Tensor out_grad, int64_t[] dims, bool keep_dim, bool reduce_all=false)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : sum_grad
W
wanghuancoder 已提交
2034
  no_need_buffer : x
2035 2036 2037 2038 2039 2040
  backward : sum_double_grad

- backward_api : sum_triple_grad
  forward : sum_double_grad (Tensor grad_grad_x, int64_t[] dims={}, bool keep_dim=false) -> Tensor(grad_grad_out)
  args : (Tensor grad_grad_x, Tensor grad_grad_out_grad, int64_t[] dims={}, bool keep_dim=false, bool reduce_all=false)
  output : Tensor(grad_grad_x_grad)
2041
  invoke : sum_grad(grad_grad_x, grad_grad_out_grad, dims, keep_dim, reduce_all, grad_grad_x_grad)
F
From00 已提交
2042

2043 2044 2045 2046 2047 2048 2049 2050 2051
- backward_api : swish_grad
  forward : swish (Tensor x, float beta=1.0) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, float bete=1.0)
  output : Tensor(x_grad)
  infer_meta :
    func : GeneralUnaryGradInferMeta
    param : [x]
  kernel :
    func : swish_grad
P
pangyoki 已提交
2052
  inplace : (out_grad -> x_grad)
2053

2054 2055 2056 2057 2058 2059 2060 2061 2062
- backward_api : take_along_axis_grad
  forward : take_along_axis (Tensor x, Tensor index, int axis) -> Tensor(out)
  args : (Tensor x, Tensor index, Tensor out_grad, int axis)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : take_along_axis_grad
H
hong 已提交
2063

2064 2065 2066
- backward_api : tan_grad
  forward : tan (Tensor x) -> Tensor(out)
  args : (Tensor x, Tensor out_grad)
H
hong 已提交
2067 2068 2069 2070 2071
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
2072
    func : tan_grad
P
pangyoki 已提交
2073
  inplace : (out_grad -> x_grad)
H
hong 已提交
2074

2075 2076 2077 2078 2079 2080 2081 2082 2083 2084
- backward_api : tanh_double_grad
  forward : tanh_grad (Tensor out, Tensor grad_out) -> Tensor(grad_x)
  args : (Tensor out, Tensor grad_out, Tensor grad_x_grad)
  output : Tensor(out_grad), Tensor(grad_out_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [out, out]
  kernel :
    func : tanh_double_grad
  backward : tanh_triple_grad
2085
  inplace : (grad_x_grad -> grad_out_grad)
2086

2087 2088 2089 2090
- backward_api : tanh_grad
  forward : tanh (Tensor x) -> Tensor(out)
  args : (Tensor out, Tensor out_grad)
  output : Tensor(x_grad)
H
hong 已提交
2091
  infer_meta :
2092 2093
    func : UnchangedInferMeta
    param : [out]
H
hong 已提交
2094
  kernel :
2095
    func : tanh_grad
2096
  backward : tanh_double_grad
P
pangyoki 已提交
2097
  inplace : (out_grad -> x_grad)
H
hong 已提交
2098

2099 2100
- backward_api : tanh_shrink_grad
  forward : tanh_shrink (Tensor x) -> Tensor(out)
Z
zhangbo9674 已提交
2101 2102 2103 2104 2105 2106
  args : (Tensor x, Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
2107
    func : tanh_shrink_grad
P
pangyoki 已提交
2108
  inplace : (out_grad -> x_grad)
H
hong 已提交
2109

2110 2111 2112 2113 2114 2115 2116 2117 2118
- backward_api : tanh_triple_grad
  forward : tanh_double_grad (Tensor out, Tensor grad_out_forward, Tensor grad_x_grad_forward) -> Tensor(grad_out_new), Tensor(grad_out_grad)
  args : (Tensor out, Tensor grad_out_forward, Tensor grad_x_grad_forward, Tensor grad_out_new_grad, Tensor grad_out_grad_grad)
  output : Tensor(out_grad), Tensor(grad_out_forward_grad), Tensor(grad_x_grad_forward_grad)
  infer_meta :
    func : GeneralTernaryGradInferMeta
    param : [out, out, grad_x_grad_forward]
  kernel :
    func : tanh_triple_grad
2119
  inplace : (grad_x_grad_forward -> grad_out_forward_grad)
2120

2121 2122 2123 2124 2125 2126 2127 2128 2129
- backward_api : thresholded_relu_grad
  forward : thresholded_relu (Tensor x, float threshold) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, float threshold)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : thresholded_relu_grad
P
pangyoki 已提交
2130
  inplace : (out_grad -> x_grad)
H
hong 已提交
2131

2132 2133 2134 2135 2136 2137 2138 2139 2140
- backward_api : tile_double_grad
  forward : tile_grad (Tensor x, Tensor grad_out, IntArray repeat_times) -> Tensor(grad_x)
  args : (Tensor grad_x_grad, IntArray repeat_times)
  output : Tensor(grad_out_grad)
  infer_meta :
    func : TileInferMeta
  kernel :
    func : tile

2141
- backward_api : tile_grad
2142 2143
  forward : tile (Tensor x, IntArray repeat_times) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, IntArray repeat_times)
2144 2145 2146 2147 2148 2149
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : tile_grad
H
hong 已提交
2150
  no_need_buffer : x
2151
  backward : tile_double_grad
H
hong 已提交
2152

2153 2154 2155 2156 2157 2158 2159 2160 2161 2162
- backward_api : top_k_grad
  forward : top_k (Tensor x, Scalar k, int axis = -1, bool largest = true, bool sorted = true) -> Tensor(out), Tensor(indices)
  args : (Tensor x, Tensor indices, Tensor out_grad, Scalar k = -1, int axis = -1, bool largest = true, bool sorted = true)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : top_k_grad

2163 2164 2165 2166 2167 2168 2169 2170 2171
- backward_api : trace_grad
  forward : trace (Tensor x, int offset, int axis1, int axis2) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, int offset, int axis1, int axis2)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : trace_grad
H
hong 已提交
2172
  no_need_buffer : x
H
hong 已提交
2173

2174 2175 2176 2177 2178 2179
- backward_api : transpose_double_grad
  forward : transpose_grad (Tensor grad_out, int[] axis) -> Tensor(grad_x)
  args : (Tensor grad_x_grad, int[] axis)
  output : Tensor(grad_out_grad)
  invoke : transpose(grad_x_grad, axis)

2180 2181 2182 2183 2184 2185 2186 2187 2188
- backward_api : transpose_grad
  forward : transpose (Tensor x, int[] axis) -> Tensor(out)
  args : (Tensor out_grad, int[] axis)
  output : Tensor(x_grad)
  infer_meta :
    func : TransposeGradInferMeta
    param : [out_grad, axis]
  kernel :
    func : transpose_grad
2189
  backward : transpose_double_grad
H
hong 已提交
2190

H
hong 已提交
2191 2192 2193 2194 2195 2196 2197 2198 2199 2200
- backward_api : triangular_solve_grad
  forward : triangular_solve (Tensor x, Tensor y, bool upper, bool tranpose, bool unitriangular) -> Tensor(out)
  args : (Tensor x, Tensor y, Tensor out, Tensor out_grad, bool upper, bool tranpose, bool unitriangular)
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, y]
  kernel :
    func : triangular_solve_grad

F
From00 已提交
2201 2202 2203 2204 2205 2206 2207 2208 2209 2210
- backward_api : tril_triu_grad
  forward : tril_triu(Tensor x,  int diagonal,  bool lower) -> Tensor(out)
  args : (Tensor out_grad,  int diagonal,  bool lower)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [out_grad]
  kernel :
    func : tril_triu_grad

2211 2212 2213 2214 2215 2216 2217 2218 2219
- backward_api : trunc_grad
  forward : trunc (Tensor x) -> Tensor(out)
  args : (Tensor out_grad)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [out_grad]
  kernel :
    func : trunc_grad
H
hong 已提交
2220

2221 2222 2223 2224 2225 2226
- backward_api : unbind_grad
  forward : unbind (Tensor input, int axis) -> Tensor[](out)
  args : (Tensor[] out_grad, int axis)
  output : Tensor(input_grad)
  invoke : stack(out_grad, axis)

2227 2228 2229 2230 2231 2232 2233 2234 2235
- backward_api : unfold_grad
  forward : unfold (Tensor x, int[] kernel_sizes, int[] strides, int[] paddings, int[] dilations) -> Tensor(out)
  args : (Tensor x, Tensor out_grad, int[] kernel_sizes, int[] strides, int[] paddings, int[] dilations)
  output : Tensor(x_grad)
  infer_meta :
    func : UnchangedInferMeta
    param : [x]
  kernel :
    func : unfold_grad
H
hong 已提交
2236
  no_need_buffer : x
H
hong 已提交
2237

2238 2239 2240 2241 2242 2243
- backward_api : unsqueeze_double_grad
  forward : unsqueeze_grad(Tensor xshape, Tensor grad_out, IntArray axes) -> Tensor(grad_x)
  args : (Tensor grad_x_grad, IntArray axes)
  output : Tensor(grad_out_grad)
  invoke : unsqueeze(grad_x_grad, axes)

2244
- backward_api : unsqueeze_grad
2245
  forward : unsqueeze(Tensor x, IntArray axes) -> Tensor(out), Tensor(xshape)
2246
  args : (Tensor xshape, Tensor out_grad, IntArray axes)
2247 2248 2249 2250 2251 2252
  output : Tensor(x_grad)
  infer_meta :
    func : KernelWithXShapeInferMeta
    param: [xshape]
  kernel :
    func : unsqueeze_grad
2253
    param: [xshape, out_grad]
2254
  inplace : (out_grad -> x_grad)
2255
  backward : unsqueeze_double_grad
2256

2257 2258 2259 2260 2261 2262 2263 2264 2265
- backward_api : where_grad
  forward : where (Tensor condition, Tensor x, Tensor y) -> Tensor(out)
  args : (Tensor condition, Tensor x, Tensor y, Tensor out_grad)
  output : Tensor(x_grad), Tensor(y_grad)
  infer_meta :
    func : GeneralBinaryGradInferMeta
    param : [x, y]
  kernel :
    func : where_grad
H
hong 已提交
2266
  no_need_buffer : x, y