Lines Matching full:tensor
34 TORCH_API Tensor toNonOptFwGrad(const std::optional<Tensor>& t);
35 TORCH_API Tensor toNonOptPrimal(const std::optional<Tensor>& t);
36 TORCH_API Tensor toNonOptTensor(const std::optional<Tensor>& t);
38 TORCH_API inline std::optional<Tensor> wrap_opt_if( in wrap_opt_if()
39 const Tensor& t, in wrap_opt_if()
41 using OptTensor = std::optional<Tensor>; in wrap_opt_if()
45 TORCH_API Tensor
46 apply_loss_reduction(const Tensor& unreduced, int64_t reduction);
51 const at::Tensor& t);
55 at::ArrayRef<at::Tensor> t);
56 TORCH_API at::Tensor copysign_tensor_self_backward(
57 const Tensor& grad,
58 const Tensor& self,
59 const Tensor& result);
60 TORCH_API at::Tensor not_implemented(const char* name, const char* reason = "");
61 TORCH_API std::vector<Tensor> not_implemented_list(
64 at::Tensor handle_r_to_c(ScalarType self_st, Tensor gradient_result);
65 at::Tensor maybe_multiply(const at::Tensor& t, const at::Scalar& s);
67 Tensor restore_reduced_dims(
68 const Tensor& output,
71 Tensor scale_grad_by_count(
72 const Tensor& grad,
73 const Tensor& mask,
75 at::Tensor norm_backward(
76 const at::Tensor& grad,
77 const at::Tensor& self,
79 const at::Tensor& norm);
80 at::Tensor norm_backward(
81 at::Tensor grad,
82 const at::Tensor& self,
84 at::Tensor norm,
87 Tensor norm_jvp(
88 const Tensor& self_p,
89 const Tensor& self_t,
91 Tensor norm,
94 Tensor norm_jvp(
95 const Tensor& grad,
96 const Tensor& self,
98 Tensor norm);
99 Tensor _nested_from_padded_backward(
100 const Tensor& grad,
101 const Tensor& input,
103 std::tuple<Tensor, Tensor, Tensor> linear_double_backward(
105 const Tensor& self,
106 const Tensor& grad_output,
107 const Tensor& weight);
108 Tensor linalg_vector_norm_jvp(
109 const Tensor& self_p,
110 const Tensor& self_t,
112 Tensor norm,
115 at::Tensor linalg_vector_norm_backward(
116 at::Tensor grad,
117 const at::Tensor& self,
119 at::Tensor norm,
122 at::Tensor pow_backward(
123 at::Tensor grad,
124 const at::Tensor& self,
126 at::Tensor pow_backward_self(
127 const at::Tensor& grad,
128 const at::Tensor& self,
129 const at::Tensor& exponent);
130 at::Tensor pow_backward_exponent(
131 const at::Tensor& grad,
132 const at::Tensor& self,
133 const at::Tensor& exponent,
134 const at::Tensor& result);
135 at::Tensor pow_backward_exponent(
136 const at::Tensor& grad,
138 const at::Tensor& exponent,
139 const at::Tensor& result);
140 at::Tensor angle_backward(const at::Tensor& grad, const at::Tensor& self);
142 at::Tensor mul_tensor_backward(const Tensor& grad, T other, ScalarType self_st);
144 at::Tensor div_tensor_self_backward(
145 const Tensor& grad,
148 at::Tensor div_tensor_other_backward(
149 const Tensor& grad,
150 const Tensor& self,
151 const Tensor& other);
153 at::Tensor div_tensor_self_backward(
154 const Tensor& grad,
158 at::Tensor div_tensor_other_backward(
159 const Tensor& grad,
160 const Tensor& self,
161 const Tensor& other,
163 at::Tensor mvlgamma_backward(
164 const at::Tensor& grad,
165 const at::Tensor& self,
167 at::Tensor permute_backwards(const at::Tensor& grad, at::IntArrayRef fwd_dims);
168 at::Tensor rad2deg_backward(const at::Tensor& grad);
169 at::Tensor deg2rad_backward(const at::Tensor& grad);
170 at::Tensor unsqueeze_multiple(
171 const at::Tensor& t,
174 at::Tensor sum_backward(
175 const at::Tensor& grad,
179 at::Tensor sum_backward(
180 const at::Tensor& grad,
184 at::Tensor nansum_backward(
185 const at::Tensor& grad,
186 const at::Tensor& self,
191 at::Tensor reverse_dim(const at::Tensor& t, int64_t dim);
192 at::Tensor prod_safe_zeros_backward(
193 const at::Tensor& grad,
194 const at::Tensor& inp,
196 at::Tensor prod_backward(
197 const at::Tensor& grad,
198 const at::Tensor& input,
199 const at::Tensor& result);
200 at::Tensor prod_backward(
201 at::Tensor grad,
202 const at::Tensor& input,
203 at::Tensor result,
206 at::Tensor solve_jvp(
207 const Tensor& X,
208 const Tensor& A,
209 const Tensor& dA,
210 const Tensor& dB);
211 at::Tensor solve_backward_self(
212 const at::Tensor& grad,
213 const at::Tensor& self,
214 const at::Tensor& A);
215 at::Tensor solve_backward_A(
216 const at::Tensor& grad,
217 const at::Tensor& self,
218 const at::Tensor& A,
219 const at::Tensor& solution);
220 at::Tensor cumsum_backward(const at::Tensor& grad, int64_t dim);
221 at::Tensor logsumexp_backward(
222 at::Tensor grad,
223 const at::Tensor& self,
224 at::Tensor result,
227 at::Tensor logsumexp_jvp(
228 const at::Tensor& self_p,
229 const at::Tensor& self_t,
232 at::Tensor safe_logsumexp_jvp(
233 const at::Tensor& self_p,
234 const at::Tensor& self_t,
237 at::Tensor logcumsumexp_backward(
238 at::Tensor grad,
239 const at::Tensor& self,
240 const at::Tensor& result,
242 at::Tensor logcumsumexp_jvp(
243 const at::Tensor& self_p,
244 const at::Tensor& self_t,
246 at::Tensor unbind_backward(const variable_list& grads, int64_t dim);
247 at::Tensor unbind_backward_nested(
249 const Tensor& nt_sizes,
252 at::Tensor unbind_backward_nested_jagged(
254 const Tensor& self,
256 at::Tensor unsqueeze_to(const at::Tensor& self, c10::SymIntArrayRef sym_sizes);
257 at::Tensor unsqueeze_to(
258 const at::Tensor& self,
261 at::Tensor unsqueeze_to(
262 const at::Tensor& self,
265 std::vector<at::Tensor> cat_tensors_backward(
266 const at::Tensor& grad,
270 std::vector<at::Tensor> stack_tensors_backward(
271 const at::Tensor& grad,
274 std::vector<at::Tensor> block_diag_backward(
275 const at::Tensor& grad,
278 at::Tensor clamp_backward(
279 const at::Tensor& grad,
280 const at::Tensor& self,
283 at::Tensor clamp_backward(
284 const at::Tensor& grad,
285 const at::Tensor& self,
286 const at::Tensor& min,
287 const at::Tensor& max);
288 std::tuple<at::Tensor, at::Tensor> clamp_backward_min_max(
289 const at::Tensor& grad,
290 const at::Tensor& self,
291 const at::Tensor& min,
292 const at::Tensor& max,
294 at::Tensor clamp_jvp(
295 const Tensor& self_p,
296 const Tensor& self_t,
297 const Tensor& min_p,
298 const Tensor& min_t,
299 const Tensor& max_p,
300 const Tensor& max_t);
302 const Tensor& input,
304 at::Tensor mm_mat1_backward(
305 const Tensor& grad,
306 const Tensor& mat2,
311 at::Tensor mm_mat2_backward(
312 const at::Tensor& grad,
313 const at::Tensor& mat1,
318 at::Tensor mm_mat1_sparse_backward(
319 const at::Tensor& grad,
320 const at::Tensor& mat1,
321 const at::Tensor& mat2,
323 std::tuple<Tensor, Tensor, Tensor> sparse_sampled_addmm_backward(
324 const Tensor& grad,
325 const Tensor& self,
326 const std::optional<Tensor>& mat1,
327 const std::optional<Tensor>& mat2,
331 at::Tensor sparse_mask_backward(
332 const at::Tensor& grad,
333 const at::Tensor& mask,
335 at::Tensor sparse_sparse_matmul_backward(
336 const at::Tensor& grad,
337 const at::Tensor& mat1,
338 const at::Tensor& mat2,
340 at::Tensor renorm_backward(
341 const at::Tensor& grad,
342 const at::Tensor& self,
346 at::Tensor renorm_jvp(
347 const at::Tensor& self_p,
348 const at::Tensor& self_t,
352 at::Tensor repeat_backward(
353 at::Tensor grad,
356 at::Tensor _fused_dropout_backward(
357 const at::Tensor& grad,
358 const at::Tensor& mask,
360 at::Tensor infinitely_differentiable_native_dropout_backward(
361 const at::Tensor& grad,
362 const at::Tensor& mask,
364 at::Tensor native_dropout_double_backward(
365 const at::Tensor& ggI,
366 const at::Tensor& grad,
367 const at::Tensor& mask,
369 at::Tensor evenly_distribute_backward(
370 const at::Tensor& grad,
371 const at::Tensor& input,
372 const at::Tensor& value);
373 Tensor sgn_backward(const Tensor& x, const Tensor& gx, const Tensor& sgn);
374 Tensor masked_fill_backward(const Tensor& grad, const Tensor& mask);
375 at::Tensor var_backward(
376 at::Tensor grad,
377 const at::Tensor& self,
381 at::Tensor var_jvp(
382 const at::Tensor& self_t,
383 const at::Tensor& self_p,
384 const at::Tensor& result,
388 at::Tensor std_backward(
389 const at::Tensor& result,
390 const at::Tensor& grad,
391 const at::Tensor& self,
395 Tensor mean_backward(
396 const Tensor& grad,
401 Tensor var_mean_backward(
402 const Tensor& gvar,
403 const Tensor& gmean,
404 const Tensor& self,
408 Tensor std_mean_backward(
409 const Tensor& gstd,
410 const Tensor& gmean,
411 const Tensor& self,
412 const Tensor& std,
416 at::Tensor cholesky_backward(
417 const at::Tensor& grad,
419 const at::Tensor& L);
420 at::Tensor cholesky_jvp(
421 const at::Tensor& input_tangent,
422 const at::Tensor& L,
424 at::Tensor cholesky_inverse_backward(
425 const at::Tensor& grad,
426 const at::Tensor& L,
428 const at::Tensor& inverse);
429 at::Tensor cholesky_inverse_jvp(
430 const at::Tensor& F,
431 const at::Tensor& dF,
432 const at::Tensor& X,
434 Tensor pinv_jvp(const Tensor& A, const Tensor& pinvA, const Tensor& dA);
435 Tensor pinv_backward(const Tensor& grad, const Tensor& pinvA, const Tensor& A);
436 Tensor chunk_backward_nested(
438 const Tensor& self,
441 at::Tensor split_with_sizes_backward(
447 at::Tensor _nested_split_with_sizes_backward(
451 const Tensor& nt_sizes,
453 at::Tensor split_backward(
459 at::Tensor max_pool_double_backward(
460 const at::Tensor& grad,
461 const at::Tensor& indices,
463 at::Tensor error_for_max_pool2d_double_backward();
464 at::Tensor glu_double_backward(
465 const at::Tensor& grad,
466 const at::Tensor& grad_output,
467 const at::Tensor& input,
469 at::Tensor glu_double_backward_grad_output(
470 const at::Tensor& grad,
471 const at::Tensor& input,
473 at::Tensor infinitely_differentiable_silu_backward(
474 const at::Tensor& grad_output,
475 const at::Tensor& input);
476 at::Tensor infinitely_differentiable_mish_backward(
477 const at::Tensor& grad_output,
478 const at::Tensor& input);
479 Tensor infinitely_differentiable_logit_backward(
480 const Tensor& grad,
481 const Tensor& self,
483 Tensor binary_cross_entropy_target_backward(
484 const Tensor& grad,
485 const Tensor& self,
486 const Tensor& target,
487 const std::optional<Tensor>& weight,
489 Tensor binary_cross_entropy_double_backward_target(
490 const Tensor& grad,
491 const Tensor& grad_output,
492 const Tensor& self,
493 const Tensor& target,
494 const std::optional<Tensor>& weight,
496 Tensor binary_cross_entropy_with_logits_backward(
497 const Tensor& grad,
498 const Tensor& input,
499 const Tensor& target,
500 const std::optional<Tensor>& weight_opt,
501 const std::optional<Tensor>& pos_weight_opt,
503 at::Tensor binary_cross_entropy_with_logits_target_backward(
504 const at::Tensor& grad_output,
505 const at::Tensor& self,
506 const at::Tensor& target,
507 const std::optional<at::Tensor>& weight,
508 const std::optional<at::Tensor>& pos_weight,
510 at::Tensor log_sigmoid_double_backward(
511 const at::Tensor& grad,
512 const at::Tensor& input);
513 at::Tensor softmax_double_backward(
514 const at::Tensor& grad,
515 const at::Tensor& grad_output,
517 const at::Tensor& output);
518 at::Tensor binary_cross_entropy_double_backward(
519 const at::Tensor& grad_output,
520 const at::Tensor& grad,
521 const at::Tensor& input,
522 const at::Tensor& target,
523 const std::optional<at::Tensor>& weight,
525 at::Tensor binary_cross_entropy_double_backward_grad_output(
526 const at::Tensor& grad,
527 const at::Tensor& input,
528 const at::Tensor& target,
529 const std::optional<at::Tensor>& weight,
531 at::Tensor smooth_l1_loss_double_backward(
532 const at::Tensor& grad,
533 const at::Tensor& input,
534 const at::Tensor& target,
537 at::Tensor huber_loss_double_backward(
538 const at::Tensor& grad,
539 const at::Tensor& input,
540 const at::Tensor& target,
543 at::Tensor huber_loss_double_backward_grad_output(
544 const at::Tensor& grad,
545 const at::Tensor& grad_output,
546 const at::Tensor& input,
547 const at::Tensor& target,
550 at::Tensor mse_loss_double_backward(
551 const at::Tensor& grad,
552 const at::Tensor& input,
554 at::Tensor soft_margin_loss_double_backward(
555 const at::Tensor& grad,
556 const at::Tensor& input,
557 const at::Tensor& target,
559 at::Tensor soft_margin_loss_double_backward_grad_output(
560 const at::Tensor& grad,
561 const at::Tensor& grad_output,
562 const at::Tensor& input,
563 const at::Tensor& target,
565 at::Tensor softplus_double_backward(
566 const at::Tensor& grad,
567 const at::Tensor& input,
570 std::tuple<at::Tensor, at::Tensor> slogdet_jvp(
571 const at::Tensor& LU,
572 const at::Tensor& pivots,
573 const at::Tensor& dA,
574 const at::Tensor& sign,
576 at::Tensor slogdet_backward(
577 const at::Tensor& grad_sign,
578 const at::Tensor& grad_logabsdet,
579 const at::Tensor& A,
580 const at::Tensor& signdet,
581 const at::Tensor& LU,
582 const at::Tensor& pivots);
583 at::Tensor log1p_backward(const at::Tensor& grad, const at::Tensor& self);
584 at::Tensor sinc_backward(const at::Tensor& grad, const at::Tensor& self);
585 at::Tensor sparse_constructor_values_backward(
586 const at::Tensor& sparse_grad_out,
587 const at::Tensor& indices);
588 at::Tensor embedding_dense_double_backward_symint(
589 const at::Tensor& grad,
590 const at::Tensor& indices,
592 at::Tensor index_backward(
593 at::Tensor zeros_like_self,
594 const torch::List<std::optional<Tensor>>& indices,
595 const at::Tensor& grad);
596 at::Tensor _cudnn_ctc_loss_backward(
597 const at::Tensor& grad_out,
598 const at::Tensor& loss,
599 const at::Tensor& raw_grad,
601 at::Tensor elu_double_backward(
602 const Tensor& grad,
603 const Tensor& grad_output,
608 const Tensor& self_or_result);
610 Tensor svd_backward(
611 const Tensor& gU,
612 const Tensor& gS,
613 const Tensor& gVh,
614 const Tensor& U,
615 const Tensor& S,
616 const Tensor& Vh);
618 std::tuple<Tensor, Tensor, Tensor> linalg_svd_jvp(
619 const Tensor& dA,
620 const Tensor& U,
621 const Tensor& S,
622 const Tensor& Vh,
624 Tensor slice_backward_wrapper(
625 const at::Tensor& grad,
631 std::tuple<Tensor, Tensor> linalg_eig_jvp(
632 const Tensor& dA,
633 const Tensor& L,
634 const Tensor& V,
636 Tensor linalg_eig_backward(
637 const Tensor& gL,
638 const Tensor& gV,
639 const Tensor& L,
640 const Tensor& V,
643 Tensor linalg_lstsq_jvp(
644 const Tensor& A,
645 const Tensor& B,
646 const Tensor& dA,
647 const Tensor& dB);
648 std::tuple<Tensor, Tensor> triangular_solve_backward(
649 const Tensor& grad_x,
650 const Tensor& grad_m,
651 const Tensor& b,
652 const Tensor& a,
653 const Tensor& x,
658 Tensor triangular_solve_jvp(
659 const Tensor& X,
660 const Tensor& A,
661 const Tensor& dA,
662 const Tensor& dB,
666 Tensor linalg_solve_triangular_forward_AD(
667 const Tensor& A_t,
668 const Tensor& B_t,
669 const Tensor& A,
670 const Tensor& X,
674 std::tuple<Tensor, Tensor> linalg_solve_triangular_backward(
675 const Tensor& grad,
676 const Tensor& A,
677 const Tensor& X,
682 std::tuple<Tensor, Tensor, Tensor> _trilinear_backward(
683 const Tensor& grad_out,
684 const std::optional<Tensor>& i1,
685 const std::optional<Tensor>& i2,
686 const std::optional<Tensor>& i3,
692 std::tuple<Tensor, Tensor> linalg_qr_jvp(
693 const Tensor& dA,
694 const Tensor& Q,
695 const Tensor& R,
697 Tensor linalg_qr_backward(
698 const Tensor& gQ,
699 const Tensor& gR,
700 const Tensor& Q,
701 const Tensor& R,
703 Tensor linalg_matrix_exp_differential(
704 const Tensor& self,
705 const Tensor& grad,
707 std::tuple<Tensor, Tensor, Tensor> batchnorm_double_backward(
708 const Tensor& input,
709 const std::optional<Tensor>& gamma,
710 const Tensor& ggI,
711 const Tensor& ggG,
712 const Tensor& ggB,
713 const Tensor& gO,
714 const std::optional<Tensor>& running_mean,
715 const std::optional<Tensor>& running_var,
718 const std::optional<Tensor>& save_mean,
719 const std::optional<Tensor>& save_invstd,
721 std::tuple<Tensor, Tensor> _euclidean_dist_backward(
722 const Tensor& grad,
723 const Tensor& x1,
724 const Tensor& x2,
725 const Tensor& res);
726 Tensor fft_backward(
727 const Tensor& self,
728 const Tensor& grad,
737 Tensor fft_r2c_backward(
738 const Tensor& grad,
743 Tensor fft_c2r_backward(
744 const Tensor& grad,
747 Tensor constant_pad_nd_backward(const Tensor& grad, c10::SymIntArrayRef pad);
748 std::tuple<Tensor, Tensor> cholesky_solve_backward(
749 const Tensor& grad_x,
750 const Tensor& self,
751 const Tensor& input2,
752 const Tensor& result,
755 Tensor cholesky_solve_jvp(
756 const Tensor& X,
757 const Tensor& U,
758 const Tensor& dU,
759 const Tensor& dB,
761 std::tuple<Tensor, Tensor, Tensor>
763 const Tensor& dY,
764 const Tensor& dmean,
765 const Tensor& drstd,
766 const Tensor& X,
767 const Tensor& mean,
768 const Tensor& rstd,
769 const std::optional<Tensor>& gamma,
776 Tensor gelu_double_backward(
777 const Tensor& ggI,
778 const Tensor& gO,
779 const Tensor& input,
781 Tensor as_strided_backward(
782 Tensor grad,
787 Tensor as_strided_scatter_backward(
788 const Tensor& grad,
794 std::tuple<Tensor, Tensor> atan2_backward(
795 const Tensor& grad,
796 const Tensor& self,
797 const Tensor& other,
799 Tensor amaxamin_jvp(
800 const Tensor& x,
801 const Tensor& dx,
802 const Tensor& result,
805 std::tuple<Tensor, Tensor, Tensor> layer_norm_double_backward(
806 const Tensor& input,
807 const std::optional<Tensor>& gamma,
808 const Tensor& ggI,
809 const Tensor& ggG,
810 const Tensor& ggB,
811 const Tensor& gO,
812 const Tensor& save_mean,
813 const Tensor& save_invstd,
817 std::tuple<Tensor, Tensor> householder_product_backward(
818 const Tensor& grad,
819 const Tensor& result,
820 const Tensor& input,
821 const Tensor& tau,
823 Tensor householder_product_jvp(
824 const Tensor& dV,
825 const Tensor& dtau,
826 const Tensor& prod,
827 const Tensor& V,
828 const Tensor& tau);
829 std::tuple<Tensor, Tensor, Tensor> ormqr_backward(
830 const Tensor& grad,
831 const Tensor& result,
832 const Tensor& self,
833 const Tensor& tau,
834 const Tensor& other,
838 std::tuple<Tensor, Tensor> polar_backward(
839 const Tensor& grad,
840 const Tensor& result);
841 Tensor i1_backward(
842 const Tensor& grad,
843 const Tensor& self,
844 const Tensor& result);
845 Tensor i1e_backward(
846 const Tensor& grad,
847 const Tensor& self,
848 const Tensor& result);
849 Tensor linalg_lu_solve_LU(
850 const Tensor& grad,
851 const Tensor& LU,
852 const Tensor& pivots,
853 const Tensor& X,
856 Tensor linalg_lu_solve_jvp(
857 const Tensor& X,
858 const Tensor& LU,
859 const Tensor& pivots,
860 const Tensor& dLU,
861 const Tensor& dB,
864 std::tuple<Tensor, Tensor> linalg_solve_backward(
865 const Tensor& gX,
866 const Tensor& X,
867 const Tensor& A,
868 const Tensor& LU,
869 const Tensor& pivots,
872 Tensor linalg_solve_jvp(
873 const Tensor& dA,
874 const Tensor& dB,
875 const Tensor& X,
876 const Tensor& LU,
877 const Tensor& pivots,
880 Tensor lu_unpack_backward(
881 const Tensor& L_grad,
882 const Tensor& U_grad,
886 Tensor linalg_det_backward(
887 const Tensor& grad,
888 const Tensor& det,
889 const Tensor& A,
890 const Tensor& LU,
891 const Tensor& pivots);
892 Tensor linalg_det_jvp(
893 const Tensor& dA,
894 const Tensor& det,
895 const Tensor& LU,
896 const Tensor& pivots,
898 std::tuple<Tensor, Tensor> linalg_lstsq_backward(
899 const Tensor& grad,
900 const Tensor& A,
901 const Tensor& B_,
903 Tensor linalg_lu_backward(
904 const Tensor& L_grad,
905 const Tensor& U_grad,
906 const Tensor& P,
907 const Tensor& L,
908 const Tensor& U,
911 std::tuple<Tensor, Tensor> linalg_lu_jvp(
912 const Tensor& dA,
913 const Tensor& P,
914 const Tensor& L,
915 const Tensor& U,
918 Tensor lu_factor_ex_backward(
919 const Tensor& grad,
920 const Tensor& LU,
921 const Tensor& pivs,
923 Tensor lu_factor_ex_jvp(
924 const Tensor& dX,
925 const Tensor& LU,
926 const Tensor& pivs,
929 Tensor batch_norm_jvp(
930 const Tensor& input_p,
931 const Tensor& input_t,
932 const Tensor& weight_p,
933 const Tensor& weight_t,
934 const Tensor& bias_p,
935 const Tensor& bias_t,
936 const std::optional<Tensor>& running_mean,
937 const std::optional<Tensor>& running_var,
938 const Tensor& saved_mean,
939 const Tensor& saved_invstd,
943 Tensor layer_norm_jvp(
944 const Tensor& input_p,
945 const Tensor& input_t,
946 const Tensor& weight_p,
947 const Tensor& weight_t,
948 const Tensor& bias_p,
949 const Tensor& bias_t,
950 const Tensor& saved_mean,
951 const Tensor& saved_invstd,
954 Tensor group_norm_jvp(
955 const Tensor& input_p,
956 const Tensor& input_t,
957 const Tensor& weight_p,
958 const Tensor& weight_t,
959 const Tensor& bias_p,
960 const Tensor& bias_t,
961 const Tensor& saved_mean,
962 const Tensor& saved_invstd,
964 Tensor group_norm_mean_jvp(
965 const Tensor& input_t,
966 const Tensor& mean_p,
968 Tensor group_norm_invstd_jvp(
969 const Tensor& input_p,
970 const Tensor& input_t,
971 const Tensor& mean_p,
972 const Tensor& invstd_p,
975 Tensor convolution_jvp(
976 const Tensor& input_p,
977 const Tensor& input_t,
978 const Tensor& weight_p,
979 const Tensor& weight_t,
980 const Tensor& bias_p,
981 const Tensor& bias_t,
989 Tensor _convolution_jvp(
990 const Tensor& input_p,
991 const Tensor& input_t,
992 const Tensor& weight_p,
993 const Tensor& weight_t,
994 const Tensor& bias_p,
995 const Tensor& bias_t,
1007 Tensor convolution_backward_jvp_grad_bias(
1008 const Tensor& grad_out_t,
1009 const Tensor& grad_bias);
1011 Tensor cat_jvp(const at::ITensorListRef& tensors, int64_t dim);
1012 Tensor block_diag_jvp(at::TensorList tensors);
1013 Tensor stack_jvp(at::TensorList tensors, int64_t dim);
1014 Tensor cumprod_jvp(
1015 const Tensor& self_t,
1016 const Tensor& self_p,
1017 const Tensor& result,
1019 Tensor gather_with_keepdimed_indices(
1020 const Tensor& input,
1022 const Tensor& indices,
1024 Tensor evenly_read_jvp(
1025 const Tensor& fw_grad,
1026 const Tensor& input,
1027 const Tensor& value);
1028 Tensor warn_backwards(const Tensor& grad_output);
1030 std::tuple<Tensor, Tensor> _cudnn_convolution_backward(
1031 const at::Tensor& self,
1032 const at::Tensor& grad_output,
1033 const at::Tensor& weight,
1042 Tensor scatter_reduce_jvp(
1043 const Tensor& self_p,
1044 const Tensor& self_t,
1046 const Tensor& index,
1047 const Tensor& src_p,
1048 const Tensor& src_t,
1051 const Tensor& result);
1053 std::tuple<Tensor, Tensor> scatter_reduce_backward(
1054 const Tensor& grad,
1055 const Tensor& self,
1057 const Tensor& index,
1058 const Tensor& src,
1061 const Tensor& result);
1063 Tensor _to_copy_backward(
1064 const Tensor& grad,
1067 std::tuple<Tensor, Tensor> index_reduce_backward(
1068 const Tensor& grad,
1069 const Tensor& self,
1071 const Tensor& index,
1072 const Tensor& source,
1075 const Tensor& result);
1077 Tensor take_backward(
1078 const Tensor& grad,
1079 const Tensor& self,
1080 const Tensor& indices);
1082 Tensor to_sparse_backward(
1083 const Tensor& grad,
1087 std::tuple<Tensor, Tensor, Tensor, Tensor, Tensor, Tensor, Tensor>
1089 const Tensor& input,
1090 const Tensor& weight0,
1091 const Tensor& weight1,
1092 const Tensor& weight2,
1093 const Tensor& weight3,
1094 const Tensor& hx_,
1095 const Tensor& cx_tmp,
1096 const Tensor& output,
1097 const Tensor& hy_,
1098 const Tensor& cy_,
1099 const std::optional<Tensor>& grad_output_r_opt,
1100 const std::optional<Tensor>& grad_hy_r_opt,
1101 const std::optional<Tensor>& grad_cy_r_opt,
1111 const at::Tensor& workspace);
1113 Tensor values_backward(const Tensor& grad, const Tensor& self);