a  da@sddlmZmZmZmZmZddlmZddlm Z ddl m Z ddl m Z mZmZddlmZmZmZmZmZmZddlmZddlmZdd lmZdd lmZdd lm Z m!Z!esgd Z"Gd dde Z#GdddeZ$GdddeZ%Gddde Z&dS))AnyListOptionalSequenceUnion)Tensor)Literal)_ClassificationTaskWrapper)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_cat)ClassificationTask)_MATPLOTLIB_AVAILABLE)_AX_TYPE_PLOT_OUT_TYPE)BinaryAUROC.plotMulticlassAUROC.plotMultilabelAUROC.plotcseZdZUdZdZeed<dZeed<dZeed<dZ e ed<d Z e ed <de e e e eee efe eeed d fd d ZedddZde e eeefe eedddZZS) BinaryAUROCa] 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 torch import tensor >>> from torchmetrics.classification import BinaryAUROC >>> preds = tensor([0, 0.5, 0.7, 0.8]) >>> target = 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_differentiableThigher_is_betterfull_state_updateplot_lower_bound?plot_upper_boundN)max_fpr thresholds ignore_index validate_argskwargsreturnc s4tjf||dd||r*t|||||_dS)NFr%r&r')super__init__r r$)selfr$r%r&r'r( __class__j/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/torchmetrics/classification/auroc.pyr,ks zBinaryAUROC.__init__r)cCs4|jdurt|jt|jfn|j}t||j|jSCompute metric.N)r%rpredstargetconfmatrr$r-stater0r0r1computexs$zBinaryAUROC.computevalaxr)cCs |||S)aPlot a single or multiple values from the metric. Args: val: Either a single result from calling `metric.forward` or `metric.compute` or a list of these results. If no value is provided, will automatically call `metric.compute` and plot that result. ax: An matplotlib axis object. If provided will add plot to that axis Returns: Figure and Axes object Raises: ModuleNotFoundError: If `matplotlib` is not installed .. plot:: :scale: 75 >>> # Example plotting a single >>> import torch >>> from torchmetrics.classification import BinaryAUROC >>> metric = BinaryAUROC() >>> metric.update(torch.rand(20,), torch.randint(2, (20,))) >>> fig_, ax_ = metric.plot() .. plot:: :scale: 75 >>> # Example plotting multiple values >>> import torch >>> from torchmetrics.classification import BinaryAUROC >>> metric = BinaryAUROC() >>> values = [ ] >>> for _ in range(10): ... values.append(metric(torch.rand(20,), torch.randint(2, (20,)))) >>> fig_, ax_ = metric.plot(values) Z_plotr-r<r=r0r0r1plot}s(r)NNNT)NN)__name__ __module__ __qualname____doc__rbool__annotations__rrr!floatr#rrintrrrr,r:rrrr@ __classcell__r0r0r.r1r+s0 9      rc seZdZUdZdZeed<dZeed<dZeed<dZ e ed<d Z e ed <d Z e ed <deeedeeeee efeeeeddfdd ZedddZdeeeeefeeedddZZS)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 torch import tensor >>> from torchmetrics.classification import MulticlassAUROC >>> preds = 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 = 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]) FrTrrr r!r"r#ZClassplot_legend_namemacroNrLweightednone) num_classesaverager%r&r'r(r)c s>tjf|||dd||r.t||||||_||_dS)NF)rPr%r&r')r+r,rrQr')r-rPrQr%r&r'r(r.r0r1r,s zMulticlassAUROC.__init__r2cCs8|jdurt|jt|jfn|j}t||j|j|jSr3)r%rr5r6r7rrPrQr8r0r0r1r: s$zMulticlassAUROC.computer;cCs |||S)a=Plot a single or multiple values from the metric. Args: val: Either a single result from calling `metric.forward` or `metric.compute` or a list of these results. If no value is provided, will automatically call `metric.compute` and plot that result. ax: An matplotlib axis object. If provided will add plot to that axis Returns: Figure and Axes object Raises: ModuleNotFoundError: If `matplotlib` is not installed .. plot:: :scale: 75 >>> # Example plotting a single >>> import torch >>> from torchmetrics.classification import MulticlassAUROC >>> metric = MulticlassAUROC(num_classes=3) >>> metric.update(torch.randn(20, 3), torch.randint(3,(20,))) >>> fig_, ax_ = metric.plot() .. plot:: :scale: 75 >>> # Example plotting multiple values >>> import torch >>> from torchmetrics.classification import MulticlassAUROC >>> metric = MulticlassAUROC(num_classes=3) >>> values = [ ] >>> for _ in range(10): ... values.append(metric(torch.randn(20, 3), torch.randint(3, (20,)))) >>> fig_, ax_ = metric.plot(values) r>r?r0r0r1r@s(r)rLNNT)NNrArBrCrDrrErFrrr!rGr#rKstrrHrrrrrrr,r:rrrr@rIr0r0r.r1rJs4 J       rJc seZdZUdZdZeed<dZeed<dZeed<dZ e ed<d Z e ed <d Z e ed <deeedeeeee efeeeeddfdd ZedddZdeeeeefeeedddZZS)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 torch import tensor >>> from torchmetrics.classification import MultilabelAUROC >>> preds = 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 = 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]) FrTrrr r!r"r#ZLabelrKrLN)microrLrNrO) num_labelsrQr%r&r'r(r)c s>tjf|||dd||r.t||||||_||_dS)NF)rVr%r&r')r+r,rrQr')r-rVrQr%r&r'r(r.r0r1r,s zMultilabelAUROC.__init__r2cCs<|jdurt|jt|jfn|j}t||j|j|j|jSr3) r%rr5r6r7rrVrQr&r8r0r0r1r:s$zMultilabelAUROC.computer;cCs |||S)a:Plot a single or multiple values from the metric. Args: val: Either a single result from calling `metric.forward` or `metric.compute` or a list of these results. If no value is provided, will automatically call `metric.compute` and plot that result. ax: An matplotlib axis object. If provided will add plot to that axis Returns: Figure and Axes object Raises: ModuleNotFoundError: If `matplotlib` is not installed .. plot:: :scale: 75 >>> # Example plotting a single >>> import torch >>> from torchmetrics.classification import MultilabelAUROC >>> metric = MultilabelAUROC(num_labels=3) >>> metric.update(torch.rand(20,3), torch.randint(2, (20,3))) >>> fig_, ax_ = metric.plot() .. plot:: :scale: 75 >>> # Example plotting multiple values >>> import torch >>> from torchmetrics.classification import MultilabelAUROC >>> metric = MultilabelAUROC(num_labels=3) >>> values = [ ] >>> for _ in range(10): ... values.append(metric(torch.rand(20,3), torch.randint(2, (20,3)))) >>> fig_, ax_ = metric.plot(values) r>r?r0r0r1r@s(r)rLNNT)NNrRr0r0r.r1rT;s4 L       rTc @seZdZdZdedeeeee e feeeeeedee eee e e d dd Ze e dd d d Zdd ddZdS)AUROCaCompute 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 :class:`~torchmetrics.classification.BinaryAUROC`, :class:`~torchmetrics.classification.MulticlassAUROC` and :class:`~torchmetrics.classification.MultilabelAUROC` for the specific details of each argument influence and examples. Legacy Example: >>> from torch import tensor >>> preds = tensor([0.13, 0.26, 0.08, 0.19, 0.34]) >>> target = tensor([0, 0, 1, 1, 1]) >>> auroc = AUROC(task="binary") >>> auroc(preds, target) tensor(0.5000) >>> preds = 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 = tensor([0, 1, 1, 2, 2]) >>> auroc = AUROC(task="multiclass", num_classes=3) >>> auroc(preds, target) tensor(0.7778) NrLT)binaryZ multiclassZ multilabelrM) taskr%rPrVrQr$r&r'r(r)c Kst|}| |||d|tjkr6t|fi| S|tjkrpt|ts^tdt |dt ||fi| S|tj krt|tstdt |dt ||fi| Std|ddS)zInitialize task metric.r*z+`num_classes` is expected to be `int` but `z was passed.`z*`num_labels` is expected to be `int` but `zTask z not supported!N) rZfrom_strupdateBINARYrZ MULTICLASS isinstancerH ValueErrortyperJZ MULTILABELrT) clsrYr%rPrVrQr$r&r'r(r0r0r1__new__s      z AUROC.__new__)argsr(r)cOst|jjddS)zUpdate metric state.zM metric does not have a global `update` method. Use the task specific metric.NNotImplementedErrorr/rA)r-rar(r0r0r1rZ s z AUROC.updater2cCst|jjddS)r4zN metric does not have a global `compute` method. Use the task specific metric.Nrb)r-r0r0r1r:s z AUROC.compute)NNNrLNNT)rArBrCrDrrrrHrrGrrErrr`rZr:r0r0r0r1rWs,#  rWN)'typingrrrrrZtorchrZtyping_extensionsrZ torchmetrics.classification.baser Z2torchmetrics.classification.precision_recall_curver r r Z,torchmetrics.functional.classification.aurocr rrrrrZtorchmetrics.metricrZtorchmetrics.utilities.datarZtorchmetrics.utilities.enumsrZtorchmetrics.utilities.importsrZtorchmetrics.utilities.plotrrZ__doctest_skip__rrJrTrWr0r0r0r1s$        }