a  d?a@sddlmZmZmZmZmZddlmZddlm Z ddl m Z ddl m Z mZmZddlmZmZmZmZmZddlmZddlmZdd lmZdd lmZdd lmZm Z esgd Z!Gd dde Z"GdddeZ#GdddeZ$Gddde Z%dS))AnyListOptionalSequenceUnion)Tensor)Literal)_ClassificationTaskWrapper)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_cat)ClassificationTask)_MATPLOTLIB_AVAILABLE)_AX_TYPE_PLOT_OUT_TYPE)BinaryAveragePrecision.plotMulticlassAveragePrecision.plotMultilabelAveragePrecision.plotc@seZdZUdZdZeed<dZeed<dZeed<dZ e ed<d Z e ed <e d d d Z deee ee feeedddZdS)BinaryAveragePrecisiona 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). 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 torch import tensor >>> from torchmetrics.classification import BinaryAveragePrecision >>> preds = tensor([0, 0.5, 0.7, 0.8]) >>> target = 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_differentiableThigher_is_betterfull_state_updateplot_lower_bound?plot_upper_boundreturncCs0|jdurt|jt|jfn|j}t||jSzCompute metric.N) thresholdsrpredstargetconfmatr selfstater-v/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/torchmetrics/classification/average_precision.pycomputers$zBinaryAveragePrecision.computeNvalaxr$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 BinaryAveragePrecision >>> metric = BinaryAveragePrecision() >>> 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 BinaryAveragePrecision >>> metric = BinaryAveragePrecision() >>> values = [ ] >>> for _ in range(10): ... values.append(metric(torch.rand(20,), torch.randint(2, (20,)))) >>> fig_, ax_ = metric.plot(values) Z_plotr+r1r2r-r-r.plotws(r)NN)__name__ __module__ __qualname____doc__rbool__annotations__rrr floatr"rr/rrrrrr5r-r-r-r.r.s =     rc seZdZUdZdZeed<dZeed<dZeed<dZ e ed<d Z e ed <d Z e ed <deeedeeeee efeeeeddfdd ZedddZdeeeeefeeedddZZS)MulticlassAveragePrecisionaFCompute 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). 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 torch import tensor >>> from torchmetrics.classification import MulticlassAveragePrecision >>> 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 = 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]) FrTrrrr r!r"ZClassplot_legend_namemacroNr?weightednone) num_classesaverager& ignore_index validate_argskwargsr$c s>tjf|||dd||r.t||||||_||_dS)NF)rCr&rErF)super__init__rrDrF)r+rCrDr&rErFrG __class__r-r.rIs z#MulticlassAveragePrecision.__init__r#cCs8|jdurt|jt|jfn|j}t||j|j|jSr%)r&rr'r(r)rrCrDr*r-r-r.r/ s$z"MulticlassAveragePrecision.computer0cCs |||S)aiPlot 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 MulticlassAveragePrecision >>> metric = MulticlassAveragePrecision(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 MulticlassAveragePrecision >>> metric = MulticlassAveragePrecision(num_classes=3) >>> values = [ ] >>> for _ in range(10): ... values.append(metric(torch.randn(20, 3), torch.randint(3, (20,)))) >>> fig_, ax_ = metric.plot(values) r3r4r-r-r.r5s(r)r?NNT)NNr6r7r8r9rr:r;rrr r<r"r>strintrrrrrrrIr/rrrr5 __classcell__r-r-rJr.r=s4 N       r=c seZdZUdZdZeed<dZeed<dZeed<dZ e ed<d Z e ed <d Z e ed <deeedeeeee efeeeeddfdd ZedddZdeeeeefeeedddZZS)MultilabelAveragePrecisionaCompute 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). 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 torch import tensor >>> from torchmetrics.classification import MultilabelAveragePrecision >>> 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]]) >>> 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]) FrTrrrr r!r"ZLabelr>r?N)micror?rArB) num_labelsrDr&rErFrGr$c s>tjf|||dd||r.t||||||_||_dS)NF)rRr&rErF)rHrIrrDrF)r+rRrDr&rErFrGrJr-r.rIs z#MultilabelAveragePrecision.__init__r#cCs<|jdurt|jt|jfn|j}t||j|j|j|jSr%) r&rr'r(r)rrRrDrEr*r-r-r.r/s$z"MultilabelAveragePrecision.computer0cCs |||S)afPlot 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 MultilabelAveragePrecision >>> metric = MultilabelAveragePrecision(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 MultilabelAveragePrecision >>> metric = MultilabelAveragePrecision(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) r3r4r-r-r.r5s(r)r?NNT)NNrLr-r-rJr.rP9s4 Q       rPc @sZeZdZdZd edeeeee e feeeeeedeee e e d dd ZdS) AveragePrecisionaCompute 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 :class:`~torchmetrics.classification.BinaryAveragePrecision`, :class:`~torchmetrics.classification.MulticlassAveragePrecision` and :class:`~torchmetrics.classification.MultilabelAveragePrecision` for the specific details of each argument influence and examples. Legacy Example: >>> from torch import tensor >>> pred = tensor([0, 0.1, 0.8, 0.4]) >>> target = tensor([0, 1, 1, 1]) >>> average_precision = AveragePrecision(task="binary") >>> average_precision(pred, target) tensor(1.) >>> pred = 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]) >>> 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?T)binaryZ multiclassZ multilabelr@) taskr&rCrRrDrErFrGr$c Kst|}||||d|tjkr4tfi|S|tjkrnt|ts\tdt |dt ||fi|S|tj krt|tstdt |dt ||fi|Std|ddS)zInitialize task metric.)r&rErFz+`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 isinstancerN ValueErrortyper=Z MULTILABELrP) clsrUr&rCrRrDrErFrGr-r-r.__new__s      zAveragePrecision.__new__)NNNr?NT)r6r7r8r9rrrrNrr<rr:rrr\r-r-r-r.rSs$( rSN)&typingrrrrrZtorchrZtyping_extensionsrZ torchmetrics.classification.baser Z2torchmetrics.classification.precision_recall_curver r r Z8torchmetrics.functional.classification.average_precisionr rrrrZtorchmetrics.metricrZtorchmetrics.utilities.datarZtorchmetrics.utilities.enumsrZtorchmetrics.utilities.importsrZtorchmetrics.utilities.plotrrZ__doctest_skip__rr=rPrSr-r-r-r.s$       t