AllenGeng/ocamlgithub · Datasets at Hugging Face

text stringlengths 12 786k
let max_unpool2d_backward ~ grad_output self ~ indices ~ output_size = let out__ = CArray . make t 1 in stubs_max_unpool2d_backward ( CArray . start out__ ) grad_output self indices ( List . map Int64 . of_int output_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length output_size ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let max_unpool2d_backward_grad_input ~ grad_input ~ grad_output self ~ indices ~ output_size = let out__ = CArray . make t 1 in stubs_max_unpool2d_backward_grad_input ( CArray . start out__ ) grad_input grad_output self indices ( List . map Int64 . of_int output_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length output_size ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let max_unpool2d_out ~ out self ~ indices ~ output_size = let out__ = CArray . make t 1 in stubs_max_unpool2d_out ( CArray . start out__ ) out self indices ( List . map Int64 . of_int output_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length output_size ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let max_unpool3d self ~ indices ~ output_size ~ stride ~ padding = let out__ = CArray . make t 1 in stubs_max_unpool3d ( CArray . start out__ ) self indices ( List . map Int64 . of_int output_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length output_size ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let max_unpool3d_backward ~ grad_output self ~ indices ~ output_size ~ stride ~ padding = let out__ = CArray . make t 1 in stubs_max_unpool3d_backward ( CArray . start out__ ) grad_output self indices ( List . map Int64 . of_int output_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length output_size ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let max_unpool3d_backward_grad_input ~ grad_input ~ grad_output self ~ indices ~ output_size ~ stride ~ padding = let out__ = CArray . make t 1 in stubs_max_unpool3d_backward_grad_input ( CArray . start out__ ) grad_input grad_output self indices ( List . map Int64 . of_int output_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length output_size ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let max_unpool3d_out ~ out self ~ indices ~ output_size ~ stride ~ padding = let out__ = CArray . make t 1 in stubs_max_unpool3d_out ( CArray . start out__ ) out self indices ( List . map Int64 . of_int output_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length output_size ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let maximum self other = let out__ = CArray . make t 1 in stubs_maximum ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let maximum_out ~ out self other = let out__ = CArray . make t 1 in stubs_maximum_out ( CArray . start out__ ) out self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mean self ~ dtype = let out__ = CArray . make t 1 in stubs_mean ( CArray . start out__ ) self ( Kind . packed_to_int dtype ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mean_dim self ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_mean_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 ) ( Kind . packed_to_int dtype ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mean_out ~ out self ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_mean_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 median self = let out__ = CArray . make t 1 in stubs_median ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let median_dim self ~ dim ~ keepdim = let out__ = CArray . make t 2 in stubs_median_dim ( CArray . start out__ ) self ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; 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 ; t0 , t1
let median_dim_values ~ values ~ indices self ~ dim ~ keepdim = let out__ = CArray . make t 2 in stubs_median_dim_values ( CArray . start out__ ) values indices self ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; 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 ; t0 , t1
let meshgrid tensors = stubs_meshgrid ( CArray . of_list t tensors \|> CArray . start ) ( List . length tensors ) \|> to_tensor_list
let meshgrid_indexing tensors ~ indexing = stubs_meshgrid_indexing ( CArray . of_list t tensors \|> CArray . start ) ( List . length tensors ) indexing \|> to_tensor_list
let min self = let out__ = CArray . make t 1 in stubs_min ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let min_dim self ~ dim ~ keepdim = let out__ = CArray . make t 2 in stubs_min_dim ( CArray . start out__ ) self ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; 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 ; t0 , t1
let min_dim_min ~ min ~ min_indices self ~ dim ~ keepdim = let out__ = CArray . make t 2 in stubs_min_dim_min ( CArray . start out__ ) min min_indices self ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; 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 ; t0 , t1
let min_other self other = let out__ = CArray . make t 1 in stubs_min_other ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let min_out ~ out self other = let out__ = CArray . make t 1 in stubs_min_out ( CArray . start out__ ) out self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let minimum self other = let out__ = CArray . make t 1 in stubs_minimum ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let minimum_out ~ out self other = let out__ = CArray . make t 1 in stubs_minimum_out ( CArray . start out__ ) out self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let miopen_batch_norm input ~ weight ~ bias ~ running_mean ~ running_var ~ training ~ exponential_average_factor ~ epsilon = let out__ = CArray . make t 3 in stubs_miopen_batch_norm ( CArray . start out__ ) input weight ( 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 ) exponential_average_factor epsilon ; 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 miopen_batch_norm_backward input ~ grad_output ~ weight ~ running_mean ~ running_var ~ save_mean ~ save_var ~ epsilon = let out__ = CArray . make t 3 in stubs_miopen_batch_norm_backward ( CArray . start out__ ) input grad_output weight ( match running_mean with \| Some v -> v \| None -> null ) ( match running_var with \| Some v -> v \| None -> null ) ( match save_mean with \| Some v -> v \| None -> null ) ( match save_var with \| Some v -> v \| None -> null ) epsilon ; 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 miopen_convolution self ~ weight ~ bias ~ padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_convolution ( CArray . start out__ ) self weight ( match bias with \| Some v -> v \| None -> null ) ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let miopen_convolution_backward_bias ~ grad_output = let out__ = CArray . make t 1 in stubs_miopen_convolution_backward_bias ( CArray . start out__ ) grad_output ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let miopen_convolution_backward_input ~ self_size ~ grad_output ~ weight ~ padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_convolution_backward_input ( CArray . start out__ ) ( List . map Int64 . of_int self_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length self_size ) grad_output weight ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let miopen_convolution_backward_weight ~ weight_size ~ grad_output self ~ padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_convolution_backward_weight ( CArray . start out__ ) ( List . map Int64 . of_int weight_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length weight_size ) grad_output self ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let miopen_convolution_transpose self ~ weight ~ bias ~ padding ~ output_padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_convolution_transpose ( CArray . start out__ ) self weight ( match bias with \| Some v -> v \| None -> null ) ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int output_padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length output_padding ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let miopen_convolution_transpose_backward_input ~ grad_output ~ weight ~ padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_convolution_transpose_backward_input ( CArray . start out__ ) grad_output weight ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let miopen_convolution_transpose_backward_weight ~ weight_size ~ grad_output self ~ padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_convolution_transpose_backward_weight ( CArray . start out__ ) ( List . map Int64 . of_int weight_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length weight_size ) grad_output self ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let miopen_depthwise_convolution self ~ weight ~ bias ~ padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_depthwise_convolution ( CArray . start out__ ) self weight ( match bias with \| Some v -> v \| None -> null ) ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let miopen_depthwise_convolution_backward_input ~ self_size ~ grad_output ~ weight ~ padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_depthwise_convolution_backward_input ( CArray . start out__ ) ( List . map Int64 . of_int self_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length self_size ) grad_output weight ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let miopen_depthwise_convolution_backward_weight ~ weight_size ~ grad_output self ~ padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_depthwise_convolution_backward_weight ( CArray . start out__ ) ( List . map Int64 . of_int weight_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length weight_size ) grad_output self ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let miopen_rnn input ~ weight ~ weight_stride0 ~ hx ~ cx ~ mode ~ hidden_size ~ num_layers ~ batch_first ~ dropout ~ train ~ bidirectional ~ batch_sizes ~ dropout_state = let out__ = CArray . make t 5 in stubs_miopen_rnn ( CArray . start out__ ) input ( CArray . of_list t weight \|> CArray . start ) ( List . length weight ) ( Int64 . of_int weight_stride0 ) hx ( match cx with \| Some v -> v \| None -> null ) ( Int64 . of_int mode ) ( Int64 . of_int hidden_size ) ( Int64 . of_int num_layers ) ( if batch_first then 1 else 0 ) dropout ( if train then 1 else 0 ) ( if bidirectional then 1 else 0 ) ( List . map Int64 . of_int batch_sizes \|> CArray . of_list int64_t \|> CArray . start ) ( List . length batch_sizes ) ( match dropout_state with \| Some v -> v \| None -> null ) ; 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 ; let t3 = CArray . get out__ 3 in Gc . finalise C . Tensor . free t3 ; let t4 = CArray . get out__ 4 in Gc . finalise C . Tensor . free t4 ; t0 , t1 , t2 , t3 , t4
let mish self = let out__ = CArray . make t 1 in stubs_mish ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mish_ self = let out__ = CArray . make t 1 in stubs_mish_ ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mish_backward ~ grad_output self = let out__ = CArray . make t 1 in stubs_mish_backward ( CArray . start out__ ) grad_output self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mish_out ~ out self = let out__ = CArray . make t 1 in stubs_mish_out ( CArray . start out__ ) out self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mkldnn_adaptive_avg_pool2d self ~ output_size = let out__ = CArray . make t 1 in stubs_mkldnn_adaptive_avg_pool2d ( CArray . start out__ ) self ( List . map Int64 . of_int output_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length output_size ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mkldnn_adaptive_avg_pool2d_backward ~ grad_output self = let out__ = CArray . make t 1 in stubs_mkldnn_adaptive_avg_pool2d_backward ( CArray . start out__ ) grad_output self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mkldnn_convolution self ~ weight ~ bias ~ padding ~ stride ~ dilation ~ groups = let out__ = CArray . make t 1 in stubs_mkldnn_convolution ( CArray . start out__ ) self weight ( match bias with \| Some v -> v \| None -> null ) ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mkldnn_convolution_backward_input ~ self_size ~ grad_output ~ weight ~ padding ~ stride ~ dilation ~ groups ~ bias_defined = let out__ = CArray . make t 1 in stubs_mkldnn_convolution_backward_input ( CArray . start out__ ) ( List . map Int64 . of_int self_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length self_size ) grad_output weight ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if bias_defined then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mkldnn_convolution_backward_weights ~ weight_size ~ grad_output self ~ padding ~ stride ~ dilation ~ groups ~ bias_defined = let out__ = CArray . make t 2 in stubs_mkldnn_convolution_backward_weights ( CArray . start out__ ) ( List . map Int64 . of_int weight_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length weight_size ) grad_output self ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if bias_defined then 1 else 0 ) ; 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 ; t0 , t1
let mkldnn_linear self ~ weight ~ bias = let out__ = CArray . make t 1 in stubs_mkldnn_linear ( CArray . start out__ ) self weight ( match bias with \| Some v -> v \| None -> null ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mkldnn_linear_backward_input ~ input_size ~ grad_output ~ weight = let out__ = CArray . make t 1 in stubs_mkldnn_linear_backward_input ( CArray . start out__ ) ( List . map Int64 . of_int input_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length input_size ) grad_output weight ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mkldnn_linear_backward_weights ~ grad_output input ~ weight ~ bias_defined = let out__ = CArray . make t 2 in stubs_mkldnn_linear_backward_weights ( CArray . start out__ ) grad_output input weight ( if bias_defined then 1 else 0 ) ; 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 ; t0 , t1
let mkldnn_max_pool2d self ~ kernel_size ~ stride ~ padding ~ dilation ~ ceil_mode = let out__ = CArray . make t 1 in stubs_mkldnn_max_pool2d ( CArray . start out__ ) self ( List . map Int64 . of_int kernel_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length kernel_size ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( if ceil_mode then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mkldnn_max_pool2d_backward ~ grad_output ~ output input ~ kernel_size ~ stride ~ padding ~ dilation ~ ceil_mode = let out__ = CArray . make t 1 in stubs_mkldnn_max_pool2d_backward ( CArray . start out__ ) grad_output output input ( List . map Int64 . of_int kernel_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length kernel_size ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( if ceil_mode then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mkldnn_max_pool3d self ~ kernel_size ~ stride ~ padding ~ dilation ~ ceil_mode = let out__ = CArray . make t 1 in stubs_mkldnn_max_pool3d ( CArray . start out__ ) self ( List . map Int64 . of_int kernel_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length kernel_size ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( if ceil_mode then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mkldnn_max_pool3d_backward ~ grad_output ~ output input ~ kernel_size ~ stride ~ padding ~ dilation ~ ceil_mode = let out__ = CArray . make t 1 in stubs_mkldnn_max_pool3d_backward ( CArray . start out__ ) grad_output output input ( List . map Int64 . of_int kernel_size \|> CArray . of_list int64_t \|> CArray . start ) ( List . length kernel_size ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( if ceil_mode then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mkldnn_reorder_conv2d_weight self ~ padding ~ stride ~ dilation ~ groups = let out__ = CArray . make t 1 in stubs_mkldnn_reorder_conv2d_weight ( CArray . start out__ ) self ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mkldnn_reorder_conv3d_weight self ~ padding ~ stride ~ dilation ~ groups = let out__ = CArray . make t 1 in stubs_mkldnn_reorder_conv3d_weight ( CArray . start out__ ) self ( List . map Int64 . of_int padding \|> CArray . of_list int64_t \|> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride \|> CArray . of_list int64_t \|> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation \|> CArray . of_list int64_t \|> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mm self ~ mat2 = let out__ = CArray . make t 1 in stubs_mm ( CArray . start out__ ) self mat2 ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mm_out ~ out self ~ mat2 = let out__ = CArray . make t 1 in stubs_mm_out ( CArray . start out__ ) out self mat2 ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mode self ~ dim ~ keepdim = let out__ = CArray . make t 2 in stubs_mode ( CArray . start out__ ) self ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; 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 ; t0 , t1
let mode_values ~ values ~ indices self ~ dim ~ keepdim = let out__ = CArray . make t 2 in stubs_mode_values ( CArray . start out__ ) values indices self ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; 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 ; t0 , t1
let moveaxis self ~ source ~ destination = let out__ = CArray . make t 1 in stubs_moveaxis ( CArray . start out__ ) self ( List . map Int64 . of_int source \|> CArray . of_list int64_t \|> CArray . start ) ( List . length source ) ( List . map Int64 . of_int destination \|> CArray . of_list int64_t \|> CArray . start ) ( List . length destination ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let moveaxis_int self ~ source ~ destination = let out__ = CArray . make t 1 in stubs_moveaxis_int ( CArray . start out__ ) self ( Int64 . of_int source ) ( Int64 . of_int destination ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let movedim self ~ source ~ destination = let out__ = CArray . make t 1 in stubs_movedim ( CArray . start out__ ) self ( List . map Int64 . of_int source \|> CArray . of_list int64_t \|> CArray . start ) ( List . length source ) ( List . map Int64 . of_int destination \|> CArray . of_list int64_t \|> CArray . start ) ( List . length destination ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let movedim_int self ~ source ~ destination = let out__ = CArray . make t 1 in stubs_movedim_int ( CArray . start out__ ) self ( Int64 . of_int source ) ( Int64 . of_int destination ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mse_loss self ~ target ~ reduction = let out__ = CArray . make t 1 in stubs_mse_loss ( CArray . start out__ ) self target ( Reduction . to_int reduction \|> Int64 . of_int ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mse_loss_backward ~ grad_output self ~ target ~ reduction = let out__ = CArray . make t 1 in stubs_mse_loss_backward ( CArray . start out__ ) grad_output self target ( Reduction . to_int reduction \|> Int64 . of_int ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mse_loss_backward_grad_input ~ grad_input ~ grad_output self ~ target ~ reduction = let out__ = CArray . make t 1 in stubs_mse_loss_backward_grad_input ( CArray . start out__ ) grad_input grad_output self target ( Reduction . to_int reduction \|> Int64 . of_int ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mse_loss_out ~ out self ~ target ~ reduction = let out__ = CArray . make t 1 in stubs_mse_loss_out ( CArray . start out__ ) out self target ( Reduction . to_int reduction \|> Int64 . of_int ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let msort self = let out__ = CArray . make t 1 in stubs_msort ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let msort_out ~ out self = let out__ = CArray . make t 1 in stubs_msort_out ( CArray . start out__ ) out self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mul self other = let out__ = CArray . make t 1 in stubs_mul ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mul_ self other = let out__ = CArray . make t 1 in stubs_mul_ ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mul_out ~ out self other = let out__ = CArray . make t 1 in stubs_mul_out ( CArray . start out__ ) out self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mul_scalar self other = let out__ = CArray . make t 1 in stubs_mul_scalar ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mul_scalar_ self other = let out__ = CArray . make t 1 in stubs_mul_scalar_ ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let multi_margin_loss_backward ~ grad_output self ~ target ~ p ~ margin ~ weight ~ reduction = let out__ = CArray . make t 1 in stubs_multi_margin_loss_backward ( CArray . start out__ ) grad_output self target p margin ( match weight with \| Some v -> v \| None -> null ) ( Reduction . to_int reduction \|> Int64 . of_int ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let multi_margin_loss_backward_grad_input ~ grad_input ~ grad_output self ~ target ~ p ~ margin ~ weight ~ reduction = let out__ = CArray . make t 1 in stubs_multi_margin_loss_backward_grad_input ( CArray . start out__ ) grad_input grad_output self target p margin ( match weight with \| Some v -> v \| None -> null ) ( Reduction . to_int reduction \|> Int64 . of_int ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let multilabel_margin_loss self ~ target ~ reduction = let out__ = CArray . make t 1 in stubs_multilabel_margin_loss ( CArray . start out__ ) self target ( Reduction . to_int reduction \|> Int64 . of_int ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let multilabel_margin_loss_backward ~ grad_output self ~ target ~ reduction ~ is_target = let out__ = CArray . make t 1 in stubs_multilabel_margin_loss_backward ( CArray . start out__ ) grad_output self target ( Reduction . to_int reduction \|> Int64 . of_int ) is_target ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let multilabel_margin_loss_backward_grad_input ~ grad_input ~ grad_output self ~ target ~ reduction ~ is_target = let out__ = CArray . make t 1 in stubs_multilabel_margin_loss_backward_grad_input ( CArray . start out__ ) grad_input grad_output self target ( Reduction . to_int reduction \|> Int64 . of_int ) is_target ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let multilabel_margin_loss_out ~ out self ~ target ~ reduction = let out__ = CArray . make t 1 in stubs_multilabel_margin_loss_out ( CArray . start out__ ) out self target ( Reduction . to_int reduction \|> Int64 . of_int ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let multinomial self ~ num_samples ~ replacement = let out__ = CArray . make t 1 in stubs_multinomial ( CArray . start out__ ) self ( Int64 . of_int num_samples ) ( if replacement then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let multinomial_out ~ out self ~ num_samples ~ replacement = let out__ = CArray . make t 1 in stubs_multinomial_out ( CArray . start out__ ) out self ( Int64 . of_int num_samples ) ( if replacement then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let multiply self other = let out__ = CArray . make t 1 in stubs_multiply ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let multiply_ self other = let out__ = CArray . make t 1 in stubs_multiply_ ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let multiply_out ~ out self other = let out__ = CArray . make t 1 in stubs_multiply_out ( CArray . start out__ ) out self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let multiply_scalar self other = let out__ = CArray . make t 1 in stubs_multiply_scalar ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let multiply_scalar_ self other = let out__ = CArray . make t 1 in stubs_multiply_scalar_ ( CArray . start out__ ) self other ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mv self ~ vec = let out__ = CArray . make t 1 in stubs_mv ( CArray . start out__ ) self vec ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mv_out ~ out self ~ vec = let out__ = CArray . make t 1 in stubs_mv_out ( CArray . start out__ ) out self vec ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mvlgamma self ~ p = let out__ = CArray . make t 1 in stubs_mvlgamma ( CArray . start out__ ) self ( Int64 . of_int p ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mvlgamma_ self ~ p = let out__ = CArray . make t 1 in stubs_mvlgamma_ ( CArray . start out__ ) self ( Int64 . of_int p ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let mvlgamma_out ~ out self ~ p = let out__ = CArray . make t 1 in stubs_mvlgamma_out ( CArray . start out__ ) out self ( Int64 . of_int p ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nan_to_num self ~ nan ~ posinf ~ neginf = let out__ = CArray . make t 1 in stubs_nan_to_num ( CArray . start out__ ) self nan posinf neginf ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nan_to_num_ self ~ nan ~ posinf ~ neginf = let out__ = CArray . make t 1 in stubs_nan_to_num_ ( CArray . start out__ ) self nan posinf neginf ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nan_to_num_out ~ out self ~ nan ~ posinf ~ neginf = let out__ = CArray . make t 1 in stubs_nan_to_num_out ( CArray . start out__ ) out self nan posinf neginf ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nanmean self ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_nanmean ( 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 nanmean_out ~ out self ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_nanmean_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 nanmedian self = let out__ = CArray . make t 1 in stubs_nanmedian ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0
let nanmedian_dim self ~ dim ~ keepdim = let out__ = CArray . make t 2 in stubs_nanmedian_dim ( CArray . start out__ ) self ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; 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 ; t0 , t1
let nanmedian_dim_values ~ values ~ indices self ~ dim ~ keepdim = let out__ = CArray . make t 2 in stubs_nanmedian_dim_values ( CArray . start out__ ) values indices self ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; 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 ; t0 , t1

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

let max_unpool2d_backward_grad_input ~ grad_input ~ grad_output self ~ indices ~ output_size = let out__ = CArray . make t 1 in stubs_max_unpool2d_backward_grad_input ( CArray . start out__ ) grad_input grad_output self indices ( List . map Int64 . of_int output_size |> CArray . of_list int64_t |> CArray . start ) ( List . length output_size ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

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

let max_unpool3d self ~ indices ~ output_size ~ stride ~ padding = let out__ = CArray . make t 1 in stubs_max_unpool3d ( CArray . start out__ ) self indices ( List . map Int64 . of_int output_size |> CArray . of_list int64_t |> CArray . start ) ( List . length output_size ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let max_unpool3d_backward ~ grad_output self ~ indices ~ output_size ~ stride ~ padding = let out__ = CArray . make t 1 in stubs_max_unpool3d_backward ( CArray . start out__ ) grad_output self indices ( List . map Int64 . of_int output_size |> CArray . of_list int64_t |> CArray . start ) ( List . length output_size ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let max_unpool3d_backward_grad_input ~ grad_input ~ grad_output self ~ indices ~ output_size ~ stride ~ padding = let out__ = CArray . make t 1 in stubs_max_unpool3d_backward_grad_input ( CArray . start out__ ) grad_input grad_output self indices ( List . map Int64 . of_int output_size |> CArray . of_list int64_t |> CArray . start ) ( List . length output_size ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let max_unpool3d_out ~ out self ~ indices ~ output_size ~ stride ~ padding = let out__ = CArray . make t 1 in stubs_max_unpool3d_out ( CArray . start out__ ) out self indices ( List . map Int64 . of_int output_size |> CArray . of_list int64_t |> CArray . start ) ( List . length output_size ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

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

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

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

let mean_dim self ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_mean_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 ) ( Kind . packed_to_int dtype ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let mean_out ~ out self ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_mean_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 median self = let out__ = CArray . make t 1 in stubs_median ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let median_dim self ~ dim ~ keepdim = let out__ = CArray . make t 2 in stubs_median_dim ( CArray . start out__ ) self ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; 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 ; t0 , t1

let median_dim_values ~ values ~ indices self ~ dim ~ keepdim = let out__ = CArray . make t 2 in stubs_median_dim_values ( CArray . start out__ ) values indices self ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; 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 ; t0 , t1

let meshgrid tensors = stubs_meshgrid ( CArray . of_list t tensors |> CArray . start ) ( List . length tensors ) |> to_tensor_list

let meshgrid_indexing tensors ~ indexing = stubs_meshgrid_indexing ( CArray . of_list t tensors |> CArray . start ) ( List . length tensors ) indexing |> to_tensor_list

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

let min_dim self ~ dim ~ keepdim = let out__ = CArray . make t 2 in stubs_min_dim ( CArray . start out__ ) self ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; 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 ; t0 , t1

let min_dim_min ~ min ~ min_indices self ~ dim ~ keepdim = let out__ = CArray . make t 2 in stubs_min_dim_min ( CArray . start out__ ) min min_indices self ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; 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 ; t0 , t1

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

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

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

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

let miopen_batch_norm input ~ weight ~ bias ~ running_mean ~ running_var ~ training ~ exponential_average_factor ~ epsilon = let out__ = CArray . make t 3 in stubs_miopen_batch_norm ( CArray . start out__ ) input weight ( 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 ) exponential_average_factor epsilon ; 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 miopen_batch_norm_backward input ~ grad_output ~ weight ~ running_mean ~ running_var ~ save_mean ~ save_var ~ epsilon = let out__ = CArray . make t 3 in stubs_miopen_batch_norm_backward ( CArray . start out__ ) input grad_output weight ( match running_mean with | Some v -> v | None -> null ) ( match running_var with | Some v -> v | None -> null ) ( match save_mean with | Some v -> v | None -> null ) ( match save_var with | Some v -> v | None -> null ) epsilon ; 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 miopen_convolution self ~ weight ~ bias ~ padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_convolution ( CArray . start out__ ) self weight ( match bias with | Some v -> v | None -> null ) ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let miopen_convolution_backward_bias ~ grad_output = let out__ = CArray . make t 1 in stubs_miopen_convolution_backward_bias ( CArray . start out__ ) grad_output ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let miopen_convolution_backward_input ~ self_size ~ grad_output ~ weight ~ padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_convolution_backward_input ( CArray . start out__ ) ( List . map Int64 . of_int self_size |> CArray . of_list int64_t |> CArray . start ) ( List . length self_size ) grad_output weight ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let miopen_convolution_backward_weight ~ weight_size ~ grad_output self ~ padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_convolution_backward_weight ( CArray . start out__ ) ( List . map Int64 . of_int weight_size |> CArray . of_list int64_t |> CArray . start ) ( List . length weight_size ) grad_output self ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let miopen_convolution_transpose self ~ weight ~ bias ~ padding ~ output_padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_convolution_transpose ( CArray . start out__ ) self weight ( match bias with | Some v -> v | None -> null ) ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int output_padding |> CArray . of_list int64_t |> CArray . start ) ( List . length output_padding ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let miopen_convolution_transpose_backward_input ~ grad_output ~ weight ~ padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_convolution_transpose_backward_input ( CArray . start out__ ) grad_output weight ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let miopen_convolution_transpose_backward_weight ~ weight_size ~ grad_output self ~ padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_convolution_transpose_backward_weight ( CArray . start out__ ) ( List . map Int64 . of_int weight_size |> CArray . of_list int64_t |> CArray . start ) ( List . length weight_size ) grad_output self ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let miopen_depthwise_convolution self ~ weight ~ bias ~ padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_depthwise_convolution ( CArray . start out__ ) self weight ( match bias with | Some v -> v | None -> null ) ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let miopen_depthwise_convolution_backward_input ~ self_size ~ grad_output ~ weight ~ padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_depthwise_convolution_backward_input ( CArray . start out__ ) ( List . map Int64 . of_int self_size |> CArray . of_list int64_t |> CArray . start ) ( List . length self_size ) grad_output weight ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let miopen_depthwise_convolution_backward_weight ~ weight_size ~ grad_output self ~ padding ~ stride ~ dilation ~ groups ~ benchmark ~ deterministic = let out__ = CArray . make t 1 in stubs_miopen_depthwise_convolution_backward_weight ( CArray . start out__ ) ( List . map Int64 . of_int weight_size |> CArray . of_list int64_t |> CArray . start ) ( List . length weight_size ) grad_output self ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if benchmark then 1 else 0 ) ( if deterministic then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let miopen_rnn input ~ weight ~ weight_stride0 ~ hx ~ cx ~ mode ~ hidden_size ~ num_layers ~ batch_first ~ dropout ~ train ~ bidirectional ~ batch_sizes ~ dropout_state = let out__ = CArray . make t 5 in stubs_miopen_rnn ( CArray . start out__ ) input ( CArray . of_list t weight |> CArray . start ) ( List . length weight ) ( Int64 . of_int weight_stride0 ) hx ( match cx with | Some v -> v | None -> null ) ( Int64 . of_int mode ) ( Int64 . of_int hidden_size ) ( Int64 . of_int num_layers ) ( if batch_first then 1 else 0 ) dropout ( if train then 1 else 0 ) ( if bidirectional then 1 else 0 ) ( List . map Int64 . of_int batch_sizes |> CArray . of_list int64_t |> CArray . start ) ( List . length batch_sizes ) ( match dropout_state with | Some v -> v | None -> null ) ; 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 ; let t3 = CArray . get out__ 3 in Gc . finalise C . Tensor . free t3 ; let t4 = CArray . get out__ 4 in Gc . finalise C . Tensor . free t4 ; t0 , t1 , t2 , t3 , t4

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

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

let mish_backward ~ grad_output self = let out__ = CArray . make t 1 in stubs_mish_backward ( CArray . start out__ ) grad_output self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

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

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

let mkldnn_adaptive_avg_pool2d_backward ~ grad_output self = let out__ = CArray . make t 1 in stubs_mkldnn_adaptive_avg_pool2d_backward ( CArray . start out__ ) grad_output self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let mkldnn_convolution self ~ weight ~ bias ~ padding ~ stride ~ dilation ~ groups = let out__ = CArray . make t 1 in stubs_mkldnn_convolution ( CArray . start out__ ) self weight ( match bias with | Some v -> v | None -> null ) ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let mkldnn_convolution_backward_input ~ self_size ~ grad_output ~ weight ~ padding ~ stride ~ dilation ~ groups ~ bias_defined = let out__ = CArray . make t 1 in stubs_mkldnn_convolution_backward_input ( CArray . start out__ ) ( List . map Int64 . of_int self_size |> CArray . of_list int64_t |> CArray . start ) ( List . length self_size ) grad_output weight ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if bias_defined then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let mkldnn_convolution_backward_weights ~ weight_size ~ grad_output self ~ padding ~ stride ~ dilation ~ groups ~ bias_defined = let out__ = CArray . make t 2 in stubs_mkldnn_convolution_backward_weights ( CArray . start out__ ) ( List . map Int64 . of_int weight_size |> CArray . of_list int64_t |> CArray . start ) ( List . length weight_size ) grad_output self ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ( if bias_defined then 1 else 0 ) ; 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 ; t0 , t1

let mkldnn_linear self ~ weight ~ bias = let out__ = CArray . make t 1 in stubs_mkldnn_linear ( CArray . start out__ ) self weight ( match bias with | Some v -> v | None -> null ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let mkldnn_linear_backward_input ~ input_size ~ grad_output ~ weight = let out__ = CArray . make t 1 in stubs_mkldnn_linear_backward_input ( CArray . start out__ ) ( List . map Int64 . of_int input_size |> CArray . of_list int64_t |> CArray . start ) ( List . length input_size ) grad_output weight ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let mkldnn_linear_backward_weights ~ grad_output input ~ weight ~ bias_defined = let out__ = CArray . make t 2 in stubs_mkldnn_linear_backward_weights ( CArray . start out__ ) grad_output input weight ( if bias_defined then 1 else 0 ) ; 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 ; t0 , t1

let mkldnn_max_pool2d self ~ kernel_size ~ stride ~ padding ~ dilation ~ ceil_mode = let out__ = CArray . make t 1 in stubs_mkldnn_max_pool2d ( CArray . start out__ ) self ( List . map Int64 . of_int kernel_size |> CArray . of_list int64_t |> CArray . start ) ( List . length kernel_size ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( if ceil_mode then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let mkldnn_max_pool2d_backward ~ grad_output ~ output input ~ kernel_size ~ stride ~ padding ~ dilation ~ ceil_mode = let out__ = CArray . make t 1 in stubs_mkldnn_max_pool2d_backward ( CArray . start out__ ) grad_output output input ( List . map Int64 . of_int kernel_size |> CArray . of_list int64_t |> CArray . start ) ( List . length kernel_size ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( if ceil_mode then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let mkldnn_max_pool3d self ~ kernel_size ~ stride ~ padding ~ dilation ~ ceil_mode = let out__ = CArray . make t 1 in stubs_mkldnn_max_pool3d ( CArray . start out__ ) self ( List . map Int64 . of_int kernel_size |> CArray . of_list int64_t |> CArray . start ) ( List . length kernel_size ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( if ceil_mode then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let mkldnn_max_pool3d_backward ~ grad_output ~ output input ~ kernel_size ~ stride ~ padding ~ dilation ~ ceil_mode = let out__ = CArray . make t 1 in stubs_mkldnn_max_pool3d_backward ( CArray . start out__ ) grad_output output input ( List . map Int64 . of_int kernel_size |> CArray . of_list int64_t |> CArray . start ) ( List . length kernel_size ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( if ceil_mode then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let mkldnn_reorder_conv2d_weight self ~ padding ~ stride ~ dilation ~ groups = let out__ = CArray . make t 1 in stubs_mkldnn_reorder_conv2d_weight ( CArray . start out__ ) self ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let mkldnn_reorder_conv3d_weight self ~ padding ~ stride ~ dilation ~ groups = let out__ = CArray . make t 1 in stubs_mkldnn_reorder_conv3d_weight ( CArray . start out__ ) self ( List . map Int64 . of_int padding |> CArray . of_list int64_t |> CArray . start ) ( List . length padding ) ( List . map Int64 . of_int stride |> CArray . of_list int64_t |> CArray . start ) ( List . length stride ) ( List . map Int64 . of_int dilation |> CArray . of_list int64_t |> CArray . start ) ( List . length dilation ) ( Int64 . of_int groups ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let mm self ~ mat2 = let out__ = CArray . make t 1 in stubs_mm ( CArray . start out__ ) self mat2 ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

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

let mode self ~ dim ~ keepdim = let out__ = CArray . make t 2 in stubs_mode ( CArray . start out__ ) self ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; 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 ; t0 , t1

let mode_values ~ values ~ indices self ~ dim ~ keepdim = let out__ = CArray . make t 2 in stubs_mode_values ( CArray . start out__ ) values indices self ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; 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 ; t0 , t1

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

let moveaxis_int self ~ source ~ destination = let out__ = CArray . make t 1 in stubs_moveaxis_int ( CArray . start out__ ) self ( Int64 . of_int source ) ( Int64 . of_int destination ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

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

let movedim_int self ~ source ~ destination = let out__ = CArray . make t 1 in stubs_movedim_int ( CArray . start out__ ) self ( Int64 . of_int source ) ( Int64 . of_int destination ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let mse_loss self ~ target ~ reduction = let out__ = CArray . make t 1 in stubs_mse_loss ( CArray . start out__ ) self target ( Reduction . to_int reduction |> Int64 . of_int ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let mse_loss_backward ~ grad_output self ~ target ~ reduction = let out__ = CArray . make t 1 in stubs_mse_loss_backward ( CArray . start out__ ) grad_output self target ( Reduction . to_int reduction |> Int64 . of_int ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let mse_loss_backward_grad_input ~ grad_input ~ grad_output self ~ target ~ reduction = let out__ = CArray . make t 1 in stubs_mse_loss_backward_grad_input ( CArray . start out__ ) grad_input grad_output self target ( Reduction . to_int reduction |> Int64 . of_int ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let mse_loss_out ~ out self ~ target ~ reduction = let out__ = CArray . make t 1 in stubs_mse_loss_out ( CArray . start out__ ) out self target ( Reduction . to_int reduction |> Int64 . of_int ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

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

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

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

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

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

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

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

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

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

let multilabel_margin_loss self ~ target ~ reduction = let out__ = CArray . make t 1 in stubs_multilabel_margin_loss ( CArray . start out__ ) self target ( Reduction . to_int reduction |> Int64 . of_int ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let multilabel_margin_loss_backward ~ grad_output self ~ target ~ reduction ~ is_target = let out__ = CArray . make t 1 in stubs_multilabel_margin_loss_backward ( CArray . start out__ ) grad_output self target ( Reduction . to_int reduction |> Int64 . of_int ) is_target ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let multilabel_margin_loss_backward_grad_input ~ grad_input ~ grad_output self ~ target ~ reduction ~ is_target = let out__ = CArray . make t 1 in stubs_multilabel_margin_loss_backward_grad_input ( CArray . start out__ ) grad_input grad_output self target ( Reduction . to_int reduction |> Int64 . of_int ) is_target ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let multilabel_margin_loss_out ~ out self ~ target ~ reduction = let out__ = CArray . make t 1 in stubs_multilabel_margin_loss_out ( CArray . start out__ ) out self target ( Reduction . to_int reduction |> Int64 . of_int ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let multinomial self ~ num_samples ~ replacement = let out__ = CArray . make t 1 in stubs_multinomial ( CArray . start out__ ) self ( Int64 . of_int num_samples ) ( if replacement then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let multinomial_out ~ out self ~ num_samples ~ replacement = let out__ = CArray . make t 1 in stubs_multinomial_out ( CArray . start out__ ) out self ( Int64 . of_int num_samples ) ( if replacement then 1 else 0 ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

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

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

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

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

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

let mv self ~ vec = let out__ = CArray . make t 1 in stubs_mv ( CArray . start out__ ) self vec ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

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

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

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

let mvlgamma_out ~ out self ~ p = let out__ = CArray . make t 1 in stubs_mvlgamma_out ( CArray . start out__ ) out self ( Int64 . of_int p ) ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nan_to_num self ~ nan ~ posinf ~ neginf = let out__ = CArray . make t 1 in stubs_nan_to_num ( CArray . start out__ ) self nan posinf neginf ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nan_to_num_ self ~ nan ~ posinf ~ neginf = let out__ = CArray . make t 1 in stubs_nan_to_num_ ( CArray . start out__ ) self nan posinf neginf ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nan_to_num_out ~ out self ~ nan ~ posinf ~ neginf = let out__ = CArray . make t 1 in stubs_nan_to_num_out ( CArray . start out__ ) out self nan posinf neginf ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nanmean self ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_nanmean ( 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 nanmean_out ~ out self ~ dim ~ keepdim ~ dtype = let out__ = CArray . make t 1 in stubs_nanmean_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 nanmedian self = let out__ = CArray . make t 1 in stubs_nanmedian ( CArray . start out__ ) self ; let t0 = CArray . get out__ 0 in Gc . finalise C . Tensor . free t0 ; t0

let nanmedian_dim self ~ dim ~ keepdim = let out__ = CArray . make t 2 in stubs_nanmedian_dim ( CArray . start out__ ) self ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; 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 ; t0 , t1

let nanmedian_dim_values ~ values ~ indices self ~ dim ~ keepdim = let out__ = CArray . make t 2 in stubs_nanmedian_dim_values ( CArray . start out__ ) values indices self ( Int64 . of_int dim ) ( if keepdim then 1 else 0 ) ; 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 ; t0 , t1