o .wi!]@s ddlmZmZddlZddlmZddlmZddlmZddl m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZddlmZddlmZdd lmZdd lm Z m!Z!m"Z"m#Z#esdgd Z$Gd d d eZ%GdddeZ&GdddeZ'GdddeZ(dS))AnyOptionalN)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 _CMAP_TYPE_PLOT_OUT_TYPEplot_confusion_matrix)BinaryConfusionMatrix.plotMulticlassConfusionMatrix.plotMultilabelConfusionMatrix.plotc seZdZUdZdZeed<dZeeed<dZ eed<e ed<    d d e d ee d ee d dededdf fdd Zde de ddfddZde fddZ    d!dee deededeeedeedef ddZZS)"BinaryConfusionMatrixa9 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. Additionally, 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?T threshold ignore_index normalizetruepredallnone validate_argskwargsreturnc s\tjdi||rt|||||_||_||_||_|jdtj ddtj ddddSNr$dtypesumdist_reduce_fx) super__init__rr&r'r(r. add_statetorchzeroslong)selfr&r'r(r.r/ __class__r8i/home/ubuntu/sommelier/.venv/lib/python3.10/site-packages/torchmetrics/classification/confusion_matrix.pyr:v "zBinaryConfusionMatrix.__init__predstargetcCsF|jr t|||jt|||j|j\}}t||}|j|7_dSz*Update state with predictions and targets.N)r.r r'r r&r r$r?rDrEr$r8r8rBupdates  zBinaryConfusionMatrix.updatecCt|j|jSzCompute confusion matrix.)rr$r(r?r8r8rBcomputezBinaryConfusionMatrix.computevalaxadd_textlabelscmapcCJ|dur|n|}t|tstd|t|||||d\}}||fSaPlot 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 cmap: matplotlib colormap to use for the confusion matrix https://matplotlib.org/stable/users/explain/colors/colormaps.html 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 )rOrPrQrRrL isinstancer TypeErrorrr?rNrOrPrQrRfigr8r8rBplot $ rr%NNTNNTNN)__name__ __module__ __qualname____doc__r!bool__annotations__r"rr#rfloatintrrr:rHrLrliststrrrrZ __classcell__r8r8r@rBr 3sV  <   r c seZdZUdZdZeed<dZeeed<dZ eed<e ed<   dd e d ee d ee d d ede ddf fdd Zde de ddfddZde fddZ     d dee deededeeedeedef ddZZS)!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_{j=1, j\neq i}^N C_{j, i}` 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. Additionally, 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 specifying 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$T num_classesr'r(r-r*r+r,r.r/r0c s\tjdi||rt|||||_||_||_||_|jdtj ||tj ddddS)Nr$r3r5r6r8) r9r:r rjr'r(r.r;r<r=r>)r?rjr'r(r.r/r@r8rBr:rCz"MulticlassConfusionMatrix.__init__rDrEcCsJ|jr t|||j|jt|||j\}}t|||j}|j|7_dSrF)r.rrjr'rrr$rGr8r8rBrHs z MulticlassConfusionMatrix.updatecCrIrJ)r r$r(rKr8r8rBrL rMz!MulticlassConfusionMatrix.computerNrOrPrQrRcCrSrTrUrXr8r8rBrZ$r[r)NNTr])r^r_r`rar!rbrcr"rr#rrerrr:rHrLrrfrgrrrZrhr8r8r@rBrisT  @   ricseZdZUdZdZeed<dZeeed<dZ eed<e ed<    d!d e d e d ee d ee ddededdffdd Zde de ddfddZde fddZ    d"dee deededeeedeedef dd ZZS)#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. Additionally, 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 specifying 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%T num_labelsr&r'r(rkr.r/r0c sftjdi||rt||||||_||_||_||_||_|jdt j |ddt j ddddSr1) r9r:rrmr&r'r(r.r;r<r=r>)r?rmr&r'r(r.r/r@r8rBr:s $z"MultilabelConfusionMatrix.__init__rDrEcCsR|jr t|||j|jt|||j|j|j\}}t|||j}|j|7_dSrF)r.rrmr'rr&rr$rGr8r8rBrHsz MultilabelConfusionMatrix.updatecCrIrJ)rr$r(rKr8r8rBrLrMz!MultilabelConfusionMatrix.computerNrOrPrQrRcCrSrTrUrXr8r8rBrZr[rr\r])r^r_r`rar!rbrcr"rr#rrerdrrr:rHrLrrfrgrrrZrhr8r8r@rBrlOsZ  ?    rlc@sleZdZdZ      ddeddedded eed eed eed d eede de de fddZ 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%NTclstask)binary multiclass multilabelr&rjrmr(r)r'r.r/r0c Kst|}||||d|tjkrt|fi|S|tjkr7t|ts/tdt |dt |fi|S|tj krTt|tsKtdt |dt ||fi|Std|d)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!) rfrom_strrHBINARYr MULTICLASSrVre ValueErrortyperi MULTILABELrl) rorpr&rjrmr(r'r.r/r8r8rB__new__s      zConfusionMatrix.__new__)r%NNNNT) r^r_r`rarxrrdrrerbrrrzr8r8r8rBrns:'   rn))typingrrr<rtyping_extensionsr torchmetrics.classification.baser7torchmetrics.functional.classification.confusion_matrixrrr r r r r rrrrrrrrtorchmetrics.metricrtorchmetrics.utilities.enumsrtorchmetrics.utilities.importsrtorchmetrics.utilities.plotrrrr__doctest_skip__r rirlrnr8r8r8rBs&    D