Ë
    þÍ: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y)'é    )Ú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ÚtpÚfpÚtnÚfnÚaverage)ÚbinaryÚmicroÚmacroÚweightedÚnoneÚmultidim_average)ÚglobalÚ
samplewiseÚ
multilabelÚtop_kÚreturnc           	      óÔ  — |dk(  rt        | |z   | |z   |z   |z   «      S |dk(  r�| j                  |dk(  rdnd¬«      } |j                  |dk(  rdnd¬«      }|rJ|j                  |dk(  rdnd¬«      }|j                  |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   é   )Údim)r   Úsumr   )	r   r   r   r   r   r   r"   r#   Úscores	            ú„/home/mcse/projects/srt_converter/srt-converter-venv/lib/python3.12/site-packages/torchmetrics/functional/classification/accuracy.pyÚ_accuracy_reducer+   %   s  € ðN �(ÒÜ˜B ™G R¨"¡W¨r¡\°BÑ%6Ó7Ð7Ø�'ÒØ�V‰VÐ-°Ò9™¸qˆVÓAˆØ�V‰VÐ-°Ò9™¸qˆVÓAˆÙØ—‘Ð!1°XÒ!=™AÀ1�ÓEˆBØ—‘Ð!1°XÒ!=™AÀ1�ÓEˆBÜ  R¡¨¨b©°2©¸Ñ):Ó;Ð;Ü˜B  R¡Ó(Ð(á8BŒL˜˜b™ " r¡'¨B¡,°Ñ"3Ô4ÌÐUWÐY[Ð^`ÑY`ÓHa€EÜ& u¨g°zÀ2ÀrÈ2ÈuÓUÐUó    NÚ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.   r/   r   r0   r1   r   r   r   r   s
             r*   Úbinary_accuracyr3   [   se   € ñF Ü*¨9Ð6FÈÔUÜ-¨e°VÐ=MÈ|Ô\Ü.¨u°f¸iÈÓV�M€Eˆ6Ü/°°vÐ?OÓP�N€BˆˆB�Ü˜B  B¨°HÐO_Ô`Ð`r,   Únum_classes)r   r   r   r   c           	      óº   — |rt        |||||«       t        | ||||«       t        | ||«      \  } }t        | ||xs 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.   r4   r   r#   r   r0   r1   r   r   r   r   s               r*   Úmulticlass_accuracyr6   ¦   s€   € ñD Ü.¨{¸EÀ7ÐL\Ð^jÔkÜ1°%¸ÀÐN^Ð`lÔmÜ2°5¸&À%ÓH�M€Eˆ6Ü3Øˆv�{Ò' a¨°Ð9IÈ<ó�N€BˆˆB�ô ˜B  B¨°GÐN^ÐfkÔ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.   r7   r/   r   r   r0   r1   r   r   r   r   s               r*   Úmultilabel_accuracyr9     ss   € ñ| Ü.¨z¸9ÀgÐO_ÐamÔnÜ1°%¸ÀÐM]Ð_kÔlÜ2°5¸&À*ÈiÐYeÓf�M€Eˆ6Ü3°E¸6ÐCSÓT�N€BˆˆB�Ü˜B  B¨°GÐN^ÐkoÔpÐpr,   Útask)r   Ú
multiclassr"   c           
      ó  — t        j                  |«      }|t         j                  k(  rt        | ||||	|
«      S |t         j                  k(  rft        |t        «      st        d|› dt        |«      › �«      ‚t        |t        «      st        d|› dt        |«      › �«      ‚t        | ||||||	|
«      S |t         j                  k(  r<t        |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ÚBINARYr3   Ú
MULTICLASSÚ
isinstanceÚintÚ
ValueErrorÚtyper6   Ú
MULTILABELr9   )r-   r.   r:   r/   r4   r7   r   r   r#   r0   r1   s              r*   ÚaccuracyrE   x  sB  € ôP ×&Ñ& tÓ,€DàÔ!×(Ñ(Ò(Ü˜u f¨iÐ9IÈ<ÐYfÓgÐgØÔ!×,Ñ,Ò,Ü˜+¤sÔ+ÜØMÈdÈVÐSYÔZ^Ð_jÓZkÐYlÐmóð ô ˜%¤Ô%ÜÐTÐUYÐTZÐZ`ÔaeÐfkÓalÐ`mÐnÓoÐoÜ"Ø�6˜;¨°Ð8HÈ,ÐXeó
ð 	
ð Ô!×,Ñ,Ò,Ü˜*¤cÔ*ÜØLÈTÈFÐRXÔY]Ð^hÓYiÐXjÐkóð ô #Ø�6˜: y°'Ð;KÈ\Ð[hó
ð 	
ô Ð*¨4¨&Ð1Ó
2Ð2r,   )r    Fr&   )ç      à?r    NT)Nr   r&   r    NT)rF   r   r    NT)rF   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   ÚboolrA   r+   Úfloatr3   r6   r9   rE   © r,   r*   ú<module>rP      s  ðõ å Ý %÷÷ ÷ ó ÷ UÝ ;ð 9AØØñ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ðr Ø8@Ø"&ØñHaØðHaàðHað ðHað Ð4Ñ5ð	Hað
 ˜3‘-ðHað ðHað óHað\ "&ØGNØØ8@Ø"&Øñ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ð` ØGNØ8@Ø"&Øñ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ðT Ø!%Ø $Ø=DØ8@ØØ"&Øñ>3Øð>3àð>3ð Ð6Ñ
7ð>3ð ð	>3ð
 ˜#‘ð>3ð ˜‘ð>3ð Ð9Ñ:ð>3ð Ð4Ñ5ð>3ð �C‰=ð>3ð ˜3‘-ð>3ð ð>3ð ô>3r,   