package torch

  1. Overview
  2. Docs
package torch
Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module Torch.TensorSource

include module type of Torch_core.Wrapper.Tensor with type t := t
include Torch_core.Wrapper_generated_intf.S with type t := t and type 'a scalar := 'a Torch_core.Wrapper.Scalar.t
Sourceval __and__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __and__1 : t -> t -> t
Sourceval __iand__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __iand__1 : t -> t -> t
Sourceval __ilshift__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __ilshift__1 : t -> t -> t
Sourceval __ior__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __ior__1 : t -> t -> t
Sourceval __irshift__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __irshift__1 : t -> t -> t
Sourceval __ixor__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __ixor__1 : t -> t -> t
Sourceval __lshift__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __lshift__1 : t -> t -> t
Sourceval __or__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __or__1 : t -> t -> t
Sourceval __rshift__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __rshift__1 : t -> t -> t
Sourceval __xor__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __xor__1 : t -> t -> t
Sourceval _adaptive_avg_pool2d : t -> output_size:int list -> t
Sourceval _adaptive_avg_pool2d_backward : grad_output:t -> t -> t
Sourceval _add_batch_dim : t -> batch_dim:int -> level:int -> t
Sourceval _add_relu : t -> t -> t
Sourceval _add_relu_ : t -> t -> t
Sourceval _add_relu_out : out:t -> t -> t -> t
Sourceval _addmv_impl_ : t -> self2:t -> mat:t -> vec:t -> t
Sourceval _aminmax : t -> t * t
Sourceval _aminmax1 : t -> dim:int -> keepdim:bool -> t * t
Sourceval _amp_update_scale : growth_tracker:t -> current_scale:t -> found_inf:t -> scale_growth_factor:float -> scale_backoff_factor:float -> growth_interval:int -> t
Sourceval _baddbmm_mkl_ : t -> batch1:t -> batch2:t -> t
Sourceval _bmm : t -> mat2:t -> deterministic:bool -> t
Sourceval _bmm_out : out:t -> t -> mat2:t -> deterministic:bool -> t
Sourceval _cast_byte : t -> non_blocking:bool -> t
Sourceval _cast_char : t -> non_blocking:bool -> t
Sourceval _cast_double : t -> non_blocking:bool -> t
Sourceval _cast_float : t -> non_blocking:bool -> t
Sourceval _cast_half : t -> non_blocking:bool -> t
Sourceval _cast_int : t -> non_blocking:bool -> t
Sourceval _cast_long : t -> non_blocking:bool -> t
Sourceval _cast_short : t -> non_blocking:bool -> t
Sourceval _cat : t list -> dim:int -> t
Sourceval _cat_out : out:t -> t list -> dim:int -> t
Sourceval _cdist_backward : grad:t -> x1:t -> x2:t -> p:float -> cdist:t -> t
Sourceval _cholesky_helper : t -> upper:bool -> t
Sourceval _cholesky_solve_helper : t -> a:t -> upper:bool -> t
Sourceval _coalesced_ : t -> coalesced:bool -> t
Sourceval _compute_linear_combination : t -> coefficients:t -> t
Sourceval _compute_linear_combination_out : out:t -> t -> coefficients:t -> t
Sourceval _conj : t -> t
Sourceval _convolution : t -> weight:t -> bias:t option -> stride:int list -> padding:int list -> dilation:int list -> transposed:bool -> output_padding:int list -> groups:int -> benchmark:bool -> deterministic:bool -> cudnn_enabled:bool -> t
Sourceval _convolution1 : t -> weight:t -> bias:t option -> stride:int list -> padding:int list -> dilation:int list -> transposed:bool -> output_padding:int list -> groups:int -> benchmark:bool -> deterministic:bool -> cudnn_enabled:bool -> allow_tf32:bool -> t
Sourceval _convolution_nogroup : t -> weight:t -> bias:t option -> stride:int list -> padding:int list -> dilation:int list -> transposed:bool -> output_padding:int list -> t
Sourceval _copy_from : t -> dst:t -> non_blocking:bool -> t
Sourceval _ctc_loss : log_probs:t -> targets:t -> input_lengths:int list -> target_lengths:int list -> blank:int -> zero_infinity:bool -> t * t
Sourceval _ctc_loss_backward : grad:t -> log_probs:t -> targets:t -> input_lengths:int list -> target_lengths:int list -> neg_log_likelihood:t -> log_alpha:t -> blank:int -> zero_infinity:bool -> t
Sourceval _cudnn_ctc_loss : log_probs:t -> targets:t -> input_lengths:int list -> target_lengths:int list -> blank:int -> deterministic:bool -> zero_infinity:bool -> t * t
Sourceval _cudnn_init_dropout_state : dropout:float -> train:bool -> dropout_seed:int -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval _cudnn_rnn : t -> weight:t list -> weight_stride0:int -> weight_buf:t option -> hx:t -> cx:t option -> mode:int -> hidden_size:int -> num_layers:int -> batch_first:bool -> dropout:float -> train:bool -> bidirectional:bool -> batch_sizes:int list -> dropout_state:t option -> t * t * t * t * t
Sourceval _cudnn_rnn_flatten_weight : weight_arr:t list -> weight_stride0:int -> input_size:int -> mode:int -> hidden_size:int -> num_layers:int -> batch_first:bool -> bidirectional:bool -> t
Sourceval _cumprod : t -> dim:int -> t
Sourceval _cumprod_out : out:t -> t -> dim:int -> t
Sourceval _cumsum : t -> dim:int -> t
Sourceval _cumsum_out : out:t -> t -> dim:int -> t
Sourceval _dim_arange : like:t -> dim:int -> t
Sourceval _dirichlet_grad : x:t -> alpha:t -> total:t -> t
Sourceval _embedding_bag : weight:t -> indices:t -> offsets:t -> scale_grad_by_freq:bool -> mode:int -> sparse:bool -> per_sample_weights:t option -> include_last_offset:bool -> t * t * t * t
Sourceval _embedding_bag_backward : grad:t -> indices:t -> offsets:t -> offset2bag:t -> bag_size:t -> maximum_indices:t -> num_weights:int -> scale_grad_by_freq:bool -> mode:int -> sparse:bool -> per_sample_weights:t option -> t
Sourceval _embedding_bag_dense_backward : grad:t -> indices:t -> offsets:t -> offset2bag:t -> bag_size:t -> maximum_indices:t -> num_weights:int -> scale_grad_by_freq:bool -> mode:int -> per_sample_weights:t option -> t
Sourceval _embedding_bag_forward_only : weight:t -> indices:t -> offsets:t -> scale_grad_by_freq:bool -> mode:int -> sparse:bool -> per_sample_weights:t option -> include_last_offset:bool -> t * t * t * t
Sourceval _embedding_bag_per_sample_weights_backward : grad:t -> weight:t -> indices:t -> offsets:t -> offset2bag:t -> mode:int -> t
Sourceval _embedding_bag_sparse_backward : grad:t -> indices:t -> offsets:t -> offset2bag:t -> bag_size:t -> num_weights:int -> scale_grad_by_freq:bool -> mode:int -> per_sample_weights:t option -> t
Sourceval _empty_affine_quantized : size:int list -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> scale:float -> zero_point:int -> t
Sourceval _empty_per_channel_affine_quantized : size:int list -> scales:t -> zero_points:t -> axis:int -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval _euclidean_dist : x1:t -> x2:t -> t
Sourceval _fake_quantize_learnable_per_channel_affine : t -> scale:t -> zero_point:t -> axis:int -> quant_min:int -> quant_max:int -> t
Sourceval _fake_quantize_learnable_per_channel_affine_backward : grad:t -> t -> scale:t -> zero_point:t -> axis:int -> quant_min:int -> quant_max:int -> t * t * t
Sourceval _fake_quantize_learnable_per_tensor_affine : t -> scale:t -> zero_point:t -> quant_min:int -> quant_max:int -> t
Sourceval _fake_quantize_learnable_per_tensor_affine_backward : grad:t -> t -> scale:t -> zero_point:t -> quant_min:int -> quant_max:int -> t * t * t
Sourceval _fft_with_size : t -> signal_ndim:int -> complex_input:bool -> complex_output:bool -> inverse:bool -> checked_signal_sizes:int list -> normalized:bool -> onesided:bool -> output_sizes:int list -> t
Sourceval _fft_with_size1 : t -> signal_ndim:int -> complex_input:bool -> complex_output:bool -> inverse:bool -> checked_signal_sizes:int list -> normalization:int -> onesided:bool -> output_sizes:int list -> t
Sourceval _fused_dropout : t -> p:float -> t * t
Sourceval _gather_sparse_backward : t -> dim:int -> index:t -> grad:t -> t
Sourceval _grid_sampler_2d_cpu_fallback : t -> grid:t -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> t
Sourceval _grid_sampler_2d_cpu_fallback_backward : grad_output:t -> t -> grid:t -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> t * t
Sourceval _index_copy_ : t -> dim:int -> index:t -> source:t -> t
Sourceval _index_put_impl_ : t -> indices:t list -> values:t -> accumulate:bool -> unsafe:bool -> t
Sourceval _indices : t -> t
Sourceval _inverse_helper : t -> t
Sourceval _log_softmax : t -> dim:int -> half_to_float:bool -> t
Sourceval _log_softmax_backward_data : grad_output:t -> output:t -> dim:int -> t -> t
Sourceval _logcumsumexp : t -> dim:int -> t
Sourceval _logcumsumexp_out : out:t -> t -> dim:int -> t
Sourceval _lu_solve_helper : t -> lu_data:t -> lu_pivots:t -> t
Sourceval _lu_with_info : t -> pivot:bool -> check_errors:bool -> t * t * t
Sourceval _make_per_channel_quantized_tensor : t -> scale:t -> zero_point:t -> axis:int -> t
Sourceval _make_per_tensor_quantized_tensor : t -> scale:float -> zero_point:int -> t
Sourceval _masked_scale : t -> mask:t -> scale:float -> t
Sourceval _mkldnn_reshape : t -> shape:int list -> t
Sourceval _mkldnn_transpose : t -> dim0:int -> dim1:int -> t
Sourceval _mkldnn_transpose_ : t -> dim0:int -> dim1:int -> t
Sourceval _mode : t -> dim:int -> keepdim:bool -> t * t
Sourceval _mode_out : values:t -> indices:t -> t -> dim:int -> keepdim:bool -> t * t
Sourceval _multinomial_alias_draw : j:t -> q:t -> num_samples:int -> t
Sourceval _multinomial_alias_setup : probs:t -> t * t
Sourceval _nnpack_spatial_convolution : t -> weight:t -> bias:t option -> padding:int list -> stride:int list -> t
Sourceval _nnpack_spatial_convolution_backward_input : t -> grad_output:t -> weight:t -> padding:int list -> t
Sourceval _nnpack_spatial_convolution_backward_weight : t -> weightsize:int list -> grad_output:t -> padding:int list -> t
Sourceval _pack_padded_sequence : t -> lengths:t -> batch_first:bool -> t * t
Sourceval _pack_padded_sequence_backward : grad:t -> input_size:int list -> batch_sizes:t -> batch_first:bool -> t
Sourceval _pad_packed_sequence : data:t -> batch_sizes:t -> batch_first:bool -> padding_value:'a Torch_core.Wrapper.Scalar.t -> total_length:int -> t * t
Sourceval _pdist_backward : grad:t -> t -> p:float -> pdist:t -> t
Sourceval _qr_helper : t -> some:bool -> t * t
Sourceval _remove_batch_dim : t -> level:int -> batch_size:int -> out_dim:int -> t
Sourceval _reshape_from_tensor : t -> shape:t -> t
Sourceval _s_where : condition:t -> t -> t -> t
Sourceval _sample_dirichlet : t -> t
Sourceval _saturate_weight_to_fp16 : weight:t -> t
Sourceval _shape_as_tensor : t -> t
Sourceval _sobol_engine_draw : quasi:t -> n:int -> sobolstate:t -> dimension:int -> num_generated:int -> dtype:Torch_core.Kind.packed -> t * t
Sourceval _sobol_engine_ff_ : t -> n:int -> sobolstate:t -> dimension:int -> num_generated:int -> t
Sourceval _sobol_engine_initialize_state_ : t -> dimension:int -> t
Sourceval _sobol_engine_scramble_ : t -> ltm:t -> dimension:int -> t
Sourceval _softmax : t -> dim:int -> half_to_float:bool -> t
Sourceval _softmax_backward_data : grad_output:t -> output:t -> dim:int -> t -> t
Sourceval _solve_helper : t -> a:t -> t * t
Sourceval _sparse_addmm : t -> sparse:t -> dense:t -> t
Sourceval _sparse_coo_tensor_unsafe : indices:t -> values:t -> size:int list -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval _sparse_coo_tensor_with_dims : sparse_dim:int -> dense_dim:int -> size:int list -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval _sparse_coo_tensor_with_dims_and_tensors : sparse_dim:int -> dense_dim:int -> size:int list -> indices:t -> values:t -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval _sparse_log_softmax : t -> dim:int -> dtype:Torch_core.Kind.packed -> t
Sourceval _sparse_log_softmax1 : t -> dim:int -> half_to_float:bool -> t
Sourceval _sparse_log_softmax_backward_data : grad_output:t -> output:t -> dim:int -> t -> t
Sourceval _sparse_mm : sparse:t -> dense:t -> t
Sourceval _sparse_softmax : t -> dim:int -> dtype:Torch_core.Kind.packed -> t
Sourceval _sparse_softmax1 : t -> dim:int -> half_to_float:bool -> t
Sourceval _sparse_softmax_backward_data : grad_output:t -> output:t -> dim:int -> t -> t
Sourceval _sparse_sum : t -> t
Sourceval _sparse_sum1 : t -> dtype:Torch_core.Kind.packed -> t
Sourceval _sparse_sum2 : t -> dim:int list -> t
Sourceval _sparse_sum3 : t -> dim:int list -> dtype:Torch_core.Kind.packed -> t
Sourceval _sparse_sum_backward : grad:t -> t -> dim:int list -> t
Sourceval _standard_gamma : t -> t
Sourceval _standard_gamma_grad : t -> output:t -> t
Sourceval _std : t -> unbiased:bool -> t
Sourceval _svd_helper : t -> some:bool -> compute_uv:bool -> t * t * t
Sourceval _symeig_helper : t -> eigenvectors:bool -> upper:bool -> t * t
Sourceval _test_optional_filled_intlist : values:t -> addends:int list -> t
Sourceval _test_optional_intlist : values:t -> addends:int list -> t
Sourceval _test_serialization_subcmul : t -> t -> t
Sourceval _thnn_differentiable_gru_cell_backward : grad_hy:t -> input_gates:t -> hidden_gates:t -> hx:t -> input_bias:t option -> hidden_bias:t option -> t * t * t * t * t
Sourceval _thnn_differentiable_lstm_cell_backward : grad_hy:t option -> grad_cy:t option -> input_gates:t -> hidden_gates:t -> input_bias:t option -> hidden_bias:t option -> cx:t -> cy:t -> t * t * t * t * t
Sourceval _thnn_fused_gru_cell : input_gates:t -> hidden_gates:t -> hx:t -> input_bias:t option -> hidden_bias:t option -> t * t
Sourceval _thnn_fused_gru_cell_backward : grad_hy:t -> workspace:t -> has_bias:bool -> t * t * t * t * t
Sourceval _thnn_fused_lstm_cell : input_gates:t -> hidden_gates:t -> cx:t -> input_bias:t option -> hidden_bias:t option -> t * t * t
Sourceval _thnn_fused_lstm_cell_backward : grad_hy:t option -> grad_cy:t option -> cx:t -> cy:t -> workspace:t -> has_bias:bool -> t * t * t * t * t
Sourceval _triangular_solve_helper : t -> a:t -> upper:bool -> transpose:bool -> unitriangular:bool -> t * t
Sourceval _trilinear : i1:t -> i2:t -> i3:t -> expand1:int list -> expand2:int list -> expand3:int list -> sumdim:int list -> unroll_dim:int -> t
Sourceval _unique : t -> sorted:bool -> return_inverse:bool -> t * t
Sourceval _unique2 : t -> sorted:bool -> return_inverse:bool -> return_counts:bool -> t * t * t
Sourceval _unsafe_view : t -> size:int list -> t
Sourceval _values : t -> t
Sourceval _var : t -> unbiased:bool -> t
Sourceval _weight_norm : v:t -> g:t -> dim:int -> t
Sourceval _weight_norm_cuda_interface : v:t -> g:t -> dim:int -> t * t
Sourceval _weight_norm_cuda_interface_backward : grad_w:t -> saved_v:t -> saved_g:t -> saved_norms:t -> dim:int -> t * t
Sourceval _weight_norm_differentiable_backward : grad_w:t -> saved_v:t -> saved_g:t -> saved_norms:t -> dim:int -> t * t
Sourceval abs : t -> t
Sourceval abs_ : t -> t
Sourceval abs_out : out:t -> t -> t
Sourceval absolute : t -> t
Sourceval absolute_ : t -> t
Sourceval absolute_out : out:t -> t -> t
Sourceval acos : t -> t
Sourceval acos_ : t -> t
Sourceval acos_out : out:t -> t -> t
Sourceval acosh : t -> t
Sourceval acosh_ : t -> t
Sourceval acosh_out : out:t -> t -> t
Sourceval adaptive_avg_pool1d : t -> output_size:int list -> t
Sourceval adaptive_avg_pool2d : t -> output_size:int list -> t
Sourceval adaptive_avg_pool2d_out : out:t -> t -> output_size:int list -> t
Sourceval adaptive_avg_pool3d : t -> output_size:int list -> t
Sourceval adaptive_avg_pool3d_backward : grad_output:t -> t -> t
Sourceval adaptive_avg_pool3d_backward_out : grad_input:t -> grad_output:t -> t -> t
Sourceval adaptive_avg_pool3d_out : out:t -> t -> output_size:int list -> t
Sourceval adaptive_max_pool1d : t -> output_size:int list -> t * t
Sourceval adaptive_max_pool2d : t -> output_size:int list -> t * t
Sourceval adaptive_max_pool2d_backward : grad_output:t -> t -> indices:t -> t
Sourceval adaptive_max_pool2d_backward_out : grad_input:t -> grad_output:t -> t -> indices:t -> t
Sourceval adaptive_max_pool2d_out : out:t -> indices:t -> t -> output_size:int list -> t * t
Sourceval adaptive_max_pool3d : t -> output_size:int list -> t * t
Sourceval adaptive_max_pool3d_backward : grad_output:t -> t -> indices:t -> t
Sourceval adaptive_max_pool3d_backward_out : grad_input:t -> grad_output:t -> t -> indices:t -> t
Sourceval adaptive_max_pool3d_out : out:t -> indices:t -> t -> output_size:int list -> t * t
Sourceval add : t -> t -> t
Sourceval add_ : t -> t -> t
Sourceval add_out : out:t -> t -> t -> t
Sourceval addbmm : t -> batch1:t -> batch2:t -> t
Sourceval addbmm_ : t -> batch1:t -> batch2:t -> t
Sourceval addbmm_out : out:t -> t -> batch1:t -> batch2:t -> t
Sourceval addcdiv : t -> tensor1:t -> tensor2:t -> t
Sourceval addcdiv_ : t -> tensor1:t -> tensor2:t -> t
Sourceval addcdiv_out : out:t -> t -> tensor1:t -> tensor2:t -> t
Sourceval addcmul : t -> tensor1:t -> tensor2:t -> t
Sourceval addcmul_ : t -> tensor1:t -> tensor2:t -> t
Sourceval addcmul_out : out:t -> t -> tensor1:t -> tensor2:t -> t
Sourceval addmm : t -> mat1:t -> mat2:t -> t
Sourceval addmm_ : t -> mat1:t -> mat2:t -> t
Sourceval addmm_out : out:t -> t -> mat1:t -> mat2:t -> t
Sourceval addmv : t -> mat:t -> vec:t -> t
Sourceval addmv_ : t -> mat:t -> vec:t -> t
Sourceval addmv_out : out:t -> t -> mat:t -> vec:t -> t
Sourceval addr : t -> vec1:t -> vec2:t -> t
Sourceval addr_ : t -> vec1:t -> vec2:t -> t
Sourceval addr_out : out:t -> t -> vec1:t -> vec2:t -> t
Sourceval affine_grid_generator : theta:t -> size:int list -> align_corners:bool -> t
Sourceval affine_grid_generator_backward : grad:t -> size:int list -> align_corners:bool -> t
Sourceval alias : t -> t
Sourceval align_as : t -> t -> t
Sourceval align_tensors : t list -> t list
Sourceval all : t -> t
Sourceval all1 : t -> dim:int -> keepdim:bool -> t
Sourceval all_out : out:t -> t -> dim:int -> keepdim:bool -> t
Sourceval alpha_dropout : t -> p:float -> train:bool -> t
Sourceval alpha_dropout_ : t -> p:float -> train:bool -> t
Sourceval amax : t -> dim:int list -> keepdim:bool -> t
Sourceval amax_out : out:t -> t -> dim:int list -> keepdim:bool -> t
Sourceval amin : t -> dim:int list -> keepdim:bool -> t
Sourceval amin_out : out:t -> t -> dim:int list -> keepdim:bool -> t
Sourceval angle : t -> t
Sourceval angle_out : out:t -> t -> t
Sourceval any : t -> t
Sourceval any1 : t -> dim:int -> keepdim:bool -> t
Sourceval any_out : out:t -> t -> dim:int -> keepdim:bool -> t
Sourceval arange_out : out:t -> end_:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval arange_out1 : out:t -> start:'a Torch_core.Wrapper.Scalar.t -> end_:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval arccos : t -> t
Sourceval arccos_ : t -> t
Sourceval arccos_out : out:t -> t -> t
Sourceval arccosh : t -> t
Sourceval arccosh_ : t -> t
Sourceval arccosh_out : out:t -> t -> t
Sourceval arcsin : t -> t
Sourceval arcsin_ : t -> t
Sourceval arcsin_out : out:t -> t -> t
Sourceval arcsinh : t -> t
Sourceval arcsinh_ : t -> t
Sourceval arcsinh_out : out:t -> t -> t
Sourceval arctan : t -> t
Sourceval arctan_ : t -> t
Sourceval arctan_out : out:t -> t -> t
Sourceval arctanh : t -> t
Sourceval arctanh_ : t -> t
Sourceval arctanh_out : out:t -> t -> t
Sourceval argmin : t -> dim:int -> keepdim:bool -> t
Sourceval argsort : t -> dim:int -> descending:bool -> t
Sourceval as_strided : t -> size:int list -> stride:int list -> storage_offset:int -> t
Sourceval as_strided_ : t -> size:int list -> stride:int list -> storage_offset:int -> t
Sourceval asin : t -> t
Sourceval asin_ : t -> t
Sourceval asin_out : out:t -> t -> t
Sourceval asinh : t -> t
Sourceval asinh_ : t -> t
Sourceval asinh_out : out:t -> t -> t
Sourceval atan : t -> t
Sourceval atan2 : t -> t -> t
Sourceval atan2_ : t -> t -> t
Sourceval atan2_out : out:t -> t -> t -> t
Sourceval atan_ : t -> t
Sourceval atan_out : out:t -> t -> t
Sourceval atanh : t -> t
Sourceval atanh_ : t -> t
Sourceval atanh_out : out:t -> t -> t
Sourceval atleast_1d : t -> t
Sourceval atleast_1d1 : t list -> t list
Sourceval atleast_2d : t -> t
Sourceval atleast_2d1 : t list -> t list
Sourceval atleast_3d : t -> t
Sourceval atleast_3d1 : t list -> t list
Sourceval avg_pool1d : t -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> t
Sourceval avg_pool2d_backward : grad_output:t -> t -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int -> t
Sourceval avg_pool2d_backward_out : grad_input:t -> grad_output:t -> t -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int -> t
Sourceval avg_pool2d_out : out:t -> t -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int -> t
Sourceval avg_pool3d : t -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int -> t
Sourceval avg_pool3d_backward : grad_output:t -> t -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int -> t
Sourceval avg_pool3d_backward_out : grad_input:t -> grad_output:t -> t -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int -> t
Sourceval avg_pool3d_out : out:t -> t -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int -> t
Sourceval baddbmm : t -> batch1:t -> batch2:t -> t
Sourceval baddbmm_ : t -> batch1:t -> batch2:t -> t
Sourceval baddbmm_out : out:t -> t -> batch1:t -> batch2:t -> t
Sourceval bartlett_window : window_length:int -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval bartlett_window1 : window_length:int -> periodic:bool -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval batch_norm : t -> weight:t option -> bias:t option -> running_mean:t option -> running_var:t option -> training:bool -> momentum:float -> eps:float -> cudnn_enabled:bool -> t
Sourceval batch_norm_backward_elemt : grad_out:t -> t -> mean:t -> invstd:t -> weight:t option -> mean_dy:t -> mean_dy_xmu:t -> t
Sourceval batch_norm_backward_reduce : grad_out:t -> t -> mean:t -> invstd:t -> weight:t option -> input_g:bool -> weight_g:bool -> bias_g:bool -> t * t * t * t
Sourceval batch_norm_elemt : t -> weight:t option -> bias:t option -> mean:t -> invstd:t -> eps:float -> t
Sourceval batch_norm_elemt_out : out:t -> t -> weight:t option -> bias:t option -> mean:t -> invstd:t -> eps:float -> t
Sourceval batch_norm_gather_stats : t -> mean:t -> invstd:t -> running_mean:t option -> running_var:t option -> momentum:float -> eps:float -> count:int -> t * t
Sourceval batch_norm_gather_stats_with_counts : t -> mean:t -> invstd:t -> running_mean:t option -> running_var:t option -> momentum:float -> eps:float -> counts:t -> t * t
Sourceval batch_norm_stats : t -> eps:float -> t * t
Sourceval batch_norm_update_stats : t -> running_mean:t option -> running_var:t option -> momentum:float -> t * t
Sourceval bernoulli : t -> t
Sourceval bernoulli1 : t -> p:float -> t
Sourceval bernoulli_ : t -> p:t -> t
Sourceval bernoulli_1 : t -> p:float -> t
Sourceval bernoulli_out : out:t -> t -> t
Sourceval bilinear : input1:t -> input2:t -> weight:t -> bias:t option -> t
Sourceval binary_cross_entropy : t -> target:t -> weight:t option -> reduction:Torch_core.Reduction.t -> t
Sourceval binary_cross_entropy_backward : grad_output:t -> t -> target:t -> weight:t option -> reduction:Torch_core.Reduction.t -> t
Sourceval binary_cross_entropy_backward_out : grad_input:t -> grad_output:t -> t -> target:t -> weight:t option -> reduction:Torch_core.Reduction.t -> t
Sourceval binary_cross_entropy_out : out:t -> t -> target:t -> weight:t option -> reduction:Torch_core.Reduction.t -> t
Sourceval binary_cross_entropy_with_logits : t -> target:t -> weight:t option -> pos_weight:t option -> reduction:Torch_core.Reduction.t -> t
Sourceval binary_cross_entropy_with_logits_backward : grad_output:t -> t -> target:t -> weight:t option -> pos_weight:t option -> reduction:Torch_core.Reduction.t -> t
Sourceval bincount : t -> weights:t option -> minlength:int -> t
Sourceval binomial : count:t -> prob:t -> t
Sourceval bitwise_and : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_and1 : t -> t -> t
Sourceval bitwise_and_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_and_1 : t -> t -> t
Sourceval bitwise_and_out : out:t -> t -> t -> t
Sourceval bitwise_and_out1 : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_not : t -> t
Sourceval bitwise_not_ : t -> t
Sourceval bitwise_not_out : out:t -> t -> t
Sourceval bitwise_or : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_or1 : t -> t -> t
Sourceval bitwise_or_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_or_1 : t -> t -> t
Sourceval bitwise_or_out : out:t -> t -> t -> t
Sourceval bitwise_or_out1 : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_xor : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_xor1 : t -> t -> t
Sourceval bitwise_xor_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_xor_1 : t -> t -> t
Sourceval bitwise_xor_out : out:t -> t -> t -> t
Sourceval bitwise_xor_out1 : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval blackman_window : window_length:int -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval blackman_window1 : window_length:int -> periodic:bool -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval block_diag : t list -> t
Sourceval bmm : t -> mat2:t -> t
Sourceval bmm_out : out:t -> t -> mat2:t -> t
Sourceval broadcast_tensors : t list -> t list
Sourceval bucketize : t -> boundaries:t -> out_int32:bool -> right:bool -> t
Sourceval bucketize1 : 'a Torch_core.Wrapper.Scalar.t -> boundaries:t -> out_int32:bool -> right:bool -> t
Sourceval bucketize_out : out:t -> t -> boundaries:t -> out_int32:bool -> right:bool -> t
Sourceval cartesian_prod : t list -> t
Sourceval cat : t list -> dim:int -> t
Sourceval cat_out : out:t -> t list -> dim:int -> t
Sourceval cauchy_ : t -> median:float -> sigma:float -> t
Sourceval cdist : x1:t -> x2:t -> p:float -> compute_mode:int -> t
Sourceval ceil : t -> t
Sourceval ceil_ : t -> t
Sourceval ceil_out : out:t -> t -> t
Sourceval celu : t -> t
Sourceval celu_ : t -> t
Sourceval chain_matmul : matrices:t list -> t
Sourceval channel_shuffle : t -> groups:int -> t
Sourceval cholesky : t -> upper:bool -> t
Sourceval cholesky_inverse : t -> upper:bool -> t
Sourceval cholesky_inverse_out : out:t -> t -> upper:bool -> t
Sourceval cholesky_out : out:t -> t -> upper:bool -> t
Sourceval cholesky_solve : t -> input2:t -> upper:bool -> t
Sourceval cholesky_solve_out : out:t -> t -> input2:t -> upper:bool -> t
Sourceval chunk : t -> chunks:int -> dim:int -> t list
Sourceval clamp_ : t -> min:'a Torch_core.Wrapper.Scalar.t -> max:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval clamp_max : t -> max:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval clamp_max_ : t -> max:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval clamp_max_out : out:t -> t -> max:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval clamp_min : t -> min:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval clamp_min_ : t -> min:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval clamp_min_out : out:t -> t -> min:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval clamp_out : out:t -> t -> min:'a Torch_core.Wrapper.Scalar.t -> max:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval clip_ : t -> min:'a Torch_core.Wrapper.Scalar.t -> max:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval clip_out : out:t -> t -> min:'a Torch_core.Wrapper.Scalar.t -> max:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval clone : t -> t
Sourceval coalesce : t -> t
Sourceval col2im : t -> output_size:int list -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> t
Sourceval col2im_backward : grad_output:t -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> t
Sourceval col2im_backward_out : grad_input:t -> grad_output:t -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> t
Sourceval col2im_out : out:t -> t -> output_size:int list -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> t
Sourceval combinations : t -> r:int -> with_replacement:bool -> t
Sourceval complex : real:t -> imag:t -> t
Sourceval complex_out : out:t -> real:t -> imag:t -> t
Sourceval conj : t -> t
Sourceval conj_out : out:t -> t -> t
Sourceval constant_pad_nd : t -> pad:int list -> t
Sourceval contiguous : t -> t
Sourceval conv1d : t -> weight:t -> bias:t option -> stride:int list -> padding:int list -> dilation:int list -> groups:int -> t
Sourceval conv3d : t -> weight:t -> bias:t option -> stride:int list -> padding:int list -> dilation:int list -> groups:int -> t
Sourceval conv_tbc : t -> weight:t -> bias:t -> pad:int -> t
Sourceval conv_tbc_backward : t -> t -> weight:t -> bias:t -> pad:int -> t * t * t
Sourceval conv_transpose1d : t -> weight:t -> bias:t option -> stride:int list -> padding:int list -> output_padding:int list -> groups:int -> dilation:int list -> t
Sourceval conv_transpose3d : t -> weight:t -> bias:t option -> stride:int list -> padding:int list -> output_padding:int list -> groups:int -> dilation:int list -> t
Sourceval convolution : t -> weight:t -> bias:t option -> stride:int list -> padding:int list -> dilation:int list -> transposed:bool -> output_padding:int list -> groups:int -> t
Sourceval convolution_overrideable : t -> weight:t -> bias:t option -> stride:int list -> padding:int list -> dilation:int list -> transposed:bool -> output_padding:int list -> groups:int -> t
Sourceval copy_sparse_to_sparse_ : t -> src:t -> non_blocking:bool -> t
Sourceval cos : t -> t
Sourceval cos_ : t -> t
Sourceval cos_out : out:t -> t -> t
Sourceval cosh : t -> t
Sourceval cosh_ : t -> t
Sourceval cosh_out : out:t -> t -> t
Sourceval cosine_embedding_loss : input1:t -> input2:t -> target:t -> margin:float -> reduction:Torch_core.Reduction.t -> t
Sourceval cosine_similarity : x1:t -> x2:t -> dim:int -> eps:float -> t
Sourceval cross : t -> t -> dim:int -> t
Sourceval cross_out : out:t -> t -> t -> dim:int -> t
Sourceval ctc_loss : log_probs:t -> targets:t -> input_lengths:int list -> target_lengths:int list -> blank:int -> reduction:Torch_core.Reduction.t -> zero_infinity:bool -> t
Sourceval ctc_loss1 : log_probs:t -> targets:t -> input_lengths:t -> target_lengths:t -> blank:int -> reduction:Torch_core.Reduction.t -> zero_infinity:bool -> t
Sourceval cudnn_affine_grid_generator : theta:t -> n:int -> c:int -> h:int -> w:int -> t
Sourceval cudnn_affine_grid_generator_backward : grad:t -> n:int -> c:int -> h:int -> w:int -> t
Sourceval cudnn_batch_norm : t -> weight:t -> bias:t option -> running_mean:t option -> running_var:t option -> training:bool -> exponential_average_factor:float -> epsilon:float -> t * t * t * t
Sourceval cudnn_batch_norm_backward : t -> grad_output:t -> weight:t -> running_mean:t option -> running_var:t option -> save_mean:t option -> save_var:t option -> epsilon:float -> reservespace:t -> t * t * t
Sourceval cudnn_convolution : t -> weight:t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> t
Sourceval cudnn_convolution1 : t -> weight:t -> bias:t option -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> t
Sourceval cudnn_convolution2 : t -> weight:t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> allow_tf32:bool -> t
Sourceval cudnn_convolution_backward_input : self_size:int list -> grad_output:t -> weight:t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> allow_tf32:bool -> t
Sourceval cudnn_convolution_backward_weight : weight_size:int list -> grad_output:t -> t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> allow_tf32:bool -> t
Sourceval cudnn_convolution_transpose : t -> weight:t -> padding:int list -> output_padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> t
Sourceval cudnn_convolution_transpose1 : t -> weight:t -> bias:t option -> padding:int list -> output_padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> t
Sourceval cudnn_convolution_transpose2 : t -> weight:t -> padding:int list -> output_padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> allow_tf32:bool -> t
Sourceval cudnn_convolution_transpose_backward_input : grad_output:t -> weight:t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> allow_tf32:bool -> t
Sourceval cudnn_convolution_transpose_backward_weight : weight_size:int list -> grad_output:t -> t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> allow_tf32:bool -> t
Sourceval cudnn_grid_sampler : t -> grid:t -> t
Sourceval cudnn_grid_sampler_backward : t -> grid:t -> grad_output:t -> t * t
Sourceval cummax : t -> dim:int -> t * t
Sourceval cummax_out : values:t -> indices:t -> t -> dim:int -> t * t
Sourceval cummaxmin_backward : grad:t -> t -> indices:t -> dim:int -> t
Sourceval cummin : t -> dim:int -> t * t
Sourceval cummin_out : values:t -> indices:t -> t -> dim:int -> t * t
Sourceval cumprod : t -> dim:int -> dtype:Torch_core.Kind.packed -> t
Sourceval cumprod_backward : grad:t -> t -> dim:int -> t
Sourceval cumprod_out : out:t -> t -> dim:int -> dtype:Torch_core.Kind.packed -> t
Sourceval cumsum : t -> dim:int -> dtype:Torch_core.Kind.packed -> t
Sourceval cumsum_out : out:t -> t -> dim:int -> dtype:Torch_core.Kind.packed -> t
Sourceval data : t -> t
Sourceval deg2rad : t -> t
Sourceval deg2rad_ : t -> t
Sourceval deg2rad_out : out:t -> t -> t
Sourceval dequantize : t -> t
Sourceval dequantize1 : t list -> t list
Sourceval det : t -> t
Sourceval detach : t -> t
Sourceval detach_ : t -> t
Sourceval diag : t -> diagonal:int -> t
Sourceval diag_backward : grad:t -> input_sizes:int list -> diagonal:int -> t
Sourceval diag_embed : t -> offset:int -> dim1:int -> dim2:int -> t
Sourceval diag_out : out:t -> t -> diagonal:int -> t
Sourceval diagflat : t -> offset:int -> t
Sourceval diagonal : t -> offset:int -> dim1:int -> dim2:int -> t
Sourceval diagonal_backward : grad:t -> input_sizes:int list -> offset:int -> dim1:int -> dim2:int -> t
Sourceval digamma : t -> t
Sourceval digamma_ : t -> t
Sourceval digamma_out : out:t -> t -> t
Sourceval dist : t -> t -> t
Sourceval div : t -> t -> t
Sourceval div_ : t -> t -> t
Sourceval div_out : out:t -> t -> t -> t
Sourceval divide : t -> t -> t
Sourceval divide1 : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval divide_ : t -> t -> t
Sourceval divide_1 : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval divide_out : out:t -> t -> t -> t
Sourceval dot : t -> t -> t
Sourceval dot_out : out:t -> t -> t -> t
Sourceval dropout_ : t -> p:float -> train:bool -> t
Sourceval dstack : t list -> t
Sourceval dstack_out : out:t -> t list -> t
Sourceval eig : t -> eigenvectors:bool -> t * t
Sourceval eig_out : e:t -> v:t -> t -> eigenvectors:bool -> t * t
Sourceval einsum : equation:string -> t list -> t
Sourceval elu : t -> t
Sourceval elu_ : t -> t
Sourceval elu_backward : grad_output:t -> alpha:'a Torch_core.Wrapper.Scalar.t -> scale:'a Torch_core.Wrapper.Scalar.t -> input_scale:'a Torch_core.Wrapper.Scalar.t -> output:t -> t
Sourceval elu_backward_out : grad_input:t -> grad_output:t -> alpha:'a Torch_core.Wrapper.Scalar.t -> scale:'a Torch_core.Wrapper.Scalar.t -> input_scale:'a Torch_core.Wrapper.Scalar.t -> output:t -> t
Sourceval elu_out : out:t -> t -> t
Sourceval embedding : weight:t -> indices:t -> padding_idx:int -> scale_grad_by_freq:bool -> sparse:bool -> t
Sourceval embedding_backward : grad:t -> indices:t -> num_weights:int -> padding_idx:int -> scale_grad_by_freq:bool -> sparse:bool -> t
Sourceval embedding_bag : weight:t -> indices:t -> offsets:t -> scale_grad_by_freq:bool -> mode:int -> sparse:bool -> per_sample_weights:t option -> include_last_offset:bool -> t * t * t * t
Sourceval embedding_dense_backward : grad_output:t -> indices:t -> num_weights:int -> padding_idx:int -> scale_grad_by_freq:bool -> t
Sourceval embedding_renorm_ : t -> indices:t -> max_norm:float -> norm_type:float -> t
Sourceval embedding_sparse_backward : grad:t -> indices:t -> num_weights:int -> padding_idx:int -> scale_grad_by_freq:bool -> t
Sourceval empty : size:int list -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval empty_like : t -> t
Sourceval empty_meta : size:int list -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval empty_out : out:t -> size:int list -> t
Sourceval empty_quantized : size:int list -> qtensor:t -> t
Sourceval empty_strided : size:int list -> stride:int list -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval eq1 : t -> t -> t
Sourceval eq_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval eq_1 : t -> t -> t
Sourceval eq_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval eq_out1 : out:t -> t -> t -> t
Sourceval erf : t -> t
Sourceval erf_ : t -> t
Sourceval erf_out : out:t -> t -> t
Sourceval erfc : t -> t
Sourceval erfc_ : t -> t
Sourceval erfc_out : out:t -> t -> t
Sourceval erfinv : t -> t
Sourceval erfinv_ : t -> t
Sourceval erfinv_out : out:t -> t -> t
Sourceval exp : t -> t
Sourceval exp2 : t -> t
Sourceval exp2_ : t -> t
Sourceval exp2_out : out:t -> t -> t
Sourceval exp_ : t -> t
Sourceval exp_out : out:t -> t -> t
Sourceval expand : t -> size:int list -> implicit:bool -> t
Sourceval expand_as : t -> t -> t
Sourceval expm1 : t -> t
Sourceval expm1_ : t -> t
Sourceval expm1_out : out:t -> t -> t
Sourceval exponential_ : t -> lambd:float -> t
Sourceval eye : n:int -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval eye1 : n:int -> m:int -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval eye_out : out:t -> n:int -> t
Sourceval eye_out1 : out:t -> n:int -> m:int -> t
Sourceval fake_quantize_per_channel_affine : t -> scale:t -> zero_point:t -> axis:int -> quant_min:int -> quant_max:int -> t
Sourceval fake_quantize_per_channel_affine_backward : grad:t -> t -> scale:t -> zero_point:t -> axis:int -> quant_min:int -> quant_max:int -> t
Sourceval fake_quantize_per_tensor_affine : t -> scale:float -> zero_point:int -> quant_min:int -> quant_max:int -> t
Sourceval fake_quantize_per_tensor_affine_backward : grad:t -> t -> scale:float -> zero_point:int -> quant_min:int -> quant_max:int -> t
Sourceval fbgemm_linear_fp16_weight : t -> packed_weight:t -> bias:t -> t
Sourceval fbgemm_linear_fp16_weight_fp32_activation : t -> packed_weight:t -> bias:t -> t
Sourceval fbgemm_linear_int8_weight : t -> weight:t -> packed:t -> col_offsets:t -> weight_scale:'a Torch_core.Wrapper.Scalar.t -> weight_zero_point:'a Torch_core.Wrapper.Scalar.t -> bias:t -> t
Sourceval fbgemm_linear_int8_weight_fp32_activation : t -> weight:t -> packed:t -> col_offsets:t -> weight_scale:'a Torch_core.Wrapper.Scalar.t -> weight_zero_point:'a Torch_core.Wrapper.Scalar.t -> bias:t -> t
Sourceval fbgemm_pack_gemm_matrix_fp16 : t -> t
Sourceval fbgemm_pack_quantized_matrix : t -> t
Sourceval fbgemm_pack_quantized_matrix1 : t -> k:int -> n:int -> t
Sourceval feature_alpha_dropout : t -> p:float -> train:bool -> t
Sourceval feature_alpha_dropout_ : t -> p:float -> train:bool -> t
Sourceval feature_dropout : t -> p:float -> train:bool -> t
Sourceval feature_dropout_ : t -> p:float -> train:bool -> t
Sourceval fft : t -> signal_ndim:int -> normalized:bool -> t
Sourceval fft_fft : t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_fftn : t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_hfft : t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_ifft : t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_ifftn : t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_ihfft : t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_irfft : t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_irfftn : t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_rfft : t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_rfftn : t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fill_ : t -> value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval fill_1 : t -> value:t -> t
Sourceval fill_diagonal_ : t -> fill_value:'a Torch_core.Wrapper.Scalar.t -> wrap:bool -> t
Sourceval fix : t -> t
Sourceval fix_ : t -> t
Sourceval fix_out : out:t -> t -> t
Sourceval flip : t -> dims:int list -> t
Sourceval fliplr : t -> t
Sourceval flipud : t -> t
Sourceval floor : t -> t
Sourceval floor_ : t -> t
Sourceval floor_divide : t -> t -> t
Sourceval floor_divide1 : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval floor_divide_ : t -> t -> t
Sourceval floor_divide_1 : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval floor_divide_out : out:t -> t -> t -> t
Sourceval floor_out : out:t -> t -> t
Sourceval fmod1 : t -> t -> t
Sourceval fmod_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval fmod_1 : t -> t -> t
Sourceval fmod_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval fmod_out1 : out:t -> t -> t -> t
Sourceval frac : t -> t
Sourceval frac_ : t -> t
Sourceval frac_out : out:t -> t -> t
Sourceval fractional_max_pool2d : t -> kernel_size:int list -> output_size:int list -> random_samples:t -> t * t
Sourceval fractional_max_pool2d_backward : grad_output:t -> t -> kernel_size:int list -> output_size:int list -> indices:t -> t
Sourceval fractional_max_pool2d_backward_out : grad_input:t -> grad_output:t -> t -> kernel_size:int list -> output_size:int list -> indices:t -> t
Sourceval fractional_max_pool2d_out : output:t -> indices:t -> t -> kernel_size:int list -> output_size:int list -> random_samples:t -> t * t
Sourceval fractional_max_pool3d : t -> kernel_size:int list -> output_size:int list -> random_samples:t -> t * t
Sourceval fractional_max_pool3d_backward : grad_output:t -> t -> kernel_size:int list -> output_size:int list -> indices:t -> t
Sourceval fractional_max_pool3d_backward_out : grad_input:t -> grad_output:t -> t -> kernel_size:int list -> output_size:int list -> indices:t -> t
Sourceval fractional_max_pool3d_out : output:t -> indices:t -> t -> kernel_size:int list -> output_size:int list -> random_samples:t -> t * t
Sourceval frobenius_norm : t -> t
Sourceval frobenius_norm1 : t -> dim:int list -> keepdim:bool -> t
Sourceval frobenius_norm_out : out:t -> t -> dim:int list -> keepdim:bool -> t
Sourceval from_file : filename:string -> shared:bool -> size:int -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval full : size:int list -> fill_value:'a Torch_core.Wrapper.Scalar.t -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval full_like : t -> fill_value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval full_out : out:t -> size:int list -> fill_value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval gather : t -> dim:int -> index:t -> sparse_grad:bool -> t
Sourceval gather_backward : grad:t -> t -> dim:int -> index:t -> sparse_grad:bool -> t
Sourceval gather_out : out:t -> t -> dim:int -> index:t -> sparse_grad:bool -> t
Sourceval gcd : t -> t -> t
Sourceval gcd_ : t -> t -> t
Sourceval gcd_out : out:t -> t -> t -> t
Sourceval ge1 : t -> t -> t
Sourceval ge_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval ge_1 : t -> t -> t
Sourceval ge_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval ge_out1 : out:t -> t -> t -> t
Sourceval gelu : t -> t
Sourceval gelu_backward : grad:t -> t -> t
Sourceval geometric_ : t -> p:float -> t
Sourceval geqrf : t -> t * t
Sourceval geqrf_out : a:t -> tau:t -> t -> t * t
Sourceval ger : t -> vec2:t -> t
Sourceval ger_out : out:t -> t -> vec2:t -> t
Sourceval glu : t -> dim:int -> t
Sourceval glu_backward : grad_output:t -> t -> dim:int -> t
Sourceval glu_backward_out : grad_input:t -> grad_output:t -> t -> dim:int -> t
Sourceval glu_out : out:t -> t -> dim:int -> t
Sourceval grad : t -> t
Sourceval greater : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval greater1 : t -> t -> t
Sourceval greater_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval greater_1 : t -> t -> t
Sourceval greater_equal : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval greater_equal1 : t -> t -> t
Sourceval greater_equal_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval greater_equal_1 : t -> t -> t
Sourceval greater_equal_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval greater_equal_out1 : out:t -> t -> t -> t
Sourceval greater_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval greater_out1 : out:t -> t -> t -> t
Sourceval grid_sampler : t -> grid:t -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> t
Sourceval grid_sampler_2d : t -> grid:t -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> t
Sourceval grid_sampler_2d_backward : grad_output:t -> t -> grid:t -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> t * t
Sourceval grid_sampler_3d : t -> grid:t -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> t
Sourceval grid_sampler_3d_backward : grad_output:t -> t -> grid:t -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> t * t
Sourceval group_norm : t -> num_groups:int -> weight:t option -> bias:t option -> eps:float -> cudnn_enabled:bool -> t
Sourceval gru : t -> hx:t -> params:t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> batch_first:bool -> t * t
Sourceval gru1 : data:t -> batch_sizes:t -> hx:t -> params:t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> t * t
Sourceval gru_cell : t -> hx:t -> w_ih:t -> w_hh:t -> b_ih:t option -> b_hh:t option -> t
Sourceval gt1 : t -> t -> t
Sourceval gt_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval gt_1 : t -> t -> t
Sourceval gt_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval gt_out1 : out:t -> t -> t -> t
Sourceval hamming_window : window_length:int -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval hamming_window1 : window_length:int -> periodic:bool -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval hamming_window2 : window_length:int -> periodic:bool -> alpha:float -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval hamming_window3 : window_length:int -> periodic:bool -> alpha:float -> beta:float -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval hann_window : window_length:int -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval hann_window1 : window_length:int -> periodic:bool -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval hardshrink : t -> t
Sourceval hardshrink_backward : grad_out:t -> t -> lambd:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval hardsigmoid : t -> t
Sourceval hardsigmoid_ : t -> t
Sourceval hardsigmoid_backward : grad_output:t -> t -> t
Sourceval hardsigmoid_out : out:t -> t -> t
Sourceval hardswish : t -> t
Sourceval hardswish_ : t -> t
Sourceval hardswish_backward : grad_output:t -> t -> t
Sourceval hardswish_out : out:t -> t -> t
Sourceval hardtanh : t -> t
Sourceval hardtanh_ : t -> t
Sourceval hardtanh_backward : grad_output:t -> t -> min_val:'a Torch_core.Wrapper.Scalar.t -> max_val:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval hardtanh_backward_out : grad_input:t -> grad_output:t -> t -> min_val:'a Torch_core.Wrapper.Scalar.t -> max_val:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval hardtanh_out : out:t -> t -> t
Sourceval heaviside : t -> values:t -> t
Sourceval heaviside_ : t -> values:t -> t
Sourceval heaviside_out : out:t -> t -> values:t -> t
Sourceval hinge_embedding_loss : t -> target:t -> margin:float -> reduction:Torch_core.Reduction.t -> t
Sourceval histc : t -> bins:int -> t
Sourceval histc_out : out:t -> t -> bins:int -> t
Sourceval hspmm : mat1:t -> mat2:t -> t
Sourceval hspmm_out : out:t -> mat1:t -> mat2:t -> t
Sourceval hstack : t list -> t
Sourceval hstack_out : out:t -> t list -> t
Sourceval hypot : t -> t -> t
Sourceval hypot_ : t -> t -> t
Sourceval hypot_out : out:t -> t -> t -> t
Sourceval i0 : t -> t
Sourceval i0_ : t -> t
Sourceval i0_out : out:t -> t -> t
Sourceval ifft : t -> signal_ndim:int -> normalized:bool -> t
Sourceval im2col : t -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> t
Sourceval im2col_backward : grad_output:t -> input_size:int list -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> t
Sourceval im2col_backward_out : grad_input:t -> grad_output:t -> input_size:int list -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> t
Sourceval im2col_out : out:t -> t -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> t
Sourceval imag : t -> t
Sourceval index : t -> indices:t list -> t
Sourceval index_add : t -> dim:int -> index:t -> source:t -> t
Sourceval index_add_ : t -> dim:int -> index:t -> source:t -> t
Sourceval index_copy : t -> dim:int -> index:t -> source:t -> t
Sourceval index_copy_ : t -> dim:int -> index:t -> source:t -> t
Sourceval index_fill : t -> dim:int -> index:t -> value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval index_fill1 : t -> dim:int -> index:t -> value:t -> t
Sourceval index_fill_ : t -> dim:int -> index:t -> value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval index_fill_1 : t -> dim:int -> index:t -> value:t -> t
Sourceval index_put : t -> indices:t list -> values:t -> accumulate:bool -> t
Sourceval index_put_ : t -> indices:t list -> values:t -> accumulate:bool -> t
Sourceval index_select : t -> dim:int -> index:t -> t
Sourceval index_select_backward : grad:t -> self_sizes:int list -> dim:int -> index:t -> t
Sourceval index_select_out : out:t -> t -> dim:int -> index:t -> t
Sourceval indices : t -> t
Sourceval infinitely_differentiable_gelu_backward : grad:t -> t -> t
Sourceval instance_norm : t -> weight:t option -> bias:t option -> running_mean:t option -> running_var:t option -> use_input_stats:bool -> momentum:float -> eps:float -> cudnn_enabled:bool -> t
Sourceval int_repr : t -> t
Sourceval inverse : t -> t
Sourceval inverse_out : out:t -> t -> t
Sourceval irfft : t -> signal_ndim:int -> normalized:bool -> onesided:bool -> signal_sizes:int list -> t
Sourceval isclose : t -> t -> rtol:float -> atol:float -> equal_nan:bool -> t
Sourceval isfinite : t -> t
Sourceval isinf : t -> t
Sourceval isnan : t -> t
Sourceval isneginf : t -> t
Sourceval isneginf_out : out:t -> t -> t
Sourceval isposinf : t -> t
Sourceval isposinf_out : out:t -> t -> t
Sourceval isreal : t -> t
Sourceval istft : t -> n_fft:int -> hop_length:int -> win_length:int -> window:t option -> center:bool -> normalized:bool -> onesided:bool -> length:int -> return_complex:bool -> t
Sourceval kaiser_window : window_length:int -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval kaiser_window1 : window_length:int -> periodic:bool -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval kaiser_window2 : window_length:int -> periodic:bool -> beta:float -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval kl_div : t -> target:t -> reduction:Torch_core.Reduction.t -> log_target:bool -> t
Sourceval kl_div_backward : grad_output:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> log_target:bool -> t
Sourceval kthvalue : t -> k:int -> dim:int -> keepdim:bool -> t * t
Sourceval kthvalue_out : values:t -> indices:t -> t -> k:int -> dim:int -> keepdim:bool -> t * t
Sourceval l1_loss : t -> target:t -> reduction:Torch_core.Reduction.t -> t
Sourceval l1_loss_backward : grad_output:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> t
Sourceval l1_loss_backward_out : grad_input:t -> grad_output:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> t
Sourceval l1_loss_out : out:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> t
Sourceval layer_norm : t -> normalized_shape:int list -> weight:t option -> bias:t option -> eps:float -> cudnn_enable:bool -> t
Sourceval lcm : t -> t -> t
Sourceval lcm_ : t -> t -> t
Sourceval lcm_out : out:t -> t -> t -> t
Sourceval le1 : t -> t -> t
Sourceval le_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval le_1 : t -> t -> t
Sourceval le_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval le_out1 : out:t -> t -> t -> t
Sourceval leaky_relu : t -> t
Sourceval leaky_relu_ : t -> t
Sourceval leaky_relu_backward : grad_output:t -> t -> negative_slope:'a Torch_core.Wrapper.Scalar.t -> self_is_result:bool -> t
Sourceval leaky_relu_out : out:t -> t -> t
Sourceval lerp : t -> end_:t -> weight:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval lerp1 : t -> end_:t -> weight:t -> t
Sourceval lerp_ : t -> end_:t -> weight:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval lerp_1 : t -> end_:t -> weight:t -> t
Sourceval lerp_out : out:t -> t -> end_:t -> weight:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval lerp_out1 : out:t -> t -> end_:t -> weight:t -> t
Sourceval less1 : t -> t -> t
Sourceval less_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval less_1 : t -> t -> t
Sourceval less_equal : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval less_equal1 : t -> t -> t
Sourceval less_equal_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval less_equal_1 : t -> t -> t
Sourceval less_equal_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval less_equal_out1 : out:t -> t -> t -> t
Sourceval less_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval less_out1 : out:t -> t -> t -> t
Sourceval lgamma : t -> t
Sourceval lgamma_ : t -> t
Sourceval lgamma_out : out:t -> t -> t
Sourceval linalg_det : t -> t
Sourceval linalg_norm : t -> ord:'a Torch_core.Wrapper.Scalar.t -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval linalg_norm1 : t -> ord:string -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval linalg_norm_out : out:t -> t -> ord:'a Torch_core.Wrapper.Scalar.t -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval linalg_norm_out1 : out:t -> t -> ord:string -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval linear : t -> weight:t -> bias:t option -> t
Sourceval linspace : start:'a Torch_core.Wrapper.Scalar.t -> end_:'a Torch_core.Wrapper.Scalar.t -> steps:int -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval linspace_out : out:t -> start:'a Torch_core.Wrapper.Scalar.t -> end_:'a Torch_core.Wrapper.Scalar.t -> steps:int -> t
Sourceval log : t -> t
Sourceval log10 : t -> t
Sourceval log10_ : t -> t
Sourceval log10_out : out:t -> t -> t
Sourceval log1p : t -> t
Sourceval log1p_ : t -> t
Sourceval log1p_out : out:t -> t -> t
Sourceval log2 : t -> t
Sourceval log2_ : t -> t
Sourceval log2_out : out:t -> t -> t
Sourceval log_ : t -> t
Sourceval log_normal_ : t -> mean:float -> std:float -> t
Sourceval log_out : out:t -> t -> t
Sourceval log_sigmoid : t -> t
Sourceval log_sigmoid_backward : grad_output:t -> t -> buffer:t -> t
Sourceval log_sigmoid_backward_out : grad_input:t -> grad_output:t -> t -> buffer:t -> t
Sourceval log_sigmoid_out : out:t -> t -> t
Sourceval log_softmax : t -> dim:int -> dtype:Torch_core.Kind.packed -> t
Sourceval logaddexp : t -> t -> t
Sourceval logaddexp2 : t -> t -> t
Sourceval logaddexp2_out : out:t -> t -> t -> t
Sourceval logaddexp_out : out:t -> t -> t -> t
Sourceval logcumsumexp : t -> dim:int -> t
Sourceval logcumsumexp_out : out:t -> t -> dim:int -> t
Sourceval logdet : t -> t
Sourceval logical_and : t -> t -> t
Sourceval logical_and_ : t -> t -> t
Sourceval logical_and_out : out:t -> t -> t -> t
Sourceval logical_not : t -> t
Sourceval logical_not_ : t -> t
Sourceval logical_not_out : out:t -> t -> t
Sourceval logical_or : t -> t -> t
Sourceval logical_or_ : t -> t -> t
Sourceval logical_or_out : out:t -> t -> t -> t
Sourceval logical_xor : t -> t -> t
Sourceval logical_xor_ : t -> t -> t
Sourceval logical_xor_out : out:t -> t -> t -> t
Sourceval logit : t -> eps:float -> t
Sourceval logit_ : t -> eps:float -> t
Sourceval logit_backward : grad_output:t -> t -> eps:float -> t
Sourceval logit_backward_out : grad_input:t -> grad_output:t -> t -> eps:float -> t
Sourceval logit_out : out:t -> t -> eps:float -> t
Sourceval logspace : start:'a Torch_core.Wrapper.Scalar.t -> end_:'a Torch_core.Wrapper.Scalar.t -> steps:int -> base:float -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval logspace_out : out:t -> start:'a Torch_core.Wrapper.Scalar.t -> end_:'a Torch_core.Wrapper.Scalar.t -> steps:int -> base:float -> t
Sourceval logsumexp : t -> dim:int list -> keepdim:bool -> t
Sourceval logsumexp_out : out:t -> t -> dim:int list -> keepdim:bool -> t
Sourceval lstm : t -> hx:t list -> params:t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> batch_first:bool -> t * t * t
Sourceval lstm1 : data:t -> batch_sizes:t -> hx:t list -> params:t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> t * t * t
Sourceval lstm_cell : t -> hx:t list -> w_ih:t -> w_hh:t -> b_ih:t option -> b_hh:t option -> t * t
Sourceval lstsq : t -> a:t -> t * t
Sourceval lstsq_out : x:t -> qr:t -> t -> a:t -> t * t
Sourceval lt1 : t -> t -> t
Sourceval lt_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval lt_1 : t -> t -> t
Sourceval lt_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval lt_out1 : out:t -> t -> t -> t
Sourceval lu_solve : t -> lu_data:t -> lu_pivots:t -> t
Sourceval lu_solve_out : out:t -> t -> lu_data:t -> lu_pivots:t -> t
Sourceval margin_ranking_loss : input1:t -> input2:t -> target:t -> margin:float -> reduction:Torch_core.Reduction.t -> t
Sourceval masked_fill : t -> mask:t -> value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval masked_fill1 : t -> mask:t -> value:t -> t
Sourceval masked_fill_ : t -> mask:t -> value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval masked_fill_1 : t -> mask:t -> value:t -> t
Sourceval masked_scatter : t -> mask:t -> source:t -> t
Sourceval masked_scatter_ : t -> mask:t -> source:t -> t
Sourceval masked_select : t -> mask:t -> t
Sourceval masked_select_backward : grad:t -> t -> mask:t -> t
Sourceval masked_select_out : out:t -> t -> mask:t -> t
Sourceval matmul : t -> t -> t
Sourceval matmul_out : out:t -> t -> t -> t
Sourceval matrix_exp : t -> t
Sourceval matrix_exp_backward : t -> grad:t -> t
Sourceval matrix_power : t -> n:int -> t
Sourceval matrix_rank : t -> symmetric:bool -> t
Sourceval matrix_rank1 : t -> tol:float -> symmetric:bool -> t
Sourceval max1 : t -> t -> t
Sourceval max2 : t -> dim:int -> keepdim:bool -> t * t
Sourceval max_out : out:t -> t -> t -> t
Sourceval max_out1 : max:t -> max_values:t -> t -> dim:int -> keepdim:bool -> t * t
Sourceval max_pool1d : t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> t
Sourceval max_pool1d_with_indices : t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> t * t
Sourceval max_pool2d_with_indices : t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> t * t
Sourceval max_pool2d_with_indices_backward : grad_output:t -> t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> indices:t -> t
Sourceval max_pool2d_with_indices_backward_out : grad_input:t -> grad_output:t -> t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> indices:t -> t
Sourceval max_pool2d_with_indices_out : out:t -> indices:t -> t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> t * t
Sourceval max_pool3d : t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> t
Sourceval max_pool3d_with_indices : t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> t * t
Sourceval max_pool3d_with_indices_backward : grad_output:t -> t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> indices:t -> t
Sourceval max_pool3d_with_indices_backward_out : grad_input:t -> grad_output:t -> t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> indices:t -> t
Sourceval max_pool3d_with_indices_out : out:t -> indices:t -> t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> t * t
Sourceval max_unpool2d : t -> indices:t -> output_size:int list -> t
Sourceval max_unpool2d_backward : grad_output:t -> t -> indices:t -> output_size:int list -> t
Sourceval max_unpool2d_backward_out : grad_input:t -> grad_output:t -> t -> indices:t -> output_size:int list -> t
Sourceval max_unpool2d_out : out:t -> t -> indices:t -> output_size:int list -> t
Sourceval max_unpool3d : t -> indices:t -> output_size:int list -> stride:int list -> padding:int list -> t
Sourceval max_unpool3d_backward : grad_output:t -> t -> indices:t -> output_size:int list -> stride:int list -> padding:int list -> t
Sourceval max_unpool3d_backward_out : grad_input:t -> grad_output:t -> t -> indices:t -> output_size:int list -> stride:int list -> padding:int list -> t
Sourceval max_unpool3d_out : out:t -> t -> indices:t -> output_size:int list -> stride:int list -> padding:int list -> t
Sourceval maximum_out : out:t -> t -> t -> t
Sourceval mean1 : t -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval mean_out : out:t -> t -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval median : t -> t
Sourceval median1 : t -> dim:int -> keepdim:bool -> t * t
Sourceval median_out : values:t -> indices:t -> t -> dim:int -> keepdim:bool -> t * t
Sourceval meshgrid : t list -> t list
Sourceval min1 : t -> t -> t
Sourceval min2 : t -> dim:int -> keepdim:bool -> t * t
Sourceval min_out : out:t -> t -> t -> t
Sourceval min_out1 : min:t -> min_indices:t -> t -> dim:int -> keepdim:bool -> t * t
Sourceval minimum_out : out:t -> t -> t -> t
Sourceval miopen_batch_norm : t -> weight:t -> bias:t option -> running_mean:t option -> running_var:t option -> training:bool -> exponential_average_factor:float -> epsilon:float -> t * t * t
Sourceval miopen_batch_norm_backward : t -> grad_output:t -> weight:t -> running_mean:t option -> running_var:t option -> save_mean:t option -> save_var:t option -> epsilon:float -> t * t * t
Sourceval miopen_convolution : t -> weight:t -> bias:t option -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> t
Sourceval miopen_convolution_backward_bias : grad_output:t -> t
Sourceval miopen_convolution_backward_input : self_size:int list -> grad_output:t -> weight:t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> t
Sourceval miopen_convolution_backward_weight : weight_size:int list -> grad_output:t -> t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> t
Sourceval miopen_convolution_transpose : t -> weight:t -> bias:t option -> padding:int list -> output_padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> t
Sourceval miopen_convolution_transpose_backward_input : grad_output:t -> weight:t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> t
Sourceval miopen_convolution_transpose_backward_weight : weight_size:int list -> grad_output:t -> t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> t
Sourceval miopen_depthwise_convolution : t -> weight:t -> bias:t option -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> t
Sourceval miopen_depthwise_convolution_backward_input : self_size:int list -> grad_output:t -> weight:t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> t
Sourceval miopen_depthwise_convolution_backward_weight : weight_size:int list -> grad_output:t -> t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> t
Sourceval miopen_rnn : t -> weight:t list -> weight_stride0:int -> hx:t -> cx:t option -> mode:int -> hidden_size:int -> num_layers:int -> batch_first:bool -> dropout:float -> train:bool -> bidirectional:bool -> batch_sizes:int list -> dropout_state:t option -> t * t * t * t * t
Sourceval mkldnn_adaptive_avg_pool2d : t -> output_size:int list -> t
Sourceval mkldnn_convolution : t -> weight:t -> bias:t option -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> t
Sourceval mkldnn_convolution_backward_input : self_size:int list -> grad_output:t -> weight:t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> bias_defined:bool -> t
Sourceval mkldnn_convolution_backward_weights : weight_size:int list -> grad_output:t -> t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> bias_defined:bool -> t * t
Sourceval mkldnn_linear : t -> weight:t -> bias:t option -> t
Sourceval mkldnn_max_pool2d : t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> t
Sourceval mkldnn_max_pool3d : t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> t
Sourceval mkldnn_reorder_conv2d_weight : t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> t
Sourceval mkldnn_reorder_conv3d_weight : t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> t
Sourceval mm_out : out:t -> t -> mat2:t -> t
Sourceval mode : t -> dim:int -> keepdim:bool -> t * t
Sourceval mode_out : values:t -> indices:t -> t -> dim:int -> keepdim:bool -> t * t
Sourceval movedim : t -> source:int list -> destination:int list -> t
Sourceval movedim1 : t -> source:int -> destination:int -> t
Sourceval mse_loss_backward : grad_output:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> t
Sourceval mse_loss_backward_out : grad_input:t -> grad_output:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> t
Sourceval mse_loss_out : out:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> t
Sourceval mul : t -> t -> t
Sourceval mul_ : t -> t -> t
Sourceval mul_out : out:t -> t -> t -> t
Sourceval multi_margin_loss_backward : grad_output:t -> t -> target:t -> p:'a Torch_core.Wrapper.Scalar.t -> margin:'a Torch_core.Wrapper.Scalar.t -> weight:t option -> reduction:Torch_core.Reduction.t -> t
Sourceval multi_margin_loss_backward_out : grad_input:t -> grad_output:t -> t -> target:t -> p:'a Torch_core.Wrapper.Scalar.t -> margin:'a Torch_core.Wrapper.Scalar.t -> weight:t option -> reduction:Torch_core.Reduction.t -> t
Sourceval multilabel_margin_loss : t -> target:t -> reduction:Torch_core.Reduction.t -> t
Sourceval multilabel_margin_loss_backward : grad_output:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> is_target:t -> t
Sourceval multilabel_margin_loss_backward_out : grad_input:t -> grad_output:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> is_target:t -> t
Sourceval multilabel_margin_loss_out : out:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> t
Sourceval multinomial : t -> num_samples:int -> replacement:bool -> t
Sourceval multinomial_out : out:t -> t -> num_samples:int -> replacement:bool -> t
Sourceval multiply : t -> t -> t
Sourceval multiply1 : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval multiply_ : t -> t -> t
Sourceval multiply_1 : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval multiply_out : out:t -> t -> t -> t
Sourceval mv : t -> vec:t -> t
Sourceval mv_out : out:t -> t -> vec:t -> t
Sourceval mvlgamma : t -> p:int -> t
Sourceval mvlgamma_ : t -> p:int -> t
Sourceval nanquantile : t -> q:float -> dim:int -> keepdim:bool -> t
Sourceval nanquantile1 : t -> q:t -> dim:int -> keepdim:bool -> t
Sourceval nanquantile_out : out:t -> t -> q:float -> dim:int -> keepdim:bool -> t
Sourceval nanquantile_out1 : out:t -> t -> q:t -> dim:int -> keepdim:bool -> t
Sourceval nansum : t -> dtype:Torch_core.Kind.packed -> t
Sourceval nansum1 : t -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval nansum_out : out:t -> t -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval narrow : t -> dim:int -> start:int -> length:int -> t
Sourceval narrow1 : t -> dim:int -> start:t -> length:int -> t
Sourceval narrow_copy : t -> dim:int -> start:int -> length:int -> t
Sourceval native_batch_norm : t -> weight:t option -> bias:t option -> running_mean:t option -> running_var:t option -> training:bool -> momentum:float -> eps:float -> t * t * t
Sourceval native_batch_norm_out : out:t -> save_mean:t -> save_invstd:t -> t -> weight:t option -> bias:t option -> running_mean:t option -> running_var:t option -> training:bool -> momentum:float -> eps:float -> t * t * t
Sourceval native_group_norm : t -> weight:t option -> bias:t option -> n:int -> c:int -> hxw:int -> group:int -> eps:float -> t * t * t
Sourceval native_layer_norm : t -> weight:t option -> bias:t option -> m:int -> n:int -> eps:float -> t * t * t
Sourceval native_norm : t -> t
Sourceval native_norm1 : t -> p:'a Torch_core.Wrapper.Scalar.t -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval ne1 : t -> t -> t
Sourceval ne_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval ne_1 : t -> t -> t
Sourceval ne_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval ne_out1 : out:t -> t -> t -> t
Sourceval neg : t -> t
Sourceval neg_ : t -> t
Sourceval neg_out : out:t -> t -> t
Sourceval negative : t -> t
Sourceval negative_ : t -> t
Sourceval negative_out : out:t -> t -> t
Sourceval new_empty : t -> size:int list -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval new_full : t -> size:int list -> fill_value:'a Torch_core.Wrapper.Scalar.t -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval new_zeros : t -> size:int list -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval nextafter : t -> t -> t
Sourceval nextafter_ : t -> t -> t
Sourceval nextafter_out : out:t -> t -> t -> t
Sourceval nll_loss2d : t -> target:t -> weight:t option -> reduction:Torch_core.Reduction.t -> ignore_index:int -> t
Sourceval nll_loss2d_backward : grad_output:t -> t -> target:t -> weight:t option -> reduction:Torch_core.Reduction.t -> ignore_index:int -> total_weight:t -> t
Sourceval nll_loss2d_backward_out : grad_input:t -> grad_output:t -> t -> target:t -> weight:t option -> reduction:Torch_core.Reduction.t -> ignore_index:int -> total_weight:t -> t
Sourceval nll_loss2d_out : out:t -> t -> target:t -> weight:t option -> reduction:Torch_core.Reduction.t -> ignore_index:int -> t
Sourceval nll_loss_backward : grad_output:t -> t -> target:t -> weight:t option -> reduction:Torch_core.Reduction.t -> ignore_index:int -> total_weight:t -> t
Sourceval nll_loss_backward_out : grad_input:t -> grad_output:t -> t -> target:t -> weight:t option -> reduction:Torch_core.Reduction.t -> ignore_index:int -> total_weight:t -> t
Sourceval nll_loss_out : out:t -> t -> target:t -> weight:t option -> reduction:Torch_core.Reduction.t -> ignore_index:int -> t
Sourceval nonzero : t -> t
Sourceval nonzero_numpy : t -> t list
Sourceval nonzero_out : out:t -> t -> t
Sourceval norm : t -> t
Sourceval norm2 : t -> p:'a Torch_core.Wrapper.Scalar.t -> dim:int list -> keepdim:bool -> t
Sourceval norm3 : t -> p:'a Torch_core.Wrapper.Scalar.t -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval norm_except_dim : v:t -> pow:int -> dim:int -> t
Sourceval norm_out : out:t -> t -> p:'a Torch_core.Wrapper.Scalar.t -> dim:int list -> keepdim:bool -> t
Sourceval norm_out1 : out:t -> t -> p:'a Torch_core.Wrapper.Scalar.t -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval normal_ : t -> mean:float -> std:float -> t
Sourceval normal_out : out:t -> mean:t -> std:float -> t
Sourceval normal_out1 : out:t -> mean:float -> std:t -> t
Sourceval normal_out2 : out:t -> mean:t -> std:t -> t
Sourceval normal_out3 : out:t -> mean:float -> std:float -> size:int list -> t
Sourceval not_equal : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval not_equal1 : t -> t -> t
Sourceval not_equal_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval not_equal_1 : t -> t -> t
Sourceval not_equal_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval not_equal_out1 : out:t -> t -> t -> t
Sourceval nuclear_norm : t -> keepdim:bool -> t
Sourceval nuclear_norm1 : t -> dim:int list -> keepdim:bool -> t
Sourceval nuclear_norm_out : out:t -> t -> keepdim:bool -> t
Sourceval nuclear_norm_out1 : out:t -> t -> dim:int list -> keepdim:bool -> t
Sourceval numpy_t : t -> t
Sourceval one_hot : t -> num_classes:int -> t
Sourceval ones_like : t -> t
Sourceval ones_out : out:t -> size:int list -> t
Sourceval orgqr : t -> input2:t -> t
Sourceval orgqr_out : out:t -> t -> input2:t -> t
Sourceval ormqr : t -> input2:t -> input3:t -> left:bool -> transpose:bool -> t
Sourceval ormqr_out : out:t -> t -> input2:t -> input3:t -> left:bool -> transpose:bool -> t
Sourceval outer : t -> vec2:t -> t
Sourceval outer_out : out:t -> t -> vec2:t -> t
Sourceval pairwise_distance : x1:t -> x2:t -> p:float -> eps:float -> keepdim:bool -> t
Sourceval pdist : t -> p:float -> t
Sourceval permute : t -> dims:int list -> t
Sourceval pin_memory : t -> t
Sourceval pinverse : t -> rcond:float -> t
Sourceval pixel_shuffle : t -> upscale_factor:int -> t
Sourceval poisson : t -> t
Sourceval poisson_nll_loss : t -> target:t -> log_input:bool -> full:bool -> eps:float -> reduction:Torch_core.Reduction.t -> t
Sourceval polar : abs:t -> angle:t -> t
Sourceval polar_out : out:t -> abs:t -> angle:t -> t
Sourceval polygamma : n:int -> t -> t
Sourceval polygamma_ : t -> n:int -> t
Sourceval polygamma_out : out:t -> n:int -> t -> t
Sourceval pow : t -> exponent:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval pow1 : t -> exponent:t -> t
Sourceval pow2 : 'a Torch_core.Wrapper.Scalar.t -> exponent:t -> t
Sourceval pow_ : t -> exponent:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval pow_1 : t -> exponent:t -> t
Sourceval pow_out : out:t -> t -> exponent:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval pow_out1 : out:t -> t -> exponent:t -> t
Sourceval pow_out2 : out:t -> 'a Torch_core.Wrapper.Scalar.t -> exponent:t -> t
Sourceval prelu : t -> weight:t -> t
Sourceval prelu_backward : grad_output:t -> t -> weight:t -> t * t
Sourceval prod : t -> dtype:Torch_core.Kind.packed -> t
Sourceval prod1 : t -> dim:int -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval prod_out : out:t -> t -> dim:int -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval put_ : t -> index:t -> source:t -> accumulate:bool -> t
Sourceval q_per_channel_scales : t -> t
Sourceval q_per_channel_zero_points : t -> t
Sourceval qr : t -> some:bool -> t * t
Sourceval qr_out : q:t -> r:t -> t -> some:bool -> t * t
Sourceval quantile : t -> q:float -> dim:int -> keepdim:bool -> t
Sourceval quantile1 : t -> q:t -> dim:int -> keepdim:bool -> t
Sourceval quantile_out : out:t -> t -> q:float -> dim:int -> keepdim:bool -> t
Sourceval quantile_out1 : out:t -> t -> q:t -> dim:int -> keepdim:bool -> t
Sourceval quantize_per_channel : t -> scales:t -> zero_points:t -> axis:int -> dtype:Torch_core.Kind.packed -> t
Sourceval quantize_per_tensor : t -> scale:float -> zero_point:int -> dtype:Torch_core.Kind.packed -> t
Sourceval quantize_per_tensor1 : t list -> scales:t -> zero_points:t -> dtype:Torch_core.Kind.packed -> t list
Sourceval quantized_batch_norm : t -> weight:t option -> bias:t option -> mean:t -> var:t -> eps:float -> output_scale:float -> output_zero_point:int -> t
Sourceval quantized_gru_cell : t -> hx:t -> w_ih:t -> w_hh:t -> b_ih:t -> b_hh:t -> packed_ih:t -> packed_hh:t -> col_offsets_ih:t -> col_offsets_hh:t -> scale_ih:'a Torch_core.Wrapper.Scalar.t -> scale_hh:'a Torch_core.Wrapper.Scalar.t -> zero_point_ih:'a Torch_core.Wrapper.Scalar.t -> zero_point_hh:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval quantized_lstm_cell : t -> hx:t list -> w_ih:t -> w_hh:t -> b_ih:t -> b_hh:t -> packed_ih:t -> packed_hh:t -> col_offsets_ih:t -> col_offsets_hh:t -> scale_ih:'a Torch_core.Wrapper.Scalar.t -> scale_hh:'a Torch_core.Wrapper.Scalar.t -> zero_point_ih:'a Torch_core.Wrapper.Scalar.t -> zero_point_hh:'a Torch_core.Wrapper.Scalar.t -> t * t
Sourceval quantized_max_pool1d : t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> t
Sourceval quantized_max_pool2d : t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> t
Sourceval quantized_rnn_relu_cell : t -> hx:t -> w_ih:t -> w_hh:t -> b_ih:t -> b_hh:t -> packed_ih:t -> packed_hh:t -> col_offsets_ih:t -> col_offsets_hh:t -> scale_ih:'a Torch_core.Wrapper.Scalar.t -> scale_hh:'a Torch_core.Wrapper.Scalar.t -> zero_point_ih:'a Torch_core.Wrapper.Scalar.t -> zero_point_hh:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval quantized_rnn_tanh_cell : t -> hx:t -> w_ih:t -> w_hh:t -> b_ih:t -> b_hh:t -> packed_ih:t -> packed_hh:t -> col_offsets_ih:t -> col_offsets_hh:t -> scale_ih:'a Torch_core.Wrapper.Scalar.t -> scale_hh:'a Torch_core.Wrapper.Scalar.t -> zero_point_ih:'a Torch_core.Wrapper.Scalar.t -> zero_point_hh:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval rad2deg : t -> t
Sourceval rad2deg_ : t -> t
Sourceval rad2deg_out : out:t -> t -> t
Sourceval rand_like : t -> t
Sourceval rand_out : out:t -> size:int list -> t
Sourceval randint : high:int -> size:int list -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval randint1 : low:int -> high:int -> size:int list -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval randint_like : t -> high:int -> t
Sourceval randint_like1 : t -> low:int -> high:int -> t
Sourceval randint_out : out:t -> high:int -> size:int list -> t
Sourceval randint_out1 : out:t -> low:int -> high:int -> size:int list -> t
Sourceval randn_like : t -> t
Sourceval randn_out : out:t -> size:int list -> t
Sourceval random_ : t -> t
Sourceval random_1 : t -> to_:int -> t
Sourceval random_2 : t -> from:int -> to_:int -> t
Sourceval randperm : n:int -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval randperm_out : out:t -> n:int -> t
Sourceval range_out : out:t -> start:'a Torch_core.Wrapper.Scalar.t -> end_:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval real : t -> t
Sourceval reciprocal : t -> t
Sourceval reciprocal_ : t -> t
Sourceval reciprocal_out : out:t -> t -> t
Sourceval reflection_pad1d : t -> padding:int list -> t
Sourceval reflection_pad1d_backward : grad_output:t -> t -> padding:int list -> t
Sourceval reflection_pad1d_backward_out : grad_input:t -> grad_output:t -> t -> padding:int list -> t
Sourceval reflection_pad1d_out : out:t -> t -> padding:int list -> t
Sourceval reflection_pad2d : t -> padding:int list -> t
Sourceval reflection_pad2d_backward : grad_output:t -> t -> padding:int list -> t
Sourceval reflection_pad2d_backward_out : grad_input:t -> grad_output:t -> t -> padding:int list -> t
Sourceval reflection_pad2d_out : out:t -> t -> padding:int list -> t
Sourceval relu : t -> t
Sourceval relu_ : t -> t
Sourceval remainder : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval remainder1 : t -> t -> t
Sourceval remainder_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval remainder_1 : t -> t -> t
Sourceval remainder_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval remainder_out1 : out:t -> t -> t -> t
Sourceval renorm : t -> p:'a Torch_core.Wrapper.Scalar.t -> dim:int -> maxnorm:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval renorm_ : t -> p:'a Torch_core.Wrapper.Scalar.t -> dim:int -> maxnorm:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval renorm_out : out:t -> t -> p:'a Torch_core.Wrapper.Scalar.t -> dim:int -> maxnorm:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval repeat : t -> repeats:int list -> t
Sourceval repeat_interleave : repeats:t -> t
Sourceval repeat_interleave1 : t -> repeats:t -> dim:int -> t
Sourceval repeat_interleave2 : t -> repeats:int -> dim:int -> t
Sourceval replication_pad1d : t -> padding:int list -> t
Sourceval replication_pad1d_backward : grad_output:t -> t -> padding:int list -> t
Sourceval replication_pad1d_backward_out : grad_input:t -> grad_output:t -> t -> padding:int list -> t
Sourceval replication_pad1d_out : out:t -> t -> padding:int list -> t
Sourceval replication_pad2d : t -> padding:int list -> t
Sourceval replication_pad2d_backward : grad_output:t -> t -> padding:int list -> t
Sourceval replication_pad2d_backward_out : grad_input:t -> grad_output:t -> t -> padding:int list -> t
Sourceval replication_pad2d_out : out:t -> t -> padding:int list -> t
Sourceval replication_pad3d : t -> padding:int list -> t
Sourceval replication_pad3d_backward : grad_output:t -> t -> padding:int list -> t
Sourceval replication_pad3d_backward_out : grad_input:t -> grad_output:t -> t -> padding:int list -> t
Sourceval replication_pad3d_out : out:t -> t -> padding:int list -> t
Sourceval requires_grad_ : t -> requires_grad:bool -> t
Sourceval reshape : t -> shape:int list -> t
Sourceval reshape_as : t -> t -> t
Sourceval resize_ : t -> size:int list -> t
Sourceval resize_as_ : t -> the_template:t -> t
Sourceval rfft : t -> signal_ndim:int -> normalized:bool -> onesided:bool -> t
Sourceval rnn_relu : t -> hx:t -> params:t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> batch_first:bool -> t * t
Sourceval rnn_relu1 : data:t -> batch_sizes:t -> hx:t -> params:t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> t * t
Sourceval rnn_relu_cell : t -> hx:t -> w_ih:t -> w_hh:t -> b_ih:t option -> b_hh:t option -> t
Sourceval rnn_tanh : t -> hx:t -> params:t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> batch_first:bool -> t * t
Sourceval rnn_tanh1 : data:t -> batch_sizes:t -> hx:t -> params:t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> t * t
Sourceval rnn_tanh_cell : t -> hx:t -> w_ih:t -> w_hh:t -> b_ih:t option -> b_hh:t option -> t
Sourceval roll : t -> shifts:int list -> dims:int list -> t
Sourceval rot90 : t -> k:int -> dims:int list -> t
Sourceval round : t -> t
Sourceval round_ : t -> t
Sourceval round_out : out:t -> t -> t
Sourceval rrelu : t -> training:bool -> t
Sourceval rrelu_ : t -> training:bool -> t
Sourceval rrelu_with_noise : t -> noise:t -> training:bool -> t
Sourceval rrelu_with_noise_ : t -> noise:t -> training:bool -> t
Sourceval rrelu_with_noise_backward : grad_output:t -> t -> noise:t -> lower:'a Torch_core.Wrapper.Scalar.t -> upper:'a Torch_core.Wrapper.Scalar.t -> training:bool -> self_is_result:bool -> t
Sourceval rrelu_with_noise_out : out:t -> t -> noise:t -> training:bool -> t
Sourceval rsqrt : t -> t
Sourceval rsqrt_ : t -> t
Sourceval rsqrt_out : out:t -> t -> t
Sourceval rsub : t -> t -> t
Sourceval scatter : t -> dim:int -> index:t -> src:t -> t
Sourceval scatter1 : t -> dim:int -> index:t -> value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval scatter_ : t -> dim:int -> index:t -> src:t -> t
Sourceval scatter_1 : t -> dim:int -> index:t -> value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval scatter_2 : t -> dim:int -> index:t -> src:t -> reduce:string -> t
Sourceval scatter_3 : t -> dim:int -> index:t -> value:'a Torch_core.Wrapper.Scalar.t -> reduce:string -> t
Sourceval scatter_add : t -> dim:int -> index:t -> src:t -> t
Sourceval scatter_add_ : t -> dim:int -> index:t -> src:t -> t
Sourceval searchsorted : sorted_sequence:t -> t -> out_int32:bool -> right:bool -> t
Sourceval searchsorted1 : sorted_sequence:t -> 'a Torch_core.Wrapper.Scalar.t -> out_int32:bool -> right:bool -> t
Sourceval searchsorted_out : out:t -> sorted_sequence:t -> t -> out_int32:bool -> right:bool -> t
Sourceval select_backward : grad:t -> input_sizes:int list -> dim:int -> index:int -> t
Sourceval selu : t -> t
Sourceval selu_ : t -> t
Sourceval set_ : t -> t
Sourceval set_1 : t -> source:t -> t
Sourceval set_requires_grad : t -> r:bool -> t
Sourceval sgn : t -> t
Sourceval sgn_ : t -> t
Sourceval sgn_out : out:t -> t -> t
Sourceval sigmoid : t -> t
Sourceval sigmoid_ : t -> t
Sourceval sigmoid_backward : grad_output:t -> output:t -> t
Sourceval sigmoid_backward_out : grad_input:t -> grad_output:t -> output:t -> t
Sourceval sigmoid_out : out:t -> t -> t
Sourceval sign : t -> t
Sourceval sign_ : t -> t
Sourceval sign_out : out:t -> t -> t
Sourceval signbit : t -> t
Sourceval signbit_out : out:t -> t -> t
Sourceval silu : t -> t
Sourceval silu_ : t -> t
Sourceval silu_backward : grad_output:t -> t -> t
Sourceval silu_out : out:t -> t -> t
Sourceval sin : t -> t
Sourceval sin_ : t -> t
Sourceval sin_out : out:t -> t -> t
Sourceval sinh : t -> t
Sourceval sinh_ : t -> t
Sourceval sinh_out : out:t -> t -> t
Sourceval slice : t -> dim:int -> start:int -> end_:int -> step:int -> t
Sourceval slice_backward : grad:t -> input_sizes:int list -> dim:int -> start:int -> end_:int -> step:int -> t
Sourceval slogdet : t -> t * t
Sourceval slow_conv3d : t -> weight:t -> kernel_size:int list -> bias:t option -> stride:int list -> padding:int list -> t
Sourceval slow_conv3d_out : out:t -> t -> weight:t -> kernel_size:int list -> bias:t option -> stride:int list -> padding:int list -> t
Sourceval slow_conv_dilated2d : t -> weight:t -> kernel_size:int list -> bias:t option -> stride:int list -> padding:int list -> dilation:int list -> t
Sourceval slow_conv_dilated3d : t -> weight:t -> kernel_size:int list -> bias:t option -> stride:int list -> padding:int list -> dilation:int list -> t
Sourceval slow_conv_transpose2d : t -> weight:t -> kernel_size:int list -> bias:t option -> stride:int list -> padding:int list -> output_padding:int list -> dilation:int list -> t
Sourceval slow_conv_transpose2d_out : out:t -> t -> weight:t -> kernel_size:int list -> bias:t option -> stride:int list -> padding:int list -> output_padding:int list -> dilation:int list -> t
Sourceval slow_conv_transpose3d : t -> weight:t -> kernel_size:int list -> bias:t option -> stride:int list -> padding:int list -> output_padding:int list -> dilation:int list -> t
Sourceval slow_conv_transpose3d_out : out:t -> t -> weight:t -> kernel_size:int list -> bias:t option -> stride:int list -> padding:int list -> output_padding:int list -> dilation:int list -> t
Sourceval smm : t -> mat2:t -> t
Sourceval smooth_l1_loss : t -> target:t -> reduction:Torch_core.Reduction.t -> beta:float -> t
Sourceval smooth_l1_loss_backward : grad_output:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> beta:float -> t
Sourceval smooth_l1_loss_backward_out : grad_input:t -> grad_output:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> beta:float -> t
Sourceval smooth_l1_loss_out : out:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> beta:float -> t
Sourceval soft_margin_loss : t -> target:t -> reduction:Torch_core.Reduction.t -> t
Sourceval soft_margin_loss_backward : grad_output:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> t
Sourceval soft_margin_loss_backward_out : grad_input:t -> grad_output:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> t
Sourceval soft_margin_loss_out : out:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> t
Sourceval softmax : t -> dim:int -> dtype:Torch_core.Kind.packed -> t
Sourceval softplus : t -> t
Sourceval softplus_backward : grad_output:t -> t -> beta:'a Torch_core.Wrapper.Scalar.t -> threshold:'a Torch_core.Wrapper.Scalar.t -> output:t -> t
Sourceval softplus_backward_out : grad_input:t -> grad_output:t -> t -> beta:'a Torch_core.Wrapper.Scalar.t -> threshold:'a Torch_core.Wrapper.Scalar.t -> output:t -> t
Sourceval softplus_out : out:t -> t -> t
Sourceval softshrink : t -> t
Sourceval softshrink_backward : grad_output:t -> t -> lambd:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval softshrink_backward_out : grad_input:t -> grad_output:t -> t -> lambd:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval softshrink_out : out:t -> t -> t
Sourceval solve : t -> a:t -> t * t
Sourceval solve_out : solution:t -> lu:t -> t -> a:t -> t * t
Sourceval sort : t -> dim:int -> descending:bool -> t * t
Sourceval sort_out : values:t -> indices:t -> t -> dim:int -> descending:bool -> t * t
Sourceval sparse_coo_tensor : size:int list -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval sparse_coo_tensor1 : indices:t -> values:t -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval sparse_coo_tensor2 : indices:t -> values:t -> size:int list -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval sparse_mask : t -> mask:t -> t
Sourceval sparse_resize_ : t -> size:int list -> sparse_dim:int -> dense_dim:int -> t
Sourceval sparse_resize_and_clear_ : t -> size:int list -> sparse_dim:int -> dense_dim:int -> t
Sourceval split : t -> split_size:int -> dim:int -> t list
Sourceval split_with_sizes : t -> split_sizes:int list -> dim:int -> t list
Sourceval sqrt : t -> t
Sourceval sqrt_ : t -> t
Sourceval sqrt_out : out:t -> t -> t
Sourceval square : t -> t
Sourceval square_ : t -> t
Sourceval squeeze : t -> t
Sourceval squeeze1 : t -> dim:int -> t
Sourceval squeeze_ : t -> t
Sourceval squeeze_1 : t -> dim:int -> t
Sourceval sspaddmm : t -> mat1:t -> mat2:t -> t
Sourceval sspaddmm_out : out:t -> t -> mat1:t -> mat2:t -> t
Sourceval stack : t list -> dim:int -> t
Sourceval stack_out : out:t -> t list -> dim:int -> t
Sourceval std : t -> unbiased:bool -> t
Sourceval std1 : t -> dim:int list -> unbiased:bool -> keepdim:bool -> t
Sourceval std_mean : t -> unbiased:bool -> t * t
Sourceval std_mean1 : t -> dim:int list -> unbiased:bool -> keepdim:bool -> t * t
Sourceval std_out : out:t -> t -> dim:int list -> unbiased:bool -> keepdim:bool -> t
Sourceval stft : t -> n_fft:int -> hop_length:int -> win_length:int -> window:t option -> normalized:bool -> onesided:bool -> return_complex:bool -> t
Sourceval sub : t -> t -> t
Sourceval sub_ : t -> t -> t
Sourceval sub_out : out:t -> t -> t -> t
Sourceval subtract : t -> t -> t
Sourceval subtract1 : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval subtract_ : t -> t -> t
Sourceval subtract_1 : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval subtract_out : out:t -> t -> t -> t
Sourceval sum1 : t -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval sum_out : out:t -> t -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval sum_to_size : t -> size:int list -> t
Sourceval svd : t -> some:bool -> compute_uv:bool -> t * t * t
Sourceval svd_out : u:t -> s:t -> v:t -> t -> some:bool -> compute_uv:bool -> t * t * t
Sourceval symeig : t -> eigenvectors:bool -> upper:bool -> t * t
Sourceval symeig_out : e:t -> v:t -> t -> eigenvectors:bool -> upper:bool -> t * t
Sourceval tr : t -> t
Sourceval t_ : t -> t
Sourceval take : t -> index:t -> t
Sourceval take_backward : grad:t -> t -> index:t -> t
Sourceval take_out : out:t -> t -> index:t -> t
Sourceval tan : t -> t
Sourceval tan_ : t -> t
Sourceval tan_out : out:t -> t -> t
Sourceval tanh : t -> t
Sourceval tanh_ : t -> t
Sourceval tanh_backward : grad_output:t -> output:t -> t
Sourceval tanh_backward_out : grad_input:t -> grad_output:t -> output:t -> t
Sourceval tanh_out : out:t -> t -> t
Sourceval tensordot : t -> t -> dims_self:int list -> dims_other:int list -> t
Sourceval threshold : t -> threshold:'a Torch_core.Wrapper.Scalar.t -> value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval threshold_ : t -> threshold:'a Torch_core.Wrapper.Scalar.t -> value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval threshold_backward : grad_output:t -> t -> threshold:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval threshold_out : out:t -> t -> threshold:'a Torch_core.Wrapper.Scalar.t -> value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval to_ : t -> device:Torch_core.Device.t -> t
Sourceval to1 : t -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> non_blocking:bool -> copy:bool -> t
Sourceval to2 : t -> dtype:Torch_core.Kind.packed -> non_blocking:bool -> copy:bool -> t
Sourceval to3 : t -> t -> non_blocking:bool -> copy:bool -> t
Sourceval to4 : t -> device:Torch_core.Device.t -> dtype:Torch_core.Kind.packed -> non_blocking:bool -> copy:bool -> t
Sourceval to_dense : t -> t
Sourceval to_dense_backward : grad:t -> t -> t
Sourceval to_mkldnn : t -> t
Sourceval to_mkldnn_backward : grad:t -> t -> t
Sourceval to_sparse : t -> t
Sourceval to_sparse1 : t -> sparse_dim:int -> t
Sourceval topk : t -> k:int -> dim:int -> largest:bool -> sorted:bool -> t * t
Sourceval topk_out : values:t -> indices:t -> t -> k:int -> dim:int -> largest:bool -> sorted:bool -> t * t
Sourceval totype : t -> scalar_type:Torch_core.Kind.packed -> t
Sourceval trace : t -> t
Sourceval trace_backward : grad:t -> sizes:int list -> t
Sourceval transpose : t -> dim0:int -> dim1:int -> t
Sourceval transpose_ : t -> dim0:int -> dim1:int -> t
Sourceval trapz : y:t -> x:t -> dim:int -> t
Sourceval trapz1 : y:t -> dx:float -> dim:int -> t
Sourceval triangular_solve : t -> a:t -> upper:bool -> transpose:bool -> unitriangular:bool -> t * t
Sourceval triangular_solve_out : x:t -> m:t -> t -> a:t -> upper:bool -> transpose:bool -> unitriangular:bool -> t * t
Sourceval tril : t -> diagonal:int -> t
Sourceval tril_ : t -> diagonal:int -> t
Sourceval tril_indices : row:int -> col:int -> offset:int -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval tril_out : out:t -> t -> diagonal:int -> t
Sourceval triplet_margin_loss : anchor:t -> positive:t -> negative:t -> margin:float -> p:float -> eps:float -> swap:bool -> reduction:Torch_core.Reduction.t -> t
Sourceval triu : t -> diagonal:int -> t
Sourceval triu_ : t -> diagonal:int -> t
Sourceval triu_indices : row:int -> col:int -> offset:int -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval triu_out : out:t -> t -> diagonal:int -> t
Sourceval true_divide : t -> t -> t
Sourceval true_divide1 : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval true_divide_ : t -> t -> t
Sourceval true_divide_1 : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval true_divide_out : out:t -> t -> t -> t
Sourceval trunc : t -> t
Sourceval trunc_ : t -> t
Sourceval trunc_out : out:t -> t -> t
Sourceval type_as : t -> t -> t
Sourceval unbind : t -> dim:int -> t list
Sourceval unflatten : t -> dim:int -> sizes:int list -> t
Sourceval unfold : t -> dimension:int -> size:int -> step:int -> t
Sourceval unfold_backward : grad_in:t -> input_sizes:int list -> dim:int -> size:int -> step:int -> t
Sourceval uniform_ : t -> from:float -> to_:float -> t
Sourceval unique_consecutive : t -> return_inverse:bool -> return_counts:bool -> dim:int -> t * t * t
Sourceval unique_dim : t -> dim:int -> sorted:bool -> return_inverse:bool -> return_counts:bool -> t * t * t
Sourceval unique_dim_consecutive : t -> dim:int -> return_inverse:bool -> return_counts:bool -> t * t * t
Sourceval unsafe_chunk : t -> chunks:int -> dim:int -> t list
Sourceval unsafe_split : t -> split_size:int -> dim:int -> t list
Sourceval unsafe_split_with_sizes : t -> split_sizes:int list -> dim:int -> t list
Sourceval unsqueeze : t -> dim:int -> t
Sourceval unsqueeze_ : t -> dim:int -> t
Sourceval upsample_bicubic2d : t -> output_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> t
Sourceval upsample_bicubic2d_backward : grad_output:t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> t
Sourceval upsample_bicubic2d_backward_out : grad_input:t -> grad_output:t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> t
Sourceval upsample_bicubic2d_out : out:t -> t -> output_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> t
Sourceval upsample_bilinear2d : t -> output_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> t
Sourceval upsample_bilinear2d_backward : grad_output:t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> t
Sourceval upsample_bilinear2d_backward_out : grad_input:t -> grad_output:t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> t
Sourceval upsample_bilinear2d_out : out:t -> t -> output_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> t
Sourceval upsample_linear1d : t -> output_size:int list -> align_corners:bool -> scales:float -> t
Sourceval upsample_linear1d_backward : grad_output:t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales:float -> t
Sourceval upsample_linear1d_backward_out : grad_input:t -> grad_output:t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales:float -> t
Sourceval upsample_linear1d_out : out:t -> t -> output_size:int list -> align_corners:bool -> scales:float -> t
Sourceval upsample_nearest1d : t -> output_size:int list -> scales:float -> t
Sourceval upsample_nearest1d_backward : grad_output:t -> output_size:int list -> input_size:int list -> scales:float -> t
Sourceval upsample_nearest1d_backward_out : grad_input:t -> grad_output:t -> output_size:int list -> input_size:int list -> scales:float -> t
Sourceval upsample_nearest1d_out : out:t -> t -> output_size:int list -> scales:float -> t
Sourceval upsample_nearest2d : t -> output_size:int list -> scales_h:float -> scales_w:float -> t
Sourceval upsample_nearest2d_backward : grad_output:t -> output_size:int list -> input_size:int list -> scales_h:float -> scales_w:float -> t
Sourceval upsample_nearest2d_backward_out : grad_input:t -> grad_output:t -> output_size:int list -> input_size:int list -> scales_h:float -> scales_w:float -> t
Sourceval upsample_nearest2d_out : out:t -> t -> output_size:int list -> scales_h:float -> scales_w:float -> t
Sourceval upsample_nearest3d : t -> output_size:int list -> scales_d:float -> scales_h:float -> scales_w:float -> t
Sourceval upsample_nearest3d_backward : grad_output:t -> output_size:int list -> input_size:int list -> scales_d:float -> scales_h:float -> scales_w:float -> t
Sourceval upsample_nearest3d_backward_out : grad_input:t -> grad_output:t -> output_size:int list -> input_size:int list -> scales_d:float -> scales_h:float -> scales_w:float -> t
Sourceval upsample_nearest3d_out : out:t -> t -> output_size:int list -> scales_d:float -> scales_h:float -> scales_w:float -> t
Sourceval upsample_trilinear3d : t -> output_size:int list -> align_corners:bool -> scales_d:float -> scales_h:float -> scales_w:float -> t
Sourceval upsample_trilinear3d_backward : grad_output:t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_d:float -> scales_h:float -> scales_w:float -> t
Sourceval upsample_trilinear3d_backward_out : grad_input:t -> grad_output:t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_d:float -> scales_h:float -> scales_w:float -> t
Sourceval upsample_trilinear3d_out : out:t -> t -> output_size:int list -> align_corners:bool -> scales_d:float -> scales_h:float -> scales_w:float -> t
Sourceval value_selecting_reduction_backward : grad:t -> dim:int -> indices:t -> sizes:int list -> keepdim:bool -> t
Sourceval values : t -> t
Sourceval vander : x:t -> n:int -> increasing:bool -> t
Sourceval var : t -> unbiased:bool -> t
Sourceval var1 : t -> dim:int list -> unbiased:bool -> keepdim:bool -> t
Sourceval var_mean : t -> unbiased:bool -> t * t
Sourceval var_mean1 : t -> dim:int list -> unbiased:bool -> keepdim:bool -> t * t
Sourceval var_out : out:t -> t -> dim:int list -> unbiased:bool -> keepdim:bool -> t
Sourceval vdot : t -> t -> t
Sourceval vdot_out : out:t -> t -> t -> t
Sourceval view : t -> size:int list -> t
Sourceval view_as : t -> t -> t
Sourceval view_as_complex : t -> t
Sourceval view_as_real : t -> t
Sourceval vstack : t list -> t
Sourceval vstack_out : out:t -> t list -> t
Sourceval where : condition:t -> t list
Sourceval where1 : condition:t -> t -> t -> t
Sourceval where2 : condition:t -> 'a Torch_core.Wrapper.Scalar.t -> t -> t
Sourceval where3 : condition:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval zero_ : t -> t
Sourceval zeros_like : t -> t
Sourceval zeros_out : out:t -> size:int list -> t
Sourceval new_tensor : unit -> t
Sourceval int_vec : ?kind:[ `int | `int16 | `int64 | `int8 | `uint8 ] -> int list -> t
Sourceval shape : t -> int list
Sourceval size : t -> int list
Sourceval shape1_exn : t -> int
Sourceval shape2_exn : t -> int * int
Sourceval shape3_exn : t -> int * int * int
Sourceval shape4_exn : t -> int * int * int * int
Sourceval requires_grad : t -> bool
Sourceval grad_set_enabled : bool -> bool
Sourceval get : t -> int -> t
Sourceval select : t -> dim:int -> index:int -> t
Sourceval float_value : t -> float
Sourceval int_value : t -> int
Sourceval float_get : t -> int list -> float
Sourceval int_get : t -> int list -> int
Sourceval float_set : t -> int list -> float -> unit
Sourceval int_set : t -> int list -> int -> unit
Sourceval fill_float : t -> float -> unit
Sourceval fill_int : t -> int -> unit
Sourceval backward : ?keep_graph:bool -> ?create_graph:bool -> t -> unit
Sourceval run_backward : ?keep_graph:bool -> ?create_graph:bool -> t list -> t list -> t list
Sourceval print : t -> unit
Sourceval to_string : t -> line_size:int -> string
Sourceval sum : t -> t
Sourceval mean : t -> t
Sourceval argmax : ?dim:int -> ?keepdim:bool -> t -> t
Sourceval defined : t -> bool
Sourceval copy_ : t -> src:t -> unit
Sourceval max : t -> t -> t
Sourceval min : t -> t -> t
Sourceval set_float2 : t -> int -> int -> float -> unit

set_float2 t i j v sets the element at index i and j of bidimensional tensor t to v.

Sourceval set_float1 : t -> int -> float -> unit

set_float1 t i v sets the element at index i of single dimension tensor t to v.

Sourceval set_int2 : t -> int -> int -> int -> unit

set_int2 t i j v sets the element at index i and j of bidimensional tensor t to v.

Sourceval set_int1 : t -> int -> int -> unit

set_int1 t i v sets the element at index i of single dimension tensor t to v.

Sourceval get_float2 : t -> int -> int -> float

get_float2 t i j returns the current value from bidimensional tensor t at index i and j.

Sourceval get_float1 : t -> int -> float

get_float1 t i j returns the current value from single dimension tensor t at index i.

Sourceval get_int2 : t -> int -> int -> int

get_int2 t i j returns the current value from bidimensional tensor t at indexex i and j.

Sourceval get_int1 : t -> int -> int

get_int1 t i j returns the current value from single dimension tensor t at index i.

Sourceval (.%{}) : t -> int list -> int

Gets an integer element from an arbitrary dimension tensor.

Sourceval (.%{}<-) : t -> int list -> int -> unit

Sets an integer element on an arbitrary dimension tensor.

Sourceval (.%.{}) : t -> int list -> float

Gets a float element from an arbitrary dimension tensor.

Sourceval (.%.{}<-) : t -> int list -> float -> unit

Sets a float element on an arbitrary dimension tensor.

Sourceval (.%[]) : t -> int -> int

Gets an integer element from a single dimension tensor.

Sourceval (.%[]<-) : t -> int -> int -> unit

Sets an integer element on a single dimension tensor.

Sourceval (.%.[]) : t -> int -> float

Gets a float element from a single dimension tensor.

Sourceval (.%.[]<-) : t -> int -> float -> unit

Sets a float element on a single dimension tensor.

Sourceval no_grad_ : t -> f:(t -> 'a) -> 'a

no_grad_ t ~f runs f on t without tracking gradients for t.

Sourceval no_grad : (unit -> 'a) -> 'a
Sourceval zero_grad : t -> unit
Sourceval (+) : t -> t -> t

Pointwise addition.

Sourceval (-) : t -> t -> t

Pointwise substraction.

Sourceval (*) : t -> t -> t

Pointwise multiplication.

Sourceval (/) : t -> t -> t

Pointwise division.

Sourceval (+=) : t -> t -> unit

t += u modifies t by adding values from u in a pointwise way.

Sourceval (-=) : t -> t -> unit

t -= u modifies t by subtracting values from u in a pointwise way.

Sourceval (*=) : t -> t -> unit

t *= u modifies t by multiplying values from u in a pointwise way.

Sourceval (/=) : t -> t -> unit

t /= u modifies t by dividing values from u in a pointwise way.

Sourceval (~-) : t -> t

~-u returns the opposite of t, i.e. the same as Tensor.(f 0. - t).

Sourceval (=) : t -> t -> t

Pointwise equality.

Sourceval eq : t -> t -> bool

eq t1 t2 returns true if t1 and t2 have the same kind, shape, and all their elements are identical.

Sourceval eq_scalar : t -> _ Scalar.t -> t
Sourceval mm : t -> t -> t

mm t1 t2 returns the dot product or matrix multiplication between t1 and t2.

Sourceval f : float -> t

f v returns a scalar tensor with value v.

Sourcetype create = ?requires_grad:bool -> ?kind:Torch_core.Kind.packed -> ?device:Torch_core.Device.t -> ?scale:float -> int list -> t
Sourceval zeros : create

Creates a tensor with value 0.

Sourceval ones : create

Creates a tensor with value 1.

Sourceval rand : create

Creates a tensor with random values sampled uniformly between 0 and 1.

Sourceval randn : create

Creates a tensor with random values sampled using a standard normal distribution.

Sourceval float_vec : ?kind:[ `double | `float | `half ] -> ?device:Torch_core.Device.t -> float list -> t

