§
    ’©ºjÔb  ã                   óF  — d dl mZ d dlmZmZmZ d dlmZ d dlm	Z	 d dl
mZ d dlmZmZmZ d dlmZ d dlmZmZmZmZmZmZ d d	lmZ d d
lmZ d dlmZ d dlm Z  d dl!m"Z"m#Z# e sg d¢Z$ G d„ de¦  «        Z% G d„ de¦  «        Z& G d„ de¦  «        Z' G d„ de¦  «        Z(dS )é    )ÚSequence)ÚAnyÚOptionalÚUnion)ÚTensor)ÚLiteral)Ú_ClassificationTaskWrapper)ÚBinaryPrecisionRecallCurveÚMulticlassPrecisionRecallCurveÚMultilabelPrecisionRecallCurve)Ú_precision_at_recall)Ú0_binary_recall_at_fixed_precision_arg_validationÚ)_binary_recall_at_fixed_precision_computeÚ1_multiclass_recall_at_fixed_precision_arg_computeÚ4_multiclass_recall_at_fixed_precision_arg_validationÚ1_multilabel_recall_at_fixed_precision_arg_computeÚ4_multilabel_recall_at_fixed_precision_arg_validation)ÚMetric)Údim_zero_cat)ÚClassificationTask)Ú_MATPLOTLIB_AVAILABLE)Ú_AX_TYPEÚ_PLOT_OUT_TYPE)z!BinaryPrecisionAtFixedRecall.plotz%MulticlassPrecisionAtFixedRecall.plotz%MultilabelPrecisionAtFixedRecall.plotc                   ó6  ‡ — e Zd ZU dZdZeed<   dZee         ed<   dZ	eed<   dZ
eed<   d	Zeed
<   	 	 	 ddedeeeee         ef                  dee         dededdfˆ fd„Zdeeef         fd„Z	 ddeeeee         f                  dee         defd„Zˆ xZS )ÚBinaryPrecisionAtFixedRecalla6  Compute the highest possible precision value given the minimum recall thresholds provided.

    This is done by first calculating the precision-recall curve for different thresholds and the find the precision for
    a given recall level.

    As input to ``forward`` and ``update`` the metric accepts the following input:

    - ``preds`` (:class:`~torch.Tensor`): A float tensor of shape ``(N, ...)``. Preds should be a tensor containing
      probabilities or logits for each observation. If preds has values outside [0,1] range we consider the input
      to be logits and will auto apply sigmoid per element.
    - ``target`` (:class:`~torch.Tensor`): An int tensor of shape ``(N, ...)``. Target should be a tensor containing
      ground truth labels, and therefore only contain {0,1} values (except if `ignore_index` is specified). The value
      1 always encodes the positive class.

    .. tip::
       Additional dimension ``...`` will be flattened into the batch dimension.

    As output to ``forward`` and ``compute`` the metric returns the following output:

    - ``precision`` (:class:`~torch.Tensor`): A scalar tensor with the maximum precision for the given recall level
    - ``threshold`` (:class:`~torch.Tensor`): A scalar tensor with the corresponding threshold level

    .. note::
       The implementation both supports calculating the metric in a non-binned but accurate version and a
       binned version that is less accurate but more memory efficient. Setting the `thresholds` argument to ``None``
       will activate the non-binned  version that uses memory of size :math:`\mathcal{O}(n_{samples})` whereas setting
       the `thresholds` argument to either an integer, list or a 1d tensor will use a binned version that uses memory
       of size :math:`\mathcal{O}(n_{thresholds})` (constant memory).

    Args:
        min_recall: float value specifying minimum recall threshold.
        thresholds:
            Can be one of:

            - If set to ``None``, will use a non-binned approach where thresholds are dynamically calculated from
              all the data. Most accurate but also most memory consuming approach.
            - If set to an ``int`` (larger than 1), will use that number of thresholds linearly spaced from
              0 to 1 as bins for the calculation.
            - If set to an ``list`` of floats, will use the indicated thresholds in the list as bins for the calculation
            - If set to an 1d :class:`~torch.Tensor` of floats, will use the indicated thresholds in the tensor as
              bins for the calculation.

        validate_args: bool indicating if input arguments and tensors should be validated for correctness.
            Set to ``False`` for faster computations.
        kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info.

    Example:
        >>> from torch import tensor
        >>> from torchmetrics.classification import BinaryPrecisionAtFixedRecall
        >>> preds = tensor([0, 0.5, 0.7, 0.8])
        >>> target = tensor([0, 1, 1, 0])
        >>> metric = BinaryPrecisionAtFixedRecall(min_recall=0.5, thresholds=None)
        >>> metric(preds, target)
        (tensor(0.6667), tensor(0.5000))
        >>> metric = BinaryPrecisionAtFixedRecall(min_recall=0.5, thresholds=5)
        >>> metric(preds, target)
        (tensor(0.6667), tensor(0.5000))

    FÚis_differentiableNÚhigher_is_betterÚfull_state_updateç        Úplot_lower_boundç      ð?Úplot_upper_boundTÚ
