o yiX@sddlmZmZmZmZddlZddlmZddlmZddl m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZddlmZddlmZddlmZ d0d eeeefd eeeefd eed deedef ddZdeeeeeffdeedefddZ   d1dededeee!ee"efdee!de#def ddZ$  d2de!d eed deee!ee"efdee!ddf ddZ% d0deeeeeffde!d eed deedef d d!Z&   d3dedede!d eed deee!ee"efdee!de#defd"d#Z'  d4d$e!d eed%deee!ee"efdee!ddf d&d'Z( d5deeeeeffd$e!d eed%deedee!deeeeefeeeeeeefff d(d)Z)   d3deded$e!d eed%deee!ee"efdee!de#defd*d+Z*     d6deded,ed-deee!ee"efdee!d$ee!d eed dee!de#deeeeffd.d/Z+dS)7)ListOptionalTupleUnionN)Tensor)Literal)-_binary_precision_recall_curve_arg_validation&_binary_precision_recall_curve_compute%_binary_precision_recall_curve_format0_binary_precision_recall_curve_tensor_validation%_binary_precision_recall_curve_update1_multiclass_precision_recall_curve_arg_validation*_multiclass_precision_recall_curve_compute)_multiclass_precision_recall_curve_format4_multiclass_precision_recall_curve_tensor_validation)_multiclass_precision_recall_curve_update1_multilabel_precision_recall_curve_arg_validation*_multilabel_precision_recall_curve_compute)_multilabel_precision_recall_curve_format4_multilabel_precision_recall_curve_tensor_validation)_multilabel_precision_recall_curve_update) _safe_divide) _bincount)rank_zero_warnmacro precisionrecallaverage)rweightednoneweightsreturnc CsBg}t|tr0t|tr0t|ddddf|ddddf|ddddfd }n(t||D]\}}|t|dd|dd|dd q5t|}|dus`|dkrb|St|rrt d|dt t|}|dkr|| S|dkr|durt ||||}|||St d ) zOUtility function for reducing multiple average precision score into one number.NrzUAverage precision score for one or more classes was `nan`. Ignoring these classes in z-averagerrzBReceived an incompatible combinations of inputs to make reduction.) isinstancertorchsumzipappendstackisnananyr UserWarningmeanr ValueError)rrrr respridxr3l/home/ubuntu/.local/lib/python3.10/site-packages/torchmetrics/functional/classification/average_precision.py_reduce_average_precision*s(H4    r5state thresholdscCs<t||\}}}t|dd|dd|dd S)Nr"r#)r r%r&)r6r7rr_r3r3r4!_binary_average_precision_computeIs,r9Tpredstarget ignore_index validate_argscCsD|r t||t|||t||||\}}}t|||}t||S)a Computes the average precision (AP) score for binary tasks. The AP score summarizes a precision-recall curve as an weighted mean of precisions at each threshold, with the difference in recall from the previous threshold as weight: .. math:: AP = \sum{n} (R_n - R_{n-1}) P_n where :math:`P_n, R_n` is the respective precision and recall at threshold index :math:`n`. This value is equivalent to the area under the precision-recall curve (AUPRC). Accepts the following input tensors: - ``preds`` (float tensor): ``(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`` (int tensor): ``(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. Additional dimension ``...`` will be flattened into the batch dimension. 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: preds: Tensor with predictions target: Tensor with true labels 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 `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. Returns: A single scalar with the average precision score Example: >>> from torchmetrics.functional.classification import binary_average_precision >>> preds = torch.tensor([0, 0.5, 0.7, 0.8]) >>> target = torch.tensor([0, 1, 1, 0]) >>> binary_average_precision(preds, target, thresholds=None) tensor(0.5833) >>> binary_average_precision(preds, target, thresholds=5) tensor(0.6667) )rr r r r9)r:r;r7r<r=r6r3r3r4binary_average_precisionQs ?    r> num_classescC0t|||d}||vrtd|d|dS)N)rrrN)Expected argument `average` to be one of but got )r r.)r?rr7r<allowed_averager3r3r4,_multiclass_average_precision_arg_validation rDc Cs^t|||\}}}t||||durt|d|ddS|ddddddfddS)Nr") minlengthrr#r )rr5rfloatr&)r6r?rr7rrr8r3r3r4%_multiclass_average_precision_computesrIcCsR|rt||||t||||t|||||\}}}t||||}t||||S)aDComputes the average precision (AP) score for multiclass tasks. The AP score summarizes a precision-recall curve as an weighted mean of precisions at each threshold, with the difference in recall from the previous threshold as weight: .. math:: AP = \sum{n} (R_n - R_{n-1}) P_n where :math:`P_n, R_n` is the respective precision and recall at threshold index :math:`n`. This value is equivalent to the area under the precision-recall curve (AUPRC). Accepts the following input tensors: - ``preds`` (float tensor): ``(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`` (int tensor): ``(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). Additional dimension ``...`` will be flattened into the batch dimension. 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: preds: Tensor with predictions target: Tensor with true labels num_classes: Integer specifing the number of classes average: Defines the reduction that is applied over classes. Should be one of the following: - ``macro``: Calculate score for each class and average them - ``weighted``: Calculates score for each class and computes weighted average using their support - ``"none"`` or ``None``: Calculates score for each class and applies no reduction 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 `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. Returns: If `average=None|"none"` then a 1d tensor of shape (n_classes, ) will be returned with AP score per class. If `average="macro"|"weighted"` then a single scalar is returned. Example: >>> from torchmetrics.functional.classification import multiclass_average_precision >>> preds = torch.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 = torch.tensor([0, 1, 3, 2]) >>> multiclass_average_precision(preds, target, num_classes=5, average="macro", thresholds=None) tensor(0.6250) >>> multiclass_average_precision(preds, target, num_classes=5, average=None, thresholds=None) tensor([1.0000, 1.0000, 0.2500, 0.2500, nan]) >>> multiclass_average_precision(preds, target, num_classes=5, average="macro", thresholds=5) tensor(0.5000) >>> multiclass_average_precision(preds, target, num_classes=5, average=None, thresholds=5) tensor([1.0000, 1.0000, 0.2500, 0.2500, -0.0000]) )rDrrrrI)r:r;r?rr7r<r=r6r3r3r4multiclass_average_precisionsO  rJ num_labels)microrrrcCr@)N)rLrrrNrArB)rr.)rKrr7r<rCr3r3r4,_multilabel_average_precision_arg_validation rErMc Cs|dkr;t|tr|dur|d}n#|d|d}}|dur2||k}||}||}||g}t||St||||\}} } t|| ||dur[|ddkjdddS|ddddddfddS)NrLr"r)dimr#rG)r$rr&flattenr9rr5rH) r6rKrr7r<r:r;r2rrr8r3r3r4%_multilabel_average_precision_computes&    rPcCsT|rt||||t||||t|||||\}}}t||||}t|||||S)aComputes the average precision (AP) score for multilabel tasks. The AP score summarizes a precision-recall curve as an weighted mean of precisions at each threshold, with the difference in recall from the previous threshold as weight: .. math:: AP = \sum{n} (R_n - R_{n-1}) P_n where :math:`P_n, R_n` is the respective precision and recall at threshold index :math:`n`. This value is equivalent to the area under the precision-recall curve (AUPRC). Accepts the following input tensors: - ``preds`` (float tensor): ``(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`` (int tensor): ``(N, C, ...)``. Target should be a tensor containing ground truth labels, and therefore only contain {0,1} values (except if `ignore_index` is specified). Additional dimension ``...`` will be flattened into the batch dimension. 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: preds: Tensor with predictions target: Tensor with true labels num_labels: Integer specifing the number of labels average: Defines the reduction that is applied over labels. Should be one of the following: - ``micro``: Sum score over all labels - ``macro``: Calculate score for each label and average them - ``weighted``: Calculates score for each label and computes weighted average using their support - ``"none"`` or ``None``: Calculates score for each label and applies no reduction 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 `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. Returns: If `average=None|"none"` then a 1d tensor of shape (n_classes, ) will be returned with AP score per class. If `average="micro|macro"|"weighted"` then a single scalar is returned. Example: >>> from torchmetrics.functional.classification import multilabel_average_precision >>> preds = torch.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 = torch.tensor([[1, 0, 1], ... [0, 0, 0], ... [0, 1, 1], ... [1, 1, 1]]) >>> multilabel_average_precision(preds, target, num_labels=3, average="macro", thresholds=None) tensor(0.7500) >>> multilabel_average_precision(preds, target, num_labels=3, average=None, thresholds=None) tensor([0.7500, 0.5833, 0.9167]) >>> multilabel_average_precision(preds, target, num_labels=3, average="macro", thresholds=5) tensor(0.7778) >>> multilabel_average_precision(preds, target, num_labels=3, average=None, thresholds=5) tensor([0.7500, 0.6667, 0.9167]) )rMrrrrP)r:r;rKrr7r<r=r6r3r3r4multilabel_average_precision4sS  rQtask)binary multiclass multilabelc Csz|dkr t|||||S|dkr!t|tsJt|||||||S|dkr6t|ts,Jt|||||||Std|)a;Computes the average precision (AP) score. The AP score summarizes a precision-recall curve as an weighted mean of precisions at each threshold, with the difference in recall from the previous threshold as weight: .. math:: AP = \sum{n} (R_n - R_{n-1}) P_n where :math:`P_n, R_n` is the respective precision and recall at threshold index :math:`n`. This value is equivalent to the area under the precision-recall curve (AUPRC). 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:`binary_average_precision`, :func:`multiclass_average_precision` and :func:`multilabel_average_precision` for the specific details of each argument influence and examples. Legacy Example: >>> from torchmetrics.functional import average_precision >>> pred = torch.tensor([0.0, 1.0, 2.0, 3.0]) >>> target = torch.tensor([0, 1, 1, 1]) >>> average_precision(pred, target, task="binary") tensor(1.) >>> pred = torch.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 = torch.tensor([0, 1, 3, 2]) >>> average_precision(pred, target, task="multiclass", num_classes=5, average=None) tensor([1.0000, 1.0000, 0.2500, 0.2500, nan]) rSrTrUz[Expected argument `task` to either be `'binary'`, `'multiclass'` or `'multilabel'` but got )r>r$intrJrQr.) r:r;rRr7r?rKrr<r=r3r3r4average_precisions(rW)rN)NNT)rNN)rNNT)NN)N)NNNrNT),typingrrrrr%rtyping_extensionsr=torchmetrics.functional.classification.precision_recall_curverr r r r r rrrrrrrrrtorchmetrics.utilities.computertorchmetrics.utilities.datartorchmetrics.utilities.printsrr5r9rVrHboolr>rDrIrJrMrPrQrWr3r3r3r4sN   D        I      \   *    a