o yik@sddlmZmZddlZddlmZddlmZddlmZddl m Z ddl m Z  dAded eed d efd d Z   dBdedeed eed d dfddZ dAdededeed dfddZ   dCdedededeeded eeeff ddZdeded efddZ dAded eed d efddZ    dDdededed eed deeded efd d!Z  dEd"edeed eed d dfd#d$Z dAdeded"edeed df d%d&Z  dFdededeeded eeeff d'd(Zdeded"ed efd)d*Z dAded eed d efd+d,Z   dGdeded"ed eed deeded efd-d.Z   dBd/ededeed eed d df d0d1Z dAdeded/edeed df d2d3Z   dCdeded/ededeed4ed eeeffd5d6Zdeded/ed efd7d8Z dAded eed d efd9d:Z!    dDdeded/eded eed deeded efd;d<Z"      dHdeded=ed>ded"eed/eed eed deeded efd?d@Z#dS)I)OptionalTupleN)Tensor)Literal)_check_same_shape) _bincount)rank_zero_warnconfmat normalize)truepredallnonereturncCsd}||vr td||durc|dkrc|s|n|}|dkr-||jddd}n|d kr;||jd dd}n|d krJ||jd dgdd}|t|}|rcd |t|<t|d |S)aReduce an un-normalized confusion matrix Args: confmat: un-normalized confusion matrix normalize: normalization method. - `"true"` will divide by the sum of the column dimension. - `"pred"` will divide by the sum of the row dimension. - `"all"` will divide by the sum of the full matrix - `"none"` or `None` will apply no reduction Returns: Normalized confusion matrix r r r rNz4Argument `normalize` needs to one of the following: Nrr T)axiskeepdimr r rzD NaN values found in confusion matrix have been replaced with zeros.) ValueErroris_floating_pointfloatsumtorchisnannelementr)r r allowed_normalize nan_elementsrk/home/ubuntu/.local/lib/python3.10/site-packages/torchmetrics/functional/classification/confusion_matrix.py_confusion_matrix_reduces r ? threshold ignore_indexcCsvt|trd|krdksntd|d|dur(t|ts(td|d}||vr9td|d |ddS) zValidate non tensor input. - ``threshold`` has to be a float in the [0,1] range - ``ignore_index`` has to be None or int - ``normalize`` has to be "true" | "pred" | "all" | "none" | None rzHExpected argument `threshold` to be a float in the [0,1] range, but got .NLExpected argument `ignore_index` to either be `None` or an integer, but got r+Expected argument `normalize` to be one of , but got ) isinstancerrint)r"r#r rrrr'_binary_confusion_matrix_arg_validation;s r+predstargetcCst||t|}|durt|dk|dk@}nt|dk|dk@||k@}|rAtd|d|dur:ddggn|gd|s]t|}t|dk|dk@r_td|ddSdS) zValidate tensor input. - tensors have to be of same shape - all values in target tensor that are not ignored have to be in {0, 1} - if pred tensor is not floating point, then all values also have to be in {0, 1} Nrr$+Detected the following values in `target`: ( but expected only the following values r%*Detected the following values in `preds`: L but expected only the following values [0,1] since preds is a label tensor.)rruniqueany RuntimeErrorr)r,r-r# unique_valuescheckrrr*_binary_confusion_matrix_tensor_validationOs&   r7Tconvert_to_labelscCsj|}|}|dur||k}||}||}|r1td|k|dks+|}|r1||k}||fS)zConvert all input to label format. - Remove all datapoints that should be ignored - If preds tensor is floating point, applies sigmoid if pred tensor not in [0,1] range - If preds tensor is floating point, thresholds afterwards Nrr$)flattenrrr sigmoid)r,r-r"r#r8idxrrr_binary_confusion_matrix_formatqs r<cCs,|d|tj}t|dd}|ddS)6Computes the bins to update the confusion matrix with. minlengthtorlongrreshape)r,r-unique_mappingbinsrrr_binary_confusion_matrix_updates  rHcC t||SzrReduces the confusion matrix to it's final form. Normalization technique can be chosen by ``normalize``. r r r rrr _binary_confusion_matrix_compute rM validate_argscCsB|rt|||t|||t||||\}}t||}t||S)aComputes the `confusion matrix`_ for binary tasks. Accepts the following input tensors: - ``preds`` (int or float tensor): ``(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`` (int tensor): ``(N, ...)`` Additional dimension ``...`` will be flattened into the batch dimension. Args: preds: Tensor with predictions target: Tensor with true labels threshold: Threshold for transforming probability to binary (0,1) predictions 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 ignore_index: Specifies a target value that is ignored and does not contribute to the metric calculation validate_args: bool indicating if input arguments and tensors should be validated for correctness. Set to ``False`` for faster computations. Returns: A ``[2, 2]`` tensor Example (preds is int tensor): >>> from torchmetrics.functional.classification import binary_confusion_matrix >>> target = torch.tensor([1, 1, 0, 0]) >>> preds = torch.tensor([0, 1, 0, 0]) >>> binary_confusion_matrix(preds, target) tensor([[2, 0], [1, 1]]) Example (preds is float tensor): >>> from torchmetrics.functional.classification import binary_confusion_matrix >>> target = torch.tensor([1, 1, 0, 0]) >>> preds = torch.tensor([0.35, 0.85, 0.48, 0.01]) >>> binary_confusion_matrix(preds, target) tensor([[2, 0], [1, 1]]) )r+r7r<rHrM)r,r-r"r r#rOr rrrbinary_confusion_matrixs 5    rP num_classescCsft|tr |dkrtd||dur t|ts td|d}||vr1td|d|ddS) zValidate non tensor input. - ``num_classes`` has to be a int larger than 1 - ``ignore_index`` has to be None or int - ``normalize`` has to be "true" | "pred" | "all" | "none" | None r>zHExpected argument `num_classes` to be an integer larger than 1, but got Nr&rr'r(r%)r)r*r)rQr#r rrrr+_multiclass_confusion_matrix_arg_validations rRcCs,|j|jdkr.|std|jd|krtd|jdd|jddkr-tdn|j|jkrI|j|jkrHtdd|jd |jd ntd tt|}|dur]||k}n||dk}|rxtd |durm|n|dd |d|stt|}||krtd|d |ddSdS)aValidate tensor input. - if target has one more dimension than preds, then all dimensions except for preds.shape[1] should match exactly. preds.shape[1] should have size equal to number of classes - if preds and target have same number of dims, then all dimensions should match - all values in target tensor that are not ignored have to be {0, ..., num_classes - 1} - if pred tensor is not floating point, then all values also have to be in {0, ..., num_classes - 1} r$zSIf `preds` have one dimension more than `target`, `preds` should be a float tensor.zhIf `preds` have one dimension more than `target`, `preds.shape[1]` should be equal to number of classes.r>NzIf `preds` have one dimension more than `target`, the shape of `preds` should be (N, C, ...), and the shape of `target` should be (N, ...).z4The `preds` and `target` should have the same shape,z got `preds` with shape=z and `target` with shape=r%zEither `preds` and `target` both should have the (same) shape (N, ...), or `target` should be (N, ...) and `preds` should be (N, C, ...).zJDetected more unique values in `target` than `num_classes`. Expected only z but found z in `target`.zIDetected more unique values in `preds` than `num_classes`. Expected only z in `preds`.)ndimrrshapelenrr2r4)r,r-rQr#num_unique_valuesr6rrr._multiclass_confusion_matrix_tensor_validations\     rWcCsz|j|jdkr|r|jdd}|r|}nt|ddd|jd}|}|dur9||k}||}||}||fS)zConvert all input to label format. - Applies argmax if preds have one more dimension than target - Remove all datapoints that should be ignored r$)dimrN)rSargmaxr9rmovedimrErT)r,r-r#r8r;rrr#_multiclass_confusion_matrix_format*s  r[cCs8|tj||tj}t||dd}|||S)z5Compute the bins to update the confusion matrix with.r>r@rB)r,r-rQrFrGrrr#_multiclass_confusion_matrix_updateGs r\cCrIrJrKrLrrr$_multiclass_confusion_matrix_computeNrNr]cCsD|rt|||t||||t|||\}}t|||}t||S)aComputes the `confusion matrix`_ for multiclass tasks. Accepts the following input tensors: - ``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. Args: preds: Tensor with predictions target: Tensor with true labels num_classes: Integer specifing the number of classes 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 ignore_index: Specifies a target value that is ignored and does not contribute to the metric calculation validate_args: bool indicating if input arguments and tensors should be validated for correctness. Set to ``False`` for faster computations. Returns: A ``[num_classes, num_classes]`` tensor Example (pred is integer tensor): >>> from torchmetrics.functional.classification import multiclass_confusion_matrix >>> target = torch.tensor([2, 1, 0, 0]) >>> preds = torch.tensor([2, 1, 0, 1]) >>> multiclass_confusion_matrix(preds, target, num_classes=3) tensor([[1, 1, 0], [0, 1, 0], [0, 0, 1]]) Example (pred is float tensor): >>> from torchmetrics.functional.classification import multiclass_confusion_matrix >>> 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], ... ]) >>> multiclass_confusion_matrix(preds, target, num_classes=3) tensor([[1, 1, 0], [0, 1, 0], [0, 0, 1]]) )rRrWr[r\r])r,r-rQr r#rOr rrrmulticlass_confusion_matrixXs <   r^ num_labelscCst|tr |dkrtd|t|tr d|krdks(ntd|d|dur8t|ts8td|d }||vrItd |d |ddS) aValidate non tensor input. - ``num_labels`` should be an int larger than 1 - ``threshold`` has to be a float in the [0,1] range - ``ignore_index`` has to be None or int - ``normalize`` has to be "true" | "pred" | "all" | "none" | None r>zGExpected argument `num_labels` to be an integer larger than 1, but got rr$z5Expected argument `threshold` to be a float, but got r%Nr&rr'r()r)r*rr)r_r"r#r rrrr+_multilabel_confusion_matrix_arg_validations  r`cCst|||jd|krtd|jdd|t|}|dur.t|dk|dk@}nt|dk|dk@||k@}|rUtd|d|durNddggn|gd|sqt|}t|dk|dk@rstd |d dSdS) a9Validate tensor input. - tensors have to be of same shape - the second dimension of both tensors need to be equal to the number of labels - all values in target tensor that are not ignored have to be in {0, 1} - if pred tensor is not floating point, then all values also have to be in {0, 1} r$zaExpected both `target.shape[1]` and `preds.shape[1]` to be equal to the number of labels but got z and expected Nrr.r/r%r0r1)rrTrrr2r3r4r)r,r-r_r#r5r6rrr._multilabel_confusion_matrix_tensor_validations6    rashould_thresholdcCs|rtd|k|dks|}|r||k}t|ddd|}t|ddd|}|durK|}|}||k}d|||<d|||<||fS)aConvert all input to label format. - If preds tensor is floating point, applies sigmoid if pred tensor not in [0,1] range - If preds tensor is floating point, thresholds afterwards - Mask all elements that should be ignored with negative numbers for later filtration rr$rN)rrr r:rZrEclone)r,r-r_r"r#rbr;rrr#_multilabel_confusion_matrix_formats  recCsNd||dtj||jd}||dk}t|d|d}||ddS)r=r>r?)devicerr@)rarangerfr9rrE)r,r-r_rFrGrrr#_multilabel_confusion_matrix_updates$ rhcCrIrJrKrLrrr$_multilabel_confusion_matrix_computerNricCsJ|rt||||t||||t|||||\}}t|||}t||S)aComputes the `confusion matrix`_ for multilabel tasks. Accepts the following input tensors: - ``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. Args: preds: Tensor with predictions target: Tensor with true labels num_labels: Integer specifing the number of labels threshold: Threshold for transforming probability to binary (0,1) predictions 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 ignore_index: Specifies a target value that is ignored and does not contribute to the metric calculation validate_args: bool indicating if input arguments and tensors should be validated for correctness. Set to ``False`` for faster computations. Returns: A ``[num_labels, 2, 2]`` tensor Example (preds is int tensor): >>> from torchmetrics.functional.classification import multilabel_confusion_matrix >>> target = torch.tensor([[0, 1, 0], [1, 0, 1]]) >>> preds = torch.tensor([[0, 0, 1], [1, 0, 1]]) >>> multilabel_confusion_matrix(preds, target, num_labels=3) tensor([[[1, 0], [0, 1]], [[1, 0], [1, 0]], [[0, 1], [0, 1]]]) Example (preds is float tensor): >>> from torchmetrics.functional.classification import multilabel_confusion_matrix >>> target = torch.tensor([[0, 1, 0], [1, 0, 1]]) >>> preds = torch.tensor([[0.11, 0.22, 0.84], [0.73, 0.33, 0.92]]) >>> multilabel_confusion_matrix(preds, target, num_labels=3) tensor([[[1, 0], [0, 1]], [[1, 0], [1, 0]], [[0, 1], [0, 1]]]) )r`rarerhri)r,r-r_r"r r#rOr rrrmultilabel_confusion_matrixs 9  rjtask)binary multiclass multilabelc Csz|dkr t||||||S|dkr!t|tsJt||||||S|dkr6t|ts,Jt|||||||Std|)aRComputes 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 :func:`binary_confusion_matrix`, :func:`multiclass_confusion_matrix` and :func:`multilabel_confusion_matrix` for the specific details of each argument influence and examples. Legacy Example: >>> from torchmetrics import ConfusionMatrix >>> target = torch.tensor([1, 1, 0, 0]) >>> preds = torch.tensor([0, 1, 0, 0]) >>> confmat = ConfusionMatrix(task="binary") >>> 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]]]) rlrmrnz[Expected argument `task` to either be `'binary'`, `'multiclass'` or `'multilabel'` but got )rPr)r*r^rjr) r,r-rkr"rQr_r r#rOrrrconfusion_matrixRs+ro)N)r!NN)r!NT)r!NNT)NN)NT)NNT)r!NNNNT)$typingrrrrtyping_extensionsrtorchmetrics.utilities.checksrtorchmetrics.utilities.datartorchmetrics.utilities.printsrr rr*r+r7boolr<rHrMrPrRrWr[r\r]r^r`rarerhrirjrorrrrs        #   %       ?   <      F   -  "     E