min_recallÚ
thresholdsÚignore_indexÚvalidate_argsÚkwargsÚreturnc                 ó„   •—  t          ¦   «         j        ||fddi|¤Ž |rt          |||¦  «         || _        || _        d S )Nr&   F)ÚsuperÚ__init__r   r&   r#   )Úselfr#   r$   r%   r&   r'   Ú	__class__s         €ú‚/root/private/project/pallet_detection_v2/.venv/lib/python3.11/site-packages/torchmetrics/classification/precision_fixed_recall.pyr+   z%BinaryPrecisionAtFixedRecall.__init__t   sZ   ø€ ð 	�‰ŒÔ˜ \ÐQÐQÀÐQÈ&ÐQÐQÐQØð 	cÝ<¸ZÈÐUaÑbÔbÐbØ*ˆÔØ$ˆŒˆˆó    c                 ó²   — | j         €(t          | j        ¦  «        t          | j        ¦  «        fn| j        }t          || j         | j        t          ¬¦  «        S ©zCompute metric.N)Ú	reduce_fn)r$   r   ÚpredsÚtargetÚconfmatr   r#   r   ©r,   Ústates     r.   Úcomputez$BinaryPrecisionAtFixedRecall.compute‚   sU   € àIMÌÐI`•˜dœjÑ)Ô)­<¸¼Ñ+DÔ+DÐEÐEÐfjÔfrˆÝ8Ø�4”? D¤OÕ?Sð
ñ 
ô 
ð 	
r/   ÚvalÚaxc                 óf   — |p|                       ¦   «         d         }|                      ||¦  «        S )a#  Plot a single or multiple values from the metric.

        Args:
            val: Either a single result from calling `metric.forward` or `metric.compute` or a list of these results.
                If no value is provided, will automatically call `metric.compute` and plot that result.
            ax: An matplotlib axis object. If provided will add plot to that axis

        Returns:
            Figure object and Axes object

        Raises:
            ModuleNotFoundError:
                If `matplotlib` is not installed

        .. plot::
            :scale: 75

            >>> from torch import rand, randint
            >>> # Example plotting a single value
            >>> from torchmetrics.classification import BinaryPrecisionAtFixedRecall
            >>> metric = BinaryPrecisionAtFixedRecall(min_recall=0.5)
            >>> metric.update(rand(10), randint(2,(10,)))
            >>> fig_, ax_ = metric.plot()  # the returned plot only shows the maximum recall value by default

        .. plot::
            :scale: 75

            >>> from torch import rand, randint
            >>> # Example plotting multiple values
            >>> from torchmetrics.classification import BinaryPrecisionAtFixedRecall
            >>> metric = BinaryPrecisionAtFixedRecall(min_recall=0.5)
            >>> values = [ ]
            >>> for _ in range(10):
            ...     # we index by 0 such that only the maximum recall value is plotted
            ...     values.append(metric(rand(10), randint(2,(10,)))[0])
            >>> fig_, ax_ = metric.plot(values)

        r   ©r8   Ú_plot©r,   r9   r:   s      r.   Úplotz!BinaryPrecisionAtFixedRecall.plot‰   ó0   € ðR Ð&�T—\’\‘^”^ AÔ&ˆØ�zŠz˜#˜rÑ"Ô"Ð"r/   ©NNT©NN)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   ÚboolÚ__annotations__r   r   r   r    Úfloatr"   r   ÚintÚlistr   r   r+   Útupler8   r   r   r   r?   Ú__classcell__©r-   s   @r.   r   r   1   s€  ø€ € € € € € ð:ð :ðx $Ð�tÐ#Ð#Ñ#Ø'+Ð�h˜t”nÐ+Ð+Ñ+Ø#Ð�tÐ#Ð#Ñ#Ø!Ð�eÐ!Ð!Ñ!Ø!Ð�eÐ!Ð!Ñ!ð
 AEØ&*Ø"ð%ð %àð%ð ˜U 3¨¨U¬°VÐ#;Ô<Ô=ð%ð ˜s”mð	%ð
 ð%ð ð%ð 