Creates a tensor from a list of float values.

Sourceval to_type : t -> type_:Torch_core.Kind.packed -> t

to_type t ~type_ returns a tensor similar to t but converted to kind type_.

Sourceval to_kind : t -> kind:Torch_core.Kind.packed -> t

to_kind t ~kind returns a tensor similar to t but converted to kind kind.

Sourceval type_ : t -> Torch_core.Kind.packed

kind t returns the kind of elements hold in tensor t.

Sourceval to_device : ?device:Torch_core.Device.t -> t -> t

to_device t ~device returns a tensor identical to t but placed on device device.

Sourceval to_float0 : t -> float option

to_float0 t returns the value hold in a scalar (0-dimension) tensor. If the dimension are incorrect, None is returned.

Sourceval to_float1 : t -> float array option

to_float1 t returns the array of values hold in a single dimension tensor. If the dimension are incorrect, None is returned.

Sourceval to_float2 : t -> float array array option

to_float2 t returns the array of values hold in a bidimensional tensor. If the dimension are incorrect, None is returned.

Sourceval to_float3 : t -> float array array array option

to_float3 t returns the array of values hold in a tridimensional tensor. If the dimension are incorrect, None is returned.

Sourceval to_float0_exn : t -> float

to_float0_exn t returns the value hold in a scalar (0-dimension) tensor.

