o yi[?@sddlmZmZddlZddlmZddlmZddlmZm Z m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZddlmZGdddeZGd d d eZGd d d eZGd ddZdS))AnyOptionalN)Tensor)Literal)'_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)Metricc seZdZUdZdZeed<dZeeed<dZ eed<    dd e d ee d ee d d ede ddf fdd ZdededdfddZdefddZZS)BinaryConfusionMatrixaComputes the `confusion matrix`_ for binary tasks. 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, ...)``. .. note:: Additional dimension ``...`` will be flattened into the batch dimension. As output to ``forward`` and ``compute`` the metric returns the following output: - ``bcm`` (:class:`~torch.Tensor`): A tensor containing a ``(2, 2)`` matrix 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_update?T threshold ignore_index normalizetruepredallnone validate_argskwargsreturnc s\tjdi||rt|||||_||_||_||_|jdtj ddtj ddddSNconfmatdtypesumdist_reduce_fx) super__init__rrrrr# add_statetorchzeroslong)selfrrrr#r$ __class__r.`/home/ubuntu/.local/lib/python3.10/site-packages/torchmetrics/classification/confusion_matrix.pyr0] "zBinaryConfusionMatrix.__init__predstargetcCsF|jr t|||jt|||j|j\}}t||}|j|7_dSz*Update state with predictions and targets.N)r#r rrrr r'r5r:r;r'r.r.r8updateos  zBinaryConfusionMatrix.updatecCt|j|jSzComputes confusion matrix.)rr'rr5r.r.r8computewzBinaryConfusionMatrix.computerNNT)__name__ __module__ __qualname____doc__rbool__annotations__rrrfloatintrrr0rr>rB __classcell__r.r.r6r8r(s0  0  rc seZdZUdZdZeed<dZeeed<dZ eed<   dde d ee d ee d d ed e ddf fdd Z dededdfddZdefddZZS)MulticlassConfusionMatrixa Computes the `confusion matrix`_ for multiclass tasks. 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, ...)``. .. note:: Additional dimension ``...`` will be flattened into the batch dimension. As output to ``forward`` and ``compute`` the metric returns the following output: - ``bcm`` (:class:`~torch.Tensor`): A tensor containing a ``(2, 2)`` matrix --- As input to 'update' the metric accepts the following input: - ``preds``: ``(N, ...)`` (int tensor) or ``(N, C, ..)`` (float tensor). If preds is a floating point we apply ``torch.argmax`` along the ``C`` dimension to automatically convert probabilities/logits into an int tensor. - ``target`` (int tensor): ``(N, ...)`` Additional dimension ``...`` will be flattened into the batch dimension. As output of '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 torchmetrics.classification import MulticlassConfusionMatrix >>> target = torch.tensor([2, 1, 0, 0]) >>> preds = torch.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 = torch.tensor([2, 1, 0, 0]) >>> preds = torch.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]]) FrNrrT num_classesrrr"rr r!r#r$r%c s\tjdi||rt|||||_||_||_||_|jdtj ||tj ddddS)Nr'r)r+r,r.) r/r0r rOrrr#r1r2r3r4)r5rOrrr#r$r6r.r8r0r9z"MulticlassConfusionMatrix.__init__r:r;cCsJ|jr t|||j|jt|||j\}}t|||j}|j|7_dSr<)r#rrOrr rr'r=r.r.r8r>s z MulticlassConfusionMatrix.updatecCr?r@)r r'rrAr.r.r8rBrCz!MulticlassConfusionMatrix.compute)NNT)rErFrGrHrrIrJrrrrLrrr0rr>rBrMr.r.r6r8rN|s.  F  rNcseZdZUdZdZeed<dZeeed<dZ eed<    dd e d e d ee d ee d dede ddffdd ZdededdfddZdefddZZS)MultilabelConfusionMatrixaq Computes the `confusion matrix`_ for multilabel tasks. 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, ...)`` Additional dimension ``...`` will be flattened into the batch dimension. 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 torchmetrics.classification import MultilabelConfusionMatrix >>> target = torch.tensor([[0, 1, 0], [1, 0, 1]]) >>> preds = torch.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 = torch.tensor([[0, 1, 0], [1, 0, 1]]) >>> preds = torch.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]]]) FrNrrrT num_labelsrrrrPr#r$r%c sftjdi||rt||||||_||_||_||_||_|jdt j |ddt j ddddSr&) r/r0rrRrrrr#r1r2r3r4)r5rRrrrr#r$r6r.r8r0s $z"MultilabelConfusionMatrix.__init__r:r;cCsR|jr t|||j|jt|||j|j|j\}}t|||j}|j|7_dSr<)r#rrRrrrrr'r=r.r.r8r>1sz MultilabelConfusionMatrix.updatecCr?r@)rr'rrAr.r.r8rB;rCz!MultilabelConfusionMatrix.computerD)rErFrGrHrrIrJrrrrLrKrrr0rr>rBrMr.r.r6r8rQs4  2   rQc@sdeZdZdZ      ddeddedeed eed eed d eed ede de fddZ dS)ConfusionMatrixa$Computes 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 :mod:`BinaryConfusionMatrix`, :mod:`MulticlassConfusionMatrix` and :func:`MultilabelConfusionMatrix` for the specific details of each argument influence and examples. Legacy Example: >>> target = torch.tensor([1, 1, 0, 0]) >>> preds = torch.tensor([0, 1, 0, 0]) >>> confmat = ConfusionMatrix(task="binary", num_classes=2) >>> confmat(preds, target) tensor([[2, 0], [1, 1]]) >>> target = torch.tensor([2, 1, 0, 0]) >>> preds = torch.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 = torch.tensor([[0, 1, 0], [1, 0, 1]]) >>> preds = torch.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]]]) rNTtask)binary multiclass multilabelrrOrRrrrr#r$r%c Ks|t|||d|dkrt|fi|S|dkr)t|ts!Jt|fi|S|dkr=t|ts4Jt||fi|Std|)N)rrr#rUrVrWz[Expected argument `task` to either be `'binary'`, `'multiclass'` or `'multilabel'` but got )r>dictr isinstancerLrNrQ ValueError) clsrTrrOrRrrr#r$r.r.r8__new__as zConfusionMatrix.__new__)rNNNNT) rErFrGrHrrKrrLrIrrr\r.r.r.r8rS@s6#   rS)typingrrr2rtyping_extensionsr7torchmetrics.functional.classification.confusion_matrixrrrr r r r r rrrrrrrtorchmetrics.metricrrrNrQrSr.r.r.r8s   D TjZ