ð%ð %ð %ð %ð %ð %ð
˜˜v v˜~Ô.ð 
ð 
ð 
ð 
ð _cð*#ð *#Ø˜E &¨(°6Ô*:Ð":Ô;Ô<ð*#ØIQÐRZÔI[ð*#à	ð*#ð *#ð *#ð *#ð *#ð *#ð *#ð *#r/   r   c                   óH  ‡ — e Zd ZU dZdZeed<   dZee         ed<   dZ	eed<   dZ
eed<   d	Zeed
<   dZeed<   	 	 	 ddededeeeee         ef                  dee         dededdfˆ fd„Zdeeef         fd„Z	 ddeeeee         f                  dee         defd„Zˆ xZS )Ú MulticlassPrecisionAtFixedRecallaŸ  Compute the highest possible precision value given the minimum recall thresholds provided.

    This is done by first calculating the precision-recall curve for different thresholds and the find the precision for
    a given recall level.

    As input to ``forward`` and ``update`` the metric accepts the following input:

    - ``preds`` (:class:`~torch.Tensor`): A float tensor of shape ``(N, C, ...)``. Preds should be a tensor
      containing probabilities or logits for each observation. If preds has values outside [0,1] range we consider
      the input to be logits and will auto apply softmax per sample.
    - ``target`` (:class:`~torch.Tensor`): An int tensor of shape ``(N, ...)``. Target should be a tensor containing
      ground truth labels, and therefore only contain values in the [0, n_classes-1] range (except if `ignore_index`
      is specified).

    .. tip::
       Additional dimension ``...`` will be flattened into the batch dimension.

    As output to ``forward`` and ``compute`` the metric returns a tuple of either 2 tensors or 2 lists containing:

    - ``precision`` (:class:`~torch.Tensor`): A 1d tensor of size ``(n_classes, )`` with the maximum precision for the
      given recall level per class
    - ``threshold`` (:class:`~torch.Tensor`): A 1d tensor of size ``(n_classes, )`` with the corresponding threshold
      level per class

    .. note::
       The implementation both supports calculating the metric in a non-binned but accurate version and a binned version
       that is less accurate but more memory efficient. Setting the `thresholds` argument to ``None`` will activate the
       non-binned  version that uses memory of size :math:`\mathcal{O}(n_{samples})` whereas setting the `thresholds`
       argument to either an integer, list or a 1d tensor will use a binned version that uses memory of
       size :math:`\mathcal{O}(n_{thresholds} \times n_{classes})` (constant memory).

    Args:
        num_classes: Integer specifying the number of classes
        min_recall: float value specifying minimum recall threshold.
        thresholds:
            Can be one of:

            - If set to ``None``, will use a non-binned approach where thresholds are dynamically calculated from
              all the data. Most accurate but also most memory consuming approach.
            - If set to an ``int`` (larger than 1), will use that number of thresholds linearly spaced from
              0 to 1 as bins for the calculation.
            - If set to an ``list`` of floats, will use the indicated thresholds in the list as bins for the calculation
            - If set to an 1d :class:`~torch.Tensor` of floats, will use the indicated thresholds in the tensor as
              bins for the calculation.

        validate_args: bool indicating if input arguments and tensors should be validated for correctness.
            Set to ``False`` for faster computations.
        kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info.

    Example:
        >>> from torch import tensor
        >>> from torchmetrics.classification import MulticlassPrecisionAtFixedRecall
        >>> preds = tensor([[0.75, 0.05, 0.05, 0.05, 0.05],
        ...                 [0.05, 0.75, 0.05, 0.05, 0.05],
        ...                 [0.05, 0.05, 0.75, 0.05, 0.05],
        ...                 [0.05, 0.05, 0.05, 0.75, 0.05]])
        >>> target = tensor([0, 1, 3, 2])
        >>> metric = MulticlassPrecisionAtFixedRecall(num_classes=5, min_recall=0.5, thresholds=None)
        >>> metric(preds, target)  # doctest: +NORMALIZE_WHITESPACE
        (tensor([1.0000, 1.0000, 0.2500, 0.2500, 0.0000]),
         tensor([0.7500, 0.7500, 0.0500, 0.0500, nan]))
        >>> mcrafp = MulticlassPrecisionAtFixedRecall(num_classes=5, min_recall=0.5, thresholds=5)
        >>> mcrafp(preds, target)  # doctest: +NORMALIZE_WHITESPACE
        (tensor([1.0000, 1.0000, 0.2500, 0.2500, 0.0000]),
         tensor([0.7500, 0.7500, 0.0000, 0.0000, nan]))

    Fr   Nr   r   r   r    r!   r"   ÚClassÚplot_legend_nameTÚnum_classesr#   r$   r%   r&   r'   r(   c                 óˆ   •—  t          ¦   «         j        d|||ddœ|¤Ž |rt          ||||¦  «         || _        || _        d S )NF)rS   r$   r%   r&   © )r*   r+   r   r&   r#   )r,   rS   r#   r$   r%   r&   r'   r-   s          €r.   r+   z)MulticlassPrecisionAtFixedRecall.__init__  sp   ø€ ð 	�‰ŒÔð 	