Sourceval to_float1_exn : t -> float array

to_float1_exn t returns the array of values hold in a single dimension tensor.

Sourceval to_float2_exn : t -> float array array

to_float2_exn t returns the array of values hold in a bidimensional tensor.

Sourceval to_float3_exn : t -> float array array array

to_float3_exn t returns the array of values hold in a tridimensional tensor.

Sourceval to_int0 : t -> int option

to_int0 t returns the value hold in a scalar (0-dimension) tensor. If the dimension are incorrect, None is returned.

Sourceval to_int1 : t -> int array option

to_int1 t returns the array of values hold in a single dimension tensor. If the dimension are incorrect, None is returned.

Sourceval to_int2 : t -> int array array option

to_int2 t returns the array of values hold in a bidimensional tensor. If the dimension are incorrect, None is returned.

Sourceval to_int3 : t -> int array array array option

to_int3 t returns the array of values hold in a tridimensional tensor. If the dimension are incorrect, None is returned.

Sourceval to_int0_exn : t -> int

to_int0_exn t returns the value hold in a scalar (0-dimension) tensor.

Sourceval to_int1_exn : t -> int array

to_int1_exn t returns the array of values hold in a single dimension tensor.

Sourceval to_int2_exn : t -> int array array

to_int2_exn t returns the array of values hold in a bidimensional tensor.

