o .wil@sddlmZddlZddlmZddlmZddlmZddlm Z ddl m Z ddl m Z dd lmZ dCd ed eed d efddZ   dDdedeed eed d dfddZ dCdededeed dfddZ   dEdedededeeded eeeff ddZdeded efddZ dCd ed eed d efdd Z    dFdededed eed deed!ed efd"d#Z  dGd$edeed eed d dfd%d&Z dCdeded$edeed df d'd(Z  dHdededeeded eeeff d)d*Zdeded$ed efd+d,Z dCd ed eed d efd-d.Z   dIdeded$ed eed deed!ed efd/d0Z   dDd1ededeed eed d df d2d3Z! dCdeded1edeed df d4d5Z"   dEdeded1ededeed6ed eeeffd7d8Z#deded1ed efd9d:Z$ dCd ed eed d efd;d<Z%    dFdeded1eded eed deed!ed efd=d>Z&      dJdeded?ed@ded$eed1eed eed deed!ed efdAdBZ'dS)K)OptionalN)Tensor)Literal)_check_same_shape)normalize_logits_if_needed) _bincount)ClassificationTask)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 rrNz4Argument `normalize` needs to one of the following: Nrr T)dimkeepdimr rrzD NaN values found in confusion matrix have been replaced with zeros.) ValueErroris_floating_pointfloatsumtorchisnannelementr )r r allowed_normalize nan_elementsrt/home/ubuntu/sommelier/.venv/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||tj|dd}|durt|dk|dk@}nt|dk|dk@||k@}|rAtd|d|dur:ddgn|gd|s_tj|dd}t|dk|dk@ratd|d dSdS) 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} Nrrr%+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_validationTs&  r9Tconvert_to_labelscCsV|}|}|dur||k}||}||}|r't|d}|r'||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 Nsigmoid)flattenrr)r-r.r#r$r:idxrrr _binary_confusion_matrix_formatws r>cCs,|d|tj}t|dd}|ddS)5Compute the bins to update the confusion matrix with. minlengthtorlongrreshape)r-r.unique_mappingbinsrrr _binary_confusion_matrix_updates  rJcC t||SzsReduces the confusion matrix to it's final form. Normalization technique can be chosen by ``normalize``. r!r r rrr _binary_confusion_matrix_compute rO validate_argscCsB|rt|||t|||t||||\}}t||}t||S)aCompute 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. Additionally, 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 torch import tensor >>> from torchmetrics.functional.classification import binary_confusion_matrix >>> target = tensor([1, 1, 0, 0]) >>> preds = 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 = tensor([1, 1, 0, 0]) >>> preds = tensor([0.35, 0.85, 0.48, 0.01]) >>> binary_confusion_matrix(preds, target) tensor([[2, 0], [1, 1]]) )r,r9r>rJrO)r-r.r#r r$rQr rrr binary_confusion_matrixs 7    rR 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)rSr$r rrrr +_multiclass_confusion_matrix_arg_validations rTc Cs|j|jdkr.|std|jd|krtd|jdd|jddkr-tdn|j|jkrI|j|jkrHtdd|jd |jd ntd |durS|n|d}|se|d ff|d ffndD]\}}ttj|dd}||krtd|d|d|dqgdS)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, ...).r.r-rr/z Detected more unique values in `z` than expected. Expected only z but found z in `target`.)ndimrrshapelenrr4r6)r-r.rSr$ check_valuetnamenum_unique_valuesrrr ._multiclass_confusion_matrix_tensor_validationsB   (r\cCsx|j|jdkr|r|jdd}|r|n t|ddd|jd}|}|dur8||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%r/rN)rUargmaxr<rmovedimrGrV)r-r.r$r:r=rrr #_multiclass_confusion_matrix_format)s (r_cCs8|tj||tj}t||dd}|||S)r?r@rBrD)r-r.rSrHrIrrr #_multiclass_confusion_matrix_updateDs r`cCrKrLrMrNrrr $_multiclass_confusion_matrix_computeKrPracCsD|rt|||t||||t|||\}}t|||}t||S)aCompute 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 specifying 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 torch import tensor >>> from torchmetrics.functional.classification import multiclass_confusion_matrix >>> target = tensor([2, 1, 0, 0]) >>> preds = 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 = 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]]) >>> multiclass_confusion_matrix(preds, target, num_classes=3) tensor([[1, 1, 0], [0, 1, 0], [0, 0, 1]]) )rTr\r_r`ra)r-r.rSr r$rQr rrr multiclass_confusion_matrixVs <   rb 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)rcr#r$r rrrr +_multilabel_confusion_matrix_arg_validations rdcCst|||jd|krtd|jdd|tj|dd}|dur0t|dk|dk@}nt|dk|dk@||k@}|rUtd|d|durNddgn|gd |sstj|dd}t|dk|dk@rutd |d dSdS) a:Validate 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 Nr/rr0r1r&r2r3)rrVrrr4r5r6r)r-r.rcr$r7r8rrr ._multilabel_confusion_matrix_tensor_validations6  reshould_thresholdcCs|rt|d}|r||k}t|ddd|}t|ddd|}|durA|}|}||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 r;r%rN)rrrr^rGclone)r-r.rcr#r$rfr=rrr #_multilabel_confusion_matrix_formats   ricCsNd||dtj||jd}||dk}t|d|d}||ddS)r?r@rA)devicerrB)rarangerjr<rrG)r-r.rcrHrIrrr #_multilabel_confusion_matrix_updates$ rlcCrKrLrMrNrrr $_multilabel_confusion_matrix_computerPrmcCsJ|rt||||t||||t|||||\}}t|||}t||S)a Compute 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. Additionally, 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 specifying 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 torch import tensor >>> from torchmetrics.functional.classification import multilabel_confusion_matrix >>> target = tensor([[0, 1, 0], [1, 0, 1]]) >>> preds = 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 = tensor([[0, 1, 0], [1, 0, 1]]) >>> preds = 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]]]) )rdrerirlrm)r-r.rcr#r r$rQr rrr multilabel_confusion_matrixs ;  rntask)binary multiclass multilabelc Cst|}|tjkrt||||||S|tjkr0t|ts'tdt|dt ||||||S|tj krNt|tsDtdt|dt |||||||Std|d)aCompute 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:`~torchmetrics.functional.classification.binary_confusion_matrix`, :func:`~torchmetrics.functional.classification.multiclass_confusion_matrix` and :func:`~torchmetrics.functional.classification.multilabel_confusion_matrix` for the specific details of each argument influence and examples. Legacy Example: >>> from torch import tensor >>> from torchmetrics.classification import ConfusionMatrix >>> target = tensor([1, 1, 0, 0]) >>> preds = tensor([0, 1, 0, 0]) >>> confmat = ConfusionMatrix(task="binary") >>> 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]]]) 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_strBINARYrR MULTICLASSr*r+rtyperb MULTILABELrn) r-r.ror#rSrcr r$rQrrr confusion_matrixUs /     rx)N)r"NN)r"NT)r"NNT)NN)NT)NNT)r"NNNNT)(typingrrrtyping_extensionsrtorchmetrics.utilities.checksrtorchmetrics.utilities.computertorchmetrics.utilities.datartorchmetrics.utilities.enumsrtorchmetrics.utilities.printsr r!rr+r,r9booltupler>rJrOrRrTr\r_r`rarbrdrerirlrmrnrxrrrr s          %   &      A   2      F   .  "     G