Ø#°
ÈÐejð	
ð 	
Øntð	
ð 	
ð 	
ð ð 	tÝ@ÀÈjÐZdÐfrÑsÔsÐsØ*ˆÔØ$ˆŒˆˆr/   c                 ó¾   — | j         €(t          | j        ¦  «        t          | j        ¦  «        fn| j        }t          || j        | j         | j        t          ¬¦  «        S r1   )	r$   r   r3   r4   r5   r   rS   r#   r   r6   s     r.   r8   z(MulticlassPrecisionAtFixedRecall.compute  sZ   € àIMÌÐI`•˜dœjÑ)Ô)­<¸¼Ñ+DÔ+DÐEÐEÐfjÔfrˆÝ@Ø�4Ô# T¤_°d´oÕQeð
ñ 
ô 
ð 	
r/   r9   r:   c                 óf   — |p|                       ¦   «         d         }|                      ||¦  «        S )aŽ  Plot a single or multiple values from the metric.

        Args:
            val: Either a single result from calling `metric.forward` or `metric.compute` or a list of these results.
                If no value is provided, will automatically call `metric.compute` and plot that result.
            ax: An matplotlib axis object. If provided will add plot to that axis

        Returns:
            Figure object and Axes object

        Raises:
            ModuleNotFoundError:
                If `matplotlib` is not installed

        .. plot::
            :scale: 75

            >>> from torch import rand, randint
            >>> # Example plotting a single value per class
            >>> from torchmetrics.classification import MulticlassPrecisionAtFixedRecall
            >>> metric = MulticlassPrecisionAtFixedRecall(num_classes=3, min_recall=0.5)
            >>> metric.update(rand(20, 3).softmax(dim=-1), randint(3, (20,)))
            >>> fig_, ax_ = metric.plot()  # the returned plot only shows the maximum recall value by default

        .. plot::
            :scale: 75

            >>> from torch import rand, randint
            >>> # Example plotting a multiple values per class
            >>> from torchmetrics.classification import MulticlassPrecisionAtFixedRecall
            >>> metric = MulticlassPrecisionAtFixedRecall(num_classes=3, min_recall=0.5)
            >>> values = []
            >>> for _ in range(20):
            ...     # we index by 0 such that only the maximum recall value is plotted
            ...     values.append(metric(rand(20, 3).softmax(dim=-1), randint(3, (20,)))[0])
            >>> fig_, ax_ = metric.plot(values)

        r   r<   r>   s      r.   r?   z%MulticlassPrecisionAtFixedRecall.plot  r@   r/   rA   rB   ©rC   rD   rE   rF   r   rG   rH   r   r   r   r    rI   r"   rR   ÚstrrJ   r   rK   r   r   r+   rL   r8   r   r   r   r?   rM   rN   s   @r.   rP   rP   ¶   s�  ø€ € € € € € ðBð BðH $Ð�tÐ#Ð#Ñ#Ø'+Ð�h˜t”nÐ+Ð+Ñ+Ø#Ð�tÐ#Ð#Ñ#Ø!Ð�eÐ!Ð!Ñ!Ø!Ð�eÐ!Ð!Ñ!Ø#Ð�cÐ#Ð#Ñ#ð AEØ&*Ø"ð%ð %àð%ð ð%ð ˜U 3¨¨U¬°VÐ#;Ô<Ô=ð	%ð
 ˜s”mð%ð ð%ð ð%ð 
