§
    ’©ºjGN  ã                   ó˜  — d dl mZ d dlmZ d dlmZ d dlmZmZm	Z	m
Z
mZmZmZmZmZmZmZmZ d dlmZmZ d dlmZ 	 	 	 d)d
ededededeed                  ded         dededefd„Z	 	 	 	 d*dedededed         dee         dedefd„Z	 	 	 	 	 	 d+deded ee         deed!                  deded         dee         dedefd"„Z	 	 	 	 	 d,deded#ededeed!                  ded         dee         dedefd$„Z	 	 	 	 	 	 	 	 d-deded&ed'         ded ee         d#ee         ded!         ded         dee         dee         dedefd(„ZdS ).é    )ÚOptional)ÚTensor)ÚLiteral)Ú"_binary_stat_scores_arg_validationÚ_binary_stat_scores_formatÚ%_binary_stat_scores_tensor_validationÚ_binary_stat_scores_updateÚ&_multiclass_stat_scores_arg_validationÚ_multiclass_stat_scores_formatÚ)_multiclass_stat_scores_tensor_validationÚ_multiclass_stat_scores_updateÚ&_multilabel_stat_scores_arg_validationÚ_multilabel_stat_scores_formatÚ)_multilabel_stat_scores_tensor_validationÚ_multilabel_stat_scores_update)Ú_adjust_weights_safe_divideÚ_safe_divide)ÚClassificationTaskÚglobalFé   ÚtpÚfpÚtnÚfnÚaverage)ÚbinaryÚmicroÚmacroÚweightedÚnoneÚmultidim_average)r   Ú
samplewiseÚ
multilabelÚtop_kÚreturnc           	      ó0  — |dk    rt          | |z   | |z   |z   |z   ¦  «        S |dk    r©|                      |dk    rdnd¬¦  «        } |                     |dk    rdnd¬¦  «        }|rX|                     |dk    rdnd¬¦  «        }|                     |dk    rdnd¬¦  «        }t          | |z   | |z   |z   |z   ¦  «        S t          | | |z   ¦  «        S |rt          | |z   | |z   |z   |z   ¦  «        nt          | | |z   ¦  «        }t          |||| |||¦  «        S )a°  Reduce classification statistics into accuracy score.

    Args:
        tp: number of true positives
        fp: number of false positives
        tn: number of true negatives
        fn: number of false negatives
        average:
            Defines the reduction that is applied over labels. Should be one of the following:

            - ``binary``: for binary reduction
            - ``micro``: sum score over all classes/labels
            - ``macro``: salculate score for each class/label and average them
            - ``weighted``: calculates score for each class/label and computes weighted average using their support
            - ``"none"`` or ``None``: calculates score for each class/label and applies no reduction

        multidim_average:
            Defines how additionally dimensions ``...`` should be handled. Should be one of the following:

            - ``global``: Additional dimensions are flatted along the batch dimension
            - ``samplewise``: Statistic will be calculated independently for each sample on the ``N`` axis.

        multilabel: If input is multilabel or not
        top_k: value for top-k accuracy, else 1

    Returns:
        Accuracy score

    r   r   r   r   r   )Údim)r   Úsumr   )	r   r   r   r   r   r!   r#   r$   Úscores	            ú/root/private/project/pallet_detection_v2/.venv/lib/python3.11/site-packages/torchmetrics/functional/classification/accuracy.pyÚ_accuracy_reducer+   %   sW  € ðN �(ÒÐÝ˜B ™G R¨"¡W¨r¡\°BÑ%6Ñ7Ô7Ð7Ø�'ÒÐØ�VŠVÐ-°Ò9Ð9˜˜¸qˆVÑAÔAˆØ�VŠVÐ-°Ò9Ð9˜˜¸qˆVÑAÔAˆØð 	<Ø—’Ð!1°XÒ!=Ð!=˜A˜AÀ1�ÑEÔEˆBØ—’Ð!1°XÒ!=Ð!=˜A˜AÀ1�ÑEÔEˆBÝ  R¡¨¨b©°2©¸Ñ):Ñ;Ô;Ð;Ý˜B  R¡Ñ(Ô(Ð(à8BÐa�L˜˜b™ " r¡'¨B¡,°Ñ"3Ñ4Ô4Ð4ÍÐUWÐY[Ð^`ÑY`ÑHaÔHa€EÝ& u¨g°zÀ2ÀrÈ2ÈuÑUÔUÐUó    ç      à?NTÚpredsÚtargetÚ	thresholdÚignore_indexÚvalidate_argsc                 óÌ   — |r#t          |||¦  «         t          | |||¦  «         t          | |||¦  «        \  } }t          | ||¦  «        \  }}}}	t	          ||||	d|¬¦  «        S )aâ
  Compute `Accuracy`_ for binary tasks.

    .. math::
        \text{Accuracy} = \frac{1}{N}\sum_i^N 1(y_i = \hat{y}_i)

    Where :math:`y` is a tensor of target values, and :math:`\hat{y}` is a
    tensor of predictions.

    Accepts the following input tensors:

    - ``preds`` (int or float tensor): ``(N, ...)``. If preds is a floating point tensor with values outside
      [0,1] range we consider the input to be logits and will auto apply sigmoid per element. Additionally,
      we convert to int tensor with thresholding using the value in ``threshold``.
    - ``target`` (int tensor): ``(N, ...)``

    Args:
        preds: Tensor with predictions
        target: Tensor with true labels
        threshold: Threshold for transforming probability to binary {0,1} predictions
        multidim_average:
            Defines how additionally dimensions ``...`` should be handled. Should be one of the following:

            - ``global``: Additional dimensions are flatted along the batch dimension
            - ``samplewise``: Statistic will be calculated independently for each sample on the ``N`` axis.
              The statistics in this case are calculated over the additional dimensions.

        ignore_index:
            Specifies a target value that is ignored and does not contribute to the metric calculation
        validate_args: bool indicating if input arguments and tensors should be validated for correctness.
            Set to ``False`` for faster computations.

    Returns:
        If ``multidim_average`` is set to ``global``, the metric returns a scalar value. If ``multidim_average``
        is set to ``samplewise``, the metric returns ``(N,)`` vector consisting of a scalar value per sample.

    Example (preds is int tensor):
        >>> from torch import tensor
        >>> from torchmetrics.functional.classification import binary_accuracy
        >>> target = tensor([0, 1, 0, 1, 0, 1])
        >>> preds = tensor([0, 0, 1, 1, 0, 1])
        >>> binary_accuracy(preds, target)
        tensor(0.6667)

    Example (preds is float tensor):
        >>> from torchmetrics.functional.classification import binary_accuracy
        >>> target = tensor([0, 1, 0, 1, 0, 1])
        >>> preds = tensor([0.11, 0.22, 0.84, 0.73, 0.33, 0.92])
        >>> binary_accuracy(preds, target)
        tensor(0.6667)

    Example (multidim tensors):
        >>> from torchmetrics.functional.classification import binary_accuracy
        >>> target = tensor([[[0, 1], [1, 0], [0, 1]], [[1, 1], [0, 0], [1, 0]]])
        >>> preds = tensor([[[0.59, 0.91], [0.91, 0.99], [0.63, 0.04]],
        ...                 [[0.38, 0.04], [0.86, 0.780], [0.45, 0.37]]])
        >>> binary_accuracy(preds, target, multidim_average='samplewise')
        tensor([0.3333, 0.1667])

    r   )r   r!   )r   r   r   r	   r+   )
