package torch

  1. Overview
  2. Docs
package torch
Legend:
Library
Module
Module type
Parameter
Class
Class type
module C : sig ... end
val to_tensor_list : unit Ctypes.ptr Ctypes.ptr -> unit Ctypes.ptr list
val __and__ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val __and__1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val __iand__ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val __iand__1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val __ilshift__ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val __ilshift__1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val __ior__ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val __ior__1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val __irshift__ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val __irshift__1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val __ixor__ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val __ixor__1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val __lshift__ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val __lshift__1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val __or__ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val __or__1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val __rshift__ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val __rshift__1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val __xor__ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val __xor__1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val _adaptive_avg_pool2d : C.TensorG.t -> output_size:int list -> C.TensorG.t
val _adaptive_avg_pool2d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val _addr : C.TensorG.t -> vec1:C.TensorG.t -> vec2:C.TensorG.t -> C.TensorG.t
val _addr_ : C.TensorG.t -> vec1:C.TensorG.t -> vec2:C.TensorG.t -> C.TensorG.t
val _addr_out : out:C.TensorG.t -> C.TensorG.t -> vec1:C.TensorG.t -> vec2:C.TensorG.t -> C.TensorG.t
val _amp_update_scale : growth_tracker:C.TensorG.t -> current_scale:C.TensorG.t -> found_inf:C.TensorG.t -> scale_growth_factor:float -> scale_backoff_factor:float -> growth_interval:int -> C.TensorG.t
val _baddbmm_mkl_ : C.TensorG.t -> batch1:C.TensorG.t -> batch2:C.TensorG.t -> C.TensorG.t
val _cast_byte : C.TensorG.t -> non_blocking:bool -> C.TensorG.t
val _cast_char : C.TensorG.t -> non_blocking:bool -> C.TensorG.t
val _cast_double : C.TensorG.t -> non_blocking:bool -> C.TensorG.t
val _cast_float : C.TensorG.t -> non_blocking:bool -> C.TensorG.t
val _cast_half : C.TensorG.t -> non_blocking:bool -> C.TensorG.t
val _cast_int : C.TensorG.t -> non_blocking:bool -> C.TensorG.t
val _cast_long : C.TensorG.t -> non_blocking:bool -> C.TensorG.t
val _cast_short : C.TensorG.t -> non_blocking:bool -> C.TensorG.t
val _cat : C.TensorG.t list -> dim:int -> C.TensorG.t
val _cat_out : out:C.TensorG.t -> C.TensorG.t list -> dim:int -> C.TensorG.t
val _cdist_backward : grad:C.TensorG.t -> x1:C.TensorG.t -> x2:C.TensorG.t -> p:float -> cdist:C.TensorG.t -> C.TensorG.t
val _cholesky_helper : C.TensorG.t -> upper:bool -> C.TensorG.t
val _cholesky_solve_helper : C.TensorG.t -> a:C.TensorG.t -> upper:bool -> C.TensorG.t
val _coalesced_ : C.TensorG.t -> coalesced:bool -> C.TensorG.t
val _convolution : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.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 -> C.TensorG.t
val _convolution_nogroup : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> stride:int list -> padding:int list -> dilation:int list -> transposed:bool -> output_padding:int list -> C.TensorG.t
val _copy_from : C.TensorG.t -> dst:C.TensorG.t -> non_blocking:bool -> C.TensorG.t
val _ctc_loss : log_probs:C.TensorG.t -> targets:C.TensorG.t -> input_lengths:int list -> target_lengths:int list -> blank:int -> zero_infinity:bool -> C.TensorG.t * C.TensorG.t
val _ctc_loss_backward : grad:C.TensorG.t -> log_probs:C.TensorG.t -> targets:C.TensorG.t -> input_lengths:int list -> target_lengths:int list -> neg_log_likelihood:C.TensorG.t -> log_alpha:C.TensorG.t -> blank:int -> zero_infinity:bool -> C.TensorG.t
val _cudnn_ctc_loss : log_probs:C.TensorG.t -> targets:C.TensorG.t -> input_lengths:int list -> target_lengths:int list -> blank:int -> deterministic:bool -> zero_infinity:bool -> C.TensorG.t * C.TensorG.t
val _cudnn_init_dropout_state : dropout:float -> train:bool -> dropout_seed:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val _cudnn_rnn : C.TensorG.t -> weight:C.TensorG.t list -> weight_stride0:int -> weight_buf:C.TensorG.t option -> hx:C.TensorG.t -> cx:C.TensorG.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:C.TensorG.t option -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val _cudnn_rnn_flatten_weight : weight_arr:C.TensorG.t list -> weight_stride0:int -> input_size:int -> mode:int -> hidden_size:int -> num_layers:int -> batch_first:bool -> bidirectional:bool -> C.TensorG.t
val _cumprod : C.TensorG.t -> dim:int -> C.TensorG.t
val _cumprod_out : out:C.TensorG.t -> C.TensorG.t -> dim:int -> C.TensorG.t
val _cumsum : C.TensorG.t -> dim:int -> C.TensorG.t
val _cumsum_out : out:C.TensorG.t -> C.TensorG.t -> dim:int -> C.TensorG.t
val _dim_arange : like:C.TensorG.t -> dim:int -> C.TensorG.t
val _dirichlet_grad : x:C.TensorG.t -> alpha:C.TensorG.t -> total:C.TensorG.t -> C.TensorG.t
val _embedding_bag : weight:C.TensorG.t -> indices:C.TensorG.t -> offsets:C.TensorG.t -> scale_grad_by_freq:bool -> mode:int -> sparse:bool -> per_sample_weights:C.TensorG.t option -> include_last_offset:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val _embedding_bag_backward : grad:C.TensorG.t -> indices:C.TensorG.t -> offsets:C.TensorG.t -> offset2bag:C.TensorG.t -> bag_size:C.TensorG.t -> maximum_indices:C.TensorG.t -> num_weights:int -> scale_grad_by_freq:bool -> mode:int -> sparse:bool -> per_sample_weights:C.TensorG.t option -> C.TensorG.t
val _embedding_bag_dense_backward : grad:C.TensorG.t -> indices:C.TensorG.t -> offsets:C.TensorG.t -> offset2bag:C.TensorG.t -> bag_size:C.TensorG.t -> maximum_indices:C.TensorG.t -> num_weights:int -> scale_grad_by_freq:bool -> mode:int -> per_sample_weights:C.TensorG.t option -> C.TensorG.t
val _embedding_bag_per_sample_weights_backward : grad:C.TensorG.t -> weight:C.TensorG.t -> indices:C.TensorG.t -> offsets:C.TensorG.t -> offset2bag:C.TensorG.t -> mode:int -> C.TensorG.t
val _embedding_bag_sparse_backward : grad:C.TensorG.t -> indices:C.TensorG.t -> offsets:C.TensorG.t -> offset2bag:C.TensorG.t -> bag_size:C.TensorG.t -> num_weights:int -> scale_grad_by_freq:bool -> mode:int -> per_sample_weights:C.TensorG.t option -> C.TensorG.t
val _empty_affine_quantized : size:int list -> options:(Kind.packed * Device.t) -> scale:float -> zero_point:int -> C.TensorG.t
val _empty_per_channel_affine_quantized : size:int list -> scales:C.TensorG.t -> zero_points:C.TensorG.t -> axis:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val _fft_with_size : C.TensorG.t -> signal_ndim:int -> complex_input:bool -> complex_output:bool -> inverse:bool -> checked_signal_sizes:int list -> normalized:bool -> onesided:bool -> output_sizes:int list -> C.TensorG.t
val _fused_dropout : C.TensorG.t -> p:float -> C.TensorG.t * C.TensorG.t
val _gather_sparse_backward : C.TensorG.t -> dim:int -> index:C.TensorG.t -> grad:C.TensorG.t -> C.TensorG.t
val _index_copy_ : C.TensorG.t -> dim:int -> index:C.TensorG.t -> source:C.TensorG.t -> C.TensorG.t
val _index_put_impl_ : C.TensorG.t -> indices:C.TensorG.t list -> values:C.TensorG.t -> accumulate:bool -> unsafe:bool -> C.TensorG.t
val _indices : C.TensorG.t -> C.TensorG.t
val _inverse_helper : C.TensorG.t -> C.TensorG.t
val _log_softmax : C.TensorG.t -> dim:int -> half_to_float:bool -> C.TensorG.t
val _log_softmax_backward_data : grad_output:C.TensorG.t -> output:C.TensorG.t -> dim:int -> C.TensorG.t -> C.TensorG.t
val _lu_solve_helper : C.TensorG.t -> lu_data:C.TensorG.t -> lu_pivots:C.TensorG.t -> C.TensorG.t
val _lu_with_info : C.TensorG.t -> pivot:bool -> check_errors:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _make_per_channel_quantized_tensor : C.TensorG.t -> scale:C.TensorG.t -> zero_point:C.TensorG.t -> axis:int -> C.TensorG.t
val _make_per_tensor_quantized_tensor : C.TensorG.t -> scale:float -> zero_point:int -> C.TensorG.t
val _masked_scale : C.TensorG.t -> mask:C.TensorG.t -> scale:float -> C.TensorG.t
val _max : C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val _max_out : max:C.TensorG.t -> max_indices:C.TensorG.t -> C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val _min : C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val _min_out : min:C.TensorG.t -> min_indices:C.TensorG.t -> C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val _mkldnn_reshape : C.TensorG.t -> shape:int list -> C.TensorG.t
val _mkldnn_transpose : C.TensorG.t -> dim0:int -> dim1:int -> C.TensorG.t
val _mkldnn_transpose_ : C.TensorG.t -> dim0:int -> dim1:int -> C.TensorG.t
val _mode : C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val _mode_out : values:C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val _multinomial_alias_draw : j:C.TensorG.t -> q:C.TensorG.t -> num_samples:int -> C.TensorG.t
val _multinomial_alias_setup : probs:C.TensorG.t -> C.TensorG.t * C.TensorG.t
val _nnpack_spatial_convolution : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> padding:int list -> stride:int list -> C.TensorG.t
val _nnpack_spatial_convolution_backward_input : C.TensorG.t -> grad_output:C.TensorG.t -> weight:C.TensorG.t -> padding:int list -> C.TensorG.t
val _nnpack_spatial_convolution_backward_weight : C.TensorG.t -> weightsize:int list -> grad_output:C.TensorG.t -> padding:int list -> C.TensorG.t
val _pack_padded_sequence : C.TensorG.t -> lengths:C.TensorG.t -> batch_first:bool -> C.TensorG.t * C.TensorG.t
val _pack_padded_sequence_backward : grad:C.TensorG.t -> input_size:int list -> batch_sizes:C.TensorG.t -> batch_first:bool -> C.TensorG.t
val _pad_packed_sequence : data:C.TensorG.t -> batch_sizes:C.TensorG.t -> batch_first:bool -> padding_value:C.TensorG.scalar -> total_length:int -> C.TensorG.t * C.TensorG.t
val _pdist_backward : grad:C.TensorG.t -> C.TensorG.t -> p:float -> pdist:C.TensorG.t -> C.TensorG.t
val _qr_helper : C.TensorG.t -> some:bool -> C.TensorG.t * C.TensorG.t
val _reshape_from_tensor : C.TensorG.t -> shape:C.TensorG.t -> C.TensorG.t
val _s_where : condition:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val _sample_dirichlet : C.TensorG.t -> C.TensorG.t
val _shape_as_tensor : C.TensorG.t -> C.TensorG.t
val _sobol_engine_draw : quasi:C.TensorG.t -> n:int -> sobolstate:C.TensorG.t -> dimension:int -> num_generated:int -> dtype:Kind.packed -> C.TensorG.t * C.TensorG.t
val _sobol_engine_ff_ : C.TensorG.t -> n:int -> sobolstate:C.TensorG.t -> dimension:int -> num_generated:int -> C.TensorG.t
val _sobol_engine_initialize_state_ : C.TensorG.t -> dimension:int -> C.TensorG.t
val _sobol_engine_scramble_ : C.TensorG.t -> ltm:C.TensorG.t -> dimension:int -> C.TensorG.t
val _softmax : C.TensorG.t -> dim:int -> half_to_float:bool -> C.TensorG.t
val _softmax_backward_data : grad_output:C.TensorG.t -> output:C.TensorG.t -> dim:int -> C.TensorG.t -> C.TensorG.t
val _solve_helper : C.TensorG.t -> a:C.TensorG.t -> C.TensorG.t * C.TensorG.t
val _sparse_addmm : C.TensorG.t -> sparse:C.TensorG.t -> dense:C.TensorG.t -> C.TensorG.t
val _sparse_coo_tensor_unsafe : indices:C.TensorG.t -> values:C.TensorG.t -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val _sparse_coo_tensor_with_dims : sparse_dim:int -> dense_dim:int -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val _sparse_coo_tensor_with_dims_and_tensors : sparse_dim:int -> dense_dim:int -> size:int list -> indices:C.TensorG.t -> values:C.TensorG.t -> options:(Kind.packed * Device.t) -> C.TensorG.t
val _sparse_mm : sparse:C.TensorG.t -> dense:C.TensorG.t -> C.TensorG.t
val _sparse_sum : C.TensorG.t -> C.TensorG.t
val _sparse_sum1 : C.TensorG.t -> dtype:Kind.packed -> C.TensorG.t
val _sparse_sum2 : C.TensorG.t -> dim:int list -> C.TensorG.t
val _sparse_sum3 : C.TensorG.t -> dim:int list -> dtype:Kind.packed -> C.TensorG.t
val _sparse_sum_backward : grad:C.TensorG.t -> C.TensorG.t -> dim:int list -> C.TensorG.t
val _standard_gamma : C.TensorG.t -> C.TensorG.t
val _standard_gamma_grad : C.TensorG.t -> output:C.TensorG.t -> C.TensorG.t
val _std : C.TensorG.t -> unbiased:bool -> C.TensorG.t
val _svd_helper : C.TensorG.t -> some:bool -> compute_uv:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _symeig_helper : C.TensorG.t -> eigenvectors:bool -> upper:bool -> C.TensorG.t * C.TensorG.t
val _thnn_differentiable_gru_cell_backward : grad_hy:C.TensorG.t -> input_gates:C.TensorG.t -> hidden_gates:C.TensorG.t -> hx:C.TensorG.t -> input_bias:C.TensorG.t option -> hidden_bias:C.TensorG.t option -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val _thnn_differentiable_lstm_cell_backward : grad_hy:C.TensorG.t option -> grad_cy:C.TensorG.t option -> input_gates:C.TensorG.t -> hidden_gates:C.TensorG.t -> input_bias:C.TensorG.t option -> hidden_bias:C.TensorG.t option -> cx:C.TensorG.t -> cy:C.TensorG.t -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val _thnn_fused_gru_cell : input_gates:C.TensorG.t -> hidden_gates:C.TensorG.t -> hx:C.TensorG.t -> input_bias:C.TensorG.t option -> hidden_bias:C.TensorG.t option -> C.TensorG.t * C.TensorG.t
val _thnn_fused_gru_cell_backward : grad_hy:C.TensorG.t -> workspace:C.TensorG.t -> has_bias:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val _thnn_fused_lstm_cell : input_gates:C.TensorG.t -> hidden_gates:C.TensorG.t -> cx:C.TensorG.t -> input_bias:C.TensorG.t option -> hidden_bias:C.TensorG.t option -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _thnn_fused_lstm_cell_backward : grad_hy:C.TensorG.t option -> grad_cy:C.TensorG.t option -> cx:C.TensorG.t -> cy:C.TensorG.t -> workspace:C.TensorG.t -> has_bias:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val _triangular_solve_helper : C.TensorG.t -> a:C.TensorG.t -> upper:bool -> transpose:bool -> unitriangular:bool -> C.TensorG.t * C.TensorG.t
val _trilinear : i1:C.TensorG.t -> i2:C.TensorG.t -> i3:C.TensorG.t -> expand1:int list -> expand2:int list -> expand3:int list -> sumdim:int list -> unroll_dim:int -> C.TensorG.t
val _unique : C.TensorG.t -> sorted:bool -> return_inverse:bool -> C.TensorG.t * C.TensorG.t
val _unique2 : C.TensorG.t -> sorted:bool -> return_inverse:bool -> return_counts:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val _unsafe_view : C.TensorG.t -> size:int list -> C.TensorG.t
val _values : C.TensorG.t -> C.TensorG.t
val _var : C.TensorG.t -> unbiased:bool -> C.TensorG.t
val _weight_norm : v:C.TensorG.t -> g:C.TensorG.t -> dim:int -> C.TensorG.t
val _weight_norm_cuda_interface : v:C.TensorG.t -> g:C.TensorG.t -> dim:int -> C.TensorG.t * C.TensorG.t
val _weight_norm_cuda_interface_backward : grad_w:C.TensorG.t -> saved_v:C.TensorG.t -> saved_g:C.TensorG.t -> saved_norms:C.TensorG.t -> dim:int -> C.TensorG.t * C.TensorG.t
val _weight_norm_differentiable_backward : grad_w:C.TensorG.t -> saved_v:C.TensorG.t -> saved_g:C.TensorG.t -> saved_norms:C.TensorG.t -> dim:int -> C.TensorG.t * C.TensorG.t
val abs_ : C.TensorG.t -> C.TensorG.t
val abs_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val acos : C.TensorG.t -> C.TensorG.t
val acos_ : C.TensorG.t -> C.TensorG.t
val acos_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val adaptive_avg_pool1d : C.TensorG.t -> output_size:int list -> C.TensorG.t
val adaptive_avg_pool2d : C.TensorG.t -> output_size:int list -> C.TensorG.t
val adaptive_avg_pool2d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> C.TensorG.t
val adaptive_avg_pool3d : C.TensorG.t -> output_size:int list -> C.TensorG.t
val adaptive_avg_pool3d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val adaptive_avg_pool3d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val adaptive_avg_pool3d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> C.TensorG.t
val adaptive_max_pool1d : C.TensorG.t -> output_size:int list -> C.TensorG.t * C.TensorG.t
val adaptive_max_pool2d : C.TensorG.t -> output_size:int list -> C.TensorG.t * C.TensorG.t
val adaptive_max_pool2d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t
val adaptive_max_pool2d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t
val adaptive_max_pool2d_out : out:C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t -> output_size:int list -> C.TensorG.t * C.TensorG.t
val adaptive_max_pool3d : C.TensorG.t -> output_size:int list -> C.TensorG.t * C.TensorG.t
val adaptive_max_pool3d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t
val adaptive_max_pool3d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t
val adaptive_max_pool3d_out : out:C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t -> output_size:int list -> C.TensorG.t * C.TensorG.t
val add_ : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val add_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val addbmm : C.TensorG.t -> batch1:C.TensorG.t -> batch2:C.TensorG.t -> C.TensorG.t
val addbmm_ : C.TensorG.t -> batch1:C.TensorG.t -> batch2:C.TensorG.t -> C.TensorG.t
val addbmm_out : out:C.TensorG.t -> C.TensorG.t -> batch1:C.TensorG.t -> batch2:C.TensorG.t -> C.TensorG.t
val addcdiv : C.TensorG.t -> tensor1:C.TensorG.t -> tensor2:C.TensorG.t -> C.TensorG.t
val addcdiv_ : C.TensorG.t -> tensor1:C.TensorG.t -> tensor2:C.TensorG.t -> C.TensorG.t
val addcdiv_out : out:C.TensorG.t -> C.TensorG.t -> tensor1:C.TensorG.t -> tensor2:C.TensorG.t -> C.TensorG.t
val addcmul : C.TensorG.t -> tensor1:C.TensorG.t -> tensor2:C.TensorG.t -> C.TensorG.t
val addcmul_ : C.TensorG.t -> tensor1:C.TensorG.t -> tensor2:C.TensorG.t -> C.TensorG.t
val addcmul_out : out:C.TensorG.t -> C.TensorG.t -> tensor1:C.TensorG.t -> tensor2:C.TensorG.t -> C.TensorG.t
val addmm : C.TensorG.t -> mat1:C.TensorG.t -> mat2:C.TensorG.t -> C.TensorG.t
val addmm_ : C.TensorG.t -> mat1:C.TensorG.t -> mat2:C.TensorG.t -> C.TensorG.t
val addmm_out : out:C.TensorG.t -> C.TensorG.t -> mat1:C.TensorG.t -> mat2:C.TensorG.t -> C.TensorG.t
val addmv : C.TensorG.t -> mat:C.TensorG.t -> vec:C.TensorG.t -> C.TensorG.t
val addmv_ : C.TensorG.t -> mat:C.TensorG.t -> vec:C.TensorG.t -> C.TensorG.t
val addmv_out : out:C.TensorG.t -> C.TensorG.t -> mat:C.TensorG.t -> vec:C.TensorG.t -> C.TensorG.t
val addr : C.TensorG.t -> vec1:C.TensorG.t -> vec2:C.TensorG.t -> C.TensorG.t
val addr_ : C.TensorG.t -> vec1:C.TensorG.t -> vec2:C.TensorG.t -> C.TensorG.t
val addr_out : out:C.TensorG.t -> C.TensorG.t -> vec1:C.TensorG.t -> vec2:C.TensorG.t -> C.TensorG.t
val affine_grid_generator : theta:C.TensorG.t -> size:int list -> align_corners:bool -> C.TensorG.t
val affine_grid_generator_backward : grad:C.TensorG.t -> size:int list -> align_corners:bool -> C.TensorG.t
val alias : C.TensorG.t -> C.TensorG.t
val align_as : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val align_tensors : C.TensorG.t list -> unit Ctypes.ptr list
val all1 : C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t
val all_out : out:C.TensorG.t -> C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t
val alpha_dropout : C.TensorG.t -> p:float -> train:bool -> C.TensorG.t
val alpha_dropout_ : C.TensorG.t -> p:float -> train:bool -> C.TensorG.t
val angle : C.TensorG.t -> C.TensorG.t
val angle_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val any1 : C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t
val any_out : out:C.TensorG.t -> C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t
val arange : end_:C.TensorG.scalar -> options:(Kind.packed * Device.t) -> C.TensorG.t
val arange1 : start:C.TensorG.scalar -> end_:C.TensorG.scalar -> options:(Kind.packed * Device.t) -> C.TensorG.t
val arange2 : start:C.TensorG.scalar -> end_:C.TensorG.scalar -> step:C.TensorG.scalar -> options:(Kind.packed * Device.t) -> C.TensorG.t
val arange_out : out:C.TensorG.t -> end_:C.TensorG.scalar -> C.TensorG.t
val arange_out1 : out:C.TensorG.t -> start:C.TensorG.scalar -> end_:C.TensorG.scalar -> C.TensorG.t
val argmax : C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t
val argmin : C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t
val argsort : C.TensorG.t -> dim:int -> descending:bool -> C.TensorG.t
val as_strided : C.TensorG.t -> size:int list -> stride:int list -> storage_offset:int -> C.TensorG.t
val as_strided_ : C.TensorG.t -> size:int list -> stride:int list -> storage_offset:int -> C.TensorG.t
val asin : C.TensorG.t -> C.TensorG.t
val asin_ : C.TensorG.t -> C.TensorG.t
val asin_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val atan : C.TensorG.t -> C.TensorG.t
val atan2_ : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val atan2_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val atan_ : C.TensorG.t -> C.TensorG.t
val atan_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val avg_pool1d : C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> C.TensorG.t
val avg_pool2d : C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int -> C.TensorG.t
val avg_pool2d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int -> C.TensorG.t
val avg_pool2d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int -> C.TensorG.t
val avg_pool2d_out : out:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int -> C.TensorG.t
val avg_pool3d : C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int -> C.TensorG.t
val avg_pool3d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int -> C.TensorG.t
val avg_pool3d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int -> C.TensorG.t
val avg_pool3d_out : out:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> ceil_mode:bool -> count_include_pad:bool -> divisor_override:int -> C.TensorG.t
val baddbmm : C.TensorG.t -> batch1:C.TensorG.t -> batch2:C.TensorG.t -> C.TensorG.t
val baddbmm_ : C.TensorG.t -> batch1:C.TensorG.t -> batch2:C.TensorG.t -> C.TensorG.t
val baddbmm_out : out:C.TensorG.t -> C.TensorG.t -> batch1:C.TensorG.t -> batch2:C.TensorG.t -> C.TensorG.t
val bartlett_window : window_length:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val bartlett_window1 : window_length:int -> periodic:bool -> options:(Kind.packed * Device.t) -> C.TensorG.t
val batch_norm : C.TensorG.t -> weight:C.TensorG.t option -> bias:C.TensorG.t option -> running_mean:C.TensorG.t option -> running_var:C.TensorG.t option -> training:bool -> momentum:float -> eps:float -> cudnn_enabled:bool -> C.TensorG.t
val batch_norm_backward_elemt : grad_out:C.TensorG.t -> C.TensorG.t -> mean:C.TensorG.t -> invstd:C.TensorG.t -> weight:C.TensorG.t option -> mean_dy:C.TensorG.t -> mean_dy_xmu:C.TensorG.t -> C.TensorG.t
val batch_norm_backward_reduce : grad_out:C.TensorG.t -> C.TensorG.t -> mean:C.TensorG.t -> invstd:C.TensorG.t -> weight:C.TensorG.t option -> input_g:bool -> weight_g:bool -> bias_g:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val batch_norm_elemt : C.TensorG.t -> weight:C.TensorG.t option -> bias:C.TensorG.t option -> mean:C.TensorG.t -> invstd:C.TensorG.t -> eps:float -> C.TensorG.t
val batch_norm_elemt_out : out:C.TensorG.t -> C.TensorG.t -> weight:C.TensorG.t option -> bias:C.TensorG.t option -> mean:C.TensorG.t -> invstd:C.TensorG.t -> eps:float -> C.TensorG.t
val batch_norm_gather_stats : C.TensorG.t -> mean:C.TensorG.t -> invstd:C.TensorG.t -> running_mean:C.TensorG.t option -> running_var:C.TensorG.t option -> momentum:float -> eps:float -> count:int -> C.TensorG.t * C.TensorG.t
val batch_norm_gather_stats_with_counts : C.TensorG.t -> mean:C.TensorG.t -> invstd:C.TensorG.t -> running_mean:C.TensorG.t option -> running_var:C.TensorG.t option -> momentum:float -> eps:float -> counts:int list -> C.TensorG.t * C.TensorG.t
val batch_norm_stats : C.TensorG.t -> eps:float -> C.TensorG.t * C.TensorG.t
val batch_norm_update_stats : C.TensorG.t -> running_mean:C.TensorG.t option -> running_var:C.TensorG.t option -> momentum:float -> C.TensorG.t * C.TensorG.t
val bernoulli : C.TensorG.t -> C.TensorG.t
val bernoulli1 : C.TensorG.t -> p:float -> C.TensorG.t
val bernoulli_ : C.TensorG.t -> p:C.TensorG.t -> C.TensorG.t
val bernoulli_1 : C.TensorG.t -> p:float -> C.TensorG.t
val bernoulli_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val bilinear : input1:C.TensorG.t -> input2:C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> C.TensorG.t
val binary_cross_entropy : C.TensorG.t -> target:C.TensorG.t -> weight:C.TensorG.t option -> reduction:Reduction.t -> C.TensorG.t
val binary_cross_entropy_backward : grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> weight:C.TensorG.t option -> reduction:Reduction.t -> C.TensorG.t
val binary_cross_entropy_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> weight:C.TensorG.t option -> reduction:Reduction.t -> C.TensorG.t
val binary_cross_entropy_out : out:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> weight:C.TensorG.t option -> reduction:Reduction.t -> C.TensorG.t
val binary_cross_entropy_with_logits : C.TensorG.t -> target:C.TensorG.t -> weight:C.TensorG.t option -> pos_weight:C.TensorG.t option -> reduction:Reduction.t -> C.TensorG.t
val binary_cross_entropy_with_logits_backward : grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> weight:C.TensorG.t option -> pos_weight:C.TensorG.t option -> reduction:Reduction.t -> C.TensorG.t
val bincount : C.TensorG.t -> weights:C.TensorG.t option -> minlength:int -> C.TensorG.t
val bitwise_and : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val bitwise_and1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val bitwise_and_ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val bitwise_and_1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val bitwise_and_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val bitwise_and_out1 : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val bitwise_not : C.TensorG.t -> C.TensorG.t
val bitwise_not_ : C.TensorG.t -> C.TensorG.t
val bitwise_not_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val bitwise_or1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val bitwise_or_ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val bitwise_or_1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val bitwise_or_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val bitwise_or_out1 : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val bitwise_xor : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val bitwise_xor1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val bitwise_xor_ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val bitwise_xor_1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val bitwise_xor_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val bitwise_xor_out1 : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val blackman_window : window_length:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val blackman_window1 : window_length:int -> periodic:bool -> options:(Kind.packed * Device.t) -> C.TensorG.t
val bmm : C.TensorG.t -> mat2:C.TensorG.t -> C.TensorG.t
val bmm_out : out:C.TensorG.t -> C.TensorG.t -> mat2:C.TensorG.t -> C.TensorG.t
val broadcast_tensors : C.TensorG.t list -> unit Ctypes.ptr list
val cartesian_prod : C.TensorG.t list -> C.TensorG.t
val cat : C.TensorG.t list -> dim:int -> C.TensorG.t
val cat_out : out:C.TensorG.t -> C.TensorG.t list -> dim:int -> C.TensorG.t
val cauchy_ : C.TensorG.t -> median:float -> sigma:float -> C.TensorG.t
val cdist : x1:C.TensorG.t -> x2:C.TensorG.t -> p:float -> compute_mode:int -> C.TensorG.t
val ceil : C.TensorG.t -> C.TensorG.t
val ceil_ : C.TensorG.t -> C.TensorG.t
val ceil_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val celu : C.TensorG.t -> C.TensorG.t
val celu_ : C.TensorG.t -> C.TensorG.t
val chain_matmul : matrices:C.TensorG.t list -> C.TensorG.t
val cholesky : C.TensorG.t -> upper:bool -> C.TensorG.t
val cholesky_inverse : C.TensorG.t -> upper:bool -> C.TensorG.t
val cholesky_inverse_out : out:C.TensorG.t -> C.TensorG.t -> upper:bool -> C.TensorG.t
val cholesky_out : out:C.TensorG.t -> C.TensorG.t -> upper:bool -> C.TensorG.t
val cholesky_solve : C.TensorG.t -> input2:C.TensorG.t -> upper:bool -> C.TensorG.t
val cholesky_solve_out : out:C.TensorG.t -> C.TensorG.t -> input2:C.TensorG.t -> upper:bool -> C.TensorG.t
val chunk : C.TensorG.t -> chunks:int -> dim:int -> unit Ctypes.ptr list
val clamp_ : C.TensorG.t -> min:C.TensorG.scalar -> max:C.TensorG.scalar -> C.TensorG.t
val clamp_max : C.TensorG.t -> max:C.TensorG.scalar -> C.TensorG.t
val clamp_max_ : C.TensorG.t -> max:C.TensorG.scalar -> C.TensorG.t
val clamp_max_out : out:C.TensorG.t -> C.TensorG.t -> max:C.TensorG.scalar -> C.TensorG.t
val clamp_min : C.TensorG.t -> min:C.TensorG.scalar -> C.TensorG.t
val clamp_min_ : C.TensorG.t -> min:C.TensorG.scalar -> C.TensorG.t
val clamp_min_out : out:C.TensorG.t -> C.TensorG.t -> min:C.TensorG.scalar -> C.TensorG.t
val clamp_out : out:C.TensorG.t -> C.TensorG.t -> min:C.TensorG.scalar -> max:C.TensorG.scalar -> C.TensorG.t
val clone : C.TensorG.t -> C.TensorG.t
val coalesce : C.TensorG.t -> C.TensorG.t
val col2im : C.TensorG.t -> output_size:int list -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> C.TensorG.t
val col2im_backward : grad_output:C.TensorG.t -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> C.TensorG.t
val col2im_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> C.TensorG.t
val col2im_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> C.TensorG.t
val combinations : C.TensorG.t -> r:int -> with_replacement:bool -> C.TensorG.t
val conj : C.TensorG.t -> C.TensorG.t
val conj_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val constant_pad_nd : C.TensorG.t -> pad:int list -> C.TensorG.t
val contiguous : C.TensorG.t -> C.TensorG.t
val conv1d : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> stride:int list -> padding:int list -> dilation:int list -> groups:int -> C.TensorG.t
val conv2d : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> stride:int list -> padding:int list -> dilation:int list -> groups:int -> C.TensorG.t
val conv3d : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> stride:int list -> padding:int list -> dilation:int list -> groups:int -> C.TensorG.t
val conv_tbc : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t -> pad:int -> C.TensorG.t
val conv_tbc_backward : C.TensorG.t -> C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t -> pad:int -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val conv_transpose1d : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> stride:int list -> padding:int list -> output_padding:int list -> groups:int -> dilation:int list -> C.TensorG.t
val conv_transpose2d : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> stride:int list -> padding:int list -> output_padding:int list -> groups:int -> dilation:int list -> C.TensorG.t
val conv_transpose3d : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> stride:int list -> padding:int list -> output_padding:int list -> groups:int -> dilation:int list -> C.TensorG.t
val convolution : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> stride:int list -> padding:int list -> dilation:int list -> transposed:bool -> output_padding:int list -> groups:int -> C.TensorG.t
val convolution_overrideable : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> stride:int list -> padding:int list -> dilation:int list -> transposed:bool -> output_padding:int list -> groups:int -> C.TensorG.t
val copy_sparse_to_sparse_ : C.TensorG.t -> src:C.TensorG.t -> non_blocking:bool -> C.TensorG.t
val cos_ : C.TensorG.t -> C.TensorG.t
val cos_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val cosh : C.TensorG.t -> C.TensorG.t
val cosh_ : C.TensorG.t -> C.TensorG.t
val cosh_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val cosine_embedding_loss : input1:C.TensorG.t -> input2:C.TensorG.t -> target:C.TensorG.t -> margin:float -> reduction:Reduction.t -> C.TensorG.t
val cosine_similarity : x1:C.TensorG.t -> x2:C.TensorG.t -> dim:int -> eps:float -> C.TensorG.t
val cross : C.TensorG.t -> C.TensorG.t -> dim:int -> C.TensorG.t
val cross_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> dim:int -> C.TensorG.t
val ctc_loss : log_probs:C.TensorG.t -> targets:C.TensorG.t -> input_lengths:int list -> target_lengths:int list -> blank:int -> reduction:Reduction.t -> zero_infinity:bool -> C.TensorG.t
val ctc_loss1 : log_probs:C.TensorG.t -> targets:C.TensorG.t -> input_lengths:C.TensorG.t -> target_lengths:C.TensorG.t -> blank:int -> reduction:Reduction.t -> zero_infinity:bool -> C.TensorG.t
val cudnn_affine_grid_generator : theta:C.TensorG.t -> n:int -> c:int -> h:int -> w:int -> C.TensorG.t
val cudnn_affine_grid_generator_backward : grad:C.TensorG.t -> n:int -> c:int -> h:int -> w:int -> C.TensorG.t
val cudnn_batch_norm : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> running_mean:C.TensorG.t option -> running_var:C.TensorG.t option -> training:bool -> exponential_average_factor:float -> epsilon:float -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val cudnn_batch_norm_backward : C.TensorG.t -> grad_output:C.TensorG.t -> weight:C.TensorG.t -> running_mean:C.TensorG.t option -> running_var:C.TensorG.t option -> save_mean:C.TensorG.t option -> save_var:C.TensorG.t option -> epsilon:float -> reservespace:C.TensorG.t -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val cudnn_convolution : C.TensorG.t -> weight:C.TensorG.t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val cudnn_convolution1 : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val cudnn_convolution_backward_input : self_size:int list -> grad_output:C.TensorG.t -> weight:C.TensorG.t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val cudnn_convolution_backward_weight : weight_size:int list -> grad_output:C.TensorG.t -> C.TensorG.t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val cudnn_convolution_transpose : C.TensorG.t -> weight:C.TensorG.t -> padding:int list -> output_padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val cudnn_convolution_transpose1 : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> padding:int list -> output_padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val cudnn_convolution_transpose_backward_input : grad_output:C.TensorG.t -> weight:C.TensorG.t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val cudnn_convolution_transpose_backward_weight : weight_size:int list -> grad_output:C.TensorG.t -> C.TensorG.t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val cudnn_grid_sampler : C.TensorG.t -> grid:C.TensorG.t -> C.TensorG.t
val cudnn_grid_sampler_backward : C.TensorG.t -> grid:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t * C.TensorG.t
val cummax : C.TensorG.t -> dim:int -> C.TensorG.t * C.TensorG.t
val cummax_out : values:C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t -> dim:int -> C.TensorG.t * C.TensorG.t
val cummin : C.TensorG.t -> dim:int -> C.TensorG.t * C.TensorG.t
val cummin_out : values:C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t -> dim:int -> C.TensorG.t * C.TensorG.t
val cumprod : C.TensorG.t -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val cumprod_out : out:C.TensorG.t -> C.TensorG.t -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val cumsum : C.TensorG.t -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val cumsum_out : out:C.TensorG.t -> C.TensorG.t -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val data : C.TensorG.t -> C.TensorG.t
val dequantize : C.TensorG.t -> C.TensorG.t
val detach : C.TensorG.t -> C.TensorG.t
val detach_ : C.TensorG.t -> C.TensorG.t
val diag : C.TensorG.t -> diagonal:int -> C.TensorG.t
val diag_embed : C.TensorG.t -> offset:int -> dim1:int -> dim2:int -> C.TensorG.t
val diag_out : out:C.TensorG.t -> C.TensorG.t -> diagonal:int -> C.TensorG.t
val diagflat : C.TensorG.t -> offset:int -> C.TensorG.t
val diagonal : C.TensorG.t -> offset:int -> dim1:int -> dim2:int -> C.TensorG.t
val digamma : C.TensorG.t -> C.TensorG.t
val digamma_ : C.TensorG.t -> C.TensorG.t
val digamma_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val div_ : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val div_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val dot_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val dropout : C.TensorG.t -> p:float -> train:bool -> C.TensorG.t
val dropout_ : C.TensorG.t -> p:float -> train:bool -> C.TensorG.t
val eig : C.TensorG.t -> eigenvectors:bool -> C.TensorG.t * C.TensorG.t
val eig_out : e:C.TensorG.t -> v:C.TensorG.t -> C.TensorG.t -> eigenvectors:bool -> C.TensorG.t * C.TensorG.t
val elu_ : C.TensorG.t -> C.TensorG.t
val elu_backward : grad_output:C.TensorG.t -> alpha:C.TensorG.scalar -> scale:C.TensorG.scalar -> input_scale:C.TensorG.scalar -> output:C.TensorG.t -> C.TensorG.t
val elu_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> alpha:C.TensorG.scalar -> scale:C.TensorG.scalar -> input_scale:C.TensorG.scalar -> output:C.TensorG.t -> C.TensorG.t
val elu_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val embedding : weight:C.TensorG.t -> indices:C.TensorG.t -> padding_idx:int -> scale_grad_by_freq:bool -> sparse:bool -> C.TensorG.t
val embedding_backward : grad:C.TensorG.t -> indices:C.TensorG.t -> num_weights:int -> padding_idx:int -> scale_grad_by_freq:bool -> sparse:bool -> C.TensorG.t
val embedding_bag : weight:C.TensorG.t -> indices:C.TensorG.t -> offsets:C.TensorG.t -> scale_grad_by_freq:bool -> mode:int -> sparse:bool -> per_sample_weights:C.TensorG.t option -> include_last_offset:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val embedding_dense_backward : grad_output:C.TensorG.t -> indices:C.TensorG.t -> num_weights:int -> padding_idx:int -> scale_grad_by_freq:bool -> C.TensorG.t
val embedding_renorm_ : C.TensorG.t -> indices:C.TensorG.t -> max_norm:float -> norm_type:float -> C.TensorG.t
val embedding_sparse_backward : grad:C.TensorG.t -> indices:C.TensorG.t -> num_weights:int -> padding_idx:int -> scale_grad_by_freq:bool -> C.TensorG.t
val empty : size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val empty_like : C.TensorG.t -> C.TensorG.t
val empty_out : out:C.TensorG.t -> size:int list -> C.TensorG.t
val empty_strided : size:int list -> stride:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val eq_ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val eq_out1 : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val erf_ : C.TensorG.t -> C.TensorG.t
val erf_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val erfc : C.TensorG.t -> C.TensorG.t
val erfc_ : C.TensorG.t -> C.TensorG.t
val erfc_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val erfinv : C.TensorG.t -> C.TensorG.t
val erfinv_ : C.TensorG.t -> C.TensorG.t
val erfinv_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val exp_ : C.TensorG.t -> C.TensorG.t
val exp_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val expand : C.TensorG.t -> size:int list -> implicit:bool -> C.TensorG.t
val expand_as : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val expm1 : C.TensorG.t -> C.TensorG.t
val expm1_ : C.TensorG.t -> C.TensorG.t
val expm1_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val exponential_ : C.TensorG.t -> lambd:float -> C.TensorG.t
val eye : n:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val eye1 : n:int -> m:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val eye_out : out:C.TensorG.t -> n:int -> C.TensorG.t
val eye_out1 : out:C.TensorG.t -> n:int -> m:int -> C.TensorG.t
val fake_quantize_per_channel_affine : C.TensorG.t -> scale:C.TensorG.t -> zero_point:C.TensorG.t -> axis:int -> quant_min:int -> quant_max:int -> C.TensorG.t
val fake_quantize_per_channel_affine_backward : grad:C.TensorG.t -> C.TensorG.t -> scale:C.TensorG.t -> zero_point:C.TensorG.t -> axis:int -> quant_min:int -> quant_max:int -> C.TensorG.t
val fake_quantize_per_tensor_affine : C.TensorG.t -> scale:float -> zero_point:int -> quant_min:int -> quant_max:int -> C.TensorG.t
val fake_quantize_per_tensor_affine_backward : grad:C.TensorG.t -> C.TensorG.t -> scale:float -> zero_point:int -> quant_min:int -> quant_max:int -> C.TensorG.t
val fbgemm_linear_fp16_weight : C.TensorG.t -> packed_weight:C.TensorG.t -> bias:C.TensorG.t -> C.TensorG.t
val fbgemm_linear_fp16_weight_fp32_activation : C.TensorG.t -> packed_weight:C.TensorG.t -> bias:C.TensorG.t -> C.TensorG.t
val fbgemm_linear_int8_weight : C.TensorG.t -> weight:C.TensorG.t -> packed:C.TensorG.t -> col_offsets:C.TensorG.t -> weight_scale:C.TensorG.scalar -> weight_zero_point:C.TensorG.scalar -> bias:C.TensorG.t -> C.TensorG.t
val fbgemm_linear_int8_weight_fp32_activation : C.TensorG.t -> weight:C.TensorG.t -> packed:C.TensorG.t -> col_offsets:C.TensorG.t -> weight_scale:C.TensorG.scalar -> weight_zero_point:C.TensorG.scalar -> bias:C.TensorG.t -> C.TensorG.t
val fbgemm_pack_gemm_matrix_fp16 : C.TensorG.t -> C.TensorG.t
val fbgemm_pack_quantized_matrix : C.TensorG.t -> C.TensorG.t
val fbgemm_pack_quantized_matrix1 : C.TensorG.t -> k:int -> n:int -> C.TensorG.t
val feature_alpha_dropout : C.TensorG.t -> p:float -> train:bool -> C.TensorG.t
val feature_alpha_dropout_ : C.TensorG.t -> p:float -> train:bool -> C.TensorG.t
val feature_dropout : C.TensorG.t -> p:float -> train:bool -> C.TensorG.t
val feature_dropout_ : C.TensorG.t -> p:float -> train:bool -> C.TensorG.t
val fft : C.TensorG.t -> signal_ndim:int -> normalized:bool -> C.TensorG.t
val fill_ : C.TensorG.t -> value:C.TensorG.scalar -> C.TensorG.t
val fill_1 : C.TensorG.t -> value:C.TensorG.t -> C.TensorG.t
val fill_diagonal_ : C.TensorG.t -> fill_value:C.TensorG.scalar -> wrap:bool -> C.TensorG.t
val flatten : C.TensorG.t -> start_dim:int -> end_dim:int -> C.TensorG.t
val flip : C.TensorG.t -> dims:int list -> C.TensorG.t
val floor : C.TensorG.t -> C.TensorG.t
val floor_ : C.TensorG.t -> C.TensorG.t
val floor_divide : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val floor_divide1 : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val floor_divide_ : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val floor_divide_1 : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val floor_divide_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val floor_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val fmod_ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val fmod_out1 : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val frac : C.TensorG.t -> C.TensorG.t
val frac_ : C.TensorG.t -> C.TensorG.t
val frac_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val fractional_max_pool2d : C.TensorG.t -> kernel_size:int list -> output_size:int list -> random_samples:C.TensorG.t -> C.TensorG.t * C.TensorG.t
val fractional_max_pool2d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> output_size:int list -> indices:C.TensorG.t -> C.TensorG.t
val fractional_max_pool2d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> output_size:int list -> indices:C.TensorG.t -> C.TensorG.t
val fractional_max_pool2d_out : output:C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> output_size:int list -> random_samples:C.TensorG.t -> C.TensorG.t * C.TensorG.t
val fractional_max_pool3d : C.TensorG.t -> kernel_size:int list -> output_size:int list -> random_samples:C.TensorG.t -> C.TensorG.t * C.TensorG.t
val fractional_max_pool3d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> output_size:int list -> indices:C.TensorG.t -> C.TensorG.t
val fractional_max_pool3d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> output_size:int list -> indices:C.TensorG.t -> C.TensorG.t
val fractional_max_pool3d_out : output:C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> output_size:int list -> random_samples:C.TensorG.t -> C.TensorG.t * C.TensorG.t
val frobenius_norm : C.TensorG.t -> C.TensorG.t
val frobenius_norm1 : C.TensorG.t -> dim:int list -> keepdim:bool -> C.TensorG.t
val frobenius_norm_out : out:C.TensorG.t -> C.TensorG.t -> dim:int list -> keepdim:bool -> C.TensorG.t
val full : size:int list -> fill_value:C.TensorG.scalar -> options:(Kind.packed * Device.t) -> C.TensorG.t
val full_like : C.TensorG.t -> fill_value:C.TensorG.scalar -> C.TensorG.t
val full_out : out:C.TensorG.t -> size:int list -> fill_value:C.TensorG.scalar -> C.TensorG.t
val gather : C.TensorG.t -> dim:int -> index:C.TensorG.t -> sparse_grad:bool -> C.TensorG.t
val gather_out : out:C.TensorG.t -> C.TensorG.t -> dim:int -> index:C.TensorG.t -> sparse_grad:bool -> C.TensorG.t
val ge_ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val ge_out1 : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val gelu : C.TensorG.t -> C.TensorG.t
val gelu_backward : grad:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val geometric_ : C.TensorG.t -> p:float -> C.TensorG.t
val geqrf_out : a:C.TensorG.t -> tau:C.TensorG.t -> C.TensorG.t -> C.TensorG.t * C.TensorG.t
val ger : C.TensorG.t -> vec2:C.TensorG.t -> C.TensorG.t
val ger_out : out:C.TensorG.t -> C.TensorG.t -> vec2:C.TensorG.t -> C.TensorG.t
val glu : C.TensorG.t -> dim:int -> C.TensorG.t
val glu_backward : grad_output:C.TensorG.t -> C.TensorG.t -> dim:int -> C.TensorG.t
val glu_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> dim:int -> C.TensorG.t
val glu_out : out:C.TensorG.t -> C.TensorG.t -> dim:int -> C.TensorG.t
val grad : C.TensorG.t -> C.TensorG.t
val grid_sampler : C.TensorG.t -> grid:C.TensorG.t -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> C.TensorG.t
val grid_sampler_2d : C.TensorG.t -> grid:C.TensorG.t -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> C.TensorG.t
val grid_sampler_2d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> grid:C.TensorG.t -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> C.TensorG.t * C.TensorG.t
val grid_sampler_3d : C.TensorG.t -> grid:C.TensorG.t -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> C.TensorG.t
val grid_sampler_3d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> grid:C.TensorG.t -> interpolation_mode:int -> padding_mode:int -> align_corners:bool -> C.TensorG.t * C.TensorG.t
val group_norm : C.TensorG.t -> num_groups:int -> weight:C.TensorG.t option -> bias:C.TensorG.t option -> eps:float -> cudnn_enabled:bool -> C.TensorG.t
val gru : C.TensorG.t -> hx:C.TensorG.t -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> batch_first:bool -> C.TensorG.t * C.TensorG.t
val gru1 : data:C.TensorG.t -> batch_sizes:C.TensorG.t -> hx:C.TensorG.t -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> C.TensorG.t * C.TensorG.t
val gru_cell : C.TensorG.t -> hx:C.TensorG.t -> w_ih:C.TensorG.t -> w_hh:C.TensorG.t -> b_ih:C.TensorG.t option -> b_hh:C.TensorG.t option -> C.TensorG.t
val gt_ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val gt_out1 : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val hamming_window : window_length:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val hamming_window1 : window_length:int -> periodic:bool -> options:(Kind.packed * Device.t) -> C.TensorG.t
val hamming_window2 : window_length:int -> periodic:bool -> alpha:float -> options:(Kind.packed * Device.t) -> C.TensorG.t
val hamming_window3 : window_length:int -> periodic:bool -> alpha:float -> beta:float -> options:(Kind.packed * Device.t) -> C.TensorG.t
val hann_window : window_length:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val hann_window1 : window_length:int -> periodic:bool -> options:(Kind.packed * Device.t) -> C.TensorG.t
val hardshrink : C.TensorG.t -> C.TensorG.t
val hardshrink_backward : grad_out:C.TensorG.t -> C.TensorG.t -> lambd:C.TensorG.scalar -> C.TensorG.t
val hardsigmoid : C.TensorG.t -> C.TensorG.t
val hardsigmoid_ : C.TensorG.t -> C.TensorG.t
val hardsigmoid_backward : grad_output:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val hardsigmoid_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val hardtanh : C.TensorG.t -> C.TensorG.t
val hardtanh_ : C.TensorG.t -> C.TensorG.t
val hardtanh_backward : grad_output:C.TensorG.t -> C.TensorG.t -> min_val:C.TensorG.scalar -> max_val:C.TensorG.scalar -> C.TensorG.t
val hardtanh_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> min_val:C.TensorG.scalar -> max_val:C.TensorG.scalar -> C.TensorG.t
val hardtanh_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val hinge_embedding_loss : C.TensorG.t -> target:C.TensorG.t -> margin:float -> reduction:Reduction.t -> C.TensorG.t
val histc : C.TensorG.t -> bins:int -> C.TensorG.t
val histc_out : out:C.TensorG.t -> C.TensorG.t -> bins:int -> C.TensorG.t
val hspmm : mat1:C.TensorG.t -> mat2:C.TensorG.t -> C.TensorG.t
val hspmm_out : out:C.TensorG.t -> mat1:C.TensorG.t -> mat2:C.TensorG.t -> C.TensorG.t
val ifft : C.TensorG.t -> signal_ndim:int -> normalized:bool -> C.TensorG.t
val im2col : C.TensorG.t -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> C.TensorG.t
val im2col_backward : grad_output:C.TensorG.t -> input_size:int list -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> C.TensorG.t
val im2col_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> input_size:int list -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> C.TensorG.t
val im2col_out : out:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> dilation:int list -> padding:int list -> stride:int list -> C.TensorG.t
val imag : C.TensorG.t -> C.TensorG.t
val index : C.TensorG.t -> indices:C.TensorG.t list -> C.TensorG.t
val index_add : C.TensorG.t -> dim:int -> index:C.TensorG.t -> source:C.TensorG.t -> C.TensorG.t
val index_add_ : C.TensorG.t -> dim:int -> index:C.TensorG.t -> source:C.TensorG.t -> C.TensorG.t
val index_copy : C.TensorG.t -> dim:int -> index:C.TensorG.t -> source:C.TensorG.t -> C.TensorG.t
val index_copy_ : C.TensorG.t -> dim:int -> index:C.TensorG.t -> source:C.TensorG.t -> C.TensorG.t
val index_fill : C.TensorG.t -> dim:int -> index:C.TensorG.t -> value:C.TensorG.scalar -> C.TensorG.t
val index_fill1 : C.TensorG.t -> dim:int -> index:C.TensorG.t -> value:C.TensorG.t -> C.TensorG.t
val index_fill_ : C.TensorG.t -> dim:int -> index:C.TensorG.t -> value:C.TensorG.scalar -> C.TensorG.t
val index_fill_1 : C.TensorG.t -> dim:int -> index:C.TensorG.t -> value:C.TensorG.t -> C.TensorG.t
val index_put : C.TensorG.t -> indices:C.TensorG.t list -> values:C.TensorG.t -> accumulate:bool -> C.TensorG.t
val index_put_ : C.TensorG.t -> indices:C.TensorG.t list -> values:C.TensorG.t -> accumulate:bool -> C.TensorG.t
val index_select : C.TensorG.t -> dim:int -> index:C.TensorG.t -> C.TensorG.t
val index_select_out : out:C.TensorG.t -> C.TensorG.t -> dim:int -> index:C.TensorG.t -> C.TensorG.t
val indices : C.TensorG.t -> C.TensorG.t
val instance_norm : C.TensorG.t -> weight:C.TensorG.t option -> bias:C.TensorG.t option -> running_mean:C.TensorG.t option -> running_var:C.TensorG.t option -> use_input_stats:bool -> momentum:float -> eps:float -> cudnn_enabled:bool -> C.TensorG.t
val int_repr : C.TensorG.t -> C.TensorG.t
val inverse : C.TensorG.t -> C.TensorG.t
val inverse_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val irfft : C.TensorG.t -> signal_ndim:int -> normalized:bool -> onesided:bool -> signal_sizes:int list -> C.TensorG.t
val isclose : C.TensorG.t -> C.TensorG.t -> rtol:float -> atol:float -> equal_nan:bool -> C.TensorG.t
val isfinite : C.TensorG.t -> C.TensorG.t
val isinf : C.TensorG.t -> C.TensorG.t
val isnan : C.TensorG.t -> C.TensorG.t
val kl_div : C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val kl_div_backward : grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val kthvalue : C.TensorG.t -> k:int -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val kthvalue_out : values:C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t -> k:int -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val l1_loss : C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val l1_loss_backward : grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val l1_loss_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val l1_loss_out : out:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val layer_norm : C.TensorG.t -> normalized_shape:int list -> weight:C.TensorG.t option -> bias:C.TensorG.t option -> eps:float -> cudnn_enable:bool -> C.TensorG.t
val le_ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val le_out1 : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val leaky_relu : C.TensorG.t -> C.TensorG.t
val leaky_relu_ : C.TensorG.t -> C.TensorG.t
val leaky_relu_backward : grad_output:C.TensorG.t -> C.TensorG.t -> negative_slope:C.TensorG.scalar -> self_is_result:bool -> C.TensorG.t
val leaky_relu_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val lerp : C.TensorG.t -> end_:C.TensorG.t -> weight:C.TensorG.scalar -> C.TensorG.t
val lerp1 : C.TensorG.t -> end_:C.TensorG.t -> weight:C.TensorG.t -> C.TensorG.t
val lerp_ : C.TensorG.t -> end_:C.TensorG.t -> weight:C.TensorG.scalar -> C.TensorG.t
val lerp_1 : C.TensorG.t -> end_:C.TensorG.t -> weight:C.TensorG.t -> C.TensorG.t
val lerp_out : out:C.TensorG.t -> C.TensorG.t -> end_:C.TensorG.t -> weight:C.TensorG.scalar -> C.TensorG.t
val lerp_out1 : out:C.TensorG.t -> C.TensorG.t -> end_:C.TensorG.t -> weight:C.TensorG.t -> C.TensorG.t
val lgamma : C.TensorG.t -> C.TensorG.t
val lgamma_ : C.TensorG.t -> C.TensorG.t
val lgamma_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val linear : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> C.TensorG.t
val linspace : start:C.TensorG.scalar -> end_:C.TensorG.scalar -> steps:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val linspace_out : out:C.TensorG.t -> start:C.TensorG.scalar -> end_:C.TensorG.scalar -> steps:int -> C.TensorG.t
val log10 : C.TensorG.t -> C.TensorG.t
val log10_ : C.TensorG.t -> C.TensorG.t
val log10_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val log1p : C.TensorG.t -> C.TensorG.t
val log1p_ : C.TensorG.t -> C.TensorG.t
val log1p_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val log2 : C.TensorG.t -> C.TensorG.t
val log2_ : C.TensorG.t -> C.TensorG.t
val log2_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val log_ : C.TensorG.t -> C.TensorG.t
val log_normal_ : C.TensorG.t -> mean:float -> std:float -> C.TensorG.t
val log_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val log_sigmoid : C.TensorG.t -> C.TensorG.t
val log_sigmoid_backward : grad_output:C.TensorG.t -> C.TensorG.t -> buffer:C.TensorG.t -> C.TensorG.t
val log_sigmoid_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> buffer:C.TensorG.t -> C.TensorG.t
val log_sigmoid_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val log_softmax : C.TensorG.t -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val logdet : C.TensorG.t -> C.TensorG.t
val logical_and : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val logical_and_ : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val logical_and_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val logical_not : C.TensorG.t -> C.TensorG.t
val logical_not_ : C.TensorG.t -> C.TensorG.t
val logical_not_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val logical_or : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val logical_or_ : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val logical_or_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val logical_xor : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val logical_xor_ : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val logical_xor_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val logspace : start:C.TensorG.scalar -> end_:C.TensorG.scalar -> steps:int -> base:float -> options:(Kind.packed * Device.t) -> C.TensorG.t
val logspace_out : out:C.TensorG.t -> start:C.TensorG.scalar -> end_:C.TensorG.scalar -> steps:int -> base:float -> C.TensorG.t
val logsumexp : C.TensorG.t -> dim:int list -> keepdim:bool -> C.TensorG.t
val logsumexp_out : out:C.TensorG.t -> C.TensorG.t -> dim:int list -> keepdim:bool -> C.TensorG.t
val lstm : C.TensorG.t -> hx:C.TensorG.t list -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> batch_first:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val lstm1 : data:C.TensorG.t -> batch_sizes:C.TensorG.t -> hx:C.TensorG.t list -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val lstm_cell : C.TensorG.t -> hx:C.TensorG.t list -> w_ih:C.TensorG.t -> w_hh:C.TensorG.t -> b_ih:C.TensorG.t option -> b_hh:C.TensorG.t option -> C.TensorG.t * C.TensorG.t
val lt_ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val lt_out1 : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val lu_solve : C.TensorG.t -> lu_data:C.TensorG.t -> lu_pivots:C.TensorG.t -> C.TensorG.t
val lu_solve_out : out:C.TensorG.t -> C.TensorG.t -> lu_data:C.TensorG.t -> lu_pivots:C.TensorG.t -> C.TensorG.t
val margin_ranking_loss : input1:C.TensorG.t -> input2:C.TensorG.t -> target:C.TensorG.t -> margin:float -> reduction:Reduction.t -> C.TensorG.t
val masked_fill : C.TensorG.t -> mask:C.TensorG.t -> value:C.TensorG.scalar -> C.TensorG.t
val masked_fill1 : C.TensorG.t -> mask:C.TensorG.t -> value:C.TensorG.t -> C.TensorG.t
val masked_fill_ : C.TensorG.t -> mask:C.TensorG.t -> value:C.TensorG.scalar -> C.TensorG.t
val masked_fill_1 : C.TensorG.t -> mask:C.TensorG.t -> value:C.TensorG.t -> C.TensorG.t
val masked_scatter : C.TensorG.t -> mask:C.TensorG.t -> source:C.TensorG.t -> C.TensorG.t
val masked_scatter_ : C.TensorG.t -> mask:C.TensorG.t -> source:C.TensorG.t -> C.TensorG.t
val masked_select : C.TensorG.t -> mask:C.TensorG.t -> C.TensorG.t
val masked_select_out : out:C.TensorG.t -> C.TensorG.t -> mask:C.TensorG.t -> C.TensorG.t
val matmul_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val matrix_power : C.TensorG.t -> n:int -> C.TensorG.t
val matrix_rank : C.TensorG.t -> symmetric:bool -> C.TensorG.t
val matrix_rank1 : C.TensorG.t -> tol:float -> symmetric:bool -> C.TensorG.t
val max2 : C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val max_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val max_out1 : max:C.TensorG.t -> max_values:C.TensorG.t -> C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val max_pool1d : C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t
val max_pool1d_with_indices : C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t * C.TensorG.t
val max_pool2d : C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t
val max_pool2d_with_indices : C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t * C.TensorG.t
val max_pool2d_with_indices_backward : grad_output:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> indices:C.TensorG.t -> C.TensorG.t
val max_pool2d_with_indices_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> indices:C.TensorG.t -> C.TensorG.t
val max_pool2d_with_indices_out : out:C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t * C.TensorG.t
val max_pool3d : C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t
val max_pool3d_with_indices : C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t * C.TensorG.t
val max_pool3d_with_indices_backward : grad_output:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> indices:C.TensorG.t -> C.TensorG.t
val max_pool3d_with_indices_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> indices:C.TensorG.t -> C.TensorG.t
val max_pool3d_with_indices_out : out:C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t * C.TensorG.t
val max_unpool2d : C.TensorG.t -> indices:C.TensorG.t -> output_size:int list -> C.TensorG.t
val max_unpool2d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> indices:C.TensorG.t -> output_size:int list -> C.TensorG.t
val max_unpool2d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> indices:C.TensorG.t -> output_size:int list -> C.TensorG.t
val max_unpool2d_out : out:C.TensorG.t -> C.TensorG.t -> indices:C.TensorG.t -> output_size:int list -> C.TensorG.t
val max_unpool3d : C.TensorG.t -> indices:C.TensorG.t -> output_size:int list -> stride:int list -> padding:int list -> C.TensorG.t
val max_unpool3d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> indices:C.TensorG.t -> output_size:int list -> stride:int list -> padding:int list -> C.TensorG.t
val max_unpool3d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> indices:C.TensorG.t -> output_size:int list -> stride:int list -> padding:int list -> C.TensorG.t
val max_unpool3d_out : out:C.TensorG.t -> C.TensorG.t -> indices:C.TensorG.t -> output_size:int list -> stride:int list -> padding:int list -> C.TensorG.t
val max_values : C.TensorG.t -> dim:int list -> keepdim:bool -> C.TensorG.t
val mean : C.TensorG.t -> dtype:Kind.packed -> C.TensorG.t
val mean1 : C.TensorG.t -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val mean_out : out:C.TensorG.t -> C.TensorG.t -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val median : C.TensorG.t -> C.TensorG.t
val median1 : C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val median_out : values:C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val meshgrid : C.TensorG.t list -> unit Ctypes.ptr list
val min2 : C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val min_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val min_out1 : min:C.TensorG.t -> min_indices:C.TensorG.t -> C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val min_values : C.TensorG.t -> dim:int list -> keepdim:bool -> C.TensorG.t
val miopen_batch_norm : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> running_mean:C.TensorG.t option -> running_var:C.TensorG.t option -> training:bool -> exponential_average_factor:float -> epsilon:float -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val miopen_batch_norm_backward : C.TensorG.t -> grad_output:C.TensorG.t -> weight:C.TensorG.t -> running_mean:C.TensorG.t option -> running_var:C.TensorG.t option -> save_mean:C.TensorG.t option -> save_var:C.TensorG.t option -> epsilon:float -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val miopen_convolution : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val miopen_convolution_backward_bias : grad_output:C.TensorG.t -> C.TensorG.t
val miopen_convolution_backward_input : self_size:int list -> grad_output:C.TensorG.t -> weight:C.TensorG.t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val miopen_convolution_backward_weight : weight_size:int list -> grad_output:C.TensorG.t -> C.TensorG.t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val miopen_convolution_transpose : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> padding:int list -> output_padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val miopen_convolution_transpose_backward_input : grad_output:C.TensorG.t -> weight:C.TensorG.t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val miopen_convolution_transpose_backward_weight : weight_size:int list -> grad_output:C.TensorG.t -> C.TensorG.t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val miopen_depthwise_convolution : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val miopen_depthwise_convolution_backward_input : self_size:int list -> grad_output:C.TensorG.t -> weight:C.TensorG.t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val miopen_depthwise_convolution_backward_weight : weight_size:int list -> grad_output:C.TensorG.t -> C.TensorG.t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> benchmark:bool -> deterministic:bool -> C.TensorG.t
val miopen_rnn : C.TensorG.t -> weight:C.TensorG.t list -> weight_stride0:int -> hx:C.TensorG.t -> cx:C.TensorG.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:C.TensorG.t option -> C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t * C.TensorG.t
val mkldnn_adaptive_avg_pool2d : C.TensorG.t -> output_size:int list -> C.TensorG.t
val mkldnn_convolution : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> C.TensorG.t
val mkldnn_convolution_backward_input : self_size:int list -> grad_output:C.TensorG.t -> weight:C.TensorG.t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> bias_defined:bool -> C.TensorG.t
val mkldnn_convolution_backward_weights : weight_size:int list -> grad_output:C.TensorG.t -> C.TensorG.t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> bias_defined:bool -> C.TensorG.t * C.TensorG.t
val mkldnn_linear : C.TensorG.t -> weight:C.TensorG.t -> bias:C.TensorG.t option -> C.TensorG.t
val mkldnn_max_pool2d : C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t
val mkldnn_reorder_conv2d_weight : C.TensorG.t -> padding:int list -> stride:int list -> dilation:int list -> groups:int -> C.TensorG.t
val mm : C.TensorG.t -> mat2:C.TensorG.t -> C.TensorG.t
val mm_out : out:C.TensorG.t -> C.TensorG.t -> mat2:C.TensorG.t -> C.TensorG.t
val mode : C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val mode_out : values:C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val mse_loss : C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val mse_loss_backward : grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val mse_loss_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val mse_loss_out : out:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val mul_ : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val mul_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val multi_margin_loss_backward : grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> p:C.TensorG.scalar -> margin:C.TensorG.scalar -> weight:C.TensorG.t option -> reduction:Reduction.t -> C.TensorG.t
val multi_margin_loss_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> p:C.TensorG.scalar -> margin:C.TensorG.scalar -> weight:C.TensorG.t option -> reduction:Reduction.t -> C.TensorG.t
val multilabel_margin_loss : C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val multilabel_margin_loss_backward : grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> is_target:C.TensorG.t -> C.TensorG.t
val multilabel_margin_loss_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> is_target:C.TensorG.t -> C.TensorG.t
val multilabel_margin_loss_out : out:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val multinomial : C.TensorG.t -> num_samples:int -> replacement:bool -> C.TensorG.t
val multinomial_out : out:C.TensorG.t -> C.TensorG.t -> num_samples:int -> replacement:bool -> C.TensorG.t
val mv_out : out:C.TensorG.t -> C.TensorG.t -> vec:C.TensorG.t -> C.TensorG.t
val mvlgamma : C.TensorG.t -> p:int -> C.TensorG.t
val mvlgamma_ : C.TensorG.t -> p:int -> C.TensorG.t
val narrow : C.TensorG.t -> dim:int -> start:int -> length:int -> C.TensorG.t
val narrow1 : C.TensorG.t -> dim:int -> start:C.TensorG.t -> length:int -> C.TensorG.t
val narrow_copy : C.TensorG.t -> dim:int -> start:int -> length:int -> C.TensorG.t
val native_batch_norm : C.TensorG.t -> weight:C.TensorG.t option -> bias:C.TensorG.t option -> running_mean:C.TensorG.t option -> running_var:C.TensorG.t option -> training:bool -> momentum:float -> eps:float -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val native_batch_norm_out : out:C.TensorG.t -> save_mean:C.TensorG.t -> save_invstd:C.TensorG.t -> C.TensorG.t -> weight:C.TensorG.t option -> bias:C.TensorG.t option -> running_mean:C.TensorG.t option -> running_var:C.TensorG.t option -> training:bool -> momentum:float -> eps:float -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val native_layer_norm : C.TensorG.t -> weight:C.TensorG.t option -> bias:C.TensorG.t option -> m:int -> n:int -> eps:float -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val native_norm : C.TensorG.t -> C.TensorG.t
val ne_ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val ne_out1 : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val neg_ : C.TensorG.t -> C.TensorG.t
val neg_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val new_empty : C.TensorG.t -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val new_full : C.TensorG.t -> size:int list -> fill_value:C.TensorG.scalar -> options:(Kind.packed * Device.t) -> C.TensorG.t
val new_zeros : C.TensorG.t -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val nll_loss : C.TensorG.t -> target:C.TensorG.t -> weight:C.TensorG.t option -> reduction:Reduction.t -> ignore_index:int -> C.TensorG.t
val nll_loss2d : C.TensorG.t -> target:C.TensorG.t -> weight:C.TensorG.t option -> reduction:Reduction.t -> ignore_index:int -> C.TensorG.t
val nll_loss2d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> weight:C.TensorG.t option -> reduction:Reduction.t -> ignore_index:int -> total_weight:C.TensorG.t -> C.TensorG.t
val nll_loss2d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> weight:C.TensorG.t option -> reduction:Reduction.t -> ignore_index:int -> total_weight:C.TensorG.t -> C.TensorG.t
val nll_loss2d_out : out:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> weight:C.TensorG.t option -> reduction:Reduction.t -> ignore_index:int -> C.TensorG.t
val nll_loss_backward : grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> weight:C.TensorG.t option -> reduction:Reduction.t -> ignore_index:int -> total_weight:C.TensorG.t -> C.TensorG.t
val nll_loss_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> weight:C.TensorG.t option -> reduction:Reduction.t -> ignore_index:int -> total_weight:C.TensorG.t -> C.TensorG.t
val nll_loss_out : out:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> weight:C.TensorG.t option -> reduction:Reduction.t -> ignore_index:int -> C.TensorG.t
val nonzero : C.TensorG.t -> C.TensorG.t
val nonzero_numpy : C.TensorG.t -> unit Ctypes.ptr list
val nonzero_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val norm : C.TensorG.t -> C.TensorG.t
val norm2 : C.TensorG.t -> p:C.TensorG.scalar -> dim:int list -> keepdim:bool -> C.TensorG.t
val norm3 : C.TensorG.t -> p:C.TensorG.scalar -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val norm_except_dim : v:C.TensorG.t -> pow:int -> dim:int -> C.TensorG.t
val norm_out : out:C.TensorG.t -> C.TensorG.t -> p:C.TensorG.scalar -> dim:int list -> keepdim:bool -> C.TensorG.t
val norm_out1 : out:C.TensorG.t -> C.TensorG.t -> p:C.TensorG.scalar -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val normal_ : C.TensorG.t -> mean:float -> std:float -> C.TensorG.t
val normal_out : out:C.TensorG.t -> mean:C.TensorG.t -> std:float -> C.TensorG.t
val normal_out1 : out:C.TensorG.t -> mean:float -> std:C.TensorG.t -> C.TensorG.t
val normal_out2 : out:C.TensorG.t -> mean:C.TensorG.t -> std:C.TensorG.t -> C.TensorG.t
val normal_out3 : out:C.TensorG.t -> mean:float -> std:float -> size:int list -> C.TensorG.t
val nuclear_norm : C.TensorG.t -> keepdim:bool -> C.TensorG.t
val nuclear_norm1 : C.TensorG.t -> dim:int list -> keepdim:bool -> C.TensorG.t
val nuclear_norm_out : out:C.TensorG.t -> C.TensorG.t -> keepdim:bool -> C.TensorG.t
val nuclear_norm_out1 : out:C.TensorG.t -> C.TensorG.t -> dim:int list -> keepdim:bool -> C.TensorG.t
val numpy_t : C.TensorG.t -> C.TensorG.t
val one_hot : C.TensorG.t -> num_classes:int -> C.TensorG.t
val ones : size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val ones_like : C.TensorG.t -> C.TensorG.t
val ones_out : out:C.TensorG.t -> size:int list -> C.TensorG.t
val orgqr : C.TensorG.t -> input2:C.TensorG.t -> C.TensorG.t
val orgqr_out : out:C.TensorG.t -> C.TensorG.t -> input2:C.TensorG.t -> C.TensorG.t
val ormqr : C.TensorG.t -> input2:C.TensorG.t -> input3:C.TensorG.t -> left:bool -> transpose:bool -> C.TensorG.t
val ormqr_out : out:C.TensorG.t -> C.TensorG.t -> input2:C.TensorG.t -> input3:C.TensorG.t -> left:bool -> transpose:bool -> C.TensorG.t
val pairwise_distance : x1:C.TensorG.t -> x2:C.TensorG.t -> p:float -> eps:float -> keepdim:bool -> C.TensorG.t
val pdist : C.TensorG.t -> p:float -> C.TensorG.t
val permute : C.TensorG.t -> dims:int list -> C.TensorG.t
val pin_memory : C.TensorG.t -> C.TensorG.t
val pinverse : C.TensorG.t -> rcond:float -> C.TensorG.t
val pixel_shuffle : C.TensorG.t -> upscale_factor:int -> C.TensorG.t
val poisson : C.TensorG.t -> C.TensorG.t
val poisson_nll_loss : C.TensorG.t -> target:C.TensorG.t -> log_input:bool -> full:bool -> eps:float -> reduction:Reduction.t -> C.TensorG.t
val polygamma : n:int -> C.TensorG.t -> C.TensorG.t
val polygamma_ : C.TensorG.t -> n:int -> C.TensorG.t
val polygamma_out : out:C.TensorG.t -> n:int -> C.TensorG.t -> C.TensorG.t
val pow : C.TensorG.t -> exponent:C.TensorG.scalar -> C.TensorG.t
val pow1 : C.TensorG.t -> exponent:C.TensorG.t -> C.TensorG.t
val pow2 : C.TensorG.scalar -> exponent:C.TensorG.t -> C.TensorG.t
val pow_ : C.TensorG.t -> exponent:C.TensorG.scalar -> C.TensorG.t
val pow_1 : C.TensorG.t -> exponent:C.TensorG.t -> C.TensorG.t
val pow_out : out:C.TensorG.t -> C.TensorG.t -> exponent:C.TensorG.scalar -> C.TensorG.t
val pow_out1 : out:C.TensorG.t -> C.TensorG.t -> exponent:C.TensorG.t -> C.TensorG.t
val pow_out2 : out:C.TensorG.t -> C.TensorG.scalar -> exponent:C.TensorG.t -> C.TensorG.t
val prelu : C.TensorG.t -> weight:C.TensorG.t -> C.TensorG.t
val prelu_backward : grad_output:C.TensorG.t -> C.TensorG.t -> weight:C.TensorG.t -> C.TensorG.t * C.TensorG.t
val prod : C.TensorG.t -> dtype:Kind.packed -> C.TensorG.t
val prod1 : C.TensorG.t -> dim:int -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val prod_out : out:C.TensorG.t -> C.TensorG.t -> dim:int -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val put_ : C.TensorG.t -> index:C.TensorG.t -> source:C.TensorG.t -> accumulate:bool -> C.TensorG.t
val q_per_channel_scales : C.TensorG.t -> C.TensorG.t
val q_per_channel_zero_points : C.TensorG.t -> C.TensorG.t
val qr : C.TensorG.t -> some:bool -> C.TensorG.t * C.TensorG.t
val qr_out : q:C.TensorG.t -> r:C.TensorG.t -> C.TensorG.t -> some:bool -> C.TensorG.t * C.TensorG.t
val quantize_per_channel : C.TensorG.t -> scales:C.TensorG.t -> zero_points:C.TensorG.t -> axis:int -> dtype:Kind.packed -> C.TensorG.t
val quantize_per_tensor : C.TensorG.t -> scale:float -> zero_point:int -> dtype:Kind.packed -> C.TensorG.t
val quantized_batch_norm : C.TensorG.t -> weight:C.TensorG.t option -> bias:C.TensorG.t option -> mean:C.TensorG.t -> var:C.TensorG.t -> eps:float -> output_scale:float -> output_zero_point:int -> C.TensorG.t
val quantized_gru : C.TensorG.t -> hx:C.TensorG.t -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> batch_first:bool -> C.TensorG.t * C.TensorG.t
val quantized_gru1 : data:C.TensorG.t -> batch_sizes:C.TensorG.t -> hx:C.TensorG.t -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> C.TensorG.t * C.TensorG.t
val quantized_gru_cell : C.TensorG.t -> hx:C.TensorG.t -> w_ih:C.TensorG.t -> w_hh:C.TensorG.t -> b_ih:C.TensorG.t -> b_hh:C.TensorG.t -> packed_ih:C.TensorG.t -> packed_hh:C.TensorG.t -> col_offsets_ih:C.TensorG.t -> col_offsets_hh:C.TensorG.t -> scale_ih:C.TensorG.scalar -> scale_hh:C.TensorG.scalar -> zero_point_ih:C.TensorG.scalar -> zero_point_hh:C.TensorG.scalar -> C.TensorG.t
val quantized_lstm : C.TensorG.t -> hx:C.TensorG.t list -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> batch_first:bool -> dtype:Kind.packed -> use_dynamic:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val quantized_lstm1 : data:C.TensorG.t -> batch_sizes:C.TensorG.t -> hx:C.TensorG.t list -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> dtype:Kind.packed -> use_dynamic:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val quantized_lstm_cell : C.TensorG.t -> hx:C.TensorG.t list -> w_ih:C.TensorG.t -> w_hh:C.TensorG.t -> b_ih:C.TensorG.t -> b_hh:C.TensorG.t -> packed_ih:C.TensorG.t -> packed_hh:C.TensorG.t -> col_offsets_ih:C.TensorG.t -> col_offsets_hh:C.TensorG.t -> scale_ih:C.TensorG.scalar -> scale_hh:C.TensorG.scalar -> zero_point_ih:C.TensorG.scalar -> zero_point_hh:C.TensorG.scalar -> C.TensorG.t * C.TensorG.t
val quantized_max_pool2d : C.TensorG.t -> kernel_size:int list -> stride:int list -> padding:int list -> dilation:int list -> ceil_mode:bool -> C.TensorG.t
val quantized_rnn_relu_cell : C.TensorG.t -> hx:C.TensorG.t -> w_ih:C.TensorG.t -> w_hh:C.TensorG.t -> b_ih:C.TensorG.t -> b_hh:C.TensorG.t -> packed_ih:C.TensorG.t -> packed_hh:C.TensorG.t -> col_offsets_ih:C.TensorG.t -> col_offsets_hh:C.TensorG.t -> scale_ih:C.TensorG.scalar -> scale_hh:C.TensorG.scalar -> zero_point_ih:C.TensorG.scalar -> zero_point_hh:C.TensorG.scalar -> C.TensorG.t
val quantized_rnn_tanh_cell : C.TensorG.t -> hx:C.TensorG.t -> w_ih:C.TensorG.t -> w_hh:C.TensorG.t -> b_ih:C.TensorG.t -> b_hh:C.TensorG.t -> packed_ih:C.TensorG.t -> packed_hh:C.TensorG.t -> col_offsets_ih:C.TensorG.t -> col_offsets_hh:C.TensorG.t -> scale_ih:C.TensorG.scalar -> scale_hh:C.TensorG.scalar -> zero_point_ih:C.TensorG.scalar -> zero_point_hh:C.TensorG.scalar -> C.TensorG.t
val rand : size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val rand_like : C.TensorG.t -> C.TensorG.t
val rand_out : out:C.TensorG.t -> size:int list -> C.TensorG.t
val randint : high:int -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val randint1 : low:int -> high:int -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val randint_like : C.TensorG.t -> high:int -> C.TensorG.t
val randint_like1 : C.TensorG.t -> low:int -> high:int -> C.TensorG.t
val randint_out : out:C.TensorG.t -> high:int -> size:int list -> C.TensorG.t
val randint_out1 : out:C.TensorG.t -> low:int -> high:int -> size:int list -> C.TensorG.t
val randn : size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val randn_like : C.TensorG.t -> C.TensorG.t
val randn_out : out:C.TensorG.t -> size:int list -> C.TensorG.t
val random_ : C.TensorG.t -> C.TensorG.t
val random_1 : C.TensorG.t -> to_:int -> C.TensorG.t
val random_2 : C.TensorG.t -> from:int -> to_:int -> C.TensorG.t
val randperm : n:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val randperm_out : out:C.TensorG.t -> n:int -> C.TensorG.t
val range : start:C.TensorG.scalar -> end_:C.TensorG.scalar -> options:(Kind.packed * Device.t) -> C.TensorG.t
val range1 : start:C.TensorG.scalar -> end_:C.TensorG.scalar -> options:(Kind.packed * Device.t) -> C.TensorG.t
val range_out : out:C.TensorG.t -> start:C.TensorG.scalar -> end_:C.TensorG.scalar -> C.TensorG.t
val real : C.TensorG.t -> C.TensorG.t
val reciprocal : C.TensorG.t -> C.TensorG.t
val reciprocal_ : C.TensorG.t -> C.TensorG.t
val reciprocal_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val reflection_pad1d : C.TensorG.t -> padding:int list -> C.TensorG.t
val reflection_pad1d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> padding:int list -> C.TensorG.t
val reflection_pad1d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> padding:int list -> C.TensorG.t
val reflection_pad1d_out : out:C.TensorG.t -> C.TensorG.t -> padding:int list -> C.TensorG.t
val reflection_pad2d : C.TensorG.t -> padding:int list -> C.TensorG.t
val reflection_pad2d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> padding:int list -> C.TensorG.t
val reflection_pad2d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> padding:int list -> C.TensorG.t
val reflection_pad2d_out : out:C.TensorG.t -> C.TensorG.t -> padding:int list -> C.TensorG.t
val relu : C.TensorG.t -> C.TensorG.t
val relu_ : C.TensorG.t -> C.TensorG.t
val remainder1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val remainder_ : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val remainder_1 : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val remainder_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val remainder_out1 : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val renorm : C.TensorG.t -> p:C.TensorG.scalar -> dim:int -> maxnorm:C.TensorG.scalar -> C.TensorG.t
val renorm_ : C.TensorG.t -> p:C.TensorG.scalar -> dim:int -> maxnorm:C.TensorG.scalar -> C.TensorG.t
val renorm_out : out:C.TensorG.t -> C.TensorG.t -> p:C.TensorG.scalar -> dim:int -> maxnorm:C.TensorG.scalar -> C.TensorG.t
val repeat : C.TensorG.t -> repeats:int list -> C.TensorG.t
val repeat_interleave : repeats:C.TensorG.t -> C.TensorG.t
val repeat_interleave1 : C.TensorG.t -> repeats:C.TensorG.t -> dim:int -> C.TensorG.t
val repeat_interleave2 : C.TensorG.t -> repeats:int -> dim:int -> C.TensorG.t
val replication_pad1d : C.TensorG.t -> padding:int list -> C.TensorG.t
val replication_pad1d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> padding:int list -> C.TensorG.t
val replication_pad1d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> padding:int list -> C.TensorG.t
val replication_pad1d_out : out:C.TensorG.t -> C.TensorG.t -> padding:int list -> C.TensorG.t
val replication_pad2d : C.TensorG.t -> padding:int list -> C.TensorG.t
val replication_pad2d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> padding:int list -> C.TensorG.t
val replication_pad2d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> padding:int list -> C.TensorG.t
val replication_pad2d_out : out:C.TensorG.t -> C.TensorG.t -> padding:int list -> C.TensorG.t
val replication_pad3d : C.TensorG.t -> padding:int list -> C.TensorG.t
val replication_pad3d_backward : grad_output:C.TensorG.t -> C.TensorG.t -> padding:int list -> C.TensorG.t
val replication_pad3d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> padding:int list -> C.TensorG.t
val replication_pad3d_out : out:C.TensorG.t -> C.TensorG.t -> padding:int list -> C.TensorG.t
val requires_grad_ : C.TensorG.t -> _requires_grad:bool -> C.TensorG.t
val reshape : C.TensorG.t -> shape:int list -> C.TensorG.t
val reshape_as : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val resize_ : C.TensorG.t -> size:int list -> C.TensorG.t
val resize_as_ : C.TensorG.t -> the_template:C.TensorG.t -> C.TensorG.t
val rfft : C.TensorG.t -> signal_ndim:int -> normalized:bool -> onesided:bool -> C.TensorG.t
val rnn_relu : C.TensorG.t -> hx:C.TensorG.t -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> batch_first:bool -> C.TensorG.t * C.TensorG.t
val rnn_relu1 : data:C.TensorG.t -> batch_sizes:C.TensorG.t -> hx:C.TensorG.t -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> C.TensorG.t * C.TensorG.t
val rnn_relu_cell : C.TensorG.t -> hx:C.TensorG.t -> w_ih:C.TensorG.t -> w_hh:C.TensorG.t -> b_ih:C.TensorG.t option -> b_hh:C.TensorG.t option -> C.TensorG.t
val rnn_tanh : C.TensorG.t -> hx:C.TensorG.t -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> batch_first:bool -> C.TensorG.t * C.TensorG.t
val rnn_tanh1 : data:C.TensorG.t -> batch_sizes:C.TensorG.t -> hx:C.TensorG.t -> params:C.TensorG.t list -> has_biases:bool -> num_layers:int -> dropout:float -> train:bool -> bidirectional:bool -> C.TensorG.t * C.TensorG.t
val rnn_tanh_cell : C.TensorG.t -> hx:C.TensorG.t -> w_ih:C.TensorG.t -> w_hh:C.TensorG.t -> b_ih:C.TensorG.t option -> b_hh:C.TensorG.t option -> C.TensorG.t
val roll : C.TensorG.t -> shifts:int list -> dims:int list -> C.TensorG.t
val rot90 : C.TensorG.t -> k:int -> dims:int list -> C.TensorG.t
val round : C.TensorG.t -> C.TensorG.t
val round_ : C.TensorG.t -> C.TensorG.t
val round_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val rrelu : C.TensorG.t -> training:bool -> C.TensorG.t
val rrelu_ : C.TensorG.t -> training:bool -> C.TensorG.t
val rrelu_with_noise : C.TensorG.t -> noise:C.TensorG.t -> training:bool -> C.TensorG.t
val rrelu_with_noise_ : C.TensorG.t -> noise:C.TensorG.t -> training:bool -> C.TensorG.t
val rrelu_with_noise_backward : grad_output:C.TensorG.t -> C.TensorG.t -> noise:C.TensorG.t -> lower:C.TensorG.scalar -> upper:C.TensorG.scalar -> training:bool -> self_is_result:bool -> C.TensorG.t
val rrelu_with_noise_out : out:C.TensorG.t -> C.TensorG.t -> noise:C.TensorG.t -> training:bool -> C.TensorG.t
val rsqrt : C.TensorG.t -> C.TensorG.t
val rsqrt_ : C.TensorG.t -> C.TensorG.t
val rsqrt_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val scalar_tensor : s:C.TensorG.scalar -> options:(Kind.packed * Device.t) -> C.TensorG.t
val scatter : C.TensorG.t -> dim:int -> index:C.TensorG.t -> src:C.TensorG.t -> C.TensorG.t
val scatter1 : C.TensorG.t -> dim:int -> index:C.TensorG.t -> value:C.TensorG.scalar -> C.TensorG.t
val scatter_ : C.TensorG.t -> dim:int -> index:C.TensorG.t -> src:C.TensorG.t -> C.TensorG.t
val scatter_1 : C.TensorG.t -> dim:int -> index:C.TensorG.t -> value:C.TensorG.scalar -> C.TensorG.t
val scatter_add : C.TensorG.t -> dim:int -> index:C.TensorG.t -> src:C.TensorG.t -> C.TensorG.t
val scatter_add_ : C.TensorG.t -> dim:int -> index:C.TensorG.t -> src:C.TensorG.t -> C.TensorG.t
val select : C.TensorG.t -> dim:int -> index:int -> C.TensorG.t
val selu : C.TensorG.t -> C.TensorG.t
val selu_ : C.TensorG.t -> C.TensorG.t
val set_ : C.TensorG.t -> C.TensorG.t
val set_1 : C.TensorG.t -> source:C.TensorG.t -> C.TensorG.t
val set_requires_grad : C.TensorG.t -> r:bool -> C.TensorG.t
val sigmoid : C.TensorG.t -> C.TensorG.t
val sigmoid_ : C.TensorG.t -> C.TensorG.t
val sigmoid_backward : grad_output:C.TensorG.t -> output:C.TensorG.t -> C.TensorG.t
val sigmoid_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output:C.TensorG.t -> C.TensorG.t
val sigmoid_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val sign : C.TensorG.t -> C.TensorG.t
val sign_ : C.TensorG.t -> C.TensorG.t
val sign_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val sin_ : C.TensorG.t -> C.TensorG.t
val sin_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val sinh : C.TensorG.t -> C.TensorG.t
val sinh_ : C.TensorG.t -> C.TensorG.t
val sinh_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val slice : C.TensorG.t -> dim:int -> start:int -> end_:int -> step:int -> C.TensorG.t
val slow_conv3d : C.TensorG.t -> weight:C.TensorG.t -> kernel_size:int list -> bias:C.TensorG.t option -> stride:int list -> padding:int list -> C.TensorG.t
val slow_conv3d_out : out:C.TensorG.t -> C.TensorG.t -> weight:C.TensorG.t -> kernel_size:int list -> bias:C.TensorG.t option -> stride:int list -> padding:int list -> C.TensorG.t
val slow_conv_dilated2d : C.TensorG.t -> weight:C.TensorG.t -> kernel_size:int list -> bias:C.TensorG.t option -> stride:int list -> padding:int list -> dilation:int list -> C.TensorG.t
val slow_conv_dilated3d : C.TensorG.t -> weight:C.TensorG.t -> kernel_size:int list -> bias:C.TensorG.t option -> stride:int list -> padding:int list -> dilation:int list -> C.TensorG.t
val slow_conv_transpose2d : C.TensorG.t -> weight:C.TensorG.t -> kernel_size:int list -> bias:C.TensorG.t option -> stride:int list -> padding:int list -> output_padding:int list -> dilation:int list -> C.TensorG.t
val slow_conv_transpose2d_out : out:C.TensorG.t -> C.TensorG.t -> weight:C.TensorG.t -> kernel_size:int list -> bias:C.TensorG.t option -> stride:int list -> padding:int list -> output_padding:int list -> dilation:int list -> C.TensorG.t
val slow_conv_transpose3d : C.TensorG.t -> weight:C.TensorG.t -> kernel_size:int list -> bias:C.TensorG.t option -> stride:int list -> padding:int list -> output_padding:int list -> dilation:int list -> C.TensorG.t
val slow_conv_transpose3d_out : out:C.TensorG.t -> C.TensorG.t -> weight:C.TensorG.t -> kernel_size:int list -> bias:C.TensorG.t option -> stride:int list -> padding:int list -> output_padding:int list -> dilation:int list -> C.TensorG.t
val smm : C.TensorG.t -> mat2:C.TensorG.t -> C.TensorG.t
val smooth_l1_loss : C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val smooth_l1_loss_backward : grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val smooth_l1_loss_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val smooth_l1_loss_out : out:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val soft_margin_loss : C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val soft_margin_loss_backward : grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val soft_margin_loss_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val soft_margin_loss_out : out:C.TensorG.t -> C.TensorG.t -> target:C.TensorG.t -> reduction:Reduction.t -> C.TensorG.t
val softmax : C.TensorG.t -> dim:int -> dtype:Kind.packed -> C.TensorG.t
val softplus : C.TensorG.t -> C.TensorG.t
val softplus_backward : grad_output:C.TensorG.t -> C.TensorG.t -> beta:C.TensorG.scalar -> threshold:C.TensorG.scalar -> output:C.TensorG.t -> C.TensorG.t
val softplus_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> beta:C.TensorG.scalar -> threshold:C.TensorG.scalar -> output:C.TensorG.t -> C.TensorG.t
val softplus_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val softshrink : C.TensorG.t -> C.TensorG.t
val softshrink_backward : grad_output:C.TensorG.t -> C.TensorG.t -> lambd:C.TensorG.scalar -> C.TensorG.t
val softshrink_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> lambd:C.TensorG.scalar -> C.TensorG.t
val softshrink_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val solve_out : solution:C.TensorG.t -> lu:C.TensorG.t -> C.TensorG.t -> a:C.TensorG.t -> C.TensorG.t * C.TensorG.t
val sort : C.TensorG.t -> dim:int -> descending:bool -> C.TensorG.t * C.TensorG.t
val sort_out : values:C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t -> dim:int -> descending:bool -> C.TensorG.t * C.TensorG.t
val sparse_coo_tensor : size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_coo_tensor1 : indices:C.TensorG.t -> values:C.TensorG.t -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_coo_tensor2 : indices:C.TensorG.t -> values:C.TensorG.t -> size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val sparse_mask : C.TensorG.t -> mask:C.TensorG.t -> C.TensorG.t
val sparse_resize_ : C.TensorG.t -> size:int list -> sparse_dim:int -> dense_dim:int -> C.TensorG.t
val sparse_resize_and_clear_ : C.TensorG.t -> size:int list -> sparse_dim:int -> dense_dim:int -> C.TensorG.t
val split : C.TensorG.t -> split_size:int -> dim:int -> unit Ctypes.ptr list
val split_with_sizes : C.TensorG.t -> split_sizes:int list -> dim:int -> unit Ctypes.ptr list
val sqrt : C.TensorG.t -> C.TensorG.t
val sqrt_ : C.TensorG.t -> C.TensorG.t
val sqrt_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val square : C.TensorG.t -> C.TensorG.t
val square_ : C.TensorG.t -> C.TensorG.t
val squeeze : C.TensorG.t -> C.TensorG.t
val squeeze1 : C.TensorG.t -> dim:int -> C.TensorG.t
val squeeze_ : C.TensorG.t -> C.TensorG.t
val squeeze_1 : C.TensorG.t -> dim:int -> C.TensorG.t
val sspaddmm : C.TensorG.t -> mat1:C.TensorG.t -> mat2:C.TensorG.t -> C.TensorG.t
val sspaddmm_out : out:C.TensorG.t -> C.TensorG.t -> mat1:C.TensorG.t -> mat2:C.TensorG.t -> C.TensorG.t
val stack : C.TensorG.t list -> dim:int -> C.TensorG.t
val stack_out : out:C.TensorG.t -> C.TensorG.t list -> dim:int -> C.TensorG.t
val std : C.TensorG.t -> unbiased:bool -> C.TensorG.t
val std1 : C.TensorG.t -> dim:int list -> unbiased:bool -> keepdim:bool -> C.TensorG.t
val std_mean : C.TensorG.t -> unbiased:bool -> C.TensorG.t * C.TensorG.t
val std_mean1 : C.TensorG.t -> dim:int list -> unbiased:bool -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val std_out : out:C.TensorG.t -> C.TensorG.t -> dim:int list -> unbiased:bool -> keepdim:bool -> C.TensorG.t
val stft : C.TensorG.t -> n_fft:int -> hop_length:int -> win_length:int -> window:C.TensorG.t option -> normalized:bool -> onesided:bool -> C.TensorG.t
val sub_ : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val sub_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val sum : C.TensorG.t -> dtype:Kind.packed -> C.TensorG.t
val sum1 : C.TensorG.t -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val sum_out : out:C.TensorG.t -> C.TensorG.t -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> C.TensorG.t
val sum_to_size : C.TensorG.t -> size:int list -> C.TensorG.t
val svd : C.TensorG.t -> some:bool -> compute_uv:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val svd_out : u:C.TensorG.t -> s:C.TensorG.t -> v:C.TensorG.t -> C.TensorG.t -> some:bool -> compute_uv:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val symeig : C.TensorG.t -> eigenvectors:bool -> upper:bool -> C.TensorG.t * C.TensorG.t
val symeig_out : e:C.TensorG.t -> v:C.TensorG.t -> C.TensorG.t -> eigenvectors:bool -> upper:bool -> C.TensorG.t * C.TensorG.t
val t_ : C.TensorG.t -> C.TensorG.t
val take : C.TensorG.t -> index:C.TensorG.t -> C.TensorG.t
val take_out : out:C.TensorG.t -> C.TensorG.t -> index:C.TensorG.t -> C.TensorG.t
val tan_ : C.TensorG.t -> C.TensorG.t
val tan_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val tanh : C.TensorG.t -> C.TensorG.t
val tanh_ : C.TensorG.t -> C.TensorG.t
val tanh_backward : grad_output:C.TensorG.t -> output:C.TensorG.t -> C.TensorG.t
val tanh_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output:C.TensorG.t -> C.TensorG.t
val tanh_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val tensordot : C.TensorG.t -> C.TensorG.t -> dims_self:int list -> dims_other:int list -> C.TensorG.t
val threshold : C.TensorG.t -> threshold:C.TensorG.scalar -> value:C.TensorG.scalar -> C.TensorG.t
val threshold_ : C.TensorG.t -> threshold:C.TensorG.scalar -> value:C.TensorG.scalar -> C.TensorG.t
val threshold_backward : grad_output:C.TensorG.t -> C.TensorG.t -> threshold:C.TensorG.scalar -> C.TensorG.t
val threshold_out : out:C.TensorG.t -> C.TensorG.t -> threshold:C.TensorG.scalar -> value:C.TensorG.scalar -> C.TensorG.t
val to_ : C.TensorG.t -> device:Device.t -> C.TensorG.t
val to1 : C.TensorG.t -> options:(Kind.packed * Device.t) -> non_blocking:bool -> copy:bool -> C.TensorG.t
val to2 : C.TensorG.t -> dtype:Kind.packed -> non_blocking:bool -> copy:bool -> C.TensorG.t
val to3 : C.TensorG.t -> C.TensorG.t -> non_blocking:bool -> copy:bool -> C.TensorG.t
val to4 : C.TensorG.t -> device:Device.t -> dtype:Kind.packed -> non_blocking:bool -> copy:bool -> C.TensorG.t
val to_dense : C.TensorG.t -> C.TensorG.t
val to_dense_backward : grad:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val to_mkldnn : C.TensorG.t -> C.TensorG.t
val to_mkldnn_backward : grad:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val to_sparse : C.TensorG.t -> C.TensorG.t
val to_sparse1 : C.TensorG.t -> sparse_dim:int -> C.TensorG.t
val topk : C.TensorG.t -> k:int -> dim:int -> largest:bool -> sorted:bool -> C.TensorG.t * C.TensorG.t
val topk_out : values:C.TensorG.t -> indices:C.TensorG.t -> C.TensorG.t -> k:int -> dim:int -> largest:bool -> sorted:bool -> C.TensorG.t * C.TensorG.t
val totype : C.TensorG.t -> scalar_type:Kind.packed -> C.TensorG.t
val trace : C.TensorG.t -> C.TensorG.t
val transpose : C.TensorG.t -> dim0:int -> dim1:int -> C.TensorG.t
val transpose_ : C.TensorG.t -> dim0:int -> dim1:int -> C.TensorG.t
val trapz : y:C.TensorG.t -> x:C.TensorG.t -> dim:int -> C.TensorG.t
val trapz1 : y:C.TensorG.t -> dx:float -> dim:int -> C.TensorG.t
val triangular_solve : C.TensorG.t -> a:C.TensorG.t -> upper:bool -> transpose:bool -> unitriangular:bool -> C.TensorG.t * C.TensorG.t
val triangular_solve_out : x:C.TensorG.t -> m:C.TensorG.t -> C.TensorG.t -> a:C.TensorG.t -> upper:bool -> transpose:bool -> unitriangular:bool -> C.TensorG.t * C.TensorG.t
val tril : C.TensorG.t -> diagonal:int -> C.TensorG.t
val tril_ : C.TensorG.t -> diagonal:int -> C.TensorG.t
val tril_indices : row:int -> col:int -> offset:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val tril_out : out:C.TensorG.t -> C.TensorG.t -> diagonal:int -> C.TensorG.t
val triplet_margin_loss : anchor:C.TensorG.t -> positive:C.TensorG.t -> negative:C.TensorG.t -> margin:float -> p:float -> eps:float -> swap:bool -> reduction:Reduction.t -> C.TensorG.t
val triu : C.TensorG.t -> diagonal:int -> C.TensorG.t
val triu_ : C.TensorG.t -> diagonal:int -> C.TensorG.t
val triu_indices : row:int -> col:int -> offset:int -> options:(Kind.packed * Device.t) -> C.TensorG.t
val triu_out : out:C.TensorG.t -> C.TensorG.t -> diagonal:int -> C.TensorG.t
val true_divide : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val true_divide1 : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val true_divide_ : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val true_divide_1 : C.TensorG.t -> C.TensorG.scalar -> C.TensorG.t
val true_divide_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val trunc : C.TensorG.t -> C.TensorG.t
val trunc_ : C.TensorG.t -> C.TensorG.t
val trunc_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val type_as : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val unbind : C.TensorG.t -> dim:int -> unit Ctypes.ptr list
val unfold : C.TensorG.t -> dimension:int -> size:int -> step:int -> C.TensorG.t
val uniform_ : C.TensorG.t -> from:float -> to_:float -> C.TensorG.t
val unique_consecutive : C.TensorG.t -> return_inverse:bool -> return_counts:bool -> dim:int -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val unique_dim : C.TensorG.t -> dim:int -> sorted:bool -> return_inverse:bool -> return_counts:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val unique_dim_consecutive : C.TensorG.t -> dim:int -> return_inverse:bool -> return_counts:bool -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val unsqueeze : C.TensorG.t -> dim:int -> C.TensorG.t
val unsqueeze_ : C.TensorG.t -> dim:int -> C.TensorG.t
val upsample_bicubic2d : C.TensorG.t -> output_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_bicubic2d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_bicubic2d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_bicubic2d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_bilinear2d : C.TensorG.t -> output_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_bilinear2d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_bilinear2d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_bilinear2d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> align_corners:bool -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_linear1d : C.TensorG.t -> output_size:int list -> align_corners:bool -> scales:float -> C.TensorG.t
val upsample_linear1d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales:float -> C.TensorG.t
val upsample_linear1d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales:float -> C.TensorG.t
val upsample_linear1d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> align_corners:bool -> scales:float -> C.TensorG.t
val upsample_nearest1d : C.TensorG.t -> output_size:int list -> scales:float -> C.TensorG.t
val upsample_nearest1d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales:float -> C.TensorG.t
val upsample_nearest1d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales:float -> C.TensorG.t
val upsample_nearest1d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> scales:float -> C.TensorG.t
val upsample_nearest2d : C.TensorG.t -> output_size:int list -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest2d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest2d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest2d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest3d : C.TensorG.t -> output_size:int list -> scales_d:float -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest3d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales_d:float -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest3d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> scales_d:float -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_nearest3d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> scales_d:float -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_trilinear3d : C.TensorG.t -> output_size:int list -> align_corners:bool -> scales_d:float -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_trilinear3d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_d:float -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_trilinear3d_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> scales_d:float -> scales_h:float -> scales_w:float -> C.TensorG.t
val upsample_trilinear3d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> align_corners:bool -> scales_d:float -> scales_h:float -> scales_w:float -> C.TensorG.t
val values : C.TensorG.t -> C.TensorG.t
val var : C.TensorG.t -> unbiased:bool -> C.TensorG.t
val var1 : C.TensorG.t -> dim:int list -> unbiased:bool -> keepdim:bool -> C.TensorG.t
val var_mean : C.TensorG.t -> unbiased:bool -> C.TensorG.t * C.TensorG.t
val var_mean1 : C.TensorG.t -> dim:int list -> unbiased:bool -> keepdim:bool -> C.TensorG.t * C.TensorG.t
val var_out : out:C.TensorG.t -> C.TensorG.t -> dim:int list -> unbiased:bool -> keepdim:bool -> C.TensorG.t
val view : C.TensorG.t -> size:int list -> C.TensorG.t
val view_as : C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val where : condition:C.TensorG.t -> unit Ctypes.ptr list
val where1 : condition:C.TensorG.t -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val zero_ : C.TensorG.t -> C.TensorG.t
val zeros : size:int list -> options:(Kind.packed * Device.t) -> C.TensorG.t
val zeros_like : C.TensorG.t -> C.TensorG.t
val zeros_out : out:C.TensorG.t -> size:int list -> C.TensorG.t
OCaml

Innovation. Community. Security.

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