h,ס      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             !!!!!!!!!!!!!"""""""""""""""""#################$$$$$$$$$$$$$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''(()))))))))))))))))))))))))))))))))***********+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,-------------.........................////////////////0000000000000011111111111111222222222222222222222222222222222222222222222222222222222222222222222222222222222333333333333333333333333333333333333333333333333333333333333333333333333344444444444444444444444444444444444444444444444444444444444444444445555555555555555555556666666666666666666667777777777777777777777777777777777777777777777777777777777777777777777777777777777778888888899999999999999999999999999999999::::::::::::::;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<=====================>>>>>>>>>>>>>>>>???????@@@@@@@@@@@@@@@@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB0.2.1.3NoneF}None FNone1GBool Byte!Char"Short#Int$Long%Half&Float'Double( ComplexHalf) ComplexFloat* ComplexDouble+QInt8,QUInt8-QInt32.BFloat1610/.*)('&%"#$!-+, .-,+*)( '%$#"!&/01NoneGTQOSNRPNOPQRSTNone%&)*01LVA V determines the ordering of samples streamed out of a dataset. You can either order sequentially, or supply a random generator to shuffle samples.YDataset options used when loading datasets. Specify shuffling behavior, the number of threads to use, and the buffer size used to store retrieved samples in each thread.[!The ordering of samples streamed.\%Number of threads retrieving samples.] Bool)xDoes the file have a header?yColumn delimiter.zCSV file path.Produce a CsvDatastream' from the given file with default options, and tab separated columns.Produce a CsvDatastream' from the given file with default options, and comma separated columns.{rstwvyuzxq|~}{|~}stzyxwvurq None %&[%An In-Memory cached dataset. See the . function for how to create a cached dataset.5Run a map function in parallel over the given stream.-Run a pipe in parallel over the given stream.Map a ListT transform over the given the stream in parallel. This should be useful for using functions which groups elements of a stream and yields them downstream.?Enumerate the given stream, zipping each element with an index./Run a given batching function in parallel. See ( for how the given samples are batched.Run a batching function with integer batch size over the given stream. The elements of the stream are split into lists of the given batch size and are collated with the given function. Only Just values are yielded downstream. If the last chunk of samples is less than the given batch size then the batching function will be passed a list of length less than batch size.+Enumerate a given stream and store it as a . This function should be used after a time consuming preprocessing pipeline and used in subsequent epochs to avoid repeating the preprocessing pipeline.CNone[$abhij^_`YZ]\[VWXfgcde   None\< None\ None)*/01]}Alternative version of % with better type inference based on Stronger version of 4 that allows for better inference of the return typeD None^None1>_PType synonym for lensE  None_None%&_None%&1>f9Returns the total number of elements in the input tensor.:Returns the size of a given dimension of the input tensor.Returns the shape of the tensor*Returns the dimensions of the input tensor*Returns the dimensions of the input tensor*Returns the dimensions of the input tensor=Returns the device on which the tensor is currently allocated)Returns the data type of the input tensor-Casts the input tensor to the given data type&Casts the input tensor to given deviceSlices the input tensor along the selected dimension at the given index.Returns a new tensor which indexes the input tensor along dimension dim using the entries in index which is a LongTensor.Slices the input tensor along the selected dimension at the given range.Returns a tensor with the same data and number of elements as input, but with the specified shape.The internal function of withTensor. It does not check contiguous memory-layout.inputnumber of elements in tensor dimensioninputinput5list of integers representing the shape of the tensorinputoutputinputoutputinputoutputinputobject representing the deviceinputdata type of the input tensordata type to cast input toinputoutputdevice to cast input toinputoutputdimension to slice alongindex in the given dimensioninputoutputdim indexTensorinputoutputdim indexListinputoutputdimstartendstepinputFGHNonexReturns a tensor filled with the scalar value 1, with the shape defined by the variable argument size.Returns a tensor filled with the scalar value 1, with the same size as input tensorReturns a tensor filled with the scalar value 0, with the shape defined by the variable argument size.Returns a tensor filled with the scalar value 0, with the same size as input tensorReturns a tensor filled with random numbers from a uniform distribution on the interval [0,1)Returns a tensor filled with random numbers from a standard normal distribution.Returns a tensor filled with random integers generated uniformly between low (inclusive) and high (exclusive).Returns a tensor with the same size as input that is filled with random numbers from standard normal distribution.Returns a tensor with the same size as input that is filled with random numbers from a uniform distribution on the interval [0,1).Returns a one-dimensional tensor of steps equally spaced points between start and end.Returns a 2-D tensor with ones on the diagonal and zeros elsewhere.6Returns a tensor of given size filled with fill_value.Constructs a sparse tensors in COO(rdinate) format with non-zero elements at the given indices with the given values.Returns a 1-D tensor with values from the interval [start, end) taken with common difference step beginning from start.Returns a 1-D tensor with values from the interval [start, end) taken with common difference step beginning from start.$ aten_implshapeoptsoutput=sequence of integers defining the shape of the output tensor.configures the data type, device, layout and other properties of the resulting tensor.outputinputoutput=sequence of integers defining the shape of the output tensor.configures the data type, device, layout and other properties of the resulting tensor.outputinputoutput=sequence of integers defining the shape of the output tensor.configures the data type, device, layout and other properties of the resulting tensor.output=sequence of integers defining the shape of the output tensor.configures the data type, device, layout and other properties of the resulting tensor.output=lowest integer to be drawn from the distribution. Default: 0.one above the highest integer to be drawn from the distribution.the shape of the output tensor.configures the data type, device, layout and other properties of the resulting tensor.outputinputoutputinputconfigures the data type, device, layout and other properties of the resulting tensor.outputinput _fill_valueoptoutput start end stepsconfigures the data type, device, layout and other properties of the resulting tensor.outputdimoptsoutputthe number of rowsthe number of columnsconfigures the data type, device, layout and other properties of the resulting tensor.outputthe shape of the output tensor.)the number to fill the output tensor withconfigures the data type, device, layout and other properties of the resulting tensor.outputThe indices are the coordinates of the non-zero values in the matrixInitial values for the tensor.the shape of the output tensor.outputtoutputtpoutputtoutputt num_samplesoutputt num_samples replacementoutput_meanoutput_mean_stdoutput_mean_stdoutput_mean_stdoutput_mean_std_sizeoutputtoutputtupperoutputtlowerupperoutputtloweruppertrainingoutputtnoiseoutputtnoiseupperoutputtnoiselowerupperoutputtnoiseloweruppertrainingoutputstartendstepconfigures the data type, device, layout and other properties of the resulting tensor.outputstartendstepoutputNone "|uGenerate a slice from a  6https://pytorch.org/cppdocs/notes/tensor_indexing.htmlpython compatible expression. When you take the odd-numbered element of tensor with `tensor[1::2]` in python, you can write `tensor ! [slice|1::2|]` in hasktorch.Generate a lens from a  6https://pytorch.org/cppdocs/notes/tensor_indexing.htmlpython compatible expression. When you take the odd-numbered elements of tensor with `tensor[1::2]` in python, you can write `tensor ^. [lslice|1::2|]` in hasktorch. When you put 2 in the odd numbered elements of the tensor, you can write `tensor & [lslice|1::2|] ~. 2`.None "01:tensorsinputptraininputptraininputptraininputptraininputptrainselfselfselfselfselfselfselfselfselfselfselfselfselfselfself kernel_sizestridepadding ceil_modecount_include_padself output_sizeself output_sizeselfotheralphaselfotheralphaselfmatvecbetaalphaselfvec1vec2betaalphathetasize align_cornersselfdimkeepdimselfdimkeepdimselfotherrtolatol equal_nanselfdimkeepdimselfdimkeepdimselfdimkeepdimselfdimkeepdimselfselfselfselfselfselfselfsizestridestorage_offsetselfselfselfselfselftensorsselftensorsselftensorsselfbatch1batch2betaalpha inputweightbias running_mean running_vartrainingmomentumeps cudnn_enabledinputweightbiasmeanvareps output_scaleoutput_zero_pointinput1input2weightbiasselftargetweight reductionselftargetweight pos_weight reductionselfweights minlengthselfselfotherselfotherselfselfotherselfotherselfotherselfmat2tensorsselfsizetensorsdimtensorsdimtensorsdimtensorsdimtensorsdimtensorsdimtensorsselfmatricesselfchunksdimselfchunksdimselfsectionsdimselftensor_indices_or_sectionsdimselfminmaxselfminmaxselfmaxselfmaxselfminselfminselfminmaxselfminmaxselfrealimagabsangleselfpadvalue inputweightbiasstridepaddingdilation transposedoutput_paddinggroups inputweightbiasstridepaddingdilation transposedoutput_paddinggroups  grad_outputinputweightstridepaddingdilation transposedoutput_paddinggroups  output_maskinputweightbiasstridepaddingdilationgroupsinputweightbiasstridepaddingdilationgroupsinputweightbiasstridepaddingdilationgroupsinputweightbiasstridepaddingdilationgroupsinputweightbiasstridepaddingdilationgroupsinputweightbiasstridepaddingdilationgroupsselfweightbiaspadinputweightbiasstridepaddingoutput_paddinggroupsdilationinputweightbiasstridepaddingoutput_paddinggroupsdilationinputweightbiasstridepaddingoutput_paddinggroupsdilationselfsrc non_blockingselfselfinput1input2targetmargin reductionselfdimself correctionfweightsaweightsselfthetaNCHWinputweightbias running_mean running_vartrainingexponential_average_factorepsilon selfweightpaddingstridedilationgroups benchmark deterministic allow_tf32 selfweightpaddingoutput_paddingstridedilationgroups benchmark deterministic  allow_tf32selfweightbiasstridepaddingdilationgroups selfweightzalphabiasstridepaddingdilationgroupsselfgridselfdimselfdimselfdimselfdimselfdimdtypeselfdimdtypeselfdimdtypeselfdimdtypeyxdimydxdim log_probstargets input_lengthstarget_lengthsblank reduction zero_infinity log_probstargets input_lengthstarget_lengthsblank reduction zero_infinityselfoffsetdim1dim2selfoffsetselfoffsetdim1dim2Aoffsetdim1dim2selfoutdimdim1dim2offsetselfndimprependappendselfspacingdim edge_orderselfdim edge_orderselfotherselfother rounding_modeselfotherselfother rounding_modeselfotherselfotherselfother rounding_modeselfother rounding_modeselfotherselfotherselftensorselfotherequationtensorspathweightindices padding_idxscale_grad_by_freqsparsetensorsweightindicesoffsetsscale_grad_by_freqmodesparseper_sample_weightsinclude_last_offset weightindicesoffsetsscale_grad_by_freqmodesparseper_sample_weightsinclude_last_offset padding_idxselfselfselfselfselfself start_dimend_dimself start_dimend_dimout_dimself start_dimend_dimout_dimselfdimsout_dimselfdimsizesselfdimsizesnamesselfvalueselfvalueselfselfotherselfotherselfselfotherselfotherinputgridinterpolation_mode padding_mode align_cornersinputgridinterpolation_mode padding_mode align_cornersinputgridinterpolation_mode padding_mode align_cornersselftargetmargin reductioninput num_groupsweightbiaseps cudnn_enabledinputweightbiasNCHxWgroupepsselfindicesselfdimindexsourceselfdimindexsourceselfindicesvalues accumulate inputweightbias running_mean running_varuse_input_statsmomentumeps cudnn_enabledselfotherrtolatol equal_nanelements test_elements assume_uniqueinvertelements test_element assume_uniqueinvertelement test_elements assume_uniqueinvertselfselfselfselfselfselfselfselfselfotherselfselfselftarget reduction log_targetselfotherselfkdimkeepdimselfkdimkeepdiminputnormalized_shapeweightbiaseps cudnn_enableinputnormalized_shapeweightbiasepsselfnanposinfneginfinputweightbiasselfweightbias input_size grad_outputweight grad_outputinputweight bias_definedinputweightpacked col_offsets weight_scaleweight_zero_pointbiasinputweightpacked col_offsets weight_scaleweight_zero_pointbiasinputinputinput packed_weightbiasinput packed_weightbiasinputinputKNselfotherselfselfselfselfselfotherselfotherselfotherselfotherselfotherselfdimdtypeselfdimdtypeselfdimselfdimselfdimkeepdimselfdimkeepdiminput1input2targetmargin reductionselfotherselfnselfselfdimkeepdimselfdimkeepdimselfdimkeepdimselfdimkeepdimself kernel_sizestridepaddingdilation ceil_modeself kernel_sizestridepaddingdilation ceil_modeself kernel_sizestridepaddingdilation ceil_modeself kernel_sizestridepaddingdilation ceil_modeself kernel_sizestridepaddingdilation ceil_modeself kernel_sizestridepaddingdilation ceil_modeself kernel_sizestridepaddingdilation ceil_modeself kernel_sizestridepaddingdilation ceil_modeselfdtypeselfdimkeepdimdtypeselfdimkeepdimdtypeselfdimkeepdimdtypeselfselfdimkeepdimselfdimkeepdimselfselfdimkeepdimselfdimkeepdimselfdimkeepdimselfdimkeepdimselfdimkeepdimselfweightbiaspaddingstridedilationgroupsinputweight0weight1weight2weight3hx_cx_reverse batch_sizes mode  hidden_size  num_layers  has_biases  bidirectional batch_firsttraininputweightbias running_mean running_vartrainingexponential_average_factorepsilon selfweightbiaspaddingstridedilationgroups benchmark deterministic selfweightbiaspaddingoutput_paddingstridedilationgroups benchmark  deterministic selfweightbiaspaddingstridedilationgroups benchmark deterministicselfweightbiasstridepaddingdilationgroups selfweightzalphabiasstridepaddingdilationgroupsinputweightweight_stride0hxcxmode hidden_size num_layers batch_first dropout train  bidirectional  batch_sizes  dropout_stateselfmat2selfdimkeepdimselfdimkeepdimselfotherselfotherselfotherselfotherselfvecselfpselfdimstartlengthselfdimstartlengthselfdimstartlengthinputweightbias running_mean running_vartrainingmomentumepsinputepsinputweightbiasmeaninvstdepsinputmeaninvstd running_mean running_varmomentumepscountinputmeaninvstd running_mean running_varmomentumepscountsgrad_outinputmeaninvstdweightinput_gweight_gbias_ggrad_outinputmeaninvstdweightmean_dy mean_dy_xmucountinput running_mean running_varmomentumx1x2pepskeepdimx1x2p compute_modeselfpx1x2dimepsselfdimsselfsource destinationselfsource destinationselfselfupscale_factorselfdownscale_factorselfgroupsselfgroupsselfrcondinputtarget log_inputfulleps reductionselfselfselfselfselfselfrepeats output_sizeselfrepeatsdim output_sizeselfrepeatsdim output_sizeselfshapeselfselfdecimalsselfselfselfweightself approximateselflambdselfselfdimindexselfdimindexselfselfalphaselfselfselfselfepsselfselfselfselfdimselfdimselfdimstartendstepselfsrcdimstartendstepselfsrcdimindexselfsrcoffsetdim1dim2selfsrcsizestridestorage_offsetselfmat2selfdimdtypeselfdimdtypeself split_sizedimself split_sizedimself split_sizesdimself split_sizesdimselfsectionsselfsectionsselfsectionsselfselfdimselfdimselfmat1mat2betaalphatensorsdimtensorstensorstensorsselfn_fft hop_length win_lengthwindow normalizedonesidedreturn_complex selfn_fft hop_length win_lengthwindowcenterpad_mode normalizedonesided return_complex selfn_fft hop_length win_lengthwindowcenter normalizedonesidedlength return_complexselfdimselfdimselfdtypeselfdimkeepdimdtypeselfdimkeepdimdtypeselfdimkeepdimdtypeselfselfselfunbiasedselfdimunbiasedkeepdimselfdim correctionkeepdimselfunbiasedselfdimunbiasedkeepdimselfdim correctionkeepdimselfdimunbiasedkeepdimselfdim correctionkeepdimselfdimunbiasedkeepdimselfdim correctionkeepdimselfdtypeselfdimkeepdimdtypeselfdimkeepdimdtypeselfselfselfselfother dims_self dims_otherself thresholdvalueselfdimsselfdim0dim1selfdim0dim1self num_classesselfdimsselfselfselfshiftsdimsselfkdimsyxdimydxdimyxdimydxdimanchorpositivenegativemarginpepsswap reductionselfselfselfdimsortedreturn_inverse return_countsselfreturn_inverse return_countsdimselfdimreturn_inverse return_countsselfdimxN increasingselfunbiasedselfdimunbiasedkeepdimselfdim correctionkeepdimselfdimunbiasedkeepdimselfdim correctionkeepdimselfunbiasedselfdimunbiasedkeepdimselfdim correctionkeepdimselfdimunbiasedkeepdimselfdim correctionkeepdim conditionselfother conditionselfother conditionselfother conditionselfother conditionvpowdimselfpselfpdimkeepdimdtypeselfpdtypeselfpselfpdimkeepdimdtypeselfpdimkeepdimselfpdimkeepdimdtypeselfpdimkeepdimselfselfdimkeepdimselfkeepdimselfdimkeepdimself memory_formatselfselfotheralphaselfotheralphaselfotheralphaselfotheralphaselfotheralphaselfvaluesselfotheralphaselfmat1mat2betaalphaselfmat1mat2betaalphamat1mat2selfdimselfdimselfpaddingstridedilationgroups input_sizeselfpaddingstridedilationgroupsselfdtype reduce_rangeselfscale zero_pointdtypeselfscale zero_pointdtypetensorsscales zero_pointsdtypeselfscales zero_pointsaxisdtypeselftensorsselfselfselfselfselfselfselfscale zero_point quant_min quant_maxselfscale zero_point quant_min quant_maxselfscale zero_point quant_min quant_maxselfscale zero_pointaxis quant_min quant_maxselfscale zero_pointaxis quant_min quant_max self observer_on fake_quant_on running_min running_maxscale zero_pointaveraging_const quant_min  quant_max ch_axis per_row_fake_quant symmetric_quantinputnumeln_binsratio bit_widthtensorstensorsindexingtensorsselfrwith_replacementtensorothertensorotherscalartensorscalar1scalar2fromtotype1type2 inputhxparams has_biases num_layersdropouttrain bidirectional batch_first data batch_sizeshxparams has_biases num_layersdropouttrain bidirectional inputhxparams has_biases num_layersdropouttrain bidirectional batch_first data batch_sizeshxparams has_biases num_layersdropouttrain bidirectional inputhxparams has_biases num_layersdropouttrain bidirectional batch_first data batch_sizeshxparams has_biases num_layersdropouttrain bidirectional inputhxparams has_biases num_layersdropouttrain bidirectional batch_first data batch_sizeshxparams has_biases num_layersdropouttrain bidirectionalinputhxw_ihw_hhb_ihb_hhinputhxw_ihw_hhb_ihb_hhinputhxw_ihw_hhb_ihb_hhinputhxw_ihw_hhb_ihb_hhinputhxw_ihw_hhb_ihb_hh packed_ih packed_hhcol_offsets_ih col_offsets_hh scale_ih scale_hh  zero_point_ih  zero_point_hhinputhxw_ihw_hhb_ihb_hh packed_ih packed_hhcol_offsets_ih col_offsets_hh scale_ih scale_hh  zero_point_ih  zero_point_hhinputhxw_ihw_hhb_ihb_hh packed_ih packed_hhcol_offsets_ih col_offsets_hh scale_ih scale_hh  zero_point_ih  zero_point_hhinputhxw_ihw_hhb_ihb_hh packed_ih packed_hhcol_offsets_ih col_offsets_hh scale_ih scale_hh  zero_point_ih  zero_point_hhselfselfselfselfmaskvalueselfmaskvalueselfmasksourceselfindexsource accumulateselfdimindexsourcealphaselfdimindexsourcealphaselfdimindexsourcereduce include_selfselfdimindexvalueselfdimindexvalueselfdimindexvalueselfdimindexvalueselfdimindexsrcselfdimindexvalueselfdimindexsrcreduceselfdimindexvaluereduceselfdimindexsrcselfdimindexvalueselfdimindexsrcselfdimindexsrcselfdimindexsrcreduce include_selfselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfbatch1batch2betaalphaselfdiagonalselfotherdimselfdiagonalselfdiagonalselfselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfotherselfindexselfindicesdimselfdimindexselfdimindexselfmaskselfselfselfselfdimindex sparse_gradselfdimindex sparse_gradselftensor1tensor2valueselftensor1tensor2valueselftargetweight reduction ignore_indexlabel_smoothingselfAupper transpose unitriangularselfBupperleft unitriangularxNselfsome compute_uvselfaxis0axis1selfdim0dim1selfupperselfinput2upperselfupperselfsomeselfselfinput2selfinput2input3left transposeselfLU_data LU_pivotsLU_data LU_pivots unpack_data unpack_pivotsselfselfnselfselfselfselfselfselfotherpselfotherselfotherselfendweightselfendweightselfbinsminmaxselfbinsweightdensityselfbinsrangeweightdensityselfbinsrangeweightdensityselfother selfother selfother selfother selfother selfother selfother selfother selfother self selfother self selfother selfother selfother selfother selfother selfqdimkeepdim interpolation selfqdimkeepdim interpolation selfqdimkeepdim interpolation selfqdimkeepdim interpolation selfdim descending selfstabledim descending selfdim descending selfstabledim descending self selfdim descending selfstabledim descending selfdim descending selfkdimlargestsorted self self selfpdimmaxnorm selfother selfexponent selfexponent selfexponent selfexponent selfexponent selfexponent self self boundaries out_int32right self boundaries out_int32right sorted_sequenceself out_int32rightsidesorter sorted_sequenceself out_int32rightsidesorter selftarget reduction selftarget reduction selftargetpmarginweight reduction selftarget reduction selftarget reduction selftargetweight reduction ignore_index selftargetweight reduction ignore_index selftargetweight reduction ignore_index selftargetweight reduction ignore_index selftargetweight reduction ignore_index selftarget reductionbeta selftarget reductiondelta selftarget reduction selfalphascale input_scale selfdim gluxdxdim grad_xgrad_glux dgrad_gludxdim self selfmin_valmax_val self selfnegative_slope self self selfbeta threshold selflambd self output_size self output_size self output_size self output_size self output_size self kernel_sizestridepadding ceil_modecount_include_paddivisor_override self kernel_sizestridepadding ceil_modecount_include_paddivisor_override self kernel_size output_sizerandom_samples self kernel_size output_sizerandom_samples self kernel_sizestridepaddingdilation ceil_mode self kernel_sizestridepaddingdilation ceil_mode selfindices output_size selfindices output_sizestridepadding selfpadding selfpadding selfpadding selfpadding selfpadding selfpadding selfpadmodevalue input output_size align_corners scale_factors input output_size align_corners scale_factors input output_size align_corners scale_factors input output_size align_corners scale_factors input output_size scale_factors input output_size scale_factors input output_size scale_factors self output_size align_cornersscales_hscales_w self output_size align_cornersscales_hscales_w self output_size align_cornersscales_dscales_hscales_w self output_sizescales_hscales_w self output_sizescales_dscales_hscales_w selfweight kernel_sizebiasstridepaddingoutput_paddingdilation selfweight kernel_sizebiasstridepaddingoutput_paddingdilation selfweight kernel_sizebiasstridepadding selfweight kernel_sizebiasstridepaddingdilation selfweight kernel_sizebiasstridepadding selfweight kernel_sizebiasstridepadding selfweight kernel_sizebiasstridepaddingdilation selfweight kernel_sizebiasstridepaddingdilation self output_size kernel_sizedilationpaddingstride tensors self kernel_sizedilationpaddingstride self self self self self self self self self self self self self self self self self selfother selfother selfother selfother selfother selfother selfother selfother selfother self self self self selfeps nself selfdimkeepdim self self selfdecimals self selfdimdtype selfother selfother selfp selfdimdtype selfndimnorm selfndimnorm selfndimnorm selfndimnorm selfndimnorm selfndimnorm selfsdimnorm selfsdimnorm selfsdimnorm selfsdimnorm selfsdimnorm selfsdimnorm selfsdimnorm selfsdimnorm selfsdimnorm selfsdimnorm selfsdimnorm selfsdimnorm selfdim selfdim selfupper check_errors selfupper selfotherdim Apivot Apivot check_errors Apivot LUpivotsBleftadjoint A self self hermitian check_errors self hermitian LDpivotsB hermitian abrconddriver ba selfother xydim self A self self self self selfUPLO selfUPLO inputtau A check_errors A self selfother selfvec2 selfvec2 selforddimkeepdimdtype selforddimkeepdimdtype selforddimkeepdimdtype A full_matricesdriver Adriver selfp selfatolrtol hermitian selfatolrtol hermitian selfrcond hermitian selfrcond hermitian ABleft check_errors ABleft selfind selfotherdims Amode selfn inputatolrtol hermitian selfatolrtol hermitian selftol hermitian inputtol hermitian tensors selfpadding output_size datareducelengthsindicesoffsetsaxisunsafeinitial  sequences batch_first padding_value tensors flattensors self self selfsizestridestorage_offset selfoffsetdim1dim2 selfsizeimplicit selfdims selfdimindex self selfdimstartendstep self split_sizedim self split_sizesdim self selfdim self selfdim0dim1 selfdim self self self self self self selfdim selfsize selfdtype self dimensionsizestep self querykeyvalue attn_mask dropout_p is_causal x self self self self xn xn xn xn xn xn xn xn xn xn xn xn xn xn xn xn xn xn xn xn xn xn xn xn self self self self x x xn xn xn xn xn xn xn xn xn xn xn xn x selfindicesmax_norm norm_type selfsize memory_format self the_template memory_format self the_template self selfsize sparse_dim dense_dim selfsize sparse_dim dense_dim selfsrc non_blocking selfsource self                                                                                    None۵ ;Returns the mean value of all elements in the input tensor. Returns the standard deviation of all elements in the input tensor. 9Returns the variance of all elements in the input tensor. 4Returns the sum of all elements in the input tensor. Computes the element-wise absolute value of the given input tensor. Computes the fractional portion of each element in input. out_i = input_i - (floor . abs) input_i * (sign input_i) Returns the indices of the maximum value of all elements in the input tensor. Each element of the tensor other added to each element of the tensor input. The resulting tensor is returned. Multiplies each element of the tensor other to each element of the input tensor and returns a new resulting tensor. Element wise subtraction of other tensor from input tensor and returns a new resulting tensor Element wise division of input tensor by other tensor and returns a new resulting tensor ceil floor min max median Adds each element of the input input with the scalar and returns a new resulting tensor. Subtracts each element of the input input with the scalar and returns a new resulting tensor. Multiplies each element of the input input with the scalar and returns a new resulting tensor. Divides each element of the input input with the scalar and returns a new resulting tensor. Matrix product of two tensors.The behavior depends on the dimensionality of the tensors as follows: If both tensors are 1-dimensional, the dot product (scalar) is returned. If both arguments are 2-dimensional, the matrix-matrix product is returned. If the first argument is 1-dimensional and the second argument is 2-dimensional, a 1 is prepended to its dimension for the purpose of the matrix multiply. After the matrix multiply, the prepended dimension is removed. If the first argument is 2-dimensional and the second argument is 1-dimensional, the matrix-vector product is returned. If both arguments are at least 1-dimensional and at least one argument is N-dimensional (where N > 2), then a batched matrix multiply is returned. If the first argument is 1-dimensional, a 1 is prepended to its dimension for the purpose of the batched matrix multiply and removed after. If the second argument is 1-dimensional, a 1 is appended to its dimension for the purpose of the batched matrix multiple and removed after. The non-matrix (i.e. batch) dimensions are broadcasted (and thus must be broadcastable). For example, if input is a (j times 1 times n times m)(j1nm) tensor and other is a (k times m times p)(kmp) tensor, out will be an (j times k times n times p)(jknp) tensor. A simple lookup table that looks up embeddings in a fixed dictionary and size. This module is often used to retrieve word embeddings using indices. The input to the module is a list of indices, and the embedding matrix, and the output is the corresponding word embeddings. A one hot encoding of the given input. The encoding is based on the given number of classes. +Computes the error function of each element Computes the complementary error function of each element of input Computes the inverse error function of each element of input. The inverse error function is defined in the range (-1, 1)(D1,1) as: erfinv(erf(x)) = x 6Computes the logarithm of the gamma function on input. Computes the logarithmic derivative of the gamma function on input. Computes the nth derivative of the digamma function on input. n geq 0nD0 is called the order of the polygamma function. Computes the multivariate log-gamma function with dimension pp element-wise. All elements must be greater than (p-1)/2, otherwise an error would be thrown. Returns a new tensor with the exponential of the elements of the input tensor input. ?Returns a new tensor with the natural logarithm of (1 + input). Returns a new tensor with the logarithm to the base 2 of the elements of input. Returns a new tensor with the natural logarithm of the elements of input. Returns a new tensor with the logarithm to the base 10 of the elements of input. Takes the power of each element in input with exponent and returns a tensor with the result. Takes the power of each element in input with exponent and returns a tensor with the result. Exponent is a tensor with the same number of elements as input. 8Applies the rectified linear unit function element-wise. Applies Exponential linear unit function element-wise, with alpha input, ;\text{ELU}(x) = \max(0,x) + \min(0, \alpha * (\exp(x) - 1)) Applies exponential linear unit function element wise with default alpha value = 1 Applies element-wise, \text{SELU}(x) = scale * (\max(0,x) + \min(0, \alpha * (\exp(x) - 1)) , with =1.6732632423543772848170429916717 and scale=1.0507009873554804934193349852946. Applies element-wise, \text{CELU}(x) = \max(0,x) + \min(0, \alpha * (\exp(x/\alpha) - 1)). *Applies the element-wise function sigmoid. Applies a softmax function. It is applied to all slices along dim, and will re-scale them so that the elements lie in the range [0, 1] and sum to 1. Applies a softmax followed by a logarithm. While mathematically equivalent to log(softmax(x)), doing these two operations separately is slower, and numerically unstable. This function uses an alternative formulation to compute the output and gradient correctly. ,Thresholds each element of the input Tensor.  other element-wise. The second argument can be a number or a tensor whose shape is broadcastable with the first argument. Computes input < other element-wise. The second argument can be a number or a tensor whose shape is broadcastable with the first argument. Computes input >= other element-wise. The second argument can be a number or a tensor whose shape is broadcastable with the first argument. Computes input <= other element-wise. The second argument can be a number or a tensor whose shape is broadcastable with the first argument. Computes input == other element-wise. The second argument can be a number or a tensor whose shape is broadcastable with the first argument. Returns a new tensor with the elements of input at the given indices. The input tensor is treated as if it were viewed as a 1-D tensor. The result takes the same shape as the indices. Returns a new 1-D tensor which indexes the input tensor according to the boolean mask mask which is a BoolTensor. The shapes of the mask tensor and the input tensor don@t need to match, but they must be broadcastable. Returns a tuple of 1-D tensors, one for each dimension in input, each containing the indices (in that dimension) of all non-zero elements of input . Computes input /= other element-wise. The second argument can be a number or a tensor whose shape is broadcastable with the first argument. Casting to given Dtype, where Dtype is an object that represents the data type of a tensor in hasktorch.  squeezeAll  squeezeDim Returns a tuple (values, indices) where values is the cumulative maximum of elements of input in the dimension dim. And indices is the index location of each maximum value found in the dimension dim. Returns a tuple (values, indices) where values is the cumulative minimum of elements of input in the dimension dim. And indices is the index location of each maximum value found in the dimension dim. Returns the cumulative product of elements of input in the dimension dim. For example, if input is a vector of size N, the result will also be a vector of size N, with elements. Returns the cumulative sum of elements of input in the dimension dim. For example, if input is a vector of size N, the result will also be a vector of size N, with elements. Function that measures the Binary Cross Entropy between the target and the output. Binary Cross Entropy with weights defaulted to 1.0 & reduction defaulted to ReduceMean This loss combines a Sigmoid layer and the BCELoss in one single class. This version is more numerically stable than using a plain Sigmoid followed by a BCELoss as, by combining the operations into one layer, we take advantage of the log-sum-exp trick for numerical stability. Creates a criterion that measures the mean squared error (squared L2 norm) between each element in the input and target. !The negative log likelihood loss. Returns cosine similarity between x1 and x2, computed along dim. 1Returns cosine similarity with defaulted options. The Connectionist Temporal Classification loss. Calculates loss between a continuous (unsegmented) time series and a target sequence. CTCLoss sums over the probability of possible alignments of input to target, producing a loss value which is differentiable with respect to each input node. The alignment of input to target is assumed to be @many-to-one@, which limits the length of the target sequence such that it must be leqD the input length. (Returns CTC loss with defaulted options. Returns the p-norm of (input - other) The shapes of input and other must be broadcastable. Measures the loss given an input tensor xx and a labels tensor yy (containing 1 or -1). This is usually used for measuring whether two inputs are similar or dissimilar, e.g. using the L1 pairwise distance as xx, and is typically used for learning nonlinear embeddings or semi-supervised learning. #The 2D negative log likelihood loss Creates a criterion that optimizes a multi-class classification hinge loss (margin-based loss) between input x% (a 2D mini-batch Tensor) and output y/ (which is a 1D tensor of target class indices) Creates a criterion that optimizes a multi-label one-versus-all loss based on max-entropy, between input x and target y of size (N,C) . The Kullback-Leibler divergence Loss KL divergence is a useful distance measure for continuous distributions and is often useful when performing direct regression over the space of (discretely sampled) continuous output distributions. As with NLLLoss, the input given is expected to contain log-probabilities and is not restricted to a 2D Tensor. The targets are interpreted as probabilities by default, but could be considered as log-probabilities with log_target set to True. This criterion expects a target Tensor of the same size as the input Tensor. Creates a criterion that uses a squared term if the absolute element-wise error falls below 1 and an L1 term otherwise. It is less sensitive to outliers than the MSELoss and in some cases prevents exploding gradients (e.g. see Fast R-CNN paper by Ross Girshick). Also known as the Huber loss. Creates a criterion that optimizes a two-class classification logistic loss between input tensor x and target tensor y (containing 1 or -1). Applies a 1D adaptive max pooling over an input signal composed of several input planes. Applies a 2D adaptive max pooling over an input signal composed of several input planes. Applies a 3D adaptive max pooling over an input signal composed of several input planes maxPool1dWithIndices Applies a 1D max pooling over an input signal composed of several input planes. Applies a 2D max pooling over an input signal composed of several input planes. Applies a 3D max pooling over an input signal composed of several input planes. Calculates resulting dimensions from a 2d maxpool operation see https://pytorch.org/docs/master/generated/torch.nn.MaxPool2d.html#torch.nn.MaxPool2d Applies a 1D average pooling over an input signal composed of several input planes. Applies a 1D adaptive average pooling over an input signal composed of several input planes. Applies a 2D adaptive average pooling over an input signal composed of several input planes. Applies a 3D adaptive average pooling over an input signal composed of several input planes. .Takes the inverse of the square matrix input. input can be batches of 2D square tensors, in which case this function would return a tensor composed of individual inverses. Solves a system of equations with a triangular coefficient matrix AA and multiple right-hand sides bb This function returns eigenvalues and eigenvectors of a real symmetric matrix input or a batch of real symmetric matrices, represented by a namedtuple (eigenvalues, eigenvectors). Computes the eigenvalues and eigenvectors of a real square matrix This function returns a namedtuple (U, S, V) which is the singular value decomposition of a input real matrix or batches of real matrices input such that input = U * diag(S) * V^T Computes the Cholesky decomposition of a symmetric positive-definite matrix AA or for batches of symmetric positive-definite matrices. Solves a linear system of equations with a positive semidefinite matrix to be inverted given its Cholesky factor matrix uu . This function returns the solution to the system of linear equations represented by AX = BAX=B and the LU factorization of A, in order as a namedtuple solution. Solves a linear system of equations with a positive semidefinite matrix to be inverted given its Cholesky factor matrix uu . This is a low-level function for calling LAPACK directly. This function returns a namedtuple (a, tau) as defined in LAPACK documentation for geqrf. Computes the orthogonal matrix Q of a QR factorization, from the (input, input2) tuple returned by  ? function. This directly calls the underlying LAPACK function ?orgqr. See LAPACK documentation for orgqr for further details. Multiplies mat (given by input3) by the orthogonal Q matrix of the QR factorization formed by torch.geqrf() that is represented by (a, tau) (given by (input, input2)). This directly calls the underlying LAPACK function ?ormqr. See LAPACK documentation for ormqr for further details. Returns the LU solve of the linear system Ax = bAx=b using the partially pivoted LU factorization of A from torch.lu(). During training, randomly zeroes some of the elements of the input tensor with probability p using samples from a Bernoulli distribution. #Applies alpha dropout to the input. Computes the bitwise NOT of the given input tensor. The input tensor must be of integral or Boolean types. For bool tensors, it computes the logical NOT. Computes the element-wise logical NOT of the given input tensor. If not specified, the output tensor will have the bool dtype. If the input tensor is not a bool tensor, zeros are treated as False and non-zeros are treated as True. Concatenates the given sequence of seq tensors in the given dimension. All tensors must either have the same shape (except in the concatenating dimension) or be empty. Puts values from the tensor value into the input tensor (out-of-place) using the indices specified in indices (which is a tuple of Tensors). The expression tensor.index_put_(indices, value) is equivalent to tensor[indices] = value. If accumulate is True, the elements in value are added to self. If accumulate is False, the behavior is undefined if indices contain duplicate elements. Splits a tensor into a specific number of chunks. Last chunk will be smaller if the tensor size along the given dimension dim is not divisible by chunks. Clamp all elements in input into the range [ min, max ] and return a resulting tensor. 8Clamps all elements in input to be smaller or equal max. 7Clamps all elements in input to be larger or equal min. 7Pads the input tensor boundaries with a constant value. Applies a 1D convolution over an input signal composed of several input planes. Applies a 2D convolution over an input signal composed of several input planes. Applies a 3D convolution over an input signal composed of several input planes. Applies a 1D transposed convolution over an input signal composed of several input planes Applies a 2D transposed convolution over an input signal composed of several input planes Applies a 3D transposed convolution over an input signal composed of several input planes 7Returns a new tensor with the signs of the elements of input 1Returns a tensor that is a transposed version of input. The given dimensions dim0 and dim1 are swapped. &transpose special case for a 2D tensor Returns a tensor with the elements of input as the diagonal. The second argument controls which diagonal to consider: If Int = 0, it is the main diagonal. If Int > 0, it is above the main diagonal. If Int < 0, it is below the main diagonal. If input is a vector (1-D tensor), then returns a 2-D square tensor with the elements of input as the diagonal. If input is a tensor with more than one dimension, then returns a 2-D tensor with diagonal elements equal to a flattened input. The argument offset controls which diagonal to consider: If offset = 0, it is the main diagonal. If offset > 0, it is above the main diagonal. If offset < 0, it is below the main diagonal. Returns a partial view of input with the its diagonal elements with respect to dim1 and dim2 appended as a dimension at the end of the shape. Applying diagEmbed to the output of this function with the same arguments yields a diagonal matrix with the diagonal entries of the input. However, diagEmbed has different default dimensions, so those need to be explicitly specified. Returns True if all elements in the tensor are True, False otherwise. Returns True if any elements in the tensor are True, False otherwise. Returns True if all elements in each row of the tensor in the given dimension dim are True, False otherwise. If keepdim is True, the output tensor is of the same size as input except in the dimension dim where it is of size 1. Otherwise, dim is squeezed, resulting in the output tensor having 1 fewer dimension than input. Returns True if any elements in each row of the tensor in the given dimension dim are True, False otherwise. If keepdim is True, the output tensor is of the same size as input except in the dimension dim where it is of size 1. Otherwise, dim is squeezed, resulting in the output tensor having 1 fewer dimension than input. &Permute the dimensions of this tensor. "expand TODO: figure out what the implicit boolean value does flatten  flattenAll %A long short-term memory (LSTM) cell. !A gated recurrent unit (GRU) cell )An Elman RNN cell with tanh non-linearity )An Elman RNN cell with ReLU non-linearity /A quantized long short-term memory (LSTM) cell. 1A quantized long gated recurrent unit (GRU) cell. 2A quantized Elman RNN cell with relu non-linearity 2A quantized Elman RNN cell with tanh non-linearity /Applies the soft shrinkage function elementwise Concatenates sequence of tensors along a new dimension. All tensors need to be of the same size. Returns the sum of each row of the input tensor in the given dimension dim. If keepdim is True, the output tensor is of the same size as input except in the dimension(s) dim where it is of size 1. Otherwise, dim is squeezed, resulting in the output tensor having 1 (or len(dim)) fewer dimension(s). Returns the k largest elements of the given input tensor along a given dimension. If largest is False then the k smallest elements are returned. The boolean option sorted if True, will make sure that the returned k elements are themselves sorted A tuple of (values, indices) is returned, where the indices are the indices of the elements in the original input tensor. Returns the log of summed exponentials of each row of the input tensor in the given dimension dim. The computation is numerically stabilized. Returns the upper triangular part of a matrix (2-D tensor) or batch of matrices input, the other elements of the result tensor out are set to 0. The upper triangular part of the matrix is defined as the elements on and above the diagonal. The argument diagonal controls which diagonal to consider. If diagonal = 0, all elements on and above the main diagonal are retained. A positive value excludes just as many diagonals above the main diagonal, and similarly a negative value includes just as many diagonals below the main diagonal. The main diagonal are the set of indices (i,i) for i \in [0,\min(d_1,d_2)-1] where d_1 and d_2 " are the dimensions of the matrix. Returns the lower triangular part of the matrix (2-D tensor) or batch of matrices input, the other elements of the result tensor out are set to 0. The lower triangular part of the matrix is defined as the elements on and below the diagonal. The argument diagonal controls which diagonal to consider. If diagonal = 0, all elements on and below the main diagonal are retained. A positive value includes just as many diagonals above the main diagonal, and similarly a negative value excludes just as many diagonals below the main diagonal. The main diagonals are the set of indices (i,i) for i \in [0,\min(d_1,d_2)-1] where d_1 and d_2 " are the dimensions of the matrix. Returns a new tensor with the truncated integer values of the elements of input. Returns the unique elements of the input tensor along a dimension. Eliminates all but the first element from every consecutive group of equivalent elements. This function is different from uniqueDim in the sense that this function only eliminates consecutive duplicate values. Eliminates all but the first element from every consecutive group of equivalent elements along a dimension. This function is different from uniqueDim in the sense that this function only eliminates consecutive duplicate values. Returns a new tensor with a dimension of size one inserted at the specified position. The returned tensor shares the same underlying data with this tensor. A dim value within the range [(dim input) - 1, (dim input) + 1)] can be used. Negative dim will correspond to unsqueeze applied at dim = dim + (dim input) + 1 Upsamples the input, using bilinear upsampling. Expected inputs are spatial (4 dimensional). Applies a 2D nearest neighbor upsampling to an input signal composed of several input channels. 8Splits the tensor into chunks of given size if possible. Creates a criterion that measures the mean absolute error (MAE) between each element in the input x and target y . $Applies the element-wise function: \text{LeakyReLU}(x) = \max(0,x) + \text{negative_slope} D \min(0,x) $Applies the element-wise function: 6\text{LogSigmoid}(x) = \log(\frac{ 1 }{ 1 + \exp(-x)}) Returns a namedtuple (values, indices) where values is the maximum value of each row of the input tensor in the given dimension dim. And indices is the index location of each maximum value found (argmax). If keepdim is True, the output tensors are of the same size as input except in the dimension dim where they are of size 1. Otherwise, dim is squeezed , resulting in the output tensors having 1 fewer dimension than input. Returns a namedtuple (values, indices) where values is the minimum value of each row of the input tensor in the given dimension dim. And indices is the index location of each minimum value found (argmin). If keepdim is True, the output tensors are of the same size as input except in the dimension dim where they are of size 1. Otherwise, dim is squeezed, resulting in the output tensors having 1 fewer dimension than input. Returns the mean value of each row of the input tensor in the given dimension dim. If dim is a list of dimensions, reduce over all of them. If keepdim is True, the output tensor is of the same size as input except in the dimension(s) dim where it is of size 1. Otherwise, dim is squeezed (see torch.squeeze()), resulting in the output tensor having 1 (or len(dim)) fewer dimension(s). Returns a namedtuple (values, indices) where values is the median value of each row of the input tensor in the given dimension dim. And indices is the index location of each median value found. By default, dim is the last dimension of the input tensor. If keepdim is True, the output tensors are of the same size as input except in the dimension dim where they are of size 1. Otherwise, dim is squeezed (see torch.squeeze()), resulting in the outputs tensor having 1 fewer dimension than input. Returns the matrix product of the NN 2-D tensors. This product is efficiently computed using the matrix chain order algorithm which selects the order in which incurs the lowest cost in terms of arithmetic operations. Note that since this is a function to compute the product, NN needs to be greater than or equal to 2; if equal to 2 then a trivial matrix-matrix product is returned. If NN is 1, then this is a no-op - the original matrix is returned as is. "Applies element-wise the function \text{GELU}(x) = x * \Phi(x) where \Phi(x) is the Cumulative Distribution Function for Gaussian Distribution. "The gated linear unit. Computes: &\text{GLU}(a, b) = a \otimes \sigma(b): where input is split in half along dim to form a and b, \sigma is the sigmoid function and \otimes. is the element-wise product between matrices. Returns the standard-deviation and mean of all elements in the input tensor. If unbiased is False, then the standard-deviation will be calculated via the biased estimator. Otherwise, Bessel@s correction will be used. Returns the standard-deviation and mean of each row of the input tensor in the dimension dim. If dim is a list of dimensions, reduce over all of them. If keepdim is True, the output tensor is of the same size as input except in the dimension(s) dim where it is of size 1. Otherwise, dim is squeezed, resulting in the output tensor having 1 (or len(dim)) fewer dimension(s). If unbiased is False, then the standard-deviation will be calculated via the biased estimator. Otherwise, Bessel@s correction will be used. Returns a copy of input. Output tensor keeps a computational graph and a requires_grad value of input tensor. https://discuss.pytorch.org/t/clone-and-detach-in-v0-4-0/16861/41 Returns a copy of input. Output tensor does not keep a computational graph and a requires_grad value of input tensor. Returns a new tensor with the same data as the input tensor but of a different shape. 3Repeats this tensor along the specified dimensions. inputoutput inputoutput inputoutput inputoutput inputoutput inputoutput the dimension to reduce1whether the output tensor has dim retained or notinputoutput inputotheroutput inputotheroutput inputotheroutput inputother inputoutput inputoutput inputoutput inputoutput inputoutput summandinputoutput  subtrahendinputoutput  multiplierinputoutput divisorinputoutput &first tensor for matrix multiplication'second tensor for matrix multiplicationoutput 7whether or not to scale the gradient by the frequencies&whether or not the embedding is sparseweightspaddingindicesoutput weightsindicesoutput number of classesinput inputoutput inputoutput inputoutput inputoutput inputoutput ninputoutput pinputoutput inputoutput inputoutput inputoutput inputoutput exponentinputoutput inputexponentoutput inputoutput alpha value for ELU formulationinputoutput inputoutput inputoutput alphainputoutput inputoutput  dimensioninputoutput  dimensioninputoutput  thresholdvalueinputoutput inputoutput inputoutput inputoutput inputoutput inputoutput inputoutput inputoutput inputoutputother inputotheroutput inputotheroutput inputotheroutput inputotheroutput indexinputoutput maskinputoutput inputoutput rtolatol equal_nanselfother self self selfother input/True if the data type of input is a signed type inputotheroutput data type to cast toinputoutput inputoutput diminputoutput diminputoutput (values, indices) diminputoutput (values, indices) dimdtypeinputoutput dimdtypeinputoutput .Specifies the reduction to apply to the outputtargetweightinputoutput targetinputoutput .Specifies the reduction to apply to the outputtargetweight pos_weightinputoutput  target tensorinputoutput  target tensorinputoutput  dimension of vectors (default=1)1small value to avoid division by 0 (default=1e-8)x1x2output x1x2output zero_infinity - Whether to zero infinite losses and the associated gradients (False by default). Infinite losses mainly occur when the inputs are too short to be aligned to the targets. blank label reduction input_lengthstarget_lengths log_probstargetsoutput  reduction input lengthstarget lengths log probstargetsoutput potherinputoutput margin reductiontargetselfoutput input1input2targetmargin reductionoutput  reductionpmargininputtargetweightoutput selftargetoutput  reductionselftargetoutput  reductioninputtargetoutput  output sizeinputoutput  output sizeinputoutput  output sizeinput  kernel sizestridepaddingdilation ceil modeinputoutput, indices  kernel sizestridepaddingdilation ceil modeinputoutput  kernel sizestridepaddingdilation ceil modeinputoutput  kernel sizestridepaddingdilation ceil modeinputoutput  kernel sizestridepaddingdilationCeiling or Floorimage dimensionsheight, width after maxPool  kernel sizestridepadding ceil modecount include padinputoutput  kernel sizestridepaddinginputoutput inputoutput output size (Height * Width)inputoutput $output size (Depth * Height * Width)inputoutput inputoutput Aupper transpose unitriangularinputoutput