ð%ð %ð %ð %ð %ð %ð"
˜˜v v˜~Ô.ð 
ð 
ð 
ð 
ð _cð*#ð *#Ø˜E &¨(°6Ô*:Ð":Ô;Ô<ð*#ØIQÐRZÔI[ð*#à	ð*#ð *#ð *#ð *#ð *#ð *#ð *#ð *#r/   rP   c                   óH  ‡ — e Zd ZU dZdZeed<   dZee         ed<   dZ	eed<   dZ
eed<   d	Zeed
<   dZeed<   	 	 	 ddededeeeee         ef                  dee         dededdfˆ fd„Zdeeef         fd„Z	 ddeeeee         f                  dee         defd„Zˆ xZS )Ú MultilabelPrecisionAtFixedRecallai  Compute the highest possible precision value given the minimum recall thresholds provided.

    This is done by first calculating the precision-recall curve for different thresholds and the find the precision for
    a given recall level.

    As input to ``forward`` and ``update`` the metric accepts the following input:

    - ``preds`` (:class:`~torch.Tensor`): A float tensor of shape ``(N, C, ...)``. Preds should be a tensor
      containing probabilities or logits for each observation. If preds has values outside [0,1] range we consider
      the input to be logits and will auto apply sigmoid per element.
    - ``target`` (:class:`~torch.Tensor`): An int tensor of shape ``(N, ...)``. Target should be a tensor containing
      ground truth labels, and therefore only contain {0,1} values (except if `ignore_index` is specified). The value
      1 always encodes the positive class.

    .. tip::
       Additional dimension ``...`` will be flattened into the batch dimension.

    As output to ``forward`` and ``compute`` the metric returns a tuple of either 2 tensors or 2 lists containing:

    - ``precision`` (:class:`~torch.Tensor`): A 1d tensor of size ``(n_classes, )`` with the maximum precision for the
      given recall level per class
    - ``threshold`` (:class:`~torch.Tensor`): A 1d tensor of size ``(n_classes, )`` with the corresponding threshold
      level per class

    .. note::
       The implementation both supports calculating the metric in a non-binned but accurate version and a binned version
       that is less accurate but more memory efficient. Setting the `thresholds` argument to ``None`` will activate the
       non-binned  version that uses memory of size :math:`\mathcal{O}(n_{samples})` whereas setting the `thresholds`
       argument to either an integer, list or a 1d tensor will use a binned version that uses memory of
       size :math:`\mathcal{O}(n_{thresholds} \times n_{labels})` (constant memory).

    Args:
        num_labels: Integer specifying the number of labels
        min_recall: float value specifying minimum recall threshold.
        thresholds:
            Can be one of:

            - If set to ``None``, will use a non-binned approach where thresholds are dynamically calculated from
              all the data. Most accurate but also most memory consuming approach.
            - If set to an ``int`` (larger than 1), will use that number of thresholds linearly spaced from
              0 to 1 as bins for the calculation.
            - If set to an ``list`` of floats, will use the indicated thresholds in the list as bins for the calculation
            - If set to an 1d :class:`~torch.Tensor` of floats, will use the indicated thresholds in the tensor as
              bins for the calculation.

        validate_args: bool indicating if input arguments and tensors should be validated for correctness.
            Set to ``False`` for faster computations.
        kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info.

    Example:
        >>> from torch import tensor
        >>> from torchmetrics.classification import MultilabelPrecisionAtFixedRecall
        >>> preds = tensor([[0.75, 0.05, 0.35],
        ...                 [0.45, 0.75, 0.05],
        ...                 [0.05, 0.55, 0.75],
        ...                 [0.05, 0.65, 0.05]])
        >>> target = tensor([[1, 0, 1],
        ...                  [0, 0, 0],
        ...                  [0, 1, 1],
        ...                  [1, 1, 1]])
        >>> metric = MultilabelPrecisionAtFixedRecall(num_labels=3, min_recall=0.5, thresholds=None)
        >>> metric(preds, target)
        (tensor([1.0000, 0.6667, 1.0000]), tensor([0.7500, 0.5500, 0.3500]))
        >>> mlrafp = MultilabelPrecisionAtFixedRecall(num_labels=3, min_recall=0.5, thresholds=5)
        >>> mlrafp(preds, target)
        (tensor([1.0000, 0.6667, 1.0000]), tensor([0.7500, 0.5000, 0.2500]))

    Fr   Nr   r   r   r    r!   r"   ÚLabelrR   TÚ
