a  dP0 @sddlmZmZddlZddlmZmZddlmZddlm Z m Z m Z m Z ddl mZddlmZeeedd d Zd+eeedd d d Zd,eeeeddddZeeeeeefdddZd-eeeeeeedddZd.eeedeeddddZd/eeeeeddddZd0eeeedeeefd d!d"Zd1eeeeedeeeed#d$d%Zd2eeed'eeeedeeeed( d)d*ZdS)3)OptionalTupleN)Tensortensor)Literal)_binary_confusion_matrix_format*_binary_confusion_matrix_tensor_validation#_multiclass_confusion_matrix_format._multiclass_confusion_matrix_tensor_validation) to_onehot)ClassificationTaskNoMultilabel)measuretotalreturncCs||S)N)r rrru/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/torchmetrics/functional/classification/hinge.py_hinge_loss_computesr)squared ignore_indexrcCs<t|tstd||dur8t|ts8td|dS)Nz2Expected argument `squared` to be an bool but got zLExpected argument `ignore_index` to either be `None` or an integer, but got ) isinstancebool ValueErrorint)rrrrr!_binary_hinge_loss_arg_validation"s r)predstargetrrcCs(t||||s$td|jdSNzdExpected argument `preds` to be floating tensor with probabilities/logits but got tensor with dtype )ris_floating_pointrdtype)rrrrrr$_binary_hinge_loss_tensor_validation)s r)rrrrcCsv|}t|}||||<|| ||<d|}t|d}|rR|d}t|jd|jd}|jdd|fS)NrdeviceZdim) rtorch zeros_likeclamppowrshaper#sum)rrrmarginmeasuresrrrr_binary_hinge_loss_update2s    r-F)rrrr validate_argsrcCsJ|rt||t|||t||d|dd\}}t|||\}}t||S)aCompute the mean `Hinge loss`_ typically used for Support Vector Machines (SVMs) for binary tasks. .. math:: \text{Hinge loss} = \max(0, 1 - y \times \hat{y}) Where :math:`y \in {-1, 1}` is the target, and :math:`\hat{y} \in \mathbb{R}` is the prediction. Accepts the following input tensors: - ``preds`` (float tensor): ``(N, ...)``. Preds should be a tensor containing probabilities or logits for each observation. If preds has values outside [0,1] range we consider the input to be logits and will auto apply sigmoid per element. - ``target`` (int tensor): ``(N, ...)``. Target should be a tensor containing ground truth labels, and therefore only contain {0,1} values (except if `ignore_index` is specified). The value 1 always encodes the positive class. Additional dimension ``...`` will be flattened into the batch dimension. Args: preds: Tensor with predictions target: Tensor with true labels squared: If True, this will compute the squared hinge loss. Otherwise, computes the regular hinge loss. 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. Example: >>> from torch import tensor >>> from torchmetrics.functional.classification import binary_hinge_loss >>> preds = tensor([0.25, 0.25, 0.55, 0.75, 0.75]) >>> target = tensor([0, 0, 1, 1, 1]) >>> binary_hinge_loss(preds, target) tensor(0.6900) >>> binary_hinge_loss(preds, target, squared=True) tensor(0.6905) gF) thresholdrconvert_to_labels)rrrr-r)rrrrr.r,rrrrbinary_hinge_lossFs-   r1crammer-singerr2z one-vs-all) num_classesrmulticlass_moderrcCsPt||t|tr|dkr*td|d}||vrLtd|d|ddS)Nr!zHExpected argument `num_classes` to be an integer larger than 1, but got r3z1Expected argument `multiclass_mode` to be one of z , but got .)rrrr)r4rr5rZ allowed_mmrrr%_multiclass_hinge_loss_arg_validation}s  r7)rrr4rrcCs*t|||||s&td|jdSr)r rrr)rrr4rrrr(_multiclass_hinge_loss_tensor_validationsr8)rrrr5rcCst|dk|dks |d}t|td|jd}|dkrv||}|tj|||jddddd8}n0|}t|}||||<|| ||<d|}t |d}|r| d}t |jd|j d}|j dd|fS)Nrr r!r2r$r")r%allZsoftmaxr maxr)rviewr&r'r(rr#r*)rrrr5r+r,rrrr_multiclass_hinge_loss_updates  ,    r=)rrr4rr5rr.rc CsP|r t||||t||||t|||dd\}}t||||\}}t||S)a Compute the mean `Hinge loss`_ typically used for Support Vector Machines (SVMs) for multiclass tasks. The metric can be computed in two ways. Either, the definition by Crammer and Singer is used: .. math:: \text{Hinge loss} = \max\left(0, 1 - \hat{y}_y + \max_{i \ne y} (\hat{y}_i)\right) Where :math:`y \in {0, ..., \mathrm{C}}` is the target class (where :math:`\mathrm{C}` is the number of classes), and :math:`\hat{y} \in \mathbb{R}^\mathrm{C}` is the predicted output per class. Alternatively, the metric can also be computed in one-vs-all approach, where each class is valued against all other classes in a binary fashion. Accepts the following input tensors: - ``preds`` (float tensor): ``(N, C, ...)``. Preds should be a tensor containing probabilities or logits for each observation. If preds has values outside [0,1] range we consider the input to be logits and will auto apply softmax per sample. - ``target`` (int tensor): ``(N, ...)``. Target should be a tensor containing ground truth labels, and therefore only contain values in the [0, n_classes-1] range (except if `ignore_index` is specified). 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 squared: If True, this will compute the squared hinge loss. Otherwise, computes the regular hinge loss. multiclass_mode: Determines how to compute the metric 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. Example: >>> from torch import tensor >>> from torchmetrics.functional.classification import multiclass_hinge_loss >>> preds = tensor([[0.25, 0.20, 0.55], ... [0.55, 0.05, 0.40], ... [0.10, 0.30, 0.60], ... [0.90, 0.05, 0.05]]) >>> target = tensor([0, 1, 2, 0]) >>> multiclass_hinge_loss(preds, target, num_classes=3) tensor(0.9125) >>> multiclass_hinge_loss(preds, target, num_classes=3, squared=True) tensor(1.1131) >>> multiclass_hinge_loss(preds, target, num_classes=3, multiclass_mode='one-vs-all') tensor([0.8750, 1.1250, 1.1000]) F)r0)r7r8r r=r) rrr4rr5rr.r,rrrrmulticlass_hinge_losss ;r>T)binaryZ multiclass) rrtaskr4rr5rr.rcCsrt|}|tjkr$t|||||S|tjkr`t|tsLtdt|dt |||||||Std|dS)aCompute the mean `Hinge loss`_ typically used for Support Vector Machines (SVMs). 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'`` or ``'multiclass'``. See the documentation of :func:`~torchmetrics.functional.classification.binary_hinge_loss` and :func:`~torchmetrics.functional.classification.multiclass_hinge_loss` for the specific details of each argument influence and examples. Legacy Example: >>> from torch import tensor >>> target = tensor([0, 1, 1]) >>> preds = tensor([0.5, 0.7, 0.1]) >>> hinge_loss(preds, target, task="binary") tensor(0.9000) >>> target = tensor([0, 1, 2]) >>> preds = tensor([[-1.0, 0.9, 0.2], [0.5, -1.1, 0.8], [2.2, -0.5, 0.3]]) >>> hinge_loss(preds, target, task="multiclass", num_classes=3) tensor(1.5551) >>> target = tensor([0, 1, 2]) >>> preds = tensor([[-1.0, 0.9, 0.2], [0.5, -1.1, 0.8], [2.2, -0.5, 0.3]]) >>> hinge_loss(preds, target, task="multiclass", num_classes=3, multiclass_mode="one-vs-all") tensor([1.3743, 1.1945, 1.2359]) z+`num_classes` is expected to be `int` but `z was passed.`zNot handled value: N) r Zfrom_strBINARYr1Z MULTICLASSrrrtyper>)rrr@r4rr5rr.rrr hinge_losss$    rC)N)N)FNF)Fr2N)N)r2)Fr2NF)NFr2NT)typingrrr%rrZtyping_extensionsrZ7torchmetrics.functional.classification.confusion_matrixrrr r Ztorchmetrics.utilities.datar Ztorchmetrics.utilities.enumsr rrrrrr-r1r7r8r=r>rCrrrrs      9    ! G