o h @sUddlZddlmZmZmZmZmZmZddlm Z ddl Z ddl m Z m Z ddl mZddlmZddlmZmZddlmZerWdd lmZeeeeeeefZneZeeeZgZeeed <ed Z e d Z!d ee!e fdee!e ffddZ"ddZ#dede fddZ$dededeedffddZ%de defddZ&de ded e'fd!d"Z(d#e de d$e de fd%d&Z) drd'e d(eedfd e'd)eede f d*d+Z* drd'e d(eedfd e'd)eede f d,d-Z+d#e de d$e de fd.d/Z,d#e de d$e de fd0d1Z-dee efde fd2d3Z.de de fd4d5Z/deee fde fd6d7Z0e" drd8ddd9dee efded ee'd)eed#ee de f d:d;Z1e" drd8ddd9dee efded ee'd)eed#ee de f dde ded)eed#ee de f d?d@Z3e"ddd>de ded)eed#ee de f dAdBZ4e" drd8ddd9dee efded ee'd)eed#ee de f dCdDZ5e" drd8ddd9dee efded ee'd)eed#ee de f dEdFZ6e" drd8ddd9dee efdeed ee'd)eed#ee de f dGdHZ7e" drd8ddd9dee efdeed ee'd)eed#ee de f dIdJZ8e" drd8ddd9dee efded ee'd)eed#ee de f dKdLZ9e" Mdsd8ddd9dee efded e'd)eed#ee de f dNdOZ:e" drd8ddd9de ded e'd)eed#ee de f dPdQZ;ddddRdee efdSee efd)eedTee dUee de f dVdWZdee efded\ee'd]eeee=fd ee'd)eed#ee d^ee'de fd_d`Z?e"  dudd8dddadee efded\ee'dbeeee=fd ee'd)eed#ee de fdcddZ@e"  dudd8dddadee efded\ee'dbeed ee'd)eed#ee de fdedfZAe"ddd>dee efded)eed#ee de f dgdhZBe"ddd>dee efded)eed#ee de f didjZCe"ddd>dee efded)eed#ee de f dkdlZDe"dmdddndee efdYe=dedoe=d)eed#ee de fdpdqZEdS)vN)AnyCallableOptional TYPE_CHECKINGTypeVarUnion) ParamSpec) sym_floatTensor)corresponding_real_dtype)_docs)is_masked_tensor MaskedTensor)as_masked_tensor)_dtype__all___T_PfuncreturncCsHtt|jdd}|durtd|jdn||_t|j|S)zlDecorator that applies docstring templates to function docstring and returns the function instance. _docstringNz&No documentation string available for zb. PyTorch team should run `python tools/update_masked_docs.py` to generate the missing docstrings.)getattrr __name__warningswarn__doc__rappend)r doc_stringre/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/torch/masked/_ops.py_apply_docstring_templates#s  r cstddddddddddd }tdbid d d d d ddddd dd dddddd dddddddddd ddddddd d!}td"d#d$d%d&d'd(d)d*d+ td,d-d.d/d0d1d2}td d3d4d5dddddd6d7dd8 }tdddd d9d:d2}i}||||d;}tgd<gd=g}tgd>gd?g} |jd@vrdA|f} |jtjdB}n|jdCvr|dDf} n|jdkr|f} |jtjdB}n|f} ||j\} } fdEdF| D} fdGdF| D}|j|vrdHgdI}n|j|vrdJgdK}|jtjdB}nJ||g| RdM| i}|j|jdN|j||jdOdPdQ| DdOdRdQ| DdSt | dOt t | dSt |  dTt | dTt |  dTt | dU |j|vrjt |jtjdLtjdBt |jtjdLtjdBt |jtjdLtjdBdV|jdkrjt |jtjdLtjdBtdWdXn|j|vrj||jdYnJjdT| dZjdT|d[fd\d]|D}|fd^dQD|jd_urd`fdadF|D}n|j}||S)czuA utility function called from tools/update_masked_docs.py script to update the module torch.masked._docs.py zI{function_name}(input, {operation_args}, *, {operation_kwargs}) -> TensorzReturns {operation name} of all the elements in the :attr:`input` tensor along the given dimension(s) :attr:`dim` while the :attr:`input` elements are masked out according to the boolean tensor :attr:`mask`.aIf :attr:`keepdim` is ``True``, the output tensor is of the same size as :attr:`input` except in the dimension(s) :attr:`dim` where it is of size 1. Otherwise, :attr:`dim` is squeezed (see :func:`torch.squeeze`), resulting in the output tensor having 1 (or ``len(dim)``) fewer dimension(s). The boolean tensor :attr:`mask` defines the "validity" of :attr:`input` tensor elements: if :attr:`mask` element is True then the corresponding element in :attr:`input` tensor will be included in {operation name} computation, otherwise the element is ignored. When all elements of :attr:`input` along the given dimension :attr:`dim` are ignored (fully masked-out), the corresponding element of the output tensor will have undefined value: it may or may not correspond to the identity value of {operation name} operation; the choice may correspond to the value that leads to the most efficient storage of :attr:`output` tensor. The mask of the output tensor can be computed as ``torch.any(torch.broadcast_to(mask, input.shape), dim, keepdim=keepdim, dtype=torch.bool)``. The shapes of the :attr:`mask` tensor and the :attr:`input` tensor don't need to match, but they must be :ref:`broadcastable ` and the dimensionality of the :attr:`mask` tensor must not be greater than of the :attr:`input` tensor. Args: input (Tensor): the input tensor {args_declarations} Keyword args: {kwargs_declarations}zExample:: >>> input = {example_input} >>> input {indent_example_input} >>> mask = {example_mask} >>> mask {indent_example_mask} >>> {full_function_name}(input, {example_args}, mask=mask) {indent_example_output} zpThe identity value of {operation name} operation, which is used to start the reduction, is ``{identity_int32}``.aThe identity value of {operation name} operation, which is used to start the reduction, depends on input dtype. For instance, for float32, uint8, and int32 dtypes, the identity values are ``{identity_float32}``, ``{identity_uint8}``, and ``{identity_int32}``, respectively.zReturns {operation name} of all the slices in the :attr:`input` tensor along :attr:`dim` while the :attr:`input` elements are masked out according to the boolean tensor :attr:`mask`. {definition}aThe boolean tensor :attr:`mask` defines the "validity" of :attr:`input` tensor elements: if :attr:`mask` element is True then the corresponding element in :attr:`input` tensor will be included in {operation name} computation, otherwise the element is ignored. The values of masked-out elements of the output tensor have undefined value: it may or may not be set to zero or nan; the choice may correspond to the value that leads to the most efficient storage of :attr:`output` tensor. The mask of the {operation name} output tensor can be computed as ``torch.broadcast_to(mask, input.shape)``. The shapes of the :attr:`mask` tensor and the :attr:`input` tensor don't need to match, but they must be :ref:`broadcastable ` and the dimensionality of the :attr:`mask` tensor must not be greater than of the :attr:`input` tensor. Args: input (Tensor): the input tensor {args_declarations} Keyword args: {kwargs_declarations}) reduction_signaturereduction_descrreduction_argsreduction_examplereduction_identityreduction_identity_dtypenormalization_signaturenormalization_descrnormalization_argsnormalization_examplesum)dimz keepdim=False dtype=None mask=Noneprodcumsum) dim__as_int)r/r0cumprodaminamaxargmin)r3r.argmaxmeanmediannorm))ordr-r.var))r-unbiasedr.std logsumexpsoftmax log_softmaxsoftmin normalize)) ord__requiredr4)z eps=1e-12r/r0zdim (int or tuple of ints, optional): the dimension or dimensions to reduce. Default: None that is equivalent to ``tuple(range(input.ndim))``.zBdim (int): the dimension along which {operation name} is computed.zord (int, float, optional): the order of vector norm. Default: 2. See :func:`torch.linalg.vector_norm` for a list of supported norms.z}ord (int, float): the order of vector norm. Default: 2. See :func:`torch.linalg.vector_norm` for a list of supported norms.zjunbiased (bool): when True, use Bessel's correction, otherwise, compute the uncorrected sample variance.zQeps (float, optional): small value to avoid division by zero. Default: {default}.zjkeepdim (bool, optional): whether the output tensor has :attr:`dim` retained or not. Default: {default}.zdtype (:class:`torch.dtype`, optional): the desired data type of returned tensor. If specified, the input tensor is casted to :attr:`dtype` before the operation is performed. Default: {default}.zmask (:class:`torch.Tensor`, optional): the boolean tensor containing the binary mask of validity of input tensor elements. Default: None that is equivalent to ``torch.ones(input.shape, dtype=torch.bool)``.) r-r4r=rFr?epskeepdimdtypemaskzLet ``x`` be a sequence of unmasked elements of one-dimensional slice of the :attr:`input` tensor. Softmax of i-th element in ``x`` is defined as ``exp(x[i])/sum(exp(x))``.zLet ``x`` be a sequence of unmasked elements of one-dimensional slice of the :attr:`input` tensor. LogSoftmax of i-th element in ``x`` is defined as ``log(exp(x[i])/sum(exp(x)))``.zLet ``x`` be a sequence of unmasked elements of one-dimensional slice of the :attr:`input` tensor. Softmin of i-th element in ``x`` is defined as ``exp(-x[i])/sum(exp(-x))``.zLet ``x`` be a sequence of unmasked elements of one-dimensional slice of the :attr:`input` tensor. Normalize of i-th element in ``x`` is defined as ``x[i]/max(norm(x, p), eps)``.zLet ``x`` be a sequence of unmasked elements of one-dimensional slice of the :attr:`input` tensor. Cumsum of i-th element in ``x`` is defined as ``sum(x[:i])``.zLet ``x`` be a sequence of unmasked elements of one-dimensional slice of the :attr:`input` tensor. Cumsum of i-th element in ``x`` is defined as ``prod(x[:i])``.)rBrCrDrEr2r5productmaximumminimumvariancestandard_deviation) r+r1r7r6r9r8r:r;r<r>r@rAcumulative_sumcumulative_prod))rrR)TFT)FFF>r<rE@rIr@r>Fc s4g|]}d||ddddqS) __rRr: TBD.)joingetsplit splitlines.0aargument_declarationsrr 5s  z'_generate_docstring..c sTg|]&}d|ddd|ddddj|ddddqS)rZ=rRrr[r\)default)r]r^r_formatr`rardrrrf;s" reduction) signaturedescridentityargsexample normalization)rkrlrnrorrJ., cs |] }|dddVqdSr[rRrNr_rarrr Uz&_generate_docstring..csrsrtrurarrrrvVrw rZ) function_namefull_function_namezoperation nameoperation_argsoperation_kwargs example_input example_args example_maskindent_example_inputindent_example_maskindent_example_output)identity_uint8identity_int32identity_float32-inf)identity_ord_ninf) definition)args_declarations)kwargs_declarationscs&i|]\}}|r||qSr) startswith format_maprbkv)op_kind template_datarr s  z'_generate_docstring..c3s0|]\}}|t|tr|n|fVqdSN) isinstancestrrr)rrrrvs  Nz csg|] }dd|dqS){_}r)rbsec)rrrrfsr)dictupdatetorchtensorrtofloat32 __module__r]rr_mapr`_reduction_identityuint8int32floatritemsr)rdocstring_templatesargs_and_kwargs definitionsreduction_namesnormalization_namesoperation_names example_dimr}rr~r{r|arg_declarationskwarg_declarations doc_sectionsexample_output templates doc_templater)rerrr_generate_docstring8sZ# l     #                   rop_nameinputcGs"|j}|j}|ddd}|dvrtjd||dS|dvr&tjd||dS|dvrPt|r9tjtj ||dSt|sC|tjkrOtjt |j ||dSn|d vrt|rctjtj ||dSt |rttjtj d ||dSt|s~|tjkrtjt |j ||dSn{|d vrt|rtjtj||dSt|s|tjkrtjt |j ||dSnR|d krd S|dkr|r|dnd}|t dkrt|sJ|jtjtj||dStjd||dS|dkrt|r|jntj }tjtj||dS|dvrd Std|d|d)aFReturn identity value as scalar tensor of a reduction operation on given input, or None, if the identity value cannot be uniquely defined for the given input. The identity value of the operation is defined as the initial value to reduction operation that has a property ``op(op_identity, value) == value`` for any value in the domain of the operation. Or put it another way, including or excluding the identity value in a list of operands will not change the reduction result. See https://github.com/pytorch/rfcs/pull/27 for more information. rqrRrU>r+r2rrIdevice>r1r5>r7r9 logaddexp>rAy>r6r8r:Nr<rVrr;rYz identity of z on z input)rIrrsplitrris_floating_pointinf is_signedriinfomin is_complexmaxrnanNotImplementedError)rrrnrIrr=rrrrsR      rr-ndim.c Csg}|dkrd}|durtt|St|d}t|ttjfr"|fn|}|D]/}||vr4td|d||ks=|| krNtd| d|dd|d | ||q&tt |S) z4Return dim argument as a tuple of sorted dim values.rNrRzdim=z+ appears multiple times in the list of dimsz4Dimension out of range (expected to be in range of [rrz ], but got )) tuplerangerrintrSymInt RuntimeError IndexErrorrsorted)r-rdimsdim_drrr_canonical_dims    rindicesshapecCs>||d}t|D]\}}|||||q |S)NrR) new_zerossize enumeratemul_add_)rr flat_indicesrszrrr_sparse_coo_flatten_indicess  rrHcCs$|}t|D] }|j||d}q|S)Nr-rH)reversedany)rr-rHrrrrr_anys rrJ fill_valuec s|jtjksJ|j|jksJ|j|jksJ||ks"J|}t||jd|}t||jd|}|dkrZt | t t d|dd}n| }|| dddf}ddfdd}d d }|||} || \} } |tdf| } | | } |dkr|| \} }| |}t|| |} |||| }||\} } |tdf| }|d}|dkrt| | |j}|d Stj| |gdd }t| | |f| jddg}t|||j}|S) aSparse variant of torch.where. Supports sparse COO and hybrid sparse COO tensors. _sparse_coo_where implements the following invariant: _sparse_coo_where(mask, input, fill_value).to_dense(fill_value) == torch.where(mask.to_dense(), input.to_dense(), torch.full(input.shape, fill_value)) where `a == b` means `assertEqual(a, b)`, mask is boolean sparse tensor, and `to_dense(fill_value)` is like `to_dense()` except that the unspecified elements are mapped to `fill_value` rather than to `0`. Returns a sparse COO tensor with the following features: - all specified elements correspond to masked-in elements that have the values of the input tensor. If there exists a masked-in element (as specified by mask) that is not specified in the input, in the result tensor, the corresponding element has value 0. In the dense part of the sparse tensor, the masked-out elements are replaced with fill_value. - all unspecified elements correspond to masked-out elements. NrrRFcSs.t||gjdd\}}|t|dfSNT) return_countsrR)rcatuniquewheregti1i2unioncountsrrr intersection,sz'_sparse_coo_where..intersectioncs4t||gjdd\}}|t|d|Sr)rrrreqrrrrminus0sz _sparse_coo_where..minuscSs|\}}||Srr)rcobjwrrr_apply4sz!_sparse_coo_where.._applyTr,)layoutr sparse_coor dense_dimcoalescerr sparse_dimrvaluesrrnonzeroslicerrsparse_coo_tensor _coalesced_rr)rJrrinput_flat_indicesmask_flat_indices mask_valuesmaskin_flat_indicesrrmaskin_input_flat_indicesrrwhere_input_indiceswhere_input_valuesw1where_mask_valuesmaskin_zero_flat_indiceswhere_zero_indicesnresult where_indices where_valuesrrr_sparse_coo_wheresf       r  mask_inputrrIcs|j}gd}||vrtdd|d|d|}||}} |} |} gg} g} |j|kr<||}|rMt fddt |j D}nt fddt |j D}D]}|| krdq]|| krn |q]| |d | q]t | d kr|d kr|}||| t|d }ntS|}t | kr|d vr|d d krt||}n||d d}|rt| D]}|d }q|j|dS| }|rd |ddf<nt d krfddt| D} |d t| |j}|d kr[tj|dd d\}}t|j }|j d |d <t|jd D]}|d}q||j }|tjtj hvrL|tj!}|"|}|j#d |||dd}|j|d}n|"|}|j#d |||dd}tj$|||||jdS)N)r+r1r7r6op must be one of rx , but got  insteadc3s$|] \}}|vr dn|VqdS)rRNrrbisirrrrvs z7_sparse_coo_scatter_reduction_helper..c3s |] \}}|vr|VqdSrrrrrrrvsrRrr+r>r7r6r,rXcsg|] }|tvr|qSr)set)rbr)reduced_sparse_dimsrrrfs  z8_sparse_coo_scatter_reduction_helper..T)return_inverser-rUF)reduce include_selfr)%r ValueErrorr]_values_indicesr-rrIrrrrrlenboolNotImplementedclonerrr unsqueeze to_sparse index_selectrrrnumelrlistrexpandbfloat16float16r new_emptyscatter_reduce_r)opr rrHrIrvalid_reductions output_dtyperr input_dimsnum_sparse_dimsretained_sparse_dimsreduced_dense_dims output_shaper new_valuesr new_indicesinverse_indices out_shapescatter_indicesoutr)rrr$_sparse_coo_scatter_reduction_helperjs                    r9cCs|sJd|j}gd}||vrtdd|d|d|j}|}|||} } } | j|kr<| |} t |dkrD|St |dkr|ddkr}t j | d d \} } | j d}t d|g}| | j }|jd| | |d d d|dg}nw|ddksJd t | dt t | dkdfd}|d}| |} t j| || d}|ddg}n@t |dksJtd| }|dkrd |d}|dvr|d=|| dfi|}nt jd|d}| |} t d|g}d|g}t j|| ||||dS)NzEreduction operations on CSR tensors with keepdim=False is unsupported)r+r1r:r7r6rrxrrrrRT)rF)rzFSparse CSR tensors are 2D and only support reduction along dim 0 or 1.rU)offsetsrVrHrI)r7r6rIrXr)rrr]rr crow_indices col_indicesrIrrrrrrr)r*rrrr2diff_segment_reducerr$emptysparse_csr_tensor)r+r rrHrIrr,rr-rr<r=new_col_indicesr7new_nnznew_crow_indicesr3 new_shapennz op_kwargsrrr$_sparse_csr_segment_reduction_helpers            rHcCst|||S)z;Sparse variant of torch.where. Supports sparse CSR tensors.)r  to_sparse_coo to_sparse_csrrJrrrrr_sparse_csr_where8s rLcCsZ|jtjkr t|||S|jtjkrt|||S|jtjkr%t|||Std|j)atorch.where with sparse inputs support. _where implements the following invariant: _where(mask, input, fill_value).to_dense(fill_value) == torch.where(mask.to_dense(), input.to_dense(), torch.full(input.shape, fill_value)) where `a == b` means `assertEqual(a, b)`, mask is boolean sparse tensor, and `to_dense(fill_value)` is like `to_dense()` except that the unspecified elements are mapped to `fill_value` rather than to `0`. Returns a sparse tensor with the following features: - all specified elements correspond to masked-in elements that have the values of the input tensor. If there exists a masked-in element (as specified by mask) that is not specified in the input, in the result tensor, the corresponding element has value 0. In the dense part of the sparse tensor, the masked-out elements are replaced with fill_value. - all unspecified elements correspond to masked-out elements. zB_where expects strided or sparse COO or sparse CSR tensor but got ) rrstridedrrr  sparse_csrrLrrKrrr_where@s      rOcOs^|jtjtjtjhvrtd|j|d}|dur td|j|jkrf|j|jkr0t d|jtjkrEt | |jj tj d}n!|jtjkrSt||j}n|jtjks[Jt||j}|j|jkr|jtjkrw|}n%|jtjkr|jtjkr||}n|}n |jtjksJ|}|jtjkr|}|j tj d}|S)a{Return canonical input mask. A canonical input mask is defined as a boolean mask tensor that shape and layout matches with the shape and the layout of the input. The canonical input mask is computed from the :attr:`mask` tensor content to meet the following criteria: 1. The shape of the canonical input mask is the same as the shape of :attr:`input` tensor. If the mask tensor has a smaller shape than the shape of the :attr:`input`, broadcasting rules will be applied. Downcasting of mask is not supported. 2. The layout of the canonical input mask is the same as the layout of the :attr:`input` tensor. If the mask has different layout, it will be converted to the expected layout. In the case of sparse COO layout, the canonical input mask will be coalesced. 3. The dtype of the canonical input mask is torch.bool. If the mask dtype is not bool then it will be converted to bool dtype using `.to(dtype=bool)` method call. 4. The elements of the canonical input mask have boolean values copied from the content of the :attr:`mask` tensor (after possible broadcasting and dtype conversion transforms). In general, the sparsity pattern of the sparse canonical input mask need not to be the same as the sparsity pattern of the sparse :attr:`input` tensor. zG_input_mask expects strided or sparse COO or sparse CSR tensor but got rJNz"_input_mask requires explicit maskzZ_input_mask expected broadcastable mask (got mask dimensionality higher than of the input)rX)rrrMrrNrr^rrr broadcast_tor rr_sparse_broadcast_tor"rJto_denserr)rrnkwargsrJrrr _input_maskdsF!              rTc Ost|ra|jdv}|jdv}|rG|jdkr|r|dd}|r#|dn|d}t|g|Ri|}|dd }t||j} t|| t|S|rTt|g|Ri|Std |j d |jd td t |jd)zBReturn output mask of masked operation applied to given arguments.> r@r+r>r7r6r:r<r1r9r8r;rA>r2r5rBrDrErCr<rRNrr-rHFz5_output_mask expected masked operation (got callable rqrz,_output_mask expected masked operation (got  object)) callablerr^rTrrrrrrtype) r+rrnrS is_reductionis_normalizationr-outmaskrHrrrr _output_masks(      r[csLfddGfdddtjj}t|r!|||S||S)NcsV|dur|St||d}tr tj|gR}t|||Stdtjd)NrJz7_combine_input_and_mask expected masked operation (got rU)rTrVrrrOrrW)rrJcanonical_maskr)rnr+rrhelpers  z'_combine_input_and_mask..helpercs(eZdZefddZeddZdS)z(_combine_input_and_mask..Combinecs&|||dur||||S)zJReturn input with masked-out elements eliminated for the given operations.N)save_for_backwardmark_non_differentiable)ctxrrJr^rrforwards   z0_combine_input_and_mask..Combine.forwardcSs.|j\}t|r |n|}t||}|dfSr) saved_tensorsr get_datar)ra grad_outputrJ grad_datar rrrbackwards  z1_combine_input_and_mask..Combine.backwardN)rr __qualname__ staticmethodrcrhrrbrrCombines  rk)rautogradFunctionr applyreget_mask)r+rrJrnrkr)rnr^r+r_combine_input_and_masks rpFrHrIrJcCs|dur>|jtjkr)|jtjtjtjtjtjhvr%| j tj d }n|j}n|j}|jtjtjtjtjtjhvr>tj }t ||j}tt||}|jtjkr[tj||t||dS|jtjkrlttj||t||S|jtjkrtj|t|t||dStd|jd)NrXr-rHrIzAmasked sum expects strided, sparse_coo or sparse_csr tensor (got  tensor))rrrNrIrrint8int16rrIrint64rJrrrpr+rMrr9_sparse_csr_sumr%rrr-rHrIrJrr rrrr+sF        r+c CsN|dur>|jtjkr)|jtjtjtjtjtjhvr%| j tj d }n|j}n|j}|jtjtjtjtjtjhvr>tj }t ||j}tt||}|jtjkrj|}|j |d}t|D] }|j|t|d}q\|S|jtjkr|durxtdttj||t||S|jtjkr|durtdtj|t|t||dStd|jd)NrXrz=masked prod expects explicit mask for sparse_coo tensor inputz=masked prod expects explicit mask for sparse_csr tensor inputrrzBmasked prod expects strided, sparse_coo or sparse_csr tensor (got rs)rrrNrIrrrtrurrIrrvrJrrrpr1rMrrrr9_sparse_csr_prodr%) rr-rHrIrJrr r rrrrr1Fs^           r1)rIrJcC`|dur|j}t||jd}tt||}|jtjkr'tj|||dj |dSt d|jd)NrrXz*masked cumsum expects strided tensor (got rs) rIrrrpr+rrrMr2rrrr-rIrJrr rrrr2   r2cCrz)NrrXz+masked cumprod expects strided tensor (got rs) rIrrrpr1rrrMr5rrr{rrrr5r|r5cC|dur|j}tt||}t||j}|jtjkr&t||t|j |dS|jtj kr?|dur4t dt tj||t||S|jtj krX|durMt dttj||t||St d|jd)k{reduction_signature} {reduction_descr} {reduction_identity_dtype} {reduction_args} {reduction_example}NrX=masked amax expects explicit mask for sparse_coo tensor inputz=masked amax expects explicit mask for sparse_csr tensor inputzBmasked amax expects strided, sparse_coo or sparse_csr tensor (got rs)rIrpr7rrrrrMrrrrr9rNrHrr-rHrIrJr rrrrr72      r7cCr})r~NrXrz=masked amin expects explicit mask for sparse_csr tensor inputzBmasked amin expects strided, sparse_coo or sparse_csr tensor (got rs)rIrpr6rrrrrMrrrrr9rNrHrrrrr6rr6cCR|dur|j}tt||}|jtjkr t||t|j|dStd|jd)g{reduction_signature} {reduction_descr} {reduction_identity_dtype} {reduction_args} {reduction_example}NrXz*masked argmax expects strided tensor (got rs) rIrpr9rrrMrrrrr-rHrIrJr rrrr9   r9cCr)rNrXz*masked argmin expects strided tensor (got rs) rIrpr8rrrMrrrrrrrr89rr8c Csd}|dur |j}d}|js|jstd|d||jtjkr]|durAttj|j tj |j d||d}t||||d}||St ||d }|j|t |d }t|||||d }||S|jtjkrtt||} t|| j} |durwtd ttj| | t ||Std |jd)a{reduction_signature} {reduction_descr} By definition, the identity value of a mean operation is the mean value of the tensor. If all elements of the input tensor along given dimension(s) :attr:`dim` are masked-out, the identity value of the mean is undefined. Due to this ambiguity, the elements of output tensor with strided layout, that correspond to fully masked-out elements, have ``nan`` values. {reduction_args} {reduction_example}rNInputz&mean(): Could not infer output dtype. z> dtype must be either a floating point or complex dtype. Got: rrHr;r\rrqz=masked mean expects explicit mask for sparse_csr tensor inputz6masked mean expects strided or sparse_csr tensor (got rs)rIrrrrrrMr+onesrrvrrTrrNrpr:rrrH) rr-rHrIrJ dtype_sourcecounttotalinmaskr rrrrr:SsH       r:rUc Cs|dur|j}t||jd}t|}|s|jtjd}tt||}|j tj krHt |||j }|r5|S|sDt |sD|j|dStdtd|j d)a{reduction_signature} {reduction_descr} By definition, the identity value of a median operation is the median value of the tensor. If all elements of the input tensor along given dimension(s) :attr:`dim` are masked-out, the identity value of the median is undefined. Due to this ambiguity, the elements of output tensor with strided layout, that correspond to fully masked-out elements, have ``nan`` values. {reduction_args} {reduction_example}NrrXzMmasked median expects no fully masked out rows if dtype is not floating pointz*masked median expects strided tensor (got rs)rIrrrrrrrpr;rrM nanmedianrisnanrr) rr-rHrIrJris_floatr outputrrrr;s&     r;cCs\|dur|j}t||j}tt||}|jtjkr%tj|||dj|dSt d|jd)NrrXz-masked logsumexp expects strided tensor (got rs) rIrrrprArrrMrrrxrrrrAs     rA)rI input_mask other_maskotherrrcCsl|dur|j}|jtjkr)|jtjkr)tt||}tt||}t||j|dStd|jd|jd)alogaddexp(input, other, *, dtype=None, input_mask=None, other_mask=None) -> Tensor Returns logaddexp of all the elements in the :attr:`input` and the :attr:`other` tensor. The :attr:`input` elements are masked out according to the boolean tensor :attr:`input_mask` and the attr:`other` elements are masked out according to the boolean tensor :attr:`other_mask`. The shapes of a mask tensor and the tensor to be masked don't need to match, but they must be :ref:`broadcastable ` and the dimensionality of the mask tensor must not be greater than of the tensor to be masked. Args: input (Tensor): the input tensor other (Tensor): the second input tensor Keyword args: dtype (:class:`torch.dtype`, optional): the desired data type of returned tensor. If specified, the output tensor is casted to :attr:`dtype` after the operation is performed. Default: None. input_mask (:class:`torch.Tensor`, optional): the boolean tensor containing the binary mask of validity of :attr:`input` tensor elements. Default: None that is equivalent to ``torch.ones(input.shape, dtype=torch.bool)``. other_mask (:class:`torch.Tensor`, optional): the boolean tensor containing the binary mask of validity of :attr:`other` tensor elements. Default: None that is equivalent to ``torch.ones(other.shape, dtype=torch.bool)``. Example:: >>> input = torch.tensor([-100.0, -200, -300]) >>> input tensor([-100., -200., -300.]) >>> other = torch.tensor([-1.0, -2, -3]) >>> other tensor([-1., -2., -3.]) >>> mask = torch.tensor([True, False, True]) >>> mask tensor([ True, False, True]) >>> torch.masked._ops.logaddexp(input, other, input_mask=mask, other_mask=mask) tensor([-1., -inf, -3.])NrXz.masked logaddexp expects strided tensors (got z tensor for input, z for other))rIrrrMrprrr)rrrIrrr  mask_otherrrrrs1  rrWr=cCs`|dur|j}tt|||}|jtjkr't||j}tjj |||t ||dSt d|jd)z{reduction_signature} {reduction_descr} The identity value of norm operation, which is used to start the reduction, is ``{identity_float32}``, except for ``ord=-inf`` it is ``{identity_ord_ninf}``. {reduction_args} {reduction_example}NrXz(masked norm expects strided tensor (got rs) rIrpr<rrrMrrlinalg vector_normrr)rr=r-rHrIrJr rrrrr<s   r<r?correction_opt take_sqrtcCs|dus |dus Jdd}|dur|rdnd}|dur t|}|dur0|j}|js0|js0tj}|} | js;| js;tj} |jtjkr|dur^ttj |j tj |j d|dd} t||d|d} nt ||d} | j|dd } t||d|| d } t| | } t|| }|durt||||| d}n t||||| | d }|s| |j } |d kr| jrt| n| }| |} t| |} t| | g} t|| j|d }|rt|}|Std |jd)Nz0Only one of unbiased and correction may be giveng?grTrr;r\rrqrrXz+masked std/var expects strided tensor (got rs)r rIrrrrrrMr+rrrvrrTdividesubtractconjreshaper rrLrsqrtr)rr-r?rrHrIrJr correction compute_dtyper sample_totalr sample_meanxr real_dtyperrrr_std_var5sd              r)rrHrIrJrc Ct|||||||ddS)a{reduction_signature} {reduction_descr} The identity value of sample variance operation is undefined. The elements of output tensor with strided layout, that correspond to fully masked-out elements, have ``nan`` values. {reduction_args} {reduction_example}Frr-r?rrHrIrJrrrr-r?rrHrIrJrrrr>}r>c Cr)a {reduction_signature} {reduction_descr} The identity value of sample standard deviation operation is undefined. The elements of output tensor with strided layout, that correspond to fully masked-out elements, have ``nan`` values. {reduction_args} {reduction_example}Trrrrrrr@rr@cC\|dur|j}t||jd}tt||}|jtjkr%tjj j |||dSt d|jd)NrrXz+masked softmax expects strided tensor (got rs) rIrrrpr7rrrMnn functionalrBrr{rrrrB   rBcCr)NrrXz/masked log_softmax expects strided tensor (got rs) rIrrrpr7rrrMrrrCrr{rrrrCrrCcCr)NrrXz+masked softmin expects strided tensor (got rs) rIrrrpr6rrrMrrrDrr{rrrrDrrDg-q=)rGrIrJrGc Csl|dur|j}tt||}|jtjkr-t|||d||d}t||g|}t ||St d|jd)NTrqz-masked normalize expects strided tensor (got rs) rIrpr+rrrMr<rLnew_fullrr) rr=r-rGrIrJr nrm_denomrrrrEs     rEr)rU)rWN)NN)Frtypingrrrrrrtyping_extensionsrrr r torch._prims_commonr torch.maskedr torch.masked.maskedtensor.corer r"torch.masked.maskedtensor.creationr torch.typesrDTyperrr% DimOrDimsrr__annotations__rrr rrrrrrr r9rHrLrOrTr[rpr+r1r2r5r7r6r9r8r:r;rArrr<rr>r@rBrCrDrErrrrsT        "]=  u  }  V$U.  *  4  L    1  1      ?  *    =  #   H