Sourceval to_int3_exn : t -> int array array array

to_int3_exn t returns the array of values hold in a tridimensional tensor.

Sourceval of_float0 : ?device:Torch_core.Device.t -> float -> t

of_float0 v creates a scalar (0-dimension) tensor with value v.

Sourceval of_float1 : ?device:Torch_core.Device.t -> float array -> t

of_float1 v creates a single dimension tensor with values vs.

Sourceval of_float2 : ?device:Torch_core.Device.t -> float array array -> t

of_float2 v creates a two dimension tensor with values vs.

Sourceval of_float3 : ?device:Torch_core.Device.t -> float array array array -> t

of_float3 v creates a three dimension tensor with values vs.

Sourceval of_int0 : ?device:Torch_core.Device.t -> int -> t

of_int0 v creates a scalar (0-dimension) tensor with value v.

Sourceval of_int1 : ?device:Torch_core.Device.t -> int array -> t

of_int1 v creates a single dimension tensor with values vs.

Sourceval of_int2 : ?device:Torch_core.Device.t -> int array array -> t

of_int2 v creates a two dimension tensor with values vs.

Sourceval of_int3 : ?device:Torch_core.Device.t -> int array array array -> t

of_int3 v creates a three dimension tensor with values vs.

Sourceval conv2d : ?padding:(int * int) -> ?dilation:(int * int) -> ?groups:int -> t -> t -> t option -> stride:(int * int) -> t
Sourceval conv_transpose2d : ?output_padding:(int * int) -> ?padding:(int * int) -> ?dilation:(int * int) -> ?groups:int -> t -> t -> t option -> stride:(int * int) -> t
Sourceval max_pool2d : ?padding:(int * int) -> ?dilation:(int * int) -> ?ceil_mode:bool -> ?stride:(int * int) -> t -> ksize:(int * int) -> t
Sourceval avg_pool2d : ?padding:(int * int) -> ?count_include_pad:bool -> ?ceil_mode:bool -> ?stride:(int * int) -> ?divisor_override:int -> t -> ksize:(int * int) -> t
Sourceval const_batch_norm : ?momentum:float -> ?eps:float -> t -> t
Sourceval of_bigarray : ?device:Torch_core.Device.t -> ('a, 'b, Bigarray.c_layout) Bigarray.Genarray.t -> t

