a  dZ @sddlmZmZmZmZddlZddlmZddlmZddl m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZddlmZddlmZddlmZdd lm Z d-eeeefeeeefeed eeed d dZ!eeeeeffeeedddZ"d.eeeee#ee$efee#e%edddZ&d/e#eed eee#ee$efee#ddddZ'd0eeeeeffe#eed eeedddZ(d1eee#eed eee#ee$efee#e%edddZ)d2e#eedeee#ee$efee#dd d!d"Z*d3eeeeeffe#eedeeee#ed#d$d%Z+d4eee#eedeee#ee$efee#e%ed&d'd(Z,d5eeed)eee#ee$efee#ee#eed ee#e%eed* d+d,Z-dS)6)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)ClassificationTask)rank_zero_warnmacro)rweightednone) precisionrecallaverageweightsreturncCst|tr\t|tr\t|ddddf|ddddf|ddddfd }ntddt||D}|dus|dkr|St|rtd|dt t|}|d kr|| S|d kr|durt ||||}|||St d dS) z8Reduce multiple average precision score into one number.NcSs<g|]4\}}t|dd|dd|dd qS)r#Nr$)torchsum).0prr*/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/torchmetrics/functional/classification/average_precision.py 5z-_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)rrr r!residxr*r*r+_reduce_average_precision+s"H   r8)state thresholdsr"cCs<t||\}}}t|dd|dd|dd S)Nr#r$)r r%r&)r9r:rr_r*r*r+!_binary_average_precision_computeFsr<T)predstargetr: ignore_index validate_argsr"cCsD|rt||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>r:r?r@r9r*r*r+binary_average_precisionNs B   rA) num_classesr r:r?r"cCs0t|||d}||vr,td|d|dS)N)rrrN)Expected argument `average` to be one of but got )r r5)rBr r:r?allowed_averager*r*r+,_multiclass_average_precision_arg_validations rF)r9rBr r:r"c CsZt|||\}}}t||||dur6t|d|dn|ddddddfddS)Nr#)Z minlengthrr$r!)rr8rfloatr&)r9rBr r:rrr;r*r*r+%_multiclass_average_precision_computes:rI)r=r>rBr r:r?r@r"cCsR|r t||||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 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. 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]) )rFrrrrI)r=r>rBr r:r?r@r9r*r*r+multiclass_average_precisionsS rJ)microrrr) num_labelsr r:r?r"cCs0t|||d}||vr,td|d|dS)N)rKrrrNrCrD)rr5)rLr r:r?rEr*r*r+,_multilabel_average_precision_arg_validations rM)r9rLr r:r?r"c Cs|dkrvt|tr&|dur&|d}nF|d|d}}|durd||k}||}||}||f}t||St||||\}} } t|| ||dur|ddkjddn|ddddddfddS)NrKr#r)Zdimr$rG)r.rr&flattenr<rr8rH) r9rLr r:r?r=r>r7rrr;r*r*r+%_multilabel_average_precision_computes"    >rO)r=r>rLr r:r?r@r"cCsT|r t||||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 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. 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]) )rMrrrrO)r=r>rLr r:r?r@r9r*r*r+multilabel_average_precision8sW rP)binaryZ multiclassZ multilabel) r=r>taskr:rBrLr r?r@r"c Cst|}|tjkr$t|||||S|tjkr`t|tsLtdt|dt |||||||S|tj krt|tstdt|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) rZfrom_strBINARYrAZ MULTICLASSr.intr5typerJZ MULTILABELrP) r=r>rRr:rBrLr r?r@r*r*r+average_precisions-      rV)rN)NNT)rNN)rN)rNNT)NN)N)rNNT)NNNrNT).typingrrrrr%rZtyping_extensionsrZ=torchmetrics.functional.classification.precision_recall_curverr r r r r rrrrrrrrrZtorchmetrics.utilities.computerZtorchmetrics.utilities.datarZtorchmetrics.utilities.enumsrZtorchmetrics.utilities.printsrr8r<rTrHboolrArFrIrJrMrOrPrVr*r*r*r+s  D        L      `      e