a  dZ@s ddlmZmZmZddlZddlmZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZmZddlmZddlmZdd lmZdd l m!Z!m"Z"m#Z#esgd Z$Gd d d eZ%GdddeZ&GdddeZ'Gddde Z(dS))AnyListOptionalN)Tensor)Literal)_ClassificationTaskWrapper)'_binary_confusion_matrix_arg_validation _binary_confusion_matrix_compute_binary_confusion_matrix_format*_binary_confusion_matrix_tensor_validation_binary_confusion_matrix_update+_multiclass_confusion_matrix_arg_validation$_multiclass_confusion_matrix_compute#_multiclass_confusion_matrix_format._multiclass_confusion_matrix_tensor_validation#_multiclass_confusion_matrix_update+_multilabel_confusion_matrix_arg_validation$_multilabel_confusion_matrix_compute#_multilabel_confusion_matrix_format._multilabel_confusion_matrix_tensor_validation#_multilabel_confusion_matrix_update)Metric)ClassificationTask)_MATPLOTLIB_AVAILABLE)_AX_TYPE_PLOT_OUT_TYPEplot_confusion_matrix)BinaryConfusionMatrix.plotMulticlassConfusionMatrix.plotMultilabelConfusionMatrix.plotcseZdZUdZdZeed<dZeeed<dZ eed<e ed<de ee ee d eedd fd d Ze e ddddZe dddZdee eeeeeeedddZZS)BinaryConfusionMatrixa8 Compute the `confusion matrix`_ for binary tasks. The confusion matrix :math:`C` is constructed such that :math:`C_{i, j}` is equal to the number of observations known to be in class :math:`i` but predicted to be in class :math:`j`. Thus row indices of the confusion matrix correspond to the true class labels and column indices correspond to the predicted class labels. For binary tasks, the confusion matrix is a 2x2 matrix with the following structure: - :math:`C_{0, 0}`: True negatives - :math:`C_{0, 1}`: False positives - :math:`C_{1, 0}`: False negatives - :math:`C_{1, 1}`: True positives As input to ``forward`` and ``update`` the metric accepts the following input: - ``preds`` (:class:`~torch.Tensor`): An int or float tensor of shape ``(N, ...)``. If preds is a floating point tensor with values outside [0,1] range we consider the input to be logits and will auto apply sigmoid per element. Addtionally, we convert to int tensor with thresholding using the value in ``threshold``. - ``target`` (:class:`~torch.Tensor`): An int tensor of shape ``(N, ...)``. As output to ``forward`` and ``compute`` the metric returns the following output: - ``confusion_matrix`` (:class:`~torch.Tensor`): A tensor containing a ``(2, 2)`` matrix Additional dimension ``...`` will be flattened into the batch dimension. Args: threshold: Threshold for transforming probability to binary (0,1) predictions ignore_index: Specifies a target value that is ignored and does not contribute to the metric calculation normalize: Normalization mode for confusion matrix. Choose from: - ``None`` or ``'none'``: no normalization (default) - ``'true'``: normalization over the targets (most commonly used) - ``'pred'``: normalization over the predictions - ``'all'``: normalization over the whole matrix 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 (preds is int tensor): >>> from torchmetrics.classification import BinaryConfusionMatrix >>> target = torch.tensor([1, 1, 0, 0]) >>> preds = torch.tensor([0, 1, 0, 0]) >>> bcm = BinaryConfusionMatrix() >>> bcm(preds, target) tensor([[2, 0], [1, 1]]) Example (preds is float tensor): >>> from torchmetrics.classification import BinaryConfusionMatrix >>> target = torch.tensor([1, 1, 0, 0]) >>> preds = torch.tensor([0.35, 0.85, 0.48, 0.01]) >>> bcm = BinaryConfusionMatrix() >>> bcm(preds, target) tensor([[2, 0], [1, 1]]) Fis_differentiableNhigher_is_betterfull_state_updateconfmat?Ttruepredallnone) threshold ignore_index normalize validate_argskwargsreturnc s\tjfi||r"t|||||_||_||_||_|jdtj ddtj ddddSNr$ZdtypesumZdist_reduce_fx) super__init__rr+r,r-r. add_statetorchzeroslong)selfr+r,r-r.r/ __class__u/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/torchmetrics/classification/confusion_matrix.pyr7us zBinaryConfusionMatrix.__init__predstargetr0cCsF|jrt|||jt|||j|j\}}t||}|j|7_dSz*Update state with predictions and targets.N)r.r r,r r+r r$r<rBrCr$r?r?r@updates  zBinaryConfusionMatrix.updater0cCst|j|jSzCompute confusion matrix.)r r$r-r<r?r?r@computeszBinaryConfusionMatrix.computevalaxadd_textlabelsr0cCsH|dur |n|}t|ts,td|t||||d\}}||fSa$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 add_text: if the value of each cell should be added to the plot labels: a list of strings, if provided will be added to the plot to indicate the different classes Returns: Figure and Axes object Raises: ModuleNotFoundError: If `matplotlib` is not installed .. plot:: :scale: 75 >>> from torch import randint >>> from torchmetrics.classification import MulticlassConfusionMatrix >>> metric = MulticlassConfusionMatrix(num_classes=5) >>> metric.update(randint(5, (20,)), randint(5, (20,))) >>> fig_, ax_ = metric.plot() Nz+Expected val to be a single tensor but got )rMrNrOrJ isinstancer TypeErrorrr<rLrMrNrOZfigr?r?r@plots ! r)r%NNT)NNTN)__name__ __module__ __qualname____doc__r!bool__annotations__r"rr#rfloatintrrr7rFrJrrstrrrU __classcell__r?r?r=r@r 3s< ;    r cseZdZUdZdZeed<dZeeed<dZ eed<e ed<de ee ee d ee dd fd d Ze e dd ddZe dddZdee eeeeeeedddZZS)MulticlassConfusionMatrixa Compute the `confusion matrix`_ for multiclass tasks. The confusion matrix :math:`C` is constructed such that :math:`C_{i, j}` is equal to the number of observations known to be in class :math:`i` but predicted to be in class :math:`j`. Thus row indices of the confusion matrix correspond to the true class labels and column indices correspond to the predicted class labels. For multiclass tasks, the confusion matrix is a NxN matrix, where: - :math:`C_{i, i}` represents the number of true positives for class :math:`i` - :math:`\sum_{j=1, j\neq i}^N C_{i, j}` represents the number of false negatives for class :math:`i` - :math:`\sum_{i=1, i\neq j}^N C_{i, j}` represents the number of false positives for class :math:`i` - the sum of the remaining cells in the matrix represents the number of true negatives for class :math:`i` As input to ``forward`` and ``update`` the metric accepts the following input: - ``preds`` (:class:`~torch.Tensor`): An int or float tensor of shape ``(N, ...)``. If preds is a floating point tensor with values outside [0,1] range we consider the input to be logits and will auto apply sigmoid per element. Addtionally, we convert to int tensor with thresholding using the value in ``threshold``. - ``target`` (:class:`~torch.Tensor`): An int tensor of shape ``(N, ...)``. As output to ``forward`` and ``compute`` the metric returns the following output: - ``confusion_matrix``: [num_classes, num_classes] matrix Args: num_classes: Integer specifing the number of classes ignore_index: Specifies a target value that is ignored and does not contribute to the metric calculation normalize: Normalization mode for confusion matrix. Choose from: - ``None`` or ``'none'``: no normalization (default) - ``'true'``: normalization over the targets (most commonly used) - ``'pred'``: normalization over the predictions - ``'all'``: normalization over the whole matrix 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 (pred is integer tensor): >>> from torch import tensor >>> from torchmetrics.classification import MulticlassConfusionMatrix >>> target = tensor([2, 1, 0, 0]) >>> preds = tensor([2, 1, 0, 1]) >>> metric = MulticlassConfusionMatrix(num_classes=3) >>> metric(preds, target) tensor([[1, 1, 0], [0, 1, 0], [0, 0, 1]]) Example (pred is float tensor): >>> from torchmetrics.classification import MulticlassConfusionMatrix >>> target = tensor([2, 1, 0, 0]) >>> preds = tensor([[0.16, 0.26, 0.58], ... [0.22, 0.61, 0.17], ... [0.71, 0.09, 0.20], ... [0.05, 0.82, 0.13]]) >>> metric = MulticlassConfusionMatrix(num_classes=3) >>> metric(preds, target) tensor([[1, 1, 0], [0, 1, 0], [0, 0, 1]]) Fr!Nr"r#r$Tr*r'r(r)) num_classesr,r-r.r/r0c s\tjfi||r"t|||||_||_||_||_|jdtj ||tj ddddS)Nr$r3r4r5) r6r7r rbr,r-r.r8r9r:r;)r<rbr,r-r.r/r=r?r@r7s z"MulticlassConfusionMatrix.__init__rAcCsJ|jrt|||j|jt|||j\}}t|||j}|j|7_dSrD)r.rrbr,rrr$rEr?r?r@rFs z MulticlassConfusionMatrix.updaterGcCst|j|jSrH)rr$r-rIr?r?r@rJsz!MulticlassConfusionMatrix.computerKcCsH|dur |n|}t|ts,td|t||||d\}}||fSrPrQrTr?r?r@rUs ! r)NNT)NNTN)rVrWrXrYr!rZr[r"rr#rr]rrr7rFrJrrr^rrUr_r?r?r=r@r`s: ?    r`c seZdZUdZdZeed<dZeeed<dZ eed<e ed<de e ee ee d eedd fd d Ze e ddddZe dddZdee eeeeeeedddZZS)MultilabelConfusionMatrixa Compute the `confusion matrix`_ for multilabel tasks. The confusion matrix :math:`C` is constructed such that :math:`C_{i, j}` is equal to the number of observations known to be in class :math:`i` but predicted to be in class :math:`j`. Thus row indices of the confusion matrix correspond to the true class labels and column indices correspond to the predicted class labels. For multilabel tasks, the confusion matrix is a Nx2x2 tensor, where each 2x2 matrix corresponds to the confusion for that label. The structure of each 2x2 matrix is as follows: - :math:`C_{0, 0}`: True negatives - :math:`C_{0, 1}`: False positives - :math:`C_{1, 0}`: False negatives - :math:`C_{1, 1}`: True positives As input to 'update' the metric accepts the following input: - ``preds`` (int or float tensor): ``(N, C, ...)``. If preds is a floating point tensor with values outside [0,1] range we consider the input to be logits and will auto apply sigmoid per element. Addtionally, we convert to int tensor with thresholding using the value in ``threshold``. - ``target`` (int tensor): ``(N, C, ...)`` As output of 'compute' the metric returns the following output: - ``confusion matrix``: [num_labels,2,2] matrix Args: num_classes: Integer specifing the number of labels threshold: Threshold for transforming probability to binary (0,1) predictions ignore_index: Specifies a target value that is ignored and does not contribute to the metric calculation normalize: Normalization mode for confusion matrix. Choose from: - ``None`` or ``'none'``: no normalization (default) - ``'true'``: normalization over the targets (most commonly used) - ``'pred'``: normalization over the predictions - ``'all'``: normalization over the whole matrix 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 (preds is int tensor): >>> from torch import tensor >>> from torchmetrics.classification import MultilabelConfusionMatrix >>> target = tensor([[0, 1, 0], [1, 0, 1]]) >>> preds = tensor([[0, 0, 1], [1, 0, 1]]) >>> metric = MultilabelConfusionMatrix(num_labels=3) >>> metric(preds, target) tensor([[[1, 0], [0, 1]], [[1, 0], [1, 0]], [[0, 1], [0, 1]]]) Example (preds is float tensor): >>> from torchmetrics.classification import MultilabelConfusionMatrix >>> target = tensor([[0, 1, 0], [1, 0, 1]]) >>> preds = tensor([[0.11, 0.22, 0.84], [0.73, 0.33, 0.92]]) >>> metric = MultilabelConfusionMatrix(num_labels=3) >>> metric(preds, target) tensor([[[1, 0], [0, 1]], [[1, 0], [1, 0]], [[0, 1], [0, 1]]]) Fr!Nr"r#r$r%Tra) num_labelsr+r,r-r.r/r0c sftjfi||r$t||||||_||_||_||_||_|jdt j |ddt j ddddSr1) r6r7rrdr+r,r-r.r8r9r:r;)r<rdr+r,r-r.r/r=r?r@r7s z"MultilabelConfusionMatrix.__init__rAcCsR|jrt|||j|jt|||j|j|j\}}t|||j}|j|7_dSrD)r.rrdr,rr+rr$rEr?r?r@rFsz MultilabelConfusionMatrix.updaterGcCst|j|jSrH)rr$r-rIr?r?r@rJsz!MultilabelConfusionMatrix.computerKcCsH|dur |n|}t|ts,td|t||||d\}}||fSrPrQrTr?r?r@rUs ! r)r%NNT)NNTN)rVrWrXrYr!rZr[r"rr#rr]r\rrr7rFrJrrr^rrUr_r?r?r=r@rcGs> >     rcc @sHeZdZdZd edeeeeeeedeeee e d dd Z dS) ConfusionMatrixaCompute the `confusion matrix`_. 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.BinaryConfusionMatrix`, :class:`~torchmetrics.classification.MulticlassConfusionMatrix` and :class:`~torchmetrics.classification.MultilabelConfusionMatrix` for the specific details of each argument influence and examples. Legacy Example: >>> from torch import tensor >>> target = tensor([1, 1, 0, 0]) >>> preds = tensor([0, 1, 0, 0]) >>> confmat = ConfusionMatrix(task="binary", num_classes=2) >>> confmat(preds, target) tensor([[2, 0], [1, 1]]) >>> target = tensor([2, 1, 0, 0]) >>> preds = tensor([2, 1, 0, 1]) >>> confmat = ConfusionMatrix(task="multiclass", num_classes=3) >>> confmat(preds, target) tensor([[1, 1, 0], [0, 1, 0], [0, 0, 1]]) >>> target = tensor([[0, 1, 0], [1, 0, 1]]) >>> preds = tensor([[0, 0, 1], [1, 0, 1]]) >>> confmat = ConfusionMatrix(task="multilabel", num_labels=3) >>> confmat(preds, target) tensor([[[1, 0], [0, 1]], [[1, 0], [1, 0]], [[0, 1], [0, 1]]]) r%NT)binaryZ multiclassZ multilabelr&) taskr+rbrdr-r,r.r/r0c Kst|}||||d|tjkr6t|fi|S|tjkrnt|ts^tdt |dt |fi|S|tj krt|tstdt |dt ||fi|Std|ddS)zInitialize task metric.)r-r,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_strrFBINARYr Z MULTICLASSrRr] ValueErrortyper`Z MULTILABELrc) clsrgr+rbrdr-r,r.r/r?r?r@__new__s      zConfusionMatrix.__new__)r%NNNNT) rVrWrXrYrr\rr]rZrrrlr?r?r?r@res$' re))typingrrrr9rZtyping_extensionsrZ torchmetrics.classification.baserZ7torchmetrics.functional.classification.confusion_matrixrr r r r r rrrrrrrrrZtorchmetrics.metricrZtorchmetrics.utilities.enumsrZtorchmetrics.utilities.importsrZtorchmetrics.utilities.plotrrrZ__doctest_skip__r r`rcrer?r?r?r@s$   D