Source file wrapper_generated_intf.ml

(* THIS FILE IS AUTOMATICALLY GENERATED, DO NOT EDIT BY HAND! *)

module type S = sig
  type t
  type _ scalar

  val __and__ : t -> 'a scalar -> t
  val __and__1 : t -> t -> t
  val __iand__ : t -> 'a scalar -> t
  val __iand__1 : t -> t -> t
  val __ilshift__ : t -> 'a scalar -> t
  val __ilshift__1 : t -> t -> t
  val __ior__ : t -> 'a scalar -> t
  val __ior__1 : t -> t -> t
  val __irshift__ : t -> 'a scalar -> t
  val __irshift__1 : t -> t -> t
  val __ixor__ : t -> 'a scalar -> t
  val __ixor__1 : t -> t -> t
  val __lshift__ : t -> 'a scalar -> t
  val __lshift__1 : t -> t -> t
  val __or__ : t -> 'a scalar -> t
  val __or__1 : t -> t -> t
  val __rshift__ : t -> 'a scalar -> t
  val __rshift__1 : t -> t -> t
  val __xor__ : t -> 'a scalar -> t
  val __xor__1 : t -> t -> t
  val _adaptive_avg_pool2d : t -> output_size:int list -> t
  val _adaptive_avg_pool2d_backward : grad_output:t -> t -> t
  val _add_batch_dim : t -> batch_dim:int -> level:int -> t
  val _add_relu : t -> t -> t
  val _add_relu_ : t -> t -> t
  val _add_relu_out : out:t -> t -> t -> t
  val _addmv_impl_ : t -> self2:t -> mat:t -> vec:t -> t
  val _aminmax : t -> t * t
  val _aminmax1 : t -> dim:int -> keepdim:bool -> t * t

  val _amp_update_scale
    :  growth_tracker:t
    -> current_scale:t
    -> found_inf:t
    -> scale_growth_factor:float
    -> scale_backoff_factor:float
    -> growth_interval:int
    -> t

  val _baddbmm_mkl_ : t -> batch1:t -> batch2:t -> t
  val _bmm : t -> mat2:t -> deterministic:bool -> t
  val _bmm_out : out:t -> t -> mat2:t -> deterministic:bool -> t
  val _cast_byte : t -> non_blocking:bool -> t
  val _cast_char : t -> non_blocking:bool -> t
  val _cast_double : t -> non_blocking:bool -> t
  val _cast_float : t -> non_blocking:bool -> t
  val _cast_half : t -> non_blocking:bool -> t
  val _cast_int : t -> non_blocking:bool -> t
  val _cast_long : t -> non_blocking:bool -> t
  val _cast_short : t -> non_blocking:bool -> t
  val _cat : t list -> dim:int -> t
  val _cat_out : out:t -> t list -> dim:int -> t
  val _cdist_backward : grad:t -> x1:t -> x2:t -> p:float -> cdist:t -> t
  val _cholesky_helper : t -> upper:bool -> t
  val _cholesky_solve_helper : t -> a:t -> upper:bool -> t
  val _coalesced_ : t -> coalesced:bool -> t
  val _compute_linear_combination : t -> coefficients:t -> t
  val _compute_linear_combination_out : out:t -> t -> coefficients:t -> t
  val _conj : t -> t

  val _convolution
    :  t
    -> weight:t
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> transposed:bool
    -> output_padding:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> cudnn_enabled:bool
    -> t

  val _convolution1
    :  t
    -> weight:t
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> transposed:bool
    -> output_padding:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> cudnn_enabled:bool
    -> allow_tf32:bool
    -> t

  val _convolution_nogroup
    :  t
    -> weight:t
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> transposed:bool
    -> output_padding:int list
    -> t

  val _copy_from : t -> dst:t -> non_blocking:bool -> t

  val _ctc_loss
    :  log_probs:t
    -> targets:t
    -> input_lengths:int list
    -> target_lengths:int list
    -> blank:int
    -> zero_infinity:bool
    -> t * t

  val _ctc_loss_backward
    :  grad:t
    -> log_probs:t
    -> targets:t
    -> input_lengths:int list
    -> target_lengths:int list
    -> neg_log_likelihood:t
    -> log_alpha:t
    -> blank:int
    -> zero_infinity:bool
    -> t

  val _cudnn_ctc_loss
    :  log_probs:t
    -> targets:t
    -> input_lengths:int list
    -> target_lengths:int list
    -> blank:int
    -> deterministic:bool
    -> zero_infinity:bool
    -> t * t

  val _cudnn_init_dropout_state
    :  dropout:float
    -> train:bool
    -> dropout_seed:int
    -> options:Kind.packed * Device.t
    -> t

  val _cudnn_rnn
    :  t
    -> weight:t list
    -> weight_stride0:int
    -> weight_buf:t option
    -> hx:t
    -> cx:t option
    -> mode:int
    -> hidden_size:int
    -> proj_size:int
    -> num_layers:int
    -> batch_first:bool
    -> dropout:float
    -> train:bool
    -> bidirectional:bool
    -> batch_sizes:int list
    -> dropout_state:t option
    -> t * t * t * t * t

  val _cudnn_rnn_flatten_weight
    :  weight_arr:t list
    -> weight_stride0:int
    -> input_size:int
    -> mode:int
    -> hidden_size:int
    -> proj_size:int
    -> num_layers:int
    -> batch_first:bool
    -> bidirectional:bool
    -> t

  val _cumprod : t -> dim:int -> t
  val _cumprod_out : out:t -> t -> dim:int -> t
  val _cumsum : t -> dim:int -> t
  val _cumsum_out : out:t -> t -> dim:int -> t
  val _dim_arange : like:t -> dim:int -> t
  val _dirichlet_grad : x:t -> alpha:t -> total:t -> t

  val _embedding_bag
    :  weight:t
    -> indices:t
    -> offsets:t
    -> scale_grad_by_freq:bool
    -> mode:int
    -> sparse:bool
    -> per_sample_weights:t option
    -> include_last_offset:bool
    -> t * t * t * t

  val _embedding_bag_backward
    :  grad:t
    -> indices:t
    -> offsets:t
    -> offset2bag:t
    -> bag_size:t
    -> maximum_indices:t
    -> num_weights:int
    -> scale_grad_by_freq:bool
    -> mode:int
    -> sparse:bool
    -> per_sample_weights:t option
    -> t

  val _embedding_bag_dense_backward
    :  grad:t
    -> indices:t
    -> offsets:t
    -> offset2bag:t
    -> bag_size:t
    -> maximum_indices:t
    -> num_weights:int
    -> scale_grad_by_freq:bool
    -> mode:int
    -> per_sample_weights:t option
    -> t

  val _embedding_bag_forward_only
    :  weight:t
    -> indices:t
    -> offsets:t
    -> scale_grad_by_freq:bool
    -> mode:int
    -> sparse:bool
    -> per_sample_weights:t option
    -> include_last_offset:bool
    -> t * t * t * t

  val _embedding_bag_per_sample_weights_backward
    :  grad:t
    -> weight:t
    -> indices:t
    -> offsets:t
    -> offset2bag:t
    -> mode:int
    -> t

  val _embedding_bag_sparse_backward
    :  grad:t
    -> indices:t
    -> offsets:t
    -> offset2bag:t
    -> bag_size:t
    -> num_weights:int
    -> scale_grad_by_freq:bool
    -> mode:int
    -> per_sample_weights:t option
    -> t

  val _empty_affine_quantized
    :  size:int list
    -> options:Kind.packed * Device.t
    -> scale:float
    -> zero_point:int
    -> t

  val _empty_per_channel_affine_quantized
    :  size:int list
    -> scales:t
    -> zero_points:t
    -> axis:int
    -> options:Kind.packed * Device.t
    -> t

  val _euclidean_dist : x1:t -> x2:t -> t

  val _fake_quantize_learnable_per_channel_affine
    :  t
    -> scale:t
    -> zero_point:t
    -> axis:int
    -> quant_min:int
    -> quant_max:int
    -> grad_factor:float
    -> t

  val _fake_quantize_learnable_per_channel_affine_backward
    :  grad:t
    -> t
    -> scale:t
    -> zero_point:t
    -> axis:int
    -> quant_min:int
    -> quant_max:int
    -> grad_factor:float
    -> t * t * t

  val _fake_quantize_learnable_per_tensor_affine
    :  t
    -> scale:t
    -> zero_point:t
    -> quant_min:int
    -> quant_max:int
    -> grad_factor:float
    -> t

  val _fake_quantize_learnable_per_tensor_affine_backward
    :  grad:t
    -> t
    -> scale:t
    -> zero_point:t
    -> quant_min:int
    -> quant_max:int
    -> grad_factor:float
    -> t * t * t

  val _fft_c2c : t -> dim:int list -> normalization:int -> forward:bool -> t
  val _fft_c2c_out : out:t -> t -> dim:int list -> normalization:int -> forward:bool -> t
  val _fft_c2r : t -> dim:int list -> normalization:int -> last_dim_size:int -> t

  val _fft_c2r_out
    :  out:t
    -> t
    -> dim:int list
    -> normalization:int
    -> last_dim_size:int
    -> t

  val _fft_r2c : t -> dim:int list -> normalization:int -> onesided:bool -> t
  val _fft_r2c_out : out:t -> t -> dim:int list -> normalization:int -> onesided:bool -> t
  val _fused_dropout : t -> p:float -> t * t
  val _fw_primal : t -> level:int -> t
  val _gather_sparse_backward : t -> dim:int -> index:t -> grad:t -> t

  val _grid_sampler_2d_cpu_fallback
    :  t
    -> grid:t
    -> interpolation_mode:int
    -> padding_mode:int
    -> align_corners:bool
    -> t

  val _grid_sampler_2d_cpu_fallback_backward
    :  grad_output:t
    -> t
    -> grid:t
    -> interpolation_mode:int
    -> padding_mode:int
    -> align_corners:bool
    -> t * t

  val _index_copy_ : t -> dim:int -> index:t -> source:t -> t

  val _index_put_impl_
    :  t
    -> indices:t option list
    -> values:t
    -> accumulate:bool
    -> unsafe:bool
    -> t

  val _indices : t -> t
  val _inverse_helper : t -> t
  val _linalg_inv_out_helper_ : t -> infos_lu:t -> infos_getri:t -> t
  val _linalg_qr_helper : t -> mode:string -> t * t
  val _linalg_solve_out_helper_ : t -> t -> infos:t -> t
  val _log_softmax : t -> dim:int -> half_to_float:bool -> t
  val _log_softmax_backward_data : grad_output:t -> output:t -> dim:int -> t -> t
  val _logcumsumexp : t -> dim:int -> t
  val _logcumsumexp_out : out:t -> t -> dim:int -> t
  val _lu_solve_helper : t -> lu_data:t -> lu_pivots:t -> t
  val _lu_with_info : t -> pivot:bool -> check_errors:bool -> t * t * t
  val _make_dual : primal:t -> tangent:t -> level:int -> t
  val _make_per_channel_quantized_tensor : t -> scale:t -> zero_point:t -> axis:int -> t
  val _make_per_tensor_quantized_tensor : t -> scale:float -> zero_point:int -> t
  val _masked_scale : t -> mask:t -> scale:float -> t
  val _mkldnn_reshape : t -> shape:int list -> t
  val _mkldnn_transpose : t -> dim0:int -> dim1:int -> t
  val _mkldnn_transpose_ : t -> dim0:int -> dim1:int -> t
  val _mode : t -> dim:int -> keepdim:bool -> t * t
  val _mode_out : values:t -> indices:t -> t -> dim:int -> keepdim:bool -> t * t

  val _nnpack_spatial_convolution
    :  t
    -> weight:t
    -> bias:t option
    -> padding:int list
    -> stride:int list
    -> t

  val _nnpack_spatial_convolution_backward_input
    :  t
    -> grad_output:t
    -> weight:t
    -> padding:int list
    -> t

  val _nnpack_spatial_convolution_backward_weight
    :  t
    -> weightsize:int list
    -> grad_output:t
    -> padding:int list
    -> t

  val _pack_padded_sequence : t -> lengths:t -> batch_first:bool -> t * t

  val _pack_padded_sequence_backward
    :  grad:t
    -> input_size:int list
    -> batch_sizes:t
    -> batch_first:bool
    -> t

  val _pad_packed_sequence
    :  data:t
    -> batch_sizes:t
    -> batch_first:bool
    -> padding_value:'a scalar
    -> total_length:int
    -> t * t

  val _pdist_backward : grad:t -> t -> p:float -> pdist:t -> t
  val _remove_batch_dim : t -> level:int -> batch_size:int -> out_dim:int -> t
  val _reshape_from_tensor : t -> shape:t -> t
  val _rowwise_prune : weight:t -> mask:t -> compressed_indices_dtype:Kind.packed -> t * t
  val _s_where : condition:t -> t -> t -> t
  val _sample_dirichlet : t -> t
  val _saturate_weight_to_fp16 : weight:t -> t
  val _shape_as_tensor : t -> t

  val _sobol_engine_draw
    :  quasi:t
    -> n:int
    -> sobolstate:t
    -> dimension:int
    -> num_generated:int
    -> dtype:Kind.packed
    -> t * t

  val _sobol_engine_ff_
    :  t
    -> n:int
    -> sobolstate:t
    -> dimension:int
    -> num_generated:int
    -> t

  val _sobol_engine_initialize_state_ : t -> dimension:int -> t
  val _sobol_engine_scramble_ : t -> ltm:t -> dimension:int -> t
  val _softmax : t -> dim:int -> half_to_float:bool -> t
  val _softmax_backward_data : grad_output:t -> output:t -> dim:int -> t -> t
  val _solve_helper : t -> a:t -> t * t
  val _sparse_addmm : t -> sparse:t -> dense:t -> t

  val _sparse_coo_tensor_unsafe
    :  indices:t
    -> values:t
    -> size:int list
    -> options:Kind.packed * Device.t
    -> t

  val _sparse_coo_tensor_with_dims
    :  sparse_dim:int
    -> dense_dim:int
    -> size:int list
    -> options:Kind.packed * Device.t
    -> t

  val _sparse_coo_tensor_with_dims_and_tensors
    :  sparse_dim:int
    -> dense_dim:int
    -> size:int list
    -> indices:t
    -> values:t
    -> options:Kind.packed * Device.t
    -> t

  val _sparse_log_softmax : t -> dim:int -> dtype:Kind.packed -> t
  val _sparse_log_softmax1 : t -> dim:int -> half_to_float:bool -> t
  val _sparse_log_softmax_backward_data : grad_output:t -> output:t -> dim:int -> t -> t
  val _sparse_matrix_mask_helper : tr:t -> mask_indices:t -> t
  val _sparse_mm : sparse:t -> dense:t -> t
  val _sparse_softmax : t -> dim:int -> dtype:Kind.packed -> t
  val _sparse_softmax1 : t -> dim:int -> half_to_float:bool -> t
  val _sparse_softmax_backward_data : grad_output:t -> output:t -> dim:int -> t -> t
  val _sparse_sparse_matmul : t -> t -> t
  val _sparse_sum : t -> t
  val _sparse_sum1 : t -> dtype:Kind.packed -> t
  val _sparse_sum2 : t -> dim:int list -> t
  val _sparse_sum3 : t -> dim:int list -> dtype:Kind.packed -> t
  val _sparse_sum_backward : grad:t -> t -> dim:int list -> t
  val _stack : t list -> dim:int -> t
  val _stack_out : out:t -> t list -> dim:int -> t
  val _standard_gamma : t -> t
  val _standard_gamma_grad : t -> output:t -> t
  val _std : t -> unbiased:bool -> t
  val _svd_helper : t -> some:bool -> compute_uv:bool -> t * t * t
  val _syevd_helper : t -> compute_eigenvectors:bool -> uplo:string -> t * t
  val _symeig_helper : t -> eigenvectors:bool -> upper:bool -> t * t
  val _test_ambiguous_defaults : dummy:t -> a:int -> b:int -> t
  val _test_ambiguous_defaults1 : dummy:t -> a:int -> b:string -> t
  val _test_optional_filled_intlist : values:t -> addends:int list -> t
  val _test_optional_intlist : values:t -> addends:int list -> t
  val _test_serialization_subcmul : t -> t -> t
  val _test_string_default : dummy:t -> a:string -> b:string -> t

  val _thnn_differentiable_gru_cell_backward
    :  grad_hy:t
    -> input_gates:t
    -> hidden_gates:t
    -> hx:t
    -> input_bias:t option
    -> hidden_bias:t option
    -> t * t * t * t * t

  val _thnn_differentiable_lstm_cell_backward
    :  grad_hy:t option
    -> grad_cy:t option
    -> input_gates:t
    -> hidden_gates:t
    -> input_bias:t option
    -> hidden_bias:t option
    -> cx:t
    -> cy:t
    -> t * t * t * t * t

  val _thnn_fused_gru_cell
    :  input_gates:t
    -> hidden_gates:t
    -> hx:t
    -> input_bias:t option
    -> hidden_bias:t option
    -> t * t

  val _thnn_fused_gru_cell_backward
    :  grad_hy:t
    -> workspace:t
    -> has_bias:bool
    -> t * t * t * t * t

  val _thnn_fused_lstm_cell
    :  input_gates:t
    -> hidden_gates:t
    -> cx:t
    -> input_bias:t option
    -> hidden_bias:t option
    -> t * t * t

  val _thnn_fused_lstm_cell_backward
    :  grad_hy:t option
    -> grad_cy:t option
    -> cx:t
    -> cy:t
    -> workspace:t
    -> has_bias:bool
    -> t * t * t * t * t

  val _triangular_solve_helper
    :  t
    -> a:t
    -> upper:bool
    -> transpose:bool
    -> unitriangular:bool
    -> t * t

  val _trilinear
    :  i1:t
    -> i2:t
    -> i3:t
    -> expand1:int list
    -> expand2:int list
    -> expand3:int list
    -> sumdim:int list
    -> unroll_dim:int
    -> t

  val _unique : t -> sorted:bool -> return_inverse:bool -> t * t

  val _unique2
    :  t
    -> sorted:bool
    -> return_inverse:bool
    -> return_counts:bool
    -> t * t * t

  val _unpack_dual : dual:t -> level:int -> t * t
  val _unsafe_view : t -> size:int list -> t
  val _values : t -> t
  val _var : t -> unbiased:bool -> t
  val _weight_norm : v:t -> g:t -> dim:int -> t
  val _weight_norm_cuda_interface : v:t -> g:t -> dim:int -> t * t

  val _weight_norm_cuda_interface_backward
    :  grad_w:t
    -> saved_v:t
    -> saved_g:t
    -> saved_norms:t
    -> dim:int
    -> t * t

  val _weight_norm_differentiable_backward
    :  grad_w:t
    -> saved_v:t
    -> saved_g:t
    -> saved_norms:t
    -> dim:int
    -> t * t

  val abs : t -> t
  val abs_ : t -> t
  val abs_out : out:t -> t -> t
  val absolute : t -> t
  val absolute_ : t -> t
  val absolute_out : out:t -> t -> t
  val acos : t -> t
  val acos_ : t -> t
  val acos_out : out:t -> t -> t
  val acosh : t -> t
  val acosh_ : t -> t
  val acosh_out : out:t -> t -> t
  val adaptive_avg_pool1d : t -> output_size:int list -> t
  val adaptive_avg_pool2d : t -> output_size:int list -> t
  val adaptive_avg_pool2d_out : out:t -> t -> output_size:int list -> t
  val adaptive_avg_pool3d : t -> output_size:int list -> t
  val adaptive_avg_pool3d_backward : grad_output:t -> t -> t
  val adaptive_avg_pool3d_backward_out : grad_input:t -> grad_output:t -> t -> t
  val adaptive_avg_pool3d_out : out:t -> t -> output_size:int list -> t
  val adaptive_max_pool1d : t -> output_size:int list -> t * t
  val adaptive_max_pool2d : t -> output_size:int list -> t * t
  val adaptive_max_pool2d_backward : grad_output:t -> t -> indices:t -> t

  val adaptive_max_pool2d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> indices:t
    -> t

  val adaptive_max_pool2d_out : out:t -> indices:t -> t -> output_size:int list -> t * t
  val adaptive_max_pool3d : t -> output_size:int list -> t * t
  val adaptive_max_pool3d_backward : grad_output:t -> t -> indices:t -> t

  val adaptive_max_pool3d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> indices:t
    -> t

  val adaptive_max_pool3d_out : out:t -> indices:t -> t -> output_size:int list -> t * t
  val add : t -> t -> t
  val add1 : t -> 'a scalar -> t
  val add_ : t -> t -> t
  val add_1 : t -> 'a scalar -> t
  val add_out : out:t -> t -> t -> t
  val addbmm : t -> batch1:t -> batch2:t -> t
  val addbmm_ : t -> batch1:t -> batch2:t -> t
  val addbmm_out : out:t -> t -> batch1:t -> batch2:t -> t
  val addcdiv : t -> tensor1:t -> tensor2:t -> t
  val addcdiv_ : t -> tensor1:t -> tensor2:t -> t
  val addcdiv_out : out:t -> t -> tensor1:t -> tensor2:t -> t
  val addcmul : t -> tensor1:t -> tensor2:t -> t
  val addcmul_ : t -> tensor1:t -> tensor2:t -> t
  val addcmul_out : out:t -> t -> tensor1:t -> tensor2:t -> t
  val addmm : t -> mat1:t -> mat2:t -> t
  val addmm_ : t -> mat1:t -> mat2:t -> t
  val addmm_out : out:t -> t -> mat1:t -> mat2:t -> t
  val addmv : t -> mat:t -> vec:t -> t
  val addmv_ : t -> mat:t -> vec:t -> t
  val addmv_out : out:t -> t -> mat:t -> vec:t -> t
  val addr : t -> vec1:t -> vec2:t -> t
  val addr_ : t -> vec1:t -> vec2:t -> t
  val addr_out : out:t -> t -> vec1:t -> vec2:t -> t
  val affine_grid_generator : theta:t -> size:int list -> align_corners:bool -> t
  val affine_grid_generator_backward : grad:t -> size:int list -> align_corners:bool -> t
  val alias : t -> t
  val align_as : t -> t -> t
  val align_tensors : t list -> t list
  val all : t -> t
  val all1 : t -> dim:int -> keepdim:bool -> t
  val all_out : out:t -> t -> dim:int -> keepdim:bool -> t
  val alpha_dropout : t -> p:float -> train:bool -> t
  val alpha_dropout_ : t -> p:float -> train:bool -> t
  val amax : t -> dim:int list -> keepdim:bool -> t
  val amax_out : out:t -> t -> dim:int list -> keepdim:bool -> t
  val amin : t -> dim:int list -> keepdim:bool -> t
  val amin_out : out:t -> t -> dim:int list -> keepdim:bool -> t
  val angle : t -> t
  val angle_out : out:t -> t -> t
  val any : t -> t
  val any1 : t -> dim:int -> keepdim:bool -> t
  val any_out : out:t -> t -> dim:int -> keepdim:bool -> t
  val arange : end_:'a scalar -> options:Kind.packed * Device.t -> t
  val arange1 : start:'a scalar -> end_:'a scalar -> options:Kind.packed * Device.t -> t

  val arange2
    :  start:'a scalar
    -> end_:'a scalar
    -> step:'a scalar
    -> options:Kind.packed * Device.t
    -> t

  val arange_out : out:t -> end_:'a scalar -> t
  val arange_out1 : out:t -> start:'a scalar -> end_:'a scalar -> t
  val arccos : t -> t
  val arccos_ : t -> t
  val arccos_out : out:t -> t -> t
  val arccosh : t -> t
  val arccosh_ : t -> t
  val arccosh_out : out:t -> t -> t
  val arcsin : t -> t
  val arcsin_ : t -> t
  val arcsin_out : out:t -> t -> t
  val arcsinh : t -> t
  val arcsinh_ : t -> t
  val arcsinh_out : out:t -> t -> t
  val arctan : t -> t
  val arctan_ : t -> t
  val arctan_out : out:t -> t -> t
  val arctanh : t -> t
  val arctanh_ : t -> t
  val arctanh_out : out:t -> t -> t
  val argmax : t -> dim:int -> keepdim:bool -> t
  val argmax_out : out:t -> t -> dim:int -> keepdim:bool -> t
  val argmin : t -> dim:int -> keepdim:bool -> t
  val argmin_out : out:t -> t -> dim:int -> keepdim:bool -> t
  val argsort : t -> dim:int -> descending:bool -> t
  val as_strided : t -> size:int list -> stride:int list -> storage_offset:int -> t
  val as_strided_ : t -> size:int list -> stride:int list -> storage_offset:int -> t
  val asin : t -> t
  val asin_ : t -> t
  val asin_out : out:t -> t -> t
  val asinh : t -> t
  val asinh_ : t -> t
  val asinh_out : out:t -> t -> t
  val atan : t -> t
  val atan2 : t -> t -> t
  val atan2_ : t -> t -> t
  val atan2_out : out:t -> t -> t -> t
  val atan_ : t -> t
  val atan_out : out:t -> t -> t
  val atanh : t -> t
  val atanh_ : t -> t
  val atanh_out : out:t -> t -> t
  val atleast_1d : t -> t
  val atleast_1d1 : t list -> t list
  val atleast_2d : t -> t
  val atleast_2d1 : t list -> t list
  val atleast_3d : t -> t
  val atleast_3d1 : t list -> t list

  val avg_pool1d
    :  t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> ceil_mode:bool
    -> count_include_pad:bool
    -> t

  val avg_pool2d
    :  t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> ceil_mode:bool
    -> count_include_pad:bool
    -> divisor_override:int
    -> t

  val avg_pool2d_backward
    :  grad_output:t
    -> t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> ceil_mode:bool
    -> count_include_pad:bool
    -> divisor_override:int
    -> t

  val avg_pool2d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> ceil_mode:bool
    -> count_include_pad:bool
    -> divisor_override:int
    -> t

  val avg_pool2d_out
    :  out:t
    -> t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> ceil_mode:bool
    -> count_include_pad:bool
    -> divisor_override:int
    -> t

  val avg_pool3d
    :  t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> ceil_mode:bool
    -> count_include_pad:bool
    -> divisor_override:int
    -> t

  val avg_pool3d_backward
    :  grad_output:t
    -> t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> ceil_mode:bool
    -> count_include_pad:bool
    -> divisor_override:int
    -> t

  val avg_pool3d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> ceil_mode:bool
    -> count_include_pad:bool
    -> divisor_override:int
    -> t

  val avg_pool3d_out
    :  out:t
    -> t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> ceil_mode:bool
    -> count_include_pad:bool
    -> divisor_override:int
    -> t

  val baddbmm : t -> batch1:t -> batch2:t -> t
  val baddbmm_ : t -> batch1:t -> batch2:t -> t
  val baddbmm_out : out:t -> t -> batch1:t -> batch2:t -> t
  val bartlett_window : window_length:int -> options:Kind.packed * Device.t -> t

  val bartlett_window1
    :  window_length:int
    -> periodic:bool
    -> options:Kind.packed * Device.t
    -> t

  val batch_norm
    :  t
    -> weight:t option
    -> bias:t option
    -> running_mean:t option
    -> running_var:t option
    -> training:bool
    -> momentum:float
    -> eps:float
    -> cudnn_enabled:bool
    -> t

  val batch_norm_backward_elemt
    :  grad_out:t
    -> t
    -> mean:t
    -> invstd:t
    -> weight:t option
    -> mean_dy:t
    -> mean_dy_xmu:t
    -> t

  val batch_norm_backward_reduce
    :  grad_out:t
    -> t
    -> mean:t
    -> invstd:t
    -> weight:t option
    -> input_g:bool
    -> weight_g:bool
    -> bias_g:bool
    -> t * t * t * t

  val batch_norm_elemt
    :  t
    -> weight:t option
    -> bias:t option
    -> mean:t
    -> invstd:t
    -> eps:float
    -> t

  val batch_norm_elemt_out
    :  out:t
    -> t
    -> weight:t option
    -> bias:t option
    -> mean:t
    -> invstd:t
    -> eps:float
    -> t

  val batch_norm_gather_stats
    :  t
    -> mean:t
    -> invstd:t
    -> running_mean:t option
    -> running_var:t option
    -> momentum:float
    -> eps:float
    -> count:int
    -> t * t

  val batch_norm_gather_stats_with_counts
    :  t
    -> mean:t
    -> invstd:t
    -> running_mean:t option
    -> running_var:t option
    -> momentum:float
    -> eps:float
    -> counts:t
    -> t * t

  val batch_norm_stats : t -> eps:float -> t * t

  val batch_norm_update_stats
    :  t
    -> running_mean:t option
    -> running_var:t option
    -> momentum:float
    -> t * t

  val bernoulli : t -> t
  val bernoulli1 : t -> p:float -> t
  val bernoulli_ : t -> p:t -> t
  val bernoulli_1 : t -> p:float -> t
  val bernoulli_out : out:t -> t -> t
  val bilinear : input1:t -> input2:t -> weight:t -> bias:t option -> t

  val binary_cross_entropy
    :  t
    -> target:t
    -> weight:t option
    -> reduction:Reduction.t
    -> t

  val binary_cross_entropy_backward
    :  grad_output:t
    -> t
    -> target:t
    -> weight:t option
    -> reduction:Reduction.t
    -> t

  val binary_cross_entropy_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> target:t
    -> weight:t option
    -> reduction:Reduction.t
    -> t

  val binary_cross_entropy_out
    :  out:t
    -> t
    -> target:t
    -> weight:t option
    -> reduction:Reduction.t
    -> t

  val binary_cross_entropy_with_logits
    :  t
    -> target:t
    -> weight:t option
    -> pos_weight:t option
    -> reduction:Reduction.t
    -> t

  val binary_cross_entropy_with_logits_backward
    :  grad_output:t
    -> t
    -> target:t
    -> weight:t option
    -> pos_weight:t option
    -> reduction:Reduction.t
    -> t

  val bincount : t -> weights:t option -> minlength:int -> t
  val binomial : count:t -> prob:t -> t
  val bitwise_and : t -> 'a scalar -> t
  val bitwise_and1 : t -> t -> t
  val bitwise_and_ : t -> 'a scalar -> t
  val bitwise_and_1 : t -> t -> t
  val bitwise_and_out : out:t -> t -> t -> t
  val bitwise_and_out1 : out:t -> t -> 'a scalar -> t
  val bitwise_not : t -> t
  val bitwise_not_ : t -> t
  val bitwise_not_out : out:t -> t -> t
  val bitwise_or : t -> 'a scalar -> t
  val bitwise_or1 : t -> t -> t
  val bitwise_or_ : t -> 'a scalar -> t
  val bitwise_or_1 : t -> t -> t
  val bitwise_or_out : out:t -> t -> t -> t
  val bitwise_or_out1 : out:t -> t -> 'a scalar -> t
  val bitwise_xor : t -> 'a scalar -> t
  val bitwise_xor1 : t -> t -> t
  val bitwise_xor_ : t -> 'a scalar -> t
  val bitwise_xor_1 : t -> t -> t
  val bitwise_xor_out : out:t -> t -> t -> t
  val bitwise_xor_out1 : out:t -> t -> 'a scalar -> t
  val blackman_window : window_length:int -> options:Kind.packed * Device.t -> t

  val blackman_window1
    :  window_length:int
    -> periodic:bool
    -> options:Kind.packed * Device.t
    -> t

  val block_diag : t list -> t
  val bmm : t -> mat2:t -> t
  val bmm_out : out:t -> t -> mat2:t -> t
  val broadcast_tensors : t list -> t list
  val broadcast_to : t -> size:int list -> t
  val bucketize : t -> boundaries:t -> out_int32:bool -> right:bool -> t
  val bucketize1 : 'a scalar -> boundaries:t -> out_int32:bool -> right:bool -> t
  val bucketize_out : out:t -> t -> boundaries:t -> out_int32:bool -> right:bool -> t
  val cartesian_prod : t list -> t
  val cat : t list -> dim:int -> t
  val cat_out : out:t -> t list -> dim:int -> t
  val cauchy_ : t -> median:float -> sigma:float -> t
  val cdist : x1:t -> x2:t -> p:float -> compute_mode:int -> t
  val ceil : t -> t
  val ceil_ : t -> t
  val ceil_out : out:t -> t -> t
  val celu : t -> t
  val celu_ : t -> t
  val chain_matmul : matrices:t list -> t
  val channel_shuffle : t -> groups:int -> t
  val cholesky : t -> upper:bool -> t
  val cholesky_inverse : t -> upper:bool -> t
  val cholesky_inverse_out : out:t -> t -> upper:bool -> t
  val cholesky_out : out:t -> t -> upper:bool -> t
  val cholesky_solve : t -> input2:t -> upper:bool -> t
  val cholesky_solve_out : out:t -> t -> input2:t -> upper:bool -> t

  val choose_qparams_optimized
    :  t
    -> numel:int
    -> n_bins:int
    -> ratio:float
    -> bit_width:int
    -> t * t

  val chunk : t -> chunks:int -> dim:int -> t list
  val clamp : t -> min:'a scalar -> max:'a scalar -> t
  val clamp_ : t -> min:'a scalar -> max:'a scalar -> t
  val clamp_max : t -> max:'a scalar -> t
  val clamp_max_ : t -> max:'a scalar -> t
  val clamp_max_out : out:t -> t -> max:'a scalar -> t
  val clamp_min : t -> min:'a scalar -> t
  val clamp_min_ : t -> min:'a scalar -> t
  val clamp_min_out : out:t -> t -> min:'a scalar -> t
  val clamp_out : out:t -> t -> min:'a scalar -> max:'a scalar -> t
  val clip : t -> min:'a scalar -> max:'a scalar -> t
  val clip_ : t -> min:'a scalar -> max:'a scalar -> t
  val clip_out : out:t -> t -> min:'a scalar -> max:'a scalar -> t
  val clone : t -> t
  val coalesce : t -> t

  val col2im
    :  t
    -> output_size:int list
    -> kernel_size:int list
    -> dilation:int list
    -> padding:int list
    -> stride:int list
    -> t

  val col2im_backward
    :  grad_output:t
    -> kernel_size:int list
    -> dilation:int list
    -> padding:int list
    -> stride:int list
    -> t

  val col2im_backward_out
    :  grad_input:t
    -> grad_output:t
    -> kernel_size:int list
    -> dilation:int list
    -> padding:int list
    -> stride:int list
    -> t

  val col2im_out
    :  out:t
    -> t
    -> output_size:int list
    -> kernel_size:int list
    -> dilation:int list
    -> padding:int list
    -> stride:int list
    -> t

  val column_stack : t list -> t
  val column_stack_out : out:t -> t list -> t
  val combinations : t -> r:int -> with_replacement:bool -> t
  val complex : real:t -> imag:t -> t
  val complex_out : out:t -> real:t -> imag:t -> t
  val conj : t -> t
  val conj_out : out:t -> t -> t
  val constant_pad_nd : t -> pad:int list -> t
  val contiguous : t -> t

  val conv1d
    :  t
    -> weight:t
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> groups:int
    -> t

  val conv2d
    :  t
    -> weight:t
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> groups:int
    -> t

  val conv3d
    :  t
    -> weight:t
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> groups:int
    -> t

  val conv_tbc : t -> weight:t -> bias:t -> pad:int -> t
  val conv_tbc_backward : t -> t -> weight:t -> bias:t -> pad:int -> t * t * t

  val conv_transpose1d
    :  t
    -> weight:t
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> output_padding:int list
    -> groups:int
    -> dilation:int list
    -> t

  val conv_transpose2d
    :  t
    -> weight:t
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> output_padding:int list
    -> groups:int
    -> dilation:int list
    -> t

  val conv_transpose3d
    :  t
    -> weight:t
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> output_padding:int list
    -> groups:int
    -> dilation:int list
    -> t

  val convolution
    :  t
    -> weight:t
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> transposed:bool
    -> output_padding:int list
    -> groups:int
    -> t

  val convolution_overrideable
    :  t
    -> weight:t
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> transposed:bool
    -> output_padding:int list
    -> groups:int
    -> t

  val copy_sparse_to_sparse_ : t -> src:t -> non_blocking:bool -> t
  val copysign : t -> t -> t
  val copysign1 : t -> 'a scalar -> t
  val copysign_ : t -> t -> t
  val copysign_1 : t -> 'a scalar -> t
  val copysign_out : out:t -> t -> t -> t
  val cos : t -> t
  val cos_ : t -> t
  val cos_out : out:t -> t -> t
  val cosh : t -> t
  val cosh_ : t -> t
  val cosh_out : out:t -> t -> t

  val cosine_embedding_loss
    :  input1:t
    -> input2:t
    -> target:t
    -> margin:float
    -> reduction:Reduction.t
    -> t

  val cosine_similarity : x1:t -> x2:t -> dim:int -> eps:float -> t
  val cross : t -> t -> dim:int -> t
  val cross_out : out:t -> t -> t -> dim:int -> t

  val ctc_loss
    :  log_probs:t
    -> targets:t
    -> input_lengths:int list
    -> target_lengths:int list
    -> blank:int
    -> reduction:Reduction.t
    -> zero_infinity:bool
    -> t

  val ctc_loss1
    :  log_probs:t
    -> targets:t
    -> input_lengths:t
    -> target_lengths:t
    -> blank:int
    -> reduction:Reduction.t
    -> zero_infinity:bool
    -> t

  val cudnn_affine_grid_generator : theta:t -> n:int -> c:int -> h:int -> w:int -> t

  val cudnn_affine_grid_generator_backward
    :  grad:t
    -> n:int
    -> c:int
    -> h:int
    -> w:int
    -> t

  val cudnn_batch_norm
    :  t
    -> weight:t
    -> bias:t option
    -> running_mean:t option
    -> running_var:t option
    -> training:bool
    -> exponential_average_factor:float
    -> epsilon:float
    -> t * t * t * t

  val cudnn_batch_norm_backward
    :  t
    -> grad_output:t
    -> weight:t
    -> running_mean:t option
    -> running_var:t option
    -> save_mean:t option
    -> save_var:t option
    -> epsilon:float
    -> reservespace:t
    -> t * t * t

  val cudnn_convolution
    :  t
    -> weight:t
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> t

  val cudnn_convolution1
    :  t
    -> weight:t
    -> bias:t option
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> t

  val cudnn_convolution2
    :  t
    -> weight:t
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> allow_tf32:bool
    -> t

  val cudnn_convolution_backward_input
    :  self_size:int list
    -> grad_output:t
    -> weight:t
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> allow_tf32:bool
    -> t

  val cudnn_convolution_backward_weight
    :  weight_size:int list
    -> grad_output:t
    -> t
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> allow_tf32:bool
    -> t

  val cudnn_convolution_transpose
    :  t
    -> weight:t
    -> padding:int list
    -> output_padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> t

  val cudnn_convolution_transpose1
    :  t
    -> weight:t
    -> bias:t option
    -> padding:int list
    -> output_padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> t

  val cudnn_convolution_transpose2
    :  t
    -> weight:t
    -> padding:int list
    -> output_padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> allow_tf32:bool
    -> t

  val cudnn_convolution_transpose_backward_input
    :  grad_output:t
    -> weight:t
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> allow_tf32:bool
    -> t

  val cudnn_convolution_transpose_backward_weight
    :  weight_size:int list
    -> grad_output:t
    -> t
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> allow_tf32:bool
    -> t

  val cudnn_grid_sampler : t -> grid:t -> t
  val cudnn_grid_sampler_backward : t -> grid:t -> grad_output:t -> t * t
  val cummax : t -> dim:int -> t * t
  val cummax_out : values:t -> indices:t -> t -> dim:int -> t * t
  val cummaxmin_backward : grad:t -> t -> indices:t -> dim:int -> t
  val cummin : t -> dim:int -> t * t
  val cummin_out : values:t -> indices:t -> t -> dim:int -> t * t
  val cumprod : t -> dim:int -> dtype:Kind.packed -> t
  val cumprod_ : t -> dim:int -> dtype:Kind.packed -> t
  val cumprod_backward : grad:t -> t -> dim:int -> t
  val cumprod_out : out:t -> t -> dim:int -> dtype:Kind.packed -> t
  val cumsum : t -> dim:int -> dtype:Kind.packed -> t
  val cumsum_ : t -> dim:int -> dtype:Kind.packed -> t
  val cumsum_out : out:t -> t -> dim:int -> dtype:Kind.packed -> t
  val data : t -> t
  val deg2rad : t -> t
  val deg2rad_ : t -> t
  val deg2rad_out : out:t -> t -> t
  val dequantize : t -> t
  val dequantize1 : t list -> t list
  val det : t -> t
  val detach : t -> t
  val detach_ : t -> t
  val diag : t -> diagonal:int -> t
  val diag_backward : grad:t -> input_sizes:int list -> diagonal:int -> t
  val diag_embed : t -> offset:int -> dim1:int -> dim2:int -> t
  val diag_out : out:t -> t -> diagonal:int -> t
  val diagflat : t -> offset:int -> t
  val diagonal : t -> offset:int -> dim1:int -> dim2:int -> t

  val diagonal_backward
    :  grad:t
    -> input_sizes:int list
    -> offset:int
    -> dim1:int
    -> dim2:int
    -> t

  val diff : t -> n:int -> dim:int -> prepend:t option -> append:t option -> t

  val diff_out
    :  out:t
    -> t
    -> n:int
    -> dim:int
    -> prepend:t option
    -> append:t option
    -> t

  val digamma : t -> t
  val digamma_ : t -> t
  val digamma_out : out:t -> t -> t
  val dist : t -> t -> t
  val div : t -> t -> t
  val div1 : t -> 'a scalar -> t
  val div2 : t -> t -> rounding_mode:string -> t
  val div3 : t -> 'a scalar -> rounding_mode:string -> t
  val div_ : t -> t -> t
  val div_1 : t -> 'a scalar -> t
  val div_2 : t -> t -> rounding_mode:string -> t
  val div_3 : t -> 'a scalar -> rounding_mode:string -> t
  val div_out : out:t -> t -> t -> t
  val div_out1 : out:t -> t -> t -> rounding_mode:string -> t
  val divide : t -> t -> t
  val divide1 : t -> 'a scalar -> t
  val divide2 : t -> t -> rounding_mode:string -> t
  val divide3 : t -> 'a scalar -> rounding_mode:string -> t
  val divide_ : t -> t -> t
  val divide_1 : t -> 'a scalar -> t
  val divide_2 : t -> t -> rounding_mode:string -> t
  val divide_3 : t -> 'a scalar -> rounding_mode:string -> t
  val divide_out : out:t -> t -> t -> t
  val divide_out1 : out:t -> t -> t -> rounding_mode:string -> t
  val dot : t -> t -> t
  val dot_out : out:t -> t -> t -> t
  val dropout : t -> p:float -> train:bool -> t
  val dropout_ : t -> p:float -> train:bool -> t
  val dstack : t list -> t
  val dstack_out : out:t -> t list -> t
  val eig : t -> eigenvectors:bool -> t * t
  val eig_out : e:t -> v:t -> t -> eigenvectors:bool -> t * t
  val einsum : equation:string -> t list -> t
  val elu : t -> t
  val elu_ : t -> t

  val elu_backward
    :  grad_output:t
    -> alpha:'a scalar
    -> scale:'a scalar
    -> input_scale:'a scalar
    -> is_result:bool
    -> self_or_result:t
    -> t

  val elu_out : out:t -> t -> t

  val embedding
    :  weight:t
    -> indices:t
    -> padding_idx:int
    -> scale_grad_by_freq:bool
    -> sparse:bool
    -> t

  val embedding_backward
    :  grad:t
    -> indices:t
    -> num_weights:int
    -> padding_idx:int
    -> scale_grad_by_freq:bool
    -> sparse:bool
    -> t

  val embedding_bag
    :  weight:t
    -> indices:t
    -> offsets:t
    -> scale_grad_by_freq:bool
    -> mode:int
    -> sparse:bool
    -> per_sample_weights:t option
    -> include_last_offset:bool
    -> t * t * t * t

  val embedding_dense_backward
    :  grad_output:t
    -> indices:t
    -> num_weights:int
    -> padding_idx:int
    -> scale_grad_by_freq:bool
    -> t

  val embedding_renorm_ : t -> indices:t -> max_norm:float -> norm_type:float -> t

  val embedding_sparse_backward
    :  grad:t
    -> indices:t
    -> num_weights:int
    -> padding_idx:int
    -> scale_grad_by_freq:bool
    -> t

  val empty : size:int list -> options:Kind.packed * Device.t -> t
  val empty_like : t -> t
  val empty_meta : size:int list -> options:Kind.packed * Device.t -> t
  val empty_out : out:t -> size:int list -> t
  val empty_quantized : size:int list -> qtensor:t -> t

  val empty_strided
    :  size:int list
    -> stride:int list
    -> options:Kind.packed * Device.t
    -> t

  val eq : t -> 'a scalar -> t
  val eq1 : t -> t -> t
  val eq_ : t -> 'a scalar -> t
  val eq_1 : t -> t -> t
  val eq_out : out:t -> t -> 'a scalar -> t
  val eq_out1 : out:t -> t -> t -> t
  val erf : t -> t
  val erf_ : t -> t
  val erf_out : out:t -> t -> t
  val erfc : t -> t
  val erfc_ : t -> t
  val erfc_out : out:t -> t -> t
  val erfinv : t -> t
  val erfinv_ : t -> t
  val erfinv_out : out:t -> t -> t
  val exp : t -> t
  val exp2 : t -> t
  val exp2_ : t -> t
  val exp2_out : out:t -> t -> t
  val exp_ : t -> t
  val exp_out : out:t -> t -> t
  val expand : t -> size:int list -> implicit:bool -> t
  val expand_as : t -> t -> t
  val expm1 : t -> t
  val expm1_ : t -> t
  val expm1_out : out:t -> t -> t
  val exponential_ : t -> lambd:float -> t
  val eye : n:int -> options:Kind.packed * Device.t -> t
  val eye1 : n:int -> m:int -> options:Kind.packed * Device.t -> t
  val eye_out : out:t -> n:int -> t
  val eye_out1 : out:t -> n:int -> m:int -> t

  val fake_quantize_per_channel_affine
    :  t
    -> scale:t
    -> zero_point:t
    -> axis:int
    -> quant_min:int
    -> quant_max:int
    -> t

  val fake_quantize_per_channel_affine_cachemask
    :  t
    -> scale:t
    -> zero_point:t
    -> axis:int
    -> quant_min:int
    -> quant_max:int
    -> t * t

  val fake_quantize_per_channel_affine_cachemask_backward : grad:t -> mask:t -> t

  val fake_quantize_per_tensor_affine
    :  t
    -> scale:float
    -> zero_point:int
    -> quant_min:int
    -> quant_max:int
    -> t

  val fake_quantize_per_tensor_affine_cachemask
    :  t
    -> scale:float
    -> zero_point:int
    -> quant_min:int
    -> quant_max:int
    -> t * t

  val fake_quantize_per_tensor_affine_cachemask_backward : grad:t -> mask:t -> t
  val fbgemm_linear_fp16_weight : t -> packed_weight:t -> bias:t -> t
  val fbgemm_linear_fp16_weight_fp32_activation : t -> packed_weight:t -> bias:t -> t

  val fbgemm_linear_int8_weight
    :  t
    -> weight:t
    -> packed:t
    -> col_offsets:t
    -> weight_scale:'a scalar
    -> weight_zero_point:'a scalar
    -> bias:t
    -> t

  val fbgemm_linear_int8_weight_fp32_activation
    :  t
    -> weight:t
    -> packed:t
    -> col_offsets:t
    -> weight_scale:'a scalar
    -> weight_zero_point:'a scalar
    -> bias:t
    -> t

  val fbgemm_pack_gemm_matrix_fp16 : t -> t
  val fbgemm_pack_quantized_matrix : t -> t
  val fbgemm_pack_quantized_matrix1 : t -> k:int -> n:int -> t
  val feature_alpha_dropout : t -> p:float -> train:bool -> t
  val feature_alpha_dropout_ : t -> p:float -> train:bool -> t
  val feature_dropout : t -> p:float -> train:bool -> t
  val feature_dropout_ : t -> p:float -> train:bool -> t
  val fft_fft : t -> n:int -> dim:int -> norm:string -> t
  val fft_fft2 : t -> s:int list -> dim:int list -> norm:string -> t
  val fft_fft2_out : out:t -> t -> s:int list -> dim:int list -> norm:string -> t
  val fft_fft_out : out:t -> t -> n:int -> dim:int -> norm:string -> t
  val fft_fftfreq : n:int -> d:float -> options:Kind.packed * Device.t -> t
  val fft_fftfreq_out : out:t -> n:int -> d:float -> t
  val fft_fftn : t -> s:int list -> dim:int list -> norm:string -> t
  val fft_fftn_out : out:t -> t -> s:int list -> dim:int list -> norm:string -> t
  val fft_fftshift : t -> dim:int list -> t
  val fft_hfft : t -> n:int -> dim:int -> norm:string -> t
  val fft_hfft_out : out:t -> t -> n:int -> dim:int -> norm:string -> t
  val fft_ifft : t -> n:int -> dim:int -> norm:string -> t
  val fft_ifft2 : t -> s:int list -> dim:int list -> norm:string -> t
  val fft_ifft2_out : out:t -> t -> s:int list -> dim:int list -> norm:string -> t
  val fft_ifft_out : out:t -> t -> n:int -> dim:int -> norm:string -> t
  val fft_ifftn : t -> s:int list -> dim:int list -> norm:string -> t
  val fft_ifftn_out : out:t -> t -> s:int list -> dim:int list -> norm:string -> t
  val fft_ifftshift : t -> dim:int list -> t
  val fft_ihfft : t -> n:int -> dim:int -> norm:string -> t
  val fft_ihfft_out : out:t -> t -> n:int -> dim:int -> norm:string -> t
  val fft_irfft : t -> n:int -> dim:int -> norm:string -> t
  val fft_irfft2 : t -> s:int list -> dim:int list -> norm:string -> t
  val fft_irfft2_out : out:t -> t -> s:int list -> dim:int list -> norm:string -> t
  val fft_irfft_out : out:t -> t -> n:int -> dim:int -> norm:string -> t
  val fft_irfftn : t -> s:int list -> dim:int list -> norm:string -> t
  val fft_irfftn_out : out:t -> t -> s:int list -> dim:int list -> norm:string -> t
  val fft_rfft : t -> n:int -> dim:int -> norm:string -> t
  val fft_rfft2 : t -> s:int list -> dim:int list -> norm:string -> t
  val fft_rfft2_out : out:t -> t -> s:int list -> dim:int list -> norm:string -> t
  val fft_rfft_out : out:t -> t -> n:int -> dim:int -> norm:string -> t
  val fft_rfftfreq : n:int -> d:float -> options:Kind.packed * Device.t -> t
  val fft_rfftfreq_out : out:t -> n:int -> d:float -> t
  val fft_rfftn : t -> s:int list -> dim:int list -> norm:string -> t
  val fft_rfftn_out : out:t -> t -> s:int list -> dim:int list -> norm:string -> t
  val fill_ : t -> value:'a scalar -> t
  val fill_1 : t -> value:t -> t
  val fill_diagonal_ : t -> fill_value:'a scalar -> wrap:bool -> t
  val fix : t -> t
  val fix_ : t -> t
  val fix_out : out:t -> t -> t
  val flatten : t -> start_dim:int -> end_dim:int -> t
  val flip : t -> dims:int list -> t
  val fliplr : t -> t
  val flipud : t -> t
  val float_power : t -> exponent:t -> t
  val float_power1 : 'a scalar -> exponent:t -> t
  val float_power2 : t -> exponent:'a scalar -> t
  val float_power_ : t -> exponent:'a scalar -> t
  val float_power_1 : t -> exponent:t -> t
  val float_power_out : out:t -> t -> exponent:t -> t
  val float_power_out1 : out:t -> 'a scalar -> exponent:t -> t
  val float_power_out2 : out:t -> t -> exponent:'a scalar -> t
  val floor : t -> t
  val floor_ : t -> t
  val floor_divide : t -> t -> t
  val floor_divide1 : t -> 'a scalar -> t
  val floor_divide_ : t -> t -> t
  val floor_divide_1 : t -> 'a scalar -> t
  val floor_divide_out : out:t -> t -> t -> t
  val floor_out : out:t -> t -> t
  val fmax : t -> t -> t
  val fmax_out : out:t -> t -> t -> t
  val fmin : t -> t -> t
  val fmin_out : out:t -> t -> t -> t
  val fmod : t -> 'a scalar -> t
  val fmod1 : t -> t -> t
  val fmod_ : t -> 'a scalar -> t
  val fmod_1 : t -> t -> t
  val fmod_out : out:t -> t -> 'a scalar -> t
  val fmod_out1 : out:t -> t -> t -> t
  val frac : t -> t
  val frac_ : t -> t
  val frac_out : out:t -> t -> t

  val fractional_max_pool2d
    :  t
    -> kernel_size:int list
    -> output_size:int list
    -> random_samples:t
    -> t * t

  val fractional_max_pool2d_backward
    :  grad_output:t
    -> t
    -> kernel_size:int list
    -> output_size:int list
    -> indices:t
    -> t

  val fractional_max_pool2d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> kernel_size:int list
    -> output_size:int list
    -> indices:t
    -> t

  val fractional_max_pool2d_out
    :  output:t
    -> indices:t
    -> t
    -> kernel_size:int list
    -> output_size:int list
    -> random_samples:t
    -> t * t

  val fractional_max_pool3d
    :  t
    -> kernel_size:int list
    -> output_size:int list
    -> random_samples:t
    -> t * t

  val fractional_max_pool3d_backward
    :  grad_output:t
    -> t
    -> kernel_size:int list
    -> output_size:int list
    -> indices:t
    -> t

  val fractional_max_pool3d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> kernel_size:int list
    -> output_size:int list
    -> indices:t
    -> t

  val fractional_max_pool3d_out
    :  output:t
    -> indices:t
    -> t
    -> kernel_size:int list
    -> output_size:int list
    -> random_samples:t
    -> t * t

  val frobenius_norm : t -> t
  val frobenius_norm1 : t -> dim:int list -> keepdim:bool -> t
  val frobenius_norm_out : out:t -> t -> dim:int list -> keepdim:bool -> t

  val from_file
    :  filename:string
    -> shared:bool
    -> size:int
    -> options:Kind.packed * Device.t
    -> t

  val full : size:int list -> fill_value:'a scalar -> options:Kind.packed * Device.t -> t
  val full_like : t -> fill_value:'a scalar -> t
  val full_out : out:t -> size:int list -> fill_value:'a scalar -> t
  val gather : t -> dim:int -> index:t -> sparse_grad:bool -> t
  val gather_backward : grad:t -> t -> dim:int -> index:t -> sparse_grad:bool -> t
  val gather_out : out:t -> t -> dim:int -> index:t -> sparse_grad:bool -> t
  val gcd : t -> t -> t
  val gcd_ : t -> t -> t
  val gcd_out : out:t -> t -> t -> t
  val ge : t -> 'a scalar -> t
  val ge1 : t -> t -> t
  val ge_ : t -> 'a scalar -> t
  val ge_1 : t -> t -> t
  val ge_out : out:t -> t -> 'a scalar -> t
  val ge_out1 : out:t -> t -> t -> t
  val gelu : t -> t
  val gelu_backward : grad:t -> t -> t
  val geometric_ : t -> p:float -> t
  val geqrf : t -> t * t
  val geqrf_out : a:t -> tau:t -> t -> t * t
  val ger : t -> vec2:t -> t
  val ger_out : out:t -> t -> vec2:t -> t
  val glu : t -> dim:int -> t
  val glu_backward : grad_output:t -> t -> dim:int -> t
  val glu_backward_out : grad_input:t -> grad_output:t -> t -> dim:int -> t
  val glu_out : out:t -> t -> dim:int -> t
  val grad : t -> t
  val greater : t -> 'a scalar -> t
  val greater1 : t -> t -> t
  val greater_ : t -> 'a scalar -> t
  val greater_1 : t -> t -> t
  val greater_equal : t -> 'a scalar -> t
  val greater_equal1 : t -> t -> t
  val greater_equal_ : t -> 'a scalar -> t
  val greater_equal_1 : t -> t -> t
  val greater_equal_out : out:t -> t -> 'a scalar -> t
  val greater_equal_out1 : out:t -> t -> t -> t
  val greater_out : out:t -> t -> 'a scalar -> t
  val greater_out1 : out:t -> t -> t -> t

  val grid_sampler
    :  t
    -> grid:t
    -> interpolation_mode:int
    -> padding_mode:int
    -> align_corners:bool
    -> t

  val grid_sampler_2d
    :  t
    -> grid:t
    -> interpolation_mode:int
    -> padding_mode:int
    -> align_corners:bool
    -> t

  val grid_sampler_2d_backward
    :  grad_output:t
    -> t
    -> grid:t
    -> interpolation_mode:int
    -> padding_mode:int
    -> align_corners:bool
    -> t * t

  val grid_sampler_3d
    :  t
    -> grid:t
    -> interpolation_mode:int
    -> padding_mode:int
    -> align_corners:bool
    -> t

  val grid_sampler_3d_backward
    :  grad_output:t
    -> t
    -> grid:t
    -> interpolation_mode:int
    -> padding_mode:int
    -> align_corners:bool
    -> t * t

  val group_norm
    :  t
    -> num_groups:int
    -> weight:t option
    -> bias:t option
    -> eps:float
    -> cudnn_enabled:bool
    -> t

  val gru
    :  t
    -> hx:t
    -> params:t list
    -> has_biases:bool
    -> num_layers:int
    -> dropout:float
    -> train:bool
    -> bidirectional:bool
    -> batch_first:bool
    -> t * t

  val gru1
    :  data:t
    -> batch_sizes:t
    -> hx:t
    -> params:t list
    -> has_biases:bool
    -> num_layers:int
    -> dropout:float
    -> train:bool
    -> bidirectional:bool
    -> t * t

  val gru_cell : t -> hx:t -> w_ih:t -> w_hh:t -> b_ih:t option -> b_hh:t option -> t
  val gt : t -> 'a scalar -> t
  val gt1 : t -> t -> t
  val gt_ : t -> 'a scalar -> t
  val gt_1 : t -> t -> t
  val gt_out : out:t -> t -> 'a scalar -> t
  val gt_out1 : out:t -> t -> t -> t
  val hamming_window : window_length:int -> options:Kind.packed * Device.t -> t

  val hamming_window1
    :  window_length:int
    -> periodic:bool
    -> options:Kind.packed * Device.t
    -> t

  val hamming_window2
    :  window_length:int
    -> periodic:bool
    -> alpha:float
    -> options:Kind.packed * Device.t
    -> t

  val hamming_window3
    :  window_length:int
    -> periodic:bool
    -> alpha:float
    -> beta:float
    -> options:Kind.packed * Device.t
    -> t

  val hann_window : window_length:int -> options:Kind.packed * Device.t -> t

  val hann_window1
    :  window_length:int
    -> periodic:bool
    -> options:Kind.packed * Device.t
    -> t

  val hardshrink : t -> t
  val hardshrink_backward : grad_out:t -> t -> lambd:'a scalar -> t
  val hardsigmoid : t -> t
  val hardsigmoid_ : t -> t
  val hardsigmoid_backward : grad_output:t -> t -> t
  val hardsigmoid_out : out:t -> t -> t
  val hardswish : t -> t
  val hardswish_ : t -> t
  val hardswish_backward : grad_output:t -> t -> t
  val hardswish_out : out:t -> t -> t
  val hardtanh : t -> t
  val hardtanh_ : t -> t

  val hardtanh_backward
    :  grad_output:t
    -> t
    -> min_val:'a scalar
    -> max_val:'a scalar
    -> t

  val hardtanh_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> min_val:'a scalar
    -> max_val:'a scalar
    -> t

  val hardtanh_out : out:t -> t -> t
  val heaviside : t -> values:t -> t
  val heaviside_ : t -> values:t -> t
  val heaviside_out : out:t -> t -> values:t -> t
  val hinge_embedding_loss : t -> target:t -> margin:float -> reduction:Reduction.t -> t
  val histc : t -> bins:int -> t
  val histc_out : out:t -> t -> bins:int -> t
  val hspmm : mat1:t -> mat2:t -> t
  val hspmm_out : out:t -> mat1:t -> mat2:t -> t
  val hstack : t list -> t
  val hstack_out : out:t -> t list -> t
  val hypot : t -> t -> t
  val hypot_ : t -> t -> t
  val hypot_out : out:t -> t -> t -> t
  val i0 : t -> t
  val i0_ : t -> t
  val i0_out : out:t -> t -> t
  val igamma : t -> t -> t
  val igamma_ : t -> t -> t
  val igamma_out : out:t -> t -> t -> t
  val igammac : t -> t -> t
  val igammac_ : t -> t -> t
  val igammac_out : out:t -> t -> t -> t

  val im2col
    :  t
    -> kernel_size:int list
    -> dilation:int list
    -> padding:int list
    -> stride:int list
    -> t

  val im2col_backward
    :  grad_output:t
    -> input_size:int list
    -> kernel_size:int list
    -> dilation:int list
    -> padding:int list
    -> stride:int list
    -> t

  val im2col_backward_out
    :  grad_input:t
    -> grad_output:t
    -> input_size:int list
    -> kernel_size:int list
    -> dilation:int list
    -> padding:int list
    -> stride:int list
    -> t

  val im2col_out
    :  out:t
    -> t
    -> kernel_size:int list
    -> dilation:int list
    -> padding:int list
    -> stride:int list
    -> t

  val imag : t -> t
  val index : t -> indices:t option list -> t
  val index_add : t -> dim:int -> index:t -> source:t -> t
  val index_add_ : t -> dim:int -> index:t -> source:t -> t
  val index_copy : t -> dim:int -> index:t -> source:t -> t
  val index_copy_ : t -> dim:int -> index:t -> source:t -> t
  val index_fill : t -> dim:int -> index:t -> value:'a scalar -> t
  val index_fill1 : t -> dim:int -> index:t -> value:t -> t
  val index_fill_ : t -> dim:int -> index:t -> value:'a scalar -> t
  val index_fill_1 : t -> dim:int -> index:t -> value:t -> t
  val index_put : t -> indices:t option list -> values:t -> accumulate:bool -> t
  val index_put_ : t -> indices:t option list -> values:t -> accumulate:bool -> t
  val index_select : t -> dim:int -> index:t -> t
  val index_select_backward : grad:t -> self_sizes:int list -> dim:int -> index:t -> t
  val index_select_out : out:t -> t -> dim:int -> index:t -> t
  val indices : t -> t
  val infinitely_differentiable_gelu_backward : grad:t -> t -> t
  val inner : t -> t -> t
  val inner_out : out:t -> t -> t -> t

  val instance_norm
    :  t
    -> weight:t option
    -> bias:t option
    -> running_mean:t option
    -> running_var:t option
    -> use_input_stats:bool
    -> momentum:float
    -> eps:float
    -> cudnn_enabled:bool
    -> t

  val int_repr : t -> t
  val inverse : t -> t
  val inverse_out : out:t -> t -> t
  val isclose : t -> t -> rtol:float -> atol:float -> equal_nan:bool -> t
  val isfinite : t -> t
  val isinf : t -> t
  val isnan : t -> t
  val isneginf : t -> t
  val isneginf_out : out:t -> t -> t
  val isposinf : t -> t
  val isposinf_out : out:t -> t -> t
  val isreal : t -> t

  val istft
    :  t
    -> n_fft:int
    -> hop_length:int
    -> win_length:int
    -> window:t option
    -> center:bool
    -> normalized:bool
    -> onesided:bool
    -> length:int
    -> return_complex:bool
    -> t

  val kaiser_window : window_length:int -> options:Kind.packed * Device.t -> t

  val kaiser_window1
    :  window_length:int
    -> periodic:bool
    -> options:Kind.packed * Device.t
    -> t

  val kaiser_window2
    :  window_length:int
    -> periodic:bool
    -> beta:float
    -> options:Kind.packed * Device.t
    -> t

  val kl_div : t -> target:t -> reduction:Reduction.t -> log_target:bool -> t

  val kl_div_backward
    :  grad_output:t
    -> t
    -> target:t
    -> reduction:Reduction.t
    -> log_target:bool
    -> t

  val kron : t -> t -> t
  val kron_out : out:t -> t -> t -> t
  val kthvalue : t -> k:int -> dim:int -> keepdim:bool -> t * t

  val kthvalue_out
    :  values:t
    -> indices:t
    -> t
    -> k:int
    -> dim:int
    -> keepdim:bool
    -> t * t

  val l1_loss : t -> target:t -> reduction:Reduction.t -> t
  val l1_loss_backward : grad_output:t -> t -> target:t -> reduction:Reduction.t -> t

  val l1_loss_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> target:t
    -> reduction:Reduction.t
    -> t

  val l1_loss_out : out:t -> t -> target:t -> reduction:Reduction.t -> t

  val layer_norm
    :  t
    -> normalized_shape:int list
    -> weight:t option
    -> bias:t option
    -> eps:float
    -> cudnn_enable:bool
    -> t

  val lcm : t -> t -> t
  val lcm_ : t -> t -> t
  val lcm_out : out:t -> t -> t -> t
  val ldexp : t -> t -> t
  val ldexp_ : t -> t -> t
  val ldexp_out : out:t -> t -> t -> t
  val le : t -> 'a scalar -> t
  val le1 : t -> t -> t
  val le_ : t -> 'a scalar -> t
  val le_1 : t -> t -> t
  val le_out : out:t -> t -> 'a scalar -> t
  val le_out1 : out:t -> t -> t -> t
  val leaky_relu : t -> t
  val leaky_relu_ : t -> t

  val leaky_relu_backward
    :  grad_output:t
    -> t
    -> negative_slope:'a scalar
    -> self_is_result:bool
    -> t

  val leaky_relu_out : out:t -> t -> t
  val lerp : t -> end_:t -> weight:'a scalar -> t
  val lerp1 : t -> end_:t -> weight:t -> t
  val lerp_ : t -> end_:t -> weight:'a scalar -> t
  val lerp_1 : t -> end_:t -> weight:t -> t
  val lerp_out : out:t -> t -> end_:t -> weight:'a scalar -> t
  val lerp_out1 : out:t -> t -> end_:t -> weight:t -> t
  val less : t -> 'a scalar -> t
  val less1 : t -> t -> t
  val less_ : t -> 'a scalar -> t
  val less_1 : t -> t -> t
  val less_equal : t -> 'a scalar -> t
  val less_equal1 : t -> t -> t
  val less_equal_ : t -> 'a scalar -> t
  val less_equal_1 : t -> t -> t
  val less_equal_out : out:t -> t -> 'a scalar -> t
  val less_equal_out1 : out:t -> t -> t -> t
  val less_out : out:t -> t -> 'a scalar -> t
  val less_out1 : out:t -> t -> t -> t
  val lgamma : t -> t
  val lgamma_ : t -> t
  val lgamma_out : out:t -> t -> t
  val linalg_cholesky : t -> t
  val linalg_cholesky_out : out:t -> t -> t
  val linalg_cond : t -> p:'a scalar -> t
  val linalg_cond1 : t -> p:string -> t
  val linalg_cond_out : out:t -> t -> p:'a scalar -> t
  val linalg_cond_out1 : out:t -> t -> p:string -> t
  val linalg_det : t -> t
  val linalg_eigh : t -> uplo:string -> t * t
  val linalg_eigh_out : eigvals:t -> eigvecs:t -> t -> uplo:string -> t * t
  val linalg_eigvalsh : t -> uplo:string -> t
  val linalg_eigvalsh_out : out:t -> t -> uplo:string -> t
  val linalg_inv : t -> t
  val linalg_inv_out : out:t -> t -> t
  val linalg_matrix_rank : t -> tol:float -> hermitian:bool -> t
  val linalg_matrix_rank_out : out:t -> t -> tol:float -> hermitian:bool -> t

  val linalg_norm
    :  t
    -> ord:'a scalar
    -> dim:int list
    -> keepdim:bool
    -> dtype:Kind.packed
    -> t

  val linalg_norm1
    :  t
    -> ord:string
    -> dim:int list
    -> keepdim:bool
    -> dtype:Kind.packed
    -> t

  val linalg_norm_out
    :  out:t
    -> t
    -> ord:'a scalar
    -> dim:int list
    -> keepdim:bool
    -> dtype:Kind.packed
    -> t

  val linalg_norm_out1
    :  out:t
    -> t
    -> ord:string
    -> dim:int list
    -> keepdim:bool
    -> dtype:Kind.packed
    -> t

  val linalg_pinv : t -> rcond:float -> hermitian:bool -> t
  val linalg_pinv1 : t -> rcond:t -> hermitian:bool -> t
  val linalg_pinv_out : out:t -> t -> rcond:float -> hermitian:bool -> t
  val linalg_pinv_out1 : out:t -> t -> rcond:t -> hermitian:bool -> t
  val linalg_qr : t -> mode:string -> t * t
  val linalg_qr_out : q:t -> r:t -> t -> mode:string -> t * t
  val linalg_slogdet : t -> t * t
  val linalg_slogdet_out : sign:t -> logabsdet:t -> t -> t * t
  val linalg_solve : t -> t -> t
  val linalg_solve_out : out:t -> t -> t -> t
  val linalg_svd : t -> full_matrices:bool -> compute_uv:bool -> t * t * t

  val linalg_svd_out
    :  u:t
    -> s:t
    -> v:t
    -> t
    -> full_matrices:bool
    -> compute_uv:bool
    -> t * t * t

  val linalg_tensorinv : t -> ind:int -> t
  val linalg_tensorinv_out : out:t -> t -> ind:int -> t
  val linalg_tensorsolve : t -> t -> dims:int list -> t
  val linalg_tensorsolve_out : out:t -> t -> t -> dims:int list -> t
  val linear : t -> weight:t -> bias:t option -> t

  val linspace
    :  start:'a scalar
    -> end_:'a scalar
    -> steps:int
    -> options:Kind.packed * Device.t
    -> t

  val linspace_out : out:t -> start:'a scalar -> end_:'a scalar -> steps:int -> t
  val log : t -> t
  val log10 : t -> t
  val log10_ : t -> t
  val log10_out : out:t -> t -> t
  val log1p : t -> t
  val log1p_ : t -> t
  val log1p_out : out:t -> t -> t
  val log2 : t -> t
  val log2_ : t -> t
  val log2_out : out:t -> t -> t
  val log_ : t -> t
  val log_normal_ : t -> mean:float -> std:float -> t
  val log_out : out:t -> t -> t
  val log_sigmoid : t -> t
  val log_sigmoid_backward : grad_output:t -> t -> buffer:t -> t
  val log_sigmoid_backward_out : grad_input:t -> grad_output:t -> t -> buffer:t -> t
  val log_sigmoid_out : out:t -> t -> t
  val log_softmax : t -> dim:int -> dtype:Kind.packed -> t
  val logaddexp : t -> t -> t
  val logaddexp2 : t -> t -> t
  val logaddexp2_out : out:t -> t -> t -> t
  val logaddexp_out : out:t -> t -> t -> t
  val logcumsumexp : t -> dim:int -> t
  val logcumsumexp_out : out:t -> t -> dim:int -> t
  val logdet : t -> t
  val logical_and : t -> t -> t
  val logical_and_ : t -> t -> t
  val logical_and_out : out:t -> t -> t -> t
  val logical_not : t -> t
  val logical_not_ : t -> t
  val logical_not_out : out:t -> t -> t
  val logical_or : t -> t -> t
  val logical_or_ : t -> t -> t
  val logical_or_out : out:t -> t -> t -> t
  val logical_xor : t -> t -> t
  val logical_xor_ : t -> t -> t
  val logical_xor_out : out:t -> t -> t -> t
  val logit : t -> eps:float -> t
  val logit_ : t -> eps:float -> t
  val logit_backward : grad_output:t -> t -> eps:float -> t
  val logit_backward_out : grad_input:t -> grad_output:t -> t -> eps:float -> t
  val logit_out : out:t -> t -> eps:float -> t

  val logspace
    :  start:'a scalar
    -> end_:'a scalar
    -> steps:int
    -> base:float
    -> options:Kind.packed * Device.t
    -> t

  val logspace_out
    :  out:t
    -> start:'a scalar
    -> end_:'a scalar
    -> steps:int
    -> base:float
    -> t

  val logsumexp : t -> dim:int list -> keepdim:bool -> t
  val logsumexp_out : out:t -> t -> dim:int list -> keepdim:bool -> t

  val lstm
    :  t
    -> hx:t list
    -> params:t list
    -> has_biases:bool
    -> num_layers:int
    -> dropout:float
    -> train:bool
    -> bidirectional:bool
    -> batch_first:bool
    -> t * t * t

  val lstm1
    :  data:t
    -> batch_sizes:t
    -> hx:t list
    -> params:t list
    -> has_biases:bool
    -> num_layers:int
    -> dropout:float
    -> train:bool
    -> bidirectional:bool
    -> t * t * t

  val lstm_cell
    :  t
    -> hx:t list
    -> w_ih:t
    -> w_hh:t
    -> b_ih:t option
    -> b_hh:t option
    -> t * t

  val lstsq : t -> a:t -> t * t
  val lstsq_out : x:t -> qr:t -> t -> a:t -> t * t
  val lt : t -> 'a scalar -> t
  val lt1 : t -> t -> t
  val lt_ : t -> 'a scalar -> t
  val lt_1 : t -> t -> t
  val lt_out : out:t -> t -> 'a scalar -> t
  val lt_out1 : out:t -> t -> t -> t
  val lu_solve : t -> lu_data:t -> lu_pivots:t -> t
  val lu_solve_out : out:t -> t -> lu_data:t -> lu_pivots:t -> t

  val margin_ranking_loss
    :  input1:t
    -> input2:t
    -> target:t
    -> margin:float
    -> reduction:Reduction.t
    -> t

  val masked_fill : t -> mask:t -> value:'a scalar -> t
  val masked_fill1 : t -> mask:t -> value:t -> t
  val masked_fill_ : t -> mask:t -> value:'a scalar -> t
  val masked_fill_1 : t -> mask:t -> value:t -> t
  val masked_scatter : t -> mask:t -> source:t -> t
  val masked_scatter_ : t -> mask:t -> source:t -> t
  val masked_select : t -> mask:t -> t
  val masked_select_backward : grad:t -> t -> mask:t -> t
  val masked_select_out : out:t -> t -> mask:t -> t
  val matmul : t -> t -> t
  val matmul_out : out:t -> t -> t -> t
  val matrix_exp : t -> t
  val matrix_exp_backward : t -> grad:t -> t
  val matrix_power : t -> n:int -> t
  val matrix_rank : t -> symmetric:bool -> t
  val matrix_rank1 : t -> tol:float -> symmetric:bool -> t
  val max : t -> t
  val max1 : t -> t -> t
  val max2 : t -> dim:int -> keepdim:bool -> t * t
  val max_out : out:t -> t -> t -> t
  val max_out1 : max:t -> max_values:t -> t -> dim:int -> keepdim:bool -> t * t

  val max_pool1d
    :  t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> ceil_mode:bool
    -> t

  val max_pool1d_with_indices
    :  t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> ceil_mode:bool
    -> t * t

  val max_pool2d
    :  t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> ceil_mode:bool
    -> t

  val max_pool2d_with_indices
    :  t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> ceil_mode:bool
    -> t * t

  val max_pool2d_with_indices_backward
    :  grad_output:t
    -> t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> ceil_mode:bool
    -> indices:t
    -> t

  val max_pool2d_with_indices_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> ceil_mode:bool
    -> indices:t
    -> t

  val max_pool2d_with_indices_out
    :  out:t
    -> indices:t
    -> t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> ceil_mode:bool
    -> t * t

  val max_pool3d
    :  t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> ceil_mode:bool
    -> t

  val max_pool3d_with_indices
    :  t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> ceil_mode:bool
    -> t * t

  val max_pool3d_with_indices_backward
    :  grad_output:t
    -> t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> ceil_mode:bool
    -> indices:t
    -> t

  val max_pool3d_with_indices_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> ceil_mode:bool
    -> indices:t
    -> t

  val max_pool3d_with_indices_out
    :  out:t
    -> indices:t
    -> t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> ceil_mode:bool
    -> t * t

  val max_unpool2d : t -> indices:t -> output_size:int list -> t
  val max_unpool2d_backward : grad_output:t -> t -> indices:t -> output_size:int list -> t

  val max_unpool2d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> indices:t
    -> output_size:int list
    -> t

  val max_unpool2d_out : out:t -> t -> indices:t -> output_size:int list -> t

  val max_unpool3d
    :  t
    -> indices:t
    -> output_size:int list
    -> stride:int list
    -> padding:int list
    -> t

  val max_unpool3d_backward
    :  grad_output:t
    -> t
    -> indices:t
    -> output_size:int list
    -> stride:int list
    -> padding:int list
    -> t

  val max_unpool3d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> indices:t
    -> output_size:int list
    -> stride:int list
    -> padding:int list
    -> t

  val max_unpool3d_out
    :  out:t
    -> t
    -> indices:t
    -> output_size:int list
    -> stride:int list
    -> padding:int list
    -> t

  val maximum : t -> t -> t
  val maximum_out : out:t -> t -> t -> t
  val mean : t -> dtype:Kind.packed -> t
  val mean1 : t -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> t
  val mean_out : out:t -> t -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> t
  val median : t -> t
  val median1 : t -> dim:int -> keepdim:bool -> t * t
  val median_out : values:t -> indices:t -> t -> dim:int -> keepdim:bool -> t * t
  val meshgrid : t list -> t list
  val min : t -> t
  val min1 : t -> t -> t
  val min2 : t -> dim:int -> keepdim:bool -> t * t
  val min_out : out:t -> t -> t -> t
  val min_out1 : min:t -> min_indices:t -> t -> dim:int -> keepdim:bool -> t * t
  val minimum : t -> t -> t
  val minimum_out : out:t -> t -> t -> t

  val miopen_batch_norm
    :  t
    -> weight:t
    -> bias:t option
    -> running_mean:t option
    -> running_var:t option
    -> training:bool
    -> exponential_average_factor:float
    -> epsilon:float
    -> t * t * t

  val miopen_batch_norm_backward
    :  t
    -> grad_output:t
    -> weight:t
    -> running_mean:t option
    -> running_var:t option
    -> save_mean:t option
    -> save_var:t option
    -> epsilon:float
    -> t * t * t

  val miopen_convolution
    :  t
    -> weight:t
    -> bias:t option
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> t

  val miopen_convolution_backward_bias : grad_output:t -> t

  val miopen_convolution_backward_input
    :  self_size:int list
    -> grad_output:t
    -> weight:t
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> t

  val miopen_convolution_backward_weight
    :  weight_size:int list
    -> grad_output:t
    -> t
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> t

  val miopen_convolution_transpose
    :  t
    -> weight:t
    -> bias:t option
    -> padding:int list
    -> output_padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> t

  val miopen_convolution_transpose_backward_input
    :  grad_output:t
    -> weight:t
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> t

  val miopen_convolution_transpose_backward_weight
    :  weight_size:int list
    -> grad_output:t
    -> t
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> t

  val miopen_depthwise_convolution
    :  t
    -> weight:t
    -> bias:t option
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> t

  val miopen_depthwise_convolution_backward_input
    :  self_size:int list
    -> grad_output:t
    -> weight:t
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> t

  val miopen_depthwise_convolution_backward_weight
    :  weight_size:int list
    -> grad_output:t
    -> t
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> benchmark:bool
    -> deterministic:bool
    -> t

  val miopen_rnn
    :  t
    -> weight:t list
    -> weight_stride0:int
    -> hx:t
    -> cx:t option
    -> mode:int
    -> hidden_size:int
    -> num_layers:int
    -> batch_first:bool
    -> dropout:float
    -> train:bool
    -> bidirectional:bool
    -> batch_sizes:int list
    -> dropout_state:t option
    -> t * t * t * t * t

  val mkldnn_adaptive_avg_pool2d : t -> output_size:int list -> t

  val mkldnn_convolution
    :  t
    -> weight:t
    -> bias:t option
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> t

  val mkldnn_convolution_backward_input
    :  self_size:int list
    -> grad_output:t
    -> weight:t
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> bias_defined:bool
    -> t

  val mkldnn_convolution_backward_weights
    :  weight_size:int list
    -> grad_output:t
    -> t
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> bias_defined:bool
    -> t * t

  val mkldnn_linear : t -> weight:t -> bias:t option -> t
  val mkldnn_linear_backward_input : input_size:int list -> grad_output:t -> weight:t -> t

  val mkldnn_linear_backward_weights
    :  grad_output:t
    -> t
    -> weight:t
    -> bias_defined:bool
    -> t * t

  val mkldnn_max_pool2d
    :  t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> ceil_mode:bool
    -> t

  val mkldnn_max_pool3d
    :  t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> ceil_mode:bool
    -> t

  val mkldnn_reorder_conv2d_weight
    :  t
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> t

  val mkldnn_reorder_conv3d_weight
    :  t
    -> padding:int list
    -> stride:int list
    -> dilation:int list
    -> groups:int
    -> t

  val mm : t -> mat2:t -> t
  val mm_out : out:t -> t -> mat2:t -> t
  val mode : t -> dim:int -> keepdim:bool -> t * t
  val mode_out : values:t -> indices:t -> t -> dim:int -> keepdim:bool -> t * t
  val moveaxis : t -> source:int list -> destination:int list -> t
  val moveaxis1 : t -> source:int -> destination:int -> t
  val movedim : t -> source:int list -> destination:int list -> t
  val movedim1 : t -> source:int -> destination:int -> t
  val mse_loss : t -> target:t -> reduction:Reduction.t -> t
  val mse_loss_backward : grad_output:t -> t -> target:t -> reduction:Reduction.t -> t

  val mse_loss_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> target:t
    -> reduction:Reduction.t
    -> t

  val mse_loss_out : out:t -> t -> target:t -> reduction:Reduction.t -> t
  val msort : t -> t
  val msort_out : out:t -> t -> t
  val mul : t -> t -> t
  val mul1 : t -> 'a scalar -> t
  val mul_ : t -> t -> t
  val mul_1 : t -> 'a scalar -> t
  val mul_out : out:t -> t -> t -> t

  val multi_margin_loss_backward
    :  grad_output:t
    -> t
    -> target:t
    -> p:'a scalar
    -> margin:'a scalar
    -> weight:t option
    -> reduction:Reduction.t
    -> t

  val multi_margin_loss_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> target:t
    -> p:'a scalar
    -> margin:'a scalar
    -> weight:t option
    -> reduction:Reduction.t
    -> t

  val multilabel_margin_loss : t -> target:t -> reduction:Reduction.t -> t

  val multilabel_margin_loss_backward
    :  grad_output:t
    -> t
    -> target:t
    -> reduction:Reduction.t
    -> is_target:t
    -> t

  val multilabel_margin_loss_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> target:t
    -> reduction:Reduction.t
    -> is_target:t
    -> t

  val multilabel_margin_loss_out : out:t -> t -> target:t -> reduction:Reduction.t -> t
  val multinomial : t -> num_samples:int -> replacement:bool -> t
  val multinomial_out : out:t -> t -> num_samples:int -> replacement:bool -> t
  val multiply : t -> t -> t
  val multiply1 : t -> 'a scalar -> t
  val multiply_ : t -> t -> t
  val multiply_1 : t -> 'a scalar -> t
  val multiply_out : out:t -> t -> t -> t
  val mv : t -> vec:t -> t
  val mv_out : out:t -> t -> vec:t -> t
  val mvlgamma : t -> p:int -> t
  val mvlgamma_ : t -> p:int -> t
  val nan_to_num : t -> nan:float -> posinf:float -> neginf:float -> t
  val nan_to_num_ : t -> nan:float -> posinf:float -> neginf:float -> t
  val nan_to_num_out : out:t -> t -> nan:float -> posinf:float -> neginf:float -> t
  val nanmedian : t -> t
  val nanmedian1 : t -> dim:int -> keepdim:bool -> t * t
  val nanmedian_out : values:t -> indices:t -> t -> dim:int -> keepdim:bool -> t * t
  val nanquantile : t -> q:float -> dim:int -> keepdim:bool -> t
  val nanquantile1 : t -> q:t -> dim:int -> keepdim:bool -> t
  val nanquantile_out : out:t -> t -> q:float -> dim:int -> keepdim:bool -> t
  val nanquantile_out1 : out:t -> t -> q:t -> dim:int -> keepdim:bool -> t
  val nansum : t -> dtype:Kind.packed -> t
  val nansum1 : t -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> t
  val nansum_out : out:t -> t -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> t
  val narrow : t -> dim:int -> start:int -> length:int -> t
  val narrow1 : t -> dim:int -> start:t -> length:int -> t
  val narrow_copy : t -> dim:int -> start:int -> length:int -> t
  val narrow_copy_out : out:t -> t -> dim:int -> start:int -> length:int -> t

  val native_batch_norm
    :  t
    -> weight:t option
    -> bias:t option
    -> running_mean:t option
    -> running_var:t option
    -> training:bool
    -> momentum:float
    -> eps:float
    -> t * t * t

  val native_batch_norm_out
    :  out:t
    -> save_mean:t
    -> save_invstd:t
    -> t
    -> weight:t option
    -> bias:t option
    -> running_mean:t option
    -> running_var:t option
    -> training:bool
    -> momentum:float
    -> eps:float
    -> t * t * t

  val native_group_norm
    :  t
    -> weight:t option
    -> bias:t option
    -> n:int
    -> c:int
    -> hxw:int
    -> group:int
    -> eps:float
    -> t * t * t

  val native_layer_norm
    :  t
    -> normalized_shape:int list
    -> weight:t option
    -> bias:t option
    -> eps:float
    -> t * t * t

  val native_norm : t -> t

  val native_norm1
    :  t
    -> p:'a scalar
    -> dim:int list
    -> keepdim:bool
    -> dtype:Kind.packed
    -> t

  val ne : t -> 'a scalar -> t
  val ne1 : t -> t -> t
  val ne_ : t -> 'a scalar -> t
  val ne_1 : t -> t -> t
  val ne_out : out:t -> t -> 'a scalar -> t
  val ne_out1 : out:t -> t -> t -> t
  val neg : t -> t
  val neg_ : t -> t
  val neg_out : out:t -> t -> t
  val negative : t -> t
  val negative_ : t -> t
  val negative_out : out:t -> t -> t
  val new_empty : t -> size:int list -> options:Kind.packed * Device.t -> t

  val new_empty_strided
    :  t
    -> size:int list
    -> stride:int list
    -> options:Kind.packed * Device.t
    -> t

  val new_full
    :  t
    -> size:int list
    -> fill_value:'a scalar
    -> options:Kind.packed * Device.t
    -> t

  val new_zeros : t -> size:int list -> options:Kind.packed * Device.t -> t
  val nextafter : t -> t -> t
  val nextafter_ : t -> t -> t
  val nextafter_out : out:t -> t -> t -> t

  val nll_loss
    :  t
    -> target:t
    -> weight:t option
    -> reduction:Reduction.t
    -> ignore_index:int
    -> t

  val nll_loss2d
    :  t
    -> target:t
    -> weight:t option
    -> reduction:Reduction.t
    -> ignore_index:int
    -> t

  val nll_loss2d_backward
    :  grad_output:t
    -> t
    -> target:t
    -> weight:t option
    -> reduction:Reduction.t
    -> ignore_index:int
    -> total_weight:t
    -> t

  val nll_loss2d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> target:t
    -> weight:t option
    -> reduction:Reduction.t
    -> ignore_index:int
    -> total_weight:t
    -> t

  val nll_loss2d_out
    :  out:t
    -> t
    -> target:t
    -> weight:t option
    -> reduction:Reduction.t
    -> ignore_index:int
    -> t

  val nll_loss_backward
    :  grad_output:t
    -> t
    -> target:t
    -> weight:t option
    -> reduction:Reduction.t
    -> ignore_index:int
    -> total_weight:t
    -> t

  val nll_loss_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> target:t
    -> weight:t option
    -> reduction:Reduction.t
    -> ignore_index:int
    -> total_weight:t
    -> t

  val nll_loss_out
    :  out:t
    -> t
    -> target:t
    -> weight:t option
    -> reduction:Reduction.t
    -> ignore_index:int
    -> t

  val nonzero : t -> t
  val nonzero_numpy : t -> t list
  val nonzero_out : out:t -> t -> t
  val norm : t -> t
  val norm1 : t -> p:'a scalar -> dtype:Kind.packed -> t
  val norm2 : t -> p:'a scalar -> dim:int list -> keepdim:bool -> t
  val norm3 : t -> p:'a scalar -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> t
  val norm_except_dim : v:t -> pow:int -> dim:int -> t
  val norm_out : out:t -> t -> p:'a scalar -> dim:int list -> keepdim:bool -> t

  val norm_out1
    :  out:t
    -> t
    -> p:'a scalar
    -> dim:int list
    -> keepdim:bool
    -> dtype:Kind.packed
    -> t

  val normal_ : t -> mean:float -> std:float -> t
  val normal_out : out:t -> mean:t -> std:float -> t
  val normal_out1 : out:t -> mean:float -> std:t -> t
  val normal_out2 : out:t -> mean:t -> std:t -> t
  val normal_out3 : out:t -> mean:float -> std:float -> size:int list -> t
  val not_equal : t -> 'a scalar -> t
  val not_equal1 : t -> t -> t
  val not_equal_ : t -> 'a scalar -> t
  val not_equal_1 : t -> t -> t
  val not_equal_out : out:t -> t -> 'a scalar -> t
  val not_equal_out1 : out:t -> t -> t -> t
  val nuclear_norm : t -> keepdim:bool -> t
  val nuclear_norm1 : t -> dim:int list -> keepdim:bool -> t
  val nuclear_norm_out : out:t -> t -> keepdim:bool -> t
  val nuclear_norm_out1 : out:t -> t -> dim:int list -> keepdim:bool -> t
  val numpy_t : t -> t
  val one_hot : t -> num_classes:int -> t
  val ones : size:int list -> options:Kind.packed * Device.t -> t
  val ones_like : t -> t
  val ones_out : out:t -> size:int list -> t
  val orgqr : t -> input2:t -> t
  val orgqr_out : out:t -> t -> input2:t -> t
  val ormqr : t -> input2:t -> input3:t -> left:bool -> transpose:bool -> t
  val ormqr_out : out:t -> t -> input2:t -> input3:t -> left:bool -> transpose:bool -> t
  val outer : t -> vec2:t -> t
  val outer_out : out:t -> t -> vec2:t -> t
  val pairwise_distance : x1:t -> x2:t -> p:float -> eps:float -> keepdim:bool -> t
  val pdist : t -> p:float -> t
  val permute : t -> dims:int list -> t
  val pin_memory : t -> t
  val pinverse : t -> rcond:float -> t
  val pixel_shuffle : t -> upscale_factor:int -> t
  val pixel_unshuffle : t -> downscale_factor:int -> t
  val poisson : t -> t

  val poisson_nll_loss
    :  t
    -> target:t
    -> log_input:bool
    -> full:bool
    -> eps:float
    -> reduction:Reduction.t
    -> t

  val polar : abs:t -> angle:t -> t
  val polar_out : out:t -> abs:t -> angle:t -> t
  val polygamma : n:int -> t -> t
  val polygamma_ : t -> n:int -> t
  val polygamma_out : out:t -> n:int -> t -> t
  val pow : t -> exponent:'a scalar -> t
  val pow1 : t -> exponent:t -> t
  val pow2 : 'a scalar -> exponent:t -> t
  val pow_ : t -> exponent:'a scalar -> t
  val pow_1 : t -> exponent:t -> t
  val pow_out : out:t -> t -> exponent:t -> t
  val pow_out1 : out:t -> 'a scalar -> exponent:t -> t
  val pow_out2 : out:t -> t -> exponent:'a scalar -> t
  val prelu : t -> weight:t -> t
  val prelu_backward : grad_output:t -> t -> weight:t -> t * t
  val prod : t -> dtype:Kind.packed -> t
  val prod1 : t -> dim:int -> keepdim:bool -> dtype:Kind.packed -> t
  val prod_out : out:t -> t -> dim:int -> keepdim:bool -> dtype:Kind.packed -> t
  val put_ : t -> index:t -> source:t -> accumulate:bool -> t
  val q_per_channel_scales : t -> t
  val q_per_channel_zero_points : t -> t
  val qr : t -> some:bool -> t * t
  val qr_out : q:t -> r:t -> t -> some:bool -> t * t
  val quantile : t -> q:float -> dim:int -> keepdim:bool -> t
  val quantile1 : t -> q:t -> dim:int -> keepdim:bool -> t
  val quantile_out : out:t -> t -> q:float -> dim:int -> keepdim:bool -> t
  val quantile_out1 : out:t -> t -> q:t -> dim:int -> keepdim:bool -> t

  val quantize_per_channel
    :  t
    -> scales:t
    -> zero_points:t
    -> axis:int
    -> dtype:Kind.packed
    -> t

  val quantize_per_tensor : t -> scale:float -> zero_point:int -> dtype:Kind.packed -> t

  val quantize_per_tensor1
    :  t list
    -> scales:t
    -> zero_points:t
    -> dtype:Kind.packed
    -> t list

  val quantized_batch_norm
    :  t
    -> weight:t option
    -> bias:t option
    -> mean:t
    -> var:t
    -> eps:float
    -> output_scale:float
    -> output_zero_point:int
    -> t

  val quantized_gru_cell
    :  t
    -> hx:t
    -> w_ih:t
    -> w_hh:t
    -> b_ih:t
    -> b_hh:t
    -> packed_ih:t
    -> packed_hh:t
    -> col_offsets_ih:t
    -> col_offsets_hh:t
    -> scale_ih:'a scalar
    -> scale_hh:'a scalar
    -> zero_point_ih:'a scalar
    -> zero_point_hh:'a scalar
    -> t

  val quantized_lstm_cell
    :  t
    -> hx:t list
    -> w_ih:t
    -> w_hh:t
    -> b_ih:t
    -> b_hh:t
    -> packed_ih:t
    -> packed_hh:t
    -> col_offsets_ih:t
    -> col_offsets_hh:t
    -> scale_ih:'a scalar
    -> scale_hh:'a scalar
    -> zero_point_ih:'a scalar
    -> zero_point_hh:'a scalar
    -> t * t

  val quantized_max_pool1d
    :  t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> ceil_mode:bool
    -> t

  val quantized_max_pool2d
    :  t
    -> kernel_size:int list
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> ceil_mode:bool
    -> t

  val quantized_rnn_relu_cell
    :  t
    -> hx:t
    -> w_ih:t
    -> w_hh:t
    -> b_ih:t
    -> b_hh:t
    -> packed_ih:t
    -> packed_hh:t
    -> col_offsets_ih:t
    -> col_offsets_hh:t
    -> scale_ih:'a scalar
    -> scale_hh:'a scalar
    -> zero_point_ih:'a scalar
    -> zero_point_hh:'a scalar
    -> t

  val quantized_rnn_tanh_cell
    :  t
    -> hx:t
    -> w_ih:t
    -> w_hh:t
    -> b_ih:t
    -> b_hh:t
    -> packed_ih:t
    -> packed_hh:t
    -> col_offsets_ih:t
    -> col_offsets_hh:t
    -> scale_ih:'a scalar
    -> scale_hh:'a scalar
    -> zero_point_ih:'a scalar
    -> zero_point_hh:'a scalar
    -> t

  val rad2deg : t -> t
  val rad2deg_ : t -> t
  val rad2deg_out : out:t -> t -> t
  val rand : size:int list -> options:Kind.packed * Device.t -> t
  val rand_like : t -> t
  val rand_out : out:t -> size:int list -> t
  val randint : high:int -> size:int list -> options:Kind.packed * Device.t -> t

  val randint1
    :  low:int
    -> high:int
    -> size:int list
    -> options:Kind.packed * Device.t
    -> t

  val randint_like : t -> high:int -> t
  val randint_like1 : t -> low:int -> high:int -> t
  val randint_out : out:t -> high:int -> size:int list -> t
  val randint_out1 : out:t -> low:int -> high:int -> size:int list -> t
  val randn : size:int list -> options:Kind.packed * Device.t -> t
  val randn_like : t -> t
  val randn_out : out:t -> size:int list -> t
  val random_ : t -> t
  val random_1 : t -> to_:int -> t
  val random_2 : t -> from:int -> to_:int -> t
  val randperm : n:int -> options:Kind.packed * Device.t -> t
  val randperm_out : out:t -> n:int -> t
  val range : start:'a scalar -> end_:'a scalar -> options:Kind.packed * Device.t -> t
  val range1 : start:'a scalar -> end_:'a scalar -> options:Kind.packed * Device.t -> t
  val range_out : out:t -> start:'a scalar -> end_:'a scalar -> t
  val ravel : t -> t
  val real : t -> t
  val reciprocal : t -> t
  val reciprocal_ : t -> t
  val reciprocal_out : out:t -> t -> t
  val reflection_pad1d : t -> padding:int list -> t
  val reflection_pad1d_backward : grad_output:t -> t -> padding:int list -> t

  val reflection_pad1d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> padding:int list
    -> t

  val reflection_pad1d_out : out:t -> t -> padding:int list -> t
  val reflection_pad2d : t -> padding:int list -> t
  val reflection_pad2d_backward : grad_output:t -> t -> padding:int list -> t

  val reflection_pad2d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> padding:int list
    -> t

  val reflection_pad2d_out : out:t -> t -> padding:int list -> t
  val relu : t -> t
  val relu_ : t -> t
  val remainder : t -> 'a scalar -> t
  val remainder1 : t -> t -> t
  val remainder_ : t -> 'a scalar -> t
  val remainder_1 : t -> t -> t
  val remainder_out : out:t -> t -> 'a scalar -> t
  val remainder_out1 : out:t -> t -> t -> t
  val renorm : t -> p:'a scalar -> dim:int -> maxnorm:'a scalar -> t
  val renorm_ : t -> p:'a scalar -> dim:int -> maxnorm:'a scalar -> t
  val renorm_out : out:t -> t -> p:'a scalar -> dim:int -> maxnorm:'a scalar -> t
  val repeat : t -> repeats:int list -> t
  val repeat_interleave : repeats:t -> t
  val repeat_interleave1 : t -> repeats:t -> dim:int -> t
  val repeat_interleave2 : t -> repeats:int -> dim:int -> t
  val replication_pad1d : t -> padding:int list -> t
  val replication_pad1d_backward : grad_output:t -> t -> padding:int list -> t

  val replication_pad1d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> padding:int list
    -> t

  val replication_pad1d_out : out:t -> t -> padding:int list -> t
  val replication_pad2d : t -> padding:int list -> t
  val replication_pad2d_backward : grad_output:t -> t -> padding:int list -> t

  val replication_pad2d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> padding:int list
    -> t

  val replication_pad2d_out : out:t -> t -> padding:int list -> t
  val replication_pad3d : t -> padding:int list -> t
  val replication_pad3d_backward : grad_output:t -> t -> padding:int list -> t

  val replication_pad3d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> padding:int list
    -> t

  val replication_pad3d_out : out:t -> t -> padding:int list -> t
  val requires_grad_ : t -> requires_grad:bool -> t
  val reshape : t -> shape:int list -> t
  val reshape_as : t -> t -> t
  val resize_ : t -> size:int list -> t
  val resize_as_ : t -> the_template:t -> t

  val rnn_relu
    :  t
    -> hx:t
    -> params:t list
    -> has_biases:bool
    -> num_layers:int
    -> dropout:float
    -> train:bool
    -> bidirectional:bool
    -> batch_first:bool
    -> t * t

  val rnn_relu1
    :  data:t
    -> batch_sizes:t
    -> hx:t
    -> params:t list
    -> has_biases:bool
    -> num_layers:int
    -> dropout:float
    -> train:bool
    -> bidirectional:bool
    -> t * t

  val rnn_relu_cell : t -> hx:t -> w_ih:t -> w_hh:t -> b_ih:t option -> b_hh:t option -> t

  val rnn_tanh
    :  t
    -> hx:t
    -> params:t list
    -> has_biases:bool
    -> num_layers:int
    -> dropout:float
    -> train:bool
    -> bidirectional:bool
    -> batch_first:bool
    -> t * t

  val rnn_tanh1
    :  data:t
    -> batch_sizes:t
    -> hx:t
    -> params:t list
    -> has_biases:bool
    -> num_layers:int
    -> dropout:float
    -> train:bool
    -> bidirectional:bool
    -> t * t

  val rnn_tanh_cell : t -> hx:t -> w_ih:t -> w_hh:t -> b_ih:t option -> b_hh:t option -> t
  val roll : t -> shifts:int list -> dims:int list -> t
  val rot90 : t -> k:int -> dims:int list -> t
  val round : t -> t
  val round_ : t -> t
  val round_out : out:t -> t -> t
  val row_stack : t list -> t
  val row_stack_out : out:t -> t list -> t
  val rrelu : t -> training:bool -> t
  val rrelu_ : t -> training:bool -> t
  val rrelu_with_noise : t -> noise:t -> training:bool -> t
  val rrelu_with_noise_ : t -> noise:t -> training:bool -> t

  val rrelu_with_noise_backward
    :  grad_output:t
    -> t
    -> noise:t
    -> lower:'a scalar
    -> upper:'a scalar
    -> training:bool
    -> self_is_result:bool
    -> t

  val rrelu_with_noise_out : out:t -> t -> noise:t -> training:bool -> t
  val rsqrt : t -> t
  val rsqrt_ : t -> t
  val rsqrt_out : out:t -> t -> t
  val rsub : t -> t -> t
  val rsub1 : t -> 'a scalar -> t
  val scalar_tensor : s:'a scalar -> options:Kind.packed * Device.t -> t
  val scatter : t -> dim:int -> index:t -> src:t -> t
  val scatter1 : t -> dim:int -> index:t -> value:'a scalar -> t
  val scatter_ : t -> dim:int -> index:t -> src:t -> t
  val scatter_1 : t -> dim:int -> index:t -> value:'a scalar -> t
  val scatter_2 : t -> dim:int -> index:t -> src:t -> reduce:string -> t
  val scatter_3 : t -> dim:int -> index:t -> value:'a scalar -> reduce:string -> t
  val scatter_add : t -> dim:int -> index:t -> src:t -> t
  val scatter_add_ : t -> dim:int -> index:t -> src:t -> t
  val searchsorted : sorted_sequence:t -> t -> out_int32:bool -> right:bool -> t
  val searchsorted1 : sorted_sequence:t -> 'a scalar -> out_int32:bool -> right:bool -> t

  val searchsorted_out
    :  out:t
    -> sorted_sequence:t
    -> t
    -> out_int32:bool
    -> right:bool
    -> t

  val select : t -> dim:int -> index:int -> t
  val select_backward : grad:t -> input_sizes:int list -> dim:int -> index:int -> t
  val selu : t -> t
  val selu_ : t -> t
  val set_ : t -> t
  val set_1 : t -> source:t -> t
  val set_requires_grad : t -> r:bool -> t
  val sgn : t -> t
  val sgn_ : t -> t
  val sgn_out : out:t -> t -> t
  val sigmoid : t -> t
  val sigmoid_ : t -> t
  val sigmoid_backward : grad_output:t -> output:t -> t
  val sigmoid_backward_out : grad_input:t -> grad_output:t -> output:t -> t
  val sigmoid_out : out:t -> t -> t
  val sign : t -> t
  val sign_ : t -> t
  val sign_out : out:t -> t -> t
  val signbit : t -> t
  val signbit_out : out:t -> t -> t
  val silu : t -> t
  val silu_ : t -> t
  val silu_backward : grad_output:t -> t -> t
  val silu_out : out:t -> t -> t
  val sin : t -> t
  val sin_ : t -> t
  val sin_out : out:t -> t -> t
  val sinc : t -> t
  val sinc_ : t -> t
  val sinc_out : out:t -> t -> t
  val sinh : t -> t
  val sinh_ : t -> t
  val sinh_out : out:t -> t -> t
  val slice : t -> dim:int -> start:int -> end_:int -> step:int -> t

  val slice_backward
    :  grad:t
    -> input_sizes:int list
    -> dim:int
    -> start:int
    -> end_:int
    -> step:int
    -> t

  val slogdet : t -> t * t

  val slow_conv3d
    :  t
    -> weight:t
    -> kernel_size:int list
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> t

  val slow_conv3d_out
    :  out:t
    -> t
    -> weight:t
    -> kernel_size:int list
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> t

  val slow_conv_dilated2d
    :  t
    -> weight:t
    -> kernel_size:int list
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> t

  val slow_conv_dilated3d
    :  t
    -> weight:t
    -> kernel_size:int list
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> dilation:int list
    -> t

  val slow_conv_transpose2d
    :  t
    -> weight:t
    -> kernel_size:int list
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> output_padding:int list
    -> dilation:int list
    -> t

  val slow_conv_transpose2d_out
    :  out:t
    -> t
    -> weight:t
    -> kernel_size:int list
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> output_padding:int list
    -> dilation:int list
    -> t

  val slow_conv_transpose3d
    :  t
    -> weight:t
    -> kernel_size:int list
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> output_padding:int list
    -> dilation:int list
    -> t

  val slow_conv_transpose3d_out
    :  out:t
    -> t
    -> weight:t
    -> kernel_size:int list
    -> bias:t option
    -> stride:int list
    -> padding:int list
    -> output_padding:int list
    -> dilation:int list
    -> t

  val smm : t -> mat2:t -> t
  val smooth_l1_loss : t -> target:t -> reduction:Reduction.t -> beta:float -> t

  val smooth_l1_loss_backward
    :  grad_output:t
    -> t
    -> target:t
    -> reduction:Reduction.t
    -> beta:float
    -> t

  val smooth_l1_loss_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> target:t
    -> reduction:Reduction.t
    -> beta:float
    -> t

  val smooth_l1_loss_out
    :  out:t
    -> t
    -> target:t
    -> reduction:Reduction.t
    -> beta:float
    -> t

  val soft_margin_loss : t -> target:t -> reduction:Reduction.t -> t

  val soft_margin_loss_backward
    :  grad_output:t
    -> t
    -> target:t
    -> reduction:Reduction.t
    -> t

  val soft_margin_loss_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> target:t
    -> reduction:Reduction.t
    -> t

  val soft_margin_loss_out : out:t -> t -> target:t -> reduction:Reduction.t -> t
  val softmax : t -> dim:int -> dtype:Kind.packed -> t
  val softplus : t -> t

  val softplus_backward
    :  grad_output:t
    -> t
    -> beta:'a scalar
    -> threshold:'a scalar
    -> output:t
    -> t

  val softplus_backward_out
    :  grad_input:t
    -> grad_output:t
    -> t
    -> beta:'a scalar
    -> threshold:'a scalar
    -> output:t
    -> t

  val softplus_out : out:t -> t -> t
  val softshrink : t -> t
  val softshrink_backward : grad_output:t -> t -> lambd:'a scalar -> t
  val softshrink_backward_out : grad_input:t -> grad_output:t -> t -> lambd:'a scalar -> t
  val softshrink_out : out:t -> t -> t
  val solve : t -> a:t -> t * t
  val solve_out : solution:t -> lu:t -> t -> a:t -> t * t
  val sort : t -> dim:int -> descending:bool -> t * t
  val sort_out : values:t -> indices:t -> t -> dim:int -> descending:bool -> t * t
  val sparse_coo_tensor : size:int list -> options:Kind.packed * Device.t -> t
  val sparse_coo_tensor1 : indices:t -> values:t -> options:Kind.packed * Device.t -> t

  val sparse_coo_tensor2
    :  indices:t
    -> values:t
    -> size:int list
    -> options:Kind.packed * Device.t
    -> t

  val sparse_mask : t -> mask:t -> t
  val sparse_resize_ : t -> size:int list -> sparse_dim:int -> dense_dim:int -> t

  val sparse_resize_and_clear_
    :  t
    -> size:int list
    -> sparse_dim:int
    -> dense_dim:int
    -> t

  val split : t -> split_size:int -> dim:int -> t list
  val split_with_sizes : t -> split_sizes:int list -> dim:int -> t list
  val sqrt : t -> t
  val sqrt_ : t -> t
  val sqrt_out : out:t -> t -> t
  val square : t -> t
  val square_ : t -> t
  val squeeze : t -> t
  val squeeze1 : t -> dim:int -> t
  val squeeze_ : t -> t
  val squeeze_1 : t -> dim:int -> t
  val sspaddmm : t -> mat1:t -> mat2:t -> t
  val sspaddmm_out : out:t -> t -> mat1:t -> mat2:t -> t
  val stack : t list -> dim:int -> t
  val stack_out : out:t -> t list -> dim:int -> t
  val std : t -> unbiased:bool -> t
  val std1 : t -> dim:int list -> unbiased:bool -> keepdim:bool -> t
  val std_mean : t -> unbiased:bool -> t * t
  val std_mean1 : t -> dim:int list -> unbiased:bool -> keepdim:bool -> t * t
  val std_out : out:t -> t -> dim:int list -> unbiased:bool -> keepdim:bool -> t

  val stft
    :  t
    -> n_fft:int
    -> hop_length:int
    -> win_length:int
    -> window:t option
    -> normalized:bool
    -> onesided:bool
    -> return_complex:bool
    -> t

  val sub : t -> t -> t
  val sub1 : t -> 'a scalar -> t
  val sub_ : t -> t -> t
  val sub_1 : t -> 'a scalar -> t
  val sub_out : out:t -> t -> t -> t
  val subtract : t -> t -> t
  val subtract1 : t -> 'a scalar -> t
  val subtract_ : t -> t -> t
  val subtract_1 : t -> 'a scalar -> t
  val subtract_out : out:t -> t -> t -> t
  val sum : t -> dtype:Kind.packed -> t
  val sum1 : t -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> t
  val sum_out : out:t -> t -> dim:int list -> keepdim:bool -> dtype:Kind.packed -> t
  val sum_to_size : t -> size:int list -> t
  val svd : t -> some:bool -> compute_uv:bool -> t * t * t
  val svd_out : u:t -> s:t -> v:t -> t -> some:bool -> compute_uv:bool -> t * t * t
  val swapaxes : t -> axis0:int -> axis1:int -> t
  val swapaxes_ : t -> axis0:int -> axis1:int -> t
  val swapdims : t -> dim0:int -> dim1:int -> t
  val swapdims_ : t -> dim0:int -> dim1:int -> t
  val symeig : t -> eigenvectors:bool -> upper:bool -> t * t
  val symeig_out : e:t -> v:t -> t -> eigenvectors:bool -> upper:bool -> t * t
  val tr : t -> t
  val t_ : t -> t
  val take : t -> index:t -> t
  val take_backward : grad:t -> t -> index:t -> t
  val take_out : out:t -> t -> index:t -> t
  val tan : t -> t
  val tan_ : t -> t
  val tan_out : out:t -> t -> t
  val tanh : t -> t
  val tanh_ : t -> t
  val tanh_backward : grad_output:t -> output:t -> t
  val tanh_backward_out : grad_input:t -> grad_output:t -> output:t -> t
  val tanh_out : out:t -> t -> t
  val tensor_split : t -> sections:int -> dim:int -> t list
  val tensor_split1 : t -> indices:int list -> dim:int -> t list
  val tensor_split2 : t -> tensor_indices_or_sections:t -> dim:int -> t list
  val tensordot : t -> t -> dims_self:int list -> dims_other:int list -> t
  val tensordot_out : out:t -> t -> t -> dims_self:int list -> dims_other:int list -> t
  val threshold : t -> threshold:'a scalar -> value:'a scalar -> t
  val threshold_ : t -> threshold:'a scalar -> value:'a scalar -> t
  val threshold_backward : grad_output:t -> t -> threshold:'a scalar -> t
  val threshold_out : out:t -> t -> threshold:'a scalar -> value:'a scalar -> t
  val tile : t -> dims:int list -> t
  val to_ : t -> device:Device.t -> t
  val to1 : t -> options:Kind.packed * Device.t -> non_blocking:bool -> copy:bool -> t
  val to2 : t -> dtype:Kind.packed -> non_blocking:bool -> copy:bool -> t
  val to3 : t -> t -> non_blocking:bool -> copy:bool -> t

  val to4
    :  t
    -> device:Device.t
    -> dtype:Kind.packed
    -> non_blocking:bool
    -> copy:bool
    -> t

  val to_dense : t -> dtype:Kind.packed -> t
  val to_dense_backward : grad:t -> t -> t
  val to_mkldnn : t -> dtype:Kind.packed -> t
  val to_mkldnn_backward : grad:t -> t -> t
  val to_sparse : t -> t
  val to_sparse1 : t -> sparse_dim:int -> t
  val topk : t -> k:int -> dim:int -> largest:bool -> sorted:bool -> t * t

  val topk_out
    :  values:t
    -> indices:t
    -> t
    -> k:int
    -> dim:int
    -> largest:bool
    -> sorted:bool
    -> t * t

  val totype : t -> scalar_type:Kind.packed -> t
  val trace : t -> t
  val trace_backward : grad:t -> sizes:int list -> t
  val transpose : t -> dim0:int -> dim1:int -> t
  val transpose_ : t -> dim0:int -> dim1:int -> t
  val trapz : y:t -> x:t -> dim:int -> t
  val trapz1 : y:t -> dx:float -> dim:int -> t

  val triangular_solve
    :  t
    -> a:t
    -> upper:bool
    -> transpose:bool
    -> unitriangular:bool
    -> t * t

  val triangular_solve_out
    :  x:t
    -> m:t
    -> t
    -> a:t
    -> upper:bool
    -> transpose:bool
    -> unitriangular:bool
    -> t * t

  val tril : t -> diagonal:int -> t
  val tril_ : t -> diagonal:int -> t

  val tril_indices
    :  row:int
    -> col:int
    -> offset:int
    -> options:Kind.packed * Device.t
    -> t

  val tril_out : out:t -> t -> diagonal:int -> t

  val triplet_margin_loss
    :  anchor:t
    -> positive:t
    -> negative:t
    -> margin:float
    -> p:float
    -> eps:float
    -> swap:bool
    -> reduction:Reduction.t
    -> t

  val triu : t -> diagonal:int -> t
  val triu_ : t -> diagonal:int -> t

  val triu_indices
    :  row:int
    -> col:int
    -> offset:int
    -> options:Kind.packed * Device.t
    -> t

  val triu_out : out:t -> t -> diagonal:int -> t
  val true_divide : t -> t -> t
  val true_divide1 : t -> 'a scalar -> t
  val true_divide_ : t -> t -> t
  val true_divide_1 : t -> 'a scalar -> t
  val true_divide_out : out:t -> t -> t -> t
  val trunc : t -> t
  val trunc_ : t -> t
  val trunc_out : out:t -> t -> t
  val type_as : t -> t -> t
  val unbind : t -> dim:int -> t list
  val unflatten : t -> dim:int -> sizes:int list -> t
  val unfold : t -> dimension:int -> size:int -> step:int -> t

  val unfold_backward
    :  grad_in:t
    -> input_sizes:int list
    -> dim:int
    -> size:int
    -> step:int
    -> t

  val uniform_ : t -> from:float -> to_:float -> t

  val unique_consecutive
    :  t
    -> return_inverse:bool
    -> return_counts:bool
    -> dim:int
    -> t * t * t

  val unique_dim
    :  t
    -> dim:int
    -> sorted:bool
    -> return_inverse:bool
    -> return_counts:bool
    -> t * t * t

  val unique_dim_consecutive
    :  t
    -> dim:int
    -> return_inverse:bool
    -> return_counts:bool
    -> t * t * t

  val unsafe_chunk : t -> chunks:int -> dim:int -> t list
  val unsafe_split : t -> split_size:int -> dim:int -> t list
  val unsafe_split_with_sizes : t -> split_sizes:int list -> dim:int -> t list
  val unsqueeze : t -> dim:int -> t
  val unsqueeze_ : t -> dim:int -> t

  val upsample_bicubic2d
    :  t
    -> output_size:int list
    -> align_corners:bool
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_bicubic2d_backward
    :  grad_output:t
    -> output_size:int list
    -> input_size:int list
    -> align_corners:bool
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_bicubic2d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> output_size:int list
    -> input_size:int list
    -> align_corners:bool
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_bicubic2d_out
    :  out:t
    -> t
    -> output_size:int list
    -> align_corners:bool
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_bilinear2d
    :  t
    -> output_size:int list
    -> align_corners:bool
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_bilinear2d_backward
    :  grad_output:t
    -> output_size:int list
    -> input_size:int list
    -> align_corners:bool
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_bilinear2d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> output_size:int list
    -> input_size:int list
    -> align_corners:bool
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_bilinear2d_out
    :  out:t
    -> t
    -> output_size:int list
    -> align_corners:bool
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_linear1d
    :  t
    -> output_size:int list
    -> align_corners:bool
    -> scales:float
    -> t

  val upsample_linear1d_backward
    :  grad_output:t
    -> output_size:int list
    -> input_size:int list
    -> align_corners:bool
    -> scales:float
    -> t

  val upsample_linear1d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> output_size:int list
    -> input_size:int list
    -> align_corners:bool
    -> scales:float
    -> t

  val upsample_linear1d_out
    :  out:t
    -> t
    -> output_size:int list
    -> align_corners:bool
    -> scales:float
    -> t

  val upsample_nearest1d : t -> output_size:int list -> scales:float -> t

  val upsample_nearest1d_backward
    :  grad_output:t
    -> output_size:int list
    -> input_size:int list
    -> scales:float
    -> t

  val upsample_nearest1d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> output_size:int list
    -> input_size:int list
    -> scales:float
    -> t

  val upsample_nearest1d_out : out:t -> t -> output_size:int list -> scales:float -> t

  val upsample_nearest2d
    :  t
    -> output_size:int list
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_nearest2d_backward
    :  grad_output:t
    -> output_size:int list
    -> input_size:int list
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_nearest2d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> output_size:int list
    -> input_size:int list
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_nearest2d_out
    :  out:t
    -> t
    -> output_size:int list
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_nearest3d
    :  t
    -> output_size:int list
    -> scales_d:float
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_nearest3d_backward
    :  grad_output:t
    -> output_size:int list
    -> input_size:int list
    -> scales_d:float
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_nearest3d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> output_size:int list
    -> input_size:int list
    -> scales_d:float
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_nearest3d_out
    :  out:t
    -> t
    -> output_size:int list
    -> scales_d:float
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_trilinear3d
    :  t
    -> output_size:int list
    -> align_corners:bool
    -> scales_d:float
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_trilinear3d_backward
    :  grad_output:t
    -> output_size:int list
    -> input_size:int list
    -> align_corners:bool
    -> scales_d:float
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_trilinear3d_backward_out
    :  grad_input:t
    -> grad_output:t
    -> output_size:int list
    -> input_size:int list
    -> align_corners:bool
    -> scales_d:float
    -> scales_h:float
    -> scales_w:float
    -> t

  val upsample_trilinear3d_out
    :  out:t
    -> t
    -> output_size:int list
    -> align_corners:bool
    -> scales_d:float
    -> scales_h:float
    -> scales_w:float
    -> t

  val value_selecting_reduction_backward
    :  grad:t
    -> dim:int
    -> indices:t
    -> sizes:int list
    -> keepdim:bool
    -> t

  val values : t -> t
  val vander : x:t -> n:int -> increasing:bool -> t
  val var : t -> unbiased:bool -> t
  val var1 : t -> dim:int list -> unbiased:bool -> keepdim:bool -> t
  val var_mean : t -> unbiased:bool -> t * t
  val var_mean1 : t -> dim:int list -> unbiased:bool -> keepdim:bool -> t * t
  val var_out : out:t -> t -> dim:int list -> unbiased:bool -> keepdim:bool -> t
  val vdot : t -> t -> t
  val vdot_out : out:t -> t -> t -> t
  val view : t -> size:int list -> t
  val view1 : t -> dtype:Kind.packed -> t
  val view_as : t -> t -> t
  val view_as_complex : t -> t
  val view_as_real : t -> t
  val vstack : t list -> t
  val vstack_out : out:t -> t list -> t
  val where : condition:t -> t list
  val where1 : condition:t -> t -> t -> t
  val where2 : condition:t -> 'a scalar -> t -> t
  val where3 : condition:t -> t -> 'a scalar -> t
  val where4 : condition:t -> 'a scalar -> 'a scalar -> t
  val xlogy : t -> t -> t
  val xlogy1 : 'a scalar -> t -> t
  val xlogy2 : t -> 'a scalar -> t
  val xlogy_ : t -> t -> t
  val xlogy_1 : t -> 'a scalar -> t
  val xlogy_out : out:t -> t -> t -> t
  val xlogy_out1 : out:t -> 'a scalar -> t -> t
  val xlogy_out2 : out:t -> t -> 'a scalar -> t
  val zero_ : t -> t
  val zeros : size:int list -> options:Kind.packed * Device.t -> t
  val zeros_like : t -> t
  val zeros_out : out:t -> size:int list -> t
end