num_labelsr#   r$   r%   r&   r'   r(   c                 óˆ   •—  t          ¦   «         j        d|||ddœ|¤Ž |rt          ||||¦  «         || _        || _        d S )NF)r]   r$   r%   r&   rU   )r*   r+   r   r&   r#   )r,   r]   r#   r$   r%   r&   r'   r-   s          €r.   r+   z)MultilabelPrecisionAtFixedRecall.__init__”  sp   ø€ ð 	�‰ŒÔð 	
Ø!¨jÀ|Ðchð	
ð 	
Ølrð	
ð 	
ð 	
ð ð 	sÝ@ÀÈZÐYcÐeqÑrÔrÐrØ*ˆÔØ$ˆŒˆˆr/   c                 óÊ   — | j         €(t          | j        ¦  «        t          | j        ¦  «        fn| j        }t          || j        | j         | j        | j        t          ¬¦  «        S r1   )
r$   r   r3   r4   r5   r   r]   r%   r#   r   r6   s     r.   r8   z(MultilabelPrecisionAtFixedRecall.compute¥  s^   € àIMÌÐI`•˜dœjÑ)Ô)­<¸¼Ñ+DÔ+DÐEÐEÐfjÔfrˆÝ@Ø�4”? D¤O°TÔ5FÈÌÕcwð
ñ 
ô 
ð 	
r/   r9   r:   c                 óf   — |p|                       ¦   «         d         }|                      ||¦  «        S )a[  Plot a single or multiple values from the metric.

        Args:
            val: Either a single result from calling `metric.forward` or `metric.compute` or a list of these results.
                If no value is provided, will automatically call `metric.compute` and plot that result.
            ax: An matplotlib axis object. If provided will add plot to that axis

        Returns:
            Figure object and Axes object

        Raises:
            ModuleNotFoundError:
                If `matplotlib` is not installed

        .. plot::
            :scale: 75

            >>> from torch import rand, randint
            >>> # Example plotting a single value
            >>> from torchmetrics.classification import MultilabelPrecisionAtFixedRecall
            >>> metric = MultilabelPrecisionAtFixedRecall(num_labels=3, min_recall=0.5)
            >>> metric.update(rand(20, 3), randint(2, (20, 3)))
            >>> fig_, ax_ = metric.plot()  # the returned plot only shows the maximum recall value by default

        .. plot::
            :scale: 75

            >>> from torch import rand, randint
            >>> # Example plotting multiple values
            >>> from torchmetrics.classification import MultilabelPrecisionAtFixedRecall
            >>> metric = MultilabelPrecisionAtFixedRecall(num_labels=3, min_recall=0.5)
            >>> values = [ ]
            >>> for _ in range(10):
            ...     # we index by 0 such that only the maximum recall value is plotted
            ...     values.append(metric(rand(20, 3), randint(2, (20, 3)))[0])
            >>> fig_, ax_ = metric.plot(values)

        r   r<   r>   s      r.   r?   z%MultilabelPrecisionAtFixedRecall.plot¬  r@   r/   rA   rB   rX   rN   s   @r.   r[   r[   G  s�  ø€ € € € € € ðCð CðJ $Ð�tÐ#Ð#Ñ#Ø'+Ð�h˜t”nÐ+Ð+Ñ+Ø#Ð�tÐ#Ð#Ñ#Ø!Ð�eÐ!Ð!Ñ!Ø!Ð�eÐ!Ð!Ñ!Ø#Ð�cÐ#Ð#Ñ#ð AEØ&*Ø"ð%ð %àð%ð ð%ð ˜U 3¨¨U¬°VÐ#;Ô<Ô=ð	%ð
 ˜s”mð%ð ð%ð ð%ð 
ð%ð %ð %ð %ð %ð %ð"
˜˜v v˜~Ô.ð 
ð 
ð 
ð 
ð _cð*#ð *#Ø˜E &¨(°6Ô*:Ð":Ô;Ô<ð*#ØIQÐRZÔI[ð*#à	ð*#ð *#ð *#ð *#ð *#ð *#ð *#ð *#r/   r[   c                   ó´   — e Zd ZdZ	 	 	 	 	 dded          ded         dedeee	e
e         ef                  d	ee	         d
ee	         dee	         dededefd„ZdS )ÚPrecisionAtFixedRecallaÿ  Compute the highest possible recall value given the minimum precision thresholds provided.

    This is done by first calculating the precision-recall curve for different thresholds and the find the recall for
    a given precision level.

    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
    :class:`~torchmetrics.classification.BinaryPrecisionAtFixedRecall`,
    :class:`~torchmetrics.classification.MulticlassPrecisionAtFixedRecall` and
    :class:`~torchmetrics.classification.MultilabelPrecisionAtFixedRecall` for the specific details of each argument
    influence and examples.

    NTÚclsÚtask)ÚbinaryÚ
multiclassÚ
multilabelr#   r$   rS   r]   r%   r&   r'   r(   c                 óè  — t          j        |¦  «        }|t           j        k    rt          ||||fi |¤ŽS |t           j        k    rFt          |t          ¦  «        s t          dt          |¦  «        › d�¦  «        ‚t          |||||fi |¤ŽS |t           j
        k    rFt          |t          ¦  «        s t          dt          |¦  «        › d�¦  «        ‚t          |||||fi |¤ŽS t          d|› d�¦  «        ‚)zInitialize task metric.z+`num_classes` is expected to be `int` but `z was passed.`z*`num_labels` is expected to be `int` but `zTask z not supported!)r   Úfrom_strÚBINARYr   Ú
MULTICLASSÚ
isinstancerJ   Ú
ValueErrorÚtyperP   Ú
MULTILABELr[   )	rc   rd   r#   r$   rS   r]   r%   r&   r'   s	            r.   Ú__new__zPrecisionAtFixedRecall.__new__è  s=  € õ "Ô*¨4Ñ0Ô0ˆØÕ%Ô,Ò,Ð,Ý/°
¸JÈÐVcÐnÐnÐgmÐnÐnÐnØÕ%Ô0Ò0Ð0Ý˜k­3Ñ/Ô/ð qÝ Ð!oÍtÐT_ÑO`ÔO`Ð!oÐ!oÐ!oÑpÔpÐpÝ3Ø˜Z¨°\À=ðð ØTZðð ð ð Õ%Ô0Ò0Ð0Ý˜j­#Ñ.Ô.ð oÝ Ð!mÍdÐS]ÑN^ÔN^Ð!mÐ!mÐ!mÑnÔnÐnÝ3Ø˜J¨
°LÀ-ðð ØSYðð ð õ Ð6 Ð6Ð6Ð6Ñ7Ô7Ð7r/   )NNNNT)rC   rD   rE   rF   rn   r   rI   r   r   rJ   rK   r   rG   r   r   rp   rU   r/   r.   rb   rb   Ù  s×   € € € € € ðð ð$ AEØ%)Ø$(Ø&*Ø"ð8ð 8ØÐ*Ô+ð8àÐ:Ô;ð8ð ð8ð ˜U 3¨¨U¬°VÐ#;Ô<Ô=ð	8ð
 ˜c”]ð8ð ˜S”Mð8ð ˜s”mð8ð ð8ð ð8ð 
ð8ð 8ð 8ð 8ð 8ð 8r/   rb   N))Úcollections.abcr   Útypingr   r   r   Útorchr   Útyping_extensionsr   Ú torchmetrics.classification.baser	   Ú2torchmetrics.classification.precision_recall_curver
   r   r   Ú=torchmetrics.functional.classification.precision_fixed_recallr   Ú=torchmetrics.functional.classification.recall_fixed_precisionr   r   r   r   r   r   Útorchmetrics.metricr   Útorchmetrics.utilities.datar   Útorchmetrics.utilities.enumsr   Útorchmetrics.utilities.importsr   Útorchmetrics.utilities.plotr   r   Ú__doctest_skip__r   rP   r[   rb   rU   r/   r.   ú<module>r      sQ  ðð %Ð $Ð $Ð $Ð $Ð $Ø 'Ð 'Ð 'Ð 'Ð 'Ð 'Ð 'Ð 'Ð 'Ð 'à Ð Ð Ð Ð Ð Ø %Ð %Ð %Ð %Ð %Ð %à GÐ GÐ GÐ GÐ GÐ Gðð ð ð ð ð ð ð ð ð ð
 _Ð ^Ð ^Ð ^Ð ^Ð ^ðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð 'Ð &Ð &Ð &Ð &Ð &Ø 4Ð 4Ð 4Ð 4Ð 4Ð 4Ø ;Ð ;Ð ;Ð ;Ð ;Ð ;Ø @Ð @Ð @Ð @Ð @Ð @Ø @Ð @Ð @Ð @Ð @Ð @Ð @Ð @àð ðð ð ÐðB#ð B#ð B#ð B#ð B#Ð#=ñ B#ô B#ð B#ðJN#ð N#ð N#ð N#ð N#Ð'Eñ N#ô N#ð N#ðbO#ð O#ð O#ð O#ð O#Ð'Eñ O#ô O#ð O#ðd*8ð *8ð *8ð *8ð *8Ð7ñ *8ô *8ð *8ð *8ð *8r/   