package torch

  1. Overview
  2. Docs
module C : sig ... end
val to_tensor_list : unit Ctypes.ptr Ctypes.ptr -> unit Ctypes.ptr list
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 -> C.TensorG.t
val affine_grid_generator_backward : grad:C.TensorG.t -> size:int list -> C.TensorG.t
val alias : C.TensorG.t -> C.TensorG.t
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 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.t * Device.t) -> C.TensorG.t
val arange1 : start:C.TensorG.scalar -> end_:C.TensorG.scalar -> options:(Kind.t * Device.t) -> C.TensorG.t
val arange2 : start:C.TensorG.scalar -> end_:C.TensorG.scalar -> step:C.TensorG.scalar -> options:(Kind.t * 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 -> 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 -> 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 -> 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 -> 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 -> 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 -> 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 -> 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 -> 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.t * Device.t) -> C.TensorG.t
val bartlett_window1 : window_length:int -> periodic:bool -> options:(Kind.t * 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 -> 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_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_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 -> 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 -> 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 blackman_window : window_length:int -> options:(Kind.t * Device.t) -> C.TensorG.t
val blackman_window1 : window_length:int -> periodic:bool -> options:(Kind.t * 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 -> 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 combinations : C.TensorG.t -> r:int -> with_replacement:bool -> 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 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
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 -> C.TensorG.t * C.TensorG.t * C.TensorG.t
val cudnn_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 cudnn_convolution_backward_bias : grad_output:C.TensorG.t -> 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 -> 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_bias : grad_output:C.TensorG.t -> 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 cumprod : C.TensorG.t -> dim:int -> C.TensorG.t
val cumprod1 : C.TensorG.t -> dim:int -> dtype:Kind.t -> C.TensorG.t
val cumprod_out : out:C.TensorG.t -> C.TensorG.t -> dim:int -> C.TensorG.t
val cumprod_out1 : out:C.TensorG.t -> C.TensorG.t -> dim:int -> dtype:Kind.t -> C.TensorG.t
val cumsum : C.TensorG.t -> dim:int -> C.TensorG.t
val cumsum1 : C.TensorG.t -> dim:int -> dtype:Kind.t -> C.TensorG.t
val cumsum_out : out:C.TensorG.t -> C.TensorG.t -> dim:int -> C.TensorG.t
val cumsum_out1 : out:C.TensorG.t -> C.TensorG.t -> dim:int -> dtype:Kind.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 -> 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.t * Device.t) -> C.TensorG.t
val empty_like : C.TensorG.t -> C.TensorG.t
val empty_like1 : C.TensorG.t -> options:(Kind.t * Device.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.t * 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.t * Device.t) -> C.TensorG.t
val eye1 : n:int -> m:int -> options:(Kind.t * 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 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_pack_quantized_matrix : 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 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_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.t * Device.t) -> C.TensorG.t
val full_like : C.TensorG.t -> fill_value:C.TensorG.scalar -> C.TensorG.t
val full_like1 : C.TensorG.t -> fill_value:C.TensorG.scalar -> options:(Kind.t * Device.t) -> 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 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 -> C.TensorG.t
val grid_sampler_2d : C.TensorG.t -> grid:C.TensorG.t -> interpolation_mode:int -> padding_mode:int -> 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 -> C.TensorG.t * C.TensorG.t
val grid_sampler_3d : C.TensorG.t -> grid:C.TensorG.t -> interpolation_mode:int -> padding_mode:int -> 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 -> 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.t * Device.t) -> C.TensorG.t
val hamming_window1 : window_length:int -> periodic:bool -> options:(Kind.t * Device.t) -> C.TensorG.t
val hamming_window2 : window_length:int -> periodic:bool -> alpha:float -> options:(Kind.t * Device.t) -> C.TensorG.t
val hamming_window3 : window_length:int -> periodic:bool -> alpha:float -> beta:float -> options:(Kind.t * Device.t) -> C.TensorG.t
val hann_window : window_length:int -> options:(Kind.t * Device.t) -> C.TensorG.t
val hann_window1 : window_length:int -> periodic:bool -> options:(Kind.t * 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 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 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 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 -> C.TensorG.t
val leaky_relu_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> negative_slope:C.TensorG.scalar -> 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.t * 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 -> C.TensorG.t
val log_softmax1 : C.TensorG.t -> dim:int -> dtype:Kind.t -> C.TensorG.t
val logdet : C.TensorG.t -> C.TensorG.t
val logspace : start:C.TensorG.scalar -> end_:C.TensorG.scalar -> steps:int -> base:float -> options:(Kind.t * 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 : output: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 : output: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 -> C.TensorG.t
val mean1 : C.TensorG.t -> dtype:Kind.t -> C.TensorG.t
val mean2 : C.TensorG.t -> dim:int list -> keepdim:bool -> C.TensorG.t
val mean3 : C.TensorG.t -> dim:int list -> dtype:Kind.t -> C.TensorG.t
val mean4 : C.TensorG.t -> dim:int list -> keepdim:bool -> dtype:Kind.t -> C.TensorG.t
val mean_out : out:C.TensorG.t -> C.TensorG.t -> dim:int list -> keepdim:bool -> C.TensorG.t
val mean_out1 : out:C.TensorG.t -> C.TensorG.t -> dim:int list -> dtype:Kind.t -> C.TensorG.t
val mean_out2 : out:C.TensorG.t -> C.TensorG.t -> dim:int list -> keepdim:bool -> dtype:Kind.t -> 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 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 mkldnn_reshape : C.TensorG.t -> shape:int list -> 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 -> 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 -> 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 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_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 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_out : out:C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val norm : C.TensorG.t -> C.TensorG.t
val norm1 : C.TensorG.t -> p:C.TensorG.scalar -> dtype:Kind.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.t -> 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.t -> C.TensorG.t
val normal : mean:C.TensorG.t -> std:float -> C.TensorG.t
val normal1 : mean:float -> std:C.TensorG.t -> C.TensorG.t
val normal2 : mean:C.TensorG.t -> std:C.TensorG.t -> 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 nuclear_norm : C.TensorG.t -> keepdim:bool -> C.TensorG.t
val nuclear_norm_out : out:C.TensorG.t -> C.TensorG.t -> keepdim:bool -> C.TensorG.t
val one_hot : C.TensorG.t -> num_classes:int -> C.TensorG.t
val ones : size:int list -> options:(Kind.t * Device.t) -> C.TensorG.t
val ones_like : C.TensorG.t -> C.TensorG.t
val ones_like1 : C.TensorG.t -> options:(Kind.t * Device.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 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 -> C.TensorG.t
val prod1 : C.TensorG.t -> dtype:Kind.t -> C.TensorG.t
val prod2 : C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t
val prod3 : C.TensorG.t -> dim:int -> dtype:Kind.t -> C.TensorG.t
val prod4 : C.TensorG.t -> dim:int -> keepdim:bool -> dtype:Kind.t -> C.TensorG.t
val prod_out : out:C.TensorG.t -> C.TensorG.t -> dim:int -> keepdim:bool -> C.TensorG.t
val prod_out1 : out:C.TensorG.t -> C.TensorG.t -> dim:int -> dtype:Kind.t -> C.TensorG.t
val prod_out2 : out:C.TensorG.t -> C.TensorG.t -> dim:int -> keepdim:bool -> dtype:Kind.t -> C.TensorG.t
val pstrf : C.TensorG.t -> upper:bool -> C.TensorG.t * C.TensorG.t
val pstrf_out : u:C.TensorG.t -> pivot:C.TensorG.t -> C.TensorG.t -> upper:bool -> C.TensorG.t * C.TensorG.t
val put_ : C.TensorG.t -> index:C.TensorG.t -> source:C.TensorG.t -> accumulate:bool -> C.TensorG.t
val quantize_linear : C.TensorG.t -> scale:float -> zero_point:int -> 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 -> 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_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.t * Device.t) -> C.TensorG.t
val rand_like : C.TensorG.t -> C.TensorG.t
val rand_like1 : C.TensorG.t -> options:(Kind.t * Device.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.t * Device.t) -> C.TensorG.t
val randint1 : low:int -> high:int -> size:int list -> options:(Kind.t * 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_like2 : C.TensorG.t -> high:int -> options:(Kind.t * Device.t) -> C.TensorG.t
val randint_like3 : C.TensorG.t -> low:int -> high:int -> options:(Kind.t * Device.t) -> 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.t * Device.t) -> C.TensorG.t
val randn_like : C.TensorG.t -> C.TensorG.t
val randn_like1 : C.TensorG.t -> options:(Kind.t * Device.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.t * 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.t * Device.t) -> C.TensorG.t
val range1 : start:C.TensorG.scalar -> end_:C.TensorG.scalar -> options:(Kind.t * Device.t) -> C.TensorG.t
val range_out : out:C.TensorG.t -> start:C.TensorG.scalar -> end_:C.TensorG.scalar -> 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 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 -> C.TensorG.t
val rrelu_with_noise_backward_out : grad_input:C.TensorG.t -> grad_output:C.TensorG.t -> C.TensorG.t -> noise:C.TensorG.t -> lower:C.TensorG.scalar -> upper:C.TensorG.scalar -> training: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 s_copy_ : C.TensorG.t -> src:C.TensorG.t -> non_blocking:bool -> C.TensorG.t
val s_native_addmm : C.TensorG.t -> mat1:C.TensorG.t -> mat2:C.TensorG.t -> C.TensorG.t
val s_native_addmm_ : C.TensorG.t -> mat1:C.TensorG.t -> mat2:C.TensorG.t -> C.TensorG.t
val s_native_addmm_out : out:C.TensorG.t -> C.TensorG.t -> mat1:C.TensorG.t -> mat2:C.TensorG.t -> C.TensorG.t
val scalar_tensor : s:C.TensorG.scalar -> options:(Kind.t * 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 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 -> C.TensorG.t
val softmax1 : C.TensorG.t -> dim:int -> dtype:Kind.t -> 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.t * Device.t) -> C.TensorG.t
val sparse_coo_tensor1 : indices:C.TensorG.t -> values:C.TensorG.t -> options:(Kind.t * Device.t) -> C.TensorG.t
val sparse_coo_tensor2 : indices:C.TensorG.t -> values:C.TensorG.t -> size:int list -> options:(Kind.t * Device.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 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_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 sum1 : C.TensorG.t -> dtype:Kind.t -> C.TensorG.t
val sum2 : C.TensorG.t -> dim:int list -> keepdim:bool -> C.TensorG.t
val sum3 : C.TensorG.t -> dim:int list -> dtype:Kind.t -> C.TensorG.t
val sum4 : C.TensorG.t -> dim:int list -> keepdim:bool -> dtype:Kind.t -> C.TensorG.t
val sum_out : out:C.TensorG.t -> C.TensorG.t -> dim:int list -> keepdim:bool -> C.TensorG.t
val sum_out1 : out:C.TensorG.t -> C.TensorG.t -> dim:int list -> dtype:Kind.t -> C.TensorG.t
val sum_out2 : out:C.TensorG.t -> C.TensorG.t -> dim:int list -> keepdim:bool -> dtype:Kind.t -> 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.t * Device.t) -> non_blocking:bool -> copy:bool -> C.TensorG.t
val to2 : C.TensorG.t -> dtype:Kind.t -> 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.t -> 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.t -> 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 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.t * 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.t * Device.t) -> C.TensorG.t
val triu_out : out:C.TensorG.t -> C.TensorG.t -> diagonal:int -> 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 -> C.TensorG.t
val upsample_bicubic2d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> 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 -> C.TensorG.t
val upsample_bicubic2d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> align_corners:bool -> C.TensorG.t
val upsample_bilinear2d : C.TensorG.t -> output_size:int list -> align_corners:bool -> C.TensorG.t
val upsample_bilinear2d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> 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 -> C.TensorG.t
val upsample_bilinear2d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> align_corners:bool -> C.TensorG.t
val upsample_linear1d : C.TensorG.t -> output_size:int list -> align_corners:bool -> C.TensorG.t
val upsample_linear1d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> 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 -> C.TensorG.t
val upsample_linear1d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> align_corners:bool -> C.TensorG.t
val upsample_nearest1d : C.TensorG.t -> output_size:int list -> C.TensorG.t
val upsample_nearest1d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> 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 -> C.TensorG.t
val upsample_nearest1d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> C.TensorG.t
val upsample_nearest2d : C.TensorG.t -> output_size:int list -> C.TensorG.t
val upsample_nearest2d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> 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 -> C.TensorG.t
val upsample_nearest2d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> C.TensorG.t
val upsample_nearest3d : C.TensorG.t -> output_size:int list -> C.TensorG.t
val upsample_nearest3d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> 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 -> C.TensorG.t
val upsample_nearest3d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> C.TensorG.t
val upsample_trilinear3d : C.TensorG.t -> output_size:int list -> align_corners:bool -> C.TensorG.t
val upsample_trilinear3d_backward : grad_output:C.TensorG.t -> output_size:int list -> input_size:int list -> align_corners:bool -> 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 -> C.TensorG.t
val upsample_trilinear3d_out : out:C.TensorG.t -> C.TensorG.t -> output_size:int list -> align_corners:bool -> 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_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 -> C.TensorG.t -> C.TensorG.t -> C.TensorG.t
val zero_ : C.TensorG.t -> C.TensorG.t
val zeros : size:int list -> options:(Kind.t * Device.t) -> C.TensorG.t
val zeros_like : C.TensorG.t -> C.TensorG.t
val zeros_like1 : C.TensorG.t -> options:(Kind.t * Device.t) -> C.TensorG.t
val zeros_out : out:C.TensorG.t -> size:int list -> C.TensorG.t