of_bigarray ba returns a tensor which shape and kind are based on ba and holding the same data.

Sourceval copy_to_bigarray : t -> ('b, 'a, Bigarray.c_layout) Bigarray.Genarray.t -> unit

copy_to_bigarray t ba copies the data from t to ba. The dimensions of ba and its kind of element must match the dimension and kind of t.

Sourceval to_bigarray : t -> kind:('a, 'b) Bigarray.kind -> ('a, 'b, Bigarray.c_layout) Bigarray.Genarray.t

to_bigarray t ~kind converts t to a bigarray using the c layout. kind has to be compatible with the element kind of t.

Sourceval cross_entropy_for_logits : ?reduction:Torch_core.Reduction.t -> t -> targets:t -> t
Sourceval dropout : t -> p:float -> is_training:bool -> t

dropout t ~p ~is_training applies dropout to t with probability p. If is_training is false, t is returned. If is_training is true, a tensor similar to t is returned except that each element has a probability p to be replaced by 0.

Sourceval nll_loss : ?reduction:Torch_core.Reduction.t -> t -> targets:t -> t
Sourceval bce_loss : ?reduction:Torch_core.Reduction.t -> t -> targets:t -> t

bce_loss t ~targets returns the binary cross entropy loss between t and targets. Elements of t are supposed to represent a probability distribution (according to the last dimension of t), so should be between 0 and 1 and sum to 1.

