§
    ’©ºjâ   ã                   ó”  — d dl mZmZ d dlZd dlmZ d dlmZ d dlmZ dededefd	„Z	dededefd
„Z
	 d)dededeeed         f         defd„Z	 d*dedee         dedededededefd„Zdededeeef         fd„Zd+dededededef
d„Zd,deded edefd!„Zd,deded edefd"„Zded#ededefd$„Zd%ed&eed'                  defd(„ZdS )-é    )ÚOptionalÚUnionN)ÚTensor)ÚLiteral)Úrank_zero_warnÚxÚyÚreturnc                 óê   — | j         t          j        k    s|j         t          j        k    r@|                      ¦   «         |j                             ¦   «         z                       ¦   «         S | |j        z  S )zSafe calculation of matrix multiplication.

    If input is float16, will cast to float32 for computation and back again.

    )ÚdtypeÚtorchÚfloat16ÚfloatÚTÚhalf©r   r	   s     ún/root/private/project/pallet_detection_v2/.venv/lib/python3.11/site-packages/torchmetrics/utilities/compute.pyÚ_safe_matmulr      sU   € ð 	„w•%”-ÒÐ 1¤7­e¬mÒ#;Ð#;Ø—’‘	”	˜AœCŸIšI™KœKÑ'×-Ò-Ñ/Ô/Ð/ØˆqŒs‰7€Nó    c                 óF   — | t          j        |¦  «        z  }d|| dk    <   |S )z¦Compute x * log(y). Returns 0 if x=0.

    Example:
        >>> import torch
        >>> x = torch.zeros(1)
        >>> _safe_xlogy(x, 1/x)
        tensor([0.])

    ç        r   )r   Úlog)r   r	   Úress      r   Ú_safe_xlogyr   "   s(   € ð �eŒi˜‰lŒlÑ
€CØ€CˆˆQŠ�KØ€Jr   r   ÚnumÚdenomÚzero_division)ÚwarnÚnanc                 óF  — |                       ¦   «         r| n|                      ¦   «         } |                      ¦   «         r|n|                     ¦   «         }t          |t          t          f¦  «        s|dk    r—|dk    r't	          j        |dk    ¦  «        rt          d¦  «         |dk    rdn|}t	          j        || j        ¬¦  «         	                    | j
        | j
        j        dk    ¬¦  «        }t	          j        |dk    | |z  |¦  «        S t	          j        | |¦  «        S )a  Safe division, by preventing division by zero.

    Function will cast to float if input is not already to secure backwards compatibility.

    Args:
        num: numerator tensor
        denom: denominator tensor, which may contain zeros
        zero_division: value to replace elements divided by zero

    Example:
        >>> import torch
        >>> num = torch.tensor([1.0, 2.0, 3.0])
        >>> denom = torch.tensor([0.0, 1.0, 2.0])
        >>> _safe_divide(num, denom)
        tensor([0.0000, 2.0000, 1.5000])

    r   r   z:Detected zero division in _safe_divide. Setting 0/0 to 0.0r   )r   Úmps)Únon_blocking)Úis_floating_pointr   Ú
isinstanceÚintr   Úanyr   Útensorr   ÚtoÚdeviceÚtypeÚwhereÚtrue_divide)r   r   r   Úzero_division_tensors       r   Ú_safe_divider.   1   s  € ð, ×&Ò&Ñ(Ô(Ð
9ˆ#ˆ#¨c¯iªi©k¬k€CØ×,Ò,Ñ.Ô.ÐAˆEˆE°E·K²K±M´M€EÝ�-¥%­ Ñ.Ô.ð J°-À6Ò2IÐ2IØ˜FÒ"Ð"¥u¤y°¸!²Ñ'<Ô'<Ð"ÝÐWÑXÔXÐXØ,°Ò6Ð6˜˜¸Mˆå$œ|¨MÀÄÐKÑKÔK×NÒNØŒJ S¤Z¤_¸Ò%=ð  Oñ  
ô  
Ðõ Œ{˜5 Aš: s¨U¡{Ð4HÑIÔIÐIÝÔ˜S %Ñ(Ô(Ð(r   é   ÚscoreÚaverageÚ
multilabelÚtpÚfpÚfnÚtop_kc                 ó  — |�|dk    r| S |dk    r||z   }n4t          j        | ¦  «        }|sd||dk    r||z   |z   dk    n||z   dk    <   t          || z  |                     dd¬¦  «        ¦  «                             d¦  «        S )	NÚnoneÚweightedr   r/   r   éÿÿÿÿT)Úkeepdim)r   Ú	ones_liker.   Úsum)r0   r1   r2   r3   r4   r5   r6   Úweightss           r   Ú_adjust_weights_safe_divider?   U   s¤   € ð €˜' VÒ+Ð+ØˆØ�*ÒÐØ�r‘'ˆˆå”/ %Ñ(Ô(ˆØð 	MØILˆG¨°!ª¨�B˜‘G˜b‘L AÒ%Ð%¸¸b¹ÀAºÑFÝ˜ %™¨¯ª°RÀ¨Ñ)FÔ)FÑGÔG×KÒKÈBÑOÔOÐOr   c                 ó¾  — | j         dk    r|                      ¦   «         n| } |j         dk    r|                     ¦   «         n|}| j         dk    s|j         dk    rt          d| j         › d|j         › �¦  «        ‚|                      ¦   «         |                     ¦   «         k    r9t          d|                      ¦   «         › d|                     ¦   «         › �¦  «        ‚| |fS )z Check that auc input is correct.r/   zJExpected both `x` and `y` tensor to be 1d, but got tensors with dimension z and zHExpected the same number of elements in `x` and `y` tensor but received )ÚndimÚsqueezeÚ
ValueErrorÚnumelr   s     r   Ú_auc_format_inputsrE   c   sá   € à”v ’z�zˆ�	Š	‰Œˆ q€AØ”v ’z�zˆ�	Š	‰Œˆ q€Aà„v�‚z€z�Q”V˜a’Z�ZÝØnÐYZÔY_ÐnÐnÐfgÔflÐnÐnñ
ô 
ð 	
ð 	‡w‚w�y„y�A—G’G‘I”IÒÐÝØrÐWX×W^ÒW^ÑW`ÔW`ÐrÐrÐgh×gnÒgnÑgpÔgpÐrÐrñ
ô 
ð 	
ð ˆaˆ4€Kr   r:   Ú	directionÚaxisc                 ó�   — t          j        ¦   «         5  t          j        || |¬¦  «        |z  }ddd¦  «         n# 1 swxY w Y   |S )zrCompute area under the curve using the trapezoidal rule.

    Assumes increasing or decreasing order of `x`.

    ©ÚdimN)r   Úno_gradÚtrapz)r   r	   rF   rG   Ú	auc_scores        r   Ú_auc_compute_without_checkrN   s   s—   € õ 
