a  dm @sddlmZmZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl mZdFeeed ed d d ZdGeeeeed ddddZdHeeeeddddZdIeeeeeeeeefdddZeeedddZdJeeed ed ddZdKeeeeed eeeedddZdLeeeeed dd d!d"ZdMeeeeedd#d$d%ZdNeeeeeeeefd&d'd(Zeeeed)d*d+ZdOeeed ed d,d-ZdPeeeeed eeeed.d/d0ZdQeeeeeed dd1d2d3ZdReeeeedd4d5d6Z dSeeeeeeeeeefd7d8d9Z!eeeed:d;d<Z"dTeeed ed d=d>Z#dUeeeeeed eeeed?d@dAZ$dVeeedBeeeeeeed eeeedC dDdEZ%dS)W)OptionalTupleN)Tensor)Literal)_check_same_shape) _bincount)ClassificationTask)rank_zero_warn)truepredallnone)confmat normalizereturncCsd}||vrtd||dur|dkr|s:|n|}|dkrZ||jddd}n:|d krv||jd dd}n|d kr||jd dgdd}|t|}|rd |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 r Nz4Argument `normalize` needs to one of the following: Nr r T)dimZkeepdimr r rzD NaN values found in confusion matrix have been replaced with zeros.) ValueErroris_floating_pointfloatsumtorchisnanZnelementr )rrallowed_normalizeZ nan_elementsr/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/torchmetrics/functional/classification/confusion_matrix.py_confusion_matrix_reduces r?) threshold ignore_indexrrcCsvt|tr d|krdks0ntd|d|durPt|tsPtd|d}||vrrtd|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!rrrrr'_binary_confusion_matrix_arg_validation>s r))predstargetr!rcCst||t|}|dur4t|dk|dk@}nt|dk|dk@||k@}|r~td|d|durpddgn|gd|st|}t|dk|dk@rtd|ddS) 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_validationSs"    r5T)r*r+r r!convert_to_labelsrcCsj|}|}|dur0||k}||}||}|rbt|dk|dksV|}|rb||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!r6idxrrr_binary_confusion_matrix_formatvsr:)r*r+rcCs,|d|tj}t|dd}|ddS)5Compute the bins to update the confusion matrix with.Z minlengthtorlongrreshape)r*r+unique_mappingbinsrrr_binary_confusion_matrix_updates rEcCs t||SzsReduces the confusion matrix to it's final form. Normalization technique can be chosen by ``normalize``. rrrrrr _binary_confusion_matrix_computesrI)r*r+r rr! validate_argsrcCsB|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. 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 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)r5r:rErI)r*r+r rr!rJrrrrbinary_confusion_matrixs 7   rK) num_classesr!rrcCsft|tr|dkr td||dur@t|ts@td|d}||vrbtd|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)rLr!rrrrr+_multiclass_confusion_matrix_arg_validations rM)r*r+rLr!rcCs*|j|jdkr\|s td|jd|kr6td|jdd|jddkrtdn>|j|jkr|j|jkrtdd|jd |jd ntd tt|}|dur||kn ||dk}|rtd |dur|n|dd |d|s&tt|}||kr&td|d |ddS)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`.)ndimrrshapelenrr0r2)r*r+rLr!Znum_unique_valuesr4rrr._multiclass_confusion_matrix_tensor_validationsP     rQ)r*r+r!r6rcCsx|j|jdkr |r |jdd}|r,|nt|ddd|jd}|}|durp||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")rrN)rNZargmaxr7rmovedimrBrO)r*r+r!r6r9rrr#_multiclass_confusion_matrix_format2s  (rS)r*r+rLrcCs8|tj||tj}t||dd}|||S)r;r<r>r?)r*r+rLrCrDrrr#_multiclass_confusion_matrix_updateMsrTcCs t||SrFrGrHrrr$_multiclass_confusion_matrix_computeTsrU)r*r+rLrr!rJrcCsD|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 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 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]]) )rMrQrSrTrU)r*r+rLrr!rJrrrrmulticlass_confusion_matrix_s <  rV) num_labelsr r!rrcCst|tr|dkr td|t|tr@d|kr>dksPntd|d|durpt|tsptd|d }||vrtd |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)rWr r!rrrrr+_multilabel_confusion_matrix_arg_validations rX)r*r+rWr!rcCst|||jd|kr2td|jdd|t|}|dur\t|dk|dk@}nt|dk|dk@||k@}|rtd|d|durddgn|gd|st|}t|dk|dk@rtd |d dS) 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 Nrr,r-r#r.r/)rrOrrr0r1r2r)r*r+rWr!r3r4rrr._multilabel_confusion_matrix_tensor_validations2    rY)r*r+rWr r!should_thresholdrcCs|r2t|dk|dks&|}|r2||k}t|ddd|}t|ddd|}|dur|}|}||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 r8rRrBclone)r*r+rWr r!rZr9rrr#_multilabel_confusion_matrix_formats  r])r*r+rWrcCsNd||dtj||jd}||dk}t|d|d}||ddS)r;r<r=)devicerr>)rZaranger^r7rrB)r*r+rWrCrDrrr#_multilabel_confusion_matrix_update s$ r_cCs t||SrFrGrHrrr$_multilabel_confusion_matrix_computesr`)r*r+rWr rr!rJrcCsJ|r t||||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. 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 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]]]) )rXrYr]r_r`)r*r+rWr rr!rJrrrrmultilabel_confusion_matrixs ; ra)binaryZ multiclassZ multilabel) r*r+taskr rLrWrr!rJrc Cst|}|tjkr&t||||||S|tjkr`t|tsNtdt|dt ||||||S|tj krt|tstdt|dt |||||||Std|ddS)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.N) rZfrom_strBINARYrKZ MULTICLASSr'r(rtyperVZ MULTILABELra) r*r+rcr rLrWrr!rJrrrconfusion_matrix_s/      rf)N)rNN)N)rNT)N)rNNT)NN)N)NT)N)NNT)rNN)N)rNT)N)rNNT)rNNNNT)&typingrrrrZtyping_extensionsrZtorchmetrics.utilities.checksrZtorchmetrics.utilities.datarZtorchmetrics.utilities.enumsrZtorchmetrics.utilities.printsr rrr(r)r5boolr:rErIrKrMrQrSrTrUrVrXrYr]r_r`rarfrrrrsB        %    &     A    :     F    . #     G