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__tensor_ : t -> t -> t
Sourceval __iand__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __iand__tensor_ : t -> t -> t
Sourceval __ilshift__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __ilshift__tensor_ : t -> t -> t
Sourceval __ior__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __ior__tensor_ : t -> t -> t
Sourceval __irshift__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __irshift__tensor_ : t -> t -> t
Sourceval __ixor__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __ixor__tensor_ : t -> t -> t
Sourceval __lshift__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __lshift__tensor_ : t -> t -> t
Sourceval __or__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __or__tensor_ : t -> t -> t
Sourceval __rshift__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __rshift__tensor_ : t -> t -> t
Sourceval __xor__ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval __xor__tensor_ : t -> t -> t
Sourceval _adaptive_avg_pool2d : t -> output_size:int list -> t
Sourceval _adaptive_avg_pool2d_backward : grad_output:t -> t -> t
Sourceval _adaptive_avg_pool3d : t -> output_size:int list -> t
Sourceval _adaptive_avg_pool3d_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 _add_relu_scalar : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval _add_relu_scalar_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval _aminmax : t -> t * t
Sourceval _aminmax_dim : t -> dim:int -> keepdim:bool -> t * t
Sourceval _amp_update_scale_ : t -> growth_tracker: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 _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_solve_helper : t -> a:t -> upper:bool -> t
Sourceval _coalesce : t -> 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 _conj_physical : t -> t
Sourceval _conv_depthwise2d : t -> weight:t -> kernel_size:int list -> bias:t option -> stride:int list -> padding:int list -> dilation:int list -> t
Sourceval _conv_depthwise2d_backward : grad_input:t -> grad_weight:t -> grad_output:t -> t -> weight:t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> t * t
Sourceval _conv_depthwise2d_out : out:t -> t -> weight:t -> kernel_size:int list -> bias:t option -> stride:int list -> padding:int list -> dilation:int list -> t
Sourceval _convert_indices_from_coo_to_csr : t -> size:int -> out_int32:bool -> t
Sourceval _convert_indices_from_coo_to_csr_out : out:t -> t -> size:int -> out_int32:bool -> 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 -> allow_tf32:bool -> t
Sourceval _convolution_deprecated : 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 _convolution_mode : t -> weight:t -> bias:t option -> stride:int list -> padding:string -> dilation:int list -> groups:int -> 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 _copy_from_and_resize : t -> dst:t -> 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 -> proj_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 -> proj_size:int -> num_layers:int -> batch_first:bool -> bidirectional:bool -> t
Sourceval _det_lu_based_helper : t -> t * t * t
Sourceval _det_lu_based_helper_backward_helper : det_grad:t -> det:t -> t -> lu:t -> pivs:t -> 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 -> padding_idx:int -> 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 -> padding_idx:int -> t
Sourceval _embedding_bag_dense_backward : grad:t -> indices:t -> offset2bag:t -> bag_size:t -> maximum_indices:t -> num_weights:int -> scale_grad_by_freq:bool -> mode:int -> per_sample_weights:t option -> padding_idx:int -> 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 -> padding_idx:int -> t * t * t * t
Sourceval _embedding_bag_per_sample_weights_backward : grad:t -> weight:t -> indices:t -> offsets:t -> offset2bag:t -> mode:int -> padding_idx: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 -> padding_idx:int -> 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 -> grad_factor:float -> 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 -> grad_factor:float -> t * t * t
Sourceval _fake_quantize_learnable_per_tensor_affine : t -> scale:t -> zero_point:t -> quant_min:int -> quant_max:int -> grad_factor:float -> t
Sourceval _fake_quantize_learnable_per_tensor_affine_backward : grad:t -> t -> scale:t -> zero_point:t -> quant_min:int -> quant_max:int -> grad_factor:float -> t * t * t
Sourceval _fake_quantize_per_tensor_affine_cachemask_tensor_qparams : t -> scale:t -> zero_point:t -> fake_quant_enabled:t -> quant_min:int -> quant_max:int -> t * t
Sourceval _fft_c2c : t -> dim:int list -> normalization:int -> forward:bool -> t
Sourceval _fft_c2c_out : out:t -> t -> dim:int list -> normalization:int -> forward:bool -> t
Sourceval _fft_c2r : t -> dim:int list -> normalization:int -> last_dim_size:int -> t
Sourceval _fft_c2r_out : out:t -> t -> dim:int list -> normalization:int -> last_dim_size:int -> t
Sourceval _fft_r2c : t -> dim:int list -> normalization:int -> onesided:bool -> t
Sourceval _fft_r2c_out : out:t -> t -> dim:int list -> normalization:int -> onesided:bool -> t
Sourceval _fused_dropout : t -> p:float -> t * t
Sourceval _fused_moving_avg_obs_fq_helper : t -> observer_on:t -> fake_quant_on:t -> running_min:t -> running_max:t -> scale:t -> zero_point:t -> averaging_const:float -> quant_min:int -> quant_max:int -> ch_axis:int -> per_row_fake_quant:bool -> symmetric_quant:bool -> t * t
Sourceval _fw_primal : t -> level:int -> 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 option list -> values:t -> accumulate:bool -> unsafe:bool -> t
Sourceval _indices : t -> t
Sourceval _inverse_helper : t -> t
Sourceval _linalg_inv_out_helper_ : t -> infos_lu:t -> infos_getri:t -> t
Sourceval _linalg_qr_helper : t -> mode:string -> 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 _log_softmax_backward_data_out : out:t -> grad_output:t -> output:t -> dim:int -> t -> t
Sourceval _log_softmax_out : out:t -> t -> dim:int -> half_to_float:bool -> t
Sourceval _logcumsumexp : t -> dim:int -> t
Sourceval _logcumsumexp_out : out:t -> t -> dim:int -> t
Sourceval _lu_with_info : t -> pivot:bool -> check_errors:bool -> t * t * t
Sourceval _make_dual : primal:t -> tangent:t -> level:int -> 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 _neg_view : 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 _pin_memory : t -> device:Torch_core.Device.t -> t
Sourceval _remove_batch_dim : t -> level:int -> batch_size:int -> out_dim:int -> t
Sourceval _reshape_alias : t -> size:int list -> stride:int list -> t
Sourceval _reshape_from_tensor : t -> shape:t -> t
Sourceval _rowwise_prune : weight:t -> mask:t -> compressed_indices_dtype:Torch_core.Kind.packed -> t * t
Sourceval _s_where : condition:t -> t -> t -> t
Sourceval _sample_dirichlet : t -> t
Sourceval _saturate_weight_to_fp16 : weight:t -> t
Sourceval _segment_reduce_backward : grad:t -> output:t -> data:t -> reduce:string -> lengths:t option -> axis:int -> 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 _softmax_backward_data_out : grad_input:t -> grad_output:t -> output:t -> dim:int -> t -> t
Sourceval _softmax_out : out:t -> t -> dim:int -> half_to_float:bool -> 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_csr_tensor_unsafe : crow_indices:t -> col_indices:t -> values:t -> size:int list -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval _sparse_log_softmax : 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_log_softmax_int : t -> dim:int -> dtype:Torch_core.Kind.packed -> t
Sourceval _sparse_mask_helper : tr:t -> mask_indices:t -> t
Sourceval _sparse_mm : sparse:t -> dense:t -> t
Sourceval _sparse_softmax : t -> dim:int -> half_to_float:bool -> t
Sourceval _sparse_softmax_backward_data : grad_output:t -> output:t -> dim:int -> t -> t
Sourceval _sparse_softmax_int : t -> dim:int -> dtype:Torch_core.Kind.packed -> t
Sourceval _sparse_sparse_matmul : t -> t -> t
Sourceval _sparse_sum : t -> t
Sourceval _sparse_sum_backward : grad:t -> t -> dim:int list -> t
Sourceval _sparse_sum_dim : t -> dim:int list -> t
Sourceval _sparse_sum_dim_dtype : t -> dim:int list -> dtype:Torch_core.Kind.packed -> t
Sourceval _sparse_sum_dtype : t -> dtype:Torch_core.Kind.packed -> t
Sourceval _stack : t list -> dim:int -> t
Sourceval _stack_out : out:t -> t list -> dim:int -> t
Sourceval _standard_gamma : t -> t
Sourceval _standard_gamma_grad : t -> output:t -> 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_ambiguous_defaults : dummy:t -> a:int -> b:int -> t
Sourceval _test_ambiguous_defaults_b : dummy:t -> a:int -> b:string -> 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 _test_string_default : dummy:t -> a:string -> b:string -> 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 _to_copy : t -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> non_blocking:bool -> t
Sourceval _to_cpu : t list -> t list
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 _unpack_dual : dual:t -> level:int -> t * t
Sourceval _unsafe_view : t -> size:int list -> t
Sourceval _values : t -> 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_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_grad_input : 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_grad_input : 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 add_scalar : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval add_scalar_ : t -> 'a Torch_core.Wrapper.Scalar.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 all_all_out : out:t -> t -> t
Sourceval all_dim : 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 aminmax : t -> dim:int -> keepdim:bool -> t * t
Sourceval aminmax_out : min:t -> max:t -> t -> dim:int -> keepdim:bool -> t * t
Sourceval angle : t -> t
Sourceval angle_out : out:t -> t -> t
Sourceval any : t -> t
Sourceval any_all_out : out:t -> t -> t
Sourceval any_dim : 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_start_out : 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 argmax_out : out:t -> t -> dim:int -> keepdim:bool -> t
Sourceval argmin : t -> dim:int -> keepdim:bool -> t
Sourceval argmin_out : out:t -> 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_1d_sequence : t list -> t list
Sourceval atleast_2d : t -> t
Sourceval atleast_2d_sequence : t list -> t list
Sourceval atleast_3d : t -> t
Sourceval atleast_3d_sequence : 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_grad_input : 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_grad_input : 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_window_periodic : 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 -> count: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 bernoulli_ : t -> p:t -> t
Sourceval bernoulli_float_ : t -> p:float -> t
Sourceval bernoulli_out : out:t -> t -> t
Sourceval bernoulli_p : t -> p:float -> 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_grad_input : 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_and_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_and_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_and_tensor : t -> t -> t
Sourceval bitwise_and_tensor_ : t -> t -> t
Sourceval bitwise_and_tensor_out : out:t -> t -> t -> t
Sourceval bitwise_left_shift : t -> t -> t
Sourceval bitwise_left_shift_ : t -> t -> t
Sourceval bitwise_left_shift_scalar_tensor : 'a Torch_core.Wrapper.Scalar.t -> t -> t
Sourceval bitwise_left_shift_tensor_out : out:t -> t -> t -> t
Sourceval bitwise_left_shift_tensor_scalar : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_left_shift_tensor_scalar_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_left_shift_tensor_scalar_out : 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_or_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_or_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_or_tensor : t -> t -> t
Sourceval bitwise_or_tensor_ : t -> t -> t
Sourceval bitwise_or_tensor_out : out:t -> t -> t -> t
Sourceval bitwise_right_shift : t -> t -> t
Sourceval bitwise_right_shift_ : t -> t -> t
Sourceval bitwise_right_shift_scalar_tensor : 'a Torch_core.Wrapper.Scalar.t -> t -> t
Sourceval bitwise_right_shift_tensor_out : out:t -> t -> t -> t
Sourceval bitwise_right_shift_tensor_scalar : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_right_shift_tensor_scalar_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_right_shift_tensor_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_xor : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_xor_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_xor_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval bitwise_xor_tensor : t -> t -> t
Sourceval bitwise_xor_tensor_ : t -> t -> t
Sourceval bitwise_xor_tensor_out : out:t -> t -> t -> t
Sourceval blackman_window : window_length:int -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval blackman_window_periodic : 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 broadcast_to : t -> size:int list -> t
Sourceval bucketize : t -> boundaries:t -> out_int32:bool -> right:bool -> t
Sourceval bucketize_scalar : 'a Torch_core.Wrapper.Scalar.t -> boundaries:t -> out_int32:bool -> right:bool -> t
Sourceval bucketize_tensor_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 chain_matmul_out : out:t -> 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 choose_qparams_optimized : t -> numel:int -> n_bins:int -> ratio:float -> bit_width:int -> t * 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_max_tensor : t -> max:t -> t
Sourceval clamp_max_tensor_ : t -> max:t -> t
Sourceval clamp_max_tensor_out : out:t -> t -> max: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_min_tensor : t -> min:t -> t
Sourceval clamp_min_tensor_ : t -> min:t -> t
Sourceval clamp_min_tensor_out : out:t -> t -> min:t -> t
Sourceval clamp_out : out:t -> t -> min:'a Torch_core.Wrapper.Scalar.t -> max:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval clamp_tensor : t -> min:t option -> max:t option -> t
Sourceval clamp_tensor_ : t -> min:t option -> max:t option -> t
Sourceval clamp_tensor_out : out:t -> t -> min:t option -> max:t option -> 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 clip_tensor : t -> min:t option -> max:t option -> t
Sourceval clip_tensor_ : t -> min:t option -> max:t option -> t
Sourceval clip_tensor_out : out:t -> t -> min:t option -> max:t option -> 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_grad_input : 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 col_indices : t -> t
Sourceval column_stack : t list -> t
Sourceval column_stack_out : out:t -> t 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 concat : t list -> dim:int -> t
Sourceval concat_out : out:t -> t list -> dim:int -> t
Sourceval conj : t -> t
Sourceval conj_physical : t -> t
Sourceval conj_physical_ : t -> t
Sourceval conj_physical_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 conv1d_padding : t -> weight:t -> bias:t option -> stride:int list -> padding:string -> dilation:int list -> groups:int -> t
Sourceval conv2d_padding : t -> weight:t -> bias:t option -> stride:int list -> padding:string -> 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 conv3d_padding : t -> weight:t -> bias:t option -> stride:int list -> padding:string -> dilation:int list -> groups:int -> t
Sourceval conv_depthwise3d : t -> weight:t -> kernel_size:int list -> bias:t option -> stride:int list -> padding:int list -> dilation:int list -> t
Sourceval conv_depthwise3d_backward : grad_input:t -> grad_weight:t -> grad_bias:t -> grad_output:t -> t -> weight:t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> t * t * 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 copysign : t -> t -> t
Sourceval copysign_ : t -> t -> t
Sourceval copysign_out : out:t -> t -> t -> t
Sourceval copysign_scalar : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval copysign_scalar_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval copysign_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval corrcoef : t -> 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 cov : t -> correction:int -> fweights:t option -> aweights:t option -> t
Sourceval cross : t -> t -> dim:int -> t
Sourceval cross_entropy_loss : t -> target:t -> weight:t option -> reduction:Torch_core.Reduction.t -> ignore_index:int -> label_smoothing:float -> t
Sourceval cross_out : out:t -> t -> t -> dim:int -> t
Sourceval crow_indices : t -> 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_loss_tensor : 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 -> allow_tf32:bool -> t
Sourceval cudnn_convolution_add_relu : t -> weight:t -> z:t -> alpha:'a Torch_core.Wrapper.Scalar.t -> bias:t option -> stride:int list -> padding:int list -> dilation:int list -> groups:int -> 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_deprecated : t -> weight:t -> bias:t option -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> t
Sourceval cudnn_convolution_deprecated2 : t -> weight:t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> t
Sourceval cudnn_convolution_relu : t -> weight:t -> bias:t option -> stride:int list -> padding:int list -> dilation:int list -> groups:int -> 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 -> 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_convolution_transpose_deprecated : 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_transpose_deprecated2 : 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_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_ : t -> dim:int -> dtype:Torch_core.Kind.packed -> t
Sourceval cumprod_backward : grad:t -> t -> dim:int -> output:t -> 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_ : t -> dim:int -> dtype:Torch_core.Kind.packed -> t
Sourceval cumsum_out : out:t -> t -> dim:int -> dtype:Torch_core.Kind.packed -> t
Sourceval cumulative_trapezoid : y:t -> dim:int -> t
Sourceval cumulative_trapezoid_x : y:t -> x:t -> dim:int -> 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 dequantize_tensors : 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_output:t -> input_sizes:int list -> offset:int -> dim1:int -> dim2:int -> t
Sourceval diff : t -> n:int -> dim:int -> prepend:t option -> append:t option -> t
Sourceval diff_out : out:t -> t -> n:int -> dim:int -> prepend:t option -> append:t option -> 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 div_out_mode : out:t -> t -> t -> rounding_mode:string -> t
Sourceval div_scalar : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval div_scalar_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval div_scalar_mode : t -> 'a Torch_core.Wrapper.Scalar.t -> rounding_mode:string -> t
Sourceval div_scalar_mode_ : t -> 'a Torch_core.Wrapper.Scalar.t -> rounding_mode:string -> t
Sourceval div_tensor_mode : t -> t -> rounding_mode:string -> t
Sourceval div_tensor_mode_ : t -> t -> rounding_mode:string -> t
Sourceval divide : t -> t -> t
Sourceval divide_ : t -> t -> t
Sourceval divide_out : out:t -> t -> t -> t
Sourceval divide_out_mode : out:t -> t -> t -> rounding_mode:string -> t
Sourceval divide_scalar : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval divide_scalar_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval divide_scalar_mode : t -> 'a Torch_core.Wrapper.Scalar.t -> rounding_mode:string -> t
Sourceval divide_scalar_mode_ : t -> 'a Torch_core.Wrapper.Scalar.t -> rounding_mode:string -> t
Sourceval divide_tensor_mode : t -> t -> rounding_mode:string -> t
Sourceval divide_tensor_mode_ : t -> t -> rounding_mode:string -> t
Sourceval dot : t -> t -> t
Sourceval dot_out : out:t -> t -> t -> t
Sourceval dropout_ : t -> p:float -> train:bool -> t
Sourceval dsplit : t -> sections:int -> t list
Sourceval dsplit_array : t -> indices:int list -> t list
Sourceval dstack : t list -> t
Sourceval dstack_out : out:t -> t list -> t
Sourceval eig : t -> eigenvectors:bool -> t * t
Sourceval eig_e : 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 -> is_result:bool -> self_or_result:t -> t
Sourceval elu_backward_grad_input : 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 -> is_result:bool -> self_or_result: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_bag_padding_idx : weight:t -> indices:t -> offsets:t -> scale_grad_by_freq:bool -> mode:int -> sparse:bool -> per_sample_weights:t option -> include_last_offset:bool -> padding_idx:int -> 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_out : out:t -> size:int list -> t
Sourceval empty_quantized : size:int list -> qtensor:t -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval empty_strided : size:int list -> stride:int list -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval eq_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval eq_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval eq_tensor : t -> t -> t
Sourceval eq_tensor_ : t -> t -> t
Sourceval eq_tensor_out : 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 eye_m : n:int -> m:int -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval eye_m_out : out:t -> n:int -> m:int -> t
Sourceval eye_out : out:t -> n: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_cachemask : t -> scale:t -> zero_point:t -> axis:int -> quant_min:int -> quant_max:int -> t * t
Sourceval fake_quantize_per_channel_affine_cachemask_backward : grad:t -> mask:t -> 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_cachemask : t -> scale:float -> zero_point:int -> quant_min:int -> quant_max:int -> t * t
Sourceval fake_quantize_per_tensor_affine_cachemask_backward : grad:t -> mask:t -> t
Sourceval fake_quantize_per_tensor_affine_tensor_qparams : t -> scale:t -> zero_point:t -> 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_matrix_kn : 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_fft : t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_fft2 : t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_fft2_out : out:t -> t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_fft_out : out:t -> t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_fftfreq : n:int -> d:float -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval fft_fftfreq_out : out:t -> n:int -> d:float -> t
Sourceval fft_fftn : t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_fftn_out : out:t -> t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_fftshift : t -> dim:int list -> t
Sourceval fft_hfft : t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_hfft_out : out:t -> t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_ifft : t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_ifft2 : t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_ifft2_out : out:t -> t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_ifft_out : out:t -> t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_ifftn : t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_ifftn_out : out:t -> t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_ifftshift : t -> dim:int list -> t
Sourceval fft_ihfft : t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_ihfft_out : out:t -> t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_irfft : t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_irfft2 : t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_irfft2_out : out:t -> t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_irfft_out : out:t -> t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_irfftn : t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_irfftn_out : out:t -> t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_rfft : t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_rfft2 : t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_rfft2_out : out:t -> t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_rfft_out : out:t -> t -> n:int -> dim:int -> norm:string -> t
Sourceval fft_rfftfreq : n:int -> d:float -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval fft_rfftfreq_out : out:t -> n:int -> d:float -> t
Sourceval fft_rfftn : t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fft_rfftn_out : out:t -> t -> s:int list -> dim:int list -> norm:string -> t
Sourceval fill_ : t -> value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval fill_diagonal_ : t -> fill_value:'a Torch_core.Wrapper.Scalar.t -> wrap:bool -> t
Sourceval fill_tensor_ : t -> value:t -> t
Sourceval fix : t -> t
Sourceval fix_ : t -> t
Sourceval fix_out : out:t -> t -> t
Sourceval flatten_dense_tensors : t list -> t
Sourceval flip : t -> dims:int list -> t
Sourceval fliplr : t -> t
Sourceval flipud : t -> t
Sourceval float_power : t -> exponent:t -> t
Sourceval float_power_ : t -> exponent:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval float_power_scalar : 'a Torch_core.Wrapper.Scalar.t -> exponent:t -> t
Sourceval float_power_scalar_out : out:t -> 'a Torch_core.Wrapper.Scalar.t -> exponent:t -> t
Sourceval float_power_tensor_ : t -> exponent:t -> t
Sourceval float_power_tensor_scalar : t -> exponent:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval float_power_tensor_scalar_out : out:t -> t -> exponent:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval float_power_tensor_tensor_out : out:t -> t -> exponent:t -> t
Sourceval floor : t -> t
Sourceval floor_ : t -> t
Sourceval floor_divide : t -> t -> t
Sourceval floor_divide_ : t -> t -> t
Sourceval floor_divide_out : out:t -> t -> t -> t
Sourceval floor_divide_scalar : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval floor_divide_scalar_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval floor_out : out:t -> t -> t
Sourceval fmax : t -> t -> t
Sourceval fmax_out : out:t -> t -> t -> t
Sourceval fmin : t -> t -> t
Sourceval fmin_out : out:t -> t -> t -> t
Sourceval fmod_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval fmod_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval fmod_tensor : t -> t -> t
Sourceval fmod_tensor_ : t -> t -> t
Sourceval fmod_tensor_out : 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_grad_input : grad_input:t -> grad_output:t -> t -> kernel_size:int list -> output_size:int list -> indices:t -> t
Sourceval fractional_max_pool2d_output : 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_grad_input : grad_input:t -> grad_output:t -> t -> kernel_size:int list -> output_size:int list -> indices:t -> t
Sourceval fractional_max_pool3d_output : output:t -> indices:t -> t -> kernel_size:int list -> output_size:int list -> random_samples:t -> t * t
Sourceval frexp : t -> t * t
Sourceval frexp_tensor_out : mantissa:t -> exponent:t -> t -> t * t
Sourceval frobenius_norm : t -> t
Sourceval frobenius_norm_dim : 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 fused_moving_avg_obs_fake_quant : t -> observer_on:t -> fake_quant_on:t -> running_min:t -> running_max:t -> scale:t -> zero_point:t -> averaging_const:float -> quant_min:int -> quant_max:int -> ch_axis:int -> per_row_fake_quant:bool -> symmetric_quant:bool -> 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 ge_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval ge_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval ge_tensor : t -> t -> t
Sourceval ge_tensor_ : t -> t -> t
Sourceval ge_tensor_out : out:t -> t -> t -> t
Sourceval gelu : t -> t
Sourceval gelu_backward : grad:t -> t -> t
Sourceval gelu_backward_grad_input : grad_input:t -> grad:t -> t -> t
Sourceval gelu_out : out:t -> t -> t
Sourceval geometric_ : t -> p:float -> t
Sourceval geqrf : t -> t * t
Sourceval geqrf_a : 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_grad_input : 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 greater_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval greater_equal : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval greater_equal_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval greater_equal_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval greater_equal_tensor : t -> t -> t
Sourceval greater_equal_tensor_ : t -> t -> t
Sourceval greater_equal_tensor_out : out:t -> t -> t -> t
Sourceval greater_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval greater_tensor : t -> t -> t
Sourceval greater_tensor_ : t -> t -> t
Sourceval greater_tensor_out : 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 gru_cell : t -> hx:t -> w_ih:t -> w_hh:t -> b_ih:t option -> b_hh:t option -> t
Sourceval gru_data : 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 gt_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval gt_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval gt_tensor : t -> t -> t
Sourceval gt_tensor_ : t -> t -> t
Sourceval gt_tensor_out : out:t -> t -> t -> t
Sourceval hamming_window : window_length:int -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval hamming_window_periodic : window_length:int -> periodic:bool -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval hamming_window_periodic_alpha : window_length:int -> periodic:bool -> alpha:float -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval hamming_window_periodic_alpha_beta : 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_window_periodic : 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 hardshrink_backward_grad_input : grad_input:t -> grad_out:t -> t -> lambd:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval hardshrink_out : out:t -> t -> t
Sourceval hardsigmoid : t -> t
Sourceval hardsigmoid_ : t -> t
Sourceval hardsigmoid_backward : grad_output:t -> t -> t
Sourceval hardsigmoid_backward_grad_input : grad_input:t -> 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_grad_input : 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 hsplit : t -> sections:int -> t list
Sourceval hsplit_array : t -> indices:int list -> t list
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 huber_loss_backward : grad_output:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> delta:float -> t
Sourceval huber_loss_backward_out : grad_input:t -> grad_output:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> delta:float -> t
Sourceval huber_loss_out : out:t -> t -> target:t -> reduction:Torch_core.Reduction.t -> delta:float -> 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 igamma : t -> t -> t
Sourceval igamma_ : t -> t -> t
Sourceval igamma_out : out:t -> t -> t -> t
Sourceval igammac : t -> t -> t
Sourceval igammac_ : t -> t -> t
Sourceval igammac_out : out:t -> t -> t -> 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_grad_input : 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 option 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_add_alpha : t -> dim:int -> index:t -> source:t -> alpha:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval index_add_alpha_ : t -> dim:int -> index:t -> source:t -> alpha:'a Torch_core.Wrapper.Scalar.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_fill_ : t -> dim:int -> index:t -> value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval index_fill_int_tensor : t -> dim:int -> index:t -> value:t -> t
Sourceval index_fill_int_tensor_ : t -> dim:int -> index:t -> value:t -> t
Sourceval index_put : t -> indices:t option list -> values:t -> accumulate:bool -> t
Sourceval index_put_ : t -> indices:t option 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 inner : t -> t -> t
Sourceval inner_out : out:t -> 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 isclose : t -> t -> rtol:float -> atol:float -> equal_nan:bool -> t
Sourceval isfinite : t -> t
Sourceval isin : elements:t -> test_elements:t -> assume_unique:bool -> invert:bool -> t
Sourceval isin_scalar_tensor : element:'a Torch_core.Wrapper.Scalar.t -> test_elements:t -> assume_unique:bool -> invert:bool -> t
Sourceval isin_scalar_tensor_out : out:t -> element:'a Torch_core.Wrapper.Scalar.t -> test_elements:t -> assume_unique:bool -> invert:bool -> t
Sourceval isin_tensor_scalar : elements:t -> test_element:'a Torch_core.Wrapper.Scalar.t -> assume_unique:bool -> invert:bool -> t
Sourceval isin_tensor_scalar_out : out:t -> elements:t -> test_element:'a Torch_core.Wrapper.Scalar.t -> assume_unique:bool -> invert:bool -> t
Sourceval isin_tensor_tensor_out : out:t -> elements:t -> test_elements:t -> assume_unique:bool -> invert:bool -> 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_window_beta : window_length:int -> periodic:bool -> beta:float -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval kaiser_window_periodic : window_length:int -> periodic:bool -> 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 kron : t -> t -> t
Sourceval kron_out : out:t -> t -> t -> t
Sourceval kthvalue : t -> k:int -> dim:int -> keepdim:bool -> t * t
Sourceval kthvalue_values : 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_grad_input : 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 ldexp : t -> t -> t
Sourceval ldexp_ : t -> t -> t
Sourceval ldexp_out : out:t -> t -> t -> t
Sourceval le_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval le_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval le_tensor : t -> t -> t
Sourceval le_tensor_ : t -> t -> t
Sourceval le_tensor_out : 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_backward_grad_input : grad_input:t -> 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 lerp_ : t -> end_:t -> weight:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval lerp_scalar_out : out:t -> t -> end_:t -> weight:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval lerp_tensor : t -> end_:t -> weight:t -> t
Sourceval lerp_tensor_ : t -> end_:t -> weight:t -> t
Sourceval lerp_tensor_out : out:t -> t -> end_:t -> weight:t -> t
Sourceval less_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval less_equal : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval less_equal_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval less_equal_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval less_equal_tensor : t -> t -> t
Sourceval less_equal_tensor_ : t -> t -> t
Sourceval less_equal_tensor_out : out:t -> t -> t -> t
Sourceval less_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval less_tensor : t -> t -> t
Sourceval less_tensor_ : t -> t -> t
Sourceval less_tensor_out : out:t -> t -> t -> t
Sourceval lgamma : t -> t
Sourceval lgamma_ : t -> t
Sourceval lgamma_out : out:t -> t -> t
Sourceval linalg_cholesky : t -> upper:bool -> t
Sourceval linalg_cholesky_ex : t -> upper:bool -> check_errors:bool -> t * t
Sourceval linalg_cholesky_ex_l : l:t -> info:t -> t -> upper:bool -> check_errors:bool -> t * t
Sourceval linalg_cholesky_out : out:t -> t -> upper:bool -> t
Sourceval linalg_cond : t -> p:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval linalg_cond_out : out:t -> t -> p:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval linalg_cond_p_str : t -> p:string -> t
Sourceval linalg_cond_p_str_out : out:t -> t -> p:string -> t
Sourceval linalg_det : t -> t
Sourceval linalg_det_out : out:t -> t -> t
Sourceval linalg_eig : t -> t * t
Sourceval linalg_eig_out : eigenvalues:t -> eigenvectors:t -> t -> t * t
Sourceval linalg_eigh : t -> uplo:string -> t * t
Sourceval linalg_eigh_eigvals : eigvals:t -> eigvecs:t -> t -> uplo:string -> t * t
Sourceval linalg_eigvals : t -> t
Sourceval linalg_eigvals_out : out:t -> t -> t
Sourceval linalg_eigvalsh : t -> uplo:string -> t
Sourceval linalg_eigvalsh_out : out:t -> t -> uplo:string -> t
Sourceval linalg_householder_product : t -> tau:t -> t
Sourceval linalg_householder_product_out : out:t -> t -> tau:t -> t
Sourceval linalg_inv : t -> t
Sourceval linalg_inv_ex : t -> check_errors:bool -> t * t
Sourceval linalg_inv_ex_inverse : inverse:t -> info:t -> t -> check_errors:bool -> t * t
Sourceval linalg_inv_out : out:t -> t -> t
Sourceval linalg_lstsq : t -> b:t -> rcond:float -> driver:string -> t * t * t * t
Sourceval linalg_lstsq_out : solution:t -> residuals:t -> rank:t -> singular_values:t -> t -> b:t -> rcond:float -> driver:string -> t * t * t * t
Sourceval linalg_matmul : t -> t -> t
Sourceval linalg_matmul_out : out:t -> t -> t -> t
Sourceval linalg_matrix_power : t -> n:int -> t
Sourceval linalg_matrix_power_out : out:t -> t -> n:int -> t
Sourceval linalg_matrix_rank : t -> tol:float -> hermitian:bool -> t
Sourceval linalg_matrix_rank_out : out:t -> t -> tol:float -> hermitian:bool -> t
Sourceval linalg_matrix_rank_out_tol_tensor : out:t -> t -> tol:t -> hermitian:bool -> t
Sourceval linalg_matrix_rank_tol_tensor : t -> tol:t -> hermitian:bool -> t
Sourceval linalg_multi_dot : t list -> t
Sourceval linalg_multi_dot_out : out:t -> t list -> t
Sourceval linalg_pinv : t -> rcond:float -> hermitian:bool -> t
Sourceval linalg_pinv_out : out:t -> t -> rcond:float -> hermitian:bool -> t
Sourceval linalg_pinv_out_rcond_tensor : out:t -> t -> rcond:t -> hermitian:bool -> t
Sourceval linalg_pinv_rcond_tensor : t -> rcond:t -> hermitian:bool -> t
Sourceval linalg_qr : t -> mode:string -> t * t
Sourceval linalg_qr_out : q:t -> r:t -> t -> mode:string -> t * t
Sourceval linalg_slogdet : t -> t * t
Sourceval linalg_slogdet_out : sign:t -> logabsdet:t -> t -> t * t
Sourceval linalg_solve : t -> t -> t
Sourceval linalg_solve_out : out:t -> t -> t -> t
Sourceval linalg_svd : t -> full_matrices:bool -> t * t * t
Sourceval linalg_svd_u : u:t -> s:t -> vh:t -> t -> full_matrices:bool -> t * t * t
Sourceval linalg_svdvals : t -> t
Sourceval linalg_svdvals_out : out:t -> t -> t
Sourceval linalg_tensorinv : t -> ind:int -> t
Sourceval linalg_tensorinv_out : out:t -> t -> ind:int -> t
Sourceval linalg_tensorsolve : t -> t -> dims:int list -> t
Sourceval linalg_tensorsolve_out : out:t -> t -> t -> dims:int list -> t
Sourceval linear : t -> weight:t -> bias:t option -> t
Sourceval linear_out : out:t -> 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_grad_input : 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_grad_input : 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 lstm_cell : t -> hx:t list -> w_ih:t -> w_hh:t -> b_ih:t option -> b_hh:t option -> t * t
Sourceval lstm_data : 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 lstsq : t -> a:t -> t * t
Sourceval lstsq_x : x:t -> qr:t -> t -> a:t -> t * t
Sourceval lt_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval lt_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval lt_tensor : t -> t -> t
Sourceval lt_tensor_ : t -> t -> t
Sourceval lt_tensor_out : 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 lu_unpack : lu_data:t -> lu_pivots:t -> unpack_data:bool -> unpack_pivots:bool -> t * t * t
Sourceval lu_unpack_out : p:t -> l:t -> u:t -> lu_data:t -> lu_pivots:t -> unpack_data:bool -> unpack_pivots:bool -> t * 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_fill_ : t -> mask:t -> value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval masked_fill_tensor : t -> mask:t -> value:t -> t
Sourceval masked_fill_tensor_ : 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_power_out : out:t -> t -> n:int -> t
Sourceval matrix_rank : t -> symmetric:bool -> t
Sourceval matrix_rank_tol : t -> tol:float -> symmetric:bool -> t
Sourceval max_dim : t -> dim:int -> keepdim:bool -> t * t
Sourceval max_dim_max : max:t -> max_values:t -> t -> dim:int -> keepdim:bool -> t * t
Sourceval max_other : t -> t -> t
Sourceval max_out : out:t -> t -> 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_grad_input : 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_grad_input : 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_grad_input : 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_grad_input : 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 mean_dim : 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 median_dim : t -> dim:int -> keepdim:bool -> t * t
Sourceval median_dim_values : values:t -> indices:t -> t -> dim:int -> keepdim:bool -> t * t
Sourceval meshgrid : t list -> t list
Sourceval meshgrid_indexing : t list -> indexing:string -> t list
Sourceval min_dim : t -> dim:int -> keepdim:bool -> t * t
Sourceval min_dim_min : min:t -> min_indices:t -> t -> dim:int -> keepdim:bool -> t * t
Sourceval min_other : t -> t -> t
Sourceval min_out : out:t -> t -> 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 mish : t -> t
Sourceval mish_ : t -> t
Sourceval mish_backward : grad_output:t -> t -> t
Sourceval mish_out : out:t -> t -> t
Sourceval mkldnn_adaptive_avg_pool2d : t -> output_size:int list -> t
Sourceval mkldnn_adaptive_avg_pool2d_backward : grad_output:t -> t -> 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_linear_backward_input : input_size:int list -> grad_output:t -> weight:t -> t
Sourceval mkldnn_linear_backward_weights : grad_output:t -> t -> weight:t -> bias_defined:bool -> t * 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_pool2d_backward : grad_output:t -> output:t -> 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_max_pool3d_backward : grad_output:t -> output:t -> 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_values : values:t -> indices:t -> t -> dim:int -> keepdim:bool -> t * t
Sourceval moveaxis : t -> source:int list -> destination:int list -> t
Sourceval moveaxis_int : t -> source:int -> destination:int -> t
Sourceval movedim : t -> source:int list -> destination:int list -> t
Sourceval movedim_int : 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_grad_input : 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 msort : t -> t
Sourceval msort_out : out:t -> t -> t
Sourceval mul : t -> t -> t
Sourceval mul_ : t -> t -> t
Sourceval mul_out : out:t -> t -> t -> t
Sourceval mul_scalar : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval mul_scalar_ : t -> 'a Torch_core.Wrapper.Scalar.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_grad_input : 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_grad_input : 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 multiply_ : t -> t -> t
Sourceval multiply_out : out:t -> t -> t -> t
Sourceval multiply_scalar : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval multiply_scalar_ : t -> 'a Torch_core.Wrapper.Scalar.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 mvlgamma_out : out:t -> t -> p:int -> t
Sourceval nan_to_num : t -> nan:float -> posinf:float -> neginf:float -> t
Sourceval nan_to_num_ : t -> nan:float -> posinf:float -> neginf:float -> t
Sourceval nan_to_num_out : out:t -> t -> nan:float -> posinf:float -> neginf:float -> t
Sourceval nanmean : t -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval nanmean_out : out:t -> t -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval nanmedian : t -> t
Sourceval nanmedian_dim : t -> dim:int -> keepdim:bool -> t * t
Sourceval nanmedian_dim_values : values:t -> indices:t -> t -> dim:int -> keepdim:bool -> t * t
Sourceval nanquantile : t -> q:t -> dim:int -> keepdim:bool -> t
Sourceval nanquantile_new : t -> q:t -> dim:int -> keepdim:bool -> interpolation:string -> t
Sourceval nanquantile_new_out : out:t -> t -> q:t -> dim:int -> keepdim:bool -> interpolation:string -> t
Sourceval nanquantile_new_scalar : t -> q:float -> dim:int -> keepdim:bool -> interpolation:string -> t
Sourceval nanquantile_new_scalar_out : out:t -> t -> q:float -> dim:int -> keepdim:bool -> interpolation:string -> t
Sourceval nanquantile_out : out:t -> t -> q:t -> dim:int -> keepdim:bool -> t
Sourceval nanquantile_scalar : t -> q:float -> dim:int -> keepdim:bool -> t
Sourceval nanquantile_scalar_out : out:t -> t -> q:float -> dim:int -> keepdim:bool -> t
Sourceval nansum : t -> dtype:Torch_core.Kind.packed -> t
Sourceval nansum_dim_intlist : t -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval nansum_intlist_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 narrow_copy : t -> dim:int -> start:int -> length:int -> t
Sourceval narrow_copy_out : out:t -> t -> dim:int -> start:int -> length:int -> t
Sourceval narrow_tensor : t -> dim:int -> start:t -> 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 -> normalized_shape:int list -> weight:t option -> bias:t option -> eps:float -> t * t * t
Sourceval native_norm : t -> t
Sourceval native_norm_scalaropt_dim_dtype : t -> p:'a Torch_core.Wrapper.Scalar.t -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval ne_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval ne_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval ne_tensor : t -> t -> t
Sourceval ne_tensor_ : t -> t -> t
Sourceval ne_tensor_out : 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_empty_strided : t -> size:int list -> stride: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_ones : t -> size:int list -> 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_grad_input : 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_grad_input : 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_nd : t -> target:t -> weight:t option -> reduction:Torch_core.Reduction.t -> ignore_index:int -> 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 norm_dtype_out : out:t -> 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_scalaropt_dim : t -> p:'a Torch_core.Wrapper.Scalar.t -> dim:int list -> keepdim:bool -> t
Sourceval norm_scalaropt_dim_dtype : t -> p:'a Torch_core.Wrapper.Scalar.t -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval norm_scalaropt_dtype : t -> p:'a Torch_core.Wrapper.Scalar.t -> dtype:Torch_core.Kind.packed -> t
Sourceval normal : out:t -> mean:t -> std:float -> t
Sourceval normal_ : t -> mean:float -> std:float -> t
Sourceval normal_float_float_out : out:t -> mean:float -> std:float -> size:int list -> t
Sourceval normal_float_tensor_out : out:t -> mean:float -> std:t -> t
Sourceval normal_tensor_tensor_out : out:t -> mean:t -> std:t -> t
Sourceval not_equal : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval not_equal_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval not_equal_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval not_equal_tensor : t -> t -> t
Sourceval not_equal_tensor_ : t -> t -> t
Sourceval not_equal_tensor_out : out:t -> t -> t -> t
Sourceval nuclear_norm : t -> keepdim:bool -> t
Sourceval nuclear_norm_dim : t -> dim:int list -> keepdim:bool -> t
Sourceval nuclear_norm_dim_out : out:t -> t -> dim:int list -> keepdim:bool -> t
Sourceval nuclear_norm_out : out:t -> t -> 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 pad_sequence : sequences:t list -> batch_first:bool -> padding_value:float -> 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 -> device:Torch_core.Device.t -> t
Sourceval pinverse : t -> rcond:float -> t
Sourceval pixel_shuffle : t -> upscale_factor:int -> t
Sourceval pixel_unshuffle : t -> downscale_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 positive : t -> t
Sourceval pow : t -> exponent:t -> t
Sourceval pow_ : t -> exponent:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval pow_scalar : 'a Torch_core.Wrapper.Scalar.t -> exponent:t -> t
Sourceval pow_scalar_out : out:t -> 'a Torch_core.Wrapper.Scalar.t -> exponent:t -> t
Sourceval pow_tensor_ : t -> exponent:t -> t
Sourceval pow_tensor_scalar : t -> exponent:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval pow_tensor_scalar_out : out:t -> t -> exponent:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval pow_tensor_tensor_out : out:t -> 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 prod_dim_int : t -> dim:int -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval prod_int_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 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_q : q:t -> r:t -> t -> some:bool -> t * t
Sourceval quantile : t -> q:t -> dim:int -> keepdim:bool -> t
Sourceval quantile_new : t -> q:t -> dim:int -> keepdim:bool -> interpolation:string -> t
Sourceval quantile_new_out : out:t -> t -> q:t -> dim:int -> keepdim:bool -> interpolation:string -> t
Sourceval quantile_new_scalar : t -> q:float -> dim:int -> keepdim:bool -> interpolation:string -> t
Sourceval quantile_new_scalar_out : out:t -> t -> q:float -> dim:int -> keepdim:bool -> interpolation:string -> t
Sourceval quantile_out : out:t -> t -> q:t -> dim:int -> keepdim:bool -> t
Sourceval quantile_scalar : t -> q:float -> dim:int -> keepdim:bool -> t
Sourceval quantile_scalar_out : out:t -> t -> q:float -> 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_tensor_tensor_qparams : t -> scale:t -> zero_point:t -> dtype:Torch_core.Kind.packed -> t
Sourceval quantize_per_tensor_tensors : 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 randint_like : t -> high:int -> t
Sourceval randint_like_low_dtype : t -> low:int -> high:int -> t
Sourceval randint_low : low:int -> high:int -> size:int list -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval randint_low_out : out:t -> low:int -> high:int -> size:int list -> t
Sourceval randint_out : out:t -> 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_from_ : t -> from:int -> to_:int -> t
Sourceval random_to_ : t -> 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 ravel : 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_grad_input : 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_grad_input : grad_input:t -> grad_output:t -> t -> padding:int list -> t
Sourceval reflection_pad2d_out : out:t -> t -> padding:int list -> t
Sourceval reflection_pad3d : t -> padding:int list -> t
Sourceval reflection_pad3d_backward : grad_output:t -> t -> padding:int list -> t
Sourceval reflection_pad3d_backward_grad_input : grad_input:t -> grad_output:t -> t -> padding:int list -> t
Sourceval reflection_pad3d_out : out:t -> t -> padding:int list -> t
Sourceval relu : t -> t
Sourceval relu6 : t -> t
Sourceval relu6_ : t -> t
Sourceval relu_ : t -> t
Sourceval remainder : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval remainder_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval remainder_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval remainder_scalar_tensor : 'a Torch_core.Wrapper.Scalar.t -> t -> t
Sourceval remainder_tensor : t -> t -> t
Sourceval remainder_tensor_ : t -> t -> t
Sourceval remainder_tensor_out : 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 -> output_size:int -> t
Sourceval repeat_interleave_self_int : t -> repeats:int -> dim:int -> output_size:int -> t
Sourceval repeat_interleave_self_tensor : t -> repeats:t -> dim:int -> output_size: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_grad_input : 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_grad_input : 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_grad_input : 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 resize_as_sparse_ : t -> the_template:t -> t
Sourceval resolve_conj : t -> t
Sourceval resolve_neg : t -> 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_relu_cell : t -> hx:t -> w_ih:t -> w_hh:t -> b_ih:t option -> b_hh:t option -> t
Sourceval rnn_relu_data : 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 : 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_tanh_cell : t -> hx:t -> w_ih:t -> w_hh:t -> b_ih:t option -> b_hh:t option -> t
Sourceval rnn_tanh_data : 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 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 row_stack : t list -> t
Sourceval row_stack_out : out:t -> t list -> 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 rsub_scalar : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval scatter : t -> dim:int -> index:t -> src:t -> t
Sourceval scatter_ : t -> dim:int -> index:t -> src:t -> t
Sourceval scatter_add : t -> dim:int -> index:t -> src:t -> t
Sourceval scatter_add_ : t -> dim:int -> index:t -> src:t -> t
Sourceval scatter_add_out : out:t -> t -> dim:int -> index:t -> src:t -> t
Sourceval scatter_reduce : t -> dim:int -> index:t -> src:t -> reduce:string -> t
Sourceval scatter_reduce_ : t -> dim:int -> index:t -> src:t -> reduce:string -> t
Sourceval scatter_reduce_out : out:t -> t -> dim:int -> index:t -> src:t -> reduce:string -> t
Sourceval scatter_src_out : out:t -> t -> dim:int -> index:t -> src:t -> t
Sourceval scatter_value : t -> dim:int -> index:t -> value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval scatter_value_ : t -> dim:int -> index:t -> value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval scatter_value_out : out:t -> t -> dim:int -> index:t -> value:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval scatter_value_reduce : t -> dim:int -> index:t -> value:'a Torch_core.Wrapper.Scalar.t -> reduce:string -> t
Sourceval scatter_value_reduce_ : t -> dim:int -> index:t -> value:'a Torch_core.Wrapper.Scalar.t -> reduce:string -> t
Sourceval scatter_value_reduce_out : out:t -> t -> dim:int -> index:t -> value:'a Torch_core.Wrapper.Scalar.t -> reduce:string -> t
Sourceval searchsorted : sorted_sequence:t -> t -> out_int32:bool -> right:bool -> t
Sourceval searchsorted_scalar : sorted_sequence:t -> 'a Torch_core.Wrapper.Scalar.t -> out_int32:bool -> right:bool -> t
Sourceval searchsorted_tensor_out : out:t -> sorted_sequence:t -> t -> out_int32:bool -> right:bool -> t
Sourceval segment_reduce : data:t -> reduce:string -> lengths:t option -> indices:t option -> axis:int -> unsafe:bool -> initial:'a Torch_core.Wrapper.Scalar.t -> t
Sourceval select_backward : grad_output:t -> input_sizes:int list -> dim:int -> index:int -> t
Sourceval selu : t -> t
Sourceval selu_ : t -> t
Sourceval set_ : t -> t
Sourceval set_requires_grad : t -> r:bool -> t
Sourceval set_source_tensor_ : t -> source:t -> 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_grad_input : 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_backward_grad_input : grad_input:t -> 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 sinc : t -> t
Sourceval sinc_ : t -> t
Sourceval sinc_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_output: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_grad_input : 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_grad_input : 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_grad_input : 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_grad_input : 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_solution : solution:t -> lu:t -> t -> a:t -> t * t
Sourceval sort : t -> dim:int -> descending:bool -> t * t
Sourceval sort_stable : t -> stable:bool -> dim:int -> descending:bool -> t * t
Sourceval sort_values : values:t -> indices:t -> t -> dim:int -> descending:bool -> t * t
Sourceval sort_values_stable : values:t -> indices:t -> t -> stable:bool -> 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_tensor_indices : indices:t -> values:t -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval sparse_coo_tensor_indices_size : indices:t -> values:t -> size:int list -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval sparse_csr_tensor : crow_indices:t -> col_indices:t -> values:t -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> t
Sourceval sparse_csr_tensor_crow_col_value_size : crow_indices:t -> col_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 special_digamma : t -> t
Sourceval special_digamma_out : out:t -> t -> t
Sourceval special_entr : t -> t
Sourceval special_entr_out : out:t -> t -> t
Sourceval special_erf : t -> t
Sourceval special_erf_out : out:t -> t -> t
Sourceval special_erfc : t -> t
Sourceval special_erfc_out : out:t -> t -> t
Sourceval special_erfcx : t -> t
Sourceval special_erfcx_out : out:t -> t -> t
Sourceval special_erfinv : t -> t
Sourceval special_erfinv_out : out:t -> t -> t
Sourceval special_exp2 : t -> t
Sourceval special_exp2_out : out:t -> t -> t
Sourceval special_expit : t -> t
Sourceval special_expit_out : out:t -> t -> t
Sourceval special_expm1 : t -> t
Sourceval special_expm1_out : out:t -> t -> t
Sourceval special_gammainc : t -> t -> t
Sourceval special_gammainc_out : out:t -> t -> t -> t
Sourceval special_gammaincc : t -> t -> t
Sourceval special_gammaincc_out : out:t -> t -> t -> t
Sourceval special_gammaln : t -> t
Sourceval special_gammaln_out : out:t -> t -> t
Sourceval special_i0 : t -> t
Sourceval special_i0_out : out:t -> t -> t
Sourceval special_i0e : t -> t
Sourceval special_i0e_out : out:t -> t -> t
Sourceval special_i1 : t -> t
Sourceval special_i1_out : out:t -> t -> t
Sourceval special_i1e : t -> t
Sourceval special_i1e_out : out:t -> t -> t
Sourceval special_log1p : t -> t
Sourceval special_log1p_out : out:t -> t -> t
Sourceval special_log_softmax : t -> dim:int -> dtype:Torch_core.Kind.packed -> t
Sourceval special_logit : t -> eps:float -> t
Sourceval special_logit_out : out:t -> t -> eps:float -> t
Sourceval special_logsumexp : t -> dim:int list -> keepdim:bool -> t
Sourceval special_logsumexp_out : out:t -> t -> dim:int list -> keepdim:bool -> t
Sourceval special_multigammaln : t -> p:int -> t
Sourceval special_multigammaln_out : out:t -> t -> p:int -> t
Sourceval special_ndtr : t -> t
Sourceval special_ndtr_out : out:t -> t -> t
Sourceval special_ndtri : t -> t
Sourceval special_ndtri_out : out:t -> t -> t
Sourceval special_polygamma : n:int -> t -> t
Sourceval special_polygamma_out : out:t -> n:int -> t -> t
Sourceval special_psi : t -> t
Sourceval special_psi_out : out:t -> t -> t
Sourceval special_round : t -> t
Sourceval special_round_out : out:t -> t -> t
Sourceval special_sinc : t -> t
Sourceval special_sinc_out : out:t -> t -> t
Sourceval special_xlog1py : t -> t -> t
Sourceval special_xlog1py_other_scalar : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval special_xlog1py_other_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval special_xlog1py_out : out:t -> t -> t -> t
Sourceval special_xlog1py_self_scalar : 'a Torch_core.Wrapper.Scalar.t -> t -> t
Sourceval special_xlog1py_self_scalar_out : out:t -> 'a Torch_core.Wrapper.Scalar.t -> t -> t
Sourceval special_xlogy : t -> t -> t
Sourceval special_xlogy_other_scalar : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval special_xlogy_other_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval special_xlogy_out : out:t -> t -> t -> t
Sourceval special_xlogy_self_scalar : 'a Torch_core.Wrapper.Scalar.t -> t -> t
Sourceval special_xlogy_self_scalar_out : out:t -> 'a Torch_core.Wrapper.Scalar.t -> t -> t
Sourceval special_zeta : t -> t -> t
Sourceval special_zeta_other_scalar : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval special_zeta_other_scalar_out : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval special_zeta_out : out:t -> t -> t -> t
Sourceval special_zeta_self_scalar : 'a Torch_core.Wrapper.Scalar.t -> t -> t
Sourceval special_zeta_self_scalar_out : out:t -> 'a Torch_core.Wrapper.Scalar.t -> t -> 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 square_out : out:t -> t -> t
Sourceval squeeze : t -> t
Sourceval squeeze_ : t -> t
Sourceval squeeze_dim : t -> dim:int -> t
Sourceval squeeze_dim_ : 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 std_correction : t -> dim:int list -> correction:int -> keepdim:bool -> t
Sourceval std_correction_out : out:t -> t -> dim:int list -> correction:int -> keepdim:bool -> t
Sourceval std_dim : t -> dim:int list -> unbiased:bool -> keepdim:bool -> t
Sourceval std_mean : t -> unbiased:bool -> t * t
Sourceval std_mean_correction : t -> dim:int list -> correction:int -> keepdim:bool -> t * t
Sourceval std_mean_dim : 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 sub_scalar : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval sub_scalar_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval subtract : t -> t -> t
Sourceval subtract_ : t -> t -> t
Sourceval subtract_out : out:t -> t -> t -> t
Sourceval subtract_scalar : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval subtract_scalar_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval sum_dim_intlist : t -> dim:int list -> keepdim:bool -> dtype:Torch_core.Kind.packed -> t
Sourceval sum_intlist_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_u : u:t -> s:t -> v:t -> t -> some:bool -> compute_uv:bool -> t * t * t
Sourceval swapaxes : t -> axis0:int -> axis1:int -> t
Sourceval swapaxes_ : t -> axis0:int -> axis1:int -> t
Sourceval swapdims : t -> dim0:int -> dim1:int -> t
Sourceval swapdims_ : t -> dim0:int -> dim1:int -> t
Sourceval symeig : t -> eigenvectors:bool -> upper:bool -> t * t
Sourceval symeig_e : 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_along_dim : t -> indices:t -> dim:int -> t
Sourceval take_along_dim_out : out:t -> t -> indices:t -> dim:int -> 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_grad_input : grad_input:t -> grad_output:t -> output:t -> t
Sourceval tanh_out : out:t -> t -> t
Sourceval tensor_split : t -> sections:int -> dim:int -> t list
Sourceval tensor_split_indices : t -> indices:int list -> dim:int -> t list
Sourceval tensor_split_tensor_indices_or_sections : t -> tensor_indices_or_sections:t -> dim:int -> t list
Sourceval tensordot : t -> t -> dims_self:int list -> dims_other:int list -> t
Sourceval tensordot_out : out:t -> 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_backward_grad_input : grad_input:t -> 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 tile : t -> dims:int list -> t
Sourceval to_ : t -> device:Torch_core.Device.t -> t
Sourceval to_dense : t -> dtype:Torch_core.Kind.packed -> t
Sourceval to_dense_backward : grad:t -> t -> t
Sourceval to_dtype : t -> dtype:Torch_core.Kind.packed -> non_blocking:bool -> copy:bool -> t
Sourceval to_dtype_layout : t -> options:(Torch_core.Kind.packed * Torch_core.Device.t) -> non_blocking:bool -> copy:bool -> t
Sourceval to_mkldnn : t -> dtype:Torch_core.Kind.packed -> t
Sourceval to_mkldnn_backward : grad:t -> t -> t
Sourceval to_other : t -> t -> non_blocking:bool -> copy:bool -> t
Sourceval to_sparse : t -> t
Sourceval to_sparse_sparse_dim : t -> sparse_dim:int -> t
Sourceval topk : t -> k:int -> dim:int -> largest:bool -> sorted:bool -> t * t
Sourceval topk_values : 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 trapezoid : y:t -> dim:int -> t
Sourceval trapezoid_x : y:t -> x:t -> dim:int -> t
Sourceval trapz : y:t -> x:t -> dim:int -> t
Sourceval trapz_dx : y:t -> dx:float -> dim:int -> t
Sourceval triangular_solve : t -> a:t -> upper:bool -> transpose:bool -> unitriangular:bool -> t * t
Sourceval triangular_solve_x : 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_divide_ : t -> t -> t
Sourceval true_divide_out : out:t -> t -> t -> t
Sourceval true_divide_scalar : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval true_divide_scalar_ : t -> 'a Torch_core.Wrapper.Scalar.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 unflatten_dense_tensors : flat:t -> t list -> t list
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_grad_input : 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_grad_input : 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_grad_input : 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_grad_input : 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_grad_input : 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_grad_input : 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_grad_input : 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 var_correction : t -> dim:int list -> correction:int -> keepdim:bool -> t
Sourceval var_correction_out : out:t -> t -> dim:int list -> correction:int -> keepdim:bool -> t
Sourceval var_dim : t -> dim:int list -> unbiased:bool -> keepdim:bool -> t
Sourceval var_mean : t -> unbiased:bool -> t * t
Sourceval var_mean_correction : t -> dim:int list -> correction:int -> keepdim:bool -> t * t
Sourceval var_mean_dim : 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 view_dtype : t -> dtype:Torch_core.Kind.packed -> t
Sourceval vsplit : t -> sections:int -> t list
Sourceval vsplit_array : t -> indices:int list -> t list
Sourceval vstack : t list -> t
Sourceval vstack_out : out:t -> t list -> t
Sourceval where : condition:t -> t list
Sourceval where_scalar : condition:t -> 'a Torch_core.Wrapper.Scalar.t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval where_scalarother : condition:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval where_scalarself : condition:t -> 'a Torch_core.Wrapper.Scalar.t -> t -> t
Sourceval where_self : condition:t -> t -> t -> t
Sourceval xlogy : t -> t -> t
Sourceval xlogy_ : t -> t -> t
Sourceval xlogy_outscalar_other : out:t -> t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval xlogy_outscalar_self : out:t -> 'a Torch_core.Wrapper.Scalar.t -> t -> t
Sourceval xlogy_outtensor : out:t -> t -> t -> t
Sourceval xlogy_scalar_other : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval xlogy_scalar_other_ : t -> 'a Torch_core.Wrapper.Scalar.t -> t
Sourceval xlogy_scalar_self : 'a Torch_core.Wrapper.Scalar.t -> 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