o .wiSC@s&ddlmZddlZddlmZddlmZddlmZmZm Z m Z m Z m Z m Z mZmZmZmZmZddlmZddlmZ  d)d ed eed d eed edef ddZ    d*dededed eeded edefddZ  d+ded eed eedddfddZ    d,dededed eedd eeded edefddZ   d-d eded eed eedddf d!d"Z     d.deded eded eedd eeded edefd#d$Z       d/deded%ed&dedeed eed eedd eeded edefd'd(Z dS)0)OptionalN)Tensor)Literal) '_binary_confusion_matrix_arg_validation_binary_confusion_matrix_format*_binary_confusion_matrix_tensor_validation_binary_confusion_matrix_update+_multiclass_confusion_matrix_arg_validation#_multiclass_confusion_matrix_format._multiclass_confusion_matrix_tensor_validation#_multiclass_confusion_matrix_update+_multilabel_confusion_matrix_arg_validation#_multilabel_confusion_matrix_format._multilabel_confusion_matrix_tensor_validation#_multilabel_confusion_matrix_update) _safe_divide)ClassificationTaskconfmataverage)micromacroweightednonebinary ignore_index zero_divisionreturnc Csgd}||vrtd|d|d|}|dkr.t|d|d|d|d|d S|d uo@d |ko>|jd kn}|jd k}|rm|d d d d f}|d d d d f|d d d d f|d d d d f}nt|}|d |d |}|dkr|}||r||nd}t|||d } |d us|dks|dkr| S|dkr|jd kr|d d d d f|d d d d fn|d } nt| } |rd| |<|sd| |d |d d k<| | | S)a'Perform reduction of an un-normalized confusion matrix into jaccard score. Args: confmat: tensor with un-normalized confusionmatrix average: reduction method - ``'binary'``: binary reduction, expects a 2x2 matrix - ``'macro'``: Calculate the metric for each class separately, and average the metrics across classes (with equal weights for each class). - ``'micro'``: Calculate the metric globally, across all samples and classes. - ``'weighted'``: Calculate the metric for each class separately, and average the metrics across classes, weighting each class by its support (``tp + fn``). - ``'none'`` or ``None``: Calculate the metric for each class separately, and return the metric for every class. ignore_index: Specifies a target value that is ignored and does not contribute to the metric calculation zero_division: Value to replace when there is a division by zero. Should be `0` or `1`. )rrrrrNzThe `average` has to be one of z, got .r)r)rr)rr)rNrrrrrr) ValueErrorfloatrshapendimtorchdiagsum ones_like) rrrrallowed_averageignore_index_cond multilabelnumdenomjaccardweightsr0k/home/ubuntu/sommelier/.venv/lib/python3.10/site-packages/torchmetrics/functional/classification/jaccard.py_jaccard_index_reduce&s6&& 8 : r2?Tpredstarget threshold validate_argscCsD|r t||t|||t||||\}}t||}t|d|dS)aCalculate the Jaccard index for binary tasks. The `Jaccard index`_ (also known as the intersection over union or jaccard similarity coefficient) is an statistic that can be used to determine the similarity and diversity of a sample set. It is defined as the size of the intersection divided by the union of the sample sets: .. math:: J(A,B) = \frac{|A\cap B|}{|A\cup B|} 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 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. zero_division: Value to replace when there is a division by zero. Should be `0` or `1`. Example (preds is int tensor): >>> from torch import tensor >>> from torchmetrics.functional.classification import binary_jaccard_index >>> target = tensor([1, 1, 0, 0]) >>> preds = tensor([0, 1, 0, 0]) >>> binary_jaccard_index(preds, target) tensor(0.5000) Example (preds is float tensor): >>> from torchmetrics.functional.classification import binary_jaccard_index >>> target = tensor([1, 1, 0, 0]) >>> preds = tensor([0.35, 0.85, 0.48, 0.01]) >>> binary_jaccard_index(preds, target) tensor(0.5000) r)rr)rrrrr2)r4r5r6rr7rrr0r0r1binary_jaccard_indexds 4   r8 num_classes)rrrrcCs0t||d}||vrtd|d|ddSN)rrrrNz)Expected argument `average` to be one of z , but got r)r r!)r9rrr)r0r0r1(_multiclass_jaccard_index_arg_validations r;rcCsJ|rt|||t||||t|||\}}t|||}t||||dS)a" Calculate the Jaccard index for multiclass tasks. The `Jaccard index`_ (also known as the intersection over union or jaccard similarity coefficient) is an statistic that can be used to determine the similarity and diversity of a sample set. It is defined as the size of the intersection divided by the union of the sample sets: .. math:: J(A,B) = \frac{|A\cap B|}{|A\cup B|} 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 average: Defines the reduction that is applied over labels. Should be one of the following: - ``micro``: Sum statistics over all labels - ``macro``: Calculate statistics for each label and average them - ``weighted``: calculates statistics for each label and computes weighted average using their support - ``"none"`` or ``None``: calculates statistic for each label and applies no reduction 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. zero_division: Value to replace when there is a division by zero. Should be `0` or `1`. Example (pred is integer tensor): >>> from torch import tensor >>> from torchmetrics.functional.classification import multiclass_jaccard_index >>> target = tensor([2, 1, 0, 0]) >>> preds = tensor([2, 1, 0, 1]) >>> multiclass_jaccard_index(preds, target, num_classes=3) tensor(0.6667) Example (pred is float tensor): >>> from torchmetrics.functional.classification import multiclass_jaccard_index >>> 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_jaccard_index(preds, target, num_classes=3) tensor(0.6667) rrr)r;r r r r2)r4r5r9rrr7rrr0r0r1multiclass_jaccard_indexs @  r= num_labelscCs2t|||d}||vrtd|d|ddSr:)r r!)r>r6rrr)r0r0r1(_multilabel_jaccard_index_arg_validations r?c CsN|rt|||t||||t|||||\}}t|||}t||||dS)aZ Calculate the Jaccard index for multilabel tasks. The `Jaccard index`_ (also known as the intersection over union or jaccard similarity coefficient) is an statistic that can be used to determine the similarity and diversity of a sample set. It is defined as the size of the intersection divided by the union of the sample sets: .. math:: J(A,B) = \frac{|A\cap B|}{|A\cup B|} 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 average: Defines the reduction that is applied over labels. Should be one of the following: - ``micro``: Sum statistics over all labels - ``macro``: Calculate statistics for each label and average them - ``weighted``: calculates statistics for each label and computes weighted average using their support - ``"none"`` or ``None``: calculates statistic for each label and applies no reduction 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. zero_division: Value to replace when there is a division by zero. Should be `0` or `1`. Example (preds is int tensor): >>> from torch import tensor >>> from torchmetrics.functional.classification import multilabel_jaccard_index >>> target = tensor([[0, 1, 0], [1, 0, 1]]) >>> preds = tensor([[0, 0, 1], [1, 0, 1]]) >>> multilabel_jaccard_index(preds, target, num_labels=3) tensor(0.5000) Example (preds is float tensor): >>> from torchmetrics.functional.classification import multilabel_jaccard_index >>> target = tensor([[0, 1, 0], [1, 0, 1]]) >>> preds = tensor([[0.11, 0.22, 0.84], [0.73, 0.33, 0.92]]) >>> multilabel_jaccard_index(preds, target, num_labels=3) tensor(0.5000) r<)r?rrrr2) r4r5r>r6rrr7rrr0r0r1multilabel_jaccard_indexs ?  r@task)r multiclassr+c Cst|}|tjkrt|||||| S|tjkr1t|ts'tdt|dt ||||||| S|tj krPt|tsEtdt|dt |||||||| Std|)aCalculate the Jaccard index. The `Jaccard index`_ (also known as the intersection over union or jaccard similarity coefficient) is an statistic that can be used to determine the similarity and diversity of a sample set. It is defined as the size of the intersection divided by the union of the sample sets: .. math:: J(A,B) = \frac{|A\cap B|}{|A\cup B|} 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_jaccard_index`, :func:`~torchmetrics.functional.classification.multiclass_jaccard_index` and :func:`~torchmetrics.functional.classification.multilabel_jaccard_index` for the specific details of each argument influence and examples. Legacy Example: >>> from torch import randint, tensor >>> target = randint(0, 2, (10, 25, 25)) >>> pred = tensor(target) >>> pred[2:5, 7:13, 9:15] = 1 - pred[2:5, 7:13, 9:15] >>> jaccard_index(pred, target, task="multiclass", num_classes=2) tensor(0.9660) z+`num_classes` is expected to be `int` but `z was passed.`z*`num_labels` is expected to be `int` but `zNot handled value: ) rfrom_strBINARYr8 MULTICLASS isinstanceintr!typer= MULTILABELr@) r4r5rAr6r9r>rrr7rr0r0r1 jaccard_indexFs $     rJ)Nr)r3NTr)NN)rNTr)r3Nr)r3rNTr)r3NNrNTr)!typingrr%rtyping_extensionsr7torchmetrics.functional.classification.confusion_matrixrrrrr r r r r rrrtorchmetrics.utilities.computertorchmetrics.utilities.enumsrrGr"r2boolr8r;r=r?r@rJr0r0r0r1s   8    A >    J    K