r.   r/   r0   r!   r1   r2   r   r   r   r   s
             r*   Úbinary_accuracyr4   [   sƒ   € ðF ð ]Ý*¨9Ð6FÈÑUÔUÐUÝ-¨e°VÐ=MÈ|Ñ\Ô\Ð\Ý.¨u°f¸iÈÑVÔV�M€Eˆ6Ý/°°vÐ?OÑPÔP�N€BˆˆB�Ý˜B  B¨°HÐO_Ð`Ñ`Ô`Ð`r,   r   Únum_classes)r   r   r   r    c           	      óÞ   — |r&t          |||||¦  «         t          | ||||¦  «         t          | ||¦  «        \  } }t          | ||pd||||¦  «        \  }}	}
}t	          ||	|
||||¬¦  «        S )a]  Compute `Accuracy`_ for multiclass tasks.

    .. math::
        \text{Accuracy} = \frac{1}{N}\sum_i^N 1(y_i = \hat{y}_i)

    Where :math:`y` is a tensor of target values, and :math:`\hat{y}` is a
    tensor of predictions.

    Accepts the following input tensors:

    - ``preds``: ``(N, ...)`` (int tensor) or ``(N, C, ..)`` (float tensor). If preds is a floating point
      we apply ``torch.argmax`` along the ``C`` dimension to automatically convert probabilities/logits into
      an int tensor.
    - ``target`` (int tensor): ``(N, ...)``

    Args:
        preds: Tensor with predictions
        target: Tensor with true labels
        num_classes: Integer specifying the number of classes
        average:
            Defines the reduction that is applied over labels. Should be one of the following:

            - ``micro``: Sum statistics over all labels
            - ``macro``: Calculate statistics for each label and average them
            - ``weighted``: calculates statistics for each label and computes weighted average using their support
            - ``"none"`` or ``None``: calculates statistic for each label and applies no reduction

        top_k:
            Number of highest probability or logit score predictions considered to find the correct label.
            Only works when ``preds`` contain probabilities/logits.
        multidim_average:
            Defines how additionally dimensions ``...`` should be handled. Should be one of the following:

            - ``global``: Additional dimensions are flatted along the batch dimension
            - ``samplewise``: Statistic will be calculated independently for each sample on the ``N`` axis.
              The statistics in this case are calculated over the additional dimensions.

        ignore_index:
            Specifies a target value that is ignored and does not contribute to the metric calculation
        validate_args: bool indicating if input arguments and tensors should be validated for correctness.
            Set to ``False`` for faster computations.

    Returns:
        The returned shape depends on the ``average`` and ``multidim_average`` arguments:

        - If ``multidim_average`` is set to ``global``:

          - If ``average='micro'/'macro'/'weighted'``, the output will be a scalar tensor
          - If ``average=None/'none'``, the shape will be ``(C,)``

        - If ``multidim_average`` is set to ``samplewise``:

          - If ``average='micro'/'macro'/'weighted'``, the shape will be ``(N,)``
          - If ``average=None/'none'``, the shape will be ``(N, C)``

    Example (preds is int tensor):
        >>> from torch import tensor
        >>> from torchmetrics.functional.classification import multiclass_accuracy
        >>> target = tensor([2, 1, 0, 0])
        >>> preds = tensor([2, 1, 0, 1])
        >>> multiclass_accuracy(preds, target, num_classes=3)
        tensor(0.8333)
        >>> multiclass_accuracy(preds, target, num_classes=3, average=None)
        tensor([0.5000, 1.0000, 1.0000])

    Example (preds is float tensor):
        >>> from torchmetrics.functional.classification import multiclass_accuracy
        >>> target = tensor([2, 1, 0, 0])
        >>> preds = tensor([[0.16, 0.26, 0.58],
        ...                 [0.22, 0.61, 0.17],
        ...                 [0.71, 0.09, 0.20],
        ...                 [0.05, 0.82, 0.13]])
        >>> multiclass_accuracy(preds, target, num_classes=3)
        tensor(0.8333)
        >>> multiclass_accuracy(preds, target, num_classes=3, average=None)
        tensor([0.5000, 1.0000, 1.0000])

    Example (multidim tensors):
        >>> from torchmetrics.functional.classification import multiclass_accuracy
        >>> target = tensor([[[0, 1], [2, 1], [0, 2]], [[1, 1], [2, 0], [1, 2]]])
        >>> preds = tensor([[[0, 2], [2, 0], [0, 1]], [[2, 2], [2, 1], [1, 0]]])
        >>> multiclass_accuracy(preds, target, num_classes=3, multidim_average='samplewise')
        tensor([0.5000, 0.2778])
        >>> multiclass_accuracy(preds, target, num_classes=3, multidim_average='samplewise', average=None)
        tensor([[1.0000, 0.0000, 0.5000],
                [0.0000, 0.3333, 0.5000]])

    r   )r   r!   r$   )r
   r   r   r   r+   )r.   r/   r5   r   r$   r!   r1   r2   r   r   r   r   s               r*   Úmulticlass_accuracyr7   ¦   s    € ðD ð nÝ.¨{¸EÀ7ÐL\Ð^jÑkÔkÐkÝ1°%¸ÀÐN^Ð`lÑmÔmÐmÝ2°5¸&À%ÑHÔH�M€Eˆ6Ý3Øˆv�{Ð' a¨°Ð9IÈ<ñô �N€BˆˆB�õ ˜B  B¨°GÐN^ÐfkÐlÑlÔlÐlr,   Ú
num_labelsc           	      óÖ   — |r&t          |||||¦  «         t          | ||||¦  «         t          | ||||¦  «        \  } }t          | ||¦  «        \  }}	}
}t	          ||	|
|||d¬¦  «        S )a  Compute `Accuracy`_ for multilabel tasks.

    .. math::
        \text{Accuracy} = \frac{1}{N}\sum_i^N 1(y_i = \hat{y}_i)

    Where :math:`y` is a tensor of target values, and :math:`\hat{y}` is a
    tensor of predictions.

    Accepts the following input tensors:

    - ``preds`` (int or float tensor): ``(N, C, ...)``. If preds is a floating point tensor with values outside
      [0,1] range we consider the input to be logits and will auto apply sigmoid per element. Additionally,
      we convert to int tensor with thresholding using the value in ``threshold``.
    - ``target`` (int tensor): ``(N, C, ...)``

    Args:
        preds: Tensor with predictions
        target: Tensor with true labels
        num_labels: Integer specifying the number of labels
        threshold: Threshold for transforming probability to binary (0,1) predictions
        average:
            Defines the reduction that is applied over labels. Should be one of the following:

            - ``micro``: Sum statistics over all labels
            - ``macro``: Calculate statistics for each label and average them
            - ``weighted``: calculates statistics for each label and computes weighted average using their support
            - ``"none"`` or ``None``: calculates statistic for each label and applies no reduction

        multidim_average:
            Defines how additionally dimensions ``...`` should be handled. Should be one of the following:

            - ``global``: Additional dimensions are flatted along the batch dimension
            - ``samplewise``: Statistic will be calculated independently for each sample on the ``N`` axis.
              The statistics in this case are calculated over the additional dimensions.

        ignore_index:
            Specifies a target value that is ignored and does not contribute to the metric calculation
        validate_args: bool indicating if input arguments and tensors should be validated for correctness.
            Set to ``False`` for faster computations.

    Returns:
        The returned shape depends on the ``average`` and ``multidim_average`` arguments:

        - If ``multidim_average`` is set to ``global``:

          - If ``average='micro'/'macro'/'weighted'``, the output will be a scalar tensor
          - If ``average=None/'none'``, the shape will be ``(C,)``

        - If ``multidim_average`` is set to ``samplewise``:

          - If ``average='micro'/'macro'/'weighted'``, the shape will be ``(N,)``
          - If ``average=None/'none'``, the shape will be ``(N, C)``

    Example (preds is int tensor):
        >>> from torch import tensor
        >>> from torchmetrics.functional.classification import multilabel_accuracy
        >>> target = tensor([[0, 1, 0], [1, 0, 1]])
        >>> preds = tensor([[0, 0, 1], [1, 0, 1]])
        >>> multilabel_accuracy(preds, target, num_labels=3)
        tensor(0.6667)
        >>> multilabel_accuracy(preds, target, num_labels=3, average=None)
        tensor([1.0000, 0.5000, 0.5000])

    Example (preds is float tensor):
        >>> from torchmetrics.functional.classification import multilabel_accuracy
        >>> target = tensor([[0, 1, 0], [1, 0, 1]])
        >>> preds = tensor([[0.11, 0.22, 0.84], [0.73, 0.33, 0.92]])
        >>> multilabel_accuracy(preds, target, num_labels=3)
        tensor(0.6667)
        >>> multilabel_accuracy(preds, target, num_labels=3, average=None)
        tensor([1.0000, 0.5000, 0.5000])

    Example (multidim tensors):
        >>> from torchmetrics.functional.classification import multilabel_accuracy
        >>> target = tensor([[[0, 1], [1, 0], [0, 1]], [[1, 1], [0, 0], [1, 0]]])
        >>> preds = tensor([[[0.59, 0.91], [0.91, 0.99], [0.63, 0.04]],
        ...                 [[0.38, 0.04], [0.86, 0.780], [0.45, 0.37]]])
        >>> multilabel_accuracy(preds, target, num_labels=3, multidim_average='samplewise')
        tensor([0.3333, 0.1667])
        >>> multilabel_accuracy(preds, target, num_labels=3, multidim_average='samplewise', average=None)
        tensor([[0.5000, 0.5000, 0.0000],
                [0.0000, 0.0000, 0.5000]])

    T)r   r!   r#   )r   r   r   r   r+   )r.   r/   r8   r0   r   r!   r1   r2   r   r   r   r   s               r*   Úmultilabel_accuracyr:     s‘   € ð| ð mÝ.¨z¸9ÀgÐO_ÐamÑnÔnÐnÝ1°%¸ÀÐM]Ð_kÑlÔlÐlÝ2°5¸&À*ÈiÐYeÑfÔf�M€Eˆ6Ý3°E¸6ÐCSÑTÔT�N€BˆˆB�Ý˜B  B¨°GÐN^ÐkoÐpÑpÔpÐpr,   r   Útask)r   Ú
multiclassr#   c           
      óx  — t          j        |¦  «        }|t           j        k    rt          | ||||	|
¦  «        S |t           j        k    r„t          |t          ¦  «        s"t          d|› dt          |¦  «        › �¦  «        ‚t          |t          ¦  «        s"t          d|› dt          |¦  «        › �¦  «        ‚t          | ||||||	|
¦  «        S |t           j
        k    rMt          |t          ¦  «        s"t          d|› dt          |¦  «        › �¦  «        ‚t          | ||||||	|
¦  «        S t          d|› �¦  «        ‚)a•  Compute `Accuracy`_.

    .. math::
        \text{Accuracy} = \frac{1}{N}\sum_i^N 1(y_i = \hat{y}_i)

    Where :math:`y` is a tensor of target values, and :math:`\hat{y}` is a tensor of predictions.

    This function is a simple wrapper to get the task specific versions of this metric, which is done by setting the
    ``task`` argument to either ``'binary'``, ``'multiclass'`` or ``'multilabel'``. See the documentation of
    :func:`~torchmetrics.functional.classification.binary_accuracy`,
    :func:`~torchmetrics.functional.classification.multiclass_accuracy` and
    :func:`~torchmetrics.functional.classification.multilabel_accuracy` for the specific details of
    each argument influence and examples.

    Legacy Example:
        >>> from torch import tensor
        >>> target = tensor([0, 1, 2, 3])
        >>> preds = tensor([0, 2, 1, 3])
        >>> accuracy(preds, target, task="multiclass", num_classes=4)
        tensor(0.5000)

        >>> target = tensor([0, 1, 2])
        >>> preds = tensor([[0.1, 0.9, 0], [0.3, 0.1, 0.6], [0.2, 0.5, 0.3]])
        >>> accuracy(preds, target, task="multiclass", num_classes=3, top_k=2)
        tensor(0.6667)

    z;Optional arg `num_classes` must be type `int` when task is z. Got z5Optional arg `top_k` must be type `int` when task is z:Optional arg `num_labels` must be type `int` when task is zNot handled value: )r   Úfrom_strÚBINARYr4   Ú
MULTICLASSÚ
isinstanceÚintÚ
ValueErrorÚtyper7   Ú
MULTILABELr:   )r.   r/   r;   r0   r5   r8   r   r!   r$   r1   r2   s              r*   ÚaccuracyrF   x  s„  € õP Ô& tÑ,Ô,€DàÕ!Ô(Ò(Ð(Ý˜u f¨iÐ9IÈ<ÐYfÑgÔgÐgØÕ!Ô,Ò,Ð,Ý˜+¥sÑ+Ô+ð 	ÝØmÈdÐmÐmÕZ^Ð_jÑZkÔZkÐmÐmñô ð õ ˜%¥Ñ%Ô%ð 	pÝÐnÐUYÐnÐnÕaeÐfkÑalÔalÐnÐnÑoÔoÐoÝ"Ø�6˜;¨°Ð8HÈ,ÐXeñ
ô 
ð 	
ð Õ!Ô,Ò,Ð,Ý˜*¥cÑ*Ô*ð 	ÝØkÈTÐkÐkÕY]Ð^hÑYiÔYiÐkÐkñô ð õ #Ø�6˜: y°'Ð;KÈ\Ð[hñ
ô 
ð 	
õ Ð1¨4Ð1Ð1Ñ
2Ô
2Ð2r,   )r   Fr   )r-   r   NT)Nr   r   r   NT)r-   r   r   NT)r-   NNr   r   r   NT) Útypingr   Útorchr   Útyping_extensionsr   Ú2torchmetrics.functional.classification.stat_scoresr   r   r   r	   r
   r   r   r   r   r   r   r   Útorchmetrics.utilities.computer   r   Útorchmetrics.utilities.enumsr   ÚboolrB   r+   Úfloatr4   r7   r:   rF   © r,   r*   ú<module>rP      s[  ðð Ð Ð Ð Ð Ð à Ð Ð Ð Ð Ð Ø %Ð %Ð %Ð %Ð %Ð %ðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð UÐ TÐ TÐ TÐ TÐ TÐ TÐ TØ ;Ð ;Ð ;Ð ;Ð ;Ð ;ð 9AØØð3Vð 3VØð3Vàð3Vð 	ð3Vð 	ð	3Vð
 �gÐLÔMÔNð3Vð Ð4Ô5ð3Vð ð3Vð ð3Vð ð3Vð 3Vð 3Vð 3Vðr Ø8@Ø"&ØðHað HaØðHaàðHað ðHað Ð4Ô5ð	Hað
 ˜3”-ðHað ðHað ðHað Hað Hað Hað\ "&ØGNØØ8@Ø"&Øðimð imØðimàðimð ˜#”ðimð �gÐBÔCÔDð	imð
 ðimð Ð4Ô5ðimð ˜3”-ðimð ðimð ðimð imð imð imð` ØGNØ8@Ø"&Øðcqð cqØðcqàðcqð ðcqð ð	cqð
 �gÐBÔCÔDðcqð Ð4Ô5ðcqð ˜3”-ðcqð ðcqð ðcqð cqð cqð cqðT Ø!%Ø $Ø=DØ8@ØØ"&Øð>3ð >3Øð>3àð>3ð Ð6Ô
7ð>3ð ð	>3ð
 ˜#”ð>3ð ˜”ð>3ð Ð9Ô:ð>3ð Ð4Ô5ð>3ð �CŒ=ð>3ð ˜3”-ð>3ð ð>3ð ð>3ð >3ð >3ð >3ð >3ð >3r,   