i!]$ddlmZmZddlZddlmZddlmZddlmZddl m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZddlmZddlmZdd lmZdd lm Z m!Z!m"Z"m#Z#esgd Z$Gd d eZ%GddeZ&GddeZ'GddeZ(y))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)zBinaryConfusionMatrix.plotzMulticlassConfusionMatrix.plotzMultilabelConfusionMatrix.plotc eZdZUdZdZeed<dZeeed<dZ eed<e ed< dde d ee d ee d d ed eddf fd Zde de ddfdZde fdZ ddee deededeeedeedef dZxZS)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 threshold ignore_index normalizetruepredallnone validate_argskwargsreturnc t|di||r t|||||_||_||_||_|jdtjddtjdyNr#dtypesumdist_reduce_fx) super__init__rr$r%r&r, add_statetorchzeroslong)selfr$r%r&r,r- __class__s /Volumes/fast/ai/experiments/voice-extract-mac/.venv/lib/python3.12/site-packages/torchmetrics/classification/confusion_matrix.pyr9zBinaryConfusionMatrix.__init__vsf "6"  3I|Y W"("* y%++a%**"EV[\predstargetc|jrt|||jt|||j|j\}}t ||}|xj |z c_yz*Update state with predictions and targets.N)r,r r%r r$r r#r>rBrCr#s r@updatezBinaryConfusionMatrix.updatesV    6ufdFWFW X7vt~~W[WhWhi v1%@  rAcBt|j|jSzCompute confusion matrix.)r r#r&r>s r@computezBinaryConfusionMatrix.computes/ dnnMMrAvalaxadd_textlabelscmapc||n|j}t|tstd|t |||||\}}||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() z+Expected val to be a single tensor but got )rMrNrOrPrK isinstancer TypeErrorrr>rLrMrNrOrPfigs r@plotzBinaryConfusionMatrix.plotSH_c$,,.#v&I#OP P'Xf[_`RBwrA?NNTNNTNN)__name__ __module__ __qualname____doc__r bool__annotations__r!rr"rfloatintrrr9rGrKrliststrrrrX __classcell__r?s@r@rr3s(:x$t#'+htn+#t# O&*FJ" ]]sm]G$ABC ]  ]  ] ]$ F F t NN !%!%&*%) ( f ( X ( ( c# ( z" ( (rArc eZdZUdZdZeed<dZeeed<dZ eed<e ed< dde d ee d ee d d ed e ddf fd Zde de ddfdZde fdZ ddee deededeeedeedef dZxZS)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# num_classesr%r&r+r(r)r*r,r-r.c t|di||r t|||||_||_||_||_|jdtj||tjdy)Nr#r2r4r5r7) r8r9r rkr%r&r,r:r;r<r=)r>rkr%r&r,r-r?s r@r9z"MulticlassConfusionMatrix.__init__sh "6"  7 \S\ ]&("* y%++k;ejj"YjoprArBrCc|jr"t|||j|jt |||j\}}t |||j}|xj |z c_yrE)r,rrkr%rrr#rFs r@rGz MulticlassConfusionMatrix.updates`    :5&$JZJZ\`\m\m n;E64K\K\] v5eVTEUEUV  rAcBt|j|jSrI)rr#r&rJs r@rKz!MulticlassConfusionMatrix.compute 3DLL$..QQrArLrMrNrOrPc||n|j}t|tstd|t |||||\}}||fSrRrSrVs r@rXzMulticlassConfusionMatrix.plot$rYrA)NNTr\)r]r^r_r`r rarbr!rr"rrdrrr9rGrKrrerfrrrXrgrhs@r@rjrjs%>@$t#'+htn+#t# O '+FJ" qqsmqG$ABC q  q  q q$ F F t RR !%!%&*%) ( f ( X ( ( c# ( z" ( (rArjceZdZUdZdZeed<dZeeed<dZ eed<e ed< dde d e d ee d ee d d ededdffd Zde de ddfdZde fdZ ddee deededeeedeedef dZxZS)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# num_labelsr$r%r&rlr,r-r.c t|di||rt||||||_||_||_||_||_|jdtj|ddtjdyr0) r8r9rrtr$r%r&r,r:r;r<r=)r>rtr$r%r&r,r-r?s r@r9z"MultilabelConfusionMatrix.__init__sr "6"  7 I|]f g$"("* y%++j!Qejj"QbghrArBrCc|jr"t|||j|jt |||j|j |j\}}t |||j}|xj|z c_yrE)r,rrtr%rr$rr#rFs r@rGz MultilabelConfusionMatrix.updatesm    :5&$//[_[l[l m; 64??DNND>> 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]]]) Nclstask)binary multiclass multilabelr$rkrtr&r'r%r,r-r.c tj|}|j|||d|tjk(r t |fi|S|tj k(r4t |tstdt|dt|fi|S|tjk(r5t |tstdt|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_strrGBINARYr MULTICLASSrTrd ValueErrortyperj MULTILABELrs) r{r|r$rkrtr&r%r,r-s r@__new__zConfusionMatrix.__new__s"**40 I|^klm %,, ,(=f= = %00 0k3/ #NtT_O`Naan!opp,[CFC C %00 0j#. #MdS]N^M__l!mnn,ZMfM M5o677rA)r[NNNNT) r]r^r_r`rrrcrrdrarrrr7rAr@rzrzs"N%)$(FJ&*"8 # $8:;88c] 8 SM 8 G$ABC 8sm888 8rArz))typingrrr;rtyping_extensionsr torchmetrics.classification.baser7torchmetrics.functional.classification.confusion_matrixrr r r r r rrrrrrrrrtorchmetrics.metricrtorchmetrics.utilities.enumsrtorchmetrics.utilities.importsrtorchmetrics.utilities.plotrrrr__doctest_skip__rrjrsrzr7rAr@rs! %G"';@ccIFIXMM`PPf=80=8rA