Œ‰Œð Dð DÝ!œK¨¨1°$Ð7Ñ7Ô7¸)ÑCˆ	ðDð Dð Dñ Dô Dð Dð Dð Dð Dð Dð Døøøð Dð Dð Dð DàÐs   ”;»?Á?FÚreorderc                 óv  — t          j        ¦   «         5  |r!t          j        | d¬¦  «        \  } }||         }| dd…         | dd…         z
  }|dk                          ¦   «         r*|dk                         ¦   «         rd}nt          d¦  «        ‚d	}t          | ||¦  «        cddd¦  «         S # 1 swxY w Y   dS )
zñCompute area under the curve using the trapezoidal rule.

    Example:
        >>> import torch
        >>> x = torch.tensor([1, 2, 3, 4])
        >>> y = torch.tensor([1, 2, 3, 4])
        >>> _auc_compute(x, y)
        tensor(7.5000)

    T)Ústabler/   Nr:   r   g      ð¿z_The `x` tensor is neither increasing or decreasing. Try setting the reorder argument to `True`.g      ð?)r   rK   Úsortr&   ÚallrC   rN   )r   r	   rO   Úx_idxÚdxrF   s         r   Ú_auc_computerV   ~   s  € õ 
Œ‰Œð ;ð ;Øð 	Ý”z !¨DÐ1Ñ1Ô1‰HˆAˆuØ�%”ˆAàˆqˆrˆrŒU�Q�s˜�s”V‰^ˆØ�ŠF�<Š<‰>Œ>ð 	Ø�a’�}Š}‰Œð Ø �	�	å Øuñô ð ð ˆIÝ)¨!¨Q°	Ñ:Ô:ð;ð ;ð ;ð ;ñ ;ô ;ð ;ð ;ð ;ð ;ð ;ð ;øøøð ;ð ;ð ;ð ;ð ;ð ;s   ”BB.Â.B2Â5B2c                 óL   — t          | |¦  «        \  } }t          | ||¬¦  «        S )a8  Compute Area Under the Curve (AUC) using the trapezoidal rule.

    Args:
        x: x-coordinates, must be either increasing or decreasing
        y: y-coordinates
        reorder: if True, will reorder the arrays to make it either increasing or decreasing

    Return:
        Tensor containing AUC score

    )rO   )rE   rV   )r   r	   rO   s      r   ÚaucrX   ›   s,   € õ ˜a Ñ#Ô#�D€A€qÝ˜˜1 gÐ.Ñ.Ô.Ð.r   Úxpc           	      ó�  — t          |dd…         |dd…         z
  |dd…         |dd…         z
  ¦  «        }|dd…         ||dd…         z  z
  }t          j        t          j        | dd…df         |ddd…f         ¦  «        d¦  «        dz
  }t          j        |dt          |¦  «        dz
  ¦  «        }||         | z  ||         z   S )ai  One-dimensional linear interpolation for monotonically increasing sample points.

    Returns the one-dimensional piecewise linear interpolation to a function with
    given discrete data points :math:`(xp, fp)`, evaluated at :math:`x`.

    Adjusted version of this https://github.com/pytorch/pytorch/issues/50334#issuecomment-1000917964

    Args:
        x: the :math:`x`-coordinates at which to evaluate the interpolated values.
        xp: the :math:`x`-coordinates of the data points, must be increasing.
        fp: the :math:`y`-coordinates of the data points, same length as `xp`.

    Returns:
        the interpolated values, same size as `x`.

    Example:
        >>> x = torch.tensor([0.5, 1.5, 2.5])
        >>> xp = torch.tensor([1, 2, 3])
        >>> fp = torch.tensor([1, 2, 3])
        >>> interp(x, xp, fp)
        tensor([0.5000, 1.5000, 2.5000])

    r/   Nr:   r   )r.   r   r=   ÚgeÚclampÚlen)r   rY   r4   ÚmÚbÚindicess         r   Úinterpra   «   sÉ   € õ0 	�R˜˜˜”V˜b  " œgÑ% r¨!¨"¨"¤v°°3°B°3´Ñ'7Ñ8Ô8€AØ
