o yiYI@sddlmZmZmZmZddlZddlmZddlmZddl m Z m Z m Z ddl mZmZmZmZmZmZddlmZddlmZGd d d e ZGd d d e ZGd dde ZGdddZdS))AnyListOptionalUnionN)Tensor)Literal)BinaryPrecisionRecallCurveMulticlassPrecisionRecallCurveMultilabelPrecisionRecallCurve)_binary_auroc_arg_validation_binary_auroc_compute _multiclass_auroc_arg_validation_multiclass_auroc_compute _multilabel_auroc_arg_validation_multilabel_auroc_compute)Metric) dim_zero_catc seZdZUdZdZeed<dZeeed<dZ eed<    ddee d ee e e e efd ee d ed ed df fdd Zd efddZZS) BinaryAUROCaB Compute Area Under the Receiver Operating Characteristic Curve (`ROC AUC`_) for binary tasks. The AUROC score summarizes the ROC curve into an single number that describes the performance of a model for multiple thresholds at the same time. Notably, an AUROC score of 1 is a perfect score and an AUROC score of 0.5 corresponds to random guessing. 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: - ``b_auroc`` (:class:`~torch.Tensor`): A single scalar with the auroc 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: max_fpr: If not ``None``, calculates standardized partial AUC over the range ``[0, max_fpr]``. 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 BinaryAUROC >>> preds = torch.tensor([0, 0.5, 0.7, 0.8]) >>> target = torch.tensor([0, 1, 1, 0]) >>> metric = BinaryAUROC(thresholds=None) >>> metric(preds, target) tensor(0.5000) >>> b_auroc = BinaryAUROC(thresholds=5) >>> b_auroc(preds, target) tensor(0.5000) Fis_differentiableNhigher_is_betterfull_state_updateTmax_fpr thresholds ignore_index validate_argskwargsreturnc s4tjd||dd||rt|||||_dS)NFrrr)super__init__r r)selfrrrrr __class__rU/home/ubuntu/.local/lib/python3.10/site-packages/torchmetrics/classification/auroc.pyr `s  zBinaryAUROC.__init__cCs6|jdurt|jt|jg}n|j}t||j|jSN)rrpredstargetconfmatr rr!staterrr$computems zBinaryAUROC.compute)NNNT)__name__ __module__ __qualname____doc__rbool__annotations__rrrfloatrintrrrr r+ __classcell__rrr"r$r%s.  6  rceZdZUdZdZeed<dZeeed<dZ eed<    dd e d ee d d ee e e eefd ee dededdffdd ZdefddZZS)MulticlassAUROCaCompute Area Under the Receiver Operating Characteristic Curve (`ROC AUC`_) for multiclass tasks. The AUROC score summarizes the ROC curve into an single number that describes the performance of a model for multiple thresholds at the same time. Notably, an AUROC score of 1 is a perfect score and an AUROC score of 0.5 corresponds to random guessing. 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: - ``mc_auroc`` (:class:`~torch.Tensor`): If `average=None|"none"` then a 1d tensor of shape (n_classes, ) will be returned with auroc 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 MulticlassAUROC >>> 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 = MulticlassAUROC(num_classes=5, average="macro", thresholds=None) >>> metric(preds, target) tensor(0.5333) >>> mc_auroc = MulticlassAUROC(num_classes=5, average=None, thresholds=None) >>> mc_auroc(preds, target) tensor([1.0000, 1.0000, 0.3333, 0.3333, 0.0000]) >>> mc_auroc = MulticlassAUROC(num_classes=5, average="macro", thresholds=5) >>> mc_auroc(preds, target) tensor(0.5333) >>> mc_auroc = MulticlassAUROC(num_classes=5, average=None, thresholds=5) >>> mc_auroc(preds, target) tensor([1.0000, 1.0000, 0.3333, 0.3333, 0.0000]) FrNrrmacroT num_classesaverager7weightednonerrrrrc >tjd|||dd||rt||||||_||_dS)NF)r8rrrr)rr r r9r)r!r8r9rrrrr"rr$r   zMulticlassAUROC.__init__cCs:|jdurt|jt|jg}n|j}t||j|j|jSr%)rrr&r'r(rr8r9r)rrr$r+s zMulticlassAUROC.computer7NNTr,r-r.r/rr0r1rrrr3rrrr2rrr r+r4rrr"r$r6us2  G  r6cr5)MultilabelAUROCa Compute Area Under the Receiver Operating Characteristic Curve (`ROC AUC`_) for multilabel tasks. The AUROC score summarizes the ROC curve into an single number that describes the performance of a model for multiple thresholds at the same time. Notably, an AUROC score of 1 is a perfect score and an AUROC score of 0.5 corresponds to random guessing. 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: - ``ml_auroc`` (:class:`~torch.Tensor`): If `average=None|"none"` then a 1d tensor of shape (n_classes, ) will be returned with auroc 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 MultilabelAUROC >>> 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]]) >>> ml_auroc = MultilabelAUROC(num_labels=3, average="macro", thresholds=None) >>> ml_auroc(preds, target) tensor(0.6528) >>> ml_auroc = MultilabelAUROC(num_labels=3, average=None, thresholds=None) >>> ml_auroc(preds, target) tensor([0.6250, 0.5000, 0.8333]) >>> ml_auroc = MultilabelAUROC(num_labels=3, average="macro", thresholds=5) >>> ml_auroc(preds, target) tensor(0.6528) >>> ml_auroc = MultilabelAUROC(num_labels=3, average=None, thresholds=5) >>> ml_auroc(preds, target) tensor([0.6250, 0.5000, 0.8333]) FrNrrr7T num_labelsr9)micror7r;r<rrrrrc r=)NF)rBrrrr)rr rr9r)r!rBr9rrrrr"rr$r (r>zMultilabelAUROC.__init__cCs>|jdurt|jt|jg}n|j}t||j|j|j|jSr%) rrr&r'r(rrBr9rr)rrr$r+9s zMultilabelAUROC.computer?r@rrr"r$rAs2  I  rAc@seZdZdZ       ddeddeeeee e fdeed eed eed d ee d eede de de fddZdS)AUROCafCompute Area Under the Receiver Operating Characteristic Curve (`ROC AUC`_). The AUROC score summarizes the ROC curve into an single number that describes the performance of a model for multiple thresholds at the same time. Notably, an AUROC score of 1 is a perfect score and an AUROC score of 0.5 corresponds to random guessing. This module 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:`BinaryAUROC`, :mod:`MulticlassAUROC` and :mod:`MultilabelAUROC` for the specific details of each argument influence and examples. Legacy Example: >>> preds = torch.tensor([0.13, 0.26, 0.08, 0.19, 0.34]) >>> target = torch.tensor([0, 0, 1, 1, 1]) >>> auroc = AUROC(task="binary") >>> auroc(preds, target) tensor(0.5000) >>> preds = torch.tensor([[0.90, 0.05, 0.05], ... [0.05, 0.90, 0.05], ... [0.05, 0.05, 0.90], ... [0.85, 0.05, 0.10], ... [0.10, 0.10, 0.80]]) >>> target = torch.tensor([0, 1, 1, 2, 2]) >>> auroc = AUROC(task="multiclass", num_classes=3) >>> auroc(preds, target) tensor(0.7778) Nr7Ttask)binary multiclass multilabelrr8rBr9r:rrrrrc Ks| t|||d|dkrt|fi| S|dkr*t|ts!Jt||fi| S|dkr>t|ts5Jt||fi| Std|)NrrFrGrHz[Expected argument `task` to either be `'binary'`, `'multiclass'` or `'multilabel'` but got )updatedictr isinstancer3r6rA ValueError) clsrErr8rBr9rrrrrrr$__new__]s z AUROC.__new__)NNNr7NNT)r,r-r.r/rrrr3rr2rr0rrrNrrrr$rDAs<    rD)typingrrrrtorchrtyping_extensionsr2torchmetrics.classification.precision_recall_curverr r ,torchmetrics.functional.classification.aurocr r r rrrtorchmetrics.metricrtorchmetrics.utilities.datarrr6rArDrrrr$s      Peg