o yiJ@sddlmZmZmZmZddlZddlmZddlmZddl m Z m Z m Z ddl mZmZmZmZmZddlmZddlmZGd d d e ZGd d d e ZGd dde ZGdddZdS))AnyListOptionalUnionN)Tensor)Literal)BinaryPrecisionRecallCurveMulticlassPrecisionRecallCurveMultilabelPrecisionRecallCurve)!_binary_average_precision_compute,_multiclass_average_precision_arg_validation%_multiclass_average_precision_compute,_multilabel_average_precision_arg_validation%_multilabel_average_precision_compute)Metric) dim_zero_catc@sHeZdZUdZdZeed<dZeeed<dZ eed<de fdd Z dS) BinaryAveragePrecisionap 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). As input to ``forward`` and ``update`` the metric accepts the following input: - ``preds`` (:class:`~torch.Tensor`): A float tensor of shape ``(N, ...)`` 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, ...)`` 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. As output to ``forward`` and ``compute`` the metric returns the following output: - ``bap`` (:class:`~torch.Tensor`): A single scalar with the average precision score 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: 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. kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info. Example: >>> from torchmetrics.classification import BinaryAveragePrecision >>> preds = torch.tensor([0, 0.5, 0.7, 0.8]) >>> target = torch.tensor([0, 1, 1, 0]) >>> metric = BinaryAveragePrecision(thresholds=None) >>> metric(preds, target) tensor(0.5833) >>> bap = BinaryAveragePrecision(thresholds=5) >>> bap(preds, target) tensor(0.6667) Fis_differentiableNhigher_is_betterfull_state_updatereturncCs2|jdurt|jt|jg}n|j}t||jSN) thresholdsrpredstargetconfmatr selfstatera/home/ubuntu/.local/lib/python3.10/site-packages/torchmetrics/classification/average_precision.pycomputecs  zBinaryAveragePrecision.compute) __name__ __module__ __qualname____doc__rbool__annotations__rrrrr!rrrr r$s  : rceZdZUdZdZeed<dZeeed<dZ eed<    dd e d ee d d ee e e eefd ee dededdffdd ZdefddZZS)MulticlassAveragePrecisiona: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). As input to ``forward`` and ``update`` the metric accepts the following input: - ``preds`` (:class:`~torch.Tensor`): A float tensor of shape ``(N, C, ...)`` 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, ...)`` containing ground truth labels, and therefore only contain values in the [0, n_classes-1] range (except if `ignore_index` is specified). As output to ``forward`` and ``compute`` the metric returns the following output: - ``mcap`` (:class:`~torch.Tensor`): 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. 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: 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. kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info. Example: >>> from torchmetrics.classification import MulticlassAveragePrecision >>> 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]) >>> metric = MulticlassAveragePrecision(num_classes=5, average="macro", thresholds=None) >>> metric(preds, target) tensor(0.6250) >>> mcap = MulticlassAveragePrecision(num_classes=5, average=None, thresholds=None) >>> mcap(preds, target) tensor([1.0000, 1.0000, 0.2500, 0.2500, nan]) >>> mcap = MulticlassAveragePrecision(num_classes=5, average="macro", thresholds=5) >>> mcap(preds, target) tensor(0.5000) >>> mcap = MulticlassAveragePrecision(num_classes=5, average=None, thresholds=5) >>> mcap(preds, target) tensor([1.0000, 1.0000, 0.2500, 0.2500, -0.0000]) FrNrrmacroT num_classesaverager*weightednoner ignore_index validate_argskwargsrc >tjd|||dd||rt||||||_||_dS)NF)r+rr0r1r)super__init__r r,r1)rr+r,rr0r1r2 __class__rr r5  z#MulticlassAveragePrecision.__init__cCs:|jdurt|jt|jg}n|j}t||j|j|jSr)rrrrrr r+r,rrrr r!s z"MulticlassAveragePrecision.computer*NNTr"r#r$r%rr&r'rrrintrrrfloatrrr5r! __classcell__rrr6r r)ks2  K  r)cr()MultilabelAveragePrecisionaComputes 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). As input to ``forward`` and ``update`` the metric accepts the following input: - ``preds`` (:class:`~torch.Tensor`): A float tensor of shape ``(N, C, ...)`` 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, C, ...)`` containing ground truth labels, and therefore only contain {0,1} values (except if `ignore_index` is specified). As output to ``forward`` and ``compute`` the metric returns the following output: - ``mlap`` (:class:`~torch.Tensor`): 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. 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: 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. kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info. Example: >>> from torchmetrics.classification import MultilabelAveragePrecision >>> 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]]) >>> metric = MultilabelAveragePrecision(num_labels=3, average="macro", thresholds=None) >>> metric(preds, target) tensor(0.7500) >>> mlap = MultilabelAveragePrecision(num_labels=3, average=None, thresholds=None) >>> mlap(preds, target) tensor([0.7500, 0.5833, 0.9167]) >>> mlap = MultilabelAveragePrecision(num_labels=3, average="macro", thresholds=5) >>> mlap(preds, target) tensor(0.7778) >>> mlap = MultilabelAveragePrecision(num_labels=3, average=None, thresholds=5) >>> mlap(preds, target) tensor([0.7500, 0.6667, 0.9167]) FrNrrr*T num_labelsr,)micror*r.r/rr0r1r2rc r3)NF)r?rr0r1r)r4r5rr,r1)rr?r,rr0r1r2r6rr r5'r8z#MultilabelAveragePrecision.__init__cCs>|jdurt|jt|jg}n|j}t||j|j|j|jSr) rrrrrrr?r,r0rrrr r!8s z"MultilabelAveragePrecision.computer9r:rrr6r r>s2  N  r>c@sveZdZdZ      ddeddeeeee e fdeed eed eed d eed e de de fddZdS)AveragePrecisionaQComputes 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 :mod:`BinaryAveragePrecision`, :mod:`MulticlassAveragePrecision` and :mod:`MultilabelAveragePrecision` for the specific details of each argument influence and examples. Legacy Example: >>> pred = torch.tensor([0, 0.1, 0.8, 0.4]) >>> target = torch.tensor([0, 1, 1, 1]) >>> average_precision = AveragePrecision(task="binary") >>> average_precision(pred, target) 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 = AveragePrecision(task="multiclass", num_classes=5, average=None) >>> average_precision(pred, target) tensor([1.0000, 1.0000, 0.2500, 0.2500, nan]) Nr*Ttask)binary multiclass multilabelrr+r?r,r-r0r1r2rc Ks|t|||d|dkrtdi|S|dkr)t|ts Jt||fi|S|dkr=t|ts4Jt||fi|Std|)N)rr0r1rCrDrEz[Expected argument `task` to either be `'binary'`, `'multiclass'` or `'multilabel'` but got r)updatedictr isinstancer;r)r> ValueError) clsrBrr+r?r,r0r1r2rrr __new__bs zAveragePrecision.__new__)NNNr*NT)r"r#r$r%rrrr;rr<rr&rrrKrrrr rABs6"   rA)typingrrrrtorchrtyping_extensionsr2torchmetrics.classification.precision_recall_curverr r 8torchmetrics.functional.classification.average_precisionr r r rrtorchmetrics.metricrtorchmetrics.utilities.datarrr)r>rArrrr s     Gin