ˆ3ˆBˆ3Œ�1�r˜#˜2˜#”w‘;Ñ€AåŒi�œ  1 1 1 d 7¤¨R°°a°a°a°¬[Ñ9Ô9¸1Ñ=Ô=ÀÑA€GÝŒk˜' 1¥c¨!¡f¤f¨q¡jÑ1Ô1€GàˆWŒ:˜‰>˜A˜gœJÑ&Ð&r   r'   Únormalization)ÚsigmoidÚsoftmaxc                 ó¬  — |s| S | j         t          j         d¦  «        k    rQt          j        | dk    | dk    z  ¦  «        s0|dk    r|                      ¦   «         nt          j        | d¬¦  «        } | S | dk     | dk    z                       ¦   «         }t          j        ||dk    rt          j        | ¦  «        nt          j        | d¬¦  «        | ¦  «        S )aÚ  Normalize logits if needed.

    If input tensor is outside the [0,1] we assume that logits are provided and apply the normalization.
    Use torch.where to prevent device-host sync.

    Args:
        tensor: input tensor that may be logits or probabilities
        normalization: normalization method, either 'sigmoid' or 'softmax'

    Returns:
        normalized tensor if needed

    Example:
        >>> import torch
        >>> tensor = torch.tensor([-1.0, 0.0, 1.0])
        >>> normalize_logits_if_needed(tensor, normalization="sigmoid")
        tensor([0.2689, 0.5000, 0.7311])
        >>> tensor = torch.tensor([[-1.0, 0.0, 1.0], [1.0, 0.0, -1.0]])
        >>> normalize_logits_if_needed(tensor, normalization="softmax")
        tensor([[0.0900, 0.2447, 0.6652],
                [0.6652, 0.2447, 0.0900]])
        >>> tensor = torch.tensor([0.0, 0.5, 1.0])
        >>> normalize_logits_if_needed(tensor, normalization="sigmoid")
        tensor([0.0000, 0.5000, 1.0000])

    Úcpur   r/   rc   rI   )r)   r   rS   rc   rd   r&   r+   )r'   rb   Ú	conditions      r   Únormalize_logits_if_neededrh   Ì   sâ   € ð8 ð Øˆà„}�œ UÑ+Ô+Ò+Ð+ÝŒy˜& Aš+¨&°Aª+Ñ6Ñ7Ô7ð 	fØ)6¸)Ò)CÐ)C�V—^’^Ñ%Ô%Ð%ÍÌÐW]ÐcdÐIeÑIeÔIeˆFØˆð ˜1’* ¨!¢Ñ,×1Ò1Ñ3Ô3€IÝŒ;ØØ!.°)Ò!;Ð!;�Œ�fÑÔÐÅÄÈvÐ[\ÐA]ÑA]ÔA]Øñô ð r   )r   )r/   )r:   )F)Útypingr   r   r   r   Útyping_extensionsr   Útorchmetrics.utilitiesr   r   r   r   r.   ÚstrÚboolr%   r?   ÚtuplerE   rN   rV   rX   ra   rh   © r   r   ú<module>rp      s¼  ðð #Ð "Ð "Ð "Ð "Ð "Ð "Ð "à €€€Ø Ð Ð Ð Ð Ð Ø %Ð %Ð %Ð %Ð %Ð %à 1Ð 1Ð 1Ð 1Ð 1Ð 1ð�Fð ˜vð ¨&ð ð ð ð ð�6ð ˜fð ¨ð ð ð ð ð$ ;>ð!)ð !)Ø	ð!)àð!)ð ˜ ¨Ô 6Ð6Ô7ð!)ð ð	!)ð !)ð !)ð !)ðJ opðPð PØðPØ$ SœMðPØ7;ðPØAGðPØMSðPØY_ðPØhkðPàðPð Pð Pð Pð˜&ð  Vð °°f¸f°nÔ0Eð ð ð ð ð ð  &ð ¨Vð Àð ÈSð ÐZ`ð ð ð ð ð;ð ;�Fð ;˜vð ;°ð ;Àð ;ð ;ð ;ð ;ð:/ð /ˆ6ð /�fð / tð /¸ð /ð /ð /ð /ð 'ˆfð '˜&ð ' fð '°ð 'ð 'ð 'ð 'ðB* vð *¸hÀwÐOcÔGdÔ>eð *Ðjpð *ð *ð *ð *ð *ð *r   