AllenGeng/ocamlgithub · Datasets at Hugging Face

text stringlengths 12 786k
let nanquantile self ~ q ~ dim ~ keepdim = let out__ = CArray . make t 1 in stubs_nanquantile ( CArray . start out__ ) self q ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nanquantile_new self ~ q ~ dim ~ keepdim ~ interpolation = let out__ = CArray . make t 1 in stubs_nanquantile_new ( CArray . start out__ ) self q ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) interpolation ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nanquantile_new_out ~ out self ~ q ~ dim ~ keepdim ~ interpolation = let out__ = CArray . make t 1 in stubs_nanquantile_new_out ( CArray . start out__ ) out self q ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) interpolation ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nanquantile_new_scalar self ~ q ~ dim ~ keepdim ~ interpolation = let out__ = CArray . make t 1 in stubs_nanquantile_new_scalar ( CArray . start out__ ) self q ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) interpolation ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nanquantile_new_scalar_out ~ out self ~ q ~ dim ~ keepdim ~ interpolation = let out__ = CArray . make t 1 in stubs_nanquantile_new_scalar_out ( CArray . start out__ ) out self q ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) interpolation ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nanquantile_out ~ out self ~ q ~ dim ~ keepdim = let out__ = CArray . make t 1 in stubs_nanquantile_out ( CArray . start out__ ) out self q ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nanquantile_scalar self ~ q ~ dim ~ keepdim = let out__ = CArray . make t 1 in stubs_nanquantile_scalar ( CArray . start out__ ) self q ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nanquantile_scalar_out ~ out self ~ q ~ dim ~ keepdim = let out__ = CArray . make t 1 in stubs_nanquantile_scalar_out ( CArray . start out__ ) out self q ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nansum self ~ dtype = let out__ = CArray . make t 1 in stubs_nansum ( CArray . start out__ ) self ( Kind . packed_to_int dtype ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nansum_dim_intlist self ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_nansum_dim_intlist ( CArray . start out__ ) self ( List . map Int64 . of_int dim \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ( Kind . packed_to_int dtype ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nansum_intlist_out ~ out self ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_nansum_intlist_out ( CArray . start out__ ) out self ( List . map Int64 . of_int dim \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ( Kind . packed_to_int dtype ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let narrow self ~ dim ~ start ~ length = let out__ = CArray . make t 1 in stubs_narrow ( CArray . start out__ ) self ( Int64 . of_int dim ) ( Int64 . of_int start ) ( Int64 . of_int length ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let narrow_copy self ~ dim ~ start ~ length = let out__ = CArray . make t 1 in stubs_narrow_copy ( CArray . start out__ ) self ( Int64 . of_int dim ) ( Int64 . of_int start ) ( Int64 . of_int length ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let narrow_copy_out ~ out self ~ dim ~ start ~ length = let out__ = CArray . make t 1 in stubs_narrow_copy_out ( CArray . start out__ ) out self ( Int64 . of_int dim ) ( Int64 . of_int start ) ( Int64 . of_int length ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let narrow_tensor self ~ dim ~ start ~ length = let out__ = CArray . make t 1 in stubs_narrow_tensor ( CArray . start out__ ) self ( Int64 . of_int dim ) start ( Int64 . of_int length ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let native_batch_norm input ~ weight ~ bias ~ running_mean ~ running_var ~ training ~ momentum ~ eps = let out__ = CArray . make t 3 in stubs_native_batch_norm ( CArray . start out__ ) input ( match weight with \| Some v -> v \| None -> null ) ( match bias with \| Some v -> v \| None -> null ) ( match running_mean with \| Some v -> v \| None -> null ) ( match running_var with \| Some v -> v \| None -> null ) ( if training then 1 else 0 ) momentum eps ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; let t1 = CArray . get out__ 1 in Gc . finalise C . Tensor . free t1 ; let t2 = CArray . get out__ 2 in Gc . finalise C . Tensor . free t2 ; t0 , t1 , t2
let native_batch_norm_out ~ out ~ save_mean ~ save_invstd input ~ weight ~ bias ~ running_mean ~ running_var ~ training ~ momentum ~ eps = let out__ = CArray . make t 3 in stubs_native_batch_norm_out ( CArray . start out__ ) out save_mean save_invstd input ( match weight with \| Some v -> v \| None -> null ) ( match bias with \| Some v -> v \| None -> null ) ( match running_mean with \| Some v -> v \| None -> null ) ( match running_var with \| Some v -> v \| None -> null ) ( if training then 1 else 0 ) momentum eps ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; let t1 = CArray . get out__ 1 in Gc . finalise C . Tensor . free t1 ; let t2 = CArray . get out__ 2 in Gc . finalise C . Tensor . free t2 ; t0 , t1 , t2
let native_group_norm input ~ weight ~ bias ~ n ~ c ~ hxw ~ group ~ eps = let out__ = CArray . make t 3 in stubs_native_group_norm ( CArray . start out__ ) input ( match weight with \| Some v -> v \| None -> null ) ( match bias with \| Some v -> v \| None -> null ) ( Int64 . of_int n ) ( Int64 . of_int c ) ( Int64 . of_int hxw ) ( Int64 . of_int group ) eps ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; let t1 = CArray . get out__ 1 in Gc . finalise C . Tensor . free t1 ; let t2 = CArray . get out__ 2 in Gc . finalise C . Tensor . free t2 ; t0 , t1 , t2
let native_layer_norm input ~ normalized_shape ~ weight ~ bias ~ eps = let out__ = CArray . make t 3 in stubs_native_layer_norm ( CArray . start out__ ) input ( List . map Int64 . of_int normalized_shape \|> CArray . of_list int64_t \|> CArray . start ) ( List . length normalized_shape ) ( match weight with \| Some v -> v \| None -> null ) ( match bias with \| Some v -> v \| None -> null ) eps ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; let t1 = CArray . get out__ 1 in Gc . finalise C . Tensor . free t1 ; let t2 = CArray . get out__ 2 in Gc . finalise C . Tensor . free t2 ; t0 , t1 , t2
let native_norm self = let out__ = CArray . make t 1 in stubs_native_norm ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let native_norm_scalaropt_dim_dtype self ~ p ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_native_norm_scalaropt_dim_dtype ( CArray . start out__ ) self p ( List . map Int64 . of_int dim \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ( Kind . packed_to_int dtype ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let ne self other = let out__ = CArray . make t 1 in stubs_ne ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let ne_ self other = let out__ = CArray . make t 1 in stubs_ne_ ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let ne_scalar_out ~ out self other = let out__ = CArray . make t 1 in stubs_ne_scalar_out ( CArray . start out__ ) out self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let ne_tensor self other = let out__ = CArray . make t 1 in stubs_ne_tensor ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let ne_tensor_ self other = let out__ = CArray . make t 1 in stubs_ne_tensor_ ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let ne_tensor_out ~ out self other = let out__ = CArray . make t 1 in stubs_ne_tensor_out ( CArray . start out__ ) out self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let neg self = let out__ = CArray . make t 1 in stubs_neg ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let neg_ self = let out__ = CArray . make t 1 in stubs_neg_ ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let neg_out ~ out self = let out__ = CArray . make t 1 in stubs_neg_out ( CArray . start out__ ) out self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let negative self = let out__ = CArray . make t 1 in stubs_negative ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let negative_ self = let out__ = CArray . make t 1 in stubs_negative_ ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let negative_out ~ out self = let out__ = CArray . make t 1 in stubs_negative_out ( CArray . start out__ ) out self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let new_empty self ~ size ~ options = let out__ = CArray . make t 1 in stubs_new_empty ( CArray . start out__ ) self ( List . map Int64 . of_int size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length size ) ( Kind . packed_to_int ( fst options ) ) ( Device . to_int ( snd options ) ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let new_empty_strided self ~ size ~ stride ~ options = let out__ = CArray . make t 1 in stubs_new_empty_strided ( CArray . start out__ ) self ( List . map Int64 . of_int size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length size ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( Kind . packed_to_int ( fst options ) ) ( Device . to_int ( snd options ) ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let new_full self ~ size ~ fill_value ~ options = let out__ = CArray . make t 1 in stubs_new_full ( CArray . start out__ ) self ( List . map Int64 . of_int size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length size ) fill_value ( Kind . packed_to_int ( fst options ) ) ( Device . to_int ( snd options ) ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let new_ones self ~ size ~ options = let out__ = CArray . make t 1 in stubs_new_ones ( CArray . start out__ ) self ( List . map Int64 . of_int size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length size ) ( Kind . packed_to_int ( fst options ) ) ( Device . to_int ( snd options ) ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let new_zeros self ~ size ~ options = let out__ = CArray . make t 1 in stubs_new_zeros ( CArray . start out__ ) self ( List . map Int64 . of_int size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length size ) ( Kind . packed_to_int ( fst options ) ) ( Device . to_int ( snd options ) ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nextafter self other = let out__ = CArray . make t 1 in stubs_nextafter ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nextafter_ self other = let out__ = CArray . make t 1 in stubs_nextafter_ ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nextafter_out ~ out self other = let out__ = CArray . make t 1 in stubs_nextafter_out ( CArray . start out__ ) out self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nll_loss self ~ target ~ weight ~ reduction ~ ignore_index = let out__ = CArray . make t 1 in stubs_nll_loss ( CArray . start out__ ) self target ( match weight with \| Some v -> v \| None -> null ) ( Reduction . to_int reduction \|> Int64 . of_int ) ( Int64 . of_int ignore_index ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nll_loss2d self ~ target ~ weight ~ reduction ~ ignore_index = let out__ = CArray . make t 1 in stubs_nll_loss2d ( CArray . start out__ ) self target ( match weight with \| Some v -> v \| None -> null ) ( Reduction . to_int reduction \|> Int64 . of_int ) ( Int64 . of_int ignore_index ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nll_loss2d_backward ~ grad_output self ~ target ~ weight ~ reduction ~ ignore_index ~ total_weight = let out__ = CArray . make t 1 in stubs_nll_loss2d_backward ( CArray . start out__ ) grad_output self target ( match weight with \| Some v -> v \| None -> null ) ( Reduction . to_int reduction \|> Int64 . of_int ) ( Int64 . of_int ignore_index ) total_weight ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nll_loss2d_backward_grad_input ~ grad_input ~ grad_output self ~ target ~ weight ~ reduction ~ ignore_index ~ total_weight = let out__ = CArray . make t 1 in stubs_nll_loss2d_backward_grad_input ( CArray . start out__ ) grad_input grad_output self target ( match weight with \| Some v -> v \| None -> null ) ( Reduction . to_int reduction \|> Int64 . of_int ) ( Int64 . of_int ignore_index ) total_weight ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nll_loss2d_out ~ out self ~ target ~ weight ~ reduction ~ ignore_index = let out__ = CArray . make t 1 in stubs_nll_loss2d_out ( CArray . start out__ ) out self target ( match weight with \| Some v -> v \| None -> null ) ( Reduction . to_int reduction \|> Int64 . of_int ) ( Int64 . of_int ignore_index ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nll_loss_backward ~ grad_output self ~ target ~ weight ~ reduction ~ ignore_index ~ total_weight = let out__ = CArray . make t 1 in stubs_nll_loss_backward ( CArray . start out__ ) grad_output self target ( match weight with \| Some v -> v \| None -> null ) ( Reduction . to_int reduction \|> Int64 . of_int ) ( Int64 . of_int ignore_index ) total_weight ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nll_loss_backward_grad_input ~ grad_input ~ grad_output self ~ target ~ weight ~ reduction ~ ignore_index ~ total_weight = let out__ = CArray . make t 1 in stubs_nll_loss_backward_grad_input ( CArray . start out__ ) grad_input grad_output self target ( match weight with \| Some v -> v \| None -> null ) ( Reduction . to_int reduction \|> Int64 . of_int ) ( Int64 . of_int ignore_index ) total_weight ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nll_loss_nd self ~ target ~ weight ~ reduction ~ ignore_index = let out__ = CArray . make t 1 in stubs_nll_loss_nd ( CArray . start out__ ) self target ( match weight with \| Some v -> v \| None -> null ) ( Reduction . to_int reduction \|> Int64 . of_int ) ( Int64 . of_int ignore_index ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nll_loss_out ~ out self ~ target ~ weight ~ reduction ~ ignore_index = let out__ = CArray . make t 1 in stubs_nll_loss_out ( CArray . start out__ ) out self target ( match weight with \| Some v -> v \| None -> null ) ( Reduction . to_int reduction \|> Int64 . of_int ) ( Int64 . of_int ignore_index ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nonzero self = let out__ = CArray . make t 1 in stubs_nonzero ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nonzero_numpy self = stubs_nonzero_numpy self \|> to_tensor_list
let nonzero_out ~ out self = let out__ = CArray . make t 1 in stubs_nonzero_out ( CArray . start out__ ) out self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let norm self = let out__ = CArray . make t 1 in stubs_norm ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let norm_dtype_out ~ out self ~ p ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_norm_dtype_out ( CArray . start out__ ) out self p ( List . map Int64 . of_int dim \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ( Kind . packed_to_int dtype ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let norm_except_dim ~ v ~ pow ~ dim = let out__ = CArray . make t 1 in stubs_norm_except_dim ( CArray . start out__ ) v ( Int64 . of_int pow ) ( Int64 . of_int dim ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let norm_out ~ out self ~ p ~ dim ~ keepdim = let out__ = CArray . make t 1 in stubs_norm_out ( CArray . start out__ ) out self p ( List . map Int64 . of_int dim \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let norm_scalaropt_dim self ~ p ~ dim ~ keepdim = let out__ = CArray . make t 1 in stubs_norm_scalaropt_dim ( CArray . start out__ ) self p ( List . map Int64 . of_int dim \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let norm_scalaropt_dim_dtype self ~ p ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_norm_scalaropt_dim_dtype ( CArray . start out__ ) self p ( List . map Int64 . of_int dim \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ( Kind . packed_to_int dtype ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let norm_scalaropt_dtype self ~ p ~ dtype = let out__ = CArray . make t 1 in stubs_norm_scalaropt_dtype ( CArray . start out__ ) self p ( Kind . packed_to_int dtype ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let normal ~ out ~ mean ~ std = let out__ = CArray . make t 1 in stubs_normal ( CArray . start out__ ) out mean std ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let normal_ self ~ mean ~ std = let out__ = CArray . make t 1 in stubs_normal_ ( CArray . start out__ ) self mean std ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let normal_float_float_out ~ out ~ mean ~ std ~ size = let out__ = CArray . make t 1 in stubs_normal_float_float_out ( CArray . start out__ ) out mean std ( List . map Int64 . of_int size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length size ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let normal_float_tensor_out ~ out ~ mean ~ std = let out__ = CArray . make t 1 in stubs_normal_float_tensor_out ( CArray . start out__ ) out mean std ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let normal_tensor_tensor_out ~ out ~ mean ~ std = let out__ = CArray . make t 1 in stubs_normal_tensor_tensor_out ( CArray . start out__ ) out mean std ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let not_equal self other = let out__ = CArray . make t 1 in stubs_not_equal ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let not_equal_ self other = let out__ = CArray . make t 1 in stubs_not_equal_ ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let not_equal_scalar_out ~ out self other = let out__ = CArray . make t 1 in stubs_not_equal_scalar_out ( CArray . start out__ ) out self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let not_equal_tensor self other = let out__ = CArray . make t 1 in stubs_not_equal_tensor ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let not_equal_tensor_ self other = let out__ = CArray . make t 1 in stubs_not_equal_tensor_ ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let not_equal_tensor_out ~ out self other = let out__ = CArray . make t 1 in stubs_not_equal_tensor_out ( CArray . start out__ ) out self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nuclear_norm self ~ keepdim = let out__ = CArray . make t 1 in stubs_nuclear_norm ( CArray . start out__ ) self ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nuclear_norm_dim self ~ dim ~ keepdim = let out__ = CArray . make t 1 in stubs_nuclear_norm_dim ( CArray . start out__ ) self ( List . map Int64 . of_int dim \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nuclear_norm_dim_out ~ out self ~ dim ~ keepdim = let out__ = CArray . make t 1 in stubs_nuclear_norm_dim_out ( CArray . start out__ ) out self ( List . map Int64 . of_int dim \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nuclear_norm_out ~ out self ~ keepdim = let out__ = CArray . make t 1 in stubs_nuclear_norm_out ( CArray . start out__ ) out self ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let numpy_t self = let out__ = CArray . make t 1 in stubs_numpy_t ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let one_hot self ~ num_classes = let out__ = CArray . make t 1 in stubs_one_hot ( CArray . start out__ ) self ( Int64 . of_int num_classes ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let ones ~ size ~ options = let out__ = CArray . make t 1 in stubs_ones ( CArray . start out__ ) ( List . map Int64 . of_int size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length size ) ( Kind . packed_to_int ( fst options ) ) ( Device . to_int ( snd options ) ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let ones_like self = let out__ = CArray . make t 1 in stubs_ones_like ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let ones_out ~ out ~ size = let out__ = CArray . make t 1 in stubs_ones_out ( CArray . start out__ ) out ( List . map Int64 . of_int size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length size ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let orgqr self ~ input2 = let out__ = CArray . make t 1 in stubs_orgqr ( CArray . start out__ ) self input2 ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let orgqr_out ~ out self ~ input2 = let out__ = CArray . make t 1 in stubs_orgqr_out ( CArray . start out__ ) out self input2 ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let ormqr self ~ input2 ~ input3 ~ left ~ transpose = let out__ = CArray . make t 1 in stubs_ormqr ( CArray . start out__ ) self input2 input3 ( if left then 1 else 0 ) ( if transpose then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let ormqr_out ~ out self ~ input2 ~ input3 ~ left ~ transpose = let out__ = CArray . make t 1 in stubs_ormqr_out ( CArray . start out__ ) out self input2 input3 ( if left then 1 else 0 ) ( if transpose then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let outer self ~ vec2 = let out__ = CArray . make t 1 in stubs_outer ( CArray . start out__ ) self vec2 ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let outer_out ~ out self ~ vec2 = let out__ = CArray . make t 1 in stubs_outer_out ( CArray . start out__ ) out self vec2 ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let pad_sequence ~ sequences ~ batch_first ~ padding_value = let out__ = CArray . make t 1 in stubs_pad_sequence ( CArray . start out__ ) ( CArray . of_list t sequences \|> CArray . start ) ( List . length sequences ) ( if batch_first then 1 else 0 ) padding_value ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let pairwise_distance ~ x1 ~ x2 ~ p ~ eps ~ keepdim = let out__ = CArray . make t 1 in stubs_pairwise_distance ( CArray . start out__ ) x1 x2 p eps ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let pdist self ~ p = let out__ = CArray . make t 1 in stubs_pdist ( CArray . start out__ ) self p ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let permute self ~ dims = let out__ = CArray . make t 1 in stubs_permute ( CArray . start out__ ) self ( List . map Int64 . of_int dims \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dims ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let pin_memory self ~ device = let out__ = CArray . make t 1 in stubs_pin_memory ( CArray . start out__ ) self ( Device . to_int device ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let pinverse self ~ rcond = let out__ = CArray . make t 1 in stubs_pinverse ( CArray . start out__ ) self rcond ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let pixel_shuffle self ~ upscale_factor = let out__ = CArray . make t 1 in stubs_pixel_shuffle ( CArray . start out__ ) self ( Int64 . of_int upscale_factor ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let pixel_unshuffle self ~ downscale_factor = let out__ = CArray . make t 1 in stubs_pixel_unshuffle ( CArray . start out__ ) self ( Int64 . of_int downscale_factor ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let poisson self = let out__ = CArray . make t 1 in stubs_poisson ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let poisson_nll_loss input ~ target ~ log_input ~ full ~ eps ~ reduction = let out__ = CArray . make t 1 in stubs_poisson_nll_loss ( CArray . start out__ ) input target ( if log_input then 1 else 0 ) ( if full then 1 else 0 ) eps ( Reduction . to_int reduction \|> Int64 . of_int ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let polar ~ abs ~ angle = let out__ = CArray . make t 1 in stubs_polar ( CArray . start out__ ) abs angle ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let polar_out ~ out ~ abs ~ angle = let out__ = CArray . make t 1 in stubs_polar_out ( CArray . start out__ ) out abs angle ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let polygamma ~ n self = let out__ = CArray . make t 1 in stubs_polygamma ( CArray . start out__ ) ( Int64 . of_int n ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let polygamma_ self ~ n = let out__ = CArray . make t 1 in stubs_polygamma_ ( CArray . start out__ ) self ( Int64 . of_int n ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nanquantile self ~ q ~ dim ~ keepdim = let out__ = CArray . make t 1 in stubs_nanquantile ( CArray . start out__ ) self q ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nanquantile_new self ~ q ~ dim ~ keepdim ~ interpolation = let out__ = CArray . make t 1 in stubs_nanquantile_new ( CArray . start out__ ) self q ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) interpolation ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nanquantile_new_out ~ out self ~ q ~ dim ~ keepdim ~ interpolation = let out__ = CArray . make t 1 in stubs_nanquantile_new_out ( CArray . start out__ ) out self q ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) interpolation ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nanquantile_new_scalar self ~ q ~ dim ~ keepdim ~ interpolation = let out__ = CArray . make t 1 in stubs_nanquantile_new_scalar ( CArray . start out__ ) self q ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) interpolation ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nanquantile_new_scalar_out ~ out self ~ q ~ dim ~ keepdim ~ interpolation = let out__ = CArray . make t 1 in stubs_nanquantile_new_scalar_out ( CArray . start out__ ) out self q ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) interpolation ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nanquantile_out ~ out self ~ q ~ dim ~ keepdim = let out__ = CArray . make t 1 in stubs_nanquantile_out ( CArray . start out__ ) out self q ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nanquantile_scalar self ~ q ~ dim ~ keepdim = let out__ = CArray . make t 1 in stubs_nanquantile_scalar ( CArray . start out__ ) self q ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nanquantile_scalar_out ~ out self ~ q ~ dim ~ keepdim = let out__ = CArray . make t 1 in stubs_nanquantile_scalar_out ( CArray . start out__ ) out self q ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nansum self ~ dtype = let out__ = CArray . make t 1 in stubs_nansum ( CArray . start out__ ) self ( Kind . packed_to_int dtype ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nansum_dim_intlist self ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_nansum_dim_intlist ( CArray . start out__ ) self ( List . map Int64 . of_int dim |> CArray . of_list int64_t |> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ( Kind . packed_to_int dtype ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nansum_intlist_out ~ out self ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_nansum_intlist_out ( CArray . start out__ ) out self ( List . map Int64 . of_int dim |> CArray . of_list int64_t |> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ( Kind . packed_to_int dtype ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let narrow self ~ dim ~ start ~ length = let out__ = CArray . make t 1 in stubs_narrow ( CArray . start out__ ) self ( Int64 . of_int dim ) ( Int64 . of_int start ) ( Int64 . of_int length ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let narrow_copy self ~ dim ~ start ~ length = let out__ = CArray . make t 1 in stubs_narrow_copy ( CArray . start out__ ) self ( Int64 . of_int dim ) ( Int64 . of_int start ) ( Int64 . of_int length ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let narrow_copy_out ~ out self ~ dim ~ start ~ length = let out__ = CArray . make t 1 in stubs_narrow_copy_out ( CArray . start out__ ) out self ( Int64 . of_int dim ) ( Int64 . of_int start ) ( Int64 . of_int length ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let narrow_tensor self ~ dim ~ start ~ length = let out__ = CArray . make t 1 in stubs_narrow_tensor ( CArray . start out__ ) self ( Int64 . of_int dim ) start ( Int64 . of_int length ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let native_batch_norm input ~ weight ~ bias ~ running_mean ~ running_var ~ training ~ momentum ~ eps = let out__ = CArray . make t 3 in stubs_native_batch_norm ( CArray . start out__ ) input ( match weight with | Some v -> v | None -> null ) ( match bias with | Some v -> v | None -> null ) ( match running_mean with | Some v -> v | None -> null ) ( match running_var with | Some v -> v | None -> null ) ( if training then 1 else 0 ) momentum eps ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; let t1 = CArray . get out__ 1 in Gc . finalise C . Tensor . free t1 ; let t2 = CArray . get out__ 2 in Gc . finalise C . Tensor . free t2 ; t0 , t1 , t2

let native_batch_norm_out ~ out ~ save_mean ~ save_invstd input ~ weight ~ bias ~ running_mean ~ running_var ~ training ~ momentum ~ eps = let out__ = CArray . make t 3 in stubs_native_batch_norm_out ( CArray . start out__ ) out save_mean save_invstd input ( match weight with | Some v -> v | None -> null ) ( match bias with | Some v -> v | None -> null ) ( match running_mean with | Some v -> v | None -> null ) ( match running_var with | Some v -> v | None -> null ) ( if training then 1 else 0 ) momentum eps ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; let t1 = CArray . get out__ 1 in Gc . finalise C . Tensor . free t1 ; let t2 = CArray . get out__ 2 in Gc . finalise C . Tensor . free t2 ; t0 , t1 , t2

let native_group_norm input ~ weight ~ bias ~ n ~ c ~ hxw ~ group ~ eps = let out__ = CArray . make t 3 in stubs_native_group_norm ( CArray . start out__ ) input ( match weight with | Some v -> v | None -> null ) ( match bias with | Some v -> v | None -> null ) ( Int64 . of_int n ) ( Int64 . of_int c ) ( Int64 . of_int hxw ) ( Int64 . of_int group ) eps ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; let t1 = CArray . get out__ 1 in Gc . finalise C . Tensor . free t1 ; let t2 = CArray . get out__ 2 in Gc . finalise C . Tensor . free t2 ; t0 , t1 , t2

let native_layer_norm input ~ normalized_shape ~ weight ~ bias ~ eps = let out__ = CArray . make t 3 in stubs_native_layer_norm ( CArray . start out__ ) input ( List . map Int64 . of_int normalized_shape |> CArray . of_list int64_t |> CArray . start ) ( List . length normalized_shape ) ( match weight with | Some v -> v | None -> null ) ( match bias with | Some v -> v | None -> null ) eps ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; let t1 = CArray . get out__ 1 in Gc . finalise C . Tensor . free t1 ; let t2 = CArray . get out__ 2 in Gc . finalise C . Tensor . free t2 ; t0 , t1 , t2

let native_norm self = let out__ = CArray . make t 1 in stubs_native_norm ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let native_norm_scalaropt_dim_dtype self ~ p ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_native_norm_scalaropt_dim_dtype ( CArray . start out__ ) self p ( List . map Int64 . of_int dim |> CArray . of_list int64_t |> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ( Kind . packed_to_int dtype ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let ne self other = let out__ = CArray . make t 1 in stubs_ne ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let ne_ self other = let out__ = CArray . make t 1 in stubs_ne_ ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let ne_scalar_out ~ out self other = let out__ = CArray . make t 1 in stubs_ne_scalar_out ( CArray . start out__ ) out self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let ne_tensor self other = let out__ = CArray . make t 1 in stubs_ne_tensor ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let ne_tensor_ self other = let out__ = CArray . make t 1 in stubs_ne_tensor_ ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let ne_tensor_out ~ out self other = let out__ = CArray . make t 1 in stubs_ne_tensor_out ( CArray . start out__ ) out self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let neg self = let out__ = CArray . make t 1 in stubs_neg ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let neg_ self = let out__ = CArray . make t 1 in stubs_neg_ ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let neg_out ~ out self = let out__ = CArray . make t 1 in stubs_neg_out ( CArray . start out__ ) out self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let negative self = let out__ = CArray . make t 1 in stubs_negative ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let negative_ self = let out__ = CArray . make t 1 in stubs_negative_ ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let negative_out ~ out self = let out__ = CArray . make t 1 in stubs_negative_out ( CArray . start out__ ) out self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let new_empty self ~ size ~ options = let out__ = CArray . make t 1 in stubs_new_empty ( CArray . start out__ ) self ( List . map Int64 . of_int size |> CArray . of_list int64_t |> CArray . start ) ( List . length size ) ( Kind . packed_to_int ( fst options ) ) ( Device . to_int ( snd options ) ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let new_empty_strided self ~ size ~ stride ~ options = let out__ = CArray . make t 1 in stubs_new_empty_strided ( CArray . start out__ ) self ( List . map Int64 . of_int size |> CArray . of_list int64_t |> CArray . start ) ( List . length size ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( Kind . packed_to_int ( fst options ) ) ( Device . to_int ( snd options ) ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let new_full self ~ size ~ fill_value ~ options = let out__ = CArray . make t 1 in stubs_new_full ( CArray . start out__ ) self ( List . map Int64 . of_int size |> CArray . of_list int64_t |> CArray . start ) ( List . length size ) fill_value ( Kind . packed_to_int ( fst options ) ) ( Device . to_int ( snd options ) ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let new_ones self ~ size ~ options = let out__ = CArray . make t 1 in stubs_new_ones ( CArray . start out__ ) self ( List . map Int64 . of_int size |> CArray . of_list int64_t |> CArray . start ) ( List . length size ) ( Kind . packed_to_int ( fst options ) ) ( Device . to_int ( snd options ) ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let new_zeros self ~ size ~ options = let out__ = CArray . make t 1 in stubs_new_zeros ( CArray . start out__ ) self ( List . map Int64 . of_int size |> CArray . of_list int64_t |> CArray . start ) ( List . length size ) ( Kind . packed_to_int ( fst options ) ) ( Device . to_int ( snd options ) ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nextafter self other = let out__ = CArray . make t 1 in stubs_nextafter ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nextafter_ self other = let out__ = CArray . make t 1 in stubs_nextafter_ ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nextafter_out ~ out self other = let out__ = CArray . make t 1 in stubs_nextafter_out ( CArray . start out__ ) out self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nll_loss self ~ target ~ weight ~ reduction ~ ignore_index = let out__ = CArray . make t 1 in stubs_nll_loss ( CArray . start out__ ) self target ( match weight with | Some v -> v | None -> null ) ( Reduction . to_int reduction |> Int64 . of_int ) ( Int64 . of_int ignore_index ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nll_loss2d self ~ target ~ weight ~ reduction ~ ignore_index = let out__ = CArray . make t 1 in stubs_nll_loss2d ( CArray . start out__ ) self target ( match weight with | Some v -> v | None -> null ) ( Reduction . to_int reduction |> Int64 . of_int ) ( Int64 . of_int ignore_index ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nll_loss2d_backward ~ grad_output self ~ target ~ weight ~ reduction ~ ignore_index ~ total_weight = let out__ = CArray . make t 1 in stubs_nll_loss2d_backward ( CArray . start out__ ) grad_output self target ( match weight with | Some v -> v | None -> null ) ( Reduction . to_int reduction |> Int64 . of_int ) ( Int64 . of_int ignore_index ) total_weight ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nll_loss2d_backward_grad_input ~ grad_input ~ grad_output self ~ target ~ weight ~ reduction ~ ignore_index ~ total_weight = let out__ = CArray . make t 1 in stubs_nll_loss2d_backward_grad_input ( CArray . start out__ ) grad_input grad_output self target ( match weight with | Some v -> v | None -> null ) ( Reduction . to_int reduction |> Int64 . of_int ) ( Int64 . of_int ignore_index ) total_weight ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nll_loss2d_out ~ out self ~ target ~ weight ~ reduction ~ ignore_index = let out__ = CArray . make t 1 in stubs_nll_loss2d_out ( CArray . start out__ ) out self target ( match weight with | Some v -> v | None -> null ) ( Reduction . to_int reduction |> Int64 . of_int ) ( Int64 . of_int ignore_index ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nll_loss_backward ~ grad_output self ~ target ~ weight ~ reduction ~ ignore_index ~ total_weight = let out__ = CArray . make t 1 in stubs_nll_loss_backward ( CArray . start out__ ) grad_output self target ( match weight with | Some v -> v | None -> null ) ( Reduction . to_int reduction |> Int64 . of_int ) ( Int64 . of_int ignore_index ) total_weight ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nll_loss_backward_grad_input ~ grad_input ~ grad_output self ~ target ~ weight ~ reduction ~ ignore_index ~ total_weight = let out__ = CArray . make t 1 in stubs_nll_loss_backward_grad_input ( CArray . start out__ ) grad_input grad_output self target ( match weight with | Some v -> v | None -> null ) ( Reduction . to_int reduction |> Int64 . of_int ) ( Int64 . of_int ignore_index ) total_weight ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nll_loss_nd self ~ target ~ weight ~ reduction ~ ignore_index = let out__ = CArray . make t 1 in stubs_nll_loss_nd ( CArray . start out__ ) self target ( match weight with | Some v -> v | None -> null ) ( Reduction . to_int reduction |> Int64 . of_int ) ( Int64 . of_int ignore_index ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nll_loss_out ~ out self ~ target ~ weight ~ reduction ~ ignore_index = let out__ = CArray . make t 1 in stubs_nll_loss_out ( CArray . start out__ ) out self target ( match weight with | Some v -> v | None -> null ) ( Reduction . to_int reduction |> Int64 . of_int ) ( Int64 . of_int ignore_index ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nonzero self = let out__ = CArray . make t 1 in stubs_nonzero ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nonzero_numpy self = stubs_nonzero_numpy self |> to_tensor_list

let nonzero_out ~ out self = let out__ = CArray . make t 1 in stubs_nonzero_out ( CArray . start out__ ) out self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let norm self = let out__ = CArray . make t 1 in stubs_norm ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let norm_dtype_out ~ out self ~ p ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_norm_dtype_out ( CArray . start out__ ) out self p ( List . map Int64 . of_int dim |> CArray . of_list int64_t |> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ( Kind . packed_to_int dtype ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let norm_except_dim ~ v ~ pow ~ dim = let out__ = CArray . make t 1 in stubs_norm_except_dim ( CArray . start out__ ) v ( Int64 . of_int pow ) ( Int64 . of_int dim ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let norm_out ~ out self ~ p ~ dim ~ keepdim = let out__ = CArray . make t 1 in stubs_norm_out ( CArray . start out__ ) out self p ( List . map Int64 . of_int dim |> CArray . of_list int64_t |> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let norm_scalaropt_dim self ~ p ~ dim ~ keepdim = let out__ = CArray . make t 1 in stubs_norm_scalaropt_dim ( CArray . start out__ ) self p ( List . map Int64 . of_int dim |> CArray . of_list int64_t |> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let norm_scalaropt_dim_dtype self ~ p ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_norm_scalaropt_dim_dtype ( CArray . start out__ ) self p ( List . map Int64 . of_int dim |> CArray . of_list int64_t |> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ( Kind . packed_to_int dtype ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let norm_scalaropt_dtype self ~ p ~ dtype = let out__ = CArray . make t 1 in stubs_norm_scalaropt_dtype ( CArray . start out__ ) self p ( Kind . packed_to_int dtype ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let normal ~ out ~ mean ~ std = let out__ = CArray . make t 1 in stubs_normal ( CArray . start out__ ) out mean std ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let normal_ self ~ mean ~ std = let out__ = CArray . make t 1 in stubs_normal_ ( CArray . start out__ ) self mean std ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let normal_float_float_out ~ out ~ mean ~ std ~ size = let out__ = CArray . make t 1 in stubs_normal_float_float_out ( CArray . start out__ ) out mean std ( List . map Int64 . of_int size |> CArray . of_list int64_t |> CArray . start ) ( List . length size ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let normal_float_tensor_out ~ out ~ mean ~ std = let out__ = CArray . make t 1 in stubs_normal_float_tensor_out ( CArray . start out__ ) out mean std ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let normal_tensor_tensor_out ~ out ~ mean ~ std = let out__ = CArray . make t 1 in stubs_normal_tensor_tensor_out ( CArray . start out__ ) out mean std ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let not_equal self other = let out__ = CArray . make t 1 in stubs_not_equal ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let not_equal_ self other = let out__ = CArray . make t 1 in stubs_not_equal_ ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let not_equal_scalar_out ~ out self other = let out__ = CArray . make t 1 in stubs_not_equal_scalar_out ( CArray . start out__ ) out self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let not_equal_tensor self other = let out__ = CArray . make t 1 in stubs_not_equal_tensor ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let not_equal_tensor_ self other = let out__ = CArray . make t 1 in stubs_not_equal_tensor_ ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let not_equal_tensor_out ~ out self other = let out__ = CArray . make t 1 in stubs_not_equal_tensor_out ( CArray . start out__ ) out self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nuclear_norm self ~ keepdim = let out__ = CArray . make t 1 in stubs_nuclear_norm ( CArray . start out__ ) self ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nuclear_norm_dim self ~ dim ~ keepdim = let out__ = CArray . make t 1 in stubs_nuclear_norm_dim ( CArray . start out__ ) self ( List . map Int64 . of_int dim |> CArray . of_list int64_t |> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nuclear_norm_dim_out ~ out self ~ dim ~ keepdim = let out__ = CArray . make t 1 in stubs_nuclear_norm_dim_out ( CArray . start out__ ) out self ( List . map Int64 . of_int dim |> CArray . of_list int64_t |> CArray . start ) ( List . length dim ) ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nuclear_norm_out ~ out self ~ keepdim = let out__ = CArray . make t 1 in stubs_nuclear_norm_out ( CArray . start out__ ) out self ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let numpy_t self = let out__ = CArray . make t 1 in stubs_numpy_t ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let one_hot self ~ num_classes = let out__ = CArray . make t 1 in stubs_one_hot ( CArray . start out__ ) self ( Int64 . of_int num_classes ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let ones ~ size ~ options = let out__ = CArray . make t 1 in stubs_ones ( CArray . start out__ ) ( List . map Int64 . of_int size |> CArray . of_list int64_t |> CArray . start ) ( List . length size ) ( Kind . packed_to_int ( fst options ) ) ( Device . to_int ( snd options ) ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let ones_like self = let out__ = CArray . make t 1 in stubs_ones_like ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let ones_out ~ out ~ size = let out__ = CArray . make t 1 in stubs_ones_out ( CArray . start out__ ) out ( List . map Int64 . of_int size |> CArray . of_list int64_t |> CArray . start ) ( List . length size ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let orgqr self ~ input2 = let out__ = CArray . make t 1 in stubs_orgqr ( CArray . start out__ ) self input2 ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let orgqr_out ~ out self ~ input2 = let out__ = CArray . make t 1 in stubs_orgqr_out ( CArray . start out__ ) out self input2 ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let ormqr self ~ input2 ~ input3 ~ left ~ transpose = let out__ = CArray . make t 1 in stubs_ormqr ( CArray . start out__ ) self input2 input3 ( if left then 1 else 0 ) ( if transpose then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let ormqr_out ~ out self ~ input2 ~ input3 ~ left ~ transpose = let out__ = CArray . make t 1 in stubs_ormqr_out ( CArray . start out__ ) out self input2 input3 ( if left then 1 else 0 ) ( if transpose then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let outer self ~ vec2 = let out__ = CArray . make t 1 in stubs_outer ( CArray . start out__ ) self vec2 ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let outer_out ~ out self ~ vec2 = let out__ = CArray . make t 1 in stubs_outer_out ( CArray . start out__ ) out self vec2 ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let pad_sequence ~ sequences ~ batch_first ~ padding_value = let out__ = CArray . make t 1 in stubs_pad_sequence ( CArray . start out__ ) ( CArray . of_list t sequences |> CArray . start ) ( List . length sequences ) ( if batch_first then 1 else 0 ) padding_value ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let pairwise_distance ~ x1 ~ x2 ~ p ~ eps ~ keepdim = let out__ = CArray . make t 1 in stubs_pairwise_distance ( CArray . start out__ ) x1 x2 p eps ( if keepdim then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let pdist self ~ p = let out__ = CArray . make t 1 in stubs_pdist ( CArray . start out__ ) self p ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let permute self ~ dims = let out__ = CArray . make t 1 in stubs_permute ( CArray . start out__ ) self ( List . map Int64 . of_int dims |> CArray . of_list int64_t |> CArray . start ) ( List . length dims ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let pin_memory self ~ device = let out__ = CArray . make t 1 in stubs_pin_memory ( CArray . start out__ ) self ( Device . to_int device ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let pinverse self ~ rcond = let out__ = CArray . make t 1 in stubs_pinverse ( CArray . start out__ ) self rcond ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let pixel_shuffle self ~ upscale_factor = let out__ = CArray . make t 1 in stubs_pixel_shuffle ( CArray . start out__ ) self ( Int64 . of_int upscale_factor ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let pixel_unshuffle self ~ downscale_factor = let out__ = CArray . make t 1 in stubs_pixel_unshuffle ( CArray . start out__ ) self ( Int64 . of_int downscale_factor ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let poisson self = let out__ = CArray . make t 1 in stubs_poisson ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let poisson_nll_loss input ~ target ~ log_input ~ full ~ eps ~ reduction = let out__ = CArray . make t 1 in stubs_poisson_nll_loss ( CArray . start out__ ) input target ( if log_input then 1 else 0 ) ( if full then 1 else 0 ) eps ( Reduction . to_int reduction |> Int64 . of_int ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let polar ~ abs ~ angle = let out__ = CArray . make t 1 in stubs_polar ( CArray . start out__ ) abs angle ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let polar_out ~ out ~ abs ~ angle = let out__ = CArray . make t 1 in stubs_polar_out ( CArray . start out__ ) out abs angle ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let polygamma ~ n self = let out__ = CArray . make t 1 in stubs_polygamma ( CArray . start out__ ) ( Int64 . of_int n ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let polygamma_ self ~ n = let out__ = CArray . make t 1 in stubs_polygamma_ ( CArray . start out__ ) self ( Int64 . of_int n ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0