o .wiZ@s|ddlmZmZmZddlZddlmZddlmZddlm Z m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZddlmZddlmZddlmZdd lmZ d1d eeeefd eeeefd eeddeedef ddZ deee!eeffdeedefddZ"   d2dededeee#e$e%efdee#de&def ddZ'  d3de#d eeddeee#e$e%efdee#ddf dd Z( d1deee!eeffde#d eeddeedef d!d"Z)   d4dedede#d eeddeee#e$e%efdee#de&defd#d$Z*  d5d%e#d eed&deee#e$e%efdee#ddf d'd(Z+ d6deee!eeffd%e#d eed&deedee#def d)d*Z,   d4deded%e#d eed&deee#e$e%efdee#de&defd+d,Z-     d7deded-ed.deee#e$e%efdee#d%ee#d eeddee#de&deefd/d0Z.dS)8)ListOptionalUnionN)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)ClassificationTask)rank_zero_warnmacro precisionrecallaverage)rweightednoneweightsreturncCst|tr.t|tr.t|ddddf|ddddf|ddddfd }n tddt||D}|dusC|dkrE|St|rUtd|dt t|}|d kre|| S|d kr|durt ||||}|||St d ) z8Reduce multiple average precision score into one number.NcSs<g|]\}}t|dd|dd|dd qS)r"Nr#)torchsum).0prr)u/home/ubuntu/sommelier/.venv/lib/python3.10/site-packages/torchmetrics/functional/classification/average_precision.py 5s<z-_reduce_average_precision..rzUAverage precision score for one or more classes was `nan`. Ignoring these classes in z-averagerrzBReceived an incompatible combinations of inputs to make reduction.) isinstancerr$r%stackzipisnananyr UserWarningmeanr ValueError)rrrr residxr)r)r*_reduce_average_precision+s"H   r6state thresholdscCs<t||\}}}t|dd|dd|dd S)Nr"r#)rr$r%)r7r8rr_r)r)r*!_binary_average_precision_computeFs,r:Tpredstarget ignore_index validate_argscCsD|r t||t|||t||||\}}}t|||}t||S)a Compute 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. 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: 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 r:)r;r<r8r=r>r7r)r)r*binary_average_precisionNs B    r? num_classescC0t|||d}||vrtd|d|dS)N)rrrN)Expected argument `average` to be one of but got )r r3)r@rr8r=allowed_averager)r)r*,_multiclass_average_precision_arg_validation rEc Cs^t|||\}}}t||||durt|d|ddS|ddddddfddS)Nr") minlengthrr#r )r r6rfloatr%)r7r@rr8rrr9r)r)r*%_multiclass_average_precision_computesrJcCsR|rt||||t||||t|||||\}}}t||||}t||||S)aCompute 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 specifying 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. 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 `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]) )rErrrrJ)r;r<r@rr8r=r>r7r)r)r*multiclass_average_precisionsS  rK num_labels)microrrrcCrA)N)rMrrrNrBrC)rr3)rLrr8r=rDr)r)r*,_multilabel_average_precision_arg_validationrFrNc Cs|dkr;t|tr|dur|d}n#|d|d}}|dur2||k}||}||}||f}t||St||||\}} } t|| ||dur[|ddkjdddS|ddddddfddS)NrMr"r)dimr#rH)r,rr%flattenr:rr6rI) r7rLrr8r=r;r<r5rrr9r)r)r*%_multilabel_average_precision_computes&    rQcCsT|rt||||t||||t|||||\}}}t||||}t|||||S)aCompute 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 specifying 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. 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 `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]) )rNrrrrQ)r;r<rLrr8r=r>r7r)r)r*multilabel_average_precision8sW  rRtask)binary multiclass multilabelc Cst|}|tjkrt|||||S|tjkr0t|ts&tdt|dt |||||||S|tj krNt|tsDtdt|dt |||||||SdS)aCompute 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:`~torchmetrics.functional.classification.binary_average_precision`, :func:`~torchmetrics.functional.classification.multiclass_average_precision` and :func:`~torchmetrics.functional.classification.multilabel_average_precision` for the specific details of each argument influence and examples. Legacy Example: >>> from torchmetrics.functional.classification 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]) z+`num_classes` is expected to be `int` but `z was passed.`z*`num_labels` is expected to be `int` but `N) rfrom_strBINARYr? MULTICLASSr,intr3typerK MULTILABELrR) r;r<rSr8r@rLrr=r>r)r)r*average_precisions -     r])rN)NNT)rNN)rNNT)NN)N)NNNrNT)/typingrrrr$rtyping_extensionsr=torchmetrics.functional.classification.precision_recall_curverrr r r r r rrrrrrrrtorchmetrics.utilities.computertorchmetrics.utilities.datartorchmetrics.utilities.enumsrtorchmetrics.utilities.printsrr6tupler:rZlistrIboolr?rErJrKrNrQrRr]r)r)r)r*sP   D         L      `       e