Sourceval bce_loss_with_logits : ?reduction:Torch_core.Reduction.t -> t -> targets:t -> t

bce_loss_with_logits t ~targets returns the binary cross entropy loss between t and targets. Elements of t are logits, a softmax is used in this function to convert them to a probability distribution.

mse_loss t1 t2 returns the square of the difference between t1 and t2. reduction can be used to either keep the whole tensor or reduce it by averaging or summing.

Sourceval mse_loss : ?reduction:Torch_core.Reduction.t -> t -> t -> t
Sourceval huber_loss : ?reduction:Torch_core.Reduction.t -> t -> t -> t
Sourceval pp : Format.formatter -> t -> unit

pp is a pretty-printer for tensors to be used in top-levels such as utop or jupyter.

Sourceval copy : t -> t

copy t returns a new copy of t with the same size and data which does not share storage with t.

Sourceval shape_str : t -> string

shape_str t returns the shape/size of the current tensor as a string. This is useful for pretty printing.

Sourceval print_shape : ?name:string -> t -> unit

print_shape ?name t prints the shape/size of t on stdout. If name is provided, this is also printed.

Sourceval minimum : t -> t

minimum t returns the minimum element of tensor t.

Sourceval maximum : t -> t

maximum t returns the maximum element of tensor t.

Sourceval flatten : t -> t

flatten t returns a flattened version of t, i.e. a single dimension version of the tensor. This is equivalent to Tensor.view t ~size:[-1].

Sourceval squeeze_last : t -> t

squeeze_last t squeezes the last dimension of t, i.e. if this dimension has a size of 1 it is removed.

Sourceval scale : t -> float -> t

scale t f returns the result of multiplying tensor t by f.

Sourceval to_list : t -> t list

to_list t returns the list of tensors extracted from the first dimension. This is the inverse of cat ~dim:0.

Sourceval min_values : t -> dim:int list -> keepdim:bool -> t
Sourceval max_values : t -> dim:int list -> keepdim:bool -> t
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct